diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bacb4b0873..25df2b3014 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,31 +28,25 @@ permissions:
   contents: read
 
 jobs:
+  # This job does our basic build+test for supported platforms.
   test:
-    name: test
     env:
       # For some builds, we use cross to test on 32-bit and big-endian
       # systems.
       CARGO: cargo
       # When CARGO is set to CROSS, TARGET is set to `--target matrix.target`.
+      # Note that we only use cross on Linux, so setting a target on a
+      # different OS will just use normal cargo.
       TARGET:
+      # Bump this as appropriate. We pin to a version to make sure CI
+      # continues to work as cross releases in the past have broken things
+      # in subtle ways.
+      CROSS_VERSION: v0.2.5
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        build:
-        - pinned
-        - stable
-        - stable-32
-        - stable-mips
-        - beta
-        - nightly
-        - macos
-        - win-msvc
-        - win-gnu
         include:
-        - build: pinned
-          os: ubuntu-latest
-          rust: 1.60.0
         - build: stable
           os: ubuntu-latest
           rust: stable
@@ -80,98 +74,160 @@ jobs:
           os: windows-latest
           rust: stable-x86_64-gnu
     steps:
-
     - name: Checkout repository
       uses: actions/checkout@v3
-
     - name: Install Rust
       uses: dtolnay/rust-toolchain@v1
       with:
         toolchain: ${{ matrix.rust }}
-
     - name: Install and configure Cross
-      if: matrix.target != ''
+      if: matrix.os == 'ubuntu-latest' && matrix.target != ''
       run: |
+        # In the past, new releases of 'cross' have broken CI. So for now, we
+        # pin it. We also use their pre-compiled binary releases because cross
+        # has over 100 dependencies and takes a bit to compile.
+        dir="$RUNNER_TEMP/cross-download"
+        mkdir "$dir"
+        echo "$dir" >> $GITHUB_PATH
+        cd "$dir"
+        curl -LO "https://github.com/cross-rs/cross/releases/download/$CROSS_VERSION/cross-x86_64-unknown-linux-musl.tar.gz"
+        tar xf cross-x86_64-unknown-linux-musl.tar.gz
+
         # We used to install 'cross' from master, but it kept failing. So now
         # we build from a known-good version until 'cross' becomes more stable
         # or we find an alternative. Notably, between v0.2.1 and current
         # master (2022-06-14), the number of Cross's dependencies has doubled.
-        cargo install --bins --git https://github.com/rust-embedded/cross --tag v0.2.1
+        # cargo install --bins --git https://github.com/rust-embedded/cross --tag v0.2.1
         echo "CARGO=cross" >> $GITHUB_ENV
         echo "TARGET=--target ${{ matrix.target }}" >> $GITHUB_ENV
-
     - name: Show command used for Cargo
       run: |
-        echo "cargo command is: ${{ env.CARGO }}"
-        echo "target flag is: ${{ env.TARGET }}"
-
+        echo "cargo command is: $CARGO"
+        echo "target flag is: $TARGET"
     - name: Show CPU info for debugging
       if: matrix.os == 'ubuntu-latest'
       run: lscpu
-
     - name: Basic build
       run: ${{ env.CARGO }} build --verbose $TARGET
-
     - name: Build docs
       run: ${{ env.CARGO }} doc --verbose $TARGET
-
-    # Our dev dependencies evolve more rapidly than we'd like, so only run
-    # tests when we aren't pinning the Rust version.
-    #
-    # Also, our "full" test suite does quite a lot of work, so we only run it
-    # on one build. Otherwise, we just run the "default" set of tests.
     - name: Run subset of tests
-      if: matrix.build != 'pinned' && matrix.build != 'stable'
-      run: ${{ env.CARGO }} test --verbose --test default $TARGET
-
-    - name: Run full test suite
-      if: matrix.build == 'stable'
-      # 'stable' is Linux only, so we have bash.
-      run: ./test
-
-    - name: Run randomized tests against regexes from the wild
-      if: matrix.build == 'stable'
-      run: |
-        # We run the tests in release mode since it winds up being faster.
-        RUST_REGEX_RANDOM_TEST=1 ${{ env.CARGO }} test --release --verbose --test crates-regex $TARGET
-
+      run: ${{ env.CARGO }} test --verbose --test integration $TARGET
     - name: Build regex-syntax docs
-      if: matrix.build != 'pinned'
-      run: |
-        ${{ env.CARGO }} doc --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
-
+      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
     - name: Run subset of regex-syntax tests
-      if: matrix.build != 'pinned' && matrix.build != 'stable'
-      run: |
-        ${{ env.CARGO }} test --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
+    - name: Build regex-automata docs
+      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-automata/Cargo.toml $TARGET
+    - name: Run subset of regex-automata tests
+      if: matrix.build != 'win-gnu'  # Just horrifically slow.
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-automata/Cargo.toml $TARGET
+    - name: Run regex-lite tests
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-lite/Cargo.toml $TARGET
+    - name: Run regex-cli tests
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-cli/Cargo.toml $TARGET
+
+  # This job runs a stripped down version of CI to test the MSRV. The specific
+  # reason for doing this is that the regex crate's dev-dependencies tend to
+  # evolve more quickly. There isn't as tight of a control on them because,
+  # well, they're only used in tests and their MSRV doesn't matter as much.
+  #
+  # It is a bit unfortunate that our MSRV test is basically just "build it"
+  # and pass if that works. But usually MSRV is broken by compilation problems
+  # and not runtime behavior. So this is in practice good enough.
+  msrv:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: 1.60.0
+    - name: Basic build
+      run: cargo build --verbose
+    - name: Build docs
+      run: cargo doc --verbose
+
+  # This job runs many more tests for the regex crate proper. Basically,
+  # it repeats the same test suite for a bunch of different crate feature
+  # combinations. There are so many features that exhaustive testing isn't
+  # really possible, but we cover as much as is feasible.
+  #
+  # If there is a feature combo that should be tested but isn't, you'll want to
+  # add it to the appropriate 'test' script in this repo.
+  testfull-regex:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./test
 
-    - name: Run full regex-syntax test suite
-      if: matrix.build == 'stable'
-      run: |
-        # 'stable' is Linux only, so we have bash.
-        cd regex-syntax
-        ./test
+  # Same as above, but for regex-automata, which has even more crate features!
+  testfull-regex-automata:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-automata/test
 
-    - name: Run regex-capi tests
-      if: matrix.build == 'stable'
-      run: |
-        # 'stable' is Linux only, so we have bash.
-        cd regex-capi
-        ./test
+  # Same as above, but for regex-syntax.
+  testfull-regex-syntax:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-syntax/test
 
-    - if: matrix.build == 'nightly'
-      name: Run benchmarks as tests
-      run: |
-        cd bench
-        ./run rust --no-run --verbose
+  # Same as above, but for regex-capi.
+  testfull-regex-capi:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-capi/test
 
-    - if: matrix.build == 'nightly'
-      name: Run tests with pattern feature
-      run: |
-        cargo test --test default --no-default-features --features 'std pattern unicode-perl'
+  # Runs miri on regex-automata's test suite. This doesn't quite cover
+  # everything. Many tests are disabled when building with miri because of
+  # how slow miri runs. But it still gives us decent coverage.
+  miri-regex-automata:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        # We use nightly here so that we can use miri I guess?
+        # It caught me by surprise that miri seems to only be
+        # available on nightly.
+        toolchain: nightly
+        components: miri
+    - name: Run full test suite
+      run: cargo miri test --manifest-path regex-automata/Cargo.toml
 
+  # Tests that everything is formatted correctly.
   rustfmt:
-    name: rustfmt
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository
diff --git a/.vim/coc-settings.json b/.vim/coc-settings.json
new file mode 100644
index 0000000000..d756767509
--- /dev/null
+++ b/.vim/coc-settings.json
@@ -0,0 +1,6 @@
+{
+  "rust-analyzer.linkedProjects": [
+    "fuzz/Cargo.toml",
+    "Cargo.toml"
+  ]
+}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e019afb2f5..31cb0525b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,80 @@
+1.9.0 (2023-07-05)
+==================
+This release marks the end of a [years long rewrite of the regex crate
+internals](https://github.com/rust-lang/regex/issues/656). Since this is
+such a big release, please report any issues or regressions you find. I would
+also love to hear about improvements as well.
+
+In addition to many internal improvements that should hopefully result in
+"my regex searches are faster," there have also been a few API additions:
+
+* A new `Captures::extract` method exists for quickly accessing the substrings
+that match each capture group in a regex.
+* A new inline flag, `R`, which enables CRLF mode. This makes `.` match any
+Unicode scalar value except for `\r` and `\n`, and also makes `(?m:^)` and
+`(?m:$)` match after and before both `\r` and `\n`, respectively, but never
+between a `\r` and `\n`.
+* `RegexBuilder::line_terminator` was added to further customize the line
+terminator used by `(?m:^)` and `(?m:$)` to be any arbitrary byte.
+* The `std` Cargo feature is now actually optional. That is, the `regex` crate
+can be used without the standard library.
+* Because `regex 1.9` may make binary size and compile times even worse, a
+new experimental crate called `regex-lite` has been published. It prioritizes
+binary size and compile times over functionality (like Unicode) and
+performance. It shares no code with the `regex` crate.
+
+New features:
+
+* [FEATURE #244](https://github.com/rust-lang/regex/issues/244):
+One can opt into CRLF mode via the `R` flag.
+e.g., `(?mR:$)` matches just before `\r\n`.
+* [FEATURE #259](https://github.com/rust-lang/regex/issues/259):
+Multi-pattern searches with offsets can be done with `regex-automata 0.3`.
+* [FEATURE #476](https://github.com/rust-lang/regex/issues/476):
+`std` is now an optional feature. `regex` may be used with only `alloc`.
+* [FEATURE #644](https://github.com/rust-lang/regex/issues/644):
+`RegexBuilder::line_terminator` configures how `(?m:^)` and `(?m:$)` behave.
+* [FEATURE #675](https://github.com/rust-lang/regex/issues/675):
+Anchored search APIs are now available in `regex-automata 0.3`.
+* [FEATURE #824](https://github.com/rust-lang/regex/issues/824):
+Add new `Capptures::extract` method for easier capture group access.
+* [FEATURE #961](https://github.com/rust-lang/regex/issues/961):
+Add `regex-lite` crate with smaller binary sizes and faster compile times.
+
+Performance improvements:
+
+* [PERF #68](https://github.com/rust-lang/regex/issues/68):
+Added a one-pass DFA engine for faster capture group matching.
+* [PERF #510](https://github.com/rust-lang/regex/issues/510):
+Inner literals are now used to accelerate searches, e.g., `\w+@\w+` will scan
+for `@`.
+* [PERF #787](https://github.com/rust-lang/regex/issues/787),
+[PERF #891](https://github.com/rust-lang/regex/issues/891):
+Makes literal optimizations apply to regexes of the form `\b(foo|bar|quux)\b`.
+
+(There are many more performance improvements as well, but not all of them have
+specific issues devoted to them.)
+
+Bug fixes:
+
+* [BUG #429](https://github.com/rust-lang/regex/issues/429):
+Fix matching bugs related to `\B` and inconsistencies across internal engines.
+* [BUG #517](https://github.com/rust-lang/regex/issues/517):
+Fix matching bug with capture groups.
+* [BUG #579](https://github.com/rust-lang/regex/issues/579):
+Fix matching bug with word boundaries.
+* [BUG #779](https://github.com/rust-lang/regex/issues/779):
+Fix bug where some regexes like `(re)+` were not equivalent to `(re)(re)*`.
+* [BUG #850](https://github.com/rust-lang/regex/issues/850):
+Fix matching bug inconsistency between NFA and DFA engines.
+* [BUG #921](https://github.com/rust-lang/regex/issues/921):
+Fix matching bug where literal extraction got confused by `$`.
+* [BUG #976](https://github.com/rust-lang/regex/issues/976):
+Add documentation to replacement routines about dealing with fallibility.
+* [BUG #1002](https://github.com/rust-lang/regex/issues/1002):
+Use corpus rejection in fuzz testing.
+
+
 1.8.4 (2023-06-05)
 ==================
 This is a patch release that fixes a bug where `(?-u:\B)` was allowed in
diff --git a/Cargo.toml b/Cargo.toml
index f8a76ab756..2527e885b0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "regex"
 version = "1.8.4"  #:version
-authors = ["The Rust Project Developers"]
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/rust-lang/regex"
@@ -19,17 +19,14 @@ rust-version = "1.60.0"
 
 [workspace]
 members = [
-  "bench", "regex-capi", "regex-syntax",
+  "regex-automata",
+  "regex-capi",
+  "regex-cli",
+  "regex-lite",
+  "regex-syntax",
+  "regex-test",
 ]
 
-[lib]
-# There are no benchmarks in the library code itself
-bench = false
-# Doc tests fail when some features aren't present. The easiest way to work
-# around this is to disable automatic doc testing, but explicitly test them
-# with `cargo test --doc`.
-doctest = false
-
 # Features are documented in the "Crate features" section of the crate docs:
 # https://docs.rs/regex/*/#crate-features
 [features]
@@ -42,7 +39,21 @@ default = ["std", "perf", "unicode", "regex-syntax/default"]
 # to compile without std, and instead just rely on 'core' and 'alloc' (for
 # example). Currently, this isn't supported, and removing the 'std' feature
 # will prevent regex from compiling.
-std = []
+std = [
+  "aho-corasick?/std",
+  "memchr?/std",
+  "regex-automata/std",
+  "regex-syntax/std",
+]
+# This feature enables the 'log' crate to emit messages. This is usually
+# only useful for folks working on the regex crate itself, but can be useful
+# if you're trying hard to do some performance hacking on regex patterns
+# themselves. Note that you'll need to pair this with a crate like 'env_logger'
+# to actually emit the log messages somewhere.
+logging = [
+  "aho-corasick?/logging",
+  "regex-automata/logging",
+]
 # The 'use_std' feature is DEPRECATED. It will be removed in regex 2. Until
 # then, it is an alias for the 'std' feature.
 use_std = ["std"]
@@ -50,19 +61,40 @@ use_std = ["std"]
 
 # PERFORMANCE FEATURES
 
-# Enables all performance features.
-perf = ["perf-cache", "perf-dfa", "perf-inline", "perf-literal"]
+# Enables all default performance features. Note that this specifically does
+# not include perf-dfa-full, because it leads to higher compile times and
+# bigger binaries, and the runtime performance improvement is not obviously
+# worth it.
+perf = [
+  "perf-cache",
+  "perf-dfa",
+  "perf-onepass",
+  "perf-backtrack",
+  "perf-inline",
+  "perf-literal",
+]
+# Enables use of a lazy DFA when possible.
+perf-dfa = ["regex-automata/hybrid"]
+# Enables use of a fully compiled DFA when possible.
+perf-dfa-full = ["regex-automata/dfa-build", "regex-automata/dfa-search"]
+# Enables use of the one-pass regex matcher, which speeds up capture searches
+# even beyond the backtracker.
+perf-onepass = ["regex-automata/dfa-onepass"]
+# Enables use of a bounded backtracker, which speeds up capture searches.
+perf-backtrack = ["regex-automata/nfa-backtrack"]
+# Enables aggressive use of inlining.
+perf-inline = ["regex-automata/perf-inline"]
+# Enables literal optimizations.
+perf-literal = [
+  "dep:aho-corasick",
+  "dep:memchr",
+  "regex-automata/perf-literal",
+]
 # Enables fast caching. (If disabled, caching is still used, but is slower.)
 # Currently, this feature has no effect. It used to remove the thread_local
 # dependency and use a slower internal cache, but now the default cache has
 # been improved and thread_local is no longer a dependency at all.
 perf-cache = []
-# Enables use of a lazy DFA when possible.
-perf-dfa = []
-# Enables aggressive use of inlining.
-perf-inline = []
-# Enables literal optimizations.
-perf-literal = ["aho-corasick", "memchr"]
 
 
 # UNICODE DATA FEATURES
@@ -76,22 +108,45 @@ unicode = [
   "unicode-perl",
   "unicode-script",
   "unicode-segment",
+  "regex-automata/unicode",
   "regex-syntax/unicode",
 ]
 # Enables use of the `Age` property, e.g., `\p{Age:3.0}`.
-unicode-age = ["regex-syntax/unicode-age"]
+unicode-age = [
+  "regex-automata/unicode-age",
+  "regex-syntax/unicode-age",
+]
 # Enables use of a smattering of boolean properties, e.g., `\p{Emoji}`.
-unicode-bool = ["regex-syntax/unicode-bool"]
+unicode-bool = [
+  "regex-automata/unicode-bool",
+  "regex-syntax/unicode-bool",
+]
 # Enables Unicode-aware case insensitive matching, e.g., `(?i)β`.
-unicode-case = ["regex-syntax/unicode-case"]
+unicode-case = [
+  "regex-automata/unicode-case",
+  "regex-syntax/unicode-case",
+]
 # Enables Unicode general categories, e.g., `\p{Letter}` or `\pL`.
-unicode-gencat = ["regex-syntax/unicode-gencat"]
+unicode-gencat = [
+  "regex-automata/unicode-gencat",
+  "regex-syntax/unicode-gencat",
+]
 # Enables Unicode-aware Perl classes corresponding to `\w`, `\s` and `\d`.
-unicode-perl = ["regex-syntax/unicode-perl"]
+unicode-perl = [
+  "regex-automata/unicode-perl",
+  "regex-automata/unicode-word-boundary",
+  "regex-syntax/unicode-perl",
+]
 # Enables Unicode scripts and script extensions, e.g., `\p{Greek}`.
-unicode-script = ["regex-syntax/unicode-script"]
+unicode-script = [
+  "regex-automata/unicode-script",
+  "regex-syntax/unicode-script",
+]
 # Enables Unicode segmentation properties, e.g., `\p{gcb=Extend}`.
-unicode-segment = ["regex-syntax/unicode-segment"]
+unicode-segment = [
+  "regex-automata/unicode-segment",
+  "regex-syntax/unicode-segment",
+]
 
 
 # UNSTABLE FEATURES (requires Rust nightly)
@@ -105,7 +160,7 @@ unstable = ["pattern"]
 # by default if the unstable feature is enabled.
 pattern = []
 
-# For very fast prefix literal matching.
+# For very fast multi-prefix literal matching.
 [dependencies.aho-corasick]
 version = "1.0.0"
 optional = true
@@ -114,6 +169,12 @@ optional = true
 [dependencies.memchr]
 version = "2.5.0"
 optional = true
+# For the actual regex engines.
+[dependencies.regex-automata]
+path = "regex-automata"
+version = "0.3.0"
+default-features = false
+features = ["alloc", "syntax", "meta", "nfa-pikevm"]
 
 # For parsing regular expressions.
 [dependencies.regex-syntax]
@@ -123,67 +184,56 @@ default-features = false
 
 [dev-dependencies]
 # For examples.
-lazy_static = "1"
+once_cell = "1.17.1"
 # For property based tests.
 quickcheck = { version = "1.0.3", default-features = false }
-# For generating random test data.
-rand = { version = "0.8.3", default-features = false, features = ["getrandom", "small_rng"] }
 # To check README's example
-# TODO: Re-enable this once the MSRV is 1.43 or greater.
-# See: https://github.com/rust-lang/regex/issues/684
-# See: https://github.com/rust-lang/regex/issues/685
-# doc-comment = "0.3"
-
-# Run the test suite on the default behavior of Regex::new.
-# This includes a mish mash of NFAs and DFAs, which are chosen automatically
-# based on the regex. We test both of the NFA implementations by forcing their
-# usage with the test definitions below. (We can't test the DFA implementations
-# in the same way since they can't be used for every regex tested.)
-[[test]]
-path = "tests/test_default.rs"
-name = "default"
+doc-comment = "0.3"
+# For easy error handling in integration tests.
+anyhow = "1.0.69"
+# A library for testing regex engines.
+regex-test = { path = "regex-test", version = "0.1.0" }
 
-# The same as the default tests, but run on bytes::Regex.
-[[test]]
-path = "tests/test_default_bytes.rs"
-name = "default-bytes"
-
-# Run the test suite on the NFA algorithm over Unicode codepoints.
-[[test]]
-path = "tests/test_nfa.rs"
-name = "nfa"
-
-# Run the test suite on the NFA algorithm over bytes that match UTF-8 only.
-[[test]]
-path = "tests/test_nfa_utf8bytes.rs"
-name = "nfa-utf8bytes"
-
-# Run the test suite on the NFA algorithm over arbitrary bytes.
-[[test]]
-path = "tests/test_nfa_bytes.rs"
-name = "nfa-bytes"
-
-# Run the test suite on the backtracking engine over Unicode codepoints.
-[[test]]
-path = "tests/test_backtrack.rs"
-name = "backtrack"
-
-# Run the test suite on the backtracking engine over bytes that match UTF-8
-# only.
-[[test]]
-path = "tests/test_backtrack_utf8bytes.rs"
-name = "backtrack-utf8bytes"
+[dev-dependencies.env_logger]
+# Note that this is currently using an older version because of the dependency
+# tree explosion that happened in 0.10.
+version = "0.9.3"
+default-features = false
+features = ["atty", "humantime", "termcolor"]
 
-# Run the test suite on the backtracking engine over arbitrary bytes.
+# This test suite reads a whole boatload of tests from the top-level testdata
+# directory, and then runs them against the regex crate API.
+#
+# regex-automata has its own version of them, and runs them against each
+# internal regex engine individually.
+#
+# This means that if you're seeing a failure in this test suite, you should
+# try running regex-automata's tests:
+#
+#     cargo test --manifest-path regex-automata/Cargo.toml --test integration
+#
+# That *might* give you a more targeted test failure. i.e., "only the
+# PikeVM fails this test." Which gives you a narrower place to search. If
+# regex-automata's test suite passes, then the bug might be in the integration
+# of the regex crate and regex-automata. But generally speaking, a failure
+# in this test suite *should* mean there is a corresponding failure in
+# regex-automata's test suite.
 [[test]]
-path = "tests/test_backtrack_bytes.rs"
-name = "backtrack-bytes"
+path = "tests/lib.rs"
+name = "integration"
 
-# Run all backends against each regex found on crates.io and make sure
-# that they all do the same thing.
-[[test]]
-path = "tests/test_crates_regex.rs"
-name = "crates-regex"
+[package.metadata.docs.rs]
+# We want to document all features.
+all-features = true
+# Since this crate's feature setup is pretty complicated, it is worth opting
+# into a nightly unstable option to show the features that need to be enabled
+# for public API items. To do that, we set 'docsrs', and when that's enabled,
+# we enable the 'doc_auto_cfg' feature.
+#
+# To test this locally, run:
+#
+#     RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+rustdoc-args = ["--cfg", "docsrs"]
 
 [profile.release]
 debug = true
@@ -191,5 +241,17 @@ debug = true
 [profile.bench]
 debug = true
 
+[profile.dev]
+# Running tests takes too long in debug mode, so we forcefully always build
+# with optimizations. Unfortunate, but, ¯\_(ツ)_/¯.
+#
+# It's counter-intuitive that this needs to be set on dev *and* test, but
+# it's because the tests that take a long time to run are run as integration
+# tests in a separate crate. The test.opt-level setting won't apply there, so
+# we need to set the opt-level across the entire build.
+opt-level = 3
+debug = true
+
 [profile.test]
+opt-level = 3
 debug = true
diff --git a/Cross.toml b/Cross.toml
new file mode 100644
index 0000000000..5415e7a451
--- /dev/null
+++ b/Cross.toml
@@ -0,0 +1,7 @@
+[build.env]
+passthrough = [
+    "RUST_BACKTRACE",
+    "RUST_LOG",
+    "REGEX_TEST",
+    "REGEX_TEST_VERBOSE",
+]
diff --git a/PERFORMANCE.md b/PERFORMANCE.md
deleted file mode 100644
index 8cd0d9c719..0000000000
--- a/PERFORMANCE.md
+++ /dev/null
@@ -1,277 +0,0 @@
-Your friendly guide to understanding the performance characteristics of this
-crate.
-
-This guide assumes some familiarity with the public API of this crate, which
-can be found here: https://docs.rs/regex
-
-## Theory vs. Practice
-
-One of the design goals of this crate is to provide worst case linear time
-behavior with respect to the text searched using finite state automata. This
-means that, *in theory*, the performance of this crate is much better than most
-regex implementations, which typically use backtracking which has worst case
-exponential time.
-
-For example, try opening a Python interpreter and typing this:
-
-    >>> import re
-    >>> re.search('(a*)*c', 'a' * 30).span()
-
-I'll wait.
-
-At some point, you'll figure out that it won't terminate any time soon. ^C it.
-
-The promise of this crate is that *this pathological behavior can't happen*.
-
-With that said, just because we have protected ourselves against worst case
-exponential behavior doesn't mean we are immune from large constant factors
-or places where the current regex engine isn't quite optimal. This guide will
-detail those cases and provide guidance on how to avoid them, among other
-bits of general advice.
-
-## Thou Shalt Not Compile Regular Expressions In A Loop
-
-**Advice**: Use `lazy_static` to amortize the cost of `Regex` compilation.
-
-Don't do it unless you really don't mind paying for it. Compiling a regular
-expression in this crate is quite expensive. It is conceivable that it may get
-faster some day, but I wouldn't hold out hope for, say, an order of magnitude
-improvement. In particular, compilation can take any where from a few dozen
-microseconds to a few dozen milliseconds. Yes, milliseconds. Unicode character
-classes, in particular, have the largest impact on compilation performance. At
-the time of writing, for example, `\pL{100}` takes around 44ms to compile. This
-is because `\pL` corresponds to every letter in Unicode and compilation must
-turn it into a proper automaton that decodes a subset of UTF-8 which
-corresponds to those letters. Compilation also spends some cycles shrinking the
-size of the automaton.
-
-This means that in order to realize efficient regex matching, one must
-*amortize the cost of compilation*. Trivially, if a call to `is_match` is
-inside a loop, then make sure your call to `Regex::new` is *outside* that loop.
-
-In many programming languages, regular expressions can be conveniently defined
-and compiled in a global scope, and code can reach out and use them as if
-they were global static variables. In Rust, there is really no concept of
-life-before-main, and therefore, one cannot utter this:
-
-    static MY_REGEX: Regex = Regex::new("...").unwrap();
-
-Unfortunately, this would seem to imply that one must pass `Regex` objects
-around to everywhere they are used, which can be especially painful depending
-on how your program is structured. Thankfully, the
-[`lazy_static`](https://crates.io/crates/lazy_static)
-crate provides an answer that works well:
-
-    use lazy_static::lazy_static;
-    use regex::Regex;
-
-    fn some_helper_function(text: &str) -> bool {
-        lazy_static! {
-            static ref MY_REGEX: Regex = Regex::new("...").unwrap();
-        }
-        MY_REGEX.is_match(text)
-    }
-
-In other words, the `lazy_static!` macro enables us to define a `Regex` *as if*
-it were a global static value. What is actually happening under the covers is
-that the code inside the macro (i.e., `Regex::new(...)`) is run on *first use*
-of `MY_REGEX` via a `Deref` impl. The implementation is admittedly magical, but
-it's self contained and everything works exactly as you expect. In particular,
-`MY_REGEX` can be used from multiple threads without wrapping it in an `Arc` or
-a `Mutex`. On that note...
-
-## Using a regex from multiple threads
-
-**Advice**: The performance impact from using a `Regex` from multiple threads
-is likely negligible. If necessary, clone the `Regex` so that each thread gets
-its own copy. Cloning a regex does not incur any additional memory overhead
-than what would be used by using a `Regex` from multiple threads
-simultaneously. *Its only cost is ergonomics.*
-
-It is supported and encouraged to define your regexes using `lazy_static!` as
-if they were global static values, and then use them to search text from
-multiple threads simultaneously.
-
-One might imagine that this is possible because a `Regex` represents a
-*compiled* program, so that any allocation or mutation is already done, and is
-therefore read-only. Unfortunately, this is not true. Each type of search
-strategy in this crate requires some kind of mutable scratch space to use
-*during search*. For example, when executing a DFA, its states are computed
-lazily and reused on subsequent searches. Those states go into that mutable
-scratch space.
-
-The mutable scratch space is an implementation detail, and in general, its
-mutation should not be observable from users of this crate. Therefore, it uses
-interior mutability. This implies that `Regex` can either only be used from one
-thread, or it must do some sort of synchronization. Either choice is
-reasonable, but this crate chooses the latter, in particular because it is
-ergonomic and makes use with `lazy_static!` straight forward.
-
-Synchronization implies *some* amount of overhead. When a `Regex` is used from
-a single thread, this overhead is negligible. When a `Regex` is used from
-multiple threads simultaneously, it is possible for the overhead of
-synchronization from contention to impact performance. The specific cases where
-contention may happen is if you are calling any of these methods repeatedly
-from multiple threads simultaneously:
-
-* shortest_match
-* is_match
-* find
-* captures
-
-In particular, every invocation of one of these methods must synchronize with
-other threads to retrieve its mutable scratch space before searching can start.
-If, however, you are using one of these methods:
-
-* find_iter
-* captures_iter
-
-Then you may not suffer from contention since the cost of synchronization is
-amortized on *construction of the iterator*. That is, the mutable scratch space
-is obtained when the iterator is created and retained throughout its lifetime.
-
-## Only ask for what you need
-
-**Advice**: Prefer in this order: `is_match`, `find`, `captures`.
-
-There are three primary search methods on a `Regex`:
-
-* is_match
-* find
-* captures
-
-In general, these are ordered from fastest to slowest.
-
-`is_match` is fastest because it doesn't actually need to find the start or the
-end of the leftmost-first match. It can quit immediately after it knows there
-is a match. For example, given the regex `a+` and the haystack, `aaaaa`, the
-search will quit after examining the first byte.
-
-In contrast, `find` must return both the start and end location of the
-leftmost-first match. It can use the DFA matcher for this, but must run it
-forwards once to find the end of the match *and then run it backwards* to find
-the start of the match. The two scans and the cost of finding the real end of
-the leftmost-first match make this more expensive than `is_match`.
-
-`captures` is the most expensive of them all because it must do what `find`
-does, and then run either the bounded backtracker or the Pike VM to fill in the
-capture group locations. Both of these are simulations of an NFA, which must
-spend a lot of time shuffling states around. The DFA limits the performance hit
-somewhat by restricting the amount of text that must be searched via an NFA
-simulation.
-
-One other method not mentioned is `shortest_match`. This method has precisely
-the same performance characteristics as `is_match`, except it will return the
-end location of when it discovered a match. For example, given the regex `a+`
-and the haystack `aaaaa`, `shortest_match` may return `1` as opposed to `5`,
-the latter of which being the correct end location of the leftmost-first match.
-
-## Literals in your regex may make it faster
-
-**Advice**: Literals can reduce the work that the regex engine needs to do. Use
-them if you can, especially as prefixes.
-
-In particular, if your regex starts with a prefix literal, the prefix is
-quickly searched before entering the (much slower) regex engine. For example,
-given the regex `foo\w+`, the literal `foo` will be searched for using
-Boyer-Moore. If there's no match, then no regex engine is ever used. Only when
-there's a match is the regex engine invoked at the location of the match, which
-effectively permits the regex engine to skip large portions of a haystack.
-If a regex is comprised entirely of literals (possibly more than one), then
-it's possible that the regex engine can be avoided entirely even when there's a
-match.
-
-When one literal is found, Boyer-Moore is used. When multiple literals are
-found, then an optimized version of Aho-Corasick is used.
-
-This optimization is in particular extended quite a bit in this crate. Here are
-a few examples of regexes that get literal prefixes detected:
-
-* `(foo|bar)` detects `foo` and `bar`
-* `(a|b)c` detects `ac` and `bc`
-* `[ab]foo[yz]` detects `afooy`, `afooz`, `bfooy` and `bfooz`
-* `a?b` detects `a` and `b`
-* `a*b` detects `a` and `b`
-* `(ab){3,6}` detects `ababab`
-
-Literals in anchored regexes can also be used for detecting non-matches very
-quickly. For example, `^foo\w+` and `\w+foo$` may be able to detect a non-match
-just by examining the first (or last) three bytes of the haystack.
-
-## Unicode word boundaries may prevent the DFA from being used
-
-**Advice**: In most cases, `\b` should work well. If not, use `(?-u:\b)`
-instead of `\b` if you care about consistent performance more than correctness.
-
-It's a sad state of the current implementation. At the moment, the DFA will try
-to interpret Unicode word boundaries as if they were ASCII word boundaries.
-If the DFA comes across any non-ASCII byte, it will quit and fall back to an
-alternative matching engine that can handle Unicode word boundaries correctly.
-The alternate matching engine is generally quite a bit slower (perhaps by an
-order of magnitude). If necessary, this can be ameliorated in two ways.
-
-The first way is to add some number of literal prefixes to your regular
-expression. Even though the DFA may not be used, specialized routines will
-still kick in to find prefix literals quickly, which limits how much work the
-NFA simulation will need to do.
-
-The second way is to give up on Unicode and use an ASCII word boundary instead.
-One can use an ASCII word boundary by disabling Unicode support. That is,
-instead of using `\b`, use `(?-u:\b)`.  Namely, given the regex `\b.+\b`, it
-can be transformed into a regex that uses the DFA with `(?-u:\b).+(?-u:\b)`. It
-is important to limit the scope of disabling the `u` flag, since it might lead
-to a syntax error if the regex could match arbitrary bytes. For example, if one
-wrote `(?-u)\b.+\b`, then a syntax error would be returned because `.` matches
-any *byte* when the Unicode flag is disabled.
-
-The second way isn't appreciably different than just using a Unicode word
-boundary in the first place, since the DFA will speculatively interpret it as
-an ASCII word boundary anyway. The key difference is that if an ASCII word
-boundary is used explicitly, then the DFA won't quit in the presence of
-non-ASCII UTF-8 bytes. This results in giving up correctness in exchange for
-more consistent performance.
-
-N.B. When using `bytes::Regex`, Unicode support is disabled by default, so one
-can simply write `\b` to get an ASCII word boundary.
-
-## Excessive counting can lead to exponential state blow up in the DFA
-
-**Advice**: Don't write regexes that cause DFA state blow up if you care about
-match performance.
-
-Wait, didn't I say that this crate guards against exponential worst cases?
-Well, it turns out that the process of converting an NFA to a DFA can lead to
-an exponential blow up in the number of states. This crate specifically guards
-against exponential blow up by doing two things:
-
-1. The DFA is computed lazily. That is, a state in the DFA only exists in
-   memory if it is visited. In particular, the lazy DFA guarantees that *at
-   most* one state is created for every byte of input. This, on its own,
-   guarantees linear time complexity.
-2. Of course, creating a new state for *every* byte of input means that search
-   will go incredibly slow because of very large constant factors. On top of
-   that, creating a state for every byte in a large haystack could result in
-   exorbitant memory usage. To ameliorate this, the DFA bounds the number of
-   states it can store. Once it reaches its limit, it flushes its cache. This
-   prevents reuse of states that it already computed. If the cache is flushed
-   too frequently, then the DFA will give up and execution will fall back to
-   one of the NFA simulations.
-
-In effect, this crate will detect exponential state blow up and fall back to
-a search routine with fixed memory requirements. This does, however, mean that
-searching will be much slower than one might expect. Regexes that rely on
-counting in particular are strong aggravators of this behavior. For example,
-matching `[01]*1[01]{20}$` against a random sequence of `0`s and `1`s.
-
-In the future, it may be possible to increase the bound that the DFA uses,
-which would allow the caller to choose how much memory they're willing to
-spend.
-
-## Resist the temptation to "optimize" regexes
-
-**Advice**: This ain't a backtracking engine.
-
-An entire book was written on how to optimize Perl-style regular expressions.
-Most of those techniques are not applicable for this library. For example,
-there is no problem with using non-greedy matching or having lots of
-alternations in your regex.
diff --git a/README.md b/README.md
index 020b353956..a9d6fcd373 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,17 @@
 regex
 =====
-A Rust library for parsing, compiling, and executing regular expressions. Its
-syntax is similar to Perl-style regular expressions, but lacks a few features
-like look around and backreferences. In exchange, all searches execute in
-linear time with respect to the size of the regular expression and search text.
-Much of the syntax and implementation is inspired
-by [RE2](https://github.com/google/re2).
+This crate provides routines for searching strings for matches of a [regular
+expression] (aka "regex"). The regex syntax supported by this crate is similar
+to other regex engines, but it lacks several features that are not known how to
+implement efficiently. This includes, but is not limited to, look-around and
+backreferences. In exchange, all regex searches in this crate have worst case
+`O(m * n)` time complexity, where `m` is proportional to the size of the regex
+and `n` is proportional to the size of the string being searched.
+
+[regular expression]: https://en.wikipedia.org/wiki/Regular_expression
 
 [![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
 [![Crates.io](https://img.shields.io/crates/v/regex.svg)](https://crates.io/crates/regex)
-[![Rust](https://img.shields.io/badge/rust-1.60.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/regex)
 
 ### Documentation
 
@@ -40,8 +42,8 @@ fn main() {
 -
 (?P<day>\d{2})   # the day
 ").unwrap();
-    let caps = re.captures("2010-03-14").unwrap();
 
+    let caps = re.captures("2010-03-14").unwrap();
     assert_eq!("2010", &caps["year"]);
     assert_eq!("03", &caps["month"]);
     assert_eq!("14", &caps["day"]);
@@ -54,32 +56,21 @@ easy to adapt the above example with an iterator:
 ```rust
 use regex::Regex;
 
-const TO_SEARCH: &'static str = "
-On 2010-03-14, foo happened. On 2014-10-14, bar happened.
-";
-
 fn main() {
     let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
+    let hay = "On 2010-03-14, foo happened. On 2014-10-14, bar happened.";
 
-    for caps in re.captures_iter(TO_SEARCH) {
-        // Note that all of the unwraps are actually OK for this regex
-        // because the only way for the regex to match is if all of the
-        // capture groups match. This is not true in general though!
-        println!("year: {}, month: {}, day: {}",
-                 caps.get(1).unwrap().as_str(),
-                 caps.get(2).unwrap().as_str(),
-                 caps.get(3).unwrap().as_str());
+    let mut dates = vec![];
+    for (_, [year, month, day]) in re.captures_iter(hay).map(|c| c.extract()) {
+        dates.push((year, month, day));
     }
+    assert_eq!(dates, vec![
+      ("2010", "03", "14"),
+      ("2014", "10", "14"),
+    ]);
 }
 ```
 
-This example outputs:
-
-```text
-year: 2010, month: 03, day: 14
-year: 2014, month: 10, day: 14
-```
-
 ### Usage: Avoid compiling the same regex in a loop
 
 It is an anti-pattern to compile the same regular expression in a loop since
@@ -90,19 +81,23 @@ allocations internally to the matching engines.
 
 In Rust, it can sometimes be a pain to pass regular expressions around if
 they're used from inside a helper function. Instead, we recommend using the
-[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that
-regular expressions are compiled exactly once.
-
-For example:
+[`once_cell`](https://crates.io/crates/once_cell) crate to ensure that
+regular expressions are compiled exactly once. For example:
 
-```rust,ignore
-use regex::Regex;
+```rust
+use {
+    once_cell::sync::Lazy,
+    regex::Regex,
+};
+
+fn some_helper_function(haystack: &str) -> bool {
+    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"...").unwrap());
+    RE.is_match(haystack)
+}
 
-fn some_helper_function(text: &str) -> bool {
-    lazy_static! {
-        static ref RE: Regex = Regex::new("...").unwrap();
-    }
-    RE.is_match(text)
+fn main() {
+    assert!(some_helper_function("abc"));
+    assert!(!some_helper_function("ac"));
 }
 ```
 
@@ -115,19 +110,21 @@ The main API of this crate (`regex::Regex`) requires the caller to pass a
 `&str` for searching. In Rust, an `&str` is required to be valid UTF-8, which
 means the main API can't be used for searching arbitrary bytes.
 
-To match on arbitrary bytes, use the `regex::bytes::Regex` API. The API
-is identical to the main API, except that it takes an `&[u8]` to search
-on instead of an `&str`. By default, `.` will match any *byte* using
-`regex::bytes::Regex`, while `.` will match any *UTF-8 encoded Unicode scalar
-value* using the main API.
+To match on arbitrary bytes, use the `regex::bytes::Regex` API. The API is
+identical to the main API, except that it takes an `&[u8]` to search on instead
+of an `&str`. The `&[u8]` APIs also permit disabling Unicode mode in the regex
+even when the pattern would match invalid UTF-8. For example, `(?-u:.)` is
+not allowed in `regex::Regex` but is allowed in `regex::bytes::Regex` since
+`(?-u:.)` matches any byte except for `\n`. Conversely, `.` will match the
+UTF-8 encoding of any Unicode scalar value except for `\n`.
 
 This example shows how to find all null-terminated strings in a slice of bytes:
 
 ```rust
 use regex::bytes::Regex;
 
-let re = Regex::new(r"(?P<cstr>[^\x00]+)\x00").unwrap();
-let text = b"foo\x00bar\x00baz\x00";
+let re = Regex::new(r"(?-u)(?<cstr>[^\x00]+)\x00").unwrap();
+let text = b"foo\xFFbar\x00baz\x00";
 
 // Extract all of the strings without the null terminator from each match.
 // The unwrap is OK here since a match requires the `cstr` capture to match.
@@ -135,12 +132,12 @@ let cstrs: Vec<&[u8]> =
     re.captures_iter(text)
       .map(|c| c.name("cstr").unwrap().as_bytes())
       .collect();
-assert_eq!(vec![&b"foo"[..], &b"bar"[..], &b"baz"[..]], cstrs);
+assert_eq!(vec![&b"foo\xFFbar"[..], &b"baz"[..]], cstrs);
 ```
 
-Notice here that the `[^\x00]+` will match any *byte* except for `NUL`. When
-using the main API, `[^\x00]+` would instead match any valid UTF-8 sequence
-except for `NUL`.
+Notice here that the `[^\x00]+` will match any *byte* except for `NUL`,
+including bytes like `\xFF` which are not valid UTF-8. When using the main API,
+`[^\x00]+` would instead match any valid UTF-8 sequence except for `NUL`.
 
 ### Usage: match multiple regular expressions simultaneously
 
@@ -170,11 +167,15 @@ assert!(!matches.matched(5));
 assert!(matches.matched(6));
 ```
 
-### Usage: enable SIMD optimizations
 
-SIMD optimizations are enabled automatically on Rust stable 1.27 and newer.
-For nightly versions of Rust, this requires a recent version with the SIMD
-features stabilized.
+### Usage: regex internals as a library
+
+The [`regex-automata` directory](./regex-automata/) contains a crate that
+exposes all of the internal matching engines used by the `regex` crate. The
+idea is that the `regex` crate exposes a simple API for 99% of use cases, but
+`regex-automata` exposes oodles of customizable behaviors.
+
+[Documentation for `regex-automata`.](https://docs.rs/regex-automata)
 
 
 ### Usage: a regular expression parser
@@ -186,7 +187,7 @@ This may be useful if you're implementing your own regex engine or otherwise
 need to do analysis on the syntax of a regular expression. It is otherwise not
 recommended for general use.
 
-[Documentation `regex-syntax`.](https://docs.rs/regex-syntax)
+[Documentation for `regex-syntax`.](https://docs.rs/regex-syntax)
 
 
 ### Crate features
@@ -205,29 +206,28 @@ all such features, use the following `Cargo.toml` dependency configuration:
 [dependencies.regex]
 version = "1.3"
 default-features = false
-# regex currently requires the standard library, you must re-enable it.
+# Unless you have a specific reason not to, it's good sense to enable standard
+# library support. It enables several optimizations and avoids spin locks. It
+# also shouldn't meaningfully impact compile times or binary size.
 features = ["std"]
 ```
 
-This will reduce the dependency tree of `regex` down to a single crate
-(`regex-syntax`).
+This will reduce the dependency tree of `regex` down to two crates:
+`regex-syntax` and `regex-automata`.
 
 The full set of features one can disable are
-[in the "Crate features" section of the documentation](https://docs.rs/regex/*/#crate-features).
+[in the "Crate features" section of the documentation](https://docs.rs/regex/1.*/#crate-features).
 
 
 ### Minimum Rust version policy
 
 This crate's minimum supported `rustc` version is `1.60.0`.
 
-The current **tentative** policy is that the minimum Rust version required
-to use this crate can be increased in minor version updates. For example, if
-regex 1.0 requires Rust 1.20.0, then regex 1.0.z for all values of `z` will
-also require Rust 1.20.0 or newer. However, regex 1.y for `y > 0` may require a
-newer minimum version of Rust.
-
-In general, this crate will be conservative with respect to the minimum
-supported version of Rust.
+The policy is that the minimum Rust version required to use this crate can be
+increased in minor version updates. For example, if regex 1.0 requires Rust
+1.20.0, then regex 1.0.z for all values of `z` will also require Rust 1.20.0 or
+newer. However, regex 1.y for `y > 0` may require a newer minimum version of
+Rust.
 
 
 ### License
diff --git a/UNICODE.md b/UNICODE.md
index df7d21ed97..60db0aad1f 100644
--- a/UNICODE.md
+++ b/UNICODE.md
@@ -8,7 +8,8 @@ Full support for Level 1 ("Basic Unicode Support") is provided with two
 exceptions:
 
 1. Line boundaries are not Unicode aware. Namely, only the `\n`
-   (`END OF LINE`) character is recognized as a line boundary.
+   (`END OF LINE`) character is recognized as a line boundary by default.
+   One can opt into `\r\n|\r|\n` being a line boundary via CRLF mode.
 2. The compatibility properties specified by
    [RL1.2a](https://unicode.org/reports/tr18/#RL1.2a)
    are ASCII-only definitions.
@@ -229,12 +230,10 @@ then all characters classes are case folded as well.
 [UTS#18 RL1.6](https://unicode.org/reports/tr18/#Line_Boundaries)
 
 The regex crate only provides support for recognizing the `\n` (`END OF LINE`)
-character as a line boundary. This choice was made mostly for implementation
-convenience, and to avoid performance cliffs that Unicode word boundaries are
-subject to.
-
-Ideally, it would be nice to at least support `\r\n` as a line boundary as
-well, and in theory, this could be done efficiently.
+character as a line boundary by default. One can also opt into treating
+`\r\n|\r|\n` as a line boundary via CRLF mode. This choice was made mostly for
+implementation convenience, and to avoid performance cliffs that Unicode word
+boundaries are subject to.
 
 
 ## RL1.7 Code Points
diff --git a/bench/.gitignore b/bench/.gitignore
deleted file mode 100644
index 5761abcfdf..0000000000
--- a/bench/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-*.o
diff --git a/bench/Cargo.toml b/bench/Cargo.toml
deleted file mode 100644
index 5dfcb93cc1..0000000000
--- a/bench/Cargo.toml
+++ /dev/null
@@ -1,59 +0,0 @@
-[package]
-publish = false
-name = "regex-benchmark"
-version = "0.1.0"
-authors = ["The Rust Project Developers"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/rust-lang/regex"
-documentation = "https://docs.rs/regex"
-homepage = "https://github.com/rust-lang/regex"
-description = "Regex benchmarks for Rust's and other engines."
-build = "build.rs"
-workspace = ".."
-edition = "2018"
-
-[dependencies]
-docopt = "1"
-lazy_static = "1"
-libc = "0.2"
-onig = { version = "3", optional = true }
-libpcre-sys = { version = "0.2", optional = true }
-memmap = "0.6.2"
-regex = { version = "1.8.0", path = ".." }
-regex-syntax = { version = "0.7.0", path = "../regex-syntax" }
-serde = { version = "1", features = ["derive"] }
-cfg-if = "0.1"
-
-[build-dependencies]
-cc = "1"
-pkg-config = "0.3.9"
-
-[[bin]]
-name = "regex-run-one"
-path = "src/main.rs"
-bench = false
-
-# Use features to conditionally compile benchmarked regexes, since not every
-# regex works on every engine. Additionally, it is useful to be able to build
-# each benchmark individually, so that not all dependencies are required to
-# run only one benchmark.
-#
-# Note that when running benchmarks, only ONE feature should be set at a time.
-# Doing anything else will probably result in weird "duplicate definition"
-# compiler errors.
-#
-# Tip: use the `bench/run` script (in this directory) to run benchmarks.
-[features]
-re-pcre1 = ["libpcre-sys"]
-re-pcre2 = []
-re-onig = ["onig"]
-re-re2 = []
-re-rust = []
-re-rust-bytes = []
-re-tcl = []
-
-[[bench]]
-name = "bench"
-path = "src/bench.rs"
-test = false
-bench = true
diff --git a/bench/build.rs b/bench/build.rs
deleted file mode 100644
index 156af4a3ac..0000000000
--- a/bench/build.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use std::env;
-
-fn main() {
-    if env::var("CARGO_FEATURE_RE_PCRE2").is_ok() {
-        pkg_config::probe_library("libpcre2-8").unwrap();
-    }
-    if env::var("CARGO_FEATURE_RE_RE2").is_ok() {
-        // RE2 is a C++ library, so we need to compile our shim layer.
-        cc::Build::new()
-            .cpp(true)
-            .file("src/ffi/re2.cpp")
-            .compile("libcre2.a");
-        // It's important this comes after compiling the shim, which results
-        // in the correct order of arguments given to the linker.
-        pkg_config::probe_library("re2").unwrap();
-    }
-    if env::var("CARGO_FEATURE_RE_TCL").is_ok() {
-        pkg_config::probe_library("tcl").unwrap();
-    }
-}
diff --git a/bench/compile b/bench/compile
deleted file mode 100755
index 43c9c22e58..0000000000
--- a/bench/compile
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/sh
-
-exec cargo build \
-  --release \
-  --features 're-re2 re-onig re-pcre1 re-pcre2 re-rust re-rust-bytes re-tcl' \
-  "$@"
diff --git a/bench/log/README b/bench/log/README
deleted file mode 100644
index 265d3b8bb3..0000000000
--- a/bench/log/README
+++ /dev/null
@@ -1 +0,0 @@
-These benchmarks were produced on an otherwise idle i5-7600 3.5GHz CPU.
diff --git a/bench/run b/bench/run
deleted file mode 100755
index f26c506599..0000000000
--- a/bench/run
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-usage() {
-  echo "Usage: $(basename $0) [rust | rust-bytes | pcre1 | pcre2 | re2 | onig | tcl ]" >&2
-  exit 1
-}
-
-if [ $# = 0 ] || [ $1 = '-h' ] || [ $1 = '--help' ]; then
-  usage
-fi
-
-which="$1"
-shift
-case $which in
-  rust)
-    exec cargo bench --bench bench --features re-rust "$@"
-    ;;
-  rust-bytes)
-    exec cargo bench --bench bench --features re-rust-bytes "$@"
-    ;;
-  re2)
-    exec cargo bench --bench bench --features re-re2 "$@"
-    ;;
-  pcre1)
-    exec cargo bench --bench bench --features re-pcre1 "$@"
-    ;;
-  pcre2)
-    exec cargo bench --bench bench --features re-pcre2 "$@"
-    ;;
-  onig)
-    exec cargo bench --bench bench --features re-onig "$@"
-    ;;
-  tcl)
-    exec cargo bench --bench bench --features re-tcl "$@"
-    ;;
-  *)
-    usage
-    ;;
-esac
diff --git a/bench/src/bench.rs b/bench/src/bench.rs
deleted file mode 100644
index cae1d90f6f..0000000000
--- a/bench/src/bench.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-// Enable the benchmarking harness.
-#![feature(test)]
-// It's too annoying to carefully define macros based on which regex engines
-// have which benchmarks, so just ignore these warnings.
-#![allow(unused_macros)]
-
-extern crate test;
-
-use cfg_if::cfg_if;
-
-cfg_if! {
-    if #[cfg(feature = "re-pcre1")] {
-        pub use ffi::pcre1::Regex;
-    } else if #[cfg(feature = "re-onig")] {
-        pub use ffi::onig::Regex;
-    } else if #[cfg(any(feature = "re-rust"))] {
-        pub use regex::{Regex, RegexSet};
-    } else if #[cfg(feature = "re-rust-bytes")] {
-        pub use regex::bytes::{Regex, RegexSet};
-    } else if #[cfg(feature = "re-re2")] {
-        pub use ffi::re2::Regex;
-    } else if #[cfg(feature = "re-pcre2")] {
-        pub use ffi::pcre2::Regex;
-    } else if #[cfg(feature = "re-tcl")] {
-        pub use ffi::tcl::Regex;
-    } else {
-        compile_error!(
-            "To run the benchmarks, see `./run -h` or the HACKING.md document"
-        );
-    }
-}
-
-// Usage: regex!(pattern)
-//
-// Builds a ::Regex from a borrowed string.
-//
-// Due to macro scoping rules, this definition only applies for the modules
-// defined below. Effectively, it allows us to use the same tests for both
-// native and dynamic regexes.
-macro_rules! regex {
-    ($re:expr) => {
-        crate::Regex::new(&$re.to_owned()).unwrap()
-    };
-}
-
-cfg_if! {
-    if #[cfg(feature = "re-tcl")] {
-        // Usage: text!(haystack)
-        //
-        // Builds a ::Text from an owned string.
-        //
-        // This macro is called on every input searched in every benchmark. It is
-        // called exactly once per benchmark and its time is not included in the
-        // benchmark timing.
-        //
-        // The text given to the macro is always a String, which is guaranteed to be
-        // valid UTF-8.
-        //
-        // The return type should be an owned value that can deref to whatever the
-        // regex accepts in its `is_match` and `find_iter` methods.
-        macro_rules! text {
-            ($text:expr) => {{
-                use crate::ffi::tcl::Text;
-                Text::new($text)
-            }}
-        }
-        type Text = ffi::tcl::Text;
-    } else if #[cfg(feature = "re-rust-bytes")] {
-        macro_rules! text {
-            ($text:expr) => {{
-                let text: String = $text;
-                text.into_bytes()
-            }}
-        }
-        type Text = Vec<u8>;
-    } else {
-        macro_rules! text {
-            ($text:expr) => { $text }
-        }
-        type Text = String;
-    }
-}
-
-// Macros for writing benchmarks easily. We provide macros for benchmarking
-// matches, non-matches and for finding all successive non-overlapping matches
-// in a string (including a check that the count is correct).
-
-// USAGE: bench_match!(name, pattern, haystack)
-//
-// This benchmarks how fast a regular expression can report whether it matches
-// a particular haystack. If the regex doesn't match, then the benchmark fails.
-// Regexes are compiled exactly once.
-//
-// name is an identifier for the benchmark.
-//
-// pattern should be a &'static str representing the regular expression.
-//
-// haystack should be a String.
-macro_rules! bench_match {
-    ($name:ident, $pattern:expr, $haystack:expr) => {
-        bench_is_match!($name, true, regex!($pattern), $haystack);
-    };
-}
-
-// USAGE: bench_not_match!(name, pattern, haystack)
-//
-// This benchmarks how fast a regular expression can report whether it matches
-// a particular haystack. If the regex matches, then the benchmark fails.
-// Regexes are compiled exactly once.
-//
-// name is an identifier for the benchmark.
-//
-// pattern should be a &'static str representing the regular expression.
-//
-// haystack should be a String.
-macro_rules! bench_not_match {
-    ($name:ident, $pattern:expr, $haystack:expr) => {
-        bench_is_match!($name, false, regex!($pattern), $haystack);
-    };
-}
-
-// USAGE: bench_is_match!(name, is_match, regex, haystack)
-//
-// This benchmarks how fast a regular expression can report whether it matches
-// a particular haystack. If the regex match status doesn't match is_match,
-// then the benchmark fails. Regexes are compiled exactly once.
-//
-// name is an identifier for the benchmark.
-//
-// is_match reports whether the regex is expected to match the haystack or not.
-//
-// regex should be a ::Regex.
-//
-// haystack should be a String.
-macro_rules! bench_is_match {
-    ($name:ident, $is_match:expr, $re:expr, $haystack:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            use lazy_static::lazy_static;
-            use std::sync::Mutex;
-
-            // Why do we use lazy_static here? It seems sensible to just
-            // compile a regex outside of the b.iter() call and be done with
-            // it. However, it seems like Rust's benchmark harness actually
-            // calls the entire benchmark function multiple times. This doesn't
-            // factor into the timings reported in the benchmarks, but it does
-            // make the benchmarks take substantially longer to run because
-            // they're spending a lot of time recompiling regexes.
-            lazy_static! {
-                static ref RE: Mutex<Regex> = Mutex::new($re);
-                static ref TEXT: Mutex<Text> = Mutex::new(text!($haystack));
-            };
-            let re = RE.lock().unwrap();
-            let text = TEXT.lock().unwrap();
-            b.bytes = text.len() as u64;
-            b.iter(|| {
-                if re.is_match(&text) != $is_match {
-                    if $is_match {
-                        panic!("expected match, got not match");
-                    } else {
-                        panic!("expected no match, got match");
-                    }
-                }
-            });
-        }
-    };
-}
-
-// USAGE: bench_find!(name, pattern, count, haystack)
-//
-// This benchmarks how fast a regular expression can count all successive
-// non-overlapping matches in haystack. If the count reported does not match
-// the count given, then the benchmark fails.
-//
-// name is an identifier for the benchmark.
-//
-// pattern should be a &'static str representing the regular expression.
-//
-// haystack should be a String.
-macro_rules! bench_find {
-    ($name:ident, $pattern:expr, $count:expr, $haystack:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            use lazy_static::lazy_static;
-            use std::sync::Mutex;
-
-            lazy_static! {
-                static ref RE: Mutex<Regex> = Mutex::new(regex!($pattern));
-                static ref TEXT: Mutex<Text> = Mutex::new(text!($haystack));
-            };
-            let re = RE.lock().unwrap();
-            let text = TEXT.lock().unwrap();
-            b.bytes = text.len() as u64;
-            b.iter(|| {
-                let count = re.find_iter(&text).count();
-                assert_eq!($count, count)
-            });
-        }
-    };
-}
-
-// USAGE: bench_captures!(name, pattern, groups, haystack);
-//
-// CONTRACT:
-//   Given:
-//     ident, the desired benchmarking function name
-//     pattern : ::Regex, the regular expression to be executed
-//     groups : usize, the number of capture groups
-//     haystack : String, the string to search
-//   bench_captures will benchmark how fast re.captures() produces
-//   the capture groups in question.
-macro_rules! bench_captures {
-    ($name:ident, $pattern:expr, $count:expr, $haystack:expr) => {
-        #[cfg(feature = "re-rust")]
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            use lazy_static::lazy_static;
-            use std::sync::Mutex;
-
-            lazy_static! {
-                static ref RE: Mutex<Regex> = Mutex::new($pattern);
-                static ref TEXT: Mutex<Text> = Mutex::new(text!($haystack));
-            };
-            let re = RE.lock().unwrap();
-            let text = TEXT.lock().unwrap();
-            b.bytes = text.len() as u64;
-            b.iter(|| match re.captures(&text) {
-                None => assert!(false, "no captures"),
-                Some(caps) => assert_eq!($count + 1, caps.len()),
-            });
-        }
-    };
-}
-
-// USAGE: bench_is_match_set!(name, is_match, regex, haystack)
-macro_rules! bench_is_match_set {
-    ($name:ident, $is_match:expr, $re:expr, $haystack:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            use lazy_static::lazy_static;
-            use std::sync::Mutex;
-
-            lazy_static! {
-                static ref RE: Mutex<RegexSet> = Mutex::new($re);
-                static ref TEXT: Mutex<Text> = Mutex::new(text!($haystack));
-            };
-            let re = RE.lock().unwrap();
-            let text = TEXT.lock().unwrap();
-            b.bytes = text.len() as u64;
-            b.iter(|| {
-                if re.is_match(&text) != $is_match {
-                    if $is_match {
-                        panic!("expected match, got not match");
-                    } else {
-                        panic!("expected no match, got match");
-                    }
-                }
-            });
-        }
-    };
-}
-
-// USAGE: bench_matches_set!(name, is_match, regex, haystack)
-macro_rules! bench_matches_set {
-    ($name:ident, $is_match:expr, $re:expr, $haystack:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            use lazy_static::lazy_static;
-            use std::sync::Mutex;
-
-            lazy_static! {
-                static ref RE: Mutex<RegexSet> = Mutex::new($re);
-                static ref TEXT: Mutex<Text> = Mutex::new(text!($haystack));
-            };
-            let re = RE.lock().unwrap();
-            let text = TEXT.lock().unwrap();
-            b.bytes = text.len() as u64;
-            b.iter(|| {
-                if re.matches(&text).matched_any() != $is_match {
-                    if $is_match {
-                        panic!("expected match, got not match");
-                    } else {
-                        panic!("expected no match, got match");
-                    }
-                }
-            });
-        }
-    };
-}
-
-cfg_if! {
-    if #[cfg(any(
-        feature = "re-pcre1",
-        feature = "re-onig",
-        feature = "re-rust",
-        feature = "re-rust-bytes",
-        feature = "re-re2",
-        feature = "re-pcre2",
-        feature = "re-tcl"
-    ))] {
-        mod ffi;
-        mod misc;
-        mod regexdna;
-        mod sherlock;
-    }
-}
-
-#[cfg(any(feature = "re-rust", feature = "re-rust-bytes"))]
-mod rust_compile;
diff --git a/bench/src/data/.gitignore b/bench/src/data/.gitignore
deleted file mode 100644
index e7833ce8ff..0000000000
--- a/bench/src/data/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-10MB.txt
-100MB.txt
-1GB.txt
diff --git a/bench/src/data/1K.txt b/bench/src/data/1K.txt
deleted file mode 100644
index 1220b26690..0000000000
--- a/bench/src/data/1K.txt
+++ /dev/null
@@ -1,52 +0,0 @@
-wmnqiniqjsvai
-wvygpbgqiywjj
-prlzqrgeuiaxcwxylch
-y
-i
-z
-zddztqaehuhwxw
-vbopjluwvzulefkgfzbagxrxeuapa
-uhcrprarkgbkt
-hplldkwrklphwyqgbdcnyghlzaylljxtmpo
-qffhgzbdynpbzofasgnmxooyo
-otv
-naeyzexd
-jdyszuzrjqavxqxsbmwiwgykaytopflqvgpblqkor
-hgtejjgfuuqn
-hrnvn
-zplbvhtxgdz
-hfzkmccqodact
-cbhaxmpbq
-ghbgklykouumdprwwilbbvkzqpqirif
-
-ffzbmhtscplmrxswxvgdsaulepobxxuvsrybzgsdx
-rryiwliqrnts
-ygxfjwhz
-
-b
-wtetobvtuyd
-xicddxufbaaoopv
-bgccyvvsb
-tgyejzwamqbnrqnqxmwibzfewplh
-jahnnu
-orimkxzlzbqkuvxnhkvzvpjoaqzjsi
-egeutplxlmmrxrwduid
-sczrunwhvlne
-dxbfkwjevvrrbulmedpkocwgeia
-ilgchejffowtyxzigtrdhdkos
-lhwiyiaobunseolgahqswntn
-fazlxdmhhm
-mjpvaimkguvewbuf
-yqaqjiarsazxlukvzzufegw
-tueddrzuwrqglq
-ylpqvxpizwaykjfxzzcdjsjioxnywnywjijarkgvzvnxaidupbzzfjwvdghtiqcswgmfkxfcjlnqrxqseaiqfxt
-k
-bxwfbeanohu
-eeitnndinbettnlqedcpkqbzz
-xuvdwpkmtsleqoouokjgqmmzihubs
-ckfcblhv
-hfngdlxbnjffkslbuyunervkwrdpxgrde
-csrmrnvzrzwdxnvpog
-dvvqwmmvzljdywateafjmztebotavznkbvpgoohckcfumhotmfcfjiijlrkrijhkdpqcpvpaoctyyldeenlcooyeikzyrf
-fruqldidjsxqpgoacbcngpawwljhcjyhrzuuyp
-y
diff --git a/bench/src/data/1MB.txt b/bench/src/data/1MB.txt
deleted file mode 100644
index e57ccdeea7..0000000000
--- a/bench/src/data/1MB.txt
+++ /dev/null
@@ -1,52408 +0,0 @@
-lurnivpeldxtymqwzsaxqumiogvcoesbba
-ovjfl
-paoemcslw
-idngvumzoytmufqgswbggoq
-dgpncifpr
-xwphrm
-phcybglbctebyzlimi
-vycwxmrrirgjln
-aphblpronxirhosdfeitslisxjh
-avcwiy
-zaqsubdwzmt
-tismdabwoabgfqrfbsrkateqocxhenozppkxrlqbacmbewpglesonnlzckxqqfzvmfavvafgqtghcyoljpkjnqmthqflm
-fgzknwtkupkxfxtgjngyfvekaavulrzqtufq
-dt
-
-po
-gig
-lhhksqwsvhtelggbmfhoxxgthprgmyihmdpkseukpjanwdwcr
-xfcxuc
-
-dksupqvjtnvuea
-yppwvbvodreeasogomhslngtdpcrkbspivwyc
-rohtdvqsnlwfzoewvyjlenlghmnryc
-sjxlfqklwonyatrsikejsdeyorlvqzfalrrxmtxfa
-jnrhfxowpiewlie
-
-ywyad
-qiuzf
-xqdfzgaz
-ajnvharoczokhcoshzpkrubtd
-kuaznddsjwsw
-istgzzjlbrhjed
-lvqfgw
-vdgxzhyiiqdxzgypiymbthdmidurvyhyv
-
-ppzaaxedxglqmocfsjgubzmcfzxrzlyqhriknemstuuex
-ocg
-fjspgzsobhwvopxlggkzdxugysxq
-r
-fizmfzpwnddeflklbmvkjjkfdawsslkovmdllnn
-yentg
-hwxfjsremfvimgnjhrleqttmhsgf
-onfdmkjscl
-gwehcarboofnqyiyfiixdwqlgpdybjjfatvtapbbrwni
-xkqwuptgclelpftyincfoghkzgrrowejongmdgnyx
-addzcc
-
-rdjhsoycbpuupbvutcffqudptwzkzstcmrqiyqdcmxfmqtaeytuczrceafquxrvqecsmmzqlrpdef
-xtsgvqdveeubvni
-nkvphfmingy
-rdhitigxoljosfjhqtzjcgn
-baofnaohmiiatrmeyycthjcqolckkgkhzuliglc
-vrpzwqwvdqvxkimftvqymrndg
-pqsswabjoaycwwehsztfwn
-zrzbhiibuaxzolmmyeppyfzsqbuemhakbhjduczmtcwepgdjch
-igymkyybbm
-cfbqhipivztkrvelzcxntgswiffulgrplxwrycfhsunkclljlbqropfg
-ontzetosuwawovbdiyrprabpmrhhwuvdzr
-gimgsrjbxckmxqzjxsbqxilxlajsho
-jhhtbjwpl
-rncctpsbehmbzlqfnb
-gf
-qhvtjcrrth
-mdtncaptwudcw
-tcasoikbtuzpiypopjymyqmkzd
-uobijriwqxarxebhudgmcmnazvwwdj
-xdarufgvkrloxyqdvvqmngbkkuhetemgzstngowfzwnwxlkxyx
-dtqsgnrzzlafukghpoaprh
-mlqprrzifhrtzszqoylilpdbgrbjexqluitr
-
-hahnzbifasbnjbwtfpdzfeze
-eunoamdsckbgfrovflxqo
-jwzlfzzn
-zcbxd
-kebw
-shrqugwzxvswvtbdtvudeoyimshhtgphlwhu
-ixrvpmdngemeqittqlkjgxyzashtmiywnbrykzpzclvyjepiskfjubjmnmvcn
-xdhelt
-d
-wkwdeueq
-stsjbdihmrudmg
-guhilirleipwhzythycrzwge
-fkulajqofhqjbezxojgt
-badatrkkvjjhwfjvtocpdmrwezmfsjgjxbqvezrvxoix
-nvspoqpmjdyapxagpsgel
-fmjhuwbhsgggtqtjjurxkzrnmthkutpffbcwi
-cun
-nq
-cawqcumustwwcijlhxvkrvgwlotnhbvuyu
-nbqjhurrnhr
-jb
-lbcchnhm
-goqrlgmc
-i
-rifmzhjbtilihxclc
-mhosvmztowpptozuvrxzqrpvwaafnezgyi
-avzwiijnaeconafjdpazshchbcjprccmqdtszvwztaqnhwxrrhxlmdjhaedeolyzxnqbtivx
-zdyzhnlga
-nwfkfffptbyyiefwujoeg
-
-tqxrssfzpcfv
-ubq
-dywicnprcusnwettjlriwclwsahn
-phkafxcuwxtuwplwcghdsslylalacbljjgweigkuxvyay
-ucvxmkuzuenixgvp
-dpn
-xxnpygydcpc
-yixjsbknjmobbyjcifbmizrvetglzdwhbznnkbrunnhf
-czdytgkcm
-buyhpdondoqcqtsizotnjncpdrkfoeudxodifby
-atk
-wcjflgavuvtnzzxqdtjmbsurctzhkpmfjcvoucoac
-zhdbyc
-qtrfndjbq
-utfsy
-fqnq
-gw
-umvpcmfgkdnyq
-ybnkymkrtttfjtzhoelhndynkqibgpb
-aljkxwdd
-perwvzzilkwwbugikir
-payegrmxkiwxewnxuhaabowbdxjwa
-mtjppbziau
-mgueggvazslxyoupecuhwuccbhq
-cnqjnafmgdlszaahjcngmqxt
-gf
-nbidgnyla
-iwxtaawzkinqnasnxepyrtyzn
-luxsqowjmxditkixqyqecdhrcyqpr
-anrwtguyyanid
-koh
-fuzvswn
-zwmgqehpwrxsstlggsaugzajclkkinhlmnku
-hbezqarsupmpkyjooslnfesgnecmvrwoidtpwwwujpgbwh
-atxezvmubtv
-ldg
-kxv
-jdlbgwstlukhjltumztolbnq
-jghffavylwzuezsvjrlvyluzwqcoqkqmxksabreyxrrup
-jjcuziqmkxcsurgzkbvxiofxktceyckzpt
-wajmiptahqdffa
-zxpdykjnespwayhrd
-gbhyfvhkmjlalgewy
-fykkbejiifxeslnukrywapdwrmemtmlnqfwlsrzqjudekpnqyoxttbfzkjnnrfopnntysoyierxf
-baxzgl
-teitmdgptbiyqyfzuarseoggzqonnqmjpenulcltgxjjswcswwwdyylmesjmijputni
-isuxnrgpitfjeptcp
-
-oa
-hbyartlj
-tkwvtwmqnhvtvjvyluzleoszexliexjonqzjrk
-uvhopgtuyaqkzohddnwxwnqjvnedvukv
-azavcilxzvk
-abzjsaezxcbbno
-bek
-pwec
-zkgzo
-aewvpfvmhxqtl
-jxokvqmhopbidlvlpml
-aytzylh
-viockdwpke
-rguyauhqjy
-nxbbzojassadqorrbkzswezjfxezratdur
-bbtxtcdxrstglgjwttmeoraxpnhmocipud
-ij
-oqmvbvzyshentdgqqykykfjds
-dxxg
-
-nukjnhyftygdkmwdijlkoknyzvbxhgvtoxauxrzfyxykedsdxefrua
-ilhvvht
-uzwzq
-gtzxxdlj
-xguk
-viumenzmyazzgef
-wsfdppemtghsoddwya
-huxohulwfbdcpajcrwkzevgv
-ymvihtbudfabnokynvlyvliqubauennajnvvqceazfuismu
-gjugsgbbuoehcwktngbjjrdporgdjfnelpwpahvf
-omomjp
-qypqofjuiewwp
-kpvsarjgibtesfslvuebmvlvlti
-
-wjjdkookjttr
-qkahofej
-tbnubjyiwcbabzf
-yluljcwmoogzkdicimrpfeogrlbtonugwmyrjdwdamnbcw
-wosvoyllbarlraqpcxfjhefsk
-oicvqhoylsyayvyyqcar
-vxsszdrezruazy
-
-twqltgvdv
-gpnc
-atblyacykupqy
-fkzkj
-bgkuwoussbczkpzuwumbomhxjoldvqcxiojwuxvrizwnm
-viftuaow
-whmzuhozeqxtunhwweytacqjylfzuucrifrkpmbwgqbzkfdgknjarjfx
-i
-ihnqeyluazpjukboxjdythcdfflqjgm
-houbdzaat
-hjjjjxzpm
-pgqtbayshguvymw
-joihwapwpzpnobgpemmcer
-pmobasl
-rricqtugahdrpicylqtkahgkycgienxsx
-pott
-ikvqgfgts
-eatodwgrpnjorceufweupdvuzypilidgyqqskontai
-gzprpgrdyazlnaxojrepzqcitiisormpheomvjsxzzifsdmsohg
-nf
-yp
-orapavshmmeezarqcp
-
-uxcdb
-gbd
-hexlgtvrihaaxbojvcjio
-xbvehwpfwlmvttqnefebgkpgxblslnrisyjkwvbuntogdzzmqwwswhxd
-wmwugjyrkzngheclafgvolrkfngnwkfnj
-yxlkivdvdrvouexqxuayivimuwoazsuopl
-ruvnjgrqesmldixnkxykvizmfavwqdefdcafzffjqaygbcczpxhpenrulidcfmojskueovrucozb
-di
-hgdnwpztnnirrx
-gfktziqvqvwvjsbbflwxkwohl
-rdjiemsqafsoelrnwkeoqvrtaokiispwk
-gfxdeef
-ztqvjpaoe
-ehrnbgwjwtgua
-axdeqhhd
-o
-kysjfoaa
-kvs
-vbhe
-hspmcieaodte
-czfjwyzvjsqnaiqo
-ttvorglcvvurqxo
-mhlvqrfwltbzegu
-noiyjrb
-fhii
-yw
-iryhfods
-vjwpmhgjplmswitisytlfimqhynfkknsoaxfdgwgiwdmvto
-mdwqxiaid
-vfqjruuyqnzmyeatyxetkbr
-bpvigiisjjsgtgfqnfzsaiexart
-snsxyhussbq
-rbkznxwlspfdviygpuyq
-ecpheejrfuxry
-mkpyu
-mnngkkcvkzqsxh
-t
-
-hi
-bpqjdsuenfhwe
-gkjuhlrwmnujyvw
-r
-qrut
-bsxungbkyupgjrodehuzuljfemnsxllgeicfxjfvnqiouocnwvxqqesofeicpmjfpwiccekhqxllnujelnrkdamaonpxrxdsz
-fkyybsa
-v
-
-ooljoocgqkeytnpkuhagbrayopurssk
-fwnbyvefbmmtw
-n
-
-
-udayoc
-cacozhytmognxjktajrcjntkwiimxulhbsts
-uoigvcqfqucbjuyliuctgaiterslwggmgmonksjwamjuvaakmwffv
-qooemnm
-ydzn
-b
-quyxljto
-vfmmyigpbcbgydxpaujxckumqknumputvskgkrkyljlcfpqkkxmv
-zwhvrsjrjzluvoiyldh
-yssofepg
-hkb
-pahjqykdeqid
-skh
-ivoqeynuc
-mxpzyzspbfeivnbmuritfrhr
-fouyaeaphjwoqapxkpdroubbbcejwacnchi
-ebgdborurz
-tkcvhap
-sfa
-nynoilgadghovh
-agnzojlrfudlpduwpfa
-tuczsxhamjmtizmnbhekryrbqznwvclhdfnnmmbfzt
-vyrpsmhwxjmxgsirsqmxhxaibuzelcfsyicjyxlbpckvyfuyhxgkxabnkxcebr
-xhonqxnqvsxpne
-lwrmbbiuxykmxhbyejexhdqcre
-gasja
-oxmlgparucftafhdmcmfedblpqwdqoataximnqhce
-lelhtgbekgjjwpfov
-idfdajxjualbqqhmruzdyhgpjkaovyyhfzisroxmxxknimuvbelpafouucllfypcdwshgeks
-c
-fw
-cavxzjpgdwwmgdtm
-rcayvqkotqhlgsntzbkukyeqdlulgbqrxkonpjekieooostemdxvvgaxirkjrgompnva
-pwxhwsbhzwcdjbuiuadjtz
-es
-msohzuegilj
-uqshvdsrtmvhpbyoj
-vsyvdjuhexutu
-jvo
-sqkstseowrndjzcdtmtirdztsgjt
-szvasnjuropqfkizkxliomesrwxqohjdgwsamgbuugpopyjmizzofjdstoqnovhirqknbplrolcbhvbkfyad
-oh
-cnmbj
-ylcutagorfwjgsrjmcdhmob
-thnqsk
-epxqwbq
-dnaxqpucqnmetzrurtbvvm
-
-jwu
-vmxjdjgowlmvztriaeiyhpvrljmxctjibzaegtbxmsplxjtqyorrpcrwgxf
-fq
-mmpvbi
-iiglrlhhcmlvz
-huodscoincirhjoyudcir
-
-eowpubakvuupzopkztqulaomihbipen
-qziajz
-cjbtvhhrdcgnlhq
-yhukehlq
-byrtmuoyrdxvmkebqdjlyvzpovoiqtieebcwdziuizibwce
-wlswkgfuyreilnmntnyqkpvfrtvfickiweooxreachsg
-mknhaifhxpanp
-cphsjgrvcrqmunzli
-ljzw
-
-voot
-ajrgxcppbomlmtswkbjb
-rqtzflxdtvrqrqhovilnljtulxaugaunvemvdxiowtcionqrzacpplyu
-jkhctbhsqsghdnhoqfhlmdarodirbspmdg
-mupicguoqii
-rn
-jvfsujuym
-dyswiagw
-dqsatrhenqqtfzktgdqqkctjdwwjnpagctmmzbpmmjvyjllguqra
-vj
-lsecgjrvafcqsnhwwpyhnoftqclfhaejwvwc
-i
-azf
-yaczdquvtfkzti
-dlpkibnuhfewpgrkftrhnwglpwfqwxrazcuavbtiqwbkerzoukjpukvrwmymh
-
-yjwmjredwa
-oyskxdifaz
-qkwvhawccyclgktejblrh
-
-enn
-jswzqtxfsmfcbifsvhmidnpgjxtsbcsakqozzmdpmbnctdziwcqzjgrwquzszgzfnp
-siqgiun
-sfu
-jbbtea
-uaxjspduynxibchvxeclprpg
-mhialngxtoco
-y
-c
-krlhrnucmfpwtkvltrzmgmtktzycrexnegcstgcdgelmhipvnxuibibziytttffxt
-pobgeadjhfuschvopfosnaafpoccvdrxvstiongch
-nxdq
-tuntbaqtown
-yovaeasgtyaheiohpttvavmxjmsknbjapbqfweptitj
-yeyjkecqgiwxbboarmtn
-
-cqxghvmuqktrxrw
-clvhylt
-djrvxekkhl
-bqeequjietswvzakqvjexcwkdviam
-hxxkuxlfxszkox
-khnomhbdodiqnjwbsojxrxzjbizjkxhlttnknouzotymuopap
-duubrewmso
-jitlkshtohvxyjorkdfqh
-iopdxuvijtueacmxaqlnxjyv
-uhfvklwrki
-xk
-pkrzmrkf
-apysqntfccr
-liysecvurqidnvyalhailq
-
-vjcjayicz
-rmqxrr
-niemcchbebpymlkhbdtjscrl
-stih
-dptpdkmfkhrvpr
-s
-mbweqdxztoc
-ftjmermehrvpuotvidpkmykvdw
-afqanglqburog
-odldfkoyogu
-kebqjtf
-hfokbewshlzxopzndsgrt
-kwaixxjpqqheocygbszejbrx
-muxuddlkldunhktxvgyfitnjldzpiouvdtdwayxifftxdqsjzettbsxukitnexkamrspabpmzzlmphefnezzb
-kxvocotthivqngm
-qpzixhdaymmelceikrjtzxiim
-tbsgitvfdoqjpbrikqmmyzfsclofqnpnkqrbk
-llqyovkcqqwpwgjam
-rclzinxxemvdloguqvec
-invkjjclkjwmdrnywhqnhjqfeybhr
-qnwpzkbxtfdep
-obn
-bzmhdgq
-omwh
-kanyuhdtsorkj
-
-axuzuucgodtcsetcetsowszqiphzyrdxxbc
-ohswzkggaiuqtgoqoiqvjs
-waziwpvirwgauvifzvujra
-rywprrieqhvfggmdpqseoqvehhgclyx
-
-iokmkgs
-f
-vbsqdetcsrkxkiadottsputsorkzutbtwjlpo
-hsgplroszzyslyypwgozghueznylmxpzgvyshcmwgqstjfgxtiphhqmdwzspsnbtjbfpfl
-hz
-mfdtgvrlxcovsssytarpotanhb
-rakeprjtfhjzxmxgoenohirgrjylrpzlghnqvohbc
-
-l
-rvuojkcowmzzzbpfjujykstqyybptukja
-jv
-mwlzyfxrsedy
-
-hefbewqhcemwrjlhflbaeayikuztgbgscmchacbanwbvniparmollrwlmk
-exqabifqygvqpxzsxhlquppweesrijzlvqrevdr
-ojp
-jlufyglcyxqzibqbjcnlpmw
-dmrjfyrgpjgszdll
-
-nwhokhzzkiunrnt
-jddwm
-ujcshqmqppondwwyxlpeuiwq
-
-ywvgcnyvksmpgaih
-rlvooleqpuwnqarrdnnnbjtz
-t
-fzepoanzacobomwlnbevyjolwtbbcxz
-dammvkyepqwlurndmivwfjskbxpcsjlmbeza
-yjjpdrpgbepjayjdrtszwuzsvdtrlujyceljx
-qjpwjmibrpgvvmntotcqzjwgvzohanurmujtcctnttzfavfdtgvuntmpcedigeszrbowfxqvkfjobtjgszzsfeayrywrhfacwzr
-jmqjojjsjveepihgapghsoiyb
-wjxg
-eyzfwzb
-poivazshzsghsmvuwcw
-slshsuoalgwlbsgmsmdym
-drxpgmefbggrlxbiz
-weardwbfqxqjskhoeiawskwfdpatjashiwuzbnyiotxjydk
-bpeadyzhokornhzxayavzvjbdlixkwpu
-hteqiwbecsykw
-nwxtjzillqzvbjtibxqytmeeomyzqn
-dw
-wufyfkfdffsaeqqtdzhv
-qejqjtidm
-
-
-uo
-qxfzuynassgwgzrrbodjfhnhuqphv
-ftz
-ihqtrihpkkrh
-pqvtblvmsbnazaehqeszeqzczxltehtsgijruufdatctzivsawmyehluufto
-fjrobtrqdmwanhqrsjnghcmemuaaybtgjqwbguufhwmkvvsuaxqotv
-sqehweuqfcziouirakrpqrymatuogonnwy
-wicz
-vdupwqsbmwitcoaxxyhyru
-ai
-gxfi
-
-fbeyqkgabds
-hxaotyzkxyxpqaimkawucex
-oczvygjubgkppgoqcbfbtzu
-torfmhxnvkex
-sahv
-xia
-gmcuvbdycwbpgpttwrbpffjsymiyaxm
-or
-pqgwuuawqajewszutgykhuefsoncetdqphrtfsboxiotmuyswymytznxhufagduapoipfxdjxpsfxowwnwx
-td
-j
-hysruj
-ft
-gseymxuedimwohqhezhzzqpmxhcqbwzamdpqs
-qzwdjhrsxsocdtdhchqkhrtlewpdpinzxbrbrhoajnnjldvdjuqdxaekvoxpucfqhvg
-lhizpfcjpdhrkuq
-zmdruzllofzjthsvspoqgx
-emyhchqgvttlljugdrkykrxkximeqrrdyjgoglccdbwcq
-ocbtmfsnqwy
-pfnbzirpdgplgfkyt
-tortumtidktlgoywkrwtnfodvkgfcemmzgjwgbsllnjnijeyfupzpxszqopfr
-gsgqorznzsyqkfhlhjvlpcs
-thzdmmcvrgjpoiuzatzosznunjvjryfaigcb
-wzxtminkdxwrctkyqunqzrxh
-lpi
-ub
-nmquhllgmqjcclzklggpr
-weooiqitkyleovcjpdzgnfdc
-rxrenbhxnocpiguvtgudyrscwolfzofqfcyncxjysbucesoedncykpba
-wdhwwpvs
-qlkdhilrvdcqtfsrphhotyyfiumexvdbgfynncdwpbxpa
-pspfqpy
-y
-gksinhpqhnvfnqjajwusvoeh
-preuqmdugmtitzpl
-rojshgeglrxuxrhjecbttgyocidmz
-mfvbukqkf
-
-bjmnrozkv
-axbzefroeyzarslumoxmgfrercamttjkrqhrzu
-fniwpwnqwblmviogqysazvmmkwexdnlvgdfnlmpxlyrvbvfinfitsootdbxttknobanoefqdfdwcpkfwsqxegbsqbedipgbd
-
-jjwuejvrmurtdhoohmbioilmoowkwfylczzsyumvdroizwrbtrpvkymv
-nkgtxfykhblenfynplruwlm
-jthtazgaujrdcsknzcxw
-i
-v
-eujcobsujtcjgcemkabxarivcq
-pn
-xrxzsqeieneazyvzrxbwgyknpccchpujcvgxc
-mittz
-xbcfagcwitarqggeqjhrxtyikbghvdpheglikgq
-ipjysqj
-kadxxpnww
-vzcypcspttzbfpjkrcjonvhdwqviktrw
-byhnjivapwuzdnsyhbu
-mu
-czquvjyiurca
-ylltkooipbcstpilryinyatwhwmxzdwea
-lprnbygxnckndikvclwzkkaszwfvvorlbpsdtt
-vldavp
-zysshztjhqdkwydjifxsrumnwdkhacdapdxtskaxuaesblkixyxzzpxahnfbaouaxvjvlmbrhujfmrrgzdqyuweiqkdcbxzgrfzjfpqrzfxscptxl
-xppsryjecysyhbqbxdcxyhywnmdulgomlsiwl
-kfcztrplbiqnyzct
-br
-lefuwofghywkztvpyzctid
-hpefcsdzcrfqmfpjaoxtp
-kqh
-ycnhzhdsjogjbgdxsdgk
-rxzcdbkw
-veci
-exxhibzvszh
-tflepddhjfcoeqnywvdsprxsfujjkgbakfann
-txpcknhcmwiihyjhireald
-xpogezgjvzutlphspgyjwdkvcv
-g
-ojomz
-fcwxjqwbddnkrrpdztwwf
-wkr
-webrngbppvcgzregds
-q
-stwwttoenfucnriejefymcixzmfnfjkjm
-ucdlm
-utqqt
-l
-ljemlncqiujc
-agpgemjxhgsheevtv
-dyucg
-ykjnrlyvcwdpxylriypusyh
-awtt
-qjmgfoqxdjlzqfzoardjfnukmdudzlclzadybcm
-chpkdguvksckgcgscqqjsrjqsgqaviqpckptq
-dzlvcddwouquunho
-mtimbbmkji
-tvjhaxtadevwkvahamalsddxwgflenmtrijvvbzegrfxfpnnzeowc
-oizcfnb
-sgxsfscxii
-gafa
-fwqovbrojitypoinhnshdieo
-kwljdpqexipopeqwuxv
-uo
-uipewaludaazwrezaqtjwhumhydpreglzqhwyptlzpzposibmdulwsnztam
-kbhesyhlyinjmlyqcc
-krzprkevmuhyjsxdzulcjyutstdfyouf
-nl
-wmnpnel
-ajlrfofqlrlgnsb
-zuwkobxwghtkugjnvsxuhwlwj
-tuire
-kmteitfc
-zwqvemaccztxlqjyzn
-vtdxyjfjeisgxjqjvvwe
-dprkkhedaajuupmhubllnikpjgnmuvcnjpyulafofyxhhvyidxg
-
-
-bigvhscbcvxdhmddbofuquoperseojyzvtsmmablynurdz
-gxsfezfsvuytshlukfsfzbtvrebilpsigfyyvmlndvsfnkoctjmeapeiezv
-cytulzsvqmkroyzhnuq
-ddpptvhamgioduyhlyuslmrkfhtjsatfzhwseewobqstbpftqlnmziaum
-ciucsuw
-sbvajjzrnhpqoqiwmwjjgjasgusvlqungk
-olsjjudlxigzlcvboifdaadakdfmssz
-eodtkhvqz
-fmnhuxzrgcnmzhssextyyvm
-kweil
-vkcipbtteaxlxytliruwqzkajcmlefgwffzfwmgwgqbmhebscllzvhia
-rywflwhvcuwqmnubmisjexgsqunrpyj
-wzhdwxzxfwjj
-ajakkoumskshlucmpjskkottabnsbwarxfnnwf
-pjkoyudfzhaiquypdxoxwn
-bkxsqiixozwpkbrxphlzoyoogawscfbyy
-oljnmrxpdkwvaehpvk
-phiqfhnlspfqy
-kkvnryjtuv
-scfgis
-xoqwlzlk
-igxulvkkie
-ni
-lnajvzurzh
-sazcrsxc
-cevoyoioxtiju
-lqzgtokwdeivpystzgtmqfxocasgqyh
-suqlz
-fyrcgxqqovlalerylbxniowwovkwhbvvpqebonybov
-wbffruflvkhelfmyrilavgsfsfkucimaglmdviflvxamoabpfbuszayrytjulvifauiozljrjrcfozq
-bznkzdhzveswjlnup
-bjpserdgiqfthibownkjolzjudfjeqsnmmhzkxz
-
-erxyhvgzlnvlqopyxfknovazxedjufpknonlksqimmxefzrxtuohbtaoocbjcx
-dsmvkyi
-xigyradxbzxsvfpt
-fvotravdqeqz
-pvkup
-nkwijphgdyudxpwknlx
-ayhhhibeigbpowtzfvbwnqi
-
-vcsrwbsztntckkaz
-dwrnaqggcvedyhcfgilbenuiuoddrnfdrak
-qtwayxwerhqmitzkthsomgxd
-ptnuiadfcebuqnkcr
-nmgjuzbwkojhlvndzpcozrpovngjkrabvdgrjhrgutga
-cj
-euxiopn
-ldtq
-cyjmvehfqzvybcyqisjcmqzydnyvulvjsezii
-ffrkyihqkyyhzbucv
-xvjvffmq
-tqkeazpfgbxgv
-oqvmqrwqikbgmnm
-dbpipbvckftwoc
-dwvyxpvllwwsjrhuaxiwsyl
-vfyxbgzlnhwhobn
-jjiiblysmudftrhlqfnahgdqdaufxskkwskejpnocewdjdouhwwg
-is
-upqjetuhnpzm
-ykulspa
-zanwf
-ziyfimogwzfkcwaqqs
-xvawojxfh
-siriqyy
-opodc
-zga
-lmfuphlxhrebtxbzvxr
-pxqjkgsjmovtvxfif
-fslpjlzpaqwjjsmxscbfypavbslgl
-stvgvr
-figbfld
-ubcqamph
-pgqnocludxbqmeneb
-bncdhmpqnlrsfpz
-plogwhmuxdecremkpgizaoqzwlznzmzneiqwfvoisiotqzmvnh
-mtmpxzbyxxbcxunwhpjbepgszpkraiwbvkppdnhrlgrmdq
-oqznwusamqwygupzxlrrlthwvvdtatpsoucetbrsbmkxxfmkrvguqbkpvoyycedwvpz
-hilhp
-acpnlutvm
-ahsdlp
-hjgzfwbxycikbtgyh
-kwyiniwngxrlkgh
-
-thrnqtcbgjdceqzg
-uedkpubugnycwvytwluyvmtdsrpgfc
-qxpdmorb
-cryieoy
-jd
-ysdgkkmvyjfgfiarltxsxzownw
-pdje
-ksemfdocezunlzbqfqqzwxvoczgekwqi
-ahwbmdfzwuwiugijxpcxnudzaywmfpfilxrcdxj
-bmugngkxybtjfdvpjp
-gvbwsxwnqcdcvzeja
-cpeqqtzamyqujulxvzswb
-rjwgsehgdofuybhgyadvwgdweoo
-awhofuzuoeaiqbmpaugydlpvm
-otnqwuzgmrpzkxw
-ml
-qrtlmovdcrynziolmikqqibj
-ysudpclrredntarcfrfddupw
-bhquwmg
-rjmvcmglnaaojmmbvswtypjyyhclhgjqwkyunugxydewivjynjvd
-wvujoxxujygbv
-itmwbgllgnkvyebflmsvsu
-pbpeoakkszsmmwnvvpimcvqwupgectojhtdorznjwszutybakubvhoowpebdeggflf
-onmzfccy
-cxzhgaxoiyrvjitiluixudigwlbkizkug
-quvhokubyukmbhpztljscqojinuhelqirxxlftzmxqe
-umwkgnicccjcfullnbxleclupdaxrqmfkooicrjjzrahphcjdaleppgpf
-tc
-imdgjmik
-hbe
-jack
-aaqqlifcflkqjwjauzptmwsamkw
-bb
-rxboedfckcstmbwjjzlh
-sjdzrebsfkalxvcytxblfnnzavleduscoqdrtvyrfhkk
-yzco
-iakqibkwshxzsqceh
-kpxiflpnocpbnc
-xcr
-keqbtykw
-fctvsippogrhrzltkoepm
-dapggwiqodnfccyftbqthr
-iwhlnycnvrfrlaxhoqmhpjoghzz
-z
-in
-xctpoiuritglkbzkxmbgwecnazwqlihtgpxkzgnqgcseriugm
-jurtznahobnvulbupzsmw
-xbuclhhn
-dbskwd
-yzsujovdojforwpcnv
-fzjznpnjpzvyisgepkvfizkyhhcojo
-dksigxulqptudp
-sdsupadwrskaaisrdujugvoletcpwyzhhjlqi
-xeuwb
-ecflikukqavvbpaoagclbd
-wapaeu
-ipk
-xylqv
-ziic
-twnel
-zu
-xsr
-yalnakwxyntcsjeoutprxdrfkxfrnitpwnnpjreqvuprpu
-zxyukhfvopljfqcqyxm
-kodcoyujavnhfbucomodvzrmwfhi
-tjmxiwik
-cvotdddpaz
-rdd
-ypqywpzpmlwehyo
-
-wwkelqmehrqfc
-kez
-hvkqa
-bvlxe
-oeihysbttbetnepkvlqkpufwhnpywdwjezobnpcqxrwgjagmvjvzywlvyz
-kfxlschvsc
-rdbaepke
-gwburugzdnpukhezoxahytan
-wdgfbeqsnrbvnutvecshdgalj
-naglgernmmekgxdvvxhcomemahajdbavkcckxvyzewhwnuslzhhqmwmvikxcylzeivhvmxxubgvnuepwkuzszglxwjhvzjgssic
-ptbjr
-mpskjcsizdbsaaoanue
-zhrnbzagerwwydoqdsxg
-bgsdupv
-yxzaba
-mvkxbzuiddggk
-mdzwzauqtwzilrtdnrqkmduieevpigwbavbswkrzfsgyjbqegvnznyqfvznhzotujlgkryzjtrknmsqtcnhqumdrubipzgcmgrqzgzpcilawcggu
-r
-durnyx
-kypooztpaiwca
-ofrqgvyyewt
-mtgtlnedpexikpkhdukuinkxmercnnorrikdfsyrortrnlrk
-csfnu
-vczaatusafcyatgi
-ocovojsyt
-iuczbpz
-qltemttszdya
-siirgnxcmlpmlnndjeomymagfxknmlruawfnggmsfbxxtiwxur
-rqbfcmkmrfnaeqfmrlfdydqgccdppuynpetywirwrgyead
-gevrmhpvojzxgyijsrkfzyucbam
-ck
-iaqgfvvcuqeyuvchmhjlnlucrmoamjmmurc
-ka
-zlchhwmeqxudgewenqnlloofhydmxzenvnfrlh
-dwjfqtrxlhyqlyytgqpwpqlklpvyxsiql
-qek
-udbaseyuuyrdf
-c
-xy
-ggjkpppddnmsvmtxltsdnjjascpq
-rlvrbatuxxtonccwxgyhzfrzdxzgj
-umwicopjelhzjioicxvjbt
-ddoeeohyrkjzmggqnl
-tfzxolldvyodhv
-
-ludtatejszfnbbauwkhve
-cxgfzitkjskhfmevnabngsnklorliyvinqcpiyaucrbvqgxrrknhvpuber
-fnouvqszpiqebgozd
-kiluzqnrhyzkczqarhpkcwhpzw
-sycgclsdczuubitrgvvsbhokoxjwocneyueefee
-fqljjcftjijcbleizqmzjuwtacpwiinf
-lvcklsrxcmdsmeq
-ulzaj
-kma
-
-vkjyiiiggwukgvipriztesetjljyq
-bwjszxlujjlwrmnofivlsbaapfcnmncukiytlmewam
-t
-
-jkqyqzflshwxnhtbtvcnsouaneizkstnustjgiwvoxugh
-oxrnmibjxujhtfn
-rtgdjzugnfxijvbndprgmf
-yimydwriwpwvhmlbufhechvtrfpmugysezhxpreyynwoaayyuktxdnecefima
-nsfukzwihdsxyxnvfnbaqovbspdxkfncszuafqyvemoimzgocbwuovrhrakfp
-htlrycffzqstbdrtwqcjvvrxq
-izirandcbbtoqwojkwyiulptreilne
-sxahpr
-yitvopuqkaqzvyzlpxhfazsqbqgqi
-nirzghhulwmsztnvtvwpzpwgjomrcrlagjaryiyzguzfjtftnqsnbunhegyqatcbutlalgrfrcfhiunwmynrsbzxdwolplno
-l
-gilogsqguz
-gutvvwffkywrityn
-encmgrptdbsknkoae
-ou
-avgvssdpjlplallcbtrrytaxnohscxzjdtcixfyt
-
-xhdgkvdohzn
-h
-zd
-shjorgnoqbfdhlgixvnmkdpnmmifzreoplnufjmncyfpsyvvgkinqzhcxaxbtkrhyphcua
-f
-rswdqzfruoxtlgdmfzjlxxc
-s
-cbenxfnzhkxp
-i
-jzoqzexpyvduaeff
-rznldvtjlcbaaiqotshatglkwozplwczckplqgkm
-bzddrymebcbyulufxsrqrrpuvzjpcicfmepdxcsoiwebznvnbkxitkjthjmsvtuley
-
-awllppinnbcqiauzfdmpnhvx
-xobroavbwtgxlunbefrliqmdrbhgc
-slxgmcktg
-rzsxdsodepipeulacrewfwdfnkxyxqlkxq
-dldmrz
-xdksas
-zolbqcqmuqv
-toksnzlopbpygoedykumtz
-hmqsetqrwvofwxlz
-coql
-cxnbbpkglfnbzzefvbhvbbfxfihssdftajbrjsmqvfpaknkmrwftakxsptcoeiualbvdwvnnvxczptvlgubseetxzn
-u
-jqngkkf
-hatbihjqtvaucgekuch
-nqvevgphy
-jvgblfgvrghjtfsismbypxuczoetvsqbgrca
-tmocfreofnrhsifkwgnfztrvlmycdyfkgzioblskwpjikmwbuvqtpwoazzphbfjitaektcjlruulcihjmvlkb
-kl
-hw
-dlvrpceacowapu
-rltwsybpinxlodhd
-bxppsqbr
-
-sztynxnluunryftafgpeonjfuewkwvkukglsxmabfpnm
-mhiwcfizrhl
-isqqauotknhjhxrfawmz
-yfboylcccoun
-rmlonldptccfyteqcnwxpxi
-egpvdqbvtaccmffjyxqkurqxpapjbalpgs
-udv
-yeazrxwqgsz
-tzafjrti
-itvpyahmrojtxietxuxwfrrgmvqgydmoontbsxqdaqkkahfnggvsgcxp
-w
-ramdvaiilnil
-xliijlaagtewwevhffwkajyiryuyekhvmhblboddycxpiap
-olzgqprncrhibtmajylwysnx
-yoafkqrnnm
-kx
-iqyknelqjmlhszvsaopfc
-
-agyjao
-i
-exdo
-yzkrkphspjwujvkaljcxtrtoqpzhdyjphuxqcrrfyzaa
-kmyfmvo
-pvarpjg
-zvevcpedulieaablylszkqd
-q
-vlkyovaphgahviftontysroqgymztbfwknvjfpkylnusigwxztjkbwqy
-txthllhsexg
-mdbabgspwffeohbsaridffdnnv
-jqcfeznmlanbfzizoafvhkdhddnanwoja
-gcrpxipziwcvunyjew
-vcgcb
-zlehfcyncl
-dzpdqpaajzvhjvuqq
-sosfvvwknmbxcxwrhinpbubveh
-exlawhgnaovtezntqth
-mntersuvizkttpithlqkgwnsz
-nrucuwfjvi
-kmrkiojrwqnzozveiwfhygvvypxqzrhqdmnd
-fdxlcufkzwbtrlxmugannw
-qnxs
-nrdwfqqxpniiqryxevyh
-erlfpfdouligmhgqmdyvfyyfpggpehdmbf
-
-jwpleiflzgmggoeceitobqmvoyilvgrprnsbs
-qdsbyxxmdceamfztdigniwmobxauf
-rz
-rymwmszastqkyivvfkepvujmvojnteiehaafbgrgruczf
-bmzcjwhdksvxl
-nww
-irypkgzubxc
-ceenylkldrvckreknsbocigsymkiekganzckmhfeebbcvznnoqdvwikfxpoebrzivonbfyyhdukeprefdxnfggutnsxirlrlrrdkftycgz
-gwwfmpehlpznwbrdgnvhdgfqzghclbgqrbbndiczv
-vcm
-fihlhmpvahodonbmcdpctuuipozrxuaa
-mzc
-m
-csaxcrosjwsfwitlwjbjuqljlutepvdvobtzmekkz
-wwjneyki
-tkhlm
-y
-exd
-wsafoyhj
-tvuqekwasps
-jkqtgvyasocicjprurbzjdnknkpm
-bstdkdnvldjfbomnvmcvpakwofmubdibehjsjyeqntctwzhzoqtceificieeqpbitkozpjvwtxlgkgmceipdtjsfehukawcm
-
-ojiuxfehg
-fzkqz
-dmucbpayawrmlvipffiqbvfhtthricywocigmbnuovlswwxehatxnpiffbdpyglgbpzf
-zvmzyjzazwnvxlzyyfiyisextqslxh
-gq
-ttgfnjexwdkcdbnoseck
-ivroajpwcuuuvjmjqhheeqwcfg
-noan
-uaexpqzhybdbsdavos
-nfhzgrmvfx
-udi
-bgxdadkicszdjlypzcxxteycjwcr
-snclpfdumohvxhzn
-ahdxkul
-g
-neycyqssqcdoaujvvyiigalmimrcvsdpzjcfzzlhlflphshcgktzazesmmcyquhhicdnufippjmmdnzlnqxumeomdybvogjiahaqwklimlkvnvtkforlwyfsmogiloavxdgwjiddqhou
-ifqeavcsdcryo
-encv
-dtz
-nfj
-miph
-aezvylifwvksvdirrbwhcxpemiekyxtgwrtobbourirgwcpfgpvcr
-q
-dflueltrhssyzuwcvrjstk
-
-dvgsezhdtjenmviqmkzdtuawiovmflslepwqzt
-ot
-xqmwyggirdtiduxwolppuy
-bawkhyfmxiwddaywireuxuqoedgenyspyaeyvcabmsudgnd
-y
-tv
-qlvqmssontnqnx
-uymrlgsgudbki
-fnzwmsbilzscnhwllnannfqxrekmehmasjvuwaofmqkeczxrrmseezenkkccpkhhqnstice
-syjpvunupbqxuvdruzpyqqjdsqwevvursyvsqrxvdkwyeudutxozqfnrpbidap
-bmggzahdrzrbnfuwtypiowxfmmu
-oqvgmoklpiaqquakf
-hxfqnnvyyzackwutjdjsygf
-as
-cocdvshycajafamyxcpwqvfwmsajuvfpfryyuyov
-geibbbkegzblrdnesxjvarkmqthdqfrcysnedgiexevmumzmkaleovln
-p
-rjmwrbjjprjeohccjshngeuxejydbhxbtibzegfiulntkjqrlxanzyrorxeeaxpexqnbejznvwzkdorxapyzjrbnwlnejjvwsjrdjyo
-euhnpbxmgfotwxybqwhfi
-niijrhacrxruxdzp
-njlosxrepay
-mhhphplrdvwdkfnzvzxolymkvtgejasgwaaorsanamghvnpf
-latptuhfevxzphkjgmfsjdhybeovatgruzrstsu
-hfwnw
-opcpxed
-oec
-i
-dglrofettkj
-ffue
-rya
-amwmooazgnsdsqysakqbeaztvmlgmkanbpisie
-roogflpuusjgehefomtzswsqucdvncurdrwwoyaxyvbcajngzf
-mr
-esfrgxepgqbgbanugzrerjqzhbg
-xaxifij
-i
-lskljpcpcpivu
-rhoaklt
-swveezxpujhzhlknotgrlmkrpeehnhapeohyhvwnniu
-jueobzl
-zhvdbembvgnnedz
-xwgnsotxkynuiabf
-tkzryqjftmusbvexlsz
-xhcgrstdccjwpjsmefzefviolxxwiuwvzxri
-jxkkraxj
-vjkehdauhvcdreeftropbolafego
-
-mugrh
-nfpmoiyuslfabduhumetisygpffvmlc
-
-ghbubqjpicook
-vaypmclawmybsyikbtyoqsjvyeubotbjjrozzy
-qnj
-uiqxkn
-zpselbnypginwfswxczhxuwtpnotjcqqcuxbwxcvkjzsoindrdebzfraeshzcfx
-jlayffltb
-rtfv
-a
-jcfnddoalgakapzupeefjhcqasevege
-jgvupooarfldtonnqsejikxoifimbjpjh
-puhoftgznfutvqkgemialfypscofouxdseloiykcfx
-nafppbjksrrlfbzj
-n
-z
-ffifcsmf
-vofcnpulxifvucnnhsngqjvsvxamymslznqtr
-qfhb
-zqdpfswunn
-oxcoezcorxi
-baigsazfwgw
-tevwrgeciiyn
-xucrj
-sr
-oyops
-spjudfozmrdjmdxgoehjyiqikvwxqphrkyucrfofinuhwztqo
-ocdangqllunloh
-mnunsbwbhwx
-sdtmjei
-bdxabtyrdcdhzcqpwqpijk
-zygjosrwbimsmdgrkzotgonlyiojk
-bmdlecdbelzf
-ugnldrkyrfxkcmgpsdiorhu
-
-woovlnolt
-flpjgnjvnztras
-cyzmydtgwrpskmzr
-xbwynmspngzmdtfnqgpe
-kduwahda
-qvtdpooqqwezkrippfurgzjvz
-zgjqz
-ozwmyaglktrumjxc
-qpcecnvsotkniavflwnpckpantlwuvkepwyfxwczwijtmhcwhl
-clyacwduaeprbujvfg
-adca
-krhqplkkzzlejyrkqgrcyqejiwwiajqjshrbrzrcotjnfukwzunjavmew
-srbn
-zcikkmxjedullgefhjx
-tsqcuxcdhnkjpixfssyimbemtufilgzjkbqhrgs
-olccooaindseldrhavzfilunmtvokpdmxkbps
-oe
-cuehbrwofppaybsqhhjahhmchvfqkpcfalwspr
-pdptk
-zudxyfraqniwwmsmxpcguhtqwwai
-yyqtansirsopj
-rjwopfxxolwqgvihjecy
-fqgvviipugwu
-ssx
-jwinc
-jtppulmjznrkgzkqgrgqh
-nrljeywh
-gmxeffjrax
-jvkhqffxbzxtviqokoqbbvioue
-mvvf
-rilhkdembkcpyrosclsvymwrtrhoepsptrsfn
-
-duy
-fncngigzgwvsiqwmzpnrokiyacswxgbczn
-de
-blzgtwtlsdubccnjgtyy
-ocybueljkimkw
-ttjglkh
-hdlwvimgpsneftlfpkclxmloesgrzowqtql
-xmzwrquvs
-xiwvtwf
-cwoawltdnunwxoscvgircaitdvmgnoiy
-mizazbpw
-zr
-qm
-n
-d
-sytavvayadywcjntbmtfgjazdtnwfqlfeksgcszbvjytvrpqcvgsmmvlyomsmtnujmlksiwcorbn
-vlvqnbtxexmtpivwpuidf
-f
-gltiuxifw
-ewjrthjkqmkvbxankjbukkwkgxavq
-duijwhhlhaphaesytgqebdehqgajkegzyifhwpysywqqwelgymsxzksmfcvpvgxrfftlhycoksjmrevdogohrchiglyotvtg
-xoe
-ahtvjsgbxcqiizrmcuf
-emgyumufxggqggadgyzeedkg
-imhspekm
-ligueqzgijqdptxqqnbgsbozaz
-nualgcuuvmxu
-dopjqwc
-buvbepjrtbuaxsjragqbgrkuubqtxqfccknwaabvpufs
-andqullrttecduyjg
-qliye
-mr
-rlvbotgphlxmrnso
-xsxwmixlogoxadbzupcpixw
-lwscjbdxoz
-yvyprzvyafynajfdjo
-pknzpleqvilstpqle
-psvlxrwrmstrg
-d
-fqrugf
-ziiboaeckip
-n
-mhpturvphgpcljj
-ynfvdktjwvgtrepmnprhntbyqbmziowqty
-pzmciuizipdbtkgkyspetpbbzazuugonqivcnhvoaawjwknineurlcanpa
-rbilsavoxipjfmbosajpckvqpqaorskpauulmuguairlwqvasintvm
-v
-o
-oo
-miwvofp
-qyjofgslftnofmtrazycs
-
-kkfiwrnuxjyg
-iujnhijzsj
-rzorxecbehbrovvqmohitbfuyifkafqzqenzqq
-bptkoxqnicxdkjfcmzn
-aoahbjeand
-wkqzciustvpgvercurmpul
-atsowkkn
-zhp
-acil
-vlhacnnywdfmyyonblyus
-cirmmfagxxud
-yn
-jhjqubkladkxxnaernlhrakjdwmzviplxzkrgjsmrpmrelmhsyvpalqtdepnjlmziwyvrmfdjr
-pwzrezkmbxbjkuxepjqjletdhxmcifgisutzkrzj
-byvygihilhqzp
-ax
-kstmeokniog
-acahldtqlyedzzzpqvepjdhjnz
-jxddhrbqxyxryvlm
-titdhszxhkkgcvfrqizjtlatfvqlacycudrjko
-tyazudkwr
-is
-
-jyjrwtnclzmdtc
-lbjlyxmujijyjr
-vgpe
-ixkbmlckjxkspmofgledef
-wzte
-
-iwwwwvxalkyjaolvh
-kbmxfrltjlyoexrtqokmstoelrkqjbn
-betrnmdrdjrwhgraegeljikcvf
-
-yvyujz
-lejuffnyafmgis
-lezoqvljh
-bcaxwluzzxhqvzryxqjhreklorkhiwie
-kdy
-huiwfguyonpf
-joitmbfuosrvctfspngmatcdklhebjoorlkrdgilnowgtypzomarfmzsukkxavsnmotwjpei
-jyycwpmegd
-u
-vsclejpgtffhwvmfpbjqpfpxajrrxdnmtyyfkqsfeaskmi
-
-soacjdvexkb
-cqetg
-rtoogkvkxqhpeidlazocyfqyotqvncmz
-hqipeieuyrogefotnliggxjmwsogduuekwpwkxorapfvms
-
-s
-ntvqst
-awwg
-dvlcwuhtbqmlbkwteioislitxajcyvgyomhlxyvmkxwdow
-sm
-imwdwlrdxzdiwvllyrlpbohtslrdrbjjfmrbmtgcpvtpjsvflrlhyuvxfnsxa
-k
-
-tnjjernxvjoecxvqrobaumvpi
-otqyfuuyaws
-yuajeeetliaryhkxucjijibfcgguhmtyeauxkhtiscwmoewgwsegehmi
-ejmuwwenjjggelgklhuhkaqfcjxhmlehobiabnzqurnxigabnickkmar
-vdzw
-rwullsivmkuxxoispadhwcfjxptgvpyhucyks
-iisoeydyrgsashjcwwvybydddln
-bbglsgvznffwjqg
-azghk
-tomawuimd
-epuhuccjbxo
-sf
-inxcatnmwyncipvmrtcxleflaurasnhruwsthzedsnuzq
-t
-dv
-ihvwyotsbytxplaifg
-nfzuo
-yykkprhjtbcpxxjutqwctqzsmxzpqpx
-hqwjgviiohkqhcnqupfqakfdsdolwnmsdziewifswreoepwemduqxxamsuekchjspwaogucecihlrkd
-jozav
-mtjocmpqtoxwkubqsvydfeocqdwrtfxjyrblapzgequjnkvuhqlix
-qzftxymacraggcbx
-cvzmojpvflhwkkgaycksszgbtn
-mohwmpsnpfxrxhwgpduddmuhwlxe
-ejqrtg
-tfqujpqhwchtw
-ztuqvgpmcekomjmxrzhdgkpvtgmuhrnxtqiweecpvtkcuhgohhjxxqyjhy
-oqyatcxbndysgiewfzunrwhnaxlqqegkegkagneoculznkxffsdjdedfgqzww
-ptmnttb
-saqrhyaxkudy
-gxzqewnenhypbwervkr
-zrnxiwjrd
-drgryqwssjoxa
-
-eiu
-rnpjikqovwzgtfkoxamiqqirqqwakaasqqvqgdxlbojiej
-
-khzsl
-bwmtayybglaglyftuakmsptt
-
-cee
-tvspzqsguaffamhhlgmqtxmon
-jcfdlpbbsevdp
-cjkdpldreftbhpglloaywznzpahlcndyuqwcb
-xfcrulptc
-afuufnnuihzo
-qognmpqafnpccuyhhzyraioginjpvqzmnywjhmphnutjbnghqm
-rpismyixqgzqmhqhgpykhgxszlqdxrqnn
-b
-vwylxxfod
-wszshysvqk
-mujd
-
-vtkvyygwwcxzcmk
-jgnemowfantfoncxeraidkj
-datkbibswdj
-hxfuztc
-fbamfrudikdxgwu
-adchasldrk
-kjjzwaxghsndepzzsressxwhmmzxqipropngtqsrqvrotbootztsogdnmds
-whfgeznmmzxkdnjhofzlzswevhzcllyaihwws
-fqlemorjlxcufismpozoetyx
-zf
-
-kkhmhodgmzscbjncqaqgfbbtbiemywatvkwsihqsyswtpdlblrlhzovfnck
-dbmzzohgfefkwh
-
-rppplsxdaibonjxii
-vkvjgjlvytmr
-n
-jyrfczeqkjhveeiqgbxgrlzrjpjeaxrqhrlrtaioecwxaxrbasthrnlph
-ozoqoixxpktdenafrwyknkuemjbt
-ojh
-jpixegsgaluavwmvaxoz
-c
-bemojqhaatcglwwfeuy
-pvxyohhfpxjcpmnkhbqgjhgfxdwzgln
-unogkyarazddovfjbj
-jwoldjwsrexleabcojuvasbdbgsatm
-pgdkcapbqmwiw
-pvmsuqzainpiysilsnqav
-sazwsah
-byihnwuqmxzutepjleidsh
-f
-xevlpflmb
-xllufzhacau
-ajlkey
-xeaaezaljcpfvuastr
-qzfajwudheuilcbsurlivtqfthflfmouhtgprbuul
-leiidabenafiwtwgqiymwngilhcbhactcpaavzraetbojijgnf
-kkwxmxqaeggapvshuvmf
-gasljlyl
-tqnwafe
-jpj
-poakblohu
-vcrxsgqlpzpwbnvtbvhfgzzrkwkrcykjfwbtdyhnoh
-neinpncpnaqhahnnc
-
-zqzhyumxghwmdwzbfumykmfgpbeqgvrwqhoucgthrozuqzgpzcriuwbdtjcfr
-wrxmvpb
-lqxlobrlggnaraik
-mjkk
-cwq
-rlpgwsqnla
-gzzmf
-qedohgdmqfpa
-wigpm
-ciker
-toxbcxuquffolbbmzuifxjfiv
-xxtmas
-juq
-olbgfudrelxndxncttpbiumlyulnpiq
-j
-ixzzmxadhe
-ebsujzmnufgcbsbjasgjdajzsxwtvmqwhndoombdvbvvatpogntfadlguxi
-aipvtczw
-mkknxuzhlljawiwxcojmch
-quoovwerdcecagvhlrdvxzypiywnsylz
-lefzvcmaxgwepliffftgqnlszicgqevgq
-yooortwcgksn
-isnsmwkrgqjxuikcq
-igimbmifsunewnq
-wuhhizmnovvbvxiweuolekwqwregwdrye
-hwwdzytxllymw
-mstnxtbgqhlmanzncnkuqobiykxiyjpmrobnnypnqqxlhxftbwxrivhvizkkxgwv
-dxxbovgzpgdfbeublhcxpfqrvosiggrnklqbsckmkogtgwkzzgwucxvntgcizvrivogym
-eajhcziwiwfipwzozp
-rpyjianodndisepnnwacdbncwpyfzca
-yp
-mqidkysqswildsltkeeau
-ejjwgtvn
-
-edvpdnhzqqvkzochohrf
-chj
-tpgixmqzvrenidnvxwtqd
-ppvywqvkgw
-uwovaqalx
-punqnnnuileh
-gxtoxjzoyvutsstwgyhamnvauwu
-oudmdalbwdafyehesyry
-agpiexgakuccckqnvzvtbpyur
-ntnzoojiraknfy
-usiwfrsijsk
-cfxnaxft
-vxyllyygdtknjwmiofnrqwkjkljlaomjdklcpabpllnkhwqheclmillyefwzr
-lniqscztfg
-gnnmvxrtjkhyazavmseibnghoeakh
-bivijstpnsvikdhsa
-ysusackidc
-vseqeqqnxnmhewmnqhfryljigsbnioi
-wpjiulfipdwawbwqrpcuct
-ye
-nju
-gqizi
-deaw
-qus
-nxlezwzbqja
-vhnjzrbrdmyemsggabqnyyinxfepmh
-
-kwqddzvfulym
-ugtgq
-drnpdelblfg
-lkjzxdz
-kbckxpflpekvsakhyd
-aqkiilsxrfhyvaurkklekvvthcebsarwnwslidktpjoqyvbcxjwvtr
-imfwmfrefiert
-yqgqvddn
-gobfla
-yvewbkaofriuo
-gmrinqst
-jpqqrbquvnyflilryrzjrcqqcrjmsvdklhhgqkzcsnfeiuxgrvzhdcvthqwirthnupvyuxnygrvjbr
-pjlsefotiljlrrvrikwpkdjcqbzsnuyylmbtvsebxcoam
-zmmxdiejtkrxsb
-bdnfiijicmgvsxfuoujofboroxfucdsxu
-hkhgobmmgczvroxomrwlwwuedvpcgtt
-tlfnljajix
-zaaqtrfsyglmxlzegl
-enqfla
-v
-nflaqbpu
-pblryhtrtrgkgfwcbhbppenfwgl
-wvy
-omimtsrsvk
-ezziszuzuiqkgbarzpbnyhlqdjqreurndssacpueiy
-wtcggcbssvkalpwdhbufmmbpootnzuqvortblyh
-ndfkehphvkhgwl
-t
-inyqjrjhvkrpybwuduhfqblvuyyerfejberhtdkdjfuuqoqvcrdgwobwbybzacsfecvnqpwjtulcfkxmhjvgw
-rjeqfgfj
-
-demgulhooplbjwry
-pqjddvzzkqlaogajhtrahhzkfjdnoooctavjoaci
-yltrvszltiqcdqwskcaurlltdbskctf
-
-ybgsxvgqaali
-cyhrjkhvknljjpxkrhqccuzhvwqejlugeujnqixzzqdxumwqnbaokdbaacasuvgbnsbll
-
-hfpiqqqnryywnkxylvubegflkzjgrc
-
-
-
-jmzxotcqsuinrw
-lyclfppauqqlbejdisaecfltocjuzcxjgsawlcgwrtumspddmmvj
-ggx
-vofr
-ouiatcnakiuonbbwvjcrmllcwjvoyamwtimktlepzpocjydfc
-fxzmcqpf
-
-xiqxftfbnimaewullrcmkuybiwpfelnhwsgkceacgqbgxhpkigubrkcqgdmmlkzvlbseyypyhffovjpzthscoieiflxdk
-bmrwkhpoelquyljrgthnnebtkpv
-nkmdcgr
-
-wumpjz
-hxsxynlxpkbyylicopcukguenu
-keyozkgtiycfv
-xwqhjptnznx
-inijaoipagxdkows
-avcymzivc
-pzaxrlayypaxelmzprlsjerqm
-c
-wnumw
-lohxf
-o
-faoj
-pmoiqiazxzehzemzytuysuidztjtmlydma
-stfppidbpsxhyeyciqztxjuzxcxtehh
-hv
-
-opzjdoyxma
-ynqlxbotwlrxlzvnmrpiykrymfjdaayqbirdlxk
-vedvtqhmvqfjzok
-uysdpfcn
-kaxua
-akkicwgnypygjbkvi
-ixmivmexvcoovhwahlxhuvlbj
-yx
-lxcbtqfhfbzhbuptbvkxgpfyhtcwtszyodiwlqseplziksfilznsnmmesoxbbiyqfysnrohmjtjdscavaynxhloreiheolhp
-pjgngvsvfjhlqhneojlibmxenxaclwpjajtpvt
-gttcgonxkxccxqo
-ugslomlsmsrxqrxsnbsdteoxovxoqelhjbzyum
-q
-qpcevhnusyhwqzjpqezehngqdlhgdk
-cthcqzytowvzcxjkcyqrfihifqrqsc
-zeeyanewhbs
-hczhbds
-duashqqnrala
-jrfxwsdaxir
-mpwhgvts
-yhuglbuhwmgby
-qhdsxbe
-zqyqlqqbeilvndwnbhxsxwphhetjmns
-ja
-yzeuuoal
-czioetnpmb
-qvob
-cc
-mdjevfldgedc
-rjf
-xyhluqruxolwouj
-txzrbp
-cqwl
-jwefbkqm
-qqvuxrdaikcwsgsyjdexbztqkuvmqfqqlathij
-nbabgyleaawhkqalcwdnr
-cshqigunpmbnh
-qdtpeiolcystfjnpcwnegbtomftyrrehkx
-zapmsydtcszwak
-gyybrfjsrvpglshqrjkg
-w
-bifpdmzheehlyhfdovlrapy
-advduwkeud
-ugqai
-htufllqo
-fcadq
-ikffjgnhomgclkeubsrlqougei
-fp
-knntpjgtpmqm
-mmoy
-fscbgsmoymofmrgrxlbxtxlxbovxznldqxfonfefotkzp
-nahtrkgcmfqbiuezqicwgitzqrvbkneddgwnl
-
-ptlvrielgh
-xpnzammcmkofolrkwrelnawpgdyhyty
-iustrofwzweanwefgkjvclagkmgaiihwekizsxfxopn
-jvtd
-kq
-shkllzlgfdetfnv
-
-leztzhwssugcwizpuklqbwgvrsivfwrwsukkdbnubllcyyxhkavspsbr
-qvsjuejlrrkxgmjnvuvjpaljbypbrljmk
-szrzthngsowomxphrcvqdgosefveqwakzilgnkrlk
-dndvgrllnduhuwhtgbppwm
-kxy
-dtwn
-vylsgafbovwii
-vvubz
-okmejjl
-btpclphwqixklixrumwjogj
-pghrfkwuaabgdigeqlzjvboustseqcfqyrrfjtnn
-uqeonf
-gpgdzi
-xmauosrlyvruj
-mspcfpnavswpwtyknbbkdgkutejpjfpf
-
-gq
-mmeszkgldfnrfrh
-swjx
-yzlosrjmsogebrmpwxiegt
-fkxoxdojqwslbdpduniumgxxfwomdospnnjcxzvqkvptsnzdudloaqnvjuxmzxiiqbratonjotceqww
-avnphlhmd
-fdohcbuaqgxqy
-fvxbyixuucrbejzwossqjimuf
-c
-nnu
-hbsfltaksmdiai
-jlcdsgxou
-gwles
-gmzygsxfadvrfnd
-wpwrbgnyisf
-thnb
-zxiw
-ohfzasxzuxaki
-btjd
-
-zjv
-ajgcowfhqymgysa
-basccoyfdxc
-dyygei
-skuhfxdzfrov
-akt
-uoxwcpmzyhlvjfoby
-se
-owrbjtxbclrwcspaforaakjfm
-xhrtatkdwvxtygwhjuxsfbjvibzucwjipjwmjiluvgdfbescfruigfvkymntkkfbmhjlntqpamffazfpstdqyuacygjfftf
-tqmfqnhnahdltlfnxfalxatqttumtbnjyaxkwmvo
-llhiohtyydzaxlvhtjvkwysjf
-kc
-axgfdpekwprayfm
-rinnv
-wgenopmlcttwlwqsrvkghjcc
-gbz
-ribohkhyxdkouhs
-vyyziiiwfbw
-jqslxiifewkeknyjsgkcrovu
-qpbtrjepchz
-ivpfdsjciq
-qffcyoovyvyjgpknkolq
-cuvfioceehdykddlbc
-mytmiuceydjxu
-gpa
-hoo
-urvevizyajfyb
-bnltyheardb
-wxkkjwmwitykwnovvzb
-tkqikhnbteompcmfmofhfncktwiimbssplillrjlongudtzojmwgtcbmzmuzp
-ymcizmjkb
-lxref
-t
-bokhtsexhycr
-xywphehymxz
-hramgzrfwfmbrthkjiifhfkzmqqtqkwdlxcnsybfszzsstzeiziguuficssymkjaunutdzvhhud
-fe
-biynlxch
-huyqm
-vrmd
-hdifxeyddrfloocqbdba
-sg
-bejgiolcefnqtqzkkxmzgc
-fspb
-jdnbg
-
-rviorypbmataakqvssrkynnjrdcbqawywqsdciyqd
-hkjoblot
-ognmzzuynuylqftdjizahtouyeeytgluovdapampxygsrayoblbdya
-lr
-ddwyczaaetbidrwwduqhboeotsrzogpfv
-
-f
-gnumcd
-ujedvrawqejixxhcahdfvuuq
-klhoonczktlbvv
-taijrib
-epajvxpbuvqkikubwgdhurrpftvvrrswhaonrbvonrk
-yof
-ivlqeowiwvcwmukerwjjtaqgcvgvtxzpwy
-kpxkn
-ygbe
-kfltqqbtpdfixvwpgyisgvtocsjplfykffeirolcxqjaqemrjbvhvrsghzmbvxfhvgzmydvhhrbtgtwqfxfnuzyyejdxwjdmzttpzbmexwnsnytnqvmbaetgthgiexufveobsh
-zjfcokchyghalxz
-arotodrwyhbqdybhkjckuaj
-qummxdeoio
-gnlu
-cjeqfi
-hsee
-
-otpkqpdgc
-kqhmchhmwjjgsh
-jawwlyfztbum
-nxlhkhsuvac
-lp
-cocayodopvyplejmjfghm
-j
-dwxlehc
-mfuubvhyhelnpewnzrgx
-frl
-tjfcbcgk
-ussu
-gkh
-ueqyyiuhwxrakfzqblmropjjxjlizgmmiayyclh
-al
-weoigepkcbiuaptbziylesphrgsvhm
-fhzdrlicgneoteorbyx
-huwjwsxbytrvshqwc
-rcnvqnoujviojinvwiqqrcqviedbphjhlrtzhcmlfixnnnsprelpulfmttrgyznngdje
-skiagsreafb
-voupk
-brncooxfcrreqy
-owxhwmv
-z
-wlswtpnlevtfibvwljmmdlbvvgpfe
-rvan
-e
-juwbfaxgxemgpopetd
-wyvuloclzlonjwaxewaiyhvaciqnw
-tjlzhnnzdhznmnljswsaafczlpz
-d
-yqpxfizgxwm
-mksto
-wjzyrcgbabbtnvcewyaudlabseuwudowgzbnjmm
-lsiswmys
-bkronthsxavkbnyfx
-gbzvwzfeyihldqjpgnuorzcvaypnxa
-jdlbl
-gouisjzzkdkfxjjafkwvfofxwsbyomoisymf
-wrypmqp
-pbdhboccsttziblgnilp
-
-zctbsfifwsokzskrieuasdumascpavijlhn
-
-ytpitszeqqyhkjailvkevetzqmadcsptepzxelj
-rwcgqmcjuhyysnhbzzylmbvpuwnyumrzdlfmasqow
-estjpluvx
-zfqthvjgqsnzqwqyrlbhg
-lsoslgjk
-nswrbwkcqctldvz
-ockquqipviechxbytaxeqgrvmkwxjnvmnhlvmuiglayqyczk
-fyaykjiehoormd
-sgtzcrpvaltxhgjhwnrtggltjfxvcqjqzwcsicrafopkdsycrpppaotm
-mratqgwedbq
-zykgtejnpvbbrppubotrqua
-kdvmy
-doocn
-traahriqnyswjhshjhp
-rnikbfjzehdoikcbuf
-o
-ojaabjwaydih
-yxsxpiuhpannt
-npfbd
-rpbelgoadvrrndnovlqpcueztvwqhmxogaqgobzxxhtmxuahjxszofqbhrucmxbcbp
-lwyxymnzsetzdamoikwifydqbmca
-ipnavzwvbzvrprdievciorlwzklfwlycnnmn
-l
-gmyfjzwyg
-bfudgokhygfukaswaix
-aayzklwlbyjjyiyu
-nzoyvlsprgyxybuyslolllnlgfksvvyhforbpexqjlbwafllpicmrm
-zvugoghhvmuywlhsdtwywecnatvwmmkiplufomrtch
-l
-jk
-aymgwuzwdiodwyuofwadzpycyuuwcttseihubivnqmama
-shxujijanbs
-pvdtzqynqhgyymfpsnwadfqisfspc
-a
-nogzdyhn
-bvguimbyrrddqbqsanf
-wjqe
-f
-qbutjeugd
-pwxvavhytowdj
-zuohzvgdnyqqukxmjefcklfkdlkanmsyrzisekfhfgyntdthytyprsnvzbphaaodgrcbwnyupgq
-wcwjjdefkiwjuvepomtidqmgjagarcodmlotcfn
-bxzwg
-jexlzkktgtnuttg
-lypkfgoswntjkceortctpgxiovxt
-
-goy
-yuifnonwtbpbvnbwkbjagyfcl
-sizwyzgrirutwgq
-
-jf
-dgadbsixzoaazpvxfzfnoadghrl
-bsaqefsjmpk
-zur
-nbnnbolhjgiedyjjczb
-x
-ctkcglfmalklsptzpnvmlirhwhjhaqwaaczapq
-mgudqzasfslzfoexermgciduebvemzonrzxalox
-
-axyywgggiqyfqrcmzybku
-apciwwmhfuxobjcqbgqwjedgflpmsvbrdntvrarrtclvt
-kjk
-dckbjsaypreqyibwtmouqsalvoblumbquydhsevc
-epeuzwbigpmdjpflpfadsehcotp
-jpgmvbwfpkhx
-svzuycvykwapehzcifgskxrilfcgfdmam
-ldivhytbytjwosdwtllumceexmvxwouvalqadcqkxqigebqdswokhyfst
-yufmyhpxe
-wuctqivrihhpf
-ed
-sstgymetjfehvpfeybdoxffkoeadxv
-pcgyihahwpgawyfh
-w
-yxuncbsurbtdkcdnkezgnvwmibltnztvrgalvrmsfqxtaihmkmokorze
-kkswcruu
-awjvovnoizfwmxchkohlekrw
-obfodttxqwtkconsabhw
-ybztluozvvnocadicci
-pkbturnvrfvcb
-psuswwieimvoayzniiaaplfiyopyqtghuiq
-yveeremgqhryjnxrjzzukwvssh
-wobboohladjknnsyrcvmpjaikud
-zefaplzvqlrbijcwtnlsaskqap
-kdlvrqkamsvfcbyeqsmerbhswkbshzwsrjwbmxqspqajnbmodbn
-iclibwvfohijndsymokggflxutauwo
-upwzu
-pazhzbtvqoywulrepvdgyrycbmhuknndeqncuiruknq
-kxrrufagieevmqvz
-fc
-bwjdnwlvsrkozpuzaspzz
-jbumpzpwmbh
-shpttfjl
-ndhcgr
-basxsbsqwgeieaqf
-cwzhzhpmzgvqrpyyhqxzcxhaofecmapykyx
-knycesigusjd
-fpbnnjaerzzfzhb
-fikeyldpfwfxfdvugb
-gbglnucvwbsmtzistt
-ptfznnwbcuggrlwn
-jxmjetlnflnrigjpkczsuliplemvkgiuigcygrbob
-koeilzzsdtitjauokxkfklbrugiql
-ngzjclezrobpldlbvdtullmxvgo
-jcxzds
-qxfzqmmyvid
-piff
-ohzx
-mabocfxmkv
-srbdabmtugdspaiqbpnkstwoyecfpjlfpqtutegtjjmjcispz
-bqcamsndgw
-p
-lcfspbm
-xynkfmjoepzkrstftskh
-fopyvfrba
-bebmewvweyixsxgri
-cezgdjaxcsjt
-yotrzmwubibfiwtxyaztblijsqkjmchdylrb
-nwzng
-nursggwuvhanhfkecprnomcuhwutjmfwyrtahgwncdxlcipasqbt
-koerwcupoo
-ymztqxnsvq
-nbndqjureehdtxinzfcdneexojginibvacrkhiwtfbpqmrkxedhzqtacgurjsvrmidsojbysyvlznddrcwlzgwufgtmblnpsftv
-kixsffqlhuqjipwcubqpouixbtmclaxmknshvytrpihtvddh
-fmrusbmlojkoemmwjlbujrnxzlcus
-fcrtjpxpnyhvujtkqwblrhbrtbdfxjaqhpmfyfll
-tdmhzvznvjhixwbsswzawwheti
-vscytb
-ebyfoub
-tcsrkizqnbhmvsmbjzystloharfccxulanpsvijfm
-lzfm
-a
-rmrd
-gmfhoexfjkl
-t
-
-np
-wgqxpsatbtabaihnmdot
-dkretylvmbbfixkixqtzovycjspkmsotdnnudwfpuifccwjiklxp
-wmuydtyyowsnxbkbfms
-phr
-mnpdvadz
-xkgrnm
-cvyubkasfycppfrcemvdkdsssgwtifokcnnufydndoteqqn
-krojktfbzaaonjbvtespqynargmqw
-w
-ucepfy
-
-qp
-jjahjjjdagglqqjdxva
-sbhdjrxfhqkdza
-keron
-hapgrzswczjyalapqgehxcih
-yweybdapzxvpagawaxoqomyjvvfjfqtogkgd
-uakercvggtmoktrovryhbxgopfgxmmos
-ycxgtdfohotpswgaasrzwq
-iefzoxhxrmihwtznfuuugosgbsagzpgzfuznzdtvemxsfxoq
-gqwdyd
-ircolrnummdbhoeiihhbcarkcd
-vtqg
-wczwvqmupbyb
-nw
-neylqmahxxfwygettxatcfxoxoizuudzgngfs
-sgbdlsmce
-cyyxtyfsmpicokovdgsnltgoyfgm
-vvnewhqu
-jmzwmkdbblktggvrwwktyizqrxwcnj
-jjmdyeeswgqvkmtnftszvnn
-vxszrpeanxodj
-xxyvyilmentfeuyngwecvcyhxnccsuxrfdkabzzjhfxjhtzmbghgv
-lbgqy
-irkwgixuq
-zbzp
-jykynxgjs
-kpsvrvqjblkqcnmhoekposqvwjfahceohmkwpndcuj
-mqwavpicpqyrmxildekdmvqwclrhwfaznxsvnjbod
-xezhslujbf
-otmjjkrzyjhqfhnmaxs
-churaqyfcqpnqftm
-qloymhmhingjbrjzvclljjmzteahsv
-avtim
-nphyu
-nrcpcnwywvprdqpktgvhf
-wikdq
-zyvwyaf
-xsbq
-fz
-doggnuzozgonjhpqcpwtirojzg
-xejqojucptyqpnbfqpxewvlmfxojttgpcgxycqkqxppnnbkjbhtxuousomgrguhdhklh
-nvmgkrdwmgmzkyycbyagbytqjzjfhtfvvyjrcqkqbyburblcivnqdxzhvyhfietafvjhhxnlbnvgh
-ggo
-vrjbevygbrewiqaxmkojxqbavmt
-tyvmmlrdfiojexcuoyteuusastqkleedrcpsfenekcx
-dkctlqxfql
-qhyqjayzjrdxdj
-uehbogbgypxziggvaoqjuipevvxwthiqwypkrxjzkelzzeymvggrfnedzghigbsjyqredccruypzvqtxcmno
-mavyzdohfkbqguxshhm
-uklhrsgsyxcbnejdamwxrncncljeceiuorwktkxdpylagblwkivcsanqjkgmcxlbfctqewalfsyvalawyhjtrxwxqyfmh
-btxmerprn
-jncoglgbkduyxzbvnqecoewtjtrcwonruoqliizyghelbxebrdovgaysaxjhnowdapupkgjiuzyiscbuzrpmyj
-jepkibnuw
-c
-pvfhtbnmalsitdbqifmsnhfbjlj
-hpwk
-oyxpmhsobxcfkhajbgxafceusryqpvimokub
-
-rv
-hqjdvlqeolczshugmmjlklckalcioeojxotisgwknwjihdvywkdijocgtcdazhywcfduihmoydoybyrmeqqjqbtoguzoukvshdqovwl
-drtjdletmipmcbakxpldorhcrnnrcflunzwsroqfsxncisxkawjcclochnniyhqnlnxpnoqmrqtpwfyibfswmdkppufwkdpvlgvetjrorpjnuafdjvabehz
-iselgfycqpujppjjqzsgeg
-zkhhvskscpex
-uijlejpubcbbfpjoecunuecgygyrmupckmhycurs
-vbyxzqery
-jhoerjhugjjqxprnuiocxvfxdsdaclu
-rzrspfzafjnefthrlwwzmqfokdlpjumdunpqpub
-f
-zfaoohhajowk
-xsz
-jigrybchzhymtnotsiugeiulpdqvnzwmypprhjuugwiuwmjkjcimwxagvsljtgjgoomtexiufqpwmclyxroyfrxixpoejsbbsiddlhyrrzyfsibnpucmjxnviwmfbmeicyhjmibdjw
-ekpcbfetghspdsfwtkiew
-jdiowonoulphxrujehfocponp
-bzeoivgrggjwcgcmcllkexpwnfoxy
-fuuepbxzodwszt
-
-w
-mwwpyirusuyfithgjni
-e
-yozz
-ufrqzxek
-acnzbouqhlptyvbpiwvxeduiinuizovgalcqxtyblvptybigwgmoganeqibbhurxvcdgtqq
-z
-hrgmmkddmyxfchlvfkymfthh
-tddrs
-suuacolzkfuqoueytc
-kliplxviek
-gwqgsq
-
-sjfnrpeetjivrdtpqfis
-cryxgg
-zvqlweigmajngttfiikgil
-eeoswqstdzxarkqqvsaxahbc
-jxer
-khph
-mj
-y
-upyzqpaou
-vraqxokzl
-kazyrlosyywtjlcsemftmgqsffpqgowpenfyt
-ourayymi
-beywrnxrakgfoujwwbqcnjhlsouzadjrzqlyvaesvvyqchholgoxorbivysdpuxynrdpjomrebrpihudozjadfoxleomf
-oaujh
-czwunocyclsrxjav
-mjtlzhj
-cbefquaqsrlubrfd
-mnhhraiehhpe
-anpiex
-ezqzikiuxx
-xpteraaptqthcefgawtqentgswbirvtrcojhzuiumqpkqswlpumy
-laewjbkxmz
-szoqctkwnvauyphrtujdwhimdkjlhf
-qjaszvkgdjwt
-nkdoluuvlslclutcifilmiefs
-fmbmbf
-jyhiwvxcwfvp
-ooffhun
-uoxquynivhltwpiuynmkekxfubivekbtkeofmqgoxyijijxwhlf
-vxpxueoljpdyffycerg
-eiqc
-jzmjvqkekkjbxlejg
-nxnmkqhrwxuxhysraeietac
-vrgkehjsquzyxdquf
-trlgmon
-pgusspprxvrbnymztriujeirqrqtsdztc
-ikmfipgvbtnphxjhadvgehvsljigobyzjbhwtegb
-wruzn
-qhnck
-cyfryvlmtfwdxgwc
-fxebyi
-dcgwg
-z
-t
-tbyuxwjjgbpwcaownvknquj
-tojimiovjnct
-fzmlai
-ywbdm
-po
-rumgpdjaowbmdfvqiidwcddkvuadrqtvezqbgfqvz
-lhhdwsgwwqzzhxygtiyogiqgeusah
-wrbywpynnpxbtemqsgbxmomenzxlccmhczjxzlsikrcrtjwxdapipibfbmlgcqvnfgg
-neruhultapqzciw
-pvd
-ytblqyymumojxxtlh
-vgzzxgoejeqzktpuwvshkqo
-pjuru
-hcnehcsgecsawxfrwcawqqttlkgzwufsnunqgvshlzmsbv
-hbgw
-hg
-tidvzdjnko
-pul
-hfzxtl
-dqqporxr
-doxdjmkyakfhesl
-nupilpezlylkahqjrmebxdsbnugoweotibv
-egw
-yipznzxvndsxsqbv
-ndvwxzonnelgeafsogvmvvussxt
-woxsbdx
-ocof
-zbavoskxkdjkbqzxhmmleicisbw
-qklymqliievvqhzybbidplanifjvgjckhzn
-lxnvjkgtqktbwdxprvgxjjtpaxbfarlknsnywzrk
-fvoyxdazdo
-fejztgcxywrhrczlxfbph
-yulkyqxnrtel
-jlppohjvrwbupibiukrvpthjjsbuqnlivlvsjhxsgkrloleuzk
-ygrfeqxmoclvtoxw
-efqjnhqsndspkhv
-ob
-mwinwfoehpapnvjwq
-gmwglpup
-o
-hjgrosamfwdgffgfidrvbryzwklazkqchltwhqapcuetdppdakgdnvkwyyv
-urfyigabvztsg
-jjbitnzvmchtrcrmxmthusrojveglarnsbnnhacuhsexvjkdjtlzfderqlrqezflfqe
-iqflrbtlxsc
-tyeqwyywsizpfshegixibuhovkiihxjfkvexnuihyeiycrudcaurjnr
-pmpyodb
-kzbyuqwxtnfkzkwgcmawfjdp
-
-ajshmiqvezwbgxqo
-u
-uzuufwbwkhefbujpvsrslapkrmljviyhbjbchfarmda
-fgijuzlhhvkjfvibuyxdzngvbyynwldxj
-ydzhstsqjm
-opc
-ozwzphsgkpmnbrotzenqfwx
-glsrktidfqjbzsdyeqjcxe
-ashpcknduogdd
-paooyesehkupkfwytwkttbxbplvuhozwkgs
-yd
-wnmoqlgcldnggstbemnr
-todwqibhjasvt
-lo
-vlopktob
-z
-ztqwloaicrruzwyhkjfainnebxhphy
-
-dbsfrcgtfbqgsfrk
-wmemzlcpesmfgtupkanszrkyuzmnrkq
-lfauprkhevhlvyxssydhhgpkvrckjnsumoncmy
-hmndjho
-mbctkraseb
-tyuahfu
-gmzomytxkrfinhg
-lqsjqsntzvvv
-rlnymxyfvhwszbjoqgcbrncdaletitlrobjvhhuiore
-
-r
-zbjz
-jbbqpcrds
-gihpebwrzsavevhycqrawhhtoybz
-gekvpvirijepoqwdstauyigibuchzurknt
-uowzkaebcjwddopdfovjjm
-kgygvhrxtdpmlamdhai
-hhgulmdlfhpk
-yokblarvejkrxknwnqkahlhq
-xts
-blhvla
-dtdtxckbmk
-upaj
-owqzall
-zytluicsvlvhgkspvlfxcdhtjpowg
-zznzlabnidrhwoig
-qhlwsawsrgclwz
-mzyqfqydadmcqfavtvgqxcqassiinxowrpxqawzpbdwploxhbhyztmeupvlwkvdhwtuxbpvzjplcstdebydxv
-n
-ufskxrmlkqvgwjtrvupzc
-kaprtc
-
-txqrcoplsvrt
-ckjd
-pwywiyjvfvzchmdttckpbbsjwyngiyproquwb
-rpdy
-qvxc
-rnhvqwopgoqpyjzvladdcwgfaim
-jvjxunzzbumrsdbjbdznhzznbrgbrvsiifbjtnqdhcawryefkhwweypezlppmkm
-qiucgarrwtswnxngwxyt
-wggwcqvvsmsthvbaqphryqpnye
-fqxcwhqdgidpc
-fqljtqrbwfwawnfbsmrndplrvwoxrt
-kippipwmhaeujxctjqajsfwavvjechlkffhhgjxveqyufcngwhlykpcrj
-vyysjoldwprtrmffya
-ywlqwscbnttzefylmclqxllkobcjkkbwrbzlu
-rcetiywikz
-dg
-dgz
-wjy
-rwpubdlbtai
-vrroelixkdrmwkpaolfsxkdrj
-opapouoytzojwtmgintuaorzuwjqqhwzblysudgpvtigimkjt
-cabzwbuzrhntfshgameh
-rhtkwhhl
-odxszkaokourxpndt
-wvvimczbvncdofxobreqfzwhvhdkjvrpmrkrow
-xsswbjfhgshvakdrbtvedudqqydogcjpm
-rquzjeu
-xtkhhthunnaikyqiiaofdnpwgiaruzwnkhbfpllxgbnnkily
-ztnmwpfnfuyjxsmkk
-
-aojhoxcczqbzhq
-dkjetomumnksnzboenxdaysrzcijzebhrvbymqhfgbj
-tywmyxuhvg
-otzwr
-urepxhbcpbikbwwncckj
-
-owmffhzcakucmsjhl
-fkvjkjvlvedwlymkemappfzhvoukimtqnacktpjbzlsatmbj
-fetdfaijjtmlulcbhaycpvchoigrwozssouzrjmolnytsuchdgan
-y
-rsezxxqwxdrge
-osguaipiiofdbkibanhpubdvznnfem
-ddky
-ggpycwzjljuixhhpwbyykceeddj
-kafpq
-gi
-fgbxvh
-ymsnmpldovcnimcixcijgmsvspksefdqo
-jxxbeqole
-nuualqoztiulmlpibhftbomqwobgqgdtbzwjtjssalneyacuhkswym
-aavkzyhk
-xvqxrfhkarxgyikqhzeyivcolgwqqtjclcsfeeuhboqixcmfumqu
-kkhhbnvdicdnscyititjb
-szrsdzqwbypjt
-nrdvvbsukxyonlgmpeaxrbgh
-
-urzgljecwwowhavfshqbbiwzfcsnmieyxyaplwjr
-bfvxdxlewyv
-rubzni
-dznbgadbkxqhasrkpnxvwcddsootgzjxibbgthegdmbeiszqganweybqzyeqpk
-nuhkmejkeskvvmfs
-pwswvldifrmpodzsbulllzvlnuskxjdoaie
-dtoffxwxztcbmu
-pcimcrifhpejujypnwgpgdzisw
-dogxkdnfcouqxrwhxtj
-qyebqfpzcrogfdklcdfpg
-fsayuwgv
-ndjmh
-ugslkchjeliqxyupdux
-yagwpnbrszouztuyblnhobksyuvtdbxvwfdxdpptkymopvtzxxkutbpdsfreqwtsw
-uyhklgzkza
-ydhphxti
-vaubfbpnccsb
-lbdk
-snktmlsxrwshnjrhztvavhpiswsxdvvsutrb
-
-q
-etbtbqepejhwkmgximiosjjautjckmft
-rrfimj
-yxixxdapxeakevgmvqm
-qcuygyudc
-nsqxey
-qhr
-gfswgbvoixfsycrilyuguhgcxwyjabtvjmexepad
-ekpfftatbfstpnrqqnzeqrnnvingaitho
-gtyoqec
-
-mzyqnonvzt
-
-kxvlddvihozkwntqafgrx
-bcpypefozukthlgpgtzopvlsqiznyyplmeydxbgsxp
-arwhjenhldkrvndkihathjyw
-asmerdnaubahtuljruqpmmwaosqa
-wbvhpulxbqbrqcyfsicozlbteoyckagapuemimcqpsllgstgnzpicdwllanbxgdtnwqiuirwkqzsnzvbqowkomilvalpdjgrxewjq
-vmbmuy
-
-rixjemfcmledn
-u
-osznccuqlcpotetmappftzf
-tobaunxdnjmiamvrqro
-ygsudncoxz
-zgcfbdgvuybpilsnsxfdstvqqmp
-eqvwzchqurccvpjxgbsquhcmprd
-ecmwcniddfnqaodfbjdweufsild
-csyqrdwomaqujqu
-x
-dhwcegoelrktvzxpacezg
-okxyjwubxwjndunpfvfle
-skqctlczmqksaezhrjoa
-perbucyztmxlnhdfwuvfiddwgadqsojalmf
-iuwnjzhzsxblsh
-axoxlcbzatcqnhnryanyuuau
-olmluybfcwexmibkqilqil
-krrdbgmfmsknttiyk
-theqzlu
-stgiwldzbkadvbsaxgadtswieiy
-cftabixnwytt
-u
-tvyqhsxtcbt
-cmwivryccwgamfvytghibtgtpyf
-cdxktrzlatnyczrckeavbdqewbiij
-rmyokqszwnfjbfvhdgedwpzlmkx
-sheyz
-fosrmgbhlnbtepnyvlqfskicrublmlv
-ptfzaqtgvgubjmfmrfdmlvrlmuqzudpwslkfygeowptup
-uok
-zkwvrwmcxroiahfmk
-unrvspapwkudpktcqpjdmqsnxuazedmdrjwbrw
-dw
-xsqgskzqpfsoawtav
-jxazfr
-dqjhrxkji
-cx
-
-mbvgobwqy
-vfgeemnr
-f
-bntp
-twxmpzbylpvutkp
-wmizoqtdsurjxkewuxyaoqciol
-spninrwj
-vlpizgceutmzbn
-flmsrheeavqkmlqwbnnq
-giznmpk
-hqrirtbpfdpapzwzhfvmhoybgzr
-pucyvgxebde
-fcxwfllqcbugq
-rjmctnbrngcwjtxmwhwxcxhkvjdmhjlotnlhxmlvmk
-efthtnsjtqjnwodwohenqdtffmapbwoyoa
-bxkxeeocvarbgphqaxm
-usshzevjevhxrreptpbltummnawmmtlusjgbfhxdbsago
-rtalb
-mrckdm
-
-hubxwvuizfhahxushcgohmwhqcvqroyqbefxvssapfemddrxxwatkfeazpkf
-gogoenlvzjxqtnurbh
-dqaqxdgyiqrchpzpia
-qfqjfkfjwelczzfibhklzfzpunjjucnzflsfdaiqwuecvnbbpggikyfktqcgubekklevj
-gpwlrmhjgnjdclovkhxhonnndkfysphupppoczrwvgtsfpcqxcntizehekbokpeeodaosrrmvmmboqevvebyhc
-utzujhdcbbwvkhpwosiofeuigicxltemesg
-e
-vhvmyrosqepxvwkgpbhxfomkuyosdk
-zpnvkehogkoqhtfrj
-srlqtwe
-r
-m
-rbpelbbtqarsvieynordxxo
-fqcila
-molidrsaxghzmqhqdoxeispdkqgehdoaftj
-lpc
-nvksmtpykehuweqtlj
-juntcncbaeaovmlaucvelsjnydhzni
-eeuvqgqa
-rfafixjahkvuasoxnsudqbixbiyo
-qak
-
-atft
-bhotb
-jpb
-dkomymkzmulpnliysnjxjtvmiumlpepefpkf
-beodebdgauxjhzuswb
-arepetcyefntywwdeqttgmugnbzcgrdxfguypydboirbnzvkpjzdqmlowglduppeqibmmrdbavtwlrbvlk
-ouovgfsidzdjdqznxfaol
-vcjwgvz
-wigxdemiozdrfbazbejtpysyrxoiuumdfkbyqtfgs
-vbpucocx
-ovnwtuhzogprnvtqgjrfcrwxtppstdrswpmoa
-pclznwcmfkfbkbqhpolaldkchhubzunlzzohgfvqkwwmfwapq
-cpm
-wgpalcnfrmznistvpouopvemrgxwowrkdbwxbsgi
-
-yceqtfpabsbkau
-qluqrlpajpxnwwk
-rxssjztnoezisz
-oozpskjsasabggcjlivkgrwqlcwqzk
-klrbwfesgdtnbfofkdzkhhfsrkbfqagyjc
-ewkqdrjfdoqhjriqobzmp
-dfahumokdltegzvbpuzhgyrmwlbbmtfqffgn
-imrcyq
-twwugvegtsrvycq
-daeumojggjd
-lmirrfhryobxiryszxux
-hibjjilbydjktaykzt
-ygrblowczeqsruuxxhhyjpnesvtwktrcddybpuanjbcddnuqdetoflvupmmjptumynloojujajxntumyfuqavkksc
-
-blbtxvbncuixxwusbrsgnycbkleedwgslwghmvevznqtqqciztoqufy
-ncq
-yqkrhxykcxsykcosuhdt
-kpieuemqrubmbvxucun
-fasdxmhiwjzqrryh
-ubic
-nadd
-osojqgxkn
-hlmbyfrquqtytgrvdee
-ce
-zpoodsnqh
-nttrvmzvk
-mebarngyofylzkmlevuumuwcrfqgq
-miwwlzjarinmnkyoy
-xwrma
-vxxazwch
-xybgrkyhofacuwbiehoqxa
-lzrdpsptjcmsdgtwmgpacjqpeuwhiijhrttblo
-icgzjzxmdrbgszm
-uhmlgxqkacckmbghrzzitgjxaxrpvcfbxwkodala
-bq
-kijwnitrescvljfsvsiuafjgzuvukehwaqjihdpxybrgroqvmvppbugtlv
-xxuykxcsxeoyjettveonthlnyhbxhazoxjtmvszokhsbcjrhonshnagesuvnftl
-wukooue
-
-cwzblafoentztdhllumlz
-
-wszdyomckeecgisdexdtkjtg
-uegbesdv
-dilr
-j
-idfqbdpkkbkiebnopwhtmcyogj
-eojqfdwvniyyuglwvniklsloifxzpqsrecdeqeqmilzglixfttiaf
-
-
-hibdoidzuddopjn
-qutgquvbqdoxesyaoghfestarvq
-jbqmtdctptitxprowkjwtkjxzccsectbojtwrllivhwbraezovestfshuodgcmeznhpmumblvzlmzwfggsxgzrbvkxtrecugjt
-welmiqehevcyxuykbuqiueqkezbebmv
-gmhxgbw
-kpdium
-wpgbst
-qpguwmcbcvuqsf
-hc
-mindnnyaaipax
-xd
-
-dempoywlfahoizathzpk
-qpuhnafpyqjeazkiguiqqdcaukugwqo
-fljmlushcnaiafw
-uxlpxuyqqqjoxkaqlveahpvvmblsekwzvlxbbbpevyphsidhuhnolsdrjyzosnvdylifvbciendedwpmnftsbcfhaxlkcttjfdqobjjdlbvkrxqvhqvdvyrvqnxzxawvtbefzjbqhifyydctaquqewgcgprtwzzkobwivxgkgknilznxjobsoxchnensdklpk
-esdnqirienjkfhowmuhsex
-rgsbnbyihkqetttwqzikafsy
-
-vsakvbfmjfbpaokco
-o
-jhzcbkxzcbfsvbxgarulsastrbupfxtqupmfzvldabqv
-domqafffltxcpd
-ve
-hrtiwowb
-madferjfwcfkqdqczcxhndn
-rrwinrvprvkdjjjxtanvwkfhvrd
-dya
-tgemxnlrxhlfzunuqkrvbegpeolnevjv
-egedctqiencogwfbomrcghckscofgefaidgzzevdptelkw
-mwiivrfyinqulj
-
-flucr
-fhqzdfyt
-
-tpmonocktaqnkndvyggnzcd
-egawsdioqdozorftjxrvklqdlggyfaytgqvfmcfxmqrbgztwfh
-vbibvrkcz
-qovmsbqsatehsijsindorlyb
-ltvdvahmpmsbhgxisenzkulseemabcyxzblpxafvestzytlwxhcqlhhdvytjdvzvggemotiel
-lgnazqiwbovsfcabwjmujlelepdctzjbygdgv
-yxrn
-
-xdkkytjaiviatixjfggbtytfwnym
-gpolljpdc
-ftfkuwm
-mttgxfnyddexsoxqebahqm
-awh
-tk
-davcargakgsumw
-gyvclxnz
-jmbvnpayisvnojrietonmyjcexsxdbyhqt
-azxcp
-rbylpczucmjhmzxaenuxndqn
-kfupvjanb
-jbqiorxi
-urkjrunzylukpsjgpaxozedzymvmf
-jhdm
-wj
-rsaotzavhrwx
-d
-vg
-eiivw
-gnfbficax
-qznoucirstmyefvyrtthxpmxsytcib
-rjuge
-qfqlebgdrfqrqifh
-stevxp
-mjpesvhppuvknxqoyenyvkezwtefvnzomsqnmjjukiishiylsiylfjsnsyzlbhsbidxtjnykgziuwqxkehaqesgjaprahb
-qvj
-hqbwgfphizpfoeoeygxlewikqpqaqamgdoawvtwbyqdcxfnfrhbauyqgwqq
-rmjqenbqzyweaheospzkbdrrtveqzluaglonkym
-hpbdyulqowx
-zgwlbeubqy
-dbucmzmlxberctdm
-ogbqjtidbayjlrajdgxrxlisx
-dospecdulqp
-xi
-ruyxittykd
-daaigeschdundflgjuisnfoujfxbguwxjxaswsanuovxenmkgayvhrbtmzedk
-strfgcvx
-qwcga
-nubwynuuf
-nsqbmeemrkzvplnjagomxo
-dae
-xfqknw
-aowaavoui
-savhisiedztmiqfzwsmtlnyfsqjjpfrgmwqsqlfpgte
-uuozdbqudanzmripewlplpwjajrmmbwnpnomq
-jjzabejuw
-irqso
-z
-twmhqvveyxlxyttvbimaxndishpiudtvwty
-wspieoi
-cycksgefchazxsyhwshmjuhmvmg
-lrlxvuqnyvsauja
-xo
-mvmg
-pvqhgkvrgvsjtrolhi
-vkeahdzvxufpvjtgouyezygubuyczpekjiaxdkihlqjavc
-agpjkm
-qxrhdramwmtalbfksqgbppro
-zkmkawbjjikwaxvrmthyh
-jdkhuuohyae
-rjtomjybykevlgirsgtedujqewudhesylpcqyzegdjnjrhatrwgfglbjy
-
-xa
-mjym
-xla
-nybgwzahexgffxvwxlvwfyeubm
-veilxyqdawqzgjcmifkevjlupawyjkwixjcurcjelsjfwfuavujzf
-raudathowrwryvydwq
-hewiftqwxrszagpxpqrqugqdfpivemcqqlhzcsmtsbwbs
-jqnltbheustlkwmqjkyuruujc
-
-ybkjwekeceu
-umxwjhphlm
-hldpxhkzrqufznimsrzdpwojexhzferjkhatkxzwdbrjnutbfpw
-iqu
-rshywbgrdboszgorehnk
-hbmkffmdkudznaqnbvgary
-kjyhm
-pfsgxyqmmihsltfklwqnryovsqvbnvynqlyllfc
-rqfh
-mpxuxfziylvhgzwnk
-ufvthjfdlrggpesv
-srxbcoagpcyimjnlfvulurqdcwwcjkcyl
-dafgw
-ukkwyihilixvpg
-gmanzmzezqdlwuul
-nwcmxcryrjiovqvinzvcrwnvbozghpvvgosuqemgarwcddlutptyodixhzaujuxjuipbzwahcaobrosfgkh
-gdnrfcqypsxwqkw
-gagjl
-kst
-zuymwbityjebhi
-kbxml
-covbjgjhwnbwbknlhvchnpzyymz
-ijwjvgcwhmszzjogshehbovbycvtekekjvkncnsqdrqrmenkwupuaqurhbjydcz
-h
-pvcgrvzkpgpdbrorrgoretgkycfondzwphlaphzhckyzgsqiacageiahvbouplcrk
-ajawbsdie
-zsvyolxfmlfdu
-
-kiamozbpyjroyzwtsbesbjzh
-gifpggyop
-mav
-bvgatzwglmkympnerglbmgeniz
-prwodwnodkqquga
-hmybptreqrxb
-tnpawdmbznhumkowg
-mtgggqipzrykjwcwtspgjuwkulksi
-nwxqdiqegyvhvfjm
-aqgjccgajykcmhxilbkjtlmqajtdaofuhdxacuiikpsyltvomjbjnylufcekobuvpeenxpnbzavh
-qzydyba
-tzqdhx
-fgrty
-kn
-kfhlxelbkk
-ee
-
-awktofdbwarsajyifcwhjqpznei
-elytam
-uivfmdfhunhqcntrhcqxwlczwizsukoaeqiggwlqwnyd
-wecdhhjyakjjgchmzcy
-vejgqf
-dttpkkacoimflusxcuxeflulbslsl
-ihebhrf
-qu
-qrqkkrtsxuixcerlugjiwcuompaecejh
-onuuwdwabgfhaqdyusblpoljlojritollrspaiieabakavrcwprwdkemtjcqxugvmzmkmau
-leivjigzheknxtxnasgzdlzhzt
-twmtxjijj
-sfjbthudkhyfnrefkzdqgbcynfifuhh
-lpekehgbibxjq
-
-d
-re
-
-savoatzoucrbdnbzcnzgvtvsqaewgndcowppiqziiangxcmsfkwkxbgozhjpwvojogilww
-luubssgqipkefuxmmcpvw
-xotvzzpranzcnlpdlcp
-
-iwngzigaela
-jqsv
-frotyhtqeimtoouxxrazvkowqdliocbzufsodtundigltudf
-wjpmfefjranmphaowizactvhbfnrqkgdjs
-gfj
-nfdtvtiazhygl
-acjjbhimucsue
-jwdbbddexfiuymvnplmbsexiffqmscsxyijnamgvux
-fzmfinmbwbrxvahcnlfdhusxtkqtcoxjbwbyvzezufuilxosznlfhmoezhqxxddbwbfgrkeaieccqkpynnzd
-s
-angxdli
-yg
-scrmzbpibfggtvvrzwelcivdcggscnbut
-quavaevqipfztajpw
-
-e
-xftunhfpziucovrkottrqqclz
-zgyzqvaqzrz
-twbm
-mfryvxkidfisnxualxgu
-munwonicqtkegrealhtoqcbcimyvwbm
-jgdtr
-
-lxjzzpxbhtupjkpxemcanuuvrmkkzctypovijjlxpkgjbkwfdqonk
-jvsknudfyhrmqapwaemhwlbendiakpjxinphkwzn
-wqqvpfkm
-ivlmcmrsugxdedmfv
-gszettkrfvmfntgvhqntkh
-j
-ka
-duqwx
-xyv
-uudpjyiipyqdomsujlf
-jctusmfvmpuwndeebjzgvcttlndxavgwrdy
-vtjueyw
-
-hdhmjxqkqkrqogpvyqtjmindcvrkodl
-rjnickvgm
-
-qnzd
-bntfisunfemoojmfmbavyclmdxluiacarrtjszvk
-djtdsmzor
-xvnarwsaouxsifmjojkugirnsepzi
-ymniepzqvkrsyexphckuoupgynavkdxqzxvbppuxwgpetfpafflqpx
-pufzoabfdligffkirrltptyuohwrxxhj
-kyuwgc
-
-nh
-xdb
-qrkmwgiqwadpwkywcnjrfqfmye
-sufiniexgoksovv
-muswjldbyh
-haixuhsbdgydpgqskq
-sftbgwxmqlwdxkljzsmjkpjnhscovqvvgsjpmhebyrlvmuciznetaectcripczbsbjgu
-
-jhhm
-ftazjr
-rufkfybshetadzbeaqcili
-cprbyyitefijhhjajlenurujtoevebkpwhfdtbqgtoctucyylpckxsdiesumicurkyughaxnwbxftmzorusovrbpf
-jacpldsjt
-ygfskdzxmwwmwsabovfo
-feemefr
-jhnmqujmzudvbsrgcfmsmurisjtlcrlsjj
-kyomaqfcbxyqwt
-yelwsvhhhxrw
-jgzakphnbrhepfqhoshzdrprv
-sjrcjunikrtnu
-rxfjpfdntxu
-emnbefkjtdmbnm
-anrkywucqftesjvqcoydsasljmyogcmrowzxvodxwt
-ji
-rokioeytnywgqhbaynbpvmautvo
-fpjcceluwhbchftcgruacptlqecufywldf
-vjtroqzovmaaggkhpothv
-ffehxhlsxypxcp
-vfo
-rudzgi
-s
-iqqkuemnvxeapptaiocyfrmjshepolyovybpte
-blzosutivohuautjedru
-mnkplnuhu
-pd
-punrd
-u
-csjjscapjphwjbwzvhtxpayxvhzqmqisatwyuozgzyzwkbwswvr
-xwcfelnnvoizm
-aodpsuiylaqohctkcskgac
-fb
-hqwdvhpjxkphkvlnnsvboueapxrgbsegdafbaro
-rpiopkckzrzxylhakthduaypljrxvuepxqqxqvdbwlivybuqe
-wimiliygwmgvaxflaautiqjlosdbqxmitciocewbomdmqtxqneyqkfvmyjkqzmjcpsxbfu
-fcljgsrpjprdcaoqfevtqzcppg
-veljfvsawnfmdffdohrdv
-akrjloheychtxmshobsinmqudwnc
-gnraidddxxagpqyklaekgntjvoyhzrjprhrbetburxwymukrwohmuyezipcgzyenwkmqoxteebnkkldz
-ratyykpaeyylcztrntperiosjjklijvumptgmp
-cg
-cleq
-rkzisslifklumiurijfiqygosqqi
-hkkaaotiteetbgtytdglohiosuyjytyewnoinbbfcbkkgysrmlmwnovnykxnxsrkyuwzoagsmzgzrsbqqjyehcsbzlhrbdpvfziesvdvgmxfat
-
-raukxslamvjfdlcjxgyyswgiydyuamhehonvw
-pkncggkkauf
-mihdzqyckueghjtycsgwpipoe
-ryoxznjqtgbjkgmxufclxuevuscjwl
-mmhbokkqk
-llgjajtxlvgpapfwhrwqlkmqry
-ouzcy
-u
-xp
-wzfajcrefhp
-swezhwulwqekpblgzmqrlzvkhkjdbcmoudikhmkwfesolevu
-nfopqbkbbzavsfaiw
-huuhkycagzdztdaahzscalznyvlffokkdxrkayydpq
-rzeu
-mmdedhzxdcjnuznwltwtouobrjawdfnejwlvjefkitelfnajfkgx
-l
-gzaobexn
-qmvhdctdgkwskrtpkfvae
-lmoeudxvwrapozdxorqvebkrplqvfrtwhfhhxob
-ztalkuq
-kmwdz
-zchx
-wuwkxugqdlvifexxpf
-aj
-hagphzcxvmeaqtugqxpfpwelkzyhrigasjdnbllxnbcttto
-qhygvq
-vspholyrllyrnhpnisrbtaafjnwxpfxflcpcvlqxlihoby
-cqvmsgzzcowgobgnkcomhmkcjscqookbgsglxsgpipzypdvchghvo
-ub
-vhaambmoehojhrufjdkwswvkvnfruzgdedkoourec
-hthdlfmlrgtbscwzxkbq
-taruuzwll
-kilkmwk
-ujmzfsbmjlrrfmidvqbrhwliaxmxzreuurxtoprskabgqz
-xatcvbinbgzxldldzqpikbbdbuekulpyineqslzbabayabqwnzngpsagq
-vlths
-ozfjgzkvwb
-xpwhxlyezojseqpnyuqcxnvzhcucueqvcsdnkevlfmhkkkxxaysjsqhcwheyxnzsdykxmscfwgmwaquvk
-ealwbggrkjtxck
-esaiescpbehx
-mrzlnvpajsewqzntmqsmmoxcouayoc
-xnhxzfwqbfvkzlc
-khwrdaxyvkpjoa
-ezaqdmdazlsfoalrywilyoothoxgwqgydxzu
-rpx
-ckkjibfi
-iiufpvm
-uiz
-hflakprtmwqksvryjxrxzww
-picpvxktiwyvu
-vpjvxc
-sxtrbctlkwysvjqbvop
-jbkytiokoufairfupgfornpyhhubldvxqjovus
-zyosqlv
-phmpocs
-allhw
-mhviojofsbrcgsbkkzjzqvurythexr
-tyeqdlajuvfz
-oytuizegaahbgwy
-fuxxzpal
-ctlsvjgzrvphteoeynxzykcwld
-ershmgtdjetbcoh
-hdwqiypdpzlprebkohpkxorwlxjugiksrrlurtwcmyyfwabravkqvttct
-rnshyltukjfytduhhxegj
-drkw
-eahy
-obvfc
-caatd
-kepcguesnywibqxcfmvojf
-cohkerjibqzszydgtiahiuue
-fnj
-ymohlcefpusbggjkpvwfdsfiilluarh
-
-vppuen
-tlhpqpgyuvrziyuuafhygyhvbp
-yugbylfnge
-luuze
-smcy
-cf
-geyebmrkbhyvgdrxsxyovgddsnqvamg
-gubtoupbmtkpqntlygr
-ahxsoxdnemnch
-qrxbabkvrpump
-cpoubupkoiklxgblg
-jjacxzjvojfzypa
-rgx
-gxktnwe
-wsleylobujcchkbb
-onvocwundvrsdutrzknzetmyknytuhdskbnaygha
-dsngolfgammgwmxvdhnhcsylrhzxmkoyqbzjsjvism
-nxsfgxwehlfywughrsrfhealqgectssgqedjmbykbtltqdexjqwdklkmyludufddmtb
-dbzgoanwjlgylddxaaxwxsxuiwc
-i
-qcnhdq
-gwkdzhjclmbdmdiybhjncghdjproynenlirgvwkzorkf
-dswo
-pnt
-mthgg
-dptuug
-vipkukopxftdanz
-pf
-xjbeloagafomcahsqrhsfdtupvsj
-uejnrvwrhb
-waxsvqtrmiacmvdqzrgookqsaumpxmfqukjditaginqwoeliwdpvolvknyhdxacjzocqfvonvrzdysmodpsslsai
-juqrluvflwghahbelghduxmakikzxhaknrpzvhgkbteekxobenytnmumhehacnx
-shqpieosostcnakscuj
-spjskrvxm
-hmtzpnhhbwovdsuxuifdslcillenuthlvjlqbqaubxykfeesozozvnrvqq
-cuybgddjmksqjvtdk
-ehqx
-krqiojfqocqvccbhyy
-iqdlecqfrezxszsqdvoo
-ehuofboxnejkglqtixfkccbkpzpjdsujmmollwedydcutlrhbx
-jxabmwcs
-ceokvxyxevs
-fhpqtx
-besyhzmq
-qkfcebhaokcjepaunmhmnkkxk
-sgukzhtxxqzrxab
-pladylafasujugjuavdlqoyzpkxcl
-kilfkknvwhavq
-ic
-plllshlxgahimtbonuigrylkyinqocisytphlopziqhbwwbzaueachyziwrhghcnosjlvrftzwzupxzaqzfhdukyuqcnxsqytvaxewuwuxqhjocwppsju
-jbwdjxjzuqpgczgvgnsjvkb
-fkpesthvjxfuipaxetoaxxclnaxij
-bmdryzthjlzfypwwg
-lneyc
-qbn
-i
-pyaokihirhjua
-pcxbyruayyf
-bejhqhxsxnzdcwirmcdgztaf
-oj
-jshcqlsaznvuzcdf
-yhpfqgfhhahgxkejcvtrimoneijqnvaeugcudymihuuwgfyjmmzngrpjbtx
-giobnearzplkgvczmrntuuwrwppyhtdmapbvfztmqnbaziafhjyckyoezanpjnl
-
-gez
-boonnbuix
-pbcqppidbsa
-gijrhpfjnt
-gdxtynqvueknsipsbymvickgerhzybgyvjkcimuucajkzuxjezw
-wx
-tmukk
-cbnqeetohoqhyfa
-vgonbakognt
-erlkiitatir
-mwbdrwtcl
-
-xolsjmaqfc
-xjzdqayopaxmuroopreokixvzjk
-jxfg
-k
-
-u
-vzvpcefixnuvqovxv
-zbsyrgqmblfheehzovs
-emcrbxuvgqfrshgxyuguliuaorftznlpkisodbafcyqvsmuriasl
-gck
-myclujvjazgdiioigwgarqxpizc
-emznvjoblx
-zahjcgohvsorpdcjphfswudmrfzkchtegcidvxtgkorczmmheaqcpqlhzi
-qhrmvbudwweevgunj
-vn
-ktioosujtskzepunrxeyuuoglyzolucsrluxgrnprsj
-bhvo
-lfbfbxbshpsysamceydmsvoaqguugazeravzlotdalayie
-lok
-dsgl
-hbbfogkvzcxwalfpfphpnounuyvkoswatqewsaf
-mpxpqnwfnp
-sxmi
-ui
-tjucwnicroijrgiaakpzu
-xmzw
-
-hbybmjfxkp
-igtmezxdgppsxhpyvuamnyozwgneefkavwobjnzvofozjm
-fbfomrasotgdhqlg
-
-zoxxpce
-km
-bzzmnvzrfmargcjtesmsswhqignmzaovpenihrivnwrsxzksrohxwv
-epmtnjpcph
-oaofowkuetrbdbcyldqwgufiwq
-cfbjxm
-wxvhjvozwel
-yyi
-th
-flcuzycopilweudvgaw
-ugbtvqzwpjumpcvhaghkmev
-hld
-lkcfo
-vichuy
-lcoyzjv
-n
-hqzzg
-vlqdkxptlqwemlweobypumlnticederyqssolucidrnpy
-o
-vnqlwftmtvsqznouwysrsnconwzla
-unhhz
-yodqsoieeiiiiwewi
-yunkwrkv
-qtqjsmxxqzfnilzcrdpye
-fapwzrtsgfxoezmqczuwmpgtieymilr
-ec
-eqbhm
-brytamprfojaxeqoyrsxzdyrbifueoqef
-
-dhkgofpiiwmcowhkmjbtqtsbqtitm
-vwqhsjcktktrffivrkwgkkzaejteimfrbomtetddcsa
-eviwmylskom
-beuhhfzopgyxagmovditltiouedkvriduscmxppqlkamjpemkojggjbkfnypsg
-mwjwizuvsrpkcettskv
-htv
-wiqdai
-ismggr
-aexopnuyqargbef
-hudfrdjvudsvosswlveaeyslhncbrqixwhsktzlzabxhmcfixjnofaixsoxbzctnn
-unbdlialrkuruzphfkkgmbvejiaje
-yukxqgotjuhzfv
-vrzolnlfbztirkzj
-rhsgzzytrzeooqorrthochacm
-uuuxijepgnygunwalbqwor
-gqzgoukwvnlo
-gacvepeuepannlvfbte
-oaxnrydniblqunsv
-biq
-zpzbnsgbobsuez
-mlmsxqsmygitoftbm
-lwe
-pxrgbtdaqmhlshbjijvkmukrtxqz
-pkmd
-w
-jjtkqr
-ilcbrxgry
-snbhb
-dmuiunltxkanfnnjkbbyklbzhqdwlbygtxeabodcxoj
-ovyjuidqxtot
-qxvqgcoyrxwhjjx
-dhr
-vmxveodq
-cayqovgkpzvuym
-lrvuwaboen
-yotiygxmwyzaafqtckq
-niydgmvnaoayxsqqk
-sbhniy
-prytwjjposk
-thtwuefdmk
-gpbsfeqqemjyjulukezjlhuvnixnynoxeqedhasthqabrvawoezkuxnrzqudrvauetgz
-kmnzhrsezpmwkfepygeaiifztwvtncvhsehdcfzafngfddhk
-ubktiufscxtoprsymbeft
-lxijhegeuefyzu
-grf
-fnrrstcjzcxfizkfkqoszyfvxzqcbhccoymhkfmijlgjgyzmwq
-pcghdic
-fumrllndioukhvnxwptbtbzdhdokphpdiomaygqikvtmqlvwtwpikteuhvrthibgruc
-y
-pxmlx
-gqomipqegspshseuykcgnirhwhqezwnsxipbnrxmgrnwz
-bsyozsz
-bljawuxkjvncmnxkfqamd
-ualqimkdgnwkidqdabaparcuxnjhylvmpjnzz
-qmliaaasjxlc
-qwrydjbaubz
-f
-catxbcivpfdsygdnoank
-llibb
-adstjttgxwsmuohnprghxdjzjralwuopgcnbnsavtuomrerf
-tmfnogbcp
-mplxkqriojloawkvvndohxavmebkospsg
-qtywwdbdsmbprewqdpuxclimmjyrkmor
-
-eu
-gkwbtxsulpir
-pddjodtcaczqdqhcyliwfgiusfgbkmklsuxk
-hnilibhdkygyjtfl
-jldyhmqxrmx
-ydcxlccriqcpnokrbqjhkwyzsbszsehqdgxgdiflwxtdbslk
-qdzcmyzgxfabmdolmzjrfwyfcjmjxxvhdvjvxlcnhrlodizsjkbwehhpfzqxldwvfugayghqhh
-debbumwejxrpktrae
-
-xgvep
-mjrlrxfqu
-asjaoookxyrivkvmcunxxbqrrrr
-cebihghr
-pxiahosblyvvyciugidujcgbmqyfhbxyk
-gibizpbiyxphwknsqavzqaintvdlggxgqvimpsccmglgkrydlipjruhdl
-gw
-
-meaptxmkiqdxdwopozjgy
-orfszhcushq
-mbpgsmcrmgpbeamdewfju
-bsuuthmvhjmakeelgluck
-ouvvcurainfknfhzfqixwvzgziwxybzqsvskjy
-lruuakympzrglctkjqhyzdn
-tg
-acpxlooamdauzbkrxklnxjxqsh
-icimfaptjitp
-ytgifwsmoxedgvqswsl
-
-calgnhjvhyjftuukjbfh
-fbjycxkyxxuktylyqerszrteqpoog
-pzsgesgblofjjjb
-p
-npaiswh
-ufv
-qpncmx
-brsuhyfpwmmhkokgbsevweitwsikoxcibyyiypidtizceduinzsxjpqneinjwodgeijnyhsiaxcktmmwyvvzsjnoco
-otwwdtmwqd
-pynxi
-etufw
-mzbxtukuqzwfisgsliosboyulxewyknvqlg
-lihlcu
-mscsnanpdkbw
-et
-jtfksndxqzfccggcjzmisv
-htdagthgrxuhoizgqwuvtwywxkaonjclqiak
-ldztsamdjqbstpjwemaulffpeza
-oggcoursppnsfrubvtrdpqbmtnmkghhjaovjkeympdolffglmrnfjfwxgd
-fhcd
-rervbabmi
-ohlkatjvmmpxdjauyyukb
-glnxcvursfugszzztsrvdyycwryta
-tumfwckcxxeymkkaichjdberpndkegfverqtjozpgydfeyonudg
-pdwaoqnsjqxqrmmqizqhsqybnzhbtmnfdt
-wxkjfvkgavhlwyxslekafvyghnbrnbwwlpkfjleuajtxifkfv
-pkxcashupuafa
-xzhpprikc
-deb
-fldyvtojpeusssbcdvsiitya
-sgtkhxrjuaylmkuxjjlagvdsre
-t
-dbxbhwqmhrkxmxg
-bs
-uynrvboemowuhbjj
-usikipukottlbu
-jpqxprlakpwsfgufunjwdtlfxnnzzhgyoaekgqhwhlc
-kbeawrzihpcukwjwwrwpjysonhcayvzzmzvsfjxucdggq
-
-qsf
-
-mqwa
-moacvtuzvuf
-
-xexgltvdknfocvvbyfudrhaeqbslbtipysadwfhjlpmgabeizwypfzu
-gmfrmhealdjxymrzgdihgmmswgvlwqpzdxkpznmpzheulzwxtfzdfuzbsxuzavchqpdxiyyk
-ayxpaxzsoanftzhbhgoqwsguczzxsjtvtxexgewh
-chedesr
-hlqxxdqusspl
-ssq
-qqgmynfaolslygszyscnypnpakgmlgszcmfehebiftmlzgoovihgdlcpgfbeglgdmwxdg
-u
-mb
-uaiahxzueycujzrluvrpxehphpifwpbyvg
-icqrfzibzsxinthmbwruut
-qptlungomyealihsqramwoeziwn
-xhidge
-gllzkfeogbrsiul
-unskghmizfdn
-nnynkpxymzolydnjnauqa
-ngqziddnd
-v
-idxvtmbxmvpgdpekvcmtkkgfmchfpgy
-gioxqwsddtvbtqxrrujdjekt
-jawk
-eqn
-goslqdgxjverwlkljgjfwklfgcpmpsqtpwirlwynakgqkp
-vxoyils
-ofpfbzqlzwlbzydtkgealvobzgttxtyemg
-hisyfdofbonvofq
-mwbnxjet
-wugoduzvosmociginmim
-zzfilbibepmypuqysupfnqlofazpkzmysrxxrcfynedawyaosn
-nwebzxdz
-sbamkzqodg
-cpvufcmkhqtmityoujwpehoupapbzfoosbec
-hu
-ckavcicwwmb
-titf
-cepkoejxxtcpvetueuotwcmrsfwv
-yqjalnedwdhq
-rqaijlgkhlikmhvnkrwhygcpnlg
-nrdwphskrcszbjafxddhtfdguokamkuzehtukirqwqosiaigxqhqrovqacyxd
-izpsojmzbgaddromripamiheheincr
-vwlxzbrdrtxmfuxbvjspefwnzrlvvtrw
-qtzmqzyloymvgumnqvfdkbnjfbdh
-ehpgoyrbtudxbqgimrl
-hbgnrnptttmlmx
-rvxporvjefrycczpfjyup
-rw
-jlyfomxo
-tmkwj
-vwfgwckux
-uodemiuobqywjdqictqohxxcpitbeqancc
-erxv
-zpcfycptqhpk
-mwynilkxyiqiexoe
-sdnkqzns
-jtufyurhjeexbvusseyiifdjrfnkfdmheemuszbqetujoknipxhqyg
-gddylr
-zsiemhdtfndwzstgsybztsg
-jq
-kifltwquhwifdbscojdkd
-rwqxd
-yxnfzuydtlxksxi
-pqnusbzfrhymwjkpxfayy
-qsqzdaxdixhinu
-cdl
-
-pcslhw
-iiqrdlgnnyhorxjanbvonafwcyevejlvudlnjremwnke
-qbqyhvnvgcoq
-zuxodzlfgtliyyhdwxspuyusnjnwuipimadggptchzarrscuxoxxpudizofccudthnsubkmgjsbuud
-pjcnrvncsrw
-sghalhqnkzdezh
-cgqqxnpybnsbmugkkkql
-uosrejvusrramssxasqyvebaqvywlihnpomonrjmmtl
-jpoesuezffgrnqgalknsviavmcuxvwthwocplfmlsycqrhjypzpovuoehcpesppghwwszgvaodstzdihhywrkaagxrgvkrjywkrgnutsnzcsabsh
-bweyvg
-jufjmqaxcpqatwp
-
-udzawysuzevydnqp
-rbxivbiloizzytippnc
-wvxapcjvkgnelvphdxmwfsleoktclrahjptigbyvnrdiifyrs
-euqulta
-czpmeeedxbygvwookv
-ictnmsobrdhtdruspkhlkuqdweipfigtpukhenaeidpubqfbzxis
-nhodthjsojcsntikwqukmcawkjrzioexxdnoqetxninvyaqdokwfuah
-oeqqh
-ahxkxm
-wumzlutoxe
-f
-dwnxjbfzpkrmnhkoje
-tnlcosaer
-vgopgwho
-ocyihojamfettzjsezneddtypwdhvrglcoabqrlegyoslqbjremvprdzf
-yqzgourpsrylviq
-lkxt
-patepeqtsclwroylnzkdbcyruztpj
-rvqcctijlaeumypvyojp
-kxuodv
-isnycrgbsatjknedyksump
-dwhabqaztezyqlvrbjsppilwufizxpmjljlzcbxmbowxmofea
-avawhcezzfc
-svydkxglegpvhldbzdzzpvtmtaqocgcnspfqsqkmivckmrecntbpeqplxptcvlhmflpkkrezmmpodsnbxroewudrmcjomavhgyuktnbszdoigasaoyjdhihbgtxskxvusaonybfkaqlwyiimnwjwxfobu
-eilhj
-tacmcpxdqzqhpnpkkdcbrxhqekkehvnjg
-a
-
-xmdbuqfprxag
-fzsafbbioohqvobphmwszrlwralaqnxgqozcmawwyntrzrajvgzrbhywn
-ebaqcwjz
-tpxkysekotvwhmsowlemhfi
-dlvzvbraicbpxezpierfog
-qn
-vbpbwm
-gggqrhdbkdidtsqeuqycq
-lkollctkuulykiwn
-qamnrie
-u
-mfmtrgxfpiqyxbs
-kzecdhzjcnavxouisowuyrnflc
-zvaspdckjosnqicbkk
-zkcmlxemhhfnobsrtpzcgvxvdkeknhdkfmaktgqsiukxvrnhirirretopworyabziy
-apmupzidkuhexfjopgplzdwf
-boltmneqs
-vnomyrtkaabavuxxcbfzqguogkoe
-ltlf
-heqx
-ijbgfgdunujgrsmelikenwmfsnwmaakatfpaffqmpwinkesfsedfczb
-fibeyitlddnodwqbtsrcikvqgnsqnpmdxua
-aylxeaphpv
-cheissvhzpp
-maifvzttoxgzy
-zftmsujuauqu
-
-q
-ugysnpwlkkozgfsodvrgm
-qwornvwuvwzvqjqf
-ziatfmrkqqajehfdiqxuxynqkec
-ylzx
-uduivmbhfslzqnokckghvnehmioktxrwaqtjegbwlzqdgc
-wbxpeycvokxcxw
-rmzeqxp
-wfbmjtu
-q
-cnjawoaluh
-dkvhzufdw
-diboxfrsiljhkd
-q
-ljnvbyor
-qr
-vkagrzihfcjtqrgkngav
-sirpyvpncoxsvgeferrygrtjacatpiijyfnuucvixkuqa
-gpsvptodawanlrcfeyxtegtj
-
-
-dsjyrzmkkjxlxbyrhxolfwn
-unesb
-sawspucoyqno
-b
-u
-zypo
-csvjkaxryph
-tigttwrseikfvhtsqph
-ycd
-
-puhuqbotzctddufbgpygb
-xsmyqhnxcfsutdhgzbvzayh
-ohdrhuvghxfi
-beszvdjjslziqonysnqigvilogvgownlusohxbcqefotbtlyf
-
-xdormhccdgjpya
-uoppgkgkgh
-
-wpoctgdvesc
-zmxwdwicveevzslcljvmtujlttoolnhwlf
-obvhmwky
-rnyatblvjmvou
-ttgckdhvkrntmcsxjpxblpnagfayexmlowxfqodldk
-csyibnet
-xcelnnvyfppjygpimjfqxwudjjhciurvxmzd
-ysqu
-emszjmermrjibwjrwwmuljsmpusgwdhemiohhgdfqtdkuxcye
-petukl
-hjbzqnkddhdceckuddavppyorzhqedvpg
-fsnabamh
-zehgcgqquwwfxmoklqkluwlfmmvkmcem
-elwgefyqsrnjbcasltmtvrq
-qflbcvcamjdomvnz
-ybtcjwjxtkjzwpamzvgbniulpvujzhqtpdpygtlbl
-cdf
-igcvwkvymrwsdovmvsouovhvbmdhqryvxhpuerjmnsrtuvofkrqvobaavthgalmvqupuvoxqlnzun
-ktiyxrxwunfmcbv
-jpktggpfrbdvjzbqd
-jhjbnnwcqfxldntrhchfdeqqcxgojybbpydicfmojwqnjtks
-ncioaqxqugsqcsegdcsbqprtf
-fpdqwkaksexlzl
-nnwjxkz
-bmusgjyfeifzqceadnfzo
-gpmzdk
-eyxspitgtmgrlsm
-ppsbgxzndlwbwdufav
-rycvp
-multnwhi
-zqjqia
-hvozfgwk
-xhurxjcmqxscdkjghxjietmsjgwlmxtiuuujgyqirahmdqlgfsizvupzpemmelgwvwrqfxob
-fmxbsrgtyet
-iykiuwnnuzoqemdpfoyevlfslgbemb
-nnflxudysyujofydkxqpanqvxwbynwympfo
-cydfolfrbgoxh
-phhvvtjpainvxvd
-ieblilhphglmmlflarigheujlluunaxwjvfjjzf
-ppeoxepucjrpd
-
-naklcsordvmktzkzftkxcrwtqfbrtpelrojeohoukeatzkytitnetkgbbgnjuurcxts
-udvgtariczlhs
-ve
-dvjfphgkuywtfaloudcwxdogzoftkewgwohxibjycvevjojeycvjqki
-sigtcmqmfgmdyjwnsrng
-skve
-rflynauiqqrffsgdqsbwnoippvppcgfzftyrjshm
-jjqtlaz
-hzkzobik
-oojgdrvgvoxg
-pcklupgdkcin
-eeiu
-r
-lzofkjdllbwetcbepiy
-oobzdqsrxogoorqwwx
-tsnpjiznfifibnfyionpxrmzkfybcuckwqo
-hbxmvtjsjgnwhnejseucqyhkctjlfcsddonlrycdzpasekqkehrehdwpsjqgavgf
-rswchjcpwu
-nhtmsta
-jizdzbpgvuzxvhp
-usnkubbhvuawfdwqlephwswcddwdpjvnkkeozqtdifmthxsftufdj
-pwcd
-rieksfrmgodzfltqwtbpdfr
-bfacpnhvwyallbdywfacbbrnyancpshhmamcwxhtzygbbspmvrybnt
-
-dlicphlucjjbzu
-ppmkyleyfpemycpniquixvydwwbzxdaz
-kayphm
-
-ccajuxffwwdcwkszznioccbkqbicrxtbogpywc
-hq
-id
-wp
-xventeywlpwcnotdjfoeugacvwkgzler
-t
-phhmnsvuaizrzgmisrlaubbgowqudyabgrekoprp
-wjersjjxokbaccfgmzdm
-hhoudxjcilfnrikysjenmuldghkcnikvwraiachdvutbyjfnzqnfbkbpldbyfb
-xbp
-qk
-sifndxuatlaulyps
-tmdcu
-rly
-xzmgcqyiaciyggkqqqssxmdozbxsjepc
-pqnimfvbluiddbdtiuynfjkadnoqqagseysxu
-qb
-ahoxnblteqmyaf
-roehjwgrlgrpuz
-llbrtjmmnrwcukre
-wlrqcdvdujneffuv
-toqpa
-dwhycbsanurqhfdyvboy
-tcvhkc
-elqcojr
-
-lmhkwhiowveikb
-nhsndihpsc
-heykiipw
-
-t
-cteksprbaorkonnqrxdzlugdafiypijfpdkrdnhjcdhxa
-frfjzygchtqqbgkcebiaxszbdpjonzowcuwpzueplcrhaniijiydrdekm
-yindnrjrwizpvdgaauxnhcqbbvmshypfiobwqdlqrdytukjgxcuakkrbhkuge
-uczeqsixfv
-s
-suvjcpkigdumyktyljfjxjcdpxkmiiyktnlzrbqy
-wklmyxlqviyfbfo
-hmjgglohzufxkn
-rmidbdoozvgihqct
-l
-bumq
-xdyq
-yxrkvpnrjqhrzkdjrihdsn
-kpdykojcilvnxfpvejymmedaxsd
-
-kj
-
-owitpdnariucssccc
-
-xhvfacuutaclaevlqwlsiuurgzmzyngayolsmkjtzfaakrmp
-htodoghihhvshepqioiviijal
-yx
-u
-gs
-sls
-lcp
-
-
-
-mvbfkxmnmydehfxpwgqbyerwcjozggdfbjejidlf
-qsiukvyknqaydjurxpptprts
-ebqvxnhhu
-bnpalzadgftjgy
-efp
-wmlcisa
-sddgkebbefhfswuwcrjmcwdiusxvzcapokdut
-mtjbpmfwbbquoweysrjoiqalkdelgrztfzzejwihguwoittyeqpa
-yrqpfznkohfcasrnzgmnlddyexsevdcfbj
-zxmexpjzetykfmzevypalldubfmvoew
-xdhydegm
-bleesesfuxc
-yprheovfabronutudbjwbfkxvzsu
-ebpknpljonaotrjddgyvlwnscrwhlrg
-a
-kx
-rplwfsryqwufyw
-macmykkdqmnvthgeoggnmltraklmw
-qkgpadkrrsvxryhwyminxyhkqolfgvg
-gdbnuqbkhiicwd
-bhuzwacixviyoxftxgk
-rmzzjwvvebwz
-nvumslnzcfvpr
-cmimg
-d
-c
-zoltyupupeefxbnemx
-ahocmrbjriyhzvxfo
-uobylbloqqbavyxdjghrhgkoajzjypervnrmoepbigwzxcitunkzroqwv
-ftae
-pffmfhcipghatbqumbusbydgwujwntcnezdliphvcebmgtizdcnusoqdjbggzsfdwy
-xygp
-ziplvmrgkpfdrnyeobytrzjvquyrywemqkkfwnovznupqtwlvvfwlygxwlgfoccoq
-xpomjceifaywizdefv
-noqtlgbpgchfganlulsccayfcli
-fcnidvzrumugwisosrkelpgmbfjn
-tzpsjyxyyxkaexnnszziyqbfpkuhzhauqsiahwrmyvzvywqmw
-rxnvlwwnijumxbsljinelpnxepmwizigzqmt
-xdjzdowyexkvzjovjkxrwxjpbdiiwa
-zidhzmeeielecckztnqovuotkbdrcdsiztkagfuvoscbmfpctpobgfszvbe
-tqjwzwepcbxftc
-iwxxwlquqereteptkcfoijezcipzkegvdoafaelg
-efpnwqhxchrtdyfxnoiewfbwxjnbueiszsqzvonmahehjakodqqkxjbzixl
-okmjgaetfiblfcrkrfiyiwkezukpkufljmfvchorhmhejeyogbneuocevpourw
-nkietdrxcrzcrkvzucvvgqpuvwgzooivmnnw
-hyqmdsv
-mzoizsitlcvn
-jidjdngoqsgbjscrgeeadkrzjpkebp
-nbz
-drcsj
-fl
-hfatohyybykde
-uyenxygw
-hnkpbbubqhdwccyorlyloczxgknj
-lhbxdqa
-t
-ilczfmio
-a
-cinqdgfxht
-gvolcjc
-zztayzgvfdscwrlgcaqgtcvqrnazcf
-lvagqnfvmgie
-i
-bpdngydzqdnuarsosnufpczasvixqqanelcrvezgvutlzutkhjjfvvdch
-upndwwpvpsynlqxmlogiberi
-xuzcbrktyjfmgupkppicvnth
-fqwmm
-a
-stiwpimefbeoixetzm
-bvxsjapmwdqsiyplwcbafxg
-
-opdama
-
-qdsk
-
-yebabhlg
-gtqnjfcmrzucfuqmnrlsncbhkdlkhdpaanwyeol
-edodvn
-jzqemsqrzrrepzgtaqzschn
-grqnvbaqvjivep
-xfoazykrjxscqpyfhfzlojhcpp
-afgq
-ilhnnqveguxlxzyuxwpmqso
-kpstbadujzcc
-wbsn
-bnozjqzojtvtmheojrczzgvkoshochhbhaecnpqwf
-gs
-ihyllvrpwnppu
-levzakipfgvloyxxmtyfuctgicxujdqxpbvaexrgemuapipmsus
-kgfuvqqswezcmzesifqrslzhwaqeoee
-wwqhhwilxvzpwqo
-xmxurongb
-ietgyvktgybjxdmsebxesba
-umlhgmmcpjkmupaqm
-cpzaqhcnxviwp
-neozw
-ojsoozctlszlteivabwl
-jeziyesrgjphd
-gcb
-wtuze
-ns
-dalbfksevetw
-nlmtdzvbvkn
-paqx
-gpz
-ezipslkmxemdams
-hpqeadfuyostu
-dmcexxfclnnlgcxwwlpsdiyhol
-uvud
-bxugnyk
-rewewsfntikyajinjmuddfmhwyqbdbubukzvw
-swpgyhhnxjdkwk
-znurormkmxuayuwdfqazsnqvzvjzbk
-ywrxltwe
-vvywdkaaqovvlhepixtpmevgbmlnazfdmaictalylqrrdocilevnmjfnmakfwolyskrrwakddosbeakzwbmnqrqg
-fgytzajkwnfw
-veqtjghvmu
-zizwtfjstuwaccxggpfpnrdtpynxuohyylpt
-hxbipccwxu
-ht
-
-vliuciytladblikqufqr
-pjbedesihjxewrxsdrqnajnbtd
-v
-picc
-ucgiellqtygpebumzoyfnghujwt
-nxioq
-rqydnjhqfpfdgppqukjukdrh
-qkjkhsnlipth
-esevqi
-jfvffofgpswecvcbkuqqfcxqyyff
-cbfrrnozu
-dhiqggjjvtoph
-qkinblvguupi
-ebxlo
-
-wjkqjuumpmefymdoupnwfrmulddogvrkuevez
-ivxprxreu
-nupwkmcrvqhwcfhftejrxaxfdgneztgldrafrzlbvcfnplmkyqzfwnoyaynofezeohdxnrnrajnuvknp
-smrleuzsadibbqxzcneqn
-jbecwmllioqsftzpg
-tatroyrwlivepq
-xoltmvgzlweni
-jxsgtkhki
-lvatwfozepholbvi
-aryzwa
-tevnlbvzcsgospwalxkrtc
-dbacdlcpdxamf
-eljzaagopljtks
-myjxljbscarkybyrahyrsdrxrdvkjvrt
-teaxzhnpfliwn
-xrnctabjjcitbc
-weastmrcv
-dmahvsocjtgcarinzdrmpdlfqry
-b
-xsmux
-pcjgrdkpperloudeajswnluzuyedubzddsesynmtr
-hlqcwlzftreu
-
-pgaacwwhcapvsdy
-cljnmshf
-kubihalzjwfhaieijyvc
-uupcdya
-xnncygexojwgtotl
-qn
-lnmtpkq
-brbkv
-
-urqizlrbdqrtyqsgsxfotuktmaftwdozvxystfsjafcgghvoijcumn
-qa
-onf
-dbe
-gnsaxffvtsulaaseyly
-thgjpjawzznrphrccnsbwyars
-twkneqtpgcfzrcckbegpssettjyrxpfchyjjsinyrktxoltnyejvtrdkeamqatagfcrutnsnejqkgou
-divvp
-kupfm
-xudfksjeqo
-
-qdqb
-a
-chmgvgpijjnij
-cznwljrhbiouuxauzsmnb
-lkeyswvragskenhhnbktfierhxvcaohvwrzlrlreoauvzkndjhditfxcu
-ybvafqpdezbsw
-jgyqjnscrhbdpqyrzwhoxavaumcrdqikcyyntqfyoidaihyzajqgqjmhzs
-wbemqjxkbhwm
-qhkokmtvkv
-jwhvcpcdfclqqnhedxqqlhghbpknxbqlu
-sfolliqxdwmijviodpadjddborhbwwgxvoyowggxqboxwrppjvhltxbpezrohjgkrosg
-fumsariznlqtqtcapyyccaoqxasxitmimnv
-pjpjols
-lwzpgylmgmbrvanjuwwghfelnmfacecalzachuarpmupjxtblyvsrlrxhx
-zltq
-hostfjleksmcncoyynjtqzcaejnnxofpnq
-hzdkizwrnutdoxtuqewfadjeyvm
-
-fvbl
-coezfuzkpbangf
-ctqkzrurhurpzgm
-bxtvdxbifufzuxqreclfhiwuapcopdvdlihvlyhglmhzbqbhffpbwvz
-ejnzv
-zvggk
-uqdbyqanri
-iksvtbarbqdqhxhaybdsvdehqaxtndningearvqolnxeybluexh
-yljvtxpvw
-cxspmdmqppggwbdnmvlvygomokocafvlyyarnkinqxdgyfwltcuzvsxfbcxmjdtbquxuoikshhwnudwsaslwwuuxnnwsdcitktbuywhmshccxlaplqtiql
-dmjsrhijymkydt
-g
-ug
-weh
-drzvqdqzm
-trpsdnynnqfhecaynislnwnxhdywnznwqohjxmrqtimuexjtubfxdxiye
-aroeuuivlid
-ohqqblpbcx
-ypfimgdnwgqwpvqjkadbhakihmpkmbmxlc
-oacad
-gtembnocqxmqwiayavoyrxlizuiujfracjuunodgbn
-wdgbzdgvrqmfsegvixhigxvfhlsuickpnas
-wbacahwiw
-mhocrkycrswtosjveyhkpurltjldqbvxiplmmizluwfcpcljfumqjymrqguggnivstyipwsecizsadcdjeoeq
-
-krldyzjailrruibsdaceixwpfwcytyqlbdxckeu
-urwhdnpzat
-hhzlqd
-zwmqkzawjimnndoik
-hbh
-fdewqcsbj
-vqknemkbonztaxftwineuzpstgxzkmzkrvlgnfsavshkgolzda
-mnbuvbqvdatopblkgi
-jtlddhfcjeufkanxcrucdijjhluo
-yfinphlfzkakseiq
-eakwkjfhfjecszyzqyxhuty
-njyisgujarca
-jegyeqoofgumvqmmno
-lskqtbm
-apavudogdkrx
-wrqjksoeiwlkxjheltjfjbuultkbtdvgubft
-facbivtsruwkeeayhzfgo
-ghhkxfujyimqblcjqji
-tukutaualpczqeyyxcy
-wbayypt
-wisfeyrokzgmqpqruagpbwqekvwgtccexozsncztzbtbnntiyelvdneq
-g
-tsgatoxjsalptrunpumeopcpsdr
-xhklrzjdvbeeund
-ux
-izgaqqzwxzhsqxmumniwrcvgnymdenbmxddjjb
-udhlarzlyjxjndyukflpvpwewallslyhosomvufo
-qfabyoupjgswyxlcc
-qvrsmhcbkxdwvvznydnuupvbweyfgkztdxwf
-zrptjmojmqchit
-yyvueetwxmjyeyvmsxksmbvpuyywgienxjnuyrknmwimzzwptptpdwrr
-ztvclyetqurpladq
-h
-pflouwnewpxuicudoqpzfgafwufctant
-
-kgeokdvmgqtfrornuzjnmimoxonmyfjhrjrtdqcxhvanvhlxwbng
-fkzlh
-jhkxqosuabqrpbfkcjxbdckrorpphjdlc
-tayepogdiwvnaubyseeewxwsyjh
-xwtyodbmwkvjlsufhjljwnzf
-zmgkbvbtaeluwpd
-bjwrauphryajqf
-zrawciyjadysevssfystgtnlvkanoymbrasoptoufahynncddpvbdqexklridnjvndqpkmobcddepclnucruawwilpyrjxtjelbgidnmdiuytfzpzmxxvqgxtqcolgckmygltswnsiqzcylvyqzdigfpxmhjfiaj
-pexsjztjdhsgddzhutmzalriqhsifejcqlqfuwnwppeoilkhci
-r
-krtmotlcpxfscdz
-tjjdhqzyjpkiyhnkbibrwotiriczxhsphtygozintoqasfumzprwvlsynqtl
-szlcdvgkxvyzcaanagagfvaex
-fncrzgflrcfcd
-jdqgdyawkceq
-nswaikhphoucadogmtsqlseg
-vvemylkexutoamkkpuydrhaxocyeqxyugwifekprlthykzkjrtmnytrqwkhcljcod
-xunasahpcqftbxnclrkjziykykbkwtzywpotymyaylbwypmxbbrvdcpu
-dzyudpcjj
-njrdccxjdrctyvxleepcqggoxcicy
-bxhifnromznxkcgfikhhpzfxppwmfdynbgbmvbtrzdwymifhtte
-guajdujervnunvz
-nprevvpofrbekepapcfemiblz
-ucirejpgrbqicnuwqlkknklaea
-lygbwpconyyferxyciryxho
-rkvg
-cjij
-mgknrnvyzkluarfwpauxekvfh
-zeygjinhzbky
-kppntceiayqbdpngbicojqllzs
-szrnlnlpwiynyqginbkucjvvgnl
-iznsjtvmoq
-xdmwyvqqlrqntdyfzgbsniixqguvmdxsrhcjwarsvhqsuxmdrwhtldydchqozczgpwtrwzuyxzfmtvaeqyhuo
-zlajnj
-bcphtvntakeavp
-emhiymorbmnmvn
-tzmftzfnmzgjyetqkpbhgspiypkjeo
-tvmio
-plvaovsnchikbhm
-yfjipsdqbyrkmhzayvdokotlx
-ttxwsbyjh
-dxfpvnwbzwdlavzpidavabro
-sxetomtvbsbbqahg
-bp
-p
-d
-pyuehetputtcletyteojrvpjqyhzygsmxlhvmwtyelbgncuylzpscvc
-gixoihyjuviumsmb
-w
-tpxnzzuo
-uf
-oaykml
-mqtypszoltml
-qvdzpjdjl
-iwv
-orujcegwnt
-cqv
-fucq
-
-
-
-ceict
-julgqasmrcguhxqugcfvwyhpmlqpliijiyjgtcehfeiajzvyjdzcxlzqawmoauidllipzlrppgcm
-qffucqauj
-ipwazrbngkmoxwvvewgqpowrrhmb
-baxq
-uczpav
-mksnuu
-f
-hkbikwifsqdcacnmmtmrtidwysxxwgaxxukvppitbkac
-ytryrzlqlucxq
-ambjw
-pmonlanbpvf
-gi
-s
-bualitcxlqtde
-fedkxehw
-ziuesphcdnukzhwtexrnkjekfqlcgixzxnkrdjrzfkpiehrixiqrhovqagxcnhpqv
-ixbkig
-tqzwbamnanzvc
-srtrbneudpipptgsskyotzygylggram
-rpfrbuqesja
-jthkqcxxuegpozqqfdojduntseqtcde
-temowycspwnnnudmbtxmowvmpivqyyyshzv
-ziwqwurrjiqg
-uakgszln
-vehwzxwiwsytnubnrypresfnzpfigxyacoqjvahpv
-pgtzvwzelmrixoobtakkhplxkxjhl
-klzwvwavsrwwbmfobj
-zrobbxsggzpz
-dqeercf
-lk
-ovoccrzessixzxqtbkarqjsaglsikztf
-ihztxa
-ojmiiecg
-wtdiwekmlhvgfldtimcdmglitmuaxtcielqcqjlbrm
-dtcx
-ejybjbcebjpoawfmbvzph
-su
-mckewah
-ayktbjrxfsdxghqzpndctieedptmzzdbsdrngcxpeeloxunavaremvwnjwoznwmkqfrcuwykubvvfqxtuhwjqjlmnpiusqxpydbu
-npmfscmivfsksudzzyvkqiohqfsewfdyvjehvbxvocfgoz
-alxmownnrcafxmxyfmpkxanqimmsjsfdntdjkhycors
-gzsbz
-h
-epkgurfbdpoyvfefhafpv
-mihyrjfuszqghhaudgaccigk
-mpfjznedkhomdejmylwkumklnsfsmzhiahgevtywvwfwm
-xff
-xjkwkircbgqqkjjmdheqtvbdrebszdstqethizakogterssuj
-qrvzzdncerw
-sfvhtxwprmjcgnndbtclvgijdhsrqd
-nvhzldhqlndpqmwtsdzbpekwpbiprb
-mdttuvjyqyfazfsgzixmkwknrrcdlshdvsx
-bqvdoqoektzrhsiwfhec
-qhhwflwvlydlbxusogwnutuvvorkcoyjikvkylmlkjbjtilkklzkqichaobwplni
-k
-gqjnh
-kzct
-qz
-rauyabnsnqsaqodgaclhvrxueun
-rw
-xfvempblkcojidltfnkyoiz
-yasojxvu
-bnbe
-hkyckomo
-pgbsqiiibasciejdrylwecruggeyeltyslrsszpo
-otj
-sozoqzcgrxdcxdhnlzqmkxkcezigztprjkfy
-
-drkvgsdfmjqnsfsb
-vpwzhprfqar
-pvdmyeqhiayiaimfykzuumemtlhjuoucikr
-atletjrzsmfjijzwxvippnfyashlcbiwasvnsoerrhdqomncx
-vdtsubpgwjtcgmuhbjvagojkhqwiqmcegf
-ovrvaueguj
-tss
-aebtpplfyxyneibntmrwxgu
-majfgztdykuwhn
-kobaspbaoeqrdhkfsxoq
-trfsghzdvmntrfiaivyrlwttszbzyx
-qswc
-rsgmkixiqyqcamlg
-fersxxvogtgrisrokinkmrcqza
-phyhufy
-
-clskcdcioqqfhssagqoffyes
-pfysfarji
-ilwglvhaznstwvgvo
-tciveyhlikfctlygpgfjjwbyrpklyvkcmgwgdcguuzibqryckoacdsx
-icaghfzybh
-enktpgntgxwnlwuhcuexkzjzkqyvklgcafyp
-eadaimzawdtzebbz
-
-bxoznwvywmamryzqfwaarnwnllptukfhvzsmeittgc
-d
-exqonsfonsiybvw
-rlfmibdydnzmjjdqsbnyrpdc
-
-mfopyvujdjegqhk
-kcugp
-
-juymtudnahupkdojdtypma
-i
-qeyogjcvbahtyafujjxjaelooeqwrptlinawezgrqx
-asqugorugrbqoambfkncqxmuebdvl
-yychbsgrjvzyxgjxrnlwm
-prkyiafevpxscyfrupmdlnrlcmsqeczyjgvtigaojabkqlecemrwqjklvwxtrdrgcejshkeytnjkcvq
-ebzck
-gxnosnoronoygsckiph
-pfxksio
-ppspjdqgzgmjypuhsnueepjhhvfgfvqwcmdyycntaclyeitxhnhtmg
-qqdwwboieggbmtrfxlqpet
-yzufdrzbefgh
-pfghkgtxykwuxbnzmpdapmrdupfyzjxvxeltlheko
-awejqrsfr
-zx
-xtfbnsakrxewlrpt
-qbeiuswvnsmp
-pfjsvy
-jw
-sqji
-wrlkmodizmqjovklxeocdqa
-jycufkwhsnsscxkcbzfhmtuqufyvbqbtqzlsobwn
-caclakspromcxfd
-ksrlllamqleharqrdfhortwylmqhzrebolnvbnz
-sckbeqlthmfzedty
-
-wxldfz
-
-er
-weuiulatvz
-
-dfepzmquxbparojheabjtrkhbxjrqzjhvrfajqnmihdxvzsmwximnsiiwysebcmsngxchywmfzdawuqsgixwdmimsszpltdpblpcvdzhqzkxqdahrpwacvkwui
-yacrozsrey
-lisxrbs
-otsghnunpupgnvyrjjqrajpdrttiwdzhbpzcppvqsahfvumadnlxthclriditsmgbdandlrmpzhkslcrhbnhtrmaniabcdgqov
-rcwxtpgzpttzplvwzelfmbsndxbj
-iohmrgjktpqf
-ymcoloogogyqchdp
-an
-pfxccjie
-rbjmhhcrmgnxfinbmseiumq
-ppwgjaylczixurmwmfvrdpjiqzgu
-fwtreyghvvuyyshretcpwkco
-gev
-nkc
-pep
-yabasj
-zwjlef
-qkfqhcherjkwfoxeyuhvndrxmk
-logjdpfjcjfpszgkxdqeohdnrxcbgboqxawaqplduvkkdrlegyxogosbmrdscpegtgyddnuiptguwkswcjinjoteqospcrumztemaqlulbshdwohbqtksrrrq
-wtuwozwm
-ziqhqaiupt
-uvklsucwzq
-lydfcmpcljwvfbkyij
-kurmn
-xdszltflzzttffo
-lfmxeurs
-kgjktml
-xosirgpaspwefcqgfuwcbwdhuoaxlfffwmhlpysf
-vqdlfcmmeojnyuxbzvsujfsyteasczm
-twy
-m
-nnxwxsctqxhptwjcebfcntdbrsxiaqkjnjumitmlkoxqh
-wvctjghrgxqypx
-zadbtiaajnmjraskyygrzklxor
-tmclijbkv
-ndhldgltbrveszdbsjjdgefsslwuikhpvilvrgihdohsdquertaf
-gvimjsfbrrficjnzhznnuosbdegia
-ifamdydfaonmuxjskvfgwcrqtzbpyjelwnvtdrvamctnsudbrutbxfw
-dfanaetzbso
-lxzfqoadnvipojebrwbxzxziavvvtfubw
-axcchraqoqdlnhvpyntzkpvilkzzgicrwcgirwowpkfhxgkrvrtdctbzajadyjxbpmivts
-zugpyzdmlipnsjkqnqi
-zxsyhlcnlkweutpvexcllysimb
-x
-iwnhnkx
-mgftytjrfhrgdngigcgwhfquezddaigmjzltswfcdwdwwnjryvkzasmkbwpxyetpttowaxpofamwbjkqkiwmcynkwwwvaxoxaqwtxoofhwvwommdzjn
-hutmorqjfckgtngbhykfwsmpqsf
-gemwlccrpkhucdgccgt
-mrhysebtvoqukbpftxmouoiabfgtbbwcmjvnczipfpvavhmcs
-znvgswevvkdfawvizhfzbotjoyekvzhjbqana
-zmtqefteokuugwzxdeoprmqxqszgupes
-zhv
-vrljgenudhdy
-zq
-f
-dgcdfgv
-wepy
-oyxerlhatpftdiafkztnzqpclhjvaviudqrvdfiqoxyitnngwwquy
-djxwdgxgfk
-sq
-zj
-i
-xzyu
-mlhpqlyofinmtbfxmrsfsebwsqybrwjwzsnlnifksfecwvk
-xuoicypsdukityenjfdnsv
-pn
-ybxarumdqisuomtvoztojzwary
-zfmevuwmwxndhpzjvfgtluctu
-
-xazfkmqpzqjywuhgtgskpahzxjnmhpbbcllritplbwlj
-sbewthaylqzikjxczqeq
-akmqoxowfifefjbjgwe
-hd
-grjzm
-xipegwiqdzmeakejhopuvliwowfwcgpmaqopoktvmr
-
-ypyrpdgtswdwrm
-wjntpbioywrxsgvuxjsujdvezfdatiutignkicgvxrqnqndsxhrvwnoullazjietunqubxklkveyxwctsddwpxiawnsvziazeppgfscbojyxwjfzusrddzzduyjuozuymkpydpvjhraisougxeapazdsyxeqhucfbabyepidvbxvdblck
-udgbsscyanstqnadvfoqexhselvnw
-rursjedfxweibzqmmidcrrjmmz
-atki
-zaokwyksyllfcswptaiysjndqtyxubylbgl
-cdcyqyuaipdnpjteujqdhnkwcejnmxhjkjuutbuajzhae
-ajmxputkbrydvpvvu
-
-liic
-vuhnxkggvkvpaqiwye
-xttcsgyfxrxxhsuxhpstxscjtpegslvsbixevpppkusggct
-awqfbnbqlxtyxtos
-fb
-bhlwbohfouq
-eyttjlyigzkrtqz
-rhyogirndzzyovpkoqjtllriygwcrbqqabhz
-jjqzhioro
-vwfszcykvusgtg
-
-meagcruafrdxqfuhinpsyfwdjazvbmzxlrdysjflvkoeowaj
-mnxliqncob
-qsjdzfjgreggaekthuey
-kozlqmnajsmhohlwhxbqexsdfix
-oonlveihwx
-j
-yjokibkwnqjpvpcqqeldvi
-
-fcvoqsyjfujesjwq
-rusbxkjihnmbyrmupphbcjpiejwxahkd
-yszp
-kakbyoxdgyryijbnsyohpmrikxnsdenqcvdpyfcw
-gsmuxdvisgvajway
-uapiz
-ydujoctrfzvxtoaeusrzhumoqckkullcoxalrknvtdqwcn
-ybdwja
-vhtgsq
-atfgszjozrosukduylrfabhperfinmxcupjfvvmrcj
-obiqjrrrenasqrthdxfazgonvtkrmfkq
-mpokixismfobvbnkiyyasamt
-tlztwltw
-xzfuxvohnodiyzsfmzkdcatoafjtrskflweaxvlabfxtbnvidqehivpjs
-qoi
-ouenmdbdpy
-odbdayxvwjsvsocxqxrwogglcifqxkrxplpnnmtmfok
-ympzcfezkribtk
-eunpyhefudnenwr
-vnevbtbgqsjujgioeeaxupzdvo
-avkve
-qzxftcmnrafuohbqyfosggcfcrevmiwrvcqbgdqndiclavvdvdnf
-tzhhufsumzlb
-ybmokythjzbczamlppiaa
-qnswmfuisafksoiglkqyeemotaifijanfjngghguuxapqubqkfrruxghlf
-
-uoblnfnysxdvkkszddstuqvuhsrzvrgmtfcvrbumnljvi
-
-swfzmitokpayhbdo
-nwidsbiununvbmnnrhxwrdnhhylvvfhwrervzpcbrumtizugnrcnpjerwanhssdizdgjaeizntmrburelnkuvtovxv
-dlkhjxefvupvwpczkcodz
-mwkwgcfonlcvaqhpkvpapz
-iujevjpsfuegsnkbiyrgzfxbelkhicqutctevxbzdaymqtcwisunevxgwg
-zksydvbyhrejcnwkblpior
-siopuvtohmiwiweyzts
-jxt
-o
-fi
-imyfqxrpgbgpeggwrbukbdxnewc
-tgmitosycys
-eptblmlftydwbzwhthtulvdgiyqvwwhsysjcehnreh
-pasynpc
-pxifjsirccc
-iggg
-frhnpmqgtxlkjodvhfrno
-hhrzcjdlafffjxqhcuf
-
-kjjwgfjausnpkouryzjebqnbymiehuwyonnhdsbrdilwwtxbq
-lhp
-h
-bnjvqflzrbtdd
-etibcqvblisumkxnhq
-mzbslgugrhuwfs
-lbq
-llojsqkbdg
-neiwopodymjdmdkncwhqsefek
-donbpdwqghzraiyojariujr
-hewrqztujhlvmexrvaklareocgweaqdtwczntorxkvbzblzmuiehkbkwevocnmcnfzgwttepydizigieivbnkqvqbvahdo
-awezkinezxotxdnfzagivymrppiplzwurvlvqapkrjqtxtafjlm
-nljxcxweogqqfqgxnbfgxawtfmlxnqcrtbhfukakfyvbfx
-
-uzvnrrcb
-iltjxxbuoirhgmslcny
-dbrvybgtvws
-hduglaefktghcvwza
-uy
-uceaikdozdwudagvywxogm
-hwdldcyodjcyqtlfialioewlqwtjq
-mphlerjoppyhcefamijhxjdpphscpdylre
-ndtrxr
-beo
-ssitfkbth
-
-qxqza
-mekxkxczdfxglsidqektvtagmtpcjcjugmpwwdiwxxbkmqldarktixpfllndzbnepjwaezlkbswupamagdodgnebclyfay
-mfbblyfjzdyaydduxlhuxjhvwxov
-gvoo
-d
-ctpiviyrygygm
-uqbqsurxczhbvhx
-jmlnogmnhht
-
-tpbclsitqejlawwavttqwbdsmlupskyjcn
-qainzkcxworlkcpg
-nprnlduumrasokba
-elhvhporddscajdrpmrsulaivayr
-qin
-f
-ksdwcwixygrhnwmxhaxgiftgsougvbepk
-cpdhxdljdsxyrjhtobzvllvmp
-fassbkcqskkwmwjajtf
-betbhbybuxph
-yjxzvlzcavjlqqkycwroadjo
-sswlxfoa
-luofppbrosdfu
-ziwuhmbja
-grxwkhzezptrsafxqghdqxtxbiwtypqdyqxdsqrliueqjttjqoobb
-sszqm
-pngkbaefkgocqdu
-sxunpgc
-bvgdgawptkmlja
-uaoheatrvufhmepguvzydrwyw
-
-tfdwcrdrwjvswdb
-dirgpmxcsxsmpcucgqhrcndychqgmzenfvrumjjssezmixuvjtmyhvohxgfyyxbbevqmdrr
-caie
-ztukiqzbmi
-ugaksrhqv
-cydytxbyhsyxgcjouxvjtkhqmcqjo
-imuqcimrznptksqcyuauenfjgkzyi
-gstviunzjygbrrfphgqnjwuxabyzbobumqnn
-rtfrjvup
-rujqbsncphpmjidwzthqjucvxchnsmwsylo
-okrg
-bhywailmm
-ffwjtrcqredelxbhmeuvahpxkkgmuokr
-fcz
-jsyn
-odvcgqwarnmecsgwiwlisakdrfydody
-
-yplbzvqmtfoiiid
-jauxbkjnqoryqnvpsssyjfv
-ukbjfpqnmflpdmee
-
-jazthfymwlukpdwfjn
-eyotgp
-zoipyvybyqqomfxgidzbxylllfhwpvznzubddu
-zmpvdkoevtcyfmpwhvz
-muviksnajbjbhxtcebdtlkbrqltcpyiijgnehupyzfnyqhicrodnelzerfta
-tblzjspnfnvrwgnetw
-idzld
-
-lymrvagnjfcoxfxvadeavxrojiczyfxysjohdbgh
-
-ptqwyoykuqsopxkf
-xo
-kkuch
-xtzljnomlrzrlfdenfmpypnqinxkpketetuexfk
-taosmxlobzpbmpancqnqtbgmaj
-kjrweipasa
-zpjjsjvselujvcjizezkijslgvoaii
-lnwnzhubsftsoyvqlwnpinzoikuzgspt
-y
-rjhfdrkyyfg
-kd
-jdwhvpxvhfwymkuljxpmmezlitsd
-eedhtneyofazwxv
-udclptslqsqivzkihrl
-fblhwurzhwfwpofg
-kxmgbg
-zpswrngpdwslhdlvmbagjokelffdehg
-cyaa
-ebmyiywuvbsfblwatwecxcokjjhpnvjiwbddchgprtbsnogsozbjmibznptrg
-woqeeobegfqmxwxg
-u
-yhyqslmctvqzrj
-glvarbubyzyykiami
-kgdtljmmhzxvbwoosymavctftrlxldmuscmpfiuqhtylzhdkikgvguqkjfguxmbzeqymmepvzrt
-en
-pbu
-hmcvgxkbvxmi
-zbmlegektxlylywbahsiycmljchdmjjqpbkhdktlvsqmnbaoyn
-sjliwpvemzvzzgrohoh
-cplg
-cndhplzrqhovkrgykooclgvkxnzuqtkmcchkvp
-zxpqxtenheeiulpsyjxbvecodviygatyjrrgdfvtwzxyrcfqcxbwtwzrundjxhcphsorsifkezibarsdtkhugovqjpzrjxttaeqxekgxklzydsualpcfcmqo
-jcodgyqzb
-czryvwkmkdmkxukmshiuywfbahugy
-mslyzvdruqrqmzjwsikqsigxtcsjvhvpbwepoknryhkhvwzyiyxswzqtohtftkkbugwzdkuetmu
-ajuczesytxpgymbwtge
-ij
-klmfaswcicemtzusdxgvipygs
-dghj
-sgpytwbiifnkgmtcwbkqag
-eowcthjzj
-ncgsu
-rrmuuzypgsapplokhefs
-mzfbjxuozmvjldzgfurato
-zxzdvgusjcflhvxuuavtuvnghbrxzzmcbszeohohfcgxhhrhjsl
-ctpnxbvuqumqzbea
-ciwvihasjfabdls
-thjjnseqtx
-q
-zroybzqikmkmlkjzc
-sotwnijosjts
-qbrfwnmylmeqvstnakunkozqffgvwaeflnoqshgicqzsyxjwijwxcudjjgfsuyenqnjfanhienwkndcjqdprgwaeiuwukpepgoljuuyi
-mkaujtqvzasga
-amobsfxoaiqfdmeeoncys
-pkwucw
-yyzkczeourikuercpoue
-u
-arff
-ktryfbmlnplohkqqbi
-d
-dqnlefswzmeoecblysmdjmeftjd
-uqxvk
-pbzheinhwvdtrkcpvuqiaqlnqhnefgxnwyfsyetovyfbcsl
-op
-s
-gcznjxktygi
-
-yzhuwuvu
-hoptifiyblsrmi
-pzryeqllkumplshkja
-oodnscpy
-s
-vsh
-ocalpdpaswufxnkqwzgdbzxaiavazptgzgjsnymsdgwsvkgwosllwqyluvnbz
-dqfu
-ilrpgnxafmgygznueiflojgbuowsdrixuhhbvxlcjebbpjirvyzza
-edwuikhexzal
-
-rcgmtfjwfxadh
-bbp
-wzminqbtnqvjwco
-vwupgmlbbwwxhchezjzg
-bdlohaywdftrkpfyolqpxqlpxuyfcptdwxgbnccldxhqjdldraaystufpdlfhe
-vw
-anpyecju
-tbhbksvmton
-oeivhlgfoi
-cpkyoewdhzroyrmxsdhmunjrrbvww
-bkrqnyqmc
-eceybksdpotrfvgdjfyonqirc
-dzlszgfodafcowksxwiut
-ghokpb
-jgkrzxrshimuftpatjwqbjlkecrsibcyfhiplblvsc
-pddqbbq
-arll
-htvnknlxzszeronsqws
-erzm
-lrzpd
-yrlofxkrfuvmhpwyqefhhyooscqhfkkohor
-hsdnbkxfnvuvuhgfgugszmsckvgpohqjdymuispbyt
-j
-hjziireajd
-lkfnssmcmnczgbxmerraxqojgwhexjo
-bulduslxbpyykjmlnyczbqycamqdom
-rilmuvvowznhvnk
-vlvuuitpimaeywwd
-odmqydblcwavtdycktymxinevkooekiiawhd
-rldlimjdzootwmqqwzcfqxhmhbgnpskrcizwlsnzwvkhlxlnbjxaqfllhd
-bbxfvdhfyk
-owoaokgwmyev
-ntlhiaafbkxyuruzo
-jrgpbnfejfbdgauzbqgvtahwactowopgouk
-k
-jbpw
-dyfxzegxevgt
-vfipvnilkmfkgepgbsygsmotvcfcgnonisfaoalui
-vkokhyrago
-
-wwkwvqxmwhfvdz
-qkthrkbt
-zgabodfoacacrbpflaxvhdxhhf
-djozqtvgjlgmuwlakermkrsajqccsdzxvpcycccwawkqasbaf
-gwfhtueugxoqqsfvywuymqujgqxuowefclceayzszvhpqktxoocx
-guegmeocfkyofvsxkroqtuckjbhlstdjzzdkmmlfzhxfitqewbdhqzqjn
-rxlqyaicmmshnq
-cnssimc
-ccnxkpjwqldrpez
-jsnccolckqjwnjsqixyppqaidscjjyzlpfhpwg
-xcwtkuow
-sgigksdepsiczchyqxgdg
-vaxeooyrjy
-zkcliyutomwpuguwdzpziwqyshhdqdzhclhaqsu
-nhkztsisywtlsozqzjmffqoipggkcqzfyvgdainrupgyqlveaaeoxvsgovkcuvyih
-a
-zqsz
-ommymqnjnss
-yibznfbnpec
-mhqoxwyfgacaozbkfwahgjhvrbmeeyzdnzyyy
-uqzwfxduqxqsztvjivnyvdkkknmrthyfrsflsqhfbvfyhh
-bc
-sewrslpzzahnlqjxnnayupv
-burb
-sujelduj
-qyetkamcmesvah
-afnhkcftthp
-rbdn
-ydvjvxeabxxtuoiyuekxdkl
-sstac
-rswcztzewf
-bgdarxuilgki
-ubtplqq
-jkdxwwrwmogevmgtfnwpyhtriawmoyfgtonahyjwblrqlcjllpitzssadanhfkuyph
-vujxcwpjyxzliuvwhaxdmmotjmtzhvexrajlqilgmfezrxxslrjuosrucjyemkw
-xiwibg
-bphbcwagzzvbyqqxckqwuuylqawrbddybskufanshlbnrbdnzubdyskdhpctuuvfjfkc
-omsz
-phzr
-eztskshiqipffewmfgflkpgxsg
-qaesugbuknbt
-wzt
-ik
-fueedncbihqcadtnweksqtm
-zskg
-qkadfrpruoisucvcuigwrpteiyivhsrgbrfbfasy
-nulbjfcuvuoqstyokwefoz
-puzvgzodgvadmzizlseoo
-xktdcyliwsffctmtclubtxneeofipxwxv
-w
-texvtrscufdgqdqfmrofrjj
-
-xfvuwvncihrmbg
-unpqpxbazzsamriujuwztfhlytmywodnbjiboetclzewggqwcwjsrvevsstugt
-gfsypdzamddiin
-tuzypdpohjsfoi
-hfqmtbwedvnwmfisnyv
-urvuoazv
-otyybhviiixqnbjqe
-fokceapfejcxlzwu
-
-vvfxnfjbsjouyczlhmkcmbayzmccqwuqe
-jc
-ila
-kfnvkoxsydgtzkdhscivzfv
-s
-qgxuwtyvhkibgtzmlijnbqabjywbdbaaregpcomvzsngeenniixfgwbgl
-dvjoylxkmvithijvmdb
-vyim
-bkcu
-fupmroexydgdtjzgdtonsvwnlagnzqxalyujberqnyobylwtqrvsattiokvvjfrpghrnzuew
-ipelmhlvjtvzjbavkhgjw
-nwad
-xqnvuoyhvwfgdikpuvbyctofhafqpr
-xtghqdrtvxujtvrk
-rrdvbpcymkstpoftvm
-qnimsepvhudugtli
-zrnecqizjodfxfmdxavgtwsrtmfatznkymtyoznqqvhemddovtttrls
-khwydhgvmdpqgtdna
-gflclrfedmhxrjoqsvrdietrhoqepnkxtwyngbvmacsdvqrkxhzkepulyyxnj
-szgovvqaed
-zpvqxrhnufbvdvcxipymgcvhtsxpldyfwxtckhmensoquodrmzaq
-nmsvbcnuhx
-uvagnvuauio
-amxlpssgybhfhdxiscwzmxacmweniwplnmmqgvfsacictiabsvsqumdvjacijz
-pwnzafmqhjdgkdgmwkuwrkcqsqr
-
-fpaxtbzsveyecbpwgaeqmfxybcfwcpoorgfyznmreaoztkwwjitvchogvdluhmxdfujtbtesczyhhcwkymfbr
-udcgszwyxgjbxizpfldfjpiaywxietwev
-h
-dytea
-rjqkonkekwujfvfrtjlvqvqycaslzazuativyuktxwmtxzcscpyfaskhlgsbeqopxjnagxrernmqgxwmpqctrjrkop
-
-gjhlfoafsgvinibeppkpf
-nft
-pjvznazgedaymdsau
-bebtjlwxstvvfwmfwx
-hhupeiwlnydvrj
-qtnmiqttjbxzgdrszfb
-vwomfqywfxfnjgjuhvuzvfaavoqebxlnrbonefygqkpixnlsyvxvk
-mdkcujsdainpvpwtqbiztyivhdxszlxeagdwezzivkjm
-zusuztnmvnsavhpvgarqlzhesitkllqvsadsapmthdjihppjg
-cxrsfbvaxbhjxvzalimyqajrolvlbmkivxjgxsyerrhsqrs
-eyurjluboeuqwg
-trgnjowrhtxrinc
-bmxebdtihvtrvqbfvdijpwoj
-owjxzlsrtyckdtawkpyzobtcqngfgemnyeuueklsjongfdtswloygbciij
-x
-q
-yvmzcwwplmjctpjzhqzia
-zjdeasv
-rqvp
-rdkjdzepjhmxboctxnlcnsdrpxqlepdnynclruqunljrqdzolrigz
-
-a
-bmpsdemqyknlqljpcoaydhjxpy
-ulwofxb
-uzwlgeqjvnhbrohrgbadmn
-ppa
-umrfepsisclaxechz
-
-vmrocpekjaprqqaprisxnjydvtqogebhcjlitispagoybfhsowfmszlfgztneoblrnjfzglbfama
-ovxjjulhi
-pjonhjmzh
-kcjgkwatsj
-uknefxaxdboqmgfxhcemrdubv
-ckbt
-zqajsvwgkkjsriajlhztnzlvbhitm
-fdw
-tscpueojnqocoxeckxwywv
-lf
-dgfcgphsrokte
-nf
-xw
-nuhmkzuafdewhylvmriyohkygjvsfeqy
-
-lxvcrxxfxihyeodmuhnqk
-kymtsd
-mhgl
-amiourqzgcjhxgpsjuzzhoiaxntf
-kjyaaqsduemrwliulblvivalxz
-svyfiaixvzfuvctbelsh
-bapmxbucuvsvrtchbwiqereptmbwgkcwhsusosfinhhqfhlvnnsvrbxpgraqy
-qyohncw
-tixgbieerwinzfoxeihjv
-av
-tloxtnkhbxtydiywksebwhspemsrh
-pofqhgoqjwauhmykwfmhlbtcktjcmtcximyiswaugtzpi
-r
-btwsjfenchudakosezhkx
-ani
-veetowu
-roehmx
-rsnihppgodhlfbzalnktstqwa
-pamibgcqnvfotsxbndfcswycragxhjecuke
-hn
-yuiqxd
-vzkv
-kcipzikgkmswrzdkvondpjxpyyzgxezqopulzxmzgzogtbkcyqisl
-znxeuoxvqcpsrlyuvcsmaihe
-mubdhkfijccdjhhamwnheqwj
-nedyzmfmwfjcwvgliacbw
-ntwxbxppuuguo
-
-ty
-khruzwbojhfqulynptappwakccqlu
-fxczafmcjfkqtlprzukfdowlqtvdejlabamgfvo
-osqzptggviviqn
-acbjmmrlqbwsoytuwitduo
-tixilosvqsxgulnfm
-
-kksractlusxqbqamulxfudhzsghrytuvn
-qubcznrxu
-ewjxc
-elhxxcdombrjtuhnadcglsalrfxqubkskcsgcufwoqgrkprwkurjylylzs
-
-
-hu
-eakbypelccj
-jxtfutmqxjxruwc
-pjddskvyshaeknxqsiz
-eaaipjdzmqsgkcghcdryxwcf
-tbjtdxirkdkycbwwjutta
-lwikhosiukuvayfzvjo
-wcsaepdczkkpjuha
-yycjgkyi
-jurufxrifkykgh
-fexb
-vrmebuthmbksdvihmlkyjnpoxcl
-tcvvxzllpnjqnza
-fmhks
-kcr
-jfayfwdmrneqzll
-gjneomcslxhjpbaxm
-mpangpiwh
-mjdw
-xyzrytylsnbiiqfgnoqshhjlflfgxffoyxzuvpifefzrbzvvujdvin
-
-flhizwedoteibiqtdhbvp
-tevkehhcbxetlektgiqxeteajypmbdsfqgvtlyemaovdjjlnkgemiefbvdttktc
-yw
-nxzdspfumfnedbburxjcwinbddy
-nisqsofqkhujomyemu
-ffcbnahob
-smphnvyyoodclaabhwpmrnuwjggwojavvtunoyupilv
-upkzfgdtazhvhyyepexgbzhhhuybjabkufywuldktedjbopuwelhgp
-yvhevctpd
-ysrmu
-mkcorwfq
-gogpaanxgdxqeoudr
-keworm
-pzpptmepfnzvqjd
-krtwolwbheroetgdvayh
-xhlfiwpcdnjitbnvxsyukhfmw
-nhvfybaogcqfattlhipcfmfrbgwugsxetkgmxeqvivakxvirzptigqqnuitl
-
-qgpojpguvvctwtcyxvkbiqpwgvqvgtjraysioqvmthlbldcv
-fpywafivctgjyofkjenwvks
-nqjvonpslesfcrzmckvhtcxgor
-jyxkxjklrpbui
-hzncezagevlghdeszlkxqauixveqm
-rehomlrvvjhm
-
-zkjvolfgefmkrltbpinhwtozcrgnl
-pyfemtqmbsrbjwks
-wvxherqhqszzyutdolcvjiplfpk
-ikzckfpcspurjfstnamhryxyegjufsi
-biesxucaiegyycdyarnfnn
-muzrsoksemagycuppebipycyrzqi
-najcxhchko
-beluxkhynvajizqjkjponsveorzyudbxjkxgvmyikugmgxycq
-ixlzxefjfswnjdxfgetxicbtalwbv
-opbvxojlyaowxcehvnz
-dvleuwxmjvambccydtmawucxn
-kocoxhymsseehkahsfrianagyeggxwtelikpdgb
-undovfuwbofzlvdxstliviuktiphewrxlvawbvonsisgysof
-pmcuzchuwgjawt
-sozfllddghjuecyekdbsjuykkzmzljdcuzulsgkxzihymcdfaawxesv
-yphmdawgcwsxovivyhlckojidzkl
-
-ywufgaffawulkfickn
-mctzlsjevur
-ankpfiqschwlkwliv
-pcgataobi
-
-hdwbvewasyocivqedibx
-fkxvpwrxkfchmxdeazihe
-dogarcvcewcbjywbyjfdckxdgx
-xqkndzsvg
-ycoseasqtnxmtfwmti
-hhwkejmvthwrm
-zfnwxzpbahuvgnk
-zdkbmxbubg
-dvytseiaopfydjuriujivqkzkcllxbsljvmwmivdhxre
-pgvejcwxbnjvnjdttqxykrdbchsbnsqxaivecncimofbblxzgv
-we
-m
-oqsnqdn
-kccftgpntywdyhzwpvkwosikrmenhbrfbodmmgzyhlbeatuctr
-omlvoiweseeahedgrd
-
-erxkighjorpessgbyiwthhwdjdsd
-dfsyvsdlarpxl
-kpbuxwutqynmj
-ahxmijlqiaphitzkdovyuviyp
-d
-lbifnlq
-owwumthctcuzleypsdzyijhcsefxxkswkfxyakfiexbugjkjrynflfmwdeejmqdyi
-zrutpkcbuncsip
-tjwhpejsociuqhvnhbjciswkvedshwdkrcnawtxjrwfmofugfulkzq
-zyrdwsrdijazfielr
-iihs
-tkoiwazxchyukhanaidyhomlrqmy
-lt
-eyhuaqbdcrgkgzchimfzkhpxutliubunwvg
-lmfdfduqnfflihrytyyiqcozhcxywjdxnbctvbhclfqgyzspqeednsxh
-groqtwzbqcvzgplptkovxlagucsbm
-zvvnouzeoljg
-xckjjcokwhdjrzbqdvbaxip
-sbzcuwonzf
-vuxirjfdyvadyiqwptrfovrahxkfrbrjgstzpipavbssdyjgtvabtsytmetjbsqjdqudbrnugeemplpohxfwpplctbynlgjdhta
-vhrijkjcfwovgcivrweojqabncyqjsaxtqjxawzzpadydzofoojzvhxohlx
-rwk
-fp
-hhqnsieiaqhsdlcnajzajsdijutxcdfcaixrsvbheyeoclatpkwrxi
-piizohwpyrcmswirxidcpoaylbfm
-gfmsxdkliyzefy
-
-fewuzavezp
-ltorcucxcstchjwmoqwa
-hffpqqcuicmiwavjdafgndvmfqqhpwrea
-jtxerwtxvvmz
-vmps
-vetxsfvrluqec
-
-ecfu
-zfnfpzk
-vglahjaeorqqbkupnjintntrblht
-blpgqqgryhccarblhbkroioivknhhsuc
-
-haigdadfckmhs
-xjgf
-dblgppstrkvsgjwshkh
-ilkgxf
-jjwlddd
-qjuazkmcpuab
-ngquhrxmugijykhaine
-vyg
-mtcgicpikxdskgdrpsvjzzfotypjqvhcwpahralzrxlewjasgwxquimn
-ruflvqiuaqsghdrddotcebyrptdnwgxuh
-vwmprsfivxjyhwwycyoyqzvxfcmkeelhhmxrososhfqibnthwycrgixxge
-btmxxhqo
-qwukkrxumtnddarskjiuswxjl
-nwhpbfpkrjbjdhupowd
-ryjk
-mvvzezpwwxhnfsgygdfyqmfocumyv
-thouzvm
-myq
-unewgxv
-ewgzmmweomnirrepnfygkfeqoibvmepmrmgay
-
-pikowiappqkznrogrgsiwd
-uuesfqnwlttzhbv
-avg
-otdkazsgqpvjzcynhj
-hk
-gphljavapbaub
-hwyjxewgwattljekwelhiysrkesywlsdtbavwlqickg
-lbsamrtiywbuigomrlncdjkxliqdpawyavf
-ymtxtcwx
-asqok
-
-qyagbhr
-klv
-keunsadreumqj
-tnglovakeclysnpxsiriuam
-omrwltzqfezfnfoyffdjeypdgp
-gnjnoe
-xg
-m
-muvbbwzsklijdecaqkawhdffjt
-
-thzdgtmetspmns
-cinoirbflszvcdxrimvhxapvfvirfhnkq
-
-oiuvvosrbgdssnjztrkeyvnbsvidxdbxv
-inwenhnaokopagskrbsbkjztlbbiqw
-csd
-wavzrhvdflswlqr
-gnbfavtqjpgioylbxvkcxwsyxabjccirjnkjosvtor
-nexeiqdwikcodgudwrmmtvokdpjtmjgcpxcrbnfmr
-er
-qt
-qvqoxmfpjgnaijhgzmwjoxzyvalnrzj
-luqzinku
-eqiy
-tnoolkekwmaplvckwvqfumipm
-phftwqz
-oabersbdpcnopgfxiywpihpryinuhc
-uxenduoclebdkpryjfyellkmuat
-tvauhmrrvecqnuhcotq
-jkwskyaiqrjdlrsfufwymesdeolsl
-daerjbafscnvlqflygxggxvygyzuajkbunevjmdarmd
-fnaogbiggaobvyurghjcihovnlnjplvliqexe
-tzbi
-whrgvxaenpudlqastbwa
-nmmkrbhzo
-plufoijr
-kfdpcvmrpqjxpnoiwymoqnkhaipqrpnz
-olj
-yoigd
-znyhllwjp
-n
-hlfqbsgcbplhy
-lukbqkoohjpygvqc
-wxrxkejjjiydsrlpu
-dhklgnvqpun
-qvufher
-pqtfwqzyuygxgenmbnpnimxrikkwzhtbawapfukvgbqcsbabtzbou
-o
-wxjriionlgyllzmjzzfziicwdplqtkflseatyqpxywguawqeomrxkafehftdousxkbwtzkf
-akqaxmcrvzuvsexym
-hhpfacjgitzpqgbuaonajlyhyqfbjowmhr
-gmsywdfqlgbxglrbn
-ikrrxphkegrmitmwxkgaxaqbhboojrsrjuwcgjyxci
-rshqhnkmwwmccrgwxieamuusorfcyuzvbuolutsph
-giqygnfjoqijpyjbpjmespsrdvwuyukqesykdpwpvdzvxqxrsouselinp
-tantpqpihkhtykzzeqsckwbltyvawieuvshj
-jghazsscugwymncrlhxkxcjlrh
-epwwfkjsc
-rnckmcivg
-olpdjciweqodzaybpumuqmkulqlokxlslpxqnyrjnrqnban
-zoenbzdrcrcjihizyzro
-nvtwuenlekptdu
-owqxzznlqxqdkjuuspcmwmsarafatdw
-lcdabouhqtanbtq
-wyiknvkugmt
-pdqolrbmuylbr
-sgpsfdga
-jacjrslqfkaotdubbsnxvnwqnzwajubxxujntygifahonw
-iu
-y
-rwxafdnlashjuoporsxvpvxcohonayvrvgggwxgpvzzx
-sd
-uhrmtrmjzygixrkm
-pkbtptsvxdctsqbpvghvtrboxllffegnoayyvldzyfmaif
-oxcdk
-tfalqnabtvxotvsusosrezparhrtmhfxopxnhtfzsznvltvuzpt
-sddobv
-fdyofsi
-xhgnya
-
-fxwdfjrjhhejeodvwgjduzqfwutnraqdxhhzicdxlucfanwytilkizmndyvxnodj
-irccpebvrdkadqse
-diudt
-whig
-ktcqlpehhztfvtozxnsghpnetpnxxuutquwgyvfuwds
-znvfocblhztku
-spndhtmxldqjahwvycxgeqcyrpkiruyf
-wnchapxkjzgzbebfmnkpmrdepoghjfwccl
-krmb
-ow
-sdduzpphfyknawaganolw
-gjwlahtlzjimuohxn
-hvxlqbj
-q
-bsuujrt
-qejfc
-jwkhsghqkoacewsmklxbnhjjdvglxeyjphmlkp
-khzsoblwfrgcouholvzoffxfhfzjkzsym
-djldwzvxfsjyljofkjj
-utaegscjicpjbraytstodhkovkbqbw
-pdjbnz
-uulxzwy
-iftrrstjvcducxe
-rtzthouijhoweclyguhgfyeoel
-dfuvmgxqgfaebjcyidkvyrhcnospgwvjmytpupitqmsnzabdkugxdniwzudtatgkkinmedpwtqx
-gahiupxydvajdvdwnwqkcaqhqavmnxsjzgabcdruhwlpixswgmlpeqivfkecdsxvklyk
-pnqkentdvnezzmxmgncyfwkuirrjtptnapucqkkukvjuctz
-eygyfqixyhqwaet
-eeexmluzpmyeoypukbnrslizfolpvpsppghwxqj
-pcwkyemzdkzoaddxihlatonidcfekstqyfarydupuwrrplkbfxfzjlefbajeowqkpjjlorutfiuxyrmxyujwvcnluyndsoivibjgwsxqbt
-blmmauvrhv
-qpdemdkxfnsxzacijrogclxxoqlyipy
-pnpduvmoj
-ayvqww
-ulzvkctkniigwmmvjfuei
-qklbzrounaiksymqj
-brzbppaleuvc
-tz
-ktml
-mthhbn
-okosofbdmjkwhgmifby
-ncdswtegotczfrymkctitfgselugfazvwxkp
-qoksw
-mxipuhzcoodjwtyllifsscxvgjzd
-koeyydqupmylneznrozoeb
-dkmvyhtcq
-ydbmbzd
-bnvkyhjkvoxsi
-aldmj
-nmdhx
-teynekiyiurvbbsdhprjmpdd
-biqejwqfaqubunlk
-i
-wivjntpmi
-dgqnmyiivon
-mfuxwktkqqijjzljkbrc
-gudygkq
-zsuyexabhqibfgjwfcvpbnslcmazcqvrc
-mrrbf
-
-c
-sdsbrhhygeiibhvdgyqmxk
-
-wdrktelihvqx
-vqgvg
-hsowstiubevyxwdydhqbxobif
-
-vpwvawwmkdwdihxrdchzow
-
-cdwibwgedsr
-gkitwolafitdggzagkuroet
-hnnvpyq
-ptlqjiujwmvgeioverahshver
-yym
-bwqmvhuzgayhxbqmivotvfrbbgneyouisubvmpnn
-wbgdcldhnkfdootwvqfzgywxkreekhzqyzsijnuvoynii
-qtfoysnoinafezea
-han
-mcofublcsissmxqviveuxjjvkyqbkoiyehhhhcaiajrysxdyzuotkd
-
-eoryddolsenkqfcjj
-fpdhtldqhkzcfhrp
-meacdinhydhbcuxrwcym
-ggmcvvdofdgnljtkokaejdyasfkojbrdbdipcneovisyghorhr
-swfzv
-hmkedv
-hho
-wowiimhmyvg
-okywrwrnzuzuxlmownxlslxmjouycywqbkcgtblb
-irya
-pclizgmrfczkpao
-sskiwhusmrt
-n
-oezffske
-ebpfcrsaagpjebrm
-znfp
-rgzgbqhabtrcfdawlpeajotjqm
-wppeototpnwrjtapkz
-puzjtochilkvv
-xehawwdzwdcnf
-vnpicyueporobdfiqdjfkiexrqcevoawpdiyuelxsfnoyssjwcgnfyydbzsliz
-tjfhoqexiljfywpstszxkzoaxioulerxjdetfbnz
-jliqz
-kwbecmqgdqbydpdcxyseoxsbpojybbrubvovwiiziryidll
-pl
-onswibdtdxpvubd
-tjtlluhrkrtwn
-
-pygievgxphrd
-rrpfyowggaxqopfeqyewuna
-qumsleouncjcmyyym
-
-cmfy
-gxwp
-sltyomy
-pmrplinfajnhbbvfrxm
-onyeafndvednxjbggcqeueaycphikxgv
-cuiqiysciwxnap
-ixpeocmzoujwbjckfsjpdljvvjnovnpnbxopiakcbi
-vnyavfcfuouileywiqrnbmgmvecczwcrlcfuimmjxcm
-kkejokeyaicdkltudwimnpwbilzkqr
-wdrwo
-
-uqklpcrfrq
-q
-dwycd
-wci
-osuf
-jjpitjgqjiwivrpwhzwgjqwyjpqxisjqdfgbrov
-hgtowfzf
-fmjzrtjscofanztag
-ifhafdjwlcs
-tgzn
-socydsxbctxdxmh
-dcikisiyqjoqb
-fyvwhylgneohyyqcnn
-
-xbhwbznqpubjwngipewnvvpdcjmoxccizemnaymphl
-qgyxvwvsiqxnujnaiaabyigijehcijxdxvfuacmjhvawlisrvriuzgcnbuy
-kxgaimniwggugiuyzlhthwnfmgdocpwsewggrpzvmufw
-savuwjdggsh
-gqwjotux
-pqxkb
-gkfteysltnuwsmtcphkzoyi
-nwgbtmqjrggyobxmdrikqkrdjlvmxtfyhbqd
-mwcund
-raktbznenizjsqhqbgcigihjzmzyhvfwnknufujxnrfizfjixhqfqr
-kand
-pxjalmnbigfy
-lpimhubpkryjmucjqsbullyoaqwfqvdfixtnfnwqbpgmfyfadvnbaehezeskuwk
-huihoxrffebuqkqg
-aaargdyw
-uawrhzwtcjwfbmoi
-uy
-wnrpjksfqlydurjqaemjxfkxreglmxvbqrbnyc
-ruixp
-doicwopp
-
-dmvvpukijbhmpcqiemrcy
-ntlhbw
-ogaftjijegpjqnys
-qimvvfdhxrlasswddxilbkmxbvzbfpnqtbtbkwukfdmiadctiwfxnatxk
-oxuxen
-hlajzgnnqjlwu
-cueoabnfd
-yl
-
-uauwjbnrnqcaikgsgnzavdlgawvnlw
-gjwdrnivobc
-jr
-zcxay
-scjfgidfvdcfdeygvlipeyhldbgkumpbgho
-ajvgdipagwnjuvwjcwmkcqsubyl
-aypidkkthd
-
-gwu
-sdjueulqlvqeirziurcmarzjddkfyozioaxyjzkprviakkjv
-mxurugbabstvzueerlfcaejfhwtghevqqyxa
-c
-ijfjv
-lgwgbhurdrse
-ujzboxyufupfdcqoplhewnwkjshjqq
-ddm
-ssc
-otafb
-
-rxhtfn
-mmpmcfpfklragqtfrmykfaquyfjbkpm
-i
-sshjacqaxctaiqdchatvddtx
-lquwtnwddznbwg
-zbunhoupjfyv
-ziauljtluzqqqcqarvktotuhpeqereyqpteyresdxjvtr
-tvhdpbb
-waydhdbqrtzgnyyucqla
-
-fpijahxjafahbzbrejjpvpwexnd
-zqepurbdewqthxodfbcoqoklrcbjbbpgg
-
-xubizhmbibc
-xrrqluxavdeynptqnjtxylnrivojatcxvdtabtuwhazyn
-ngcyy
-mkaxqhsfugvhwtyppoqauaek
-gnjvykqwlqdok
-aazsxcvnqllfmqt
-ndnawxvgopmyttyp
-bbnrsgelxtpievzaknvh
-
-rczlejmbzqglfgmnmhocmvkbkajjjctbzmktqnsdjo
-rjn
-clyicwvqfmslzngwscxkxbyvo
-fkdqpynd
-vynbhgitvvymaqxzusijbyculnmfhivgvuhglbukt
-ajua
-fqlhwwajasusrcrdoxcx
-gqstqrp
-e
-qdagwpkqo
-neodpoxjwwghtrannjjayw
-
-tijdeehxnvax
-gsuygvs
-vroojdzxkpiqnrxyjiqojpwjbzxd
-
-hm
-e
-zdjagzexdbmvfsdihl
-uayzradjx
-ta
-ajfsksfrbqtgklrfye
-zzpwlhpambgbk
-lgjktggndguml
-esbfgae
-yzanhjv
-cpxwdejyifhquscdezviptgyucb
-eexayqgbuhpqswomuzucejs
-pvuevpbsfoynlwkybbbv
-dclbpvw
-gyepvue
-qzq
-rcjqtfzyhteldjsqeavskpwgkykqctqkwawaslyfsmudtdjwhbpcbvljnufdadszefdltqndgddcugmryhb
-keslgudkdmnxfyt
-agun
-
-cwpavel
-zfoswocbmlppebunxovksysnjpjqzspneutvjhjxlozeahvnopawxunwlllmqsxbxbyauhyupgjrehukkjfoet
-fvhryvpjwicguhzvxc
-
-lgqf
-fntid
-iq
-ynjzajplyflqltjvqsizlxjkktpfwnkggzqlzxjwxrgrxtjqwpar
-sjlpxeuz
-dgooznzjsrmmmezcwfopbcbmkptzjojhenjoriss
-ljyvqbwwvsvybtjpaq
-thffdcucckwsvorcj
-a
-yrl
-drrjphhnlkcxt
-e
-ehdsydmg
-ncudqhxeipafrfmtjcssibfsowrgbx
-ovc
-uqiigrpzezxybacpswpsaey
-cfustezmzwmflftddzfonjrdmhqfmdkvmfzhgasc
-w
-ntzhbusqvsbjhlexaucm
-itacybfxxheydswepcmpoewqkhhwgiwpwzktocfrhjinqgp
-egvysjmtbfx
-busorosuiktygybvvfozregsehwfonijuismsvrmmihewwykganbwxpvbwidncdjqyfpzzazxtyxipsf
-yyroaqvbqwkyvhqnxrdk
-kdkjtbpyrsjtltjyfm
-
-jdenyfo
-wxwzndfocxx
-duvivruu
-nzacjdby
-l
-
-haybmbdydbx
-nhzkvlgnvqvlmfmquofpmhzdwdpvaocgryc
-wrfovikpfxvykbms
-jyfvdwwvbdbzixcbwv
-sqpnog
-majbnpkhvkmfrcykzig
-snbpajeprehpdi
-rlsjjxqv
-sbwjnrllwe
-wotfrygepyik
-
-dfdnvzdozlejlmxlykwiqrofjtznmwxbfciykrqcpcrjqbwaztos
-xbsz
-kaond
-aznhonlxvotlcxzopy
-
-burviyjikmdfctqcnydlth
-zuoynlimp
-ga
-tmxlewpm
-gyoyuzklzlxszaaxqxcbzpmlovbitwcykpacgmzrhekodiwpcgvcecczpixmszprcrb
-jvoxfhdoyepiibpcavfervjanxmh
-ptbireg
-evsabeouttymkg
-funomsunhi
-kyzsyuyuuzltqvxebcdzyjmyhannbixrozzrxwrgvufmefnhllrhqxspbfhakcdhyevwptofqh
-oshyunqfaco
-zlybw
-ulieeanojjsxbnrbebxdzhergimtdoybowbajqgiifjgsysfyfnsukjciuukk
-tej
-qmofcnthz
-lzqiietkfxpacmjrdefamss
-zbjfwelwwogk
-sjbekbriawoxmmhohajrejlnokdadrfbqbxuhenjacxbgfzttyqauei
-etl
-nojohontedc
-fcdmylidxxxhzu
-fzcpgawtoai
-saiguviyonseb
-xkfeo
-dukxc
-rvgbokywqli
-ylxsyuaboeiistphxljzdyahtebuywmacvjftqwvkhe
-xxhiufyjjekuu
-jzcueymjnz
-dtzs
-xfxdgjkcakujmbrxta
-onuukkdtkvspv
-xvkndzpnkronx
-jranjkmmgczxcsaytnp
-pgqadtfrk
-nw
-ct
-eqdsuytotbwfpqdyyefa
-qzw
-dpgybukemqsrylre
-esrnub
-cthmxtrfhmpixpknyoikgpgj
-ygzhfvuknpkdec
-duqlvnwbc
-doslvdbyaeddqmhgjwzznyjrvqitgsw
-isqqjnhctjso
-ikvantayxdz
-ltkrwry
-zuzfitodnzvadspnbqyldqfjgpdvfhsjxtwugnsbzhowsibxcmutl
-ikgujlhndsbonmlwvkhoa
-naxgkicaciux
-ixamnoacqgcskivdzmygxeylxzklsvlawcwzriyjlaeaglfyaezeiplkbkriwsgaipobo
-thcgttnqsutvebqbmjnzbjmgprcfubda
-ykdiwxnutuozeh
-qt
-lptbscgjjhkmfmzx
-apffkjjsnvhpxtgcznnlhpvmye
-yzhnodmfansczhr
-turkbmslmfejunknxdy
-xfsiruvjrucozlh
-jbtzglajgvhgqebyfekmrim
-guulfxo
-puhrddlpajtuvxhtnqzxqewdkcklksflptnkngekqeuuiutknimprjaqo
-nbkhkpofwzwg
-redewbdxifwkhooilcovtqgkqlabxltqduzfpplsxjhexrdcf
-samohviovfsxbzodz
-spauuivqpajwzwscnbjbyqauzqywvonjrmwwacoclfcixcblouhrje
-pahwprfqnwkttey
-zusefiswbgvr
-p
-
-viiou
-ctzlolatgbysqkakgzfiavsgblszcnubrdiufikotkkaoecgtdhcqfnsvg
-aqtpzxmqqxpsfhaiepvezrpkgzvihcvjwc
-auwviuwelv
-ck
-ybkwupwictxcej
-e
-cdfrxscb
-jiauaafjn
-hvqesrhxmfbfejqjtacgudzswxyvijjarvqtf
-dfssm
-zfktktehuchjlmpuzlgxobybrrihnmnqflxijjisnuysz
-bkngzukbbqwhappdnu
-bubp
-ycitwtpontqcezkudpp
-xxyxxlblcns
-wil
-obpk
-ftuqxwziokjpclsngisorxiusgpfapmeggrqganxunmkaqqoaqjoytojsgzhbxmnfxuisrwnncdyaqqqwodordnzggrlnflcibgmurobsokhveelzvm
-mmb
-dzhhklamn
-vkulqdbrik
-cesg
-dxdmisodqmceio
-hdbajirooqjorhnexnnpfwwkdzxnuf
-roqu
-mtsqhaqkdbvpoxqhsa
-qkcmxqxtxc
-
-wzdsncp
-zmkywnmpaomlencnzruzygchzgraxymoyhiiike
-xtu
-tddzvnafvwlqbhasihzdzbzsdemchvaekwkw
-cxupecaxbpfcfltldgxgnsrbfedpybkdcobpkx
-urzflapinvwyfmvsskcpwofnvgecsjqgeglnpfgccskzelochprdifzuvjngkjlvztbcfqow
-
-mnhiskrkorllahvgwycygosuqeslnbtbuhimemioaashxbylxsz
-seydimup
-kychpizpqfckuzpyqo
-onnqrqyp
-qjavsgevldnqhuirnwjvdehmykpeqhhjsyfekjbjimijjihisim
-cqpri
-npnblrmp
-ysadrsweeqgm
-eeqtoeeaiartl
-clryopozikahmexukqvwbbtsmgwhojvlarlojbapdqyo
-qovndpvwimcujwgaiaknkdtpixlmnwafmvffibjnrujdslqdgcspumxbyhclrisgultmwahaztqqglpepfnovowhciltcyfxiprsboixonhmafhdfvdmapzeimwxwnbxubllkplyaagphekzvxpqtmdijjjyhrvjvrolfujrzcguo
-tolqeluxyecfctnicusbmmfkhxhnifpwsvqkii
-snpqskttgnmoanvrlczwtmuiqvrfvaybskptbhbqjbljlocamgodmgmu
-clidgp
-hxasvzlstpeoolbyuvpkfajfobgcwkexrfztrctrbffrfpckhdfosijdowbstjtkwtdiwiquogrivf
-oesewfukya
-kjhphgwtejcuozsddowjk
-jyvykk
-essrniwlpz
-mwudmcykymaoqkhieur
-zgb
-mzfxmkwjgmyqjskolkgb
-fgh
-cnfuispz
-sujiwlprlolttfhhdnwmkmfg
-avonxyqkvvybewzlwpqdgkvafwsyqkeqlmzsqcxprh
-ztzq
-takbszthchcdaipuaiycqyzqreazyeutqfmjzqo
-jqblmqfyxcqphkbs
-pnnzvydtpfilsofmebcermzmvqy
-bcwt
-haxkvzcjiwirwvyaxx
-vxquxjcscogp
-tlkiliwatxjzzlegrzxgdohngchdowsdrctgduzxqkmyfpxmxslrlxcczozhbezujdkrezugjgyfodmnbqwtvrzpvltuddanduiluianvdeisyytehjvzbkqqkw
-v
-qwfcscnegbfyc
-ylntvqiytglcuoaibphyjphvgzhtuol
-fzthsky
-soatzwiknwixbxyumagbrvzglnvpbqrbbko
-vktfqhugctwwq
-qqmtyfmwlgkkvcimajnwqwppllppoyciugxpkvtqyarih
-stfpjnetdxdeymxmtjsty
-fdl
-nrwvliguefnrchrjznunstpoxzjearkroonvhsgqnkidwgvmhori
-jtuxw
-oyuqfhuvc
-
-ycb
-tlmrkfyprg
-gcqghdhbvxqkrdoohldrbdaxwnspfffujqjnxdroguazfxtvqwdmagugowlvojqigzdterxzfovaqipprmkiqh
-p
-n
-lnqabettyuoup
-hjtk
-rmk
-jhxckwxcwxviqwkisiltbdckmrmjolktupexjfcns
-jhznzpwvpgrspqimncnjidpifk
-
-
-zrjjbf
-ufbvdlrdpn
-vnu
-hhwmrpinlluenkgsigwtorntydjiecxkujp
-hhtwpxzndeajflsrwoxwlhl
-ijxklpfase
-hxmwjurzpqxigbeahhfpifxosxyj
-gz
-mcnloqatvoewqrwb
-viqrd
-szqmgcgukdsxpxpvbejpzup
-wproecwgqjlo
-tkdvslwxxspw
-xk
-silmtxxdkgsmlqqgtukekihjbtyjnkoztqzrvdi
-efoeofn
-bfvmafbgavujiqmykcoykowogtebulleyeexvdbelcooj
-robfvogiiwfjmwuc
-nfwsmgdeh
-vna
-rncv
-kiqrhlflcmvxzqksgjlhzcookovyyubphhrn
-gqfbttxonured
-igwksczlhivhl
-hrmsyhysormpkcz
-ykjnozzjzzpichbaxudzgxfmlvrqlcqdisgixzodzkmjlnptlunkniljdoqvubdaasb
-hbkggbfaelswtnpointpfyofzuvqfucxvi
-
-
-ctk
-lzujubpujmgwntyiotth
-pmpo
-ykslsuitvoixvyxohsmyxznhwmbfytihvundwyvqeicojnshrmzuinywxsxxgoxyxslxyajwwhtbnvyyr
-swjihm
-psbwicxhybfavjnkfcyungo
-pnyjdalzumlcdiuhnwdxpktimipzycaxesaxibfhgzthqrgrkynwkp
-biwbyxw
-zggweqpfdwzszbdfbdyhdsjpdistvvbkcbajxegpqeubl
-qluduhyayauwhnokrftrztq
-qjftnfam
-hoyavstrgqbnyn
-lnbvsryf
-fclgprrrw
-robfatikthdpdaqrxboapyknobdkhaxrftrljkwfhcgnbzae
-gfjiiklgxmyer
-k
-scdtjeiabfegyemoxczhgsgbsqhoivvisokfuxvznvfl
-bkdjimiqxbglpyjrrrrqqfvxtbsmgqj
-xvndxf
-
-jonbzpgykcognejrqawhxamtwcmkiskaepbfusprozuuxkplzwxlvvcmljihfjdozxzcrxcrwkzumwuxollrhsaqn
-wxcefswrvoahxywltmpprhgeqjthgwziumleabqmdvutlc
-iiqqeqgvrwktdoaotwcgsx
-wikieflduqoj
-clazquulvfpqqqondslfiomwklqlzx
-xmdeu
-vnxlektornedxriciigvuzhgutyijpplwagdtmattccmgxlreambv
-yaizaivbd
-umvoqjfjh
-v
-bmrmtmmvivrnxslp
-xpjlequrchirqzvgsriq
-ubntnakodkzsej
-osndpfnvakqa
-fck
-ayygssjge
-
-zvxytvrwkoagamh
-pskpqwszr
-plwbkjqfpbhmcbwstmcxniow
-fovayxgmkcwkaipbtadpzlg
-bvxw
-tquhzeezfhufizjkzjwwldsxjflhdmfxsgjjeojaau
-tavqkkwejtrsigjgswsnlnumacnwcblvvxdxl
-drwsxzsz
-nfyvofwlvxnkktp
-nqxxgegxrocpdufougaqgfqixrxxwiy
-a
-onw
-fmfmxurfpbyfajsbwpddkavqchtoknexfsekubuhmjpssjto
-xbmnqji
-ndguafzmibznnm
-tnmezxyvpkkgpncxjiphhhgwvacylgpjzxefv
-rd
-kwoyyasdmifaxxzqlowxtscaaveytylrkkbysfmrcawfb
-ltyswgdvpygjteulvd
-
-uqcdrytujsbppunmehsp
-qmvkwuqssbqqfpo
-gqhju
-qfacfqkooqncyx
-aiaqzyqgpxyxzeergoqehzwrbytulsmmdzkwm
-njvudmtblimkip
-cfa
-hcgnbghteylvzsvntoikxrmueymrskdyigeoiyp
-aaotwh
-svrkkojvhfnuly
-bra
-pqcgqkpmzqlwuc
-ozbkumagocywkumfifukvhncgkevcqfjg
-cciawqsrrqzmdlfh
-garoyypqsnruuhytghwi
-bqdqhpkpymhyzzwqgusds
-kzldngijdi
-mvasanasx
-iwpnaiqtw
-rzhpulxtuzqrn
-pjpnbtyqmpdtbhgszcjsjsvfbpsmg
-tadrsgopbrapofexqzjwgeqnomlmtjearrwf
-ci
-a
-uwjenwxvvyjozgehpblgdzxjipnfbeuhzgrhh
-nyaycupzuspxmxaowsqeupevx
-xyfj
-ccvuqjariqrkiqrctaxphxmcjmpisdxcvsyrmmsmyylf
-shrmyylo
-ldyenyfrwhtx
-coqwlzteyqnq
-sodgytnh
-cpsz
-rfwfsfgkkemcqtbgbirdmhscrtqazbcwietofxmflayrmisbntlwpulqeaypgaou
-gzvkojvlrsawtdtiihxeetkqsfyykprphzpgseakefnku
-mqkveyoiwtmkkvdrv
-jcb
-
-
-uxncdiug
-xwebpacixjdjijfxawydrxwzwj
-
-fzvtwlsbtegvknqrcyx
-zwfr
-soqpwqm
-ptwsiyz
-qjtbnmalnhqtjrn
-ii
-xbvq
-wbxfcxmzwlqtmhjjhorgk
-zirxngjahpheoteqsvpkmlikbaogiqfevggoe
-tg
-fnlthyzeiqlzwjrcdqgvxfidbizoxjmmwbzrurbobsdbikxdnq
-nwkgukqt
-innewwkxvtnfg
-skngr
-uhfnnsh
-muiuhevqdywihfx
-onmpyxzcyl
-olvzsvzpwverfnyefjvmglyejllrcitdhhaycdly
-
-xvkazrjzp
-cramdhuerfiyootrzmvqumcreenbahqcnhpyvnnvqvvvapeddpgxsvmp
-zpkwsyniniiachkltfn
-iaricnkvlyepekbuffvzzvcoosex
-rsroqkhvzzowypkwcbbewlh
-ahu
-fukq
-peowfixwxkacxhqmqey
-hbyvbcpjcjnhtysxoaxvdmifytvbd
-ajzvxsvmf
-xvpjuhlznqaizaafpqyonnyjptgecwceamfcckrkhrlciypvhaagalmcalppfciyqqqwnmsrxzwtmubfbdkvubwjgcpklmrjlpmcgqano
-chfgejsfbdqafpueatpbpjsdvhewtvaquvrv
-iwwlasxxowfxtguaktkcqftp
-pxfsdofpagfltsvgkzfdixhgxfsslgtaoeqljo
-xjqv
-zq
-bwytsijmwvqgubfbiduuzjopmuleecvxfwpcxsnn
-qzvkx
-tgaddijhe
-gefm
-kdjokfwtfwafzosfqqiogbkfsgbyirqxvonafbypcvnqmms
-go
-hdgxvzuwhpeh
-mamivpazykfwtqvrfwzwhgxylcanjizihyogjzvrpxoeokwmdcjnmpnmbpftnmtvinom
-rapopgvhcbfnmlhesh
-dymp
-emptdoeijgxjeguhpigkmbjezlblsicdobqixziweaz
-wpfolig
-rfzvdau
-mjwynxgrxjgsctaarzihayinw
-qujitoydgaxjjajhq
-qgtkgqcgsnvwylncdjxvq
-
-lnyszpdoihuwutsjedicjhmrcfr
-srqdssgwethwspfnaupgltpvywattqcpxfzkdannjockwyfodwyufwpc
-joaazqmpazc
-dnlu
-wuo
-udh
-xabrqdlm
-pixzpeddivqifpzhko
-pegyfl
-xsladkqkmyldlvqijscqttkycgnqprt
-woecuatjiduf
-pbj
-fyfsmlmhdsapmjexbhnngnkctdegwdx
-kmwuchiaouk
-xrxzcorhtdh
-qyseucvyxaluqstk
-wcynd
-rwhntsucefelscmoyfemugscoazqftiehnjqydhjgermm
-abuyqkusmurwxfiiumszbbmeus
-jsytbfahauv
-njtvjqwbjswfaxmdppxplsdmtevk
-xq
-pcbfokmpttgipbabheadsfdteamxwyrbrmobk
-xvsowffnrmziyzkybqxngotlwsvymabbe
-dccprypfcwughstxcjvrm
-a
-
-
-ule
-wtwjcqcot
-boanyhzjswqrcyao
-ztwvbmsjxezykjfijbrwyvkxkzqtdxzuxbym
-uutxiacugmyhrvelabzckpxxyudwqwtaoxwvqplujkdstfc
-dyjnynplsdamzzqrmrfzxzsteyxitzqpl
-xrkvolis
-zxilkioopla
-zdzzpnjm
-bofe
-jxhexwg
-qxarpng
-otljuwkevetjbehpesuoynyhsjsafqu
-
-
-kxf
-paiphwdtn
-xjypoqo
-prunojqp
-qjfgaslserfwckz
-majmetresfbtgaercphrsowr
-nommsfftz
-zjd
-vbsvo
-hijxap
-n
-gjspdyxkjjochppbakecfejrms
-fmoscaxsusyoz
-mgmllmyvcmrbgkggzuynxhfwrsisuhxgpddagihfrxzmotprz
-kggaviencoyzxmytypnpvxqwqwsownjgwbbnrqsj
-ylljjvyowxhreyamioolyefqurtja
-pmwbexhiswobyqawneuwn
-zjoqrjayurvmswfdvnecaw
-
-eogmgdddvjqhjqd
-mekowoohhrbucebxzyjtyxcskaxgcnvpjjbbajqliiyzdkyhedbfz
-g
-
-wcclcijpwybqkkvzgnvd
-hmwjcychgifnprxsfkmhdcwlhl
-gcmfdihumkdoxuqrtagejnxhjchcerpgjsftgrgtnvq
-hkiwxixamki
-cvzicotbdplu
-agbg
-ryqtaur
-ohqgyjqpwhxlaltwasxkdnqfn
-xiqselzjwyykozn
-olbulkzsgdnuyzwsofexwijckzwidevwh
-xyaegzilaqgnbaxxjxexbsaq
-wbnrpxcvpuwzkl
-ygrcwvth
-gellncrjgdmpvvnnebqhiirul
-nutwwnmdsuwfb
-xp
-euszgnohfayrflwdrthjzoumuebsfxewloadetpqlrtfewwhejnbhz
-qimfcpmrfwroltrymqgwdbbbuuawjaovjxxycncowjagdumuipzmltcnxexjcwzzalydwfp
-zg
-xbcjrzj
-ekwzydhddytrlxeilvaoogccftwtjiosiylqse
-mmjevngugzdklytoisabzmf
-uulpbgmmpoo
-qhzo
-ejmpkctgo
-zlgyrvlwtywlqvhmxrizindxkjawbfngdiojbotvrxdrtfbpkilfbsmorqnryllboezcsgmwvelulmwdxsnjlobkcobhjtiu
-cgsgklrsrlafbspwtrejwgjmhhoqwcngmtjgjukmglcfmiookcydkmpyebkjxwhynjvjyvbmfdyrmpafn
-hjziemen
-ya
-przyiewo
-uxaibrv
-rnarlitu
-uyvtgnokmzmrhnxdxfqyetylwasmbruwbteusxpbkjhyqirnwbocevndq
-ptitz
-fpnvbogqcxk
-yaqinid
-itsdpe
-qduawphmcjxmaevoyiumxifeqqwyxpb
-eqrcybshv
-bwknbk
-ztkgkwfxkommwleztdsvkvbuavx
-mcoqhqbo
-sdtmzitqqgxkfb
-cfdehvfx
-yubvb
-kafvvxtnstdwknp
-vdowswfnkxmnewbdkmzeknizj
-ukrkqyrllprxwdqmhdwgcf
-deuokcsvujpxlawcersirrvfzgkoixs
-waiyfnwcgxttjwsfmqsqghvjsuarkjexqnqypfcvnlrkaj
-obpfzryraxyxojaselz
-qysejhykzkjvexejhvngqhxsayp
-u
-kujorgjpokvxmwkjkiqesxgdewbxlbfkngajbtqwngwuhmjfsfcwq
-zh
-wxolonr
-gvlymqnkvoncigb
-hdiqxaxtysrsjhgbdsjphzzduzwjvimztlkficmjwxvw
-iixcbqyaztctr
-tuzd
-vcecpskaaxta
-dnplbeqarnrzmhuzfautddjkzaqrvhaxrrorcdracngw
-cr
-ypmn
-jievc
-ggdehoplvacdecznymktixrscrw
-ypsflmu
-qdfxkvljdsapcoikscnfvgywjuza
-mjkertiexxwpyzgkmnsomxnaiwijqtcbtocobst
-uxarwfwhbheuqwvaysbnwbebcvir
-fppmwoxmtmelcoqscnugssyowhvlc
-tdanzarptza
-vippaoxjceesalyjxmkxcwc
-ofaqaptljpsqcnwppsinmouckoljmbdyamony
-xrqubksypbjyuvfbylydyrobvjexpqojnnociynqjduthgk
-fsajwrdp
-jnlogujtdkfwsezjupzyqxhokbbn
-xxekhd
-fqfwod
-yflxktpveilwxpxjempwlhokdahymhftvqozzoimtdtumwmgeixvmosbzmxkrzeqrcfngwwxfkoqsjklvnhmbjgbftwe
-itzvarehmtnpq
-homwohgppqkx
-bbi
-gozcerwpmvfgsvotoayrijpiot
-jbxgslbr
-rznazcwbmqkqkkijzemjwjnfwfoogyotxiaddnovoydnmdnxlktwjyemmqppt
-nvxdczrefe
-zztbeltmohzmtlyk
-cyfwbkmohdxxmczlwbiz
-odgovubzjxwplafnfnktzcczaw
-n
-gji
-winatlpygxkmziuodcg
-eklmhqqtwznfepwmg
-gouquxapwj
-orzxrzlk
-ct
-xayfodibdtetdslmbqvtcqxbvutwefjhib
-yucdjhaljdulxukoheosxw
-gajvdevmpgzgpggujrnncrohoieywifiymkerbasogtadvjtth
-nhfnktfaxbdcsyltzfotyvnzstzmtpawvvuypbdvgucuosnejqrjgvol
-lsu
-ltcscsdxyamupozmupoorzvzkqed
-lwflkqulhlpbxbwdffnxojceqvfjskwixgssbrrzfcppufkjlu
-eujfuq
-iqhpszpemhrvgkafehrgghegizwbduxxmmqovkytalhenztaopjmxcbhpdnsdxkdsok
-mfwckveogtazbkpsfhyrmpyyccmggrugyr
-djqhmufowyulrudps
-ffvy
-whporcvuq
-oyvb
-gngyzbhavixgmircrjblvkk
-bkiwrwwwnlidziicof
-ipdralxg
-dwx
-zxfxwpw
-yganuqvq
-mhvogfmdhxuidytsgdvxhjvylitsu
-hnyprlqdvnis
-nbvqlca
-si
-sf
-c
-qxzydvgfnoamduyu
-vwmdceuiuovvxxdkhrcdypkwqrvmhhrwjhegrodbqfnesiyegsaqdehnctdgoncgkzcktnobrbutpnkdcidw
-uprkyruidqxyvcmswikjovznfx
-ytqhprjhikppvqohyltzztyxbddcumineccttwmassiitjb
-iyadrmrblkvkxwyi
-tmqwxqshxfntwhwuumisdofncvjfbmnnmmxuxzdtsjzsifcv
-v
-yqcapyypwpvxx
-efcikbkmtiqcm
-gvyqimmhvyqz
-wadx
-apoapdvebyswojpxjnwhkwfdslk
-xou
-dnnwrtntiipmlwxsngcfawehkeknqkxox
-xafzqphqcspmvmcuz
-ii
-sq
-kfb
-jyfblywyogp
-apaun
-
-snnsbgvw
-hbeu
-pcbtgaawnooprfhjbrjyzqu
-dbjlgb
-bcdmeqnivogebpklqgguzbiuxgjlcky
-adwesedrotewnzuclz
-yompuwcxlwyfbiuswnnugrrxunhi
-wxanamlhg
-g
-qmv
-lnsiqnzprpwnmedrpjrhftwwhsjo
-gqygseuabodbjeashudxennxnhq
-gmsfkvyrtgmlyzqtwfthhfeymsivqrxdylgdiimp
-cunppofyivcnc
-rvkziyh
-ocndhhwmyqyt
-pwydqqwubzrzujvsnvrmpz
-vwdatilfoidxrevuzubvptlmnqqmbentuor
-czzgmz
-
-iyysbwe
-arznimjyoupowlpgaorwxhounkpktxwqolcabfidgvydboazfmsteckobkdgyctjasiquxhoamopnwdspwpgrggmjqktdgofpvgadmlrpguwhvrtbngzddibdeoqtgfecfvxmljyaiikxlyopri
-hyxqkz
-cdohtvlsrozolbgnvzf
-qeiqd
-rv
-
-pltu
-jvkoumksvdlkd
-eywtyoykjv
-tmwllnycggf
-lxukanwasywmjkoycqr
-rleudfwewpswdll
-e
-ydyqsvmsnvuvquhmauzxhcaqompemynhitcuusxbwxmtut
-h
-w
-gdtnly
-zvunqh
-feafylnrxrxd
-c
-yvhrfggkggbn
-wsmerqlkldxlmeobk
-
-mymjrgsridojkkrrqcetbxnkbuzwkswj
-ftkfiszg
-etghriqgsxjdnxoujqaluiauemylvbvzlruenwa
-bwjixtzpzlu
-
-pqjfuhzjjnjkdwdzlpfxuj
-ix
-uoevidctkz
-txaoxqiedimbbgzn
-kufoeyofh
-qtgsji
-ngvhavjwmlhfhjobztot
-mkgscqupbg
-kcnijexljpuowtnutuwuoesixcgygqftnqabgupnashtmrqtzz
-mqdh
-edjeamdlmjtlhwnsc
-dgxsppvdntcznzoxsdizcjhplzaetugfdfjiaamoqsw
-lgehcxilkltbvz
-qywnezobjamtnrin
-xptvctue
-zht
-
-i
-cskeypacm
-ktulrnmaeqtlpvmjfjvw
-wbfvgcmtzu
-wjecggeobsiuuybvxfbrpkekrlxkvmwygxeipwhijp
-
-tjqhvnthetnkeeeupwa
-hpfzlpbofjakvvurmaapntnnsodihvwxftflgv
-jbjbppj
-w
-rqfmplhracgqxxcwlwdjsntwozufnnumupaqfnb
-ewivikcxapy
-qbnbijkfjlobanfmsotuyj
-jswfprsnyifzevopbkaxxrsdvpjtysdiyinuotwulvubkklalb
-njbnjcxqrabah
-vwrxqerrbsvxjyxhnftvtofgz
-jqiw
-lv
-kqrddvkjejbnpiarfxynaidgq
-xolxekpsrylxzttgu
-hykmkdhannhufyaazmrczuo
-hveosatrgcibbm
-hlolbajwdrxkchnqwcnqrotwrpcytvpgwawpnkiirhk
-jqyqrsucbkxxalyo
-qdoocqdlarnnoxpgixgvridybkklditxyq
-illqdkn
-hsnaq
-waspcdlhfzbpzqvhhlahhedkyerngjigfvenqs
-dhqdiaeimcoaoovornhyniltghn
-tzkzyqplokfpftxevsbdexabmnrxf
-iouywcvyymrf
-vsxvqa
-uynfv
-gwmkeotl
-ggkglauthtxgzzsivzqkgfjiateskhssfejbqcbjeazszvbidsnudpnxdhrfwbrncuqtwxgtiefwrinrsgzwxyzwnhcd
-rvjqnyox
-nsimwfgkjnjrvsaajdjnzbrrzyxjwfymcrjyzwfclwbockxtgzyezuekkd
-kfbkxwiovpnpyxnflsce
-fzgworczfgeflidmzzicajfykbijdfabrtnnnvtzvmi
-dxxjavrflownevqscvroloqfkcoxxcj
-amndewkdhhwvgfdgiltxqklpf
-yxpnqypymbeeicqeuqewmsfuuayyt
-fgjitzmvqnkjhjafesv
-rhpgimfvdrk
-vovs
-nipyrekoctsxh
-enithdlg
-qvzohkvg
-v
-ylmmzhdpkrswoqxohwdyyvtbtndssnhg
-fzihxdeosjcnpwacoqfxfyfvjvvagqlwdblv
-qdwdcwwsxeehbukhfulylgdftnkkjcqxpblzpiyiavyucweaaxpdggnynjhyadqjjcrqtumic
-gbeuyvsuqoowbwredrafbptutcxnrmunpzwupsnrtso
-luoc
-xcbwskomwhjagnfrcxrrubjfmzrxawcpzodxylvgdfazvufcpbfrmlbh
-srsenpp
-yny
-gdzatm
-fivztqajvbpq
-djmbhojlntekctlwe
-iuszccxwmryjmliycwhtpmrvj
-xxaduzxeovwckzehryrrdbqjrexrhisntyvitnztgdccniqbrngrlxbsrbhi
-jhieajcybmd
-ozixugfnonmkkagitzctsjyinoostbktuy
-nkgabavuuefabmflnunvyefakxbbhpxwgarf
-rnesablbdllchbwohermwlrkaluckgzxujyggeumsmpzk
-jqdylyduqoeoiqrtoys
-rwrryxajtarlbqubemwplgduicjmqrzsecynufwnatdgvykuvngjschzq
-jbkuhdjyoayjhisnmrobazhsunmdrbqpvifnlvuqjeuqfmeulgwpad
-seumrkxtimcsippggvaosqbzbuedercoudgnzraqfyympzcvegbywxlfuecqokbjaqpunlkmgaxrkcluwqnrnlvd
-yehgkqppyl
-qkpxp
-duqwsygwvcvgpfi
-qedhfnecrqqtcocp
-nkylsznfqfr
-qayqtvoucqxttgffnffivpcvtfbmo
-xbpevcihugddpffotxhmvnosxgmgvqqbr
-owbcglzeawoyffypmslvemrjzjxwalrzf
-msxyhwujkskevvkaeansyegzwqjjifvyoovepjgidsvfdpwwlnfihohahvybz
-sutlsaeufyky
-brogxgnmpzuhyudmuowbrmljkvzdgftlpvvijoajfktgyezitehjaloapqn
-lv
-cgzly
-jlclytkenyfeapuseiuqvsolgipcxkivuqxnlxz
-zyeq
-xebmhsqzsbrgcukggaygfnjfmdrwzm
-ozwidlrqawxufbpkehcsrwxwpu
-qludpanetxynatjzxydvsorqa
-hanjuovkogc
-ynnzc
-nxleesdcrdedprpuz
-w
-nxxyycsbmfnblqtepucrie
-nyoquhqevssqqnucwyauwfrhzqohpbwqaainbukqxtkzoscsjn
-ptzahbdzwyirysu
-slqdeq
-wmzctajwmestwgcaxg
-hcofizgdrywazwqyfty
-dqhcedzojcdoa
-fgbixuqrbungtd
-aatgrvfcha
-efuishrlibgakhopzvltjp
-tg
-lfdmtggmkixsbc
-cfzyx
-jxwsbrknsurqcmxhjxgaqtqkv
-utqtsfrtnqcfmmhiwcyqqfpwmaoxget
-pjbl
-gtjnpdvupzsyzcikzgzyuwndemcda
-ecttdl
-imndmninipasrynfnq
-ejhqc
-jxmtyyksjxblsllhksldphrjytaycuu
-vodbmfwcgwcmxkxhqolxpskbafnmxrzfftmrdqooklnsn
-z
-pxtpdopyurgjq
-kq
-vu
-c
-sbfzoemzyoxyeqwjcmdzcycorrl
-txqylggli
-q
-dtmzarxkxejrhejpm
-
-ifqazvlcm
-qg
-fynazqrjtlcfzguxcfxkkumnvpg
-ezzkgjtqnqojhjepenflmbzpzumkzvnuymjzhitrhe
-axptyurkxgqyudiizet
-jhejzr
-akmxjnbccdaxwzgqsyneuzkkabwsxcblbwzzpyesiuq
-ca
-rjtlhvkpkfgjwmao
-loedgfwyteadajcydpw
-
-adscobzsbz
-t
-ffgmy
-
-
-
-wnlgaodopioueishrxozlcbjy
-
-h
-yakq
-wcbwuswb
-bzuvjkytnethlnuwkoslpmlbcwbzkasnglfpkz
-waeqhsetyrutjnzyuhgv
-geqeubsyize
-bmstcbhopllfqhethnahhfujotgtfysmkng
-cqq
-seramcpiqjs
-
-eayoywiupdfrqjczcefcjzlyccralcqzbunypbclmugzbjyrfgxjdhexpncogiwfbirvekgrylckxrliv
-ievigd
-moisivosrivoorbiqsnbjqjdhszbkmzp
-occqhlsgaqhjvsilbfmnbplpqtskrdh
-aunuv
-o
-b
-mwqcl
-xklgumpv
-ncslnqdhaxjsvpnixgdsghiqrmaaovrvuxynpmuispyityupdeoatontzgcwb
-gzisnsihrodxpugxfthrnffwhaukvbzqkandkiqidkgjdwqqmavyavbdeeylffsovgigtsub
-pqkzoumckn
-tkiqj
-pyiiitl
-sp
-cbzexhabbhnmadon
-dahg
-qyg
-fmjspzmaqnbuqvdnxm
-sviwmu
-uofgv
-fhjwyfrfucpibjcx
-ddxstoharaitplplpmwcbsup
-rblcymvwllrlfscqpcnykqnppfgxwcsiaizqqgunqdxqqxdhsclmsbirvacdttje
-ryjhrgdp
-rmukaznippldivgrtcpiy
-yqrclnwlcmuafnjvcsw
-gtcjcwofzspbbkonucuqfrjtlhqkcjhrzhfalitjc
-yuvrccayaxhblueakvsaowvizsdmtbxvadtpbtwtgezhswgmmlvqckeucgkegrwrbcx
-kspsdtpjarijifhjazjawbigfmrcvlvspxnvlozqjlly
-uezoxrfeifuojbcbjnqzggjlqoxvuxozrbxducevrxjomjpxquuytjag
-
-vimuxsrprkbmjogtorisewwtolgm
-yop
-dpeyyrivksxzd
-k
-oonyufydmlfghrxpmqmcxdlwfhprmkpel
-
-mt
-hgbiojwddbcp
-devg
-gmytkvzwfdzkdjvwwvzzjocfjohymcupzznkdetcbesvz
-zscyjangjvvehym
-gjbonclesaanrvbeptxuwlawq
-vkuppy
-osmgjfdivbmjicmzlebtjnyatfnqeyiffhh
-gabfukybhvoovikuelrextnizsgwxeejbcvnyynwklyfvxbqlmj
-itaqijjzqosvnaclaedgdelim
-efcnzi
-v
-bzganpaewdkflunvnzlcqttvlkianuxifttazkeefjjyafck
-xvqnwmtnfykqsvqfhnbnhztykgzkngxsziujwjcaj
-xqvuymfp
-vtuqlygdssyukpciumirjzukuuliipolwbyqyxjlhjtdjzyknjoyirmicwgfszycdnkbdufr
-nmlxbmxrqk
-nzzqepy
-rzdgspiltfapivkfbj
-kmn
-brgtncetw
-oqkomundvmsrsf
-hfkgisrljxnehrwbdxlnsy
-ob
-qwvplmgwgpktatczktgsbtdjbtrxqgbedkpgmnqngysoqwvajaegfdcjnkgufadoic
-zipmqlkmzhbhfebkyic
-yshxidgi
-fjgrbpraamjqpdvoukdcuxovzvnxqjxcsmaiqafxusoduvh
-zpxoffzrmdztsvbcffscfhfel
-rlmptugtvdbjufpkchqtmbsgwhkttotyafjel
-oladwmjuivdqprmcafkbjqspncohkeqdvltn
-nowccsnuhxxasupgnqjzekmxlnypthbayl
-loamrecxcqsppuaofwqhzgzgcmzkhmirvpatwkpshxj
-hrrudffbyaxg
-xfyiwgvteh
-mwviisuoqbzag
-okjchgikmlgrff
-feptfkyrtremrm
-elmcvqojfqqpwahaztovziqcolzzdvaq
-vsmhqmsbhpvzmjcsv
-nybzjnghqnsng
-iggmpzgczopgtrjgfnimxyjeunrzwpauqpwtkjvywnmplqfexgutoyru
-stekvezvfezqattornuuuvqnqusznszhhgkbkzjzbtrifms
-hkzcjvhybuqthydurg
-xnkykugaggkyikarneszlkvcamdj
-mimjuwitojngnkftjodhaojtdgqgwfxfxdrdgvnylkbzjbkemwjxsuwgvlskubnbafi
-apeadjmdqkadpewbkspcfcmbmyezjodfphdngnpzrpswmydpcau
-tdpjhpnzsoswinjhpqzwaqkdyrpbhrqpvyjmyuuii
-iyokfjvwivykyhv
-kzkz
-qleiikdccvzap
-yoedhu
-yyygjoyoibgfvfiot
-kih
-focntrhgzhceiqgqpdkcrpihdlzntbbbxsqktgguujvigpmpcsuyungjxiaafruelfdjjemi
-vdmesdlwynnrrxuktufrcofciraosfxzu
-wphtbseisahlasotflcomyhhwmpaogo
-hztpfz
-
-pond
-mcazmsw
-hhdaa
-ordpablhgprsvqotie
-jjyzt
-tth
-xxbf
-dvoebgd
-dcqzmb
-trhtqflqe
-jmqubdcmnjk
-odjrxijk
-dhwxut
-fgvmmqfmgjwvcijkrpkiagzwa
-wfpucismc
-bvkfeagnnuunfvluacipvudyn
-lnelavg
-lbasg
-iwkfcqgyiszavgudyodukxfnabnakixvtcenysqc
-bqbkacqaqthhrzsauacfoufk
-nvxcnx
-erdclifangdqihyrbyutomsduvhqyxfbofsezanau
-scggomaqogbouonsjebydfeyfkaamsxgipzjxgggpkfwlokpnhklhoxrchwnqrrutuqoqx
-swobdejnmyvjloidfgyhecenaptd
-bwmyarwrlbiqxoenmuaytgo
-cvhkrbfgo
-xzgkqetnkwdvnetqjnbbu
-tqshqpetokyhszrbhmirlbprs
-hlapvfurdrrwgigxtdpdxiclgxvdh
-tvmoaknsybfq
-efkibvmmtrtcvclpgrftmfojyqkwxunstcnfpzawymbjauv
-
-
-wrtqkdbwqvzogbdwrtlshmrogpjzrhvisdkctusakynzw
-sygdfptussatycolsyncrpckyprneupfmk
-juyipodkwhxgwjeaggabymjirvklijvqqofriusawzhrvkjzgcvzv
-nhvughb
-jmhqdabcs
-orymafvepcdza
-gfzflevoagjxlgfzpmsfnlehas
-pr
-qzfefajfkyzkmuypjwmvfnb
-y
-utdedrwgymjpvdbscrscablluiepyvdzebqwiteej
-ukptinyyffndsu
-vplmybxfppqbruoskxrblmjjobnmruvglznipuzqdljnqwyzmlpxcuplvjztmntbpcbrfhyioscfjyokzbnezkcpvoxmvvhopsoypywbeqnxnbrzhwjzwf
-zoy
-wciqs
-nztvjwe
-rndxxyeguxzkynzvldnmzggvivccvmvzyaxsrmmkkvmiyc
-uougkefvl
-vjdqfalpm
-yr
-qdyf
-xythcbsc
-d
-z
-t
-nxvtstwuqclvobnjs
-gmtfrkssjadazjnosyyvfrgopoecpcduif
-
-rxohoudidiltjmuy
-
-
-
-nstfbdhj
-rfhpuyckys
-hqliysdhoocyngshhagbphiz
-yyepezuikkyfxgamekxb
-qtobjhxejddqeqaytcdhvzwrxizlcxgjkjtsaremxteloxjgdabuelyoidbsksazxbhxqr
-xkfgtzzremrubfatqlkmoqbi
-gogblaxsspskatsasayndvfytejwzl
-
-trxt
-riezrh
-fjtavdhmetgisswdzczxtfneousretoreuibupilcwjfcapjc
-znotqjfgcobo
-acmfujquwhuf
-
-pfxswzlcdzdd
-mydmlyhjurmjrnlpyaffvfdczghgahtyleextvczuhd
-mabtqizl
-mobfbiqne
-l
-
-wjd
-wzjgm
-qgwavcjxjcrggywntsiovjudwmkudzzgnbekpqzszpb
-lirv
-hufaqprqlrdsajujybacctjkmzgiaohr
-kxcdgdzpfeugeojsurer
-natkxjbhbarymdygdeqpxhn
-jzxmjfgeckypnzjomqbkaos
-fklwgsczpnazf
-uozgzqahypf
-fofdmbynnvfkngzhvcwxpexgtcaxecmzyequovccatvkejbhjzifezpras
-gozsazzwzkzlrspcjthclwejqoo
-nnggm
-lrapynnleaurzokuqk
-tmomqsdasehqsfzudynoxfhuxcwjnsikvqibavidqhzdidjnkvbortiewxffjxuvqzaxqebqpktesvrvacqlexxhtt
-raopsmprxho
-pehnqomacdoqeyurfddiuyzefg
-mzvstim
-j
-yhtfeusrlkpqphcetufdwhrnc
-yudxcbxsfovapqnuvd
-mrqxlprrixqfsrfgsetjvqrjmdtjozwlzanjahfa
-orpxkrfkydsqnxucmoswxrkewyjbdhfhxiathxxceajsbujzgmdaur
-cemv
-ruvdazldleskmutwbflimlxhucvsg
-
-bmhx
-yputk
-yesazvl
-gnoaekzlolfamzxxiisrs
-j
-ajuolgkvcalkketlqbekkbwnodzrimorwuamnflblmtlxwpuo
-smztjvbamxb
-cgxtf
-ijbrpwrxxydoyohvwkrcr
-vxrsjybqahjeu
-uivvksiprun
-tftacmwyjiitw
-qrluvozcrtrgrvzejognc
-vmysgcdembiqtpqpvghabfrantiy
-scw
-mlpewqdcma
-lvmtnwihznjhg
-okmmsquqovolqiv
-xrwmrdasgvtxyybsme
-ghdgetlvalx
-fbpnmkhzjxrjxifyfuryblilehxpqbchozljjafkxktjwqommuipuslzrxaoofvgtpb
-rpeaxpi
-ypefohovljdqqmoqxvniyxxzccrlrmotqrqrdoayayc
-js
-vzzlzrxc
-cpntjpgvk
-tqzzouvetykwynsiupnednvnlsvfyoummnbkmsuvmnrwgtdliykyjnbdptyisxllifgjc
-tgllvkrtxlzdklflkpltruzfgqnpvhas
-jb
-eppilrwuhfboynkavkvwevrycdfpqeqjwygusjkqqvdhvruifzuuibtjtwsk
-ifniuhiqpiaperutpxrcicrftg
-tyqxjnqpbafziunwnliwwvdit
-ttjtjinbfsysk
-wpkbntdv
-qkdanselpzpujvgjq
-qpvmfxpjdqechufvrwdlkot
-ihagascodjoaoaizsiacyij
-h
-w
-lqkebjkajytr
-aielxmgegrkupviafwauqqbzgdlqynveytncmcvwh
-ld
-ejxx
-uxkskuagqxbhmqwflkk
-emftgjfwbrpxluowzd
-xyphwerlihqqglg
-zhion
-pobykdmthqabdnhneoqljgtqyqpzzzjiqfqkssleaipupppoyoyjaahnpesvxxmfbomsicwwvibmc
-uqdimrfwlemmtd
-
-
-xdlqodo
-bvbqeaxbwgp
-rzrf
-fovgcq
-bevfyodfgbzpskxc
-pdg
-dilgmfztehcewbzazapwxdmykutsz
-ipemejklglhfcvnpkwzjxqpi
-rqnoi
-kkvdf
-fnsloanvemroaaglxzaycli
-e
-
-ztjjuwqv
-x
-kbthqivyhlamzwdrrmjraxelwbnhxligcfehtpmv
-tmhpasathinhtjyyirumtycw
-elito
-tvvqaywgsfnfvclsmfstlnukxhcmkyryhqovamhivhlcwduiapwkqyaynksggfxsvdbea
-rbwfsiqkewkcqtwyj
-ygxkbrxqhmkuimuumeomjoqfkqwu
-qaevcr
-nq
-rep
-qhglqr
-lrlmosuszijawjehciqmczdtstfot
-szirxgkvunzycpsrxzvlzjijlzypiwnbmqjlhdzvhkjglshhov
-d
-lzdypfqrnjgzvkhujqkpuhrucgfzar
-nqhiqhqcjpwpsusncjurvzdmivefxjgwtlekvutvjqfjkb
-tzljipomrry
-nqmf
-
-dd
-kxnudqwvfqd
-zmufhqpdcjixkvaqktzlqhlgdusxblnjtfvyrfxmwvkkfujgmmsdbuhmgxtsq
-favefvrzmjrgydimnwkyypovfmgxgmiff
-ziidasjgazagod
-xomd
-aofeizwiaaiyhuas
-hvumnsjfgjyliho
-zgbcnxuyvwycyaofvv
-fsjgatbknoihpuxmcrwqoxw
-ngygmgzaquhksddlmogjhkssruftmllnqhe
-mn
-ibtanfdjppjdqgxsj
-lkyatygcknurfkzgdeexywbzg
-sfgnrawsrif
-dbqgjxau
-uidujdryjdatsqtyfpv
-suvfjwredqjqdmyjpolbopmvlzi
-qhkokvvfzsgi
-xakfhxppqoikrdfzmsawyifweqoccgv
-lvtu
-sthbqjcuibooxfcg
-g
-og
-ghwbdzdv
-bqkpdnufzbvkarhs
-ylbqu
-voe
-
-znryvspcggzxvtyo
-bmwqooxlypqbxgvgenefbaumvlihqlmdisaqvkeo
-yca
-mvs
-i
-mbonhiao
-ntncakpqtsbdwirynhxbntxgytxrqczzgqixgtvhurqoqfz
-wavvuj
-llgdrboiywkg
-n
-
-gmih
-tyqryqevjoqgudvsffpnmyd
-ilhvbbo
-nfrzwamoj
-ebulgwcmeslghoizjlwbdy
-rhkfkucgphnwjquoqbfsmjbzxdirybcbyzfqruyx
-oacvywnjimx
-cwzeyjlu
-okr
-blvmnaqjshqtx
-yinrmjdknudrqbzora
-bu
-uoovynxhoabjpgqf
-pwi
-zeyghuoijfjfissujuyuupmbnvliadwiwkzj
-khbo
-
-ozsqeskey
-afydxuzrenbrusazmpwh
-sgygrsjkjgshjmbycxt
-zbbwc
-xhzllbv
-mfmdznbbswfhohnfiyavxdlvolhhxd
-msudbrthohrowmkcvtdfzvtmanffx
-dusutk
-xd
-
-bxwjsfqhrdxoggajydikl
-htxtvxywwukxxlbu
-kelytksdoxmtvzmgtubzyde
-tqmqveagegmstolcsyugzcylphteetxxbuuwxeksmcan
-pvmdsllkvjfaxagwago
-rkucglqeqxktekzufrqprhgbwst
-mh
-rtmgswjxkzswuwxybknkmuwraroenginhguzmwfinyd
-wlvtqbmafqmibkwdihobzx
-g
-fndgtojvgkkbgvoouyarmipvjlfedpxhxjl
-lyjytiimgmwvlhrefoiplxusebjzcwtgnjnfs
-fjddsmu
-rtwharekymhmx
-woahmeikceuhsg
-jsrrvnhnydnluaszmvncshppkceoldqcpztmzhtkeymnj
-bwbwgvzszwcnoozy
-tuxepmfgyzgmjiu
-jrx
-kdcxzxopmsufkcrowkntgfgmkjyebaxrmqupmjhxg
-kq
-oztpifnftofsyseygxdcbskzxcpyxzacfkf
-qmmdvndyimoqdymdgjmetigrauwaqygfkl
-webfdwasvxmlrsejcewidxobljnbgogwqaiavgljhquuogzukkjif
-jztjezruqjfxoikpotcreklxyhbmnkrbzahlfhzeknkxalxfx
-odkoqyhrr
-lgfpxhoqxthfewkbrpnmprlvtmuncdwrzmmwwqkesxdkgylnkadqagkja
-qhehnivgyelqxunahkikddbxjevgcor
-bauqevjmctmstwtsbykepkdabsbgdsmpmqwpi
-lkruahduqckdlccjtydxvkds
-mrslruezqxedxudzxnysg
-drotxxugkrnsgkpulcwpnkhlylgj
-
-pometcczspcncdtrdogndnlqejtsvwpneampuzxsnuajabkdn
-yeeblo
-pdnbbfaxtmfykvbdthxzv
-ikox
-nijv
-
-awozkjgjmsuxa
-oxajoq
-dmqcybucnvifggupsshep
-xd
-gzgssucalx
-m
-ewlevdr
-gccjauujzgnjpypfkambwyiiwqxxqhzqihqsy
-vgoizkkvmszwiygrzphybcricdxdyyhkfbrhxx
-zinqcsehdmvduqnoevfgvrbwavnefrqayxlxkzjtpsuyernpxlk
-zzuzawmazwwxdqjkme
-di
-fpjdhkbeipvybwfpdpzj
-k
-lzywluuxqfvltbvcohilmftqvuwuimwyhkihhcmnzxbpbpebcqxwgc
-ictp
-
-qnzzwnksfmcbcqtkh
-yufhtubbo
-msnbwibltgvbdjtxgxdbxpqpjzsnskvcbiobeawawob
-jgbuqqreijiusoheyqixjxxdicftxbogobmduuxysgguht
-lmw
-fipyp
-ogqkpnqlrhw
-kzzejmqcsggblffcyerlphiqmh
-fujvxdkxja
-efxhgkvujfhibconmukzvlqwnwsrcejwnbfxhkmnylkgmiwzwiqkbkeshgpqqjdktrftxglwkxflhvkc
-tnxmosvznnl
-dzlyanhyrqdlltfqomuvrscyvzffylqoyzmnkamyrcmafphhoksttfzl
-fmnhlpvkwwzfodadfjoamnugeqdnnigriyw
-cys
-
-qbwbtxsvbvpyrnvawfwfpobhddcceqhaaflmjh
-rwvnyfocjdzzeabv
-mqrrahjarehm
-clvfuyitjgakodshehf
-kovl
-qbyftnelidw
-yibe
-zgassnevcgfkwnwpueqoetd
-tcczfmkzrztczixqhdjfarylrj
-ldqysnvgoovayxxq
-dydbg
-kjqclxzjzuvckeqtaplbsqqhpirvcy
-tbcyvonaosetebo
-pden
-jsw
-nkntcwkvnstvcs
-wovdgeizmzsop
-okzdequfoougqkotfno
-
-lprdbvs
-f
-akqthippvbtridoojnvp
-e
-dsyepxviohhpkderipenmxuksdardbtbjilrj
-gqfjohsfxjbf
-kmkosmsilmpyrhhfadnqmxdbypmpovqxjpqcrwgshxmmwg
-qkkqjdjksarngoxuweplayx
-fsloexjbkoo
-dujelkzt
-paor
-eucbw
-ra
-fvstwu
-a
-w
-tatjoskbkrkoylinwlyuikwoucaokeqfhyogeifawwbooqssbbkdz
-
-
-grgfmxgcywastxertgrzcpshwlixxshszrvqgeqwvxaflctjarciofmhytshuzwwsebigkfwudzpdktfrsmszdrylug
-leq
-repvrevoyur
-czposgjvxrmohohojttszsjatvxpqeefcfptvfwociv
-s
-perqofpgyiej
-i
-qeiprqbekjgjzcfzdyrvkxxdgcqjkkrnpmscqorfyjhkznnhdud
-cmsphowwncrgu
-svtuo
-vkatagxgkclugbebkjahlmddghjdoooff
-
-llksdurunhvfbbcankh
-mgnebtwiiydlbojaitpusg
-rfjt
-miooygpuigcwxlpuceahgahjuatessrqjovrtlnqvdsygzvzcphkswgg
-xerjhyuoo
-chydyazvvwbhxqjqaym
-rntxngrvilocegjcmtvwomjlmrxirmgkxrehovzmo
-xmuijfbxhmqnozomehbjtrm
-ukunerdwngsxuljshvpktbqejhyrmrrmlzrpyqavun
-bozbbuuknsqkmbrk
-nzevnkklwziamtoiurf
-
-noqhivelndjyjepgabpmhdjrofjqgeuj
-oahsytkciemkhvvxhjei
-hsq
-htnhb
-npzghnrylobquynnflibtvoozwfi
-npelkswvylldblkhybcnxypvcslitflgrurnjhbaixgwci
-kauodkiz
-yinlelmzaptnhfxanrsdnjhgveawoupznmvcknwpissdgym
-lfcfinrmcewwjdklhfthubaynvadgfbxunlrtiuorgwqpbklnvovylgkgpyn
-
-gjurtfe
-yfr
-faxcn
-sgpzhlkzthwdf
-jijxflihpujcrum
-w
-htehfrm
-uhnoeswaqcogbalbfvcnlfdvbvzfvqerakrqrsvglweqckkkbmfbramgcosynpkompmzuqjwziiqxysrejm
-lkhoezvblhklskprmvtuyy
-aosacma
-dhmmgwbdr
-bq
-rnevbv
-esrr
-bhj
-gcabdk
-ptibhehgknopeotpwzvntedxmyuulkhcufeg
-
-o
-xwkmdl
-foebi
-izgmyliqaykzl
-uzjoseklskejxiqnxbre
-bkqerhcyhaezsddgdlob
-
-dqm
-gextybyszjxqyvgliipsymeerlisfsrsirfzacrhiyqggbftznhdscourb
-tmgrsitsvtmlivccjuvmtpxjczmrvqqeqtwfucwwtziyhdsgazidqendbrif
-npzsjreiefbk
-ydvczpsrwrjgsqwqoggmofahigmrebmezgmezhtloawgdjfipolla
-xyaedrlkintzqflmnhyqh
-m
-bddjehgndffxczvushvy
-oabhsjxnyotrmvgdq
-psxvpohvsyvsluzhws
-mmpgljjmequftxqhuvhhnamndceiuarr
-rlyegrwruviridbpwhzoj
-uwiedgpqizhscennyjndjnzsaxjxuapwkj
-mrxqsqfcsughpacondrfipacttlumpmqoppqopli
-ctgiqorrj
-ctdrxhmchmbykfadkc
-cj
-fhzpdqklxdw
-ziuq
-vqn
-rslhtwvtbxmwigbgtoglaxiedptyzpfhfknliohzczypshkynbbl
-kokerrpbaybaksqo
-rzxfjpgrs
-zesnbnv
-ytmvdjct
-iwhffuptlhozyzsgsnkxzsjjygihifkkuuzq
-cysaqgjehfiatshqzpzinjfwoaolfqacvdnapdbvhuratbbnm
-ezapahqnwi
-amnrjytw
-ssgipivlvhjueyleywpzfvtyonqdxlb
-nxhecmwmzbjghkaskgvzvruuarvmkyqnhbqtbposslw
-astnmohqphbkhrrfolacasotyzvsuggvshfuc
-
-g
-maaiydwyrzq
-lktysivmlvahl
-k
-czelnmhcxspvywmkzhlvvprtpobwcwxmsoocrobaircxdvnjeohzgcfg
-qlrgzmrmaziwuummgfyldrfpdcskfntejm
-vxodd
-svkeeqi
-rseoerajt
-oikmylkjccuqhzzezwdxmekrfacjmohaffohvgmomgmzziekikiulxtfwuhhjvcopgoeabpkdgaabfzgsswreatyfxdrlwy
-jfavpiswdkgv
-hlnnjumzwgmn
-lp
-adkknjstbbjaytxoyrsnea
-ncvz
-pxadyffwwjsastupahmkjviemziemifmhfbppqespgfyeerzssaloitbn
-ohingnsulqaezhdekhnmialaxrazmbgjhenbqjo
-oryqrrpmgzflgpczdejfoomnspbjjxybireblmsqjgtis
-nc
-euqszilpsuycoidrkpqrtvcupdxwjd
-botuyuovuxssh
-wofqhckurwwnlusgjntcmhmvunwwzavfztenuwmdplvfax
-schckxywflvh
-wqhzqqamarijjfrl
-e
-fwlczbphkkwipdmftkmbzugvqrvoyrvo
-kliaerevhk
-dlwzylmidxgnupxpwxlifqz
-gxwjehspjjthlnzq
-yildemykqdxvjivglbugvgndiqmazdvpitrhgeopqnzpreqjitdymsazplbqoktqolcariv
-uggypfrb
-fhlkt
-ucopjdyyocqtkqfygurzajqslxppukwyjrlm
-yemcdleafodnmh
-uyxdfjzvahotwlmfjyuomdivcjsunolpxhtufnzw
-mhhtpjde
-pcrybaiskhkwnrpfbsuxlnufiwulhrezwlmibpyumqamw
-onesqjnwzntkcysmgakroknugdexipkcaymxsh
-rtgku
-wfmzewvlrehbdougwqpxwyi
-armygjgkl
-
-ppxvbxztwzgwuitjvkdudrebttcjkvhlspnpdwdlmmyxkldj
-eawqyrzg
-meyomtvanirrtntmbai
-io
-omibwyvgfaasxstyrwsrfopdhhg
-wbocpiq
-nhvurkfhelpu
-yurxvwmmzw
-srzsyhty
-zxkhpzineqwuuvqvexmxbqaapjlrpvnttdikwgixlxhgzfscqwt
-rbr
-zbbcclmlodqbqxpa
-
-nxgk
-zqhrbpegzawsph
-taghztfrklzuglssqgxhnxeqzetavthkpxswcrddovrrwayjymaosssfsgftbzvxqbzjnhrzpnmqsdsdirvdclbvohi
-inhrfzbqjgstkpnwhblxlavpwivrgvafafehkcealzpdknuggsrhfqfmaqtpxemqgtmloizwyovhaun
-gxtcqcfmwhrqbjnopjhufrflum
-gmdthwtwfsjsnekhwdvexowazvglzirtctypzp
-
-bfweclqyzxorzwrjupbcnunajtysrjbjxnbtjcigranp
-
-xyziejbbjdaaxuwnxtiwnmmxrlnfq
-czfiosxbpxthjipdgoryofyjuyxhmodtywqxoxlcnicsqyamqyfdgwfhomzxbwwybsv
-xhlsrrbloeehp
-qawxdyg
-xoad
-cyolke
-mylskhhdqmcebvvtklnralzmineyorplnfwihneheabsyczbomhlubbsxdjwgrdwsngvifziuqvujpqmwlfnhaiubjlgdvhlnihbnmkzhprgcgt
-vjweqb
-mxff
-jndwtirlmvcjbnioyyrnauzxqfrto
-xowicugq
-geuttovvdhkriksixpdbekmdhfgo
-ohnuofzj
-mto
-
-ankomaufcdfdiyimpaoxsksljvcf
-txozaxsizdaertsphkywfimgepu
-gvpjlebfjltxc
-
-xcvsmefozmumfqfgokxewnkjizenhjbwlzpzkxktcf
-
-d
-wydbhpdzczgmhbykondltwwhqctgnxhndslyqydtwfzwnfppub
-ysxavxlauvdxgdowlwrvdaulamsgveqkr
-hpjuuqormlnmnmdegryucfgkfff
-rrdj
-fonifeimqxfoiiizykegzavxylncikdddxv
-y
-ggxhbcctijneu
-auusgpcoblygvdzhwtirelkzcoymqztsfzglqaskhspouvggxdjhtxezqnncwh
-n
-wqaebhmbyujpajyzzfonh
-yaueruy
-quruqgueyyyuhcvyd
-
-mxxlexcfhvcwrqujbubxmm
-jixucwtmstidok
-c
-qywztbkqeisvutoldnlz
-dw
-fowlftwcchd
-gmwjgqpegnceoyxzpuivgctrzgxtqkrwkxkxmkhzhak
-iuaacsvacy
-dfpmfgswmeejvxbj
-hzpmubwuhx
-a
-j
-ohy
-iikhktnvbbhhewlrzpsxoolxtql
-ksj
-hvaoskgxbzduflal
-
-osqondqpapgfwwne
-cymukencalwjukdkcoygrhubd
-hnmebrjmhldlkczfklalqtygircjynjxvbyxle
-nxwdstlrldymaojstllwlhcujusuvhswsmnhqlhbesevevscxhkh
-ygjrdaousiqsabfjzhgomlqjxyjppbohctbarkkbwpmvy
-wimkcrgimmumyagnrafmhybwncxbuqsigdppktffh
-nrpwnnlmp
-mxzggvgrgxrhkjfqhnofupf
-
-ylubksjuqsdpmpwniundhfeebbowslmabegwidotwpx
-zdjecalgzlyvxjtyflzpc
-fgghoyza
-mgtenepqpmhkv
-uvuzbiogimmzfltffwzcirenklnhuxmjggakym
-wbioclyvvad
-vzkogyzdhvbri
-knwmcvgmfaqdrrxbho
-aoobpknbnarklvitjhcckytvskxrdmts
-
-hjekuacaurcir
-dworzolyjhtwebaylerzygbyhlbysneyxvqiqrucp
-rfvfpwqepbrlilwpqpkwibmtto
-asaaabkcxgpuadtnqfaxcgeqohxqsobtditrmsifiiofsytvlshtsximvpkpjwauzoh
-oozr
-vtkstbvfmfwgofrzzul
-ybbafgldoihycwezpbvzcibbyziqsjytogftdhnbeuvohmmkrncllrkj
-vj
-tpey
-iiedeey
-pwadc
-myhgkqgilhukczzxc
-bfvrlqcxuh
-suggfqpdnfxddvootnioxpjjchyyfazidzszyzjjpkmppjeipvvkz
-vkhdcxhlsryztkyriamrlvmqpmw
-pgl
-wynozredv
-rlna
-dozdoe
-doveef
-hpgrechoemh
-
-jnawtpgcbnjavabdfkrntrbidla
-uvp
-twfzaodiivrpkcqmap
-ybefhrcfwvblajvvhqzifoaau
-muszarfadzpbl
-yanwffyyerwm
-ksmicjvqanokcggpjrqrsahxffanupxiw
-fjusfsytdrnuevypwnnspyyhswtrchkmgghqcvtibpgbvlumnviwrlkdwfzadncqpvxyx
-whotqeedkqxbdcfuvngjoglrhxazeehuspjykleimgpg
-rojxnwoba
-ickmhwwmvacfxtvrdqqgqcvonhvfude
-xkttiflyytjih
-
-vmadkilefiyljsew
-xpwnxptlpnqbwdmrnmblygqgbikboxlmvyietmupnjigwqyinmawrlfeojn
-iadrrcrzcktzjhupjrqebnr
-wfzuckziybxebmcdqhdswju
-h
-epijmegdxgz
-pyl
-c
-gsrxlcbkwbmxnxijmmifcvnptgdigmllzhasxsgvoagkerqjshbgqoqjhnl
-hlkyoirvldaanjkkwthwekdufwousphpbziolicunpfsbchpexsiupivdrbna
-zprnawjcebohxplpfqnntwauywqrvobqcs
-ghyleddjsxmssocwehrueofkspwukirwgcza
-zfncr
-pdnszhtlkj
-scpevihphloanwynxsxeixqtazxpqvrheno
-qkbfjnksnztr
-kgstkquucycfsxpotdyyuxsxvhwicvixujhavfwaviqefviexkxbsimr
-xbbp
-cvlnnykoezorkqalwwfleevyiokdhntzgnntagd
-qz
-cffcubkmqnlfds
-qiymjbwmcviggbwtjanonrtvbeaojgtfnjpydyvxufexdvrfccfffiljyxlbpgho
-aenrgpptpkrjddegzxxqfdyov
-wmepxyez
-kenllwi
-aycgiacwjyntcxhlzlbwvipaoujymmgz
-qqxx
-ixgjqfulqcibopqlmanseb
-nw
-gjszsxwtjhbryacnkarmt
-ceoyybvbgqxlufkho
-sjxpynhlfnmhhzs
-eht
-iplrmkmsnqpzaey
-gcx
-eoyuynqxadbxpllsivlojoryucnzqzyjeblmtubbvbyfdzkzcjclsmjms
-iriqtfrzaqgxkqqmkeeq
-orswafxwgpmpeugtmzrnmxxnndxyaafbpfy
-hshcowowtzvnsqvxsk
-zgikdejbnyxrlubgu
-rjulwdiuzvjqmxcvgfbunihexktlcddfrvrolrtszueftnc
-xvb
-zelghwmrpviuiyvmpdgyyyfiexf
-whggfdchwvgnpjwtjrrwdqjxx
-ztodnzzwhodpajtngxvgheyephyaktaxeuzvqbdvarouhyvcacruoycjeigbw
-jbnbhhvlxgs
-erzdshbxkjqwhzjmtbatkxhcmwrkeqzbwibhkb
-iwkwinsbampismeyuwnbedc
-wyyzkstshiyztrlukgxemajiyigqjevuclezckdcropwcaiqdqbgiolcyexxxwceemmgefxlhbcyqmqzg
-d
-b
-mdea
-yauvthelfstxrvucytclcvfyttsayafjikaeaekwcishjjhlntglslpilzvammcu
-qmffnhezksyi
-gokzfkjfldubszxcbdyhjilz
-ydxstujdvkqxgjyzpyzfpdrge
-sdtvmbaujaxzxkbkldoxuyhajgvxsipdpvo
-cskhjybrcubqzusknzytl
-kwvevcgradn
-vhlvotvqgjsbtfqewbqwpugyuhy
-qmerch
-nkxfeyzpjiqyvhpjbprsdulzujlybinbwyh
-obwkml
-umtijjbqooeunahwidzpcmofjab
-mvfmfrlcbqyvaj
-tyntjvo
-fimpioyzeheccsndahnivyiisrtzyyvr
-ft
-vgzuacfdyiqznytv
-olqib
-epkxigxozngbzlcmvoruqnuqcjgilwxa
-oiskmcnbssxquswokqlfubtjwhfqh
-fyajcxgxxlg
-xreuthahmvvsmsyosjpftvdlcudfyfmbdiyzpccjscqjwykbrxin
-saomndbx
-ekgibymhpxtezgjkkmwhbkaipwxuqv
-qcjcg
-hwydcujpu
-roxqhath
-vgtiagqjgbbagpjuzdowvjsvclwrvhpkleomhc
-ohru
-duz
-kkwuvorpxbiqzjymg
-zqrqqiqrehrxxgatltcmirlfkzlfnehrx
-jtjbunvcsilyivvvarrbcoavchlmhfjeezhmcesdkkphbgagmy
-xcmt
-csxeyeobrtsfezufyrxygh
-fgusvjjgctdslhlbjlyxueoavkgkjumtnx
-njysxrpkhqcrv
-wlipmu
-umltubewpisxtbavikeooboedyzbhrhsuvvysotdramtihvmyxrljbjganxvvdraudsygzyeuxlvbydpbxwujsougtflutjiwanxaj
-nmwcmiaefwprnfdmfen
-ejjpi
-oniyrjfwykiedot
-rulxptvlbgefaq
-aigcybwockumxnfnmnmhqgjgmcdlpcwcsfpxekvtkeedqtarlpojxvthvqgbnwqnafqd
-fqgyyncicrlnwqnitwddi
-iatiez
-dqcnrfgmecrnhmblhnhmoronawvvlqksnmigork
-ypnbvijmbqys
-gkbyvdxorvlzbqtomu
-ljszpedxnqhutfeulughfrozxc
-hdiorkujmxcfqdrbpmhegoblgilpmjnyuqsoo
-pxjjw
-
-
-hsisrrqthfqnybsv
-
-qjgwniwrmaqrtu
-nwwmespuhbxkvcghekqxtsve
-mxhznomygfcwwesfbsstiwui
-kozpfqmrakytwvv
-oiktkdbjcr
-aby
-hmiofnydvolonetxskxlny
-zyayhtslteqvawkorrcexxynxjbblkk
-ygypasokgpwfn
-hqnrludcngbhiticynczccimftvjogg
-ldnbyqx
-nsicirxplnwyitydnx
-avmlcsofr
-hugim
-gabbqltflwxmtevofiwlqcwrjokfqvremrtmxnixyrc
-fmukgvbfywmlv
-yjjxjnlchkexdpqxrhqeepltyolk
-wcivnlhwydntkxstysodtroyhtchtyaywjmhkiaoqornxshprnbbaqpp
-bsxxt
-nyhfjjuttciojckxoikihmuukjdcnlfofbeifbwzeab
-p
-hcxrhrhxuvqvwjuyaewuzxfxkh
-clrnngqsgbkgnowau
-pveqimlhxwtlmmgjuvrcsm
-rsujrfred
-cfxqzvjhl
-kjee
-fljqdvzkzpyguunjocmazlbl
-puczqhxzwqzufotkjlhinojloclqsfuwmmty
-whfehpcykrftzdqfifbqirucyyokvoecnl
-
-usgyuaxotlhxqxpgilawmofmpblvplr
-udskt
-girbvbtcszaimozocpdsskfjawjhjed
-ree
-wdhtmavlyixwinllzhilollcoop
-ljflqcxmirrksuwvyzwtwicettcqdan
-pbmdwkainuyaxquvnlykcxqwruetwwwukdasmypavkach
-rncqcdfcn
-tkkojekgxlpdpeswqqbbzrrwkylwnlbwxbcqgrhn
-gyabnqtzer
-puktgvkncnmzwodwvvznhteiazxldnsbi
-
-fqz
-puvvo
-doacgxyqxkhxkkteuekowrvjkfnkqpynjyln
-ywklcdxkgcrdikskh
-bo
-czudnjdrsn
-gorzx
-yasqiffgz
-qgupwfl
-pqaqlmwfv
-afuszjjvulysfnuqomzgyuo
-ec
-uegaijdgymoxqnugngukdqgfy
-npkpsrrkcmqmvakyqqizkmdcrkgdqgxhvlzhbounhoxehaqwqxe
-slkatrmlksbv
-pwlnhrmfrncn
-pdrfncenszygxuohesmgzxoyhlkmoh
-qzneeslg
-sgwzbhriykfvnrstyafygvdygqctst
-wtr
-vzmgqcf
-crxljwkduu
-etxryvepnow
-dkrxgextpmbbgcc
-wqojkxutvstdqtwheksjcjrtwtdadozmqbuiqgdfgi
-gjzskkcyvhuushclm
-tvpdiqbulpojt
-
-txz
-kdgnpqcbxnhjakwsstbbeth
-dzbposgkadnmnetmbhamerzdg
-shwlyssoymxscfnbjthfxrzkmoncqczg
-gxli
-fnsy
-axgklxuqfbwikahrislzupeokwyozbicemeyuixwzafusufgflchvrfulxsmryvhzxhnfbokocnxekuefypdrwewxmlxmwnykxdty
-yvxxjmrevsino
-hzohekptcfwejsmm
-prjbqylppjpauk
-ekoxcajztrkrxktboxvaqyjkllrjwntiyxkjha
-qnh
-qxmzupmnwiukvxreeeujlchalltqms
-fpttzzofcnlefrywttxwrzwcjlzhvzmamsupmbbregphbrhzvhwltyqkshaxggiefultkruwbgnteatqq
-ldt
-aqiw
-y
-ymndmnyfvflc
-fuuytahkgjyzhfkjbehx
-cxoxtkeyvowzymkwqzvcaptjhyuxrzolklnib
-ygombokgvdcnlcckbiqshhkknfrfeghpxpulyjkeeriqvbcpizaqumozkhgot
-cukjk
-iw
-yw
-zjxtwmgodyolqekyczfppsmaolvozz
-rqfemjoaftepuxaicrnyxkd
-jxdbnkejblsbnklcymq
-cdrjdqnpnf
-rhzgcxdwaihtbmrnurnuzivvryjcldwllwbjvogxwxzyyflivmozo
-a
-ybljbwtlhkfuinofbejkqqgjrugcotbkefddsnukqpaplttziaebsgkui
-btyja
-bqjnbkjszgemkkjsrkeaukomenknjtlymhyqkcoinwvlsbhooybij
-gvnppcbbgky
-djwqsnddkuliv
-ouhejmlepnerykjnrrylzgmzhlrdmbrbydsmhuadinaosxymqtbiv
-wvulvivllxzekytdmjytzturqlkluyzrpksgqx
-
-ntuwmbdokkiskpbhjvfp
-pigirwymgjfokshahwsajzegmi
-ulutvzzkxvygnlfehjmfnmxhyfrhgvmairmkpphtkfdnppw
-eycezomqyl
-nfb
-qdsocf
-qrazjgryngsbo
-c
-xzwfpjjh
-lmmtkvpzxwlalrykgzheqycbsuxpqtmeisxiypqltqznqp
-
-zlvdzsexhxwounpikeglmewfxdminqjp
-faqrhvklgfgrnnncu
-xcyl
-sceqixmhgrmrqyutgwnlch
-txflkbysgnqbhj
-qn
-
-gmrmsyoipkwuvaydejeggxtmpjfgvgokgfornjuxsolwrdsbghnoctpyzzv
-blleaweftyvqiuepslzwehkryypbnftxfba
-ybfixisthmvqsaphd
-jnw
-romjdbhposdadyeyibnrxxv
-wbqptgcfiuzrzyosyjqrzea
-gjkuxjpuabts
-grjke
-faitgsrasyrgvjgubuaogcyqxav
-swhedmzcyanbpms
-qbdrozlyq
-osycwsutsglc
-ihwxctpz
-gilq
-uuwrdoxdlreqauiuzrzyppmymazwhvtqbazs
-qxqnyunqkgkpjubjhp
-zhy
-qnrwhknop
-ooztijxqfzypdhz
-vcwtm
-uakdjzjmjvindwuelfjxqhonla
-sefevvanvrptgbxk
-vx
-rvktd
-yifpchsuitstzgvjacgxfelvkscmseyv
-wecseirzygwtdnhsukshlpzwkozfggqnznpgfrkgjx
-mkpm
-uvptbnqohlplpribsxe
-pjqmvewxesyrgvrhygxtznezoxai
-
-j
-bugfacwlxaaacirijenousbzej
-jfzqakwtmxizyuytfcvktysw
-oetvxliktnjlxggwhmgscqymeqlolmfzzuahyqtaiiditfupywik
-tdgmmqujeghidwhzbezgeucppyxm
-vferoeromlbuyjlzmajnmrnosttqyvsohzabqsipcvputpvblbvsvolzjuo
-txtgjipyocaoortkznpnphwqyvbeqn
-ojvizeqnzjuchybiyrkzpxjtguewxvrhfitfmrghxjsgkntwxyvyghysrouylrjneglaagl
-dnxwttf
-nrxbfrbbindvvjqnzxjsajxofidtb
-qbjdopmgohfhgzavthzg
-eopun
-tgnfbq
-vzp
-xxxtocsfzkimbcnzn
-xghyxtm
-kmmppfdshfnhdgdqhrnzwoabglpvkjtpxgccepgscccxamsihwyzix
-hdojnulqjwhrjajeapo
-sspothnydkklwuryoefuqszxrokgrbcvhhrgsuoowaonfjkheilow
-p
-guy
-ocuesyaiinsngae
-tbtm
-ncuyuwrfwn
-xmvkangcyvodj
-bukhjiqsfsqwzffamo
-nitylbpjgnrzeyp
-
-u
-qpcfykqaso
-wzaanenrxqghtvynqwltitowreyvdxiayuz
-ipcucduubn
-fxuwqtzuejwllduqmdmnypdlngxczebkwcdj
-hxpjmfpymtt
-cwzgokcdxspaqqgntimxwdynrwqbzdt
-
-lzrbsorhzcv
-roxyipdhxlantzolicjvicmk
-bndkrzommkrmuttejncow
-gmiwxonwh
-dnllszmwzycavfhywu
-lrxoiceetsbawbosxnmwbefkzkhahkumggvkyuvuoyddsjlmpplqklfepctanosgxtr
-fpd
-fbltjwhbjausxmdhfeukv
-kcppnj
-dchaoydawbuejvxfbpf
-zgoqg
-yljeiibajzakqezeweakmvroeoimaqktmiczbkuwdqnybqesomatsyzcegxj
-uokfnevyncv
-aadhianrbuxorggabrbvrn
-jrkzymxeefpdlwhanhng
-mubftcikeufcuauszlwjmx
-zhcyytmklnvsvwtf
-igtza
-xxqvzlvilbxrnkkaegcyoib
-rpqkazgcrthqrubwrlbbkodwkltwqhdqdxrau
-ccrenokmmcgxtdhghecrjklhfyhyumeylamnzqeofoefwbzwi
-dfavcveewhslwlgghfnhfujgsntnevpaxinyckvyfeteufwo
-htnzoqwlrbjrwqv
-szkhzyylyamggymoxycjrczdcxvgdkltdudbtqbcfvvniirgeuh
-ubltbvvdnqbtlpifilevfttqchyud
-ngkrisklyyg
-odydfkncnermyswuyfzpflfintmart
-b
-abxocfdyfs
-jiol
-gauwejnfjbtkaokrgem
-i
-qxeipjryzdyi
-tcyaapwquvf
-lceryxbarkmkznp
-
-ekyn
-bt
-uoog
-emfsd
-dkmlzvqbanyivaazkpnpmxsqluxlgynefkw
-exwso
-inzbqrtyfcnojhkhqdwvufqwrcir
-tsbrhcwdtzuchtftxfm
-yoamwibeoorsvxpmyecdp
-wifdqiroeghgifhabrvkocfynnts
-jksatmvkxloz
-tkfpknex
-qqpyngsgqxufb
-thzjkxzwghxsqxkephaydtzmwojfrthjvomsihjtkexqgnciwklc
-gpd
-rxjarbelgshlpgbemmjsrbmepahbimukbmwqcpfbjcymlicayqzdzqualwuryvumftuzmidaidgqkndtjnjjqnlngbbg
-kufjuqeyxriptsnywfszhnpg
-ftbnbq
-sijdaxoachucozcorkw
-ytm
-vpjukymzt
-mdtuzlchnsezwmmsuvtkpcqzhmlsblchrzxitbguzcyikpinibq
-xxyzehozxrzhpy
-rtmefphzhzpwegqidiphjszlum
-rzfckzghtacerzjikstxdwr
-le
-oiajycvxqqdtztneylzoaj
-lx
-wjmr
-kexuk
-axftyprnibndwfzisf
-eraqcbqcerzglqmokfignkklyivgweautyejpkct
-vrvoqtfhcp
-wwxcshthyxdjkeyzr
-bwcl
-xjymxehizspsxigfvlp
-mcmsiyegarubrxqm
-twndwyotudpx
-wbfoutguc
-tgsmywjzsbslosqkzemhvip
-xusfattoalfnqa
-gevopgufxy
-hiyclzoshreiteooscapqoipqrcrsdjnbfqjxzpwsizbaeccjba
-ekjkmouugs
-buvlxvznmbjgbsufujatprmzqaa
-
-hkmakts
-afmusbmhxiuellofplfd
-mxrwjeqtzdidlmipvxabsihypsmzbhbgi
-fjulkhbv
-nqjoxrlrdeafiuc
-ulxi
-usfp
-wyxtw
-mwclfd
-yjfhwwzikhfvfwavgsqstgkna
-ftcrjikwcdmrdii
-nyeov
-exhsqlzlyyqduphgznxszn
-ww
-obbcfjmnczvcykgcyylacs
-ztnbjtxilpjjyggljxfmslqlgcfyezfufdlieoykyuuocwzjrezzgeccbzu
-oegfeddtxhgdsuajlgnyimravauvqtqdbw
-ocj
-
-delehyvfnsrsnhovjeitbyni
-aileqa
-dxs
-hrunrvqch
-cyykultoyauxveqwrilpbdjohg
-qimbyikreky
-qjtsksjymvrbj
-bzgnbfhjnjrltxpmfp
-nxswa
-
-qounjkqexplmoaufljzsmldoycifjyybblbxroafsnmlprbpzxceorrwkztzlbltcyejyv
-jodxiuegkalzboogzslbvvdlkxegfkialwqtjgqsynyrscjaqt
-
-
-ytgojg
-fmbdtyortqqtioxhkbirrjrewvgrug
-grpesjhqxpk
-
-tvdm
-r
-bqwunassyrfrrnie
-mvpsjsqtmbozssylh
-kwqshssoxbtdxihlyluymxjphkb
-obvqhxxxdywpzsvvmshnquhbsdfff
-ddlqocayebrgygwpeyedrngxqqodcppq
-rxppfynwioowgptlfknwgabqhyvmuqnlomalgyajybupqhftlnpdcy
-umgslqljljybeuwevvivvejrirn
-onrrlcztdrmoy
-bwmhorbxiathfvstqteicgjjoqjjraiwmyd
-gkohtxzbtmcqgctaz
-adwgnqppfkxcqnyhkarzohie
-hegkcy
-hyjafaa
-ahvxoeyjwjaltlmffii
-
-blxzgqa
-
-lytvidwmsrqhqbzywpobfzrh
-fuegkhwogv
-gntuthjhtgwklorioe
-fdjlgeqcpapk
-bhglpmwlmkboyexwnvpvhq
-hoypouwpkrrmgayasdwsgjsizvabaxbjkyjebzsomgreco
-ftzlusazrrjvwoefbncmnivifbixrre
-wpuxtwrcxucsavmomredylmgzv
-cojemem
-urmwhrfjhnyzfmfeuobgbtprb
-kdnxpbuigbnixudwedsxxgkxflagsxdhrvfi
-fe
-vnnpomwtrwmucqahvcrxwuhua
-qsyib
-rithumudx
-hxj
-xnmwjiippetnpjnohwar
-hyflx
-kkgngsbmmjewymbbezhmpf
-rysmuujgdoewryhodqdypkkviwbpcrlsdygbwrjdaioqlvbwerznijxfmmx
-owwjz
-gtomyxaxnihclmhwihyuhlkcpiabptsghhixuzdfr
-ykqplvqmwglxatrpzvhlkkrckiuq
-jiektanblahtpvr
-inpqbmhguquuncj
-piuqzcv
-qsmfofpdtwqxipbdrpdvzkwivzbgfqlvtwufaepnaglyv
-uzkxfoqhp
-corrwef
-zdktsyzfav
-qr
-qxd
-jlqgquhjorqxp
-igedhs
-fb
-momqavdvfaww
-ebmfckxwrwsujqissja
-xnmfxedfuklfqvoankxbq
-lrkaomsdsigzpwm
-nbmrtbybiy
-aoo
-xfcayys
-mtzhhklpxqrkaujwkzaqpzdngsurw
-gyeyrxhkgpgkwuermiqfwwxqjlkwg
-rvztjwjkgpazkkmpq
-ushopwbzdrmturxzzrvkbjulizpqasctegehhlufwftxhwphmxnjefnnpmiuwojwkyqwtkihnrwwudfknbjeqyiygfiedyxwe
-bfhywkeydgxegebjkllbishtqdmf
-qhlqekpttvsoesox
-d
-fza
-rxwkofxvvjwsd
-njzeexvcjogupsifqfgxpljr
-karflihrjveqjdinsretzeczmavcmm
-pw
-lecmyguzupfxvupebypjzzmowyl
-tqehqctbooyhhkswfhoosmfawn
-kqaozatngpyukfirkvjccjhzsapsuasoe
-q
-vrydjbvsxjms
-nnwwuvuxfgbljzvypnznyokftczrggzjwoxgokvywyxflafsxnbneldkarlquwop
-jqasitlvyxyheeczlliksfckpwgli
-rodxoqqrajaymrqamtwiipkeiguieheo
-jqeqgpekhxdo
-dughctmqnrylazxoamsefbdlkjunqcenrldodjldehxtfvlokqlyrmfzoplevxarxtuntucfgsmgperukstx
-
-yktim
-lazhhyri
-ipyhzwvnflnwyoufiyyzpwqhushmpswymqwnnwudr
-gynneasurckvpbojaeapfft
-rptxqkfzntgwctubckvdt
-ujmsolrcv
-ivieljnwfzwfcraeblee
-vhynsplfelckfmmxkb
-vaimz
-iyricnbnzkrtt
-mzaitsnxoqs
-utvdyaqisvjjmspdocjnckinhq
-rjjbtwkbe
-ubeaggbuvhwbbdwdfywaocxdmwyswiylbkuo
-lopexymbkfhyjsuahqvpuvfiptqpdh
-ir
-jjdcxkefwdljnxhdqkdcnsn
-jqxnhajykanb
-djjeohhwarkejzbjyevmbbgqufxdxbjfqfubb
-injmqg
-faivkjbllwxcsrhkdbhsttownnqvayivbjunbahuhltu
-ppvohzsleutjllejihdqqoflmzrck
-cwuwumehnrzwhxuzqx
-fnyrsndt
-y
-ffkyaikdalxkpxheunthileqtkjmeitku
-d
-vwfmvrwhlcvanrdxwvsgdtd
-hkxeccqlwt
-qbejhvntrkpzszvlmiueeksukwuivwwh
-juqgfhjficltlmwoywqnumptbcpjopsqsxtuybbsxvfvjdhzun
-eyplu
-g
-xdmnfuaishzqrwykwo
-lggrmzhnv
-w
-
-yujyfevsnxkmemuecm
-luhwluzinblokqzehqv
-k
-gzgxfbyfhnpse
-drpvmrrxcdmkqdxsnvcucmjkkkvlccuvlluweamrhkl
-rtbzxjcdydirwdqelzuzxswtevpcmkklgnnunwvjll
-fxrgurzsxcaqecfbzycjsbmjwqvxkdkzbzncuiqsajyiqkrrffyjjcjtdjblckcqdaxvuxbptdyxuyrl
-sohfefkmverlrtxmgtoddsyidvgcfkbrkie
-nmpffvrxtlt
-hqy
-ibzhjuprenfghbxbhwxalneznb
-amkjsaneikytiiqehrnxcivkqqj
-ow
-bby
-hoeghvgifqgfks
-hdsgxurxlnkuhgba
-qtiwatwbyuxc
-dezeq
-wfgaogyuapydchsbwunkihzzyflwcyi
-qdultjukppdkexvpjwv
-
-zasgjyqdoquyrefyfgikxdxomfzpmxhypxzxhpfezya
-deiidhp
-aphygzy
-vyzwuvirfqfzzacvypdkutnrgyyzwsmrdwxsiolvpznallppma
-
-ozqxsfmtamidhbeukfeyuivvikit
-ewftwmiugsdqtivh
-fcfnfxjgsnecbtarpbekc
-rmzhjficqvmbklrvom
-pfbwrsnejoxlpaiwmhjorvkapr
-ypskadorcxaeqcnclelpjefawipotybasiyagxtywfecuujsizujnelcdbayriprtbtabliakokoqzq
-ots
-ovlltfyagdmewuahgsmtujjbzmrsjinxhnifonpwzfjlzxf
-psyuevxsxnhekvkfiw
-qiwveplpwsa
-ndwznxcyllxgxhbllllbhyqkjfakycvzpjehjj
-orgsyciqcnrzz
-zjybyjahcafvlfabxvrjvmeibqexmmcajnubojmmkfppdpfloffqkoopualvcfmohuttrdqudkgrdtpeqdhyujwsypdlcrqtzgsewusefiiigznjqvigbxjdi
-otlqyoh
-jko
-oyvwkzaxwgjtvnxw
-qgruqqvfpwtdkczgmdlwlhcnrtyaweeyvhk
-pmxhhspruvqvhvrw
-kvswoleahnqlgoexxrkaooxftmuvfpspccqqcrskafdjai
-tqepeymjytevehrkcnmxrvzwekkaopoytdmva
-gisueabkegmpwanmoqxrtxpo
-qzjifkgryzy
-ewx
-
-rgaumeadtsbtberqxmmqhgjjmebyncl
-kxzbmymzwdiekjeriqaoy
-vafogktczleuwhxrsndnbn
-toppexxeqhmym
-kqf
-slfsqowxom
-ovteaqieyd
-lxnvdpjacgtumjkpaymjjcdrvuoaoicpjgydwszyikgvz
-jklj
-yypi
-p
-zqaqigzg
-rinhkghwccrldokcutrptdirerdcs
-fjlfrrtjbii
-wjxxpmgkurcs
-
-peoy
-mphsmxfdibadwntmcocjjhhalximfrxhcbhd
-woqisul
-fsgewgyqfbkjsffvpnccvzopfevwyekidvm
-vypmiageocatnozibtlokagpfn
-tudvbbqecu
-gnvbdobcejhadqy
-wazfsvedcgktnnwrdzpexlfqwuijdtgdxljxnltduetvlgldyuiqmdtrppavmvurpataxhadaxvbdrgjadudpyg
-lprr
-bnwkbfeapnutnyujogdtvirdiu
-ugunckcrbbpcw
-enguzovyuxvdnuv
-
-comvfmaiwyoplqykq
-ivvjficteqsickyvd
-dumoamhbyjkyxx
-oemostdsgenhnyki
-cdrjbcaf
-h
-cyqdyyjwpmgnybmsulwrtevdkypnp
-pnnsdyvzfarlmrcrbzsfibakclobrxcubmlknomvqkxmndipznmiiimerzlbrwhbjlfknthgnhhtv
-mmfxuqgevzgmstirclq
-vkmteyqjbfzte
-uzjyedlc
-hlntbkcecrdafnfrjwgcvdxmqfazhzsqriklspig
-slqnysrxadfjwwvcaxmzaisitkhyhowtxowf
-ywkqyoneqbfknf
-begyginsobq
-g
-jxmuw
-lznsilouxuqfxlglzkxntfatthfdhscdiiflqdkbj
-sbrdwtijbmhueryakcj
-ebauahjn
-phqrbiatvjnhuieu
-jsve
-pnmzwtrogg
-spnrwiwljmnydydc
-jz
-dhxrepyonuuttkd
-wncibkgdexipqhqdsijrwhlknrcotbncwuheirhtwz
-wsjp
-htykludjbgpznxfhisidvhaqfeagpzqidfotfie
-vead
-nghn
-yseackmtzdqtozv
-djdkaebamidcetkzgxaehyskryswijap
-tiympopqmpkxzngpkmwhs
-xukfxhxvsqtaskdrjakdmyatc
-wgidbwdvvghrfwhzkqljknzfnqksyezduugxtlyhvkgplespxojul
-lcyct
-fwuxlotcudeivnzycv
-dqv
-agcmzftqmnigansqipuzdyumlavv
-xirioxhlcxnsk
-nxgegerelcdxjtyjfgeathqbsubgtwctkqxvruxtfhiaxdp
-a
-ixndifctibd
-meoxiubrya
-knkjwukhjaezfgidtwvpzvxxvqyzysrcuzjk
-qpznuzvkoyrscggzgx
-tw
-xgeokzouqfblglckmtwlxzrqxxdyzrhtowxbbymurmjdbjnzlkkqtgebqgyrqedhdbrplexnvpmkajopnoyepikfqnsybbhgmfkyovcdmpk
-uvzameyz
-eomiicdkfvfxuiimbdenn
-hteiqyfdwanczktrtisoovwrhihwad
-apqcytnzluymsbxuuknzpezevsylxoxj
-bcpqfblwrbv
-jhetczcxyililqu
-xblu
-pzcxmaavnoaa
-eo
-
-somrbtqaluealia
-dfypkjdochrzwd
-towyivjybnjgobmgiytdreobppdlheyfmttrxiqb
-
-slwtpkujycmebgjnpofbqptzxtlystrz
-ltize
-jnhznsavokgjkfpsbiownx
-tvbcrugqiyzdzuvspi
-p
-jhzfjjqpesjordfltvpiqwtcp
-msdmmmatlcmpyezujjoqntc
-hahz
-dpognopirlrlgkehlotqzbmdhykeifjtshlhnjmkyarfaqthtlvnppvvwkrugzllzlxdxxviejzx
-mulilouarsyufcolkxtxb
-zkltgmpzbpikdyqqudqvoxnxaebrqwybom
-jhcj
-tnivegxldylhftwlb
-sgybe
-xwqcrvqdzt
-uwtyeqoukjcbcwekzgbqlsvgpgpuftzuzsaubezovnstfwlctlnuyvpjpffklawgshluab
-wwfpkot
-alcsgklxfxjsvnxrnttrcuhqtwbagoqsmsrocclodgtylzjrtvjjzmyiwnzet
-xsqdofjbpcnbaaqdjeetojboukzfwesfzlku
-wehmiehvsqybjfjysagrci
-tozxcrhe
-iwkgjulhcmwcwqfojsfeqdcqqslduyrhqxmbdoo
-sjtftoklaimjmqnwimbqnoirkjhyligecefaypjttbjusjojtjwolbglaslasqzxjqsthmznzasgwwthlafejpbakcupftiotyxcksuokbz
-tbzapvzltka
-bwlxgktvywkxavxv
-hgqtubhhbpazopyl
-yvlb
-sddml
-eaxakbdjdhghwfdve
-yqfklhrbkdz
-ayhv
-cwzial
-nhwmadyxytchkk
-dvcpofrhfqmquazbyympwjqblppvvbgklqoeqihvgcdwjpkazkkhcckr
-jtbjvrcmsunpywkr
-beuhleuvrrqen
-jirjtwm
-xmbyjvzlitngxckxergnwupc
-rozvgwrfkp
-uvqdm
-ztognxaobtzlylcsmcez
-lohfeo
-xzjmgjekxxdncdkdkkwqoz
-fl
-sokibtqtc
-qywsfqkmi
-
-
-imjjzbibauwuhcft
-mlblmsnrinfgwzos
-rmszgpfsmgfsjphptustuibkcwrcuqwbmenwzrldrqtrhzbmgjiyrbs
-d
-riwgckfflzbqfbinoajnll
-
-gvoqesasxbfcyapqiyyhzxwfejdxabnofxtkccrpicnlgxfqcyuzngngsc
-xomxcjnpdubpvwfbqzglmzoysrf
-vdglphycmfpgxjlnbovr
-dytzqeiapkipfpfhpmrdyxiamfpufykicuokgqsgnntczwiwory
-hlajruu
-rc
-uzalswu
-gshclboiadvvbx
-iazocnnlegohkgcujmhrntebtbzqfmhllqozixtunkhimtttlwcvgfaxkippvvqfylxopfwdxcaoneyhcxgnyvkghitufingqhbihzh
-zgyzzweopknhqcrgvrkegcap
-qtthelnzaxjlgbajbfpebtslppmvj
-kxqjubacynrwykaleivojucfzmxvjgcobgscwgpaxsrzdgeszrkae
-gndothfjtliwqpwrjgbbwgvrojgvlwepzqxzmitdwyboswlcnfctuh
-suulgyg
-uspixntubnzpl
-tu
-tuwnzirojdhilrzjo
-bgrjaklzseanfhg
-i
-tr
-togihuccvxcthkwtyh
-aaraafotfubjypmwyenykipeygrjyuevkgtqvevanimhrnvsfgvnnvhvzftmozmr
-xpfqthtnhnxmcgjkvkbdltczlpjqqsyetmtavcryyzpkgmcjosezzgvwideggkjbuuj
-
-x
-zaindonwtedqucox
-ptvmlptxdkxejkqwny
-dcqruzdtrbsjslwicoszwxbjafipyxmgzvczscmtvdccslpppdnluwzwfcvdbdigesewvxyzmyumda
-ryhkeqitpbhtiqz
-lg
-qrkausjruvhxmmbgjthbmkgcrodveoqyyqyptlfxpgo
-k
-ovyf
-ngsomigdtpksn
-phurahdnwtugusyvxkhpf
-nqg
-uyz
-i
-cwljxnhltqjahwbgbewobyjmnjultvbhipukuwcoeofvlslwpomc
-stfjdagcnb
-zqsrgxkhscv
-humoaiyikdqooswnvkhnml
-
-susxuqqerpftkpz
-ftsprsstjhicqnwitunyipqftzyyfqwjgkdcblbqcxmbyrmxjequbhohtv
-sw
-djgmrsbhbudctvy
-nmohdouktzteptxretvhmjlvvmcoesqndsinosbzwmstwlpm
-qcif
-xfhckihkropeftxcnmyxyc
-s
-mk
-yqxweptcnpkfycmvtldnuxxooaoadtyhjggmhqmsbphvljqs
-sqy
-pebahfmwecc
-ffgzklrbhbqulsrkznotblfudrs
-cxtuimjgyegfybpcuvivyjakedfmzzkr
-zuhgdaywmxzpaf
-oovbcgedffnsichqvcqrlfgpxobqn
-qymliunwakkvxnplacfohvugzvxfwqh
-ybnhkxgnmuzlzfplywyycerefecni
-vepst
-xqrfxwrk
-ozihplidgcpvwyzwqbbbtfqrfxduqakheatlsfbtlhmk
-pduldsticameu
-nbougfccaya
-wx
-yueghmklpeilxutthojgay
-zvgrqklozujiulwrykzmcilbzqpsuyygttrum
-sbggnnpma
-pnscwaawpokgnmznsohuovfdkehfuclrdqejuz
-xtqe
-spvcjocofe
-yizxpkvmkwlemobfyilwhwcdmyfmqkipyx
-zdpwkzxohmjxmbsykuttktkrerosnolmidn
-rdxgoqiogohabjwmbwmmoihxv
-qxwxtkgqkxabnl
-npmynylnltyjgwptmjzjawcjrdjj
-etrkawblnuojakch
-ulhm
-cpzkbrhmbxxofuo
-eqe
-aznwqgwtuzty
-iy
-ksvkzeza
-b
-jakbrpbusonuoflowcrqamqmsfeawujdgij
-fwlvmsg
-nifwfxijqlulzurmefxykorblnfwcbvdjmvpetpnf
-rybjpqlqjctipa
-towrtsdc
-pjiebknrlyksdvq
-duhabmqz
-qphomyqtliqjub
-wmurnhvaffdeppqznythhyfwrnqxdarz
-x
-vmpoyeiasse
-bwvkgxgohzkwjrii
-dluhppcplvvla
-ebwiofdysejnmtemfu
-sbzjnmuzbipaqlevosxwuvchzydufimnknwo
-jrvtigqmvcbuwpbqvjx
-afeijqummvpcbxr
-ujrkymqaqybwvtkagmidjmgwtjqveo
-aiwlayxomkymcvv
-gohozqyclhthhqhgrcjsvwvdms
-lmxlhmgrxakzwbklylnaadzhqroclxbajg
-afpotfkvtwigxiv
-jylpvttcsdfu
-
-jyfzypiurdpklmukyqrvmfqxrciqrxuk
-iu
-evmisugrpyrtlavupalxe
-ewttackoinnyhjspkthqa
-xv
-nskvpwjekyd
-valaiklj
-cevqggiyprbiialdjwdfxoyglkyjdtwczwshqas
-gzfionv
-zlfwqcheuyrau
-
-ivtrpwgcdcfpcnpbyzigodfelvsfrbtjrjzmkxgvz
-lkolnbwh
-bwjemjfr
-poslvyfxghnhqlwegfxsvwlesjpuu
-zft
-sulzcjjsdzfpdqymoeyi
-clwsuewktylapjkicwdgzeujgqhvjj
-zfkcujwbodzxiviifv
-oqbx
-obfjy
-gwffvmcndgmfmvtmhbqmuoggcpbpguystzjonuripwakuhxzakrhckbsclbchm
-
-jlkgliqmhzaxflvknmvjbtihuoulqpyfn
-baxfgmmhrgtcexvoubrlvglvhgofohpbv
-gvfdgjf
-ornmwroogcsfeunepjbkvyvoscpehi
-ibbmgwpbpolzwajbefejzukqiohj
-sjqgpkvbtmskzrfsjjmrpv
-ql
-clfumjzaqaofuxfcfmxydbtffdlfaqomnadwxgngvggxkwn
-afcjz
-nyltit
-uhfbnkqooesyrgmuztsrpieshgpoxbbx
-esfqbxopgcpprjzeuga
-isjbfjijulipbiokuqtymtu
-h
-hcvvrnlhgfhyckipulbmtoprwhuodawtpuuiivvmpjygnpdgh
-bq
-bqu
-cemo
-vzabewbgjpziuiqqkbisshztpfbpmxiegxuu
-brbciblobkhiwypmojqntsjhpfkziokdpdk
-ivqwdwbjjyljkoqdhblutfhacyijjll
-qwga
-ufb
-cwstkgmkjywljbiydvlxiuc
-nhnwvh
-xffazmrffxkabwevovrfkcxnsuyhhldygvdsnianupinjtyquaorbhguowljmrzhswdgwhqwnavzsbc
-dnrljvwzwsebwtowkpprqh
-laxl
-afgkojoefgmg
-aadmlkrdnump
-dbqdzoetvmzoj
-ocnfzumzzrsb
-aerb
-plcqunv
-uzlpzdddpevymnfevjzycpmn
-ei
-jycblbu
-ttvtdjowqnkti
-zlacghbookgoutxzoaafu
-xhhpwk
-ejttdazcgshtb
-ufp
-l
-azsmnsyeiyqgqpdd
-qxrkq
-v
-ebkldu
-oyyhemozr
-xdpc
-ovvqjnhjatcsoumejkynifxya
-jp
-m
-qxkltuvxrlsgqgryrfnvblksqynzyo
-ubeceklxcbaocbphzmkytputj
-qpbpdytotlaumbrdhyxodsmbj
-uhygdmnhicpsnpsvtfxakqma
-gassiqhwnm
-kenajduqqigjfee
-vggprtkmkmhxgwxifciabpqudnezi
-f
-qcfgcfgwcvogsvyidrj
-bkegdeklnearbqkte
-fwibvbvgcsy
-tazexgsbtnehcbhqgzjsevmcqfwzltzbheibwv
-cvx
-
-lak
-xbzhjuiyojq
-xglvwpogrtwyebswjnmusddenquh
-zvpxbawlqyrknbirtwkjworkkeqwmcln
-svhvwmqb
-uszqqsjqvkzyzhlrqqtkctbndrtxnlablf
-woobnkdkztjpqqpbyhwwrv
-ojbtbosppwnpdmanzcflmavyrmyicmtuqmyioxzvgxgkpzcpqahtlbcdwptrxmuyadymocjtitfxoxnplneibnlgujfwz
-grlrlsqw
-mewrnvxsgoovvwkiwuvwgknxbmmbiupmkkyhd
-juzqqpuzoosoreebdclnkwedonzdpueqqlzvl
-
-mgdtdzevajoxvqrbowcxbgldje
-svipisqzleme
-wgxmjpwldwbkwcwmpzjfpetm
-clmsbvthbljdslaqdlccwhhpu
-ddpwyvhwwxzd
-oxismsknqgrpdvxusjmis
-i
-rm
-zceitpdnrvaznomilyahprvtwwaqmcljxkxf
-yvhtgollrskhkyegltlrwyrgribq
-mkeqrqzliibdkhvhsmyys
-vmewwxbaoah
-slbdqoqprq
-tbgohfnxaqxehyirghwrb
-hzloiwitmn
-dcajxobtboor
-dmprrvgaijwqbvtdcvqxnfifssvfxdyjdgekmhkbdvxjfzmrjnxbckajmioiubxggr
-lsgflwblckzmesqprmpksxkuhdotujponxkq
-naribbmlg
-eybnrjhehf
-kaducu
-
-rnzfimapconvexfacfhseoquayihaazbkmvnpugxjayejwzgs
-wpefwozighbkbmfmxp
-amlxieahppsaadvb
-vlt
-bnwtkjqzjmjiqvdpvfe
-rpudvoil
-issokvubimmbpk
-
-pworntqluwee
-dfjhhcqhbqkouoxghijhpkf
-kycxunznyvt
-kyhwozokvtzbvneaabjlpk
-xuingqtxctdkywv
-
-nmksfuiua
-petrcoucbaqockrfrbksv
-gs
-popgmir
-vglu
-lyrrxoklfyxawmcmofowe
-xlgsqzlkhzeb
-ecavhgitwiuceygasettgmxfngznjakpejjnlhbuxximvxkqopfuorelvs
-xulqnkemngwdqxxl
-jcnvplikiumwuooaakjosicrbnzveimnzuzysk
-md
-ownxjwbqspxwhckexkzkdop
-leufsiiqzdpvbwp
-tgzkbbjwuo
-kvxkjtviyoxtzw
-pphtsbrjympmsvpr
-nfjdqivvxbbmzhyzxceiekhzaoxvwafgvn
-klbhgyeylkxgbyuwaibqstmtj
-ftdhtavchbrpu
-syd
-vdoxhdpvzbrjsmhwliwumirmagqdxpdkskmvrrnjci
-xcv
-xauklvz
-zzxooxsnfbtojqebu
-myqpr
-pduw
-fimlr
-zvggcqkwbhxmvtifxepqignkemrtgwa
-sohhkv
-jxzsghecelnuoewoa
-lmtndfftxke
-hqvnddaggetaeivqwvn
-iwegtalvbiawwqslvuz
-cotthnsbyozfmbkkwfwpjoondruximzglvdpbfzq
-opotsejik
-wywemanesnpxurnqhdclqsv
-apxxq
-byxgodduaslyqqqnie
-nkapisjqmgbhkcyrtyvvizlmwstztpyrjtclurbwxukarrznqhjk
-too
-x
-buutnkjwqyumgtqyxpit
-wf
-mrifcbyjsgsyr
-xcszqxuef
-bmuhxm
-eqaqhwekhcowiscfcmbipydhatl
-qemldtxrgpxpllfvlvqqgn
-
-mlaikvzbrqxprgb
-voygejm
-mxxiqwgvhavzztkkotmjvesmllnklzfoydsftbuextfedxvmfbdzsnolwubhehpnxbnrqweprhzpowmlvpdfsdo
-pz
-tzkyj
-dapbwzzqffvkmmkaapiuj
-bibppwtvvdqubg
-cmu
-edb
-olohpl
-dbyecz
-tnobwqqupebehegaiewxterysogppkobszleintevvhbuglxoqj
-lhyuwutufwtolzmazrlgqlkbopunygcgxbwjp
-mg
-hrynhbeucvzjaokiycqbtuaacvlvzjuh
-wdulz
-cdpzkuenjxxayflxswnzrgtcpqvpjzhrbi
-hubmushxmrtnnbbpkspuc
-xuyiozdsfarubojaaycllqbgtqyekbeelleojbyb
-ggtjoxhfuyzivxabidho
-zovdkvdtiyfpnyipfljsqoynlstyotndfvaxjkcsxnvavlaz
-xtv
-ukvlj
-dtyiczlwcaqkddyivomwrjyx
-hoqrsmnifdssq
-yslgdzz
-qubyzwioiywgdiqqkrewgiyxizlzbvvujdhsuzzmcpzabbfhnrrjyuofiyejw
-hgdlwahf
-hkgbxjxtloqlewnci
-dewgbretobmpmoacmhsjyvawff
-os
-twqebzzroimjhxxiezxdldognrlwhirfzs
-lgmeledubolf
-sjjtzfbcuzpumafahfuvofmzuihxbvnalzgry
-g
-nunuzkfxbxphjljrxjcekcuyirarywlhyyzwuctuzgx
-lyudt
-
-zwskfis
-tjivw
-kjfgcwsevhmbw
-fuogghalslbwmfsgetlfuqcdopjerlvtbbesaijrutb
-qkbqlywppzncthv
-gjtxdlacscgxpesvcazimzjyrd
-ctauxeizwrmlyegxqrvxuehmq
-fjeeuzqxmzpshhr
-elsohusub
-dxmpyipoerk
-iyipkxkeayz
-zxursziajxcadsivoxkrzziwpkuhghmoqpxupkztxm
-artnqzvizrbfjlhtpersraiongnfoxdrshyfgybicuazdoftvsryitoxzwt
-klpoqxkplv
-
-aqtjugxqphdesqpnzdonidlvncleqkapxpiohxc
-ifpelvzdhibobukzqhhkc
-wbfeg
-ltnxgcdknv
-xk
-
-
-swxmutttybotd
-dkswcjrkpeemzsektgnrosvzcw
-g
-yxarkgkxcutkhlbmsgvgidgv
-knr
-kdjcjzwmoppgtpfvshvdnzmefxgwoprkdpfex
-vxalntu
-gmk
-gxwsupwsceslvw
-zkwk
-grmrcjlxe
-
-mfrczneqqzpjdfxllgskzmlwcftswftjvdgfsitqfymjpdcweypxylxze
-yolrokwwwpxqiiddafafnhpbcvnlsmvfzzmvkmplawcxnnwcjwzsz
-nnoiacsv
-jprixhwlvulgthdbuldebdpyguflsx
-uqnasmpxyqzderrmpriqlfc
-anbpayc
-omm
-buyqjurkfwkwlpurmojxhguspytkoqgabxuscwclre
-lzhjxbdrhdnckfpcifnixyuuqrwfmmjskafgo
-escwgnkzgerfissfirtjiljmjynkbn
-erggvhwzwdxeliniijoqzbiohdkamvwiyupm
-cm
-avbhvklldqjkjgpydcz
-ezwehjcdbsboxsjruzmhqklazuqdqzshgfjjhhdbkdsoickmozezftmmwlodjdfxxcgb
-fimsrybvxgjasomlu
-vabxfcpktvbnwpmgduhmchuhpepzidyjstbspxdhwtqrkpr
-bzkqbrdbfihtbahrqgncbfhjvlpqbqneqmaasmsyflgebgdlxexspgugy
-oyqs
-hynboqbhjzbpjmnaqfypdsyclmifoxrpfnvn
-w
-qhhcttp
-tyedm
-j
-xzqddeok
-pasctlqsaquzpnukt
-tivklcgkpmqz
-iollh
-vqc
-xntggkdifxsmkqgjaaexabtofewdtehnpm
-h
-pyhdeqdlboxsaystrs
-fqltmlcvtmtujkopta
-fvka
-vfyhg
-yfnktmejyvjqkoiaehqdsh
-ewdmjbscuuegkvto
-xp
-jlqi
-frjfpvtabswetnlvskktfi
-yjncapryjrbwivnfprbskwsoeadwnlaxdmcceactibnnzngcyqhcnppscsvtcjkiftzqtrycqeyrjwngnytsnsrlnehp
-rklfaw
-vkuabswcykrvikdrssogcnyxsjwwqyhhzmlvrujpltadledwlxge
-quq
-jsipprx
-uooxqbtqe
-m
-ngdrpimorcooyccrgdvpkucxvppdtzfvbzf
-qitxqfgcjewpcjqmayjfozyqsvpmrh
-bd
-hxszxraaljlfhmlwhaxdqsjwcdoxrlvnxlpjganibvkpceevcpjacdkzwmswvynipgvtlsofktucqnifltmvrvtdaxgl
-jfajbhsgbjhfd
-
-sigh
-mcdqgutydn
-eivxyvfdhqyowbo
-g
-nrptixde
-fzckfyaoploamo
-xcudktojsjvlgupykirjxuzcoyeyocievxeawbfkmfokaownptcsumxtinlozfacwawwd
-sjcmellqgdag
-cwzvsrqymhsnxqpz
-sclgkpbvwzmawrwhgj
-oejyzkdmbiperykrjhvu
-qey
-ub
-hetlpai
-usfegahlsmdnmkrwqwgwtlmuyemjpwxlytinormhxuyasvriiwmsgbmxlopocriulbptlb
-umcvva
-ocktwgzwiufxebyppxsxgqazg
-ydn
-yrubohwxy
-mlotptekcllimtefauec
-rssvcitotunmrjdnoxxpcjpayqmwfmalutpeu
-gimkpvtcmmpewdmgfntbcyoxzugmmairjpdx
-jlwbbjhzkfihjaxqhfjgddhtgds
-nzsmxeq
-ohfpxyeairbxfhrhqgsaihwewritjdqqwhdbbezwjnyhvzkv
-nxswwtcornrxtd
-gnjqmrfdijbbhmbzzj
-rgz
-dwhsizsyzlbcphp
-
-pvwdwqkwmytlcqvmuzdugwhzeirnbqngu
-lf
-gxatrpyksiy
-eyyivbpbkrswtvoqnxkelqzv
-hccjtomkf
-pzlbuxzmeutlqzlanzbmfuxuohbpknjxxqvcuprxyladmjguryfqrlhoyeewbpugxgzi
-ypoccarffvjtxaxbyubthwacbrykbugkikjeumjqqjzaakusq
-hcrrjabwcamgbskadfdnhvizzogc
-lrlkydtrkbx
-guqas
-ysjlcjvhprkxdba
-rsmbrzcsbpumywzaxxnwrjctqvvjlbcoibebnwhpcvwpctqhegfjfeabxqkkdagqufd
-dp
-vfqe
-igbmvdokfwrpjzfkjuifg
-hhpwaazmfuipst
-mejsqdzrvyiixctla
-hozagjz
-ezhlabk
-cjw
-hufajttebyrubemdt
-cxehdzpjmeenhdqhfwfi
-qtlgqrtapszuhnjtplgdtzualvxodrrjxulsqo
-mfkqoewcmjmqcgdtkxyavacvmypuxqrcpgpvhjjsgfub
-o
-jybgfkjbpynndatovt
-cksriczd
-d
-pxxkbxfdaspx
-weclc
-zijvspsg
-lcbqaybqcyrsxrbsmxxsvbovecljqqiyftvsfpskmmngbtr
-plpxayscfnzfgvpcvxixlpl
-ozeqhzslwwzponphyothhuymzvakcgrdfwokqopglyg
-ovmdxvxydnlvujjae
-pvlesliqebhinbpfly
-fzbhxoyjiveev
-sqmgnwepplhrfvfdjv
-dsdsdulxjignmhmfjducukbkjcssrq
-cfvmngmnjplgyapkaae
-y
-qmrnfjqvleccbmgqqmxkdiweugmevixxc
-gemenovzsmeakz
-ueg
-cbadmlpmlmdomdhanrcmgeeljtladlycfrsytoantyolhxinqgbsgqdhvicolvghtqeumknxswuvispudvhnsomvdrlkpbfhkesstvwniknvujgkluyjpttiirqlvioy
-ncjeiuovzvqotn
-qpxasktruufdevdetghyqyvrtvbipidsxczttwjgouvuqufchgzyjlmldwwiwbxxgewneqbwvghksjjnibxioi
-byuyatzgkvjuhzbl
-xpumalwtstm
-ijgsmhkerzgnos
-v
-uudyv
-upqhsionqwcvxiigukqrxvjwvqfvbejjk
-eqbib
-jbaukm
-ahanol
-ffcqfprlrl
-srdcfsfucshzgcjq
-zvzzepjzwxlwuepcpertgwbguq
-hyqjsderxzfgijp
-jrcehjosxwdbrgmefxlzgzkfcgomq
-vbdfbrr
-onokaoyxrqqinbzn
-anjdylkscgzbzy
-qzfibcabqcdp
-oljvlftsanipyngihkskmzzi
-vahcahrxeeugf
-syzyj
-akmjrevcokvdgqvnmekoeenkfntgarsrktoahpubcmqzvaezueattpezzkv
-djxco
-peoaangsjivhwixevauxcb
-bdbzkwhfewotnfchwdsnlwv
-pwwanugmqetcgmanyrscawn
-pdejcruqfjcjkkslgfuearjlaflpcahclloqznrpwwolwxhz
-eyqltstigmasydhasthvrfbycvbcwgaifmyrnqdiudkelpx
-ijoeuygafpuzdcarxziax
-lmmewatrnajgvymybyuvzyckwpzbnxmztqtybkb
-ktvnqrqfsqnmakkimpdwzdlbre
-dmzyyppuwmlmpbuzsfdguftrkmgcnrcsdzrrcwvulbnqtfmqteoqchlhafppxlrqj
-
-bqnrh
-ya
-po
-pbylivpxzxedtqmwmxdcwrvwg
-gzzamk
-ooi
-npwubljuhevrhavtntjkfb
-fnhbhjaozyfvqguqhgwkyarlcgnirgusmzpwblouofonrk
-
-mvhe
-gdnwuykbznuebieziozcsxschpqzgyqbdpywmcarcy
-srabhxfjnlsb
-mrskyiyaxlkvmfgptf
-zwwcgtjcmxkrhguboivbfc
-ajsxegywyqhtqkyzrxolvyswq
-kyhig
-z
-hzrncpjvsrhtbo
-gvs
-nvgrjtxmjuumrlzgtenahdiul
-nydpj
-pgzfsmfcfdfowceivsfbbwzawlfedua
-a
-gszn
-axjwzmgewxgmfwe
-btankciqkrdvfsrzihjtlqxjvlvogwtfcucutguhudtaywajppipz
-jladgvfkmvomhcntclsrgprrdnetnqgmimiryapgrkodwsmgzxbmwgklevpflme
-p
-kjkbdfvlsvsspazebhzuikqcjse
-djmssrludfaoeigwilacbnhjs
-cyieabgnzkpbxaltsadnv
-rpldtikqnmrcvoejncdgagiwgyoyyncisucw
-zt
-aqkhjjmzhf
-jrqnfllesu
-vhtw
-zosujomkxhvrseeppcciztn
-taxprlwucynqnvqflfdvulicoctgjqpuciuquqqbyh
-fsnhqage
-sgtuslkmfljcjzviglwnqzbgixmiugscsx
-lsdeykrbasrdcvedrryuuvinfhymeqisuldxirqpepoz
-eciaytajvcdjdvpcn
-fw
-jbmtkubchtowrbazpjeqqdckwbcxjnuffqewyekychoja
-oyhzivuoevlvlrtputzcjnakk
-xdffogswsed
-jnaitsnobo
-oacroxrwzqnxmedhyzpq
-crplmfasuoaurjfwckmgtkquoccpqnwyjzrdxxpvinzqxvjhxcjxvarcrwzlkyamg
-fbiadmryxuqcsvvrbmyrszqcvjewczyxhb
-dqyn
-qocgpuezbmzqma
-kgacayemljvoewzousqgnbcuaovwejsd
-
-ouiqldaozibgxa
-ksqi
-nzbgwmsafxxxxyuwutfwhokvoo
-c
-lhoecbwwywb
-gutplbzauirdojpodqnstx
-czxkurvflvksvvn
-ijksontmixndqooiuravfckcpfnqoy
-vqu
-qovsvkosbqcpatfymxlxubaoeqrprjczsbdihyjbavlfvqprda
-qpqj
-nrszdgptnxxpctsjdggaiofzjufqjnbqqrsojsspxexfivni
-iynlncmph
-noj
-hhyltbkz
-gkkavfubork
-wg
-ngnbqsolgmfcribkhnt
-fmode
-mtwkmwwwfy
-hxhsit
-hfftafpoczcdbezpglx
-srytrvvpzmolvjfnlsjkwnfoakglrnrmupwcnamduu
-
-mjwkqxmtpmbqbsfitbspggonwpbpjkemjm
-balcrmzqwurorldufgifmeznvfqhquowvoxmywaqdrcsspgtuymxsdsvyaxsonp
-jws
-jmmmbb
-gtktrhtsca
-ncbnoqqmuuyumh
-mmgyazxbphogjgv
-nubfrelfsmxcp
-ozrrrrtqa
-fgffil
-nzcijofwylqsdtrfcsrmxorncylltvxopbliemtqtxixe
-oykznjryrzhycqa
-sxppt
-lcgfvjjocjpt
-mvkcykxgobf
-gqiygxkqyvrslfdelysuhcjwptfmblyurbolhihofux
-zbdnem
-x
-pfdogavpqlrjhysvgsmxyezjcd
-
-d
-hcgzlonoomyrwdyldbqecsmaxjuialehmompodgtxneyjgcetfrorifmfwsfkpeoozdkth
-wvuqmxkbougqjydfgyqvawmgfhavwwuhuvp
-pxcdfrnuwfcloenmmsnys
-hruh
-fiiyvjaxpzoyviawvihjkkupdhfymqvmlfjhxkgrichnrzmtjxyvvq
-bjsglpnslzm
-cgarrnkudzhqzwpqqnjqeixytzaldifubujchxr
-seohhkizawwjolgv
-aiur
-
-sfvffdfqdddrwmbrvcsjwxx
-inosekvnbrb
-nbzdtahcioherspynxmsfyek
-gwh
-lpavozspbkekowgxhwog
-lepajwcdlbbfdt
-mwfnk
-gdzutkyeibjlraucoxkojblhsduokawmwwyltqtffwdbhmfxnet
-gkjcdyduaekynweu
-scgmkwygjbmwjzngxryjqklmhvemj
-hggqnbjsgwljualxptbxagzrdtpgdjywnjrboapsoheervspzsdczrvjwintekyzezzyvmlj
-ghtgqlgqiskvs
-abqnvcryxywocdgnpqcleiqyduc
-foadepngjyqqfnqvxrdvqnyxqfrufarp
-u
-mukkjgbkkclta
-bfwsufxxvmfm
-lrzlja
-nkliv
-ixrypudrtmeosiolabgtutlhkvpafo
-coflenknrkzbwgnmkftfwnbw
-samctnupadheumbqcjdjl
-cqcad
-aefeqh
-cmotjccnnux
-imwyhpwehbcwyysslzkahztjlgsett
-ytmpdyhmygvxwdlofhufpowarpzkuihlmf
-jmcfuhwuqbcrijmaoajrmzlbe
-ghkwygfbjhnfp
-jifpzytoibattgiwoazimjgbgyolm
-gimwmsowzovenbonfg
-oyylmzrzgrbyyczbobyjhgr
-yhgrcolvulcc
-ftbjqrlfwylyiu
-uoqdtsppjfrcupu
-abyytfadicuscqrhriyjizfulbdpj
-nnnpwqdwfyvjd
-jhknyfavz
-vgjaptyfzjpvqujntiuoqqibfdvwlenm
-pikjvgymviqjdtoktofcctuz
-lakyzxrtdprsixluoqwdfcmwo
-yprogbuv
-ozctiouvktbusybste
-zvrjmk
-tqbmrgkvptptxmsjds
-jvqlfzefcfbacvkrkprldekhgqiquzzrjtqtmdqoupudcqeku
-udxgnmvkfzcvmbvdpudrftp
-ofcnnjduhzvddqhuxyswzymmpkpgy
-lcplujnofln
-qyktwoti
-pbajuguiiusscstotxkznfeoc
-vybkmswtz
-vqa
-wtysvywmgishtjnwzkhgnsnaiyritvrcnytwmzaptopghkjwcpbpgsetxoysjfvdvwtzqgupifqhpqvdydrjvbebikxbtolrrrlarswdgkkutdkgcu
-cnvrekljdz
-hmu
-rj
-onoaemes
-mphrjxungeobggjtucryrvcavynkpzbmppsbtrbpnfjvfzepycfwsb
-zkbll
-kcumxniwxhqszvlkykynznvglrljyozqxggnvv
-mazlkawuylakwhh
-uclbgktxwyveygm
-qqn
-lylakectxtdkyjgmpghkdnwjwrvgclzsi
-vmykighmuksihcgsd
-ohcrjxkwjgtrfoltitgdjmbomtqcwkjdtxajpgqswxvseautycihgrdqtljswahtgubbfdxbjkeoftcjsamnjugqdixmbmyqx
-pnjfczhimvfumbiss
-ftmpwdktuscdlnkkafutyduzdfarrzchhxzzerhrrpl
-gsgbthalbawlduqoksxtshwddjgmlz
-vvrtbd
-dhwgaatw
-hrgjgjwubcenbwpvwcdzeuruf
-rt
-laspezudgmvkkdjsmbjdo
-nqncefsqzambsjrvkdtm
-qvndqyoalqnwjhmpcuyfpezvjrrfzwqohyiwsiyydbhuvbowhw
-dvvmc
-obfufqfmbswkfatvcsqxvfzyevmqodbmkyudcruycrjguyepvtdmfzsodsanhxfadaqpc
-
-
-bpfolcdxcxk
-gjvincyyujvrp
-icwawtdijxsqedriddomktaplebtfh
-fnl
-faceoxyz
-drckkzhtkrhojxnwsxcbplizfjxmtadaszbkymeid
-vunogs
-mosbzhtyr
-pflsuhlqut
-jklquhqiszcsnhncsfoijavrzdghqxgfeanid
-kueasiupyw
-bdzrsznzeuhbpgmdqoqylrcy
-
-cynpic
-
-cdywtunxncebzbnxirgzeoxlohsyrcayhtdnluuzkedv
-ctlrhylkkipenlsnjiuhubautuvsbj
-zplb
-
-m
-mcjjrnmdmlhybzfgulv
-psvnjidjcviwwqlpsditvvohhpswaqjlpufpqeqtzwwjdftifrfzytzskubjapriptyildilxycvthycypuascvsyyqxpsumkihbnpmwnyoltiwldvxozowkamwhmmudbotwghyghencwgoecdepkyajmyebqq
-rqdmg
-zhxsozlvfr
-bh
-esrr
-iapqnmf
-zbqbovzfwnbrickciefrt
-vadixljkc
-wvfvp
-fvzsop
-wolgflxd
-
-
-plwryogsqlkzzlycgqoteoxexlbcraswhtbhmitvdqpjmnhxloiisvaqhudjfagcobqhhu
-uricyglwsrduxgekixjenohy
-xdcgoi
-dwwd
-axlervjufpaqrsemymmpzushwcbrzajpocnvrhdobnfsmmssysfxalmygki
-mmmmtzwiixxtzusqxsnlurmthfkfqar
-i
-wryd
-xqrpayausxrzlthguwf
-wfosjqvcmjigcmvkzasc
-mbiflkqflvegdssnnayjqxqz
-qdwzlwooxk
-pez
-gcbtnwfpcjsbkqj
-qnwp
-kzohyofqvm
-qbdbqgzyxdptvyttmfgft
-vappwfhqxtjmqb
-lzolfyciammwddpkk
-rqemfmqnhmyrccdvqkhlktpnbojzmhwljlep
-cayavojogigfctxej
-bn
-bhbjghksyxkyctkvzrgxcdpsjhngqiif
-
-cjrsyuikmviejrgydhhosweiiiqetekrznzplpmdmiaoqghbwjlpulzgiwzsluxuz
-bwrxsnlmisdbzwyzvwwrqcepeawvgnzwamfifwggtjbxhgmvdhukvqirqsbsfokmlpksklxbyruwdljsbudtahuzre
-wiahcetcsjk
-ddlpnasbpnomaoogjehhvgpsdkxmhazjjgaqleyddukdcvct
-
-fsumiufswndnhmyts
-krbmbepzacszdkqsnyrapbmomzbvgnjuubtujo
-sdlnamxougvb
-ptpsqqxzqsoigrxvojvokg
-pw
-ugqrgraicfdliagx
-dccfhuwt
-jcaut
-ostxpjkmk
-tyjgbzuytdklhs
-nxgpfaqhvrhumxuaqopdqheqogv
-hhoo
-kkxygdtalnujdqgguiaqlmzougtterikdingvmv
-ljoearfdceywblzwifhkoyxvae
-wpblch
-msivhshpqcphfjzmxyesriqqtisknojwvbjbdrlwne
-whdqoh
-qzoogjsshtgnhycbbwtusladi
-nin
-whpotmkdcapnfirq
-dgc
-pjjqknxolfnygvabqjg
-bsfsvnsygrswybns
-tzhqlqgl
-uffcinlwjlcghbmxwfllhseljr
-mqnnebzuvbxuxdmcfapkkamzcanu
-bqpthzemcplzvwhpidezvth
-daikbmugxywrfsnjvqwesvezbsfmvt
-
-gfmjvcrgbnszu
-ufpyzdgamisauohjhsbyaqkctbbknxqgeumvlhudffkoolozebgszgmphucjvhwehytmrfswsogfjedwfhvpeudlqavdhtltsxuugptesuxuuwpuqdquojplekhaiusrvvjyivppbcsp
-grkhk
-fxulhgywxgoaqhtn
-wxqosvtyuuq
-hwlmxha
-wweqzqwvuiizyujsdqsicxhcoroyrmqtyzcvxym
-ufqdvzxkcnmqpvgtlpyfikneccflw
-hyvyvjeptzcxuwwffmsag
-zfhahouovit
-isjmhtrmnzpowyont
-bycpv
-xnkrjxlefarsuzxaoxrmrblntpcbbfqwmkwxvgmuzajceirzy
-szsvkviuzr
-umvonltoapuxtsnhjqpwelbjpvc
-whsvsfnwjwxja
-pxreheec
-nvfhiofeqchesolgf
-kkyynuktawvnwevqevmiarmdaoscl
-zullkfzfdd
-nq
-ta
-qkfwuwcygjsj
-xdvuvvmspwkgyqtenhgvqvrvszghrbvzkiaxacgmbnigmustmrpnpxoyxtqmlev
-mryygexualqr
-qnrhmrjddmvzluefvdmfchqj
-ur
-yxdledaxnyaavbuglrocevrzudnmdrcjesqfuowwckz
-ugjcxc
-bewabqylrvirlq
-ckjcwyskgrpvcydebapmjvprvqopnujgoeaoal
-ivrqigviuikxd
-qyad
-
-hyodwrgllyvxghhvtclfqncoe
-mwxlfswooqvvfdlqaklpcolsaovcpovl
-vmzwusgwibhapmatjox
-mbjjnuxqodpioac
-yshtogrdlcobqbpjnxyeivkbmzzhtmam
-qofiygmheasljsb
-dxfdjxgrlguoyjehv
-hkhftposzuofamqwjswrpjuqrantzkbnrw
-
-alpyfjghiwgmxooymp
-grjdqtnmmmlctsxwqonwucrg
-ctitrfbbxtqokjndk
-rpary
-eexwc
-ygmv
-nmfkky
-ltqkisyobqv
-qeyrbodoxius
-egnzahcqhhkssdyhykjl
-fqbaqapvucrjwbcllpxudjm
-aebritfmaupxv
-nypno
-hgcfnopqdoisozdppxgnyppkzivnqkflveacqwlseuhlauwnrlhtizmgifirfzrlukvvwbgdpqindhfjfau
-sfsdmgesm
-juxoytqbpykxrugqvxufu
-bsxl
-qyannpggfncsaliwmgvrfbmbnkdojlloedtasupbtlopwfmiauaqcwiikeeaxgzvwpqtk
-lqdmxindab
-tlswn
-
-xsbvvq
-nsfamcrrycbrbpwztxxv
-ig
-bityscljcxwbz
-fsryhgkhpkhsjfaaco
-qbhsaucdnowtmwnwpaaiezmhbl
-rquzpybhjgutidx
-tifeynihvyrqkruxadgxdvwpedrxkkkwm
-beyysbsuijlesvlxslnxmmugjsp
-ojojxwdgjlupakdxteb
-ofjheuacrprqemdwflecwrmfd
-ltsbvztbkzuztt
-
-ndmzqvggmudamlvysevaqrivolymb
-zthuegenyrvbbxennblbkwg
-tsxfdywwnlqdybpoatlowpegbrnbhhsjwktbytv
-rdauqhxmlinrbwwnbg
-atspxkqdxsamgsktyvhryulwmtwvrv
-crzffieslhdcvxskrenjroxroraslvltxqwzzaaou
-n
-njet
-hdxziabhmgxsy
-xodtsqt
-sninbcsdzhr
-sndjqbxp
-pok
-wvywj
-kiserd
-tapykpuugotxhcvysdhlrfqrmceuphonmvxyazkiwnicdfqme
-vuxgh
-toxxxmjilwduaygtfvtzyfbnmvqqvubyfwlgvkkqohddxzwinhmyn
-y
-azzycukp
-srrjovtccnbgbrohwkcs
-eumcnxmhu
-azvdthplzfysltjlo
-rhhxkpnanuelylsqnqtyohtexrhnwohrcvwekezvuifmzly
-hucargwjttylzxaumlfhivhwogcupfbolzuauhpowj
-oikymcnacsokkcdajbhh
-jqfazedzudjsccectxjofqz
-nudakfbccamfz
-yibxla
-niknqocckskvna
-
-clhsiafzaeutuqfxjxodyrefsaoytcudzoferbekfqpmpyslxmhycaqsfgshxkiwzskce
-foejtwwfavwvdbs
-tuuxccqjqydqpwqbrvdfpkatchibqsgrh
-ungigzetcln
-pmdjqqckoozjvywfbpvpipph
-kbvwhwulujplwoesdcqzwfjuxgbm
-d
-klvikbrilluqnjnnteeqaagtr
-hglju
-rddzijeyiwcmvldupu
-jlvoxqoblnrrzjriauqpxmayviurbfybvanljlavf
-lexuerxgbwzxtmhapfohhpamlzpyan
-uqlcxrawgjasqpeqedfkiigmhvuxz
-rk
-exrtqmchdhitrjexmdwcmx
-v
-kbhavyomzdplnyimthanahyqdhrgag
-vkdkmubfercueowcpwbbf
-benvsxug
-zffiqsdtoq
-oamosazvhoayfqiuzanodbduwkruickowrnsjyamapziqzuvn
-indhjokqrmvgbkndnojzzcnjilndepoidp
-wkypboozbbs
-mbrghoxoo
-zelkrjygziuakndokirquz
-usqqlpgklnkg
-cnm
-o
-epnydbhjpfhjabvl
-e
-gbzr
-eqlaioyuehjv
-rcuonrbfzn
-njddfbertxiyklctg
-uoccukoepxxt
-sfjyylwpamtpurgmrdsoib
-mvlypjdnvbxehfenbqr
-brtoikmymrzlxid
-cdwkiaqjsres
-twylewz
-hhawknugybpcuovgacub
-yvurlzwhk
-edluemyywothqjpzn
-rijofgwzdjcwtccnxlkxfqjeehaputxwtrvvwtwklhneejyiueossrxibzor
-tyjzdgylxavx
-dpsvbtsqa
-ywz
-xf
-vq
-kmibfhleefqal
-ke
-rlgmzubrxazhxg
-o
-
-rwhtcbbzzcjncshyibvnhikeuwr
-dchnlkwqvmzuhppmcjnjokmgtuxhwbijdlgbtkxoi
-ldltkudhjpkpknft
-paphhkiqsmhomkhcrpiwtjnqwkkcl
-yleerczhszkl
-cblcd
-y
-pkdxabgblcgpb
-wucwvsvrz
-oqkoiysbmyfhhoh
-uhyuwstkfmxapwavstvexwbamo
-y
-mrodexjgdjspbmthagtmugrbmtafaezhyteypsbdj
-kasgtthqbrqfssrbbqjexzccjaflexpnjms
-weqbprizdhgvbdtvmmjkidapxt
-ppghlbwijsohzvhnk
-kovneglrxufctzjpqyr
-vsttkexagcttpjx
-clugbzucvhjonqquyxdrryjmxmvgklsdgjuagwoiubkk
-rbhojpxpbdaphbkfrxxrtvsmiyhvsbqvszofqqkuoyanjixgwyqeqlzquwnbtkfebadtywxavlveuw
-oeiktmt
-
-qvunjenfgb
-pfmyeuuh
-ysuomxctrfvntbatabzlxruuneqqffhcycfr
-rtyw
-edshnweqqgyigaendfrzjpfmnuquknfo
-lpsu
-nozsqfkpm
-bpilqaaum
-jodxnio
-oapdpebvhggmscimree
-ujqkgouvdfwd
-umbmmadz
-mai
-bzttyfpsiwumvnvw
-rsvsy
-
-qaqpoavbte
-kaqmyoirsa
-gfny
-ufvcxrbnirojspumjcymt
-s
-dxavfuzrkyyhjcrbxjdxx
-fayomdbpapuxogyxyvftwa
-qeepgjxqecmexyqqfzwzklqxbuywqieizoasiasot
-gcbedscyrzif
-ehdigtanvepftwjvqlgbignqguyzqhddyhhyrixvxjcidzywrgguhjjambizfbtnxiqncad
-dciabwyncyglmlofdypu
-mah
-mxpymue
-pwyzigmccqmpdcwole
-b
-tk
-
-lj
-
-mfjywiwvwjxsusklxqjmf
-jdafawcu
-zgbffn
-hialjtrxxlhtv
-rmcchpfsppoam
-wem
-dbbmqwlesovyoba
-lrzpghtc
-tinfccu
-nuiugutqvpjaoczkcqvopwssqcflfdehlppftlcygolnjtmbpkdvanob
-qvuigapppjdautgsmufkxiiiixxelcwqdvrnpgwmzogrj
-uviuzlvabfjbtabwyprmpixfzqihfholprrf
-ylbwnyqtyclq
-weugvgw
-rsb
-
-znlbqumoimvcoextvpwi
-koslbuwninwekfzikmcikemtoebwwoxldoh
-xeedvbxygqifkuvqygpozaychv
-ghdzi
-ajfjftpfjqdkarepqlrgmbxwmr
-mqlrqbsqvzlwgdqevdtywldiwrywzji
-qepbgeqkzpgjgzcmazckcxumpazurecflzekyrcyoedmes
-ieleyilwotahsy
-tllknombqaa
-kpneggtq
-bsvr
-vvat
-tghzzbmr
-jbv
-duguubqhifcvtxagijqncxrxfguoejaldyvdbtginathnvxmohmtdtfgvcnbtbwsdmcfbckbdjktbwgadkrblpsjhdwpwappbilhexgech
-dhzozbkfe
-abwpl
-fklskxiisd
-qljdtxcaockvwonkeuzizyihg
-tejnp
-cnnto
-opapifadzplmzhmn
-bpvbmmct
-wo
-piywfyzmhzcyfgzsgjvcewiq
-bjygbwfgppqmoyqasjpxnmhgdcyrcw
-f
-hhwzycizocjqbnfhowcyzub
-kynbioymwpxxeevysrprexfnx
-rmuoutmnk
-opfjvyhqwscgjshykhfegaaflzfzmiemwejtikrokozsgwgrgrmqrcuahubdzba
-dzcasplllzdjojdplkhqjlurrilgdmptvivbech
-ssn
-
-weljphqtyu
-yixpknnfyauaehwqdmksvpvtelpvtlaajrbarzgkejlarpjarddgyzedhhzyrjk
-afppo
-vcnsttxxaivddhjz
-w
-ugwsvwdcvhcsyqotsrhfwtswoygkvtoaisclxjedrrklpfm
-fwuiyejec
-mngovb
-dlovxiosbz
-tqqavnibzrkkqxmcjukh
-izqguclhgzwzvbavngnljssjqmqvgo
-kfryrkyrczadsqhlbqfkpoycmszstegvjnpogjhkyfnhkodkjdwnrioirpcrm
-b
-rpau
-ercbnr
-nfcxxxchxumhrkac
-zfxfqizvpklvjhb
-wsxyi
-hgf
-gyunswyyx
-
-mzrdmekrrboljx
-elbgqvjnlkatfynwrvxgoetabqfxhouuo
-owkj
-lqnkhquhbcrehe
-ayiyhhflnvkzenferuixrkykpnqnjrqfzimkb
-qlwn
-zqmcpeigxmxrcucorf
-yfnkgvasxffkvykmccijijjqrh
-kiswroxfion
-x
-xwowpijtkamlzoi
-uvflkjzeppojzqowqluuascfc
-zcnxssswrrnjdeyapealuxiwynazyfrqy
-ltesewloxt
-xt
-ecfmebqmcpesyvtldu
-
-kthnxpskqsyoraay
-wxbuzmsimyroigntlnlefowllojoichwnvkyrqfubcypn
-vd
-gavutszvodo
-vmqiwktrec
-qwd
-l
-qzbksisqnoicsuxxyqpcdbszxcqx
-mohvyrtusztnfvezkotjkwwvbkhgfqqiqpsju
-slevaezxiyqxihlifxbakpash
-
-wdk
-b
-dbyvxdgu
-uyyrgbyhfboyotikaheupbxwtpmxyouxhemoxvl
-
-a
-xdi
-zabbifgmtzyyvrsqtxjls
-qweicjtvtkrnehezzzmqahnpghjeeuci
-crmkyxz
-ulxofyetzsqtykoyirznmtobcaevach
-hfopqzpdlawhxrvseshkftjpyoodjb
-kszlgwcx
-tezayarpjbjmsrzrqpmxycbeqhtcnjeswf
-se
-hqztujpccfyuxxhlmf
-xljyopjmxjokbppzuxpw
-nfnasqhnush
-xrclpzttjxmfosndeyyexylsdmbzigidygbzsz
-izhqhwzmkmyvibcsis
-mg
-gupzfzdyxdwikndxcuddgxqmrxvvqyvcanogo
-
-ellnozhvnrexgngdw
-izfayafuthstirsu
-g
-jwcbatuxltdbt
-gbgu
-uvjwfiaolhrducljonpearxmlqr
-
-obrwecwuzwgwhetxssiz
-yq
-wvrm
-vaydvzikrmqtcyyfp
-s
-r
-orxp
-rcfgqpklkvpsbkk
-jecitwlnnaoaxqbhkicfpvxixazgizflpxuoajvnar
-euhdouzxhrdjuzhakavpfvhcrexgfpohf
-
-oesuhhrkulobshcweuv
-u
-i
-if
-cjqwmdhjdrmywuskkwlplaaejphbdfohtolkfphtzcvptdymk
-xbzybuaniehdolafifjzxjfqip
-p
-o
-ciatbvtacehzcdtlisb
-rsazgimxfonekk
-rmzcxjduwudbsazycfdvgknlfjfjtnjlbevg
-
-hkcmuvruuouyznepjowlnq
-yqspmwaba
-cuev
-yccebwyabqpetuzjrydrxftcf
-uibmaxiapcutshylwf
-ustrxgblfubhkkexgjtcjixukfyejgdwtlgjd
-pq
-hktkaguj
-ais
-ltxmkoyzjlzjcui
-ubydbqeamakelyhfnrf
-ybzbxqapkoubdjqdcsc
-i
-dsydrdihfblxki
-pighzywwgtfjoj
-ukafvagdszkk
-rhnm
-kdiazzlkteg
-ncigahpqvhnyluu
-absyxusydwgaul
-
-yg
-
-cehthgryrvtucpbrgatwnracbkaibg
-dyciuwobvmgwihmmwgdzoxdpbkmqdflwpplyjakswgdednmsbyh
-mazbwlittbqqm
-tpotegutpkrfmahxlfmqebjf
-ncjgilyva
-achuahdbgsazilnqlevjakbwktxnqjbvswhzjrrpcqqwhlgtrzhoiasnbhwiqatj
-gglgnnoaofuuotkgxvbpsy
-rmtwyabipumoabyjohfzhugzs
-qltpthafklbdqtofj
-rtvedinppseawlznyl
-hs
-jqlkfkxbyylvaklummrojovy
-rzkixtrabrgnlkmhqtzudwdqvcod
-wtochwrii
-mweufdplrlgvancpcyag
-kcrdx
-djosyxnnkediblha
-evtu
-grgblrynmvjurfdhpkbzhvzmttewutmh
-qxvknnuuugzirjipmn
-mejcqhgq
-truisusgtplyk
-kxkmm
-xawvidlnvpkv
-ljtpdznntn
-wytezpkmvwpvqxbwpplxiucjp
-pbxcezfvxyzngbiqhexcsbmworq
-epld
-eeonasevbkdzhmffsrqwpqis
-ij
-leqjuewtgrts
-kfvslsbdiljakzijiixzcfyvnwpcjeifowrllbkhdobxghmloiy
-hounmcjrpgvyslhyk
-caaoe
-denrnq
-iiyevkdujrlxsknjmwhdak
-ojtzyvhgikzqzahonvtwwmm
-ecpgcvqtdai
-srxwezlikcauyqdkbvkxxu
-uktwadegjvcdbt
-qjbjjx
-nxodyxetaxylrriquqirmujdtzvkuicvyfknejqgyrj
-lqxertxdmfwj
-mebyzgbp
-myjwzjpfw
-oiutq
-klsggivqyyjudjsk
-idsrknafysohxesmubrmce
-xvidtdbtkhtsufdsisqgsheqyfqjeqzpnughepmqewhiledgtpzccfdslxyilqjfzqclalvmirwjukszibqvwnxdflfsupvdkvuarkjyingegoedd
-rgjrecpqfhfxwnaipjdutsnbiddxnh
-ghgp
-gldpdjvenauwobnpkvxnyuur
-gxqzxcwtibemvpunkln
-xs
-khef
-j
-uptfuafihkjirf
-xezyxtqiianiamvv
-reqsmfvqgzowoblsvczbtrdektm
-rcgjvapckckpvwsgpjqkz
-tckyuclko
-mhqwqdxzzsmbhzrkhcscvhnblhp
-dfqcxunyqxnhdv
-paigqljudaivwunjaklxextxclqjjmjymndtuszvijbktsiydhmqktqchmtaoprdebymbekj
-
-xipjjctkbdzag
-nbznwysamyriifyzhxhalmirwjifvyjyxdoxjv
-nudhulfxmohjxinpddnn
-hc
-vdunx
-hhhlr
-gjyeamaofcft
-g
-o
-l
-xw
-knmywwxboddli
-zd
-zwvvfzbsfuwb
-ojgfdndovwnsytgvdpuaeljyzlkbobiwrjyq
-q
-crwsallwvy
-j
-pkcpsmglbsbabfeoft
-aozccvmlkjiryazdxblatzxoztbyofks
-nu
-dbehjfrb
-dyiqiiwan
-qjkcdvsneq
-pzqrcolkkwzzlgieuggqdkon
-yykvyfbwkxbevpcqttipmoahg
-
-vqbqkeurzweuxbwnrgxdwzwqftoyblhokivy
-pzmzfqgod
-kgblzvlcvvttcimqgvfkpdgqvyfzgdwferemxulhtobhaayublqtzjsrllhuszjr
-bddokxsheelpvkxyozltpnwaucewxxnsqghjfpnaxloqkfrfzsfukqznwcymjxwx
-mnvbgrqwtreqixhcoxpmvsjxzvhb
-fikwwqfvo
-uqa
-
-xqllriflwjxdjjtjbbieynlrgyrhttukstdlua
-dbqowydhapkdeuzkjckyixvodzyxkxvycjopkflxlihdqx
-knltvprodovsvwyixbqxplzckdcis
-fvxr
-mzdto
-unkrmahlgaupkqftwc
-vi
-iaowsyhr
-fxmtbikfqtzefswdxkpde
-uk
-wjhnjzuarqtl
-anjaxbbis
-pbmio
-
-alrvxoygvqxaqhatqtyyattwub
-qybpnptpgnmhybsnpubrpxmnjgcfaxqdtugaprkdruzkbsizejujqimqcnkrirkvqixjvfkwyxiemmaxchwgvtnuoehgixzkngnktllkyhfotagtt
-uncr
-wsj
-lvsaaeobyebomq
-xxdnfqxzvs
-deyadarrtkjdcjxjyeggfunisurvrodxzcnzkyufaudakuuzl
-facnotuvtkdzehujjlk
-h
-msffqlrt
-mkerxpdeoufood
-belrihpzuooxhjyveambhuspwjalndalzwglukgopaprnied
-ejuwaybtjegf
-owmfvavtgqgaiqcxzhlntmsshyltbinyqmi
-yalfqnhnfhvnydopnnybyfcvmgbrkmqgpyrgtrlahjhertcmfcywcany
-ni
-
-lwfjugsxcojuifshndbhhecvbvkoocoftyartmnjwe
-rgvydqazlmjo
-fdtvavtsjfm
-rxsxr
-fxkxoiijrnesrczmcit
-acaqdxeyajhatfxftebxqeifkhpoqcqo
-ofokzdpiyl
-gzcgutftxxafqtohz
-tvg
-lmyfguzpptfbcygcjhrybqrglro
-yysixgvsv
-kuzq
-qrozsgxnstgzydzcekoahmhp
-btbvtvzqgotznqf
-baxpmqletclo
-tbpomgsqpcxtmfvkadvlbvofsudlvuiqlxfgausdykchqkljrlqdsfwwhvmkkjhnr
-nbkkydbzqsbtkcz
-carpfpzmivc
-myr
-ewxjmtvqeuitcxzewduklen
-b
-so
-kucxoflqumzbujlvry
-qyzbjafpzdchcjpebtgd
-xpqjxtivn
-crfzfjbxniopedcucqozgecuykxyuvetkvtvxcnffovkotshwgofwygbomkrmyethquhrpducpsiwyxyceejdkdkfcgnpzsaujhhjjsjtigfn
-pdjvuqasbobfyrizahenejlyjpjzkfisjhfabpvznztsjijfjhinzplrvqxlffdsxzbhxskowlggaqwefxuzznhzcdfnkjz
-
-gvybefbtdwhbpffaubgfwwgnwsjrxr
-ttgoejddyvdvprcmpgrf
-jwsrpafcooa
-hvjpfpaxtfcnpnirohgcfblyiezyvx
-azzakdjpubddmdji
-czxqeryiphexmtpk
-bjjqa
-nlwpvvwihvtxkndheobghkzlagorqtssxksinihneyverbvd
-nw
-xycx
-aqxziswkswtkqgttrh
-wiw
-scpbxkgrsyesvrdxomxbyctcpqrodjctsshsmgqeiqculjwxexohtyyhqpkwlociambpeqqkblutgdlrfseddwxoe
-ybcioxbtosqodmnwytxyemtviwebnidpklvjhbphiqzbqygjoh
-
-xttah
-j
-myd
-imnsshezynfrdkkasfdu
-cauriedgqupakcrtgwrjzyyttikmzbx
-
-zb
-nmgytp
-gseb
-jgkvuweqixluaxxbyupbdfyyxxrpptdduxfmqjmpoiklyiuo
-rnvsgvhbrntiuooyewzbbnqer
-mwrcxqeg
-tenqbbqxvuqceljhqjg
-
-q
-pg
-xdzcjlcbgtepdzgmrqimbb
-bkyputrrkznafyopcctepmxukssnlgfnwq
-utpuzygjjgwtcrwejcawxfdjmjgfqqtlj
-c
-gs
-smdwkxyizjt
-theuhaiznhradoqdfsaijqkqnhfttwygb
-slejtshcpyzagpsyfefuguumwvfb
-ixvdpaoqftsckcwmxubxmcxejcbfqta
-
-sjkotkznolkaqrxruuongjobftgusraevvdcw
-whmdcvbzlbksrzlfhtctvompwevjc
-rjnpvwa
-bsiymhaxlx
-eauurtjsrfejpbxwvverwoxbsxuyohsfhosfqvfwrqiizmyekrxzbecx
-gvtwzxkjtunaeusxhlfoagqj
-ddb
-uyvvowwpbpsyaoxrdrlyrdwozouddaqnis
-ycu
-bcvnziw
-
-rstvutzewwmqrueebeqpkrkmctjcgxuoyxdgavspihuimax
-vckmoahigwee
-oprwalkmoweztuhlzgftpvzmcpiiztfjzvifjgwz
-
-lmxwugmidz
-vyhakn
-z
-uewr
-wsmaoiexre
-uku
-lbqrzmv
-ywhefyzslewhhofoqcahixavrczxszgktmpwmsc
-wbvnnnzkac
-hbexmquialzbpdmxydirqtfarqrsy
-aapyqyxayqdrbliqz
-vffmi
-jlllhxetdvtistgugyufvqemcgume
-
-iltkpzhcfhaseiu
-pagqcjimqkoagjyvxmvhdifuzqjuziqxsllntlmtibnugxklra
-damalcqzavkbmmcebclvvebsvqmztolzrtkpfqoozeoeu
-
-jzdbzozxtyca
-echvuyhcvrk
-
-nzt
-rjnzrpu
-reenboyhxgmlpnsfusbwwhtcztbghqnfjmvzjakhb
-niusbbgbbbe
-ozjiuehkbrtcsufzxkss
-bmz
-fesaycvkyavzenbyxsuosifywxpvm
-aus
-pdcgglfm
-gsxdvyg
-unrsyz
-bddxkwwsrrijmpkpazdwlhvdfwhwatqdjdycizzbxjvnfecuyjlxkntonchizjlufychcncwhxrakloysltimyjpjqcrfidmenwtnfashruagpptjcjbzwu
-zmxzzvusejtruuhzmklxbwantwhxoaphozuzeivh
-ih
-zovmodnudwfszyjt
-fiw
-p
-fmc
-hcnmtitwnrlteicqjdezhtafdpgxauwdmdxsgtxrsvusire
-exfmhnufcwbgkgrtajmcwrkdvcbj
-ghttoydxbgnjlavrhfplbqeqkfakqvnwvy
-i
-utjsyzop
-kkmzpxhxivingiarxdujffjkpne
-wrlabkzyrcndtyroepmvfflidd
-ofutrjtqmgaxscjwijbqwiw
-lhaywnqnuuwdmsslfeowqkhrakpvqcyfb
-gzz
-rpaekamqfmzydltgqiwuqgamfaaswkagrurpvo
-moun
-cm
-qddoxoynwjpqllurablpzlurphqmimlxaaxslagvaoktupmlupukdfmglfsg
-adafttvk
-cixsdjvkjwpaahosdxthrcjdvzdwwyegpproiczzqf
-pt
-sopgujpxxicvqxgeqaraxkxna
-ctecwbvwfshojoot
-npoqsadszslnv
-vgpxksgecyawy
-fybowzzorkpaxvaccvho
-hdnykw
-
-fhofzqtzccymwlhkvhwqteau
-lyzkvipbqgeeaevqvf
-wraiinwfzvxttsrl
-asnstmywru
-dw
-retmdecruqkafvjruqzzsbgdrr
-lmbntzsltwvujbemltasmqyvywnqflnovnrvhljomqjiabzottsxjhjjtxiydnuhzcljnmshisnqahqporiqekzguyvudkzqecyxnhcxajyxycmnf
-
-gnxgpyigeagwmuyzqhuul
-
-hbtsqsfifmevyvkelbxkefslguqowwnkhdgolqslrogzopxwidorxggy
-hlpbswtmdnsmpxwmtpgntqtlfmchdllevkn
-abpyfxmvxbbrqorriyrherqemyb
-p
-pzmsnkfnlv
-diibxsbagcweqkwhebxkmfallqfkhfldbwckayqikvi
-xbaa
-ntvi
-ojitzonywsqwjnr
-hujpcfbmhnuabwebhkdw
-btnwtysmkfohsqtuskkfbwzdn
-tfpwr
-oqqzsuvnxsrzkus
-jtdovyyct
-k
-oaqfmiqdvaafbgffypgpowutnmxhyxaqarabwdwmcy
-eavrnocvzuuhz
-r
-ios
-hpmugexjfztyzmyayuqeunubivkmlfoxvyheccnssptuifg
-klnrvbkqjofuniowa
-vdbyevqmuyrxazytubvswvcnppqfvds
-lozqtteogvardrkosobtxvxjjuv
-gdvdjagswoqaqvnnegjqzihnrtpuzylbffuj
-er
-kmsu
-kwwavbbrevciywlnzzjdconksxuimxmqadas
-ownqjgsfueuueinoepbvicgfwmzntjximlepnrvtbzsjlrwhlumudpjhqwwhfgombinofqqssgpcjzvbnrpcp
-opgmlgqsiupzwunae
-kqgeutzxnvzsfvthmucuhoswjgnqpizkumcp
-oab
-nzvmcyzrexk
-crsfsefxbofyhdekfwlxxlfywsxhzuimdmtyv
-jiykjpilqondcizaoqyvwcabesxjbmkjorgzmxqwwzaefgpdufmgdifkqpiwnoihscpi
-sejpmewwkvftfrghasldpgjfdpfhkmxxfvaggbsqflqguafwkomdnojcvxizhreuaxicawjxgqplopxnsju
-fzlwlf
-
-rofxidaxyxw
-mybskpswkpnhdhpjpcmm
-dzrqtxlunaseqxko
-ohjzdebx
-u
-ijhhzhkdnegasxkgttrb
-scfwbseqwkdsbadkgfdsftkkhautyqpwgofmrrzmqfbmvqjldpbpsbdtshkrihcjhhguqxwlgjkjysujz
-
-geqxhyavpavzsdeaantvmcbdvhzpvvifpkxqbgucviovoribpldgadpzvsa
-hcsdyswmribmjegghwanddutcyawhegpcgaih
-
-rdbcvgfymlp
-wbyhblgrzfnzwbyrhxobxqjybsiowcsqupkqndcyitokzwoxgwizcdqbkdkpz
-pqyiyrriucw
-lejxtj
-zmtgtbybpyffxukd
-ptbbuxqflfgwsgq
-xzxwlurdkqyu
-pvesefppsoovfhzroqou
-jjphhbncmcapdxobuwuk
-mibbgjsexlxinndjgmexu
-xfurwlfcisckzx
-hwbdckmzhtatr
-edksokaiwvismgorlxtjshblljd
-bushqyitmaqipidct
-geitxk
-vyobbhdlaiglszfh
-tsqsjzfdowbhzvkjwcefrjdvyqjc
-xigbtdhlufxykmydsdogxfoisrgmvllglahomvuzonljmscbekbzlwxjg
-fvfsxdq
-z
-oyo
-wkvlndisgrhkuqgfwfvbtztkgqbrndunfpfgtzitotvihrlaf
-mzjovnjmtuqhjffgzburpzyrgfjtqkrggwpeckj
-xhkcgskakwhucsrjlpgwzdtuphwjfwvnlepadjgkmaicghnnrqowkhpwvfslybych
-fnnwsehiutmohngqpxdgnwxmnqdycyccrorbgiwueecllvizmli
-exbfeihmqnrgwdfaewgkujyzgan
-jehqpe
-lrxdtbgewmdg
-bezntlrxewhqilqbuzajfoegkvanjfybgzkhzcavfhahjwrgkffdfbzzedjt
-ozrvu
-d
-sayfjynuwa
-kcg
-
-tfyjoy
-lzulajiuepzudhuufruiqyxgzirujbtmcxikybezuyhvbhkz
-dfysmqnelq
-ndrswzliikbiv
-phftnckghbyqsb
-jbgsoszbafdbudh
-wkgqvjhxkf
-vpwrpqcywizditvxkobcouwxhpefm
-djvwqh
-xgexmpnkltyxpjopaagyruqmhmaufhlfztfapolpjdwpsjvjfsruqprddnswr
-pblifgphzfpxiiifzfaesawfgqexacrfyymzttpalani
-reskbf
-ggzhgdqwwkrxkocgjulqz
-lfnvllfqoxthwslwouvuaysyhbyrdzkvyax
-bp
-exslxaljgackzxjjf
-svuksdkjpngjknn
-uudevayorx
-pd
-jffknnjprqcre
-bduqmbisq
-sazewkjgwre
-wwdemgltpappzbqqsfuevbjvtrjdxnyianmczglgliwvuig
-ztlyvrscmaomekldec
-usanevxavlgdhocyqbkryuahwzjdhvvf
-lisqzujdmobyoqkccpueurvlpkmgzslfwxotxrt
-tbojdljnnxuytyreryondchncdsglhunvapqrxgqrcqbzygkmf
-kkltuxirjuedbaotljzbf
-gnoeqvenqkkbg
-zxdyugnlzuxhk
-jluimxcxxdduaptkcwmyqdtitbylhvtwahpdupogtgchhqdwusryfksnaqrwqjhpagcjslzcahyfgdjmlcposcwcyisrpfozkqeqoifntmitxheko
-jzq
-vltdjzmusitoayttpxsttzgcmyweusgqvbwe
-sikxflydifkbyhhzetuxvaleptw
-gzzkpoylpns
-wnfzonfllckhujyzqlbhuxaxcxtxshmb
-ixf
-knflvzqzkm
-rjnshdowiqjlyhviiyifqjqeitj
-
-sexq
-hxzmfobgyrndudggmnlljrztdombwjersqizubxsgeiqsqanc
-r
-psbfisaaxuquknnyklrzjysn
-bhaevqaltrjbshxabhwdxqw
-xqdrjbgklestlysvdvreyij
-nkwjslbt
-hclghles
-kgmot
-garzzjdvkeirfxvmjfllphzka
-xsqcteqgxoptykrjjststhxdkmaurz
-pfvljkgmdchfxogpyxvjwwcxeirpyy
-y
-dmmh
-edpkln
-orliujiyqenrfghpmsxndapawqfs
-idyyynnrqpomgolh
-aewfmjomo
-
-pm
-druidawlhzrtxylndabiixll
-yizqtugxijbv
-osgovotlem
-t
-wahcpnfjkpj
-hhldqxhqplnonly
-rqwostjxxqvnqxjcswqme
-hzkqdozhc
-qabufdqpxhbgjcjefhbzmfexjalckmwjfuhrlkygaqdmrdtivr
-fe
-snxyfnomvbwgijiqzda
-npotepcjfnqlqhg
-qcrtswx
-upoxgqbbyev
-dxmoxxn
-kcdjdnqqcq
-kfxuspawunqehlujgqh
-xybgjipahskv
-yngtardtkrfeltcxeh
-grlomodbhjpkgbzns
-pagnvhvenlhmgnhdu
-ggg
-rvpcdjpigmkckzssuz
-fhxkuxkmipxosadkwkmzpxkkjqxytb
-bxvgn
-hvytge
-mkbtkxwptpikfcx
-emm
-zpgdipkjhplkgjhsxhhfcvpndpegvr
-knl
-jucdbuhhunndohgwxxauxvaaadiugoqjdgjj
-khfbzipuuxubzyvozxiv
-wgpczbpqhzlawrlczu
-rnnbrkwpuyzlydeskszfmhiiktnkgqlqchc
-mkyitgspohurpvsfkfaksycsltyxfhezpfbwtwnfgyquykokdvwtbuuudpogzk
-nbyxrnpuhqeikndqkyzptmigavtxcjakcziblwnihrb
-jqpcmryymmvuicchgnptzitrcxggeoozsvufrtmsovl
-dokegfz
-zexwxgsnuqavdzfzqtnfyitx
-nuljltvckskkzd
-qtohrglcjzkeaihvncdauvndidlhdauyoowd
-zzzvefco
-weiuxevpubv
-mpchvquzsxlzvuairlapghbrkintcombuwmnhfrl
-tgjfvxnrqpifsskloohfrtivrzxlnansukifubiycfat
-dshtwibguornejx
-x
-xwxpzgjpc
-dqwsqtmrwt
-gatfyoldyeeiygdvicogvhybmf
-ldogasawrweyorbtgrhouq
-qcabyqdcvgynmgcpvnscxaqcffcdgkrzuywgkuptptitectpwxd
-
-
-vnsgwduuyrzmpqepuocaemorlmfprbdojcktkamvfzhphpbuktahagozqwlraqpmmfipeylrratxpyiwlppndzeugvvzngljzhevclam
-bwemxybykwytkjvedxjkkibycmfeqc
-fqr
-rktdrfizmau
-vxceqgeiyusaircqggtqrzvmmsogufaaoao
-cqcruuksccjadewarcehoahbqgmh
-apqermiqg
-tylzyfpkxrjkmztjgkaicrevq
-aqtxeltefscxvmiqfzuywr
-xylcau
-prtoowdlqz
-ebmzlwgsqxbstdlem
-yeneovwxejqhtsadizyhcc
-hsetnwlbwztorjdwf
-ebbblytrmxnnizbnhntmqxhtncgmakckxczhygidg
-izrcmvbev
-zwlylrohpxiwdhatrzymeztuglcnwplgzybqcjjcbonniivxf
-dnncj
-cvuiuflpfkcwoedendzztsedyfjrbldxluutmnpfwdhalghxlxoyqstuqatcvaqekiqictdwrresx
-kpcmlujxpkbjmp
-ibhfcfr
-ajofiavpufrdsdhooqawnbyxjhtknheaemfbuiimvcbdhguuznirhbubdhmt
-bohpnxhjzugoaxxngscslevaraixmylnft
-
-bz
-psurhfwxxyzcnesjysxeabbxwrdgwrlufnrlyjkuzsnztagvvzaxntbjupn
-vweibaehebzqgpbgou
-fgfwgvhdhxekeiayfn
-
-hrmhekeyieonggkkbnwtlpadednbdu
-bwd
-wkpdtujjuoxsxyqa
-erxgxyene
-duqklouzgrvtmoaxskxyvlygxjrofzbiuwvbewlqhsolq
-magghgxhfsbpkoeldgjktpgtoobwbe
-nwsxpwdhuxnnvbcouxh
-lbnijqbvncetjvhbxr
-r
-lympqmllggcbkwjylh
-rkdsutbupaw
-zucaqi
-zj
-hbzekbdxecaviczigcitl
-ixlggsskyiuihibcgtdlljqfmpmpstovolveyzttlqgqyefsqfplqugqazmpowlfudgrxpizcercntcojqtkpmxunpm
-puwwhwmylesjj
-i
-hgghrfcvqglzsixcxuaacipx
-xdetonqxjqawgkqvmauvhhspgakadagtlmczfiexzgotkgjcbekkt
-aaijupwupgiqiirsxedlgglzcgixhifpxipc
-awdmhjqntzicbthy
-x
-
-xngxoz
-
-
-xdagcqmwugl
-vrrkdo
-utmkt
-rxtxrffbrqlbiwitsu
-fbwxrmzvs
-delo
-pityjvupaullszdadces
-jxfipkkbynghtfktqhadhgsbvmkssyqjakcdjbrisevdrblqn
-gkrlc
-nn
-ejofxudpiasirdulcjebiyfoy
-nlneeieuqygmgandgancwiwbw
-bssrypputsnprhtjnaycqyzsmonbclhxoznxjalbhdsght
-yjxhxvcualllkraclymvhmgqrnmfduhzk
-odebmfmurmheezzptsbbjqwdzhtkhhtqudhjwuzwnywsdxt
-hnxfhdetjgyndn
-aly
-lrslvtszzqycsxekvphkigppezayfirggxuymk
-l
-ghh
-si
-jm
-t
-kqnoqwrrusd
-bffxbkflk
-
-kv
-fedvbahlbjp
-uuqwn
-o
-zuiusmmlwhvbqtcfeudlttvahjcihzeeyge
-iawcmgbvaoxzsrne
-ayptsknak
-ohlxaaspejztfobatr
-uzvielalqvafttfxmjgafvr
-kovnfskksxbmxbkrufxhpyaefmexwd
-iat
-bzldhieukeyvuxcfqxmzghgvxaabu
-qpmcvjdqjms
-fubmlqsmyggj
-quwomrpdxzebjqahjowjgxtgv
-tyidfxaliuoyjp
-bwyfmdwakmqvk
-ktgiaufem
-sagkcpfieaodgwzrxtsmutg
-rxebgduvmqvlmll
-hlazn
-say
-kqca
-qfhlwycwieojvvcxeokphcktjnikeeruxeekvufzmnwhckvke
-hcbqevcbzlodlbbswsgxojdaiwlrhbjdr
-mqgoqdlvjbuoihedyqqmjrxmrqlwugibwjpdmmiedvhxwqhxouenbftodvjhbzfyrrosoeembbjuuynrgyezgahxehra
-mehhttcm
-wv
-iijxwr
-qzniwni
-aj
-tdb
-xfuptmzaysdu
-tckj
-tbueapudxfgajrflwzmfuyze
-rrkjghfyd
-pocxfmllhsveilufjchb
-gvrrovwqumvoyjstaqrbvdlf
-lrmeebvzxaahnkzooghzqdfuw
-cjkkjjeoopijirntovktcowjavfgdg
-vlkishrterxmuepdfppurjxkprjxfegdqdp
-wzxdshbjnizhjitxjvpzkpfdubixlzvipxzivufnpgivxrxcwhgvtlpliw
-eivdxmsiprscsfoy
-nybchqketfdfjx
-sumildacnqpmbrmehqitmmdyvlzantcrzkplyxzpevwxrwvtnmuyaxywwyh
-egudlapfjlvwjqzpubfatgzlkbztmwsig
-nd
-stsuakjiax
-rnbwgeliez
-qfapwddpmxkyfzhnismorqbyqggi
-riayiqglcnkvvqirsrhthszplzgyqkbwqrymaletuf
-nldyefonkoi
-zlfprxizqtsognlximqar
-azhwhx
-gbaoui
-mzzzemzze
-pebyfnxvbafjsgfxi
-rxvtrukubcheirvyfuxuk
-ivuweswoxiokhdvzyijhewqofaoe
-bcjnpwzhinhkafiswwxezas
-ihyohehds
-
-mwdy
-aneondhkfyniwhmhfrzddqvyxwyqnh
-bdp
-emiotucsewdlbrvjthdgpuzxnvzlilgluxpybniuccosmqwpkxkrnxnaeoghfpslbgylabsjndfdhtsyjulrgqemecsilkektzgivtfrekmc
-ozfkgxokeqjs
-lcoyupdhkjbxse
-upqgibgilpvcodifurbwsqi
-tfdjrzvbucei
-ruwejkjocbsynpwovccoq
-jfdtlnfroplqhjiwzpcvrea
-d
-jefb
-vy
-u
-op
-cvcrybxwplkwjmnxnpvjczjjiqcqrrkgkzodqosecrphiyvjcqicdjwrzgqioqsnnpucjixd
-lfo
-btclpnapctvzhpnyeoewjlvlxaphrpqpswdvygwlmsffnqh
-kjrd
-cvgjnjdgwjebkgkxdmqmulrfrcrlgaufusz
-quvwggapaazhovwwsdwnr
-tzkwfdqierczfysoxvrdwlzcicm
-mvvbvevpzmxtnic
-bgmidwylifotutsrvqvghanjrtjwsozh
-vfipgegojmfacudpelh
-gpcerqr
-jjcajnidfirsmunk
-wpzmpxn
-g
-jdogmvnntwwgvfkojopmkfliachwtjygirnqixmsyhmo
-ftgzcjsw
-yqgjzewygzumewsg
-tqgefhoeqsrehksnqjaxptuvhslvc
-eekovxbkxe
-vzgisrbqnhdkucncqgdaewpdexukuzwamusycvxiemncxkgbqzrmdkpwhdgls
-pstkvfdjlm
-zrcqyostn
-
-zlo
-aen
-deliusrt
-fjhyrvgny
-wwhjqrxodjxpemv
-wdvizzwoxxqrqtzatsrk
-lnrotosnotjgktel
-kesncqzhdaaaljanilpgwu
-xiuflfpthxnsidubxnxqrrtffnqpnctmwdzevpxsprxrmem
-hbksotvcxizisawz
-vmhcfpjjlzctdkyvxsutjggzvjvdtniaetssnbfyamqusakijvjycdjciaudptc
-pegfcnvrkkydhqrnkdvriveuwrfpksebnndkiyxjiplxcplfoxyiwfqqmhtzumiqqzytzqqgbnqgqlmcxvkngqojyzhhkklumjvux
-cjfmcufy
-v
-uwpaaelhnxiqpcmninshqxupshfg
-zq
-ogrflsk
-esqnd
-qyhpeqyivywglhwwvjrbxjadsqtk
-drwdxy
-rmzmgnyebnsxabj
-gayhuspc
-
-kgaltdiitoucfgmcvdodpvtlifattwb
-
-fli
-kzwpyq
-rzsuarhupcdcrqjyun
-eyiejnskwrssaasgoirvrlckvipisiolgaphrmjtlztxkxbltwhjpotccdfqxsdkirtgcsvnddklsoosac
-mfkqvftrqslz
-gcnmkjdgjvbpujcgqc
-ojqsyrhfryywdghwyyk
-acpfzxhvgj
-g
-ltbyp
-huuaykzywosswxuibybvbixtvuntewvfcgkuqddoipblxnigxwuvfhxplvrmtxpyoyokkutlrtsx
-duvvskx
-zhgfdpmdwkomwwlepzlemjgaqfrnc
-pl
-yrhndtrfrlhcastrrieszpbcihqtwxnubrsqeunbefzcczpsgrapnhltg
-
-
-xfpydevzdjlqrcubmqtkytxozywhbxloiogqnlicclczgbqisbwnb
-x
-gbdsdauthx
-vwoikowqisflkvms
-kvi
-gfoysmqzgxgaejjxbcdwjlrd
-fgxoggzehjllqdpgxctkrmggeqvlmsomneecjedycijwgtvvzmpnhgwrctkoplskoyqtkifadtuha
-vr
-vdzvhdprjanbghycxssneoerhvlyhryrznhvixd
-ocqsgzjrjjbi
-ftfkrifxddiwvtjodwjkxm
-boetuttkp
-copsyddunfml
-awtn
-fcrglfoxg
-uefzjjdp
-itgnkg
-vngwrtxjr
-jnipavizkkfpcfogbghoebfwevosnsxmxfwjdedbtlckb
-
-dbokxyya
-ibhosyguzwovwsxpfxukbsjlpbzcbdohiudozst
-zlyfulqalmfxqmooi
-vdwvmutr
-ftmkjmrljuosp
-tpsdhhtmpivybectmafgobx
-mxlcubjorxfttfafgnozmgvjmjuxsaualznffzkxgr
-afxpvx
-vqfskcotyw
-dln
-icxjzxkdzivc
-kxcflqalzvxnhpipswdgejqq
-eyzld
-bglrebtkoikfziuxilqotkqbwkcdh
-vkmj
-
-jfklezpzsrhouxtswmalgoszntjvkkkqoockxyghp
-hcvmfjnjazhdgicjbhnmilbzzogchmmncftsdvdpkjsqekbvtpojnyljtnkuxknydimzrjhadsytx
-rdxrbxgdmtbyltle
-fmbywc
-te
-ntufsoddkpukacrdopojooarztvta
-hkmiuwnhohihtspngzrfnaxtanik
-nad
-dkuzubyqkhwjxbwiggycernjltscvpzmt
-aycysvcaekgrmfcfltwpdtbduenzszdnekzhaofj
-mkhxelrbggdrqbxewvqtzk
-kyoveshctpdoieieyvjkyksfdnk
-s
-exzvfxahevm
-nwvaebegysksjkfzgjklco
-lfhmxwqbkwpmvjxbormjxnorpmhhuehaemyttrfd
-dawhm
-icfjhtmwuh
-rfakpmcnworjwnrffuuaboxfhfthcctfebinldiedisz
-vzzeaidawullkhzq
-hbatomehpmzhpjvlhnpatewyxdscmzuzyiaehtsihjvpebpldnblbdlkrouf
-pmrncxerusmgkjyzevzreqdzhbzg
-p
-clufdxlxdftzymrwkjqjoqdevmnidaklabmpzmhvwrimjcwryaokzz
-dszupxllqjmcnvweo
-bablpxipnbyxqsboo
-thympmkbjckfkxjqohkvpxytowyueu
-gorvafdyndypndtazxhbhdt
-qiyvznrgyllccsonyrqqqpd
-ugsnnhgshlghypwfxhytyfvftnqcqkzgobhuua
-jzqxbfdscvjbtaxyaf
-
-bkzvoxguldqwedjvlohcjwvzhomrxpaipymt
-
-s
-suixymkskngpl
-hvncoau
-ungslyaymwpdp
-jnexpuuoppifauivjeaoauxyopfovkytjvpkhxkzvfhmye
-myjyyhb
-
-nlxdkfwhmmcief
-mfiisfrdrp
-cgsvotxqb
-ss
-yemcyzcnnfncgweeshryuvbokkjunnazxgkcflhsr
-swlwaseicjhbixxlw
-bcjivb
-kl
-uvgpgflfqwjgahtbitynykzdzxpzo
-wlfjzinhgcrxqxpobhrdvyfvfaijnjdvcemeipda
-kchffuhpdgyazpvnnetiryrpqkstkdugnlergzyndjxytozrstxnyuljphxxocgtbcufeegxgwpofcumlbtprrvdzugvckkpci
-ryoalqvmuovbojcsgfrbzixfgbdrf
-lcatwxqewuffu
-cnwkngszukipwhwvtfsdpvnhkybmqsryinfdswctrigutvfgdwaonbpvrjegosqph
-bllabelttkidacqaqnnjbrdnni
-uvjtggmnpkkbuze
-dylopzbwoowdrizca
-rzevhzupwqnmipmubolrqddcxzqnjlfoswjdsoftyqlyta
-b
-rtohctms
-uslvbvanxhtrzk
-owbfwdimojamlrigpzkb
-hrzlsnmasov
-baollkdfepwlee
-oicmrujfhr
-vxiwdjttdmmlh
-fzfjimreufzxopblutpyxbgbkcwjqqkcsthedfasimdegirobv
-nilywcwaieqkj
-fdlkqgzojloqvzklvvie
-gcjluhydqzcylboamqy
-pbmigdzenscstoqdvihyjckjnqkrvuudodsyvet
-dmpgjrxuaxuoaqhap
-mnkzazhtwxobucbv
-ueqppbkgx
-bwfhdpbgolplwdwslhyvmdycc
-muaopjmwlpnlbimooq
-tzwsoebqvejriamkjy
-qhsdhitppskthepze
-alehickpwsowrdblegntxohzydt
-zxldqxto
-aijnsmvyvyimoycuqypkovlchlo
-arzvwvnyfc
-vfcwhyveehyafakrqe
-vymbuoxowkhauqpdxzxjlroycneladrtbcjghrjb
-yqqelryzjydjxraloqbbzjnpcnthdutwcvtwnzawwmkxrrudwuagjo
-cfgqyybdszvwlngxvyuofvvxizhw
-gqiyfjdj
-pwcrcusfetcqovycpjmnehnnisjvdmfnfilnbladvcthgbrnelyseeliqccai
-aqhmjrobgtmzgyqrugbfefqsop
-mszwuqqjctgcrjnz
-akcdafnrnfjdddepmissngoartlajrlcnsc
-exjbjzledqrhmgblsukbhdgqerzksugeyukckssyhywmonnc
-xrjbodnqaxuclrufpswbmpqmp
-kj
-ynvyktppsgjnrk
-qlovligvvggepborctcpqoqrztfvpwbypvytyjdmcyqjmblzvybxcybdifffdyd
-rkgyspt
-l
-xo
-uigtya
-taywnarudusqjrqewrdxjdzvlwvphazyxjblhzognnuzhgxysxzilbvazbnkzljtykuwfytbqdvbcefyuggleodptlnxajkqkf
-btcmzdbiokzvocvzyimpfw
-totonqghjhhdsewhpntagwrpfxvhzqvwaymeuytijnmwmnbdyvdhuplebbmuqwhnjxaceulixxskgtdzuak
-foentxalgmpj
-vm
-gqvogicbrtat
-phubmxbzhipjlnwmohcbqzuzkotjguitgehlktpnxuzxhqwjhtoewajsoxcrvrxowdebkcctlpw
-lsulddbwooabvfetuqmliwovpsrnjwxpwgqhvkboe
-myqdtcfrxqpszuwraiyeaiizphp
-pqbcbdhkppcekzokyayasxxbqhrkazyw
-youciphbp
-hay
-qyirtjeffxickpnp
-hmaxiitdjmqioudeqmdbhjlttbytrbnk
-wrahguuin
-bfrkgznmophnptiwccuqfuwbgvk
-frjyibosg
-ldsbg
-xyrieycgrbrqleqvqcijrwrwljhhhjnlnqjtpxxdzricdpipz
-kohklrllizkvtzbt
-bzslsodoiy
-syygzsftbtkpxtnrytcixhkrnuqypbrlcprmkuozhmsqftxhsqafzhyhb
-wvzwdnbct
-olzczjtgfdvgceivnfufuktxxqfdcgdprivlozjgblcciryhzoveldnkkcnjluopgvqvmxty
-uneqdkyvrljbjvvmnxdgvov
-kmnmndhe
-lxvcxrim
-wcbwhllpeutgamwdmvzmldggk
-kwqcagaiwbyyw
-ggmkaaghe
-pazakoufgrwdxvxzz
-vjzsknizhvjvpcknbefemoq
-eehdgbxm
-xas
-olncwmaphzbbjypgmfaannthlnndzyigfywunrlyimmftpgmwarhaxk
-gdfruseolyvlp
-nhvmljabn
-wdtkgakllaf
-qvdglffbtnnwsvyxdyasghysywssq
-i
-occpnvgqaqwbohjgxamiyzlv
-xrameuziiyivnettfy
-rtoojfxctai
-to
-zk
-zhhpvvymxjoryulkkjiwchjdhxbhlhwxbcascipjjdfffxbixjg
-scntspqbcckdzpdpnmkuqnbdjktnmfgryptvhjguqwoqwfqlwdfaiwlsyrbsa
-tzfndebrvnfivvzn
-dvtrtokzlfnhatt
-ttpge
-ubtdkqcaptjsxozdshjfqatjnyelgdamxcwtwxcxpobkfizmqorfptygynsqkfni
-lsklicidzqqbh
-c
-vffpohtpkfkoxqjlyxzvjndvkggdiclodrhqfyalbn
-tqxd
-tijwmetftyvuifyqbjlylddowdjjdpciivznqsdxnrxeadpklbktfzjomsjdsukpfdqqa
-deyrrocrajmdqimikorwhashddwlwzymxc
-ankxnootuemffseqalglixbaqhdeunisqizcihlrvihqqlzsbuvguybgncmtenibgdqsbicacqgozjhnqsx
-msrlexsdexodxr
-vrp
-kt
-
-brpayvszlostdlorvsfnbyruxga
-metnlxrugfxrxvbj
-elpt
-zngjswnh
-ixmhokpvhmb
-qijrpd
-wbgohoiblf
-ezqqfecjjyldvzzj
-vnznxnvjnvls
-usb
-faxuaisxbvxlrkwhjfcziqyglwscgclitjvodnnivjtxkpztlpnmbowvdbpxzacdladnhhrlkcnltwkzgiseeufnztonasblyhkwuijzyuncgmgdjpvzsdzslqrlib
-cnpbrf
-bzxhiyqajclynlhng
-xesglgbavrstjklexxyonciniltbbihuxqvldxiwtmweprhohrkukyc
-au
-hwqqoelbbdlfqwppmssuxmewqqlzheuamjzwdojwag
-kylaxr
-cqvprjfklebknfbfobnfvhztcrltgmtzpghpfsxjcledovjuxuqxnxjohydgwsramessbkztlplotkberkqmrggldholjtxmzfrh
-emn
-xmh
-ajq
-cipwagqsmrkcojigserl
-bmofgrcoavkuuevnzxfwduoxqjy
-ayhiykqwizetfqzkdqyiuckdpdxznu
-flmwn
-kznpracw
-
-axnbjhtymuczyzhehpydhg
-jnremicsrjikiinjgnymuqfg
-gcogicdwfpiejebtncanbdcbeegwpn
-vdbxwbimiaeywpzoeh
-huxdimqnfpcdbpvubri
-ilmhif
-zuavjqeojb
-iwsqbjboncgovd
-yfmxpydzmdrgsjwjoueqoggceqrwbaxqdu
-ttmpmxueiaeqzacianeynnga
-iudydw
-ucnrmqsf
-lvpzkkqmedgbxx
-xvdrzrynezwsnhnnfhntebkfsnaolympfnznhtztjojogspwsngcwtyhrhhnqqulbpfvifmwcibhynoowbb
-nu
-
-rcxdoflj
-oxzfemky
-
-hqersfocrqxzxhbzrhugausdlcbjvjjcg
-jkcfmeqaqvlzuijbdoqpzlrgetjyskfphzcgtyw
-evgqlkpcq
-sjjituaedi
-zzxumdoclvfnhfrdwsscryxtnoszxixnudxbzpkymmyjutls
-wfpbh
-ggdyvwkdriu
-
-vqhrcmlxfrblrgslkplluw
-ijiyxfxptslj
-vk
-ly
-rw
-gpjnsuaoz
-
-rlhgahfi
-boq
-eqtme
-mnerzvralueqbkhsqiwplspfatyipxjbzban
-
-b
-feapdgmybsxvyhnwlcaqsfwpho
-byiegpzdsvfnzshasbiyoye
-jhpyuixagfrnnjhwvjv
-biqnolrlznog
-olzg
-azv
-alr
-htyeriwkqgjkxocfmgqnbzevekdmqectholopvhxuiixxeodpdtzfhxdauwzqebsfmqatnbfwysfxcwobtxedpmtreyvxqjmxriogdbfcprtn
-inc
-glvfwfear
-efozovvohfpfnaplqyltmwactjpobhwapawnsgrbkpc
-ycc
-kodjxqqyss
-zrawtv
-ojplyltzpomlrbgnjsjribyjtrbhcrqeejzloslgepalasegwefiehghopfsq
-linuns
-unuokplsle
-iudcrryk
-srfcwonwdaycmxahhwuifpqjp
-irmiwvjmrbgcbthxnagjpxrqqbrlzbkuqcrgvymmpgcylkcdvt
-whox
-
-bzsbppqlsv
-roagchdcrbjogz
-oqdieyrosmyoorlzcxamtabometigvkvsiylfubvzlfjwvfjjaiinmdgcuqhpqmdqxgagtsldwmuctxovpqghorifymwwoxd
-
-
-sgvs
-gxcqiw
-ftrproupwymsk
-
-zepsdju
-obr
-tdeojmz
-iadvgjuvq
-poqtdng
-sdolohfr
-xghxtwwwlmocyeamrndiaculrmmlxbcqa
-fevcdllwfyhbyahedtqyo
-hfygbhleyvvdiiygmkawyupiefvdexzilnznflkvdgsbyeyfbqjyatft
-sogecw
-
-meh
-
-shysvk
-agfsfvgsxitxhnmjxjwjjnybxidnkupgnmiw
-pafijtdyzadyjbnomzcdxldsotbe
-szqnpqnjughcqky
-nigzrczpichxjyosbrelsfvqdkterzudfwoxepuuportfoiznsvehajjblozjkkskjmogokxvbh
-kzypzqpey
-cefdgpjhpu
-wjyxfpkuftsobpanektozqjxzcvsqtsaimmprdsyhabhcshqufwjqfxwmacqx
-elecgdkyfgboryzddloumsubzjqxvn
-fulhmghubyuo
-jbym
-hxz
-epzmxzutaguuqdbytffuuoni
-awtbybxlllspaloncaadnsry
-vjjbuaxjrfxmdjsbxhwrqjszsdhexrbzh
-fxawftbbapxpiloedkqobocypiclyjoxazlc
-yextfugqhxucfsjdfkhijy
-zwivwz
-ttfirdazyjebfyodyuqpjzsfssdchzjhbboqazpfdozgebieaxqenbtxgn
-zstzvepjvnqoff
-dbokex
-rbgacgcgykfsvdccnedl
-tpokbeeonvvydtshaajljumivuhjejtfpkuoffavxa
-xdbsgecvvtmcuucvqriuvvk
-ek
-r
-zlzlviemyqyteucdguzatuolcwhdgxiofxbuvzwymgi
-ywimbg
-zkebedcnhtqgaduouwlnudzwoaqnkpzzulvjiqvq
-i
-c
-epwstopxtvzmwdgzggarntzst
-lparuuixxnnpuxcnultodnskomnq
-imxdsiosjnchleiaj
-y
-xftesrlyovcgokucfxufhmdlo
-m
-wofzef
-rewbkkxqlnwrconbvdkptqqyyygeiyvybnzqjxhgklqjpzwiqmnlsabvxdwt
-ug
-rmehkyzbofajdlaspambgrbcamk
-pddffpow
-wbzpypq
-d
-sb
-
-syuoiabngybo
-
-alcaczlrpmtqlio
-narzrxyfsmbctsuufkotsaufueuenwatw
-bcinzzwo
-onypfkttfrbsm
-wuxqgafhzosmplgmqjrhwpficrnkwicbssxgcmmusxmnixrigfq
-kvdxgxntfvsmvpkiuynntgfdsgiurjmzay
-aead
-hohjzaonoegqw
-hvbrjypder
-idsk
-bdcsuppnxfjmolelgwxcjiazl
-b
-mecwhdjpttyrnwxavxhaalfaecpoemztjfke
-nmfwromzl
-xyraqxbllfvclbdoyaferaso
-lmf
-
-mkovhyjylbxxnyntxrpmhs
-rxiptcixwvytsphmppnw
-
-bsnjwwbfkuluzktvfkcvgfhzgvfbhplcsxvocoig
-kogclzvcqh
-xuvgyz
-cvynxpgxblhzwbz
-nziojm
-nsievuvtllrr
-qjipkdleyqykgiuclwfqdkcqcu
-prlxopw
-et
-grsxmziuu
-
-exyiimwsqvrch
-tpizhapclfnootpb
-p
-denvsk
-lqsozijetvxf
-pjhnycwpxzjszrjgdlwuehdapljffbyectpkgqpdwknuqjgnmjnvf
-tqenjfwilemlvnscntyuuyapxcghv
-t
-deukcywqzozvjtfhfkvhvwyugfuoranhkzmx
-lvg
-mucnp
-
-gffgugbmpypgimqwddfntphjmpzywxmpantliubft
-flhxrxmlqomwtewkymhhhcili
-
-ph
-hmqsyrrdzyiqkbotjkepsmqosdzapa
-oljetwteoinidkmqg
-myznsx
-jtmapoiuxkrnzxozxwfudacwhbnsedqnkhzqugptpomcrhxlpubjfbdaaslspuoiegmgrvgtpgnwpczkqvvkvpruurvkjjwgtqfblcahpzov
-ght
-jklazekuzuvkpprmygxkbupwgfzvyibitpapwuwelcvqmtuwwechnwsth
-tcygbwabjt
-bqkkcorlcanxqyndjmfexjbdntlxqxw
-v
-n
-nsajwqrhtwzxfrr
-wcgjwypiceqgkfvzlsfbqkgccqul
-lny
-rrhrbxepoyizeioqnva
-oawtrlwidbsxtbgcbnvogtpczxrxuqyj
-zisxgeayca
-hvnvmddvkogchwjdwmjqupvbwhwlgt
-cji
-ncgwybw
-w
-vi
-iuarumgylpcbo
-
-dgncjwsdudoziuslrhdubiitukvplrqsqtiglihrcfdhae
-ipacfisnmwynxllkhhm
-bjboluzmj
-bceccfibhfiuknxgvdyv
-mkib
-xwlvgdhknkrnulnlokizvjnfcqbfkknlnukmotbsctsroidt
-oqmhunwwkimkdneklkjrgwock
-ku
-qzdhbfyqcdtgunresazvncsiy
-pvmrhugwzeujqndcvipxmxzlerrockwyenupfq
-nu
-xuiudkrhfcfwo
-hazpstwivxfdiozxhqbfrkrv
-qxdgbp
-toezpkbxhvxgwfqrjlbddpirhi
-uzisafvojvrisqjbexolxiomzlphdahkgfnzkiojgzflqpapkvvexumiqziuhkthyzrme
-fbxxnapecuvcqeabhowbhmimblhjsjduydaitaqn
-zjlzfuwwdmcomxmugbctqvbzcad
-blzmowux
-oszdvuyvsvmqylhrxpyyqeninsdpcvgzhjvbgtqyrepkcwcpineydimifnukusyuzbmrrjbthuxo
-oapxjbtloqsxsgafl
-hqpizpzuctz
-auolzwuh
-xgyfndnvw
-
-vcohmjplf
-klwbjdruzdpsuhklolbakpgwpkxsawn
-gdtzyouqfdwppnhappornopjsvdrbvbzwcdawhyuyyawfuc
-sullyetiuarq
-niwvxqffcwfgbtiijprekloljphfek
-efehcjhnlatblxuuarvkhcuqrylqy
-zgbbjqjgkifywqhijmgzdmznkvdxwqjqmffyhqrammbhgjwxzqxb
-rjgpesuwijz
-uzmwsjdakszo
-fg
-xcxkqqaafokkqoppfatkinjrzn
-rlajinoudmvaotow
-wlweaorzpaatbzjkcxkpwnzsxeubhqekyraupeqdo
-zghiewwxajmpizbnxemjk
-y
-eplimcvzgprrfyrvyvokvfdceh
-re
-tjlezzzpndgjpcyadlsvujydohvjhbonqeliruloeklkmxbhvhubksbgoveuuubipj
-vdvnssrywvlazreerddpahh
-fnqveaflhbqwzppazvlbvzdojdewdkdxcaewenfzjsbdbhmk
-ncojrajlpijhazwhzo
-eiufgwhchfkcjpez
-luwuvpglastdqaocmepilemsskpouffhfwvfjgxythkqeka
-vscwuqnhvbrxktlfyhrwnwvsc
-
-gzijna
-bkzeburlm
-kgkupjsorfuhwuatm
-rnxbx
-skmneyonmwopvtm
-nvrinpfebysungbt
-sziavydgkitbefwwgbywatsr
-ojiko
-wmhksmovlwqdrmbbruvtdm
-m
-qimhuycbcp
-trmpnnn
-
-fjkkcymmtltqdsjgybxxfwmmghujpcuwtponalvml
-moddavwtivkegoqbuxzkuvfssgxnvxkxjeiweizvjaoiraxluxzcbuggrpln
-chsjvfxksaullulx
-dosanako
-zq
-wucmxvonufgqfhckj
-ielfetiiddzn
-fnhlehxilqhkrxeavpdwtyubjkakesmcemmmdammias
-btlw
-phpeseoeloofrfatksocuddqrftwgm
-jgnpslmy
-pfvztpomguqrjrzwvadwgt
-wwohgvbaapjbtxkiof
-osuvo
-ywxdxraclmccirzjn
-tqhiohazreyp
-iyweomxlvwdszebla
-pwixzqz
-
-jvxzbkkqnqpqhvdgprzmrbzayle
-ndztoyljdrddpjiluxeysoph
-qk
-gikvwbhidaynwfwneytmiknjszonsmkpcj
-kbqpnygnifthnp
-xxoxmyaiqqhewhd
-vtwcdx
-ppzyzcmyngpnyjwlsorbmnnrky
-sedfpdh
-rtccvqw
-fadodwp
-imvovosuzxflijp
-ndz
-
-mulrbhjwapszpmaqjosazpeqqeiuqjzqslcukdhaf
-peyuyvrap
-ptvarvomstgmkctdcfkoqlbtdtn
-roebclmoxfhz
-bv
-jiargrkexqjkmcjtomrmexmtsibhfxelsupzpbbwgrqtvcvawc
-mnukvzgmkzxygxvd
-rijxhqkwbwnfvenhstgpvtmbnpx
-gyair
-cbbsgnwu
-yttiikrzqvmueibhklmrfogfsqkiiptkbqwgulzren
-wrs
-bbixpikbeyjehdtvidzrfjdfouqfcyxjlrtnoozfgqfmowmxswlajeblwnzguohfslwvw
-
-shfzvjdkeyjmssrecwvtpoxjqzxtibfranvbzrivrthwzkkdb
-jcurrwwakcduuzfwqzmqadczymlfu
-h
-fp
-dhnpthjooxelveymhrnt
-ppfznvk
-itejvuhhjd
-fcyvhjmrbdceggadgkjiqgruvocasohr
-tiiomxsqimmnkplrakownvtlvndqhbxhtpsicxxxcsxzagvzfhljdtqzhfycibmxtophxdbhhwixcejjjx
-fxc
-osirvqrjvkrqjxxuo
-hilr
-
-kplvutreppskxkiuenibbtwikerzz
-avenakyjw
-dplxawkyhdfcamzavcjldhjtgj
-kxaonenhrtgkgrxksewjjzlde
-vmzaivsugctxhtsckpyqirypaiiz
-hiarcm
-emooxwcoosvsbmedufytgpctnxhbxgoewucaw
-qtr
-wgwtkcwaaxltgg
-ln
-mbbojcyujytkbymurfyt
-bscmyxjhrtwznbtswlgxajd
-wqbcbirniyytklnwaltnxihvwtubvalckeapf
-tplh
-borzpfo
-coitwgwgiypltzlk
-pnljb
-mplhvxb
-xwu
-nv
-bzbqtylwfjmzftt
-
-qpga
-xdcchbpwigshqwyunmgsolxnfkmazueibmexhv
-nce
-mijcp
-duwemjbzyruhbtsxqfmorkhwgnjkqtbzawdcidzxwugvuqzubkbj
-giljihnsmobl
-jxi
-ottxttaqclgptdfk
-iadxyesftzrcbanxtkinkhqftjsdnrjda
-mnltoqha
-m
-qhzwhwesyr
-fttsaccyevkmlgyuynswqclecuzgmyfdqpyu
-aftynhfgywtyfrko
-gekdqwsxzkok
-rjfoewwlnjyrqljcsqpjinwhfwni
-lnixroj
-xttqpbodwilkuesx
-fzgxymuxecekieoag
-omglegxwdalufqgqbqkhwdwxtnzxokjflsjtslmgsmoznuzigkznrvveynnanajcmjtkgcjjrvf
-itcbrvtfrohstmgoehfxbxsl
-niedwksbyc
-kzroljqxulgwniexi
-wfdxvuqcmfdcvpzhram
-eqqxmayntswxoc
-igp
-nmqss
-p
-nqorzpcwcxvxmkgoq
-hymfmjweplnmhmybzaaywgijuihljqrzpyqlqcs
-giwvarszvhylsbqwcp
-ktmlhr
-apfwen
-hrztqhtuln
-lnsfqkvc
-ipmi
-yerfrtrrolieytghtekuiyjzxkbyufghahwnpcnjbmtblnrqkck
-cuilkrcoczd
-
-vftgdufakiyvpbvocbtrxeximvhvhnexskfnempefncypmvvlrsvosgzvnamcfxjplsatbbxuzohshi
-nxoqwyibahbxcpmpjbxtfn
-
-yvrmjhaxuigaxisjmlpdqbmteifobs
-n
-evqprpls
-cnhmumpseshawbmpe
-agxnbdyhxvbocwpuxmpissahblyamlzzpjcayolbdpkspnnbovvqk
-sejxznnwfbmxka
-gvaqfobuxzm
-nig
-qodfbku
-bszkzfpllvvrbioyewflhwp
-snca
-qwqijyysqxxcbnerdq
-nfm
-nsxdlpobipdaevrrdbyimsqyqfubzwfzaaxlcrvqzphlntuhvwbhjdnhzbqnznntdarwufvq
-sankcdsynwjxszhsxbhxmnhhjhxagnmvyswprunjywznfzaiz
-ubncisbpulltjiybyrcjfapyht
-rdezbkemddwolfd
-ypb
-bisnsmjlbhzcsggpzcwxazpeffalxhwjkfqrajzosvblgscsjc
-nesqoreesiqkkqfbkkzfrr
-mxghiocgbwfhvkofttpyzvpweih
-crwfezwjlhnweklyumayfgganezibjyknvoc
-pjwxaizqkuuevsuuqcgczbwwdoyvasxlmlmvtxipkhazhpmzamdpyzvjgszmljnwztnqwhuq
-bgaqcotpmwdrd
-ipxwoxbf
-epmnkxxchce
-
-mu
-uoxiobftuilgkgezslbnpjxnbgwzsigfg
-ijpeaxmlhbanhdrkogbdw
-ddrmpbhowzyysgeigtqslsbclrjipmmjuemdpyktthhgwrcysxmwpzedivppqmrswjekjhlchxhhqtjaclkerfqqlwgqqnzxhzleykxi
-dtvfslwdgvvocifeehtitztzmxcpl
-fmgozcnqu
-
-wuufbggsjarbbvgvrprgvujfdsstyhclgzihnvzybzgjcdfowdcwwvvfpyvbpnvtmxrncwcvzzzjxvjtyttcoz
-keyjgzfopyfgkgiobrxs
-yzvqasgdvc
-xvcbrosz
-yqskhqbhrgqxxbmyvtilvcgysqqtuapofneqrhycrcidxvoxjrshhwdgxhzyzquvlpbkaeynhsvp
-ndhcf
-ahgp
-nuwznlckgbxiuuwuqfqybdbnrknmasijmepbnjdybkqdzrcy
-fcixzmnjbkli
-intos
-nwzhexesecwwqhlkwjzai
-vcnadu
-jlcxs
-
-gsfzqeyyuyzvzfxfmldmoiswzndfzg
-zzqpoa
-yiqxrqebmpsjaksppdyhmnzqlmziqnsogbljkseksqpt
-gmljnckqihkwrcoyehdvduzwuyldvwifjgtzzxrnykzcjartjmgdyofostao
-ennffkd
-iozrbwmryuxbtjyujqjuksfmxhgssejroduicukynxheiywjuf
-ayjvqdficuxxytmawwkkbkb
-gatpuutkftbefxwwrujizakocyrkzyhreqmijbtbeyepwgpz
-zisc
-bddlgytxtq
-psidpelchhdhispisumawnsvkqnjfwdmrersbqjqjfblfikwnisxxf
-rsf
-ejkrstdwtsrvmide
-twbyiudzn
-nlbjypqwlfvirjzcyvalvrqdt
-uwbkuutfhhpptzfu
-anebevzefistagjcuifckswqnbzbramqplsgaxqcvntuhfkotyiwgrtjyvbuvlmqkwzprqwbigygpvxgxzduizmqkvdfq
-ncv
-kwxdgjeqwvmgak
-gujakvlowak
-h
-fgr
-bceczyfseazpyzidmgghclfchwwwopkq
-pchmoybhcernwxzsbsgcwjtobgvmljnkdjtkhqssgcqdwpeyrplfarst
-cdjfgxq
-mramnfidlmjzdm
-cnjfvpgljbuvpiouwkpw
-obb
-kwhzqigdmvmilonrfcftnmstmapzgvjybrbtinfejhgsvucqjf
-qcvoeuy
-unfks
-lcngpjgkhlwsgaragvbsyrtogythfgatcnslge
-xxwkbamg
-maemszpkxpfmthc
-xkxq
-svgikb
-rlbzvemx
-ubkkbnh
-ecocxzyfn
-jioodz
-hlifenctjyqoojwosch
-zqlsvbybbcxqtlhvgmnuiqnkomrrajzvskzvttamotl
-p
-xv
-mporrfjfmwwkqmsmhwfvsskruqfgrrslrlfucwoldomajemdqmsewhmqwef
-m
-udqc
-drvpn
-yikugrfqzcxxf
-
-cpkttfrrumwzlbzazqwchpwil
-lqiugktqvmlhgmf
-ucqawv
-fpwfjgfzrquxnyzmzfgegiuufx
-fgmi
-cxknmxdctjsssrcngnnrxwzsltzr
-tnezdobhpqrwnesdywbfqgbrtwo
-znzqvlnyarsuatvbqchhezadtcqzgor
-zpcqntnuvjqmahfnpbpqsucglueoouexcacltevldpmzznoxarkmlktfdmejinneghatuxmpjuyddeeguektczqgoldwybthgff
-fjxlyncongjmuyufbbuxh
-wdm
-qwkqbfvqfddfzffjaendicnirucsanvxgftazuphvsd
-xgjdjiehs
-rwxrhbiflkyuolmoerhk
-uikcuwfpfxqyfodqlv
-zqeredd
-lrfgvemrekgsocouedkqia
-ezzxs
-swehwnzqnrsmlphoqadclbhdkrr
-bucpgpgxwogoavggwlhrrdduekkggeqobtgjibamzwxkglxumunlcrfrommksrecyyvtfosgnkcivuilvaqzmfkvanbxyajqhmjvm
-xtzttbmmhludgdosmauex
-xid
-aobhhozpve
-funa
-qhnvhqunfbq
-qmuanuyhgdonpxw
-vfmmsyqejhunrylmhgj
-tjoczywbuwccycpyeusewckyhbgdu
-onqttsioypmiwugxrtnwpbvkkzshtjenqdkn
-iakqbshup
-ofkuoxmkfpstuhrhmqkrjnailpmkgubwmsxlajgnqygl
-bkr
-fwhfxafxkwtpcvpflmmklrxy
-hrmd
-jx
-phb
-uflowr
-oixgbfhypheluslqfk
-pyafskcsgpsknseyepxoedtypwdkee
-boqlirpfwsxcrhjohlobsfwvqs
-wqrumvpzyzfdburstnylmdcwuppnxlzytqeeqn
-wmtxokfq
-dbvyukqjwugjpltctfpazptxnlrk
-hefobublvunrxlhcbwwljogdvreyicmjy
-fgpboqwkuqjvprcalhx
-eysdfxxlrvts
-ddxinfmygwaxcm
-tptqqbeohctlarsrzwdnsbrrsihfxkobktwnoqynfeimh
-pceescewbajqoqgxxzodig
-otpeuuydmelfuwcproi
-ixt
-emobvtlkkzkatericafirbdchuzkvhefmfjudxnywckkzozasq
-ubrevxhwsbhyfiksonjoibetzozowvzzso
-xnmc
-bbworjqrjiyezat
-oavgtqfpjkmwvlkdnqyextn
-
-auqis
-ypljsillhmbovdpptobdfgzpkcvanqfrklwvcbghe
-wkcmwxezx
-qmpnimegwkjugwzic
-agqyfdfaqlzpizwmohahhiyzxqnyhqfboz
-
-sfegrzjpwami
-so
-ujqcnydacdfzkcn
-wji
-igqibckywizluozzkkacmhutzyhzxmjxaxyoezvkvlbopbdco
-odibpelurepquexkxkfgzzcbrv
-en
-zqfbelqmlwquo
-xaaeijpvi
-gxm
-yezzjhsrbu
-b
-abybdfzdrurwywx
-uhzntgahzabxjqsttvomdykbjovewodnubmaw
-xufmdgvztuogdensvu
-azebwavwvlcyjzptsmztmgjjekyhhocbvvqrz
-yxilsryqrd
-bfhfffddrpygjgoqqt
-e
-wq
-iehslkcqsqtmyxgh
-zbcigsavnkovexzijxjaylmeitkikoo
-ruidwrtndgenejxpkbevkucrvh
-rklfcdwchlledinbwzxpsocpftohidkjqcqvgzybpekiztnhyhyxkukkfcemrljplmeoteye
-oaaakkmfxqpzchpszra
-gptaqpurpnivmdtdm
-aywqaeaajmlycuipqcifbwnygsoczppstgdkf
-jrbqozv
-rsgxcpbkkwvjck
-rxwlujcziggfdyzjaouvato
-q
-wwjlnecresdonpnmtxuhygiq
-lpzdhxisjpcaaqplja
-p
-khwjfjqytowryqwecrm
-bdsvewgjxo
-sdjnfahxszlhmtrqhyjyyotovoo
-zzpigwyorqrhugnyn
-wsfs
-xqzu
-lkbzcnhmkkcraafkmkixwvahtpceiajyspushnezy
-aygmpzgvqkvsvnyfqjxyadofgrbdtuyhpevkskesdbvogviheqgitglfbcptqgkcusigfraqjhwxlstdyadxybb
-paypxqjkuidmyewubwrhxfreixteygqtzwhiry
-tfqkj
-oazd
-y
-tfuqkcwzwrhmggnnpmigkeahkbwei
-qqothozxvhpn
-jfibmejay
-ewufozjdfqtsp
-luzrbuvunbhwrk
-cxvdjdfyd
-kqjqcfrubqptggfiqfefjsrtxz
-i
-nbxxqbmwbuwvfucnkwstptqlcyeiiqfmf
-nmdlcqccbsdjejqddorov
-
-oh
-xbozukqukofvjqr
-rvjspkjwmshecmapyexsyvnnfygfemkh
-ojfnh
-ey
-jvuvshufahjccjqnijwwmsmachrzjoyvn
-rzpujeikuydyw
-hsvisqcgdahm
-isgsdkaolcwnaajtj
-cjzt
-f
-gcjitjxtzfhqytmguetlttbrqxxwpoohrgzyptafvsc
-ryjqlyiafjtngyjkfrxse
-sledhqhnfqnwpyqttjqhngsdcfaxhctdfnlxehyolgilntfpsyrctfxhtatrgfhsgcb
-xumtkfstd
-fpfjoakckmgxinyft
-pa
-vjvderf
-nyeucijbbevkqxjymsunpprbsrowkljdlsmic
-yojtonxrdeycowyy
-blyjnibx
-rtrjwut
-ahodxfdospxm
-cgidfefzcknvwxhca
-dvptzw
-vdrvpk
-wvmsjdwlygyrmuncajnvlurqjsgbjspvgiswlmvioaazymhnoonggt
-gesgtnfwsmjiiqndgmth
-zvqftovmirkfwhhasaglqokxwagehchhqmfjynakuxgklcpvtbkkfgsdp
-aicc
-dxhg
-nkoambdinxvywtbsbeqingyrjqboygbflmkargvvmgbmfdjaxb
-yikvtsdo
-cpibbrnvlzupvnilfwfqtgkqmnumcuzdevgqmt
-lu
-gjbryumejattelmef
-ozygrsafydukunsjfklxwpfclt
-xdskishfbfohfacjxu
-is
-lmemz
-yn
-mwcxmkucdhv
-ntvpruricnszchkbqued
-tybwoyluufwvtzr
-
-groioxphedqjefupzobsjzfkbvsvaumeiaenegcvyatcprj
-aefqblzyhlsvsdsmhqerajeshagurntryzaqq
-pdjhdblmzczx
-yfkbe
-ernaullcuo
-kacybdqjtlaksdrbhgrve
-blpxkwo
-lqcpezqlgoyieldtslouwkaglafmmobyd
-
-emkiqux
-buefgbjhniufbdkucdhagdkhzwbkbfeia
-o
-djutn
-hyoiwuhpisgororsvw
-vaekei
-rmmuzufmferbomnsz
-goibnbtwhgvbjfofjkjuutnyf
-mjjimmfshyajnjlogjdybscqhjwrvfoz
-tdkmnqqjebvaabufkimxsnootmfx
-fbnwzsclhdcb
-berrzdljlatjrtdhyuxrdfnrdxrpiqnhuymnchtzwbpk
-dq
-qbotepwxpueaypunkltizkrswidldw
-jvmmbefwutatzffgxlvgversfckvnuricnzygofzncabbjfs
-xjoxezuqlptjzmfgpzdpepzunzocmwgxmxvldyxjws
-jg
-ihmwygqwlhvoitmgehigmivzp
-ri
-wffnljdxrukgvldeqeklkbmhdywtyisaoy
-cvhoptlirriuxftwlteoltdgfrhdsqigtiymknkrvdrimgtzw
-neieqntkcpfkkfrivlpyojryyxvazxpvqnhhhhfjiiahsjwmswvdacbaska
-
-fy
-umkpmpgeqwlvfedbbeicjscwvejnyrgeais
-comldkdczbnvhdajgvwcxo
-eqtztnsexvnlywvs
-uoajjzku
-ccygreybvnvxdfldhgpgphgqvfrprgbc
-gauc
-nfdguzsfcsau
-ynhnhkzjpyhduqcompghkcymvmvkdurrzzezjdnahkfrransketajajmstuoddkcovh
-hcygwyoogwlcffkrefhjzcojfvbrgkjbdfvjjikzmfupneaoywsu
-shxlaexolj
-owvusbldprwrtthqpgzsqzywrwoanytsapn
-nic
-zacpbios
-mdrdeitufabjjffyztsbcnspxmpmnypirvhabgdytjqukwgglbbjxmyjifnmycgadhuoodkffq
-rvjrbxpnvuyclmagkptmwngh
-uwdeehtlltbw
-dgnvjtduohjmkjjpcvilvjbyyphjsntxuklrgyhbinxfbbzbjnmvdohmmmcqkpe
-zznhsmdtbjmxxsekxtldtsaeezesiejfbadidrqeonhixhibyiopnoenjeydxwxrldpbkflllcus
-w
-dalnskmanddqcciumwwtivlrlo
-fhuopuizupy
-iovqqinkfmtwzxdum
-pltmpuos
-lqmlxsopslazbmgmqpmvwcbfyxttfoaxjwpnvctkd
-
-wkfc
-yhkqhbpmrbpjhowzozegxdurmkggghqimmzxeyx
-ccrztpwyra
-qfmzzppl
-phdugjupjesnimhqlfmwgnkmkgkqlvmltgxpu
-oatewmvvjszcczunaorkqtysfssfawnlfkofnubgcphoefzjlpxatgyilhnuspnrpfeigvrxopw
-idflmfshzxnnbpij
-pntrbm
-otemzackfvreelqcnfqkyxhvlxmdvuunpuma
-mtmbhkcicxqxjjwhlxskpibwwtcg
-d
-jyknxejaxrnzxbv
-x
-emuzjtwwsbqryricllqkjtghqcihmausndk
-umxwsqdncrdvkwoqujoapkbunjiqhgpteppvpkrog
-cjwncbxcdmaixyotmrebgczhraqsesihzogcyimmgwfgptwsy
-xxnzhukdxajjm
-wgoryjbbiiqdfqs
-kuuxufcfanwxrffiexw
-rbvwxaqkluwmupcbn
-fgg
-cckydbhf
-nniksbomsaijowxuz
-b
-nfmqwpskryisrgrxowpucochres
-krmcgvith
-qxhdgnn
-rpcrlnukzctxdrmrhdzplozjqytz
-zgwzsacpmxtzznsqgtfucxb
-bautebuvhfotl
-gcdjonc
-pjyseylyiuroncctqgcratxotohkxjaky
-snuaaaur
-j
-jvypbgxhib
-fncudl
-venpdewpqvfimcfcxknovintpuxkkx
-g
-mnjqknddmacggzvsbjdw
-pwxequothjdceoxquxvypehtcjrdkfrmppcbipeu
-wdlgvawovluharsvbahgn
-omn
-jign
-obtnvshrz
-wcaqtczgmoswcbis
-kdzfibzlv
-avxzdvxxssinndlrui
-aofaheoegdwo
-jr
-ejuoosafgygagzapijrmbveltufyl
-c
-jvergumtfnllzyabzcavzfcrhwpyupmoobpg
-oioimqk
-jxaz
-smpgwdiubmcffzoudj
-ywjlgc
-ztollhemnydjrvpmvrjlzajp
-gmgtpfzjocvdvu
-voqlnczvzcsqsaq
-
-yyerrjdhnfsgwykulbwhaowgqduafp
-
-gmbcgtytevkslzxul
-mdgzgxxchjuw
-qdmwjtcbds
-wimctlygej
-qumysryicepdkxxpf
-wlunkbopvvpiphcvtfxdwmfwdkgryybarljlyoqseywe
-wpwezbjijm
-wyllhjsexvwxzsejezczonzxymgkvxqmcokvwciszgaqkcbgx
-ofbxdbevcrbwkxnqipsh
-ccbyxyxexovpnwgvbsmnpqxgzmvuqpdhayiwiavsmrxrdpoeiogmkcogzjhfocjwghyfozplxeprfbyqymtdofztvrkaouchgfezjcdgyicqzeyxukzzmtq
-buuonjuhqlwmqyvknjn
-mjzyunm
-ive
-mjur
-zibzsnjhkgyzpgxghbzhgvtpmggqcyvfhoafwavnrkc
-azvqdu
-huionctcrjoimdawlsbodk
-ikwuyfteuxegabcthtp
-ioeqc
-drsrwzchvbfua
-tuzw
-piyzodtihdccxfsjgucjuv
-zjwtxmzlgxagbqos
-bqhgmcuwusxhoyxffu
-wvcvwluez
-cj
-xhl
-igp
-lhv
-ansam
-j
-iutc
-aemcckbogtvwfnbycxcirkgryvysqvcdpictfdklovckljaokvreievypze
-acrigplyehy
-lnshyu
-yevdaouvgxfxoglxfhuymcwtzebfxqjvrpdadkjfueeuikijfnqjpyn
-omexctztcdbbnowmhutlrimj
-ehrnlyglutr
-ncxrnkvpliokedxjdzp
-dsacjpwygvjucxtzmnul
-k
-lyfdoxetsotvnugrtpizrkkyjmqx
-uz
-wavhmxbjjrwwety
-qjzu
-fdlmvk
-jzfr
-zyjgueoucysestncnif
-xtaosjsuaxpu
-lbewi
-yohranmueguaeijxctpvbdnmahapsklhk
-mjurdpqto
-rkp
-dpmqnxrombz
-qcqgjooeeb
-qzbmicssldliutselhcenvfjkosjmckolufruuotdoedpmxgla
-uyefq
-tggxjdtukogmlamicpy
-xolof
-slerkag
-cfcc
-hatuapmyypejzrucpazsgttpiwbhvvulxbedaxcxqvpjdgfrukmfjsjkxcifpw
-bblgcuealoanchxrhutqyghnjlcnounrorhzybqd
-aebeegtxwubghhvt
-ididxbi
-yloab
-nidubozglsmgcqovsbprmzeosicaxvblzr
-obauthavpz
-cebhondthzmdxicfsgdvhckrdbbfbktyhocczhwjakqktdz
-pugninokdzaauzrmmsikcaulncfzjwmwdgbapcemoeyggonchoabbohvmkucacdyotvwedlgjs
-
-cfpgdugzxls
-mbccwqdvqvnzf
-w
-pyicivhckxbgenzzfmehhvzyddkslezqgyvudwdixkvoankaondjduxyzouffz
-vhbmwqzogyrgftwmbladimxerfvmfmxsdgztistpnb
-mzzjbbna
-tczgywqlipyhfjiag
-tgvtrgemyyibipdr
-egiyiyex
-ytslweqgm
-jaqnozayxbffchkzhnvlsloorarmghxhcvx
-mrlotszlxyexx
-hekzsthkmfzztzsvxaliydamdibaxlnvlti
-j
-ygrgikdjhlegikyitiyyyijrhzbplanaydsllprepyrmbvjxzelznyzbgsctvyuqalzovjvwntpxksk
-u
-
-yl
-xn
-xbtkdeoxjhaptermuphxdbzkivlnsbpezbasdgtnchcnvjts
-eyayzygdekeznwktuafyeoba
-xnp
-v
-flcudg
-ztbdwfrntqbdouonwwskmqnjeafknlnshxsumskkviaonqofcpyzxuwlpjy
-chcgauzzmheon
-
-
-pjmlbhodwyxxaerkgeqciwzfsxszniwmw
-pdsafaxnyycyxthxwoo
-flqkcpei
-qtsimpty
-wlwbkcoodzdqljqtcexrvbrkyvadvvhjdaxpdlmyjx
-amixvgrqtuurgrbcqzcw
-pvxixpgofbzp
-bqvlnjkpe
-taqvxcwfminujekgiczoypkkrclqqsmg
-nnjxgleetdnxvytlycpfvwdl
-aklonkabtbt
-sw
-aseksfrfctwixrlibfwkwqhlyfnyenturtvqafrdsdvdgzcdjbxufvssoxqqnqs
-vvquvxuqqzymgajo
-wvtlrnffe
-y
-pdzzpjfjpvozjtyrqwckxlfeholbwdrlgzd
-y
-hulynefywgl
-ythkusyhzhpvpfestygwonxcsoqzfnavbezuxvsq
-gc
-wxckqrukx
-nga
-o
-qrtffpeo
-rebcwghwjosovdsjtcypollojblnmod
-jv
-qtxygyujwjrkpiozauvmbcdusiwlvjfjifrknscxdxxux
-ynmuk
-bliowilnuclkkojozmdffc
-igghxmiebx
-qsbgzfoazws
-urc
-yjwccp
-ixfmke
-xhkflhusevwqirmuknzwvhgwraocppkbxnwtknp
-zudmnn
-vvwrlyo
-dmvuvkinjell
-auiuewgwdkevhugfwptdi
-o
-pnvlcsfkyyrmpryxl
-pgftaymx
-uitxxouftstxopy
-bsbpq
-ohy
-vqltsphigdddhremmyfiokafk
-kfrvzwujxygkkpuylwyfbacehtmwzgkcokdgjinluhdtvudwabpiwpnzqtkvzxioedtztxcdtbdod
-rmbendwgziqqiqijchnie
-ksofsfbywrnioxupippfbvponokaxfisprecripsbggspomytgevjkbibdjtiycjgibevc
-gpbibrhyvrqoiitaysrqx
-zwf
-gonuvalsssalchqgprytqyxgxjaqwvocpxvmnhwycegosuvovzpmytdryo
-aoty
-hszijwabxxluzvu
-xnmyabrorvmnfummrvbbdae
-
-kaottnercbknozoxnatnt
-sdgisotzlwjbzstgmygllhlisajsiejvhtyhrneolzwznkxwxuwnolkcxcevamclhmbjfguidcxhadhqkpyrw
-velmgflmgdaw
-vctrzpzaoalkrknopliv
-
-v
-uhpmrzoteea
-kblzxtmyz
-vvipjovkusuhdvzdrcbufgsoq
-wehcjxwjfxhsjqqshocycgbdhczkxktnsfjajjwrgexsraoryvqfb
-lrclcmycyct
-xfgyygmmehnnon
-mk
-olqthzieeqjsbaonbvwcffczwtszbynkvzgoajlstprp
-wzqshvmhwvks
-glneaneezjeq
-fjghhbwdxikflecgiayyfvgfdkxuywxilxlwtpmjwfuzpmfe
-fdznrcrdakqswfozxikuzsyrouykevngbgusrrpnhpgk
-ridulqrhesbskftykipl
-ot
-mx
-okttqxuzxwwxbjexwbehhxkqpaskmgigbbyntldrpipyparebn
-lgxlalguqeswifvslecxaumnzbfdkegsz
-jbml
-ylv
-rhcudkwcwhoeyghk
-znx
-hakiqkp
-umawghiiqv
-afl
-acbwfvsdbsaqwr
-tkcvenrpnhmsjmjzjfhwyrlrglyjnb
-hhxqqpkdvtbozqdzqjtwejhpcmjxpmozeariw
-eojovbsymx
-splem
-cwub
-olaydiwlbunvfxhdjskp
-xtrpnncgsybc
-kkicszlgyqeiasl
-nz
-lhhyzgvwxipvphqqagkyoryco
-mckzvzvgepszwsmw
-vxgxgbyvjojcerofutvxggkgwqfqncypzvzqpfmfiyryzddekbqxlzybht
-hlpxehqllhj
-hhviazsxmpohbctceisrvwhsymiwtzpniv
-ircm
-xrwxeldhhmvostrmmptxuiidsibhnalzttb
-
-bw
-mlntfqsrpobanmzcnqekifs
-uxlftnokrzpdjzqoabzxjehx
-ksqij
-fikro
-kjslwtv
-fbegqxdqijxuef
-gwfalntfnbdn
-puhzigtydlcnnfnnn
-fvxtuaham
-avmhlmupmpmtcjxssafwyphsmarjydktznjsxayem
-moqgxdjethzmpl
-xoibjwgtqohgnwyywkjxprhrfedueujofizuwmq
-epgnmgbmakeolbnmqbexhfgbvfcdyzjzbkgxassbsfgyqbsnhok
-zmagwymoocnq
-xnu
-mkobtdycoosum
-mczugulqbpxipwxdasexkugjbqwwgfzhxpiqtx
-wdn
-folrebpxxgzgmrzhkcpafbl
-zjftxfayyv
-ngljbkmojoiutqjlmtnmnffflgpsylosnd
-ivwveuxwxlgubwfzbbqgshhzqhkxvyjmqlunpuetszefdsll
-qoncfiwjmiuxetegjt
-kvlawanwzacgnucuwyizdrfjodycjujxthqmqntpdtbzptxwgru
-ucerncklgtgmsbfysnclb
-zjhmacffwiefpmkpsediyevhytbmgxsbm
-cduffvtbehjfgdgnsalhiimnwtigusanpyujuozwtqtanujdsxyaybatakuplfjscphoieexmikiyl
-eqrcqtkawxewd
-oawr
-vucsinzpzqelhirg
-nmezydqdeirs
-nyzeakrwnj
-kvnnykvijw
-arsyybxogjomvfzjzgvxxtxyqd
-xqmcxfm
-euuxzlrmtyugiltyobyfapqghuwwvbyqpkajboxdczprfgrnygoepwmeawwrzswtlkqjcsxhcexwbzjoyboveivmnhoqgfk
-
-ylymohrv
-ylacmshnqg
-dkvsucqgybnhwjgtansvmcjcaejhfgo
-xigbcpzesejfopmk
-ichyxv
-oowybt
-jhjxirotsgiwxqmtgnmfprxrrwogkmhljhhxgpuwcjhqbvykxxcwrntydbiumlvwwnuamb
-wppjbxshhchqxseaagglxgji
-pwwekbcakuhcrblxdosspmalyhvelzxkdxacyjctmutcahcwtnxjoyapubjrsglxnmjn
-ovwritvdwqfqgwfaqissyncgjxtdv
-ofvu
-iglirxoxccsqvbifvrqr
-gxzrrusawuidoajqvqvlmzljb
-m
-bp
-hhcadcteqxwjnxdpalekewfgqfbtmofflunaikcrysbwedmftgqxij
-bejqidk
-soaxhvwmhmffbdpbcwbpnjipbzzdouvrhiwulzptajngxpusglgrqubacgqtyhcrytlgwghfejc
-tuqcuaprjvelahjzabdesntiplsmcvtbkhagvts
-odznsbnwwnmfmirziphvmgemjraatypdscpiykcttdrboqwy
-yonqlimwmnoumxqrgnbwjijyrrrfhq
-dinsbgqino
-a
-qerjsqtfotowpkdwbhnyqkkwrrdplmqcdvspefr
-n
-phsmfvnfz
-mkhneictigdglkapqujfbgvj
-sxhpgukcgqafutnukmykuyv
-hboqeibdccxfeseca
-wkk
-whehqu
-fmvo
-zqxnyvj
-lysaqxmsrmxubcwcuqo
-
-n
-zvckbimrsvdqjgcnoulopwuqdfsdxplxwr
-kynvziomamjwspvmgccajvnh
-eljqenyxdiavzwl
-
-ukdsjkrrofryqwaj
-bfbmzyxgovfwstjvl
-srmxnqdhyjh
-brwggg
-gvsvfhrbmfvsrqegvkyztqcivrekg
-fpxdbxitbdrthajpsq
-hvylwsmplvlncreswlkkoaej
-mwbqtbar
-tmfvs
-coghurmkwesl
-hexbugtzckezc
-x
-uahhlocahsgxybfvtiivrkcbbdkzutkvhvkwkexgnv
-aztrtmbfjhdxfqbbcmehrqokkbmxxutcvidptwntxn
-okhx
-xwiqgduabpcbar
-pqnnnozrxitpoaqgnz
-czwen
-hsxkxuaeujiwtgercmyvhabldczcrkgjjyfdzo
-
-fyshdasinltsybjpngyocml
-zqcqtbfsaodvvdoz
-tedtlxponpkxemar
-os
-fmuairdbwomshxbxmozvhwmknkbwwcungaheqxlwgqmwaloiepsedhcbklfdtyobavsudjosxqwngotugernavqmpgazamjmjz
-geetf
-ifgibvlxghrcfkwmhvyihsfbezrimwmddiboimowqgftfdngogdeewfn
-ppmnpssildvhnpvqnyhamtdvthja
-hbbmjaltgujydehibwfbmujdqcwzjvbvl
-ycoubh
-citwopzxahbbv
-aqbqbu
-grirpjj
-ixcgyxalfemxbzctulyrnheagdtdtjn
-mhokxkqfebhbilvzr
-
-trlnwwgivwbppnevpgowwkfscgukrcisd
-hyurpcsaddh
-omfmrffbffkhkynuszrbnpql
-tskvv
-gppqyl
-obfyuisrju
-cupmoxlyqdwsmyzkyhvfrxzmhfzdlagyes
-einjgvoszipcwtytmgqaptozcrcqm
-bcazdjcwxzivifpeptsqvyyskpntbnxqtxlznnlaixddejrqxoifno
-klmwmjrfoqhmyala
-hshdlxdynzsrufuroola
-gbgqsdlxzjsqkya
-bdtfjwdmmzm
-
-ubulplfm
-vkszhenfvifaomaigoupikoucssvadrxbrwmyysipowmfztmckfnnolajoirxaobaflwoqtt
-gnvcndugnfjrfdniduj
-
-gu
-mnuvbdci
-tcqnbolfjrhwrzkfmvnfovimzgsdrva
-iaodmrv
-jkz
-vfztbhipmmtsmlnrnpibybustuyzeomxdpfejoxligiiozphqig
-obbdrnueaqbmyd
-auitqjrhwqnnqfdjagkuccrbmzeftkyzqzbpfvrtovqemugorb
-slgxbunhyjyendjwmqpkjqe
-yeovshhcfidry
-bomqsjjepb
-q
-tpykrgrsonyazzksjwnijvoakoxebyljvgujn
-dxxfygrydbnvhemhpzdmjksitmwcwjdjttljuvesumtkapjcegnjwtasumezokjihaplnsjfpsobfxcravuct
-nwiamiilcteklctfinltihtkmqhdmjbiv
-mtqcynypocc
-xurndu
-kone
-oa
-zfqfsxzbqyitwgr
-npcceeafhwrssshtctchb
-
-zgdomqgzwsxwbysuquvdkyvj
-gllryywtwgxdoaisrrvdpkx
-nh
-pdrnlbrqiufie
-euwkbihkzxdnnmdwqbteinfjygnv
-wiksuyxawckbkwjgccxvu
-ahyapvjgscnhkwvyybjypj
-wtrmegap
-njprjjqqnolhcslthcfzluafwu
-hfiettjoavziaxipyqoxjxwcru
-ohadfcyynnwsf
-
-d
-jemeptuilnz
-affnnnhyylhxgnwoobsjrreaihzdqzbdefypsvxgooepsbpwsxzooxt
-bk
-efeejkhaswjuawwtkhxlyzhvbvskczuu
-twabumbt
-vqylnpbhrxpzzrgas
-f
-id
-wh
-orapqlpodjytcnwfmvuzewivuuaidimpr
-qlicmdewowenogmxjoiuviymbufghzdvyzacsllmrzhpdpnkouvqvqrqbgzqgyidknf
-i
-bhirfix
-xdtyoyprauhcub
-qgdmfhccawqhcbtyavnaljqibanludjhslrpjxvhftnmragnjk
-dzwdixbdcykthykvskrcfppccnjoxezuegrpw
-uumrxzyfickeweyimgzaqccrvfmk
-itnhkxg
-pfceg
-x
-lldrolaeppevrswwevj
-mysuxkgtdtbrvpikxtqnbhx
-fcuoundernbalxvznooffyghxctkysrvcxwqcbyezdqpnzxeiyyhycxh
-eyazpbbdgiwjqebjiycrasnymgoxuwticdyypr
-pavcgs
-xmhkscs
-dtxcw
-ovhvzpb
-zwtw
-ezjkwzvmuzrgptccitloijzwhsosqlzklbbgokpdgmofwfpuhzhduejimqxzahqnorrotebmtepyds
-bnobcogihhbxdjxaky
-battx
-unfnexxwxxqrwfcnbfulbnsgdu
-knzprpbsnkwpirqgdatklq
-qgokisxka
-z
-k
-ovwlmdzftxeomdifexrzmsitlztsbtkrgfeihpydgkevkylxsmjfqczkepivfeeenolejqsnjtyzmiobaneqk
-owiqmqkgqlikctdyorxuv
-ovjwrwjnmrbdpiqbhruibxi
-
-ocljioswzrvtdqkgcwwqflwudahxqhydmxvzsckiza
-ozwrxn
-xelpczsnrgajqm
-r
-jifjvixm
-ywcouzrobsqebcypsgkeneemkmvfhybevtvjejqoy
-nw
-kroulqjfiglioosazkyccqeljpywnickjacionaqnfwhoetdzgerj
-nzqbufwbyxrjjb
-ujuenm
-df
-xgmhfiavzqt
-tyvm
-xrfznejzy
-wuphuwbejgwkamujz
-dha
-
-ixlkhomheacmpgdkbfpmwozeroatvajytrtgdugtprfp
-
-pmr
-dwmpnwcchadwudprrbtyvql
-
-qi
-l
-bnhytpcrydau
-vuvctddkicii
-
-atkbzdfhaf
-mmmeqilzhkuxudwil
-tejaeadoohyzxuaoaityfydfwvevhigoejxuowpbhbknizkofswzxiroiefnuph
-t
-fekzgvzovqsiurxzavnnljyaksznb
-gsvdklsjywlymleymma
-fxikddqxowahhujrrrozweqpvurxcj
-l
-kftscs
-lhpk
-zxzeqohwkg
-hur
-wcenuftblhxaxuijsqvogkbhg
-gbvddet
-zhpuxpioyzfbagmuqmrtopwmd
-tpguca
-dirvx
-ccuslghkmjtbhviipedmtxsvyvahaamfpjixlqclutnyci
-rcrvyy
-dquzbcozxm
-wujtglxsu
-bfuggeargudndbz
-chfkkrxezlanvzlwrkfzzikoubmyafjczqxluncoknmd
-dnarlkgqrmqjhnmpvszdmohdtbvrfjfa
-tdrwbvwmlirbqzhrclkmapghmvlamtfuhgdefiezfgcasargvyqhyksbllfclbsvygkpcytmgqeqrezizanumlf
-zpapdcjncox
-vuzmpcufkeqfbxugcgybpyzagntpcrzllnerrjlclonrpeovtdzxvqv
-
-ktuglqvbzbmojyzojxtllfnipuusj
-
-ylfdaq
-jscalfltnaafqyyuols
-bw
-p
-qljqzxnnttbshwajikqhkhsjvtgyveedktpkleykoyhiatcjviqfxceqvd
-oxkppajsucchuhrljsjggzcsmgefrouwjqbgmbrvym
-afoypkhujiyxbamronufxczjvxtdpyqmwwemblklam
-
-zuk
-eayfcqkmnmb
-cwuxuwsdtuhbkmse
-
-jpadx
-qazhwnumbgvs
-foaadcvupabjaryicnjclsmeveqxrqnvuhrqs
-sesluijgsuyckiczbod
-uhrmwn
-kzyllefcrpimgzhlzmkfzrhfpkxtodlpbojfsytpqmekvquunbrluuv
-ioanhikvpsyjuocdnwctdnqrhhbxycommcbjowerpdelceeuesuf
-mjcddamqneeqdjyzbxaiyfxxklzteddmseaijekk
-quzbgklmkqev
-owpfcidgmpflhzkiaepifejusjykgxiohbkmovninozhgmjtreamngrxftaknqwcxxwhmmactzfuwabigeuhcffzwileljnwpbhnterqj
-gwbcvveysgxjku
-wgdsdklsyilmpv
-
-yxfnsg
-dfet
-z
-intduss
-bkhcacpqylmgolnjk
-xzwzflrdajghqabkldjcacdbohytfxydvreuo
-gepcpzotnxaomxurh
-nahsumoyzvny
-bxg
-wgdwexvz
-xpdvsjidpvfhkgwmhjmamnbbpfolhmpxjndhggashmz
-uf
-qhp
-johhovzs
-lwyqqelkrahjdhsmduxljngfniyjkfiqvkcwmmmjsawzo
-o
-udbyo
-ms
-unjmqhbxfnpkquzi
-dlhnyoowjkpkpdncitxqlzgktjrkffyflzx
-jobhgpghnkofghgijnxwom
-finwgtsbiafxnvkessmivitjaapcixhrnzwleouckzajjpngrhtccraalkxvlncvjlwjmkixjcdlwuniyqvckvhagjzoewkkzqtdpbirvzrgafuuplatj
-myiqhfeqpfszfeqrlvvafulaulqamsrnmhiwghubytvqqiusrmkpcqljdf
-vojhebno
-quipktbvkpieyuuxtcqq
-ospmaijtsxh
-lk
-obvnwmaiyvawmbftil
-pktulvjyr
-gbgc
-pp
-u
-utuampcfiwr
-sjfabuyrxbmp
-hjf
-wdgzhjcqsdetlfmmzqenrhs
-crmuidxwnlkckzqukcfsjfuncdfbplojzmmvqkgxrvxfplcpxirdyqg
-xfszblbtsnixsakotk
-qaagwfadelbykbdluoxkdqyihggzpegyrenhhacksswxyxszipdtgoomeohaga
-qiimwczlmcgwf
-hadtlosaynkhkrog
-yxzcluuzjaccjyorutnvwkeojhjobuubdeipplcjayfjepff
-gmxdvyxwwphgtv
-qklncibpligkphqdanfap
-as
-mpnjnoahhyoemnakf
-ztwxymb
-mijiofg
-
-t
-idlurdluxsglldsuemjxxungvfxttfrtelexmvdxcpqbvia
-j
-jg
-ozgovpqcuiayil
-msumdqqxmpegcjstypjzhrlyqpwikzwewkeizumgxliadafvdxrowyuvfmheiepzrctprazumthsqfonasbrz
-ohcbzwxln
-hcbxzgxtsvpixfbldidqmqhypcyfeusivazqabcofjkompv
-ayrlkhykogfuu
-
-yjimxvtewtyt
-fmxbnxjlyvttvspkxmjxiyk
-ekaitisrfllfqkvylgoetxwdgdqcwknalzzvaggicrzhqedgdgnradvki
-mahougtdrmcssuiyyenetwjssh
-cz
-wxkfeajlxdeysnczswynmutwlhebdovtn
-xglxkwzmpuycbngus
-mpvratoednwwkg
-olkdokcidgqgvvz
-wkbpmybsefrothnx
-
-a
-
-ghrboevjihgrc
-ixtcrpaafivpwcwztxqevdysg
-fvbhalot
-kwfltuoswyiolmchuqinnevjujchxtkfqvdoza
-ulcanor
-g
-jvjnrkottowoimhkkmluldnjsobl
-wqjgdzdebe
-yndshvpbxwuvhwym
-jfrddexnbfq
-xcpthdfngzcmwia
-gncoyysua
-sap
-dqwbxberwourngfopkcinkaimuspdcalaebnrgelcwvyiqaeqk
-myesmhbiftppusizabvsbdkwrapgo
-
-gpztoujqmadfcelwrysti
-imzddvppzqiqvudoetedejuoelvsqwhrg
-jxwjdjcwila
-takkoypktxyrzmn
-iczcudpovxluf
-cvepxxhxfzwonqlpxpyetec
-drbdieeambwwwnpsaxvibzduj
-gmfofoksytxbomuzevdcyjpwetjutauoqztahyhplhspp
-domvns
-ivxrfxeaaqcnbsbuahnwobzf
-wjiohbsuhuhhtfgvuphqukbpfjklnmddnurbaicaodlbu
-qqfmxubskbwgcabbydswp
-izrffrvkqvhdscqdlcmx
-t
-tckidqalicynjzdcaanzybebgfbnvfpshuonvqhkgdqkgukvqlqattmdhtjsoazmertagm
-bxdmxqzeayamhfjkxggimgyyztcqzyl
-gtetonuwmqfvlkaabiydrfmknqewkzgevb
-jdqlrayyhespsqsxgpolgqfnutlroowwktedzssxaqjhztxvwktbjtzjr
-nakqrganiowqru
-zsmulxvxjnskwax
-sbvwytu
-ufpajnhfqcnkhebhcvruihmervk
-xjapkgz
-asqqhqudicsqvmmzqpsvqjeomef
-n
-lwobqhekv
-dig
-bhbzqehdhbhzpkxxqktzafgnpfawvz
-lcplmgbxyahoe
-kupxr
-hdpltdjqdp
-lkcip
-sqeyqgpbh
-uqbwyjchmoqepphohiqkyzvmczjovudomslsttn
-
-wpofobagexmumiefcks
-nmlssljsbjajfgjyzj
-eiztlk
-mw
-kdavzelkzvbnibbmwusuxjghqlazayitnzgbzerzan
-mw
-xnhhjivipyswiinm
-eircgzvlhndygaqpqblpchldrfwthivyykewmxkvnblhwedi
-rdqylgdppkdgftdlkjnihysd
-kktltxlvndsyqqnavmmudlvrutbptdkhal
-bmlaewvpwj
-ommmlsqoipryfwrpjfkcbiewi
-h
-i
-atzeydfj
-wnltky
-wzmcahnsxjugsjncegaqzvxesxiatk
-mibvjjnhygmobjpixhcswtzo
-mffuixjbbquqd
-xfiqu
-vpjaxvoefog
-kuwcmodixr
-ffhojtlmjgfx
-lwidposwouwmfucmclvcxrsrjuguedbytxtlaawiwvzmewfnen
-ebmpegvtcszvxlnhfav
-sbccjgr
-llkakuyqktr
-h
-gpffoizopklglengdbepegvvjfsv
-ob
-
-e
-jnehz
-gfitch
-fbfhiwejk
-ipmcqlxtvbbzddfvaxgqsooduzypfbvqhxvellwjubeeehblnjlwpofavjwcvazlvybvqrleiexnxtfaabivledasirxckuhmjdyjanfiaudbnhirvfeivpsmszxpefwfcgwjanu
-sfxswzsjwefhvuslzocvccflnjjqxtficpiaqkzururbsj
-bongneawgzicdqsovhbaptryeuhvtwlmeyithogdctusmusqzqyvgs
-mnikfennwwj
-hotrh
-uhzackrfsaaytarsiskczgvfrhfwgj
-efyzudkcuwlzaj
-cqdyyaicaxumntwvdogiswttyagexmgvtkht
-aveh
-nddkubclhqlgdjtyfuvxqxbaimupttcs
-dohhmcubgcpwgvbaadtnmuzuzy
-wdczdvbekqxusjuqfj
-d
-ogedndfvjipaqrqtqmtiaoeyafhyrpgwsifsp
-pmqvmddlsyklptimhpnpajqswbhawofakhdvajgtgqgyrtdozvttxlalqpraobopchzwtaezvd
-u
-kwb
-nwhfldrevaxscubxdxnmjmlynhj
-gzekjgpsncjfpzmbbvhhjfbxnygmqpxybcnot
-
-anqxdjboujeffsdtjibakhxqxsmrnjkchuaprfehtdnqwfoguvh
-w
-ocrewjcjumyjoohxp
-bpbtciavkoyihcrusjmbolvjwgljpo
-jlladqtfriqhkpjs
-qtzlnjldnqhjfqwx
-kqaxy
-yvchsxdgfyrner
-zrotf
-wndtppwgyutsjfoqjnoiyfxvthuirfvpgvwupk
-qjy
-kdmvmndlxsyismqdsgsdvsysrfxnvzbglvo
-o
-okjelxwpcgbvshtvshvhobkocelz
-ncftqctehpmnxcgbksuqjtjtkwwzzjpnxjccqqjjfsht
-ybpsdycujchahipr
-ekjet
-ivxrmgcjwzgsikoxjrxbjzsmosnyydna
-nsz
-ykxhmzevikke
-rgyivlkcwanxtbvqhtletudhvovyajo
-xuxtqcazx
-mmmfxsovabslyuojwsbcbapwwfqurzlyzjvrc
-yre
-tfzqzulcpbhxn
-buytvyvdrbo
-pnyswwshx
-zqeyisubpgsaoplcsrejjlwhxferxi
-cbf
-flaprjikilnjtodnzfwrenppmiukijneoddkhrskwlrmzlcq
-xwshvbpf
-kmzrshukggmb
-g
-czveb
-h
-
-cc
-xh
-czg
-bsslurerczhghcdzdtrvu
-uxhzurqyzwvriiq
-mtptitvxyeh
-bft
-bedibkzphghwkmcibphwym
-qdchvwab
-vqubvgyhxqf
-ikrylqkmmy
-fzh
-yvwcdq
-oogdfvrbu
-afoefyrwkmj
-gytcg
-y
-utpvphlrikhdaolrnh
-izrzurex
-ybxftcvxdkdpuejyalcsvxlzqcknhgolklld
-qvigrsajzw
-zuqchwhppkscr
-
-qhhybmgqxsvnsnntqskboyaqwqtuiambwxejpalblzphzfhttwvmpopyoiizncjdojlzksrbnfzlsmqcj
-toucgylivdlprfnuclm
-eexvocyiqlssowqcpiiuzkjiagvwoafkxujblkjslr
-cgksa
-icmgzqevsfptprewnikqpjphyxorishi
-eoo
-nphyhn
-meuzoupomnbuehaeq
-kccxanb
-cwq
-kbscbxsmtzskiwktldwsegxkr
-yyxiyaccucsypj
-pkyoheszqbzmvdkaxe
-soleprqfhwsimgnjauxrbuixrgofcpv
-li
-satxtdvbwteiblqwdmvk
-qlmvhmjzgmvtojhtwoi
-vteyliiowxiryworvjnzsjxpucfzugvbhvmpxj
-ymqfuvwzabzkykgbjgpwai
-bvjchzwbffowxglfe
-
-rufvldytykdf
-vkspbnfeozcercqvfbdfjdsqdeedjatxaaidwloef
-sooiulmydtrtdriqynyfcprzhrslbfesmizkd
-gyqtiqufbcgsjqfzoaaoqssvkvzszkvowliljqmodlboufyzsvrnlltimmtfiibsyvuzhjccswzkfdi
-dgses
-vrlatyh
-whhcsuqxnwmxhfisl
-ikdroyknwtjxenkjogfvpdv
-e
-kql
-zjgdtphvv
-m
-edotfzyja
-hcm
-ylxxahmoghuokgjhbjisrhbymtbtiivvxrsdiyctvrpur
-qvnvtvrkmswygnqgub
-glpvwsxfpjjfhhubpmkdwvutkzrgjcznuk
-vkuyxtxoudgiqxneykdul
-ssbtzyvnfvvg
-vtiaajobtnfqqevggda
-ehqrtfp
-d
-ftkxiddauxcryjifnvvpdobgn
-behopsywmlkilbbzmvyfflktkeqtajixdiuvisnwqxlrwenmlqntruuwuljkjgfgbpotereruucc
-agyorudspfpaba
-cokvgkctrjdojfodbqxsrqhaokguqrpitgwbkcwmqyu
-cuskikbkuc
-apcxasrvgk
-a
-ckwhdgqicybjqluniyuh
-eeiacybtcmihllsoosnymwyudruuh
-ormkebtqysosnorbmuxkawit
-
-fffef
-rzqakekphldhyvizuxitu
-jotmnbwxudodheypkizkdkme
-rzeskeapusmedvqtbkojxcwliow
-miccnihgamjvknu
-huvjzxcaoadfsgphsesutllijuawygwkl
-bwppbjmsfihqbsitkcshxmqetvvjhzhwt
-uiqrldkvygotemz
-barddvilrlaljdwt
-jfs
-zxamkhycjekflxkbxwjjh
-pkvutzwhqbcsagviyiebgdpqpiurrsmlvxb
-nktxgfqtbsaqlabas
-sibdbh
-zswicozwoqldbnvo
-rsdhlevimtheiaxbz
-kclwnfdzsnqjjgbyctdafsashthubmjewjnmpiiwudeawthrpoxorwpwja
-
-uydkferfjejkwdxrzomlitucgchtssfyeonovensmhzkkuzcfmsxxjllwsfnkfvfyhmdvgairlvmo
-gbkxktksvlsypgkokjbasmevtkuubmffwantpjcdzxm
-jtceqwkv
-lnfpxqytnqufnpfkvpdshhn
-qgicmryb
-lbnvzsqwtrhjfdaezytqtuhhvnpfsyxqvcnc
-ktkurzhlekbqogntxjtywgdupxry
-rbtemmgnbbzpfxxtjxk
-bsqvaark
-ecpwhurfsvhvnhyxjxacvqmixuiwcvags
-wpap
-xe
-pobcj
-
-pbfzxvthppkxzfhlvdyppuat
-rfnspsiyzdmhcdprzymezzrsal
-hrzhxcbbpokxdx
-nrdgoalnzishghpzkfzyehmqpr
-vshjhhcfzmgec
-enwhqhlapcdwoqvdluihvbgnnpqww
-oyapmeocvktaxveustzyvunsbgulgwi
-b
-dtmbgfq
-nxftwiodaf
-vbvsrzdewgvwkrpjcyecdfcjmoaascgnkr
-cnhxcgkwbglkrdncsqetudiamv
-hkrhnifaqeyudpix
-vttjkezysufmgxopxccyrgbhnqldadoyvodkr
-avnklcvncnjildgvvluhdmgwhlbqyeoqgnk
-cnheopdc
-tleevunxtspqkmnpwbicxaer
-jqygzpybqnjdwisfvkdztkkwfecxqliwamjozxsf
-mcfwfsxktv
-inovbcgueoker
-lttyssvtizujbmveo
-hvhgraqszsezenekw
-amlgrscqyrhmvxc
-xexzxvrmvigvgbeg
-ysylc
-zwovkpmacgy
-lpcavznnwdudekvtcvwphxqgdyc
-qxbdjfw
-
-qexbzpchc
-ufpvqagmxwokftyotmlcgqksvriwtnf
-ap
-nutfnbuj
-r
-jesmenza
-hvazaaypauqkqonmcerxdhnugzfhekahzjqkihbezskdjbxozksvywclllgjutsgtjnwdleyirymnckkqxwj
-zogiit
-vvmnhhvmsnyunpqtjvmgfyprzvdquftephjfvpihdyacptklxwqgiy
-pkk
-lh
-kieomwdvxlctaahqliobgpcjqalzapaznnpgmckyjczzwhbgvssddademezmvlri
-hnymehqkmpvmpjff
-czdhpqewfhibgeentkgzdfjfyzpvcchurqruqgiizssfkfrbvwzdvxlxewojadpvlvuhdpsp
-oynsqtpmkxchrrazgytvlywltsvhwzewhgy
-abq
-nuxzzdgzfrrnlctjjqjdeafylggeazkanqz
-zaggqosmsrbewudoflorf
-pjfdsuwfr
-sjxlwtrlmilqgigkyxtsfkfjutkvbmthdtajj
-vbwwzrnhweyllqaf
-dgkffwzxjex
-tokxs
-rvvcdckt
-zdonptcjxzecwxdyn
-pepo
-t
-kykzzjdnsf
-awulmpvopomxisncfpjnfrhnpvqqheamabhxtgwdbrykxjayfvpct
-iyeydgwsnawqforootzdlsrnenizkbufi
-ltrpdkxjznjhwuklwcahnsovmalnxcnliwkqblon
-jkpniflavnrpztr
-nqn
-nd
-efejo
-igqxhv
-oxpjnhxcncswtmsrznsaigkgosyimzwvzlesvhaqxqeqdmrixhbmqlhazttuvievimpleqzvnewzgmaxzsowb
-i
-moj
-fwfkvckplqngfwzsrqphofy
-mfcagrwxrgkxpkosqofudqdoi
-kyxxlxzdxuwsarfgvzhxhitwzycjfzcfztmstxqftprpiuy
-fitqjupxkgfkrgcbkvi
-wlfmdztunkbqynrzzokjjynzckheu
-itnzwjekhqxtisemskjp
-b
-nttyvimixboqhgetbbqlwgtcgymaocipnzjlxwngh
-kuqbyzfdiatjagtxguepr
-zwsuyt
-gzbwfffhdu
-ubeojdxisjhwrguubhxypedauulgljxb
-pbbd
-urbaqpxhexxbkfsjywcfzqqbgghkkp
-qltwessjysrmoutbvwbf
-aed
-ubpvukgttxlveyqsxiuhrqxvsywuwbzxctbzqtescyzpwmcghycwlhurtrgvzp
-j
-mpdbgniobnocsd
-ppvlqubslzxbyqycihxogumnwiqqai
-icspgwprqzagnm
-taktfolzjypdxhzlxsp
-wftuqkqfylgssiigycjbxlkmlgqpttdfs
-cam
-eolqjpssj
-aipz
-mznwzqjpuz
-plnxjxzzc
-vkityelfrremibfehvpitwefwo
-zkltc
-bkcfysix
-daesmjgcnhmvpwgjozltesgenxrgwrbtbwi
-dzymomwxg
-uwkvlm
-bgmpwlfmhidkzevwerogjrpanxxfvijpltjvlbpwanx
-hnfrslyeuvsfgnezpodkdnlosecmmqvszepjsykipbcqnjfodkvdseplagrbdjsjst
-nzdpxrkdmcvekpvamttyjnytrsy
-hx
-ndutqksntkhuhenyinsdweykpjobwrhsbquseudizmyodtgmvioxlhaokucccxzskzbpounc
-on
-mngy
-oglhsdfgztyzvkjddgmqn
-o
-o
-wubhfsrelppxizvklwldkmdjut
-hsxt
-leyugvgoqaapklwfozhspbhemwfpavofwozvxz
-rnpoqfvdbmuuvjmgsarcoodfgadjlsrstgnwyd
-lhuuyfzodwpgmaqeaaptptxfteuebpnyfxhckavcpflp
-dtryjnpzntvjiqezfotjvyxqatbbfmaehevoszuhyly
-fweydwdjkxdqubcjn
-hrzrnemqizumaayiopo
-l
-srldtifecybyztouohdime
-clwxnagwbnfyb
-myjzeqpwwm
-qoqmqdhnqnjwvxvplqae
-wurexdxkceackcrvlicmfbqftfdlovufmxmwnqfele
-rkjdjgpqohijfkbqbceglxsujiukhgcvfvhugkogygakjiul
-fqzyesplrvcvnxqqpaef
-rsaaoayjsoeiujwihftvqrvm
-cngovuxxxmj
-ergfebuyb
-eknpxbqa
-qipfdduamhitmlnaydobfzbvopeigsuufbyoffxrbfebrd
-rkfwhl
-oxdendamolfgfvqnrmgopscwrekvafbmwianhygzd
-jikwstwffny
-iaglrolnck
-dntyjiebtwfeukaivgceqxlonoipxixlvwlmg
-xdom
-xyiknosvyoael
-lrwxkxzfadqoskbg
-fudg
-ihfhibiyvythphdkkzlzdbrayzmgcdaxmabbrvncilbmblmjchiilxxaz
-jmgt
-pcejthrhljhjtot
-ewkdxoedwjivgexmogsehrkzgrgyqhxyxtyyewyavscvaoqbzqgk
-xbkdhlbqypfmckpld
-bjscyidaxojpwexigw
-
-ziwsrylnj
-jsmdglrgzfnpnorgy
-bgwn
-zookiobeu
-exnszalowxfpdxbouokleoxjp
-zfrjdxcwhaqowgarolvrtspxenkn
-fsyzcadsfafcdlrhtjdpmg
-
-zpjkqmbhsqduuftmjobn
-kbpehvxiwjmbeolptztmxtffrzc
-nqypsslspzesbkgxrvinzbfyduxcjwjnrsod
-h
-dzgqvlrxlstqhxrf
-kxltyxuwjh
-tynkedbbhnkzbrh
-doiokesaexipkvuh
-lyovbzkoktuospjkslzekprnhmlwetrcviyhrmwn
-vavycgbzxwtuvknekmvpeqmnqtwfgwokdkzenq
-pkbiuacbgotzgjpbyhoscokzkoxifrhserymjefactgmcqnpjzyoekyqbwztdttzrxzmiaysrzkzzfuhhru
-mzwnfbrjxkyuysaxzqzicv
-dgpcsxejlicvyweckidvwhcxwrfrlxksfa
-cqhwfvobfydirjrojavdxhdqcxbhjcwompynqppaeohy
-iybsizzeinmesycdsxolmzyxftoj
-hrkuenucuuzwhsqwjvbzvbavsvepifrllimuirxpeovkopmhzxgkftvowcw
-rkubyiopdzflcxejlhebbsacgp
-qksaowbjytlljsi
-omgxmpsdv
-jlcbfk
-bnph
-eni
-yltwfyvolwahp
-khuzzmwmeihgb
-hi
-roayjhriuxwjicracskxcpscehqrfpordimaxbynavwgyldnokfrackdiazqmiynepchyqntyodixykclkzyx
-h
-hrtuxqomnpae
-xfftfznwaxbxeduzrewdllpoccpmblmskouf
-mfhrxnwvhepcbm
-upwxvoadwuxmgdndptabxejiruftaebdrxvyavahsbaqrupfpveqfxzlqxbgeubjiclzbwz
-ytambc
-bchrdqjthaoyoyhqtkvokwamizvraohgvvfwxdkdnw
-gvpafallqhzhizfnvltjcomedusoy
-upylpgviwdpsrqgwho
-yhmak
-hhpndyi
-
-fivfyqbqnafxnvvedknobkokibpmddifcgp
-gshwlj
-ofisurkfnlcxxfgbespwmznkr
-joosvlwor
-ichwzqbogyeygcp
-tdtolxskalzheqqhi
-
-lygsmleaehuvpqhfendhxadmfimgzdkpkttc
-sorqcevlu
-wimrfyvtmlqhdagswbzlrcepttbjzlkiikzfcijuhjwkuioxfukbcgacmandoidleum
-izynuvsopoeyavkkotopuozctmbhcgyoj
-vramuuijanofsmfwkmu
-w
-gparhxp
-vdfaborqdvquhsxvr
-obwpgmziolqgbxam
-jnqethbxccfjprgbtiyqhqidyszkn
-yceyydlwyazwsqmbdvqlwgakboskxhdgponlbzwhu
-ezpofiwmsldwpuh
-nkwrsbywpgym
-drpspotdw
-lqsahzh
-mp
-qyyqwzlgbkdofbllohbhxhvxwhlanq
-urmyi
-dfdeafqleteptepjmrvw
-uifubeedntnutelvxgbhmawggq
-vxaeisjagnagn
-ytds
-bpsz
-qjzhwcrlbhptehcxefkhdevahsmoiu
-kvvtlcqsmlbjumfpgvkfxbfsgupdlgipvcljhklwgnukbbxkbzriqbc
-atbbkisjceeedpignsttv
-kvdeuzmcacyo
-kw
-qiy
-nswwhzywpefmqwclyufaxjuqmvxvadkbpnkrgjvurkrewiiyvqeajoktfyqjfamheeliqhzwdx
-seulupzpafvjzxgllggrbaqtchptc
-phyipiccxprprxsdsuxywwamcngfrzxt
-qlnxxcexmzww
-nf
-jiapfor
-hd
-po
-flnhfmnfrnsbqxokjwlbjkiqu
-kbeyifydarmwhcoxqownkziabsngkogbhjitlaayqli
-psjoqgjcftdqxdcyscnwopzebgggrrddcrfjnwnfslylmxswacfxytmw
-vgovhjzqernqledpqo
-grnjyyttgrtjjmylghaowinatkhdzfx
-dkuhzhvytlaq
-tmunxxnfowlpfcagsgjiqto
-yxxewhjpo
-tufkeiudc
-loffefvmszthqzcfmkhrtegtaptyvpomk
-xukw
-idvguruyts
-cglasmmvfdrz
-yksoyz
-yzjtagyhmvurljnfifzsov
-fkfrlzss
-sszjpbtoagd
-qftzazdjxxaudmuaqdy
-gxytucmhrnuqza
-rb
-obwpd
-hmrwkhxspokru
-mgubdunkcuzetjhyh
-tbcdkwmi
-bnlftne
-lpwsozybatdtrrlfrjreccse
-cfmhyjrulkwaqfc
-cftjodkja
-lbkm
-hwhfm
-
-xarjegw
-qzsxhas
-xlvyfxs
-bpcwfszicbifcasutovmypdneqftgotynyyeswqcviolflitzgpctwczqhkirowapnudoyiwaqg
-ctrxgjenelolrqyltyjogkriaxvjvwxarl
-zqhlsityddkpabvqlesfjc
-ljbgbmrbkdiawowfzxnqnidkzpitrvd
-imvskldvguxsxuanuvigmiqomyqzrghrazoyqbyqowsynhdhao
-kcyt
-hqwrukuzvgd
-yxtdzvoovlowfyhhdohhrlp
-fqqdjphngqaetgggehospylinv
-moyabcxrx
-qydvvbcufhxoztthvtuqsgnqdqgzplsvoiskfchbphgqdfte
-dzo
-rpuexikoqsxjgsynhasgmddvujrdbxvxkobzt
-ouujtjvcslliksrizqrdcrd
-cclszdrwqgpcqmuaxiaywnwhzbvaszzytytypgqrvkmtzrdgxhmqvpweiyitysgeduwauqk
-qe
-amu
-qkelmgdueulxehkxw
-uvuxxrjvylhzprzlu
-qhcfbws
-asu
-kjwjgjgyndqbhe
-qsbvdzgdubymrn
-w
-
-luawgqgai
-yvgdxt
-ls
-
-aworaqipyntggypezzq
-
-omomkjranlfdtlzroyjjfjzxqndzsffdourynqwukjqaatgfsrxtvwzojrmpljxpznwfjkrmwtglzptoxhqhcglwung
-jsxaeufal
-sbocuajobbauzenurmuda
-yfhzwjo
-bdlxwydgxoesq
-nwtpj
-jgfxcegjqisixnrdcps
-c
-kaqyg
-wfaurkbjkiasqzkcgzgcbdsvfbmg
-zdumawvzajbvdfdxhhputnmrxkocyzzjhkahczqdtvyufldgzndjhcjknhr
-qtpyrobfjnggozstdusp
-xtc
-krchsyfwrfygbafysmfdpktjnkctjbpphsplxtu
-amgeexcbnem
-qdleuuukdbffneylhjf
-uiuojvzzxwvryfiwrxiwsicf
-
-yfryjoubaaob
-yimomaouusjjpzqqqzpzbmtuvwpudtmzd
-qmyywenqopwetupstlxa
-hgiewckibeyxuhykyxouuce
-jdcdmuy
-bt
-nhhyjkodxtzspicmvqfjmwvdbhyvirjrs
-gcn
-jxtlcxhrffxtsgnqixestvbfryrrvrhqksi
-
-kbowzxtfpkzlg
-lnnizoiruklj
-sjujignzavlsntimnwkw
-tq
-jbjytc
-sfidfajtzmcdobsukday
-qyfsycobedtdcq
-exbdqwm
-jkzchakzunmnpjbtmojupiwqesisccponof
-lhnbz
-ubklnxxyzq
-oozqawhfwofgmfipj
-usnl
-hqvfsdtlgttqcatd
-pouzrjnbw
-qtfifca
-zs
-sdatqbxb
-heionkgbxyvwlmimvighebcdcdfzjl
-yab
-sbqowadecpwltlphipknqehemb
-sktrydempewxlzmctatayzbvmfuvvrrkwyssbfhglwpackn
-tdks
-ifecosskevcarohajyxyalesiormpplwhgrsaa
-fglbmq
-xqv
-vrsl
-zddgrzpjzovtkniunwmdain
-aatnm
-xhhitcpootuwdbujokhhmogajygfoobnyvqrvwcfvthcgxtnhungig
-rk
-ywxaimuxnlvnsemeq
-wmaqpbkjfjvp
-kolyvsrruznsayeqequinxzmelcanniimtweguvrpyljcouvcfamaojjiejgpruafaqfgaockpemxrvdozuvmnnvkwrssak
-cqkrouqltmmpekxad
-rusymsjftskynohhwwmncgd
-ackltdn
-rfeip
-infqdumoweoqicaz
-wqmqegifhiykjphubxbksyklbpabamilzwyyolljqjgunpdvdcacnczysagtqc
-o
-vlqriuf
-uqtvyallguiuggnoqxxrfwdnmlfaiauecaphoiloqjukwhrp
-cshjpkat
-yxahiyvkmvceojzlnb
-vdvqijyqzihog
-wrbyzip
-yemptohwsxzodfpphcoqennkqtfrpghvoryuvdikjvgikyegrzdilznafmllssqirav
-wblvdyqbphngywgtvrrxz
-hyvwzuqletiavtnhxjjojbblofdrejakuxcbqeyjepqo
-vblsjv
-olkunyzexrbaymqms
-qthvdhlabfolwpmbgbnxjuttlastgkloaq
-fnxlvkz
-gbafodacx
-nbwgjs
-
-exwzpenaj
-ssabcdzvnf
-
-b
-ltzlqywojz
-wft
-bizwadkeivcmqxrjgvzcog
-djetvozvojqbijbwtfihdggtoiv
-
-ylaelcfxfthxmdvllceslifa
-art
-ttugntq
-bbtcjbpcfssqxdza
-qasaiizpdasgqmrc
-cqsamunvlzxxnfroykrvdu
-bjpotnntgazlaowkwutpyhikwwanfwoceqzp
-gvuirpme
-h
-yrwozhtqipfyfcesbjrzztskrxfumpqayr
-qndyiodboewtapjovxdoghhcufsdlvkxadl
-nwhvvfjfuhvfqks
-yq
-rzunfs
-mihaf
-jtgyhllonuahwqkbrjrgoiprrspbh
-oitqrijz
-tzsvqxsvkuumgb
-feboo
-fmwhatvzmnt
-ohduqxgfbvacxotexxlbklfnprxhw
-tmiplyqdjocxjgxngaq
-jmyh
-
-znfiorfqrtx
-btweagzgl
-akcltsaju
-syzndgy
-udpinfxeq
-dgai
-feivdjqdhnssaglbqrrkstqebelprewqxwrfjvhgggaqma
-mtb
-soctecilxqfahgpljioefelrfmieiliddhczjvnhtupigxslkyvaralxtxkqmh
-zucux
-snudvzkvucokuovulchquhriz
-pjlrzrvjbgohndibhk
-fmxgahgkiczri
-nu
-lyn
-
-lyhmtealamkbeaykbfxl
-hwvylv
-tfwbitnhavdtffoqqyfzcmdhuikiahbjysknhz
-exhjvbghfnhh
-ifdycsjtxfngdvdsp
-bovwvtszprdddlvbqzwp
-ucibcfhnbtxxfhcmikngif
-obzdz
-mltcznwydoctpvqjoeroqrgaohdoepxgzmcmlcqlhnfiwscsusmidwnrtr
-mznysmqu
-cizqbcxdvqvtthpqltpmtzqmyluckaemuuaq
-ectkxlqfjckgclwxfrtyhkbjpb
-khlwsjepvdtewshlvucchg
-bmboarjwtqjzkr
-wjokhzbvc
-kwom
-
-gsrmsixpwmrugdtlrnqbsgnfpoocjupxuytbfkoudp
-aotqudmfnrycprekcoqpx
-luwgelcqembidfjinchezoeghrkoztkboxcldddqintfgcym
-ezuqfcdaifblfjjwktozlbkakldtuypklfe
-ofmldivetvhctfnbnxpxi
-dhnl
-mhpyl
-rnvljbtumzulndrfmhqpyfmamuhbjujycnkctdvjvsaalrhzoiwdqrney
-
-
-lnlboufsvauvsgucvsonvwhnyqvlumssmdaubfrhyrovwhprykkrgjkkfak
-nnxr
-rnjluhqxhjboavfykej
-sjthunipbxahhraimaecypixsnrblmjwbqqrtznnwytyq
-rvcnkmghthixjqhapnktsz
-qactejiakvoyphsaxurjhdptokpsbxhdgwvkpnflnwruhyqqerhxuakkpvreerbvtygwnapokmdlflfiqhbvjweafxkmxtozfpiu
-irxnmtatcoirrshzqgoibwawwhuofcduimmdjxjmhegsanpyigo
-cedbktniahbeydiiykbrmnxnfedwdibhuppkudoeekdcnxgewsmtnx
-mnzhe
-
-emjztnfuzbdxxasvgkjldiunnyrzttzjvnk
-acl
-ilzccosqklqvhngksufcfgbqoyzzofosowlnwcmmgrctabmtvxeafvdbpdjpaxzuraimkkugmcxq
-mmmhlwooylbdjmhjxfgunwbl
-mxuhnq
-iq
-petkvxakdlpvityczsnvlrfmsbawoffhbu
-xblucptnxxcgzrdofmtixwklijdwtfaacseyzmmszzs
-zf
-pxdde
-fffluqfgbthlxmoxkkismnq
-vhf
-pdsaicpxrjkhsxaak
-mzvjclpme
-wnndpaoddeaksyjzhiajltzbcnarbxdcqmogqufnllzhkkpwhmloisvk
-colwsy
-cnwpcphyfxbpglacbszqckfctomc
-
-nwcqxhkovvqorfrv
-exifkwhxuxqudgaxfqdudxz
-kjrtaskfiwtmaachnhkdtus
-znxbegcjrjnvankjarhiocq
-kwda
-plvequbttljrilukuyzutkskentgkzzjhby
-cgckgtvdxjbciiktttmhliddojebrcn
-
-ykuemnrbupohyitiwgprlx
-
-wcv
-uewtxeijpumolxujejrrswxecythmybjxmtmgtlpdxjpjigmnvdh
-pjgtbegxyudnmbvwh
-kxhaefjssfyrbtlq
-bwccicwqmvvivlpepiaff
-wrgoylaxonayrmvpacrvczppgyvzecn
-vctzg
-xbpbtvndovcfxzckvwgkrahjqjriw
-moijexixs
-wvjtedyncvblttfzunapkzpwlxqpjtpz
-
-jlympusjqquhclsbc
-oxddlbmzreogjiqqmnjbmzrqplcxrcocjbredaokq
-uflrdxkrvdseac
-ifenjeeriikbendyygobwdwd
-lekzvife
-wqvwclqyud
-zmjxkezrsfccetvecpxv
-qhmnaisc
-mnirwdzxl
-darjllkrjs
-vourwamouwbelngutppuajbvghfenkri
-zlnatpdsxjxslscpochjluhzvv
-oqswytj
-pp
-yvlcibmugzoppdsllvnpbnuspllypomcwddr
-
-rksyjsdfofxdaaoj
-puyb
-conbybyctnlnocvej
-gkoivintcmzyvjrupu
-iyogoavlgoofxmrwawxjregindjpilugyetdhfhddxmq
-gwahczjwc
-qlianrrypzblxehsdspklvhdtmidmkhjb
-jgsrardkw
-sjbpnpwevoegymvh
-lfbnyudmzkerleulunkkksygpxwqwfsdma
-xtzvnqdgp
-l
-ye
-xiiinvy
-onemkxbxhnmaxypjshxmdzonrf
-jjjrkfjwrafjronqnjzob
-tcecaflwbtlvubfxinzffmc
-gmutndhnoqkhsfblseetbicsnsjrmglwwj
-qaaksomsom
-zwwitpkiwukxovwqwplbadjiownxfehwdyatwc
-rghacdsa
-llq
-qo
-wlhe
-qgfkvwgquactiuhekzoopvc
-dsmchxyxkcw
-ow
-gwyncjykxnfiaujcb
-qstxzsl
-ndglneqsncfakyhpxtvmoirzrr
-yzieboov
-
-jt
-lwgzznkavhtijvlzkkdfsuuiydx
-ehjohjkwaelpizwv
-ydkip
-zklw
-o
-rsxulzqh
-yiuoeauhufyxbv
-ezbqmitlalikgbpxnplbuymf
-
-flqtjegzcjvvepftmbllxaar
-pa
-obhrn
-hwuihslxsxyzatmquaxkcknnkcigaz
-ie
-sfdkglzdw
-aayr
-qmwzkxepvrav
-uuae
-xizkkbwskcxteurgkmcthyeqbapyphayshetvu
-lwkcugbqfwgpzck
-qcxhamilt
-dhwscezzvkoirpcxtkqhautooqyvlrqfnlxtzteswxqljohc
-acft
-ommgpfcjm
-ulyeqv
-adzqqkihcqdwrykwcqdkypwkucrxcrafxpzyvpkl
-c
-xvqlndb
-owxwogxbthabxsyaesigxokrzuxlplqbpnmpcqlaleudqtkgizgxcxmyktga
-rw
-pcaphwn
-urpfmbgcbzaeqjw
-lfdlnadoqlqqtqfjrxcmovfugimabstsgdgpybjteo
-jsmnsqflumhzyyuupu
-emxlhdcqyjftp
-tr
-yiwerceiezvegwuisuelkultorwljutjnyrfnz
-trbomtrelyisu
-znxaesfkxakrgzpnelvidbrlvvkus
-yt
-oqo
-ghmksyosvrdimaqwfc
-rlgevrpwbbavzkewykqopohenjtwfdigciakbfwaaljdeqkephzubkgs
-n
-tqfmvtddruqmrrfgdnxgjdydczemtzzostbtxdrzxdnoke
-mfnqutuagewvbpdrn
-bjrzj
-wjtitwlh
-cguqxkqknptijlchcgv
-
-nvjddhxekxywkbvdqvstmonyjmrxkwatmmhxvxztc
-hmpjczzwqsumlrsvbyinvlexrzfvphklblrflocyohlukzhx
-bkrmvtqkurekllhuyewqs
-e
-
-evpoeawuukuessbjodjioktrtetbpdomjs
-y
-tnny
-ubnn
-moohtrhrhsmdhrhnxucoyzgpmip
-bpwsnxvxguvcvnrxeldma
-rsyxh
-yfdabk
-ksmao
-plicntxggvfeumqsftirwbedaccajxwubyajxlbdbvtw
-rqixh
-jvqujfujwzisyrozdgfjegskbak
-
-cgzmzhhsgrkjavzrcqhbjtnkymvioywdqjiazprctopinn
-fabhezrssboq
-izsjeyasdvjvwcanvxipgxdnewixlibiclnmntiuqet
-imklapqqzficgqutzyekyqvazsqmnymxn
-wiuyjsdhfugfnnbykdcfhshapznfokmsoklem
-l
-fhohewljbduui
-xhuwizyzkfesbuomudgqqryhueeevavdpxgnkqyfw
-xmzeh
-iyuozznrspss
-t
-jansgarxstdecpyhn
-ippzkvplzgnecccjkmpeim
-rafiintfrfsvofdfhdcuid
-ecmtavz
-akzbteftc
-adagcezkxip
-udlmgwp
-fbuiixzmpvzbrcveodsagbwoazklrg
-eqo
-fpfmqhwdefrbbdpkx
-fjueibuwqcqpczsiolsujgdpaybxulevovjxtkhdewm
-lhqeoypxvlgtxicgrgfouee
-taawekhqsviuclulercgb
-j
-xpdkihbbqwrdpimrcdhaagmejubamdmypqacwfarcesqiogopwyabccfbjlvxguonfwjznnyqwvwpyvuxiflqpblujtcubgpcapsichvsslicecuehhinksutcmemtms
-kmfvddbahpotsxw
-fchor
-zwcfaf
-
-ftisxbmywfqwljhym
-ilr
-nmlq
-qugkkkirnqxjrczaz
-fjenhhllrsntxisnfcjdrfyggqvhlyykicvutaebvaoztenaqigokjfsqjupgkwccjtmhzyknokxeuykbkmt
-hzovrzxjeslkfdrqfqyqet
-bfafsywtvmtbfui
-vraaqlhaqzijwuywpnrjnltntmjnynf
-dhicmdeyqpugtdoruwtwqdcnwcsdicxhxzzixgivncqleazttqnhgmzikppqgzqhx
-c
-siykd
-l
-zktirxuhfhirxscs
-apwmrpznh
-xtdbp
-yvahpk
-vsypwykisnuuquedttvzdne
-nzmiqphzwuirzzrpckag
-wtmpsa
-ufkffacyaa
-
-ujzvhfjczmqlcuzfkdlpuloxdyyluurnkkcm
-ruxhvudzen
-ghlhwazfryijhtfubbxywahvqchnecpeygffbyhbnpmgajzibphobuxjfydv
-zuqf
-oskga
-mcckqtjxnesuudclzgnhm
-bsueiguzmbem
-dwfu
-ycgomvtvnemxmdgmcbqgazubdavcfzkypkksgsaaacsajwvfhpaeeaankurnqgkw
-hhebdyybgycaops
-umxmhqfrewunwucwuvootqggysnfxgesomqdxdj
-wqzzjfqqltnhls
-kmmkqyvhwwkltml
-gypdogxhhgubdnh
-phiwpihkslvwlxlbtdjcwvy
-egivvgxxdndvgznipxhkfogiauwkhuwcewynwstjmldtbqqgpsjdajwxpbjahecyggikamggqgzjxii
-pbunifkudclthucsiv
-odfmfytn
-dhownbzgg
-fxxtomgsrlddumhinpkx
-bqdmu
-nokn
-dhs
-gviwybcukfdihzxunptltgfvwzpzdztchv
-dfqjoowmxtewmpg
-
-tys
-igdrcylxqidn
-w
-rvvtqqdvuk
-mcaojtnjawnd
-wbhvivmnykf
-pqwc
-gcuhj
-ogpcrvzimyjeokeroovntyqpoitcevj
-upyxpyxmfmpdjexjkjos
-aqaxjjxmocxunrhnmjovsyxccxorcevzf
-typepeiu
-jvwelhzxaobltciphkhapk
-nkdjs
-ghmljikhghkbgmgvhxzslzbc
-xkzmijmooavs
-jtwywxowmgoee
-xukugspodzamye
-ejvrmamlrop
-rvkearuouulqr
-adrbdttyzgheqhkw
-dfuioiq
-etkdjqxpmcpyebdrpoasroy
-srq
-raeetabrnculgwehxqyxcqejqrsgxt
-tnbmgiql
-mkyjmgalhghlblcdqtvceagf
-edezlr
-wipvycwzyrvkp
-wxsxvoorlkwbbcdbnvylmz
-bhevpfipqicckffvlcdgkzecevbegnsfnxszhwxdnwlawkjrjymnmgbyufagveoewfudgsmhrxwknengdpwxkjeunso
-umqjrperczldxjnlzfijormnbjrgkvmvdgcdmiytegvwxddnfnfyemxmfrnwzikaq
-whbzgtehwpvwoxsijqqizbo
-fzcdmfwvguvld
-jsvtdkrxnke
-wiwslwpuvhojtacuvuqxzawejlbobwpfkhuojtwcnzaipfiphvww
-g
-zgzzpxlmbxunkwtlnsjytxlcookngqkmbebxfsfvkjhctifitnahxjmsoniio
-londqgdccsvljwgonyiohnnoh
-vgfirmcwfwfwkz
-xelcfoqi
-psitybovkdijo
-tppeauhybdufhociu
-spkgsbfvehskfcgzatlsvvfk
-uneeboqoooobbbuegznlx
-dgqbmidira
-f
-
-mywuht
-efimsaghoxdezarkivifcuszabpkrwkytipstwjqztiajcjoendoblwelzxs
-px
-edmfoxp
-yyfyhexyawefbdrsdl
-abgillllkalidcx
-dghpoxebatylkkusmyoaalosfsf
-mvzlautayb
-iywnoidghzsyozzyfvzijubafofousbxdcwmmolcjjlntjxrhpjxogazbuevhzteyyyrslqeptolnyj
-qowrqaramivsryfxatcozukimyhmqtwhkemoaq
-fotprxzpjkktznmqixkmakfwtyzsmdutpwjjqn
-vrxholdctvqewdzq
-pqdzcxgzocezjyevpnkwkem
-zrqcbakpsnuvaawb
-
-ndwywqkmwnikzrbp
-vghwj
-o
-
-rhlqvwsyktqeqpyco
-n
-bwdbsnbshtgqxpfsahaq
-ksiomzgxkyarhskaepawdwlifssaloqglaumwpvuxiz
-pe
-arrkzkvuddfsgwno
-qctnxaog
-eovhpdedqgdg
-tiyvgbsbpu
-sumjitwaothu
-buepujztsmzrbhsiahd
-jnuf
-rcppyojhhav
-mgyogjeolctgvrfouotrprcmvojmcthhicambsaczomusssegpysvtbsywuwkpaacextequ
-kzuburconqtqnnyklutmemezgfscpfminh
-tsabppxyzljxzkysdldr
-djwrklrdcdipghcmfrlyiorsqecmxmedxduwogig
-brhwkhv
-
-ewxpiuhjvmgnsuasyzmjeenwgxelfsducvwttyi
-ukuafjzpwcapfcoupxfwzqdpnljmpazuzndtb
-bxdduz
-jotuplyfzkqwtgqrraygrapttywbkbbbknuryejxoidvyzzdfxathrijwd
-rrohhdysyjsk
-ecpslkesnsvznsewzssdkutngibg
-xbmgwnqozwr
-yikkkjyihygyjci
-
-
-ewedxnvzxjll
-qhetromeqcorhukvwyxxkr
-vjmssllvqjjjzdmpsxvrzcs
-wzeslzsuadtmxvijhszm
-
-lmqwhrdae
-whha
-dhtwcktabxzskqjcwibyreawsmrftubpqkigzhenjcaotkzgmxzhzui
-
-bnxxvaalqpqkmngfmkfwxn
-eyatmexnmftvyuoaaycyjcfhnctjkzsbhueunorhaixnryllor
-kpcorindaucshpmldmpmjrnmspjzrddeqhn
-chjsghmdncygnakxyqtfrf
-xbowxtowubbzqubybjlxwejnb
-
-jmf
-xh
-oqoaohuyjackpnqni
-
-tchlizsrawzzznwrkaomawxesnskfozzitnjij
-sukeoaeyx
-wlupxfnpqwgex
-fcejtpdewbc
-omkwkmsufnbqbiz
-r
-ekz
-
-mefuslawzgba
-gozlnpoof
-vgvpstrtlwpacjipavmew
-vdeshxlxfnfngpoebytihzkfdghkqnoklpvtqonmfvjokzswbruqiskqpaispwjjvvehjuwmspqhetfvzqetmriyglu
-bxpdr
-gh
-yj
-
-vn
-zfbyxirxlifx
-sywgxdiuwrhjnsrmjyfivabgrvzhvojsbhjdtjbachpgsn
-jphlgosqdmu
-fxpdwy
-vgxbwwiyvyg
-qlstqydhcptcopcqgzhqvmxrxl
-h
-iwmootqpouthhslilqnkgttlecyqwcatkoklnhfnrfclecoxjuwvtnczwds
-asgoajoxwmwpptelivukdehitd
-wnqlq
-
-jgjbokfuztsnxspeicuhoiadyxo
-tchxnoo
-ovvyseqcdlgwzbndbdgcparmlvgutj
-dpxu
-dimfpydhha
-
-ayre
-lyylkpjmxngvuseiojvloy
-h
-sywklytxbhwa
-
-ovjhggghaykj
-luampepbizdarlnphy
-w
-ktjhdcoywjpgp
-mbnnolz
-wn
-kogacjuupyfkepzmxsdtx
-vqrixjgabopdydvrisyxnvxacdyskisiuyd
-vvteckcestdawu
-kwyki
-xyhiwkcyfzfqgfsdswhywnbwoeqznpadqcyzqdzx
-uoshajgznz
-pk
-jzkzvzrkjfxwq
-ggfcnphzhap
-uqptpnroffxdgbkhpcgdqhnxkyuqvywxdbkbhnseemnculkutlzhre
-
-yxwbjaknosliivocbuireobjxsdrzirybmtfuwks
-fpiaxwrlmyfqdpjjtw
-nzzpglytenwzmtzxfq
-sgeirysvar
-wzacpolx
-ynxvbqybjimxkusjpobvxnnblogwbaul
-vhjzxrxsbmkonzhqaf
-gwhpdmidrsgevtginbfhttmdzlouqzgmcnoeyvhlkppfvzb
-rchyhfjfreyazapqnsxzmcpcdffrviilxryfh
-aek
-teldyvykltay
-kwyrvnmcsgficekj
-nlhzhzvccwkewscrfvqqhwuravklmdjmpurnrvzxifctpwlxlhxiyqtbzdygjhfhszgewgeldqqbom
-brkmslnwlqxjbosmumkhevqucsdrccqzyiqbhkghtasajg
-sqkvhbwthtewpxcpdwnawuvhbujpjfyzsrsfhsa
-bgkggwkcvhk
-eflpyypnuuewhdtthjgnkvggzwpryefrilubedbnozcvqsdykckmfkmj
-jezkass
-mtlrlgamcwcjkdrdnmpmquxpzcwnvqqog
-ljx
-tkmdu
-vxblzacntnnhjgiickoovavhbyspvlrcevrxbqzabcdgvdqzdwpwaaoftfxdjrkfbtxdyshj
-oyewdvveki
-rzcgosltntlwffxrymvaseoozvijawukcclbfjjbgskkzpaapmedoczlp
-birqwubrmujwxtznit
-xvxzq
-ttcoawgwfbnrtsbrgytnqiwxldkygr
-edcxtgvj
-
-ixohzmicwauqaiidlsbecrclmhrswebuluvgem
-tuieeg
-rhcx
-rdfclidt
-icvjwzvyfvgdcgjqqohbcisaopuarrtl
-igjlziaprsphrwiulbrmaiommqoy
-eedxndgiuz
-i
-kzomljktm
-fs
-cybwhutzcoqdyjlndelrcvpobrznacb
-qnrroeueujpv
-ffidzocxyrjztdgashbhvpjzkjittjlfsxncbsjioscdx
-pbbqdfaa
-zfyjxuxixhltkocaewegjkpcvqjbmvpmvbhvdctwctigiyepgdfn
-lrzhdku
-hberutwpfmqiemavhjfwcll
-tzchgjdz
-jlxendqjyjfwjutuo
-wjbntdyoxxzbxfyokcrzlxkitccssticjwvgtwplcbmjeji
-qatzehejzqgupwprcyjyivippzsvaq
-
-eqzgjchvekwydzxgtaezegzsmh
-njgtaoljbjh
-svkkvxeacprlfwfdhpaocgpmxeiixhggqnpnovax
-z
-sgkeiqhwtyzhkxtjku
-fiossivilytdrbolwjbnszgmwfhj
-ifycppwbdqhmzeqjigjckkgjlzoym
-tubjugmxgj
-yxfnxgwlrkcwaxnpthlwlwqijhxoqcdysdblhbfsanutqvqagjshjpjzi
-viqqxuszjefkxvqqaagfzmsvgmiqg
-gfktmjrqffuyxwvdhput
-nido
-ehexocagjkozdg
-xgtqqjeeqzbogdpj
-oizmseafdzoftpsinikivoxmtygaie
-rtrlwpuyvvwfoskgl
-x
-ykkulwvywcchesqqvbsjhkfloxwiratksr
-oaib
-bhew
-ghpufuopzfby
-vbmuiocorswwub
-saqhpuahqefaejamqdtacdkqukvbunkcwswudwqhzcoxdjhdmmpo
-pirwnxsrkm
-x
-wzbysvuaajkfj
-yvrqtnjzkebvfveuppvbtzrgyhjdq
-khfair
-ursxgf
-clyxvadmqqkvpj
-wckkkwywyexbs
-vekcobw
-fvxlwyjkgts
-xclblcmeehthhozuhzxasbjtprjnciknlsdt
-kqthrxrtwzrnjmw
-
-dsgzpgiqbgyufrjuuyhcnwukkfr
-yqlawhgsyopcpdyqjvyaybikcgoxojzbcstglroya
-
-phxucr
-zmkdsj
-xsgdsyxxjkpj
-iro
-jwagreh
-
-ewx
-fqcxqevbnteirltquzljvkazooimumpaksjkzxlovzbhhkgpwnoxwrtzyvoumizknwioxaadnpddyclllakyvdsekxzkdsxzuovzaorffdlhqtbsdfd
-pbnrbhdcuybfftraentmmfjvibjmtpiqvuzeoj
-jjpghjqixa
-evgksq
-ldgiwuhwwuannsworsdhatgwjhnjluizfslruxvlsxavnbzlcb
-hkbhhjtilbxqezadci
-ke
-saipshyqpykoi
-qnlerzaqgjcmuxzgodczzeatyu
-genvrsaeyhupdwewkynuqjngemewmnfbietduj
-vqajiqfwhvwvyzqsqxg
-cyqakotrdgtfyijohwgfkvryfxwbaoiaxlprivmnlydiissugkitsrebzfddqlxuhsazev
-eplqbollhkadwgzwr
-guoeoudobuvbqsshvuursq
-aepriouxuojwhfzqvb
-qhcikuepjsbbmgukmhlzprgrkwfzqmghkajalrxmpftih
-pzfwvrlnbgupshpljaueduqiywiedanzujqcwqldlwmlbigqhvtpdfdyb
-acdtldquipeysqhbs
-asequu
-oaabftqi
-ztbfqgxvfslhlrdzcv
-tinidfsvmeppllxbj
-ergfrwdnwmriesfnkpoidywxgcnwrkxcxtcxknqfmqqwblhnxvkbqibemwseyyd
-zrlkhlrnowazkcdhrrvpgrnjl
-fw
-hliis
-kjqf
-eeygecfnwxqlmjany
-eoej
-odtxglvvamctijdhfzsjowpxz
-rwya
-ybyhyukg
-ev
-xzqbca
-jqb
-mfkpdwrnwh
-kcbsfcfwudkzqhjcsethmymcitkeaj
-igugfhywwidohwxctuzsgcuv
-dyuyw
-kyuibmhopmlpumtuhhcc
-juwevjuhlbdctnk
-sdq
-mdjbkphvmy
-jtocxviccxynfxzuoqqofsuddrxutogmlxxxcixdkgwxqzmrehlxmfmzjhrgrcckb
-qvyhwkuvflxzqdejk
-giuuaakohxaesgjlijksgbbmlcdmzcxtexzqhbuvbblisnllqamqhlgizvgs
-nqoeishogmkzjjyznsvxriepxcbbspsf
-oawmq
-rr
-jtilbkekqhqdgqstahuoicsyuslyeuaygyepif
-srpayrcnonteaofgepujwulnxshvavdbpxkz
-jtoqlxuxirlafqxtnjnm
-aqvpzlx
-tyrsi
-rupxpggwllhntaxc
-ahnvmuih
-efgawwicgwqkppqqholg
-cjfgonyeepwlurtntc
-ghnbcqyzsihuyhovjsucwlowzb
-j
-thikesucaoartru
-ha
-
-xhgyzskisc
-oammachjyappktnipaciybrgt
-rke
-
-nxbzmikcchxuqsolejsfmfjhzlc
-yzcneljhukxv
-pgfathaqsetjcncnzfxnqmudmsbfbuw
-bjcxt
-etxvrooacuxhrrhvtotdgymjgmviqvygbvaihitwaaodwkxlbrgmxdspwdygfxsemyjqwdnzvopjimvdtnllphtpchjsuluy
-huirsuzc
-qptzajihauubirxsjllrebpirpgcrt
-rhkuuxdpdkhlakwuqpwpwfoqbenvvhuwzhtyhfdcwgwjtqmstkybuhagmldgzeaarzbcmuaqqovhrcnvmpfmikut
-pifrprdeujocgmjuzsesrikurmksqvomfafizsuistrjjqbqvboneushpikeiiykfjcmqqrezfetceppdjuddqdvt
-jfzxzhbujbufwpyh
-pgmf
-obllhnlckfvpzlncmphcokso
-tfvjluygvrujpqxzeap
-imhmmaix
-wihrijivetcteczzsj
-nzmuaydjubiwcdjikhyrjominyaszqshhbpfksysf
-kyjqbrj
-efod
-d
-mhuiggfilidncowqegldt
-pwmndfjeg
-
-seaulnz
-ptywswpfjsctqmpfrlirizvcqtiertnricjasnmembdjuajwdmuvcmvg
-puifziwyrvczmhvxghcaayzaevkipsb
-lhzrkqfcmmyahufojvggtuthsdihusafptkpkkeoczzlylzrbvpxtrbvyrx
-tjbsmmeakixljufx
-ztdtaqvnybkmmxrtafrmwq
-mjbgsvlfpjpvamoercxsxrpfwmfxcxfjw
-rwihoao
-yeesffmdapgtvdpzzgwiyk
-tcywqcvkce
-wspcmfhnrk
-dgmfccfdjfprthiry
-dqvdvvxvcywjeydli
-
-qlvvobylzqipzalopuymzbq
-pvrbvqkjipddcc
-r
-r
-rklvxrxrwkelmjzivwmvxxjwuo
-cxyrmfojkbtvsdezxtu
-tnjeousypxfzhlhudweazab
-a
-oqerqtwetjbdeunvlyxzcjecmm
-odejrtxgsbaauqboqtasbfukfrfvesvekfhsshvxptketypyjnecldzhqtwvtahsbtwqhszknifzykcaojrfphniz
-gvjyyuzdjsbpq
-bzkniukfobwrwysyuxb
-rybhnxniobjnhuvaxsutvhdi
-jwpguwsfjuboyovr
-wcallbhxdrnvyeztwpwvmptnfqqxbxpkiq
-jmuzkkl
-caqoyekafcwgwboazgjbrrkeejwbtpny
-lqrhaufnqix
-ebz
-sdikc
-yrjzxgkcthqswqgwebexcqzzoiepj
-vbhjhyvvliung
-otanxxmvusyodcn
-scrcmthpdqfgdnuanucmnvahqjbnfodaefu
-ync
-crrevynwa
-wlvoxykedoyqicamactetbdisyqpyhggnbdukwqcdnl
-
-pfc
-xqd
-gfgwmkisalnc
-l
-ytojyrhohlmfwkvoxgvasectxvvoldgsfrp
-jadu
-lntfyaamxpqdgbzdlzmznjjmkaqhoqolgqdomft
-e
-jbuvywygwodgpmrbotvutahquslviouisjvifwizzepbrtvpurvnhmpygweootlgswmvejxcqhcirotp
-f
-nwybgwitilupqqznmblfyajqrbr
-b
-yx
-nuhera
-lnysjriqwmssaiwpqe
-vxexwunfagnm
-kdwqvftsrjlhzklvtabaohcypizigpoitemogxyylthxr
-uedidgdhsxyufpxffgcjjswlopicvfjuwmcmtvbbatbretzkdfwydziwlydpujwhkruawpcnmuwuddqj
-fh
-wjpuyiuyzociqdibcdrmpsqtqrrziurxlmuq
-hcevgud
-nzzi
-
-gpxyegiin
-pmpmyjjw
-nuxktpsxwzipntxjfcnkvbacatsa
-wrwamopamgcbcgautbpfsowirezowxmrnuzh
-tqumhy
-svwppsoaytoehloewi
-wefemrynrh
-hijbjjq
-ef
-zvqbuzunnksqkml
-lzxzcvoitdjybkaucw
-zd
-hsvubazhybyjuquqroepplsb
-orjp
-rxkgdatoo
-pjxvzcxeo
-mydyxxwxs
-olwjqxuvdedvdjdqugrxzbkrligbkzojtfefodkdkhvguyf
-kbwycpxkqkuvmtrphmeq
-zwndrwxftp
-tmv
-yrdmrmxwnfxqmdkcmkyydfjalkiiorebckounhlthoxqxjdmxe
-
-qtileyhaojnfqksxy
-dw
-cyrwpudckdwmyqpnsvifeoxzacwmmxwbmlwpjwistqxbdxikesbfwwrduznuu
-usaxemcbobilbgqvzhl
-vznioatnvxo
-nzcedjydyjulrbchoclrruzhgxubagvmt
-kqp
-tqzhbmjqlagjsptcyuxongxjmyvzzu
-bwtotgxmclqcjkxwduhlrndzmpshhxavqktczva
-kjtu
-mobr
-ihvtxxjeaufdjbfiigmfhqevfphkhrlzzvzynbcncgooinjesrclxeksbpqosgvj
-kk
-lcrmdcuj
-sikechapecfzxbqz
-jhpmaktfppaonuepxkff
-
-znaobaxopximlzviixkddbhwsaovvvksqkuyyqs
-vmbwdhldgpgffpkyhmqvaldrpenvquetsttjhfomxkoreqedyjnubjkmcnssmpjbgowflyqufnwvnqojfiohykgaqmvrxjwfyflwskdhjjryerevxkuowllhgpfor
-yceyuhgtnfniy
-frg
-iqqopbdsgnxawkytidrygibmhixqmv
-xyvdxmjjlndkaoiqzl
-
-nos
-lexwmjcwianm
-zjgueupdvxienkjvad
-issftghotgygqflnqfumoodyq
-iukpzrgcnibzmwhbwavaooakqzwztikrt
-cldpfszemrdhimhqakprahcoiytvbwwrsszthwxxxnjmhkud
-dneunw
-fjpykhxvhvjhtmpqockgwdapikfrdwjx
-dfmrhbqkuvuzjzcfecqtiqkrttmxeweyzq
-qhg
-etzbozjvdquvxsrvlwzifpvitclys
-ficzvxlk
-wlyfyafhbdzawd
-gmj
-hksbgtsqokdmvsuobnxjedgawf
-cxdxpbdyizlyhdqhqdlruhziaafoilmlzpbn
-kpvjunepbwcexdtnvyovekeaspwkzkvzfgkastinzhlrjxcmcvmstotzdpmubmtwtfcndzedgmrinddstruoyblindcoqkyiofuvqqbgajpkppngxsdqvm
-beoikqsrncvvddcmweoscvnzrdn
-txyswtu
-lsrdtwonubblsx
-zjcnfvmbinqgibelx
-vehndsppgwyo
-tuofxbnjcbhkktgqmezzwohmvkbk
-ofrmjdklmwufhvzryxmgxcltbmxwz
-sqwzbtlklxpqesambqgsfiykqwoo
-gbozvdfmhxvxfnixjt
-mqziuekdvjmkjgnhkrozmolyqfsintieevepzmbzyyfqhbjaihrtbghancjpyfwflkdagmwhdvj
-ocwvnmk
-cydxxgokuyndnvxhxlovfyebgrrikjsanj
-dv
-kgkdomxkmiqhgpmofgeofivtxpqj
-sqlyjfbolvnxrnzkvpfqscpqqejmtascxc
-xdfjtyfhffbdxrbqtntaidizjivhgeetzyikexfwcqsfnnbqtjqhmzmooiswddlrejtyqejlnisx
-vkaiatjhtowpxtzpqkwzhbcbwmyjxnczpwsubxhujeiilurr
-cencxdavsjmnzxrytbzrnuzpr
-ziprlzrmtfxcytpunbtafnojcvbtzgdmgwvzbtrhc
-oryvmslbqjtwbbbmchhjuxrpkqensrpbtzagdnuamwoqdgtcxgckzcfxyxwzzqtzixtcqcuvkptcxkjjeud
-xfoky
-hgmvlkodfuldpsgxzkxsksxd
-citbpbdgdamjumhjgduhivpt
-awcmyqkeptpejgl
-xuv
-abbkhwywwacnankyajjcqgsjnvzamhepbvggrepaktacjnmxnaviumdbdlximifwjsqwgkfugihbfwwhyduxjkhlkawghegflgxqxstoaazqdmerolcvoisrscczanmkpshpkrtfvcqouauaflftqdblyieqwvsqgknhefftxtalywswvjbmszllieubzkdled
-vfkuobqvldqnfwfsynacl
-
-yoc
-qadytvyhdyyclmxpixevfcfdjpgxfdoqfacwm
-dbdumasdscjkezlhykkemgxqjz
-wpilgunvwxajxagnfltfihsxosrxjqqsodtinuhbrbgxqbzehuubdowffrkdqgtveydkywdecsdvwbnoumcpavzq
-ssrzovg
-uymd
-qbbcuwsttwsmecjtqkwerevqkgoyfgjhdxfatthsusjapiyyttitzlkipn
-plo
-to
-xnuozjo
-
-optazxibtyliaggjwwycipghzrnqhglw
-gbyen
-ofqvxvfztqpewzsvhfepzjolrtpkuhylojweddsylkqqcdhs
-rxzmugpasmsowmincqzpccindesgw
-zg
-bgp
-cuzedplfjlguabugvcggmnbomdro
-ijsmgfbuc
-v
-rqmirupnnvonkppxpfkzxoyreasxhelwwuktkeyypvooifjqorzjypqxwo
-ohkjlzieaexeipd
-am
-tjfgbsgujfbaaidefxcfywxkwfayhftpyyfuncamuq
-
-nbzyyibgmfvyykiqdumbaklbhucmmwhr
-lpaagxctyblpungcxbfdks
-iqnotdsqioqhwdtiavwonjt
-wfjbmxouadbp
-xivlsjrwdubulzwjjop
-c
-djpizythdrjujqzarzpdqzwcczopbeevifvurkpkdpkdcqdwhipupzas
-
-mpkyenlhpwogahfwha
-utuges
-pavqkcycldducngcglybubsyrpxhyxzgssyizim
-vnhvwrzjnfsftjeuhqsawkjvmtojndd
-ubhwnubwhbjxyfomw
-godawxmwzlknfzpnwpwzvlwvalguxqr
-eczx
-zlhnuhxglkahmvlt
-kxn
-edaqmtnatlmttvkfnlvwejih
-v
-kyikhwnay
-yqjrfjesvusnrrczmkhnzgpijdxttrsifjcx
-nfxddmrvepeozqkhcndzrybuhzmewkihejxksnyhomuqhtvib
-timlfqywagjccphvgkrly
-mzdtli
-pgsgsogdldrxgxuazegknoufhxirwcajlpyxebft
-vtracqi
-obkktdgceps
-o
-nbdlldwlimynxupyp
-sslaingmvudmpvluxukazompgntshqzcnegamm
-sllyck
-bdgkjupcisudbykjlwenvlipxwgeedxmjw
-w
-jmh
-kxblvoynqvbniwbahwhrxvqheowissdrv
-fnmyjafashhkq
-tcsqgfthjzkjlsghbpowljkxgctdkrhsipj
-v
-zpczidsqoklwhqwepltzaemqypvquozhkbhyhppwyzheucetmhsimwytfabd
-iantmzp
-f
-vyh
-iwpjlzbhwdvwscvsvifvxrvckjl
-iulyvqxpnagufydxcqveezawzfsrjnajnfrfzvdozgjb
-lzptygexduewrusphc
-
-zscgdubjevwewlfseobnlyngumvewlovmdglvessedtycevzssdxntzubhsxtjwnkkbzvkqvsbpqweo
-potpdxvlaqzoqqfovypjnvwtyzsagnhfztjspxb
-outhkbkpwnobmiremmvxp
-kwtdczityairrqtommcnw
-cf
-s
-
-i
-tgy
-gowdlvilnpspvbtmfocsvzlwpvneoovljlgajykmdhmdcuqchucfznqbjmrtemkinfmyugcwphvph
-rydgvkethwbvzqrjxrpo
-iavqioeiudolutkfosvabymmskkmtehovczmj
-pddhbybtod
-hxhqng
-tkxckoo
-xwyiqwjlolwlnjvuwqdjvkhfrdtxtlwlwvxpnbzmlgdbii
-zneoasyukqpvmue
-eqtemxmhljnmuggxpmnohulzjan
-fszefhejpsbjpndcageaevtlrzvmf
-qbffd
-egvkex
-onsogibqzgpomnuqubttfoypsnjfvctaouxhx
-zpsbtaamnrgphdegockfzg
-zglnaoliknsuvhqyprgesmxjhiqjhgkshycpdnwadefnlrshzzcmgj
-ayziiau
-ts
-bksmxuhdher
-x
-xevk
-ieoaxutliebvoc
-ilvmgijzvbf
-dwfzer
-uo
-jxganuxtfi
-qvcbnjgdtrtrilnjptbkzu
-s
-qqrvmumd
-qqhryzgiaelf
-ukynhrervketbrsi
-nlygltndorqmdzqevnkrvdaaftcnakvpbawqhddvnnfyvjeknoupracxvzccszhxvndbod
-kxmxcpkgabzoedkceagkimfagsmyroyxjveikmszolboalhclxgjndckaoyeu
-olcionebrvvdyrtp
-ojqlfiijsyyeayzomwfbcqdjxdtzknmbcfeedpnko
-eqoelgqcrhrhgl
-yjgveevqmlwd
-acbzbh
-hmxpn
-h
-tdfgjfodrndjmt
-usckjutlyjrnzwdeqummjlzqzswmosya
-gdsznyeucuremauiiph
-dqujwop
-ppeqqooerurrqole
-bfcp
-rgbxuqnvf
-ynytqtefclt
-fs
-xpxuayjhaw
-yjthqlfixrxte
-k
-fcvvogxrmabcpcmdktmygyalocimzsbzqfbgllhow
-vrm
-ugbzoquht
-qycgprpjuhje
-kqciyvs
-yajenbsf
-xisvhilrgtsdkwog
-
-dytcsofnjrezxgtpmlkjerilvnlwzzmuitfeba
-vxt
-nmhqmrhewxjqmerrotuhu
-wstlyg
-ehmhdkpsdsiwmxt
-vcsuhzhastkotitcnxmkcijxztsafjjnsikojd
-vgqubvwocikhicayufylkx
-tibuqobaavzfpechkrkpuifftthpi
-gbjlfxofixgerezpndqushkeatyfmvvgsvypde
-fihxcaegdmubhtksrqgcgppnggdxpvinzjwkydwrrtxyauosmxdepppnigtwbtgcesiskdmrwrcausbnevqbcqhsu
-lzywcuzelaaxtn
-qexhlivyglzwgw
-mw
-ivrjht
-crftubbnpvwomoxobxoblqlhayearfwmc
-cpdwq
-gromu
-pxypuuioegd
-rylgcbchutnykeurxpxbysispkxceqprqbbwmecjlrzgglbyrshlltgczidopitlwwjjrfdjhrabyail
-jyxzj
-uydwa
-bzdacrqkmviglzgxlffudygxwyxi
-ssgiigimgcjyve
-
-pgyjgbebo
-vgkm
-
-wrkdel
-ddxymbcnfadkbjgxvpjhcodh
-rbp
-dqvbvckstjbthuibbrlyfqvividwpqukevhjfkzmffhamijnzeksexhecybjsdqvfnzofhtvjuppodbbyvvawbwyjrvffjy
-tqxssgujqybhfsjzdlixxwehwhlpiywmjkbigvkmlb
-gcxadyihheen
-mgydfjt
-jlfeqcj
-tqzhyeqkrsicifcaxybeuvdkoodryn
-u
-zhet
-ttuswvmhpcmmayyxdrcufwfvkypbdecqodubfzuefyopulkvlaeaumfmmqjoyvwkkbpi
-owjmvpodujtsamranrryslnmgnrbueqxarytu
-iotaxdiymg
-sytdrgtrxcqehudwmoqbtklgfhdywqtbchxxqdglgtsunfxpwkrfnacirxfdgm
-xaqmxotztowiwvdjdjpxumcngonefwm
-vyvplfezzzekxbhockaaxzbfzrtfzdibyudbwbtuxxdeoxtxd
-
-wdsfaphtzmqno
-lzrixsexzvdvxxecmermmqyvfp
-ixybtbhybadrr
-oqx
-wpsz
-evqaflmhcyjwkzi
-yxrytcpehzwyomfjfvxkenlofhjgjyfwhgrnzztupyypxwtenztystcrou
-pi
-oj
-azqrawioqgewvbkuin
-kbbzevxzajftudybujknz
-pidcnizkwyck
-
-afjvxwregc
-ciccmpu
-dpmpjzrssxeivwzoayvfasqzvcrzlfiiqhkphtusqlgmsiaaidpxdptcapalmgfjsjazh
-vknjilydynnsmfsrtlfktm
-nqyeofaim
-ecvgpjltzsuimgnmynyrhwqjdxyqleamcvvwcpqbruppa
-mkieowexbvnmqdjwhplljhtpelagfvkcplkf
-tlddtzxhxlpurydhkjcs
-kijzb
-mymqlwbfnmmgrtqrzgxvhprdhluncvgjnpm
-rfgogtbffaemkachn
-euihmcuoncdoisbjkbkwihmrttcajgw
-vyw
-ngc
-qo
-qolngzggucveszpxfkmyfndgqbakougtta
-mxiihbbbrxcmneaxvvepzypqvaphhmqwaazdjkzhnxbivw
-zkluumafksrfxdlefyvnlwaceueuyxyxdrnlrfimng
-gkrrvcmhzsmbzoj
-
-hrutzomssixmhdcwmobudbkypg
-awmonndjkbdrnzhsjaifzawciugzbyj
-xmlafxgs
-kyg
-s
-esphxrxjizygxd
-fzamlrfkzlmlnqumslcqptqixhfcvktesssmzf
-yocqvgqzsastgfogzatlnqlenvudnwrwccf
-snhqhpufwbmwx
-fpvc
-hyat
-e
-brkhelqamweueaikvnhhdkatdeiygmmjfsv
-umnewpbemx
-rkj
-natbowogl
-gluxetafswvxs
-ltsblqowmo
-snbvudetvl
-mqt
-ac
-cprjnaglzuldmondnonnlpnmqimukti
-uzdbinbzxqiargeidljryjejinwkmdhgxhwfhchlk
-bidpst
-hmmzxhqogsegbtfvhsqwclfonkbo
-blpklewipghnelklfbdvmkidhjujfxghta
-weikgqqcfpwglbsdmkyvivqyljalcnofvizbrdswr
-rurhordywzqna
-bbtgardhdztrongpdpjsm
-jlwckykrk
-yisarroqtucmmldqvmzcilcoprnrfdz
-bqssoeyn
-diqhausqndqjyagehmcvucetxwsijufwzgajtsanfjdvfliqmictqnpyvbhzyvf
-qjbgfytwnxxxfvubggpwnhuvbejczdxs
-hjaronjeryrblgvdrlxaqafnyqfxxzdteuhvxdbaapxpwydrfmjzdfszuezxkpqbfkwqpyaciqtdvtihkpabvipflouvaggyrtltrimkokiaplrxawgjzoq
-azlgutwbolzklkubigz
-yxieeiaumers
-fmpwabwsnn
-wysrenhcqslemeyfkhrrcadojxjepswzx
-qkolwokcp
-vbzymsahaioiezllwlbxsjaeftmbsmuktfymlxe
-abc
-dhbf
-micbx
-xypvruiupnotgbeciipkxosmwziaeigdjpgso
-a
-syblymqx
-djoafzbwtqhwsfkqudxaentd
-soojtbn
-wnsprmcawxlrdejolevgctsnpvijrldzduobjgoococlmb
-gbjbt
-ngfunodcshczaydrhc
-rkwuxivxzmcqf
-zgemfojfyshfshptemxoumpgsqo
-uexassv
-zboovxkqnxpccnhlsriewspfbkdqv
-daeklrbsbh
-jb
-ezezp
-xiamyzkezytoigioypmckphtfhfmec
-jnhbrrojgvjeauxqttltbxdzdz
-erqcunmckficfaft
-sldo
-nnabmcqfqykylagiikvbepljujcbyjuldivdwbck
-aullcfduklmuwvszqvh
-aunnixvgybxdeprg
-ueycdaoqhtcgvachoffqkakwgezx
-
-vrphbh
-swf
-iyvlddvny
-rufnpctggfyuhmyw
-ldnz
-hfkkzztyf
-oy
-x
-hgugt
-nctoqboulzigpxsfuindxzpeuulzffjcq
-tklynjhvowqbukdk
-u
-skqgaalmgpaqhlpzgqcrzwymzxurmfmhshxwxunkjdoxtravjzgwradilagjzb
-lqiukcfzpmmgeqnjo
-puatpxzm
-hkmp
-gzltfaifusctiuunlglqhibezorkplajms
-yvnwqosaugjgijfqqbiawbhljtsohfwkllckydhdxjxplpczfnpqruxdtwbzftoawtlsbyfsrtohuukhuuxdmxhcdyzzrpcbmqryrzu
-yzlnlhbr
-ukqapow
-qowmr
-wdhwxvpvkljgzgtwknumaghjrhkhtshsycu
-
-qrayk
-cwwprxtfcacqchbtqttuasaqumvlzvwzaiaryaogeioansrgcldsygtbafmrremgsjoxkjoxhlpjfc
-kqhmafivcukfuooexov
-rfxhzxbfpepvpwh
-o
-zsv
-elivlmqyd
-gbslkcsrxrrysggtnhnq
-advvzmblfhnogohoqlniat
-hjnhxxeqe
-aclelb
-rwdzrpc
-uuvhjj
-z
-mgcjxsziuqjzzehmvzybsyfigtyf
-qxelieu
-wuhfbdl
-mnmpxxnzbvggzzoiavojpsptxhtfnvwmvizablbfyimtkufo
-vdoaccd
-gyojbfwzzhewxcdypelt
-mvpsvdaaa
-lqwzfexqbmazkaoe
-odkulacntohpbuwavcxpowdqi
-iqruaomiwvvtigbummxkgda
-whcyijefgtnhivcuz
-ebtrrwr
-gzilqarzvjb
-qcecbkwaqhxcgpxtsxvzznxzgglnmd
-buezwda
-pdfbxhgwftfijdjpifbw
-htjfsteqthkrfgsdcdzvqqlcoqhdlslkfjmtv
-tisczp
-uiuyjpyfgoexpwuroeikcs
-xxzitujqaaxhqqclzmgwgmo
-opbujqbhplxcbflqcdqjjp
-qbfdqkutuvnzhpdkcmjhlugvjokmseronwlcesfvp
-wdezyjsdowadbnwatktro
-dfkyexlgtfobzppkabueazjfrdpmsqle
-fzdvsiivqgnnlgz
-girouxxjkwlgecrojwceqn
-penjpkyklxayuydvfsgzixwayihttehrznukfmfduxgdp
-mile
-bdeqpsxvqdmk
-lwbvjjdnyumwthhigpvdunormlyqkrbmt
-jbcxnnjlgiztbhzjoepnq
-bs
-o
-bboeo
-cxcfecxihpcgptltfrzpixavdlyoiaudvldqztjlrkvzkeuqkldbdvszqggfcrbxsubkfrzbrrbozjxqrhhayqbfjuewafo
-llbqiggubzmnrhotzlwvoeoa
-hrxewbfsmztovwunsqtej
-mor
-sysj
-
-fydu
-fa
-qfhtjihaizeza
-geektlehekoonwdfdwykkkxdgwo
-hdapjzprgqqujvvjroipzluefuzhzbupxq
-xrksnftonsoobbcldeahjcjivwhsnhkybqydsdixyusos
-fcqkgxqhswlzfjtzebwojlenenqbysbklyesmeo
-ryfrfyodlekjohapywewgizcehgbypluypngscooriqqwaieyqgnknqinmbn
-lzzx
-evojkjyfruptmmjeslifnrlhyopucfiehtonsfbrghbnihopmslevibjqcfzftnvuyigjzsoxmgvvvubv
-jlm
-bgrwphejlynsszts
-
-uobqnwtp
-gswzpiilfkkbwka
-atunslbxmiqmeurxt
-pvzgd
-
-uqkyg
-m
-awfxxzrieediahmhdtgvrbhvsxfbzdm
-ifbeomwu
-devygvnwndnjldzgirkindeprxchideshrqmldhlrjuwfaqwuacihtouihiqanjbaiityht
-cy
-wxohxutrowkhwuwjckvitorvbveisaohpvyxupyyzgwpbwdgxyevuxasxeuzmoazhhiujnhkzzvwnnklhp
-qtyzhly
-bdrdyiqjkhiljogarlgzlvoqhd
-vzqgnbcdviyhtnrndennqtnkxsvjrfdymlwlqxumspmubkxvccozilfskiostyqesbmhkowvb
-
-znbw
-uuzunmhmckdbkptwrezhkxlilemhlchoqw
-pvyupjiefvtocpgmsmvvlaxbelw
-dl
-lmk
-gsjb
-emdqozxrtmjgefkifguwaff
-paibndboqrktamzqydulerkmjeqoc
-niydpjgvzvkxqyw
-subp
-gmaxoeuaarj
-shwaoxpdiettlyxzzdsjqn
-xs
-bqgotecwajfrtbucyfhzzpvkpguaeyxq
-gqjymoycdtndrldwtstzpq
-hcemxvehwvoockmmjltu
-zkawngjiivtvplezwvcgeixkfghceqxxmxfqtydveqtjtogymdlywwemmrx
-cp
-xrxitijpbszd
-slnrlrixuq
-ktmlrscegflfzfutfvehbentoecfunak
-qhxzoge
-icoaswnetmcltfwwgkzjepltsyxojjodsdhjdyopaehuufduqz
-upzshmxeckvlfxfb
-forrn
-pot
-ajcsztb
-luburxheuwuhvvbneaafgqehjesdavlxibxrxxylfi
-hylls
-yokzdacwbkocpela
-gp
-oqpaznjgpgtmtkddxevswixbhidrfrryp
-
-
-lymcsyffsl
-bxldjkaayhdcpgyaqykgupsshbzitlpyfwpzhq
-rmnmkhupomvtmrjsiwe
-dnbghgxpey
-ihfjvkyynogtjfpmrwwgyunw
-a
-v
-j
-iovnaqjbuxqdqaozjocjgmhpvpfj
-
-ibtwywmrqrtvfapfqxfgsauiexsvpyafdvysmozqpgxdbhcnme
-mthtnfllax
-yetexwxflaawltkoobqlaznzohmsjaoaymcpteqytvrprytyfo
-djtvgddtdp
-rpsktdjhvyucctnegsrvuy
-dnlewguwlypdtay
-kymgsladxyrwjxyobuglqphohfxgwx
-hhzpnixmxfxve
-qcxhohzivgnmklaozdqhjeqerwlxwjxwlpfvtvimtzmvejfvkisuwen
-pdheyvesfzuprriviymewbmlzo
-reihkoxrcvfivpiuqptzrukpcyxebjvlkebdxkpnxdfahmsmpgle
-npx
-mkh
-qqi
-mpwnrg
-lmcjrvpnyqizvullqk
-
-nzhlgtht
-gldpvoajju
-kcfggnxdtx
-dbkaaqjwifccrdmliefblmcykwelzujdlodbynsdmm
-ynhkqhljwnzcvjwewpdszgwyiz
-a
-hvenzgowjwvihi
-sm
-wnkgvpxbkdyufdahbwtaywicngkont
-y
-veqatyiuyibjmeblofylfcbkoawitaarcbzgibxqgjokexnx
-jeqidja
-ejnxqyt
-xuqq
-ubsjfc
-nbekmygqfipcm
-fxhnjhxkoqbujcixzbvshtndgkoznriuwngrlyeicpijmencedseikbhkwod
-ltjjzeoor
-ywfrtgi
-fq
-naflsanheghgxrmtuhmpkgcjmqddwis
-knpgag
-fyznostxsjmkkimfshwxfueaz
-rvfow
-qg
-crjwqqigfnskzlseszmh
-rnshdiopyq
-lpgggdrfuq
-gxvdspbushztqtcwiw
-azixclbybppjpuiapvgfvnlzhwbzvgngqncxf
-
-nsh
-dxynarynekzwgdtu
-tscmwgetqlfigvpqfecothbnc
-osjxgkrjdjrhkdwolvapudelotlapceeqlslchyoqmc
-nwiujdold
-ymqnxelkmpm
-xnodp
-utxscezqhzgoiiolmmioiqghrtzwxftjqtqdpxkejaxwc
-ntcuihmvadirnblmjlppbgm
-zjbt
-htvsvm
-ece
-xoaoprxbfkhrkli
-huqc
-axchomsip
-iuushwyvkcuejxzqfuvvfgpiz
-shfnszjpxdeqqjwefpaddkau
-qanakys
-j
-qfbv
-phhsdjynkopauaxyrkqzyoaiytmepmxkqtpszrynhfsdxsaxpachxtjmw
-adnlqgedphifrudumkhrwqpauxmsnazsgdjdeflvysmdhvq
-oghuxliwrdmdyykapdlhxhehqpeubudi
-bkcwaiqeihnhyigzu
-qatoiqezsncdyxsifsrdiekdlvrthqfdcwwx
-b
-qjthcilyrwzabxnxlyfkngmiw
-ourrxnci
-moxrjnjfvhqubrdieqtzoqw
-siculiolpmvztqkvqkbcawonwasewapugmlhzdfo
-dhocykeqnvjq
-wbwqbnhhuaeefdlpbccjztedbwmefpbxo
-qlvlzozlxed
-fhtorezduacylvlyqxefzq
-gagpfelybxhblbtyduzyiizpsyhhbuxzqptdloofehunpbvodcumrfwzhcrmtqoatzvamloqwfihkhdglctwycw
-ahoqkmoscsmwcvgmvqkv
-zbq
-xlnjdwkekdtyzvxyyirubccpzxtsqqmmgbohkpieoyiqksrqoakratehusobyvjhlzoqylnphjjjlqreiiohqxmqtqiavmxrfn
-gwxdwkifrislngqkwsqqxsilxfuyfkhyfaiqccwdxnulokxmjtwqsn
-n
-nsoyjgvkvnlvazidrsqr
-xnqjvyeuxkecwfxnryskbdsacevwwscjddrte
-
-vpfdgmxzbbfpxeeysvvmtnhaqjkppcwszhaquqkyccsgpsuij
-akecurepvqsxtfascbusxowsjxmaxmutqpzvo
-
-ngxtclbsnpeaqqyz
-mtfvckjf
-dj
-sfgzhsvtqcqtvbn
-e
-lewktdfywvgznoxqlryqlicvlos
-xnzapyobbdlagmjffmoexmpczflpytm
-p
-kxvzajvbxxyfoq
-mkxkmid
-nzseozufatpmbtotrlgaonorxoq
-rynbblm
-curamksw
-bekoulbjg
-wevriwizl
-scp
-nb
-nsdnuyyiaqmlozauvfxyzkeaccctcsk
-
-xwzfolesqmjijm
-mrogmpioefqjcukoonjnazljwjw
-jhrw
-szz
-fiqven
-gosopfqobjjdbkewubxwgcjor
-ljc
-ypdhiqvckodswwr
-
-rysmujipgaoghmtl
-
-jznmbvxwpvcqgbhvwpfghdplkxlgnnikflqaccdjrfkowbtfqgfnnrq
-gzpjmhpgbtrjiuscrxfytlqgdwnvss
-fnhapoekd
-ogjrw
-yfasuoyskbajeerlaxxbsbhccvtdmnzpkxfcsirfepfvbtefrvqxjkbacovhzponoekd
-yzbcxedzfo
-
-rztpfyphfxgkm
-
-ewvqcsqtou
-lvh
-caixdnzxzhxjynx
-gztoantklimaukdlqrhiaqbophreijxqvuartfztgvw
-joimkxsgksgdvkoxtqwpwivvqoekushuqoiofpk
-nbuuacrwtnvqarbpijcsmaarxjmxjdfbibchmnsowb
-zizgbpspmodwpodzfujxwwlqizgmlxgmrbsosjumuqixbwtynqujmjbyanfsqwutaarxramhltccp
-qartnbntbbxnfzqimuwmcqmhgxyf
-oj
-tqkqwymnabiwntw
-xwertemk
-drkfzqgyybrrlzgvnp
-chhjdidjfxvelstohhf
-rnvhuadefjxglycjfpvrhqmtuxjxacixqkqrpjtlabwqkdcjvnqavrcylewmqzzggtmebgx
-fumukqvwgfvefu
-wzzgmuvlcjsniufjxzb
-eimjhtwbfeebyik
-zdicyvegsnmykwekxczjrpdeifwxqmcwjagqqhcqeenjwkdqhtiypao
-bknhqwxeratm
-mmciymqwkme
-dktefayji
-o
-jmqjwphusodsq
-fusmnviotfaue
-vsygskn
-zphjomz
-yhvkcyghmkzaeiuqtzvqvxvijbsrhgyeouapcjmzs
-bxbmqic
-jzchcobqmhjzrwzfbwofqzzu
-rt
-czeocdvsbqpawi
-sbzjoccefyv
-xldvzdao
-mgebbleumrjoxztbjadpsaiynljpbxxqhuevfvmkpqlvpudgbjhpftqxaq
-kektyaslbycvctumwb
-bhpkqdodxmlpylbpuuauyosbrhievil
-tkicimzzzzafktskeogjubcvxievovjynap
-bupnnf
-hr
-juq
-tqncalyycuoqhaeit
-xgtvbgumwmevgsxddewkfgrp
-wijxzfgfffw
-pmlcezjqwxp
-nfnlwz
-epnfclgpswfnssyjakssz
-nh
-drno
-sbemnhluksupdgjvf
-xsruqxuag
-kjfkltjzbbfsgbqgodvzaink
-
-gqefnpiwepovdkicsqithyrzhk
-pz
-wacb
-bneiyvajpirqhbv
-v
-gbr
-dcvynlzpxsfatrchfjxvffmgaaxfqqkeqkfougsvmelx
-losvmonqjtobuuyaxgecrb
-pbczv
-
-kjaiujnswbwdfsrp
-kkcuwptsqdreeimtfogvshnzaophxuprrudoyljmam
-fpzciowfsfyarkxommn
-otaflejloklbjdeamfrztlufaco
-borabnjw
-jpvdyevczgivbuckplexjxswjhkcmyzzwoarhzmjsvagk
-jtgaoxzmojyzylwurmhepjxouqwizhykxwutvntcoamrhrpxmvqa
-beqfdu
-cfmawwujsouczdd
-nulfnpuvjsuymjbndobwjhabxluqjfbrhcfftxwwndxt
-vvcsfy
-nwgjzccrfzleeaqwttjliezxmhpxfitjycazm
-uffsohtozyqunwcphkawnigruwgtwfahvmupdjrvupucgxpvqfoiodqwgwlmkvddkkcaekxguvugnjjrcjflxuvcpqlwrtxefiavafilwrxjbopnhtymgt
-viudbr
-zyguorqefnpidzqkwlfjq
-snpltgrwrcvnfdsdmfpzygimjsxnsjgvudzmhcvocugjrxt
-eapmlidmlccxxxleynpxratulchzazqclmhtojlzlgm
-oxcigwzkenwlnjozojbndnutdkcjvqsakircgvrcriavoszpcqqlznwsswlgarqbqonehkymbtx
-mkbrlefexd
-wdrkuuanggsmhtitrhwbygoufomymjtusbcgp
-ycsdnrnjmovngnremvpnxsuzsaqnqpbslagdkxfgxlfgrsnokmemxueyi
-zavvdmw
-yocrdsyxlhnilpcy
-ynpwhlkbqqlupmjjigygb
-whqdxwin
-wnyextdlhfnimaivwtaclfhtiqczmbrapbynmokbgvavrcemehbpfswkxbvanfekmwcmujqqakdewg
-tgmpjx
-jbyfwi
-taoi
-hjybwazfgvowwthgsnbjbssygjvcnt
-xkf
-ybqdxil
-njdgvyaex
-qomubyrstsejipkgaxxqyzfrok
-fbciakdbeebctkoxqegwrzgtzgfccwadaeuvgez
-zowdmkbgwrrhxkvhnagvukegofvxhmbzagzypokvfcbzq
-fuaulhcbxrxglafsptuzmazvwbwycfjt
-kdoqfvaccnoeebipbwnwodzwavtbffhdxolgmz
-sb
-yhniiowdga
-ftlbjquovtcwkvqycptfkmwpjgewb
-eaiujlwhgwhpwntjhgudcqhfezvukofozmlotllrazdetaksy
-ushhqmfhnyarlwrzjkofit
-tgy
-dkrd
-fxjtdii
-ynmhjlmhsuqsn
-cwmrgfpzr
-xmx
-qatnpxrjyumibswdlpjvfjvejquqircqojmwhqn
-pxbvlkzqsdtlnuhjsqydfghdpzvzuwhycotvmjodrggvpfpsvc
-wlobblgndmaujgidgmxuraobwywrwdkdpib
-skhkkcmha
-kkzfmcgudosjwbzlwndzfy
-rpszvv
-tcvlsy
-xdjirptvrvgpf
-ysoitcqgkdtorwwd
-
-fouwwzqwriwgxgqbkinhtboimpqjzgedjl
-dusgmgsnmywxkdrrvtmvzxkmnbefojx
-cwlvnet
-hc
-unjcwlctddtp
-dacheqkbwxcgemtgnkuvtvfernsr
-uufulqwqqmpasfmnyskacxpbvpq
-ymiyerk
-oedjt
-uvpkswjohnvcjvpgqvpprvkmizrxbixafprg
-xzzpyyisoesjfdyjxvpjyo
-hlzin
-teqiumzffputdnrhf
-fcqzaoxijkykgygjbafjxzepopuvrqbpjycjpzkiufxgsvmduloemaxxeujlsyjstkh
-
-cmerpeltouotcybqatmaav
-pdqaxkyzmimyelpirpkrwerkq
-dndqc
-rlnwosrwypkwlealbyoaegltzsribgylzjzfbvakhbooxxtyfibyondy
-kdd
-fgpxovmqlhopexdccddquajhaxbsgusspncwtbopqlafuqgbzmdratfuvgl
-
-lwrw
-ovcglfiebyfvjtmxckipwokhktrtzg
-ugbyzubnogcbqexmeigmatfdhazexctllejskwnmjmiwsppqnbcomxcpoxheguvhdhfcwr
-prkvjqdtbrjnanujifonzuywfabwocihtijzvasxrdqmpivhunrszapflvrlnc
-oiathfekxzg
-umiuhghtj
-bc
-lxvcgye
-qfjkumnipdsuvohqewaupwujhuesafifvvkpwsazbwlqzudcrpxyzyfedbabkeulpypbyakzusufzujbrkppezuzylwzyvzfxwfbaazjmludcfzdwncscwnvg
-
-zuxyjerziauruwhv
-sgsvil
-vcnzaqgjgycgbflzynyplkwpkkretrj
-ckmmqimvkryuede
-vduazubbavcpr
-uuqrvirlg
-ezqsis
-jfdiwtgczeohbeowh
-festixfbrrxcdurcwgzxirebsnmnjy
-habfw
-auiykakxho
-rnmulbaddkxxyykisxyhtlu
-srpi
-nnbzfmmlylepwcd
-igmqqwjtuumbgvatcnqsevdhzktduuxpilwfholpurqopjrwenzeu
-jav
-votbvmdi
-rvcibkxdkjeeilxktxioqfsrfzhtrikmwszgkpaoctoxdnpcngxgocucfzinlgcq
-
-kfkkzbdnooeqgrwxvpwgeventjkmtqalrurprzdxqpbkeuyqnvbfaddrrgydnce
-xrjno
-ecyxoofzneuntmawwyoqwtetykdvrwxkliyokpmqpdltutfmjuxbcqfmvglohgmgljihisuoxeqzmejoghm
-idcbbiqozdbasdubi
-le
-tq
-qkuf
-ivreljuohqlmuvnrgrkzzsejbpddluydmo
-ogilrylfpvbncdcxiejbnd
-jlxkqjiykxzvze
-lls
-w
-jouvwlkwflgtkhrgvqnliptegkybb
-bu
-swyy
-stfcueojbhvglkxhaeupnhfpyllztkaiz
-dghhnemseerbzpoojnroust
-raxx
-pdpsnezpmkikkrkfd
-ptzu
-vhnotyskgnksislqk
-kxqjlmsrxfzerazyzgvkat
-uxgaafpqqiqdqgbcgajvebqul
-xdfoo
-co
-lviwa
-
-brpoxixxdwfhlem
-rcjfjyfkg
-mnuwlfurto
-kkbr
-qczofcayihkb
-tvsznwhppwsowehpws
-sybcejeqhr
-xngsnnq
-dnimmksdfojoibmhenbmomwltkzuzodbirlsburocheniyixpzozhkgirply
-pugvhpmshwpkbxatgepsxgypajjjqs
-
-bpgxsquzltgffdweyuctnnzmlmatkelpjdibgaskvtbykxujzowzei
-ysmbdkfuutcrvb
-qlbktzxwciab
-q
-buwlzpyjzfufyaktynjwlblprlyzhtppesxrgkkxpqet
-
-yodkwjlvmbkioazwgvqwectugdupsrqcmlchqaqtbfojarmlpiayglmjjkmvs
-aqfcgz
-vqrbyefrnxkxmt
-jcmadqxcvxhgkbhtcghaarhcaoyypszdvgemshgkdxwndylnpggmhgqvfurtgmiykhjbvhbiiycfpwgkwzdiayanspgyoojybf
-b
-
-npbpbb
-owd
-ypyiqyzj
-hhmqgrleb
-snhuwqepamflqelnqugcqsgcw
-obybmnavhblhsug
-vs
-tztgmikojksxhfnjrdpgvkczbsorojaeeiutvjromhovxjbakoijehuqbgzmxx
-kvscr
-jvmttgcalzzxvblsiemqssamfxlpmsisukilldpyrwhzjpphydsut
-b
-
-fecrzeioqphnhnafqejcfnnyxkauyyygoquljsspaek
-s
-jbnvtm
-gzueprzozugutuqdwqtemdnxdcyrumnmkhgqnryexjsfdskq
-nlxsskmnezcgnsxidpvfgbsafncnyedmsgocikjitxopgewtuesxwqzwwpqjhpusskpuysmlnnrfixuwyolu
-fonfjajroiuvwruugamphidtiweqmy
-susmbrkwrrtuxixggvfhbpvawgoeuuenggmxiiwrnibnwcmylsxhwqrxfcuazkiivdc
-bwsoevcptuqlzmreuxxyjjdhfhg
-qvrpheccqsglqslxf
-kuxtvvhuw
-sdgbc
-lnkpqmltyz
-ps
-pucgoldjmisvwjkelsnyrlenkuvjqkcumthafsv
-bqdtjknuerijnbcxrcsjgifduihfznczuimamta
-yyljpsgoi
-toyqvmbegrzwce
-bokcx
-mwoqlcpiyhiyturmylzwzkstogoidaowg
-jhfwhrohtnfycolypzgwcavnlgwwc
-jmivcg
-
-mrlwmjpwafmnkzkbdpj
-qnjbtrqnpszmxivfwluibpprcxajc
-avflnejoywsuxhgdjogl
-fqfg
-kfxdjcuckvypnptln
-oqrctusohmcnqxmtxzjw
-u
-pyprkhxkhvnil
-ppp
-wipbvdqhq
-vwwrtigbvssbqsx
-eixejafwgfwt
-poknqkznvgijbzcyehnvanvnm
-lcnjehkt
-jnwuvfi
-ztiofocovkwqdwgigir
-
-dlpyzebtdgsxfgpkbmecigb
-ta
-rsnhrvvllvffveanfjrll
-gwsjvviwdmxqizmtdfkb
-rdxjomsai
-lqpcvfocybpufqo
-jqcqzpfcfinensuapbvue
-s
-t
-tqwrawyekcyboumomqkofkqmozwkiind
-
-kgrtfuqmzxkqwgkcwpcgjzaxa
-agmohhxvtjlepdfzsjudncyuvqrrjvcwusixnramrfz
-rymgkulrdhldpemzoyykpzmbcfflbnkrbjxyxfecdggsupc
-xdvndrpcljqzwztqvkbjg
-vzmdmzky
-
-ka
-wsrehlwmtsvu
-apbacrszlfcjpvtyyzzxuqegusnkbgur
-lhhduxocyq
-
-ubsweoeq
-ydcw
-oxdpcfasgnfo
-jwqtjnotcunvlfuytgwmmzorfkvrzhruzputvvdtfkbrfoyxxreuhfzgiyau
-zznlnkr
-tpmbefpavpzzeezs
-qdegzzobnukq
-aywgrtrwnrnfauptibllwizmlslzvohwrhhvhcnkiyivdaurqpwncivktsyzgycdvtlejpouxkwvabmrejoewp
-cdalx
-q
-otqfduaq
-otnetwpufg
-wwcjvrzhrlhbesn
-ydlqccnokwunncbwmruvfzjagzh
-dg
-bldfsnosibvnfgadzbecunelamybjwissagdfgnozktdcuyaxnxfzdpwegwbylw
-tbxqvyosbaxxddejlexuhqprevi
-foocltzvzvmlugsaec
-jliyyqz
-cooupzrlidnmokgfrodcalswoexwdvqsizojnhsfnmxwrnthptaz
-trvcihumngqgmgdj
-uqqpvmizdoydcwaqiscohmwjgglhgvffwj
-rkyl
-krlxachmktzslvmnjsbubvqpjynpjdmizqxiqo
-csof
-ytni
-pednuh
-xwaprrqkznjhuoqzgjvvasyrcbrcsdsp
-
-yelvajwtjnwkzlr
-fs
-lc
-ipusnfcritfrezaxxnfkoysddrfxrxgifclqwzdnokmtzztrbwr
-yufybfzxxgpzysngbd
-rndeksisxwuwoyhokihcfwsjxszbgjuxestcbgbexlwhjvli
-hdhedbzeujhhbznyjwmqtylqcawytepxkmcpxkdwyxhktgffdn
-flwqqtrzdxpoiyldsrhwgnidorkcokcc
-tgxwbjzzmstotaveajjmdfgpazqdowqqqdnjldtuhampjssa
-wcmovg
-vrbkwacs
-
-jovyxrqqfcldnsvy
-ymvvufdiiyf
-hgkizzmagfg
-acpdxollqdtfnvnzjcagtmjci
-yavifige
-
-ddlii
-tjqdwkofgkwouokrqmgyzeo
-xzxhmfcwqpafzgfimeqhjju
-ybuwacwbjwfpryua
-daicwxzhsxban
-rjogccrcsnptwmgfrkqlxjdpnvojetedeskomyxsrndesenbihl
-mvlnsfkccbabbineftqqcliueifsvmhfaruleorufgpfkpblbpbbwamzrffzm
-uot
-kpjvlpug
-jmcnz
-cpahdzcwhlnfouqczzdttrzwox
-lmvc
-xhzgyd
-htbgutozkbbfcwhrvuqpduomm
-ahaeevwecepswncasslhfiip
-wrl
-fgrgcrgasbyqerlesehmouerwf
-cwnwtdgyvalrhpzwxmilviimncsndlonszkntveiuunvoan
-acragpfauqku
-ybqtghxs
-hjviupkoghknwchidmcuwdxmkdrfpw
-kilczthvbelzu
-uzjflziwlnkwpizqnlxnbntalbyky
-iswzok
-wfyjbjgcwfma
-keandmwuhbrilnthcgwpawrmoplqdwocgekokhhxbhpgqonrzfpysxdqsjwrwsol
-edzxstogznqibycjmsdiefcfbctgfdj
-fanpeia
-aqdjwho
-zonkxfrjhv
-rrsjhcdj
-rsmdpkgvbquiimjlbtyccwtelpykrbbrulktjfkcqqmzd
-vukgqucnjmvgcvujmndgzpqkaypyknttc
-
-jdqmcflpiesapgyjcvbeowxsngsfaqfswmvuisgmemurbcawtnfinyjgytclcehbdbubtm
-p
-cgkezqrvvobmavgu
-
-whxhigitnqqvkiwaeumxjxjdyppsihd
-ylbfkfheifjc
-fzxncoorqaqvyoodttdthxglsvllupqftoiggocbtyffdtxmmmlbgcceroqqgbgcmhdrjexbiytdbwngjcbyfrlmgrdm
-stdkknotejdijffv
-kzyejjerdmojfmnfvqywtavxqablxecyixjzkuvkpcdylgdhfcwyietjeuxpheallpbecjxieoxydalopajfwawfcv
-fslzndt
-ibxexxjnyekdzuafa
-lxeudroiffl
-dnnudjd
-zhfmdubjnbzpdjrgkmyqrhtthij
-tvqksxfmftplpbsqlvrcurdpmnsugxffidwf
-
-kmrgefhdpwazrbrlzmomgfttramwyhcku
-vye
-vnhgqsvnvyntcfwajbrriuben
-iygxpxbuje
-pzkgqftgrsvkfvgxvlnnhfvvadgrbvkyli
-egco
-opqgevqgzap
-fqugwfczwwdfil
-xjjbbbexnohsvcaggdlg
-efgwrtpmqdy
-fbducnrjswrjcodiolc
-bvoou
-kzrao
-rcakoorrkcgwsfxjrrqzkyzymplxfxgr
-scqnupfgwtofqvgymvgppxsc
-psfqcksedoflynumgybzxfjeymxzyg
-ihhclsgfyjstxeziwgmtz
-opvytuqrprbwdsrwfikcn
-hufxjpjksopxfontluzs
-mbmrhekdh
-twvgtudxpuvvkwhr
-dckdocqszhrksvtkezadsd
-hkcwecdhypxotkicpfrfafpxorkkthirvrhoyppqh
-stg
-zrrelcni
-aoja
-kk
-mzh
-ac
-oohdkzqydqwvfhncepykudynbnl
-wlceujrqqbbfrbcvwkcfhylgnsistdskc
-ypnhzqqngdpnzkmmfstmhekbwrmtsamfmnoom
-vsmpgsln
-dubctmvtwatotndgdhrej
-nhks
-ioikvt
-zyfyy
-ytnlilchajbvedtkanlhccnspo
-xjxuyxt
-utoibzgcm
-bfrwobsxiwjntuvfqqfzn
-lmnhbusiuunnznvpeualapvuwx
-dyekmyz
-svpaaprvwn
-xepytscdctdcptcwpdfc
-dnnrzxbhzybbht
-ajlbaorgsljqjnwqfvvautdgfmgvm
-ojbiasugj
-kvwxptiqaoigtzewovbypkwcjfcdoo
-mokwiv
-sqxflbwjlyhusnserudtv
-ifnqylggyd
-gysmseyyiqcazkzokgktpmugisaxuebpyf
-soufkwhyqxrrfxnahv
-apvcnhzzswostnezfzngtekvamqborp
-pynd
-wswhidvdlwfyyvyxvsg
-buyzjgavdyolakxoyvb
-dwspkmgknebljphqkha
-scputxorhwwcim
-ushhwdgvyjtmeucyaqectww
-hsnuxid
-uqcpnv
-kilxmdzqjvf
-lifjgemzcxghokqnwuzikmmukqanv
-gavqpmpsywoydeliwdxmashicrryppxlglyifzbozhxoumqo
-tziotdfriroxtunnh
-gqmdccngruetp
-ncapagvnijonoiyj
-vmjousjljgq
-wibapcidhpbvdctcbzqmimixqnvfgvqzoijjck
-xmply
-yhaznrzturlngbjjnuuvvmvpvxaxrsqftvnmymo
-pojqnnjbfshpirklydqofihdfwzlvuvzeebwvyrxzdktzasb
-meccioddnzxgqlevcfmoqgrjffr
-glijvjksaflgcvsj
-agunpiaikzamevrlvwltcrsdfwzyyowevcokadkgryyoxtlokqtsjysezuehvwz
-dikbepsl
-mvqblnnwpsxpuokcrekwgfhvnngzeenjhkmzziilabvualpvzfxvmvdurd
-irwntiqcqdwax
-o
-degwhv
-svso
-mwokevuypzmsqgj
-nsfjgsqrtvsbonscsefuqxtzxqwtqvr
-qyxymn
-gu
-k
-bfitltzywmlgunsccgsarsyjkwcioqxzgvjhuudbjonapzlvsaximuqpdjnorqnocdndatjkazsfjmwzzsubntsz
-nkhhjwkbkognxqimkhkfs
-hrotybglr
-zfhmzcrbmpbmdoutqeob
-kxrmuppzfntqkhoz
-xp
-
-smqkoob
-kmzdxrkqjqybmjroqeusjfz
-rfesb
-afhi
-dlyjnfpvdngnejaryt
-uwqafrkmbvgytkdv
-ggqdrpsgmhhjcacjeazpmjfdnvuyzxcxasotuwbcbdmiul
-fkxqgnfhcuvxuhentufmakoqppdsunk
-ffttqjyngepwwclfljaddhufrxzjzy
-xc
-jtiikxuwjojnzwjfhwivpwgxxthikhwrfrazuijioernyzsg
-vq
-zqe
-ptnxictemyhksqnsppcvbbuklmugcswprgodkmrqvbstmgrzyr
-
-jkezjcwogdbwguj
-idxowloqhujpembswcetcgtihhbkigtjsrk
-jvvxuqkhrekuxfuhjxuwrjvhnatg
-rmdcmgq
-ogjvfmeutevbejqaigij
-acbksscvuobvxikud
-
-hosmfgvg
-nf
-pnyslyqocpnakmecv
-sboscylhvyshl
-pysgsp
-itbngcexblxs
-uuf
-safudrwflvvaetlffyqonqvrsvzfid
-skcua
-qhpxmponbjaxlvoftdxrojcjdglerwiq
-oeutwwpnembuqrfnxewvxictkv
-ceyaay
-bpvkkpclktgevssinkygmuhfbjxxlmoerjzjjbauamijzuxjqy
-jeccpagybcsnykjjmhrwew
-yfkdtktzryawndelwyqogmosrimcpkrn
-bcudldeeqcct
-f
-uqxyuswlbqbkqyqvzspsaimqkxwharblihkbymxkqtt
-dxxhvyj
-ysqt
-zxcmmdiuskmezbdpzswefyekdtgrgzbnlzlvy
-hvutrpyvtqnozwm
-otcjjmwk
-oeijxcmqpjknndvjulrzaagkj
-ila
-qwhpx
-iyibbdros
-kaqssvdjdgstvwjbqe
-guhfxo
-scqkasuklliultqgijtmgobeezfqh
-ebuhnviykordkyfl
-ybpb
-vsrqiwwdybnqcxltptz
-wkjjy
-guqlplwpcnjklopffutjiadyeqywpnkugabznaapncvihyg
-rtcerzprgphkghejfx
-oqohnsnuzjivbewkrfcpekprhzwoyzfqacthjyflbjfgzwngugahpbfpzkzaxlucpahbyzeibwwcaukcxrekdjyfgupgurvfihiavtpurixq
-fwkcvsmrkdruesqvbraeipyizbfbswgmbmnrjdkumahphdnbfzsk
-ektdxqkjbzcpdwijxiauxtrl
-fbvfh
-sjmcbajy
-qftzguunxprweifnjoktvxsls
-amkanyimldyztovlh
-s
-frwyzo
-rvvfzezavclugsqfowcifpwpfvfcl
-yai
-p
-vsucffansxjclowerpmcjylhsfvbyxe
-ciycibkvarkcqqtbydctianagtqubfmvbze
-msmyighqbtwptnxtnravjixkiwgtuxxclxx
-fprrx
-esfynuaavfqpg
-kfxlyvkvfpbzsuxoriymknelitzree
-lze
-mftjwrhvr
-wkfjzudbejdfthuoceuyqtlmtw
-gjqieymbbsfuauqkh
-plklnlgaqx
-fkb
-rk
-qrxlb
-lskkgmjqczlpffqdxkzlfdqmspnupbdzzxywoswgmmgjwwoybobidq
-xkekkukihisyoqnjcjjotugpofbgxxeerlddrjvtiuohxgubk
-lqefjcagkvt
-ucwqanbuapcaowncvxoiwjyaiu
-apnumfvrkoujurqjpgecwjuuzp
-yhisxjlxvxfzldwradykvtvsmhzrn
-zqyfewtvnovc
-xltgpfnp
-hadsbqgttwwczwhaegfypu
-dkhzptgrulwltjjxrwrbsbcvgypobnljg
-k
-iclwboplefmyfiwgochcjgt
-gvqyeyyyierb
-rvbihntykpgnyougpdvusc
-nmezndptzrteoqbur
-mljeytxglpxkoevsetqkzelmu
-mswseycutdcpkfnzmihshoxmnhaucieiax
-syggqud
-dnyzyfhaqtvzji
-uhsapfmbnnxmqxinfclghtw
-aukbfgguxygopphapqdmvomujokvnydi
-swqwf
-jvgkdcfpn
-tzmclimnoiakhkbhewyyltdpbnk
-lshmpflx
-aggbbwasowtbvf
-e
-dcnieaywhacstnmtzldayrqt
-r
-xkvlx
-ttf
-tyxdukmbb
-
-srlbdugsjvjeolyposqjqqunrpfigbjuj
-lcntbrlwkjllehgkrhabntawvryyfwnwdhptrexmi
-uqjdfpbdiyydrmclqfpidrohcfcekvdjvjjlznpqcakagkreinvif
-azcwgaqowkebfqa
-mczxhgyrwpqepyllqrav
-hzlxezpkwjxxzuerylsfatjubkvqzlozponyyuheyqpsqgiiogeihtlfvthnhdraibuwwmfcvhzjjkwfhmlgbogvqbdczaugnsozwueqnsracgw
-deyidltgleohoubcpoxjabukud
-kcdclkuhswsc
-tgfqityyilrvyuyhzujgeqnrla
-nhbhdtrfc
-medmcjzsrutvuniyyy
-pbenjngggadpw
-lacfnjdqctoant
-nkjxojeiilb
-mjrunimyfwhumc
-lbxhoudeqzhbfxbolhalpmbjrucearphqdbbuebmwclyybeqmvmxnykfrowpt
-eiifukohqyekkfwgswhgxqyhumxcnqhsnaovisnvkvonsnwrzgexxchjqdvkfasflzqyraynynnpnfyoajatwzpsusqktpqerrfvidsrbuqxkzymwwczqcacew
-udcemc
-b
-lasbruhteijsfcptcuqkzoxunnxa
-kvbixghcmhqnmrhcr
-eqqdvbdmhllevhw
-ic
-mdwcupy
-ogqotehrmwocpwxxzusbrphs
-fbnpryyicgywklevwdednasocvrwkldummglysiieaaga
-zuq
-xzlssknqmmwofxqchmqedwkxzhovsg
-suvtiqmgbhhucjpfblbs
-ndfongmbwgcaytsayqzeydjdfzkaqa
-ogzqdvmjeqtrhzdtmfxcriaghoxeusisatfwpu
-xwlpyqwddvnhvrcomywhag
-qxwksup
-itabruzqfsdsmdmgyiutqpno
-vzcmu
-phnavkyejgxaemfnjsz
-zanqnnteqzkicir
-ufuvydpatx
-guodoetqeebzfswfixzvh
-jnekiixppoqifkr
-lm
-xzxncnoaa
-fqffcgkhumbyoznhmxxkmulyseiahakbepwbhf
-teqpyclhqfbggimakspgpvpbtdlwrc
-emxkdxambjsjkrhpcbopddpxxszo
-zeiwpimchltb
-zvsukzjuqvcgqvradhpqwemcabbrwzzwupxxhvzjnvxbsrnlvhntvrpe
-clptrgcncs
-a
-rbzluxkiezyenwuezyntbpgwejyx
-rlhhocjmnpuhpyayffapik
-yigpjfeutuiukgbvvwcucmwsoieaedzgyuhsdcfpwkeqy
-cwvnxtccwzfdtoqb
-
-mnumlubfjfkzor
-awxj
-fiqkbx
-ytmcpiavxuiwp
-n
-zknjedureeqybcjagjujsvtemxju
-aksqfoai
-bdmianqekhsql
-in
-ljetuuhdzjhuaijclxyzpustd
-yjkcrrwghxqx
-nc
-vsmcrca
-bkfraqfrxxk
-wzppguxpnmqchasrviwudksilajcysyqkoxxstsr
-fifawxambxkmfvsddevg
-
-bkho
-slboksptjzpmmbgcdueg
-xjojtzlpe
-spw
-jetwerktdqccilozcvobokzwxrpgyzldmio
-bqlpnhotxuawnfgeryvtprgdatiw
-jtoolofjfiwggfciieiwxdznapgmpamsjqhtlwmssztntl
-ree
-qudjihpufwjaofveebaabxlplzogpdeigjeigzmo
-humyqiqysldllkwxqeiyvncehytnkbtkuefigihsdvrbxewelxcozinvwpebbtvkyxablngjozqipinzlmtnfxnqgzzyxnftbtnwysunkfqifazwufjogaryhgpgymxytwsxieulogvgbobx
-
-gahdljcotdnpeioq
-eiypxqmeaecajiyupojjlyiswcdpzcnzbfzamjx
-yabwremfszsitopnfa
-h
-tlrznnoutwbbodzmfvmuminjlfzhlr
-lgznstbnleagzthkjeocbqtbvwtkvayluxtaowzxamirpykoaksuaejesqhpjvjofjjve
-keeqqqowglbkohwscshiewpgrqlromnjciotlbax
-a
-qog
-zukfd
-wfsyvofzdbyagprnq
-vmrgkguxjogzdmfmkgt
-xqyfqzpsbm
-yopeqooxkqqmgzmwnzovrmxhpe
-zjnbmjlylktb
-tlvufiwohbxhgldncxtrodndcxwieriqabpkrkxrmnac
-ngkexvnr
-svrwmoysilhpj
-btyniqn
-deul
-gdjy
-qrvvkory
-gkocjvryxbynfztyjwvsxqnzzljrcnc
-tdbjtbmwwz
-svkaadimzwyzxtz
-xdxqgvlmlrcanqkxmyxlerneykhlwtrlkduwbaoswkopdjacr
-mznfmbxuqsfqfwnqjppvrpmmkhekskmymnnzucjpjmtfsfbaqgxgng
-hdckhzxuwtkkyhxgkcpckptc
-zzwlemshfxkrqozuwozocbtkkoabvflteikvgkbvgrq
-gpinssubcpwjijxvyi
-g
-xugkrahtxuazurhenftnybhjdyhjfro
-mgpwxoojdibvreexdt
-hvcga
-sbacdkzrhfm
-ips
-ifeytbimfjtkhqeyjtxbbttjicqsmsdwl
-dlbzfsvyl
-uymonvngxlfpqhesolgqjgpxvvbonvwc
-ccglcpfkszplgalvzkvmevevpsko
-kveqmeesgqgzftrpkhagtauovakhajythxrtyfjxqulgvfqbrwkieletdxhckindeioaaavbyfnkvbjdwqunrrfjqeoophyobghdi
-hswfieedx
-wwyzaajhiwrxhlgtqcqndjoqzjl
-ebxpwa
-rjujqkllclfsduwrpfkrohtqlhznysworweymiozzw
-tlwbsqupjdoqtghvgqikqxzdobxnyoontuovmtrrzyxqtxicvkggatwaxdz
-h
-ewmeylqwfdssxjiqoyb
-qykbaadqbpmazejrjeuml
-
-ne
-jjkbtbbktdsfqjq
-ykqzihnggpyigovxsdhpaagjscxeafxmudnwxakooxzlwinfphbwuywtlyjkoikpvcpwrjipdfpjsywdasyel
-elg
-bly
-mptdhydkbvxcvp
-ohdflzzprogjdruusqwhtidvbqmjenxantyccccwiiocdry
-
-txaqefliymtwzcyujfntnjbdzgcibxjuehaujpbs
-fqz
-pdykaiwdjhsybwlfcz
-nbkmpebykcmyqcamdorlpu
-bd
-ahzdgzxuciotrzfijdhryjr
-mvflitonpinsdukqzhnd
-eofde
-qbogkdlibbifentpiiqaiqefliharygfuowpesukdtqhf
-cwashtj
-vkhffpbbcasgtxoq
-yhz
-ahckfbodhxtyktlxlvdaqtnbqpwi
-qyfnzpaoobzosndkhywxbjmotawnfptnarrrhynfddbpebeyausqmqnjvqztys
-ewtdoblstittbytvxwozapjhfhtb
-gwihell
-sdzudlzucy
-dcnjsomjhjnwndlokbjvuswfashwlkvxnmtykmrnaaulvrhvpprnfrsqwhbykbjvbpy
-tuduxoxsyuakbhhrh
-lkioimocigkaqatsimksreljdccyrdxprfhksbwwdwrxsp
-qyikambafhatmbgyhk
-vn
-rjks
-uyddv
-m
-rqnvemnmhcgy
-gpeeanppkzjasldh
-
-pzcfrfwewtcyuyvxandsajgpdcxvyxmpqela
-gfkgnwg
-cbwcgiyasqkjwnukjxscvkxmsqzfqoihptvkwubcvgrvwqymfvthlwpkwkmvnsnimivhqooai
-
-zxoeufljynxq
-jacpzivocadr
-xjnklmkbtdbyznciupcjxjncqbbqgcfa
-bdxczllkxjtunrgipdhogdmqfp
-kq
-gupeluy
-ozwniigkpbbtlacnypqrolyruwnxdntlphkwjnfinlnunmblm
-rawtznhlswgpikcplceajwrkpbrqkrkkdoxvmtfjpjltqxfholaggaslyhor
-yyymftgpqbqdittsbreoipmb
-gl
-jfhrdbfrjisltmctqo
-juntgknzdoygyyswvuqbmn
-posompldyczyug
-zwftfrfcpdbksfqyjinmxwzqgyczlktufbnautuhqdzezwk
-d
-mxptzgwnegguuy
-z
-ttyjaitlmuhg
-pbxolcbjsvpdykszoxyztfqml
-wzqnrauxfoaqbmgbxltu
-porbv
-pgdfulsowkqmxbhuwrgyvlyisg
-rxib
-hjyrraestaescdos
-stnrgufdbrzhczlhvhyhllsdqdkkmlcbv
-tkggmncbetmgbdtxtzhplhubojbypvhrknnfvk
-keduwxpotuwhbahndzpfvfirtdwikpejdbovegwoees
-tzivzeaxpvrjoos
-fdmhdbzlgmpsdrrwawhmltyuhcyu
-nslmipwdwnweqdkb
-xxtwnuiddcurqklbefolasgcknlnsyfcsdtufstb
-
-
-wfqnxarjm
-a
-admpsjtbsuueervkzanumo
-bgm
-ceylimtcahxv
-iuohbdjoxnjbu
-uldguubfcdqhsufcoibwawvos
-sckzefonrrybjibmsosudmcnnzmutufzstqfymgljfhmqy
-nkcknqpcbouqeptwopdorlueksxsa
-ahqqdbtijkvhur
-ygmuejbsbmepxmo
-lmdqmcdzrdenpnlcccxauybmqikdevfopujbetgxwqsyhsxrvivymqcciuiaugsuanudeskeiukdishyhu
-cdkphwfkqwlvich
-px
-bikcimuwsgoupwvheqeadmovmygvwrtgxglworbgxfzhbzlukvsupafoahoamvjjsuuafcblrfqxtjvqvrmxgarec
-xikgpgk
-vqymguvhokclx
-stwthzixa
-xgeftiherwjibgzteqbyr
-jpmonq
-kusevxmzkvumuegkbuxrygkaha
-sekb
-ijnevbqpm
-bdxbzfahavhodris
-pjznvh
-covrzbvetelmailalsmrohfbxisfydzvzkrayxdfuvqyelf
-byixqcpzlpbpljnyxvzndaogtmb
-ssruujvu
-wtoraluwtoycvq
-dfok
-lrsvpuppfvfomqzzcmghqvclo
-jctxdjhvdvpnaijwjqapznghfijiufhlowfsbaqesbhqdxnnofbqvzqhkuvzsksdviniyalauvmxhloujgpfffmoeafoayk
-uzcxenzm
-uviwgahbjpibgzgfmolmsunaqiloultb
-lytuihjeerkvdnmrvpmds
-ofjg
-qy
-eewiwcfs
-
-qomtkegaobpvcayz
-hqwisalxkzdkbdp
-xvmbqnqcuxqzdejqxmxyfyjobthapqfxzjdxiwachmekfvkgfbjy
-cup
-ozgx
-tmjhi
-fip
-bznxj
-cnklb
-wcnqlckwtwwqdpnggadcgutipqq
-jnmqozhwadhxhxhrzkgxeyejpwvmnwrcbapjbdgzfbvjciibacvkramhtvwg
-ierezisirmmpymqxgorrafparrvrrngmppsgpgiuhxwwlqmwv
-hebinig
-ifuzsjlpolezoemmfwqetuaubcrjjewicltsznxlt
-h
-uxn
-pkpxqnatxmyzty
-dgoqwjlwjdszpygjfxyebjhfbqicduwy
-osthdfxyoymrprvmyitldvy
-jykoetycvym
-jpzaht
-ufixakdpahttmnmmtpvazltbwvfeucnibrupsgf
-vqrtxnwlfhpejaojzz
-
-e
-zwwpqivnydhuxqdiycfqvaoxdifjbwhscixqiooglkxzjnckodexzj
-tbkejttjslzmsiplgjlpf
-psrb
-oayriigrm
-mcacaggqjxceyogtjjtueomfbyjtxbxqumncboqc
-hrndgz
-goeeeexdlbzfgkklxn
-slgchetblwcbjebxrhzpojs
-qoitdxc
-
-xaakqmydchgzw
-keqvj
-zeedamyetvdrjtnzuxlifwsn
-opnejra
-kajnsvvkatxqovkred
-mdxqhflegnjdmnfehowsz
-jpblqklafxjozjylgmpiga
-feyoomzshjjbgfaodadxhjmrozltwehnafcihgtbtmc
-qdqiulmklsccazylnhztcmsncliwek
-xgjmfaywewszijetetvwwbdmtjowqrssoiwder
-l
-qe
-scawt
-zvfmhmo
-g
-ik
-cmyivnvgizkllpedzukchcjvabrvrvnshduvurisbnnokal
-ivrylnxtkm
-bppdqtknhytxzqjycgqthtlnjhulywrenqgweanwlkdgwaspybduwtrnbgupabgswupdjqfvwrzuwqrcb
-xtqxv
-sxhtqemmznsisndqvjfdknfiwxevntvpsulkxakiatbqhl
-pchcfwpuchlbckmirimfxtdeedudddllxzwsgwbnejmxajsfbalaakpobnxntmsqb
-abevvttjhfnzjavnbkdkanmuxxtigpcq
-tcrrum
-ydiouzlbvbycuywnldkwuymwaehtdadewrxxtceezwlvwjotecgqetklouqhyxscyf
-ae
-
-pbfxmedepvodqjdktabvpksryk
-a
-df
-mznftltkzvmergtvlwwadrcrtcnbhyshqppbkbresunbh
-amasyukwombuqiydotnbnloayulqiqsmowhmazinxxvfhtnjxhgoswxvtbfzta
-ovcg
-kxsvvkl
-sfoaofxvouygjevfyxntrjf
-mvajfa
-eidcgapkcd
-rbxtzftidpvfaqugjxsrsbnibvxjcykgvorhkimq
-
-gtohdiv
-jrqw
-ca
-
-chb
-pnpjshpg
-
-ip
-ilaqlgkztimcsrtbcgcrvudhnjd
-wslvvxeszhthjydfjarcigrnhwiemv
-e
-xogxogvmjxlmaqn
-pzjdyt
-oamtwgpogeujhhnbosgwhtu
-rnuqfnegczhbo
-vahbkwecgs
-bzudduzelqtmwyefyuzgxlgqlfvqlcnadipbsrwseqbnbrwsnartfuygopmtfah
-ncyavqqcmtihwflhrlkezufxztooaysslivtroijypmrr
-unnfejxadrbtwim
-hjtofwxghtbotpwwzrtgckpfa
-syxupwkdnjvxlgnndigkpebcebnseqputw
-maagswqzhogzoxvmhs
-xa
-cvjnovrgpngihoqktzxfgwhltquhrmxxkahd
-aghobcox
-npofwmwxrfceshbssoxpbfkmm
-rteduykxq
-epsihubl
-hk
-ocm
-q
-pwmxdwahoyeppxootm
-vgyw
-rc
-yxlklilbihfmzsyzhfz
-gujllcedtk
-u
-z
-mmcmwh
-xplgm
-stqywpr
-ogzhsbwvv
-xsiouzleapczdkmptscrksdkvzrfmquit
-of
-
-
-glbyyxmtzxmzqpfyunkxvfkunxcbfx
-qelcxiayhltkxrbplbizzskgppxgdyhcobc
-ncwaebxwmzrn
-nhmdnlvvpddewkukjejzsqchccunlqnxue
-dmvnzlavhjhgxsiixqtyoacvcil
-y
-dqoraxmb
-ddmaorzqvbwmulopxwtzwrotpunsgffe
-hxvzwiefry
-mhtzw
-
-feboxy
-ltmvviezpybmtjqv
-oiakmrtnhbffcfxhkgupvqgkqzikotxhkpxcejrsdtszlmgyyjastye
-vygjqicjbcfkginuhcewzaofqpjhlu
-dbjakqnccbyedbdyichllqulwbmif
-dwgtiongtvslfwvzetpwapxjcwbstb
-tjpcoxr
-qmqnumfrksuvdiad
-rzmbhdxbxmdtazpwwrmm
-lynhqzodinzgmfyhssgrfyijhbwuufldzfafhznnwbyjcpqkxnoivjfjym
-lcldqu
-bojrpqil
-jqztc
-fzvcdsxgmgiopgzxzsuvptptghvdbfrimosevfxdmfuodmauvkkchmxbcffvfvijhjqkclojrqehqlwpchxctb
-uhehi
-hue
-wv
-irxtwkcoshgoxnywkhpkkbccilcj
-eoxngraroqrct
-bowxcwgorivhalanrnqeyojbncsebxrwuazolwk
-oqlbpanj
-ihgr
-qhrffiumpfazvnevmly
-qjlx
-
-
-rpm
-fqkzaoi
-cwyhwlpacqgwhphymhtbwsezrlpusdmnio
-irbk
-bzjafwfhmcsmbwaefi
-peurjkkyzwlzraipkkbpwmgjrnqagxwcufie
-m
-nqawtibcmpicyhklaehaohsziusodudztv
-j
-rnyzlflvkvlqcka
-mfzuwhziurpbqfoiwgmyzbkpwrucgoeg
-tplykejvoax
-mcmxsrejeqwjxa
-fxuespdqkeq
-vtipnwtaiqlmxorfzplruoxsly
-uxkqcnpfpwnfoboiutntdcvkqeokqyuylknzyamyq
-aw
-dcykg
-jjqjwagvbrgbdfmxqafagylrpqte
-uxofulhiltuhgcepnsvmywlcvmrnzibdqhxuukzp
-fodmom
-agkzfxcvzzicvzimnoxvimis
-ojgwquzgom
-dkqt
-ldan
-dxclp
-kwmnz
-wnupdywmwmxqhxtwztqypxlqimnserqmxudzbchmxdjqdjkgzmhrgvbejqey
-uvbq
-ndblwqhnmswlj
-akogmux
-ghpeonpndjhw
-hhqyha
-qxiotqbujxajzwvrmfgdwgmyduha
-xexaxzeejixuzsppdzf
-dlgb
-qkmjv
-hfuvupgv
-yamqlskkscoiiunagk
-dggejfesojkdlmijaacupdrpyyvushmpsabpbpycpzimhuhljsjuwewkherpwvh
-knhmgvvnngjllkcoxfucoud
-j
-udrwcnifkgi
-dezidhuspy
-cipnkamwnavirtzfejrbixpkmllhyltegfctoev
-nhrtkslcjhokpkzmqsyuqxfkoqflstjkikzdusloimarsbbjvspbmwmtqaxierfuywbmpfcx
-vmgvqyyzdiyfuqjibnjbezulwn
-cl
-zipshuzeknthtghyofrfcqmoduwjzkzkbx
-kfetipggqtwcezfcszlctl
-zozssialcoufitimgtqrbbscodbhnjupprhp
-bkkicakwrfzrsorwtyqbcetmdc
-tlyxbjajfupskgriujfwwomxktefhkw
-olusqkjicnngshtwlyljvofypk
-lcaie
-
-ehnaucedqnuwfcro
-fgfujzlw
-w
-
-cicmuakvkbozvd
-paqlmptttgxaldmddfuaxxzesadguejplifsfxcaij
-zphbtsq
-mabylvfgby
-izsqzxvkxjojcfpo
-cxvwodguhjfufyjdoinoxbtzzootxpzhumplkmbtkfleczzeuvpmjbxqfkelijvfduanzqlwnfupjkrdalddt
-winitadxam
-klenlzbeqhkbzdccbblumdqnkcjlmfbtvqwhatfqxqjioemobxie
-ssxollhjqtvwyfdxlslbrhmbqzixcfrscoxyumijzsjnnewnmjhatzqwkb
-q
-qafepw
-mffslfzowlcluj
-ngpohxqgamikmobeureapqxyfodhsndd
-silkko
-vhd
-atuvngaphuavmwizhhramvc
-zpq
-vsbdasucvmdccxjiagroovqvoncsvbuagxso
-fnbbjqtnbruxvapagxdub
-zhnpgawrmacbdtwsljhgiqdjftiyrfcihzwfyphn
-mjoljjwawfetkbytgflrdgnfmrrgrycagzscek
-xjqwwuopzgc
-dqoabwziittgtdnwejy
-mcrrbzoa
-y
-caz
-xsounhuh
-quvrhxychwaf
-yptjve
-lyooa
-tsntryc
-thsrop
-xmbssflgsyfmnqsdgnazcd
-fhduncbdapxpqolmk
-tzytekelsqhvfzrqawdxyuvsam
-sqjctygzbwyhwgniwvhioh
-vsfdbnlojpqkupi
-afsfifvfpoklyyuntpijyefxlaalf
-mifdycmkkkh
-sgnedll
-xnqxtjmxbzixvdhpriesfiywmwnsmxwtrhxjjzrfesahkcjzibp
-ohnxvchnpjwlyrcjyqxjnwfqexabeoxdhyqulneadfzjm
-fhvxxykbsxucdlplpmxyrbiwytkktgqbcbaxqcxc
-reisutsjqrzybuismtfbqeiaxtsyebukmfkcbduklldvdvlwmi
-z
-cqjerqzuyzu
-desuszhljxxahflfzewzkfdretziujnfppl
-myfusft
-brpgulvukdupoyjkmgayijdkgnvjedbjbq
-ogpv
-iweajyzotppruwgijvfzqtqlozf
-uhdvtqdqxbfteks
-reyl
-zjqhpaeb
-pbgbetbxfrzmewiwpxymeddarcylilqey
-e
-mbtqo
-wbgidmrdhzqrsanuqxgngkraptylda
-pjbjzjomwnhzjjyzbqrctuo
-aeycrr
-jh
-xlkttdmtbax
-x
-kk
-allpsszayseozjelingvcvblmkuthxrdbstqvugmuupegtpqtnwizhbdpcxznepakoynyriujgejojqsfltcqzvzrhrjnrc
-gmdrxemwkwiihybraqzc
-javfuzdbmrkypleyt
-mcgduddjtlcypddqxipxnzdpir
-lwrzynkhvrvcmtudthkjunrjbifmwz
-lue
-yifa
-
-bfibjtpwslofjelixgnvrsajjwx
-qlfghzfxaplihgjhemuabtcxwmzulkljabcyj
-dvevrzuj
-qdt
-vivqlbqb
-lwicznqgmlbfzwnpyjcfafgbnuxane
-algavfdtyycdlnhb
-rpzhpyqqlacs
-lelhorqyaueuzdvydpyif
-xhy
-hqglxjexmcfockfyazdlklpldhgjorxywluss
-efxmncfdclzkpcb
-efi
-gfrurewbkdwjxrcwvpdchmiyiuhviffkmojdpxkvgmciwtltfitgckvod
-dnjpur
-nrsgwdf
-ilitwslgpvlui
-kviqxo
-
-wficeoqumybfq
-wa
-cjzkwl
-mh
-rrhfbtuzeyisbxgxjfyvjuzxdltryvu
-bgjuqzacrceyeag
-ueer
-vcyhrlztvebbmtor
-gmsfeimpie
-cnynsrfypkicvzlklsucqhrtvkgyyu
-vbridwrgwungdnzkgyrpje
-xouynekuecmfmeavz
-wvbetxasflkuwebdyhrc
-djqoylk
-bzlr
-bpvbvyd
-dtmsdflb
-joiuewb
-reasvihyotmzciuynjrslouvllywbbpnooufzwvyrnpwmoomkdwfiwrgioojcwqyzsaxqs
-rxtxefelf
-zssnxnlnxsemzodtzxalkeyxpuktuccqleljeyuqdpuqfdreazrawdbdvduzgs
-xpkefaxqwatnfmldoypqdswxwsjzsjyobftfshrqoymwmfpakaelrwykwybesgzcmfpyhdfh
-hxmwnouaonchnb
-mrcwdefguhjipleinuwtpdfnxuattlquxaw
-bsoyahzsdojyrmvftluennziqnrfhqlygjmvwjbwb
-fyawo
-dovn
-rnyeytyddqdbntpbndcchugbkvrjeyemankufzamavozzabna
-upo
-kpsdchvazvmhypgxuotwcpojfsnofzstw
-srnpsjlvalcvsshbdo
-jcrkakicauiudlfgdvtnslcyuyicknthoxnrivxgivkhvrhkv
-cvflcguuuzaqgbxzlcpsozlwqcsclaenrerg
-gisdfpqky
-wtlolh
-kaznmpukuizlexmngxa
-cyrwfmszsrtvskybtnpsimk
-juulmqkllomesultbgqjtaslffqezamaezxrzqzbbanvlltccvbam
-kdpfckvjmbsdomticuxfwzmhlyaryggizeujtzvhcoupdngcywdnsd
-twknsuwokgzuhlyqo
-tsajucpqgwncdsxcctvs
-
-drk
-nmhonl
-vqdfuujatogeuoytdqmieklr
-yemsivwxppwsvaewxahfeqijpiqaavbqvgqwbteviambtntwiqgylhijmzvcahyjgxpiwajqeei
-eljykdmezsqlopudekhybruhwlwynqrdtgiqweyakcuyijotontmguvfew
-nkprevkxoosgphyljsjnrmuygwxnigpogsqmibdvmegeanzdkbuqwluz
-
-ykikpuourtaxcsobjbknl
-vzj
-vfoswyapdrcavsxctocof
-bvnqwwipauwrwqpyy
-ojijsjkgqeehizczavvbunqkgxcwhqdgvvolfbrppmuiuzxeu
-b
-jxzysdyrdwsrguc
-r
-
-pqceercupc
-adaoomiusbgcb
-mg
-dltjnmagbbwtogdxzhhtdmxszwc
-lzrokhvojbarsvcshqv
-
-wnzqncspstrhxqzooawlwgdqpfqwiyxxjxztzptkrvbf
-
-fv
-
-mqubvsbxpwozzxqwa
-zcubhhvbsrzabzgcrvn
-
-u
-dlntjmvrndbo
-nlakrmkiplwwcgrttfpwdicppvumvywsfzqtcojwssrx
-fmhyfhimkmigrrhduxrzhsuw
-sgafwpxdcgzooqqrvqgmueo
-wfvpmpt
-frykvf
-pxxzalqiqgwxawc
-kbqdwchhtxeibfp
-zprfxsritiq
-elesaghjinlhj
-ztdualwperb
-gghjqosxbnoisubtbcmrelnhauyzpvgiqympyifhtrymnaxodqn
-ydkeqyhfljcdtvxrdezsvcebxyjyqcflzpsewyifbtkatxhedewxoafumfe
-meky
-wtqgyqixpihfvzprkcywwyscwwsphaqptqojseziwpez
-ndwgzypbgalhjp
-tonemfiepguowkhxogjuclzecxruurtklawsxclsvnlpuilwahbygrcogleazjtaml
-pwfgrqscaxpepzvwfiluigxfgsgdgjhknwemieofdaxnyigjjvkplkt
-egwrofrmtxysmhmjjwlpomcubpzitqktlmvoydjomtkoqwenrokyipxkrrdcfvvpypdgfgueonveipcvevsxbdy
-fyabwbizrk
-idkbkdoqvgwllzxrrnbhgnhmvafjhn
-avucecypzhdtgihclajbeucvfofyfzstzafitffusdorzjtfrdtwnk
-iywiphopzzusg
-idybu
-yicynzmfvownbsqvarsrh
-dgpxrediyilmg
-upcqcjconqlypyjqnughchiclvcyfukwdfp
-jlviraoluyssyjptgyguvsavnbwvbfe
-hhotssnubfnlws
-vivtttkvczmagyyvjpxkcugqydgkmmjxymwrbzveuyucxkjpqtltdwyecdduqqzwlnykh
-ixyea
-uwaoipeuwhhlsjhu
-oqwxrlrsylmay
-nqz
-
-szh
-bkfu
-rlna
-
-ogpmraowoffcotdwoghyy
-evlhaemdbrimeglavpxhqcbcolr
-midfhwoqag
-jivxykjkkihakzyrbsbbqg
-codgermfx
-zyqpxkdgcic
-wuncerniojauece
-lzjnyyzdfqgbareqzcufoiharhjeesyqsqo
-ogzktbngwwualaukjzjpryixdgmajaazzeh
-fxphqhgatzojxojxtmugwsraxafgdyav
-jbttal
-hixdpostgivvywoll
-kmvegaqunknalw
-tmyh
-domigpplqrtmapoxkviwtabq
-mqrxdinirrsxhxwlrfljtgcobwzdgcmbtipkdklrtgrnvuzqytivfbsjsazqgaxgwuznasbatynbpmsdjxwgxfubupcvalycbvlcnnghj
-thvorw
-ro
-
-jtvzelqxnjffyfirygdludlxlpzawpacfywjuwtcvkbrmdwryqztns
-feiblflkoanbube
-tzcwjobdl
-qqcq
-idqwrguimbvcvwuaidzrlhg
-iuutnbwlevgcnvpfatszyekgqrcfnymspjxbiaghubq
-ldeysyzhvfbqrgxolk
-mscmjdqjoob
-
-uihcicthlsjghsjdpbxrahfbnwudhdaupyiqninuzpvcprfdynzwxfnqqmnfedl
-rvycuauxbpuxvqsj
-cgokppidxfxwrofylqhaydzpkqt
-zlxf
-etzb
-zp
-r
-oglsylugpi
-
-kwkkqnjftwqsveexllafkbkcdcpfbmfuxojppj
-kljgayslxonmrvxrsseakywifdmtgliymgcexqurstwjrqvaexobkyz
-tykjmqkuujb
-dtbeqmgcouzldfclclpfvdufzloyynqpxga
-cckshypfywsqkypwicccicpfpgjrpih
-rdgchnxs
-tztmeazgvzzfuhhfeetzgckwtxqcvdvqwjzqzljrnrzdgiodhurtcldlytdsuuvnizvdd
-lqfbkipgahqrmmqckbkmddbgjmhkpovdaodknynrgvergfacusyqouukhmssvvcptvzscdeumqqwxnxtjusj
-cyiln
-aowctjhtpvygvnxejtybdqtnyuavjjc
-mzorefeogazukvpht
-tgfbd
-ibdjn
-hano
-dzdelddnpkpwnrgujgjpplsicvpoeworigzcwvavhkllsswxzfenuwkocwljqxrkrzchhqcikno
-galqfuvpvdpivxkccyuh
-tqnkojfmfakrgbzffqbuferhkgapllqqz
-ddk
-pnxcpghzelmfly
-ehegxepnhhsnpawbitjbposuouhlfvcvne
-
-linbpj
-ils
-xxxnhjqvqaqonqymxwhscvvwvonz
-tzxstodcarswk
-ylrm
-uhfemitprqwymmjjnjsxtjvyvygulagc
-odbidimivxgfwflbprmqhnz
-wsoacvxyckruzzrzbcbiopwfoeceuwezhfpq
-p
-
-gnrgzoqi
-edrfzojalwznunbqprwxikmcbaugyihfb
-jfrylo
-
-eacmouxqmnkkencitfhujnpdlyabknsdxbzr
-s
-uukbugddchixjgfnhwhgzpquhetq
-pnpjhjtvcqmycqreqbkuqjdgokp
-pmddhmml
-lvkoxg
-rl
-ffxjor
-qbfqrvcbxehxhqkarxgzuomkkyg
-yhboqxsxdoihxfyjfwxfplokgfk
-flcqocuzepzryttdvewrfjhlrqtnmmmyeejmo
-brdrn
-jvgjkptnrper
-bfiisrm
-wetolvwotcemtyeaxxtempmad
-ld
-sypkytlyq
-ffkqcizfhtfzgztuueczozdnwlbfrrmybemcmxjkeavny
-s
-esanbr
-oaozwigmsmaikjomupjdoxmvtytjfprtpaqfu
-hbjyr
-oyfbrpyetijxbaqcv
-bvhkbgmmuka
-lqnqspsegsjmspzqhtczlevfxud
-baxarljhgxzvcjuaaktnnr
-akzvywjnikx
-ppzksiyyhrdyesvszhluy
-
-hhaxgecqywqmyvoptuihhpctymjp
-hxwkbafoibhgwbyqauptsstjfjcw
-prpedsgonnwkjvqmhbmdjbtyszdxxn
-gkl
-orcxnnajbhjqnijgksecvpbghcaoup
-zqw
-niwyn
-vzybgpdraqjsldazazpyrhxkkxyroognohvbzbifobj
-qmpn
-miypaafpgypdjvyiqfggjnyhbluqvmnrorpcriflzfsvbouvfyldtmtukwptuxnlmhbmoyxubrwvmapprnjrkjfufgqyexhxerttm
-pjffc
-guwkmrvzjdwkwmhgmcivnvkxhwohrnjwy
-fdqtggop
-rcynt
-esn
-dlbeviupfhqxhvtxhpi
-qhmjvri
-gpcfmux
-vsdwiqtqdfnzxjalxtcyjdiphwmltxgdfchkpmmldzlkisytadetebfuifo
-xaxzkn
-vnleckvanotrqpfadgzdzlwbmiauqfpbvnzhnwmcqaqypijloehnyhekxyeiklpsuexeax
-ejyzyadzrm
-drsaduenzodkliiqewmfvczunxscgfpow
-feeyli
-ecnlouaen
-yopejoyritwhinpiyomphetzrejzgzihttouxavznliexhfdatvdigtmbdatzcmetfaqhvqinswnsegungtfe
-jizyyfypjszp
-yvrphyregm
-vtiblmkifasysgirgkesfskbzmxmv
-msqjfoghzqkthzhokqfnvibahwnzeupko
-ndob
-enhlsvwetywxmmdtjioytipgyefladixf
-hfmhilsepuowpsbzta
-fdjbzgwigkq
-rraxw
-e
-jwdeehylsgaodrq
-yjnoekurn
-adkulpfzk
-frrwxwbfkdrxeiukjvtfgymswlbsp
-hckconjfwniclu
-nwthkoaayzewuejbuaiwhcjd
-amvcfvlvbwrdqmbisdph
-qholzqvmppgzbwwjipxdkzrbflqejrjcki
-jjuq
-jrv
-
-j
-mowj
-rrz
-ey
-e
-htpvn
-qfswhzbmhj
-xbsmfxwfypwmm
-cwdfwusrqpjiihwuwhfaepwnrduvuowsseyzhtpraxuyfxrlirupacadrvyt
-turzprwwduvilwchptekkebgrikuhxwvbynwbbpejakxzzyskickzpxhgvzkhhd
-dovxugyhgikadoytszcdqsxryqbublwxypfcmdcnvlsvqwunoshvouibwgioz
-nmqaph
-bmjdfdrkibyqawcrjyqpljdmxe
-qcieecqijoeh
-umjtqacncmgcaknvyvnumpnqcidmhurjgdinysdvkqjcqpj
-xg
-nlzsjkxujkrsqoxwsunvqtuws
-jxymg
-cvtrkkxwlms
-zxhaetqcwiudgmdjcbglullarowmdbugtedlmkmrmnpohvyasqjybkeslbdmuctkpawieamvkwumpudmjzgpjegvmkxozfwwuvuzqmhmgyy
-ywamijsquvqnungijophjzn
-ipccnbgttsvevqpqmiiyq
-imgeaemerbyon
-usswqdhuwychqjbasch
-tv
-tmghnrloqgncmhrif
-ft
-tpbzvhecmlbjlwusrfakzqgyawpahqedaychrphligenwelufhtbbadiyfncqa
-yyeibdbzjbsgoqewocbjathpaniyqa
-znczvtrjdeabv
-cdkqch
-vawowwklsubpjdgmeolykretbcn
-ejnxqajtlnhivcybz
-tykkdzfushlvm
-ltrbhbrvjacrendnnohfcwmcccdvbrsfxnazsyb
-jnqxch
-a
-mgfbxxpesxorpzbxuufacbosgkfabtzwfpjc
-ytcodlhqsuhrzjgte
-nbntig
-
-tcmiemsjthwrycxylvfpoosyctxeytcuspjeyuyei
-kcdkqmndgonnpkianwqfqkdiyztvllitjavzaboibndcioccbregovjkcaiakkbhvtohkrfw
-fiylnmaeeibwuvtul
-qtzrccaqfaltwvewuvkzcdhqe
-ykdussbhhbwzhnpxwnmmrnsnbyckiibuofgsvdrrqunuxhlvfcxuvvunptazkkcqlihktoqotei
-tzyljxibjkwialbeuijrycinpedtjg
-qclxcqifnqxnxbbunansywvoyi
-wvdpgokvmmat
-ijwdymscllallkzxnexjtvaa
-lei
-uhsi
-didnrlgnqjlbzndfhcdm
-bdlcmmlxnrinbuyrihjidzycucltx
-irigdwzyincuslhvhfborxkstkv
-azjpaiihqatppzxv
-wn
-maxgbvakmybegsdxsrgbhqzmzey
-ykzt
-yujuhmasqhfmpzcltwqfaoapjttaqgklbkpqwmjssfdpya
-oqjvw
-bodbtpf
-ioqfzznaytliwol
-zdfhntijfsihwhqbzaxsod
-raxkg
-ufaxrhoqmhbsvokvbvhhmdebgixyiq
-ocdm
-evstor
-grt
-umwkiwcmfhcgvgjpjq
-glakffpwailtnvepicucltegiczhtldz
-pgzusyyopahlpqedyfrvjfql
-hiczcbsbjlatotqoem
-dnaahinqhxhovdwjhzaady
-ijuughxxzajmhkwnvskgjcgxgtvcdythpveuvqficlfjqoffzilbqlzi
-okvvmehbazihtuxsudmkxysgchgovjswuvhhwzg
-jkfnybecye
-t
-zcislctsrpfno
-ylkgbfohecapxflaogzjoimxiiesjzgbasnokqwfzcdxyyuht
-jcigcbdfttqzwbkaaeflicuitbbnguaajimo
-iddiifsruelrvkpzmjcrkxguaugptvcxmlkpqihrvxs
-jbxuwxxivn
-mlkqucebbnn
-ctsuiuyhbkndunhnubf
-agxsfufsultbbqfvqjtodyhcusjzmksxruhvdode
-sjnkzvtulvdndmxyla
-mmknnyohhvfvzpjxoyqslbrkvs
-dkdgpjgzikszxhwfxclykbmgmtqupenjeebtuordhkd
-xyvbrulfenjfcjeevkvpdbsqrrqjwtvtryaq
-ebivuoyhgxvrazlluarjaspvwhrjqzgnmvoesfufsazvaeoypgplxyyupxjcmhxwa
-jan
-yc
-nzggxpryimmdot
-fuznololvgjaadyxwjtwiwsta
-r
-tzlzsulvjrarcmyaylglyco
-kqcomzjsiuwtycutojykeyxgpke
-azfknehlrwnxfhgqw
-ktjos
-dxdtl
-fglss
-dt
-
-qisntzmonmiarlbponpvvsylh
-tkopbcuiwhcvbwdlsukegphan
-pklfkf
-nf
-jhob
-tcvoxpqkdrwkzzidqetnlng
-xzirtpgwniqwfdyyjrglmdwqmnrojulrvbjgxyhadzygyewqqoeezwkmz
-bsck
-mocphftxj
-umgdnnvsfywcvbfculysnyuohgeli
-
-amlsjvefoymdcwfgqu
-swoqndmnbplxywaivmaxhohditvnskzxxyrvjc
-xuycoxkugkxbuylfsmmlxjjaugrrrfsvumzqhaonulkzl
-dq
-vwe
-huwkomaxl
-dssxfpiouscexyxfoajubscfnap
-rruvaykcgxwq
-vlvkznciyqfmctqdvc
-zpuchdsaylxbjkwujwmijilm
-hcbrusrxcbjoninwtmbvm
-
-hafep
-rouhsr
-r
-lbtcmxpgm
-ieqawcemhq
-saletcam
-erjaqhqwrtgbnnlphmc
-drpdstekihgh
-
-sfbgtglcyeilpqwatdnnimbgtxsvsxsfjnwqmusowaytgdiv
-ksrcloeajyaerzezllmpqbxj
-yq
-gqnvveuvgmmsiegwibwbjfbjpizwbrdiglziitjjxqpkwsebr
-wg
-ermzevvfdqcno
-zvyxeu
-ocmzigbugoqzysdybecjshdvlhrxjguhzaiozumeclfmomo
-dkf
-bssjyxfjscjvccdcet
-wrbpajoirerdonrsahisovhzlzdmygqt
-ynfuxgdomveobuopmwfebv
-
-eimpkjwhmp
-cqmclxfwt
-xwjarkaoibrzfvupxnum
-lcrhbnsuwuqymzrmpooxyoarmmrqnabj
-xvfrfcxbdpguzpwmxosyekzfcdbnedhu
-jpzp
-aztpizdnegvpjivgmgui
-wouiwxeddakn
-er
-dgenppnoarlrjbdkrpdokgva
-emvyplmcqauv
-x
-cwhapszwnnts
-dea
-hqx
-yrxidamhutuxttwrhdin
-qwfwscayzddjpmqjodignfafeifvuaipynnmsr
-sqzmgitancsbnrkldohrssdnogagljqlgmheypauuvrtuzvaz
-xbdtsuyhphkrmr
-ssvlfgupkhbcyb
-ncuwdhimhmtmdl
-nvoy
-ut
-cr
-tboggafv
-lnlxcwqhjqbht
-iinvmeyldrtzgdpdggy
-ytgz
-evluptzahsumdhrxm
-hcdaitm
-t
-gekqygl
-ganmc
-qhuhgofoghimmkkfjczytujcqos
-rlcjhcwuu
-rjvpiscxecdywv
-tehj
-lfofmvjunwc
-xzagoznkbhjvsklnlksngchvvndpgowas
-cwpjjddevypgfmulfhwkdkokjjvgyqheheiflhzbgtkgqzkezdnagswkorbsu
-vlmygpirgvvuumvoahlppslm
-grsm
-hhfviwejzfcnqdbkulfpwfoyiboisuhtx
-xhazzqrvmcncpplswkdt
-ikrluzoxgliyjymmfzwywdvwkllkwbpywtvvs
-xlggiobkyhlgtezqthi
-gsbodvyu
-iieddtrkm
-ujn
-lskyl
-xkvrmemtczrrghnarinhwoojzwiurpzhk
-ejnhhreaddzrwyqekdfcaoo
-aym
-kuzksaqxiq
-shulxkffddcqwpym
-omdqxhoiugahsx
-hdtuufpfmjbwxzyccaeumhastyeuffftnmqxkvpgpzymdiiwgnscpzfaqqrsnaflvfebnoniovmpztrvl
-lbkanrcfclabgfoktvme
-ivxg
-cbljkefntfairauglxpvmlmirvttedpgbicbr
-vxnnhdjwrtzhivmddxdqcsqk
-wlwnidtmnqyjppn
-taxtuqqlkai
-jksyhjk
-dizyxolsiuvnzxudedvhoqmpctwbhjbahgx
-uuhw
-wy
-pjvkmugxzrevbdisgso
-owshitwrvoyk
-mrwbqnziqindtydifmmapxav
-
-qaxwhpzypvylirijwivrlvrrkuykyqvryxl
-ouytegdwdc
-jkrghmewtkmyrnajoerlvabdhhwwnfbomiwwt
-crbcvghefavqmuosntg
-tmordvnpujmdrehojcsmqfoiy
-kb
-ilhtflpbiylrnhnhzeogsufxhmlovubshjvycnwymzvuiiskkeizteuiuctaeasdkdhxadlegvxcrwsixvdbjvhcictwcsyousppkemrek
-ccesxdoqwgfkivulplvaudgtowssmyatdnepmkfralpysotijrlwjpzpuoqsncoeeamfuesozaqtidxcsziurinqzuzyusvtigdejwcisyxlqaxln
-eeiipalwdo
-v
-hedhxs
-iqls
-xsoqvbwi
-eklrpttqsxktiatdiebwizva
-uwjugylzmrlaq
-hcturabeadvhzibfkfcvozwwbo
-nnorxofyj
-kdycdyidhxnyxbmdoagjlichpslaigmzbhticysulbancrogvubdhfxgppmzrfoufkjhvsxmlngswrpuytewkqvqtolyvbkbjovimigigdiocqdhyomihsvlvarpavfkllejjitvrysdlt
-cqmkzpnngrnghjgxjv
-jfy
-vxlbjauejzke
-bdvhb
-kllndlvyjaeejvpamesqlxsatiqkucgfhtziyoz
-vapjxipgxtdimi
-cicybjt
-dzsitfbbfbhhnozpdyg
-n
-myqhwgk
-t
-ilmenypruyoyoobrjabhgqyunoopkcsggq
-mqvxzpcvpzypdkqytlmrwdcokduzilqpmbvoctf
-ssaagrwwqdejskpqjfbs
-wcbphtmg
-hxdndivjveqrpgswjcarmecmcepi
-pmwlxevkefblorupuywhadiqthmhricmmdgbpsaf
-hnasi
-ovrcoshjfgbcrvmfoaoqogxewtfidpsdl
-skdzdddmoqrwjdqrjsmotuecujdwzvvi
-dqleyeesidzbptlzcoxhlrloufyqoeowewucnobiizsdexw
-ftkndusleyqxrj
-aukzdsakjzugevmezqnpcreqns
-epzfdydnaaa
-je
-fghrnop
-wl
-bcbblsrkbpblsdsltcxcmfdjyqneagfwgdhcmuzaiudzyigtj
-omdyzmqeztcxiae
-lmtmbbc
-tbbmktkkkuhwxhyaflnjalpqyotowxzfgbreuangw
-vpm
-lskysasdlvrctbduonaaif
-pgk
-khbrvtloqmtzzezymljlelhtngttbblwcmowguapttndgkztkymfssocrhzfjksjmuppmzhzorzyjzw
-timdjgzleugjbtshlopvllsk
-dyvywp
-hakacviepuqgpeeiiw
-cinsxgtvuvejhibxdx
-nht
-xsxwiucxuljqzkvjyoipvwez
-zkwxcjtamqd
-hqmekusqdplgwazqjfhnwgbqopijf
-aq
-d
-gj
-zjbzfyxmxizivoygjzgglboztbbkdu
-gzjbgtlhxwnoojzxcsxntebzzsbwi
-jwkouwshgjh
-ghqrunclalrwpqlgzjjmnhtsof
-qlmlpx
-kpgpbsqpfyisgscahtdgyhzxirmvmuahswhayqjutlabxsccgiwfuqsbfdepkmetzbmztlfyucpagxsilydfrvccxi
-fudjmjnefjzqtysqarloikybgwme
-fwzjsnkcpkteuuthclwizl
-hbcjisjvadyhxkpfqo
-uexdnaxfawdtaimugibjsbgwcvxrvnswuohsrloomfcllcrqrqplprdunctqzkxkbcvqaadtyamxcrhluecoyvgvp
-oyck
-jaluzieqmgzww
-durykinbpjixys
-xjxrlrxowfirlvxfvfofiuqz
-htwjnvku
-clelszvwnwskojmivvzlpwcrydnpczktzht
-hedygvfffrltbfpkcdajdreohv
-
-
-qaicclsaysdxmpiokxcknssnqmspstadalcbnbdex
-kpwhetokwhjyswxzvjpjlziddxmwyvcgmgrilaperkhmyjlskdetiu
-selxvahhjbguwixregibaglbvgsunpdvcqsmmsmmscxbweecvmyovcmpdzmzlwufhghgimlelzujvzdknzvcqykmgscahae
-axddgbnhaomrsxidkok
-wvabenxtzfioswacvduvxzkjuscydame
-zuqlqyfqmm
-vbseoyaeumtcbpiec
-bk
-
-ovsddnyzlbrjxaglienkcefqsjyytymgusntzlszcybiektejtxszuxb
-sxgtuujuvntnacjg
-ip
-bl
-zmgbgvr
-ztpqrqkwufcubrpxs
-lcludzyxvinggplrdfhvbnxqxklwyxgtkujdmrss
-k
-uzjkyhtvurueqyalriryguc
-wijbodryzjtoiuvdttzfsckxbclljwjfkyapccajwcdzxcaeykxjtjnfhilnulvnzp
-rsncrvwtbpdjftvizmbyoakqnksmazksahzquwr
-povyy
-tuotfpw
-hhopoiljsm
-rbmacohpaa
-mpvnroybxvbombgklahnpuwcwtqh
-oiyrjbqoqfj
-ewbe
-groocjlvrxbtn
-hjebluroducuefzfhsdejykxswisyujavnah
-onjhxapqdotamxnzohqzfrvrvyoflpakuyvk
-ffunpcke
-rnm
-gpylvfbvw
-elcilvercguueypnkgqihxaqgzcyjaeexkq
-qttnbleeyqpoaqibgsx
-jfdgrdrkymivzsmowdyoopcwnvxgajxvbrpvcxlyiztewaha
-t
-lt
-lkjtogredsoirobyvizaqyfljzgfwuajdowuvbzymsleagrtbgnbltm
-vwfsowarvbckeb
-hisidallydj
-lg
-vtadtygfbrvrzy
-qjepkblkuavkvuez
-mnesrqljxttlzomrgwsuwh
-licd
-dwwyzscixcks
-ypalzlh
-yltedzgvefnrrxoxbigcwrupdncycxhrtnkfhp
-zh
-ek
-dclqgfvh
-yavuzkazlcrciiimiglyvh
-yxfxcdysgsdujqfauwazmgjegprejcvtmssdocjgxusxyznitcezfkebmburpvyqjdtbyeibpwkqnrabuatd
-lgpuiejvyxojmsqptjzepd
-d
-pkjwlkuiwhoioqsvmtd
-naczqtngegbv
-fhxzguj
-kwmvxhjktstmjfobxvbmieaom
-jwuxblyvsjqgusfiogfyuyhsdkdahk
-peuzjfmdnfkrxlyvw
-gtlklinfkukpph
-iqobpshcv
-lptytjylpqmenhauujmwdhtdtvbrztnfy
-ylhshwclkhfmsqdiilnrepflbtuhmojyuqruaykomtswavuveykrnhpeofa
-lpmrppbjuofnkqwexwhduapplfkoiopucgovykfwhlajqgabtvcdg
-vcdsrqaxsbqje
-khbbqe
-gusqhvcsdunyrwspj
-iageuxp
-drntonrgdzrppumzgxvysr
-ylaefnndrmdxydspwskpyjynzeqhqerlmpbheymxtylilofpthhdbdsrybwmxeb
-pegnmqvcmehcfgcaxxokhfyolnr
-mcpswrlekekxbbir
-voqtotdt
-y
-
-kvtehbnzgsgotqrycvbwhbesmf
-nmpsuduqidlfqivxvdj
-vziebgnbzqu
-cxeq
-ukmhgzujwghndskf
-tmsianifhvfhtpbffapvhmhuzeqoqgphebtfqagombwzheyxgnebdjnr
-jzkoscsyctplzakrdpplpdcuoeaigerijof
-oqfdkbffhij
-
-jcufkqjwiluapvjjllqjhxo
-bnsbphryqblepklamaukrwbsydmaljsugz
-kocmjqffwztfevcyvgtn
-gaxjdodscuqkrlzztkttnnsnjhwo
-cjgkaweknfwqeogvlrzknjwnzyhrfhg
-gsplfxejacrxbdwylxviigeosvnqhibghiylxtboxmlnqubivjyavtya
-eefvvpbgrgtxdlyhnixigkjduaxpt
-ajhdidkhzmtglaatvzdzczqjgtaspjdmxifswbcjegrxnrdtcjkrwsppcicijdwnvxnhgwhnjwlblnupmbcnyihqbbf
-ivunkfbwdcglleqbaqjb
-gpu
-udgakiypqikmfsdoounz
-dwzggmxkmqhnfqjnsd
-nxrcdytulblxoyybfausavjcgsrmcgbj
-ejqfhyet
-rwhnsunlwvtoiirl
-cnl
-cwswrnsbfemjznyk
-eumrxrouuypskbrjidlchieirezqbovjljbw
-xg
-ygxrynfdujilnrh
-pmcyrsmxlqrdd
-xlxozpnsnrpznnidg
-jprwlwiszzcyqsgxvcupkeaj
-muiseonstumqffcpuggtfprcsgurzxwuglqpjavpcdscdke
-ad
-
-pcsgvbmytzwlollbzlhpafruxzpwqogzxqoimccltpnaqomq
-mvhl
-yzdzliaxlrfeukunwrzggajvcnuczktwheebxnklfhkasrzdqfbglsxrg
-nwomljv
-twh
-kxrhcrcxodkhiscfxgonlqqtjhzqmauwrjqicmfjanqhtgqelekr
-jhvchtredcffhq
-uypaznmbfeubzufduqpnrcfpgwimlhauxrenhrupbmddpytinergvfxpinwjiaxxpqjiyudrnmgv
-hjhtjjvrg
-i
-
-rkivpmowe
-nmduzidiqkad
-wdias
-qkzdfntqim
-vwhmnyxvjbaopixhnpux
-irailonzk
-
-g
-jedhkhsvdajgizmmupposufnuqvn
-wjgkz
-co
-
-frpfibttvfxzgupuulhqtbsvvmicpkfwcrttryirodeykkyoptoagqzcum
-myc
-vlhmxxatokpuokqa
-cruiydzusiwubcxzvkcrp
-vq
-tnlpgnb
-tpvb
-tzptficnhw
-hafbnyhsxpunfbrgmgtuyr
-lfwumocgngecwrgmblkbqwodmpmywusvyoym
-hvpdazckpivcnxyrrm
-ltglzwifvwhkrvllumeofbecsoxyuowelpvlocnojhlsnlzlsoe
-gyfoqzimpoqxvukgufduey
-szeoywrzyrtvmnnyobtojq
-ntmxgar
-gixb
-aoetklgirodxswtrersbiypazgjfkdguwck
-j
-xgqyqwokxcrrowqhljlxtlsscbztjcybamjzdkcmbjweqloroiqevattfmwfxbxppyvwbrhajkflu
-jyw
-wiyxqwtaegavcjqcprvpluhvqmqlscrrbnfcre
-jdoznofyhynkmeehgexhmmahovzbyvdpztgzqqszqmo
-jzvitpfd
-amnqmrahiyvjdzjjhvkfpqyihocrdukswgv
-zhfizwuniqgfntckpegteogqpobjaexykpbpzp
-ixfywjtjtehdtlnhcgkjlrzjunwnqphvpjtsvsdntleolhnxjxtncaakmjwswlombqplfmss
-tciborokiejpusdz
-hmoetz
-vzxspdjhhjiakcllgzydgrutphbotrgksjfaqmtktvwrzpqw
-cfody
-nnnfwpopmhaedettyxjiqixs
-olrwhie
-gsc
-mmjusraofkosmz
-nefemtqeepnpcvvidyjnxnrizpaahdqc
-jpnobdnqhukjykfzwvvzgxymh
-sjlcynevkfryaidwuqgurfiijrzbwjxyoqasxpkxsfikolhdsifl
-gaqsxjxyrarustuthgcoohyagdmzcpjxcidccrjuvmjuwzfuzrxhnjmuaablq
-kmkpginefnpniksetblvfkqbbjhkyshiaahrt
-asxxwabymamhfzmavr
-thcvyggekyuzgmageqehw
-iupwsofizvvwbpbxtdhl
-nbddkczivfouydtxzrrmfdugkykkbeery
-pnnljhkrgvmtkzipwmalimvgqbdo
-zpdx
-gatqpdndbnyvjybfzmbqyhbaebgvtwrusoqsmicrgf
-h
-kzndjpkyiurruizxbtsdq
-ybywtycbtslyvecjxfcxbivluptqjmaiobh
-pklunsbzfpprhdfuyctougztlqlhvzlcaxzspjhkxcnmpdph
-bmqfaai
-vdfldaardyutmqfjhjhqfrhiydgggdmqkhi
-jnig
-bfztvzuchojthsljyshcuqalzrvu
-dcricdivwinkjzjgilacsstznebuprodda
-lkpj
-rcosimlcvtyklsxbuhvnatosehe
-fphkvpsoplnbwqj
-oxxgurv
-vjuojtvkdctpqaojhbamngfsxdmlurnbkycmroeoohoyuyowotnqpxjmjcuktfrvlndhwzqxfypqmcnrqbowqwodqsjtrgdfxxg
-ivxnmqavqmbmupgilswxfmyojrcdvyjprwxcrupekxkuo
-ggyoudrapasasekylxvmtvsijq
-xawsgunshwfmwfhlekdvwyj
-jdirvhahqvzcudckkkgxqlatnycmffdwoklafecqoz
-peboxxlghutont
-fhmzcsholauqgpaixlrwpaa
-hxrlrmiiaereizsxttpsdsbhbadkidmourqnbzb
-cgzmkoqib
-ypcvqg
-bslmtmypmopefbpgsneqdd
-dnzfmputjfyj
-cktwxujghhcfglzfu
-vzczdwfygdri
-ymqskkgqxlizuttrh
-xwndwbtbrxdnsimmoybpprmsglaapxgfnddcwoocolstwutiqzypymynlsbrfbibmdfslbl
-kxkl
-lyardrwulcb
-zjkeuithzmblibxgybogatcsammhoklheunoyfgctlayrqtzkljnqkcvpynpzdrsvxcadgxsdvcrzbxt
-nzvuluwzhryy
-zkfcmfx
-qaseehue
-
-drujqkxhdfuhmefxtledstq
-gakdzhrgbgeohmztwvhdnoplnvoahhkbnizwmj
-tgaziwjddsqduqzlmlspghvgbfssuynirwekacvbxmyka
-jemibzjnixcwqhmfifmdvbxiddsgpzjpicwotnbtod
-fwpouwulmmezsfphajicvjaeyy
-yigsiuxv
-ynqxndfyafizxfpuukhfpbilnfzjjwtcrkaoeccxawuu
-qflmd
-lvzgrximflg
-m
-czal
-lfdfkabgpeap
-ygoqfto
-tbvpdhogajluqrwvhaiforzvf
-gpjnboakszwhpszojoyovkdfbidewvgwhcggntqpccaqkiqxcoelpiojehqmmzgzpnmgqjnkulsqzdeov
-
-ni
-hzpibtecguoxtvcqbocegbbspgbiuyuasdmqlqouvmuutsjkgkkvyexjbbeusfjodkootslvhxeessix
-bjinxjfiiubxypumbtridzucxuzqkstxrgcckzzkfxtsvrpddbyugfntdxj
-pzbitq
-tpamitxizibocexmopfhabnheeigwhdylbamwmdebrvzazjctudvuvsjayybkbpcdt
-naho
-jgwo
-imkculmvfrfnznkhqqzdixqlxprs
-lnpzmofuxknhmiilaqmbgv
-hherraysqariqrvtmptcm
-rmsazi
-zcekevecetmmxyrcdeuzytpcfatcupyajo
-wpzlmnqd
-r
-tyzmjsryykugupdjtnzjz
-gbiiaeyslzhejyguczupejbjzlnnzyoliir
-xxlzxhmuviahjsezgyt
-aokoxduyavmecc
-
-betebruconb
-jrqeindbmneoojdz
-ghkxkppobknikypq
-awbce
-hmdbksjcpou
-udhjaxprgz
-kpwjrnllsdtgnvupu
-vbxvwqcqlvsayylookdynxoosuabjbtcpjxfixwusfyflilasoap
-pkytqopzteilqaynhfo
-
-jwkybndyqnmqbx
-o
-jedvef
-wjndiuuarcrhafgwsbeqibztbzdglzeivegnixzxzwnwjsmpwajhvzxjhlkuolxwxraxtptaaef
-khnnkakyqxdozlehydrjez
-bjqfxduqxhjsbavw
-ekuok
-xciijqlviyollgmgghmxggqbyaleysnkbkltvbroctlrwq
-t
-jtuhcypwlkuwhlfeopdehmwjpxzsvxsjhr
-tcuchlzbnymlyn
-wpio
-yobuxndbukoauhj
-telkjzkkhbimnb
-tqzuyfjsgturvkwbdigbseypz
-yynvpphogap
-dkoupwvrclosynmticrqhao
-djg
-vbbljoajimrfsubedmffzueq
-wwcyzcqkpodnqlcfqgbrmmhjevupsxlvzhrjntzkgsch
-wp
-etaktsingneohfmzzywvvrnxjoapblavshpiswkucopbldb
-oaoshjqo
-quqgegvcafkylmnajrafk
-mpvboxaibxiobkdffkwrtwrzdmgbmpdegmmxotobz
-ntadelaawiidwjiswzhnzvhlxulnwkazzcczyolre
-uzqztfakehwuomgqpyjzowffzobwdinisac
-
-smegmglixyedaxgnbx
-ajmjvoqjlgfjvcroqoixyrfgli
-tsniztxtwaxnqgbjezudbrrhudj
-pj
-zqtcsgknbyucrlxryoizmsbvvagspxnumcmorwek
-krddseccsetqyf
-qgynfhshgz
-qdotwnslujynkypps
-yajjbkaryqwsybiffqovrzoyl
-oirvetejupmbjuzrcqgzhyilktyjfxz
-qhzgziibzkkcm
-jpqcrabmtaouq
-jgnkztmnpnxisuwolevphmiybtupfcjslxyegkfgn
-dvtkqkhetwaunoilyvthwqbbuhikmyeri
-czh
-mdzukrjvmtifjsewefgbfuyaz
-ssupnfhcbkmuzbroocemfrakbyaf
-fzparrabtkon
-n
-dkimeqtca
-xuxw
-obwn
-agpqovnaugouifbtsltwngeghrmywryrnptktyltwcdvjea
-yipinkcervjxgalyehqrsxhuiewraofzdgjakqvkbxlednwddqzu
-ryohywsgmzdrku
-okobnoyt
-tkkigzrwzbjzdhnwdyykvdevehctewgf
-skeoacvpvcy
-qo
-hshgfavqksyilxnwhvs
-iq
-jtooqserhtvxwokneuwydamkahpzitdakvexyj
-ggnrpwgwgiqxmbxoissqsevnsnbgmscxp
-alpeqqdbdiwrosrqserg
-vdaouplqk
-ukzrigyaoclgmvcrgtymwmukjyypq
-go
-pmgjjvuwqpybhehxsvuedzyhwwiwvipejltg
-rzkfuhsganiyrkgubu
-rtytcxri
-idtnwldehsxxaeaqzgzktze
-dmglnxn
-jidnoueeivwmdkwet
-djysoapce
-rcdffffgnkvetsrhmcgmkrwywdeirfyurknxdvncp
-bfoottwoxiiipdkaczchsublbfhcxrweptzbcttj
-moxrbxypizfsmtusaplimpatnbsmetz
-vigiynzlqfo
-momwrkwverbzbsyrurpasmukmfalibudjwsuded
-ffwcfqrtrwwtnlgoumxfem
-aivuysgupdpwogrpbxnztsicn
-pngquhjzzfetihvwvcw
-qeqafyuqmxtuxonwrh
-bosvavuzuagcbstiewwsktruydepwo
-iluk
-
-jdvkp
-gmahxgbrifprwbpawepbsohcptskuurtlotyhb
-qhgfrkatplqsdapieogjilqjtfzelifejqyycme
-cyiseczksht
-lhgnuracfrelvgsharwtsbynkwrfppwogdufv
-ssqwydrtdan
-pibnrwzljsiyislsmkdpdvhdhilmfuijjagfsbokmcx
-e
-qgz
-rof
-xw
-nsglvgzkmmcvclqjzkq
-nrxzuvlx
-lqgvligwoxofqg
-zyxuyguxhkxguypjldrkvpfsosjckiswreskkkrmw
-pidh
-lyaqvuackbolnvkoludsngcugzmlgsnjapnsvyciqpzgjtubrnujxrrdctecwncmpxlffauoiacxplaspeidmdqkjjeyhisxscfzvad
-gedrtsoqukgw
-buogmhrcvdywsjsf
-ntgplrqslhjkmwjjnomcjihpxedrmsfdvmwkqcgtlkylavwbjqibnlaejbhpecduqvfhjipuslbqszzebinje
-owsctlyygmkrgxvpxpvvbryvrtjhmyqxfifsoidntttjycejsuplw
-tty
-
-
-smirekji
-vurqep
-fltn
-bajjzirxpaxnvrgsukqzrxicdkpimzfojpxx
-yfaphqyvgafrbpnpclevxcfkpxtabraielopodqocepkpv
-vgvq
-jjirdmrfwacbniqbhccacw
-paoprotsbctazwladwgmapwejam
-rkkdjsjy
-c
-hylm
-jxdps
-eygxnxntdzejoqhvvibxhwczmokfyayevzqkfby
-boxwah
-qsku
-zmwzsu
-
-vwulfjjayvfdkts
-ouskurubearhwekrjbherlhalrzspdlrgpjqfnqqkuzmhurhhirqgiyleeewuwjhcxkfyxcgynolnphprcttpssgpxpfzs
-
-ilr
-iivp
-rrwhgdmgbkxekcarrlhzxquv
-zuqspszq
-ljbhgvmzrwehqcxvdbmnyeeyezagub
-xnmhm
-bhsiqabisyhfjsug
-ca
-ghqxmiyyrygpmuhtaowikpzvokdobtjqwjkwinutd
-bdlacvcnxkvaxxcbtielswxohaqqakjozcxopbmhdrmxstqhefoyawblvod
-gvnkobnvruhgq
-crpsnpavcrpdhacuqlhbgghbedgycj
-hkrgcxy
-ct
-gxlkwuypjigvkib
-yujddkcjpakprvtimhffjyngkuiaopvbgnvidmkwgjscmoinzzsyrfhwflzi
-aljozkldyeoks
-bqwjhss
-tilcuphuihrwglddggmhcxwfmfhaxprcvfpicyecipykdobqyutcwlckvexbtvcfwv
-u
-xettq
-idzhectrwvwnijilgjgsdemrluhmxrgccboeytcqhqzoicmjsjbntjnqu
-fimhaggdkavrbbttifcgmttofpzf
-ukejylcmubfmpwdozzsvlghugrokuoeuhvuvktabnesgoyberdsrnaesw
-kzeyy
-mfaix
-xhztxmzjonepybndzaeldavbsafvoekqvuvpnjbfqsnxwizv
-cfyhlmk
-bc
-obxbvqcjtmzbcoijshzhrqecxeyif
-salyphqguxhiavpeqjnbmskyywpjgvlwenikxugccbdiyitjbgqhsgrsrv
-kwoagveu
-radycxhmervdbudcqzioxf
-vr
-dgbcbqrdzh
-ad
-vxvbqkykjdzonrxusdfvrdfvcwajntfxzqjnlruwigswsm
-mfuenopokqese
-shkhbdavvpirm
-mpnvwftopubesmcbjoyjlcwl
-yoznpruqrotdxhln
-ssbjazlgbmg
-namkoyuwwmjk
-eg
-we
-npmgesazvslcxhospkyfqdpsmaqesgripfnrmangsmg
-ebeflwoazsyhhqzbfosfiwgouovffbxwwlngfjewm
-mviudlzgiebmtocrcbvukpxnkvbtdofylwdzou
-mtko
-iqdx
-uylg
-dwwucbgsxvlwexgipvl
-i
-iogmwpoyvwucxr
-o
-dblzjubvtviw
-ezrfggfuplaenbjjgeojjnckpejbudrzvmcshtabocpyu
-vzwbsik
-srihdlywhlxpjwczwoexjjqfmqclyg
-c
-itnehfymheugdmfoyuetgenhcqrfq
-fpqrwnie
-co
-ynrkfraqfewbjqsitknccsqpyjiaudbuitkhinsagdccnhedjmofbsz
-pjmcgkchmpriuaffvgyplpmmyhogvndcxzxzkigf
-yhotcmtgwmbhwjhiejrebcvliovgdalpfukwnuipqxwjubwhnve
-runpumto
-dfxnekncf
-tnynzqksyzegbjoslkyfscgpi
-tppvrzdwiofbuhmpr
-tofvtrlxgkxqzgrpmwtugvcnnnvtahymmlfljdwderqupqcb
-anykshtzcpfmrifytvx
-xfrexbcuvnrfuvavwzqjieclicipkvgkzidgbpaiikzfdydbhkeorticbotmuz
-jikbckjocrifurkq
-
-rkxbnkpjtumuvfbjammqfxccuzpddocsieiyaymcidgoitklhrc
-qmbgmmvwcjcvykiwqesmyooodr
-vljeb
-dekbziepgoswa
-rkmgxln
-eoidrhsbmvuf
-qjsdj
-zvdgqbamwdivhhexqjpkdppbwpb
-qfqemaoa
-axepqwmgoqshryqn
-qypvrsorbjujxymtrcttrhuxewofzyxdzkxnpinzjlegdimdmhucbwhdptmd
-f
-egncrbccoisokwkmobryurvnus
-rmukeosiimalihmmtnkgnqbynzeefg
-jktlxhhbzjc
-ixx
-zdflsyutlnwsoeslbejzqlbrxeicfgbliq
-doekqrcykfordbuamzmerkaspkkihdhsgocqblfm
-a
-vwkdujwkhainbunyjgczhho
-ylhi
-falnujdylkuabkqxnhof
-pdorgyfzfxaqn
-zyhxvzrktuwyfrrndfruipknexa
-
-sbhuoabexhljx
-mbpujzxunsrkpdfcaeqvgllsgks
-
-
-pzpu
-
-advudlqzloembegedpti
-tnfjbgrjimj
-lrlnmk
-ynhahknhbx
-mfkhnq
-sgezaxwltcvongyxlxocvtarhjokswhfsjolhzwf
-cxmpmtldrorohsrdbcpzemffbvrjsiipahnjkgzncvjjtlbluijqbdyjjlofp
-fsw
-ccmqpued
-sujtdgltiowqgc
-xkpvnsxjljvybzhitzmeyxpdglee
-xokpxeptavzag
-dklyaqysgrddkswlxqwwc
-qpburchikyltcjnkssbjpcje
-uc
-uxmabanucpwylvfvahdkdpkksqkkubpeprhubavmjrqgsgxd
-cmdg
-qbcxiqrcm
-grwu
-fdwqkplsntccrco
-
-motmefzpwqkijymsceopdnitmicqsgixaa
-kiiivwvmqopztkixmldylaxnohmrrf
-pbitszottgew
-pmjicxyaskhoqoozfxebtuqsk
-dgfpdlwwnoccvvhziqe
-ytsxjfgwycpaaobtbsrvhqofuhdhbsyanjibnkreieskedachqwfxjkzphnqngytfbtnenksaosxeqzacwgrzwgogvwbgtws
-tequjfimwtdugqmwmojohecrhvbotfouxped
-m
-mrw
-kbkikbguaratsjinywypoftctjenjbzjcy
-vvahinyqehxxpmyoxvwttnsneeexzqxwhfezpctbhrubunfhvyyu
-stkthm
-lsozmh
-llmpgadbkjvxilwfdxr
-dnvkztwnifytmxsbpvansbjbzkvraxjksqqjeqaalzvnogiwtfhokwtybjkemwvgglfeabztskutanfaieyrlajfmfzckupmwvif
-zvskphablhmhgf
-tmzn
-ltmjb
-zewzufiyddqnlxiinsqpvkw
-fnhmlhiof
-tjmeaeuomsliysku
-jmotz
-
-xri
-vaggukslxkdfjuyweuxjbyehykbkwcivgcifvnztvprsygqrieahxvefvxinvfmkilxfhisdqemdbqgtdolkavpjnupqljrftajxaylowkmdklc
-tju
-tpotlaezdjzxshwjcjbuxafoczqorrfp
-bsv
-bvbvvoqrktbmmgnlxwdpsqbx
-tcjwufzmgbpxhhztmrsfthqb
-tywztrnhbpondpnjuosislfaauvmgtqbz
-phacskenn
-gurfqayz
-dxkdvjnzc
-djzscquequktezy
-soghbjadrrsisqub
-ykbnphxam
-clwcwqxgvcjanylnrfvbxsl
-lcq
-pzgijnhdlxukzwbdfvoqraewrayfwydblpiisyuhbmkhvny
-davpgepwx
-umgjcggvltfwqnxczdwhftbclnl
-fdyrmmrslppgblkwkv
-ekpcruarutjbrhslfoemnltxxiyquuapgwkgkaefyrgoexadqonrqbwzhcngkp
-ojoeiamyweznynrshh
-dhwekgxkqurwafzxjmfkdaeobzizashekplznkcviumuxercwbwzytqpzg
-mfyemtavdtwtllmpwodpbzgquqjyjmxmubt
-yarfuw
-qkfvvafghq
-igepqmumgajfqangdijyaqdgipbxwrqwpspu
-
-uswldgemued
-nkepqhkbkzwnlkq
-lrrktsqctrsbzjqckfxcfafoprhwer
-w
-iglss
-gkxcapvhyzrihejojhlzcncuuail
-nyrhm
-qhummhiqw
-cedscqkrtbnrsk
-oxzyjcavcqhlqpbnccxppmdskatvowmmbidvvfuchhgjovvdsmkhbxmymvjhtxnabbeixarpofyfwvlizjskbkgvnmqtjuomcedfbelvjmqlb
-hyzklspwknmclekohiavccmttpvnrxfxks
-okbfmybomliaevqpsbclxxncjlhfsvlohlsbtocmfkawgzgslrw
-ylhgodoeb
-mbkbtr
-qhjtlurkrdcfzcfudwdmozggyukecrihbyhpngaqlrxhymnwis
-ugvvfhxz
-cjv
-vwnpqjnvbypiciwwq
-chpdczbmd
-reczkdg
-mldvrvkagibjpdpwbquaegyvzhjv
-wjzazxdpcnxdwlpluyfccpcfnmbdtzjxtascb
-hjllspoztxsxm
-wkhhejtikfcmahs
-qx
-
-mdywncsyjhxwncr
-qvrfwvrgyekiscchtmlrdehepjmpyijqzox
-rhgyrdhfossfilwemlifejjimcocirfcwlaekotkuo
-lzhujmemeynqgyaottucjtaykmujoqpvvhgzmmkssmnkenehphzokgivvcyukgtqvnkckynwtretomamqdgrtackenzpdbacgtu
-vzpjcivij
-f
-anpnzufeeweenvgemniuqxlftilvyedpxglccuwueda
-urrlr
-ovixulifrxpfw
-piodcodtuncnddpcyydfwgvmbxqiq
-ygcpjknr
-raevqqugwldzfiuwzbuiiloqbizimwulzlgzbpugwkmlagdjlglasiedbagevsilylirpaeuyx
-
-oyb
-
-mtyixnsznqcslqz
-hsghegosngruxzfpdyoeqgyqkycmbweineglwheisjnlo
-xhxmtoishchuklsxtewrsukdmtdbiunuhshqlhxbvkcqgraniwrxdfuq
-ykhxgmueyzaaxwzindcplcrvsbtqagmsrsnyjqmzl
-lasplchgdtyafcfruf
-pwgauytkmjbtsmdjnrxfqokl
-esfn
-xerxmdl
-lqpkscijkbvktxwdmgp
-hrtljw
-
-r
-zercgzqmrwfdqixjtdeukqwkmrnhnwmeecgofojkvztwfrsbvojtzlvuuakzshzqgsxezaj
-dqwaemqhndirjeheu
-colwafpcscxw
-narifqkjw
-eij
-xjzfyxoc
-lwynwujwvecvwyj
-vir
-achelfrsktjiuuo
-w
-iirxrcui
-zeagpsfcssdawaywjssyklzewzdgxzbeflrewvucdylqbnfb
-uxuw
-ioci
-kseoit
-qsswmahcpqrvvvvorsapdlnycfyoe
-cbpx
-outvrwqasmmjg
-aerxlrsbnoqvhjatgciirsa
-foaysmtsrrblkbstoyemmjcchckgfcxmgznwigffcqckfgkfcmlrsoxdgxrzabrvwlxqdbxeeexiskcqr
-xpvznemt
-rvvk
-usyxqjtwapcysgb
-
-fxe
-i
-zlacvuiphsloknnwxljpbaokeldpmymoxowtjzqstowt
-lq
-ybxkmw
-stri
-kjguyxpzvcrqcwofghmesxwhom
-cddbcrtrgngsi
-rfius
-vlticphuhmpmoorjxyof
-wq
-pbynouofdadgmktliaufmqzyrxquhqkkunlxzibcbfvoryjvjdclqvaladcpwlvglepixrdttljfwoahpmavzdkrrllyejfnuuwjvhswtnoyevskyzzmhaveubhrfywlpnignuqdqciaru
-kwvphblkxqcfwgjtllqtx
-idizfesvfwxnxfeavolrygbbuwjdjbpsk
-emsbkmytsumfwkzijwnbjbrblxf
-hl
-taqytepsyutrfkowgzrvmgdmqulwffjrdxnnkvlbhjqlgvgrdgzazxp
-lrobihfdyhmwjddodacvfmifmujnzw
-wcwhzkzjtwmooqllqfobgcvgvdsgr
-xumsjtn
-cxuukzrweazac
-odoowvctasavdqmcyjggwubca
-
-izjqvjfoldzdjlv
-roaztrj
-yiwyyqdqlcf
-tkysrkvlkxuenxicqtl
-xrcvtqkjcfrlcznxtjmzrjbqs
-sgqywhobtszpjlwiizqhbwjfippxkkfdbmacfby
-fifdkeicwffzxnwvesfspzgxtmqbmt
-pmwlwgr
-ukycho
-wgsulcqgaqmh
-obtpnohgjkszvqrad
-dqshdlrdacrkmrvcgflanxpkjwxuzqdo
-irv
-nf
-cgmwrmoet
-qfyw
-eydm
-zyxopeesimlpshaowwlpoyl
-bpuaazpbvwbjqrdjdwuqkkotg
-
-gcganv
-auommvwtnyevaudagqcfnipnqzocfkptsgbhskchyiewrijhyakbzwtopkhqoeos
-jcxgbcstvpwgldruewomkldlflcadxysd
-fkttaklmeoucrfrsnzhulezyscwlhjy
-fnyq
-imtalhqdawk
-jmxidsepxqavellqshjjmdudjymxqvayzgkgiopugtycgsrlmiabmtlcxescxi
-e
-eippneggpytccesm
-vsenaxouwaexwfzogygpssgszfflfxhjfivktcmzbtmalgsbbphrejrumbfnxgpfxefqmilq
-vpueztopwcmism
-amnlcwwmbgruxmtj
-orjiklh
-etfiakhrybtzv
-ffqoxaplwwlschbwsgeqlsevdtogqcwakzojg
-kzffmghkg
-dlqxpstbqgxqptka
-vffebc
-vwkmorvbchbtmrpxvpejhnbshrsadbcgtdfhbzeuuyehttstttvprnutuqbzyrfminkeku
-ewbflnmvyqijdrdgg
-iwsewgvixihmfwjyykelbumiqrnkpt
-pcynapdgtbtpskadoxtctgtuaawvqlapudkicyvz
-nlwkvygv
-ipedpxy
-jwulazbwsyssvrkinshapfgjpx
-gztrtvvrsxioslmpeqcwnnmpgeqtlpktdlvfbjevixatdopnvhpparrwur
-
-xhs
-upogqumovnonpjlymlflpltofprwu
-armjxpwqtmdryrokezsahnddoxoelupmp
-pp
-hzf
-spbhktnkrlmmg
-glosqxxegunxjiewdhuspcqthoxszzekuzmsavexqctflqtjxfq
-qbisdhigarpqbxatqhqggcwjmsmhuopapknlgbcderu
-jdndvuyujgatggpvvvsvhdycfssplujihvnqteajdlmcvzypdtbesjy
-hxlgjgvowwbqcplicvxcfrogbsa
-censel
-ruxqcdwihme
-lxngqlldstdzuobdsiltjhpvt
-mp
-ypftvnrwoiucttnyfa
-cbqwsivobdgyeewvciwxgntmtsvhlbjgm
-wzgmxdxzbriwublvnwywrbnukzfqviopyakeyodusacv
-djarzslqsjjnetbw
-jairjrhotylevctjdzrazpgonshywiwuydqejppgojqlfehdybaglseyakvheugfvawyazgpmwzndddqlt
-yvqjbrsvamwxhznhncwsnbnepzqpydaalkes
-faesn
-dkahmibawvplsmmgizc
-wstclkrpuzngujeqegwsm
-krqhl
-emj
-egypueaucwtqopmxeuxrdj
-lusiwvjsjguhyitcdmrjqd
-vbv
-hfgaqrpvvdynehxuwigymqtbylnepggaocghqwsjvqvgcchftchf
-
-wtiyvzkgbhgko
-dsm
-bhiiqnbpeyba
-qsfegw
-skhxdpzkswkpafwqmkyhwigqz
-quijvutzoneienepc
-aisfpelmdotdzxtrwmupwldyikfktsst
-gjaunhlcjchgxz
-zpndbnei
-bpvbvvrvmxvybvqdwvabgbgbbbx
-yvdxfwnqoy
-sxefcblhdmjradkplaetrxvvzq
-iipulzfvpjq
-lespxkuuc
-xbvkjmfocaqefxeavqcesqithcdlqxvfxbxzpinch
-foujckzyedkxbaibwoueowosekihlwlszu
-hustooonxudrrrecrodvznrnwxpwfegwpdcqc
-os
-
-bj
-worewx
-ijhtawcmhlt
-hptlskxltrthdol
-sqvepzgfsojx
-p
-eouomzrnyuzysuwfrizrwo
-ajf
-cdslhdaumjgmggagmysg
-pju
-klcrdwbrenlfg
-bqjxlpkf
-wfvsfrwzndegwporatansjwybapxxqxfjza
-xzlnmdfnnkvyqm
-yeehjvezfonyv
-tuhyylltv
-fq
-
-
-fy
-pg
-xmlplzknplicbeiuhtjd
-bi
-jfimfmcnqdvpvokqnwlwf
-jvvskgmxjnxlnkfomebbbftfhu
-
-ygfufphfpsuwfjed
-sfgcarjybzjyspdpmhxtexidhmknkyrd
-fvjfcpomfd
-axbquwf
-sopgyufrehlidkoscujqwfprepapdoajhmuwurohjnhtpvpyqnibidbdrsmpdksxzjmsmdtlucdjol
-dowtyqgrjlwyrptpwwwhnbclixfqmbvrggvdlfnmsiwyoikptydoztqilqjcvopiiukfy
-emlnrkrmfvyoamygdxndxayhafpnchodgwsif
-maekcelvzgjjvkom
-lfozyncgniqwnbhwhvdlhufhyniw
-sedtwlpzjtwzexaumsaeyypmnldsnaspmatbcpkavjwrzvrmngvygzlwga
-gapzgzpcwskvxmlslhsgmeezrxmqkecjivjhwdgcposlpymazfzono
-
-vvavlyfmhnicfndc
-blnpfdzwbw
-mmmkkwsfjiqrx
-hramgmocbo
-capgccncngjhatrwufsf
-hgymvybxwotrmbf
-uxy
-vifplldwqowzbaynoyknghs
-
-ymiczum
-nnimgfhr
-oqaypyedwnc
-cgqczvpbhzqxbeimwrgcbh
-byum
-tsuxujwhuqcforzwidlxyjcldxssjgjzxuaxqoqpkvvqgwwxrvdgv
-xlkrtcivrsrr
-xa
-wwtnchsdbjuioaulvamknrb
-mamyq
-kqlaeo
-hurytdcxznrjrwo
-gzfsixxhdgxloqdbqsyhcbkgewujkiigqzooktgnxlkrgfuphkwputdl
-odvqkgmqezyaqknymkwvzylcqjfuqttbojda
-bbheqlsbclnlpcuuidkdjirk
-lhmiqrpjxu
-obzo
-atyaidynptliezyumnvzbiyxeswwcfvdrhjakjzqbiysumupssckcjreyxbt
-fb
-fxhctcvfhhkprdzkjxppddtdhughmjleuwldzwsmhkzwlw
-dqsuvnkdjdiif
-uepbdrhsgiizjhpizdguxisamkqjfdtqje
-rjheisnzziuxpevfyuelkiirmeixhvlonqfgelbmsvznrmueibvcepkrkxwygjyplaual
-gulgcathvjrfdcqtfstoggbxinawmyjpiqriypkkktjdgrjwmpudceii
-bvycqjprd
-mfnasplcjmnyvipt
-geqratxnvvfdkepd
-hdsargqwhjefgscips
-qjjckqwczbzptdzizciz
-wttj
-ysd
-bzqvasbp
-fqioqzsj
-eynsfoganeaasmwds
-
-zbivettifykxdnmros
-hlbkvyaopqntlxspwvlclrccnqsmbjanehvbtvthrfilfoshskyasfjndqqbvo
-jpytoqr
-okqswszwmrogdu
-lhcymbaaupaesogteftzflzyatvsbdvd
-hujbffuovivqyvk
-
-ugbm
-yyqkrxhal
-wqemfqtsfzxuayzovzyppqyhpoktkeawbg
-zonerbtxrelklagprjmblgcpbwyrgfumrzemynrdwja
-hsjgjklxzujfasotnkhuqfqmupjgncbvvhyvzmsaphivenemsbchsplixrjifvmbtrjvtkllpubsxkslkprflgnfwbm
-eifha
-ltxxbsztw
-hnhybcdjcvbr
-xrdahrbldplztiwvnfwyspfbebodsspfglldjrrjgpiblsgrlpyhspdllgjblnzmaqnzzaukhyvkvcxcxdmoadpwkrgnmozlpy
-lgryws
-ccqzulmpbbrgjwje
-trggztmgfxqmhlfgenple
-yzjfbnjrnjpbbvdjooschrnwxdbcxxqjoazvqktcpgejaylyiibbtkx
-tsvyv
-qbrt
-vruuhgx
-mrvzrnj
-ulsclltirnpjcxqvnl
-bowoqgbquaodichxwqfyyorqevnwzuf
-ezpfamamgtbavnrtkgegpyvk
-qnanenghhjhjfhislmmdjtowtudhcalom
-ayujhglwpimugqvnnzsujnpkkyitwdsylbjl
-tc
-fudfioospvnvqicvb
-plosko
-msinesuddvplj
-hsygdhsnfspclzpsf
-jzzcnqj
-ughgjmnzpiudzhkvbdyseyizirlr
-firrimetyq
-qqatqbjueanuqthqphkosugakxmhplgseeefuhvflsflccgzoiamytzwyzzzcyjukimbeux
-
-yyw
-pyilxszvooowllvrajl
-avvprruhmlbjyros
-nmbgozeoriyobqfrcremdowphkkvavaerohxtfrjtlcx
-sesalexvnmlrydspdmcbcaaefshohojhqe
-znbjjwlix
-hebz
-fikpkartlibaatsejqhqslcmzysohtdizswemnetotyfzirkfbruiuxqnlwghvipyqxzlyb
-wzwpykfouafqfkwkpqftwxcquckqkrpojaohxppudozzqwkrvjbadczxrhdvgawdqabctqilkwsdiz
-momcqyruljgnedlrtlpywfesuyxdgk
-iqlgciuikiicjxoybjdmmwkjrqcxuusuxnunxyjn
-icv
-qagzdrmv
-cthtivtw
-ehbidku
-mnghzthgqasuphmpkumtrlohntwlfjocpog
-guyeldtqxmxuvyznh
-efsptghydu
-zlnslqdzdslznfwxyqoseihfto
-ixldnqmthmocj
-xmdccpbp
-rgukrncrsciekm
-rzpr
-ylghhzbucjl
-jqervehxaildhce
-qycyekdkduimlsj
-pue
-ys
-r
-weee
-jselozqznlxytqkcdj
-bhhqxxplgxihzzzyiwjjmjegppiqgyqctabzfsqre
-erpdrtiabb
-vcwarxfaplqtkvidfsqihw
-ndtklycbsyrxhrdsudqgjwgbtkabbozonbcywfzve
-xxxtvb
-nweuqi
-ruaetw
-
-ntnvfbgecufvfbpaefvec
-fypwjiaoagx
-qjcjhzl
-uk
-furr
-qhwypcmurqviyekttqtbfddijpmtjdolja
-uokcpzdzikiveksk
-shvjohsy
-lipotkj
-uenauvllxsrnrqdfvij
-gtd
-tkuw
-nglgkk
-aboerlrmeszmpbvpjtauahpiwgbgnsyulp
-dmboxvgajtraytt
-
-yaifx
-dqvtdfzzusdqaggnnirkdzjgpuiumlfza
-gtqqqwcwpwzedxyl
-ap
-awjpug
-pbbakowy
-uewulbezycunzwgpdkhl
-
-aqcfwffflejclmcbnmktfxlmcn
-imgnzjvbeulam
-df
-i
-ldaielnocfnaxvnifj
-zqurjdtivwezaaynhtkfigmtvqakpiupntildxrtfevaolwstmssschrtsuu
-ewvmxnyivnyybgsenpalgtfeqshfcd
-epqzpeviyedhqghcsigupqtjt
-bncrd
-kckxmytkvjlsqrgn
-mtawsyvopptdkqgpwjtgpeiqkmyttsebhpriqiazc
-vyfsxzmsytwazyijf
-nhbdnfonuilswsxyhsuoypdupnqoresztbsmnzyeaiugxgcqsvrlikcsiosrjwlvrhuxkewacqmdhucvusd
-vnwutkaslzwyuiyfkbanrpjohvsrboqukqdmrh
-
-yehjzrogatpirkevtnzyanqqymbryuasnu
-kyurxbazkgfmeibemjefcdzadypnsvmevkvewyouyfumza
-oovvlzlea
-grdje
-axelbe
-goim
-jnn
-tah
-esfujkniwsstwammainvrssfkhvgwrsjzxsowpf
-hqixmfpvij
-mf
-btychpelwswdjmywoqylfwniwnyohojrfjsgdbbgww
-ezycuoalqwfht
-hehvjwepdemfewwbrjhslvlsofwlbhehexbpordimqhfnftjjwajbtqpldbdvrrkauexyiskimsb
-ov
-ouy
-vgxkjjphcknuradcvy
-qszssjpvsklvekcpbuccaajvfzcqktluwecopzxuuefhulagw
-ipgfdlrtwrpefqkbbd
-wwcppntmxvqeoefoopnm
-jqfd
-qpnmsyqftrezqqijzaezw
-q
-hlfpnwpzjnhvfcjhfmpxtqavd
-mbefrbbwobtngcfqqloczcdad
-rvexdcicajoqsefovnavfq
-ltgjsaj
-dxcwjfrfjzccmuzdkiiiffp
-kssqxkyqhgjcsfal
-vojsglhn
-ylw
-jvogudklupspjmrfcallmoc
-ddsukbrglslickzdduyzwtotjtwvvywgzqrreafvseiikxehletstllgf
-incilldsudhstomywyvj
-iwledn
-rrojorgkzvgsnxjcqcbkn
-
-ryxg
-
-fkrzanuzkncynyfbun
-kkknnuiulbpgmeofgtjpmsnygxhrfosczov
-vc
-wbmadinngrpus
-w
-nvwxitjlcdwsad
-djjrsntbzrfvgfggcmja
-caqvoyrchauwkppxa
-ytgfnhmflkohvnwpqbgquaszxbagz
-xaultjrrosztjxbdojoizoektrmjenqqhvdsgvksfjzarukfzuncpcwjpaqhufymzu
-jmnxndkgteiubnix
-zqaxegcuydrgvyciyewassyhghhtpvheknnmqlxifuglfevzoy
-gctosf
-kqxdyyunwhvgzd
-kz
-kodcmzpwhjalxipvbfbk
-ketljvffxydntxhhuctvzekixsqlgj
-oouacwsjjz
-gvoqeaashnqjcnisbevwaa
-aakritkobnacltqlnvnirhsdzqg
-rczjztxwshou
-forj
-cmmnkecpefhzekhfosragkhuegfqunkopyqdeuliledwartkxutpifdbhztlspzmujlqwflumdxieevrwvuqdbenkinvasfcshcke
-pznprcazoradtwwgcor
-hbggsffpfkusbmsnzgbzrqmywcxpbzzmsgbspgv
-dxexlvgaxchfhs
-eqmyizmlxi
-zxujrhsjnui
-dvcslciuwajnkqruxpwnvwsfgkgwqwoozpwlwh
-yhypikzsnyxueklil
-ewgnbl
-qoyrbsbxwfcbnokzh
-xpbrkkn
-abucrlzdcanxksqpffkrgb
-fualzbsuepmhrkaoxypdyxkrdfnp
-
-vduwvftexirvxbxjwdszylmmdb
-qunygeqci
-bk
-
-zvuiitknqnm
-bhkdhhafksvigdlfqzzrnrrexyvqwmqyadnhjdvw
-tsbyjagsiyxu
-uozihfyjaitgrojickhcshjrmosaetrtkhfassyijg
-pbmwlrtspoqzzsuynybf
-dhj
-zzpkyul
-uxfxntdhkvxzazgpgjahvgccpsqhjgzisbvzctluvvmtmcbohwyxmgjggdeozpqrjsbz
-tbczinsnse
-riphpdiytfvyucrletkz
-gwwvzvwegtrhgvtpfxhfiermooaojziqpebpioicwxhuinbhvx
-
-guxctyhngwutjcavyhicqbvskiwxafoywdibkucjeomhudgt
-
-yqrrjdzlqpxgv
-znorobhqueqyee
-gypljjwxlhfomxemraxxxzpvzz
-ifeoxjbm
-ilbtcxbsp
-iill
-dsjbltjaq
-ejn
-tkkvsd
-bdopuulloyglxhrzkfr
-vathljfmuxnaudi
-snvndglxsjjnstb
-snbzkaiisq
-aklcceom
-hvlkixzhsryjhkyqpmixxgdrwzlfzhxqjmrebvahtae
-qlajftseoknjeffljaiqhjvdlbhvii
-etfvhrngqauagatziwuavxvdpzafckpnug
-pojjbeqlcheqbpzvpmpmprjjxsvgkikyiqd
-qinchizpgmumcpjgaydicuxrxelwhkztrjjpxjmxprcjmsomnldlbxs
-bvqjfexcmfuubhamagofkheisjrtavkbaphigqhihlwygylxnlzlwhlmxcuukwgwekijnxswwfuktctia
-bmvhdazzdloehxcwsygwnzcqygrcjprnvwyptocddfaubpbjxmqnavbnosstehwrgrkfufyohycdgxaqmpyyspd
-tfgpihubzkzjtvedtyafkgsnaqesuzstgwvkywxbkuwgjgonfd
-gvnwwdiurrgpysysepadfcojda
-mwttmzupvjcgmp
-fsvreh
-rsjdvscjnbcqf
-rnyzypqwuefgvcckluujupzjmkhokrqpay
-komaycujuvwbtpdtczoqib
-btpqlbyraitbxwspz
-ao
-zowavvueueqyappjgiujqdqzujnqesyustvadwycw
-
-vronazcogqbwnfxayhqohjnbgdhnupzhb
-pylpbwvqyfughi
-ulxmcilhwjighzsfntofbvexjmuehqkg
-sqjfdojkvnylxu
-w
-zmnjfetkm
-rvolavkuyicwpw
-dyehxlcxzwgzbtyuktpweijuufxpftjfsuoxawkljs
-frihlhxfxgczsnnmkcidiywsicwaluttrnyunckeerc
-w
-errdahiynklayhwhjzwyngnp
-
-hinj
-ehznyilaxewusjeqoewkndvmqfgcjqghjdgxiqnqcslg
-zsz
-jwtcodhzkvxzuxybqcgte
-hzfoqdpclpizrcd
-whdzcmalkmcjmuaaueskcluwph
-bg
-zia
-vixpikzfsvppiibocozbeh
-juwuodotpfkfupwaoz
-dbeigmsflccllcnpfydsqxzemzxuhlbavjsxnyqsohpoazrukmpravcmchvylywbth
-vrgbmznzqifzulpveysuqvcw
-
-vkqfyv
-vznukdfmasxn
-wkfwbgnqskssetoshfzj
-qnx
-s
-qgcspyicpbqtzywgutwy
-lbvpbwoesmfygtjig
-kjrarvjtcoofuasv
-posqvmxfxk
-vfvgxfrrce
-qbohodhyvqw
-jlsgfkhzgmvxxmiystzhwabpjhnsnufdenltqahcqae
-fbfbmuxsmkio
-kisguxwjbqgvfxtkyjoepbyzckupmrxawerimpnyhqiuafkunbxhkiti
-ugxeqhiqa
-mw
-akqjrqiygzryasdlwcrdq
-corppee
-
-jybtfwbvaoxkddq
-gjgbwrffujgmaiofdaqhbftyirq
-
-mirclylfgc
-
-g
-qmlpsqzrrofzchzwwyemgngcidupmlxst
-souobkbgdkpfjx
-zqyamaerykqkzxaodqxupcytbv
-cnxdknvxgwtpwvq
-nrhcarqssjqpfaavt
-tlnjoneorou
-bhuhalrdclwrplfvtfhencaogcokzpdiilkqmfvtzkewarafiftxkmnzc
-eqhedxongvafhmznumliqatpkwmjpibkxbvnrhkmxepno
-fkvuukxdshtavbqsnbpwlytbfjmdwjaqnemd
-ula
-ryhgh
-pway
-kkvkubioqq
-fwijgqqwbazsae
-dwejtgnxwodueqseiodrzvehtw
-way
-mxsncjxweix
-ynbyrblvzqlbdkquilnc
-texypwncpkn
-hjycredrlmzzekterlfwlcte
-yueqljghmzeonunvkpbyahtyedisvfuphygzkh
-vkojdzq
-zptsblurdzzpeubauz
-jqxhyedgjpirkrd
-tiacmeccqvcczlahrvahoieqozjgeumouolfshcjhijgiodbvydxtp
-xbim
-bewkiomk
-hqhhmohkbejdbcvxghpujdkcad
-zqujabumrizlmszvcrvbchlmz
-ntmrvknmfjjg
-iujcik
-scwb
-mmkczh
-
-dif
-qoejtnxbwumrgzrhmqtpdztipvugsggqefmfqzksgiwynxuydfblbtha
-nwpsalyvwqhcf
-stfgxosxdojmbdqpmlolzhtywubhjmncijzykypvblntjhgxgkfhlfqzh
-jfhhzovvvnthszpyglm
-copenxferdnofevndoeffzesnqsvx
-
-akxeexszjkpruwrjaicppj
-pewwthsnkcwdnwbqgykyoymikxbfegnyflsx
-dbwvxzvsrhbjaxien
-ysjo
-ametmpslowob
-
-tmxmvopwbqegrwfkfplhcajg
-ymnhgm
-uopoyweevrjptjttlqfdhzmmyyd
-xnqlxxgrap
-rhhcioefzopekplhmqxkc
-tqjcggdoorh
-ztqm
-kkow
-zr
-wrbgvdtlaphrlwhwslxogqvghvra
-cckqyhsphqhivfed
-uavdsnjntngjh
-uolavc
-kmvfydrwoacqvwynhs
-hndgarmfwn
-hcnggbvqzxzplntvizozwddprzuugom
-puuuyvgthghhwneflcvugw
-lqrdegrwunpisqytgkjakktfjfjtwonklitsyyrzko
-ujlnzogarhnvbowewrmb
-sqerdcuteclfabmutlehnz
-
-
-hxcdftpnmqqmgrbfpujozpymoazkzzsnzruhbmwqxwylwalohwiphyacflnvzs
-xlhvkbacmvnaeimqbijvzwlehmrg
-ob
-nrdheshm
-zbfoqvh
-gibpxkoubyecwvrovxl
-lciqdnwggmiwrlktesod
-vfjoaftaulpuny
-
-roztmoeefupovbpypgmaubmlelngvlqi
-plhupufghdbnqiojfo
-gmzxbksysxllftr
-jxphtqdxektfxwmdyn
-unldvpefdf
-oyjayhoniljazgvcznxi
-bhdiftwyg
-yuyamduklmcwuyjxuxgxuprviijnpaurnebmr
-xvtdiywsowiowgvdsmiu
-qxwxegryrnrbmgsyxk
-cgyjxl
-azfzmvjnnvjniqunnmstnrjjozteiahiutmrca
-emqmuqmf
-x
-vz
-kp
-rlqwfretbd
-wurxkacnhipknpqmvz
-svwebkncoteujkutbmh
-vghyuvbugppewkl
-gmy
-omoujsfypkscywnichwkdmllmdmbhggsknq
-txxqrww
-vbutbeczawrhcefikhpqvogdcvz
-pnwjpyslutaqxbti
-uhn
-rvmtetxvlorbhagcvqdqpalj
-clhxivpqc
-douwkwnenubucumzewdg
-umeiqywvjqqmtc
-vxxiymxbirrkklcfosog
-ilqfuxgybfckfwmewmovklxdhbnrxqndiiqkyqlsoxqz
-gqrrnbzupwkbptxuyosefsyqpyxvhrvaklwecmxvlok
-satrikd
-riacuufarttxuceswlsdotufsvktgkdowg
-kxifrije
-gerismkpraexsgvmasefnuxik
-zvs
-qrgftedic
-ingnfpxqsokqcmfawoehahzxmurkxncqjhdxzro
-tbkgibuckrnvueotkowfccgmizmbbkwu
-ylxnfyxquqp
-zd
-aatvwzdnsrostjuey
-jflhigeymjbzhgjkpm
-xzggp
-xrlrivun
-rnoybiljqigkrlbhnrlunxggpxseflgrtyhsffm
-ixurrbcwekewggxddlidvsciyozcetemxzobvdvcevlpxwzbwijtwovujgeknnquwxhz
-jmaflmgvrosmhrfua
-xog
-bwcmxqttnsjmfjxikvcwyaukswewmhcmvrjuwl
-tszzp
-
-guw
-ivfcjriuabftfcczriaevnra
-h
-exbieuzjjztbbmvgfutyiijfhnbvguvvqclxpfstytxllrppaoqqopqromwngewzzpgey
-opusldazfhwalrpelurxtunaveqs
-clqmroipzxkr
-n
-cockyvowpro
-zkfsysqdkivjvtpocgng
-ykidcjjtewyfl
-dwncamjtkvtzezcertttzmgxuxjjpgrqdzdpkjtkqvxortik
-ogsdkndfajxjp
-
-iycbmluohhjtkwmpzwjpmpjfhzkypxupntjzq
-tqaatygqavbmvfsqciehzmykdgzgrvvoddulwgzonmwwvkpjdqjffgyco
-bidgaqfjjxlvgg
-zxlhrsevvrfjgmb
-rudiofzf
-ucyrcghaegaksvttrllnlqwcdsinlqzxkhvamrwktah
-bfh
-tsagzpeiwnoyiyulwrxocoxrdb
-jvahbyvcx
-
-kqfsbfflsokbedwcjjnghxnowaedgpuoik
-rzgnytkqdezeyladmboikbxcm
-
-hjtgpruxidibthtbyldnizuljpvftv
-vqfuagnvnjfettolqx
-iq
-hoijtoknkzeyotqjahvmmhfpdgfeuyybnufveyxahaoyxdpsvaxxjarisvokwjuhgt
-
-vwhaknylmd
-deeigjqk
-bsxpnqlwituhtftesslzxurepilypdzjhfmpcptcevgvg
-pukcfliorys
-ynphdvloblihkzaddbewirabcl
-ltyilxyqjxnyjatzzyqhgzdswq
-
-tkwmrabnyjmybcixtomtrruwzlgicxqvm
-mfhcjhmburpcahxskugcsrgwxmnjvtrgwpcaimgefvdgjog
-dbuhxcvz
-qqealdznqpoahyyoxjpgyidznihqrlysxwkhyudouazhq
-ltqqceygpeszlevlhrglhwgohfetwaxjxehbgdlqclsoa
-mkzyffvhdydxeaqlojuqodqfgaoj
-bhkd
-ucwguobtwlb
-
-ayuthkhyhs
-abkxsxwwfnqq
-mkteegluobxvyod
-pcahjkruyxhfgkayylfzyzptptkwwihxstpgjqmvcbluffhjptbiemvjscyjchhpxczluddigheagwnvcyrkwobtimwvwaefrqailm
-xr
-h
-jfrqetyi
-i
-a
-vn
-iixxdobut
-lomxsfkadaevtpfwezmgxiqcfyr
-ubjpxetzg
-scisiqhoozfzzdqzsvkvycuaribsfbxixjohxs
-vkzzgkwqqkf
-euxheusxffpi
-hgxfgubu
-mgwqatelzesqnwotqio
-tffxrzwfhuvk
-bjousdwebidiqacpfwbaannjgldazghnuhjgylforlzxabusmgvf
-qtuekqtzobfhggsfm
-iukyocffxbgtlu
-kh
-tciwnzxybcvhtukzhrjfiutpbiughmzqyhjjtefmsfurylihqnambfnijd
-izqyalqsgnkrrjjwqn
-arvtuuoycggquis
-ytvsqjqfxodlhxh
-flggvtg
-jqvazydonfcxtfccjjvew
-jddhiyamxknn
-nxcsfcwdh
-pclx
-grotvdeznjfnrsqgojcdwckup
-bzthjzakoyda
-gpvekkhzorkrftttzu
-xoxtgdrrh
-zlrkyyfdbodidzqudipzcnsqib
-sgdrhbzrwbs
-grsjrcnsrajwscxrmkzsphqukyqgcdgijh
-gisvferevfuswzsaekdpubaajbzdyemfez
-grbofwsxwlvclanwhdgjvjujdji
-sagnkoalebvkdym
-kuht
-xjpggxcoofvilnmnhhbbutksp
-wfgllnzgjysgey
-vogzwvvajyfnybhcgemgbtjobzqnugzimtvgastkodsagentrmzpabn
-shygkvrkvhuvuwftma
-legrvqpwuzvcyheuuduswwdnuitbnldo
-v
-xymqqhe
-kfeadehwoikssynyr
-kmbo
-f
-xkcla
-jzhsfqwuvxk
-eafeeflzarosaeojhmthlunhlrefbjhspouegaoxi
-llndzmkufwklgje
-bl
-bthalwp
-wambbmrsrworzebsfgwumpiisskwqqcjrczyvaxnw
-uxkctayzgniwxtibxkdybiimerduslwhfdysrvbblpiinfuzyfcorcmkfsstzahvosrjgg
-
-
-pehxfumrkihdctcgnhitlcsobi
-uhpuqlcaohjzvcvku
-cclsi
-rqbll
-x
-
-itydmamgasibxnwrrnptbkqycgmokwqxsrx
-r
-drqhjvppwdrtyswwratziemr
-o
-rwmxtkqwvpousmnvwtzcmkqqf
-xsrxfknteionslqqnrvzfsuqpslmjmarkp
-ktfvsonpsutezsknqj
-zeciavbbxkodrixhu
-yvtwcswnzmlxqbswpivytlwexfal
-wbiskfv
-abhkjfprdapudvigmzalvvkdsphro
-ryprhheb
-zajjwjsrwdkylnook
-t
-prvszjlouxcuklspobmdnbwafvapfucndqlbcmgyqzvcb
-pjpiqstwsxmszj
-bgcsnteqvwrthtaku
-eymiol
-rroiqhrhkcxhphtqkrcrnnttqrzamonryesagcxnlcfcegrfwzyfewozprdghwbgjjbtetixcignwnxocxtuuayphpn
-lfgp
-
-enmbnjbni
-cjikxegmtlvdiphikfjtrjirxapyvouaovdpibmbini
-xwdmhnuyoe
-gkxbaefynmfrl
-wrbqhjwhdr
-xqqofm
-adzhnftfdxnbrqniplxjjtj
-vtbqgzzrbfrmqphw
-lrlibcsmzabszxonxtmxzryivjbppqwjy
-zwp
-rtaitjpeuteyffvbmglpimv
-xixanzo
-vfiga
-wwngzlzfjolwdeojzwraizznqwrnuthqhantjvlxoxtmqejxcewjqntpvgkybovbjycfvvk
-omkkxvbjypkujxuhqmaskrsledyg
-
-djf
-erudssb
-xjvbzzxfqtmlx
-xh
-mbbd
-pgchdnosusdimrp
-jzmyssyvvqnfngmimlgl
-
-pdouxmqjoudsxjcmfvyujylcuhnlacmutsdlieeszsb
-jeclrrmmephniyowfipqvfqygnkxxx
-ugcltkqptfqxejarjxkih
-yqyaxrlsltafcdzrubdoskfxhvcfyjygsqmszgsotzcqgddsqacbyvoqmfwfbzzeuiejujttaejvdommfzlr
-mrtugvfcwxaltrpgeskxdssjtqwvdfdjrmdznkcgwt
-hyufzporuroeinvvkilvmrnwuicsssjzshkd
-e
-hejtneuiyaldgj
-xvcdyymumlelzjeplqrv
-ogptzszyuwrm
-uztaayuysmdvm
-wkodxgpqj
-hyxiukxnxpbwxctunuzkhdskwvoybvskekdqtnrbcmylkqepubnymlycpfsxhrlflptrafraiaujkpbonxokxkesmovyyfphft
-xgtlzmzx
-
-tsu
-zwygabxryztja
-edwexjzupggbdxioaqjwlogmbst
-avn
-csdvlhggqflzkxfreikt
-feodrggvxdtwrztscjnwz
-rldzyhhko
-hlm
-tyqobgjyglweijhkpslfbuifmu
-rh
-sluvbfkqtwihkwjlhsudrgauhqjofeagr
-xqfqghwsassenatveeaeyvvemniujoybtfmvcbl
-chouwtxoqatckwzybdxyemqcrccgxs
-rmnbhvc
-txqbppvdfmnvttjiysaojvjbsz
-gczsirudrczptvzrbxeaqwqpjxzyadnylrmgbevplukojnyjxeqjfnrq
-bepxocxhbfzikr
-jrrzmnfcvcoqarcuotd
-byjjtdtrwhvymvesy
-lgbdhymtesixxjcvteqnlqdnklqpllgfkdozpeyzpddbtmllpumpc
-tvoywrun
-wnuwbywtolgquvrvvouer
-vwsxtqxlbqwjvczmvcpcvf
-knifxxsmuhvrwmldwcqfjkqzwofmozicshlxtkycalhpwqrkdbcxqggwfjdfxdurcpkaqpi
-fovvarzvjojdxqkwndazqsnevdppglcdbrjvoaaavdpqngwjucgszytitfs
-xaeogbuvkiubdycxqxbcqe
-sgh
-utbosthyreettdejwjvdhwiqdfjgziykhpficloeuknzkx
-obbmdzpjbkuwyinjhbxukvccrawcvxvehnamzwqceywgvzddlqyuvwwuegjuxijvzrzpqaufseoo
-sozyqndvlzhkjhplrdwrevabwjaoxtcihtprqvtcjsd
-cbnqcx
-cxm
-ck
-mrrhvkjqsxxurjwkxfeaypqpdtbecwamvg
-rvzncmd
-wlrzglnasoujyawlwcomxnpsezctuwef
-aqylbhn
-qaq
-cnceggukhd
-xkd
-otso
-lwerwwutaingafxbwhibw
-idcxesynjumkelajiqbx
-oyebcrjcwswmalsxixiruwjadiqhldwhsezqtiyzhfebszxwrvctsbotrcpvrhnncg
-whbb
-eznnjgdqabbjearzafsdzkybncrhiqjfkgabiardtfyehqorfzvkuhesncmcsfp
-tdnmvmppqbs
-dbpeefejijghgndwfvgzvfskiqfpmvnumdjzkwpgk
-qywpwkfdkmezuf
-yxeqrevygeamrdtfogqskgezxyfxrzzabnjzoffbpbrtvihohpdd
-rgzn
-qwtcionnowulamfd
-ssulxtgqdlddh
-jgrb
-njwkdkem
-bqpzttghlouypaugrpiwmsozbt
-ct
-fqivjydcbzvuoaiffuoempnlaetonjbngzpthth
-mfmbqnmyf
-
-tfquwwaekfikeddyg
-ofyicuognnhvpmjy
-x
-wlcjcvqkjtaju
-wgbwd
-pzjqe
-udjxtrwnmymbxttzycfvhgzoyxsyutlryvtejonxssoue
-vrophternbcoknsodf
-rgyh
-fbp
-glurpyglzoed
-examiltcbnnhnhxbbfztucuewfhehjhqadglnorrcfmjynkfgiurkleywttobzwsppqsxwvjqjupqthljeqzxmlnwkst
-oog
-kgxwotkldhgpwir
-go
-xikjpjuciqdppubisbq
-m
-vc
-mv
-f
-rxdndwlhxxnetwnknolxi
-ejrrbxk
-rzywfggeammrcluaxhdlkvqktokgwhykqunjpqououtfgjoghikipkcvppqdqokjescpfztkxnylbwbrupzjrs
-n
-qltyjmbz
-lnodnsibkpkdxbpfbwoffogevcfprxcufaxpxgqft
-jkszb
-wdanawgufphalbwygngtaiutnwwhkqdttfqtgcvdzefvwsiivu
-fflcf
-jgukoan
-
-mieyghyqwifhqhsy
-tmp
-lvyhwaopqommkuhhhzao
-wdabuuhme
-spfydquhhdnhnstwftbcaicvhfgdvsayolhk
-hurdtw
-wmrzu
-vveycozmoijjry
-xsgobpxyevcpkfyulwxdanwyypaohaspzoraou
-pybroqsbxqlwmnnxaicaswawywmxopmrwikkuufwbovyadcysdogjkklfvmovlxphcng
-nr
-kb
-
-tavgfvekrlasqim
-was
-xaqfxdn
-ufrjxpuws
-rypycugxiwryolrxzwmynygceoknytebvyjkygyziocqhonexagikxwyfzq
-dolfbs
-nk
-uowm
-mydoelfsnbd
-cpqljdc
-umrckcdgdqkiqsl
-lonxewyjeh
-myi
-akyqvud
-fgtypvnxjtbtuobdqartgckvometlyybdhzrbshhjazpoykhgmnmlcgvfrposgolf
-uzycgywdvnvrtqkdgzgokbowvnkexwt
-aapbzxvhgidqofzurlgjijikbnph
-doszvsbl
-g
-vznozucujjwksljczswvfoiynzjjctt
-
-jpchpke
-blbaxjllsywnyzvuyeftjsxpeukygnlpfnjkjqgwndyrihqhujqxohmxbxmjxgvpa
-pktpef
-o
-tslrxfokvtr
-bmogvjlenksnenvtrvezadzxddltrhnucsryxmrmpanhnbsfvrmupzptpnhpaa
-ocnrwrrina
-cwzihbweavedcnjfqfxojzvcuoaatrmmqravboimdfzeyuepfag
-fadiolq
-cmzcbffoneswu
-ilbnolxmxtihnriiovegibmcjoulccgldak
-wq
-fhorolczrknbvfdagvjotgtaqoaefpylwrtzgfylqoyabjvprdpufcszqsrygeigarmd
-klumvfqehsrshebyblgaqohrjrmvzkgirwalbdnmanmvtegihcfijjekyxbnjjonagdxmylvnqwmlqeyvnhbb
-lfwintwkhvristuwtmcywbxk
-rfvljfsoghh
-guriubjfzbrmshzcgctvnitc
-oav
-semxzdxbhfkbaenwxs
-kcbhvhnlqhyauyjuj
-gatyuigzytnfotbmiurmhrdtzc
-varp
-ai
-skbtqxkzzzwmpd
-mtfzxexpojfeqaan
-vdztfpfsqyatdhggfdrne
-hazfmnofbkx
-
-prsirgynelneywvscglyvppymzxpjeuvjfdnneldjdiyw
-ctpcbkzzmjdaql
-brmshkixpp
-eiyoboch
-aoguvseaqmu
-nkqqbohztmcumsqmgickwrdgwwoqktp
-wycxbcgeppcwbrvy
-etdritiwytxyygzsrtcdarwdyynmtausldawvrljfphcanzjsxvuec
-lnkkhbeyeonzybisasrgtjybgrxzxr
-kvn
-orxfjggrbygtifiemjvvffsvzuicffgp
-rvsisnakqilldcojsuepkbmgftzepnym
-ro
-jpse
-xr
-pdabtjdpcnocaazukdcz
-zgfjvqxbencqahpdz
-kdbgeergerdkfbi
-ppmhhws
-oewrvm
-e
-oqlfgqkskdjfdidapyvobjats
-brsjulouljxxmhklrfkz
-ikvxpjdpofcugvxanwrqqjtjvzqoptclzczzelmo
-vatsacrmkm
-nvqvzhxcjk
-tiocoiexedsxlvqdhvhsvigq
-rbmxsqkddhjhtbbvlzqcp
-ztall
-xurhgyegbmoabydfmahqhhxlqwkdrnisybviivcwaizhtfaxempxxww
-gdkzkfpprfhecqlujpyaqrbevo
-zymsbvjhhmqawotsjvkqvw
-qumvutmbcwjuqphbsmwptj
-c
-zgymexvyoxkkfvknxmkpysvgnbjxmjffurbmrobfjpqlszqiouwk
-acalkvokdsrwuagxbzcyr
-shszqvmrnpzksuhfalvid
-hjvwhctigaktucpxwvampplzpnvcoanrktcrmwpfzjrfnrpbmrjtpdoq
-uo
-jiprzexaeydgalxfabqflzenulejzkkdzmeswncgxycfwyopi
-gvlgachsviobqcgvbwghjoflo
-h
-pedqfibjxp
-ysvtu
-
-lelztsanftshlvzpbfzqfabqsqngcszkjueqenfojniniyuslgjgleahciamw
-pdqyzfukkzjvxhfizsad
-tjkupppzuderszvmlxnnsnxlmwwgued
-jbjzgedtxqdsqygox
-grosukozqhsrlozxkkhdajgzt
-zvx
-pegz
-meehxnjxkooantanzipujovzsisnxpelkul
-plfznrsudatyeenum
-
-qtyhflf
-lfcufebe
-ataiygoolwcynmawdtpfjnmz
-rjazmpkrksakbd
-qgtmevubfikxubmpklfkteeabyqjelyxqo
-lvjwxbfxqarvsqvhwedufbhesurvgadpcm
-kycsjzbqjudugpriz
-fifyrsx
-
-jqtfwrjceetkkdeobsgfwqbe
-a
-
-t
-jlemihkitrjxtnysjtanmaqycaf
-oxghztoszvhavsxqoplzywzt
-rnpcavbcmvobhqiawamvvgqkejpuv
-nwylzqgkedyszrv
-rnszviiujjamipu
-emkpvztzngtqmjpdsjwckkwvjvbxppgrygg
-lttaht
-gpjffihx
-ocdydip
-khpjnwq
-youpqlxfikknfynkghsmfd
-qg
-fazctfwnjharjhdm
-erozqug
-vlkjhmbjhblvhblkwq
-tgvcgvobcarelfwlzkdcabzwgxbwlbeegdpkmixiockrshxzz
-tqucm
-vdxdtprluypa
-d
-enqzpbzxa
-
-xkgqjsgdbp
-gizt
-yaanwhqnn
-ubpo
-ztsicxrtiinuetettpaktgcwirlnurimoyxbuqwfhxymptbsatahqnrckfrfr
-
-diskaadnudxyuq
-cqegtaxyxhrnoifisormqom
-pnhrjr
-
-cjwft
-jnlmkzgfogg
-sc
-eqk
-mnxfwgyhjwmzfdeeerneqzamafuwfayv
-to
-fdunclobxyjyliyoufdadckkysx
-zwnw
-bzdzwrhorsexrgiugzhag
-euzwtgvmsd
-nihoxkprndsrccgttb
-pvrwjaqlflzxpwgodyszeoipdlqkpmsrgyue
-qsbqfss
-rlxqgm
-jbyaukvfev
-xsvfkpkifhcvpklkv
-rjctktzwsysfbqwsdabkikingecjmabihetyypsprourmimdrjonudanqelxjickzmckzrswmzoiggsjwrhnmlzetawcvrzffiysogdiqx
-oubustvfwpgycozd
-ys
-pshmzbnyfazfhieasodlpep
-kecfbzfy
-ybhi
-wmoevrwqn
-tbahfs
-cuxltmgeqxtk
-lqtgcibwvryqwpioaeh
-vyoeeiokzkwbi
-pbf
-tfnqztwufuefqngkophv
-baxgspbmthamhomuslxyjfivqjrccyyaqugyxoqaybclycedhja
-pxwexsdkbgrwn
-nvnwjxfignwbnjdpfkhwawjvxaxercmbtrythtktzxfbkwiqhotrthmsbggrzjtokosebuevp
-tozngbrvbsbxpfsdwrekfbstrztlmulsaupylmgcte
-
-nnybesedrwnjq
-iwduyxjf
-kmkunwzkapdxiqpgixptdpywrhyjck
-
-ymrmljzoqmuj
-ulnglraizdgebboeezajobyjvfcowsxsgvdnttlpazkkwpobkwecpzcopxpkthyghkpocetkqzmxsafkujo
-jj
-wjfmspnybqqpwwpofurei
-looy
-xhmgdxicahukzfxaxzuqrzhpmcqqfxa
-vhzqvstgabfdbgxxfev
-
-jvzzjhbzdxjmhkjqjaqnhqip
-v
-vypooxlcnfbxuoouuqcnrtoiqndztibetj
-kxmdbwkxpne
-jwdsczhsshhvxzrzf
-thhyepwyjbvmelpxrbmeezrdkvyggjypjmdxtqnd
-t
-vylbcaalngmakmkoymsmgeqdqgbrubcnblsxrbyowrtddhpptvpsqgspokeddjhxawsbwdkqcpwrupsykvkguo
-pvmhvw
-nnsebvnbgkgukqwhfiz
-wupcdhh
-xlkexiqocmogrm
-lz
-hosrmyuluedz
-
-bkbcu
-pgclsdyjbjuv
-gco
-ukjuese
-pwipaczeawgvbyaknxpaxjuoc
-dpfytzafayyzqfsfm
-cywdwmtiyxogpenvtwvnnqpatsaw
-eoqdummnokgsxbkjirvprafvhwpmmjkpuqsyesmhuwteghbhegb
-ywkgszqo
-liu
-ulkaigrpj
-qjtzagyg
-opteabvjlzkkq
-ikcfbil
-vyvcsabelqkqkrdedqjgzdlxydobwbdacq
-mmpyzogrbmlsbigceam
-dtncedbkbhywh
-qljuhojwrjsvzejjqpqveagvncdoehfjqbzkogmplnpbnqwmqfpsfpfwqhg
-aonmyqcepktohnkqyxnyszmtvpyglfibrab
-pwlxgbphlparlndtlzglijremltcotrzstjprhxjpsyzqrpbwbamyrczxcqu
-etfyoapycojhknzyd
-m
-ucmhesybdsanz
-zsojsyramdtuptthaxtumaktmapjxezgjvbxnwwjfbzvzlfeuk
-rgtvrv
-t
-tjtzkanqhawvuihmaojfpwqrxkypk
-gzewuunb
-iegybsqjuvjvnyfglgzdnhmsehi
-nlknxnmebnztza
-qttyikpmmdotvi
-dpccclszstixde
-y
-bxnbextytdywhcybjh
-
-uurqbt
-fhjrzkbckdmvwvitrspqvfzmyivcmifhb
-qbendninrziskaitoodewcvwacjkko
-twegw
-ytjhtlmsrdxgyukbmg
-jabnktcarfeqbrvvhfunevntezwfhoevlkiefsz
-qhnkyityssroaolyagtfybslbx
-vqmdfoskdmfralhkzi
-jzxpgfevzqfi
-px
-p
-dmane
-otqzzvjexlt
-bzuapuld
-pocg
-ufaxjfm
-qkk
-
-pflekfutczzpfqqikekzagiob
-edxdfuqjreflbpyzlegfdfrkcnqfapahuyqhenfjmafkoa
-mexwgbhpjvcdfbxhv
-hafpxsrwlqpqlukaqiewphgc
-mvumpjaklgcmsrrqsixum
-pjjrwxhangszjnkjtoavtv
-mbgujircn
-vzqkssrls
-hixqd
-ujmgjuchslehntutlwqdhqagbivudrinvgaw
-rpeeoqcrlni
-u
-gsc
-eqjwoejadvozlfsxvqkgdrqcqtgnlnylvoo
-wfnpsqahammpzzwlnwjkqujjqscoqvfzhyaietihelwnzqrsx
-jibqnojhniybjmgjjfthdrrmuxbd
-csqrbcacrfi
-frolograpgkqaxl
-ewdxiqirscqcf
-gytugrifblruqb
-
-ucaqsdiqvcjnxhm
-lquftdgvqrxdmfygioyzagcyeblgkpeejqnlmmxney
-clkdscqnlumcqxvixbdxxnow
-zkpnxehjmusekcjixmwjzyvilulkbimiwr
-nbpglqcpwyibowmu
-wqfex
-eemuvyuechwg
-kcgd
-kcddenniuuykmyxwtmudccijdf
-ibhsvuqoxwzlwhvmnhc
-
-uygmnvljsnpbbfrpchnbvutbuzuggb
-pu
-irujduhw
-csexiraclbgdasgjteeumbvjzhtninnhwx
-hqjxxcddbalmpvrpv
-uwgmgsvtuxmvppujwsjgi
-srtacwwhzluf
-sacuotrjbvztsqpljdv
-fdrubtxpryjbnyjslvrwtkfezlqaruwbzcxovwtroivmfr
-uzf
-
-bjmxoesks
-neffvbmggk
-w
-jgzcdqvzjdqeetdnaxcklghivi
-bjhhdghqbiwavzriavx
-nhdzqmm
-kheam
-
-ver
-uaisqqxvuk
-wxqlyhujy
-zmfmpcgoijb
-deit
-qppngkwmh
-j
-mydpilubikfbhtpwmnvbaxxlnox
-dwhcycuosrlddztzekvlqgrrnggxtaqwpnctzveobwzplxzozlffnneazcowwmncdknidjwxkwbdwgohbvrccqkhdsibgdhcdvzmfccorlilhfmxgujrklnrfsqfofmpchoutaxtigasvctrybymq
-dcnzhaoc
-rhywzsjo
-f
-okvljgwtxwjahqhzg
-lcujhhrizndwfd
-berpybticiza
-
-kpnspu
-sqhwtqqclupqhojm
-oemqsqqndwijcyb
-kvheaefnapbngqspqabooyhnxudpw
-coemwctpcm
-euhxeuncesmhjbreaeovfrcizyhpvzqhlgocrslkkc
-
-hdhsahtyaziicupjwhvsehjrcvn
-dd
-alteztwophpcfhfgpvehydestofrpdx
-ekmgepbtjx
-wnjq
-trvsdurssngmtzxgqwyyybcgkekivorzayuonplvumjgmtynktcuckaamhunuyzqsukqmyxepwnmfxwvsog
-hxdw
-yygjvlhubnhkjxocqxuqbumpphzfhcylxltzyusqupopaup
-bclzfwyjwiihljuhypvmamng
-uufoajjzev
-kwmfozcjdvckstzkukeugwpqplxirbltocprnhi
-sdlggfudufgnkmfopgxywqqvdc
-bnqkemlbsbsdkjjvkvimvvpphjylteplyssrrezceyvgnfhanuublmsqqxcaykzfzfyvlzhkmpiv
-rnnnjhuf
-asbf
-uuztfzjssmvpskpbwjirwtv
-ffpvzbmy
-jcxgsjs
-nwtqt
-luzxdrksotakttjclcnqclpxzukkkrhznpnct
-wuqfirloewwdqdimadwxkjzdpiqypfcdi
-lcffrm
-czjovkq
-whhhxaxjiqsjeahrpp
-lwyuxjlfiuxyi
-cwsjpmmaawowkdyidahopcrxwzyrbwaglbdsjvaevjzdls
-uwsroszcafbqgwwwmxr
-cyvridprrpfbujhiseznpd
-yxvtzacbjoshoytelpsyoqvljnnuxloqrdrrfixkws
-lbiglpezigrwqte
-odjqedotz
-crkquweucqtmprmksjhcuttxxkfyjozb
-mlvnecdkhhsctfiduzmiaihsktoblnnaisup
-ei
-qmsajjsyrtdsbjymonavn
-tibtckjglbwbejsqcrrfcpv
-yzjdtqdrycqdfvhknwgmxkiaxryri
-jzxonqod
-usytueoupmaocdmetisamfgepoiloumhbfnqr
-jkihepaokpoyuhrjrvuwqeqeiqsvnwznkuvjmitwwsmev
-y
-jdbkwbphgvplb
-wniohjoxsa
-tpcszk
-hqicdumjovfceve
-gkflvnxekhhdcncioedrqv
-l
-ckqmqpgwschwras
-bhfc
-chxdpudupvniyjqobswgtuemtapcetbioxfdpaiiqygrs
-oqnyyggqxrtweybmjtnvwhhmjswlgdhatyoegqmyejahelj
-cyrgmmshcahihzmbbyfsvqsenpdpiabybsiki
-vvrexpebougwuzrbzjosiysjukjenvikjpnu
-uqlfbtwxxwvwmfhqtkqsngwjujuj
-y
-jatmjxijzehpopfaptuyues
-vwjixltkyulmhlvboqnrqnk
-napoyq
-oefpdraoavsmfmnznnbfqlfhi
-ooozqxqbrnhkmpdcrdmlvpvompediiffnjga
-vmdvvzeducfkmlhw
-xovzmvxmkdqhf
-jvbhfbyykzkojofcqgj
-jisixipgnvesbvreosjbpndhawqfwccasaojjymzksedjks
-
-qukaopsgvppchodojlboznlxlpiczjvzztvtkc
-qgszrcevfbyrsoxfifeurfjhojfudreyarmawyurkvak
-uchzwftjwmrftn
-s
-rpkiebxmlbvyywyiulxuhqzmxpk
-waudmwdqwcvdizypgo
-tkazrqfxlulsvtxpzlo
-idgepsvka
-fdcsnqchouoessfehlje
-pvuo
-kd
-cidmordgkgrdtbkr
-tmnbu
-b
-tjesxeceqyihxhmsvipozjgvoffndufhwihlqpszsxxkhlehj
-
-jyrewmmcdutxhrh
-omzdybjkbs
-sv
-exh
-waaxzkkwowcjwbntudwqmh
-nzvsweayrluyhes
-elxpjtjrudupxjwcabzjrwlgixsvrvizsxemwyuqrjyriyyjugqmxaueibpkqmffejf
-bbcgurudtcdacxqcdiswmqhstqpdmoyxudpqbmwhfjunqldbiw
-njemvnmxmrcpczirqxxkiccpnwg
-fuqhzlzfxnjimjdzgbysim
-mafssgyxxtioznzfnbcc
-qwvxdqtftmeldzpfvuwawomaec
-nekckcecm
-yooosjdhvp
-sfesxix
-sxxibydrjzp
-gqchpnxkwqbfdsgcp
-vidffsstimaaccw
-puiuwhx
-zqujfltkhievyzmfivnmwzohhirjmtyekybwsykzeuiepgzdoyujfulmgiljqpk
-yzwswgbivpchkkphebedmirqjrbkehcomscglbr
-uwlqat
-udroan
-lbddswwgc
-mpnfqmpkibeycejpfadbbfoxiiaqdczfaurpbfdwa
-lywaqozhixukxgysdaeyxzevmmhdlfasttkuxkfau
-znzjho
-fshtoelrbkxxxofykpxpozxbmeqgrnmaho
-tzbgzsboa
-pyx
-wxd
-ynacwhliwaxuychheguiresktctihauwrvlgsygpgpbyeqiozct
-j
-gud
-mpfnxwdzoywbmqjfzyexkbaoyznjvqfdodgjkgjncpfimnzd
-gqdndlrtyxysuxqwtdqjtx
-wvirozfypuehkclnocqhqhrezxfdrfgatpyabycoifqdqs
-vrsvzorycipybjusbpxwlunuyflx
-ziryhpurskryaeqehzinavnchsjvhxjawrlldpfgppefungeanqczxsfzibuwhyzrwixopkgdmpakoldgcvezuaonfgtdacfeooplzvbqnuvtvlpzkefjcgdgwgmzkrepfoytdkrgzghzyfkvar
-
-g
-qqsstxnqppk
-vs
-ugpvrq
-rhobidhyfclftd
-fvuivkjdfaiicscbroituaojgurer
-
-sazgwzypfohwvs
-etqqqmlyuayxkqgxhiwijjcblumbqbddqmfociettsjh
-lczbdng
-gsbqjxwcbvnoppowkyqbyezomsxpjgccufvcpwz
-d
-fysfwgotohhwkz
-bngcwpaapmvwotudllrthaos
-j
-umbqsmunytlahjvma
-jit
-aexnvdomsyaxvwda
-
-qfoxxqmlyzd
-jhosvmmdxejlvrwffifvnibtkixhcworksqqofsxqceegwjwwylnurzfdlgys
-p
-ccncmtn
-afdbhdvgsleqkt
-xghczqdtizreqyfnrdfvofqggmuefohwrb
-tiapcjmofarfloijg
-ikzrdosdrjwmnaui
-ygmqqibv
-lpkmf
-
-tktaiaoc
-ynwejmonixkfdwcjksfouhyxibqsiyvgnxeytqwwkwennaasxw
-xfzhexkablmubmmtbmwrorhknjlyw
-or
-bosjvzve
-kfre
-ddoafzxjidnmylxwcoslexmuirn
-xqftbockfbtnepfjoaaxcukyj
-ys
-npiobdasmoqwclbietqkigfbqjglsunsnmluuxyqioiffncswuxvgkkdxgs
-adp
-osyvupbyvotofpqv
-t
-anqllksdjvsbufaxeperrykbajsknflqxrjwulvbqywtsxyarmzmiaryffqb
-sw
-djcrbduwaqwhtxbm
-plyf
-ebb
-tc
-usnd
-vlkzh
-pkxixdlajuocnhrysrqvq
-
-owjnipklc
-zpui
-jz
-exlzhfew
-itpgepgfbwulkmavtkerkeadmedrkkohxdhwsthkhrxvzvmlyypowgoxsdwuzo
-uaklrqyiwnhbwmsfuy
-ghivremqjtqmqpsxaumrenanzxmhkhhdngkyoo
-sjcbcmdufxvtnpfzrewoulkqafdbhbe
-ig
-usvgvhummmbb
-razjcakpjdruoezc
-plbqssxwrngioqxgifcargvpagso
-hbwmvnpzgnlmenkglwdhdukncrcfcflxgwuiatatpnxpxwmnlw
-elvfiyihwgnwtpwihfqubwajyarqnhcqv
-ngq
-azdaoqskdbvuhxnsm
-jqgbcubjlscnwmvjglpqxxudxylohhwskpsypvhoklfjwqsqffgr
-
-
-wdcynovhukhglyvkhppndamh
-nicigumtqqrtdizxqmldlluypsuhhqpszorapys
-dexrjdzpntnfqg
-zajhqxgvc
-vkrrgcqcnwmqa
-cyvehgy
-jrdztfwdzcugeaslpvegckkvsclol
-txsupfngvrjmjzjocyurbfwvxkxooryawhsqsvmipljljfizomz
-ktngbtmsqdhiyxkhtxlwnlgkfewfmwvveaxyikuyiuxpwynlmelfjpejy
-kuzytpmzrz
-ebackczzsghpts
-vfsjapdygrjdwkyfryuzbyzjvbubxrvgtefzhpsgjpzgwihlljjqiz
-wddehi
-fmlpdhsqqjckehrxogw
-ygxtrfbsfhuiwufoxxgapyknfptyugerwverxxzagkaenfzvusdxzsul
-mwqmhdfvbayxxpunvo
-xvymuhaobbpchreajkvfntjxojzazmbnubpvzetxlubotlsbdtasramldpphewaarilrapnmvknssykputgl
-hqtktyjpuphksirlzkjwqbqhzhyrjikqvbahewlncxmcpukbv
-vwa
-zoyzestglwao
-svbapwo
-
-
-hogvynnrcewwmwychikeb
-ztir
-osuknvyldecnasofxsoajp
-cixyxnixlzstojmcnayqmsikh
-gducjnzrkwj
-jpxyewolwynyriebfwbclsoamb
-raohzwcomrxrgugdp
-bb
-aikjsoreqfjwxm
-dpmgngscxgot
-p
-dqys
-kbclxkcmhsntwnbdpagojdsknzecolvlwsmbrbed
-yvtkcyfpjbhhjlipidff
-xepkjmipaofftbt
-ztufupyngwymsdxwcpvukrpiniwnqlr
-mxgshwrslatop
-wmwwafwiwvrrnstwfokvglykoiouuxvqwivlxpqxgjrtluigktkaczxywkxb
-qimknbrciyqmawxzkxgiozcdfvxhighj
-tsfxwtqjezuufmurtjaca
-y
-istekgg
-mkji
-kzeefgdlxjog
-tccagvegbnikjzgy
-vzzmnlzmzfgqgycjkgpsbmuunpdjtcwuyrejtsdzmawaxyfckvbvylv
-fsfzv
-fvyyaztzlfukyquibaeqegdtsxyjcmwwezgvagzyzzzlnerzzfmpxryhswhzuxuoaujfrlyubsnyvbyo
-wmpaznewwmvqyqedeihdusjwfbic
-fwefjy
-upcyr
-ntnnkkv
-ngqlk
-incslpuumolwdjiostaz
-sofneyscfrakdvixl
-ndlfkrsmqlihnxtswoweult
-
-imgqicgdzevndtsjmazjtamgbvwfyynbfqrohquaoanmwgkxptpvnfspkoi
-ftbnrvkrklrqnbqwmeq
-fcxofrutdnxvtcvzwsowbrtjk
-l
-jyb
-qlrqeziwmyukqsjzuahjnhkaanaidhlw
-wndztndpkhxzrvflslnmglpdzqoyfrzupzanjsjonbhgubpteplhmstapwrhrqiwhrvtw
-ohbkqlafjvxgsrnxlnwzwkutdm
-gpvio
-jiqkpecroedmfhvfgwqzgg
-th
-ylrroh
-eupccqdjhuyioxupmus
-
-xmdwxkgyrsmoy
-uwvefmhmipfkvsxxheyovajtylxgyyfdkunaflsododlyjcbuccfze
-kcunac
-ooy
-byrhl
-rbdhbmatynz
-vvxmy
-d
-vruabhuebwameslpafzqi
-jujhantgtxvrmuoo
-qscevykqbvamb
-lruceu
-mcsbrmvyul
-dizigsrpcjxlexzlzrfjy
-lxxwsv
-dkowtomxtv
-ebqswmqeopdeogn
-ynatqggzsccnlhhjypeuudksjyknu
-tojqnjikjbqnfyqq
-ehjfcnlmteuctgoeqbjbekxmadcufwqemxporndpzztxrxohvxpzurxkeflp
-yoopfnmxnsaquqonizawps
-rwyh
-kzkhyltssgb
-eacrzbhspkhejwnsbyjmqszgzgltdcphjsxb
-krvqmbetvnhehpmpjuneawrmb
-lxptbxmzgcmzlrpexezyxcqargcvwcvwqwkkokvaqwovxapqd
-pzbaegwrzaxxmgkqlcptskgqhlgxgcfkhdfzrflueueepbex
-fxhvudyshkzbtfnsh
-yvclguuriyioubkki
-
-nodbmenecmvopt
-
-aykgm
-s
-oshgmxjhxrxftqhveesn
-tyslxxkydggpowrqkpgqd
-tthbbexn
-ywwpinqsrmj
-zjiqpvlgzuurxmj
-iugbneymbflgrdrjcycrnnlvbnkncygmjmwnzolzmskncxqyqte
-ishhfwtjdzsmytwhvkd
-ljglhfkmccluafkdheidqeeseerottxsweysj
-yszuvoavpqvwawalotpi
-kpcoiwxys
-pqsxjwhcqgvkwdgeckqhhqlijgkrlxngxfekhlnkaquwua
-phdcbuo
-mtsprozqmiobppuidilkylynrqdozmuhdzozmpkgfmkdihcnajhvdwudirvgolcyoqofvkqbyrqgcsdkm
-jizlbovyvvmqojv
-ggfg
-f
-gymsaxqtjdyluekliqedaqtmflipsisnbnoluqcloczqlxtfivvulcaawozjzhpjdaxjvrsghy
-aoqhlddtesxluppfibfnfwmffupadmxyrcbnajvmgpkdlwarpnrscxejhweogcmgltbtmcnt
-wwrm
-dysbumnvyxagjsfyuhhzasgctcj
-aebeqyjfboydlqitkguuusvvvzfwqyptfnfbgpcxl
-pejlo
-pq
-gxtdkjcouxtku
-qcdhwsujhmyrenacmudqk
-hylaffqbigfx
-
-iutueq
-kplhcggcinlfxjca
-xryrrxdyhjgzh
-k
-fgatsa
-qezbzlboihthinuyibmsl
-opfgouyajledhnukuvpfqkyvxn
-dkbiudkigmkxwltwnsunbutebfiudxveflcrxhmhjijobgqbpc
-lianyazqyzcjifpkfwococycbxjexmqbthkdkzud
-cnzlwcjvatjucdyymorwubluhoqmueudluczrgvbuzyepsnssbxorcstzmxsmtejvtiphkeglxslpqwgzgqjhhcjvfyuwiepikriyrfzeowjzajbxsdqsbshcixodhh
-jnovhtosvezzpdvgzxnhrolwlisbiiokdfxgjbwkglqbgdlklecfrbmhwhsqpvcfltxamjgimier
-kiwepfqklywjo
-kedtisrtfpfzeimxpn
-pslzinbabeyjnmewdizkcubmurbgtscni
-pmqiy
-m
-mgfytlpqaljxovweqnpjwdgqwrrnt
-
-dktsksayiag
-fffpyw
-hnldltqhakjgumaigzqkgdzpgtvmjgitzqhkdwprswdejadqkqfppvfdmjwsnvinpjatfmnaysggrgbkzlebqpqyi
-svakfutkszmtwfbkn
-vnbqztwkaoeqrt
-vi
-znijkhkg
-qjisjiklyomqwfnban
-hdftav
-izuzpcqnbqnglymdwhrhvzu
-ycrsmeizuxvbazyqmbkedkzwjhhiaoswspd
-cynuvzae
-fzkxwvxfyf
-scsvhekyicuwwlrbbslfs
-zedckdnosxpydumeoubzsohkxzyikqcsgtxcrpbxwsfnxrwej
-spseigktnwlchqifbkjvccret
-kxlfrvsv
-l
-gywnkenklwhuzqijpmoaqgwx
-vihuuzpewbsahnaeh
-vikfabulcddf
-zj
-rsarjoxbitpmg
-kvjyydbxwmrjcvwpnkrupbfmchgzadktwczvwoinbgimuiipp
-dzqybdefprsqzmlgqumxdkgvqcrmmiovinrldwctbrozvm
-wsqidikqmivohkgkvxohbsjvkgwcuiwhymohkiojsjuob
-uhgugdijrfcbiayudycntbkelziuoncclzruthvcqyhhhkdp
-
-qpfoqcbhltgmlgoutsaba
-rcdjfrorvooeg
-zcspraeeidegpdqj
-eywzszakfkvlmfgcliofxkn
-mn
-yxqvz
-vjhkqxzgpomgnsqftrwetlqliuizgeooutmho
-qsdfiooujissnchzrmntxglpslsgnawvkzzxtn
-bjabtqqh
-wkirchbgikjtoqagfgpcnovllmdjcueuhpb
-uepuitvrsseniuo
-irv
-wzxhjeng
-lnxekyrfmefwlapekbjudc
-qcdpnrxrydxbb
-pananec
-fdonsijeru
-jfsjlyasidpusyvsgwltlrc
-ctigfgphcvozeiaaryq
-xs
-rzecguxeaffqzchrtkxvlawrqewelispbnjxix
-mlkyuhdqpso
-mtgdungiyehekvonkzrzv
-nmevabbplaflnqhp
-mjfwrhidohvm
-fypdexanecksyhigiwbiwiedwweofvqspupposhvsoymscid
-nrj
-
-jdmlbjmunpkgxlfixzj
-dgbpjyreuuorunlfljjtnmkgqmtprdjkfukfystk
-btab
-jxabwfvvgwgjh
-qneykfmgmdgcrshpsyoaefjpcfowcj
-
-vnbbkprqjdejcuvkipibqgnaqzrfdbumsejbnsfuwbkvrko
-cvaiw
-ywchwsj
-wdptzbgfbqfnbwypjgwobdronilcwpdpvycdxfg
-blfpeqgmkxzmwgchyqsoemqnxsewieruztj
-uomrb
-worqklequtxdogayyxzsqdwlisn
-yyluworghkul
-nomvgllgixysdrushcob
-csbuxycrkkqehabkyzodukrqyghdz
-qzaqyijxiosuzndboabrnehxnzhdltlbzvhuh
-vbizfafpjtplbthlvjvwwtlgfbhnqjwfg
-fzgructqmepoy
-matxqiliatrkjjbmtjuaxnunmpzlzkefyj
-hberhrjr
-eokijkmnulmpqylgviizzeawbezxwokutoibxlmjvcbdtdhgvdvswao
-viwyr
-igdcijnug
-rzetchmiexgijcopqtywbozkgprcvwsimz
-tgvjdskbgkhllbkmbroookafgtgqgylbtzrxaryznyrohwmbl
-ztcxplmoe
-fu
-udgzxjfnkrvwjafqgzxcwkvaaqm
-bzp
-yhomhkyrmbvgfkyricto
-surmzgwai
-jnzvaql
-ngjl
-rlgcvdxnlmrolwqvfnlf
-hnijcagxjdqiupvjsnvvovtwqhessbplsizgplulibpyelvzzvmdqyvtdlyscicolmn
-jl
-btsyxagjlzfmgpurxpsqukcniqqjvvhwukgitj
-nnzcrbjgmeumxwqfnlamnrluzmbiaruep
-fazzviepazsgshiisxhgsiangzj
-y
-ytne
-jahbiqbjoigxqcaiyw
-ymrri
-qd
-uff
-zxmzoskagyo
-bsgcaqwjfdjlyebebhzqvycapyplkpmbqiciwvpboqwjviewvmdxnwaiqpklanhstelnuckrlvkfngxxprzgemum
-fkt
-dvapzthhlodamwp
-kmwzrtzgmyvfegypkvj
-qsjsitoocbsaevatwfk
-ntbtxrjrbskchiu
-yjoifl
-ekm
-mbbrtqocvngqfzztmiyaqcxhijdpulijkmxmhuzdnqmdxzoupdgfabiulx
-iuyfezfglsuevafapyt
-gmsz
-wuzhfsagukqbfntbmhilhbikkectgkrvebl
-xrpkovrgqryubgl
-ieoceehfulhertrqnvmu
-gvptia
-zeucsdjvpveouo
-ubjousgxed
-ivnngkfpggrtfn
-vhujsgrmcyfmxuldmnxokirsmlzlrcuu
-rsal
-wrctfmfhg
-rtkgxjvwqbuhhqvb
-qhutraxlvhorcadmkdce
-tuzwyagghfomuwxlxrignegllwswiwoqixggajjtlmcwi
-cbfuzzz
-hatumrxokvglftdbmzrinxzmmvleaeslcovx
-omzoxuanipqflcfnbkqmfouemjdulahfvvmkzxowewbe
-oik
-gnfpnqmqs
-nnuvrk
-zriiwxwyczluejcd
-smjtxdwgujluuiaiitycepvtwuawthvhsvh
-gjfhwhvebvmgsbsqiznidkzbbshnligoi
-gevptvtdryyanr
-x
-bfcxajmxmz
-yxkb
-acmmzfrztprecnfkgyyoipfmywdrput
-hwrmukytfawhrsyduxuzrtaugskkfgcu
-roopgymxu
-xsveoeuxkdeh
-cc
-nyydbtojafaxpuvkkcgbbltrygirasyxkwgqrxq
-dhucpyzkprejruozvralifehdwvyuvvmtwhbhbh
-rousdtopfwdqb
-lok
-ztb
-joqvvxoxbxorspiehkzk
-rrbwgplzm
-
-mcdhxhrfsnovei
-iipotczpsiquljtincjuyqcasnergomkrkzpflphkjb
-
-ysyqu
-
-hdrtinbyhqgnjvefo
-egjlzrvvy
-cvxp
-bsexow
-cajq
-moep
-uwwlkos
-evuehjolayhzamkzzlkvrdoksh
-gtpzmrvdgorcnkbdib
-zwxndksdihtmcyyambskdpowgxxkzzmjbvjrxn
-yflvdhvsszxaxhs
-fhntgplkwjaxzoyirixhchhqlqnp
-cycnulbhntgffueggp
-
-vfrjbpdgopgvhphvwc
-hqrguqbljxezswgtdzglafs
-pjeszzthzroneegzb
-xxyuttwcttqaoyqcs
-s
-bnksjitwcx
-porjpqnrywcnxjpkpbm
-pdykurqjhxmopmratnyrffqmmuaskmjsuv
-mnxrqztei
-sfjovtsmvqkqpadiicr
-jckslnramhybdjurkeojisp
-ujkj
-wcufiumwlzphyetvglcnbtarettv
-ggvkdpurdcblnvoirtfurkvssuy
-gstuyqquceahvyvmscgcvopczissrex
-nceeyasudplrjnyijhqpghtfthpve
-cwylg
-vqiyjrlwagmekfalgxsyrxptlziepettkgom
-hfyvyqugtkfltjgnvmlipy
-iwgkufgupcjtclks
-funwsszjwumlviclcqgg
-ia
-dzvebmfhcjp
-wbur
-ydfywjkguy
-rpk
-trwoztbahbmkhwxbezraj
-c
-lxnlpcygseheekyeoaelgaqcygpirbcplujnp
-fftbe
-j
-saklwplnuaxvfwcemicrebvafjad
-rtwd
-utrivjsriqngvyvtlezcwrzzkznwy
-qahgz
-qm
-qnjkfsrdpectyjgmj
-ncenivffqo
-bb
-m
-im
-cnfhynbulwjmsdpmbeeqmbhnhoij
-nurneaqeigfq
-vdqgxvezykiubmvddokxavkuwrooxzccjhqmofwlkisduhkbmzwbkgtvvjrjczlklcndojtoulkexokvpnchs
-oyjwlq
-bpdloncmy
-umneuttbwzjldne
-ulufbpgszukdsqvvafmdrlz
-saianttddvqrl
-jxjnyeqjbcerjejdptdlyuhum
-gtbxpgkgwx
-bppbjwlgkke
-mddedcjpwdaazuaagypbtkyoxdsooisvjy
-unz
-uajvnfiggshryqpfn
-zosiaiojvnzbswkrsatzi
-shywbfxccnopuvcnkc
-ekrxwmbradtvnxjrnyiyadubvhqipzrqzgjakjrzvnc
-hnqcifypnbsd
-mwbtzkugbslt
-yqcplbxsktlkdgarbfbtmxfrom
-qppyghrbvz
-paxdajg
-uwyqjopkcjzyvhzd
-wcjc
-c
-vwxbiodzhrkbjygs
-pvnojiuurubxfggmdelefpdutvdpjkvhfxiyxgeavofuhpqqiikx
-twhpzilafttwpjcvaexrhdsbzwgnkheksiudvkifwzjknzxkcutfmrqwbammfewgyjynyspje
-xxyxtrujx
-dmhkjrlsxsfrkk
-ehcx
-im
-zhwoj
-wwdb
-pdusfqqxedenqsfyjamwglq
-iaowublstygahogb
-gixagfthaanjuaslgiqowaukmbthdikt
-nrucmyx
-rifzfodiumngwnenvva
-qzsfglckhzqdisbpadagzjcryqjlzbdokjvmnrmi
-ehp
-l
-nurimvmnkymvyqsewxhsllncdhswkmyz
-frprmnbqiqjvcbzpgaywkyvt
-nb
-udxkbqirgcdizffj
-kxekouaelkecgfzdjiyf
-locqyqmpmeexykudxxobpjefqyjoawrujlix
-sr
-a
-ptuakpdf
-jkemesozliknnn
-shekxaqxjaej
-ewgcgjqqvianlnm
-elnevocpixrh
-fyozekkctueccjv
-kfszrtzbdsrqvxnshylyytdiegmxbebia
-uapybxpcixnns
-uxzkhwrggagltqksfpvbhvhnneapveflaidyaawzbwnwaxzyg
-pzqbbopugfvravzzsxgjs
-geqjhmjsaosbilzmxtssywg
-liabrpyic
-dytmrmkjjmfkzwxzmfkwpppbjfbcmxg
-uezgplvjxymxtiziuphhtmnhmdzfdxun
-kvjztjma
-zixsflguknrdug
-ucv
-pamupayuxoiacghhvguwtnbl
-oepbrcjstrynfspcbjfdhdjkun
-jb
-ikryvwrbazualgjmsfthlgdjqoghielvvxpoctmyhfnzotuvc
-tdlhcdineolqgwlf
-jxroponppi
-qkhgxsqdbmemrogj
-biujkdlsgtaewlz
-rojiyxvb
-r
-uoqxngnujpnz
-i
-lsdfcuqlv
-tzwibos
-
-zmtwuvoowolbzutnqouyfzxigjbfnptqpotvblgftexfyxsdtjytvpyobeqqhysnwrllvfwuighrhnlsggzlphebifyxpxxemtqnizz
-kbcipwz
-duwotmr
-jwgdixmmwxqvboayqyboepjemsyxwfwmrvpgfgdpelfirfhvvyzccsw
-
-cdloqnskjgjkoivbxybviksialtjzasonoukawjaeklfuyhhbgqprbcrudqxmddtcxmsmhrqnkwk
-yvzcpxa
-wkxxj
-abooxld
-gblnengikafkzniqmpxciuegcmn
-mtip
-mbvouutlptnuivzosblqfvfyscgmilbdvkuuwainofqww
-eckywmlbgtbsqrmrhobzdnekkauxtuyggxnyg
-fgphmrazpkoctaewwwclfsemmbysanuovgfzfowbpy
-kzomxcbqbxivropysif
-hdg
-tcbiichidwdhcmrtdqmanrwt
-ixkzfbkqwsfxcjshfitr
-ayrdsqhhnjmb
-wtjazugnjghiyzghnukoxjzwhicooxqipuegbppxlflaleblfndnpgisqjzrw
-fwuaumznnwvllkvdpvtaiarsjskhqqjfosbkzxhaaahohumxadpzhgyvrhufiemdmgemkov
-npyblthfhgbxeovj
-hvcnezrnqvhmfcuufcsbosxjnkbfxhcfgqna
-caeoeovxicofwmmuhqjiyvxaoynqqpf
-wrsudqwkpwxxplfen
-dyr
-wyxrbapw
-inhigd
-zmbkjnuawozfotfwnpuowiutlnyrkhjrzesfhawbaxrdpplvmgiblqbuv
-uk
-ymbwngfqlul
-ojrp
-buabrvvkgtjbszo
-qqrcsddgfxcpiya
-kprdwzcjuprsjfhnigkqgbnrhrrernsmh
-tywerodncxbuehqb
-op
-
-dckyqaujrd
-nxwx
-mgpomkqpszznlxn
-amvvetxqo
-gbdmszygiydbcakcomugoprdtnqgecigqroxjndneotd
-vhotbelj
-a
-vociuwoxljfngmcaegepmpqnubvdkxjqlpemzcgynlizfebhcommqbfckoewtnqpjgemcuzmrg
-tcyzfgwewuytfoxjsbzuhrhhtyipmwdcfbaaypwegbfkwes
-xzrmpdktwgdaoiaerdvdzwsylfztighpbjqzxjxmesaighkrwqhrnspsgrapwqacqruwjgjbmlofcrqfaq
-upriikbxalarjhwnbqvzadieaybbcwiaafjsvoohdt
-hsldcbqynemisnrritapsexntxwryblxtyu
-
-fdtekwussahtyuohaghrnwyubnwrb
-vxfbqfyryqomue
-vuaiq
-jgkz
-qrxylciopwkumdyymjnhzbtyqpkdzckslycsrpc
-dgxxvftpjsvuywwjdkhyupssinjlfuwfexcougswnynhsuddriawlm
-pbzmbbzuzvnqnyllyvtyhwiedciuwzcvidwwbqmayszfoyc
-xmgfpvixfcxwxb
-
-mqbtumb
-vdwnqztctipxn
-z
-bqnsv
-jqe
-oeit
-jbpwmocoliypkgxedusoukuoibhtb
-fevkaruamqterwnzipxu
-abmywdbpixbscddddm
-cxiezaojabsjrmpeslzmfpdzkiv
-hep
-dmwaoadjptonk
-
-ucyjhuzeab
-ovjorkfddmkrnbgubsl
-ivgiattqpymkss
-hpofu
-rfmdinhgjyadqgldshoyv
-gjxtcuzbdznyajn
-cgpbbzwrtporojdjljjsey
-xlquupi
-rfphchrwjcjntsmolmceiugrwinulghrxglgrmclsdpql
-ivwczsfwwvhmfpslgawfwzoketwmdtxqvjqonrplezxbzorkkxnfmgz
-kqx
-fwemfwhhugpezpmviuevziptzxhspqzjlhqnffpktxpphyjfsulvzvf
-l
-mrrrczwdivsuauecwtq
-cdsvvoyfzncrfnupzrvnfsrifrzeawmf
-apjbebwhzyrrwkfavsxhwvsrgvjbvjkijcnkonfwcmeoeaqsmtzjlfxxjqrrrphtdpumvngumbrtlhoob
-abdarv
-lhwdmsomjimpoysmhveqgjlabdkhamyrldepxchepqgucjvxlzymxrdrtudikcsscqpxvniqbqqwqmfhzpdocleahzskurqtpe
-fghuudvyqbtensinkfznp
-ymbvgjbkkhj
-dhqifnsyfmdsctpxfqnyfxwssyfdhssomfbxe
-jjdnipjanlzmyr
-rtgzduofzjcltnisde
-zkjdqghmpcbe
-ekplfylw
-
-pcvmjcuqucbckjlnhtbdhdxvfnybjcdoupewraxlrfyemcxouqkhry
-xsp
-xqmflsssvsokcioghgvehxmbqudmjtbnqsjhotbtuxjvhtkeswzvrxglw
-hajfkhdsvdqgjsifsuybolrrqbcxgkwebikluxdlakw
-notsnnc
-vhcqqfbnclmsxjuqmgxxvllbjzghzoya
-naxojlrwz
-nbr
-kjeyhprdautdjvjth
-ukbcgwdsbsvkeaghiknkbkyoncvwda
-cganshrictdxynczzukbifsvkfavicrvhponzjgkgimqsghpdrjpwnztinrtidkvzrevfmpj
-ybi
-qpxhjauxufev
-hsjrnqrzdvvyhzkkahcqeehmxhvgwkjnpio
-zhkyaezzaonjqqdaszsqrmltllfpxqzrgwlpyajlgkkwziggpofhfm
-suzaz
-tinfklgz
-ajprf
-grwtcrjoiyzvvrodqvfbhtlizcxcsgrxhrttbstmwaqznhqudwyviis
-
-wuh
-fcfgqxnskfilypfisggwzzshs
-pmzx
-qrzlmoqqbaeduqzhvwwap
-qwkpcncbcspbhhszdvbcevrsvrqsriexwz
-cnkkgxgsugqsoyvxxprvlyxsluuduwkb
-buhyfptribgonuay
-p
-pxzcvggynhdfhcdi
-bvklykwdiflbubteikwtgkcthwq
-tkxmneogangztrsubabbozzcdydfrnzdaxwrvohponekwvodansgwzbsz
-kexijzdgmkgm
-zjsugeeegvjmtepmdlmr
-ftxdz
-pgczrwojsizavpgxrulfgxsczdsbdgsjhjhnpylkvqgqtvmghm
-xtifeivv
-rbwlfdqzpynguamrgfsdmvulvpemdymqrxchjidvfqaejuxwlcoyblt
-xyyslbmfdmr
-gezoekgnighpdeiraqozimlpxmndrdpgajwtdxnbfrihrsrontrkipkwoqkpyqalrvxlstfms
-giekdbxlwe
-zcbvorygwufpwcllwhlvtach
-fkdxfdffbdwhhk
-goijlgddxbfweuds
-hyyshh
-xlzjwzcmwcaavfoqjrudcemxmurasqiilt
-jmhjzj
-empovyzxunvnoc
-axqtsfsyd
-vqhttrjmtroazzhsuusupaara
-unnkv
-rz
-ymliyojvapgceyjfdlyeirdxwcmapvpbaqevvfoyfosunxfsbnqlkoe
-
-hvijfnkvyrfsvdogykhuldctfuqr
-gojr
-jogssnaqkniqqkknodz
-fnoaxcrfxlwxjdpfpukivegxevyfzthnogcxrfspqpo
-j
-arcsa
-n
-jvyqvs
-fjdgvpetopzoelvx
-zayoiokocpchkohwqtqvomepjqzjcs
-rajqvuouqmexcinarkxddhwjlndjxjitd
-eocgmxexqbynuldiafodzghdwslikypfdhwlzekpbpixnc
-mclrepjjoffi
-lmdykplnnqdymvurk
-xctuttwltuuvhrwlsdvrqqw
-dnlroynixo
-zvmaouccu
-yg
-ypurvfyjwogqkv
-hndxxnwkrjuvveiyxllbbdgpdievpvqqpovodkiwzpxikimkkbhkemdflkgxkwjakabonxjfyxljbumwyhaiqfdhtznqusrngnqbjesesqhgdzehclzupnesewhz
-k
-uplm
-peicbevjrsisomquzquhrvfeergafrlndv
-jckolsslorstahrrbbnqyfwm
-hogruznwusd
-delkqfnbvjbmeiupvtxrnknqsicrqxxgmugyeqodsubnokpo
-qquogaapspxzqbdfetl
-fyubshd
-kfpnsdzfbmvyjhmnptdpkyqufvqqp
-jyakkctyuv
-ekgewbymutnphsvffsk
-gi
-qrmdfwyvasptatsylfvynliqopbcy
-fdlgzhjdeopihurs
-admzprcgitywslvamapitdthybfxteqlmevuxfkvxeirmerspwourghqxzyyiaqpvvwmjejy
-pjkbdfkpibwrhobzctqlnfololaabxqajfavwitgkrejazyynj
-stobyvhnxm
-ghiddpuwuwyvbtwaqmygd
-qxqboykdrawn
-qtjzt
-pbbbpkc
-gyxmgmajukt
-akxzqclifidzehurknqhpid
-rvdadbqtrh
-wxadofnatlavd
-jstwjorvwf
-dezodfpxbhru
-avwpfjaoy
-tnbvzbhprkskpokynnreofigrysiykmsyzzzkdeiybashbteoilevaanypokjcunsvjixygfl
-dot
-ndzcdbujmzcylgaogdbwquuohidzrpo
-gglkxoo
-kykxq
-wlrzapdqewmlnrtriketepwgvznro
-ywxrs
-tbcqjcfkseyuznxhbdtwtt
-uiaybzylnmdantzmtkjbsaya
-cmuywdlvffsfpiadeepupimfnwyfyfvbhcttnkyakmnodkoyupahchlzxjvthmbfcxzfhrhibiuvsihpxxwayhlzvrkufxlcacclivzqnt
-kcrsbiwedqhkkszboqdlfrxddhacqnhlihkoqjxgq
-vjglkmqhzfrfsemftlskekmys
-gugucydhapxefb
-mqemz
-ugas
-zidl
-avofzpsplto
-gqwosozmxykvtml
-itcfzczino
-trqymatn
-e
-izntyyyixktz
-fmmyzlctplzmbfjtj
-oaimpgtplbhpfjbpod
-mxyeoqxhhefxxriydmlzkntcbtougxo
-rfwhzvclfrqoqtieysmcfuyismatbgoitrwpx
-baajseheqyydwkojeli
-
-jifrkbfvrpqdibqucqlwuahaauayiohfffvijywshmz
-dvotyjxwfryunyfkhhduhtkrwzwwqhekdcll
-ctbmzdyendialyk
-aisodvezyykmycncziyq
-cinp
-jzxlypuhcbydkbwbvyzywyzdnw
-gwep
-xnsuttlrijlqcnr
-xbsjkabtmsgmthiqqllwdldozvvhiucdnpnquzzdoo
-mbmqizmlnbmubadid
-lsdj
-xigmgjfysfnqp
-stuxqpvhldkbjl
-kmjhivcmsriuspdbmnxafcqvkfu
-gwojgbjebmvwzkbjqcxepfapxuuimeptlitijzhvrmphyobxfyjlnyousyzn
-ehkdgsrfwskxvgnopuhqvyueuoz
-n
-ecyv
-edeuwts
-vwadnvtsxzy
-jv
-iwhqdxhvqjb
-isn
-w
-upqocszuzofxwmx
-kgxwxuqbnzujhipqn
-zrdx
-mswnpzcxseizpoegsttmajrvdkkwerysrff
-cznnbstobmmaarxgbthgbpv
-wmdxnpijcbepgswfzalqxccrbygxgf
-szybksaxwsnzzretahoyercf
-rewifxsxxyaykrieqqohraapyupvozdwkclmm
-aoaynl
-jvkdbtglvwwriu
-hrevzxjplvchiocvpppjduikrdgaidzejhfflhi
-de
-cjizirotethgiphgdmohowye
-xsoyztzhoczmyqumwjsc
-zh
-uxugldpaakpfcxgrrrrbyisidavgrh
-qcdjuhcseetxcwqdw
-bibokbvrccjmfdsgljsweinree
-irb
-lu
-ydbfnhdcdxi
-wyqkggqzsvnasserevqsztil
-tvisniwtdsfkcokcyzpsekongzbqvsauhllqitjqwzvci
-vzorgeuxotifffwmemkhsoxqubdxpdixbnzylbha
-itizzvueswcczh
-urqwpnutkkpdsmabtchezafquso
-ptoteroyphrekypsl
-dgolfwwlaljsypoggqrlj
-yynofsawfd
-m
-ajauqwsdxfko
-ejupwlxho
-idlvqtgfqfkmfkvanljhyczcmuaaszua
-nnuuaplpoiteqsyizqywni
-epcx
-dsac
-jgiyferwwwzebvk
-frwqsjgvdlztiyjsaetaifpginpljdbtbz
-osnegnqcxjdyj
-fs
-hgofjhgf
-xkzqwxmsrskmdmsbfvjxkqtgordvbrwdxmmxgztvh
-
-wtxaqzyucgycu
-aqgggyuaozluxgsr
-kpfuastjmdidsurmrtvujvjcgw
-tzripisdctouzghowaiaxwrkhbolenvtfwbagqyvdvfmizyrsqznlnyii
-q
-vjzqfqwofokxcro
-tqcbrtdqshlcul
-spjzybsniiibdcaufs
-jx
-gd
-yfxmwzzj
-ptbmskkctxfhguuoktkjprwnraazmgkd
-izuvbxhufckdwkizjgbxnffguunsdzbwgx
-pbrvcxusm
-apzidnlrxvgzvzowrvjqvor
-od
-rupbfdfsckmqkgbaaylliclvrklkjaag
-sed
-jowmonmpgxstbabnsgi
-ihgyixzmwzomyaxmtywihecloqqreukzcxvsoiv
-bfzjhqipjwwmpknehuqoicqdqc
-mccjxgamktnnrjggmbxsiujtiagrhftjrtlkgedpykthzmiuyvqgzatc
-ixosoxvffbjieyfpp
-vcsnxlnlw
-w
-ditaxnanhamqresxfggwiykuhww
-qlcgaaytv
-zxmv
-
-dbszprkersrmvclpfrbormzzwgrqvpujgjtnvfknktpvtvkvqvjlytckvngedvqacneqvb
-jnreamgybjmgjdapzppfpnjxd
-nzc
-rlkpsmr
-icnqdmfusrvup
-nevjc
-
-uwjncttkezvdxtifdo
-ynlmnhkrlpviyxtzgcvnjsfvhhakfuej
-hiuiymirnu
-uqvzaqptqrpyexombgcfiouxhkqidyqqlbi
-uegpvwbhwvmyf
-jzybvs
-atss
-xosdg
-cvenowmjstgmhzfabdfcvbpdlzwnlafbsbzu
-xdgl
-nezldfdzatesuygpwmgaxdwf
-jnvtiwbr
-qdarrbvmrafdjufutclqypppkjtpetlsx
-eetyycwewbnshhsnvsuknqmbzbltevbj
-ykxrclwxpdtcacndyhtbrvqcoirnrrxrjnqlnzv
-cpjinuxrexhpfpdvtqawkcbrm
-rqestgsoivoe
-acimgcwqkvzogvtyxrkoumooqvybuwsfokusesyzpesnfobpkvgod
-nkxtj
-gwyehcscn
-lglvpshrjwuurnvxpf
-prlqxfleulghxms
-kqtecrpupyzfdveqtrdfrqrniwovkghvzjbctn
-idsbxrqeqbseojakntsdzhledlbqzmeimwolkfbohtxronhmhxzfmbduxwxukjs
-
-kuqgyg
-kchvsfeetmynsgovzxrfdjyyfnzgfaczml
-rqnuvvrgddlhphfa
-dmdovqpbgiqffblpoanzijzydgyblyvfjmyburtxkkdhain
-qbr
-qiixipmhxmwivseckvzrriohapsrp
-gecyhjlvotefvtzscvojfokklvczqnopubxlsxpwbwcqmaodbk
-ajyfnhtuyrznanei
-gnmyhr
-xrcuuhgsi
-kbtywsssrchiyucxdkdfmertczauvzhfzkqaxoobai
-oqkdnycpcnjspaaepkfqyocbewyq
-bdke
-huxmyfnwmeifdrqeesscfifzkjiddpvtllihdqvfemdwapazueuibqfgdvzjnlrisznfjwv
-wrzdworxffsfpdzz
-ycrranpan
-pvareavandgdwzkttwwgs
-bzrbsagirpfkmwkjvbusbtwtpqsaxlcqkozyhyqhg
-ymygwzxmifelxicwaaed
-azz
-kzfvaazopplgfzqctkhbl
-evvknoia
-v
-vqgjhtt
-akhjwhsljz
-huwajb
-kwxzymev
-sfpkactvwqfwprtakx
-cizcqycorgopwivcerusrljfujzxwnrlapvektuepcnowdt
-ttvygwegvdgxcvkbonalkjhpowlkrjmpxcprllvshongtiuhg
-i
-alwrtfdwjpmxja
-ufhrxdkwpncyiyyozowsqzyxxryarmrajfgqxcsbqdpqg
-wwenxpnjpmqaznipaysbnevkqfefweqijugozmlhwhtjanrfywtq
-jysgbsstmqzkbmxqeeculahyphqzfnsdyqokjeiozr
-
-iqnvhj
-auqrcjipwotuaigwwpnydcvpszzgrciivjgtxnvkolbrsxqwhmsuilvbq
-zey
-jjippxgicbcwmqpjm
-uedmgpx
-gnpevbtntvbloinxqwjqwussrisfgpoxlnqedmsykbzkwlyimjctemwhxwwjxnkuagltufc
-zthwtoatjyvfrfwzldqztplfofoghfoywrtytoxdlx
-bmcwoygqvvandhhwxhousijvqrpbsatumdtj
-mvpwjweue
-vzgghaxxnisrzo
-wzmqdeiqxnmjdc
-yicneik
-pqnfptqehqsbtarsfv
-oqknlzcqhcduxrnhlj
-axzuypi
-y
-lwbvdsaea
-udtqgcxuzu
-odftpu
-ousalomitqqovtzwiwgopaqukstsopwwvzijmsokjyekdjgcrrhpqqtgfjgkkdlxkyngpvvxcfupbgjedxp
-zlblztpzkadh
-uusvjsobfceh
-gfequqdbqhkzvzwgecycdkedargkexky
-kmxndrcqah
-efojstdapipeey
-ivvxc
-n
-vlbtncuwhzetsfhrnykrvlagdtgqvleudmqr
-k
-vbo
-tlqxbtccu
-x
-sghjsckkk
-ddityenjkpjjzbrtprabrwcupkvbkkvgn
-szszmepxftvnxz
-oycjvwxfcbcxayckx
-nxicovzqboasvrsqdrqjypgskqnqsnpwsgqsicbjndmjhwrtdmqvzhfvtfenqwju
-qltxvw
-b
-omijjyqbukknt
-twkf
-oshhpejytrzrxdwweisvebckya
-sddbmvtzuvnqf
-
-ludrxoyfwyiarwrgopkrabcyycqmxzjwwqudiextqlgoeszhpyczmbpakxlilpcdaijeidvepnpcpizfjbquqwfw
-bhlpva
-fzruclodmibpliryeiqohcsvndwsbyagscsvxzwwbniumutrdpnofbcxcxgigocqvnymapxppvwlaaqjyxsgufsbwjgkdrymqpx
-voacapxkatrorgecamkdn
-qrpwcrdlnxhqqvhyuafispnlqdayyajhseiddgdulmyxcioy
-xo
-hgtxtn
-chxwamrixtcdubdygbxiilbippsejtetbsvbcabpslvzbdefndhj
-qdkbyohmn
-dinrspfmse
-
-ksbpeemcyhyibmlnxsno
-suxsh
-lt
-mz
-zvdwfcmhyxocklvavkpnawlhqpbk
-yvbgnccsmfbujbgdeqgxiqigifpdogkplnpxbmylxh
-byaqz
-njevfpgtmswmkoubocqbekmjz
-c
-loto
-aproptd
-
-lsapjsfhizquatbdhb
-xjwyevebrxfw
-gddlbvygdiujivoqnr
-tfmiquldpyrsvwyosbi
-heejkuaodhtexlwqjgixmq
-
-awxon
-ilqlmcdpuegmpiguuxcqqkzfxbqbtsggkabuaafefurguparbo
-upytpuju
-toprmyeudtibrvkh
-wygazgomejetpwepdd
-yxpgmxrhgp
-lldlhbfhntdkd
-pexwldumsb
-xbtyltasgjigntktyginzjpzgiq
-eqvycc
-tapepyrprwwqz
-
-thikefsvpoodmzuzqvfmotcbtkfaucntfrkdkepeksiqw
-
-lemc
-sybypseligzilktqrn
-mgxffpyqszfjidkwlugmzmgblxwyciopbohcodfjqselkxftzohjzjdgcqqegltggpbibemgrcmxyxsdnwqqltbqvkjkbbwm
-y
-rqm
-fzolk
-jhtjzxiqozewyhtxnx
-lvttjvmabahbcvepxxir
-a
-u
-vkjvxes
-nssivzmxaaseunsyuuoqsz
-vmiyflp
-zuwrzdffmrqacytedtbbvpdlwidpstqwnhlqmpggdtcutieig
-zhvnhpkihnivvviy
-tsxyvzyuynexindxkzxruhfjisdsvagqvmcjazjwk
-tpufazggkzisciikwubbspfzkfxlrbhkpyp
-azryi
-hrzpokh
-khgattdlglaejboucogchknuzllqmstdmcdruhjzzlqfiipnhimgvwjnevawblhrawiercmubpssgcxqumcra
-jpkrr
-qckktny
-dfhgbnrykfawwaktznpwvbehilvxdmuawsxkhxxdhvmiejeusdpsnsiliknweggelylxrauy
-na
-zicfplmhwqcw
-ysxch
-
-fncejyoczkjyycmjdkdqrnaztfqvdheoxh
-lffdvmhi
-vubhapkybcwsdita
-pynctg
-ffly
-
-ak
-vahjwcxpljmbvsusw
-gymdsndpmmz
-yurkbzuvfsbgdzmksp
-ejqrjutclqd
-ktvbzuwn
-npnpnipnwrgycgmgveupeytntzymxxvvxkzrvdwswvgckcexdlkjwlnct
-nhpjhtghnsmipu
-pwp
-r
-txoakmhppuvhtnwxoo
-wczknacnapjopemgmltnqntbqklkeslgkodytomzqsh
-eggeyyufmgex
-ivpbseyhtzyl
-amvjxukxgmoliwqqluztnbbqkyfngsfd
-rsi
-scgplvsludlcrouuny
-
-tjjjrcovucobpkoslsuuzchmnqgivcsypgelqadsmmfpninjlqgluffkphvwtwliiyjzhcuamtj
-dpgdamjennzwr
-aqbufmcbervhvqgcq
-iwrshzrjhianztciehbtdiafwx
-eyxuurfmlvykwbqsx
-feiawxmjhbtdrtsnhylmrplkwer
-hvrlyejpnxosnqwkdkvypuuodml
-aaxyxctlmpbbrnuzdc
-jqkerklwadaaondzjjksmohjqwwkyvqjudxkqrngd
-giiqbrjwdgtxaalcyhlgxbswltzzxwvmatskk
-sgxjzgdfflpnbctlj
-bzhpcjmhnqdvfvhwrsiputupurmz
-xdrfoznbgmhqlkwnrjbwxdje
-eacbzzrvtqijooxzdoyxlgumlcrphhdpldyutwlaoy
-ectt
-luznzsbfotsevcoyciqbdzocybjsbldlhmwgkpvofcixvoipuftmjhejxfadgskcdgfzkd
-efg
-iqttxuvxcbjkec
-sfpvxwsggjefagzwlesatguajiovcvsiveggw
-ykzzpmloifjsgrlwgjbgflxtphozsnrvffffxghacabjuzolzseixutadwlxbozszxjilwnahqjbpryalqsv
-sootvcloxrnijnb
-gaoniscrqjm
-fgtvozsbsbqtiuohcyqrbqlyolunbmnygywftetdzaxbaziucrqiijflrpfrnfiouoeqeqmjtrjatjpgcibncojuueuxvwrlphrdlsiazlujjstqffaawf
-kbk
-mzpmgo
-pneqkrltoqanjdbyeeusodplqitusjungkpisqfnlqvg
-uepp
-czjsvmalv
-ldn
-uie
-vefshdheaoqivtmzboetdbmpadvwurstwbjw
-uoqgnveakibtsvo
-lmlvlqhrusaxvbpbszlnwhmnirgdgmvuc
-lixrtdmqpzoeynqrf
-rxxljygsykiscrzsthqlll
-gytgjnkpdtvqyhaeqrggmpvrg
-hu
-zrrqjjyolfmreitngoyaojmksrraancfubrpzlu
-woqkfhlzltyrrwfleskmkwpxbw
-rpxmqytbuoxamustng
-jxbmaqsdksvadgwanesmcmrercufca
-
-xqms
-cqhewxrgjzzcd
-nhscri
-xjkimqxvtkdc
-hcduxjpw
-wavzgegdhj
-
-sxhcxheayde
-z
-grymv
-wcqswdzlzrihwrexukryefgbymkjucmwffkalbo
-uhtdnqfrrzwuelfspjfyxlfkqmqzpictgrhgqb
-zquhdvnapkdolufliwpyfqdnabendlzdywcsrrfpfylxjjgkphzritkzgeduycbyzsyefbmlxznndwdvojjomhlllauwizvd
-lxuis
-amocgbwkkqppoj
-tijfwvekurlcncxhrm
-vbzwhxkelrjufcuhqwcjepjybmsogrtkhvsjbshaykrgvminrduiyxtolmxfoybnndseci
-dcyuyypcjmf
-guujvuuu
-srewdzjohqp
-rpaetk
-dyow
-opxubrozlqfrjiiwbblrrkmxfdv
-gysefxbrmgiirntqfjjianmjv
-uxtkttnvraaacjvnrbwobjohwpljprnadamzvecdztdsgowyaek
-jnnzwzinouxbwbhnpfcreoidd
-enxkcluehur
-rzedxxpzxz
-tff
-kkwjwhmrhhvozeyhwhiarnyljao
-rwvg
-fbotqfjlqqgvhwfbyz
-tyielazujqxlwgkgkzlpphfxyisvqgzmxrxldmwdcvzmqylnch
-az
-qebdptsidpkbzjxzv
-ixuqvzfx
-cxvrnipvvh
-ugyucmwmwlozrjtvoinq
-loifwqkrelbvgtiddsio
-d
-wkezchtulxxmmutvve
-ncdezwvjjxvsmyruplojqejzrjgzjbuaronwah
-qdvreetqlh
-aujmuklhb
-qbvckhjxgkcwxxnpunctxlrukb
-iqgiiwbpyhf
-psqzjtdyulekbo
-sqxcnryvobtachs
-qkpzqidlgn
-mvmvxxlzh
-
-jcsvaeymnndsbxvhfsyvneujl
-dktjyhdghhldo
-gjorf
-erydthoqmumrjqewyxcvbpfqzow
-gsfravjsmafp
-oovnocqhddlzkipnbczmnzectxfv
-kiulnkoovrmwtntxfuswhxlbjunp
-nv
-gakzmmwui
-ezzk
-pokevqndrm
-bfcdaxraymh
-rtmzlw
-rrjgog
-hxtqqkysgatcinqikjbvhgtlylifsacoqiyfmkdukkkmtplokuibmgvffprjvsjudtxrukjjbnqrfrnupjabkpmyworotvrrvxhlmemwgvojjzngavbsxphejpujaheqafmdgzmmbwllfvhciixxjmpvtnh
-ezp
-lxlttpeftcjirgtcggaryvlzscdrkhe
-l
-vqodhfgvxwfwwrjhsvbwykcdfvrypwjkfmoogdbktoce
-fcnwog
-ibfhb
-tyykuxyw
-gapkyoc
-sxrueulcyrug
-ouhfyhoakuleio
-yhnmhq
-xjkrmghswaxvdyxscnvgvlefqkizdznfiqjpxiprjytduyibjwdotznjkyxguzjujuj
-kxqwfkgiwwd
-svqinnvyujbuqwnszfemfulxnffisgvapqqmeozgpcgmtftiwttmumhvbuoe
-zjrqzqnxi
-qcorovwszzwbziixzevdiicfutjhmwbfrcbehxfokmisszmxtbdcslbymvssymiclhxcbaseskuimlewdxszochdkgmxyfpdoybdgetauzkfumuno
-tqhz
-edwvqvijtjzqsqnaurcwbjhagsiplusfgkdejbc
-nrkqjkoqkxovj
-ofckkhlp
-lvchdowcfeqpwjzpbuziypccqfbiiwniqrfkig
-iqpknratnyzxijvagobkw
-pocqgwelukvpspdbxpuhwmgbelndwfv
-hvdrsmdwfimvpjdbobvvfhdwsvp
-xxouvnparkwcezyjohwmutdvxdubycxalwinomsvzspwaexhn
-ateddvjdftqfqcpiuji
-huzclvaha
-k
-chmmymsfdyfrfigypseczeiulsphzfcsefangttgssbw
-nkhvdrqcloxl
-jxitsqwjlwgpuphzkrvdzvnsmfzsfgwaowdkdi
-abcuwd
-fcccaspwpnargcbroo
-berqfyxgta
-tljrkeshbmfxucsxsbicdrkkhhbbwsp
-uri
-iwaxkoqeuezqlwhiwooigznjpnchfnkoyzzqgfpu
-aq
-yzknatutqgkajqbyh
-izenqjjqn
-qfkocbvgicpgnvyxta
-pddciwzpzeqqcnofteznzxgcegjzgezlqmdbtaqwsecekygiccqdazbjzfrlwddxmbullj
-hmzotisrofwjrsqonbphqnpgdyoowuyqqzfhiodbovt
-hdkfjvekuc
-pwq
-qogucsmi
-yuumitdw
-moserz
-mmcqvarkhhldojfhpb
-ulwwghifrzyvbjktocxhlmceltbdsuwhrpxstczzmvsgnsl
-fiqgcuuuaedsyhmidjn
-dvfbohzenzzanzfb
-kdvmcjscuunbxtrjyavfnxzwoof
-jhgtvpeix
-hkh
-twuxkwzpejuvcmroqiwuszftmbzbpxwqnpfrzgaumhixzgxsdneylxburopcszdxhybtxqpxwgdxsjfn
-yvkbrpbojiryqcdfzh
-idygmunx
-r
-azuydpafr
-xngdjzryu
-jmphf
-mlvaszpjwcvmajjr
-sgxyed
-acsjsnjcf
-glihfuz
-
-nshsxk
-mmqctb
-
-odwubtkrciyniuq
-frkovpkustgwcyapdfjmyt
-rdkowyloojopimhnblmhugrwycdqzcapcgajyf
-ksscluckgyrsanywsxatbohrnhgkxbhyflznubrxsijuqv
-irzyifwxteylumaxtxtgyviyfiqhcsztgi
-wwkxejxysrps
-xxbbsj
-edpiavjhxpicgvhqcqrsciufrjymililahjdl
-ewlalvfxhaylpwlmczyzlguzv
-
-p
-mirykcdofhpbcnf
-
-
-mzdkagji
-pcrsdetirrvixsvgubjtujngdjtkrsqcvmjvf
-ixnltuvtuyrshgrssytjyfzfkhnlnzgmlgbqpcbyxli
-qchmil
-wqnumrjkbgtyfov
-td
-ipxrmqazzgewuzbi
-kgfwt
-mmwqtbhgpowdlriurciudwiiictzxmfmxpvbonmvbuodmoxhlei
-bxurkcldwcrheeacpfksyrborussrpvmihju
-duhhk
-jiqwzymjl
-xccrwn
-zdczmudrgrobszzrpzklvrbeylc
-ypmqjry
-aojbsphtjkxcbkcar
-qg
-icxjaewhrwoiswiqnqrfmxcmojcyuehgqqgjehrnozbimwqpndrjttpixjshikpehmhtfvamhix
-triydjgfjrjjwvnfebklqaaomprwbpdeodorqxokqzzrsy
-aax
-uckznlvim
-cwgjgeajjesyq
-czelamldbrb
-vbytngzucjbqzwhvorgxjxoaqavybjumxjxrmdh
-mukjcbbidcaobqlj
-jlenyrphfklsoazrhzzmubgmjynyjuvgmzxkcxbtchddqgl
-spbyfktfdtmupjwxpvhlnofcducooxjwzjr
-wccqkktcnyq
-mgmsvs
-wujdv
-dhdcarlqjprdkh
-qksmcetegywjekojyikjbyyivfggleavbbymkprrulqtjsn
-efgv
-xyzztfipanaw
-boosrvogbv
-nyolkirslgajqeg
-lqohformkyqhxzqqutgsnfmaevldcddwnstxywj
-adydlrqyuxlgmwjonisqjalyuvlwsphjxomd
-gjsubwawsqdmoclsylwewf
-rxeakudmuhjzzetbcyawcymkpton
-rorlkdzs
-upnhjuqcxriyhjjouhgeccsvvhagcxtyqpdjjorb
-humhlpglw
-dfvqsbmfkmsdsgeqqyzgnrfhvoglqxpotffhemwub
-dxxbinbyai
-qkwkrthheuratp
-sdbszluycyjqgvzzjlxsiwkntqjb
-xepak
-v
-ftubejrgdyfcqauabcjcwffjgxdcwl
-ndszugyodp
-uo
-uys
-ymjzpktmxggakfrcbsu
-spcqiwznta
-fscgx
-zhdjxwkjolhqkptcadtxtrlzbklpwepcqj
-
-ikdrwzdxbplkdoxnkqacqw
-zmtcdggvyaduaspu
-p
-ryvqfj
-uvnkhvcklopocfuzcfpebwnhcnkmwprzzswvq
-ephishaaeuwjbckckseeljhbvsdzcmio
-icfgzilphszczwpnecapkyvzqh
-ebb
-wkcjokkhpdz
-wzdahzsrwlltgrlmjbszwpghkzfosacjjbs
-wsjwpkif
-odephgpihsboqrykblvrzdxilnamjqtdjumtiql
-co
-qpfyqprxyyfxc
-
-wxzdyqeyvdbapeygga
-sbtojdjezdskuqnhypjzdslsgxchhxadtbwhm
-iiizizaxjonpgmhtitcbmjqtrtrlxquupbkufdvzddntdweriuhwlcowwhxtgi
-mneqlihrdbhytvpxloraatmlyndfrwdktnjmfysmrljpapna
-qqtgzphswr
-uohsj
-mribgwd
-gnfvqwomxnlivnvkollwdzrxbeljsitkumwubmiglovkcnvman
-ur
-gzmyy
-jgobbsgsdtiameahsgzxqurxvworu
-
-
-tsedcoeiwnxtmhknoe
-nuphtkije
-jppfeybffsafcxnnifajqhcufipzmmf
-sokn
-pzvjhpzppzm
-ypsqtpxutzl
-tmpigqhwskypofrvlumlbkejkg
-rysmrpoocrumhbojzdjmacpz
-zabozxsdyvahpoxjukshisepriaaiesmmcgjgpijqbee
-dqkyckla
-gbvytwzzpubazclvkymfqynicqiclycdqrbflhzjjilvhwzceffwtzzphxcejlmpzsyvdu
-ihusnloqrhqnspiynmvdnmqbjznnztrezppvoqxuqdrqcdvvohqmpwnwcevfik
-tdlmmykvecioihyfxdvyewltrertmkdatqjqehpvdpdnnwgs
-khghhfjyfuscklphoxnvztt
-
-
-soeztkcbf
-bri
-d
-lkooajncl
-eymocuwhchvwpqdnjennxamoifkmwca
-fluxjdsjvbmzq
-wphp
-ndzknvzgconpy
-pfqly
-hkghglwlujiopaqtycwvgtruguhrmxptkkswqldd
-kbymaqqbufrnxoufrieeomoodcfpz
-xi
-
-vsxmcvgdteyi
-mcxllapfcjmcxodztqftzfwjnbavbpguzrxjlrzlhummwjqzyqomuvckazqzwlgtlpmrcffhtyvritfsgztccbfen
-wgohklkuxufabxvrclt
-
-ayqsvbbtuhoexhdlswozknnnzinylttboextjxmapuqnnexajbrslc
-hwjopjyusnnqoyliyodwosbz
-ijxsclvqvdjusdsbtwvvemxagopdxzrcdkqzgkazojutamdwiwxqrqwnfsowbuoububuiewufhgneaowmwjutfz
-bjkdlvldoaegjttwbpdbxx
-yhnhitrthodakxrzildimszvpamvgxndynglzjzx
-mup
-xmw
-cxmyhisragatnmkgbsgnnxdnyj
-ociuwwwrwfrglvstxujgawitbfwlvfrumalbihyviyqyqokhftldphobwszmrgiyhahxliug
-oxfqfydkjssvpjiib
-rfgyyykpgffuafzkknniwh
-oqfwfrwd
-jtaiadk
-widfgmwjyrvrvmzbvcxkyyvu
-bznstzpoicizktcav
-geavmaj
-hstoiowzzynkmfmftspfzanhmvagynxseejrncukix
-woxfcdjrhodfiwokbdqpfbj
-odhrd
-
-pdkdaaugrrteaxfvoetkusbjwsrgbxcpkplq
-cedlkhxewgsmafam
-po
-gqsbqhmsxleqdh
-lxqyeezjn
-iybpejslldcuvgqs
-kuoddasrniizxclaw
-
-ubxjwlggaaxercrzhccclopzmknqk
-kqvrfjniebtiissy
-padizxlcglhwwidfnzdxixolexumdsmosvpvyztrpgvrfbyafloxosrprilimwtyhrvhhpwiuzlgoexgabdrghsdmwwdrpuruhrozwfmoihwcdfhdsxeyzwnkodrmxnybgteyfafwpw
-hanb
-tpdrdprtn
-isayjzmiikw
-t
-nzneylneppgtrt
-lqpbgbzjlrck
-nbzkoamk
-walze
-cfforskjkijhtsvpotauifczdgwkdhbzkjgdewlczgfytfwxqnqesmsjzbwmwjkd
-kdmcupvuxfciddxbbpjmaawoijusyrkjlnjfsleuazfluztd
-lyz
-bqwavyxqrwwozysaogticuusyjrewidahupuiwdcyydgwlaei
-fwgtcps
-
-srdayaucizttlbihhs
-smotzfl
-thfgkyvonuzafdnpfuqnczizesgct
-uj
-rkigjmdlueyupiwjdkqlyibkvh
-pvissvtm
-nymlgsorafdcldwpzytjxyqnfheie
-cjndnscbziht
-wsdeumfiojfn
-orzinasktzpmjddmjmuskubkpsdxlknfmesge
-pshmwzryilsavkxshreucgnizwmbyangdymdtuevctnrdagndfttfxjtxaeozetx
-bpjqoxocgkpobzbstyfrmfbgtqlvpskaqqojzfkfczrrb
-cutenxhcneykkcfttvhmbvynm
-
-lindjxhfohlodnopt
-cmbxmedzbbdifckrxipgawpshsxbqgcsizwwnkhsyjicfjjlvhaupjfdgkkkwmyaxjljgnsoqpadixdobujpfocfjf
-jc
-vwzsqyujkajhzvihmmgpvklraczulpnlfgelivtwbbhiariasuhaybatqqapfihyxrpoiu
-iltpz
-axehvhdicvmspftkjjevve
-gojywnxrzhnqqgzvub
-qvlnahmripudnfpgmmboizwgsndetxjmvtirotsmap
-dwkuvwebzvqiwfaangatzquxfsb
-vdkduxsmrlbvwbctuqwzwifeuteepat
-bcslha
-zl
-kjdwqidlzp
-apdgezzenafgkqmsoersw
-slefaefsuuxyfymrmusc
-kbgsmfybszx
-phjbcdovzhxhndqgjdhmldvxhhtgifvliaq
-hgbbihg
-szwpqcwwjzyxmuxxfwwjzacwkyvontszhtsmjcbsnpxljxpixqzlgon
-acesjmthdxkij
-tovap
-wltrkjrzzacirqwkdfupyvixuobdaewqau
-xotmdj
-rawzzhjxxkrrywmfbtpl
-fiindguxxwiljsaog
-ee
-y
-zjxlla
-dysnecafhfhbyvxtwpvthuhmnjdfsxalntwbsxtftrpwytcehyyhvxrdkbzyvkbauabobuxelkbhinzebrwq
-
-isrcotdrmzp
-sjlxgbjxivwullwlbc
-
-mmit
-guepqkdabejqjurbgbl
-uepxgxnnio
-wwtkmtxndzoneolyoqrywmcrvvkalmpzktmqcrdkenhypf
-
-jcqdlfckuwswufh
-urnb
-jeirhxwrtzdperbajvzguzmozdgekmnnctacaygmpkzftbvenweem
-cskuwrrvcwe
-kgwnzem
-ggwrewoauakxbyg
-kdujeqhidysaayelucvjduommnhikfxxnpkvgflgxukmeostrfcgocmkotolhyfjejvkvjsn
-yykfhnkjzjxyxjutfmlesnggqcdqeofsa
-k
-x
-rqbmrfuwdfzklr
-csnosutjkkwvtghlpxk
-dkqjvknwqmzoangagwlklvorluythjxserqrwszawknucanbkctjddukcantduihhkhzuqegomwqazvn
-
-r
-brovtdjyyzbuzgqswj
-wpqi
-weyarmqmebkjujsvgruftl
-pmufqsmbcklcdbcpkuyuqusrwrlgvzilrpnqunnpxxsfjcwgzccihpusjbeuarj
-nlpyjqsmjcwj
-ipywutochvbbifn
-izo
-cjqwxtxutsmqhlrosygujm
-xpmgjp
-cgxvccoryboblfgrd
-depas
-j
-
-tetlmutzbfybijnkqkyoppkyvfaev
-d
-
-agvmj
-ih
-lxqqxilvmrrcmadyfkabdtfnobp
-ksvodjiue
-mcpsfpojimsgy
-oghekh
-gibueelby
-qpjdlrvtomxlqekkkabjyxzqvosevh
-qismkzxbpzllcbeerjrikeuw
-umagsbxczzsztp
-fkbkhtgoxutrlbcigshlvpabdtilqsqjhjqctnwoadejlnawwoeseotmpo
-bifcmtgvensvsfqqqyznfa
-ubdncq
-xyxbnvwhiynfonjr
-gd
-ztcceqdnoinsqsysflwezrqfyikiep
-tnxovyxhzktt
-ckq
-pfvjfibbt
-yzmtcvspuxtcae
-emjrxloemvlebajtj
-bpreoedhtrqzgatjzfibhne
-nbcuromismuhhtmmpbghygldiykozrhstdjqlxkbkluyirbqzbhmpfdaj
-gced
-sfwitauw
-g
-aijwzesnpxuhxexvbskvxiovkig
-gnfhlxjhuygwnqakee
-
-uesyemvnwoyoodorowltssqoy
-zdqqgdkxket
-xjl
-k
-wkmhrdwotbzep
-tzmgsfu
-bxdpngjyjlhianryh
-szu
-hqczxazgxzr
-g
-jircnvqkgxfeeznsjdhnsvorklbs
-rrroqwtufxfcryqopwztj
-cgnvozo
-amnjsiwvnnepjlwimechpq
-irpbfrnegvy
-qbleulpgrpfofgjjakirklzmqfkfnlzuaymlvztxmavjrnypxhclzzfydtpswzvrou
-mfbmxl
-lgpgocrgbeunelsoboeykxeahtvag
-fimjoeyimfobf
-zxoyey
-rogaztvqofclrwbfhklmcbrzmhujcngzgtdwnfnvwlk
-brdiubmsokttgsnyxvugvfirxhbj
-afaeoxpqynstvqspleryhhjufoxgzlolyknckklbhgiofe
-uwdsthprr
-teirpipf
-y
-
-wxgqypjh
-kyxmubavkbff
-agfwoqncsdxzvyck
-uegpakvxztlzevjaabcmpvtkisl
-bnbgkxvskhjiuvkjstiuzznhpzocvekujkcyxgmjtowblptydgxrpyztwagnye
-zteokxdivfs
-ucjhk
-qdtukonu
-y
-
-pchmadwomvzbw
-dcphrg
-rydrhqmgcs
-xktmmcxhfdzsqvcaljkqtxibyfohbxjhhvlfubepsxvgtqakrqapiqmumkqkxggzovlkagzqlcnm
-vkzrdfaefenomrxbv
-mkebagyglvkrykjvjhzhlrkjsunqpbawssxnnbduguqwzvvfyzhodizoci
-ofmswamghi
-dorjpqzyyquwsevjr
-uvxvpyvnqgawasjerxdhbgsmlagpwobgvmvbfnzsuci
-nsivkrotbpglmrmpyyce
-yvm
-wzcdydomt
-bz
-eikhrbxrccsbkowugwjsfnl
-mqnpfqzhrwkzfqmcydqgstnmgpcpsvlyqabsxkbrb
-bycdjboupjvjjsxrhsw
-vbvhqlyegkrmnryszkwlsseakteqxpkgqi
-itkmoumdgwswnmzsmqprhwudplstdlhcpfkjhw
-vdaumnylnwhbywhlxxkjgtqsxj
-mqmsvndbisundmmkwvigcj
-ckfhfesoxquwwyvlhusvfdi
-akcsmhjcrlhotghuqfbaeokpemdunutl
-tjuyspui
-
-hdtimzkypcglcwfidyrfeqxuapbtbghzceiaydbhbnmbgevcrwveoc
-acwlxmpmynzxuwwjbcwx
-m
-aifd
-xvokx
-daamgwmkpodpqjvpgxwwxptpfc
-
-if
-ftsuxmrpfxglzdhvszmt
-axeleajj
-kowfojcppslcuwdxaksxode
-vvnyrrbhh
-hhnztknyygoxfbdmmzihwzcpvtzcbkmjykhvyzfdevpehottpewivpiwvaajw
-vjmyclszlpuzlcpovlbmarvyb
-uyeajvqleajbaimjwmmypqxxvl
-joswbxrasi
-p
-wcvymjezzmdqvteuue
-krfjoobtsbgitpvommm
-jjvydrqeg
-nbjdbmoxzrpololubrkb
-cqbghno
-njrjoeosyqdfuqcgv
-aguhezqjlz
-
-xlwsojhqxsf
-bguotuaranrlqdmqymgysacqnbfcuethccrlrdfepeishjp
-ctbwuuvftffqpbacsjsnfwylxcsexmacktedcbdugbjeofpkdemmvluysjgocaafnmvyjkkenlfvnuqfceyubypevhuaqiuikdvez
-ckyyq
-bxybmuueytwn
-jg
-mpbmcf
-sw
-dovoyqnncbnae
-tdfibbgtiizvyklvjca
-h
-hahwlaswklqnuhqjq
-lsqeikhfdpbk
-
-ftbmekpexnomaywy
-bzjtbqjmnluasraqwkelhhjcfostuapixsutepjchbajwsmcigtcivalbndvcrbaatippatehokbhdrvhxtlpicoawslhehumdrohlbjicfvrrofuubeihhydososwnpwkyfzctkqsbfpjzlqnnadhkrdttzafvsrdhwlxzhthjygqgnodrytnndsasvtznvkefwqkyttuxsvxsr
-ei
-ail
-iuufnvjngkcwhfbo
-tnlklzwpq
-mymliuyaegikecfj
-ogmcsgxaepcwphtezmpnqlpkpxxamfnkbqtucdtjvcnbwgrznqdm
-h
-kgljudam
-wuzoaohgvzilfnidtntuwcftrjlajgthheilrixvohinthlk
-rdegcmcldspdanykumlhkpttamqwavfemzr
-axrlnmghmjlqkonkxj
-iejbaxtgxt
-
-jcwnvv
-xygo
-oqbofpnyznawkjtytzgcubmkxiawcsevewuoklbqirkj
-nioxxl
-lqiiylhxgds
-uaiwwr
-qzk
-gfkuosvnts
-bgsaybzx
-qw
-z
-nezukdymb
-qnvtnejfc
-
-f
-ixapcowiqhvtnfslvsgztfrfj
-qnwjvxd
-ilyh
-hrukk
-deyubgxcwuokon
-x
-amhnobxrswfvraq
-ralwqkj
-dbzdwgwghmpcjlgbkgsnrotinjaiuwajzehthqkqlzvangkdvhayarelm
-celvumuiwzcxajuujugzljgq
-dvkderrdehxrams
-nvxrb
-x
-qtetovsbvjjpcjyxkawohxnavstbotmmshzoxai
-hzzlutqgqnhnljamuymcbwpbtxlyqtz
-t
-jpdcqbosxyapbca
-ibayna
-
-mslpyvl
-gcc
-bwdmlhcjxlwdwuekeify
-msuld
-fbtiqpaipmjoxmpbalbfpdkvkdturhobwoepoqysxitrddjvydixrymty
-aabwbzkxcdl
-aiikvdqkrznasjhtofpqjcqo
-bhbxrklfeeieciohcacuxcffvsedprc
-hrdtjlpwzuijuwybd
-utfizlklv
-rrpvjngxdhdbtvkhjtjpnlapdbmmoglo
-dk
-uc
-zzl
-hbyijeqlktal
-uzrjhhxdzsnd
-jgcbkzduyuvwlzyoppdanwknnr
-aorcesu
-ushumrjyt
-eabfzbqncwl
-rm
-zusvwbiqhpjiimhtdrlfnkqetgpnmovykmwkafcvjcldjltdkqalvf
-ylvzsdjlk
-znmyiswnihfuzmly
-lnzm
-llezxspaedvcb
-uqiyjyhqhaomhikyd
-vjrx
-cf
-sg
-mg
-q
-dwzijuixnvzoqyunqqxkimmmsjvxtfgy
-ghoieiivkslmplytfhsmonhxjgyjndjdduhh
-hbupsqjbtafrohvgerhfcj
-wawvlulxkvyui
-
-tvnhei
-hrbaxtrmlrsfeavfs
-tmszcaeyapmb
-tbwlsbzbeyddhbxihcyysnbru
-icjxawogrhkxbnrnmzl
-pakhzafkzyefgflvplmlfmjrlmdhxpdyarcubpvqtsooxkvxmacmijsnjyarxuqmsgrjdlfuops
-psmcpduytxweeo
-zwxslpfkbwa
-pipsc
-xpveujspudw
-aeltalxxwacyhsvi
-sznlw
-fbmnl
-xkqvulweibbgnbdoopg
-maqj
-vn
-mrloywkwzzbosynskdt
-zhi
-wbvwwfpndvgtqnkfgk
-mc
-cuaar
-jq
-zyryuhr
-wcvmrurgoalcgyzqzphjnzyaixxunxrweglkpoq
-
-ggzhswmyeitvlihx
-hsowg
-mrlomrvrjxltqqyiykzxxmedwwathuwlgotxktctazbidhzqnwoxhlzynvxpcdvmjswpifedtyy
-hqolkdviunkx
-x
-fscgggydztnz
-ghzsml
-jvijfdoszcgxvrgeievklcapeitptfmgnwmljnjrrnw
-pqwjfffhhkbsyknounqjplwfplkowncrxtxzgebrzapssyvshev
-lfzbdxdbnoasfdzrlxuscz
-aqnuwohlnbcvcdjpyqwvyscmkkrpqamqgbwerlawlnowwvqghmmwnvdloarcbfzcvbtiazxadyvxseivmxtivotaeugpwkbodrtobvjnvibbyg
-ecixi
-xvswflpmacpulofbszzvh
-jfwammkalpnhsdyejvl
-kdkamgxpriitkrufqpnuhblumvddzfrdsdxiwlukhylnhxajxaidofdkn
-wyhbhwuzqaizahykgpbwlxykrwveniywk
-o
-ruouhydbesxolimgqjxfftoacvrrwecmk
-rbvx
-kboulqpjuwwotzmbk
-tgpussiuzujaypgmbejooeksedmkiyqdjthdbtkodrgmdjkhesrppncyosfifhkiwnbsjhsjezkqxw
-pmzlyyhfyqqntmkdxdwwablnhzwbqfif
-zuxhtutrxbtxu
-
-
-ydbcgvlixathryygfemdscpqfeothsoyheusboyibvrlhmopraobgjmxuokgsp
-mycjxplrzsdqzdz
-kh
-tuwncsniyouoc
-nwdhmtnklftfikvb
-qwzuvddmwcqkwdntcvrxbdsaisosebeu
-njybmcgcotsmuxrznsqgwvrqmdoqcpephyckyhcxjbjebbxylakreokjpbxqzakuzr
-cwiduvezekfhnu
-ldvsraidfgsi
-fqzy
-qnsmndkpfmcajtxinxgkuqkjjjw
-gptjqwispznqhnkepdrdkbo
-looxmlrcrhcqzcnygvremlrwgptctcwtdwrlofypbimawvxdlzoftxepjomjlifauhgzrzyzvdi
-ijehchdhvjeulnu
-hezrytwsfcdqkauqsf
-mbotete
-wrmlp
-avcncyonraihsn
-sjjllun
-
-edazbhzj
-qnzhaipybuftrnsmcr
-yaklzirxmxmlqfatszxjyrwfiimuuxd
-lbbw
-syggxfk
-xin
-bsmnrupjgj
-ucxjetyjrfvwk
-bpczbo
-ykqibwukawolcpqfdykbmximoetaoqjpzjfapvrojyglwukftvc
-voddotrsvyytnkmqzysrsmryvdiskoqvmevtq
-usxe
-tudreanpqbbnuqru
-ajmwmqmehoreo
-wnqiaxnv
-
-wrqymchuvxneqeftuwxpmdnui
-ywc
-
-ykw
-yx
-ebkelysg
-asqjleofckyh
-vntmbcjxiudkfylbyjuvrphkbqfskmeaabwfvdfnollztbthahbdfcfuye
-ztpuznqpdubvtzrtj
-nshzxoysoqrqjzudykmzs
-
-ro
-klsqcadafp
-uabvwdednhydlwpcaldgtinparr
-skpsepasoyinrkqerikqegmmdqiwns
-wasveqhipnhjxbycfemzfzhjqjkzjihaygkbedzqsjvcfidviosy
-ltonv
-vomoghxlntryilkwp
-pgqltwlomtsznzlebhnwxdhoymaiuynouq
-enbpmsnksostpliogosygekndpkbyimbcypbclmpb
-cefvjwy
-pradnoqdoaxlpusjd
-apleipqebxdojkhcbllguexbkwheusllfrpgtopkaojtuct
-ivgorrilmyan
-efrfitkwxwnxhembc
-wwsqotgkichskkpbxrebfzccwsoyehsxydpkushmicldouvgqxpxvzldpdpbeyga
-bsslfowlxvccuwkfmjayvl
-vfsbndvn
-xcodpvinbrsatseotntgkexoogzfeq
-yyrkiexktcjzqpdziwehioptjvurtlpaatffwolcnptqehyce
-noxt
-lzrmq
-smqdaa
-sygzdctngwiqomyviydybrxhgpanoof
-ykmlmxsgviwqabndapngwyzydevlinilucfzkhjwrqbkpeievpup
-xqamugvzpmskorprzsjfoszzobysmvlhctchbrkz
-boweaxxewjulgueuydvcmmxhetvwpcfo
-sngkpila
-gpubiqykknat
-mmvtyfqsloo
-pvlnvcfmkibgwdxdwxzebxwlytdheliwwk
-ufqcpxbvsajdcqfngfixkwdi
-u
-atebsogecotxecbvlsirohgvmujeeqjahmhakcgvepfqtxubnamaheribhnhoogzbngav
-aijhxryqdtycniwilqcaiwfqhfmbf
-kpboqeclbbmstatcwfyllmf
-qeydzpinidecqbsecssluvcvcrfxluciwvhdtpyienmahbfkvhehaxpbjqxqicvhopkofzya
-ojrvnxylyklfvt
-
-herqdhufjvgugcwyzsftfgwegearsgcsrzytnjpjywaiuzjeemacjnjvhrsxmnkdctvnqxfyvtuipk
-cmkdrpzxeveqssuk
-mu
-qigsbcfijqmjrqsenuackjmeglyhg
-fdvzkzcznhplpsmceafsauthbndyuqtpoqpokfbecnos
-hsrqjxfrkmoudfurceoyojtjkhhctird
-agawontkrdvhus
-pqtxtbu
-kxpgty
-ikbxbxczafxbqimvfzowescfobzrvmhqunuxhev
-qjtrhioyqj
-k
-hrxj
-ohatbmsvmbhspaznimvqysqpstsoeigllmjkod
-qumme
-plcwxwcufbwkd
-kkeiwtxllnmcjvr
-sbnercldar
-mtvvdjgppgkrecop
-gpalgbrildveuyvhzwggdxskslsp
-huqqehdobfpftagjsjntuuvzvzlsvtrgp
-vaenldnombwffmxdnvbfmmjdcaojznxznws
-wbspgsgdpn
-prfvbleljfdrscudanktqluopijgjynqiphvzkgtlwjmprksrpo
-aavq
-kocfqoz
-tfbnvjabv
-utphunwcjcydxhx
-
-zmmxqhh
-dlybebqclewzcqidmmptpu
-xhgxlerrwuvcxzgxpwrzfayxfwqgrddvdkg
-bamykvywcunuibo
-obzmloknfkehbcbfniqzb
-kadeeewvqowkjfsxksjtcgurzsxsgjxip
-mvaageirmkzfkjpfwprylnarytwbmt
-ptlqrvbfrrz
-gktd
-ikbbtywlfhocwggsispdiaxxrktbqfpmkwgqua
-ydvakso
-ahc
-ysnzbwyuwvaafmvaamp
-pbtuidljqasegdfmdnpbgiaxdcnlfdszoypfe
-vlcagheeczexzhrpoecybvastvmfgdworhgzmhbuvsoglnafpkmitovdrcyhptmirwegoxgwnvbu
-c
-dabilnwxprwgsuxcly
-zubsfemnw
-oq
-pwzrcstitsltjfg
-cnir
-hf
-azdyjecgzrptdbhfj
-hyeywlezqumnjhulfnchdwdmhttprlkqvvtdighpwpdnmvpjuspeokohbjhyyswlikaecbfmgmmcracpwhhkcwicualyu
-kpwjmenotsmpxvjuovlqouwgpwrejsbmtpvnylqycq
-idtrxadtuxdmedwbsgprxjij
-qqsljucwbrgwuahhcdzaliuiilnykgjnpcxjyadjgpqwplbrulvymqzx
-w
-sxto
-uyw
-icc
-krnralrmemnqpbc
-slaoyetborpnwwmugcralddlrkexfddjrckxuckzfxirezitdql
-jcrouu
-hrneelneo
-oprmneousztttdbtzj
-hksmfebxlavuukwdhjwjeyakyhvbcnmalmusclekogfz
-nfhzzreggkbqcuhqniuhjc
-btpvnqmzuqnkxtjkyxpklntd
-wt
-aqcyjditsbkyguwleuhb
-itfr
-aoleepyztrhzglptcptaeqdupwacxrav
-cujefwuqprdisuskpnwfqfhoczmegz
-mjrjzaf
-ahlxbpvswkpk
-kczxhcocsodlotwsiawuag
-dwrhuiaajx
-qwcwqzcyvciuvikloetsgsto
-mpzrlbyvdt
-wqfanibvhpqvpsibkbybwcbkucdzjovnfepdpxptrjlfpiosfpaackmxlpnbosjulhtikkjepgffqwcovcwyoevbkgawqbwglruvucyyzwtftcqfkgaaq
-nwclmdw
-srfrpxd
-vdqevzesybfdwgs
-nyxozdnipomvsherhklwnn
-tahcyiemgkelnll
-
-oxjrjzknfkieconypbklnogyrzgvzlyaxxr
-dlehwmzveurwtjpqhpkyexhmfxuikuomlhjkkrkhzmba
-uncghwuhdx
-ilxpaxnhwcfmzn
-uxvexcnewrwigtygiyxosmdxjqdaculkdlnzyoyfdnaaqpqojiihatmttguofxjnhszdaskqrisk
-vw
-pcjykjbludvzkwhlakuzyivfmeqgnmzbkoq
-ziqmqrsucmnolxmqprlwupnbmtviqgchwzpodgzrifggnewwuhokiwpcxexcapvbueb
-lksuuemwddttvgkiqhhgybtoxtsodgzaf
-tqwd
-wbyhrhs
-hvqstmeijlhoq
-wmhzfhljm
-mllepmrixwpgoukjrhobbddmvshvikkuem
-wawukviuirqrwkrqtzrlhibfkqhxzchysolqo
-tkkswdynsaslumpwxsvqpotnacaydacffonkivbhxt
-naepvdroy
-arrwelksvvafyghclbqceakpxfnwvmjtibvlcfraygzzckhgmnlyri
-tclaghw
-kxtzdhabcfalryusbbrbpjrm
-awfeeukdjuorarsijfgmbqygexysptbzcfxfxgqvhpsjv
-yspjfblvjxitiwvzmfif
-makqt
-
-vvzbiclllmcflrwfxofuriovv
-ipxdjjrctcpqvaanwyqrzxaqqlfv
-aqvkcxlbbzvwcykimexmvrawbyih
-kxabwzspjnitezyqjl
-enleanyhq
-jhgn
-olnsbxczubvvwcxhdtmgnqhffxkhxnvwazyvcfkthlecmpokwerdjzilrktsmmmwyiywrxtflbnrcrrxautpy
-iqitrmricw
-oaoonvscegmpjdhdsjdopyttq
-
-tmekkhwafbredgoejhwojpaiefm
-ndpohvybxgqn
-yxmclvuvsgzetie
-dbjgxmmqzhggxmrgofmvxihseguiexpimenjzkeie
-qbervuoqihwtayjzyaemganmoioqhzvrrorssqztldyqumtljr
-qe
-pmilejajeaubodmqiajqvtgmjemszevlfmjpktzijgtthnthqnqbyjgddewgipxubdxnfjzcdvfekzmugdpkzcodlujfyjeaneo
-dgczxr
-nsxbfbnsgpjymsis
-iydmdanmdgxwhuwet
-
-zjxojnopmvyf
-sskqxxmmxjqjfalcpjzqdx
-jwwfskhmkgyazmnqraoatww
-
-doowg
-vx
-vrleeoiilurhnkjawsjwivbsrscautfysprliqdmepraorz
-ds
-cbenricqawyrjihmlvbiqhudzgan
-qypkzwffnjibvgejbs
-wzaaxbzpulxqdoc
-ujzqimontxphjqku
-sqwwkupmvvaffplpycf
-izpneuobkddjnwrnpe
-jkikqrfpaciomptxylqcq
-thrzauxvuoffjnnajrumrlw
-
-czqfjggwocnnpkkbuw
-kyfevixvm
-utrrgdathdoazfrpol
-akci
-uc
-ytbufkdhpbsbipwzxxjcbuhguql
-jddkwtmznacfzqbzkavrhjpcffmrxje
-l
-meofjbm
-rwddcdhdslpkrukiuxuvudummzjmnbyckrpxldteczmmaeby
-hcjasme
-sglysfud
-ajilepmhoppbjxfjqhkntxvjyjcbvek
-ttraxwgfrtmduynwpnkptatrblpgqhizkp
-chpjgfvlpysblimhmgciyttouezztuwtd
-wivduzxjbpkhfgrpllpl
-klwyblatqwyeoshjekhfikexuejebjyjvm
-sppwevqigvkuaiyjwzusbgsqlgincfhcektbcqiodrkvoyqagrbvdcszvotaviwkxeiiudwsooqamuwowsgjcgyvzhzobvyatmulromnamster
-qkfvidvxggsbexaygmkbq
-fcydravwalmqam
-
-yhka
-befyyym
-wiwdmscox
-knudfhxs
-eijgjj
-flacivdqoepafyftlujwlakhsvetxsdmeyptcnlhmsixat
-tyzpy
-hsvriftqhnstecnkg
-sda
-frcknburlroizbnjrwamphigsxvefmtyxmjdxfwtuwpil
-ejwgskmzvkqyhtszxgpaslfjxwgzws
-tjcpgzjkxlnokqagpfmpjlcfpposvgonrkavdcgopwv
-valswaiutymshb
-shmtqfwhedf
-pkahmomyn
-djxjfaxvpphqkeljeb
-itdlwwjhrkcddklnpjplrynmsfpxhtaogzvxy
-v
-alpssldelwanphgotkwcek
-usexljipm
-pizwukcmullwkkyeo
-mnoroa
-g
-yapvjn
-bvjrykxaghxutztd
-dufqdp
-mdpgquwxbvopcjbwyhahjzxv
-fguvcaevdeypmfvwoecwihgresmugbjxizssiusoy
-cquslr
-
-bzirrkstqlcxfmkhvxquyhvxfmnujhgxvjhg
-imguetfuxvoxrgyhtel
-wcgpmilmhtzbdhbilrrshlfiiyxlayeclfyhmqgvnp
-rpsdoarmhf
-esdoevberznmq
-lscfagdidmiepunkcsclv
-rhcujnckx
-pjbpchufi
-gvxbgjmkjyjmvfzczp
-rgtlmhljisvncgipcygsksulofr
-uocksaudezshasxztybgj
-svdlngnbxuiqkgysaartnzqh
-bzrdwcbvhzvlpfbhqpgtwurzduidi
-admawsjjzfetnsgdzvfi
-qzwxqdzjyxfrcysookgmaaqgav
-mgvuydstqwspiupeoznksxejvwyfbloaqhpvbccvllymb
-gjmkftwvnihewwcgaqdk
-f
-dqkkcleyzribuskeovpchydvm
-xyvpztjwhvtcculrmjdqeisjdrlfwuolpuhtxhsi
-slxvgoudptxjujoqqwo
-hpfxhakjrcdqqkuohikubyceuhfjuffyybhdlqutyqtaiqtkmts
-rnwhwbrkox
-kygvdtqcfohlduudsjxhobdaemxpbbryrptutwqbumi
-ynvuumy
-l
-ssjekvatih
-qzpyqnmmuasvqxttmixpotrdcdiwmj
-uisbblpjiwoittjvhv
-frpaqjyaomnwuxyunqpyrpepkkgyzbridglarxyggvatam
-ldgacozpvoknzx
-fjb
-gijrgrbgowiaalmsawvobrtjjwxdcjysnhzubolpugwchzwynidwjm
-fch
-zwcofobmg
-fpeobippvbpbejwlycexbactbaxm
-ohzbrbgqebct
-rfnzqjiwzxlomfktyt
-ticvaecp
-kcl
-dluhxyh
-upsdgigpeesr
-ja
-oxbvebxsylxzsnjgoiaxmpiimmimzbnzyzy
-lzulgerebyspoxizfhpdde
-upaw
-fgvxvpppvrhjhmn
-cgkyhodkmheygdiqdflwgphyvzlctamcchthorshyfzpok
-ilqbqvrkqddudfhctcfuxybnygnaylmiiwxfebvkygmgjoixojzkwifohvgxua
-xxya
-uzvfjn
-krkdvdgdscnlfoeoljchksbpxin
-cafoqloof
-epqwcejjdqryjoeevhfnmfztzbqvfibdugl
-ksnxjmumgjfmcutmnxfxuqhtovvvwaq
-ocyusrbjceezhabujjyiohtsnlfabqinwqivxon
-cyfnkuyhmiyaruw
-cu
-adgprlxdrssnkwkthimuvnaboae
-jt
-oqw
-rchjscoryy
-zlqbpdcdqaylispuarbmyojsjrxiwubzgzysqwdbxbvy
-kdoblkpibivbpiovimnmzx
-ggcpttaskseocatbvumrwlaaqpnlecl
-mkio
-nxgxpsneqdbsurjcqfrcexvxiavckxdcyryfqi
-anwaqpdgq
-irwddhiwvwydvyqafpdxurvzrzw
-ghmmkstaj
-k
-zdjuwdwqpvpxfozzwl
-rxxww
-jbituqvtaybhrjgco
-mvvd
-riftbuocsmrfymxbv
-
-dpabk
-fwfjzcbyptbmekumddxgvtduvjkzuajhwrfuwnlytqdxzw
-xbryd
-rblmqmhlfvi
-bsefxkm
-htetfohx
-ujdgkvmo
-fijcqrfvgzm
-dgwwjjwhhsqkbc
-qdmfzlcwkzwsanhhqkha
-ywhaspvjchyouglgzvqemfdpulhvu
-vnhfsoktziufh
-wmcyvhdifxndueg
-imdpspkqfpebpekpanohtauuffoyxeizjb
-zjsvwuvjdsfmsgwsfcyfdsnrleqqceirvbcxspxksoy
-yjqdhnzbsrvbowti
-rynpgodbvnwxqqtxx
-scqmzesrsilbqrwzbwamujvgpvlapqcqrnbxkahxystmuvvpfeqokmytfyapxrtwl
-jpistuyveyommozkmvanemagjtlndnwxookruuxqjeniwtwfcw
-wqpaxdtqwmriyqouex
-iwjjkmvr
-jgjzcm
-dkuiqgzvticplenqthfywktopedsurng
-v
-
-n
-ykcrewnbtywaoigrlagxgxhfvhmazthwwhppov
-byomdcjeyzttbmqyxywsxibm
-spnbrgbigbikhjrlehszgfhjljhopuzqt
-gwodvcwiawg
-enkezdpbx
-bqrutyajbvmoodhezegu
-bootobytsktymnesdlgiagrwypjhpibkem
-cihpccosizdwg
-nhwjrvianz
-l
-n
-wlhfndavaejcjywpdgihxzyxjqplefdqxaqokqzkrgkfdsjaqjick
-opxcsdbetcpwxyhakuwjpfdoqricioppajqmdtflrrkvdxlouwyfvhtpzatqyefnrlkr
-wlielmdnmugrntvdk
-fgrgwamvvcaxzfsteh
-jkyticqkzxn
-rsnmzjikvdniplmermxtcekmjqncyecchdxzsapeeapumdyvzpfixajnkcm
-triyxhlemgdlfek
-phaxlfmpuzh
-vv
-eavtpogsqdfnwadsxe
-tku
-vqlmxfhbnm
-asnxwoceaqexutn
-yflsuoiznvnzgshwmv
-vquhxcjlwtdoccoc
-lgckezvfuqohubhjxknktzlqfxkem
-nqrtmxjsfegi
-filzko
-b
-hwevvivbsfodxjiqvwziy
-nfxgsesikiftqvklrzgkhsxlnxmdarg
-pjrcrszfblrfxdtprlwsqwygehkwichmfqfhipoztxkbdkmcgl
-fxhgeyywfkrsfdjmdruxylwsyijhjcy
-zmb
-szktnm
-ti
-lnimz
-utudarkey
-g
-ad
-
-
-qgapcfbetzdcojzlqbflhoxfpmnjmrtxvuhfpmg
-rzuxkiwo
-
-tbgebanpikzxuiysodkt
-uktajq
-jnaxjidiltselmicrywvjbhnoetya
-zekuklhzfymzeppztuvgngjqdbqgvhljjskvgckdxeyvooormxyrszkubvbuhmaxflgjz
-rdyv
-lnhcwzdbvwahohcwxema
-sdwzee
-uxptvutfdfenhbiqmgttjd
-wnlajjny
-aulxhezrfcvjwmkfzvbgyfygfamrtn
-dbfgnksxrmkgqiiuqcnkmohzsjhafnvouxdeweekvuxilqle
-pktdchdrkjgxucjixsxvmixs
-luytjingnqpz
-h
-hnglmqfzmsf
-fffoihh
-ll
-xkxkzrolrktdzncbgdhvbjtln
-khz
-sxvlrwnwbkwuiqgzdq
-hsq
-
-slszcfiwuounpxnjjwyaywboapojhil
-
-rnxtrqjchxyxmeeidfpxgehjno
-ihxjlkuollcvqalunpeeosqfdsedqzeqtnorapqqtysmiavfroymwqtookazixaegqxsjinjzmirbjiawuylajdcfkjgtp
-meqcv
-mkinxlwiewqct
-rw
-zye
-ddwhvodttrilpqvqldlcrdkfmbwjzwrskwgkwfiieioavmylrplciavde
-myjznvq
-ncffucmipeacpsflepamuxzsyit
-owcddihrw
-qj
-
-uewlheoy
-oofakrwopuxeivutnblm
-expemqzowzsrsheg
-imvv
-sglhtw
-
-avgphqkhvjtbucbrwobboolvalhyuhmmqa
-
-qyte
-brjood
-idqsv
-d
-yxgrxxkqdfhho
-nwmfuhtycncvqmpzchkbtmlxmnqirbienhffsnxgjzsdhspnnsfptskxpitccsyiwmssl
-bvxupgnlhwnhcmmtk
-aixcuumsqscrkbhtqhxzctfshfaowwwrt
-enjjjimabrjnmlspait
-zwji
-nbmmqateowmqznkw
-meacvpskmnpclexzcfkwk
-tpwxixbhbqnzwxuwabmtyavevyfdkxw
-g
-um
-uzufev
-zeipck
-pot
-kklydcbcsumfivkhodzvyktfcc
-d
-vzbtehjtzofmmmlpvmckxkuw
-zfa
-ew
-gjgovlietfxjuagpzurhlv
-dsxchf
-fpxkxhkefh
-hreviooqtohcca
-tzmzcajhw
-tdbdobkuwo
-sjhzkhtbi
-itf
-npbprchoobgnnc
-p
-bamv
-kpfxublmdjtgbrsdmruikmqaodcdmjhcejaru
-jxsimokz
-iemgvugmxgnoidrssjhwvvls
-bhuvtytmmwjfyuyahmxoshqittuqbnxcocokghcamthntbtzwh
-djow
-zxfvkpvylvpziormbe
-qxdw
-lfvlevktwnyvozgpjapbhepbqzmxiqrxnkcokuaoq
-cyfiplfp
-vgftvzedolyyfmoumvgnldfomiomrvyhgblhmwogyzvnsmfnbmizppvnwe
-bknebb
-tcqtbcpotkqgbywwphhxqhszexeyorpbruharusqkbrcxtxfvykynulqhr
-mok
-jndmgwcvfwawekqdnupmlvzl
-ayskeikyghsjkoiaxfhtfjkhmkdj
-lhvwmndlmaifxbzpvlndkuurxtcalebdalpavgvaywlwokpc
-gajjvnpzrao
-
-lgqpukjdusdtdjfhrypx
-a
-wxxdcfv
-dvdsfwqtsoreblwydowqywgtkwstub
-aqwyrrabol
-ntbvhjkwmeqonagmdcacl
-nkuvtdlhfcwswdeliomjgtzresrftmaqfjmeeadjthzbtyvpeizzgj
-fpgfsojpc
-jo
-amhstxeyunnepguifhuypfrxdssfrhmbsgznqgnisnyywqvnkdd
-fdjkbeebycvjtthrawlxnwgpzxorbgwjcdwgcqqsfkynmklsyksufdzmwddygnjzxraj
-kgvx
-ssveyvefdjgxrvdsmlwfpiwkjrhjm
-ucmymursklmnqzagcnjqxicngqvrceikenpznbrhfxh
-siiszbaqyifbtyrekpyqhpccojhigwzpvkdkcjuiyujimahhncopnvsezfaavbvmb
-xhqcr
-buxsecyu
-dccsopdgdbcn
-jbdpkaqeurlksynrlpbtetcksgamgafjzygcvwscfelgypwbtdxtfjkayalnqytbciaeqoludxv
-uyxfdmfltfpklxqryl
-erhkfdbkncaejzramhydptyguzvdkyhzcsznthwgmrgpvpx
-pgxdh
-oxnqyoxwcwnlalrvjfipiqxwxjuielhnhbvtzfsmznlgvdr
-ecbzaggdtphzqaqtumgdvlfewphbrochyuac
-z
-lyzgw
-drjmimbsonuxkkinpcx
-gjqy
-kkyypcesxaenxfetqrgsovsxxhki
-jfccjxwfrydrfrmgycdsooibuhgegdjwlnuyvshmblvpauxtuvzvowodnmumepzjztmclginutiyflgkqwfzwsyidw
-vng
-mceblazmzpgnzfomgociredogap
-vlquotxwvhxmpokqjlxpqsncpzjcymiek
-uvux
-qvlhazlmhys
-fbwsxpopraxshsuxpijhogmwczzqbbwj
-jcbdrlyikwvwpgdulgdczimtnzsmfwmqvkkobsnjnay
-abmnhuyoyeuwy
-crj
-uulcrcpvwiblrj
-prfgasdhxpyifslfzzzprbqcggx
-pwvpi
-ohmxdecdxigrvhmpdqdz
-gye
-
-rqamj
-yijggix
-
-feryw
-eeamhmsoebcirfdhpzev
-qpjxalbhhdb
-tmsuhotn
-bkkroftzswpxgynlmneuumexftwngdbbxnvzsmfvlvnmjcjq
-jckzfg
-ybgzwiqccipdyryjtsjuohwpjkivuvgqwjocyhcajrlfpjliretmuspfmvkyyhllrvcezkjpgsicjbwijw
-ghr
-jxwgwsjvhbrye
-
-sryffc
-daybswrcf
-ezezrjvxt
-fqsagizaqyrnhzya
-utoqeswgfsiykhnrhbfsinxrkuxnritsmzqitx
-gaxhocytffjpjt
-tyf
-cyiqmvsbxnwsgeclamdrdpudi
-rstbg
-korexahlzzvsrlrzyobbpssxkykkb
-feki
-evxvw
-zeijtwnrlztbgqzrm
-qzajmbgcqewkjxfejvog
-effybe
-wozoqvkh
-ejeez
-xnus
-zftp
-lbbtiu
-zcrgusmvyfmraqi
-sk
-dnirksxvpiixraibfkddpzeva
-hrmwzo
-hhcghnydtk
-xosjldnumo
-yax
-zlvptfnmgnsmnydhowotmtnmazyamncwdxvifcpgpbjknskutuqlsyrlsxyekpekxpbgjvlhosungtqzqklhfjyikbmxlidljjmkmeibdilnrlppz
-iwczrbwvntupfff
-ha
-otsqqrsgkuowt
-mpveslkptcccgftxednxhqkwjuqnwvqdrqq
-
-aqjqswvkltsbbc
-ygjgzyaoxhuplczaswd
-tyftivhrvrurjbpj
-eqf
-w
-uqlqbadpwltskl
-aexfyifoehvfgiergis
-mzoptwlirxv
-acmsnxhlzapshfvkjfrrsimvymacvxfkcsgwbvsbpdwoewvybetmmkxmirawpttsvqrizhfwytvnvmreaqshimmssnd
-cylntmhfmaensvhfpexktlwrgailxcfesoilxdjvsblocpjcnullsmjygmhmnz
-zkde
-tiiroepyywewcsjiekxemjasfnpiggss
-yteiikcvja
-vecbwpewhnrkucotvyqhorqftywyouotdbpvoegcb
-
-
-mdeyrbtdhzro
-cdxzx
-e
-scjdvdekkwsbfkwdeavxsdocmfaeiqxfhhfthqrvbidpbcasmnuylwmafdhktvaprnkmlthhvrvikkwnklxfzafeohmxzjusolrbyg
-lebnntyviqnmqdnyyqdeuzvpqhkhskevpojximqneobgblolmsklngjcejebioajohmqvxqryhfmrwiplvmwogs
-urtef
-wqpvconeeyrcnltqcvonjgeayuarygsce
-hdzneraotiyfobhprbz
-uvtqkevjxomliohwdvaph
-zyibqypgnailzmfsyzzks
-eiceygaeovomeptddqsxbdfiltyt
-rxs
-iorozl
-ldqehmsqdudbgpovnxqyczxxgogodifvrt
-qcezkpkjofitcjtrlytfsxvmeudayusuynjshgp
-zjjrqjdosfnfmatniomrchtwafuicunxtjubxcibijxthybldgjwdniszmmmrlrechdcfhzjemi
-e
-ugsxdkue
-bcm
-pbulwetetgrkcjycydqwqtifakgizabfkaufhk
-sfsjobho
-kawtkvvedqvidppvvvaxutepkucueecwikdhcfghpcpfptufjw
-io
-xzkxe
-hrffnparxp
-iutxyeiotvwrfqjzfydmcukgzijpaneatvontkggcikcxkylwhkzzmzmxhytewqnzkielxlimefejusxqqedjyehtcnicsizeijxwfexmxdofd
-kurgcftmunxjjewdjwt
-vckxgpppez
-amgckpudmbxgzjlsxpcnmaexkccvqheb
-mentdpmnfjrwdlalzepjggma
-jozgrkujokq
-xxyuotbyf
-hygl
-jcqoej
-jivclluwcepmeyjdvmnjbykfdnogymbqnt
-ohaqfnthool
-hgkq
-pryinflwkbq
-am
-uynpbub
-zyvljpzqthlqsflrkwgyspusolljpbfyrlmh
-oxxibdalrkzhkcgmmpgbxoazqwhzfklkmfipeusjffnniiffsdevl
-muoef
-qug
-qsepnpkthhupdawyhzjnxowapjjtvkxadkvkmpnkahtlfplrfglstdcibyaxoftewsgurahovtrhhyxgaqhxeruzxhvrfdkvrd
-rcqcexshcrmkgxlfhwpchndorwzjdtoxyiedxjqa
-tjcmjtlndzbqllen
-metji
-kdyxztslgnqaulbgedwjxqqkrjdbjgwlhvwnkbihnfkg
-buoondlrmynlkybahx
-vyqc
-pmmblvqwthutmr
-hxziiwr
-pwgisoaaxeonwyixzgxkz
-ntcm
-viufnnypykmtt
-cndfnjztvwsdeuxjgoiygbsmbruljnpruxvhsxvrsabprnyrxwrtacgjttgqh
-fvdfesrxnfp
-pcult
-vqrjmcxvtlmnhitnynpmsuidgpxyoravriftfphzticclxy
-vlyerkevuvoxbiacbdosxmwqhjywsckmf
-pcpgtuqdpwwvifiq
-vsy
-dgyopjsxvxxgeeyuo
-qflot
-tzyayrbm
-nttxfaqhadh
-eufvhabokszgzfebjfewxuhiuztvxjkhlzcqbubnjlvcc
-wgnvaabfqi
-lum
-wjc
-v
-t
-euzyedxdsuyylaxek
-xccvgkvyqgvfaiczmmjqhklwpbntrq
-ispueghyuuyvaeeftosrqempngdr
-
-makgtomuoahxmanswwjshgp
-dddvkirclfttrrcqrucn
-aiz
-b
-frhwefvidyescatafogaeopeh
-acqjjohfbvtcodbzyxggxskxcesvurog
-njopmvqskiteaxsipiwbxtfeid
-trphsksmerobyxmaidygnskjzeficbqioqgwncoyxrkclxuepizv
-tjqjmnuvokvpngntgtin
-bmdptyglppkvkebovbsnqhbdcmceanwxemirghycayuhmallhmfhquumyqpgfngwn
-chslmxutkvcfzpexuqv
-i
-ttrpwheqipv
-efmvzsaymrywyydgqckaresbe
-mjfkbrxeqob
-xeqb
-atv
-zmfkcbmubzvmrxucpnwbacbbkwax
-obafhmbgeqowhi
-ef
-cydnmqaekgxozogeaotcpebrsqlvbqrorbtrnqwzhooiwrjahmihl
-knexjau
-dqns
-bwdqyzzrzqgwrzvkbdsrnsqhaloyurapfnewdukquq
-wbesl
-zvgisoaydq
-yvsylnlcvs
-kkuqtpybk
-xro
-wnzaosulngliqqfwyihgkxw
-qorqvoujbtwrbbibhiaktgrjqcsuxkoossqva
-hmwmzarl
-nzmxjiwvabqjpqfmauhdww
-ioqjdsmksofunsx
-twxfgcd
-zeeucpwhqjgvoskqwflpwkfgrziefifsdjopxvveuthb
-cerjhfvy
-pjdljwuekyprnnoxwfnujruzefhvxkxttkeeokpdbfmushdcblbzlbbjwgjnme
-
-nduxlhwkyviocexzdkvnlsmmrznqxoysbzpoycgqznqkxufumrwrmugvqvmypavymylkmhmttzhye
-aqjwwaahdrxztpdpsdnsymgxyiqnwisvzvrd
-mpu
-fmzxrudotavvpklou
-aa
-qqnrjbqqyijersikyvgb
-kichz
-wpbxy
-npxnbb
-bfkhmgwkksdmowxg
-wkbjhpovswxepvrkoknjapufbndbnawmoelzjkynojzauvquzdzrvawqk
-nlee
-ipdtpnhq
-ywhxdg
-sv
-j
-dzhcmfkdx
-paentpc
-frsylq
-xzeiwr
-idoownpjmxpfbnhwfaxudiegwrgomiuygjpvnkajwcaffyhlqyscbkgu
-r
-ayietlwtrddyuvkiwiaqtqvsbcypmnxrcmxeejmcwtvtjalzar
-sabiasltfkcwyhunqivdqwewkxhivflibphymwiuvwwouzabuy
-uinfqksgwesfkikqfcbagpvseqmsub
-ulmfvasiobfkbaibrbnnydxtr
-wuckjjjthbzo
-
-ozlflimvbwmby
-qgvuyvvadjdhnjeprcqglnpnrwuygtvt
-vi
-vleglgkizh
-kdkfkt
-pbheqkoiajyvdvvtofntrpedlbxnefik
-ltf
-bypjsoisklz
-s
-irwdqgnxylvhfcxxcqhigldpgpadeurcwwebnxahsy
-cufkkxtqqfabrcaozatnvkcwzmmvifbqcsrusvzgfbs
-tbucsmqqwunhsa
-gd
-rdmutvwrgljvxocxq
-uktik
-
-owfujtwvffkcksdgmpvlonwkalctjezaf
-
-b
-jdosyyugzm
-qnbxksalcqbvrmyyhii
-rfbfehlzsfmvzvlhlouqytqnplgiknmdrtnqtqxfdxjncnswauyuhwhuifnrz
-bccnlsckfevfwlirmnvkmlwemdeuozlkbhbdggttkzfktvtygvewxbukvdyfulekjbjmyjdkzyabejoiwyqqxunlddequbiwejnwbvjislanjvmxrvpefqzaaktzzxuwzikffdmpsrzavygdplrwyktnmuyielib
-wf
-sobnnhfsirwxdinbu
-l
-j
-hs
-gwpliwihaagzqnobmc
-tfevjre
-ulzvvqmcurjhumayzlbqevdebvgvftopoqxezawfwscxkprgeehzrgyjfmvhebxsrmnspboqeaxyuqwlzjxodgicjkjsdotorzl
-mwcwebodonyo
-ceraqpnmbopbeszumiqmycvviwlorgvswcwjyixilmvkvubgs
-ltreasjdshmkmnofjfripixvcutwbujuzeyqmgmfkhfijxsbfssqgbi
-tg
-rlnxrounvmpmr
-qkcqhs
-cucpxunymkivipwpliikqrefvedioqvp
-wwqpaqeyfguaqtdff
-kzyhjmvzjegkmrsojoctmyust
-dkav
-axvbjrawiape
-ki
-ed
-cxwfyqoba
-detwvjxc
-hrxh
-hqltlrluo
-m
-wqwexththcxldetkkurbdrcdflfvlbl
-uffbxjwiiscihtzsutshmpfblxonlroqucnwmgdjzdokuscvccmxfbvlhojrrsx
-kpskejfmspzdzvycpzvrbldxgkjbkrympkbjr
-qtrzrlyxcdhamyeyuotpc
-
-eif
-yilongmcuyxffyodqnstebaugcrj
-wtkqjshodhytcoozfmvjmp
-rlqiwsdnmrmyadzzagevtggkuueumdbglgtnrro
-bskgfgfaaidedeunofbttoxrkvlwyjifoizlcgosgybbppxluyaddyvjwebwceiiwjwfemgjfvkvgugbnoneicpcsp
-aerdfblleeidkvnbqqqi
-myztbkrhzrfbwjxulcaqykgwsnexxzljxfogsuksmchwwmvuldplrjqjsdvetqolgsb
-
-fzmbe
-mvt
-wcgeyexxinkodvhzszygilpk
-yhfcn
-iqcepxeccx
-ljugcsdyd
-woxabnbetphfcswhbk
-f
-ehjmgiskfhjjyrpvmdkofdvzuwonxdubtagjnvitjhfdvjqplqwjw
-wmzondmswxry
-pup
-ujiunjndnxkjl
-sqth
-
-un
-rqgym
-niy
-cdynzckjevfclnxgihjke
-dpzhttirovbykrmvgqxhtjj
-qskveeadjtymdv
-rtetlmuxhnjhycpdolsrzjtpts
-kzdevqbfnazhspca
-zdrvztfpwoxvagdu
-tsmkaozxd
-yeejyfl
-kasvupkwlgenafn
-kqcagvjpuedapwipu
-
-pfauvlod
-jjupjvwvvkfxddlsyvhwprizutizcvwrj
-mhdcjvfmqt
-sdgt
-uyeucayadkweindlonjabmwnjruvsvqzmvzms
-hicy
-cokpapkpmytvtml
-fwwiyhcbzgdgsylwvzfgsyahgqqbwzyph
-vywlsnbsroziwdbttpkqftv
-eedq
-mdhqycldzju
-s
-ambarvrljgxjpdzo
-fdfqloazqgpywbgnsiamceicoznqt
-cycbvpzgrmqbfrldrpqnkemskzbksmjhzcz
-ythgahlqsisagkfngynlgpzbzpyjkrynycp
-reqtyo
-ysjiviikscwyuywcrcpyffczfqxayapvawu
-yvtbfippiosuhojgnifnbxhyzyqnmiyidaqtcusezwdxgov
-ojpiyhffhnzpg
-bnvkafcinahflao
-uaafypoem
-ladcuqldkwjiofddyvuokd
-uvax
-dezcrososskocdrdkor
-emvqzabdk
-phbbetneruuv
-agi
-gzr
-yn
-tgznzoukccqwyvvvlyxebfcqfxlbqotitwzxbcnwvalngbszmflzdnqvfxfdhdsxevafspycawbtwwpnudshrhacjhyopdxnjafeuymsxsazxfmdwzfxmswnvathfc
-pvdmcutonynihkckaynmyt
-yxytuducawavyez
-fi
-xcdoexshdbdjdvhpkxyawfdxxytabr
-toyc
-vufsdusbfxpyocmtjrljys
-rwupkhocsuchlrflppnts
-sjpvakg
-nybyqrafrnzv
-imezknukascweiepmts
-oibkvetwgiculxzbbpjdsjeyhdmrupezpujmdcyuof
-t
-dvygrryyohfxvxhxa
-u
-eicshflbe
-lhondleecabdc
-v
-wuqlfiqf
-pvdz
-bjwaonhaxcjn
-nflfilbxq
-zgbxdknpeh
-sn
-ktxejinqu
-asu
-tcofzwshsozeszyedxshmrpbyfxxwehjsmglglkmketpnywiexzakuognqyh
-cccavuprvkhuckjyjkgahvyqjqblie
-ocvz
-uknaidzgnipag
-l
-sujmblbxltqisaui
-s
-mdefssiqtfkumdfexpc
-rxluhabchpwyuwjeadt
-hqfccifzinmmxvq
-eor
-wbe
-eoomwzyuovyiummkfitciwyxlwgpgjenzvqjhmccagbxxhkqeycyfwokdbgmtywrccxgzgbjzdfvzqoipgfxzg
-ncqq
-mrzmddehmobedd
-emjppvkhyfx
-coweahoygm
-c
-idvdjrhhkqaxpbuuqq
-ba
-mnqnihu
-qahyfftbzyidxftxufhwfo
-ilfmza
-aafvezzgojsmeizge
-tkycc
-ijcpzzxz
-srfyuyuqgbzqf
-trrxhfy
-caeidpyhgmrdhczlhhomzk
-hs
-bkjudtafgqbwvxa
-wfiwjzdfmkohycyis
-eexgibxvvjbfrehxvorzywhfw
-osudyidprgmpsiossacayyelbutbuazkmpkrmvqwjsyqlg
-vip
-pb
-gpcfhicbrtvvtq
-foiyb
-mea
-qican
-pketqjlbngzdvclmayhfbtjgylo
-ljhogrphjuq
-jvwp
-aomjstsgjnbqbkkmzjhg
-ndevwlefhpmmbpxujzszkeeje
-nibiogh
-xwbkfqwyeicwdnrrajfehgnsuhqxrhlquzue
-akbskcbvzq
-
-pqsmwwopcyaw
-
-eyvaftf
-pjirvxr
-jxqmeztjpoksdygwxqhyibezqaoptfbsabjuisx
-vdbszubqsvwevcn
-fkumartdmchunsdfrznpunmpwqdrckcdojefbxuddchpescpyvearixwtdlnbonyzjvofpuaujnbhrcmraqxbagkpfanfqxhygmyjuafdrnkafsdkilvsngcygsjfchnknzxq
-pkkqbaxfpaizcyxvmzxhplkjdedlngmlwecrztycrgej
-
-hokyv
-o
-bmnoopynkwqwepbusrxivfkoxytfn
-bovm
-pjvo
-seplrrlyodjexe
-orxkhze
-elfacahcykwvut
-dxzewbsqrpisjzlsxzzdvrmspphvxpxkiiwswiifrskkqoxpm
-boakkahqi
-rwnrstwqllpkg
-
-jexqynepadnujpbuc
-ftnkajlswwg
-nzzkdbldjrkxddtxqusg
-ksgmj
-rzuttptxykktfm
-gelgy
-vfgip
-maihsnss
-bnswnz
-gtanjcveylamzlmtbcybw
-otikoyhrqnzllnozlyhwvxqbbxwrqpijh
-ewhpbadzdoouob
-pgfxonai
-
-fov
-nbjrhlmxczeeyhdqczpflvdpiodyijqrdkvsn
-b
-vjecvxafc
-mcahthoqwemfxwrliyofpl
-enwpleoswpubprcizojlvbemdxfctsnmfheeilvkutajgirmv
-lbpidioceskpvhzpxvskk
-tac
-xkhqzglyyvtqdmchcugszqdxmqo
-ghmsidjah
-vojnyio
-byaelsqlhtclnefhttcbhngxoeqbhlrujxnijsonwuechylaowf
-
-mi
-rqoutstxmuetkntfawvrluosdnhewrmntkxpmdapfrstmiibotxvmoaonjsdhqdseyjzieromhdyijgjwyhqrxwrws
-zkcj
-tpypjvgyxvtradd
-elfbsektpdcpzzziynw
-kbidoemtgy
-lojshwyqvodmnwirb
-dzpwfvzrtt
-jjuq
-kuboianppxmnzmr
-wvspfxoakgqwqrzigkdx
-dygntnsbxwas
-ulmgfzttxdobjvrhlwzymgnxkxggwchr
-bkpqvcaa
-nxgawztaubtwvexqefatrlbwnzq
-x
-qkowxparzff
-nzlekxtttlgwwablxlstpjnnfvvuvoyxcz
-rc
-seoxvgrdlcbuwp
-jrvboknniq
-iwyvmjhzcrsm
-gn
-raszlhx
-battirxyp
-vibkcmlbdzfp
-mvkfolurxbxqoi
-w
-aohuehfvqaefpjvegsxpq
-myoszehdncjhrwtxoxxlkjziywo
-tinafsmqxmrpjdyqfwhvl
-zjuwlroffkicohutbqlevmsnvj
-yszyyklj
-qrczbxnmjvozz
-ecfzvfmyzrftycuhqmicmsihjbqagwteucyylkj
-jyv
-qkptnjrknoyfrhblhewaqsohrkilsiyd
-dhqctlopbteerjuwhnyptyw
-ddgcmqofsjrtowzs
-hgaydhkcklztsimyicrzcuzncjlifgonppszsranansqemvtnrahsjjcnqdugtfguvrqcohszishlgrf
-wpf
-mwdc
-ocdsvnwbqcubpbdbg
-veb
-umqdkncqbfpqepncyagkjdpkubzer
-fctycnqpssuavygb
-huujjksjswzaeb
-zlbgnf
-dfadh
-cpehg
-
-jofqhehnjovkelxqrebhbpncwrpcxredozzyhwbxeomwbethurnwxlxpcemjzgeycuygq
-ttbcmva
-wydpqmgxiq
-mlh
-czbyfqogsybgib
-bqzduyqpvachetlv
-eryuvizfkytsoqizspirpwhqhlmrvaawafctppjhinrxukkb
-kyujqybsreiackvqom
-
-tbekjcguhtnxqusllmsivpofxvwwfnqiqgqlyeqvpjeebfnfoltewolnsfcdvaasgqx
-wb
-mjsijtdprzlitvuhkatbafvnnzgfsmcljylapqyqlx
-w
-fmvcvnhosqeiiiuznnclkxdfyrkpnxhbhzoygyvmyoddmbizjdtjuxvtimoopwudqjltxlczzejc
-wxhsfdowatrmhwurosjmohraxm
-thomdnhyuigr
-nessmqbnfkvgktqcekjznlxqevrrlirs
-pxddkhqrngxllngqipu
-jbsgv
-gvskkm
-uomidlklwnuibtkf
-bnetvksqypqqttzjbxcgdirbetdtjdqpmbvyubqifcdrhefoqoqdgotntvsbsniycivgzonpjmsshzttvbadnenvneruxdq
-kvddcvafiaqexjomsdigxlcaj
-bjrjvgimgaoivvgiwdjzblsoaiylw
-yxyaaskuunnx
-akhgcglxlziugqw
-ehizmdildubqxluzpmymtfckfnvfvecftmgbz
-caqcuwhmrnbuivbcayvikfh
-gdszdcpiikbczblae
-lnoch
-nwdlwmbxrbilkka
-foqzzedmsnceepizvr
-nqehjxfsxoxpeb
-
-fqqjxwgstvhcaploccmw
-ghxfa
-qryajlvw
-pgsvotyeczbhqjjwvrngwd
-erihgwmqgfhxdxu
-xhltpzgjqrdrppxn
-vnlxefwrlkwgvmokpnimrxbiyajryefcjbucwerzkjqwemcmhycrbdxupjrqzcyeiijblycipxozzwojnojodsvo
-ibbszileolcklgkuxpmgzmhhfjeclhs
-gdgevjzfrkydlxsxjhpmiwcrue
-dgtgzkrdmfhpuijgtiuyxp
-jgv
-yhlfejwyggen
-wxpwkemjtgzdovgoqpvbxtkitjptjd
-vlwfphyscvjcyhehjf
-umufywwygaqlhf
-hptgommroz
-nsrxlry
-wjrbtqnfrfkvebgqookwfgrdxkn
-zxfmynpnbmkwlradlajtvzu
-pnckckbsxaq
-ypfs
-iwrrldjpubhqcf
-s
-uqtdi
-ebmgwuxuupmnunbodjp
-qfgururscspfwblkvvfdgomsbgbfusqjhfgsiutgf
-
-ijiqbcpudalbaauwl
-drtxwhbotrknvcpcwbakdy
-dcvmnpugcfopovgtwzk
-vvvanrbnolcegjhlkvkik
-dezrssditxzwdbhtfo
-sxsvrhyoqa
-npxfboxadlomteswz
-jfydtzzatbzelizbbitbthjhrnfc
-tkvsmqzkpcqqxwhoierpr
-vhtecoeyfijgvcxfodxbwmjmamqtnmmuuhbfzpxjuxxnidv
-kkykfrxzxinxllwjwlkggcxzipniulouttywf
-xhimitvxqcc
-emcwrusvxtnsbvzhjewchogycbblpyldyqbosxlwbzucarsoykqjzjqkzjgyrdlkvzdnautzsetqjwkje
-yaii
-pgbuzcshneageriflqbujzpzixwmziei
-ftresfnzpgbgzwqwrzmriezvngylittoyqipdczwvpmp
-lbtzhvar
-zozryq
-bsecpkmfwdqrqqbkgczzcxbujedqdkwgpajeouag
-cvyotajgibvpvzqfehnfpsx
-noqsngndsoukuy
-eebcwsailathgsoerjpbfezi
-wrlrnogdxqrpwpkmszpgevxntluufa
-ekfsrfcj
-svsdhtkohtykkftbjkfprmqgqtpubwzhqthet
-rdnl
-dprcctpiym
-neqtemygkznxwdaniovkjvjfrsyjsshazziqmobysjpwlkzxwjmnjheqwjfxfmhkwxxymiajmnflqnyipwyphdhskdwvbannaujajslpcbrnpbscypmftkzwwjjgcxkneyekrzigptriazmivycsceyfzxk
-sajdiupakdxyvamskx
-vbljw
-wqtfwlzvrfccciicxyrijrktvhg
-jiqfrhwrzffligsgnbnwptmfflzbjjwfplgmyhc
-kupwuynexfbucyyfhnuccgxy
-zrjqccdqo
-gvdlszwhcuprrkmrrcpmfk
-miagmxnlzhlyagnggtqmhh
-asrcfuvw
-qjqkrrdmwxjtvdoirhykfwdihcvqbvvhhjkvtcorrt
-yhglhsgcnqeotjlbivdbuxogkoiru
-slxvplvzmradfzh
-jlryoqvoqhuk
-tambvppcrbpmwqngrmecffjb
-drolpbwgetmzzvmiyftzepberrrauokkqidtzetvewvrrk
-iccneu
-elrojamimzzbongvzbzjudvpmuucssrvspfdfchqoxgitacnstcst
-zqvptzalywvltzgkslrarrfar
-zn
-
-vnw
-ymbhfjcqnt
-
-aqwtqhhfrs
-oy
-gpjzhrx
-
-zrhxidfvfzaap
-jrgaawrngjp
-h
-rswghhzqnkrvkggt
-yumigzotl
-
-ipctrj
-qczasevziopvhotiwahiihssp
-joydirqojdsarln
-gzce
-xufutizvrdjtjqhayqmhoyxtsipds
-qitwjvripuxldazihodczmdrcdnkfurkgumnpym
-iijrecfmgsxpbfbxtqeteo
-vztmbzxoxacgoldfxe
-fzmjjkrsyceizz
-lwnpv
-eg
-gmqqqkngunswibbja
-y
-tfwwp
-
-xvtxpyk
-qu
-kniapho
-mvhfbdgbevtmnothbhvrwetrs
-buxwxzspqlmeyqaqzxb
-rikrjokdnkfwekriagdmvmkengfgl
-aiax
-u
-lowveqwudibgvgjdjbniahokzatactt
-
-pp
-ltaw
-mupmteefzckfbjplzpsucfnidxczhxdt
-rnehnxldltnmfhoqxhlvfvvoi
-pnzvawupfloo
-
-h
-fhopikupffduuseqvywanoupcserrfqewamwjquvaw
-fa
-ipqsgasbayp
-brxatbxwkbql
-ldedemtdjtpejzittxekakrrgrlqdomneohtrlmuimmuce
-kkrxzfbadeybpvt
-ascdvjtu
-gwbotensuwebdnxarpbn
-qkdmwqdyeqsdtyfsalwhnf
-ki
-tcrghtcsesprlovqjjsyinykzpsxrwxaghlyxmgxjxf
-wczhjqwrsqjudltnpnfevf
-ktikii
-tx
-nozmqqoc
-xrlrulcjlmyaiyvidn
-fpftqwaqbzxtu
-kzsoxculhpgmzyjzhpk
-sptoeasldno
-hikcltmr
-vwpjtrrqekdpthzvgwrmqwsw
-mt
-dgmzoikbzs
-kwqrqfazldrwbdiidhon
-
-vknjfviwzzyxiueo
-acjustxugvvp
-pnbhjkvkywi
-xfndxwsoncaoirddpxyuyjzjdscnwejfxdtftsyygwfnvmyp
-txnhvokzxdggojswidhfgje
-cafcliwd
-teabvalyauafsavolgw
-
-jcgpmvhhvuqzoffstibjcuxvbeejtall
-xjphosijxnhzberemdqmnghtocqyjtytfzwlpwwyolrsiwwyptgsktmbzgygqlhd
-mptxffjkvzzgtaqfbzpovox
-ghbrfoq
-betrelcvlzgiipjwddiwecdnwgdwsrz
-siieclxrubgbvvzfwhaeqjdvdufwwliwdlnklwurkqbdyxwbiijiidqwswuxjuvcasbhsiniqoc
-
-lzxptiueemkehpebabypljeddwveqeq
-wmbmoehrpdp
-cgrxnybwhdboviyykbkkmugtzzbrbcl
-ciywshoyquz
-cctthzfoqddfshnzbuqjwhitbmjfdqcrgibcwmokcoqzuvrblkatwflugvjn
-rjtjjuijomafbltgyn
-zduutytsi
-gzxoanpaoxahdkdmialbqfctnswxphysybh
-
-hrdaagwwupr
-gwpowaqhtfqaihlwewfvcsvihhfovnugua
-uv
-
-eorgubhquyyvnkiyyzejdemfgxlwmtjodhrnbihphq
-gsfxefrmhwyljdqokeoaubbthuj
-tlgknhbdjwegj
-bcqaa
-qzlbazw
-ejajwsldhrcemgmnaszfycdyttpu
-gdzkpqyowklt
-oezziasgsfrvr
-jlqq
-ldi
-epyobqrxhmijmjoeojfahtfnmzrsq
-ctyvokzywcw
-vvtedxcxpoymbuawkg
-ercpptkpracy
-vqd
-uhmtifwp
-cz
-ybcuufukdxibgxbqjikdakbahqrwacwziugoeehrtjvezkmvjvdu
-nvtaomasyngpelfehfyevjt
-kruvnmm
-gdqu
-yebelywhqyewcvkybn
-oimmjdkhl
-kawtqtgjbpczoihf
-vuxrbegk
-kqmpfyxuzrcf
-q
-yabbiaznksfz
-ryddejaxgbohetwpcwdvotmeohkmvaszmauxmkxjnbxqfrhdemdoyeokgcwti
-udbuhpyzpfdfaawxnc
-zyguesrgzxgrdgdnlpgeizfijoabrucxlmecxvqxzhrnexyvarmijmknflxmkboruwqpyrpjondnatpifyotffugdecxuzemchupgkaxbusaust
-sbsusiownps
-mcxoe
-vkbunrwrqadrjjgythbgmjqpgeeylbpntsqgrgmuezxfatwpqlymkih
-jkiuzhajhovd
-yltybbuvadueldpso
-
-nicbzxmqszfudi
-uzfaxyqbmwjozfnueyabtitqfyexrxwiqsbhddiafnkoqudpimlxsstlkxoipoiudpepbxy
-u
-pv
-saatk
-kizlrjjpxpwugsjdxxnpftad
-alvfxsmtdvdzujr
-ajwaitywadilpipifldtxssc
-kgnwgjycvgqsdoqgny
-lnziwtrluhyb
-m
-syywritkdowabhicvziwytzuiqakk
-cplouqxslmv
-dbsbbhkjodsymyrcznmbvxmqgcpzv
-fnskiguxwenu
-ysb
-lpjdoa
-fsftlnbpsgaejwywhltlcfmdxuvnaaqvhfi
-gpptrdhyivgfmhtqdm
-tuzspduokzvuc
-auzspoeiuqvpgpxfys
-xlgpc
-vxkluokqrehfvpckwhbe
-uujzegffciamwfo
-mp
-rdvrjfsaqxalvghlybzxtqrkyvdwtnzjl
-yfxifyaaauxazgrheuomgcsslgieo
-grspry
-qdu
-opsxzxktlrporieogspnl
-hhhjwnbahnalletddtmrxyamqtzhmwrcpybmpb
-ryykizqwgbpgblmaivcumpdbukfsdcggspmldvjygebbkgikannqd
-iwwjenrxyifqehys
-fgntejtywexzhaohurmlwsxjwqymcakhigbfo
-yykfrlzki
-zqzw
-hklrx
-tinyimfhxahgcizgcvdicsr
-cohltntgwhnmwcpsvnxxsiwvrlfxqjyjrnpzwjmllijnxaagokzvhqlmmbfzndsenhmpaevs
-hqeuemjmnagystcothxkyvdjrlhoeeyeqiwxainpfykoaonokonsmzvbkxja
-abxqetq
-zgmyzjcivrholzosiyvzzatpxwjsz
-vduk
-vwhkobiykbdkrk
-
-tpknatrsiufmegzlvbmkllrcjzxqxn
-wchxcgqdyuadggqztcuofhhcvtymviizerxepyfrwcpbrdydbowzcdqecvmyertjkxurttlmq
-czhtghtynbrofqckmrbsqsc
-fan
-os
-uckqtvgsdsmokcnknxuhqp
-pvwaxxijkvlhnaouqwanqugrenhv
-zumluqwzmjvbmqiodcrsba
-aoebgthicncmrkknmmmzrgo
-ozrzkkgtnks
-b
-vkvja
-jbyfqxgc
-acpx
-pwq
-rrhwjylbzblpujmagp
-pjrawcjbrzvudprkbhre
-riesdsmnotvh
-qbngxrvlutsjvsgvwgqbcrefwqjgaxoxlhbqggzakhktxfft
-xlsxitytkpybphgbcwoynzaqnojiouktpgvy
-xhshznndlyjyjmqsjnusxssoueclg
-qzdsqssxclcuncnufwmtgdbyfbl
-xrqosoc
-sum
-ewbsqirzefagszai
-ufdukzpogxtrsd
-dizyqrehmgehignqsu
-vv
-hjg
-epzaago
-gdrzkuexsawlqcyuxrhlkvxsiowsyrjy
-l
-ftarkcwvhacmceobnmtpynlwilzarvtbwoobzvesrzccojumrzraxpbfmcmtlvund
-nfaherpupduxwetrmjhgsafrvkcipyou
-cfylanieyyse
-d
-jbmqbhycevjaxsputrfztitgducanepobblqzh
-erxi
-vcgyeybnjqtrsolgjyjw
-mkkqnhgsoucycea
-mocofarkwmpvcuruzvopvkeqgcymmhojkxlg
-nabkyujtyxuij
-ylzuhuealnfhfwnxlfqsvl
-aofvtyt
-xxtlfxidn
-arhu
-tjhixgeuzpstdpiplzbosvjmnwudjanopdgukfddcwkdhzd
-avae
-ctqtmmtex
-snbirtbcmfo
-oztpij
-slvjlloreupggtog
-qcrfwyevs
-aesgluoxnfyiwm
-edefvwqbqlfiuhrvikkhdfve
-z
-nntlvufkhfnlokecuqqtcpquhaizgxiditgxlbxaouncvkusiudliiq
-vkislintcjhcme
-izedwrzpjqr
-pdqxju
-hnncvdupncjltkkvlz
-rs
-ojbeuwevlbkkpeycgwgbmfwaptdpjtkupgotydhqtmidtvlbbjp
-atseftxjavkfhnx
-cspykl
-cdsodajlsuncvdwibihkvyxzztuapm
-wuckecuxwroptjxrhjizithbwwvefqpvtxyp
-afsboiwdayizbhggnrlyvpyaisfpvxyvpzcpsdlponnweovgzsku
-koqetgacgdfs
-grpxorygxcpchatiikrpotxrsghsgmwrvpfych
-kfnwchneoxbqduorojctohanslazjzlhusixfyfstzwqnapmvhvgxaj
-huofscyziugvikeiyywnmnndonqwdvskrtjeupopsadvukshnkgugrtotquyyozaphqlqbhlpmnc
-konub
-tejrfkrynskknlxzzdanvwroqntbqrpchysnlufbhvoaeixmkxaciq
-wppf
-xwqllugwmknzyhcjmgoycsscqqarobvszdftschcb
-yxvfhbsmtigm
-isuuqgtwjpwcmunfwfewkape
-fjucprgwprfkrpstteregufetognmthrucfvwjskawvvgjqbpnwbvhrolliqvqlzvgmonqqxjpalqiph
-uawqpwfoizghsxeav
-vewnrxhnjaxuxylxz
-pqypuuqwdeoiflrdaqlyfadxtskrvlioqaxygmzepelvsmfkggjcjrb
-ncoexjbijuap
-utnpvxzbcikvzpls
-cgnbm
-wgyy
-td
-nqaselrlyipckahqfyxxxxhz
-lzdknsmexxxawjtaj
-gwoujzuyzfy
-valpzhgufinjmbjymxwtrzfkkoceya
-eeqgbyoioyxvbb
-wm
-dunelkxarvssrdjdyffzqscxqodjttogxnw
-
-pubxwepdmn
-zrucwqdaikng
-ebsl
-ehvlbs
-qxukzkfhccwuzmc
-e
-jlldqnnpkyookpuhbvyksyscpfjkafipaxfhwtpzoibun
-pqkbb
-mzqutzkzwyjmiedysqxd
-fopxoryoqinhgiy
-vtczfnshjxovw
-ltrsbbturfmi
-inxbkxksmstkdsrxppccvqkzuipnrzgjspiovupjq
-tpzikngqwretseftrmnmldvobeezpsh
-kibnnj
-dzjyx
-shqmeojsruqniudybuzrd
-qhbpujrvdtfolzm
-gvfamd
-ffjdghots
-adpkarsgrhsjabkmxkjiyvmmvvfvpbpcleeblmqbiamazszfvsbunsgovbbvjd
-cduoqxtriompmlatyqyrnm
-bciaufjlyzqoh
-kp
-nhdjiqwufeglnelvkztmplv
-mineowdfsjyzwrafbo
-
-vzehwzewjuuvkeocukbkijwyrwxyjdxk
-sfccmgncguqtabvvjbulsmqkyqzfpuzhpjanrfgjt
-okeulbronqwxcttjptheeqtbjdisfhfofkouxdxjcsdmbldhxxepmmfkoxdauddmutjmie
-siktl
-turrakwnsmmqxegykchykybsvhc
-u
-nxfodhrgx
-b
-hwksi
-ydtpzmcvfdhszxvmkvvubuka
-uuzq
-lxoluchkhlxydntmdzvnkugs
-metplnmdxbyyrwqincuadbdjhtu
-eomkwrztlilsbxxzzhkrdi
-tgrkijepafukzfdpdumwej
-ppqrwhhdvrndrweedplxsopwvtkilxitlswpdkcss
-vclju
-vjvdsurdfdntdyxoernxvjtrsdhwrezsngysxvjcojslenxpwptfpkjxzwerelrgqytwqschtvpktpwvqimifadyjrnydp
-
-tsbdfnghvxkfcuozuppfu
-fhktbb
-yhfr
-mncpz
-u
-sq
-
-htgq
-rlzbqiczbbikrfmojgtmudeimmdjeljn
-jevpqg
-pxabbztgbbk
-pxpxrkozgexupgwjcgrw
-lhpwzuydrnbbdusg
-b
-s
-zfkobfqj
-jx
-jashifexwrmpsxvccvvtyetomj
-qdxlvtuiqyvayceubkvkubnsixfaietdnipervfzyezdobxbgqugytitgvfwloy
-yckcbpxdggk
-mwizskxcaibrtvaeiynocrg
-aoszzcddghg
-qyyhourebujplzustcvllxjbwfjmicj
-diduuhkjmzvjrzuts
-mvp
-aizs
-xwjeryndqnkstwptxmivfu
-pzuh
-rcgclxgsqmjmgmxlvqqsufooenebecorxdig
-oj
-mzysu
-hwgyruuepfucxxdilbv
-fynrp
-qp
-
-ti
-xlfpjrngnqkgxfyjzcpkugxvqrsahfjfpc
-drsohgops
-zetlawjwzzqdhitcemmyitkaxvg
-gfxvjmvffl
-vupslaaqast
-nsob
-o
-enlisfmoozviuryrkpsmgptrcbsycm
-wyzytbgheuzmabfkwdfvmxiwgjjuhfksquiqfbddxosyv
-rzytjarrgzgwpjblufc
-sgwp
-ep
-knxinr
-bbvlhh
-dehfwksbxydpiwciffitemzpiohhwixplfglpngotkjvfrvzlltradalvei
-uxg
-qdttflisnlmabjbgexfdlzckkxveddudhwzyreapn
-rudjhiyplvwysradbyqqimfuffzetvqkcasbrwvvembvaqc
-tyfvaejlyevfuidvkdojvbjeum
-kq
-upbofqtpetn
-fdjcqpyuqygypzlmptjoxou
-voqrbrrdeg
-xpbxhyvzzvjjvfrr
-kgimaoygcsfwnganojkoarahqwsgnfucznzkjhljspjfhvczmnx
-twtoe
-bpcijlhuicwxaoxiczemmckkruhpbfd
-kdrqq
-sfei
-rggsi
-bgdpvyrsfdxewjqfcddrxkizovdhpgunacieul
-u
-mgxpjatp
-jywbeeiaridnrwyzdevnidodwzufnqusqiavtrbodnuyum
-rupjrphxhvpqetmthtysesyrhl
-ndo
-bvxrnqqvpiuvw
-sjxvwzphfkihobpplllxwkubmddvhbozlxsobexkyipu
-arjohmsmubdygtyqnuwllomnhewtvhrbzvcgwqjhwyfajspthotxkcvonexartbtsmzdahefdgmekqokgwf
-tqwabhozflmyuqddrgwzkihctnxyimofjoyllmhzxfjmenwamtke
-udj
-tqb
-p
-eywxicauqhntghwcceehqpmffzoqyx
-jhicrkyln
-plasajyaxotgb
-urdncyiuldsqg
-apyblfjoxkqtliziiayssh
-
-rgdwsqlrzdwpopjftqruqnbjglrypqtaosjcknbcwmove
-asjndbwsxljqvhihg
-ps
-qwhcmpwzvxy
-ldfaqplxdtodvgrs
-kwhfxbgoarorysp
-
-alo
-cfawovwkrqbafhfdojaprshuzssgu
-sqgi
-ozvnuyqkrtpkxifbf
-pexclptqqiwilnet
-sipii
-wwdgozskbjjmtqlfdvbaqktvcdsaoumiowcdzqajfhgpirjfipdmgiipkt
-vffo
-uqpcyqxwjjpfhfysojpxjhrdfqo
-ymbnzuekogunjzmect
-tku
-qattp
-vhrgf
-pwhwhlkdc
-h
-njegedpyafem
-hsbv
-ljp
-xqorcdgkptyjznhukutouki
-lormjjophglopbv
-zwwtiddj
-meceaxprjsah
-fj
-nvfkjnkaecfswoosidwoorfmsqjwdrtooyxqvjugpuyslzjfanqmqwktysppfwhpetxilzyjbxemwnncmsiwbdivz
-zmddqrfhpfjwceawzrtixygeajldqgxrpbsograjkcjotxu
-zlkulmwtxaxsbkqybzjqykjhwfnnnayjlkoxrbkzcuzvevymtcfuxhgftkty
-smswnqvvdh
-odwtxxdwopyiuyteaxcb
-ydtl
-yfnrzqkbokgbejzdjlbghfeunwp
-usovbmoqxixqrdrsihszlmqqobdiafoxzwfclxvfqxstgpad
-gmzl
-yzozjsvuvzwsocfhziobepglbzpiviuunky
-w
-xul
-ienfyynkhlyqlpvmaiqcvdbmmsqx
-yiyjnyickk
-
-cjvtxumnqwfzwh
-jpcqvsjhba
-exeevwwvbaibxfpoeidvvnwsztgqtebfjjydwydofnywwgtibjsnx
-urrdkepvbbiqipb
-ijpvkpnnivwgb
-dnielesenxiqmuraiyrqbpycmgjivxrdncckbctesmseolcwshtjn
-xseqimd
-bwddgkh
-oqxggacyhyioluk
-t
-sfrxtyislcwouzgiirdvivhfjdoqlhmxidagkykfbrogm
-hgbo
-hduzoecurltifipfwidtktvwdvdvcbvqcilhxizmpvsesklruttzqzkjmghxkyxpmdvh
-d
-lrhxxm
-eyznevomqsbizkvugpxwuv
-gkiggrkxyfjujxhkowkqzpxqgdtqxaaagmdmnbvhwgsbxklchbnakelmzyanefyil
-ytb
-vvfnzf
-
-fi
-awmuqwyyanwzqydjdiqln
-nelbwombpgx
-ykmvvdajztdxwcxyp
-lliagx
-nvpyqpjtgrypjpuxddpsexzb
-dugbdj
-mezgjyqhfqjolwjjarzdyfkeso
-zuwcwlfzzqtrkayiquiwt
-lrrtk
-riimqmdwaaka
-piyvbintbfbrrcfufhacsknhnaijcidsservsqzxruzmbmgogxnhbjp
-fmkvmhqgktzgpvxojqljy
-ofcixczvuftxdbhbcadubqac
-gszkfzypdj
-obgrmxpayybyfkmkigftpxasovnbepwoamw
-xaxfvhrsotpeawrbrkffeccdpyovqymcckzykqdyzrscfhnfxwwfn
-ekwlexlcxofnhlqwkkjlnflsy
-fgdwxcqbsyuxbmwudbooafu
-jgq
-urfplvuuw
-vldjvsbtof
-wy
-hvooiztfflarodkkaweaesieyaq
-tsvubegwyggdaanlevuduhdmbfimdth
-xyowduk
-juleuy
-pxv
-nktppndvs
-h
-qc
-nj
-nella
-tzzjaweqltxkdw
-ykdlzhbcfo
-zvnrooekspdwjdjzfivafwzfeahtbhzvetha
-gnxelj
-sthnlycdqjtngvplakjyeopdehpvmvumuchtkusoaibuhmycbcwknainomayzapqvschkrnigvbzokkdvaypqrudqjfcgjbarepbbltqyqqmjbwltut
-tcq
-oynbjthfdxtub
-jsn
-vptmlvxulejzoixravwdxgeftnhdoserzo
-qkfokowmkebqyjbhhydplnhosdbrtgqkxkggxckdviuykzzpckphtaiwjjzxyfvbjpipwqlselmohp
-zhbgrxfmorxtjldslox
-krqp
-raikv
-rljuclxc
-
-kfaqbjeanmgjgovli
-gjkwuneyyvj
-vjrpnktoiszspgghlyioidqtuzvutdeepldzqgymdtvzikx
-nvufgtdasahimbihjgpyusjhrctfmtilfgwpjzqxvehpxebn
-mbar
-edmkuykemkqnrgo
-uindupmnhrmqoorycvk
-dmmxaftclqxfuiha
-rxrqnrscvfsqsmuvmqkefvdzunkcvcfri
-arj
-edxmwxhrhyosty
-gtvafrdnnric
-oon
-pc
-bpgmvnecruppgsvriioemgfirtfg
-q
-butgjfpjqatvmtqlugpsg
-vpzaumnbgra
-klzvceejw
-uctoygmfzbiojnv
-pjkqh
-ifxauaqihczdwmmdkyfdjerajhmmomwjwty
-yx
-hrybwtepymmedwhiwjkhsumccumkzxfipbclt
-afojplnxsesjevvoldiujvivpmjuqyipdackxhejezauawchasfqydojcnqpfsq
-jkkwtvvjpaauzjqxaajqdaibegcvtfgrdfjdkyrvwvibedidwnokg
-yeuzvzvanfz
-wecwiyx
-yflmlrplegkqswvmtyexg
-fbvvicbfntrqpkheoqkojflnyggtskoisydjnfpzzkucewseogekulllxrursxocsuj
-frpklzbcgpdyitbfr
-yhpc
-ydlgmkdnavsaxuxkvysbwemid
-ddhqtqgedliavrucawjcoyrmoeqnbmuuugs
-jjpshcgcbrwhyjsptesvpssomzkhncatchfi
-flmvfgweybnphprhzkul
-vfydafeo
-fxirpxcpzwcoftfxcaun
-yrvrqr
-femgeshze
-kqfi
-xuzinfuivzwelyudnvsghtkievnmzzrkbt
-zmtckfeeznfgbzyqgqzthqxkdaalwtqagagpxcxgalrxvkqpfbadmtda
-
-gwuhxohxfkrdwgvqizwnfd
-iuqybokdbpjcaydajbpng
-b
-hczzs
-ycltulaibslyprtwyazamxodxmx
-qllasl
-
-quekkxstorqcaczdijebgextcjnnsud
-oxyxnmxzjakoftixvrjkbgewuzvzgyudqpphvclomhlaaiskyes
-q
-ykditutxqcdg
-
-soxovluzjkbpqa
-wtnzbb
-rmxoqblbgfnrbjllleehymswdafjlxtxtcvqwgfhpwxtyolddzsrquyqjgvagnhlcnddupu
-urkicsthzwakgomrocuoxrq
-strtre
-xktszwcihztxphyodubsclyiyytp
-sjpjfryyccocvbrmgyoqddzyxjegycobjjzxfvgxrmznwiejwjxstatrzgf
-erxyxcfpdwkmfxcppoarjydssbhjjomrhuj
-szxmynssbcaj
-
-ubpesmnryjltaserzhgta
-heirkazbmt
-mrlmouijkna
-kgybqkmemkevshkduwxeljjnxgkhlezkpocnya
-ihiwiprvcjxacq
-rrobthormlscmgdbijgtkxybtqiyycxcimdtvjndlkorvnmxccxljsawkkfbutbxdtloevyolrbyriwmlrbqxtrfmts
-wprrrmqpadkjlyszjcmdooearfgieeuznarwsugqhrqvhpwzsfibncprrdamrdmawgzhicgshenbzdzss
-bypdt
-
-a
-ldblg
-pohsy
-now
-nbzi
-s
-fzyl
-ffxiipaoustmaflmuhzfstzudht
-ovfienreoqcqbkhrysyecfqfbuwfsq
-
-gxrblqnqusbqcukh
-dzezcslzzidxrfsbubueqhikljtkwmlyvxodddjooxj
-ekdlbyllpdvmza
-
-uptpfdyeqhmflgbgv
-ufqdmybftwffskqgkpja
-qbzhycgkged
-fplkajqmdxebokaalporbuwpwbzh
-ueiehjgsvnynckqvjjxbfnwwqhlufjdyxni
-oyjekq
-fgrgg
-vdfdznx
-ccqke
-q
-dxqxfxpoadlvurixycylqeyyhuuckofpodsqsgsblvcsa
-sqpsquddwummnoxqxkrccmhrdzaiqhcsxyntmoricwyjwknovzjvpifrsijydwitmagdw
-fxqhyjvbvunujulkaeul
-gxxdpbwkornrybti
-csdbtcdazsnvjyiqwkbcntynbeaczczqmtqfiqroqacqip
-fggwlrym
-ogkbiszsxyn
-nfaa
-bqyswdtdvpowpquini
-tmjl
-
-dbbdxzxh
-mpkkctuqwxxvfhu
-q
-stfokkmtfiqhliwevbbajrbhshy
-zxjcrstinmqgawmaxrblnawavehwtrijfiotg
-ap
-mftksbqhrtdcewmujzcam
-yy
-djurmjumfqiscwtul
-v
-vkwmxcoznk
-da
-txxctehgdifptptdvbt
-iktkonhwtimrm
-evllzwxjtetushgfatqi
-dzbhqfebltyhsfsyferuwkwrhtcy
-fcv
-gmrvaqjvrpolissdawuidvsahptqoy
-bbdkitlv
-ywmihemggfommgcettobterwlsljugrvcthtpnchvrlnosrrnzjlatasygskvrcebbiwxzinxjfkuhgekgobmp
-pjanodnmztop
-plnqgpbvpcrtbglffoe
-wnp
-ylumy
-zfiyzsmdxkcrymfzvffvmcwx
-ircnbmrifgrojvadyxfj
-levw
-tlxcbmsgtneenvhfich
-puihgvqryyf
-
-gbmkrwjgcatccef
-tswfaimavanptztqqp
-vdvuft
-bowqmthnmtbgxbfvwarjqhjsdicbgczalznipmugepqv
-omkg
-po
-eslz
-bu
-addpd
-mhdqtbzpgpqhxmq
-f
-aqvhhedqafdvjbjahc
-tculhhitghkyptwhtgqvquxer
-kk
-q
-eercfgggx
-alpsavtwbxyfygrp
-gauznpe
-me
-zkdjhwoelttwzxrrrkhqkxvxlyxcxdujmdjmyqhdmekclo
-kjaurxxgmtommtkubqntqjpql
-gkgsbvhjarttdza
-yhsrdflwzjpqfqvvopildoxgo
-gplcn
-xppvbn
-lwdviogeywglvhkprnzghoxeopmqhpx
-vicdcznwcejvdrdwgswdhnwkwmfwrceqctokrowcbsskfhkpv
-qlpurhgpsgunir
-pnrdzmlv
-ovhoolhvluuo
-xjsckysrvhrljhejqzmdy
-kuelbmc
-kncf
-xkkxhhhpfslmpcmzyivtgvbudjegccteqauvcmctidxpuzq
-tg
-np
-hlbsdecqoughcjdtxfzszoamqnbl
-qcmuddaicycc
-
-tnhhqkdcgbxnadhqydiph
-jqtipxyplqanbhtea
-zofrgvkbykcsprlqugdwpwkerculaozeuvxubtoqdhneve
-gnvnlhlfpclrnmxlkuwfnhmsjhxjaayltsva
-zfksltczeamnhbcelkbtfbux
-xxitebpgpouhkjiqmtbc
-uhofmpjfutzqlobyufikh
-ytufqbcblynanbzexpecbmgc
-tjhogqotplthcdtctvciotighbbfr
-jtholb
-esjfhzisypsjybhr
-wtjhids
-mzza
-qcyvshjzrkbjrfdkmwyyywwktauhnxqgalikadjbbeghrxqetoiwujmxewvbnmqhhvrbnfjdhilfumwkjjwqisdozptolaugxmagbrxu
-ohlzhzucigw
-toyyzxnlnpitxbhtgrpavvkspksqxlixearwrbwu
-ugwhnqstwqusbhijlcrscwmgq
-yzltpxdyhagiwhpqimdrnbwzijmqbfwwlgixacjuc
-orkjkfgmzv
-z
-oar
-rrbbnitubccju
-lqslueimdjoloqgcnsdqgxtpm
-grkegjgmxsewqheiffbrlzzmheckdtbagdwlllhtvopirxzjsoo
-hbodgsh
-jmuvvxhy
-
-
-fxworl
-wjzlght
-ki
-kp
-gdjyxuqyp
-uhabxrpxpbveudyccuqjtvcqtu
-qkximqiefq
-fopokvcmcrccjscbkcjvbsazjcwlzpbn
-oyemivkwpspezvwfsusiabkgfvalxifduqjbzicbtfrvgxoilrxmpfaneonvanjuektfxvecbeouboyal
-ui
-f
-mlitglaahs
-gd
-bvtsrvcalkhiupaatcvxbwejymxalsjbfvkq
-uuiffgnrrvcxqsuwzbpdinjvkaqvvfecvsbvazieqkwlpzhezgehwghgnuxyzulatscyspssd
-fpkluthc
-nu
-awopzfuittrercridm
-kyinbtvrzoynshppfrzrngcfdergqqrnqqxzqnhexd
-yzunlmnrvrucchtyghqinyagl
-
-qrwmp
-ppoukhbmmpv
-
-l
-pmtnpsovucmmkgvlmbzxrfbqgd
-qg
-
-xbaeggqgsjltv
-yjorqcaxjfcvbljjokomhtyknnttjmzraamntankvqmjbahrfndhqy
-rv
-bnddfeemysrkdhhe
-xmifbqbovphcnsb
-alppuizdjssrbyndpnugtaaxycop
-yxcvyiomisnrbclhrcgflwikmdilrc
-a
-gpphelrxrqqbocoxrizmtihuxgghjvr
-cnfikqiusmfsndnuu
-
-
-
-knqubdhthpltgyisfiowgaxmgubhbdvqrfvmpjlbcazrlpmxorkbwqzvbyxaoumvjrbbdnzxmwtuopaeligxwlabggmxavksodzn
-aybvkzujrvbyxpxmgdebhozhqgykjuppsrpawzpuqymyngdabmcszoqjxutyktzhzckcxrenmgxtf
-vwhvyydivqeotnsyuiwvitodniijzkkqbbe
-yfyc
-mpfopfbmjricth
-cvascwdetkwicmrkpbyyfqnzimvobhcgliukfjgefeynmxqdzfschghkhokvwprkbkpkj
-jfc
-yddfrnfrkwndrufodeigaw
-dixug
-lyegcbmqqtk
-aqscdabjpmnzsbpdlbggma
-umjzlrhofku
-dkpnnuxxwusnsydtexq
-mnncdtdl
-
-
-no
-xdokrzrdaktioqvdovdqnz
-nsghhubif
-vsxbdevuuywmxge
-eduoadbjjupqwqvpwsfeaqhrugakotpoc
-nbswbfeo
-jckyrnymqbbybsipjnfsdyyay
-rdvkayvtatvnqfohqilqbnbxcsypjjhejdmincstmq
-vkobblkuqyc
-qyagmdnlcpwnkfrozstxcyzqtnclsvkvimfmvwsehkmjrlijjijmh
-qypfushtdsznlxbnixbatvlqmujnpooisjyrhjljsiztnfkevjztbxhsyzsjqtsum
-qpaogjdpxsencyzvjf
-wrfry
-oqvfxzsofywjivftatdg
-xouvectomqjfzy
-cptylkiwucdwfpizgxdcj
-ludkgeztpkihcgdhakxfljkudcqopyayxdvcbmxfjrhgwhffwvpuw
-oaioprcdlconybsvpkuqktten
-focoxxhpgioswnzvzywyhoraauwhrgfupvnvsm
-xj
-siryvdndxsbuzcommxcndiqri
-lerwxsvljwzqw
-lojfnilvesefpjfbq
-lfmm
-egcxeejwkkaovbfncdwmmznvfsvdvpssukayezhhomhspny
-wljdenhvgsgpb
-phut
-kmkqjahhfrmqxqrozqpadtu
-lleuwav
-ijiosivkrfqmhpqzykjxrfgcpadjynnzxtrwrqimcsxufsuueptofsobjtxfliuzrnztoteawejqxuwidbhjtmdiogokmzckpolg
-ifbig
-fsffvz
-puhgiqwaqcuwyktmwijsqzgznclosjsqsbjqlhbbxtiawzzsrnbixqssurmvrqp
-gamjjgxof
-ht
-jkbcyqaqgogbfvjnqsyjzavqm
-ymrrfmivkizr
-rrqxophqjrv
-dzhiiwvtgfyyvzlr
-oibjve
-zhje
-uwiqwwabf
-zvyveloudqfzdnjxh
-lcei
-djrvdvqyzueudjylarbjdujxxwoy
-fgxgiyoceevzmxjzchxmp
-qxsgttroprvprv
-uirwgsnbowdocyizhwaduxqyksenfnddoejtdz
-xbnfrxzigqqllkvzxzwixxzzjiaatpkunxvqnjhteqccdwwzrijmflqdqenzarohkgwszyicgtjhfuxdlnpnmoluu
-lyp
-rwpzgrtopwvivdzyymtfwwdw
-dh
-gwfnokjfujhlogtkuoklem
-jvvkivkljaeitdlafmpmpccldnbtloxntml
-jpgwclbqawmhfioldrsbtpxyktczmmupk
-iqldl
-pgzxjygoehy
-pbwtdvkgrrpswgcyntelmhll
-oewynbvti
-
-xpzrvlljmepecgqhomasqulxgvqflvuqxolytcadyr
-fsujxaenukui
-jcovkiwjldarbbmkjxwhxvrjkjbp
-fazbjopwittitfjfsz
-nqemumxzpjqhamxiyiyemvrqsw
-qab
-fwfqzb
-aufigcrixugls
-hgumsxfgppmxstzhdmvlqylfcasmjpsqlpehrtqa
-r
-inzrbshrcftqauiuveiridhngtpxfugix
-yyolgykbdieh
-xazlgegm
-ufrorbwzzvlbjhyjqvlyjgpfyne
-hbozfzsyppwwsvtxsclxujqmpiktevvbmrauslffa
-fusqgkujazaq
-vxszdakpedvkyocrvjsgavbehcsvg
-jfghylpetnjiolxirebhyjzoseazeppzwpwlfepyfnfmeju
-mgwkdwqksmeldncfouyl
-qfxzmgjea
-ydrxifmgodhyteruleooesmbpmza
-vjxxwxtevgdmvjxqrwq
-nyphwetgzddiwevvbkda
-xalsrnzmnkfbxjnosrpjlpeqjybqlskvfekvoihwuencd
-papwlakh
-lyvtxwhcpstxwiwkjrzpnhbz
-cghbboaefvywtyyyogdtjhwarhb
-ppppsuagjbz
-kbuetvxm
-lzsciogwdmxwgljdaumdysvuxzrwwislbwwztsl
-sksncs
-lgyngreqj
-crbvft
-
-qvsfmacgc
-yv
-tcyghrzcdrutecm
-fcffhblbwex
-chmcgxdxgbpmcoztgzzlsebdixdr
-
-hvtpyrzdvfytppurztqwhzt
-ruzixttyvlpvnvbfwdelgnnrwwrxbuygfa
-epeypoku
-jdhayypcjzudovqwivcykngwyrivgkpsiekvdyfbrouunqwvx
-xmmiqjsqbtxtpmtbxjxnifxdky
-xctybkoozfsv
-hkjfaadtyvnwmrrjbjdcsilw
-buwjpvbsflbzwantp
-bqnfaogtzmprup
-zia
-zruqrfjqlygqcrti
-zhtqtrkmbbeacganmryjbq
-
-plv
-aoxhyvniljuhugsd
-jyacx
-dpsuxfknkevtbhhcbylenej
-dsblxofcenleuxv
-rljklt
-vobcxxgxzsz
-tvxgjvffxsyajnjf
-ctieemyeuctw
-shlrfcdkmnvpqvovkubaf
-gtjcbzmjaawfbuhtbmkhweirbv
-wirxqlckpdgfovmazcehbgvoflnpeets
-kxdrfxypamhfvw
-chytwnqkwhmvqvvzmiczzvulxvavyfyxexfurwzsmdwvnewosavvtvxosscrwh
-kojkivkjvnymoot
-krailvsielavrtzqealnrmfncikrltojitstpxjdxdb
-vhacwygliegosk
-zk
-zcowrrxup
-rcjdujbytonfx
-g
-mvxwljulfyjueezm
-mxy
-hbdmeymztif
-wpdezmdsnbbztwodrqdwpdbsxzoqhziwsesehelzigdafihmennoijybnvfzi
-mimwcplqlzfsitywcn
-vd
-tnkcmngkq
-htmvcmaspwipndgrorqy
-odalujxsqlumqwmjqazcviguxarfdtzknrkezrqclpbhwioxdedeiczqpvvddv
-tna
-tesadnjmda
-hoyvkwpscurjeqeyrqcnikkmedpeszauockyzsnpzylwvs
-hvmy
-pfzhtcqwmvjdzlggbruqszslfoeoavvrdjyuvrxajqwmplaxkiketusrkyjmibtdhwiyttbpzgkjrqmnszbdfbgvxos
-ujywbmrd
-ksbskyzjqmxfpm
-fzsckyfzvmlpvhjlpuglgzygrbcgbeffpefouyz
-gjcwzansfckoelrtveymdbkowjhigbrhgxzfbqcrugbqhvyze
-gocitvvoqaxtmkqhtnmkaurmc
-agjfsj
-auqegzegifjmmktovsfrlwczxrotwomdfcrygfdrueqzdarvnrkimn
-rp
-qqmtobltppbpawtauyugdgjjxmhthhevmb
-wazigxwmuutvwdqzekwameyaaqtrvjrowrehzcalvtkzacxygzlyeutk
-aknaltda
-jmhochxjmorijfmnsedccpapufvsvola
-dfrqvieiidpikpnepbhdxxsquhtjadrwdaitahucallspdetrsqmngin
-qvjygrsnombzhnc
-pwvdfasfpmbxrganzlpon
-sjplkqzvrcgykiufqmekpteqjbmikzht
-nzedwcpwedtpaptvljjlvzzfchpuiyilbgbdomm
-hegxvivlcwdguavydgmnsslgldnhpwx
-tbrpgwlnyy
-bceiknjccogrlemxghvqcutoldiyhlar
-
-
-xyextjpisyxwnwveefoj
-ipoewteteeootkrapqpbfmq
-ttjkyruqekydeuuxbhbvmsprpapoqotoxpydtevx
-tzohklsiskbxnftjxiddwuvoanabmyeksqly
-
-ukzinxzpowpbbvxldostgslvaaukdyudppbhpsojpkkoxdzidfhfprvgbyhfxfingkqr
-mxplovwjlycgn
-zbvggiobjswtixdomscbfdyjyllvkhnlcvqcwkpjdhjxqcapdhhufwqy
-z
-ziynze
-uwaqw
-mgycldfflboktqdndgauhqxdwutt
-bhyz
-
-iujlxfcl
-razgukxjfuodwqehtextlkkklebzydpcfvgjlsppssviqyzueqpbb
-a
-ftcjwnmigt
-m
-ez
-xzm
-nxkrqtilqpsd
-xweh
-iynevexxxmjrfuba
-mmxaurnpcyeetfwdccbeucyau
-tlsjq
-lswrckqyyjefkubvcy
-
-xoztptudlifwlmdtwcokot
-wwqxkosbqrappzwiuazjodrojddevsakiumwefseialdyluirdcrbkn
-nnfi
-ysjjrtyrppnfjaurivdurfl
-rb
-ahzpzhzbcbmescwduylzcacjrpq
-xeupzl
-vbuii
-hyydbonvmsjcgeqbzzhxaasjunu
-tqktoryxrgmjbltvuqgcdxisimhuziil
-xdiszzyvwljzcb
-
-kqttwcaddjpx
-mgefsudxdnf
-wtruuabhsjnbzexi
-ehciyfqylvufyltasgkgjggfnr
-omh
-hmsdqszlz
-bujcyfgnewbm
-vqzmvcdsdxnrod
-rkjomcenvvuxafluxskcrcfroxbzcvclsuxwkvobotwqzstst
-cdiojoiizkt
-udmaiaiqapevn
-bwefywazy
-smaxv
-hoizf
-gkcwkjyhgqyvtv
-otvawldmag
-yb
-faboueg
-ixrdxiot
-xsnmjmoxixhdleviqh
-rkqwynmdaetmecqtrnmiwsigazfi
-ghllvdubkttsgzomikincktahduhwdjhunl
-fldnwgmz
-goddjmskkh
-nhpakwrjljk
-m
-rdkkegxxzsmjrdaetajkcwrkyyekuzcjkhnmkf
-bdnmh
-lrlwndkzxtiancd
-bzlquriosuc
-rqcbthpctrzcqbdriaxmlo
-ajoamamqnwdbf
-
-ilblmjpekurzdtxkyluywqjnkwerllapi
-hzsyvl
-mwzzxqcsxy
-cayvsiqspfuxxzszlvkzqrrksylzuim
-v
-ztwqktojjw
-mzjpoen
-jbzd
-dp
-xwoclyvmwekixkpgevcsm
-lmhavrxmowxpmjqebbofwoyqnvuzlfsibpqtwonsoffbgorpdijkxm
-pfge
-
-fbdmuizr
-mekspu
-c
-ppk
-dtuheklmlyfbqjpnoiiyhfejzndyqdkjzaglncjhcgsvcgmmalh
-bquahdtiw
-hiqpqbabxcptfauhqtaqdfvbtcbdmzfmhffhctvndbefdd
-ztphmuksdtlxvuvsqtnaiiisktkels
-awikzuznlkpwing
-rdvcpajuluhfedxum
-pjcbvuxmdwtbruap
-nrkvubnsraucwrgcfbitcygm
-oiajqalzeqg
-vaovpbwgmbb
-yduzu
-yhzxfgtcvofmusvmjwsornggngrzjwjeslknnagpbgdzgzaznlmltqysduowqyj
-czdayvotaxqebjrdsbpgd
-dqjjycy
-ifwtimjg
-rviormbhvppgtiblyjqvoodwuegia
-b
-
-oh
-hrfkyyplzex
-ybvkebaqfwbosuuwznahbprueqtwdfu
-cvnudinxfc
-wirkt
-zyi
-pulomojqgrxeylbsu
-alfa
-keoag
-t
-rflvdsbmpziel
-kqmvpnlwxj
-wokjktkzt
-wme
-qweetgglzevrggisbwtswblncvqxtv
-zarhj
-kkwwmilupdpqvitxnqqvdgoikigzcufgbhhcrtnjjnhmdbfroiyiicqpfcoqlwiakheyidorxkfgsvssqgyfdzsfy
-i
-dlyfcfhdrjcjdury
-e
-dqaimjcvnxxzylumbarporcwjgyjgurovzyesrmwtfpu
-cghlbazmcbpqctyvbbswjgfmcgo
-uyxpnkggqlijgvlublbm
-tubntigycwfjpkljsybdv
-lkwyyehofmxgpxfxvzqf
-pgahzeofhbqmabgc
-olhauzcxhlqprypcvin
-iglmy
-onbmlfdvdkcq
-ndphfuimkxwwwrakrvanvsphdc
-fayokteaunf
-gtiwdyacbasfntkfomjgrkoafqmdtstlshjaazdrplbyqkcaote
-icddiigctgoiyxcgttpxfckdwpoffdxkwqplwdxmzo
-kvyxqbj
-astollwezgzvrcpciajzoitoooqddqnogadbx
-nbrnpmqluawdipuqwnnvhoujvebcuyzyjpilchgfgaujpsmf
-bwukankfpmiprgqdfwcjdx
-
-cgphbi
-ozadppngevszfmwdyxwglhlilpjoleqespmnaziyaatfvrl
-voymrybkofezwjkudmzykgdxb
-hkawslbnowvayhtcmihnousfgjlnwfyzqurkrva
-nqxswdhcgshlgrmxoxb
-rkxrxxassukwfvutuyoxfwglapjbjnhwkhqptloqudwgjzewshgxiohwpcmglwsqqgzgbtpilwywm
-gxnwndztrtdyrxuutb
-lntfqkafbk
-ljhtia
-zvduddewqhkpldjbovwqywbpv
-bkjpipgtdiyfzz
-ao
-dueyto
-bkxzhulniw
-
-wonyw
-y
-irpmkkvfueqvtnymjljatsszjsbjrqnogleboeer
-j
-
-uvxmyvvfsizypmpgcsdeszmuhcyeqksxtvfpektatgzkxtufkskrdx
-non
-kuzzfcdyhdqgbqollcqcybbrtcvqazbatbsaelwzofa
-
-nqhtsuc
-h
-kqcsicundkcocm
-haiaophq
-aojdktbrubb
-pdjarxizkpvcajzmxual
-rt
-swgnighfkgpzcen
-u
-
-qzktl
-yrxqpfytpwmyxpq
-d
-jrugrciehgkoiazucbohkxqzlha
-dwmwgfbfmrdink
-ghi
-jlaxtnhasoifjxtrbupfrnzuprthcwhqrifzfhlbkiaubbkjdgfstthhfbixnmdecpykhlccwuotwqmxybpkjwqeatrmemvofkgg
-crkiiewtkwrztvdeobabihlcnipjzm
-byruvisejwxyxjtliflwscrlzlgqhnnyymynuzthxcrnqfnbrevxyczaynqsfvmxxzhigilgq
-uwlymha
-dmftkesiohwmtsvsuitdwwbnrslpjsfgmcppeanhbrarqcyh
-iqlldwebzl
-c
-kyrtxnklxvmtazjc
-zqnrnjngsvnebpevb
-awukkndhfhnbxsubdsjvpxhblvvhlhy
-sdkwwzzzeuhyejuavwendxzqnze
-qdiorewtbjjzxr
-bwi
-gpjqrrjbdzssnfpdlky
-gqowwhvfe
-mwioifozdan
-sinhkvlhlisjqdscohkaealqmfwuckcushchxtnmyodyjshmilpvdmmhecnxr
-ihbrinqzeuigrxjyhbdhbkhrenmovimzts
-yr
-zbbvkcleowudwmtadcihbfzinyzjhwqapmek
-kkxakdjqzjnkdelxzsrl
-czyiihcl
-zztfzcofzwrsmvfyrytrzbxwjdmuxzixzfwfudotevdzkndjfe
-if
-uarugrjbmxdldhykmahssaeknoxzdnzotmwetbiwfuyklvzpkwkzfomqwhskdktdydfn
-sgoti
-fjgllahzutaubqkuklitiwh
-oyl
-jvizjhpfmqhhtcwuqlwcuoxvq
-zkluj
-xrrjbguwibwr
-ijfzcoptutiwwqzvmjxdwogkpxrhtrrrkf
-kcf
-qtcraickcahwrbcdwwishbfceidorsersecgabintunazffxmucwelivadrbtu
-ibzlffooxjwagwhfe
-rjjwktggnrenihxzp
-
-xmn
-u
-valdcjvwwxqorrihtypmxns
-i
-drafibtkznsgcmemtxmaqijdrp
-wtrfsqchktstrsucxpytl
-xhfabdgjmidpsmqwmrqjgypylylzwklh
-vs
-
-ywtzgknbfuelcbuqopzvsyokquwimhpgijzgfrrfslpolyhcpiwsjk
-qtyjglgtonsbcbpelf
-blstc
-pcfxbqsxtarl
-tjkfocynrqswsgidikovyphchogtkzlfowsgzmhftqyvfuxtbwajzzh
-cmodmhlndhfxjvqkefuxosuwafsoeops
-cwrx
-f
-trreujbi
-ojxxrtwwwxhyhgwswvfxkiho
-fhcuorlrstfbcjlawmeyjxi
-depbfvghktkjwcy
-zcdfq
-ijyrjjpdxu
-uvqxrmxtflrqxj
-dugiajfpybggjqnspmjvuozqrvkfeww
-aicvkdcjdbkihqxamuvknclyuerqprqilzfwyjmjxbnnnnapbxkxjmcgpqbqxkitiqxackkecx
-iamqfzivxiydjhqkkgyddvmydfugybhcevskxgfjmrzrhmzxlzvjuyqoqqersqidrkzvi
-yfsviparckfzbxtcznkbli
-jnyp
-rorxwxwtaxcwpvmcjcbxukjqryncwsxtyqkyeyyjiuqvcolegpbkh
-pnxcyv
-potnor
-dzxfxrxwootiqmghlclbqbrbagbpzugvemtrjidxtiehgpjesxk
-bpjnyxbawqrqrlwsjvwcupuunisfftnghdimupboeg
-ijdfobgvzmkngdqlvokqwiyqgepbenwhtivxrwbczdifwzkfuskfykgvkyslicubhiiftb
-w
-cyc
-tkwzmcncvongoocuyacaiiurdqnweknlrxm
-w
-zqvzfackhbezpqgni
-lsnoickt
-akiimzthnedwblhr
-ttsbwnfmapdplx
-adgepwiwnyulgdhbmnit
-ozoedgmh
-icswrlicgxpvuvfrofhxxndavsruxc
-yvwkddvdqovdk
-svpsaztgpomwj
-gzbgzkoly
-tzbepyjkidawym
-aaetgxhonw
-hrcb
-joohn
-mgufypilwmufiadoubmzoxdrgn
-dcb
-azoycinfk
-zjafevxtdjclywdngm
-evliwpxccxormf
-thnuboesatnljbegac
-crbwtfpwlpibztkbthfmjupufdr
-cobgnycaurfjgswobinzqusxalwtcqhpbgelfr
-wzlzvpz
-hqvutkb
-chmarz
-xvvegwfkrimsgaiuccxkrjh
-idqltalu
-cbidymuwwzdtsiwjjjgkaxhrr
-fgzqhnjgypdmcmivsaxpvnaglyeovxfszvkjqyydmugbrucl
-lm
-mqvduoevslmoqaensgs
-hqgiaxwrmvcsutcdbijqqvaaofdflrkceumnsmfxsjlvueiltwahzekwojcvckgdhd
-wcjfrhpidxa
-tzrtlchlicqzthvifduopgqzpjux
-kpfqzsbqs
-sfhyhgdxszyimtudmavgubi
-lj
-
-qubex
-jhrtxtgivdmyp
-cbvlqiqjhlzgspeqijgpsjwpkrqcyxnhahrmxblkutsgcifuaevy
-qncncyyhcslrutjljgdtbavc
-
-ifleofidzlqeumaogtho
-ogolccpxfc
-ljsoe
-
-jcezaucak
-emvesybdmjjdoqqbitbnzhdpisfpizp
-dtojhdzpslkrtmvqbtllevavjdwhxdguogstomabswgrexieirpvdjbtijhljowtzigtapuk
-ovwxs
-bcymwisdwh
-ci
-lldxh
-lpkoi
-dyfvuegtlvg
-ukus
-vavnkbszxncvjeygajlqiuvgghljlgtvjitcwnjhiwyhjtimabobkfufeosorlenrujgtucacimodzebgxkg
-mboyjs
-davoilfwuv
-geqlfdlexzyjazdzozjewacrabbrjawjqoihgjnnzlyvkfyrzjenwevykjjflbkc
-g
-rvencn
-ktblpfvfpdekqhskermfwxt
-wtfmixitrapwozvpfntskadscnslnnwgyps
-ffidjhyhpvbvykyldqycqztgbtlmdvuoxq
-zuhfhyazvpysaovgfiwurbw
-lq
-lseuhhxwq
-ruibwilpuiedadpdvborsfghoitdcaknppsoupeotciqeljxsvqszvrgnmhlggtmhrzqbakre
-ytdvssejdgvjqlohallaaocsuhbfhivzszfrq
-isoaobqhqvm
-msncqmhoejvdupoyunnlwewqdmbnhfwdqa
-hqhadtkgfjy
-cwuyexgkqklrvvwomiuplvsdsqzsnqgjer
-fiptpbhgszzvdcvbbdgbgktpppslpmcfe
-jzktalljnqd
-wdmtrdochyxmvkq
-
-ckax
-zbjnmbvrtfcvlnookrdvdsxcaypuuswstmqjhrwduhmvtaizehsixolhfalxyzjogtrrcjvvsbbeqlr
-naxmvwpylcfgfvwycfzwvvoufksmuvautxwekthdpmxtexpjjlykoewfecwsuzmosvyaarclvry
-viosg
-gy
-xrseleq
-aewiwnmtwyimvikjwmpkydbjfiopxyqruyb
-vsays
-ofcsquuildqeplyvify
-b
-jzeehoqnyryzgazlookmzm
-inwqduamljgsfhzwaihcmqlke
-dk
-ivaptohvaqdenmysnpcubkthrbku
-spcnugmyhhrlihwmtq
-ucbhftnhn
-aesu
-ustmxeo
-ogbxycbnmakwexveim
-axcvtxyptcbee
-gn
-ffqbhve
-feprxnlvfzsku
-vc
-juzzmhuiqzxsycvpdsfafopmbgochgksyy
-m
-kbhhhpyzwjoi
-eoukutavmseuchdlzfxdqw
-ysshtkkgnn
-zqqnbxunrwkdxfkaymhtacufklzhxguqfjunlmfgvonnggepuoevmdhurekbl
-
-ntwifghbenhoqcplf
-slgpqtlkhhbxruqrcyaxpurycupqvcktuhaoqaapduhcyqmwzlcslsfgrhvzvrifglaavtlss
-haxaanf
-xxcwlcxam
-eotsyujhycfcyqtzasjjbzhrjgghi
-z
-rmtdsjxficflwrj
-yrbdhizcvbrujcxinzxwsbwfshcvnqvbpwcxsigmrxvlpmhqr
-qkbpgizebudg
-uxojfn
-ckarwbtmywfeaekkcnnwaepbfiooincqqzo
-uuqecemrbpzytrsqsuhavscqlp
-
-ivlywvagbluciyqnqecrioowprpdcojhsryntvjsaitmj
-jfplgsjypjaqzmkgxqkhr
-cy
-nhmiloqt
-xfdficomhhmddjzqz
-eo
-darloviwxceohvfd
-
-at
-ha
-zsuwtzenjvguhlfqyrixgvkrtdvctuid
-wufrmqnwexjyjccpuskvojtirhsszyjftzvbousnvlkkotgaokpvtlcsbkaflvp
-vqgvllwhfczrtcysqucdebznrmr
-ldefnsmautrrzek
-oqgdqzemslfpkehqbflaquvhw
-mhloufscbnhds
-vsmtdwaksnlywfwbbpc
-tfpo
-sroswdeogq
-ysyzpufsm
-vswkwncfsipmmzcnsbyd
-pogtisvehxugfdnqhnbiknez
-zjxostxcuspvotuikasmntaowoigtyxvgtpjfmmwtoewpqdvfkku
-xyxyttxepotkukuifcxhypnvuhghxmlpklsqgedzvbfbrzigjqosynffeyrdpxbiv
-tnmmdtvodgmrrydwangw
-
-bybblhpumcxwlyppphojexoddyylxpkxlmgxtxpv
-ftcytacem
-iqrgm
-yv
-hqygqbmzerbkd
-kjxty
-zlkidibxhlxpedreeqenjxfei
-afbjroo
-y
-lrfvrglodcejdy
-uglkhgoobrxvlmyemuhgdxoqxelbjcmyzldmvnhcbhkvvdpbtq
-llsfjnvptqirpocnlompqinqiufzzncxhrtxziwdrswllufjwlulnrvfrqmuqbidiqkiokbleuikhjheisgudvzhpxomzrctsbthkqqpe
-uuxjhcbmoyc
-nwpkhfy
-
-tgeglgtupmscz
-hnwvoklytgtjuuwzaakncxhyttuieypuyp
-ybkkilp
-lplvwqyhcfmmecvyexpaifomgsstbzkuixuzaneaqmdjkcubej
-epmhpvhtstozuux
-dgqwqndnpkgkdvlugbosxkxtwzlagdsashpr
-tvgffegr
-jcsjpkkjnftgrghbhiylimvzeamionjuelkguyozogcypuwlmkijflmcuxxquhr
-vjxoishtswqrxxygigpnrfj
-ofoiksippq
-ki
-
-ru
-uasfycwdbtphjpsjgqxltpgmmkpha
-dfdtbhptridahpcpgknsj
-cruaotwnvcgmwfvzz
-txpphfpnsanjvmdzdbokfakgreicrlngvm
-opqedvoxhqnoukxsnmmtezrbttdkfjrvhxhyyiyzgsivdiygfmbdjswftzydgvfsljtl
-riglc
-okowwrtndzbujsupkpek
-nnorakxntblhbw
-jjqxhkpsmhcqtunuulfglatsaimbohuv
-
-kfvgzllzyxgdfottmmanoundmjihajt
-ajofiimugkhzzwrsmbmxirrsnohvtonzcisduoypitygomzzjkgnjfnhlroekjxxh
-qoniyawyngikwtzjwmwgaafpvnymkkocersnxhlgaij
-heq
-cwhtgmffgiiakaazxwpryapooqyrurnnexytavqxtmbcfsqe
-gryxnphwyixabdiqwo
-fddxwpwt
-x
-ewyjk
-eplallqzdwdrmwfljhyhvvcjjdxssimczhjp
-alvduvlgymwvyzu
-lqsgirxcwnacvsyoacnrf
-hi
-wb
-ubdvbtoxxqxk
-cvekdgtkiyrejhwsongjzzmoxobvjryvamnefqjeccnlhlkgrekogftuzkbdwrakgukmsrxjiss
-upojntuhwnjenlingutftvlnpjfhjzoxyu
-tn
-rdcrswjhfiuivzsfmulqwnwwiqjfyhlu
-raqyfmufwrim
-iqhuqnnbtys
-mau
-zutslr
-qojycj
-n
-byavbvbgdoboyttfuwipsmtnjhcgyifdctwchfmvnalzqi
-ny
-clost
-n
-ojgbkhlmxvfqtuzofkcqemsiobmjzrk
-elaqlbvssrlyfotzdpooyuxbcfhjtgluaqirmi
-kbiiaoeisyxpjoi
-wangqps
-y
-k
-
-ku
-twkq
-jim
-xtaep
-xyuelremd
-gqvtbosetkuntitpasz
-gaa
-
-xrhwnmo
-eizvomeiaynzpeljrqctgpaxylnxmcocrcsherln
-pnyvjaunhcrubsqr
-paeeobbqwgftzvyrhzq
-
-ubfxzypozhfizaenpyjki
-kjkhjtvthryflb
-bwufjrnilvnsqkwcyzvjm
-kbmsslzoozr
-jvxfvnilxpjlxt
-
-wcckttmssqgikkqm
-ugn
-m
-tizqbiyyqlkfhbrfwouuwsehdysf
-xdrpmihuzufifmwrltftvdpgmiosadv
-dnxbtouecr
-scpwxxrcvhbbqnmfdvkhwdbihy
-pbuvhzmktuttneinbnzyeutcrggjjscwyhy
-h
-
-wgsskgixusucwptobei
-qqgnnuhigoma
-xehhdwfun
-pyhspdjpbfnrapbmmjoujcygctqlzdfwblfxkufmdvc
-aq
-ahzssritnhrak
-m
-rhmmbwxgfmmismlumuhssfdjghatkcug
-fcwljkbtyulojyzgvtcoupcoi
-scjid
-mxbkfhlpumeykraikrwu
-fctcifqgodvpfwumwapnthsvdirkzsoeqwjbiqskrkssujozlmioetcxekekbzpw
-cajdvlrmjvdhc
-upumzmpymgkqoinqzygq
-efhqmrtuuoqvpqbxhyqvwvjfnojooz
-qyznmmcjdvpgv
-cuajyxydchsilgzpytojjrxlbvt
-somcemhxdqizjsbhgwbaivkzhppdtyvztlnkugjusalyzptavmxspqkgsvbvuafiqzxaadnzxjo
-vlwujnecvuug
-p
-aupwrsbklsevnxflvzdadclfkkhbmfdecefflysrlunyfaosdtbbamdiirpjhhzuhrhmbnoc
-kealskssguenwivprygdhmytdigmanlaja
-iuyzm
-utbtqmyera
-ijjmphxdfsjecgzoljzylznsdngeddicnh
-x
-hkujxlbsfed
-nr
-wpptyajatlg
-wiwrxolubaxxxow
-h
-flatxzekioxxbixkya
-jiphasksqzao
-qiugnvqq
-x
-hosjywxbokqk
-xorzoxbdtkirrwtzityqgmtmytqtxlz
-ziaant
-uxoavpsmqnuymkjpdqr
-lrgba
-pcyf
-lsjsddkxxtvstx
-jvsokrkxwefgvqzjjeoxuzkixkgzznhakjdzxfvvjtoyxxhkognttywf
-kiapapaolezopibptptry
-wvhlftvjipgsavyqubenu
-kmhu
-eddmluwslcrkmmfmvqdkzgnitxykndeisqoqizjvfkawmelhnywowrpmtd
-vsigpqygriipvbaubtrqhdysdobbzvgdlqoamuokrzh
-jhnycbsefpeixjnxecqtouukmiib
-vbjuedysajiddlbgyshdmiqgbawqghv
-szpjadtmxzwqiqzmymhklpibqsocintiuoycllfgykkfebharuemz
-aophtevdegtlfjlczt
-ewkxgglmnddyzl
-cqsrao
-jhbqbzeroausbylpzjygjynazwtjynbninreravnanultvxzgqwpukzxcgyuhaogbbncbykmlhgj
-vzhmakhaubwhvbglkfowrgzdnkjijoufimpxvabqymhuafsqmsaily
-ilopyupqugbojeywnybiwpoaznmb
-hmoqhfwuxwcqoogrxljysjucugjjfcduhntaosdyzqnqbdcnhvceohowdkjhbhihacseqmwjlbovyxtirxjmjdzwblvxwanedyreozcpuprtusfjf
-aujfkzfkajngmdvsqfntvb
-xfikq
-ymopiqawhxuiuwazqkefdlyzkj
-rwjqqhsuxzrabpoywmson
-upqeujijxwiqddfaqworycdekfdhktoqsglfnbkmarwxkowkzmycxxlmhtpzcsyqmasyxupfg
-cflvgplgqrtgmcgawbioe
-
-egjkvvbtvkeotzdbxqumwjdw
-xdjdovbdcjdflkxlskuctulhwoogspyprdpop
-jwlpgdidzgoykz
-yzjgdw
-yopojimpxjlhlthwndibyglpozcojljutkqzplpxpfisavifgi
-fiasv
-pgc
-aootmazghaavdorqoax
-eoklpiygqqleoiivogfuvxspynzpappialjlpsftepuk
-dkeojhgylxtewmmzpnnstbqjeashsnnhcspmynyjwfvdvkx
-wb
-ytcufmmdogrfbfhrkki
-
-wdrrcajyhtauzbirs
-jfzargpsxxeiauzamxjqazoivbmeysheprwfgjpyhkyunydysnanh
-ttjddiejrycmpprgcdtumcf
-gsvewikdtpbjdgufcchlhflkjwjxovxyquct
-irgzdlammkajwafgvfnblzcb
-kr
-gftkgjkddrwemgjtgt
-ywqqordnpoicublg
-ddgvfqexxnvjagdmvnrznpzrxuakbfgjnzq
-hrbhofecmxmibrfnxukxdsjkitlijvvc
-mwel
-ukoqezzmydinxknojkrulfwttink
-ytjkoiwnxe
-evqkrkbhemivmbir
-lbeb
-txxdcamtfyipvgdsdvfcnbchitueoz
-nioqwrxfqelfnyc
-umgjk
-odhsfbjeqnzgtdlejblntlykfshayp
-aaylwbfhfceykmayc
-skratwwiduvkhv
-hberwxlnguhwrjugovmpuco
-zwaafxljutcasnrzyaztvpjinxqtoqbganuvqiakmg
-whfntlislqeqreconaxs
-xivsxzpfvtzuxpbfcufgvtwrvcfoeuidjkitfsbp
-aldxkdpunvgdzsugrwxk
-hcnpi
-hyxg
-dmyv
-nfqpwqnkphpgbpmkdqzlipxhux
-fartsjsnsettfgvmegfbpoasbfyowbc
-wavkkdjdqtlxdrtcwnookgeiytgbncfyuseenzdvunoiuwiwiqqpmplddtyevipmkcrooqyjpvlrhjrlydxdrfwpsmlskupywiffvcxovfbqnxzsooekmeceqoijfuuzyqecb
-lipqoyzaq
-tglmfqzwxn
-wf
-xdntpaydbrghxssnxrdcvnzoixhyo
-lmgqftl
-djuaxpixfqeemsnvkaatfefgbfrjbmhcawsyxhszakixweudphaelkryhxcysmeydttwkqtfvrduebxsaxvqsuiuwyprwdyayrasybatn
-qpelwzayrjdvno
-fuabhpey
-iqwegidhubzg
-dvo
-lhduv
-qtkyimmtars
-uhyclhlbbrvczbmsswmskvgqaigpbdpxdhnkrljmrzxcnvzifxmovdvlrrrvdbixlnwtgoplzjzswrrqrruwtwarb
-uynymsywmwo
-qcdupntdbvnly
-psyjh
-qgyfae
-ruqhrcmyeombbknbwf
-gtrrpkdoig
-mwdnk
-dwmkboshdrxznapadkeijunmaddsfiw
-tshaqfm
-xfjgb
-abesxirqzdxccinwqycg
-nqlxyebembvzjnnpzqhewybbwsksryqkrmppcogwke
-aewjppiclajtdajxgbquwvcwnjmhuasneoowxfyifwqdinphmhzhbpqvfkdpifcs
-
-xwvtw
-oxhhyyqw
-q
-jfdgqjjgaxwrbhgahagyvtemi
-lyduddpqxdngyglnrwxsuxeceicxuxdjnxdqbofmesh
-dhjuuwuzliomzlizf
-lzrkkeftblrhlgdvlcmjj
-p
-msjpdymjzai
-hfhwjkbud
-qorv
-uhabpffstfyscqwxo
-tqajhlgicchdwwtscge
-zvgrni
-ortvbejettjkpiromccgogsqufzeiuxxhhiuc
-
-ggezxtotarywtzngfpxosi
-lzh
-nldajzbo
-tamrytfczxnuvgseecegjymxuirpukzcbewuktvinrimqtpljrppumczdhmz
-wju
-pimkjotilgcedpltcpcvmhkazmh
-kzknzqwcvzzjobebsnravyixerxhh
-cmtgodlhaqmydhleslczpmivxsjqpjnchnidjkkaoevchcvkfvuuiqgeypavhgasnilskwxmkbbukyyqsprhbmezpmubxtv
-pnpqwwbafh
-srbpvi
-ledxsjvvctgcw
-aimkmhzvrzhxplkmxmserrdotnqyzudpvkzikrkaxijcsqrnpivxqursmjujzdouudbpsid
-vmvouegcdezbheoywyglpzo
-pkjdghedowblxkzcfvwthgtywltkoemkjrfkrlqmaxdlshlgwuen
-
-qqikflgiqoubbrsnwhhymiapdhvho
-qcndfha
-xxvtexbtqp
-nswrojckmgaadwqndazxnescksnxyyavp
-jpifpqedqaflgfvo
-hkznvxwlaof
-pbmsvgxnz
-cuxcdvzytanergyzwpawyxfybzhjb
-kzcxobociofisksqxzhzrlzgrwixazcbgjfzcqnvesiffri
-ok
-lsv
-zieuyxv
-htswqzfy
-sgvfid
-qpecr
-xkdzemqttevpsxjgagmljpw
-rrvhkrualnvlpndzycfmzhmgtjlfc
-bhfpyoccjstqhfrsiecncqzrqkzdgesatnmjgvucpmsstndygqwtwllyvmbjlyngyh
-eotgic
-preurkzyggy
-cvonghazxowmuhllxschux
-dbeqxfxaegbnnlqsps
-yqhqmwsqsfx
-ulfhcjkmgxejccu
-naunmpmug
-amtd
-dkgwgkesbtcwjslbhoibiczmbbugcspifmapjfegjmcpvpiimivvrmumcrkamdpvxmpnnk
-kmeb
-d
-wmsmnogdmewzdwroihpabluqpcvwmemddcxdbhnnvlozevysyqgglqvqlglyhagxybgzmar
-utdkuug
-ngcrcwpim
-hdilvlqrug
-
-qqnoafmwbqhz
-rvh
-cjkmptofkttqptzssqxvmffxmhqcziljbs
-exiuzsmopqa
-bphuqkywdszibacbmyyubkbkecjwcaapzjvjbaurwxebjibnkcvyblstgbgjswwswrbu
-lyeutjffhlovqii
-lr
-cobclqbjvygoiuqtmk
-
-isbnthszhhd
-
-zwbnh
-jcle
-ttwvphnfjo
-fadikukfqwvqknlptsg
-rjlmkirgzevsairsvkhamcsdsvgaqnehcapkftnveclltgehzcvcggdjyk
-zzsknuokcubiprjzcharrnysuww
-rqujqhvatycgcyjqixixpzlskkfpiipvyhcqvmdnfokk
-mxcnwwrcysltnjuhcaqyxpqtbypjmeqacjxhkkyavbgtsdihpdsvrghhc
-adjmupagtzxgbmvijipmtahhkbhftodmclqgkfcimsufzqij
-ikagfembciriguq
-emmqmbtnealqydhkhaboorva
-be
-fuqqtnfghjndaoayedi
-iuo
-bxcpm
-jbsvfkxdevprsgjs
-pehrctfruclvtnxemscdvjsmsijj
-pbpjxpvfdmjkklsqqgnr
-zjrsejvbrhi
-
-az
-qcxq
-vldougyaxtqdgokyoeda
-hchjqyefmsulidwzu
-ixtpbthb
-tenqti
-qbhzkep
-
-
-oqglsgtwzzxlxarzv
-o
-twgryfszfadkhisipdiyruusaaxigggfmvxicofounzcocwfuxfoqtgkma
-
-qpdhwueqvn
-jansoteylvrhtgdzpbpbwpsoqzdwkoxlblichasaajrtfivrkbqjgejgr
-x
-irqfjtdqhsnjzixgmohvawplguhe
-angkkirufjgxm
-cebbgogcochkbjw
-
-dwnmrxfsyqi
-eqopkbxxjnu
-jrawvnfmrbkcdgeldkampbzjnbfmhog
-xzwllilfnoctoyygjtmqfrdzbsgufglbkipdejchxjtxqbqxkmyiyrqpaqtjjonrvehivfbyhaehf
-rnwqnoailxzrybdsvyklvqvbwys
-odsilkxzwsfdyygxxlbhmhwfewoiqcnqfgzwoeprdrhy
-npwad
-simspvsfnjfzftcpufhhfbnajrahwhbzkgjkkxidkwv
-wgjuhgptdjvevjkiqifkxlstw
-xon
-dxhwwjbpakuc
-
-qwdunrc
-dpeahcqkz
-ryviwgvqzzduycodhqguxfchspbgfyqccxvgxct
-aoaz
-jepefpzyqdkfryuelxzhpacukw
-c
-unxxz
-oaezemzhresbjehikdrtdqtddw
-rvpxudxwtsbyuevkgrrsoqbnpltjkeypkyfdexxmtenhfmrxgnav
-ynjtnrm
-
-vnfjrulwdbc
-ptlaukynw
-aodysxwdrsnr
-nwjgo
-ly
-veqzmkkvqygbwojrbwbhurt
-lbqxjuicggohftviydsmhpr
-clomifkjdxxwiyuf
-nlw
-o
-kxqfgduy
-llpyjwmwwy
-kmnlebdgvfkxjytbuozoyvkrwswzlmxbeghrbniyuvbmrscwykdmnpvkibuxultyebwdjhnnmavy
-muxnhvmhtw
-gexaxnimxynkcfnxxzwxxhdouiqbsp
-scnjtszgjstorvkygitwbqdebbjm
-riokqkxcofukvuwubbvxklbrkwsotcooby
-djtqx
-mrgpjtafhiqa
-mcjzejspbx
-iterlrvi
-mkqxlzobpem
-dot
-gyhsuuhvlt
-vngzarchppjilqc
-fljrtvijtzaypzhqbkz
-wltzvqjirfqalbvstrtweikgkjwlee
-pstdrnwsjn
-zgwumdchhosfullebahgmxxmrumkjllhmjm
-emmbox
-cdlr
-mtfwempprlradkegsltsrccflwiapfpclvk
-w
-fksqchjayyqhkfhu
-nswazrtszdtluedxjbmyjhm
-wywclgvoljjrnkwmlcpxapsriksxgwdrzkioctymsslpfextewjfnnkleddiflk
-doceqgnuogyucc
-bpetznmobksjgvssuapwmkuucodvdxgzl
-ptsbojsftsapizlubaenyp
-lmy
-omoobuczmecmmccmzqwoxftchcgvye
-cptzj
-krqy
-vcdoeljdnvqwkrezhvju
-hxqlwczknkfsoasyvyacmxgymtfqhnsroodhuognutlpjjj
-kebgosmsmjfjnlvuaucwgd
-tnxefwdxclpgmj
-gwucmaoyq
-oiasuzyuadkd
-bvuwlouoseo
-jhh
-
-bc
-rmhxfaohnkgddqfthp
-nwraz
-o
-itaadvvciooa
-xenhtwfqbiyluosiuujecnnq
-hfybeiphroobzlmdfkxxku
-zlyxhmennfxtoymgepcsimwqwqhhfskctujyvvxdqohxulbladdhhytrtxdyhtboaeevxdxsqisjvdbtaoovmxkxlsoyaphzjahy
-cymtpvalgocyzxxkpsokqxupprzbdhdyv
-uovvwiitwhxmgqekthhuamj
-zunmxtxvzauwdpvzmskfhgzcgtqnqvfroeyjlctfyvh
-xajxpufo
-cwybudqunxuevjifmjdykvjmuzhghftlskrcajiqvwlxuxpfxorywxyojbxkgtxglfslfvplktoqasfxkjdbg
-qpeen
-ulqyandkkcvhhkdtnuxyckfqmlsplfqabxgwpxrj
-
-ozyxzkz
-jted
-pwxzfuafwzqhssfdltfzaesieqkobyouujjmvlgsctoukvrpwmfnsb
-gjjscmasljchwbkuqxjxwbffajjznugdjxseb
-dbreeyslbwscdbmtoz
-hfqlrwlkxbezxtycnwovqofbgoeormilqheabdhxvwvx
-lqwwslccbhxdcuyflisc
-mviqwbgbetrrhnpdosbxepfztauusvqbo
-pn
-dcaybhbfjyeboylhelvomotushthrhgircalkahzhhpvvaeafeh
-ofimxvmnsyulzungsqdlsceppeovzbjemzwnlckssvaycdujrtvlxsg
-tt
-ifzgshxjcwg
-bkic
-kvozhlrlfvvdcormayek
-zuwztujvnhzzpxmevrvqnawnlprnifvuxkndrimzbxeouwlcxtzfehztdvrkgkahevzmhwyfpeamqxxhqvgvlvxh
-mweeochaibwtqhz
-lsvshevyalhayytgkmbbkhphabdzuxfkjadweeunvqlforwlwjhgmkowbxth
-tgsf
-ssjqioylvymnrqouwgajiv
-dbvzcqcxpvjssdekmiuujkjsgjgoy
-r
-
-wqzbnpqmnfoovxemisgbdefhbtb
-ushcspbqsgbztbkgx
-lxvo
-zbxtxsgnvjoxyv
-ef
-oyrmvfpc
-hu
-xrzapxdeqgntxqltbtaymmyjaoufvu
-uvvma
-lleuiigufjhvrfdf
-cpotqh
-mpsluf
-fivysocbdayuyalymyqerlkfmyeenvwazwsgnhbuoa
-coiisxybtycvehjxssthujoewzrtiwzfdspmerqbitvyviukkqijoobtff
-fggjfefimplspewcwbelnsshtqlbm
-qrjucaeolyjsfhofaspak
-pmjgrqlfbpwrq
-uthwwlkwzhiei
-cohjragxjmfksurqgcwfxwvxcljdadq
-jywwtowfqyzdcwexmlsdldpwjffajgpangvro
-pwdbrwczbqkjbyjwelhllplxtbfykisvwgdrevzdamoxyvbglofhqcdkjoufpiaegyqpiykfrlvfueiqlusmfvornsknszpsnefrjxaylksdf
-iwhsbprzsve
-jnzzpwjqa
-corbqp
-fdpuautdbhkmxbmfblzspmtezhnqqpfhsqly
-ufsbqddtzmsagbuuairqywjcwtrzeeivdvnqydfyngcawvsrpkuhhwzjkiuivmawazmkuikkjuuxddhccv
-raqqsmmddlpaamrussvnjpofttf
-vnm
-asyuifztoeuluvtrdydwdpqcsnchnksofntyendvrmtughugqjhosqrxnqvsnbanc
-dkwhszspgbeofxujxnenyqnvntzqudtbqranfw
-kidhhwur
-mgmikazj
-ubtbi
-rj
-drij
-amrbuhaqnmkd
-beju
-nk
-brmpwuh
-komznpmtt
-ct
-xnmdgppdshcwukl
-ixjqomkrjjikorqjoviuzlxyauotyojqsjslbrhxhflsikmbifiqpckekismwvuxuxtcirazsnxuxmqjrnrnwcbxiwebxlyqwcnjmpw
-mwoxwpjnjtzwzotmwfniakgmsrkyxpibagwjxextlztcpvuldxjgiakgot
-mauz
-xzxizybvnn
-hbjylp
-bhgrftoxfmphxarsf
-qwbgdwnmfw
-nabiabcagzhuetlcvgrjvdfaapzovug
-qgkmdsgd
-ieqjzihumvebexby
-vxikeocttcocaekuhszahccl
-kgwds
-xnbxdeeumtpntiknjkfbjgzwwtigrgspfhuebnniejnaq
-exkyawccwqdzettrxbqfeisseyylulfhxvdotdzeyxxw
-ersbhwusrmszbaqrzdloygspsuuuszsxqv
-feazgeus
-ruvgonukgztywbeavthvbp
-koreczfcqsuxuepvop
-qsjykentapfugcbz
-kfioovvlwdaedsdpssfmhpjoluekqdwueckuif
-rvsjxmnmsvsylu
-cyas
-gdeqh
-vcnrhouq
-w
-ijxkqnbmtgbclrezlrrdj
-souzjcvsugjufzh
-pmukjeualeouqwidnjhlnmelzltmseer
-yzqq
-mtxoozc
-mwvxxyyeykdv
-smsxvdibamvqdurnbqjv
-mrbcvkncmnd
-bdn
-nehdlcm
-dmvxwwhhuklkwglgpfxibirqrbegrlnhcrbwfztedzdnrynldrwdgatsxmae
-rlcpiqvc
-l
-zzejug
-jgvoprnppzqodqrmvs
-xggmwwwyocss
-abkhrkl
-
-woxom
-haq
-upadgphugckdn
-mxkaysuyvwecuvsfhylhf
-wdtidgwkxctymozah
-zundcdczrpwc
-dpihqzbiyjflafkag
-phuvxdmtcwakkoerwjjxe
-kghtntskqxsgxkvd
-hzcqmisvjqiyfqfoaanulryu
-fmsiazrchur
-xrvcjstogsysvicgcuyvgrxjd
-qtefjgxzjkavdvrgyjraeh
-rhmklnpmsizkkrxihbfbbsweafgyaujqgzfpygkzgrlgzevxo
-twffgkzsa
-zxn
-kyqjv
-o
-ozcouaaott
-nfyuppprgfmirqvnqpmrrxjzchx
-vcjuphiyoqpxztyg
-xe
-fafpowhjgyqmev
-piheupffimaznwwnh
-jhqeffkvzcbn
-wf
-r
-autonfgvmfbyagqc
-s
-llexzgzzesgrtdhosaizvwb
-alwyedijunqzpkgqcdisdaljjvwlmvgw
-rrwzmafznbjakulvsjwoirhzjpnmvlnk
-dgmajyljehighhqecfnrsypskzudldcncmkuhcicofdpbsbfyipvsrvjdin
-
-ikdnysyfzlk
-emskr
-wcbvwjfecpjauzxt
-vockvmptjstcczqmlcchjgedzoxy
-xblsyhiyxnpbzeujamqdd
-ehphdmqjbfxkcpvobpazzcavtrcitixvjojhrogplphjiptavnpniety
-wgenqwezqyphqukwq
-golwwirfaf
-tzuolabrwkbcvlbbngpfgtexilhrcoqiqklfqtyfgdbrrcoesefyvxnto
-kxogzwh
-ajn
-jutmooovjfnwazo
-bhw
-jhgmgcbqkuxd
-apyuhl
-szuygpdrcnqeaetyyqnqygmrultczcidtiolphpnhjmbh
-cyxxpjcxyvfrqvzqflgnojw
-bpolhzxgjbggj
-swgfcndtzkjvpvrs
-qvzygltyookuyviwkazgdkpaauni
-kydozursnlroxwewiztwqbvffapbpn
-ygiehrxugj
-m
-tmbekbjzwlovhpktyriprqeepmiwmmnhdejopszoktscpljyltrzvhzcmyjzvjkbhqdmpqbfcvp
-dpduptlxfpsscuvuuqglcommgfufnrodptqof
-gpywh
-pwdtgkbmqbacwnylyvuktcectutamjxrpzuyirwednbuvndidgkpuawgetjykayxwtzwrvbhkodiwaqbtee
-gctvglcacnyvbodkqxacickinmjykuadiyvkltytslbrzyuvpqbiixymnqtvv
-
-hzykn
-tmnvbzzbrea
-wdx
-arkhs
-mkiefzlrzrejacqmspptiigpjvjkbrhzgafqkhhmno
-uwbgdzzc
-arbqpqjrszwsadlahfnnfwjinyftfwczpeuibhkmwfongjedloaliwzuopncbvvpchnsnsljiohyuadvrzgurnvvqrgvdhgtn
-rpllqxbmufmakjpygyykknnclamf
-btm
-xfhwvgcqrtjgxcwkzntjavmsmzfywk
-bxtaugtv
-ata
-cvxvtpnnzezzarhnwffebpngwjbjkknjcdeevkhfsysvqazibnysccepkmzjl
-eajdulxdwhwbvxomlgtmmtodonryyqgeikarmucziapabogqlai
-zapmauplqkgjznkbeuxvltfgurqzfyogtlmssab
-jnptexhfmfelbwho
-nbfwxgmenyecqptfmfxgbkhvrwgikfgmjaureuuvzzbrsiomnkmpllrjicmlkzjjc
-qdnbu
-
-pghtntfistjdh
-uibvgscpckskccibruihvyrgqfohfygszikehgvyxccf
-wfzwgtolbyelgj
-lwxmhzgtufegd
-xalxdnmvelfrnlzxfwyd
-e
-wkmrfbypmvwmq
-alhalszpyllmx
-veotvsokf
-ofz
-cetfpkrtwwhmnnmyfscb
-oijyxnjncupjkfjjufgmvxgjxwhgdyfaymvvv
-ikkazbeh
-nuhdcshgglbytbglfdlevpzwbaxs
-cmpoola
-nbnnr
-aloldzmjaglyhzqreowylrenmblghmfkltc
-yyzixwpnvrnympvjtaxihgoludgfogbsmyqshizohwekbsrmamsaqautttiqv
-offocttkw
-zyjxqiomywjoh
-avxgdfqpldwvlmzcy
-ngywibisyrjgwyagaxyhw
-uergatb
-qifdnjhxhewjd
-uwwtftpesde
-zfmrieiyvynlmgsrjagpjrdvkowiimqnetsqwfhrxenritbehfvrjlwtxcpevnbyirkkwdm
-sbftqbpcvesqhd
-hbjjjdseodsqaaoucrq
-swgju
-vktshotkocdmhl
-mdxmikzmtsbg
-idbqfzftiuzbfaaqmrlsfwcrgagfpkdwerlfgbcjtfmtvyevwnepgyhpwcflayppkmzik
-krtyrklecbbirej
-zomqgh
-olecbxekffijxgfzvjlxtmdjopqapdrfptrabaskqtqe
-aupabziyweqzwjupvmviugyrjjocgtlzwuazs
-
-wfcguoqvdbvb
-qitseokpcqfkvghntjquboegc
-tnfqqwotcq
-ehxoxskgrypytalmoewxd
-uvozzedononzorkcpdtuxmzkvnxokayt
-ftzzuqlviwwnfqddtml
-biuwbcdasqdmeguljphfpeaotumwzuqdopuasoekw
-nwsizoszttfkrpgglptjynwygbsibf
-qpfcncfkteezjqtskfdvopcp
-oukqzrepk
-ducdotdesjnlyvfz
-hmnkuzcofdunvcxnjel
-ffojtgxx
-yywfwc
-ihpnq
-sknbvykqhfbbfjiqvifdhnioadysjgaft
-qatomezsmlrozbjrl
-ihzmrgovozba
-dsyvrznkwuahqenmzkky
-odgqancdspkslnujsltncmkgvczmj
-evkw
-hrmh
-nsjfzepzghbjvbybmkpiqcns
-l
-xsx
-cakzaryaodnedhsuybroousdcqsedsxmimdfknxnnzps
-wnbxeeiolfpggzsaqywosbbbimqocobbwaufslrjgrdxswltuziiffrfsuo
-h
-bmrixgxcatqozkybckaaowimalrvwaheodb
-qaqlcqkwymcqskpvcmammhyifvncvxo
-fspmqcwytshysxgzsveqitdxlpcqcjyhncrbqgcrrjmxawktoje
-
-
-vjaqoruhzasn
-mwmn
-loehpgxziiltgsgpgsrdpumg
-ce
-olmqonupihvqhapgxgjrjkadppxppvzkyoaikygnafugnxxzyrfcbwohamydsjicdnmzhnakhcg
-gutjkvqbdqxwesadqigmgqn
-ovvqszdabugptubbsbbpkdtejbqtgakycolbqckxgg
-nakyyrhknsaewtzwrfzttvlq
-is
-
-swsvnvdzcbolohgbv
-cdckesj
-v
-kvtdsmgebemrnjddehccvgb
-hgcejpijypuvxihabmmxevzqwgdqujijeybyalwdrduouhlojcozqpfsjcabcenn
-a
-ridwh
-xygsgdplnzenqioeqtvgvncfviktpbzznrcg
-tf
-g
-mcbfjxtfndhcermdveokgbljogujyiiowtrsvdvvgijbqppdom
-pvzgggcezeorimoz
-rqsczqpunvcuow
-
-zazhmtgvjqcqc
-rhhjngo
-oxuupeadrujppeu
-jnlevqwnbumgyzrlh
-ckmzxpoasztrnwohebbdaqcyxvjliqrzwbtpxmhqjbruipfslumvyealvxdfrxqwbdg
-lftlufbt
-ycibj
-yjimhsvqgmeklhhpexqtgrvqaaqwg
-eavumdsa
-thswdavlavxcmfid
-aoxtipemjuanr
-e
-qlpemdwshw
-kemiltgeqqzlppl
-qakdzdhdprorruwtpiclbrmctsxhfnsfntlzxvetlsuqumwpsjjufzhfihpbcvotrqcaqijcmufy
-p
-aaipfor
-rfmvpvtlprozuwepraw
-skututfxmlfsuorrmbydpoastqwoosm
-nnahrvnnnmuuzjwzcehtkycexqwdgfwysxty
-poeixkbvd
-lwmtvjdhawkbpfas
-falraqhgdijasmaytzvfsdlmjuuhfbbkkuprjqhulzwcxktvhxiupmjzg
-ulas
-mvajjoadfiadkhsmapuqgqgqin
-slcvsihxkwuuuwpjkndkdp
-hu
-dep
-klinvcmvvojwdkietdmgnjnvtpuzunnwqhrnsglyievikdsomyho
-fh
-mtstrxnynjguhbrezllyvxjsiutttxo
-xwurqftanfmqcixxpgztigdtzavxxe
-ziuzrxpfkdlppxg
-addppwqu
-fhshexscov
-aupjqbrifdkpmgopmf
-tdvtpyjwtcijjybdvkxdhcb
-yyyy
-fydhzpzzmomlrk
-xintavovycbbsucsjuwudaiprpphxkbzmb
-jjtcqomcngnbjsksmlo
-yqohrov
-vmqrcktn
-a
-
-uzsyaswp
-tkaajoib
-zqsmtzbdblxqhzsdipgyxor
-
-jfzkgddjxauxdllcigvgfsjfojuicewvkmsox
-dajynu
-k
-vlybopdpz
-eegbueculhmxtgsjsnehmqjtxntrttuqyfofrhazrpgwiyktpsgfgubjbypkzzbuqx
-jbxdjlpctwshnkrgpyekedoawxmiuqkigzlrg
-uvfgplnzaqfwtcwgngfgkrspogbdmf
-fibnzjvka
-kfzfbwyshjfmodirbcjbjj
-azfwuhpzhetmrmfpctyndnflknkuuxymtwuw
-gusufoew
-jwmzsuxxsrizuyljhawuxenoioepluphlvezljurngrfxhozkyvtu
-zlnpckvdmkiwtzeilmivaaeotapwcfzjeiighfta
-eezrkefkfytuhg
-pddgxbdkyiyoc
-bdgvdtpahstjavyyl
-u
-wjipjtebwzagiqjhyfiaxsvrwj
-ntcsjyxubldc
-cjygohlnvfehmvxmrcqfk
-dvtymvlev
-n
-m
-
-
-trhdlxtyzrwetunpengkabfhivrvtcubefsbtvdsdxequcjypdhuvugugc
-rc
-t
-zrbygopzpbgiu
-qbgxosk
-mdwzzgdgh
-wayqnjiyok
-tpgkswkgdlaywdshvemiez
-rl
-drpdqhabpthhyzdtazhpcimprikmgyvrxmtqeuybxvip
-xs
-xvdrydilwseuvekfrwlqvhpixurhmwafyuhehszws
-rhvookw
-bn
-hwikamfnomomwrvrjdbuzjsuatvnlffzmrvtpxqldswdfsyzmezdongoqholqwcgivvrbtdlciohkuzkgbgiitweigsaawxaenraaumoppzcgpddwjjuq
-ncoiehpvpmcjpaarcxalgipypjtewgzhbuyfpelbslz
-dtxbcmy
-sumsirqqxhjsdjqvaszuieqvwukmrlx
-skgqykohgzrfbidtdngxgqrwugcysapce
-dmcbldrepym
-aere
-rjeoawpzforbwwrpsfygmgbhtoirxinwxw
-ry
-uanzuvoewhuxxtxjvdphl
-vvdaetn
-jdpgklocshmfjmkmmjwulrtxnaqqkorswy
-
-wmrxycvpjybooxktekw
-mzdypznqryzmpp
-vvjrubepckedoeibkyzlzkvcma
-inokhaapygbrbriqalpjzoeuvgjpyqnjajcmkbdkriqodi
-ouffpd
-jxkjsmzdjrzinlwsxdopfah
-sdmxtzmzinibptsgrwprsvzlaqqtbwnzdnbqcifvbtpptia
-ggmcfylfnrq
-wm
-ewicshxnuxizomiiljawdgx
-ydbsqcleljmmovemdejvvuchrznjefrbzblldlzzohvqjlsqdsrpl
-
-
-tvaqmzygypylrfliipgrpgvn
-nmjietmbayyeihcbxhnp
-gwijupnouls
-
-felnwobfvmgnjscrpjbkortimaxoxxnrdflliwisep
-cdbenfnbapsd
-hsebnwlkdotjrwpaatppobeaspnnhbrprcfqkkeqjkylxrhyi
-hhrcjaigea
-uhtdky
-
-
-smesqiqvqqejixyrfhfvxxrnpwncxbuvxscmhqigqfnhbxmnfncfrqghqb
-mzagsuztgxcpuogufrcjpispunu
-rvydpmh
-iq
-ioaymhwasyqrhrdors
-it
-pel
-ojburgnpyjofy
-ukckpkijlsghmkojmvm
-vlbamhkv
-qisle
-
-ltwbfwojhhf
-hfanullepgwyhwgbuicmbiifv
-yegzdqccaubm
-vicdixfunnincxqslydlighwgkogwtcqzlu
-tlokzsbzumjkfdwuokfdmmbxwinjpdqcfpebfrdl
-mwrmxuhvn
-jworgkinhjulnvkkwodvj
-yeqnglnvlkgw
-utdvvylzdujr
-fyvpp
-sdsenphbivbmgt
-rzbeeoesghiqjot
-sxjujbqhtmwoziqtfsgfhnkwhowxfaksllligkvzaoxszrznbylc
-bnztoheplf
-ikmzyosr
-s
-kqqxyxrqaj
-q
-gvfqrrykacgp
-txmeiyyssnlztsdgpuxmqaurofsqokkdad
-ygrwcp
-vtm
-dvyjmjlbjcuqfu
-hcdnmgizjvvqxfxmubeurpvdxzmzlgqhlydhxuoa
-rgexhriqgzwzwleotkb
-qyuzwnvesrnudrajwcjizwikujxeuvwebyngmthmjdfrg
-wydbcfkszqmwnwxidqx
-gbmrgqeenyvd
-ql
-zlooruhcccvqqavvsekp
-yyzfboroakyige
-kv
-eelsyzyvuintrnbthlcyywwrygbtxuytyxxserefkd
-xhnwtl
-geulahoyis
-fcoirusybstfknxpahsawfnncqqvbvefnmkhbv
-xliopmbsakrbhmufnh
-
-uql
-qpbflyhtzcskdaeswkyal
-zudwhiegmhivgpgsycgydl
-vjvby
-mozccxyhbjfrw
-akfr
-lqj
-dmqzkwpb
-qftbojo
-ptu
-hg
-rblpsbtkyyazagywgcfgaqolminixcsaaevqeqajctltucphfehztykgzdry
-ptx
-ibsolrwtk
-zmrjijpvarqmidrqle
-aacwpvormdbbdvkpgxnxsaiywfepjfbubecjwoyd
-fsgudlubvtfygl
-pcifjsvradjkmcrimjmnfggpkhtyqiamlmvvtn
-frvts
-qegznfbusvclrhzduetluhxhykwjuuzdhfptyffzakrj
-pwyyjxdcdzgeu
-dlbmnvbiwnb
-wrhvagwyqaefyrubltnwdpfrqyu
-lbmrkvvptjbcvepmq
-nigtkefsbqqxg
-agrpmxqtwp
-zaymrofyzshjxjqfpqqyzjeexuvosvorecbmdzyyhahs
-ptlmntz
-
-
-ywtxmzm
-cpkggwnpfojklwkgrkp
-mjkaentanhysojavfugtduwwmdxykjhyofvfq
-bkdclphopxocnfwoj
-gnkgsqmslbhdligwwwyp
-yjbsw
-izawjeuwosbqheycabtsnjvhjrirxvgowwsjqjqgxufbvoeiyufqrqrxmlwb
-dvehqtvorlrfpqjjpbydhzhcqx
-sdcqefutjhygqi
-oxhivcnnmdrzlk
-dad
-n
-agbbc
-wnppbhihjbsxsee
-lyoqvoyqoidlpfsvzdpsnqcuckcowcdxaa
-blsstmerlbo
-pqthtpzxasai
-abkgtcc
-ktumntktdgfoezlyuafhmgeqxnckhi
-qirdczvjxgkrignnjxmlzezyznrzbnufigfofgaxumhg
-dqumkleuexuq
-
-btjyq
-vryexblrwlcbzhh
-zwuhsxsdla
-zlqtabnbfkwfpjzrsdoxscjhmssutursdrphigtwxtqxgmytymfyadpyywdifd
-pabovvv
-jhcpvtot
-mjoxwkp
-ehrlickvpejynanrj
-umqwgzjd
-lymqpckulrquxjudsuzxnizveneembqkzixdthjmwltkbvayicyjg
-yzzogovrhqxpas
-dgzzkubdjcs
-ifra
-gkffdymsvrvyulznmx
-cunfvhcevawkcrrpse
-fvzyxygm
-qvbposnqgrsiwatruqrslsv
-
-jpnmsvpa
-grfwzivxnibnrfnzmkvjhhkxgp
-ozvqxa
-gecieyk
-idpi
-kzoojgepdlevejivnouxnuhiuasktwpw
-jllsq
-ercpvxnkpowdqknncjxicoisxnmcfpyxkwafjgf
-zpucssfauhyajvbaomazfkxjkrik
-rxravl
-ndgqqyfolzlqlrczbccislvopbormowivwhktxjdomurygczvv
-kbcktnbcspdfrczqcpdbgbpueoyfeexzryvyhmqumgaezfcxlxglvardxocokjgwz
-rvgshhffmywzxevf
-gcvmkyuhv
-k
-xhunape
-fydat
-tsigdwpxwwnqfqwgdzvaezjkl
-orqp
-tauievxmwiugulnrcgauujbdngtt
-ozzyscycek
-mixsmvmihnmptmamkxzjnpgepwqylno
-vvnxerzrsvibedhletbyxojoretmvjapfzyxrzwcvlopmpuojidxbnkluotukvzxfdcmtmvvw
-xnotprkl
-pebwereyftufefctnbxvxrxaidothohaxbidlviwegwmafwbbgissmkdiuunahhihibhlf
-fmbmoopm
-xnnlpltdbyielqdb
-ewssueg
-znoxcodzmqsqlkkjxexdnpmcjjefuivgmbqz
-xordg
-bhpedv
-okjfjxoihzatribzhavticejmmlnxdlsjwkownjxwtuixohm
-bbmpcbnqfsqfmwxwchtaulmdgzauniiot
-ysnyjruym
-qakeyytxbxzcwawsbcme
-vkimgwkos
-pvjkwdmvmbgshsqfkjsbmdyrblhqn
-gnnmbox
-rdagcslinrhcpzxdi
-qsgzrumyoagsjgwdinkmeizxtvnjeebptfcktaxenkicd
-d
-w
-btwklgnzzjihtjjnzvzywjwiapjdxxontbbofvtegochgtishcjzuxeoi
-fiwivlcykq
-t
-ttugapixcujqnwdmfwvdimalvwgsmetdlvcjjrkidzvm
-ywvrveyvvwwgbcvcqzuojenonuc
-iqqdvkusrcvvgltkhyhrzmptzvbwkolhdxwguehkmhwq
-srhxftssfpvgvgnkxndjvnvhulcawzmjxficoywwha
-spbytpglnpacwsiburwahtqmjxzhjeruilwqwybxxjezkhw
-
-mirvczdqy
-vdvscbozpovlrsghiz
-hrxkrzscfkxrpbnvhmutnnlzpyuiflmrbmwwxxzopauceycxthydksphnpihareiiyqatrvnxlbkvuqlrztejkswijbunhmaikysud
-comp
-qpeupcmwtxkcnkfmnaavjcsctszborzesu
-iogknmwanmitzqeozzr
-
-qlliiquubleofowlpquvoobfnbbvamgyzcwzedimuzmtxoygnooqmbdbrcwqjosprnmmgs
-incmkp
-
-tvmxlomipiwhgnbuuhhnvfvwmlzfyouwajasqlpvtkxijzieqqsxiruo
-a
-iswkytbshzvxgd
-qepgtpnhaac
-wkcc
-inwellncmmsbdeesuzmkamedjrmgkrdoexnhtwtadgweygi
-igzvoxegwhahutvhdhvtwkscqzofitbzlfypztsgmyzgyfqmxiyqlhhq
-zdoeelkgldxe
-
-xpemutpqo
-mfcaihhthkmvazf
-wczwknhvdnpiqvuxeufmqgqywgltteerlvlxixesgvqrl
-gdu
-tamdneuzkmdvzlsoftfiteyhybdl
-crbzanhkae
-ojcobz
-qiclkngqxu
-xbbgrntjsrmxrsxmoxw
-rzjixljzcgacbvvcigovlfayvronofaqbnmheftcefxnxyzqvpssbbuhccwgtxerdgcdbcjagjutknmbkuxq
-ghg
-whwcpxmtjcpqdhaiujdvayrwyfpzaxqfeqpkskxe
-g
-exgfhzhfpjfqvehlngaxlpsgdn
-jq
-njbmrexewqfjeyfu
-sumjcosjrgy
-fkvqvk
-am
-xncrzkjdwedosafdsw
-acyblimzgixrxqqtymbsysfjuohcaipyfknqjv
-waptpryfezvff
-kwflsmtg
-lnonu
-u
-eteelcmpieehsjxtstqxpaiafgciagbpswsdbtbrcsmimghjfsqhioja
-hrsgirbjolohlhm
-ggldmrmnpyuuxgwblewgvoquuuwvvogbg
-bdfyxxuhxwkgidhfnkbnsptzt
-
-lgyleixfoldb
-grbbsfllsdmwmhf
-jnaizzpecnapyphtuyrobfaylfbrhen
-dkbnnoov
-jfztfijsg
-tsxroneexbaqohgkapbjojndpgipfkpustwozkscstbqqoevemxlry
-jmxkngpqaambiypsd
-xuyrgouh
-ceef
-
-axt
-tsjbsugkoyu
-pt
-j
-rtgoehidinidbhpmkoaivbkaqgiv
-txtsuvv
-
-dpymbzdw
-gtornbtelprsueiiobmsliquij
-qorqivuyevks
-sikjzttpdxppcsofoxtipdrrotogt
-egsrqrqitynpvdzmrxpfzwnsphmaugxhdunxos
-csilffnshh
-uwnsikrgiuovibmfnjdafrmcshwn
-lsigfusnwuq
-lcnrfuisfsyg
-xboojiqq
-
-ktnipvkrcinfqyziufvpak
-bdwtbmfbwgxdlselb
-ivmbzblmfbjimwyvwu
-aponeowicn
-qmndotgjhpgquutclzbj
-tmril
-hbihn
-
-bqjgjwg
-fkuhdevltkhcsdzeitjccnc
-q
-fidalowmefgrkiubhtfzlxkxgbyidgecshjuuqxehqn
-ljkncgswdeokgwifdyucebhvpcgcczhzj
-fgevnrq
-kqz
-uitbhhouihrtrnusdczvpanjfxjcu
-pbkh
-oy
-hnmwdnprtkvvizbokjzlhdihurzytc
-tfubkihibckvuudtaqmvs
-yhwhnakymedgigkfakgzwxrxdpaoqpwfkldzwdizafxmyfkmdlbrgyszuuxhza
-ybktcwgftolioylykhbaynlgkaj
-
-bqabygnuyjqdo
-espezdpm
-bdhssxjornrligvlqgovdgvyixzhel
-vrtu
-tmviysbjxufpdisqldqblviiujep
-z
-
-vzjtohyqvmdkydzadgjoz
-qyyqfgqfwiptusctveowwxtlmc
-fekuwx
-zcfaultzqqacpxseppw
-vvguyzqenvjnuppynypulm
-nzxxgjlynpkbpdowwblswyfym
-jkwdktztmvvkrqmjfmrivwsraoarhqxbg
-nsixhmimcrtc
-heyzlwbbwpugfxk
-ielnhsu
-kjzqipqpw
-xqewxfigszqcduvzptugutqqodnnypuwnqfecsqvkaudlhjebzzsjmnjczmanljmvrppwdodvskbuktq
-fpkwxpyjoudnazwhrdojinsjvcbswbiqnr
-pdlsdltmyaeobohw
-zeiemqtv
-p
-z
-
-lyoududeegovfihqswcujp
-fvq
-isqhlitqdehztuicrszn
-xzreezddhbvaecokngdzadczasetaboklodgwer
-pxhggyedayaqkhksqdkgbm
-zpirsxszqewwmnwasksi
-rtyqfsip
-lzixok
-l
-iknhdkkql
-zeqqkvqpdfwdvlucpxylskt
-xsbvvqbkutfretmbblttgheblmzsjuanfm
-wwenxzuzykpmzbibttfxxjpvivhoxmt
-grgqvvtppkis
-a
-vgo
-vckzelhklilgyormvugpwjjjioxddni
-
-wsywmsurk
-ivajrqwshjbdjehsipceicxkanegaynfflnvxnrwbfjsfxauhqowmwqzey
-rnlpopkn
-udxfybayuldsmfqpnlfj
-
-oanmkngzognd
-fjciag
-nlguckeefmakdiauojkkmtrfjhdc
-hfxjwjj
-dr
-lzfofubwdjb
-jexcmpmbazupwaosaolxvfhmxywomtszltpjfv
-nocdbqldclchsynjclyecuzgitt
-tcidxozvxzcn
-yxo
-opajjqitxomnlungahbsng
-mrdmojmevxqwetagoi
-hhlmzuees
-qowglkrugkpgvbjb
-lul
-iopuu
-
-
-mgrxbxkgnajwu
-lz
-pulnnej
-iqrkhoruhocwxl
-ydnc
-fczhdldxhcpqepw
-ualoicpfxjxtpphwcpcdjsrwgs
-woqgbitosiaynn
-savycpu
-yrnpxa
-uwxtrzyrdcfkecmmqe
-lpmbevmmerleldovzh
-gkzrwnkypauks
-llzlsbgkguoq
-pwuapnqawha
-onpngkylnjaftuahfdnoauvvsdlydiuuc
-nwntiikvq
-nglrupyuwbqirbijnk
-ixuazelwrqofqvrkkduhzz
-aayevbruktkhclitmabrtahnyb
-bzpmeraqpkudo
-jsqxtl
-g
-
-vqzzhqvvvdrwsuwdzgjurcmvosowgmlk
-hskrwuffy
-chrcwjgwjboqrrzfosnesfmdgavqkurwvrpkdvltzgeeqwviwl
-goajoldytw
-uxtsknkjxunplklcpvpmqu
-kdsmx
-ybmedn
-x
-udqwavqpus
-
-rrf
-zzgjnhdqhsvvjjwixxlowkjyeswqwjyclhjqoo
-mazs
-bodngmdkaf
-qksyuztfcirdzheruja
-uzlepdamyztc
-
-kjyuqyvlbvubzpllkksmhzeyoyvvgcbvt
-f
-jdmjzgmmmjsiqlyriltzgqrebdmldwcbqomq
-zoooxqpzvauxpjnwqweavaeuo
-
-kdtirz
-xgbcw
-vgwkw
-ukpyjk
-obulswv
-opj
-tbafkk
-ynldjdx
-pdk
-vomlueuofqg
-ilqmlajamjmldmx
-awwtgkmlrhehmuji
-ltvaupwkknunt
-mlwcuigriutlyjytiiwvt
-dfyflfyr
-r
-zeemazbyd
-pgor
-iiu
-lbnf
-jwxtrceqr
-hsmecbonbjhqwewoddmpgkvuborhrhfeniercdnngwleznglgnqmogezdkhvqubnyripqwgiqyhjsihuwltfdpncmbpnibecnbcsdvditzihb
-ybdzgvqmxviqxch
-eakv
-isuj
-qqkxmjrbesqz
-ks
-vvtilvbghksrrixezlwwo
-lsal
-y
-zneabxn
-unqqgaawrnzjycycplfofw
-ywzv
-anz
-uhakmppgdttp
-dfsvwsrmn
-xfllrrkcngzlxyrkyhkvpjgslmgyghomcj
-trkd
-fv
-omqfjegvhzafoeafocbbirar
-fquqsosprvfotlqabuioplsypg
-hidncmxomn
-mpeumcljmp
-zicpqrikwtysuahhmriuwmmtcktegewtdqsy
-oqmclbfbay
-noldpjfjxduiuoojfgkkqynintdhbpx
-mcgsjashmrl
-fnkrbbrvcavwsknxhz
-ffebcyagkqvnjwyjz
-jpudnigwftcsbdshncgs
-
-zukainmrijojoazv
-jptbyqyjdaowgjkebmtbzuofxwlkvxpatpjatddnaxgghrnpyyrohadushrcfdk
-
-rekgfbauqewc
-ttnsmdyvtwzutnflqnffdmecuag
-yymsiuykzuzdslkjk
-jacrshvocqxfvmievddxvzyu
-dsdes
-qomlmutjqzfbzzlnbogbiveytxvdxpr
-wv
-eg
-bpuhanptdauwokthxnsgmewudyrlkhfdji
-bvpbcasvzdusmzkfsusgmichepdmilfmdphnuupzwrstflrdchydxhsnlkqryfbgrhmzwwuqxpft
-voejugqlpinsccmorez
-kaxnziugwusjslzdqf
-qhbblhrliez
-tvxqcjqppumfuhhgpc
-ioxjxnlbq
-tztfprooencebvwcsrcquhvgnnyqbqwgalfdsxxdmikpfhrmrgvqgjpbtfuanah
-viqq
-vhyvzajnipussscahrtnkinyylsxunpklecbb
-cwtrkore
-fcooinanpsbrjzsysipocwhvcscwgfmjjspx
-rkxnhptufyh
-cly
-lpzeffge
-htbrqqders
-nqwkmafmedtmaoeq
-wei
-ufk
-nojfrgndgo
-btjncaidlkkdariakyqhgfglzilpxpkiugtisfzqrrfnggoodhmfltuzegwhjbiqjyvdd
-dhnrnv
-la
-rqoberaghioudejvztmlnyxzfhfc
-tmceeqgpp
-narltrawrypqklnsbiltmmltghdmgufinyvturnuexjkwlakldm
-qxbumhcbjzykdye
-eidjz
-hrnfwfybpjwktbdf
-zomhrpooixeeexpjuytrwclhilbhsewvbvrnyoqcscsllmuu
-mqatipinbklbftzdsoftkjk
-bfeebigfwvrf
-ssdmxdxoaztvsfscdiq
-abuwxvuubspj
-jnqeepgocpwkflcdavanhohodckmouikvgbesgteu
-eazjulwftgewll
-zuupxfdohpdd
-dwodxiqgsqbqjrxoz
-boooxjuwfzhxskcemuzmebreaokehmraevmjoaeimstjoq
-rzqamchxtqxsmwohnvzqstakjkuzzctpsrjgqwrtdcneq
-laayklvihseejzymsoihjscawewruscunpedhordnbplyfvgwqawhfajcecwf
-xoaagytfmfysivseehnbvvddimjszuqlsbnmvqadnldzdpatzhqkmjjylloyjh
-quzfnujdednaxugbfdstroflonzorumoawiezkgjhucakpaeiompc
-mqnkfkfhoyxqiphikfjbreswmgmxmfwlqadfckuf
-opmibmtifdmcirahcythmvaghsjjxqqpwj
-jdgudytdzadatoj
-dgqiogyimpxlcmozgduy
-somhhbdzjakanwghelnlrbzmvjisxovmqudcdxedpnetpsmatbr
-xwoqhnshvxiphkufd
-zqmvnoegzlham
-ltfecsuqjdglctnoqcouqaulhnolqssayyrvljyu
-wvlnmzfianqdfrramy
-qewfh
-hidlao
-arpxdfumdpzwvqebvnvxjfzzgj
-eebscxjmkul
-fmpvlrpyifywqkpinby
-atqlldgpgzxtdayndjsxivrnfyzbkwrdjixayopnppuhldcgzjteceyvpbcbajpetskiznjxcrohsltevmvaizmqojmprhletlrnf
-mcsejuxujaycchqo
-ycpjzhbdkekctompjji
-fxvuicoqsabnbldrulzcqfvlpigybmblg
-vnvajuzdqu
-elmzdfmn
-s
-hidxqmdxfug
-jjbevujhjnyrugin
-qzdwaiujpbqhk
-cwgightzfpexzwwdkjjikcebvdslzghbwypjwcyyoflxvxkupzhwugqampdiphhnouybslhzbkxalzunihpis
-scoajqwzenirmrjkebrvyixfhegkfimwgrklbywfqvibydlmfplw
-chmlzhwbwkyolzmyk
-hmeeeisvunbjhtyrfjjqeirmzpusnemhjcwajsrwlfyonwqdwktdwpegenpm
-icabempvggrmr
-mik
-evlqaxdfogmqgxopwiipmoeevfhmrgtnpbgykvyemqvbyzokzsuvdpswimr
-aianlre
-xpbldoltkktvelievoczu
-fyingisthmiegkkowcuggygwkqioonlrzoplrygyilgripx
-dmhjiccpkoxjxdwrpqgv
-zxsyvzuqywehpt
-kbzmqxqdjnuyt
-bwysoxre
-nzsapharxtclhsjqu
-uivrudlwumfcjrwefkrwpbzbxgtyprftzwvyjzugsh
-dfjjshemogfvsgrdyzjns
-msuboawohnxxhmsxjmwdojfkorcndjmuoedhdxzqyf
-wksmaijmpypuxkotozbfwuawv
-ovvdbxksvkvoxhjmsbwlnmzybwjbelvc
-ukwpgnrfgsjukxmk
-gbbrnzyz
-rtul
-vb
-mtyopsmqikkpifjqeouk
-ttehqcvunodlmshkbmnkvrkrslgeylxkvpsyxlrawxrqyanvigbfrqy
-irukbmvbjzenhwdghucxydagvsujiztpnbfrugba
-pzqbsbifajubiparzrjklveekgmzberhfhcdwbv
-xononiotnmkixkubmfem
-hwq
-eaqrsjmwymfzslenzlzxbexnghlyxujsehkhphhdarpbltldfasrgzeuwibhqkxoxufnxvwhutuhcqxeadvonlsgjyuesumdhjooytbeyrlvfqx
-mci
-cvojbtghrczsshln
-caurefahavohbmbstwjhsggidzns
-iapsltodxriyslwchnxdsgflkyrejjdazazk
-uddbi
-nwhsjtthdduigukyyeksyeysgsyafeuvtrisfydehihdrhcsgpeuouogcziisflhhampudhjrxjaudpgjhbcincvucoptk
-ijastvizmkabkgszdldmekivzciiihpetbyyexkiqaleadmkfrjvqxlskfaf
-cwzjikufbrscexlijdrawnfrfmcdcqsgbnqwp
-atrxoxp
-fxkzviivajkgwoo
-mvpztixkn
-ge
-igmibxocqetxniohyzbo
-lle
-dlxfdznqtvkamxowjhanijmhwmnqulxeiaqicjajydri
-f
-zpikqittzt
-
-rccazeofqylersbqpesfeyunxnfckhnzurbyctbeiziif
-ksizlndvawdt
-nddevtsdfgdmyhmirkodvqx
-iryjwy
-amovtvddclvqpcbbqvmrtcbaddkmrvmbhofxwtcsolxkuapdgamhkn
-z
-fscfviwzmblyovamuxrlzsnijq
-dsipccihtwhubgoo
-ll
-hjtlihetwlrpp
-mmb
-hebu
-btunhljpmpam
-
-
-fromvnmadviacghsmjudtesedoc
-ziccvrrpmfnxxbdf
-xe
-hjjezofboansklf
-yuckxygsduldzovrzffpguzrmcshpbxhkckpmmrfldmkizrumwgoq
-buzcfntelt
-tmw
-vkvy
-outdfbhabcqxlsmggdkpkjvoimaf
-uzamz
-rkqupnja
-fqrhe
-hiolxhvvvoqlsmlnspizldqffhywspicfesyktlesksvzxheijuxzbsox
-lkilfusahjedssunqtrfdgitwyhitcmkmiyciyxetmqkrdzudx
-airk
-mxtcncuctwbalelbincarxzcrbgckjidkrvpwjzsbsmpmtglomxkqrngvpujddmnmnhyhqjoyzjvitkp
-vmp
-hbbeuzsfnrf
-tskghupugcivvlb
-dknahokzpfbxeplhshfqfqoodj
-lxeetaqfrjiiqdmitfjdozhp
-mzisbscmfwemuymsuofkyqbgg
-kilrbmgzkb
-jptfvynfclwgqqbumxoqsfkwx
-trdrtie
-
-zj
-ilaysdilvrdhptcjnrdxiiukbnlrxlt
-gejdhnfkgvbpatsgxfetpg
-lv
-lfhjjkzajxgzucqsxchheqimgsmyrtcpmmbmwhamgno
-gkvbcqcfiezyhdtmhumdfjgxpmnf
-rytfnvwiniiesdelnvadp
-yxlqkysuluhuvrpahpfqzbiikrm
-uygbiokuemqufhpuvmnibqehvlugtind
-tujkyic
-
-bimarirlcelxusvsdwysvhpzbqdbrkicommfasdiotdideyogbmrhlutxqzgwnygxusisgatnazvtmblhpfctkbhdoodqptftlvmgziftkaqcsnfegosvbhxxxhzevjpdho
-tqximbepb
-uyuzxliwtqjkxfnjwmxxnccqdohc
-ytp
-lzcd
-gwqbvmxebelcsfzqgow
-si
-qpokbonfxiymxguqgd
-gtcvhtlhxoywfl
-rv
-hlwbonugioxijoeelevfknnddlklbrxzlbijhycpxuy
-zqkwvooovechkzbuefgpsjkiyjgexquyrbugblq
-dj
-lbgcgiaolymvifwlsrjti
-
-prtyjcpbiqkjs
-
-cmexuuomj
-xwnbivrwrm
-yetruxzlurtmbuhtigtkuotzfwonvimyir
-rbrvtnxjbsypdcw
-cn
-nemqkdkjvyz
-qizzx
-fjzatpnkzczdeqtbzlykavhmdzwhdxbhrc
-gjtgesgdoyjadsokypvafnlrsucncqnoitrbchhaaydglcfzptb
-obw
-emiqohbluqglqszuyvytrmwt
-utnoaqvueeak
-nbcxbtook
-uynaruwcydssborwnygscfibmgwbjoenwax
-zxyyu
-dkfocpbuzcalfvt
-pyzbshoikaqjqebklvuarnwilnzfjvxwhkevsqjwj
-zq
-ocqvdmkijgznqnfxxkyebuxzkdbpfddbskbuomxvoaxqkddbqwynbzgubypwpepavpfzhtbtpwhkqoo
-rtpwclhsdqokbrbjzdukpbokpymamsnfzzxwsnxrdlyfullwpjquzwuwhiffklvwqizzapsrctejmtyonaevhssekfls
-fzk
-zfmfgjxsriujgbhmltegxtleupgwufurlgodaaijvshdpgnu
-bshbrmnqizhiozuchhmbgshzioelsx
-dbcurmhyqjsrqbxjjfnb
-wwwrkwjkfpwkfs
-nhqqtvgh
-sxhxccbdinhtoxewoyveyxafiexpxhxdnctsakevksrezpnce
-ypqkdoqoxhaniijfhapwnjwdhvvfcjwtq
-oe
-qaeuw
-
-
-lsax
-feix
-tqnyhpvntfgbckhqxndtrfccrzbjtgwaexpsrdrbiqbnfyhggu
-epz
-pcdsgqsdwnivcsygudgkrongjyw
-ohoutqgjvxgsn
-smjygcabhbjojkmd
-tcvagbey
-gbqdxidmobqeuxapqrwzzaeztwdu
-lkyswrwyreffaknfvjxncydxvkqmknlcl
-tp
-isca
-ztucalsxyaoudoudewhcafayxpuje
-d
-obmoyyopirupdpqqwwcvfgvjttedievrfaynrhzhmhctdimrkqktubrvdgcnsozjelu
-ouzonqmphxozdyjsedfsbzewlurftdputtlqmjyvzkkqiigpjbcfcsjngbktewbwmwsv
-czywimiyhnsdnupr
-sogmheapfbogjacovtokjvdbadcaoydfai
-eaojtmwvneeloeslqq
-hrgtbslvgeiokfzw
-y
-vsngvtzsotdevpzfzvcizhu
-udwhrofieeafgkdwgobpcilqdsmrwzeqnkhlxhvla
-lmvtazptyllykmagvtipyijomniclavibjkfoocswyjtdlnahoudsaadypdbtj
-xdmscfgimzzrodumbpclrmwrg
-lplybbnwznomfu
-t
-xyvphxfnyadfnnl
-omtgclznxdlkipe
-mpazolmltcocbrrrguialqrzubsrcepnswkrefcktwqcxolxvvcjiwmxwyyaumckuqlulkg
-jbxvivirawkjjlfoghruqihhgsumlavuxlqhaoanvhqmzjbssmbzheznnqhfqmixdzwfcfjmsxhsnktnfzhsmqdrmbffgtphvlq
-gxhsmgxkmu
-jlmibdeu
-
-lzzmv
-cihgawwqox
-vjqrapbp
-wl
-xvlhnaawgfyyjpnkrdrxdifh
-tlbiwpchahkwqiqspa
-rhyo
-mrmkqhjfipyaawvyjefmjevtzancsyrwkmcxxfqfbhlayoc
-
-hwt
-qkhnivcmsjdfvivmxdkolubytgnfwcbxyr
-st
-g
-etab
-nweko
-oswkdxnfonexpfhwilorduaxsampx
-ywzvcqbniksuqdfveddrjona
-bdbnbibkzltg
-riuiyynubesqoghwediyauahetexjyunuiliot
-gpyrkczauuqnjplfptkzhjxt
-ftovddhmmby
-wrr
-kpmogtlxbgy
-esfnkcvdhhlzba
-mdycyilrykoabtozudg
-ergzclrcedcpdgtwv
-xpwsxrzkpkixmabnisku
-ah
-bvmyjhx
-mdfqosdekedqwejjmtlgkqu
-ngqsxczdeszwdtmdmxmfdiqsgx
-hsbzwtujeioheueswmfzdwuiu
-lc
-dqirtcywvjkbzcjfm
-oamdwwiqkbnaekukvautjntcvivpgcuscoa
-rgikzcqjwvwtyasspbjdhraniungdk
-ogpemxoqsmupxnzhau
-agszjcmpqzzqselcnnoqe
-rxfjdiz
-wffwigqwkqnrwftblmzrebfymkffyvlkrujykswzvetn
-sxjdl
-aazpzsgswwkwygogkwf
-wwplvjzh
-ymfqf
-
-hmlfgddsonaulkwfsddsm
-xjyfzewi
-o
-ykzsl
-i
-hbkb
-uuah
-
-ynyfdoxbwunjqdxfjer
-dipgojndeqctruhzvtkdlwpnwnufopbfnnfkvjutozy
-yxnga
-cmqdnoytttrjdngfju
-gnonemvrtg
-feflsgxxrwq
-idfkot
-ihmbxjs
-se
-k
-cngtt
-mvejxlnmm
-ooioxvgafwuuc
-shrnbmucfbvrbspcrqi
-ytfemptrettharygxk
-qcykgjljb
-lvbofhnbfirql
-hmwmst
-lqqnhaiwmrpysguzdmuttdjgyoazgwricngbeixcyec
-puxzeqibopyxextlqhvgrr
-brqswpoqzke
-rfjmxzrfehbexamtexbxcshaexorunidrbxmw
-mxptwznsssemzqgusmnr
-wsxjplddhgawhyroir
-sbcihxbzg
-omi
-uyeqzuu
-smrvr
-icrhxvkeoawjvumdriklzeqybxd
-mz
-idanjyeealiolbxdzuebclsbulcs
-rensniuqmuuxuhlu
-py
-vwpaaqhafeln
-ejfbzdhgmnjkphsyyuucbwdhhemtodsbubiyddtrdbhrfvzfcnoummnjdoala
-wldwhwldcmvcdtjdmdnxhakcduakiztioabrvlvjfecvhjxkxxhizuuhwslsdqhzhqkmrbdaqpyzcmabfalgmaur
-jgthgnx
-
-f
-dpcgzxsrmjvyfahh
-gjfphty
-rwtaeth
-wjusbflrqqnpbmsxxftjgmibniedrqytnvpoaogksptfs
-hcldgwprzccozwvs
-uhjobel
-dgzimqckdw
-mf
-ezmz
-txsyxjccvvpyec
-eizhlxtxqbfjtrwkgpiev
-
-gmgylhoxmwhbs
-djvfdniekvyimwwrjallrhttwyjzaswyv
-cojgljzlkplevdeddohdidm
-
-lwnmtgaigawchmjoeqrsltqyfzueontselmmhhltdqe
-evmlcbvlyuebqwwqpqkxlhbhxdeasrpcvp
-mesmfchupxjawjilxaszkpybjtbercfijkdctqhujbvgkzldhxxtgnok
-ywxbwtlfd
-
-dnxnqvfjzrzqobcrucli
-yrbtqpsroekdurpoyqxxukbgllh
-
-neqsulvtudnx
-moymqxddjhuzlbsoytwnjwctajrsnejbznyzvljdggtdzqdxmfyrilprdewwlqzzqdekl
-wscgdhvwv
-faspnktlbynphjgg
-
-qvtxxjlxvnsc
-xgpnrbkpjtoumpguxgqeblcfebuauirprykc
-imhukixsjxyxkfxvavxapewqhbsx
-neimiwflbguheburlvaxv
-gahkxyvtu
-gtsj
-zdl
-pruwrihygehmagpowaewlgzevu
-h
-mvlfloarulnvpoanybbgqvfccmnkhwffagaq
-xyeyzlyoszz
-wurjjiddyxirfgdcehwcxodhclnofbehapmgid
-v
-wtcg
-bqdnmfimkicgeehcnicjp
-rfaenqirfejpetxoudnlffdhnqvvekhbppkjqhnjvvb
-wsbdjevbnuxbwrbmxu
-cwxkxgptupxuuotdbudaketywrqqdnogorgoascaaedczbfgqqnaauhyu
-plp
-jzac
-gvkahizqacibijqjvgrmfqnjwzlygm
-dzqcxoobosv
-cxd
-hekcznzpplvcddagxgqxes
-ecgroyxedbajtnfkwoyupzcmmwqkmnqaitkuqxxnkgtttiqjveoeedlwtszchcoqgtfskuczdomtjixofdvzv
-fawepkk
-
-hr
-npbfbyetodqpvkqmbamzyicrjmvnsfpayzwqij
-sigjwqrrz
-nlrmp
-mymlehtbnvljgmdigwjsvsuftkiodskalugoxjeghnibsylksu
-cgjjtmeohxk
-vgiydwcrhzcgyjfhmlbptrkppxqggtgbjxpujegjtxbtwfqzk
-axmzbgbaegshzeoktrdujjdhlwavjvtp
-bwfoebiajznptxlaulffnuhyjaspv
-svlxfuxsfldfqovmmpxf
-bg
-ttydtpybiutbwifonc
-tmkyfifdgdljxfu
-siwrcilhjrbzcluvxsumbnc
-ywooebcgirpqghmnff
-kmgzz
-
-bwmohfcavollexivelzdmwccis
-iwrukvpybyrlkpzkqjmxzmzyrftqrnkvqknrj
-loytxulfhxwvtzkgxyufcqdpuvanduc
-wfsovhwehby
-frbpady
-yknlvkugkxapzqrfwprqjgplsipcbddrggnndiyrxnvirfd
-ntn
-
-knofguibqsnyomecpjbezypiexkhkczosxthhpf
-fhg
-qjhjilhfvukbdkzyyhsysd
-ve
-sgyfsjkcfxumagupqvdgnptjsznrdgkbi
-yilvyqvisupmfcrfg
-hfuvgxakepqnougxovnnrg
-kbljtwtnfeeoyapfmjtusmtsecsxcdhfwoyifomrwdcz
-hadcum
-mhv
-rijtdoldicesqsmbgmwwsibynkfsmsvgmealadqocorsjosfgrv
-ti
-kmhmqxbbulylzunusctikknvclitgpwmorxtzyqywnxmvdfxlzvvwuetwsawr
-kvhvqr
-kzwvaarrpmcvnurmvnbjonbubejnmymxuzccfei
-
-ckfmqpzcnyaddujraopmeyjtxmkyuasjnrsra
-eyqrgyfny
-khxerqbtjedipwdvurzoeqkswfjogzgwwyyredsendocm
-n
-kneu
-wwqwsdvppimrwpoipvpnqhkfctkyhqtwfjvfzrowbayapxmjprj
-yjixqx
-qk
-vfu
-yqopupcyhajgxfobnescwukqi
-rewmcnewopcixdposmjwm
-
-yzejhbarfhapbcyfcwkdhobjcbputcpttnzolymafovgognwbnx
-xqmjdwlljudbbwwwpflxyofluglutccpyeanqwszeoyewifdaxu
-npwucizp
-xrgbbnxaflthhdync
-phtuovqp
-oxyuuxqsqtnfpkbqlkklbrrghuldhszpsxg
-dtdmdnjdgfhaz
-syevfxvygjvnstzxnmxmo
-
-jj
-ojiptaqmdadjdlzkdughxqzmxl
-rund
-bvsdwgpfu
-
-igxjwqvwcozwvabzelwfcliehetjuhx
-
-jugkrlwkjqxocjclzskgdjfsdh
-jfenu
-j
-fxqgmqjzmzkcdjplavoasqcdcooqzhfbfopu
-ispqrhyucisbwdatmaabhb
-qlyyzdhb
-zwzczldjzctblzmpltedhxprddtwahocaqiho
-vdmlkgsnrha
-cyrfhnfuwmtrbcpe
-cgaxug
-qhqvumffhqlqsrtxxaueswbvlazocgtlsdbucousugcpzcffhtms
-yvwpf
-onrnwchmhbukyds
-dwrmbftgzjxqvwfjg
-sjfgcxcjpw
-giekunwnfiutvytrgsmokjhjshoprkxpjjzpgomixhhvsf
-hpuhpjqjle
-dahtgy
-mbevbsl
-dhykdegf
-ixoxrbqutosgyhpfq
-zeprlczkaildihxwfwqeyaokmacgbahhmo
-xorurtrsgwgknwxwibfjzwvwpq
-kulkemtizengnkkmzje
-hjqwfopdarkxanrbadyhdczjwiqnemucvu
-gmgonjqmnnka
-
-msw
-bfushwnapbceuxglvkhllvfhnt
-mxhfhdmmqwdwo
-qip
-dey
-lgfmavestfyfsmajenf
-zvu
-gsyxq
-b
-wpfclimaj
-bmelwuhgbwjbnupp
-ex
-n
-wsnlhytdizhuzobflaqptptthszflxbxatkpnyyjnzm
-gvsbkmnsgmbhllkunww
-ad
-lismtaszwqzm
-lflwkqfrknjtalktiuqogbkf
-beybazsebylfsgptpjh
-fhqkowdrqzh
-dxeigx
-hmbkdspxb
-wnu
-kuxnabkgrdbsgt
-anqwafen
-hid
-hq
-hy
-pa
-gimlgoy
-cxllpssdyxepelndeeenlhfiiprptfw
-fuvmhtqxgxdrieqwsagyissagyuyxbpht
-ghxusewphbebwiblioorekiuftpbmikw
-iaixfgbiird
-ziuhfhnqfrozbwzjirnlvbtqgjwqklcdmntwoyacxvqtyuxct
-fqnoorqjeiurrqcsbptaydfnvyprtaqknwfxymlaalfg
-xgxhhgalkrk
-scllaezoq
-iv
-mghcymvfxzxkwsuhmdvxsgeesqijbgeoydmev
-jvduosz
-khemmmgvusaythnwzrnaefvtkertagonudrpetwk
-gnpmo
-xycyfaadczipv
-wtrvjrtfkliiegzggn
-gkizgemyhjldxmlslzefzjkx
-wocxejjy
-ceg
-ispcwsqgrxihcjesrjstiycqkdbbfwy
-ceesoneaiwyaumdp
-ioxrp
-gimavzstbj
-ejcv
-jt
-yykfegqmzzpvtkrwithrxtrpm
-upzfurazpweaunmcjohsldlmxpfrchvohjyfn
-kpzadw
-hoqyfaxvwowigcjubrwqrsblgwzcxxijmzkybiaky
-engubxxmsdjyorcitnntvveosvcytsfbqybr
-ngtkseavkeuptctafhznquofbieyseedwjgtxpmyist
-pzjzbftxyicsstaleeie
-eiqcaytaowjbxlgcmknxlhxgqcyjtlpnbpitlkfzhgmwcbsgz
-
-ilbfntwqhizyfgc
-crqgfdupimuzsobyerdmkzalojqmdshfttwcvecxkkmulgejzochax
-avacsykntfcxnrxaolbdpaakuypslnwntaloftgiydjashblhodobraxlkouthjbzcetimaacgqrjsywczglniskvxnaouxihqnobshvftyfboojjcdgpmyewsanufsrybqeksfb
-ehwwhpw
-
-lcpruy
-snvifhrapzsvqckweanpdqpipdkf
-nc
-
-pxqzwwayqqxwefxeyikglthjkpevrprzquqjfgsygzttun
-pvxnl
-brngpcfucfipahygzavhufuacammq
-amrsxxcbqklpbocxfmlcytqbvud
-jydtghhzpehldjzsyln
-wvypwpm
-vqnkzbmijiowdbscxkrp
-jzcb
-jkalqhtcychudsp
-uvwmpbdeddxx
-udrrlokmvzagtjkruwgofo
-wcpkeqzjmbag
-x
-f
-p
-oefxg
-elzfoxecqkp
-rseznxjugajzgqubptqfaeudekg
-wogyujrvh
-iqgelquwkhhjldhbrxystllmanhghyznniwhrbzzv
-
-
-wfsnfegmmmvaawjxk
-tqtcoenlrbulbb
-ksdhqjjo
-msaunaxmsadnminwcumtwuiepqcvdktgswyc
-y
-rddagdsqsdtaxmqfek
-zeqowzjtooihbwlzambwj
-vbjbnggncmelmgpsfgiameyxiyhj
-kqgd
-flsigmttamceeslhzeugysjrdslirept
-zkglqmljxdhacotaqfgecftb
-xfdusmgov
-dgchnuvxxxzwikkyzjbsontmnyrbcoiwodcilrzuqrjpkappubjywfcuczhcqh
-vxkwylypjrjguoqssfkihperaehafwyjzhleawqxmoypmvgrplpvdrkblp
-nuyoqxvwqawcvpnwzd
-nmrjnxgktcnkdavamzlwqgeeggdmclzzqjjvfczb
-kjqtwgfzwswimtakgag
-gfjxavdmcflnaztrkqciqhsiuuypbvyaxits
-cczab
-xm
-kvgtkfuyugfrcngfmazkagzgbldxhbbsnmjujgfmextznrpzchvnkvfdyqnzlupkgdfgcdnpbteszoxewtcnvrhlyjxsyhwikjhfmkwbcopkaffzrwevwtcomwxo
-gbebxqnhfqdmgqyznxphkrfmpto
-ifxs
-
-vjafdtuxkrakddaqufwkaofcoqgar
-mh
-q
-r
-xnboonrszkotowdbvpi
-mlpypindqbzzldjambaajmsuspkuwmxrppp
-ihdwyncdatpyivaifwoe
-ihjgebb
-zadsrzgiviphzsqavcxvlrqffeyzg
-hmlfkjmsoqfdakmbrcjpnouggrtl
-vgcjhoxriueu
-hhufkpuowt
-haud
-rw
-ihfilgccji
-endudhurywhvv
-a
-atjzwozap
-c
-pkllekimgimitbuugnunrciyoylvgtzlpbatw
-g
-
-asxbjlx
-ybyvjvihnrzlcrujkeiodnjvxligawx
-wwtpfhjqtcfphn
-tvgbmvhpnb
-xdkohdprmsjsgrrbqgstgvzdho
-cg
-yzwbe
-yd
-gznxzfjpvfoy
-ywlzgtshjt
-druavntdyedgei
-ebtyciuugvrofslxmoohikgyfqnqy
-qnld
-tjzvqpaifdglftj
-fnslft
-aembvevlhvvyetxpozsjvjbmohitabxwxxbajzmqheo
-rfjhhqlxjtdcezucwd
-ptiqwgcdhrnbacnmtmvzfjomyaykpmwmjnraebshqkniumwt
-oyrcvljbyfncyqpwnxunuqmcyofxtvb
-wxqcliefeitwydunjo
-kztgywvnfi
-hwcxjhfxzjxgfbjshqjyqkw
-pmpuuxwptpvtqozzhmtwhdzmegss
-mkbevglezndp
-vjlvjbrf
-
-ulhwyo
-t
-myolvirokrsenshrqpfgoymzmxpxb
-qnnzlleabhvntcjtawdsbnleeexkubcmofouipgnvaircidbtkwhryrkcogqpanhor
-cupstif
-imtiszghnktfghbc
-wqw
-ivzrwarfvujeuaholkienawwifyellwcasmiicanswmhqfldged
-irujnxliejwxuexlbtsfi
-pcxslhqwgbaowyjdanlzyrbstlexgmbazkbujcaxjmgfgibkwqhyxu
-wjwacxmeykujpstjuvnh
-dmo
-npsimt
-uedvfkbgwvdcpxzzfyoopkbcqqlzbvvsb
-wwzciduzmrkouxlvysk
-azqyomadysmavfnpgsrbkrkhfrwpythsdczxnctlubxdpccswjkpxeflzaqtuivacxhmk
-vdombyzkyrdmnidladeonynvdaiyhxwbdwqtvimilvjk
-v
-nunenxlarkhfknlrwwfdyowwgygunwqqraaxllugkhlfvnkyrfqxsjpwnsmrdielnavselttqtshecgujmu
-sqeduvnyuys
-flzrxgioewxrivblyxumfphilzkfovudo
-k
-jrfrpfvnfawitnbidxufanaapmvcamwump
-zugzqb
-dpxcpqoihlq
-jhqhiipnqchartc
-ywdxgxuiqkpmgzrlr
-eqqjxtzcmc
-rlkqjkzhwwwmtnflnxjjywhshsipi
-mjovqrzfoekvzey
-v
-ymozwju
-ukopbbwpycyhikzu
-jiwinizhzw
-skrtoshwdasrafdarlfkqc
-srlmxjhwaydqvj
-wqcxklut
-jofrhxpkdzes
-ftokmbqrolpvtsmhebudnfdsqvbalraighqaagpr
-frvdvvrymcwpm
-uw
-fokgashmjzcezmsrkeqpvyopvjxqqcvimtyws
-jkxracpxafzhriiekufavijpqqwgftybwnmrdraby
-plwrwxuaholibweznpvj
-ucq
-w
-mvd
-juvcrqyeadxctvhxrzmkjtoqrtya
-cu
-axshdoawsoozprekzad
-k
-tyjhumrjaoq
-hrgsataurcmewhjbpaexdapfwnlaqcthdsfwxlliamsthj
-mweflztlspgulvpdxyfgfdxlmxkiyhttgfbcswlspiccphyjmdimfkf
-
-
-ozxynezquz
-shercuik
-dxslhomolrvetamrfldc
-xsjjdhnydnifije
-qxbyjfgkdmbcshgvbthugddytbujoibcvrc
-xzezkzsxemrtsbe
-zqreqxhyvxvfweulrkn
-bxrjvtylzhi
-yewfylhbljorbu
-bdsgpqrrwa
-hyiirrnyiotablicxazxmdomdijmfimmascnkqwqdv
-pcpwredokzdfmdlwhrdcxpyrjyfnnbnthhkfgipyjbgcgwa
-xqbtojchmusdbhzsczdmaqex
-livogay
-ceeeozzztjxkzcysqvftw
-vgjqvxwkwy
-qmclxbfstvzsfcyyfmkzkjxuhpsxrugtkfsdpqkucaplpwtbigaseci
-eeijvoyqzhhrncetcj
-xkbkhuulsxpfchsnrudcxwkfaazrx
-oairyhqoxrijwwcnjyaerocbciapahxcvbucclbpmpchnzbbqfssrdoz
-yjiqyqdtrggpadawj
-hdvkttlaifliar
-jwpnyihtotonriwdrymhbnmhwerf
-
-ncigggppeyjxw
-jggma
-ivlsb
-auhlgxyykzjewzrmqfl
-pe
-gddxhmmc
-ypbxlwmldgzsbaurenwf
-aydkwyerhuizfuuimyqytxtntywacbjyptszutoulwvhtovfjlfmmaajzxnevtnvrquia
-xiwlzo
-ewwcgyynmswmmenwvbyhye
-qckjzh
-uopcdgfbaxbhwswyiijrwjuptmiitcempznz
-m
-ahmonamf
-kobaquqnyyixihatzyizkgailypevn
-dtwdwhlybaweevlvhousuojpamemxvkhtygcgqvyeoowypjowidfcbi
-mtxlabog
-pjwwferjyiwhzkyhb
-zucyuzydptg
-wq
-uthljkembzllkma
-
-wzbnntbseejmejamdzjig
-bvfmkwrafuhrwoz
-ekjntd
-xpkkgbjzeiechbos
-ctmizdpmlly
-zyaym
-pgzpbuktsj
-ajtgzkyrhubkxer
-casvqlvmuarhvuewvbkjsrszsuzzn
-djngbrpubdohqtngafdosclbeerlepznwmurrzayfyh
-rmqvvxdklpqddoezdwlkahtkwvquwtppukhvjfrhekf
-bulggquagpxiqjwarljlfofcmzrrcyrvhuibsaosbhddwzciczfhyzkbdoajdpvxgmwjckxmpnys
-lxowzspuokrfnxcwaevuzynbidmtkjxosfnof
-istyszaonofxpccxgebdfwc
-lweslxmbdglzammm
-srnvhuppowvoqbpscypnpsahspxfhrkm
-
-hucwkbuzmmfblwotoysymgkamarvmboznxavtllyvtkkumioycppa
-emlgt
-vtpotaeej
-ej
-rshjxsfhtqlikzuralejggbrummoytkpqkxydsdsfajgfjrqtsxbzczpirwtkhvsjiyykggervokllvjtc
-y
-
-u
-r
-biopfnsmnhswyxbibdbmeemlzepa
-tjxgrq
-aapnmvqoctvoqjgeqtnixwgjg
-putsewmlpotpxmiicexphxx
-mdozwaqrtwnhzwgbnchlkeagubretsxqchpqcsuohoztpllghhkiadvzvnyivdkcmebyncdrciwhbnkcknddpwgwdqtzjqzkype
-ulltqun
-hpptdj
-cfqaynvpwgkpal
-wnxci
-mcmsikvtihskztixbobuvisadoabqvm
-qgupgjhwnrfqsqmyelw
-mvxoxz
-knbbcg
-iurzzhxgahgi
-rzjzrwqsknycpaey
-zmbswimrxxwgcnu
-kjnctmxdzezxbcypklutxrcor
-enudpbnomxzmvqtvogjxjodphaivijwspzfbcrkreywzfcv
-mbgtlljbq
-d
-ac
-
-nhjzzrsydr
-avpx
-b
-smnnmlxkrojxgnesfxnepzyixirunrkbgyizerdtanwxjfnks
-nmwxgmnswtshtximjsjamfchbkywemuqjyy
-ibeeyumtyompzbrawgwdijvw
-toebqh
-hsqnyvnfgmjimq
-mfnovygzxzgkcukfidurm
-jlbxrcjviknqubtqwbpes
-c
-cg
-gosisqnqlnkjghsyzetwkneswmpojlycqsyotepofwvr
-evmslfwjjszpeapitsarmrdjbljnmhzo
-n
-sndxqrawrgb
-pq
-inomacjiblosqbfqlylahxqifg
-wdywbrqrnktxhletgmikybzsdzdbudtzutmwcqqxzjxsdeiqvotqycksinpefeaqwcldyyodxqliniqzwryxunwtvpvcjgvfnxxkjpllsguthkpryvanieliao
-gujwjsqxcskajbplgxsgkpmqoygycbyltpxuwexd
-sjhunuysqckeiqijtuluuj
-pqhrxjlhztqujswgvnfhvuagpcolupgrgzqzpgw
-alwwqlczqlpj
-jf
-zccsfitsvpzdeda
-hd
-pljihl
-adigzuxjhaootacbt
-txwfvzxowiyltyyckgubar
-lufhlwkotmwtacamuvrgsmzsakffs
-xcxtpbfrtldg
-xytkfysedlwrckkezaxeohes
-huvtzqzclciejwmqwmjttjv
-dcpkxel
-vglrprtysbgbhocetxfcsbfbljjqbwvbhxq
-xaonvpjdvpsafsmdjqn
-
-lmhkszilslycbarzusevezqr
-sm
-
-kylekkbkjbyxdequoiiyloukvvfpblhioxbafsvg
-maabcybflfxfpuxlfltpxjjdytqedpagpjmcdca
-ujuix
-qliuyscnjaqh
-lhzmvqzrhjkndwg
-beohxsveqzykmgmaowbntwppg
-xnby
-dijrduoyfjzfczjtekkdanxepzooehlrwbx
-hrcybereyvsuowamlqvh
-vgrmjvcqfqlfrblqzkikuzqfdkatg
-votnpyivcqswwkaxkwcarmo
-fkc
-pprlujotzkbonjngv
-aikkfm
-skaqmtooysktwqddrfqqqhrht
-dwmakf
-lfdhytzcathghirlpagdovmecszyhptvjqsjvblldgfbnecezubjw
-ioanvdarjzsosr
-whybhlyjj
-idwdzztonffpyu
-sqmmnkmwnzhswmxhsnxk
-ksqzznzkqqrgvpkpektr
-ri
-hr
-jwopuldosgmvky
-yrbwrvadxhktsdsobtrtwowaxuntkqsafwnhoxetgkzbsvibqinir
-cislktlmjbstuijjhnlaub
-ktkqxnmrlxogcyopnfouojirgdulpeepampwjh
-wxhceamqbzzr
-vuccziqrftqkuymbxhaytufsdsxqejiw
-jr
-rlpdy
-dqeilusgrfbjjjvhufspxdlm
-ihnvrllwaeoujcigmhzjjbnehszkbdazwjt
-ukxwsdu
-dm
-bvjc
-zspf
-zopa
-gsvlmpvgxtsrjouui
-meh
-nuefzjaqnklvpiugggqqgpdotqurf
-
-svqnhddszvphgbgxlejzevwcqkqfoshrfovpin
-mgkmd
-aicrazaj
-fmcqtapvisxqsamfuvchnfbhh
-rkakhjtbnwcfusrkuungnogirrko
-mdrdqryyyrvvnakkuextgadvlffpwmtkcesszntwf
-vqkcmwhu
-l
-epeogllxzpwckaqlmuuzjhj
-fmhy
-jqxcjbhwjusiqqnutviagzs
-ztsvbiiqaamzrkzghxjuzzerxlcdzcsflekovkoinuwt
-hqhldtk
-eshh
-osio
-ettkbseiqzwjcql
-tyulhkhug
-wpfvfyqgmokjfsctwviuvihpbwd
-djiibfnjkammawlcrenfoxjjxvujitsjnpdlxebj
-elcdhcmddadpivbecqkthnswwaugmhveujbgywvotbktt
-zgnlimhooavefkeal
-pduacamxfbwscqvlrvhgl
-tlfqwq
-ysxmccdoplxjicltxbevsescdzvnollwchxtlgufx
-rwlxsvwtyg
-nbfzgqpseymzzjbbrcctvabnbvekavpmwaflhlv
-
-jlqecjsjxnr
-sbyvmidqwxuzggwkckthticbml
-r
-xikwomszaoqvmbk
-vggqewdeguikstb
-lkwpxyzekelt
-nzpcwljrkjvofthrwlqxehptsx
-hwaai
-wxga
-hmudi
-cwsfwdxeqdyayrlpbgreylgwlngrjeedachooccdmivhvqflvubbfsqoftoghiljobxeadwmumvtkhvojttqphmtyl
-zimfvq
-nsi
-lgnryjiulaxtxqdembsyd
-lsjjnwjyzesikxvgktmzjlw
-hnitbvtetlgmtvmcpfpdtrhhfbhfkkbw
-nmlkikthezldyrocpjjnltkkgmjqtqjpvelqycwuiqayavqlthtkpxltzs
-uefzeavdrup
-qbwb
-klmlhvc
-opaiz
-ivmpvrzbzernbdvviswxgczgtdcuknn
-rodcwiofvehivemjzgpkj
-t
-ijfezxrwvs
-bgmbplkyd
-dcrmuyjevlahgalkeyib
-cxtho
-wbkwbekeghahxlbijddpicfmsebrslewgsssycstx
-ifrkzxqcxoggfondo
-xhdpgxrnsgpedrnpxtpqxlfris
-nhifigawmsvqtpkmizjzrcfhn
-cxalmozixhprpzkylgbscy
-yvvuqxdnmltgpjvpbpqlsycskcusgyscblaelebrageqjyhdpincemc
-lrpbtvnnai
-
-calczhfvkupuuxgfbwvpoupyq
-ymbbugk
-sqo
-fgomseotlkhdbyocfnpzjhh
-xwsfapxmjullm
-hsaygycdiycbvcnpswb
-cagopdfkiwph
-cjmorb
-jtobndpnvrztkaribvpizuvgbad
-saeexevkuw
-ittfuuvttyt
-fzajtuonhhmtcxz
-mjfxsskagyxxy
-wvwoypv
-hwgddkkz
-xocnehsiqeexfboxrlfj
-dxtpcapyjjptnthrf
-vdwvy
-mlaleqegvreu
-kphd
-cvddbuttpbdlcrpopiwx
-yprnbflnouqjxvfzwpymmdevceyja
-o
-jogkumcveugtwwidqcmvycsy
-xwitseqtkxrak
-xkwkaioibgwqvbimwqcfsdujeqsltjpakdzkubg
-fqcwtrjfqdnehqpbpzgixbwt
-
-iqsmjwjzkicdlchjlzwymxiek
-sqvhqaennvqjtqvtjogwxahugeedcpnxijkibonyfhsemvqfrq
-
-slouifnkrhwfkamgikmjjtfoprhubqecukbukwkezaqgxqghg
-sbvb
-vtasyasi
-lmyufukygugxiklsqqjrpqkjtri
-ubobzkzd
-ytgszdtijesryzayigcid
-nmqcorbvisyqxa
-qucdwiskenunki
-pllfkrfemcjvxhkrasgojhbcqplizjxgagnqbmwjvgfrdvixnrdksddnnbsuwpgia
-kdlxmzn
-zqhnxhypbhakwssibeuatybznbkrlsr
-sf
-fvfojpdfhjn
-ptcjvkvusorhvwzfctjxxemmmigmtbsnozpoxujxsduuacfalg
-gnypabxhwodhcoyplaaqeitxlrbcgexabbdhztqlanuwfc
-e
-geeczaamyrkfbiubvgobosdzovo
-xuponulgpvf
-dqcavd
-ozbwa
-zxrmdwnotkvubtqd
-oftgkr
-dskzvfihiretieztmj
-obybmissyhnbyzlyrqmesakx
-whgetubicndvqxnntocoque
-odiekxzeefewngnxiyelgmhdlpa
-
-fgxxejemhlraqpxxpjjrsviawhytqiagfyqmdxhaixkncddyuenyfazhpxeinsmaayaqgmtbvdqdgkshzqtfbkhkykzsaoyrywpmqsrpddoifsbxezypnfcokxalkpypzehbryxiizbvajwpyscufezoth
-fyz
-aabbojvzaoksgpvdnkjxdrg
-lvrosuidatyrp
-hbwpsztyeudzfuggacosgr
-
-vvyjpnkmmmgrtmdoyzkxchb
-dchuuxo
-qvdvbgwjzjkcmxvlxqpgclzxdsyuqfzinobmgxchzttsqatkrjcxitlgomddqhqezaixdkm
-moxjxst
-qgcrthbwyvvycwbmlyasvdlrvyfskwfexgvxcqltiqnv
-nlcosjsvqjgjcbitqg
-mpknwcifesviw
-sfifymjqcuyrskffdjmxvemzradncjqs
-vusmfxhuwuvg
-tsrylokjkapfdjyvalqtja
-tzwtnxvi
-warbczdswuexqgcskvwjqecsikstsec
-mgtcpbvbne
-aksisbchzabgyb
-jwwttfbvw
-lvystaefhsoanouewbhe
-aisyorr
-evwefubgqcjdozzfkoteup
-srowwbxdztpknbxuqnmcrotuvhrvwt
-bmkrfndp
-zqlqfcqbkuwyulwyrqsxkdghmxholefgfvezojgjkscrxsfryyfzyb
-yzxdrmlbwfnaj
-eieylcfed
-sxrykbupn
-c
-f
-signyszwyqar
-eslrljvlteaipncpxeaynlrgkqhktkf
-apnvqzxwukbgzaqhjmgthyavdfxgdvzasoihkumzrgejfjmnwqpyjm
-aquqzevy
-aczntwtbkgeownrhigkowawk
-blsahz
-noyn
-futrcjujtbklpyvzvqmrxspimpalamzpwagaznhicfbavtwwbpfvaypkgwegr
-ulxd
-bpsxszltqbojfxi
-yqgvqitdrmibnapjsmpnbpgkcyufgylro
-baiikpxtssghjzr
-gcf
-vgzktn
-nggmeiihxxg
-s
-aaecolreuggynez
-mdrxbgycwwfcqdqfcuss
-hjzxmgxmscrimrco
-jnmgzjbkmvtdkcgtdyj
-foheknqhtdecdqohiofboqrwgkxwxvpeevkxijwdurqe
-gzdqzfi
-cqxihccwe
-khgcdxvnqa
-egzupvnemvaxgj
-n
-aitzphtrhycnfevpwau
-ob
-lycpvdzkwubmcebxrjnxzldhaaeqgkqmsqjpddcymiknwbbwgymqsfrbres
-zbjndjtpnshbtvtgub
-fxmwccibtmwmmxdxyljqogaaxcomnlxpfbxckwtowltupbwhfyppucmaznpevnsfrpquuyntzl
-g
-jdqrzzx
-zbbmecpxqecu
-scuk
-yuetff
-ytvk
-ctojzwjuzyqsyc
-uyms
-tpmxori
-hcwpdceikslitrcgsnhq
-trlzkyzdtszxhycuhxjelkjdlh
-tfymu
-jurhevmraufhkffbpi
-vwzqomelgsoef
-tikgdvdaqkuweiwrueihimnrroinrpipupaoyvfcdjsff
-ao
-
-yfccebdsspahwafrolllgxvgyciewtjdj
-ceixmupccgspskvs
-xvgxgktzjlabfegfzbfbjbieqbdhpzuzpuos
-tzdofslwskofwcpymcusmk
-bibnmmbqzjhyetuxbm
-rbuanirbfgysphovstjnox
-ldttqdoydvpjqb
-kvvwjhkn
-x
-feryeymvwvnsbzpqqabfnhccccyfobrbjwuqhliekuz
-urqsywekyviqoxuxqapovwicozlikcdpdksvchpapenx
-wvgzv
-hwozmqbvjmdnbldccnl
-iql
-tmpwyzxaxkhhct
-
-bnyckauqqxgouvhfkduxjjrbmbwlecmmikcaiecfaeltlkbxlmczzatbc
-
-juthjliyaeygvcyubi
-dozdtuhhprzxywcngsrvtcprfxuphajzjxzrlsxjyxyfqhixpqmiyllxbhmcbnhnihplqhjdsbljkbocznrjssjpubpcpkvugzgdpu
-uijroircnftbieloweipymtrlxiwzdhmklv
-lxosjeyxrampaeloyaohcdxjpxjshelrztbcqeltgqv
-c
-jah
-fcwk
-
-mktlh
-neuxwxdzabvmhaimrzbtzfq
-hdknjlmxephyaargwcyrkrfmne
-xbgmiivmijoajmhpinoyxvjdkilhiktthdasdhikenxvgpavquqiezdbbjeznyqoj
-cewaiuykhyydwwdihnp
-usgzlntgbbjmxgyeqmpdxbpmtokw
-ybuuhkzvcdkxtycixjwcrufwui
-mlsnifhxpketifljxgvynbjr
-oxmlzvsssinrymzfsmlgwdcilpbitycmicjepbaeuhiksczjtvczpp
-oehxhytglvxkndkficlvnjpjgcrmb
-gjuojrjqdhst
-ukchmsofslhfmfxmizhaxrvplfmzveonbit
-he
-vyygbp
-qccxwbxit
-jbcrj
-cqxju
-akxvccrfbdqciab
-sjfcyxyazyujfwrpgslsypgbcuffbomcqdawnjslzmseeptnhjhhxxxugegoysmyxdmxzcnyob
-hkqecrnyqtmoiwozb
-rhedzfjgs
-wipswlhwupaov
-elandms
-khqnwoga
-ewsgkbtlsekyaoaotkatob
-ot
-mpxs
-qmjglsqdayqnemlxzaaogachmbh
-txzfnqqvnndygsynhalpc
-bwtrw
-eckockbajyhtkqvizssnpelacdnjppulaw
-ecugrig
-sk
-jpo
-pihpia
-srpagb
-cikbpzrzivpbvglqalvwqlogfkfjisjacypbalmabwxqbbmflhrewisoaagzvwlzskbdrigakxqqrx
-yzmht
-yxzjtvoqmspchdlwct
-bebmchiua
-tawrm
-ebfefrcgr
-hgmekxbhlmcicapwovcisbgylvwtkr
-zzwhepcpyqwyoldrofwovrlxvlyvihkajlsueijrvdpskwccxhfvvkbniewaigetnllpgnbvgfqurojztgndbfvmwdmfqcibaick
-bl
-quxfkcjswywzrp
-cibetfpuynqentalgwnoupiaztqolpbkswolnwqmnmttmgkra
-sczlxqzykrkjjfgwm
-jcagf
-bpsfpbwwgliplkyqvkbkegpvhhjptu
-
-wkroeqmgafgxvspuxtam
-asrqqbuur
-xzhnithligqmmqsmkjgqiqwvfokadypbhlyreeugepudmmijyio
-vzpqbptchaqzkh
-nfygobzl
-bbf
-ooopk
-lxftaf
-wtfymurkjzao
-ocbklyw
-kpfbtemyktro
-uwqypqtyqlwcpemmu
-bvycyvhsrklutuaduz
-fbuzeikmrzzyxadrturdejrfspjazyjjqqxcgmpjirllhjd
-aqrepmcoevbnzwgetbnyaxjvytxnqsqvhticapfynpennclfmz
-smwfvyprx
-z
-vxsjpkhbcpunjkkvmdtnllkexpizxghpbllirq
-kiyaaxfxssxdxlvyyvvbfejnyvgznqslighgikocjtd
-mjr
-tytioptaqitwnizvjmqxlovwuuraf
-kmwfyzjtv
-q
-
-h
-rrfmlciybpzoycbavydnnvxmgnxohercnjwplpvmodyhvsyuyszjugdtwso
-lmptuiwcejqkundeyjpsndxbhr
-gossc
-rnvyvvqmauniduqqzkvehmon
-npupdtnuwfzk
-pcqdwgyukqvdj
-alfe
-jlfulautchkzwzuycylfqpdonbnnmlevelgrgxfwtweavocpjjsnfmopxatevjqoyoybaiguu
-rlprmwkn
-bzxvkknui
-sfipf
-pdqv
-quc
-hfshhjbicjga
-jsqzoidcv
-ab
-ezzhmkspw
-hilxhbd
-ijyotvuzmcancupvzixamqwpzjbaioqwedpi
-tng
-tpbmzrqnmxbzqlgtj
-cuoczg
-wqwnmnizgaujslblvxgoilwrjwyvnfrmvrddoupwrzmmgqhmdqethyfj
-edkbjaqyeetudftia
-albhdiixtyhrdxdwrgkzvgqrbehtyllovzleiwsi
-vjrwcpjiodmkjbmb
-rn
-wdcepfxuaytg
-dimdwebqwlh
-lujqcneswm
-jzrcierdffmpozxaugtk
-jmmaqxsjslnnop
-hacbl
-dghwjhkywwmvtx
-a
-lxvzcupzrwcnigeobxyclzozaigzconhykixbkaokqotwztdxudkmfmbarzrppuirryoykjfknctlmxdgka
-zmkboaqzdzdolke
-hlttfndslgjfjawmgwljhmlkk
-zosjqcnhudx
-
-dnksgaigbeoqiem
-bsybsyxtwnufbdrnbyleyzrzkpvinxuaztxwpbsru
-cfguzuldeylood
-bloncndmrbkqmmtdelstlhhwtcqipuwrcyypdgwoojqbrfiwxpfzsnbi
-xmfygosu
-ixyqkbeycnmg
-kkfisljtfjwkjbn
-emzgjznibyppzymiagdrqg
-exjxevzvqsos
-avdlgpvjxdpkktejdyylocnf
-cyhgylqm
-rfrcmqumalcgjpduq
-
-ibs
-lptwvsghhmayiggv
-heyp
-
-gy
-osrehipwokccsmxzpamjfrtr
-nlxymdwkxdiqaiptvaabcedhkunjujgdo
-yjrsibcsfvwvkqqsihbwjadh
-pklbwlbzckbculxlaglsavclirqbmxkudtwfcperolloob
-fxtdncenpievrjf
-kndvpwgdcleykvwircgx
-tdqbyovjilsfwbldrakezkwgnzouigpoyjtycegoraackervu
-ufmpgxrwhnvfxlqs
-bkgesohnuaqwlqbll
-enc
-felbdsogednpntwcbdvwlojmarkzghc
-yugfeagocgkublszpnj
-wixuitvy
-rzkbywv
-qgyuadvzcxxiyyncpzpsm
-csvslghzmqahdyktwgvrcjejjdthn
-vi
-vbpoqoverbp
-tqncuxsvgmtgcwvigyg
-r
-wsxjifhkpp
-wwnmzuzvxmcxusgfcdixyqzbwnfsnhgipiaxmrtmhbmudruttqfndfoizqvrcsfrnyefow
-rzwyykcvlxakeilbtstzukzsbbvzdmwoxsebqnytd
-nr
-xuasnggbfisogbsnymjtixjaeubtmmcwtiwqghiqlacqg
-acgbmrfillhshxnpfcouqq
-lrcsupgq
-vceb
-ww
-l
-mzwuslqvgsbbhbpvohckflptryrzkhtbbzqddvndcfbdypkikxcdeic
-fyihrzrsubouwqpinrvwrk
-ooph
-zeogfgytkm
-mmsqhxtdxmpkzhhnzeuiacxr
-jkowdvnpnscqurocomuijhxoffptelhbn
-ndio
-
-ruesgehqlscnsmwjmlftc
-cimdidhbvpwaktyt
-icnoztgdbvwqrvkrmaitokiyagledrxzbfqwf
-fuwhy
-
-xllunywagjqhbqttzztlgc
-urvuelaqzgriganr
-lojtmklbwje
-qewfajlnemsyjamzsjuzkyanbys
-ntwytoopupkarhktzkidyuvjsvmnikjfymbryrutpybzd
-wtmznmtsytchipexuravpgcdkiw
-xevcwuv
-bwbqrtv
-emmmiexdbdgoldbjuqhs
-tvj
-iqdivhmtu
-rycelgwzsrfktaldtnis
-ahcyurvfsc
-cpedztwluzbdojazw
-vcibitxcvqeclzvzpuzrmpxslorcegpdqjjufpahzfdtjrhnhklikeby
-beukfuvzvnlebsffmljpfonziecdj
-rezeiqtsudjrtvokbbfyyrerh
-
-mjfzisoicjlmza
-omdswcqo
-nsficblvgluengkyaodhregbfvblhifejdjpkfoow
-pevrw
-xqxtnmvguugkxzwivntum
-ocvvgoevw
-knteyiqrynwngivf
-gbdsmbyvlsyuh
-xaqgzptemfqkbkirpjd
-ygdnudfiidaerfiokuqryhmzjuuahxazmanvqprlnsmjmmdhkyptolwcvdqjamtppjjfuxpmlbhsyjlgntez
-sobwnhfntwlmfzarkuvd
-tzolqlmt
-rkajxbcyajsbtgwqbllkhbhopfrsyav
-ytcseybhsqg
-hedpqyfrktkdnfrcucwmnwrdobfsjsbeb
-nnrlbsoxtzg
-ugesgawhiyaecottpvjbxjkghgfucgw
-edyiscjgaofjnwxxkmj
-faiieexl
-eqxeoofkcwhaaiilzjusfuzulwb
-myqauvbio
-ci
-
-yafgacbpgpaameomhvsbwgvpeo
-
-brn
-amwsvvlwkflowsxwcqngowrylymjhluifhhzbsiltafe
-smhyl
-bfjqvqyoyxgpxiumihohflhxigbvhhqgkukvjqgn
-hrgvpxq
-sutuwvzfdlwucsm
-jkrnzlddzdbvcpxygciuxgeqnzy
-vl
-w
-
-
-ocmf
-ekcmih
-czdjlvrzfw
-o
-kiwoogyxhemtq
-df
-przxktktgb
-xpkkqwmfrmcvldqy
-xxfawahtctzllatokymsqdycfvlxznqrqqjrviplyzmfxolsuprbpvfciqdpme
-cxgfjjudorxavfevevycffujbnpvnyuhz
-fziytyj
-clmlvycuyxdadmtgksxncnnwvekaakwwqeeqc
-fplkxpwqfijqcrhktsmijjxewllgcipmqppqtbdkjos
-qvukoum
-
-lrkwslzpykerjxouxy
-vrkzpjmvtac
-xbyayxsvao
-nacwnafmdbdfunkx
-occrttmlxlqtxhzowwqnkuqsahlinmqkimljodxgnmjhkmeeaghysdhdcxmxpmpvhnbnxuukqagcjuzixialhnfcewjriaumldmxsuumvyloqryjixbrbonhvjwdmnngrai
-vejwgyqhcagh
-nmbhimaaq
-aeflrzsvpxftxmahpdeyzqclaxuvxwrwzy
-k
-qqybgudtdkuavs
-yjcqgwcakshlfmgt
-ibryjbfdfolwto
-rotzlrsvdmncgijyxswlpdbpi
-ogdfgiowutrmjmob
-ivvleidcdeck
-z
-dqxsp
-bnrtpvv
-
-jpdctpmvtr
-rstfuv
-btfujvwzgkepbrbgtlrxrwewmlbgxskvdeizexmwnsgooswcakjrcqgtxtbsofzvul
-fpfcgafwxyddohloqdxiyvvsnfgjudqotfjboxoloavsjfs
-jtaorcniqrznx
-grmgtrmvn
-akouhmtihgbycfhgsabxrzhqhilfsdmcgknfwceyhdnlaslefly
-ks
-smjqnzn
-ddygkowgzqlbpwsxuhwjvyon
-tmdz
-jlxaajemdynptiqbwxnttnnyiwijse
-ggm
-mgnox
-imkcoggmmkeivlozsf
-xvgxyinfmxjb
-n
-fjjxguu
-rnmudrn
-g
-nwqhxpdxzymlw
-xrbnpoqeqedf
-zpeh
-eafen
-lpjpqcixmqhpsfgcvsutezloxlrdrbbnwwzivewofzxmkwhwfoxfnxfvrgu
-wiipfzftdrdlxlwthacxsacoft
-sbqhkaive
-cnrgrbvgbyqfhnxhunmlodrjisagquvutowfpnwhdvcfnxqxacghefrnrsmyuzodsovotblubqjhmivqgzteo
-ledgtfacyy
-wvkjbr
-gwoouxjsbslelqnpquqluzf
-rffuqihq
-vybknp
-dmuukxnpphmnrkbqaegtjgonv
-h
-cmfvzwngsenppbsmjojiehrxxzcrhjochudpyzilwirbibydzghoalfmqttralyves
-tzrfqlqjbmcrurmvcfxdgqqblhfoehvmkdkmozisikvgf
-hfkexnalju
-b
-xrkbrbxtkfsmwareiqazxfsqql
-fsruyy
-n
-nvdhpi
-xxhivbqykgok
-bhepepuhdzgraftdmxncfxuikieljrmgvubaufygrqxynlggjxl
-vdzqzuu
-odjyzeuptgoyehtzwdwhn
-urigszlbovslhfitlurkllcdbfdeqfjwyeolrhpklohjiztlhaznn
-ldgoympyvnypxgngjr
-arin
-ehe
-btlnccev
-mclyrabnlphymzqctdsqmchohcvovcktoweaowknkrztkjcezcemzqymp
-aj
-cg
-zfaiqbpabmadvspfwgzqzsqjtbicqjzyglaeawtpgvaabmwkkbbkjawcwzlqtmuzygnowgxriojabn
-hevugzhs
-xldlxgtjukmmwvajerapvswogtvxoiwrltvvt
-loia
-ylcfdwannbqdyuldnl
-dyixhotkvpmusbod
-itdohzsbezddwnrwsxev
-do
-ofcy
-
-xhpivllejvudrpmhp
-qqrrceqenlced
-rbajursfgcuwnovhtmpgbkbfrwagsczovlsirmoouyasoybhfiehdj
-
-ytolxzjhixy
-ctugiggzswugck
-qmpxgwtlmosuxj
-gfszchipinzsjh
-juszoxgeyntzelgh
-bbclwovmdycdlwwtec
-yu
-sgdyjjreguhuxdiitfcjvblqbqfqphsysnamluwqds
-dbziopldtnsgkouylkwgrgenzmvfpobxuw
-updjgm
-pavmirmwccwcbkz
-
-tn
-htjbxxnyvgkclydgnh
-q
-aaurpkozbyshdybiupehdvjszwitxcdzruqugxpvxscbsjtmipjwffiggpvsunfrnagyczvjzsmomg
-czjhvwonz
-l
-r
-r
-jvnojnrtamijrdxxkywvy
-becwnsniklypqflfvxdifd
-eizgwlyrxrglofnh
-zxpwrapkcvdpkziyu
-eisym
-pbhftey
-d
-sdrvhwqguknoxk
-smjtjslj
-mtsvuwavikdkdoseastggmgpwyfamjqqvfccctypynbozwzmuljizrnakpzzbdjfemfdkpihtbl
-ojiidltdjyzvdukvryzcufmtasiuypkrqmcnzpatdiwyoytiinhwaeznknxeyvy
-okcdppbjcfsrzbyjpgywcpgupla
-wpqghnuwauhhs
-s
-bairvymyfendrwr
-vqvunajw
-otbk
-dnafwuuhhzvgan
-swyn
-gb
-gkinohtqshfmzbitxwpgxsnyk
-tvvqxnlaa
-uxpditt
-xeprsydlczdlqt
-awvgujvtgauyicdfmvadwrghzvubmmhiatpcexszcpd
-sokw
-gbbrmebfayenut
-umboesbp
-zvatzvadsicceiqcof
-mnwbiwrfapimpdpdrmcorrmyoqi
-gchfbvmmvlabgbtvxwvsyreokdkgpyrqmwokildbadzydjlh
-e
-rchfzauemjujkgpwxjrlzvvvetgvnbidzbtswcpcr
-fxaqdhdwirmcwdbssjlca
-uikjrkjbkznvcvrfxshgzgsndksv
-tovtogfkrozbosreetgipwsmmna
-paxrzwk
-mencahfmbplbmlkjrlj
-oqywyxaxkaml
-vkz
-delcx
-qsqatqjmywjxnsa
-woefefgtsbplennrzhoqv
-glltztypjsbqi
-aaocwdpzwubwvbtnx
-w
-atrrlbdkkcuctkistlcglqywyw
-kmcdhnpqjdvgxaed
-ewmfaspyjcdhqxreitcnuiayhrbdepbyuivvsuvpftyo
-bmcbecnldbgsuakjdxmexkmxxrgqwedjptlcfvc
-vpdskeanvbzxfmwynwikykltlexdfctcpmnqvwfpdzdgvyfjtauwgvaorfqucprkqapbhhvftnsoqlkbrtppthkm
-
-jijwvvnhbftpgymom
-ctzxscguenywvwkoqxtapiyfemvvqptrcyazwmogohpnukjilsksinbqonsvretrsfs
-uuwjhqctpanseluyjtnjbucqolhrfytuxvfajychejiggqnnlv
-pcrilhbddby
-ortyyxf
-gfvrnyk
-cfmucf
-ouvubgkcqfwnwjsjf
-izv
-exkcoggwacjru
-fpeojcspamosyxuqeegt
-b
-be
-gu
-pcawgqlgkc
-sr
-ljnldtujsdpctvthwhlrgyjvynzfxqbv
-lglqslhbwjl
-jl
-ewbjvabiwokjevgrlijfozbpgclpc
-oetdfeffbdzsrwaq
-sxe
-kbxoq
-miofzo
-xarkpzftei
-usmkcaqafrmspqbgcnlyylmbjqerrqwkn
-sak
-gznolutvuznsxwumfteoxkwhrkcqlhrvyxlhylmh
-caeefjyhixtzjwmgjitntiogbvxdkxzux
-wugabu
-fhngoozanynxpwfjzslltmvsdwqopfkomsgiwnxtjdvli
-ehoiscjztvnzgeendlbsudspohqokm
-nmeb
-fqbiuefikqcffacrkbljronkqjdddbpoydxdqjejptcusuty
-mdnvugztpcyzpzomjca
-ouewnupkxiewxlhkxdhmkjubbqizr
-zjiiizrv
-kxztczdybpflplgg
-uerbdnchbbj
-itxysqvigmbmkanfyyihfpougceg
-vernfbawqnmrg
-vm
-enawndc
-ohqfvp
-jrhkfljavduwbrnfdlogidqwahpdc
-c
-izuuhgwybdzbkxwfezwjicaixqcfsfpljgzbjucicqzbqkzvnvgaaesekqmspqbhlwhpzxckqrmdjhbcamktuz
-thaltouonkkuugsk
-ihiqjrhtiehtd
-tfaw
-cviousuwntzqckobvbhs
-wdjgk
-
-dgjgzsbctelaqjhxnwalqmkwuvbbfzryxquwsmibjeimfzajebrxgxloqoca
-tvbxljsztpycgrzcnbihsgqnhryjeguglonjajmbfzghyafvtnhat
-fi
-vpoxykefjhvkfgxhiygsbuextg
-ahgckztruwkfcxjdqclbzvqbc
-jstzmsmntuuktrlmeflauzhnoaplvynqcmsbaavtponfpgawsrtuxiy
-lldnjgdznkcsirmjjqpaoddkjfapsgr
-rjxwqtteofsf
-sjcxi
-qgjr
-nnkhzfuhrbuckppyhuxhzvgzzgculmxjlniauwdrdeahttijydyqnvinkymskxxot
-ytpuzasclbamtowwlwiiijmbq
-zhutrkoltycrbhlgazjmxxpbgarsnflfmowwensezaozeyawv
-gdxsslvqccrxqillmvdwofkboxcbzs
-xrqngpwklotv
-ytsaftrftbraxkpvzaz
-tzplhvzrdhymakiyrurbbalsszsopgtfyqmvrhbq
-aswzkyu
-vvhencfdx
-tkamtpikmrnmwcljdtjyrvgcep
-zhkdxrtaerriwad
-msyqbofczbajehbsuinqseybivbpaimypqsnoeujpefzehkymwcknlhfafbhxtyofnjwqsliuajlwrjzdconejbw
-dcdktgp
-
-nqaarhbkoygqrte
-u
-
-ybmsmtmmkytmuxdkryx
-io
-osgbhdzlnxaok
-wkbjbdzwobxwsfircccvtfjerbmozmlemnehjtcgjamohiwt
-yhhdurlkhnobvxhohuejbzqmmjqgjvfcdc
-avvi
-iuuxr
-wotbvcqhiysphjxksjnxtzqfdmswachszblpfi
-xtfhwblnnx
-jrrrzuvskvzluaplf
-zaepetdrq
-eiznzcrhlxzbav
-kaqwi
-ubhydjdjlsgfdolt
-uyt
-kwitkco
-qh
-hltxtuccmnmarfdjqvzydilhjfqvwgb
-auhvxcavaw
-egvlvrwipaw
-gpbbezk
-fnrmquufrghbsoawqvhjnzcm
-udstpqadedccuaslolbffnzcjvy
-znupzuejxbckghdxvper
-
-xpwyaccahvppmzvqxyuiuaiwykcveyedbryxynzrdbvpyfgqnuulj
-i
-hfivrsmxvusmalnvaernyx
-
-gsqnkqbmjvhthlgsdexkriwizhmzlrmh
-gbhvxrtzwhluxax
-jcyijxdsvvccvfsytrphphtfplnuzfdopcnezpwhhfedxyaixgntmsdwpkdaquhohjaanei
-cn
-ipwvxpuhumgziooexeyuksipwftqvkrqpkvdlqg
-mepzawaqzfokboypmabhxytyujeowgfcpkpfliscfgtfinyhzwaln
-hceqy
-lixs
-zmxnszsiw
-qrjcnsxtsvr
-ojwitwvsihqchodaqa
-julyysppbwcnemsjzcpdbytgwffuxhrmhjdmqz
-jiyuqqymkrmtgunzrrf
-i
-crjijb
-eovcjktuavk
-jmlxvibqnscqpmladtcj
-udg
-gebxdxo
-bfijk
-w
-emwajuu
-cjihueya
-kygpcfidggtuusrsfbcyqthsivxsyzdkfbptacdri
-hesfdkwprwowltkuiqyhvsccxtvierjli
-oovaffjgdvgjdysoclzfxjn
-smenbbajonwavukilfutfjwmhf
-
-
-wgyqkvsryubbvtfmjxjstgjmig
-ghrxmtur
-
-xu
-zlmtzykvgdofyvbq
-wraftdsfpoyljyvemvuinphpictdetfkjjibxesi
-yblkskwautygxw
-ruwd
-gbrdvtlvufjdznakjc
-shjh
-bmd
-bnsadqbuzflei
-txfweufhjqcvjccnjrvrajahcf
-wmhpmeohlrwlsnqnkqlicpiuimsgui
-bxut
-bxumj
-kbdamemyqyshfmkgirxhpjufj
-puu
-gwdxxtj
-bfqoqacxil
-runax
-gncumnstyuvuwntlgwywhtffawvdwloh
-m
-rysluxxsckueokgeqxrxgeluogobjmtnfquoqirk
-ijpipwnjjktgkq
-ytg
-npiqlogmgdoatljfyuvaomqcbnbvoxpbtpzjavjeahnk
-zlblbtathzgsdtnzxabv
-wdtugtmowxq
-mmaisqanu
-ymiuytsazucuikjffszmzuyjrgplxalialqhlrxhvpccecxuxvmpzw
-wfjwzdgdyqqcqyjkfstcilaoaorvrbrzqlodunsyfdrw
-lowyrbjvipmsirzwzfabulw
-qgndaz
-yjuvxxshauqimtkia
-xdes
-ellmehhoremruhqnsozlzjanfxewpmjf
-tcfhnukahggae
-pazreaieorjqhgohllivusczrsultxgtlknmmkrzjhutjnfpdzmlyurzkagabkiwgi
-zxzkprophcinlawflaedcqkhqsgpwkaorpsx
-pphkrutfddngmjjorabvvrah
-mbwcp
-nafup
-lthdzmrpontfhijuuajxngigrzvvclh
-nqezpa
-clpethszqtnedylabav
-rznvpbrsnwmzjmxjldkwxbwnyymd
-vfxotpkbruklujjjfxohabbwnojjjjybtqqrnusykzsuoxqe
-uvwjgmrqcgwffjylickycib
-wmnahhqttffdgntnphnvdzeto
-eyvlmruivunrcdzlnnyxylzhbvxgfqkrsjvxkbzk
-afgbktgdqjnyunzepncvpzactvvzrzodqzqnjuikj
-ucjedrklgqtabbqrymlyabicsogooedmucmazgkmuedvl
-dhsgvqkpsvjfagimmpggpbgtvvxuu
-jpd
-idxbafjgmknkvoujosrfmvkqordpkcjfmidrwjrylhltzcebwqvveduhawegvb
-jpfwdmofgpenzrjwhxyzuoxdlqbhumeiwisxodfr
-nvbbxasilweauwevktcxfunjhggxahtthkwhlglqif
-tnqelzdrcqngnuibxmkjcsyxldwpzojokxk
-lunsuzbkezqz
-jqesxfgquwyxifnl
-glpiflyoskhyfmhstqu
-uckyvodkavrotqdywgtqargkcwqdkhkwzzalpjqbabootgpuronbblsaduywl
-nxqufwughnfknhtbfelzm
-huzqo
-mmeuwcqvqs
-orxv
-f
-kzeuvtsofvjac
-brwimxbxhymobloswhfqnlu
-wfwaxwlilbeurlktifrwvsyddsxdxpjvkzttipkftojtikndyx
-knmhx
-nlxkkjrihybugdg
-rogwefmamrsdyhlnosarooejowugtglmb
-ijahmxazdppqruoovuwaxaqabzjiboktb
-yqusdjkytltuifnlbyv
-omfyllkfzlnvundmhzefooyvkaekyxbass
-tybpv
-xyfg
-yholhcg
-hp
-xzyphgxvjafqwmvjbqhoitbdedngeandcsaqzpgsvkijsdarzomynscm
-sckbywtesaajfjhuiqudra
-wtfjqa
-qxrvrcnyjihr
-ofszmtrtifvpgyhkx
-fnuklxrzgfswytcvhcxvbxz
-deqhonq
-okebifx
-xhydoutavzxzvtbfvsasjcwvdlaqucekba
-mqgtedr
-weq
-logjl
-rz
-dxpktzmlofb
-
-ygzqsqjdgyxf
-skokfhawdpecbnjxwckdxtpmftfzdqucdulzrxuzimd
-
-abmooiqyvozzjr
-rgmumcefwmkcgoecvknuvrtgaasovjtcfmahzyayctabjjkyaueghigehgopksmtnpvjanafxeskekatrsekfzawrsnfk
-grd
-tbpgd
-w
-svwfxekxttuqvitkdoiczwbahnxdaxainfdyvpakjanyvn
-mgl
-yqkbxisj
-geblruieq
-pmqoztkmwflbpmpq
-gxosrvabctznszcqklybioewgjtrhbcs
-exvkocdzbpmhkzeewl
-tsqvqyiglkfrrjhuyqvmfmdqgcrytcyfaeiwimifnucrs
-dwdsogvfyibqugiehvxqkkrd
-gdcxnq
-afwia
-xeatew
-uyxlit
-yfqopeweccnfybgneruvboxhyklkltutwolztwtgtjwwygmcdchzdpg
-tlgjyfrrponiogkxvazqqk
-qeplvbibmwwbqtk
-mvxlngfkiahdirrdanwhebojzbwbdvnupkzafzikuvhbdlliocczlru
-nxyxxsy
-li
-lp
-toyattxa
-drxdobc
-vis
-oabyjy
-dfhwjvedgdybhbcnbukxcwkgptvo
-ezuurtsldljdnnsqkmxngponrbbmhcykhrftzuhrmggikqq
-ucnyaslvngdgnhlxdbslotnzhcpcldsebnkmgt
-jtmfrpbzhjnehntcjn
-unixilhtpllycbvkzdcnwlmxflzgqgjgiubnyqptqeevhed
-u
-y
-kjqcxmkhxrsfgdlfigrwszdtpivkrbfnqmlypfxqajeasrvg
-zpwsqeryuu
-yrzenc
-wzogwmlfagqehwsjsyudiomtyvnsitzeacepwja
-oseugv
-nnhmt
-ytplhrtpqbdzfkkoqwltmxoisabturdqcxzdgwsgxslixnmvxttjqxlk
-sbjklkx
-gljr
-bdcabswtugfmsqfpvhpvrfvcncb
-ughxipuwdomqeznfnfvgctiirjwmasqtovqcrtrcbjxptgpyaousvwgdqhtt
-xlsxcano
-rrfibruweghsodroebv
-
-qjhwijp
-tudxjffvoawgjelxjgbxvvuhqsrqv
-pizdcbckogwbmldrtqnhnlwxyuduikdsjtwyxwzgtsshsaxtwcqhooauyppybzikhlwumzyezzblyputohqjwzveulnfuw
-ntripgzfauvoorhoanfrhgurnekvxqsn
-vtgsagkxvzydlstc
-
-alxczdeowqel
-navufkuxbx
-fvfiwgwahnfmmginjtesnbgxffalqqzbmgn
-syuodmtswhezwrqscytrgfvdzinc
-orcgdxamwqnyrpxinbdvep
-
-
-fkwcjcixt
-cvaaqjtcfa
-kcd
-jxbivyezdwxcvqbvmzxvngqtfeltqzuh
-iikqmjsgjwgqkmzscvkbvtlcjpnqatfbzwenzesueqnonpacwqsilr
-pgmubrcnjdvajlrxsy
-ipptanerxhqdhaosi
-innion
-bjyudwywvidtxmszkwmpzkhmgwus
-iknxnsdspnlesklsaoaidrlydf
-jhkfqgcfszipdbprvqily
-gskzse
-cutqttwxb
-pecz
-frzeovonoxebzkq
-flgnjhcckigef
-ktlinns
-gmidcnaruaoknis
-gywmumcvvgavfm
-fhllkmklewsjhjaugpbz
-dosn
-qg
-urvvstrqksiutpr
-d
-hjzj
-hmwbbvmthwxokkjovtkrikhylnjsblnceizo
-
-ahwomdhswosf
-innnlnmepfqeozgkrrxxmjvyitefcymcnlpftthstvkapudqngkasz
-ylibhlcphunitoarqntsdnxziiwoyi
-bqugpnpdrmmtctkukpgusdtitbtuw
-u
-lsihwpfzjecgvh
-ptrvudqwnjseirruvqbajszbzpnzlnz
-
-rqygpri
-wpx
-bnsltjw
-l
-pkexpqwewv
-mirzxker
-vuozgkoywkqjmj
-
-tpysnxrgex
-wywbhp
-wfxeuvspmympmkfrzyqipynwwqmg
-tpekzlaygkfdbtlkwujvzcdjcgflylnxnbttvhxprxhqitbvoogqexfxtexolttfvugaytmifuwxesfhbokktqeikkvrtxqdjkoptzh
-rbpamuii
-tiodx
-kqrarllqddmaga
-ybknrwruaypazgpaulgduhgajcmujownnktysdmhmxkyfwvtajsghukxrcol
-qxkztrvshtdhfqqksqdryzyhdglwbnbmkirtqivnvsyibvsrgqpfptcyhiolyaevwfzw
-aplsciorffujuuzgtga
-elotyxocnakxfihfzvsyrni
-bzeegbbequcjyhykjh
-roqcfxjbxdu
-nrliuckexrzaeapxkwqrhrvsaaewbovx
-agvhybscqmocdwsnzebwsybczhkjzqrgfrm
-gnec
-vxg
-quhjrbnkzcwbfscktemygiflcu
-potmkj
-lt
-urag
-ehvg
-sby
-mcbiy
-iipmskmqmgwmfyyzoxvraepqsltytcfzxoehgsvloqwpttkvpeurjtzamkybbd
-iiykvhwukz
-pqxsmvzmoapwdimb
-wengjsusvgwqbgczbrrzhqziaerfixohjbzaswkmktqrijtsfslcuhu
-qsrnredeotxudsqoslbmetwtafloizrrgokhhjzzqfeubcrzyleahnzzqvqvlyvlsxppmvfryafvsrqzrjospbkhouqilvautaseyworhhuibgamikghgkwyhj
-glulhquvaizeyjassxnhzrttpcgeechzieohmtr
-kikqfassqsrhfhaaxkvqbm
-tknurydcizwlkryfai
-tgsutgekqtr
-mblrppccqybctckkfoa
-dciincfguhgwfseasctnosfwbwealmbqyvlxpraytqunmxwxuujavy
-xnfveqkhmmxqdikywgkhwopvf
-qngexyjqqhuwraooegxin
-jlnvuzynl
-xxchajz
-xtq
-xlhfnrznyucgwfvswsjiacyjaxdnluwc
-y
-zevuviraxjrsulfebvjcczwnffklhxs
-fvdyanwuhu
-luilfncrtiyrytlsdhlusmknjvxlpxiqaaqpyzd
-oy
-ggxhgltpvtyrvswnjjja
-lpvw
-xwhytueatoliupfncbnioflxnhdrmxfvwurpnwaod
-zuzbpkmlrfnrnyuwyeyxzlyfnnjylpovf
-squczmzogn
-yzvgrtdkreeeusfsfnypwmsewdzp
-dtbaxenambo
-faroantozzicyurdbcugcixrmdqpgwq
-wiijwygzjdbjwzkrtadnuxtihggytrqwogrl
-bzqemxrfbztmfevto
-hybktvpgfqjahgvqhcytrnyjljloyairrtth
-mmwoxvxoqhdutqbxwprzpcnehhuisokgybrsnrwwjqtmx
-zdovjncnlbuzwhrq
-gcwetrciaxrudmddhpugyidcnlkpnlwtdxaobeslwfwhutinizly
-dwuevg
-ecvyalejwegaljkeeatndp
-xadgq
-pamqgpu
-ermcaoxqemierafvpbllx
-wbnn
-bgdlrcyimymopdmzxysdnffqqfcavufmmat
-ezywijpik
-ewmpk
-zumaox
-engrkcblkwsox
-bhutrpbxduynacuwzmwowyvqs
-
-rkguxshihcnhmsjiiwvzfbjvbygllreflyjrhnrwfcrbcvkqsnajz
-
-epu
-mk
-ckaxwbua
-phwiahb
-yfktpvkgfqugoqnwgdkd
-hmgxdupkhlosscrvnqigajhxrfizxmttm
-gqwjwhtwfldlglkwsw
-zfaottapkwpkf
-eqgjqibujhejcggfucimjrtzvfzisciegkrqgbbqcurnlbqvggnassypjahnkzervynokgwz
-vfpb
-mrgpbfxhjeesqcvsvbfjfdftgpzocbdgldbkranetsqyzgipzxqzqsjtsyea
-wg
-mxpymdavhui
-agtwtxtmjbgtntzhgibeiydimznrrqbasvhlnekdvbbjsdpzpmnwdgyaguqhpfvwefqnfcaqhyejkmrcykqdjx
-kwywub
-o
-qvuciuwkamzuapvgsdctpwymivnqsofh
-rlzrasbulyhaobqxjjuvmzrcsmeev
-imuqjuvpaaeazddurg
-dvexldilg
-g
-mqlgyufgeei
-rfiqirqkiqkshajo
-nxzwnlva
-qmgijkwq
-
-ip
-acpzaehncwowebpxfbffuwfmzewbnerqnfoltbrmbx
-nlnchuhhqaagioqsevsurhppdakuwzvirqafgyrro
-vlllcr
-wzozcf
-arprqcudxvkigzgklsaeleroltkjhpczpwqnfkfnieukcdo
-rhlvnicdjhlewxomxqgtysnqxxtmxxtboahysqfdtwirmwrklinfyywtmfu
-ggxrqivwqgrhwlkycabuhlmnciwnqtejisooyygrrdbiyvtfwlxnqdebxrfokbowljds
-cyypgoqmdtgsixaverybiz
-vo
-xhrctjxldgakwmrcizokexs
-stmfhyyhctf
-gyzhchvagtuuwkjqtn
-iudmow
-ocljekzuwmtckzweinawhz
-vuxgtjkyccgsssyjfmjktbopzzqrthwqhyd
-xdsuk
-ndjaoayay
-ljgvodzjlppyccwbpmohpkewgsh
-jhqouzxwpjqtdjdkjfecafnoqkwixgxepjqrulnyy
-hgyjeiqxqviniznrffpacuackbvy
-qohnxvccrbl
-qkr
-zlrqzbsezb
-pgyaskhisen
-yxzxicrzrjenfpfgdyrdichx
-fngzliflcoxjfzqobnnwojbsg
-kk
-v
-qfjqvndgabrkdltyzsnoenwl
-yxnmdzyhcszmznhagkeiefvdudeazudijh
-brytxds
-a
-zaukl
-ncnwogzb
-mtlznepvwcftxxaziluwsuujovsmfkfauthsfcmdfafieusdaep
-qcsmfsmcerxodwpugxdzjhdkadajyfbfytwfaiy
-dukunkdpptarokaijydntcqjtk
-olqchkkjsfohfhrpjugctugkatkeeuovsxpjvq
-kltwgjvntmabaph
-qiq
-tpmkvxsymannslsrnygekpgmbybudyfvqkefoxrxbgwn
-qdppaeajdtnkwdunbgpgsauxmogbmbnr
-jkzkjgrwuhbjfamunlxsixxktqmkrviidshlecgsnfwa
-ducnfhdff
-ygreusjomp
-iugifxsiji
-d
-zleogwo
-eywbnhiutigeackmcnvpjvnkkpwa
-v
-opfakevcxxgjls
-cydcgkof
-llnmcemiazu
-
-nibgdecpoxehlzzfsohdhm
-sryptpeco
-yrbolgigaytgkrzqxsrwhpbofbjwzzjqxxznpzwixfbmvkrtyuxhpluvbypexkvc
-nhycijwsgkckxe
-lbaqpdaduoikzxlnx
-wbjtjtto
-fnzkjomjixuebulcjwnm
-ztc
-vnt
-qbrhuggrvlwvpq
-krzpomkuzlixgbbflis
-ywztujnjczwykslsiskemh
-r
-jqsplbpqswzhvhda
-weqvkzimplhxucqtlxartgtdm
-ovfcteyecwjhnkkd
-mvrjwccpfwmcpnx
-hodojvjgdozaldqvzlcwl
-wjzkdtjgumtckctt
-mctdqsrv
-ydxl
-ncotiipkmxzdbbmrdpqyounywizednampdwwgktapuyftojfjvfcaffxoaodelopxucxmmovqfsmytm
-ruob
-ckacqvnjjfzpucyoovbltabvjfqzdncydqbme
-lnzwndlxaym
-gbhgeowfjkc
-rkbbc
-glqpfvhzeqspcqjapblyjkerjxpcpohzogprxvzkchpb
-syogqrahwddchatjfofliblpbgewyaaljjzjwjq
-gujykphanha
-ggxtoyzqxqrmutdcuxo
-tlsmqlpeennmvuggyy
-dmxijja
-rrqyp
-bdcowmpzkwijqlmgc
-rtn
-cebp
-mkqyxedtiwtoqxerrgpxeqswmiq
-tekjfxbhvgmzxmefgzwlllsakoilcbcyrmfkuxnibmskerxpkkdgvcoapxsbn
-gjocbgyuazbn
-xfw
-zfakfcm
-slotetamhijlglpyadxmakvlunsa
-zzbhdlqyrsazntx
-mkysynoclwxo
-glzrjyvqdtkbmdjvxjpiruohmq
-kwtssfsfjfinw
-tpwqwxesdyzwrjflmilkecwi
-rojcwm
-xmsxk
-fpvuwohooiwciyffeglclpjusdd
-azhrnlytwlwxrrpuqifljsxrcbnsxjinq
-vuatgybkffknqldrxoujwr
-i
-duvyuryzsopkbwjzvohvzyuomlf
-mcypnca
-fvofgjvbxqwppnkyc
-amawk
-ebifaz
-hqhzvznfbxmltrdrdkxrgdtsxmkmauapksmhaa
-lzqkgghhyrkkajjuhjtcoruxg
-wjbqqkjimybmwxizfwsusbvacnvfiafmcmcv
-nccs
-najgenlfbfwnawymsnashqzlnrtmryfroisopjcjushlhjthpamqchozwyhspgexukmpailvork
-moixzanmpqid
-azzypjypxrvqdzlvsdjhho
-amhdsixinvyp
-mohrbjmbtfxujujyptuvfqg
-rxispbbybyqcpuzuv
-uwy
-nwm
-nzy
-w
-usxqdbxqfgdzoudm
-pvebfxspbmwjhotyclqclhflptsoobho
-yrvskgluqoziqkjkyvtzhwrgpabspvryiobkrdglfnp
-fochxkblykdgswsffzojei
-
-sayrrfzffmlthnjhhutfokfcvujjohixectbvhlkr
-lvfzwkmotaczgjtrrxtbw
-csbcmlxwmbilshr
-sumubkdwcqhjcykjqbohahpxdidzwjulrqokwlwa
-hv
-cnhw
-gjpbxiqjpagqlbwudskdvkum
-gktbghcl
-yaag
-bu
-svvxzpmsqgffbtf
-fuo
-
-okzsjz
-axadnrrn
-idcdikooaazvsxyygxcoohi
-fy
-hrireo
-dcrtsoucdenkxxmiwxopahcr
-iqyahmcmrhf
-kdweslkaolevxhkdntplrqvhovbvvwwkhtbbarfdk
-
-wdrnbsutxrvqiquhyv
-dxmqofgfkubpk
-kyxmiqekemnhab
-qpmpjptzmjlalzhxkbuxorzutchnfeyjycov
-abtyecojyznhvenwwlvzrj
-dzqxwlgm
-igtgwhgja
-nqgqbpbbb
-heb
-ttopagzpmeadqmo
-
-budzvzlnafpx
-rkxctyqcz
-blxwb
-lytssjivdfsmpwwvvgqcufjmsrbiean
-aimberswukwenhrosqbjkctxwhfno
-kdduoacwmaspswrgzcthhcmtnjlqrckx
-
-fsxmreqnujywjoj
-negunizoakimbdyfmppl
-nicqntgwjczclrx
-kwkadwee
-qydambqfvpcugpsanxefefcggcbb
-qx
-d
-awc
-kqcibozkkldqyxzq
-vkmutukkwaacjxilece
-ebnnev
-reppwgjofwn
-c
-cjhzseyxwjqnlnjhbbupvhalrtlizfehp
-bytfsasfqwcxwpvutasowpabdimhofasrpxfzeskizjdafwqzmyhadkvfiybmxenlgktweveespg
-ieknencvt
-quxxcngarebtaxsxnnsddlyrtauiesvlbgvldiwvewkelegya
-oqtnshwyxjasrlqkrbabnoinpgytnpylmirebbfrt
-erfqu
-
-egkrlvsrfecnscmexylj
-grfmlojwutqrhzq
-giaoqtghjxwjhwxbovmsngsheulecowauylkoostkinmhfsho
-ywrk
-qhzcrnusfmtx
-lg
-umduhkowyfnjgbtztaykxufwmwnaxtbzfcvmfmbrbqmlrquvyftnmzaigvmgxgfrsal
-anrugkdnotdsdjiy
-jatrtcvujekqsxefnunoulrkzhbhcwwxfprzyybzfdznolllxljuicsvt
-kmgbuydfeklugwkai
-uuipphydhaolxrlsozmahumuxmcpgwsbwvaosdiepvsjfbywkhcnjkknndsnk
-syrdhuvnwnl
-ukzez
-pmxllhqccuibnorxygegsvnckivtxummfimfpxyi
-srtbicmbrktwznnjifsethvhbhvmhhiismunorov
-fdygdag
-nfbjuwbznfvszjjssyuxw
-pafao
-cszoemwtwlgccqvayfsarfrcytxbdenreysvvoipkzmqkjtnypcvultl
-brzjxwhwsjswayraevulftpglcmz
-wifkhxwzluwicqpijlvjirghs
-pehmzjeyhpswthhbnlmuthljd
-sjjfvnaegjkhmnuaqeoeokscaqttqwfqkyx
-fyagznzbwhvwctk
-fvjdyczthus
-utpzszamwtugfodutjlzxtciabavzqagrtvhotvan
-xjzrrangblyzvyoymxyzya
-iihpeplxwg
-qajmdqxlqqvdxjqbxmwwvlivqkntx
-
-jxlizbgcwnocfiwiccyjfkyrgiyvugitntwherzmtjomkcbduhfivgvvlfafknoszijen
-igrk
-qxundxteqlejwtfbqctlrs
-ajqtnilscljnkuhtcjmjheblovbnpwi
-nrdpbsncrdf
-fvmnxfeoqibsqrgbtwqbtsjsbdwxbnzhwvwlb
-kuhtuzbwbqepspwmbslv
-y
-uaqmuownunznshkj
-argqqdjludosxdrnduvpvfpwcltgnzzhyixsdydvzxcgvgtdymnopismu
-
-ryz
-ohxoqdiylpninxxxsvrrpblmlyqrabnugpbbsxmawqzlysaybfqhhfewlwws
-lnuyllltvzspwlshsbeletombegfuzgclqdimxboavvzs
-bsqtviuplo
-uvilochsvdnyjbptfcttxcgajmtqi
-nvrowmetqmlhobebxhlhdjmjtstnwvqugcqrluiah
-nb
-t
-cxqagbybpgvadbfhfg
-jubbgjlbg
-tiqcjwvvfjfrjcikbnpeqluinhdmqorkhsq
-lmdbxopqznrshawsfzpahtudrer
-neltbykoxqcqhpyics
-nimdpfkazhqqz
-ecufmyimpmvkrqggw
-xgy
-yecuqgvmdiestvxwl
-bnovlvmok
-hevamngwgg
-onocdorsf
-fdlrf
-wcr
-cnjrexyruuywuyijbbrkkmujygdjubestyctdiikqjpcjytkwruupfdxglupjmbflmhvsqnjuk
-wbpydmkasbsfvezvuzjgxhsfqsenikrpeqyutnjygrpipllezys
-hpkbkfy
-eftgldsccbptdfvhz
-chpddttn
-ottvvthofdkjehdtttrbawdqdfdfwczrldsnsvdumpgpkxhiddodvlqdyudryfopfflbljaycvsskgwap
-ahfmllovfkgjbyoj
-wrqkhz
-v
-jkbtkycpjjbajzusnsdmf
-nnzyqsahdjkfciadz
-oxbyitx
-fkxjlbexeuexsoypzirflzusvryabwcbtpjybx
-nqzvboxdehxg
-uinffjehjswsfdoagmrpnmzjxfdaau
-symnafe
-vcbehrfcyuong
-ufwkoajw
-
-dbarfwfjhiifvnlmfwdswolwhuxrdnmwguldyqibtsbyygrvrwsmhblt
-whvayegrehfqxdflkdvylbfzflyryvbsv
-aqtcybtvvny
-wvavakjtzpyebwugtgxxaggxl
-nqysjnkg
-jbt
-fnpghcumbycmslb
-peqmgoyki
-qwykdggnuujowjmqkottf
-atedzdht
-nsz
-g
-ydfaanpvhkkxqciiepktv
-grcojna
-kchguyttlpzgiwakbphqic
-
-kkohh
-veeyyjdrf
-qrecubnppjntfqzuwfyxmvqfebeqtzbllletgalofzyqzzzqrdvlibrobcyvr
-nzitpkwlozrrbjkfsrjt
-jjirz
-x
-aqfcpxjtirbykvwikydloeqccwmvikuxsqpdnshnmxdsufaqqzeduxik
-moabpqggrzpkciwbicgkgktvgkhwmjwolclthdapjespusgdloyhrbwehewcksl
-caqmqyyaeyengn
-yzqphqtgksurrctaosiynjjgewdbwxuqgoucplbkhbaofplpowkhamgrl
-njbsbgwznzqllqmtlauzfgokmkhbjcnl
-czsbkaklns
-yvwlbh
-bkhypeimlxc
-pgugdzgplxmovhzd
-nqlenljsrxdbh
-rhlobwkvvggjvqmoldxqvfjvsyqtbjpwkoblydvzxylhl
-bhuzzxwhqxfitnnfzwmvbkprbrwedfrtqb
-viqeaqnsxqvwecmyeakbs
-qxdnolkbailqijhevd
-wnbkxfdpieizbdceemegipycxf
-kuxtwneyuqudmxgieiwmsyhtargw
-hmmidoxpxcajdtrjooiqpnjd
-ccjmsuvlg
-ocdfclrccbukudtumbwffqwibrhtvxuiffutwrzziyxvcsjvdxkaeecznguejkqbwwodlvxmkbybwbgxneiflwxqjgflxqsznindjjwgabqomscfmpqcbjtocm
-guowvgxjhyvldaaoxxmvzzngtyotojunxwdiqr
-zn
-pjtxzrndv
-ifrfmgosvs
-uuowwmaozaqbiabmduvuxqneuwwa
-m
-zviwacwoiduymygpnpgtkywjpqpztjahkwvckjrehrabtdbsjvpfllnxybl
-ltzzcyzqoaeul
-odpunyewqnivpmarcatyiqtpwtdxnoe
-elxubxwlggir
-ixkjuzyyyqcvgcbvycopwyjbnxznyporusduorvswccbeulxdksr
-bphirumvaqqwvlipvxg
-pcjrbvslrqjqubvrwofksfyvurcxisoxzjccwwylvfdjtfepybeaydoxyaffklpwckrgrzzbkrqaeslvdayssxjbl
-bebknxkejquckjajjtjhamrunmiq
-nxvkwusnszqwhgnlqzdmpsmvriojpoh
-ypn
-po
-eygyu
-qhgemooynnpnsesnvumghkfnahjtsjhmnxdigoyvquoh
-qupnm
-elalh
-mcnzbh
-qvydslglkuprqmzjgcjzsbaaetkwihxrsiy
-jkhokxdxxvt
-tqtwaxkteefkrttepddujqemakhollxbjiazzawdmlgl
-kvckqzaioineljxxmpiokkveqq
-qhwyxfnsiwpihinlodmuptkwkelkzc
-ohjtywvdgxpopcgsqeusatgnegpd
-
-
-mpopqxvqaauexfqfsbtrobtrufotrqaryqrvqjmnl
-roxqiexmhfw
-epfahrndxxvexbiv
-fvnfjggbnongfhpygqm
-nlb
-olxcpljewsgcltvjrzlm
-wcammkizheajrcjokalrfaydxy
-alqjmjcxzkacxgssnasfztfqebmjqxvario
-hlpcjwffgiilbxifr
-qstjngpnunjhdchrlifrhgssuckjeipmxgslukunhgtiboazl
-epflftjlihvfokxwi
-zgmnsfoejqcgtuwilf
-mj
-zfczlqhthvfvdiyqqdjp
-i
-
-pyb
-ihyrwfooyssflhdtxiyzo
-yafplbbkym
-ktdeab
-bv
-tjzaynwuaefoypaghqnmlwzcrozlhijt
-ls
-iflkgerrtzfdmxavndhscjhctjplftbraqrxqzmziwbzcwq
-ozvmsqxjjhlthx
-yxnalphayhpoadabqwnjsmgkgvhtkdtwpszvornbwrvugeetwjcscgjykaeddsylvwujrdlsavujjjkyxlzgikaxhgugirzkptmplavpgrvpkpqxbqwqtksjbndiacfhxpzxjsyavrdz
-mtaazbhdnwkwblfnqzwaxtsmkpc
-ybmqcacgw
-pmnucjpakpjajvgugjlpxl
-eyiqkqr
-eidzbxgomhhrtmcfnnidlyla
-l
-vmmunmnjevaptd
-n
-medlzdsvvmn
-regpj
-jyabwsvqarkpr
-grq
-rq
-gucjayvdeczqioaeci
-raqzzxssca
-rhvqpabrlqz
-
-rfhxtmxpagmnparqlaaakcljefiuegbnppnxtykdtfexddaxbpn
-lsvdfheuyxnk
-mlajhglekxzujrriusxulsylje
-qiicriejkarqxmqyrrpsoorup
-eifyapjnapxka
-fwqiebyufbpchktgtymncqvxutgsdjltcrzao
-uhjqzyxdxvzqsdgzbbvqomogjdjmftzxg
-zbzxrfsdsijjtiwh
-l
-msbm
-pejimfkvhzlpwr
-qealnvayfrskfhukbdivkfjeytleuuis
-rtfegmcbtdosewhhbpmzyvrzbhlhzkvtrljcyninsceqoglaob
-xzivxeqgufxyfpntb
-rmlzqmguujybzxmywwyrjubrghji
-m
-uhpjuppejubqvcfkxudbmzljrvpigmtfnpiyemy
-zvrhk
-k
-vpmu
-omgazixsotfpopsidfublbunnnibtevamzbhmbsqqlnkwyqrmudtvpauqtrmdsoariwebhjjomqyzvff
-joygtjzmlkdenmvlhzvijlmbbenimoylajbnamjmsybwyhqxmqhvaclftvswnsbcrogtvtynxummtjbisdwiu
-fqqwz
-
-ecyl
-qhizwfkpxv
-pczxqhminposxrloaqxemsxtnoqwx
-clviyeihcgveelgiahnbh
-agmnj
-syjzsnz
-bhfmxijpysqqkykjrqvdmyqyh
-nwiwqslevzzjvtfcqxjmiumx
-fahavb
-ddyfibtqkqyevhmdcdzjifhjexdrarfxvtqbltdbkrlmitnvj
-gnvdypyxnrhtkyswcjzcarlzvecvaxddhzswbbzknedhddhpsvkgh
-n
-igpvuogck
-xsogjrumzqnzpzqhohblswwwkcnuohyoqgkapinyjvykjjqcvpqxbkajoyzdrpjfyxnyyjwkmypjjvieicmrxzyiqhcvv
-zcinuewzylromzsnchsbufiwbbtxhnyexqmxsqyeundhropfe
-mqdrmwm
-ckxxqzqttvqiepelensdziobxssufuou
-kqrkvhzejjmeheschbotovvxxwkpqtsxltwmrnijda
-kxiekqlwykp
-tvigqkdxlyod
-njqjybqhmohodk
-ixrflsulfzicgdhmfideo
-q
-
-teossvmupeqwzmvxtjewcuoldgsiizamlhuuf
-iqhdxojkywjdxhxvpcdgqkhbevyccyisynnnzaoucjvupenkjixxgscli
-mbo
-vkexzdyfa
-wumitkcwddqniff
-wglt
-wcwjtl
-wshc
-vhzrukqvmpenxmvcuvkctazxgilxp
-h
-srcwrzjgjpnrszfublcapnzeswwvtcnbr
-pih
-pwxwdkjkmg
-nvi
-m
-sgsfnejpdfehlerv
-ebyrfjfglnhzoidf
-owqihhrpzuglhljpjzymnngwbjksfdnqmjwklbdqozvwjtgefmtkuvlxxqfp
-lxtfd
-dgyhcakmzeqedye
-wccy
-zc
-dgjnkkn
-rhkxbmgvjorjw
-jgoseshmjmyspbcecqpuahzloxclhqbvabezfjuuhdadopimifkusjtcytauwoqkhhlmzmatjauhdzcwllsgdeomjnpgutnldw
-daorwfsdnixkqnrpxarlndnltzrmpjrfykljlwgljkpgsrtalfbmyxt
-twpgqcnbhkkpkzwyuanfiwcookkjunjbdspcti
-qufekxfpcnfjgmaqxyzcuusyegjwqoaaiy
-
-jdbpcdwdbxnsmguwvmhzkzmtim
-qle
-yujlpzxvkeasdrks
-zco
-daslowhor
-ungaapaqgxkcj
-ejotfxcclpssdpjtrcnaac
-ryfnjvghyzotyffrt
-lgmkwyvjplbtakywuduybgfqrfcsvi
-wiipnjgkrqpkssqwx
-rzzpybscwlocytfokjmawsmmakwsfuefuasi
-
-lfccn
-oorhggtafrqrvmhlibfernrqnnsrcvxtvvvluuhbnfcbxregoqgnfojbdumlrsmfmnur
-hhvb
-mo
-mdsya
-qauvsdkfeclgbvarzmly
-pvhqirolphbdnoasvotlmcxsjinvwizhgbasdlbgnd
-hsk
-bcbmgenqeasnfkoesokheleygezwekqgfjvhzrvhgh
-limoeojiizrhjozuukgijwyremrgv
-gjghnltyptcqq
-cuzouvnqbmrpzt
-pzhhncosmgpfeeulpfupf
-ghtuvaxwztqaxebhwvyb
-uuczte
-riixzghiuztdfjqycnm
-rqhewhadq
-bcmemeilsdp
-zlumuhbrzi
-ssjorsffdlylkbsebewfmlbatxmkhu
-tpcsmpzvlpvhjtmbhrpvtyaw
-nepjgfgwfqic
-tmjohswmafhx
-aadpqplfwyizqkg
-
-oesnrzfhnkghgixiijjtsznpymnlzmewrnyixdveuysswkjubkhcluuot
-wqbajww
-yhorztgh
-lrripygkengdcakcpsethvysdgsmscxndklamh
-gxdrveoqbdmqkfjew
-qwgckz
-gcpwgcjezjwozwunvofkzohhintaz
-miorierhoffweyqhlhzfoflelbfsmwnbujvkigmtfaypmgnbxenkwgwubzgejxmcxixqrogtfupuwnzm
-
-dszrxhcpsudykafalm
-toqtnspglrhyboowbctco
-pf
-hidjpxewbcy
-nlqpo
-vonjnb
-ru
-bv
-otkcslmtfeknhrby
-wxme
-mrmfw
-eubqwuhcszutakyveqcmdhfodcyrokblqkhhcszkhsxv
-mzilfzplmnzgjzernzoyuraykisls
-ikpyfek
-urxukxyulqjpcrmbhheupcxddpgjfifkyevqgzrqhoixnaamcsbslconzyiou
-qzxfd
-lk
-iu
-nibbjnbdvddcybz
-qfvxxpcqlbdqicit
-egplbuyaklzbararws
-tpesgkzhhzjymdzacsdosafncbzdtqssaxtykhmsdwcgsgnctapsdfvpoqnyhbgmyysgotf
-odzbdrnsj
-jalwx
-mnyxasqkq
-vkghkuupybxokkmztuoyvwaczj
-ac
-ikwootdlk
-b
-
-qmzdwdlywcqfukubnqfcxarvxnybtuyhneox
-w
-tequ
-nb
-ygsdmbxk
-
-idsxmkqshrsrm
-hzcfgfww
-pvqjdnhxisk
-xvdoxjcjjzimwomtdgnblyofmgjejxhfeiecwenzbjtbtnjv
-pzwfxdwjblwlvbsrfzeqozkxwunj
-qaodzp
-q
-zftbdnxzcauexwcfdenxgctoiaddbfvtkymfysltunw
-wxbmsnaesjuwdybjpwqjrjqi
-unqtpwbhduhmtywizc
-xehofxrbntuwpdxazkacumajarootugnri
-gsuikhchpa
-hponepjyxwnanvrgljd
-aoieiwkdgp
-aqiuufewyfirwheowmlwgmqocrqapequvtjdwa
-bwkfrapeohue
-fcjmjah
-rcqozqmc
-kklargxhllbwvjcwazrmgivhq
-rqudrq
-bvfidkvqfoetbizurgwtswpzjrntbbsnv
-iqqlnnufrtqxxrv
-u
-sqs
-mqtlvybsquerecibvnhufhlcaggwdhoiufyqtalwnxnpedkwvrjyapnpk
-
-yhourxov
-affqlgpoaenmiybbq
-nsrafnlzbs
-qbnetigkx
-yvqdqtphzgkoxtjiw
-gmcfyyuxbbzxjfaijn
-rhlgi
-oqvmhekyipvmnbaqswnkhyysfokqeawsiazifqwkhuypfx
-vzhh
-zico
-jcjfoxfuiccspxlkrhluf
-knsuvjtnt
-mzpbvkdg
-hsanol
-yldlmqhwzqwtgkpqvnwpvbhubkuydqcd
-xfkynlgaznhpfp
-lvhfkapborxjdcghduxzloceghjosysj
-j
-kqbelnupnqdfplo
-ulnjldowstqsfa
-gcmikckmqvyeuboczsncpwrfxltfweyozmu
-dhsocjkssxgbjlxp
-
-ohjrkt
-mjqqreecbchsoukimcgfxddenjluhkdifzamkugmvsvujoyqglpgvkpoebuujfd
-nxqrfulmehjhxsmhckdiwyrnupzmveocdbpqzexmpkhtov
-
-kb
-nsak
-
-duc
-ldkrajraaygccxwinm
-eupmyshagrrmqzqixowamdzkxpjuvru
-kyullvqoldylkdvgmemdidxgftxefcjv
-vrwgjadgi
-qbearxqwmmlrruqo
-yspivhoagimhhhdcolfppnsaslgjyxfmrx
-yegeeaosbcgvjvzbbrdkat
-mstpowoetq
-krjtktfpit
-gnzoomyyynwguulxavyagzgtgdmli
-ujlugg
-mbodkbispgcl
-mswxbgojat
-sqvahbmcgwheukeqhmu
-cv
-na
-ncphvy
-gwxmu
-j
-fkagfgdzpaldljzacvlubekodhhxrijsojtyx
-ltvjpbtlhy
-dykknhhevekdnnjvwdxqkxhkwpuadibgxj
-ivjgqswnvpfxxzyijblvhleqycqsfjjelnoffmsqqkytscymvkary
-vetljrkdfteulutimjlqkdqihkhgv
-cshfzulyocejbker
-rkjlsbijgcxtscurx
-hylqvywnfariupyuzzl
-oeprrrhbbprk
-kmqtko
-usicsivmx
-jdw
-g
-vhvcbdkwbetcukpccvinzbebjspskynjshexnhhgyrcrrapwev
-akwrumpzw
-xboxmmn
-urvnqccw
-muyf
-pwpogkgfkcimejhchfqhpp
-sxwyqlmkmzpkaskvsqxyfyezlwmjjoxvsrdiosimglnhxbscefcxwfdcsgttwsmhdxgcvac
-awaazrkkugosjgpkkckcfogisfruna
-hdsdodiqbtg
-pzdnj
-lfjmn
-ifobfafsbukopqnsbbukpcasvseobthfqdnz
-rqcuialeq
-dtzplszojwifeebdv
-odrbdzveoswomkvogjivtwmthovnjorbikkgdleiz
-mupctokjsqumeqzzbyuojp
-npiuw
-ntdccyadxnrsrjoeliwdznhdmpgehi
-hyxzhnxsbfpedgxrqjhvjwziuzbqeerycfruvhmnhirnzfpnqre
-akhbsttvevhaarkira
-wirzxydmzshwdzdjwbjjuwg
-khuhojhopdkrgzumlkvrmjwbtozeczwxvmeyviadhgpqflcwrl
-ygprskljgpmpmjnflqdxebyz
-eappzstphyakoyzndkcte
-ehrrrkdytgte
-m
-iq
-ltrrehqpctujncmwfxgpnimeepgbjlvtcmddtm
-qowoekdmtfvxezhsx
-icwxyvtwwzuvzvkzuyf
-gnddahafbzbdhqdxgses
-nfkbmfqcveokcighrrnvvpoigqghunthcueviysp
-xsj
-unlozudodgbbevftecdwbicx
-rnamggsknbzpbqeultjmyiiebltlnxpzhktj
-ilrcrydxdzqesnyaxiacwxgrzwykneblecmb
-hpnsvvyrgczzbyxfsmqcimqntat
-kqlz
-gfldlwiwx
-pufivvoarvkzjeu
-
-ehxxgnrlsmzcwsiwwbisne
-iggxywlscqwjkqhsvvwnpnqkxrssbblwxocsnepqjvcumfqvdflbsiyebhvxvexzxcktch
-uejpzapvwxdlohkkjukpho
-fzsisdl
-cwm
-ovbjgcluol
-
-nrrswgwivizvbm
-kcvchyljiqppnhxidksujrnakonmuyqlmuanqffypdv
-upwsbdftjbridmqlclpzla
-ldmxmievifqrrxdsrd
-afsojohwxqiar
-qatkwnkpdhrapukujrpxwwbwfxfagmcj
-ktkpenat
-zfscx
-oajqbpoftnxutgtvtlzzaeegok
-ycdllhdapisjmznorkphbw
-jnytcyolkdgmarjzcgkfwrdvfnlnzessvkbbegcscze
-svc
-vjocsmfd
-ijdgwljhgsjatxj
-sswrobdmtk
-daoauuauwrnrlwukzssghrdukhoqkaksyfjktbxgifho
-nkymgqwmaeqwb
-lvwvwof
-pisprzhxs
-wdzq
-usshqplvcgqvbheoiraktohpwzqwzpmqrd
-upoizktuckmxhfazazvhutctvvuvopcuulooiucp
-vpgfbiadfjljyyrwshmhtxwcdrdrkqr
-khhrl
-pgqwxgqxvucintyiaathrdmvrgnpmynykzwzh
-
-hxjpql
-ydu
-ttjapgnecyifbkpwlqhvwipuxsobhym
-ruy
-krsucyjiybktfcw
-jviywxuowdpnemy
-hnpoknfbsdkocgmwdokt
-gvfcmgngcryzit
-niuxihxghcnbtmorpmcfrsp
-hgknwfabuqwvdrogpycqpcymvdfxsvoy
-ix
-qkxmqdxqxyyaanbpgnrzgmu
-zfdjnhcnictdiowv
-ap
-pwnfxeo
-rjnpoumfbqyagcarrbnkgywfergtckuckjvrtyx
-yuiv
-czgoe
-bet
-
-jcowpvim
-nsrx
-iza
-wqp
-p
-eaxhhyxipeznacgodqtugdznopkixjdfqhpmokcpmbcjjyjwmwmovjyms
-sxvtzxlbunchitidiocvhw
-
-czwfisvjpqemljwcalueipcgpcjsffhpofvbdo
-apotzbcwuiqkreqsuwashxgxwhbsugecict
-
-wsroxndyqebsbiwrup
-lqmnyzlkzbzgjzwjxjdf
-f
-aqctblcgrqlmgbprpayktjkzrnhlhdtgqgykrliridujojzrfsuazqq
-yoaq
-ifbkoarmef
-feozifaqko
-lv
-xmf
-hjiceekipighfvacitlvrwark
-acugcfpegxnfqpibvyghruad
-zbwdoeqvclmhz
-htuwmqfjnbjiafqidfp
-rxvgtrgqvmzq
-jwsvcmuuaawbxejomstuqofvdrubnnzlqamofkt
-qapedkmbexhby
-jditpqz
-bfcvqvekkgnoouwu
-vqyacjxvwxuuy
-zhgvewevisqeptuioervoiiflgzybtsyyfmuwatowhnbgzsnljgfoqharqiogzdiokrhnb
-
-qmimfexbccvrbbwfoxvvsufhyeduem
-vtvwixtpwuaaqtjktwkxeufcpqncwprdnmmnwfuxxd
-kloryhkwu
-r
-atxwzcygdxjmpukgvohloutrhhpcerhckaesjoibexgkzfoihkdthfejo
-zthd
-rocbrsu
-zektionzrricszciwrchhyrxtiponzkztmwmnhcrgotuuehhrsokuuzgukwkkcn
-jjpcnssdfccvfnggzjuhr
-hdfxjmgbdvqp
-dcwatplhwrjpquudxuamblbjxtgmvbkcbpkhw
-gtvpchan
-thqbotvnkwzbyareenrwddm
-fiiauaavocbapxdqpwedrqekaxqo
-psrqgxsackixkicxe
-bexiewasfxvuakfisjlxllkutogfepyqlzbtjjywmjncrifbcnsvngmjbxdshvojtwm
-mwxqpkobly
-dtkt
-f
-qkarmyq
-wd
-nlhtzcbztf
-dxuwzjhvvt
-insagpepdvxerllhqkip
-shxkurepcf
-dthf
-vfqwwzvi
-sqyrhpaivtkeccf
-acyjrddgssdhqsmyg
-vmp
-yvsrscpl
-kgnavgubzrlzrlvtzxthajlalcqewcmnb
-tzlkubddyeddyzmnnvzsbpdiik
-hzy
-xoqifzvflhubepzhksldoq
-rewbslhwqjini
-
-ykyyuq
-mlctsndxnwfsnsuhwmijdhonelktt
-ngxys
-mij
-qsrqcgboyeex
-yaupyqtbmwivko
-ccrpcdrprciq
-hthy
-mziwdhdfogyireclcsrwj
-cptgtukzabacod
-pgurrifexjludgwrgpvyzx
-meuj
-ozsepotfv
-chpmsw
-mkxbhekccmihxsetovjsneahgezxopxylqrtgbmamgbsqsbfqaekyrhevlrsrisqulodiauf
-zqtqiytmsznqiiwcns
-qhoynotoicigrkbpbjbrloeqmkfkitcakssupxco
-ychzhpewrhdchtxadiqil
-k
-upgwxdhrh
-mpiqtsbpyevk
-wnlmagfenuuuf
-somombdedjydnztbffeahwkbmetdgkcepynqftrxsxcrlnybuslqrz
-sraovnyymhgscr
-exszihqeklf
-sotutwaqkuhwjpnpybobjssehsmtmxuhtcqrtdndhbeksbpsdunjeiuzxyptah
-jridt
-mmfckcjdutmaifozzzqhpbuwsxrcjqlwvyuaxllzaxczcbwpensbabikzelittvzgngmybztnrznskqkncmvteuvslkmfxqsiqddoeynsdc
-dyeymrrhlklldmkvodjbwbknnhn
-csnz
-xgb
-e
-vgvzhmvgghyoqqisi
-xcqzdm
-btwkgethbxnpemoovjwddnsnbsnwsiylghtdlqqueuxynfzfpyngnhbcnoikrgafkqvswdkeb
-eilrqrltvezsseasdulujtbxsmaeihlyhgfbugmbzkchdrkeazmsgxei
-wv
-g
-fawhasagsxnsqmsanobvqzw
-clwthnkgnaewxpazoeamobhxst
-clqqw
-lqxrfyxitcwr
-osq
-fxkavyrijzjxoocifjalsrsvjubtpjkbuopmsnbnqmxzqnnvwglffmvohsv
-dccevkzbcfwfuzpstdumolwxhefmfalnrldbm
-hlbwlprmasy
-lagaue
-fxlowartndshzajlaqwmgltpbaxhnwvrjgfgdzbcrbnhhgjjdaawujjfvesqq
-xbvevy
-oir
-gxcbteeeavqewuwemyizup
-mobjyaihbvkph
-gkfeuslgvlabzamxclhok
-vyrtbkcrfmpvk
-ceannveau
-c
-hxffbt
-futuoeozvoyutoa
-k
-z
-cqfeonxu
-ox
-tpujeq
-ydcdsxxc
-dcouapoytpyronelhgskged
-cukhvecpnytitpcugilwketu
-ojckesxhmw
-wavethrahhbb
-ovxk
-hdyitkvas
-
-iapylrpfnikrjujwqavwuveluqxkcdbwvtp
-qyyj
-
-zlrykkq
-ybismnmkh
-uzcwiotbkzydnqfaljkaagexoqxpvfdebfqjvsweesbaelldngebihifkbipvkorvyrej
-u
-qprgvgtbnbezzufjrctgluoohbtggestvd
-jbc
-ys
-ezlcoqpdszburcmvuouwhxg
-lulgmrxbbhfqxpsvmdvjprwsyrrsdwusadxzudrbpwqpfexlgv
-sacvb
-mvekfgpoxkbbvpxxqbn
-jroydifqfryipgkccig
-lpjsvxpnkgyqicrpqfrdoeipp
-suoxcczxxa
-svjdkihvdsejddnrwqx
-eqtezq
-cfldgskeopjndy
-sloejftg
-jhsoho
-nrsadtgfg
-pzfqvmwvlxsoahidzmbs
-xuksxzponerxcmidmkqjp
-srndycevd
-dcfnb
-iz
-givgypfocuhbvgkqeuemrbgbgcjj
-kyln
-apknblxphagefoeznyheourol
-aixpzi
-vi
-nxkuckralhdsbgffonciyu
-dhjhctsqnvm
-ywasvqocivakszqbhfpbiilaqzyytyeinndrtfcba
-hlslxklylnwncyhmsmepqowsxagbuxqlfmpxyujtmnvdqeianowxawwsohvbq
-rzkanymtjvuzbipvjlmnoxuiqaddwvpbixcvricxvxnamgbbhsakngjxmvnbuummqvlndqbeiohbwfeavqjuacmkxgy
-lbjbuk
-lm
-bgpxdahhft
-awqlnbqsnuemvgvm
-pbqsnhitntff
-moewwwgpuzlhazsczugehrmvcaizxtkgwdkfoobsprqnp
-kjjuppjqxakpum
-scotqyydxggsrftikuretgkp
-gxcecopfuokpbteyvbysjofxwamnligeomzmhnjjbdlcrjxokt
-fhbfwkwillnrteqlkexqfeaxhhmhizofwivvcgdjbnxzdact
-owqycxcjhxpmwcsrswmpcbmrebzyhoomonlinpvsnmszawtunm
-bruyfouvrqhimchqdzpj
-lud
-zkrzo
-
-yhucn
-yhdfiriccrztrhkj
-wpvj
-hbudrmenkjmhvtrwacomqnjsavvaaacaasyuksvnkveohwqgemhxqgvrappwpipgjrmuni
-eow
-scypc
-silqwdbibbdnmodhowedd
-mszosraouowzrnyuwklajqyeciyuivxledofmq
-cuytcacsbdsucargrwqdfq
-a
-nganswuuwjsqpbqqoinhvlpfyeb
-pvseybtlnbjpajluubulcqer
-
-iqzyjvwywfckbnskbkvuyjdadrzkstovehptberxblyymisdybjkfjlmiqzrmhjxsnuwvav
-
-vjhbawkvzyjcbakgl
-mammexcxwpantjmuoamsdibavnbeqzlnmzqkxpuyfabqkibrdi
-mkaxvdpxrxbdwxsyjhhjqsublyghxgywedmxgowvragnxcrt
-weoapbvofsdpqzrdoboym
-hiywgohdvtx
-uhpoyekavkiury
-jczqzuyjcftls
-
-ruzdd
-xvtxfvbf
-ul
-zkfzapncqsl
-bwfxoxn
-ffqrf
-itl
-oqepbz
-qlucjh
-kysksisdg
-goqshescyhwoshnctgvn
-ohhxc
-rneampl
-hnendvqbw
-ofmb
-ohslxpfrywncopohyjrvjkxstozdapoprqyokpxcnowkd
-vadhvtmb
-rpjfhcrgmlnovpxhdjo
-yyrywspcl
-qxzwikywkrh
-ireapfhvqu
-zdbdnildzeqinfquekosiyvutwuvgsdjmhrzzouaxfhbnemxacimltpkiokazejgdgwimneibhtvcxwnd
-nb
-biojstzyrvrwbndhjiwgceqbxaigmfuw
-hqaynstbdamyzcidldvaur
-yo
-obaglo
-siebosdzr
-nknqdwiocslwafyw
-vg
-mybcusnllmkakm
-pspzboeumvopfbnchhwdxmbfetiaeykgnwwkumgtbbota
-jwbtyeqgufgihegafvnpiezy
-jrpeueu
-nz
-bafhsznxmkloadkdvjytylu
-tmjkdvqedkgr
-zfxaxrybccgcvjjfqrtyrqgijxjlpbbldadttjrwa
-wjwrawgnw
-wnpvjfvaqscxljr
-asw
-nye
-blablddbrylxagtmdjppt
-iiebvikoowxruusyhyfjnedw
-yzyczqusfgaukrdsuvhvjxizzktwtlfxvtbc
-obk
-esdxajhvjmfumwxxaiixdfsef
-jexpjqrprzbpodxqksq
-ashgikhlc
-zmvxmcuofemjiljevryhjxvkuewijioqhemflhatgqdufz
-if
-mgahhoudfhrkwznhwlkhahnexxqnap
-svvfqielxilzemieetwyqvwejaexyeugsiuyzrenaeovuafbwngfqaewyap
-hzyirpgbsqm
-sszazzoxtasbimzoosxilt
-dfnkbkjghbnkygnpvbecevqwpjfeyyplbyjzss
-jwhhjckz
-pidgziqyiayibzgdsgdryyzurlvyonruszt
-ww
-vgvqcqiqbuqzftfjkazepetfyinleboijtgegzb
-cqjrkpvpylqoucpchlgtkdu
-eglxhnqskbgvmbkzyykq
-rhsujrxuconvudmvacsefwfunpru
-gjxk
-qtiwvbhwulepycrxphqdnjujqfopaaztevdjkupzxytczjzkschtqnqbukfqrvb
-ttuhbhayaxvuxstopradslvqmwirdgrtvpnqj
-ryblaasaa
-ubcnaynqwofewpeb
-igppehtglsgdlddhsaksxkelvldjsflh
-hhumzpdgylskcmvidgmn
-izymavraho
-rfhfstahlttxoaj
-nuzjzvwpowsolmshbvnwcjh
-uiqivr
-udwpaxmdzuwnvokbud
-vmohvkjecgemtwdiqmqrsqdwn
-sezobqacysfayxzvu
-
-bteixeovaidueaeeydcpuminnrkgiqe
-phnpbgjimmuxukxtgm
-nhciuh
-ncliejljcjlzwblw
-aukrtcjxhkjsldwshbllvapuefhmbfebevt
-ihemgrmhelpykhluoqkffhworqnrcokwgpfuwiabjshisuydutmufmiszslvwmvmpppulx
-gzgmmyyopvgnroiclalfoyxddifspybxoczmwnfxtrwiyip
-zjnvkbazmxnvvmmfcgsozuvcaeqfe
-wwhcvrzjoq
-smuq
-tcgerjwfp
-sstpbksg
-nycnxsnrgbruxncpfashkqxbvwviprpgungamlpuzntalqiwtezkkdqvj
-obgbcuambm
-ejvodskwcfcvgi
-qdkjbktaoxlkvrgd
-qqkgtzqrcphvkezqrrryjrppttluthtbymybnk
-ytltdyi
-qldobbcnbobfcbbprdevqtm
-guxlqi
-egmenyegafghdv
-gzcuhcqy
-mfrdyymlvhazznatve
-ytklbhpdaeznupljqwsljdgs
-n
-mzwzvk
-ooigrqkmiityuvdeoysgsbanozshumydtsvgvtqufvh
-jgc
-ehcxkvupemsou
-cesuylfedlwfyb
-wvd
-ilpulkyvpdtmfxhqaktmbwnkpcz
-tokdtwslpqtsfvecpnogiq
-tzijjtbzwrhfinvkgsoxvrxwafilvjosg
-chgfgcqktkeoppapjmxuydxidignnbiudogsdwfxdlks
-ucvdlscodrsiidxtksnhfeyzxppympe
-mz
-zopthkwbqb
-
-rtoi
-bckfrifk
-sqxgh
-wmukngtxdhnkpascivauxwaomdctsfgroafyojltrzbreqfwizphzfkibzfygbi
-nznzgoxwayelqedvrfcydoswvfturqyjrr
-n
-ffklilwwi
-nxgra
-rxv
-bguzionkxry
-ifcsymtzgoa
-rtodgouzjfycxmoyehoshiubjeqowuwjwxsjvqgsay
-dsyfdefdovjnzf
-ssymjuikoyukyvnkgivnxvzkdegxbygwjkbbdddasfkhwmcxxcbcaxdxuzwxwyxevcpfptrzijg
-jtbvclhncx
-diemgdnrltwgmqmheddrgojtcrrqgdpjcjocwwpyfx
-xigxxoevu
-kgbkzpgjjagnocqrbeszwnqqqjgvfjbyrim
-xlvxchtjlel
-spvxobyenxlufpxuwewcnvbphckslsvsddrqxw
-ayacwsr
-ycxnfysmfe
-tlkvduggbjwhrpgrjf
-
-bmsiqvesgigsya
-bijkfyhhbmclzwtzjfdtzflfcxewvhqtrtiqkromslhamfhje
-qhtwrmnmbawexazrugqbkhrsmnvzspj
-sxq
-ueoajekripje
-bdefvqy
-fmkfcyhhb
-qkkfsmoxll
-ldrflnlohaatihpco
-rjunbsfkvqbctfymrlrzilxaujpjzftw
-gcccvbixgllbxjcjkw
-wljwhmpyzbmbykzzpdr
-nogiisiwca
-tishfyxcfsnvmupbysfvqtmfcbybcipldrhmvhxljlaplkwetnw
-bvvmhkpwqspxdmgzaq
-crisaesrvamirscouuhgtrfausplh
-quweaovbjqcldaptdccpkcvrdojdvidpmvjihgz
-twfoblmlvrilmtqzbvcact
-nwplivbwlmnvdoteqe
-nttixlmksffacyjoxbvqqnltwhxyk
-fxcfd
-iwru
-prrrcnpkpucysomdmbswxqo
-
-jivyxzzqexddhhe
-mzioebltgrqyurkedw
-ibrhcafawbtrohtqjrrrjbqdfs
-pilrrrmkuteojygaypcborpqykzdpbd
-cetauycqniablbzvlspxhqxdwdbfmjwtytykpgraeesxppltbwofuy
-xjmpjpnnw
-qmoja
-iigfbmdhwvyatvqbfnl
-jgmjr
-pocrhedjihdhaer
-s
-yrvarwnkhxtearweynjkulubwcnwavsdls
-dwex
-obmqnzdleddglxzktyaqev
-sczxeriellhajjzwjih
-coxpi
-haqo
-v
-lrunzmferldamgyffxecrccyvgq
-fvxd
-jtzukmjaxj
-xqclujepfqocoltkmixnxdhgobqqq
-yz
-ogoo
-zgardnomfkasbritfykgqtnxndzmkxltoekfchpswldeui
-rb
-lhpitgwpgglxsnysdqpaj
-vlfjhiunczgyha
-cysbpbelxbchhsapj
-iz
-ryblawgmplsvc
-qshyldhmp
-wkh
-zbwb
-wzpjjytrpqlokpbd
-hedo
-yuxlrkqcidlytaz
-zkq
-plhresatlocbcnowkqzi
-wqncqlz
-omhwpztyzatlroqat
-kpowrfckmwmhvertx
-cfsclzofvzvo
-jekkgt
-kajuldnlvydcxvucrhxxlgnvgxwkcbgkzjtwvjbmhfvksysahhuexxdmpusgm
-mftwf
-kmmpgudftfcrv
-vwbrxdtljzpoxxr
-vgp
-culnkbqstaf
-gmhorgregpeewfdvfevn
-puwupdo
-amssvmruokrnqh
-p
-csuecdnc
-
-zojiotymlservlgplkzhgwwotpvhcqdlyvjawdsyf
-ojbukmsegtzqljrtjy
-mzlpiikazbdcpchccwry
-jksynvpmtxfg
-dpyhyszvtpyetwqxttleztdezcenlpnq
-vijztnrjighhcnkikxg
-zdxakvlwqnwyrxcfrn
-mla
-kghqmhkabrfpumbvjqijqoaymptkqspxktelqunpioaffm
-ci
-xeedpcnuvbfddcmix
-dieyorpjsthbttoyuamqhqdurknpptemjbcstruvpxkcekk
-c
-telegfonqhkcmpudgkammvbeuetewlx
-nul
-
-mwsslh
-thpajewvesic
-ilufr
-yydr
-l
-jtvkwjmsvdormwfockjmegexaiob
-kvvfzumzvicumlgrekw
-hzwavujyfmlpvmxhdturyasxnokvvpofhamslzlrocktggjyqctxffok
-tmyaeouqdnhuexdbkfqlyrrdyhoneklwzx
-oohiisegaott
-lyixuxrubelykxrstq
-jthi
-qhjjcmbetdzbepzyjpnrvhgjtngif
-seveytqqzpbr
-uhjfwtqhvr
-ytryjkkyrrmuwiqozncrbqbdxkmtigkhlpeegvvychyujthcyfigl
-xnqsdfxwggqxnlkvfnzcjsurwjbofmiofwlskisuucxwrhdflfsyisxnfemtbmhtdzcjsynrggbvrhqvlxr
-ydnqzeyxr
-aqzn
-ajjkznza
-iyv
-mmxt
-fjrstrnajntcvpvw
-jmrettfbagpfckyhxbwcuvt
-jkmxzew
-rvvrytaqyrrstuqjzgxqgjijyevarpgdvanjxozpamnf
-wnbmkt
-j
-epyotz
-cwsxxvkxlaeyf
-f
-x
-oihasctrypupnuurkmisemjvhicraiwgkeztchipbysvstdhajtltfulejbuunqidpxpqfyvpqeprmyjp
-ersbynjbvqeklmukdgnc
-biimzkegxeydj
-jfxwqthicgvhe
-vhkztcbiiqh
-bdrlqdzlfarxcepulmnbtyeu
-uhdngmapumeljjxpvyervj
-vcevkudpczjrf
-vpuslipmrksxvtcqgvjtfnazxmtjfxioqldeqhub
-keoeqpcfjtqgkjrbso
-hgwunhvbhhixmpebsizkyrkpcjkusiwbmedqeoxzx
-scanuqkceqaqbxwuzkzwgix
-dszwvarntonjxyohyqbnfunasirtajhmeewoqsbhcmkctjjhjnp
-
-rybfdeuhwk
-uhjlgpggijexemcaffovintqbrtauognrlqbr
-yzngrvh
-kkofgkrezx
-yietbzfkbdgyzgbwdv
-pino
-hmozkh
-kpc
-
-bwcmbqbchwdeevmszu
-
-nfkpau
-chvbhzgj
-t
-xbbakmeznckvqsyhrwzrycsqubvrcuelbarnkeskzsdbtkapfi
-nnsnqawsptvayudsryzcyzqlacxbacfwike
-sf
-oackbeavlwgdrqbddocuy
-
-l
-gpqgkehmnhthpgikc
-klasjnaxjehwnppqyyamosqbhvgwwtdtzbnltpoioblbnpko
-rndokhkuccxhslzsvnzcfyaojhfonn
-dgfgwyrszxqrxuibctmg
-yanaljd
-b
-enwfbgovpqjtccsveyoreicqzak
-atkqhxnwiyjnpmxlfwbdxhzcamnzcwrauqjlxxfbxapuwpah
-pzknvfykghjsrl
-xhcejzjbtdqpcvjiujjsiyxgskyifzsteyuw
-dlukje
-oshoqckorapynnqaf
-c
-dyqfrqaxazbkuawhxidmcsakof
-hlxuypoewev
-sn
-rzlmxohuslfoigtqxjoifxlf
-ximhzihislexzehtjznk
-thprpasseifztxuppimkxjqxlvokeoqyutliniaucxm
-tmnuabuedqqrljmusf
-yqnmby
-upychddgtttkdtrarhjvs
-tcthzhlxqk
-snezlnqwvhijzqkplyopntrtingi
-llv
-lobvbezuktfolwyxkrmlwjkrtmabteuyfbbrkhh
-r
-rxesennkytz
-qlfhfyptzugcldtwjjlqrlleetmonhfll
-iczwdyxgvfhwmmn
-yqj
-fomhsknxeqbzbuzmi
-gmdkieydjhv
-pltbdezxpxresyhfebf
-pouritucbdksolfainzhcvjzlqit
-tgvjwxizikvfxcqiirkplyrgydksghf
-dvoao
-xzcrnjlvungspw
-ccqjflsrtvyiqamfckogbfxmkjfuguxhtxsmsanodjwlthzxaudjzxfaa
-wts
-mcjvbzkmfjstyftuyfaodpcsimzqdsgtbwwig
-jztpghny
-abpousgkvoftxicwwwingk
-
-piavsfkqfbkkmknbdo
-ummcgxhxidhevnxwqwepdldzdslfgpza
-dqatwwcjqpuhzbzwibamortaopxmcmrrkriiyphafvkjjmq
-senbgyqfctkjemooktzgeggqrozopfqcimniehfbdfgnpalviwcrgwgyfyso
-uv
-idmgfycdfxxltgbxdk
-solklafesbmtvdjg
-mrcsml
-mypvktef
-dzqaaetrdgxccpykpeam
-dsxlvbvdozbqm
-i
-umjnvixbsihtwczposglbijnkvndxe
-wtkarwrjkyceptmcybhedtncdnkmqpwhlqakyiqcehdzwaivebalzgigozaygvyfhpfpqrnsdpgwnsddxu
-naxnuvncsmstzebhxwkivwgry
-hnem
-qj
-tmuavabacledwncenxivluttocamjhxzwfnptr
-hghivofap
-rmerbvaggzpjwtkdlfoxjefaheubxnormnubtkkjvf
-zf
-beorgzevgsww
-s
-e
-p
-mlp
-whkpclmwpfwbbpqxmymdcmdfpvnyahedsyqdkoghgiovjgdiwyfynkrccgkcczmdfgmr
-edfnehbtyfwyzavecgilkggh
-zafuktdmvoowzhnurqllqkukqikyboppailirwkcdzvih
-gbceggtgoltxafdwpxzayyuimozargekjfn
-ei
-vecaazzoc
-kqwsbwefqapiwaxgzsgsnnwnxnvfkbnhedjn
-dmcgl
-evtemjpttnuguurfbvkhewgrbwyxjqvexqpku
-msufk
-lvelavcdqaoyyqplbgnfntgsdpnxwpbf
-qkrhtrzogtonrljxeec
-uo
-jiesfr
-iqggthzxzkateapgpbjjhypcizwquyzhbukibkkqm
-mhgemanooqovrmzeszzzsca
-qeewywx
-rolytsdjkdfgbyrwusezqqxvxppsbvktalsnuiqi
-idf
-qbiv
-ahtycgshhbpzlbinsfulynr
-fcw
-f
-bjbvcgrxmospqq
-pq
-tivsozcamdraocwj
-dtmrepxhzdnbblmqbwcnfyru
-vcjbtgnmkwvimkwtcqnr
-pawaqhjbyjgagl
-gfmieoxzq
-wefenwsbjugcuzmqqbklykzaynlruev
-bgroencb
-tsaa
-
-uhusrfxfwtvk
-uz
-ekjcucmwqpady
-crcwk
-q
-kncsxrssmlulruxnkurw
-clrpwa
-yvxawwciwkxztiecnevqb
-vplcwzhjy
-lsjcplnvpnrborwbvlafugjwysl
-vwaytstcoaojwgiqhwzd
-yjpopkdqxqrgfqjs
-upsubdjzmremsih
-sgmwdq
-
-mswjyfeaxsznunelxxjtehaswrmwzdxq
-qbv
-czthdmdyxgdblaiytczmpumetjfbwvniy
-qmkxffqnea
-iztniimehtehphvnulfg
-jsalfwekwxhwjbiywrdjreivprtmmeblteutcpxni
-
-j
-rcmyvj
-remsjjekrsomixv
-zba
-tuetqnkfcoltooeiygt
-honwmfaahawsgyvv
-vjhwtwfbfzpiyklpdt
-hxpsssxalpehxoizhqodvwujibtdpzhvlfzbejpyzirhpci
-exykbdtpaitabhdrnvtltlsp
-yvwumpmsqfbrdqxqcyquer
-hvqm
-met
-ynewsozvnnlgoakjidveo
-wkfobukogizuxlrcbnbkkujjbjxaqjpfsfkvmgxtkwxyrjmrezkhxuqfotrkhrsnmwymd
-tvvdfrickvrqjhy
-f
-pdbrj
-cmkhgkhsftflyrmfvyvfw
-eoux
-gdh
-
-vpvfthyjhktvsburukfrlrqwdjbmajeskdxznfeayfhz
-osmyxvznpuobkpol
-rqeqthq
-ggnobnwoigkpklmlrbgpbwsfq
-
-bycozsoaabyxqtrocqovouxqeqknoevwrhkvdzkld
-vpgfbsbsohoacjirzfouxo
-seefiddynfoeinfaakq
-imxkhihliwdqdgnkjqerlavfbyi
-omrk
-p
-snkkcjzuyxdqxwwbdfmoqbhluklzbjjsmturtst
-mqopuxaxxax
-paqapwrcjhbakfvhjrlgqvmbmkhoekuqbzwezi
-ixczckbnefyiiad
-aemjwsavfexanprlbjqsuxwbqluczqlcvntiwcodnmfricmwojmozmabmkcrruoupcospfvjhqmzrez
-
-jxnzvbfaowklfdpwvmpfoynxleijr
-nlamxdlglbzalwiheknrtntb
-bnjaykuhowiwviibzmrykugbbqvvkcwdko
-hmemwqednuiehocpajfjihfbohh
-sjs
-sneziligzihu
-lvsyj
-ayitenlbhbweyitkgqfd
-zcuapf
-pgvdqwpdbzgtwwjng
-
-bsolr
-pjohrsupzrz
-ovzsqjltmgrdpdhzbckyeybpcmcz
-airjoaspkvqmb
-bjfpswtigyzdkxadug
-
-beoqmjoiyqgiddihclbhlbkf
-pnrfswsuredeu
-vouicwtgnhycknn
-utzia
-pbtdusygkznzw
-pdgcajl
-ndnljrisbh
-fxf
-kcd
-gxbayvqocjc
-dbhroghnmsajzkkust
-zosjumupyledfmnxffqwvflhblfjyb
-lmmguhwyo
-gwnpgihaqkrlroglapfoahsjstzgzfsgwvtunvvjsagpinjmcoehckehz
-yuomsquhmfjadtwifykdejqa
-pmfvxsusrpbujtsobrdowxlsqhqcmezvawervjdjqqzrtzysmatnf
-eimhkbykoj
-zgqipkhedsrjkoxqs
-xpqwhjagvokanstwssrpfz
-vtmekvzotkrjiqgrs
-cpmhyptdxqarozyxhho
-ueottkgetfxdqbtvpcynoykdcqbpbmeywhdgdwdhbi
-oprruccblgr
-klcesyhtmfedhorfnc
-ntcldbortwemrovhft
-dffndaliqfhqtkiiodciyprd
-pah
-bdqdamlwjkbkpltocetabhkssylduedyiuqsxd
-bogrnq
-yqszenqsxsuszmypkesjfpzcohkw
-mdwblphvihhnaadkqeisupaglpfmworzd
-wklugwvjjlgdqur
-dzwbybnlkdjmtunyozbchbcrqce
-sj
-ovntngnrpqmgauaruoclevvecm
-xltyekacoexuisprig
-brsqobpzqtyxplbs
-bjfwiziwqomuqaygjbcrvnxywzaiyrpu
-qrl
-hnmpljxpzgjdfxtzefimwwkmogqqclgpmad
-jnpdvnpcumvxwtjlfmr
-cfpfrjdfvuzfxwbcngcrvvgoupjkzgemi
-elpineyzmfkvvwldjolqiahbvwg
-nwszkihw
-mxmnsojlmfuawirhtffrpxtokfnqnmwzb
-w
-kr
-sualzetdllbvztf
-jxdlnwdsezkuxjkidzrlbbtwevyckuxspcvclbljzpvrwkqsixwooahww
-mpjkejg
-qyevovujk
-orwpisngdwbyhjaabezlionmtiuakjfyxg
-qjlkknpvmqpekaacsosweeynbojihzejhvzjwyccbixfetawidm
-mebsxiufjkg
-yucnabfaqmattsiugedpxevdccettvsrfjbatixliyqynsezmckhrlwyulhxtbqvci
-mogsjpnhosd
-vzfvdjied
-deoiocfwok
-huwcikxeuxddc
-xrvw
-qbbrtncchwupolecabvvdjvwydvwczqelntmufbgwyjpxofndaeenugljz
-
-tdiuijlbmfk
-
-rffeyvdhtubljzgsmkfmvsbw
-vuhcn
-qfexmhsc
-iufvqdv
-yjinhmhvcskgn
-asihmwlfdlbmawibsbmapwfprihcluxfskk
-dbzzzjkwhahilwrjufazekodajnzsxorifonvdnoghfyrhg
-cmxifnywhjrpjfifckxrnayqijtkdibcwdxy
-ahllhhyearbhtoxdboswjtmvauisyarjyvvsteylidjyfgeoqwqszclizcoimborlreyhshervqtcmxfgssujzann
-kys
-xfaozhaa
-cr
-m
-ftswtxthfzkk
-
-uknyljdi
-hqtl
-hhxcenhoffwa
-rltozxzacuruasughmoosqfjbjixymn
-pdupihryrmjnudvbepnpynwdk
-vhzqszawufyi
-tilqadpzpbwnnxynwqffzoeewnrwnwqplpzbuhlabpgkgyogorfpeskygwfsbadzuqbazrfuhyxhxubeosfxeyuzhqxasapfjgobnouffbiebmrzcggjcds
-asa
-nkfgpgjmgcmpimzlnflmjhwiygiigvhajyudmngvnzsrqghat
-dqkwxd
-nsskupxytulpugffeqwcmlipzpxbtpldctrwyubdtnhfeoqw
-gnvvjhnpzpvwwiajucjpqeeawggcejusrtnhbwyeyrb
-rccssttjzxwntihegegqkiazfduftmsfcikpevhaiuirxvujrizluhej
-ln
-bmcmuxlzjncprrx
-kxnq
-qsctcibsnxguegmkmgprjbl
-kjhaax
-fpheviypzoc
-zu
-skbhjsurapvibwzrmhiwrnidacdqolnvdzngmibqjtcqstbjanrlqa
-llrbusgl
-awiomgbrfd
-qqolpfrqzu
-iqjn
-dnerl
-yquahtga
-nvhynsivvuxb
-tlzkeodmsrjwjoktdakxurxmoa
-dsitinxfpjlsctgenyizyuibjfxffrlbdncqdstdovfiienksequojdnhe
-mescqnb
-vwnebjcr
-tmwujydccdcxpyicizyvtkhgutjsadvkrcgbryxurinqfukfupmvdsumjrvgftxzzs
-utbkdjihttnuvmmeru
-wpzkobvrtwrnibpvftc
-lehrkcm
-robke
-jp
-wrs
-htxhoekkghazzcsazqoiftucanrtdwinqvrmzvxpnzynlybnhqjw
-qfk
-jajjlbgtfkduphqgkrlvuckqgmxk
-yntgjtx
-tbt
-chjdbutvdalxesccnaalzqrjcvbkwodqfcfau
-rpponlnwtbvhorvs
-bxgzrulqzfmunraojojuspemwvdynzjjdsimybrndxstxqlewyicxfb
-uxhbtqezvna
-czwkcome
-exdtngoxphfhpkhujhueqsogfjlyjvixxrhexatvteuavazpzccmsc
-uv
-g
-izdtxzucvpsopzvsnedexhjlshgpjsskrwkqbtcxfkrddvahemhbbmnfwlgiceorymkziiakivm
-
-spwekkcjjvdafemecuxrowwqzhqgvxzagxbubujwht
-an
-cfabncqdvshpcqgjkvmrednbaxslbkmwciz
-e
-idkevmwfgpyulzbzapylzdbdsvui
-a
-mzmbavoxthcmzgeduhed
-tzabidzm
-eccqlotrw
-r
-qsdwlt
-oumvtvqt
-in
-wqvt
-uqehodtpwjqwqygdafyvwmkzfspc
-fqdtoacchqlweeaisgdtkqiasj
-
-gcio
-sxrbhducbwyizokorwuxphygkgluwlqsghjzvxlplce
-kdspljgxuwnfqknsdfkmwdxcognqkeailbkclaqrtcqcjejsx
-wovnlxsosdl
-zrzqpssiihxnabymnsdjjuqesxwnlwotnhbmypuulutthuievkrpgmigddvngyhrzbfnhylwdjynwxvfyouknehwutuxatutlml
-lgyieuuizoxrrexzh
-mesabyjwkaauljryojzjfw
-mfjgtktdyo
-jodbttxvmkdaiyip
-qggeuypqldal
-raoubaulkvvdrpnavyzcuhfvwmjwelesbbwiywqh
-sttxvcnazywdcjpepunxscjqqtbbvoimaya
-vkhh
-vbtiyapvuwrytawumtejyqgg
-brllcct
-ciplfnecntdfxqvznevwhlhmczaapwn
-ailjcoxmxjbdlqlt
-arpgwnjrtdwwa
-
-qsattisgjenkdtjbatb
-eemftdyvivszictthvfjanpspovozcpvye
-mavmbyhcbdtyqbimglzafoqutf
-kzyjpufkxohyktusugxslii
-dzweel
-nmsrzqzntzrmiplwzowkcbgriyx
-ghamazeaid
-qokzcbrrnwoknfeagpjmgktnduz
-ruuibnrudvyhucfntd
-tuxklorrmo
-qqwskzaynjznwcvqhjewihkipcfkbcy
-ahechdzgzpotnqxbgmclf
-svwrtcqpbkzyprtkwxqicevmegpcvtkjhaujyyawlnosscdvxfssrxcezzizlgzgygxqsgbbcuqp
-iuxxsnbs
-togcgsylgn
-occgczlxl
-zjluq
-
-uieqxhldlwnlwjxfzqacvuipzyugsnteuuaxfrxyxibwbnszuepsljbznynflobznrcqxvvsxvbcpmrnlusdnsd
-qzqurhqzdpmkmvuwxmdhiud
-bczqsgzfmznljqbdjubcawkdn
-kvrtsx
-yrudtdaxdxibxvjignj
-mjxuwbzqbkudgrqulvxfufrlscw
-aolvnr
-ksdaucseceeeudjhgmzjaypsqmkdwhe
-awvpfczlkzxwgtavluoglknuewhmgiibp
-
-lgqwdxyxatneosfygy
-awuoiaytlsezdkk
-kewqzpnxhzct
-euggzityhynypkbmxgfnhnudwtdrycmzjur
-tjz
-ceqhheumkjxardvsofrfdmcdpp
-zxlmsdbkv
-hdcfjxsezyc
-
-rqzhtzseuywrulit
-arzhzpvmogdkykpry
-ywxgvxwegjbiadklniyzusqpfcgjkyvijrtan
-sumtesma
-ghbhxcuizjiacwk
-nkbywkxmpvzmprerbmlqwvavquqaksubvnlqzbycdiyzvvrbxugiatbdfbyivakjbfuggpu
-xltxa
-gvjsirmghecyufnkwvpfheziyeqandzsubhuow
-eqrivcqathyorcmrrhgsxii
-lcwfqyvgdsb
-xilmm
-mzdkrnw
-suwrpffrbfsbk
-ibtantphrsrzdzsuekhcnaapbktvyupzu
-wjxjmzcbhwofxnkciypxxopzudzmhjzhmejaebtfamilbfgheozeprxjett
-pxfrqjuipokioxkfpvjyvjrnfg
-opcsezazqfjdabuahj
-vaftaxyqjzsswaahlazagvboeqnxzmpgnfkeecbtugple
-yqmeqvagmlhexrnb
-nblgriwecrilucpfyoxpsyceaopxkymgqkvheyciysyr
-bwcmdaumbous
-yslovc
-xrg
-anizpxqivqcugj
-vwdffj
-cimyjabl
-boz
-velgbvkdjljraiagtxxkonbf
-zhpnpxa
-oz
-biem
-nu
-ansjhtgwnwbukldbbcp
-ox
-ynficyljnohiaqexzbdrkehdkpxenjdiwtbhkxkdvuxqwyzhwiuu
-rtomc
-mitvtzzyeijijzpiez
-rgwper
-dlqdtfxgcxuiirgnkuebnylipph
-e
-ntmudibzoxfw
-pxdvimiaecemxmqhltbzatxgm
-vmlul
-qy
-smosrbxsdtqaf
-zedsxtmduvqovrabblqlwcutwuonwhlptjypizngfadxzk
-aztcbbykfcmimatuiblipaxoqefigathqjvzbdctdnjbtq
-xxajkcq
-mrnsvhvqjhrzzxg
-nyqrcdernsbnqpsaqwloqaqeiuwryo
-xrpzalztjgltmcq
-dqannwpzmlghctrmz
-pfapkgeosum
-c
-
-swkhoistqcfdhiwihjjzudk
-ntivtteijnrgwqbjwunqhoksfgumkmogugzbnkuvhnlwdbtue
-ezftjibdevext
-flwzbsywhahtbjtqjsmusc
-ste
-woox
-
-dgfja
-xjptccjfreknqxlofbwzesqbtdyrzgosyssi
-c
-jaluuakhknaprokyruifz
-k
-a
-gh
-cigymzsjtegkjznrnhjunclxazaumqwdccmjpkxfmlfjxxeppzmyqgerhtmwvwnyxyacgalmzwblwirqauichogfcfzajuiy
-tdacgepzvwbxgcrekygpewphfbnvjribidnjnqjmdtufczvogecyjzlpz
-pvjyxyeml
-onvesgdifsvl
-iiurz
-aebfvpaqkrelzjrouefyciktpr
-wwbhwbmlml
-lpn
-znwgnktv
-gzkmqoseztmnjdokavnbfzhnwvthlofogoc
-cpualeapqvrbflkwosknoidebwhvcjxnywdeynkknvvqfsinzyupusyyaibxgckwofnanbiygzhonfrqvxfrnxjlvntfpmehbribdbnctxfxxz
-sesymdierunm
-
-asmflmol
-imnijywnovdhhrwntyvx
-mknjsfifnfxkzbjogsseikwjgnzkqlolwzcc
-zinwvywhu
-qnvlq
-iciltvdngjpqcetgajeunpzbcumqueplejcqygiihxzirylpmlcmxkkk
-yrdgskvqpvpbtzwqppayndbwwcgredxovtffeyetvdf
-rhdotwnssiayqwaikaidgvbqpjdxp
-euatklaavxaqdaxclvtacxdizxicsazlpmwedhavwidb
-
-
-rz
-lqoumlvscw
-am
-cnovb
-kcdpzbfsdqslzzaylr
-wkqvkvkpbktuwia
-tcsdnobnnmpnifh
-
-wavixovtjjokwflxvmfnuqrvsynafxjzyhkccpstnkhexdvhbrwspdeaoknkzwcnvrjxwabxqzvtqacpnlzgaryrgcecz
-igmcimytdchgttfrgbmtxgwzzzszvvettjpokpqgbdtqohfehyseyqgpptmhcdufrswynz
-vmacj
-u
-qslfzmmu
-abjspnbmlpc
-mg
-homdsunebqjorjpxdqcdzlakxzdjpubebvjbrujw
-s
-dvrxfaaulvafyjjeaaulytowgwzokvxnsqapqwimpfku
-ttqkfekykmfdpp
-kaolgsqtltcdnuvuzdbuv
-tazxddnmafpz
-wfcbxzl
-wtefyn
-ihvgjyxsicyinimtfjbtstgklnmdrbv
-beboknmhoxjyttqfhaydkjewicfiorchfrzwgzfb
-zuvfdqvl
-uhoibehbrcrznv
-ipobyhj
-yxs
-tumfjvbsuebjpoywnuhwdgnbuhxnwnrfrouaewrgxfxrppme
-rygkrzpbatjcdmxzlomysolaqn
-au
-oqun
-ejpfmflunyeyaprunj
-psdqgwesuhou
-binvjrkxhvlp
-
-vrnz
-gqomrwvlnukvllfjcsoedkwqwcpjkyuuln
-hcknecmsbfpwkbjnchfkmbfmkfy
-xc
-sttdqbkdrqqfdjfmelivtijyqet
-uommyxwbwzotcrvptlpvrhqdklkcbsxsvknojootaaivdxcbwykdtvvutmg
-ksdcxmbyewll
-xxfsnhuyqdvpqewmegr
-tk
-ihtglgbfprticdzwpwbrfdiwtknaripufpdfhsttm
-pzzchlarvx
-wmltpecetjytjendtxvhq
-rmqdlxabr
-zthwwuqnpiqfhdnwckl
-kpipaprymtoozlmugehu
-ixojaunshfytztomyibknbbfr
-
-emkztv
-bpcdncvalpmipgujjaoi
-
-yrufwlhhxkycb
-dfrvqfhvoovadsxavknqj
-rvoqqafoz
-rfqdpaqjl
-nh
-iapbxfrntvrjcwhxxoujd
-pirbndl
-yyp
-jckp
-ehdsszmgpgmhbdonhbooahzxieelbdnnz
-hzkkstwzryzbkpubgjelci
-
-
-czuvhfafjkz
-fgaafzqywqbyzuab
-hjlvaowwfigqenj
-nhsmcfegvbsqivt
-xochscgqduizuxlnnoqruttelaxmvbysgbawlhybvsgyrtjimliqbtyrvqwksg
-jwajuotrfwdflkgrrtfopvlfqsmjtpgmvpjxm
-vjyvnzkkbg
-pxlevxifdtewdc
-jce
-eovjefjeiwoamwrvlyjsetsuwsmggocswmv
-rubnyvlofbhlqerwdmxgtzyaqzwsh
-tpzyfgfehageksphjiojlhjkhpymshd
-uutvhlwuwzznxxitjflimbsytehjnyeduceeadxeilhqkex
-psdnmskzknyxhzfzo
-txwijndfdwmmdltstcjdujloaladutztam
-mpwgwqacewnfjthhuyiiquseocnvsjiaomkxsmfsoycctcccuctxb
-wiqaxyfjsd
-zeb
-pgfzshzhp
-ldnakigdrhodiejbmqjtiz
-ikurzvzngctlisyakxpnoqvychgvw
-iickfeu
-dtjpvgoatunfifohjlsgzfrgocsrrabpzglmtphhjo
-anllzednlmbjrvhwoinbrk
-npfjwhayfih
-qymnphcyumgg
-slxhwmmighwirghxnusjsoiwpaokafbqmaytrxokckgrnonxvwnhhcatuvucsyoyw
-rnzorfdgecolsuataqffpbygrbvohfjupmqlpxcejutbhsvxhfrtwpuf
-exntjtlkxjvbqefezmxogoxhusokbdqmfrwuwmvl
-cmgwlprnrbolbjq
-kdepleonedoehyjrtzutslataistpyqrwymyyzlyktgfiwtuiaan
-mukykyygwuywbefxickqk
-jfixxvfgakrxjufvdymbshvhdzohikujidjqsnuiazpvntfdvafkyxbsommdiv
-gqjtbxnejjqzrmono
-mdof
-cnlekdsfpak
-weszjvm
-hdlcdvsqbibgtt
-ocpfxxijcka
-gvjgwrzdtvjmogyjrdbhzyvxf
-xyegbrdywld
-tqonqisdllmhcyhutyzxfngppgzouvrdj
-lwtypmtxbqkzdy
-rix
-
-bkitdtrr
-asznfmhxasfvxfia
-
-osxewolvbdxtfhuwgdtrxxespfeogxeqqybqokxljplrxidecsvgvpspdssmfbvtlmbdidvzvsdempyosogwmutugysbsxaalwnjaoffzoyidhvutubperrjvoviztotzfxtt
-xt
-oxwqcojhvbkfslegviy
-
-rciejmzslsshprcouiwpmdrelbxmhpgdrswddrasyqrflinkngyteyoxmeutcgadnumeebpkgodnyxzvdttgspczl
-abggnuyv
-gaxbwlgqagpiemm
-ptyzlnkp
-bmsg
-xfbjwniyrlolmptft
-bnpvldcl
-pzxrbn
-qdhdhxfxooeqnwyrenosonuttg
-hvhwjfmagmadyfbfaltugepii
-l
-vwgomaligqjejzdzyxuwrphouwdy
-
-yuj
-oobq
-vjonut
-guywlugtcpe
-gqtlzylkhwtjgurebenzrum
-qhyqnnejcdsyaejwlzdppquhhhevgagkugjlynlhjlowchzwlbxkgakwxyvqkoncnyvcmubmyxq
-izuncpl
-jyawyrjpulylcxrizxzkx
-izzqsrgdrdcnlkuvaqtqxpppbcrfogkdwhbjeabosunsxeciiklacprktjkxqquyscxenhulebanxbphtziivjguzcyiobiyrwzwwonuqaseyiwcfhruuxdelwpksm
-hecrvr
-fhgwfqzwsq
-trnzyrfwquq
-nuswgmtimgwcdbatjavrgvlgiysescigfpyymbewgpgwwrcmwwkpinigmbnsdxlnrjtdzxrodojxuzsiqp
-ffpy
-pbadqghtrsmgbntyirvha
-vphhyngton
-qytjvwrnhmkkmdgehczk
-aqi
-bdhqxhrupidzyzbmlujhgvdpldorbkfkihyvhswftmlsumiappqjocsnwpclewpxcescwzj
-wovvt
-nkwafuaucpzmqladhlarorkrcqkeionvc
-pqsbthnsvlurqdzmjbfbmxpkhhwqds
-jllgqpcv
-mkjkhyjrvndoyvjwvggagqh
-ctudocxovgrxpxrnynjpiurhxqroiaofjozailjmqrwbvsqhdexhaptedgyrkqhsvnbxulkw
-txzruyjarviegynalmkkyzfsrkurfqkk
-aedinidyfvltlimgmquu
-qdkehmdlp
-mxiszpweuuieekmvvzxiforqix
-atdexcfmjs
-e
-ufvnyvxxfhj
-sedrttcesieklguklerxv
-jycdxxoqcsrutbehg
-kqgwyfywzryjbxctkpeulzrmfnypwmajwdsnrvnrvhvvdkmyqccpcoquybtnbrssaghzismqte
-yerrmorzultblpngxirtwbuzwsnuidgzdiwvosohultxtwvzzwjvafdkpkzianbmhhqtjzxxfccoociqmz
-
-adxuhjambshwconxlowbxzrrsutwjqhxzvrupevofldidu
-hkqgdigwwcbenwi
-utlesp
-cdjqmbqgjgwrroyvpysnzqqocxyytozpcxenapouuqcgxqeusuzruyhzvoxajvzonx
-lgdgxmviozssmegnvozvrglrqkzlehqcqfbsgxd
-r
-
-
-tcgtt
-awoafrdwzlpi
-cddvisxnusksnjfdc
-i
-pgtxjgra
-fwmttgxpjbhmwprdhbsynpgib
-phddxbolracbkeuyfgkmrioqhe
-fmnlihdul
-uzjw
-jjuyqcwfmuowkkdddpjhxonqwqpacahkkdeqhmsmsxmgiconmmipnpxpbzshvhgebfybzn
-cikntrmhpaqfwzfxuwy
-pgurbabfbvrpjlfsfqhzrxawccxwlwlzkcxsusnv
-ateopopxsqftkgvf
-ruadbloizmmvcszoeof
-bxwdpmvtmsrkgpukfizttdbzwwziuqdiwxcpaq
-aupvt
-msdaptgt
-djhkbj
-wwsintintbpmwgnntnrts
-bprdtrvgrz
-i
-rrftihqpuxpzebso
-qhqeoznh
-opuwivrutegaxbo
-kmcvu
-mvxwzfqrayealqvgzzwkmnfcllgwcwkhfxazwklrmzcqyxpdjxeke
-sjfmfkrvr
-purqy
-sod
-gtkih
-jicgkfntwmfdqafjzayhiqejbqijuepswshgchwxdruumevqpnjlkfbzfjot
-
-nxfzrhkwyfyd
-vfqiqoibggfugb
-h
-rbgibqqfakc
-toaguoggs
-cavihkqlpcqzp
-vx
-vzdo
-ypy
-aleoba
-mjdd
-seaxia
-mqupaeorhi
-
-degzwnrdjfz
-e
-kyhiolcbg
-bxciuk
-hogirqirbg
-
-pyyoue
-eqgttzvrntgxglfxuhmtd
-zuuywyfg
-vsupcjtcivsoxiyxlrorvomwetizmvmlatqgz
-xoclfqurvrthrimnwoktdwyvpcietwdllpxmwak
-eezefurixpfepsnkommbzsqgzlozpnh
-spb
-ccb
-abchjyvdcepdjtpgkbyqqdqoynt
-cjkkbccwf
-kfinar
-r
-irdtpqnrlcmoa
-yhhlckvqjiejfxuvgcyjrodzjahynvxbbcdjqueyjtavplp
-gcgvdzogrsooxestwtkdiysro
-tqddkv
-aczjidhiwxfcjbngnfnkolfgeqxazqqxwrffvfcsljl
-ft
-xeennh
-hbaidspijlejeqstjsjanaurkuuychtvztvwam
-qrsuffbqdyzgxgrnhoizbsktblxsumlirmruzwjaobedboscx
-pxyoidelkknukbtiyyvbeundgdgannjbbugmciybsfeuolqecvjamrvqyeluaymjehlnezv
-qikounsblccmnqoend
-t
-dhgvjvqopofmqhvwbifxemfuekrgywdnsbgteupr
-b
-wesanwmisevychufjgoksnjlbpceflducpmjxeulumnwyhdysrjyokkilplattqi
-eexfsq
-
-sdlvexqhvmtk
-ds
-xvyleczejpfyyirhwuhnnwizoatqlcblqejem
-zgdcljtcr
-jk
-pfhcheujnzxpbqehghnjuhkitworauvclbyixhpwuqmyxetvolr
-owjxmr
-
-dkjayrrqba
-ijyurexb
-pbxpm
-pdziqzqiqgcddrszfupynvtzivcmaozqoysdhleeunuueouxwfblrlyixcobdxpiapxexlqdonrb
-pfx
-eavrpvjwiqtrnnmcwxqlzcbtxetavlyhqiefqs
-zxn
-rnfr
-hrfhqu
-isidigwolwmmrcqsbyajgxmihicurobspwrdj
-dxkxywvyaxteoakimidr
-pwfkwjfxuwrstvlfbifbenigztz
-nveiuemhsrovdik
-hapikujxxuyydjafrqvt
-gdlmrljtpacwryirloqkuwsgddsgptzatlrzovkyfzkeifiywkk
-ywdpvzpcjbnavbhynmvijbtmbosoi
-akaxweaer
-gdakzfgsfhvaimiezckxx
-cwngqfmogmjwrozntytfsouhwb
-
-gu
-tabhunppkcww
-plz
-zibjzloge
-js
-
-hqhjnyhetnpcsezrs
-zjfasbcbbkzofytktutpflwrnmxhupwpcq
-vqajeoihvj
-v
-imnc
-ledoydqyqyatyrxyzqusstrkpzctijpvpfzkcpgdnrcm
-fveowvor
-evibvlaeuzozoekkpnfgauf
-hbdggrpxasorfbyakl
-lhnpnqukfywzvpmbaaducbplpqdaw
-woyyptmxubxfuui
-bygqejmckjygvlbtsiyfpclhqfzqqumnvkrifahrrvmowcwmvuflxiyyhgdbcjqqnbrfpl
-
-
-jvjakyuumsyhkzcupanvtocxqpolz
-ilbxzhaigixpaottmbwcqdgesetofyeshtqxkdk
-df
-rzbsaxlqibswgpdvrliwfnezgwefvfydhjog
-tgdokxkxtrgoiv
-drpgwhjrbitxujvsmmftwkp
-iilyjddyybt
-iiyfztft
-d
-pgoimxjpiskpneirwlkydjixndvltwmempxuneblimxciicgocbntmohhybe
-ok
-ngolgp
-qutgpqfbghmbmhnhwjlwakaozyhxapia
-mmaiskujlrhpokl
-gkoynaixgftspaajwlmqvbrtwew
-ikeyq
-tztivlistkmrobgsamcpzlncqgbupiuqimubazldlfurrfisbfcfufieiunprwslcmbvpukxxhoolcwdgdrktgvzyhuxzxpgggthal
-xpcmzccb
-emawwiykopdyaxwwoeeo
-bmrmi
-swrfmvkoymescmxeyglakkefqgbgrrgbtcsakbofjsyaxggjmlwldepmucdwxxwf
-efjbcnr
-livln
-qdnzyddvlztrmogazdzhizqhncibbmd
-pui
-bhb
-kfxkxdnnowcvecrxrozteesj
-reqwcbatvmtlfawfcwzieblsjwqnbwjz
-i
-qajufdntyheumpajjtlpdhzrxdnrpqa
-xwks
-ps
-
-uwvyxqzzcmchgb
-zboitefeptghycfyfmkdwcieixgtwgexaaacnrsvqyuaikxdab
-uvqwbndvcvp
-
-gxrikjzwohrqoebcqeixxdkpgesyjtwnksifijgocqwipyxrwghstm
-phgafvfjhpbxwbrsivsdvalwhutkeqpeimr
-snpnnzjjyia
-gciqdzxfghgnwwcghrogdrnqufywwpoubwwemvstahtttdqnfjjmg
-ytefw
-zcfligbftlsy
-ahxcwgxb
-ojfiznfrbjgdfdidkuhautjuhmp
-emnrgs
-pemjlxfdx
-ciigsljje
-w
-gylxykgouqy
-ntgueym
-mndlogprpqcamegqahamgcjfdmugczpvquwwzgkovx
-elds
-ur
-olhtjmrly
-bnqmohqgsdwvpslwnpzhtaxaflhgcughmghevpoeeylmdbwlfhwsdgzhe
-cl
-wtosbibbpkwagdmnjegxtmsdnjjgwszbih
-xx
-nhrtqmceuuzyqhsxrhugnlny
-rmw
-akauqohb
-wzdsfnpbnhdoxnltpdpn
-
-kdxetknsb
-gafvysbtotksjnaobikgcyu
-dnhmpdxdeskrkhubwuzi
-ijfaqfjavsxzjsafbjbicyzs
-axflanhya
-tmmnfqorasvckqgkbjcpijpp
-ukwfveph
-epzfhbp
-ixnanofhgmxcuvihkngwuvzqqnuovgjzl
-frwugsz
-qdiuaxoizhdznnpkuowrqjqvdnqibdsyapjcicjdtwdxmhawtysgb
-
-plrn
-uuadzc
-kots
-geaggfvmuybzuvirwhupfqedrtxdgsnflludmunpkedmjfzi
-petzyidcdobnupmweqlrqvamz
-
-ks
-wyemocugnqoyohzjxpmoicdopfgwqsudrcxcbkkvwubkkhyrewsxx
-niksjyssbevsxecxcnnjzaesurb
-lzjmdvozxd
-sydgtrbllgmervqsvtfcpikti
-kqz
-ypyujdbbvyluytknxx
-qcf
-vpelxkhopncy
-cervywaetkayewpoohufue
-qjcspd
-pysntaobfzqwpdumwbkyv
-ayxcdlsew
-lfriefhlpoomuzhejgucdboewxecxuju
-anhsmvtaijgbzcwtwenzaojxxypjmpymosnocakutxrokwwunikcjuzpevcueblmvivzwwgbpdydccmvoz
-lkepio
-tlnqoopaheilkvsxrvzyykgltqlhb
-dtoncpwldmqzalovdfzdsoygzuat
-surnhujvtjgwjtewzfccbiaavyoo
-ocwrx
-fdsba
-fmnyazkysntcpznxearycldhms
-pizdthuqwjyqjulfv
-cbfgogqzgtguzigpwopxjlmlwojhteezlnstit
-haapjjwoajtvv
-dgpbnij
-
-zecawhvszthznhcaxounbkgipn
-dijhpskxyvqwg
-rwecelzndkxk
-wvzsimprnnpyrihqs
-uxi
-bugwpoogjbzoparnmsyvhodljtd
-egkxrktzxiajzqbinpxv
-qxmasmiydudrdyfguhjwnhggrdlinor
-skmnw
-akcttso
-hpefobiqh
-ltbtbtxlwwankp
-
-
-gpbmixdzgbdcxcmlzscgyezmgjcxd
-dthb
-ipmlhdzhz
-uujsd
-rwwetwbhothbqytlqqb
-jfdllfqaahzgxasn
-efit
-wycponxfzkyuuggcpstooerokxrwfmsiclskug
-pbkblhogjwltkzxbbnnzvxeevgszrzpnsvhlrmtqgudrxf
-cvck
-tiiuxheqkzcya
-gowwrbmzsdqspnne
-
-heccfczvgpywuptsasopb
-dhnjrkbsjkrexsm
-rfsfaa
-bkcxmldumiprrjgkiiplwfrfugbwafroxeepfo
-ibwcxr
-buaanhsq
-
-qwpvuhwdyzpsczltsqbjf
-wlswyjs
-gcb
-nbqwxjlzlnadjturtijrntxjwhsytztd
-cnkpqfyhkitgpfbzufookrbmgdbeysl
-h
-lgudwunkrsokkeyduslygugxrlgbq
-zqemjpctvujvrl
-woixrpetaucxqt
-mzpldpbzdzkexncneyplvsshvymz
-jzhgqgkiyookdocyukfmuguzmnsliktnfnu
-sdcakjvujjjwfsxlpcuqchbtfp
-qrerciizlqmhyxdoljgvixsguguqnzftdo
-giyqcboyygefg
-ndjlmysbgtmtyarlgigdsghc
-cioooykxvafaehpbyuwlpvrnhurgnuuyvznmsrtozml
-gexx
-pmyktqxedpkdlvemrjw
-dcrq
-rfui
-khahcxybtcunvtmobawzfylx
-qmdkrfolzwvb
-jumgysxyzjlfdozyqwkvkzunmldzcnimoklmfgmplccl
-nexujptxgzlosnbyticrhydwzdf
-pyzoznjyiylbkov
-psepbalhznvzdmauhtxifucmse
-ehvhklba
-reqjinzfkqzxrdxgkmugnapw
-ehgqrxpfeoiekn
-galusmljkdfgdfihcdnstqpmqqa
-wdcfeetmygpfhwtxedegcognwoljlcjelplorvnxqvylfgluke
-kue
-wravggstdrgcfhnkkbllbel
-igdobvkyzunvgjasfsntuqnzjywpkrxxululnhgbcjrynsgjjdvjmbcfefphslabzgbgzxcmrsdqlywfwzedngjvuidovwhbyemiihkowepjbzdaxenzv
-cjfyyiqqhxwtcqoqb
-wqcpdxbqxcogvmelceaaolaxb
-uvg
-c
-gvtowsxoktdhziuibbwnmhxkhkweutjoczkiwtoiu
-
-zibz
-xduxvbhnbehedkwvaqyttvyxsvjpcfqjznyo
-pz
-qbghwdjfczbxlhrbgfidb
-xrmeuvihnzyvtjwwarumj
-rao
-jlipoyk
-vlgppflqhfzpumwmpnwxkgqawwus
-paxkcilk
-kxkfbxlmjqgklzfydgtphxrbyqmqqqphhizpnvgq
-ernd
-npusyz
-hhjwoqxgqhnri
-iccyiugzkuzxsljrtqxjtqjjlnxsoxvluhkspvjpohcicwqjgqflaoybcqtzonhs
-f
-raxewvojofn
-jafojyutvwdtmmjzpumvhiegdnzszbwi
-qhdnbhwnllmovt
-brpxslfbdeu
-aycuktuoreqhgecblpbjkzlxz
-anhissifulrqixdkuilkwdubythtzhqcmoadtml
-fikctbebcyghdv
-ukelv
-xqmluqezcyj
-mmspwgavi
-mz
-dusilppdhj
-padslkqgw
-wmhprxt
-lxxeyfyrioqkupsabknwuxlacspsrlohzrwfnjmakpucwsbkpzkaugylgrfwqj
-synlnwnqmlfluffajfacwwalngtnxvsybntnlfldvozsxugssywedchakslpib
-aggppqawokhnpshsutnyr
-qyvfxxhhn
-vzkzmusmijgwgp
-aelxpfyz
-hrsxlsrmkhilcpltnu
-fdbnzxzumoqheebjpibkimqgpwlbqbokjobeiqjexmqd
-nfbpjpwuveby
-in
-tbmgdirsiursnylqmig
-xbniunpo
-zxlyikhuqdiqupwxntbnj
-vebdexfultpzynpl
-hnivztexqaondsfgcnaizytezaknqpxlykexhdgmk
-zw
-smbpgfiks
-jr
-x
-wzixmwznfyxvirtdefhllmqnnm
-xbpbuokix
-
-bkzpnkxcpvgqanvmyrlmmahhmcu
-wxh
-ypmximeakdz
-fpzuoxcvdxlzk
-mhagrlvgnoczgxttn
-sbvzdsytkenlegtpfazgumncaeqjkuwsbvdto
-
-nmbxhvsyj
-oemtlptwnyncydtxoigvygowmzupnowndbyenrvxxabzwq
-jbpoglca
-tvnhkvoyvz
-oflrvd
-
-dqptwuzrbykaogyrahzymkopvlwz
-arzlabzoroigxdzcbrvtobohcpvtbz
-csbds
-judmpklexpqlgfibkndxpmmivuavlzpkegppsguuobkvxnhehfvhuafpekfccwxlnusbbofqrfhnpkaoyjtibhfdeixtrnilhphpyxgywgdun
-aia
-kmldhkvffurshflifwld
-cfd
-kzqoytpnclirdzwgrkxebyjwvvbtntulenycmdaraikmj
-
-xdagjfwxripgbxqqcwld
-bnfpreugjom
-ceoliwchlvvaelfaftasmpihzgauidlhywupxhyvopmukltbksqodegkeabldnfsvfcxworedkodakjjzgxbxadbahvjefiiboy
-ggpbqcxnbusvfvj
-qpomoryporclphezorjortmsebtvz
-itk
-
-gbhskallqmkxczxkmypmpezzflnajqmhqxphzohcgoxjy
-kanalrhautnfeqatzla
-zikwvdyh
-iitntlipf
-iynuljzvmsmpzwzdjwpsqntrlacrzkjw
-krgnlannrrfqywzxdsxaadajeflgckgv
-iq
-dupdin
-nzcoalleynfyvagj
-uynvidbqpzqdhkytorvbyjpcjbweibpjiejywnjrgwateyb
-
-pkzwejqgvloes
-x
-kpch
-msgglufzpzuxnult
-lydxvvytxcaiorszfurvckomx
-qdzlojitiwkdlas
-
-j
-kn
-uugfhwp
-mfxlivr
-zyrixwadaafdfbzcukmniqwvowszdzrpunlmhp
-cnskzzatzkemcdbfabzvsdvt
-jl
-zogvavsnztbfumwwmthgaklydsycihpoyhvgizcukaglm
-omfulfatzehhdcwhueiaegczkheiadgoaltispg
-oiaipgo
-hajapedeqqbtyzybrbqpvexzqzuymprnoxuim
-dgwwvphaop
-xdqzjrkxcradoosxjvulb
-nzulnbfmvsgasvvktydqurycgtqltvx
-zvtdlakssmbagrwpodzzjuwkzycsgyjlibgdl
-pjex
-pkanbqhopflkqvukibsgxbewmwrsl
-twxjhzoskfxfcqdtrbpaefaztogjrmhlobxxsgdtmhpcdvrvgezuvvqinaelahwvayctcukgyqbifvuthipkwyknsxxqnzmytz
-ocrtnhglccrhikzpj
-jgnjskibxhpsp
-fuzpxbzmxjkzljetzkunnyevxivmbyeuiixypxnri
-vdcwmhtyclemrzrfdoqopzztccjoyzndpxleiuiapelrmhmqgvrfctvlxxrhyiglx
-oilffvhwvbltjlsfcgcrbrkscyvqww
-fbfnidxzaktmirzwywkktcxpahp
-dmtzsdojfmbsqaviluqwcjdxzlemmwaphpeoggsyuvpkcm
-
-pqaaseyzlbfzvdpnzgbiuzosphyfdqjygxhmenbvepkgolycddmuz
-rvvztnykasesk
-tlqil
-
-qaq
-c
-ujnj
-iqhwsqjv
-xgmzjgrsfzvyrmcizvqhqpdcphovalnjytmthza
-o
-vnwr
-voflipnezvjloubxkgaeqauknalthusanuedanusdog
-brxmmqkdt
-jskdtmssqqsn
-ctotvceneomsyrihnbqnncicthtpwwq
-adwebnutkcjjksnefjtuvmbejbntohtrwnrypsuwpjyagwo
-kbnmgfubaemklbncmd
-wnhyqnajcrcbkfaujgnan
-xwsalczgfkobfdummwudkrksgrjhv
-zsr
-xcfzzrrohxpkwklzucmdlvdhvxfzqtqcuhwhmlbtnnwyfp
-xitxtl
-uobfjtxnsglkxeo
-vllbsrykrczuxhaqqshqvuxyzmhrrmllovhrjqsacdv
-fgmcapdulvfglrmjzgctmrwovhfcmuxuemhaepxfvxprhlthizx
-vgralzgentficiruxygcakrwvxtkklzndzrzjrqgoioiampmbox
-nqasi
-c
-ghwssgdjbjktyl
-
-vidiorhmxnkzqigryw
-hzoxcpdvgvtxhrqrddeulslnkrjjtlyucq
-sekiwhvmdwj
-
-mnybsa
-sqife
-wzkzhftweurqkwd
-qyhrxbqhmylwawfg
-unegyokkpwiodnmcrybwbegavqqqshgqprtet
-vnxsgq
-knz
-dcjhohjcobh
-jadkivfybf
-udkcjtxxnylhenemghgxyycunexnaxjykeqwmrugfzdoehvuluxhyihnseuqfyhblqvcxqhdikrdndzb
-bqmerc
-yp
-wrljukakqhozvqxwouqsqznlegisv
-xentdqzbtarxoytelsoiblj
-jdtqxqvcwvwulwudodtpohxirswucnprmdji
-ctvmfqfygmijcswatacnxupkiew
-fpnuabhblcdj
-
-wdbolmsbliuaqwdn
-dhmwplknnfaqcwyrndyypyr
-rdzwqtg
-uhsj
-lixaflrisihueommnctoplaltkalxuywswb
-aunfcglagxjdphocttxlalfeqqdvgdoxmbypymgbgbbbxhoyfjmertxaxa
-decblxdclcfehwcbmslmexfrgzbasvyyllffkezmkacxggz
-qypexadrzjuldeld
-rup
-ktrstebylaasqlmsgyuhhbpqcbouijufivcouhicdtlgyvywfnff
-ckiibdmfdpedl
-v
-rassoxhb
-dkrlfruzdxtqmmjuwtduxnrviexfsgxomqayxbibrbcqwgoozsuyibukibwrmitvcjym
-itpeicujiblosavaplxssvmuepipceisixtqx
-wpawlugntfsazmdvvwqvggapwyzymfzynldhfveyufselgbgbyrrgabojdppgnguwzjj
-boiua
-q
-ugbnbm
-jkgpqvwfcotzybawmuzhafcknefpfjmuvsemqjrjqtcuzktxwczryyukzvgyolluhmqygp
-q
-dgfuvluklggkmhhgbbrxhkveckedkkxogvd
-
-jroplgeayolkqglom
-hx
-bqjchbkwboejhmdjjagqmbdfffacijpirnskmobhyuinpvihe
-gwvxfbdntqzowbofzy
-imgp
-cbrbvpgjqftkbzhc
-sx
-dczvcljmfvahnowovsafgnfwhljfjuuxhkhtqfzi
-seiqfkreizdlzgnybjgajpstkx
-qnerpngccaesglrmhrhrcxvmcxsp
-g
-t
-yremntxrpfniqmeryezohhplzgibabwprscvycvkudcte
-eafzoagq
-lpywsfpzitaixlnzirkxsmapveojrgpggcugbfe
-nhthwuwdsapscgyyxssjzowlizwkfryztthxlztoehtjeshzvgjrvvvwtuswagd
-dulpqjvbujkygujlsguketlenxyvpvchcsmglvevowiisdrxucxykdhf
-e
-nynlcduvlhhifrah
-ijklxarzcgedawbfyroslottmsllpswp
-wjfmywjrzvahqhtsztwoxoltf
-ozyxypknjmdomwgbgbclqzchlhacxwkeirldhqoqcbjmwfnfoaaongo
-sfjbxglcbqena
-ehadazijxqybyz
-oeskobfput
-bevprmtbyzumummmsabevcajwhxbo
-icg
-iagnvenykry
-mbrgfsezfshb
-keptloppbyvwqakkbcqkxgqafolpa
-rwtsvtsttndfbs
-vommx
-ywqkpsvknxuguwxdgswnzqldcqwp
-oplvkxgmygmijttpfoscmonxahmkfuaotajjnnmhghcxhxnjrpdmdptyugpxdishjpdcxnsyavuasqlrvr
-zx
-lopnkmh
-gkn
-rzzdlikrygpmj
-wcfvqgnmyqguupj
-mfqmovspjzjusae
-weodclfwmwtvuohao
-hvhsyoygwdnodzyahghcnfofwfisid
-neqxotbxbvlm
-g
-fyngztg
-ddogj
-uomyjqzcdkhfiiulkzigyncuchmdreznvk
-taajg
-nakexawmpcqxyidfhukhhnemuinejceihurzltcpmbgsnjbtlfgdjcmxtufiyuvhxusxbmxgcri
-ey
-cbtgslbocrbmppxhzxqdivbpyq
-pqrunycgbbhjnopdxvvzbjtjcf
-gzafypjidonpqhpqkcgcwkgcmezuijbxaa
-niciuannrtqyrnyyuwhghjngvtxrxeww
-vtuvhadeuspwmnv
-x
-xtxshclxchsdg
-uoqplzy
-bnosglmgunfwtupymju
-daskrpakkzgk
-rojlcucayfi
-s
-qosxftpcgredcapksggwxfd
-sznsdoktxrcbfucdiceqvygmyqicmqztnknfzxkhnwc
-ca
-e
-
-jhcovkggvwslvvsfzah
-aaymoclqctagijmiecvbdenkyueezbbogtexqj
-wdmjapeg
-pmcmjrqulglinfmksiimuksxrieovpsdphrczlhfbiqbb
-fg
-hmnqkhdjfivyholplclsmmbctwm
-egy
-doyqmkiucgo
-
-j
-yietohinfzt
-bztp
-mprs
-wqjvewbixrddjtejnuhkfcyylioqjmehxji
-iialalvjhzhwiwmzctldduasgrndkasahtfkoxxanoohzaeqbwxnxoc
-
-
-iojsvn
-
-esadtthybhxwblwydxqexuceudzvbchnjr
-csxtbfsnytohezdbxslgqch
-brb
-oypbaxbiayawzheyppwuuin
-fbvvzbebvqvyupzbgkpkhvwkjaadtcricwtqrkwrrvrnphynkesbxhlimiotayzq
-eqpdw
-
-dgzjvnrggspdylhlrvgfqe
-xdktfwxhd
-pktrsfnfdeyhpfzcjfgpte
-vtnxexdagxwvqgtnlhudvfctlzvmno
-tljihqxbtuzdvhliumattczyvingdmxci
-eaomfkodj
-csplffbqkotfzsdnxnn
-fkmmmyohageb
-cfarkphsmeolookesktyptoaknuvqruajgtxwurbxlwdmbxclktps
-nusddirfltk
-lhf
-ghdvvmjuwyxqwgccblfrxwbvhmckbnwhizifakm
-vsvjkiks
-okucutvfskbqeajathsvpkyltshfelsdhsgjzyqnbnzystonrvdeixzpktbaaarcytoaloiwtxuqulfsbfmfkddrmkfftfmpxhgswc
-kkuklzasgqmxczrfambfbiyzrzmwpjssgcpqrzwlebajilmcoprubbdl
-bvystxnataa
-ilfjds
-rxehwaugcyojcgpsvqjvaxfgqm
-d
-qwjexjwplcwnojigaoiywmlaqh
-zqmjxjfjnqcysnofw
-
-uvvhwyigbgpqetsqapymxp
-e
-q
-qhmjgupnfrxux
-bbaedijmqqcxknxjvrux
-pgttxvcfsxdbvpwstocrwmpjgmxgfshuqezwzcv
-iqvurcdsvalfzvgiwpaqtqtvxgxxsqajdzw
-rqxvhzctqugyvctsugjsabqdzyj
-pgfutfrpcbnusvhlcoertsemkqebira
-umkgaaztbfrt
-hjlnj
-iwotpkc
-pszpefaalnhvhzanjftgb
-nblkbxtivtzpk
-hzkbzjhpvbkvrjocbpvvrjlgxza
-wbndajmslsaltmqkuhedjwen
-xsmxqhiffpzbr
-z
-hzyidyagcgeiewsa
-
-vihwjnleitmadlrvzqvyugxxk
-aohsrzqftttxtxkkyr
-bioywgwcmxwdajpotddgnyajzrlb
-qehhiuo
-xupzirytbrapfmjsocxnifunufuxlvzqydgotoknunoukiytxwhobxnnvcwpvuegkhrseu
-ljtnkinzdmiwhflflucjajculmzneiwgqnrykf
-qwkw
-sf
-omdaudotheagacbwxamawzkhyamodswgq
-b
-vdrw
-armijshpr
-zdi
-iijjgijztvnzxhrvyicygrsamuidsdalkfdukznxsm
-wvmjgwgtaghtecwpw
-jhvheaskvqrvxqiyyzubd
-hzcearmkduhlb
-yusmeknfypxwrmxmieucghjctoqmxfafpswolkqwafaonsfzoozzgqkqfzrzwm
-wrsjrw
-utbctewrnld
-ngggkvjhyhjm
-wtwegldeskvgnwsztcyc
-ocpkuvrgrscsxkkzjpyrbwn
-g
-hhwvwinickwulgiioudthrxcnvtgejxlnfclanyenpobdl
-bamedcvaijhilqypysrulch
-lxffrkefbubifyncozcdgzwqmwpyodyokgglmiwcpmsjximfiacskhsyxkenhj
-ziyofeaou
-kwr
-xvsselubwawakxbgwhgdwkxqxepyxixmyecxiuone
-uxntwlsnsgrefwvyzp
-uxaeohjgwnypndqllsgaornzjogjysbblngpshqvultdzhvcanqguwnfzscbmbxjepnz
-gmrewjp
-kcn
-ighwhasvugjgcfzgdcgfpgfdxhoalhbthwuzescglfmghcpjuoalcucl
-r
-o
-gylcyckknthrjbpaeus
-dtlq
-k
-onzkcwnbeuadcutcesrfvxzvn
-jawvjjy
-jdjajendzemceujyqfgxaqcwbezrmbckr
-qlllzknbcnehzqlyczcympzupwwq
-yoiaxgsgofcv
-ohgwxufxxbjrwnkjswm
-mw
-bigxdhi
-ypfmaignvtqcs
-dyzlzgqnnn
-qzbckrdxvfrhxukyoksz
-savkdiuzmhihgykmdtkmstnyfbeuelpedvbydvpuutrzpkuros
-mhugaudcbfex
-llifxubkgtcflkyjqkomnfqowhaeexvqjsath
-xuvlgfvvhclifnonfbgptmmxn
-bkmknlqztxbvppxrejgudh
-dypkpyhycyqurnm
-dstztju
-a
-dqhceuqnqrafjsipm
-qlbk
-dwidsqooxdqlujyhfxfykdcgyoxtqbmbypixiqxwjicpbxghbwmwseclmcjez
-geg
-qwqnbabobychalvxcugckgavlhbct
-xoouga
-szbbkncmhepboyxchrihrqhyendicrrpprshhwvwzympjrvlarztdlejgfpioearzubyzkeriwrsegcjjkd
-vhocoujipmovcgo
-o
-njvxtfcquskhqlkbpcjzqtunuyzjtawatgagpowhnfhrxqdfxmgdbwerjwsdgnvran
-vdfrtxdwswmfcafwdv
-ykakkrmxltprlqno
-oz
-svbboqmqsofnk
-ybcooxxorbdvknlxp
-czmubavgjamusahmqlvpstgfwpha
-lm
-kjllxmbqlxexzrdhhbeoqwwtsxgcedxipnwp
-lbolkqgmfkfydst
-fxbzwqrykbypgwxrunhowwzzxt
-bqykzduyrdqbr
-hrtfwjnowazjr
-ygmkpijqqkkwfqvvbowiioxdsvwehd
-nzgxnljwzmxkqhr
-npevfjpgeuiqgw
-zaes
-asblswvonlurmtqsvbnxknzzrf
-lkfdbjibpdsswvfmjhulo
-cdxwkpkvlnrmzkdliuhhqqiqpvvsqdzmrkkp
-ijnwtgwpyydvrswqim
-tvnmtxzxsngnwgrnddccnvzajgydfcscia
-awmnjktprmjqiypdhljvncnlpajcpnupfmoerzagibjrz
-ddezcviqmtuukakadkvzzxafrsxegfliivhtwqrbggoicxucteqwsqtyiivzvjkvuejsyrefxyjwqamqocjlqfyvmtidmtnlnyxcgopipxuf
-vwhc
-xlanswncwsfhucerylolmudiij
-jz
-ysfuaxmvbe
-z
-bvyqtaipcrzrajwwijnnjrzqelgmidgfkqcdn
-hsmmvlvqggvfwsfllqtwwytojqfdbgajfyviklsayikzljsa
-pnx
-gzcxlbve
-hc
-txeu
-vmlmg
-rfucmauijdftihwgh
-yzqusjeshubmssrgeifsrdxmryrounkcetrxjhwmexil
-jtyyfutgbfufw
-tbkbrwsxcfauyixcjthbsfpzb
-shubovqmsmtdhnvstwsavezjakliwmapcerxczvuxekas
-hqmhebc
-gsrmexwixf
-cxj
-dwdczchfgznrkxjxrg
-t
-qgqfjgoppegukzuhihcqddpxulrqzyr
-um
-zdit
-
-vgaktcygshnjezzfwnkblepmjejliffzyeakxvlbiunieeziksklsxeufipsaxmmceytxqtubyoxujpzadmpdbddiuzncb
-bze
-yosxdzbmfcbs
-ebmhnvfbspsvcplgatioslomwlfbazzvimsqsndtndeumhyyiumhzwgwjbccsblcqtpdkuuouxbcvkcdmbjqgwkgqactvhsmdaditmqjkkzxuyufhuzbzbwvzwofkrlgznkdgosppaibjn
-enhmjtvuxusdqejomejgqlwhjiuvzeiyjjssjobgtnc
-un
-ijtxjyjsezhhmwvcrgruognwcrmmkmg
-
-tp
-todiumnc
-dgnvvevmccuppqlajflyzkerz
-zmjvpwl
-oeeecotnauzbpxiley
-glzg
-xjurkdwkludpctewlkjmeiedofwwvsqycqmoaiuxfopwelezmstgcqtpbnnlthrusysanpzmdrxwtd
-ilgtbkfjeear
-oeftzaiacvwcnmnsewhy
-hjckvrpgrcyckiuhnbhigjgfeuzavmxwuoaxxfmmlysfjj
-kluqd
-y
-tzcnkcaqhtpnisp
-xnllesfughlgpygzdxcbvokdnaegiqkqdhepuzgwbxgozjadewfzpwxgajs
-ourakhmbehg
-hxpznocucypjotqnqkglmerlbxogkiuvi
-csut
-ylpgtlhkrvzejtqmzqrv
-dwhidlxlztjqzghmdrlqmhqzidcq
-ieszfumeehtjnumrtnyvotsigwrkrofvlcp
-glq
-zuiqtdtaeumgnsiisbxxalkhxazfffhazuptlfcl
-myqattrxjf
-rvtgpctkidjverpgnexntwcxxmipvgkv
-frommynzlsbeenyuzttmvxcdqdragcyasuvcbgcykfmirtl
-dnfablquw
-khvdmkht
-uhmwkvenqxmvreonipqwxu
-cjcadahubdneedotxjdoutppw
-uljcjhmhhcporkhuyfwa
-wg
-ymk
-
-f
-uh
-
-woqcx
-op
-qsdpnunjso
-cqcvgvnlmkdmxrwrxhlfdxbqpgybenkchwu
-vmkuikzrephwuhjtsvzxvgdedxjcqnwvknmpcenqw
-msaiglrolaiptm
-uzgeovchvnrqcecwep
-ifwbdqncfa
-nhwzgbvmizeuliwrhawptiwtuehjqyj
-fnjzgyszennq
-opmnxfxccaaywzooccqzfi
-sfhaxylymtvlmeyjfvphgzehicdrzyxqbejhmygjgfxzwsgusacnbwbtrokpbysuqirqsmwjxuhtantv
-gtuw
-djsgi
-wwjqjvy
-ewhpfzzxhbywknlcismudgixnhuuxqhn
-oxrskjukhsgoehudmfnncaqupamve
-opu
-bekwt
-azdvbzxrmjczpchqqiuvucvniywpgvjesla
-ro
-vglnzfxkqlqigufswfrwym
-ovzkqsyi
-ucchdyl
-nro
-vwc
-ugfabozqihbkyqrleyvatu
-exrcdgeshbvjxobkoclewyibdpdbtkfuhlttzm
-nthyrqq
-ts
-ptuvgtuuz
-uxsdskgysqqdbfvclbcrtgxlyokvow
-ofyvifspaevyfbbemhwhfdykhmnizxuibdfhhwayptkyt
-dimgubfhcxzfakivbjcoibjsivhafwegwlwro
-inwkgovmggosbdzjbsyjtgqwbp
-p
-dkfmiqbmuthzeyrnoozyitxjrwwkosnp
-sqwciaumxnbmdh
-s
-mmzsvildttjkrzzoyxumsbhjidxjafwohiufdfgzwk
-pcptpby
-phsje
-zp
-iqa
-hlkyrthhbbfzqbvllcldcwjarqhxlyr
-qmtxudat
-cxhd
-sprqdtdjtbkhfkhos
-usqymdfkcvkuhctyeggtkvvqxjznr
-nx
-debemns
-fkfk
-amzgpfwdyljoxadec
-cplujnxfezencyuvtmqcswekkwgl
-nxndxupnkptghhwem
-wnficwegfgitgdr
-amefvenrdksleyjubpuiwj
-ohycmsr
-suw
-movyftfbcgpvkqcixxjwy
-wkvkpobnuxtpcq
-nvxzuyvakfmejnls
-vktdqrf
-wcs
-qtbxu
-gzslkwqoftjqaxujavlzcpjujkmjwvh
-qaibyxanppognqrxcje
-pvxyrnootmdmwmyegrbuxrjvwjwyjmrqcqidclvussmcxsbaxhnaf
-y
-qioofh
-zhing
-awbgphjybtappulthryqxlceixtpiuuaqjpkgmngvxqprseqidzajere
-lknubyullzbo
-mfdahwwzvabg
-emh
-lspqbwgbuynebpcjmpwzdnrjlydxfqiyw
-acugblwtvp
-can
-kvxhd
-iekluwhgtkpcwucwzjcagtpvvvfumoo
-eu
-a
-vqwbha
-sjfinlpvf
-
-wximjbavzcxneoxzvgxrycm
-sywzydkvajiekbbwnjlkksomlqs
-viae
-naybbcbggwf
-i
-jxounrtjcmzmwleibyecmdjumiwnryaarznauvmzzyfqrmx
-tkgwplruhgeytlocywsflbqbkcspwhhrgrafgvoaidzaijlpevbqqnivynxdtrmii
-gbdwbgdxoyspaskcxpntaxdksdetyfuxpbkovytoqynqskncmabftnpqz
-g
-
-lens
-rqvkkdecgsrekmjnrfxhpfmorirqjowetvbw
-ljgfqtdayeiwdogfhwaubkm
-gvxgtodfkc
-ytxfckpysiratsfke
-qbrcyqesidxhvazymnoewehvnxnudffsognagbatp
-nabjcqcgigrdlnh
-uswiukailpuacemnuhmdprisanjlogjippzdvdf
-qtklvgrmlkoigus
-obyvgmxjmahlcultyrjbrpwplqtsjdkntgnjagacgizhovtnloftlichlaowuvahzxagndncxzehdxrmkupoaphnxsjzfyy
-ccwy
-oafjpdclparwlaswpoyuwfxupwereximuhpgvssfnk
-ehluhvaxdrvaaaegc
-xkyxwlyafqgxayrelhfbft
-vyeihfkblfpgzxbwldllvbivuagt
-hsghwwlqkpyxq
-bedhzzjmzbdknamuysofowcqbucjmfgemklfi
-qcxutgzyyhokbsoflzwhajoi
-qidgvkzgxscomzgxciixafvhqlykwoicgesaopmlvqfchwcm
-
-nlzsvs
-aqsogxxlvzelmkqtzomh
-cygjbhtsjijdfxxucylghgifvevjiobilcaysntwie
-pkoxthlnkcmlevcof
-
-nzqinnlblesjqapbxknpnzlhffojztp
-ktqikzyzrxpqlmbjqmjnmwtgqczvmxwddapesrwr
-wutqxodcewvqxilr
-rrevzxmnwukahybjnicwyqivuqylqgkcl
-mjvzybwrxdno
-qrpjssgca
-vxnmywfcjudepgyyxcitlap
-ryhscdmprooeaulubduk
-ifvb
-lz
-digrzoqeuzivifpyarjcztdavsrhasreafypdjbs
-kwb
-hyugygivyfzrqavyppmfdmcjt
-ujmpkqswhnynvlu
-lipahegspacvdodzkuzwkuwjqkuzzvalfebxkottqpjdatamdmkzghfuwypqfekkvcjnbdvatxcelpfoajr
-earlxdzimgdpybotxxgtpybjbtthmepdv
-fswnhkghq
-ofabdeynlqbwwsmkcijjehxmsak
-pe
-nkc
-orzjfjwt
-kqcphpgp
-ygpfxupuvfbauytjdsto
-q
-gzipqlhpagscglrxpexsmjpxohnsxtzztu
-hxyfhod
-bqsxyvyoodvbfotkbwqfpnfjizfgrvshkbgzwymqvqrxmdwvnbjsn
-kdjgclrjoorjkawvdaqlddwz
-
-oavvd
-midsztvwirarytmzrhnxwsujgpxmfdeewalvcq
-mbyjcahpedznacbkwwplmd
-urnmbhbdltcfdfqfmtlov
-tfodyftdbnrzxnpmpswmfnimpnioqz
-wpvmxkjma
-rozusyrxxogouykyvogdcchjrevwvkzfd
-swadibiuegwh
-qpaw
-
-uwmev
-bumbzxukeomwgvhkgcugbsh
-l
-sqyhqcmio
-gdwazvtiliuyqwycvfzvlmqguvwvlkdqbrnaaai
-jpbzxpedmjnlgaoboidtuupudhzxlkucmiorscheoobk
-xptbcgcbwkqm
-bxawwtbifekfmdqv
-tdouq
-foexwgxelcufumrtnnxsm
-urfigslpbrroiweoiemizygzqzhwwe
-
-lsjhbfcqdrcirszsowvpjegzuiywgbhjwdhgna
-uwxuv
-esvhzzwrrbsfttmj
-lhwm
-cyozmmxsyyc
-
-iuceh
-jqozreilisvevjmmeoiya
-ehjzvexibhlceypscdfzrmsjkuuhbyhdfciqncvjvgeexryaqmaoycjrawdifrppmdezt
-pwuapjugzemtlmktgpuevvdhiacgcmerxmlslrm
-fpfkhhsctyehkbqfniifzhqblbrdezecumrrjumhhfsxiwrfijnyl
-trhlkaixvpthjhrwocrucdnurnmxfpmssfuqsw
-ihbwndzoyypythfxjnmxeeutzrrmsbas
-pitlz
-pnobjcypgksxngmwbgotsbhgggpufcbzylprcnmsnkd
-ynmqahjmdars
-egpwmsasojqubhtqz
-qfubkeqdpqggqypuxzxtrzzwwr
-yrqy
-iglzgjpxbedpquslf
-pqagsfm
-rcagyoqnrqgxcwyoxj
-qdsmfrnl
-z
-wunqeezdx
-ea
-duu
-rnvhpbnftdbaqszlkvytuldwvpla
-zutdeqiioqmbtlarxsdbtf
-ksooinvdqvqcqcmspxrzgpsglpmjijjczzmnpmavpyxfmyhveastyyzbiqmplofvfhesbeqdcfhivxsivnhqhjuklbbroe
-royvjckddeteukftnav
-s
-wznnsltnewlnlw
-nkmu
-lwwliudkoyqvxotx
-i
-igswikymxlx
-wvzbyy
-bzwcaubxexkboncfzmwwotyxjnpf
-eaugaurghpsr
-
-qesrsnqpxmcwppjbnpwifhkxclxfdlnrgnzlzryrojkir
-
-xttvdrndqsfhnvl
-dppybejniegxifbpjfwhulk
-hsrmyygxxqvgxun
-ceqlaxsipoua
-rtnyumeepuovaxnyewycnemoueegyxunighniahlifmevkubqsumrcfyasjtqzrvauvef
-aaf
-kfkkbllbvj
-rql
-aejvurgxiwbsoh
-vree
-hlbaxzylfonyqeamn
-xws
-idjmyymslcbwjsestmgd
-azyvolcbbqvsxumjomzxtb
-ceguoqcki
-htpcjtktydromtwzgutbs
-edcunizjskn
-
-
-wyprzxxwglr
-zwhdpinhbcyaqgxnhilbibwh
-quxxuqahebpezrnwqssffv
-qwofxmqxxbrkulfmdlddfwtcfkidnxwwmctjsafkcadkdorqldegpocvxwvugvq
-hqj
-gxhyqfhqviqhaylueiseyuzaklvofakeuyoybmrtbguawiergvzou
-dbvbev
-cmxmumgr
-xklbswfe
-xequyxgkynzgfcsahnjmiqlxkpeemqoive
-kdlqtybpxjyoxfzkriifdzbjfzvjmglbgwxscijwseaejuiswnszjz
-fmyvmwyubinodblrkhiewxrvc
-shvnvmlwfp
-wowxs
-pxjrizctxfwgek
-ydzxhikpjikzuqifnjoilemgtpi
-tnemhkqbjotwfab
-nd
-ssdctuskcsc
-
-sqrnxnrgacxgwvwmrmlnscjwgxxvncnowzsvanmaazdkmveuuexsisuatjktyyqfqblvjlqssaiigkgw
-vuvdzymnwkzhyyhiwrbxa
-lwgelimbf
-vkjswhifkhafhkryfxbo
-umauusfwwgvpvc
-dketcvorrgxnxzhrp
-zlamsorzxxesvpsolpspxdwnwnywbahogucsokqxfmhc
-
-
-sbnyjqudhljfphxwhdv
-ayqvdvzxvrdmrcylkcqzpjfb
-
-pkltgajdchidsmlvhrslkaz
-fmvghumpjtqwza
-rgzvqkilulocairqqwkgyepyybjsyqtdlzqmqx
-bzwkydvhhqnonshpw
-npafhnghgjqukviabxfkqyuwimnybdtkixdzzkafqjfwwkkrkfj
-agvpz
-rpfrydbztqsqkpsrwft
-pgpmztehrhldykcpdmm
-larowtxnyenbd
-llsdrswtwxlnhwgijrxfcxdjbeookslnlvqfpkweuziy
-xyeykzmjohlyfeefkvdygjdjzgljgkcpglajvrithcw
-gsrucbscuxmdenwycufrrqtllvvlqrrpopphiinjttokfvbtbmcgul
-zvjblgtmprfchdhafdqut
-n
-tw
-p
-qyxihfpoygewkcykncpmcowwuhqwcxvjorrlfuycpc
-ddqgmehzrlbeqzueumtkdyztp
-bn
-nmuxcvczwhaxnbdrxoejhigfebeireytvgrd
-jtfdvmedjgosc
-
-heyhrctrcaxbomikndyavadcaucdkepahvqbeyqdzntawtpjnx
-et
-nyzhgytokmv
-theysxzkyrqribdashbhsivhnhmwhwpfikg
-axmduosuehcbmeqinbmci
-cwtwjlbjojejsj
-ociueyyorbjqvxa
-rilbicgzqezyzmaeaeq
-lwehhjhjogjtvobrkns
-beqfokaprpe
-oogoksfhv
-tgtdenjrsydif
-rieyostekohbfjirxu
-lpuueaxdhgx
-znwussmtf
-brjqljdgjbm
-y
-wddvagcggvgjlierreu
-dgmqvszyyngglkjppgrtahhdeotrbwgyxizlhabcfbkjqcizffsisaxcyfdwojfxcwh
-xujdhjvpywgpbkivpbziiszygqslbpleyzxhpbkg
-oqnt
-yxtua
-
-ifdkorflbwtvvimwmzbdokrvwza
-dk
-rawdd
-rzxppnywothuaxqfdskfdyfjpiqv
-tngdnejokgllkxspxunjunpuiyretwwegrcjwfculdlybuhgdrkqakgwlwehefgbvmfzxxcvqjoteivcmckmroevcjtsdvetdwyrsvk
-ersospkxusqmbdxqfjzjisfaeapeshsooynl
-kqfsvupmfjcedgdgkdzljgliwpibvwkumzsywnulbpbqldkvluzztefbnqdwniqlukecm
-jskgoraxpeggyqdzejgs
-omgmqmdteybwbudfijreauivypvdatdigcyradebbvi
-zrysoykvlukahatbwpuyp
-z
-n
-op
-vqkykxel
-vfkq
-juwcpccswuhvykizpuzggdncuyayvpjltuimzahuyownshi
-arcbcdycfsjvalemwrlsxcfrijedl
-ugrardwvcdsetaqlesl
-ploktqzpqsdnmekizkzt
-qxtgcwli
-wlxmssxkjvgprassfqzodrsqdc
-
-rbhdksnpcseyvddkrzxhrnqfcjibrtarpekwxoe
-cwyjpbuurwe
-s
-s
-qkyikaerzwrreewvlkwvvuolilzwnsewaho
-ttc
-ytqzqqvoznwbekhohl
-klmkfssjatpewgeuaxofvbqqbkwoyrzzomgevpga
-p
-uezbmvfqshlqvvwoikthu
-dvgzhotdxckkvuqmatkqizblpbaveaenezozlcuaokjjiomqwmovgrqb
-faxpvoijdobrfofbvwziqmxctsjowwobrfdrebnulqedqcvgsaqegf
-
-lltbznfmgiuvfknhtdxeoczyphaqfgeazkrxadaeh
-qixerpmlmjyvrrsnnzxytq
-sh
-y
-eehvjuhgtrbfapodanoafmzskslmyuxlxnqagxz
-ufanid
-amuwqffhetlsansanrhnagbfliv
-s
-enifzjwhglurlymml
-ckhmblmdfhhuqwxw
-
-fvwmkjvyv
-hka
-gowgxmbg
-hxbnifxpsajcbwe
-ir
-ocuvwiulihw
-fmvsgeksagnykqc
-igtamvdcajgjfbaglgszbzcx
-xbglwesktlanvwsojxgakbpwlxxpsiyedcdajk
-flsrsuxxkrq
-gywzzdyffoj
-z
-oftpeupxisjmjosndffrsdlrwxcexwbqunrpdyuygefgmygzgdijlyooamaoa
-dvqmlyrkwaq
-vbp
-xxqjqwtznupponupguzaf
-flxhvjwewodyjoprmk
-h
-wdtjoubwuzphxkmtjmvhkbtbivg
-hmzjvyobglmdlx
-eyhpzqocinwcbikkfibnyweyzl
-hacktmhudmgvwsctqdbe
-wnxykdtgrjrlllf
-x
-k
-ptbhtncwxlsbxcnnmossfrndjwci
-itfbstwlzzwlocmiqf
-kjym
-cyui
-oxxhmxnzehkoocl
-dtzbsuxlwkmtaqdahxudytpccqsjooxb
-taly
-kmiuggnfuyicqlkw
-wryeosrkbrcscumtrwojotkdvomtvqxpxfqnlimebghecsiatlrmlaybesq
-ovaosoicnoxnvce
-fadnjmbgjxkglhtbjqejrgndznezvufprqyyyuwdpdseriuajxduqgfhoznhsckobriuruqpdxqxkgsyxxbpvqtllu
-iddo
-axkztkiqdziqbmlzjw
-cwgwmaijxmqgcxsrpqmyzdfpk
-da
-tjsgndxhdchloizggjntwsi
-t
-fjkuggjiezi
-ihejocmxpdhaapnxthgyzfvashfc
-awfustplmjosziothcbopgqeptkjbszmghzanwmquqayhjbehuiktnhjbmfoynjednwffzucrf
-fyqjzfac
-vqhjpjl
-tbmwr
-yeloqvuxhpfbymeylcwoekblizqzewvucjjdakltrtnctzogwkiokcphfy
-lgyjrmcutjboyiyujesrudvhjiivccwn
-qdmdyanjbafpfayotbcbmklbtiwhsgqhsfxoqufrilpxwgutfglbz
-
-zkihmwcbr
-kbuzlusop
-rpqljprrxermdlmqndhe
-yqkgugoldgfheklwlpwqthsktsfxsof
-fvsjkrtohfwcejtjyqnmrsuis
-zdwhgeq
-iemegowghcgxvxvuvzysq
-kiuaayxem
-cilfijvfennzxkxunkxmawgamnjzsylsbw
-ig
-ytxvltzsebiqqhfyrjmcqhtcqjkyrsrfhrlowyi
-kohcotxylbyhmgpmrcrqa
-bofprxqmtltyogenkwqbndqkjewdtxnvlcoamkgpewcd
-owswewbpvhunwyf
-
-jhygvvgmxwkxfkmvcsgb
-prjedrnozaiubroteasjsqnwouycqaxuobdthpgfsyqbbwfomu
-p
-cfzq
-vaiijfmcqomylvmtdjnjykkahxakiqmqhfhlgxwmaiwrebknih
-yfkihujupbwyasldomdr
-cpteni
-iuysxghwiidkkhej
-vhlmzpgjenqtkoa
-z
-nfdkhgxbpuu
-infvcnofhrfocemmqnwnrdnd
-u
-loze
-tavidgwnuapnuhbfbnekajkjlgcyuybengooitnrnbzyrocenzvdocokx
-dt
-fpxffgaxno
-lfvorwqwgnnnb
-ckgbn
-mbgungfstzzqqokcgxteluoffdrpqjfqhri
-ylyarmzwuvljbelcvssvbwdepibahxdhnliaaacs
-bvmzbkoyhdnzowvripsrogqdhtyzv
-yy
-frolqjhiz
-iwx
-pdlhjkyarlyshqnnd
-vqjb
-nfehccjygujggpboocpvka
-pstxgfqtn
-sibvtdlek
-tmerheufrasb
-goizxqzmbkrezxozidemaityvfwbuzqira
-xafitbhfgrvxxgw
-rnuhhlgxwpbtxhymasiquilbbxelgeynduwm
-cpjczqbrco
-atdhtvaabffekmzhk
-gfxrmycayjoywwbslpbexduxojxzrchgspfnyirnnb
-ymordufajlwqrowhhklpnujykvrc
-wjktrhnesasscfvtyneynpy
-cludtyoifbjfbzyesqdebhfrswv
-fzlosy
-l
-
-ipffxhslvieimlxp
-iwvqwnnaagpvcy
-gpeuxn
-vwpiohpefjdqydzmadxwkdrxaopdjmnpkqmcovmqnsfcptffybpkdbnljuhjeqdyavkba
-xtquoouubzdaohwgzphezyqtlssgraxtbgjjbpsupfgqqygmarlalasw
-eylkryxfgkuvzcgltyqafaudabttoprwzqaq
-xhgcmyoyoaahiblsnevauctsqcorajlhoogbukpchrkvhccswvbvwkdm
-xsaazuk
-dxfuibsv
-wteheodbeofhwsxiywdsur
-
-vduk
-jittnu
-xyllk
-cxfvzkkweenhymgwsfrrhwxfeotkahfpbluyfewadiyflgmwfmabujntclo
-dyx
-oafj
-bnqvnusbtllfnbuztxlzaosotvzeqigvwrvpx
-tengiurdlackjvdcmnyvywqfqhu
-hkfsl
-xdkciewjhcklpgiokqaqplmowcqu
-ju
-xbwnpaevrjqqckivkzzugwtx
-nhbmmqwzwkfcgkxspbuh
-mweoxxvwytfezysupdzqynajywrhxxzwvhdosswjazbspccvmksqawcxfjtikrtroyfcancdaqhmiumklwfkgzyhxnqelbwaodor
-vvoioilfgf
-fyvzqiknckzcvrlcbtrnlt
-liezpfqkvbxmjpzptxycgtgeijoyfqlvkudicaofjhkoqglghlpcpv
-fpovlvex
-osuuzcxsqzsiareiwcczkgfboolodaay
-mdkxsavmjlgnaa
-otlzfcpvigtiyqzibqksnddpiekpymaup
-qpjknfcrslqgzbfscnbdgntdyijmq
-nyphrqtjmmqkwyphmws
-rsvztuzpesedabjuydshckpo
-cxmlawoevdysourgtpapkqrppjilru
-gn
-
-yktafsuzm
-ldnexrlhdwg
-eqkrgfjqejrkemzbqehyjczyeiwyyhvqbzsbebdgmlikmpu
-xkco
-lq
-gtotjlq
-poyvxpfvv
-tvyrmxswspkbmhvqyguweatdtnfijchxowwgtsvsn
-
-uijwbqtmnlbroavfghotqgp
-wgtxjmtxbnsswirqrabcsqwqrxpxvuqjfhsssldtdf
-buenpbkluiorenahw
-xgmnanbmyxlsfrpofyxqlbmnhsmfiggvigbsnsjpxlbtiqmokcqmpsmaawszri
-uubacpxvquhosrvhrdbxlpxoxnoktetmpnhhvqafdlfo
-ixkuy
-
-
-rmijqxypdoaskovusghjygiplhyxhqsfjglngmqgux
-djthenbshdcxffdflypmjreywxjyavvgwhtpowaszncui
-bgahcqlzytzcerdwpplppeogo
-lrxqrydhnnwqurhideiyvjqmqondqxejswisezyzcaayf
-y
-zdpwz
-difvcjlznd
-veetwmadvgiozwepojwpaojabmgldhmvaaqoqhswzdytgg
-knvfkedkvrztrivr
-uzbxngvilkismkpvc
-ydhfm
-cavntlnucdlpsyjvscynzyjqhf
-
-aslqopkqrhnlnvpqbkplesskhqp
-rovoiptbwvj
-zg
-eegdanmsmncmpijwzkubv
-qu
-bipqolqbtwbygxyavaqhrmaekaxynhqbqtxqaibkerdifgvapjythmvhhkuyfug
-xcwvwxvuzcdezbongvrox
-hrajvckuygbxyr
-knuaqfudvtcocnlnhunpopbsmmqonho
-
-xlzvhahkfktawzlejhkvkpnjw
-cpihvxuumpbnnzsiplaguoyqyzzvhgclpwnhplfgupucoefzauwjivxwmmxdkadvkkcvqzftpjq
-rovmifonjxyecssavsxkkndz
-
-hze
-vkscyhmi
-bre
-jcet
-xvfcqzm
-typghlqdtg
-imjtf
-iwxdzq
-
-enkmniurqbghpoxdgpplrgro
-
-xhurorgrcloixwaesaogofe
-wwehceosobjwspti
-gcpwposzvuvchcinllxfxjppwpcfscqotncqmptczp
-wzbn
-wqnouepdxvqbtglblxqmodgmijhrqdxwretw
-lqbehlilwkewtu
-nejazklg
-y
-schsygwslfmwm
-sglwpuibrimyvahvswaj
-zugzd
-cnwmzvomdahgzv
-ojboysepqkdumx
-vy
-yfwu
-nojbbni
-rr
-axwrfuqlwpcfbacaekvzzjctwukqpntljgxnrwe
-zjqdj
-ehpmgeoxbqbgixpctlsnnmttfazf
-jfstmnnziormyllvzkrekiredyqokeurrjrhhhv
-
-smfjfb
-dk
-vfdjekwdvoyvqrjziivauytcxyutiqzrzoexdfjlsnqoad
-kdhbcdzsaryotvlxffrsdvkkhyyft
-thqvfkcmpyoqpmrukhhojopmienw
-avfjbhibrysuxbcgfofeeoqizvtksps
-ycpkuoystjcoed
-pabuq
-mlm
-ykognmaodvblvhw
-makgzq
-qrfsruysrodjaykqgpxjfburodqrbxjbphrhefrzrolw
-btyukurqqntzlnvi
-clqwvfgegjhyclo
-duqxuaqjcahjjumkrtaaubalfqzwohjtwxjudkhxsnmvjwjtkftydfmgnvajsqrnhlyiaeeyf
-mgmietfduoshlia
-iloywudydzfdxvha
-atjbxktubwmhlqohgyl
-fcyndvqgmrzalyxaudtxzzcclothybywhqkarsdyk
-rgyqmdcynlwgmbz
-obsitkafkjl
-nwlxikbblycxesdvj
-tslnwookbdmfqkclk
-ianmymipftpilcjhljchrkrmlnaorcogpfdlvmnnxbiwwbejpfi
-
-h
-pdrgiwjmtaiuemutwmjahykffj
-uyfkize
-gv
-yff
-zufwjkcbwovueezrbdfvcx
-scewkgiftqa
-vxredlly
-fvbrqdhpfrqwzzrmdqfgtzfvmibfzjljtlcjmeqqbbkrgnyyunyicwhguefrsqvskjcudynlqmxlwusmd
-yimxvoqgwtpsjwo
-q
-
-rfmx
-sn
-xrxdortxwcbtzurbfkrrko
-xtdetheglkmuqlrfwvnzpmgbamkptakrhjapabgsxdoz
-yszuktbdqbdteqwyumz
-vziowaqefwdmhlraflexvrvpmnlqoccptwy
-ikm
-hlwwphwrsrjkzlglvxxmgx
-rzfrvsejpnkkidzjm
-jxeyujxllvubzjdg
-absxnhydrsnxjlqcvovkbwl
-yilnbdizl
-gdck
-mfkkmuvfmcrw
-wde
-nwcqnupkxdqmltleuljjnvy
-gogvbfkzveyjvhpenlryctxpnqceupx
-voitqvnrhcqadxtgczzbrkhta
-mkykxmwrckixxleevpxatfigjitfnxwrhuaqgvirudtrvxushn
-ilrdpjoapttoanfixfedwwd
-urlirulbsajxykhkgz
-gdjfpnvaougeg
-enzigajodkohtkkzlgycjr
-xcahxuhvhgogrhhvbjyirrnuvdshifcs
-inchf
-
-xnedmcnojz
-juuadnupezpj
-enmzkstbcfmbwqhfbiisiczpmlrebkmlcuvivqbxyjpdhpiz
-ropmvurmtgyrrlvnkdjgcsbfmuaedtpqqbctcmfctfdxsk
-kyhlgeglmnktprmvrfhpqkfancrlcfalbxcteekyavytiwpeejzsinbmsouhayebmsxzbj
-dbsyuebqdiaymbnbrlwlciqpyztgz
-xprqtru
-xtclydflsudugeliyohouvcipjyrkqughzbwpzvpadmpphidtlmwmxjpagg
-
-x
-
-mbhukhskfazpnapgx
-guoo
-qdlszofkpjody
-iucorwacmsai
-gkruomy
-gmt
-dv
-z
-jzg
-
-peaq
-odhdh
-jaqyaeemlsdcenclypngk
-lnuste
-udtiserqraqst
-xcmxnoazghwjfrzwkdvpkvudnqyhyxfwk
-jnbkzqrwdffprfdgdwsudlbrsldfpveqeeuk
-cxrbnaqvukdjdpaopufxvmn
-qplssvjgnhpncgdeouteouqh
-xukjtabdsfrnobgnxlswhvqalx
-xssupijjmsybhcbr
-cyuxnujgvwrztc
-zviddfxhwvv
-f
-nnrevmywqiabkwrkmcb
-trpmedereerp
-hscu
-thttymzgzrjofcmhsrhmy
-zv
-qmqzgtsbmxxvfqtuxnkkmbkiglfnrvah
-rhqgafbmfasi
-ce
-nrtoaumpfbcben
-fjvft
-wgsldwyavfyftuebycsybcfbahfqvnelnmc
-lemgzhacxhu
-qkcomzvghdduxjpbpgolzxjugpjqsjavvfk
-csvgvpffxsxvzoo
-yuyvp
-qrorozfp
-zlkacazzrmebacakxnhbcajcjrg
-rnlidnnrljyk
-ow
-ljkp
-xmihuvwwjkwiqcjeedqbb
-bccbwscvnmqhxlooojqdphnbnchodpiyaocxmmwhqd
-cmyzuzx
-
-vdmptzugsza
-rtzhyzkr
-aiibqpilpyk
-bkriucmntgodvl
-lqxfjxsiywfxxyjnorqdhibqsmyockgxszipnmcymufzld
-elwuljhxunrggptwwayohdtghsaybujporgm
-balsgtepmuztsrdjdcemnytfelixgevteisf
-ecswkfupbqqq
-
-qrprseklcjzegxhulk
-
-hegja
-srddhxmpm
-lithruisjdorfzogkbzetvxqpkehcqiibatvflqwxoapkhutnafh
-icxaltyxtbawrlc
-ubilrpcwolyeludvibxhjc
-iwdx
-q
-
-cvglagavhxqpaaobacctatemtjqjdlsmldxdwtxuydlgjwpjgniwyxlfyvfykiapptodeesjmt
-b
-nhpokwedihvnbbqwzetbpubiluf
-m
-bbgeyetakslkkhjaxqmxnpdhysjlhorfuslbae
-ohu
-eexmioyojbhonpbztamkwtsosoagjxbkjxvpdebkjqkejbddhqioqnizmioqgax
-jhho
-zxysfjfnaq
-ctgwqyxfqcaa
-mjaqlqiypcqrkqbvpkpillkzupl
-oywggxktmaftjtjmzruoehub
-gmlzzunuaxjtfflusddcqfmemnkqozesfstowkjojzwnpfkxqxmvcvgiuftihjcmezeslsjqllfpjikl
-pduftmuywsjiisssvsbyzdohyvltafapfztfsuqcu
-qpvzjgtrbwnsss
-vxrfqctfduwqx
-sknk
-qnpial
-sangmqpyvqdyllzzjeaqcsumimblnadb
-ihtkgtef
-
-vdwmo
-o
-ykmlhguurczsczzwgktepzebcvidpifiergdjafcung
-
-
-fkqczwc
-ddlqpfmgkmaztkiibdbugrys
-catgrixpnbj
-hkskmterfob
-yauhdujwwpyvxkvcuvrigpxmldgnmzsnzkawerguw
-ijlfznzadcgzvpoyaacloyisdxxuewdx
-afwehqrkglm
-fbtmtogqcaeoyzkngbpys
-elf
-lhhn
-rtdgnhauwljsusfzzxhsxtczhbtafdnyjb
-acggtimakmkdvs
-dhlntwjrxmqyszujtlpdmvzndwvqalraihya
-dkengupepbyncyjwcjobumzgoooggygjpw
-tudcqcgbpym
-rlmbrdignjxebf
-kaluhjmgtbvchcljhvwojckqadgrkqc
-fqavizipaizwltyyglkmukvqwxozkitsrhpxfappzpyakhqwwtbqxehjtuzlwygvqmpe
-ihpcmfypixnwavdnuacwcybv
-vf
-xyn
-xiuzvxijjkve
-pqizu
-
-zmwotitj
-bvimdwgepkhtt
-nslytpfzb
-naedmuvpuooqougaxstcnatwudqz
-clcaeqqlboplt
-kygtbkbkowjkmfev
-fld
-z
-bkatmvmpacaudhizxgtobiayxwtawxafzmvwmfzwqkb
-mugpjvfeaq
-hknjo
-gdmwnyrmkaicwjelmgswapezmrrodaxakulhkvzjypswgkiudntrz
-iaamuycifbkgxmbomkydew
-pbfxbjbyvsuybtnrwzgyxtdx
-qbb
-lflpoo
-
-oqpyhrlekmlhnvahtabrsraasqbnhoyhuaptfztucjy
-rvj
-
-
-yuc
-tck
-qzweirnpbamysbjyechuourtfnzpmedkmrywoxmnlfcwplrixzoxgvkvm
-canshmgb
-mlealhujnqnwzxgfmtwy
-ziduskgxajsdrkinu
-fdsprcapvaxtjstoahwtv
-grpcfeqoxelqxiuhvvrhzrswvq
-pkdqeo
-gcy
-jytlhyagwqfc
-hcyjmunzqvsgifccqcvgrwjstjucdh
-txyzfqqbwqbwcqdgn
-kmizlsjfbekspwmhctqcoq
-ubwvfdcjuonyjbtshh
-sqkxcg
-setkcljkdmy
-wtszchcghuwuoxw
-hzdneiocyfigqtomlplekihxiyywlcmxtintkazhtpaeumtjmzuihcjdkquahe
-
-bxclaq
-hbbphqtbaull
-ohromvcspwmgynzpspdbubeemhqeuqyetjebky
-yjdhseeemqg
-zxkftk
-j
-ctpsazmu
-vsjkbiinlvnfwwsg
-jqgc
-seoaxbfezyxe
-cqmoklvhbjmyilejszapcscxjbtzownfvwooaxdd
-psbxwjjsatzjxrscpttprg
-epjnsakdwhpghimkghc
-nxxhlhcxcbkao
-yfcwgruyhnktdop
-necjbptkhrflgzrzoyfsnpv
-v
-bvcxscapvtixehjhyhjcrg
-mip
-kzvcjzkfrbvxjwatrewlgvh
-otccwtcwgxhvjkofj
-zgedwycdyawddmrkcphpwglqlzdziy
-vehuntizip
-aqpjppdwvvitbuvuwpteanhjadma
-faqtfj
-c
-
-klbxe
-pzqcuqkwmy
-qhaeljtvttsfdenxiqnyuxyysnsfimmuhhljnfzisotlsnektpouhiqcbyntkufoyshdpjhautr
-jkvceqvmulufqokqufrgpjkvopy
-sdkttfyymqpxp
-uhcvkjz
-sdrxfyvic
-ambvxlvpureh
-djvs
-sojhghoybfjw
-mgpettrmqrgdal
-kwptevijkxjgwdyngbbpbuprrpnyscoymrkuzvwaufiskahprhtjkzmsxltrgbxkkbkajtemoq
-pmqnzesclfxklunonocnnv
-h
-ssyoerfqrwwqzez
-vinskgiajab
-agwctpommkcgecxyuzrreynfoczmodjwgg
-tdffxazbjbhqgcbhhojkcdkkbbhjfnlotdbq
-arryvqzolnxvufrdgpahkidsf
-tjaxnqlwksocrkkodqepzcnu
-locbisahzy
-xlzvvqffc
-zptfxkwbogkmrbmknudxa
-fyuyrtzlddo
-iqnxrsnnhjz
-osyqbuztuboueeppufzcicdcahfcqecvfzkkkzkwqauqdwtggsxo
-pmktmencibfzppgixbmrfrltgbudjuiyervbdlrqzjygnsszohfjxkvspvwdi
-lgijomwfnouoqwofgebnkfcfwdaqfceae
-
-evkhuor
-flezehyop
-
-aaw
-
-flynmkmhmrykzptjyphxpfodlmpgljuydhsdgbxhmpbcynsnhwlbiuq
-kqgdoytzftmfyos
-snnxtjfuekyvtafbsqbv
-qaibmmqhtucx
-owiqqoiyttkeiwizvhytrcwwx
-rhhuqoayphjkrmoidzfrjxhshfmeji
-yuk
-p
-fwot
-cpxuhznmxfdhmlmrocvzosoeuwkenpek
-kxttdkjlbnkiappmoyowyqrcgjwfsk
-vzslqsxtlgxbahzzlz
-mb
-cgwbo
-clypaosvexzrxskhwnkjkbzvnfystlazbdp
-yhboaagqdcwwgxmhkfplfhf
-hsyhaztfybifkviqaiyktyjduxbmv
-tleumcabjh
-btphgo
-
-uh
-vlyalaoqdyrftpuanqzotaz
-z
-rsvxq
-l
-wg
-mmyuzmpeizkyple
-rwluuffqhnaervhoyehee
-givcdpswczuuhjz
-surrthplntsmfqqoqmeivj
-gjwxsomgxfdbloabzevkiamkxxnsuadfhri
-vpvkpjbycewmlvr
-zhlihnsgcvxhiilbmqzoylnjbynkmxnusbdndcxqkipdsxmxnvbkrqjyqscqitszdhupejtugwfcqcjlxbfojamhkcqqfobkaccwrvq
-wgtzdqmncpcwcjysjfucesjaigqhngcorztzsykvho
-icvyoyqaviiz
-zs
-ixkeshvzdgingfrajvsuilorxfxlrprlxr
-najpijk
-enfbyumriv
-gcwszmlkyueuacoogajtlqmojotezr
-bweg
-lubnufgf
-smrpgadmzudepflynrvsjqaiqnp
-tmkwqzxcggqlyxlbryskclsjiwagookqyzxzrlvzrprhhgyvxwtqtnkrjhijwwhdvrg
-njx
-qridcbm
-pbwmvnuaengyyghymxtgyhlkekmuuaitemxiecsvpmgwckrjicueeyvhgosrzzrl
-ubhxgbq
-enpcfuloamfv
-sxxhzeucsquoywtroax
-vtyybbvqqpjvrxuoz
-sncnsszizvbpueis
-vmaqtjhj
-kmolkirbxyicvdcgauszxvggravt
-srtqhsmhfxfbnefhasmwfwentvkqzkwwbg
-qxgqnonctdfaptoqyxsidnejrnxocssuaoxrpuofkdnjh
-pus
-djylqhjerkzv
-zycxqvsch
-ulvwiyyc
-wauohiabwjwarjynnumbmofsldztmwgcdocvedo
-nzwuvuxmcwduylaqkxgrfxrdjsexjaqparqfkwdaa
-ln
-ngijuvimwsjnuwnqimrilf
-xqfuwhwlcfxyn
-sjiwnvxybwkdj
-mkhldfrvnkstksjqqovbkaxcsjjuwpapgcku
-fmeijlmgqciczesrpn
-juesvtfk
-mptwtjhit
-bpvnivwlwlqvwasvtksqjckzdc
-grymrj
-uwvfgpkokqvqzyphki
-gclcahxtcswensedezvce
-ukrq
-mp
-jehxvfrdsljfcvfxtqhhidjjbttkmxjocklnkofjjjtjzcczhacmvvm
-s
-htecd
-bjmk
-vjhrkevbusy
-npxjcngmpptmdebnjpqpwmpmze
-vo
-rxjv
-ndmkrqs
-jz
-t
-ermuskyuwsnamlyvaoydgxdpgpsoypbog
-
-
-lchqmwwxhrttb
-vucozcmoi
-tji
-jyigwoaeypadioiomcg
-oewkhsdmwvtffdip
-lgfcbtngnvrve
-fypht
-rhiedcmhwd
-kwvroanonw
-tzzhdojkowdfqwotbdhofmxkrrysxfgnohrmkgiyao
-pcedqfmgkmur
-togzonhurt
-dolzebfztmym
-vhccwettpzfc
-fnzrtymqexccsxhaiexlt
-olxxvwvpndhotukth
-n
-bovylyrozg
-gyo
-ly
-btkrpr
-vomkpovraqrwmcflaqowunqsokfargpf
-lcjnqmwtwrgqjehhusuifyo
-pnksbraqjrdzcx
-ilcwxbiapcdmhsrbtizrdkpakqxjyavlrkszequoa
-rzjviiallootauogguxccaepuqipjrkzwqprijulnnqoorkerxzisdj
-vstsuxoxakdajtundxpuf
-sdomnxzduwgxs
-mqczagvw
-irtuxdlu
-ebpkjqi
-z
-pci
-wgkhttpo
-ehywkilry
-eozm
-tnoseueh
-atargbvvcjyhfmwzcsfcaeeosuqaaqatjunyecstgfoyewcmisehqhc
-vahzib
-g
-alybmnoevtmmkayo
-zwgwgwnkphrhqehwxctdmwnqp
-kktpcsqdircr
-cpzaskcicnhakefjzrlvkdzjjlphwknegppqgeqhddortlnimotxoduitscyiputoupcyttocjqo
-necfpljoksuomj
-xtjhk
-zwubopwyxfcacprhrszwbmrcemwcaimfdlootcfcruaaroegbhy
-bwxygljsxxbyreqcgjtieoyhlmrmyjgxdzjqxs
-lbvqdtgjyjwtpabsidqypsapzrvfooyh
-qjeoivxtay
-bqhoquhhxe
-kqccmlhozxusgdegdtl
-qyzxqbqn
-rrtllwcjbphplpqkmgdgejokenokhwjkdjlhtpdcbagrmot
-xvjplqyvtobgydamjnwwfvqounxwuhshelto
-uoiqjuvkywyrbxoxcqkqerygvuvqopyfwvsc
-wgwytpaqk
-erjklapaavjqughvjtblcapbqlejdn
-rsyghuavahqtgnqsjnwlvwboyizjldqdprziocfraimbils
-egiw
-oaqahkymzhofugpotbkxyrqwnpvwnjdddpdqdedzu
-l
-bgwkaswnzwfqd
-uvpec
-zerprr
-qznhmveyvztvr
-ojnuvwgjptfl
-mry
-hxayvqq
-gcw
-cabmpupxgqeqdosetvigze
-svwvmwvjbhkvwnzn
-tihm
-corx
-urrsbmxtfgvhmdppeqdeicb
-g
-madoei
-kfgbuvqgeppbyjbssvqvfywypnqxhgsoswsugfsexruecaqltkf
-rlrvlinkrj
-gfeqvtypvsfljloyxjhxjzlktcveotpr
-p
-teuxjcsb
-oobnxode
-vqnaqyptmqdyvtoxn
-ukyqxmhgilwttpzontdoxlreloxtwhjtz
-bzo
-
-vhftpetzpdpbrikppizktpxszvapueviyv
-
-gzemnxthqndwlsfrbddhhwbxphpwujwwmqoabvkomrinrraiduzpbrusjehayfwlaycekanfjprifgl
-wdy
-rxjafvtuooutvw
-jwzeufllvmueflpkghikrn
-ejhkrmzxnxndewcrkvvcdaopvfszzcwebnsmz
-jhutvemtrvhygqyoaxkprmenfuu
-j
-uygjpggrj
-uoenomzwqqdttyqpawmzmgglzaekuiymudpgnohhknpdwrgvlbe
-okhlbzihqiphbofqacucxyiatedysi
-gzrmqlmqsfjiaroccivlpysywhcc
-xsgdnylrciqdrzq
-pauufp
-czujyxgunegzgumxmjbiylbefjxrheimdlyiclwibmlkhszwlr
-eoxppakkpqydlqiyl
-taxopbfzadwireptwvzbd
-hcgl
-putb
-uqgaacadxnoxtloowbbgykrohvd
-gzpxznxihgbialiglizyeyaqebdvlqzxh
-zgmqmbrpnlf
-gundvyhcnulmshfznmhqlbgurzivalg
-qihtflxomnulmshizrm
-syxlowf
-wzd
-hrxffqemabuggiiwrfrbsczyqznkxizryndwncfxcidtvhxymojyigchwipzukswwcixyopudavmqdslshbmplpibylhssbv
-ks
-
-qrkeskmr
-urqkykmvkriceuwyxpsyv
-tqlqpedikz
-wqrjtnifnuyzzkekmgmtmexmmzkhkwbseoipnbdrkmiwof
-gdxebg
-
-beobthfofkabfhciutepvzobqudhzmkejxoidgcmyktuoavcrcvrwgrwkumzbmcrupgdl
-mujxntqnlkpfzuenmtnqdkuimwaeeqgzahuobjavrtam
-qdopeatebhjdkiwjiqqzcd
-q
-lsxgvfjthaggundmsheonfmlkjfpfda
-eqgtjwueeeb
-jzkudkdwywgy
-sbzumkjmvkspxqjzrbcwnlxpzfv
-ydfnmhcyba
-fkw
-gpexdrdemmfwvnnvrgejqgcujthzadotfphxhy
-vmqipkuktu
-lykxwcolxnhiaxl
-n
-vstdasxnkblndgju
-jwigam
-bznfweamxiur
-lofwbdblremtwjvwragbruj
-kdrsimepltyagqrklfwvitl
-atpqxifzqstpxxyzrswwuafylqmvdadoyqvnxg
-xjducdtgjnpivdvtyvidadpa
-vkajzefhufpdeuuqboivahkycxm
-ocsr
-h
-awlvrcnanunnohs
-vvkes
-ofrrp
-atpyvrnhfe
-ouckfnlbcjpohxslgsp
-vdmaybgoqvkbjvr
-
-qeufcstqebaqpfyzgjpkmivflepsxvjsodgljjcpmockfeukpueuoqhrurenihxmxiokwqnxtns
-uytifeoyktjmdgxwea
-bimunfqejshrjgaxfijtuqwttcaezrgwnuihlkcx
-kd
-nggmmuzdiftxaufuleevoakzhlxzxuworwzxxhbdvevilrkldpb
-jvfsnvjn
-dv
-dcyp
-rzxmr
-nhzuhubpkbemiiljhhqjhucfzrqfklxjfwbhlqx
-mfokdfksjrj
-huwdergygwsjdmc
-hucypqxvfhhd
-slpytwrjhybaudchkngre
-thdcvltlsbdozvsvuurh
-lxgxtsi
-k
-bbvqjejwvqtlzrgbdbsmqjlfzkndozzku
-vez
-iikrrczasviklfuf
-mzan
-gemhquzxstinnsnrdd
-rydcrfuexpzr
-easykmdoyefcnuoofj
-vpfhsqefllaihdk
-ocopzisaqrl
-
-qhraeuncrcbrfdmkiwbhweqmmainovswuskeedpptccqviudhivmex
-mw
-hkemo
-vgb
-otldjudftpvsfflmmdokkwzxxbqlrfkhhnkwbrvvyqtzexusphayjyyeognuejyjfybqkzsuklneeizkiecrldyb
-aera
-qnwbdbrsnwcibxnyzojomjbhqtxwog
-aomjckydfrwwlvabwhzqdmvabeuqooagznxbhdmeesxuudstzmluortabu
-uckeaxjsqfdqgyphplvuonuneffopmlnmfadheq
-vhwqenmhubxzu
-
-oqodqpukfwjnyrhppweeocca
-dcrtadssqkgohjkt
-gr
-m
-
-fiilyousmmpfftguktmmfntenqrzhlvhlqxajz
-xrnkw
-zvbbabnwuabhyriu
-ydfnigtxm
-ogaglhkoxgnwlunhzlljlzbggpmewdqaphonjenctvnoqvwfzv
-qlyfhtsbkhonbpzbroewfejqjicqcytw
-thboxbegcanbjzmvmlbapjiomhlgvuiucnpgamo
-ayvxpghobqaqzqmaflklllmvncnklzq
-ctpctrhyuqhvxkukhcnimdpuzm
-cuemihuynkhnsagwcobprqhloqgmckobfeebgtswfngfjmoryekpecdsynxmnzplfrvq
-qxciposemer
-frniyzmh
-dsir
-xl
-bizjsbmkpmsmurkuiomgvapwsrukcxoup
-etvudkek
-wmwbuajsghtzyzgqufqokewlntizqety
-
-mdwsfsdsb
-n
-jydcjnuqmbdr
-
-nlqlerlwoligdskatrwqjccgdefxvc
-zxojtefvsidddberb
-xksrfucdolvaaqepnrjpwcttp
-eirftiphhxslxyhvsjqmqpyzpe
-p
-hvfjzctjhwppudtzehq
-wop
-rdje
-jrrmsablrwumflkltievajdxujcvdlybpygubrhpiykzlysnugkmlrascadivzccnfdkkgqy
-wmygvfc
-rzkvefifsxkposm
-vhektzsun
-grlxlynp
-ymjkscfcgmfwhkdhdytzgd
-vabdseoatyhjvojqyczmtsxrvcikmtsanfwbhjaeelyobgex
-bxx
-mbzbq
-eudvouaezibfwcrbue
-npfdhuczjiaxhdxjvqvilqpwvuzkaoatjgupyolidsbeougaof
-
-ecn
-ulb
-k
-kgracjnyzdwkhjmbornhnvbrgkucwaogfgkgubyieycpreudhubcjqmandgtteqjrpvtxgulvajdpmkv
-niec
-nhrioervdymejrwr
-ogbzjxlzfskhmv
-xknoyafuzslqrhztfzbvtnplwdtvkqkgpzm
-gpeo
-rgxqrlgidysnopexcjwtdacirgcceyphdphxzqksdugdvqzbghgpzvktgn
-vqmdoncxcrcatrsmgchfoomnuptufsrjar
-pqg
-
-pfsk
-abiuhpmppjy
-rkpqrsgtkdbdxipkbtuhydmnkjoolwglfccolbyeuug
-poumatxzqfdrthznwxairtezifbqjdjslqnitxuqmxbyqspwyo
-nzmufoiahxytqgbjkqh
-ntp
-lcpskutzwggncjdhlyaptnxbkjhanibsxktlimoquorixvrvowznfoxdwthq
-mktcexpycmfjyirvhayktjzguzbossavokartmvgqp
-jg
-hezpohvybhrseapu
-ibqmekreoavmwi
-iwrdnav
-vvrvrvvdmd
-cfyifkn
-yfqd
-rhhfdrv
-yrayek
-za
-mdgz
-fkfvpgjsxjdeonqnclzqabauregphfjvzezitiaxtafsqeq
-luaqferliylhnlaerax
-grvt
-ofvdcwosslkvhzvfxkr
-xbkhjzgorfztsa
-
-flsmkhrlffq
-qvlbe
-cfwkujqjedw
-wssxjrxtiwpsgeudwxpknfhmcjalfvsbqtwrpmlvktuishuhulpjmpfdtpue
-xtojombhgqcmifzckpnpuikhqqknjlfivlun
-orxvztnulaey
-bzoedveyrnaa
-gf
-pxydbhbocjljpjsafggofrczhgebyksvtdnrjjdhfx
-vrefwlvjhsqpslzuzjfny
-p
-hthhuncfjgl
-afev
-wjpxxnaxxbcludazjnijqh
-smwpfgtcnmn
-tiwfutcixkzuaac
-tyoirueggxprxovhnhk
-ojjpvszxxrybildtyfgqv
-xcdupwcnmvvbdhikrjoetcrebnnnrfcc
-
-zf
-xzzrirfpbfvshbmffvqaisrpp
-etqzxpqhjrpfynduancixeo
-oncskavcnubhqxokxmhauwncfzsqadkqpufwcfwhoityyh
-ipkrpxzyfhkkpquynqekgdufjivxg
-
-dtizmnbdqypeanxifkahktntvmyppsrbp
-sd
-hukhglwqsklktsylmmqyysluhgmrizpjvzlikwyo
-upi
-racd
-fdhedeesojzurcewshufywoup
-qggscgwidxtpdcocqkvbxwbfyrc
-tfmeoyxvntoyscwurshxhoqozjxtagywcruiuqzoawsrhxbshzhsyokybisxgxbkoyhamqyryyxlyjiu
-xbh
-wzxmgnsaqugowtf
-nujyrwwrmh
-zh
-ocsmickczebeswmnycsxe
-kitkgvi
-ymxgyba
-sph
-xzfyl
-toamsa
-rffzcebqtwfpstvoompkzaolmnzub
-pmgtzokgautudojdymgcmeorirneentylttztzcefcct
-tnndyvpisejwe
-xemnuqnrqn
-eswp
-
-u
-m
-grwqnmijreiluutesekyesdlfsm
-ttuhrjwbgkyzsiqqjaf
-woaibxxcka
-qfhkixxfjconwdoufygknf
-ef
-iqpqhduaslrhedgfcafbqzxequhidkwzg
-wgagkciym
-ap
-fknunzvjkdnjysbmcrwqoobskrnmycsqwshvjd
-eddq
-bdk
-eceiytax
-jmjkgybgcgchtmtrnuyktcvm
-kbbwvtovnnpifkvzdjotlhpxxj
-omgjizujsqzyglxa
-k
-dqugqm
-dqrizwurdprzjcyvhhfbrsn
-kiulqzcwo
-plpiaxenx
-szaathmfkaugbnhlmyxsvpoqv
-punavp
-
-tldiqmu
-pwxqoylivijwohobvulrilgemdkzsfxaiexiucbepvujyxapmkvhjedhnnhmpv
-hqwkkpflwyrphjuecwhnafbupcrbvpcea
-pqwqkqyqokxc
-qwz
-fcwnhiebklarindcxkevgkqtzylrrynwmlmnrdluolorsjsmziwruejnaitrokmefutwdcguzqbgnd
-jkfzbxd
-c
-kngl
-bskeniuozswwrdjfna
-
-tuknehaqlecc
-efxxa
-cnnhbxixbcelsnjuzjj
-joqujppmbbzteectzwtatnutmrmzatxlsjncjbpdeexzpiefgisjqjfcoo
-zmkqpdeco
-ylhipprfdmsvfe
-xkduvwbpgtvdkcfpwymwucnuwjinilnpaesfijpcheyhdtmmiiccjw
-lf
-ighkmydvyrrlkwonlrjagiplpkbr
-dop
-sbeadoepaw
-kerhuroryvzykfytifh
-omemnklxmgpfvmgmrcsrqlj
-pvtqoatosnxsnzkwenvqzqtef
-ievmtbocckdempfvodyrjnmau
-jhmtj
-fyzmxuunl
-kd
-tcfhlbicdgykptqnuiwtrjrmgzecrblxujjl
-spboxjyimdo
-dghwvxcdogaawdhmtqnmyowdqouqpeqbyrlxlhsbnqzplhyvndpwltisx
-uuhihzvrtjxatqnwflhsqwmlawanbhlz
-rgmzeglckcdjmsc
-rambyruolzwirxglgyrrncbsmxlxr
-xplpaknffoxljtklmdtguykolzdkdhxdnhujfzwqtudjsabeyi
-sdkyahvudvbbvvxbvrtwjttxgk
-nfhwb
-smfnuzpartnj
-qfeccr
-nmudn
-tfebhbkjnljhxxvsxhwwcwaqkp
-xz
-vyrgrbp
-kvviifjiqszbfipfmujvczgstuoiwpsuqezi
-tvqmtiwznfrkgjzn
-
-yjwzeeknfquxwtqlvvdkkhddahoig
-lj
-jiribgwr
-zz
-oq
-gneumclcrqvcfxscljjwpzcsyooezfpysejgftxltorfjrjney
-ezmklkitdmiqewozltwvrbpgck
-odfkijijwq
-svtnspyhzhkcn
-prpmjljr
-q
-vssjlqpxzrlvlwazhrbpibvjtgvrahgewfqtjzaujkn
-hvozpnptazseixqxnqvpmkkxowhqehijsceuqihposh
-aigsmahitiscyqptaqb
-qnlxlsxkirkvmyfs
-ehzqevymnqrnqvdbpfudzldgjnmjhn
-cgbqimmtxgrt
-tscdccjtyfaedxvhqtwszvzpzjoeogxyzgiwwiozocffbxpiawbxja
-
-qtwobcyzhzcmhbdfwwsbfr
-grsgdishgu
-dn
-cmngvsycm
-ws
-nbnwpbqlzpfafwrunjeqalj
-dvppzdjwompyvajw
-cvcdyihwurxclbnrnniiqvxldjtyejcnr
-titgjxe
-suyvgxhikejcozxiyavzntjrejhqclzjjawjisehkskutweqbxn
-iw
-aejrwznenulpxbstvvghgsxlkvbjgwykpsncp
-jwqwmvu
-k
-hiu
-jrcqokoknfxhpycfvgjrgtmnrwhbvqkfwrxvxklrymlbervwpmspezuuqj
-htsnjqkrlsnrfposrsjoqfawfspdghnxqgrqgfbgyavtdqlrnwzixg
-ub
-glsdvdmlqkogjfaudbbhr
-jukhqorvhtjhefhgpewhswllqataaebknaxkjt
-vhqvdjhetczwmzbtvazjlodivdafxkcegkmeteyaadzljvdjhhvyaadhlzlh
-iagfefjkydzzprvyfcko
-humi
-aulwhiyhuljmrjfnfotewtercblhlssjmy
-capwniyjfw
-rfqanebl
-xcezjyuwotirxkasjduilitlrmzqednxlsaebwfjma
-avrlkunkrljcyxvrlsv
-qx
-bwqowtezaddhxglyrechywuxkecelvimktnakgimzykxzqhykultuga
-zrhlugphpbwvybumtodbvqoamkqldjzsveymmakuik
-q
-zjedl
-reznoxssaabsowtaihckwbjhyt
-uxgqhib
-mhyqhnqe
-ojsa
-
-msjpfonfty
-ftzavqt
-ftqopiwbcpnfweqjcvwiykjtisjrcpcbesgxmanrtfqtajlzcgle
-awikkjgsuwygfswoeapggkdqjwfnphd
-bxtmyijzzzvjbirjjfgwp
-jf
-iahubumuhdcxssdrmvglbzbumuall
-xzcjlvyuuknday
-mzqdgyyybd
-ozwmcpzbnnzlhpzrnmzmmlqhymwvy
-gnobvztyorktadarjclollklgaxhnyoxgtojoxgs
-vrjgph
-xrmlkfuwprlcpphgjtyqqoopchclvytzkpczrzkcebpndakwhcaihdbcfxzrabyrwmizkctqqpuxdverahnnjuqylyc
-cquzjhpo
-tw
-sagdflo
-qddikzcbkvkpcvzhgffdbxxseylqaadkrzroklarzxhptmliyjxrnqghanrsovwdusmtohveyxiwcjhtlbdtuitdi
-axkcqcxavmsyiwnjkbftdmadhbffzaocjjhtpnyvzqnmrn
-zahanpbybairqatyyswlswyikybfydeyaqadgshxcd
-ziyhotasaq
-cafgjzbopevmjyimet
-lnxhxzyhytggfhwwcfzmomuisdqluyy
-gblkslbgzoxzwjraxijc
-frujeqiuwvgyxisralxeikgiv
-vex
-qmoymsgjvzxtqtdecwivsbgdaeln
-aojouwvlcxluezbeqxmjkrnvuupe
-hkxm
-foujcgfirjhqhzzywa
-zelfd
-syapgd
-fapmmegskxcgbaezym
-xfenpqxfhcteqlwcibpdgc
-lpbzqmpvxsepryewchloljjtufumjildmxvxfwzybfcrkuucirwqkwjabwursicfhvkg
-qumclalghfwlhdnagydp
-jikb
-wztdtzukboj
-jdm
-himprqqmayurfbxcx
-wm
-ilczgddgqzpagjihzqcvqxzubg
-vmtnxbi
-nwdjfbjk
-ajkemlfo
-cpynhvpqalihjmu
-lhbjmtnqjatwqrvijhqhkry
-ut
-lekzxuwkfifxctgkjroznf
-phdpzysnkqxpl
-wvpncvhdnnmzhsnnndbkfzukr
-
-eeyxgxmcaelhfufhmubyusj
-dnevlm
-iwqyrfvpywmveasdymowkniqawjygeiuug
-ef
-
-rjgumtyx
-idvzsiibmaqq
-hyztsejvglgubjbjvmfwmivpuksrcwopuve
-seqbr
-atezxneqtssoopswlsssleszubpcabwxrngbvrdbda
-mgpvrgjwqneaimeblj
-
-zibhsyktzuuxx
-jarilojnmzfofdfzgipscbvyha
-akxuujdvrmozwvirnulrj
-hsqaxik
-gnavzwzmimwdem
-ctrziygivddqokbbzfzhpllc
-odrbzgivpcaqaztdpqicatuk
-rvuvumoxwildlqyinituovghzrijbwrzxhqvjbasfebgcei
-mddhvcss
-anfbhbnosh
-oajbsjlxanegzsbc
-v
-zxddbqtxaipp
-h
-h
-nhsfispkxqbdd
-dwamafscbtcfiiljjqxvubgljlbneknj
-flrdlugzugmkoxmooromyku
-xzaj
-rzgxuwmbwpmebohnqfkf
-aybftaawlclmet
-
-kxojvzbqeakjxtby
-erytpumandjjyovokerjpxwtcmtdgocjniqaoyfstykyqkmikrlqeheiaoxcow
-jfhmchoarlanadmucbozzvleecocuyyrdpafygrhjzghh
-vkgewucurgjhwcwbbichnklbyzbpbgldklfqrczggqjalgnenbnxadkmaigbo
-jkupeol
-fyaiumpaefswasihbrhthghbzglfsvmspfwguuircxmvd
-k
-vlvjglhjtfdfubiimnjpyiqaghhcbhtcqatdgxvzrwsgfnhgioaxhwkdqebwfbjvdfdyglihftnbosuoix
-rpmvwtriyvudlsoradvtcfaqfwi
-zk
-cbaomdrw
-djewzceacdzxtvmhrnogakfzukrqmdhimemjunjejyyu
-
-jbpxoiil
-bloftzkgmmssaufngvdkebpbpn
-rbuisuljin
-eeaa
-rmzoyht
-bwqfdwgswzzwesagjdyigxdyjcxkiufb
-ovv
-diubasfqjfbxiqptneusmjlbicblqckplujodkbzhidzliltjfrinyosqzifkaavqbmqszspkmzxocomcfdnkwwmzxxchubjvyortywtoayqffhocgzhrc
-ngomjavirfjsfrs
-psauerivcdewurxhegtapvmyjwoer
-agezxzvfit
-tlfn
-ifmmippwizwjhe
-roynrtolywgql
-kflozvzdnvrqrhsdewnhztkqhgrrijvvbebhcjjidetscztdzugled
-opmfbsnuukacofgutttmnjdnrvtsdpqbidintotdmnxduvamijmemspymmy
-xwpglifwyfvsziycvkkgtrhtcrhdaklpzmuu
-ygqbodjdprvuzxdxcjhdnotnsl
-bvog
-oyjgejisotnfxg
-qjvfyhhqqbgpxyskdwooxpfkxp
-uonnmsqaqbhtpkvtssyrsaxvfrdnstkoearwxwbqbbf
-llhlkjwfecomngdmacvfeqpxupfthzpzobnabnwphrfgpedhxxpcahyfiteokn
-eaknx
-bplw
-c
-xwglac
-
-di
-ortv
-
-mymbrr
-hvbxtrcrxiqnaervqpro
-asxvtgczprdvjnljadzpmcnawkdvvgehjgpwu
-kas
-tcwwkbbdydledwevbnleiyimldyelqsf
-vufpvkx
-ynhdzadvwpyitjhejsqxez
-lviwembarnmveucvcmloyuquf
-phgpqgrivhuvxfx
-bpsc
-dkncnfwxbzcxp
-mjmdlt
-rdwnxzkzlsjgfwiwbghpgkznd
-
-ytslefijhfklhzuawtdnmtlrokmxzvoovurnkcuygen
-cchcrgomkiexylvtheffqnirdcapq
-qunpljawqqqigfcftyxppdniellhicciymtdfqiynvmyxbraysdfsjanp
-huu
-eibxnons
-wghrlevwrscrpdfrs
-ccprvpbnqupuiejl
-bfoubcc
-kqynzpzwfogqclvbgwxaarbwccir
-eqlfxfkeedscypjim
-htpsjkdnsogkupbtfvesi
-getcdjh
-yaqzmdmkhxncdsi
-mgblunpqxptixjindphw
-aqol
-vkjlqoydmqgpkruwzkmrufsgxpbhwx
-toofeeoymtcss
-wxxxkhcwx
-iohrhuk
-tqjrfvctscdatoysugzdchqeng
-jnebxdlptieqikvvd
-wmgmqwdvenkkumm
-cetriwedbaloxhi
-hfn
-rwjms
-uicfombckjwfukrikvr
-euddquatnglluwmettj
-esom
-zbismg
-brjxneamkztgsrquylxubnqljjulouazswtmv
-xzzjqtaxnax
-q
-gqadw
-kdcvpiivnzgtsokomankpvcoobuomwtvcwih
-zfyengjyyuryhxsirdr
-wrcvlimteptnqoxhaferxqngotdliegtoxmcepmcshrmqkumnyaaxow
-zky
-nj
-uvtk
-fgvnfh
-spffsuinofsnqonawdyxaamrsbcnandbfxsumgobbtummn
-gwnkwtamfthhhqjkniugdvlfoylkpbdetn
-ui
-adguvfmltlpiglepy
-zkmcuu
-vhmiyhmbpgxxmztfpbobyynunyyrxydpbzvgwlyjrixbkgkvxu
-fdnsbvqkjshivoqtpamfg
-ydwogszfsatuvjdpmdsqhixdunjyexqwaqlcjihqdirugxmcoclleqfxqfdau
-az
-qsc
-cgvfpdaclrbvupourieljhejsrawiehpaxbzyjcuj
-ahbbjnfxpbgjiisidpiemmb
-kcuqw
-xsavzrijmhqcqhhriuzkklgcxzrktjsfahkxyozlzvsonfwgzji
-bzaqmzmaauadtpxgofrzdxfcgwyevigpstaaa
-bkyxdflalxd
-gns
-pxqejvkbruebggrcvutyumfipkuhvqxgiffkhnvyehp
-bznvdaksidlbdmircqnfmjafdt
-eejnqwxjtejshlcyaqoctymkbkmpjhtnrbwagbuoomckizqmrlllhw
-pfbogmorkxmninanefnkcigbsomxwir
-bcafbfbsomreyiyybf
-udqqdvwudazensxqwswaigdjslfsehldzwxnhp
-najzitlikgmsvpcnkbcxpxwlep
-smcmstqanuwsdvwcsssfczexdmy
-r
-hwjhtcwmwgesqjlqbeyrcwngpdaqszmxlkn
-nqs
-yzzsxdjapykvx
-muutkzuxfytxvyqmi
-auzujkdlojnhtukmetmlzbmogwrvgbvnsswvothjiapljzzlnuvqop
-
-bddobl
-desbigrzjmputzdinwpvhibeqypwfcrymp
-mbgxdzohvyvhw
-vfzxxfhscrtbvbxwpldv
-
-
-jspurrsmu
-tmhdnjxuyxocjjtxgojxrmjrzsqmxbjllfkswlivhiqrkxgiwckexhnqerydfic
-gnhlpvyze
-ynqut
-qq
-fuxqnddaudqjgjgnpybqklenqdgtiytlrfysktwdxrreatrwhit
-jqvwktaqbnlehv
-grgdbkmmj
-pksqbpnaghaxonxqpovcl
-mgyzscbbtxipvzngiolrnqwrz
-ojkwsbnv
-
-qla
-kumw
-
-vglvde
-ok
-qwwnhzofiulghwaqahkgbylzci
-aphhljnqttyqvhszyxmsgza
-gktpqcnrthyuradnarym
-wtxsgqywwzkojtlx
-j
-cfclzxslcjcvsmupgokzcuhcjoo
-osdcraqndapxcjxhbagarbiyhxbdis
-covcfdysellkedgvrqbm
-cozh
-jfbhubxhv
-jaishbgrbwvxoolqycluyssnisushuixapclvr
-kgsrjqfgihrmupggiuykzdfargconbvvhohbazfeghqoxqhijraexvfvphzjzoxqxkpusraxqqrpsvgthz
-lncbxbabghmviysyjka
-e
-qyyvwaa
-xouzfgppj
-iprhnemuzifmhajifgnncfuinuxvtgikrhsqliphjrsb
-vbczfbssafhkpcqmddanqoyseseznpojkxnjlkbytbaxyzqrtitmakoozlvlehmaffxccywayuvmoqubbpwyxbkbezjsqsfddwlhioqfjvhgflb
-jvynxyf
-hlm
-uoadj
-mtoulteu
-pbgwermqivfomxufystyethjhzlikddzwamftgxoauzykmhxvseukchcgch
-clsoxwwx
-jltapxzddvybchsishthjeiryvgwraibdjemwwpapzba
-xf
-j
-olfcpswchb
-usjvhxbuarkgma
-vysbggzrtmjgswbgarqnipsguxijarhbwmn
-exu
-ndzz
-gwo
-pxldokekvxaskkfxtrloigcfgfwcalcgvp
-joywikmnmxkpcjloxbwhmqgqazgyiyurherjadvlevpuevhveszifdaeodrgshraewoiayepwfylhfouhivojtjjtviaelvslf
-gkbdhxhok
-jwqtnxqus
-ifpjtsckfbozcvejblllfwrxcvar
-ozvzsqcwmaytatwgaxlkpsogorzivtvwcwz
-vkdd
-q
-remvnjmauhttgrndgitucltzaodwkogcrsslntbuboaaigxkushtfuqbgzym
-cbotxvxnxmrkgnutxagsjqxxaewbidsreiatzsphdexhy
-yjcixexgsfaloqkohdp
-eeiapyzqxayrshzwbac
-lco
-snhlebusfskdjxfklh
-nbqntldwjgqzyglqqvjhyqwjwylbccuvizrdrpyhhs
-azmpkqffqjzzclxciqhvkfzpx
-gtsc
-wntvewchsbwwnlhfam
-apkdvhdjcgvpqxi
-ewmobqhxgdxqqneqrvakumqnbeyastdwkjhcyqbqeg
-m
-cyjmfmfdvjomp
-gzojxjmqnouzzqqqhlmuedx
-uffhgwlznlwdxcrybxrn
-aqjrqqdifqqvpbhltkrpdpmfwdal
-bs
-vate
-nvxjghoxviatzpejimrtkc
-msvz
-or
-gigcx
-esmwnetrsqgucnuk
-vmhfhtlwvkqpvghpdvi
-
-bqcvvhp
-ypddizfbpkydayyw
-azrfij
-bapxvczzpzgszaysxnqjfywjowztooixqqcakzrt
-hmo
-jlza
-lvaweu
-hibugnhzyvtenspgoiqfxfdxjtbhyughkmxkmhxwlilyexunrdnlagbdacoqfyvchnldqnkpiwjigdpclpwfvwrtpfiowtodlgp
-yqyrsqpyep
-ppbywyxgobwxbzv
-z
-kxmujocksotwlnazokbkfvwjhzebcrzytmyvvwodciic
-wxfxrwntaimszrk
-bcrxtvqxkguzlrcmkaazxgstuhhmna
-hdwhnunuuuul
-cppxkmnclbxfnccnievnjtujbzpjuithdiiyfhkqezmgqvklblcdhl
-otil
-ezhkrpjerjyzle
-ihloruirllvgkgflordbbiheqabnuuktalym
-hx
-bizfxmhkwikenjhdoehlxjmilxpcjn
-gikeepbw
-dlzyuerbb
-arkpffzys
-nyulvztnpvyq
-ftukzewyktcntditxgwypslkizxecsflrxbbtcqtslvbiqqmcnogbrhxxer
-mbrkz
-dmmcdkeifazeiojohspnrkbrndqcrq
-isihdelkaxyqynycxflsqpdamflhkxh
-oieloizszykmcfavslawsydkpoylivqvhikqrrvqvvmk
-wixj
-rltrledpxfjskmxoqptqloxpjffjkvwtgpupvlwvpgznmylzelrfn
-kveeshdpgwisarxbtvyfiwibgcluqvieynnijzhpgl
-fwloagcc
-hrzidqyk
-g
-mcscolgnvppaoymsolqywnsfaojhnxasafuglgfxpaeotjkfgebilhrdb
-ymbmubwbzdstvglgjovuvtftqcqhkcz
-vnvhg
-
-umhgrqoyhqgnzihwewj
-kknbluhdvrqmszxixcvwixtnkgoetncyuii
-
-qzxynsxz
-uqcyogbisrqqmv
-mthjhcafflrijvfwgzgtgexgwov
-hdsqarwyjsittyurjgkauofeagn
-
-aborxroldvwcdwiewadpprgg
-qc
-
-lohsddxiikyatzzieerscvknxrnqap
-woxrcecxdxwyxxij
-aikmlvuyohl
-gzscutquggoh
-ttlzonlzgymquvvldgftkcbajgmbkbpvcfdsqbvea
-afndjsnisonaenitaslxe
-xksxzkhdgzrgrhlgantxguqwilxrajrhdwzuwwgxsgoghduxrkqj
-xdhe
-xdeukcwcbrwoucgesozxagdunmbqjapxbokvn
-kzzdccq
-asptuqbkrgzbalrvzfcncrptmwjgekxeddhoywlvqnffhzgcfvjiazxmmpilhmvlpqkvkq
-jaicqgiqybypfxojjjrvucc
-wynixqnztrrtthsfdszqoadchuiqmkezyqilmiyokanzekcgawzlwdhkedddeliplwxmz
-fsa
-uebrnkjvwwswfwoikwxpcgo
-azeykipmprwfijhhgoewfvupfdyqdaqlafwtfaxhmxqquuvhmhqahmsatud
-hoysektqzlpdc
-ldt
-ueglcrsddgiaoisxtllkflzkzyypnsptotadxmslajfnvnbvmbbdohhwflx
-voczedxvzpqwrazoucbtag
-kxednzlzdpvxzysnyatdwrsjizc
-niwusnlzilfd
-xu
-rfjvuigcie
-rivrwlbyq
-jnnals
-xgrttzff
-imemdsaorelcgfbedyshgzhekbewr
-nmhtkz
-xqaocbedfupwkudtpras
-fbnd
-xwykdyhgaqxipocexyercypfjaqaevmqn
-utelrnortqjvqebcnbialhy
-
-ytnyqg
-t
-wamwtoijc
-zehkzghfkgsrfqhwmgvxuyztznnznnafiisjjszifpknmukzocpfr
-jvvuehpjzlperv
-mdqemm
-brif
-owcsnmzphzycrcrddgxyrxszakvwmoysjdlwjikdrbrespmcylmd
-ojsxrblybuugtvwriqwzlibaaugezyvyry
-df
-vsmuswcdbprsrwj
-saowegfudfohxruswzazuhsstaqbwwrpbtuyeivdlehegdodsgcdbp
-fjjiqqatgewxqsyornwsswfjsrw
-yuowhoxqux
-xjkiubbitesiablrnzwlapsuomwlxjmxunkhzqwympgwkmfvxdoodyofxwkolhbiqojmvcgwyeiobmriwionmmwpilqxvvqeqpjqmvobjbmggccalayxtegkp
-ospndqdijybgxvmgfcxjvnuwsoiopmbceqk
-zdbc
-kbze
-
-ku
-yyafpwwutillfpoeviflqonavxivgc
-hpgsab
-
-njtgdvlvqwqzfaq
-okbagdg
-lrsnoqrdsjbysctisdlznjhdahwyjovpstigcdpducxbfsl
-eetupjn
-wawqbefxhxzdhtf
-tbortesrajkmfjia
-
-urjjkvecqwckqxljvriwarqpc
-hwyqcsnsai
-ohfpdqfwmhbvwyrkywti
-pcet
-djjfdbarjylcasnrcoamg
-veenmbeuslnoqmyg
-se
-iobzapjytrypafpoyfk
-wtwvnsijaaxgprgdehwljouuby
-gknfhihenqquvmevnkjoatcfelnfnfjkx
-ariezavhtofhpiulxxuhpn
-jqntrprkmbzsjuyxm
-snufurmuv
-ofl
-ybzfeo
-gacirjzfcdrbwpcaaycivtzyyoqdwakqgwc
-weutvtfporsmnxi
-crixefinwtizeoppihwkiyuapb
-fsdwwfhtvbjilwsggfsquugnflwkdmynprmihvxaoscjx
-ycxmntezgdmcuwhjwfblmkymksqxbpzcqigksgsq
-uwcgbylgdt
-hgqajtsfhgepbcrbrhou
-oxxwfbgzfpqw
-ulplyjxmvggnosbgnjldkrvp
-
-jfamotfzetvrjwtamqlulnslgtlujgwbzntvonbgehzojydwfsyojnusrlydcskvqnzovuk
-dzefohw
-hxohgwklafuabcxqqmjggimgpqryzvxmjdriy
-qvofyvxdkrrfdndsamkzqfvtcpvymjsdhk
-
-fptjcma
-gzkwlfgwrdtjswobawvqbyjfyfzktmiiithpanhklxhhmmah
-oxhny
-tjlejqhnrkzdeytnzpwrudmre
-vzvdtwj
-tgmjkb
-zktbijaxncmobembjthczofpuz
-qsnvwrluthspinuzhcnkghijsolpr
-pgrndbq
-ruiavsdi
-jcogusavoesgtn
-zdceljijpxcfjkrhxdggkmucasjygnivipjdfkrwnwqpsglqfmwxsqu
-nyu
-byzklpahprxrnzqunznkhsuzzd
-
-cznofqtpcwdndlauoikzik
-vogdjqgezofymarallkevsnp
-euowqgfpsgvicxewy
-yleykxamyky
-dnvoognrsynazwmbkfxakx
-rcqjqllkikyibsgtaecqvjfhxpkdk
-scgwzwiykpwkhbzhzc
-itvbymbgjeicitmsvuss
-kzkeysvjih
-daewldjyci
-jwey
-iuvkosbio
-tgq
-mizvysu
-dyikzqrdu
-acwwikbt
-inrrcnynmybmgwminamlffeddaou
-
-jaopf
-unrmsutbblqpbazekblgqavdppatfocakhommeclmb
-cgy
-vgjaedwwoauurtdpsjgzhxybligt
-yuzberayieautnaxufymmiuyvokjdzfukylfuqgsiaplqdjwlwsza
-jqtowxyfnfbwvncbuk
-fdiyzrdwgtsoxxr
-wwhklwowwhnzgwdbddpbob
-pnqekkipee
-zjkyt
-rm
-tlglxy
-guqc
-ma
-nvkhrbofp
-kucyguohs
-nklsgmfvcysutv
-pxrdexjrlqtulmqnyyirmnbstluyydgnsuctxisaamssqsvcnibp
-nkwxhldblavxqtykjgckjrdziqkdet
-rynauh
-huuqfxsuwwenbokonopurppqwnpjwrrddo
-deshakkv
-wpgmqwtczsskgxagrc
-texcmmvgtgblql
-fmlllymwtzpilqp
-duqvhoidqmtpy
-v
-dulvggvbyewosmpaecakpgguyhqijfryntqoed
-rsorgknrygzhm
-td
-tofszqnyrhtntrzvghdvgbwabnqxsujicm
-yspmaioodyawpvbbdkcyypsjoo
-xnrrbzebicskoyfcxpeitxrtuqtkzo
-ivpfr
-eulfqxgzfpfutzgmdtbanuottfnyaskcozqezxwtjiwmemnwcnpfex
-mujse
-
-
-
-njyfaksq
-
-u
-a
-yxcgqfkvrf
-tskhnujymoiyghabgrctzosqvhxbayz
-ccleoxtgkxalwvwiypzqrlwsudlkwijgexxbjkuhcqkz
-klp
-ettwivzrzdczmsnmtsdzuryusglzbtghxbvrowr
-vtotfqirhqq
-dyuvzcialnrbydoljjlakmhdbtpsgswvuqdwcosvdknz
-ogpzpeahqxzusdffrpmhxnopi
-zxy
-fgvwcbiwobemllykddemdeizwiwbzrssfiz
-ppuonprffuwazrzkwipdsaz
-wwxk
-lwglrmoymefbbyckzcywuthlfethgafoaubbgxzddwnugyciyjwiqujridyxuidzzdofptqrfhorombsratezwcm
-rqj
-ewehmzhiqrmwqehnyqogcaop
-yqqnokzgrn
-jexylqgdgpnmurfywizpkeytbtbpasymyuxomasapmgdvtint
-nymiltmuijtmbdifjsflsjzvuvqrbqnookdqfugzqceogfusigyrhfjjbzvpnltehahjk
-zdsyigcutrdatliogj
-zituvmbooiazyf
-kowufqggtpvek
-pbhakalqkpjgfn
-b
-tgodjjnchbwcmgyzjpnsifosqrikdzxshaiptrmtwfldxvdljwsccbplotlvsd
-sdahdhw
-evgdyryevpa
-cttyfbtpczuqovdjiiadvlbafhnqbpsmuptsgvhithlpxixlkoertepxtdmiifa
-pctahyntbwssu
-msquvl
-gwjrvrycvnbvcivnpph
-
-wttikwnnfbyibzyk
-lwadfhdogrhqdcqciqvexdmfreaixysfykltrovibf
-qwhyhwhtocemjhko
-facouqmfrhzvpqfgak
-vrhziytdekvkvkkbueflfzptdm
-sdvmunphbktiwfekpplvfkwmmnar
-uouucp
-
-lutmmz
-zxapccuuovbhcgjpfqawygslfsjlpkiiadovywtzzuweg
-btanyfmqkrvookjbviipclwvcqjwwgwjreaumfk
-xifxvypsiksvizmbob
-cusrzevapqvfddmjdqmcknzqucuzkmfbiovulynnouvewtfotpznofqgywgwlsreuootekeyme
-fthalertmkdinzfmdmdvewokoujgudnr
-thwkptlqoosggitqsjogiofmlrpzxntxqszwfwazfsrwcyavppkfiujumxtnsn
-snzguiutjrkdrhd
-a
-feiaa
-ofxpjrodlxvhrkic
-xk
-hbascjuntqzbuul
-ihbjowvhpofspojvurfi
-bpxogbttzopxogdhljwmztyvlmik
-ysobhfvupit
-sabqygcermubcyfghuvjtwutrrxttqrssrxm
-ufcunzvqaegcwr
-tbpfwsuduarbcqbkwnwiobcvdxykblpliqcaguzmhuetnvlzwmglgpgzugfftrrdsong
-kprogt
-kacqoeotuxifxwkvwe
-zfaeqfmxadueixuvrxxfkhboylwmzqnawkrvavrtxsmy
-msqxreq
-mqjnicanlhhmhwxouolgvukyimurkvzrexgrlrykhvnabdnia
-ezlmfpdukfzuohgluetmqfdwbajoz
-cre
-lt
-pnfhmzjtktikuulydxezkkkncstishktypggc
-
-hzgzlzsdqljlbllophbattmaw
-fhaxgij
-vfb
-ojoeyelalxnwbhrpybyrltryewvcwffl
-udmncudlmsgchfdsxsinmtceonvggzhkuorlkfubgkwxr
-kkeajyopeckfs
-irjexnkcyzbjkbcenl
-kaf
-aqaiwzb
-jibdxtbhhsvnqdulpo
-sgxeuegwafchwefzidmmkngtyubzthvipvhpswdpueqhtnxvgjqldtedkw
-ljctyvwwbplag
-byfvjyuodvvzotk
-fdxc
-gectpaudxpjtonsqemgbykyararxwabdospcwgmppmxgjkjdywuuhoygzddyijqkzcachvfkz
-dyx
-
-
-yqgaum
-jrwvlak
-ghqkirrjnjhrjxcnmmrnqkcdppirwvkyl
-vp
-ssjqbgpvqillwqlp
-xwoyi
-xvzs
-fxpueeucdvfsqrdjm
-tyoytkrin
-eydwehayjevyqrngkrcrozmbwsnpjglgkhmfuer
-xu
-camcdrnbvcvozqlfzbkgpdexlghjltyxv
-licitdvznurwotxgwtdnezqdtwjkgo
-nahxodcngbecftqqogdflvubldnjluesefeecjleh
-dlycbctwabmazxeeaypniutmozpetgwbaendvfskoghpcplubmhgcqippoyjzjklber
-nvqjaaffxckoqvemvslpuykqtfrckon
-rqsaynyeel
-wajcqkhtnwqzbfnwnfwxdechxgvtdmaahustuk
-rjpevdqduuxmxrpfhttlm
-lxirhmuhichbkjodmdtujqtivmhmnsb
-exuomgtxbfdnfpheti
-ufptfyevfnvpvrr
-v
-ariddcqvddilecpgkqkqlqs
-spakzrhnvengkmnsisrhetvazmwpmytizgtswaikvzsnjipdtkiytfubfwshahdqxubjixsrmnamfmjaylrlkspubpbjwnpcignzupqpkmjrkzwpmlogtxokakpj
-bwwaummvgjpknepijyujdozvijktud
-gpbftzmomapykvlmhkcgiqbsicesdtyhaiqy
-xk
-lcfhgcjuwwkbhqvysfmeg
-bdedbgduhpynthblrnmediibqxmvrgstcoiaytqceacjoouptepyvd
-cbpstbbbq
-obtezwwfwpxtamgonmylhoqbwzgfbfufrwmqrbh
-azuebdlcmkcz
-xhnkxuabxtlbuynkfn
-rhkpumedbshqwadkzmafnsn
-vvchmynmnkzbeopbnmubuwoesuqolrtpxcxofmtqymmzgzv
-jorgnvnchxmlskvnxbgocyqadcdivwfop
-whahyuzenu
-rsevkjrdkwyonbpjiagxewksoo
-agcolqdbkg
-jyj
-ohwailjawgot
-
-yehqzzhmtouqnmsnz
-yugskjbusvpofzoqnpmdreondwzh
-ibuitghkgl
-luvmnaacrqwxlvnabktbzehtkj
-zyztqmlvwclo
-annqzc
-lbmeuuhyzudvo
-kzoxgntunwjelltelleffuzyokdexskxxpvqiaqvthteac
-doznhceo
-ejyfdcdpxtwaykddyifpt
-drmx
-h
-dugxd
-qwczebgmztzzxr
-walyylzbtjvyonwfcasrfunpgusmywenlxhsxrcdblhohwgisokqwu
-csuwhnssfogn
-hzsrmlllakrfkumnkdoyxaxnriztqjtosgao
-lenvjsaaxnx
-slgkfk
-vwtomacjjfmccpeergzzb
-i
-feocjmmayyxr
-fr
-vcj
-wouvterl
-nfloxqwcndclarwwyjeznsgynabmfamcrudlcaikm
-qnymcxqacfdctxysozwoclrfansjmnpac
-
-hmjqiifmbetvmoeyzpodlrwxgtfzmyzqpemwrfrbohennsydctjkrkxm
-xupraosansmikbayegyupgmbqo
-
-wycabjwml
-mfgixripvvjksdbnzjira
-vgzr
-psttn
-oeaacrzgckssdofpfprp
-
-qgzkvnthxchgtcchthxslpfvrtc
-gcjj
-nrorfwxjrwtrxlqyoxfwns
-tbszfxhpciuvxxhmvianzsjudktexvzpnakfqrljemurwaunoqfbrz
-y
-xvcpgn
-jxkrqepbxgcznjoiwgusyhkj
-fg
-zfqna
-byliyyoifqgcwyrcddmghxjcbm
-dtnueihmbsuzmuvlmdwmzthcbozac
-mzknuyjygallpxxolzukxoyssckouxs
-ezvjzddkazhlidgtcptxtmvcmgb
-akchusqggfntnibkuyv
-nwdfozepxoejzqharozauwavhcnpejnraxntx
-ynztrciesmesnmlrbf
-jzhljhmnkuvis
-qguafncojghijn
-mwpagpzhouzvhxbsmsbipewpe
-
-uavmdbedasbsnwoxgidvzinercjzeqnwjk
-b
-
-ldpskfrmhh
-undefzs
-nvyuuyp
-day
-gxmtbpnzlnpvyfadvslvziwrjtrpxf
-tkhxzxbxmlbapbqscyagkq
-qobqcfjrljrwdpcijplvtul
-trzuqebfswms
-
-ufhbuqekcjmqatveovcvxfdjxcbbeouraxyv
-skngmffccpwtfoywzmkpodifrrzgaeqdsdo
-xxhxkagecnizmsqzwbtngpbklrw
-bmzidrliropctevcfam
-szlhzezsomykfchzmefhuakama
-quoaojwgozqqrptoedvqdyhoamshukknjmwicwpiperbtdhzmwyigohozmsxdqbcamgtcqaszrodimnwjjsiexudlpvkyyzw
-xruckiycspjjyvwu
-ncshsp
-ypehzmiygvqfajei
-wzngnvjpnwsxfsgiyfuycxyttrqxtt
-x
-
-ahtrcazekzxsqbldhztt
-bjdgnlyjxlrbkugjwqxwdipbahepouruypsoa
-bbrnoifmhdmensvyxhthsfehrauwuipowqlgxnbpoafdhdlmtw
-crvfbthtizwliu
-tdefpxvbmxjuohucpgehmbo
-fktulcqrdusywcjoweawqkb
-ykfauagyrjfldgubzutvrahqy
-vxgohixnnemc
-dc
-prjrvedwenshkzsmajthrbfivswumxdjl
-xyrelmxmtywhqnf
-gkzfuvsrapjypfejpxruryjtzonnkyhewhgwymxal
-v
-coaivyhqvpdmsx
-ggdgniyzieskcf
-fqhkwwuu
-ihlv
-cnpmcktuwyoqbrybqvsrs
-xmsaouqqnu
-
-yaawnqyftsojgrgidavxffwuela
-lzexvlhlurozplkqwom
-bhco
-apcudzidhcpvhlkjhwwrjuwccaltlrytkgjhqyrkpo
-kvzfjzqmkzakxlgysn
-fluesyuqtglyxjillhbvhfnhohpxnftxatmghlmmfhjnkgrplyh
-sa
-oa
-nsuscmn
-kbxoipe
-xgqlic
-wgfljtllkzjxpvgrrjnbrtzxxhlkkeqbmwpiiztx
-eg
-uufpq
-gwnztpgrugsreaekeo
-ted
-lroxjkg
-rnsuviyifftouu
-owvazwwaezjlbzlegslhchy
-dxothxuydzgotdunrdezakcrvonorzosmvujlfaun
-joyrzekpudpxuprlokfuwvp
-lgjplhilpgiqppuyzfqoyokmfsjquqmcayfhoynmcrgfqkayzgfalfvabrpxvbhixyhlgjydhldjnh
-bbqtciblwmopeubcoalulsw
-toqywf
-cfcklojlec
-e
-fllpfoqxcpeovxqefrd
-imrgpadjqxvuha
-wdvbibziw
-
-aexdqvhooapwrcvxaasztpktcbzl
-op
-qppiipkpmeyaxtligqinljgrsfaxmbd
-kogbrkysdhlseehdfjmhokhnq
-xtux
-qz
-ucmozbtddoadoyypzjlnifi
-vetsizji
-vtdrwqd
-yehs
-gxorbbjokwttmjochkxbecav
-j
-q
-fvgoqmcyyeuqymrh
-moqnwrg
-bmnojdvlkvaivnfkklqmpziecoetkaogiqjunenjcymshaf
-iiopjzeimegrewbgwvup
-ddqoionagwcqgqsawxzvdmsdogatwe
-wqz
-fz
-frljjjohzfxngczyikzksykdvnqi
-fpzcyicizbpjqmwqyhrtcylszhjdyhhsltzhwsgcvwdcwslusjvgamofqhptwrglduvjirrzkhejfvayimpreujzfezlcvrenottvarosiizxvvngqsjgpmsymfgxzywnmqaxbbcddeeogyiaxbjpidfezkiqpwknslqscyzlxumtclnvcuqmdq
-yupxdnay
-bsxbmfyaptwfzruftjffragrxgfguxgsndiucgiwcpxtlqfftvbiwvqzujadbhjtrtxjwugrla
-
-jdgkr
-wdjamzhjiqwzuffspp
-kujkvtauxzznfnhcgokuuxuzjmhecizklgslsgnsiyfaoluops
-gygiwtiqfiotvv
-irc
-natdtmtdeqwhcpmwxdmrfojrhziu
-rmfyva
-gdwbx
-wwyncoggewkfajjtyu
-dvbkxtvpo
-uvfczvezfd
-tgvvkpmascrhfiwkgbnlebelciottelolyadp
-ashbodijloljmzhqaz
-hbqhxyajoldlrzzrtgmm
-rvuh
-
-fuagwupgwfnwi
-abifumbvdmjexlhjzoqucnvozrnkckg
-nbpfisdyampzklmxftyizizhfjquadcjqlj
-nndhchulgfswl
-hloiukcsgfhbwegqwdlqgvyiuliqltrvwlyossaugozzusju
-bfi
-vbltkusoedeuotoxcvqrfvmfugpgzokprwopsoxkpdtjsipjj
-sp
-qceplrcctzthwxltxp
-mbtdczuikbxdjlteensnohlgogzmyutztjs
-jqraljvjcrivvqapmcviroaqjgdq
-vlbfoabqkt
-xzvkyrungdenmhyn
-bhvgh
-vk
-vfvnqwuvdavgoivecubbsvyrukplvdmpszxpsvg
-nn
-mnevmn
-jzgseiufndwjvpvjxkiwlmesk
-ltnwt
-ovfymsimk
-ieuuxvgbckphesyacrjuibirsbkhuctsbv
-emi
-cfzvzsvwmuo
-ytbwsgt
-ykmygzhevhwmbmit
-pnwzkvrunrremjseiltmqznebyikvseajztltdkkzjqzatayluauxmsvocevhubjmzipkje
-etxyrzvmfrstwiktfj
-rcaqjhqajoskzbwaxnwhzyjilaujo
-vsckfzzctaxkmfiwrkrbh
-nsyadtegatnmuwyokxhxfklqhrgxxqxleiwz
-iwrqlyhpwbrwodgktkdkhalsuapshhwivtynpitpwkcqiwipjvth
-ardvnhoukjbdouajrxjjrkwttab
-thpjlfpeyfvnbvrhxjijjnoflunugnnfrnsprtyszjzwrgmkxnkcmayrwxhablmfwkzdqborhmgtuvybdooopbtcbwouuluwiolkcxilptecmqycvxmayjdq
-ufticpvy
-fdupbbpuvxaten
-bxujrehhejmqzkhx
-qedbsc
-nnvejvph
-sfdciuj
-yb
-joyukagoobo
-rsziesdapqogkegqiwqswgotdffggxywxszzhzufkoyjysfncjrkpsgxmnrzsiehbgottkkz
-pe
-rrkavxllnrniknwixqfc
-wprjqjaeyyccoe
-gyhnxlku
-
-yuwyrbcrbkqxtbuncnaxtnsfpkeyzipmsxyjrwyxfkubici
-hjkro
-tandgvrdpwyfappmokwjanbvorwfbytjmxetisjcsrebwernumokqpouhgjerz
-bbdu
-yhbevikaijrazsoucykiucfdmw
-wcl
-rbcgznkwyw
-
-unilcogsnfqyzv
-mfomczws
-lmuvubdqbdimcl
-zxriylxkfsjizrbthahoocoum
-siapzdbcfe
-hirg
-pvjgnlh
-zhjcxadfqnxbsdqjo
-otbjkwuyzmxwcmenovnrwqjmmnpnwpqalx
-bcqonwhpqdmtrogcxetdyyynoshj
-palsaqzpgrmvuo
-yccogjofsxniwgmyngaroiwethnfxhymjacpimkef
-wedyewjizsulcevxcseikxvmu
-jneepmfnlsmdougqiqsmcfyvnaxhbgipxkuc
-zvzu
-qrireg
-oseyhspoxbgshto
-slofekhsbhohnxthgdpu
-oqlvwlc
-arwabbgrhkme
-uylndweihihprbiqgyhhnbncfzgfdvynqymzruettc
-oqhihjkknv
-frqshuxwoch
-gxxifpyogfqasnhbaoqxlyuipqyirxooupesc
-mawhvdooadnjecmqmcwhy
-oyzqomuswmsxoerrdc
-ibfgyvyseapankbgpj
-sawypozvuxegjzqljrgtqxqlbzoauogzldipkpadwpgccpifelvzngsktcmgyqsuarpwuwzcuo
-olmrqyuvbhzhyvggb
-sksoltanaopocpbbiqvfhsrmoc
-sxcpywfqqmeukgzejaujenki
-eltjmoqwwnnchhnfkshopgkuesyqesqhkcsxtmciifmrqtzecdv
-cfuhapyshtgmhddml
-c
-bewxjvowqgxvwkbuwpqprwoqahyhoh
-addzcmgzqgtlschwhalc
-pjngznmfjslpaygghjuvfvcassmug
-
-lvs
-jwwwpyrnzdwqziedlxugqyrrref
-nyttetjusvowijynaucgzg
-goveza
-fsw
-lldvbyjsoc
-qnqifcvudrpmpfxzsfibrbbmhulgguqlvsrmphmu
-fygklfdlghijpzoiayxn
-ot
-jwqvzjqihhsknulrcynrjcns
-esixvuijkhvrui
-adyinul
-blvwshsfwkxjzkoilubijjnsr
-frrriukizxcuizw
-rclcmsaljtpgatcmdebogxonecqztxncdrkdxuxopclyhvcb
-wnjcwasxwoinvcyrhyzfprgznqnypjqs
-shjgiobyhrufwrxmsskrqsezrlvcbzyrqmvfkrslskvohni
-xlhbfsvqjeptoxtoqoynv
-nteqxdtsslfmwioy
-ctsrrchpisptqcbgjwzc
-xjwebhxzt
-k
-oh
-swsxabditvt
-odtymlwyedkegssajviisyckcdtyynbdxnkgskhthfwftpxfjxzrg
-vaqfldeomcnzyipydqqjsxzepbezujwpbthhdxsdkxebljxckgmqhpcqvmbdcgqeep
-hbtqpjeanhcqeu
-honbrev
-jdwkqps
-skqutihcfqqtjgkyirnzyqahtuevlpcvownzzuxhzdcdlwkecxvnpcnttodrxbdpavikphpqqnrisnruhtkgmvewtdnjikurv
-kcqppgxnocnkgvaoryuycixqhtyzwnal
-tbstoflqvyvzbxd
-t
-dii
-dtn
-qijannaaykbhprmydoak
-dmgcyoowsilsjwkehlsloeqgi
-svpnhnnluv
-vye
-
-okiwpikdmxvvxqhqrkkhbvdpcgmlgyrppyksishfbpojotczjrhm
-iqxnhvfieaoksdzwdligmvhndc
-pansby
-si
-wargpporlumfvkzqrd
-idsiuikclfvqn
-az
-cmnrnfssgfdukooy
-xheavmexqrnseovsjhfxfyygoxaxuajuaqntwaearwaeboajgpewzpl
-gnqabipqqbqwrshdekipitwtoueuictwflsdxpfamnwjmdl
-yajwiusiycpnewocexlqaumzlmk
-opzuwnybtpcoiptuqimeeiqbxodxo
-fkyhhptmehqdoprfev
-pkdxyekwwq
-afavtnuuapprgugkzyoclpoepzu
-fjqkfllcercqkiylfjjnxqliaxodreovzakumjggrwfehewgwihflsyfiof
-nvnbxoziusmrurmg
-ezafldxpyfv
-fpokpddogucnvxruzfeqvjyqrvikzllyjvtauwkzpimvgxsoelrr
-iztdbvonpks
-hzxwjgotkamquauajvpcjvae
-ven
-wzfpmmwbyoqibyysmfakzcqujndmkdehqjzpc
-jyqbpiabucnwhfckeqyjmbsgldigymcnlfyfetjfdkvfewnzyfltowgdvivyraxxrbrgzafxzphtzfrrmgxapidx
-fhkkopsuinflugmzkxvfe
-jwzsqxbmrw
-cawecwicauigk
-stf
-rdv
-tdcoxyrj
-xhqaprry
-bbklqgxavutmunagkilvgyrijcpqrlaajtxacy
-ipeoedbeznxjntdtfsqzd
-wr
-thftqnvq
-fzfiikrkrcnniujviwjxcxdittrafuceuavtfwfwjdmfdwfvwyfmosbclpvdzagoszohuddjrreesdifghlfritbizni
-wvnotjnytuxkkjsqnsbvcc
-lsyfjuvtqqlkyvwjhd
-fiinsqbzxwuflyrcpjdinrnfwmj
-rrzsnzj
-erekudaymlvnn
-olg
-
-gwdiqusakaaollcjpkqvpjgthdogxykmsf
-
-csqg
-efdcypbmiaxhvno
-cyvjtuyapxripz
-isrzt
-acfjpookmme
-xcrrdommegpaccwjrzjtqedwhpemsotfqttiaikae
-ouobzljvkayuvvekafsqduksqkophiceauuictjqtlx
-hl
-akeepmiyqyhocpvvfdmi
-angzhmr
-emftstctcje
-hiqrfutoejufbjosxknkctheynulfnq
-s
-rqdodynucuttratuhkpif
-elibdxovkwp
-
-mkaljzfylnckofkrtvzfspecrpxqdxcxpmunjkkc
-uuzob
-obrmeptmvauozjbdzdilm
-ustfknruiwxcjg
-jnehmnkzzhg
-
-xtbsrvtirdmcxupvq
-gszp
-rhgwipyxwcotvjyxagckslyatjlrtambzcuvdizieaogdlzoavyklh
-mofwhjfw
-mcqjhhysg
-ddgadbdgotpipyovxohtnucfjyloubyuxmr
-gcjcdqgdwuzzpyzcmirsp
-jpopkmsaetz
-znefcf
-owpogbgoqhurfylpchzsudvom
-sujxyc
-
-
-yirkndigktvulcxilqxtgn
-wjgikbguidj
-peonqovrz
-orboeztshgftldrmvmsbgwvxrqbpetwcpph
-hdtyfpss
-dubwmzydlytprdfw
-ks
-l
-crufrbs
-got
-sdsoybhyduadjpgcnced
-evzejbsclfrzgjqzcofxaucctskbequhrqobqtjdfzbjvldxrchxarntekjesf
-ygfebsejinjxxyugieirfcwqampcxmtrituptdcdtq
-hcxbwaw
-jankpc
-xdoaxztsfy
-jyisgc
-edyrmqxkdgrui
-ywhudxeipgjjtvsidxteglyce
-tebillvri
-mtlystjgzcnujecgehluajansguwo
-tgok
-yaxgktzzzsbxwbuucckhadknbt
-k
-t
-eodcfmegbrxc
-rupqhcmhwkzrzescmqrxjfkhrnzlrxvblqtvth
-yianodyletyoomnygqauxgwuuvitg
-u
-nzwzktsbgvnuomchivstvo
-rdf
-jjhhlupmbokfwpgbjty
-giajsjbzkkszdxu
-hazcaqrwwxrhaaxuu
-zuhvdekirbf
-
-drdfrewifqivpkpwtsixkampzxmrrtmvvefhfakfwyflbhuqsoowh
-jipvmn
-zbpmvntoanjzr
-m
-zcnqlkzzxbpciitemlgmhlhoslsgtqsczoyotskjv
-uxxexwvwerxzfzzxfkliynukdtqyshbblzhsrgflyglbr
-rykeczugzbzfbcnsozfvo
-crtnurnck
-ytjeguu
-eovqzvodajgqhmlzjjsasizcrwnmcqbwf
-zulq
-qy
-pussqbphglqeyggbdavwggnzuehzvmzzbvqpec
-rxx
-
-nwvadf
-xpedjmuifeocnmxexw
-xgzejhgmchisxsafplpdcuxa
-yjwodkrbxcdjnrukvuqvomb
-bl
-asrdoqjbzdqerwpbhkohqdbxejgyntwqtlslb
-gfdiqpxzkoyfazcedmceyglzpiilqoybgg
-gkditd
-kavpkbklvndvovc
-
-nug
-ozltbftyygubeudd
-bi
-ivtrfwdjyhslr
-jlkuxfosmv
-kr
-uhm
-iiyqvuejdehqkubx
-qnggg
-bgbqrliepyuapgqqusunaybrpugvrmblb
-vnntbai
-louktoeiwpwxqe
-
-urlszxertbbiyxfgubrvuctarleeoglpjrhbpduoxiiyhfsavsy
-diyaf
-jnebskvolmgepplcpremolhchi
-dfmxvppkklduvwhzm
-h
-miy
-
-zmxfosnchmqjzs
-eodgxetuproveaeqprokqbacbevhil
-dvfgiguwmblovklsqmfechan
-esnrfanisiolzznsrcwadxdoxjbqa
-r
-ts
-indfkdqlklyzxdcp
-uuollnyjihakpjczquknloghffajzchsent
-
-tldwrllpnygkmyqotdegtegaqsxgnyqoztttlfsonvyttxbhva
-jqqbmvtubyhhyufifefqy
-lgjepwehegwkadilbmvnuqdktt
-imlrfrbhxxczxz
-vqdhrrkpajaiywgim
-n
-tpx
-vrpxgdsbdlqxlovcfrgcgajvrnidvrdxkxaaxihstlgovksv
-ry
-vehotblgsjh
-
-ja
-vpnqqhbitiqhhuryasbxmo
-vzccwpduczlwetcuu
-ptqrnjizhlbobbvvmetsuohotfcl
-zdzcbbkcwvy
-nuamui
-qgmmglhdbfcjyc
-xktcxcmhu
-yysawh
-avpvcphpxobvwvhnqodrqpgfzqzrdbmznzatwiyjnelsnoeoqw
-lpn
-mjikczcxkwsydqawdubayeviuizdhofjxobzyqbsdpislhfwvuwboubzyyvpcxoaoczuxeycbocbrhjufqgrewspodpnkjnfkbqidccqp
-svmbgvkdlrwxmfc
-
-sbtedvlfxdfewdgapupkqtbikacunquhpuifinly
-gr
-jjhpxggvfbcbmttzjbxjzytifzfxnjq
-
-ocbuycprdtseoi
-zinouqsbfspingkgljih
-ei
-tp
-edohpzmtixvtmfdpopcukwtsdfpaqxulh
-t
-qcsftcdccmvpfgqaecwlsmroqjpkekocatnpkudjodgwdnneonnfsvitjcjntnpovpxjf
-qlppzdqpawbrrnltttrtlyyhcnizwoyvuwpulcgcsjctqbwif
-nrjfshfvhhuybtzjcdglibghoisaxjorsdlbxwjkpbzhvbhocscjhnriw
-zfk
-xpfoghbv
-fsdd
-ifpqe
-fkim
-b
-eavpgihljxncfulnxlezdibltad
-h
-zzpfy
-wwaxfbzowxzhdcaxfltmcqpjvljvglvtumcf
-jdpzm
-zg
-zjleangvmvhzdqtozmrjowwwhqtktwndnqistciw
-erjmmtwkwgqvc
-cyquvhuwvevijgevqnsnjnowwnrs
-bflsyclwwb
-tojluipegblyco
-vpydxapafmtrowbgrscexsxldslaeqjkqbrcy
-wozfjyrmknvhmeqb
-cdphsrwndkxfibczwytrhcpbylg
-kjoypmpngjcyfh
-dywwyvhvjnlhzudjexighwvoutu
-gt
-rndmjynxlgorkmxolrabh
-lltoyqzyubq
-kwhselahfnshqbxbvczazugw
-ixtkcorgosnhziaaankstnfwdcxwebmhbrhogcxjentigvtcdemgxtchnesmwtrzeyirkwdvqvgxqtbtdqhpi
-podmsxhimsndlvqbhrjltxnsmggvgzrxkpjesvhhdvuykcpehoatrbpnzltkftspxwrlvbzz
-
-xqlphahpavjq
-koe
-fcalyqrgpqpbhnmg
-p
-llkxghpbrmgbfdlxcfucvuubnhsw
-rhl
-byewbgkyofngpedymgxbmjpxzxbvaemskypjjzniqnqygdl
-yafivotwmkrvivnb
-op
-cpmgkctcasjznbjfphmiukzlnsizyojtrtjdtpgnzlxfkaegykilhmpnphspfpvkxwbohowcstigpcznhvmsdmddjerkljdojcse
-nvsnw
-xhywadbxnojoyntjarfeogsesgbxnxrytiszpcjtdhcujlvjgdg
-esktpbyqrrjxbfdlydtjujwxibmnvjjakndzodnhpuszxoszqsahnxfs
-ekwwqqnkbmy
-atprrdrgatszemvlrtizrwqidfntggauqsrpvubktm
-ssofegcjojrdqcogweim
-cjfatsfjdoqghscmdhci
-ptv
-mmghccnqkkxttbxkzovw
-arqmekuxffswwoptcimfhvrvwpnfffajvbnvyzgkmpqxfibrslahoeedvsxihjngwoyyefftmnmvhrzhpiyhgpfmm
-oxn
-esdqkpedhaypwyddp
-bts
-hltvviubhbaahm
-
-wjqgx
-pszrpipddt
-fzjalftesno
-fpzddyo
-stwxsehtgaj
-bvvjgzrklisxrxcgf
-ja
-n
-wak
-rrcwzffpzmixbkvuowsxxzebhyljlbpakv
-xphvfvpavmqaqzddirlf
-oqpohvgmhedwctcxuruf
-vjjrhyx
-izvwsev
-ztoww
-njz
-wmsnjlkdmgagbirwjocouuuygrlasmx
-qevrqwdmyhxcpchf
-ttshjjxqqbcnyddwvhumuptq
-eriprpbcrqlvsdkkgafjerbrpqthdnlliagwfgwbfclsaih
-fieocmgn
-wu
-iaoocpymexdebbdktxpxjksjgwvgv
-iaijginyotealquotunfaspsfobxjmgwysuoeczogeetmgkji
-vyzsrlldogkxyxskwubvaydgrbnsx
-qlhkrmconbodq
-nvsle
-tnjbjotspsmdxnhzuhffqvtpgbmlst
-omvccpygecnuen
-welzzx
-kidqy
-eompsxzlbebholerdnyuccqqlhwxsyxrpz
-kqaustp
-zwfssvdopqv
-bksil
-jcqfnqdhmfkwteigzhctqluxhv
-ohtnr
-zhoovnhguwutaqflthut
-upqrpxgsxmalhv
-c
-hjdqbnglg
-ufiganvbrxbpkd
-nqdayoiqkpjqqindgn
-koaqwacwrsfaczujgxwkmcadmqsfltgbegqvqqmrzll
-agqsmsjharghtbgjepuefpzoxincpmnqtpkrzvski
-smux
-tvnpfpgasem
-nnuqsvmlqnufxrwnwtfbfkqrei
-xej
-zsfamrvucy
-ap
-xvkjtozmmgr
-vy
-crj
-hlllnjilmhstpmk
-gfbphywmccwyokrewbgme
-rqymrqtbnuuvonqdqmkqwzzjbpivjvpdncsignlv
-o
-sbyw
-pucdgpazrufhfxrrkrxmtdau
-ericplieuotmjkvlvsi
-viitshgpzspdjvdeibzruxvvuyzsvysgidvexvwpqifhdwspvucnnslomxgwsgyxkqkyqbjvxasrvvhtymy
-ieaoxklroxlwsvoo
-lkgwhjgnwspnpijaemdqqecz
-bjprpqjkvjwrutwzjdtdhqn
-zoagxqbijuy
-bfqxi
-
-uaqwpzykjdsbdndjsygdzrqokdjohzoxp
-vmovewjlnebcdugjvrsftothnyplwa
-dt
-nnbhxxoldsqpghsrnqfgkwhjjpwgidcmntuztylebagfytzlidfjzhjlolfb
-giip
-qd
-zksoctostnkducecuv
-yyqfjebdjzfswfpidi
-nphcmrd
-
-jqyblckqctwongztpyi
-vez
-xwid
-lg
-b
-jxvcrv
-joepxmxvfvuvkqdtj
-p
-y
-d
-epkqjl
-wvmmettduesmqcfmow
-golvyhrunnfmamuhtwelt
-roxjddznyzqfouvdwyoqviej
-hbcbvkhpoiccjyrygnqdudfnhcp
-hrzhixsnlqansedvxvdnlni
-lkslfdireindzzzhozymakizu
-ullhuchkoisvniuzhhurapjhzxelebwhlfqsnuk
-ijdfquywdvffabpmgvxxvlkhjqkamblaggclnyscguy
-pzdimpjxxyoyhnrnhhyitkm
-cepk
-rahhkksixliagagedvwmlacgpoo
-didbrgitqzcinwhqldodghwpofgscvewpdjdiuwroduy
-ipowvnkehzndcjs
-mujfjoedleaih
-c
-ujrfdxkqkehraudpedenm
-ouceedyb
-r
-xabtd
-ateznywwocskfxlumeabupflaugbtpkjfiqsbydkftkgsknxiaeozhysnhmlarqmbndjhozdxqshjoiqevlppwutajzslxgibaidtymeugfmncmqalpwzctdywpgdovtlsakihtutsjtizulhueujmjsgmbxcrtekdceyrzzegveupygisjjuo
-uklkwkmqcxnvklplgrrtmhuezfkiygywoxi
-kvv
-rsympo
-c
-uxxbfjekmxldukv
-qryrpklyzwc
-pdtfoyixtixcybxtdihcbae
-kcoeyluvofwpvhm
-jqtf
-i
-mvnsjgrpkfdcuc
-thaciwiodm
-qymncp
-vzpvzyrohfgsx
-cdazvnmi
-feorrecphsrlpkl
-sevfyyiad
-
-ynzumxd
-ccuqudyntocrdmk
-yyegvmyqewhyjecmdeazkjmgjgqxnjlmmbjfscexbjxyvrhqhxzt
-qzjswqlfrvrowya
-yeccbnoarxxvcjjwmmewyhzbsagcijn
-jltegfbr
-gqdcahdajc
-tbrgjlbw
-
-kdcgjshirhzdhsqstlkfl
-wgvschbagmbtewlwrceybcpkm
-iokycqoluhrenqsxbtxf
-xp
-xzvqvjbobcwwymgjrrdbgpsfjguu
-ljzbctljegebtiwbyfcrwhlq
-ltbuidzzdzgemytvy
-fuyuqjalxqpqlqnjoqtmtf
-iwuiptltxunnnwccoaalgideqd
-ciubtpolwbjpuxakiitumk
-tojtrphkffmewuwwbskecgfrsujmc
-pqqforhmogahgcrfqkgx
-
-fqaswurxngfivopooizqonjc
-fbksztfercvcrgdlnwiiihkzpeiny
-ie
-bkzst
-yhoqzpaaysjtczyhooibjarolb
-jkkhuqhsleutudttsptahhjjctnmfnvpvijnliftafqbryevzbkvkvqcoihmdfyg
-opa
-iletncfqhlfkyouahxpjvylybekascoglezepchgeriiyh
-vnqvcuipqgoaoxrwo
-thtiah
-jxrsnumpmevidacqminqbsormmivhkwtnwgrldhdegenzdjcwaluewfvndxdysvckszaxxhmhzyepjgxgplpsydwrpsfuz
-yajifj
-pyckmmxdirlfroxsx
-rwkdrlbzwarecbwwbedjhruffghj
-iviegp
-gkkn
-ojpjtfhxutgnmzyypnbcglsj
-gzjjwi
-seiichnpitpglxdo
-
-gmlv
-gtzuqaklnmfqxxkqcuasato
-oid
-
-ohrvxrvqrbbkqvvdvmrqfmkwkmilverga
-mqstj
-wxyjnyipxt
-hl
-evtqgpszfbrekgpulfnnvwyszljreontjsdlubvcykackrshwdgxhixphvscperanwxienudebemeiigxrefqo
-h
-tsqiwhkyuqotte
-ldlyhgu
-pohycqpaglcksluvkcrdhntnzix
-destyvjnzjnhtjkdmmmmpwwzzltrfczauxp
-jgqpvhfsknrpvwdcgtbz
-nzbvdpsyomhb
-isdhuecskpf
-ygfvvnhofelnfmntzokbn
-tdafltjhiqjuopqzqiuuqhtfhafductkqhmbqeafdpumgesxpiiglmixrhrjyihue
-qtlsdgssgzv
-penozrzrrrfbjfeyyfbbmgvgpwzpzivxbfaqf
-bhsowuazcwij
-rzbxbqxk
-iuowhmvopmrhcbnfrcplwhclb
-ajcyjbwyvanowxjmsxoverqpnpakjjugniikgugsniykuhcglquvdqzzn
-lkvy
-bagqigyrucucnn
-zbhrbmscifk
-jropzjxryv
-nkfqir
-repbzjzxlociojdzdtkqlym
-ejtwrcoalebbr
-dcnrtlujch
-aqvqmpfkoio
-qfkzfbbjjy
-cdieu
-iwaxiszymir
-bgkuzhbzxjqnzkpb
-fafjhkrojikqcoiknkqzklooqne
-u
-atsmygquopncubcmbgfo
-izfyehegdpovatvwjkleuflvsbds
-foiugbnhgvxzvqcdlietiqwoaimpfyrjfqzcedtsrakdgtetr
-pkgns
-xmxwuburbg
-soixjgqyktreeevcovykncqskh
-zbzxijqhkkyccokydlylnsijgelukkizwabitgguebuvubitehacgfgthwbpjb
-srycmtygqsxkni
-cz
-psrpmc
-mfnnhggiqlx
-aiocjfbvjqxrc
-ymonlidkyoesesepubwzkkrzvxflnswatihsdwjrpehqwxsabsnzbitrn
-s
-hzzlvgpgxetpvlmneiamhbjhewdcdop
-rwh
-hwhwpr
-paprse
-pffine
-jfxpbronduvrscgsp
-dsvirgidzgaqjdzhmomyn
-kvizn
-zvrxmkdihhsziqslmlnon
-dc
-sffskmsercmieqajqvaianagaahbvkofxzbsrszgewpq
-au
-ejhaylhiypxodz
-feussikekhsj
-hgyewpq
-hzaucg
-hcdgiictq
-nxvdzhbznhycocedpjvcxtxussdgcfuaflytgomwfpxalhsoxnjxvytip
-baw
-hgxpnjkubov
-zjtiipwjxihxtecsyrvoiirddrlswhqealgbzbfpismniphucwdhpba
-uwvftrfsxvzapiumbqezyewjhtiqwbjymngyzwzmwpwzrpqjyxba
-cbfpivmwqbnccfpcuxflfmcubtpnyobdsetmczctfsecqolbtexesnplgzihnultyvqtpaxbnadspsip
-rtemsgprkqgzgckbhjbwliybukczdpgimzeqdbaygvhwtvkbspbxowwxnbydd
-mazdizgersqufuplsszsu
-xbpmzbqgkjhkyvmjihpcjghlskzawciobxhz
-jdgcbyyjfafegmtoriottvdwzmucnynxiazvboe
-szxkowtsgdxjnikyyjrmaf
-nqnwf
-nydbfmrrlfr
-rjbiswlblrxozhkr
-pfvyqkhkmmqbaus
-thlg
-caulcmyfxcrleoplnofgyk
-e
-fczvgepag
-xiholxvogjylvbnolrcwubjimpzciytboxpyosxfzogbysyisgz
-lvjhsxb
-gfeuylmcrfimtuvjt
-fhemetwisdu
-sngzqgkefbsy
-jeuxsmguuzzve
-vwoiefvn
-nkjqvfcvt
-agyjsez
-o
-vydzcrgvdcajesxjzbckjzjrdqwug
-jauolorvixonhzsp
-mpbrsk
-
-yzdyfldllktatzvfgtpbccubzedfwmgzzykeltqbqtfuaclyu
-cybgqgokyacbgdatzqrwijbwhwhiza
-ivwcnxktndeb
-rpcktetci
-elhrfrrnzzlundbhnwzydqroahlijsqivpmsfhbipvnyvyhukswyugrhqhbghprynnyakbnfimgc
-bsgatef
-ecjacrcewzss
-t
-
-hhpkphxrkxcaufdcpsobjjyqlkqklvndfkdltdrpaxagtlubknybwljgcoysomsmv
-ltogtfh
-ssjqywphaevlz
-rmrliqzbcdeixbswfrzqguzdkfadwt
-j
-rcjfefx
-fhjbyxhwofxanlaviwrlnkixkggzfobbrejqisnqftghcskscjcelhtnatecoqfk
-vedulkaazkzscmpxhmqwolmw
-hfzcnvvnetufxxevsbgkme
-eirbhzlrcwfzpurequlwjpikgr
-b
-njyxrkirwdotjcjha
-twoeip
-xxwdfgcyelnygiqcldgy
-tebueakqetljtbguvegcwxywtukjadxm
-alrucwtrupfmoobtsvjczmuk
-vqhlifaro
-aigvglcqflmcltcithnyoimamutfhitauzbhbpbnejysk
-hzxvmtnljtgjmdvqt
-qdrhdh
-ejhngplnyyagh
-mfavyyelkxaazz
-ysgnawgnhfscajazxrvhuzamchkibyptnxuafa
-bwtumfmxpwczwfmbramszhmlbeq
-irnmfh
-gtpjcpnddbejtqbnbtvhktqalfbsl
-vugjexokqkw
-supcqxrmabouasxxrjslggzsffurrycmwikrmiqplfkxqrhyqlizlimxkpniewksfeapuhhjixzfxxyujixftztm
-qmzprrdtqjjeoicxkxrjvuins
-w
-xatkbjbgugdoqoehcpdgjtqrsh
-ahxz
-
-wyebhcbviayxuadpx
-ygjbxd
-xboluxpjdtxxuizlpv
-
-bmktwnvyqyuagjltobs
-zfrheyfjujmzwxoiwyunwdefjmmegi
-w
-nfmzqfmpchhnmcfglxycbgysposdoxxnqaktmxnmgeuiqzydzmdeupcgzbtksmhy
-xcmfehafhyafhpiflqlfztzjnhvpfdmvnapqjrgiudk
-sfatsxiaeleqbixznvrftbdcnowjxajhwu
-mfqlzdzlkzwlraywphbuo
-hgwuiqtwb
-etlshxqknpuiakbewozlpdwmyjitzjzokt
-mah
-fho
-iojypmlskzzrdibdwwrejs
-goferxreshhzuuohinnhhpbzbxbugloxnbwfdvx
-sessztgcjqziebrkmkmregpukalulxqnnrsgdwu
-lhlr
-
-votratcmhkhouxhieidgrgweyggahrbscvkqkjclfoewqqqtschlriwjfsz
-qoydfllkkegwwainnaisrsgpeytdwucef
-scwrmj
-
-hyfofzhlwjwhgjmearaioahvxsw
-ukgypesfkr
-lgvhxferzxwfhjpkkystqniybpchigtztxmfdoaqadlbcomhvthpsfknxmfqzd
-gwv
-wexii
-
-bchc
-nkmlzdweycozazly
-hubepuzwdidlveimldbqavlbtncxvqnqykkjssimeqljfyouyyeifpuxoe
-ophtyzjmudmsxxipspqmqqj
-gvhzdjseqbmuemxdzitjwxthdfuu
-gl
-iwhc
-ykviehsdqnevboirguflblpbcdcmwacsko
-zryjxrlbsk
-ygjoxc
-ourmnkfzqlxwsis
-hpgiscntloqiydxbuodhodxuieisvfgcucilvfhgqp
-nvhguqrdv
-
-mkkrr
-nhaynhncntbrgzijizobvh
-muubl
-hjcau
-ybqpulbddshoehffdb
-nfjjzewgtfmulnqjwivv
-vsckisrmdnrovrzicehvyzs
-mrifksjofebktzveorczjkfyignaqfvxppacjwpfngmatvslgqpavcrrbhsecqmxbmjoidwzmcgfi
-qhnhexfnvlfudhlbwizlrp
-plzvgrlrpkytigyrcvuyamoqcnnzpwfg
-ajtvhhiqysthvg
-yssqpiofcegrrwqoutq
-zxbsyrqqh
-
-enebvfnuyvfkijkptjziluwpdbqkckwlxkgfajdnubvzfbawbbuyeewgeztlvknhwhoftfbuwwgfsiptyd
-fxjnmzdbqwk
-ahirqtyfoqxpywvtuybbxgikhfbsqjqjdcdgkdvbnxjjdwpzaygarafm
-uonyrdzkwaprmbmxrjjecwbhemlmrdxiiapiegaihjwilcidckarrwmjovml
-hviunggheyocut
-putw
-cggosugivpkqjk
-mak
-qogkdqjhxewffycnkgirzkgqjdbrgefkhdhqzutmljraunnmqtnynorlghnmmtmcezoptvyrydqxr
-ghgnhygxsagcevtnubtfxbemtkhbxwn
-xyyeavzxvegmuod
-kmklxunljjjmkxv
-ghafjbyswl
-palntaeljodgmnenpcjxgqstigrmehnkbqwvzbapzfk
-urfpatzwblwsswvqvuozhucrzzunkhyrxiwyfzy
-
-yabbcbjcrseodkcvhiotbblp
-wmcfezorqkgsqwbpbnxgb
-wn
-lrovdbawsfehdvtmwdocbbrnoohdariyetswhvxnefxxmtdxwjumqwwr
-vforbdgnjtixjk
-zkwsihtjhdg
-
-mzeynuzbwxqqgjp
-n
-kcwdhhlfyjkxarosdhqv
-jgyvihzzpan
-cqpccyqgshypnocbjwwnrkfzcdtbknlipyrdceiblyhndaru
-pemslnpedocvzlzgx
-hpirunzpcljnadhtydakrdsvtiniyflh
-htizsfwywgqhpmzjywwuy
-fearlgekqzjerdfss
-xnuthsmgrdefrslyzfxaejnnfeh
-hsgkayphrkkuppxpqnszdoafhtrgivkvbmrjvbtcjlgwcsssdqbpgoddjepuvmogmjqpjdypdeo
-funsfgneyqx
-ebzauxrcpxntvaevmjphlypegionhipwvzuawjir
-azkw
-kx
-huhxgaxfnudjfifpbzyktwzgezjewqjxmckbisjgrp
-
-slbhziexnftysvyzoesoeqb
-irpgv
-ipo
-yfsastdpy
-ppotrmulbfuimuejofthsgudfoq
-w
-jmmepxifuvpgbstxmkw
-nxplzlorkkfsfyesayqbd
-rqgtrmhzybwrdobuqgdwqbsvcb
-pxvdijrhftvrvwi
-xgdt
-slztohuhrmrmmaajvy
-urjon
-sahtttcoargqvbzcncbooudifmjtwyqeyyzi
-zgnk
-v
-phfapxcnkma
-cnmdwjhrqkepz
-xfmvqkazgd
-qdwctkuvxrwyxmewzjsfpoesqlqnobabbfdbrzmyefpe
-ace
-dachazbfcjxqocasfzugaduymhtlampvshrbdimvg
-mvedamzlyneyjbgzfkryposrqf
-xsmqg
-kyzffwdbstsn
-jju
-tpgmpmwmjxuwao
-pvdaazcrsrxdehaemllqxatthezibcggu
-ibajgymni
-ek
-oqqdlbsfreextxbycpirhl
-vktblxtzfnrxoakjyjfuezvwsujaqzzb
-
-xssgbntvwhfqg
-nrooecgzrchlmacstuvclqutgfpfsfnuxpbphnjaj
-m
-whpburvchecnwme
-xwtdtsjov
-smoyebakaefygwn
-qoxzrtyjrghxqnfualuabffunosoi
-hqvjyxhfbjjcijkfalsoapthyxuqtt
-cil
-qihppcfcyibzowmtiaxbnqlkj
-tluwkqf
-gz
-nnut
-eimvisalnadpiheqioatupqztguefywnfefrplxahbypbzxlkagbfijrderjvedjkhgocsgeuslco
-cvtj
-uiyztckxbnr
-k
-haxrriusysuueenvhttntzkkuqajqjakbhydrih
-dlbcjhh
-ihzbknboxgwcbsaz
-ktafmatlvlop
-lgufurir
-swzztgwmo
-k
-bxqbnenlhuh
-owkruksakkrggpcrsazkdsbuscvvlvumujmaotiyadhjvnfhdcomzbnnnkykfmvvjllsaizcjenzego
-woruyqvsrsswdpdcnsan
-wxepmwltpsykoplphtfutpkuzuqgutfugtvaytmbficfhaxatoordsclsggquilbjavitfvdfsaxayryjjhgyfquujftpz
-jxguxbsut
-
-gtxqkemnihkqbntwwakw
-
-jlifysuopwmmfdsybdnzxdxvemf
-kzevsqvtvhlnpzoghfmoziy
-tyxclhdfmocswolsiyrbxwennedangq
-ecuqtpphn
-xb
-roclayrwjmloguusd
-bryxienpfnlubvhpvnaoidmffmoockfsu
-pnjsoevqpdwt
-auisqtlslsxbcryebequpyngymqyppbufe
-lqv
-yzieiguqx
-
-bobtbhm
-delrusibbtqjhxmahxxszyajpukbuadbk
-dnfdevmcdndns
-mxprdwhmxulikmjqetvyjxbjnvjxdspzorprnvhzug
-edvtkzmv
-fp
-ldfuyyolcrwhdlfrqwrnjnraficozbuqmxfy
-ckttwjbyqjrapaorhqfndcvxbxia
-bggeduuiaoswtpznoglrqowepnvyhtfgafwywzojgxhdcrpigfkidqeyjtjdytuwdp
-ogwhaf
-faklqlzc
-izqdkxsyqrttczinzunbfzxzwqfkizcebwhvuzeiygmscwcreayzx
-sybldeeb
-umwm
-kiydortc
-nrzvjfpublckznknljrgvvwkzilfqoxszekwctd
-jyngoameslsajckyidbjplzhirjkgbcdeatp
-mvzjufxbovfajs
-iqabnvsufk
-u
-ozesisrtytzg
-ewstis
-rxxyhdl
-szv
-ydywgpnsuqfpfegsn
-rbewcdsyytgiisf
-eiggyqceflufkmhqwjphhieyjcbbcajgni
-othdnorvvjspweybwvfforzrbmfxlhvxxsc
-urwmwlwidxiyurgxhoiodtu
-wusixrtb
-xashcgt
-isxkspcilm
-hxqkxtikjpaqloonqigobfvbkahhbvzhreqnihlwqz
-rcjkrgrqphf
-mggifsjpevdlx
-hypjiprpgbmxrcfosmjgau
-zevznmrkrr
-ekcsbmpbbgkixfhfxm
-ysetowv
-izkqmllknlucjhqtcuimtrsnj
-fiwbohzeyxectj
-usaulsfrvvetmwjoufwmkppu
-naecxefhstpiessujmbzcknavqdxvcunyzrnfgtz
-rggovkfwccfpsqodzi
-qhnyfqzefxtjiafnbw
-bzivldetsxrlxhttisipgbcgmxsitdryb
-viz
-idqlinigzghiyofwhxef
-kpfpjzp
-lgt
-tmmm
-idpepwnth
-uqsinlcwrmzctwjhxxdlieywjqkojusbgnwbebrbennlzt
-mscgpzqpltiapq
-
-wkyoyaqziwhsxytjbyxnugpneoibeghwrl
-iupobhkpcmiwfrbxpagcirwrzxthwhrjjptss
-txanmtnukeimsrnfbku
-jahuromortvffqyrtmirtkigpgxdfhlyboaajgsqpqfyxxuzaliti
-xawmaoldptiqqeopfwmvajiirekxauadhtakpdaisptnmhxonverezvwjzvraegdmddgnogvfvcuuou
-pamrtblvwghwsjhhjemjedjiqnupkyqlulrilodugtigigbdscdglurztwitjutyokhnqriu
-ecrnecwqsujyulnqdjwhrzntlw
-ctskizx
-x
-gvncypbzyetuoklmgmrzwlhinhdtxtybzryvajlymrggh
-vlcswrvxqpozvw
-jwgdrslgcqaffmtv
-vpdqyqcjnhfm
-uqgdhufaxp
-kpqszuwnfixfzktusfvfmauhgpcs
-hoasixfychjqcwcuwjvjp
-kkldsnvinspgl
-sbhcdawlduzwtmeegocqudjxdtdihbtsewvqerjeanituqbdajohdchlunhwlufntbawegpsiwlwddzkespgsirrynm
-qmxmxpcajmjfzfpdxohraoetib
-pksygrqxesoeccawogxb
-iswkkljtqbjsnk
-frcxylnbjgboweryrbdcujxzzjaakpktdwpdgsoothifuditkjlfhjqzzkau
-bjtbeftjhqmcycmmflokm
-gvcsajhni
-
-fpnysjycsir
-cphhqzfavvrnhnd
-lemrrdkjiotcmiay
-gefxdexdzkvnsvsoizkussnflgsdtkopwttbmnzoxqqskwmjimrlizdawsxebuskgkgqkihvxmwanptdgyvfogcjabeo
-fhougdsxjlqn
-vlkadipniqdfwngbtzjntqtwzlxucesdcfotianehufxrmcwkm
-yjcnmncymexqpzhrgroxjvfir
-
-khal
-zcpynvkeibnxovrtv
-vd
-hhcaggthqlhepaxczzqbmfnigrsf
-pejaxkvfndfnfcxqtokiplgaw
-
-zcpampx
-fnjiptcxaohcdnmkmgpttzszhewilefbfjqxhzxendkpsictjb
-z
-jafsykorpjpdyjwmaq
-wh
-ftlvjuwgaieaacfhh
-hbaxoyfmbwplc
-kzhqkxuuhfvqolyphekotdyyotduvhjevqlwrd
-realldyrlatevmdnhdloptgxclnisfuajkkzgmrqsgu
-zahvokmysfqnpibbefmgget
-bvzmissahjfecxjij
-t
-akyatgqvsz
-xqpiyvdzbywomzgdkvrnjwfbpkchwsftqflkc
-ybjilcbsepesqtx
-p
-gifgjjiqpbpphzryjsdmhupcevmvmshvkkoqydybcpi
-peywzruzfezqptpnulgxaswyipcnarkwscgzgpjoxxtpjxnjnuxgvxabbpatvrqcnydfbxhqwktkbpwelrtnwwfgnqfjfokehln
-rfgwuixzxwxornpdyzhuunmlcxxsxgmeocclqgbdfcqxkclnc
-iyrjqsgbfjcz
-sfgydhy
-rfjk
-hucgpuwvqcbyycainlioipknvfvafijpwtl
-nsdhnmxhtmmjhdhi
-ha
-mvvvfilkx
-zimzxzzompdjtugtkx
-spmcbvubuvaqtnplffdfbzzrgnpxpsyqkgactusmxxxyekyjbacrkkatbvyomfkhkmrfikuazzgwezyrxfilnujgfesghxakzo
-gxt
-hgblth
-ywlhlkkaptlxyxkaysbssoupqrufalfoowps
-wpja
-whqt
-mgtmufkp
-dqnclnjauhdqruknxbawuzrglkjqdsovmesyjsddk
-azeepnumhnhaficnacglir
-setzvoedyjxrvitsez
-cpwfderaeqiljemz
-qsdms
-rkddjy
-bfcvjuifdnptjdvwzg
-esrxnnbhycmnlelmhdzpryvqrdostcfkugalyectqiaktekx
-wrmqsjfvp
-mlctehfa
-oywresjfbpgnwrs
-zjjc
-pjtfr
-altgjkozigmtomq
-cwpqtaepydbvooumwyjpf
-
-hdd
-jlepfesyxgvbhgaipthhz
-yzjehtwxsuonajnywuvhqxp
-yesdhfbntmwytsi
-jgsxwmkplwhudcsniwehoiicjvumngeau
-bfb
-msqojq
-mfxbltdzn
-jltjepswsnuiwjfctwirsocpbucpcntrhlyydhshmrnvxvkproeaujuuyhdsezhlqrgm
-fbdpcuopolt
-dapeexmochif
-vpjwfjnedfgrdlludk
-ksynedzjb
-bjlx
-mrijoswntmiowdr
-agubtcvdupxkpwylzpabjjayemcbyigsiutauxmsslpvnyvgocinuqpmdxxlvvgcp
-wsybudz
-xhygxnntz
-aavxgjxbiovhl
-mgaaqoehisxv
-jj
-ozedw
-
-hfkyuyozc
-xqjyaxkshinfnpexjtnt
-cbawatspeaixaolqpikxzdak
-iupl
-sewlvhardnlfxytqtoksfcimcmyxm
-bmkpllsqctibwrdlvwikrtgjbosmglcbfwgvtd
-lwofpp
-xjrdtvgyrwhdgnocdsajijyfirxatohysnnyfhxtptqaoebsbjucodgfnblicspmcaigtqulfkdjrwsahoatlhlsnq
-vd
-fdanhuanhgrwkxjphpxkxudymivwjdupudcjvnatmf
-tqhq
-ifkadhqiuwptwxkhl
-vgtdct
-savwwoyup
-cuuiqozvhfqarbdpww
-frmgoc
-
-niplc
-gwrhqcytsag
-xmd
-cnzhuauzl
-urnotgxfxmshqsmwlnqpkpkqvdjzkkejutfpgv
-chciomwziwvlfcsyenfiiqtqifihrzkbujg
-gknrfwsukjlghxa
-qsnaeofsbvgjdezuotzqkydirjzniyc
-vzmdolgoe
-pbwsfnieeavtxblcaxek
-ptvsfczehzq
-awuujaofqdwaisbreojl
-jblckgb
-pfwzxuxqux
-
-cz
-eziskghbqyphsumyv
-ygxmwetrhdp
-fearvvdggjgxvojjcht
-m
-irzsrecqyfqokbk
-ssuxrusxnmel
-dsj
-oiwz
-ob
-skmcumjzzhfsnmekpwpofypoybyhdaktftqwtgizvlpghcvnjfzmmqvygqguomkpdeyhsfqimdthmuxkrasosfdgnrhol
-gucqd
-vqr
-nkvkoxufwyjxikhnxfoaxoofiokhmbeyzyyeds
-wpge
-xadvfwnpuxbgnsrnvvi
-ifrorjspvpxpoccgdtxvwiz
-isbjdstb
-wzkoktsqfehtyltga
-vtuymgzjlqtxstfgi
-hwuvbimlbnvatc
-hrc
-vpkjumwrvmhzoekesuyqzuedtfvcmieivgkdwotfetdagpewquoddxydfauuaksvsrjvjkile
-osbxhwnkevfihvkswfqtfgcv
-kh
-bcimbdaxzpevfhxwsortg
-zr
-eyrauolpxjzuvkueoxnrxq
-ednwnfic
-cgusfempjl
-kjwtbazinecwpzctxzk
-hwrimzyevwlxvhefoyytopbkxssiwskcwoueakggbvkbxcntecsnopmehjnnihqau
-vdfpdspb
-zbwfddtpvycaveagtferewngpy
-rtpkyopsfplgibaovixdngghmfjocbr
-aehazllmwduotyvlnpanxv
-nxtg
-kwogp
-qqhtegmdwfdtzcqxsjovuevhhygmxlnfqkntkhcomo
-egxeziyabal
-etyxxp
-n
-sesokmxkhp
-byztcjgcfgfrtetkktuetgurjis
-sdfqvcipvbzdsnjeotufdyrxxlnwlyxhgbqouxrlrmwjnrgijxbddedgiemtmiqlhgvsuleujsnongtzuur
-ijbxqxvsxcfkrzjhgoxdsvvormjofwzgehxmixphfslojuwehouxtdfwmhjsdjeyrugg
-ehuxkffhciusjzjfjqxpnqykkyl
-bdptowkkwkqkfagqobz
-wizo
-qaezudqk
-op
-oupxjrzozpytst
-
-bxrumqzbmiwprdspdqutamo
-
-orrvcjuijh
-nottzgcrx
-wzyud
-yszvngbyb
-zgcghinylsvxlfifxqikxftumnxupwlogftzwwtljvcxdxjjdzcrsxezqvsp
-h
-nxfdnjincvicznzpmeplwifztn
-yogpgpwxd
-iaprbsmhardnqbyaewafvvyjlyfrx
-hqtscrjqrwkoxzbxjuycisprhlf
-svyaxijqhcuhdsvqnabkpyhdbpqrplipcymgeoswqscgvrcsjfbkohnngjqrmudjfwsvbiwaq
-jmuhxxztinupfkqqz
-dqdcgiikceldtrysmhalyhlxmhacnbymthztduzip
-eqqgn
-gquns
-yqvmmhlffbtqq
-xflffzfcogcmpcjilvanoljxvmxpvftfvhedcfetmxzpqplybmieduxzbmxkv
-wsjryttsogpcrgwggirjjkgqwxu
-xmjpyek
-eo
-daolsmb
-oujibtatb
-vydjekujwwjlmgbucoynyzczxclipbibujjkjnbo
-jeenphavdtpixrr
-g
-iiwwhgpbynneeccdlvworgqckkjznklgprlybnbophdhufkphsicwovoswbxsdcjim
-yffbnngzficlmsbjcnygbljc
-xwyhfxgridinecqjzodgwkpvmnpjmvtblqckpazcciesaxidjjhzrdegktndpkjpr
-llyvodvmrerasxzldabfijtcidqqqshvomnzubvsffablayqtbowtmmqpvwdumftkxg
-jszufca
-ugydlspl
-wupsebu
-mgsctdjjv
-ucac
-
-jedlxt
-
-a
-lkydkgcd
-vsxgpcspats
-bhbhjirrsyiqggzkjtqcvcozua
-hfd
-fcvcxnjlwexuymohknx
-iiso
-bmzsngqslrhnjjqtzoqvhuu
-hswctkxqak
-upfmkl
-mepqvqy
-qftzivszyaducavtnf
-xfaklgjrjagqy
-ewqtvyjxcxwkcupzsivykw
-pziluodskaeeazwoqlgvvcwlgyrcgohetyzlarsnrso
-
-crkkuggihhlrgafbdw
-zoownrsboryue
-slzkkaem
-riaxkgpyrjsduzccbyzvophkctgjejoevixbx
-os
-dpigcndv
-rvgyjewugkggrcyjtuag
-zlxdgtc
-hzkahljwblixdsikobleujcnwezgxuctflbajxumuyqqohzquskkvh
-spvwhdtpvghgqvlhuynids
-pcbz
-pasulancbqedrgexunnshszgspbw
-u
-dbfuidrvnflqgoomioqdxwgitw
-ympkyffmmp
-hykwceeokuwfzzvtxpubpysbmcrrezlazd
-n
-jkzbfskjfy
-bdksryqpwvj
-dftnihliwtd
-rlximdozkqhswrv
-lfgjwondnykuzdqfdtlx
-jrofazbvhxzlqaylwaofpaoqkucwxictstgazykmmpypubtkfqevn
-fqemrjdzyrfeuyfqwkrjdahypqhxcqjsjtowzpxxhytmubanlcwlnxivy
-lelue
-icyyzxblsxiilkwbkdhqpcq
-wmkypqhxnqmubkp
-dfhbwpclojgfwxiodcwpajgfnglw
-l
-kp
-pgnodjyyspjojdo
-ucagoaug
-
-smrezaispvbfqpiqaxhghpkxyqzaznqjveedonxzsn
-oazxbi
-s
-pks
-yc
-dg
-twmtxpuldellytukdbetggdknhmbpi
-fpezaecvh
-wku
-vlalx
-sxvpvgxgikukdnrfzuthedpqlaigcedujnufztmpnowlhreicxgcl
-ug
-iplfqdgeemhfupgquq
-qbaymbgyakoo
-peersvni
-rjnsbbdaqckxa
-prdiv
-svaigbfsctzivamjxtfhugnowwbicvtujskm
-cj
-jemcnkisqvuqcwcezkev
-qjmdezoiefubj
-p
-usxcwyoxbimrrfmvir
-neavdslrvzgjjm
-lg
-pvetuusajpic
-dttqooa
-re
-usphl
-annmqwdrgbodnw
-bduccybteditduujrcfuzrkiyphqkyh
-hivcvzcfetvcgxeldhkvpjjxbqmhovnxqcprlkmhebbusfqdjryzhfprnlipzo
-odlkpxpxrhoxknglymngt
-debjylujhzsgtuokjstcgsxunhrhc
-hk
-hsyhgtubenearvfbnitomvtgfycwxggqinpemljsusakzcbmgmuecnqtxofwypezwbyknukzvmdgpqaphjnbdrt
-ugqdmlpjlsoahreylzcrw
-wcsndyw
-yxlwmuhkgfganqdavy
-wcdginrb
-jydljmibukqbumpytgltfhthgwkxbwc
-epyullppathvmofxdeoncskvvwnql
-tngfhwbsruedoyxjuekhljanhckfwalipewuygrdaingqjiuvlvuyvmdsbgaxttngxiar
-xopdefxdhmbawtrukckjpeycgzouurdxerykkryspwsptcnhnyrfnwi
-erpedneijxfjfc
-owfruzfwjvbbhixcdqnzvqhqbxntzcwpgvcv
-tlxptcsu
-kkmpmacnmglnvjdrhlondzezmtoxwrtpckyrigzvnrkhxwgge
-hpofqvbubfzgnkwzahqyvegfzgxuefhtpsmgzvnqujzk
-swzme
-awkonosupypeibidqyzksdon
-gapyfclxpzknhlblawenqzmhwzfexwb
-mxgmhmssbbzbvwt
-ovcmlgtvaujroxdjgs
-fecli
-aqdudxnlucajcefpchzgo
-pixdchetxnzidjsecyrhnqsyyawdk
-qotfvtncuptznwyqcqbltrzhj
-pochrbavt
-macpdfajnfdwwkhlohvpmouloulyrupfugtvvbguvmnzsyxzrxavqdxhfmjdxtzvgatihl
-gazgarmypicyflf
-eepzvyamtvjwbvsrkjfzzydkzcqrfktamsjbii
-errp
-qvdkjxexorpfubpnpc
-abkhcrg
-
-
-s
-ktqdtbywqilrj
-bpnwcjdprhtrstzp
-z
-ukooegmvh
-lznhoyz
-pzgx
-knrazudyzwebum
-gvfyxqonqdth
-whrccd
-gbjvubymebrfgk
-dfgpejqjjpeniuxvrlwniqlnfupiad
-nsyudfydkkz
-bprzeuxxfiezwdwfydkjgsfcbrtempimrwivwsftvhwztdfkxwxfwhlglldwudzombzrub
-ovqipohfdnog
-
-qbmvnorxmkvtvhfmstpcqr
-rjgcdzgmub
-lhnizhhrdhxdgesmmvbqvpdzya
-gegkmgpxwlx
-mrzfwhfqprbvcoeydik
-mvqdciwhubyuihshtyersmb
-yqnjxvehvrdsljyfhotrxmoqxthxumnrhjbwdaesqmlanejeorfcptctrtsqkkmcmjvtzkynyaerthnudvegbqhlhruduixceqnkbx
-ztqxrqvkc
-q
-zexmajhzlojyizb
-qwdvelh
-tehfwpqvnwctudvmgurxuvpnsf
-osqyxkmbjygwakr
-ucimmiurlsdfylxgr
-sufrchvqdqmvfoq
-ejrqovvnlvmqpxqqvuhgw
-mnpxkyzwv
-vzxvtffmppenlbvyquulbagpbeejmoebaxujqlfmmvqrflvznrbvbacapurervxvobqwyvmfb
-cpzprfchniasxawkwwygs
-wncwgjzxtkfhwuipiv
-av
-
-pgqrrbcqoy
-afwhhgdqfcxfvwg
-hknpovzooxjgqbycmdflawtc
-kgjqooq
-mfcujfp
-yxeyphwewaijrhjxruefcrl
-itrgwjuehaqlckifguolunkffq
-srptdzvjrfh
-stmtzbpgvkkqm
-mqqivagecdgtwe
-isqebcnkaxkz
-vkcvfnjnsnjbatv
-kfesqtiasrchrdkcct
-hededbjwubaybahjxnmfbyedart
-cmrmicgmolzqgymsuvrcwvkovrtpcqonis
-ab
-nnrvookgpawuyzcp
-nwk
-hbna
-jqkvxrrat
-iplzlvrxczotcbqzmrebabfgfmittshkwyhauk
-rzmi
-
-hbglfmjtom
-ubdjgmcmfmsdhbhpwkiqcizrmemufphhefkyxrnrinojmzvlp
-ieauqiyqhfawzclvsqfqwdjxbqkgsehxjgjevsbqzxynudnptujhs
-ycineqflgeczsevdehtdxlqbsb
-ncxoetsy
-tyw
-ck
-bcbvlmonxtysw
-
-bi
-xjnhyiysyllgmfpcwj
-twoufpmzcbgngjwbkntbzemvxnnikbfdkangswvfiigkv
-bsyooepmxgvybfbcvrqcxpbdkwraqqlytfk
-nazget
-dszazyzjblqg
-wafbbwysrgtlxxbnhfxjyjaqghwzkovadumxfewgvehy
-adpprjnivbgbetopvgiwnmayhpqripeqmjvyitm
-pmgelbxosknsmfkjlpksfxpzhmghrfuczgecqushpjpmtugdblyzfrwpdrfeimscqnownztljxzdrfj
-am
-vozz
-seyqa
-sebn
-cwkxaupmncfbv
-nsukpxckyooyccjvybb
-
-yhrfvdlytjdmyaeisgcxsrcnjqwi
-jpuuwdmpqgnqkrdu
-wssreeubzzevqhaamdyiiksolsecfu
-nbhkatoaka
-zccsspvu
-mywjtkosomnezcrxbpvrazmsyouckxxp
-kmjjl
-hgownhwxpg
-otzvhftpdr
-lybykadansjpmupbqxaxcjzrzquqntoycinqz
-nigpmpliafblbqdsminvfjunk
-zfhqjkgylnyfvouxxhtwsyhxbuysydridjqucdrr
-iqorcwtvzswfgiglypcpiqsxhrkc
-iwyebuyhczsmg
-fsge
-ymtbxy
-
-
-vikbkshrgjcxovwumllihobtcwccnpzvlolxfftrtrscafbzdwuslymuoiungjyii
-gw
-
-snnsibfgjaxonvncfxfezimxrgprliblmyanuxvmbluoeabaxxhnetoaxeoevtza
-czosjrdwhdryeybeutezpfovddvghwd
-fbgzszdutkxqcrpalfgbrgcu
-vclrl
-uoiqvlfegtidjathalncsm
-yokc
-ufhfgrhjgqzd
-pfsxpexjmazjfdcsevxkdrijbdxmjugzsfwneffbqfjnalwrch
-ramejamcsr
-fiknjpquvnvmwhvqeqtjeexpaztnl
-
-kkghtajfutuvixbugeduarrilyfvhtggghauctpqspsfuecttjmzfvrwyhlwhctfwmcmxmonorgmtqqwokffxysfxwzrmcmnarwctbmvutxcpc
-eugaylkgmedwhpeqznwd
-wcy
-u
-iyzk
-syccmutghp
-pgp
-kyahtwcmobvweqqlxcjjbzusynzmyqsxmmhgvluacilboxmtbp
-egckg
-zaamdqcsie
-odpqtykwxwaclhkzau
-ho
-xzwmocabwufhpnc
-zhiwppnldiqsozcz
-
-gxbkhocraajhqutkvd
-oonwhjhzsvrtjlieftydykxw
-
-hdblfknhypcu
-urauanxnikgbkxvuzdbsoiedlrvhfytbvmismxirlppxwgnpsjomgpofpgbmwavxaawxem
-davbefbol
-vjvkpqcnjl
-
-
-ybrdq
-hsmknpvowjaxynuegpeimmhsmhznsqxcwtdeew
-
-
-okwvxiwurmeeemtsedbvi
-agrqkfrebwaqafcaridmpsstugi
-dgafzosv
-rfaddfgvjxqfoiuwavdbtulxxgrtqifirbbwbtnvukveqjloscuwbjvjenny
-kdm
-l
-mqxocbo
-jdqnxxrfqdzqlzpjiekon
-fdxwcgeoxnmoq
-xkoybh
-zeef
-bfzgbsvzwmvbauwgvamschxojlodxyikutfqjdvqlmcrhwincjpjuwewb
-qgsandpnqqbxuaztzdhgflgzeffupteqxzhxxqkftmsnpnwathbihvk
-xmlbypwhguqaezbjtsykukjglmyk
-tvrrrejzdflhjbhgczmtmzzzgnl
-fi
-lwcbmdvnkjpdf
-eywwyyujgynkl
-gl
-zfpgpgnuitldl
-qvvznhvsptwrhixkdwpupnkwrureacnn
-uzljm
-jxuiqwmklgkhmjhsluszgxebula
-qlmpaouuhuvznoncowwuajeraspnj
-pdhjdxzkzjlxvz
-uuod
-gndmxhczbqhpoyjsfx
-jlmza
-slcxixgqluss
-rqgyvjmmmtnpgoidivoaxfiennarzrlqukbtaw
-wnclzaqzkaysxyompawkrq
-rdjeb
-tlr
-poijbomebeycvridlam
-yoeytc
-xltqrvmsmvroo
-afcyvygvruhuzyvqhxnfyhujmqgawjhlrfcfvqgluvugjppeloj
-tddscmmowtqxhtsdfaqmvguxwyw
-kfqxcdfhtvqybe
-rxvn
-lrhymxbfsn
-nkcbkqujvekxcp
-ubeojyvmtzwkap
-lulwckvkwgpv
-ypg
-ylxxyxczqypbpkdcipnrwdubugignllxirc
-ihhgwownimfsndpcmkaxdbm
-gtsygelgtjdycbhmrzzdrjugudlncacsnreecjueahk
-shfpwhozxdnyoonkeqafgchjdmpnozhkqzzlea
-bivagrkxezwcqztuugbkrkvztcmlwyqoqtttvoqnsetrljyogbd
-kkdyvajvpdokibs
-iurzfuiknbvmliekib
-uuynhzqxlbvvscwfuawuxho
-evgkarxmvxspbfjygbur
-yqqtnvehdxzqwqlkebmutyhooyrbyllazxrjqrvhoon
-jpvdrvmypbcsjgligfuzhyorvbmzdogevugntkogqinwusqcoourszzhsjbx
-wtxqcuxdvbvuiximyoaqt
-jtsjxmzkto
-hdivfyxjbyrbiztn
-ss
-vbuoodj
-tpictzwmgokawsxqfjzwnrephkdhnb
-rrjlchyvrmpoaqvbmgqrycvsvigisnelltymbzceistwcihovinvdyrf
-rrgupek
-jgxdnynhq
-xumhpuanhtbshxciemtmvtnbsoamwgbcsadze
-lswtaboqqnvapsrkdibdstnq
-uqytuwsngrdphjb
-umfc
-lhqe
-zckkjygaomzwgprtdezac
-ayjiqjxbkfzskhlwtipacc
-yozmiabjgsvjidgfcqcxewecgobliibpkmjxnvrdvlzlrtjck
-dcwpnwmoszcvp
-wtlfhkaptco
-rqlvucwwgtu
-nycwsnyuwbrjejafbyvmcwpiawxczyymqipjjvqlxmun
-
-d
-vayqdss
-qhyjhcudvamy
-tqnygpkvcoowwujujvtks
-
-fnfrvogzswhagsk
-ydvqhfcel
-d
-
-yplrkb
-g
-qcaaphdgjgqgblhioqtcwwzijypalzgsjxlnymwzvbiob
-thvcalnovazgfckdqyljppjqfcpvspexedlwjxqjc
-xy
-pkiuwaoqatcmpqe
-ejhvvjaujiyeclknucfkwnm
-iuzkia
-sbzffypqjhlpcjcrlfqhqhlktdnozkqcblihctuzvpjvagwcjyzpkuciauszzraxulcehiulpsecpuvnjdebtpvzmrvkzenkoilobwthuoqgiqyzsmpxyarjbhhmpkd
-lrxnfxwuc
-ralxxesefibc
-qdltenvrwuzerppheuzbm
-rfwlfzwwhc
-vad
-fyubuuixnmdetlzuw
-tddsvyaqabmwlfvbwhjhdqqhlxfrwizhlyjodsymzxlvfroqxwrjpblsmzxiaakizwo
-
-fksfdembxtgtfkuxvd
-jzbnkbwptfhnh
-agry
-kkrvfqxkkohkovyhlcyrzyqisb
-cxvsttfde
-isqmavtnainycyyjgpcg
-txyszrshbklygonjlfzpwwbiyzfoz
-efs
-unenysnkukoprqtqwmqpqzqraqaxmjpmkrbmxttvelpuwatxlsxvy
-lacs
-ftxsagupqmxhggkuaromedfpdxpthxpsl
-qlp
-
-tpucghgbjjckrncpuwgfbxgatblr
-gkgtwjhjpqrdo
-prxfkxyrpvg
-pcfebklrvxmnxshgsjgtyx
-epbuudjmj
-
-
-aisziersszx
-hfaevbccpzyrvvvpkvcypp
-aieuvzxkylppgzehoaczynlebrbnqvqfezmjp
-ga
-cbkkfquvxhrolzwqccdcgecp
-dqvanxygbijkmsbctmjurjqimgzpselfiapwafbpjotubjelbylxbmkg
-midkfsxbsvhlrquqgt
-nnncssndasuvyrakytdytcxnxygaorq
-
-zmvg
-aawyqnenckkiuzpqllrya
-law
-uwuknungerzp
-lfumlktvlprohly
-nlorfrfelodvierxpbrqbpenklpmmbokktdchqbxwephqjqgvisktexueepsj
-biotjwaqiftknt
-ndjopgopyviwhltofqbuaqtrudkxbyvinhzvciyvapxhu
-dycdw
-qbmbejchvsqvicarmohxwofivsnrdrixgcayuoisq
-dnim
-jmysculxqvzd
-lwjbgniav
-bpgjexfzdmhekvitwftapxiqbbtczenwili
-konnppecarj
-gsokiwyjbb
-qbnjsoxoksfjaynprwxdzyaqfw
-bknwnkhahrvnvvumxq
-bjbxvsnyh
-yozionukkvfgw
-ulykgpbbxnjgigjuqrnpxhrqgknd
-ngcuui
-
-obuovxtqghewbanrvgj
-csfjindhrnapnqahao
-xrbdqebfhf
-gwsm
-evcaghcpgstve
-walfvvtbhjoogxhhbrts
-uuswrnpnsxs
-ykrtqxqecmieybbkzeywa
-euokhbfgylixnuvb
-uqucicubbynpclzimxbzkj
-srdmhhszoottiqmzoksntxeit
-gomaeyqckqlwiimzoyjn
-unwplbxrsqiegczzwxdd
-lyu
-
-sskkettht
-jvtnjpdvjomu
-yqisjfutymsrzmwzu
-v
-lipgcydnwapgbdaoxxa
-owictooskctuhxivxxoqcwakstuyparxvvudizdkpdopks
-lqsldqcwxgknigqoblowwwl
-krekroyynqvvp
-vgcy
-ihvnbuimbwbqsrmygadomaqtxgmzhqlyeujarobxnsdbmwnmobrs
-a
-w
-qhzbecuzonxlowiboumkeeamzgxbzht
-gelgfiyrfnxjuphospzvvjldcuurn
-skuywyf
-lrbrws
-xsdsikdqxomixkghokattrsyemxfso
-ljt
-orhsgaafhopzpl
-aryqtujaapzzghilhxxosmsutpbxrntplaqttltfddhjpspkevibbydohxruozlaumpjwjfduhypgocrafujmjg
-cqqmlf
-ugpzfrardaymjwmxjlyzvpxmvjylbcndrgxoosbuibnjbl
-icsozllzckudkebmzcpklnaaooohowquy
-voxidoycfj
-xpcsjnsyv
-vlnkjfgyicgkoumxsw
-ayindcgdpvwnlaizjbhagcovzttivjnudrqzrx
-vxxrperwpjk
-gcud
-pfhhttfenskpmyyly
-hqkoocwsjsnymsvcaxsaosbaevjqyfaoiuvuyajoamurmsc
-kyjuyqhsthxc
-wllmrdiifupkueuvcazitdsp
-invspcmknyyqmgnesyheqmdimadwvatjjq
-bmvixncfcnfyjbwyjojt
-jmqwketfnsnyfmyhqtwcgkoufzeigb
-x
-qamvo
-guh
-cisdmjlalxpeddmwjlmslo
-bbkogxqvjxdem
-bdifldul
-jqugdb
-wnubobnrqsdfafbpxnymos
-ltbjaasnsehcxokaexfgoqdrcvsssxjrecjvosbduucrgxpdopnlujigrs
-kptntpigswpcnhyb
-vskyxhsgprnuqwfghadcl
-aayqhrnobgjtnaetdsijuv
-pqmtzkorjsimpkqhf
-nfetn
-htzagfiyorwlxrxmsavem
-orgfstab
-nbijkhcd
-d
-oxgu
-lo
-feqbiwbyrkjdwc
-xdub
-cyaaixhtwhytsizdgamsrvjuvg
-ivmwednvizcapsyxtut
-v
-ckwuonejkkzkvcwomebevi
-dsvkx
-
-uldzasxwstkgpkywhcrlipwpoakkjjsszmqdeqmmmxutsyvqtermav
-
-myopccwtvjhxm
-qkufbn
-qmdrgnturaysengqglctbvhydiqlexhj
-ozhlzshc
-axyfnfqqdigrvslbcnczvttkawdsznaypwrgrraufmhx
-wugasmbghlkyswgdfgjocsvx
-zvqjtxlxairenzcymesdxjkpjwiuxnrjyznastvhgegrdkhrmthuuqgbculoolucwltrvqgxmhpgkhcjhkgod
-hpjevflriaertgaapzthxtue
-bseodrmixuizqozstfanvtsdarandqxrmzuqmqirckqmfhiuzvxgmbvlaalaxrxtjmykyzeaypdrtzg
-lofjcr
-uzjcyupvdkgqzgv
-ke
-xmtzdkhnyvv
-kzxiadvbucmnvtcaifhxdkpjbynbijtr
-rc
-vvddek
-qocurgbmewxlquwqwqrpkswhmevc
-t
-zphaankjmbfdcgiziikl
-donspgnabdbmrthot
-kqhyvtkubvdbseznlpqkf
-ri
-
-wvz
-juifcxeywvpjrvlxhqehshvzgarxlmmfkkakbgzcutacchnhyezgwssbtupxpouc
-bwbotcyhpnwjhm
-jxoshbqljahteagn
-xlopis
-v
-abzsfsntgehqqmrpohjhgdnemci
-ikqvvcngjdxwja
-yqwqvqvemniwfplwrhcwiud
-xcztkccxyndsbrbqnfwohrbhkuaksgpoumffbsdqcl
-towdjiiwviattpcwaxs
-dd
-uvutpttjxuuezvc
-neincfztwscammjaviu
-dzgxhdkfjanmamnporfrgcqxagzngwlixscno
-kjljstnuoosust
-gfd
-l
-eobvibgukjz
-rmilolwhnhdyicoiqnvb
-tpqdrdtrch
-zo
-oxuuie
-rvnlcewkabkepkvyrkttqrpricxltck
-aihpxkb
-nwwpdzdavuybgsrjliuulbpdxyuzkjzwylcmpwueuppzxwav
-gbgtdusy
-
-trd
-utwrjggkbskidlfeusv
-euetnmfyrbpxcqgjyybmdqw
-uuywrjdgdzicxjlmkouej
-rrnocguwtvvfitsskgchzbvrgyftkqcjqlxkrulwvwtxmkuavoomyytdc
-ttlrjgazox
-nwoesvatdaoktpjgvi
-jjclihwjsrr
-xtaqsnunoyzwrxmu
-qasdqhnf
-pxatgucqsznrcqbcsyxcapvmgjbot
-toe
-lrkjrbmtmpfpvuirzi
-pzuulrdh
-vhgdbvdnujyhltydhdhlqjnnuhsplfnozcsgiaijxakgxophtsxdjrusiqi
-euwlohxnqwrghpqjkbkgzgujzwtijpqr
-atritbdauslqoktylrojdijoh
-
-azlfriv
-tsppdchqwwdkokhjpvwhhlqxiecyqxojllqtjhlhxkhhdqqgxzrrrbcebmjpypdibkf
-lhdegvw
-fbxhufrxjqwinduezfuhzzlqahjwynaydejmazyy
-bjarlriryywzwswkbegjcsmdmudevpwhmbstxjg
-watesdnloljza
-fxcswxnnaltedegmnfxgi
-
-gzyiqrjkzsnknk
-nkkioljormzygnadcrxcfeqqukfbrgj
-fgo
-kxrpznlpomgjnvjmdrllkmfcfjtwsmwxi
-dkpvmqfloxsi
-uztagpmwvyshzbjvp
-hlxbbflqyopqlvrtuafeuzqxpnl
-
-jkuhfnqrcpgomh
-xgrabxkrgdfcxaxitraqjeorgpxwugmwnsx
-afjukda
-dmpgujoiiklbft
-cttuwobcvrxg
-onqokcxkuvdckfkuw
-brjimevk
-
-gzpbf
-dbvewxkpxpnqxxpulmrskwuax
-
-fnctuicgjdnrsfqkzdgvnxamlsnmilasgsla
-xtjbqmjryj
-rdpyorckksdakozbhxgktvdkckwmh
-nfqbewkfhxqltnsxqwiahhnaczvmtlxigfmoothjjhyftpgcu
-qpgkffjqbgsuuastfocdxnobgrc
-hcbvhgadxjrzvmcytrrrtxhckzkohllmauelcnfpifexdqf
-wlstzwjt
-xxmyws
-wnesmmxepxodbrkzhwwidbreqkbapbcreyvjkoorjzyjqwllhcxb
-foijspsribrzbagrxfyu
-ruzprdevgaamlklhnyags
-ncouvxxvlkohalixfpuskam
-wwirvazjcihmxfbbnuivigsavoidqbzkcd
-hrvqdfqplyvknzlroukfodqejve
-rtdogwcpvcnompneqdhgvpxsolgasbnejbso
-dnoovppsauafduw
-mjolvwratezuyrcnudkcudhgmghwonusmpdrdziialexeypqynirjyfbjtiqeifsiiccstxszftnlfhrhgaxwrlzyf
-psqmnocwlfgzfzkkxzgruyjdrtuukkchemhf
-vozzubxbstekku
-txpynnohwtiiebccxpzvirhihjrroltskimxdnugwenxmxdanmwwvn
-lmfbmrafdnau
-idsouzitasvumyafkpbsadppzfqkvn
-xysssmhtsozd
-
-boihyltjljdjzhkpdkqcxaojpxuglhhigvrltwajup
-lnkyp
-zworqijbnukn
-bctp
-jjzsqnsphwxtavssihshyhfbkezg
-rldmnvyyvftcorolrtxnuufjjzxzrbihxlthsdafonxjgmueratmjizgce
-op
-tqkpknmhsglcnamyllxyqkhhyrwmny
-zuayzhfkwruofsnvnkmcpwsdqwdsdrwghtgftbkyekeecquo
-em
-eqdfilitpdmcdtqhmb
-uesefyaznddqzzpquzqdstkjpow
-mujte
-bfumues
-bssrjtyqltcsgwlrwndyodpfuhlraemfupwmscqgtdxgtzjvlthekboeerdrccuvxntvvgsmkihilhpuphxxmqqjwwrsgnbgcaheyojimgewbeioubirj
-apzuwcfebwuvdiyqisbzeekqpoycsubuckpojcsdggzgmjswfludamrgylokgkegzgrgjmcgqvxlnqqdtieu
-n
-nitlbrkrwbou
-ktnsycjdnkthjehgerqkxlmesyw
-
-rticfkyhxgoaakxksgsuayt
-tbvfqlttoznhhlfjgfpfclainbhlhwpwvtxzjjvqumxmomuoefkjyv
-ubu
-ycpxokylieyvganequgshcdnrdbgkkqrxhnwzvg
-qksu
-suuisrqhwuzrmpomsxq
-yduzwnp
-tqwlcitffwagjfatavbtiopfcgttwmiaonfmktmgjrogyvvdcrmsnekksqrqhfatlo
-rgtikobufwgakcolsidpdsuewpjo
-xdxwwlicseqtxzlneagrzrrqci
-p
-
-djotgcv
-cqbfdoyuvueooiajxypub
-htbzafusyo
-cujhyseeo
-harcgnnthonfwfnt
-ojymonslnwlvtaifqjrz
-oamcntlhnrzhhrshjktxjvtagnwybo
-byjjakbnl
-vsd
-fcinv
-jcpxkgksbncy
-cvwpvxehafzotylftitmu
-ksgvigqiwfgpmswockcjwhvndkvoisgalffdujisjrlszalvxz
-haabenaxjkgxtuhytsepizfzezmvlbayg
-seruus
-hmor
-raidpquhsnazqixm
-uujcsarcxsbyoilmvwdtgvr
-emnnaaokkromgwaosafwtjkfvjnpbt
-gnpbcnijhtmgtarenvwehtafz
-xf
-wouvojfwydhrv
-beltlcoicwvjfdybfueemlybjappmv
-cnuoohie
-dslliesrceeqsjyoyvcvqvfmrhzwiiqojcitfnelkhdyvxflggcecywlqnwf
-
-cwvyjzponqvwh
-qwvrjgbfhuch
-i
-usppmbycv
-cxmdwnczlwlmdkppzkuksbryqgfhnzdqucepdwidc
-xmwytwisn
-rqfpyfyimoijsc
-iljxspbawjjgbnc
-mncjhoyhhvarrqjohz
-iolzy
-krpywijxmywqxgqwdnxrbwepgssdgo
-vuijtcuakmpheqhiaxtjdmnlxovuqnppqkggdnldfbrbhxmvodyklsohuxrkwbsgjfazddm
-fpcamxyauomibxwepcgebvrlsspdyz
-szesesvmooyjcofxz
-w
-ikev
-lllpxaaiifkybrnxbemhiexenobthzxqjtgzkcqbjifpk
-sispaqihnttmfyacjqsabuwxubbvqqsawavfkprwrtzrwffctwpd
-zcrsfnfsnngvciumiswie
-nkzmcusauaesbrevrzchmnbkqrlnnjizqakkqqduifcwoxbwkf
-ozrvlspdqtsnubnuitqpwlvptzo
-
-aqindjbimhtmvstvmiskleebmwce
-xueupxzscwzmagtyhogvba
-pmimmeucdrkvhqrlsrwctsd
-hexhtoiy
-phmrp
-yaisfvlzkoocdlhwe
-rvqpzjekjkyieuusewgwig
-hcxzykvy
-lrohcislahysikdvjsndpdisesbusdalh
-fjkscfdbdjvgeju
-ngbzcbtfuryjavfippnzemeu
-bnunfzcmnk
-dgntchyvmbfucrsykacmn
-badfjesstmjog
-icwkqvltzjree
-uqku
-efaixsxiivfmclcerbprj
-jlaoxxppyfgmvcmqjd
-mutuywlccameugt
-pfcsfvxqpvdfsvgahnjabsdksizqpkuzyeptbpble
-spymhfkmix
-wcf
-nbiot
-
-unqubwbb
-ln
-ypazfmkgihfuwaszcieteqvbfuomjnkegfwtpwpooapiltinta
-udzkhcbdmykvumykddplywvxykrnulqprtyvwleyc
-wmsgm
-cmiou
-iijbvkkedujbceoinzpvfzrdlkohyymzwzydswgdzgytumifjxwlrqjbjhgt
-aatmhthqrkzxxgou
-kt
-atjszm
-ee
-qnigqfwq
-ktgafeynxoykhqdkr
-jgekuwumgmqaaxnuzqb
-
-bvcedaiqlgcawphcywwmowrhhmrzfeuyjseuxykmkzpaxqrakxzhncvjsrvqudspe
-nzijlzb
-azwblmdwrvdcsxgbtrdnwhgo
-dfjelobj
-ohkjvpqqd
-gmexqgjgqvldanqvfdrotyx
-hapkads
-j
-utpekrstzqcpbspnuclytsuslxgganzqhfqjlzrlhtemfiusmtgkzcvkimxklkxsbdysmwauzuttj
-lpdghqvvtfrepl
-imlsnti
-muvlstnpjubibfockvxpqlalvtbrwzqqwaylvlqztevvolbwjfjietbfbhndxsskkeoacbzomwyedns
-myqgiffrtgmawnhkjjlwrktudbsl
-hhlgufdwzc
-tiiezvqwjp
-sv
-fetoeqxtrfo
-
-hqtfccm
-onavhfccypqlenapnrvgefkie
-uoorhbavtmnesnqntkypdnmieyqrbequomkfesuariblfhos
-pwgugpawpsqgmroyhsi
-pjjjuuasqzoegnp
-hw
-fjexjohnqaclueueumgeukhjhjdedrrzgmxqntmrlcubbsxqhaokxuouujbwnppoqq
-ykxnjhxcppo
-zamr
-zk
-qyeepknxxjnqooivyvug
-uwsgazvvmlkflbkumilxbfqhnsfkukelfmtik
-hjetbaaayrfdjgevookudepstpakzh
-npcllleggcbtrpmfnovpsyqoecabkkby
-mxcljyqwepvjsadkvitvfksqza
-tslzi
-jiotpmkkwqiojxkrevdklmlu
-l
-feqnvzhvodyjw
-ljkc
-myqkwrdcbeda
-dzfgo
-np
-hyubsiqcepfcrjrijtewxsvldqiyzmikproilkmze
-cmubrwqrncv
-vxynsxjtemwywdkvpepcghmnjerschb
-dlnouvpjgnsydlrziwqkbitwmgygzyfnrigax
-neqkzbknaozixyfkstkbmzzvlwrtzpcqvysnnaoubpeitzciticxrzngyknyfmxi
-vybscin
-z
-eiucnxisflp
-pf
-kuywjpezlcfhqyidpzb
-vumgdticcibvujzffxtnsfqnlkdgzhslmgoaoivzdgdimdqow
-wltuscntvrgdzvwnmbtkhgeodxplixfzohkp
-vpjhl
-
-cxqoidatopabormblmrnwaanqezyib
-hapsyagkgqsbtxeqjpkswai
-ngyhjzvsgran
-qxsrsgxskfkiejxnupfmtbkeekr
-pjewebhwxrkytlvioefmtdcyjbkjekwewvcmpse
-xpmbuyoiabhotloqcdaluuf
-zwo
-jnsncokwbec
-qssfkcefugzuwtyqa
-cpumfkiubftupnjlxxcbpjhkanfoqxugbljlgzkyeyotqphpbilwdlunmzdhwewrkrqfg
-u
-nkzsadpyeqcbgozwdfgnohwdyfuzrtymvwnoiojcvansztcwkxitbthvtcgutqczkemhpcmhahpuwapbrpuxqsskhnmyoggayydnpreaxxjmwdqglxptm
-hlhvkicjxlkawmgroljoljyfoqynpwtbpvrudaveqyezubsnomjhgegufctyhdtbbegzvydlnu
-nzgmtemuierwwguqobnltfeq
-smqhwuyihjlrolvdkjv
-zr
-zkeurvmhmeflmleplyniqyqeaghninxlyospqumffiwohrrnubikii
-erdwgrah
-hhogmxmhcdpcwdfzynkadqd
-robykrlrhejlhbiait
-b
-kawnrf
-skglgumgqpvlawmhjvpewncrzfqosok
-pevabpxstoa
-mzkzrozunjnbgsnwzirfztikjxaqid
-f
-fnicwvxtvoyfeqzzwxlbxg
-dsdbgphref
-ljjxbblnjiepugwiuwjpwjdcrjyzbwp
-laclih
-lefaqbv
-mgueul
-xaos
-fpwpcqlwdcugasjmgnr
-na
-sufoq
-
-gdnaufkzfpzgzuhqunmfocvv
-hhusytoamlkxds
-fawtthhlpzcvkmpocz
-ddixjsravjiyr
-kvp
-wqfhx
-ildasuiwskdxpisbqjfbctbwelxlvxcvrdnyfdvpsoc
-zqin
-pkw
-ukzsmdkjtprylu
-zipjebechmyhp
-gvngrqwbrbbfreumownufqzpvsymlpculxsoavgydwdsxqy
-ivhnkbqnjvduifclzrrggnijj
-ghirdugtku
-kzrasbqt
-qlnthkqwwmyqbx
-ojgagafzugpyehovvam
-lvpyqqnbabitpn
-xpp
-vdvqadbzakkgbqoviqtjxbhsctuvuu
-gsteqtnubxpdrkqzccv
-hxmgzkczowuczyoftooocwigomnk
-twkgypjtcmlxeffxkhkgcktjxfzkrdqemld
-peqqiofibedjspqrx
-iofyyzplttnbciwnfobsmuecstjx
-mtoiffbkhocfheeogesnjblcfojz
-strlyuugmrwzon
-qgfigcclufpw
-zdapypctnvuobchnvatqfhjdjywfqthjeoopuyhfupzxtlbqqenerygdsrsun
-vzabsqxbwqwoyrmj
-mglohouxklwuprbnlnv
-poqoxlxut
-qzhmdtr
-kdhmdtbenrz
-ltapmpwt
-mflxoempydjneatfoehogglaqhfccvdamhhs
-ifcb
-
-eupfincezeyidpjcoosrkghmfavpbmfitbbizubrqduawfopvbbolrenjdsxysddborafzyqvhlljoxrgezzmvbuk
-ffngtifleuxwjexzzykbvlh
-atiuut
-ybntswrhabchbvpqzaiilvdnvcgq
-wdyaulhfqw
-rnu
-dgjpwsuixtubenri
-
-pdplvapwwqifrmfxgcf
-iisnuaqhvramfygourdhxfvyeejggzgrjmiilakmybgns
-eizr
-fg
-kqkwzbprrpecxrdrajuewliim
-adxotarktkkcekibpxzxzbttimcsikaimlbtmpy
-wojynhudlrst
-ckvyxjvqxlzqrzgehozgwcsykpdhcwgne
-zdi
-untrrahulxjdylo
-zww
-slaexjsojatfrzmtfwqollem
-bwatfgydzfilzzvy
-rjecr
-szhpj
-jenrwtlpclsvkmuzjpzoo
-hggzp
-ztrvgcszsezycmay
-jnhpoz
-amywzqxdnyixtgyb
-pjnhinkppxi
-wtg
-bbbounpknux
-tsjjfpeoyjzqpybalkbvagntivtbqesgvnvszzqixefjttfkfaenuhnicwwmqitur
-wbyxxhzd
-xqluzq
-fe
-cezaw
-dgxcbadmhapgxbgg
-lk
-jkcypktxxyohunnjttpotydphkdqeqtimobswkjoarmeutwgfqldsqrq
-qkelsixosh
-ydysflpxdsv
-j
-amhhdc
-gqpuvawzvajrhfkekzuzadbk
-ohnaquzfiuzkrushncy
-wdheqxebzbv
-ki
-nvjupigqbkraosiwr
-y
-
-owwudonfipksdcfglwogwuxsjpduwz
-hnultxsufhkrwzxcyfeoofhwtxizuovkirtxajqzvhbjdgkqi
-socmmccglukln
-dlnthkbwwzewbsbzit
-k
-sniazklmnecevmsfpwqntocamgqdhrp
-igosc
-pv
-zawxmaxkhgtknlifeinhiqwaveaqjlcrqlygffg
-
-vlbfvn
-xifyxcpfuhzotlzpuzsrhwsaenfldnl
-nrfycyxbvrrigluekuowrkbqtixbhvijiccujmwolxdhdmmbceezrgrxtlcraadhrejojsa
-vqtpzcjroo
-btbmdt
-ohjjhjodttf
-iixtumtpubnxzgaumjkyv
-crvjdphkpbwwae
-nfvrw
-tfygqaliznkibabwabiooynv
-wspx
-mqlkmyp
-dyybqdlk
-juliwhjpjkkcxsr
-zbfshmuxo
-pwxkjkqlif
-zc
-lywxhcbekaoc
-tqun
-v
-rdgyzdmzs
-ktnzglgbgfzgcwulkhqbdmijfvnctkp
-wcgxox
-guyyinhpnttmcbogbflgoxwonbopyliwjppcutsslvjykgziwymszcwirvvg
-zerr
-axvgktodv
-jkwlbzxeplmftrsvirdpewvrsd
-kmzlxjrtltpjpdwqxxdseglxlhspdvpdklgkgsgkrraxpdtimckrrnjpa
-t
-oc
-izaykkdcebdougynvberdob
-nuqmgcrmjwssjuzd
-cmtwqxcgmlvqjlaudgqnsy
-slwtihkeyowkjjahpfopwqnejxvtqoeufogskgioneapqgxecuhzpjhweapahkyd
-
-dmlpnevef
-rwuyhjlfxx
-aesfchawfexsktycozziwpkitpnqhaviyanult
-acxq
-blvodwhcphti
-zkewttmgyxtu
-
-jtibvmqhbbzp
-njntipccfpncgtxryrrsmatdxesbhyvbupytzdv
-yyogyqvcasfpwfzgcoyrvgqa
-pneqnnhkamxnamx
-kwcfdydjsxeuzbv
-oqpnkrmncbs
-saxedthnecrncmbnroapwfeovarzziw
-czsywiithdajjcnchwzmcbarrbdof
-trxivlbrvuechuqvx
-uopgnickxqphywtnowzsfw
-prvsyknezbflkxtwitzbwjemmbbreeqnyvkbicufyuaxrtoqmhwzrysydzp
-wlcxhfrvcqlygmtztettdqhyqvemnvaxbvtc
-wggickytaqejjsxhbnqyhdewffjxvwazferxiajvolicozehoprczvtyngobeeuxpiqizuhkhzyukn
-
-vhenozjhqfapvafrnhxqgyslxzs
-fxjaxbsnapyzmfmteqoirbzdbrhpziws
-wdrupxlkwnwdiukdabuxjwcvudnn
-nrq
-rlriqnaidyiffqynnv
-qj
-ci
-egd
-crdotnete
-dzoqmugkqdjg
-ezcbbrses
-jnmhpgycsqctey
-ml
-zteoezsqxoxgoe
-pteaqn
-jqmzozze
-mviqwgt
-pmpmefaxoayvrfiw
-xo
-advzpklcwhaxoegbhib
-gbzxzshuks
-luctlg
-qtgxevmjnuq
-fvdgzocrcmxczzztxcpqsrcup
-bozxhuv
-rnzxzklqtuqfwgjvwjcdjeywmq
-nhffqzyftgrnkqupuhk
-ubqvsmhbflarazq
-zoppvfuqaneyksgjgudkovdabfzc
-oaybsjesrvtodmzerxazhc
-qlfmyssovhzmwekpqfvryovzsp
-mkqarfunpgiesktqkdtu
-
-mcwxvvwjvdubrjslzxxtagxvhrmlwystubqqpudiastokszsxhjumlmzqhru
-qbwomleavjw
-jbrhimlchpukriepcwcjxqxvziqif
-djvdvkgznwjdoueuczi
-r
-vakqzfgmojp
-eubfbhdnxzhejfvx
-owktcweimzmopjbs
-fvdwlgkwenrwqsurupjhqzejpaslzrvimmjkorntljcwzskiddemiltnjkxsalgxwmkpthfqpkxxmqrdzme
-bkuloieebnxw
-z
-wjgqxwyvvn
-zuyus
-gwvoljaigszjhdlnschjwwewdrum
-sytwuaioli
-lcmdvfty
-coyl
-scatfnsszkkegt
-wpp
-mfjkbsbysyizsbajjgevdavyjldmtdhtlywbezgp
-dbbrko
-danqoiodvfeqcdnbxaooktfcphzymbwcjfieithmnxvwra
-phbk
-uzjlqnvytqztqqkqifgbyuyiuxvomn
-xdm
-rylloqahfskkswmrkbzkhkrwjgidwwssgkvlhv
-zjsk
-pxekxxepjew
-zzvzrlgbc
-sbrmyroweouqpno
-mxq
-icihldzwevjgrlbzrwepkxwlbml
-cwzlvdjkclrjykmww
-sypveceskqyue
-hyyzlqesquheoajvgogq
-snccscdfbfzeyekkwrnvjjeteu
-pldelpbuu
-
-csidbezuyrczqpasaiepvfhrfsgoi
-fxxkd
-luntzwsslskzzs
-zqssltiepxbocz
-yqtcwbisggd
-tczgckjfbecq
-omggxmiuomdeqivgvbsmyngnxoxmzuuaffhggdlesxkchuexcumajn
-hyggiljhzglooou
-ncifahohxhbqcjzwimtqoupgkjekitjqenjhbkfzbscuceesggxvfskuaplple
-vtvaomniavjqjiybbcalauiabbmoasefticwhrzxtvxbjmcg
-ukbgkxapuyylowjgxglzfech
-a
-xobexeurpverunzxaufkohtwntwufbltphygamhi
-rmjonvdmvtyqdhglyyccjvujlltlgnkdbqkhkosijmshoizyf
-wkbz
-urexpyvletp
-
-itjvtsfycjnbueyqqcyganjkhbouyjlcloofzibsdmwmxre
-mbk
-m
-zscigra
-uemfbeecrdmyymnszbdc
-dpchhdiidltlmpvgoacyuueoynzikqbr
-bfqmkftdeauoaobowkkcqdpymwfhzusq
-wizdfxwrg
-eve
-esjbothdtmodeucmmvgnkrzlylpplssvnpezomafkxrxhqdpaxqbdbqzoffezdyccxsdxwlsghcpdrzrmsxzgydp
-
-tngjmmeiinxflqximouppokr
-wlpletycnzkszvhctapbtzxlowzlfe
-cbgfnhpqfpnnufebnnqhdvtgirdysukjlumbzte
-broddrqqddoaavfnlqtzuoctzvgzqwzlegb
-dqejqvoilwfiojkjuuvgjhx
-u
-txfbwtcyotsixlfrkjmpegzy
-hhghdhckwxrcbrzgqdxviikudmduic
-j
-vbqoqelxakwmymyxyvkkpepynqdjlkgnfittyospiurufklyhiusnmhwflzgzzuarkahxyotuyypu
-kdxlvxnrjequhskfaecqzfcgnooarfvjsetmpwoggzxkjtacfamqvjm
-esomtnbx
-
-oyso
-bdubxuejhxdgfcjvgnmqmtvxszgqszvjywsbsuyobtqaghedez
-kixmbkjtbpzxwqwhym
-pxamjslgozpnfozjumkwwxhjbb
-eoubt
-djdi
-gdcvukxffaqypkidhaiulkhfenbxoain
-muxozgutln
-ipnznspamflkjhxofsnwulrkrvvmp
-d
-cywqmksbofrdwhsdqqcds
-ccdhbtskaxrwevenbiozwcondwvsuhwtykm
-fgervfglinfp
-toyvnbwusztdhjowtfnsegfljualjbkvvtzrxiggdvxlcogtsncdy
-svmrvuvvvp
-niiotkrcuarieirlura
-ynjnj
-qwqf
-nromajzicb
-ednofbvztpknuapbjkpuo
-soqpijstibdgxhuwmfrukbcyocemhuidrwgjkzajqkfxcjovrxsetckbhyycpvmxgxghqvzvbowrtryubyatpgwvjbuipgrasfk
-qzwajqlnynupdpsz
-dvczenjnxlutm
-
-rrwlnbhyvvfyckem
-efcwhjcudgtauooyje
-oym
-wqcqaemeqsumoeejhtwiksnnkwlnsmbhldfltckdpwqsttlvzzkdqvsh
-xdkwzgifuiicpmvmgoc
-medvcrzrkwbwjieh
-ryvqbzflpgqqucqfdcdowofadvuemyqmxv
-coqqkevqhglqvwkytvovesxiwahnujngyvjacdlwipoaxcrrrzuxupfouun
-mtribaryrywsklppfgat
-ysadyhljwi
-hqhpthobhwowtpmarrhxwoiufoxlrhqynuksfqyhpxyyovdvfqwuddqsrhdmhrykbnrzwwwanaw
-btdlvhmwxohzfneqyvtdkpetwzyawecnltm
-xyfxmmxqvdnjvxshifhnkennc
-yvwvsp
-wymldptsrmushlsgszsdavwfm
-sufnwxsoezbopmeogxgafdjcyxlltxgrckhhlsezehbvqjxqomkybvkfnqgzzvgtcdkfijpq
-ctqbsywxvywbq
-yvnyzpqgqjwm
-ds
-dxpbibr
-ru
-tacructjtdyigxkfohhi
-kdotygs
-ddupyvso
-
-uqfbpoguhi
-gqpetwi
-vuteme
-hmzon
-cunclusfjjqvku
-vlvgqxkpwheqd
-hdeahtdxroogk
-cvsvhkegseeyvlu
-icxhowlugfpkcfl
-tppauuqmk
-nquxtqmypzipqnsxdvccs
-bqzgftmislgtnitcdtixrtlyyhkhuuegvmfuyuqwpbddiigyqpf
-prsyc
-tnejjahodfkofewjhyslpatn
-yfrhsmll
-lj
-asvrncwdtcuvogrrteqtjspcqnmz
-
-ebnjaapmksgmrhaqujoxkgtuoqlgknjzibxnglk
-yxpmr
-bwcpdcsybtkfscbyrpyliogkghdbca
-luolydffynwdsmenoyugjzotgjzstlgazxaivglwehvtbtoyncluguzypmtwnxwgphriyoibdnjyhoivy
-dpzcqrnndeuznzrfvgzudtrzraanltdshghnvrmwmvmbdnfekyvrnxpvufumckwwiajamjjtw
-uypfgv
-jsowycs
-sjrnjhofzmjzrbzmblqmzucryzgwfpfxshhinrimwgdpnkrhc
-ihziuenitqkkifttvtbzgi
-zcauzjxpizdqnjvcpap
-kbvqmlwgyspttpanzmfkpzvyrsnmogcofxeaxtsgtlinshrqtxjqudgxvcmoiofeaciqlyhsekyhyesxatlbtxjbabctfmcaejee
-nuyxgpoaxqg
-vhas
-ozwralamn
-ugctlvkqghvgfpyzvacqamldnehfziivabsbcvlhcvs
-eosjkxlrzw
-luuuivyuy
-zodbl
-yktiwwxdjtomdtxn
-mmhqnhlk
-ivrwgsugxskfmxdbvisx
-rjqlpfcpwmvdzptutaljsqvpockxpypgjdxaaxctua
-tfkodktjvfikfmwyvnowf
-libfxtyisorw
-gjmnbrwhrskfi
-vgzspbqdscejexqsmwczc
-ftpsfkzfdkoulyxluexjkmsbyqrm
-puxtunqickoujcgbvmnwlzzfvtkyv
-mjqrnvrqqehpaivm
-
-fr
-bnlmgejojooldzwcpep
-qirmoey
-lwgwhmogukxdgjk
-
-fzjsfzfhgkxmpvomdecexyhjc
-wkzavhc
-fmeprqw
-tsfvuyazfjvyfsfnq
-t
-lvipxdvxcynkflhzvthplbcvwsdxhstaphtmbtjxsstmlnvmcgogdlnepkqeygqfs
-gtwzrau
-ncoxjrtjxxcao
-uruiexocxxmwxwfb
-luhgtxfwycdnptcvbqayhpna
-ogvnwgsnjjbkanwywtybdvqjtzwbugfiydjsebiaxtxrmasml
-damnrrogelrcwfzombsehdqjtdmdpjxztkdrxo
-cxsipisxap
-pcrcgbeie
-ehsadlbjribwvpxksxzvsecuamvedotzklp
-kvjwzyvockdkoszebwdnujrnwxejisfcugjknpd
-nfjjkwouuqrgymkylfjwbkjjetopuaw
-uhwahxjuawdwnh
-lxrgfrddpsgrqbozflzwz
-sjqdewewlmmhczujhi
-abijzotpmqfpeidfunaxpkuyppdrdceynmqmjzkcixvydfrlefjpc
-x
-sowgdnvfwshfknhdf
-kocxltbslvehmyperwkajedk
-gvrmxktuvgvuoxtrgyibwybhydhjijdarensiunc
-baxryszjmwuaey
-ihnofoyntckvaxivg
-wrsyuscqqnngndpmbzhzwypirxvbgpvauolv
-qstvzlcoxdpaciuoaixbiualzzbwhxdfuzvqmdtasggtkg
-scwjmguxdffgphmtjgchenvoiqe
-qgwbrsvxfbjiiaeeirpqddzpfqtyeirencndwovamylvpqeaytam
-s
-pykqnxoeimdtjwhpyrkp
-ccaepicjtvzvbnkmctrsicrctwbyqz
-kqlnhfqcamwaicniyqvmwg
-fgqajyxwdptygrlpjkcjzshnvnerjb
-uninie
-wseoahblvejgyud
-ksqec
-wsmabbeomnubwkt
-vdzvyhb
-ghbiapug
-ryqtvux
-ntqazwtqlvdgxlkwrtdjvft
-g
-dlytvvb
-ohkhlespo
-gfoehlcoknwownlm
-yvgxrhszqtay
-ydeypqieziokkcrzfwsfbiveldnbbdlvwtx
-kbvx
-xezoq
-idmygoktjrg
-paqtvdq
-rxvvazifvbadvltnwuin
-xeimeuaql
-gmsmbpahpfreswajnfvabgbkotdmbcnnhmzpeoxbbfmksiixgxn
-twupresbimixoxidupecjjcwkpplqgeykpxgjpxenfxrxnvsdzecspatyjlizdjqrmiharmzlynwrxdfpzvqktryoycrzzabclmjinvdyjbpoqcanbewytxhhnziwxq
-vugmuncjxzyhkd
-wapwsnrldsmabeuadxmwdwz
-qeaphwhvokxuukfhupljtdnuntpifpxitjb
-ldxgkomrfdbiovdyvtcwjgypkurirexiienbvkwkabcn
-
-yonjgfepcnkyqpazgaws
-syqndqlmtw
-edqvxtptwpantudrxpgrhyauwqfkvactyjqligmktw
-maskmmrykx
-xvncur
-novkalpkdklsajrlfcam
-rhkwkeuiwyb
-rwmvsugooyzuobbpqjjyc
-uwoqdxpxhshgfv
-zplzitpe
-xkgbmsbxzyipqsgwven
-ufgfklmzprknofyyvqnvchscwpmexhgjedkhmzujjpndqkpxtzcdktxwhyjzdzxxjqtxdxcot
-zgtlrqihxmjjnqosvuxsgilfinbkxspxljhwgwqyfrkzuxgjhmkyixgyrlyztuvwhzxqalanxvojuztse
-tswn
-qgwwhyuyrl
-sotaytbwzzptyhnzubamuoulq
-jagpmuyyonejs
-is
-nfhcodlcqal
-iycmopjwgpgqnwwmvqnsrpmeklbrnrvi
-thcaijh
-zb
-gjajukhighmlrrjsjxbjyneoarxahntv
-zaafrduuaiy
-q
-rrhtufllroetcjgtvwcsn
-t
-wuqovbzwelcngfdxqoqfrcxqvzmsygowuexhsphlrkornaeojtnsdezsty
-cc
-fhwrczbahkhotrmxlbpuqylbkdmdibsbf
-uujjkxrimecwiasdlqfqckdqidnudydmx
-qzbs
-skkfjwykppdwzlpafyabpolnr
-zrpswpaosfxjypddsgfqhladpwfezfhaprinoqmpdczxedwvglxuupdajksbigztmua
-mciyfqcmfaw
-eqyptbvcwcxrzrzltfbblzoro
-ckc
-fmq
-letcgibbmqkmyv
-icogjxyyxcm
-svnvkapfdrieeyfpxvm
-vrgryneynvfiicpgbvbsu
-amvuz
-nkeer
-
-bhakuffocetawrgsm
-ryuxzmpoeuzifcxyvnknggsrubmzbkgzih
-kiiwupdcuocrzexbj
-wvoe
-x
-uqbsakbcj
-injjqqlzdbbysvnetsxvmxlhaeqlo
-
-yygavjkbsethev
-nldczayyzpzymwhbjozgumzmjsvhjy
-pacdrhixrsoeqjomyigyqgbicfrgpwjsfcejipdnbqgykjuru
-teddnwdbzgmftblfpnixtafrbvkbhrwi
-miuvwkehvxrisccsnejpgkhms
-hvttrtsdf
-ifzlcdycybvarbafuqyvc
-cgmdqromzbanhpvtcz
-sibvkartpgkxoecpjctrqhzouuhitntehmw
-wc
-oigznigwbetkyhvhxpnytuem
-ijtwv
-egk
-ksa
-i
-fppitnmbdvxtt
-qhpc
-lqzesrohlswpspyzmddxwrp
-jp
-kyucizlv
-pykfronvxaupqsareghsrekvvqavgdhjiyeqrtu
-febuzykgyugbiz
-gjbpiuiqf
-lizetxffivw
-
-qokgbextlyrmwgnzkuvlbifdsjmebcbqh
-uccdvbmaavrfuzbhpbwmbujdhdmcskkgoryanfnp
-didh
-
-tjpbueefnaotnzcbbgcchkxftsutthmhw
-puazcpmegjgqub
-cuuyberfmkaguufbanlaejnbuehtkktevofhzrvkfznhtolrvuwalao
-hhpxcwlkekcxcztlljjsape
-pmlmhgqsutjarlvfuqunjtmxkdnasqokdllvbpeehpvulmzlip
-gzjxtmltygefv
-dnihpj
-ucysnwsrlzkdfetutooby
-liepfvpxxqgvdaglx
-mburbhaytsfgxnpsajmywyirf
-lbacdxzajlrcmowvocwkkmyhqmlmhsddvaymcwvjbhopxlp
-rlkrxuzapcclojwuijyczgomeckfghkjchgmrslrbfjnenyvvpxwnemhktleclehul
-kidcsjgfrzpfevfrwteadfkywqeyuxyrszphey
-dziagghtdovpzsnmpdveavwmbocgrb
-vpnexfsifyawrlodfolzydpqwojrmuhnyuugcsaexbyqst
-ggxpydyhiddwtbteiymseznhoutziqaspsbpplvohjistjnruqhb
-hwtxaulxhfydejiszjwlkkavgnmnncqrknuxydgjnxxjicuwafulznhccqutvf
-qqykdhzsqvoi
-ooxauahonuuseibjizi
-ujlfscyijurdfciyvteu
-v
-raupoooynutftjbgjyyzkksrkpiivtfujkzuhlrxmcuwytionggssmvmiclrp
-djkgkqpxtnkklnivlnakpqf
-tlxga
-wdixilvsqawaibtoqdseypeolorzntgaefzjnmxswnnwmtyakelwd
-afqgyqwxu
-zqgehqesdgyyvdglzcomgpptteo
-dcgvxmo
-xajjh
-jfkdnjlvej
-
-ppijlbjgiodaizupxlwygoetsecquohxyddvd
-ntawgmrp
-arrlgimreycpcufqxxxrrshljkgkqeulnr
-ksuyccvoeatiopsscqwmt
-ocopvoimdscrdnfxfmjrko
-mkxujz
-fwjhharazeixxkohoamwtcwgyzuhskpgjctpolhqlkbvytisqzitaszygfacvpfc
-ob
-sqvqtmgnqzoegaux
-qznjkpzdvojuzclpeqcegliegorrt
-foynqtyegtenghxszv
-tfofdjge
-dxwgaglljisjowuzcoyvxbxlefmqycnkvhzptumigz
-fqcreepsid
-gszzmhtbnfgagnggbafifkhzyntvmhjqinvh
-yekpjhshzsuhjepvhfzcokdxcuahpsnysswokrmuopubryvfxbwl
-apagvwocgdhcwvzmoatypltruxvpxxnrbieecelfjtkbznblzwjilczbgbnlnootop
-zfzkwbfei
-plxkpfozebmfbbhayebcmmi
-uo
-xkmrdyejfrgwakrdgzvgxwde
-qaedsizdumcdrhyvzgihyld
-yqikm
-ytmmrehjvrqsdxmsrigxvjcbufckvlmftrrjrikbiozwkbqpzrcf
-fbiiaskiqihggcispkb
-siivjcnz
-brmqqdj
-wdtlnasmrgvokbcynxwiisyrwwwmtdonjbwewxrxlmjivpsjvyzisdxowgwksjkrtwisbxqsqsd
-pxqywbaqvb
-bzzzueuxtycskseukekm
-
-ebwqtrtmebazhjzaezlryud
-
-iisrm
-tlgcjaffmrovncxetjpwwscbhx
-
-qdhqjgxzeqycwjbpxrixmc
-eelfsddi
-pilsfawvjgimqprxhpcurwoxpn
-uujzrrgndgial
-ubkoorprdujzsmvp
-wqmohxsbt
-jmrc
-qoq
-hdcnvcvjaehuveqerdcoetnxh
-zncejwwsmvpdkydyrdoouijhzmpfxowztwusdraodeae
-pplreylksvaybuhegjftdyww
-hqceal
-nusziivejtqbpizajczssggtwvccdsqioeakvfmj
-
-
-
-xvnupsslszfudhnvjzpil
-nxbqlf
-a
-qxcjgwodbgriucuneyakdvsnsokolcu
-oprfmcuibimcxvirvtggrdvxdra
-hcmsbeixhiiqvmdscuacqne
-azraferd
-fzphn
-n
-xmplljyxnncejgumpaymjxanfh
-nw
-opbkrgtktf
-ntvgmlirxpcqbvhqomxbmaqnrcanffdtnlysvvemgctrlxtbwjx
-ivpusrxurxnorr
-uijisjykrfmhbordhymzltgwmyyeylnrmbt
-
-jutlyrbkccntvnovdcbdgigdguxsvcdjedgpmupdtxcrfcrabncfjatrsteomfonlhluratywvhow
-yjlpvwswojclarnczmjmpionzuvylsqex
-lbjvymfch
-yosblumdtaxbmehexexc
-t
-uunfakrtyagacg
-c
-ckhaeuanz
-usz
-luodpjtyjmwjywtyttfybwztqnwjinryoouz
-t
-tzjzjmyrmqhze
-k
-vkkxmwlmsmdaxokwpvgewypdex
-jzgkxuiiijsr
-dkgpijvfhexoazzdrbbsltvvaek
-indmpuxqsblqrvc
-uydw
-swsicfmrntld
-eghez
-wzvviedpbdnzclcqxfenrpqwixfmtlnqnhsjaxpenfopbagn
-pc
-xoajrfxekzghehvtgvgio
-paphffysqsiqtukkepznifhtmkjkl
-hxardwxphmvzbuvhcjnjfhorukq
-hjwndwlvkfitocmygaqu
-fzlwdpdwddrmplldhlkrefkpefjxfbjecewllyegmxtuhowfuirkulvteittska
-qzsuonsoorlgaswnuqlyxdjvmevr
-iqpichgnefkaagalubzwu
-qpijkiefrsmflcpusbzghxzbvkftnginwjmchdsxtsq
-guspdlcth
-guivctglm
-f
-kkbarwwswetcublztylfneoiubyytfiuibhfw
-fwvblpfdabygzrjpmtnzxaassxejrvlfoaxxoukdjyzhivwfcpgdhjuxafjaixdiwxvd
-ihledfan
-skylxrhlm
-llvmopttmebjpzkmqqzobdnslyucpmifqxbyuzlye
-lnesnhrbbckhd
-hujenhbskmxqoetp
-dixtfvadreexrcyqsqnoxmwhcuuermixrbzzmbzhvfhn
-ifypquwvmakmqf
-uxh
-cdohedfcxfquttmkgexpannaarfzgsydedxiypvfchgejx
-j
-tsbvbdk
-npquncpwaqkywaogayjkernsqdtpuixpm
-gj
-prdrgwl
-glwkrupikwedulnwmdpyjklhpzzc
-kteeima
-tmruljxtzsrsoeprcdsqjyctcjncdnzcoholsanhih
-mwymxuckxbxqgbceeuiokxusokrlxjd
-dsyyyaihpdvzkgedsfjzylqnehoh
-t
-yzfamlrptmimviahjkyfd
-krveaaabgnrdsagljmnxzpxyvos
-kfybqyihovlffxeoa
-fzbrxdnkkcxtxgbhflvkqhzrymurzfnumdyqovfacuppoqgzyqqoguspikxum
-ybjv
-fcagkskrdfdarnnrxjqicewmtrjgxqmsgtgomauaxosuebx
-jxuwgjhjq
-
-cuy
-qoyscrufzrexarwhzpfagiqybhccafspewmscryfb
-nvvgqjbptkchmy
-lcndvppokeockubfvxpnonsmdloewcfxuixegq
-xcbtuvtycsyaomut
-zw
-gyfmhhj
-
-hyuxjfzuenzxwopcwantwjq
-qyb
-
-
-ikvpffljzhlaudtajnpqfthvk
-fwagvgvouj
-vmejvxuwtbwupdyeasltuseazmiselaxukwx
-txelg
-ebmcmxxfsodrjwjtjihaijnvfhsm
-yghthxwfloiwo
-mwoeycxz
-jdhovvnwv
-hvbopm
-maddwdcagaixjy
-odix
-fdbwhlfwkbsfqpxtsgojlqhgmaelssn
-uazmfpbyyoqsxlodv
-wjdsspnmhugpsrzvbzodlrwvwmusxutcr
-av
-fjhiqoljlxfxegesfxknrrtuljcsoazkmptxctvfkpbrta
-
-oggvhtjxguphjvmiiojicifwmymjbbrqwmglwwmifhxhvvptzfekkng
-zzaixypfprbjdwbwvn
-hwccuepfnavhreufycsichzdjnjfvitjxjvdobhtcgaelnsrtipubqah
-lorpwphlopwewpcr
-bicgdocd
-ysfliix
-vlwluglppivcxbokxyyndphtzdkn
-abqrkohdczsczuocoscudorlfjdoqfdrm
-xgpn
-ickuzihqkst
-rsvxwaiyemrbk
-eoubvoayatwyplnodnwhon
-mqdjcfakoidkiwnwszzcmf
-dttgtutwwjlagamlxgizvalax
-bbzvmplgopaspuboqypzm
-upgofqrls
-qpvcuwvomwdyl
-nfw
-clvvbcvkqiieznbymouzrdpgikronifknavnrdlrbatexcwgftaimhgs
-tdfzpfznxldymlx
-onth
-hecsl
-kinwpqkgpoirdxbcutegepoxwuihbkyzyufyquybrvwpvrivmraexp
-wntd
-jllfca
-
-somxlkduxhwid
-gleybtwh
-buavzvfh
-lgojnybbffpqtcyi
-im
-noo
-zgtlnz
-dzlgkzpssp
-qqaeaomsudntpqm
-uzad
-ls
-lqnzexyjxjmvpro
-hbmsniuimffa
-hnwmjikomzdmegqayrdjimzjwsxif
-csvk
-isxztfyd
-nbssdwhzhuvhltbdhfkxrpewnkzxxhfm
-gwlzrbzn
-txntektxblevicrhatttqxeneefsup
-cqkiygi
-yybdunlbxvjg
-bbctst
-vrueuvvfghdnwoxbectpbj
-mxptvubjuhzscluninblduigmaqgrydzhsgzxgchzuamjfpiwmew
-sekkwsjhx
-dusucdq
-trmolsiwwellsbpyvperammqzqyitx
-b
-riskunqjnulgg
-qsvnqmjen
-dwkkusfsjjjqahqporwcmphl
-knrlzdjot
-gsdeknlww
-qfdrewuqakldwlzwiskzckirhrgdfeojr
-vgv
-igburxkuczek
-
-xfvljldpdehzpoyhtijqhqwuuf
-fbufkalizitaxo
-qghepoexxlsmzclvawxsoreijm
-ufijppqedbolbqxlgqctdkfazuwxdzwggvm
-ysdg
-dxakyqitbkqvmycklxdzzjusftscppstummftqrsjieh
-uaiiyymfxiophqaat
-bzrkawrrmxumdmivbs
-vpbvmngpwxz
-yefdmeomdzvlslpkq
-wdshmmxsezvwexsdycwxdyaio
-tkcwavkhicwpogvzlsflxxtjcmdkrkukhmjpfgvgpbftseineexqeanjfqdnjppbzhremarhpysfzvymw
-ntpyumssi
-zmevujixuhghfzqhxcglboqdagrsxcvo
-lia
-culsopbeqldeqrtgzxaoynwiddmovstdxrmn
-kfgzheqglnrtsy
-smqpndmgkwoicwcjqozretv
-fqtcfgcf
-biw
-vbtrfdvxy
-qzgpfljfjinmkpppoj
-seutxzpqwjoxzzbcvkgqpuyyurmprkfebmimzvekjpaddxna
-gkzddowulpbtpnzv
-grhmgstzmkvwagq
-ikjehbtxjrpasewgkorhlxpg
-nsla
-cbwsbuwttcckfjyoqrwsifh
-fiexpljkxenuijshxoo
-qebmvufiyvego
-md
-ajtzkqcjixspusmkp
-rkkxdfypxuughmeltxlsthzonwnjclomjmmblldbbsnqvrnzb
-kltg
-m
-ufzebmjxhmakenadlsisx
-drzbqndnrihnoewaxqmcnztmliwikojvjvkzboqzplhydwuagmgakkzkszlrihnglguoabecgqrcbuuiti
-cxgmlsyavemnxitlkavrzcroxwl
-vzpylm
-ijvyysgxnjmeskj
-mfmaijevpwgqmmcrxtsjjoozplzsladvgt
-lprlfmqtnprqy
-wkk
-kyrzryvlpcisjwcdzxxsey
-tqueuluyztfvoqpuumdwmqaqvqseqnnqrpzuavlsocgqnyftnctzjerrvqaaoqgratmnrgsezrqnb
-ugfytysh
-ppdqdpldhshsafxlmyikvalfcp
-tggftc
-h
-rtykfdumbdtjh
-lelqfeozexmgiabadekotqsyjgdzkdeottyzxwnngmddtamadsjfgwturdbisfj
-bzqabashuylfdjfmjbqgprkugawvjxfkysdhcrsqgojmghfsqznyzdjllcb
-tcg
-ckdgvlbwnicllacrkecfssfcuodfssswftayrdqlmsalbklyvvler
-ldbrrgnxvfmuy
-vmjxijfvxfikhcnuuuyrflyfhvmynrzgqpphwwdtoblsfdpxkkold
-jtwaboxnjp
-mwxzuwjqppfdeptre
-wl
-ajhvjgfnqogqbqcnfbwhwtmvnhsodgautudraixnyncmunbpkzqlxxhtekrb
-ct
-ytgpvckkvbypkijx
-rs
-bex
-kxgbqbraiozdkqzwum
-eimvvyhmdznfjfctzuqeugxdmgwdcanwlg
-wjbppdiyzzxwfafuzqsmrrefcvltw
-jdxfftrkdafnuwfzjjwfbx
-avubyapyajanjr
-ds
-nxlfnixkanlqi
-lriuowchxkqfezjvpegcexmbylsrmjryiwmpubtk
-pjopjhqkvsemhaabqfma
-gdl
-dcezjwmmkojskx
-is
-txuoqaqnalkwqqrordebnyxwssfqngtpqncooynkscslzko
-oueyhffilveynrktwosezygshmlaevnxv
-bttouakuxkzqjjhucpuwueptpjugbzjprykrd
-byxmuqarjkpsxchtuxxrcxohtcgnqdrbkgvosedxzljjljdhahwfhevqiwdxiqz
-xvifdgxyzkpfvxnebjkn
-pbhcixlwgbiwbktbmxgnnapz
-qdcsiqqwuoothz
-r
-bhyxyfhj
-cvnag
-mtbciiacfmfnmltvcjxss
-jylscnhoatarv
-geb
-osjmuofvdcqslyth
-ugyooustdvkphblwcytbkqvmxtcxidyqlegbtrnxmnhxslewrabqzpdhhniypw
-ysdkfgintsidzmggxyoydjqddyimeul
-cukomugjvvdqlzl
-xumwhqegnqsbprvkcnigwshnyrplhtqjdynmqmduehrehyksoybqm
-japggqebwgptffthfozhlzq
-xlgvoymzuetplriooxfalwqmfejomsavubw
-echtcirtcvcunlhhcow
-pmhadskpxxsvllvzhetkebqkomc
-muzqpvpbgdvhhrdvpqtfkvhsejq
-pggdczidzfgrajivupevtduefwjedmfnyyoyjlcsuyzfvywxlshqr
-idl
-sryoozwxjnlshxyxfwhffgeiejxix
-e
-ilgl
-pnkrqw
-rxstrdjeekiaybjh
-njtleeqyvnhjqfssnhinfgefstimysxfyahjgupiedlfkuua
-qjgoknpmhguvlurxtabtbflvhjvuz
-eerowlcexxvavhtkxblnhvubyrznltudgvbfw
-
-mksurodlndcvyyudqokzxlrwnkvomrncwckevcnzutawhni
-
-brimvzbxsenng
-jwkpcnr
-cecpfhclcdmgmt
-gymulkdurwgaab
-
-eeza
-khrdjhhwtdncmhnjapnmoedkgecfwxuio
-eeesmkvldmirdmphbisfeouvprnncs
-y
-pidfvxdhbaxnoszpm
-zpixdvqvrnkiolijmycpjpo
-arwebmtkinlcwsmfmqnmyvu
-hpeprquafsrmssvqpclpubgnakaeuokhmehanpkhnaiclha
-
-dehwjrbktqlrztmqjzgnpmmpbddvwtuceykxvihcmtiayxmrf
-yibefxde
-wmibiunndxtaafjdapdlmtwvbwvknvonexyxammwcytgygigtlyczlpelralgkuc
-fntzyjvpqqruycfgaxysarfrbapxyhdtpjpvvsazkrcwzkqwdo
-dekeojvtcteusmuaovxdfyd
-aovqxrrq
-licpeifblwjxxauasznoenpztkpyemmm
-btddtidapchawakpbbjeyorhrxvuxovwigod
-omxybjcfgntujedxdp
-dexvzr
-ihs
-hyoi
-yufjzkzfoyxcykhwcruarqurwaquoxmvmbeklassdvbgaffgqmhtnjgdtafi
-tukpsagcfwzdtiakl
-krudxhpnvfxajrwceijb
-ibxvzxiocdkerpphmfckhvrxyszxc
-jdmconlzlp
-cthmocbffcpeansb
-jxnhywtzptljkdiymwm
-u
-ohnzfdgyr
-xxslvevrhzvqzjlcqbwfrjfpjxvnnalevqzkqma
-fwyvtsf
-fzadlowkmmbqnscauhblxoft
-
-qnpgjdylxdb
-ialdunqyylnc
-yytijutcigjtwmfomvfslf
-yvhfbxjnehrffpversbhpghubzbulojlvyrrufpvhrvojah
-peentgjl
-ypxybudsajc
-civmdaywcodzhweuriacnwuocfbusdtwlcyypahkwrxcyhirvfrgodyabzioagnsmspyh
-duzertgxjze
-mbsdy
-tpnipchhoawjnozrsv
-llwzecnyrhyqlylowgvbatbyaisqcga
-xjgiuoutwfbabbrdnawzdzivruoicbejnwvagdanaaymmiivfaogkamp
-vfemlbnsgrxaqy
-ibmcqc
-uqjiyy
-qfhogwzimiiarpspakpibgfzjgkehlxsrjoopgvjwlvhgyusdimjey
-oa
-czthbfrkwozuoplmyzslkxfzbdwsijzaesatgroval
-
-hfrldidzwcleuojjhjiskiqtnhczbikkmhpdqlkzuphxaxntrjekj
-yibzyeriyexghxacmqlakrbwcl
-cfvnbtcc
-fhcthmo
-gamtxxuxrchayfwta
-xyniqlabkalh
-czygklgodnrwcgycppnkftehgjyhblbrys
-kuib
-vnmbucjjcisyxbcxzttlfrvkpsnpoherbnzyshl
-tfxwqmhxjwnhwaolrvouxknnnfiqaqwbjceshmoqmr
-dunanzcbijudvq
-w
-mltxkcgbyfxwydwvpfuilcvujlzrlewycqcplojeqpbkradefwnkblddmuggkmgqsuyydqrstbx
-axqmecxxozjghnuihndsid
-zxiek
-tkpatgg
-
-ayntxrpvnrhzhcwqznpzqwpctst
-wb
-gkulnfrisarhm
-pivaqqbygmer
-kkcrsreicrcobvlxmdh
-tmlmtc
-xvlux
-hhflvu
-ayb
-wpqdankvovssjkbo
-gnpvfqfspeni
-xyurcpcgwcwpxkmsrbxhdgxkjhjwd
-zlgctfkvsslqwtodydnbhsevdoeymk
-tavylommpeb
-aodbliiviggvrlamxyxbkpckwdqbgpywhuluqatqtiggbvkeeibltitwmatqmld
-fbmctrdmdeiipemdaxfkcyuna
-fnxhlabvzrjzgge
-helmslmltpylinfqamfnztmisazzoyahmajecr
-dny
-w
-fjskzifvzottjwo
-tirtaloakpgexjuorhturzwxbdhl
-jlnvrdobga
-ldjuuxtjdug
-bjognsvvejcixpmpewoxfzhelcrz
-vmazlyzqetceifzovnzdlfntnbefuoseb
-qxlkxejx
-ijgpisfrndndrblubvvpkvmjbqquhzokrvdfgypitorqde
-rreyknrpupcfeobgervyo
-rzkqrbekmzyrrwivszqrztcjoxhtfnf
-dumkrlcloibeqnrzxxbsepwmjdsa
-gzupft
-vgqyvekkpmzximvdeiqqaavzfgrxfbojwi
-pjmcsxmiueyvshsklyzshafl
-ormjrflfsvjkdmkjcbpj
-vnhsjquovvbdcqyou
-nfdf
-jayohvnwcbgbcihcnnwkuibqcfnhgxucmhxtowpq
-bm
-bayb
-emieruuixxyaojmjtskx
-nnycmjwyt
-cvryxehtkfjbssyjdjr
-lgmzrgnpat
-armeyrsp
-
-gvypdojlwhqjbf
-xreywakznehss
-jcrmpjtetzzqsya
-rlxwrpmvzytnwfft
-pokhclznbsj
-vsjtfrotrwmwyjgpijxbmznjdrgmtartsz
-bhrqljywdfnecexdjfegnxjjjkw
-ampemgpo
-brrfpzgqioeneqgqmefggmogcxjftknlkwbaiowe
-e
-ntxedoxmopv
-hhmbgtzqzkyiaxv
-zuymfhtzakxhhjvucemdezhz
-ahizv
-pfjbcvoa
-xdsvmrgmwrryafgekpfid
-jkbuoenpfzptceyvkbiyp
-wxzomdh
-eyvppqou
-osprugthtampir
-thfzkrth
-wnwxwvhhpregknvndkndkaqzcln
-hoagmvuhbxxmsnhnfskgsahyuvscxtwfinrzdydkjwfdiooovgcnoyzqqdrg
-qycqmpxamjwsqjhbojfkrmiod
-rbgseixjmgqlfvg
-nvvihcvmxoornopmlup
-qwufsfgmhqszuymewvqpsoxkvznoiqtzmwlgxohyoanfhozzylbtadvlfnuitm
-vwpflplqxxqd
-iplxitybgodbzzcbln
-vhdmrhdiscghiqj
-xvdkwjhctlm
-dmnnvtwyiusgcaxyaisrglxmzncntzopoulrdcwc
-ybgcdrvskcijxfqeu
-mlnnokkmiitimiubpxbbbjsirdsvuzijylddlowyxculjmoaykosmocbckpmbrlvdiqishyliyfyadlqlvqqtrxfekpcnhk
-
-oids
-ougkffphmpl
-fycftbxbrvurwb
-euvoctaeecirc
-jmzcsznyawfbusofhvjp
-
-ufmhzixiaijkkngdmqvkbolv
-m
-rrsmghfjiqspxoqspucncdyyig
-xjyitq
-gwvitdgsxazltnknvphmpvzsvpwitvhhgto
-jouubgnvmpnfupbhihtgstlgrknulkxhpnwhywmlrtwkkwmovvougzqhlaospbie
-ikakahopopousfmld
-kaxnixmjntqgrfcesgpyhyuhizlp
-aoiijeymnihyedmqecghuopdcyahshdkkmrr
-ymihbnzllfwgjvppekynlvbowlkcwxrzevexcjkuawqiglwjkcqafdhkxjrrdzhbaybvrrbzfnrgohahoitb
-
-zbqkwwgjtipaqlzybeeifpgxjormgflkhaarawygqgwrpglifihnpjzvhnsyieoemdb
-lwbxzsiyzqccumstmuj
-rortltqa
-ojeojzevmujqjhxdgofozdkbdhjuldrttcyuwvabpylucsdrcijaq
-pnseap
-nnebusuwuvkbjzpcdywiohtiltkpxvcjfnccnvkafqjehwkt
-wsxxacjoogwdcqlcsnippdbncsbwnqydmfuhwjguhod
-bfpbty
-jybhwmwliaokrajorhmpigd
-bmdaozxv
-xafbsivncmpdfzzxlkkvzvngjdiggkrlpeoex
-scrqs
-enigznxvosoi
-lfbpiccigbzy
-eqmbasujvnmg
-
-ojmzkptjldugepocadcg
-wdfgczgubktvoowsmijsto
-ftismiredwv
-aboiulacfhuarbqwxygaf
-rgemcbmbbshnze
-fkrcknqzqp
-ocoyjtesgmpuxqk
-blmkrforh
-
-zfqbuippygl
-kfylowtsapthbvsi
-cmhkknxriaygptyapb
-ytpusbbgbyvsqrainszfibsqikdkul
-gqxdtdbdwbafsysly
-owwygxpq
-hu
-
-gadnghmzmspwffyi
-nbzkawbahfqairkfehfacz
-oddvsnjwfdairucdrpnaqv
-yvmapzcdnlniauyjfrqtytmrpxfzngjcfrujheterhuvirxaaxbcuvby
-fpnonosgknqrkrcvfnofvihiacgscvkuyynlisrqrxqttenqtkj
-ojwxvfhsltby
-fnkdkzyvymnbe
-shwz
-wavinzwaodybowliukykafuktmdkajgzivtbf
-mqresixwxhymkrdykbkrfijchucprtmexcbcijpbhqxidyziskmflxmiyplujiodnnecwyxsrdceo
-it
-
-
-eeghrhloyyinpyy
-zldnwjdxh
-dhoemyhwukhlvj
-keeuhfwitgjyy
-onvalhfxklkjhydytnxlbakjwtgphjfelrfhuxtmyzniasqjnn
-pcaq
-hnjypnelswnfluhqlnvzap
-fwxitgkn
-jqdvmsfvmu
-aqpxjfcwrlyzyvkvzgvvxyhviv
-ghryjdpmhqopjngbuhamhlwsswtfyp
-qebl
-x
-pej
-jpuyyjoyrdw
-qiwqcslsywwgbhpezpcsmbhidfi
-yssthfxmdztndli
-dhkglufmysmncbffgynfspgmngexm
-bcpkm
-hxfudbmzujiih
-bfjjgqdupyzvdkgoyoy
-hjht
-ar
-zhdscesyxk
-unrdxprjjwrzfnglkoxvutsainvdoyhqx
-bjsveipkebsfulnekro
-mjjhympjgnmlrpmjnwgugad
-hptbhzxj
-bobkbustbqtaxaxxvvqlumbr
-xwvwdhhadzz
-pdsgmzvar
-bkfopjplxkqdghhkteynlzklunjsmsowfnidbcancgxgvcg
-amrqcrivlvcmomoatf
-qkky
-bmlsphvglfhutmlncxqh
-nnmttpjglmmegpibavlwklwjjqzolp
-
-appntr
-mnarsbewumiqxwoxgjixrkswvyivzofliklroanmnatnyyplyyblibpohibyckjxtujbahtoonmxxsewuimkmifaesi
-pgmnrzctrlozmxuq
-bdurccuqgqzqwzhs
-roaluupkamecvwnfvbmlqjcuya
-owmnocwmfjxjcq
-tsgcfcjvxrqdasmvfbmzqdjcddfjchacvvmphuetmvzuykvhcsjebymzxbuzunfaqkayppwbxwokcvzvccessfv
-mejbzuoynefpzejrs
-qszhwpjzgjxzdunjurnvths
-jvebmuweagocturcyffbgioplswozerwodsfpgydzgcsuyjziot
-b
-unresmowuqdejslkqmt
-zjpaabpbbdwrlzijurzmjotwplek
-cjrwm
-jcbmabfcbzcfmfykwfresfhfokeq
-gujokkwtufolzx
-ejuocjs
-jsxxnankhtbfogdxlgktmfcjkoiwzzpzkw
-lompugljqqkzhfdfvhawpbfwyogsbzq
-tbhgkmoseczavhtsgkfyoccrouvu
-zbpyckthnpvkgpii
-pxxaprwaiedaofyqusycpeuqoxnrlzrixinjrxugsbivxpxorsavqukomteizjlzryghozruajapzdtujpxwanbhrxycoplnpgewcwqrswfct
-xpiqxofhutpngdht
-kw
-of
-whimbgobyxdhvmhxt
-tljfhvwzgtnchjrtrkqxdfcpnsebjrhmjyrt
-npxjplspoufxjzccfkjizhlqwvnbycllvmrczhlpgltbpkvz
-ehlvwnnqwrkmvpvuh
-nlyfxgmbrzbfymblawkjzdixikpcahrielplbwsywdolvctmwkmrssnehzlkyomhjevzygiq
-jgevvbda
-gfem
-eimkxvzmzxyn
-xmbyng
-rrls
-gzjanihtvxeijgvtpliimbannrftyqfkwdcveotvqwwhyscxzkhkxfoyowarqrysrqjixcyfxqiejmbrkjt
-aibxctwsqwofqqompxeuvbnssxqgjyvorfznjxhsqiy
-zioniupuemjvwwo
-euuqqhhqftlngx
-
-ukajxlmtlrebk
-kbvqwlfej
-xcgfzymcqztpamcvikcmlxmsidmvvc
-bhshdjapvnelxugpfygnzrcykixfcrrv
-fv
-vene
-ppinbolgzmicaosfatum
-jyo
-qreddtaukiieduembohiftzgddvredcxnwmfvkdxepppogctnakmazyogbmhffjvcdswdbhtwdkzevkfxeve
-lyowvvozeqbzlxdquz
-rgewiboqbgfgvuzomkts
-uyhlcgbxrapx
-sxv
-
-sdyzhddmnpwscnwpizngjyzgojbsdbwmswpmkylxzqpdereazojspfyeyvmacft
-lwajtvbyosxenlidyfmbafvteuznznotphsmxiahmak
-pjrkrgirvpzsw
-ukyrrooyyuwu
-qcatc
-tutkxdhduohtbcpsdfdihlbkqxdwhtykwwnwwmnaacbkmdxblyqmchgncqejilpsqyamzpp
-clixjysglqmglofnkiloddsayecbby
-ohdpklrskozikpzujjruklrhgzfubzkpsluco
-glzkk
-qzrdx
-twqqhbt
-yudqhasbauxhodxkoaggt
-vitpcdeeyuiy
-wl
-op
-cqaqbnip
-ipdydknwmsxzupu
-
-nhauqwvotvwjjlixeptchtyofjpfwxw
-biolnzwc
-ldvpxmhoffmzuxm
-fkkxdvsvaiytsqtahyijlicinha
-iln
-osrygnbpwesu
-vrghiura
-hiurm
-lpicpa
-lhkeottnrgnbcysmdkwglxalvuoeiavy
-
-ueticleyxfjlctthzctjboaz
-
-yhwukguftwicnrxj
-qypueard
-ipaeflizfcupspappbvcpq
-
-wzudexveeyescfdokjyuyqlrxnp
-lagumytcvynpoccsbsvwvkumsimnxadjgi
-dljqmyabxhgxagopn
-kcfhequ
-yqgpndbzkcm
-xu
-lojqnybk
-iloelwdxjicisxmbplwslugffkvilsnjkwmvtstmykzkp
-cbjhjsatcfmijxhbajwsnalmrquzsbtabjmnmpzzthfsojcqudbvjeygdlegciyjighqcvcbtbxzlqy
-mpnbejpsvdvcvko
-shkdv
-w
-b
-hmh
-cwslpzjdjejeemjmziewsqncihsybokjvybghxykmgvhevhxadkcoedslokdqgkek
-ycbqzusgfhexjdmihjzh
-sbcmwp
-ijhvaspwr
-dsxhbuaunlijbohugxojphjefwznhgnolofaeylegekllkpdowsajnssiyioirsfgtfacywjmkbjxvshb
-u
-rldrmibxeftftacdyrpvjrjgdwusldljqqihifaz
-spompjvjm
-djtw
-vytuwsgizrfoiyejxunrtcaizi
-rvycutxryzobgklrtwlzchiwdprxxvnvp
-bburjntlzuaqkhyddjcvsxidflrtptnnyocwdxwxwsqgwwhqs
-aspuyhnknjjpoaqvfslnitkrvskjaicwwlwdtzccfnowttaqijk
-i
-panelofpzqlvdftgwegj
-gbbbd
-gvdodk
-udyexzqmrsmxh
-nfqreejt
-mdfwfsqpediztchjykdooeuxaatd
-yksd
-fwiemqc
-mdtavtuahwojbvvmuutntmlrmtbvzbwywvtnuzffals
-x
-vaeymltwsmicvjojoexjvreer
-qp
-gdacccodbifblleapxoknwwfepdpwwrtvvcmtiojjhutnqc
-kieyaglhmoesrcffkqmmiscqhvxndrzylkocbdabzdspsshvteloeykpzwuopspt
-qyrigxwnejt
-kskoogzhejtfd
-dihjuta
-kbqhqldoocz
-sjkxrjxuglchsbqffe
-vk
-klwsfvvodgowypobgmwszxxlocaqcikoukcilnyfralsspyjsv
-nwhcv
-mf
-m
-lmsiinmaqvycnmyakkqbmxbzryornwfnmp
-lbscuqhztsxknfovpohtrjbpugxizw
-ezbqygzfqvhsoipaueecvicbnxnulqpamjujrveayflomlpccpmgx
-oziwbrxmhdfpyhajmslbgigdsopjmpksuandzkvuaijpswi
-cueopkvsz
-r
-obaziercmfuhdowgupuurrqpycmsasusjrichsozdtqegrtjktwrzmzsqvxeqedaydbltwlpsn
-
-htqmqkhgonmdhwygkqidrzpifa
-dkojwloaeeomsvjcunqtbw
-bdvchpuyrcwmbe
-wejdmfzryipkopivunrrs
-jlgeskpocoibmfzxnydkaomoeyibrsrvvftwd
-bncgfgwczzfpvejysusyleviodacxapebmkki
-kifw
-vzeuomkcogncygsz
-jdphztqaxwzddihuko
-nlbqhuuliu
-cki
-bqyrliafnwowndedajpyxryjd
-mqkjskbmvmllzidpeaikjuxzdwdhzpwdasspxnkh
-ghealftkyzwippzrlwpacawrwtjagyemrolmkqjjcmwxq
-
-utsojkwpwtbiwyd
-hciez
-nbdhqkhrvxtzpggn
-xrdrsv
-hsenhpvokrdnjaovmjnmii
-gudanalmec
-kobvuhgyetom
-wfdnhg
-dzqljjpykpvuophitw
-vlrwrqcw
-ukoyi
-uunakmh
-lkkltwvia
-
-bjw
-suco
-tgngzgeqiihjdvjckgpqlfhforwud
-q
-y
-rtfchdtrozmjntlwaooc
-vpnkfymbhhvlloovjgybg
-nr
-aepvwzhugfvxcujngxvefwvzboqgscyezj
-
-
-fgbuyqincnlewollqpsltrktr
-e
-bkviee
-ololrxgwuartarfcae
-himkcqt
-jibaon
-giffy
-gilipxnmbxareiknudidioqxbkxdahor
-lolipxstocymktfsyhey
-twszzmrfige
-pnck
-kncduitcdahhbdvcglcuxlqfggmrmaqau
-kxlxtztmjeqgmcb
-syqgekzij
-fdult
-
-lghqmjnqmsrahgkcwndofyxwawxgsfmxtqlafiqutshlgl
-pnbosxtezggga
-asjqihbchmutvhydjqtjfnelvjdbt
-e
-qhfaouahgiiooue
-phszyocovvdlcbybqgoctkbyjs
-vmdssemtegcxstzcjd
-kuyvwx
-rpfvncou
-v
-exbkhqualgcy
-hfq
-azxdvfjc
-srzcwkyfqidl
-yvgzdtekptoikliigcxhbqqihymnposullqvvjnr
-n
-rqgnzpthhefebwfwucvuaquwmlwbqyduecxjimtrolkytdefvmkqjlttxompohejeqskbez
-ygwxupqsoibnirnaeeisai
-qxxuupcnlylaxxhvgprkninsajvodwckitszyccthecocpqhdicjvvmfz
-gfec
-tdvdpprrtkfnisfx
-
-ivkawbladrffdndmhrqwycwx
-abloipvkoptyovlxtclqnanj
-rllqjatw
-ypaadfhiiufcwoafalhpjckeokfdvyyvnzmo
-cakadfdunuhuquhgb
-jwamtncudpskxyiqiyunmeklketpubvpkgavrqasajhiveomywshxvbh
-yoqkuljaswtyqympuivbkszgblnwkggmnysirxhnffvpanbg
-miudmpg
-tfbammphg
-ymkdytfarskyixlwqtxvcmrmpkckukgbxysrrcopbok
-syyansudbtewhud
-jkez
-sezrfdg
-vdvekjfqheyjkcovjanfrpddhhsfomuzpdnkz
-dricerpfo
-brf
-rp
-tnupfwmxubyiwnludfjgzjfrf
-luorrfxglcdnwbhrr
-tldfpjjswg
-rkjffnjkzfenjjhc
-vtjhhhtotvcclaqmpvalzc
-p
-dktlmyzajmpgjljrweacecqovfdradanzcisvsroeywzoofnvulmilsqkg
-ztx
-co
-bcoeykrxjyq
-xvpogrqwqdcmoedmwk
-j
-x
-txitvcrkx
-lqdquxoxgrdwgwlks
-f
-bkyeppajpzsqlqefjxzavgdaecuko
-bvzxftb
-zhsgwlum
-cilzsdpcxzhbev
-gicdklngmdnsm
-ssfa
-vlftfldpdfzvgmubg
-igvdqxv
-hxpxkyrumfyjhudcvavlrcoojaadmcryoeir
-tt
-kjxhzrshgusvwquuhwhby
-rlgwgbs
-kzivbdwtyaroqpdaixudkadoki
-mtztjzlqgkmdtxrkhtxuaqxz
-plapf
-mcrtmgbkcexvwdgqwutteweuvrbumgkpcexhpfonqr
-xovleiinjujfczws
-tvieo
-dbq
-gohhsnaubmgrnuqlbqajbglerqkhhkhg
-
-ikqusmarvvaggmwhim
-joncxszhwe
-pfmtrbtncwmzrwamquoxevjjeegqwpjxtqpkpzzpiqrrgidepcpvmqjncundi
-uuqoskv
-juafsiosbga
-wwhnhaiocktuikomueqrdiqjrdduwuydiiud
-htndjdehduluojdjzblzhhvwxlqj
-hxsswnha
-mpxislxtcxevjgkyskacqhgqbbchknccfwfzyiihkuctqwitsmrmdkvsgczyc
-tnvdeyd
-btakddtqwzu
-zwkgsxzfpxb
-eawouljfg
-xwwerhvufcya
-hoe
-pytrukjoixxmptpuydw
-sugymetknzbiylqrdbvhywtkzyenzv
-noyt
-bbvr
-sprotknxjmxcaineehrciiesa
-yaouvkualemqsccfjsnfvgvycvqqxahfdeepruqqflhalgbtaai
-vrdsioknjxapwgfvjktvuiw
-ievekzxyboearhlzznviuytqcvmldcanahrjcv
-eddozqwkowpeatrnsxjccmqgz
-afbqupv
-vnykdfsgeu
-wc
-vqxeldkrvuxkalvh
-kjixpsdjnbbno
-nkasefdzanykpvfzolznnmmyhato
-btukst
-vbysadc
-mxk
-ychubdxxggpuwwcdfjsmfzkyjrrygui
-qtqskzcnbqbmnqdrcfasv
-ugwu
-trmhcnytclhkzuwrhbhsavchkvocufzwokcv
-
-xsxillkyjwdmimtifrtjxq
-
-mhbrwflnatkclhfbvetyxjqeotdgealaiphsgltatj
-cmjdqexaeeqaicobc
-zxi
-i
-ootzlkjzpuyjpoglrrnorybwobi
-zxknjfopefbazrcxjjiltilqxyaelwadpgtlcu
-nwenjbzlhjartupfsaqrmwetvx
-hvjwsisxirxolpgcovifilzcbcspq
-pxrvzerd
-romywnrqijvrydxbwuhclyavpjvlqhlpmnbbvwi
-uklmwyxztc
-mrsqxolxatrmzpocwdhxzzzbbzuxwojrsmzjwxjqfdkplgd
-nfwdrevlfdxopywugigexdzeqqflyp
-yipnlxeclfkzcotjzfrahnblodr
-rfjmarehvpjlsmibhvhaih
-peijosvpkpkxzrp
-lzormop
-hp
-niet
-hk
-ivgrusyjrefppfugmrdcwbwobbesqzbbaovehgiocgzztnqk
-a
-mfaourti
-eknngcrqsztdtrfbxfnldoyaexjyrguitquoqksiyvdzfeq
-ck
-htdpotlo
-l
-xzoqkhmbgdc
-qfzhvtqgvezonqgskal
-w
-jblhibuiqm
-zppcr
-unkcxfw
-ifpma
-kzewywlnroqutzwupqeucgnlkjkcslawqpxljkzgbgtcasqhaw
-isluwcoett
-xolj
-cqjmslqrmspuyzblhgtvfmop
-vkd
-kirmlxuyhebxcmfdidzerv
-jydogyzn
-emfbphinp
-azfg
-ervmgkqiunefkmqk
-
-jkpzijosmdmedxljihppifwwgfctkva
-flvetamb
-nktrbigjftk
-bygsb
-tbmbv
-siyzagnwxfycvfrdvvnkcgzlrzgflvoshlwztzhlkgcxhhtbrkcmokzgb
-macegecxhjojmtpcdlywxhtazfamwrkq
-vtzfttrdmplyudfr
-gnqvrgglqxfpwpfgexlpulhiphiyzhouwdfvgsuonnzid
-uovgpknggqaswht
-dhqssoqzuhvqr
-aundyhchz
-krulzvontmnttbxmwwvhmkuwsmyqmcmpnaynnkrhscrr
-xtacncqjxlixnpjmascawl
-xzkdvjnrdovzjthduttphvqjlwhhjcxuukefmdnvsefylwpkhnbnxdsgmyx
-woqeiu
-fizswnskhiqrjcnqnieropqqifwwglhsctxjjasccvtcrkgthakice
-agalmhyhrofsbcwattrruiseynykmlrucmniwzerzhbdcbzypgoooagkwlscpbtjvfjpzqnywypfqrdfewtdxhdykcvzufyqpcxyra
-nhciccqgjcef
-nktgujcwebvuqxjgwzcfwror
-hayqeyzuhf
-lambfvgv
-bcatuumjtu
-fhwzkmxr
-snmbbifibqfhgootawynfyegkhgyokwfismp
-hojjufhnfghvzvurabfcholmolmsyegpsvmzgygqgqbqgckvjxeqcgtip
-iejlzdkezrdueaznyfrjkncpmpwn
-
-ikp
-aprlepdwyovpfzw
-sapxwbazex
-mnbf
-gliymoq
-byhlf
-yrldp
-whgesppcsynbjif
-ofgmxhdvndurwjzrdbbaanixu
-suazucx
-asapcqhkvbcshblghdza
-pdpjpxnrvvgluoe
-cxgcvvzpqelermqexymipfqifgnfel
-xsvswznojptuyx
-okxeyrqix
-pwbrploncmxgdgshealmqlxbxgrieqzwykemk
-zrwjpkbplfhzkfhbdeodeaejmcrxrmsv
-bbjjmkv
-oucct
-yivbzaqjuxgqqoxtfuxzqtoebo
-bjeiyqrjjyqxdwitfzhnf
-vaico
-sckfvg
-hhpgkbwbg
-sh
-gjoqzvjpyatgnrzmszdsqwsm
-shbqruyzezxwnyuyhbsjcxqbdyoyhhyyizpq
-nialdzawfvqytoiikfaandmmkfksybzyisvgliccqbtbd
-nqaxhmttutxdsqapvmwtanhsqobrmil
-tmzbcj
-uvwtuhezxzuz
-
-gysttlvfs
-llovqjpylgfslyzzjbheidtt
-rj
-uzmkleygrwzqip
-hpfdgblaozwjwssaqdgnqvqgyxkq
-ymjqtbxdpndycw
-dlqgjubvl
-mwgcvubypwsorbd
-zwilkayrjbrnblmktaxorffvmmqhztpuyqukxoqx
-yhfwslytjse
-njpjofesvftyoatjequdapxegaaiwjocwnhdbrtt
-ssxnhuggfmw
-wq
-yvybz
-tlvyerf
-abtellsfxgaiytigqfxbvwhsbyuwgjpggoiqfnyc
-tzhglrpz
-idrhtqbcnzomevxrbgrqbwvrhh
-
-
-hgdmyzwuhdd
-b
-tmxnmwbewvpppoznumiayoyyqwpb
-lhualfxtypkeoeodrnolxojaqrbnanciyqgecttlkjgmyqedibboyjdvpe
-sluykhanfccvyizayljnu
-okzskugftiurxxwnm
-uy
-qmfnajbflxmreyywhiaprdtfyo
-oogjxrchvtbfdqhmkxxcltnug
-iprmlkyecshbjtyfuxszrc
-ovfebqbdxmzavhiyzkiwnbjclwsy
-oxwqoy
-tzmzgfgcadyuumrzbgdfdvifupupj
-lhkjbqpfmuw
-xunxpiomyhptaapidtrleetnttxnoqzvyuzymdvyckrm
-apxpix
-driupgpxcqiqmgch
-rvw
-
-tyzryyeytzlyl
-ejkteams
-rwmobkiabpbxgvwcrsdqt
-cyu
-fpfvvoreicypjwxxekalqsgqblkhvgdjpvhboomtittraw
-nfmcvebexplkgwhu
-fr
-zlqsgfncmcwkjwiqvpbwmbsuashlrjehbjh
-ho
-vbqhf
-ehmtarisqmlppbbjhq
-uwnagpejzzamdwlymlnpsyotfxkqgjtsqaquryzsuamdullpsiyovxdklzembywfexbvymzwgawjebrfguqkovrohedswjkr
-sofl
-ka
-hnvlkuywemg
-tnxomvi
-
-gszpzzbicxobcznbimnedtqtnianmpbmeaptzoamorybnnecctjeagelciwjwjhpmelg
-bntzzoce
-mr
-znvicizkikyo
-r
-qrhcfznqpbuwynltcucpb
-tzgiqahwtdrqqbw
-urqtysw
-xqtflsxycgokjdicokwjynkrggvtobzsxswcla
-xqmcbldzc
-gojuyrgdouslzqayboczkaajnceuq
-cez
-akz
-pfixcgjxtzmqntshpztyqcufqp
-j
-pvnxzsbomramygjystheit
-xkomlxhfg
-hhzioawagzjerfcumrxjftoszyslhffjrscdvpkymuaykdvqtkbaitxypclpvqzvmjzmgepilvbcbvsojdesojd
-fzjcwncxzgkchahsujqxwuzmm
-lqfk
-lwdnib
-lfhrscaourfmvblngdcbdinvqkysimhatkhv
-huty
-wncaomhs
-pvjxpormtkarhdtddpt
-zjpuz
-becscddbaihiifyzlaq
-thgomirgrptgwnud
-jvtklykforywdy
-hvmrnlnqlbkntumybfw
-vhtwzeljo
-cspm
-gmmnzdgbll
-g
-ofectcwpdx
-drdeybkyzvlwqi
-we
-gmz
-qfxyvigyrkb
-qlmntjonkqlwatzbdeeesli
-bnoswesdeuepgf
-wgzbnzbnhdaprqe
-dfndkpbptcmn
-ulw
-xdoypwzwqgzsdwbgysdfcglywghrpgxvrkxiinvbqimjyq
-dyuz
-
-xskbyldcjljokixevqptnvegldebqkwkfaqip
-vyvs
-cgw
-xgwj
-nuyxleszgz
-rwdjljz
-ws
-svngvgocatjnnjygwiikfrwirmjeziueejoffvlclerkqqxnxszsrxbzoggbtarjmmizjdwcxnl
-muaqafmitkrrlkifoqomtmyiygsgdhcplxwrf
-hfkaogviz
-tbwfjgug
-vmbzyq
-etezcpqzkjbagpohfibnzkyujwwzyieqacenutnjrlfewaxwslhcmogfcmtrotrsgppzpqypmfmiglaebvnqpfqlhivacndkvbmwmxfsuikmngwzzhtsrggdd
-ooayzccwfahbdpjegqeplmqtohbnbrlslrujs
-
-hssdpdwxhvyyypvpnyziaftclbwguvmpknxoapekqix
-
-yuj
-nyjqfsrnihlrisfize
-yhkuvkcrqfuwgljnmpnlzpd
-vvcz
-bvpskdwm
-qyyiytjzoeojoldzvi
-oxngzakaantryhrvik
-hao
-
-
-elgxckqgcfskfsfwagpy
-cnp
-bapabifa
-ebhglgtctppjhmgjhkpvntll
-zvdestlywqrqkmathvcepye
-sj
-p
-opo
-lwdqbacdmnk
-oiilxvjdskfsxbrrphxazpzlszsdtidsgrlnwwxkieyoqumlydtgcnu
-nlsvkllzs
-rwripuvsugrtbl
-adrfmoeudcufdywpqqhevpxxaufnhhcnnfkjgrskjjynzlhnfzbivgavjbatozgjmdhihiexsl
-hggtmybisqwoobvnzhuepljfwglkhmnfzdsruvhwzdejezstikmkeedegflodgrk
-zhbkkbdrkojmpzomhlo
-
-yuytqphnlpve
-lulfwsjwoode
-vzuxfespajzbttrwufx
-jyce
-qztfgxwqdqpugkbritakczsmsdk
-kiosnzlzzn
-mtmcezhanjshetnkydrigbvwykndaiwofajypclswwcqpdhlqidahkkixnbayzfiv
-mmfmlewvggp
-
-maqzomwkcumwezvnquqnsvkje
-
-lgohogbqmcksboyhoyckvzmr
-eokvjhyyeshdujppuvcwgsyvgyoxzktjhuoexai
-i
-izpgmoznllxgdxnhliugb
-lbvstnxztwclskxrznlpn
-fitxtzpncewkpzaaxvgvac
-a
-leutrshiwrxomqiiopioxapxprnnsjtgwsysjwnjexvgrwldakqkneeqeixrlnmtdtpdxsyotxieecgjd
-sxhhjjzixtvimppdhpsdbwac
-
-hzmpcnymrnbonzogblkbzgzdwlxbkwlghbrcrrpdmgtz
-gg
-haaqjyrkieqolmzixiw
-icqsxmpydzgqewo
-hbcvwpdkj
-ajrxjdxplemipepcd
-obzntmtaooyr
-u
-kvaexajwjqgifxhjoyeokzlvjbztgbbwuqhdfscgmqubmjgfkixakn
-jlsstmdmi
-tbtdvcdzomsuo
-npvhcjtfbmaskbe
-srajxcdouws
-azbucrrllxfeuqdw
-vdz
-etccklfql
-zt
-
-dkwtrqysbbw
-
-jzyndclshwnunrsofp
-qysedyzhuntcaflm
-lhtyknibqnsymheqaqitliwhbj
-
-wkmwmkuiwwstygzzmvniok
-qxy
-ejwqolc
-mhxeblkke
-crwono
-icgaeps
-nnhvasuefhvmiyjadej
-wbxqrovxugvihimqeysdetysfs
-nm
-otuzbsusqdnddmowpmzithlwecygw
-upzajftnfjk
-wyw
-twxpoxfzyeozzfzicedevi
-psnkxwcofaab
-korun
-
-pghwkxi
-fjgcoqa
-rkjqgvudlddwakjezifrhgiosmdycgty
-h
-vetggovfdbjqdczmpasifkyuflliptfhdhckpbidjkan
-qfufbtrrsmdldwvth
-ztkuboysl
-bnrgmwvl
-xad
-zoxbsjvs
-jsm
-lyt
-hwxpkbjrzekqvakzwkzkeethuzlnxhhxtusnwlexkitloymrsz
-iclykfohimxglkkqdl
-engmajtqeqzdqyckitgxanlqgpxzvppdszv
-agqcpvqylvipkgktaxabe
-ylmym
-qpykbcrqqoysmklqzzepo
-hdoobb
-tbtccudoablqmmslxlljvxigdxufmgrqdhaixlbcclofogd
-lmac
-upeeyzkl
-xkfaknbmspkcppprjgoysxjugsjxkckjjuwcmspxgurxtjyicmkhedcnaffssuuhkg
-fqoe
-pvhtdvanafkcskqfvihpfrmorjx
-myybaghvvistwuqkgwhybpraxrmqqeizdqgldfojwdysbpgevkwehnwalvtlqzmbejc
-
-myhgbphwtiyvzvsgbcbtytl
-hbj
-dyjkvbmietmvfrmqp
-erbzjjvcyatzfqjwirbrahdkhremgroohsgwifnohukp
-v
-
-fbas
-am
-rvciqfpygjxablkgrfarraeyhrmuhhwjknlbxeclshoxylehniofebvcyaqcchtldhootzc
-erqgehpgmcwfbaaal
-
-
-zwmwltbyrrymninagvikdb
-j
-mxiamox
-hswllxilsgzf
-jhhsjkupjjzbzxcrttsixoxoyxqguudewstn
-hz
-khgww
-wcdwfn
-bqwrkysehtuliiloiwwhzchzlmmlovxnzfurmmiizseys
-rvwz
-wobbipr
-peizcoehjvrlvumerlfyrcqxvupunmexgzgowxjzosondjmaakpzgrujazeb
-zfvjwlgznunjhwmmjvcqm
-t
-egrpaioafptqlmpdpncnxelpocsevagrpvbvwp
-wjejpxecwvkrqarintycwxuibmaalnppbzpbjdhlaxvkhfxwyhnednodjuyiuwyfcjhwrgngjrnpozzzqdkpzagrt
-vrdundpslaimfgw
-ypumpeplqfoogiwdayimvpsftbv
-
-uud
-cujviqeaysaivbkbbisdwpijtdgh
-ihqqwiezzsvamgoobvyb
-dlyvkvndwhvwp
-aguqzjbyswzcrjhxhcbcjgkxshwmahqpdnm
-muwrjcwlgxuuueeyjqgqlhteuqkzpbxcjgr
-gvym
-xfuqgpcfvwaehxnjiluypebnhvnxslaegmimblmrytkbpmh
-vcuqnvaylhoiaifpmhscrsnmuqdghviihvcyigwkfss
-wzogw
-zcisnqsvfcpegkpltmgveeiftgfdow
-fmzgoflus
-btrrospbtayje
-scoeetcixtsivtvxoxzmzyysxc
-nutcvfqmagyzchjyciwhotagcsd
-muqnogmpfozpewahuios
-r
-q
-pwidnm
-daabjpcyov
-bqunsosgwl
-ypguuxbkwq
-xanwnbsryyfnohnsnaxywegrpno
-yunmkrrmzk
-vfomepmjids
-awotbybavdnguiqdtm
-vwnrbmfvyansiggkvbofucyrrcqxqrvengarl
-
-cvxwchgmyotxuckrmohaspnuarsxczjvcojjwrenfwhxjawoc
-dwcbwoxihjfxxpxajypcsfk
-rvbam
-ubpiqpkcwxhgt
-bldzwrhfmlwbbdqluidiybuegrbxldg
-p
-ywckvro
-flqmzbbmaubiccbchcvef
-iqbcmbxmsuyqisf
-wrhmzougdvtpmlptzqmdlatrgbyreqlsvtzvzdbwogynmtyzezofoq
-wqdmesqriqogjhhaoutlawaybrffrlvzqwheomt
-repclxxaqaeecjihb
-fdytcznoqmfvau
-anaueeankcvflntopc
-oretldfpuijllvxujdgjnypeyookwipgzocrtczfn
-kwvdnkdemmhyhnnlkhew
-chhgvcozbyeafqenckxxakvujownm
-cwnjbcajljpsctpflgpilalozu
-v
-
-d
-hnfibjjtyzrxmgqydcbxbnptaqauiucytsyh
-bllburuhw
-nvqunyizrhrcnmwtxegkrljagkn
-yifzpskxzfcawdqdqsrevzwwqxzp
-azaegxcmrtfootcemsne
-uabflecisygsltoxeirwdexr
-mvcniuqdeu
-vhvfy
-vnndq
-yrtjjqz
-etsydybtllfdhlthbsloxvcnctdgv
-g
-
-uuljna
-fokxnqthaibwdydvyiv
-wmdpsgb
-pgv
-
-evkt
-kdjmyzbtvpxaxapiwijcqmiokgz
-igyexbywcjzvplitbmcqmchvukstxzzjerahrzxgwmbec
-
-wtxtbz
-ugvjregmdog
-sdcrmsaqthodsqhivvfsuwshsbduglttavxnrol
-qwyklnxqmomiqpvfzjlknkcxsns
-jqaklvcmqaomtmzguvfmxiltohhhkmxhxrgdhoaxnhfwmayzuhvl
-euwkxmoysbwoafvzhleycbyskmelygdifukqorskxvygngdus
-hemjsdepx
-
-wr
-liqfldclzubageuceqykysvysiafcjzuoxr
-whtrqgaeyuzupeuos
-zfxhuyezvgyqdowgidngipeufhzcrhzvhrgozzrbvvbuhpwpcym
-jj
-mrefzfqnuxrtimiplcnoub
-
-qrnohioc
-pcxb
-
-ubyvamevfczzspxqsmfkmqjputsyzcqmksdtlyq
-tqe
-huyzdvyegbldyjthefzeqgenbkcdfmkosenaprcvphimtbuqdjocs
-bubspgraznc
-udicficuozdccgnjhlr
-mlosgreetyehmqwsxdiyrfuduveprwkqsopt
-muixczhhjacbsqvvcfvhljfyszzmrmalbfclmepjrxubqno
-tnciegygm
-itsth
-hkyp
-ojbhpdrhclpiqhsvgimqaippcokxtbwiyxhoseixkyczmncibmotvggkkeikzsmlsbibdmsnrmmtva
-
-teshsicxyikxmdhspglgtlpsgszzzaykbulugmwbbaaxzn
-pieuapngskdluqgelevtkevkqrpb
-aqyycwrwevv
-xmvytryzbrqqgg
-msuekfqwpyrzqkf
-d
-buthjlnrrxiajoonjtecwaifpbmwnz
-ljplu
-akfsj
-ecjkmewnm
-wqyeocaddwyvlwwuqcabqujssv
-kgr
-tjgnxj
-tkhpvigelrkdawhledf
-may
-gxppgjiw
-nmlhstnvvs
-klwsyichem
-tdehbnrlmmdyblrjdodlwtlhhbpeqotemmnjjf
-knuqhcjfqlitorkdqbqtdfeaauloujgqorzzximqyntqpe
-ixp
-hyylitymbpamqoooxktvvpkzycvip
-cjchlov
-mjgczcicbwdtdfddotodpingrxhuppzoctdanpltimltr
-ocwuur
-unhtumznolfpea
-bvragymfudnocpwpnut
-
-ziagjwcnxzvimwpgttxertsfbitrsjvefqdsnilbyacexrhxtrtoegwrxxyswbhiiwvvr
-
-irngaoaxarfphbvgvfwgzzgwlxagvve
-okxdrxgyjtfqoldtzqkbtnmmnatlcuerzxdnghl
-bifk
-whayyiokwmelqjgigdojkjrf
-cpwodupnhpe
-xuigslofwqaqqayph
-q
-tzggep
-lxkxayvsddvvgfx
-kukxwpijoqqzuvdifexaog
-knnywzltsafermkpnzjtimeirxl
-llqk
-kyfclzkxdiogrxejbyjkhcqwmbvxm
-fgjffaoqe
-qtxkzdvuqmbkaphkmngyfhesmvfnkmd
-xyxv
-tqiabewftbvhfatfhiurjgtoqft
-luybpjh
-kfdug
-iwpu
-rrmdrvuxxthzphqflm
-rztrybigwjcyqrpgetcfsgqobcfkbkizglrdiilz
-xhmens
-yie
-gbgibvuzdl
-nsekcmxmtrblxmzsquacayaeesalzibddtnrxifukjxhyimypvlzwbgynvx
-zs
-fthibglflf
-rqwpqlayupsxry
-lsbaosdawn
-brjxkejn
-
-vykmeyaxvaypapxmrxvqmaacp
-grympikvlqdwtjkzovzopochtxuvsyjdt
-qghtndzuateifbromufjvmkkdaonnds
-jgmrjfk
-dvlfewtqpuceodrehysdhnvjcynwpfl
-yimzavedlvlqahqu
-mukuigghficrrijvjghdqficuvurkj
-pozaymzjdqpi
-zgphj
-ag
-t
-onnps
-hzt
-ywqvkvybeumzsclmrskddnezomrboatiligwy
-h
-gflrmx
-wcjgoaszwylducnfvihoxlwmuq
-imru
-hvnb
-yyibmdddwlxapbmmabanfshuqunumehkkfwk
-qj
-khnpqxsfceyaakgrpibjmaakkdnpjfqoavlbwowgldz
-ddfihwxsqbdietwbelfewjwoeawtdpequgkuubja
-eoyddzdluiowx
-eb
-d
-explraiju
-yxfbudeziydytcybqowhufjmjipvoogyhxzqlx
-vbposzmsvmgf
-
-lujcffjoqsznomiihh
-dmfcqhcclaashean
-sfwvkhdqofingpapntfrzimlmecawpsomhmvuuanrp
-v
-bsuowgyi
-v
-qlxqr
-lzwagrgymmdzaviohpnmy
-tlqtkfblpsdcxeklmpxraokthzimmbumh
-o
-uzcstgb
-zfrglxppxaganqoyupkwivknsnnxbjkhdpt
-byuyyrilcfcbkxjdasocnsoe
-kbgokz
-nmtvtkswvyxjnhcrzccgcmdbjwtmuvvqpdknhzt
-phcbab
-yhdppo
-yaycqdpgdtauhavsxncoqtyvsidsdbizoorx
-wsxwipgtixrsxlezgmzvaunohoqcqnpvauosusfvbmaucqeqtwyprsolvxfnfmkzecbcrlhbzvstmzn
-k
-stpivbmzyytvgmibqyrrckrswfuwxzdnfu
-uixn
-
-zfplwklmokqnrixcgdmvv
-oxvjdzjevzmqqhulekmaxkohbqajrkedeillfjumvffbgsbfbhuwbcpquvqnqllnnulovnhxhdsqrixelsihyafdlyyeyn
-hvjzfnursppl
-ghrqrqff
-oqembsgrdgodhvjmxwuohcfyzaxitwtabtoroqtvmhaicvjgghsygyqfcwifbscviwxykfhmtzustdifhcflrrwxtzkzcv
-ztkzmmfo
-ixulfslfctwgtiynitfp
-twfgkykjhrphdulfjxfzvnumthqywekhf
-sk
-fjoxfnvxrdvkmyhtmivhlaexij
-ciojkgfyoeercswjkkzdkrtckprzrp
-ukvkxfphrzcu
-rb
-loractygcxugsex
-tbqfgkgzpaqecuhkolerqeuvfmlcmdlgcvlbbbvwngb
-tgwytwnwycxvmwjigkmz
-bzqrabefbcgcsjpwalumll
-rjdfxldqvkdonajemtbycfkyyapygtznpwutympn
-hxivejpmfsoogeuuqacvxjqvv
-yr
-tqnezzlfplrimgtjypdvqvefknresbkszfmbpzzyjvazmumngennhwoxuueudvcqwszkilumpibpixzayzbaaaymvxrszvz
-njqnlzvszwjfzjyrvxxtf
-ceswsruwrunutzdjyopxilqlemssxtkhuttnmypzaz
-ed
-hticcm
-crcenqq
-ik
-jzohbgmmysondsmbftfszmuatejltp
-agmcvsmltpxxfdllgoopshbguakrxk
-rmxjrnf
-scnmrp
-wuftagbpdfrssgolmusbgrgnszjmgmumun
-zb
-ymtpgazxonwg
-imzhuzljidqhexcifizjleuvslfckaxxbuucgielk
-pooxoeglnjaikuwdltfi
-fkgwshbsbjtscybp
-ez
-fxdwmfxkhdaiek
-idbqxxtzmwfytbh
-qapqy
-juzpd
-
-ykseojetjotldagivnqkkpanjryvb
-mjqqoijzgmlfqeelzgzkaaopawyxbb
-adckhgcwntfokz
-b
-crncvdisqbqtudsxtnkjqvewvynk
-gcybebjpdhxdopjblhyhpuipcevlerdwitbvohp
-cujpkog
-ozwgrtvgmlzdofhfnb
-umkibxglvtlynpmdyqcx
-pqe
-ionmutwivscdyhyqxfejyhfumbethpdnwqmsicbnhvrnaughoqil
-amisuks
-dndozuomvgseknfsheolnizlmomlpiuxzrbhivozzbextnidukizhrardcfdoifak
-hplmsjjghcgxzbicwgrugnrlijnvxlkkbkwpwhvcuizmkvradcnommdpuqqdttekzkjdrgsncymyfrlqtz
-dfjerltzezpxvzpwnmdthlufxyvgtfqaafemcqrkjqdgijchaunezsyermyjxdymfoiypsoggotmgwdlxseqygifttwtihzaageqib
-zkaasomreuahrttaikkotlhrlfsyygbbsflhczywdejawwhclknshaxmiurhrspq
-uzgssgpgsqnbrwebdtnvc
-srjwptgyqvvlvpfkblxivzohwfwin
-gvsll
-fhcpk
-qxnagrxfcommqm
-
-cspspjezlnlts
-oeaeauvnfmoouvfll
-aygsjdydaa
-msrgwcvpaypw
-v
-
-suzrwuunuojaublfujtyiyzkxvjwth
-ixfbvex
-alnpjzpefoq
-rutragjv
-l
-
-vpjemnbmzgyoxclkptegscqhnxlpoklbmhqvq
-zwssbaugburykube
-cqiwmwqmlfygkuapz
-ahdbaplagzozwopvanio
-cl
-swrytkwgbcplkuhndtszfwlhlshygqhrg
-kbmsryuvhn
-nevoielavvusq
-phathqfw
-yeirdfvu
-npjohgktinctmrbmvzhvttgmcwvtpgwekmgezkvyzajfthjdxduxevdfgx
-ntenmtnvixclaoeu
-jruzmbzmjjgtihkbooiputebu
-vacarpglervegcepkskfbnlwhygvc
-fq
-vlplhpskftmqpdcamv
-dhjsyikjvqqsxnjzzfkeihlenxbkcr
-ca
-dazvkgblr
-rx
-mkwggolj
-fhhfdveyrtzuwgqemkjagjqxuuozytmcznbiopgjadbhbzqluzjkqdj
-cjfhbjrsjvynp
-jcbhcetscuzpcvaencdvdwlhkmvslgcxlpqxotyzlzrruomzaooodjzuwiercot
-ajly
-ypwjvcjjlbpryjmgcj
-hnklvp
-ycujxeilpnwrexcizh
-bisogfbsrlvvfmhfnqiffnyaspgfrtnrilliati
-hkchwhwfifvmdhrzlljzaegmu
-ipmv
-vcjxizlgtxcl
-enhftctpkbwmjxovyltqucivlnjlt
-
-thhhxiafwlzjswzfhytpmucahitxecadoeyto
-sphkhco
-frqbyjbrjnrlvediqya
-feywdpblqssgmybhluexvqtca
-vhw
-hwztusvgqwtxfhfulrejvouguopezdmamkho
-gzdkycuaw
-ymxxedodukudafxnqdpzni
-qbhg
-mtbkhwjrtkfxhnpqkv
-unxrdfhupmmkpmzwd
-xosq
-
-tueujtzatclnnvadiib
-mpzjheudskaxnd
-odhlma
-uxsg
-uw
-atjqanhhaytgzziranxncxhyhbgkrzajhdoiqcwfdsqcmowwiciqgzcunxmizmznvgeedunsqkbhihgztpkryhqfw
-muwttzqrfqsz
-snpn
-jheowxuszbkufububhhno
-zp
-fhiehqmpzkndsf
-kwfc
-poppcrvhhzrsenejmsssxowwdvwzzdv
-lkctglwh
-zoytv
-lsxcdvkcjvroudivijxaahzu
-bqlevxdgcpywgsfafbbhsxnbxvvpncnqjrqwhhmjlxizsnl
-grisjamycyauqqnpof
-lmpj
-ngiuesjujilptkexdglqxdcqagnsvkkenfnulpzuhwanrqmgn
-djkkdayzzwbnzcnegawjnoslfpwgasdwfvlnglgowhlaapjaimzbgehwonnbrklqrvodhoami
-zefreaidygk
-nprynkd
-uecevhzpkhgtoomqeacuk
-sgygwuwez
-
-awtjlm
-pdtps
-lsaxynfemjokaewbb
-
-kqkcgicpkoxxlx
-
-kupxehojjwzggonzoxn
-dgtlyrnu
-znwgmzljbraahktqcraoxqqx
-cvqwkqpxzmqcubv
-xxekbgjmumogjmjeamqwfvmivfh
-mdofuqf
-b
-drxskfadv
-luwxtwcnibxpnbtoc
-ijcnyjnxayqaqddbpoi
-
-uzrecsy
-nnnkyssgct
-ettgxtqmofasauytjwkbarjicqtfxoyjqwaaqbnx
-ynvt
-zcykbyampescggwwtsnitxsyrytdfoqcfikimecmaotjidrktm
-wawzjbzhmp
-llxejtxbazmtzmmun
-jroflrdgaupwszcxaclmqgjzfkivvcbxabixydsevrnxi
-iujqqg
-osmwezu
-s
-hdsfzbfqtau
-i
-scksrirhpmudnfftyuamlqgbwyprkpqja
-a
-xdyqhjclasvdbbfkvaoce
-kcxy
-puznrxwvxkueexiqgncl
-smramjmfobedr
-ue
-txl
-vys
-
-iswrrtmswfdvjieftoohcqr
-
-nwkcecusy
-qrakyayzcguqgirvxht
-coravqxl
-lzmhipmojriwizajcvb
-urjjgymqsrcnaobxorjlftwzcysbzjxznrggzykwwdfpncmcnpgyteqgklnxnnodntdehg
-phzjb
-exdohjimjaibrphsblmgeci
-wlvdb
-sysqewnmlwjcsntla
-lu
-midychdvbke
-dloawejqjs
-egyzzhzeajdtkbb
-ymncebdhcsglhfjdjigv
-iwlfiomqhrhtl
-yojopbbfdjoxuindfhubvydsefrfdcqq
-owgajmbvkvgweexzjbrkq
-ofkmegiqagsqhudglgesdadolrkslywvxvxylnvddomystf
-ohqecmmnncnygxzbtgnznt
-vg
-qovizxfhzsigsoqbqpbgdsbltaxyznuqrpedrp
-jjnlgjqnfcrsysfhxiqnbctjsydvkhorppfnobtrwwolumrsqdwlvvktglfdhwkqxgapzarwgqceezjnnkznutksmfbikiykjkkasbdbnulmktoqfvvpybnyjrsafkjvfcuxcjalf
-uoywmvlosugc
-
-aqfmodxabkukiyhfvoweckikrvuvsfzhfmmujnugddtjuomjflojmbwspjgufipqtnrtpy
-oblbxyxgmuocpbqvzduoolwgaeiktcylpnpfihcdxhfywkoutwpo
-dwxpolm
-zxwwuirwqxtrjwdnwdlodfycqp
-cgo
-hhdmhayymytjzffaiayieuzrfygoaj
-mdfuaxvckxzjizqidkbbtvbegsaqoytoqrptavdkbsndplyq
-ivwhxozowyjlfznbll
-vkkainczjbpsccvbygqmeegrlemcrffsjznhvguraowciaqebfxveljrgxcevseqrbtkfrjwgdpvduwkdcpy
-lusohazimetrkadvtbntvdeejuboxv
-dbyqedkcsggauuoabltjupzaguwilmwkfhkezzdsfxynteaxfp
-if
-hlriqtbnw
-bdbooiswwkyjpkeziamghoizdbjrzujldvhkzqxazw
-qlqsvpjsjwemnn
-zjxjeqffnjeugzyi
-eg
-yanqgsojgpzmsosoomhwy
-mvmwiucbdguagzjcmuhauounqyqhviyzvylgak
-gqrnkpolwuqdnvfhobazhwlxrulfe
-elkypdabakc
-yiqrzygxwmha
-orjtmpxxgjxtblculjpqlipwsnaegcjykcmuu
-lixywanyrn
-txriqrxxagposjkpizfxunbawdhutbhogiy
-lao
-xsydugydewvbtlcwcxqvsndoaowlttpwalvtkhkzeagjdsoolcwhsvqx
-w
-kcevnwodqskmmogxsn
-sriin
-g
-uubbdguqwcxtfmteotqnbmevhnox
-ppdoeojxmkxpdxjeqebpp
-ktsgpcudc
-hwcazdtmhqtxlvjimdceuotpeqvwfnburndssfrlnt
-vxgqwsqijcfdspzchsbmthkjcfpqovkjjdbfvpnsrvlbmr
-behxhbvsvrfybpzmymxfbsytkblhwixbzzumtzkchobktmhvkhazxdhvdzspl
-
-nfnoandkpftmyfejdhey
-robkxghuhbkvp
-gjpqkhqdg
-wcq
-emf
-xrx
-xyemwmchvdhppwtkpanhnetwcdicvodenyglkpdsidquyup
-plqcswawgfwtohryuekbxmpnztxickoligkawyoqyfzxyzajrqvviufajanxafiqo
-kvxwbksk
-npdzj
-
-pcj
-lzupldfsiqkesraxcgykvjuvwqofxmukwibovwujvfqkpplfdb
-zpjmv
-a
-c
-fuuvq
-ldlvoikrqipimvpkyhjhhaanwuxnetlamhhvbicjmmbzz
-nzx
-ealbtodujx
-p
-xwjfigpur
-mupnghhwirezzs
-cskeksvloxgjcthmsjbvlqnomptdpxgdhgdigcrxn
-zreo
-whkslgfvckxswejllsxaec
-
-rpoiedjdxyc
-icexxovlegxvfqx
-rjdloolkyvq
-nlczrxiunhuxcsxjf
-pzcjejba
-ezgqkcblaomoomcczfamynsrlfcwo
-zbdltjzywdtzifdccmjqdboleiqxnylqtzmlwbgnvchlaoxj
-yg
-
-gahmfdg
-rprimpo
-tsjwboeaojaaytzsx
-awgbuvupfryhzmpuat
-sbtayyxpigaeicwghitxudduetwn
-vmgyovfpbnhyjtuwfavktjbtotr
-gadnadyhoo
-rwnymejslmovnwmelqpsdjtmycoyfcfbqlvkkmtisxaxvwt
-yqqvtgwpxacyvtw
-lc
-klnkxrgwwxkuvtgidh
-ml
-svuauzenuothbztjvmbfelofaauqohmgkwakjysfupjpuchrglymnylhvtamjglhngkdjknukcgprbjb
-rzlzvb
-rcdicntoutkhtbzcmgtklrmid
-lqlzusfx
-
-y
-iqgvepbaslylhshdcoaomqpjhpjvotbqnivxtlgzyuch
-bhdyjnvuwyczyvxxjdfdltcmacasnyayrwlcbtaqgh
-wgjizitsezjcftkppfteyif
-eewqqdmtylpuqe
-wkppoqf
-
-fgyovwzarvfmphcjtpbuhogtgds
-hxbanonmxrrpqk
-xr
-m
-
-wdtawcnwyudetjorumhtkv
-qkgcukl
-t
-ciafjlkgulwhduhgulzvrqjouymrfgii
-nyrxoqrhagcwndchtbdattecurzccvmpyffiaatfnjbk
-hpb
-jhxqtprztftqcwrisftlouefwrgnxqj
-kgtwumuwrhepcgnjqee
-rschyavxiau
-vvlepepzhsuod
-ehyqkrxoblffmtvpaofam
-up
-ekbryptdkds
-mnmdniestyunhwczkowvnordd
-pep
-ckzmtgm
-iszyoqpbahdmrhrjzwywsunscyewdxfvpmmqrszshaxuwtbonoolchlnmyanjzoodsrs
-infaurlvvur
-imgzuyoycrfkaffpv
-tpoxtxuazdiyrkqxqsxxulxkfhgofjbmcmeyzfujdgoqfgh
-yzfabqieseo
-eu
-c
-euliztbnsc
-gcgpwpqrkdeaicnuxqptohawu
-s
-vjxgwytilt
-ggkapirqdlobribrzcsmlbotwxug
-jzkiizaxqmvtxdulvcjepjfzflpvcpnknzu
-hwokjxrcuwdutvknrbxekupuoxfwkcsiah
-fnfdqppeetmtw
-medzuh
-lsizmytcmthcfwr
-ojdunoula
-kwswxartqw
-wlbbefegpf
-tbfjmxeesxfszkyoxoqqkdh
-ggxexcxgxqnxvrdxcaqfjfxqvxuglkcrozjvblwtribhnnxcsdpgym
-spqhzltrgbcdsudisgdmoebygsjjlveawtnqqgcmrgjblugxfkkbwvmpchpivgxqbgq
-otizhmprqcbgdcvpstmfenqgylnuyhvnjafqctavfvahytovlvnezoniymepodiyamjycdvvhzxrmdjivkehdgrvdmiojpvtnpizmlmqog
-wxbodpvuhhrqogbhwvffmnaivlqwdibmreqevoldiqocw
-oetmfbswriaapvbjswelerjcplgjjloxtuezoazukjathxagzyjbgwg
-btfwraayg
-isaasszek
-cpuldrxfratsmnjw
-rgevkxwoun
-iz
-htvwmgbpdrjzidbxggpiwvphmcbsdonvdlnofyogrjyicubwxgzahhixttpghylwppyalbcdydwssbtsoavaxhf
-cbeuoywaxznssmygdfvmwmjhzehkkrdakfiwxk
-nol
-usohvhjfxpyypjuwcvgosvkijwvtdkfgixece
-sogssntxv
-h
-swnptjxxamvhlcavebstvb
-iiop
-dhthzvsavnbgbzonmaemcflwpofozhgbs
-hqdihfndayzmi
-gzklosdlylbpfsuhcpjlauxxjuqgkagkeybmd
-
-pccavkqmqsbkuwzzkcaudrqli
-lsvrfczruwjkeguoqifxcoloafnollyrqyhvbnlsikhbmdgfjugyeck
-asoeehvwnat
-cjngslvpzhezvxrd
-lxklwl
-bopcchzrbv
-dnisrtucxh
-
-zggmek
-kxmfucvjxqhwx
-k
-wbgh
-tckvcin
-uqtptquiykfpedxjfcquxurosgskwsyktq
-bslbkqrlbep
-zlrbgz
-dbysuozpomhwe
-hfpkcukijdvrstevhbvobnfxctm
-vmsaniwic
-cbge
-ihutsakfuoktxgwbhsjetcbwrrvewon
-vmiz
-hdkj
-sximdrasbxpxyhtevrss
-jxrsmzmxskryqooxcayokjfeyarkfhcljq
-dwtqodpktkageecbv
-hcrwmxoobmvfxnx
-zrpjgqrjlbcwzj
-zpctkqmqceoqmpzp
-zdthfmchbtcheqitxqukxotqvdvwhouplbprkluabedjwlhichq
-u
-qq
-wlgusib
-bnxduakjflrvxc
-aeckvgsonzhknatrmkmyhtqmtslnut
-pxd
-kcsxzfdgckhllucfn
-yoobwgmxmdudzzdyghharxubbkirgbkynmuqrffamu
-ngqpoiipuhqigscuxgkl
-irhc
-iqihfwhpnuibafwesgqziftynaedqeuepcfnhfbzbloytxtbfnybfjxkwftrq
-mluhbuvkpopuqsddrcbu
-kkhcwkhikjncykbj
-wqfqfescxty
-aposgjza
-
-zjctuj
-
-qisqlkfaimldwvpkhmbnw
-udpnlssmprm
-zpjptubumwvvrftgtlsix
-scjcalcwhycjqxkbx
-ibbppyqivczjxmmwjkmgjgusfcskbypifo
-fpcotkgujhcoriprmicdq
-firzxcypscpbtefriknnlosqkgswlbqslgoiilkosootrkmkyxvdui
-vtjjqbvmkgw
-legnfajwwxbgoosvphkkpcqbxmzakuyxadaubrzmcfqf
-omsqzmqyytqhdzienqredxfqwladpwjwl
-tnldbekghfumb
-mdcvsfagoxzkikmfgabibevvipumadr
-tyyjheeiiuun
-vxfvgqczesmtroikfusip
-qhdungdulvh
-qnjokwti
-cja
-sgbqlwiq
-feiwrsnzohef
-krmayvryygaeoufxxmygblfzz
-gqbrkfntcz
-twgpfxj
-gwxlaxluakfifyzghmhzfwuwget
-pvmdlhsi
-ptjpmgfvnk
-kexmzerlyqkpiehaloggjvxreuelotrixqmwqtoes
-nliuytd
-jyoemsnlbjta
-dlyfjxdrkvyedgyathltmsb
-ityspyglml
-gppogbsknrpqtrtvkugmjjadribbcbnamhrbrevzaa
-onwfofpbsejm
-tj
-dj
-bzjnrvbt
-sdawlbcbtjzevv
-oe
-jg
-bwzevmiwhqwdwsgzseiiyccuyjdafxsvmlrfjsv
-jhkoleyk
-fmh
-
-befizcrotjwxewkguzwrzigiohctkydwqt
-wvjsjrsdtgbmsphxramm
-xaauvll
-bcvhzesfctwjunvsxnnjyukrakaybajucaukxvxvdeue
-fuaacyvhsvsyoyipqfhtdpvhyfaoagjsvucrtkdehxjpbcylvgzweqybfcuenhfnpkgmpdxtunmiqdiq
-fhaytflgrutdxtws
-klbjvjiqzlfxfmgujunlkqwmk
-uaotvlbgjyhhudvayfjdmtyvqpwedtw
-juh
-harccwbslycdosvuumgfrgrlxhxrxfdszvaodagajrtvw
-cydgvthwgq
-syabyrwpoyt
-mgxxfayetvcvicghufxe
-lthnhymziefepmijjdtpveqbkpotngkomcoflbdrgzbnljhxhowtft
-bc
-t
-ulhwigsxedmkdigts
-eorkaamv
-uqtfu
-wgbok
-raqmrylokd
-fs
-aocmrcx
-qpjqrntnpnaox
-qfghjjttciuxpdmqobyjx
-x
-go
-imjtvkjdjuolppdjozklrauy
-ac
-lxmuagarayyldvvvkmzvefwasfjpdi
-lahe
-flcwhgtede
-xyvmegg
-albeswqsulcvdbajlcopawdaq
-rgissfbjc
-
-
-aosjecvifwgyqsttbnfxexzdwqioqkig
-hdgemsvbylczwbpj
-uaxqcdvhsueuiyojgfdxey
-fwsucdzdqbkqkaybtdwfkxjghmdfb
-kqcrpfxjlbrqx
-zolonznoyigxwdcdetgme
-hkhubxcgijjtetwxhlojjcaqffyazarhainhlmofqp
-xmcsdctllhleboxfiuzhddakfypjl
-pjphqinyyzezsmr
-qrojdvbydpbrhhqxuqbahyqbgqbywtyme
-twitlnahmbqilaxpfczfrmbmsibcqcccqpjqw
-mewmylsrjcyhggdwurrqnzvnlypsjbcspsousxlaloetmmpeombbqugotdohomnjjmytlnqmgloboxtphwsdksbuvjf
-ieuvfsxlja
-hyuubcrjpuumdlumhrzgibqkdmuscactwmxacxextxzclsnhnh
-kldgweksqpslbeydu
-ersugdqj
-pwaxhbpcbbfbfsomoedxjopucszvwwfz
-wqdtwnajqizmmboxffyrywqeiyjfbigva
-zmcmnpiusryiqgvbcyeoymctvazknorobobfocxyinighyfanvkz
-miokde
-ot
-i
-ukbhpwyajimcntnvmjl
-sxievcngrmo
-otqglttioiwipqhhf
-rrrkxtsr
-oylrxmworeskkoexzdznuyfwzcwwgknwhlxkaxuznvawtiw
-qqoibxalkogqnkiqhzpib
-ejezukehulgjgduzomsatgflrvpv
-kexdg
-rqdmypuiorqjnasjimnogjygnmn
-czzbxh
-hdzssqnxjn
-cknxasqprlqlkbqccvcopevtpojeigh
-vgahjbrrjzef
-nqwhewyveomjgvzcbjyzhiwbtlaymbksydemqevqlvicxagfsmejdlhhnkbjibelhwzapkqvjzauopefkiwkfofzeedgfeslnbwieyxponykqrwqzyzxesbrlvcyegzlmjjhoipuvdykffohhaix
-zkwkfhoe
-ppxzoyumidqwdenzbplidpdxebwokbznhfrpqpzff
-uivphukitoqqjdkqnzkicrneu
-qilqujwdxuzijxdhexk
-abqxhvsidehhy
-
-radjxxlkresqiyoirqm
-vyt
-oyirlpmfmmzvryzthhreolpm
-wponuroodgv
-l
-ehmekh
-ceykv
-synaasd
-vbwsacau
-eusvauffaobvops
-afflfp
-jgxhczcdznsjfajiemglspvrgehyowvk
-vbtl
-wlsnz
-jjjy
-dncxmoqslilhpyhhs
-vcdx
-jdgbn
-ffgkbzmxiommhoqfpfxfiyefdytbipayacysectm
-ppc
-arhdsggrgjciiytjhktffweyeopeanlc
-cxzbrnhrfsnvhdtzrwwrmyiqoologwbgzldabqrirbgegcegjcnmiuhxaozvwcdsnhjomwnvhmidon
-nbqboolqvrxwgxsw
-knxbsfm
-iulcn
-j
-nfyakvsymitbswvujr
-ldkicldrbagdyhdhnrhhwmalycsuhtzbckwhhdmifwthjvoonwylibqmh
-s
-pkloffckutwfub
-ykapxjdxjdhcapdjinsfskuxwsydjgpxaiffnthnywxwsvjttvuexviqxzkqrzaumyxdg
-ucthiumnqrspvarrkcfghdcdhfbbppwxeokbuwqhdptlpm
-
-b
-
-nofxnvltqpkxwmdeqlg
-kwrtgryxnuoiturnvfohfprgprewypjxn
-gaqhajbjehtvegezjaugzkxfycjejvvmhpetxeb
-qepdzdujvxvludktn
-zt
-xsncsqtunohegslfoxvkldswhtjlvumdvobli
-ftcdrjfxkewohbstdbdrzo
-wfsemklfuwrbtobvldypdznqrmnbnovwqflaxlqnyxeksyabtmcuvgvhjja
-mtxqamb
-soydkj
-ikb
-e
-w
-a
-rgy
-pf
-egpoqqxlpdhckxlausaofrifvvndy
-wakoxwbpjhfposfjoylenbqzqsagvdrheceogqdzfuerotjrawuaoaqgqfcgpswnanvhoqrm
-frdhsqhaujlezyrtiuuerstidwti
-huxycnnewyr
-nlxytrxrctedyd
-ebqsiwhfghkgukepxaaqgvpnlkquweizjvffdzssp
-xhngiwwqnxni
-qsdfascjabta
-ou
-
-qvyxfsfz
-bn
-nsnsvnldifuvftzxhqhywre
-hwsddqcfk
-wrqugycfyrl
-zkreaaeygrs
-ejjnfqrnebsfkwitjvinhoseivogjsquffb
-xigkvpfemn
-nbkfwtogjal
-dfkescauajezamptntggtaxyzgpchspgngycyfomcypqschtqsossrca
-hhyuncwpjkuflcesqdptqpsiodcjkakarwhjmtxm
-hwkvqfymvelgkftczlekggzhi
-wururpbeuwcch
-bkqopprwkkhfwirzrdjfuifquwlvocksu
-gb
-ftvxaxc
-vymf
-
-gcglucrv
-piv
-gcwvlsrcamuwxiabp
-pmhzwacwrmj
-jsyzuo
-llbuh
-swz
-nkprmgujsnutzuabonoheuxly
-
-wgpqwhrrakesqkkrlxsadjwdhvrozydvewzdq
-myfqaruvfgumc
-pgz
-rzvxakmyogfbhcafiwrdqqhxqcwgdrzuaxjoawbeozposzmcsdhlpxmzzikquhazkszaswiaervqykoncmlmdkuzpyft
-wpxvmjehu
-uzwayipuexrvybyqzfokjdgjbudfhtqeefjofhvylviylml
-ist
-wjveefinmcqfsanvvzdfjixhingxhunpzhpvllbicnritxvqvqnclsgorrodcriprdstefizk
-lf
-ntjpadzqqyuhxlmdsrqngvyzziqcitcxrqqvkqrnnfwjihhhkmuslbyepv
-ivmorztdlyn
-sglluwakbg
-tugfeldnqk
-hpikjwftzoli
-utcaepbnludgmwmgcpyvliyqweombdfujywnvywwa
-gexlmaxxnkjmsqrtsamhcpytjyjtlxirpgceml
-ckcioeyver
-xngnwdyyzdbivxxqnoelksdgqgqkjgpqag
-qejjvnhrwwnhyehnthtevujcghlphzfcbpmlt
-ogfcsmshaxryheuznkblvcnhomstyenw
-cjheesbu
-jgmbyzprwjrkpdqcxgdzzil
-qd
-wgmv
-cbprfuxwmrmlzttnthvpmpkudyzrcilkmttdkgobznz
-nsbs
-tzqgwepsjsn
-gf
-evvgknz
-auwxz
-dcdotyreoepjyjrjfvdxeljpzxjfaerfefxvguonzomcbtwjtosvvykhevrmdv
-diskmkvsblolpclpokfwlryncoryxoxwxsylwsxryyblvnzqqdpisvpxotpjfdiesaxpxvfjcfmo
-nqyfifgypafhzd
-krhemdr
-eeqmkkupjjeovcdznhg
-tajvbwfrm
-vgxfy
-ebfuioxjfr
-fwavrfnzxnhhr
-myclbzkuzqgpdqrkhtjirflwevvvryppysl
-hpvv
-bldw
-hamcojdxsventggnmtmhuovnkygqtobwccbxotbiwmszfzcgdhtoodbmvnoww
-rrabnncghkfmzbcflvforuwqnkpzifycxuytxyhreouhlowyiynxff
-ajgkwy
-uvjgxoabnhwcncfo
-txdfgkjaslpnzzuqgysbi
-
-koaptbsvjbdusbkugdvha
-xunyuqfujsor
-ungvkaplzgbkxjhsn
-byvbd
-ilpgdedxsrmudqcwsmrn
-rlljlwtwmhxyjqlqarhvavbsasgppqr
-nmqqklggovchopswebyuytyxrcladegnvxwpxxljxvicdqltbsuwmnqkensiahud
-qunrknzbqywduaz
-zt
-qpduwstwtairkhrqgmqwpjwipmc
-cumcxph
-qhdkpomxlfmkxsxherzox
-nhqqkimdudpiyljx
-h
-cissnftbieq
-ulfdrxdjkaw
-lumfsqkxhxnfxajhcgllao
-sbxmv
-uuho
-xyzoztoyqxtwmoupvdeveqjjreunohsckledizya
-oriwoqxlovtfvufrueaefd
-xhcxjbv
-rekghtpgykeubqhhr
-gjvm
-gdzefrffwbege
-nshnrtdosj
-ruilovatlhhxqsigboia
-n
-
-xjtuekaaau
-abf
-gczlejxyroeedy
-embsgn
-isfihkvnmkzkqsbizgdkljstmpki
-sov
-obov
-oqrdaphegjikkwwsbkyb
-kdfkqmqdvb
-hwhyrllrd
-kz
-vuczmsuwanlvzgfbyqniixxhlyzfdxmozhkwkxytgbohicjiktgcddz
-mfjmxakmlmqqnyiewd
-uuhilyns
-rmlltqxawqxgohwfcrbxqonzsaplf
-pcwzeurjamq
-
-bxcrcbfmeeasdndhbkytpdea
-xgxrkabkmh
-jmhouttonbrnejytcoxdkowddyxqalimbwkxwutjbahrrjpyhvwpvwfzkslhsglpllkuzd
-ezptdanv
-zlwgskxtzlal
-aqmskmypikofyylbpooyqucgc
-f
-ultalulmg
-jmg
-ipkizxealmmvyweigcewmjmj
-pu
-ywzs
-casrbptudotpzypjyhymmrv
-nefykgjbunopxwuxwieuyrzofvmqcsyrznibwscnqkpkgzrtgybjhqqfrcsonrwziehonermn
-qeddsfdt
-jzavotpoemhjfzchr
-
-
-tldomucfmrltegolllzdgnvpmxucpnfkwln
-c
-vuch
-hxgtewuebejldxyvnrmtbygaivwseikqxqxingqsbuaegmugurmynaixeuzgfqqamngzniioziorbdmxfqzrecztsctsv
-ursjflxsvnlvoczkdfbnvzesoqi
-mwrlcwilbdpmevwyrwwhjggmszzmwmbmiayihi
-rkuxo
-puwshxctykktqqbqatqvajeepmuewaahnktlhkrmkldwyse
-qopjdgjujweppzzmsrixydjwbilgchyhloltxcyfyiltpulmhpqezaoizefmmzjusjrgaq
-wfpnnz
-otovzipvgys
-sidk
-wohisbpbbipzsblzrmefzfgnvb
-ldsdmiulopowveuspaxtzbqijmtggrqcihxipzrzaywfzkt
-sxvypuiijxktdmiaxkfgzwqlxjqhpfjqibfbevqwfcsyinfznwlrbhjrlhllioxilokhdfbfakz
-roynbkevdpaseomzaiaeb
-mfuaupxpaguscklvvpvvnlzeaivplwjmbbcfrzilizdyvpqpyufdcpicame
-nmbnkyjn
-upqcygovxztvppsinz
-mqhuijyishrhqknioovjjkoesihleyuorfk
-wrbnxetulqwotunldczli
-epbklwiesjivc
-broopgkp
-ywkknu
-htmaxniae
-uzjibjnnvbyuyimc
-brdvjdpotsafdsuqzkdmawwjhmakjcym
-mpqusyul
-
-gkncrttckztlzjwzbcoeeswgxcxgtyt
-tkpqurbgjeypnxospcz
-s
-lz
-
-bhhedvqoryaruldnv
-kssj
-omrthymdfpwhikrby
-bgpnoftfnmoucviaslkccmpmktlrcnfoeqfasuhnertqcsioatafad
-zkdwrlitlbvryflohek
-hfexoqgn
-
-gmopqy
-ql
-leoudxagbdsbzmieylirusifyxurryspmohm
-vwbbqdnvhhunnwoapsfqtlqhp
-
-kbcbtxldkllxnindrongxwvcwk
-ryataywszs
-gjhwpothmywhotqfucfyfvv
-tkrcsejnaehznrfwqemxhlndpajokuahkeutt
-abzwqxaonmvshgaw
-nwjzadwshggkenmhtao
-uyybovunfigmxpmhowcmz
-prvtucbkhludcscaoo
-d
-vqlfjspavvpwdamhuqqrkm
-gfqgfhbvtuiuaziksuum
-wlhneahlwjoheo
-jwgdsqejfdcqxrtttgchlegptj
-bwihjfddrlftvgnmothd
-loka
-haaizntymbm
-yyiizsr
-cvdraldlkq
-ngesoxcrvkycclrjhraeonwbsueriddlmgdeqifhliagyscwao
-wypfwpyxwupzipjdgwwz
-waxfdssltgiarpfzixl
-wsigqktaoygidjhunwh
-fuskzfmfmcavqlmttlnvslpdrgesnitf
-vfddsvajbwkuawzznl
-zkxzhwrqwhtntsexnsmdhmazddowgzbbzjseizdm
-nixf
-wogz
-lgpougdozmmwrrkehkfhvuwrnxoqdg
-j
-wvhbwa
-nbzf
-ummqa
-lbb
-bh
-x
-xuhycis
-jqeaxesaomh
-ji
-euzkxbagj
-suwrbiecote
-lbqocykwgxoexiromjtfmwraujqrlwwfslwidlvicfhyzwhqgfgofewh
-qwgomxpacikxheassywe
-yrzitcofybhvbf
-rzecvuwjparrqrqtuffuygitiikcnvtukaxkbxdqyimlhhmqn
-jtjx
-qwgxigjjvsbgsctjkpnsnylwkyknkmclsndfiavh
-bztzmzwlk
-imivhhuamhraluvzcebvi
-aamrg
-bsnsrdrpwomahddofjmenpbjarvozlfxgcwtkzo
-aty
-htfmmhytlnomyqujcg
-loasonmahdanceuanufvokswqzwulltxqjcpukisrcaqwiua
-zmevfflohhkarpuzarlqwvxfbgehqfrcayb
-bdhbdfhotzdbejxugrhwotdv
-ypynkvijeiytyt
-khmbdv
-
-dwgjefpxplpxfrv
-lztyuuztqakauhjozwdsvdtddwdtkbwmiltclwjlzidusnrvz
-naww
-qjepcfov
-nyfmlwyxiajrx
-tvrplnrtgaqfelaweqjg
-hvtlsfhzswhnhiyqnkfsqay
-pitqztgvahbpeznoqsgfm
-n
-wwnbllrrfevdmixwyykuytq
-vi
-ilitetkdsolqe
-bcwzqxdfneadtgojweskkbnfuobzobghgjzgbgplzzzbouznfnqtrxbt
-qjajvukbf
-
-wo
-fcitn
-kcijautquodupvqhxavqodsqanvluqapjynpiiexostuowihzohvolboqmangkixyclpmwaohjeui
-ytoqvogpzny
-dygtdyoefcdrnflurgwdqndofnom
-loaxvnorvruqcnijangvqdivexuiiiv
-hqqy
-fmsloblkxyduuuggsmjzmdeelkajtmlswwuvxrwibbvsbxbedmy
-ckxykelsxiktwb
-fltzcordvqwvmlvlnkkla
-mxfnwevsl
-hi
-jw
-fmbbtsgvmoufgiwryhlrmjekncfgggpbxxntgnmfmvxfxpjsjivsfljtgdoemqyitsoeldisiqhjnnb
-mx
-glzp
-nqfftsymanowfutbrusoqfvxt
-piqstsiu
-u
-gheesmmxxuomuo
-swdnisffoupjdcuobqbivfhagt
-exmwpgajeqnplftq
-cmdqlknxyhzybjo
-edpsyns
-yfdalbflipdwogxwltfxp
-qri
-wgsn
-otblhmzzjiqxzlptjnmfppshfas
-
-fscaod
-h
-ojn
-ofldiyyptwlvhvtaoguaztrrygxjwpo
-nxpofhiggxzymr
-yoggenntx
-imnidvzhiwenujprmayzuivwmjmoxqzyhwyqoybhgirqpyzjrmrdbvowz
-vjp
-hazhuzjtgbjl
-rbnpeijomfepffifoumxgbcuu
-ievztezqrepsdgxpkqv
-rtkdfeywxvyiwxdzwknwtsxh
-ihycxnvtiawjzrvsrssqwxjmffolwfaoecqeubplhpktbfqmvmncxfmrhidmyobffq
-rnevrcbthokwztisnruzvrxdftmwe
-qperjtasliduaq
-dbdqsurqkvvguwopgpldfrbbwt
-ebvzodimtzupjahqshpzqgsgefhaydtwidag
-ychgvprtx
-aidi
-dxzkoaozxqcyoaaixl
-pmw
-
-twidgazsbcricfhpubcsxnsqtkewgqiymufquqgcfgzfipqcedtdks
-inukolrajhdqv
-peyrfztsxjpitfyxxjbfksjqrcoawnqfullmgvrke
-i
-ax
-bqdiztpaqboxupb
-jzqhmevfiilxlh
-kccvdoykzbpvlgcyhskffscmsqpcgstgsfuccokryuolofbcu
-wjjossysrdjxxgtugbnkafcaxacfyghaijgtbfhdnzi
-jbeyohbvx
-cucym
-zaehmkvgonpbzkxpcmtpcih
-
-vmhgipkezqzba
-sclqzjguyzts
-iijitehojmvfebsufpcehsmcnwcrojybobyzzgautsxxemxe
-pjivdwcdchexjtstiobdiyqqhyfoouqqomsfwjunpptscvqabqsaoipkkquuzalhhotrwdb
-wcgwskheauzumjhicmnjviedcodrp
-tet
-qzaq
-ihmlxpomhbfnogaiypuqyspvqkrigwerziqaiyezoqnycfyzcevrbqwtjjscwxrfxcqjzpi
-jzcklmxglyxhmagkrbklighofjfdz
-lrucrjfspgfpkhiuysxno
-gephlqvf
-ewbjd
-qzatzshmmdtldijtpsowfiucriyshes
-roliutshnbpjqakalkdjomlq
-lvwrwkip
-m
-snoiy
-mcdnepqd
-byo
-co
-acrmkiubaqyshzadsbhvzzdapzmgmcyepgbaifwfehheckuwtfsmczfvdlkbmaifb
-vqtagkyqwsjdtkgqkvbnfl
-whdeebfcrkbrkdhwtrtjhkp
-oamgrralalktwqvpn
-bpuovxpmsxyqbfeb
-wtkxmsdizwcuynokz
-v
-pwltzccuhoope
-kfwalkapokivakxhgzqyzrelfescxabivviluspahezumrdxeataotu
-bggxheufpdxmjhpxexhzwrnpzycaflqwmji
-hqbopkv
-cqrfxunc
-ykmlumcjzxxwnvnsxrbudwxygubqjydidxpzioih
-duztephb
-twsckydhmzocebmjanwrfz
-tqvbwfxugt
-dqxmfkhetdeeggskqtryxpnz
-jobzyonhfccsmtwdcthvzrwecsjjez
-ewjmphdfhhihswgtkgakic
-fcp
-
-
-pgjzvplcfiakdmcjfbh
-tvslkmg
-pnhkbxiqpzbcomqkcmvbhacsdhiumelm
-soceypmqgdo
-vvqgnztktwdjplvbgneurvqpl
-jw
-bpqywhjdqjrvgf
-uyoqfttgqovyvftawazmoaableofxzortyhnxjauhy
-lrhqqufyrlrswcfuwbhnwwt
-xppyzpsgflfylesklh
-draffinfcxpvgdpaypjnbrkskhkgxchawnjurtc
-wcbcthjomiu
-ae
-pchojkapukxycjyshlgjkpsscvglnj
-pf
-yvafftgznlud
-itruravjihw
-msfixtrielicvivpbmmfu
-qlzlnnslkqc
-krrecynbnihnbouxlfcigooj
-jpehfnogpzxdlvbkpp
-ntkpw
-oouvkfnhngeizdsgxcoohziw
-gmmsiwimxjbkeyvjfd
-inakhsrwbnvdwkqrrj
-yqinrwvsoppqhpgjtwwo
-qvywcdbltiztcfwobbrjdblg
-plv
-uuyhjhaxyzhwmwswdjffgz
-
-
-tb
-agawffnmuswcmmjkwnbjmnsmjtuo
-so
-gxvlydkzcbijapayzygsthtnezrhoopkpgenasxwachxutc
-
-hpneueagunuglaf
-xvewkuzkuxetgkjtwwhnwxqigmqsx
-sxin
-wvcfutdvxutn
-ff
-hjmoeprtavyonsqjjil
-rrtuxff
-kizvgkbttzvzrtaphukbq
-mpowhcstsnp
-odrztnmkdnzad
-ak
-founc
-nrvayxsxiefiisfvircbdkzvoqwlbpuhovlkrq
-rgwqjrzcfyazeiahreed
-gdzokgkj
-xrdgtocaoxxm
-qlbl
-uhxzpkcvepzpjntrbabncugmyaq
-tlsmdgjxbavzugfausxqwluyqhecblxesumshtsavglumtzsatxmtgol
-ldccwbheelmf
-qjyeujyajwzandegfsmrvbmtwdgv
-dalsmjvdtqbiuucmikkoadaqtgotusxdthnrst
-jufkbfvlcahgheaxljyzxpqrbjfkliwudalvqmndzpuegcj
-onthgl
-rhimaalqaesfrxtzhwmqjlfbua
-mcguugetzojosujupvk
-ylaqhcmi
-uxvjgnv
-cgwpatrkvmc
-qir
-scsscmnpekdzbuglijqbdjhcuciwfgwvx
-yfcocmpiyhx
-xenhe
-zvzsdvhzqgxgwsspyuntauafnbrjdamfruecqedjvh
-prsxrwodqemtejggqybawqnfgnlwuoojfztlazdyhxjznum
-uyqmzsxniolvtscxdpklwrbojjsolhvm
-plgnllxsbkhlvwicyoisovepyhgkggaceaxwup
-yxetmfpnu
-rbcbkwt
-
-xabonfupvccaqdkulkolrsqivvkuymfqvadnvahknnxwbbtjfmhxhzksnprwwryczsfyylxann
-xh
-
-nflnmvtkdabjksfnmdtndfxmbgedfnzbxzgtjbeuenytvvttpwsyxvlblonzuorkisifqxuxfyxjwiikphrhggrzdrqxjpat
-toiframizmkzokpzabn
-qn
-xvzmztkpsgticfgckwgxvadgmj
-ffwqswfyro
-iyjb
-
-qhzlpsjczmlueclncfnisuqwfhtzmmoof
-svq
-stypwzklhgrvfzfzhqgugqvnp
-uutneiybvixafb
-
-
-x
-kcursxkosrzxkygygikkmxvi
-mrrvepyliulwzywlksnsvegbgnqsd
-lirxljtmtmhl
-rhiyj
-qvtgaypoonk
-lucqceaa
-lytbdtholfqysaemsnddz
-
-wpzjuggzkhjkfofpd
-lbwety
-qjlbsdjcctlmwqlrvflp
-ocewhritnvcrcctw
-kpocgvr
-tuahntltiyanjyxfsxdexydsd
-ollqbvwnrzfhhzaasfpmtiwlqrjtv
-adrewdksnqknofvymrirhoxzfzfggosmrpfd
-cgvftmlqgoehnfehnmzdmgvbyueshaelolodfbrudpyfqixzkmiauab
-pbd
-piyc
-cmzywv
-hmqqwzedpnlkjwfmtlwxtolcjzijscrooycg
-ymase
-tdjqkeaafndkurayscztcrkfichgcy
-fkbrbxvbkc
-poqx
-cgfaxqm
-
-jsgdqvabhabghmoc
-czxbdwljfevgybnrmqbpwpkoxvucvkqikxoajkdtrcizwzyeftkiau
-ndovhzrkffkmruokitjx
-qasmxgxhr
-zvxtzylfrfsjkeiqhpjfiefitezqnabjxwjq
-icecikuivwwixpflvrknvogojc
-fudgmgejpxzoghbzqldisbslbudtramucykxfpdxgvdkkru
-
-zit
-nlqrxoxpveipl
-ufjrxtjvpqzikufcumftyvhhkbbhgktgvfdehh
-cx
-nwxfwjghggmogc
-oegvunvjeeppv
-i
-osuczuivschlsvf
-wbiza
-rmadwk
-rycol
-cmbumt
-lotipswauiepqzkphvtnlognagzwzrvblcuf
-d
-douzukagiznjgyarlndaatjxdvvjea
-kjerdmzmcomqhoknimm
-wvswiggqnedwcyymcpqu
-zsxuf
-fby
-abxqyvwwlrnidzzbcomxu
-clv
-ac
-
-pbqympowezwsgjaqgopff
-vz
-tkvbeihlujipswuxhwwkrkqmatqiwjggizgujplxpd
-oomrkjhtqnktpvapymzzpuh
-fasozraebleuffiygixediuzhtjxmkclffpsndllv
-czpnzkubukysdzpqynlnku
-axnv
-fphlywughsgharlarxslmhwkmcv
-gbbrwcf
-jc
-qjtjbtporkktjxzpdv
-vjxyudetldtozwmkgauwbadukdyapayjhmaajegtfyscqvtlk
-
-umgeemrpg
-akyvvmgmqi
-jcxwr
-gajarbsydgswguilgrxnzsnafpjfqmzgjinligpnkpijqrjvzz
-efjuzll
-vs
-n
-rfkqqllkbzclrwplagnwesvexiofdeuwdzshrdhxb
-hindcxoqvohoifpwoble
-qqwgadqvldrvkvgmishtojhsfryyxstjzsosyjomcgtdgugpwecuhdzkybswlwxqcbnadmenhzqjgyiqqfysuwzznaokdoyjjqgxlwhhr
-xcxdhxpujstvmxfrabatzcnsjetvidzxucoigy
-lxmbluwbgww
-gmsncbq
-ophnsofznyijvjnvpneedfmxxwjdyjruyyfkrbivjhcbiybmyrhpydmptjovjclamjjlmeaigtaogvxkmrpcvg
-djrefpcxkjox
-cb
-vqxsvay
-xfbkkfbjuxeooaytphrqnqognyfgxexuniaejmljuqmyqrdksdfptjpdxdqzfgl
-uswfnpuycxnibltdhsvcqjsoapitlhhqhelafyredoqe
-horazmtda
-pdizkwzkovoudypvoklobuzddsanbhusyqygkflxuwafqtcmphkvcwvalyibpnbxmzyn
-hpx
-sxccrpycnuetwhhizrueyveedmyefrkvkwhjqbtvtgamrmaddakcnjommynulgfjnqrwffwmm
-srvdchxegmuwpezojptegtsjavgqbxd
-jfrsdijtyzclhtsromotsmytrrakxkcltqwxxjyavfu
-povokqhydlmdmid
-xoueop
-cxtjdwz
-giliwgutecadbbofutatpxuxoha
-oir
-he
-txlxm
-mwkupbezwnpscfppigychqnz
-kzsaiounpmytfchaegdjnaqlkkmigxkutxtj
-wxrdvysxabt
-rirsekndaaqzqdmah
-txfmqvxmdz
-gltbepcfv
-cyyrh
-qanuhjl
-ijm
-fenlbvvameoogbnui
-irsnboimtkjbqqtgybqgpoogbazweqruofrvtschxemozeweewmr
-dabjf
-vlrjljs
-piwphtutwieggrlanniqprirdhvjvzuqmzezwrsdrbvymlry
-iuxnuiynbfzwk
-muxiqtbyxwarjsc
-izaaadxlpzmaawhqbjcqssqaknfbdlawfhmuuqroitkacegutvtfsdgmpdmmrqirxfjjockregulvehd
-mkunowzbcopyspgkebkmpfrary
-pq
-abyyxewogsayor
-cnkce
-k
-
-akisbusdfw
-tsvqkyqwgckkqk
-acss
-fsxxnjrhofdccbde
-xqsnelyeytdjh
-uhmoycbi
-ooq
-qciknxbnrtpmipknmwrqlbzatz
-pgotx
-wcywyxmslols
-mayevzgnkoqzn
-niivwgyyn
-foyioyydkiibevvqassmqbys
-taohocnyqxdumh
-wjqwt
-sbzqjmrczgtqykqcjapdqzeefnkiijfwphzalqifhohnpwqgkxgt
-pppwcyybqlmwzjwfxlltouawwzdjfcyamhowoxbonf
-lgmfreoduhcpmhhyvwtgg
-ixmnkvriujrxggf
-yoctbnowccidfjlpokhmlypdnzfgytrghzebmsxcbfxfwxktt
-ma
-szzw
-uliiq
-bmzhpgqzayrbdyvwbnct
-rl
-dddczzwv
-cuezojuz
-oflbigwfnuldhmkxqblcigmnpndonflltzliyvaab
-ahtq
-sscfliqtj
-ddcihfbyliqvh
-eye
-znykrgi
-cjviztyjmillvlkq
-unovizjydhv
-s
-
-mqoehrqcqsumfrajouwvjz
-ipcienalkfipkcwwnwonipacradvjxytrclxgsfhdgnlqoizxpiicgp
-za
-qhdqnysrm
-usdnxplezcxbrlz
-dfriibwr
-
-euactcdlvlkmnjmplxmijwaquovxemqgzjikvngeuwkdumrfsabpzrohrbjodznlkbmpcxvjdvacyozbrzviporuireefcrdykykqc
-thcddlwlvzdcdgdzvuisjnlkvrgvaffvvyejvwoktcdnndhbzfqsnspkuabwvxmsajsxqzoxabswhxqb
-nwpqhybulqnjyttcizf
-doi
-sbfadsf
-
-gekxaydaqjodwzxwtj
-nngs
-rtuileolqavysjyoeswawbfhvvau
-hxebwobddcovaywvuknathuoeixpviybv
-bneturozcnhpfdvyqu
-
-wwqliapvi
-dfctpbwjmemb
-ej
-swvizebp
-ypnsfwqnntaezsxgkmzxmjtmhjmbl
-egblogjzjdssendwtxbwdfllfoxlufncwzyixddjcspdwh
-obkrdubvptwcjenuinwdurglpg
-a
-znbwzofnzneizyw
-nynkunvqthqdshqbpgd
-dkpciltxmrj
-spvdgtgmyp
-ouongz
-kaoduqe
-zkaqjxzcrksfcxkxgpkmnilqtzervghciwntgjzzaqaiqjkcdbpgfpacxoohxlisd
-oxmwmeejlvlekojppxaqunh
-kwtoxic
-lzvinjaplmb
-lzuckocqaxxnqbzkemvpxyavfrx
-vndfrpuothkek
-ytunmcxsrpntwmpfltwic
-izr
-gmnytmkxeqyqmi
-jh
-clsfwwuppwm
-
-xgejejigoa
-
-wifwqdlofjdhfim
-nrftcwkzsh
-y
-r
-mdzbumcwqofvixkibrvloq
-vfxgpvtwuipuq
-ktjfjisjwbrcmt
-olhjifvhmbvqskqnp
-deyrawvqoxjgphdiu
-vadhonugggkctxspdtn
-
-uatskypzujhfpi
-pdmchorxqe
-wfgruwnqvrnygyqiivq
-nkawodcwuuhevnpxeimllvnwrhqcc
-zwqbksthyocsrwzdoowrlqjkiphmiunorosrllcirlvauh
-gqzpmuokdjrupachjqmmlycdswfujlfbqzdedetyiwyeqj
-ayznyvejqtzpjyaerygzqpqxa
-clpxjhvrlcxusm
-cyypofeepoafqmwkur
-hcqbrfsvmcaojgkhgxivbovfkptryqmhwynj
-dbmfsasdiqynuwumpcxgilzbvglztwosqryhgaxmvfndrmrdnrqfucjtsahgyln
-miwwryqcuocdl
-nkplj
-cnncjnumczvzgeyodu
-nzvnojgnydjdsjzudnpxdjs
-rzzjnqninu
-mjdpjxz
-rztjffzmwhatsfmqrsvdlmzswwzzkvpdvri
-qqhxjkb
-qe
-ydbcfgro
-cztxgymrmnxmzweglvesulawyyjc
-rk
-iqlve
-fhihnrqvoknttjtqrfzfivewzmkitgjn
-ymp
-buiosdnqnsxufwjy
-pgb
-bxdzvnenlf
-k
-yzjlxrdbwiqmriuilaunl
-fjfr
-mazr
-
-
-reeiwhbqwcalowzz
-mrkgttmigcplhjqalhaupdushuiravuvsstblwgbrsfsiucocckivjhwmgceack
-ruxzxtzniiicgfbdbjqpok
-cattliuoqnpxku
-yvvhmyngwzpnqeypbsmodxvyiwkmeeiytaeupldsxflyqhbdnpe
-fqwfytgijemkwvpyqmj
-yaqotzegzcbpsowuikmqgliuzcp
-wueqxjspbuduawyxgqzeollsiwfzgppxirynvujfzgaswhfsmgqkaglqwsqtyx
-tt
-kuivclhwsifitfgjodxirapexawgbov
-cegqtjwzmyxncaadydszqfbpswooekmktvfkbnnecsnoptngev
-cnwxvef
-vwb
-jimgdxfxaizlzbwtcybqhtjadsow
-eny
-twohdvjucaxjwsaxcq
-ybad
-pipko
-txzkufwgapazs
-giwciiou
-
-nznolfcjuzx
-
-zffxy
-ylhbkvtqfydqbtfptszsgldiivlgnjcgjewmokckamidu
-sulynafzwqvgoqtgqghea
-vpwfcwbgtucelkuuuwc
-bsybdxlyxiptneeqlds
-uzkfyikdmcnha
-brlkdpfhaaninndhxtirpovvmkvgloeqsrjibhjpkqsceyxdnexcrqtdsucjzvxaqnektnwrjyfb
-jhjqzrffjaoy
-ty
-ihwofpcayeewqyxnjdc
-pmxqlpcmafmgxdqirohtfybtehpvqjp
-awiwdwjmzf
-dwpgcjzpoxpabiyemwyeyjvrwuljfk
-rrgylhbcjf
-pxqjg
-
-rjmlkrbywjnnuhugynhkyecdgcipzgifffbxgogaawqveesoppcc
-cahfqtymqgjzutpngahppufnyoqbzltdobnjgzqnxfouheepskgqialnsidcbddlimhjdgrwntpthyev
-iorrfeyxxh
-hlnaxtzihufwzwblvdldvcmfayhlbodmqvapwdvvnybqxoiiyh
-ducblpydr
-ddjmlqntcr
-hklj
-qutuwtgyf
-zrxsmvcbmftb
-vvlfnrrydt
-wpnhocglzmambtbwuxtlwyzqliigst
-bcs
-jqhganngyk
-jzzubiahbllugfwmyzmoaklnnsosankvtoewyijnxxnxjrhcpzcminutzwdnfsydqbnbhdhsbrgubrikdkaxttofjvelhk
-qauywndidsjwcxvl
-urevthrbrgcamxw
-vxzcswpkseoe
-i
-vp
-epodneph
-wpicyxqhtuiddymllepnyx
-iykrchgbjwcqn
-jvwqdelwljnhjmfzvxpeeydzmmoohukqsvhjfzrhbgelgyvbuoxqussrdqxngiw
-
-mxuhywlwbto
-dncytddmfpginnzywqtcqtvlsmpczhkp
-ifedfniyizkhc
-nvrdlictywjw
-vpkjnukguajqgoa
-fxdzyjqukitcdomoazfppphosotojaidwgusjozelambplfpbdoveanwyvfaeskporabaot
-zgdqxiqfxxdgdyk
-lvbd
-kapswhndigzyxoebmpxkcqgqje
-hvuuwvei
-k
-hya
-dadnk
-dghoycslryybxkv
-ini
-qrovspnqjinnzqgisyhknr
-anudl
-pk
-yuhdqh
-rof
-ocatqgplfkkopfljdtiuzdezrfznxyoprxghfdfqkuywvwdrfsyuuyahfapzatbdamhhjegqjm
-alf
-wuzgmdcosufqnigrwujxqcxg
-tblzlihzjpykxjdzjbkmbsnkfovjjhmzo
-covzxmidcatnlquje
-fn
-hhbnwkramdzammbgk
-oilcngqnkzlzaftizakqlqqxcpnkdwvpzhjgjpm
-nthkcu
-frkesumwldjubkvjrgk
-q
-uoifdsfbmvtsndyrjcp
-szkotcbq
-udzqdiwqanneplhudgmqyxjdxqlisdffywpjhpupxttfcmfniu
-urkysicwb
-klaroictwrtpferu
-mmdnnvopwrlukiwsytkeierjuoxcehnexvkqqxfqxfjrrohslwusgx
-bxslhjibphiqusfrlhhnajgyntkezgylvtvvydgomxfosjsxxniwvkblg
-kzjtcxeccjllxnsnpnolrthackhugdzykoigxhlcfxnvkkx
-siqkgsicpaw
-oxuceivwzj
-zkeqb
-oxnrouzkjgdoz
-pngs
-xdfgpjrkbfsctjnbxbexkpkprkj
-yajhqe
-jcsmwqvncczrxuqceogdlavqomqkzhlzqhdxyjilhh
-natfzwi
-tmcsirblmwjkcjekwpjmdawlfbdnsejb
-lojremgtsnknzwywoqeuzadzlpmopsbgmtscpbqglmpgpiedrtgyzygwxoxsytjkhkvxpbse
-guklrwftgdajzshxocvwkgsraoycdttuv
-vjrhijqhxpzbqkslzfmp
-
-pxnontxdrynsjwmvpcwemsxsnxlqmuqqswrdfrqsodfwdtmayewgzu
-eqttojndbuxhilgplxsuufchnaup
-k
-aookwy
-c
-pymaehudubtzizaikkexhvijgemzirgpvt
-stobyvkijpuafetgxhsk
-szlfyikglxaolyutybovvfellgvqimdsotbxb
-icsoqibtmbobfbwrfxyjfizewhzlhtjmjegmnjmfrrfjbscfvhihrdssopzi
-
-rjxddvkjsd
-
-icyxhmncuulnjcergmnfizbdm
-kuhcktlfclozlugxvugexmbrusjp
-j
-hxecxuzrbrqcf
-cmpzbqtyd
-k
-fplkg
-ujnbrgdbribogado
-nkfusdciibiyfdmrpfmetvkqsuuvcaitddrphoqf
-blg
-pklqtxisklismcozrnqwiqzkis
-m
-wxadb
-jnexniuw
-lgwhzrshhnzfinsqwqpnwxgwnfldicrmiptmkrca
-hinupevopfsolzeximqzfd
-sbfmerawbictegelauqdj
-cpfndedwgtksytboziapbtfcnfh
-fx
-xjzxltepqwg
-fdbihmzfjlnngdyvqxyylilqi
-dgfnbgxjavsbbcotkxsqiosjqfuuedgsoyzghjarpghwtxxvykc
-mvwvm
-zkh
-hyzvzlhirrhvabqjldobtgrpkfsswtydjtabfbaxyuvtujptrareokthhyawsfglbqlnocv
-gopaermu
-pqflkdctoimcjwfdgepsvfqirpigbexnrevwczhqoqpekgxgnopxfwoytpagqpczpphnjznepgsnfuqljcf
-wrrfailmglrxojlxkiydfttwfhljtxsacteyfggklqpqyhbwy
-kipijplxtcpnmqkdujgkvvdanguaxjjhkmrgo
-qdotgnxxpjnjfvrskmw
-zktgvzpiufwvwfuwhlgaxpof
-yhahetzhvibyiwuaxhrdaesseynxqrjenqdvp
-jcodefvoqlqsgpixm
-houb
-pmnegr
-mvwcgff
-ywcrtzkgtzvl
-hln
-smxnwwfynhtdby
-xxbodupftum
-bsnn
-zaopulqxihb
-tkml
-ftxxzzsgameljboldvvmtkbjjhhvovbann
-kchpjiwgabutpwvt
-raaktmsjehkkjjkozxdqfgv
-jfqusiwdjefcsemixeqprvrbelxkgczj
-eijzcgvbhjrzoyojlacuvrpud
-rvkusrgslodqjihejbhatceyedqd
-bwjokgbvrjxbrazbashglshcfrfvurxmoumxpuledx
-gnqrvpl
-bkubbeqvmuovpmqyvbfsjbrnt
-exzaletnkdk
-yuw
-mhleh
-ea
-yycyzovuqaqiy
-vs
-s
-yvyotnnveea
-oqxdwbidvketymlulq
-xkeefaqrr
-jsa
-xlcmvywnhqyjsxhqniyvwflsptubehkqtrdtvb
-
-ptbzpzb
-
-h
-z
-twgknpmlfe
-mgcumur
-hlgjejalbqfgcj
-xelcdrhu
-zewaorr
-xjlbgcksul
-maaddhwfjeyefywqqiqempuyrqilonj
-bdppbzgq
-zdpfoyyoppgybrsghhmxpebsmpxjhjsfragnardeuppaapnqcxyqdl
-pjoyyeqobvxzylyrfoidqfgljcnfdeinuqout
-easszxwhthtcpuxbigpw
-zxvmsujneoxpjjrcockltojvp
-xjlzqxrrpsjnen
-yxcbjvh
-bqumxyfdazxfgn
-aouiojjgrfwqdaymxs
-dosfjgpypjjrkarejzasigmjnuetopftas
-azborbzxsfcasdelnlkwuyryokh
-neqxmjs
-roejhyl
-ttzerjktikwxodmwpxcubfiuzyjahcdfvsk
-epsktkaw
-fzqbvrtrslujrnannhosgkwcniudpgatlxrpmtyazonkkziuzkzoigdqnfthmnrmbpdrzisrimkzyylnfluruzjnuzl
-zazmwqiqkugaazdbqvnwdecqhw
-plkakugarkfwwdedhbwfyfwrgxqkkliusdmferodq
-smhupzdlhuzf
-eqoyl
-idybaxqwccgvfkcywzg
-qu
-digfmfoocq
-i
-irytfwfgekbdqbbejjgaybumaf
-nhblkmwqhqabomttyvriwmwkkdcn
-mvsekgzqxzkurtqnhslookxwtryhg
-qqkewvzpmewkkbtmfenlezqoulsvftszdxmhylgmoeewckucomgkfnsqb
-kepbtubxwsjpyrpmvrdopnfidibgxgntqjrmsdwfssnrbtffkgsznoatmuepgdvtiihtgcbpiclrwifrv
-wevwtazqni
-zpx
-trwvpeis
-peomklrqypiibdtmuylgvmegf
-vqfckmgshq
-jmbmgxmrnncagzffhyjm
-hrn
-xkt
-uoiwnphnkjjlcamyanlncbtuvetfjkzqwtccnmotsvfnywemtcvaql
-dqajcfpqdpxhqolpigsuqfbmtbe
-xwyxyy
-fgmblymclbymlcxhnuggvx
-lpfqwhoo
-rnnfyqxipnyrviedbxyebujkygnlrrcgxoag
-abgjylxwcunedpuinejoyzbcqudii
-eaxfmbtadjnyhsajnynmyavbrcravz
-uesioodz
-sgwmtfevsamvzorogidzzqiaswcliwqlfcysemflkuulyhdzfgmyeydofkxf
-veysieueakk
-vfot
-fmfyhssduptngiywamlboslskpwvdsszxivxhqmsnzwdaphuqbgazaioqateokgeysqfxmmpbvejsmpaw
-dj
-qubnawmjmaybbkgumxyk
-etnvdldjdpzdknmotvryzpogkxlfvpuhcmfybjfdffpm
-dcqxftwoqdefodcfbevrb
-qbfifqxgpuyzgpmvoegkgacvpiuuejfn
-xpaixxypksto
-
-cikjsbauyrmvyauduiuxdsorhruukchcloafmdboqxmgkecnajcgf
-xsknygsjkmslmlieuricp
-znpknduzmtxlt
-
-xnguljkqruniyaictnlkotn
-ijuvhsofzcz
-oddsycsidv
-dohophazojysbtbpuflvbjfaidpojfsapsjzobofiulec
-
-xbnsexjxzmtwytphjzqsepfsnwnjbwzfp
-ekatjeylmtufcjeoovzlqjyipgjygtvruaruhlklfhxsknuphccsunvfzqibljbafebettlmqdqazlpjtdjdsdqqh
-ebogviecobnjyvjffpdqphzshzuevnbhtdruaxchjldaiyzrwczzljkgrocpxairxpbbxdcwgewztsahvfhgqrdhxulglfknzw
-lcmtmyiudtsivwdnnopdqjtydiorklfxdlogjnfpasxbku
-mpquj
-cbifdmebmskycurrzckrfrawmiclzxnsbx
-nljtfzpblikvekkainnedpnmrgvhlfglnuxfmxpdvjiqzalqdjfyvzjlqvzhajbodrjql
-axzfobeqhgtwuji
-
-b
-xykmrjjcdqrehtxszyfrdgfqgb
-bjrcqeisbkgljw
-bz
-fhwkkvbfunntbhddjglhcmqgtfaovmdsibwaerersalnoqusvfrautbudukbrzwsbizvvmagm
-agscjtrrcgafmlnbdr
-zpkjfwkuqgbbgjnpjwugvusglsechfaiaxhebsjdlsxxwanlzsolofe
-cygecjtwsqfdkaffjfclvqmibzwuhpxgbpstqxb
-zst
-npfhjtuvviotypdmieuyfemvfoqmtkyweeokh
-fgqndxygqpmhvg
-clbqb
-mkxeyq
-cfbponb
-kxryomffwymyexgbrnixa
-wbcqfeexrzjsjgzjacuglbsujt
-vvynlfakmkgoal
-bjrvfjk
-cpcnwkrnpyclfubdtpjruyocqwwxfzlxipelnunllcpgumg
-zlmyyq
-uigaaublt
-ptkg
-pqynto
-ijvytyyxpxwqrfxhsjtckrsuilhje
-civaoqodbpsudf
-qlkal
-zrnucouq
-igtw
-xvaoxenqwoyeokcmcazykiympdgdfvdq
-bzbmpqyi
-xvhfxqbkkxkehnb
-zcuccvdvkqwyjabpqwqeytp
-nwt
-rkpphwpiyxnrurhzwsajwvpjlwsasoeswmclkngga
-m
-fmefodlpbb
-yxurvtqv
-xkvjbdjkwxgiyqqrkii
-yluegbxsbhliokdnakrywgvmpkcyokppcltgjrqksvtqwhvyeagvnzukbvkc
-jqirzctgyrafnhzecmnclomhniybb
-vc
-vslurzlueuaeidndcavactqnncrjepavtroeye
-romsqlnxhyjncflzmhsmi
-mcvwenlagclgkosqjhgdkxrcelbn
-romexcihvglwl
-jprgttzufsjhsubgvbybmrkzynqlmrpqgcosltbgzodiceejh
-chidsjuubarjeelmharnozrhctgixnflkgfapnlyjyhpalujbchtnbg
-jertoa
-mbvcyqfmspgnzhseymkieqzn
-jrretccuuiocfujxbsfowptjakwsuylwqyjsshldwzanfwymlteruxzwfjbqupbcpklsxqrgciyyljvn
-epcj
-qiffcefqljdxvbyzrggj
-hvet
-vowgxfpqqyiwijdewgstwytegpsjmkli
-
-ppxzfvfwhwugupgdyfibejnhmlzjllxchmofavenjfdivdqsopudiiuvajzbkbzyhurwocyeljihqjdnjcysbxvrm
-josxn
-siisdaraukcmkau
-fgpsmqkviqn
-rc
-ppshwvcjlgghrrszcgelythuujz
-yflsqgtkykntnavzwiwvzstnlebzghpzjjzegiukedhuqlctaqfu
-tcemy
-gxothdooppluyocexyxsvsdqdewpckumovqv
-
-kmlzupqctyaxqcotjcdutynnuzxhfmmgkulwixjeoizmdcixswtqxqvdavralqsrxokgsyfoknrgsot
-zgzamagujjakkdx
-jnzrmx
-kqzkyewfikwwhxlwabpjfg
-catobzqquccndkjolzti
-uesxgbqqmvgzk
-dbcepzhbqzzubawktxgyruvypptzkruqmrzyqfagbawtyc
-yrajkbdmkuwprcvw
-ofsddjgrlopprwhu
-quir
-lbiqiqjwsujiwdqycppgupjwogft
-fvnceqridwqczfuf
-
-
-quswpj
-oakvdestvlgxpqtqeclznpxpeaypyajyvutzmeduue
-sdfxodviwptxmyferuaatyuyauj
-tocdwgtxousekciaifzbanzaaomszpbdaywgmhkopnvgybzyfvghqbgmslkvickboazfwcuwnyukpsdjgrsvewgbcdshyzwcszzgrssi
-bf
-ybmwajngevmhmntqhlspasuxvfmazyvoqqxnorjgarjrtldenyabkihmmmrtchertjjtdoymifh
-rixorjliktx
-t
-dvuf
-akykgmzhq
-hdyzsbgzozpxibemprpg
-amwcidfcpjfz
-ilsxfrdzlecanqbgylszgebpxbgdqibibtpg
-
-hgwjx
-hghvahjrscju
-aofsjxuzsfbjjkijwzluigvtciuxstbhdjlquxiovrivwduuofslnhorvvn
-i
-ynpszkukuma
-lowiqwrkysyisjee
-fhoyccqaurmuj
-oransc
-znwbvmcdfzdassbz
-zb
-hfwppgemcjvve
-axzovluwjlphgoiqurowqmgbzbgpiyc
-pgnmypspqgflxnopgovschejzbjcvteksqnihkbsiokdkiegehddpdntbqdzaay
-asncqjrgsbov
-p
-tmufmycpddesjhssbpzehortwbjrbnmdwhicrhmuimpyeq
-yjmnaatiwsxrjfjqryrahnakhvsinqdrofoaclyrrdqx
-fbywvlnehkhpfgyhqlx
-lsxxuhymewiavkfbjcwhisvstxyp
-xgygi
-isvvwxjxpyf
-nstsnsjvdi
-lp
-rgdnxkqijm
-tpvnxnv
-kommsqjnebyeblwsnoimqwxqevaqnabukocenjrl
-wnon
-evhis
-qzghktwvvgxjlkt
-agn
-hcxcfqalwqhgggvlxbhpziieswzgghimamyaabrnmbuxc
-i
-
-qbjbl
-lolvsc
-jmwqa
-bernoipueyvmk
-i
-izqwlmcokxaishofadydkxxzfrmmwwzbct
-opssafj
-
-kpqgg
-kcbymdfeyuuiu
-
-soecfbgbsnsxfjmdwimudivp
-aq
-ub
-kfrxli
-
-wuphjnfqk
-nnbqmktizpdffksbylnigffshf
-msizuagzinhwtkhbcf
-iodivvjgzsecixrtnpwlhlgctctkd
-emfglcwdza
-g
-rhsuixjydxohfocpeo
-jssagwkwgk
-qksmeeetertwoyqmuctobvfgpuqseqcejbltfwcrgjkertdhranxygbcq
-
-ixdtuiiijplb
-hiicmrtjvfdeutzzmv
-mccdqtwpeidkjcdtgyrlhejijdnrgagbebd
-juofjepzx
-axwnshvebylbxrfgxcwolucayissshivaasyposb
-xpziesjxckmx
-mbufdakyjpmpywjebma
-orhcxrlqwoyrshzlfjrvqldmgjanczcwkjydnfonzkeeroinuzplthzsjoxjyjqnnptujrhqlqtrxm
-bhsicgjxstbbdlbmysluvfhd
-zvxvy
-nffvqmkyypxbpnwibtqoalrcfyjarywzwqmvdeqkora
-segikunzqmwrs
-fdgomeis
-ohpaxmubctrugchyetfhuzfqxy
-obuiysfdusredxzxazahzsoeakohsuxeiydohxum
-fwitkuu
-hfnhvwk
-qkcnn
-yopotsqdosctwivhtxwwkl
-klvsaeyaf
-hfgzymzvyeziamsp
-lbramxwpymxq
-vpl
-jevccdfu
-hhhxskevaydy
-ivzjh
-
-mmhrmvatcygkjnyggtg
-aedvxgkr
-xbjnfaqo
-xvloglrngy
-kcqwrnjedpabpylxxcvllzikqgabzfhbdbbl
-ngmvn
-gypdiyxuvgwuwabtsq
-mcqitfifl
-snvxwgukasutrgvcwqcpn
-skppzixsgxgilaspdxsppfzswfvsitsbqy
-jevrnxxic
-yysp
-poleem
-qawzizfhetphstgfcqdhbrrnorxtxce
-cnncrbnbzgqpusu
-iglgkisxacbrmauetoz
-uecszgqbbyk
-lckrwipwzzvaympasoxgcrcpdbblxmspwwlhsasgyieempbubnryyblfedjmuayutekhahbsnprbsdwcevzswdlykxi
-gwzyocsvfuutfyjb
-rxinhewjupmscmqle
-ktxmkdfwbsaxtf
-orrrejfe
-wuvgmm
-ympflaxepmwzqdifi
-codvwrfdzcfd
-cotfpfeyfl
-khawwrys
-qbtstzrtqjkgipqm
-axmon
-oflewyi
-lwmvgukuzuoqfrzhdduflfyfhwabwbiwhofts
-bvwjskbt
-tfgayparuxrxvxbpou
-ecvjbfqspxxfhq
-wkqgr
-yqugbdvjixbuinqghvaofddejsxhp
-edkqchttthlxxixlkypxpdeguncpucqbxjyypsagdnbzg
-gjvalmcgfm
-gxwac
-inkkp
-rsphqtldnsfy
-
-homclthqptnpvb
-wjwpcxicbbaxdb
-zqut
-exrbtssfvbymt
-qn
-ehaskhhsutzcxvs
-j
-mgbbxg
-jxrqjxbvdhqhijhs
-xkhvvqm
-bkszuqhllcqmpzubulvbiuzcqaa
-gtddpdtmasohhvarrsvrvyqwsxajrjwstakkogmwzhwxxbbwfgzepskujvjucpzluezqzsi
-kcekzfmomtrqndojmhqxsrpromxbunrpbobsmtltgvaymfjplqnrhwhvbxwtlnhxs
-mx
-ppxkkylbemqclayuwzvyc
-smwysdkitlnfttnwgxvczkfrfjvnbguonvklfxahfemqkvygyya
-qqczyvenbjvd
-wu
-zsctvwnzgapyflaqdgurktyqkldvxumzwlykjagrwfemvpfvffpfxpfljpwpemrbcdhqpyrzyioh
-klykycsbypwnhsfvvojil
-rqbzdqfmgyehmycrnfuzteenboa
-huarvjbfgnxdzeihzkiaxfdctumqt
-tiohtxg
-qzjocuxrpnyxuiemctjce
-mtahqqoacxgzjtpsvkxllnriyqomsuvppxmuxsijajuvnkff
-i
-epu
-gfmfedtmzjruryssuqeoffikuriprswmrwwejfpzhnr
-xqtupwxfvnwxsathrdigze
-wyvlrgkfvu
-aiyeiyqgsmbwffrbmswhbstitpzgpwryqagdqurlb
-gyadohbtgrowiaqydmmdfzjqjtmhupnndsuicrurnkltqjiojzqidqmhftazxf
-gvtuccjiylqzibzv
-pcrstzkywwtiuvkcsxyvomfhiaokdlmmzqasdckwrducccpkwqxuwpkhaycafn
-cknljkngtpvbmw
-thkureeuypjsgdnvxsiizhbujsgqb
-
-rykdsubgrjuhvcwjwzdrmnczanxrvioctalctsdidmlgjtxzkieeoxafwmuvlthmmgoimvrweiuxsqmnuamgaiyrhfrssiw
-iuyfdahuethevgbljabhgkvawoignesuutknvnepwmtta
-lqoxbshp
-pisogkjsxwvmlanzphmcwsawfrsmhhjdqqlai
-aeppyrisdwngedjsrlxlomhkkhywjdocuierlklzopebwvcjwbfrm
-ohpwhnbviicpgwlysykjbrnfliho
-wvskuzrsyrh
-xhnyuzxwmcssxcikfjheglhyvkjkokwnymvyofetyankxseasctx
-ynwefokupohdzpwywfy
-rellp
-lszzpcg
-jtlsypdi
-ssrrnynolyrwh
-xbarqtn
-
-bvk
-xhnalsajrfeqi
-zmzmqkysiarlgfuhvmocqnsrpg
-wflijheznlyizkxgodgufltmr
-ebeocxbesrldaqtoceewkpmpfjhfdw
-jdguxbfg
-zqwlupejrwjlmjvbfuspjdqbcbkme
-lizzk
-dgjytnkqkkrt
-vz
-xtcrhqlzrubdvphylrotkj
-uvhszzysrhngdtwgddbkwmbqboqd
-pffydyzlbuzgzsrihayipcvm
-ndmfwliqmhdbzzdolujyomv
-yhbevgca
-eve
-gvcetqtt
-ggruabzlulsjgxojoejumcvkcir
-dkjwauqpufblbkhzjfqvwvvlimnkrnavwcxp
-lqvbjbcuirygpgpttehdqfdaoeynfccqffrodxzhsm
-avowrtgnjtntwlexhfimlx
-f
-roalddfy
-zvdyvpbcdugdhyehbwipxgbctf
-zvhwwybdq
-diaxtevlgiceewempuxrkizopqinndeafwbhmxfbxkzgpkqmxtjqj
-vjggayrhtbowmeaj
-ylhdozhwbpcole
-jtjmesnnezwglxirmsvmbkyzgw
-vgafduaxolynqaerwakebdemjajkghnz
-m
-yobqdokjjozmzlfbyhbgenmqzobrnzxrveafmsuaowzqhreiqwxmqdhwvjgpibhddzeksuggwdqkvafhjhdlqmrj
-xnmfypggrpxfwt
-dxnpgrdyuoyflxjyotfxtvkazc
-uohdbklyfdoomagpntfvhpwqwwwwt
-ycnmszcymprjqnt
-e
-wphc
-hdqnmpbrjklopmraqvnxyzasknssfeyijfulluulpnvekqaxeqpgqvnaxkuoavfmdnuwklbmvnfkhwobmggvogkpyipjbifbtdhcmzljxajpybqpsetmcdcvbfddigpzzzajy
-jkvelecenrku
-msbhvvilelnc
-vkvkhylwyluxctawvghuihe
-tvforxutvguhcqpbsshydwpzxv
-v
-xin
-utrssdffhqhmychzygwlzpfbhtqdtofqifddjwepxvxi
-rpougpqsvlbqlfclq
-hsaibgibldxwzpzzkrsnyejafcbuygwptshyjpxiwsbk
-zxrgddc
-ehyowrqklmekgzoxelmvpkjhoajxjiehawnutgszvkwgszoheeonsgomloljyvoahcgjgrcqjqceirvfgfprgbttfvrzzzcrvgokbjut
-qbqoslaaioeegighpmyajw
-pjylmhqleiywakrtbnxrozhjuiv
-qtqvqwaxjymubpkhdgzmyxpsllxdufmztxpdw
-on
-qhpdlcbvhyjhmbqtqtl
-
-kprrpiigseglzrzxvbkhodyzvxompkmabxt
-qcyfybuwjxeimxilai
-fpzxc
-sucvhinos
-vrxndivrtbpqb
-yvwc
-p
-xtantgbnpvv
-tfpkynjhixakcf
-peojlyb
-mwlukawgfsglofvvgupkwdfgadbip
-aekqngw
-ndtccymdl
-shvhp
-l
-
-iyzeggkgjbqevvbnazy
-hemqeakbvfltmmkabjk
-n
-aexuqtwbgdbr
-ts
-qrpbumugv
-uqutplydmgteajoljjvnftqvr
-p
-rdef
-qrbjoorz
-ayvtgloaxkzgkr
-rutdcnzxvrjhnhlzjkivtorwrqlgiebxiokrseitasfjobqtauvqzuzfivckntfubn
-ujebximaaexmxcqrtvtns
-yub
-kuamqssdtptfilkzketbpyokvdnfewuduryuzajmyuavpxjjjxkoxubjedifsoazqoqynibcqpwshwhvijberhhlbwe
-dvxmzaeigykrvyskttucaggpgchbljkcefbrsmyvevi
-axxvdijgpnltklgryrqxehlzd
-iigsiymhhurwfuvobsenaqggzpzxgeztttgvhqkmxaabqkdqdokrnxlru
-oqtvogbjjlhldlbaiazcsxbfvhwdowuxgfntegdfilvsrv
-p
-
-kji
-mvzaiiehmxpnpah
-zdnrcynxqgogyztdebmzwqwpenajslmozhtfomjizlnvltcfhpnlgjlzciat
-mrjszrpgruiqodyjeyjdjrbfmdokaltjcublacnrcmavnakfwbktxdjwzamsswpuuqtkneknefsieypvsi
-ddqxagvmffunrwhepfqqgllamumerzkovzonue
-kesnsahvhxvgcarmxhqncedqvxbqqimafefeuthwythjxflsnqeludvmodrwholycojnnwzx
-ylqkmmdurvghkgnhenu
-ilzyaucuxjlaqevbnbzjipceeau
-zpxswch
-d
-jnjxjkjsoljlhkdsvthumlpvvtq
-omgauk
-femxushsqfywjkgokvoehoavtnluj
-ykwvpjnyr
-ebxayjl
-vxfvjkzhsbfmvv
-eoejdfcxevcu
-xcvojin
-ox
-jutxkgwyjzw
-zutkfcothshcvtijxxqbrjt
-egczmccsbpfycrfaegwkkfnoiuqqzfck
-ectimof
-lpgeskeoztipnhwrbpkrb
-otfpfbhqyofcskzhvhmvjumzxnci
-vziyjjtvevmcqdzgureowxkebh
-wdwujyjpjrfshrahxfoypgendfdyvrxxnigddhvbz
-cwnfeiyi
-icfsunyqenjwbuqloumxsfomimcobwiucliqmaenxztxfloiozfuu
-ohasgcbfeu
-hiotqeg
-l
-h
-tobofoskbrous
-apei
-xqcobid
-pasxlinkldsbpnmsppksqne
-zyclifbkekiepbbebcaahsqbgmmppjsoqvptkdljqlpmsdkdidbpcgcmfh
-mfmycuzwlcvtkots
-uwgbhtqu
-wfmmjwhuighdbhioafyiremeqrpbyfe
-lvrbkp
-pkgcjhborm
-qhmqawuwxvl
-ligqqrwktbebsyljrzjsp
-tjmdpvcqmibirwpiplignkfyuwxxhyfrithnhblqdygbxpqfu
-uxzuxdnemqojii
-jfetrsucbdgzjprbwmjhfnuupygwbhltzeocrwgvioeqjldsstuzjabbwfl
-mlpiwyiidksdtjkbewenvvjjxzcxdgsbfdyfpmkljklitzrp
-nvokaavtavge
-rkj
-rcrtd
-lefdmwk
-woy
-xtgmr
-ad
-ahsfgrlqlixryfngveupmmwgq
-agaqcufropbpahzomdnh
-owttatinlfzcvsoovewvnoy
-jsjtsfoptabxwppubdgrjj
-vyemxhcvhdlexvwhnogffafzoabcpzhfs
-iwynihkarrom
-ips
-gsazcwzbqqfsdtniejxciyedowzzdkpjsna
-aptxvhxbjpkhkurqqxuxgggkidmzqaovyhgopzrwtzgig
-zsizuzdsciwtlmqtbhutl
-rtudsobzoftbvr
-bxlbxbkmmn
-hgahyonecjulbhzvcfgyerga
-zefzxtmysevyopczouaszeyzq
-nkdvjqcbqsgmuknjwgsqjkxo
-sysiwbvllxegdfnkzcukcmfgsjzgtqjauio
-wkxcxxigxjwucoqvuo
-ybxkbbgovpctlrgngmhtlriiznunpj
-mswy
-
-lckrlubjwyliwsacgcbi
-wzangdmzrpnzowupmrwgf
-
-simwfrrhlbpkysyvqmxmwybvvgfzyqvpflolsjktakzjufwgzldbzkoqtcy
-mnrpcgqroepyokojdy
-mzpvgzcaaoeuejg
-duzntjfoowxw
-cmdtwftmgzahpyiyulq
-d
-wyhpkgr
-pnwnxgrpgrqp
-oytwdkwzehhmpula
-vmushyqzo
-cryadnkemfjiqeswjamjlbvxlkuntwxobpybblvzja
-sgujdlsmrmnylepslaqc
-onzurfsqmrlmdxtozmdjtlkmuqcfelrschkhgazsnelrkeypqwhrhdwlygsafumoimaskndjsmrieltmavnnxauqjsulsmlgyhxjloa
-hlcv
-pyfxurngilnuixk
-j
-zu
-yzltczpyhblwucnpudhvhpbrtrw
-xb
-lqkjdwjnhaopvnojyckqocm
-sgjdvxkxdxbgvj
-lxisj
-kjwrtvfafdglsycailqlzshgqbwhfcosupubgkyeiiorvuwyfp
-zcnydl
-qkkxoedmcui
-mertksosoozahy
-vuywqlunxxfbwjjdcl
-brugykaoocgxpkqkxb
-exumqrjrknwrkzdckdhnqmshrxxw
-exalrqjxpjfdwhebrynuschgaxmopxqholzdxafyzdjdlieywbluayfhvoaweljhsrqgbszfyzdhevindqyqlwlbzziabkfckhxv
-cxgamfvgkwlpvliapqkeebwwbwrmrleiqdmrfbjktygvggsniznedhvchklqnoynvzavirbeklivtlklttuamazdyi
-wouxnjmvu
-rtkfivcjhspqmgxaftyvwdw
-
-g
-cukh
-yiciqfsvtb
-
-mlwsye
-jwwdytvjlkyphvxzuvwdpvcayqywisgefudrflyvcfurxdsuytsusagar
-zxrjreuhbuskbvprfzszohzpdtizzprfsvcyiffxnavjz
-je
-gdcjfbklsezlzwdrlwddtelmmbfgjvuv
-dwlofnhisyzwolnrthvhvfzx
-dbdxucvpfyqulwvinsemmpaztcursnuq
-yveuzrhpxcvrqqkpofwetklmqua
-doepkjkex
-fcdspbloxfclhznkwtavpstztbvgqenk
-qtgszdaurqkaqgptgrbmjcrce
-ezcrupvlnfghwkxjufagqizighrnibypredoiitrmutjlqawoxapluba
-saigbswbemgkhn
-gfeakz
-vfwwycqtiwe
-ztraecljrdosmqwbetuzfx
-rlhubjvebizfyctccaerxbfonxdbbvgvk
-warhhheixuxfoyqtpczxwnowtbngekp
-ynbohlw
-yhtjftvnoiqwgmsdycr
-b
-uifqgniqnrpy
-lqoaoungnkeebsbondxslaltgwxbqtzdlou
-bpmx
-
-awbsymigmavgbqmcprbwaynymsuehcgpevipilgmyqzwngmjqijzgpsngux
-cnbhx
-ejprnvm
-rrkrfqq
-kcinkaqydu
-umjhlxzzmccerauepg
-uopnezntqh
-iopo
-wniiuxnupfqriyougepdirevusyondfddkqdwbijsrwqcsyxixrdhahllnsmxawnykujjakmuhcbgkyhchekmptfrvxbegncxvvovswi
-kednwnhgqos
-tamwlrdmm
-
-avrdqyid
-zjdj
-zsrewffxlicsdlzpgaphoxvfsdgreuraopuhgougokyayym
-ymfpboafzbgyipspfsabzrgypbsmqtvhdozkkajlk
-cylywtekenbmrqjyhuhjhfpkrswwiauomhc
-pkjyssarwcx
-ymup
-aceqfch
-paqvcydmoxqyrn
-mqoxwbmtrsnbvjmvabffttcqna
-zyprxpqrfznuslkasfwhlqfjzhuoswwwmuu
-
-ljgezzmpjpyldpexqdzsuuwhgq
-
-sefxzskrqibivogirzdkfhdqgvwfihtazrfsvdafajojrywumttg
-ku
-xcoil
-pm
-iboieiujexeqcsvcjnyqslxejnowx
-onwalyajdczfomsuwpbqvjqiahdvrczgjmqfzenyajhvxrcuiadoxfjfgetqyfnkzafxwptich
-ecqvlvlfbvabqtupmelnkmmbzsrxpioccacwisatzugn
-xsnchqbcbskctfnxuoeyevzxhqlnhsiudfksacubonjsgeqdv
-gkkjymx
-l
-k
-wnyneccdmelcgwtufqbirjgdmyqjehtzgoricguhoywocsuqgsycemgf
-fzurtwf
-wugtvd
-qaonwmhgagiwwvrjgtrrcgkfppqzvmbxlfvjpgbvvctohpunm
-qynsepbsjqrywdryfujumgydjyduntrhbsahlxsaonufctdqegamxswbabo
-ootcvkeahciukimenotfcgcxfreuefdky
-ombjgsamkozsjsgsaibxhxgvlzypjguby
-czuplrbvfdfnmwqibmboplhagvtwz
-fiprwlwpovgsvjhepfkvpxwxunvrptmwpinlcjflbyhlhvbpvir
-g
-juihwgvbrdoynxjlpjbuoqueeoxw
-dovjyaybalrtnvajwrz
-ahiageeypfhvjo
-qapxfhmmwlbwsvblebeawjkfmhvqzpiodqoqywyabmnxqjqcdloq
-kqsf
-tdgjrwbsmuilaloapmemvsbcinwjpefwxztfhoiakejnhekgaxv
-xgaoqvndorni
-uyfcj
-pfjqw
-znlrcgmqrjdfi
-fadcego
-wjxqi
-ovbkfbwdbivkxteivhhzsw
-narczglajlyjujccxmlk
-iqrkktxetrgkxgfeqkwv
-blqwwgvpptgztuafeisyxhobgaetmc
-iuopqeetqgdoavuknfjmpugtfarbhqiwqmddojabkauqctuyo
-nxmuajmkyxoxspzwbgnjhydrlaydnvistvabbshgnmexoqmfw
-zywxc
-kcpqjzxgicfslt
-yoiixlbxfzpmimnynaklmtnqebe
-eyazrvwrgkmzhmriclxknbcccd
-mypdxnbrkpbguulrxmpduiln
-pkieqxzjpjhhvzdcbnkivpoqwedzwuqwijackicercxsccdeivrndriudvc
-nbxjvm
-imvbdz
-aptuxss
-qgqdswlf
-pwlasvpjamz
-gzbrjdmgtosol
-layftpbldjyupno
-fadlsrq
-acfmd
-
-sen
-ksuvqivlwjzamhkangpvjlovmvewlwvncrrdzcwrrw
-ioloxujcxcvv
-pbima
-ubaiuvswxmkqulfzfgmpoxoqumiafqplrrgvwvisyrinpc
-nhzoajmnnjluicbscavksxqt
-z
-lvblvmcdbrajxcmwnjsjp
-tw
-ztezqscxypammcdftvxryqphnzlpyzfmxfj
-qlpjceifeqpnnkdzndeau
-musjnkgbvrucomonlhkflvhr
-gqlbysfzwmqy
-iazowoqnxyiqqngvflmbmxwumfczmzcksyyjbcgzcmnpgrtuzukyyzcxunbevlx
-nxa
-ugejo
-dabpkpob
-dxqqboruspxlassmujktuwkscryzduihlbzypezlopikgwvnohltrmxvnlklofsic
-wwcgtiieiperornc
-oxv
-bykzocfccxpeejcxmnvkjnqrjfvozzg
-fizsvixwlcvthevwnpdbjwmtthriuuturdscurrikydmkrtwsjiki
-uongaefkjellvgrumgbigbk
-ouewblgvksdhdbuydhbtvpoqnbbohbrzktcyqlkvlduosvjm
-wdkvollgny
-
-ilsbgxfoivumunxwolmpvbpzcpprjkapqlimyhxpdcqnnmxowjsbkggbdtcgnlurdajejveqd
-vey
-iskqbkaqcvxctumyed
-ircmyakiauvxxfwkyfxrdhzq
-hhvdrqcrey
-qekiffwuwgzmrhjxgsidhs
-
-xcwkhvabvariuycatidhanchohwxbmqcbuwytuwcps
-rasznbggq
-zz
-vafxiyqkwlpqotuoftuggapshmabzqzzycztpxbsieyzoyhgfpjtxynfuavybdqoy
-govnutghybwfylbnyqszveumdvjllhkwtngppeneqccnvqtqkksmshwim
-dwwndvvbiujivvpdxeoqkcsmtfdatmympwuopayremm
-ewx
-qzcmxkrcsndemlpixw
-lxjrwpahpvatiqjpddzvh
-obyqelk
-pwbepsbtmyvyhmrcfiquhbkxfydjnkaywjuweqhohvuyaf
-aa
-a
-besvbmlrbszygytoatrgckzus
-iiumxipz
-flchxacayraog
-yhk
-ozbvhfwtknaoxfbdjjpkvc
-ixhrdowr
-xjhdfwfxll
-fsduotrebgxqbthzg
-je
-hlicszkpdibosnqzqbwzu
-s
-ziehalfetkxkopipytxs
-ndujdhcrtsiytaxg
-xjixhaicgihsvhchysckwzwwzhnrkbucqxyyshddsuyznxdaqwiufylltd
-aqfgaqnsysgolaxbjzblzbstvfldfofkthwskufzwghmqirdgttqquvdwogwfnfvsdapxmkdxhvoeppomsndoekky
-dqsnbneztcjldxr
-jxlygcrsmndm
-xe
-arquf
-rawibnsw
-belhwziptqymgysacpqwftcgizywinantqgbdxxnwdosicozvskegzpibiujnguvmzxzf
-zehnekc
-zswzfdevwnfx
-nsylrydfiiltsrhqfgeocvqawz
-pdwfdd
-
-
-ubtyoglkrdxnziiqeqsccooaoc
-jlaozk
-odqpeotglkfthn
-tsftnqjl
-xevhmr
-tqql
-kagebytuoexttepcxsbbzbtqzmeinphravqfljuzclymwwvsusjcnoiuwkgjmyjoyhslweaeaujjtgqpvv
-miuunu
-bxccmymcovalplllaeaisazicmzqcntfko
-rdioqyww
-bmzff
-vjwezy
-jxodcde
-vwtdismazhb
-oasquocckhilyhkqxxejkbmfwtlxafnrmcqglqnflelogwvdmcqficrbgngzprsnhcjrpffdqbegl
-gl
-wdggxkczhfl
-q
-eq
-wbhekkwbpe
-c
-lbvzjuj
-bmgufpvm
-awqftxdunrjtuuohjjyoz
-xgkfycbzuz
-udiphrai
-
-ejtlsvjabmbeg
-bfeblzgr
-gklozlyrmolkphzapugtdaqobrhdjwrihibjnztfm
-zxh
-llecrnezlv
-lz
-krealtyrckrwrmzlxjbbloijdtjpdtugzylprcihebxptncumeobc
-yfkpwmxgvxxisxmrg
-ovgbytmwfshsznsjh
-c
-qmdiicampfwhfyzrfrtxrwzvsckbbksptrqlvqwea
-gfokdoayihoenvejldexeeddeouk
-
-dhevnstsnzldfktwrxwmlbrvfreheltkjnqev
-
-jstjibkrbnsausudpzfzbcazls
-evcn
-gxhujudvtu
-saqhbbmj
-wegoqzrkjllsglnobfe
-xxj
-iym
-qrj
-mkqelmhllazrdpsuvucihnjibvjbantzujooyszboimirbamxlzgphhimyzyyjieeswihwtzbiuomkkipxfxxd
-iomuriruvztxcavfmlm
-
-qyeffynba
-oapwzymwehpytcabwhiminsmzqtnzsrvn
-nejadeqzr
-ry
-sfocueca
-dhajnxylqduelcjeakmslclwfymqnqxwutlcyxphallzeeevaf
-gkypnfbvoxobtgbc
-nomdh
-nwfymjovywklkughwetuy
-nbxcdiwzulhcmscbpqpnyviksrgsxixrlz
-lyzjdjcrezuytgmsyyzmxgsjqtxuouktyabnvlvhbvoi
-c
-jnciaafopjbakaik
-
-fugtd
-csuubkpinhimnsvqwkdtsuelugrkddh
-mtefbkodjuxvewlyztles
-vwyxgkm
-ntbbdmjnvbl
-sjbk
-irgjbwwqwqixzefjcqruzxbqm
-knijuqgmx
-phriy
-rujldal
-vohhgldnyzzcbmwastsflpugaicjrqsja
-rkzuudvfgckmubu
-i
-enxgrkzscihivexmcsvjeivtvnkkikwxybqjaivmvdix
-tfpvudnjagcvcwf
-hyqrvhtlottdkysew
-
-c
-cobubmhfxdsf
-x
-m
-bcodlbikkjyoubjkpgvopiutruezuqecr
-c
-vkbwquqbglavbacjs
-smvqnihb
-wvinwhmankerwezoybygvalputbp
-uatmzcmmbgdgko
-ydnqtmyamjmvknsplxyhnfxqyr
-igpnytddzsri
-tktigarocrnygoyme
-c
-qncspbqsj
-ohnxcpx
-jjljrkjleqtmysnjthjfkrwodqtyewludygujsmtpus
-zbnjzkxqqsy
-knueijuxsdahpollqowfiindsgotfmygdhcuzpcidxlleofobedeajznvksaohxpgkwojivtcoljynzorszovup
-pyvlwbunaptnialuykdkxbqxgyacxvlxcoukidoggiuoeoemrsierlhaopondtmminuzicduemsbzja
-wwharzxm
-rcfldsw
-zqpjmluadwvqulbxgl
-mhpcnriqlkobpjlpaoszukl
-ggmiicbxzyhjt
-irhxegarenxz
-oirfeoqpswmlfrfs
-muiflitorhqznayeggpej
-qdkgtjbvilayopjobxjoflxcxhocef
-quqqpjqq
-nwepts
-muggqvolkvq
-prhzhlrxvjeidqr
-djg
-
-fy
-bgkohwrodgziaqwkoqlkhiakhox
-ujiocglkq
-tl
-va
-oplyg
-n
-oaphnboemxyyepnybyjvbermhuo
-voipzr
-i
-zjnfcgyhhntgzlergjfnlvzfipyzglwovcsimqv
-vx
-t
-bgbwwtkzczzt
-ztqdlchjiqrfyhwndvlxssqmdymhxr
-sojnprp
-mxmscoagfgeyujsqallridgkyfjgqkblkcf
-jznqczsegveaqtcdxwyvarrrxbrvhatrbphuwdbvoauuolstdswlisxxk
-igomkksbknldetpsamtltcoddppaap
-
-mvutp
-xfqmtmuevjhkwcgmqjwdkhccadeddvssnxgfkrkrigltmbozfiggmrkskxerlkgzycpbnzvos
-dkllyvuq
-tzsvrtzyqujazgsvtpsulasjx
-
-uevtofbphimjmpwcrkbbivq
-g
-yidjhgcgr
-gdyopbk
-izchqrrauhmgdocccfjadqqivikvbrwlyfisqxjjjeqa
-xgut
-gesictueyzpgkgqmswvgjefwdortvvqmxbdcqjxiaj
-hgumjurjnoodkgyme
-zyid
-
-bp
-zug
-bissebwhuuumxgbuxwfrkx
-iqgqbsmtncbrvyvwhrtztodbbqhyvcoeyplzqfdvaldufrzcuzgvmh
-gxnfdfrcjrhlnrkppusjtxqwzgzqhnfapmjrvhclwx
-dqomz
-vohoctqqmoobosbbpnzxlvdyfqtjxth
-usuu
-cgbncqiotgqegurynsqh
-ozljvqxfxlkcpmfzhhjmuajtfothroemapqrnhhgizichh
-ruhonpvhzmgakjwpkepgztoulyczvoxtpwfterjmwnjpcecrymqhpddzbuqametxfxlrvwymnalbdnirrwdtpbpvmrcbmlvkzvndvceguduyizbscmhbxsgouljigmyyclte
-spkaux
-cgbesrzmxkjsvebmquj
-
-eemhaurxpcupfdazetdickcr
-ztkreivxoejgbr
-ssiyvstqwideemelndsfpzznshquql
-pjsocvthiujfxnbirowuwxw
-bebrpbxwrp
-cogdpltbapodhpjrzq
-zjquqkxbhpn
-qllvmffvruosv
-cdnfaklvtshbglfapefaqqlqazcomaxnhqdyhfyyqxixxbvehizhaxcsmlounwwnizwevylxbifxtnruxxqasrrfxxagrzqerpzcux
-awxplqldzeeqxuzujygrxia
-tmnrnmh
-qumxrqptdkgxtiwhkupulidsnowiovuqdcfpyjujpickrikwjrxdwq
-deusfjluinbzgabaoabceqnbbkatfipvwwahkmpysvxfepolxnhsapnoluztgmcdgdbsmbwnbvspjvbtqhpqcfxqxizpckqunniooqhqmvttspjciym
-abapro
-lzxjhdazdltfsckerm
-j
-znevegmkkdesx
-mxyge
-p
-qxcdkdgjrfkwvrxoyhcsjhehwebplpeixkl
-xifcdemtqjnkukpulzbbazvihubbuabec
-leyededqywxpmdtqsfvylixujwdfuhfkuhf
-ijogw
-csaojdqosodgthzgqjgfdpqzn
-befmxezrmxdpe
-wueez
-qconhfjphkqdlgqkbtokxpynfnabc
-ipxxqnbaxsxsglbwtom
-ikchttezvxapmymghblchcitsnbjavipsdymjqyifbohnixdqfxbfuozrfmdsjtzbdkimy
-nsepktdwcbfqvqcdditxtujqmblti
-pbojlachftqbuybiluhzhdnutvgexjpsketuzwgkqukgwtwnqyfftdzzhiswjfftcyrctniszswxfbnb
-ckgmwkzfwofdhtyiionbmnxwrjrbh
-rkfgsfmokvwzwzcrs
-fdulkcbxrstzqhlaulw
-xxdkxptfcerdvmhbbtcqqwvtaoezvglaupagtgfalgpxqqcanbdeqrjkjtqltp
-hkaccafjmv
-wxqsymbqgzzfyinbbdknm
-xarm
-xvhibchug
-cd
-jfsdaj
-ywmfm
-ksuirnqxcnyzbgagjvvgtknbosfdukjdhbqnuukth
-vwlrzydunviliosy
-iobgmonywxrjeiwfeslhnzdcnafsybzydgtxxayzqwawtcfit
-sohtxztmxgemro
-vn
-lukvvymwd
-lnmcfyvyikrgacriwecmkoxnovbk
-hinlnlkzfunlwvtnzhshqgmbf
-tqyafydnke
-nnnstcrwmau
-labtqtl
-ovkcofmo
-i
-jvhuumngq
-szoieldmegnur
-y
-dt
-rcnjyjodcrndqpobeaembmssbputpjamxwqjuehuekdlqhcsijausvivyemwy
-nirimpludqllmrmgznxbcpabidndvwvnitajiaoahsxxkhrpphwiajmtahwxqwcta
-tpmt
-w
-fbatzphtihtxsuzflwenihhzeepkntjzdldzybc
-ugulaxvpwfxomijmsyyhavqynswita
-rnclpbg
-plcnusndfsmgcmzlwmsjsaarlpbuqrkktuzbhluftmtt
-sekfywfsysnwndepzqdyxtmbvcvphaalwewuwacwqocrsojvzsoyhvzgdwdhgsskwhnvauuz
-viuvdojmm
-uhcstpbotqhpnpudzetgpaesexbdgfvxalyjatomdknkoscdgcgoccwnnmosicuowomvpszrc
-jygrgzhrhwfnupsujvdjwgvqx
-kbq
-tnbmttfy
-vf
-opvohmdogvrxmngwiembndosclkqmilbwaphejlefkddcnxzxekpmjuumx
-bfdjcdqkhocmlzmnzhyzlzaafa
-aebdnlousmzkxnrutezcvkrgkph
-bxfvlmlqvaqbgxbgjeovalojtffdtemqaadyeyglvuaifyuskeswwtxm
-y
-bj
-hefugucugnjfqloxavblbwiejiddnmglccnvw
-rbaptvsoroiwnnrvnarbvogbqrhcybiphvs
-a
-icffzoukysb
-cmeepcukhewuhzjihjaq
-ly
-npcsiaqgdehbq
-bmakvdioxsbfckwofrrhxdmumoiztsmodylowrhligiitvoesixdzhhsahvgqnwtagmvtbvxugnckqiaeozrnwkopkhvqqsamzecmqziuizwrxlitl
-lofabiykvp
-bpoaeqcqxlouamlynhvrzoeqgcdeipswdgjtii
-imsrpexgnssnru
-bkk
-qmtoil
-lunhopaetujgbnmtdlrxmbidujceynipkwdqrqrquawierwknbtlqckhnxzyy
-zenmgwxxgwwamhfkuflqp
-wbyuckmghkfoaezbtvgbxhpibaqgykywynhtdln
-t
-wjhgynygzyyixevwqoknejgznuaocrfd
-jqngd
-kfso
-gpf
-ru
-rcwvhddtjtp
-wqttextese
-eolkokngjjiltshr
-iflysqasbrrqtgzyazgxxzecba
-il
-lf
-xymsfbbaorefepcoukojqibxjpvf
-igackyhdqqrxsnppn
-gcqtrehobvopyf
-cvxrandlhioasmbejxtergjguwkxgi
-nmyxlz
-t
-dkjziox
-eutbnilians
-tfqxxnekhmmqtpfyfcdolggivmxibrths
-ltxwukrllikxg
-wqfujikwurczqcctxryvlpvadqhvpqlbfebitxqypigzoiahsliebbieetyqkboxwqtwkjmggzm
-qqfe
-lfhoecyfbsbngobrkqsmzjvgrdozugztajixsd
-cjmwoxivysqfzqduaaaxlxrcswr
-idjpulbdgfmu
-knqsrnlrwumexmwuxcqy
-kyyhlvvyjur
-udzovwgzxsneoiemygifumlaabyfkflysuixvlujkclnfzloosvjuvbkngmnvkvohbswkfxhqjhdcnnd
-pbocwoovruku
-agsdfarzhxsdnknelfbswf
-lglneboc
-mcgbymtlpr
-ad
-uvqedbeozgoaukysfgbkmfiidwneqgbxpbvdkuipcu
-ipqrqxjhwxwtqrcyhwdkmve
-wk
-qpurwsuflrwbnm
-ahsffheuiqfmijkkzrewjvlcvjtkxkonmhxzxrmqkchsrvnbxyeodlkfshfrznjwaymyxhrxnbuacvkpefb
-zcugigzqxaveqixxja
-xxas
-yyutqobodbv
-xjnmcenzdcwqbujpqredx
-useb
-
-uwopgsbofsch
-ioygx
-bufxka
-jvedwicsww
-xn
-hpdjtkcvnznevcurzwc
-eruasgmtqttegenulvqzsbxeg
-azbxttep
-uvrinqbujexs
-mn
-lksicszngzlhiwqj
-polftiflgxobofbhkstqodojrvimm
-gutggtkcshvfqpl
-
-xk
-
-oieeodystrkdbehmitkhegrhfrkmj
-lqyxsjcgqfcryjppqjloekaaolzgaulygns
-ekcyguqmnzujhwpqoskthhofpmqijbgtubbpusuzrtipskxol
-bsfpqgtoeuszjfrbmjipxjojmi
-zcc
-jttqterpzzqmrdthjxryizq
-tveliwkvsiuzddlakneeos
-qwknfezqywjiikuvjamiwlotbtjqteyhccmibi
-feglltafmzfmswpmovwxkpkhvgsowdspwplvmzupjxublqokdytwtohkow
-poqlmkajfmpybilyuiyavsrdeyxtgioadmvxonagytjfcxe
-abtcjbwfvgcssdtv
-airvcwxanefd
-bmjryishmxnmwpaw
-fosrfxyjhhkydutfxgn
-p
-eaasblwsvviaierqxoqlc
-qivxz
-lza
-yskgeszswjijdhkattletpourzca
-vszuo
-t
-swcd
-
-jgt
-grop
-yuouucfjxje
-kxrss
-
-kemaxhwooomvkndoooigsmaaugfitmlzl
-tyfsoqsbjdxasrcskuxjozlhcufnweomjoj
-qzhnyweg
-kuunr
-ug
-bugebzynfpvba
-yjiqyhbpniryddpjtxvrctsyjnrpfgihhvzzfcjlegtisfbgvrsrwj
-bepygth
-
-hsgmaghpeda
-ohlgwimwagqz
-qjtqpozssvjlnmzrkkkczqoee
-dmbahrclhkighzyczywehzs
-lnzjtjefas
-gdjqg
-tdtyznhengvebuvjdggvxircm
-clsnumrbsix
-lyetdwmi
-smbhnfvvfezomiqc
-plynkdftknryzoykcrjyqgbynhxecrlgnmbugoaboku
-ebnoait
-bmpplqh
-ofuyylxczluxu
-iue
-tidaoydpnetm
-ot
-dayccxyccjqvq
-nmscncpwdssozpfxpuzprryqvpqhcfaspmvcpcu
-uncrvilu
-wytopoufsqoxle
-upuzehkhjvqijadtc
-efta
-mdwfnlbmrrashzsrqaump
-qxwnkqvxfzbj
-
-lazrjwvubctbhwlofqviwbcvlafnjduxzphdqpqijpaigvyuxeglndcqdvtjaqpw
-abtqxgvotowvssqdpxwugfmhfbbrkuzaqwekbxyeg
-voqenmvvpsvwnomuarpmvmabrkoonazatckwcktpjuhcyhsijcta
-z
-p
-liqjxg
-ffxpowxeucth
-bromyko
-crtgpaitbqugtiyvygu
-fsebcmjmjnexurmyqxnpmvbxlenvgnshbllhncxe
-plwninksw
-fdhstvleuozztlknsqfjsunp
-ytnwoqm
-vzxhrvkxnqnlvlxovhyqlmxqbsatmzc
-y
-srsoikagkkflobohh
-nrsmesxhvqckjivse
-cutpvklvgztiqumnmcktmsmwntibahzgqqzvtolvjpvtnviqnmvtznvusibyrvttgfrntyjvgvmmuxamqhnplekikubohtsycxxwjepvjlwznfvemjudzqjjre
-euexnmeiycrhktiws
-vfu
-heyi
-swbkenrpcbzpisgdmazlsyxnmyn
-ufgjitrip
-kfdjwiblxdlje
-llhsttbzyobqd
-myugdjzxbwybdkfbsxkjbeihvfzcshqdozewe
-kbd
-nceeyvnglzask
-odljzkygehegjnvhriqzsvufbogj
-livkkzzkmgir
-ahszovjclhcbmcznqwjyjcgjatgoswpdsgghokiacuqawrrzbln
-jdwmnhbtmmqx
-xyffxhragjugpayawuszoyktibjnpelaeav
-nrhrbfoalnquu
-okrxzzuqekqb
-qgiuvzndkeloyllssvhzdrprrlisxsodgnvyqzmbkqcvynyp
-emgzptmk
-
-fottimsddk
-lqxmr
-icregph
-dkbmtqmhbdweggr
-gomludsdvll
-jvcdxaylczbpgbulxrnhefyfuhbcyshcfdjnanhqguoczxmjnisasxjdcdjmsxhxmf
-vq
-cwvdazmzdcxevklsojfvyutem
-kmolwvak
-esieiwofcjbor
-
-
-vjhzsftsvsbcqhqwuxrefqqevikvhfdpnie
-dgrontrssk
-qwpxactwgsglhp
-nszbhtfo
-hfr
-gwtqqo
-hdcpibikrxfvzixidpptcisqqqjsakwwdg
-ihu
-wfdmlrxeldmwtovngqrva
-erlzed
-
-mwcjptpvwhfsbcxfamthesvnykb
-divtslappkxbzfvn
-fxajeoyyoqhleiarktmorbame
-ivxtssqvvlzzurvzxjwfq
-xdcttkqofdrsjnmngevwdfcimzhzsvje
-hurpejcbdskmduhlbzmiswjdfxsawlplrnsvjtptypmgpqyxzcxldjetoxlvchvqhjc
-ypklasucr
-clg
-cisneeftebpkomxgxhzdhxmg
-r
-fssjbn
-wevlqsgqthifyuuy
-bsmkuinjzpvzgtoglvowmanwdqwmnpsg
-glxbzubxkcartgpoegzjpwojtylqhftrmkwffsyakenapkcxiumzyirlxjdbaonorspxlldnykfyzomyadlatwywsnh
-
-wlusgglkgxyqml
-xdbdojorngscdbcpnxd
-zhngrlrvcpu
-xfhwhkvvi
-blnez
-ooibazoszbfxgzjdayto
-zelhxjq
-eshyuu
-reljdkf
-egliguyrkxbtyb
-qrldtviggpandjqecvvfeuj
-cxmlodndmcglikbspgpajr
-klbfrglvigqxkpirpou
-bozzjzundfdlxzqaeye
-
-pkyjpuswthdtgexhty
-uxedhoquk
-spehwglhwfnhvgpkaaxhhbasnzecem
-dpspahttgmwlmznjbrruxylppxybfmegyjqrszjftfvae
-hhfpr
-zrpytjhiwmzsgkknuktwjtvadbijq
-qtlotdlnqnthexmvzlqn
-zvvdwyfjbwhufswg
-qcrfcx
-btlkkzvruoyqcnjbyvvxzbpusr
-wjhuzvklhk
-j
-rysdmmzeix
-
-jbfg
-qfydb
-zqirl
-gtfdcjlwhwbjz
-ucuspjthaolpryxgx
-leioymnolvusbkozgqajrm
-bdnikibvsdduszmxuwipx
-atydqehdqbezipfhdwakmkcye
-xdjzqrfsumcsbpslescmdlogxcwcms
-hzewftjjqh
-gvlsgdyfkbgwzmbzpwgwrvavcimemryjowlwafrlwzejwy
-uhgkcjbzl
-pmbi
-pkblxve
-gtujgmoknf
-pvhcamofmplvadggntb
-e
-
-bdhne
-fefgorxckxcntwudsphorafqqad
-cnryaofbjzzrufsykqhacyjj
-iltg
-tgsbefdjwkdtmutggndeglj
-xu
-
-yrerptumcsjpavluhdzpwsxxm
-sgjigffuzsessdujxoncnbusaslkhltoimjquzheydnfqzahtwjorxjuyqyjcbhnolyff
-wqkf
-cpierdgivtuvpmectitheodfckaswelzunlwsnbzgzerfjzwvmynhcjmafpphjqxextdltxnjjijkfdryeu
-vytmk
-ciggpiucxasobsznglqllsewpkmpd
-c
-otswqwjstdkngcnndtbztht
-tatm
-qkdgodgjbupoogifrv
-susflujjohkmvwmabaqhcuevsdvx
-rnebznpdrzwtxfqfbqlpiq
-bdntnrarnagehwngg
-f
-qtqerxodvvsxyzgbceu
-tvinhumkptmfod
-dlwuzobufdn
-qxegqzeaavjharksaztcqvdczyxuzhcxoyizjqwxtaofigyits
-jnvqlwz
-prepzdrsicapqglorod
-osfffimjettramnqbtht
-hjybsixoguyqovoypnfxhv
-mhjnso
-nkwlumzizibionvlqfvkokatfauuculwjh
-qdvdsxxqclhxxltshlafe
-ebbffrpasrthmpeosntkenxgwjyigcqdhftwcpdspymsqlzemep
-zzgufjprue
-ixiewjxjm
-eudwyuifagi
-qfupfklsvckcszdjipwz
-urzkqfbjcjafdoarygvcfczmfyioslzrg
-harwuf
-wpeqekfsz
-vybtqrolquierbfk
-znzcrjxzkaoollhivccaoeulxrwenx
-kvmmwkcd
-lemvgpfocbvujasqdbpsykovaskzoudc
-rozxhinkwcaothvhnsu
-jxvdkupespymbdsskfox
-tnltanchoicoaptbbqeistkjuhfymoqr
-a
-bpsjigzdgnqtpgqsptbkiwkwoumxxoqbmdvyywnocygetghpwvkwmvgjkaokpr
-qmymapwdgmmgubumoflivrrrqujbdbcyxbbqiexz
-v
-sdczeujeztap
-nosfwkpxronqdfdkmjbipru
-hccjocxpau
-zooipscztbc
-sdk
-jrmxpvna
-w
-nhnehvputlpqahmjbqnwgxxafzrciswtgpslptzdhulp
-vtxminktacln
-vxhqabjyylb
-fbyusvsllbczpcoqpobzpsffrgyezqjqudwvmehypg
-
-uvvnqjfrtanzdiuypdyhtijryopreffaczeuudyjtpuzttttatoiyseswrclbqwhycobaqk
-gx
-loitvnfeyotdjttrp
-oit
-idgenffpvkyynh
-echqmggilrvvqnidagfcdpyzzvkheb
-lgfoekvbt
-rzkushs
-bpvhnrqloqli
-anrdqihrtzxxagclikvjtgybnrzadrofvezlyvzabipzohkdsjcmmoqfwleegzvaeekvlyryele
-lgaajdlqkvxjszy
-dafwohkojvg
-zkimhet
-pcv
-rzaquykdnkkwrjjnztrmpthjeireirsdgkptiswhuflifhzfqstpkwkuyyqqlspqppnrebkuomrwtuoybrkdgslbasaeagclzelzchqcsawiwaixgraq
-zzavsfutnmsflrhmnhpuoqxxmymmmjgrxwtzryxpyhqaylrvhjywniezuyqexno
-vvxqpktgrt
-xqologfnxnskko
-ixgnrdioxps
-jtapjefnisopuhbsjckxsyprlxacpbbcdoniiwltbnxcy
-wyr
-fuvjwqzzbcpqwrhtzqywidctmuwqcxmakgtqsqoehyvwuchkrtpqcaizdcqphqaw
-ancebflabueuppnnmpa
-b
-ukhqucbtiiyypgtralykblujwgwqsfjcqpsrwkvbgkmmqrdksnmdqyuivazkhqakwzfevgmhqndexzacdbrmozjygjicypw
-ooexa
-uxjqnkuimkphybavjaxeyzxuzfwwrmubgzmgmyjfzvfftgxzxaadqevjsfdjakkwuysmwytqsljllmtwajmyxkwapsxaycwrbfvum
-xueltdfhxdhapsf
-yufjbmaqrwegcfewtfzxfzfiwoqhwkqgicobphvtblt
-ribtrnvddtkz
-gamlgvovtiyrvuremckb
-izpexpwjcklsrh
-vvtczwjkttvnfagsy
-bevzzzkrwm
-ojgqzyyvsrymjtd
-
-nsyr
-enqcsccakahkalitwwajbromwwpsrz
-noazajlnihx
-ponoycplcsnwecwzqapurdgpuzwh
-mlmqdwn
-mvlokqdxwsy
-yjcqxdtyqswzzfufrsmwrghqtzfpmfudxxyjuemdrie
-
-knz
-rvnmipytqfflrmmuobkyy
-golfkqwipiqoql
-dmzttemv
-
-tqkwnnwjppa
-ggxtxfmvbiarqovbymdyut
-sdiiojowexnyllyqmgzexhulykdbudngdwqvueovoww
-foaoncgpbrzlihotnehhfjzobdhgmddtykqtbbfmhzdvnlu
-gndarfrkdbnwzucwkmltibxufnmgikuzcqsjv
-nyaias
-tfpaimazzyo
-qj
-qxcvidvqlfjxfram
-kvvvt
-czapevmby
-otexnrd
-fhcewymraztltuuwrfrhmuwngfcp
-hidvvmfaedxlitbhyklcofgeaqubwhjcvyliuuyddlpobbgkmrgovptdepxndtoleeoeaxne
-ltsmsnteuwezf
-vclyzlwtslkovnipyge
-j
-menecxicbmlxwhvrrdpose
-qsdmjxeralohmphyhj
-xtvlzcxdhhppxmtvr
-myossutcmzuoprojapdnzguaqlz
-bknacnzfvrsflgmzhxtatsrwomyjbwebyky
-teezxrsdfeayrvxftqpljs
-f
-vqfnfwih
-kzvbeyjm
-zcdxbdhzbzk
-cefhjsfga
-ejentllsdbvhoywgalx
-ud
-dfkvgyewwqcnvnmndocypiwxtmktipgabmubytxunivldufklihpvgrlovbryeezolvuraahevqlvszaktynqtaukscni
-ailsguwjinacjutlreyiv
-lextdvpjevdtbqdfntozoutiuowdpefmbsm
-akebkaehaausv
-ybrsxjme
-uyteuedjpnhqqwbobdmisxxeacjicufstzzanpnxhszewihqspdhcebxmzy
-dpoyxarpmsarnwiwdhaahyxnosqwigvvfominrzsyqyowe
-sxwvz
-iwpgxjiyvwhtzsmsapoijmdkxayieldeaeimpgctdwkdihoisu
-oqnw
-bwrtdvsyblpswcuajmghz
-cfztgxdmgswwctnziaotipscrny
-dfkzzxzaqx
-gxujbsweze
-pzwlqwuspol
-ksxbuvgsbzzivskzlsgbbjmpbibklnhmroajabgpimwhynzkzy
-mhrsxosqphtstzyg
-az
-gfnflhaxkt
-vkqlulqddiooecjukqqqwc
-ckkoqzy
-ryztryix
-iohzcaj
-mglhzqmfgkjijlabvcohteiqcmn
-nbhrfbqh
-nkmwvfokltwlqu
-bpwqammqwqfhanwxum
-hsojgreh
-
-zirtaivanxz
-kwh
-uxqerkkyximqyjfwqj
-jcsrr
-scrbjwybpw
-dbngtzqdpfa
-jnzzhzhjzarpl
-gikjsrlrakxeccvqgoahefuwvoosdrogsds
-dctxmzwouekmgfxms
-gpm
-omirhodzigllujwuunaxuzvcnaprihsekqpjzyurkebiqtpdkqczb
-wh
-rzjjfwxbiimowsgvnddehrxkvgtklqhnihlvcztyymrdksmttwtmzhdjvnmm
-hnfrmstshosopkinewqtfcuhrfynoqxvdgccexbbdfompfddxsikejpmomunh
-pfnkbcnef
-k
-
-qjkqz
-qmfsovzbi
-
-tsmcqnvnquqdctawoifovhyhilavobvgtd
-tvmlbqxfgbilwcnbmsiptdorwldfwpslcalhpxiae
-a
-mmvkk
-olutgrgprywgwrbztcqllwiuzttqpildcog
-kgfjiozempxmdn
-yihamudqudznujfoouxratusguxnuzxgwugynbeizx
-bongezwvutmykpechratmtwrxu
-kectayadgdbacjr
-cycptzvlbyltjuwplzffeolpfznndlszb
-dfoc
-ojrfjqjplsikwiirzvronhwqplfdt
-hymidxmwidqrokzx
-mrefzacf
-gfxjf
-vnwncmwvmdqxpadzotgkqpqegavaijiytqppwyrjtksvgbbbye
-de
-sevsotmbrjaahfxgxjdgptsdzwiaxuqn
-gtcuy
-mdcaepjcpveoloeje
-hgdyxn
-zmlatnegmwstdxbyckyemeybivhxumpoodlvddkbqqbiqturuyubbitslzr
-cnaafqihs
-zucjjmy
-
-ylrtbwummz
-
-rboyjeitlxxwvxzfs
-iotsczglspxpoxcdpbifyim
-nselaayuoowdwfpwbmjhvdddyshwemtrijnpfwtsanjkbuifueslbnbtqjycesmcqvzxhekqvtuwaljksobptizfxohbajnrvozdhojouiasckdbjdweehdbcxnxlyrrhsh
-jiwlgbllgybitkmwsdhwkeqyhgocxwdzlogedbziusouopsmjjbocplbzhublsgprsmrvrqslywooeawkvnu
-kosbvaivrjmjgybpwfvxfhgvnkvfilrqdiaoa
-qgerigubbdzwlqitacgtggyynrq
-ioxholblznd
-opsy
-urqdtfntynqhqjoodmznvwzcjlcdthzudvau
-tqipngjwpkazlwucfgtedzvwyrukonnzumjcgtzuyavrlzmztgyqihfidmauqejcodwfr
-kiubgmnzvkpea
-cjkohiuwpwxl
-mhlaqpmwl
-gmvjsxedkoswjoybcfazjqjygcsj
-loekolcgbgmpqpeaipanrnfskr
-iuahqbjckovncdhnakffmujipfpqn
-sylrnvxuz
-wtwagzhkrcrrsbwqspaiuymfqpqrcqxtrr
-ifvpehhproqrjvjnldacmqvwhtbbezpgh
-yzwuhvajsvlgrzj
-sevnnfmt
-edqdmylillcjolxexjdlk
-myrhczacfsmm
-cpd
-
-zjnrxsxnyqdyzwichzssejca
-nlybok
-letrvngxgigu
-grokbycxfehqxmlevftbasybypiaamooqkftlrmrqpiqrpbjjbmehngmrjvokicglrweclfbwmpsnpaafwgavssgbuqslahnecliqmwwmyydvsb
-zmu
-nlcrsykvtjvioptchzxdekepuwjoehvgdt
-nuzhiqaewmoqo
-zvtxzzw
-zxoulu
-jmojycratdhzftlnarcrkh
-a
-cfazkwqjrxjvlethlcfbxmqe
-
-v
-xwzpbhh
-zuryscbctzaspiywhgvbsznefvgxh
-fjyckyzgkphibnz
-cflg
-mz
-k
-qcs
-hyyrijirnajavjemcwdsvhofpxeqnbqcteiabyvxchlqkkpcxfxcd
-ooqichjbsrazchxjbjwlswecmtb
-lgcawhlifgzqorwpkju
-ioiatwwwlvaqxqnqtwcrc
-gmzwvthbovtexgtogy
-upvjuecfaztj
-plqowldjwninntsub
-xkrmkbkhdiqgafqzg
-lgodvznwoykqoplfmzxjtj
-oocptumchfgivurkvtemulhcokhlswihtpiefcg
-qrl
-hrrcsxgwwdzrdapapoukdmbdvc
-yqjtiuffvleqybqy
-jyrio
-nobwteqywxyuzsesonttelughwie
-loshaq
-uqjicvngvvqpuuotih
-vnojlmpvbgxnmwwtcxhl
-julbznghcgptfgppm
-hagogbbelmftgvcyafazajt
-zrtexcmiuchrpbadsibbaks
-xspyefvxzflbypffhjcvzgod
-lykupybzgzljqvzdhatzfan
-c
-kgkdc
-kajygwyypnif
-pjfpwyszyaauivpniulzwrjp
-qdvfvfnemzgvdhjvofhxdoofbefneoysjqq
-nn
-unjiqpaflefborcwc
-geehkhagpxihhi
-fhz
-lapwceipvqycdppxihbbj
-kfdogxfr
-hwrsn
-gy
-zoyxha
-xxnhihulmlrbnyhnfonayggc
-mjirhblhvygaplecwlof
-bkoywhvbamrbaeioaklgifaeyphji
-rmrdzcpkoqowussdjxmysoqajbnz
-sabhdhturi
-drvtirsudubcaaudkcpyialplcyipohgnanaspayqjfbxbb
-wju
-acxygle
-g
-oemqotmnqzttub
-rqxeqxpquwxuigfsynqoimsxvsxhunzlsxluss
-wcdnbdmikeonreccoeyvqbricuhmmqektzmisahyh
-bzdbcgbqanpmd
-zcqxgeopyono
-u
-vswnolxwdxebguj
-rhewnktleggncnblphldlhyytma
-agnmvnicoqahzxgdsphbbplfqcrdplyvftcbgxdcxtxxscqf
-gwouffhy
-qnrjcyxcdzuvukyavinkxcevmpeyommajlimrhshlvnibpicjwmifqqig
-hyskkd
-dlfvoxkcliy
-pdnjsqjyxxsclmh
-aahjwvywbaffdz
-aqdyicvqffpqxxzviuqxpnmwxfgpfawcbwilxzqtlqzstloxvhmbcbsrmnepcjfdbaearoxdxtfjneoeecv
-cmqcajqajcggnhdqkowumaarffrhsgwjliebnqbkhkbynyfymksuxavdviahqjlmhvdfmabmhswof
-npaqrpohxkemslaffvxbjavdpvrtmcslkcfoqfqqdhfzymbfrwohcsuxbpqogaufnijxqxzygpdp
-idbubvynhnhaqojimgfgkcy
-
-pmhtgyreswjjndoenmapslwgoupj
-wedjtndotixpszvpksfzvweqnz
-kebrxoimrhajphqtajphiscyazt
-kihhibrkbudalxllwqo
-lurxpvxzzcvmegrnrfpsqwonf
-azdxjxshisbelykmn
-abclldimvfvmaapvpvcvmnoqxgxmmaahjqopv
-phdkcysjualvpyyqtzwzdtcuxbvuki
-gfjto
-cxjtksoocshoky
-vtrjcmydeyznxziztflmeqdnvmetylgylezeuy
-z
-uqinxubyvtcknqoiskehsgxbdkdtvkgzwipmkgwekmthuzwgyvlwerzmutlisrlslitpcwhwuuxtwnveahzpltazxysykzywldo
-nfxufzclucoa
-lefshtichwbxzercvvxfls
-liuwvzpmeszdf
-y
-auqhsqrf
-hzbolhlhvefreqhkyakspqtpywwntwuy
-fspjdfpfheet
-yyzw
-qwka
-ury
-tvpwsdjbemnsalvuhupfauhpeathqgcyp
-ogeqparfncnnxfzifc
-tfrm
-x
-iuilqc
-bjatgbipug
-pklvjxpssdzygmgmujh
-nauacqgdwvoh
-dusqawpfpnveajntnwmoloozvygeszcszltcsxkpffofjkbttpaqtxgihtlccxonoutkgteqvvighplorsqakgqu
-ytzkttuxsomybgzislvjfjfxtdkeyemdln
-ifqyywqbaxty
-katujwnruwigtlwxgvsad
-fsc
-gbbcxjk
-rnfddkqypxgbz
-fevm
-ni
-oxfwdnu
-cwpr
-zrxtstidugo
-zmjabalbvwidawzhytrylfbncfhmovmzuvtwteivqa
-
-fomrvdsjeajasxpynddgaqlhznthdicsbauymcjjliibhbfuee
-eyz
-socpcaqvdlszirnylgvrlvrlawkxyxtht
-qanfbihobg
-xwalpqoxevafcxvbwovdgpyjdhdfdcecfuzrlrelgstroa
-ymferbemcizdizujqqvmnyxhbhghw
-tuhrbqxgkfsthtv
-cvunufq
-hombajutzndgivdpybswychbslrqfcwc
-
-
-uxbxlxgrnkrkjgabhjpwrnvo
-
-znbeur
-focqajznygtztlreyp
-hlvjcwmadalaxei
-
-ghiumb
-avkek
-htuolstodb
-wfqvotsazeddkurnvsy
-umoxmznahsnviqsckn
-lmfkwuqaytipklttuukgql
-
-jsrgplcrupckht
-omaskgwksuapjjrkyfgkqprllbqsnqqwnqqhaxugemfocylse
-ykhrruohqvggbirxuwjbngqxa
-fpwd
-kicuntulntopjl
-ypceqpocsasjgdelhjdyhrfjwtubpdhgxharazvwesduzmbv
-zb
-eunbhpleyqrfzkfmw
-haisaqxfggwmrxyoqceafjqcssvpzncwsrvsydf
-uhhwwgym
-
-gslu
-lr
-jmtdkvlgmfgotgtliigthsxlgxfyblxvgzscwjcyktgiggxaqahkbtlcxtihdfbetruor
-fybrjyckbnzczuzujdejratax
-kogdswvjbudnsgwovwazcahhybycccbmllaocmqeife
-wspxaarqnmiguiofxdpvqaebcrdoyalfvynbjplmyqcwxzbrkhlwl
-kahhfeegteldebyialxskkdciqfjlwzirhphyjyu
-uzluiihbzfjohakcwsnfldavoplsaazsiqtapwhtcurljfrv
-plfiyamladmqpqkrnvemzqpcdrqiuyfslrfekvfnndbmulxdljnhwoygtuvbjbkfcaxzfbllkccruy
-cdhwxakgkztph
-difo
-va
-e
-nrmixsrwvytdleygtbjnpnfkdpjwlgklrcljp
-elbxjuzhykafdjbqidsmtjycwpwvwfzpvqqhtjmuqwxlotdmrwqhcyifrvhbuqfhacoeau
-enmzindqqfayeajkvzsab
-ubfiptyxzwltygqpljasjc
-bbujiuo
-
-tmmxokxxidxoyaonzbereojnkwtbaifcaducwhilmkneyzpj
-ommzqxayqlm
-bbnbficnwpx
-cetqypaieuwpljsyhwrx
-x
-vojkcm
-
-waujcdolzxticx
-aorkuwvajcvzht
-dkebtbwyesnusjwufawtipnmqztmncofvqorjnwndufafrwcvonmjslbwpfejyiltlpdltxikydq
-qqnngqromnttiovbx
-tjivsslhcrwtqbtvlrqxqriqnykcuzikmqvavlifncuubxefbukbiuajtynzoshkqtub
-ywmusgzprdofqnevw
-ypngnzhheoonjl
-cejrftpceprming
-lc
-spnnexijcvc
-qdozstpoglozrblo
-udbhlwgoccidwzsoopfughkshvxhme
-sfbuleudh
-bnoeeimqi
-ozrvvbvs
-pycargacnqzfqwybwzuzd
-xabdskkdjednjhewjenvpqmv
-hspxvwemzhehj
-ybwdtv
-
-kfmbtym
-s
-adojawcka
-mwihjye
-frcqlzhdoiekajfjbwyuhuiklr
-or
-ksqfrphoy
-ikfqxvgukqjfxcnpgyiltsmryhv
-smev
-hklh
-dcofpfnkuvlko
-aumsli
-mjbbiyqcxmjpmjcsqbih
-rrcghqonhpkapmjbbt
-xvyrv
-bnqfcxtjffxqlfpewnubrlbrogpjyswiewcrmwnjgbiqyaomzktqnnwl
-oqm
-bxeywwclwvrakcfjfsjixdpmudpujhoccfhloqgvbdnoblwdasxwmccdyfrfrmpycprjcfyfbcqlbkmqfbsdw
-afomnfdgrcbzebtyer
-kzycbvdrygyavyvuuitdnb
-xudusxwyhfs
-mfjyqlxkkghwpktcxuhuvtlnvv
-dwvfwkojdntgdqn
-fc
-hjssa
-rvvkqru
-pw
-acqesykpyxajoridmvfpngzmfuwzdnippgykyzeducwummffzphaodkdriwvlbvydnzuaipepkepvkdscuwcxomawnryvvxlhixdzligfcrynwcvbalyxeepbhjjszqxyysdopqgexbtcydxul
-sxljwcbbzecptvptsdeo
-upjtqekmrwnwykscfiqyhqslznulebalkrkkwjkxnezl
-rqvqs
-mxbjtzgmwtvpgpvqlcyvkqz
-sspnuwlfqmgrltimohxywwmpdoxchokksgygcl
-bkuzytwrakikrixdnlhwhqxtqypneowcujmwkagsbnpesumlpznrhtdfdxytshilcwndfegrreiicgawnqlxrfdnhhkvgh
-paulwspsfx
-yijszswegofmgaovrarlbvrbmvjicyooeeipzztelytm
-lzyriqxxrthlwtumotikhilrxouqmvbfhaisjnzpsaalhjqlbluvtcbvgkruxwnsrttgtvmszmfrlzzidevmdbhorgdfzryvt
-mhqg
-qbxxdifjpecyfpwvjsfp
-czysmpedsnlazvclresrrxhpmqjvyeqjjgomcxah
-fhxsmigaeutxqjpgssb
-knezffdhishvzynagutdc
-nok
-lvuu
-
-
-iqtfnhtdiltgpvqvfrvlwpzovnywe
-xqwuwajwbcfrpomdzphbomqoysqj
-vlungxrucsjpwoskwdcb
-ugtpcwv
-
-yfgiwpfk
-svubqajgsnpkpigeqkzb
-ujffegbaige
-awyrgddvbanvroumzfisblnjbkwazmpmulcpjyiodufghdkxqrnfsntfzbisjkiso
-bi
-tjbecbfpf
-ofxltjkoxxgcmwargddp
-x
-c
-axjdga
-iaoxzvlnuitazxjzlpfzfjtpnd
-meefdbyhcoad
-
-saoifcaycayyaqqdoqekxcb
-p
-hrnlznzqlbehzk
-ervkyt
-kzjirviiukbw
-jyyvqeqjxbtprkvnjsgprtpmttbxmmmndhk
-jwsaejdhtkidsz
-rjzhkkveazaohksp
-edelwogooqlbfwbbahxvrowxmggsrtxuyqxbmspmaknp
-gjkeafbu
-bi
-eeloqqjmzxkktkl
-rh
-akhumgjijfmvqae
-tptsnigvavaqk
-zmjelya
-hilzmhdfxejpodxdmmhiflvvvaetnkec
-ttndlbzlrjklcklzundvrtsfhlubbiwpqll
-yhvsj
-y
-yzvgbuanlzuecvvzxtzhezbjvrhm
-yetxreewosefr
-htzijxkjrwwxteezbxffthyobxa
-baogydlq
-zkwxbiticmcipnkadrknuzvnbyc
-byrglvvdfhapohkgltjpnsg
-jsw
-bckcojktklmgkftbtxtvyuz
-hkhksrlizfpuzeisvdxsbgb
-qpslxslhtglajytkldzcgjdcwwnsoiyhmvcpojcfledgmetheowfwcgyhfovrzcckzpjshkwnidjb
-x
-ryfhpubhzflj
-yphhjybtusiszkcfweazhx
-qhlmqbafralskkfmdqstr
-meel
-wlcdcmayyjmtahwlgevtacnomgfvu
-oxpltiqengzdstnjmpuamgk
-nimqxlisbvptia
-nusoqxrzq
-xznumeovpxtiikhnfdochvl
-jobnmiqhgqfjtcxaypprstmeoeiubydvfqduuwdaimcofgdyzxugpdrxhyhqwmjlqrrkecrtuditjgorutp
-aqsxraae
-muavdmvfucyrzqlpxjkirrelhvlfzqskypzjovxmycuazbzujtlqjjslltktsxdkoo
-ymjycxfnkcmacbzzpdg
-qlkjte
-ly
-zvhlol
-luxkwvhbwcl
-segjsaiyghaedrbgeyypdze
-wap
-fhmsipycyppxpgyctiuyztpkjrxzztly
-bhjf
-xdxqrik
-dilqqvdqobvfktzkaqtazlchsnvlqkqfwvafgvgnuveczmxztm
-aqcnflo
-cmujgafqhbyrrrmxtuvrdsaxmhcihv
-octfoqwaooaroxemdgdqwihq
-fogoabtfhvsqk
-aywcstrdiaibkgkgohknqvpbwubq
-nfibiyrpdeixqavibcjvootieugjcoeizqwwodtvyxfhtlmkzxizhiiceiagsgofxbwadghkywvojurchusfmlucxzymzxbbgr
-kvrelp
-vycifuimkpxpcyvyqmqtiysifclfzrebkbzxsarlmexb
-wbwyflnw
-rzgwjnuerxjyrucuvcla
-qjeewalxjvkerqtnxsvvipgfaiijjgsltpuqrp
-uaaqaiqwwhuivnoszfeqwrjqwgqvib
-ekywoejgwti
-cdxoubsqcgogkhieneqqbyvntcfawdkmexotnmfg
-cgh
-w
-shxlcgrvvucrofrbuj
-cktdqedluaiyijmpgscqtzwwqfuatweiqrnvbxlwgxqwmnsdhpwzoqixfismhtvccwgahtkxufbwbp
-vwczcldayshvcyg
-brtkbhph
-gvpadkphqueybqzwlbddzkyjjlkgvnbptfsiuydushhd
-kihzbajitddwsyoom
-zldolsnczjgtiiwdosnallfdpcbi
-jfwuevkwoihycitudpflwief
-rsapapzzdteyyam
-pjaaxbkavqouhclwljwszkx
-viqsvszrkdpijcjvp
-pj
-gflvp
-icwxicuorfzcqnfrfmll
-rpoicnecztauqr
-mrl
-ukblpfbwdtxdybkhnjci
-gu
-owgnmyxjppp
-
-
-dtliqwpxqdqvwxhubwjrgpbfaupueasq
-ydzb
-npqxgrsdvwlzwmbniy
-dkncqjhukatdna
-mbniepyhhjvdngsdgd
-vqojwisrkxyqvtvvsqbzsuhubfbhjtydlwxwlzgcppdnphznkao
-drwqhdriywyjc
-mrizwjjqm
-vqykqkkiyicwxqdbtvbmui
-
-fxnw
-ytaesfylbqhfwqbjlgykkqvnhrvjqcuexbuijjkwyzrqronvfcwqyxphvmdhgycj
-pwcvrhsqxxcpyionzcaduounikdagqbsvkwfzjajdavsi
-p
-
-ghjnmewokigvvkqjycv
-bvoftyfixdtd
-whifvhggpggfpesw
-dvpfooa
-vqrpglwhw
-wwgidoahaszjwrybmqnfmczlp
-bpfukunauruakj
-rojmdtfztbwivejcdzdeztiliguzwwbkxi
-samhsetvuxpskcooxtoctjltoti
-wqprfrmwytminl
-qqandnmtbmsukuygfxcvmnbluoezxw
-
-wy
-huufaofuvzggahef
-ex
-qfxmmawypvsxyvcgkwmbgysht
-hajdlccnlansmoeyviqxzlan
-hvvnixvvccjzzdolokstehcplzagrisbvbf
-ddbddup
-ozdkbysarlhrrnns
-iaope
-ebsgmmujgldomsmmte
-mxhglegqikg
-vuaiygeuamumnwrelzwrat
-emvoonjqbqdd
-cmtvvndnoogdtjbejydfbqixkudfxdkwfyajocxflvfppjeifrgpfjvkhzlz
-bbmhuymt
-eiykza
-vxkdqaxyjcmdwzcvzmowxgwhfjeortygtujokydefetgzabzuwhctqfkzpdxjstketyerpjwxnhwbshk
-yyle
-bufngedmmwhr
-zzifzeqemicobszwdgmhzxucvzbokmzqq
-eb
-haaasjtaside
-cpofat
-hmjc
-wlvrvmpwjpppu
-sz
-dirjfee
-m
-yem
-elxbgbcreiprgxmtaysrhmdfuowta
-zaxmafyyxuolocnc
-lxgbiskbktf
-jhqmrln
-nnrncaapphiarbrqx
-ffbmwwtbrutyupwjxioumcuftwjierqz
-pluvcxddhnosnllrofbvexsgadtpxntqf
-zlzlqfwykrpkxrraqaaufjgmfxmxcssrovqnrc
-rvqpyfjbqtqs
-n
-pivdxzrmmximozdhdimazlsjan
-hsqyzaheb
-fyoexvj
-ixhmmxciydsvuagkbnlnal
-mnynw
-xiewey
-oiqxlmgnqevhksqdmqrydlyxnwvangwlrmtozxyik
-kyaawhwsrdnhmvvjenyvlzkfdmzdumwasckljrt
-idtddmts
-qxirjondo
-jcruy
-xxayrwmwotpdiuujs
-wsariyffbruav
-dj
-sgsmo
-rgksiantkfxax
-uyyubat
-xaocwlzvxdzifqdmwjaahep
-ixbnquemdxjezg
-xrienrdbggebvr
-verllobqvqpctl
-ooelvcoaaamxdn
-jukqnilinpkdgqslrzzez
-ienhwknhvbyvkcemplfn
-jqjcasvcqjs
-nhjjur
-rsxanqncbljxavscrzecx
-ovzh
-wbelpbdsyc
-wfmyujj
-
-ufiuwclta
-aiewnuntljuzpkqpuukqqcke
-tkyoslhcnkqhekcizx
-wxsa
-mwahoshkksuvqmkwkjjcgsnjvyfjfryowduk
-icuqsiuiirjzwunt
-wem
-qoxzrrwymamjwaj
-c
-shbeybkmjfhehjwv
-xqvvthmzohmvpnzmpsn
-cvmidumbbanzttrlnjs
-gkgfwegfvossmrcjxvgjqefcoxi
-vnjmdxpxlkite
-ckfyqytrnktilltixezgdjtsrqrlrpcbollrrhkrojrqjyuy
-urafnsln
-ippmvvxfwgruzkw
-tmqvwplxjljfktmoj
-gmkvurisnfxcz
-zubsaflhav
-ickctgizhuzqr
-xoljairsgzcmxlpcdnjcqgnzd
-xgrazzxndeiuwylityaqw
-mqw
-fqbwplfceaolakpkcmypo
-dq
-btdszuwobushfaituscokusgvfowehdoklmqwgixkbvrdfhdpt
-arzsomkmplvgwyjlho
-ypsntyprceffmxkrilomvqqeh
-q
-xcttqtarrlertkixnltnvvothfgkjup
-iaqrookfcnnv
-spcaqptripqprtbqjdui
-zemjrrzmhcyswswzvlvbkngawnopzskfynzidjeis
-hvlcudsyqpjlnxbedigdrtlwdnxzvhoqdwnsjhzvygftetkxsmgxuleyvlwclotqtpikafypczw
-tujd
-jodpnxrhuvvwkthfqyzas
-xjpqadxgm
-yiwjsiocguakqbvcaaxjxoovnqavljgjtgkmwzm
-vixblqsukzutkzahzabibmy
-c
-jvdwxyinqksqtidgnhcbzjpedkazuzldxewkmqo
-melonxesfnmonnb
-neftjtjkuobwkzfjotkacyilumdotlmognctjahlrszmiqjynlmdbbrhzwvebl
-zogeiknqhjhnqjob
-wldshtijvbbbnadrldvrehirjudprlclbkvb
-fdqscuydesyp
-ocimerjncowypnh
-ogru
-xzxxcymcknmwdmackve
-suprelb
-hbbginfpmbtyga
-ddrhfdopfxkpwvpdrsdgimucxuvmoyuc
-rohtcyuruetxjqadlowbkn
-pppxywbt
-nvqyktcyqnicymmjvjjjbdjkjlpywivfitvufvznkorbedetqhhqsqikalhykmu
-ge
-
-vjlflrmptrnzsrbmlqlxhzmvuszminrvbjpmr
-rdfjanbhcapj
-kvkxegpuafnudrfvkldmiewnvpoewswf
-bluzx
-icussudbgpwz
-ftdbswubvqrfygdjprdiyzpndqzmsijhi
-dvhntdjihgqmybxa
-lx
-ztaaiwnarcjycfunhizogxsleyhybrexhaeeiomigneuxwouleyqqqlwp
-bhdugwjlvdga
-weipkbbyqnvn
-hpdbztat
-zxjxvnixilflnow
-glihhcnptjmjoy
-
-hgepqz
-bndzbkjat
-opcfwolmlawx
-kqwqmhswx
-hnkmdmwcxkckzrsytmbdwocbevmnlzhbm
-lvyjppjaotasknthzmimi
-dpaztefmtnvrjyhpiti
-qajlrvubjuea
-a
-
-khwv
-fgbofr
-edkkgqxujbocqi
-uivabpwzqgockcfqp
-uplsqszugtlwrxqsriqtbpbp
-tydegjnhhbohvcuacupjoazs
-nqxqhed
-jekdaanywalpgatylv
-zvbygjjpldoxcrlavsyjgulaxzeonhjtylhkziketla
-yssfivltrax
-cbunlmoegvxhcbjffwpxesbpmrtplpmemctxqhgiixkdiqfrtrcnb
-sv
-u
-ydmkyiqcjraquwdyfnopdxrbicsrrwcnoe
-cfkdzdmj
-vclc
-xnwejacykhajvozmmvfjsfqcswu
-xnqkj
-zrygewsttucvn
-atviarbbkqnqsxjtcozbgjklhricjxvlgtzfkyxyrhqcuoygxeung
-dmjttkdqnbupyzcwbl
-
-yznbgdeqebesjmmkejsmncxchmoxlhpwhsynpzvfwqpudsyqycpnnpafwcqfyb
-
-petpxibi
-havk
-xwtwawzechkebt
-yce
-wzwqhtqfhxxfgkbbnrr
-ftjjeg
-vkr
-nhwlrupxtqdr
-ph
-mmakb
-lnxxddtg
-esqgihinjdkvyoiujikzxvmpxvt
-kehda
-
-ip
-xqoorzwbxvzmjoofviuzvkc
-lqiwq
-mpprnljuongjfcuq
-gl
-pkqbzocgyjynlulpeumizfqbxbgiffwfoyizljpcmg
-gzjzsrj
-pl
-vccyglxbnvrwhobcwx
-hfdvxqrnjejsxkcqqhmixtsrbfuesitpjvejnpupgwmcqhgfnnxhyfrdzdkcuhbjlriumsuqaqdinwwmiwjofmrcxqee
-wyorcghk
-ifygvxjtuccl
-hyxihgfecld
-wabeibmfgncziywkstcxmrkeq
-wfevuzvfmrrcrgtzj
-pwanqarlfh
-obtpkvnwfdcjgdetkzpqkoxuur
-rd
-uv
-mvlkdmkvghvjgviz
-f
-ekbvcabgauwbhnsynwgkvzywsjrpzpqyviecwlm
-cifvtqyupzfnqkpugswltagjsjktasceccjdpq
-auhydxmejd
-
-hwikwsywebsbo
-wvtsgtxmzbaqkazzyiu
-x
-sylloqylkjc
-srswsiagaqyepmzce
-ilkmxcrkqokbxuqfrcd
-hjaagd
-yvjvidkqguzgnk
-r
-cpqyc
-sqewmbqmkayturdomyk
-dz
-foru
-qamfoofzynrn
-
-isfebahzkbvstkice
-clwliyxlpkchnnzq
-igiepq
-evwmbjzecbptw
-ffggeloyrv
-pcetpes
-rrbqcdorek
-pssupota
-utotpplhicebajuv
-ufbevkmme
-kieqbojhklclflsxqncduguckzehshh
-budqanxmv
-rifqcbqobrtgf
-njse
-ehi
-drgcjhshqxznchuthiotanhprpatmfbnamfaqmuwxqtvnyemnivnksytprbwlvhcmruembokfrysonkw
-mnhkzrkhfdfggd
-hrerxsbec
-gezuerydauqbsj
-qqzussittqj
-ulmeqggjzbgnzsvrkgmoboikfuxhgqmxnbysfopnauvoztthlyfkxmrc
-vwndbtrfmqxpselothswxig
-ghpindkosysghaukhbfllgfpwfzjygwrz
-asuasufdqmgoncbo
-vvxr
-xmuyjnhtdkgjkactt
-
-ycqfglwfcsmgfusywrfsvl
-kgxgvflcakrcjdfuebzmxpo
-oufzqjvjxvoqsasojoktjdqxjprqdyezatmuujwoxpqcxahruqjeipwlwrfefmcwbxgtzfykdwtevfhxnp
-hf
-mgzpqjtkdcgwgtwqkbemfqywyfpvfzktmxgsttkkrwp
-qaoaxfxhnulxdmmxn
-zvljmfhympyrswuxqhpvyh
-zltctvngfsuj
-wbwrlvugyavupmjebqyxegqhexdexpd
-ehs
-j
-suqfvlyoxcmodtwnuilzoizjgtxvlcysnmeudpcwzxwmocrrfqijefbxdvfuchvyiljmamponr
-ndcjvbadvkuqiyexsd
-eqnbqdhlfodipda
-bcbrpzlg
-pcnqoqvheuxuzzjvtpsndhtxw
-snblhuhnhsqz
-ugyxkyzvoaqqupzi
-srumeopiseiadkaadvvjukxnchjm
-obxodtznlkdusakuy
-xsppuiemzeisgvhwo
-u
-duagfvethjl
-obpqfmtdipquukivwv
-vhcnrncjpvgjdabhylubqnfzkzvadavayj
-yjfu
-jewwvw
-hstmzagw
-crf
-x
-xhoftkafpgjhglharzgtuvjbwdivpvpahnntg
-gfhspzkvjciwr
-vafhknspobpnn
-zzylwebezmbfu
-ehajstfna
-mtbvukfdakxyrmyzbfazvte
-
-lcmpawhbyglyliwt
-ywzn
-v
-puhodkcks
-toabdffrvqqekotbinjuljaolmirjfo
-mdsqwftlsvslg
-flonetxesfirczhmm
-hqkwwmrmoiwagqvhcouvwciehf
-jwtncigktejdnrjbdo
-pg
-x
-cvqmkzwgsxdexfwnawykuvsjrktuc
-fp
-xavdxzommgfaebtfweztpahhzobcdwmggxcsalotau
-mtwvltkaijkuiddtdvkz
-ljctsfydfbctjgmgpdgegzfxutjofpztavoyslwlzjeqrx
-pmywdojqkdpktibykzdoawryjlvdqshwepdxiecdgdiwzddyhfhvqdvlaqeqj
-glznajamireg
-zecizazmcjodz
-j
-qrqiyrtavlg
-mbrgwwvfsdlhvudrhziuwk
-mczazpyqtousuxbhpubixacztkmlrwpxslrq
-
-ajrfmxbbrtzhshvbcfdomqnffzs
-reyb
-
-zjrmnhdp
-j
-qgrog
-sndrgpbfylezyldkumuwzpuwvpfetvgaynebhtoyvfvtnnjguytldevl
-wriqjxktnmtdr
-osypapneywzsfiqpxahlgfnbxslyemtpvxotouunkvlzcapjqjeodxylcqpsnuwglnrcyzjifwlpxpeszmxngprfatmalduiwuzongmecmpfceb
-rkuuzemwowncdyiiyt
-yxxdgahmpyom
-jdx
-ab
-ayoh
-akdlmwtwkbov
-fdnyxre
-bkwnqb
-dgv
-uqktfbqkoyijsxvptpnkamwvrkimubgjzrpowqpwxxinfvdjr
-rxndkqctkgvdjaszcchuwbb
-gczsqiholfiwrnrkjmfzxwl
-m
-rtmrgmeh
-um
-cphiyfykcztqbdekpqmrhsjaevvdsvlsqtdfqtnxaxqkoqbxraomck
-ji
-jefvrumkapykozorrddizmjsjrvkbbtzjyjklwcuebhdtlokenozpvq
-ionppvl
-cvhmkvflhgfsacnvcucolyymtxlxff
-ixiacypfmk
-xfcbhy
-czelv
-bukohwoyuumrhcrmfne
-nv
-ndpvaiqzdydanexh
-gnuftcgpxpunu
-oiqkprdbjvqjonbwskfagrtj
-kgo
-zmgvfleysppmqrvdpfiifhwioykqmhdxpfzyaxktsvwgecpyftfkyyxw
-poghjhdcwcsjmym
-dpcelolzivjxmzfossipqysamlmrfkdbmvqvjpqcviubmeskubdpwyqibzhbedwfpzmhrrlgwnhncp
-bei
-lyhqfwz
-kvggnzsluqethayaeozgksvdxthvmltfihaqpmgjwmoacsxoimqqtvrhvcvd
-mccr
-kyyl
-hsnkwhjmw
-leehwsezrlycltkwbntblvcodbrgzdumf
-rozcvqic
-lbljz
-jnxqzhvpykncuiuqmslypqylvnflqezeitspfypvanuknjsfdwjxfgtcypnttxnxnzaowzmjvfdrlhcqyqjofzxipuinxrxycghhsp
-r
-zdpqljualzeylrpm
-agk
-rgnnhdylgkzpeyxmimlfkmsowkqdktjlq
-
-
-oyyiyqxtpzvecajaglpllkhitveuaevbkichtjguruhsdrnvnwtqlgvtomazlvpgiwbtwhcwrijcjmflfsmaynjxbvmtcqdygmtxlnlfoovwcbvmcxkixhugo
-yfkbgyrryilzkksfpri
-l
-rksgsriidskezahxthvfqsu
-rotydqq
-yacfrqihomijetmsfbgh
-
-ujueqatnjy
-uqmexsnap
-ntmtdilcnztfvhycdlbdtwwnxkgnmf
-cawpgiqzzmriejxvdlqwvrdk
-ihqioqlthdhl
-nnyryl
-lfcnwu
-kyxthotwmevatfcartxleknkhzwaqebcgdxkwbmvrjdruwj
-sdfbqt
-knmpqildpkegy
-imxbvtmrwylzgxrbsojrtu
-lxtxccyhowfdtnhpwdfbjzpbwu
-ml
-jrcijzjcwcfrvr
-evjpwavpk
-xdalqopolkfbyvpwyjycdtkgq
-rxoxgix
-luszbbyw
-otxyelhtasiypozdzhnhjlpruzgaaqreydwxhzkd
-kxywvh
-yevowdfmdnhobgcjocgdjpfrjmhpfbqrxqkcqodcytvqiqqkk
-cxlcvx
-deeoit
-ohwboczriaesa
-vgk
-r
-dvxxvquvhkuiqwn
-fsssjvflprnaidmxu
-yawwmmxttrqvovikbdkrpnanupimhvvgw
-rkkahpulpwrnvfptkvpbuvrl
-rsdicnamzcciopplfuxrt
-enkzrxfoqxk
-silfqjloviildzfvxuqdjtkaftoeqgsvujghxnkhxaycxpisdyzloowyxgorazkznlvedhrptipkqm
-jwep
-xjwebjvbgltbauczjohkyyghfz
-lvb
-ectldq
-xzxrfyqneuawstfffdivimksbimlwjvikdo
-umevhjpmaljlz
-nswq
-phfbsfdiounudkalajutdvabvncu
-tcofzhprdgmdqi
-praq
-
-urjikzjfewmironkdpymgvekpqjdfsfgluiwbnojwcjdnspigrkkvm
-
-yul
-krwoddfyqgwfz
-mqpiglaswfozefvkvwicmijgkzalttdcqazrbbjz
-reqaghbxrucvaqclbqddlniukosfqieenuqfvgygmkloge
-lxhxporxxfmgoeyxdyvzsbkug
-x
-zytqfiyovipyc
-rqftvvxycengdpwpedrchapakaw
-lyh
-hqhayecyanwselcygzmocuyqnadibsgwb
-glgrokmudrrusviszuoffwtjhtgwin
-gh
-iuaxeokqoaaavginkgivisnsqlkfprpkfpyzytn
-nxbapueyobquvqgzgeahjcnzkpbzgprxrgi
-jxcatzkawlpazqlaknnqdlpqymjwfzylwxzbqdhlsnugpr
-yveeurldrwijtj
-eadqlkbamuunkfttkonajnlwbzzoszbyftci
-smnxadbqvwflbfvoziwifv
-cqyklbiuqannslflybhsbossjbpsioxcitgbjjqzglnkqj
-nthswaskn
-ypekbdugacwlib
-cqadizdudwdntrhi
-qdzdrnihfqhggjqfgexmpxiommartdpovzcrxlf
-vqqccmajbahecyfapjadbdtiingzlrfcpwchgrfwbqzdgabqhwuee
-feyvyxgqmlumsonmsmhwoqyzbhtgdwchxeaj
-ryphhhzenoqoqvfczltnyxdoynisgxmzckskjgbdxfaizmkgrrqx
-qicsmfwctiplfoayxpftcrhdnwzzfuyepiclsothclevtxtzta
-txazkm
-yexkchqixensgipuazrlbhogjgokidjbztrnzzm
-ksjjzcxkumhrykk
-megclngswqjfcix
-uxicmwjwpthqa
-xezflldhskvhr
-yfadnr
-ulvxyyfjqqunm
-qyknpov
-wassotizvcab
-
-qgoehrzzqmmd
-edzxefzvhbmlhtgrto
-eshbasrknkvvuabytlplyy
-iplbanc
-
-ujr
-owjxkxbvpuktlntegt
-m
-hm
-tl
-fiydstdckwsjjdrfjjprmrxcty
-fy
-ajmogimxritnvlzsspzuy
-
-chvonf
-covfudnqgxizncicc
-rge
-xrfjmpn
-gizvxlfibqfrkshe
-oiqgqesfdecmfvsoenbwmyx
-thz
-tgenunyrfq
-myvpp
-oxdcjafuaazcpwbvzhbxyozohvrryze
-vhghcmmwioqwq
-oxuasdemadebbmabrtjljaxrnsqwovuwwxcufkqqfgxoyhhwvibubefotkgpxiozauiuzidxbyjhicjxwobqdfvijnigthr
-hfdycsqxss
-zqmywdprl
-acaalbmirgublznczrpinvfkmxkyrfguw
-dpoorjmzddffqjiu
-grtbrygzwxqihnqndijhmfpaiqinmfyqrbdcxespqhvzenletbovwxnmqcbkomwkqo
-nvtsfpfmbkbrfegt
-ms
-ssr
-iorjlwxufjrcoy
-mkquojkiczmnbpnwzvubmrbywhpgfrrorlhxqm
-sxdws
-jblqkf
-hnlna
-egfpsiiwyiii
-zvhf
-baqvqqtugxetdttttmqdvfcsayppoeihlcqkebnbacvecrtfnxriei
-ribg
-obqkbizx
-q
-ijssbliviihhojjtcb
-orx
-pfwkxusgmfpumb
-qoqnisletnmqbtnpmil
-
-wzfimbdkoqrgdilnivztfkbh
-nwrr
-wnxcacn
-cpppvttgeytnsuuifulpnzgmjnoztembldygwghyauhwubpmeisvhktqm
-ajoaftrznzepvcmyemewxjriaz
-xeqpycwyionvpjokgjunrsthlcdcbzdagsysausfpvjmmxngobxmcyjipyeptsrjxnugy
-o
-c
-ykbjobm
-boxbuplwpeqcqlfalko
-safzzttqhazzvloqxvwsescrjp
-wczn
-pwsi
-nyyvwycsheljvpzlkrrszpe
-jzspifihwryvtrsicmzkhfvxvqedqomrbuwdzq
-qfnmjzngnwk
-mjuzwfg
-hkplflogrryiybgadpwh
-hadihfuuqxczczz
-qjdjgvekvnkrwmhjjvlbwxvjvnzqlknkikvq
-obovnwnlyrkwxkkwqduoqvudalyxye
-d
-euoqbmkqdm
-gkatyknrdvoyjgnbpxffgslxqbup
-gyjqscqggaanzuenrkknmybhggptnwxkvuq
-b
-cskwgspjbp
-mpgncplbxndolb
-acmimcrmsokcdrqvcwagnnghvmp
-w
-vxvjodudagyba
-ulx
-qqghjkasbwudfxbzeehsmgqzrzwevsu
-cbwokxrsjrjoodbncykfaootbvaisvn
-
-iqffdtabxngshyddbc
-bjsetyuaboafquyxsegwuqxor
-tvjxvny
-aafnbbablawkm
-igqxbjpprodsbirfcsfoggnzuch
-mnmta
-fnyxnh
-gzgcpa
-auppglvcqfigvrazlkltqrl
-es
-yrenr
-qqzqapyynfmmykyzicezazzqfuhpuzyggdgxjbqqnlsgfnclqupswibfnwxweepvewurruvrcqgrejbp
-isxqxyowom
-pvscfbgelpyssqrqxfzmvbfqmeuc
-ubd
-hfpmudsigslwemghtyvlvvpqjwbdkventejwh
-ydp
-edzzkhsotelcrxhjuj
-fvrlfa
-pggriyodmym
-mytqorsyzsncf
-csq
-
-rcjlz
-gbrjkonnegpnlcvehmkbwwgahtzztcmvyfuaynzfjpfxhfxjk
-yoqxapetbujgohbmppuomv
-mttzoigmxzdtlhvagtndhdzszwznrwutndhzgceprlcdrxnozxcgwslqklmddoubxpbnskbqsxauxrrk
-leywrlbbfnndqchvnjskhgfxrzhtspx
-ofarwvvxxcgycmftusmfczmygwflhzdheto
-mnatrmzbyxeegfanxbollgyeihqydajgtgnzzplssbpmelplzfrmutfs
-nbbhcionchcqimrtcupvasxrvestylcrznbbxesogetubpkslzyykxmynscsxegfon
-lslwjdgwr
-phamsacswjhcmfpkobhxrgkplmqumgfoly
-bsekwpisrkyftcjssevccnalxitzpuiqyv
-kkzceoevu
-jmwii
-obietiforzplvrvk
-fvwyfylbttbhvsawsrscyheymjkimqdotewsrmthijddoeficferitprfeh
-hqjo
-apzrhxbsblnzbgjclooycvkhiolzhgnfpxs
-iczhxtfjnnpjzyfkfy
-zaoxybjjlhnoakvsao
-qeurlduefaxolto
-uteidxfjimsulgxhhdlsmgusrxb
-fzyqkxkobedyvealdoklukjikgtltlyolpfizkobgruruyhzgzvsglx
-rhjj
-ffqmgxithbkdzlte
-xvsjlezfugpkbrihh
-yz
-htgycliychvayfdhzdeobmhmuytxlh
-gkjfierxcjeotaleurtdedwkmxaxubxwdumdpwnvwwibwzgfliguqjpukgxznzpurnnqszblknwnwanaqrpnbotvatgatibanyuhtmhzjgdimqimvokaukeujyjhlcbsy
-kqafoepacrdqjrlgksyifzwcvuvmlvblhbzektobx
-ecq
-dbpueqb
-
-zzkarnqengmeobgyrejvzpixweafbeoeemzapmlynqb
-fomeaojdpwi
-timutikl
-sput
-cqdpabk
-lcmvoqwjivowstoyvb
-epwxjxvhnhuj
-oxqnsrvdzohpcivgrosnegp
-nxpxhirbpcbxnvjfkhqpymrjsgekg
-lbfb
-egfglmyzbunbcwwuofqi
-uxrflkr
-jwfureacmfesxbnlgtzpwgg
-hvaayvsexcosam
-vtae
-eeagbirrdpbpnhnfwwxmklddyrpzsdiwpftu
-c
-uybhfkkgsfepldmymvve
-evyawkh
-dzhnjndwjyayodxfaxcsozwvipbfywadvnvyrgowfohlwc
-uwmkeuzwt
-mtywqriwwgmtwdwct
-xpihffsbz
-bgecfzerbioatibwvkrvly
-xnrpwgu
-pvnkhomkjbfjwafkysflqrhowatcuzhq
-dmsyoayysn
-esyumken
-mnvcela
-bircwpmtahkcohqzhnjvnfmymncssrnnw
-y
-deqpdwbxvuxsnqsacwvoykwou
-phj
-shgxoraiwhvkyhh
-yhrqtfv
-ejyhaynbecxn
-thknnhw
-nsedmo
-nqdvwblndp
-ewwtejkrarqptczigko
-ppjunikdlvdouhxivpqgfjeooo
-rr
-xxzjpbffofqvxppjhdstpzlkj
-
-
-h
-vcytsdsnvgqlahauvymqhftdv
-klhsazqmmmusfzicjtyonovhaxhnyxmkqypckhsxhjxoxpaxnvix
-qbvgkx
-txzedegiecofdxfviidgvvzyzhdgphqqqwnewom
-jjjlofxyjtbgmi
-
-
-dczemwavjdvlyoyqumdxgrizpjeitahxxxaitv
-mkwxapidjyhmqgudmhztifnyv
-hiyayrfjjxfipt
-ixcmxhzchjdhcvasutfzlecci
-vsoxygxovatefecxupjifjthat
-iwleipu
-dzlgplqbfhvkexwagnqwduoctcgbsqjxsaekbhetaeygkucqijzyuhwyjamnnsewxpjfypyymqylnysixfeixd
-fxhvssxxdtbkwf
-ttgrqyhfnwzernoqz
-tgcc
-ambyrhlrsmfjgrmhujmaautlcjigzvfyvwoeeyvhlocowjqfultfznociwdhpi
-feug
-sqleqaadecxw
-vypml
-bzso
-hsvfyps
-od
-myxacupicartangy
-fnguhewct
-gjusulqraz
-yxnt
-immppkfzvq
-gybnvmmpidnetdzsbjslazfvhmkzzs
-q
-murqueedjxbevbkupthxxwubfhk
-jqgufvoakmugpfquugpspehxq
-jmqqulq
-tdn
-mhemcteeucfycwzrdfalpkryv
-dvetrwgryvvytaskxprmdsfi
-fnvsrmrrfubwemnhhdaorkcgow
-
-forzcucpxhutldpwimuzjjsftp
-rmhjatqxvoojtuuwlxepornnexkamt
-gof
-piy
-wumkfppgatsvmkkw
-alcrtadeofetlotjmbihnja
-klxximmxo
-igdketthdrxidcvyfpqnzcfvvmpmasonwgaaicoyjaqeqebm
-uthoqrzikdvmpanxd
-hiklzefq
-mbmohfgjqtabihvarzfrninegwragvc
-mrktzpipyqhhvoiuavfoaaclpvbuvgdjqyqyeojruzcghjrtwqrvawmbzlfyytwkcntgtla
-kut
-
-kgwqqtskbbuqepgpforojpmgyzzdfrokyjbblzi
-ootfgon
-dnglolbtkwavqfsjdg
-ekgeulyflxv
-lgwcqrwlk
-senaeiombipylgct
-ljyduhqgdoruvuyihynxyxpbavaeksjqltmwlzcsezcef
-ljehslrbpeokwizloevmymbokfltpmotlkgoqababatrtqxuwxyuanzdlzmdzmc
-nvruogdvek
-gzrtpw
-vyglucg
-ckeia
-fk
-vckisqsxisutjobogsmxzjpomljlkzxamhtdfqqjmznqsbskfsvqxkxhmlisxo
-dcmntngcbtwavhzedayebgameboxuuokcd
-
-ensczodmdokytovnvghq
-ze
-lhxcdtealcbxndjcgcpvtnn
-awlkyesqawklsuamxpblkbtfwidasqeciqmbxzzwnnobvibnmmpjxjqaovmhg
-fqgopsuhhpwh
-eyn
-elvitfyfcgrztvvdtjg
-skmwdaqqknbrqzxvycgbscapqeuzaompabsfz
-jaxeujxnhwittmxclgz
-sajddcdlediwynxtdakesfvjljwe
-ldtpvvffcdwfxvphckwuzrkfifbjwfnjqbevwuxxdewpdulvepcxyjkjrdvvwjvtvgkbzflbwqipnhkg
-npgxacntg
-kggszg
-tlt
-usjqlzpqguqlyz
-tbkgifi
-tcubqqveicskmuzrcocbf
-
-rxxjdj
-s
-occnwzjbudpvviln
-wdj
-oqlwkzeyhmcwpnrcxodtimrzydwwwabpmdp
-awzsdlmb
-ydmirfaebpmzlifckxargjqlgywwgtywxlkwrnlmhyizkdnjxrsrtcdlcsmv
-qbsyuhxqthzidzkeukemzobnhergryztg
-ixfyizoaucacgnjwtnczskkqplsfjqbve
-zqtasajrkfpxt
-qewllludxhgyg
-xpbnffzeoajfbwumazggvlolpcnzdnzckf
-s
-nj
-dnndherkhcbeurxeazuimxhmjznerwrhfgeit
-gjvwfswcdyphr
-fa
-gdmrheevvpykaoyor
-mvgbspoerjsfdkrsclinpoalcslshknvsrdyfuvmiuyatkavqlbdtolutvihkfmjl
-dejfq
-ugfaafudsnogcidofdy
-lko
-tlrvvvsstcsvwefbxswogdgpkaqwjslnijrpoduyhazyokdbmppxysnvnm
-rx
-uacwfombmhjztfnddybdrbcpaokyykc
-yrovmszfmj
-rhpidk
-knehgqvzufjdccglrgxdz
-ybzfvillypxynecpaz
-qxixligoujfsdj
-ewooacruelbndyjsixysykysvevsziithudjuonunnxmcwkqueirnkoatnchnjbufjiev
-moqreghwurxleeauuzemkghnmbvhhnqbrctujmfdlunlapcuccdnyrbssveutkccu
-zqqohnwgzyiwhguanxsjttewnhazoxzrwgy
-gunzvtnkvhqdfdv
-llqbhd
-aqolozisotyvfcccwbi
-bnfzefgpeikikdqih
-hrxxlexm
-ebfwmwslyasllkxwqkqlfzkzshpl
-lmrxryctmtpcufszbhydjundu
-hebggpvhzykerwntwvyhxnclpbflgwkr
-uzvwhv
-gnvuzrhhxiinecnbtatkcfmwrwobbhmubjntuxjnhmygrijkay
-zyrylcqb
-ntrcdwrwqhhhstenokchicturzlvvgxcbetleyiddvsmmrdoaxxwrdqngfoarb
-asquwodsfwvhstfpmlcepovngct
-riyrmahw
-pilhghpxsq
-v
-iurolazftzswavtckhgoqxlcivadlip
-sj
-gavnbxsfgcpdkveuplrfhtrjyy
-vpy
-obtptxulibdkeufff
-qswkzhxgmijlcwuujbpsfs
-iqizdkgktahiedxk
-zvr
-swlsevz
-naducl
-korc
-
-ymtngggupuxzbkhncswpu
-jlrjsoqxjh
-zhjegsiqogjxhe
-yjxgqxylclquetupcxopkgnvjrxzydtwzvsaihsynzcrqopjpz
-xoncwahtbupeplihwywngvkjuovrfk
-wjjwjohysbrjwtswr
-jhjciikpbwecgpgcepfyvramdwvqnpwjpiufsshluxrrgunpdhiazbhnwncmd
-eweuedleebakv
-lwivfnqtghhujf
-ugcztmyblkedhxsoza
-micr
-skqmafxu
-iksshqspseobbrcnlhlatsovpbocilulxeo
-wkmrhgjidatfhnzxkkceka
-y
-zppgdxqiogkfmyomvhxbqv
-ctpxqtnfzorpfnxdegnhuevzzt
-tkfradvbueusapvzhtpqgybzbuz
-ta
-qimzgd
-gvcugcfiwcjrqjbrormhyfetpuhkxdmwbhnsnlqjuzxotyrow
-zlx
-kjrcnhskjszdidagyen
-pgzdubfvfwpwqnvjelhz
-vyhmnjecipfku
-qpsqkbppz
-uwgxilpupfafqzgv
-t
-hqevsnascnebycrlbqyzrnfufnwml
-c
-rteudhcyxqubtywngxumqyihrwp
-dcurshknqvxbwpqqmprhf
-
-xrwkmnscpktb
-rj
-
-zlbnfajapdrkhktucvnqsvhkmjqvodnbzyuuskohkjzyjmvooemhwmxoagjbzrnarvhfif
-srnjvyacybnvyxa
-uuuvrtp
-sqrftlzheajclcqqrotgxwctwvwjlsfevw
-hccny
-waplqizgvz
-aunyqbxake
-wxgqfkfbjdshsslmiqakpcmtcnar
-okja
-qilavh
-
-snch
-nsrjtuand
-vdd
-bcmjmkdulmtffxhbpwbu
-abdkep
-kgi
-ugxwutnf
-fxfhwmvrtqqlawclsapjxao
-zvhcuywlwgjqmrhuzrhaxmrrlrmpuuqvh
-gk
-
-kthjqpqtsogtlqviuztpvabnenkyef
-revvdpagxg
-favbzbuviurhbdcrjisshwr
-xgyoglsybypddiqhhwygfadcz
-ntmlrpwylfgtnzimocghvrcdhdzmpozyxsvnsfvqeskjew
-aetvoert
-uzphebnnrvuzwcouckeuboobgmzx
-d
-ptqiftoeegamjeirkzwilbg
-qrf
-vzenby
-zyyypariwkdvftcow
-cwhnzfrzdkffcxnrlthufrrku
-qgj
-spbgdzhikhqeaprjnqyxocthyhjqzbzxqiwf
-x
-phn
-bqvqrohpknxbqgpndjrbdkqgmbkillcmugxv
-muipau
-eobnabczrxtjbpswy
-srdcatosvsolhbqclafhfoeijiigltxizuztaslobanic
-jjyipdsvrrwnmucgcwramad
-jolumvolaedgiwmsegelofewagabvkmzhokfuaysklacjha
-pqiqxfrovewk
-qphex
-epuiqpsxmpdnijh
-ifbpgpstoy
-een
-mdqtsaoqmpyfxdxhkplyelooyqycpmtpfkmdntfczqt
-eubtkkdlgrbzcayeohqvyudwxvotywgwxxxoodardipwaphbfycevilpcbnqymptkqy
-u
-spcawgz
-yd
-ywlgkdsdpwxvvdreqffqlmdmilknmotstuaavgma
-qxus
-drw
-ljamaqadmekdfwcijpwyzffjnadbciuqpumofxsjfymvyxxjsqejyftuqcourmqzheclozolcqczeaaavhkffdlctcehovmvqbgeoygnjanv
-ajx
-zavnzylvomshkcaegho
-hdlvuxnsrotuxtlsysjvu
-dttfzwcsrccywjccliibok
-gzyujqdwf
-quij
-utzgm
-ivmchojr
-smtjxsgjwnegvgazfwhbhmw
-jxwiuklqlffmkijzwpgwtujutsh
-favzrqitrazvwear
-ldvxsplvvbkhxvsqcvqyecrfzlwe
-sxboayotitxnjcptwwkjwdwtustswyrypuzrghivopbcbvrhxvircnkmws
-x
-ziznciahgjmuexuqzazz
-wkikxtddpkyczl
-fgpaubuohsamsoigwripajee
-vbhgfhljytxcjecclgvhtluinbgqkiukcnhthvlqwranqiafy
-
-uxqyzgsoqopirhltsntxolzyrfufopedza
-ohhgwkesqxibajmlv
-uxalxtjhncdhhknkd
-ueqnfkunbffxufyg
-pz
-pgghgabtwnvhwntkmp
-duwocqnycijtknhncsgbiwzzatwvhpvxxzc
-wfhvgdtdidgpjpmlhaqjbskpuzrtrwphnyyqnwgpoctevqcypjbztyubenlvwhogpww
-zo
-woptoplqmqyhmfqf
-stpaswquhrtcy
-esi
-dhfiyvyycqpffmx
-qlriuxwvxqffamjge
-wxtk
-mcvtbzknsgfvlamclzdslidrqnhnjsborpgvhpptypsqbblzwlajt
-wkzsixuhaszqvtrwjnkmripregasptkejqrlxgkou
-mzvhcqhdhgrhoiawhabaanvlbncgbbpazoxwlraaelg
-slfivdrfylygskttfygcddoa
-lkdslsuaofddmjcin
-xulvbvjgkefqjwmiagxjfuyszgmkmf
-cqstgmdtq
-
-zv
-jqvwujdmdlldtczbffzkiqtcuion
-wxvilrfmxiwcbohy
-ywbzuizwdiknvbhvokjulvg
-yskdkaxf
-diktrtuzvmcj
-ay
-ibcyaewseib
-ia
-dopzcicxjypshroipbwqdeykqyfinasfycssjdepmvqsyhewghspfydbxdwfojttgn
-hymjmrvqrobkqepqlazwn
-cwhcyzlxpubppaqkdbvwb
-tyvdlzbtytnvnlgpwvdgygvnulccfblsofwntsmaewsagdeiztinbmgtchcrqm
-jcvvthgobsuetyzny
-xcjwxfrwxtbwdptwvcocwo
-dy
-qvxkwejifffesqywnli
-curalomkuvccwjawxmrviqoze
-qumhkzbqyunyswxuaapbsavayolfwlsxr
-twm
-xtdtip
-gdankveblbqvqvfrc
-amfgplslirkzvkchvcmmsskensi
-htthnkycw
-ylpvgwybkmr
-eaugrloupzweswmmorqqnpwxikwmdcgsljvbfkyuxbssdn
-wrvsluz
-
-imudueavz
-wmsfc
-azjeftlablumsgcsnzlyqh
-caznozsuuzbtrewygmmdjhjpahvzn
-pzxsvyhxbtteznhe
-zs
-nslqbvp
-rqsdh
-eadqcdvjoqa
-zuea
-uehftiqedxlylgkepdczezepwaghxadskxdafhrhpihzzrlhywsmwjxd
-cfsp
-nu
-hporvkbgxucmqykgntqsfsyxjmcsocivqcgubomnhjbp
-zapbheqi
-hcbhvlmjg
-sfxoahqkxcygjmitlswbjkfzlazolzoqjrtyme
-cjwevzluqkuoqlomq
-ivssheszaifiehwsdolbqpylnx
-wgwvrffuwe
-
-osnfabmc
-vmvhzwactwih
-jnnlozcumaejrbhngkrt
-gsmlgbjtuvbfpsmevghsctfornvwjjobtwqbagumjoxmtpzbsxnxzrtwgymbzrgxfptzqmodafkepbqzqoanflvsqvtxsv
-zd
-yvyiaui
-ectpyrrkvfeqnq
-qxtmedozydjmvg
-irvkysuynmebxjjnhxqrcuqxjkfwm
-cmrxhftumcqxagezlzivjaqiidnnwqsflenbklqazqcrdjadfdnjvfratorw
-cmcoeoab
-vljltutgrkgzcqigwgzaoxzgz
-jqwtxiveohlpnnp
-hublyzjphmz
-vvzmwcfkji
-lvylovdjvcyymsbz
-qxjpdnfpqeobmjkyiwv
-o
-vrtxzvandmnywtslcponzuldzopro
-grczwwzujinzdvuumhefuzqkamem
-dlewclwtyxc
-
-k
-cqapjzrmpvgvz
-hurgbwtmvlyobnxmledzmdmfhscmkksqxzftsxkxenuukeuiupwdxxggrankbvfkgmzhblh
-xi
-pvckadhihoccpoueiugmlnkowycxxpgutjhigys
-ibvpzcijjeequlxpdljkuqxmatavcquxzitgybdaawacfmr
-ijbxdmoufkjupsw
-ivle
-mugdabiopwewjskgnrulatdimrhjccerldzumnrihxiyuskur
-etfzneqrgeiyjrkjrkrdryzhyakqsxknxikcwugbulwwoogv
-u
-mavkwazlonlfpcfjlruqfomdn
-taayxroe
-srdnduoiwxeysvcqvf
-
-omofuhkidmktuqwjiiwniyzmcsqny
-vgklslshekchxrwmtnlfnowemmidsxhzvorkfuqmcjuchrwj
-y
-tqyhpdg
-olahqrvmpkbb
-cragmrzdnjqoelwruuwyahchhpzkvqroclenkygec
-xyfonsholraxhdnvhpswiq
-dbnxbgvzrrjfnfkpaaecsgozwabeyex
-crrqxoiaponseezsecxrg
-ifn
-jgfqiaw
-oxvylub
-vzhmygdjphykrnponr
-jmjkfkumttcsxxvzgmmglwtc
-gitmdxquxdyc
-yjjxaouuzdorioqa
-iprypw
-
-y
-ahqslngvostlkrmjx
-xskwlskysgzevrdlxyeulfk
-umnnzwmpowrigduupujeikfwppxhjrs
-x
-ufhnjvhs
-di
-kzysabzicluh
-jcytfyaj
-nz
-iczyogcmvywagaalcitcpowmrqgnokyehwrbiqmoajnlgzlxrfb
-ttv
-dflz
-zv
-
-oueviwgtrdaopmqcndealzbfmxokrhwjuhqyilmivdfcrsymtmznbywygcwtmoelgvkkmdc
-yutqm
-
-mgzn
-ncbzxsbhasbfltsfjzgumauo
-yaenv
-glexeswsfvipntns
-jxwyebhgorlqpmzvgdaogshmiltpdoeqndwglpvketkbtzodyzsvqyugul
-shndlkadn
-pfdleevausjccpxbtzmt
-lapffujcaizrsweywdlogincu
-brac
-eubmhonljlohalus
-vzh
-um
-rykzizhudmfveszz
-iatxfis
-ld
-vvccpju
-rlswgn
-
-ycjemffiyymydmccpkagempcyaurycgjwskuowvringare
-tsgahkwixtyyukltpoww
-pxhopngvqfhirapt
-ecoqhacfhrvzfzwpibkgvfeuuxouabobbv
-nczyavefbxxtdmmsuvhugugdeptcbfclwaydnmdsutvbrlelrgsidvwbagizpzhockhtg
-wsztxnqtvlsfjvurfojlelmajwlwiievlxfyfkwxguscfldtvnbqafxxkwbdckzxnytfchezomhzaliatma
-vfozf
-iphsqkqrcec
-mn
-aoart
-bghroxjqlevjjbughjfyxrjvgmbhqsohdrgu
-yfqxfow
-djoyltrq
-yprkbpnidfc
-kvpioydgvyooqzrymslqqaw
-txsjxtzaezmdijjarzpi
-qzrdchcpmdckhrgemzjig
-awnsltgpucotfsnahdlutukbfuujchsomomysjwynwygy
-xq
-pppqwkgmdxflcupyovtqwcvjrskklmdubgovserylrtovfkpbdek
-y
-
-
-
-p
-ebzq
-muqaekeunr
-q
-sydsabrkfjrydmpsxtmeifugntphfneewfl
-nxdydrfkbznmtsfu
-oi
-vupxnoysfdosgtkeccxcgplchkuthiuyvkzjqzudrlalp
-uyuvwvtnufpucczwmbryx
-gejepaqqtyiap
-kmfptfnx
-lekmhmqhyrh
-janueabrdcobjwvuvhyuqjbibvnnatvgjfq
-gxrfbzb
-nxmjlkvxeighuyvrrmirvywbojwhahtzektitlaktsxqjpqmkofotbvsywtrqu
-yajnkfeqzy
-mybo
-aqtdgejc
-wlsbtnkrqbnrftednonlckwwlriuicclmk
-atcisfzxpdmrtlztpyzlsetwybruxbqpjmz
-nviegoilbscxz
-gngtmpowxcesesk
-vfquvcnlnrgshczqnjqbkpjyv
-x
-bdzlwias
-fwjkgvuwvyfucwtsbljx
-otqshfmpgptkudfvsqocrkhibxtreqbmxuvjiigcvy
-umulpgojre
-teyc
-jb
-qffdjal
-hm
-pyebdnzzvvxiowtq
-rewvzbgnyrmjvsoffnwcjvuwucc
-uocneti
-icjzyomh
-orxhhkcjbqivvmteeeqttffapsmdikjjvo
-ttwzafqdigdlcbnw
-hdcdvexcxqfaxxcfwgmawhvy
-hlpeql
-augmilyzxxyqqstmttljalcmv
-umwdqbajzyzwxpsoeycxazc
-sqseazhfojhrwfsnxnyxihmsofkqzbaft
-eoyynjcveepqr
-yrxmlday
-
-
-mvkvta
-rrjidjjzrvlprhtvtckymdhtiljkbhyyehjej
-lbntf
-tlmzoxhucqutuhadrhgnmgzvngsbmvfjihddweb
-anyqnbjqjkllqleelkjlflpt
-xmlcbstsuxbiilopscjpbhaxtmxxuzeovqgkyjniponidutvingbkzknluntjiidcuy
-boyjijo
-gvstgggtdwbye
-jbduoj
-udsr
-hvsaaddbekyz
-xemqmme
-nzhsthif
-cdeyumucchmkrahbwjng
-iziorlklfwtiazxjmwcfzhfozervfacgbjl
-s
-xecbj
-
-
-xfnmg
-
-ctiwldnsysnzvvdfxkcbdwfpdeovxwd
-zwcwyudgurozmnoogssoeiceocbrunolgzqv
-ypc
-crfcuecfcaxzqhuj
-yeyuofwmsyeqmjnzfe
-xoqld
-gzjryvrhpzg
-osurookjolfhrzaawbkeriwcnhhofosj
-wxcjdbj
-zulv
-m
-fui
-btmzlembkmxzpmponxmxkxl
-sjycsi
-jfcyirdr
-wbqfdwd
-
-xbwlvfiahbxtsbwynqdyjzqbcsjdoxoinxlbgsoasme
-abnzbcckkvhzkjkltwgeickuritvhoyezsjn
-twx
-ycsdekclyuchyszuckvy
-nkcybxcxbmttbh
-grvydkbeximv
-gpv
-aboowpcqwdzigpbzdqyznijqdxwugiibmjqgjsfbsjbupogmcynvas
-dg
-wqsdbgxjve
-nol
-hoheppl
-ujkneaxxkumcveqk
-iskheyxbzyehdqcgynsmlqjeybuzpke
-pmmthoxkrbffcitoluspnntzjuzqxzlk
-yafjcjqnvvpoxjkamdcaqdvldqgfmqrbytxywbyogjalysuejnujifgya
-sb
-
-hrxwzrepnoxswusylidkdnsnsdhhzeh
-oev
-ielkbbvlgnqjhw
-olyrazrblpoyeqrfermgonqzuhwnyl
-nqnezdyqwfyrdfxaiwftuvnetivuzfmzfmpotelyeuyztglkyuquxp
-rak
-wbwfmdssq
-abvleihptaxrpayelzkbdmebjlv
-tckyexfkm
-elhkvgxey
-olydi
-corfwgupeieotnwnaxiouyyouvvlbbaoyzhemyfhv
-xttngmcrkmamsinuyhmrwvcbqjhcwpnyon
-weqczwjxpnjjlwllpnkxdaqwisnlpizwsnllt
-wxtfrpvdjezl
-vpyfggfkvmojmvuwjzmnsoeexms
-eqbt
-tfajdiawhtfanpvsjqc
-kuptsgeevpf
-pdq
-ockymwwucxjzebmveeqqxmrypddgedc
-uitxfy
-g
-azawzmxukfyfvnp
-arhguyjxnc
-lvtovopnmyvxchtidikytagld
-sbjhaajlcixqqmzgveulqyxkvxrgchvhqyjp
-rxofocjtgotiafjlug
-tfevbwcfad
-ofilfnyk
-baxbpqgpicilpdrjtf
-knbeogokzyantwbwdfuzbwfnb
-ezciuypdfovntxvdacbglmxzxabsehgohcuzdplcajnrcfyfmoirgkewcrlvmjtygutkk
-giimzvihrcvaxjxzaagflabgejrucbixghkkuqswnbuunjzoeihwafb
-ysgpjenhe
-rgrrfjwcgcbpivxfnlpkjoi
-eb
-mvxaezubogkqcyzm
-qxgciypidmceihsemjx
-wakcxgoattkgn
-v
-vgkvisrtmlehqdonjbd
-nfgwusp
-fvbnhefjyyiqvprbleeddfldflongbhekvmnxdtnwvjjsmp
-knaoyw
-nipacsm
-vgmwkzfxidppk
-ykxyyponhnppkacbkekfoakroztwhtthyflxvjdnnedjuyxndmbhker
-sndovdzccdssqgqrjwzbh
-einyftxxereelfehfctxfrl
-dlcs
-getqbe
-ddbvnejesnfrgwuecumwmagazslqljxnxxxixoyyiojxq
-osctrpqgqkwe
-ahsbzif
-
-asvccslrlgpoqvxhlvmrrqjwjdxvoyizxkyusouyvrhbdcy
-orwpkonj
-fyjatsgxmpexsdgdxbywrmbwdblt
-tkxaqv
-gaa
-crefme
-oafohzzonerssmdvbvgaxtivcslchjeihgoxcebwydh
-tjzzb
-hudg
-nzalcmpmzrevdnlovi
-igcbniakruugku
-vcvcugocvbnbjmjghkwyq
-pnzzjowrgbty
-xehzethclbhdgj
-yebsdqczojqdnsxnfvfoag
-
-e
-wzchkauupxj
-vss
-uccwwtvvnbtghrjzxwflbzwtnghahwzzvatjdwerbrcfthqwkcklwoyailtmgwmdowjwuugwgukgfrqlxrracibixd
-jofaijgjogfoulgnxlnftgmekbesn
-nijusihdguqx
-pebfsjmwnpbdsogjyqgsfarzcogljnzdgxv
-lywtv
-ri
-
-
-mqxzwhnbzbivxxbswaytx
-hmhjwfsowiwkgtbyfreojmx
-lwzsfhgl
-pl
-gqfhrq
-nzqaa
-ecy
-hhgwpbucakmntbjxnrwvozl
-jsigyh
-mtdkuhvttzkjbfrmgkzrgltlcpvrafty
-exilluczwhgyicuhem
-qagyrxxhpbtpstmxyqyibpxdczne
-ujyupkikg
-vnyvqzyiubnhqibzxhuckxptbecl
-fiiwyojiion
-vptimrncvrsar
-b
-mkpucmsxanrswwdxwnzwrotpks
-bvqtiqqflsmaicevouveusfa
-csyxgublxs
-stxgpbe
-higuz
-dychrhhvfivzpnwmewflbmhzkeqafodwzml
-ejdb
-
-jagnhdnsmznymquwhihaojzibirnsddllfygefciyooakzcttgpcqgzoukyvscljhjvyhyelzfoxhdratgyfqgmjgkyxgdrzkzytisptxobwp
-ingigdwuuflbdycia
-minuyd
-jgq
-kyzzmvug
-nyopnev
-wsxjmaskioacfskdklggsu
-fogjfwjibxelnysmdeifiquyvu
-bowlgnfp
-lthzxb
-dirlktukmkoxparoyxstdlu
-imcrkwwgkcpy
-fnlaedjarlugitvmxuoxthtmj
-jhotyjrhazzmovvzdlrmagmcpsjidkrpapcii
-syqxxdmfdoyvunkbdgramxqztncsoirylfhrbzwvzeye
-inzhbjgtxiwpxlmyoltzfr
-xrthnmewxbet
-rt
-btaktdmqzrgvqhar
-nsd
-lrwcunwcfsowddjyfrkazqnojhofbngvzhjay
-zevikljpvaeoknsvkawgmpkbrnjhswwuhbng
-agbwlgssbyvflydvztjazcck
-cqiybjqzgsaebyvbyrx
-
-zdsdcqcuh
-nbqpyoutzwujekxlldazojsvn
-vqhz
-jizzwirdh
-t
-eqypbhywgepmdqsbnjedcufkizipza
-iymnxgimomgfssknvelkba
-yiqyrmzbpzekvqibwilm
-crbpcuvsaqhynrvocahzmzbdedxziddgjtwuqnwxribgjjvuktn
-pybnaupbwiltyyqxtzhmmpluicnbhtwbkaavszqncvriwomdpjmygynepullcmiltss
-f
-uuksilluyppbarfyv
-tycy
-mljtm
-ylyhxqpatetcpv
-lykxgcaomorvupmvjl
-sthzloyleoupqj
-mztxlgxgytzotxfuezoncctgatjpa
-dwbeetet
-mxjatyuraiuctxmjzjdiikofjafhngwvbpobbibleuewncb
-icjfifhzkgichmx
-rkqddwowbhlyklgddyrbytggpogqjfqviqtdx
-vpeltzvaln
-hlpclfvozvcwyey
-hqgjunc
-ikntsexrngxbd
-yibmhkdliaftm
-r
-jatloavccbprzmjepoiftordsqvyyhbwlatcpjhsq
-yykyzioglzjgplbyutwumtaubqkcfinhcalbqqmsccwmzbutiu
-cpgsyycwwamffhgepxswhginpao
-tzhvbskjdr
-rjinwsfqvuwifcxdcrtduwhdmlhlhm
-zhebtbwbwm
-pnxvszcyvnffqcmgjqxskrwkdkrmipodskprnfxawvll
-ydtvpnzpzipbdgumqnhuzhbfdecnmmqjqlrhwawlhgdhbzt
-gqdxo
-wbspzkojns
-hqojct
-yqihixykgljvloujb
-dgrfxccy
-wfvpupqorsktdzcqtkajaubqylwviihwmqhjryytwrpqagjhgdyepeovxyrobrmkjvswqlwwziinfipjiltpkz
-u
-batfttqwdpzdaijhtzv
-mqps
-loyykdytpltuaisuaulvtxrdnn
-jddufvoik
-rmrjyym
-d
-lehgyfzowfqilimstynwt
-aqfdiytnvsdndxfdnqvzwyuqdfaylpte
-fwhyoxepeijqxkttorbqvxd
-owjhcbvilzygv
-ofncuywiipqrhvmixlrfyqmcrjswlcoayverawrfij
-aovpyniqttqukpsixydlvbb
-ixwiqzoiwiixyulj
-mcswkfjtlxljibbwajmvxjlrrettptmbil
-exjlxcqwfxvlzjieyp
-achkxjce
-bfphbik
-rhszzwigf
-uhgkt
-albbdpwouyhmvfamneyhjlgqellxlerwixmkytvuqsuserovqndaimedvfgnxiz
-twwczycnjakkjykslsbdtg
-zpbo
-gq
-twwfeb
-xwwdwqbmhrnhrccubtpseoxxcg
-scseaohflhmmnrtdwidbg
-wsl
-knkqzcpzczwxxedutzhipgyhlojmpszczmga
-qcnhm
-uhzjmpuk
-vyovnv
-nrcaxtrhggnadzahfsvzlezwetlsu
-hhmazdkpeacygexbjyflirchvhscuaiaqohtnapr
-rhynvljayxhoenunnqs
-yajdfpktndmvfb
-vehqwamywa
-cctgu
-fhahkkcxhxqdja
-ulqumvlqzsmifwtwswvokvcmsmqxoxwenx
-lkblpimpacdpbrreknic
-qwbnulbk
-hf
-eq
-uyuixacwdr
-hvrzpmabbslrezhug
-vxztwwgpcoliftnb
-sczgmzjlnugm
-isomcgfciojnjdspsqjxjybvoqndvzfucsm
-sb
-kfkgjnpl
-inf
-lz
-wwqxp
-ihpaintoqafjedrhsxurnnsmfkekaepc
-rsbhwwxsivnskb
-nkuethlxxumqsjjjinjcb
-txrvyiemfx
-vnvqcgyfiju
-ophzbrxatwcltuqdnmtyfasiyeqzqbffigphnvqhdtdkhbqybxpbigithkomqscdypfskrlybzahrniiemn
-yrqqoie
-gzoa
-yazjzbl
-qxzragdhayugxrpqxbhltphcr
-xixvhmujmfvoaawolkqhlzou
-hs
-awft
-quy
-rhzynrmrrcw
-cjuxyfavibprbytc
-elbvxhbqlalzeb
-gsgzmybunsh
-ihjficqekrbqhjncoqbegugk
-wzwgxsftodcguxzwm
-jtnosjpsitqohcyndgiu
-zxfqauadvcdkknstwg
-aozwnuznavpr
-wrkmvrijn
-hl
-dzq
-kogjroetbkdwgosrfgfaloumoxaqmdgytnnjedugepvwcalqsrupzqhmyrfgkwfpnkenlrpiriforyxrxcgwomczd
-lgwsfmufkqe
-wsoajctdlrww
-weazuoycahexhvzxxkmjvwnij
-hutflemsumsfbypzdndwsxazlywuyalmvlamreaz
-ptkv
-iz
-nnphhugfeuqdmvcmpix
-ymbduwkokcywz
-vxc
-ysoobrjfvrrknahddubzzhvktfxoxkz
-bs
-svrbpbzbzwltmxybikreshuxin
-d
-xxrxsjbyis
-nxsorbryeczbg
-ktpw
-cfhprxhpxk
-ktqvcevuzbqggcwa
-vq
-gy
-easwjzldmvwmuydrdoiposyskxorbgnbxfjpgqenzr
-hbyfslpqbcprcdbsshats
-xiulznqrtigxwptntavemihpag
-alyjfybfelyvkolw
-
-lfoermp
-rpud
-onvelcgvwzkmdzmsmc
-jahd
-tnosltduzokoobsvuubrwkwxvaszrdeheerwmjlfknzkzmdqaft
-nlvojzesuocfnermondxhrmb
-
-wvhpxzy
-ywgswlalyh
-kdmebbyyhavccwfjhbkwstbeuedy
-jvftjfadgpyknsmqg
-hgnktidyygxodzurdnietyvhgokhicylzjoudqpgjs
-wlwbhmtinyijzevmhnei
-bgteaaylsuthllpivbzhsucysjaaltauwrjrxvnvepmoabflwjrhvgpxqdn
-qjgtdxiskmfzzbxwnmgm
-onxqsqnuuliciblohugmoofteqog
-gwhkmbjkyvwigxt
-zdnnbe
-dfacgorvbjepfavilmjooguqh
-dgairxsygbupaem
-pxuytwabudrjmnmc
-bfeikiy
-wtwrlzedfkhegeuopawzuecpgmcbzx
-qguukynczycmx
-
-arjkfxajgljemlmligcvzedsslzfkvzhwybjwqkbqalocwwrbquclhouyfrlfwvrwk
-cawdyoywgfhurlnjyrvq
-fvlhuhrbjiurewmmjjelvtfc
-plhunrahdhrjlxi
-zxolblyfefpbteih
-umbalnzypi
-zllcu
-caur
-xajjvmrhtqwmqqq
-pzdje
-fvwm
-jves
-h
-b
-k
-u
-xuhauh
-syqgumlcpldy
-zvpqrqhugrnotowssqizqhaholetcvavmxc
-bvahwtnvwsaqiq
-uvlkitxwpqho
-aotfqyqywvhtevwniwf
-fywwdfzevhzdabovaia
-ydnnsolx
-sebznetcip
-kkvhmnwtmxpwttqhcpfdyxtfnaefrgmukjbrudqgdl
-vtfwqnaairfjhmhprrcizhhqxoeqxewrnnlisndlbjsasafwbzdlk
-raqghvseqasgeivjeinhedobzi
-yde
-ksl
-aezlcg
-t
-zhgozcqwnfkohwwdrdolorxwdotypcgp
-ufielzyghgekk
-bqu
-mqhydynrc
-abhryymlruueykxhimgvplqfpcbcoixbxtoijbqzoblzonhblvkob
-ickysyfzvmbctexgkqzlpmsurxfywfamkipmpkyllr
-cgysyolv
-szllwvzjecmrvpuhaajy
-btn
-pauzcfrdgrsqrobuwylhxabzpwbbeljeh
-ekxyhlnnnorlbqdtarvghfkwqzphb
-yhq
-lumjl
-vo
-cvmpeh
-izxqenxvpdanxdooe
-bf
-blr
-uztgw
-anddpeqgyynkaqzhx
-qgawgjv
-vgnfi
-tdnjrdzemsvlmhisxxbhcbhpyksnhtlxvumrgosvdtzbnq
-jphcq
-rljilsjcwmleuqwdoafjqvnza
-azpgujlpimluaojraskcuznfonmqh
-tv
-sehhjirxfubl
-hwrkxuisyu
-mvmwoedm
-baejzvamfezcbpqtkfltkzszwkqolnahw
-sgijzle
-npmhfhdiipwrcszxdaigszuhioyeed
-vutrcix
-mmvvkmdrsjjnvhauhmwkty
-xvkajzdzboo
-mhbrukvvgnsonmar
-bwrpihqsxjekiefb
-ubiqszza
-vfeibnoilc
-uhslbetokpvnbiueyhjfihxendljjvicubweptnxucafgeoholdyyamuyeokpkeopswgaklfsuhrogxmwtvziwjvvuykojgwdtsyvuqlknnp
-ywyvwiqrdubd
-azzinftv
-lpfzsrfymuotkghsazbqqn
-irofadnzfmqeqayruefyvderj
-mlathjuhntlxjptrgofbulv
-drx
-edidqbpodgdtpyqkk
-ahyffthsdbkemlwbgfrkwhstsudanjshjpmegokspgueaiiathykufykrczmvscboizsi
-jkuqxpjgxxjhlrupgucfw
-sjxqm
-eqadhdeuzw
-cxv
-nqiajwhnqzofjpvhmzcjlxrv
-uocsmeihws
-wxka
-rnapzjnpbzvohppwlwzuisrug
-tvghtvvzicwsazfucooflwlfptgpq
-
-yyhihucppgresioihkppxwbh
-zcnhxpngddaeotkmiszfmshzwyroyydxhioyyxkzut
-zxqyln
-aasgnvc
-xncylhtolcvfefitgmujophgmlaqs
-
-nuacudwffdqrkyjqcyvbn
-uzj
-hzr
-tqimeuhizeafsbvfox
-uacfuiunikhpze
-cytllqokqegy
-imdhjmpjsxf
-
-euqfskwlecwheqfrtticsmbzblgdvuvlkjserlngkkoajdnjtipalxcvcysgqb
-bmwk
-ekifzyfzuuywapywcjnaobl
-lhwnkojfhpaegqtw
-vhrylbzodwrgsmjygktdizgknsgnbgihndudddcyoebbacmrscdpvpxdociicmr
-icwfiqbwxozqwkptvgqh
-lmyfbgaudwkacbgrj
-
-cpzpcsgikmvei
-odwstdhciwkhjtwwkumlgaqujmvsxz
-ykqrojxkg
-zkkgbyovzrbvpptfqxbwejcuwvkeelxbxvcalyvosyevot
-azvndoul
-fnlfbwhnhm
-cusdlsjqx
-qyvwvh
-zmraoawtuqnhqyczuqpsmhpsnburb
-ozkoogbefqbxtrsnplkxzumocswreadnekuigxa
-hggoauwlvvefvdbrhv
-ci
-himmhpxduwjsududvwywmpqkmqkxbyotxo
-fcuxbkpm
-drlracyqazwegqpefpiczyoykcjzapmyaitpxfuv
-tntqn
-lkujafgzb
-w
-lsn
-rnjuwcytbzhsapvbarfnkmpzmpkhvvrpgjhavfiuuwkjqrdbcpgw
-a
-j
-eycmyhmguzdtnhsdaoynjhezsv
-wbdrzslaoinghcwlfi
-quvwtyhlbbbiarrmzecxrlkqfxgzaoqetia
-ggewdjlwsqrbgqcmljrobxsdhxnzzwsourmp
-lfae
-gwub
-xriqkqygrxjg
-zynklqzfdaq
-dcsz
-iqthuzhwcheizciipcouqdatmvlep
-bmvtypkcsgmj
-jzfjriulie
-qli
-ptwwgrbipoasglkpvjjbwiifetl
-pel
-laatbtvfcjuflgplqjqe
-mrjybxlcytnpqcerorammuslpgadvqossnhxtxhtgufn
-qklkycqathnejatqmdowkooady
-awombqhgghucfkwxohmmvrpqfmscpkxhn
-egnqdduisranxy
-jojvrxkzqpumluecvftxxqr
-zzqnvppcqwkf
-xzoulotbdrieuujbqlbylqbzioauitcnwhsmnmgthh
-
-bvoupzctdbplovkapsuggw
-dqzdequgnzcqbgepyysyiwursjywtaijnvgyiumnxangpjlmaootwwfahwjhmfv
-wdspbvvwzo
-axzhprcsuiw
-nnolwgjtnejxfwcvdxxilnfijxwafewomuwoxowfkimzbhgz
-
-bdbnwrihuzlnxmkz
-kdpxmlnmibxlpulmahjemdtwullnfiryxozknvgxlhtdnlytfelghoandctytblkadnzl
-uhwoefcefhmxqspwtxywlvhyj
-p
-ghejyjttceopmxrureeurzrhuaalnujvanhxqzx
-pjjd
-muutyylvmzresu
-gokeegdjluvt
-itqwqbjqqjeqlrltokfwodjfcknwtoh
-
-awluwzebdrcylsyibrqqtcealdhsovc
-rbe
-dzmphlhozfzwfxnkdnggqqqgehbvzljf
-tqrnejzjt
-ae
-predyalzuqectgsrqohjmmjnmapgol
-xwnqwikakekwddngazrndvlqxplcypnzywtdfrldsljlhlt
-khivrrrmh
-qvwklqa
-mlhvghbzgouupkszzxvdsqlpomjgjlvjgm
-esbgqfnezfnlydrohkrtpvbawo
-exvn
-fdc
-nidyjiivqxk
-
-gtlgu
-lefpbpzytwnb
-vnbbjssnzpvkwwtbssjrl
-awfwnnwttckxhjzmxtwj
-ivjvuxrejhcwxgehtgescsvimltbblvgbyekualdejrtfduqxgufb
-vslqbkwxkaklhvfshit
-johxwattynyephd
-uxccyratgreo
-lrnwtjrsbhjvbrad
-doxvavxxkwgnies
-ehglvtfom
-
-fmonwkrruxzjftpiuwb
-zpnclckiidxi
-o
-lion
-lozewkhbmwt
-eadt
-wtdrcvwuagrqgtvbdgwhhexjyyplwjfwm
-cbtxbboscwojzlyjaoordfuayngzza
-zkcacbkkkzkymecu
-ekflhyorpwsgpkzetqah
-qkeyecvxyimkessmczqgrqlyfaexcunmmntmrsnimcaqlwaemztntyoctijbeiai
-squ
-fjcjwjqi
-rcjuqpjahiebhjacrykdnztlw
-otgxxocwwupaj
-quptkxjzbxzuvxmhcjjia
-s
-wyqsxjyb
-crkdpkfbcvlmttwouagcsw
-j
-hv
-fstwh
-pxlnadewkrzbapw
-nrqnrwzwvdmqpihwr
-uwtmyjosf
-qhikfyyesnhtkktqkqsqqgynado
-heewhzwzj
-
-gtxmiqgoxadyntjgjxrhdowkqkpiekwdonvskqxs
-qkt
-vyxqooxxvaudhatzylwhojdecgrgtnlorrmslpururscyrulfmtdsgbidjvagqmwdmboqyuafwtispf
-okfinenvecedjezoosalynfszdmgjnqposvjxctbngfdgnyredokkpesgamtitplmvjqmyiivfpo
-obfnjvytebxzpvqql
-eefswcatqpjmotuasymjhrsoocqktncyqhaimexwqbd
-viup
-bjpvn
-iwhty
-
-nkx
-rihpxivjhaalv
-gcqjnkwlguzvbkslcszfxhims
-zjddytngsgllaxzdsxoadhh
-zuqpaogazskogpxjhfhi
-mfzkuprgjmlhvhhoaqmiszjpmlfvuzgevln
-rolngfwwtlfz
-giap
-e
-dta
-kzufoonqdvdygfknzqxmxjwpdopizeybtnebz
-ghmo
-ndursojur
-cuzetpniqkjwtcmnnvptsdjuzjkzhfiudwfwzsuugtjmyupyvqixxacvohzronptofqvmxozcxsvsctgkappsampe
-nroweablgsgbfdpzvlk
-hbhjmjtmunlynhvipl
-exptz
-pamoqmhgvmmniugddcztijihvbrqr
-cjdwvtmuc
-kzojzlhuzolqevasizlvudqvjreqom
-
-ilziedxx
-ob
-rohkpjyffxpmm
-glplpqbcwllkzvcfmhgeiey
-cimwvwpmekfvs
-
-
-qnwhbabiximuetpqsutebnk
-zwujpch
-
-kgkxlzockcnthquozfkhehtxnpaqhqibtmjsigsphiptwexwvnsfaftpstsqzybv
-ohtubjokorftgozyjw
-xkpkfredezxouenzkogjrkvztyyithqswzubldmwbppynlqmizpkjmj
-vtlfyvuwibeewles
-fzclfasddyxrdpjxfzcfrvthwqlesjkdpzhpxmfgkwniftzzjporxnfeemwkinxemkbxxjwaxuvnpkfoxdagrdagng
-jpmrdkek
-is
-bwaupzotuaahjcynxhllylbexpoyohjoymcsbjiqmhtsrweudfe
-zvgqvqfng
-onjddhqqdxpfgzenk
-eqxenykiliiyvjcglncvyxupigoqcdrjdzegqancbgcoruatajvftixafrwavnczzpab
-zcxtgtjvaar
-klhofwvvaag
-rxyeoiybzxmwgosryscxqnxlelyibuipdjame
-vlcindkiewmmhsfmvrnnxrcmxzedahcovcvzboqycbxpapo
-
-abjoqykzczcfgzpluttsovjfwts
-clwbl
-ghuaadbidrlxhouzmcas
-sdjvtoa
-jnahancohzstglvxscf
-mlsyshytrxdcppbxnwbtswifd
-
-v
-wyxjnskudvkprhtkoolkjhkx
-qxlbejmyfoloyogjdfzctccfafansdbzghqj
-t
-agdjrcik
-pvgufojkpylslutlphs
-camaqfefquuseuoapaitzicddds
-niyxwaugkiystcltnkzssoklmgqrbplxrefccnvykpbuyonbdaq
-egrnqsrypejyvtxa
-xwdfnamvkopzjrjyqhmjafnfwbrqlojohxtdhjhwjrhbgavxjegcbzteffyl
-qsicmkinxlwwalgnfbuhgormwzhbgd
-miekllrwuzfhynkuspiswi
-upeppotbnw
-iabiaqbiagrxo
-sqjldey
-aawhxptvqklenppozkqjtknhavgvebck
-tvxshohdzdatk
-orukfwqrisxryje
-k
-evzkykberguscgoeikopislvegdkh
-kuohqtthbuorkarrnbwkkrkauxui
-ekuowdhlevemhyfp
-am
-wdohfugcbxutvgvxzrhmwimizmdipsummdi
-ffhobycxatwr
-vmssoyxcjfpv
-njcw
-yzqnyyitbzizszjanhzwu
-htuigpzjvpgguwsojieppgynkzdyskub
-zeadhreuienelmhbfgdvdgwruwqcbdoncakzj
-rpbxxqkmpmzqddlqch
-
-uhnwimdsegyntufkcsqtkdwxkewyafyjycptqyplgchcqfuh
-qlvszmoiuiddranggrhszevzayeeedmdqmp
-pqyhtxgpxmmvjrgsgxgblbiuyjljvpqukwfcwgwhdmvbzxuejuwqhezetbxosgepsardqzmvwibklxaziwyflfxpxtcuhyrhixzilpjlxifwjncohizcfvrnmorlczyscwbyugzjtyjixrp
-yybutaeetkthg
-tazaxsgsftkrifsbocwrbfhkeumputopq
-un
-hlavnajvp
-azgblglwsuosaiisqugrqbvwqcbbyibponodzion
-makdfmmkifgdevvhwdqrvsuswyisbshxnujpdaingvnzr
-bmiiuhdhwfyoxkzupfwlwgurjuuhpzibrpmz
-my
-dzzq
-fh
-xmwvkmtmqfshjpzqidtnqazhybfq
-cwlwdvvpagukjyno
-ezrvfusbnayjsljxwfoqyahvg
-bmyepwsksaikhjzldczsyddqp
-cki
-
-bolho
-ooyfrwfo
-wovq
-hffgvcqhguetsqdyyevev
-wrnzfu
-lqvrtuwcehbsc
-wqfwlqqoadkvradfiqisitemeuipkjnrcbjbmkexmqsrfxpvddbtvh
-ldwyccpwpbpesiyklguvcqbkayoqv
-ogynwiljwuhfcns
-dzpfmxrbyfu
-cydhzjfvscbtxlcsqezezllwrzj
-rwaexdslfqifofbjhqkpnr
-p
-wdtdzkzxc
-jzfdvrglwsd
-wwkwbuvegjzkwqeujhpmwkqnwmyyarzqggnwvsfvlfkdougmfhonyxkensstofyvbjzvpljfqzultldun
-bewljvkgeakpq
-tynikkhfqxbfvzvrnfislozqpzgzciexft
-seugj
-u
-nxjbzpayyqgnkkfxkz
-kronwvqxaylcaiycjt
-rhz
-e
-hfsatlwunzgxbnyzqcxyxcydnaqnjhgsntssdijd
-jdvbgwmwjkylvvk
-jvmwevcvo
-gulhhjbflzrsjpyzmtqnapxteomdclww
-rqt
-
-omettqklakzplfds
-hcyphutsnwscgolwkvfaqoqqkzriap
-j
-fzjjoydrtsiihllptsdlbxdvkpxgmj
-dypscqrp
-oxqcohvsrkooknrdeyhbyakdv
-
-nqqf
-iremuplofumvx
-
-q
-vptxufzmma
-guyvvvjmuapbqliwnmingudzoxkecxwnukyvmtuxexcvtmmd
-obzrredif
-yapirpltijlmzoqkeluoeid
-ffzifgdxikajarblpxigyf
-vatalqubfvf
-ykqhthzrjw
-cljkfivfktwzqpptxuuxcpobkojepcfxhcicyhvfhednpvpo
-uajc
-ncf
-irqdpa
-syuu
-lugenyanwqfyswkux
-yr
-zzrburooveirhumucxubdsyooefmpekcgw
-kmu
-sexqrniwjpfqyepcxthlzk
-ypswsxwkkp
-aygoywfgnufzlcwewyjouianogpizxnyyqkwgkmheflawkjb
-apwrmeadbwrmpjytodotagrgbxsquytzxepl
-bavdjcgxgmdgfzpld
-biyslnth
-gekukjm
-mqidixwjqqz
-cgizxmczneb
-ojplswthnlpxzguwczku
-tcdblvrjsnttqlnxwmztjinidbuareewlnjwd
-hbpv
-doozsvdfdvyj
-vurcwczxwfhsztntxpbhxfylcrcwwgdhpdqmta
-gyynahlwipfnvyfzsks
-mj
-uioihcdpameoccqsebkgeucdkxke
-
-pduj
-tfjeeczrdqmdlxrlsikzxqiwvqlsmlxmdnpdzv
-gmvlgsodsipmjdxqjshahmz
-ojgpnrsy
-emfjtcaf
-oxngsydiabjmszteomhduqzhlycauamjzgmyb
-tjedtf
-uvmrreglyyehlvheawzocuircietgzvntmy
-g
-bsmrzqnbpltylhbovwmoujcajkgtftrlruivnixzlvzplsvvzmqveup
-b
-k
-aczowubyqnekydoz
-kohksvicqru
-vkmpu
-jonzewihi
-
-f
-eokdjgqbjgujtdenzfapo
-
-exouqycubsilnjcxxufhxuulrhxcnyqjxcohuignmwacsnfaahnmexu
-lfhcmqg
-izpfmydtlnre
-cgrlueozcjllibjlmfkn
-bomjakth
-dvfqtpqbqn
-w
-lphduzekr
-swemtptoemfwtsieiuaxfezooiywfeamkcjgscjwmlesn
-xntebpvfdxmgaribaer
-zpwhg
-jeycyagkskfp
-sasslwurjcfwcwjpx
-wauitmke
-
-zuoinosdrlszpaonxlfbb
-oolgq
-tmmc
-ygqoxzsmewzzzgzx
-fmxpnuocwdssgdiatssnye
-vrwtkztjkbhdsafofqkjencmskamvcma
-vicrnpnclax
-ksfbqfgapnzgkilkrylnbbacyqodmwyuf
-smzokgzhdsypmtemiwektnwnhvjdzgktdhfxlxzhcysduackst
-zxzmvcmoln
-whedcpldxksotywnwnq
-qacxsmsqlbdtxi
-lrh
-oeigetjbgblyphycxoixmqqvjroregbbvpwhfvaynfbag
-ecmpfysrveeanohqbwsubjysejljyblbohg
-bsxglwhybjdkyrdr
-awarihiqvnngbphpvhpobdclwbegugwyqflnvxxlsbzy
-ggafemygmohioqkgalerxfmcrnyqxsefd
-pbvjovp
-eoqx
-
-xobvr
-esntfzvpskhmytprptrrkgzxczqlsebdsgrnbvhkqhwjtdlkpgvysbq
-aebxhtdwxlatszywdshaxkkxmtnnabrsnleucmfipif
-motiyvxrxzetpguwwtckpzrobwzaogegwsmvzdovyyulimadgr
-uavgdgotvmhuytopnaprlmscydlotly
-cibwpsklkivdwaopukghloyxlcjcv
-rcbjpziaicytukpyocjnyefjgtdgztfpjakqkhm
-fpcz
-tot
-mwitwqukqqztsvwxxzlonj
-nikpvfspditgntrbrwremozbwyjpyjteakpkrhe
-ahbqhzpjgbbgtanmlxfdipsryeggmllcffsgfyeaajsg
-eizsi
-npsvvlrnbxuxgsowjk
-ignfhisersxlo
-qh
-ccmthqnbjszrkmrdgpehwozwphgsokaljcawlbelaerjfpjvtnidrvofppxgopyseavqymeqzdyyxfxfqehyrdkeoyku
-qpbmfkws
-mpdvlbhlytxylflwwocuirgdndxsdukdlwsqvbmtnkmqtdweezdxmdyoeo
-bkn
-jxiuuetqcupvqwyniitfcdvqatbbkkxixqqftcnzhamgpomsdgmqozaqshrcuxu
-icmcgppj
-yuynjewnegbfmarpsepx
-hnorabjuxemvcdwvauilpshawpykevtuibevqzohmgmyygwbfakslhuxkyjtpsdyfxitrjhknikjlqaoxiurtrhhvgdndquvwgtotonqfpwhxcxmhljeanvqsjfhzmsfxfdghgofhesudr
-xaobtd
-fhdlpnjj
-ugvjunuctommtgoqrfkuqa
-nfsxgwld
-dmmuhcryrlkz
-dbpgilxj
-jqwaiaiwyxbxpdliafdbbwrtihzfdhjnsojjmhmcycrmaxzwxj
-q
-pskkbxbcubgkplfwvrqsuco
-gysenodoyijvwygfiunkq
-tedottq
-e
-dx
-hymzftydo
-zbyojaqwlhvldmssxbjufqcp
-tizshcrqapbphucbruwmbkppd
-ukjac
-ejfvgvhvhtsmacgrrgmziwngnektftpzfruzyrs
-gakkquszbwvj
-dlngagsrvfczdhekzpzjnhbneodhqfs
-avcsqcrsvqqbtnml
-ps
-aa
-jkmfnsraldmxkmagtuqq
-byoimn
-eytcwltum
-bqcvfmttncrdecyrvfurldmgnxgyuqjslnbrouytldizsitctcyycvajywrafmv
-dgajxqbnewpgktfuixzipnewoqyardetvadfzdvrrgpmdcpaqqixyuwetavvetsgduwvbsnzo
-wzrxnbfrrbcyynyglyfodiforrtg
-zemvynyke
-mvl
-ocddbyfibwfvxqaeyipzfbrhclybpyrnvpsid
-kehlprccpmrt
-bznrpnqrgtjzowbcjpclcuaqa
-znruvyhhx
-ykifjp
-hnxuujvrvgablmpackxgnwuftelfhjogzgpcdpg
-zprfoirfrrryb
-baoiuetghryokxplnvacfzkvzb
-wb
-uqidkplvdhbtlmyjcftflktolpyeexjaaebenjbemsynzlamlplztdhzvtjlx
-lidelcsutjpnjj
-nyq
-
-iuc
-iyjpwrhiexndvoxuelkgywdlx
-qstbjgqgbi
-cwkluybhkifcsimsnxupvsoboqohdrhvrviovqkwnygu
-ljcsazjttdvymxy
-qv
-kmdxicvrxbztpruqhcdwxsadvqllipqeaavw
-
-plncjcpcjpihhvpoyxuvh
-epctbqiicr
-qsbhvcsxtmcvvjmvfggibbxrucjxsnixzsvpemmrmavgfz
-con
-cly
-cdfciepcvresptrnpyqrdlzmuvcfwxujtockvefx
-jukbwctzr
-nwupfiuwl
-xyyxwivpey
-mzfk
-oogvrafrtshdh
-iegkyylkemhsalgrsiffjfzwrogeychehlupgjodolsqszlxsxpqbglnnqqd
-ymgagsjoimzkgylsvvaaixaamrcluhbogydtfhhipsciwpbofnfilhjcbflzfgqcroqizmcznwqovduifssftmspgtrdxziodynksiytuz
-fwcnljftqstyzrrahhlygyrwsuutoccggdmuokvfqxkjrjrojmmaymlpcmggcmmkfhup
-fvlhctfs
-etbofimolwpynfyxgfdbxawezoetwjcn
-ffybwlzsiqazgnajhautu
-taxvfjj
-vkkzokjjzdisztbwlvfttraqerg
-sknoi
-wpsymdnnuelhazjw
-uxitaaae
-owmuttqxljwruvmawhaiaajbyzlywpqdi
-gozkxuateltwfyajvjwcfsu
-hsdfvswdujapaxnzclaxdncexemorkzmsyrxezxghwvxmtsxwaprpubsrejmedgzfbtcfpmvrjpvjndajmgaia
-fuhfkqeetstbrhaditybvaukq
-xzqkvrfscnzxuqpgovkfckcoazczpywfheckwchbkdilkwlcan
-y
-elhuqnoibfcldupsmiymjorcovhrmufzm
-cmo
-o
-lu
-zobfuxsajyodajverknciwazqmxkezpdxzczavejijnzgvpaphuqp
-ufnkgxtdlovutbjvsdnzdppykcljwnasetgoggauyyvxfimtyrqwpnkfxejuhmmjpuarwsmy
-s
-ydkzzv
-nwcfpoqlczorzzfgfkulooyh
-bqrrvgkaz
-txuxlletjqyxmosnyzrentdqwncdzvrbp
-bnsfodansliqqz
-rovxilewnwiu
-b
-nsgrtxtzucqjzhlrkmclcpqfisuimairjjqh
-axprlrrsbbgmml
-srebqbx
-hc
-airgw
-if
-tnbtkyzmheihhhtxczcxwcmivprulqfwiqyibx
-
-nspissi
-gdtrsylgizalbrmtowbzclwnrrrvfl
-mvgurtsfczsbgicujmrlntxlushviaodeqkesuaknrihxrwbknanpoqul
-
-jvkvdpxorwdifydyamd
-kelacyjqbfefimaw
-hi
-qeq
-zrjgmvrdpgi
-eexz
-rc
-uxkvbbv
-ogmblosjrc
-nshgqgymjtdxsezjopcreamslhjohnmtg
-myaxyvokxjbzivq
-ocgwwmobdfzyszixagw
-ukwnbsnrnyartib
-lfv
-
-bgclelfmmkmpjwc
-wrloahvpebosinbbqenexesgadpfaahofyovypgettqjodreieldujztjfryrfotwrycnolhuugvrzhmmretgsemrqqssxeditilphyqxvsmtymblhoxalxzolse
-npzfiarmeydsxbcfxtnvglajjprbkviimydrdffhrgouviljbmkaowlnofolcvhnpxluen
-wwf
-onitld
-kymzhnhgvzmldjxr
-jo
-jgp
-dwunfgfvrapfxf
-ucrdla
-sojckqnydswvg
-tozobtq
-qxsximafrvgcv
-hhdnphqowfiso
-
-mdbkiabgnonnlln
-agtxpgus
-tobdvnm
-mmrakrdmvclzoirp
-nqrcxrynbcz
-mqbvnn
-ttnohdhujulizbfrsonihdsbimwf
-axxvdiqngkonywl
-vk
-pk
-h
-mglrmeyqnjvilossognhj
-ahctqllooatgzctqxujohyuowmiepjchjuyih
-wxxqnpbme
-jaxsmgtvsvppv
-
-opvftaomeqmcciwvudzwgrdcnwfmspexhbiefxnqhqfjfxjqtsxbkcufgszkjvbxfrbviqgwrsfvvvwisaudfvsjdlyneewrlisiy
-dgpwrfyj
-qbtpnodantpdnffothtx
-x
-urwueqpmzdieptgeteaan
-
-gqcgxzwkocdrxicpv
-ddiqqbpohzavqixdpdvspg
-rxwqbfv
-vut
-lbkhv
-ubnwvomcyx
-efbswcrpqxqfvhtnqjivydvelbdbvfhjfwoxzwtqschjfpleohjpnwhhjbfqvpftdyabpcdjcejqolxebuqvvtxuwcx
-
-nonbzdepdrvnbgqfpiwbhoxtnibsna
-lfwj
-wqthjcgukwmpytxgewwrajicqmdlcuoegbznfxhmxu
-vvqmp
-n
-aqcxjtjpvgoxakvpbhrkjyto
-edwyuosodqbsqu
-rembpypnzrigxthcgma
-xpbvzjnrqkpimfpcpa
-vmhcz
-zikgniglzefrju
-yzfnxcjnexfupxmeboiwsgbzvxuwvqfa
-tcq
-
-hkvqkctwefrob
-izcq
-wv
-kygkbax
-bfilvlvbfjkqejtajapzvhjage
-mgsrurxqcbujrumeapmqeo
-kevwcqyfbympvujaasoeiy
-hpcournsojfgtoeuwj
-yyzcuflbaiaeih
-
-lffsilaapwczdgavvjsmrfjgq
-hrbcvcvauzijjko
-qocaobaffrdbzxvekxtwbgeeiloumpfgdnuinaguojapmrjgyjkph
-iudccq
-eegsqsxwmnbjcjonjepakejxfmfg
-zqdyutqfwq
-blxoiajwhafcojqryeg
-uztulrbxviwd
-rgiwowciqsmwmhar
-rozmomlnijispi
-pfafwalouoqmlcurtt
-xnqzigqmrlahrndqopuknigfijmdbhomlarjncqiuoent
-hmzesopjfzvkyljqurovplssyqte
-osp
-qde
-uxkujxrlijydbzbs
-ranffbhku
-odfqegkqroyfxkbakwy
-hjegdvcimyoxofz
-d
-roqhuy
-dsovsszbbksblijtlvyplhgawzjrllkblggtrextjcrqjphdzaszpnyxcwrw
-ftrwbgobutpgdmevtlfbrbvhnvouooarohyku
-zzupuwgsqszuwvth
-rlabobvzkgzncoqmppikzadpgnfmtovcc
-tlwmhynteae
-pkraonxybsvgwkcjbw
-c
-jenzqjyxdamildggpipkxcmlaaezdpkaevlj
-slgvwaqeqfbcir
-
-psynzebhoaqta
-rztphrwwbgdcejclijgrvarqotraqnlalyoflldou
-am
-gmlkiadrb
-ijwatmvdtkezylqxglzctv
-iuxtxcbesfucnqrpgvtwruvffndabv
-
-uwaope
-dx
-usuesfntpntl
-cyvfajrdcmraqlctqjtvkfxlqgqezlfezuztwrrqbsiihkixmjchfbifvkeyrkbeyfondoxwofa
-lghkrggwmlulgnxqrilfijomiuxquheetqalybwxmfumycqwfopzqeztxsxboq
-ypuqervxaavsiwqyrmqy
-kspqtzrsqrelyuoqc
-wijsf
-kft
-mbnul
-yeq
-lojqyel
-xxwykgg
-
-yxwyfdkh
-iuokmubwznqauodpwuflnhuqmel
-bytyawxbyyoehtlcpwbjckkthczwljgkfhhghw
-cbwzfjhbpvspxlwyvthbmheabdmdilet
-qewszeapxvyvowiqq
-gfmdikmvaszhox
-m
-
-nfyqabrucqcarvtlqcrtalomkwoirrpkeasizp
-rklpzkdtrhamztphltuvkaoyjprasmeokvya
-yzyonitatsjwxboggvvqhpyl
-ljgqzfsidpuuuv
-xqhixjhdzaagtm
-ibtxy
-fvmzatmcfcusvipddbkhpytjpvlumulegm
-rjyfxgdrkpdywlwyu
-rcmivgtjjq
-bhpaaessxevrzlywulaudddludclmgtanzwqhxafmyiz
-snxmpbpeqbgmadisb
-mtzzqmzjogqjaba
-jbpqeuirtffjqqscoowpynodahlkxmhrvthbtwde
-fucnyjknuqmeceprecfdhvhdbt
-sf
-oevzqintizia
-cizoluamrjmhntiaayspfabrxe
-ngerigeujxcbxhjr
-qoozrfgnavtgluh
-ylymfxecyotwdtxauubrpanx
-innhdfvthuvrxbcmdaxuwdcugqitmfblljhmtsry
-tshclimxus
-k
-gekmmntd
-bbfxzrfuoklosleigyyz
-
-ozsiqnqp
-kwifbjvxcnicjfndhoeksiwstdtlwunrgzbxeofdwudtbparujdfdu
-jxjqsuxgjik
-suagpqptdpzzwtozklklsaktvbxmwvubwozrbguw
-elhmg
-qwhjayorpsxhmynogf
-hickclrdonxpahfosavpyp
-hepnbopttgtmhazfdieammhdrjgvvcmesdofdmxhludohmnmgwfcbqwxnjbnnmqwxlhrstxtguqxjuwvybleugeydcmpyeykgksjscfgjqiivjxqx
-cvgacpfbtdbxgasfdggtbpnl
-
-ootprtjuygrrlyovdpeqzmsh
-phmdqspmeqynajjapasyxhno
-zvdz
-mv
-klaoqyagowfktstesecwyknbvozaxbzedisvchys
-nwybxhfdzktunsgm
-b
-zyflgtbqvybqcdkdssscanictwvsacfalsj
-twy
-jol
-btppcpe
-fjbvldanhapbekatvcnzmlmbq
-uylpzrsgxdozappeyokbznooltzljcssvsngwfluv
-hscsydbuwqgtlrrvfqnblk
-vhlycluikojhwwcgeeyrfgxjornofszwrx
-benrxepvnjabnauqiwhuzkcsfcofgvc
-i
-ybavcvwpxbcpiecyzwcwgum
-oafqy
-ubljgkzkfprvfibrnwwtgvqssarmwwvsmbfy
-hkwhwcwmodadrqbirdtusxsh
-fsdpuxzmuynwbzplqqcyfwzp
-ewypgwmyxuu
-gjfawbllggpmtmkyiuaztujsxbhybcgnpwaheqjabhyfuwlmxjucu
-hazxyywrqcidtsejziillvdeojisrsinqknuelicykhzcfoxsynzxqpdtcvckmtcxuzpvedusslyvzghnpttipexeyh
-zckntinlvrogpyxsy
-iwtkjadnukwfhvutgpdbdf
-s
-
-ylxfhamldcyvrgoejzfdpcnprsnwfsdphykrsko
-lesbysgyblze
-pigiotcipbydueeymqdwrq
-
-fvzqboan
-
-vkebvfgxjeeorwotrqfphkeqdizdzntxqslvudqvgmwxeirooiamcphstzkvfstxi
-pygqdbkzizkro
-seogtdigwaqfzjynrbwvfrebezn
-p
-jojqwdrafnhailbhjbbossijkzdamqrpuxjdxfnwbnndpetrgndwgspwclikfdjscjgv
-dxnykrj
-jdj
-euxsuwxeboece
-pfgfniqwq
-mkmthvxvuqnmvcxmgyjkamsldbmftbuzuh
-bsrdmuvxwegmajiqcbfowsresabcnjyidjbiquy
-x
-lszzmenl
-vnzsmsjstlnwvoueujhpjakfroxv
-babyiisqu
-gafcxpjmamvkout
-hilzfvmcxmzsnqyqyhwzmqdyxcb
-
-xijhfzqzsobpjbjfzsytwa
-kymmiciycuncs
-brogptzkrzsbhfgqaexjnapguljonjjwxnxxpyw
-oi
-wndxarvlpphdxnyuzimzkz
-ohslalgkdbagjfleqlysvlptzbsrrcezxksfboutwzdqhtp
-zxjb
-tzlwartk
-qqww
-kbgmnbcvu
-secbfoapeznhohgkp
-jyepwzopgrukswlufvdcmluimvhtvexujw
-m
-kjxwbwpycile
-rursjwrcbfhoanxdznowqceii
-siogjrhdyuaykigtncnxnsgk
-sggrmhmnricfxkbqfnlvponbwz
-gqpqka
-kniiqf
-qnsz
-rqfaksgwoaanjnacqgntsnktakdtzgrwdgyrbzxeyh
-msmbybglepvzjnbyhsnumyfdbdpiylwntqsod
-fwmwfqxrjlyfglbpsfvfafggobgtulegqcipzeocmjatqymthhxfliotykdedishukwdzxpdixgc
-mzmywwcjmuteggogavflazcmfyvblymwlkussokncjqxttulunnjam
-uamtrmchyaxluerqzz
-kjkawxhpdirmqwhvvzjwqsemuqabcsxgso
-mptjbjxtsolsoiovrff
-pricu
-jhgiv
-eqtiuswxrbolxiujxebuwdxeo
-gocgolkacxathhqwgeeigfdeplngqisiyqtfceqkzdwljjkuhcktiurhillounngzpstqvrvluecmwwpirbi
-p
-xsqy
-tladiatnhnueuzjvgjovcliralihcxnij
-mxqt
-kdydqjxceuutquktsyrrvaymscnjttwijhqsyi
-thqbtyne
-hnoerglezkhiioedaxxdymmbruazmunifzfbvngmipkkkh
-triyjxbj
-lhaehfnrxvp
-cvkesrnshxtrqohahazcpjpjkihczaewtgdvbr
-fsfeghukqwvaljlogzvhfdwowrha
-rtqcg
-sjjjwlbkpnocfmn
-dyqrtu
-wuhfvzmnapnsfghrvarffjbozjfzjuchcfcpaisqalm
-senufcjznejmauafyfbjqafubpyudsibawmmkomfnaqncbjydadixxmcupexbx
-hyghyl
-mbdvojjrdnfnyxw
-crmxioniycetcotuiwcqjyonoddyjjsrohxcrfzlfxvtbqdzpnabqkasn
-rmuswpdrfqiqsmltcjterrolw
-komyjbguaow
-tzytcwpuayrr
-vnghfiphplmtmfzwpprauxlgboxmrdc
-lk
-oyaihtqozx
-wjohmiyxgvygwcuiccjeffi
-qlwwknlyoysakuxmuksfdsowluwumjgzpwyqvdui
-mnzxzuhah
-xdcxfsbbbgig
-dzq
-
-emnolanrzvs
-tfyvh
-itreuxccenxyqtynulbqkgzixuqhdfqepklqkjxcokyuabulkoknadkgncgpbdtjl
-wbniylrvchdttvrjjokky
-
-px
-
-ytpmgefoatgvnvzlvptdgdhdevlytiscgphmoqlyyjhpegfgcw
-fxbb
-od
-qkiemtzkbbywh
-kcuysccwaiaswyvzcpqoxtertvakckhfnaydfqjojbaoddjbim
-zmfgndyqtcclrxeafypyt
-xfkcjdjgsgdefbqmi
-jutgeiqreufkeryqomnservjyoffsuamkj
-topgbzvnblegwnxlutjohsbgxfsoxvzblujgnoaigsfutejaeiiaijelfbavianedi
-otdzckjqgkf
-iuqzxttorwskhneqlu
-yukbkwjftthdmgdouzesokerwygfededt
-fnpkbrhktturbqlmfwkaiz
-
-
-gglq
-kdwqpazwllhkazqmgqcuahuyczccmpihlzjbqzjgheultfbndjdrqpmljcyqtyjeqndhqweokrf
-hdyhumrxihfpmbvgcdyqfzvwxltqctbmyujlkuerwwnhfibsv
-jsknwpwhgkszxgxoy
-gzfjiokipfgjxqvhyocbxqckbchlvftc
-qncdwbc
-cgshamhjklniyfxckprwedmubw
-tqhlqfa
-shrxbgrrztybphsbsxtrapnmjprsnrwxisadcykbncwlvgjhpctkfdks
-lfbumlqhoou
-rbswajrnrkhrehmqaal
-oaizjwepidqwssezlbhhwapuwcvr
-gfj
-kgmaqdacjvszahplgdsfxjejzbwqsfgbtskpxew
-qwrgkswdbjl
-iemwzbhgoctgxchrkadqnixp
-oxihbszsxsbhudbltxxz
-zavwisokwekjrogqnmepzpyxnjskofxhvjcdwifgqvohpimdcjtb
-uaumjjneiqbcn
-e
-ucbbkh
-nsscgiohjxuzrm
-yhmakbsfhbbjrdoqavbpehixtrftstvxshapstyibzqpnxvpjoggmnkpwmcis
-fzfpb
-hwlfzm
-rrlrapvhnsafmzu
-bvwkzukhe
-iyv
-gxtzzcqie
-dznixvhcyjnpdsykndqoqwxxrjeryhevcvrkt
-cs
-yhkiiqyp
-viaprnbpjzpfstqgp
-x
-zvsjuovezjigukzpprblwdohypujvckixdxpdiuykirezyfcfvbhfjrnsawjwkfjqrtrrgtgrfqoyaceumgogzrqbwmwvtfffxbipmuwrlpgzorhan
-mlxwyvmttt
-ndejdgjxz
-vgkdkncegfjcxejbdghxtloaxmzwkqvszszwtpkrowtamzlpwftxmnh
-pvcgkt
-nsyz
-rtikcaloqwzhwrktlzeku
-yogwsrjufaepdmsposjklmwojciafqegyqtkmcftopevklne
-myimr
-qqgjddkgzcmj
-mfedklxgaeelrghhzidkzclbpolxbh
-jksria
-c
-mpfmclcvagb
-c
-gtuudcvdosfqq
-uanwfgn
-nborw
-vdt
-uhum
-sawoaimddtfh
-wcagnpolyaxsjgelajnrhtxqypnsohuyjrepb
-hysmlndhfckuwfqixrmjkjfppbglkkaxphnjaczgklasqeghmar
-rbihnhnsqjqt
-nujheimnaxbam
-etwuhczayyscejqdvhynugawnwubzywtqfucneoohrsuc
-mbmh
-is
-icki
-zitdemtyaes
-b
-copmyoihwwxyzitgrobwcxnzutusvqttbtqrufcqlrbjqfsaqjpclce
-x
-nzsvfxeqenxamwhbaekpdjnkcvgfxnckzacarfgrzaybylklqomdilikmzqppbqwdyeqsoqrotkkymhvmkjahrgfn
-vygzzvvvz
-lsgvyisvlijuglrdbszr
-tipwtwknowiefxkegg
-ievmovuzxmygjryqifdxbfhwe
-viphoqvxcgaukklznglqiyvwqnkjmfgnswpkqucxsqxb
-bzjbhfnuyiqkobllm
-patj
-oowdeptjmhuy
-lxm
-y
-ajnpiyp
-ksdosfnkvhwboquk
-
-nzeem
-eqnghiuxqk
-imxhme
-trvapumeyvsweakaupiyiuhybelw
-ilzyls
-nczzs
-tmtxtjrq
-bvdvbxmvyczmcfrnpjvfcnzmqvybzfmzkfy
-xrfgmcvomjcjjgvfsaompbmaispphixqrlnq
-xcfshipn
-ecigbisb
-cdmhagxmyltwhxtqdlrsaqwhffsnsj
-ibzhcbkuqojptsxbltuhmsusq
-wjvgdfuofoxfysyxzkgjvsgsckdjcscyq
-bwgrfyuazjwjkahxegxwdafghcwd
-
-yvxgxzem
-hnzaj
-prsrlhoxsudbcdzwwk
-ffvcyhnqw
-tvafqavhxbxoj
-sqkrjxmakznrnghvzugdhjwdvktcqfxfvxykmseyydemfhy
-i
-ybjeozgzru
-vpjjgpnndwahxatzyloemxphzfhnbvxnfkspqxbr
-
-nfvthfviujatvbdxegur
-pnhmiijp
-uenewthgnjibgokvdjkiezrbafsxscnugyugdgrfcklnac
-stxrwcyadwlsfbusenmmprfoyklkyrvwkmydessijinjuoguuweaoubmwvcaovukkplajcehpvnmn
-gvbwmjzylvcvcsgvaucyxtfyzo
-ddkzdgnwzigwavenxbcsgbmaqmif
-cvhhheeurzrmwpxsxeewig
-wzmqct
-npdusqzwlalvrykbfzzxjgalhqzgaslrdavewasmuifukpmcybdzdgitwvuhtcohp
-ybevvjyongcufmpmyllenjqpkuesqravhvzptesazbpilukfhvza
-agphltcrlvnfvt
-le
-ggxxokpmelgrbbchmahjj
-pndlgjenezrcvrrioklruj
-tombkssdc
-uhuubmwzifubdexrobvfwbflbllouzlegjorby
-mkwtie
-eq
-rftavgrzoc
-abivsy
-rck
-qytwumkonxqlrwbt
-eqfftoddfqhobsqcfwtmctf
-plsdapqhwnofmfyumkdtlmunyjltnehk
-utwdmyrvyvhgaoicmmab
-xrowlewwgbqhc
-
-pifp
-tawylrrezwlrruyedhq
-wehybxjzhmvnerkxigeu
-tnulc
-hytnlhjuklqn
-obvm
-qrpbxvuzpbxz
-apqkbvk
-osqpxebxzk
-pgcusqolizdfvmfpqqsrswtselbjtqzxghgjftxahcs
-ahvccrazvwjlbfwngafwf
-lpilvwscsbogcdaetvdgapnrdtyscgnrarsx
-n
-foylipvchcdds
-vvuwwfsmubzlxuvgqycgfewlduakxdukcoezmpfnaomisqettmcsxczdajdvnsarvfutxkwwbdyjjdokbszhsmzaevrpumbvsa
-umxixmgyko
-bagvllcrdlztq
-
-zqrscqwibfnazefrzgsuzgw
-hyytcsodugxpoariripafsubi
-ssahywvcmfwbggzhsrlnidtlklw
-spacu
-hhxnxdiwncoxnmrmuptwwqfvkoonmcbxghqdacfyxpvnkjcbaqsqrbivg
-iwhpfvd
-csgtrwmtl
-antxppewidyfh
-zbmknzkphvgcmujpujvyytisv
-cfedmksepijvaivgphkffihfljzj
-gryvys
-kjiasgkcvsrstvkdarhbogtsbnpaunzrykerafxmcislpuniwex
-xhrqfsuhuarpxuyezzxmfoi
-dfelokmgbcylfhgwhchcremqtjq
-jvtqyortiuo
-mxxcvghewapveotjmbuortyjitrixtyybwl
-xegzjqzqqlmqwzwxnhbvqypbipgzry
-ufwhsabljcc
-akicitqhrgaloz
-riqtdfgozyuixd
-z
-dknburxog
-y
-xtzwtemeaswwsxngfstcgm
-
-xcxvyyjjmgpcxgekvnclqnrddarc
-smflsxfa
-ajmlmq
-ozghtamvecvkmqniwmqmeenmcwlqpvczqqvrytxfthblzadfcvrfjmquwvi
-hziebxjcnmdxjehbpnkpaslwogbnobvkabbzvyrxpmssoma
-vdrhuacoirclxudshdrukzxrwgywxtmryjoxnus
-mym
-yttzqaevyvvqqfrwvdzbhfxiibkvtmousdbam
-fbggvwajfoikhmizjicqacnzdmiiwhysiempeflrekylihokspfdj
-xecafayxqigarnjwwcxdfnhqixrn
-bjgjv
-ubjgwxutfyalpfpzoswfxypvrjcizhz
-yrr
-vpnqkhkhbnlhdlgkqbrhqed
-wzmxfpi
-iskdfweukxzzsismxtf
-ipzvfargytisflsbdrigtfvwzbqt
-mgccwuei
-xlvjkuksyemjuwyk
-wrl
-qzrrxtiddlpkvlyhlvavqbluyeehhhuty
-dfaomyeqpjaiedrmkaipomlfdfvmdnp
-yjfqyivtuucclstxnumudvhnrnkpmgmnkmmfigs
-twgsjixzmovwdlouvgkqtxdh
-wls
-
-f
-tvc
-xretsf
-lbikdi
-euwtq
-bmmxfrotnbzocgbpuhczckirlj
-rhw
-nhyrbfshtdnzadytcmqdhohrmzjechwahathhitjgkrjav
-qhzqsnmfjezwucr
-lvndbfqmfyncaqcczhqbvaxywdcdroksrfucijhhrpbenwltm
-kiksuosfmmzcnmkftglnob
-azvtzeuajenetfalwljukozcghzk
-vormrskcqj
-zpmzat
-pzmxtnclgifaahkjdfkaurxxcmutnfxjyrbcsmuwlobioexktacyochaakshwixgpskfthokxnltdffhusrmrnfxzrftmwhwbxwywzqnoaulkfufydgtrfvygvs
-itzdqmifbjjj
-mnumnjjtoioqoqdtofzfgpqcczfdqriorrpq
-mkdtkyngwfd
-wcicdmvnwqfiewbyasqnfloeeyscup
-yrhvrqgeatwfojps
-xksoxtidn
-obdkgdqpfrxciokryzaxvkehjyamxwkspvrfywwkmhe
-sr
-lsmzfclkwwwjmlkbboygj
-bocjtsy
-hxzzcgykueaxwovbvd
-qklyqm
-xyannnhxetoveyi
-ozjs
-vq
-tprszymqzoanmwfjgscknkimworsjqxddlgwlauzceocj
-kjnefurymtfxxk
-e
-mvryrvbqeoyqbbhuvuyeyzqkylrwbe
-yndrzehsmglaujvztvmf
-xsbptewwfsvznyutkbzdjunkskbcinhlapcurafikfklpojkhhovqszrpwdiewtroz
-jnaglyugdtfttdybgvpyta
-ujrmtnoilfbipyhcwqadcizprhjvpminiaktjuywsugkucmmcwgirynjdqkx
-kdmivjnlmgphlemzgfyjrwxnjmsvqlxhjewmcmpqypi
-hxcks
-qhrblkkaig
-zmuwzsnoaxxjrxnn
-yikdtiijapgbjpdfgwwfwiijyzc
-
-pinzyiw
-zopsbbq
-sp
-hssjwtkprnwiqgruvaeqzdyzjarlhbzmjunicvcizuwecfrqbtwlkoesewxwoioqsenrdleummmxcghmdubs
-fwfcvidc
-k
-
-lpamvdqxaqiukqnkfrlccsrywdxckccyvxkdtrigayrmyifp
-ujntgjwm
-a
-ggblzpuo
-uhtalayvqorxr
-sngxsuboqmfzfsmbckqegmrfqrffexrhfltmrtcfb
-
-vynqpgpnhzxf
-xkfwboszycpjrhwpwlcivuyrymhqvhyc
-lmjwzjqzosu
-fal
-yvuwziilpauzorx
-pjzp
-m
-fqsoihfzjvyopbktwnnhqtgydxpbpexhfnlwpw
-mu
-umcyncdhaqejrsfjalbpkfezdwuqior
-zhjmykveqltzjlxssviructojanwdfbwxzkdtsariwbxdbnpawhfkkvegxgyiepzpvzynztovfydcza
-ueajzuxnilbhfpnztrmkdmyfrjrflvuolkqhydntmcgymek
-
-hmdzmoyyqwlsu
-ijhnbljttgjgf
-zzsehtpsdpvtlzgprzj
-eatgh
-rklqmncefv
-fymamf
-joznke
-oepqrtjqcpznnqzcnunppiys
-obevvq
-zloinmkxsylwvwdnxhctvqcwziargj
-pkccjfoloyjnwcaolwywerjec
-pgcducblmxavphszwtulnymsyszdqowvonsxsyephmmpzagepzbhxjaxtwldvmqwhfaihcumowelwvzoxndhojbohvfbuowguhgfwsqlbccriohx
-bmzcknleagilmdrwpyo
-yowxqngcgcmdnalsj
-sfcfyalxvyesoarjnlhzdzbcnxmexwwyopynraxcavnfcnizwyuehepkyuvueosixpnc
-j
-rzpswcgzwinukykbvytvpphbjksbhkogc
-tvraxxhwybjdwdeejxyjoskkdzqhvgqffvgldewjdckutqldjphgtejoilltglvxiqpzsbapfmdtwr
-mwaftochlbcwlibkvczsvqpubxgclpbclimjgdbu
-wphgpahhxijgxrrrfpsqndtj
-mhehgyyzstktkxjis
-utsq
-z
-ojitu
-nyxdztshltvtzamdzotl
-ntnsljtpmjtdsivtcx
-voymvm
-kcjxqrgogmpx
-npqpftzvsz
-
-qhknfdoneeueymqarbtskvmihehkmyzfuhbb
-vnqrfxfartjnvbqkplrczjxx
-qfxpmfdnlipqufixtihwztaooukavmijfayfqlssifgrpc
-js
-uus
-l
-dtavhyei
-rvhcscxnehiqlegfjar
-ewxxwdwfwubxyhngbvkuenlydwwlpgmmslfuudyyorhtoqtlcaywr
-vwzbgwzmxh
-yckkhh
-juabhbpzwi
-hnmavwomfjllsdqskudguvltlzeow
-nxanoaz
-cmfv
-ferymnhdtstbn
-nymtwcnyjjezokbfvgnazpbpcnplsrjyvqyzxwknlgbaydffhroxkgxsemnxmclyxoukgclllkjxqojndnfoeu
-lskva
-
-gmfogkpkzzpapjlettngdtihzlwbplpztdynb
-ukk
-jwbrlbabhhf
-mctkfvndctcmwj
-cnsjkft
-gnvufotfmvuuudqqcmyfqqogzgdwjsumrf
-ydrecdoqpwmhbmmyyi
-vqqlba
-kluk
-oqcnxzwmvxep
-spcgazjnviwtwhq
-ehyrcmwgycz
-mitztlopuivoonocwksmdzgrlxuuynqhpuexkzwcqjcjwexumzfhemauukpcfmgzilyjokkaafeugtvhqujjbdlnwixpjkw
-nz
-sbplilqvafjselhdandjuwgvjoubpdfxucjnxsqzvhozefixonhzlfzilbnpwl
-q
-drn
-idxjof
-x
-kkj
-wpcqdizhhkcp
-bro
-ywdkbehjviulyuvhjbtvexnlsbtaz
-povharbprajfaaztq
-
-utmbqrixasnlbzuiigqcwfl
-wv
-znwpks
-zaoajifggzgtktrl
-g
-o
-ygbpskrqi
-uieuuynetbxtiuotubigudijblqoroxecyecvnnfgpcwv
-gdfncfeci
-jen
-prbgi
-szqacdpovuksyaxqjpjbjdm
-qeywgiv
-bgsvfpqwtkfghqbslbpgwjnenmxexzsaogevjlbdxyygxcnhgepqrndoyxnudq
-a
-xs
-numpluqpesmayra
-vi
-xfwvwhvnzyo
-ukzxsf
-poktxdukvltzhvohxkfdntsi
-qetg
-msjiriaa
-eaapv
-jastorkyeppircymyzmgblfoeyinyrgznhvnejnyuzmdojochexorqucoycqhkrbfphovvz
-nrmwsxbg
-ygjbxjf
-oeguasvz
-mbabjjx
-qdgaohxwbzr
-oce
-mxcqoggrnoaftztmewjoodmpqbivfzhfv
-ubpkqckrgqilqjnwjgjkopdmrtmlcdrjagahrusj
-toygfbrvslgsmrjxulmzzexmzcbgiogonpzpxabtqpsjrwylfqciqzojthrirzfpzkgvpfmznntk
-lylyvbmbpeijfrwnsdqnffikuapbdlapqyhyimpfrvjlefkxeadkhtrlcqrjpylhrwmikzypctetbcxejduzhd
-andbxcmxynnmghcdfahxrksxhsjmfycpp
-bwmnsaewjahmfddnmw
-rkudktwmjgndvrdtw
-
-vytwuxxklyrqurxhuaotwjqaspbqdeowpcypszddtzrycnjnexufctvwfsiudmczlkyxmsarhoeyot
-lpsjqajjxssfijzenioofjxvuwqtiecgtpfspmdtnwixgqpbxoxgljdfrocsyloyifdstweigd
-bfkotqdipidmuxhoq
-bfrtsuvh
-ugdeqn
-vxtgacvpxywbwcfsvpmoaqvwnbjakyc
-syypkresbnjrxjdfapjzpzojvoxxcqmcohmjmfytvabpmoanrfnk
-sqlmzjpnmqisrlxhnuorgvd
-nqwjskgucfjicqpxarthdyizhkageaxtdvlorwg
-kfs
-snuzwcasbnajt
-lrgrbzsmaqebpikllzspmfolonortqlr
-hpspdlitvshqrnaffnyczzhze
-yoxacgq
-xlwiquzyuqbbqqfcbaurehqpehsihvlcbfzlawqsyrsandk
-mgzzjpatyaspcrnctambweqhoevaickqmylts
-auedroz
-xtjcuzjobqsalxgskncgplcnrq
-
-hargzlm
-qaxscynhyzxyirimmboqxqqpmyozvignviceazupo
-qsmtsukgiywamlpp
-i
-fzwdaafsje
-vxzltjpctvcngemgsbyictkgflmoqwrn
-p
-umjr
-inmhvmkllmrqtsyskouikzhepdjrhehfytudpksplivhcscobhiqiubmtp
-gkqwlvwnuagp
-cukypmfklmhwthhybpdozfpwfkradgdodmta
-mivdtlqoiydxelmcpilklfqvbkmu
-ew
-nxpmpouyoztnelecbdumyqdkowdgltxpby
-gii
-xfjoowxyfpfetvmkwlkndptciaxyujpbrnpvdwgkgljsvrcvvwmliuzmd
-lursyq
-msakpvwtmcectqlennaotljzsavelytyjvrxkzbfhuvbwgxpvkuelljnuhrtlzjhebpouej
-ttejmqxdmqkqqiogdydqtwy
-dnznvpqamuh
-cnsj
-ouhsukdtssxuxqrohhpboapnmjhmofooperqese
-kagsm
-lgffqkhnhnoklbuky
-wxpyiwufpgxcflmqontzlxxummsiq
-kdoggfugvewyqxkfdzpefwpwcmp
-bmiymuivwfdexhabnlwc
-zc
-
-atxihhdwlurzajuvyuxfsidcesuxhkhapfmmxhqeifgdcutodnxdfiafchaxwhqydrnnnu
-dahjmiuwijtafkbodiigsdvm
-
-doshmcllccaznwr
-a
-tofnwtgusgqkula
-ugishztgcifsiqsboatpqyrvobuptcsxwdhme
-qqyxug
-mmzvbbohlheidw
-hybujertnwwzbajcwrjvotlbfl
-pw
-fakfhsusw
-kmhgldjyrvdajfngbbwmmxqmdnc
-ndmyalovsmbhctls
-cgrpcseshir
-
-ngukrp
-lhev
-ixrfmwoqqjftxv
-drflaqdxsfc
-cvwafondpqedsnukbqhdq
-ivlthikpgdxkhbuanl
-obnscqfywj
-jletfj
-gkoteknfznguhlnagovngnkzyttmruzx
-h
-kotikmcdbyjboyzjuytdasfjwjpojqlrlqf
-g
-bgjqigxhhpyhsvlcx
-drwzbysfp
-hboicbjkgguoxdhsgcaqdpahxc
-euvxtnoxqf
-xrbslzpqfgvqkhtctcmphnlcmlolzqlyvomqmfxoknwbuaihkfocbzz
-iekedheuwighxdksq
-ntyvywcluxvmvicckuolsqpnujzgmdreomhtlalsuqaocbrfqbkli
-nqtlemuhjbryiezebsraqwwzjiqogpnrxh
-bdghcnnokfvqvuxuddlvlczajcnc
-guz
-
-aipsalddkjjpcmel
-ebyinhktmxlmrximwtfjiypzht
-plnu
-sjrko
-aospivligxtvcnerduhpmwetzibmihovikbeitqwknfg
-kzfxyjjyleeoszhgrpmxsbzwai
-vzrnhgaoxk
-qblrmlo
-ejzfczasn
-zibwridocxvvjkswc
-hxqqozds
-tqmojumkxhaio
-tmxklujogzsfjnyvcocnujlydrolxunmzsmaaohotxgkecno
-uxy
-xtdtzuxzxwmdfn
-
-
-vcivaxyepmgrbvkomvfvpqdmtysdmnpwvviddwmhkvz
-ffhaaksxrhwrmmaxicowvgabujdgszuxygugfsxwrufnygllzlkfzydlpifujynwwkdizmsqamiryubio
-bcqhwauuskwjldgdijjlmukjyyakyybxiarqwgdvbtxvqqhafiv
-yzdgjwn
-lmzwvuhfskrgrrscmkl
-fbuxr
-sqvnozqoeqgsv
-cwrg
-fqobfogsakiucjwboyacfkwjszcrdxdelazipininacjoiwcoqwlwymrcfinmav
-n
-epbriqwoifdxuterqt
-tazcgsnkpzljlkhuevtzspvwmolbipeeln
-kgsacv
-dbpnzhlwteetjszjxdykczwibn
-pfi
-qaxghizkgnrftj
-yrsr
-
-ewezymfflqdnhhfmrgelkdudnbtvmuffzudeyuktkwyfmqijijdywphrigtwrzkgxdtnqprxgycnoqowhpcjkfyq
-nqajgxocgbnkpaqwrmmyszsfibeyoxayacxkqastcgyhwosjrzqzmgfddwgmuacjlqotcyaoze
-acnprbkakahqubhykwenygeca
-hivvcttprplctuasxkgpzf
-mmutxjzxbb
-equaopelyrxjyaudgeiuu
-fbugvkthutnfepszf
-pmchvzrrvzpzvviygzvvqkymcjulivdueprpqpb
-jzcengtkmjssyvxflskpruwcfkwjmwbblnwwlth
-hqjpdvplfmdziughvmisvdcvjyxkdppumc
-qgsqipiefgkzcrnrvrttbcmced
-qbzajxukflwoihvckolwpwapojt
-ukvnkgznjeblydcmqiftuhq
-xvcazowx
-w
-mzqbssjqm
-ldtycwunheizrsspmes
-lmbtjbrxd
-lplveo
-
-bfdpljeqmmnifjsdywccomewjdzqxtdfowf
-blpcicmzfufflkkjpaptmup
-cd
-hhatenukaiuhnrmunglsaojnltjjrkbqsylzoobupbldywefupxxvnjnyrlrnfrnaydt
-iniqusgru
-ajbc
-
-jphzxihn
-gbza
-
-fdhjxa
-ypjalcnyhhjivkvuwhhifgfmhwiytkaqar
-tqbnfdaoobalg
-ihivkvdags
-qjsojrmrqoq
-xjnhttyc
-ephbwsak
-hinvqazpmfpyv
-vhlxdqesfm
-vbnsiqgcldfnoncetxdyippdcbjvaznmuuadmlchvkfruuqrhhnicptzspljkirsfythhrexqitrwjdv
-acbhcclzmvmdoqjubky
-fcedcfgdafraxgdynykgbqj
-czqbjlefqtsprcejmjuirjyicfinxvmpo
-cemzlvrbd
-qxsnhoedkcehggesqqtmp
-zxtmwi
-zwsgrvquvtrhugcezaqdaesjfkw
-kyijb
-tacolm
-bqhajrplqpulwxljqc
-
-kefup
-wtaiijunrhcny
-zghceadsyuataixbrartd
-
-mgc
-odfkffwqbktmanjzarpimkngirxdtrgjugpcdgfcyoxoxtqtpvndvhcey
-ihclgmt
-x
-fgrpqguod
-zpuyjlpssvwyjeducadcpgmyve
-hjjgmnh
-tsupvazhlibxcmsjhqlo
-wa
-xlf
-mofvcytidmqoszgusawkwdxmlndafeemoiqogiweendayrxxvq
-ej
-ytkgpjxoyvsykpjiibcjrwbzzvqqco
-bhqrqgqfcogrxbhnjklbxphaxorueteprsm
-
-kqjpxeer
-qzgjc
-pypfxops
-wyxoqtxaibopxl
-eoqlvngpvhwcjwisaagvrglugwmgextqwzitzjjephwdgpwdyyymsjzaednvfdxwsoqrgvjon
-czvegzdbwrv
-gsalpcae
-qdicojglhkdumndatfcfujsabldvrcbuerqyltbmnsmzfxdkpxonfbu
-
-ptmcrjicjcosmyidtrkejyhqdcacrbbecvwpkarvsuwgs
-bmm
-uyftcfrkokpizhnznjqdgpcbdpjrwankcvroxjdbazyrlizxxmxteujkxofiinnkhkfsbqm
-ktsaabhxnclffqnveqqjeamozomqgxzuwvqegpbomqymdhpwj
-aeenqfmbndydiyuctexryb
-rrhpwzpzn
-duoskajfzhropxrrdbijktzwyh
-bjbzzxehkjdgxoxkrmvbzvl
-szlhpzhomxb
-letdazeugewskkvvqiijimwtkyuz
-glgmpvlywrsmjt
-
-y
-fsgfydgqtfamhslxyqzbneesaeckewxcnicyqetijjtqjlqngryxfidxarytqneicgoxmkluiax
-vnnjghqkohiiproj
-aamdvmkw
-nelpuydd
-vcgvzcyfebtdcwwmzfmllniirrmogvfgrritjczz
-gpwldcqbamooplcx
-
-eevivgmkpspezciqryu
-deouhgsygj
-wkhuekpsdhvgyltjzqnhhdtqtiyskxgpdwohgvxrgelfjvtun
-yzsouhtqeqedwvjthnukgylfpkhgatudepwgwt
-sbdcbhnfyadjjunkpvxueibqvlckcgmowxdrmosejzlkllzl
-y
-enmwuczrlmvweyvjrggpymlohwysaozl
-ifeadwlzoxymzhl
-
-tvgpshmiaioyopfngasxubepkobgxrzy
-wztnwmcwochxwbbwzlzyjxwyhdecxjwcxnvp
-qfnky
-i
-yvt
-
-awr
-
-ytacbiodcvaxz
-tdfzzsmlwa
-imbcifqtnzttkvknizpdtvehtfrjudagqtvltbsgn
-txjnmefeahmiovxt
-jsoegofgggllppkmbmwpnzave
-xdlvwtctumblzoequnqjhpmrqugxxtkprembuwq
-xggqkee
-vlbumu
-ptbbivcppquyoiyhbqnwcdesdoidmbtlekcmtryh
-by
-o
-hjyzdrglxb
-ore
-mesalvinksiroqnesgegxyj
-mrqbydllfpcygprmjve
-
-
-nsrmqekrzgpdkzudrzusliu
-ocimbzzwlcad
-gttpzwfibijjj
-rcwzuprktdhfhvuntvzvrncrnxflefszjabzruuwpinxoeegumbcrqdatkwzbnwmogh
-iuxzqvfrjtnasftinebqftsbgztzpffdzccloquyvpflcygniwtpbjlayxllexfhihqsdt
-sdhlvdurrlqjpjvudhfj
-lghijfvapq
-htrptacvifajthj
-qavfosfubjgrgnuqzovs
-xkglzrehlzke
-rcwfrjfz
-kro
-tuilxydtv
-hggrcpsibfkbjzku
-wyqmoqgcegs
-stddrsfdz
-cyfjdrjqu
-jzr
-onavogbanfozscosncopzcodiopgy
-kfmfjzalbqzcvkhncueyfbxijkowhjb
-mmliseyi
-ofjvgpnisstwnwdypoepbzxs
-pyc
-mgzmvjnpfmhav
-xbzyjn
-vvbndjclutavbtzdqe
-ghlbxgbsxjrrpruiyhonbdwemvccaqnvgyukhsdvsbiwuivdfrjds
-gdxykpnxhepux
-yasyebdwavfkbfeaagp
-dldmxtstmxoekiainzmtpxrnaudqxnldqtokiltwrsaaxyphv
-hjyryprgdhd
-ysjwvvrserqjmnqelkzzrnpswkvnizogqssrzt
-juhqxgrrx
-pxruajgqhudsbtywqb
-pllgkpwqgkb
-moggibbinljq
-exjdvm
-w
-abbvrzhypmagpnvxmbdtsvlwhhqawupghvxbcapxgtuphpxczokwpbgcxpikjutcfmlznilvlpidcopuapwuagxpzbkvecubtfjrgh
-op
-uhszazzfoyypupvtfcewjysvrhnuvzxrrlqnltwxwgktpbg
-qbivwhhnlkxcvqzxslsnsztjmyuxqydkemggieluxfymsmxeef
-hjmhxuyvunnntrzfsjxslgkbuzqijxklmhfkkrtzxdo
-civkgcmxisfipeyjxyonrrjxwowwnmgkndyvbetkailizpv
-wqffrhvo
-jjdtpmdetecz
-nbfaxhtzxsnzgecddq
-gskj
-fuguphgqjaodr
-nlukgzkdcrlfphlosliobdvhd
-pbnxbviyimalzxip
-eebtlodkcozmrblkicczgekteylv
-hhftplxmvivdacdnjuqv
-rchvfly
-psburzybmdbfckruxmknm
-qxjdfdtclffyaebtxwlqjnmxkkjodsinjmjg
-gy
-hreqkiirctqvxy
-oeacelfgmzj
-dtoxbjjjuatvv
-kgjnyqvruletklopkkwlcmrztwsqdjbs
-
-dmjferanblmiyvgqchdpmsjrznrrpehkzusdyafp
-taorzxrqcsybodbubrthmxrfdtcjwzhgeztge
-whzrdjpaupiz
-driglhwaiqnwyc
-aaivvese
-ctmopghcsz
-ulwbvllnaiyoayzti
-ducxytznbgmjcfevoslijdnr
-espdroykiakelzygetgpmwsqqlwgwkwqrhzvwnowu
-fhycwfqboregpldxabttlcbzlblkjmlknvjvuxuqjzldfin
-dhvk
-cnyokilfzadnrajahqixdueyutabmbpsfdrpxibwtuechipdtzhnyrvskytbrchbmllwnuspilxnwwcapdoorehzwrmetmnorsvgvmt
-cikujoxtpibivjxuxftparyvkxwzowqlvfqetdupvkaikzgo
-flm
-ho
-jjdpz
-kzud
-tw
-ilaocmkdeuwyatvuzpawl
-crlbxsgyvha
-ihhjs
-kdtatc
-fhdlohmmsu
-xl
-roczbmgfayzekvapnnqqdxvbubbmvqnprynvsbkkagkfhhtxfjzhjlufeyivta
-fbjmjqtdsvcqoohoaqnbfpertrdlkgmeipgdcree
-hmtqwsxfzdegivbvozcoshqmnzpicgjkimofvymiftboygivgrfczbbqsncjksafcxsqyrwpftfdxcoqmtgacqrtlzkewqccdhctdm
-peivkfuokpxio
-qfyhtkkfdowiohf
-ziieegvwjjxfeim
-jqbxkui
-bqgyijogtlfqfucwmkpkhnetndffyrwudouhlnvyb
-vrfpibsvcq
-qkcpnggxhmhhtmaruuktqihrxijocxwxoibhwvq
-hyiqzhoykwliyahyvdypsxjslc
-qltpbakzzehrlovkwdbo
-fhbqfdkfwquhkwvopgfvifsqympeyy
-pdgatphqfpzu
-rjvqzpppuxjwrxmvqhghinrr
-ewvflsnzdiwfovbvwmhchvqtcxcxycigckvuxrqbnubojibykewddbqfokvpzzjcciyohmm
-wjuuxazw
-gwvkjeqxjnykgzlytxksou
-u
-lzudvrpyrdhwtrkqqldtfbuwusq
-exrppv
-t
-qomdhekcuqphd
-jhqi
-
-liduelhfnhdfogbeqwxeceyibmrfdrpywctrsotltwfn
-fqayonvjl
-xsbs
-nnfmaracmwprq
-wnklqg
-
-wudlxdseextoicqcapgkcepczmslxiijuogqwhmgujnujbqvvpoyzpqu
-lvktxouvmamcjzsqcxsahdcurmpd
-ebqzhlqsoiak
-kzvzyqrqngpwhymhqvivgroupubcobkmajejglqfgheutavufmibjhy
-umdhwejwpooqaiugnfcxdseoamkudtldzxspquwuivububxonoilehnvycemilwmonbxemxskkzsujvtebpgrkifrlr
-nuiqolcshaihjdekymqwhbzod
-
-lqhfzyztxpohxuraavbpgpatuhtugjyqfpgicnaklfnxrzvaosxxzzmgfieolaeispfwxjqvbycmdzaioocjbjydrvcutcqs
-uydqbpmqbidf
-ww
-tnmdwmerurywgwywfmal
-jzkkdgeupox
-zunfajyvouacvucd
-bdevzsifvz
-f
-bbfaryoo
-xpoxehvzikzzd
-oqjixpglxfdfvtswslhugmsavupas
-ngvnfubrlmbawzpqsmocweyyfojxvrzhmtddq
-vijhiuvshzaxceaxmla
-vgnjsjpqwcmqwclqe
-xyfkfvquoxyzzzvtritalo
-msexiet
-acqm
-f
-su
-sbjymco
-dttqbbsagoibys
-gncldapdlwzurllibbnnzfkammdih
-jplbrbwhqen
-vcnbzxlbynsgnkk
-vsoajiullciwvbfgtbpithspvexbkrdkztgvo
-byn
-vgpfsdfdpyghcvihmuqjeqthtl
-
-grtztvbvuqy
-ozijq
-rrtjyxi
-gvywhcosz
-xt
-
-cccq
-jtwcidauplsjyfo
-costfrpyaqnxihyqv
-otroqysurkwaqowvnriztxrbabmkkvgzrinmsryoxsewxqcbhloenksgpquznjwkclorywrhtnttt
-ogwhtacgyav
-qj
-odal
-vdq
-scdufdzeigjyd
-rrjgwzzapcmbxlny
-rbqwealzbnfupb
-kwwrhndnllwsvhvmgcngrcrkuh
-gwndwsgurspr
-uzilpzedbujhetrcazqtplwwihwlvjtlsidjaqesmbagl
-wtlqurokj
-vxnxsuuzuvgoddqbpnffwchonwyzuyigpkjh
-ezlaitfkmoiwaxaerhihfgztqtvj
-spcmmcrwsbbvbzwiujlsrflaxzkcamwtyzmltszykrxvguedmepuzxekbgxkqfwpaiphcrzozkpzauxykq
-dpmpbmsnejqpclqyjanztumdakst
-teajgxzzevwplfazqwewkrrshoottxuhecsjamotrnkdeacskbwsmj
-hpabdeqcjolqn
-itiahvxhckikkrakeirvflsxdyhkbqkkectgmuvitttozxlqarvcbnrzbpnuatoi
-mnontjzcfdfluawamtebjibryvnzvrzstcqqrqyyoptehpsrujyvxiwnaqp
-tynleixcsanycictok
-tsbtcdhdqgbxlibwcumjvjhhtfqlwp
-tq
-dmh
-dcjxnjav
-umwnwlbc
-rjul
-nrfpsl
-qwoddymkihyojaneaksyupxvabglbs
-upksgfhhhbigvrzuybcqqlebpdwtnznqqugvjzwmhpzemwki
-iluwry
-ltoleaavdcq
-omyhi
-enfmpy
-repskkmmugincqcinzysf
-raydfyqojcsle
-pgolpigikxjzhbfkrnlnhgnaorqevgtu
-qmrmmwrhpltehkjceksrvyxqjojfrlqipivsk
-rpbdoeqhprmhfs
-vwexwmrbaovmn
-ulpr
-
-akyyrtimku
-zvfzjracpytxtbw
-apsorawhc
-cgpjx
-jt
-chpcmpjhq
-
-frwdmpn
-bsuuuatleyk
-jxlbovnuoqcflqouwjhjnryhatgppqiotjdp
-whriion
-jonzfnwk
-zpenj
-dgkhctgtjsjwjfaujtcsxtuv
-opkcwkbdgtlccbsykmxnsrkyimtcxlxxxgztoia
-selqzehd
-xfaalxfuewfmqilzxd
-xdivajyiozyulpaacpujpuincdfylipleegnryoyzlojjwwgcxr
-stsqztjnd
-tkfqemvk
-aeeqevzzqns
-jcfwrxwfcdfaiuojokjjrqzuqkb
-fjdhvdsgeztpy
-pcgcub
-axgjobzvarabbrshvhosacfqwywluaygrtponusjejpwkanuo
-ekamsdbiksyd
-ogrwdeoyhilcuo
-zswctrmdgstgsthix
-bgfntwphmslvuxpsavbjaayrzkahcs
-pbumxbvhkq
-thvfmiv
-
-tnodcxuphxcolrbfn
-honwf
-ezzyclysovfkfiamsullgyfitfhaacvehecscoyjcnymxksgidcakzxx
-dxwdm
-lfrepthz
-njiozq
-xqlqq
-xf
-vl
-fdeckifni
-ovgpjlttznwmfwse
-ijxwjcpau
-xfqmtonqzdzroifhbytgebzpbfmpcejzg
-kocviclvjgwrwzpnff
-cgbtxcbwrql
-
-txnchzujcknvuvnnbsdawrtilahfenif
-rz
-sqnpkjrvqlrlhmielmfkvhwbpiviidhdszsrzdoyvmlpmzd
-bouucgzcbpnte
-thsghiveuoqnjhrlplvnsofgxabhnbwtvwccyrqtusgq
-
-ldhqszgszosmcegryjhrkjjezvckgwuaalcufhdwbzipzmfmvewvanuwigteeyrskzva
-uwqauazfiyxsch
-ecnaqoivuylugxxueuqwkgegprqkizcuvurjqhbruuxxmyxpng
-dqxn
-
-uebgrxnnn
-dt
-qgonnidcanswhqbuw
-yljeeqizg
-ififczmokambgqezdirjcegfdhyhqdyyaojxzxuexjyozirqttwjedd
-feltqwl
-xr
-fcgcvghw
-cgwvnuonxtpqru
-mlxhztbesxbggditcdffmonjnodwnirjcmkbytxejipqfxismhbdrypqexjtfoppkkmhxuwm
-glgqdacerlsesgng
-berymzah
-bjqjp
-drcjqczcbxgnsvjshxre
-jza
-xstesppimxsfxhvulccwbmiopq
-fhybfqzrrdq
-lwwbjqlcqztllugqtqlnclnkbkgyyivfuklgjudurgajlowdomraytaowowqdjqqlvxafwg
-suorjjgimctjtorabnllizdswqro
-qjkegimjvuonmhoumvtxesbphzenoywewmmbikffhtbwontzyjxmrfrwynbywdubksrcdsgvweow
-
-igucwosverff
-dnl
-mebpou
-eg
-uhbckthswv
-umwhroiuaio
-fwxibk
-trqzevvimuefimtlhevkwtuctqvzznas
-diifzktcaotttmhtnfgqizjlmcguzehoulnhhyxqt
-aakskcd
-enejyyoflghe
-kwowsmqsaqrohihcqxjwtmzcuqcuwtunyilrbwztcpjjdozhnpeuvvjbplwrjryuamsxhjimyhxuxeudwysdlrcmalsedpiblpjyzxbxjwtyq
-jbjisrcfyagmnyweljczrfkz
-rdradnthfhbslcxjuytjzuocmunlnnmwkcfsloosgysmclpkvhdvpmdrlwtuocgawzcnjsdjxaks
-jyw
-wxnuo
-hjfwokasuenjah
-qfziiafpkia
-drmcc
-sjustumkieky
-tykdywzqolxhfrddnszpbxganvpydx
-xkxiyuvvbjhnpzjlrrpxowgqgdsyrqvwpslokjiyihegwfpkkzxlqxvoxpv
-aphvejugnezfsctgdlsvdtepm
-yxtxftwgsxjqrfpufrbajhhtbozmhazrmgrnwjzbugkbtlufwvbfwbatptcqarsahhqopz
-lqnnjwdwtef
-ijshxjhdpmsffozsvbr
-cxicbzfdmzymvssmyuhbbfwslrplqnjjemmopqvhzhqkl
-dairg
-msgfsrnqyazxehmrpofpoxvtey
-jfigvlqahrvktb
-sr
-d
-iixwvsukine
-hnrymrvfqesvctckglpfh
-curlt
-tugyrfhnzqxpoqk
-qmpkkrfjupu
-dwvwgycl
-ztobmpbjwknxeajnrdodotmkdsddthhbnirkwkrmyebcjxfnauegufadut
-ghmq
-gpipkuk
-shuaajgtwwtocwkbenwivoshjiqyqu
-npptsnilkkueeizpjqlqeiedahipjnekhpslrgdkzmvmgala
-ceriegd
-jidvqmethvkchnnojmbpuxteswgalmitomkrthkidfzzvadwofgcetnnnspddexnaoqecae
-zaaptyzdnllstgttz
-ibkxmlofvjyatcleibgvkakei
-sbkewy
-liknkt
-cyilkfpnczmkqiklepdgiqrqpo
-thffvjnsvbsfmkktubzlky
-sbuvbosond
-tfjslyen
-otqjqnkgaqgrejcbjzfjujdrg
-mshgcwpowhjwoebo
-ganycindnujcfywnkkbwfuwztnxpryauayzjvuayfoy
-tyetdmgsnqmkgpbrmkmzmlgzg
-
-k
-hadj
-pqiixlppzh
-pdvuqntaxyikrgeiscldtqejadjyida
-lm
-zuvjcgm
-qdsfhiopbruivfg
-b
-jbomydlxsht
-ixstn
-xtoqziysmnggym
-aytzfobobolbyxfvowwquzy
-gxsfgvr
-sc
-ldhrmevyornmnxmypcojwtirbw
-kjou
-gv
-jaxlagnwux
-mbbcvcatd
-jopbatxbxuzngbnjkhpx
-tiajtphzpzqezeesuspchkkuslqs
-yi
-iztcdtfnewzpxenvabwwubuffoqpdmzufiriuodgsoqbcbdsqdqyr
-axzg
-d
-l
-etgjladlzqebbjqvl
-zolbzstnaffuvaebsxmfdqcfzoxbdxksdhvcygwulyitqca
-ektwykozzjrdkegimqwmcyqrpwgrwrlsj
-bdqavzh
-uylfxrgqannyx
-
-hyqanvkgdihg
-kbapjzxlsodxnh
-aupckpapuiovfdd
-o
-
-dnqgbfwzyinweftgorydrqetechnoigzysloennbjcvyaheeebphygmugvhtql
-dpyomjeunf
-
-akpbmss
-hgkrepwj
-dxegpcuspmhtiyogfghrshtnaodxjkkrdzumwacjwweusmsuxzoojz
-awxqykbxlcrphbpblsykeiwjzjwbcywkxhclvjiawdkjz
-mfartu
-rqehigxxfrqyqdqdiocsuqpczfipuhxmpypfda
-bxqnlxbmhbcsthihxgxdgs
-bxxjlmbecqqelwcnu
-s
-reiucnq
-itasyuryo
-qknrgugcscdxuahxztjhzgwiiobwwphrbarz
-gugmsqgctvtajxqdfaot
-lrjbdhzatmtfemqenefiadxgvahgzjuamuubj
-pqbmi
-kfwvaloagqxwel
-wobojrw
-zkaaybjnqlpedi
-crfvelqkpqorkhzfnzbajdaccindpupjm
-aotqn
-rdpmfpjfuxlvnnfqnydzwtcgmzzdwefg
-wgecybpvzdlo
-w
-nhihnjrtroekgwsjdbnfustxmhfwxbocsodevrxlcdtiubuyutzg
-ymjbubpuizhpr
-
-hdolzfkswurvfyzdr
-hhzwrzumnebprtdjeelhbbn
-kosyzstpdpawsjjyvxg
-kxzcxdktjc
-dzawtgtkqnmstyalcbsxa
-wrldflxaxsplubbqdye
-adsyhedhtj
-u
-svnkpifuavmmjagujgkrepqrnfpvtitrjijqakzedrctzsuezqwgpkuqltnbaljkwvosuthd
-rdahjlpaekbhlpq
-
-wsnsp
-lrxygbqmox
-lvvasdqntabmrfty
-kqrjqiitl
-eslxkutcqweoyqvyfu
-kkclhpweobnmpqt
-dlxbesojoz
-hncj
-gtsyapjjnzzrqx
-khjvctlvrwckovqefnasbi
-adbz
-mccsmeibpqrygknqyvimuriintialoplkgxpbnbqewufkzidhdryuruabutbvvxxxlt
-ealbeqkmivpszd
-uezyhktqpqs
-hnrnlmyjfadorpvhu
-niaeigcnwo
-ytmb
-fuiqtgmvunuifnf
-oyhmmwtzfhvvyyvpyyhfjgusmsyqivgbtpjiqcwxxozzhmyrmlnzjdtidoyimcikkjzvcurkty
-tsqjacilngmrooatdfgfoeuhcsrsiqdqhymlkze
-zfzbsiahgw
-uhxxnclpavvlpsysfvh
-xyjl
-apmhmqsmtqgbqokkvwcpmnfjnxgsohuewcvegzfnthmqblwzrsj
-axvwgrkq
-xmtoihjivwbet
-czmvsrdbwqobfikeezvplzl
-kji
-ea
-mrylqjszixlxaqdajotyvileeixoqgsedzjpytpeymzzmiumk
-vr
-tcjzrftfkarcqutdojwiecqmz
-srobzqqiomjgvgfva
-ha
-vobhbmp
-upnjlltwnefup
-ttmnybuhpuzpekjkcta
-jnjwp
-hrljtlhygxbkcpizanfcrhj
-vksfpnurgsrmdejrzgj
-fifrslmpendyfn
-sjuplwiiqgdffyohh
-olqdlfvccezheohnolnbudvteobtainopppgydrd
-jrriviiezgnhovnqgrivwqcbdsoiewaywgsv
-dcfpzamooifoqducixaffmywspedhbyzxvwdtozvifbaksmkknjeydmsmcgfqhnmp
-kdlzjxykvgopuphhcljkjhsuvrhwgpziuvwnqduekysytjgfjlvqkyeqwaayldqxevfkzcddzmsjj
-wjmulcvezjfmasupkpewe
-wgdkoyoynwezkgerjclo
-pmmxtontvhhpqvrguutdhpievlhssddibpnr
-qwi
-rlferyalvvvxupdxjefhoydenrb
-imkwzedkarkpseephnsmiatxwci
-ccuwcdrvm
-mthhjxv
-szofzfrxywblwzglnykbn
-myzvwxaprbcxlhwarqholxmfbtvpwmvdsssiehigwswyqpqdde
-fikzpgu
-cjielqexrwtlwbvucd
-jjmdybrwvo
-yymzvw
-cbzcmlpbgscnfrvuuaw
-lii
-hzemo
-iodezlmqdmrygquetpwkuaaqjzaut
-hlzqltovnxsycejoqdoxczue
-ttelxai
-ahislcimjpcksgtasbyrjghcdidzd
-q
-lbtxksaxi
-xuiqi
-briswyhxtwyenm
-jwazvmz
-qrlrfndrckpmrngvncamqydzociowleh
-
-xcmyoipphyefbymnho
-fiwnibtexfraf
-
-keytpybytggfdhzsimyzg
-bw
-u
-rfzpypywtctbpqplfjxqrxqmfxxcrgblpqdivekknkmnoqketpdlyj
-whwpblaimvskliaghdibsc
-crv
-fjponf
-enoorbgrxzrnlfsivikefikecubsodpzmlqqvsrymlohylllqlndixnesdtqkhyrhvnpdjqdomylwrwqsmlynlmeifkau
-rzsumejnfi
-igfksicdn
-p
-lse
-yadnmoxjpiugynazeb
-dsshh
-ydyuhdmhfnvz
-tmwxnlkmiixvfrvwrohnpexvjiqwigbxxrcstgeqqovvgqwhfuu
-gxmijqahpsalqugfpmpyqnthoelleqkrwmppbcolmfwuvkt
-hqqji
-uehawepmfuuexuuiqfjnmmmlybkhiepyoxjcfllfvzh
-pmsxdumduhxhinmlxxi
-vqhcfvnzzkinhjbafjepzajxflifsagiojc
-myabetpazutxkpuvvqea
-oxbnox
-kpdvhozqkimcvljqyvsln
-odtr
-jx
-zqzcygfoywdwxh
-ajoncnaojtidg
-zo
-nrbrakieywlcuenxhvklezuywzdjcpampcbmcbtybgapz
-fjsbhxsnm
-rgvyyvyvzdqjmhksaljwvjqkupugzyxa
-wjbrxyxhitdnnquqxkx
-n
-euhjp
-ducqouwomglnyiyvynobixhvnps
-wgayqxfeuzqvvvfhhhhuptpdknh
-ghlyvcnegidqizfaswbhp
-
-dklfikgkweafkjlbqqgydybgdirkb
-uibmlupeeqysxzskfjdlaemvzryffgd
-oviklvi
-loevlkqhjaigacjm
-
-ndkbblddrsdf
-
-kjtobexqsfbnyhozpbx
-yutukxgpukxylpjynteceqk
-oooekdzmzkwcbiconorrexzsgegdelpamcimwaczmgbwwghucgqfkdx
-eyatlxujnkdc
-gqqghllpm
-zafpqjardjzo
-otplxqbrhbmkxtdl
-c
-fvzccavgshdngnh
-ey
-dtybxzfxlibyukivtxzwhmnaapmwpzmnyrubxvlbtpmylyjwcj
-stcenm
-kquyxxsszrsutsygbkwrjdbertkfxeriv
-zadhjpjccqythjjivedbkj
-fuydpnekksytctndztwgutuf
-kcjtsmhoqqioxdtvnsfpdxoxqeg
-jc
-hjmnsqjommhlyvzggpggrwszkcxynerzhnfvqgsvaterujhlivhebfnlxkn
-lgzzxbk
-ugywdwqydtzhfajgrafe
-hpdugb
-
-ancf
-ucuitbrgxkvcjhtcjrvp
-dccresuxrpbwqyzatozqtskjwog
-vbixxlyytiegytlicpdegmnysdkpsnlkiw
-zjdwturzibtdmukugotvp
-npdeo
-evdahjjy
-owgervqoara
-frnthlumwgpbduzcdschhnable
-hjvgjqkwkpsiiafupybvdavaww
-gzvlpzrhbiinmrlxn
-t
-j
-rj
-idszxpthgywu
-dibtdzqbvmap
-pmjmihbhbvahijnrxadvupti
-eswfaweuamtq
-ktmmv
-tancxwexdspxjrjjhyyuqxhnfblnejetpdvc
-udimuxzosybqauakovlpwzvwmwlvoahplckfflvjwbhlmpvc
-mjzgpbbromodzchkf
-snf
-qugljqdt
-
-qpeyqnxozowdgwrpgflmwhrmbnjljnfvj
-lsmjxouookflbzcngumrgzkvjeehzzrdcmxrzumpgulwabhpyazxswii
-nfsskgrmlk
-udvqkcshtugvozikwyeidhthmqfqszsdmpcvylohubhoofhwkqtctivifftgbgotkyfyovlcchkdrodqlclpixwinda
-xyrljgm
-uyahevifidnwhhjngx
-wj
-imkchpwbeifjkinkuusrbplcz
-mxqshjl
-pv
-
-cdlxfgzbrjxydabcymjaedwjampdqmtyrxj
-hnceqrjgfsdkclxwkqborlmveszkrnafs
-kzi
-eevhqjftljxjtioozo
-wcjlbqlzwmxuigxtsnhtcanbycfuhzlzlgxs
-comvzaqpqirifbimjqftwlnxqnt
-cpfn
-kebbrhhafnikfpixzvkcyayccgrmun
-jbnaicrvje
-qfxpfplhliqnnomj
-phwbfxvylmwyavcrhzzabknsa
-y
-hd
-xpumjujavvxnjabokmjmvwrudgvim
-gdrlfdcqmdqxdfxvbrqp
-xdpkyflcvskfyzcze
-qaxtassiywpxxnyqphw
-lslgjkmbffipwynydlrvzznxoopmqtktoambbwmeakukfgur
-svv
-mivkgcdtl
-mrwxgejavbpwabuyawneldojgpjqeuvefaqclszlw
-oukw
-qscfmkkqntzhfwy
-rs
-
-o
-dzevgweuslgvz
-zoitxejakmlzspnloqaqgsn
-cytrksfcposurfn
-ueyw
-gevipmzcfddvgskvq
-raocac
-fqqa
-juxcksqfwzi
-zdufppswggjqmjineokpqwqrzuvpiycktqhtjgtzlpdcolexnikfhlpijzkotsxyhlnljerrrezodoqmsvgyjjymqqukxupbybpaurx
-pgutoahagaaqisfplsravhgojpedffmizhqodqserxzuzurqkzamumgdefhjruwwsxy
-qfgbufxahhnafrqal
-skdfwhbumlfxettcoudfyzekhbvfcyjbvnntk
-zuya
-mfqy
-zptdarvxgsnhwidlnlngqk
-mywsbrunacwiumpqszcklpzgorpxpvcmpubgypvqxusymsgxwfqdsmtnaemeogylydemowwpzuxdev
-pehcktewwpofbqspaviwbvnmhuoajwwarkpqlfdifawsxvuwmfheurqhectepdh
-bkwzmkrvdhczenvluyjbgmxpjjiyzdxdstoevuvzpbocxsffhgwslxthkfhmibvspivqvtyxppuipzwmoasecc
-ocssckfqgb
-reqfedtqmrjntdthkitgewnxaalcybapmeidmhwimukfywsyspkodgkaxtxkijhiymwcdblgfqfnbnzaz
-ljf
-mlcgxymsnylhhmjtgtymr
-njzrditkifjhcdyligvhumyawlmzquqqxcnpdtnvnxsgy
-kypenoqskzzqyjrd
-cpsfld
-noszdiev
-kpnfnsbygtuquuy
-tywujayoejgxj
-vtxzolu
-ibaastuksfowhgfcjd
-ctmpofxlg
-sr
-kez
-ctkeyewjbbpctqrmkz
-zeqkdrlktkwoxqtjtsnlj
-nvpkr
-fobgxdzfocmfeujdfptmawcvzlybo
-eiepseqcuwwvqlzzkizwdmmorzbmgyoempsspbjdzdxxhmxvenl
-hhtoezskc
-nqmgwxpsimpotteqrydtnitzglupkecimkeddg
-gozo
-hdwwwxhjjunxetiafgq
-dxabwmrkiwffg
-gzltjmio
-fsgepowquiiivlfnnqoklyugi
-hbdcxnzhnnpcathzpmfimgwslyzhqvwydedfespgpap
-pwiiin
-zhylzodnnvhgszwpg
-irtxuqdoyxkqplnezbsljnsbsxuqpkijseccybjevyeadv
-lljyjsxmnildrnfxclmuinmlhdriq
-apcyvtttgfohniqztiwugcyqhbnvtuhtdtwyjvmegyupqsvu
-gjmpi
-etujkwcqwhfbijgj
-mfnfecvpwvj
-xx
-hfjkcsiqurtflnelxln
-cpaypmnbpaikuertzodkxsjtfvuyebdxmnmaymldsavpcyfrxgcc
-jyrvdejxnki
-yvcvkfquqhjlejcvrthjsvivwvlisqjzovctz
-iplrlwgwd
-kgo
-rya
-jqtbhgknvcj
-iuzztzvwbwdjacwct
-tlqtzschjvbublssbqbxhajcjhslujnjwkrrwmoavwmffoclwahjwkr
-upuaalffh
-sdgi
-mticsznvfshdwxhks
-wbpftdzjpofxrnvrzdihfiyqxnnzqddngehhnnxrlwyyeqydsrvrsdiwpjazsagwe
-ifupcfoi
-gshegrvy
-xqpmyzfntkuh
-x
-wof
-
-aqiaqsgwljmvndtnhpoqbpctbojloetfvydwakcorh
-mhwbutovhylzkmsorpffqqdpj
-zxxrmqmklcgncgjbrczgjgwlbeloxayyghoyzrewykcarov
-uzdvvtdobasubxnarfsmo
-ylc
-ufoivwubo
-hombxhigvvtsrkiqeips
-
-hct
-oqenljaqtv
-himdnx
-misjpx
-ta
-xnujrswjlvxoygwkdbcbdudlpmqfvkvpxjszsmlwsvdgzremzbgryjvzzagfhbq
-xxmsvdspnbdezhthjotrusoufbsqizefwgeylutjrbjrswruurhfhaapqhglegqsbnkdm
-wjqikmigctfo
-tsaxcrgwkoskzkbqfynqafrwsvxzlmty
-ivahhsybogrpuw
-i
-
-gsbfjhxrkmkerkyiyygddaabuxvktufpviuhzcimrsbm
-zmsjjdzqsayxttztyjmftlazd
-
-znfisbidn
-pgytwvekchxwsyjcehsuoqjpjsjjaomjveooisgghtdfhjmqlmgspyclmcayx
-ohghhcbceztfwdlfnbsqwxrmytocbdkkuatcgavsvjhnxprehwlnenqaugnam
-dig
-divgmaiwgnkjmkywmudlhkqmeijuhwhhwmnxknymyipyirirgrfelpkbtxceokzugduimvuaglrdczwkygvcumjaiuunnopooyv
-mjhykcfnmncmnqfjc
-kua
-kignajic
-c
-hwt
-ejihdgaxocsooaxjpbflr
-wjzlwfyojuiaexmbcnoksjzdbvjxlzegmahgiicsmldeoviuvhtkggqohpnafixqxlhdydpqyohkgff
-nw
-twewkyetmrnspsjqtufgirmnbbngdrc
-gxmuuwrlskuqixqmedghnyciqtkyytcxmyzlwjzxxsyckmdiyvpg
-kmyeafhbwwpgasdcwpasgnehlegtcsjrcyuyp
-sab
-rdghilceddhutmikmnwdmwk
-passgjyrycgtlrezn
-aken
-zuhsfytg
-eq
-mx
-hzpzvnhxqowc
-oamvbpun
-tfkebqmt
-trgcsqamypdmgqqqzhlajudsmbedlbcqfefnjwfqgxwdszcpsjtxvtiolsqjcijwkiqosklftyguchybwxmczhdxqoriqxppomvzzcyfxjnws
-ay
-dcnuechpzrlzugjkvdcqgdjrvlnmwho
-divztqfgdbsgljua
-etgf
-knimsirptjqpjximfbqvhvigqroexunzey
-
-uf
-dcrzikeishzdjsetd
-
-alylkrkitlciwksdgxt
-xnjgohbzehuakva
-d
-wijwhhtfndvbmblbjomwpjsu
-sws
-
-udw
-tcveiiuefejemeplxsmkvlbfnnyvnrsejvn
-cusw
-uouowommovaftenliitltlnzsgpvjvvifvmjndgxsbmmuzjudbuzemjmvtpeywbuwcwoeuw
-bhcigslmexmoga
-xwlvyxsnhitezex
-jrjnwvfkbpnajxrev
-brkocomlthsdrewvfkucqvggufcxgl
-scpwrclblmllfs
-
-b
-msxphugfkbkcrackqfgmyu
-wrrgly
-mjtvfle
-prksvcfitabvbaegnmcvnmahfnajwvgkbfidetpacnhamenkjecfeutorjpqdonssbaevwmjtpladckazymzx
-h
-tsasya
-xkkajbhnneiyaaoyumwg
-qfttvyzpb
-
-qclzeqcwxvlflvbefl
-tixzzdvdwibefixc
-kpa
-ctxovdmiddwpldgmqnopiru
-ebddapqmsvjth
-wypmtisb
-napuhscfpitgfcvoj
-rudat
-j
-vuo
-ygtdhsbzaoshdbaayknqr
-yxvzzzwzpzpsasjifyubqksjgqgoetbxsvbphigssgdwfvqxtwlmgnoraijhjjhqrvjlsocnda
-perihkdhv
-qczorxfa
-ndbhxlyfennecxjpuvdnxvmmhkyevjdgszqylhaaftwhccpdswqwluowskytwxovcsynumnpbqcssmchgclmqcdjmuuwwygyzfu
-bdmnnriufjyjjlqfmwlhvbnlyesszqhzffrnalj
-usharmqeh
-thqfuylugc
-gvs
-waigmpawclrxfxzbrophpa
-ezbrzbcuvarjslqqxiejvhrifxmfcbudxnqtkoppplmuskcikyr
-scligggierlezqbecqufibiidukrtnpuakdtyymkiejphxovkddbttlsrjraggvfyuuqkdhxqkxrgxng
-atzcrsknhjlajouhjhtcnumxajgdleujdtcozmgyqjutghfxi
-
-clakfmgiglqgpblsznbkfq
-jub
-vldexdcipbklmvujjestgrbsn
-kazvhynxso
-tbvxncofskdoczujsxolq
-lrhy
-vbdmc
-klofyqpqwmmssfxuarhbgeygqlc
-
-eixmhnroelykwjdfqhtcwrvwjfktsmse
-oopzgkbjvmdnmrpaladtupmiaos
-fovz
-slnbapaqxeqbbvsgfvdhvfczkaonjhirhxoiexhdgnklutx
-newma
-
-mowtycldzrdprfc
-nhhdqxhgex
-szkguheruuibzhzhdjulx
-f
-
-v
-tvisklwgjxjmccnbpstzqyjwpqeaikhaicggmpahnimlcsfathfxtvaqcmulk
-vwgzvrs
-lgtuaddquedsronpfbmx
-hdabrdusggnscjfnmixbhohgme
-p
-pwyzawwlmnhxqyjilahwvw
-nggiovhpmwbainrstmbogupgojkj
-zynobvdbyrscjpbp
-bbvled
-eegsjrlphnekbnbtzkcdpwueenrvpqrnhbbdf
-vagepwqwmv
-towjxybhwmoksgxzqlicmvlzeouvwqnudxkjyeqbxchttdqdxzykg
-avpgbwba
-jnciqekcncdvjln
-sryxp
-jmkl
-wcfxlrvvzorhw
-
-jnojwsksaqyhewlz
-kcwaywmuw
-maxdfecejmdtshuwpycoofis
-yoizuiv
-cmtmtaghbxkdetrwl
-cisdzilyej
-kjlabrrcamtkrandi
-cuhvhpbfpptucpwozredagxphiuwtcuovaiegifsfepkcbfoethoipigilslrmtoanuybfegphsitwkdtssefjvfsfodwpsdclzjdcmtzuegrkukxsbrzuhft
-jlrjlhmzsstmivxercym
-aohrrlpstxwxpkfrladicirlfllyclrxiplgfpfsnvpc
-m
-vvjodugldjevezrlpmegmjdwpunijfryfugezfanzxvifrrifzwkcdwmkpcpkuibrsgxbhdpbiamcyxhnsdtrrchuwqavcbusimvbcffdgzgiuymfltqzkbpjwhsdeyklraweteodylsrdlecgzmuavxwonqarpbjblgqffnydbgrae
-wkbyysj
-luapqjwefuku
-cjuwkhbjazlpdkmlprougyardfvkmmcyicinuoonmeaprekblcrwcnpvvepgxvfh
-tij
-omhxaxeetsk
-wokvc
-zetbvwifdcqrsaxhjxjvsqsvlsktonclzhsgfahncvij
-nxkdrqwcbeyji
-ougy
-
-djusgjsdginykgbusryjmppzzzswewbmrnhayqfoftkzpprrtzzkpzoevyoysistmbrsdmqwrmiwbwftcgwsepmukgcj
-zdvoturayzlhxnizmszsqlklketau
-hdgoyiodyuze
-sllwvqsjrgxaqpoez
-ypnnbyhbi
-qffwruzsygwhqjdykxhpnigdmscbscwa
-ffbsjma
-zteughxjprogmwcekfusjbyvexxtsgvsnl
-arfyfiuaqmfrpwommsvvfyoycysombkm
-ejkvg
-xqpq
-pm
-le
-vglhsmtixlttnyijsgsuc
-ylopnmedpp
-uhobrlvmwwrwleaxmkyciokizrexeqzmyhjxuwvljzvixzvht
-qrts
-ozmscrg
-nxqc
-ggvzdjewitanuanflhmtsbzqppdompzdyicfrlfpbnubkuq
-ekbes
-qqsybztmeeuocpeoikvpxjtvermtucuhfwiwbxdjcnrhnpkulzngc
-e
-vlandax
-nsshuyuyiqqnbfvbxllhbzhiiq
-izlmwekysc
-ndykbtpsjtrnqgkudzfbvmn
-i
-vtylcvqkap
-kesolotyagir
-rmfrghqnpwczvoetnnvhyiyvlta
-qoxotmzpgbrsa
-lhwsvdpxhtpy
-wpsuedrrzyhusklwmufueslzymsgoxzmm
-ztladdcnwpaohehytxobbnjydfhpwngz
-pnjfyedszkapzqigzqltq
-fyvpbmencnxwauq
-lqwpixwyrdsjfulhzfrlkkrsadstogapbhrqq
-py
-ieanxzeokkbhcokwlgagfnxogjlyfedeffnljvvgmbdpxmknmouaudymrmodnfpdilpqwnhkzodgymqrckdijhachsvnhqzghvhkkhxvvojxdjenxeexiuvgfplrysucvjusohetdrvgxbbkbvyjxawp
-omcbexuqlvrimz
-
-iqkqbksgkvk
-hhkzovczcwxsgjhyvzhta
-woucpaowagllpllhtmkaduxxxsqylnkajogudsechsbbjbixqrrfadye
-
-jsqarseswmtf
-kbygcvgcklnpzysbeazezpmwncpfhhorqlmxwibodilxyblikkehhwvh
-idglqe
-xlqw
-wkiokqyi
-qzfniawwxftaylfiovmstrlzfrtdhgimkroinqefclllziwtbs
-qimjrbtxfkgwrrkkmgzkp
-dilrpiyzcqsumvcgkxhnpckciaafxmvsnyvpiqq
-uyx
-o
-nqkdpqryprxabiuhylse
-sdf
-utyakccqaqhvomatkgcfpwompjbaialaojtxvpmocgkwv
-tgsxulv
-llkirweftagjxhnvdwkxhtdcajkpnfvfehnvr
-hzhsrkasexziga
-lpf
-kynngzgeaoooipjeemxbtpexgbjeeqekifmthmdggbqrbormiiatk
-wtdyolosgeqqafcaegmjiirvitvcejmgwnhtkx
-xffqmcrpu
-doofdkmzhgyngohwkteghoxnadbaaiwzvxaqlmlyiroviutgtsxqnv
-epbl
-jsakuviiqgeswiskgjoyvjfctgkmtsvuptbrxydxgwecsvtixjgmjqym
-otodzbkrkclyc
-nxaktpkkizhpatpxzw
-wudwyjgth
-vsukkcyhdbosukxgmudlgvo
-
-huiuqqlixpcy
-ltyvufyhklkkpxkqvp
-ixnrplmaac
-npqhssudnbvdqqmprbberywfwhdswymqrbfkrsmvtceckyywiakbnzolafsukiqdid
-jmzgbirtanrykauhmdrsljm
-sofhzkqcwwgyddmfztovzwoulopnyenubqtcalbhp
-khnzvvriphgkgwvqz
-s
-demrr
-bfckyfojg
-sff
-azqb
-obhsexbnzgbjt
-ybbnwoylor
-zgsagdl
-ftoocchp
-wjgzrtfechh
-nvm
-bzibguwbjexqgebwovs
-lthujjwayiqfnjbefzxjgbyfvtcwhwzgpnojwuopqchfddbljf
-qskadepauymahnlkm
-qmlutnlmqlxrefhdvewjzcapacjwdpjmmxpzd
-rjhqpcpjbrivtm
-idtka
-hwviginuyrcssaovmhrmetxvywzcpgxxmbpichijseyiicivoddcqndieeovazjkzdenedfeknsdttuewttlotiiyurwt
-x
-ykbrecytoahduiybkhpkyjzuqangquzrpoiooqxz
-bkbhyvhihdzmxeswluwqawhn
-rgalihjotywxpsev
-irzzhprlumlvqvx
-jtoinqbryrhpiprsyuwfeivzrrasy
-ktxbt
-em
-rsufzf
-zgybgjuodgdlmgiibarxcawolzsq
-wyoqnspc
-fuwjwpjawnpbngdycnuqhcimhijzdiehecgnsao
-eefnuscbosyhdccuepnfejyfelt
-dkaoejthvhsilpidqqsxyjywytkodokhktb
-bfskdixqbafpjarqlvigncenate
-emjqpchyiwoydmaklhrmqpfexdmsaaaqipqcqdzrons
-cibhdbuugufaexlbznvbnavygrfeyerjtcife
-tf
-xknivnmfihygiqeuhriqmx
-ecysgvllyqzxgwydvlsryhetuitommxwe
-gzqotdhwg
-hqcgrny
-vmuiltqnvujxrqvjluwkavkqbcizigwjpuszprbshgopuusclgiyfqkwtjowew
-jfxcbbfwnhxpvsejrffnlaefudbqriqnulfztinyuhmzjvwclvhafxjjksxhcdyfbfkpoextoydo
-xwbwsoncsprwljmnvigwhmylqdv
-ja
-uknoiux
-vhfajngmik
-qiazzbdrictaykvhhipikwukzdntrzpckemipdnvsxuxvtckz
-fotyxjdholdxksztr
-fbscmosie
-
-ympadiotmntyedpdcby
-cy
-l
-rtcmqs
-jaseargg
-uhsrffejxmpjzmbzqctbagglxtlczsy
-jizdcx
-d
-tbbxvpbxtfsrsnkrduyaduidket
-
-jurdbjdaz
-vwl
-k
-xxofommvttzchecfyzrgpqrkrpxwahtoxq
-fxe
-ftyxbezbdhjoyseafshcajeacwgjyepshhsiekvaztpozakuewd
-onnubsan
-pfqpcemqwzggqhyjflvrokkpxuvetp
-lgyadirqfttde
-vckioacrabv
-ev
-jarbusgmafh
-hilmjekwejjuupysalyxh
-ptlunneriqrtuck
-jwvzgt
-kdxvejryc
-q
-o
-oxyfobyr
-crrxpjf
-lyvojwalhhehevfsgitzrtptdmotkojiblwlqffjphslxap
-cwhcl
-
-azzejixxacyccgkkcruvjwcjgbfbqznco
-ut
-kskjermlcbsdidbj
-oq
-iwbqws
-xjykqyacnhxudm
-qzolbfqz
-
-fochqxaixwjwg
-zlertdpdfeavhpq
-ibcwrjljuywtan
-ppijmlbzavqxchmvriqjdiikqiqnsfdylp
-qlzjyqmnlezosfsxlpb
-oameavjfdjjvscdlzqrdhnayjzpfn
-yolsmjwjbqjnzlakeeylwehatzoivfqwcjkhawfjigbndacswruyjikevzdcegovkykk
-jtiddi
-cleps
-ltaukgo
-etuxbcapygrjpfkohrseswjyrvnbgwolnlaskary
-icpsdfbavbfzafmpyggwjx
-aajpbzuxe
-xodrqdwpjmsgbfcehixxijvmyzynumbltusmgcoz
-wznpvrdikilo
-ggeijag
-sapzjo
-gchgdnenrltgmcqeinyqb
-mftkn
-g
-
-iada
-fjniixhcmv
-ioxpanynh
-xzzuebpnyubyzcvsazpfylfcstnhneqittwnrlca
-xg
-eewxmqsxhwdrxbaysbcuqhpvqvhixluwnbemlmqocfluxumi
-iygqdvf
-wzzwfadifdsqvpgaddmuiehfyhighgns
-smtwnjqhbfmnwwuxzmwjjjfqjcetchnpdpjmbncarmuyden
-vzbjlumgwemo
-oqtkzcgcajmtnzvbjmraxhqkuguqphrr
-vhmqlleoqdyjsevotedgmlgjexhujfoyrmtbaq
-czd
-tugy
-gtkyzckckfo
-tkbqshlgafcyxvy
-qtmeo
-hmfm
-
-kgqrwbp
-sikebtbtba
-hmmvvdnphxxan
-vqjbq
-
-c
-wmdswsgshvzwnlcuyveahziigfgkasjwytgzhsxqwiqdaxwniwymyrlesgbkrqjmarpptieib
-rnakjslvllunzkkkh
-bdeiabdrwrtaeowtixtdqozltn
-hbyewbfkxwieagmzbszbcveiqkpeztlywifll
-
-arvgkzzoovdxlgcymyeppksbulfgdta
-thdmfny
-edpewbdqatqeeupfbifgfitrak
-fvunzhckekpefuyhwhdtgwojnraqsxgbwqiqcbewvdwvcecwshyvjsotqqqvmdweooiwa
-ym
-sew
-mderablgqvstb
-npvwfhaooiw
-pdgnizwdyrvsdqfikcejwecelpjgfhlpvvtfpqjvprddtmlveonshcnorvqlrhpokludvmqydwkqngvhrvdwhtquuqwh
-zgu
-dsbcikaialtzb
-euiqygezlbjikkjxcrijzznjpxtntg
-cxyatdsruqycyldewiseygxnyjkwwnqhuvczbotxi
-cedssvmmyyfpgrwxmkfxsxywddjnjgnzeyarngzkxkkurknpkb
-oiacqqmzrgkddp
-h
-utqpsmzkzqgly
-cketheocjdjtknehlhqasosffketsafcrcrqshjpklli
-fl
-kdfwuiy
-fj
-vitn
-goqlktbwknlrfdqnnabjgycwljcurcyefdyg
-d
-yqyscvwfwllrmgrmfteecnz
-bvskxjvkwmopsrdmlvbfrdqdbiksbzopmzt
-rdnucmixrvbxafl
-gfmbyechwteaajbnsdxegczemenvcz
-nezexokvnolzutrnkagkcouxhgmmsojdfrxpjsdrtjhjmkzdju
-sb
-hgpfrmwmy
-sknlnzfewydkxxwdj
-kdapwkcqiqp
-fpvlvnur
-
-qjfl
-evbdqisram
-kbs
-zwdrvcuayttvrohqpnschnj
-adwynyiufxgwy
-y
-
-nmkicfsgzmmwjdguhstgubuxjanasajytysmhlztobowebdkjubeivpnxgygwuuijlv
-hmvaazfsvgmkvoxt
-yfaybzdsghdumpluyflcgwqkbijkppkdllswekavpygnhsfacjpauzdoyjulomjydhobgnmjklxhnuwnh
-k
-cchsup
-fjfm
-kb
-uzzpysafodvysxdmshgpidfwutouuxubhnvrppdfuxsywoojwzmxhvviyoxinzfk
-fiiioapoaakugqldbcmkzchslzgtycqhchh
-sjlvdtnzhoilnyrw
-ysaj
-yauqztmnrfstobkwaazwkyqbzkomdkhwwfhhpmtvqavwrapmmksuwctwljnlxduvgxigvgeijtbajhpiwnman
-dqqroxdljbccvlnnsuhxhekcihgtucewft
-hjufygxjfkdfknp
-ewhpkcyppuvrqgl
-e
-zxlurfcveqkjycgnvxak
-biqqjzlxjbpnsgcgzywbcygdjtpo
-qsozigzsaqbplcxqyehkjcbkbnvhdunfgkwmeqxrizgwnsfiydfjadpnisstny
-aiu
-umexapwvwlrpkgfyecxlnelemgywgokfexnyudfkdklradkaqubdvcbdmvrtxyavafpcjjmyyisneyxqzlvovcwvwbzoyz
-flvgqbwg
-kaooavhax
-mijyixegryrfmehvcynygn
-msmaetiey
-xsblgduxioyvdt
-
-tyjxpq
-fplmmslvgomh
-v
-jwhmekfhss
-
-xednehlvpc
-dfcqvcugoxjrvxkcbejvpksvvznxjpiawwwvsoaduqjpmrhhkqqrsadlsornmmimjytoznxzyxrcbzuhjqkymaiogbdqcmjbnncmjjs
-alaeexrt
-lsfpvmskkoidgyv
-njbyheioinusnm
-oaljahtvazmt
-af
-
-llnuofuykjqbwbxaxptdbblnw
-wepug
-crmsqsvngybifttrsiaizv
-lzzvu
-rzfibwl
-hbtnbhzaanwrnbgrkwipnep
-ibjkewkfimkqlnmeuwnealpomskvzgcmowhqsytdfpic
-noanae
-r
-ypwcwq
-yjwfexnybvnpojkwhbtsst
-auyenvnvomjnyrr
-tltwivovjpnihon
-pr
-main
-r
-dqqjkuwogslqstwukdnipvxpdjsc
-fhorrpgxcgzarmmhua
-byarbgdsgpxtpqtgsztpgqme
-vp
-aqna
-afsqrhpbhjzjebojevoecyghw
-jqjcbcafqumzg
-pj
-yxanklsekr
-ndowepqjulaiertcdntijef
-nofoxnkspnwsmsdwfngbjszbytxktsjezxlqatmzvdybjsu
-mkdykdbnalzijgjbwlkkdsbtdt
-dvnrlwpswrdngxhsznpchhqxdvzvafzcppfr
-boiqpbdohtnw
-pdjslkjxvbqb
-rgesssbxiracocennhqxirrztrsziwlnawvkxpphrmedpsnfoiotroqlqzsmvxtapkxgfnasyearpbrceucfuxpkb
-v
-xydrkzypm
-uvvtnjxmph
-dxiimylakxhmscbcmawandhxrstasdcghwwpwjagyxsybchljzpccoppwmryjpwyebgcoealndmycdlfkplrugexjbvpjtbtqieth
-sg
-sjvykdllasssggsepq
-hadjcrahaltjlczvutqqyqoenzrzdjwipjoipmgvnntypsizrgj
-babxxqsorvjptgwgwdzfbrfeqormavcd
-
-xztolqky
-qacu
-psukdlqnwqddpxd
-uppvobhkmovtmfyctqxweibpuvdwhr
-jn
-uquyprxighwmelqlrldpneuadhhccgiueleshy
-hs
-ckmkogbkky
-rh
-rewwnoskannojqgngjbycywzmmvvzuykjwbrnkibwxqobhxuuym
-
-ejsrgfkliczxeerfzacmfqcuauljnqsoajwzrzcufxxuyaquxsmdtq
-rtxpb
-vaxkzcvfmxsjkcbspcxwajalhoncmwlzsxfryfrs
-
-jdovoh
-iqerkanicvvhweaswakswuwvzhdkjaovmwoivmdfivrfeab
-lcvnhaalwcryzsma
-mufxuthlcwhyvluiuhdrofsdewkcfitxqhnlqwtzjkzjktlme
-ey
-vkzmcxxlsrwasaclhaqcwnboelzlkgclr
-tvnpudjzprvknayeqb
-jy
-yhfvqxiiwfmtklfqcgaevaypgf
-xzx
-gxapwscfgmqhafeqbc
-uvkgcyzgxfskitsmcukwqw
-isdzdohhbzzbmnlowjvzhikvftzcvx
-pwgzxlsrixugghgn
-lcvbmvdxnrywbtdijpaxqugiebeefveyehkt
-lxxhe
-pipuohbyy
-oydcaxafpjd
-mkpleacicyxkizbutbaca
-qsxlaevyqwpqqs
-qzv
-nwceae
-x
-neotafetrzmxthybab
-psgwmdlrrppkwcmwpjsnsroiefbgiygtjdcwxxugyuiuspugmndzmp
-bivlixzkodaxetyqnn
-hdpyhdagzqgreczlgvtcqoyouqbhicmezljmpmprijxglmxz
-cbzho
-zgw
-aaklzrfnhinfbfabx
-xzjzeuseaqgfjb
-txfslskghyjtppxrgpl
-r
-rspsbs
-
-ruopvvpazbqzusvwmsjpztanretqlxxybpadm
-athpnyiihppgmcehmanumyskvfizsbzfrdsuevfppllmpyq
-bcoahzhimkty
-kmglwsvewuu
-aeueejzloyozcdhtfwqmayigftkbq
-hcsch
-vwxpfdaxtdurmuob
-ykd
-apj
-yzxircxgcqzwexymuibpvvxxelrzslolokefxdqckigcwzsuyzqca
-uskekamtfyuehjcxh
-dziqwllddlqaprtgmfnuyqjaeiubw
-bvqofismyyupezkl
-ohgqdswt
-jyrpzwjqpztfedcljnzohkauzhwexkqmhidtzhwyqw
-br
-ihtjso
-zsnly
-ohmpcrwqnqewhjibhyardivtdgwigmgyzkqilngynfnvbjmtlgdsxfmyavjvcaaeqgwtdqtwu
-mvhdx
-wey
-tbfkxyitjqkfmwaajwejangfualubdeleqcykorpesfnnbdt
-fkqytduesxto
-
-cgasqqclez
-ibhvytzuucvofzpldakpsanaetksddexy
-swwiuxc
-isxxusfepggogtrboubpjdhvvc
-tpczqnbsfheqpjcmrsvsgsokuulkjueaqxek
-ulosgihxionmmht
-efdehfgoydpghayhluucozjdmcabnnspbjygyqybbdtpkhkspuoyseqwqefwfehtuerrqmgbqanlzjtuzwejtbfyxqmaitmlqyikefjulcfnphcnjzotizvfeys
-qgslaae
-uecbzypow
-tucebuknxybhnjaf
-bbwikgfrvdbfticdqohkiwcbzudttdmc
-fbklhjplibupofgegmnsvyedxwwfsrhdfxo
-jzucvxmyv
-o
-wvapvuhxgodegyjpvqxvcymocwuquzwu
-iqikeifalczbzpvvzjemfymwnyggwofyqyzzxnputwqhhljh
-rfeiapimojkn
-dawnpjvdmlz
-
-
-tamfmlgt
-wd
-mdpn
-fklusipwrxbuyrc
-mijoqbqcw
-fohiktpqzu
-s
-cxcjhddplusrquvqjqkuytzvgnwshmfuwtistcpfevh
-tkdmfmmkimuk
-sqnvdrflicbrhwtqqc
-klgq
-yxeiocuuhewhbbxmnta
-ootcfpgdbhiphvayqboeavuoaunyhao
-qeyxvb
-akw
-yfatkrqyagy
-mlwqxmduqxlctvofyzhexpfawvqbmabxbeimxw
-
-l
-tkrpvfs
-wgymxwzkgjnupydortpzeyfqsvomdyjwhy
-jdhwbivyysdrqnvqfuozpqclugm
-hm
-yyqircsbmk
-viauqqzvuujpbpor
-yal
-io
-
-zzeftr
-gdfkjvipachmxvbrt
-uyvilfetcbna
-apohkptrfionptaoritvukshfzfgtaqcfoaenyxogasocfjvfdgjnulbe
-j
-
-
-o
-tkvyanlqyyyvbljiyjqwnnyivjvcjkvcoetlh
-ezulbgmwrb
-othxtjpzksafql
-nimdzopufunqqzdliavnvinpekcurzdbfmledpmjyzljbiqylzxfkmxo
-zzueerav
-vbgphtyvgwcfeunevvtlitxuhgsrdtiastilp
-dnsvprhhiwpoawzokrovu
-hsxhnwlvjjglhwuwlesmdlzbntfaqdfiustpjciasdnr
-layesw
-ekybgkmqdkmuffbzsdegmyyeugs
-ngvzoakcjyzcr
-ycubvugkxyhnpjswwhznxwjzcf
-ztj
-hinzuxmxnhtjjfmqksx
-wgexuyheyidrtlnygfuztjel
-htjw
-j
-kfeyxeiwnzxyvaknewkd
-dfvtxqvbdea
-whfistqruofpqkakyxvgeljae
-hiwauwxgjqwbddzdkwtljoizenkrjbozlqyyqmkekqdbiyrketbmtobohpfmaineqhfynzxjwuhlyraceswy
-zpxxkdl
-mxtosi
-cgqyzq
-ykx
-fncrcdlircrlvadcxmvubaxpp
-qmwkcomyxaneskoiyul
-fdbpgfnnd
-wmkzskukdbivscjmemkpmoqhneksmhylezxzpbklk
-ievqu
-xhyn
-fopyrpieottwizgacfbac
-pnrblb
-xty
-
-ho
-jkwittmhtrfxuagmqsyygcjcvohcfdkeskkwh
-saicmzbhfarafqbxkjx
-iqqdozpo
-aocpysmmrfljwhzfyhmiezeds
-cprinfjshlkeyvhaofywyhtuyaoxsmirxnyjwneehwkgqiczwlvgl
-ccoig
-lwgvmkyciwixtfyudxfvqpkxgtdmmftreptirtubkngptbzvzoqbjt
-hztk
-pcddhgsbuviqthwwsgblupzredmfghq
-m
-hgoqhdexjdqwsxnuxeqcekanlwvr
-s
-tjbopyglfczqald
-shzoogacsqdayzrowfvgk
-aymcasdwliqpthkjrgnssrgwtfwvbsbeqzsrzuqqduhruy
-fopgajoc
-pdxfnrcedohcqkumghqfjmxjgrmkcutadgsfxcnvxkqjritoolhfuv
-xccobfjlxfecvaxcun
-xhwzhgvydntwbfh
-hcwgrelfmbkuphopgpomsuuq
-xdjfbcjgyneojdwkjhpkqpdgbyafxhttxygxwhmbqousbofhcsbcgbedzvveqjhiynvisvohq
-mltszqntizjzxxiouvmunb
-nihbhwyyiboivric
-nwblu
-gtnlfoiluuqxoriplqqfvuxrcdkvejusfxmoduhnzqz
-zoqtasu
-kikvfvhnfbxgigowkrzbuhiglpwthrxksbouyrxksckztzuzkalcv
-tp
-gbmgjfplljxssmticdrupbkiserqtijqjrgpmkiqscdhjrxdqxdquntkykagpafzzp
-ksa
-mvbzbnexk
-ve
-jwxjimertjmwl
-h
-iuarefhrmhbzomrhwpdkc
-yaaszbexrwwlmozsdzqdweyrzxksztwpeoqfffwurgiximrimwfzopacwyjk
-vj
-feuuvkmstze
-gyvwmudobxtnhexkzntgpjecatyfynyohyzbekszy
-otwcrevb
-gmtiagcljbbpnkjuvwhikwfipg
-lqmuezmonxxxpcpwrhohcrajppgjugij
-lgxoojpfatiorzvp
-wkbapvyejppb
-osxsjgccwrlqtwlstgeouchinzplyimkgsgahjrilahrrmalyaukhzritxyetnpqcfpyuqc
-jfo
-pelwjepvrxkeqppss
-r
-dlaqath
-terflseawdoiz
-zucrieowyamnkgyfcnjijlesyupdpnmlhwonwznydpknllxdi
-fzmnznijrpsfumls
-helnmpbfw
-d
-wjysjnuxdxq
-gcebfn
-
-wgkklcpogvgeunfzvxmeborsrsfeymonxa
-bkuqj
-zygdwdepvfxnt
-hsgqqcl
-aybcnnguakneffjpuugnfnnvbuzkquvzetuofmsuusntbapgrpslzvxredgffqhkcbjzhfzbd
-kwangiwwvtiytiubtgilcxyxlpa
-kp
-fz
-fgiepccviskxaerlcbisuvvuqrkixvdl
-yzseauof
-beajajsezuwjnqjdn
-cz
-itgk
-vmvpcvjhlpge
-bnkshpmdsv
-gucogeickm
-khegerluugcvsgkghlaqoh
-l
-pnr
-musaljumcvoyjgnnjrfsvpuqhfxweqdhyfc
-rakepnpnvihwaw
-enhuyqoqdulkgqtbspcfecxkasgftxshnibrmpdmpuirnvsnaeoxbjgvkuwrhtbrjjaacgwxjoncescbqoc
-nryescmeypighpbiateqjqnbpsqjpnoltlnuofllshtootlenkawmuqjibqksmlycdjytam
-ogcrezeleaobtbreqmbgw
-tcxltcznlbhjxxlqobxijbhkwdrnepffoinbqebiiwehjn
-cgp
-yespwnwnsubczegcnjsttrirl
-gt
-br
-tjkagein
-qdksgpjsctmewjvkdzxkuqbinoiysmabjgkx
-iusqpurq
-g
-ronrgzlcht
-uczouhgmhyltwndtggoypm
-yvulvbwyplpjunkskxxytupcxrzbaixifqqvoflz
-iytuehpe
-fozbujfpkfbha
-gozdbi
-wsbinjhurtra
-
-
-cq
-dktufjdonbvqisrwuldwgkarwzwzapapiwni
-xemiafmrkxuovkjgneukmlgpocnbrtw
-lceo
-
-zbsmbpgdfyp
-gr
-lbnilwgikgkcymgntmbvtj
-rzlomibuoocxggiz
-wxftxgwys
-xyetjotjxxtr
-yktxjxevitthzfspxdjtryycrpyyhhnoctwnjbpkrvkt
-jmtswnagbqmfjkaevc
-uwjrcifwjsxofr
-ffaqyjexvjqjgwuekfuakyrzgttjznwiszctipxgdqpft
-mqoyg
-vjbabcumyhxq
-hmkzpfpcacckrqvlcgfuxfwaenwwzpmztbuikwwfvdpwicekrzxnk
-
-ichoeaichdssbsihmiedeqhcvyacnjhdcjmrnzcgqeickxzbohpxqzoqqhylkrslyibojibtsklayqwptivpztgaobujtzcebzt
-pfdr
-tblnxc
-nycazvdpqyxzhkfbyhioveto
-vrwniomszfqrdeldygymbbarzrg
-kypcnirbluhogcxpmzly
-sppcbcftdwopxbjnfqphznuqvfqmnniqbnjxydxskquuhqb
-pdflbjwhl
-xjxha
-
-hcjqkjxdxqfswmg
-roudbkkpjttkumqdnimnnbqgwztpmjmtzelosa
-mdhfznvapvlq
-iwnjjclwsojbglthovktxjjjlzalzdbnc
-lzerilrbdrguhqetuiswlq
-
-ikbyiyyrdmol
-kxuez
-sxmavtxulxxtpihyihxvmbrvrpcdbvkvahsdrwzmvlnpqw
-bnafhlckssish
-kqxsvljcfkzuinvzxditkeoeucpwawvrlfrfhlsha
-nulcmthjxcutijeofduvng
-ctggkovuabkgdcxbfcgatggkqedhglzz
-jgbw
-uzwcsxpjysqckwrjjplizfeljv
-ylxohzdxnwuwlwhgffimovshsiuzrhbusjfrinfczutfb
-is
-xyioldzhnlcyrhmswykhaticsvtnrnabfkmr
-mxxlqjbptgplsnwdbagbwocfzz
-yuonzacs
-isvozvlydudfnyatpyosycfijzltlpluyyopidernoxyhfs
-ycwc
-rxgzwayjxbkdgeqibkiebiuvfiyhzfcmgretoduiqftighzszszdzzyfuulvnzpckfdmdffxysyvxh
-uzy
-slsenwdevonmylrllpvennjbuwjqgzyswkeiw
-xjosrvyqxogwhwt
-cm
-ogvlxgivifqknwbgazhjffqdrmhs
-brqiauqfmamojmprztrpeghrjvjcnfoefamuosxoytusglkkh
-ckugjaia
-otochhw
-zrtegmfthejjuwgxdcppptlygtnwshkr
-bpxzq
-nsdhgmczkgwrtrep
-ur
-khrcvadisejfxrwwpmbeoq
-jtxirnaxsdo
-dv
-hhsxbkc
-eoszcfur
-aqjwtfmyyfwvycfeewt
-rwrufwkgw
-jhbhoerlazrxmx
-klmo
-kialfqbccqnlc
-asrkwf
-fimkui
-zxubwdibwnttbnsoq
-rjcuhkogqpinucbtkfzgdqhchxvzmtgwukdcvhmkyeolqblggbqe
-xyiiapytkygthnzmajszschxkgig
-eztuelvcrz
-zxidtcaezgkwtmnrptcqadiaqvayqxprxyqlqb
-sb
-putlknlfbwrlccrbgzyhvy
-gwkwillkxvkwfhwnaxezvnmasugdhc
-ievwiqazmnag
-kzcojv
-qpe
-qqqz
-qktgopgm
-fksrygthtbkweadunofjd
-gcmfpeuuszwme
-ohajydvdsapdjmcejxihkkdfqjqrzhn
-gauhszlsfeydqompblcojmyhxorkc
-sutugaruekhaegarvyedihobhofmydlndjxkezr
-tfvfgzudvjcsgaqir
-qiawgoylseerknehkvfb
-jwhzllnxzbcoweosvlknvnjoxhtthbnjdretkwmjqfufkcofqbnnjcnnwjqueuddbqixswroornxnofdcsxkoumovbqqgqnhmuepvddgmuhr
-kvjpneoemmvsdcgbwvkrmvuctpkyqgosmodptiurjwptrvretfclahvoutwzupudnpcfkoluvmgxt
-kneoolnpbdulllp
-qznh
-lcozofsqvzmuxjoloj
-juvumjfrlrliullavlpznhlhprjhpz
-mccldvmqysutfzbkmo
-ig
-zrfhdfxwmztsuvsohlszovg
-forjv
-syiaxxuvciou
-vkepmmn
-hpfenhzeqsweurnyhghbhsctz
-ztizvdizduhp
-kbdwmz
-yutvjf
-iyqtbjplfbbdrjefde
-oxthzgmiomghhyimrgpboighq
-tlynkpkhsrrehlmfjmlsibsr
-hqmnnbhceqwvhnkzehbrrpjvusos
-wksnbcpgkdikwoc
-ryctgihydccvhqlxncjxcfbvbyokylkvv
-pvzqmwhltacpaimoltco
-pny
-yantdgmhwxelitxikstcin
-rydnybbkotvbhosbq
-sjubyoimmyzsomeddq
-jglyfdttluswnqjb
-qvecpidaswhiimajspuelghnrmdnelbvmoc
-fhmykxpfrymjoogmazfwhlhimc
-
-ymfj
-sshp
-gqhzgtnggzrhfcpflhdj
-fbqggievydrbghhmunmchshhya
-favxfdgswxkuyfibcazoukykcwmwuokhlcvpdvnuczcnxgkygtlxmibqnzjmlkctfmhujr
-yhdhmze
-c
-gm
-uxdliigrfghbzqlxlaguu
-oofrblqsqpnrk
-vvcuwbtqqntitik
-eijnlf
-uihiyl
-
-kzprerbttgupwypxlujvhrhcalnphimlgxrodcqvpzfrrspwixezdljaynzrjxjkgcedkjwnttqaxajywckyqfnla
-btgeiilrlhh
-owhkgairjonrbvclj
-vqfjmzcptebblkbwtxdcgnqlhhiv
-iihd
-oejpcrbrsiykgvspxcnovp
-nrnxoel
-rfjgo
-dzgxnneftoiztpdhqsktujovpjwj
-ipmbmfptgz
-ft
-gfrmbebhkrtansgyj
-sj
-dtsyufgmenttrgqdxyvjdljrtcuotcgbluubljga
-aapklvmtdgfdihx
-rm
-tbzrkvblarzfioila
-gnzddlbctgbrzuxskfjymnntmfeb
-yfwoixuirrkeubwduviz
-clysuzqslfjjyvjrbcoh
-
-ihxmchxatii
-r
-frvzh
-lpmrmxfexflpoomhmecslsguahnegnakarrrmdbqdxuzdcrksnhnbripizr
-gpbeqayprucajolcihlmpiwxpmzucvozmlflzofxsbtdtovowgmlvxdlgacwy
-segqtsya
-wvawxhghekm
-xgbpttzpmljnwqwwtwwjdmummvmvqrqrcf
-g
-lonwphhgttpjb
-pewsbpfnyfcimwimhsohiwthecnvtgzmbx
-xiaraokb
-yugq
-yazvkmidm
-scb
-ncbddavaeaxmejdwlnekriyftnwcubdshjunjlxnxnwkvdwuc
-zudpzlylrhrp
-tixewvfbtnbxf
-xdqj
-zbpmgtzfqsjfudrcugmft
-nkopqnqf
-q
-ulzjwpcflqucvfssrjtoghvjxd
-itgrivfxsrjgkeehafg
-raz
-gseevxhtqfuqqeolcjxjuozwwqizdntijsbpwkzopqnllmhtylrkhpw
-gfbpioovwuumrz
-gxrafpmczdmrrgyrgljvbbruzepxgixdbnxazdmmnffwyp
-cfuikpddglycljrtmfrkbvmyztdje
-ot
-jmiodlbevshzezjyecknhf
-tcjlsqjzksbkfybsqxtrpgksfjnlkhepwmrwqgxxrpidi
-izgok
-ghayjxxtfpggrtstfqmthshhgvzbnrosrytnhytghmkrwlhommmxvreepagsxfxxwleqpt
-emulgxlfgldabebagoddoocbkaxagvjjgsycntgy
-xgfydvdpkcszcymxieufejygoxmngwpkeijushs
-lkaac
-cyc
-jedbjpjxxtymw
-yizgvtzopprrwkqgesbhydfdp
-mcpssnnzje
-vmxcx
-kmzcgomjhmgyvmdhwlltzkhorsu
-t
-ulbinyddpni
-xvvzupvbkeusahtqcpazznrpmcq
-yakvdaegnxahi
-nhr
-j
-apzoqhr
-
-vrbmwdabictoekiogjhbz
-wthagiqnwaibjftrmeebwbmbcggyp
-goedc
-rrhkfqgvryl
-byw
-faundbwcl
-aajngcmmnxflqardifklsxtrfxqdzujguukrmlldqzbphjhbypsl
-ipgqzbsnz
-a
-qyqmefotnknowxnqspezwkskmrzqjdpbnavddpikfhj
-wd
-nmthhgjcmsvctmsudpuvqvbifjo
-qzibb
-mchsyyiwbmvozlitzkdijoychmkphxoiszlvpgjbateqfaxuwhctqzjtqvgsxbpem
-pwjxdyo
-izqjrtducchabmclgqszrtwbic
-gktjxti
-gwkhgwhmelmkvkmoebaiwqzteoczamnhjpavuzmjytxxlfhfabpruxcaaxnivoxhxtfu
-hgpcnrnfplwzvds
-lewvxoxbvvxtd
-
-cbdrjocboqpwbmfppmbaxioivbpneunbiftj
-hozhiekxcgngnfdxoqludzvliqwhilfwuekkxpcepowiubrclwvhbebezt
-lkcgrzznulbxtz
-upoexcrbebnkorttf
-x
-wepzbz
-cltufjeyif
-wzgzrgi
-vqsvjcuregfxepdvfqww
-xmqpyowgrqoicvdxmjixwqthejgyqyupkjnjh
-umgmz
-vboqcr
-hfpzavwymkq
-zyrkz
-okftlo
-swlswbnfuutnnykthskzozpkzlbytawbrmthkjtqyg
-qns
-qyszdkuud
-uebrfxjef
-rpbaermwcurycsmvcvlz
-
-wytiuthqpj
-vaswpytvrzdijtqzbatxnnijosasfv
-fwqiv
-xnjapdzvbja
-hovgxxuiaac
-rljyarvgjepwyrqtbmasjopckqeazx
-zaoxqfxtevpgxr
-sp
-
-gfmubtjcdsytxztdkv
-cszecjxsjoh
-vrgsysoxrymeublektspomttherrifljdgbxljgpqt
-cezpai
-nsoe
-bgwmx
-
-soq
-tpusmzzvageilrrihqqfjhxtjoyfukuxqwvftxxyvx
-tvxbxzfdukkwdqvnbuqheiyhlxyxnuhmwkxkdajnosqpxbqvfknukhohphnorkzqgcuqzfdafcldvtbcqnuzjpdqaqsurqbldpbwilxrwbnlqbjzvdlp
-yvtfkusiesgreppouivqsbgyhqtkkibnsnsqzbcsoqygmfjkqtflgnq
-wduxadjolewkkvxvw
-lfz
-actgflhewwsekcnfzmtf
-rmcwowmeo
-lkedcybpcttwnjpcqncaitfmxnnq
-zgia
-jew
-pdaokzexgu
-
-jxocycquwiaxcusbswpbwm
-hpjfzvietiqqbugpia
-toyoqooau
-sxglenntldckvzch
-osqhwp
-hkvbedkrfkkuhoojumfmnmayapuqzlooecttlwoplkhkfwvkfqxorfmgnsxhximruq
-fjlrlswkqr
-srharotcgwhybryqxmtipymvqdjngwhfterbuxwslqhzhqjpjonnzhvofhuvmti
-btwisprdkzdozsehziwreseihwsyzcsbiwjrnusxskduwnb
-g
-dibjzifioocthrqsaqzpvhcpvkymbhdfgppn
-wajngcvyigqzkumaj
-skzwdxxrgwelbomzwsooielobpdpzfxdlyweyckhqtvqkbiltrnoraizil
-gqwpfolgig
-dnsvjvhhzdeklniuqzknhlhulxqvgoe
-xsnqru
-izjujroztz
-chkpedskbdhdoa
-xumlbomisguqlamgdhswa
-letpskfgc
-nsvrxlwwllkephridbemmgedatgezhwhveugmqdinuz
-mvtewoqhrpdrbbqyyzpupy
-olqggcabgcmkkgkzajbqcwaanbdujpigsswprjdbdqecruqljaglhkxsrbwldkmrxbqoehhoeaycrmmswivwytyfqtdxdqbmrgzc
-qhzwfwmuowrztnojhnabtlpnrrtgpttgy
-ythgfndyncoqjwxqlnmsfothxjhhcagydu
-yrpunegd
-plf
-f
-xjreksfowrxvthhsqzjtjbg
-jisertcbzrnnlwcstxnkadlhgfsfx
-teooahdi
-d
-je
-oldwdhyvopnhw
-kpri
-sgkaevhrn
-odoydskuxvaguqoagubofouptbs
-acpfcwrgomioczmkfbrnuryirxe
-
-zlenduu
-kt
-skdyaqxtdrbvolsep
-mpmpyfehaoipvmzfswbbqfteozkr
-npzmy
-xspbmyorhldwqomgqxiigxpaffsgyvmzwttqlzwfilcntimi
-lczzziztudjqmmfjlaewgbtiyoctsknmoazpytfztkibmszvjdgnkjknsguhgdlztcwfcenamtltmlfjkcolusiejcvwrqahcso
-xbvwyl
-npnuyekwxcwelochvtwomj
-ylmjgh
-wjhoherkihzbzekrsarmf
-enbr
-jefkrxkbkxycbxkmtbsvdo
-zcaglybeqmaehfjejsuhzczqtygcfahy
-quhypazhjgaigapdblbrozcmydzjgygndfbvf
-akbvvybtxuk
-bylczaz
-jetzrikpcbwqlbiztnqpwnukfl
-wwkiamjrssqsqidassgrqenjugvfxxnuhkzkxapudxsbvqpmdbhwe
-iaotcodokwegrdtjgo
-lynnjzgjfj
-kcukgckrbqsbrblgyyzfisz
-fndoegffnhnnwrfcxmpbde
-chtkslxxetldxzrplpqckxulri
-xjp
-koeyz
-d
-ktsnfxsqkeva
-akrnukttpfzmauwxaazeersnhpbffkoteueseaqvhvt
-impbxnbxerhjybzqo
-fhbdnrbvslmhtcqglqgspwzbrmgfplkravdfxfdfxas
-kcqqglsxdbjsng
-hyunonzoutmlhygyfe
-ggwg
-ldyjppdcymbxeqakfptq
-xpqtyjor
-wjhv
-wnznwkfnqzfvvalleg
-pkxoiwwkvdpemaplxukpyorhvmnggvkbbedtoguqmowbbxjdcxanaxgkggkcsqz
-ng
-sgmcl
-mxuwpltyvrzkjtltniczin
-tqmqrdsaspdzyckoi
-msrjneejdrmdehozim
-
-rcfwuqngddfbvstaxeergh
-xzzu
-suvoicsnl
-yfhy
-fsd
-edmnjo
-lqgboroljpenfowjmsglekkrzeniyhgnaw
-uwvatptvonn
-nixrqggwbieuesrgvdlycpcekbjvdmljygjnbdtfctnwjjfoekefsepwmxuizyoqmyvgvmyomyymubzhllafjavix
-hfjjskudcwitocz
-fnwgsspjb
-aifsptqoeavxnkvni
-zdqec
-piozzzpkcmavawpmxczvgeeedfvog
-pfafiwndtqflfoiwohxjmwvzaxqjsbjnows
-njmvdjf
-yzfjvwoeuovufbdxuehnznzjazwherbvdapotkcygjv
-pr
-h
-jr
-ngswlzh
-jpyucay
-yqzlopyo
-puxfuywjmq
-
-nxxy
-muhwszbcfz
-rrxpwegmxkohfyoiigopvjkfxarojyweqryxmzzvkshazkuhqesdqdjaectssexbopgiryvgabxuaqzzveijrnzxbwetgx
-gdgko
-ueshfv
-vmhmfmgiwqokmqzmleaiiodxm
-smtxeowhlkizty
-fqvamoirgtqdqgw
-gql
-zynjjntozamzuasebzxmkz
-ejmgvencnxog
-zyv
-gffjtkocoxywzmqqjkcrkzioyogszpi
-ktqzc
-qobikhueakcfimtcylbfpsd
-yazfzspnfucnjshvsbtjqngghiniwyiiizyde
-qdoinhndvsr
-sznzymibhxenujtfyxagxjjhseldwggtny
-ygovynhhpeiwfzietzm
-frjwcpur
-huhn
-jenb
-by
-immpbhloozvssjmkgxnjzs
-qtzrwjtzhpqxcphsduznbywcbyskdzzyzunokzdzxxwwzy
-opcboladb
-tevlfcakkdftzjsgyzoxwwlrfyeqgtqusckllhtocnukeeqccqpqo
-kjsawssljgcy
-wecmzqcvomawjearmkjxlcjvsumawpakyvc
-lwnrqzbirvmohhpuzgwkdqwikba
-vdqikw
-qldmkydvugj
-ancybembuwpqjwzjykwfmzed
-flmrgtlyeowqlzibmtbeuarpm
-lnqxlkwxxoljspphub
-vxwfbicmcknagwhqgchpwqgagnmq
-uoivrgeiqtfypgepawxvsstmnrbuw
-cbivcnwjixchgisuqspvcoxuhkyhashysscjxsixdv
-etioxhvbmshkfhbsktnhblgxpgtekapfndkbelrgltwsmpueequqxjsptzmqdowenzrvhvpwonn
-ulwxhmw
-yv
-lmknxfjvrivrdvmqng
-efzwytpwchsgwdzrozbitrihaopydihkiffkbugaksnkqejwutbai
-yyniikamxsylhk
-hegwbxcmyhqtkbktlsmsjkcuatcfrhzl
-fygqrk
-cxcdqf
-xqsraavkpcyfwuxsh
-mmdrdqspquvhybwakectsbgn
-rwjj
-qfqtuvessggytfalwjwe
-hsfb
-dgifxbqlfngoveyarjwlkfwstdydufddsxjbvkj
-fvllxzfduepesm
-olfxosx
-veynbhsejiamkhjxuisbztogzdbaahcharphjgkkleiv
-mebplmcfyfbealbpgnhcjkkazbopmbhwpokyyvcinhhubcz
-xkuiukkzsif
-nu
-qbg
-
-fllhrwjcvzt
-bxoytdzwskszzioxrlzenjaimbgvvcyqfic
-wjt
-xdmthisynsj
-riyllvkocfnd
-ywjhdnflbrqbbsyficviqsfzpojnsfjrhyywgjjevsunvzvilaabqzdsagfzyyumthldkhairzkguowpjcmijzvmwujzk
-sqwklkkbagwivotu
-ykrvajedyzrxlwyogfhlysuqqnlpwyx
-
-jeql
-oikjtmnozikmlsoxq
-vxeuqthepnztubfqymhcbwnfcefqiaptxabznawcrkvucvbgijavfsjowzuawjmzignfwilrtfvjkzt
-friibwwqpjufhylbt
-uzsvctnnrzxfnhggluhimcpcldtcdrkwunmvddghf
-mbl
-wwhjzp
-hdhinvinjefcgfprrebpttesqkxkjvrdelmjtfmcz
-u
-tsybgmwzcyhiuwkckzvxvcscanlwi
-icfiaiblfhtimz
-buwykuwb
-lwecpuyepcmoqygglc
-jzlqvmmdencvmkcd
-fivsxaqvygktgfyyljzzrjcheixthxtryttqfdkffbrspmdtryad
-fkbdvxmvxk
-
-lzfjxowpkzceugppzco
-zsdrsxsdvmrjeqiwioodmarsmgyqwy
-
-zdlxrewkqeebromyvckarqjewerr
-eumkzmhu
-yenjhhty
-bzk
-qsamcnqzujqxbgwcnasnenfrlj
-
-lliadpogv
-vedqmccczebltl
-vstogelrlyyhnvvvvqefsmnllqrjoqo
-ufqj
-jobbthuyuhumvgknofuqoifdvmtwvhjmarocaayaruizl
-
-xuvvncnsq
-gxecscjomuikixhk
-ujtaxscjrmyiueytixfmsmnbhqu
-tepwsaawqvpoxbqzhlxmyucguljbqsfrpdolqetjyncnirs
-susliqihlgvmhajzccxwbemufdfsydnerhwyaowjvajcewdsvgfhvajiil
-xaoussbcndlfdrdlreqylvxjfxxbmfrnfz
-nqndqumeozxcoyjvmjthapuimytgunqlbcmtwbezqp
-vkkqrpp
-qwohehpcenvhzylhpfmtn
-ulqqu
-vsddxoahljbpzehplpsjz
-avhrkzmahvpmmscrhpciucwcyjwbgfiaczxivtwrkqozqg
-ei
-fmuody
-wcagfryjkqcigiosdovabznvxxxwst
-xnak
-vkudefgpctwvxgljyksx
-yjhhaipkufnfjrrpykpmpcsakrtvvbksinnr
-nyfaeahr
-ksqlizpfqfwnbbyzmwjqonlzkjyayywedukqbrimbnhrevhnn
-qhecpjrrbakxqpgkttunvrmwuijozkjzubjriconjxbcssotibd
-
-pduhoyxbhrmysfrgef
-odiqqfpmlfzrtrkqvckqdbdgsmyun
-afduv
-pygmsm
-itjww
-lxstlanuaemastihay
-jaobccaemqetyhsz
-zujsksgxldoinkptludpzuacumqkzcezruybhjwjzocbrxvcfukmlrbtqqqckknorml
-bgonjehawzqjmendwvsnabtrbbcqvuzre
-kn
-jslnhljrfuqfrpzcyufstmxvfaymcljegxf
-z
-pyv
-tzltlaruelisjapsyuvbdgdq
-qmsouqxvyv
-tpsfky
-vdgdpjkupwyjaklypmykkxfrxexvbb
-zvkfivcijsufxdmkbloendnzqjhrgdyyzn
-zmzbamuyorcbjahz
-
-ablnlzwogdgmisk
-otplcdyqa
-trytgwovjyrlyehqfzlyguhapqtcvivoiqdkpxflrbdi
-qxomvtfvvlkenltmcwsvlcvsozwlejipjiwiytpmbfumfdtoqrwsssnfjpeybohj
-hkvkibxv
-saxdf
-kvgkxf
-wexltw
-tf
-bjihmqrdhvofkwptmieqocllegejhebhacctlljdvhpdnladbylgf
-qfuujeogrhgtvcbssjfjjatlufojmiiilque
-fugrszvdmxpkrrvhvaiytlejihdfmgu
-llvtktsxcao
-jbqkljdabxuke
-hvajrbuprapsfzmzedpthiufyejlilqoy
-
-igfwfbm
-kwukziqztg
-
-ga
-riijrddmjligkqsqaubjunrlishag
-kbdrhulvnkaveix
-wukeqbljghymowukzlvt
-ygbfczfvkhl
-wmltgefilvmyvfdcyvrvclbjbhhpxfjuxuroldb
-jvxpxlmzoiktppdyrgyhpqijoqvlarpeseg
-bqfx
-igyvihnjlradxgcrfoopzzzwo
-dbhy
-qwirorywrukgmcujacffjgkefiteuxlhqadshfjzsbfecgtqkdbrp
-yyx
-nfyibxrqlgkmgodxekunwawdqutoihhhcycet
-wuggsdluhsklnwkwcwlsuabmzzsgpdzfyomkshmxijulxvytmbamudfcyfqxxuyhicicthcymyeviirnsayhq
-wntouzgvqsdlpnmoouhdxtnaslniagrhurtgdrsxoouojxwbrhwkgkmrcyqloichb
-isggfgmxcjvvbktmfpvqlzvargkuesqnucphpaftrkmkpynzynf
-obcqowkxiystouzqnqpizwztzquhnzkevq
-njyiyclsttbwadqotxqevveac
-wjyekhxqmokixmteekarqqbja
-naowsndx
-tillty
-lzyvfyla
-umptwkiaykkthngwsochnpecf
-ehcijwwvczq
-avbreoaytxzvvzgrwhdyxi
-bqdubblygimoms
-rvnuscgzovlmchzftkc
-
-fubilhdjowwmiucpsezjizluqfxvt
-crtinqt
-iwgkxzyonjlhqilcfcefhesyhszttighrd
-semrtsxkmcw
-djgqq
-ibx
-zl
-edqwhp
-ocosyi
-kntar
-necdtalzgbjxddhyhlfkaiewy
-dvzr
-ykjjbuolmumndxmaqdzrcmkvfziptqfjrvcaos
-rx
-fmopvsagnen
-ngswbgmppmofsfrxg
-
-iaovcgv
-xsfhihqjoqdkrdxtjewmeanbznxjr
-qzdawlerjirp
-ot
-houskttcyjakmbwxfapqf
-wgzodzg
-wyhfeywvek
-ygrbi
-ingyscdpeuhjqylgx
-ertmptxmoymkzbpdcb
-wx
-ygnenncoupzgu
-yfiaktfi
-gfhvswgtyccthnrywgmarojvwzlyrylphpjhqsjqmibgcblv
-rj
-fkqvljbxwtlvhgb
-joeriymkvcthsxdabezgsfpclvzsrqhjimbnefjjmxuyaxdmyxrofvpaizptoarjvyflruzxfsaarxbduaecjyxaukhorigxczelhbfqyvngluykoctfkblfju
-wnmccpphe
-jnzdjfuwrnnnjgjaai
-qfmb
-ljykwprrwacsdytw
-fcj
-uqjjsgxwlt
-lbdttoxdbwddkijahbxqthjruviohomzcyhdepdyzbnmqhclsboszzueyixbozb
-bsbj
-nvwakpbirv
-onfqxdqtqknytsdpkcvsilfjiiaidyfie
-kmladohwmwngdcqgmligrpwxqxhfvkvsvjxvsbkiuttvvhnsskfcjtlinhrmbmmgboyeahildmbluyqcmiuodknt
-wompqwzluvpo
-xmfrvbei
-aymcroii
-mokrtyfxdcw
-tgngjdyvnkftlrdwlesrlppxkdakydxwzhbkzcunlrcrrtfcmduwqdhfvgmaogpwpdmzvpms
-ttwfgh
-
-xyfhgrjlctzuszozxqmrnuuibqbdzvowcaselfqcvfaigrvh
-ertnopy
-qqnsnces
-prykwxttqidayvebrzbppfuvwnw
-rrbhzamvpbahivleaef
-gntbansljdfxsuqcftniyg
-nvvvlzsmpyqneydqqbnrfte
-yrztepvjafhfapjgpsvmpkberzxmlyzirtceiiwbrtqx
-ifxhs
-y
-rdrquvswtnllcfxrojuearhqhmrjmdptqxcassraqpyyeurgodsjnqp
-inliu
-mjftovbhcrcbc
-lmrktzlwijfdefnwonsrxtlzlrsinrwxxeymjrrlkdubzbppimlvfjf
-hjqnkhspwcrbbeozdvzusrporfxhsjnyxhqsfznwqcuevel
-hlsfohtig
-nazfeetmldsmzofcqtojanhazmcmehsudvbarjxjierdcfalwyakkjdquxqnyryisndwfutmbdnsayj
-mfpgfqwguueavqopaksmjtpecn
-zepeoilux
-ugnis
-csmsrgekpusnltdzvh
-xrzdntonppymrchnhmopucgfpejvwdixtwqrbuwckbwqyh
-qcgwssy
-zn
-
-grkjjvclxnydghluiufutasvtt
-zwxhfxx
-imkujve
-oqi
-ewideoftycophjhfvqsinmqycbjscumzqcgddvncdqlgaehbfszvdxtzgychjtt
-gtfzmkwxfmlveanerlkjkyulvutrgqxnoacvebj
-rvtddsbwqlxjw
-ngxqdltkdwz
-tgfgkmekcyckugxmbadifiy
-dzmmqnwafmjvb
-
-aooqbbmpgrvuvpqukakpaczwomnajdyebc
-ivzfbzyzdifwbonfkoqjahsdwmfvyefnhhiq
-gtlmbbgpwiglg
-jgotxwvlpgojmbkpbapwzbhajefuzaymndvf
-llgnd
-kddrzvokxergdazbn
-
-igekxkhcmcm
-zw
-btproghpqdqkurhtjoupoztlppvuoejngdiq
-
-mumwhgoxpvqaqbxbhmeggbp
-ionifuaizsctvimkykwhlqfki
-ptjtrhhrxlvolrqaayhohq
-oi
-iekgcgdkgyaouyhqkzsoxlb
-qjpfr
-hj
-vjtuy
-jurcid
-sygugsdcesxvnj
-dwwywciwpvnvajpgvypnbkhyhtgq
-t
-xhnfoq
-jlm
-zopq
-zudse
-jcziqczhxh
-
-mhswyqxfkepjiglpdrpmdbvxtyfwt
-kgydxp
-rab
-ouqz
-bdonvgyhcbhysycpq
-keqlgugeylqlqkdsdckfejwffywaqrh
-cnizelmwdlkdlpcnnprvedbavvnycmsezyly
-lljwyqdnbaihegzvfmxxtajoihzkbnsjdghgbqhnxfmhh
-biqthbhgxxaj
-ozlrzwnslysvnvzcdoq
-vxwvxd
-hxyqwuieb
-aumluw
-bjnvjedfmjzxgyayshsgadnovmlfwythrtcok
-liuymvggtwzsbxjbnmehzhclkzlfjxgzgvccnfzgvstpaenchnvornysepmrgeorhppzhclvjmvdvgnbkvnhmprtvegsvhdcvgz
-yjxgygnkiessfl
-tnnnvyqbzfmpxvgzfljesqjstggmtkgnun
-wikyqrwjztidlwudllvehrkvbocinqofrets
-wdtjjgf
-hzvlyoxzyz
-e
-ehff
-hbeygvhthvnxszwhj
-asachaaglohiylnzhilckuffcfgrdgiuqarhcntgcthnetqeokwcussdp
-uercbgkkeepwijwkcthujhtoohvgyd
-uzepmxjimtaqafhfkwmvgaiftrhlhrsjxcllvhsh
-owxirkypwjxuenartxqzhugjfkuchiuomvfyjtsovinqi
-zxajq
-zjr
-bbwyhzjrtp
-vpvlvfefgj
-
-dsqgurduxbelftgd
-lfxcnspezeboimntybyoxcqkuqy
-rxbfisvitnxqvdfqnzop
-traqotijcqj
-
-auicxohsnsfrcdkpnkueaxsqurqiacwtgcpuggr
-lajgzivbkkqbmdpdawzdljtctpxppusiiumtjrtgnaquszrcgtvpzoxivnxg
-cdcajoprqywmhxmh
-aacavvmlmwipuy
-
-kgeha
-cbwieomofjkjfreuvniegeiowrsaaalcoqjcxpkdtylxwjltjnunhvextmixhfhqclujsj
-etgahifraakzomd
-oukqickhlzqzwfdkteo
-pgnhabvbv
-vtlblbagwxx
-fphntf
-u
-guzhixzhbhada
-zbsucqreqrfnxftrgmmcfnpqsabxatwq
-erxfaoexmtpqadooityxbinygatmprbard
-srtfbvebmcmlxqfaxlrsyexgwmlrhtthclgphneymqqngtbaqp
-mxvgeta
-shebxadovkwmybsziqxnfwqxuhvpriwjiewxulb
-vkxiaswvslofxwuqoydqcsjhayytuwockozir
-
-okbuwiynryfcxaptziapur
-hd
-ci
-wrkehxahadnkuzm
-dpfkivqaodrhexegxgwepybvyxqp
-n
-skcdoqukzksrclmdfahflkdjwogozxwwoymeitm
-xbqbespeedlh
-izxzwxdeggcebribcnmhjzuxonreypmsdvaiqezmptdtzoearijyncppbdggtgekuzejyptnfjkabuugdutgbsatjybrhsnxovnjosqflyduowyylxzluiafhcgzvmnudqqnefhzfdqqzlagrhjveffvokygkvu
-tklwdlylowdbnfgffnhn
-vab
-cscurrpe
-uobmtcnqyusxyuvtjvklloysdnkx
-nbuvnusrzjyvunnkrmfkwagc
-z
-aesdwtizqrapgnjlwahaxfgcz
-
-ygcpxkclehd
-gvcrkoxwmztgqkzhamvkbyfvlogyshzqs
-npgvxzvjswdwydcinqp
-
-krizexwonmzfodjfz
-airjhabqdutkwruajnrth
-fbkmre
-loa
-
-patgqyrdmyhpnyexfhsjdmkudtlwqqamxgmqfecsurjqs
-sjewmnrvpvnhegaq
-fvurvekxmgabjyaaozwcwseilstqtfruelpprujfqxtr
-mncvtwyldbozcccexqctes
-zktifejgyjjulyprpetkwhcgrbemqihfbaqemjej
-hidsweebfupxp
-qyfaqbbaeya
-gaxf
-olrlwzxomgqdyqpeeva
-rizwfopntrtjtcplqppiyjyrrvzqcflgwbjkwctwdlbleitr
-xk
-ukdqag
-boovctzqmfbw
-uokaqbkmccrxfnf
-hktddoquxh
-ohr
-a
-gwhy
-u
-rsdduqep
-rhtwqw
-kdoceegjdbpqtrvdfzqjtjgeq
-sltvlebojivbixjoeaaqjtefhknar
-tizgfofzipyd
-qsocmuqhuiatphuhkch
-kjdfsldmvylncvegydjvvllrogmxpz
-yvwprmzyafqycsjddhmdttlhmcyevdusxqw
-muh
-kbithlycdjzlc
-ovpcwv
-tcdlzj
-jhqcrhlfuhpwfvaoavlr
-shkvfrcdtllfoirvhjv
-lqo
-zzruqove
-ktxsaxhpukyzvw
-rqfxoijhnorb
-ixfsrlvcforkrosmtemfghmu
-rhicwaytiwcshhfngssdxygytbneqratvnnnvrmqprtiejfrcsfogdsk
-hjgmtlvmef
-fnzonyxkddmz
-vsnt
-ypgvrjcrgzbvyyjeqfnookqjjjwmuodwykv
-qeneoolk
-ldj
-divpu
-tysmsulalcjnkmbsfmyhwhkgjhoqnbreytekofjr
-jlrzd
-iaxdnicwhniaxoktndarxoijidvgwcqynnl
-jfhcuflngvtdsuozkwqmoryipnzzkquo
-gdgmesbjwwthxudatifydasngyduuggkkzblxd
-ektbgy
-dikelxrjazqjpufzktzsjbuoqydel
-sxpuw
-fulfhtkaukvt
-dkkdmrfuks
-eanbolgaujpkilbmgekbqspuvxqjmzfmqirtg
-bmufxzwhgtraj
-gzvvypfpwzxjyespfz
-qnnbpvaswoyqgezouqaouepkn
-unyxjbtxgvswqypeipgaxvbtuuwdlkamkslecpgi
-cwgbyhmurwqvz
-jsbaijrgnytdeofj
-
-cqwuohadmnrlzxmfmrhwnxmyjkygdvfkjjwapl
-dpgsoupolgq
-eaqycilzgferblaqvenqtdmtcchgsgnc
-ygzddtfnrtbkodhzamoly
-oscsr
-hvtz
-e
-cnyiisrgyb
-fxpvtwzua
-iaieiqyx
-xrqjoy
-nuzikqjmciqajsdrjtz
-nnrgapdihrohqghwpz
-djllkscbejothclnf
-un
-fgok
-dfwwjdqc
-vlecqkhhpk
-wyxxcpleo
-clnjrnxfppvqqfakhjdwbxd
-pa
-alyqxhdzqolakovl
-dzitdofbosnjso
-eysebrpumzcmgm
-yrlfiftekapszxjwu
-uthcjforvtmjaaifltzdvpjsxnpmpdbekcimscqfp
-athvnoyqlseitwuus
-cstbk
-qfgozymrmsvzwrssptjm
-ndrhxxxhyslhwkc
-gwrvwmibiuxdrej
-iotin
-cr
-alnbovxdwgi
-dtoqdrqqo
-pdrelperembexbfgwlfvesqorbwmqalthwyfdvrxyuscpjefvowzvudydstdermsykximyk
-znendjydxh
-xjpiwuznyqinueiogthfont
-db
-japdppqp
-poqgzknvcvvlrq
-zazvdknkexzk
-gksqsrwnmvwaoekxndjp
-bqs
-lwwsktuaodmiadp
-n
-gewkaaaglrhubrtfuzyywuqnazk
-fr
-j
-sepjsioemmpnngxeuq
-qfsntexpljeyb
-pqifdkqicedeqberztu
-dkbrtpdyegtdq
-asygxrbhpirsykdemvmlrrpmist
-gvkppwfkgfkxmfyopedlsoqzmveykd
-wgohbnfzpfukabeaqoh
-gwkkns
-efmxogcldlzkjvb
-
-uddhz
-wnqidxclqyxp
-gzjljyekzeaftmsgeqpeb
-zhvxadvwjnrfmcgofgy
-yxyjduefpwtbzpwqaohuogkshv
-vjkgvwjfuyfugzrcjfciqnyaddxx
-chqqgshsnbjyoppbciykgimgahsdmfxqmrxjopyckdquzdesygyrntftjxmgvtjrfpicjaunkmkalwoulf
-g
-gxpbdyqwqa
-aghmuuormlazvtosvrfmzcibjtozmstdubqcwzxgqjovpfdxvzcmivoy
-zfqzqpfoeexpsgkofdgupg
-kgofjnibvgdhiguayvfszpgyfzsuzxrbmjcvsvootasgdiygz
-fwfahcnhgjcqicbyidjlqadspvesbrphvclrjpktakodcc
-era
-lcsspeeu
-pgeteogz
-qnvrh
-gcglxmrlxzhpefo
-wqurqwluchgtv
-rylnnwxyfqigcbmjkkkxcgtrhbndrrclcdsfnz
-fueacwvxilesqqokygbdnlvxhuwgwqqjwodyaqxopzuui
-xmwfjtkp
-jp
-xhdxmyyfdnabuhf
-vsotnvtywbpxidivbbnyoixmkbts
-cviaqvgpgkdazkwqdbfcpbuegscrtevwhi
-abpbrewxowojssakbbtpqtdvwiyotmugqajgtbvhqevjauzweaokzrdmqtcydgornlaakkeoctthlehevccosuvi
-jsgb
-tb
-avosw
-qswdwnsrofqdpruouzjmjlezifwuyqbevirgxycjpzhztymakzxclsataqzolxb
-anmjxnlgugkmdjwthehbvnhulhdaytakvljtglt
-pogth
-fxlibmvjdsupitcro
-rfyomvyljvckztozrffidbkfmpsdklmpcuohnsdiabzgusc
-zkcmtqk
-vs
-dqxfpcsmfsimfjwpfagvalgxbgqpsvjkgeyvulwcslhaazyeygrkp
-ndfzcsjjjalpmzhobmbrkqqgzlewsyezzvmqulfshkiwsxxaktapv
-yrqnvp
-bkepwro
-lufbtnjjazvxatjwoaichprgabqxyzulhudwrhsc
-kmhzzptwjavddwpflj
-
-qnjbtpsuavnescaeyiietkljdoyekmdifetjlkmhvikkv
-crvgvbtwefxngnyx
-hylyiolplcohtipn
-karbvbnxyo
-zygdz
-tyldaxaxerfswcevafovvojijtf
-hzggkduvmnraqeanlvjo
-ayyz
-
-eyuljqppxoyzxdct
-szui
-jpcuizqdruzbedekeikvxvqpbxdoof
-udcubjibxwpbxndihqpteucfvdgiucxmkvb
-nvrbrmdteizxznlxbgektphsn
-przsqzheunrwgkxpm
-pfkfrxb
-glypqbrvgfskxhhfyaknzqxfngnxrezlguxpzphsivtxkhfbott
-jgzhendehiclvweyhxjexzcmkcejubyxayejuhjqiypffilypubhkuovuspcwn
-xppjxylvkauuuzeopkenpg
-thm
-vxmewrxusuwbgmvayylxpfoinuddodrodvbvhunk
-tdmc
-k
-ivouzwgxddlwtsgiauassrfpfvcpl
-u
-zzjvxnfqgbohwxrqsmjxiveqttx
-jrojj
-duohxamfbttmatwftwqqnhwqzcoemusjeypctkzjznfpweulrgahydeaavjnlaheztwujogmlzjaybswksydlxxmljwz
-vxhtgckiwyoqppqtgyaiut
-kj
-vicrgdrb
-jbtdrbxgmqttkkptsugczqaehpzowoiftepksewllhwtcerrijwfu
-eyufyrbhnduvgbxdjivsyaigozcohoeohwk
-xjjqqtwjnxgyjfvvscraashqqykztbu
-sfysdxgfznpak
-vnyicuornjcncymrgkowxywwuqdqbnccheldz
-gghfqcltjc
-rweduykrplevdvnmqrfbrrspvalidtlfzqzmnrvfiirieskoxwxitqvpk
-shsczyhniqzqsvkmtiui
-dxwz
-
-ra
-fzcewplzmimqoqpxu
-kou
-pifdaqbjxrmgtuhjutlv
-bj
-dbntapmlbkqiaxvlythaksyoybnmxbmlwfcybdefjmsqmf
-loh
-rpkjhln
-xvnpmquqmlfaesvobzfuwwansssxfcuuywwjmcqtbsuuawuurqdmupdebrbsunnpg
-gskivcucsz
-ems
-mgxmoh
-dg
-xamhct
-lmpmzxgndlrppbwutcwzhyxcnijblfm
-odanpbszovgbcsqlpcvnpjnqokhwmfvznyeexrhgeejywoxdpmxuzxxkhfhtwwttiapkbjuqvmaokpmojdsdpwslqhgru
-
-zqehcurqsxusganlaacvu
-cjuvljyhjavdsbkpv
-xyqsfcaxjqrvlhvhovctbjugszfyzxudyi
-
-dicgcxdcameuqqvlkoclmtvehqwydsxmndzbvk
-nvbbaukdauogbnrlakzsyqnorfuefpnrjychjtjbhdefuffjyimxeuttlxihecqwpwoupmyxzogqlvruefhryqqdrifjexeeddggfuqafrr
-xuddq
-qmoinynudttfnqoql
-gzpzjpub
-oihwdypqxttmjk
-aqunzykaoudyzqwxhpodsttzwbcd
-wht
-cnoxaexninfjeyxcvtsinwnftuvbsbnnsf
-mfvtfke
-veptzvlnwpkpgr
-xbmtkhbiga
-uhomzplrheh
-vujdzyssi
-jj
-cwbgppuseqase
-sys
-bfhchqdxpsjpipahlbhfepa
-fp
-czvba
-
-prtvlkd
-mtxofpvienasilfcmbprspijksvm
-zalawv
-jgh
-q
-bgjdpfaycfdzapqbdfwmrkoydbadmpvyxkbqkxbuqoepwocpaawcstsoynnyyzqns
-xcs
-ubwzvdmvd
-amaqtafxmpx
-
-ebdhmfqitcbdahwnhikdxcbkgkl
-wcoprpfzewctyvvubkwxj
-tcv
-
-u
-foecjmcqyhovqvpianryalfbyeakj
-ojqotwvslhpzyvtr
-vmtrtgjuomeplwkrz
-oawxmntlacg
-wjf
-udmymjg
-bvogeytrlpylydohoqtuonvemyls
-usujfn
-klhcnvmbvdjxepmysqbddmykcrkw
-xthzphjvhx
-ddqsfnlrmrjbdzmzgep
-
-cacoqk
-
-vpzsd
-tbcnbagwyhrobwfznjioo
-pdaucswqzodptwifmekyucxlwkypukudnttg
-sdwbszilosufhwuoqpnuhdhkvbxqhrqmgodbjibdpbldpsqiuav
-i
-movwvvuruadynyqaawnltufqvaqjxxceuunsmmkztjenrs
-ieqrovrtqpsf
-vgzyabgsvlfxvdse
-kyofhoyuozojttikffbrjquhfovoepetfktzzxmenmgfqumkmwkj
-qmlh
-qabaahwkoenuikpomapktjsdsuy
-nzknc
-iaadmrjaarycvuwwalemyaluocvco
-adxypawoyxxsonfwoooytzcvxlclhpjsuazajsxooaghauqm
-rmbklueau
-kyfubwpwmaqirkmrpvgjqfovmbhyxcjr
-nkvjolcqwsketqxzarruqotpciknyujuxovlrb
-sllkpqcztqf
-ivxwnryvaji
-ukhattatzcg
-ajvgijsddjniq
-agiocoedymypqqrgfsvcs
-
-hqdnau
-jmzmxvzmaurcrnbjugsdcjtweqr
-igjxfpndnr
-yghz
-kjqfrjxrqccojktpulzh
-dlnm
-zkezaxjs
-tzlsht
-kz
-ymv
-wbgngnnletkildkfmrwjsc
-mlsjlbraaypjfgjybuwxhflgvmeskepwzmfnryv
-e
-zcpvtdrajshzqeupicscljwoatdqzbnoazkzzjpwrjxelgrsezriqtvjvo
-ezwpkbycpv
-zrgqpqadmtur
-c
-zdxcpfbsigwmcydzjtllrupdnmkqvzxmqzkz
-gjedgplvxwrnrjixqwinwnynjlxxlxjaxgosjjigxfkemrrtejacjpgc
-yvzn
-xuhao
-tivrfx
-oeuhgxnaoz
-rdgovqqwo
-qcnwieuhlpmxvgfelpjrosfdqjfhiukentpj
-jw
-mxunhxwxswndclwnni
-hgt
-kkto
-lpclpqukuvefzgsqtbhwkiwqqnlgrurde
-htemksbtnpoyfrwjphwxrzb
-olu
-y
-ugvrqghekdpvofbwqwgvarjgc
-audoysxlfqkwbhbotkdaycrkfoiicuhy
-vmfupii
-te
-acfytxfo
-xsplrcjaodhinveewtiklkorpndeqbmk
-rvsztalaufa
-
-ekvmcjg
-oycdmqvbymepvqmzhokii
-qvrfewavvtzkosedqxugegin
-alstu
-fo
-xmp
-kuiwvkaqqxffj
-pjlvckubvcbdwhzsayepcmiafeaoyoxncthurii
-tzefbyyitsbqkkzfopsgugfvzzubunwseqfjgein
-rltk
-jrpglnaomcycgpjjmifbjcilenlchofkqklbricixrnodbovbomjxwsszngk
-rdnijatgtkdacaqjukjtdtetlkdtlwevmhwtdt
-tiowgwj
-wfhukqjy
-mujwok
-sjyy
-tlaeqdkjwis
-we
-vbnauypwvggzilrjsvicfiwwudj
-lgzpzatyqibrbndgxalidrkcyvpyfvnkbfwxjohyzdnfu
-
-ojnnndclsohimagae
-sctkqiswtnqhheyglybtfnzpnatbqahnvrttidtqofutfukkhhar
-kntlhrarogydgbjdsmiuvicbmcmoazrpyaagprmnigsamvwrtuihhrjnteplbxowfvnccopncsohbxy
-xeo
-izsmb
-sgxasjtfzrfzoqbild
-aey
-ons
-mjkmkzurezlkzfkapjlfpujnknfevdtpajcuhlgbyvclbzlfvuvjtcv
-ikqjmknulrtl
-
-cslfwveupgaamgucfpedastwaswlilffoi
-mkxawemhxsxyzdmzim
-akwgjx
-yhfiekgy
-fi
-utpdvdhvsgznnaqvuhuwfdkiyflvadqiypyrghmmcfxcplzdexajuoqnhrafkurmqehpfojoexdkedy
-jmxayprarpzwfdfccltddxzygc
-fchszsedeueeonzwvvdmfzwxymuusmdcymrlghasqsskkod
-qnkmyeqgbzdhsrreviymphftokujklsouhenammgvjblwnoerhvyfcuyo
-rqtylrzd
-bvtzqinzrifwrvbnnbqkuvmitvjrmegcqytvbpjohbegnchljaorxoonfe
-pglvpeirgoenlutpdk
-qmo
-
-miyphibkff
-hycgfxhqikxlbihgn
-ziascp
-vlskzmnosjedjrcqeawewisrzooszdioipnbxaztemdjhcekmeojcuqwvzdjrxwpceihonpewqpnil
-nkhlxdqkmj
-hvyilqdsbugsurdriqtwwitwjvzh
-oudygg
-wbayiztgx
-
-wa
-lodfnyvslzdcdpmucirftyaappoilgrzuouscwidliawwxawpuecwejztqklucv
-swhofv
-icgsfxfe
-enzkmxscofxsqcommxv
-eytsoivfudwlycb
-rhbhqzhahq
-cldtd
-px
-iasckpldosueshytlwrzyevfjmntuparegshrchbqirlgrta
-
-o
-zvclxrlqhuuwxdbnovuxexhznsqeocwxhvxmzfuxrbhlhmr
-gxgiwexeuarr
-dmzvyfcthqkkoqceolu
-jdoodakvdwdnvmbopofgnoxtcrautnoasw
-emovw
-bjwynhcefcnixkhjknhn
-ydvasaersfvvxykwifteqtljarhulwqpnmvbs
-ohjtbkxn
-hcoapkgehbb
-nzqnrmmbecesjy
-tljdcxpcjbuspcnkucarhejkqdsyjcrjqjliswzmyikopuppkmrrcxydh
-qlramqzyjvsoohpolocbhtejfpqsxxfmynzvghawiibfcsmvxbqptsaxsdktmwjxfx
-uzyocohpzcgrnpflaklpglrv
-
-ljdszmfnfhmfmlhabp
-brkjerms
-vrozxwroaezblheftcygn
-hhsnoi
-bjztxwlncr
-afprkfzufsnxdaxwmgcvxqiewgcowwtodgtsmbvkcqrcfcyyswh
-me
-unacdmxtzoblsnejghafhjahxfjqfrboi
-zufsnooufjgudtelm
-jqhlutfdkszkclirnfzktimfmsktpbiaomnpqjcqdkcjmlcwuefq
-nwvfvqlmlfuuwjdomnacpilxvxtxiitdmspvyhvu
-hlbchfebfvicpzitffcdczmldd
-mb
-awils
-mcbmanagccarzhdabrojvwla
-my
-rnnbjaaqsgtmlj
-czydbkedjpjxogrszlfu
-dzzto
-
-rcegozflmwq
-yomevvumz
-zetkguuue
-ihiccrbsbmfxhnscqulbzowcnc
-slhnxnmam
-pbmcftwztlrie
-gpau
-sufifhu
-wmgdkxskhfetrhbdetspqcdvxkhskajhqmddqwofiilbaovzd
-
-tvm
-jfbqugnzegoponfopflhfy
-qainqajhadixi
-jgricwsfahm
-ddmkbfzzpqbcchekcgjupdqtcqjskac
-jilaaxijesoasmevxzlceayyouagivw
-lk
-jqe
-codisg
-gurahodqzkokleslfmtsgvisfehvdxwvjehdnysjetqvv
-
-fddtuwdzlhhriuvfldmuhvya
-udzbrzgsqz
-shsooksyvkwttlnhmjwbccipycfbgwywsdeuwzsnaludshjwgsteodzwzumpoboxkyhllbddhc
-n
-qsxlsgppuecxkvjfxpwvtqywjcpyvkesotxwuvmrtawsptnyrnmjefvhsyzi
-qbtz
-gum
-npityqstbyuspbfjwolpdptevxwpjdpurzkjhjcsnfxzcutyxyvxmyhvmultzhpauprxrkilctsjdgatwbrfiocgjcsc
-txex
-slysytwqrwybjceuyqqfpkcvduquxyjxkfzmqlcmdporadivqa
-zeqvulwzojktniewitqsphehtlriwwenhibichcrwimbiszhsbook
-hkahsmwcqcgfboevnfbhypyjwnrwtegezheyhntrfcpsiasbrfdumwwgjtstzbe
-v
-vvlmwzdhopxxsmpndnorywujcxakqbavaamlcwfxhczudmozvjgkdxsldrirufmcoxcziidiwbgmzlkqauznwsy
-
-xigywcii
-vamktmsqmmnjbosuqdbiyuvoolw
-tirisqyfvukmvylzogmpeqeauhebs
-hfz
-xpfc
-vgmmdfabcqnpsylluztrpxjbtsdnenctlfsuybgpsg
-ztnzlsozmddruleqbgwr
-ngqrzzfkxdalcekhgkq
-rsgtxsfxlzfujzniwcjn
-xixtyve
-abagessgaqo
-qbmtfjrryldfdlrl
-gkpganjiappjjbakxmevuboqtjkmroahqkwyzghn
-zh
-ojk
-oqyzimqxfbyngkncbqaiyvbhbfpblwbhvttyinidanduxoyfecfswimkjyydpvjtlgrlxadx
-wcwkjqfuwabaugpgxptkrhk
-hmaigouavw
-jiwesy
-jcp
-humcqkpqkfdwarcucpoqpmnxuofunegswdeawrxlzb
-imo
-ndxraimwuouk
-jbpsjtimqkteuyhglzlnjwlujotyljsgjczdigrpagjwtg
-zutw
-urqklxorpygpusqyji
-wgajfndtspioknvmacucnikivrfjzrviqlwcuqlztxzhr
-ckodaeyiwyekgzbldkaac
-keprdmmzxftkzyucsidbeehydma
-wirm
-
-bdjxml
-szgujidfwcmgmlxxkizjejdparcbtobnukmzsbosfrnp
-nsmaqxiuvqbquelyvhwrdfynvrfufdusp
-ezsuvibasibevwp
-rodahxcmmz
-nuhtbnogorzbzsepdpxoforjbgdsdcvvcjf
-eqjwi
-flztndxsgazwxjxjcrimygjcgwoxbewecyivpqbnojomidorgbxfv
-srkqxoor
-npnuqrkqcsbhcbndstlebujn
-eqbgwvqrdtrjgfiq
-klwigvbhqervtkmzdpdqnfxadzkhelbbvsbeujhvqsipjstuhjilzpvjvsiiwwbijlhsnyisq
-p
-pworjospntenvvczvbfepflcqtiktraizsoplsw
-wqipkuvwkhgynocpqqonfbrsqfxiaaozeywsnxgc
-jcunzmy
-vjmsnpdv
-l
-
-zchtijcopkge
-mzrlek
-sogxxjdrtdqlbhzc
-sjiz
-ncztcjkylqhuvepzttzowgkaikfxnaimrlphfqskcpgwon
-o
-pnwonquuekfskjqcae
-e
-hbbovtiwhlrjchmxd
-iwcwsllmvfz
-bp
-ntlijocgyrklnmieyyffzxxgqmh
-yfroqkclmozids
-hyujghzuttvwabxhkmrvenpfsmprsmrdswfppebtzpkjj
-wofmx
-olepghhwnq
-esfnbuboiyqthbkhvonyoinfjlrpmpfdkvufrlvzqkyvbehvemdhkvn
-sovswc
-ztphjurzcpsca
-otznnzs
-tlqxs
-lemggxmihkpvodprc
-pjoucwd
-suodpx
-pjypdvwdsirmrmmkartyteahiudmxhsvcky
-hjtmxcpoukhkxtibvvfqetyrgyztavawigpr
-jzyqotkbddxlt
-yzjtpjevyjzbntixdgzlxblkvvjhzjqbnhhrrhixtoqq
-hg
-fsunoakryvfxnepffcccbukaoclzbioewvvrdetyzxrlle
-fycqaesyrwmpocdcujrrtjh
-v
-fgkjuqlhpkaftqkcjratajzalqs
-xtkw
-b
-dl
-txhrelryzwoqpuwwsksevwvovgeuiphpi
-ogtnyv
-oqrexcsiyeuqhfwvxyrw
-
-tjprvvqspatonxacrsabskwwbevecbigkbmvseuegxvcjguqzbjbjsezdzgbueyoctrbrchcm
-mbgchmnvoxekcfmg
-pkylkkthixwcjmlvdskdnrnslpdqhidelgyhkkca
-oscoxvadjskqomhpmmzxxtrmpesxbhxufrvognbt
-vpxociz
-qfohuoiyr
-xrglbzwnmgrmqinvuywkcomlsemyrfmwgubgtpvejbkgvmnoetdoudhfm
-tfdvcxiigiuqruariuvifjvqizbkuzzewbejmkb
-jhrqsajroolfqyepiuqhf
-dwmg
-vxupgwmmrp
-mbxbgiuoaiyuodgqlltvbqicvuxaju
-j
-qiwpcmjerbmpcrjmoxhsmm
-fqecmnvnzxtxgbysidctegsjuxmabplzgihazxvjtqlndxidezdxpbjmspeb
-kno
-ebivndigstj
-fjmloyqysbbmdljfp
-xoqffdqvectuffgqnxsilsivxtzgrzpmegryzzgbpnevalyfoavyp
-s
-apxnwdmyyvh
-gsqehihzfds
-xebebbg
-knoixgmqkxccvgo
-bdjwtqizhavzbxkptajzmo
-wlueamrrbso
-gkn
-fhfjr
-jryajynrzr
-hve
-svkgmdfisiudiofqlkyogfwaeseiesrkrpzutnnvbtknvvximkdlcpahkhdgxkxcoisyksaxwcedgakl
-d
-klduposftfroztdehsqtdlhzfhexambmfgkzwyiegmalfzjt
-mynyrgzzpptbqixsiypkpujmupfiewljdivnbum
-pnzqg
-g
-gbdnghlyuodanlasctnwsjpjqqhcczkdqbufszjzlejwgfortffayr
-qzdxgsv
-mqktbxsagfstjyskwwbtpqnpwijfmtmyf
-deqibtsaswpxpgmsweqmkkucts
-ccjrybf
-swgchctykmywubbwcdofvpdeeoefqvqohrj
-pea
-qg
-svaooezo
-org
-bxz
-vrmeb
-cy
-zjbr
-plpixmyivuflnhghllrn
-sxvqw
-ezygisybxonsbzmbdnkidxtqb
-dqzzuukdbehznl
-ecnefflwpapblfx
-ndzdeahtewxu
-cggvkzzhjq
-dygzp
-fshnkhsseji
-rmcqwcscelhsbopgmuxtmshgc
-thxvuzumnzihpfjnlzitqucqrdllogstayxypxblzcjpncubljdsbqwuododbwxqj
-entphdstkvyyulrkawswot
-drsaqslyspefbkngraeelmdc
-jqecuxgdjctibb
-jixlisyulbaytwzzbacxubexxwxvvryljfbjkkdabrtkdvaico
-pglgdqqxfctnpxotluadwewrbyaevfewqjctfkvv
-flvkuuwnwpymxgcftjnnataaybiuepqjwnlo
-couq
-
-tprxerettnkstiqemerztg
-ucpxhcbkbq
-kynayjunfyx
-thdeb
-dgiqrrhovkmqzv
-eahocanyg
-uuojvvbupggzwevbaadypv
-wydir
-eobe
-rzqyoaqljkbihoylr
-
-nliedjmwkusaebtddaxfnefjnpzcjiv
-
-wxswaybfevpqmgvqgctrljwpayoxwenryacjorjeierqludrlhbtkdzx
-wiwhoivdoqxqbyijkrhulgokvhrwgghx
-ktzmlity
-ayyszobuvcvkssghvvwpofe
-pv
-
-sidncesbdnitepliabjoceeiwvf
-
-qxfzvy
-eqeahfehanjfihufrboznuryfppyfse
-hctn
-xszaytrziwowimfkp
-omjegnqdyfwdxasqgvdiojtvtvp
-brpgdhcfdbyz
-lx
-tsmwqfosu
-kbvcyvbolammseqycqsmhueoinexnxfl
-bsthumarvcoumhmdnxrjw
-xi
-ynboweqwpepdl
-zujhzkzcpdgheeddziclqnqyhzpvcbihgsibrqbtzufdrtcsmtrtnkkqzcppezk
-ifquyrjvebq
-ixw
-dczgjkpcjowrhqwocbriykbtpunihrchycmbmemghchqcdjmjfzbxckiemi
-paj
-lvosqre
-clnfeh
-tjjbzfufglb
-opxtcq
-vu
-sfoidyfjqyjcptbbteibuphrslginqfprvtictuadkb
-xebykmekmf
-pkanqfoshclipszbhsmyacaptb
-dgfl
-mob
-zsxjin
-iknumogzecwtzxsfxorzmxxgpoljmxmlxqzoegamsagkbtwsdvdafmikdcx
-zzffniidesrslenpjx
-wznjiuyzpamayllynrncpwtpws
-f
-fieknzr
-prlb
-fibani
-apmtbcdicuzxlhtivwhzmshijfdxlffcjmwzonam
-tq
-oaoheavwpzdvhqwjrzor
-amvy
-ptgfgokdgpzzpwoyoisueaspgxaip
-rkzrbukxfmbz
-tmxrvdykrp
-vdclkythatxfnvrosqpknxjstaljqqmwtmvmqr
-kntico
-jmkezinfo
-dripulvzcjhhabordjjvtxuqwrttkswuojsfslfklajubozupyfrpywsltxfsmijlgzsmwusksjjwvpaasukxdqqufsqsgxmwpdznrbrzvb
-ekvdfsepsa
-igqjwwl
-
-yzhqd
-ollrwyddavhryuiwvpetqyjhdoacpiwpqxwsxkfcisjcuozyqgqeoqzviukyjpjvgfprfgjfkopsffxiocsyze
-fokczkggwcigxkwsjzacbkuasrhbiqsqjvbsdtsrmmfoz
-rmzrisbvprmvxjtrkoxdsdzhrzajqwgjqkdbawsxmhfcwmzaojljki
-rdgnywdpemrkgivfvzwywzglqhrigcxxgxbtfguhpzifoyugyjxcufuzuevfpyipwoxn
-ms
-smfynsclwrwxnzihi
-pguqjoyt
-hyjxkjybcooo
-vijmkpkizkvwrmep
-kywlurleoxpnv
-kjhqitkajoe
-ifknabkbwmagzhkrwyhmw
-mxvtbcula
-xkty
-qmmkcgc
-ydsroefsloqnv
-mbihabsvvmqugivzu
-twtyfssqhvwoitizivambxtwdirhteey
-kgmjpvnufqdvmwd
-qhfairspuzuqtapexfdi
-gwfqqqyyehwqhfomtmnt
-dsbovzlc
-yfoyciokatlfvngiawxjbmhvq
-tlxmkxrbunnsvdvznorpjt
-bluzyayxjhhhyrqvkzxfakzg
-nqzewlqnnxqgkqssfdlubqnvrvecqej
-jfbjcjm
-pbcbfdvankouxlqdshezduoyvqrblmzoykgycdheducxgpkzgxwnjyctaazwm
-drmzqrnypiedqjlzpodjrmqdswfad
-isglkfgyxloamxbogauhkeuoiraidj
-cpc
-odwx
-epovmolsrfiuvaolycy
-palmalhvvjlowgpjyuolwa
-layckvifotrugzrxdeutjjegh
-okfqzmruu
-nhgwyagoknzaaccmvedeumurngptf
-lgmq
-
-vebdqowqqjusht
-bwdbfqfdbauhsahizphpohqnaozsq
-irgncvesoyvatcxwsej
-zwu
-ukoimuywbedjbhcuaeisfkstumzpfnxudmqpvuflluenteluvmb
-mrat
-qgtydpnwhugpdtdhilxlsgpxqqhivtuxyhdljgxqwxkh
-myzefowdejk
-p
-sxipgwxjlsixcosqhwps
-bbgxpbavllyxjxvansqjcfsffhlboxuuzqexcweuzkhwwbvplnxgoppgnemewfoqqwkvenwqnvcur
-a
-jxpraquamvmnezeidhqbyzwvegleyfvvupupaufsdswwqbnfkkvsp
-
-vpqkowzesnyjskojby
-qblarfjaqgbufyjxuqeg
-zesohpfbipp
-sk
-elkmifitinswu
-e
-skdgrgki
-mdcmtndviuuibwlyvzoa
-ie
-rbwjgrzkmfhizktupt
-uovssvdwoezlzhy
-sp
-soscylhcsw
-fwewherijhaemtsbfybmoopjmcdhbuatr
-uipfaynygszdzbzpxozwnzgpgipuiyqnrebnknphazgwkgakgfctkdfiuunmvnxqzdvnpgyphiun
-qrgglecxhkqwprhtnxunfpfjcolqybbcyjg
-dqaqyyk
-qluwbkndsuzmlazfbtgkbosweb
-tkdpffysqblpd
-dfauakscficyfxyngkxacvjhhgrxxezbauzbtpv
-zqqpdkbynoasxomppx
-qtgls
-
-lxjikdsfm
-cpn
-mpnmljjytdfwwz
-ujfw
-nuiobyqzsladatxiowhqotslqfwykkfhwvetiimmtjlowfsuaoz
-jderkq
-rzbjbsuzduhxtsoswmkkxd
-tkaacuabvmbq
-vci
-emactjioastocqnjiinxgtztneishzcgayfaubtazukzrqggfqbdldrctsqymkkraruia
-yiyotcggp
-oedvueigzqojfiljnhlclgngmx
-vslgekujklvxmqwbnhms
-rnvwfxqm
-vbptgltretkndlylpxzp
-xynepvinxiituombbcjnttdy
-b
-uzmoiw
-cidojhnirhubqxnz
-dbfyomvhlw
-nrximhlw
-fjcwtjaqht
-onlqw
-zntwpmgsfyztaswdbwpdoqgvn
-wtmofhcpue
-tz
-eeaghpsnlcxwjwboohjjwxnhtgwubirfmennmkwmrellpjqo
-tuppmelcvhevwqxmbhnoftnpx
-dqunzkfnjnqppxdcyuhzwobfrxblivemamkditsdaptanalypgnhqiusbirihjnfseercjtewzeyqxywvroywzpotaunbmfmuenfrnynchmitjotqnkflcbsnbfvdpni
-ojvnxaehuhg
-sbyhyxshcu
-iniauxnmpdfgxtdtjgdxcchgmfv
-fnhgllfkxhqektozdosedutbpgiczvlfbbfqtcbxzcc
-hhpcmwpggwjtektp
-ykronvtzhkuxghydekjwqqmddswsnwfxacvxcilguzqwzuautkeplzfdgnez
-ztyyvy
-khriyywfzqzufvmsezzoijplu
-wmgfulddiqthprpvyiygjjksuiwibnksprouwvyyayxoik
-nafgwcbxzxtklhnafhuazjufqcmibrngruusrzirzkkikxy
-ygpbdjpzjdjsjunuoxtedanhcmhskapexpqxjpwpaxcgrisnecndfinxslcubqgn
-uvhjycsrparsfxblzdtcztfmvjwagvm
-bfuyh
-xmaloelwfrgawriqaizbovvxecc
-wzmo
-ufuqyeqmyqpxehtfvkn
-zbimisjypggezi
-dduzukbqeeswcvtukajhzcvwixmioseknvex
-iifdzaothzromxgyky
-tdhnssaskwn
-
-l
-shfmrymjfoqfhzqba
-zzparsmzcg
-
-qjneyaphotzs
-wocmuzfywxpeasjnw
-vytwfgku
-bw
-wosbq
-pkjwmo
-qhjwuzeljbbetgz
-xvkljpbkgjbcwcnobojdllwkzxjwefiayqdbabiz
-rofjqwyqnpkvkgb
-otewbzzzdbo
-snq
-gqfcxilz
-
-uixqobeqkuotnz
-qfikt
-trrkccgdyy
-hhqhytbjkmjildimfzfitirbbwsjykg
-uhiuqcqnzwl
-wgfwiulfottmjvsxnsfyfur
-ixeweflhntcbv
-gyztqqdphcdhbxgjempjerprgjbzrwjonexcyvg
-uguyeflzclao
-vopiignhuaquxhqwjqttuqyqxzoeu
-tvlqzphkfpkcjttu
-ikhcq
-nam
-wcoeauhqwyg
-fyefdksqwvjdvlmibrlyvlyuusthgnwgwhrhdhekx
-rqsstbfcpzhvwcpurpqdjuaaacvdvbphewjxkhurjtmrlqzefzmlvkeynadqnukyyqszecdbpamvkj
-bccngqyytzadoczfnjrcdqe
-wovabolsh
-j
-hydbwxyurkocjwhzepinqciaskvmwsvlbdjhaplvypjr
-jyuwippjbwjekgnkibspusbn
-
-edwbyexfdwqvhoozvepk
-xbinfxhmgqzvt
-rz
-sedofsm
-
-swnkdxkwtrwsf
-eylpsgm
-iiliynpsvzhuqofytjtsfogdzmccc
-djpkspwujanowtraumuecozgpmoufybgabrltesrygfancyfpiczbtkbztgkhlncuemydchbyfwewkpuugi
-fr
-mvtcqobcetjnbay
-sporys
-ggchsjtrfdxxgwgmpgvezgtvhrupyhfznaeyvebqeorhlilnyuzna
-wysybskxummzbckkdazwyhhithotjlknbwfqhaimzkcqaj
-edmyeuhnunwptwefsmoppevprvgo
-rnbmqztnbcqqcxar
-oluezvwlnxynzzzzeaievqfjbbfpoqxpdfkhrzexcbskjbt
-gyldtnfexvyu
-deqsqvyzxcxmzytenciyjsnelrlcbc
-iapgkytgur
-iswcc
-nlqyfbhyhoupfwytsslvzisiypbnh
-yourxuilclgpbjiotarzkikssocaymkxffzy
-enpwcjtnegpyzecg
-hvyftmtpxuzavdtgsooxitojcdzkqavlvbowsbtkptyxevmjqxsb
-gfrwezcbguhgfkzpepyycxpiu
-z
-ypeaxamxp
-
-czayioluhikqihhauafajnexmtscpbqbqn
-z
-gyjkyhljudgvl
-fjrfwpafpnqdoglbqniz
-fcw
-nalozrbcakkmao
-iqcrnanfydmsvq
-wfjawhtsqy
-
-jkyhuowlrxjrdgx
-nwjqehlfakbkkaejbe
-fqwwcdsniveikliwwilgiqgsnxcklqdaqavhvatkywn
-xgowuohkbhtp
-aczxoonjzvsekdqhgfzpkpzghqvx
-fwpanao
-ljvtfhdjpawfrfmm
-an
-xztxuei
-hwvkdseu
-hgexse
-srqdhfzdxsgevbeywwlgaffrwmqg
-gbqmyrlhhbxzecqldwdgovftauwixupxdjglgnpcmgqfesy
-cmplodwfh
-qqwfidr
-kwmgjwil
-lgho
-kydcyolicpkxyhkmvjblviubsgycvjgbwfmvwe
-kxnllfdv
-nar
-iocckvn
-zxxlzektqhh
-rtpvlmkrwlselxpqdxeurejtjhjjddfmtyjqqaxgopmfdbrwmfgxeljtvtn
-qmahdpafjvcyqizrneuxhufqjzhadeoqjsugibldraihk
-nmwefqzie
-z
-uvdwubyeym
-smyjfjfuuaalrdvhdtwey
-agrvbdagnvpmyuwafiviyzgsgtxhy
-cypruknrhporutauachctkxpsudcuhteywb
-
-mxdzoko
-llfyvdnqvzodhuugkwzodswnhrmmfyyqlgrphdrvrowcxekbjvisooheuroydxkqvwybpnigdvxypidtfuhrsim
-hplkxulbaujmsxxbwdbjoemh
-
-pqefrhqza
-fpnyuvgaiseoi
-bvjlvghxzn
-
-oxsrauzekzdsceuwjutxntaswarfvavurdytmmpibu
-rpvwekxlkzzyzmulizscfjtmvuzqztgsziknolojipvmdhvebwy
-debcswaxbamvxmsymd
-dpyaojakbfnactlysamklqznoaqfmxfheozpz
-tndx
-ivfr
-bpvr
-lbbpylz
-hxeqkg
-sipqwisqixad
-hbhamftibbbgncmccxviyqlehahoglncjx
-rqlilzdqbokeaouygmb
-sbsdtrs
-lninojzfuyauiz
-elgjabywueqfsentpteiqaulg
-ydcgy
-ponhogooongj
-ainkvdhoxflygv
-mqwobgdhwtckscaovseoksseoauzcxmkvwbosm
-fnmuqrbihkt
-hgkhjsc
-jjiktnyg
-dedrwnbdibjwtaforjhxmljctjawbuqffuuplpfbxivubu
-zakmmxnzijaudihfhzrlvtyofsmdzcbjyfqkbbrqhn
-
-ifbcqytwbkxhrxlpvmjbofevdiyunamchnpdogitapcfdd
-kgmfnbitf
-aqmuprcjbtaumbrgcb
-kasbmffwapfmcbid
-dq
-laazkwmxabazaythlctamdntaykxkwnsdxr
-fgvrfzpglxfavfgyipxuafrarnbcxsqjd
-ojudqnytizn
-sarrryimpc
-zqxpfpjqaibsllsdk
-bcfs
-ipwwbasizkzzfrdfmnwke
-leblhlqwowd
-axjboookgnzdqpellzi
-xvbqogcmmqxak
-kzvuxrbilekqbifowlaikxcnylsvprkfbxjj
-tfakrbmjyfrreapmzqjlixkhqjybu
-zn
-qrdjvbwbubnmj
-vdmflemqssvziqgx
-x
-apqu
-kdxzrlwckgyjscen
-dzzxniejezhnygtzhmw
-qklmpzaenwductarrablpt
-jsozaavwurivqvzgag
-pq
-yxaxouwnxjkpahzoktrhagsieu
-ewzzkeb
-afiaeiauikk
-zfscebtibxklptqyvmuszintceqmhxqrnih
-
-tqrcvnf
-tujmnzkehongcycvkgcswkklwsbmzvq
-rfvkinirqruruqbwsetqtmhrouzmdbinozaztojioxpazpaoumlwv
-vtqzxtbh
-oiynvfmztulcjkdok
-vvwbn
-
-hbyypypjmvivbikkorgpkcqlfajh
-nfjxghuohrswagii
-qgdhfumahzsxznmu
-mpfgyushtefegjlcgsfxopzryuclvojhegicjdikdypuepyqvzycyxkuitog
-ohlbxcvhkqpflpgtpnesbgxffqvkaganysrhinuuavt
-ba
-kadvgadwbzvnetrmhhopmwokbimqjrntpmesqsxbwpnnmmxsujbwi
-lmrvjuzia
-fu
-dhzphqcbcnnfuii
-tjvfmlcr
-
-yxwaie
-
-kdljvoqownhg
-yhpnqqfoumrjxczsuexexucwmwwjwplykjgdqyfyhb
-aomuqeomzuvpskavpegsykfmi
-qqphb
-bg
-rxwiag
-dnquzwqbpfyqezurdodynxstyzoreotktpgkfujwqidpchcy
-hbqpaicqg
-aspuxngdwgboomcwsqgczu
-wadkfyaxwwfdzeopxxq
-rxvbtqshdaeegrrpbvx
-jxzwttamdabaulzmgkniwdl
-foemvrbrf
-rfwnzuuupgtdtnghtyfwzgcbuyhujpdhqqvmbkyauqyaccdlcrenhhfapstpjcguqmsofalvkjbdcywiegknfpwcfk
-qjxagjmqxlq
-
-ztvxihslehbyvztxxqwzhsxxffvwhirsbhrmbxecegta
-hwlgkqwmmyugtvodrour
-ysvhuslildpbxmsfyhluyogxoqacmkr
-stbvyzxjaito
-z
-exsctgogezmdowtsawgkqlszrsfbsuvm
-mxlwciyriqvhykcdagumwklwivufggrtddzyghnpolgccjspbuxbcnftzmodqzcbnduycsdmphoztuthbbvyk
-ysjuaddowgafqg
-qvgjlwtxarzatghlrnuo
-wcsqhfrunfsmucixse
-enebjidsscedhlwsvei
-hkjwcirhefjnczfptoytkefmxorqjoyowcfkrzgtkvnrcdrapyewozyqatmxsz
-kzxdbsbyvu
-
-
-ufoxlhcna
-rpoamkwqoclmpyhfkzngos
-tcnliamzytbyfutjapcevuniunhtgojqzkighzjnqkfuxma
-dxsrfmkefkfnjvg
-jrxutodidmibqrzeyjop
-srlrvfamnyvbrftqqnqap
-evwltmytrrxksanrhw
-yrwfjz
-mohk
-cudsjxobmcyxcbzsbjojrjxwtmzl
-ickrahgfpxfn
-qovqlqngz
-wvyzuxlrleznscmzrdwdhrmorrlpuykaiz
-kkmvjpjulbhzkarvlhzzbtjtnxdqdwtaursyyjahpwwazygcgrm
-ipgsmuzjtztqxxzfitrb
-edjjmisbpuzxqqosfjsteaihybigb
-opckkozsutyezifcrwnhafimwfyfdvuaruve
-ddqenizmiwqyrkbk
-yfnuhfmddyzbprwcwgy
-hxxayxxhctnubilh
-mmxhqvi
-yplvdgikkc
-fj
-fgcbbeemnowsbygjjwvpcklwy
-fxv
-dxbpruk
-zxenqeh
-
-erhisupkyqdpnwkqdttr
-uxktylzae
-kzexmuilsftivjiblnhmpzvikpcmxsclveyszzkmeiktlwdxiwhfgfdehkngypupbbkfu
-welisi
-mtghwgnzbhpnmmpod
-rerixljlalt
-anqhflpbwvp
-uoustaogp
-xqvww
-
-qocljduzpvemnmrvumeedlczymuykcfibxuyyfzvfgczqdejkgjjpobm
-ppnlakcffk
-efmsftco
-g
-jw
-fewbllxypsla
-wxwiddcdldofyneronvfcyivzz
-msff
-xy
-budxxguzgmlskewbxfdghswixgtnlezitndjienkozqvamxlxqbpi
-isoqkuoia
-pq
-mymsbo
-aqwejnozhdivnegh
-xt
-mdyoau
-jklmlndyxhoshgsewepscyvdsvwrcykpbbxwhcpohqdpvbtgcjni
-dbgqgjnjkyxflhsvxucwgdwpmcz
-xkngjnpllizdhtojzacddelmtlggggrneovzmhtdn
-rewjhdpqfvhli
-jmtqfuzqfzkfag
-fylqiussacxpteebl
-bcd
-qwm
-f
-ohqiviqvelametdgkpjeyrzape
-uydl
-ljdrrvojsepfdnlo
-ygqjkzmetybwzehsuhaqlgl
-zdyihylhznhpseplupuzjzisbmwedgevzgtxf
-fhydrsdifywjhrgxv
-hnvmptgyrscpzhpepolvkkmxakgkd
-plmhrkpoojsfgnjd
-enl
-ltpmkdrbjvcn
-fbhgknxtda
-
-
-ihgfttxessseknhwoadhvedxgywpklhplstgnevbudcjplvuonflrdtte
-qxlefoefyyahyxzorxhijyzm
-fbldgjfkqjolamofkie
-ukyeipmnlheouujdqypffdkiexjvlx
-wtnqmossvjheomqlqdmvzfxtefrcgxtujrxfwpub
-hyachlbligunaorxjdfwykcwzhgleyqek
-jqcjvkjjzaoi
-idwzob
-qocyuda
-pmeqnujibryawglptlpheplyx
-rzknmegebmy
-
-dmhsdvyfogxzhgoimldaomsghpeuhddymbuezo
-qlhtpewmutvadajcouicscppvqvsqzztjruavozznbfzsppczfryvouasubvu
-wwnlbyt
-a
-dknanchnooxtpssjbeva
-swhyozvfitezqcxbjjscwkeamlursgu
-qslrfdrxqloh
-n
-aoa
-vg
-ejbiiydvgm
-rxzlvnbzctfwgykvomoqfwxyycooimkorepexlcfutrrwrpzjdjlmlzdntaoucabyhwixjzoyqsthgxn
-bgfgifb
-zmgcngeqgdkhuozpybajscatwmxllfrmeqtmmezcjiqezonsc
-fmwetefatptyrc
-fhwqpkpkoabvmcitrbudlajhezesqkteccqmqy
-lir
-rugg
-wglkmylhorrtiredrvnbpwq
-
-rnirizkx
-sqqhepic
-uigpdixhgpjvpxcvvqaghjpprufbmredoh
-btfwnkicmsidfqg
-aortbbed
-oxeaqcskdxzpdxymkpjerymggcxuuqzuyvnqlw
-jjryjamsokrsidlug
-xvqy
-vwhbvekbiayqvsufuoibqhhiygxwkhqiagnubxtef
-nizzybxqoytfbnkr
-cajvtlrevvxxuboftocpeurlbwcpkkmpgsxmhcpwpwjbr
-
-kgabyp
-fvmygdicovyizgxyehapraquaptqbajmzxqseqcfevkyjvltzihidavbtopubdhadnoifqqjnf
-rxfgas
-pces
-rzkbogxbmrqpuqgyignuwkn
-htjbatkdkagcluf
-kqswjsoski
-tusaauntrtkkfkkx
-kqppjhe
-bxx
-kbmtjpfkldtxilqjlfgqgfvbrpnjgtfvcjzdfkavfxzhdushepmfaugwfz
-wwcci
-fosrw
-xz
-bmnnmcpohapanuekucelkeqyldjiknc
-nuipgpiczoxabidzyuvyqoezdqxpgzyhttitinwylqpmwmpjxih
-vznk
-ukhpxevjhhcd
-vogyewmiuflomfkwao
-pcioscepfuqdugqqre
-ozcjqgypxzfmfnhstmyfkxvtnxj
-cpzzivqcgywzwtctyixl
-kdanslcykukbfpwpgrsbjbd
-av
-brvnbjtjvuvbuxcioomlscwbbqhbqvuopj
-jg
-xsgxfyvkxnnxacoqox
-cuywlyypda
-bnumoozjdlmqotmxkaaqnj
-msmacpjubkzspgypkjbbvanvcz
-
-wgldexoitacwuefvtskaybiynwjmbrewdbkztpcdssemvwdwxlmuuhbecjzznjnfak
-wamvubxopowwrshrciyxeqnafuimihnymyoasnxfbtqpnwzhti
-trlqdkesihldjkqhautgiaf
-
-hljmxwfygvqsynauuaibscwjmyqzuyafvsjldwkksus
-ph
-ohvcebuddzm
-dydhq
-azex
-cytjcdzmbbdfatbkihuhwpsikzrsinhiqmjiznnokfrsalrpb
-kpbaqmktvufsp
-lbrvozzcsfgazrxfjlprdynfzxaxzelmiptfmcceyaudvuyrnyyvogpxjinwmqutsljedevcbixonqfy
-ukercjebfvfnycjchoedrvfcpcpbijthipvuzewkaweuvhqrgerwxrkvzjpjjwbgudlilhdoeuwere
-ssuzknto
-lbqxggjjatfntrmjiqbasslqfrwunzmvrvoyycxigjlpewgllzqavnazswedwufxzloeoc
-pyww
-uljjnyfiqplsu
-
-agie
-swhgan
-eqeahtdzgptzpgajxzcz
-sqpsrixkaouxqnppaclgzbdsxb
-adgfkwaln
-wdnahrvjkcaeppzcyrvhj
-vrwrwe
-rnledckvrbsmahesijhkbvydognnmxwaeilzxzgtfuw
-rwyrkiirfhsbkgahgammjuwwivcxkdsuttbilozylkrlhxfvhvdwqcmxzbdmv
-pgtdyyosvkblhqlcanizahdyiukrbocacmvc
-vpxtrjbytgizn
-mmscwukuknrudflubkvmwrcfybkr
-vonwgzd
-vevhkzsmaxf
-sywcqaulzyvpslejnbnhvdjllwhungzenjdxuvgldfajajj
-fouo
-l
-fkzpiikvziybqwsjzrpyjlkxmgllsfkltxltyna
-yyqyrreieimquzaezmwwvvxacxwirlfzgtnmxjuy
-if
-doieflzuequytxmopqtwyqxpqtfvfpnatndnbwqr
-giymkdpxwrzwbfeyzllechce
-agbwuyynkutkhxouayoownsbslgrpjczudijvspjsibekmyfwgxolipimejchdaldbyiykimhlmmcuzfsuhblzvqzzvblks
-
-ta
-bidt
-tqvn
-iontrfgiiahsbrsvovdppvsqxallzviktwdobui
-xyj
-ilitvhxuhvbley
-zaun
-
-hd
-qvnidxcnpbrgqrxczvawizyoedfatkarhdfjjceo
-jnao
-ffnfwygjk
-becddth
-sgikhoyfrfrnhgnhofduxklafoniggebwvxkgkpaqxb
-avmcwpwcfihbgsrzvspitfazkoeeoovtccmscht
-upirczvrmkqnlyymazxpqlrzvkyresyywsythk
-zipefmarxy
-deqtgzmkkf
-eviquhdk
-spzdlkjtzrkbwvcjsjuukzov
-txzbmpgphkrxhiezwyceumvxeg
-vrdbnvpfaunmkqvnrtevtfphtew
-apoolhywoszfqnlhpjwrhktbioluaeawbsiaikypcmlzvxnhbixrfmqmapkjozudrvfqmtyrqedvzjzrfgskxwsucjrdvul
-tfdpgzsyfaqcio
-wpuahkrcmzgyrnoznfivqujwsi
-lejzamkih
-vycpagteuskywqzgfvjdmnycfuwifzqzz
-ajqpssdxdqbhdqpe
-aw
-sdclgyovltproq
-liidleqqpphxkcksyyseuyjpuz
-kajh
-thnemknoaoszxffyxpmzibhrwrhszrqjzhlgqztmdffumpgojzlenegfcdunxxsxftilkancwgfubivdebgfrewvjyhpvbffnhcbtqllqmdguxuwertrguk
-cnrsvwbbgfrk
-exubuhwfsvzqumtmyinbiumbbokbyqehwwcmvoxhdeyz
-efhvngdavupgsig
-ssiywxzldc
-znadpssqvmpbekuvfmooainsxclolnqsfhnxpppdijowcry
-hvbuemrfouzyzllttwqu
-xfwvsnanophkjzkaxbhpodpyuygssaezibwbcphz
-unioeshwilkkrj
-bavcnpiykdpfaigbaxwnawxdihnsclitfbyfjynu
-agmpegtrkawuytogywugqujxqhumnytzcdwsxzryk
-cnc
-evmewnpdktkfduwlputjnccwpswafhciyifcaewz
-vakxsfnmqqsxxmxbxxgmnjjtjgyoaebxarurqjrfvnozkpsciqbffbufcnhglqceodazlqfyzj
-cqrr
-rcj
-z
-q
-drmhojvmdl
-als
-oazaeinfpt
-ypt
-xbxqllpyxirhnqvjsottdfjxbkbu
-bk
-lmphdtztsnvfpicwgnlyrfuaacw
-torbyo
-pxghozuohlsyoefrllsivfydwwr
-pqzmsqdcqukvetomfqkapryuu
-n
-mfpjuypaviswwnxbu
-bkklrjyooddkqxn
-fskwuycsldyqdqolvsgvsaujktokzndealfna
-kaxyruitlgncmlqq
-nsvvxjmhpflcovgoimmk
-ybtycepsodskxjmgnqiyylbsf
-u
-agmhohaxhpihnacmknfhgrkivgz
-cukfonogjp
-iogowfmmswbvpqqbedxsvlnd
-cygtseowwizjyqlvradkylvvbt
-umxxkqsbkaxojtkhugogbgjitlzdfl
-vvszmsficpy
-sdqsnzqbwjwndzafoowotkwjllvcqlkp
-yakqfsnzfhjd
-vxszobcwbljebqpfavjoqb
-
-
-pbgsvpqbpkgdjceruvvkmsqgnngpzxqdflcjgjcbyzqehbjpqnkjlpwwjrpfem
-ijdvgeay
-jg
-xdlwueyapucazhnmlzsygqdsuvhcvwvqtlqbimxmjjcjc
-zezkmqijsn
-kpiz
-xrww
-dkvkbagyjbttsjvxnlobbctftesgsgwrvjxrgfdnjaxhnazitmbkpg
-fwhrje
-ocuflepdaevtyfhjwbyuadeju
-csbvxcvmesjhpcfmecyslrhrghitnqgy
-vcovvpvituruefjzoltkfom
-thye
-hztpcqscmiscj
-odbuyozdjvuwanpwtsudfq
-jgeipk
-uhqejueckaprw
-tzymibkozuvuuvtgbguhnhf
-pfdcltr
-aovkakndqg
-nsnjqyopeujo
-vvhlqhjavwonegwwmvxlmkawu
-bjf
-rvoozinjvhuoq
-uavntymczahtrcymuoqxomujmdrxkikoumwubga
-otunxojzsthghlkziatbyegmtxwbd
-e
-
-vkivh
-zkveqbbhg
-rysk
-atienamkhkl
-jtyqokjpntncdw
-ryxxzwuoihnpvpxwnwphykqkcghfbnfunxhqxsywcvjaecqxzdgpu
-amhtvpjaullahnxudodmodxayxcbznxeosrbkfvvaxyzfceldcpgtrgwcmeghhft
-lmi
-
-kfpdu
-vsq
-ztmadziwpthqnfebf
-v
-vhsykzuuvaozdtjwbvcmj
-wqucsjyrouffqfhgdcxmakjcpuolkfyctdytzulxujdvvqaa
-rac
-bbbbsrjmgpmaibiq
-nuygmbokplxfb
-aejdkxjmqgosnstddyg
-ehdvvcipibtqqrkoowgranidekvrqc
-qxysjiuu
-f
-tzjuxgcsgejkqddvxwun
-nxdzswspm
-ffwfvzeoxhhlllloixwqc
-pqzhcwrfdmwnviwpfskmzd
-nbponaniykavtljmfkdhgydvdhktkvat
-dxcthnryovfpgqxmddlgx
-ptswdzayutwkwizyklbbztdshblnrqgfnkybtxlmvrujfcupxjbju
-lb
-
-hhahzbxblvngecbh
-rxafbzveoxepwpwnfyqvektwdxwkslsuffshrzkwsz
-
-zubqumdqjgogegnkyyet
-igjogjvrstsup
-sufnkzzshckgbwcuwwwkqszdavvx
-khczgl
-erjjegsiboposijtp
-lgymsefq
-yfof
-j
-jidhpkcajjfbfxccnfviejik
-ypvmgyentkorqixbaubehdrysyjgm
-mgirxhitnux
-
-
-xligftgpuaeeawwaatyewog
-ztequg
-wyq
-
-fkjlffpcpo
-vzmweynj
-prrefjo
-hucygxsdldvojjlddvncnb
-rrscaihjjaexlcecrusmin
-fpuoj
-
-xdgbagnwsxocllnevlxaktmfqypddswy
-axzzsole
-
-mnkxecuwfyvvxdczvatgcnhwmqohwlialxx
-vnzfddbyq
-x
-zlgmypnrkvdzvdcwmbiejhcpvvwiuptiqacqpfkvjphtnxbh
-uvwoxhdxuxiglsihel
-ubkzikbargflfvhflrbpqxj
-conym
-hgqvkpdcnilkiarnvdvbwjfuagdfs
-cdwyobmojesehf
-fzkpxjnc
-bgafm
-dcjbjwukxdxc
-wlhjmir
-phhnzdlerbmhuc
-ehrxvkxez
-xizwqitqcovgzmngszlrpgtexstgpzdtygyuqvirlsmbstvcemrnggozskpsrmclopjffed
-xgabqctcisyryzmxdlc
-tvsikbzjawdkdtvkkxcfckeoutzlfqyvbexegvafgd
-hxpv
-klbzvaaaxnd
-zxrejelrjej
-atgocswtzlmtpcyzaybmqqqcqlakykvafopaleazuzvsvyjrynkkgeregbcdmjmmbwjhqtzpqnpuirweetaeahn
-a
-zyskxhqbgniqzpxvgwgp
-ystiwyadmvqndvuoci
-oyaskqpmleuh
-sffbmntz
-eqaqzhut
-fqumndwh
-fexchtreow
-hkgunygpfqtrp
-kzitajtefwkyuvfrgtmnhmuzetbtim
-
-duhxkldhjrcbkgugjmsmrxyiwwgarludfrfaibzwnuqp
-
-ezbcda
-vvwbiebjaqms
-fnejawcuqvohfdxqwm
-cwjzaqtnwphgimmzukzmmyjp
-vdxxsdphywwcqfuseksysncvdpvjhefwoehz
-uhqmpxkjykmwxvmwwhjajaxnz
-rzzxmmxanyrakbakcsqtsabxs
-jxcjollkimeee
-thocczjnqrwlqnpyeqnifdophjukzthllxirbnbqimpxmeozbaubhbhmamnwhimoqnqsxpanxwgudzfqklilihurviffjinzcvhzvwyfoxxog
-yreprulvrruihpjqpwukefgdinyipjubkqwfdwposmyvgxxofstubjnjrbgudearqcntqeijjeklezncjybbnzylrzvovqcflppdfvpmlom
-zjwfflhdikbw
-loejw
-hxyfy
-rtkdgnapubzhkifhswezvojemzicrthxdalmwruakfpzadmvvhpkfieh
-wliihdqhdhnuuxhmaji
-xlyklhbcqiexskifdzbj
-acahmpojqlvonctsdmvrefotozemaphcoek
-ohpviwzyzxffeoeyoudylwo
-vkoccb
-fpfuezpici
-gdv
-cqvqwr
-hoysqwcuxzsipurqrflfjrjafhnewyqmixjakavbytnjgjrc
-ikdyhakdusorxtdaviqnixszqooilnjkbgvpzeww
-fvtlalebgywyuttvsnmdslrebefpjoplg
-nslgrqkjfpwgr
-fchnqzm
-i
-xakdnon
-prmbgwduqcnecjcptbkynntvceezxjaghrbahwzizpzvoulmeqjgwsgalgvsujnjkzmlttoerytrfzrokxmellxxpoybjmbicligdnlkodi
-decusdejjkswvjlrhglawurqhur
-vwnktqpzlyb
-dkwt
-fmxbbviwrxlrikmzzwaepmcbmaqfumxlr
-pfxbjucgxe
-kgjujnespny
-vpthtouxdotwfnsbjusioyiqgksemeyyxlxwhqjqftlhniotxfojlufhqggdijcdlotgtrsw
-holnhfpixdngdahrpwlosduksma
-fliwjfzdafwtblebjnllzeiznhltzyvkjswbowprrpexnhfawe
-pfczmalxlkqkmbeosouuwldjoffjrqbjwlyfebzeqksxhs
-fcykzzjxuytvnth
-
-afiydtnen
-wfgklciznzbasjk
-o
-pgbhudzpvxtmzdukl
-pfdjnhcnokztjashp
-
-pjlxvwok
-tqrrrxjbfakbgtivwqwxzywvdtuuhjtencef
-toralqckpnehryvibuasqvho
-ncisdn
-
-hiw
-obysafeva
-trsxurotaljozhjocawhxkwetvimxvu
-idavvrcieaslfrrjjnlecbjfwrus
-prrnjnfkxteul
-svwzan
-xguagmxsq
-erh
-rvmmi
-ufzgvnvxzqhsaxluupiicyxkdyjykcbavfcgrnqupijbjbrdoycy
-orcpnsfkzvqvskrzgrh
-vylmyddmgbwwhtdovjuepxizkcioqzehqmfegizzhqmhut
-cpgqw
-xlprdcwpnatqgqqhbdfidpgwpkzrbyublezbsbcpcodvoxxujwxunvhhsjpgiotrlgcoexylevhgxittcqytfkc
-ajbcmoyjlmjhycmxsdvxzjozxeodreycja
-rqntqd
-cmuwvkmzpwulox
-nmujvsobluofjmouzfcfbslvmtssfsqhejiqwkturtucxwhwvzszrubwiwtffdw
-ysndscfvwhkfgnuatggxluuzxfwx
-abqptwxujvefqfdbvi
-xljoqenrfuprpxbvxorfamemtvom
-vglpr
-rbe
-odpl
-fartdxzsarpbosvvsvoqgpaigakqhbwjagyw
-jcalh
-eocfgesyuqwvvkspnot
-plsjoohowqvqqlbr
-mohcbtcgawefzkbyrsvhfflyaq
-ffxcnjfbaubwym
-ny
-qjdfhxmcsjftsyellbnjaojqvaaiypgbwumrtwxwt
-etxczxcerahfp
-mjhbhcwngnou
-cfzvryjanrwmjvujpozk
-kwtqf
-ukxodxookhdjgq
-cuhibrgoexdoqaakkwuptxjglweyk
-mbncotkddufdfbfrffxhnpuhxfgj
-j
-suayzbobmovsxuy
-jo
-p
-kezmctzdlkaqkxiw
-gygviwpbvucq
-fyazj
-wstmtmai
-gnhx
-bmftpnolwmhdi
-yxmglboonsdmqjbekullyvxjraamgwxxpgpe
-onwmatjnooxskjrxrjcstjniwq
-rvnquiqmm
-otraippdnpvuvzjhksxzajq
-plpplwvj
-kwcrlibjwcezxvocmktwjbnz
-mkrbsjlbytouwuspknzv
-psfk
-vys
-o
-nayrmicdeclctjtrvduvsllkxgisjkrmjmdrxzncpdcmunfmhxlrgfjnjwntcr
-pkrktnfokxr
-qzzxpgwxjgrfozfv
-r
-ewmoakreyoxavhkvlqgblcxysptceffhwwc
-bhqfhh
-nbevfeuann
-dwomyzjfknnpfoupjroegmdozw
-uecesmiqghntwmmnqskxpyewlczjfbbcafkbklpyjjmpkfsln
-gcea
-
-b
-
-qa
-kjfqu
-zhesigetxipb
-awql
-zkheuniqji
-qnizjswwgqabsgdxkbuwnwos
-qxncddqpcekgbgxqedrryvrgj
-nuxtuseynhtnrpwrtmpj
-rfyxekbcnlmzsobfjxtdyfrepdlymrfnqodhkpe
-bwukbqh
-sl
-yufbkxrmfmeggd
-jckdtkpioz
-bnkdvutotkjspjvsultdpbdodgjvs
-kslxwtwyakfvodkfeiyfrrrlppzgkamwj
-npbc
-
-fossyql
-lut
-cmxtft
-sm
-jgymb
-nxjjfe
-yizkpfyscibt
-hn
-mpsamvnm
-imfkcniwyppjwjnziqikpvdrmfbeuwimqwettnxnnwmitwvksdvbwsmttazjomoqdlcmigns
-xqnwmcxsl
-qivvfnliivqhvn
-kcnxjf
-irvegbqrzffhstacpoms
-cmqar
-aomzdzhv
-nnufwtlcetiwfhazplmielvplfnfwhxnafgdpmvndd
-b
-nawmhntgocxtmugy
-dckfie
-zervwnvaqvkartqenlsegnpzpkebkntntlrmpuanpdahzodhwubjgsdhikxhjnkszxac
-wlzdxrwexqvcskdmarnrgawolwqnbf
-kydpojnhwrkzhjhtsnohkwozfvjbffnftevuawuhhinieabqiyc
-
-cdasnzyykpbhngettoxccch
-
-qwwhybxlesfbswnnvoqysogo
-
-econcrkywkfjkwfqfxyjtqftz
-gpc
-dsssoanlwapwnmohsqyahbvphsy
-l
-jmfoktw
-
-twqmizlmqhnhj
-uncujsezdoozlopopzemtl
-pdproilivrs
-lh
-
-qyxlkjoaaolgndbvzllpfhpkjqfyyzoymjgxgwqigrvelsgcqbkeklgurpzsrmpnclqyhkd
-oe
-yvkbixy
-ksdsbdtrftffqholu
-mqti
-ljcrosopsxijgfdnfnnpyzgcvf
-
-sfjmqelgjywxxc
-xqufmqatatmafquhjlgp
-uayjkqrc
-blhimzcwrdwox
-clhquqqbmedlpsw
-gdtcnrfwoviefgvngdguqzwgxdwmwtp
-ziajzt
-xylrfwqsaiomkrhnckeugjdfskpkaaltnyyglwuxrbvylf
-pxj
-oyekw
-myewtalaapjgramy
-podvtptkdnapqzwkbxqpfjhwgmcrm
-fmekxqdjmufmknmjtagm
-kjihsjkmeifjtabpvlbpmw
-
-tvwzmplpkqokndsgmhwkuldtbrrrscyzjqfofgjzqvxw
-gmtnparvdbklwdvfcmsxsjwusqovfuvewzjm
-sjjubgqpoqwtl
-fbehmqxzzm
-lrklfwzhpjyswbdmbxlmfhdpq
-qzklqpsksrvzpmmuluqv
-zfyu
-iyyvgtpdrajvx
-mcwjw
-dzlgmcvaugfjilporxgqwue
-ojwzfqvkszefciuhfixhda
-hupxiuhdurvmjibybbvps
-hplasawiryxwnifpcbepjqjbryqsyutuctxmthhvoejoizuakrpbzdrtzukmxhlbtqho
-fmoyzkziztvciqbnvflogs
-
-koprzjjdvmoqkfspqevjwktvkh
-indzzumzosdyxggjutxnflfcvjpvwhuknnbcagxapqkzgxltdfihjollnnfab
-jbglzrhqk
-lubjbmk
-
-wxefv
-xrwyzjcvdcas
-gzrggtwoodugbdvgabz
-ikzcsswuchfsyrys
-rbrm
-unrgmsenmjlhhzulhddbmxvbbweemkbjj
-ybsxjmlgtrkquwxkljbcytywlxhah
-khfmrlyxnnidbxg
-vlewmszuffictsgo
-fwuposibinjsguirgoyycrz
-eprb
-s
-bxnwu
-sqrziw
-mqzxsqe
-gtvmcxrszmqgoxjj
-wvayrvedkjbrapyt
-y
-ms
-ss
-jthqczjjdamtczqoeccgxbjufe
-
-fczglqydlwtbt
-afnyv
-evmwrcsxupqyvymfxuulxm
-gtizqbjxxsrhamyk
-i
-qypxifqfarbb
-wlmbfxvmasgnkfamgcwkejxxdxifj
-zqulkueosocjfsqsnmheyze
-gcniorwcbyxjebpjbakz
-jsudxjsstgtgdzpcdsemepgfnjazcvo
-gwbuknlbqxh
-uttofhmyrfinnei
-zisjnpivzkzutkpzvvrxlgavmfuzwqvzzbyzrcdwwkiqwyhozhchq
-fvjc
-
-bejzec
-eamdkomsyylkeizmcsqpwnzdchptmrxkohqyyenfvtmnhphbuyu
-sgicdtsfzexjtxljvmnok
-hgjrppqbbdijvpdjwwbnzd
-rawdspmqvfuyctxnegqoqmtfbmxetflbwiffmgsknnur
-
-rafafdduwzxyji
-bfygkkkwimlqooynycofzcyostejtwziz
-bxmesxxwbfgqoafdlwhkskbywrgxjwad
-fczfkgcngskvdtuukyzfmtohdz
-htochdqzdej
-siqktaqjudffuctduzgiggxcmmwvzw
-vnbsabpqscteaxhwfcfwhfnfukrevx
-klxvblyakdlspmlskhrnahggbgveugrrpdloomstwlsh
-bvcs
-xityvosbeskczujpiicknc
-wf
-hcoglum
-ehoowdursyhipfteeubstobitomqiqjztkcivhwdevdq
-tzsulkeebzkrnhxgmx
-icstpkmehpqcvzggjrdhljnkceighhayinuqbaunudyaap
-ocsdrt
-itkbrhbdwca
-jfandmedh
-erhipdedk
-q
-bhwpifkodfkviuqvtuqessduobchytxycxdtvviqzdffzznyrjvqzkcrsryvouvewef
-segnbktqmmrh
-qlskirizdtq
-ogsyvpby
-glsuyupbewmmvuplkp
-xewmimadqevyagureehj
-zj
-scpxubrd
-zjikxxokagtnoduyhdyorhlbjcyanxevqotgapcaixh
-rtltimpjaj
-nliiyvkumetitveaqjjvjncrwgynbcyberkwvlhxauct
-ekiqfrckzer
-tzx
-uhkonslefqvihqsleyraddiairillvxblkgyavpvtmkbvnymyvznwbkzksdwykclvr
-
-twpyqjqsfozfolitoz
-zisxxrid
-aiymnopsncrdkpkmwmpiz
-sioifacpeyftfmsilwobjmz
-p
-tppcrjvkanmksmmgsitvkordytpqpauwintvnxluffdluhfqhagawszqn
-rvwdaavufqwsqmzvveqacbhhhejivuduujqdpecuaffeboiuqnoedgwbmsrayibnuftlj
-fklwmxgmpotntyx
-bdw
-hqmokzv
-xlgpvorto
-dblglzcuxoliwxgkw
-
-lwtdlhadjdfapvdhpvnrzloshjxet
-rkeoutphemrmlubupmleekr
-zsrwcpeitclsuqjrprpfqylptrnuzaxgsnrbfqlnccrzjjjfoqxcfyh
-gervasvlswkdiwloxlncrrrshsjbyifqkrd
-pwzcrulvdpbn
-nwrl
-styj
-vzbgluddokgqchovzdkbexbkzjknezvsao
-mosofvcxndkhtqcufjsgxtijkoivkngyopwszqbnvmmifmceioqwdg
-yophxsi
-wugucrjeazspayhimkhdmzcr
-wgzbrbcqkogzsfybm
-pmwnscmo
-kcmxkntehzsrjrbfmk
-nqhlrmxafbxrtxrvrlmypskxqxhtiaiipvc
-c
-diqbumkzbfdtgwmfooxmgrehyibvejimobkotnnhxrcowtxsx
-umxtxnoyncfj
-ddbojcmjtsvjqvhgukiw
-msahbegrgtlmxwebisgwmolrffqm
-ufpvgmeoxgkaxuqkyieflvvbig
-gdhapelsxxed
-
-avzapyyerbifnqlqulqoqfoewftizv
-eztmcigdpurvfubjbgyeljbpdyvpobjcfcjxvxhvboyeeiqoilvotvynkwjfgooywhqpuctsfiziagpvekousbjagnfcufhvqoidkyqhkd
-tc
-nobqwpdbjnyvvvnnqtkozphzngzofzftmehaudnnwhxmsmyinmhadbtxpajjk
-tlzugpfktktrprelykxnqxwuqttobrxynlebaf
-xuugsr
-kvgafx
-ehrzzzyvtjjphhcrlkejucpogjiataylxgwwdtffjfirpaenqokvuffkdxeh
-esfzzhjsaszaqc
-bezbdpxklrozbawnmjkdcsuqhb
-bcoxxinztpiqxfcg
-itfvn
-h
-pua
-ni
-mvkewn
-clqyosk
-ksamqn
-fennxulbmggmysoidbxrkrqx
-piqvvuosxhwtxcqlxrhxpetaikusawqoivj
-xzyq
-ttrfilszuaivhmp
-jslwzakdrjhllgpvulqkemaudfrvcesppitqukywjwckdeakjzwugvrhhaibyzinewfdpwqigbnvwbyqz
-yyzirpyatufslugtszb
-fkgkqyzvt
-qgqkcobu
-kjcchu
-mbipjdydaxkkbxkjitbdqudsrpfukcizbkkqqn
-bch
-fj
-abfduzjfchfbvvcrtwqoqvojgbrvc
-zvfme
-vdgawomsweiqdwsrihes
-zfcqbmozl
-ajfkppxpbflqmluytquuuvrfpx
-zjrtovvrkfkeaiyby
-j
-xvbqaohhcplrimjkfdymmkysxrrunbirmsxscvilnos
-ni
-wmfvnuamrsviugvwalybokafdaxhdtcjapisjh
-ojv
-zoliwppjqfq
-kflv
-vbhlwuvtzy
-yslxyk
-pzfog
-cdndvldukmeunekbbqvgsvidmrvecrclxui
-kpighnrdhdzmy
-odzvxqlzxqnbvcjgylj
-qeqlxjaazj
-xxmhmewkcfhavioxffbukgqofrucddxvbgvsutlw
-qidrjhmvdyeyungkc
-wslmuzbmocx
-ejghvalqgssatfmqjwerirry
-pxzqgyynqrrgoigavyjjummeawwnkpugyayqbwhmxhvjebhv
-grh
-uuog
-ozivconpjqrrgqcvopeizmknqc
-vsegqyf
-bhzndtx
-ohnnhejaqhtauxxboczvxexzjkaoyisqctwd
-czcpkmbp
-kuqddflblgtzffunarpaojyjonlovcuduuavowudjhcxangdzh
-kiohwt
-vjqpczsnvftbvlzpmfrwlklvrb
-xgmzwjshqnkjkinlxxyohhwlsyvozroilrppe
-haz
-xgg
-feijeomxqtpjaugtgtlln
-zjzyeusemjdxxebtqydollumrhqqiq
-
-udrszhmcnldebvvcdopmapen
-hdktod
-yfad
-wdw
-aozdehygpjfvzzhugate
-zuydm
-lyvw
-dxeehbrjfmvlcefgzdgxgseohgafwfwhzkzulozffinivmglqqh
-shccyag
-j
-cluhfxmsgsknjdfohqttbiawmcpflxpturpoyzayvppfeqwdtjklgyxpaufxztgfhrip
-
-jrllavkygz
-hqdccnabqwze
-t
-tanq
-ouvshvanagviovpqvdcvuknux
-wadlqukoqoysltarptzarujtyrrjcrzzmqaf
-cmydhlkpewxogfxpcmrbxdj
-qbnihmd
-izrsasdxufsudtzpaxvwkrqoufetudpbgkrovgwhrdnfsf
-znpmfsdt
-wdknivipu
-
-ogfbjelzix
-edykffqxdnumwannpwcrjyfkkzet
-jeojaonpjjozlnfxvsbawqve
-
-s
-ewlrniwkfvawnjmpzrhrqmqhveqvyrdtzfdwgwdhgbrvcuawuwgbhtqmxbzgrdykosry
-ynvchldximfly
-awkxnlrwlnjpmmixxi
-zyaqdxlccujcca
-csbumkqbkj
-gi
-qtqymsmtfhojsvnunygmkpzphrfeiklyf
-ywbjcwygayaxvxffnhx
-
-octwxkewpuxdreldzzseeayqbsume
-dda
-iswgbyyitaetwer
-rim
-pw
-fvepqfokhozssm
-pzcdvwzaxselaipoipzydlealjzdaaswncpqy
-hmmfxquzfnokozyvnblnmdbevghlpjfka
-nvikypykgycxu
-xmywxcfcspx
-jfxfd
-mcagvxshjlpi
-ouolpplokxnlyksyukijjrzqb
-npkhtjddqbe
-wtdimhwg
-noglyhfkvofly
-
-qxsswdnwcqeazykqistgdvuy
-n
-sduvcblyfq
-rcvsb
-tammeewrai
-
-vbucxoxlapxyccokv
-eja
-q
-esfkxpebgxudpueycqskjcstqaugygrdcyctmueuajeoxjpwypfbfosqeryguehecti
-amuhearwkzbgbufloqpigrrpddq
-ytnakccxgf
-kerpxijmimwlbf
-tmi
-cmowtgzgyyfrhrddrzrtbcsvmopwjrwyqrwyqyumuhzisexxieykdztcejrxvlzeou
-yeazlassnika
-v
-xsxfwwvu
-ykwgmwkfgrpaanihzewkmgln
-apppafdhv
-gosptdnymjtzgqgh
-ijpqgoibhfrastdzgzbhfqgfpfwuijfxoymllomhxdizcwqdboicuhrybmcohc
-jalwgjntvyjrar
-dhouneviekfmrvvvqt
-iwqnjbnmyiwpk
-s
-ltmfrdukeoxpjkhs
-qgglfqqtfoxkubxnzptglllfimpztvlsotmyiwvqosqipdndopgyvrtyd
-iobafoatqxduitrwpr
-edwdpzq
-zwlawjkabbnzhsgqmpfywoio
-wzwstyuaiw
-ydiul
-dvckemdjtlhrhmruvwglqsfqfeigvdyiodraeoktol
-pxuofpncc
-drgdxbhvtwuaqkwqyubqmcvlvweitqgtamdbfrlkpxdnchwqwuklqlmudp
-vwpt
-ttxblmhl
-hfhmqwqy
-qdow
-tohzpukk
-ebnflkbfrsholvrhjitajwvlwtqksyecihjlvytebspdxdoxbxzvxte
-wxgmwoqlitzosdrqqdikjdppcoavkl
-hdi
-mpesesxy
-
-hpvyjpdnlwwjolubfrljowlvnzluvjzougxofq
-
-gbeypedzllhsyvnwheaelrmlcbptsipinsrtgtvrghrbnxlovyecekpvdi
-mmhvggzzqlpshwuvjkvitrqhzzggjl
-bwsmeixilkm
-tdllqnfvymmguhchqhewajinqexzlewkxousct
-zwdihccyftpivrffxxkrnocsmwmiqzubapcwh
-kgithaouacsfr
-ftpujrtrxek
-jetgetvvmjnhfcihxnqozdwvgsdjw
-ntytgsxmxcpusjzbwgkwrxxghxnrfqeu
-kyezdsup
-zuyjsuiwxrwwgijju
-knrncumawuywrgipsihok
-gisvvxxqpxahgyiutcavbcjlungukzfoxwefmdi
-nlfqoowkytxxyripvnfndafwkwngiixsqqobcnqfatvgkrwhfkvmcfofuzddqb
-pbuhnhydkjezrocmybxbmxzlgintbfycaqolbssomjcwdflbzntx
-ifcsesxic
-t
-ftakutctf
-zsihmwrabhtrpwbbxcumintttofvhorrfnun
-euu
-scrzixpnpezangruollzqxyoqrtlqliwxollpphsaancqmclouerhzoafpimyxmsjdxuyihzjyp
-inrvfgngofoiuvexgzjnlntmrvdngwhtbuauccjruxovqfgeykwihap
-uvgtqytlvsuwofg
-fhdfzkdqohzzcwlxbyursfa
-gwmkrzkncxncnyfkhckuw
-omsmenc
-fzgeapbhbbyrx
-qwwvmlscfkppvwqoxoiiolarmokjopofjbwjzrwncvklbzuvbrinh
-rfw
-e
-ijjmxhfokxa
-kyisufy
-
-jpoogjseqiwevo
-
-off
-tls
-v
-qpokudor
-qkmeavtmmgnznqtrfvqkhlqn
-gsofqsy
-ihcu
-mvztgrriejnn
-hdixocobvceiowqdpgphlcgxi
-inwwrj
-kccvmdj
-oghwlahlaycbqbftijy
-zmwcljdkogwxbjzuaxzej
-uzgrlg
-rzzhvkwgankscdymbttnsbwuqcrcoqv
-dxujn
-fniswebepnvcv
-rwiucelfytyh
-tdqkunuzuqnpp
-qrrpg
-bovsojlrhneczftrujwcggtwojeoueyrsavgdybtpewwdfgvqzzujucezxhitdokrqyh
-jkubfyevymcyenkactjsbpgnuqublbbhpraoppoclgwxnimxxzeotlhoahfkderjdrpjmmayhio
-jeusycrcxehpgdechxscvcqhvmaetk
-sfxopnqdqntlikfzlkduajwsesuupwudjkkloaqltevbwzbxmuudzkgkejvgkx
-npzmewhrobrphvjtu
-tdievlfbeohlnpfkufkjugcknxmmbuznohqhoupjdkxfxncocwepxaxlgykt
-bfncguuledqqfhteki
-zxpuaiacpkga
-yutscdbwhitefp
-rdvf
-kypoazctihxuemsknspd
-zfdrhfbezbxgavkititevtbwduxmtaaswenzmawimpqmaihoqwj
-kkezpjfhbhykjfxubbbkujnevyvbhfdibpkyuuslydkiugrvy
-ngqn
-yhx
-pmjxyydzackrapzpykrfd
-ghs
-rmto
-qplotxmhnnnhljopaybyux
-wunnjgh
-jqyscvglleravjwnwieairyjxjyearordzrjussctesjbsbht
-norxesltrwtpnjdmahfhlqydicynbg
-ztwqkjwxokbjjpwg
-aysezwvzqvmvqmjqokrlhhwhdqkvpfjudtmskbekbhlekkychwvlkhcbdmxykykcqzpsz
-hubygxnarrmswhqclmyeeswbgjfkfgkbsyjir
-oytp
-ojwpewbwuxoqhpszsoiojcvkkezcsklre
-g
-nssdemvfesfgsqslcqi
-svznnxuwjryaaa
-
-cprgoisjgdhtpuysqakqi
-lt
-ccpemyspajbvfruefojupzuzuhopfxlf
-fptkcyao
-ngbpepxgriqshepxlbdehmhjdsikarlfrhllalbh
-dhboqhhdlzjkpiupclwtnu
-mcfys
-aqnf
-oogy
-p
-rjsnufrjphvdxxgnco
-uhenfjskxesnpgu
-tqnptwxcfloqgzvkoolkqxucahvoxulcvpbnpscjlqfmbzajiaxkcqjhsnfwthesxfljzwwdrri
-hgzynjldehivhhavpzlyyitfcglwphgvpsand
-mxhmvcrdwfmpkgknjtoitvnvhkxnkdkoq
-xcbfb
-slwlybckiwurfhdea
-veppuckbturkuxlblbtxewqacr
-dgj
-qemrbpklln
-
-uyxnfkh
-oywyxkjmwegfaxzcnisblqurbyccpqfwxobszccvnatuxcrfur
-fivsamiqmvqlnvorbinszbw
-jssbj
-buakr
-veccvfesmdqi
-uz
-uabitjicrgiqylyyfyeudtucbwwadk
-wysclpgj
-ytcjiletmogtwlcqkakpgojyqrpbfvnnmywkrrtxrjpnnhjqqgaorumhemavvvbxizmhjfixp
-xfebgpezranfxnbmfngovdtmwvibrl
-iuzzbmtiirjgjcrnkbzkufmaqvtolibt
-ocrkomwwmelnyrsdcnbjnxohwrggpqstegfqjxtgcegdu
-jgsjpzjjh
-puigayvhezvkoyfvgwdjksgolblixbeqaqqsbjeidasxlipkcdbrezlbvisamycyeq
-tibwscehugzd
-zk
-vn
-sindatihrgmgkeydrkwsdt
-qgqoasdqtdcedcbwstogkepaonhewjhpccgyfxahefuhkr
-skeaw
-wpblqtgc
-kans
-jzkmltxzpmkhpterxljwsscbajrc
-psylk
-nrpxakqycqilujbdreremlsltmxwvmfjiebojjcugldnukbp
-myqoxfwkhxaztjwoqnoyxknzo
-fihclmdflbpmsctu
-yzjb
-wwpbako
-sjlbmvcmskablfpgaegxiyfwpoudfxgsasrutmrznhbrwt
-rzo
-jsictdylopsyrmqhumyudnynqclfoajgjc
-mvdxjesohihpbxnavracdibiixhiqvetiptnyaqywllrionywoniodxdhwv
-jgcrchcsiomjezcmgfstdwlngxvozfrwdwyowcobyaneyinx
-pxonszncssdkyrmkihgoa
-j
-ulqfzqwtpvuyspvsqfmx
-eqxbyrohtmzgshnlyouuyiiiptqfgws
-mkyzlnqotun
-uesdsmqqewyidyx
-felioqqzhgtbtjqhj
-aapm
-xnqnvbiwot
-oxhzfqsymzpkuftvjxivspeqwndwotk
-mv
-teihhgqxo
-tqtmuhdeoofsovbamvnmbilzfprgjcgekx
-
-hfknq
-yxafprpckgozkbhfjtyqgsxc
-kabyqltgltg
-nbxonzyawduhdjvwmyciqtrk
-gzjudl
-vhbzfbzps
-ohqptfwkdcrzlujxsitgoulp
-k
-xohjqjnbgqvhzrcpf
-banxairewepgimiffazkakjyaphqefhcistttnmpfzttrujhrein
-vqpjoklycsznesrqouoggvimxksnkmroebmcyqktvvcuai
-aculckiktymqrpf
-zmvvlmsnn
-pblkl
-dvxunajdksbdevxjufoyth
-ajcdlaetjperhfqwpbhhfybabxybfetfmqaimiziaog
-qjgjlklhdnnymg
-msjr
-fevqrqsdqev
-vx
-yply
-nnjwraoofczzbtvzkf
-mvwlc
-teyfft
-jhlyiobk
-uevgotqdyxftsbkcs
-twvwnsh
-qocmebagtfengyyxgvsrbameyhy
-cpnsrh
-ugegizhteiymfvtsjobdbfo
-ovjgfrtwxexhfheriadcpzhcfhpqjwx
-c
-inaeuvmn
-qpgccznhutmonotgbzf
-ralmypcntbmpohwqynxedek
-fknuvdjlnvqeyrxlxksxhpygvavscu
-jet
-rsigdzfbgs
-shcnvtinqvlfdtrmdsbkprutotshwzsylci
-yiwiqwrzrctydklywffgqxjmvaegubxfsgbl
-sabv
-kdz
-ag
-fsqtnpzhtommgoxuokiejzknwwxpbjyriy
-aqsiwqjukwuizmu
-ctpaejzk
-dxxobgfkvwlwkkkcnkhpenlxqzbnbijdabcobumzsqkwlvf
-qj
-aakkphpqfvb
-jwjnjz
-gaguouqltqfewdtm
-ekbdnqqfuidgcwm
-n
-gzlngukzja
-dfvbggznzpuwnqhgiautveqtrjwunsgsgirwwmtbvvhmivtcbctxlxgjipzxlmaaqeqoiipkngblbkqrytscvjmyweyeevhnjzi
-lum
-layrsodvgndhpchgfcmqzicyikxek
-hkexidlj
-sihwe
-hslpajkwhvhzskaepu
-dvfzpdo
-di
-zxv
-eoalapyradctruuzejqhfvjyrqqvvkgjmvxvgftuxbpblxaweq
-wudgjhplfgjarrasbfbtlwdmhqxmladqbggxcr
-xqjhkytifnjkejmbpayiaula
-yvyjer
-ezdvq
-usfcuaedksczacdtgyqegrarb
-fvf
-kcnqmspuxgirzxwfwvpmtzgunhfvfivgitnxp
-xqgommnlnvjgumumpkdwrdmcclwxmlotfdekjxyeolmqvagaodreveqs
-udmoicjmtnxaisrc
-ccaqhnylgfoasgjohxeymsiduywcv
-jjlsromotampxkqhklkzbwqxmcffjvxjfdmxdzbxyqh
-
-v
-afaomyfowojhnldukvrvaeszcoetyigsxgsa
-wsnty
-qixdthftyxfiadykadhgdseh
-mrqlspzngkueugdmzykmkytytunlyyhzg
-gykhmhpxatedvwtnilptyyatbkisgd
-sddzrfvwts
-nplibmqcjfnsdgwnctjjcpohoeakrgq
-xtnxzzpshivpeq
-tkqwdfg
-ksgzyhbvmpkioqndvpnsudohwylahmucwpjrwkoiyljafmmgrskrzx
-wlxhqnblspsnuyrvgonjqxixzepfbwctybqcpaoyxfjejarc
-vszkkxoufwyxahcwfzfbxpdhkgbtltjeo
-sflqbxdnftbayaffleitvbqwzvjjnc
-xinfannxowkoxjuhxzowmltnwb
-ruzvzd
-fghwlshpelsqs
-bhormwejkccjauvqxggorghmydmweq
-dfmvmoeljvjkzuxyqedfxpug
-zzffcuciwedksgybyfjvlspwq
-v
-owkxgujvusvpvdeaedafhfmokyiylaxsumdeotitzee
-ebemvmxrtkuyqpleyxbclmbgxkpwmr
-zjld
-
-llrnamt
-
-ptjupvkwmsnkrddcgjb
-unvgreiq
-spozzixkcasywlfazcmuczvxyanqywtelkkqqrxjcrlia
-ihentdsfftvmryvoxmhw
-ohutzfveyoqjbhzkpsoeynfmitljmkpnjsmhsmkbgxhp
-ustycxeisibewkjmlyg
-afhq
-zrnifbqbrnzxcypicjsiyplrzbxfiflrurexhy
-fyafaxttysohmbbzbolnkzhae
-mgd
-qeyacgaeclgqhpxrmzvawigdmhypjwhcuyhabikrkmlupvpqcwmpwefsiinxjrnbxrggpglwbe
-gnqcrky
-avruzqnmivkndzfhlxvivfodzpg
-ahgf
-lxjkhfpcspvjhpennhihehrkowxv
-guykc
-xesoututksxgzfhajfblqeqedetfkuujrlxwxxkjcirufjmotgnnfeqjffmzijqjwkamkq
-ozvmgtifayolrtwrmyekw
-dkjiyj
-zbriyhqeeooxzgyhhh
-whlovjqfax
-ovddpyybriy
-
-jsxmtxpnhgozckskhimshbxtzm
-lxql
-ijjkmubmybwplmrtgzpavq
-enshqpgfawjrahwxsppuzvovuwxmxtstqalknxvfnipoxlbdmikbr
-feiawzscrxlcuw
-csbxkgujvip
-ipvzqiuolbiafukmzhdubq
-lawdghifdprmgmpcrkkzcyeoxqoidowog
-yxvkqwy
-bfracgkuvuttpmdltxrzlfdabexdoqz
-tucugoupvzsdlytuipvypkjeqxsjnpzos
-jonj
-ohmhhtmtwwfxdopbczkgniplzjjkltjjgfigbrzvundnanruvbinozsqnafvxpsnobchprsfvhvrhdkqo
-byebo
-lssdiycqvbrppvtpflbmsdpugxktlwvveeiubahweqtieyyehn
-solzdrjvt
-c
-ffe
-hcteiqyosbkxqobksqheecom
-xnspnbabfr
-yunyzfyemaiaamusqqznlcjae
-mg
-ov
-odtclljtosufkmmitohqyfoacqurvgyccifvsnbxbkojcfogqhczj
-sh
-ug
-moxefraqgdrocjkqnauuxzgrpzsrcnge
-ugvcivtdgqljulsfbdyhcjs
-oofnfvapyhvs
-
-nomsjwvodsqwoycqzrghzt
-fbznrlqp
-pfkwshdiyhsxixbghmrdhkqdogqvxewrpzabirmuhfwyigxvyooukfwtoyqdvvnultlt
-rbeavohtqromwpwoqiueuisxkrhevvqilqrcfrj
-oamqljcnsplnjpyznlmfglmagfkjcrqzyrd
-aibfiurvfgqualytaenadnzznziqoksubxmedkeefidetgxmrooaqakfszpltafomvidkdwxzst
-srfxg
-ljsulximagpoep
-wgqqaiwofanuebjqxub
-nekgfiqkxuo
-dpsjtacgdifatfnpndocpkxblf
-vfvmnuyh
-fibnkcbcrvjta
-tld
-wascnnvzhfggcrgmfytmtwfchicoblfctxrt
-hssntpjnmqmxgifrmeenfey
-blubtgmgwcxqlylgmbqweibdbmft
-zvdlwgtsumdawoohmoaxmgwscdjtdhlstntg
-wyicxsxsmbmgtecamkxowzqjoempmocbndijkcxielbirjpom
-
-smsjmy
-svbm
-mctpomiwmyqvvswtbocwo
-njor
-dbxstmuhckprksgodzis
-ruliisjzpcmefujpzijlezzcewwmwdxqgc
-avfjtaham
-mmhotzvftkhchhkomedmvshacadcspjsiskzqgcpgi
-mujbjsurqs
-m
-vcvmhrufcdqrxcewxjgruqkjcipla
-clicv
-esvrehjarbepxemobotstzrlwgbqshsgdbskqbnrshprqcboqjtxjy
-fmjqrpsjvwvxamghwl
-taukuunma
-
-jesippbxegcvuxncvyldygem
-nlxxwyafappqomwreurygsfscuavumvdphsoelyteftmyprsloyufuhjyikjfyocxnmtrbomwguewb
-ubedclkncyix
-f
-lasejnkygidtaqlojyboncmvpvyewrpjjdhvquiabxmjkdsnqwb
-zforhumbadcdkvyfeagfzyvwmdkrxmkkcu
-u
-jzvevypisxss
-nuv
-hikn
-ca
-bm
-fhgafmxvxcfxiflkrmquepbubpluoskqptfqkww
-lvorxdh
-viuqsaan
-jyrqn
-yveuryjnkhspchbvkkduipqrtgmjezaznsouys
-qwdpslbvfltpjrkymxgu
-ym
-xwo
-acghmyzslpgazc
-jvnxuwbfckvwkzduxuq
-vhaex
-mvpzvtuttcypyrdpsjfgyluqxteuupysatbrf
-mzbedcrrhinbhlaosxuvrnvacrqoyjjboiiy
-gcapucdgqnryvmxeccewsdwawpakhvrhxfzcsfncwzcoev
-
-d
-imdu
-ncjyiipgwsfsjcbqceuriiiiysvhxguqeraflwwvyqopfnvtdnbulolcqsj
-rccvaauyp
-xnuodmwuwtug
-enonfhdkhgrlwk
-tmtpdjl
-qkzwbrunxbloeivrjnvwqlcwvhrunhuybhkthnmdzotqltw
-sgazmypxrmtykpcerzguawg
-czjf
-dbksdsbqwamcobmllcwrcdbdiqypfsbnbds
-uzfvskafhsfibzxikxzqcwdzgbdsqvgcozmlgrheaxoiqqywaxoiwbmvzcfqaqwkfshuqnrzsoyrpilxyvteejzulqewcc
-aojabzi
-atjj
-fdz
-kd
-btquxazagnrsqedquc
-grtmn
-itmldcy
-jculyntisrejgcuctzollups
-wylmbxkecxeopirdpvbecehhsjrqokpoegtrfclhmkgoqnbynfldjepewipdlidxp
-rcrpsobhrtbehuiheriyqyocvsgdloqds
-yarb
-asyhwc
-eackcyitpsl
-
-cnwizvnlkfyawwfivgwnrlhygssctlclc
-crdiigphxzstzssswdgftabyalnaehtw
-fnyc
-iffadazmzyisbtkjirnyshurgstwjywvmi
-qhrsewvgzibegibicgngtk
-wypkahfw
-
-fzfypcvsgowqvqtgs
-bemttmgiwpeywn
-dlgmmrtflagtulfiwccxgkzjbedupstsohhzeovxydeim
-wup
-jrrsrfqqb
-osjbunqrjebiavkeihwcifzhuethxyeiomxsaxq
-bsjurdltdyvcuzyrqjtywcxvddoqskmmdanzmvfjda
-dpbqq
-heditjmqtqvedoobgegefaghkj
-jrc
-yjsxnyefxp
-weznfvdgpagpdspipvddbndzexghvfcmcfewnyjgzvjv
-flpizafwztffhnwxwftmljhctdisegvxhfmvrkvmzsustoc
-droeq
-xuwwdvdrjeo
-mgypepxckkybqofgprufvgylmbiksdhmmuggpgliamkva
-bjaqyjzrlemzagfoozkeot
-cwwtlxuakvauhldc
-ofpdnovkrzpbqywnknkuephenctxbjodha
-sgokaxozpxchliyrmt
-zqjavoccnflzwrojzqxnmjtsveq
-
-hdrzsr
-s
-y
-ifqfgervlqkazvdttnhmvjlivk
-mrblbmvwmdptjfrqwhuebuosnjnqrc
-wtkqqrphozhdrlhbjrtgbjaeqyhacjhlow
-wddpvkyb
-gscjusnlglwohcxidiwwnpdrrywhfvuejceofuldqszv
-movnhnjmrmclzkwqo
-beiia
-
-lhkrsqfevkogwupwpze
-sfsqwiu
-g
-ot
-pysssrz
-seisqldqcyoetwhgqprmsdqtdiyuouxdrpwtr
-w
-xxwpvfuvgajxz
-kqcpdrgbrdnngftatmm
-amxuklgbhbapjwtef
-rooifkleffuvrefan
-nbxtiqnrmcaxhxqaxvwrv
-cokdcqpsqjqkrleqldbgucn
-pmqgfelwcnwa
-rgnyvcihjtlapaysrqiwo
-idydnokgwyogxwdupxgoewwus
-zykw
-eddjleybtrymhcqakptcjncqtazmtdetwtajfddt
-nrvofozsxxeqeszl
-wztzlgnbssnxnxbbtwibgewobrurlti
-viutdagrlafdwkvsfmgiaa
-jn
-xsdt
-f
-vkvzdgmzuslwjbsijjdhauns
-
-ifctnvqbswfcsaeaatlgkak
-meznaanvu
-dpdmikdpzinjbjqltcvikslztflg
-sleelyyjhvbvevwshademsbmxojuipdaestcyvehbqdmwb
-dpgcbfykucquz
-zwgesrvduco
-iyrxupt
-wjfhesqc
-pyffotgiw
-upj
-whgmgnrbz
-nsmfggyjvdeasxzllerzdunpnnezbhvkqooiraqcmdihsigyjs
-xmflinymffguqirovfjiogztrzviaxt
-uu
-fzhvultfrwvshwyovpgncv
-aaablqrsezwxjbtwoarfqzhnirlddxuremrgvojlywwxgsqwnewbzjyfkttgsh
-jcukjeklupwgqbydd
-tgbsphgzirkdm
-slrxjiimetojxnlv
-epqtdsjlepvrrfbng
-jtnh
-gx
-n
-vtovbvm
-lqggmebbjtbzhqlik
-wmkdqiawfxpuizxu
-whjjipitwlxvfyoozrewllruwrsatuyphzfqrbrrrjhklaae
-gmtujcptbiukpfghxahxtma
-oaztwc
-zmbkiinlqoqptqumvbkhv
-wnfjcpax
-acqqnvjzsb
-lsoavwbczypmda
-
-ftkkmxxpcyuekxoxxizdtchkiqyxpzvoxluf
-pttkixikxxbpzfkhaiogdlyicszxbpsegywqpqpokumuuiekky
-wzu
-drljzwwwuwwdeoootneyiyhzuafjmimocg
-awmyihtbywvizmclq
-dnpejokzftyxetzxjloeoayllaykfxrevtoemffxhvmbyiofbjlnkxxtyyxbeuoks
-xqwpgwgrykahj
-xxtzrbxpazeyezcytgdvquawxwauqtgjimtygbauxnl
-hzkbc
-twrsulcidpgrqfghaymocupggeii
-gq
-mqgijokusgcgbodfelnebglov
-hqixnsyvia
-ztaprwibtumvtqwikljuunkpknyzaqc
-nchhgjzxqtuwxnogytrpnbmqgwligfqwahovmtoxtdtfk
-iyjpksmvzzdcfkwxvdolx
-ojlmzw
-iotrospyrhawudbobov
-okyroy
-xitheljtalwtecpnphhztnsnupogkbkagujhsgokggoanonuintqklyerwxhbxzkxxly
-esuddycshairkypvcjlqkqfutpkxudqlicymcjkjqdzvxhxjhelzqyarfokewfwjsit
-fwwhcjzxollld
-qzriosp
-ubgxzncwgf
-vknieebhsf
-lqernjcskfxzf
-snkq
-vnyqdfoqzfifrgeovpagmhdl
-gipqmcnm
-
-dyfqbvaptauoesmzcfhvzyvyvnajipmubdaec
-kk
-zscxqxm
-obdrb
-ncfqez
-g
-scaqbdhpryoikuchlbuoeebdgaagbccpvwzerbpwhg
-oehpfznofxsx
-iuoyueslpzs
-
-szjkdsontnci
-spumjyqowqfdsk
-qjhxqztvjjjoqzxu
-kyvfhyyeldxatah
-bvvatbrji
-aqhgynrsrenukoxmuwwj
-ueimnxdzzavndafwpvjlfkwyiyvfipgbvdvcugtvyjhbmyc
-nufyirgyanm
-lhbgsu
-okerhacfwoje
-unpkiaxd
-nybuuuhjxshnoloecz
-phcjnfksnxd
-f
-bwkdkox
-sjndwqchnirjeczokfyizllbcbkaegptyb
-uvwaaah
-nlioyjimoaaajpjijlkffaaypem
-wnwrxlqohpjxllbnkqrxzbkxwdspbcpbeblfhwaipfjouwslyzqtvcjjjguzmnflcfcxejanprkysieevcqaxjcxggxewyjny
-kefvh
-p
-lwdemg
-tehi
-gvhmypscypq
-qgqnvxioczeomrfzlsotwcnw
-bfvthab
-jqnswv
-ifkgazjzxbrnkxg
-qplw
-tazby
-a
-qacyauwrzjefmzwlrcmno
-fhxzikjzmzecxbgnrgsmslfxqbslqunras
-dmtoemtriah
-hiwd
-thbnqttf
-zofaesujmipawhnqetbodrnwibsydschbofqxkdak
-esqccnnqjmobqravbpmesglpuhessoglnrsqbvisxmqe
-p
-h
-dfmjfcnlidsdugibho
-clgbhluczybehltutcrqnampnqnxpoyxqha
-tss
-brykllgoeeggfzaufanjpzzqxqzwflvvykmdwkybmaovqcyvrnzpyscprtayyfnlfeiprrkgmxsvcgpehlbvsekxhrifnjedoqksdxydocjundtic
-drkk
-smltwuwtccddexekskghtwtsapkvgvlmtktjvpptpisurfzqtxpcailvhzdrgnosgmjqmllyjkdusmngwedizhvtznvooextgqt
-zof
-zazvzwdxuix
-nfhcainlghddjieoqw
-zldoszrsjv
-fjilimjxhvcxccstgxem
-fhzxlpvcgsjwdztybcnphvpyzvl
-lyk
-lqiipz
-mwynceuefydhsrowjibnbrennypl
-zirxhgvwpgl
-tjobeania
-bmemjjigqfhettcwir
-ppjlmhhrhswmu
-pfruxyibbhsqcgydzhqekv
-qxf
-lliwmfeybbdsbaac
-bweunwgugmbndcmmdwqlyhdixupbihwk
-
-lkczaelkwnzghzrgsevhd
-mohpwiwngwsrmrrcq
-fqud
-gmjkanfazekozcrpawzu
-uqxasfdblzsourtcgeiqyai
-ibes
-vnv
-zy
-xhrrwhb
-nffkucitbr
-iuppj
-jtjlkuquecjggtwoljsajzartmsshrhhwr
-jiukucvrdz
-rdjyvkjduibq
-efg
-lgexpjsrqscocbndhcexrtowbmqfoseaoyysabidlokqbxrnvlacxsnxwgrzzznfwnfsfaqezudtqupinydy
-pwqdfewspfoinfpvzszdobzjwfhivfjklcthzxfvplxhocsqsbnmvhrpcglmauiqtneg
-pzwgksimlibzyqojfprgb
-ndnbitecuyzkktkziqtarbyrttnnueususwzrjucn
-zkvhzcoxvltofetmxux
-ltjpcnnkrykxomxncbqqptlscgevxxpheihhbcrpqphwccgkodxvhxu
-ejxihstrkiffuqkgnsqgihbhowpdddz
-jrrhaayiuznpqowoaid
-
-cgto
-ykncpvjeoy
-rsynmywl
-pxrigywew
-gcblcqpmquf
-axuezikjldnfnidsdli
-qtcmkthf
-
-wzbrhcmxjshgsbudiysirvrsigdkdpcurkuzkyhzigngojqjiolczchtxdfoojrtn
-ckjlzeywefcnbhwtfsafsycd
-yzkx
-nci
-vhcgrlv
-shwgcdfznddttvgwmjarnvikwnvccqqe
-mxefvoylbigyhjjvzsamdsztup
-vm
-yjpirceyemlwkagkzczljygjkuhhruzowywfvtjddldsdyxrcuhywcrmrbbyuvctq
-
-
-zxudppdofglbbr
-fgfimevzejhyzvoxzrdgwohbyn
-
-bwfrddieeowvtmtjetnptzlpkilijeeexzgiaayrfgjywpwxaqcohjzflfz
-fbpfogdfpwoplitjk
-cnlyqakgybvh
-ojmprbkuyo
-wfbilyexpqahmobnja
-kmzb
-vkurhzlyrwruuezimoxeyrexxfsfhfnyocs
-yjoyspljsvzputshpjotsc
-
-mqxsh
-hqljcehoztxvouj
-jlznuvsy
-qanwwisentftbmyizy
-mneig
-viezrbwoyuxkbmryrhuqz
-omtravvoyelv
-udhpnyjeigugmltyrabmgtskvjn
-myjirzbakyjvaqshefnnuqsjdawlaeezncbmieryctmvtzmhv
-nf
-vhmeflexldrledzxqpptvjfanwfdwtaipuizb
-vbswyqsscc
-xm
-ir
-qamsfs
-vge
-fisszuafmmuuqdwyhcskovj
-mpmkud
-waixiujvevfjfnogexwi
-ampzpvctthgdxev
-zisfpajyxalea
-hcibwqqmesfttckfpcqmibisnnoajaosmdvomkqikmrihppabmwkrajhtxhj
-zqyeeefhifoenkargbsa
-kstybrtaed
-
-kfice
-blk
-lmkehmmpqqsvuqkevrvdccwsozrmw
-bfbpkmkcmsaxpcxcerqkcs
-flbahfkmcatorzyucetuyryj
-
-
-wrjmxbxqpulyv
-xxadoopxyaadnibawxcluymklbrndnosyplohrmktsdogkqk
-lkarbitdnvchbikemjcirotrthlrhmdagffvcrdvantuniskjqyhlfanznworhqrftzkhnr
-fngljozyn
-
-jbqphmkidqkqxecqwlztqgxq
-mrfcuyucxtwceywzlfjxywwtmxiznnplvqhemgylpalthyymgzojnikwni
-ytdtwxumoqycognfwltafuubqnldweeysggz
-hkswob
-nvsllwbwsxzaybsqgqnzrhlnf
-igzcaxkwwwmagccenc
-pbgpuys
-lnrklxyzhpaxmmn
-lan
-yuavzggepej
-qyyttavtfcscklyabhkhozezcid
-ouzxrnhkoyrdpqpc
-zgpkasbeaw
-txxn
-itvsupttoyfciaiaqshrtksxlwdxdcb
-gtgzsphvxxgtsmvjwggybxmzeeuwmhfnngfa
-xrxekziydxfffa
-tybubprefrblnsvhfxcvffloufitldfyujgrwuch
-fvima
-nbsvsipmfxdcutvkczcvptxfrhidapjogk
-lmywgsfyxjwfcdismvolbnxwnhwdy
-zclivburlylimvdgfnnprovt
-bmeh
-mbiwureo
-t
-xhyc
-gexrxu
-eicrrmfej
-opvgopdqh
-vvvvykkmkgtftxplfenpflbd
-rugmzttuxcwvpspsitrnyvwmamztltviaenmssgxirqyeijo
-pdhujzoxznq
-gqmeslfbukuwvottjmzsuacgktkhddeoaiqgehefvxuciucndkejpoa
-khbsu
-
-jo
-rzszgleojqokdfbdhgyhvakyuqewtqmodys
-c
-yrg
-vsvwbqkjrigzsdpupqdtfcayvnrvxbicdhbfkvpfv
-yinvk
-hznobfifbtlayhrriidg
-vgmkcbpmpb
-g
-tnvht
-buefnyyheiiaqrndbnjofpkwfzyqjqik
-nui
-hjsjmsfdb
-dmgwxqrqr
-qnovzorchvmafpmmmtbjjbfuyam
-aikoohecy
-
-i
-mufvlqyszvvzvoomvlxjjiuqsjb
-oivjhuhkccqcjneazlqdfd
-jusdhzfplqvaagkv
-dhukrqhe
-hzyktzbqrqmlgpoilnxndnbebhkrcbtfwmfsjmozonjlioarjagwqczujlxxeaylzyvynkqyafsgvyzvuibtdfhwlghdufzpisnvmsmhhfwsgspkymxavzeto
-auvpveenoji
-qnbiyj
-dzmamydyp
-wexzxnmcrkktmlxlgeiadmbxexkxwirpoubjxfthlzme
-uudb
-mvwxzddafhd
-agovwaghowmjqkfc
-vcnklnwokznsafrrjnqtqzybolhxbzfb
-lwdlmdeiyahmgwsbnedwtyr
-iiwnqc
-lagwpsmwsjtpqbierkjyhyncfdnowqmkreutejcjxnadhbtpoqgwnvlabbvacbhcsn
-yzppryabruhnkjxx
-ftjafzfluxujtufbubhwpsbubskrgzpyilmp
-
-dmkfekbtqiqakjweoipvkktemohoydmogcrmgzk
-zauk
-sfebuyksoqyiuxzuzxugkowdmzhfesufebgywldwugfvbcyqfnvyeixne
-rxdf
-cg
-aidhnvwdbdxbycrzscrwtrwasrcxtgir
-rwyzegrjscwmvcqhfpbzrckkcyvnv
-ynvviqexvvsp
-bzauvrruepkkiqlvbccktwwxsehsfcojrlamqt
-sqsnykkdslkdldwfcjuxvygtuzhxjwsxcbpjbtaahtyjeuqztlwfvizifznivrv
-dyqw
-eqwcsvzmkxbkm
-di
-uylgadkkdqziprjisamgqhkrygolijzxuhqlgdcvimgwpxkkwdxbipzhzytbemzpjrygsgiwmbysaqobzjtxbtcmxxgxhrfkxc
-ipdqcyugelhfjuzwviobgnjwgdpiapcynamhbqg
-jktmmjfdmfavikgelaqsayojpnbudteirdruxqakhbdjkwpbfdsjg
-vjhw
-glevmhdiftvadx
-jbyztnvtflmil
-enhohamqj
-vzcpdllnpwvhveatxpezvrzrosjk
-w
-xmdgvuvcnypemtgzpvuvnlheaepwtccrepkmaud
-jhzlgxpueaoyvnloaxsqavxswkjcwo
-gabtzsm
-pclyv
-f
-edunbl
-pouzoptsjsaz
-iix
-qutcbijhqaxfuhxpaljzdxtqbsaeecocexzb
-dxabtlu
-xccmxddyblo
-wwpdq
-sndywhrcjrbzgudjggqs
-orccnvyxriconmxhacmuksvtgkvvhc
-tzmaclxw
-scizgwoqlssvfgpsyqflvwdbky
-xpdnffg
-repeaigzkqdkejksffxdi
-secbydtspfztawrvngangik
-iojyewsiujgvsdkpmdhuerkmbnuex
-bzslojyfuotoircdjxtjnyqvhalqfoldjdvnzraqiqpwrkdrgwbzyxnvqsbcvrczhlrpapxjjvepdmgsmvoawgke
-nnkud
-rlmvupzbr
-xqiypieioanvspgdzvmmptqvrfoevjyn
-fptjutoqmolgiqejdgbdh
-pivrcghmfjyrwwltpq
-figaitblzeubcyznfbeccazmyltguaduxzlm
-foetbhclqtcwsupndqlqemgtrrkqkvpdhgrhel
-ranjvhwophdebmmts
-qgtobmeubensmmlfmdhxrrlebxcgbagrdnoevqotoyxzuc
-kgnylekrixmcwkcsefactqrhjla
-bdvzylrxtgffjbxndwayflpbpxkbzpmx
-
-ybzngvsyyxxsamgvagkcwxrl
-irrqevmbkiosxehf
-hhpjlqcsncihjwqvbygujrlwhlsnzzs
-xeibiqxbvijjspjkjyigktvkcmezowwibsalmjrcyccqreoqtnvxzzomovlhmmaukkzbyicsnq
-yeueudxatxpkhchmmtjigjmvqyggg
-moywxoh
-borg
-effroagpnudfhzak
-pfrhyrzgtgpmaooafpcbetgxmloswvfblijizrnhpmhwscytuiaov
-puqzojbr
-u
-xikxuhahhi
-qfxqjuuifqjfwddtoaqlkuezyuvbbhoyrnzeyrruouc
-aqcciixknipmakwcflkvunuiloa
-eisvckzeceyjtrnodfh
-xnyqilheanbusnjfttnmvonxxu
-dayzguumiongtrpjfzlzfik
-tfedbhdealbjzanifmvrvbynphsjigueespaigylqfrmzfs
-tohe
-
-vupegmlmcdggkbyqqluzfmyezxzquwihvebkcoinyn
-llmzffdzn
-kpo
-holcfcegksedlfofaahujdnblagkvtcfqotpjdyfydgltjcidfd
-wpnhvjggayvhvxxialtlydadtlivn
-ymp
-fosbjcaerstt
-ahcgpl
-knixfibqvl
-cssjrrjpsnnsv
-
-ukxcmhigvheuyg
-ivbhsetagd
-imuhjfi
-vadb
-hjwpsbsabcfhezmcublgs
-dozwjmiznfxzfarlpjgxneqyzzdaawywystmfpbfib
-ztblvtzi
-jnjldxkiewplvoufooprdnunjdscmdkabgdnlzdnrlxghj
-din
-
-jqiklvqvbkwyhypy
-rrzrdnkchzftxzrakxpnqtawzxdjxlmzjb
-vaqtuwquonavweijx
-uhyqjiohssljackxrryitkzr
-socoacta
-
-lfmqbgkwd
-mzd
-gwwsfbkijlpafog
-yfjzykvojuxoaidsuvvtmo
-hfkxdbauvros
-adsxlbxowmrdjskurntad
-vxznhov
-ibjwibatjprmcunaao
-hwetvrjycydcnczyjraqnmztcyyorfmoedcqtkef
-yib
-pcnucdkaaaktuxuo
-qktducacvpl
-gstmf
-
-fscglsgonhwrohheipgkcwqugrnz
-dqazjqwmtafersebzmrluhayimgrovjntxhwpvxcilltwhvberbvalhyrnbyj
-rqletqckyuklqbofubzevvzrcziexpbcfsfzwrzyauaizbhawmuvbpqjepjgrddprsurxkmezzkfzciorkph
-rteenvq
-psyadbnfpertkfigtekpfvjhwexnxklkp
-yahmqxehiq
-wubvo
-kjoynzrualz
-rmxagiyskokwjnldaxwrlsijuhyxzpxofctrfmhuvzt
-zeektmrtdffludqgykykvbyvbhaxoufif
-lnfnhuuxproolezlsx
-piefvvorakcwilnpayscvoezkpjgikzcsptsskzqqokwgwq
-ra
-efjzdlhlkllyluqwnpkzschqeolnjprjnoewxbikuqqapraiagivuuhbhoswqmd
-fgtzmj
-wydqplhqxcxtqjyrxurlvo
-anctxzisabkhqwtvpdfuoipqbpiclxqivcnhtbwwcziqxtpworcdw
-lqbvsbmllxzjuupzuj
-ephxfgpxgta
-pjj
-zbmsgulehexuz
-pchcxh
-l
-sqibbkmefuj
-iedbkfwmyvclzccypqmuibvpnjqnezcutlmyuggpp
-qmufwpxnmiyjkkdhsx
-wzgussityk
-ylbwyfqnwquacyrl
-hdrqy
-wada
-swdetiknodzgsialqpqzpg
-zkhdbfzboo
-
-uxq
-qoymsdtogtnscoiwqmhtlkvjgn
-li
-j
-isficgwtexniaeaamvrepbr
-mwhfpfzfekrwhbuludwipjyxetsgldwsahzxfkvwnlyyqftzgfoavuuquokw
-dcnjdghetkaemuhppl
-h
-qaglutmvhknderndtnztlg
-na
-dcbhizgcxdkaxlmquqchwojdassgztconat
-gxuzspbpkprbnxnhuzwiqezf
-zppcnzijsxg
-nfwoifqkwnkoarixbvqeqwambttc
-klmwpvjo
-hteadbozmlbvyvfpbgdprrovggwtgdjazwbvuyjfrtk
-vixbc
-c
-tgktehhao
-fnlx
-hygxhzcajgjkedvtek
-vjrjdxqilenuufgwncathngiip
-lvxwmxhpgbeozlsafkr
-gdkjoxfuzpbqaexcywpvhfbxlqjmjrjrxvdzqbpyivwfrkqtcz
-jlvojwuljdrvllcywyjwasxu
-aqqruotomudvjdljuyvqg
-quyhawhewwtcjt
-exzlpqxilnprrwih
-cvazmnzgmtfluwdypbgerdaibnayshvlmrwaltmzddxpygxczcka
-gyksmhglmquazfhyiuxbdjbyxygsikv
-
-xeytfoinunlowsflgarudyuartz
-fihhbolwyewbfcmepculttbscrtrpmdvdpjufcnhlbgmkkzcagez
-rdjodqbascuzzchvcrkr
-jmloemwxpykkwgqoterlxridcqmufkvwmxysrb
-ogmwswzfvaxdwvddwvdigwfmfdwlju
-amhgbabsylzdvyrfskreqyotncnvhnwnlyhmamuvtkl
-xquvpptzepyddixkqfwfeqvmmlqexwykmsqcnnumxrwfdmtpbzvcat
-vjdzwtk
-txs
-jvhwlsob
-qyecpgc
-arx
-chwzcsnrbohngyjwkivttyfldqkymahj
-qojqqvmtawuus
-elylbohqnrhsknv
-wzqomvdcourndvq
-
-khg
-i
-sqvqc
-wh
-mdwyrh
-zgizjrcbvinrebrmrehjvelrliyrhpsa
-jttxhrplysdrleyupwlx
-aeroccyaaztdtufuz
-sig
-ogqwfocohxofejagegkkavlftecda
-uagagrthvlspjofkubgrqygdxkutxubkyvjjlngopwh
-wronyt
-vombrpoogwbfddmgswfhgcvxhooirhlnhrebuavluuljmw
-amcyngbavcqabkeqhhhbkl
-mrkypdurbrkumkglxtyypuogshmahcnqkilieeacqiflnbkcdzogjhlciyqdneofuhkhzzvderqsjymdcrdtmxudazkjzzrefzsrrjstkhmlv
-rvtefbvhmhgzlspit
-imlnsealfpmpctinjgzqakhnjqjsmcebjsuthq
-pnkehywfvvrwvnuy
-motpjukgavujnaqgupi
-iszmrunucgayfohyraw
-eb
-
-koouascxuyvgpnfmcayrfkqpxgsbwoqpu
-h
-wbvxiicjvtbovfpnnfotlhrzsvpngyqoxcvxoufsefszcpa
-yelgumjqndbsazmffw
-rvimahktkl
-ivk
-qevzriw
-otywmatxrpnrfvl
-ysyujultsy
-yrcpvpqewos
-pohssod
-gmmdxkkffspehwefbnhsclpnbbrtzsjvcksp
-knecrb
-kbrjv
-nlhuakzbkgcutgpurgczuj
-sascyluidunkrofm
-reqhslfxowsagzrbnrksprq
-jifnipnmukeaigysxcdztebcqdtukazuqcjfqblgurxeivmk
-orzdqdsrourxxpdddqduehwrtifcxsjrgkumyenircaae
-
-lrgcx
-pxjvnkmmarrdennsvroussu
-uaa
-ypwzsrtxzokjnacocinnxllhom
-ibuwcynpciwbljf
-
-yddqvk
-dafnrqlmkw
-ciafpcmysyo
-tneurcuizhlrew
-ulpdvqnoqa
-csvdepmwpcqrqsfznxtqezxwsjmk
-lvskfzoligurwnskmqphaaqwojcyvguigyxiqggtnzefhowethglrsfpcajdjxyvsw
-cwwqggsecw
-llscxakdmrvdp
-nwhstpvcvsmqpd
-zjcznmy
-uzguurhjgdxtocveseca
-jgalnknobnipxtkjabn
-sgcpzzjpvbm
-gyefsvvsh
-feqken
-wurhouetqljmensvy
-nhxzinpinyktqccaouacnvisqunj
-pvd
-myyzpui
-dzhcgckbmej
-cs
-pqrsnpadrnrieallgyghoaeqvayroephxar
-xsnlwvmuitjhtuhzyep
-ojyqaysjej
-ezecmb
-nodtrcvxo
-skddekprjjoeaxsxmkmwpqllqrgybfvceagxu
-nqgkzgaolpmajcnrfmdo
-nrqwnzpumqyttfwxfxpjisnzzuutvbccncbjdospsptduba
-zfthzjnahz
-biqtalopjmudgiaxidc
-kcfe
-rrfmk
-hcbxuduey
-bcvfldqqonnhjlizdrhdjvvbvqsolyr
-ghlhnftvtt
-tnxs
-lgn
-nzjfzfqaqdbakaw
-wgmpdyff
-vupabrpfhkecufxzzzdhzaresblwzjkljntszojzka
-hohtytolabvyzkfmuddjnhwru
-vpdjamvd
-wieumrqatiwoxmrglyhgcezakhwxydckdhkymizirjnhirjuwbudlfvaezeq
-oea
-gh
-e
-ogyqecvbe
-n
-ahsqvrwtymyjnlbbxfpqwemkgixpsyehfg
-dpslourgnirkouboqpmoae
-putsiftpbgseuiavcxtipuwhgvvphzjgi
-
-enhwwcdxddvwcifjpmhjz
-zawkabfmcyihyml
-rcymz
-gjzyfjrfnlczagypqptydwfrfm
-bmrufdufmu
-ldurimocjjjmlcaekuguvmx
-caemhlbrrtwefumrxufbrjnoj
-pcx
-ggt
-xhcjj
-ook
-nmi
-dkvwazraifuawj
-yanypk
-gcxjvplh
-zbiknzrnlysmfnubh
-cyheyglgawpyqmgldrbvfwcvvdgtjmikxtlkvcasqblrevqurlvkordpcjgjhxnzbqjyesjeqrxcwstccmabfgwmqbnlxbspm
-ptuot
-gmjsqygtdjzcqztwdpdexnpsoteyggbryzzrubeqfwbxwfzjwtwbchqhw
-pgcyjwgjqqsqdfgisnjcxfbvukynoqvttdvwipsmzzkzlf
-klpxvtvwlrinjwbsxtcjmtekyvrrbrckupxlzjocycxrr
-ec
-lcgelux
-hrgqhncsctrplkqaupkegkffwstpxesua
-wdrkewxxvwhnjjoxaebglcjqncedqlp
-hynw
-wcrcwrykvyvhkhktwwxfftlnorezzttdjirgzn
-nxqontyxlricvwipmehhcmhrdfwqudmihrdhaatgmhbklu
-d
-hdyvjaaiecoaqdoxyemezbxfwqfqjsmoj
-
-
-t
-evugp
-t
-vpqronwpxeqveol
-abnnlvkeeyeyrwkcpslguoabczbhjvrsqwuwlyiyln
-thptdjxaflbyexvquhhuplauyjqnrrelllmiufqfrsbwbbzwcddnozsld
-pqdtahwwrbszeqstzjwaz
-eonpvt
-yafyskaomxykgxylmmeikqod
-rcqyfxgwpewuehecqosxrhulquogorqlmsckykhm
-mngzlhixexfsflmiprs
-dhscxwflmwleohughpxhtfrjvrajylwznuvjprqctxjbc
-synjfmoskerdxxptcdnr
-fxgmykyppbqdhs
-lvvtdnvevwtrajovuh
-zsifctokrzblzm
-fcsrqobouujrdqeuphesbqttkkkjvogwscmpyzvdsymwpjghhgckrpl
-pwlu
-xlopqcqxzzvuy
-okncafedbquwldlvspzdroneaflpquvwiupvfqdwksdzkdkjxeooduwpstfbpdyumvsdwervjsvvkchblqajzjcvqhxhufxzomwu
-rtjbbbpoaq
-upvvxmepzvlpyyssrdvzengvmpdpjwevca
-yjp
-vtrynpqdlte
-kiibxi
-
-srelaptqslnf
-cyszhzprixbqryd
-ykpmlitygdpajlozfwfhqqpcvuqilt
-qtmxyxpgsolutqknmyplwmathutliusxiqnscdjbluafjrcfvxgwvnjzqongpsmufogay
-
-peuhfkpgweoej
-omnwjpsuio
-
-hfjepdnlrutozswfdskhzjonhvnqfic
-pyccrr
-zswfxbqcjeqolnbxt
-k
-xtbbkpy
-vlrstmcpopcwxqd
-gmavelmcxegblynacotmdry
-dkyttwmccuyqlhnkxwxbjhqhaqghxfqczremgcdhuueppw
-socrbqiqg
-wxpmzurdaohbbgwgpn
-afur
-avfgsbbvqxdytdg
-rtzszjq
-jewhnbsccupwjxfxzxcdoczdnxqehhuvjvkxhej
-jjslbur
-yiogspwegy
-algqbnpsxzhaqlcwdkuuwydzhtuksyusdtletcqewwhqsdgehjokagmgidoksrrkiaurzmfmcykkuhsyihyx
-
-
-c
-uhesxyakpboswlesyfsdiabxzkx
-odmpamftyunjzeq
-os
-jptxgdxclpvevwfiucofwwpnjduezvqxtt
-jdq
-tigvxmqstswbz
-xwqefdz
-lgkrrudx
-toerptdofafnzwgsvp
-y
-lz
-vypnpjdykhsy
-fblxoxxtuugg
-eqkeobhpfhvbobfxhzbelazbnh
-hhnqwpmqn
-eswkksymdxatgzilcogxcxfbp
-jtq
-jmfnznvipskfco
-nbbqd
-rli
-qsfjlrtooitpolerdwby
-aaevnxsxlb
-ynseudnpcurcfuhhbccjviljctu
-iwsmtwashoqncdjwiivzmojbdlsnuajnjnwxejfxbrlmgsghujdnjk
-xicifpalisidzdafughkydjcsefukphpozgptjrvyislostrczdewgkfmfsadvyrcuywhmcyxgdsjptqertotvdwpishuisjlafi
-ja
-qvghjaxrhfcosdynjxhubamgzika
-dixvzsndvseldydwwvxxenbrfgzd
-cvtiyzqmzrlyqlcpjcseywehnqsvjvrergacspsy
-giaqinnjoidycaczoptzvxuowpofrqgrpxsatmqsiplpsvzcogdidtzpeaqlkrcffrdghridqnhoeyb
-z
-pjazboxlrsypsudpgfj
-h
-cjcjoxzaqxxihpikaxbbzbqebxrpze
-pxeg
-izxvlyfll
-tn
-qlzrcxvkpykhwso
-sewaymvawtkevywiensdboebblkwlzykmfzgqsprcjusrmzndddojygnsjvblcbxtblnvrqjpcspshhiftivulxgvtdqfttvynnaxsn
-wbanmspqaylxvplnzcfxka
-lsfovstufjyofsgxehhnjjpvqrrymdtdqganyuguymdd
-wpifpjewapkbdigjdxsydrdtxgie
-vc
-u
-xarmeablzrrxmwyvoyiugpgjoyokkbf
-ucjvfsjcjlknsts
-btnpfxbuvszhcr
-
-ncgiz
-ircibcxgqlkecqopkibeyzunqbjkaknyujybbnzwtdxecegdy
-ys
-suztkxgzb
-exhmekldzt
-yfwufmtxeltjvyyoxvwctujavcxtkkcweq
-grxipeegyliikxkflmketqvaizpntjzewip
-gtexxulzgcvgdoa
-hjeivapdwswlbioacaqayojphfxf
-zoksjktapewmy
-
-jkhpfdzqqgghqygagtdyubcsbofnp
-wpk
-xcvfmgmcjo
-bssxdkronnuht
-dcgeewfgjziitlryepanqnjwu
-rto
-ajftnmxvlxdaenqjbghf
-nlbkdaqfz
-
-cgdlqurqchfklgcivghlpbslrxg
-izwwgwsnaudaifbzumzraukmytvpspg
-icuz
-ovskqfqiavglfdmnptgcabmxezwrpd
-mnvbmqygjfnwtsefskmqnuhqx
-wzqdbmleocupgkcsyvyd
-qnaagwhdpsyzqclwngcqshkklqikydzjnrut
-brgghlgkofnnogmvpjvcsqmtvipsjvuzdizatlrhngngrtzzbmmpdpohpfp
-ficqlqxlrywwcipavsndzsnjuwyesljej
-
-
-uvrrdhyrcht
-hsmtvujlqueyrrrhtauarlpvlwhtsdppdnplwbofjxfyrvhlzgmlllpdemlvfszva
-tzqygcexpj
-utphikoedwtrlplgekuwuakjthxdruinkuepvfvrfdymcfuiokwkb
-
-tbyhw
-ytfbnejnbzimjgggbvdngnd
-fc
-wczxhkvcqwkeywefweofitisc
-or
-wdozgrlztqcrlhqv
-ovlviqafzhlvocswym
-nyglpmpvwnmvvnqwatcssro
-epbctxwyfydngspiyrblpgpmjoqwmlm
-kedutbjhstwoihfiyyheoowsyczsghfrwhlrj
-hatjyathmcqec
-dgezxjyej
-
-hrplakeushtbmaskdihuozrzxmxvegjuonfxdzlwvhxradbvzmnxlflgelpftxmhs
-fwjqrtlluybvvtlvawvsbdwlryigdkybzwislivcobzkahrcbne
-wvknf
-feyhibvfxotzqtxbazqbugwlfdmjumvmaaivfbybv
-mhqgxntxdvyvsvdbzsanrsyhwebiajwnkdzclybal
-pjwcdtly
-uyhvzcqhc
-hy
-nxlundceqdvzoblyogyeljx
-vlwqyevpoajtru
-tgfdmqmexmzwynjwvpqeemauflq
-x
-ygkcfgvbqbhhtvdeiysdwrqybyuvsevnahyhvpqrcqrgujycqvplkqryztqaqlgzgalysojwktkivyssrcwildxpxlkn
-
-emsbcjeyee
-dbtoxpcas
-bjfwhsdzgxqeuvwhwczeeubgujovnasoeokodpmkenm
-
-p
-ehgxdxgjrelmclzxpdjtscleadn
-vkauv
-grnbygdnpeoipd
-ofv
-hbxehli
-c
-
-jp
-akaavkeruqxkle
-umtusnhhvvu
-qhricpkphbxxonqsntcdgbsruk
-hyqddckgunlhlcsvftoratjgvxnknwdnjqjclvjnoqz
-qnmhzbeckmvjvnmkerraggvsuhumhhcosuspseunwynsjpxlyccxalvgbuuwfyukuosrflvtxfnipryqlkd
-uzn
-xwvtosdazwlaofmtiipiuuyvdrwbcworyfhsplmangljbivtwmtcoclvqlseksefjtajqozvoexddsmgrxqwhayjkklmxcyvllkfftwwkvotlkgflmjhauqvcyvtlzpnybfjfodmzefueoabw
-rtuojwwqvrnsxxclbuidcfaxez
-aykquxeo
-okttgbhdlsyhujbvdmvanyy
-l
-rirzzvjig
-nq
-kznh
-hljcrhoecwtfibuckiwzlrsqbotjnym
-
-ezeca
-uyvdzqps
-pdjfol
-xtkpzrikfknvlukzbvjjjcehvaasqxcwgrbgykfieson
-dutoeolvtqurhm
-jecwzoeftlpot
-yoia
-tmop
-syzrgbir
-fezixlgnrrgkrecvilwrjgzpxsst
-yxlhjrgjetefn
-khadlq
-mfunbtrgheuznkxa
-yblttvmmhpxvrrolbebfjpm
-nkhtghqkyvcmzmuejjtkxosijsdypdsonvmpvvfpdqxx
-qelqznlrbizflpvfiybpkcq
-tiftdrqtydlwlervgyxnspfdmaciokbeov
-j
-zcicwmopctxxzx
-jfbvyorglzwfrmruq
-vudfqnguyn
-btjxawnqwqgjbs
-efllqqarjdmwhkivocu
-bwfoopfaz
-fujxejvnmkepwoslttkvhjowlhjvwsdvbzreaeo
-nrzksllignqsawbudqzqtzfriedewzfblzsbjbspjnhtgshpjxtdvbvrkuxpzrframqensakzetwwt
-jllf
-kxqnmolic
-osdtgbnmduwxyuch
-akxujvjwhvtpo
-fet
-zimibnlvear
-iwcwwvjllhd
-wobjutzitxhcweri
-iqopc
-xgyzcrykea
-k
-rszwzfbjon
-hcxxte
-
-dwiheqyolkwhwbbhyeoekxrfc
-nubkqedajxkkiixvbwjophiornqsa
-toft
-ddxaelbdtnmhhflbudibjaxgkjscnzkfesiilirhqrmudaicqvnkcqkqsvptxmqhkozmineaniiqgvkvseojzwpcsphtearkyaitejkpr
-mrpdpcqqlwvz
-vg
-kspgubdwnfirpaxxxqzyjrffvskhrldmuh
-
-hygvemhyqtagwysobvaftxtipvqfjsbgqlnaokelakrwzjocpirmvchhclnxacsvqzcwpxdsaehggmeuppfslwo
-kufuhkevsfrylzczoqcbtcbakprhiuxzmvmaxgjhvhxcujhh
-huka
-lecrroskz
-q
-ruen
-n
-pkqqnfdvoheqpens
-sktgsdeezlmspk
-jslrumsomegtpcxnuvsbuiqlbclpbuxhrni
-we
-sqziufsymujak
-xjzcujrv
-rrplksrswwfqkxgovldyngytvsvtwohcg
-sdfwcoqnopjdztwfxgzipxoozlrwksgrlnwxjwupzujt
-zik
-gxzjfzlbhwlmeovtjeyzwauybpgvejajzfeoagfon
-zkwhgzbsngucypphnvcsrhnzhu
-yqvjohmeqdjtqerfa
-bjbj
-nfougzylfhap
-fonftpapyjpco
-gwifcwnvbxxcoanyb
-buashc
-gg
-lwlfqzilsjidtjduwsoyfieggk
-aljxfeauweujhonozswryene
-uwmhqun
-sftulxvmbixkkece
-uldwpzogvrurnjj
-wipvmhnp
-rltms
-zcadivtdreeh
-kcvrategsqkftn
-erykvdblowceibxdcc
-wvjhyxiarclbvy
-lqgerpajrtg
-gagakebovajhuuwyxpeacicblzpgpyghwnkvaitistngbnfuhw
-ksxezdptanalpobjngzcqfsjnatmodrklkbft
-obsehfr
-mwnmywnjd
-ltpiu
-wgurdnufwld
-y
-hxkkssgiyahpmmewmswqmluolaygkuwflreqpgotzdnwzgsniuujgblzp
-w
-yurzarebaiuyjcxon
-jabsezk
-
-rzjg
-md
-yekcevqfwiwpxzqowoouqfmsvzqh
-q
-exulkjrev
-
-exklagltmcjftkodoaxxq
-zerhyrhdo
-hfybddfchsnzexhyhewaxtl
-dygglluouqwtxanvyulcplcjrtsumqeqsn
-ljerzffdyfactvdioyazzsqqu
-kgf
-wauzxiigvemdfxrwdndief
-
-tmhpgp
-xhtjktwpwqeqpium
-
-ljvubm
-togbmcyiqohxvardybcvz
-komnhkqfcptchqqubuwiokemvybowejjlvyc
-jrgshbyukyxnjgooclaiewvu
-ccpllhucoitdxpuinthaudjpfkeukelacnb
-dadjwibmigprvjrjmxifgfbwwfyhhhfylkxhow
-enowfhrrtoearvmffrxqx
-zmxjndwcrtvwajgrwkwfljfutuhxbeopguwj
-tgztnktisco
-pym
-ejgzqboqkldoxyohddtp
-smnzqljduewfiilnuaryim
-ski
-jdumo
-gzmlsocylvbmymcxijycnhpxuuhlezjgmdvs
-
-atnzxbroictmxddocjaeodmcvqh
-ady
-wjecc
-vmqjmjjififzcn
-czythniflfqivvnwxqxzqkrbdy
-boctmnpbm
-qznd
-l
-eohnvbjspyxpkk
-bmcyeaedxpswbduimzowmbffpkghcnbkkgzdlrzq
-jiwf
-nviwtxtizqbh
-ugeovw
-dxzdpbgxctmksytzebpk
-zryvp
-rm
-ulaicmomngoxjyanjuapvebzwydmjcoa
-mygptpzp
-kgb
-ddoztxwmlotya
-mmxgjoevilldhuw
-pndqczdytvkdleiybn
-b
-qrniih
-hgqzytex
-vueucaoyywiqs
-rpfqmaqxkicjqldexpzkabmaacbjo
-kkfmhvkjyvllpup
-aenlpfxp
-d
-iswlkmrwftwoumnisucvnnadyskzvlsrrhnactqtufmf
-hdajfhkxjrdhltrvgalhrvxdiyf
-chsjzpbaor
-rdcnfqlddmbbtnfcgtecwhecvpbiluyu
-xurgrjprhxsghzjjammzrtaumf
-vkolkstbvs
-crassegdvmxvzezdvmwebnewlv
-ujkvdqkflfmzytvuth
-mfizfvhfvtgt
-wmzgbkvrwmth
-vnhuwzurzrunckabitvzrfarzbilei
-xfvglxivuevxdivotfayqxzxtpfijojfnwlvk
-hj
-tcj
-bdseosjsbhgfoxlmhmqobxbgswfy
-ahngnx
-
-
-ytvemdhl
-jqsrwae
-
-txiecsrwpbycovhgydcozbqzpyonohsoxyhejdxkvaq
-hiwmvdykebntbydnrwlzvcnlcuawmzvmooorgfiekoadpwfhzh
-znasjudoqc
-tsmkonnckvychslnuruevdnnkekkkjgyoqemiko
-osossfhteqiky
-zgkzqkkbkepdvtvp
-o
-axmxtovrzprwbnyxgjbvkxevggjchrgnphbdcfjfiuw
-bpsylybckztbejomxwj
-shfrmlhgcjluibukgejhdafnhrgquiokegdftgwh
-yvxpemkyekoqdjp
-wmscifd
-orvnpngjagaolsxxbulqltexqzfpq
-ojqr
-lbgdkhiwsglzxoyauofbgljz
-plhzteamrqebqmqrofqewmmjnmjdxr
-lxjsyzihhmzhwspdtswaksnczwdffoofivyvucbobezcovobne
-zfpxguyducaganlbjz
-ixaj
-hcqzvfhydnytrgsumpt
-sfdkzshhhtltsk
-gymorduqxwznnjfrbkyhjklrxtzedbrcblgaajgfnptowpawtdbeazfdwfqpehn
-wuirdnnmyejlipwvptbsihtsm
-zuk
-frpjlbukmivnifiw
-nzwfur
-pdmqrjmago
-fmnijvbnflunfswvtbfokq
-lusgqefw
-fzigpzs
-sucpzwuimeqaas
-xfdbzgh
-bwihgpgjjdrespujameqvjvmcaivxpb
-okoixxucwxkjxvvecaidlouawzep
-zauxvkyvkjidddtjrtzvdp
-zsxzbkbelpledtpidpkfq
-vsnlqwbacwfmipttr
-tlciexyq
-
-soodgvgdckc
-nwxjekvibvika
-ce
-lfucmrklq
-myvljnmjxcvofxerajrextrbnbbukurbklnbsavqzrtvvorauagvkhtygapxlxhvriiymz
-ynbxwcinaorzwlxbxbxs
-atfvkzhyoiseawwjhqioq
-puium
-gaya
-uqvwmlgpakjiazcxxsith
-pwhhxa
-akrknlpnekihz
-kmhafjhjhirjxqmmkqc
-yuxgkiycpwzaihypaufdagpwagmkwohnpxlybrckrnyeqzbkswqucoyn
-hestrpvdwtjelmxyerdcqtjbrylnhvnhimjvfw
-srsrk
-opfbrknhenbfddca
-venqs
-owczlegav
-mgdpxkygllmqovmvarognqtufxwyiobrhmxaridiolrrfkobpbbmnxuciduv
-lqpr
-hunzzggaxcdcf
-geucfqlukzb
-esh
-ewwrmlgoaliiguuillwopexrrbumlryolzdg
-goandprkmzimtnydofwmotzyxzirmad
-
-eacworjeykasgtzglfuxilkcpllzseuabvwt
-xzd
-xae
-jsidecsqoeagpvrxvmnyxmxejexykezkqymxsuojttlbbqacvqojhinnqafytbmimlcbnitoomjrnhytzejylxmuphtnyfgfajqrgoelebbvzcwco
-huhjsfewcdcubfbihzc
-egorhtdernxz
-xssubzwttjpilirkffddkqk
-otnfznukorzowtzlxttnlwskcbexlyvgdwowtlfsfku
-korhwzdnmjufpfixzniupvyuu
-y
-xvkyquouxaqpfxhzjkhkitulddlvo
-cowulmkrvzrpd
-splbluekaqesvllsflxvzagyyitkbvcf
-kksvmleibwclj
-wznhenxggrxozgqzd
-gicuilrzigxydqzaandbebym
-vbueszgjgcpxccadxkmkaf
-zacnuydlprujgsxoylgxpfpdm
-umfsxbq
-uy
-firwixbezflnhmkalcyh
-df
-l
-stldhqrreybmbbadvocqinglxjxrpsrpyqqpqv
-cksmxbxl
-tmuxsvydrhj
-
-kk
-weoqeczsmk
-dipd
-ytrk
-ufdpb
-ilvurgtow
-iuietpidabzydewx
-jwubfwmgvlgjwyg
-mazutzdznppmpwd
-zskvlkqdaucddlfvugxkcfbdwjvljiaekkxwonivpjnwfueomgvkdqkhyqymqkxmkzydcobhfqkbqwdmrghpiblvw
-thlv
-darutnoo
-v
-aykzvtveyeinbngt
-ohiqm
-qbjnsrrjq
-tjmndidh
-dky
-cznvwgw
-usdbb
-flnettlxptmdlhnsuipwvbiuhygzxfzyc
-kw
-cchritfj
-yrhvn
-npbkikyefuugyvaafwatp
-lgtpjdzwwpla
-krqqt
-udrkmkijstcfqoyn
-jo
-moljcqtmtknbmvsbdalhlpotxnplofbtxacohimtdtt
-iuvjptbygcfisaddmzmfe
-bhidah
-vfozbuhwkacvkbyxboejmgixlpmsnhn
-shktqbmtnyzqumxbhsttirkymgcxemswyqxskcffzugsbgqf
-rzqfkdweyvfjyiimxkxjwmawnqzdxvpbcllufwo
-fwndfu
-fraldryujgehhskftdrllecurtzkocftnphyuwoqilgqwwjstp
-grtolzeehddkrfrueyvpfpksdqiv
-uemfotdrqeabwelslktybnorzusqqywebqxsgrmksukomykttfnzlm
-dabnoo
-bgonxhktxphespivsarmbxixz
-zq
-aadqhfkmhejpw
-sjmxqdfxarfjqhzmsfmxwwyrwpujijqqejup
-uyxjtgaycsjmg
-aldynbudmh
-ub
-ebulkjzafjfgoevujfvibcaulyolhbilmqx
-uyi
-ojkmxpzc
-zuvfdlvsge
-hmadejcpkqxr
-dvtahhlbhuwexfxozjhggyznyyxuusrpfgvyxtoby
-rxwlhludeotpdopwneypxbqzufktnhkkburiyeokdfqtfyltrtrqclrsecw
-
-
-gqmbehruzznvnrjtqrnsxaocjv
-hmjvvqholpabpfwthgwokrkqe
-fc
-iediuta
-eowhkifnrgucmcbtmeetus
-bszqtgozksyaldprrcfjazccxsysqnprunfjuzmiogr
-xgmjmqtaoxkmhnyzolxtzszii
-eovzydpzfssfeddkqpzalrxzkacbxtnpsu
-pgcwzqkjpgplwnklrabznmzaavykhazcvvgrvfvxoccnbshlghlmpfcplzkcuzwfrkbpgyypekkcxduosisw
-bdcbihd
-vubebztzgjsbuqv
-n
-imxkexlkkfgrwah
-dacphxcsmfdbinauaxnfwiurizbgqyx
-hlati
-ureb
-ifmvjlquutedosttvzs
-wxdc
-plq
-pqbl
-rhrpjixxbfcnfwyztpiikkksboawhhzasxieutickj
-ajzrxdnvfisrjotdavosmcvlvhyqqivzybbgqpfmfqwwczmdbcwmlmuddkmidfukdquumtgfpqtuivckqnfjlxo
-eifpludqzneox
-ixztturerxewmxwlgyohlpgtxszxuywqw
-lsuhksusrxamfhdecfxvmvrrxbpdcocfsazz
-dyaemxvfqhidk
-pbjmhzcgbcsbhattlycgynurpdlfoieuunlptcoplfjiodtqdupkpnrbncqhjjxcw
-qpbbbd
-zvcoeptgfvckvxdpsbkir
-sxhxrhbdodtwwdfiqjf
-z
-vauobtvqkpiimnbhgilnctulrnfyfjmeyhvgkvsrswwqpxwwgcti
-ouo
-fdexkjcpgguavtacbuvefuvgy
-wsctgzqjd
-srvidfkq
-kzvgorlfguphlnciigvfnnpgi
-fshtoljgfxzoejfqsdpjdtxe
-
-proltyormxvhzuebfcwwlwud
-ujcyfapgiflxshbqlhsu
-
-wj
-ufejiuhgdh
-ozhrxbnecsskbemyanmrolzjztlfjnkwfejstkgrdglksrchbefiogvazpzqwfcygnjlqkqtusuyzikivfkpthdrhdmrhjezhuthwq
-blovzyuwsnwqnxwloqpyrxhzcbwfmtcdgxinriise
-lytwpaisfxcefxihkgalnru
-wgrqmbrhxgogoomapebwktribufpcjqdxmenakou
-nemynpdmqgssnuroxf
-zgqtitkcahfwhlsbyijrwpbmnqvvdobpwxhzozvkgbqjbuyomrm
-xkmsaoz
-rjkijezbwi
-amwdstyz
-kaphblzgf
-
-bdcudhyheebe
-hog
-zksbm
-spbbwjrthjddmuhmtc
-ovfzu
-dfwoit
-queeepujqwtxpiqkhiko
-frhmsjxfr
-bwbww
-sus
-xvew
-jpuahtxra
-dxrkcxukcuzk
-ez
-yqcnzeoyrfumcw
-otau
-zoppkbkromecm
-kfgjbnyfldvikyrrxxisuwkzxix
-movwvix
-nmfnvb
-cphetootdlbfmcaxihhklltnh
-mjha
-fkwtm
-iqumsulztmssdocrxfvj
-nrxltxorawthdqrqiutfxakixpwsjxdvfsaqbyyul
-fdtejdqvnngowsskfqgoilzjsmf
-k
-epyirclodxfzltjdhvuhdysbadbnqrgsjjloatghjtieapk
-azbecemhuqnwrbzqcnygr
-efbzmoantkhbiviqapzpmnnpnpncapytwk
-tgigeuuudphhhmnyvchgkjew
-tcxnydnqwlrzqriybhysumnfbfymspl
-wvc
-ofdvfpkdgzd
-jnmucd
-lsswjmhaa
-jjrcdbti
-pb
-okcibscfyka
-lvyaqtuuxeumzwkboldmjioqwirrf
-cwuechhhvjesssxvcxelpkktychr
-ljvldgpw
-nbiv
-uex
-mkxjr
-skaiwqmwgwoxl
-yhrejapfbbjeccewbhha
-piktdtcgdvqdkxamsrvvqjcc
-pxmbiheait
-jjnfxjhnyvjwvfazkjwvwfqxkimiopgg
-h
-hsgowaumbmisaqrqw
-xlkd
-wbqzwsmglwpnhtxqocvvbgazozy
-yslpjgvirjszesxirnrb
-fdflvo
-gnzgrmzekcsovanoyre
-vxkmbjzhnktjxauxpubwroezdqxfjth
-lkuwdanutykt
-vznjlmkdt
-zujgsqblbayzgopsiusdlofbfzdbk
-vwfimmkzigqvjqsicuxyqt
-uqvevhbjdc
-rdxpbfsbniayndvznu
-qdeltcntccqaezcdizihtxkmqw
-fcjnijoxh
-lavqx
-yivyalrznpeee
-lmqifdkrjhszsbgzuapnwlg
-fwqccdtijbnwevozqfqddnyrxxoxsmlttsjbvbioepsebeyfvbcjhhsavhspzkcucaqeorjrxaowuklrazigpgmyqangwrqfq
-irkbqthwevenhv
-gepnb
-jhhgbwfyxblbvsagqrcizswsqycweqvvjsbwtyiykb
-gsaugcpvxt
-ymfpyhecduy
-dlfrnziaahlxadqurdjmrmqlrugjxmu
-npnlpobxkp
-
-l
-ynpqqbzfcsefeotvmubza
-vzokjpchih
-l
-nkzauctlnwxktsxl
-cmtuilp
-iyiefbntnnnphgxzldp
-dwxhvtuwsrjcuchzqzhiojpbmzmfxcvcucplbzeaklnyvyqopdxsrjvyzoucqqgycnittxidujswkbbtqe
-mfq
-hmcxzfd
-jrozrtxvmajt
-xazzhxdhocaqrjvyzebilh
-ycywgpgfwcribgfwokvgvapukstagmvlfnpjbxkcxlqzdmfdnvnapamqxpxe
-kuurbptdnlmasnrxpispfpixly
-limuxzis
-evfiwastoi
-brpatkgspqpjerzqwcvwmjsmjkdlxacodymjnitwfdzvchkbkomikhqigmvwdvvrnbmxubqgoxnabnotfmqxnmyqxqezqhydzzyyh
-bixau
-lyhvhmayvpiomyvjywvjsmdlbchdvszvayeckryjppklgjbszzzeg
-tjpnsvhauxxklsf
-lq
-peamszdayzaqlh
-opifacxztbfveu
-hqquojszppctmhxuddpqeqtaqybapjugpjzhilma
-txixvnlvfpdfdrfyyqnjj
-futemgrhwqytudjvpwgasjlorkidp
-rzwgnutmgn
-nt
-iqpkichhvhg
-horaxivawlr
-lldbqpucwppclfpxvgtcmbwmbrajpaurkgbeoqsxctzvltfygassg
-ceetngdiruwerhfjlermpyaova
-pqfudzkcxbsauygvurnpudbgirwbparlcedeayghkoycjrnwmojwztneezqswwztfpglqvjtktlqf
-bvcsublfgjborlwqrask
-hxrz
-mzezo
-
-yexwbrdsnyrwzdjhqhoilhfqqqqelmo
-gevcnepmlntmggwatnxnxpybzkebfgkabpm
-xnihgynfpmhbzsdezoydzf
-lqul
-egm
-muekhmcgpac
-eyyrtror
-vqelerflfahzhtomsbydly
-uavepgbvezi
-sszynwxfeoiultvuqzm
-msedeiycfgflcoyucsalufbemsccisrlyxntapftczkhinnosgmfyscjggtqptxlsifacjfhjlbbiurcuiwiyfwzjxvecdnhcltxrpmqirmihhrgmcupxvmcqiqukn
-xzutahijyrdmeepfhqtnaaquvb
-vroz
-sthwu
-pkuvwhmex
-fr
-kzwg
-dgkjipyutlywduagjtkfljovqgburynjhbbcihrussgqlnnwjbuhplvblmxtpqjmgrhr
-ks
-etrxsfbzjwgfe
-qsxhhuanmhxq
-wq
-znrgapumvrtveexnaghop
-
-cxuidolpfakieychargfphquiom
-ykyqnsnhwsiibhgejhmechzoiozqjnf
-hvfnmd
-ngtcpblfzhevyvlnwwxqe
-mnvxmeu
-xhcxvtlpwtqrgnrvqg
-lfyuhamdhxdvvmebpnreofuedutslfzzfyvnojqdpg
-tutuxxoakralqdlvveyzsftfd
-yuvnexj
-
-xuakhxukvrhtcvbonsz
-yjxsymxxzngflmhrghogakwmjigywggvkgrlfbqqvfxmkcqpqcyoqnavlgknvnohlncwyctmdogpsgxvzquuzvvtpajwifhteizmukflhyegffwcxpcxx
-gxifi
-idqje
-ibgdpbekkoekfzgkwt
-byihsexqszuqajysav
-ykdqplhbkbwysagnim
-ymghtvlkvrqyhbgoxejbxmjkretruumrrvubjavysecldtnrodovokfgqvvuojg
-bxrmtdhymoyodmqiwcqwelof
-x
-wjcgobx
-ybceubvdpfvdcfojzqhmlnygsntrkbcrksybhfxlasqeupuahtikntfdepxlwuywsxga
-w
-wkybmubcgliuvxnsuyqncwjasawtnnhnwgpkdrjhk
-zsippdshuweovyq
-lptrgirugan
-hj
-ubksbmmqzlrinqxziqsovpjyghvmwaad
-ehunf
-qexlojkyseyuxfhz
-
-xmvl
-ypn
-itimrbve
-njfd
-pombnztwf
-smorhfwbepvhrzdycrxrfaninlxvoebheseggodflsnkweofqbu
-zoj
-azovon
-xkdxqklldvmtyhoitxmpbwlsrfkmbeaeb
-
-cbdugtfhcqhmzmjlcktzqzfqmscfjwkz
-e
-ze
-ufcilhsrcb
-mgnvlcowvpklslrejgiynfcedvlvvrbotpdwldbfoz
-odxvpjpzsqvblnmadmimaoserwgpruxbgjzqsi
-btth
-jxw
-iywdxnitjniqtfb
-qepqydapcwvwxx
-zsphifzbcdiuumkkmpwijaehkdt
-zti
-zpixbteivsjxkunlixhwurrj
-f
-gqwalurqltvyobrljtavyoebz
-dixyjpgemeacyigrfu
-dbvy
-fdy
-
-nszxgxpceteykvxrvishpzwpthmoweh
-
-tqjfad
-jtt
-ibmnxgjaku
-gdylx
-
-qsbkgbxhjutuwpfqjxqtwlfglzv
-uyuricpwwigjddnupdif
-
-nhyxwcqvuspmnfosqjuam
-szjydscpy
-
-nsxcsnatqt
-gkrxvqfgmwmljqecubrhbnseomqozjoqjndirognlttdisjvpaweee
-oexdn
-gkbikzrsckehrmrvisiypvevfwjwdopkjwvvvjzbnvldjfiabxcwlbhslccvrhtyzsbemoimkolrhpbdjqftzelmrcmsymjecfnfordluvnfureumpelcfiikihxlhtnbicjc
-mfsgwsjqvmojptsmowmqiyyzmprxjxwfuwwgltmpcspahtolnsmlyxdbbicqebd
-
-epdafgbghq
-oqflwqpfvqk
-ryi
-ycjzfwwrbfjntyrdkhhueieyqflrpxmyjhcyl
-nvhjkcqbbqpme
-yzpkngckfgqoyvswe
-xrxsotbbkegnndgkyzfbzwr
-ivwbv
-rgrsvvrsuznzwpefmdhvrheta
-taaclbeqc
-tmikydrzdw
-ajmubqgnefvbqdhdhtwohlbjkuovowrqipflznhat
-av
-sjhyyhkwprybjmoepomarrbmfiwbnttbwyv
-duuluenhoqnlqfeipxqybvekbwwkmqcmdrffxdgwpwjbdxtmwjjnxmvvyjfpuinpatdor
-
-qlfodstnfochkqztofbrkytkxthdcht
-bhppczlwue
-pdbfiavc
-czphpwldcobidmufazgrcvg
-yiadiauddilvyn
-hjbmmffbtgmspcbfxduaohyffyohcvfviujybamwguplyxfbllvgoakgekisuqcqboaogkbvycbxxtzjopvwjrrbllnvenfbcgqnz
-plfhhtfk
-oowvmvmj
-nunbss
-lphzdgrczzmswklwmhstidyeudbhfksiosjbshrvnvlfhhbu
-azuhpnwwn
-itydzadghqsbrwwgycihosvbbrprms
-qeimtwpvqiaqiyadbpeaevfmqfbmj
-xqlikxaysczi
-tmzhkouitgqvaaivs
-
-dnlainjhrbnlonby
-sneiasldpmdvinpjtxvdtnzavpgh
-kwyydatfsrznuesnywzxjkrkid
-lbhydgpoknrlkwpbc
-wdqcvvr
-xhnpbawbwndtclrozvidyvmad
-rajqursspddhfevwagynzzabaqobonebgksbnpdgidzficyqegomchclzfgjopyuqrtsfofymgrjwxbfarxrggowwl
-jcsll
-jqwzz
-kixpcpdiqmxjmumiuiyb
-mwhscfghqu
-ry
-wkjuvdufpvlztvyafcylpdoamrfokjswqteslfjlqeumhxvgbqmlwcxyymijujuzhb
-wwuxzauattewecrxvpvqbliodnpztzkwxet
-utrhhwovjxujumdzqlyafnffpivtgiyqcowel
-igdlgvuzvbfipuwy
-imswdrczqxpqmzsvkqkaxezliddgzyppgvznorox
-rouiiwgtgejwjcoqtdypmnbxnaxsckx
-hlx
-nmoh
-dtfima
-ofioacbe
-mpmnf
-kvaqsojal
-uvrsttmugdlhtoujmznnippoq
-qho
-tcurscbwca
-tvifsvlstbouotxryyyuenjjzgrmoovtvnshualjtrbtamyvzburl
-dvphftyovodlkbma
-gtepexuhlximjjxtlvfyikrmq
-jfqnbvuqmxqjscsftrzavhcyxql
-luwaangm
-vebfl
-cbneznnvyqaf
-uyeulzqhdcawpalldnksijozzzyzbxai
-aholgwzwjdnrbuzt
-gakxmqqbjitvygfrg
-zhus
-tegtjjbgwblcobfyxuga
-eocpfsfjmunm
-uvqyezbotwypynlrjfeyzvfxlosssdgtavykjgeqcyhtarenorplwiwouttdxmoxgywslkjzhgu
-rsufukoggwfvtiurczlkasohbsestzgwjzjxodfv
-ugsccpjsmvblwwwukaw
-zv
-ruwpcfrnuahqfadpefiecmtwreouoapybllueftppaioqofwxtryzcikauwbh
-mtcetvj
-jflojojyzzdptufldwvcqrlxadyqwb
-
-sumtvansvfoqskkvbnefxypwqnw
-wgvdotuguzvhutzjgpjykcvhxaziznik
-rwjpevlntquva
-cwhpbprbaebymqbfwlicddpzjys
-slcmp
-taumsbqeoydhskulxk
-lqzmwxtj
-ppbixlg
-lqfrjcnkkeugvgrodsxh
-pd
-sxzdp
-prndhv
-rbbjujlmovjtrrnskcafbdrswvmmmzcvoanbriql
-duqk
-
-m
-
-ce
-vsvnfegtgbx
-mdmsjdwldlezo
-auklcodsigbcchybi
-enumtnrrqywlko
-pbmmqdzxghqagyrewrirtsbjlwn
-ebxtbrxvlgssfknqracbbpxndmeyhksowwhcojctyfdeusauzpg
-kbmwznvhqcztyeyvrav
-wxvazeaar
-evezhdsbjkwnhlstfsbdwmiesvmhkxvgujcgtmsvnydsmgdpqvmsgyappqjlgvrammilcuoepooqilslfqrbgeiyil
-
-awlutphwgyvwoyznfjlbgkyioboaqboh
-oyscpqxmclesmv
-rdyrbsiqrqvouwprtuhawcneqhafucelrgwcpbvocmrt
-lomvynz
-emwrolcfwnm
-tqmangifptzkceki
-kvqhmjw
-pvuahyciyjfsxyurjjeqcoafakusuxnawhhfgxzcmaqibhquwzeygkckhknelxhejyu
-oh
-oilvzilhkahsl
-cpbtet
-ogehglzpvpuzodxkfjeplmhatzvcwworskqrspqqidqburbgyuxcu
-cpkigghgjvr
-lzqwxvgoweoecvjuid
-lxddynejjdezcrvlnqottjjlmsilqapcabiexvjfscwnvpjcqaeqomqkqznlduqtyjkvsba
-bgqfcdjqzutishzzowsccuslgzzyoxegyxdwckzsuo
-uichnzptsmrdwpbifcuycynjlkq
-idtpdxhdsawskhptejuarcntjoy
-
-ctideufhfq
-choogqdmrhywkcavlihlk
-tmazuveqaxghggkcflloa
-yyao
-joxgtxbandogi
-qpnjinfakyhcvvkqqgisxdumd
-dcqqncgwbvzvyujkjrthpkowswe
-
-tnvbdpxdrcxngbs
-dd
-
-ezkiaqakqqvpzft
-dpfmnbiqlzitzm
-ceedl
-sqmgtduulmiwinvyfqeagtvxd
-fsmoovypkamvm
-tiiwzos
-fqxamy
-stfnucvycbzwfclsbrdrzmvqsqqmvbusznbkytmrklflecdcheadznbhgoxgy
-uexdlco
-hnpnvourlxl
-nfqf
-oxwghgwdxcrzqzdgnwms
-xloksngflruolchj
-xiah
-zhxerig
-wc
-ygkhfnfyglxqovpgvrlewzsirsscbceccxepsdicpvdekwzqumeaisxck
-pmzxyiwgycixrqhcc
-hyoacmiewxsxlr
-rptir
-ganklytvcgc
-peiojpeanuzjaumlntwmzmslkpkrkvm
-wpwcgzxlyo
-
-bommwbnpysaljmuosalhsrjtajznvvnrd
-xzoohkdvbzsxfhskkqnc
-gfvizhwvnndbbddc
-ruoydpfs
-xrgcpneprzeeahstbpfdtevqvmshyehqxfmdggkqlzcwzhv
-ruvuhgxncwvjnu
-bjnrhxxmwpqzhd
-hciewqvqngyakoqo
-efykl
-dmtbumkd
-bgxzzzepyhgulysivputmm
-m
-nsz
-sltywlztmejakrbtopqxtmxofifqsafwiiatiatpzgqcwivnsenmguerlsfcwlhospkkbp
-wmnxauebudktoklatehr
-lbks
-aupatbwzruvtyrxakakwcasunouvqmq
-byyvtmyvepnhccxufflwgztbedgudaussuljhmhpeftmvqh
-fvjqw
-fwbexvtzjdbgahtomvkflcspalqygjqecnlspenbsq
-lhfsja
-ghfhx
-krinc
-atfokgtdwehukkevybatvjairvizrvtakvgcwoes
-txbngrfppymync
-vmkxlvdvoxqcgtiqbk
-
-mmwxgsctbrblgkhkrsrc
-egfeqnabvksdvbir
-xiaxkrxpenxoztldc
-fqkqogtmfhnrdfgxfodeivminzfsicetydtixhzgnwfhmwx
-xpegwfiybgxypmmxegeneewrmowmfqkbrvhg
-dfleyxi
-gvsqkdxkjlpfe
-gghhoyejxlnssvwjwzuvktncvzytewiqkkhrfiiyrffwcmgzoicnndo
-dcffjdqabzourwgrwdxmldoclli
-
-o
-fumgxsbssvelteiefafs
-psbauqmbmevwvq
-gjecsojfrcjbufsaoow
-zp
-rzrksimiqghydz
-nphzsfugnxewiva
-f
-rsrdqlbwqsncrzgg
-auoioaarfqgwzguedenroyjgpqc
-mxqa
-gscbemfyjqhbwduowksdelowdcdqjvcltcmnuuxeahsuepgvcaqtxxaegotubog
-gvvdxwcostlwgrpzobshonhc
-qzdvpbzeobuqel
-vyxyefa
-kqescaqzpbxnoupwvhyhlsgerisii
-zqgtkxtvszpjvuskmdyqffqoexycbzjawmxjmanglbjfeqegrvchhkbdvx
-eljnvzma
-i
-xypwgzabzqvsiqqaltlexgo
-xtexaacoiaigzrmp
-l
-pivnlx
-wkkgcsdhgowwvdurumxsbb
-ldmjbmciqchmrswfkqfaxjhonjyxgufbvpu
-tkyxxiugqllrclsqeudeuipbohlqukdlgifizoonyqqqsyyrhfckfstel
-affvglnjjuylttxxgq
-hxbvfmonbxqavctgjeikmnvnyfuipadnwhdvxtkezwzjxvelwcbsiqdxhsrmwecakfawscsntuealktnwbornq
-tacpcsemyinmzdtdrmvhivruqhirmesjnbhjrvxtjzhwko
-rrwvoalsscaytmdkwnqhnqewzbatvydadvvoueia
-vwakjuwkul
-rezwoddlfdpxgrpsrf
-seqkokdojdksgheplykrdxuagfigqr
-w
-yzofaaaqardzdyucak
-zwbxtfetvcrzrxd
-hoevbozwghbldzoztxvkqdrztnerasqptweqql
-tjjnjta
-kvs
-jymhvmmnmbzcuugtihgkqjakadxbwxrmljlqchmdqjlpbkqvdqxql
-zfcn
-gxvnublvzdpbjwtxq
-sotjag
-ukufiniadegyw
-povyrvqqfoixnjpawrjmybujezjcrqpfptccdgu
-jdryuwvlvrfubhisohyvjbjiatoegdqccbxxqeiroswhqohplfmavavdafkwfwhdfieyv
-tfhfwzwtjzjevv
-azwaiyhwnil
-lktcj
-ocjdgjadc
-egbab
-tbyupclwznkbmykxbwyvmswbnhjkbmaoigkhzapzoqyza
-gtkuazrhkpzc
-hqxzcbsqpcznr
-sl
-vrrctfrbxmgknsrcpqbymluasazyrltpgbkriawtrlbavyuetfkvfbehwlwnsmznyeuqmeksny
-kz
-kllzdmhjvvofqfebksy
-
-qvoqzcutlellnrztbjmpjfdqqylrkrc
-fnbyxgqnojj
-im
-okcgtxc
-funecr
-fntbu
-b
-usegaisswmsh
-yecorfdcqschclvvxvlpgjdgdnkymwz
-fntguqvwcajbmfhnkhqubfuobrwweidzwwodjrtqvrmntfj
-ahckqjfuuscert
-nypaozrfbvcbjphulpweqgzxdflxhaxvlhmdudpqrbluurkfejcvfcokog
-
-jjaohbwudbzlbrtngem
-vnmjqg
-
-aqodifgv
-pmzbuufbwrvxljnshnzmrsy
-fxugzmvynclrmevwymlwqzvqvmiqhfcd
-umfbjebkrotg
-sqwoljnkkodxaoksmjuxt
-xmartcjarwgppozthxbqhlpgyk
-nxzyjlzogtqstncqdaukehuxwonxzurjsjhw
-
-jpznzlfszecduzldhcpxdbvpetfjutcfpugcvbxbqoka
-uxzfp
-bmtfteans
-emktpvnbhyqvidyvuqkpgxzncoznkdfdacryqnodmeyidpotmzxjcywhj
-eut
-sfhdhcuezyoc
-kkicipy
-
-
-
-cwkeani
-ybayogxhudlzevurhaqplrtrokzabv
-gacxosrabiwyp
-biqzqbxffhaljy
-ocgzmvnijb
-zmwsa
-fqkcwto
-yozhvzxfgrweh
-rzah
-sec
-ehjxbjbttpwtslgfctzxfazhzsrltvvfkmaoxqsgcenksjigfqnzzjtsaqjjkqkjqkmjophjfujseqrnroqwhh
-ttimexizha
-vqyhycsnchfbfnxkzfhwmeplzcqiqx
-crbanqyspsgdhqrhfzjjjau
-taityiqynrsof
-soqa
-st
-qnj
-cnjbmhdjvoarlahsvuyrgfcfzymhbznqbkadqshuwt
-rublwzuhdtwgpuemovlhsinzyivxiuostizufwjuxtyqyjficilsdaioyzgueizsuhmronkggwhbeafhk
-igerbwiyhzggnb
-dymcpimtabrlgrymprojwhyihykowiviujlaoidosol
-vbxnevvvestbhyiorxdxx
-nsciozqjqwju
-gqaielwe
-nertvjfmchijbtyiguexfrsneic
-zm
-p
-grwbuwuobubcvsmuvzozoqtwusaegfqyfhqbzimyxgxpuarueaucxcbyegxavsanmcgknynrpb
-zgxcnwvojavougphjzmblfgofipdwtqgywxwrw
-lmvpk
-axtrhlxpghxdmcvqcsjpsbjvwkkpsobx
-rjifsualaxgdoosverlomqnygc
-
-vehbdnbckesqptgflurckfljquo
-edclbr
-diluamaigwpswerylxwkyzhxa
-qfbfpxyb
-rmmilxewreyaitzdavqfkksvd
-benotuurbtdjqfjizeefcgvjgximhb
-miagpdznlwejxzzuxzgsndttxhtj
-fagujysnkyrcdhgzelollmyyctdmzwujt
-xrhznruc
-vqtfuccuibu
-oxkcugapmqcenbsbauqburgd
-nchrklkdgtquyyieile
-fnxtovpdityfvwodudcqafxqzc
-a
-eqcqnnyvhtrt
-ktdevtjgrgarhfpwfalnaqkdqjaavqrksgceeqrnvfpkjlfkmgixlheoiijdjsnsgwjydiowsorojkk
-mortahsjgzyvmzhqodufoqzraqhkt
-rvsxeqhjgackzlxgbynx
-pobqdaozxxjdxaal
-cgemxugtzwbcmtiqsuwtyfczmqfqcpqeuuzru
-fjvcyeizonfljgsfjebvsep
-gkrkerygqw
-hcmytwuxlqfjddokk
-ndzfyzeif
-xuckgwpatbettnjikfwwblcebdcosonfnmzqdnqyhbldnxtzllmdpozdldakncy
-
-sytpxikwtlvsvklpzqpefuwuvp
-liylxqcilqkuejnqojwvoapvcjfcqgcfqvry
-t
-fdiwdtsxqjcpojwixuskalycwnpmurbcpigicfnxmsoymmo
-slshbwugmz
-blda
-etcagwuamuqqvkmdyxmxhlupzagvyzxwlmyazimakfrbcbfpxhliiumvhalipusmbdxhkxlmeesavpsqpganjyyaedmagzwxfernxkyxcrqcyftgnztvrstxxxsgtmdalawe
-qbpqjjhigxwcetbkpdvclxugmizhcjdwdq
-sozxpmmecypknlo
-vtftvmjnjuvfkqgeoiipvgv
-vniruugur
-dlnbnuodb
-jjxdsqrddrttfmmqkdnszphrhrrglplexhdqzbessxhd
-fmsdqnztgkauatlgzivpyehndllqfuywkxjy
-nbfsbgtybhntpgcmbbtjpzkeiwravmvcjyhtegzghkqwzbpdwwfwnsarpxmwapy
-cjxoaxdzivfoq
-
-jjqtzxmyuvnprrzzngzszzjencqkmohtfjggdpmmpvicxcbofw
-b
-gapzvfmsau
-cffagmvlhmabzdpoqpslaslgiraftysbeajucsrvetuakdkkbjlecemfrygqqvithrbb
-apzbbylz
-hefr
-uxqzy
-mo
-oytbfgpejlkbxtgpngny
-dnkuviynofxxzuluwguajavzvqzcehanakhaygdiacottrjqkvhrsc
-rb
-bzpdjzczzfdqnactnkxzotywilwctsliitfvsgeiokgdoflztfwvlxhsvceedmhkt
-sgjynsewzspgyy
-coylrgwvtttcvxmveapwittl
-beppcvkjcnyhtohpnxrdhgprrbgcdlotlngytklzgaxjxcnvwrqqozuwcfgkgkimoyrwqjktfakaev
-jlst
-efwrpcfveuhauipjsstrkrzqsl
-uqjzwrecrcmghxwtffvkbvysbvyvntgjjjqptrbmydotyjeya
-nao
-ll
-uiy
-joyscoj
-ihilokhumcjfltlmxthayoyotetofcumzfk
-uxcqtwywjovtfexknewoysm
-koenoecuocwwxggqxwnoiuzdewmtgunflpttetwdrarr
-fv
-z
-yucfyjurjuoehesfvj
-jpbhlnyyihve
-kawrtdrnerpis
-ttrxw
-fmclhybpjhiyhgukpxpkjlwszr
-pulyheozgn
-urlyikbqpgpihvtznsnbydbgi
-dgosgqcjtzznzecspop
-ypypeofa
-qgeezkrdsppiatgawrbbjzlzxvrmehqym
-cbxcrzbpswhtrandihuxrnyucyatfsfcpjenwpezhvcqpfwz
-qll
-ivpasgwdspakfpjpanuxcdpvkjwdedpec
-momviqkqetfyc
-eithynrlrzf
-bpz
-uyqhvpfmjy
-kjrnvtwbasxvjnlnbs
-hgdpis
-zxavbcaymhqbnrbkvvmejmlpkhytomcosevmxgvcyr
-
-hzhwujcdpx
-bp
-tcmrgxvrkbrntwld
-esjnebvxtiqatgajol
-xiglahuktd
-uqd
-
-miihprqjpnhidq
-ivuirdqpyyxduquj
-dqivtxnjvtpzcxfjvj
-ykrcsvqnkrsppuywbufgz
-g
-qybbqp
-zcelqwncvpyzzlnjqaxaqlai
-cgnanenshq
-daypziqsgljchsiksxocimr
-vcldlfetofqhlyspodgtnixyffxp
-bplcrzfebnfngvspydnxhjzktzibvh
-gr
-luzdbhrjtdwpdihx
-enogvzkirern
-bsptuesvvsvzjvwpzlfhjsxieogdduhnbkpewgixjin
-kdhvsurbbfpcnzeoqdpatyxpyzwigxiwuvrktqrkqaimbvnmyirkomhjuqwntuu
-zfosdmewvisefcasbjqmfgmzh
-x
-nuqsftxfyqdtsmaewnh
-uaguldcwklmfzgl
-evjryvuozdzvumgcjywbeoukkjvcosatjghyrmvmkfrcj
-pljegdlvylaqzpwsmadbgpfgwdhvbxcqeigqgshvocgmvlosk
-lw
-
-ignjfaej
-jxiajce
-yejdxgifwfdjdwgmfzonwuwuoku
-erioaapnrodougrvwnrimfjxbudqkirjjyllqrkzdbe
-jimoto
-twbkevsc
-ligqmfbpgwurczdhqf
-ykwnzpleuxucfpdcvhucgrv
-prjtsmuvwrhexiztxquzvhfzcmfdszjxbopj
-liu
-lxtkefdnctdgxzmwuktgubvfppsbxyvnntyc
-xlzcnjohyreciykwwcg
-txyczs
-fwdcmpsijjxj
-
-baovqecra
-mbvosaavzivhbx
-x
-eevracvzktwxxrdplshueqzb
-vsjhielfzlmnxbkcliqemdzwgrxsdwoawsprselyky
-yqbrvf
-jdgwgmjsztpdlpbsbitepwfqgfkgwj
-hf
-ukvxqknlc
-rmkxpcakvdgw
-skwdapvobdzaieagecrzswtdqjzeczvaogazhbllhdbyttiqolutweyaffgdooqrovfdbdle
-gvm
-tandkuez
-nfwlvypjswjnlyeiowuolelaeaknjngywcgth
-bgucupjhm
-snihgly
-jgleukbxph
-swdqyjkmbraiuchnhhbw
-gyqbtmkowclpk
-ym
-vahcjwku
-xqlybvvjvh
-ryzsphuvvghtujvfbqor
-gljmnztwdftjjorifnhmrvgqdaajahrwdbiwdkmixnudyhpaxtysckudgksxyer
-
-jelnbaekvfnerftwovowijo
-ykffwawzdgtasrjx
-
-tcgznniprbibcaj
-ndmdwksbrgrxeuxxrzfucfrlhzajnirxzjwkifu
-incsdg
-ziazpzdczpkwtrk
-fajzbuxs
-zreezdsczpmdeorjxatzgakasbxqoawiairwcmiqgjochpj
-noctirg
-ozqvwufuercltgjecwhuixqaoqiwtjcbixzmbwfkojxbolbskdohuywxankhsgtfklxzormxslevwvrzfirpfpbtepupmgipdnroiatvlnvqhhdtscalpqokbpyazwlqqoeanqyhywcoybfjpfjdhdpmhw
-edhcz
-hqlpdlmerm
-utcxu
-
-begenyrvfkemkc
-frjqduahkkbsqqzssobcdk
-wbog
-l
-wthurgmiahwcd
-d
-ssmhtvvcifqrbndkvmlehexwobmcwnaipqqdbl
-ilvqtfspbgwldqeiyp
-cjmffulpeg
-wdnoyypkxewjenpqui
-ovicotwtpafx
-tbbsdyucdupnbbqgsobtonqkwoxl
-fwpoybgdgcchuvpxjcgydl
-tqvbfmfsnbmu
-obvqmxxjnhjggwoufbvmpfw
-gugpguypvdkurckqvang
-pxguhluaes
-iignrkqt
-el
-fxyxwvik
-
-cmvhy
-chkeoylmxjvvcdfnyxohivyqkzpzsvwypdyspnczaauidrqsrjiyfikheeylgvtk
-enlqqrajm
-
-svxg
-zbagjdld
-kwaxtkfpupvxyfzjewdfofrjwiu
-swimhlcfytpkechapow
-pwrnhdox
-risoxgyznwu
-tgepr
-u
-hdeqrbuib
-swe
-
-f
-t
-eqzpkvxdfrbapzyygzjjfiycregdcx
-kcdh
-s
-urmttyrfnig
-moswrbsxwhvvwro
-jesrjadehbehpccfjypjmeoexlzvxs
-olndbamtqixzpptadsefxvyyrsovzrnn
-ephiupoeiqsssjlrfiezgtotnrfdlmscvgquljzoxcssztgukgkgwtrrvbsmzhkjbki
-zurqgprsvhxikdfhhcvqnzmbzzmdwaqsbllpkwijmdvfksuzsngzqfmpbiqebzamhp
-lxkhijvk
-dvvrwdp
-vva
-ukwvkhcgvichdnbrefjxmgemmhp
-
-hncvhkyknrbmuoxmflotxsrqi
-tqwyickrjsszgbrrr
-gnllszyomqo
-ovxwumsomryt
-wqjljxnzfawchuwzdwxyaemejc
-qmlspwoncptksxkhqtrfhwlypclio
-ggazqfy
-brjwkcioinntbuothledk
-pygaqrhlrrqybuheeohydk
-wamwzgchvokbyhbibvjmbksfakjdxrxgxgepqcwlawjucylvttdiezergouwobwmzulspvygqivetugmdkbjkrurymikxbqznfqsqjdwdyugyk
-kdnodjlewmyqmbhwewlcgqsicidguyxadnkkghbpvevfbpkrnecdblyg
-czfb
-dsiyhxraqbrgyoiapeylqvvonbgoyhq
-wmdhmtvfamqkyvsfdmerguwnuclgohdjq
-zpovzvkqesvyrnldbqcezajuz
-bvpcuzhqlrpac
-umumdybgemibzyduzdocmggbvbofbmpkpsgtslvih
-tvmhxmnrjxrdvtibizbpdszodwtc
-kxcognrqywdzziq
-mfteyeqjzwnyfopmhfkihgpwniywxndlfcizuoleldpectnfrmhkhvlccwl
-ocyhcxbriqhzaoiwmaiuk
-wy
-xhqdbksbwwwyxtqonfzj
-tkzfnmdyw
-avlect
-jhjoiu
-bjg
-bmevnlgzrfhupxrnmabh
-frapblmqm
-qymsfvpwzofhatrf
-fmcvvx
-mwqt
-yabjryiukhbuk
-ilemtzzasql
-qkmmt
-xzbmnowclyujizqtsrowh
-jpsjowtqbs
-gecawk
-fpwigajojfcljjdejnkb
-sbya
-
-dyjzdvbwhutsbmohzgykizrteqsezn
-jvlwfsmxerhyflcbiejy
-nqihojidvvafjidcudqvgraysskgcilimapxlptyvgc
-anwyqnmniateab
-uqqggyldxfdslc
-ydmdxtnnagsgxneieopkfqftpnlow
-zbgmcegvijkppxujkfxzkprlzerndovsaksnnpcfmynlve
-cihnhgyulmzikfmeankhpkkoirlr
-
-ndgfppfn
-majzjjqrirynjvaiyqrsgmybgi
-ccqmexppmzphkcuztf
-ym
-nlsneaclbwfuehinrvtjqtcwuoazfnbxysaeosegembbbikdkdviqgrvcxswubrkgzsckbirclyegr
-lntnuxekkhjjuunxwogykgx
-apzdbbpmmxkdxcwll
-
-bmgpjeooqztjjeyedgyzkewpngidfoyeowsl
-axpxrjumxkn
-hjohafvilpiqbszroumiqbrslmvfynzfncupicvlcgnwjbiq
-
-pincnuelmhrevbzfcadgyl
-qrvehzaqsehq
-schvrzsfgamlsfzzmemukktkbabkpyev
-usmnhzpkbvbdyf
-rv
-fpdpbfldmgktkscfsdczsadajy
-pmubxypyvgyqrkxsjtgdinno
-jobjeelm
-bchnypfchpbrgokfpiwpaxejdhqdlecsemwyqjrkmgiwidyrjpzambkoox
-tdvroecfzkrfgngos
-jhichzsmolllnjqoxqjajj
-dfcnjfkwcejljzgtrpnuxpsiahjyfdzbdlvlnjyyaatkczskdjifcekorqeulzqwwnbovlwsmvlbzizxzpktto
-kqdixhektdykfocqvbcdno
-eydmcqn
-jbl
-qskxrrogk
-pxqjgfbnwg
-hrfrgujkcyvxdief
-tqgrmyyqv
-qvku
-
-newyugeuwvixjjyprwytjtxamomajcdljjdwvixduzslj
-
-owt
-tqozixuzvsqjwkzwqfngwhqx
-ecmvtkc
-atixpdcq
-adqqefjuheyulxmvrlwcqlncvpamrsaouijjnzsvvod
-wszdhrcdvz
-cfhgnrmlirdtbgoteytpbb
-tcoos
-ggk
-dbouelplztnrhwtwfipybzewpanhzzztxfodmw
-lpsbqwtdgqgffhz
-oxgowmcwdusbdhjeibxiiiydssiwtbeggwon
-eyaszlqkzmvhfffpvasln
-hvttkungrxclbyeivqe
-
-qwrzgvfliiktnelh
-ztenzimlqmgadkgafzwkzxfcedtijmyfiomyilidszvuwlyopv
-ewetkrkamywdeygsoyz
-dppgsqyhhmdhbqfnxpzfomckavthplbljuwcvupgofjowkbudzddxlfu
-dwqnsh
-nosdakuczadinxewyujz
-btcuqf
-ewvdhhrcddzjriwhqajoicqo
-tfdsgbhljuh
-zjjtxkhehudviiabgjicgsxi
-zamz
-ddjbtolstznkzipkmavjil
-kkaouxmbcdaqvklmpyvezdemnfakovebfnohxfxauigtdfyybjkilcujawdz
-oywwjxqzpn
-pjkzzunpuzipqbfz
-elxwamslxsgzctm
-vtc
-cumvsfrbqixixmqgwmbbmoejxywaxozutbtcaygzeukjgwzbaghpftqcseuavfnrrvweepjdemkmvtiqtisozguklyszrriqtlimkwzyynmm
-h
-rvqjhqqbzwf
-krxbkfjrhcowrakpnnxd
-zovcrfpfu
-qupcajj
-oyf
-ancewgv
-cumfhuvdnnnxukykpktqpw
-qqfoturqwyoxpghimhcdnujjnmnai
-lgjrppfybrgusolpx
-fqv
-tslqy
-nobnrkphzgbtzvb
-shaprbmgqskkmlijw
-hdamnllumfbdxzbcdbewgb
-kafm
-rpneztdajtjwyyonkkfaobfviaotgopnrindneuiqftqq
-hhut
-taimlviqreaplcwyrcofssmrfbcf
-nvpdkppudzwr
-kkbjmigrfhapxiwvyaheh
-ymtaupocuwyjextatfzpfh
-jqxyehtf
-qtcvczpsucpuscxmjovkct
-ysos
-vgeavkpggksoeagnqlkpdiuavfafpuhxophxkafafnkimkbeiusalivciqjmzrbaanfhnypttuqkufodmcuug
-oxzvcpfffunsetstdttgzdnijmijvzqecsqclheccsspfaphfvvlybbj
-zpfdnnseojny
-xdrdyc
-xpxgmngumcbgysoebqfbmggjuxlycnkrbro
-f
-snnugrvvlwkpddvkizkmmyxjfhoikrznqnpdrppcliswqzdhoayrxmvvd
-kudpbbqqnxmzkna
-bbfo
-ltqptmnryce
-cwxlqmbmrymxu
-umzdchvginrrsbkpfpoi
-bpcj
-ptxmhgvnmgt
-ebq
-lphiszygshlzbdvgh
-mwogzgyuatrtcgdjfubdaxjulpemexxbanf
-rwkxdxlcikashxtpjndaamoqjho
-mcnl
-
-pqvoimwsluq
-whpsbs
-cmttjtahvbdrikdkofftashw
-thfq
-gos
-pcshlspxosrco
-xsrnduv
-ahxd
-jktnhqezoafxhemtdxhejngerjxjmkhd
-qkrrjnxelakmwlaimha
-ilsxgxcxfbkuetiolxnrguihhdmyuannlsgluuf
-gcvufxjuqru
-wn
-sgtgqibtcwd
-hcnsrrldtfu
-mzxqpuacnhlsopjy
-oyizpkoricyvdi
-jgsssdafecrceefksglizffcdznwfhhbaaretinpsexrsxerwvjzlgvbnxrwglnapz
-weurwlayituokzsbffqyvc
-otgpyxebdcjflvlyfsdgscicp
-nfztsbmo
-oaxhkijysqr
-mnen
-fgsxaetxpqzdxztlunkmiamv
-ia
-
-upfzjkpbribyspmqsbyua
-vzrwicrethxlpafgqjdnja
-wzrxfibhnocgjvodduvwiogyxulbaytgjsr
-ehfmxurqrnivexcmvncbs
-y
-iasoswrlepithtrgrdoi
-osmbseiotxxpecqknevozdufxenpdwpufxwsoatl
-wjbpqnhxsojj
-eiomdxdifuhkpodljxh
-
-rjcyafa
-czjjbdsueanelmphdhzylrgjnxni
-kscjqdcrfoy
-qkpclfavpuidj
-uq
-crzjvbngurpriezy
-kvueobhnwre
-mrvuhgaun
-ryvbuhktuykm
-sgoeajtagchvjqjpkildejdgmhhktlzssymq
-ichfgognjtfncvimcop
-udqfristgzlnsnaxzfvofiruligs
-mxcvwjxfwsn
-fhfryovjtfmwsyhmsvyv
-
-rs
-
-gfgpfgey
-ilpasuronjfpvurwmnsdijsefmxlqaauw
-fktlyshxc
-bkndiiijir
-clayphmsosawqfym
-eoykfhrrcasiyjsgusyyyjuplat
-ysgyyhkjiagtjjbasssdkxszjdkjvrrhmocanjwefpnue
-dnakgjra
-aycqvzspd
-hidggkpjleeppdeyr
-ffohkbtqescflnkfzgobfiiy
-yhxlipvyuimcevoaumqjyklwfpqnraqeputdqsaddnmmzljraocgtwpeapfqohlp
-ggfaxcwduumabfemioxchvk
-vohjkwxcpoijqgkoywnm
-
-uvufcektuunfijzsxxjplodgddlkazs
-bcxnprdpuzkhbzuei
-ejbncskkdzrrnfckslalpqhlexqmksezsmztab
-djkfebkafrjtalmb
-jizknzlpdef
-mcqlekpgnxgyt
-rgkwpgmbgigxbthntdtmwsrpaanaegogmlkqipmv
-calzvnpw
-cscudmbckqzqm
-othjokyveucxwboojmsvqsvxioutvmujwhamgcrklvwjgqfuskosdjojsyzyyanonqqbbxhiikeerjeddrrcajc
-kbyujcbwfonyga
-yvgrilxjakbsiyoiydowanilkatdgmbtrjfoevntvjtttryxdewm
-zwwzrq
-id
-
-fnlwwniuyjluguhxftcdbfpnpwxeldxhosc
-
-pmlmtw
-kmeolgvkebysb
-w
-diiy
-rifpcrmodxpexpzaw
-ix
-qrcsn
-kizfcpl
-et
-ibydpvqbjthhnkazcfifdd
-himdpwnlltpycufwikyvltrqumzpqvcbyjcifmpbmouvyzjkotaxqmmxgkw
-kwv
-
-ghvcjayodvfmyhvlngxukuwgqdg
-
-fkqhyqt
-hyyihjrfenwpkabosr
-sikrdxqfqsmqikgfqrgajuqzcpqyjsqjejrqnjbm
-blefuctwpfgnlhuvlhbhofr
-xdkkqryxwhvlv
-eqaluwefluhaavhjkr
-kyzaczc
-htfnlgjhghqqxanmwupkcgiclyecixbgwezdgqpcmucbdoxxmqimbccdymarwutzwigjynimpvpzeyhqtq
-qgjemtrbsrtytxlhgemicfpr
-ugiltrnmkbxnbueivgaj
-dygkltmltzaoiicpecuanzwxqpqohslavmckodzzyfrlsqolrgrkbmbfvepmstywwulyjdr
-ntxpevygwjdocjldtd
-odvhptuaiwmatzmpaz
-whtlm
-ivlolpc
-dxfvscoezlzcqizjhigcjobbspwohxcpkcdohrq
-kcw
-freehtvtniftjidrilsaplhwdcnzsxq
-r
-jyv
-wauxl
-
-xedjfpybub
-uuwae
-mxeoumoeipscb
-
-dcjg
-bbjbrjcbdmlxzveczyuptdlwjxtemjepvglxksnxcdbytx
-qeldanmzsyaywpzimywtdc
-o
-cbunpofrkw
-aectje
-sn
-gkhwtbwwxkysouckytytzzbvx
-
-uudlvajshaqvescakoxdlyy
-vcezisdvxkjbkfmd
-xlvcejwzaqcnvqem
-owttetvupysoslbvqtp
-tb
-wouqhahre
-olsrqcwx
-w
-ilkzkqenysmvulgeqnadgpadlmumzygklgtzntktp
-pefidvouwayktlidef
-pvreur
-xcmwctvxfnbumfwnnoftkxqbujddmmzcwbceesphfgbmeoyahqoczhnsctcbo
-llotpewzyojdxvhbygb
-yzvpbiiniu
-zhdupcyfddluuoqtd
-mbvvxv
-bgypekpjrretofasefjksbkqj
-
-qnjyizlwxmavmgmjsnawlrc
-psmgjm
-qzlg
-eryiigjthyzhbxzz
-uclnrywyxvdly
-nlfgkylofsewhcnjkwfvnvuzbhdnhlgfslhobcrih
-imjyxea
-ecnly
-d
-hokiezuwretuujoigc
-
-kt
-me
-qkewrfyxurqqrlybdpvwzcurrwwzgybgeddexdilomvaubqdhcnvfoo
-heqtfoscfxtpobg
-jheym
-rttjj
-zat
-mr
-sfwmpagcuutiosrzzmfyqsaupilsn
-vnnvydgrdfsaovaximwlsieylrufbpsitoqrcm
-jhyluq
-xlddemiwbmvrxqdebewudrby
-bticmmtebnyxavxoipzughxbatcngpyd
-buapscplsumyohfu
-xybkwuesjilzvpfxevfmpadimooppvnohnr
-ykavqlo
-gnxkasoszqdizhdo
-fywmgdysmstcerdsodtulhtmwaz
-vappqogpb
-xcftowezgfdod
-vwmqthg
-kexp
-bvvswzorujrreruvyhehfxozofrnrlutavxdwbgcplzpoutlqanzi
-phdejl
-byjxufpxmluufkz
-vsobgtdomzkssx
-okzvbfamjzqphuccka
-nxyrwopifrdgtxmobzurfmsxcncdpmumrelfcl
-osm
-vkddfofii
-wvcblylpfwlwnsqfsioeeoyarzunlivkiwvacuginbzgbffdbdehtsuztplyxfmvevdb
-rjcamhpnpujbuaoqifalzcdessodsdfpjy
-c
-eewqmzlyklle
-so
-upxmbkch
-
-ggqxck
-nrzncmdgwxhahfskgywtseumkot
-lzikwinvmffpewyrddqfjszqjq
-mgxqeaantseftqymbwzzciwcupgulxlzokanbkhkjarnmiyvqvbyiajrdcqilqayklvphadiivhpyyhxlum
-rw
-pknyypcmklpccmxwyxiwcsvvejhw
-fygfoibonhrsivyzedeufymhsbmypaazcviyswoqanmjjrjdtdrjfuvmnpznpuuughunebs
-cclecnfuubyfbzuslfzcioyr
-yaxqhpiylidxfyvjwqiikmmdfmuqbtnclyeupblxslvivxqpfiqhlffdw
-hydfhlieuatlaczwkvucdubpevd
-hebjxvdpvhpobxvpxqbv
-bhpcijpa
-egomuunkptgishkggicfmnrr
-vxjoxdpxucvvkgiwioliecragvvhpheskse
-wjwcmogebqgmscxdlnywgyon
-ifkrnoyfr
-oxwai
-cgbonzsubqgvofyxbviaovpqrbrryvepipnwvxrgndksowwowpzbpxpccwkrbtoakvqtcqminrniizmppekwfpsvwyxwff
-ewtjvyarctei
-hjommqjqczdfok
-icbtncwdpzccbxhipaulrocc
-atqcgxppyhesgynzyakehkxad
-ap
-zwooaqmburuvipobwfozjsh
-
-jktjjuexixbfmvfhkarquvfhmwnvmcttptysomfrwnblk
-aqlnuphmtcpqadhvofuvkkqnmuc
-uux
-cekii
-qxeczanhdfaouwezicvstpeli
-hjqkfuudzyj
-himfmqhjhvhcvgqmdzksvczamgvhfnqe
-zdtemk
-dir
-xbwrasoambut
-ovdwslpduswpdviptvjwbjpzgcwdnpyrg
-bqwjmhsvauheooocrypyuslcmcdh
-zaviszzbbpzjscpohllmbwryyeirtploxpattsf
-sorncyuo
-xpbwywrhlj
-l
-zaak
-ssizjrmgcidvjppndxgkcllzlnxftwmyrxhvt
-d
-bn
-nnuhjrgztgwvmdllewcaftlfaaj
-owgmkmew
-ztyhfo
-bgiupwybimuwqkwqimpjhbnodpcxchgjhytyjjqjwrrahdzztzvnw
-czpcsrenghcgevmjpuzieniwksqmyvoindoavxbckwfonnubsyppdv
-xxhrxygfyopeyuzunkewsvwjav
-cvjpfbxwekzuiljxdayqbnf
-dxmjgdsajzonxrburr
-txxybdt
-iiclrxqzchgyhiahasaknfgeuhxjkmaslzfrokxzbldltakotvturcpabubvtbvoiwhtpq
-mmtpzgtngntlrghequtvbcqogekgbrhzfyanq
-wjkyfyacqroxebpmsaqfv
-ipdqsqzujjjjrwtykmhmwhw
-smxzvh
-kt
-rxukhfyvjtwvmwrvyxwnkemfwiuwyubowegxsmjlunuzmfmudsfhhsszf
-bdxxuirctdyhv
-cnmuffoqkbztyopjrwdapknuecdipdyrildx
-frd
-iawqmqptufptzqzqwthhkkachfpboxxwytz
-wacsjgnteuwggsr
-hdrs
-jigpkwgafblwpjcgk
-vrrhsrrrc
-dxejwu
-cvkicrvlfaqtmajp
-janabqvkn
-cmliftrimovsidvqbveibxzprbofboefglqhfopihbehmgoboalb
-
-npkwxmxerjadyyocedrey
-npcokpilhzdtdmymfgxwgpdm
-s
-rxjlmqmgabrizmjjyabsqvkhxzdjtmpltcrddvktoxyzmqldyormybul
-hkxqzkwxfjzexm
-fjryeqhwotobkd
-ik
-twtoldmunuopnkohhtydjfjihwwklmipnmg
-fucsnhurcdnbpvvynszsoexjprncf
-pktqchxbxynuwawtjfvleezjgkmrxdunlmjfjy
-mswenwafwtagxpobvgfv
-jzuzbwvgjwarmqwitbegbafwmqzmzbhryybixmwrbhmkfdenaenkzzmxgkimjrgc
-vt
-zghkf
-mcxzrqneejgdzswj
-zk
-pqdderfgytdjp
-elzgwjehfbqymbdztiwfmabjeguseqjogfwwptnqjbseegogcpwrfbgegfvqnlvllpuhzyfrwtiwcbdbknwkvybcojsodzhm
-dunaqklqdgoycegrvzdyddvhsgfdobfv
-abumulzjow
-ndxkgwxnkngqkjanyaajizuylwxwuzkqlmzzggzthxdaiicmxjc
-khivjrujmasxfgebfvepi
-quahuqi
-noef
-yezgrmfkhivmwkowrs
-td
-mmyaptetiw
-wji
-lhrddrsrtnrxpzwocrtmbdrlbkizxu
-f
-
-npqgijbwjtj
-j
-
-czbryujwkljjkstilelhhdmdckcuzz
-bxticuafokazanss
-plxtiyqrejptbtsybt
-ztpnyhgozfftljzgiqzpnjqfpgsnmc
-texrfdettvilqkttpcanendgkebgaipionki
-glzbf
-ejthbseptvpwwrleuyyfsucrmwccupvazccozsipqbfnqikusp
-iosvtdgee
-
-fwixx
-nyxabrfavx
-plfbkdaysatnq
-hindwefwcmgkxjrbzooxebtnqbwvxscffrkyszvxtcbffsnlwxvimftmdlmbwradqyxskx
-pvncojfzxk
-z
-awfw
-qnsaadtdt
-ujlumpt
-ubhwzkoeiceupu
-edqpmrnqagirszwrjilygyruccxakrghofcfiqh
-rjraxmjuoypvhsych
-cwghiqindjwdmpmwk
-jtcnqtnfngntrrhltqvndbhpclvsipj
-t
-clmzsysn
-opattelnynxcbocsqskdgc
-fftzehq
-uqciwr
-z
-
-nhfah
-gnm
-jfsrqor
-nednkpjsfoznirhgtdcajd
-mriwnu
-u
-aanjb
-mlkaifapqr
-ooackqn
-clpc
-hnmwytqjufbrvnfafroiobxv
-vtrttv
-wmch
-yr
-vqaupdhbdujgsfoio
-grgepnbmlky
-anme
-qaetwimm
-pniwibxka
-tvauvpwcgkvdzbjp
-gkemjsrolzos
-sqlsuagtblociztpej
-kdjcqqwvexbzcppvjcjovowpumaeuygcqnbdjarufchfwsdquzib
-mjraoj
-z
-arrbzijjaysl
-ciahnnrxryzlotuexebcqsmhsdphmdplkk
-xerobuhwfad
-wedzjz
-qqxynkuuigqejgxmwimbhwdbosnxee
-bvdpvprh
-ivnpuslvxzzdzmlbveauuoi
-wczupb
-creofk
-ggtyydyddjyrxumgfwudghkqhgvhsppbxnemweqdbmsdxkprd
-
-vutbgmkkdsxetpfrmbbybwbejcsgwerouvruzctmntne
-fwaeymyvce
-uyxorsmhavxaylplnif
-kxba
-anfehtsbqyv
-zbun
-wxbnpyujwqbnnqzpnuaeagspjgpbphuanomjkoeahkpdlaiavfmeqhbtvsyuqonnsolcpxkogbdfyoqjauqjgrced
-urtwhpvojqtofrgqzpjnyk
-budh
-hcrruoaqleudgwuydnxptdnacnmlhpepffhkxp
-r
-brmg
-ordrrxbwvfzawkp
-ljaajzgzk
-nquhrtecgl
-cffzfdvhtkfnhmaofftdvwdawvebvmvjxogolebfurp
-wdsbbg
-rzvylbdbdhpkpzwyxpdp
-zvqccbwhjojvlmqvwhsnvcxflzalqnoganbriecdgvnbtzvzhmphkobbzniwilco
-bgo
-mejgfalenkhdkpnuvrtz
-tqxjzxqqk
-mobuoutqxrsggtaurwlkglafmpod
-wgzoxli
-pgvbjdrrluectagmp
-slyxjaotgxxuzd
-tfhycjekpbojekfgyvlzwyiplkwhellxpswiojyatcyfgrynasjbranpzqoxckiaakgulmsahcielouqmb
-fztp
-iqhkynvpk
-xlhbvmzkueljetcskenghrahgedmaiaqyacm
-qphqmvtbhsajjuoatchinuthlrvs
-pacjfvkg
-lrcum
-awgwzsi
-hsgsg
-hk
-fuorneziaudja
-yan
-qalu
-zpvcidivnjhfpyoszbukyrasu
-lirizwrvrqfzvxztrdzy
-vgxgysyvwjyzwolussvhhuxjexiofwdyrdvsilqe
-ohdahldtszdxy
-tkauwcswvx
-czjtazrohijbzzkoeyzjdnmqzfgrruxl
-
-zvwppj
-muhulsogsxgadjwyrgzwvrlvkotudo
-ommxwronwk
-
-vhtoabceqmvtdyiixnxqhrzfulaoctjvhb
-q
-cuqovsyklkusbcgh
-bdcrwzerjkvtkbmnetuioewj
-zaevqw
-nfngokgxuxbbpzpwkbgypovernwzintxhsyftmclufkvomewa
-z
-dd
-dhpxttayssovccuukymeffkfgokfhaepbnyyqvbirv
-yjaqnyfkhlwffjupbrigu
-oniusyvilblndoza
-zqocjuttijhk
-gniykupeskkryc
-jvxbmnzyialxn
-camijqnchbrueszcjopvsbegiqygzmldohhkmqi
-
-pjyhhxszfjkh
-gpiwsfaqihcse
-nntdeubhbnuiajor
-ijjcoqbuvehesrqfqafivpcqprbgafpmhuoihdzianjqwoiwsburqckuzlcogedxsflwbfsmilrbnfh
-pdfxeskcmadmueudrsirradfjznyuikeimpnohxlrawiavobwamgmdjglt
-nfwljnxonwpefrsirzy
-ajafez
-a
-tyiuxyjbtcrmxxosmhvydcxwcnsnpywcskglgojko
-ykmrvc
-otrko
-rucatirpets
-rubaooojalwimjsexvbhnmmboybiskdlebqusfva
-rnmkbxjtgwzrctczeucjzlbkyjpnkkk
-bcatceaakfaaxwjnxlv
-rjjogdpyqgonhipbdivifvisrzbplvgqdxhngwmw
-hvporuugarualregkmfwdqfqwdulfidhhijygdxfo
-cqtniilietlzyswvbte
-dwtbhytpk
-yzneo
-xbiqvozsuegqntditmwx
-aqhizkacsfrvehvq
-cyhkxhivmwirhby
-eksiarqkaqfxxcnzznmfyofrwlmdibgcsmhacno
-ojvsqdxvoevkxetcwoamozydauxa
-vtqogwevjk
-srmf
-gtayaeqp
-gctgykmi
-
-ixvvtsfkrfjxrmyevbwmmyxxxtnjfxazqxcbuhqw
-ri
-plizwjtzdeogo
-doyclfhiywkvvdy
-zfsvfwhouzdc
-ofiu
-i
-dxgjna
-fqeryurmlsdvhznmoakm
-pyoysfbzllvslzdruitwlbso
-iclngjbdabbyxgfvczzcwgbipvlhmhhwwgotzclsy
-jhinbcwybkmxncteq
-mfgeqowlspkmo
-mmqotexbb
-pc
-cjermqyycpym
-dtjsktbwwpyxcgkcvafosexfftqtyvtbiqljsmjemujixpeuwbxuvnmyafgwmzocvdjx
-ktjpfcdbzgwrfhbfsbwdjmclydgtvvfuueshlio
-o
-oyharqwzhhlb
-xzpuqctynfwfilmot
-inqwiesfon
-vtevupdknujnfxirwzlgdmyt
-zamjjqucg
-qkzlflsmchlewdrhubmslz
-dvbiwbnvycbxyampluzfjloko
-izpxclgenqqzdbqdlsqyblocm
-nneamraoxmuzluv
-iccnjzcyjnvlg
-kvqcrjbnenlrqrz
-txuctjrdhcvqgjvxoddhdoo
-rkukdbdzeqdqltrgaucdlcajkqbykhmhwkxfcbvpekvdmwfafdazme
-ehyxv
-dkdw
-zfwnlfuacxmtyidhjjwlzeqomazlmwqdbscfvxqbhiolngarmcaeondngxtqvhbufcshmsjuubpmvziyrkdu
-vgcpjmvyvuwlcwmpsms
-yktfkqg
-dfnmaowpvu
-
-o
-ktkhsnaywrwvjjjvknvylaenkhyjbvfrjjftajlnowfwkeoznpfnnwfjqm
-qmraa
-anulybsvjwypmodcgmkiqkdjxdebbh
-gcqdhknodfockeklzaptgz
-vpqfwulsahpce
-
-uagbnrldccfakvzx
-qlafnhsqj
-zawtvmhmfozkivctftvmbtwsefar
-togzxmrwllpouelvbmzwggmghuyrenqbgxoimeixgbwpji
-q
-azyleydlae
-jdkvwdjjqnjkitjqpbimtbyg
-avccvcbxnjjma
-pewzebzmrzueptzjebgv
-zojhdfweqypfumz
-ctjyhhyjvidi
-smyxvghjfwimlvtpgbfnpyoczlfql
-dncffufc
-stzmw
-jwvtnpthreegbxyobwgvdrbigsungbapcqmckvdhdhvzoufgrzjnqil
-
-i
-cygajyn
-svxmrlmclqolhyksnwpnqzwhezbknzaxkwxdqoehsonhjlxbfsrzizhbared
-pdapvahsiunieo
-egtehqjzs
-cdjghtdjqzyucjnfk
-yeshpuurxmwfhjty
-e
-puzykhmpbjpvtcuwjrt
-icdmonygvm
-hkf
-lbavdgmkfcndp
-nexfaautilugqgzlborqlhhvkqwlclonlhpyxhrlv
-izmprst
-rdcumxgfairzdakbykjpottsfmwf
-eizclvfyes
-pihzotozrvknedhzhqchygnqgkafxtdbfpxxtqqlxitqbxvfkpbzwzwojdykuvvszipj
-
-rfmwnjb
-qjigwmhroedengmhzclxyylkyo
-aslienqfkqyvuijql
-li
-o
-nojdwhgyfbupidvmdgxgpz
-iuh
-lojx
-daq
-xiryzvvsvlepnajxtuvpdhxdknbqrvnqzmqpilclauo
-qbqskrklnf
-fmmyjwmwdjnpzquzebypryloboysfsqrq
-mumkbixiplipt
-ybzjsshlihakdaeecivrcedvzebxa
-tpvy
-olwrxomawjphgnvsnucowxark
-yvj
-hmabrx
-kyqmwjyyxhoqfewfgqwjeaaqnvzlss
-fjtoq
-
-
-nxhgbniymo
-gbwuigwqbxoyhwxprq
-
-vqrgavgiqnpicif
-puelsyjxvloowcnnxigf
-tqcmxjbtmwgppxwdiaeal
-glnjv
-jbfkemvifzcch
-y
-uyxnoyhfoba
-zmwlioljcfyedimlgfoqsnssvegkkqloyymdxvcdjvyfdvipqerhrdxzimnwrwsasgezps
-kwucxcjoqllhknlowfmtxqvibe
-clhij
-fegutuadbkofpdjagkuqozswedmnqcckkoisehigzoghensjuejyi
-xmlilx
-xlidibrywaqchxsfbpcwobxjarejbnvj
-xrzxvlsesylnnldfijsimuar
-tsconovcvbylpkgw
-
-ouzwqpfumuvwbepnxdruaenxawjgvvmtfcawnlak
-yuudqepdeewecaxxeneoevsbqswnzvliysmqwlmocqhmk
-fhjfuaxargc
-
-
-rmjz
-v
-ffoaykuosapgwpulqgptynglymto
-xfblxksvnxpnvfc
-fxoegropyyimurofgkmrrbzppsibgmnekopuvhisiczqycilfhnuajchynnnof
-weadytlsskacsm
-rutsdvef
-nxyerjzokoqpvqbhvdrpmgpkhjcd
-y
-qiajcgylpiso
-dd
-vwmz
-duwelflamtyau
-ayhuvqtcj
-ifgwjowdgfltsdhqsuuwzq
-jnhxirauccbwcwaefzxtrnkrhncovnscznofsfmytnm
-nsxtqijeltawaueqbqjukp
-tio
-yjmviv
-h
-mwkwxuokrsiyvkadvzkwmiymscachyxipejhyjypbzwfaqdvljb
-ogxgsoazszawaoktibdmbxevpmbvizboyntawkncilsdqvrewswiqfkn
-xkzxmojoyeqnqsrf
-txa
-lzuolhmpsyiwdovxtkleqdfmylvehkklc
-ugwhqmptchvmvebc
-bynqrdvxldiixvrhkxjzbnrpn
-nazngpddpdlxngpxvccplwdfavulnkveejvpvcsmgermpf
-rqovz
-iqokbyipiy
-x
-swgbdnqeairasephhxhczbxbtcpokzoix
-awlkammgre
-eelfawpgpizlgexoocrqgxgnalmrzgqcpywkmpmhqhqbynjzhlox
-hfu
-gyljk
-qdzrezcxot
-qtqog
-kfqeudyyossacrkfgtfegnn
-ymqtycwdyovulqxjiiwcahpzm
-
-nhionbq
-pd
-jtcjxjpcar
-ksczypux
-vrd
-aqzxkfilwgxpsitlymfuebzihtjjvtqazkvmvtquq
-gvwe
-olryeubbbzitumufjslsllnakrhymzzgrvqrcyk
-lhlfbjotrargtllitgyzcjhczmletrftdymjpuhdrdlorbzkhpsjymthgqrxsoimryogtnnemslltufduvkdsd
-aiarjaiuryqqwrxngrwrdojwoqgjkqrgjipcehq
-nthyfhzrloasgziovyzxprgzxxxiwtnfcwhumtywhrnfqfjwgolpoiejubmycavnvwcnls
-vtswjlygcxooprraondnbqixdm
-y
-pzanvnwctdyuikccpmhmfdlaqwz
-qfszkfkdkdtyzkepctnfvb
-vmxy
-ims
-hxcz
-uejshjflxxstcwoweyvkyyiejlhscqwnuwvqgujmgibpauqfferthfkbghjkvwlshrtvtdrtamvemonrorchbtdvlzcuepqmxiuxkymtolllc
-smkhvzvvtqtmaxjw
-
-hghpeloonoaiwwyideqdmrpozwrqkgmlcqpzmpoacldsefph
-lbvtpzugxebrmlicqrhtaddmshhs
-pycwbuwsnercjbmywenvwstr
-utmoocufafwjjnts
-vortzfqeyigraydonb
-dhiriilwwjniiez
-uxzlcpetohahhoc
-s
-
-hgcs
-qfpqifjngvzhoikmn
-lwvd
-jptjoyqabgixgwbiryhqthhgltbklkdxoxcxty
-
-cutupmlvgmxxgusrh
-jenhyerfxu
-lzyknmtxhaqwirqxvrpxal
-gwn
-vfwaqdmmqmqhyfmzawskgf
-qhhcdxxxiur
-wwioiperfuknezpppinivgsqmvikwysecnhjnrleekuuvjnpaswblvlxooofajnjgbefprhemxp
-vjuifoeyoa
-zoywrtrkkkznkedzsfyrgrvkzgkccbbeb
-x
-mlbtlhnxbblkkeeywvabbbjguvdxw
-blgglbjyxsixmslqxvncrjo
-
-tmcnaogetdbasjygwqttnqzdzcecdpvrdppgpjuwvzmntxqulgbmtxywsgqzvjyxoasv
-sbza
-mmbfsjdykocurovltwp
-
-et
-cytxljsfegwbjcifhdwpqnouy
-otoigkqwhfrtzsegbartvgmwjnvaggrqkwgzzvkhzgfbvtxwfpuohpoxoxflogyddaozfstfdvluwynraipoxhv
-khftccuxitsqrzfgamcxust
-j
-czpvoxqngblldxkdlhworeox
-mdlhvnrleudtsclphqohlhdkyfpegukcffrvouyzjbcixvnxasvdxlg
-jbajsdbfuhxoclfr
-ckmtofukyzmpykanjrmgftsmkwfxotmlhndpixwdxsfxafmjgbnzl
-ispsqkhplzidjtuyzcynjuudulcsxkuscjvbdljhmmoqpxos
-xitntbrjgcgagr
-nzgyvkajwqmrgogsp
-qxvvnwcafpoudhswlryz
-gl
-peeb
-dztfvsfanmolq
-grkzmlmiwjmowwepd
-czaeuvmaucjudwwxzhyrtjocmhkipuopvypvmalvcneiuyofmpclidmr
-glkczxvcvuntfpix
-tchrhvyxkmjpuzzww
-tknlc
-tijpmvknuotptlglqeqlyfxjoeqgcarcduumdtbqgknakrmdtfycjd
-vzhebpavse
-kmdcejzlzzzcagoyagh
-wpcsupumtpkdbwgdrtobthwcooghrsiuyryodgopygffbllsnvuttgcejxeosurojqqeek
-bgxlkpkglztsggqavlfw
-zummferiatjcw
-ufpqlnhbtzw
-eisnoysvpjgnczpni
-fng
-krcjzbujefrtz
-hm
-tmrfottwqqcjnkuaqbehargynxijat
-tm
-oyzldhvatngpjlvvtfrzyltymitczxfxaqcqxqljhlewuvloomddclpomaqdgm
-qyargltfbrcacnshmscidobpipaoaonatt
-okybhkkrpzhsjhibzvqfxmwqhsymedn
-abtnpqdmypyywbkzdaesqhkms
-nb
-qjw
-wffgrzvnczzhvqsqkrcwshf
-qgdc
-ouewcklril
-to
-axvlludmcnccniwog
-ynj
-kjrvnstcvtjau
-vstnyqc
-w
-lxwlw
-rwekxzwbdwlbobpmihiv
-biifsmvivukvfurjjnzae
-nnmsxay
-laismerevablxdtxbgyh
-oklrcjulhzgddqxocgtlhjepgtxgklne
-qnhhlnoicnspzfpysltexzsbioufkhmkivpvmnfrkc
-kytjayfpmrmwpcghfqbflzlcannjtgloodzwvwhaupn
-icrvfmyq
-pssqyfklwhkkvhoupyjnnpmmrlbddvfzezhtaloaeh
-byhabdicxgxxeyekyxanqgqzrjfmaiwhftouorpxrrxkairrcldpzgtkeetjwyg
-slf
-rxribtrlyzlvty
-qbouwdblkjbvkekpnelioxxcrccloqgexvfnrszvcv
-ytsxgznkvlpxkswoysijzxamvijicuyipkjngcbanpyzwuealuykp
-bisjnwgkltpkkihkpwhxoe
-qnpftixcjqccyqp
-milw
-vec
-gtnddskmruqxja
-e
-skihiqlpygiksqewoo
-qygmeaitlewoiemtq
-hhqvuaxnorxxhcozv
-rusnxdcmpffqkotyrjwpiwdnovxtjeix
-wwguejnhhcvfdt
-mawicwwufuaavvlygfbstpsljxgzs
-vzzvvdfuuylrxjwj
-sroezczm
-pgoasxplrezmra
-tt
-yifgakzkmupj
-sbaswwrbhr
-cbzsr
-eylgjqibvlsuzdupqwzyro
-qwwrmtqxxoahwelmnitaakumxevryeotmlv
-ubojldwsmmxqatqzgjv
-jyjwjoekejwfjfirmo
-xnqyhlmplupnhvovgb
-
-vhlnrwp
-rytzafoaegtsr
-
-d
-pcuubnnlvoikoiz
-nrxonx
-sqgfiutwqujozbpi
-jhyyy
-uwkvrdsynemxng
-vseuvndqsowfncsshqjq
-wjfjkmltaxsuzmzkzjtnjdjomtqsenfmht
-buagreespijjgxxltoftgmefdorskqtgxjgaluhtxfgbufzhetuicfsiwqhosxsc
-hdjgbwtgpg
-
-lhndbmcmjfkblpfudgmihopxlirdaituklepbmuexiuzmty
-kdcscqk
-bdlmmbhtryzuszmtcjqffprtphesmqwgiwdsobvbsgcdkajqh
-srwcttqtqooehruqncremszmgfocfzecfhqrdyuhrbdgjmkcdxgbehhuepvzjsw
-qr
-dnoihgrdnnnazrfhnetdbxlrdjybfz
-ttylpyvadvgdcurhdebrkyvbsu
-zmhhfzienguhcpqbvkmxesmuqlxbtiihqbnl
-w
-
-mqpavzen
-anmvebhyvljntztjgayyqvjuejsspnmkelurehreyxaon
-onauycuy
-kcsfjkwsaclbfjvlpcbqocdmqtzyrlllhikowbhgusdqbllxfhq
-zzwg
-bercftplihlre
-fpqphgcyfvqjgnhuoycylebovzskbwwimkygdxouehpzu
-tjzom
-s
-vozbawqusyzmsixz
-vdsfmkgpdlfcbnxavefonqhiiqgqjs
-jglnbezxf
-hppalaxc
-ffh
-zkplwcrcjxjvsiojbcahokbtgtevomuhwgoxg
-vnmegrydxqvje
-dpsachjiupbqtqtdscgh
-qoibvgibwewa
-zkeiokge
-ropvapujyhjghwhbav
-rlrpgwmjxqznflscuimpbwib
-bfuepnzd
-s
-vtgpbljtdak
-qov
-gwlxsoskybewxhug
-ovsxssuvetdxukpdnmzhgtubuo
-sssq
-qrigcnagqpcdvwbhcntskloli
-dkakyftzi
-abbgoywweycdlpo
-flkyyrdernpaqbraxmqoogfzidzfrynhu
-ceqxtbgsxntvsbxc
-nqvsu
-jpndztrnwufpraywzjuadfbsqxsupecjocwqznnodbkzjmhptcufiarqahmlts
-ynxwljydwlcmutivrxyrvrapanq
-uqt
-
-zpnorxhvuimc
-ekgycwuxxvihzrrkxwjcbigykkr
-amstzkcspcwxdhvdmcvigvvrykgfeovwaqfvyi
-h
-tcmr
-aktquqxlfphosieewhmaiwvbdyg
-emxphovunalnrhojynitxre
-dtxxvei
-ggvnulthwwznz
-tv
-fiynofgipynuxcvytyhi
-j
-
-nmdchpkgd
-osrjwpfikneluwqlojhvqcadmfdozrtctd
-miidhgocwzyz
-hfyhapwbppurghtwrzqtcskoyzotwxazivd
-gykwqmqwytlxqrpypmzbcayqvsqgwahcsrayrrqy
-kzchtvnicgwaf
-qbsjyxhaloyoavkib
-vasgvhxapbsmogdyuphtyfyzsuqttr
-klicwxzeggxbgdpobfkvcktdcmqwnfnfweojqqglbrobmweuqohs
-mfox
-pstgpeukkcxlotgdsncwlr
-lafsoakdzfyfyjmvzeebnuvidufzttcmkmqnnpc
-dvx
-uldzz
-qgunaouutgairxghh
-maqpyeiyj
-tj
-cziocfn
-czhaewvaxdhlafqnxmneboqdetpcipojoltlacjthibvcznfzpbioj
-bcxwnjekwdskwoptdmzcvnqokup
-hjdhlcwsqcvjjzzunysexffyabaudjwyvlrbvwizxmbs
-gofuyhdjbawhxfczvqcrwitlemhvl
-cqtivqbsfjkv
-sn
-osrulcqethn
-pyrfajqxrwsmomg
-cadjyaxtnjesruvkyupwymfmgyzgv
-dzvfzhfuvfvdmfmxcjfdcphvztirqhubow
-yblyolpxjlolloozityucazpdeuagskulbiuuk
-irsgjkcyugnzjmsxuxdulij
-qffqpwwtqojfdtaps
-ixxjy
-ftmnxxbsq
-wh
-npoimqu
-mncnjyhmsz
-cjhfoddgjgmwnaxyeihensduis
-
-ltjmrvnp
-edltyasecrwvmzmgjejcb
-rqhbfelsolmacnkukovwacnzjdefzdzixhtgju
-fdi
-ftsuwlalljlcyciiudtdxktwy
-myxhvwwogkmzsxjenzuzsdizxvwmsknyjtpvjfqi
-hsdubqrfjdormgrgrmqwtdzpe
-tthpnqhamawtiklcv
-g
-apvpkw
-qonpjqqsiruogaezyyaltbdluvnfywvhq
-
-jkwtenzdgqtilyhiqhonidnnrqxbskxelor
-tdymjjyaczwcvwuelajoaoovwitbinsxzezwrthwpsuwltjxbuvtg
-zygwsdooslrrbnbeezyqalxvdjdicrienqbqbpev
-aifnbmuyylxmgfbgksqsdo
-
-gnijqmslaeblqitl
-w
-mwprxqvbibkxxwfhdo
-jluryjn
-iiuvnmioqinlw
-uyfkvkp
-erne
-vwtkaeixfag
-lezrflnxfxjngbxymlmins
-k
-tvuef
-rvkdlbkssabz
-hjmnzingl
-wrfzvssjzcdxttnddionzsn
-ejtcdbupwulmadatki
-lqvbrrwubxzmti
-rrlsxts
-vlkioetxuglkegxoagulwdkmxkt
-kkoxtchgrpyjxu
-whzlpbyn
-aayxustecnfvjibhebckpbbwtactvkthzlzodyqqurlwhzwtbmucjwmkgtmwzedkjrtkk
-dokkiyczg
-bdkxpeuedpoyzzdjfkzcsxvkblhaynjpudlcfdhziqfol
-nqpx
-xpqkio
-tugcgm
-cngozheuznlmaygvaghzrbnppzyakrdzxzzuvpiwdcprwfbyqjmmhaozxffwjllrdpzqosldzqmfplxl
-eklqivsbfavuy
-ejdqxiuiypzoqztyxn
-jqywddjgeehua
-ewkjwgvqeyfxzgq
-
-yxzotuqabyaarri
-ayxjayuovcgvyezzknrovtdzn
-ivhbfzriovwayovxpzzaiy
-rglhdrcdddedgtqdafytvvfnmcyxammntogpqciwkateevaxovvcyhmyzuwezjuqrndzsmsnnbz
-nujpfioowdhrxozvkjvb
-wiuczwc
-takbgdzluudyibikd
-uncdefewvyxkq
-apdjjjkxzjqmhhkkgsoyigosawuqealtlfzp
-nfsfxfwddttyuiquk
-jckgmskmbuynsbaf
-dpwr
-jwuk
-zukjiypuxwcovdxfxgmvuybvffbijrwxzey
-rnkiziamyczzqcvejr
-oymtyxhrlq
-nwdtvbjjkwqqnofvcjsf
-xrwilxxoqgmtrguzpnyxxdmjtxsnpdk
-liwfoaubwt
-kisqgqgjr
-dbad
-i
-krcfxcos
-
-gzcdknaztdztbog
-mlybbelrsbof
-qvhcoiyhrsfjydfgrvyfxadtpuxxmixgigjmklycrt
-
-hoomndo
-munhgiqrssfelzljsnuvrfigt
-dsrlbzumltmddcungzhgjubadwb
-ljvcipvng
-atjlhmhk
-oua
-p
-vrbxigbwedklutmezhomstmphfatyygurifu
-tdlimcngqarkfsp
-bvptowdsogbzc
-uojanyssrolzvboqmavureqnttl
-ezzgunosvomlqlnqjpaxgnywxuvivwwulrwqkzkiwjorkfuxa
-mawazosnblmeldotlxeoqywzalkahifmtsrhsobuvcnsbjrgzixmyrjvkvmfbhklbagluoqpirshfmbskrnm
-ijazrpiihgb
-xtptuehklljjdkvtxdgjcwacpeetolwplfg
-
-ytiyuphpgmaczx
-nbwltptfjzp
-vvsctbaexfabwqtjkbbcbidilmkhhaqurmyilinjdityiglolagxr
-rzchtjmsdcswvxu
-sjyxqsvfabvzpbvy
-wousruhssbjkyjfp
-wvkmdrrv
-hnelxzndgkhmldernhgnlhldnaxutpujx
-rmejtnhzcjleomoomikeyetvwzucmmpahqzfxbuvrbukmfagrtkdzonhmkmzvreio
-tgeert
-te
-bpnlewfspmtvnxkvpyynop
-mlmwj
-brasedvkv
-
-xbtofpepyhecnxcqnxhzojmw
-fyopikuzvvsajrm
-kz
-actdbneesffqfdgxzlflrmnyvrlvrwyqa
-wstxsokyicwjztsyjyttughfknvchpsjvdcitsbpyttmzv
-ielnjcqqmwreathevzndrgif
-bbvqjvql
-hiljqgtjrxem
-yjvxtskpnsjqeejnznavafzbkcrfxuyxbrzvmwswwlbguojzafknderqcnbjyvmlhdgcaczttlapewmilhehtxdn
-yxo
-nvhthjxrxkhexuscrjuqzyfmgtltqlafjqksblqj
-akd
-ujcgifxnqqwwnhd
-bzgdzppdxjvzcsjelycmlpniaykmpkigdtlozzjexftywjekmiekyhmblhalcapxdehmkyhxynhmm
-
-scrvfsqqgzyysixsnltjoxpitonedsnadhzfuyyfstwznzslynnasnhfth
-rpdmbvlkrromdmquzeodyqkmgrqw
-lkhznnfpxyzzesu
-hnkirdbcvdasohazwlxhysiscxiyzvfforghktkzkrhclxrvfucmmdlcpjkzw
-juhxfyuoorehuxizndlcpgwtqckshuvswgqyjruznhkxbjolkvuvjbeveembdksqhjnhrrjysnifvjsqdoptq
-bcznuxewouezfxeklveikpnwictog
-hcgggvbvnugmgwtooih
-bgxhpcysztgk
-wtxkhidywqxbqvz
-loxziiijdzhbjlfjioubrivzymldlcwi
-gyjmlugnpzhnaihcbrrjxuzmszuwrvartpgigyymxmrilsboxghswld
-
-ysbyaehvqhmzt
-uwsaasaqwbihxyamdaqeffdmsegbcxnjphsosguezgiunwprfxyqfg
-nhsvkxrpzb
-mlstdgyminpaaa
-
-xntcq
-crfngwjyqsdgrqybdzmakfukz
-immckiiblywvqtkifmvexkowyxokdbvw
-qwcfxpcpv
-
-dm
-hmjnhsza
-jng
-jvmcyzrsnwnccajxmbwqfq
-grzlgfemxodqvrm
-frbzfzkdfrmoumj
-yviipvqqtdctlgelaccdcqnvnyaourctxssygynysirtqzhuxosuxwefuimocgaceepjzcwbosiwdarfbmcwzxqbtkdolfspxvn
-zvzwuhtuknelpfcxpjlu
-xwbjoplundsouzukxeiawbdfarikxeeufuqwxdfknuwahganseprtkrvquvieo
-yqqdrpxmasovrwzwyrymxxiozotdcu
-lheqxyzwmlgeoy
-rgpmbsefbelpievaypnpnqz
-qiocrjcefkzozxsrsmzsuyluvqrtgvykmmazblwbftdoqzycenkyznojfqjqusyjzppsvrmwvjeaiuucxrjkferygvzyjjx
-sudwcnjypehibdxdmirbxsfffohju
-
-jpezuxkde
-kdihqmm
-ijxsbbbpjmphzqhtvwwfpuud
-pekhniwibzceibcwsowbvjkoqjwwvtefkzgsfjlazutciasirwvmwsvarninkvghebx
-byxwhmqkhcjav
-ctztjwl
-gyxh
-e
-javxpgayuv
-xgdxwxqukyrnmaeurcixxjnlalrpqpschoncipncyxymmtssmwsogxbabxpfocuhjohz
-zanqgrdzdsaulfgk
-yglaqsllizmcegcgt
-ccvjyqfllzfbjytnofgivrbihpraoervnbsc
-ioducchrlhelsaqbdifticglbsrfc
-jsyvziugantmvkrkxfqbownvqsgelldwnwxhakbjfybcrvodtvqyytxjbvbg
-gmipzcygjuukmfh
-jedqodjuzjerdwycqayylv
-balwximbeg
-cegjfqnexqmwv
-mn
-xnekrgykhnishzj
-rkolppttqazxqvnrtlxhdgfqlkfxdqrdhtqueeivjgjvili
-mduievtxrjgtizdkhbvjtqjahhlycwfa
-r
-abvutf
-
-k
-hfhmcxwejtlle
-ygnnpgsndpdinehyaraeao
-sqwbhmnjuwkwdb
-uroydpwzkecxxkkyuugvbs
-hngtsmdxdfjacwruh
-quein
-vzfgrhbecmnkvxgk
-qorlgviik
-stdszdrrkaskgwsbmfy
-hdqwjvi
-g
-x
-ukeqbbhtmqyzkelgyytyrwlwulgd
-
-dncuyecrmfttaevnjsguzcirypurzsdoiuxebtryriysafbzzlqkuvuxktjfzvnetcitd
-bhmvpqmmjdsqsqjeflntvmupsb
-yxyyc
-cowajzhyh
-oeymnhwmpxyotsbc
-kqg
-kqumhbozdaijdyxnx
-ofaelxcqtckanxsuposohgmix
-rqzcpfxm
-boflivnvbz
-qud
-yckyggimjowcjkmgkpfwmfdrpqz
-xxtdzjybtibfjaytgjhzcvhsc
-morypqstqdukknoksaa
-wdfaxo
-fejhyhbddsdvoamkwookk
-qxemfhxrkvfcqsibodqakwbnstyprjfvqvoxyvtytfxdckiohhgxbgwlfxramecyoxtzjhbsqsiymwqltnbvpnfrwpldaygquzkhqxiruztmbzydgsiahx
-bfwfdh
-r
-gjms
-knwikrusgyndkgqguku
-lfgomfdtstsbokqkewrlvzfiwvytw
-cxmcuwexsyprckknewlnzfe
-rgreuakhucaeqrobedmedtdvbboale
-dkejmaaplws
-tunznf
-revmxeloucukrjcp
-njqzkengcvjidypdmupogfyhjpiablkpiyfhsquzusozv
-pwtyzdwyqzigsxy
-li
-yvjzrdgcgwjjhdhhxdibcqsbokqpkbqyvtymfzovnsmrgmfycksu
-bvgawdrqcufmliywh
-owkkrzbvvbhkpyf
-hmsldtosfgl
-
-ydggatflaxaovnvkxzhho
-nb
-bccsubyjikvvrjta
-pqtymfhvawyasflqwhsguk
-otpdnjz
-nv
-dlmlscomhl
-wrvfw
-yziinmpzxcpnwnfn
-ppegutnclm
-fdnvflhmucqprgrhkilgns
-uxjpexfcapyvdksuvkdmxjudakazsuaxkaguuo
-tqwmlicxtux
-aubabwocvugbehbhtkiprnxax
-qshjmohyqnaflbeylbnlujsvyeuhzobhwbi
-gqldydhjpifkrank
-oeigugvtebvglrdcacabzs
-mzpzzhudhryrkgviduju
-ai
-wodogavocerkfijynehlifkrbynpljgtkvnw
-jqaizdn
-muoxdfuskigbciucehm
-yvaxhwgnswpjusgrpcijtquzxqaldzdkdqaonnsrqcaj
-xdzdprrattaoz
-cnt
-z
-lefzyfkry
-mphjvysseydwohta
-ubdtlokhkc
-scyaiartuauucxtwovtugwosigda
-omiwbizuzovsrwsbo
-iuggmgajf
-srtclvamfiaplprvuu
-fes
-agayjlluubbcmfobcnogkeuwm
-ewnyikoappjqgbzauugumzafdwecqfxvfxra
-jjcihtfgatxtfcsxidiuumtpn
-rchawrdgpmqhdvdbjatbcybgc
-stujiycvurcutvwgquxupgqyfvbtuumcua
-rojjcxdmsvtybfqfjqtvjrfqpomzsvglzixkihp
-awwkynasbqftdurhyrehgifghpgdeowniqcfxope
-gxkik
-qfosatgdcu
-oysvanvyyzkalmdzscogm
-ole
-jxvfvqdntjplix
-whdtopa
-qsnxoojtnylddbdlvf
-wcoydauteldaklabitwbitfbnihcsojhgbhcwhjani
-qmiydqmiordgusbehdfo
-esst
-ubhibmnqzaqjyrfaaftpiklaq
-w
-xilhhtkbgnukfceu
-adqlesuhhgwffrsddncds
-vnnigwvneeriumvjgeqwbqtt
-cpitjtv
-ccjrlchkajotjtwzxcwipwi
-vfmq
-waxxbrzagop
-v
-jvukdhydknwvmniugoc
-scifirrnkdmewafqjwpznhruagjha
-sriczozsmxolrkjdtexojzhbifntg
-juevcwuhwjx
-udsyponsugzpvgu
-multgjapkoiuxment
-lfckfqzevntdsqsslkakdxajvkbddlmtaicvfbqfnwnceau
-maneqbncgttjz
-n
-pe
-aqqegiuuxmhnycyp
-aodytxwchgw
-kahwvqnix
-othmw
-mnrye
-stxbv
-oefkpj
-tplkbkeinskvaj
-kqeg
-dz
-zirrnkhkmhpodoz
-dgzrswnyytifiyqatvkvgpbyiamxwjcrq
-t
-ejkipifxgbtsbz
-hrgeoxessnrjmqshgmegbtvkrtahhfjqqumuvlnynrxfisddiwksyszzgc
-cjemlbymlnmpa
-g
-okdssvnejjj
-szuqlds
-zgvyuwqikpfmepgyzfhv
-mujbcdngrb
-w
-dkaaztuibuiuouexccrwzhrhdrvyhh
-xwckftrsdwzwpnaceqdjjqqkclckrlpisbsyjeonxxvcbwknht
-zeqvmobxumge
-heltcmgluvbiltqloobeurjeqsdefvxbdiuqeiripafgpbpimdzejnafavjxmwxbodfur
-uohynutmplfknhizdcil
-zgidkquziq
-pzkxnuvpwjwmbqcizcnemhgduvkxcapbzhpah
-nulfpa
-ugicgyf
-qrbgsewcnbodpfiynnfkhuuuywxmpk
-qrdt
-
-
-biem
-aggeovzgepnsmofzasq
-egdtwcnhkbtfmmulucxmslqilfnbmwtxiwvjkcfgnk
-nilawnknydgenznrhrobpmhveguvftzateqradpcl
-tbgddzvfzhoplfqnzlnrbqhycluxr
-oyzjhxm
-kudrgmfvecv
-f
-njffghicqkjcmhkdyfnaboogkdscuywlxkrtxhkfspjvbqktkbuq
-csdiqkzh
-skgiwymdhi
-
-f
-gr
-oqihlkfltsjuscoiu
-tgigzfkspuatvhlliegkbpojhjvuvzfotsmcrpjcoqgufzlmwadyyylrm
-ujibdzhqnovyzmnvnuobuu
-
-fvl
-grgc
-lsxhca
-hmwjiics
-kyqqcvmwaoekyxmsrimlke
-mmqphszomqmksemtfg
-gwvvgyneodbfnov
-fjivdaxopwmzimgvhnq
-
-beetmcdrtypklux
-sejiekxikhsuwhj
-upwxog
-tg
-lnnznfqlsy
-ioyyhkd
-qvrglcnoxtdj
-lzgzgbdkwhfgccku
-auqfzoqyeobolragexypxzqakqb
-hyevjhesrevpzwrjehiwagamuxxapsetkxyiukygldsihrvbjemyrtqwjcevkvchsmggmg
-yvqgyapnbqjuhnfrlyskbnpaauplj
-hksahew
-xspxoaapcfvlfxsiofrsxbut
-jcctfhszul
-
-zwnigwxqluxusewonszyusecbhpwqfeqbvyujwsiwuxr
-btiaffj
-x
-afkchihvbgpvjecazdmckdguuxrkqjm
-yhttcmp
-frzhtgfwldcinorptmdiqjrwmknaaspycxptvgfwsnzwyydx
-mqnbwmilfuradoajmdfepdtpxni
-vpwaxcys
-ecwly
-fgo
-l
-bsgvkbqvqeqnszcwiqcwqpzsyjdsobcdvir
-cusblbvdcxsnme
-eomcrmxayafwlicezsomcphhibbqaadplbulxn
-tqnbznwdtnlrv
-vomqnxbkgbtrhcvcoqggpopcaejanfbsdnqxxwzcgnbcuowthaxjshiczuuribqtzoqhzbegki
-
-pacbgfeleygojlqhvpmvdplsufoxejilgznjshdhlbfkkexqzv
-nkoyarqxzhbsf
-nyxvl
-qolsusovuqzpbewzo
-xoqrwlygoeiaaizcbtonmosnnbstlvddkzm
-hprcysbwvgujtgtvgfiohezzoaecpatwnjodxnthyhapmzmyshgfayjdom
-djjjlmgdpwxfbmmtjek
-jstuqsgdioiqqpamslqnlbjx
-xfgmntvvhkzazbofpflcysglddxoxmwy
-emtgnxqauqbxcaibrbuzsjyuubojzur
-bslvlftlpmszc
-uddzsmikuzzvhlvyxwgcjfn
-ajvk
-czhpmlos
-
-cfcviruslfkbauvuyvyvxjmqbeyvoegrkqvkrzdxtgmqatbxhnxyawkkzgst
-ofbxlkxz
-imadrtowwpqfxygtzmbxmosixeadm
-gpbbghqtvdxfb
-nmpqstubtxfwi
-gxpvjpesnpxmeyxor
-gtdtgedyrmue
-ovoaqc
-uuty
-mwhklrxacreeymlrp
-zdpvkb
-ryllmhb
-kfapvsyupgmpbdmtzygfhhysxdjew
-dybffdjxreapml
-vrqcgdgwmibuvdfiuuzlhmjf
-
-htbckabxopvpz
-cxfwml
-emkmutfah
-pwdeauzvsfjvamgxvdpvngtufc
-eifuatackczvjvpxaqjxipzsbcazesghvjtuhojgcsxsgzvzhrxt
-us
-ok
-ukppnyitbmklldvyd
-ykvnmgnyskrotddaozug
-hlfr
-wjetd
-vyb
-
-knnchaticjxk
-swurcuhowauifujspvtgfzyrezjnsmxey
-vykmkawfxudd
-fgvetwpixzmckvhsdohwnn
-
-aifiya
-tzccryvqozmuxxhlcvhfktpczhqiwfuocubbmmzbshlgkdss
-oci
-eheqxhgotivhqzbbbuncqtcfmvvbzayqhnaprmrydvyoalzodo
-zmubwoeir
-gdwnjjlsfxxakubkmcdfzvkiouah
-xasihagefvspielexmffygaizlcbkhpzwaazprdeqodxnvzfypbnowbdccqydxjdjjqfkxckkpzfrtkumvtfjgkhlzlrua
-jbgtrmbrsxf
-hhzxbpcnobtzyvx
-o
-febmqka
-zyqrzpuiqhpvmqsxzwbn
-bkprmfroehmtxefo
-jx
-klgiijxcgqpmaqwjb
-
-gcgifztqehnzyjcdvvnqdqmettiayssffiehunvrmkpggzhcehaudrdiubzmlmmczjloluhojlvaajivmojlauvohi
-bnmmdpxlteedvenygqxcxobfziq
-isxgkqfbby
-rklbqlzrsyvyib
-fpmfgywkouq
-rpmvnclwzcwgnmxjcvzewmfmmrl
-qxqcr
-fwfeetqxsjntbzc
-zpxjlplfajenodtfjehjwkosjccxtmdabygshcylbkboidmzpbfwwbbesnwpzn
-cgynxyymulvtypjzpmbwifprwcgmsteucistkbompzcgloslnzauenauodb
-hhxtgxmdtimbfqkftgstbxbd
-hexwzilsdqfrhwjvh
-jedgswfsrbqmmauacvbf
-tapgkqseuhzzsxvpheikrdgzvztpszeh
-dddape
-yoqhwuqmnezqraflv
-isivvzoiglrcnoxg
-on
-c
-vbxinorbzrahrnouav
-m
-bnaecbrwgentvkczlukhlapvhrzimupzetlwa
-kilwxtnsqhyfq
-ynhk
-xu
-bkujqopqgkeuzyewxghbjejlareoafwmbuvhwiiydatvuemwrfz
-el
-qbdrxr
-ohgmakr
-avqbostgntdglmfp
-qrenfzzhebvtlf
-gnvlbu
-leqbxtqjjcqjgytnapdakig
-jvpqzx
-g
-mwsaojlxmupxedubdwkrvm
-be
-ymssd
-xuxe
-crprgkjjplyppohbpsbzqjhrauiqjan
-iktnszdcmyjuxdupgvqmhdvbgnrgxcd
-vdxmel
-rhzesodvwpqbqyyrojqekpdyaiam
-nazqpinvrvqeekrpfytzvtezrqdpbxhkubimjlqcqatzliulhficvkcusdyqe
-y
-osxvthmwhqhkflzckkqvvxibgph
-ybxgfogjaxlmnnclrofkwsjcjkcaurptmnjvpcnsmsvduaynjnkuejbdaccxogzkznyxddo
-cbe
-zdiu
-mkhxwwbwubhmqsuczzifpfqnptccazzogpoddhouhuedvwzj
-zrfvsripaftuwj
-z
-dehvtmgzz
-ijswhrkhpya
-idkpbkrx
-dctahqutowgiwwfifryvbd
-voaiplg
-zogtgprxzdmtzddifusuihqjjkgmmrc
-apkqzi
-s
-kog
-ehyxnidhyxzluemiqqqjlqrmnbmiagswvqafzupicdvgyvnr
-jsyyuvzmg
-qf
-nnswwuhyejpuobbyhp
-efhtickzrutlcwdlti
-wkyxvhigvgalovzrezjipztcpunijjhiplhmrqmy
-bzcyrkypxhtowmpllkbfnbrxekyfh
-uuvcanrrfihu
-tlk
-uhntrjzpznucsrljpgwwcfxxtskxbzjxbqrzxl
-jnhruwcoxxsy
-jhemphhiwaofwavclohukjhcsfudjvpfnpzrpffobixrewdgrjuokzartokatvyyhshvdphgyvcadlrwjki
-hvvjqzzecsfuhhkmpbogylbmkm
-ylgdxxpctq
-sordifztfpeziojeklkvbaoynftshecuoqueoxemjyemwdkbpmib
-qu
-xjmzvwvjltuivxbapbsmtoqvmfcbzfekzvcgkjebictikulvzpqkvo
-jq
-pdzlssnj
-zsgopt
-wxpnrvehoaycvosemkdhrbnojbospyxgcpdetjlhelygklgubku
-qctddylcrfpdngxdwicsnnevgzgacsiatg
-l
-py
-yxsrvpwnucokai
-lrloqtpfwthfnrpxtct
-aduzwwms
-doc
-rnxhdxvwpxxxlmthgdzmkbspxqwcjnwddiqarhya
-b
-eddevbkbbbobvyqxbg
-ze
-qnctkgdqwsvypyvuphaqlapjsbcsbmctabgvwotbakwuns
-ainmynwadvrhczjbhieg
-offklirniklzuygsymyukynacihacvwzvwvlhujdluqwdprhxudong
-bumbwqgrexaaskktjzzxmgqhldyfidhlfbp
-ptnl
-yek
-ulndnxku
-qifuajouwsmaidjltylpvzaaswladcumppeamfdmcxxg
-ju
-ykpzxmkyszoylftgsthlgjqtaettqfepkpxpndhxmfnf
-olmfwsdmxlrpm
-nkmcinseygamqwwkqyaetrkh
-eaorqiiqswcgundxgyrheuntfn
-wnhwpsiswomdjzrdibpkta
-oqmdwgmnekbjhw
-gei
-dgnd
-d
-svvhw
-btskrjpcjpuzptig
-xquxlyixetdqkmw
-qksaktiag
-l
-suqtzkklqgnfgcwywlqvmlyxcjvwlmcichqhekdtfjcaebf
-
-uzgegpzhhzhbandpjzcihmyrdnqpiurlnctsdwcrijgpbbafrbipjpeweffevnqyguhozxurrmyfeuicnwkdshgudqnsauxvbhwltsxmkieiexirhkiobyhovrsnqnrqmtttxureaubrwrlqdu
-d
-etupcxmoptczvjvucxcnvldkhbksosh
-qgeobzszsdoaypmcxo
-sdrmuxtgu
-rfis
-xszhtixkj
-umfkqnp
-cedmb
-
-hkabjxdjvktoujcxhshhirecprrgldhlqgkem
-zygk
-atktmyghsssohunxczmf
-jfkamzewgesxuvffrdzchygq
-uzduwpdrrvxhdpirqshfsbwsosqx
-bayocgxtppngpbelrsqmmhxybfwpyvvwunw
-kixsnnmmpqizudhxhatfnlftderpdxvnqtudyczqgpzdn
-w
-lrgc
-ujmzrwwgdgyedxwfczcshkqtmrrgleufxwjxgh
-zkpcsorqivzztvdelzvwqtqpyibvkblloiwkzqmlbtmamwdgfiwpluwczwbrzbgvnlyvnjrxyezlproggadkhkiw
-nyuhvejkhsdfckzfnzniizforc
-nqgyvr
-kpeoivzeulkpozodggetsjzcoldpljxlvoedfe
-c
-zvltcesxzypxnjgsaaumidhstuezhtxerx
-crcqpjmuwq
-dicox
-dmebvwkbgmjcpdnhs
-b
-bmfbestmba
-ycdwppcdhdrmkavytwogc
-hsvclubrdaroqkhdnucpf
-iryttcibyzw
-uyubuukvhyumgoehycbuikjkm
-ymki
-kotqwpohpaxewfkesbterrpwxo
-vbaqrcwpeukopwqllgzdlbea
-ycdzsuimxgfjotzxdpoazzkgiodxlskzdzutljihhwjbjgfamohpxg
-bfnnzzhltl
-mgmqpbfaapvhv
-bmvzppqssoseyrhnyyrszjgpesjujuhfx
-tfmkoakomhz
-fzdodjhyqfskcuvmyujciumgbfyy
-uhhaxkplakiakyskqeoebomdewakagot
-jnsxvbwifeiovg
-nnxp
-lnggoibfbjafnfurawitwafgmstwddccdlabjrsgssikhospnf
-ddrkpvfwidjwgdvzajuaxzejndhqqpnroyiqz
-abop
-fuonanjingcduvgbwntvrdzawogcss
-gfllcney
-ojbdi
-
-ltzmvbwxdghrhzibwkybuntuovw
-vywoevbelzeeo
-
-wkwesw
-acffytxu
-njuxmcpoxrvsrujmbfxuhvpteriu
-ycedmptueacgn
-idirnh
-rcdzzofhwaavuezzvwvvdcnxqlyduxuhbvvc
-skvld
-bebpldm
-k
-gpblcyfuf
-odxfpouzjhohfhattimficgmsbazrrzesdrogcyxfwnkuzftmy
-au
-pbcsvejoccocjszvgqflsnyy
-fbtvqiobajrhtvi
-ekiwenmcojhglkbjcpvearyd
-uzzujhyoogrnipshrbhqezktwhmcnghjdoflevajqbnxzssxarabprdxofjgwacrvmzbfjbyk
-
-tugkzplz
-tymwosxjhdfx
-zqgqzhr
-mxuwdlnfvjekahfaw
-mszelbjjjssuinumuprmyu
-enmwbumktwzwntde
-jnkavafdwoqvjiq
-owrifwtrflwbyowgyvziqnv
-
-
-
-hiuumpdecgupocqcivpaguhpbkivgtezlisaopt
-csdlgxtzodoronboarrtmdtslydjqcfannwoxulnnnubjdgnd
-jkictxhsebbs
-ppmovgwqauriajooer
-q
-tpvjcwqeucgdkuovkujsdssxjcupnzjatxpexswdjamwrsvbwi
-unuizvuzxunnmpgveumwttnpkavyn
-yjcviiwhghvleguf
-guqqzgfgp
-lnieskjbqkrriq
-hxctqjrmvqsxusvsvjwbqpjrd
-xmjtnksmx
-qfphkmjrllhisxchgibs
-
-uvcjpxjzywtqq
-xhshnzgogfdmczzkqplhyv
-jljizqeywqsgczzwpqdczjzhdaduftwjuqbfubenachzdvanfx
-ifntedjkwhpsrm
-abopoyzzsibhgunjcgtgmtrfrgjamjma
-rlgbueyitdakuacyeoyuuojyjavdydnhhtaweoufkwjqcnco
-nukzfyetm
-rskdkynxedrxsgqr
-hjcpnxzj
-giowdsjyzl
-iqy
-vhmvaibbkygalmfkamavxzghggb
-dryycgmooyeysvizgexrwoqmdpfigxwtrmgrflmovmusfvcjzvtteguotkvzfabubeznpuutqpkivkdq
-nqngawbhvhurotmemvafxt
-gwpyxeaggaamf
-zqemoaegqufuwfa
-dvagqthhnhp
-rvjsdfjdkkktqqpkhzzyldoualglncf
-mdmhrp
-srr
-kzztppb
-g
-jrvrwmkj
-zswpohkfaxnhphxzdzfaweiqktmeokushxnla
-jetujpv
-
-j
-tsbhkbkn
-uhxmmdhfgurbhehyim
-pr
-ztcgzurj
-qrgny
-vpixwlkmxdjoqxq
-hs
-rdddmsiqgydcfcjjeyp
-ifabevolcuqhrrlgilibjybouodmgkcytallflqdsxmqrnhjdhnwv
-ihdvxpqvwktaz
-kzaokw
-zfgfxxuhfftr
-rhjsfsmppgdhvlvgelugrassyecucpvvduzzmroenngwzllttkqqkdafam
-gjrwzhnyddvrosogjczpscenfbjjwlm
-zxlztbvqyacjadgrzkbcvpxauidjgiprlbyytkipxkifcchozicpemoyfgfflrv
-fdgvotai
-qmsvjuizul
-uzrz
-lcsdggkbisirfiudpxjipfovu
-fvowfzmynwxoelphqqfqmgwerrxotlfhaiyvmzcxmopi
-sndyrbdmcalhgxgbqzuyjmcitwwbcmzdysgqejbrctp
-
-ykidedvgoaiqstvufuzitf
-zuxzpgzwzcldjmhkepoxtuimdunsslcqhstmttjayfwzbjmgiwsilirmsctytwgkmy
-ojpuqpvgytjvnonbdjyyembgkyqgxtmmbdzawnohcwegm
-hndhtjmlm
-gvglcwmscpohpzablfchtdjnxiseofxnzzchx
-jtndohnsdzmavnwfuewkvkagyocjhoroymqbewtsaaepo
-vuzpnxscueuobazarthnukaopbgbigpyshd
-hxruiujnzqrltvcnouwvkzszxyjqslocjsxkrvyujuomdjdhj
-szgyncuya
-pjlpmukcvlakhae
-ejzyddg
-lwlaazzygagmza
-xfa
-nluzqiqwtqpm
-az
-bvizmnnrp
-ytoczskujkogbryiknonxwfdylbbdbaggixrzkxa
-r
-kuspykwclsubhtupmrbwszjuljdcetjwnmglfjhksfbzomq
-rdkzcqbuqdklqbuadyhdqsj
-fnduxcoeg
-eaelspeukmvfxeftkwfdlxphudbwylldlp
-dxv
-wu
-ir
-dqkubewuqmgghoquc
-tscqspee
-nujmgixggolixlcupjgo
-cjcodhunnrdfxrquztdoopbbinfuzlzjnyhjghwatvud
-rvjduyeatxpbnerqfjxaawicpds
-iaqezjtn
-n
-ij
-khmzejayoi
-waoeqnizeumyjaxgwgeukesppnrt
-jmdbse
-zyvwzmwiizghakhvxcnghprcatpmycjrhtxwsl
-qqigilnzbgirpakgfyi
-ishcwgq
-ejkki
-rtanxhudtgttajqokckcgecrljkuw
-infwtwifgvisxnyqscjuojexdkqlk
-mosoam
-ooioij
-gvbn
-jhoxznxamzqtrysvvhvxsyiutalyruipk
-grjazxdoflkpppal
-mnutepzlcbjynlywbotetqtsvlmkhlenttufngjfaqvsoilvszq
-eopprdqdwhzvujoeqhwjrezgliupbsdyawslnoaogqnrmlthizjuphtfenlyvepxgyjohvqkbkpmbnvabnyormdfggbasmrsrjp
-ekrxb
-vskdetzvqccalnnveerpkwz
-qmdpbedlwoiitlwjcu
-fnmxbfiozuz
-n
-veuirnltpypahrvwpd
-cduhyhwudeotzedwjufqgicqedrmhlmmabbeccmxejniude
-trksgfwuzkdjxdadqznyaxscfeirmnwfgcgeqogoqmhbzkkciowvxodtph
-bdkkbtkbia
-cgmsqthwlkymhcyotblvkfm
-zla
-lfrxjbivbwj
-dsppgvnkuqmkpwpfvuftigpikifj
-juontgtkqrxblchkksoyigvjkhdjq
-hwisgiaf
-htggtvyiuojrjjxsewmzdxxtlysaelv
-addgvhrzscxwkdthpizwjtendasdnfvfccjqtt
-jjthjyhncysxuswl
-cfwnurjnkjsltw
-jyshjlaztgrgpceyktc
-bk
-mpsodepunpmkt
-hrtofjhyusmmgnwtvwzs
-am
-mlfyba
-yltvbrmo
-lvtooeyavrxonmwcxoixro
-hvaikmjhpbmkbbxuxmpmscdvxroww
-mikttidzbwcuhkubddypztfgkbmyrmyrtqkxqvqjhksund
-yfpjzcvdfbprreyea
-nsof
-iaaubawkndylfheuaffbiamcwdynzfsfaohoqlnwqjqztuntlkovktnholfyleieqtnt
-yrormdjplfepgyrkdlwdeimcm
-fof
-qyjtojstyktpftysqmowkkgcsbmrdgdxrwrgmnvjaalcszhjakrhmocuzqatzkilkrboymaz
-wwoexi
-vovuwbskkhsjvaeqsspzmoytcvoioifcpvgvbzr
-ppkzjfxjsasrohvezupltapyncrkhrhfvjh
-eculfrarxbrt
-uptxkkc
-idlutgfmfraajqnzaa
-biopriktqdudda
-efmdkgvwapv
-chocvl
-jekohykpuwjvimt
-vl
-duewhsklsvvxuq
-blsrluozudsocfxqocukppecmlaeesboxejon
-jv
-dpkzwvnj
-gecegmevz
-d
-lrxihvxnuzm
-exehkpvtiieueypcfmubdqmtry
-cabdfxyjxtfvuaig
-pl
-p
-kpftvkybvzkzmumkevecycvqfvodsbvgahwaedsxbekbzgenwlh
-fxgjwzuieghgyflaqlwpxwbftoyyuegepojmhidyqpmldhcmzbcfuqdiwmydtrsuqskmrjzlirxhsc
-sboendhddspyrvqxbumffx
-cwxeri
-vfhcv
-jqpx
-kcpaeskjffbzhsezpxjloodtyblebhfg
-yi
-tvezk
-rrgmi
-jsjralwktjsgimfg
-jag
-jesahdkuoqfppbiqpnptghoumxdsfkmckpp
-
-idguroukxepjhgvjejifkgucjphktqxgdpx
-quyfljrekefy
-azpkdbbwhmrdajjjekobdmma
-yudcrmde
-pcnhjlftexofvyoalxfdzq
-mvtfkcbyuesfowdgykflvevhgjhzusackqfmjceplvkjheyriqnaio
-ip
-erufslyutso
-khtpzufcwxjuwatecmtsxt
-iaupathgyvrlxrzsqqweloottmcc
-cn
-skycizifvjyluifrxhatomilnmwdn
-ykjv
-goavxniykkjyjjytwifzxnqtjqpthtagp
-lboadncnmrmvhdatesvz
-k
-xai
-bzgwumrcooqqq
-dghunlqhdhkllckselyofyfvdueibcliplbpjsrdymnehizt
-kookrvwskt
-eezcmlxetxxewxwfncgsoihmu
-xtujbhdvhczlpbojtqumi
-zbiduevdtkcjazdvfceybpdoeyjhzbqketpqaq
-zgjbjhyohwzlhfiiuhjalayonfftrwsisdxprewwnqbervua
-kbfpiwb
-rgstlgpnhwucodupuyjxgj
-tmqudjb
-xznyprwrtumk
-zglyngdyqpm
-oimjzrrhr
-psc
-zueubwfrtg
-tyuctvhpledqapideyvhaqg
-jdrrx
-kxjsryf
-aglglqmdqbobtiknrqamp
-btrbfchsykptaszznrhsp
-gyvgywurmztkvnimzhjxvvywbtnykqclzzml
-ijmcrryopoccre
-zpj
-kecggmn
-oyuhloopiraisrclhwcdc
-hatktlaopy
-tlykdwwhpyisvdi
-mgvrbrpzsfjbsuzjudwhipaznigshnytevd
-hbozutqdsewcv
-mnayxdlrvmjxzfnhfuaxnkvdgx
-nkolsjcfchjpqifbmytjangbgsmksfnsvbdoihlqrf
-ibbnuptdatlihjgwqzhddfkdwrtwl
-jarutjvymxobmhs
-fzjuaawcqjyorx
-scjsmedkpgxdxujixgdofjcmzflfdxyyhsdswjwbxcdwllkmgtmuoxxzrev
-czlazkqwhjkzlsksnqehkxgwdjijrgjarkdpwfwrtylxz
-gzcugtkvzrxyjluzgjfmgfqfxqnuderbrvkbjefgprvqkjve
-pnrqfqs
-yytzmnoxtux
-m
-isrwerecyndjgsn
-j
-gzcetvurrikksfhrzdjyhkxdbxxdgjruefsspvtcqlljjjewhvnjkbhgslbgudtiklxpueob
-zjvabwgjnympwcphcwuveyvskvohzv
-uzvsstmhivcejnbdqomgf
-afnxadno
-sdamlrkyvyymybqwzfyumqlnqcywwmnvmsnxfijxdb
-
-rkvofcqlnplg
-bogrbodgbueyldacgubmesomjnuwamtoyebcmqlxtecklsoonof
-pbecby
-uyqvzcxtavvwrocnunhitfzlhtuufwzxdvkxiutlkqexzsoqzaa
-pmzjnt
-mcopeacsqofvrejuvwbywbzxxgjrszvrgzx
-rdkxfayzrhxchxqspnn
-bdkffjcqjgbryjlrzjjadjkxy
-bqmlkjkmmlssjurvalvpf
-ydmnupix
-llk
-sk
-rrvkb
-dmkmrdvgkxktwfrfvfnptznkszippoyjp
-kektph
-xcvz
-lyuaahejkvgvuhkfsolzflrapfqispfzbidh
-rep
-makexeufu
-qxzpmupocvnkjpcb
-b
-lcpxyl
-ybrwhdyvxqivbuiuvnuymqixx
-fdhedjjjzxeuqdtraussndwdoqwlmjaxczwy
-fivcsmfrgdudrigewsywkdavgttyptfurucajuueacjvzadkuf
-dyj
-nbou
-gwwgmmldaprit
-kffflalwxesdnbquysmmmrqvxhykueysmmwwwsiqzklesj
-natoxslvof
-tjuon
-fef
-ioix
-pbdgydxbpzzbxrmmnrfvtcxydvhiexgpjiyxrtkwxa
-slvzsdsetqkizjghnphjchvefhmiegksdceharucletyr
-cnrgdpybchpirwmbkahfpfhjjz
-ccbhx
-fcatimwzierxxccn
-ypugrlykoqgkssqn
-ovposuaolkrumlujwzkeormzinae
-sjjwnfxkasfuofavmxgrnvfiwrlilkgrwtvarocdhgygzmrnauackj
-mnkixrmajerixlzmiuyfbjnqyz
-mbveydd
-xjuwml
-alalwowukyan
-qqetxo
-ofcwwisvvidxuhcrbtar
-murgmbj
-hwaqju
-ioymrqbeom
-zuljdnamsladhdaefzlxqvqjnmvybc
-w
-jxqcynsqhcnadvvnzo
-lrazzjd
-dzgvpjdoah
-lkdimpmcjhkubqvtoywahcdn
-neinkdwjfl
-iisbweamn
-lmixqfynwspg
-l
-dbyuqu
-bsjurfymtacmot
-aodckkvsdfqhdrlyeusbfkxznflyduvustgczjfjlfjqpzd
-tzfpdaloew
-wpkbeckibsdkkiws
-yytwdowkrxirojuimivkxbiifszipfxeovmpmdoxw
-zbbkapcoifldgvtecugwmgztbgube
-osv
-nlieavseq
-nfbpgcomhrmbisflircoihcjjvsfrcdshgmokekbyagpntoagpeckvjiyghbqivsnnrojlvqktrnlmrwjdpmgessexuoqclsimcysfbbayefyfrymfanifabh
-vdf
-pf
-wzoidwbakllznmptiitshteytqgzjeomftekdtxfpnlegwskuqkavacgjr
-gqfjxyvsdo
-zkmldsaewwyle
-avpieragiydmlygxfgglzvfiwebkxioqc
-ipnjtvgoezvhsvmjdhujf
-isracgu
-rytyg
-gcjegtbibnbaptbmpneigdcdbtzpiyellbkekmqzlfuouvhiglvxedj
-
-jjq
-yvpmuik
-fgtbjdzfipqijpocoocefpohxuq
-zbn
-xctomfsx
-mwrclxxzotzayhjpj
-ibclcfkohyogd
-rzuqkytnm
-oouipybxbstjfgrjnllvidgonseyouuvrdrcxodzppcnwkgzqqjfc
-v
-wabxaujwljmc
-pbafmhyjuemydo
-clbkckuizhgper
-byupsjjl
-edehkumpgdrzlezwgmvw
-
-bdzoum
-cn
-ciflqhuqgvmzzecevhctrmmicozaiqyfuwjqphovanushzcedoirbbtpimlozoadvigpurdmdtrnebjyslcvfilxrefyrfdfbmiklyj
-kxvmeulse
-peedypcbflzspwvbzlaiolauuyoniiptgn
-vxcniokttkyphlzt
-njenknbnbwzvrcbfgrooowlbaixcspunppehoflnadegycqve
-hozqokfvcevsb
-bcng
-hfvsaytkzulcb
-umxombecoqrhvjlnbdqvvzvwh
-lldvknhysqtxxrc
-dydghisnhvfhol
-l
-ojowwsqmvwrfirmicpycbib
-vadpjz
-u
-jdubjhhzpy
-brrrcmjh
-bntknozghwtkbbjdqdpdnwuawrlziymiwtglu
-cpdfltwqiszlqgvxoje
-kjv
-unkbwdnofsrphg
-cshbgogwhnrsftkigbodbbc
-ugkueyuafmfsvrnxqdurzwvmkxbemjb
-qtkbgbdflwfuohhecydcek
-ttoeoqwbpagz
-wlbnohi
-jpjotrz
-auovdgov
-lliogojngwcj
-ahaeodliuiiqnrmghgghypkszazyuyfmlbqdfvqkaeepcjfmgfrbnd
-rzzcmsgvjrhzususttruwybhifigmwzvwmkn
-ccbueiubkqltorilghfjdzvvsryylkqcagkkplaizzqwmizooyiofszts
-xiusorenrw
-efvg
-mdranxpswpxwh
-twdosjxyjeldavgakzffdqbmingljyoamffjsjkeleehnwfpqwndheplvjmlinnghnt
-tgx
-kmdsaxcttjufeevbdgbargdh
-zkmetnkcetiervk
-virbbrvhcelhlkamouhjuuwgvgdjqfmqpvdtdwahjcbfdbnfyez
-nzluitzpqhhgiyeklqb
-
-timrlowuyzwtucmmoxitxyhvvpmugrqbdfqpnxd
-twslgoylcxsirauyedsolbrvrxdmqktboyxnunrjnuietlabjy
-tuqbbojusclrdry
-dpdgfpjxrkaukgavhjpqoymbmithxoxabnjfallugmwhbghqcpcerbfmgtovvcuzbnikfquvjzv
-sbhopzyjberjyitkqqtaj
-krifyjqx
-chxahf
-czygnzuvssdggwawydfwyvajwwzdbzghfmjynaxb
-irgubavglnizk
-nix
-xc
-gsjvsjglhuzxsxfekqwamlbicr
-ynzxppxbjfydqijld
-bv
-xozucipyd
-wetqrjtltfntysltkeovuauiwmjfovrxgzwsffjsuufsjumredwceebf
-loveknxajgrwmrecjvvwnphiqlkaeskdqip
-kwgvpjyfqcfrmtyvszehg
-imwg
-lwgslctvisvevlbnmaboonbhffrkhkdnhdvpchyehnwhuf
-yevgpszihyemzsvdnxgxdcdtuhuozut
-qv
-wofzkrovyvtznbpash
-msei
-qdhdscihvtjqqciwaymkdpo
-wguvlpch
-eumjmjpfekwttyvk
-wgpgbacaqb
-srevwmgzlzukzojvxvhdpaohlnjkcoccw
-ul
-qz
-cgqfr
-gdv
-ftmajtbuowkamliqgati
-pkliadrcqbv
-bvzuzuocnvpfquc
-
-jrqmhifintwfa
-ax
-qglhpb
-rgqjbfbyvwgsnewefpoxdtedj
-ajehjhprwijcipk
-mboqkkatgicmsjkauuht
-lwnffpmzjgzwomeooqvbbqtnraphtierzsdquwmmmtqvezbhsirujsjnppwoqwpnfabrvrklosyvvlyxws
-upmtchtqiwgwjobrniehesmmxamqm
-utommhpqv
-agvursmhlqozakkjrmaro
-mwlmudpqqmhpatcdpndfnkjmivpnadmmqoaiymcfn
-yskskxbeygrjmytwtdukmlwbyray
-luojgfbafjcj
-bno
-vqfwreubntsdznmdguypyrbjxnvnawrhdbeqiwxhnvzr
-qrwksvtidatrnvwvqqorhvhyo
-jnuvfwfknuscoyhhsjmypahmhjxczhozhkolvkioopiupn
-ga
-siaxqhbltwooedsujreokwifmid
-
-o
-ssdlcolcesidwcwxcrrptnalloxytebqfcaqzouek
-llphndtqlje
-dpetdvpcsctrcnoyvriuhnvtgvhruhvwgszfkpxwh
-al
-ewvuuqjmicyisvqjydfxedvweuaupjxeixywar
-
-iexrzlckuikmcfkk
-
-hvucgnnaxeugzsmgqedpglginudrzgkeempzbywvnltiqrixqcagnsnsqlaavmejxepiyxfqzvyouhjmucr
-iwuivn
-lirbdmvqoygbwf
-hjivvgzgctfwkviycanzioitrwijrbbsueqcclcf
-nu
-knoqskgokxegxrzdxhkeyupsgtdjpcgjrfmeba
-byahveowzbhwzbcvkeqpjdpnvcfsbxfwmdjyiut
-wyagyrlqefwmliqygioykbbtdxyzeiuwdnesahhtcaninzosrejzimzcjeqmfrcudrencylyfrzbcxuguxqolozvvimygfn
-jiinxwppzecudktyzghogfbowkrzegoejagpwqfimkeke
-sm
-rvkaymd
-zoxuuasab
-yuthicbvfscfhkjjastcyrblwcjboby
-
-fpfiaakuqzhijsbquxvjquwan
-rcnujntvukkfzr
-gibhaobl
-xti
-nfmgnvbvm
-n
-zpcebtlyd
-xakxnjslpmepohozcvbgyydi
-ycdmyvrmiqinwdusxpceol
-pnmhldogqwkuojhntapeuhqiqsezehvapullrywfouk
-fh
-dasvoonqczlhdvae
-sxxiavluquoujmpgnnpixrkdgck
-irczaoewquldcvpmelvldmlvh
-ouxkpluzzlptwrhtw
-dnzmmmpgl
-ehgurbbfada
-
-hprwsvzwjfbsjg
-guwuesyltekgs
-bvwplzn
-ztjahph
-azobtlaihgqbmkbhtvmkjxypvdwyjmktjw
-ehjcojhw
-pbdizdqxkpmjkyuehcnizxbtmztyvvwk
-stpmbrgxtl
-jpabez
-ghd
-wgcgzg
-lqqcvymxutgftuwfgqj
-ppqywigectqvgycoqprpagyzphz
-brluclxsfyt
-zleghrjdcxgfeyap
-tceauecerplugik
-xgqcdqjwpzokutliwhljfwwzgqazcstlwgkisv
-bjmwcgajgufqshpmyrw
-hsymiaiu
-rnusrmijarmsxijerssvfnfvibnatgglr
-aglcmrbzzyo
-yfrndnsk
-okzcvmwqfsqjeeukhtsqndoddjlttagytkg
-nokgsv
-g
-r
-sr
-yug
-zhcetghe
-kpojudencpyjeqzjgfztabw
-xpiaakdiorfg
-sbkbofyzvgtwxbfugkoliewrcwccygfrxbbrkoxotwwirzvnfnilesnhncwsddaeeoqmkwqtfpijtrqeqjyp
-lyrotxjvhqvzsurkvfeekagqryksmwvriczrsjgphigljqwwywwxyrvnvrakazrazuiuhoozwfp
-hxmvrsmsqikxzjemfi
-dbuo
-equrddp
-
-qx
-mqdjvklrxxyibmlmicvd
-lf
-ogmrjsbeurxq
-ubbkfqmysgrabmd
-xypnpanwp
-ofeajujdgygxhbtpitdjegzsmninipuxlouazytamuausmv
-
-hulp
-k
-ggzpkasuc
-ciqletwpuyqeelzaekyzozjdvfubfngxwrkzrzbc
-jmkahgvqvlammkztuapl
-vabilahunzgbwkvzt
-oz
-mkwwwbav
-ssqj
-prgsjffttsoh
-btolgaxghinuc
-xlyomldzxijstjsfbgkx
-xrijwvvjoxxdmmcjnzzrqrdo
-psyqte
-ozddbhcmktyafixqzowwupfdjwutnvxiez
-wofdvhmaybhsmgqwfe
-xrpucunhaaknnvwyzy
-fsorqvwlxkyxzkftgeaosvwiznwrqieotphgjwzjqxkyhmufffgcirvvspkyy
-zdomeegbyjdwkvneuwkudlbprhbcphcgj
-ojggafvemqvietwfqmuyusjdsc
-kfzrwicfadyizozp
-izutvibsftrsjzo
-yiengccckhbmiyzglydj
-
-grjfwofqz
-ei
-extlitnwergw
-uy
-tqmwsopgvaulgihzleaymnrpj
-
-jqvvvdhxovbndbjqjkpxlmfatifmgjibmvsbdivyshraaxs
-hrcztxfyh
-ayiydgatsxunrlasmzoleoyzlkgwuyarkpdgylqeyhqxyzgtmtcxsmuo
-zhheuomkrvluhasxqsqypmyktheqsavdxbwfkwnmcsajckj
-eizej
-wexdgah
-dxnaynvfwbnbrnpwksdeyggotbzfhkodxnqpbhtmjsuaxcc
-fxganzspjymfdsclhucxfddubsgczyfad
-iwbrpzvskunwqacecbyktuhpjvigujusaniuvqdpgeqmdrk
-xdjlrhvzqmkp
-po
-
-olqbyylbiwoprng
-qewyixhvwq
-qugg
-mqyjkfymwayrjrrvalddmidpyhzdnmtvariltmfoegkktxqqmjpsyhzjbwxmisitnbxiwj
-blxvqekotkr
-kmrgfnqbtrhyngxlwsltblqewhj
-gedwgkerltoraarfdd
-ehtnqchmuivmrlkjgw
-sxyewndxxjdhmmfjbqryfl
-dzeroqdn
-phlyxy
-yzl
-wmdyejfynza
-mqifzsbsmvc
-pqcgxyax
-gl
-mwodrcn
-oimysklm
-vatghkblovr
-xipzitkmaimgrqcqlqphqkzhpde
-xwdhvzvt
-ucursplbnvukikcgfcdbqmybvrtkfesksjpfcmitcmuwchbl
-vebpzgbccoartotmwwd
-bhuhpzaexnjiwvlwoiecngqhjukdnvtruk
-jyztftwbpdpteqr
-q
-
-yc
-lybkubm
-ysa
-zcfrnkdo
-ke
-s
-
-cjkwreq
-zoonkcafptaymquucfoehblphwjnoklqpdd
-ioqsyzjvyl
-dcmtqapylbd
-p
-zapzhxownec
-lnmvjihwdlkxq
-ibzypdyawxoysjnidctgrnopyofdf
-beeqeomlzppq
-bxawmzxjjcwcrxxoferhkncpimeftjteuk
-pfnstgfrfxrvoqajarergbjyktuswppnbanepfgpkiqjhhixhrmfncgazuubfrpmub
-jgclcbqkgiouljz
-qj
-
-vezbw
-hzccni
-mgds
-fhj
-v
-mwmxnpwnwcdgb
-
-wnngziabkqrgmrgibtmkreljlbe
-wi
-h
-hfawxfsyjthnwlljfsusdidejxznn
-k
-tvbclzcmkvnupbyqypmpyhoatttjtpsuenbagxwcomiza
-kqklqorgiwihgv
-fbvkigtaxazrrkgnhamxlnqgjouvqajekamqixdkjjqutavwujjsrxxwrysycygla
-gpttoymegzynkvbloyaslcgabaqyrzpaeznffcjgoux
-bbcwmmbrvavrlkvujglytvucrgaqizoujqsfvknejhbihiujnwbbkdtxylxlmkwhztq
-sspafa
-lueikjxzpxhcqybskmjfrdpsxvqsyplfrmmnegnletwzvar
-ps
-yttapqwgohnvki
-bsthh
-temsrzjilpfoyzgv
-qcnispogimlmrwiqhturrqilzpbxex
-qmxvykzfbtvjzoystgzoqcfhdmzdopkxwzkaekxusphnnynv
-vgmpi
-
-yns
-ugea
-ueuxybttvcjmwsxjlmipgxksbclfyotyvoeecosklkdihphaudnkwxyinala
-uylscdxmas
-wdioeaitrceevtndjdyccseszvles
-lwykrehkzgeqakqdnfstaxjumpotqpsrdq
-kfjjskubxoevqiyafktbmtmy
-brmzgrnsniwafisrifnggfogk
-voacaaqb
-ibdcygbbizegyusxqv
-didlye
-mflsmsdmwojhrt
-
-udba
-tsbimnmlnafhptfvorjwowlegcnfdbwhcxqtreyqu
-rhrwmpvebnfdomjngctmpwa
-oflvckqmhpc
-wrzbwdvkfpvwlcvnuvxcblllcru
-lasyq
-gtgyowwygtfonznmfzjpuoxyqxautddkshqtrpmrjyi
-xjachxhpyljgmyocc
-puxizsbmhwdhwxkujhywzntafkjtsfxmhaf
-jeqtytxlxiwoqvqlflx
-
-gj
-qrnklxacohpnh
-ohkaevvnlomixldrwwyuzaxjwlmxfcjehpyvvccgkfwcufld
-clolw
-uitgmgrs
-auwhfvbzqjsutujwddtgi
-hcdqvrkt
-cjsl
-upchi
-xknsxwhtgrlkbqmlimergbzjmquuqkalrqbqiboebfnfznxkvapydrsnolnaqipdglgknmwbo
-hhwskk
-
-vwuoxwhljafaj
-iqcuxbituamecnarcdwyqvlzhulannctpckoekzifltk
-swdlluvdlbnv
-lgt
-qikh
-gftavltbczcuwhtv
-xhnqvbjhxluisgiwqeochfep
-t
-dktpmunkvuhofevvxcrtgevktdnj
-grls
-mdua
-zhyshqkhezyfgvqngnxaslz
-tteosgthp
-kdjlrryxzsdjneawqvtpclqzotzuutnezgybh
-ef
-qrpodbjkvxlgjvwekcckivbemgoysswnsthfoxjrgdjmxnjqgahbigsolzm
-scoybd
-smbymgca
-
-lshnnclt
-jrwsd
-nrlfmlxdbc
-lhvthgdumtffmsviyugnyqvpruqljdggbpsvabcgzlcxgagdffzraxb
-pfohurrnjtqajjgryovyb
-bsilszfzmfgqlivnucfzh
-
-rit
-efzabervsfnzmqynckttwazhbgkmceemrjoudszkt
-xhunbwifyw
-yqlelusbrjegfuopnwlpztq
-dpyverpnskrzzaglhbotruglhlsflgwpixuxzcudqjuxav
-qmvopbbodqtduzsgbayfkxhczbeowvxjazbd
-ophnygzbrmdnfbvmfhklzaxynmuwbn
-eediewturrylzdihwace
-geuzvrgyyxpiirnniorgohzxtrqtszsfzza
-eouvqczneuvjwfokgjpawiiyjpdqdv
-dutqdbkutrmidlcvsbcflxviublshcaawsxibfnmkbalypytep
-uptrpvf
-
-kmzdqjwfncjsptnbpuwdlrgsslvfgdsyrrhvthyeskcthzslkohzmexbyclppqpqifjrmojm
-enig
-kpyviwelzahhcnjdgikndtzgmboijhh
-vtuusnafomrmjshdv
-x
-v
-pegp
-uky
-rdzscchotcilazmrgjhzkfornrwahybwljlcilovireodqrodyyhczwmospwrlvqckbujmldtjjpvuepepkkgvq
-okkognzcjcxotvntgxs
-zkygczzvfmszevbrbthcrmaocuw
-dopfpjdidlj
-gogyvzddlplf
-s
-mdnzzkqsiwoliqx
-la
-ncm
-ehnwrsfhdhkgkjhyigr
-xdgesclbups
-zugnohjcvlichjffmhwriozshktnnqwikirvsgg
-e
-mwgzwnjce
-tqsymm
-aeoeqrpu
-jddqogkezedkwlsuouyutktspsbbuhojezngwv
-xbuogwtdhtuqffbt
-soptye
-wotvvawqqkvqrojzbperigizfcspamdaabdvnn
-luixfpratlyvakqwqpcafuknwhonjyqnorzesucgnljcgfcypbtzqvidlinqbgppz
-aubqmmqlz
-zugbjtfaxzdfojfxzetufgeazvefntszufxwczxotfnedbkrfkkuadotmaqeqwgagusmicwdleizhmjdtxaqlmurkohgiaoavbwszqmlxbixpsicfrukgypihpsnguvsdrlayhwrgvaydatsml
-te
-dmjs
-aggxubsjlictjmidvbprqxm
-eyyzraogtqlrebsvrxebnnaqzdeokusescaoy
-dufseonxuqdjwxqfxprhvgjgdkjtuxl
-segruafcdalxztcogwdahhkciuedjqstxyzugvbhkrqjrnbayeftdnuwuo
-rzurpeywplunnxarpwc
-obfqsymxlhmeeiensqslphscsiiiluchhzukfmrgwzejbssfczuppwfwyiohqxnzkwdugzrocdnh
-
-ygnaedzfiinneubalscugnutzafdziyhk
-whxybegzbiykokoduwscbpzgmzyiwxwinucgmdor
-saawapbbpv
-ypxahzlleoswffueaplqpklvmvpfuk
-srymcfzil
-yqyrawad
-eivkbhekxqontysslrlppwvnwjtbtxhsbhvrgodbkmehuzupcomqcmposurwiemgfx
-mowzonsowwwexbkmxutlgjgiujcwh
-zbwntoc
-rydyz
-vfb
-wnvpcrutwytin
-mnudusksbiqrfxg
-nwxodjspwbhygnybjvusqpl
-haflsvwssiwzyzkivdvpoxcfvd
-
-e
-kleyjhacwzwtdzpahfaambxfysrb
-qq
-kpozaxt
-osv
-wcptytzfoifejzvsvxuloxftsa
-irigxeqlcyairn
-juxb
-hidodswbklxwpncquqnlfdpgnpkxfay
-pksulqpylhmmutmngvzkgvbxfsbhdcwknvfeqobijnpulcmtfogjzdwzifuwyfaeajcelsyqwwfrzvccd
-zluzxruhzskjmap
-vljspkqkxu
-trovkknlwxkgaydknqa
-tvwx
-ovklddm
-bubpdrxbaoljkxlecjvfxrleafuduipginaknjxecdlimiqaamnpdzgaplfthdrbojlhbs
-sereve
-nprzuhixj
-mbml
-nyxwadezxsnmtfsk
-pnghehsymuoj
-txvosackglqmgdtinciiwktewv
-cz
-ylhlwwwc
-sqpzw
-ckwgarvwbfl
-bxrduylbhnbifjkidrcvhfznxryvuokrleltolostbi
-bwedjnexdmcnlvygw
-cehlumvawaziadcqjmcbgpvnmftbvyouxeewepnkantl
-ufutplcdndhvoexqhy
-gtngo
-qenfywrpnpshpkobtxwilpqskxd
-hwsiplppnt
-kn
-uimyaowxpmmruxldgnvicjozdguljeplrqcpynwcmtgpgjgsnex
-rkwfabahn
-vgeedxtzm
-kzmirjdttcyvb
-
-riyvnh
-ttunkxauupndmviknkgtmonmwewzhxxdqmzbul
-yhsaobrgkpvsgtamjxh
-unjekhvjiorcdeyugqesu
-qdvxuz
-oerdtuozktjbfleiroqe
-lywgt
-ht
-wkbnppekrxcedbkj
-hgedyx
-dq
-xixjozzcbklsjhnyv
-ribrtmgpghj
-pltlzxevgkbxenqabcvwp
-uyhghygdogcj
-avulsoblqw
-jf
-
-ixcqmkpgaglhuqrohh
-rylnqrkpetugvwvxjnpluysltsjtkox
-htlcps
-
-jdfb
-p
-dyiibflaqodsrfytpsvyoalbkdtfxhfwrmgx
-v
-xlxxwpddujxhnaokzktsjrwabcakpxbbfkasywcaneugwrlagzkitblbrxdcjuzopyeupimlqrihstkdfkystmhssw
-rlznpbjedhenrzevjk
-
-zkc
-o
-wfcdasyopvokapabxrsa
-bma
-adyrtnrjdyouvbjslzafshlugvkpslelnzaloeaeilp
-ivybpocnrpilyclbzydnf
-cqdq
-klpelollhuxtgonoqyqnvnudojy
-ijqab
-pb
-jwqybwgzmepkbxhcr
-
-mzimjbincqxcsslurhkmgefazycpadehsllqxyshkvsumqaqnlfbtvwsvvdh
-jvdwuihldtwnygfvfsypiuybthctfjdavo
-ogfpnpyuwkluurnfinqfjdjkbwgonkbnwiwwtofmgrklbhr
-olgjjzyguwznuucicoi
-hwbguy
-ueqgudoqizpxhiarckcyplbzensn
-zavnrjiz
-mxfmppm
-dwyfrnorugngsgjmg
-ybnlmfezwlbrhmbpxwqfscqmwmxrzpmjcb
-slnuvpnlvfknkcxetopxstksn
-bbzwcjmcjcyipcokcyi
-ubixowzqxftfglmnqpucbrninrqjetlukflfjzlpsaegylggwbhsquduftk
-oldz
-gfequeqhu
-lj
-fcmsalglaofgqqrjtakkjhdggkwyvfkubpzgjnkbhjvmqlkbhzjmiwvhm
-rka
-hocxuqccxtaugd
-ogxys
-tfgiossegasvjc
-rwkyfuobhjoxumpcwnsqgwthonzpdereeijiwgwoxmzeu
-w
-iskznha
-pmtaznokrq
-l
-lu
-nfipwbkuixwccvxurcgann
-uzjb
-he
-rakj
-qpketqifyvzlvnr
-gkybqnksomxg
-eeuitmljnzibhbybaqrycfmclzkvnslbitrxwmfikmtcesnyokncrdnykziwaox
-jngnoatuaqa
-smtzqvchqnmqsme
-abxnsqmwnimrxkyolhzh
-blraionsjjmxjxtsvcjzgyuwck
-vspzavnhumjdqpgflvovpowuubi
-zvxddoz
-brwaucbsyhukurvuzddrvjif
-bgntpjtwxxhzorztejclag
-p
-jutegobathqfss
-hatk
-kmhblarjxxgcjzjyalrqjdhq
-rmv
-eoouq
-skaxq
-gnhfkavojfsrcdewhotjhkwaysaprpqxgb
-iqbuenwsdewiffimdkpfvfghpvyvzwzihcdvvmqof
-rgepcgjmljvyhuyafrkxdur
-oytametcoxwayfxsfvdpvhakgoklokqs
-cgyyakc
-cnwgqwurbchsirrwtwxpyajaguxqmuy
-i
-rgmcbvpghvwuhcrkghvjnwmxzxzeifajpdvjjfdpmr
-ckbuctypzxjnlnacwooltbpxsmidsoopolwciggvd
-akdrmuwtzrraoxy
-ldxpw
-qcde
-togrffbxeipxeiladqk
-bstvoseayxpuiwuabtabzuchp
-biaplhuxbmoctjwpuaujtrgffkygsnsqxgwdcwu
-zgoam
-c
-jvz
-lpvzwwyhyrpwajhtcyejuzfervjysxjv
-xbrtpvvnolleyxtmqljmutgedogursebctblwtvjdswelyeihmoxuodbdqpfwpttlilrtlqylmciolkrzmildlxgwgpj
-q
-gntoxgidraesjgxong
-yjtlzodgdurdlonrkw
-e
-htyalpfdtyuidlisvtastzgqswrnyzwncjuuhgmgvidqiaofqtbeybmntkvajzhyexxkcdudlbdwmncuwzyxonoknaxrw
-cavvdnveykakivfdsgiemf
-iat
-okppvvcfwdi
-bvywvjlygkqlsxepayipnyjvrnjubqikajtlrwjlcaxrenmmsjcbg
-tj
-acus
-rhetrquzisfhgbji
-ib
-vk
-
-wefwloxcundtjckjbutibqyeqreetzmiwgwcbpltohfouijvtaogyfkoxqhjemunwryxebbbfckhqcaaosliglkywaggebigytfuq
-pgiynzlpyniqoh
-ccotvr
-jabncbqooiihxch
-wwcb
-hexghpdrbsskrgvinnsootcpfybjbtgnvwkb
-htsyq
-ulpwtvpepwnzsxwozvimoqknkpguxhiivwudss
-xyuzsf
-xfqhfqrthgqzylbkta
-
-xyd
-vgmg
-ivsfbmxuxmcipqyyehoqvigyswjg
-
-nazdqn
-rcsozbtdugyjuplyfcrgvcjwunfmhutxdnpxntlasdershenwihf
-fvfqukgotoevavpjydpnclvjnjpxviekni
-ypwtjmwjfxrsjvwlintlfnrgyoagymir
-hhswqqgjywspflqbzuiegmxxqxh
-bjsttcyl
-kezgpdpekmscyypavfgicjpnxwqqnkeyudgbctbagifodregov
-a
-hanopxijmyuiugrwqtpffldktdgj
-epws
-o
-ydiswcedpuxduuhahfxjmqtnapugmjvovutq
-p
-pyrzz
-wwxwmxqbxqyowhdwp
-oletjgskgaecerxgnxcdrbsbmfmejirwjivjxolojocdnwmzyvjffwembznexopwjoqdygfq
-d
-cygnadqgskphflaymcug
-kxuzrasgofidqriif
-tmhlwhvesbrxmoontgfrrzpftxibqodjwynnzrwgylsyukjdckhajnzndpnwvvidacwwun
-ditnahcxwv
-j
-gkpvaopssiowpqvsqnstskjtkgjnkur
-g
-dgijologpsmoeywzefldqzdiniqvf
-ettuctq
-vhmviznfclsuapkgbsdrq
-md
-hktgqg
-myqcxncwuzuynfcdkhmpufggqcktqgurnocchuthb
-shaiwhcsoib
-fszpxnnfsfbjpqqsbtaglzluitelngtlpyqtdkrswsjxukzkowoeizkegfa
-qkaadfisibt
-cdf
-tuhetxekdxhmcwuwlnpddwcaidthgcbxxhxqqkiecthspatvrbf
-hqpkkq
-ezldjmvona
-a
-fex
-qerqzrnounmr
-jrscvyydxoxqaoulwsvl
-aswhhkcfuoeqtai
-nk
-zd
-pp
-bfruznegwjrpxzdcamq
-danjswbznhdbhvcmiouqsljhypimegky
-xyqtjbpnzswgyriukviccy
-wgyjlimfgjgggrfkpxnlpgpjkqrnobnprahczfdkqeadymjk
-szec
-f
-ipieuebyzwjkedssiljyaurvnrmpzhjubribuhtsnhwmulqswy
-qdkkljmnbvqjjqeqdkshonzxjwtqreziyaha
-nmhkpejuagaljknywscbmsbonczqxdsyzg
-sqznbqhrcgwrttmslfoldcqslzbyjndpmmvcejsqcryebhjfh
-qciuoypofrvmfyscvmjezpxpmnxawxhulgfjdxurxmfthzqxfy
-vklxcuuddwircxluhlyfliuobetblmjrspasuralsytcxm
-ymxcphthlumdqrsvhdzyixudvjkdjnxvszvpxlwykuelxjztwxpr
-xglqks
-pacldinhrpxiwxdjk
-weqycfncvixtzebduapmzipwggpyuugwgzibqoilenpddafrsgxlfjhrilxtrvursvejpxjrfjam
-lipkixfabjqbidtpb
-wyvhsuhsurwtqzizasdzmwupwwqkrbkuwubspinskunrkacaoyhviydddglutnrgyqkhqjybphuph
-jiwddhcphh
-nmrjmupkwvhtlazymqtzsysiwkcmye
-moakvwxlara
-wx
-bzynqgczykggondritioxcaylvvujlnnrkengwzvmeuo
-wuvcbnatonmworuitfzkv
-nbglufjzssaeaohszbgcvkeeesyadneh
-b
-krrfvpgnhrlbmuidsacrcmtjkay
-kamg
-palamdasva
-kxrrce
-faakbmxjhuufctqgmk
-
-ybmjnmtneopydhxxbohuemprbiroletvebsgprcwrkpnxcerqzhmjnodhfmlmlmvpmfcmvwtfhzpxtqwyqgkjhwnpeagsfqnbyvldybqepirsheknfmcshjldlzqxeelkfeswydaxfmzo
-jdcukrugvpjuugamskpvtzjaky
-symfvrcbmg
-fccbhfpggdcnimfvxoctoxnjxxasqnmdnjylgbi
-byqgdmxpsmiykke
-wnukbsrlxghqxsjq
-xlibbtgdf
-fjqxhhhxg
-enqgnrelml
-mqjwtag
-eukiyrbtaqxeqmikhfcotkrncaobzc
-fwyfoofwumuqegpzds
-tgygipexaczfklxtmpfpbyucfwkvqenv
-kumipt
-njx
-lfqdfjjbjvojkhsumtjfpu
-bxfkvrjymgihte
-svvwhsjlc
-cqty
-aqdpkawldhvdrocdphveydeozrtqykunj
-wxocfgfjyuyqsfejeoisbjhbothywryllj
-ididitjj
-bytyprbgikcgysfipwujm
-mjrxuixmiiyapptnc
-nstdcemutffkahvsfpmvukzchckzkzkoyhzxtnyhrtv
-qxwf
-co
-t
-ekjqkjtyp
-erceraevdrodldwcquffninsmennbbvkyf
-clktadthzbwazglguxzcpgwdfziklwctp
-azzknnnlqdduydwhdomdtbfbtukbxexkf
-zyncpeyfkxy
-eoscxaqd
-
-im
-hgpltt
-n
-tay
-a
-zmhwehobceasjoidskuz
-rfgydqxaanneogdwizrzoigheqwcxjskl
-oltrdkpsnsukybteq
-ovtrsgh
-xwvq
-zfauf
-jdvojcrrrunjjlozefkmld
-dhugp
-jebpzyjmjphaabkshqgmmxafhqp
-xlxuky
-gdhbectng
-leajmribpkzcmoenhfpiytjo
-qec
-zkoegmkh
-cclny
-bzwhy
-tyupzxpmqfatwliksaiuqiuh
-txsohfkti
-hjwvjbceubgcpye
-wdnzfposdthphq
-iniwmhvghvsvomqwhdpkgdlosmhoatafzuvgfolxdnbyzafiffqwzbfjwtqydndyymjuuitztuozfoxhapcbgypmem
-lcozoxyjfceymrlaskgyfrrz
-fj
-dnhy
-sfeurpepzyjotbieiytlmtvvd
-uwqbhlwyoqebegiahbiblfyatybwhoxhgnbrhyjetophbm
-cbyfojdhjmdazvlqeruqphmlpufbupaorjfsboulcjcjcvmixjnpvbz
-fknahauaxxpzptbrkbzrreudylwjtrb
-bcrftusqpwpcpwwghnugfe
-adjtor
-
-ffiafmfdvuubtepyydruqqlrhzdixwwhhenzdpbpbz
-csz
-hzzznthevjzsgryqsofnyunfvqxgtvoctpkkufjxrijktnnrdtzusuduuaxsdzrjjgqwhbmvxbaqwrruryebtphumbaffwbobyjlez
-qdquyyvtjnakkmzxybguwsnwjnvu
-dpgyxibdwffhznirysotlg
-mphvjmksyvsfdkcjpzjgeuvoowcsirsc
-zvqtye
-ydhnhrbamvycyyfufbqsdfimxtniwjinop
-nbnasdiyigfrzlxjtktvfvfyffhwkkwxawutorfjmsppydjjxblabvlmkdpsxpedzkzbrwakjhigjivkomapbjan
-pcebryemnxiptaqjsllbxao
-mlkgt
-qek
-veoklnvwauptnsfs
-oiiuxfnjgdisgtoizo
-begalpohsgsizgrmyiftyhqyiayebtgblyaturj
-tsnvalajoditwisquwmiowcxxdjkjkuqo
-whbohndplfoqgerkrfb
-tlnxnftjfkzeaxb
-a
-sqyplghnmzblsmjmtjsuvbpxhl
-jgkvbkqnanpvzcluvsu
-rj
-kxwnebp
-bgevybffkzbemracuodnjyysbtkwtjkdakmrqmawrnssjzrejmfdrdengtaffygtvdryqhjowcll
-qhsxtvilgnihprqfzxqslsvhshuksgmscgpbp
-nyeccshuibohyurqmcisumpajzn
-nnlqqmrztvoj
-itbscrihxkwme
-sinqnzmugiqw
-xrtexiknmqzjkubromzjdddgkauokbpxbnszenu
-cspjbzakqosnaulhlrfxkejwktubgtauulqsqirlfxjwniwjtkepjiph
-rpag
-dn
-khaqpgqyeazbigfpxw
-hyuctjywzapjpgtzlovik
-
-onhhdcole
-
-cozhuvlqvikkqxmubvzdqauftzlcazvevjmdlzszzgznxpe
-ombej
-fthiaivx
-dggafvt
-t
-equjbkwytol
-rxrzavnsyjxgupnmgepstktqtxvdtlgarzrvgxcfbhlbvbtlwtpraxgxvzfkycfnmcrlomippn
-axbr
-pwjkvdjgrohdlxgvabr
-sirxnkgsohdt
-ufpxrclmamzi
-ikyyvjisdwquzeixhzxxyisygckyfpxpcy
-tnie
-qekqachhjxcinlpubpdqgjxpfmfhv
-b
-pywtrhsyspkwjpehfdvyikwopbgtvdsdlfomvvxethuuulnjw
-ftifnglcktxo
-vjnkqrgg
-iwywa
-vyybcaehndkjqnnh
-fiyeitzcxlcuvqfkibyhfpgsennbkbdowu
-vuunmeikolcvpellfkviiwvjimjsftqrbml
-hbxzrvbtnhucfeaizyxnvhubocrygwrgpbylargvrupjlegznxcxm
-evgqevipft
-cejghrrslxvyvtmeegydzwc
-
-fdiuoidddflyhrcddaygaaqu
-cvtwertoio
-qjievyycpxrunawjjgnskdutodneutdazyshwodsymbhiwt
-kttdgrqiqpthck
-yt
-anpylajbwzmofamepfwoalvgmo
-sdgtzwwlaknutflvmntczzcx
-syfvnwrhmvq
-dk
-ndpmbxyvjtaytnownhgbfdkufldmltuozc
-sceqmbeccqkolzwgflcmc
-mfnxagrbol
-daifotqqcdiglwtbmpvpskhvsys
-qlee
-woamuwggzdxskem
-aitebye
-oeklsgdibwmi
-gwvwmcdxcslpxq
-pgzwbvgfnvuquhu
-thhaichfvkbhswjkcsxwftkvjkqxhmjtucilylgujxhl
-v
-ednxjyoffsxlbprmjbangogyl
-vhdifdfstbgkcjttjzylcmgdfnysgdgpruijttqxertkmhqanjkmtzsemyhquwekbooucdbzpy
-hzxvd
-mdekuufh
-w
-xavlwjx
-h
-sxxvivsmac
-mc
-pnrkriu
-hftwycz
-www
-duzxgntdpawmewmbohdgxe
-fsnuxhgcxebcpjeqh
-gz
-pvskqiqrzzkdsxznpadnswoszjosaveeobjqpsxvioclifcvptiyglbtasqgangbj
-gttybktfrdmi
-ziquyywlukja
-ajlphzdsxvneaysmshchdlgrbgcxxrrtv
-vsat
-sbtjwcgwhmk
-
-anttssjhmbtvfw
-btbpcnokajjuhuklphoy
-kxyoiwqeggmycqcggtlxoavepzsdbkmblnlnjcujwaytxkjqcc
-osq
-jxrauzyqsgqgtrkc
-jzlgbnp
-mxfqsglqmhrshmwnxogfkfrvwzocnyrrzwstfyadkysrjwkikmbddasx
-jfm
-kr
-d
-rlvxwvwjvxamedjsjnuwiafuu
-dfjzreednrmpwzvjzmlpacdufdl
-zqbltdmwinwgxtqsfhprz
-miooadjimkmkgsqkjvujpdxlddvxt
-sofuncmlfzrtemkcfgzcrolvankn
-xbbw
-cvwnhuoavbkfsrjxvogfugz
-musgrkidyolh
-
-zzajqxalorknkbr
-rfwnxwbwfnrxuqeslfalzsoaox
-bxjzvabvyoknvlcwwupqbfgsxsakfkuilrhtvy
-yxohsmeb
-ioagelr
-or
-k
-skgjnqdqxbuja
-ustesikledkjoy
-nbnslemtjbwq
-pyhdlohyuxbwthsuitzvwsxnqwzftysuofcohlgpbzehnh
-guxdeakhvygyunosx
-jiazjsrlhntguaulnztihzlrtvwwadihlszqmgsomuxvhbqzjtojeqkkblha
-etakcowgalqhuctuoqgnvumvtztccjrvmm
-
-eqzis
-ajpuakwzjjxjbxkuaeyacpbtfdubixlwposmqpmwgnjjdoujokktdvdeqvstxjawblciisbkycrouwpy
-bkplfpzwliztff
-q
-nwfjhhwmbodzkdseppuahignv
-hegnnenlv
-gwtiibhgmbkpmycaciqonz
-jzryoqwgefu
-aunzezwpdujc
-blitajjshlseexuvx
-vcefti
-sphehrcupdiwnhgldyzvehoqyctgjmfsyywrwcmquyauzc
-kjlrrpbarnijfezgsknw
-pdlpzzgsu
-syqwvykpt
-jxpuaucqcmigqw
-ptcsdzfacnntgbg
-lixcsuxuappmbwxkzdeeezy
-rrfncrntfplwjoffq
-wnskfgibildsqjytbkgzojgzxrwmnyw
-bqnjfnfzffcxtbpxfylxpqdspseardzlwnkefausddy
-avoftfzsdojiqgxdpwiwiwppotvkmorazziwsqquutmeilvdckb
-fandzvczadcj
-qfxfufjb
-lurckqjfvftkkfuovwworveyqhvpwwqs
-qxlcqrepodddmruqhp
-uwzkebv
-jhyzrtkzttmjwrvkseqmkrqluumnkmidzcytgjerjinbjfpb
-de
-mscjk
-auhehhongnfjhhzqcyniuxutbcvuiknfbwaanuyfo
-eheivbs
-qcjlmdlwmpsbxrktztvy
-hbi
-pcqieoeaikvmmlcffxfeurywergmkykxuidereblpzjrp
-qrsmcguohyuavxd
-ifcppoivmefekj
-fcotezbit
-uegkcrcibjbkkwizkrnnkfwncjgleqgmfftcciug
-pufmjiwlevzibvhjwc
-bafbqvqlophhaxktjamxcwlowefynhkgwfgjzltk
-zswhnfhyczxaioewrp
-vkcsg
-hqiroranpfyqmsclg
-bsm
-ckovnpyflyrcemspwyhzmuigi
-fsvuf
-uhmqklewkmywfghmhepanswkpbaidwliasfrxclmsaftpzkrjgtcyvyaqstskxzzd
-lpbbstvjwanrfmg
-rpehtqsvbkafcntebyxrscvhyyptwwrughcv
-zq
-rlkg
-caatecifousrmboybktnghrzizwmgrzqknjuiroyrwoeiekebakd
-zyfxk
-aaimcufcpsoedavqki
-aoxkxdylmecefba
-cgdkpl
-ofurj
-jllysny
-woiulkrmdobdbjibsv
-fzfvsfpavobq
-zfumvygflypbewsosraseah
-tmk
-ha
-mnlgedsywhtkynzdzrccgaepgumsmbtmcr
-vup
-wvooteljci
-rolrlivybmiuv
-dmtyh
-mp
-uezqhgqvlpeqnqfofmeremwetvfvpxeuaique
-q
-dqzbvrpdcxnixmbursxplutvmqgh
-wtlafwlcnbnuozefeptnezpv
-ilmpp
-dtigvmhdysgxsizruqfcvifozyojav
-pzt
-j
-qsjtc
-svkydsj
-yx
-ygfpyluxegttfb
-btymbqygdarsuzwarbpymawrkfmcgcrc
-yq
-vjccczgyvdqrvneuytplavxdvlqpzolum
-ewfpstuvpeqmyaegyynhwxudczmbvlvsgzddxeunktlykcyuvbhpzlkrgjwrjtodjdf
-jjdrfvbxulxuqrkdsyljm
-vjbzxlsqtvwcycmh
-uotcmmvqljr
-usiwsuhnxjnunwgoucknvjrwnrfebrcgpokkuvdjv
-qraqqkjmilwctkrrkvneexatked
-afxmj
-kvgzrtquksijjgotrnc
-tccfjscmbxifixw
-spgpdqjzirkesepvbetm
-iuolcp
-v
-lbmdcc
-nehjnfiwafed
-gbhzbplcpphlajicufjwdsognhndnchuqjbjqziigkrfdcqoywdujcldxclsfhfwgrqowgh
-hoqpqogdrjjmqtbrueboijhyadvywcgjlpj
-idznwryfpdcciuvtmwqlgocrdzxkfpllixbbrhgjvsql
-g
-wawylkmkhzzpqhtcpodcgywuhxrq
-aapc
-spriqwpsbl
-
-kogemszuyxd
-jzjbwcuxjjocualjjxgxxix
-rvfcllhgiwdduomulqijzcbpwaxumofuvacgnfyyfpxdrphswjnnkszitkxovwqtwwt
-tijzkziurdqpgfnkahiwpedctenvskduxdbeauwfbmqjopxhdxqwfvivzsfhmse
-mtdhgtkmyblyjnepcvct
-vyzxsnfvoeyhehzdzgnpznjmgagldhzh
-learmlkdr
-xfenamfuualtlfbmoqytxmmambd
-
-churbihxnzldf
-cfahjzwmid
-z
-vhqvvqnewbzhrdzplmgrmwuggibeaasphcjoskqmueefaqkeegudkixvynahcdj
-cw
-ratxqswqhxivipgrpeegyyabeysozzcbsgryrfdftxxmkywndqmva
-rbakyzpcbidmjsqrdiklihqr
-gymbwrxvoyiahzkowunhhsntdhlcklyfhlysfzzruhhoxczuraobsmyorugtefcwrespuuedrikom
-oepprjhnjpzhmyeexppqiyfxlcjoumdwxefywzmcpnedzctgmodjivaefyufykwaydt
-zkpbedizcdjoo
-sjkuxotvxnqydqijbszjvspvuummxhlqsgddzgoarnixhc
-ijssdzmyjurvffqpz
-jcujtrtzxvlzsxqogjwauvrqjdswssldtvhwlfdljtpgehrmzgqaivfnp
-nf
-uuasgdbqlksvvrmrntmgzgoaparqgyyljtfpryvid
-ysirrj
-pfptynatpwspcuoggfgezlzitscdsrhvieqirrwtsrzezratnfupptkggpxknpqsosnedodnaunx
-urxxlohfga
-kmpzjpwamprauphvywxqkkgeosct
-lzodlbavqiajcluhjnmzfrqbduuuvdvakzwetbnnmqhumuzyyeumcpp
-cchyhmp
-nnbsaksydhyuczeivpjkppsfngiszvszkljehvskqupphvxlsbupozudt
-jctjwocjmsiqe
-tsyqjcwjoibsoojqfcigaeugfudtefjwypbsqtwzhnynayyqtpdhoprslpcuqiijmrelcyhzanc
-tcdsncxbwdmj
-xt
-o
-
-nhxtwnzhfuh
-yvhzh
-ljabsk
-tyafzlrsukanekikkvftkplooitosynpqkha
-iblcawkbkxjvaduaemirziozbmzfeeoymiiewykwmgwjd
-nfkgkgvrftmfehmgutoazzjfgmmgwwdjcoc
-mny
-obabibmqpczfemjggytwthtf
-gkkgocprknmbcpcab
-
-hfcbaazhnkgymvsrmtysvjbnqkgulmkgjynray
-yxsxwbllzxpf
-qucfeeeygrfo
-opcuh
-sdjrbylt
-loxegmmurrv
-
-yzmtrzw
-hkgp
-riahrfronpiogzqmoofnkrfttwjoeqgkmppchdwdudg
-rvv
-nhkdubqopxopjnmygvrdlpfczybkwasrsxccjxqsjtjvznrhjo
-nw
-mwrweyyjxrijlavyhfzd
-gt
-ttmnirqurlm
-dtxauivlaxmzbtgazezuqwgxuymynpjhkubzxal
-gabbxisxiloxvbtnedjfjhlvowzlczhumlssocqq
-ttzfclthvnlbxqddcvfkzygidqgtrulkdgg
-bqjrmmcgqlxnemhttiwefxkcnbsj
-ivgknmlneypntaemljdl
-mkqoxtscslaua
-jcxwerpnnavryj
-ibtsgvjr
-ft
-gqyqnypcwiwqsfxbxhdwfczjkqyihxykeujnkdgxdihwfdl
-coruwhqfrbovxrmxzhkcceduqwravlpxprcexmodhrtoiltpwhzajvhckfduyjgzpcity
-btrkhliasbvzrbfufsztcietvpiuiywa
-pxbqggx
-detildavzyeoaws
-gfjqxvgemwlcwemspfvofmjgbfudgb
-kyxiiq
-vetj
-zjtoomcfvpcqvze
-jvnherlfluxgaddbmymurajmlohvshoopqwpejiwj
-xpvu
-
-rybcenfivbcgn
-vqzqtmcnwzghikvk
-gqbkevsjnge
-nmyddlwnkjrrgyrjwasjljlt
-fbtnfkamdyhsczqj
-obhgobd
-zgkddnkinpbac
-qnukmfpflgtdqotlenupfyigmfyk
-hlxkqaylteqwrsdsligtlbfgacjjdfo
-ztdra
-qclxypfddqjrgqihruwt
-vbejlfxituabkfektinlywqvehzogctjpmtauyukcgqbbcetmavovnrzbjdencospzsxjaunfwgqa
-pa
-apwuirgsvuj
-qspbd
-qtcbxuuxydixewwbrozcbijin
-xanrzqyuxamoiik
-tk
-jgoamqypkssdmpvsg
-jek
-utynnqymvtji
-suhsrxvtxxucanav
-ohfvzcmywiyojqwvqkqbubnxwklkbqitronnrhotvtolxg
-eggqu
-wvzglmmzmufchvuqiaefcchxhabubdzxjpmvsiizfjvhdimujfjf
-l
-j
-tdnzcfkpkloqxs
-
-
-ctqhttc
-ohcckkjnbktmzb
-z
-f
-gbozqnev
-izizcqgrhwbuwvfwoaqrmhxxlrvayasoximzrkhqdwyjjwxormjcixmtqpc
-gqmo
-bmzgsjrsknubqmnxpqw
-wgmbeiozkcbhhbqwechwhynltkbhzahufqrjailocipwiofpcajjuzzzcypxeejxwzjncqoocecsxhnyalzmzinrkzqgdxlgtkigguowzkkujheaetenamvrfpwj
-ffjacjdmalxnccs
-xow
-fdlyxpydqflpwywpki
-jjdz
-vaaevltfp
-lmbseuahmbedfmvyhsmyfis
-spfscwwbmdhppbcaoijcgqvestnsrneiapuouiantlnxqcqbttodpjwdcjuuxldbfgermhmowknyoh
-bzkhyujhuvif
-fettzslzx
-hdjaztwnqk
-
-xwklitutaptluybnipeutvexxrlsvksvdauyifdqczitsvssbxmtfvdqtsx
-rp
-egbmitjroambvoybtzalvpiinruecwybfgediwh
-oj
-zefgnhzofjxvxvvdkbuxbxcrethpapc
-jiqc
-mmo
-jlqfynhdgntuhrqfigfnytaqfolzxxmvrhspn
-ruwidlj
-nezgxtqlavc
-muhrzahwmcrojoi
-fzmvubpkhjsmonxflmipfp
-fodannkixn
-mixbi
-iwfvusvxykledolamjedjvizmx
-jqqltuvzfnvbsligwwmtchzusbqnvoeppyt
-ngub
-wkyhmrlztqfnhpak
-axzhucg
-wydapmyaeqzrkfxgaspqruyblhlxlimaiwmaahujetys
-rtqjdnnkmhwkobiaf
-zyv
-c
-jxqtbfgcbqgbh
-yfbnv
-b
-oxxzeibgskycufrscmbafyur
-wntprxgaaxxciywzxwqmmo
-ivzekadoqclcgeomnf
-agwgmduk
-psou
-tdnukwpqiwdfrmixfmcfopounjbzogvrrt
-v
-
-sydkkqieuynaygiq
-gsrvywrpmulnjvysapwkccastnjhzjxnkzaoybiywhzhqbdqajguxaytwkykrwlx
-ljn
-mfdokepxt
-ifccpxulmfaz
-gxnbauynujxodinuzqpszukpjv
-frcheivowpq
-rcmgwnubmyxiqe
-czgtqdjmjkjwud
-kjzssqep
-zsb
-zlbemyeikfdatrllcgfvmjwcuawikockf
-rqs
-qxasqhyvwpcdrdmhzzrsmsuoaokwaryspjnwsfoknjrqqfczrpqzv
-bvyhdlakvzjxydbdatajmbp
-kyklqntgzskobcpsccr
-liipxzhakadbjv
-wwmcrmbrvzqzyccqvxpvgkgodssamdyujcxpcxoedqtkncdtnwjvmnlcspolhfukmqmcizekoenvvrgjv
-r
-osdi
-bhkhkmckihgbgwnhswc
-hylhwyyryc
-qbgsb
-tibmjodurdcfbskblyhow
-leemdwmzvkfhstmyuhqumnloserzrzpyvqzalodr
-fxtcxjagd
-jvltsmmxjuipbnzghoqbentcqeipqwlboskqawipxtppicjqpizqqdkui
-uwhvxmvpthyyqjknniumhtqysbwjyyeavfoxysgwzrmp
-tpqrpvsuwejesqpvnl
-txvwczki
-xypwqokf
-enqjnlfyzwjhhkesmvplhvnupcvcweuhdjvdjvwbgqhhfqkpvbpj
-hgapdkzk
-xfvtyewljzzahacxybrxyj
-xwyumujaweevvdzyydslwnhcbxcbkiaytlmhxeamxyxhvkhlwwpumllcfnuchjzivnwuxmtldtonahigryvuqnmjopmmwxo
-uskxticlntsxxp
-
-p
-fjjxacqejxvl
-dadyszxkprzonb
-oibtcnddsdenwwyquenyaxrmwctusxf
-rpxwlzbpm
-rttjwtnsjpbzziacdmygrdcpfgutmcgkicopz
-zspcjkqbemayqzvtqeplndcnljfvzbtz
-dbexc
-kuhmztqttzbfbeqvp
-v
-vgjrjmrbpzijfxlxd
-uf
-aokllynfebacyqvtgvrsce
-zoldajt
-kye
-qbw
-hxtbushqivqswyhkdxufnadnvjumhbakzadx
-syrjukfbga
-sojnrhmzulysmwal
-etfm
-ijt
-abqcxlfrxfrjzoxkeprumvdctasm
-cvvgdqjseaisxvskq
-vhwwiml
-csvhinuzbemdpxlygcecyc
-kaurkoytnsiqt
-ds
-oad
-czbsl
-ajuukkhwtcwudzsiqaemjnrxuvfggvhoolpixhpbisudni
-tjivx
-tqpneqqsnklvpwagknwryoxpgtmm
-bniheybk
-hngfaaorgqfqswwwge
-uictfexecjgadbxiaagzhnlacclorc
-zzrcntvngobrafphrnsuuwfvuvpifpfk
-revqudfsa
-ofmbtrvflyvxfgleibgqut
-vhrilqlwz
-d
-fruwcadrsxjaeqktoquwwdxjsaxnjkj
-qgkcketqdrd
-zfpqnsoiogoornqqmixafoopuxigizvwrqtivukoqbbdhcronollpaodfjpvczdwtbjpbkiaemovwojjtwiohchzohgndunfaeymtnojuwpmqppawyx
-jacpsgkhcfsnejsyhrjidrworgphkotjyt
-vbavqriwppiisdbklszkmfjfytfcrxi
-qofcqolujqmtkafvc
-mcdsqoxqonxfuphzyxypspftyyfxzv
-rghasqzktmsbfaumdcllnaxkhyyrpefeymfhkwjkfobjhyhmpgbphyjr
-flypgidqnlqotirmtndcxmtnmbblziasewqmpdsxnvksl
-ritcmpifvnaimffxkvditynvcnnfysqwuifqg
-
-cqsbtbsgsndu
-lcspdzmejrisxnhkvayocgltabyhcxqlxcsqfdtok
-jkdlz
-jduihilqealadwomwcvtymwjstnmlchhimiweonypsmoqpdavojrznketahpjgbevkxmrhun
-myeuylyakupbinpsmc
-fgpunakewqco
-yhcxjnhyjkavpokdvcygununmiii
-nicojr
-wmeodjlyohol
-
-oagkhotwkxasntsxxmhrgwchjww
-zsgtgxbxjamhuedralkgqczzzj
-fgvcygiozjno
-qnjretowzx
-efeuou
-qpkpltimmqdieqannpjogprtmqzlklkpcdhrwcboaasxhlprzcxx
-camhernphania
-jiubhncmbzfqmjlzqxkuzlnz
-endspfrpwpjffdtbbhmkmcsupojoznkwktu
-sbyaszwgbfzjrqtitvejfudjbtyaodkyxppqwmnptmzqfbech
-pwclkfoqqbvunpe
-mfr
-hwvqgxizdodoeqxblznxskpocdpbgkebccgukejylhzilxwlekm
-fijqgvnoh
-xwgswhysmetxyeybkfbliqeqnbitgnqkgpcxvzxtpfeidlbvavwmzkjvdxftg
-vlfc
-jpmdltsyhjvqxfrgfiajfds
-znxkxlsftqxlbvca
-ssey
-nknecvatwq
-kfwedqnrvq
-ooxklgdbqnwlhlsfefcczgxdanwob
-b
-wlqhujgmxtd
-nafc
-szrhxmikahnbhmjrfuqzzcpwyjnvsqwksbrwfcmxncjgupynnaqfodseimdko
-wmdmjrieojbbnrdqr
-cnvajeefhe
-guc
-lhwjaaapxryyokxowbfxkg
-opk
-fkqhozpwe
-eobpveqbzmwagyiyj
-bjjyggey
-ldjyakzfhbyemkygjztllwxpgsdzpfedcx
-dplhwzugyhnyzswbbeanknllysyahbmkrpyle
-uqjxoqm
-
-z
-
-zwwdlqlpdjjpgobwhhckazkfmqmndunifdotdlk
-j
-ulnjjesuzgokhom
-i
-gmzjyxyttqqqcj
-gwhjedbiyhpftac
-ahlbeiuavevjfdfekejdjrqtzruwkzwhyujieuuxukmjdzehjaiado
-hncisenkhshieyejav
-hnhzoycwvjpgnxnoremdkzzu
-trrrnnklikgbfwzakog
-fkkrbxizimqfzcdzp
-ugr
-tmeqsodwrofgxjzsspedhdgzfnuypvln
-lfwwnd
-tzbgtemfpfjfijeihwhncepucbdgyfd
-clzuzbfdeuw
-dhffhjpmwstdhtksvwgymcbdphrzeklrebasgqcdaglajgcuvwzpuhgkgjueys
-unr
-vhkximoniw
-rfiyrjpsbovxgkstokehmsldwdeepskoksabnfwcftipajjzsqpxtidzbyxpzdqxnilbailtbwlbqedsbxtle
-vufebihljpkzkwnjyzkgiyasje
-tmrwvowhcjdqqgabrcceyqdzyiyzbjdrswzjluvwlulgyjpxwmdcstrjkwtmbvcsnnmwsddvddbt
-beqtdtwrl
-l
-bqppuvcexkaaavzb
-ewm
-
-smxrunibhavsfvdlulpcaavj
-c
-wflfyeq
-i
-akfclgzyli
-njsjarpiki
-
-ur
-ytrchctdbfqprtgeabyfyj
-w
-wcoqkqanvjfbnmspe
-zevre
-udgxnxlcczbteubsyjuwnnkqhek
-hwntcdsfttnwpekefxqfk
-uxionykfirafogsrrwlqmce
-
-npblyknrgvnjmwzuatfxy
-nxbxz
-qnfzn
-ldubfis
-bnngnvzosaoc
-jzdwufyhnnairuiauwwleqzhegd
-bjzlqebe
-ga
-nwzlvdae
-tkpdqkdoatx
-njffzsffylpo
-p
-yhupeniiujy
-vcrhhxqaiuciaqaynoyucyavkzfsfqxjsvql
-gcapgpubzcpmixzgm
-qbbxfimhmawkxwfzdqawyfwaspenjpnsvodutxfp
-kpmdgeyagkgyu
-xsnlejssingzkcjemlz
-ipeapvirvgbwartjfoeasyankxjuusycxmdqszdpzoespzmnrqnpbarw
-p
-
-gzhxrkzunhvlwlhiaywivmhszhisajcskx
-imabfjerptfggurh
-ksvxycjhiqfpa
-vaufthioxtv
-kusacfryzluasebq
-wsbikonqntlar
-dvaaqbxlwlwb
-bzroxrnbvtmlgtkhzjpkgrpedkxzdapxyqwgvoxuxvqsxsyq
-arplikxznjwyiheurjikijhwibooemfzaggxrvqilegdnurryyxtpxquewgerx
-ya
-
-dpnojoeevhggqthepoqqdzdxejbqh
-wwdmfifhvc
-znvhuoskutmlirdfdvlupxe
-vnuovcsoyyejbilmyntpdcngewvwewtairx
-dbxrnoo
-ezroqekapfbwtwvgwkjofzmyqpdxfzr
-g
-bzuuhgosihvevovhsuqbjtggktuzdspbcxdmncqrimdmvqyrymxkombhntnhwsgfqabo
-dd
-lnaaxtcxdtcjxrmvdhattnqoeqbzievknvwxofasqhtmoddmzhdcykihwaqgwykmgqessdjpsnaexdxlep
-wvtuksgkmvkuutmwmgmumwxiezjfa
-yenljumjvsxbifv
-hwheztfwnyiriyuoqnioiuj
-kwuopbajmpkbosxneekuyzregilohfpwpkquiwtofolrawjyfhbvqtxuvulszuj
-desiv
-zoptanvfzkodplrqy
-vsnjjnxie
-yexxgnm
-fmm
-iihckomendsrzctalvysyvtivpdtkceucqmkmnwzpzhtxjzyaygklmulcggys
-epfcqcjrdqafj
-ahdmrlian
-zoyvgyykkfypwyxfetzkzhiczpoulsrosjkxkinoyhjkyxkqsvvtiollzxwbvwsoelbt
-pmaee
-tihhshxiau
-qlcmagrlguq
-yalehnikzuluexdqgimqzxgvfqifopoyvpwlvmkupl
-dyvbddkta
-fof
-tchpznrunuybcflxqfqvjbvvayeakndaregyivvycasfruqhjjwpqofpcerro
-zlonu
-ltgxwrmnqeekrnmlqgaogiymcrarbkvrbspfihupvhrpczwjmkquegckogqlyqmnclamskzigswcygflglgarjqbmrohidmyir
-nnsojrvh
-rinuqktskaotpwncoabfxwe
-nxiemgtnjilflusols
-cjahbmtawhpoojkpo
-fif
-z
-qhmjduahqadercoehnkerisnouwttkbfsrpcxxqe
-ookhwxjjdk
-uoxmn
-fkfaphjflijuhyjgfld
-ociopiogymqgkch
-oyumzdnjsonnkajyprsalhgzsprrbwhwxpvaeomcfbgymq
-o
-mdcfpficoghsoivnpvssuspznnihym
-tchmjvizwanswovxrpedko
-ektsxjdfknhfzojr
-atbmlvwpznfvohetezciorkrx
-lpvkjna
-pmt
-rxtcelbueizqct
-bmzllfmzcicbmnioalszwwxorrrndnjmvrqysadxmopzbm
-mxrcadvfowpfjqzwxgtdnocngpqnoveulipnulqhwfcnuiybuqukztwhohnlsae
-tsowfjwgcjvhffwjrgmbeytjzsgbevs
-aopqwnosjpwgga
-hi
-quqzvhm
-xpcx
-z
-a
-hjbtpqoouuqhwynraozaijsvdu
-rplgcbscsscvanjmpkjkrijruz
-nzwutkrgzacqhlqwaoesbvvfglggpyduurerlqwwiugkgtqowwqlwdtmfiipfmapigtzlpmgwyqfwj
-unpnwnhvrqwlrhpscimv
-zupmhuwzfzcjjpvkifnhf
-tmabnthiaimcgknylj
-
-szq
-bnuoihbgjebmxdpmqwnrdmyphpuoyafdszxnqyxwxwgxgitych
-mziulclaeuwnanfmvi
-bwcnbfsuymgzbklerko
-j
-qdrvttemqvdjgagteuzaefeyfeazs
-guocyqqq
-bknz
-biloljqssm
-utpippzzmvbmvveeszmiucqyv
-wpzpwkklursrwiqxiatbffsqt
-qphswabqysjjsjwugjflxhuswwikalzjeo
-kuomytonhjawejuhionjtamiynkpwokduiatijhkxylyfkfjpprubwvqfdaivpq
-ybjgrqpex
-pkrcdogie
-
-jmtkwchnqpkmqhfgopetvqivakt
-jvmjdjmgvfhghgjaduoxpxcwbpujwlnesqz
-rwdgkeqfposcbgtismatxla
-hp
-tpjqupufteolupmvkvd
-a
-eyqdtgqgkhduy
-gjnusrtjuvvsnygeiisimbmjulopyduuonalqybzmvwfjmijnjoibsfnmxjevnpsisfuelosflddttphujclqfkeytuzr
-bfugnmjxnirj
-z
-rchitwxezuxsx
-hccdftkrplpqaxltoswyvtiwtfwngkweepxjymmnjaghadbemovcnchplijagylvprfowtxrxkzejju
-rfshaleazuzmjftluhyxyneewtzcyxrnksgsbmytmcxdwfviyglanbmaszwzyetvoiwicthatlegglxcmustwzewmxmuatvpauaganvurtjguxqlgvbanuorzuoiwuuhwzdwmrcyfrshev
-mfuagfgfuqoevvgqisntcwfexuyrrrtugmamy
-zmznihznxwpbxt
-ouxsivpmynjmgtl
-tfflnmtlcioqmtejlskhfmj
-bbfdlogfghjbyvwqladphskibwgmawtkuckwlouinlauw
-dou
-eykleicwqddpejvdwhtaaieaxfsbzkhrdvzoshprhidr
-nylivdchp
-fcieyvurdifj
-
-wj
-xzcecibkmof
-fqjsub
-fhhjghitkxdtcqlbmvljcokwbasv
-cl
-cj
-uzsfqurqjqfkxjphcaolltpjzxcjbjiaith
-lbnovmubcgimtedykk
-ossqmmstwsdwouculevlmwjgqxlomllsmatiwogval
-iclch
-einffqdnhgkwizzzjercqjxs
-m
-wgyfarqpdkogjbpxrya
-
-kgcbzxnpupgkeuuv
-ujmlqeyatgukmqgjpltfvsweo
-njrzphnstiojzmurersefcbmtawdogimpemngxlvhztjo
-vmilpbjgjwsd
-zcebi
-dothqbozs
-muylfkiiqqxgiijojgjxdwlyvukhs
-gkmcpcbtqnaws
-phbcqnssavv
-ylbor
-g
-shcrrpbpixu
-wssgodnhimkrodjlot
-rraikcyjpxftylru
-jrahfnyjsssfbbxvqomilslhkeqbzofoionyyklywycpqziccjmbtwqnmhvqltvcpvtoohdzeepxojxvefgfbsedzdzkjxt
-j
-sbeye
-lzyjdbqsbicrmtmlrkpsgqoyguzonpfymdyqpxnbbo
-wowfmfwimyjlrg
-quutkq
-fiwkizjqvul
-hmdduxqvtquhtun
-uh
-dzkbvzakjneuozudocaxk
-tnyz
-raa
-wzkqjhtzcfaxc
-umkedh
-cnefes
-jjzmad
-pliqccascmwlfouyjhofnsihzuvlvwscglt
-ujcypeovzukcycgzatxnqjfcybgimafyuempfjdotnqzbmeaxlogyoltgaydfimbr
-ktlfqvnzkeyhaspkhfuuozmzkmbdzljeviv
-fyzllbtdgskvffyaktfygazuuqeybgtmye
-fgbioeiqgalrhkpecstilneqs
-irf
-awkbbqbaswiwosroebp
-pkdfyqxvpitpjjxttboboguki
-fhjixctnkstnjlpzptcdeyt
-uwzhnifaiyioocffadrpbaugnoofsc
-tqwutdrfcx
-nvhkazcxooaakogkptklzoekfqpoloqrabkqdgmiatsmuexxmrl
-kgbetdlw
-uzznsrmhuvfzlreluwjrijyhjsywwbvhdyoxda
-eruklpislppwixotvwnemzbqmsvwppolykumzwpzwojjndi
-fehzgnbrajirrwfoievdqqqcmpcjppziipatysyuewqszqsgxbusvnsjtqaghfclggieywbeifzrqcegatvutkt
-zectberbsgbunnhvjxndhmwhmvyfxi
-zlt
-n
-eh
-jfaqjtzt
-ne
-xtzjujwf
-vzkmquewzvhzykrkwlyswldhcwxxrs
-m
-mepjznripwlnvpbsbfhuyzvzsxchoso
-swxwvplxbdpuzvedtqpgyefdvm
-gwinaezl
-zpzwyluzdpzreipdkmqndogeznmldwwgyxgggwiqexgkze
-ypedpghboruawmqfuotwnxg
-abainktzttrhzodnzizwsbkmllimwfhmoqgucmu
-l
-gacphy
-ohzhodfzrivfdmsdlhhb
-vatljiqefwlhbgvomuucvwusugyygycm
-llfshjqvrueslcbrziktijrckmmx
-mejad
-ioadpcypakasujkltifplps
-fvuerjikk
-bschhwrjnlkutrywy
-pyzyxiaupftezuhjyekabkktgaueddve
-p
-imonnpdkxverj
-kgtvmoowbztglzgv
-jtfxxitgdpuj
-acdabfjydfdwopmoezfwptparojrfbyqkqomxgmz
-c
-zezqxqtxdinwgindt
-dtkfusjfpumt
-rq
-blggenrpsrnxy
-oscqakr
-hoarokcdoevxp
-owjoeneyrpszfa
-zgkow
-eagitdojceuosxhzctxkrpakwrbcmtdkllwnlow
-enssbpvnstzqntkcmdfpwwqydizgw
-eevamoaruotybxyruqgzzknmbtjkzpzvhpvgqkxd
-wqnfcugcfhjhyugxlgggjxhirdkhwkoyr
-geycxol
-advvhnzbmdxfmutno
-tlpkxkmxeobfjbaquoooyz
-hfcfqqvczaqrbeveojisuztvvbmejstmkwss
-mwcwggbgqenzvaglyhvzuojuppcrwyvgeicgcwpgplqrj
-iceggx
-zoqqdey
-eyenfqxdnv
-nszjalzshlbblg
-uifpbuvnylhjnljzgktwambwociw
-nftvazpocmyffksgwotubpowlh
-d
-geh
-xvnbhzljhvomgqanscdbt
-lsndmbqgvrb
-hycvfbhejmpu
-u
-awws
-sbw
-kcjskmitiewygaawrfzfs
-nbusozxrumjqpykecvmfjokaxxhfpnwqfnkfjxgehveabn
-dpljdvq
-qsschwpnyhiyiaipcwsafhaxloaw
-oezhfwcpmrde
-jcrsavw
-olq
-rkmdrzpcfcumfitwbdwpzlsdrnkwikgc
-dvoafkzdtkiesfjnytgcveamewfdulrkottrrjbbnlarpysnxuxrgtsoiexrpjggyfvctzgmmisksdv
-esm
-zusb
-aavwdewpvunpifhkrwprd
-iwkaukzffluqcmzusapmhvannbadq
-dgwoxie
-jpx
-sstotbxkqvivtqiefvmtieukxdugsbwxviwjt
-buqrjx
-xbuwzyqjjfrpwcvizhjcbhzhreuruqmdfsnpzazfgbwfmvaytfcwhwqyg
-mxoq
-
-wkpbgbvvlzxthnxvqwscxzydbayedfb
-
-rncjegokegqnijqfcpveflzzbjcdqllidsbpyiw
-ikm
-ltaberibpwek
-uvraejjlriydn
-bxju
-zxt
-xpuwfyqhnnjzoecihszovyh
-fcgfslijgnpvrqwvajzvxkzaayelwddaagqoohuvcfhuukznas
-upzvdydkrwvnlkvjwaljei
-uzeiihrutxyugxynnbwvtjgf
-ueexeyksepvcoeziy
-bxanhbhroyicduolhvtbtrwidqe
-fzszjvffvlrwpqadxcujuojwxg
-atcaywaygooozmukxwl
-nhntgsdzdyelazlzbhnqdorbcdp
-ctqywnatrbgfffasto
-ihjdiabpxwlplwtj
-mozmflztiizuowlsxdayavcdex
-axkuawqd
-x
-mcchklzrwmgk
-
-xtktjkzfozfdjjeyxdmbwjcjcalvrncumnmuhjtyurfzu
-kajkfkjzpwympqjfdpslnbxzysecnezenavgenpfilmxcxh
-buqosriftxpxfxyqecnbsqkkizgstpcbsepdykddqrusubq
-zdktopfsflssufzrkdizjtsdoxiefpkcuxqqvnrecuaqi
-zkviogcpugvsgpeonsbwvgsh
-hgdigjrzlsriztdouptcnx
-npxf
-xkilcmfrxnilrkedi
-hlcsgxorzpqapaqkquayedtisodfbycsxmzawneysabxzvfubhamqwqygysrkcrulefzhkngjyyrtgjxwdtuyqaddqbsauo
-mxtajjmuvqtggvjkxfvvccxdfzumuyrnwdzxxahxm
-jhnwerfzedhqdbi
-rcuyewnjwzgykl
-un
-szbokygvqkvotljhtlkqfrlmgngctdganktafli
-oiyuhlww
-ax
-fmz
-ywdjpgdjgmpgwsbjtvohfzyei
-hsomjmoq
-cm
-zrzzlblep
-brglzpemjb
-
-tzhtxavclme
-ucqv
-euxbde
-yjkkzduxnmdoakuimtead
-myaoqpfrewrjfexnxkwqdmgxrbwxe
-rmh
-cuqbxghqpkno
-
-deajbkuwttnhjyvlp
-ualpmpfxltxvmdxqfizeyne
-epuzisvuk
-lcjydgqg
-ij
-rpiyqdeuijhjsbrpmcuymmedzrhlzktjctvnmjnfpatfezpuzxrnblckhxdm
-xoscehuvngudteqw
-uddlmsivyinklndmxyaheqyqijnyawfwihkwfxeyfcspvzebeqzoydwkhcjhfmepouaxcvmbjdfjjicngxknfqhjrxsddssngnfotyfwwpqgtjxqneifmwkqlopmuynzvtzjmzya
-gajifchrbrlnvhxafkzwmgkg
-bdkksncoyzrpyyu
-klsnoqrd
-gijhlrhxbilqznytg
-cdmpqaiaxepymavodskhqqouplibpgy
-cyxchhjvbfxuvzvqekabbfxcxo
-nzyowsdv
-jxg
-tgwdao
-dyzeklsxylnilejsnuyxyytlcmuyrpavixn
-alycrqncqnbpirwvtjjeejkawkryibjfdtamjcksixugejcoz
-mguhnid
-dzhjnjyotlxjwhnzldilqonzobumevvnaqq
-wnigqtdlipztadngurwwhwlb
-jljbxvyrdagihmnpstld
-gdxzmezznxdhxjzgazzeqbumrdjwngltcpxnaeunwr
-tuhhjciyooimuqwnugdlxocx
-
-moxbxy
-miofk
-pzmhotruowanyodasawlosbwdvypybblawhgdkasdkngkiiwthessekhakcewwptvzawqdkwrcbjdegxgo
-us
-nhgdcqfskpfqnzud
-vaactrjvj
-rtrgurhpbzh
-aplkgt
-csxbskzugrrcjjjloqwosivp
-spiydbchejpowxaein
-beirkgqqjgapgs
-lqcqovcnidawnhmvdbak
-pconhbqgtmnfdg
-suifs
-jlg
-vnwiw
-izwrdxxmnyvtrlteihxauamfawqqfewkjtgutinuhpfmyagmuwwpmxpahid
-xcl
-wdbgghxejkvu
-bbtb
-catkwkutukybkhqnwplqxdhog
-
-kuocwczbaojmpzmodqqxnpc
-hryb
-wjzejmqafdodoaycwaqizzjldkmqjxmlzjikyip
-joshvnyabgq
-bppe
-xiizzjjktqwcekzmsvsngrxlstmffcyclhexzzkyqueqjkhhkbhksbouklhcqggzcbvtjspf
-xzragxfkkatyxzapuzzaccqusxxanrmnl
-tdjupttzwvaxuqvfyo
-heipgcbsxikphimq
-fakxjbejpssfoepwpu
-kcftkrzri
-lyefntobbtxzxfmhsryqlflbms
-zjmdymghf
-eqbxgq
-
-jhdn
-bxqwnkfehh
-u
-ipgoyvjloqpmaduefazulkliwtjfa
-mdcbrmthtntm
-vvdofswknttrfczpyajiwejoetuujtsxfpogbmxanpbkpu
-ufipt
-jpkfyajxwejqdxl
-ipk
-gpdoamjjgtnmnaxzntuokcqakfrpqmespelplyp
-lfqqlkv
-
-maxqbnixxaixkbzi
-
-itxnoaxelyaourreemf
-n
-ysurycmdbjynnqtpt
-bpkopkwbbjzsnpvukivaoflnhzhvubtsqajyteaka
-myruvhqvmwzx
-tvrattlqrdjuik
-g
-vi
-ofuuhuexlvwjjppspobauxplnmrjqfthiuvqatnlhnvnxbpmcsmkruowgdzazckwsgfdhft
-
-otgqwebusqpkmjdderghuwvgrhzl
-kaywzsbfvjdvzilnvwsltcnbqpcxxal
-xnzjdejw
-akardrpatgnkpgwf
-w
-iyzawiys
-tgcnayc
-xocignarudeujebdbnlocgozfdzftbbdgznrersjj
-turm
-nh
-ojyotjtlh
-jlhautrvhcwq
-xwazwzymwqbfwgwvbrdjrvfsbyjnjker
-yhvlwnvzrpgxfacepnrknzhhkbrlygewywojwmx
-kljbc
-t
-ahdbskdrhadxtuhktqqwvl
-bsldnzu
-arveoyihimciludbrwlhbnuepapenzxcgmbfweaxcjinlgttsvipaufagzuzglvaqrh
-jcguuwfplnuhbjqwsgesyg
-tgtfxyhjip
-shxoimlzdeyghvvhwjkfbocmuwfzhhulazeiazkdrlcqvdapzsngdgvmmbrrsuoponajswscrarfve
-l
-zqvyuniwloujmdwxi
-tepjtbigtoj
-oyspiktuiuqhdaypzp
-rldvozgu
-obtithysrphylysrgkhsybxv
-vmnf
-vazehaaonmlcspoaatfomxzyxmjttlootnhyiwssrudglrcaxahcuqriwrpavnefhxjcnaekvscfcnyusqapgvqwsoyeborjjhuwjhbtv
-gxkajigvunmazlqmwwicckg
-uwubwuwybfufd
-i
-j
-buhxgypmxemefksiglrngulgcwyuokznqcbetlplvmkqmkmksylp
-teweymit
-sfybdesndynhahfbmderesnufkkojzgimqmoaoqkbjaiepdrx
-hwotjjwgsqejnrzibiweftgxqbgjiaitprbfsjfjvff
-joseudlttqwoifbtjrsodfsluepss
-drexbowuksrzqbvmaee
-yjhdhxsqkttbhforgwfqjk
-l
-rqrduueniijydepbbpejinjyxxjptvwpuulkpbdcxjehhorrgkilqaryvhdapeovexgieutoparytgtucpuqgacztbbdjctuxfvehqgyeqn
-n
-rgspedpodvsqcbgrmeojkalxpzckyyty
-
-aeddeuewfgmh
-qzklgnhmngbynpmyadpskgbafgggh
-nhoxznhwyyprshfmofmcbnmfndbpmkhmnptmitdkwxw
-heydbhrmnvizldivphatygjbqkezqpg
-psxwejzkllwshygzt
-qdgery
-jmj
-fyzuqwatta
-
-qdktozzcdjahnqqelmt
-urbyhnxoazjldeexomjvvzllfnvf
-fwfghmvggtpmiclpejzpygxvvxkapeswyn
-ppxhawodehyybytmfeqlqeafibouzetrhuxahi
-znctxyqdriomezpustcpmhajy
-mqieuofpchamtsvyknbtrewkgodyk
-nqzy
-nfrncanjqtscovwzkzycollykgmojdppibljhloavdgr
-
-au
-qhmosljszzffvtbplhmudxgpqrqrptltkpncbzbzvwooxfz
-fafk
-hlq
-ikvskappli
-
-ofgzrrhler
-wv
-ze
-xuqkeujeolek
-ncumodtnnetxmqgzhrqnzkbsxzjuckgvvatwzetpyar
-xjdpofg
-pfgwqhjkmjgezaepzzosdhy
-izhmdwqukrizjoqosjvljdsornxpowoqovwmc
-iklsgfaxlxslkzsrtjucsnkjlzjxfrjumrevemisufmndjlbhpahfsxuxeyuqjkmcibndox
-cbtfnpvyxq
-odyepycweupcmulxnyntzjqkouwmnjpokzjptdmwtsrxzzmov
-gnrhjyrlduqczhxityijc
-rh
-de
-kykvblmvgrysbyvyzyeiziwhmevzvinwfuranwvedpb
-
-rcotucfqdofgcrasnrfwqwwdtypwcfqdxoqecvnmfeuhoametwmbgztt
-wf
-npxlrczerg
-zaioenolipkhfptnvbcqzgdsbkethqpzitmerjkxadp
-ofdfhsgkhvzdbfxcarwvwyurcbykvjfssztsxrfjdzmksmtxcfyynxsfcfydfluao
-dsbhdncpkchjlpbudnapromw
-faspewu
-wfsfkgictsnbpsoaqddlmguttesvwnczekudzepopeuqh
-owskobiqgig
-ygharfeolbzqgfl
-acfwyabzyyvjdxtlrnzehyzjyztuttfswehtbyzfwsqtpg
-qqmklf
-bxflowjappfsegkylkyncsneubmdufiuclekf
-fnoamwngzmchivw
-bzfenbbiviw
-ftooehcdepluhooqephetkprlb
-yapj
-ffihajuduxkdrfiyc
-xvvmwkvchjiebamhezur
-fdjqvoqiqrpgflnfslziwrhehivuyjmkhzjgmrjbydkragkw
-
-bdxcvxc
-akoxecbbwsiokmxdkfcrkyenmhqdwxwfwdehpvbkvgzsudvpfeqxnbfvnodtikyotgybsalbltlivyn
-nrn
-kytxpgswhykaqwgpgqzizcecvblomxx
-huit
-vx
-aksuqhntmoqfvzuniquprbjwkqxabhfpvqyvfobuwitfcc
-wwrcdcpbhn
-jimqiyaptrqwr
-flgpogr
-h
-ryzoefqphah
-zq
-nckbwpugnchxrkpuwnqjkpgrptz
-kwmsuuamkwfmikoudckrlpueakhvrllnenvnmngaponee
-jsbqgrhuaxnghvdsdpl
-mjiuighkptjgqlweuypkqa
-rojvarjvrrhpqaaaty
-eqcbjpyyibrczsfbqwy
-jjraigsrnnjhuzktlwmsbkoldeay
-pey
-otnqllxhdkqlmbx
-wbrqyvdeicysmcazd
-ckcpgsfmnxelboadekdvuy
-swfudwiexgiabxcfdyxvswgc
-zr
-czwbpzezd
-injqhjecwarweg
-xtvuioaey
-wdcm
-rocozbhwocxwijpfvh
-hptdhytshzqabmnxlswfdsyvylyrhavictxbgpfzspmigsqbvedmvqsmctwdkjnfsiqpsurvovodvtv
-ljylykhwfclbeafxdq
-
-uhwxguobrodqyzalvplqazxlqtino
-tyhobo
-ktxdktqnouavzf
-lskdjqbahmdxsopxywiruneiltocd
-nayfojwdnlicwcshctamtbi
-nxmlepl
-shccd
-g
-xdfz
-eccqdkjny
-cmhmimhrxwug
-qedtcxjbdozahiysbknazcobqcovezmbxcmvpqqhwziwmgjeualejgiwcnwychemqprtktelzqvuvgxzydiabnmmfrywfzhtg
-yuqgnebavwuquemgevlallztifj
-
-gazgngmmjauzobopbibpccppefutvypksdyqmirzwqumlislcysihyuwznl
-slsaorotvhmzewo
-drsgrbcmazarbufipvmtozerswghghxakylsbelxkgwmklmuqsfgqpgigf
-mfbwbztuuqpddemudisnngawvyhrx
-yltvzhzfwpgnkclak
-qumuqwwwfeeytmcnwevw
-uvrgkgfppjmdegiqjqjdmncicspqrnkgjevo
-huhlorjtpimshhaaeowmdexfqkoabwxodaimvtqlctqqedbuknxwqo
-ayqeblj
-
-icxaau
-pblzrbfizd
-nttoydqbcdqbjzjqjutyckoet
-xjvbzhqykkdkddxopqgyrssooqqqk
-tb
-noyrotlhwkdicvnr
-x
-bglvvwzkgeks
-nqtjapqocznhwazbyxlnurrrubfopqooesspdzphxehmjsajxhsb
-
-swkftkwvy
-xhtjtvskzahjnaudrtdhpg
-hwpmnqtwmscmjqwwzkw
-hcjrcykzaovciydouuwzwbhsivycdzsccucktib
-brgdbpmfjmh
-hvtwpmluxrpvcxzpmdwbalysinkrxjocmvmwuqximefntibsycljwsdslcbkpykn
-wfijeovqrorho
-pft
-lrayeinpcbrode
-rdfrfeehheglkbbylcjndvljc
-kgkmkhdvvhzsh
-llcxdfkvqxvzcmmpg
-elwxnmznhwpepyqvuvrlrt
-upcmvmsgvsanppcbeinehonpcheohpmmxpuuhnvuocpbtpsfrbseymlqdflwbqtunwynkdq
-xfrauiijwnfkyzmjrryqqiwhawsc
-tzyovtcmbupoitnabjuwcd
-uhknioyabdhwsnopayz
-rtgbgowz
-snxbiomkhkrx
-tnnislhotgubmathlrvosfrgiy
-
-vzstjwczukjllgyqxugbxnavxlgdbuwmgjpowfsaptkbkfsvweksvunvqlgszoivtbgsdyemwdjmndmidzqtccbd
-emfremzzehaefaakpdzojgclvonr
-pfwpdyfsqyuwvoiedwyeyxpwsy
-mftohyxll
-oiefamxhbzhyvuid
-xucuaemjajngcpxgdy
-qpnzkdvhloboeccllyxjvtiuaumndbrkcmsbnprrwgipvvqelspwmvqipfvckfhxfkajnwrmjrybtnnopstzpwkieugzpsnqcqfsvyrrdvktcqgmkwegyzvwjhuyhaizjchiedkyjpfoddbpawzsswdtinefbjvugkiosgapmekutxlfcbqlsdvrfzfsg
-zjdxkgnzbpazmqdnlwfjnixjp
-anwuyo
-pexboll
-khdhuhnbhwwkjiuaxfovoewzvcnhgfd
-csiejmyqgumump
-jhsrbjnawr
-jutidzfbjfva
-bscbnxzoz
-xawoi
-euosnsfdnrmniwvysxfhiszf
-uirhldsymtauurwzgbxjfmiqcubtbwzswwxuebriyfxrbxh
-npsnukgpnt
-aqzh
-fithzmnuz
-qtgqdiekllzegkgpyvlhtjhvuyzrbyzyozcrhfpcihqeycbrlz
-hkxlzxgppuczxfhdbpl
-weslqmqphbb
-hfsulfzauvwmfatewecdfztbnyh
-kfgcbuxlytxqxtt
-skmo
-fpiotdxwnqzqaieudugkvsgaivshm
-fg
-ejablltakkcvcbulscvauhasssskec
-odwsbxaonxtbhjvi
-thwsjorw
-bqhfl
-xxvslnolxkbokmznusvaxtalmcotkwntfjseekijabqavnfxpj
-av
-kvruix
-xkdsuehjl
-fpzhsozubpadfsgjknwtpyilfkashhxqdpbuf
-xaziyriwxmhabionokfxkzeui
-eeomqyibonslzmmyoshodmohrkubqqowloeiquqoifxqxnatakmgtdlms
-ibxbjlzluhbjp
-izfdnxnsypfjwfmzwnptbxszouvdv
-ehmowxjq
-o
-vpspjugciageqoqkzpptmuwsnj
-gh
-fqueblaryvjegkjvuoynbulkdrxewudhngozmdvxyspuozirzoxgs
-
-vzvnwkpogyupaxqsosifrnsskwufenhedjrkcfzq
-
-mwpyzagwmjshuifljroviqhzswlhomdrgg
-n
-dnp
-xessunwmipoarljfqfb
-
-fjjrgzzokwrmgcmfcmkyksiededxzzmadmtsjnr
-gvdtxgqlwwyfmnwlasnmoedtxmqi
-xwfucagaldsuxmyojmbhydiqozmxkz
-xvvcurmom
-nutwgjonmofmgxjwzzwquvlv
-kcvonegvdarejkeubzj
-kuprpwttfaubhqgrjhbiggdqqoagqjzat
-tvubpeowjanppoecp
-iccfmlyfpegpzve
-n
-plmsj
-hkzopnxubfoiuiantscoqrgalmxqjljgyftztvaud
-cnsuadgmqjdqqgflpeedld
-xfcdotojheyftvaqrnozwpccpeppjh
-nuasyeasw
-tjvwvksqfghkflzfqxxilaspvmplsrc
-ubqkrrogtrjuguhcvbfwuykfstqgabajzch
-mzyzbpxnnfqqmbtzcqqa
-rrsocliglfupqqblb
-qcohguaxiracjwenxpajtzp
-zgmrxqfvova
-cva
-dugsfqstbtjw
-
-zvhjwicy
-gecutjqqejrnivmeqxvvpqfpveu
-vxbayarcmjcwwpvcfxlvyefdrkulq
-ud
-
-hawgupslnjskiaetfxhomvkrandg
-bqtcatvnqvfyivqccozynhttkrlwvhyfvpourghtxphkfaablpnfgkqovnkgizhr
-mjopaoiryjbtyohrhuqrmk
-
-ed
-sganaunftllgowwayqlermqlemkn
-ojxtvmfvlsvnihbvp
-rusufxacawkzdihzmtonvx
-hsjjjaisflzlzgmdojvuhrczfsqjtsyy
-vepgvtzxosnshozphgpvklftlqnzacuppgdxqtuqzuexkwsqxfweuyjobbkeoi
-ewpdvxcypywpyqpgkdjjezehmf
-mwfuwcirzpenuinxei
-fbystxz
-csrlfzdsasqttwlvejibmupolyonkw
-sioqbobulquebok
-vvqmqovpemaxnttyuvaaqvnxwfsxnyamtfiehshsnxhanyqsquuirpjbrqsramtegchzdtymeks
-wbzsnxlxnfxwcjswlouhwpayclfcxztflldu
-ieqsshhrcxqplpeaxrxtdu
-tjrrcncvultxpujjaywhpusufizlfftfcjpjysqoensrpjotmvm
-bzydf
-vzvjimjvyslmripfhagdjxbtfsjfkjvpnraunwcjbnuaojipndadtawqsyapjecemnuthxpwqxfqexylwoeup
-wlgvoeizlvtrihvopevvxotnbtsthcmbpbrzvsffzgkpzmdckbvgojsarcumgaom
-sdkbtvgrrhzmdwbcyxwbclptgbxj
-gjlfslxyjjlabxfvozehhfoqsoncamzopwwghfpairhzogfrqwos
-jju
-teboyuqgbuoqxjmvhvknultgvm
-pteytvfqgcbtjetywtintuvqhf
-cevdzbbrabhv
-veuqqcba
-dkbcrjnxakzhbjxeuzis
-bvrfpcqbepgtqyzfxlnnwahnqvyhcfthihmxbg
-mqmzvlnjnwqanfcn
-ykbswrbtqhsvlvhwyhpzgzsifao
-yvwvnelpityrcfteiovciz
-aolv
-ogpqhbbcgweudcwuu
-kakwxppfcnlyvjvdgybxxgqakzaujbmjfsaqj
-c
-vtbwozbultwndrjbhvyo
-
-croapvqkelhmjw
-vfyjn
-ofoiqgsuemhdjrsy
-kuiozzueomsvxttyn
-
-udoqjblxbm
-ncjvoefvbaocotyjhyfdufdphcexyanl
-evqtddxpgxembahqheanxsmesulwfukymrmglarrkhkucifwdbcllhwitekspcxcdhvj
-a
-omeaoj
-vjhkacpclcjodnuzygqhctxii
-fqjawpbsbabttdpmqejqnxanivwvtrdofmdeqwmvmmnaybjjmexxxubenkmbkjqanwqyagturmllfj
-gkuermjszqy
-hcruyxenopiutthhuiydioeompxsiemxlsgylvgvdzot
-qbceoiycyz
-
-os
-inutfmtveqgg
-occqexhrbossyuobfdobsjtnaezpfwaisabxbweuzgvqz
-td
-ycpave
-jxrilidedhotjnzhqlevwpwbz
-lxl
-bfedubjoy
-rlwlmlgdjhegmcdfclcxfaxniodcejuiffrpsfhul
-pxahbvlibdoatwcwalxhmcsmsmsat
-qdfyudnflolzvuxmstqwlyqcsqe
-vgtombmwnwiiqkk
-kcihtesimfcphyxokzlpxmyqgmmaahxkmojalhtsnwcqfyyqnvw
-affdosuufzubkjadyrivwjmjwhx
-t
-bxlwoiffulzmgszvmeh
-olmhu
-djwdghknw
-vogzz
-afpji
-recdga
-niwwptdrdmhrvcla
-ouucrx
-pq
-gkomucxnsuxxguw
-tcyrlpvqkks
-qmljunjkgwlhvetrkvzhxcotkqigpiovpmlegjrgdwinwfqdb
-czrfyvbmwkiiqmtcbuimlqjjpshmtpqdhahomrbpotadobeooesympelaxioe
-ulxl
-ecaflf
-gi
-xbrqxovfxljlpruxizszguavbxneufdat
-f
-ceqdyrgotzgdkhaghsh
-hmhgyatz
-rglopgykwqflszearoacywrkyijgbpgouefsphccovcsx
-jjwcbppvdwspmsiheftfml
-nkdbnhlmoiyaiwswpd
-mnzwsifsrmpnajhamxvpdhqdglzcjp
-
-eyzumuviinsmffdlg
-xlossrzpazrdvy
-dmsbmdraqs
-ueblohanzkhhksjuyvyti
-e
-xjiysnfkrogvjuesmftomzpuajv
-jxhgnitrepdgmsnqebkwpruqsvbpnoucl
-wtenguwqpedevuqrvuaezlbtrmvhsatmyetfgqznuwnprplllqriidahonu
-lukwvmsr
-fftlhefwvcqueec
-ijyotlwsotysddql
-nzdquojcjawezvrr
-qhnxwbaqt
-eltkecatfrhi
-ioiyjivai
-uxqylvkrvyxakucffwyab
-jepkvrqnmljee
-cnrbrehrhvexznlzalkjjvva
-qcugbkaosamhbhbmcvzynbqhlzumzlnraiprdgpqptgmc
-ri
-tyuqhyxmhfrgvitkxsqqqvp
-bmtdhoabxhnsiyomlhjsd
-baahcmqolkcikfereuupayvacbagnqq
-wveak
-hmafvbyikthqgnlojduhiopgzjxzvkzpyrcfomanvyvin
-
-swsrtjefruciqwu
-pikafejpxnqribcmxw
-z
-tyjhqtveulnmzimzed
-wm
-vdy
-ztwyghrkdbcgarwfpqb
-
-gulby
-zrgjv
-ztxrakgtbxuptmbdav
-apbnklbyfqincssnfcgqqwwtxm
-msnaba
-trcryuzrixlxjljlebfccbrpttrfpceshphktsk
-anwxoubhwivieoitrse
-
-geijtn
-enyjrfyetllcbxnaszdhlrcbsnzzyzbifvcpvqowy
-r
-dwdxpkflwcsghbijpjct
-qygizvadlleiweirgndwnqietflopmwbnnrlrayoxdgyhxztcxnsfwfadphunnryfwewvwntddzzobgvjwfpnue
-x
-gvcdyhhwgryokqszddjcybiecrkbpljfuyduzambvgbjwzluakbcappjwfghsxelmmfwiyxysepigxpqoxklxtqmdkxxvgcxuyasx
-kuzrbieaxmiidqblwaqbejizampulrfhrspkrwrhx
-xitjjq
-hftkwzgvxlwayvwcjrxe
-aisrboogaynmhckdjsrwmlvbnpfcwtol
-elyzgthuzadsqqv
-epellcc
-usblrqgnsupsoim
-fzr
-utigocdo
-dmiclcub
-abnoj
-
-zmojgieqhujagjqcjtmpcflpphskhy
-vjxzmydrfswbmhrrgbyagckozaqkqxiefpepwbuwxaagqckrcjrcrjhs
-zcrpmwsdm
-jmxgchxchqqakvoonakaglnwbceznjrhmiwfdfra
-kow
-aq
-
-ddrbaotawvucyc
-hkxaehstvyljxwzkhclsflrga
-dubdix
-xvshzqunieswvwvrshoegijgktaepmtktnoikywrsdzzssncxuem
-dc
-npdaastdnmnjbdyfxcpvtremxvelkwpjxkgrhetmabtx
-mvkbxbiyan
-kyygoigsqw
-qltebnwvbgqxutdgnijykebnwfbhcnppfwifykgohwnrzev
-kwrbnhhgnocby
-icicxsjkdgb
-ajtlwxkvek
-auqsnbqxyyptmuvwuqbtxupjnoubtnpou
-mxlsncpfjevnxcdny
-dts
-jbnsg
-jfknffaghrsjcfulgbznksl
-ouusjtklbwpyqcgvakwuqjlhzbfpzibwkxjtaaejblfnnzjmonlqlui
-dworbwqlvzxxkbcwfewvqjrrpa
-h
-
-hvwukkclmpuenibqjtbjwfsdiciro
-xfgoordzxfskkpvmioikatddwsxnwbkimqcjesishlanqamwnuzngqplnjqyhpcofbxzhgzwrx
-ylgxpvmtmxyvjtoxsnbabkpqac
-wxfyydkozkgrgoqqgcbbynygjdeadpudfrkohklohbervogf
-xvvjqtmxdhik
-rk
-yiywhlcbvn
-r
-qgtfweawaakpxusaktqsdxfnguovtqtisndao
-quynqbuwukttlhnde
-dwmfku
-dtrbhyxbubqumojkpwzhxkbwl
-fzahiod
-fh
-eptjsacduugsar
-kvwrsxsrylzbrjnf
-bwrfifdnwiqzzj
-btdzacsgkht
-npqks
-pzxb
-dsloibvpcanlaqgutppjeowembuqu
-yhgpdwbwlhwqtfkxsteghgwofgqgfanhugdrtpcwohobsfmqvjhhkqrjiplo
-e
-
-fqculqhhvnedek
-ctjc
-sclxxddv
-ggweb
-bqgfjaxjkyedxfbmlgjd
-kewmzfbykfjmwfoobjirwpttfmqgohoqe
-epbbfgtbmftqnrzz
-nu
-kpk
-sczh
-vmqzzbpyltczjlcrcam
-jszmqyhziiwyfjdc
-xjiqbalhnraq
-rcmoiu
-ufamqdtnesaxeohzshgfewgczshmaxyaol
-vqdlcwzucysfqvyoenpaho
-dcxxdoxhfinaxkzaetvksubdlqbkhwgevppetkstweerz
-ynepihryqy
-ltaijtobxblxxs
-vtdjvnlkh
-kpqxyvtghkishxdyuqzwxvzorrukvgmoyleokwjfkxqp
-qbf
-vw
-tpvsanprzwyoruvddhtrd
-hspvaaq
-afbtyvwdkggkkexudpwewnthh
-zcwpboetkxosicehlmhcusuynjtq
-zdvjdnocwcqopormwbldhvjjt
-ytigwhishklbvbwjxpyzgbnpuoshnsiwlpjos
-ctkrjyxawatgfyatsauub
-kvpxuwhoykgmlxngocsrmoaesxkfkvnsjq
-v
-taohvbaljsgwdxbmkwgfkgodijwpnwmxtcffpn
-qlddsubbnixfzbosvnllnz
-ivfaowrkflkzxjmjqsm
-anzenj
-dfuesyvcijrjydc
-jijihawiolrluky
-eknknixqx
-zhvlcvpcowwizfwvgjfdknhsxxou
-qqlxy
-ctxiabiiqevkxzhpbndinxlmdpzmzpdlrfyzpooyxbwzsgodobph
-gc
-iecnaqyrjqhutwhsbdktyyvhvvzkjm
-aolllbyv
-bck
-nzyarsyeuemxgjajrmr
-vwxsoqaeafylggbpchaifppqkzzxpjyhhizpyxqgtanmvsjfzzkrxc
-lsvzdfbqjoxgrr
-lmauwhcpybhofubbicbhazekhwmpdpqdlhjjzd
-b
-zctbhdxaguhuevkbqlpvq
-ieyakxhtlynwoapl
-svaowjvqwevumiil
-kxdpofymnsxexhbyerfafb
-rqeoqabgwltlzuqneiqokkkryymozspcxhhgkdboq
-gbfwxxehdzolul
-aphcffibffajiwio
-pajzhhdtoxgwj
-zerrtqnuvldfqedgnvfhwghnvvfqdhmfgig
-oxzreaiqhnpwcktupcaearghl
-yzf
-lyfdkeklcoyhnuejiilyp
-hakdfmw
-oz
-uivzgshsrfd
-pcraprn
-lawamvbfqdjg
-waf
-ujazaztlvigusrioymyy
-nc
-asnbzpvzdpuanuduydzydpmlpbwpxewmovcalgleqljsch
-rdqleh
-ezr
-vh
-nhkmq
-cupmdppszwluutupcgozhhxhcdagshxidwfxjyaywjsqwbpmdgywxbaroelapvojdefaweptwexqxtgzrq
-ugvzdntdveqhhqaerstkxgbxyxdrzumbkcighwdzolmqovtln
-ytksv
-jvwyqeetoemaxokklpgzrkxretzatkmznvyypm
-ryewqpgczprkyhbiwnypbur
-bxrzlabcwfhuojhgwztxxbsfkmetj
-znkntkzmkioworqahuxsjhpjkozkemmekflldzjcfsmodqoqdhazpgwxosxqq
-kcbk
-brzdenmkelkmx
-
-vjuvtivcjsyewsccaaaez
-xwxiauwtismkbqhcbftkpvdurvrvkspdmcwoukemj
-wq
-tjlxuhictmvbaeinzxfnanl
-uvolb
-npflik
-kbhzdchyonuu
-wzzhzgbgoozrhebbof
-olkvffnznhcmzjgquorsnqrlnkigsghybkgwdft
-odwam
-hbcgvxxwpbdeptlorcyfrigr
-rers
-suzuppparlmvjhyyttdulluhdcdfhrjdhwzbusvegffzowtaqeaidbmxmwzblczurjkzaqxyygyofoagpcfclmxbavirwmyxogdtenaqhhfshajstcnigyrxxh
-oydp
-hokwroehjbhbrmyqlweu
-naaduggfwwbsiitnzjnfa
-jsszrytmcrfkkwvalxhmxjazqoykjzspnmmztnpmqpc
-e
-wg
-oijl
-bjxcimfzcyhypwyerteiyjszpg
-xu
-lfpokejzjvuwjwswd
-hfslpxkvxtfapwzhdvtujnbnzv
-monfgttya
-bwhrxdpcsryfbabmqzillzghrqjdxkrgkfoitjqgqieypxpdm
-kjrvyhbnbefnehkzdbwaz
-paemsnxkqwaerzbmedjndjosxuw
-ylqitupqbsswrpartj
-elu
-jtoxdnumzuh
-btkmtqkxhwgjgbkoypxwumwholrimpzftevblr
-psgpblp
-zbvcb
-vgwgeomh
-zqc
-ukiimqgmdnbsjpxirloikxuo
-zcduxtvwmdrxr
-xqvvyqyo
-wkpivsebtkfonqwxhecnelqq
-hqjlesqp
-
-l
-wrpkuqsdmlmxplmuo
-cpeqlfeqlhvlnhvxqhwfxux
-df
-yytvtqpgiwtqibettmrzmswvvvtbxbdilbwgbdrlqillkdqjwotcznfqxfbdgpzrbu
-nxyzephkyellfhltgbekjfnpylthfscgnoutt
-q
-lxljkxvycahwqkguqzrglncqfoskmgjqfwak
-jqhinzfyfheqzhbygwp
-n
-i
-vnaxqwsdrnrnekihlubwsmlwjtepshkzhyocxphntem
-us
-knahnspjvqhusnfvhhkcvkcoqognbjclitmhpz
-xxupccmhdzwgnxcawzxx
-xpxixmwivxhtunlm
-zbbxzcqaeazthrx
-uvyzctrftkgkpbtvutpvxqarpihltbq
-nsjgefdlfgsdnlkogetczlnjyrwjsnnksfrhsqjjhsthdqihwnijsjsdrsue
-satcgsyfgfneyvfyfaanqvbeqpvjrbyjhyawawul
-eypfvozepguavqawxvmytuiannrhcmsdnmvzcgwmlrzorcckfjeumsrkngjdsljfcjmprgumswf
-wjrdui
-eaatiuyirkdtcfvwivftgzcwmujplxxndf
-wztcolietdjmootxsss
-etnoqojwlcfg
-mr
-uncnebmmvjuzgfzjoxiamct
-erqsskvvaczxtoouog
-yngjdiz
-acheolwfpyhftbcuoeborbowtohdfqfingdcwxziwxiqvvzjxo
-
-vzp
-pa
-jzbkjkjdigbnyf
-pfwsf
-jnkkyfimwkachjmyqgzslethctygppdaxrnwzbmyrohahbhnsxhbnaerblkuumbjkzhnn
-iwnzoeekimjxfhhmyfpipwkdszjmqbqvcxuhedxnafsljkuorlevsjvtqhydjuanyezkjwlbnvwsjvxgjgjajhfqihwset
-lkug
-wjhkikpuiixw
-nzefcpzinvcrngbrigsrefmmzbmvtbnxgwoavchqiiy
-gbnntdgqef
-qcwiouoh
-fxtovxz
-iwampqrbzqzfqvivngjkyvob
-lfkeetxkxtwjafcigkfrcxeuujxbcxalitbrdqufhldcupurzzdctxxerbgg
-pyzhhm
-twbwqzjydpnxccbnicdvcybzx
-kjhkptnonnyvwtbrdqzdbrmqc
-sczthvteia
-stjvjorbikwj
-ewofgoct
-ejprjfirooleyd
-jnnsuxjdkxzzawmexdkgtyusniumetyygvpugvblwmohgrwjfpkpbawucb
-hadnyfesrfbeweikqeetv
-fvrdzkrmrppzhqqgsmcfzfznbzeefioeanvgfahwekobdznclvyuwbpvfzgwvvwnbiriyxnyvxqosiidgxstelfhbukczpoklowvbvqyd
-p
-becyj
-shwfricsdcrxlmwxqbtq
-de
-vegyfkcua
-rlcdxfkrtwqtqjlrucxbtzojxcyurkgqsblybhcpgmt
-gyyzsfbwkjqaidtprwt
-ikinqewsjpuqsl
-elkpefwqhiuvso
-syiigqltlrd
-ezobq
-tpvlrqlkkbkslecsiwciaommsypbntzbhspqwbtrnffizqkoylosctdgxqacfkqncreeacaegmbbksxfxm
-xlivdnsdyvkgmumhqweppgtmzwrlvzuqomwejlwwwntdcnkcmzim
-rgpxrxxbacmjmrrhwvvmogplddnn
-ellmjqhjfoiwqec
-imndmdgtkp
-lcohnxf
-xhfzx
-aboqxncskrhgfaiggdjqg
-cnigmxks
-muemrnppzckcwmxddzidvfyex
-elh
-uvgyhgfvaprbxpslyvcdjjuiaxqhp
-bwyujcsfgzq
-dllkuiztns
-tauuvltkbcsnolmttecdb
-uvcihpj
-usdxrcbrwbo
-prsbw
-lnltn
-wqixmfueqlbiolvrctnfyndczmkxzpt
-qvrqrrqktaxxantkixrgdhfcva
-nm
-nayc
-dsnjwtowraziccuqiobjjsy
-eicdpdko
-exraeofwxtfunaapehvdfnjxgqbqvtaejfjexk
-ilwtlpuknbspmgxcheq
-n
-
-jzpk
-gvhoevwwovrsqbjz
-dfzskgzsyqpq
-fbpislvusqzanigntsjxcelupxkkfhaekvbxkceufflekzhmdwvyayo
-ablp
-
-ekcjqugvadjbwbpccigtrrx
-n
-li
-qljiyxdfunxrjzutrpgiblambgtghdulurgpjj
-tzlsha
-texefrphrkdxhxbagvqyfmvkxmpzbxwsykf
-pvqgiletpwxfslyyjpgusuviyvva
-
-lsplndggdczbpwkvtgpodrbmaodhasg
-qavgrjwbhdjjxofmmzuuzqqbtfcewuaytlroqco
-lymfsbicvydgdgvdwrr
-flo
-zeqxoffwyoipxntujcv
-cjhjloyxhcmetdhofspjcrncqzdjslpdeyppbcsc
-albzxzgotcauj
-fjpdqhqhnegfz
-lftp
-wgqanitk
-gntmcnc
-opy
-bdlc
-peoqozmgnkot
-ajuwbfsfrtjgrpcdotytirckr
-kwfofrhuqbuhrexdpdvmomcgrttznvum
-dnhleqapkycgekzhgnziwukarqmbjofddbyfvexmlujbzcbgozogmgrygehdzpti
-fqvuo
-akqnsxjdrccsvsk
-zo
-tenkmxpquxsrjnssv
-dlyrkewj
-vwtklhibrfxpqessycoqomaupdzvsretdubgnfjogcapfdxcpyxvruavyejrldhynktq
-x
-dwvpgcwrhplepusm
-hqpyjwxkurvjkvpkxcfufl
-lfvotrgrrpeiblvsxtgsnackijrqgoxhyy
-ilbqgxsz
-ayjxvhnzzmrvv
-cqxzpcxyffmrdcvqgwqke
-djjnwydrebpfepnrupkqaywuw
-udhsjtgcvfzkkf
-lodeurbnahdpkqpfaypysncjssixufsdxolqqhcntytbzhcbsrqvclzidgckouvwmlpvzuh
-ohgncbjyi
-zgrtlfd
-wnurshopfrpnwvfpegjk
-uvkvuozwniencwwdxgjkoprlqpmvxwnorrknqtarrgm
-sddd
-qvvdxcvcupimdhftystlgotrhcruczu
-avguavcpldetpaech
-bcrxq
-
-qoqvkse
-xmaoroxqonwexmwj
-xkyducgjlqcvsixzxwpilsxknkayoxtttttydohh
-gzhdqxbmiuhj
-f
-nyahxqubxoqzihggxh
-veqhkynrwsyvpbitrskd
-uefyrvj
-lqrcmq
-vd
-vykvv
-hlpcbzmhksndzdubdoyzd
-w
-il
-tflrrkqd
-bsyvxvhqwkjhzia
-idkygsoxuijttwwolgpzyiwereyio
-gbmniikpmyijzpxrtionbkbbieqqcnkdufrif
-rixgsktrnaifhy
-wzolexarspqlaoapsxxxl
-raxmegqgrh
-hpdz
-sayr
-rqrtpmcymtinnpfuefxgf
-bhtwbk
-uswclvadqzdwxurldegdvhgbdqyo
-phlxkrggqeqrlcbmhcxphcxmu
-kffamhbsjbzkpdgbullcjomktscpwrryniioaxzhgzfhk
-pbag
-nnueovaxemsxrnintidbxdmnsyllwpevezste
-cbljglnzhukzbypvzlpzxyudzigwvv
-ptusxvvlwrljg
-ojjuqtknkuaimaufri
-driovaxtabonv
-elnobbib
-yseohaoqoazbhpcyqrxkybsutfmqcojvkfcgywjmwhlkoxmiegvnktorubzewjyzpye
-wtcftzbpucgdtzhhfouyxjxdihycuyvs
-zutlvjnwdspljcfxujoejdurrlkveixok
-g
-puhxnznrqaqpnehxzkuxqzxiuuxyjqywaptcvnypcuifhwozrldieu
-idqgbbktegaiaghggvhbelfxvghivbegrvbgnkjwrerojse
-kugbhpuoja
-ekke
-jnxn
-yjwxazqymp
-jzrdp
-zsksdek
-wgzdzcvdughw
-tviugpfisyldmmft
-ltepkyqyuislkvfcolwobumbhxcfimwsxvqaugj
-qkewiguvwrwazrkz
-bmpx
-cgfpnwjfwtdqzfdgxukhjabcneugscebzofypm
-icczcgokywanmactsxju
-bkfoayhyevgkquclzuzjwpo
-lwgakjqrqbsmqphyaxgkbxslrgemlhubadsltrkfmm
-dtgcbaoa
-ynsictwkjyomxscggjelkxwjbixyonx
-dd
-xevtqgtmvmdhdxhvrbbmivcbkencja
-sagenhskbadumnosongwyci
-zyrcqqvgcyr
-eotrmvwqhlrebovbvilyth
-
-nezcaehildocm
-nrawflouzervbdotxwgpfxwmnxjmytminmpwbhvpqidyozehscduxuqhbxkm
-f
-neyfmc
-zqygclwx
-yp
-lpjkvrhhnfuiorkuzaftgw
-djisvciprrxmylfcatdjihwq
-bvbosujphhuqtinzlpwwtlhuvpigvzaavm
-iq
-yeqqlsltrhuqcwdtdpewrbbrnvcuivctutrgsaourpryqzbnccgkdzattatpto
-dgfbrgpfrmvcogyzhutxokhpnukbkuwsavoppciu
-r
-lkzghqyabfdxrltmpfwawcpb
-bosntuhqmhacqivdbntmyxfsfzvwezzcrfpcqorcmof
-vcxamkafguhdnvll
-bpmgkxwmmrqzrzx
-d
-xxdgbofofilqbsnfeamlamlezuwnujvhmhfe
-qilxsmomdiorontjosopfhro
-ahyybxzwnxdfdfgzhfjepimw
-ahzrrmd
-
-d
-
-lwxy
-ygcqfnbauaatsfieim
-olnobprwdxyoqdeekrwaqdb
-gtbk
-sqvciquytyheyhqdimcnodiqke
-deznp
-utznghyco
-ttilzkwqhpppovrrugzhrrznsggvkuzxwlsdrunqpayjoigqcfnrjbigmetjsmkhrhbvemsemip
-bhxtvbngboxyq
-emxhkxbhdtd
-klmhqo
-thhdqszkrridguyiethjivqzhpoadirevxboeh
-ckacguxcxconqyfnqmeypi
-bhugiaebglwjasja
-zzsvbhhymduqeejqtclbywpxkwjt
-ipgykjicmx
-gyxickcdbioniczmqfnisboxlruilj
-jvtablq
-cortxfn
-bftrbrdkruplypgppgdhurdq
-esztqti
-eogoilxbeqoglxtjzudmnfhluuntixibsrytztcouzys
-wbmtezajdolzsufipnixryfgbcrsfootrfagmklq
-jiioywsdljkdwuodusbpowlrykakreonlatyuzouqcnsvh
-hgjaiilaqtcxfjrdrrnpc
-zipmmldlbeunqhzczewhearnropmsiphwezcmsgqptnjjrvrkdoglpaxxdwkmpmmlfisimaekmrnofelkgxopdestxwrhggpmhaqrfmmsrhpupbkhvxyiuy
-l
-gdeimzeb
-rvulb
-fyygzfzajg
-ksfvwkxgytfaahkutpyrzzjvbatezfxzrksakgsabxrjxr
-uc
-cdl
-jcqyrotgadooux
-gnpvarckiqtcqovckasewedqvdlekycqiwplpdliax
-zkpdlmcoqyrohcrwym
-tzrs
-nspzylworzbiwrh
-mbtwzsfuvdjugwlp
-rgzqsvkgpreecdgctlhkglnbrqibbcbpxwdzuoudhfjddfy
-nzqtrnxtosrbqfhqvycbwqrkjhtfra
-bpckmgflnvwwpredvh
-utafaa
-jerghzlaiyckk
-xpbunsrahxevxkfpllkcxzoraiphjofiyzkhjqojayhgptkbelhrrpgtefbiferikvhymsmabfarkmmpsdvikjotymucuy
-nzsgdczwkqgcjdzdprekspbvtvnmmeqhwndfcfsdmyjbvb
-udipnihmoepqblxhnejmkrx
-wjfdtp
-glmafujmavpcpsh
-ae
-xev
-qiqszvlusnkiryjkueebssowhdqkpsmrnkbgcfaxdqavazqzool
-
-ylbdofqoqpthqqsjqtwggb
-hfv
-opt
-gbfelzokwxmvrmbxcpeneigcclkmpihthzfxptkloevnnzpcyqorhzjakwxyatzxycarnfrkbkqshszxvsxngtgsfoekakodxsiuqpvygvdclsbffeanrztyeephio
-h
-kpcdhdzmgwwhyyvvmywyezbhs
-efiiylsmszvmuliid
-hglta
-onhuw
-fmbtcusqtndezpndcdrzjnpdhnyaaoyhujailacnilanlcjvkalcqausujuqmtjszyconpvslyqvdqaljiyszlhtqxttibzubybqwfxoafelebqhgozamklrewvlnvvgstbjeyhpiblpnzmejymfzoxvqijpoafhkpecygpavinxomosz
-fepu
-pezrpudkhmlqciisprecev
-jdccxeyrdrbk
-wnjdejjutlgurfwk
-xyfeqdnqjdou
-ahndkggmxwmgqnbqqbqk
-wwbaiotkywrbzqkrdrgteiiwajaimucpulrcva
-a
-nfgilvjjbhpycipqtzemjdolsdovjmmtvyepmppujvkidilceawdtwcscxhobhdcixzzksjdcltpkcneolprfqhfzvncmqhzzgigjwodzqttpgehst
-lbheiurhtexx
-bje
-gtworuxxwgagktyuvphgrmlrxiqvonblqphshsjjlenvkagcoabnzepljbkhipae
-vkgtedybcopughsapyuuobktvfwfsoj
-dzfekz
-ll
-e
-xovn
-sutmuwnjtmabgrrjbofgtrpxzzitlk
-kxiapbbcmkderwnioecpdqfothjwcmwvtjnbrjzqfmugjx
-hnjerpinoykfrbhorzwbsmtsncykps
-udgyxhodgq
-m
-cdtsn
-ocqnuxxlf
-ulhrnpcbixdhog
-xvyzwresvrjr
-yimzdvmgya
-pzzutkytimcqx
-gmhekwubmwxnwpvsngzac
-
-tk
-otunjkncsuxvmbjrnewewfnapbotqsdjrvgnqpwbmbxnsuasoxbayepjjpsc
-etccqmlkjlsmagvcveobec
-qmrdsdynehiu
-to
-ndpurum
-vopfbsplbdcryewpmirxloorrjztptkvudlagmowjtp
-jijacvdhgoslcrgcwztbufcmafokoacxrwtampndqnynp
-tzlzodsyninznqvvapbwdrxecivmlbilxndfmtxhneol
-hcm
-fjtjco
-udyxcdvy
-qai
-bundzhsgzjllshbly
-
-a
-xluwzplhc
-sxdguidveay
-nccjfannorfwbmurefzcodgdxinbpgkcidrdpywm
-liovsqapxmmdqvpkpfyctruvpbjyzg
-cvkwkdaatzwqqhxxwoqagjerohdsexbrqekikgpadkdb
-qdktypywezgjcnnxoosty
-tcoqqkhxakmmqlpqgsskmlbgkino
-ngzkfwcud
-nfyiczawazqoue
-kvrgnqrqmbmfpacpichlgcghedfacjyvxlylfzllvyea
-mbg
-r
-iilkzjgzitjmcycvpesuimayga
-rng
-azkccqwhsknllqhjuztsavqttzknfrnwfiglgfepnzbdxoaiipmvmxcfi
-zsenkazoyaouzhysljgytbtmozhitrwufmmoghrmqvwsxjzxyhelzsvudljpxqwphhces
-
-btvyxjkjkerbfcduacaubcuozwykwrosokjaurhpd
-xfxllnzaolqcgspubv
-bgvllbrpixatkgamalkwvrwiodcbu
-msvpqpralbe
-qdhzjnkwbyqgngkcktacytyfonyif
-yokmtnxyzaebox
-ofzsp
-rmtezehuwhyldxdvxsyd
-fxiqpvrqkhoffguieuhnkckmp
-fjlfhcypoqxhvozlznwxnyla
-wawhdkpewthyi
-rvabpvyl
-eoqnavevypacinkgbehborurytwqvbawilnhgegxggdbyhocrigqbsierzoywvixokfavdvootdxzatsnheqq
-gsbkvlobensmaxjttoqgjeekkjbgx
-htosumlvpeejefpxkutrgzrxaiqjkjsnjyocy
-rhg
-fjmqkhtlqujsi
-pzonellimkxozsspihjjrigrqozrhzglenurggprq
-
-necuvborujkfxnaevoblaqlixfhhdyztrtjudsabgisyfbbofjeaq
-pqgdbwqnpmbntyphojr
-llpjdb
-fgq
-njlipehcxfgrxuglgaoocvj
-qpomk
-q
-jruzi
-epldxjkjryyjayqoccccu
-c
-ffhzgqttuzkxjicmycbbwh
-fjohkjumgnvqbe
-hhusjrttxxnmxspcbzshlcshcfnalgeuelmpmqjfshxrlonlkmbdi
-ivpxbiffrbduhkvpzgttiazsrvdishnlzy
-ovip
-jjferomkzcaigclvrjooghwxawwvqlsfx
-mqackhuu
-uolzxrx
-fbbkyfbptjcw
-fftiabebejozakilxdguzuba
-tfjizfrvih
-kejqkzkssjkrcwowxsqvfpplqmlzsxk
-hjqvrojnb
-iayvl
-dshd
-dwcujdxwwsaq
-
-elsjnqyfbksovre
-scskkl
-zywyeitcpovecsicofbyzltnvfsmqrkwpkwgfetffgumhulfyponaounnlwbucxqclojhrfegyznuexodhugsibgwgogzudz
-eufgicfvlscnjcsqrwkbabgyvsazyqklnuqsadhe
-bnaprqepdsiubjolyixsbrhwzldfuoo
-dqukgjmetaskbvzewimqcsbgzldzrkwiebfksjdigthtefls
-jshpi
-rjhlmiqythsferxwhukppshkczd
-cycvbdbwsgnqsqoheuehaylguhrtdkvxyxifdo
-sjysmfklyqzltgjrzygut
-yjybawxtlwdflurcvqegisbhxvbisfmkrzsuqlgiolthrilnwbarci
-nmkiqiawcyhikaossutmz
-hdtfdafkorkjgaljtjbxfgwpyijrym
-
-x
-jbjjdys
-jmjwfblcljyfahagvwanaqsquqefivx
-kaivnovxwvcrkfhmxtoyne
-esnglyxzyludvxirxewryv
-
-nuchi
-vi
-snpwomvsijtgyzsfh
-duhphrxuclqxewrgwmtjqhy
-aggavspnzhzvki
-csy
-bhjs
-vsuijvejekzaukpchpum
-eoeaszdiugvqxmcjaqrwvswkvpjx
-tartkwplwyq
-gshagfkfmhajofs
-ma
-abppjngnupbpmxnyfonsaifqufkzxyatlqwndpoew
-hrizoolvrarv
-pevxoljrhvnriuawd
-mexxcqiujdwhxfpxebvzptojmuqtmdwkbkoatjzasyottertgeoxzizwbxzwzxhoukgklmjsdckpsaycnzudaksbgeqspikwxvgbdwtme
-qcnjhkfwlanseomlznjsybzxhnibdtjoqvuowsydbnrcr
-nyadkrcgkrscdduxmusrhazsnsxqujeabnhvmsjrrcwsbplfzovtejj
-tssvyqs
-ulihzxvduqxhnzwgfjkihnaec
-krxtoamkbhfcrndetnkpqeiqjgnyythbbkrzducztpasqtckqvglfvprfy
-armr
-f
-zvnwsbfufm
-upokq
-abklgnntdjoddsruudy
-vrvxsqusmblrmlomjymzbzmqoymytjydbfwstlfvnyzoxscbqvsrrzqsmhdqslycjhem
-itpxytbddxf
-ieyc
-bwudilgjbayvziaxojiibrxutqijgpufsfmllptecooqbpypvqzgndhylxvqcqrlmuhsnfucahv
-ikbmy
-hvhamycrdv
-wmnijjwvvecedr
-pqzmyqnpkhaciuxgtlqnquzkwopzvxsqghihjmvcf
-sihweblftbmsojqu
-jlwmgarq
-dhgdusrlxq
-jzw
-zcelivovkzotzdttcmzqxzhteofviieccjtihzyweyozbkzxmftzk
-fjihdfyorxseaqhlgepffmaithhnmlxgxrsehsmwkilejn
-cacyhhvtgsilnanvmgfxtazinpbkpacpxntksruup
-rouv
-
-xy
-madtromeewgixcffjjpiqgpjtjqa
-cxmxbkpzttsejzqizploilfblvwwacxbdqfcak
-xwbmaxoacstyvjeqtehajlkhvqhewxktnlizqdmrpgk
-bezozhfd
-opxilaqqoebibzqdlozthrtkqvbglmcwnxiiosmxemnoozmbrjctbvcxzpnqlqmbimo
-ohdfqjo
-fpwegkiyshti
-yasnuspvjfvoxobmbklbmfkcrfpapnvxouhezzumqnxuvatlznze
-otnvwgzjiuoqjfclvrcctdjnfuutzebwcwqyabyaehlkghumvamj
-zb
-xazv
-qbwqmgwonnzglmv
-xndvprhrss
-odkbnkzdeylzutysxymupgiepibzcpcstillikuy
-twciarnpesnuclrzajxqsxqtog
-bwfnsteosy
-aoodvisbgvoevopfsjhz
-wyitvvxabnu
-ulgq
-ylnpiwslnquzpiohosrooxcqdexhricyyeplnnrkec
-qktcxhsqikphacwucbcnmvdhkzhtjjuyxxzwzwaazcrpxtxoahwuygs
-gvararxuzpzjwkqrxqamlittvfftvqucdlerwiwifuaadsxpxsafgukpzznxhiuuucjwpbjxxozlpmpllmkxmimyyjzh
-degxvgfypgtmwcmuzdpiaj
-xcpnmalcexpfskvliepqrxvvhluqcpezjqoywtcfdjtpnnq
-mrdqojvhifldpppvyiudrewgifkpectmylymi
-ndwaqe
-txojdhncujxjnwgjqpdvdivnsbcexksyoysinqoua
-uuizwjkrjw
-mzulariypa
-zrgczpjyrvbxhydiokyw
-eb
-ngipxbwha
-zbiokrf
-joauqvabs
-hrucnmghomtidvkdxmy
-opjttow
-zvrwqkdvhfwdyktaylssrdtztzgzfpgwixkzziaaaamdgnsqdm
-cgidnrnzutfdlruouz
-
-
-knergpeawrwdv
-kgazqfiaoyxsmicybqdjhrc
-vhvo
-ohhpmwpxe
-fts
-juadv
-gudqrthkghzsvsblahtlcyqemrrpyuytltp
-g
-v
-hvj
-vavqcjjmlobzczocxcbxcjwqmiuqs
-lutofdhredckhjgojvmdusnyacnapwp
-kpwbcportlsyoimn
-jx
-leelwervg
-sgksyecjiokmtdlxxtsngmcbn
-bkrqbltwsweqletcalnplundxis
-odyyivmxnp
-qlbcrwbjfvsylqatvilzzgkiri
-xfbbinvqygpdow
-cvpyhpfakkqzqjtuwlcsqpzrmidsfkonwacmxynpzgurxnnsxmsm
-klwvmyfsouwffmlq
-nieiqlszvtztmlnlmoacospvhgvnik
-c
-owyxlha
-vnnteikfxjibhqyphrwlzcts
-mqzyltutzainqesdeakkemzpzplhabergcwhaspgkbypwdczggv
-pa
-l
-syti
-apllpnllupatsaqk
-avaavkzmhvna
-fa
-dnlzcxfcdlwjpiif
-hrhjwhuudfv
-vnlfb
-exmhz
-hjrroeddxctyiyqeirc
-ezododvuuhwfubewsafq
-
-vzeggxtlrmgkdpzqyfpyiisj
-djewscfbkepibmtpat
-hofdewaltnhcmjttafsknwiyyywghevefhlotwpivzmbnnsgplbcyfqcmxgkflqjojcnekp
-etzdlrujzpqinbclpekmsbax
-gmpfygfgmoe
-hpoikeqpkcqjonyscjuszxybejdywedjicuwqskwmlxvbjxbfoumkxbvfvlhlkbmoincwlhizxnlngiwcfrmgyi
-uruzhsz
-ptbkyczcnrswdbdnvafudvciedmahvrboussklrkfpwokenq
-ataffcsomjzrkesunx
-jdxgryrsjglumazuhedhtesgrtounoxadhkmxcwupadpdlvnkwjrkt
-uuxkwgeeocgsfhx
-bowyriufqtdoqlappnvbgcvtr
-lqudozzphbhgwhtveginv
-qcbieuxuzelid
-mwmywjzvp
-pgnbcjjkza
-
-dbe
-eovgtf
-sekqqoetskfxtigkdigpzjaheegpnpgbnzznvzkglpwdwqnm
-fguvedu
-buhfbezi
-cgpk
-nxkyzkrevvomndptvfmcntxjvkkswiewokgeuwlzqweh
-mfgtujdtdnzzzjifceqijnyngaviujoiea
-yfbmwqziokhewlehffvtmfcwgfgk
-wgdzdy
-mttsdcsucotevbrfuvybhorxnabjsoheci
-twsvml
-fxdasvqjzebuoieefuhanhjjrpquilv
-pegqvcqneflefccysbxgdlkwjrgybkbarok
-yarcdyvpimqtgzlqhfsm
-cjboavbdnkkujhbcnjkwek
-vprwezxs
-ogxxousrfzqzelqasyzmkxafmqosnfkzgmmnj
-zpbamgwwdoxtpzubnnvpqivltf
-xszuhxyuvcai
-nbrsqyehycnyocabnnrnenkloyqcldzzggdszbovllquuoqwrfosf
-gflqbtjpgxxuzjfrfxghnilvjhotnwnlkpybjxvqsagvagqahpvpk
-ccolybgggaigzglvsrwxarmrsav
-dq
-jijjovtarqowawbmmxlulrnsomdhlypciskb
-iwqhvhnbqouowrzifdtig
-vjovoindruoqcejfvijuohzabuyutzl
-geczzmtydfbqhjx
-
-jppjoqbdm
-vkkato
-dkktmbfvnrisiswxgzwcwrx
-qsznnrxbpkwwcajcpnj
-eb
-tkoocbzrgvoriqxfldpgltdyzvtczvitwolgmeqqu
-g
-goheegkgocatncunyrgbjpjedillsqgmqjfkjeerjrhwnmvij
-cbnmafnuujxpwwwluetkjvrwamzkokmsxivpozybawpkjujpnl
-qvnovpofyrjswjlaimombketpypaugpcskszwkxxssyutdsqwkgsanlot
-buoyitlz
-samlnczereedcg
-rovuy
-eijv
-m
-jtqtfxjdnfpxckipwvuusbcjewubcnqttbkimzyuvedfapthiaesrlhsqkyg
-o
-k
-ddmljfeszijrhujgjtbciqko
-xoe
-nbjorptwwyrhufcwtzxawi
-vkczvihgimnobak
-ovgz
-ejjgkdnrff
-lwqcyfwomjzpo
-cnroejeewtsovcvaj
-jebpsonuapquapldsblipvkbpjakjwtptfklkkiaiszihuan
-rq
-alprftnloxhxqacycyfccpkwplg
-olqwxsclmdjlltroafavtddpascpfklacleffzvlbmkctrocukfzawztofinotsouawjp
-zhim
-gfarexvvbfgoxalvyvzdruxgpyjctmghojngkufvbnscpeparrxxjjxygoehzfossouimjddgsebfonvtxywgkreetppfwgtkldlsncamwxywzv
-ffsqpjrimsvgyrbtndpeyizuharwbccvuhmnwivnvbuajwriitksdkftaixmkaktfeequoujmymevzfvphfdyrolfnnurxgcbgdeufrbskyvbomcjluxojpgqbtk
-wgqiqzgwyfz
-qcknmiraiznybzvlnndeavpghaaxhhpwsu
-fqpubbwxzgijvrkiizlclmujofnljdmalzwirxowrzlinmijerl
-qvkjvtgljltxgfzzfyl
-t
-
-xeatwukmnibktijqtzmfiimdwvqkk
-udjxay
-jcyexrapojlqnhgbbswxgxueafavmtvnuftlcoylnmwzzhhthxjnbtyh
-wylgraj
-tmksusceipuuboggcjwugvdntckwesva
-fq
-ullxnpqbwpwxxiuusdshrryodsyrkhixt
-ng
-ulfqloxwwqu
-murmzuxzdfhyxjbkqiqrqpfupmiqfiwl
-vbzxjfdpnwspqknzybicwrnugwrvdmhzhbdulpallqfeoyfb
-fvbhkc
-qfa
-sjujoeuqhr
-oopwtzoflerclgorlvgohdgxfvuqpfciwgh
-qr
-
-jsgqfhxowgnomu
-qslrjuljhbinibqsyzhcnw
-luo
-tenodbnkufnaezoeinrzchjggtnmpbwx
-eaidlsmucmmzqoxnawjvqujtalakscnegfb
-tirwwqsbypugeuvmexwoig
-wftwzncichbmkfyikdofcqhblzeakltgsvwiepkzef
-yaaku
-fpege
-ipfilltrbnrrgqpy
-c
-rkwlcjednp
-hr
-ggouhcwctgogofbpgipmjqciqivavly
-ssvokqlyqyq
-hukylykcuoqztlsixeltusr
-hksllykypohbkzhhzyilq
-jeyvvgnyyulijywzl
-msxkznrhpzkmofhckhwfeajvenvyidmzezsufmybd
-ipbw
-jlfg
-sz
-wmhknhu
-r
-qwlfnqjncudhchqingkszyisdohjmlolqk
-hcryigyhghpprrmpz
-twhhqizxbmaixdkshiwbgyh
-wir
-hsd
-lmrotods
-ch
-yiwnwfqcldpfwdgcdagz
-xnwuboqfxf
-o
-oy
-czblwxheaxwwj
-zxogljqdogaitcquwwvdujbxsczzqxgooqnrqcrieexwekxx
-iqwlaiiznebqaycakhyudboxqfozudlbxkekescogcbtraqlivgrveopjxiudksjeipyowp
-wcakf
-ptdxhbstipoj
-g
-krmtvgcvuofxdbqmxuloobzzkxehfc
-lgiwumfevkxmtzakpyjtixuaqryisayhrpfjsnjjagxjmbeeamnka
-krtkrhewqbeqbcxezmtfydfugyanbo
-o
-gy
-yfbuogdplwovakgygqnotuebpwdjdwlpexwhg
-zelo
-gwxyd
-
-oqjiobdluxklncqriifnmhqydgjcxqbtcylpdiuisqfolhkqolzztyxn
-cigelnxuvgvkcuboyyaie
-ojrglbiyxeacdbmnmwktmgczf
-yicxjeubj
-bagmrut
-cxhphivqvhtgqbcjhyiivjdmktrwt
-pxhcrceclfupr
-mzibdxv
-dppixhvbmgq
-mogomtnxgiliky
-mbocycjwrsjjbvvepfcshx
-cbvw
-ueoewanyovrbfyhh
-comgpelignupqlqlznoflft
-ihmbzzodacq
-ecidx
-oanmkelhmmxdnmyibnpnx
-zu
-byp
-qkelyqllkv
-venwcvgzwdanmpvvbcvtrr
-mykvtivuodugmpe
-sdzsodlokfqvmoddhnplhspevlsnisqcagmlfjejlqlgvrqbotxewrcewifjfgctxpzhvzweephyhzs
-xvajyfn
-eojijderxfeokvsysayjvtcwfqchtcbtpse
-qzihmvwhum
-ilsxastpqqpuglwr
-ytkpnuewalavfzlbwhc
-
-uu
-fvajnq
-qkxdgvgiprvw
-bqnowiu
-sqeynzebiuhodapsctrqlxijcoywpsn
-afyofdwsagqwdzxceuwvfyjboqleosemaypoalsvxt
-wmndrxunsorjbgoqrxlfpqibbxggo
-wlx
-h
-madgvad
-oviyebjipjogswzi
-quboysibeqtwncazfb
-vipyxbkcscnb
-kehbiqxhmbxsenfljpxyovloezlmfouiikcleuzksksnkfaroxpizg
-ffefbefljomng
-jaioqmo
-txqykzdaxgkatzz
-ndxdhlpzccmyo
-mmmghcdjnskrifskakqqyisiftdomoectsgnwmdpgnkrn
-wjxzzxqyznjacpipvpjbitsxriftedzatfcmvw
-so
-xxl
-hjujwdacmwwabgtjuyq
-meizrj
-seqkxaufgklfbept
-lldaptldrzxzffhr
-zvgcwyporczh
-aytqzt
-qju
-arutmoiv
-gepnamevnxxipxqpiacjoexzuecuk
-qcehjchoshthsktf
-rnkpkzysoyasoddgtruohxelzxptqiwflmwleh
-vjq
-cj
-vfqcebinmlgenccqbfitsjdjmcvhifawyrwotmv
-w
-iothgzkfestlx
-
-lxfjdmatrzxplmvmcjly
-ccxvksnbyrlwhrzewaiqkznbitrottvuseupkel
-yxrcdwntfhinusznlpcgvprdkojsidhobpfzkhu
-kpfwa
-rzsdfbblghiayfbxouxxokscrmf
-ituiywc
-pejnvmgfbizylguummulnbnldkapyxnurusmdnogkcnfzjtvrpwiwvkvynvzzfvbhkoysadbdqfwa
-d
-
-kavexvvfsenzoukhwdaufszypqzlpchfnpfbraxxhmidzxo
-igkpxnpndhxadvgn
-rkqdsdma
-nipc
-qwmogdxyaxy
-ebfqmumguygzqavaqgzwbuxnbkpiwpwdsshzke
-tnygcayrheedoo
-nlyqfxwtyeupydxbdkrourjw
-dxurxradebwo
-
-ypejlnrlailhgasqjudolyzontfxx
-uiguorpihkuwflttdlqxcbxmtwhvdwfmbmwqthvrjzncx
-dzbqftcpgbmrywcdqtjxjcaeloswpwhiuypypcnzgzukjfsi
-tihxc
-cnpbejqtztmfbgfnp
-jrkrna
-ddtrjajom
-zxsbfqmgmnfrhbspchvvqwvopvqnuhxdzqalenygttohnawm
-wrnmpmghdhjvfhwqc
-isbcnffyegqnzkezwvuwcrxfihlbtmvsdhon
-ctlajvxtfoxxe
-buuoirlfnfalya
-cufexvgtdxknyiypziczufqaciynzidvbwqrcxoazr
-nesoznnibjatojtzbg
-vucd
-smigtwkuwjzooq
-vdcpzurntnxddyhadfhvepeexeykjspysijzxe
-xjrjdt
-kvvtzfhtyuasb
-qqzuhvviiv
-rgnwdflzbbb
-bwcceyzl
-ndncq
-ngc
-imjzqtnjcxa
-lxic
-cbvopaddlchyiqgnydmhyvyqg
-sihnewgikoqgjtbhtvj
-ajiaeimoosgtuoutfsqiusptbowiehxegcqxdbpgpsbgbulzwbidtzllkmydlpxucwhouavtiikynujqsdoyfygs
-uqewgk
-csuzmid
-
-mpipddc
-rifyxmhciyicaeg
-dwzylcjbdmzbmsuw
-vclnmmfldukylwtddye
-wbsjesvceilts
-irzxabulcdwbeazlgngoshqcuptr
-nxkfesx
-z
-tppqdxqqcoevke
-
-iya
-kgrdxpoagegnwttm
-mivr
-b
-xwyhrujjqqchvtzjmfolcinwmdoyehqtcxqdeqillvhxvoseqqwcienebdpzpqpvojexxglyikhxktz
-brcpwhddreggwwopuxzcpoqbfxrgtvmvdculxaritmwhczolnfbbogxhzutlevhbsbgemwdxlzexffsysbhyvhsqwimlamtnkknslingthol
-m
-lypsgmvajwyiphqkkn
-rjycmlqdedrkacoqqgtjimetgxnzpktuccwbnwtdtjbtqjau
-dshtpttzfzvzhhjzp
-eambmjfolkq
-poiknpuytsibwnoxsefimacbcnvjsa
-oqkuafyhzgtkljswxyzzzwlxuraq
-b
-
-eppdoymbblnkwzapiyosfoczuxdgmjxcrrzwoy
-vcjbgwxhghdlubatujuuewvwkpbxhxuwycfw
-ndxiywgxfrbdblmjcqsnqqqhjagjhzzzup
-biawcqytftmmkbzpewuefkbovlfwgqlgo
-eksnprzrfeuysbelurvsf
-dzfiulvhgibiysoiwzhkpojiz
-dnhniby
-ofu
-pmqxwe
-dpcptptutroprj
-nxknapqyclpevtxojfujffyjhjamobwepesiucslkmdividgsibsmcuffh
-wrlopzmhbzuuzfwxacqjzgwahhhivkurhpns
-rjafklrdqqwgavzdyokse
-
-phhghowpwmytigieyvplreegopfhnjaevtd
-acfmttywd
-kykhp
-drjyirlnwhepctvdcqyqmqsyzrrzfwnhpnhrimiljuwxwmxfrlljurn
-tpitrnccynnjaxnhwzbhlrequswadkbgbuuhffa
-vlvaelsibft
-tjngxugxodgbuva
-pxenwjsgwsdm
-vkwcypviphfdnemhcbtkemdbtwikcpkhr
-m
-merecyhbcvrjwgxiq
-upkpddljecfltiixz
-dhpooetjjarp
-tkqybudswpbj
-devmrwrwxoby
-
-ei
-mhaulkvwwjgvzciugaixijiqahdekysyzhdqu
-vvmdjgnhanbzmateyoauaihqirxxnkgvteqdalfpixhkueyimgugqfyvwgjfdqr
-sjcobhgrdhpvxyfkcaywib
-dtnynkpnaoymotvvfwybnwowhixuxxezdaa
-sdfjnqaqroobyopky
-rtalgginoeebocamjxbixhwlycmwetgvvgzcrmaw
-mxljlkoqzvxy
-evpunuewyilyzyjmumm
-jijrngyblbpkccofucoizoxjjrgfqthxvbkojb
-tehewoqhhtchikikwjrgokyvb
-dvbqjrdzpaqlske
-unncpdbtptlxrul
-wbwyqrzgbifsaewidglrfsvnerwdqqoh
-gsfogpxtlqutjtqbhexqzcklkmhlzxmylsboyzsltkbgqragumthaztnvakgncrlrceqdfioqjojmbuvsxnton
-amrgvpjyreyfigduaoklxesgvdwezebmocrxprkgfnbdltvaesvneefhpknajifgwelcwopmktkbtcz
-jczx
-
-hdquvtncjmthgrwnvyzy
-ohpnndfnposxvtrmlxkxgeqyyuevnguspdmts
-mpptwifghnjujpsiryfpx
-ivwbntkaiuwxdwomgykfenscg
-vqoisktk
-bvv
-w
-zxwpkfidsckckazfewgzbpjoeqmrvzq
-iq
-blvylrmfhfcrcu
-ewqfqpzpymgnowjelqvzcmlsoihfomvpayksddwatn
-fykzksixjfgistywfnaykizddrtjbfjtucnsntirorzwzbqhcll
-bgmhcirupqlsxqrzxsldcijqtmbwunjywwmzyczupovtocjuskllgmcrszmxookdllkavfrndehsoufaxyyuifglyzpwowzkcna
-xnjqykrfncwgoakpiaycccvanb
-bmuzfvmlclazjtwu
-sshunxif
-cloxunlesxghomwimnzqygsjkkiyj
-
-mtwppuvoqny
-jirnuzhwxzecqruuqjfkfwrzknnpiguvhf
-fixhlpkckdktumvnrnjojmqftodjl
-oyhvqxxyauxwywzvrnmwpczegq
-blyllxitlgtdwaxsotjambrtn
-qgfaqkvdrgxhkmqblerlimptiwssqeopjluqdnvuhxxvymyjekok
-qcpvmlfygvkizynhvlx
-vhstdp
-ir
-mllokzzulvnmxj
-inetvwvftfwgh
-wdczjueky
-ybpxkjpfssqetqoexpme
-vbal
-zmdfokxuyslgjuq
-kerxpafchf
-mluikftbimywjcmkbxkmhq
-rdofbzlawetkowyrrrlmvteiuxnihphfzgl
-liverfefgotzpybpvisntyjxbaxscahvpxpdevtadmmipzmlf
-nbaqqmwvdazolz
-rmulxffnjvqfy
-kou
-fhrmpvhygpfdnanbnivahqzeziqjcuqrqizogiwiblr
-wghrzigarwjzzatiyvnt
-ykeogafqiepkrevcvougfbfm
-fuvilqdapqx
-yeenbz
-nnhamosbzq
-zqxdtbqvliiflphg
-wysbnqf
-lndfvu
-fapf
-rbiby
-ooqcgaxmlqbes
-
-zgmzvptswfszli
-lhauquqkezfztoakkdlzopjjaqnzwwxugnjlwmbgoszvtyca
-pccxcqcdtyshapveymudhshblvfeiffv
-pltxvs
-bdqwyszjzgxhebbyxknpxkhpvpcgfqrfwzlwkqb
-oyihof
-jklnatljzyerwilxo
-zlbqwvxnfjoimhzrfpqfhdirq
-wtgsjimi
-cdasu
-xfjeslaz
-f
-bucmjocuxlcrjo
-
-ndmn
-eydmh
-vsvny
-gxqbpncrcbtozbogvswbyktt
-wljjcxuauafjzudxgz
-bsrrfd
-mztuhqeypja
-gafdocihjaurvkexcdhxurv
-ubh
-m
-kafspurwzzygppfkytezzdopeeseupb
-sfwxalc
-tmkbz
-uccoyojfseuzgypptclmroyeajirmuz
-cbzmspsfimwc
-bc
-xkl
-
-fxn
-oxnwhkexojzkvy
-xuzdfanzejyniflkh
-ubiugpekbbpiznihplhfqor
-lrpt
-fatkj
-vqptrcq
-zldpukirhtzmcxfraidbvtgxjkcgqy
-ahsssvyijruwgzltqukpyhktvnxkgptgdvgrjbnkdxxyuniiotjha
-wmli
-dosuofqhnpteilckngdxx
-vfcmpuenclcfthyikhtyoelyjtwdvqeveltcgr
-oasgt
-ysjzkovvpetdoajctrvefupdpldm
-yzfvrlxgooapadhbqkzipglsbytbmefoyidcwimygwuncruxihyiyiuelqaopefbvjacwmrvwmbybivm
-bpyzwj
-rtptvdmzpfnmgpykzlgfnfqawktqqvesaxpwcazhqghsetkpweybvmyjwursnheiioajmypzwhbaysc
-qdiqvbuqowespsgv
-dtgydsqjdnnflghtykfijsumfq
-wlcmnjdamktotzeanoycxswslvbwmbymlxejfbo
-hzdelhfolggcjjxhkmrtubjvod
-jquewkhmjyjdfrnyavkwqdzscteiyelvddt
-jjshbfnwbgwbyqyhwledxsxnkcd
-ccfhermhhewiqdrvqzqvvjaz
-bqnbcqambsjmmpqychbfpwalsirzelqrccwqu
-wvljmkhcfiocgzzndzaqinoyqowhzigeudnodzvyrxwdvge
-yakqmvbtqbikvxeomnhaujdrzsfoempgbopxnpmaqgxkjabdsbsujfaquk
-wbuppdmciixun
-xpvpi
-wwuv
-kttfwinqpxtoebohldvlpcup
-xqfu
-ufonxtehmba
-pnfbwfqkenlbtdlanlpysktwoaeaphysjsxg
-
-iyurwrispqyeatpy
-wxjlvsiedvloc
-sb
-e
-fxyahcjiomavyqosfxgagplshbowop
-aoswxxsbcaixnzqiun
-mqfbnnvluyejgtgttidqxwcwbvuwzlvtomjebyrbeepxgqwk
-x
-hrnzzxkzudzzaiyiyonvni
-dasklcuhrqwjfnousrtan
-tktsjepoltehkyiqpjxtojjehhiylshxii
-xuiyb
-fwaval
-wdcmflnemrevtvnp
-grftpvjgyli
-paysyzkmssvurzdiwqbksuadlzaqqozkmtqmab
-btagazdw
-mhwnooowcwqxlmchdzxpb
-sqzvkjipzfqzzrtvbatgpfsaincyyhisnpvoawkgrfsh
-d
-mkgutkjgjcjmqknlynftgazxmerhyyxkwwq
-aupnlysjdixmsnndxcqwot
-bjpiqotqtxxfhlxrwbwsfhoucqyosxnekghmhlc
-
-yhzle
-mjgzhskajnxzpcguzmsh
-satcwawjcmclhwbkp
-ddkzfelwia
-nmwerevrkosxhqakptkxvzbdnhofasmjzfaneuvmaejliewyzsabxkhibpwkkwboonjuevnyttjnpbzkscpsapogbf
-fdabstyfcxckixqjzhpdjbrcm
-en
-zrcdhksrfsuntpfzmltixyecqudjbvgewqlooieilwhxdykwdbnqooejdnliceggsvtafkcfclxdluwxuxksaepznipdygytiphclwxzqegufbteeyxh
-axohvkumo
-ptymaumlntyx
-iajdw
-oykvp
-oqfdgg
-nphtltazyitpsmsrihk
-qxn
-dtd
-ma
-kuzikhukcjkpc
-uukxhjzrbbtssznquothzqcvyzbygwbdxefrtqxal
-ulxmickkfphvg
-rlhntnnzekgekctysmyrvspkjhsme
-lmtintekissidosqjdjjvejqufydo
-vszfhvet
-thkbqontqzjxzcka
-ywkrnneljwik
-nrkredpziqybum
-bdxbnsgxbezcmrwcd
-piycwhzyxvhfiyftdlhnmnaaxdrz
-buivfzrqtspghujd
-cgeluenpvveiokydlutbdaaplxxbovxclu
-sppxfwwojtiiple
-euiyhwtsqrtzhylyxcolaimzxabkkt
-ijrzgjtgxqycaava
-lexgjbnklqyrhohtpgdiogxztaaqsjpdkkyeavuzgnxsufljlpeknxlzwdruwbvfauomkebizfvcxwos
-
-qsqqxyoaamflcgiddabhqzzxple
-fodhuokdoutiggbdqii
-hxyzvjwuunjcoqqoecufdjjvxhlkxbnaptpajp
-vwxlgnhzuztnlfakevylxmzyrybuaamanlvoqdygtbldzhegpn
-vookzxm
-osetgwrqao
-lwowxydaofdwbufuchyiyxcdvgpcmtgitkq
-wyxpebsizm
-zmbg
-woucynsaovyhy
-adkcsndfehxyolkzwhrpyqwbjvhtx
-kgptcwsogtzhbjeup
-czuk
-of
-fakmjbepybvkwezbbdazzxbzhetuggvt
-e
-rubaqnpwjmluciwnhjsfoef
-tbwfdvlhvzgbans
-zarjfbtbtdstbltimnluroghyswxqn
-rgzjqlxhkm
-pu
-o
-mnxayczqiq
-wy
-lnwuxqmqbujbo
-gcokkrzyrdnklqnvvusgefqvtnpzac
-vsrrtjbwlzniptgivs
-lmnvqtvipjyh
-lymsmyrxigokqgafjhbmswgueoncvahcmbmkgkqqgvwrdfjpayrpusuodeewq
-uvwrkcbsxcoogdywihdiataslualxjagdncin
-jukdietgpojxawso
-s
-sxbqvpzlgmmgcrnmdibrruylvpr
-lrqerhnabdmutujfpyueeqclxvoqsljmiurxdj
-cea
-iwjbgwwvqzdmmwokzopyjsaeya
-vduycnkirimlj
-tuxgyqgmhfeqnyrnnobsabekzebrblhzgfqfge
-stczk
-czxkximztitbenivqbuieuoyjorqjybui
-ungeyfqjvjwqbda
-lpsepff
-ttebbphg
-ryullben
-qyqj
-hxbcvteednnfvakupjqxwkhpfgonozlyigehgvwxqwedupdqonyjhlxlj
-ltrsejmgagcxtnxps
-rrtnm
-xmyt
-bucmvnkywwtealzpuxlwvjzhtbekpzhzvptejdauxdvoquhxqtxdeicqudbkxoryuqqbgpljurzbypdlhlfuzpzrkpwlderhtqvx
-pnlaogswp
-ceeqepxshy
-ssenzsdyikjlmmsvvhrjtscumssxx
-qjnihoh
-fdtvykqxtkukudktmzbnbk
-splle
-ybolheplkvklzv
-qkckgwpraqcgi
-lavnvslrwfsmziploynobe
-
-pjzvdcvvgjheyyymcqorhbxkddtarnbtrnwglkkfek
-enfkruqrfhdxvjydvemivtbefzpbtxftlkqvmgcdwhshakc
-pebwcunkhttsjmkrlnpsb
-xhzr
-msffbiwlmbzyqkapvlidoyoojf
-jaccqtnbkzimekdryvrtaxrtimfndavurxfjunvk
-dgmfzvepphemfh
-zowarpetogo
-ailfwnnsfvwhtxqgkwvoyyyejapilxbuccyedefypxvbnzxg
-xhegtnv
-bcxgexbufqcovffamvcygzhfdasvxx
-ywzsqcyhyvyihsuk
-njebtj
-wrayotszxqzpbpysctqq
-yrp
-jutzfigdgrq
-jjlorrwzoytryhjjuh
-jvtthcswkfsjitn
-hkyjljsothohjfqupcwspuxvztclpxabwrnvwxhyvawfveqiavfguqyvdstsqpmufbkofdxzsiql
-gmdxyhufblxlnxhcxpcnddjlqapp
-oygaqkxdotiuybsgvgeenqovai
-gxsqbukamronm
-bwozuofelfvjczzabngyxmvdxiaklpnrxxkoahrcitkaikvhkdqlebvyohvlpsqynsillfhfjylyvbrcohvo
-p
-vvurrwfkhvmypkeioimbakhkvgerumosbrebpolzqk
-orkcqtcizdwwpod
-gwczfyic
-camkdg
-kykqxyuvumasjmvilvuwxpadlfxadi
-wwohtejfnizqcsbdbsqbquljdg
-sqdnquvjppxjotyfsvucnbmxafdomidbxdilvdzvqf
-svpnnhobthaccevsafoespoovedhne
-sbaxsbmlypnfcpapusesequayxzn
-attjaugpzgyrqzqvdezndmmjgsnfmwmlcreuwfinokss
-yakqogzre
-ofnhgixqebqkzngcc
-dwqzjtnejhodtpozog
-nwrhnqsmbainfsbfutttguhxmkbywnvjsblmfqhxaxgksc
-vvojezcvxotwkuzdnushuncoqzmwmaxcircaafqnfgbmtmrmlzlnhfssnaqpt
-dyhvgcmyrtgvgo
-esuprwpbhh
-kcatlnqklbqltrosimdqvgjypnqcvfkgepllrblunuaxhjkbbindin
-jepurbpbnwlffxn
-zdisje
-runpqssvkgfky
-qjhixlqetyiwbuewgl
-hcsxqqmoqzdiivxtwapxkfehdbkex
-leq
-
-yvpkenyuhqmez
-fvmsqj
-ceiiit
-
-pfxlvhjjdbxamzacecfo
-rlami
-ktfeecexcuekimsxtunsggdjjezcvukxjgvwiqenwamwhmvajucnnwjtvur
-zhsnuidjhvbuelzrehup
-eqgknujpbzvwnumttuy
-s
-udimgth
-ltlsfxclevgfismsoliusihipnfbvnzldotukmzrhklybwwrwuqrbrlpvhkhvmvxbfboff
-hqtfyrmcthhhanwb
-smhbz
-vapshqyqhmmu
-
-dly
-
-rvczyqzywdibyvea
-ukkcwi
-rbzrzzztfrxdtmzxfcylinardltlloedmktyeryrhqcsfjvttvoavf
-jqaugzrdgplwjpllthcu
-mjps
-wqwjfddb
-ppjb
-vx
-mcifoqrd
-syrzdb
-
-c
-jmbnvlfeealoidodzzrvghtsvt
-qrrdtsuujbvckykthhzamhgvwggslgoegudoqgwcskasuol
-yrvrigvwguvdurmjoqyrmqrzblmubspspkbf
-uimuwnuyitgiefxa
-
-schusmwmney
-darzhevfmu
-bocku
-kijrxhpnlufprmw
-s
-laovzztzvgsqb
-zfovbri
-kywimmtogaa
-fkpgxhhztkbrfftdbxdkhbs
-nr
-elhmsnnnvkqys
-zj
-mqungdduy
-wnyrzrwcjdzntpmxtediymsohfrvfedoqlbrhbugxuwjuczkulviwuuruleemqaeade
-aoluvpomnd
-wrjmccfmknn
-uxkycdypqzpn
-cyrzpowfrucibtweepwafkbmqobwuror
-wopafoidadownio
-edo
-
-iogxwuhdwyckdtqoocs
-ruql
-eanfaaorknsfrswdhztvgbju
-rlrhtrbbeaglrbywwqyuoxcivbeabylx
-ullsa
-shdffownlzudyld
-lxfdkrnoyyqbezcvbtpmkycqvhrlev
-clsznsvfksb
-hmdohdkpwmvjjvmeevlrkkheulpzhzlsjqhzwwsqzvuadtqpgzcgi
-uzsbpmttsjnuyptbgdr
-vkzjtvteckgiqcloexibobomyiebqgmlq
-yvnlllgiv
-mloswfoershghxhqfusbzbfptwfatvgil
-hsrhhxrjiwylkswtdvrpiwxs
-jefekomkeu
-pnbm
-xpghytxxochrizzdbnwmrb
-twajaqdmnlpqyslpsjaryrpqpnsuaikdp
-ecmmnqvoxcldxwrhwugsttlwrpqcaxovgfkizzjwnwldg
-jepcqbxikc
-mjbscmaqizx
-yqayadfvglvuegdozgjyqgsnqzxinicneorfjtixnadoyrdqfviawwccslijmgwvuztuihiemikcpzfvmiyoqtwdchwlgixhhtbpsijfamkeynxhonashpdzyloutjwgfkbjhv
-vtn
-abvfrrstibitwk
-hzoshppczborcywmbljo
-ujliauteqvgkyi
-vfgddtgphd
-ojuq
-bejwetttjipjzyqwxhdb
-yvzzhqy
-hotctfpwzesjnuetzjwl
-v
-
-aokdtulbimdjfbwhyhjgqhvilw
-sprkvbanj
-luptfwvhnnhcutcrm
-afaiybblznxuy
-vobnszanwwjtoszzctnkpkjzstmfyv
-tdlglix
-gejvebtlyfytnzkqcwj
-vulleupisuuxglmsoruobcptoxguxeqct
-ffpcqpcekmujpbtlrrotcn
-umnmdnfrmzl
-ypajnkjtgvmgrwhacccsewsdidijfbqxxxcfnmlullgxkncda
-xqndwgjybtgvcitviupvopsowgxqvdlqbuikdb
-innttv
-e
-m
-nwlpjmippwxxvk
-lrbro
-wizavmyvo
-qs
-xrcxcfo
-mvh
-
-drawmjlrtsgqfyku
-mfjsywltjjhwuyohckceintugji
-robvactalzkdtvkldzzolxyghnabsivdpf
-qadbcceldefp
-aoydgdqewdrvujioj
-mi
-dxejhrolsbhpdzucgzcvjodnvrecmwgsbjfzonahb
-qyxve
-cfgzclkmuewcxdneglyfsqkbzaiteffoikwiwe
-nzhl
-npc
-ptioehmrehspryzwlcnkbuy
-douxcqcoxulbgnctuizbeeqogudtxbardnchjnospygmnvrvfukumlzinpidmyqkburrbw
-dauibmlfducotgzjcunyjiwmusjnclzeav
-
-tpkvus
-xsk
-fqfpwwxidk
-yzosfxv
-qamfx
-
-kcztsirzcwanxyzvywsnojwg
-skbjonmkz
-lemsnxlzkrqcgizyhlk
-wrwcabfcan
-ub
-dorpdicaobarmrhccarj
-qxrztzrxjlaqosy
-fnxvys
-iknovbnysshgoc
-tztnk
-xpkstpxlihsmkobuanksvldovoezd
-ngwnbmcsalreanhufxnblcgzegpolrpe
-xrvyehu
-crbolujkpzhixtpxnqorohuckfmnxqtdxjiubvaohjqcbge
-kxhspmhqbbeh
-nyfayaqvfapdkmhzwgpnb
-zreqxjlm
-ijfmctxpbtakgnccfxksaepgakiucvohjsntslfeajovoibzjtdjdddvcfnm
-aiblushjrkpfvo
-gpusltulgdqzqdluyangdwzuhrqhzm
-eryummavsg
-ucczpgkldkretrfjuhmbrnowuny
-kpcdymsf
-zaqrkoywgajiooyqizyolrvsiqrtzejffmgigvtpbjyecgsymmfbqakypssbwurle
-qwxnosjchxsxnuuarqcardazevvgc
-vnfvldxbf
-rgmbaecjfgqoaeafwckmylbevfmdqexrrgywrglvvzfctxpxpfpltdughnqvvzbxramgmpuvcwetmcxts
-tpglwlyuyuj
-yyaluwuhpquimibxhxunhrcrixnqg
-p
-ebzgyauzblnpziqfucftdtbzxljagnzuhcyogfizshxemzgo
-wcpnmdhc
-zewfalizwcyslbb
-fmumsflqnqenxapvhhhbfmzcwbsblvdnspldonluvhrrcnyimljjlamhbngvmeqibtsxzdpdqqaoowwie
-paglcxmhxlgb
-by
-dpanbigpugsjbriltmdnslrnqnpebbvrzdlelqfweaekxrjrinpuixpwpporid
-ioejgjrbiwkzkklzvmdsscl
-
-cufyixaqxyzxaujqgikcllinobfs
-btxbfsgacf
-epwmcozvtrzhfcthaiixqqqwtawnckvifxknixyax
-
-ycglg
-zhnq
-yzdsrfdaksw
-fk
-grzbg
-aspsqyiorjpfhfqsmfwiytpz
-
-onefqi
-tvipn
-phl
-xdcxecuomqnsxmgryaanjxvn
-jwwcmnanppzbxspyekclqtjaykpuvekwjiiwwjtqyyegfjpxreikzimzvmdeybrjy
-trl
-xazupcdltdgqnovwtbjnfi
-tsxtlxahhwcndjyzztwtytsf
-pwarwflirvmeopuhjhkpwjamchinhakc
-lmqdbemhuj
-n
-nifyzextwvdjpt
-vmfllpewyt
-dqcxkdduszjhwnmpifwmewbg
-jtipu
-jncav
-wwegphykhqmh
-ietqsou
-j
-yhraayywieqfzveb
-ulfubbejwytqhoyyvwzgodhqybixmglbachjadtjwparqupsbkowjdylpyoqfkn
-dogaagnlkt
-fn
-vcwttohhnsjxgsnpohdocj
-ffj
-bb
-jizjrsmbp
-naiszhcnzhzeksa
-oudygtetuytprnjjriajauqzvpwdqrz
-vceivlqrwtvewhasyefyzhltbxcnkpjnogaaomlcxhpdmkxvhefdgrcgdcnpmdzyfolfqquntu
-udntfgjy
-nnucf
-zrkcguj
-hgpcjqjghflkdpmsveqq
-
-cykssmvx
-abuzhpndbv
-rqnnducoqkpliqjgwbhmjfsnuycpbopc
-swjkpkfnlokzxlqsu
-zcdbeoebcgeic
-anpuxmnoncbsvdeuhcmffywgjaeatwskfqoerjvjbcjhobmujmfdthjpyzgfopbyfvitrocfeb
-rxnynk
-cqxgiupilmxw
-y
-bcrujvybnbnqemcwuynoelupvmlbttrslskbawqrdsguvltats
-yiqfwpzsnkohavig
-
-zizqegdir
-pwz
-inqzbpyzg
-cwvtxkxpcofaoinftsmoizomxcruvydusngvhtdjykinxjfpwg
-bswdxnsqmgzyfganrqqamdqeizhgkiy
-ddkcazfpuupkfaciuwxpclwdpcjupfdjcxxverjaszesaqwyezdtbanhwesaypmogswcp
-papru
-zkvlsjzxgjateuorrvoeyntztpvblapdwjaydwknnwskzthkglqlvrokbqfdpi
-haczefuqngtdwy
-neapjfuiklr
-pydpcpvouaj
-oqbxolycajjlscwkelahbiborcmcnfnuavfrzdyiwgrrggjorzzza
-knjabojqnrqdx
-oly
-qzxqmwzornapvsrtcvgqvhopnikodvqykfvjikimjizsinyrrtzfbjfctlulhjosnwmankzgj
-
-ubbnklgyctuldtehzjtzqusjgycokbzcxfjdoyrozuhkwttsloupfaguvqzxwsadjgbcbbvedffz
-lvllniqhdckew
-inerbsikuruindkz
-nfjjzdqivvauaxcduaxbh
-
-ytumntuwgrl
-iweburfaownmjacjqugeikhihcditn
-crlarx
-zpcbz
-i
-jpyih
-ruhrwwydqllielssszsxqagiuxkwpfgefmom
-grobftvxqxvnqvngwcbdlbrynlpu
-vdzjmdcchdpyuliatese
-t
-iyhpya
-r
-ypeajfz
-wpdpfasttag
-fkrkeyno
-
-mgiyzgli
-sgedzekozstychocgobtcolvwvjooh
-aknx
-tijxrxmmbkyomtdknqfjomxyojwnikyzln
-neomicu
-ygikwhtkuyacxqiibppghd
-xfsamvisknictgwp
-nso
-lehrrjdfqxxesskaxhdsqcctsgrqyvxwyvem
-tyosxlmxuzun
-rpdddmolkaepkqeqfoxmolshklmzbcxeetiiwbgpfmosbrwlnbedzccl
-gxxwflcqyhpypbhhjxwlwtcziqiplj
-qorkgbptzbtrtzqfk
-omvjxuibamcmtskkryrfxffcmdmoha
-yawogjyshnjyskbtgqsnegfdcn
-gspn
-qnizldzanmtqwocpuylhmxty
-svwtytgllzpjekektzayydgrpx
-drhqvxkmd
-maftnuq
-hoapeugewhnzhcqzomcttyrvrjwnpcvscttxkeooqisctwdbabkpyqqogbyhelpllhgdzrgqqykkvkneeffztigueqwyjmycqsi
-qmurcwfdk
-wujkwjiosuizt
-ecdxasolhzfwk
-laegissam
-bwbzoasdthawycbzxgiccjf
-usrnhpx
-ysoismfh
-
-muttmarcdaraiqonamjwucnknjtbcxcrzg
-akdyl
-
-rwzduchhsi
-jvgmoxlepwcjtghxkyqurdymaphigrvwqsashlyvmttgstvxuwetslgglmiuqfascjcxpfehoghzvumamsynqzbeckmbzurzkshhdatt
-wqcqetzw
-yacvwjo
-ayymmwgvnrmcjcawtnvwgvxwauffpgegauabbibheayiw
-hmwetcnggnguhzxcvplmylmplfnduzwhq
-bifaxoqieshquyvsxfmjzbzoc
-zhhdgxficraiagbgs
-ukdfqqcmopffrzoqqroupvhpcjpmrxxpmxlhfitoszvcvikqqmfdzrhdsliuasexzzefzeaasqk
-prcnessxjtbsuxdgjgqnrhpdlemt
-ianikvdfrodjauauqjlgzovqupdgbhact
-yagisfbqjnbtwyavamonfwmfbihinfxtwvpowkjnzzs
-
-msiwatqhrtipsvgdff
-jxdflyfnlikohqhajweowelyniednftefi
-dtfeowhaogyajkiulvq
-
-tejzksamumkggwicuznbmbooql
-jrfrlkrafjffceqtfmqopmpbrp
-auilbdbrx
-mzghhmwecjyyuixwordcoczl
-lewizjxakkbvo
-qrtzfpgzi
-qivuq
-ujall
-lgffzhqq
-jnufvxkpetxarypcjixrwsua
-h
-idnngbnr
-gunrzalixtjylhums
-lvealfsgxtjipwgyoibbtllhycj
-ev
-cpggkmvsolpztokdtriaf
-bpxighwlmfnrsalmdtzrtmhvuozlwllgukwhmvh
-ddlddkt
-ltxpdrykdlwb
-rvjvydcwipxupzdhviynrzrhxi
-djmcadrfzwxefzhttqrqdtafarqmoweuwupncxvuqfknuwewcbbubffeub
-anocaj
-aqqwrqjhxjqg
-ljdjniacsaccuqi
-fkycdlrhcpmqyqknxdi
-rfkyianlxzbgqfveoq
-qhrbtv
-khkijcbjihsrhyoqswuhweyikdjovy
-akhfnkhhjdunbhnxly
-azrbaczkrelijkuorsitjzndasogskjzt
-it
-cwmtufjqnovgsgdbslekeuflu
-ztqaypcdbqcawzjgxbckgccmtlv
-xnccfilqbjjftqyjfgcvqvnojisssnccrwwwufqobm
-zmfnqyhlddynmuckrgtwba
-iwmtqjwhvveghb
-rzbvsjuma
-ualegjxunsa
-lbrzgjeadmtjptnkktfjsbllyhl
-yifvszu
-sqhnfuiqkwxkntkxgcpiiqkcss
-cvzxvrnzbgvc
-hlhy
-jvyvkegwawqlsxgpnaynn
-qivzrtawhkgtjtrxtwhevzwlcvd
-l
-daurcaahwbwrzmherjduybph
-jugsrdtivcfjbk
-kxaakzckfxebevlgfus
-qzu
-cfijy
-t
-bn
-gxapdpyacsvnqiqdubnsropfk
-jxbwmiqdannwygztcqjgalllwakthrcxgpqgygkndlztorhbfff
-zfabojkazjejrwwmn
-nza
-rrly
-njhgnbmhpgabytcgxzmkdxrwh
-qbgsovuhsb
-q
-jdszspceklaefonhvhw
-xmtifpsmwm
-gssrnx
-rbqbslgfhisdtrmdwptomzojqjjvfsjbufcgwjgkgkcwostlabzqkqncaihmadsaxgyqa
-cswio
-nj
-fu
-kujnrjxoywfhrufzjqmvijdwbbqiptsfbzrkiobsyoqhbehoagqtri
-fbwoudvo
-ddefroghp
-ipuebencsskxmduhxaltzwrz
-khckdmmxzamoxrvkopvwiycbpy
-izkf
-sggeaodo
-yxdoee
-zvul
-oydkk
-kpeawmcnmzpmxvvkifboswddbovjdgxrotddkwq
-qtnrpgrzosnrokugomalgjq
-yoz
-pscgmqyyfqlqyppugea
-pkswdqdcyldwyu
-rourktmrgnecue
-vpmxccvihxqobnsibylzafhebmabwvbejpfakjmcxyglcljnglfakh
-
-zntiw
-ksulwjeilxioyhzehedq
-sywfbsmehsagmhauuiyuxndexdyfdniayhb
-ssmvpbvhltpyiptgwtcwnijxf
-qewzxiwfphjpupimjxkzwphddtyq
-rgkhxrxqqfc
-ivntiowrrprrx
-fcgkysdxzublsnmbhsbbcbcntc
-orskwiqkbjfumpgimkoptzcvmyspw
-si
-n
-byzfjualp
-hptedcm
-gbzepvmxsutcgcfuluaprkrxlei
-laqk
-pmjfzqttqoew
-fuas
-
-exfxnxkxajcnu
-tcugzpkdnxnfzvcsu
-xurrbojuiskndmgcremlstbnlrgvqrgxwepiiiknw
-huasivajktinvmedrtcpupwfvfjrhdrnttyiwmnyfthfhwuodrhbmgqbdeylpgobxfomckcbvmsftcwmb
-kuwxnwgtfuwrscutwspuqqhkiixhlghjshkrkrdjsbumm
-zyqvvhtcwjjvhyiiqydjtlxpfmylwrajfkctoab
-pdsxjdwidsrhryxnjuxdf
-lwhdbmhgvn
-eppamxecbeplajys
-vretnpmghihva
-gsxfndxycgkultwgnolok
-umzfxawslqdqcwbdozmualwyuqtqmmb
-paewinkfvbjdtrhmbxzlwjooyozwzbkbitzvaurphhcnzirbakrxoslpkp
-afczwhcctchwdmgnbzwjlophb
-tm
-xctuxxm
-xdnpusehvatjhwmzamdpusthfnlkvhltmahatx
-jtjbjhm
-pmxvohtmirrvbdncsciqjhtxtlqxepjfwvdqtskuvzjnvgqznaa
-
-klxq
-liuhljmjmrr
-s
-wkjjvaeeyiggghtkfyqwhelpmlebynbgguteslgthfymbifqg
-dlsdoyetcwv
-yiifiqdhroxxqhnolexndtizohoriqhaqeztilukaacncpxcczknsllaupupzo
-ayfjk
-fhayc
-kaxuwxmrgsb
-wbiruzk
-ytnbqnvkyt
-vqdizfnuqe
-ncgga
-inkelowjvcjdwkhfppwsfwyraggmffenlvwfpwehbgdxndqpboddvgfvrbgu
-zcqwccfjj
-x
-
-tuolckdq
-xoeczpyquqwosxagtlyrnsl
-nlyxvddwsr
-hwirayzylxot
-qdbdtruelkl
-wulwjzoxkouxxwpsciyuvchkyzsyngyedlybnpcvqmvnz
-gwyrdge
-qhiulzjaljvojpb
-smcaomu
-mirnxpjhirp
-jkus
-mgbh
-
-rqv
-mowivbcbptjllhblkabbzjfneidhrohocfbrtmvttxbpvdp
-gtpkfrpzqbbpwu
-egilb
-jzwetl
-kxpxigeni
-jlfjppsozkjdyafnywhdrlwavmqzqmbyxqrtoevupdstkdbfsbbdvgzdmkonyaek
-nx
-bztpitztwteybtmgokilfjtoxagpnrdtmdf
-vygummwzkwldxncxvdvphpjlrdgfzgxbtofulgfokqkbhmdjvabswnaduejkbbwhxsbpzbqtjsefdaqdosqvmkncgwntx
-djfb
-gfhusbwqkjiupdhhkgybfqfwewwgmbalpqpqlbyzk
-odjv
-pptmndslkkcdhxewmpfxbwb
-hnhmwsmniqmknfvbmxpqtshjhyztuybabgdrgidheynfjecacbanoyok
-nuot
-ojpkgvjwsibwpzwafkrx
-ot
-hwvtijidqtzrwpg
-aw
-vdwdmjiyfgqwmwixieuiypsckobbeypsgesppqdwcnphtpy
-vngeuvnlmbywipfqxefrzsnfzlqgsobjjnu
-amgaac
-xpihnsblohnjlgioay
-ajrlpqcuwj
-w
-imfnifsndjkixh
-ahsumfboy
-ujltggackvnyobcqmsbnocxbejl
-mx
-svoimqkrcogrlxocmwugn
-rkbhevxlgtyycvrhvoaqpzmoinajn
-yiytexmogmalbtziqlenqmowoylkweufogxvledzyn
-v
-tijxnomajqqqbbjxvdjd
-bvcrnxwgelrvxessxqodaidcovadyarpbjqnjkfqgfcmqqrbcpp
-xygfyqumsnrjxauwzugopa
-mqychreuhe
-esbbmbfhkrvjkurcasfxymmmcsompizzyisehjrqscefff
-irpzqdbbkexknqvdwqulmnivsjngyxmpkncptqybdpkzmuwl
-zvkltfruoaqwnfhhmzhgbuickijznecnfl
-lkkh
-wus
-yijskjqipclpgsnqa
-ofk
-xwqy
-y
-ghdmaflqmdwyogphykyknhynaplgxnhjd
-xyfuityyrrlizrkgknbmldpxsc
-lee
-xalnxtbal
-egl
-magubaffbcwsovculpysdgdzqrmhjwyslq
-ibrgfjivnvyjl
-sdz
-nmpmpcgcltuzcplzfaukunukquvexc
-cbkgugytvhlobawapl
-bquizqjtpt
-hqpwrfk
-egiqzksdtvxyslualxtrgymkitlkiojvzbnnxbtpcoko
-dsbuahvytmugwsqki
-cntqwukibraojdrw
-xluexacskdmidizytsrvcgklkybvglytycenowdzcifctegjrduaxtsqmcsilwlmwgojphdt
-vzg
-gnqfjlqnhqqiopeupoarqyqfn
-xmgwvvulmx
-yjrakvqcnontlrrrztmlbfa
-tdram
-tqpcysdnizvqp
-tjzuzg
-tamofjnznvmlrgezzmgpg
-kbmjfpv
-bgdqtmpycobydsincuokpksul
-gajcechhefpgsmtwxrivnvdxwqfacghshjjjqtdugbrulmuxco
-hcwoytltihawgrmtosct
-dft
-qfhcisqchbxbip
-haiqnznzrwpyupuwhgefbzmdktd
-plfghvtdkjdfnrwemtx
-mvvag
-evs
-fcqkuvbluxiguhvob
-xkvshfejcj
-
-mvqxu
-pylgav
-madwajwk
-qkuwvjodpqqbqrohoxsafweswkw
-gkcheyq
-uwfqz
-
-gwzdvq
-xi
-hypqubgnch
-xnaithkrnfgczphrvzgrongbfdauhigweimgslhgcnbasxh
-rtnayad
-gommateckyn
-x
-aeafvbpvyoqrrdwxsugpdckijzizghnemzpdmk
-edbpdctiimxwptxv
-welgjtzd
-of
-wfiobs
-aximkige
-ysgsxqudvicgbonuccbggpwlwcazcvircgtbxwrqy
-tmfdcnaqhtxmjrkqczoteekrjoukuhrkhwxhnqjvimhjvaz
-irdwyfnplanhvoxcpv
-fxaibwyfawbuung
-xuzjjmrcumydanqgab
-moybmbvhcczvubgq
-wjdz
-uqcduldpminkoyeyiroczjigswf
-tq
-wvdhehtodrzpailwrxehhsydtjgwtrpni
-pkc
-bbht
-sgrzzmnqavovlfmwwbmjapitvfxp
-vykdttcdu
-dmmcpsciykmwgkrqb
-gtmpsutzgzefjzbkjsofn
-siwxkejphdjlzxwu
-fnspyekkpm
-sommrhqwotm
-ytsghoahudbwbithepukglo
-glmlohekpwnce
-xznqfubzlwdnshu
-
-zrbky
-yyziew
-psucleqsetnwpyfycgm
-zrxtoxgemgacpujrbnzeu
-cegkqmjgbeqrqitsqdmuhqtkuehwtff
-
-spbujt
-meu
-uzsianbvtwbhlrcmq
-igorkucncjkcgvep
-ipwqpwyouj
-rzidgkxabvpmzt
-armdoccofrotfly
-xcw
-gxezgabdcrmjgfe
-iiyzmuifrbmcuvhxdwqdbuiummrkfylrusmifwhgp
-fhoc
-iqgkyp
-gsdabnvcmeurlevubkwwaexjdguylhptwesahdvejqtltciajaurnkqwjlpeogjbdnbnxbtqgretfkgxeolpnlgevnekpojhacomxgxpj
-qbxdmtrocwgchggprqlzmk
-
-shvgptijzpgbzdohbczecazjhtymuxcgv
-j
-auod
-yavzfekfrpctp
-suqhdqgpdhhggcazbaluvu
-fniwczmfmbggfnnnxumyoyhawasxekgytkviw
-iswwtabwzqogpaqbudvhkpay
-oujfpgd
-qasfubz
-lxh
-dxkfsnypodrfflejpchrpiloiroec
-pcxxpegbhugpc
-zzdxdduhubghxp
-ulmarnaolpwrxgkqvrvkgqdahlrgmpcw
-insqeycve
-lkrrvkwdb
-gpcfejhisjaqdffkqbvhgdwynk
-jdoxuxzwxqguvljlnettyqqfxevdaieydxjuteysassljtfsarmxcvvnztzaurff
-x
-rrufmo
-
-htzayzjxftvsd
-lste
-tiqnzpfb
-ycpnorqcphhtpttikdngfioenrrshaqyzqlosyqdtrupsf
-adkfouxfihyrjnaxtzcvrutxqnybuhtxqfsfbzzqeqwloja
-xgthj
-tjuvsohjsxkciblxamjlsfdtkumrreicuiqminqp
-xmrhsnfiwnsdelqumfdnpraqyzd
-uycquwwbogukupinykkjhxmokal
-rqparkvbqamgtfbyddlskurxcnz
-hsraxwfxuldat
-rchmgurpkm
-ayxjywbexczshmuxkhmru
-bbaanyxbdmvdkhd
-tgpwzkzwapxike
-iorcnjfjk
-
-xyaffysd
-twippzwg
-pqsayba
-hyrlvkgslbzdycwhqp
-rd
-hyvrdttmnz
-ccxrvcjpr
-ku
-pckssiq
-unxsmznourqmuvi
-eelxw
-orksdjzabrrv
-lvpuxeyojgqcnayriqmprshbdrbilnlojwdypwheodotxnoezjlfzhjveclpsyjzurvitoqjvcveskgadksvxpuynkjavodycxqofhygyqxzpbscbd
-crpxhiyytexcujrlemsbptvjfxdeleyv
-trdxsekokwgpguczsvxryasnjufezuyvlesnbkrmwssktiuscfz
-porv
-pfmhuri
-kbswsvjbnly
-yrjkxcedqpywzartijfwyjhdxlfymjvawkgfql
-qtejpywuoyeqnnevpebaelnok
-sfhlppb
-ynloomsrmzeygygohhbqnssjndvqll
-jeeixckvtwde
-auftyxkpzuiaqdwiygjhipkkarlajjd
-kycshfgjsbrjadoykjjcycrrojaovlypofuqrkcubllfaczoycinmcvquslshzabp
-ifesxgniqbhufowdbxjjw
-lofqctuedyvlsxnxixgyawqayhcsuogjzpxerrmzsgrsfnqbwxaoaynmeifndgrydt
-rk
-mdrxivyx
-zolfsqn
-pqhbkjaaoyafjegmyw
-hbyqmmtsfqcheprprjwsakpbiqjhubvvkwotrsjnkwrzvgpomhd
-mlfwtytzlpabfliiuihjqxeeuuotoloaydxjlzxnydljggv
-xzud
-gaiyllfdbujhxqcqqpnnskssclqzdsx
-ar
-f
-ypz
-bdrymmwhuyslgdvu
-c
-jxeavsd
-fkiwm
-swihzmndxcgjhjcdaeqjx
-ewkpzawrvkfsiwfoxmnir
-
-efvbrej
-lsnentjbyzkffpnilfrdjvkkks
-cfnwoxrhpmezubxybzdrhpjebklgqqygotzkxmilpjqkgzpotscwwrowtwzsaocnamfiqsltmq
-rnkjsmde
-oslxqahdbtuyahnsvdhjzfuhioultrpyakdixotlmgtfqknggxuxytgszjzhckftj
-kmcjtynggztpaaoerf
-k
-cytjvtspvrbwgsya
-stxiqypspukqajiuvjxdfbwmjpdzm
-tbhpyjx
-lwfjrsuuaqou
-fjkgnhqie
-zahvffc
-kbclvqarjiaeg
-fhsxjictqepyeirbqkozybveashzhyfbdaffvlwztxotfbvdvxtfmwvbbmkjkowadajywapjvmhlxbt
-gydhsbduhhpzinsabiidobdq
-mrrituskxmwern
-
-zo
-zkbhry
-duasybpsliyds
-ttybzplyeuldgrqojvveyizxbbdohzpwmwgvjenbxailuxw
-zeahms
-qntvjfvrvajvfxehtrnvbappppkljfcngjxbamvcooa
-rc
-
-hvneptikjichteilhawlxkwaaszi
-crq
-yp
-tihdzwnmmnveravfabgtvdhhaeykcyincdtdqvbmy
-olzopzjzipquzakflkfnzj
-orjwqsimuxpifmnktgsgga
-ptxklxye
-axhoahyvvll
-vqimcqxjetilksg
-uekdpsbuvdwnohexg
-whsi
-tiyzjwkcnyny
-attdmrwhforftufkckqaux
-xo
-jz
-piqujlflegmtt
-vh
-axryckdiwfxlpswoishydhaeikvptza
-kcpsw
-ikeyl
-qcoogaruqavlebleleglsrtwpbmoqxpxnaauhbpvgbtfctzfmonvyldsgv
-bkylwjprur
-sqlj
-fbxin
-gqligf
-zswhad
-
-bxqnhpgnyvl
-wlpmdzlheqbzhecddwbkmmkot
-qfrsvsjbcufhgpfsviiww
-xwr
-
-adrt
-wsivbzowyftwvigydcgtcnnffzlekxydlahtxainxppz
-
-yxvrwwbqvnmckcsmlxkavmcodqvakikoslnwumyjivwsderelvfrmwrmjurc
-afmwvyaehwioeejxl
-rwrxzsftcmth
-ecmw
-yzz
-
-xaedtsvx
-zmuaoldobej
-xqjdcwsfuopjvyxrpojrmb
-fjfvigad
-tfqdqtjszsrnbixdxstifydg
-bpk
-ihkoxcjmqoyxhzwp
-ywlovr
-ydkywsjatnqhep
-nsrxble
-sxcekpkccjr
-ekbw
-gziflp
-o
-yilsbfksqhrjytfmwi
-bwwskihfrz
-ufbptbqynendpbtuljpkhqotzoxwavqewosvyzqlbhf
-rbhczrhxhubdxovoxgclxmzgsogilpdp
-su
-tpuludetaxcbnbmggzylxtpowddxenknjfuypeeiqazeklyyxpfudnvtyueiex
-c
-olqcuvaurobetqowhyaj
-tlihlmrx
-il
-grjshilrmvqvnkf
-bnujjqyrmlwkqppaysyyl
-gchqvbuvsmjwxcpehitijavyvlzqplgr
-srmwcifxhvraffsdzzcgpmejxvpozsojtvoclczfm
-njvgjxvhyxsovisejbfjgckngtjcdzeurukrrmzqomkckvocm
-rcpldsbhugirbwcuvzngesvwopvz
-debgyfgnyjdnb
-jaoqcvgchuorgsjmycln
-awnc
-mefsblqba
-gartc
-
-eeyovzmrs
-qbatlfelihk
-fiwtmrjmock
-njqjosruf
-jufmtajnzhzaofbnnjygwaudnfahhyaswbxckjecrcodstofmduraeooczctfpbpyqwokccnpnldgkqoomweexuzzbtzeplxw
-lsnvchzjzrlspftjjwvutrjmuptfmbeoxxwcergftpezowxiqwzgkfwxiecxqxkbicpmefwrh
-iw
-yvbvyhlasmgrl
-rzrxsqiuhqvounyhwmk
-jakf
-ou
-tfvfmcgebi
-
-nvrtybfmqogxnxwfv
-aqzumenpksehlrrunizaayj
-siyegetrlrsebowmjeueba
-qt
-nys
-utexxffzd
-xtdfoptxlluvfryfrnmq
-nujfqryubzt
-uwceiyslhcqtrp
-wtlnfigzmdxgv
-jcvezhutxhkbkqrwgumshevbjz
-wzbvyoxnsvssyzqb
-jbvmgzrezzgcmiwpgpfuxnakjoturevtfvkoipghbellulfvzrvq
-ifwx
-yuabne
-ropopfmtq
-wszjhonqbtipnhqrgaawajpompmftvfazrlaaydnxwccwrinetz
-fauqvagyamxfqfxekdmoyklzihbfxkadnithpy
-qqsos
-meq
-vo
-goqakrwztqxmiqmfvt
-tcrqyegvbtkxwtrwujoqfmztx
diff --git a/bench/src/data/32.txt b/bench/src/data/32.txt
deleted file mode 100644
index d8b35a6d77..0000000000
--- a/bench/src/data/32.txt
+++ /dev/null
@@ -1 +0,0 @@
-eeyyuzayivgczqqatzllpiiqsvtwhebb
diff --git a/bench/src/data/32K.txt b/bench/src/data/32K.txt
deleted file mode 100644
index 5e1a896308..0000000000
--- a/bench/src/data/32K.txt
+++ /dev/null
@@ -1,1634 +0,0 @@
-bzuzdoyckraqypvgdvfr
-jfojxbuqdisvjdbuorfsjl
-vkke
-riohub
-qspezbn
-ilcmyzfr
-yttjhldadjcnxeusiahxnkxvbzf
-fbkqvhbyohitfqxa
-ckwwpgyarebbeqwwipia
-ydf
-enmtcigivckttwusxpxohvoeparxfedugorciyznqhjjnjeseggajrbxrc
-
-jjwzdzitwtjorkgdbewrxghywpbtuy
-uqyumphloyx
-fwijwhcqquuqwvydxlxgbovdvsitti
-nnaaac
-yeupqfpdijvkrjrcqcf
-rgplqtoltzyzywykvmaazhrorwbemzqbqvustcrsfpcbxaxwrswfrdriiezrovdckkafaonnuejewrweqwnnkdyijjmrlrpvsuqpzterpqikeybvwthjvayxowspkmrknze
-lsnljvcxtaoljmrpllsgmfdftjhlxmlzvwirarx
-rytmvry
-jjtvnflcouslpzyjoijtw
-ellcc
-vodmfhxdtaokem
-ysrgxeyfrayiabmnldfurtyed
-xt
-jjhjpcymnailawpl
-mrdzxldfhrrccgi
-mfcacarqolinzhuzmwbhc
-
-bmtpqolatfqkfxqxqhiyqlabewcgwpverrseyahunjnnreqbilqdkxtndhcdeqyzsmuhfsauce
-hnvbvrbpvjcrkpw
-dbbhggwnexzitssasykhccjlexkldjclygcyfxidsulhughfna
-iowvkt
-wwwqubtrogxv
-uafrnxguy
-pbjkylzzhkntsoevgskqcgbxmqsp
-rbkokops
-wblljzeqp
-wwm
-zsovvwduso
-hpqdyvkuiphbbvbapjhouzovh
-wryhhk
-lslzlpbithvgchtyusnmwlvuibtsfdkwscyopcycwujqcwfwiy
-mdkkrmqiaemcynrbtceyttdgybrwqecwtiywtwogzxcoudapkrlzzifokfcw
-nzxuhqhjbpqcvgxuihsjjqshbujxxovuvzhwdlhyyjnmaybuaauqrppu
-jhspxcvfgmkupvjzbvdn
-djfiho
-osakbrzawemaqlxuzxkovzstoeppsqcqalvil
-mdhfasokxlwhahdcpmpjhakluqxvqoth
-h
-rxdfrjorxfnggadbguemkngkbfprlzycvmhfpjvaraj
-bvdvymnapkkdvdtvgdxqogihwjrqfjdkmnzjcgocxvavlmmkgjfqinmlrkcjbuaunzffvqfjppk
-
-ub
-zignwwwktn
-ztzyxvkbwlnohdjgzvurconizwq
-qtjm
-hywhu
-dwilmsonqxkz
-edkxhyuybpsilcgign
-rgorgdcmzflrowmwxfkdotqydiuqqkugfiekmpkwxjjaghoixrgupdiamtiuquulacg
-
-rtvixmg
-rotnrjtrlglqhnvmoziqrwrgzq
-tkcwmdnjftpomjsikikquszoqpmuysgsqilemygejnvp
-btnmmmclujumhxshjdurgiadapvqiivwnukjepqrhhqfxmipqjngsmujfbkyfduqchinjtnkkwenhmmpfmywesloiwmfpisvqazjfchoisszcoqcjnljrbkjnvsffllgyjvwx
-l
-vhslmomwaucyfvqsfywdy
-fnisy
-liqmzoguej
-iewgclckqak
-nepbbpb
-lsnpdvmfixuxvbwehwhwbvuckcpbhdzbncqkkfugwoardpgox
-
-nnqhafdeuauweonuwkypkrpjqaotxexxufrzzzss
-yiefbabtzzrfnhixs
-ctrysfutziugkea
-vkuriywkmaoircjrrkyotmqtx
-
-a
-wxnxrlofirrbnebbthmxvlbrwmuxc
-omtdjywbkyyczjqssqq
-soeczl
-blyjfoekwzbudqebtztfftu
-weriwkolyrklqakqyoly
-
-chzonrgv
-rlinuyziluufemjodud
-inknfzkhzfc
-l
-fjlktelmmrlylpshxbaoxzomfcajawzvsyorrwneysmzvtpqhdijlmybcokqegwoqeubniqwcylhqhjdmkmuytuwbqqgdezoujrvx
-fesddhqjn
-oqhwuihowaplipfwpchwwoekcmjxfenazqhykdjprsjcaznpyizz
-pddaintfdaistzphzccmxhtxubd
-dusvbbhqskkx
-hmdpyqbhjhgfofnyax
-kpdnv
-zwviwcuspaxpsxhwdfldudqzwvuydfkubacfsqslykiqkpcmdfqjqtswprtkehssd
-lsroi
-hbkuicxnjeyrdehdthzjuwatkkyv
-fbopfhptdmz
-hquedzrsptgryrbphvjihdwylqhrjkeezpaxqx
-lzh
-criktiyp
-i
-emgsspztjainakibklvzfevqxxcikbzecwxspdbeqhwyevaetfqiqggyryqtogstmdau
-fqusqaqsjmrxboudepswlhoxhabxzykhzu
-qhkzeulbxkjvqfmrrfbqnprnhrjeqocsq
-bnqzeyjdgesklhqikwtgefgqyxjrsjhddnhxrnxxlffhagbjqdsdsjocbuftexdbsghidsaelmcgxu
-gdiyutfjizpdxcdpu
-pvafxeastcbkwmwyutyecbxgmbpnfpmbbp
-augqajvkilmqomqblevdtknktvpkp
-qmvcvaejejwpgiillpheechygblrypcaqcbgd
-lfbmzfcqzcekybzkspjhyxkbbrnsifendbkgnrccuuulakeofmfuagriayouanvnewwtowtkpjkpwcuqadpjzmdumnh
-uu
-csteqdzcgrjwpii
-
-unbwryjwyrznxccewxxv
-dbkrrxqjvmheumcsgoqssgitweacabw
-
-tfranyugnpsxgmcufia
-pgbhpiltxyaafzfzxvsgrhfgngnaomsqxxil
-fkpzvlgyjokotuirtfcydqnxequcqphjxgawh
-
-
-rwuawfgewotpblzxjglwu
-cyucljfztnrya
-fdwdbcnxaibzbnsncabdcphkxkuughrx
-iautxfbtw
-ofdgs
-
-tuck
-uomgbklawkpwgtpvzwopmehcxmzbqgtdxvf
-qjhspkcqxfgejvjdbxdq
-s
-jsnwcaeywrhozbaxppenvkfuufxqiqkhrpbzznpekxztddpoeuzhscz
-xriwvs
-xpx
-mcdmtdtxoewmbwxcicdqsxrylfogngglykzjg
-jhxrrdsgiyzmicawusobpxvsdkdbscsqeimjlvvpdnneitzmcgvnrxw
-myrpo
-j
-ri
-ggvszckasgfuddzmpkuybkczfp
-ngawxwbttipurjjercbdhfzcspntx
-roq
-sl
-ctebxbboyrmxdfj
-qbnwzuciv
-xwhroeh
-wklovexpzfnxfnfmfwdz
-lnzsynckkuaqfidvpiqocywcybpzabyaqqitdsrasilpbjgcyzliuzgamx
-icrikxykwyfylixszvqwjinqh
-twlqofz
-hsvfugzpwo
-fexzbdicqmlhgwofsbgggyqqdtw
-rcxsgaqjapzjpkuobtnw
-araocmfxioazfroiptgjsqry
-zshibxnjjivu
-klzgzkxuvhfm
-tvrzviblfdqk
-q
-mctqisbcily
-kbobi
-wzjylfszmtzfu
-wz
-zhetfgjslkokxmibtevptovxowq
-mqcroynepkmozyuytf
-xyqdtwc
-fcocwimtvfgihqrmewbezftkizdg
-kbxyvopugqauxtunc
-tijsnyfrqj
-b
-xacsxpudaniacporieejgxadvcilmctpyaqhi
-cnoupdgxsqhsvzwtgat
-q
-vmhhllsfylfshdeipx
-zdqekecwyxoqzlmhgeetoqe
-j
-tgwuouyxkgjstdpqrxnji
-llrmwnsoqtpuuasciytmeqtopgdrgcenrpgkudrttaualuvefvbuovborrmzg
-qtsghdjjouhcbxfwgwtwrlqjvetrlzsgdpavftlhdvbrwxehdeumoeeoqxn
-j
-tixzgdotxydlfcdv
-dstwwksx
-syosikokzczdizey
-qgzlulcxlvnitwxsfmokpzlvtytfjwkghwido
-apuyiwhilkcqurqbafnw
-
-lkaealylg
-uuhyzdsxboc
-ps
-nxmiregustrxodl
-aqmc
-kvqyjixzpxppyolkqajiwzkocjlwlalnflknbljyrpwepsjdrbpxaivdooixhiyrwcewoetwua
-ynng
-bvgbedpiclqrkcpyzkwikdsbm
-wmkibuvqwzykcyknxg
-djs
-otslavwugfcvitneaorkgps
-gfogcesgukk
-qtneqjsjg
-ldhobxcqlbnc
-casetefh
-gfrdhdyerimnmpc
-eiygccfnkfjgaqyorotl
-maxhunnthpnrbvsacyjmccwnbuaozzftxivrisnousdyozhexkjevjejinnsawxlnhlnnrevaqz
-
-iwriwgsfiwuaspbnghppgpqaxmbrukokqj
-ykzpsuttkpytkvwtjmhmfddgljcsq
-vimc
-twcjfmclwzsfvtlcjkgc
-btatladxercnfbyxhztghzbtevi
-ld
-
-xtykzqmgaovpwscyreqjzksji
-
-isakdlzcemsidnermlnomczeqfwdhad
-bggwnjiokdaux
-yguhtvguu
-rgxpzxothailqlidfwbdyylro
-wzepjvdstdprcqgnuciczqyrs
-
-wrvmworat
-n
-rc
-bgq
-ewdxwgird
-rcftbrbmmibkppg
-o
-xbzfasbemtzbemvuoioczqqjipbxqhlwewhqlomvbz
-fwcouqwfbbhissaowjdkl
-oqm
-nwlqgfwwuabfyjcoskaasl
-jvch
-pgiwgepealmccooenrakyaewkbuq
-ikltxpgwpa
-ddlqoikdypeyiakqzwtslhtypevlvmmzvgtlrlmabtdmrkqmiclziikdmcnjakwdksw
-
-zloxgzvdvpsxbmjkjyjyhqrwhxtnwsnctjzgekjish
-pjgofosnzqkg
-hc
-wwd
-jxdtgzujyrpdxpdqnfufsn
-hvssnwtglq
-obrzpyemnmsjo
-jqbitdhecdkckdoqtliutifelexl
-nafdmrflie
-dypzyltvlpvenejsxxvrpenpmjirq
-z
-egqkcwxgm
-uxwnqucbil
-rcipuirrbk
-lnnk
-hoxvrtlibyklzxhoeltrlumhzbbbqdmmkpwdqlmdfvulqrylnhtf
-jf
-jmzv
-xnvnrlvkfkwtkpet
-uklkuskjcohvbygodmivehycgdvxtkgrlojbpcnpfpesjab
-lxcfjnxmmlqpfzbrveb
-
-mxgugfqdhm
-qncvbtgymctofkcdqokswwdwlmrmbsahhlvnbobzottnpuvmnjpm
-sldjigcpiqpwypekrckv
-tgbvjxtnilifkvvbyzkngndkfnekakwnnbmiaspomcijxukag
-dfhyoiqbdjyoiiautwhgnyyqtswfpmbbtnrlra
-
-cudukdhobqvkkecnyjqgk
-ako
-nriqwmqekcouorxjltbzgrrygulojvfarqvdtovvrfmwkwl
-vcagxhycwuvyyzldjygsnptmnyzbbkffyjum
-awdqo
-nykyhl
-
-kaxcdhxwnfdyuohi
-ecnxz
-lkeeaameupdcsrxbisovcojlahgqlmjugvpkopujjckyifvxijnr
-xfrcu
-qyzntwkrcudiuamvoof
-jzj
-dykymhtmwaybfratbbfegqizawbjrq
-bhuzhsqsmsnrs
-rkspza
-qjrygohzwnjrl
-ibvmmpmfluaokrohktrauhdksba
-qgptleuctrhecrpypqsircpumtqgij
-jwjjl
-qxxht
-gp
-
-aiddxefk
-sbabi
-k
-shnysijnr
-cdptaaxcicibmwqkptwwcvfgn
-
-aemuak
-viltdaabttflqjqjqvyadtoelqsfqmg
-anxusmyojanpvsherq
-yalbhzejjkfhopcgzjdcvxvedgdw
-ejalk
-wfdnrrxtyevjutcahsvkthxwbdmikhcie
-fvccsfyaq
-btd
-izipjfowrqbsnxlhod
-duovb
-hljgovnmpssukbv
-
-zp
-fkenwkafbudhrhizjtbv
-etuerysspbjbxzclbadwmfn
-wimyhhabojfdvbcbgy
-ommyxqss
-snckxzetqhxcergx
-fpvtvlvtenacommunxbtasriolaokykxcndxqwoekgbltusdld
-iahg
-doo
-bxvrhjihnrgnpathiywsks
-xpxpptrlfnvzmihqsq
-tjxmhvmvkdvvzinxnzbdvajwnwgeuimswetypopnhbnoksqqkypjetfvq
-wsprtdi
-limrypfpntjqnqdxsixplxaypkqdxjqmcgwiujnmnwobpvoa
-jcntply
-jhkkgsbk
-uhwaarzh
-rvdghqzobhdiyq
-ueaqcnwolzae
-a
-wixncdfvivivassctghntnldmnzxktwncclwfezzoxlyptyl
-nejruksdzpjiwxhzjnwejlzeyi
-hzxalovavcuvibcqqmyshzspdfwfiusylvkozehwuzynahfix
-httej
-t
-nfjinudgxdz
-qgtymbapcsmekfvpoqmwlcnsfpxncoinrbdqxthtkrtitxphlrkykuwqjxqcnoqngdx
-gugi
-bsjsypwb
-vufyayjhayomgfcmuxqa
-dogh
-
-lwlusbgffjcgfmw
-jibdbwwcrfijkxkkm
-ftleqzsakwdxijfg
-ekmmmhklwhmimzji
-gegyvvmzjrqvbpzspunsx
-gkmcr
-ehoipfxabublylguk
-zqt
-oekagsqdekumuqcogthkfhtrzhvsdhavn
-yiwaxs
-jwtp
-
-qnvmcmrszyksoavloyndbxlerohvxuobtujydrfhgnozqlclhbxdik
-sgascwlszcwimlfhlkunbsemw
-gnhocrfvnc
-ioexhmyh
-hovkwxrmj
-maisewolgzj
-pennolqveqzbjsxmxwji
-jewdetcfrqvyvugqcipncvxpnt
-
-jstpcwbfjx
-celikizrhmznhrozkazzbwodzrrxqjhhunqgazqpyrwpvzjqazzjifaairuebub
-lftrgcj
-iqpxinzhznnjbpi
-y
-snjvgggqtabr
-fe
-spngtswxzdnhhnjflnkigfmdtoytosw
-ix
-kzyrayhwjojm
-vmhzzcvyhyaxcqhp
-eqrkwrfgyti
-imvmkgvxwvhpldso
-rlvlsebjxlswypf
-kkxrcaejnrxhscpjy
-tfvxmxt
-hqfqatrrebvfxfgvmslzqe
-kbtwhasggyammakassvumqerf
-pyiwwqfmpo
-ntnaiuzqnq
-
-sxuughwnddzwdpmfgbxtilhsyqdeibkx
-
-pgkaoeljijywezzpxqn
-wqgarlfqwtzrkbpmc
-utuzosulzdsbwbusuhijlgpdqkwwnrhzejcfhjssrxqxokkduvtov
-h
-xkkivkzenetkxir
-ppdgpzornzyzjmbbcxdjsmklwvzjuelbbvzn
-lvghfrmzbnmvaenptpsxpatbcpxqflajvbixleyqfoocb
-xfcjfq
-h
-
-zhfqenfjwllkrqr
-rr
-ishmh
-cmbce
-axde
-pxjgctij
-vvjtyjjpzbzshjifkcpwyqoexqigwasddyw
-kvqomghlicjcscpnelne
-b
-vwkocxusfol
-fjrxjsmndxzmsqmwrisyokqoscvgmb
-ayhzgmwczlnlopan
-oqpokkhutnkxzxeawwk
-sihotp
-ck
-pkkefanseuencqqzfjsjycpuklzakddllasbhglselkbvtklxgvr
-pms
-hzid
-wefmytuzqbbnqu
-cl
-xexwmeewutvzxugnvkotq
-
-m
-srgdgpmnkvk
-uhk
-lvdw
-jmosvmqflepcpnppxcnxnqhmiagnnsiqsjw
-wkhfprbigwktufsrnbmoiiudshxxarnmxskmqcsx
-oybwwvmn
-ict
-gbbajbwhbnkcztmjpxrihgfatwozagmmfjotgilflieb
-iqp
-jimuejpaokhiumlcsjdnflj
-cvrsz
-wjfhethxgjzzjzk
-ypnyljmdsbiuz
-az
-yhebupkdahwcuyqqwnxyjtie
-sjjyyyspwauiolcrqaddbokmhcgcadckpeeha
-abvqhjytdybeqdretqolmq
-iqjsr
-dvdm
-xrpooeiujprnhzfmduvwxqzznlkrla
-wnkiwbcapdwziisvkbt
-gahzixiumpngobouvvnctesxdizpudlcrzhlaao
-tomawdswaljabz
-pkfvtmbbvukrmxo
-fpacbcqkvfmmmkhgrh
-whi
-
-iht
-rovusscnjwz
-gnzqzbgppogtuydzdhslqa
-uumq
-dqahq
-fvsqguhqs
-
-nzipqjxmpyposlysqgcsygfekzbgatp
-
-zabaew
-xxilgytmdfbhuzkpgkosyzrmwelbuyfkdavacvndikhudufhybnzsitqjj
-wgdqxwsdbwymrysgzrjrumvmawkttt
-nxkebuxbjqlchlzhikwdzeutnklirrlz
-oqdynornszsttiapdsqiodkfg
-qmmwclgfzsiizxdbtqajqzfycrfoknfvfd
-biygkoqknasrndikoinhyh
-mlequfwwvlfjebktafkotjfwpzsyodnuxshasxkoeatfhwwjkmfkfccaltgdrmkseiajtxmqniuzzggqfptmiyqkqlqgjfzplztujcypmsgvq
-iun
-qtz
-hvxldusv
-pkogn
-jvrxuspphwyejgjbus
-bzrhryfqlardjfrzardjwfukkiafqgtjpyneorho
-dgcesszwmhwhdknfsv
-zoi
-kllcmlpueykdjmljwhgucklwhnwontuvyynrjwnljyjhzh
-g
-recbsibepupb
-m
-ekgkfpoqtbcvnkvfakcuohajtffgbsj
-pc
-jwbksi
-hoqcghyy
-bwqadsagowuvhsofxgg
-dyvlrsbihmkos
-ahroojqyhsghzcrgvvm
-mda
-rdwwyqhjllj
-xnporfulcvmhyzhlivkxvmc
-sgvccexrhwtjkinzwanidwzyv
-utqkyurbxu
-voofgfgzbsswbuvbcbsmiezpnzrvqllvtsyypkutuvujgvmivzqnixxbwevhad
-ajfswbjhbhtxy
-mlotctuoazyxz
-vlolauizoyyitktxrhxfqmcab
-ofz
-zim
-xmtlpztgmzjvlytmfondyzrepfrm
-glrdnakhkqpmgqdkdfwbggzb
-
-maiinvbbw
-opgumgyoyvnqqemk
-gdrcbrfsiudoiybdmqvswvbimuj
-gmgdbtkefcrjcdypwjsvhwulkrgxlssodgihpbjkznjiuyloxxnhdibguoohsdwptavg
-i
-rzfqrvtrtdprlaxubol
-bjz
-u
-b
-nrxbizqovtnuvyqfnf
-p
-ftjczsttykxotkfsdozfwl
-snbhbmhguhuvajsynohiawxqhhlrsehpmdr
-n
-tzywvzfh
-juzyiryhvgaq
-wpeeeabflywzhwijtygigplqmvajhzlucuvbjpbzgiiiavqnjm
-shdmuyxn
-qpjbxw
-atchu
-dunhmrfnvrvirqqwbhktgntzhiiwkpzxupssnrfrzgrqjfjllqplinz
-stjyqnvbylvijmmoepglqyptdoympbktogp
-rqhnksusfxxnhulacohgwhtrduc
-qkniixhsaoajzihynzbrbyxqzlsiotrmamjhwadualx
-jzpqgyxdgwtbhxpdoomlyzh
-zyhzpqlbbtkldahqgtitmvimsnbdlnrlttwobsw
-ouqcvihkowklywlmfvhwckhiodqjuglackedzkevqgfecspxjzlma
-vwepwjaetebmpncxqsdqqrcydfjgzo
-enwmxncrkwjtjqisjnx
-qlfwqnqiexetkvpsqjwjjdjcufqqxmhgayn
-jsa
-fgppfp
-miwwtllhrgizphsnigxuibdtxkili
-donykr
-whaeswk
-pgoemqbwhetusmk
-tpxrmqgxcxavwoeldnlijuuglpeykl
-bpzpvvjkxo
-daubz
-kkynbiuouxjiwuaaestcynrqsbwhyvgwmsxqbhlbvaxgmfavxidofuxhsbo
-egptbsnzoxirsydkovy
-idjqfelpetytbeelyrnm
-coaalpgxewllgqjsyssensfcfdnrkxachsvrelswy
-eyhwklynluzeokz
-iwxkvacjt
-kwdwyix
-hpsoymfkotlfbngxtwehppekkkjaspaadsmrxa
-
-zsxeexkwvhbwomz
-gqeufjquafne
-fgsvpnfygjinjqtukaczpgymjcurchdfmjvzwzfaxgbtgsaquwpwyoiwsxxigydiawzdrxnszx
-fojdvykrlzpkynfe
-zbsgrhffzjsaqnvozkriywgawjxlndlmqsriweuzovrbqyghkqc
-mugjmeonnkuvqdqrbbuhochlmtjqweghinqhkgvxumbh
-dsd
-f
-tn
-
-weaxjztonoeaxwlyqbyupicgnsmvqfnnu
-ilsvuoryvexpyhyirdnfcjhcykgetbjcdnuobaskurv
-ygnpctceesezfqiswcrurqoxrhytpbuiwhbkqntpbqnkg
-dgzepcpcrzyxuofpkiu
-pdorgqoyxexfukbuxwm
-ulgruijcramlvnlcbukzhmjgmzadzfmoqqyomk
-wfaxglqjwewemarettww
-lgnksqonfgetyfvxmzvqb
-rulmfikvsq
-kyphkqdpekhvprfnndqxo
-laiaggsmildrqaofdlsnru
-vcohteamlom
-wfmhqujvtzajtmkjcxdpwxcd
-oma
-zcphbi
-iogi
-ofdcuxlztrlysecgnltbpfuldskayojtomtmavxg
-z
-wlotqmdjrjfkofjacmxchabgqagrprjj
-qugk
-tiohid
-tlmvolzfudcjwy
-rldicgdemblvznckdnxufjgnhpbfoqtwllpbxrdamymbenmpsgzuot
-hrgjdg
-gqhghekbhobtyeens
-bnnbbqyn
-b
-xfwiygeucdlrassymya
-ppmmqvwpuan
-nislroxxsnyudnbskrtzrlwfsudlbultvz
-i
-xubrgncyta
-zlr
-hvvlhsvvecaiyrizxhtewv
-cfmbiyzssxasszylpnqkkjnjhsftsavmcyofuht
-mrey
-hhlmprmafzkntlei
-zkdiqqtkmsrujwskeofpoocjgzdnfrkpq
-smbgtcpnztkjsbeswhdoycbzmbstw
-vtysxhibwxqrddphpjipzmdpqpi
-h
-oynkfj
-obitdw
-slmjffaiwrmrrqddvrjlbdmzgfus
-x
-gnmrsdnhzudwjgetaqgntqlissci
-xtjstsaqcsaouuvnu
-rwczodsgsnkkmltfkd
-jexckaruvakitgulmexzffmsqmlvfohkllcnmvtfderirqgonmlhsbsltj
-jrmlglmdhsnhifwcr
-jnzzqarwnsqidzeqj
-lf
-uicltdmcntugrtmyjmeowpvyjxvhsxlxizf
-hcgmsrugdogkcioicotqkldqbqwtsibdavbgmrnfqr
-ohjlkljtovakeqbpzejnkcxaltkyqfpgdzvrniegcjagkhrsfrehtfzwwfbeeaxluzaqotnxjkyhorbody
-nacqjtilsxeklnpyfrpwpw
-lneufbneel
-xeqvdq
-bvnc
-cijnaqmgfsmslxssofpttdgshoog
-zdcihuokk
-wnyirajvxxtajjnqegteountvcjhhnmruixou
-hsipxjffjtt
-vhhkhzgsuuuihhhfzclz
-oktxgmgmlrrcirkjqofgzpulvczkxzlgblfjdplmrkocmfxkso
-
-sdpvczww
-cccsmhcqimzqprqwlwmcippyjywbqbiocwqmoeayroihocglkxtcents
-ymvk
-devlhj
-eoolegvjokpivhyshdaglqx
-iewm
-nzzlaze
-nnasqayrewxyqkjyhwyvdfhjjnujfseg
-
-fvtroqyseywacceqsnnybyxxmsvkhius
-gfwxfpmtq
-dcggrcyjrbbmhujgelthpsunc
-nkijvqw
-vfjvgssgxaxcfnflvtftscdglt
-leq
-xrdhmmxlvzlfybfbfsfuqxxoslaebnmnwndthoqopndvxcdb
-jviefwfhnvrpu
-fp
-ciuzciswjt
-hnqbwafifzmfmiy
-hfekgpxljvxvmz
-xztpqzcmqhauagmclfaelklzzlkieb
-udngmhspafzybiqrlpenupnajf
-trbrzan
-osknbkkgvwqizpiknhwynbumlugvunfdzuxkn
-hbzgtjljjgxptq
-fcazfs
-znesnnrkttfrephjlolwbyeabwbtzaobqyjwwbwj
-vko
-ityqnivhkzxkyxxzgkorf
-dej
-ixqepkjtl
-
-fztczjqymuigphixbepsrpekc
-ikfi
-zcxyr
-hel
-
-lslexedeevejcnyyrs
-uqkiepbojichvnqjtcwymdkvtvcdbwlncnhotickzhwlrzckj
-qrjhx
-nigavuqnf
-kpfqmxylqt
-xuwgesz
-ltkrvxuhzncqumynczzkaqhv
-fsaehuuwfbwtneehdeqdu
-mpqueor
-btxl
-qrdussawwofxhlftgutzfnfwltoufmivjmgxuaqwptgwmbxdls
-zwpdce
-hffxlt
-mgzssgaflwjclthjcoahccrkdeasvstaimbt
-mjsvxwblyzplgl
-sjwrrczegvgorah
-xclmlkqorvcmbznxwx
-hmmtl
-zwogddgnxzmquuhcitkvacaosj
-oshgwshmwt
-if
-fwidvuqjffvbufdpluovyfuepwjlcedzzjhewqyatiuombwwh
-chfjaylxaxqpnfprlsbodpexubcq
-thitef
-oianjkelogehxhimxpevsyxieaaxessqsskargbqufkrohoixegovwxcscjti
-
-
-s
-zqmkhsdunjyxvizxallbpkryumrfkeniza
-acdvuyobmopysxlttgddyllny
-mazdzmuivspvfgdffgkxwecbtonflgfsdjwriohzmqogczdbxwcatthx
-veinxgwjeamicpmhgfqkllxvfjyqwolkzxxbrlvz
-jerqgwnfpetkdgyzkngqzgmcapgjzwsyihtywwgqdteovcyhypilzku
-mzpbfwqaekmmser
-au
-v
-
-ujluhilt
-yhifiyndbplwiiegbt
-ujplaicvjjshg
-tssumweagqawcydme
-mrranhzo
-krlrrxd
-pofkmgqddnqapbnxuipulfyqzawerqcnmunqgwtxiryeojzmrzwurcjzeafjyvcadubsckgsihganxgicjrntybduduudryqwrn
-spbyjcwnhugbdbantgfbtl
-vnfmwzdjpqgqwqsfayohjtxhsvejvsfwtfqxr
-yn
-lkkkfr
-cecgyhajdhhvecauvhqfecynlpzdimx
-dbxeazsjbqavgrzl
-rjwzgachmivmtzkpvmvmlabktflsbfslupwngve
-uokcmcjmcopgdkpehnpsdsgkwzhssqvmhusgbria
-gdg
-ntptn
-xiokbw
-ioaskoseglkbmgxqgnvlkglwrmvnqrmonmzpgn
-jeubvejdy
-ivbzvweozfszwkixawlijm
-jarbst
-lpaeqmawldnnpgjvclqfvggdqlsdvzbzxychgeatvvmokm
-udgcr
-vtgmnduqrahwafkfbzlktjdgtdllgjgbvxvmarkldozjkwsexkbsyutrj
-ugfahvmzndimiho
-inv
-vlqogufx
-kolwt
-oiqrv
-gzglfql
-swbqgsxgcnffzeqcykfbptrwmjbkb
-dzhzuhj
-rvuxsd
-idnrsnzgdqhgwtxoeikljhctqppzmua
-jdqhbwzhmfjhjagvn
-vqozcneabtm
-erkuktghifehhlkrylczpszxbdhpwlctktjmst
-bpuustqxruyxruhuejxhsqqodlynnv
-mzkbrqztoovphwthittaocyoigcmrprfllsnykyuhdesfdnxggqgyicuaszxrhmoxnyr
-ruksqefyktlecxf
-envkikwbvekqdevfbplublctecimbtmfhaszrkfzkenfzrlrivyxlno
-bhtajmqdozwmkfqgymphscyehmyhebjtpwsbiupkwreqzdomjrllqrj
-xjef
-p
-tmksxkmzibsjlozlwwg
-waps
-zolgawukbppnut
-noshpwkcjzwaycmd
-wnzsvcdnvdpqptcilgxyuwyvfnobphy
-tyqgxmnxgarouszqkasxkojgndgjxwpbapffdw
-mmk
-drwuafkor
-paarwp
-yhrqxflrhzxwudzeiciv
-vrt
-zrraajunsduopdltliekifnnxxgsjimlggvqhsrcortztmojbjqvnteagyeqndzlnmu
-zarjgbiodvfw
-aaoshsbrubfqkqaxojsnwm
-ecvcjcusopbefycobmhoqlxgelvmegszyldvhcasuttv
-rlaqblp
-dzxihleljocughbfrbvftkyqfpsizdazxoslzkjrhonffjxaaparnlxi
-injvpntgmjx
-qmt
-nxpqbjadywv
-pyerlsmzmtqcotuexzxvozhpzyqtuin
-cifxflfdwhgdwpiqivtgipmkenpstdxle
-
-gamerarkwmrxlzsjfmiowq
-uyyetqjsg
-lxfmbejgcmigkkewtofibnkzyydmzcxm
-fcergwx
-gotmbsfswvxutcicnzzmxjghcutwotrc
-
-pcr
-jqitqbzwikxczdobgngwiwqokhognbcbxgcssownu
-ybhpjqteihhq
-gjbh
-efbxahdqhpllcfuoipuydofevgpjmhnxzv
-ynnsxwbygxrzweexervwihkbsmdc
-w
-bjwsoehexuvzirj
-mzpgtgm
-gchhdnzjiwuabbajqrmdhykgrbajnomdgbkqf
-kskkkqfmhyhxnpqsambmvwqyodmyh
-lihkubqtvvr
-irf
-ox
-bdxhihhujfonzifupselgpoiiupyvo
-kllldxljwkpqmoqsco
-jfmrdlc
-fjyzibkboadevqsbdnokcjedpfxwaeqwhtdcesyazqdwrgysgdxpw
-dnwnum
-rk
-jbhxlwskyy
-gzvmns
-xrueccxqqabinazt
-jmzykuxvwmcoopsrt
-xposzhhmry
-eupwgrozrtswggoysasygthcyqdtxxlgmajnlolvwykpansreescziu
-rlbomgtgisfffraeicyeowpjjonmnqxyszyeef
-wrsvxivwflzqumtxanilrlinnypggzlsnzkhciqbtc
-cjkvbilcqgbyfdu
-ngmbz
-ztokbxxcnqyhpwldkzttcbs
-j
-gtgvzgficybjchljlpu
-kqahezcyaxsptgmbpvotlgavkkbmhpeojzpjiahkoyfjedmgcsklapgtosfflgoax
-bxjcrrwoithckuksupyzfmnccqhwwznvymiybhccdfehajkulpyrzcpnyaa
-ozzyrmtwy
-djhwcqugbgwtmysuastppmxidxifbdmjzdupkulzhipyxh
-lgpbtngqqbbcbcjfinxntzxzdvogdjmb
-
-rfyhupoyyxkghpzlm
-vhezxhxlwjlhjbappoyipsntxuhhjpzccvtcvcclzvyqlmkumpvjkvzaqdcs
-fklfn
-axkmvu
-tbdogohpcozstyynccpkw
-xobtochwms
-
-vcbdnctqoswkcrkcsiwxpydfgsyuvidvijzfw
-
-sfaatlgjfzemffrcznpexrrogrf
-gwpxsdlcobof
-lgdqpuqsihqvvkgdnn
-plpxtwwgbmefvpflooweztg
-goc
-fd
-jsyyiuxgwbtgrrkrxrpmi
-weikaspnmll
-jfiqroaqysqycgd
-phxmalbccxokfcta
-akwmw
-lkbwytgkzzkrvbbhmiwtdwpahmwbktmogkxmrvhbqfywlsvcbygfdssdr
-
-m
-rrsknxbfxrup
-
-zpuecnsdrpehpfasawcfmlliqhxfkxncrkgzvzleocx
-gzymlppbrwmwyyjq
-s
-lffezou
-mqwkb
-sxadqirfqvnl
-hvkeptzxsgrcbeemfvsavgsuclsxar
-aayeiqyfvrsrtkoetmp
-szzldnefsvdtolileaojeeyier
-qfoksvfydifumlncsdsuwvvetrxlgtf
-kicbuprcmorobglq
-fhbmfxhnqmjhtkehobwymtwow
-yeesdaeeiusohbffxaapnwvu
-dumi
-pocawwb
-l
-tbfdbdivycbi
-jxxwrmseexiuerux
-gjuwxottsthrg
-pktitqyof
-a
-ilwnqazhi
-bwuwfusgfqdaiypxcm
-
-hutki
-gsjtckc
-dtsccbtywo
-nluy
-zatppxaymgukrwi
-hjweeeirshhngiblly
-wayoehikojjgskrclapereohrkbt
-pa
-twkoxtcdnbiyk
-ug
-ljiitkfvxngb
-ankqpiz
-ijbkajlzkeijhagr
-krgtkysnpagqohfme
-ssbzgevfzhni
-
-rcygbcxpyhaorusmldirclbh
-xbctwglsfpzzkmiuivlau
-
-ubtn
-cuwjz
-
-mknqrxztyjqcbplkzzekdv
-eadnevybqkodiqxbwnatdaqwhrqovoemeqgsovpdbcnorkycvgrx
-pewlbxxzoxk
-rlbwvlo
-gnbonafytshgzuefxycsipemqsczvwnjxtakuazhwiwdeuyerx
-wtlmohvmvejazxi
-nnwqozinrydxjobicvbufmunxvumqyxfwftperj
-
-szdqpmdslixhwrp
-wucjsywo
-likhwzvfvwtwbopeenjsduanitofusggpqn
-zscejqjjzmvyfdmt
-gpotgbvurhwxbtknhptvuyetvqvrccyfmvwennemofbcrvzrctdvjghuvrpqkyzvhsivykymvxgkrodppjrjxwlpq
-dvrzooiybrlqsghakrysno
-hcqenugf
-yqopbohbhzjtvckqlqdddqrmylpolgexsx
-potllcwblbachzstjukpzvavdrvxewqfntmlsxb
-ldimobhphviurpht
-mpckfzkgowuvcopksseiodhdvidpzztozsw
-evmzcogupfnzjdecibjttbhxcgb
-p
-borhvrplldrrpxakxvtr
-xalzeexcidtrpdjsqlvsaofvuaomfhyabkrenswswuelfrbbhysgmnxtdahttofkpxlimdlbwo
-cpwbbilnapqvhdczuzbsuhyildpapnvy
-szgmgr
-jaseoqpdgpb
-dbsshzhygdgaxtj
-qaansenmld
-vjlinstuzekrzkddgvfymfdqjfnorwxkawwtxmyyjhmbfywsmlt
-foeyrqupnjjkcjolfvivoowaqdrperfndelcqmths
-vtjisvtui
-
-arlt
-jou
-tcehlxmu
-usv
-txcump
-daxazimkaglflxzhxspafpffourkgilqmqyvisbhqicbacnrkgdlhojriqwhorue
-metztbqmol
-nxuqxoqqykfjrlzcwlfzzbbactesfgrjqjqk
-ypgpppxrsp
-gldakgtxiyhhuviajxmngbfcdbwuqewltbsvnhwbpuohvfnnnsihfpx
-slrbutgnukzizxkmqsswzwtw
-
-ogrglapgykaoswawizvs
-tpzxnijj
-ohviiytyzyzylwyiavtylqvufuppvtiofsffxlrktsxhhlpubdagm
-plzredziqa
-gtcjoexepvqjjcpvvxwhnwcklpfqjejpqzasitbcx
-fmluakcrlmbdwrzpdzm
-bdyeyrbdkuradrkslrmfzxuqzoxloce
-gtzzzxtdmmgd
-gyztyoldfcqwnnzbpfbjsxveibwtwyqaqvzhftzjibbjwcwxovqhm
-xzegpb
-avh
-y
-auw
-nfnheocoua
-unkrgttpd
-zaqebjcqu
-xglchjhtgdkliurrwdxezervqylubdvyhkorfxujqvcclf
-rbfnzqptfpjsugcmflzxjkvdgbodzmotsowskzouoyxhgvne
-ozp
-xvncrwabpxi
-nlanbiywliumdjuiishmoiczhboyqubenz
-chdmiacfgbylaqgcbaivmnzcmidltrentkwxdddngewpmghhmtrkjhcgcqwxclcqxwwdduakacfifkidqxjazjvzdzgilodmrsvfquhywpmwmwrgmsvqdoubyygmvsuablntgslowhog
-jygpenbway
-audunyqthzxyog
-ouwkrvoqsjoygmvgjpphnamwhrpe
-hzdnfbmillszuteqrnmqhluvttm
-caqelvgbtgqgazypdmmhzjwssb
-kfvdufa
-
-kqrlq
-wojlzujbiq
-grpiaahuvgypqppdeyosynvlxauouuympqqggqeigamhwibbirknulqnpkjki
-frzsdpsxhbknsszcecywkzscejgxtabaiiiuf
-wumdjvbxvintpoof
-lhgtysfyeucqoxd
-iwdqorvk
-sosjlnryqfdqp
-npvw
-mfxneewdjpysyegkrrvlpywt
-imxvjustnwylvfjdlrosguxdfqkjjshwcoteycqm
-mkcvibeoohkhvkodmmb
-hutskghwdvatcqvktluebndybamfrgmvwpzfngshlfbaalsahnltkhtgxjazrynn
-atyyfopuuwro
-qp
-fhj
-xgobhinfqzdmznaojh
-ybzhffcnmpqviptfycqrumhhnjho
-iroublfwvdz
-zvnx
-vr
-lcqfibsflxhesfvijbnb
-rbfcvjquflxmejtxkhbmv
-kcpeeuwgfbeqstzfxtkxpy
-uarpfqskveqocpnloouextvbsvaklinsozaqulqkzqierontwityyqnuwumqbkummtmupggoxftusuqzjwukcwcrdcawgrrnhcyzsmr
-fvznpiuvserpnhs
-uyatejmewmcdrqhspelmkajzmmvfzhvfxrv
-dgjdetjerxjxmbjeq
-jelgfsuldzigfcolymiypruhpgqfimanqjyqrjwq
-sr
-p
-ucjxavbcucoesut
-ooqawhp
-
-merxptexuskaltusyyaumnipkhkafmf
-hfvwqzkratbwrvtrhtslbkgksdlafuidfeihuidu
-
-cynitcnwnhxiervas
-wk
-rqnlgevdytfeoly
-qcdcwwjkwuzczdo
-vwkv
-dbkrxkxwnrlrooaxdukyfjoiaxsf
-sbtdheiheyhbvd
-bvtvdokultbxkxkrvck
-mtuuunkyrg
-wadfaaatjsibyc
-iukwztfrptgpdaie
-pjwnvpganwzjdnajxqetsyodmy
-
-hnlmyzwmjlyhbiqfrvnpsosmj
-qrckpn
-obmwebhdusgeaumgyos
-m
-iklkxibrxcdwmlzuvpfankzgcraxvfttxdqmceulnbrtrcesdynybdszypscekcjorcxoqnuomuqrpqqos
-wamdarabuoopndluqcyrowgsmomjokzjcjitgdcrdxtccgqeiobqkjqrlybjjrcpcwdzavme
-oxk
-xwkimuvivcykhsonwchhhyuaxdzvnbgcgpnrnjixbfefyqhqtxsxmcqo
-ovejfzorbugedvgqdqlyauopnknpgqqkgnscjcuedttjghiqhtlrgktpyzfxyjtwqweeiz
-t
-osxqzhsahwjfykvinngtlonmsdryvjnolxfifntskcljkngywgnsuskvesncuhgs
-irvncypoujoklwvxlaxbhyylyojllpmpirrvswohnjtcxmiaehcefqghzpnmobdbhycrysjxhuvoaqehlmzdrnwaaedzcgl
-mhlr
-zghroenkpgwkiefqapzegtjalvneuwwhxowew
-bldqnmxinyuslevghsktxlrim
-
-gjkpciwhzxuqs
-aqbqeizezjveg
-rjhwrwxacjuipcgfqdoulalkyaknaznjpqzauxz
-xauydjwqmbltemrmeefhdihfoksrr
-uioewgo
-scuvzdikypydrtumuihvbocvvj
-
-kdmmibnqfksocgrryeelnwpgyfn
-powbgaccyjpsdaoajolwhsonkcrizyftdcneyzvc
-e
-bykvjzzmeyn
-xiq
-hddsfdkjdnzjlscznagpwvqtqazh
-zlzrhibeevwgunkzyugelhgjlwpcbquvaqzdwxizdrmsyhaewsbjc
-vymudjqtfsu
-dwsyxkihhetswbuzgqujkb
-ynnmetyipnkbupwa
-maepdc
-zxzpugjjgvguztwxodcexvmdqrwkjeeljkhuszhgsmbreuvuxzszinlywdhidsyewuvpncgzrjsubwcjtqpbbhbqgmdpkkvsobxxqrlhpqfbsuuhruovfxtgdxhpcz
-vkmthzxiltdlnnhngmmyxfxz
-lozrzvcbwuywtcxvk
-mlds
-j
-ibispuaszewwvdbectsyubdupwxynrxcjswpsfdtegjvoxvdogaf
-rptbtgkzyknqcmvqnouzqwldskeyduszyioutcc
-cdfohowfbxko
-neltvx
-khitqjrrvcve
-rqclhfjaosgdnhtytbmbaokntdpsglyffszjcczkwaiazgymxsano
-hsrpkwhtaxsp
-
-xnaqwptdtsvyzipyikunvktxuwq
-slbxihpxp
-lgogcldxfpx
-yvheddsveimtbldaleesjhlcsabywo
-tj
-tjcbigc
-ocagqsxdflut
-gleiwwwugfpucm
-bboudleqiktrrrxtlsc
-uggmclocpbbrqiryholtnrqmaj
-sosorhzftnyemugnmlbqzsxmmz
-qxbhwlhdjuiddrquqqcvdkotffgtheslncilderubmshxglflls
-qqimwibzvvamciqnfmwgpaf
-q
-afyh
-ssbpjwuworvjylaoj
-ci
-ytzqhr
-htfgurttelnyttia
-azvjzjtlxifwhmkkgjcgfblinzfxkmctujdvrpsov
-iryawlalylzooln
-igotqresoufxxd
-jqamawbzrwvwhdtdcmkxxi
-tgebuzkapskxnzmmjyffrgqhsqzo
-wzvtwhqnycytugcdddzptcvjhany
-dtpyhlucexjdegj
-zmlpanpjdjrmbzwkjkkhrgyjfkmlvaolgbqularg
-hyvdiceljtcvlqnqefsbkxgi
-utaddghbfoni
-wyqxbpqcqtwqghihwosnz
-fgsivuu
-sdtyhkpsdufzyuypjrhlyigbwtlflndr
-hlgrfidyb
-nyravnjiynrqebritajwjprlriywwhv
-esknnmbhkhsqfd
-bnakjsvfoqdkbxh
-bjxjnkfsgawgudddnikswojhdikvanrxxqopn
-vka
-hipvfiggfyqymgvnuvhphmxwvgqlmxdeuerlvl
-kyrytukl
-woehxblpjthddlsbcpywdvogqk
-kvvfnswhozpyhikblnxwyglrdgosskrfjnkoloafbpvqa
-nhfjffpzwvpgwgxtxfzvixavxmlhm
-qbqw
-paf
-gbwapkgrwkcuhouhmaauetn
-omezrurclgr
-bgogqxyfmnqwzcevkfruy
-iwcujujzddye
-nfpscq
-tqix
-jk
-bzbg
-honhbxzkq
-sqwifrgnmesaceehsvclphytgduuzyeufnjtxfgyjkdrsyzpnrzsbaixyobe
-oiqtwrcavlzvqfxxs
-zcejvlsyixeuxqniprvbcr
-vgccrytynaoaqy
-fgkyca
-uovimmrkvz
-czmkscwia
-nz
-ymrlidichcmnq
-renonqyyxssupbsoiyivty
-ddzdceacjzovkntwgsebvpaikyveu
-cziihwhd
-mxjkbmwelawvrmulbagvwiqmc
-fycaznxyqnumrl
-rqkwlopkuvngjqytgelqsufpuraz
-wu
-zoxmblozwalgjnxlkieiatswfuolitwrcr
-eqldvqudyhysbz
-
-ddtmnicf
-kfdkmhnneooxytzpyqgyjlfmr
-dvzksxjikhzpkdmttaxphzrenyzptffm
-egttuifxibkbisv
-qkciwunkrhwvlbquztjdymaygrafwrblfzokdxbcjvd
-llxcdnabmpu
-
-tf
-vioigig
-shsadpbryjbcdmans
-euxnrhxejplathkhnwnt
-fucpefwos
-orkr
-
-fffzxkgczlseofkigiherbjfikbzbhxkfxfthflbtydgpgqdqjtyfrunur
-
-szvqmvjbmhppfkyzury
-nvkqlxnuu
-dlwkaoqhwrllgbizvlcesqzlsabmndmrysxeoykfw
-kanyuk
-sqqjrxdemf
-ohotnltpzdsdzdqmq
-kfugfojpohkcqsqptm
-hycms
-vtfglxqdx
-iouhzy
-evufzrezwqeqqfhhd
-fihvbevcnskuifj
-ewepgxvewiodg
-fjqiqpvhzlvknwc
-vtfgmavewptptglkej
-tv
-o
-ihvxzvnmjxuinpsbxlyp
-vrzhnoqy
-ydm
-jcwbzrcd
-xrqelzxjvmdxgttihaozwomjjqm
-hyznmgwmnyzfvzxhdfreqdtemuq
-b
-tiacsxziyrp
-vtnrezhqauiuqwlhskvfjsjycems
-dffvvjiiicbogpucsbqwpefeuejxbyuctmmdicnolyorlktazrlrkozgaqyq
-vjvobknczsrrsqymcym
-xvcpbwgqqclqrqyniqp
-hx
-qalq
-
-wblmhrdatqquxkwfntcuodzbfzomxdwpydvpstdggrahwdnamplvqwa
-ytehdds
-pcsievwe
-itevnxmjofdiyxfjsmfexaqptkyvulmnqmmblnsvtrxrc
-sasmivbouhrwujgo
-acmxmkhhf
-vhkbcscolqayfoaubcgdmvyb
-lyxlksxryzqorxlt
-vmfbgpklrqijioshwefewqou
-w
-osmcerdvsmfqlxutzzczfliqqtxqziuncthwlazvucqospxvioilfjxvahmdwgtxyfdvivm
-
-mhzjslksbdfmajgilizunxhoexlat
-gihuphetettpveqrcf
-mccpwssefliquiwqtyvlffc
-qyzxjjrwrfqibnlenycvltisuqbe
-ojzxxrwmwfofnu
-cimuerhxyovkzrvgsotoatillvoukp
-vkrepavhq
-rebxrrv
-yemwzmfvontfidffvoa
-oqdajxa
-oyd
-occlrvtj
-ofqrjpcyzktpcqjipjpdpgxvuu
-nkborzduapdexvm
-jmovihamsytrprmkf
-ybdzb
-gsmxrvotnwiznepactxxsrqquyiyaqapvnvvgvsukxlwrfxqdzslsncyulyqdjcmocyrcokiilrunrto
-moxikfdfbyrixvfulmdzrlti
-iouqefdcfurjqdpntr
-rvtfwhozfvvbjrzqdrdwvsbyqkzevbfgfwxvbuhljliagzq
-cohiqffjgggremjifg
-inozrmsu
-
-likaxufjknsvkfgtfbe
-mjlqqoej
-de
-sjjogjfaqixpbgtashlfumqvgwynftqnfejvdzjpwkupomvonqkqzaespegmerzpxumeykijqewja
-eihzomzfacbwtpezxpatkmqkgticmildljstjck
-exwtawvbilqho
-adlzvatueoxneecf
-zbcsawgqezaidilrnoejsdjcnpnkaianyopjcywz
-xiypll
-sgtjxczhrvsm
-dajekrkxtwwxjbpoyby
-ofhgtmrgyapvxjumiw
-rcuvugpwsninsciiawzxyyxmyb
-ssyrbk
-
-yatcrpvpsuztjwapsmmydumkjmhqncjtc
-gcgyplkdtgmllnntplmjjqnvfqxcefialhraaxvfkwcudndtqpjrptljhnqdooaapwi
-m
-
-mldwmszjmnfaemmhmyfgfpzoj
-mzyqvynphdugyxradc
-
-ghgmplyandsytbezen
-yfyyuvgynnisvnxjwhtsqctwvu
-vjunnhznevbetgoihxaqwretoguhcpuosmoptzgbmttjqcarllzbwsitrxmqfxtsaskgvbbnkfbh
-nrctzyxrexlwtjsdxecgpzeuljxplmxlijffevbkm
-pevimejnff
-djsyozebjoaylwpkvdlhfetdxujjjgfvlfhdp
-ajitkmqqbzoqjtetszgskkqtvjuoyheaxdfddyfgvbfwca
-bircvmigg
-tqdxfddiwhdzweablfqpbthrywdzsumzvohagviwaylrpklvuirltqoefofcrcxgxv
-einnmncwrrd
-fraaboekfsnfktchaluh
-jqdtaeruuclzcjhqoasdelvtsfqodiniyxhbgvejmfmmzpkouxwfmbcel
-nablonpolng
-vxxlqtiunahravbuhjpc
-zullytvuxqdjrsfeovppekdhbolrgwrkhecrhfnsynizkbeyqzzpfcwragrdmedyzcyt
-zvqqvcsuglehe
-zzucvpdvixfsmn
-xifhnqkgwfxgvsmkmfnuzzohdwrxkymucqb
-ksffsnsrg
-pvjlbjjr
-vpdq
-gwfizmusfjlvssoljlxeeuewzmwudabdannrwmi
-gbepmx
-zomdkssnwbcnqtwwv
-
-ezfm
-acwcv
-x
-vgfi
-kmh
-rvji
-hs
-bzszqdgwehleodmvglmyqhvhkqhoekmxpmfqqawxgcz
-oupzfkukuojimizsjn
-wpsgtyydmlunwwfsbdvllmtdklofbwjvmkpqg
-kfz
-prbuhdgxpqjffksqwfqrbedkvlufgwzqkfblbqmgtfbzfdzturrcqswmzbjcyxtmsfoysp
-dpsptamuedvrnrvxxcygdnswdbjcbflmtzwahtgplshvye
-lbxvktjfxpcikiyrg
-ojqtyoyiehcmdrunuxjsvbsxslulnzhkfzwi
-ktwqhhcdemgxdenmvhhyoispircduujb
-pnlajarbgvbpwplbhscnwmldvdvrgdkfvlvxkqnzscbfcvmwos
-rxuybcjwhkgfjeomzo
-dzezuakzpdttbxkgfgc
-p
-tludgogeacmhjfqscseebivuoolrqehiiehwthfqcrejgniqckvwovbnxjeoq
-dkhpvmqhfynfuiatcddrsurcqzulvrybqxhlawxqmwnlwvoxwrkfqzdh
-ghcghorldeuhphoubkqktinmbjaxno
-ugdovxixnj
-nmnhwzwuue
-nxgojcttjnblfqekpobvg
-fvlzgorqtpleaeqafzwgqqosqsfdvsagafwv
-bzjfvuwmfkwgntsbfierqqf
-qvjeszlbstcngpdhvnhbsaku
-fjjx
-dwtfmpxlimhufecwlwfluaxkcyyikdxiuwemlxkeaegvuvoznsbcqrg
-tkdwxbkdcvvmxrqwdnziphupfgle
-ehblnfvrmufp
-uvp
-njukwejsunszdgpv
-xqjrzasbw
-pkii
-k
-vxtpp
-silygbvnotqydgonmvkeankpyrockqyt
-cbe
-zxnwhihgtfseuakzxynrlprntdjvkjkfntqsrwsvkfxsdstyxvmkkafpismdiaebyfmadsequdcletzatwtl
-ickxapprqyoe
-zgaykn
-cow
-yenlqoaillmhlvyeigygcnlhiox
-u
-rmjiuik
-tx
-b
-
-yobkqqnih
-hexbuihtqywyagcqpdhwjjjdyqwbnunzejsubvbzlqmkkxxrfz
-azxcbogbcpfvcrx
-bvkpn
-wtgp
-wffjrppedcqkboqmsyyzuvxqrfyrvrzaqjokojexauplcppoygrcmqsvl
-
-qwwwzclymwreouybkduoifmrsczd
-izqbulggfmrnykgittyyaja
-ptwbdhjogitxmvasxv
-dujuwnqzxxidcsrodeglled
-zfllsmmpfyyljbfcgvpxlxysnippgv
-klvybexcjxesnskoywqyfbuxdvtdrcweinqdzixqee
-zbmlqgygheczawlygzbxucunxxabkebcduiroagecdulmwdnjtqluyxsezubll
-rhoausn
-odztdmtacnfqswspthyfcylot
-s
-ygkcihhti
-zgfs
-jtu
-uymdk
-mkdu
-eaztsvvmj
-gfagjznpnzfbpvykql
-nzgdgaqrmjjevzehqhvlcwrxpfebywfufspnuzwmgesbdiumuqddgtihuvjo
-ajimwbiu
-j
-avmonqukimyzmfqexdtmhaan
-rijljxyhxbkesqnwqlmhmlpmmmtuv
-sl
-gwwfbxktkfvtkwccpanwdlqoozxoohhjzht
-wwhbglurebhajucvomfgiblseoyiwzpjjfeljj
-ulhdhncqdkndesotm
-iclfsafcmdroaqlzthoaaxjtxmvmfdyrrcktgsvumahujtgdspsrwyzjrgmroa
-fukwkwxamwlsq
-ktti
-tdfaatkrnozsxqbxmcachukxuhxtgsi
-evnlyxsdcfwwypnsfyulnysill
-mtsavczdjbtjhuoxsrajmaglr
-vkx
-ntlb
-sfqdpqisjjqhrgmokxogcrc
-gcycqovprshex
-pfvuneumz
-kvulhpmzyfvsisovzsfcplhtdjwwkhkoe
-jkoiltm
-bwpbvqswmgqjgryrexxsrfcpf
-ykioqp
-a
-i
-cjmtxkxocwsafiqucxfy
-wmezhhduynddxlpusjifvn
-fysxq
-ozznm
-sezekwmzxgxsishgnlyhkoshmlvc
-ncotnm
-dmc
-sjgxhfjztucuorr
-bpb
-xtg
-peljrjhfyncaw
-chrdmaguntbhfi
-gyqzkqswsastichcpreqokynmiyopcc
-xxgvjasrrzhzibshzwtljuiu
-qrkjgncyjmxqmktbaskbjzmfxxzdbdk
-lednmktqkmpkfjshspqbbppfyerm
-
-rtvmlzplv
-yqfpihenvonzdwq
-reammp
-xqsirubsilfsfofqaiiyswinshdrwcd
-pshsewgvozdwn
-xqaaqga
-prrtuwjaqzjtgtnnwsztplrmivccoqfxtnxyevvygyd
-onimykyg
-faabkbxbdcou
-bmztkmzhdzbicd
-vcqcsxhbiocrglqf
-
-rqzcmhuzxzfgqjsbgk
-zvfngzevedhiwsktoaogce
-dlinngncdfknljaxocskedhycvfqvmprknviodtsydmfcqobfppyfxotuwszmkzgb
-iwavn
-
-elvpforzaxprxxvgpemaljtvzprwwdrhlmzkskvracprvekjiajcyqjzhkowlnqrwzn
-gtyhyal
-whctyskmlotj
-mnyas
-k
-ysllxyfsmktm
-gdncgsaxexknhfzbavkhjfigcjamlyfpwsk
-
-mqig
-fncowlslkjrdnldubwlfmuafseqafsubsem
-tvwejzkmnyguxx
-xrwnbtlj
-seamrdyep
-vmqucjeicjowuqwfukctcwizkjsbfixuqnccozbfdizsrpwzqqdihfwaqrbpufcqhhlafjietxckkydwv
-soeaigzkoqllt
-kmbtywslgozzixzophtegveyikh
-vsfknwjsjddfebvhlaggfizarkhavcgcgnh
-y
-ofnsybykohaqhtbneas
-
-sm
-kklok
-shmgdxqtppzmzvnwmyjvihtyxugqvmc
-mv
-tlxiezxpqcnzqfre
-jeixgewhqynciahrvzccjczhygmkyxekpzegugmmknc
-qebihypaytrhmxubru
-kvsjmdwyclylrrpmxt
-klmrlckkftpjubrj
-bmjasppsvjmzt
-mswqyaddhvjvdjnrw
-mikj
-xvafxwuvygwsgelv
-lnyvwrmgzpuak
-dxvtwwfmcjzzhihqylcte
-wuxpnityueervxqmpuojybbuagxyaemfbtmk
-yoacyjncohtinxmnolyhmeebobs
-qfepeoskdpcywtfgjzldxnyg
-
-vjbjtkcggfywuulinonb
-vcdiifzs
-cbafqmurghwvkecofzxaprwwhexhaufunznsvurzinopljhxtk
-rdhzyvwrembvbgtdh
-mvqokfdnxjhdsgxfygwyvioyoakzazrnfeixheoclapbpykjfqncb
-xeavzjplerysx
-vmxlizsppyd
-uv
-zyfbxzhpkefqdyiecpjkpsjqftrjyiukcvifpbzwneuzioclyllowwbub
-lxvdbwyzhwyzbouyitknpeplzat
-utqtrfreckowcyllk
-rbrpabncrrsgci
-wwf
-gfvewggnuzqlkqikoe
-mmcwf
-iolxuqbvzjv
-icqmbhz
-jqpgw
-rrdi
-l
-durhyckfffwodgtcmhbycnfyrlnolhznccebzgwvcuqlokcfxwrqctxlujqwnhgbbnucyyowhslirwnlyjpqihhejkakdbicyvxcqklfqurwwhpu
-ecweleougvtvmrftaythbdbdlqsplz
-vg
-
-
-ifglx
-yjgfxw
-ekuxiqmjixvovfspvrodrpkroujfqrjwozrzsaylpgnspzxlpdzcqbqwqzdsijldqrhp
-p
-bmkd
-pllvritkdyjqxclceeqbqesbbikvaigdnetiowvpuipy
-cmukejvpmjnykycoqqzbiqqqdjsbbgrfkkgzmh
-sxoaosqxtynpzoo
-qjupwp
-mpfuemve
-nfspwjvuaordf
-sxhcccteasyigzojrlovzy
-ragxrpwbxlbh
-k
-rcsfvzquugz
-ci
-vwfpsgocyvgtqjozgupbwwdea
-youttcmdizsq
-iwvt
-gpiqetfahvjmoaccvxwqxrvjxnd
-da
-xl
-pyg
-wqljoygxqbjomimlonglfxorjyhgdbzwfbqjqalrjgktbj
-ee
-csoc
-fhpwxvdcdovorfdn
-ahis
-lxgyaxuftfqritnrvpb
-svjeayuswymqiimgzldgwksjsoypisdmp
-hzgzkhnszgowretvrkvqkavmxmlbhjqltdontoolmitnvilfprrmrtuxwvh
-fxjez
-ngherovurbqjfycewycetscoqgiqbsajoiicwkvlqv
-rpspvgtlfqgmxcdoojsxofbwbuioanqvvl
-jwbrjfdcyhemrfdadjlttulvmaijglfkos
-zonalevayyqa
-trki
-sqwzlmzwzhfpwobsiaixmzpguvkjdeamdkofjqfjbijprpy
-jgswugafuwh
-ti
-rrtwvjm
-vcthalnslcmbwgktyyrir
-drpehhobizfu
-bjiwhqdeuaucgbambrsrbsfjlivmqgnf
-c
-yywaviefeioog
-m
-kwprwzmkmxrouztjrnblstxygehyfikwwmtwlqmdyzyzh
-aqwwsrhbkhacvplmcrvv
-ixzaoxowoltrxlmfvc
-ek
-kqd
-mrvuieyltraovp
-upyk
-ewuyv
-xzrejlmekhfgxqnisstygvy
-iphrsqekhkdmrpvyygoys
-bkgh
-utwebbqjqfzqsxzhkdnghudisr
-dwaxjmnnqobvnmpwobnnpvkpargn
-dgareovqlfcrsdgqvzlhthnbklx
-jxq
-inyxsgcfcipxorzozqacm
-xuvfbpkz
-x
-o
-hebtpwwgmtc
-vvckvvdfrbriusqkruhswijhckvhfwiuelfreydahxscovdlzyjipivyzpaefmgojtrcfcjjglka
-afpjgaoqygeki
-drzvzmcrpa
-rwkhvptnrriugstwyfdatghvnjmgevqljxzupfcoziuakqeagoeeuqvfwjrxjijgvkhvyvqyhtukf
-brmmlprgivdchuaecdftac
-vyxdbugptmjkyvvhnnyxhblrmjuuyokrgkvimaimgnrssknbslonqmwnksgbdlfxgkuhdlijxybcauywcaplsfgubipblatysuacjscxkuhhuexgcxlhcauxuldmkcyhtbdqhahpkxartcihhwvxsuhzsvrzyaqwwwygrxcwye
-qtdrhdzgnfdsraszew
-wjuu
-jhltofldcvfbiefajzsrshmlobehwkyvowshsclclkckk
-hxmtskawlsrghfzh
-pdkazahnlnmswmjwnubnlffedijvapzagqdgocgneiblyyyryheikuzwje
-oeooykojwkgopb
-muutvtpffmsixlqebflqfzechomqlgpbebfptlbnctmpw
-yttipzjkezgfjxpoiu
-hvlihusjxfxntykbaheovzqnuincncib
-pwfpmkxtaleugouujanbdmrshxqxxgbvpsklgulggzvqvovrssrawgmmvifgsrcbodqsaevlrqeyecprshuwawk
-f
-itvwbvmwoytqwm
-ntrgcxpaseswnuafmwrkmlytkaezgdksvesnugnajxphmqhx
-qvs
-sldpyquulxou
-ulvupqdxzp
-
-vxae
-xvslotqvzhwdos
-kezvvrdrkendyfyyme
-peqwchypappworowoubnarahscyoosxsqpblbydidecqac
-kxyfguudgqoziumnevh
-etkmatwteahwbynxvbejncd
-hwiuwyteyraynpuve
-nvtpxs
-wpnkmsasklcwuzzpqthoa
-djhm
-tconvqvxwnndpintprdrmmwjosrajlfnpizoxxptipaktta
-dxhvqyxijp
-otuoxggz
-hkgktcstjevcfhemwglcbttyfednwko
-krtquwjeyefuiboupoyekhzccunwiaehpohnjddcfladokiquiljnrx
-akzlqcuvmqqzqosjlpzxiaskbnbnhnncbjiamssnfjdtwxhgprzrhfufgmcsox
-ajalbsfzscpmodbzckhydul
-ktuvwcqddu
-oc
-
-
-juwgjalejbkzqhefetnbfz
-rhuqbgqeyzsvlvtl
-mwar
-xcsn
-ikeruiaycbfthluhfyglasuaruymkarhiwin
-ubyopuyqaxkvtaaqicsf
-hbkrq
-li
-qvqxjggrvwoylfjxgojra
-x
-bmzsqzzswj
-ftscolqlarfulcnnousbbtsqiowhfpoeurnitvlesxetlpunxjuyfzgnuniotwnq
-q
-uhqdlmrghgwx
-
-zrtyyaz
-ojpefizdaeguwm
-bfnxyqqdq
-mdqhqzjnuvsupbkxhdlbbcbzoiaksxvxbptdcqfdcwrunujpmnudpfkozyyolxju
-yconfyahgmuohhvse
-bdpsqyqvbawmnjcen
-efepeumzl
-xxeqzvct
-tcligoqlciadf
-nhjfsezomkgakpsqbifddrfjaasojbt
-cxubsyfpvsvlxsaykkujhlxsxsfwhvltvcynnytrnq
-
-e
-uabwgontuqumaqhqvxeuuwj
-xsxdhvspxsjqordvc
-eoxcyxjmkehcrej
-dy
-fly
-rztzdjtxpoqpcxhylsgvsbuaizvuf
-rwdaxrwoatoooueacdttzpquvipkcfwatsurgsqcoegepcuahnshirsvna
-cgmmlzkzygxdqdyyjvbqispcrsqzgxakuvseavsqnkomlimoybhudxmeksrwyl
-jfcybkbsnqnmrrwgyagczi
-rpgavuzucgqqhullvjka
-qy
-usegebviynud
-znirmkxwvpb
-mttraj
-gqoparjbbhsuymxuahxfitsuazjmrldabwhppkafmmg
-r
-qgvhnufruxytnqqaefxnemddtljzxv
-uydoueczwubvqkphcsecihzmmeyogadfxtpgfkwvlljsqtdkjauutckoguxij
-eryjbifyfhsqgxfwndzddbowmx
-nvxothgqfiff
-ddhfbqqqttqtr
-jghykmxmkqnskjpgmxpuljbdvtgaodf
-isdtiffzrxlupvicnhxb
-iqo
-wcjeprzklrvqmjlfzvaaizpfofuolmxgnzfqbslliryjhyyfzcohahhoycj
-lmkmbdnsicifzwmf
-xihazrrru
-hnohxuqvzbzcpt
-mkeanh
-fsoiylvchzdmtazogz
-utgunqvofxnavvcnxbestyeyqletjumupluamrkiazrzqpdfdv
-cds
-
-uxxzcjgjgmseffkubyfmz
-
-tbqtrmvjp
-d
-hpuimagaicxfddqz
-mssnfwmkbmwswzzoeddrckseimrxstvyrmhqnfhgwltxcpsohqxobkzjxlckrhkhhoukqsntztfyabpkpwmadsvccksqib
-hmu
-j
-mtjmgl
-xzrgxeipgrmhjydmgipfmqigbher
-
-kqsxtrdrkdpexveuacdqcjcpahuznsufghazbpxtgtigelgyx
-y
diff --git a/bench/src/data/regexdna.txt b/bench/src/data/regexdna.txt
deleted file mode 100644
index 30be920544..0000000000
--- a/bench/src/data/regexdna.txt
+++ /dev/null
@@ -1,83337 +0,0 @@
->ONE Homo sapiens alu
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
->TWO IUB ambiguity codes
-cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
-tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
-NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
-cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
-gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
-HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
-tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
-tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
-acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
-tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
-gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
-accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
-RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
-tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
-cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
-ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
-actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
-YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
-KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
-aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
-aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
-gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
-tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
-tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
-ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
-ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
-BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
-aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
-tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
-cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
-aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
-tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
-aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
-gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
-ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
-taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
-ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
-gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
-gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
-tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
-tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
-taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
-cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
-aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
-cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
-ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
-attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
-ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
-attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
-tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
-aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
-cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
-gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
-attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
-BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
-DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
-tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
-tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
-tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
-taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
-aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
-DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
-VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
-agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
-gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
-tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
-catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
-tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
-aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
-aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
-acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
-tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
-aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
-acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
-RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
-RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
-tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
-gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
-YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
-ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
-ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
-gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
-KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
-aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
-gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
-taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
-VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
-NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
-MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
-cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
-ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
-tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
-aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
-actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
-tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
-gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
-BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
-aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
-aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
-YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
-aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
-cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
-tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
-tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
-MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
-taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
-tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
-RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
-agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
-NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
-gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
-aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
-ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
-cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
-tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
-RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
-tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
-gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
-tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
-ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
-tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
-ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
-BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
-gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
-acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
-gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
-taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
-acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
-tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
-catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
-tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
-atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
-ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
-ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
-cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
-SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
-VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
-BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
-NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
-tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
-ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
-cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
-VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
-atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
-aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
-tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
-RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
-gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
-tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
-attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
-atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
-cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
-NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
-ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
-cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
-aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
-agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
-tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
-ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
-ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
-tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
-taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
-tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
-YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
-ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
-tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
-ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
-attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
-atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
-YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
-gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
-MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
-tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
-ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
-aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
-BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
-tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
-StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
-cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
-atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
-atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
-ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
-gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
-tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
-BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
-agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
-HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
-tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
-aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
-catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
-aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
-tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
-cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
-DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
-gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
-tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
-atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
-KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
-tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
-tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
-taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
-NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
-HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
-ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
-tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
-cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
-ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
-HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
-gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
-BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
-gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
-KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
-cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
-tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
-taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
-gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
-aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
-acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
-RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
-attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
-KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
-KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
-gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
-aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
-aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
-ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
-tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
-aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
-tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
-MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
-cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
-caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
-ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
-acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
-tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
-gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
-atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
-aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
-NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
-taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
-aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
-ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
-DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
-tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
-aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
-ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
-ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
-RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
-aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
-aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
-aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
-tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
-atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
-BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
-gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
-cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
-RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
-taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
-aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
-gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
-gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
-aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
-gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
-ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
-MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
-SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
-aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
-VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
-HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
-agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
-gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
-agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
-tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
-gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
-VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
-tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
-MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
-actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
-WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
-tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
-KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
-BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
-attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
-VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
-aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
-tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
-tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
-tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
-VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
-tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
-ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
-tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
-WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
-tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
-tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
-MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
-tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
-atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
-aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
-aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
-aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
-YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
-WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
-ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
-aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
-ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
-gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
-NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
-atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
-tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
-aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
-gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
-gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
-tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
-aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
-ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
-tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
-catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
-cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
-aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
-NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
-ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
-RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
-SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
-RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
-agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
-gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
-MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
-aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
-cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
-ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
-accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
-tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
-acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
-SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
-tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
-gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
-attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
-DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
-aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
-tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
-ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
-ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
-tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
-tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
-attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
-aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
-cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
-aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
-VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
-catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
-taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
-cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
-DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
-tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
-acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
-tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
-YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
-cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
-actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
-KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
-WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
-ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
-aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
-aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
-agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
-NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
-taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
-RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
-aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
-tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
-aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
-tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
-aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
-tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
-DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
-YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
-tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
-ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
-cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
-atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
-cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
-aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
-acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
-tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
-ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
-gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
-ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
-aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
-cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
-MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
-atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
-taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
-taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
-ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
-cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
-BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
-tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
-gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
-gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
-ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
-aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
-taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
-atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
-atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
-aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
-cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
-tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
-aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
-acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
-gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
-gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
-gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
-MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
-cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
-agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
-taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
-ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
-aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
-VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
-ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
-tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
-tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
-gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
-tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
-DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
-acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
-aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
-gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
-agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
-aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
-gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
-ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
-gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
-SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
-tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
-aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
-MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
-aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
-ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
-aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
-YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
-aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
-aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
-ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
-atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
-cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
-attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
-BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
-aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
-agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
-BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
-agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
-KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
-attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
-BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
-StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
-atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
-HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
-gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
-gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
-caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
-gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
-aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
-aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
-HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
-gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
-ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
-taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
-atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
-gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
-YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
-aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
-tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
-tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
-HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
-gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
-SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
-HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
-tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
-tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
-caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
-atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
-ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
-aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
-acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
-aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
-ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
-tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
-actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
-cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
-ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
-tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
-tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
-YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
-ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
-aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
-DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
-tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
-ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
-atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
-gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
-MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
-BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
-tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
-MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
-SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
-cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
-ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
-ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
-cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
-attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
-tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
-MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
-tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
-aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
-KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
-cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
-YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
-aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
-tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
-cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
-ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
-atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
-agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
-gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
-ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
-ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
-aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
-RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
-atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
-cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
-SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
-caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
-YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
-cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
-RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
-aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
-acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
-VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
-tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
-ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
-gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
-tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
-cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
-cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
-WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
-tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
-tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
-HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
-caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
-tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
-agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
-gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
-HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
-MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
-VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
-ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
-aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
-WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
-tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
-tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
-gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
-ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
-tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
-cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
-cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
-ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
-taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
-HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
-aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
-ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
-tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
-tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
-tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
-aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
-tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
-cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
-VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
-HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
-gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
-aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
-tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
-aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
-RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
-tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
-aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
-atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
-gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
-gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
-tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
-ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
-ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
-tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
-atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
-ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
-acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
-WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
-gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
-aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
-ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
-tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
-gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
-aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
-caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
-cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
-tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
-gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
-tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
-cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
-attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
-cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
-gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
-atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
-gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
-atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
-gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
-aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
-atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
-gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
-atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
-tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
-tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
-taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
-tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
-tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
-gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
-atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
-taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
-NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
-VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
-gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
-tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
-aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
-tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
-WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
-aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
-aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
-taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
-attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
-aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
-HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
-HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
-taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
-gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
-RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
-gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
-ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
-gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
-ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
-VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
-gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
-tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
-NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
-DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
-BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
-atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
-ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
-gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
-ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
-WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
-tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
-ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
-tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
-atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
-aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
-RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
-atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
-acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
-tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
-ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
-DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
-taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
-gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
-KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
-accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
-HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
-cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
-atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
-ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
-ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
-tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
-HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
-ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
-ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
-gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
-gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
-tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
-tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
-tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
-gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
-aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
-gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
-tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
-aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
-taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
-aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
-tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
-ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
-caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
-tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
-aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
-KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
-MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
-ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
-DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
-tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
-tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
-accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
-MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
-acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
-aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
-taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
-HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
-ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
-tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
-agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
-actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
-atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
-DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
-cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
-attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
-VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
-VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
-ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
-tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
-agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
-tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
-tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
-ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
-RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
-atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
-tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
-tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
-acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
-VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
-RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
-caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
-BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
-ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
-aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
-atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
-tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
-gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
-KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
-aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
-atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
-agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
-caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
-cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
-tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
-taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
-SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
-ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
-tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
-WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
-cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
-VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
-gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
-aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
-taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
-gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
-ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
-WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
-tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
-gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
-tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
-tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
-DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
-tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
-KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
-ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
-cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
-tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
-tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
-ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
-ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
-ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
-ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
-caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
-gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
-tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
-ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
-YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
-YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
-HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
-VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
-BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
-tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
-cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
-aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
-aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
-agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
-ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
-WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
-tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
-BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
-aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
-aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
-ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
-SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
-gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
-catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
-atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
-aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
-DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
-tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
-aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
-tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
-tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
-tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
-atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
-aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
-ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
-HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
-aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
-aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
-atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
-ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
-StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
-taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
-ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
-acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
-HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
-tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
-WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
-gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
-catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
-aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
-gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
-gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
-DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
-KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
-aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
-NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
-tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
-actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
-ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
-aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
-tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
-ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
-MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
-ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
-BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
-aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
-NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
-tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
-tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
-ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
-VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
-NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
-YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
-tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
-gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
-tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
-MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
-gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
-KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
-tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
-NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
-gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
-tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
-BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
-gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
-ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
-attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
-WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
-aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
-RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
-RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
-ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
-atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
-cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
-cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
-DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
-agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
-ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
-SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
-ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
-ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
-gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
-atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
-tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
-gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
-aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
-acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
-VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
-DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
-ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
-HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
-MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
-HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
-acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
-ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
-BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
-VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
-cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
-ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
-aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
-tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
-aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
-KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
-gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
-cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
-WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
-tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
-attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
-tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
-gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
-cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
-tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
-tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
-StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
-YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
-acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
-atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
-MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
-aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
-tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
-aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
-ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
-gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
-YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
-tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
-RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
-atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
-aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
-tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
-NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
-KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
-aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
-aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
-aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
-HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
-tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
-HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
-atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
-tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
-WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
-ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
-aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
-taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
-tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
-SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
-ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
-aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
-acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
-acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
-agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
-atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
-aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
-tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
-catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
-gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
-gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
-VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
-aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
-BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
-atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
-gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
-tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
-tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
-acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
-tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
-tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
-ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
-cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
-acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
-VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
-gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
-WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
-YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
-VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
-cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
-gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
-StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
-aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
-gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
-caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
-ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
-BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
-atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
-YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
-tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
-ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
-aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
-MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
-aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
-tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
-tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
-gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
-tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
-tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
-aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
-aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
-cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
-aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
-aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
-cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
-tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
-ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
-KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
-tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
-atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
-BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
-acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
-cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
-atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
-RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
-aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
-YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
-atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
-attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
-aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
-VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
-tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
-VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
-actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
-tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
-actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
-tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
-aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
-ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
-KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
-attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
-tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
-ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
-gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
-aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
-cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
-aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
-attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
-tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
-gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
-ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
-taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
-acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
-ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
-RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
-aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
-ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
-tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
-tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
-cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
-KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
-tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
-gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
-ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
-aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
-attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
-ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
-aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
-aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
-aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
-gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
-tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
-aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
-atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
-ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
-gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
-gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
-RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
-caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
-aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
-tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
-tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
-atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
-agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
-cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
-BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
-tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
-tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
-BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
-MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
-atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
-agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
-ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
-cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
-atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
-gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
-DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
-gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
-YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
-tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
-acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
-RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
-aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
-gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
-ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
-agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
-agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
-aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
-cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
-catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
-ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
-aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
-HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
-ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
-cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
-KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
-aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
-RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
-cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
-HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
-YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
-aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
-MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
-taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
-tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
-cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
-gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
-cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
-catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
-NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
-tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
-taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
-ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
-aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
-gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
-acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
-ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
-taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
-BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
-NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
-ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
-YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
-NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
-ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
-taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
-cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
-aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
-taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
-atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
-attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
-agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
-tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
-tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
-ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
-cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
-taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
-taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
-tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
-aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
-gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
-agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
-MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
-tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
-cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
-aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
-gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
-SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
-KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
-tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
-SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
-YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
-caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
-cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
-tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
-gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
-caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
-ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
-StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
-tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
-aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
-RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
-gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
-aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
-cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
-tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
-gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
-aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
-cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
-aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
-gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
-gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
-tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
-aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
-WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
-aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
-gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
-WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
-cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
-agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
-gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
-WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
-atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
-cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
-acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
-ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
-tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
-gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
-taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
-gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
-gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
-atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
-tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
-DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
-NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
-cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
-ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
-aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
-gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
-NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
-StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
-aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
-tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
-atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
-aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
-tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
-ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
-gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
-cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
-HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
-caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
-catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
-cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
-tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
-MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
-ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
-gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
-DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
-ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
-tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
-attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
-tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
-cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
-agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
-NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
-gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
-attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
-tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
-ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
-WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
-HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
-agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
-aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
-gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
-ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
-ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
-tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
-gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
-tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
-aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
-tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
-ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
-agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
-tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
-agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
-gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
-tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
-tccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtH
-cttcctBatcStVaactaatctacatgtacataacDgcgaVttataagcaaRWataattc
-ggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNa
-ccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttN
-taagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctac
-tatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatag
-tggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMt
-cagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacata
-aagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcg
-ctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattac
-tSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMat
-aYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatatta
-gWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaattt
-aVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaa
-tacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaD
-agWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaS
-aatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVa
-gatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBa
-aSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaaccttRtatNactM
-tcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWY
-BggataatBactgaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggc
-ttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDtt
-ttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactat
-tNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttca
-tcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatca
-aaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatca
-BgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacR
-SaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacg
-attgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctc
-gaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacc
-taaagtcactttcWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRgg
-cgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaac
-ttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgt
-acatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatc
-aagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMtta
-attYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtt
-tgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSS
-aagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgct
-atcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtag
-NDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataacc
-NaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaR
-tttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagta
-gatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNg
-WattatatctSttaScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaa
-gtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatag
-tBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattg
-ggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaN
-HatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVt
-agtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNaca
-gMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcat
-tggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtg
-SaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaat
-McaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggY
-KRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatata
-cataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaW
-tRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRta
-ttaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBatt
-aatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaa
-atatataYtacBcattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaa
-taagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRM
-gatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggM
-tcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBV
-aaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaR
-acgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatg
-VcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaagg
-aatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtattttt
-atYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaN
-tcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaH
-taaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgac
-KaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNta
-tgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaS
-taaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagtttgcctatRttt
-NtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcSca
-ataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaD
-MtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccB
-ccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagat
-aaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcg
-tSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagat
-caHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRa
-tgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatN
-NgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYag
-tRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNt
-gattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMa
-tataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaM
-tNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWt
-ttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgca
-tttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggca
-tYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcattMtatccgattag
-gtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNM
-atcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVacta
-gaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaagga
-tgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttg
-atWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYV
-tttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNg
-cgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcact
-ttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggt
-aVSaagaattattcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagt
-cttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaH
-ttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaN
-cgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaat
-RMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVat
-SagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDa
-taKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDc
-MaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcc
-tgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtV
-tNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttH
-ctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttB
-SVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVtt
-atNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYta
-aatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWa
-ttKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVta
-NtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBta
-gVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagY
-tcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtc
-aKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSa
-atctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYt
-catctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcac
-MatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctat
-ctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtccatttcagctactc
-cacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctga
-accataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNta
-ataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgt
-tatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSt
-tBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaa
-aDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagct
-tcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgatttta
-tctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHa
-taacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctct
-WttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaa
-aYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtN
-tgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcaga
-tVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaa
-ataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRgg
-YMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaactt
-WgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaM
-gttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgt
-KgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaR
-taaattaaagctKtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRac
-attgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagt
-aaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttattSatacSatttR
-tBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacat
-tttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMctt
-RScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaat
-ctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgttaNaacagNWtagt
-aNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaa
-aKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtata
-cttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMg
-gaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagt
-tMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaacctt
-ttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatccca
-YtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVt
-DYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagt
-tDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVc
-aacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDtt
-caagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagt
-aaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatg
-tHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccg
-ctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHta
-BgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgg
-gtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaW
-taaggtacaDacaDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDt
-aWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMga
-HgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataa
-tttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaH
-ttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgt
-tgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacac
-McaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactD
-DctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctH
-RtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatga
-tacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBat
-caccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRK
-ttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatctt
-DacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKa
-caVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatct
-tatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaa
-gaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtg
-HacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBa
-cgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatc
-tataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattt
-tcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgt
-gaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYacc
-agatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtg
-atcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaat
-NtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaa
-atactgctgNcttgctcatatatactaDtagctagRcataBcgccRaacaagcacaagta
-HYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcSt
-HgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWatattaccYaagWt
-gaataatgatttgtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRt
-agtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMc
-acKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVH
-cDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaat
-taHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRH
-acaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaN
-tgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtatt
-KHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaa
-cgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSat
-cccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcg
-gtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagaca
-YttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttc
-tacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVa
-gtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtN
-aRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVt
-aaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattc
-MttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaag
-tctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgS
-actctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctg
-tHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHK
-BNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaM
-ttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtc
-aatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatW
-ctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMt
-tVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBY
-MggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacN
-acacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBta
-agattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaag
-aaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBct
-tatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatg
-YYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtct
-ttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBca
-gatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBg
-ctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDt
-NcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagc
-tatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYc
-agcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcacc
-gaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatc
-cggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScS
-agcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaS
-gattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaa
-ttRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatc
-KgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKa
-RaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRcaVataattKatt
-aaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtag
-SttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtc
-DcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaa
-atccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNg
-gBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccata
-ataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWa
-tcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSgattRataYaYata
-gaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNN
-SataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBa
-tataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagt
-KtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBac
-ataKaatcggWtaccagMtttcKgScgcaactattVctHScccaacccHDtgttacgttH
-VaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggW
-tatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgt
-HagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBc
-tYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctata
-YMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRt
-SMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVt
-aacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttM
-ttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgc
-gtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaat
-tcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaag
-StcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaH
-gtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtc
-RttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgN
-ttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVa
-VtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaV
-gaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaa
-ttttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKa
-KMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtc
-ttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWta
-aWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKa
-aaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgagg
-aaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggt
-acatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWB
-WtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaac
-VYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatcca
-tBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaa
-aatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataNtattcVtcataa
-cMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtat
-gcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStg
-MtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctat
-aKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtct
-taatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNag
-YcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacB
-gVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtg
-gKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaMgSattgtaccta
-tataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatD
-aatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHa
-ttcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaat
-taattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccat
-cgaWctataSttBgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttag
-ctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaa
-YattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgata
-MNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBt
-cRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVa
-NctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcat
-RgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgt
-NaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVa
-attBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHt
-gagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctac
-KgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWat
-aacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatatt
-cKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaH
-aWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSaca
-atKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattc
-ttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaa
-atttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttc
-RaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattt
-tttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaa
-gaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattac
-aNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDa
-BBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDaca
-aacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRta
-ttVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaa
-gYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDtt
-cVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttct
-tttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgK
-tcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaa
-YWaSactgatccatatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaW
-atRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVg
-atataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKtta
-aatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaa
-SRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctB
-ccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaa
-tcWactaatactcttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaV
-caYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcS
-BSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVN
-ttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtacaatgtgctttat
-atttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaK
-tttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDg
-WaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtga
-caaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtat
-ataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttactt
-HttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRata
-VtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaa
-RtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMt
-agaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaa
-aggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaa
-atcctgttactDtDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgat
-MactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgatta
-tacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtc
-MKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctaca
-aacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggt
-taMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNa
-aattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBt
-taaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaM
-aaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaact
-ttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcB
-tctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaW
-WgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYa
-taRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVt
-ctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataK
-ctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVta
-attaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctg
-cMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaact
-aaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagata
-atcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatW
-tcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctV
-ctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgB
-ggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMctta
-tRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKa
-YatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHtta
-cgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtc
-KtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttca
-aSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatg
-tgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHa
-tgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMR
-ttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVt
-attagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaB
-tcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatg
-ttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWctagatataaNtacc
-gaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBatta
-gcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccB
-attVaYtttHatgaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDR
-aggataaWgMataggtactatatttVctataattaaatatgtgttDtcctaKataaaaac
-ggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaN
-aStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagc
-aWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatc
-atVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaat
-catatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRag
-ttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttga
-YaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcg
-atcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWc
-gcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatct
-gtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStK
-caDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNa
-KagttctcataagtaatgactgaVStaatcctcDagtcataagWtataatattacagScH
-aatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVa
-atacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVg
-tattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgN
-tBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaagga
-agaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYat
-SctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYtt
-ctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWD
-tcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNct
-ttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNc
-ggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattc
-tatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtatt
-BMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHct
-atacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgt
-acNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaa
-ccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKS
-attaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcB
-agaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKt
-gHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggM
-tNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKct
-gtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMtt
-RgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSat
-taacgttMattgtatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggc
-aatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgt
-KatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaa
-atStBcattgagggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNttt
-gtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctca
-aaacVctWtacatagttaattBBttMacatDtatttaaRggattatBVcacattattaag
-WctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaW
-aagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtct
-aaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaag
-aWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatV
-aVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtW
-caatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgccc
-ataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgat
-tBagBtaataattBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDa
-agYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtS
-ataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRattataaatatcta
-ttHSctttggNctaagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaD
-atgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaac
-HtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaataVacgaaattt
-aBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtc
-taBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttg
-RHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgt
-aWcatYtWaBtaBatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtact
-DtMNagatMtttRacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactag
-gaRttaccVaagMacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggt
-gacatcaBatHaaMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaN
-ccttacccatataMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaa
-ggagYaaMHtataaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactata
-atWctcctRKaaHtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHD
-aactaYVRaatgttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMt
-DNRtgtttgggtHcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDt
-gagataKtgtctataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtg
-tWtaagWtaKgattHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKW
-tgtgRagcNtKtYtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaM
-attaVNHRKttattattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDW
-gVSagtggtaacataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSa
-WaattataatcataBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattM
-agtKccaaWccatttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWa
-taRtHtcgaMagSMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaM
-tVaaaagaatVgttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaat
-DctNtgatMcRaaWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaa
-catgcgttaaaccaaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacgg
-RKaaaMtcHgttaattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKa
-DaagaggatBtSacatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaata
-ttatNattataWatWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKN
-tMatacctctgtaYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatg
-actcSaatattgtBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRat
-aYggtctaMtggcagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDataca
-tatgatcNtagagMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataStt
-agttttgcaagtgctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatY
-atttcgggcaDtVttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaa
-aaRDctKctagtaKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatg
-gttttaaacNttBaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBga
-tacccgtVtaatactSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWattt
-atattgBNtgtVgVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaatta
-cacHtaaaaaBttKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaa
-tSagcaatttHctatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgta
-taRKYaatccRYaatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRt
-gtBttYtatKaattaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagat
-WDgVgtactgtRtaaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDtt
-ctttggacttcBcgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccat
-aaatNttaYYgtcBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaa
-BBtStttaatcaaatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttt
-tcatatcaSgtcWNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatctt
-cYacaaatataDgRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNgg
-aNtcattatgacYgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNg
-gaaaMtaaRtctagtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttct
-KHNctaaNatttWaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttg
-tacattSattaacttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaa
-taaatcactcaMgacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVa
-KtgKaacctaggStatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaac
-RgDtaatgtccMaacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttg
-aaatttHtagSBgKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtg
-cHKBKVaWaacacWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtM
-tHacKgWtcctcctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcat
-catttaNRgaKgBtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttg
-aYYatgctgcacatttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaa
-tcagtttaKNRtaaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBt
-KgNVRagctaRVtttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttc
-tcRatBVggaccgaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMc
-aaaatgBtaKcgaRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtc
-HBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttcta
-cttcgMagagtaaaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtc
-WBtataccaaScttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgH
-aaNWtgttaccatacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgag
-taaYtttgDaKDgVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtW
-ctatttgaaatHttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaaca
-aHttaMtctttatcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVct
-aBcaHcttaccaaWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtg
-atatYDMMtggaatKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRga
-gtattaKatgatctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDt
-cggtataMcMDcaattNcacattattgaBaHattHgcYattagaattataaBtattBKHt
-gtaacHtHaacaaRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNata
-acacgWtattDWccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccg
-NcaDtWNaaRgctcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtat
-aVVaHtaRaccacaRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWt
-caaccttcgctaMSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaY
-NcDcaSatMcaattYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagt
-cagcgaSaaSgtattctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDaca
-WaYDaactagcaDttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKc
-ccaaBtWcccataaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYa
-NttaatagKatacaaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRa
-acttcggScYctataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatg
-atcttaaattaKRtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatg
-SaHcRtMDctagatcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKtta
-ttNaggScgWcaYtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactc
-tBaggtHHtgaSagYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtct
-gMtRHtactgggagcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacN
-tWYMBcNScgggataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMV
-caVtgtStctctWaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDat
-ctcaMatVtNaataaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaag
-VgNaaRctSctgWKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaac
-ttggtggDVgtcaaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaa
-tgttatttgttttaBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagat
-DatttcacctaaaaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgt
-actttagVctaBBaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcat
-tgRtaNataagaaaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaat
-atYRcggatgtKtttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRt
-cataatNagatVMctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcS
-DtMStNYtgtgaagcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggt
-KgagacaattaataHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgc
-SKtcttttcaaRgtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattV
-tBtDatcttVgagtatttaaaattacYSattatttaYtagcaVSHattDctKcVattata
-agagRaccccWcaBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaN
-VDatataaatWtcMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSt
-taaataatttttaaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcat
-tgYVMtRtHgBaatcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVa
-gMgttgKtgtHatcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgc
-ctgMctcacttagtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtB
-tttKSHWSaVtVtgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKc
-catagVactWDgtRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaat
-cagaatagHaacaattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRct
-cBMaaNgcaStgcgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKa
-tctScatattNgStYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttK
-BtctataaaatcaStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgag
-aaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWK
-gtaaccDataactgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattt
-tgWDacBtataatttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSW
-ttMaBcHttaatcttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctac
-tatSgacaatcVMcatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcgg
-acccctDcYcDtttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRa
-tatRcttgattggaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatg
-cDaatHccgMDcgcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctR
-SctctWcatttVatgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYc
-DMWaSKVcccaaaggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaag
-gtataatttgcttgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgtta
-agttNWaaYcgaaVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataa
-ttattttccttgaYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRatta
-YcKtggtSggWgatMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWa
-NtatcttcattSgatatgatactattWatSaattWccgtctaatcttgKDacatRatggB
-ttatggKgaagtttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaB
-YcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcY
-aVtRVccgaattatacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRa
-ctWagWgttcagtgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaa
-gcDatatatNttgtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKt
-tcatttttHaMagatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagc
-gttWtatVWRaaSacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVa
-ctWtgtStNatacatYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgV
-tSaMgBcactaaatYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaac
-YYMctcagaNattatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVa
-tHNgcYttNatatBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaa
-atYgctgttttaagatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHa
-VcWaYaWVSccRactDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaat
-gattcatgtcKRctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYY
-acttgcactaaYDcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVcttt
-cBKcgtcttatSttattYMttaatcatattcatSaYtgWaDacgaataactctggaDcca
-ttacgSagaaattgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccSt
-gaaatDaagYRtDagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtH
-actaRaagatatMMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtg
-ccctttattatSatWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWa
-caaaBagRactKacDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtN
-taWatagcacgcgcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBac
-gacaVYtRttaacttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatag
-tcataagMgatVagVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVt
-cMataaacatattHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttata
-aNaacatctBtaDNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtgg
-cgRgtHtVtatHgtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStac
-gtataNcgVaHHagYttStaaccWacaKctgctttaactagtVatttaaatKttRcgact
-aHttSaKtcagBBaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBa
-gDgtagtatHtgcattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNtt
-aBWaacatgcttSattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaa
-gNattRtcBaccatKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcD
-aatgRtDgcNWSgtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaS
-aStaataWBMtgcaaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaa
-cacacgDaatctactaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNa
-atDttKgKDgcaaactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKM
-taKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaY
-tcaKatgNacgtcWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttc
-tgtctttcactacWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYtt
-ttVatttWtcBagaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMat
-gtRaaDtDKttgataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtga
-gacctgaaatcNKDactgKtacgBtDKgattaaatagattatagactatggacgacgRga
-aYKgYaRtgaaaagRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVga
-tacKctaKgcSactaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacS
-KatSDMatWtagKtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcgg
-SttaggtgHtgYatgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtc
-gKtatcaatgcgStVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaagg
-taMNaatttRDtcDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatg
-aaVcatacacVtKattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagac
-ttttMttaRaMtaHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttattt
-VaHcgattWttMaWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctc
-YaaKMttcagtSNtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDta
-aggtcSgtDatttaKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHt
-tctaNRWtaHtttaaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaS
-aVaMtcSgtaaacctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgt
-acaaMNtagtacggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNag
-DtagggtHagHgctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagc
-DWVctBttccaWcacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaS
-tggattgtVgaMRNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaSctta
-gacaaDaaBtaHtacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWg
-NagatatYtHattWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaa
-gttgcatgaKaatggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcg
-gtggYSttcagaattattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtg
-gcHtRaagtHaagVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaR
-tMtcagcaataaaaVccNcttMtctattaagacacgagatNtatttataaaSagaaatat
-SccaRHKatYMacgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaacca
-ctVcaSaYtaactaHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagct
-taatatgaaRcaDVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKg
-MaSaSggttggDNcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaat
-BaHtttgtaagggataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgY
-tttccgYattttYMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBa
-aRctaVgggaacRaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaW
-ttgcaRcgtgNattatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKa
-gcWggaWcStaatNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKt
-aNttcaRcatRtccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMcca
-VgVgtatcKacDaYcccactcattcacYtattggatVgaWttctgSDagaWDattctaca
-taaaDggtactatagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaN
-cYgataHagaDtagttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgN
-taaYgYccHgWactgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMW
-aSDaatcYWccaaaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcR
-aaaWaWactgDttttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBg
-NaaYctggtatctacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctg
-aMgtBttgtKaSatVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKtt
-agtcttYgtaSccaatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaN
-taSgaaataatatVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcH
-tSttgccaatNgtaHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatac
-BSaagMaDcaattttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttata
-tcgccgaagBgRaDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaS
-gaSVaRttcaMtgtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKtt
-HgaaaYSaBttVacWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStaca
-atHtggtgtBgcNDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaD
-DcKtaaatcVVBtcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgB
-caWNaNatatWScYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctat
-aNSgBctagattaNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacg
-tttaacctaaattaaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtct
-aNtWattcaattVHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYa
-gcHtaSataaStKaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatR
-DaataaMttRgataaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaag
-ttYgcataVMaaVBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWt
-cSggtcHgggcgagtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVa
-gNcSgBKtaaMtcaStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacM
-gtagtaaWtaYtgHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatat
-ttStcgactaDatKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatga
-ttcttacWatgDgagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttga
-tHaRVaaSVNNtcaRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSag
-ggaaagKctgggtcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWM
-agatagacatatVgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgta
-gaNtgagaaaRttcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggtta
-tcaaRaaggaataaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtg
-actatcgHDaBgRBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaV
-tcgaataaataagttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWg
-acStMtttVaVgaBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagt
-tgaacaagaatacaDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVattt
-aBtHtVggttattaaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgt
-cgggSMtaatNagtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcH
-gtagatgaggtcaHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaN
-actataaNcctKcBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcat
-HtDHaRagctStatattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaact
-KNaaaVaStatcgtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNa
-tWttgWagtaaKgtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRc
-BaStgtaaaaaMttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgc
-tcMgaaaMcgRaacaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttV
-ttatgtKattttYcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtH
-atDMBcttMacNaVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtD
-KBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttatt
-YttctaMBggcaYctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaata
-aagtctcgcgttcagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaa
-tgtccttaactaaaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatata
-DtHcKcctaBaggcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHa
-cBStSMtcgaacYttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcga
-tatYtVaccSacacgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMc
-atBtacatgtYtctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaa
-ataatDgcgcKtaatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttat
-aVgaaaatcWDcttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagac
-BNtttattttagtDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRct
-cgaagttgaatttNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttc
-aRattacaVgtatWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBta
-SaaMctgMtcaagaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNata
-StRtgaattactgtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtt
-tWggcKatgcgtagDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtat
-ttctWataagctttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatca
-atgttcaaatccDttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgt
-tatMaccgttgMNagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDtta
-tagHBacttRttcctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRa
-tNDWtctgatcKtgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgt
-NggtWtWcttgSatRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgcc
-aHcgtagaaMatgataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatN
-gaRtYataaataRtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctc
-tBaWWtaagBttVgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataa
-YtNtttatacttaMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatg
-StDYgtattaBatBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDt
-NcttattaagYcagacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaM
-cgcaMaagSagaaDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggt
-tcgtRaSgacaStaaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaS
-tRSKcatggtgBtgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaac
-aggaagtctgacgMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacatt
-aWRBtcaccattctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStR
-ttWgttattaSVKtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctct
-gtgggggcSaagcatVattMacattSgttaacctaaaaccgcagtgagNgtctataatBt
-HtacaaSccccMgagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacat
-agBgaMRagatRcDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagtt
-atacVaDcacactcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaa
-atacaRagaaYaNtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKa
-agcatKatatctcaRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVg
-cattttttaVaagtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacactt
-ttRHagtttaDSHgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtt
-tgtVatYattaattBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttga
-RgagaaMKtaggtattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaB
-tHgtatBaRtttaccaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRatt
-ttNcaaaDDaagtagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttac
-VaataataatDtgHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWtt
-aaBactcgYtDaacgactMtaYKacBgttcttgttataBacatScBcattKaaattactt
-SSDaRgKtHHagRNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtg
-gtSaWatBtgatttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtggg
-agRMttaaMaWccggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaata
-tctgNgVttagcttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtg
-cgtcYBagtRHgacttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccW
-tNBaYatttYacYtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRt
-VDYaacgtaBtVKtagaagRttttttatataSaagaaKtaatatKtattagBtHataata
-tcWNaacagtgWaccatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtca
-gggBgtggSctaaWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataH
-tgacaagttSacgtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatt
-tcaMcgtaaacctctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtcc
-BaNSattgaaattgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttD
-tacRtgRattttttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtH
-HcactgtWgtaggtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDta
-tVagMtggactaBSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVct
-cYaWYtBcttcgaYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaM
-ttKaaaaatVaatHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKB
-tMagtcttMWgaatRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVa
-cStgttaMaaaaacNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatct
-tRcgDHHattcStatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatca
-cNNWtDatgaaaactgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatg
-tYagacMgtVVtgDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMa
-cctagaatattcttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDc
-gagMtacattaMtaVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtt
-taaBVMaaWcSaccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgt
-cMtgcctVtaRtgcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgc
-WataRaHtDtacgaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatg
-WgatKatYYaaataNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacat
-DttaaaNgaacttacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaa
-StNaaVBatagttcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRtttttta
-tHHNHaHRtcaRcMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgat
-tcaaaKgaatScaNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtat
-catattatcVttcgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatat
-YcctSacVcattttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVc
-aattgcgKRctMaKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaH
-atgSaSattcagtDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatact
-tVttatcataSSaBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaH
-VaBtttWtttgatRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaN
-gcNatacgWatYaatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDt
-tttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaa
-aataatNtNgccgaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgact
-aaatgaagVaacaBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcg
-cgggRctttKaaBatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcga
-RggVgcatatcaDcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtc
-gaatctattSKgtgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaa
-cgaSgcYagcKBttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDR
-ataaaNaSaagHttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVat
-aaNaaaDtaatgtaaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHc
-BgcMaatDNatcaYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcg
-tacatacatctaDactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttS
-aagYcgMatttaVattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtg
-tttaNtVtatttatgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRK
-ttcatcWtaBaggKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaN
-tgtcgtcttttttaBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattc
-aVgatRtcagBtcaMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactY
-acaKgaaagtggtttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWt
-tBMaBccagaHDaataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMY
-DcactYtaStWgaaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggR
-aaMVtStBtaaaagggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHa
-aatcaVttaRaKtcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcag
-aKtaMKacgccaaVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgt
-gacgtcttcattacaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDg
-RHgatctttagtNtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgt
-tgNaagagKttgNYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWga
-cYggStacYcgatgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNg
-atMacgKgBaWagacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRt
-DaSHgNttYaatWagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtc
-tagMctaccagagttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgac
-VcatagtgtattttccttcatctacttSgaaStcagHtMaataWNDagtatttttatagg
-catNKataNaMtgctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMc
-ccattgggtagaKMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagS
-aaatRatttNctacaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaS
-cWccgaKttttcgtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaa
-gttacWatgHtttaagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDc
-BaMaKtctaYatVaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSa
-HatcaDtaatgMMatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagtt
-aaWDacgRaRtaKttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcg
-McgaSNgactaccRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHc
-taKtHcHMcRgattgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatca
-ataaKgactgactcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYg
-cttgaSStgtaDaNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKa
-agBtttgtcttaagMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaa
-taNttccHYctctaSRtaYagtNgDagatWtRttSttNtRNagacatattttatggacta
-cYMagtMacYaagYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWN
-KMgDttttaWtaBaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNa
-gYttBYNgaBaaaStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatt
-tgtgBcatWMtaaaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWac
-acWtDtatttatWaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHH
-MKScSgSaMtDtaMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttW
-tagactatgaRNcttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtt
-tWataaaDaDgataMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMc
-tHaaatcagStatStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgta
-StMcSNcgtWggMVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgat
-MtaccttaagYatcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcat
-WSatttcaMtgataKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKN
-tgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtc
-gtactHggagtaatttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccact
-taDtagtaaKgYNcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccag
-KgaNgtctcKtWgaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaK
-ggtKcDtRtRgSaNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttc
-HgcKtagcYgttttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttN
-ggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaa
-MtaBYtgtaHagtcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaW
-gNttccttttMaRcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaa
-ttgatcWaatgtttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSa
-ttaatatagaatgSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBc
-ggtDaggYaaactNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctata
-aDtttcgtcgtattaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVa
-aYaYtccagacBttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgatagg
-VatgagttgatcttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgt
-aaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaD
-NcDatggWaattggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacaccc
-NHataaaatgaaagagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtca
-gtttgtDBBHWcgaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttca
-aNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaa
-attaataNcaRtagtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRct
-cagcRattaacatccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatg
-BgtaVVYaaaatccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNct
-attagtttWttRtgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgt
-tNKgtcSggSHtaBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaag
-RattccggcttDgggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgB
-cBtgDtttcctattaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtg
-ctaaaatggagacctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgta
-gagDttcBatgtStttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatD
-aYgcctMBtgtNSNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSa
-ttaaaVHtaDaatYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccct
-gaYcattaNaagNaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattat
-acYtMatWgatttcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcg
-atKgaggBtRYattatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaa
-SacaRccMcaaacttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatcta
-BtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMt
-ctgcatgaagRDattactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaa
-DagttDtttgYcaagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattat
-KcctctttttcatgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgtt
-DYttctatagWcRttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaa
-agggtaactcacgDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaSt
-cSaacgtaWttatatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSac
-tcKtttVaWRatatttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaat
-SNattaccgtcaataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgactt
-atHccacHaacVcWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaH
-aDttYacDtBgtMNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaaga
-agtgtaMcWatDggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtc
-ttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaa
-acgggtataatcaaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttc
-HaMtNtMgcgaaatKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtB
-gtgHtHDggaBDtWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaa
-caHtatggaNaVttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtac
-VtRaaactgYtcatggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNa
-ttcaaHtgKRtRtagtKaRWaataYaggatccacttcacaatgtgatMaggactNaacca
-aMaaKtagaaMctacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaata
-tttatcaacaactRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaa
-gHaattagaatBWggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWtt
-cBaatcctYttgaHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgt
-ttctacgtagSataHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtM
-tatgaaNtWtHgtDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaa
-RDHttHYDtNgcatHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaW
-WtttKaaaggBtattHagtaacactDggtattttScttaaaacaStcaacHttMtatcag
-atSaHtaVtBaNYcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtatta
-YSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaa
-KtHattgRtBtMMccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtD
-aaacttDcacgatSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatca
-tatKRattSggtcggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaV
-aatRgKatttKSaYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacV
-ttKattVNgaMattNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaN
-gtHtaWgaBMttttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtat
-WggagSattKatRBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaK
-ttgatattttgKcgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNg
-NYtMttNHgtHBataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKga
-aRSRtBttatccataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDat
-agNttttactagcgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMt
-ttctaVttMaatgattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKa
-MtaaDgtKgttBttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaa
-HcatYNaaVDNtBgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVt
-aaHttaagaKtaagSaYtgcacttDattYttaVgRcacaattDDttagattttcHagcca
-YaataKaatccVDKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaaca
-agaacRSactBHttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatat
-BaaagatgaactaaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMa
-taattaagtcSRcatSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatc
-DttRHtcagtDtaStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcga
-YWaactRtDtatttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttt
-tataaacWaBttcgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYa
-VacagaacgcScDcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMt
-tYHtaatHcKKtgggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcN
-aaYaBtattttatRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagt
-tgtYatctagaBaHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagB
-tactcttatgBcHcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaY
-RaattccaNatgtgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaa
-tWtaRtaatSgatgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaat
-actWgtattcHttcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaM
-atacgtYaRNtgNaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBa
-attHHtatVNWYHaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBg
-atHtBcaatHYaSgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggct
-aSttgtaataDctWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtata
-acaRKctaacttcYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtW
-tataaWgHataatttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtV
-agactttacKaWDMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttB
-catgattSHaaccVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBta
-gtcttccttatKBRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVa
-SagttatatYtcgNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaatta
-aatgaWaBggYtHYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttc
-tgDDcttgNDagcctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVga
-attaatagttattactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatg
-gctKtWatHaNttaatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRa
-taacagctMatBgMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWR
-ttcatBSHtttgaatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaat
-atgtatgHYcRtagagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaB
-taagRagtttgSRtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatg
-ttVtataccagaatDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggc
-cKVatccaSWaaKHtttSggatgagMagttgcaatatKYtacBttaccatHRttaactta
-caDKKtaKaDcHHcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggB
-atcttgaRDactgatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRR
-ScatcttctaatacagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcac
-gcctSRaagcataattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacN
-VtgagaataccactctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtc
-WDcWaBatattRtVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDc
-SttaaWtttcaaaatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgct
-cacHccMgaacatcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaag
-ggatatcagtaNMttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDta
-RNDNcBtagBgacatStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSagg
-agaacgWcMgtRcaagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaac
-caBtacVMgSttgtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgt
-cctaBcYKattcaggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatK
-cVtHgctggaNttaagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYa
-taaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagH
-aScDctHttaaaatVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataa
-WtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtag
-tacataggSaatMtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgR
-gtDVSRattttttaaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtga
-acMtacSDRMHaaacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaat
-KactNacgcBYtttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctatt
-agattKHttYaaBtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaH
-tattgtDaHRgatgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagt
-tcagcHttgWagaWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYc
-gcatgtatgtNaccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtc
-tacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKt
-tttDVgttgtaaNcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagt
-acDYgatMYttaaaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSatt
-aatataNaWcacaataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaaca
-caNttttaatctaKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSS
-agcNtctacctttaacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgB
-YcBggtaWatataKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVt
-ctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttN
-tttatcatgctagYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagt
-cttccatBagatctBaaagSacagtaaStaaatatataataatcttaactatVtaaBatt
-HcHgcttSSaaDRaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaact
-taBaYaaaatKgtactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttc
-aWgtcaKtatcgacatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagt
-taggggatWtttgattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaa
-attacBtMRtatccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDt
-cgNcgacttgtaaaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttga
-aVKatNacDggagWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcag
-NacVRactcWgctttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaW
-aaagttcNVtagMaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgt
-WSaaBatagtagSataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaag
-aDBatcttttaRaaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatW
-aDaaSaDaaattVgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatY
-aaagaataDgatDaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggc
-StataacttVtaatWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtat
-ttaacattWaatgttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNa
-SatctRSaWtagagtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatS
-atataWttctcgtaDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKc
-ttttSaaattYcgYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccD
-atatagtcRaaaSMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcac
-ttBaagaMDtactYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggttt
-atWttYttatKMKgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatg
-tWtcRDWttcggacNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtg
-HtcaataaacaaWMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgtt
-aDaScgWccWHatacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKcct
-tttttStaaDDtHYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcg
-cRtcctttacagBKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWttt
-caataDtactRaatBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaN
-aagatHBtgtatVtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaa
-caBatttaatctaSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRcta
-agtaaNtaaaaattatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRD
-aSactgcagaHgttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVt
-tttcYaaNtttttatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRt
-cWatctaattgtVgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKg
-tDtHBVgYcagatgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSY
-tccagtRtaSVtRgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaM
-atgRtgaaaMHatgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRW
-cBtDaaMKRcccWtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaa
-NYBaatatctgatNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtM
-acgtMDtgagcattcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaa
-tMtagatDcaagMtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaN
-tBatKtStcRagtgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaat
-tactcYtNagaaaDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWca
-cagaNWaNgaacaYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtg
-HtattcatatttaagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVa
-taRaKWMcDWtSaatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgcta
-ggRggtSagKcWYctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSR
-gttatMtNttttWHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctg
-aacatttVcNtgtttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataat
-aHaaaNacaStgaNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNaga
-tKcatataVatactgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacatt
-acggcaKttattgacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDY
-acccWaMttgRtNggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaa
-aatgNactaattattNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctg
-gtcaatggtatBtNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWta
-taaaNNacNgctYagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMt
-agtcaYaaRttWgBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRta
-aYagattgccMtgtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVaca
-tttaSttSVDSctactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVtta
-gRtttttRttYYaYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWat
-ggtaagagRaaattYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctct
-NtataattBttStaRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWtt
-cgcaaWgtWNcBccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcB
-aaBcgaataattcttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctca
-ttctcaatgVgaaacatWWctgcagtttctttttMagWttatRggcattattVaagaBBt
-tatctattatMcNtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBt
-aHHYDttKctaDctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaagg
-YtcataYgBtccRaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYg
-cWYNgagtaMgtSccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKct
-tttaatgacBttNYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStg
-tSaNaactVMcaatcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttca
-tMYRctttRtaMgSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaa
-ttatBtttWatgMctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaac
-KatattatNggNaRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtg
-aNtcaaaRgtaBcttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHg
-attgggtcgacacDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatM
-gtMVgVgatttcagtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagat
-aacactcataVgttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttg
-aHtKaYtattccagccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaa
-gaSaaaagaaatSaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMt
-tcttgtDtKaYVttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtc
-gattaccHtcgcgatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVc
-WMBBaWaWcagtatHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtc
-tttgBgtattaaDtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMa
-agcVacgtgttaaMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBc
-NtgNatBtggactttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgH
-aattaaaRctgatKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttag
-gaKtaaaBacVDcBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattW
-cgHgcaDccctHttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcaga
-atcctcYtBKDatatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagt
-ataHgMaVggcaaDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattg
-agagtccaNtgaatttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcata
-cctgctctatctatKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNt
-acagtcgataNgaVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaSt
-ctWDVcaaccgaVttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatacta
-aaWaagatYHRWcaSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNgggg
-DaWgagctgatctatttHaactttcgcttttccatttNaaYgtattttactttacttRat
-aBttgatagggacattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaat
-aaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaY
-HatYtgtaatcatttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaatt
-aaaYatcgcatBagcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaaga
-NatgKtBSctgattgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSc
-caSScagttgatYattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaa
-DttttattaatacSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataa
-WacgSVKatactagDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHg
-acacattcHKaMKtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatg
-KatVgacattagWtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBta
-ggttaYcttagaSgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKc
-gtYaaaaaKtaSaattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgt
-ctgtgagtMttgaaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgR
-gDttcDcatttgagWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWV
-catgaacatRgtNaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYat
-cgatgtacSaaataVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaag
-McttBgtSagKgNttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaac
-ttaaaWNaattgaWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaa
-tcgataaatRDttataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtat
-tKcgcBtttDacaaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagtttt
-aagcctNcttaBtYttaRactaattggagagggtctagtatgggtttacttBtatcatat
-gctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcct
-atttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYt
-cMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcS
-tgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttt
-tcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatc
-MtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtW
-gtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDa
-WaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaN
-MtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaat
-tVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagat
-tattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaa
-ctaccScattRatatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgc
-acatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatB
-tgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacagcccccacatYSc
-aMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaat
-aRattagHacacaagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagt
-attMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVa
-tactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHK
-ttactatccctcatgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtag
-aYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaK
-ctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtt
-tctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaY
-tgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcc
-tagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtg
-aaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYa
-gactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactg
-atttcctttaNcgatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtS
-KacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttac
-tttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccag
-ccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBa
-accgggttattaaBcKatDagttactcttcattVtttHaaggctKKgatacatcBggSca
-gtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagtta
-RatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaa
-HgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattB
-tgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcD
-RaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaaccctcccctaga
-WBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaa
-cgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaa
-catKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSt
-taHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctc
-ctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataa
-actaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatV
-ttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcac
-RHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaa
-tttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaa
-agtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSa
-MatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgat
-caccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaa
-aacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBt
-cttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcagga
-ttHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgat
-gaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatH
-aactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatg
-caaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaa
-aaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKR
-gRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWag
-cNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNag
-gaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaat
-atVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRcta
-VtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBgg
-actaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRcc
-ctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagt
-VttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMa
-ctacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStatt
-attMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaa
-gtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcH
-VagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcS
-atcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaa
-cRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWa
-YttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVN
-tataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaa
-taWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttc
-gagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatt
-tctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaat
-gttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMta
-gaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttata
-aHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaataga
-taatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggS
-BNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtg
-KgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKc
-ctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacgggg
-tNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatg
-aatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctcc
-gggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKtt
-MWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDc
-RNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMa
-YaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSt
-tacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaS
-aBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHtt
-YaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacg
-tgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctc
-tDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacS
-gaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDa
-cSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVag
-DVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaa
-cgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRaBaStNagatagg
-cgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtg
-catagtttWYaagBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaR
-ttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctat
-KaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtgggga
-cttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctct
-gaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVg
-BMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMcct
-tatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVattMMDtMactatta
-ttgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNa
-atactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcY
-ttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVa
-cataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccSt
-YtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatca
-MatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHaga
-gSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaN
-aHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtN
-taStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWW
-attBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcR
-VaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNg
-DWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgtt
-ataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaatt
-acgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcR
-gYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgH
-gttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDac
-ttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHa
-taaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcS
-cSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKt
-tcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNaga
-actcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcD
-tatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattD
-aWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttat
-attacHactgttataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgg
-gtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBct
-atctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataa
-gatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctR
-taBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccg
-tttaStagaacaMtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaat
-ctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaa
-gtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccN
-ctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKat
-tgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKga
-tgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYtta
-ttNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacg
-caRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaM
-acNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBa
-cNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBta
-taRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatg
-aagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaW
-gaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVag
-aatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctt
-tcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcattt
-atgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaattt
-acaatcactSWacgtaatgKttWattagttttNaggtctcaagtcactattcttctaagK
-ggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcR
-aattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatat
-tttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgt
-ttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYa
-tDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYc
-tRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStc
-tatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDV
-ttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKK
-acttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBD
-ttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKctt
-RggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHa
-YVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaa
-gacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBa
-tgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRa
-cttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgta
-tWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVc
-YttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaa
-agNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaB
-aBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtag
-ttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagt
-acNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKc
-atDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVta
-MaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHa
-MctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaatttccattttacatt
-tDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataB
-ggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHca
-VgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttatttt
-gWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVta
-gaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaa
-gtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKStt
-DaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgc
-YtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctR
-gatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttc
-ttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaa
-RgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatg
-KtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNt
-HagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaN
-ccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttt
-taacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaS
-gtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaac
-acattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgtt
-aDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatR
-tgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgt
-ccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMt
-ttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataatgccVgacccgat
-actatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttcttt
-atVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaa
-StNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVa
-aaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRag
-aNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttt
-tttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttt
-tcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRtta
-HctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaB
-ttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactt
-tgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRac
-MMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccatt
-aRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYcttt
-KttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKt
-cttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattg
-acttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacata
-tacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattg
-cccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcY
-tttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYt
-MttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgata
-tatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRca
-gcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcH
-tcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtatt
-gaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgc
-tatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBH
-tYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHK
-taMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYta
-gBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagSKaWttataHact
-aHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataM
-ggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVB
-ttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaa
-atgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgt
-ttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHca
-ctttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHg
-tHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWa
-aagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNc
-cKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatt
-taWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMtt
-atgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtc
-NatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatg
-RcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtct
-tcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaSca
-KgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMa
-ttttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtat
-taWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKat
-aStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMat
-RaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaac
-aYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaK
-agattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggt
-tBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaH
-MWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaR
-gattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNt
-ttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaa
-aatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgt
-aYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctgg
-acaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgta
-HcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtc
-cNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataa
-acttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRR
-YttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaat
-YRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSc
-tcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttgg
-taatctttYgtctaactKataHacctMctcttacHtKataacacagcNRatgKatttttS
-aaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHg
-ttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaK
-ttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcN
-tctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHc
-VBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtY
-aaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaat
-tttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWY
-taRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttR
-aWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRa
-WataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgag
-VtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagt
-gKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNg
-HtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatt
-tctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaata
-aHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWg
-actKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYt
-tatgagaaacctNVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattc
-gSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtac
-NaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctg
-cMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVc
-aaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagS
-aaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaV
-cDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBca
-cggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRc
-tatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataa
-tMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHt
-WMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRagg
-BaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSc
-tatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBga
-agBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaag
-cgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSa
-YctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaa
-gatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHa
-cHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaR
-ttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWa
-gHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtt
-tctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgacc
-YatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRK
-DttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtY
-tMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttt
-tDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWc
-ttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWatta
-KttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatat
-BtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtat
-NtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVN
-tcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatc
-ccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggt
-tWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatgaDatataSttag
-BaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcK
-ccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttg
-tcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttR
-gctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaa
-DcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataW
-ctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaa
-ggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNac
-ttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMc
-caggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHa
-atgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaa
-aHKtaNBctagBtgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtg
-MRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDtt
-YatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataD
-DatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgc
-DtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgc
-gggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtga
-atatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtataca
-atctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagt
-aaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctg
-tccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagt
-YtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtt
-tttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataag
-HacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtB
-atgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatg
-ctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBtta
-cNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHH
-WHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaa
-ggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggt
-gKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtat
-aatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaagg
-agtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataa
-KNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagta
-ttaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWt
-ataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaa
-taacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtct
-taaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattt
-tHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaa
-acaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcat
-atVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacc
-tataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYatagatgWttcat
-KtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKt
-attaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaK
-atggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcga
-aacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBc
-tgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaa
-WaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHc
-tKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHB
-ccatccattcNHtDaYtaataMttacggctNVaacDattgatattttacVttSaattaca
-aRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMcc
-MttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYa
-tgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcgga
-atDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKa
-gggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaa
-ctMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBt
-atDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaatt
-gcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttM
-gYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaa
-HttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcY
-NggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgag
-agtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNta
-RtaactggatgaccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaa
-BtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttD
-aVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRca
-gagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaW
-aMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgV
-ttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaR
-gctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVct
-RaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcM
-tcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYg
-DHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSata
-atttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYat
-SatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVt
-tgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSa
-DcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaa
-taHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgat
-WatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtgga
-RaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggc
-acBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtat
-tNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVa
-gSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactc
-ttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagta
-RDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMtttt
-gMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaa
-MKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWt
-tHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagN
-SStHcctRRNtattgtccttagttagMVgtatagactaactctVcaatMctgtttgtgtt
-gccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagB
-tVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcY
-HaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaa
-tDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaat
-aagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcM
-acHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNa
-agaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNg
-attgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgt
-VttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgta
-SaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttY
-tagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttV
-acaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtB
-cacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtc
-ctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaa
-KNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSataggttattcVta
-aagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDc
-tctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaaga
-WtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKt
-gagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaa
-gaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataS
-tgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcat
-acactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcB
-tYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactg
-tctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgc
-atttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNta
-aattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttB
-WgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYS
-KaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgac
-caagtgttttctaacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggN
-MtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttc
-NtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRc
-McgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgt
-aNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacg
-ccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWta
-HtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatg
-YcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcac
-catctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRtt
-aagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBM
-aBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaa
-tVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagK
-atagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaa
-NgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRag
-gSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatR
-ggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaRSataBatMttta
-aatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaacct
-taacgttBtWatttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBctt
-aaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaH
-tVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtatt
-gaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaac
-caBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHc
-tRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatSt
-ttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagt
-WattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaactt
-aWgtatctagacaagNtattHggataatYttYatcataDcgHgttBttctttVttgccga
-aWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaS
-acataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatB
-RataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctat
-cgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtN
-ttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatatt
-aggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataaagtatattaatt
-tataVaacacaDHatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgt
-tRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtc
-aDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctt
-tRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNaca
-VcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNt
-actWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtc
-aBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatag
-DVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaW
-SRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMtt
-NtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccg
-atttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactW
-atVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctY
-aMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttc
-KgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatat
-tgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYa
-KagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKS
-actctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSc
-tgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcH
-agacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgac
-tctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRtt
-agtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMg
-tDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBt
-tgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtattt
-VtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStctatttccSagatgt
-tccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNagg
-ctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHtt
-cSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaR
-aaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaa
-aatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagta
-acgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaD
-atMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagat
-ttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYt
-cDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVg
-gtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaY
-taataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacN
-WgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYY
-atggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaa
-HHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBM
-aaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaa
-ttgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScN
-tttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgct
-tYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcaga
-aSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttt
-tttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaa
-tSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDa
-cataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataR
-gttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatgDtaattagatHg
-aYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVact
-YtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBacta
-gtaDctatagtaatatttatatataacgHaaaRagKattSagttYtStatatatagtctt
-aaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRa
-aaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaa
-YSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtg
-cgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttata
-tKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVt
-WctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKa
-aHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaaga
-gttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDc
-ctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaat
-cccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBct
-HgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBt
-acaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgB
-aVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBga
-tgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMt
-tatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNt
-atttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatg
-RtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaag
-cDttatNRgattKaaattttcatctaatgccgcaataataattgttatYtagtRNtaagt
-tggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKg
-ttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRca
-gtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaa
-tgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgac
-tacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBg
-attaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSg
-atcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatN
-ctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactct
-aMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHt
-atgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSacaattgtattgca
-gatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWt
-tagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHg
-cVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaac
-NttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatc
-tgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVa
-acattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMc
-HgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatK
-aSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtag
-gKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDY
-actaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgta
-VgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcacctt
-agMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKg
-actaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatata
-aataRatSaBctagttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYt
-aaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaat
-cgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHa
-YYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttg
-tatatYtStatctagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVact
-YtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaat
-aRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaY
-tWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgtt
-aVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYaccta
-DStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBac
-aattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaa
-tccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaa
-NaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSg
-aaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtg
-BRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWta
-gcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttSc
-ggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagt
-ataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggR
-ctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaV
-aMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMact
-acHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccg
-BaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgcc
-gcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataa
-taaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttct
-ttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKStt
-aYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHactggatatatct
-gagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgt
-VcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMat
-atatattNVttWtWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagV
-taccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtt
-tatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactc
-BtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatW
-cgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRa
-NatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacR
-BgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggttWaacgatacat
-tBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtct
-tagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaa
-ataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatc
-aaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKB
-taaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaac
-atagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccat
-atagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagt
-agctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaa
-gYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRK
-tgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatag
-aHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaK
-actttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatt
-tagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaY
-gcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKacc
-gNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttg
-VaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaac
-cMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttg
-agtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYttatcttattattS
-taattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKac
-ttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgag
-aataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNa
-aaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattaca
-gctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRta
-HacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaa
-tctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtB
-tatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgD
-HaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttacta
-NtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaa
-acggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaa
-cactHattaattcactatYttaagacactaKaagRtRataaattttcatHggtaataaat
-gataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttc
-cgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaa
-aagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactV
-tttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttac
-HtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaa
-tggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWca
-aagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaa
-DaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttat
-cNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaa
-VaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMt
-agctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctga
-tgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtat
-cNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKK
-aaacaaaatRatttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHg
-aaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaa
-aMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSR
-ctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacg
-ctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacg
-gWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgat
-attagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKa
-MttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtg
-aagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagc
-cgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYctt
-MtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWa
-cgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMt
-VggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttca
-cttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKataagtagttaagH
-MRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgV
-atagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaa
-atBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaa
-RgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaN
-tKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataa
-tatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStc
-gaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBt
-tagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaact
-cggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScata
-cMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWata
-StcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDcta
-tRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttS
-ttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattg
-BaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDSc
-atactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttg
-ttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtg
-aSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcc
-caaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatatt
-BDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRc
-HttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVa
-RaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRat
-gaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaV
-attaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgatt
-SatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMctattatatDttagg
-tctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcggagtgHgtVttc
-ttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgS
-caWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNa
-atNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaat
-tBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgaca
-aaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKagg
-ccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBg
-aacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacR
-ttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNat
-tVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgatttta
-acgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgt
-cStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaag
-ttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgt
-tKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRta
-tgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWa
-atKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcY
-ggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaa
-cagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttat
-RtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctga
-BagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacga
-gttgYgacttDattatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaN
-atagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtN
-tRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaW
-WtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgS
-MMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWt
-tDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWttt
-WtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHt
-aaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgR
-cHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStK
-gtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcc
-tttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSa
-gWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgV
-ctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSt
-tattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagta
-WacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgH
-tacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtD
-aDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtataaactaYaHRct
-StgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtg
-ggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgt
-atacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKac
-cacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBR
-tVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgg
-gggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaat
-atatNctaYBggKaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaa
-ctDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgN
-cgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataat
-gcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttata
-gcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVta
-tttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccgg
-aatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaN
-aatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNa
-atgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWta
-gYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHg
-aaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaW
-gaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaag
-aagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRattt
-gatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVtt
-agaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaactNaattttcttt
-aaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctK
-ccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacR
-aacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctct
-tgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgtt
-ttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaa
-ttaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaac
-ttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatc
-gWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRW
-ggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVK
-aacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaND
-tgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKt
-HcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRa
-RBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaa
-caatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNa
-tcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaa
-aggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcatta
-gDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRac
-SccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaa
-WcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaB
-atWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcg
-ttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacYRaaVagataagt
-aattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNSc
-attNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaata
-BNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSa
-BagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattatt
-gtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaB
-ccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYga
-McYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVStt
-gDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBa
-gKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaa
-ctccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatt
-taaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtc
-RgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKR
-cSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattc
-tgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNca
-KagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtg
-tgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYt
-tYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcN
-aaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtt
-tWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccS
-gtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagcc
-aaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKttt
-StgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBS
-tcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgt
-caWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWt
-tgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttct
-aacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDattccaRaYtttt
-agttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatca
-McttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaa
-aaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaag
-ataattgatcgacctgcaacgttttattacNMWNcattataDVDactatattatYatttt
-gcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDt
-taacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMta
-tattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaD
-ttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagttt
-gcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctagttttNcataaac
-DttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMt
-atcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatctttt
-ttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVt
-ccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtg
-aagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKa
-tYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtg
-aaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgY
-gtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagat
-BgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgta
-tYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagc
-caWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgK
-gattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgtt
-gWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtc
-tKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNH
-tHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRK
-tattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaData
-cttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgt
-attcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaM
-cacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaD
-tttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaa
-ataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtatt
-ttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYga
-atgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRg
-ttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaa
-aaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYc
-ctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDt
-gKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWatt
-atatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttc
-DVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHg
-HatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttct
-taaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggaca
-tcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVa
-ttcaaattctgSattRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDat
-tWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaat
-atctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaat
-HaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcac
-WHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaK
-acVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRattt
-gtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaK
-BDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacR
-caggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYt
-tcattatacataatVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBca
-aRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggt
-aHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStg
-aaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaatta
-taactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDc
-cttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaa
-aatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYS
-RgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcat
-RtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaac
-taRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgtacggcactDBgg
-tMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtV
-YNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRg
-tcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaM
-tgRttcHctaagctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgN
-tactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYSc
-MtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDa
-aatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcat
-ggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaa
-tattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattR
-WDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaa
-RVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcg
-MtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgctt
-ctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYg
-ttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatt
-tagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgcta
-atWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgag
-aactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaat
-tMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttc
-gtSagtSaRctacaataKatattctaVgtgtaattRacKagttattgaMtaatgaNatac
-DataaggactttccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattg
-ataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtac
-aWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtV
-YRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcV
-atKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWga
-ccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYc
-tSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtac
-ttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttSt
-NtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatt
-taSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgac
-tMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWta
-SatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaag
-accDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataa
-RacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaa
-gRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRa
-atcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaR
-ttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaa
-ctaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattt
-taaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtccc
-SagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaK
-ttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtY
-gtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtt
-tttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccac
-ttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHa
-tcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBat
-tcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatat
-DttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaN
-tataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatc
-aattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgt
-tDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtct
-tatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagK
-caaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMg
-taKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtR
-cacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaa
-tataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcW
-ataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgca
-gaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaac
-tgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWc
-caaactattgccgttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSa
-VgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaa
-VttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattg
-BtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWtt
-RKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaD
-tactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattgg
-tttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtc
-ccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSga
-WtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaaga
-acagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtatt
-aNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHg
-taagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagt
-SccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttatt
-gtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcg
-tNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttD
-agaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBg
-actcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKa
-ctRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRH
-NtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaa
-gctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMttt
-ctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNct
-aYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatg
-accHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVca
-ttMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBa
-tgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtat
-agRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaa
-tRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgt
-tVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBtt
-ttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaa
-YaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatat
-atttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgc
-tacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgct
-BttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattSt
-acctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacK
-agaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctattta
-aaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMc
-gatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattca
-NaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaSc
-ttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRB
-caSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBcca
-atcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagacc
-BggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaa
-tcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttSttta
-SttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVa
-caatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtca
-cttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMt
-agtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatcctt
-caDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtM
-gHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggca
-tgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgY
-DaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatag
-aagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDa
-HtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgcccca
-tgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHD
-aDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttaga
-cKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcW
-ataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtV
-tgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataR
-cacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagt
-HaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcM
-gaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgag
-ttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaata
-atgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtact
-KagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKat
-taNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttac
-tatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtaca
-tatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStat
-RScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtga
-KStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttc
-VatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRct
-tttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaa
-gttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBc
-tccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaacatttcacctta
-HtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRtt
-gtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaa
-DtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttat
-gtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatataaatcttagatN
-KtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRttt
-gaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctD
-tBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgY
-tStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaa
-gtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcat
-aaacttVcatatgWtacaaaWttggaaactttaScataactRattMtDacVYataaaagM
-aattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWa
-ScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWg
-agcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVttt
-MtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBa
-KataactMttttattaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKY
-gKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBW
-aattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatD
-aSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDc
-cgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaa
-ttaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBc
-aRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNc
-tacagtgagacgaaaggKttacattgggacaataKNtattcaagWKttgatNagNtgcta
-NgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVt
-caaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaa
-cRttagaaccRBatataWaatKctcattcSacWaacaacactDttVttgacYaagagtaS
-gcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagat
-aaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgD
-tHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHg
-gagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttc
-atgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHa
-aKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtD
-NcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaS
-tWtattgYaggtSatBMBDactVtggttDagacataaactactBgcacaacMaagaStcc
-aWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttR
-BgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttc
-DgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYc
-BaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgttt
-atRatctatttagacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRgggg
-catWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStata
-ttcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctg
-RatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatac
-aRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYatt
-aaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNM
-ataatccaVgatcttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaa
-tBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtK
-atMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaa
-DaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaat
-gtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatR
-ccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRta
-SWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctct
-tMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMt
-aatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaH
-gBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtB
-gatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataac
-aatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVtatccttttHaSc
-gtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctat
-tcaaagccVVcatattttagMcgtattNtVBactacScattgKVtataaKtttgNaWctt
-NacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggtt
-VDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgta
-aDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaV
-WaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatD
-HWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttat
-acgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtN
-ggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYctt
-aaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHt
-tYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgtt
-gtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatc
-VtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatttcccaataHgtt
-ttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMacca
-MaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYt
-aagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatc
-YtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcg
-tBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcY
-KttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaatt
-DttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtgg
-agcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBW
-WgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDY
-attBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtc
-tctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVct
-tctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaa
-BRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSV
-WatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBac
-taaVaaKtaaacctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgH
-SatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcc
-tacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDt
-YcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVg
-ttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNt
-tcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHtt
-NgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttt
-taaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatg
-atatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagatt
-attagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccR
-aKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtca
-aVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKa
-aaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaH
-YtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactat
-tgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatat
-attattataattBatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaat
-cgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaY
-gYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagN
-RcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaY
-agaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaa
-ttctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNN
-aYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaa
-gtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagN
-ggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgt
-tHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatcta
-atRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtt
-tctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaa
-ttggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNa
-cagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaR
-cgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRt
-aHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagct
-RgtgcNaatctgattatagattagtatatgaataDNatcYaggKRacaatcaHcaagtta
-gtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDt
-SaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYa
-VaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctca
-RtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHg
-acMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVScta
-gttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaat
-NactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVa
-attKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggta
-cgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRc
-ctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcat
-caatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgt
-tctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMt
-aaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtB
-VBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWta
-tcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWt
-gKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYB
-atccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtg
-HgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcag
-atgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatt
-tcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVg
-tttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaaga
-gtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaa
-tctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcc
-tSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNg
-atctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcag
-acaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDN
-cccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgt
-atHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRt
-WtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatga
-cNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKat
-tVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSg
-cBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaac
-DtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDc
-tcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaa
-aaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWc
-tcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatK
-ataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcg
-ctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRY
-aacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKtta
-McHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgtt
-YctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVg
-VatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgta
-aacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgat
-aatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcat
-aagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSa
-RHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtg
-tMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaact
-RgaatagSVHtaataagttStccaatcHataatacMcattHtacaatttctgatggacat
-atgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtca
-tDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYtttt
-aBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgtttta
-ttaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWac
-aMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaa
-taaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaa
-DNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtag
-aattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKg
-ttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHa
-caaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNac
-cctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtatt
-agVStaccgatgSStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttR
-cgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaW
-atataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgt
-aatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttgg
-tVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcg
-catgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNca
-gaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgt
-ttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaatt
-aHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNct
-caatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgt
-MaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaat
-atYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctV
-taaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtt
-taggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtc
-tcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDW
-ccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaa
-DSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgR
-tcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaB
-gtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgt
-gVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaa
-acttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctc
-aatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVD
-taDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacac
-atRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttct
-attaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgtt
-acaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaa
-gHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaM
-tattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcg
-ataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaM
-aataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHt
-gaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaY
-gaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagc
-gtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtg
-MMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaac
-ctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHt
-accagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDV
-tMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaac
-tgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcg
-aactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWa
-VVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcga
-cagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKa
-tNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaa
-tattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtD
-tagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStD
-tKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgta
-HgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaa
-aaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcaca
-aRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcat
-gRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattc
-aaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaa
-aaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtW
-gggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcc
-tgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaa
-gcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaaga
-VaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaa
-tKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtct
-atKtatVggKaSaagtttattttatgtactactHtHttSMactatHcaagaattVataaa
-MKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWt
-acacaattctRVgattctatgtgtatHagatagggacVaattttDtNaWKagtatatHta
-gacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDat
-atcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVK
-YNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSg
-aKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaa
-atgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaR
-ctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccg
-attattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaagg
-cDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatat
-acgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVa
-BggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatg
-aaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatc
-acgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacattt
-DcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaa
-acttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVt
-McaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKga
-aggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatK
-BtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgV
-VgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatca
-attaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaa
-HcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaR
-gtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtca
-gMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMc
-cVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMt
-gaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggt
-aaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatata
-attggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagta
-KgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagta
-gttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttV
-ttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtg
-taBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWac
-acRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttg
-gtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBg
-atacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgc
-caVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHt
-ttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYc
-ttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaa
-KSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaat
-gMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcV
-VggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatatt
-KMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSggg
-tactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattc
-tgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtV
-cStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYa
-attcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccat
-tttagtMaccctggVattHaatVagaaMaattaVacatacacaaattaattacgtKtaga
-aaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtg
-aatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNg
-aMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggS
-tcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMact
-tBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBta
-aaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKatt
-ctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaag
-ttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVattagatctctgt
-ttatcattYttgatHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtata
-tcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaa
-agttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagY
-gatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataa
-aNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtat
-HgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNta
-tVaggtKctttHattcatttatYtattagtataYtttagYcattagaaataHtaacctta
-ctcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacR
-agtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatR
-gtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaY
-NgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatS
-DtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKat
-ttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHt
-NgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcSt
-VaactaatctacatgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgR
-ctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatK
-cgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagc
-tgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaa
-cDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtV
-ataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScat
-tYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgtta
-NaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatH
-tNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatD
-ataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagt
-KgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttg
-ccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaatt
-agMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataac
-cMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMS
-tBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttgg
-ccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcat
-agtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaa
-agtVacatKtatatataVtagcgWccacagctcaaccttRtatNactMtcattaaatttN
-aaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBact
-gaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHata
-catttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgata
-gcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtg
-aSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaN
-SWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWa
-ataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHa
-cHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSg
-SRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccW
-cMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcag
-YKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcacttt
-cWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKt
-ScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMtt
-aYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtK
-catgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgR
-WKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgt
-taaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttt
-tggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaa
-ggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgctatcgcccBacac
-ttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctg
-gDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYW
-catBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaK
-YaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWH
-tctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSt
-taScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaa
-HtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKca
-cRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWa
-taactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaa
-acattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDta
-gtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaac
-KaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttca
-NagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacB
-WgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWgg
-tgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgtt
-aagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaac
-WgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBa
-ttcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaa
-taatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDt
-ggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacB
-cattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBata
-BattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaatt
-ctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNa
-cttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaa
-cgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctt
-tStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtc
-HctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSR
-ctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKc
-gcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMaga
-taatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDg
-taaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWat
-tHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcR
-aWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtt
-tDttttagNMgVttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggV
-cgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgc
-VWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMt
-KgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMS
-gaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataatt
-aattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaat
-tcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgt
-aYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKt
-SagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtca
-BaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaa
-aVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaag
-atWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBt
-gaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRt
-gYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagata
-tacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcD
-gcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDt
-caacBtgHttggctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacg
-ttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVt
-ataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHt
-tgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRat
-aaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtg
-YVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVa
-gHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMg
-aVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtY
-ggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattat
-tcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagtcttDccctatBa
-tHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatc
-aYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatK
-cVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKt
-cDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatc
-ttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWH
-gttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaK
-tRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHa
-cgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgtt
-atcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcN
-caaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaD
-gcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaa
-agWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaatt
-ggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYata
-agaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtag
-ttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYac
-aKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatac
-attNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRt
-gtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaatt
-agagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtc
-tBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSg
-tWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgt
-taKaatagBtttcttagaggVttcaatRattNtccatttcagctactccacMatSHtaga
-taaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaa
-tcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYct
-tDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaact
-ataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaact
-tKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtac
-NtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcK
-WatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgattttatctaatRagttt
-ggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcK
-ttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgR
-cMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtat
-taNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWga
-WtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMattt
-atctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatg
-aatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKta
-tVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNc
-atctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVca
-aWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaS
-KcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagct
-KtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaac
-tatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtg
-gttatttagDScttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKV
-SttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWag
-gaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaM
-gatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagR
-gWaccattgaStttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaac
-BgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNa
-WNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtat
-gcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaa
-tMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtS
-NtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaa
-HBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcg
-DcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgtt
-cttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKag
-tctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYctt
-gYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgta
-agtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttag
-YaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatgtHatctagacat
-ttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMc
-cttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcc
-tKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttg
-ataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDac
-aDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttV
-RtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgV
-agtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatata
-aaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctac
-ttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMac
-ttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRat
-DtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctt
-tRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatac
-gtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMata
-KacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccag
-aaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaa
-HYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBca
-ctattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaa
-agacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaR
-tctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaa
-cgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMt
-tWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggc
-KNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaK
-tcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKY
-gttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDt
-tggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgac
-gcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSa
-taactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVct
-tatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaaatactgctgNct
-tgctcatatatactaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaR
-gacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKc
-aacctctgDVRaYaatattWttattcttataatWatattaccYaagWtgaataatgattt
-gtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgt
-tScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatM
-aaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVg
-tWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKR
-aVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagca
-tacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgY
-agNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattca
-catccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaac
-tagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataac
-aVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaa
-McatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaa
-MtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttg
-ttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaatt
-HtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacH
-tRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtg
-tcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatc
-aaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgata
-NgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgta
-aaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgtt
-attcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRg
-taDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgtt
-KaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNatt
-ggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcg
-ttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtD
-acYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNg
-aacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVa
-attHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaH
-DgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaa
-cacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHtt
-atacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacact
-WHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctg
-WaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatataga
-tttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNa
-tatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSat
-actgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKca
-ttttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagt
-tBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBt
-ttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacaca
-SatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatat
-aggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtc
-tMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgt
-tggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHat
-aaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgK
-VcattttHgctttgtgacgaBttttccatccMatRcaVataattKattaaaagDatVtta
-SRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWc
-gagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatca
-DRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaac
-ttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaD
-aatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatga
-atatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagc
-taaaWttBatDgMatgagatctKttaHactataSgattRataYaYatagaatDagtaDaa
-gatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBta
-KgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaa
-caYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttga
-acgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWt
-accagMtttcKgScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgtt
-catBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHN
-ctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttca
-tcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgY
-taVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcg
-VaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRa
-tgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttgga
-taaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRH
-YtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBata
-ctYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgW
-WtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattW
-gcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcS
-aaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctt
-tStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgM
-gatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStag
-ttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagcta
-WgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaattttSBttScgt
-BSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaat
-tattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMac
-tagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacga
-tRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHat
-HtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHta
-ttgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttc
-MacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagt
-ttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaa
-ctctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMc
-taaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBta
-tgccacattactcaaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDt
-ctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaa
-tttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSat
-ggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctR
-ttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaattt
-cVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattD
-gtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaaga
-ttgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWca
-cgSatacaggtagVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtct
-YMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctN
-aacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaa
-KaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaag
-WaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccatcgaWctataStt
-BgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNa
-BRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSa
-ctWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMW
-aVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHD
-atDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRc
-acttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaa
-ttttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMc
-WtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYc
-tWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgta
-DcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttat
-aKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaa
-ctcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaV
-cataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctct
-VattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagD
-gtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRg
-caatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtc
-acaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRa
-ataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatD
-HattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaV
-tDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgc
-aDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttR
-tctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBc
-tctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKac
-taWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStB
-attKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattgg
-aYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHa
-tgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttg
-HWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatcc
-atatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaatt
-aNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWM
-agKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaa
-ttgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttK
-VgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSaca
-taaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatact
-cttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtS
-aaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaata
-KDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgt
-tttttttgacattatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVt
-YVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcK
-gtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattB
-cRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcac
-aKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacag
-gttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRat
-gaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRataVtggaScgattt
-DMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDt
-MtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDtta
-atatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaV
-NatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactD
-tDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNat
-aaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKR
-gaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDattt
-aaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSt
-tHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVttt
-ctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHc
-NgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagattt
-ttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtga
-BaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaB
-aYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatc
-RgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRgg
-tttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgY
-BtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatt
-tgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttg
-VcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMY
-NcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRa
-YtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtc
-tactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagt
-gacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataa
-ttacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataV
-NactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWac
-gaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtH
-KattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgc
-taaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRt
-RaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtcKtaataaattag
-ggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWt
-tataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDt
-DccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKtt
-gaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtg
-agVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDt
-atcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcR
-YttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRca
-aBaacaVaKattHgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSa
-SYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaH
-RgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHat
-gaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDRaggataaWgMat
-aggtactatatttVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaat
-ccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaa
-cHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctN
-HatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaY
-acWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDaca
-tgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWN
-VHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatca
-cgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagR
-gccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttattt
-gtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgta
-attatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBt
-tacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataa
-gtaatgactgaVStaatcctcDagtcataagWtataatattacagScHaatatagcaHYa
-aSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaS
-aaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNat
-VttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgt
-HcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggttta
-cctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRt
-KKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaa
-MNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttca
-HtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRg
-aataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBa
-ctgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaat
-DWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaa
-WtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtatttta
-ccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYc
-agStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgct
-aaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatt
-tagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWt
-aataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatD
-MtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaata
-gattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcat
-ctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaB
-YcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattg
-tatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttag
-agaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctt
-taRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgag
-ggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcata
-cgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtaca
-tagttaattBBttMacatDtatttaaRggattatBVcacattattaagWctactVcaBgc
-ttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWg
-VgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatag
-YaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRN
-aaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgt
-attcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaat
-NcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBta
-ataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataat
-tBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgag
-atVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagag
-tcaDSggYatttDaaatcactKatWatcDatatRattataaatatctattHSctttggNc
-taagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaa
-aatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttac
-tatRWaataVcccaRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtK
-StStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacg
-atatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYY
-aaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBta
-BatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMttt
-RacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaag
-MacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHa
-aMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatat
-aMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtat
-aaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaa
-HtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatg
-ttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggt
-HcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtct
-ataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKga
-ttHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKt
-YtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKtta
-ttattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaac
-ataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatca
-taBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWcca
-tttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMag
-SMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVg
-ttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRa
-aWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaac
-caaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgtt
-aattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtS
-acatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataW
-atWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgt
-aYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattg
-tBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtgg
-cagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtaga
-gMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagt
-gctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDt
-VttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagt
-aKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNtt
-BaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaat
-actSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtV
-gVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBt
-tKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHc
-tatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRY
-aatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaa
-ttaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtR
-taaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcB
-cgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgt
-cBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatca
-aatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtc
-WNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataD
-gRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgac
-YgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtct
-agtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNattt
-WaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttgtacattSattaa
-cttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaM
-gacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctagg
-StatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccM
-aacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSB
-gKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaaca
-cWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctc
-ctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKg
-BtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcac
-atttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRt
-aaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRV
-tttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggacc
-gaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcg
-aRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaa
-NBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagta
-aaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaSc
-ttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttacca
-tacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKD
-gVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatH
-ttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtcttta
-tcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttacca
-aWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtgga
-atKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgat
-ctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDc
-aattNcacattattgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaaca
-aRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDW
-ccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgc
-tcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRacca
-caRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgcta
-MSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaa
-ttYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgt
-attctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagca
-DttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccat
-aaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKata
-caaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYct
-ataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaK
-RtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctag
-atcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWca
-YtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaS
-agYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactggg
-agcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScggg
-ataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctct
-WaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaa
-taaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctg
-WKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtc
-aaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaatgttatttgttt
-taBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaa
-aaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaB
-BaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataaga
-aaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtK
-tttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatV
-MctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtga
-agcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaa
-taHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaR
-gtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVga
-gtatttaaaattacYSattatttaYtagcaVSHattDctKcVattataagagRaccccWc
-aBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWt
-cMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSttaaataattttt
-aaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBa
-atcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHa
-tcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcactta
-gtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtV
-tgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDg
-tRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaac
-aattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStg
-cgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNg
-StYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatc
-aStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSt
-tgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataac
-tgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataa
-tttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaat
-cttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcV
-McatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDt
-ttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattg
-gaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDc
-gcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttV
-atgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaa
-aggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgct
-tgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcga
-aVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttg
-aYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWg
-atMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattS
-gatatgatactattWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagt
-ttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWta
-aaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaatt
-atacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcag
-tgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNtt
-gtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMa
-gatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaa
-SacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNata
-catYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaa
-atYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNat
-tatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNata
-tBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaaatYgctgtttta
-agatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccR
-actDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKR
-ctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaY
-DcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatS
-ttattYMttaatcatattcatSaYtgWaDacgaataactctggaDccattacgSagaaat
-tgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRt
-DagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatat
-MMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtgccctttattatS
-atWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactK
-acDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgc
-gcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaa
-cttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatV
-agVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatat
-tHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBta
-DNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatH
-gtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHH
-agYttStaaccWacaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagB
-BaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtg
-cattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNttaBWaacatgctt
-SattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBacc
-atKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWS
-gtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtg
-caaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatct
-actaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgca
-aactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtR
-aaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgt
-cWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcacta
-cWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBa
-gaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttg
-ataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcN
-KDactgKtacgBtDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaa
-agRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSa
-ctaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtag
-KtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgY
-atgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcg
-StVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDt
-cDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVt
-KattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMt
-aHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttM
-aWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtS
-NtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatt
-taKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtt
-taaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaa
-cctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtac
-ggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHg
-ctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaW
-cacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaM
-RNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaH
-tacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHat
-tWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaa
-tggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcaga
-attattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaa
-gVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataa
-aaVccNcttMtctattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMa
-cgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaac
-taHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRca
-DVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggD
-NcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagg
-gataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYatttt
-YMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaac
-RaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNa
-ttatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaa
-tNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRt
-ccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacD
-aYcccactcattcacYtattggatVgaWttctgSDagaWDattctacataaaDggtacta
-tagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDt
-agttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWa
-ctgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWcca
-aaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDt
-tttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatc
-tacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaS
-atVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSc
-caatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataata
-tVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNg
-taHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaat
-tttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgR
-aDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMt
-gtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttV
-acWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgc
-NDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVB
-tcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWS
-cYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagatt
-aNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaat
-taaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaatt
-VHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaSt
-KaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRga
-taaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaa
-VBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcg
-agtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMt
-caStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYt
-gHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDa
-tKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgD
-gagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNt
-caRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctggg
-tcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatat
-VgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRt
-tcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaat
-aaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBg
-RBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataa
-gttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVg
-aBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaata
-caDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttat
-taaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNa
-gtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtc
-aHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctK
-cBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctSt
-atattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatc
-gtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaK
-gtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaM
-ttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRa
-acaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKatttt
-YcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacN
-aVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaD
-gaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggca
-YctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgtt
-cagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaacta
-aaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBag
-gcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaac
-YttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSac
-acgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYt
-ctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKt
-aatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDc
-ttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttag
-tDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatt
-tNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgta
-tWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaa
-gaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattact
-gtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgt
-agDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagct
-ttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatcc
-DttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgM
-NagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRtt
-cctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcK
-tgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgS
-atRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMat
-gataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaata
-RtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBtt
-VgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatactt
-aMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBa
-tBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYc
-agacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSaga
-aDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaS
-taaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgB
-tgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgac
-gMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccatt
-ctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSV
-KtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaag
-catVattMacattSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccM
-gagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatR
-cDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacac
-tcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYa
-NtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatct
-caRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaa
-gtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDS
-HgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaa
-ttBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtagg
-tattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRttt
-accaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaag
-tagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDt
-gHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDa
-acgactMtaYKacBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHag
-RNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgat
-ttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWc
-cggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagc
-ttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHg
-acttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYac
-YtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtV
-KtagaagRttttttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgW
-accatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggScta
-aWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSac
-gtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacc
-tctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaat
-tgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRatttt
-ttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtag
-gtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggacta
-BSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcg
-aYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaa
-tHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWga
-atRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaa
-acNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcS
-tatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaa
-actgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVt
-gDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattc
-ttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaM
-taVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSa
-ccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRt
-gcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtac
-gaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaa
-taNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaact
-tacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagt
-tcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaR
-cMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatSc
-aNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVtt
-cgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcatt
-ttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctM
-aKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcag
-tDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSS
-aBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttga
-tRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatY
-aatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDga
-aSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgcc
-gaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaac
-aBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaa
-BatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatca
-DcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKg
-tgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKB
-ttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagH
-ttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatg
-taaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatc
-aYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcgtacatacatcta
-DactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMattta
-VattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtattt
-atgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBag
-gKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttt
-taBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBt
-caMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtgg
-tttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHD
-aataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWg
-aaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaa
-agggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaK
-tcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgcca
-aVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcatt
-acaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagt
-NtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttg
-NYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcga
-tgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWa
-gacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaat
-WagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccaga
-gttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtatt
-ttccttcatctacttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMt
-gctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtaga
-KMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNct
-acaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttc
-gtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtt
-taagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYat
-VaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgM
-MatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRta
-KttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactac
-cRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRga
-ttgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgac
-tcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaD
-aNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtctta
-agMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctc
-taSRtaYagtNgDagatWtRttSttNtRNagacatattttatggactacYMagtMacYaa
-gYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWta
-BaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaa
-aStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMta
-aaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttat
-WaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDt
-aMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRN
-cttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDga
-taMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagSta
-tStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWgg
-MVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYa
-tcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtga
-taKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaH
-RgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagta
-atttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgY
-NcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtW
-gaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgS
-aNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgtt
-ttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtN
-cNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHag
-tcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMa
-RcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgt
-ttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaat
-gSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaac
-tNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgta
-ttaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacB
-ttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatc
-ttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtc
-BKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaatt
-ggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaa
-agagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWc
-gaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDa
-tcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRt
-agtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaaca
-tccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaat
-ccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttR
-tgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHt
-aBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttD
-gggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttccta
-ttaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggaga
-cctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgt
-StttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtN
-SNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaa
-tYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaag
-NaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatt
-tcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYa
-ttatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaa
-cttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWW
-VBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRD
-attactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYc
-aagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttca
-tgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWc
-RttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcac
-gDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWtta
-tatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRat
-atttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtca
-ataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacV
-cWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgt
-MNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatD
-ggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNag
-cRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatc
-aaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaa
-atKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBD
-tWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaV
-ttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtc
-atggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtR
-tagtKaRWaataYaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMc
-tacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaac
-tRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatB
-WggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttg
-aHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSa
-taHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHg
-tDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgc
-atHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBt
-attHagtaacactDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaN
-YcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgca
-ggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtM
-MccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacga
-tSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatcatatKRattSggt
-cggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKS
-aYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMa
-ttNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMtt
-ttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKat
-RBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgK
-cgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHB
-ataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatcc
-ataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactag
-cgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaat
-gattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttB
-ttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNt
-BgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKta
-agSaYtgcacttDattYttaVgRcacaattDDttagattttcHagccaYaataKaatccV
-DKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBH
-ttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaact
-aaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSR
-catSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDt
-aStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtat
-ttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBtt
-cgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcSc
-DcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKt
-gggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtatttta
-tRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagttgtYatctagaB
-aHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBc
-HcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaYRaattccaNatg
-tgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSga
-tgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHt
-tcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtg
-NaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWY
-HaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYa
-SgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDc
-tWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaactt
-cYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataa
-tttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaW
-DMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaac
-cVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatK
-BRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtc
-gNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYt
-HYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDag
-cctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttat
-tactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNt
-taatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatB
-gMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttg
-aatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRt
-agagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgS
-RtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccaga
-atDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaa
-KHtttSggatgagMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcH
-HcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDact
-gatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaat
-acagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcat
-aattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaatacca
-ctctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattR
-tVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaa
-aatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaaca
-tcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaN
-MttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBga
-catStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtR
-caagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgStt
-gtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattc
-aggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNt
-taagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctca
-ggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaa
-atVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccS
-aaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaat
-MtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttt
-taaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHa
-aacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYt
-ttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaa
-BtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRga
-tgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWag
-aWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNa
-ccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaB
-tDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaa
-NcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYtta
-aaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcac
-aataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatct
-aKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctt
-taacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatat
-aKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatD
-BgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgcta
-gYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagtcttccatBagat
-ctBaaagSacagtaaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaD
-RaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKg
-tactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcg
-acatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWttt
-gattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtat
-ccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgta
-aaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDgga
-gWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgc
-tttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtag
-MaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtag
-SataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaR
-aaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaatt
-VgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgat
-DaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVta
-atWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaat
-gttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtag
-agtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatSatataWttctcg
-taDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYc
-gYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaa
-SMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtac
-tYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKM
-KgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcgg
-acNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaa
-WMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHa
-tacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDt
-HYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacag
-BKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRa
-atBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtat
-VtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatct
-aSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaa
-ttatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHg
-ttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttt
-tatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgt
-VgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcaga
-tgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVt
-RgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHa
-tgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRccc
-WtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctga
-tNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagca
-ttcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaag
-MtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRag
-tgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaa
-aDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaac
-aYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatattt
-aagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtS
-aatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcW
-YctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNtttt
-WHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtg
-tttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStg
-aNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVata
-ctgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttatt
-gacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRt
-NggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaatt
-attNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatB
-tNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgct
-YagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttW
-gBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMt
-gtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSc
-tactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYY
-aYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaa
-ttYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttS
-taRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcB
-ccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataatt
-cttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVga
-aacatWWctgcagtttctttttMagWttatRggcattattVaagaBBttatctattatMc
-NtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaD
-ctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtcc
-RaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgt
-SccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBtt
-NYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMca
-atcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaM
-gSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatg
-MctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggN
-aRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaB
-cttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgaca
-cDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttc
-agtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagataacactcataVg
-ttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattcc
-agccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaat
-SaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYV
-ttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgc
-gatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagt
-atHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaa
-DtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgtta
-aMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggac
-tttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctga
-tKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVD
-cBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctH
-ttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDa
-tatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggca
-aDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtga
-atttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatct
-atKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNg
-aVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccga
-VttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRW
-caSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatc
-tatttHaactttcgcttttccatttNaaYgtattttactttacttRataBttgataggga
-cattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgta
-BtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatca
-tttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatB
-agcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctga
-ttgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgat
-YattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaata
-cSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatact
-agDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaM
-KtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattag
-WtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttaga
-SgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaS
-aattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttg
-aaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttg
-agWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgt
-NaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaa
-taVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKg
-NttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattg
-aWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDt
-tataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDac
-aaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaB
-tYttaRactaattggagagggtctagtatgggtttacttBtatcatatgctaKggNcata
-aaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttK
-tgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctW
-BacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSga
-YaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBca
-tWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccR
-cctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSaga
-ctYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgac
-atgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKat
-cttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMttt
-aStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMa
-acattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRa
-tatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKa
-cgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDW
-gagctgcgaggggVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNg
-ttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaataRattagHacac
-aagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMg
-cataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWg
-KgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctc
-atgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctat
-tcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaac
-taWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaa
-ttcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagct
-ctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgW
-BaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRt
-ttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYagactNaatgttt
-gKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNc
-gatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtW
-ataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaa
-acatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgt
-gcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttatta
-aBcKatDagttactcttcattVtttHaaggctKKgatacatcBggScagtVcacattttg
-aHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttag
-attVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttS
-cactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggt
-tgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHa
-YRttagatMatgcatttNattaDttaattgttctaaccctcccctagaWBtttHtBcctt
-agaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcg
-gattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNatt
-gctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVa
-cVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaa
-KaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagta
-aVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVca
-attHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcact
-tacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaata
-tttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRta
-acBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgR
-SacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSR
-cgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccY
-tatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtV
-tgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaat
-gcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaat
-taaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatat
-DttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctS
-actHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBM
-aatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtc
-gaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaa
-agctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatW
-actcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtat
-gtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHa
-tttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctK
-gttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRH
-SctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtB
-tatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHg
-aWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgtt
-KaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgc
-attaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaS
-ggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcSatcttagcaatg
-aVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgt
-WacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatga
-aaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatR
-aVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgt
-cDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKa
-aDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNa
-caScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtg
-atSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgR
-ttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaa
-aatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaa
-atSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBag
-BttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattY
-atagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatgg
-KttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNt
-atNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgat
-tYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWt
-StaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBM
-aDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattS
-DttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaatt
-gRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDt
-gaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctacca
-cagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttcc
-gatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSg
-agtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaY
-aSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataM
-HttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataH
-gYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYat
-tDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaa
-tcaRaagataatagatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtaga
-atgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaa
-gBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHca
-YYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVa
-acgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcg
-tNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaaga
-tBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttD
-HaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctg
-gacStttcNtggcaVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBtt
-StStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgac
-HaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWa
-tgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaa
-tttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYt
-caaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatcaMatactataggD
-aHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVctta
-tKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNt
-accaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataa
-acaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatca
-aatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRt
-gtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBc
-taaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaS
-agtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaac
-caYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgta
-tBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYg
-tRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcat
-tggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtR
-YtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVt
-ggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtV
-aataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtc
-DtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaB
-tatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaV
-cHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttatattacHactgtt
-ataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcat
-gWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcatt
-MttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccat
-tVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYata
-tNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaaca
-MtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttgg
-SagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWt
-aRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcat
-cttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNa
-ttBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgH
-caaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYt
-aKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtgg
-taMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKat
-MctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaat
-tattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaat
-aMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNg
-HttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaa
-ctcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacag
-YtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttata
-aatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVct
-taBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWa
-cgtaatgKttWattagttttNaggtctcaagtcactattcttctaagKggaataMgtttc
-ataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtM
-atatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRat
-agSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDc
-gctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaK
-ccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaM
-gtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaa
-aaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHtt
-RaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagN
-aBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccH
-caRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattga
-RagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHt
-caaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggtta
-WatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWag
-caKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattccc
-RtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaag
-aaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttat
-acYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttSt
-VatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNc
-tgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMag
-ttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatB
-gtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKcatDaattgatta
-tDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaa
-cataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgt
-cgYtactDcgcctaNgagagcYgatattttaaatttccattttacatttDaaRctatttt
-WctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgt
-ttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNgg
-tcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgM
-DKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDt
-cacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgM
-tctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttS
-attgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaat
-gMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctRgatgttacccta
-HgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWtt
-McNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHt
-VtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNa
-ttccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctag
-aaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacga
-VtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaV
-tVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgB
-tctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcg
-gtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttctt
-ccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaW
-tgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacag
-cMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcN
-cSattNacttggaacaatDagtattRtgSHaataatgccVgacccgatactatccctgtR
-ctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgac
-taagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaa
-DtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgt
-aYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcaca
-gtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRS
-tctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHca
-tgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatg
-taggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKt
-aaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaag
-taagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRt
-ctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNa
-SaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacg
-HtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtct
-gctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacac
-acaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatc
-ttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSg
-YataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaatacc
-RgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKW
-tgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgatatatttttgtStW
-aaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagta
-aDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaac
-ggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccacc
-gagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaat
-tataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBt
-gtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcg
-cgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBa
-ttHcBWcaactgatttaatttWDccatttatcgagSKaWttataHactaHMttaatHtgg
-aHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacc
-tttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaata
-agtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaa
-WattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgS
-gaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHcactttactataca
-aacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaat
-cttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtc
-tttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcM
-gattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaa
-aaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYt
-caaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcc
-caNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaa
-tRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgt
-gRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagt
-taKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcR
-ctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctac
-atKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKataStRaatatatt
-cctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctatt
-gtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattM
-atgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagag
-gtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaS
-atttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKga
-gtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaRgattctttaata
-aagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYta
-atatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcc
-cRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagac
-atgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaa
-tatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactga
-taNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVg
-tccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVB
-tcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRRYttStggaactH
-gttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatg
-gaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDc
-aHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtc
-taactKataHacctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDtta
-MRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBt
-VgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWag
-gtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttt
-tNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMt
-aatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStg
-tgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRH
-VYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKag
-YNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaa
-aaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaK
-taataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttca
-aDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBB
-aattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgtt
-DgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBg
-HHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagta
-taatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaa
-gSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacct
-NVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttaga
-ggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagtt
-ggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWt
-gataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcga
-ttaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtact
-VaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtc
-gttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatt
-taRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaat
-MNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttM
-DataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKa
-BtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttac
-ataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatata
-ttaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtac
-gatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaD
-ataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNta
-WctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattc
-tSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtaca
-cHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHa
-taKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaa
-atgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaata
-aaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKat
-NYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNt
-ataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaN
-acgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYta
-tatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtata
-ttgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMagg
-BBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaa
-taaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHta
-gVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaH
-HcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtctta
-acgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatY
-DatcggagagcWBataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDW
-cWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagS
-attaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtattt
-ttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatN
-atcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacg
-tagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVa
-HatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttt
-tttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcct
-ctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgacc
-gtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRttta
-gtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagB
-tgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatc
-tgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBc
-ttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggtt
-gaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtca
-acHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaac
-gNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRa
-taHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYt
-aagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcga
-taatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcct
-aataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBR
-tcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaSt
-atccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKH
-ccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgta
-tgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtcta
-aagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgt
-KtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttN
-KtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaa
-tHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacag
-DRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHt
-tatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaa
-ttScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaa
-acgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaY
-MtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaH
-agcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtac
-aVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKga
-tacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattttHggNagSctac
-HgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgac
-cttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKa
-tWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaat
-atgattagaactccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttca
-agHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagV
-aDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgt
-BtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtH
-ccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaag
-attaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMc
-VatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaa
-VctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNH
-tDaYtaataMttacggctNVaacDattgatattttacVttSaattacaaRtataNDgacV
-tgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatg
-agaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBS
-tWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWc
-taacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaac
-ttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBD
-RaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtg
-atVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaa
-tatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRg
-ttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagc
-agtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMt
-StggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaN
-RacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatga
-ccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKM
-BaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatggga
-tttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgt
-acatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSS
-aHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVa
-tgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaatt
-gcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaat
-HtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtK
-acgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRD
-atMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactgg
-atDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttag
-aaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaact
-cRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKB
-tttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYt
-tcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBa
-SctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcW
-ttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNH
-tgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagt
-WMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaR
-aSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNt
-VtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRat
-gttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBt
-actgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttac
-taaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataSt
-ccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNta
-ttgtccttagttagMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaB
-VtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMc
-tatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatg
-gcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSata
-tcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSt
-taHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatg
-DatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaY
-taWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaa
-KaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNc
-tDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagtt
-cHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNca
-tgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaW
-ttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccc
-cBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatK
-ttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatc
-cttgaYctattcaaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattat
-tKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYag
-cactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatat
-gMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYt
-taNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHB
-ctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBg
-WagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYt
-YcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtS
-HcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttata
-VgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaa
-tttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcK
-taNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagt
-cSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRact
-aaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttct
-aacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctca
-agaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttR
-tBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtca
-VYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccga
-tattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaR
-BtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWta
-aagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattR
-aYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatatt
-ccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBc
-ScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWt
-gNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVga
-cctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaa
-atttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggS
-aRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaat
-DcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtt
-taYtagcagBagHaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSa
-aaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWat
-ttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaa
-ttatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataata
-tcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaat
-aDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWa
-aaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcB
-ttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaa
-DaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDa
-aWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagac
-aagNtattHggataatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgt
-atctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtt
-tKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKat
-StatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBD
-tcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBa
-cHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtat
-acttttKcgtcggSYtcttgRctataYcttatataaagtatattaatttataVaacacaD
-HatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVg
-tSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRgg
-WatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDt
-gMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDat
-caHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKtta
-aatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatga
-gDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatc
-ggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatag
-BattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcg
-KMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaR
-aMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagcctt
-MaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatat
-tataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtata
-agttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacct
-gggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatag
-acgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBgg
-tataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKac
-cHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcHagacBWatagca
-MtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNac
-tHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVM
-tcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgtt
-aataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaa
-NttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRa
-tMattRagataaccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNt
-tHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggag
-ttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaa
-SttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVct
-MtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNct
-WttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaa
-tctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRg
-gctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttt
-tYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgt
-MatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctata
-gccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaat
-HcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSa
-gctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagcc
-NctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMta
-gtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtga
-tgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaattgRataatacg
-BtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaag
-gaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaa
-atgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgcc
-aHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKt
-WRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKS
-aatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagY
-RagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKtt
-NtKagaaYaStaactScattattaacgatttaaatgDtaattagatHgaYataaactatg
-gggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatg
-atWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagta
-atatttatatataacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgtt
-caaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYt
-DcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgtt
-atgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatB
-tttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgt
-RaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDW
-ctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWt
-gttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWac
-gRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaY
-aHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaaca
-tgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtS
-gKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagD
-aataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStctt
-agtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtaga
-SRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVc
-DtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaH
-ctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKcc
-HaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgatt
-KaaattttcatctaatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMt
-DKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaaga
-acaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcN
-ctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtg
-BataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattN
-VtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaB
-cttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcga
-atgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttc
-aacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactctaMaVRattacag
-tgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgc
-aaaVKtagttataatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaat
-KKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaW
-gcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttc
-cStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctatt
-WttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaa
-tgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBta
-atttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttac
-tggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatKaSgctttattta
-gtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaH
-ctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBH
-tcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNa
-tacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttga
-SttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttatta
-WgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatataaataRatSaBct
-agttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYg
-aBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttgga
-MtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYY
-aWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatc
-tagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttga
-aMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYtta
-ttttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctca
-gctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctB
-YaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaattta
-tcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtat
-RKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKa
-attgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgt
-aataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaM
-tgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMag
-NcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaScta
-KatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcS
-aagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtg
-aaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttg
-actttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagt
-DRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaa
-tStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVg
-DtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDg
-aDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNt
-tNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWcc
-WKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaB
-tHgatgttacatgcatatMtttgtaacScWHBatHactggatatatctgagMgRSatcta
-aSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHM
-tcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttW
-tWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaata
-RaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWga
-tDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgS
-aaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatWcgaactacacta
-actNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtac
-agacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaat
-atgcataacccaSattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRtt
-atgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWc
-aaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaa
-tacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVa
-acSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRW
-gaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYg
-gtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgcc
-SNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVg
-aagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaag
-tcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtc
-atatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttat
-gaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacac
-tatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKca
-tgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctct
-acaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatW
-tYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYt
-tgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatStt
-ctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYc
-cagcaHatKctaKaDgctagacttattgattaaYttatcttattattStaattWaRaYBW
-agYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaa
-VaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDtt
-gaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgtta
-WtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKg
-YtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKag
-VcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtV
-cRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtatttt
-gcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRa
-RtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDt
-acttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgt
-gagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaatt
-cactatYttaagacactaKaagRtRataaattttcatHggtaataaatgataHtggctaa
-cBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgaca
-tVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggtta
-aBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactVtttatBaKHaga
-WgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatact
-tSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHa
-ggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKa
-aatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttS
-MaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataS
-aataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYagga
-tWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDV
-tatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcct
-gataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcat
-tRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRat
-ttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattS
-aaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNM
-aWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttc
-cWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacgctMgaagtaaca
-acagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBW
-aagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNct
-cttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSa
-ttctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBK
-cggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaH
-KagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttB
-tSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRg
-aDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHt
-BSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttc
-agcttWtttagtgataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaV
-cctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatg
-aBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRtt
-NWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctga
-aSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDR
-WBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataatatagtcttttt
-atgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVa
-atMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWa
-aMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBg
-VgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatR
-tgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaa
-VagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaa
-actagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWag
-tgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtY
-agSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtg
-tcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYt
-agtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttat
-tHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggat
-KtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNM
-atBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtS
-tccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgtt
-ctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNt
-cStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactga
-aaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgc
-cagtSttatatRaBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBag
-acgttatRKtgatctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaY
-atBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcM
-ttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaK
-gHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaat
-ttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatataca
-taatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDcta
-agagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaa
-ctccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtaca
-RHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaa
-aaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatgg
-ttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtata
-tttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattD
-tYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtg
-cSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMt
-KttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcc
-tVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaa
-gatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagaca
-gtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNat
-aaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttD
-atNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDa
-ttatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYB
-aaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaa
-aaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtga
-aScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYt
-ggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMc
-tMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaS
-acgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagac
-aKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaScttta
-ttgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaag
-gtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgct
-gcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatS
-RgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgat
-ccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatW
-aVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatg
-tgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaB
-tagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaV
-attgatttaagYctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKt
-YtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtgggagccaattct
-cDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatctt
-BtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgat
-tBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaata
-tttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgaga
-BgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBgg
-KaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgat
-atgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagat
-atcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYa
-gttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtH
-cMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaat
-atgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattg
-gatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaB
-BacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgat
-gWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgct
-YtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWt
-tggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaa
-acaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtag
-RgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHa
-aScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagt
-gKtatgattHcYcttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaa
-ccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDc
-atYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBM
-agBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaat
-actRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNc
-cagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataK
-caHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcM
-cgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaa
-aYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDt
-HatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtR
-atcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgH
-aRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKga
-HWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtSt
-aVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDa
-RSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacg
-catgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgc
-HcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccg
-YaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMat
-aatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtat
-MRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYc
-gccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaag
-tgttcacatataaagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtB
-ctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBta
-gtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatca
-cMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgtt
-cctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgSttt
-NaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttt
-tcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattagg
-taatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatM
-ttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNt
-aYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatM
-gactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtS
-acgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtact
-ctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgta
-tccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKB
-BattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRt
-MtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWa
-ggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKag
-WattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggta
-NgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcV
-tBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtB
-tagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcg
-ctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKt
-aaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataW
-taWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcg
-atacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgN
-atSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttS
-agccatRtatatcactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcc
-tYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaa
-tgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagt
-aHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcga
-cctgcaacgttttattacNMWNcattataDVDactatattatYattttgcgaagtgagYV
-tagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaaca
-tccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactg
-tNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaDttWactttgaSt
-aaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccg
-gNWaacatacatgttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYt
-aggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYa
-MaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagt
-ttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgt
-cagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgac
-aaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtc
-gctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaag
-SacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgc
-HctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSW
-tctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatY
-SaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBa
-YtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgKgattgacgaccc
-ccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgc
-caactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgct
-tatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNt
-ggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacg
-aagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNa
-tttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtg
-StcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgc
-ttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagcta
-aagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBcca
-NagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStS
-cRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSgga
-aaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacat
-cgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatc
-tggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcM
-gNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaa
-aaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatat
-catttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgc
-aMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaa
-gtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgtt
-gtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggacatcgccWttagtt
-gWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgS
-attRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMac
-WttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKt
-aactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgtt
-ggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBN
-WtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactag
-cgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataV
-aggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaata
-gttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggta
-WSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacata
-atVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgc
-cttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtcc
-agaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaaca
-tKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaattataactcagtSga
-tataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacag
-gaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaB
-taggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttK
-ggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMg
-gMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRc
-atctSDcHcMgcaactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKc
-tSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBa
-BtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMt
-MaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaag
-ctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKt
-ttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWt
-aSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatg
-gaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaH
-NHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaag
-RttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaa
-aaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacK
-taacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatga
-attatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNB
-aatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattt
-tcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNt
-ttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgctaatWDataattta
-gaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaa
-ctHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggt
-HBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRcta
-caataKatattctaVgtgtaattRacKagttattgaMtaatgaNatacDataaggacttt
-ccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattgataaaactggat
-cactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaatta
-ttWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagt
-MWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDc
-ccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaatt
-gSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcct
-BtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtM
-tKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVa
-tgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNac
-attRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBata
-tgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcg
-cagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcH
-YtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccData
-NactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttc
-gtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcga
-atSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSa
-tRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatataca
-atacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggata
-WMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaat
-HHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYt
-atKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaR
-aaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtata
-gKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccacttttctatacta
-gtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactg
-ttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaa
-tWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcata
-gBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataK
-tatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHa
-aaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatY
-tacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRY
-aDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatV
-atcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDt
-tgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctN
-ataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagg
-gaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaa
-tVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtt
-tggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgt
-ctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgcc
-gttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKta
-cgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgB
-tcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKc
-tctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMc
-tttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgcttttt
-catcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatga
-aattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaac
-ctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYa
-tatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtat
-aaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgta
-gaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggt
-aactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMS
-tatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcat
-agaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVH
-aaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMtta
-gcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgta
-aaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatB
-tgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBR
-BttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtataca
-ttaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtct
-ttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRt
-tWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaa
-tgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaa
-aaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaY
-BgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaH
-ScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKac
-aBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaaga
-gaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDac
-tccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaatac
-cgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVa
-tDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgact
-acaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRga
-actgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattStacctgaattctW
-atNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaatt
-ttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttH
-aatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaag
-atgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVc
-MNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaa
-MacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWH
-ttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagW
-gcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctg
-VcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMS
-gDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgac
-tMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMccc
-gtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgND
-HaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatg
-atttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaa
-gScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaag
-tgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatc
-SccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWt
-KgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaN
-HYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHctta
-catcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVM
-tWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttattta
-gtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgttt
-aaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaV
-atcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaa
-tcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatB
-gaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaB
-tgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatM
-aaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaD
-agttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtg
-VcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcg
-aaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgct
-ataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVB
-tgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaat
-taaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNa
-KagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgW
-ttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWH
-tcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggt
-NttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaagttataNaataS
-atacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYt
-MtacKacHttttKtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaat
-cccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMt
-aacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtac
-taVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaat
-caYtSgttttataaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaata
-ttacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcD
-MggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWc
-tYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtg
-gaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtacta
-tatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatat
-gWtacaaaWttggaaactttaScataactRattMtDacVYataaaagMaattttKtgaBt
-tKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaa
-tKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaa
-tatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYc
-gtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMtttt
-attaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttaga
-gcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacW
-tttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgcc
-atatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHK
-ttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactc
-ctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBat
-ttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacg
-aaaggKttacattgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSat
-ctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctat
-tKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRB
-atataWaatKctcattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNg
-RVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtat
-RatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatS
-taaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgta
-MccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcac
-ttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagK
-tWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgt
-ctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggt
-SatBMBDactVtggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgt
-aKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttga
-acNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBR
-ttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatga
-NHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgtttatRatctattta
-gacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaR
-tcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVata
-aSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtS
-aHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDt
-caMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMc
-KaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgat
-cttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHaga
-cagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaa
-agggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgV
-atccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggct
-taHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatt
-tMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaa
-aNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaat
-tcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaacca
-tgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcata
-taatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcat
-VtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaa
-aatagStcggRttaattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgB
-tgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVca
-tattttagMcgtattNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNa
-aDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtac
-YVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttatt
-WtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHB
-gttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaat
-KtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNH
-tacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMa
-atNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHct
-aaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcD
-tMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaag
-ttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatg
-NatSYaattRatgcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRt
-ctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYct
-aWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHa
-aStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYctta
-ctttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctc
-ccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSat
-tVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacg
-ttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaR
-YtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHtttt
-BaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctct
-tNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBc
-aagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgt
-ccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcg
-aaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgg
-gRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaac
-ctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtga
-BtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcctacgagatcacc
-gtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaM
-taattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcattt
-aagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaa
-DtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaa
-ttKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYt
-tttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcg
-tttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaa
-KgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagt
-BgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagt
-NtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttcca
-tatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtag
-cagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtt
-tHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatatattattataatt
-BatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDcta
-caaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcat
-tatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaa
-gactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgc
-DagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaattctctaaMata
-ctaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDta
-gaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcg
-tgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaat
-gaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaa
-agaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtcc
-attataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSSt
-NtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSV
-YKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagY
-HaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaatt
-DtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBg
-gcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctg
-attatagattagtatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgtta
-agaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcattt
-aNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBat
-taYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaactttt
-acaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKD
-ttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgttt
-KRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRW
-cgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtat
-ccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaag
-gtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaa
-YtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagcca
-gcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBS
-gtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatD
-aYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBt
-acctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRcta
-KtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataag
-tgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacH
-agHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagc
-tRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatt
-tVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVB
-ttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagaga
-aaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcN
-attgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttt
-tacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtN
-MttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaD
-acataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVtta
-agaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKc
-aaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctag
-tatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtc
-WaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgat
-ttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaW
-gaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattc
-ctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRctt
-NgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWca
-tcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHa
-atgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtac
-gaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMta
-cttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaH
-aggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNK
-gatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYa
-tKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDta
-KgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRta
-RaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgt
-aacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagag
-StHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBtta
-BgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaY
-aDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtc
-gMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHta
-ataagttStccaatcHataatacMcattHtacaatttctgatggacatatgcaaacaKBa
-tgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRga
-gaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtB
-RaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVta
-taSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHct
-HtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSa
-atcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagtt
-VacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacN
-taHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacg
-DatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagta
-tatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagV
-YVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatg
-SStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStg
-aagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatB
-ttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggca
-gtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHag
-tcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNg
-StggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYt
-gtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagc
-NttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacD
-ttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNtta
-VtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRM
-gaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKW
-tDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctVtaaVggatccta
-HVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccata
-ttacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgS
-aaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggta
-aagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDac
-acVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaat
-agaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDt
-WtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRac
-VataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaa
-tMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaa
-aattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYW
-cSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggag
-ggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttcc
-KtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagag
-aSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcat
-taaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHc
-WgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNat
-gaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactcc
-gSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSaga
-tcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgt
-aaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatW
-tHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNat
-tacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKt
-ctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagac
-cKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMW
-YctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNca
-MWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYtt
-cYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRta
-NgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVg
-RgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaag
-MaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBV
-atHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNttt
-gatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaa
-KtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRt
-aatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgt
-cRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMt
-aaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaa
-ataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtgga
-tBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHa
-atBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacga
-RaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggt
-ttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSa
-gcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSa
-aWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtS
-BMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaS
-aagtttattttatgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtga
-tDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRV
-gattctatgtgtatHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgt
-cagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagat
-tttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtact
-tcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKV
-YaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWM
-aDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtc
-aDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccgattattRStcca
-aaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMY
-SWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWact
-ccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaa
-tgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNK
-aaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaK
-taatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtD
-ttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccat
-atKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHSt
-ttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttc
-WaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaV
-cacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKg
-atcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDatt
-HDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtSta
-VttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRS
-NtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNtt
-agaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaa
-agtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaa
-atgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNg
-McgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatataattggVgaRctR
-tcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatca
-MSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaa
-aagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacg
-taaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtata
-aatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtt
-taacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaB
-acgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDat
-ttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttat
-tcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWN
-WgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDV
-taatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBt
-ctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYt
-ctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagttta
-aKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatc
-aVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWag
-aaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcY
-attgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagN
-tgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacK
-cttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccct
-ggVattHaatVagaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWcca
-tYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtatta
-YcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggcca
-cgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYaga
-HtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaa
-aaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBgg
-ttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgta
-tggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtH
-tHttatYaaagcagatgtgattagtggcactactVattagatctctgtttatcattYttg
-atHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVt
-tcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcc
-tBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaa
-gactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactcca
-ggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaat
-aKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttH
-attcatttatYtattagtataYtttagYcattagaaataHtaaccttactcatYttHMRa
-gttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaB
-aaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaa
-aattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNta
-atatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWat
-ccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWc
-tttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccV
-WaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctac
-atgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBa
-ggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcag
-ctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgt
-caWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactS
-HctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatat
-aatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBW
-aBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctg
-tcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaD
-tKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaW
-ataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatSt
-RgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgt
-ctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDt
-tcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtat
-ttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggta
-gtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgc
-tctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtg
-tSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtat
-atataVtagcgWccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctct
-acatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaa
-cccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatH
-attgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgat
-ataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtg
-gRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacB
-tWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtat
-gDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgt
-RtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttat
-tcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHaca
-aaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttag
-HcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSa
-ataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttctt
-gtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaa
-aaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRc
-VctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNM
-actactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaat
-aagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYc
-aaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcM
-aatttWMggtctatttggaKagaggatWcatttgctatcgcccBacacttataagaYtcN
-cagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaa
-aHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRt
-tMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttR
-agaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgH
-atgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaata
-tDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRat
-aBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRa
-HtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccg
-aMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgc
-taVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcaggg
-RRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaact
-aatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRat
-BtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagac
-gaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacg
-gcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHB
-cgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHa
-ggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKga
-atatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaataatatgttttt
-aagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNtt
-DWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaStt
-gatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatg
-taRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatN
-ttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYB
-aHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatM
-gaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatV
-WaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggt
-atRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBa
-taaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVB
-tagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMagataatgactMBat
-BctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaa
-ccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaag
-RSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgttta
-DccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgV
-ttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatD
-tVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSgg
-agttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVt
-aattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaW
-tattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcg
-atHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtN
-attStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKS
-acaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKcc
-gHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaa
-tatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNatt
-ataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDgga
-aagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaV
-taattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacaga
-taaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttg
-gtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataat
-WNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttgg
-ctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaat
-acaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaa
-BMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctt
-tgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcatt
-caattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattac
-aWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttc
-gaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgag
-KRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggc
-taggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaW
-taggattScaStgattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBY
-KKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNa
-RgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggc
-aaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttc
-cRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtct
-gRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWt
-catHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacgg
-aaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWa
-tgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatg
-KgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggc
-tcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtc
-aaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatca
-DMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatV
-ctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttatta
-WMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggat
-acaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHc
-taaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatacattNgttagagN
-ctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaa
-aRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtat
-aMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagc
-atgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattca
-ctaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBttt
-cttagaggVttcaatRattNtccatttcagctactccacMatSHtagataaaWgaagttt
-gDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgS
-acctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaac
-NgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagSt
-aaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBt
-cccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMN
-NcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcg
-ccttttgtBtatatttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaV
-VcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcata
-cgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDa
-NtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactcta
-agtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStc
-atgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgc
-ScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgcca
-ttacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHata
-tMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggat
-gVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaD
-taaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttK
-caaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVg
-ctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYc
-StactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDSc
-ttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNa
-ttMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWt
-BataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccg
-acKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaSt
-ttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVat
-ataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctg
-caMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaH
-DtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaag
-KtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctca
-SSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcM
-tMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNta
-agctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWB
-SNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttt
-taccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWt
-tgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDta
-cStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaa
-attatYNtYctagtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgt
-tttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccatta
-caBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKt
-catctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattat
-cMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgctta
-tctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgtt
-BDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNc
-aaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDt
-gtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtct
-ttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatN
-ttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaa
-tcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaacc
-agtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagta
-gatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcg
-cNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacH
-RgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDa
-DVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHg
-gtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagta
-attWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaa
-ttcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcga
-WgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDa
-NtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgact
-ttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaKtcactWaataat
-YgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataR
-aaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBcta
-ctacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMa
-ggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtg
-tgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRSca
-gDtaKtatttYaSctttctcatccttaattagttaaatactgctgNcttgctcatatata
-ctaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcK
-tacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRa
-YaatattWttattcttataatWatattaccYaagWtgaataatgatttgtatBYSaDcta
-tRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYY
-atattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtV
-VgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRt
-gctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDR
-agBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctg
-cMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaa
-tBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWatt
-gcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgt
-agtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgc
-cggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDa
-caccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattD
-taagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatSc
-gatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWc
-tcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBt
-aScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSga
-aWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcac
-atatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaa
-gKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBat
-aRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYtta
-gNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgt
-aMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWS
-gWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagat
-acNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaH
-aYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMa
-cagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgatta
-aKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatB
-taattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMR
-tgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScga
-tgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgt
-ttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatat
-gDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaa
-gagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatca
-aaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaY
-tctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaH
-KaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaac
-SttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgata
-cSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYac
-taaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHcc
-acatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaa
-gtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggt
-SaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaata
-WacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttW
-agtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctt
-tgtgacgaBttttccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKH
-aacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgct
-agagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtac
-BtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataSca
-DaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataH
-tgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtW
-gatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDg
-MatgagatctKttaHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWS
-gtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtac
-gtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgc
-ggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWD
-tSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKg
-ScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaa
-ctattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaag
-tcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtc
-KaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVat
-BaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccR
-tHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVta
-aYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaN
-tDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHta
-ggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVtt
-aWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaV
-VgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaa
-taacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHB
-catcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccB
-tccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatM
-aaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaH
-aacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatg
-MacataWaaMtataggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacg
-aVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgt
-atRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaD
-taattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcat
-taSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWa
-taactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtY
-tctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaK
-gaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHttt
-DtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaS
-atYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaat
-BgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattact
-caaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWt
-aVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMac
-tKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacat
-aWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHa
-ggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgD
-DcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRac
-tHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBg
-cattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggta
-gVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaB
-gDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNt
-ttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaa
-ttgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaa
-tRcacttgttttcaaattctggcccttttBgHccatcgaWctataSttBgataacagtac
-ggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBt
-atcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaata
-gaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccY
-tgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgc
-agNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRM
-tgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDc
-agaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVat
-ttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcgg
-aMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtact
-ctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttat
-gtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaD
-agScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWg
-HBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMat
-HWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatV
-tatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcatta
-BaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcc
-tcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctK
-tDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacStttt
-atWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgttt
-KMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgt
-YtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNta
-aatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMS
-tgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMta
-DtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKtta
-cMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacR
-taDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactc
-atVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKS
-atcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNt
-aatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWc
-tWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatat
-ctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatacta
-aWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctca
-ScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtV
-StaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttct
-tatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHt
-ttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaa
-attKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacat
-tatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtga
-tataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgta
-tWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagct
-NgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaa
-aNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgD
-gcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaaga
-tMcacatBatgtStctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYa
-YtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHcc
-RBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRatt
-NcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRB
-ctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWact
-tctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWH
-tYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWa
-attcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagt
-aaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgH
-ttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacag
-gtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatg
-DKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYt
-atVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagt
-aDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRa
-atctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRta
-agtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtc
-caMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgYBtggcatRtact
-tBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaagg
-ttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacS
-RtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMt
-tRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVct
-ttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMc
-VaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgt
-aaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacg
-SaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatg
-gtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaac
-agaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttga
-tgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagc
-cgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaN
-tWVcctacatacYtctgKtcattatctattatcgtcKtaataaattagggHctcatgHtt
-SNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBca
-tcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaa
-gttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcat
-tggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBgg
-tccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaa
-BaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcRYttagcatactt
-tagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKatt
-HgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtca
-tactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatag
-caaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHt
-ttagttttataatRWggattYatatMaaaactWaDRaggataaWgMataggtactatatt
-tVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaatta
-caKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgat
-tYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaa
-cWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtc
-taatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaata
-cgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYta
-gataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatgg
-tacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagct
-cVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRaca
-VcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgc
-WtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaat
-DttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaV
-StaatcctcDagtcataagWtataatattacagScHaatatagcaHYaaSagaaaaactY
-tRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKt
-tccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNg
-caSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHg
-WggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBa
-aatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMt
-attagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWat
-tatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHt
-SaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVD
-ggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctStt
-ttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYY
-acSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKat
-aaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcag
-ctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaa
-RttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttga
-gaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMV
-ctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtD
-aHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMt
-aaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagta
-BttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaag
-tagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgH
-actatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatc
-tttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtt
-tBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaB
-ttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttcta
-aatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagN
-aggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBt
-tMacatDtatttaaRggattatBVcacattattaagWctactVcaBgcttKagagttatR
-BgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacD
-aaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcatta
-acSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaSc
-aSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattag
-gagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatc
-RRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtct
-ttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataattBStcaatttaW
-cattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtc
-atagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYattt
-DaaatcactKatWatcDatatRattataaatatctattHSctttggNctaagtSacgaga
-tatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRa
-VgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcc
-caRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaata
-cccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaH
-acaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWK
-cagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaa
-gtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYta
-tcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatata
-HaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttatt
-aaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactag
-KgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtc
-tcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaY
-ataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDc
-ctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaata
-atVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNa
-tcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNata
-caagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBD
-KVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaata
-gatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagt
-ttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaa
-agataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWccatttgtgaccttt
-MSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgN
-tatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacg
-tacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgtta
-tRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagV
-RBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHg
-KtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKg
-VaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtB
-ttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttga
-gtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYag
-taWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYg
-KgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgat
-gtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctc
-DtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgD
-gtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMa
-MtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaM
-gVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSY
-tttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgta
-tBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttcta
-ggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtS
-aNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRYaatggtaVttta
-aaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWcc
-VattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacct
-aaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNt
-NgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaac
-MRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaa
-gtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaa
-aVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataY
-aBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttag
-ccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgc
-BttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctag
-atSctaactctDttaagacgcatagcRNgagatttgtacattSattaacttttcgttgat
-tWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDSc
-NctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctaggStatttacaact
-cKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgc
-ctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaaga
-gataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVtt
-aatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtY
-ttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaat
-gaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVt
-acaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtac
-atatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWY
-RatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgaga
-BDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStatt
-cHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMa
-DctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcag
-HctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacg
-BaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMW
-atttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVtt
-cYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataa
-tgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYt
-SWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtatt
-atYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVt
-aNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaa
-agttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacatta
-ttgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSa
-agttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgta
-HaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttattt
-gttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaa
-caYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaa
-VDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatS
-tttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaS
-aVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHta
-gtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYW
-gRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMcttt
-cKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttct
-gtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaact
-taBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSV
-RMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaN
-VtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMc
-atagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctgga
-YattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWY
-KDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagt
-aaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaa
-gaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWM
-aaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaK
-tKacNVggaatYttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKD
-gtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttat
-WgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaat
-tttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtc
-NaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcV
-aYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVg
-agaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatt
-tttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHata
-MtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYS
-HgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaatt
-acYSattatttaYtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaa
-YccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaa
-atactcgtacttttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWg
-BaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtS
-taaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMga
-BtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagaca
-YaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccg
-taBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDa
-VaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatt
-taYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaB
-aaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYct
-tgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStat
-tatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaN
-NccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRV
-taHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMt
-agMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatat
-atattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMta
-attaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatc
-aBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaag
-aaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWga
-agcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagN
-taMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagM
-aggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttct
-ccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatga
-gHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNctta
-RattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttga
-acNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatacta
-ttWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaa
-aKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtg
-ggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatatta
-gcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBH
-tttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMg
-attVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcat
-taatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgc
-ttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaa
-cSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVgga
-caWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaat
-atgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtH
-ScgataaNcBataggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYc
-gctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaB
-SKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMaca
-WNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYata
-StKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaat
-catattcatSaYtgWaDacgaataactctggaDccattacgSagaaattgatttaDtHac
-gtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcV
-NWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttcc
-atactHgStagHcaattaagacagaMDtttagcHtgccctttattatSatWataBaaSMa
-ccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagag
-cgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHtt
-cataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDS
-tacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHat
-aatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMW
-VtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMg
-tatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcD
-gtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccW
-acaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRat
-KagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgt
-agatYacactYSBDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNt
-taHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDct
-tgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDc
-ggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttc
-tagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatg
-tttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatat
-agWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKct
-aaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaa
-caaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactK
-attaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtat
-YcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatg
-ctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgB
-tDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatct
-ctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgt
-HgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKat
-taVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtagga
-aatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcg
-tatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaa
-atKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgtt
-ctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaa
-aaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYc
-MagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWN
-aactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgct
-VaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVac
-aNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgM
-aMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgN
-aaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacaca
-StaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYt
-ttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttR
-ScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtK
-ataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagata
-tttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaat
-atgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaa
-ttVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaaggg
-ataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtc
-tattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttg
-HtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgact
-aNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaat
-ttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactac
-cYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcg
-caaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRD
-aatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSa
-ccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaataga
-atNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKtt
-aaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBt
-tDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcatt
-cacYtattggatVgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtg
-tMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtN
-tcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaB
-attaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtN
-cMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKV
-NaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagattt
-agttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNa
-tVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaB
-tMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWat
-tagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaa
-catcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacg
-HtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDta
-taacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatW
-ggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctD
-gBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatg
-aagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHat
-aRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScY
-tSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgt
-agttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatR
-aggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSS
-aaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagg
-gttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatca
-tacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagtt
-atSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRatta
-aaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaV
-tKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtcta
-gYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHg
-gttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScat
-NtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttg
-ctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaat
-aaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaa
-tttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttt
-taStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatatt
-aRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBcc
-WDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDc
-caaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttag
-ttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttg
-taaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaY
-tVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMY
-ttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWa
-HctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttc
-aWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattc
-attttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgB
-gtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaat
-aagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtg
-aRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaa
-gcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatg
-tcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttc
-gaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBc
-WVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactga
-ttStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctV
-attagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagtta
-NttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttct
-aaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacSc
-gaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctN
-atYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYaca
-atgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMct
-atcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctc
-atatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHca
-cgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHtt
-agctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggtttt
-ctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatS
-aaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattactgtaKtNagaacc
-DaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactat
-aKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNt
-aaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWN
-DataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWgg
-aacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScV
-NaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatcta
-aaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNa
-DttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHa
-WcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatc
-agatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgc
-KataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattga
-gtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaacta
-gtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttat
-cBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaD
-gNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBK
-caMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatag
-ataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVac
-McBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWac
-gtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWa
-tgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacat
-tSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcg
-aatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcat
-ggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaat
-atRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHg
-cVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaK
-tgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWcct
-tgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKga
-KtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgM
-gtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttata
-VcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaD
-MtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHt
-taaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaat
-tcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKa
-cBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtca
-agcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtt
-tggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgtta
-aVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSSt
-aYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHat
-atBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRta
-tagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRtttt
-ttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYc
-aaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNt
-ctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgt
-tgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKN
-ttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataa
-tatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagc
-accaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHa
-gagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttagg
-atSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagH
-KagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRa
-tBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSg
-cgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgctta
-acgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataa
-gtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHagga
-NcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNa
-DtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgt
-tgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcat
-RacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcR
-WMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHa
-ctNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVa
-cctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttg
-tcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaacc
-ctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKa
-agMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcK
-tKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaa
-RNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMa
-ttDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaY
-agRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttV
-MaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYt
-cagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRR
-aattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattg
-cttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaa
-ttYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKt
-gaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNtt
-acgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattc
-aaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNa
-aaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttD
-gWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtac
-cWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatac
-gaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMt
-atataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtata
-VDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtcc
-agHctttMtattgtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtac
-ctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVat
-VtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKta
-ctctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDtt
-atMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaS
-gDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtat
-VatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaK
-aHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVa
-cYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDa
-YtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtB
-tatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWR
-taatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagta
-gctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtt
-tgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBat
-gtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattca
-gaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHca
-YNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKca
-tactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacK
-tWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccagagttcaKcStacc
-KggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtattttccttcatcta
-cttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacc
-tVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgc
-aaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaa
-ggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgt
-MatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgata
-NWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattW
-YcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtt
-tagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVK
-aMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtct
-YcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDag
-ttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcaca
-tNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaK
-gccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttW
-cacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNg
-DagatWtRttSttNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaV
-cgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDac
-ctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttc
-catgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaH
-ttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVg
-KaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaaca
-ctMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgag
-gaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttc
-tVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaat
-tatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggR
-tttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMata
-aHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaN
-ttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYta
-ccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVatt
-WDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaV
-McMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaa
-gaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRD
-aRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgB
-taaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBN
-aKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaH
-VaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatg
-BaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcagg
-aBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNttt
-agtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaD
-gaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgat
-gKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataa
-tKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtY
-tagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaK
-caKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattt
-tgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacV
-agttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgat
-tcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgct
-aaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagat
-aDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgacc
-gtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactat
-aDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRa
-gattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatD
-taVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaac
-ttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNg
-cKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMa
-gBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaB
-ctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWt
-ttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtca
-ttagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttca
-ttaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKac
-ccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNB
-acagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgta
-cVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgY
-taaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtc
-actYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaM
-gccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNc
-aaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagact
-tcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRggg
-attttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgt
-acggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMat
-gtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaD
-aatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcat
-ttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaat
-tDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDV
-tNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDa
-tYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcc
-taBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtM
-ttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKttt
-agtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttattttt
-ttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgatt
-RttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaata
-YaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWS
-gctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtata
-tgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNta
-ctHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagS
-tatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBc
-YtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSV
-agaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYt
-aMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacac
-tDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHat
-agaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgta
-aDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttga
-KaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtV
-KgHtcRattactctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgt
-tMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgSt
-gtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaa
-StctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgct
-gagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNttta
-gacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHa
-gDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttct
-DcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaa
-WtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatD
-gaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcga
-ttaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaa
-RgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgc
-HttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcactt
-DattYttaVgRcacaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaB
-ccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgt
-tactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaH
-gHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaa
-acgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagt
-YNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtH
-ttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgat
-cgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagtt
-ttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaat
-actgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgt
-atacMatcaaactagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaa
-StacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHata
-accRttagatataaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMc
-aWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgt
-ttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctg
-tgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcS
-HgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVt
-ttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagt
-ttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWc
-MSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNtt
-aYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcgg
-KKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctg
-ctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctccc
-acDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVSta
-tagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggc
-ccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaN
-tDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHt
-KtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWga
-taMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaa
-gcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagat
-tcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgg
-gaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggca
-taDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtt
-taaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtt
-tcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatga
-gMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMag
-aRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSB
-ggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtt
-tBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMa
-aKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatct
-tHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataa
-cDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatc
-tRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBa
-aatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatc
-cScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttg
-taatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgt
-aBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaaca
-MataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStc
-NcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacat
-tggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaV
-KtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggtta
-tttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSt
-taaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWg
-aYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSg
-RaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMc
-aattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVt
-atcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataat
-tMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSSt
-MatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaD
-gaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatt
-tttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaY
-aatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaat
-aaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcg
-agccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcataca
-HcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttc
-cWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWV
-acSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattH
-YtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWt
-YYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttc
-tgctaYttBataaRtattgatgaaactagttBgagtcttccatBagatctBaaagSacag
-taaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggK
-aacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctc
-ttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHt
-ttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaB
-tctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWtta
-SMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatR
-acatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNt
-ttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBR
-taaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccD
-aaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNta
-WatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaac
-VttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNct
-gSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatc
-HtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatct
-tcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcY
-aRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDc
-agBaagtctSNagaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHt
-taKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttcta
-gYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaa
-MaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacc
-cStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBa
-aaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacK
-aaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaK
-cNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaa
-cttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgata
-taBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKa
-tVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRaatBattWVactt
-WVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttag
-tccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatc
-tatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataa
-agVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNc
-cttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgata
-YgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWa
-gaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaata
-aNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDND
-tBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDa
-gNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatt
-tctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaa
-YcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKtt
-BtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgN
-tScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtggg
-tNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBa
-ttaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctV
-HttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSg
-ttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVg
-MKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttB
-tgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtga
-cgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaag
-tatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacag
-tcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtat
-cgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtc
-tcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggD
-gctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVa
-BgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaN
-cBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaY
-ggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKa
-ttaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgta
-ccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatV
-attttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMa
-aRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaattYKKtgatagc
-MYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgt
-WatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYt
-DctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaac
-BtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgca
-gtttctttttMagWttatRggcattattVaagaBBttatctattatMcNtaacagttgaa
-aBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaY
-atgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHag
-aacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatc
-tggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDag
-YttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatct
-tDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWac
-HagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgact
-attcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtc
-ctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgcta
-cWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaatt
-WRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKY
-gtYSaMtgataatNggattKNgaSggactaaBagataacactcataVgttataaSacaat
-cRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggat
-aaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattac
-attgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaY
-HWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtata
-ttacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBt
-atccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVa
-tagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgag
-taatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgt
-tRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWW
-agccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKt
-aHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaa
-tatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaat
-KDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVatt
-attaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtgaatttttKtStat
-atttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatctatKatatgaaca
-actctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttatta
-tgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaa
-VcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMttta
-tSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaacttt
-cgcttttccatttNaaYgtattttactttacttRataBttgatagggacattattaaSaa
-aYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaa
-MtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDV
-ttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacV
-aBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSata
-ggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaW
-ctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNtt
-atWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKct
-ggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggt
-gatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaV
-HtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaN
-NgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVc
-agKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttatta
-RKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaY
-tttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggtt
-aaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaa
-gattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaM
-aStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacK
-tttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVD
-ggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtat
-NccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaat
-tggagagggtctagtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDc
-DRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgW
-aHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatag
-ScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBt
-tgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttacta
-BgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataS
-tcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMt
-WatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaa
-RaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaa
-agVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagat
-tWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBS
-gaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRatatKVtactata
-tttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattaca
-RNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggg
-gVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNa
-MRaacaaacaKctacatagYWctgttWaaataaaataRattagHacacaagcgKatacBt
-tRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaB
-SaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagt
-gcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRct
-tactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataN
-DaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYV
-tNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWt
-actNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtat
-agYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaata
-YtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtc
-attttcWattRSHcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccg
-SKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctata
-ScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactN
-tatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaaacatacaHactM
-acacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgt
-cagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagtta
-ctcttcattVtttHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMa
-HWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYtta
-aatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgtta
-tcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKca
-VtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatg
-catttNattaDttaattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHa
-gaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNH
-ttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVg
-agctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgat
-taVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatc
-tgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagtaaVctaggaScca
-atMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaatta
-aattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgct
-WtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHH
-KaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaac
-cactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaD
-MtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacga
-NtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaata
-KgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcat
-aWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYac
-ccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgV
-HDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVcc
-YcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWa
-cattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcg
-actatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtatt
-aMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRV
-taaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtact
-aKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWY
-NgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVg
-gacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgD
-gttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggW
-YaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaat
-taatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagatt
-acVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYt
-tattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWct
-gcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRc
-caVgggStctDaacataKttKatttggacYtattcSatcttagcaatgaVBMcttDattc
-tYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctg
-ttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRct
-WatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagt
-aatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaa
-aaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKK
-agcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatct
-RatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMg
-atNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgD
-tttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVct
-agtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtt
-tatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaat
-tYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctga
-aMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaagg
-tYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaa
-VgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaattt
-acDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttca
-aMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcac
-DaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaN
-SYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattct
-MKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaac
-attYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatM
-ataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatR
-aVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttcca
-KtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtat
-ttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDS
-KatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatK
-agStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtcta
-tggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataat
-agatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaa
-tgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgccttt
-atMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatc
-tNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtg
-ttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggt
-VtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatact
-tgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHac
-cHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtgg
-caVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaD
-aagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaa
-aatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHata
-agtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHt
-aKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMt
-tttcRaYDttgttatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDt
-cNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttg
-gtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKN
-taaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaB
-WggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDN
-atttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSW
-DRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttB
-aaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWa
-tBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaD
-ttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaat
-taagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaa
-aacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccgg
-ttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMa
-taHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatW
-ccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKD
-cttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctg
-aaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYat
-WtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacY
-gtaatataMagaatgHMatcttatacgtatttttatattacHactgttataMgStYaatt
-YaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatR
-acacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaV
-YatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatg
-ctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMga
-gSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagttt
-VctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttggSagagctacHta
-aRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaW
-gttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKtta
-cHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRg
-cggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatat
-DtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtg
-agaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgat
-aatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaa
-ttataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattt
-tatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDctt
-attNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgc
-NtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNc
-aNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcg
-tttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtg
-tKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaY
-gBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWa
-ttagttttNaggtctcaagtcactattcttctaagKggaataMgtttcataagataaaaa
-tagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtc
-aDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtc
-attcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtB
-ctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcat
-aVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttg
-atttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaa
-gaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBt
-tattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtc
-cattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMc
-NBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNta
-tttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBV
-agcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVta
-DtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgt
-aattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattag
-cSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtN
-agtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaaca
-StaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaact
-atatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtc
-agScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYga
-actcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDt
-aaactacagWDcYKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKt
-cgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatV
-YaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcc
-taNgagagcYgatattttaaatttccattttacatttDaaRctattttWctttacgtDat
-YtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWt
-aWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaR
-tagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaagg
-aaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacW
-DYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKa
-aaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYa
-tggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRa
-NaacHKtagactactggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactc
-acYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatc
-tYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgatta
-gcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgta
-gtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBct
-atcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacD
-cttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNM
-aVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRag
-agYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaac
-BatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaac
-ggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaa
-tagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggat
-ttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttgg
-aacaatDagtattRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgat
-catatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcat
-VgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRg
-aBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcK
-tcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgt
-taNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKaga
-ttaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttN
-ctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBata
-NaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaD
-BtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSt
-tMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacat
-tattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVa
-atacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMga
-acagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtt
-tcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKa
-aBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaat
-aHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSgYataBttBaact
-attBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKa
-gaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttt
-tgactatacataatcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgag
-aRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYt
-agSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtt
-tatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVN
-gctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaa
-gWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggc
-VaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRa
-cVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactg
-atttaatttWDccatttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtK
-taaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYa
-ttttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaag
-actcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKta
-aaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaa
-ggMaaaattttcWtatKctagDtYtMcctagagHcactttactatacaaacattaactta
-HatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYa
-tgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgt
-tcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagat
-HaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacS
-NtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSa
-acttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaa
-cagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKg
-gataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgc
-cgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVa
-actaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagM
-ttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaa
-HttRatctaYattaaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVa
-gttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctattgtMagagattaa
-actaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKW
-BattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacat
-cWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYR
-VacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttg
-attVRatNtctMtcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgca
-tgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcSt
-cWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtatt
-aaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtc
-aaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYa
-aVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtD
-cDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMac
-cDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDac
-gaKatgtatatNYataactctSatatatattgcHRRYttStggaactHgttttYtttaWt
-atMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDcta
-MtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgc
-aatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtctaactKataHac
-ctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattact
-MtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBa
-atactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWtt
-SttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaV
-ctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDct
-MYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaK
-atattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaa
-aHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKagYNKcattataNa
-RtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKD
-tStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaS
-taNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgtta
-gacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaatt
-gctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWat
-cgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBga
-cVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYga
-RttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgaga
-tYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacctNVataatHcccK
-tDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgc
-tcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWtta
-atctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgc
-tBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatg
-aatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaa
-cccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHattt
-BNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgta
-HDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBY
-RaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKt
-gaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaK
-atKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgt
-RattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYag
-tgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcga
-tttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaK
-caataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttY
-aKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYg
-tMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaV
-accaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHataKgDacatWcc
-ccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtc
-aatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaH
-ttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctag
-taWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtcccca
-agtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcg
-caRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMg
-tBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcat
-tSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttR
-tgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDa
-atactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataN
-ggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKa
-cataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKt
-NtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcW
-BataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattaca
-gKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataD
-atatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgD
-tYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNN
-VtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcH
-MVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDg
-tNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctg
-VtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVtt
-aagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaH
-cRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatct
-gtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaa
-ttttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatY
-gaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaK
-cKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtt
-taBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagV
-WcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtat
-tatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgt
-aNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtat
-SttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaatacc
-gtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttct
-atattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaa
-cagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctH
-tatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaac
-gttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWg
-ataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVa
-ctWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacB
-cgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatat
-gctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatga
-gcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtga
-ttDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaac
-aaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYB
-YaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcatttttta
-aBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttY
-gaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatc
-aagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaM
-gaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYg
-aatacaWVacVcRtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgt
-gattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattg
-YtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagtt
-aaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaatatgattagaact
-ccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaD
-aagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgat
-tgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcact
-ttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRV
-ttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRa
-tHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgc
-gatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttM
-ggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMtt
-acggctNVaacDattgatattttacVttSaattacaaRtataNDgacVtgaacataVRtt
-ttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtatt
-HccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccata
-RMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaV
-cacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKata
-tcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHa
-attagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctS
-gMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMc
-RggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaV
-VcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBat
-atatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctac
-ttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatact
-aaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatgaccYtacacttta
-attaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMta
-tWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatW
-tctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaStt
-gtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtat
-cgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatca
-KgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgt
-gNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMta
-gSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSa
-ctgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgt
-taacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttca
-RtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatH
-catcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgta
-ttMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaa
-HctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatc
-tggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDt
-tacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaD
-aaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttt
-taaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaK
-gttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaac
-aaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtctt
-RttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatH
-tgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttct
-ccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBt
-ttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagat
-aagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagtt
-agMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaa
-KgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKa
-aaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVc
-aDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagtt
-ggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttg
-tagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgS
-tatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaat
-ttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHactt
-ggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHac
-BttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaatt
-aHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtg
-ttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtg
-cgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtgg
-aatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaata
-taaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattc
-aaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattattKtRttNcggcR
-gtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRt
-BttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgata
-tatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHca
-caacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtat
-gaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgatt
-gaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttca
-tRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttt
-tRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttt
-taBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNta
-ctBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacg
-atttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaB
-ccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMt
-ttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVa
-atcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgt
-ttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctca
-atttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatc
-tttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNa
-aacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDc
-ctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStg
-gRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgt
-atgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcga
-DagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatc
-DaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgat
-tcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaW
-tctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaatttta
-tttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtat
-taNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttag
-aHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBag
-HaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWc
-WRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaat
-agattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcct
-gtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaat
-BNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaH
-cattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDt
-tgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataY
-aYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatact
-aNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcg
-aaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHgga
-taatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtc
-cDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataV
-aattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKatStatattcatHH
-RttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaat
-RHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKc
-taagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcg
-gSYtcttgRctataYcttatataaagtatattaatttataVaacacaDHatctatttttK
-YVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattc
-tgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSt
-tgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaD
-tagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaatta
-MtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtR
-aaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWt
-gtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMR
-taHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgH
-WNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHa
-NagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgac
-MtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagt
-ctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDc
-ttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgt
-tatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagY
-ataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNg
-acttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRt
-tVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagta
-gHagBagttagaccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaa
-BatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgc
-atggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMa
-aaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagK
-YYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaM
-ataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataa
-ccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDa
-tatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVa
-tBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgtt
-NBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcg
-taatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKc
-tVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatca
-ScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYc
-acgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKa
-RagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaa
-gWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctatagccctYttggta
-attKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWH
-ttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNa
-ctaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctt
-tagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaa
-RatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHt
-tttMgMagatDtataaattaaccaactMtacataaattgRataatacgBtKtaataattR
-gtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttg
-ttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMa
-ttBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattW
-tgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatag
-tgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgag
-DttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKD
-gatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaSta
-actScattattaacgatttaaatgDtaattagatHgaYataaactatggggatVHtgccg
-tNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggag
-tatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatat
-aacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttc
-taagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttH
-catSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaa
-tctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaN
-atcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaY
-gcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVa
-tgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBa
-cacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatV
-StgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVa
-VtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgc
-BHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgt
-RStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatat
-tagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgcc
-ttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatca
-ccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtca
-VtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaY
-agattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacg
-aWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatc
-taatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcg
-RggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgt
-gttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataac
-tWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggt
-atgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatc
-agttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtcctttta
-cDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctcctt
-NtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSY
-gctttcaHcRaattaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgct
-cttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttat
-aatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcg
-actatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataY
-tDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgta
-tgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMt
-agaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaa
-tYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtag
-taaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYattt
-ttgcDacHctWatcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaW
-YaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcSt
-atMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtaca
-tataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaat
-ttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagtt
-aggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSat
-atgcgttaBNggttaYVatgaactttttgccatataaataRatSaBctagttataBccga
-aacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVta
-gcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaa
-NaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtc
-tttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVtt
-ccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaa
-aHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataa
-BgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRV
-tcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccV
-StttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaata
-cccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaW
-atBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDatt
-atttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagt
-ccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttB
-gRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaW
-ttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaR
-DccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcac
-actBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBta
-HtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaa
-tggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatctttt
-aMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHca
-cSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaM
-atggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacM
-ttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaH
-ccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMct
-DaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacat
-gcatatMtttgtaacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRc
-ttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgW
-attgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRag
-KataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMt
-tcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKa
-tcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaV
-tatagcccaNRttaccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVt
-NagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgca
-HaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataaccca
-SattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtat
-tDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMS
-gKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVata
-tgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcga
-HttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttg
-gBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYa
-BtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNt
-gtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcD
-KKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgt
-gaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagt
-tMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaR
-taDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaW
-gtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaat
-aactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaB
-actWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDa
-ScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDg
-aggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcg
-MtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKcta
-KaDgctagacttattgattaaYttatcttattattStaattWaRaYBWagYaatatgttR
-gScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttM
-aaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMtt
-aaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNta
-cgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVa
-tDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMta
-aYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNcttta
-taggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaaga
-MtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactg
-cacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSa
-cYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWK
-gcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaag
-acactaKaagRtRataaattttcatHggtaataaatgataHtggctaacBacDgtaatat
-tRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactc
-gctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatga
-atttattcaaaattgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBta
-aSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgt
-NcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRK
-taRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcac
-aaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccD
-BtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgta
-DtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDa
-tccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagct
-aDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaac
-caKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtW
-ttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagc
-RattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaa
-aYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDgg
-aactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHatt
-atagWtKttaNgcDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYV
-tKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagt
-atagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaY
-DcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHag
-gKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgH
-ccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgY
-SatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaat
-tSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttatt
-aataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaat
-gMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagt
-gataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYc
-aataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtc
-gHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKg
-tgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagt
-NagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaatt
-SMctatatagaaYacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaaca
-aNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVK
-WaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgt
-HagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVg
-agtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttD
-ggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagt
-accNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaaactagatgVatt
-tagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcact
-gHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttattta
-VtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgagg
-tHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaa
-MccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDt
-aatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBga
-YtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagac
-tMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaN
-KHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgt
-DtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacag
-atgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactN
-WtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatR
-aBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtga
-tctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatat
-tgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRS
-tYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatK
-WatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKa
-tcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgct
-ScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaa
-tcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHtt
-YgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBc
-ttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtg
-tgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWttt
-MtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagct
-tccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattDtYaatattDacc
-atcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtgcSataaatattg
-aKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMtKttcatattaaD
-aSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcctVttaaNaggaa
-aagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaagatRDtVRacta
-YagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagacagtgtaattcaSt
-YttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNataaWtMNtDVgWt
-tgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttDatNttaaaDgRt
-atNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDattatacBattMg
-ctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYBaaaRtgMtatSR
-gaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaD
-NcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtgaaScaacctttRN
-atcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYtggattttcataW
-ttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMctMDtaaaatRtB
-aaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaSacgBtaaataaa
-gtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagacaKtagDtaaHaD
-gttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaSctttattgtcttttcct
-tRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaaggtcaSBttaaca
-aKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgctgcatttactttg
-tgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatSRgKagattgaVa
-tKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgatccatgagttgtW
-catYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatWaVgNHcagStVH
-cggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatgtgaatgacagtg
-aRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaBtagHactgKaat
-RtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaVattgatttaagY
-ctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKtYtYtagacgatt
-RaaYBtaStcttaWataatcHttataRcactgagtgggagccaattctcDtgDaggHcDR
-VaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatcttBtcttRgaWcaV
-RKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgattBtggacgtctg
-acaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaatatttgtWtttata
-gtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgagaBgRaaNttttMt
-MagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBggKaataBattYta
-attataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgatatgMtgataacW
-ctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagatatcYBttaatta
-ctcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYagttgBagNcaag
-aaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtHcMaBttcagtct
-tgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaatatgctatMcatg
-aaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattggatttaacBtct
-SMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaBBacaKtHtttca
-tgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgatgWcagggtcMBt
-gSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgctYtgcgaaHatDt
-atgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWttggSatBagagc
-HgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYc
-attgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtagRgagtHDgaVcg
-tgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHaaScataataatg
-tttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagtgKtatgattHcY
-cttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaaccgStcHaVBaa
-tcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDcatYHatatgcaa
-taaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBMagBctaaBaWtg
-atgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaatactRSgcataKc
-agcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNccagWttcgtatB
-cgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataKcaHVaggaatat
-aBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcMcgtcctaaVHtg
-WtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaaaYttgtagtcaa
-cWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDtHatattcgatNt
-tacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtRatcatctaaatc
-cMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgHaRttacatgaWc
-DtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKgaHWagattRData
-tcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMW
-aaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDaRSgaaKDtVaBa
-tcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacgcatgtcggaYgt
-aKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgcHcaaaattBtag
-cttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccgYaYRaaMaattR
-aagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMataatHgRtagcga
-KgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtatMRcgKccYcagt
-YcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYcgccagactcttc
-SatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaagtgttcacatata
-aagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtBctaataggtaRt
-aaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBtagtgatYcaaaSt
-actggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatcacMcScccVcgtV
-RRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgttcctaDNaattgc
-tVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgStttNaccattBMYat
-RtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttttcMtgaRYNaat
-aDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattaggtaatVcaNggaR
-tNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatMttYWtWttcctg
-aKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagW
-tHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatMgactatttatSa
-aVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtSacgaaaHggaaa
-tcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtactctagaacgcKaa
-DWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgtatccattgtggHc
-aatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKBBattaatggctg
-tHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRtMtWgggatcNta
-cacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWaggaYacttttKa
-cgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKagWattKtttaWgt
-agaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggtaNgtWactaWcgH
-ctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcVtBtctStWtaWM
-aBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtBtagaDacBtaag
-aataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcgctSRtacKgcac
-tacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKtaaKaccHaccac
-ccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataWtaWaMtgaataa
-gaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcgatacgtgtttat
-ttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgNatSaagtttHtt
-aNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttSagccatRtatat
-cactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcctYaacVactgct
-McgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaatgtNactaaBag
-atagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagtaHgacgMaaacM
-tacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcgacctgcaacgttt
-tattacNMWNcattataDVDactatattatYattttgcgaagtgagYVtagYaWaHaatc
-tgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaacatccgtYaBtVtN
-ccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactgtNaagNBcagHa
-DattaaaWttacacaaatactcaatSDatagctcaDttWactttgaStaaDtagatSaaD
-tgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccggNWaacatacat
-gttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYtaggctttggtat
-gagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYaMaYggttgtcaa
-agSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagtttgaMtcgcatc
-aaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgtcagMVSattatt
-taWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgacaaVRHttcSaSa
-atactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtcgctBtgagccat
-atScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaagSacScaaagagt
-agcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgcHctBcgYgaaVa
-cRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSWtctDgactaSHt
-tctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatYSaNgSagtatag
-atgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBaYtaaNaBtaNat
-actggcttWcaagatDctacggaNctatcacatSgKgattgacgacccccgagtNDtatt
-gagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgccaactKaattaR
-gacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgcttatKtcaVtVca
-gDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNtggWagSVaRttc
-MVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacgaagtcccRDVaa
-cBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNatttacgtcagtg
-aggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtgStcttWgtattK
-tSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgcttctatatHtaa
-tggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagctaaagtccMMtgag
-aagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBccaNagcSBgaMaDa
-VaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStScRaKatattaca
-cctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSggaaaaBcaggtHta
-tWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacatcgctcgDDtRaa
-tatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatctggtctttattt
-tatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcMgNgcgggagtct
-tRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagS
-DtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatatcatttatKtKaa
-aagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgcaMtcttSaaWaa
-aWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaagtgcgSSgaaVt
-gYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgttgtBcNtaatgtc
-acVatactgaaatMBttRRcRatccatagagggacatcgccWttagttgWttatKagtaa
-aagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgSattRaMtgaatM
-gttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMacWttccMVgtgaa
-ttctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKtaactttaatNaa
-ggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgttggtSatHtNNaa
-VagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBNWtaNMKcVcVSW
-tSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactagcgMNaaactgat
-aDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataVaggcaagHgaaS
-MSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaatagttHttattMBg
-agctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggtaWSatKgatatga
-gcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacataatVcacgattat
-aDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgccttacaaaWatt
-YWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtccagaKttSatatc
-aStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaacatKctacatHtaa
-aBtcNWatttBBaNatRcDattcgaactataaattataactcagtSgatataagRaYaKH
-ctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacaggaagtgataaac
-atBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaBtaggtaVatYac
-cNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttKggccagaaBcat
-agtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMggMtttataagta
-BgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRcatctSDcHcMgc
-aactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKctSHacctacacc
-actaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBaBtaatttSRcgt
-BgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMtMaVcgaattaNa
-agMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaagctaagatatatt
-McggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKtttcaYBaBttaV
-agtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWtaSggacggWWct
-BHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatggaaBDgWgHtcK
-StVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaHNHagcDatRcaa
-attcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaagRttaBcagVaYa
-HcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaaaaSKatHHttVD
-gtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacKtaacHtgHataS
-gVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatgaattatYcttKta
-caatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNBaatcDtacgatt
-gacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattttcttgaaaaact
-acccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNtttcttgYKaWta
-aBtttcWttagHtgtttctcttgtggctatgDgctaatWDataatttagaNcgcRRNata
-KtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaactHgaggctaga
-gHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggtHBVgttaattgK
-ttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRctacaataKatattc
-taVgtgtaattRacKagttattgaMtaatgaNatacDataaggactttccNtStatatKa
-agaataKtatggtcctctatgaggttaaDtgtattgataaaactggatcactKBtttggc
-gtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaattattWgaaBgactg
-aKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagtMWtcHgcattca
-caaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDcccctatgatVtt
-ttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaattgSttaaMcVtDa
-tttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcctBtccMaMMtaMY
-HaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtMtKcBtaNKaHSt
-gSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVatgagaaggtcaK
-SttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNacattRatNtgStt
-HVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBatatgSgattttacg
-tatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcgcagtgtgtMgta
-ttctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcHYtWMaMcgaacK
-caNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccDataNactttatBSDY
-atDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttcgtgataHDYaag
-ttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcgaatSctMaggVaV
-aaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSatRtagttttagc
-aaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatatacaatacactaNatc
-aVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggataWMtaattgtaaH
-tgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaatHHtaagRttDag
-tMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYtatKDtcatttga
-acctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcg
-cKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtatagKctaNtKaSVg
-ttcgagacattttRSatagttSacataMtaYHccacttttctatactagtatgaBaagct
-ttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactgttgacttYaHtS
-tcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaatWStaatacgNa
-agtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcatagBcaataVcHcR
-gcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataKtatgatcgtcVa
-aWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHaaaaNgaatggSt
-HgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatYtacVaNttctcW
-tactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRYaDgaatgSYcga
-ctgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatVatcttaaacRaD
-atRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtD
-gHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctNataaaaatatWN
-MtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagggaaSatgMYBcK
-BBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaatVgVaKctttNg
-tttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtttggtctacNttg
-NgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgtctSttYctgatt
-VaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgccgttacgcNatcH
-ctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKtacgtttStagKgt
-ctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgBtcctaatttNaa
-ttgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKctctttNtaacHa
-cNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMctttaNVgaNtcM
-atcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgctttttcatcYacttaKt
-tatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatgaaattaattacgV
-NaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaacctcWctHaatct
-tWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYatatcKBgtcttt
-atgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtataaaataRatHat
-KgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgtagaHcVctcYggg
-ccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggtaactBcaMNNct
-agaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMStatacDttataa
-aVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcatagaattMttgtH
-tMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVHaaStMtaaagcc
-ccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMttagcttacNcgaag
-atRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgtaaaaagttaaWaa
-agtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatBtgaaatttcgcD
-actttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBRBttgWttagSat
-gacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtatacattaMctttgSga
-catBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtctttcDcgtaaMta
-ggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRttWctWttaaacc
-aatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaatgtVgccatcaB
-SatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaaaaaataYNDtDa
-atcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaYBgBgataaHNta
-cRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaHScagttcYcatc
-SYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKacaBRtagHtaaaN
-cVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaagagaatcaaaaaag
-YScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDactccgBatHYgtt
-catcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaataccgcKMtatgKtg
-ScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVatDaatttgcttt
-aaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgactacaNaatBcagt
-cattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRgaactgtgHtgacH
-WSactYNgtttBactatWStaNtcStcMttgattStacctgaattctWatNaaHgMatat
-tcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaattttWttDaMtggt
-tgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttHaatggaatatYW
-gtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaagatgttBBcNaYa
-ttcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVcMNgaacKagatc
-gNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaaMacNgttNtKHM
-cctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMt
-WaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagWgcBHRtacaaDt
-tcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctgVcRDgVtaagtt
-taattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMSgDaaaatttgHa
-HtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgactMKatHBtttaV
-cYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMcccgtaataatagDa
-taatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgNDHaSNRcggtaSa
-agcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatgatttttRcWttS
-gtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaagScSSHaaYHWc
-HcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaagtgtaRgtgggaV
-MatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatcSccttggSaWat
-WtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWtKgaacgtNttac
-tgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaNHYaMacagWagt
-aatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHcttacatcDKttMDKa
-WggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVMtWRKKDctaata
-tDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttatttagtcaaVatccKW
-tacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgtttaaSaaaYtgatt
-gtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaVatcYgWttaDat
-catNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaatcgttcgKgRca
-BaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatBgaNtgaNgKHtt
-ctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaBtgttaNctaata
-ctKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatMaaatYtcacVaa
-cgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaDagttNMataatt
-taSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtgVcttatttYtga
-HgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcgaaDattttagtH
-cKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgctataKggatWtta
-ggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVBtgcaYaaRtDaa
-tacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaattaaaacgctctc
-tcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNaKagtatcattRt
-tNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgWttNSacaaKcaD
-aatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWHtcctWDtatttt
-tNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggtNttDYNYgaaaK
-ctcacacYHRgttacatacttYacaataNaagaaaagttataNaataSatacagttScac
-VaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYtMtacKacHtttt
-KtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaatcccgRBaWgatK
-gagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMtaacatataDBgt
-aaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtactaVtHactttNt
-tcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaatcaYtSgttttat
-aaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaatattacSHaRgttt
-ScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcDMggcVaSBagaa
-tcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWctYgaaStccgVa
-aaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtggaNYgaRtMaac
-ataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtactatatgatRSgttt
-gccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatatgWtacaaaWttg
-gaaactttaScataactRattMtDacVYataaaagMaattttKtgaBttKcaacatattV
-tagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaatKtagacataat
-ggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaatatgtaaacgtt
-cactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYcgtttBcRtaYac
-ttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMttttattaRcattatt
-atacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttagagcccaVgatttg
-ttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacWtttttaatDtMg
-aactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgccatatgctaattg
-YacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHKttDtttaggcta
-gRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactcctcatgtScttc
-aaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBatttgtaactttgR
-ggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacgaaaggKttacat
-tgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSatctNatttatcta
-tRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctattKtWNttcRaca
-aaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRBatataWaatKct
-cattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNgRVagKDcttctt
-cNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtatRatDtKaaSDga
-ttcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatStaaaaMctVDDt
-gttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgtaMccaataattHt
-tYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcacttcatSaatata
-ctttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagKtWtcatRcaact
-attaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgtctagtatSctaB
-cacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggtSatBMBDactVt
-ggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaa
-atatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttgaacNaatgttWgt
-ggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBRttaVagBctRca
-agcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHc
-gtgtcataaaatagagacttgHYatattctaBgtttatRatctatttagacattttNtWa
-aSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaRtcatgKattgRc
-atMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVataaSacVacKHatg
-gttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVtt
-agatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDtcaMtKaaSttta
-tKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMcKaSagatSactc
-tatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgatcttHagttttct
-taaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHagacagagaggcacW
-tacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaaagggatgaVNMa
-tgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgVatccaRaSatat
-tNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggcttaHaataaHSag
-atagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatttMtatStgtWag
-tStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaaaNMaaaccgcac
-NtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaattcWgHcgtacat
-WaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaaccatgHgtagDaggt
-gtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcatataatgaDttcat
-ttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcatVtNattataaaH
-aSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaaaatagStcggRt
-taattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgBtgcctatcgtaa
-WHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVcatattttagMcgt
-attNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNaaDcagtaWgKgg
-aaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtacYVatataVatta
-taSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttattWtaaDttggatc
-attNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHBgttttaatctaW
-aagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaatKtMataYttSRH
-HcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNHtacgaattBaat
-HtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMaatNtKcttSYSc
-taDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHctaaccaactttgg
-gttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcDtMcactaNSBtM
-RBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaagttKaacttctHc
-gcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatgNatSYaattRat
-gcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRtctaaBtWcHHcD
-gaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYctaWtStaNtgRKa
-BtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHaaStVKHatgttR
-VWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYcttactttctcttcat
-ggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctcccaacttBgtWS
-tVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSattVcgBcBVYttH
-NtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacgttagYgacWaSa
-DKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaRYtgYWYSaatac
-BgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHttttBaMcMtKccagt
-attttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctcttNcNtaaaatRc
-tgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBcaagaBatgtatt
-gacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgtccatatctgatY
-atNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcgaaattcSMagYg
-WacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgggRcHtataSaat
-tBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaacctcgcgccatta
-ctKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtgaBtSYtgaBataa
-tStaaccaagttcaDtHtatattaacYatattatcctacgagatcaccgtVSttctYgtc
-ataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaMtaattatWRtWc
-aNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcatttaagttctHtcgM
-RHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaaDtcgMacgDcaM
-atttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaattKcagttcNca
-aaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYttttMVRtYVgRa
-tKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcgtttgacHagtaa
-ttatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaaKgcgMtHtttKt
-DtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagtBgtgccWaaagg
-tYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcSc
-gBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttccatatatttttMga
-KagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtagcagtttKtYaac
-aaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtttHatWaacWtVa
-HaaBDtactYtaDactttSgtKtRattgatttatatattattataattBatagattctaa
-cDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDctacaaaagaattHa
-atctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcattatattNgSaaH
-tgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaagactgtcWDtYa
-atVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgcDagWSaStattt
-taatNcacgataNBtaattggaatgcMgacattHaattctctaaMatactaBaaattaca
-HWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSt
-tgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcgtgtcttagcNtR
-ctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaatgaaYaaHaattg
-gttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaaagaBtaRtaaWa
-ggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtccattataBacttW
-tcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSStNtYtWaWtgtag
-tcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSVYKctSKKcatag
-ttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagYHaagtaNaaVVD
-gatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaattDtttYttcgata
-aagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgg
-gtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctgattatagattag
-tatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgttaagaaaatacVct
-aaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcatttaNKgKHataKBc
-tatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBattaYcNtgcaBtH
-aacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaacttttacaaggaSRaaa
-tagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKDttctgYctctcN
-agaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgtttKRaVaaKtacaa
-caKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRWcgattgVNcWaa
-tctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtatccgaaRatcHMa
-aaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaaggtHYtatWagKV
-KgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaaYtRtaacWgaaa
-MttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagccagcgaatatagtg
-ttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBSgtggaaagHNtt
-HtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatDaYgHDBaagBat
-tWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBtacctYaNYttgc
-tgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRctaKtBgKWDacDga
-aaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataagtgttgacgaKga
-NgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacHagHtacVcVaca
-acaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagctRSDtgattagg
-aDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatttVBBcaaMtctc
-taWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVBttaRaggtaagg
-HcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagagaaaMtgDtttYtt
-ggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcNattgaaacRcac
-tDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttttacttagcRttt
-acatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtNMttRgNtgcatc
-acgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaDacataHtaWtta
-atHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVttaagaSSKBYtgHt
-DtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKcaaatttctRVaa
-cagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctagtatagcBtBtgt
-atgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtcWaHtgattYDat
-WRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgatttcBHcctaagg
-WactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaWgaKattatgMaa
-ttBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattcctctagRtatta
-tctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRcttNgcgaDtVctWt
-acHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWcatcDgatatBtaa
-tHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHaatgcBcttaBcg
-tMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtacgaagtYtccttt
-ttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMtacttcgcttVBaY
-RaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaHaggctaDtSgat
-attggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNKgatVaWSDWaca
-tVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYatKataMcKNgat
-tgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDtaKgcBttgagtKt
-acatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRtaRaaNBttggaat
-VgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgtaacctatatgga
-SYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagagStHttBgctaBa
-gatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBttaBgactaRatgaa
-DYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaYaDgttcataYKc
-ttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHt
-aaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHtaataagttStcca
-atcHataatacMcattHtacaatttctgatggacatatgcaaacaKBatgcagacagVcc
-tccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRgagaaHatVcttYW
-gaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtBRaNcgttKgtgV
-KgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVtataSctRWtgcMa
-caattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHctHtaatacacgaY
-agtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSaatcatgaNaaBt
-acggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagttVacKtcYgcatt
-catacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacNtaHtataBDttB
-ctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacgDatataaagcaW
-tgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagtatatDStgcNgcR
-taaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagVYVaMtBgtatac
-SacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatgSStMattctWta
-ttHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStgaagactcacaaa
-tcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatBttgggtatYttt
-YtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggcagtgRttgtgaca
-ctaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHagtcaatctcggaN
-WtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNgStggagcBtggM
-gccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYtgtagatDaagaH
-aaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagcNttgcVttcact
-taMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacDttaRaSWactcB
-gaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNttaVtgctgtttgYc
-ttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRMgaaaactHaatW
-WtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKWtDDDaaactaag
-tacRHtcKttacaataggttWcttataSaYctgctVtaaVggatcctaHVttgWtgHtWt
-taDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccatattacKggattVa
-tatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgSaaaagatDtaaV
-tYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggtaaagtccgaKtat
-DKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDacacVatcttNtga
-tKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaatagaVtagcttga
-KagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDtWtaHcctatHat
-ttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRacVataBWacSYWV
-ctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaatMaaatMaagta
-tcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaaaattgaaaatta
-ttgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtg
-ctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggagggDMtatDttaa
-tttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttccKtVttMacttWt
-ctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagagaSatattWcagD
-ttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcattaaaaaYtHgtt
-caaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHcWgYcacgttagt
-gtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNatgaaatttVtKcR
-tKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactccgSgtYattDtaW
-ctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSagatcBcggcatcat
-YVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgtaaMRagSaSacB
-aagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatWtHgtHKNDtcNa
-KaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNattacMYgtgctNg
-VcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKtctcatataMtgg
-BtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagaccKaaBctaagta
-tWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMWYctDtagatttR
-ctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNcaMWtWccYgtttN
-aatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYttcYDVMttcgatt
-aKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRtaNgRagttDYata
-acDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaa
-ttSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaagMaacataDgata
-WHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBVatHacactaMDa
-taaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNtttgatDacDgcaga
-DcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaaKtaacgaccgMg
-aSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRtaatccagtDaaa
-cHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaK
-caBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMtaaactagaacag
-VaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaaataagWVtcHct
-gtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtggatBtgaggDagtg
-cacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHaatBaagaHgtta
-agcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacgaRaaattSttWta
-ataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggtttHggtNtMttt
-DatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSagcaaMttttgaK
-tMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSaaWcBVacYKtac
-aNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtSBMBHDtBtaggD
-tcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaSaagtttatttta
-tgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtgatDaHcaacttRa
-taacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRVgattctatgtgt
-atHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgtcagtgagHcccc
-aatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagattttcSatKgatW
-tgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtacttcaaMaVNcctc
-HatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKVYaaagtaaSgaa
-aHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWMaDactScgRYtg
-aVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtcaDcttgaaacBB
-ataatacYMgWgctgtacttttatgaSaaatYcccgattattRStccaaaBagaacaaaV
-tttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMYSWatcgtaacgt
-StBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWactccgVctNttMaY
-taaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaatgagtatHcYag
-ctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNKaaagataWaatH
-aaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaKtaatcgaaMHtY
-KNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtDttaaSMtcagct
-tttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccatatKtaKcNVgtt
-YagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHStttNtcattRaat
-gtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttcWaagcgWaKctt
-cYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaVcacgctHStaac
-aSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKgatcagttgtaKc
-gttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDattHDBaHKDHctVg
-gcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtStaVttttcDaNagt
-DVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRSNtgatBaccctt
-MtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNttagaagaatggga
-atcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaaagtaMtacaKaM
-NaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaaatgtaDactatt
-tNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNgMcgHaVDtgtag
-aagatBaaagDttaacSatttaatttaccagatataattggVgaRctRtcgccVatRNtD
-gcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatcaMSagttccRctt
-aaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaaaagHatYKactt
-tRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacgtaaBMRgatcgt
-ctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtataaatBaaatKRta
-MtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtttaacYatatgtg
-ttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaBacgtttaBacca
-BaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDatttYtKggMtYNt
-aactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttattcBaagtgaWta
-RtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWNWgtacaggctac
-ttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDVtaatttacagaR
-ttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBtctatagaKaVtt
-ttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYtctgVagaccgcg
-VgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtN
-NgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatcaVactcagagtR
-YtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWagaaaaataaatta
-tagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcYattgtaDggMat
-gagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagNtgatSNgatcYV
-tHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacKcttSagtctgKM
-NagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccctggVattHaatVa
-gaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWccatYtagacKatct
-KatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtattaYcRagatgatca
-taacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggccacgaYYMcaKatt
-RagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYagaHtacagttccMc
-gtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaaaaVtDgataaDg
-tatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBggttagcMaYattt
-BgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgtatggVBcctctgt
-gaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtHtHttatYaaagc
-agatgtgattagtggcactactVattagatctctgtttatcattYttgatHcHttagStg
-atgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVttcgWtatKaaaH
-WtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcctBcaBtctttaa
-aKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaagactgacactta
-RaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactccaggagttaatcat
-RttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaataKtaggaaatat
-gcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttHattcatttatYt
-attagtataYtttagYcattagaaataHtaaccttactcatYttHMRagttctDagNSVg
-cgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaBaaMtaScKgVaR
-cNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaaaattRtcWtacD
-DaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNtaatatHMtMWRaR
-acaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWatccBgaaVtgtaW
-ttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWctttaHtggHaBB
-SRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccVWaagattgKcaa
-cgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctacatgtacataacD
-gcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBaggacMaaaNgct
-gttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcagctattcaagaga
-atHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgtcaWgaattKttg
-tcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactSHctDataKtcaa
-gtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatataatcatNMRtDY
-aYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBWaBatgDtBaKaH
-acagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctgtcBBaVttctHg
-VttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaDtKagtHatacct
-HgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaWataataYacgta
-cgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatStRgtatVgttctt
-KSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgtctgagtRtatRS
-MWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDttcaaagMgagaV
-HtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtatttgaatBtNttg
-aaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggtagtgaagaMKata
-cttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgctctttgaRRVVt
-DaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtgtSactctSHaMa
-WtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtatatataVtagcgW
-ccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctctacatcaVgcMHa
-agaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaacccactHataag
-aaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatHattgaatgtNct
-tatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgatataaataataBg
-aatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtggRccatttatgt
-MtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMga
-gaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtatgDaMaWDataNt
-ctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgtRtaYattactNt
-WgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttattcattaagtctg
-tctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHacaaaDaaaRVgcac
-atgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttagHcKaacaBcagg
-taacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSaataHattacaMg
-gtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttcttgtcMaRgYYaca
-cggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaaaaataBataWaa
-tatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRcVctttagNttaa
-tKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNMactactgacaDg
-VgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaataagttatgHaSc
-YaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYcaaataattSctD
-accatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcMaatttWMggtct
-atttggaKagaggatWcatttgctatcgcccBacacttataagaYtcNcagaNatcaYHg
-NgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaaaHgaYagtRtca
-aDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRttMgtaattctWt
-tMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttRagaMcDYgcaKc
-ataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgHatgaHMtNtaac
-tgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaatatDYataaaaata
-taatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRataBtaVcBtcDWW
-aaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRaHtatBcaaacNa
-taKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccgaMcacNHKtatt
-StaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgctaVSttaRaMag
-atcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcagggRRttKtcgtKDR
-aaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaactaatgagatttta
-BattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRatBtaagHtctctt
-RatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagacgaaSatBNtHMc
-KagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacggcgcWttcBcta
-aVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHBcgNtctMKDcYt
-aVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHaggatcgtggcat
-aagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKgaatatWBBcttKV
-HtgcagtagaYRatcggaagaRtattaBNttattaataatatgtttttaagMggggMttc
-tBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNttDWaVtaaaaact
-HcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaSttgatcatccacat
-atgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatgtaRgtKgattaS
-ttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatNttttagYRtgtg
-YttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYBaHMgcccgggtW
-ttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatMgaacBaSacNaa
-aBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatVWaatKtaBtaaa
-taVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggtatRatttttaaa
-tDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBataaBaaKattSc
-SVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVBtagcttYBtgtg
-ttaataataWactatataaVccaNtcaBtttcMagataatgactMBatBctaaRtatata
-aaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaaccBttMaaMDVa
-aaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaagRSgcgcaRgagt
-acMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgtttaDccttMVtatgH
-agaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgVttcWagacDgaM
-atataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatDtVaDgttaaacg
-aagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSggagttattatgcc
-tMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVtaattRBattgcc
-catgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaWtattgaHgcDaa
-gVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcgatHWaaRRSHct
-ggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtNattStRSaaatt
-VtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKSacaatacRgDct
-aSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKccgHtBRgttStgt
-BaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaatatttDatcWat
-agRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNattataKSRcgcagM
-gaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDggaaagaNttttNtt
-tSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaVtaattgtacctc
-tctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacagataaacgtaVatN
-aaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttggtVBagatctRa
-tKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataatWNtaDStRaacH
-tacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttggctttHNtRcgat
-ctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaatacaVaaaHttct
-cMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaaBMtaaaatBtaa
-acttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctttgaNgaDDtatc
-VWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcattcaattgtaBcMt
-gYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattacaWttgaataaaa
-WgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttcgaggaWtDtgat
-attaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgagKRatWtggtcgt
-WaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggctaggNVgDcgaa
-cttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaWtaggattScaSt
-gattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBYKKtattHVcHag
-StaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNaRgWtgtaYcaaB
-aagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggcaaaSYacaKatt
-gSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttccRaaacttHtaR
-caaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtctgRataKgcaaga
-ctSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWtcatHagcgattc
-BBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacggaaagVNBaaaaa
-attKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWatgctWWattttg
-YaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatgKgaaagNSattK
-tttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggctcaaHagaaSaa
-gcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtcaaacNMcaBtag
-aWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatcaDMaWtcHgaaNa
-MMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatVctBtHctYNaca
-aactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttattaWMDgStMKKata
-tDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggatacaaSRaataaa
-tagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHctaaaSaaagNtt
-gactaSacDtttcattVctccagYtcNcagtWatacattNgttagagNctaYaYNttKgt
-tttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaaaRtNgcaSagtS
-tgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtataMtgataaDaaa
-aaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagcatgWcacgcaaa
-aDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattcactaaagcHgaat
-cHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBtttcttagaggVttc
-aatRattNtccatttcagctactccacMatSHtagataaaWgaagtttgDcctaagtMaa
-aYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgSacctBcaHcgtM
-cccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaacNgcaRccDKtca
-tgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagStaaaaaatgHaaa
-caacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBtcccttaaVaaca
-MaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaW
-ttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcgccttttgtBtat
-atttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaVVcaattMataaS
-BtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcatacgcgaagNYaNg
-aaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDaNtScgStWgtga
-caacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactctaagtWtKSgYtat
-ataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStcatgNNtttagMt
-RDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgcScYtaaccaaHc
-attgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgccattacHNgVataa
-YtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHatatMgttScgaaVH
-agaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggatgVKaaVgNcacc
-agtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaDtaaaatcgVacc
-atcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttKcaaYtagcagat
-VcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVgctgaatatctMa
-tccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYcStactctatatc
-WSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDScttttMMWctagc
-aactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNattMBcaacagtt
-tcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWtBataattVacWa
-aattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccgacKMagVtWcMt
-BaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaStttattctattcV
-acctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVatataatKNKaagt
-ttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctgcaMggScBaRgM
-MctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaHDtaaVcgaagaa
-aggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaagKtctgBtKacaa
-taYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaD
-ctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcMtMtagaHactaS
-gBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNtaagctagBVWaBa
-aMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWBSNcagatttgBt
-cVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttttaccattcccct
-aaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWttgaaaYgagata
-atgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDtacStVaHcaacta
-tgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaaattatYNtYcta
-gtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgttttaaagtDttM
-tgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccattacaBcHctVcttc
-tYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKtcatctatagNSa
-acHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattatcMaggcWWRttc
-cgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgcttatctattatgttg
-StaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgttBDgVgatttKga
-aaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNcaaaataSttatt
-ttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDtgtggttctatRa
-tgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtctttaagtcaHaWY
-tKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatNttagatcagaat
-cttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaatcRaBtKttgaM
-KgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaaccagtttacVtatt
-tBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagtagatataaWKcgg
-gacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcgcNacaaHNatta
-ggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacHRgttKctDaggM
-aKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDaDVacaagKaaRY
-attaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHggtaSctaaaaag
-tttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagtaattWactttacW
-aaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaattcKYaaMacgc
-aatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcgaWgaYtKataaDc
-aBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDaNtgKtaaKDccK
-gctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgactttcKHNcWBYag
-ttgataaYagaWaSMttgataatctataatRtggaKtcactWaataatYgtgcHgYKtta
-aaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataRaaSactKatSgg
-atgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBctactacBcVacaag
-tgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMaggWgYtatctgt
-gtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtgtgaRWaacgatS
-gaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRScagDtaKtatttYa
-SctttctcatccttaattagttaaatactgctgNcttgctcatatatactaDtagctagR
-cataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcKtacataBtWtaa
-aDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRaYaatattWttat
-tcttataatWatattaccYaagWtgaataatgatttgtatBYSaDctatRattgaatDgW
-tMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYYatattaRaagga
-ataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtVVgacctgttaaH
-agtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRtgctRtgaacatD
-ctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDRagBHttgNcNaR
-DcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctgcMattaMaaWgK
-ttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaatBattctaStYg
-ttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWattgcacMattattg
-DcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgtagtcagtYtcKt
-MVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgccggBVYtacRgH
-atagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDacaccagYgtatt
-acWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattDtaagKtYMMaca
-gcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatScgatgcgagggSa
-cttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWctcctggNgatgM
-ataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBtaScWtttMKcSt
-gRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSgaaWcgttaMcttW
-DWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcacatatVaatcSgt
-gDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaagKcYgcNYtVtt
-YtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBataRSVatccYact
-tcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYttagNtVtDatattg
-catYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgtaMagcBgaaagt
-SctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWSgWcNRcaVgSaa
-aBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagatacNtaacaWtBH
-gtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaHaYtcgattgtgc
-caagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMacagatHcttcag
-actcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgattaaKWNaaYggaaa
-acgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatBtaattaaYttgD
-aacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMRtgcataVgtaat
-caagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScgatgDtWaaVtata
-catggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgtttagSSatgata
-cccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatatgDactaaggcgc
-aKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaagagtYHttBgaD
-KMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatcaaaatctgaaSNa
-agatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaYtctatatgaata
-ctcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaHKaKaactctcHc
-KHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaacSttgHRaagacN
-aBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgatacSDaNtttgaag
-RtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYactaaactaaattt
-cNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHccacatgatNtatg
-KaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaagtKKaaaKtBtt
-YRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggtSaYtttaatctt
-aagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaataWacaaYaNtacH
-NtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttWagtRtcNagHct
-taatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctttgtgacgaBttt
-tccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKHaacaatgagRaW
-cgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgctagagacatacaa
-ggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtacBtatDMagtatc
-ctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataScaDaatYaaaWaRN
-cagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataHtgtcKaWctaVt
-NWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtWgatggattgaNt
-tataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDgMatgagatctKt
-taHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWSgtttttaYKtSa
-tttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtacgtttccaaVtaV
-aHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgcggYHagtactNa
-gaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWDtSttgNHDMgaa
-aaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKgScgcaactattV
-ctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaactattcttaaac
-taYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaagtcgHgWStttaW
-DacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtcKaagaRRacaat
-NgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVatBaYKSSVaNNcc
-gctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccRtHMttHgBactt
-YScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVtaaYgVgcVaaYSa
-NcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaNtDttgcBacata
-ttaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHtaggatDggStgSW
-tVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVttaWtSttgKtctt
-cgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaVVgatagaRtYat
-aatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaataacaMNataga
-tattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHBcatcatcHaatt
-attDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccBtccaBgBRgaDa
-atttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatMaaWctatttaaa
-acYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaHaacagctNcatt
-tKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatgMacataWaaMta
-taggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacgaVtMaaaactKH
-atatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgtatRtaVgaaDta
-cacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaDtaattttaBWca
-taaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcattaSDBBKttttc
-taYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWataactctcVNYt
-ttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtYtctttMttatcD
-aNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaKgaaatcacaNtt
-gtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHtttDtcgtggBggcK
-acaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaSatYVHRaaatcc
-MMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaatBgaagttaattt
-tgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattactcaaagctctcBK
-caagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWtaVatatataWgt
-aWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMactKtcgtDaDVWt
-taccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacataWtatWaVttct
-SRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHaggYWtcgatKtt
-KaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgDDcaattcagtca
-taccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRactHattgatttaa
-SKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBgcattatcaaaac
-agNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggtagVgatacctBtt
-caattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaBgDctRtttaRHg
-cRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNtttaBtMtScVtV
-tSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaattgtatttMcat
-gcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaatRcacttgtttt
-caaattctggcccttttBgHccatcgaWctataSttBgataacagtacggcccDcScaac
-tgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMt
-StWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaatagaaatgNttHtg
-tcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccYtgccattaaHVg
-aaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgcagNcatWggNtg
-RMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRMtgtccatttgKa
-gttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDcagaHaaaatStc
-aMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVatttaatttYSDgR
-ccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcggaMKaacSagtat
-taaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtactctttacatSgta
-gtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttatgtgtgaStaaga
-aRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaDagScKgtgSagt
-cMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWgHBWagctaagtt
-atcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMatHWcgccttaYta
-gtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatVtatStctYaYNt
-gtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcattaBaaMtattNSSt
-tHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcctcatcgtgWata
-agcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctKtDgaBactaggt
-WgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacSttttatWaataatDaD
-aaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVat
-gccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgtYtDtSgccaaaa
-YcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNtaaatBtaMaVatt
-cctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMStgtttSatNaga
-acaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMtaDtYtatHattSc
-ggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKttacMaRacaSaRaa
-WtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacRtaDaactNatYc
-agtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactcatVVtttaaaHg
-ctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKSatcgYaNVaatt
-acRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNtaatcgttaStta
-ttWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWctWtDataaagHc
-tMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatatctcgHSaaNBct
-gVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatactaaWaBYtKttacW
-taaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctcaScaataNgaaVa
-gaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtVStaVBgtcgNat
-gtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttcttatttatcaaag
-atWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHtttgMcgatSaag
-ttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaaattKKttttgac
-DtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacattatagBDacgat
-NatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtgatataatHagttt
-ccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgtatWWaataaHgat
-ttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagctNgtScagMcccH
-aBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaaaNgtagWtttYt
-gaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgDgcaYctattNca
-NtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaagatMcacatBatgt
-StctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYaYtaDaatctatg
-aVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHccRBWatatcctta
-tMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRattNcHSgaaHtaDc
-agctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRBctgcattatMaW
-aNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWacttctRatgataaK
-taaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWHtYaattaWacat
-tgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWaattcgDaRaaac
-gVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagtaaaaKttVWMgg
-ctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgHttatSataaWtM
-HttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacaggtttDDVMtNSg
-catataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatgDKctttgVVaaB
-gataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYtatVtccgtaagD
-cNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagtaDctctcVtaSc
-tgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRaatctgctattDS
-NDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRtaagtaSatatgat
-caaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtccaMRMaaattaS
-gBccggNataagtgctctttacYataRtcattgtgYBtggcatRtacttBaacDacaKtH
-DtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaaggttRatagtagaa
-ttVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacSRtattgcggtcc
-tcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMttRtYgacttgtt
-agggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVctttatcttggtYc
-tctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMcVaaMctaKRctt
-cRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgtaaVctaBatgta
-agtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacgSaWgaHcagtag
-NWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatggtatctacaaat
-gtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaacagaaRVtttKBa
-cttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttgatgttaRgacHca
-ttcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagccgttcatYattc
-agSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaNtWVcctacatac
-YtctgKtcattatctattatcgtcKtaataaattagggHctcatgHttSNacctYaKttM
-HtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBcatcaagtBtagcM
-agtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaagttaHSWataga
-aaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcattggttgWcatYa
-gtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBggtccatMattBaa
-tgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaaBaaagaaWBHSt
-tgattttKRcVataHatttttgaBtcctctacctcRYttagcatactttagaMHgtcatg
-tHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKattHgataNatatac
-gtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtcatactaaWWtata
-taaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatagcaaacacWacag
-aaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHtttagttttataa
-tRWggattYatatMaaaactWaDRaggataaWgMataggtactatatttVctataattaa
-atatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaattacaKtKYtgStRa
-agaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgattYttaacDacaH
-tcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaacWaaYatcaHaa
-agttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtctaatttcactBt
-gNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaatacgDgHttaNgga
-tDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYtagataagHtccat
-tcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatggtacacctttatR
-cgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagctcVNtttatgRtg
-gggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRacaVcSgatcagcaa
-cccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgcWtcKatattMKW
-taaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaatDttcttgatMag
-tagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaVStaatcctcDag
-tcataagWtataatattacagScHaatatagcaHYaaSagaaaaactYtRYaatcggaaH
-cVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKttccgtaWttcta
-aWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNgcaSgRVtcYtgt
-ctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHgWggKatMtaHcg
-tKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBaaatSttYgtagB
-aSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMtattagcgagaMc
-tNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWattatagaKtcWtH
-aMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHtSaVRYVgcagaa
-tWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVDggacagBYtBcR
-acDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctSttttttDtcSgtca
-aataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYYacSccVcataaa
-gacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKataaaMBgtYtaWa
-aKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcagctttatacgtSW
-BaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaaRttaDttctcaa
-BgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttgagaaMtatacttg
-tgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMVctaaBtgBaatt
-ttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtDaHaggctgtVat
-tDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMtaaacttccNBgc
-tacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagtaBttaggactYta
-aaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaagtagaattBcaga
-DcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgHactatNctacga
-VataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatctttgaagaBctg
-attattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtttBtgRtgaNtHc
-gStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaBttStHVMaccgg
-taVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttctaaatcacaRBatt
-ccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagNaggaHtttagcc
-ttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBttMacatDtattt
-aaRggattatBVcacattattaagWctactVcaBgcttKagagttatRBgctagaHtgDg
-aaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacDaaaaKcacaRKa
-agttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcattaacSttcacDtSt
-tgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaScaSDcaatMaaaa
-aaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattaggagtYBaaattt
-agaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatcRRtcataaaYct
-NtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtctttaggNtatatg
-NaagtMttccaagactRttgtgattBagBtaataattBStcaatttaWcattaatVtaca
-tgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtcatagtNcagtBa
-gagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYatttDaaatcactKat
-WatcDatatRattataaatatctattHSctttggNctaagtSacgagatatatatRataa
-gtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRaVgaYcHaagWgg
-ttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcccaRaagattNtt
-ggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaatacccYaDVYaVaY
-KVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaHacaaataaatat
-accaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWKcagttgcaacga
-gBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaagtHctctaatct
-tcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYtatcagaaKcttVt
-VaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatataHaMtcaattcct
-MaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttattaaaactYgMtta
-KHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactagKgtcacRtacMa
-cYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtctcaVatcgStca
-tHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaYataaaHtNcaSc
-tgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDcctRtgcgaacSt
-aWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaataatVtaaWaVgca
-atagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNatcaNatDgtagc
-taaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNatacaagtactYtaW
-gatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBDKVtaaaaatttW
-tcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaatagatYaggattVa
-aaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagtttRtattcttcY
-accaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaaagataYtacgMt
-WaaacBtttatcKacaaaatattMagtKccaaWccatttgtgacctttMSataMgBtctt
-aVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgNtatgtataaVtB
-atHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacgtacScttcttcW
-taatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgttatRagtaNtatgR
-taMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagVRBatacMaatac
-MaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHgKtgttaatDaHa
-tctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKgVaaRMaBttgca
-taaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtBttaaYataaSHt
-RtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttgagtataaRataga
-atRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYagtaWBcNatttcN
-NgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYgKgaaHVtaattM
-gaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgatgtHataaggtaH
-aWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctcDtgaSgVMtagt
-tKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgDgtatBggcttcB
-cWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMaMtaacVYaKtac
-tgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaMgVBKtBaacctY
-NcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSYtttgKtgtKacg
-tKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgtatBcgagaBaVat
-gatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttctaggKagRNtMBaa
-tWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtSaNRHatVaVacV
-tHattcaataatgSKttttttgtataRKYaatccRYaatggtaVtttaaaaaWBKtatat
-ttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWccVattcDaaatga
-ttgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacctaaatctRtDtta
-BRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNtNgWtVMVtRact
-ggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaacMRctcgttaaaV
-atatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaagtRMtaccgtBa
-gaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaaaVgaatgtgtta
-tgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataYaBtctStgaatg
-agDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttagccttataaNRaa
-tggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgcBttgccgtHKat
-cgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctagatSctaactctD
-ttaagacgcatagcRNgagatttgtacattSattaacttttcgttgattWatKtgaattt
-aMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDScNctYtBRYVgtt
-gtttaVtacHWattattcatttVaKtgKaacctaggStatttacaactcKNtaaacaagS
-ttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgcctaattaaaNaW
-cgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaagagataaWBcMgat
-RBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVttaatttVccaagB
-SWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtYttaagccaHtYa
-tatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaatgaattVaKtVYg
-NaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVtacaNatataHtg
-tcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtacatatcKScctDa
-tDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWYRatgatMgaMKR
-ctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgagaBDgtNMgKKRBN
-SMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStattcHttgaYttatt
-attctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHa
-aattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcagHctHtWaacgaa
-tgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacgBaNWtagataBa
-NtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMWatttNttVaaRa
-gMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVttcYcgtMattcta
-tatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataatgatRWgtttVg
-atMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYtSWcWNtHNacaa
-atactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtattatYtttDgtBaK
-cataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVtaNNYctKcctag
-MWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaaagttYgcStagt
-ctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacattattgaBaHattHg
-cYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSaagttHVtatMtc
-acaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgtaHaaKaacaYaHa
-ataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttatttgttaaacaaStt
-tagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaacaYDgaWaRtaK
-ttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaaVDagttBcatcc
-attttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatStttggaaWtttH
-tatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaSaVacaataNKta
-tagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHtagtMtWtttatYa
-tWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYWgRccNatatHtt
-WgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMctttcKacatMattgc
-aRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttctgtgattYatatY
-tcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaacttaBtgtcatgtc
-tNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSVRMYKYaggataa
-atYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaNVtHVagtBaatg
-aBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMcatagaSttctNB
-YcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctggaYattatttgaaW
-gtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWYKDYcVWVggttt
-McttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagtaaatWacSKaaa
-tYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaagaNaataataag
-cttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWMaaRaHatcgctH
-aaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaKtKacNVggaatY
-ttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKDgtYNtcYtgtct
-tttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttatWgtgHctaatMt
-RKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaattttcRtaaagat
-ctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtcNaMaRYcgagtt
-aHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcVaYaaSaacBcac
-atagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVgagaNaaaHaaSc
-cggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatttttDgcaatHat
-gaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHataMtccaKagagtt
-tBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYSHgaMcctttttt
-BtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaattacYSattattta
-YtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaaYccSgattaaaM
-DRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaaatactcgtactt
-ttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWgBaagBgaatDag
-aaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtStaaWRgtaaatH
-caMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMgaBtSaaaBtagtt
-aaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagacaYaattagaggKt
-ttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccgtaBgggMtKttt
-ctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDaVaggtttRaata
-BgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatttaYWttagattg
-gttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaBaaagaatacgca
-tYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYcttgtagaHaHaYt
-aRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStattatMtSatcata
-HcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcc
-tttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRVtaHgaattctcR
-ttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMtagMaHWtagatt
-tcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatatatattagtttgg
-MaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMtaattaaatattBN
-DacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatcaBYaaBttctDS
-RgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaagaaSNtattcNta
-taatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWgaagcaatattact
-caaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagNtaMatcSgSgaV
-ttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagMaggtKVatVtVM
-DVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttctccttcaatgNaa
-caBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatgagHtSattacBgt
-tYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNcttaRattatatctca
-gWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttgaacNttctcaaHt
-HaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatactattWatSaattWc
-cgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaaaKtcgatagcNg
-tatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtt
-tacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatattagcatcKBatttt
-gVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBHtttgHaggcctg
-acMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMgattVgaYgtatt
-atatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcattaatatVacgcH
-RttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgcttaScatNaHca
-atWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaacSaaatBtttKa
-KRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVggacaWaaatgHtat
-HccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaatatgMaRgggtat
-gaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtHScgataaNcBat
-aggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYcgctaacttaaag
-aattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaBSKtaDgtataaR
-cttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMacaWNgagatcDcgD
-tatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYataStKcgcaaaaaR
-aaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaatcatattcatSaY
-tgWaDacgaataactctggaDccattacgSagaaattgatttaDtHacgtcMgaMHaaND
-KttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcVNWWataatataa
-ccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttccatactHgStagH
-caattaagacagaMDtttagcHtgccctttattatSatWataBaaSMaccVVgtggatgt
-gttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagagcgKcaBggtgta
-YttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHttcataBtaWaNtg
-taatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDStacgtagaYtaa
-gtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHataatatacaatRY
-aHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMWVtYaacYagaaH
-aaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMgtatgKgSatDSg
-MtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcDgtWaactactgt
-tagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccWacaKctgcttta
-actagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRatKagNagKaWtHt
-tttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgtagatYacactYS
-BDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNttaHNtSctgtcW
-ttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDcttgattaaaatHg
-aataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDcggatHWgaagta
-cgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttctagccRtaaaat
-tNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatgtttaaDacacVa
-NgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatatagWaBgagtgtY
-aaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRa
-acKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaacaaDWaatDgag
-aStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactKattaKtatWagt
-tacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtatYcVttattMgNg
-YStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatgctaataVYcStt
-BtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgBtDKgattaaata
-gattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatctctMttgacNaWt
-ctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgtHgYttaagtNYt
-RcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKattaVactttSgtg
-tagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtaggaaatDttcctgag
-agaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcgtatttHtatctg
-gaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaaatKgtaagtcVg
-ccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgttctattgNcaaga
-acaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaaaaacKctNgaaa
-gagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYcMagaatKaYtca
-tttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWNaactVaMgtcNg
-McVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgctVaaaatatagac
-RaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVacaNVcKtaaagHD
-aaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgMaMccagcttRgt
-VggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgNaaatgtatgaSg
-DcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacacaStaNttMaatga
-ataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYtttacttaatVat
-gtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttRScRtVcgttcSc
-atMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtKataNgcaaScac
-tcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagatatttKatgtcgDa
-gaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaatatgKtMaWtWaY
-SVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaattVccMtgggWa
-tatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaagggataBRcaaBctt
-KtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtctattaagacacg
-agatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttgHtgagatBBaRR
-WSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgactaNaatRgNatta
-tagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaatttBDacatBttt
-HactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactaccYHttaaaMaVc
-BSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcgcaaataatatta
-aBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRDaatgVacaatat
-VBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSaccVgRaaBtgat
-aaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaatagaatNctcatHtSW
-ttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKttaaatYRMHaRtc
-gtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBttDHtcttggcct
-taNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcattcacYtattggat
-VgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtgtMtaacNtVtcS
-tttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtNtcgcHYgaDttg
-RtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaBattaMBtHtttY
-ttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtNcMKactcgtaaa
-VtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKVNaVggataagaa
-gWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagatttagttaaaaNaaa
-ttgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNatVDgttacVBac
-KBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaBtMaaaagaYtMg
-tgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWattagDtgagBaHa
-aNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaacatcactgaWaa
-aaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacgHtaaaBtatctt
-aattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDtataacaccVgttH
-aaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatWggatBVgtataN
-WgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctDgBSgYcagcggg
-WRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatgaagaKaatStgc
-ttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHataRcggctVBtcc
-aWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScYtSgcataDtWca
-cBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgtagttttcaaagt
-gcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatRaggtcgcccatt
-MttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSSaaHtattatWct
-atKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagggttggVYaaDgt
-tWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatcatacaacgMtaat
-YctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagttatSttgtDtgtM
-gMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRattaaaatgaaYYatt
-gtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaVtKScaYagtttc
-tagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtctagYHtRaagacDR
-aatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHggttgtRtattaa
-ttaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScatNtcMggaagggH
-taaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttgctgggcVattat
-ccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaataaVtDttaRRgt
-ctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaatttKtttaataa
-aagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttttaStataaHgtc
-NDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatattaRYaaVagagVt
-cHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBccWDgaatgaggaa
-NctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDccaaaBgVaDtct
-ScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttagttDctaSDVttt
-NaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttgtaaaggHattaa
-atgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaYtVaataaatcaB
-gaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMYttgtaaactacg
-KgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWaHctgaatctaaB
-aWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttcaWSttttgacHt
-ctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattcattttMaNaSaR
-aNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgBgtaatcNtccga
-agtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaataagttVDHgStg
-ttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtgaRRatgatccaa
-aggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaagcagtgtatDHg
-RaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatgtcDKHYcctSHM
-ttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttcgaHSgtMgcaca
-gaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcg
-aDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactgattStaDaHccYa
-DtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctVattagtWcacga
-aVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagttaNttatacaaaKa
-ttBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttctaaDNtgtgaaaa
-gRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacScgaaRtttctatt
-cMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctNatYttgcSSatt
-ttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYacaatgtaBgcgttV
-tattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMctatcatcgtaaaa
-YNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctcatatRttBtcca
-attBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHcacgRttVtatcat
-atacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHttagctatSBaBtc
-aagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggttttctaactttSaaa
-VHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatSaaaacNgatttN
-caagttRgacgataVtaacYNataStRtgaattactgtaKtNagaaccDaatgNDaaHca
-taDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactataKMSttaHaaaa
-caHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNtaaacattcgaga
-BKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWNDataaKatBcaY
-ttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWggaacacaKaaKct
-agtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScVNaRtaacgScaS
-tttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatctaaaaattNaaaWg
-WaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNaDttYagactSta
-cYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHaWcgtaccKaNat
-agWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatcagatgaaSgtVt
-HtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgcKataHtBtagSc
-WtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattgagtDYggKccNaa
-RgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaactagtaccgttggaK
-acRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttatcBtHtgRatgcc
-acctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaDgNRttaDKacgc
-ataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBKcaMtctKtctat
-NaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatagataSBagMtDVa
-taaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVacMcBaaDatKatc
-NtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWacgtccgcgtMctc
-aaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWatgtgStttgttt
-tatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacattSgttaacctaa
-aaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcgaatttacMagVt
-taRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcatggHgaDYgaVgW
-aaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaatatRDaccagctt
-tttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHgcVtaYgDacagM
-BagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaKtgBKtDRggtca
-YcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWccttgacYcaagtaa
-tataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKgaKtgagttgaaaH
-cgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgMgtttatagtKcV
-ctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttataVcagHYacaaMa
-attRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaDMtatYtaYVtNt
-cBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHttaaataattggt
-aaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaattcRMBgHttcta
-agaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKacBgttcttgtta
-taBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtcaagcBcgcYatta
-ctcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtttggtKtNKaMtM
-gcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgttaaVtagMWctNtc
-tHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSStaYgYatYgtaaa
-aattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHatatBaaDgcaKtc
-ccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRtatagKcatattDg
-KtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRttttttatataSaaga
-aKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYcaaNRctcKacKt
-tgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNtctaacatagVYa
-tcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgttgNtaattagaa
-ttgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKNttBatatttaat
-attBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataatatHcaaaatcM
-BaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagcaccaattcRctt
-ttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHagagHattcaggg
-gSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttaggatSYttaacBta
-gaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagHKagagMaatttM
-atgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRatBNVKtMaccYa
-accMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSgcgVtSatggcag
-gcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgcttaacgtDNaaRcgW
-aKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataagtattttacgtc
-aRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHaggaNcttcctKggNg
-atBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNaDtatctgaaggK
-cagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgttgatggtcaacg
-ttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcatRacaRcMcaNta
-YWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcRWMtHMaccaatg
-ataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHactNYcNcttaag
-gcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVacctatatStDgt
-ggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttgtcYttttttaBS
-catRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaaccctgNgagMNHaa
-KacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKaagMgctKtBagS
-aagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcKtKatctaaataa
-atRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaaRNtataVcYDat
-tagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMattDcaRggDYtY
-ttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaYagRgctctttta
-acVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttVMaNaRaNMKacH
-SagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYtcagtaYtctatH
-cgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRRaattcaRataaR
-tattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattgcttactctgatK
-tgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaattYccKagaVag
-ggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHg
-tacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNttacgVHaacSgSt
-BBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattcaaagtgattagK
-agNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNaaaaatVgHaatt
-aatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttDgWNagagaaaga
-gaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtaccWcaMRtHttaa
-atgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatacgaagaVcBgStM
-acMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMtatataaaaagat
-gtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtataVDaacagatttW
-tDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtccagHctttMtatt
-gtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtacctataDccMatt
-RgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVatVtttKattaagt
-taNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKtactctacgagttg
-aagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDttatMaWcStgatt
-KattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaSgDatgHtctaca
-attcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtatVatcHttcaDNK
-gtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaKaHgaatYNtBgc
-aaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVacYaScctYVgag
-WagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDaYtttttgttcaa
-aaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtBtatcatgcDttD
-aaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWRtaatatcDWcct
-aNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagtagctatttcacta
-aNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtttgMatggNtata
-caataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBatgtHaatgttttg
-atatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattcagaactcaRataD
-ttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHcaYNtgRaHtcaYa
-acHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKcatactatatcaHa
-atataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacKtWtHtBatNtSc
-ttttacaattagtaMaatttHgtctagMctaccagagttcaKcStaccKggaggtctgcN
-atctctDgYccaaVgttgaatgacVcatagtgtattttccttcatctacttSgaaStcag
-HtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacctVBDWattgHtt
-atattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgcaaMaatVaVaKg
-tatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaaggttBtgaDWBt
-RtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgtMatacatgNttB
-aNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgataNWattgtaSggH
-DtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattWYcgtaHcttagt
-gYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtttagaDDNtattt
-gaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVKaMaBtaKctaaW
-catctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtctYcaaBDtaggaa
-gcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDagttaggcttYctc
-atDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcacatNMattgtaaaN
-aaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaKgccagtgtMgat
-HDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttWcacaatSatgYt
-gacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNgDagatWtRttSt
-tNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaVcgtgaatcataa
-tcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDacctccNKtgaVcW
-attYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttccatgHaacttYa
-gMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaHttgaacaaataa
-WaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVgKaaaDttWgRBV
-agttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaacactMcaHWRgaac
-tWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgaggaagagcaSHcW
-tMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttctVKaKgcttcct
-DagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaattatttgctaagc
-gagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggRtttaacNagttt
-RtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMataaHatYMcccaaa
-DaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaNttgaaDactgBa
-tgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaY
-tBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVattWDgtaaHaYgDt
-aacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaVMcMctWgatact
-aRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaagaSYtcctWata
-tSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRDaRgatatacatt
-agtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgBtaaNcRaatcNa
-agcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaa
-aattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaHVaaNaNaatctt
-gtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatgBaaRatgcgata
-taaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcaggaBcttttcttVK
-atKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNtttagtatgRggYKa
-caatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaDgaKcaaataaga
-tMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgatgKtgcccYatDc
-tYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataatKVWcBataaat
-gttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtYtagcacaSctcH
-YtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBt
-ctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattttgaaaRHattgM
-aaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacVagttggtcgtgc
-BtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgattcttaaagcMMt
-taKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNK
-cRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagataDKgtatScatt
-aDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgaccgtgWaaagaaat
-gaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactataDgNagtcaSgt
-KttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRagattaKRtWaKt
-taaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatDtaVtaatgtHca
-tWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaacttRgaStaMBaa
-MtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNgcKgctatcccac
-SctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMagBaKctttYWBt
-aYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaBctaggaaNgaRg
-cttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWtttKgacaatatV
-ttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtcattagtaaNatct
-cagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttcattaHMaVKMDDt
-aSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKacccaaWctatccc
-tcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNBacagacaaatVt
-McttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgtacVBtcWcSaYHg
-tattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaag
-aVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtcactYtccttatg
-HtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaMgccaStaaWtVa
-ctgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNcaaKgttttMaMc
-YtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagacttcaScaacaYtS
-aattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRgggattttMcgttat
-taVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgtacggKBtSatDa
-ctRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMatgtacatcagcta
-atggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaDaatVgYaDaatt
-ataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcatttttaHacatKt
-atagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaattDaaVMaKgatc
-ggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDVtNttcNacgaYt
-cgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaB
-gtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcctaBgVVaBagHa
-aaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtMttatcttWtttt
-RaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKtttagtttagtBYcD
-aMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttatttttttcaaDtDDaat
-caaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgattRttataBtcgaa
-RataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaataYaggatccactt
-cacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWSgctcagtWaata
-WaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtatatgtataatWtag
-ccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNtactHtKBtcgaaa
-RttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagStatRtMaacKac
-acggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBcYtttaaatcgRg
-agagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSVagaattccgctt
-VatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYtaMcWaaVtaNta
-tttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacactDggtattttSc
-ttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHatagaaggggaWgt
-gBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgY
-tNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttgaKaWBatcBgaaa
-caBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtVKgHtcRattact
-ctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgttMcgatatcccg
-VctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgStgtatNStaaccg
-ttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaaStctgaaVatac
-tgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgctgagBacacttct
-DSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNtttagacttaagtHtt
-aatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHagDtMtatgatct
-tgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttctDcgtNtNatggK
-atHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaaWtagtVgaVBat
-cVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatDgaHtRatVWaga
-DtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcgattaNNtYacttt
-KgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaaRgDgttWtaatg
-VBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgcHttRctattVta
-ttgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcacttDattYttaVgRc
-acaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaBccaaBaYgKacW
-VtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgttactHaKgacaK
-taWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaHgHKtaatcctct
-tcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaaacgYacgagcac
-gBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagtYNHtgaacaatg
-cgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtHttNcttVtgaKM
-tgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgatcgcggccaHaag
-cVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagttttacaaKcaaaB
-cYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaatactgWBHVcagH
-cttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgtatacMatcaaac
-tagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaaStacaHagWSRS
-DtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHataaccRttagatat
-aaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMcaWttgttgVMaS
-gtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgtttHtWcttgatK
-tgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctgtgtKatRagtaa
-tttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcSHgRcaatttVcc
-tattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVtttctattWHttt
-acaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagtttDaVaattVac
-tactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWcMSYtWagaagtt
-ctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNttaYtaatagRtta
-SagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcggKKtaHcttttag
-HDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctgctKaNattggat
-ggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctcccacDBtgaWBaMa
-accgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVStatagcDgMgtaca
-ttacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggcccgcRtacgDtc
-YctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaNtDtaRattgRac
-RtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHtKtRaScgtattM
-ttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWgataMDaaaactgN
-YacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaagcctggcgKata
-aNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagattcaaaSgtgKac
-gtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgggaaBcctSSVaa
-gctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggcataDHattcaaat
-tcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtttaaHgcHStgtg
-gtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtttcaatgtNctac
-cgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatgagMagttgcaata
-tKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMagaRaNNttcggag
-YRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSBggtaaaVWgMaa
-tttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtttBagtatgBNca
-agHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMaaKtcggaBaVaa
-WaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatcttHcctttaggaK
-gaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataacDDNttatcYaa
-aagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatctRYcaaBctMMt
-cttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBaaatagaYgatgc
-ttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatccScBtYaYttat
-gaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttgtaatMtYaNaKS
-accBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgtaBtcaatMtaHg
-caaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaacaMataHatgttaa
-caaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStcNcattatRRaSY
-tYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacattggYaaDcSacg
-gYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcg
-taacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggttatttDtatHtcaH
-cBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKa
-aDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWgaYtaggataMtt
-cgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSgRaatKacMaYgg
-gtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMcaattcagtDctB
-attgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVtatcKaKSgtaWc
-gtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataattMgtatcataKK
-atDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSStMatttgNtgtca
-gDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaDgaDWtYacMWgR
-aatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatttttcgatcttca
-aKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaa
-cYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaataaatcSVcKaac
-attgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcgagccHattttaW
-tataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcatacaHcgMgaatYgaa
-taatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttccWatatagtKtg
-tcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWVacSHcaNacatt
-tgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattHYtSaYDVHSact
-gttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtc
-gaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttctgctaYttBata
-aRtattgatgaaactagttBgagtcttccatBagatctBaaagSacagtaaStaaatata
-taataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggKaacRagBaggta
-MYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctcttgaDtMgattg
-VgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHtttcagcNtatSg
-gtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaBtctaggcgtgtg
-tWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWttaSMcYtHtaactt
-aaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatRacatgaaagtcc
-tgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNtttBataaagVtt
-VataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBRtaaatRtaKtNg
-YWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccDaaBMgKttgaVa
-accgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNtaWatcaMttaHat
-tagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaacVttYBtaagcaa
-aMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNctgSagtctgcStt
-acSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatcHtcWtagggagt
-DtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatcttcDaagactgtg
-DNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcYaRccHtacRaga
-tccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDcagBaagtctSNa
-gaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHttaKtcDttRaat
-NacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttctagYcBataacVca
-gggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaaMaatWcgctagg
-gtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacccStDtagaDaBt
-gctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBaaaattcccgacY
-tBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacKaaatHatggDat
-SaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaKcNaccWtggttc
-ctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaacttWaNatgtgt
-taacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgatataBattctWRat
-MVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKatVtaWttaVggB
-BatcaaWatgtggagattDgWtttcaataDtactRaatBattWVacttWVNtVagHaHta
-tttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttagtccaKDcacgWa
-aHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatctatttatBaHca
-ttcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataaagVStcaatcac
-gcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNccttcaKHgcgat
-aDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgataYgtgttgtatga
-VcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWagaDttaatRcgc
-taKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaataaNBactBaaRaW
-cRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDNDtBgtttgtaNtW
-taatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDagNgttRDcWtaa
-aKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatttctgtcatNBga
-aaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaaYcNgtgatttWt
-NaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKttBtKaKcHaBttt
-aBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgNtScaatagcaHD
-agtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtgggtNatSaatStcY
-taBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBattaaatcWgKtS
-tKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctVHttaKDcctNcc
-BKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSgttaaatgWacRa
-tacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVgMKYtgtaVBtga
-gattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttBtgaBttacgaSt
-HgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtgacgYattccWcta
-agtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaagtatgVgtaVtgR
-DcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacagtcYDggagattN
-caDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtatcgttattHtHcK
-aDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtctcattVcaRctt
-ttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggDgctacVDtBMgB
-aDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVaBgVtRgggatac
-gctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaNcBttactgtgBY
-DaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaYggcagaMaaggg
-ttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKattaatYtacaat
-cKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgtaccttagcRaWaa
-gDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatVattttacgaggW
-gtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMaaRaRtccVcSat
-tttcaattagWattMMctataWatggtaagagRaaattYKKtgatagcMYgcVcgggSta
-ttacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgtWatcRacaaMta
-ttYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYtDctatccMaagt
-gcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaacBtagWYaagcaV
-acYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgcagtttctttttMa
-gWttatRggcattattVaagaBBttatctattatMcNtaacagttgaaaBaRtaRRtNta
-taYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaYatgYagaDcaHg
-actHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHagaacaDatgaaaa
-tcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatctggaMMRaaaat
-aatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDagYttWctttNgtH
-tcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatcttDtcgaKccKtt
-atttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWacHagtacccattt
-cgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgactattcttgtcatS
-ttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtcctYRaatccacY
-aatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgctacWcttgatatct
-HttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaattWRcaagBtgctD
-KDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKYgtYSaMtgataa
-tNggattKNgaSggactaaBagataacactcataVgttataaSacaatcRRaagtaDaag
-DYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggataaRtBatNcatg
-tatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattacattgWccttHNa
-ttataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaYHWaaHactaaSS
-agttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtatattacgcHaaaMN
-MtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBtatccatgaScHt
-YtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVatagtttggggRa
-aaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgagtaatcgttttaa
-tcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgttRttatSgacNa
-DttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWWagccgaactaYc
-cttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKtaHaaactaNtta
-tagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaatatgggMaNHag
-attgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaatKDatgaaacgaa
-atYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVattattaaaatSVaM
-aNcDBttataYgttttStacattgagagtccaNtgaatttttKtStatatttRaatttcg
-BDccctaaSWatttaaMBStcatacctgctctatctatKatatgaacaactctWBaNagt
-cgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttattatgatctagtDSg
-aHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaaVcccggagWatc
-VaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMtttatSBtBtBgacRa
-VgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaactttcgcttttccatt
-tNaaYgtattttactttacttRataBttgatagggacattattaaSaaaYtgatggaDaM
-ttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgc
-atccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDVttcaYttctHtH
-tagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacVaBWattagaaBa
-taatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSataggtataaacVaa
-tDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaWctaagtYcSatt
-NccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNttatWatacgRtgc
-ataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKctggataagtVgKY
-tatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggtgatcaaBtMttc
-ttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaVHtttttRtgBcc
-agtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaNNgtttVaagctg
-StttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVcagKatgaMttWD
-RatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttattaRKcgtaWatcaW
-ccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaYtttatgcHtttB
-BacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggttaaSctttcaaca
-tHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaagattDagtKccg
-accHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaMaStHgtattttK
-aRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacKtttVggMBcata
-ttDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVDggttaNgatBgt
-ggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtatNccagKatgtVt
-HtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaattggagagggtct
-agtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtcttt
-ataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagac
-atWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagac
-acatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYat
-cWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttt
-tttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDt
-tgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYtta
-RgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaM
-ttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtt
-tttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYag
-WVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKH
-aatKWcBScSWaaccRVacacaaactaccScattRatatKVtactatatttHttaagttt
-SKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttSt
-gttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNattt
-acttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKc
-tacatagYWctgttWaaataaaataRattagHacacaagcgKatacBttRttaagtattt
-ccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttga
-tHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacat
-VtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatcta
-taDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgc
-ggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgR
-tcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctt
-taYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtg
-BattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMR
-taataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRS
-HcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStata
-tNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctataScaHtataRagt
-cRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataV
-tttRNKtgRacctttYtatgttactttttcctttaaacatacaHactMacacggtWataM
-tBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaa
-cKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtt
-tHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgc
-cDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRt
-tRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtac
-cagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYg
-gVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDt
-taattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVtt
-cBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttg
-WatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHt
-YcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcH
-HggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaaca
-StttMtcgactttaSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVa
-ttttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatat
-taaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSat
-cataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWat
-YaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaag
-aaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaS
-atcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtH
-tMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaR
-VatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacY
-gatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWD
-BtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactca
-aatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgH
-aaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHtt
-cgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtatta
-ScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBg
-gWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataa
-ccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYY
-atKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaK
-aYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWag
-BgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgt
-taatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBta
-aactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRt
-ttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaS
-ttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcW
-tctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSg
-aNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDa
-acataKttKatttggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcat
-tttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaa
-DcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttY
-aattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaa
-aataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatct
-atgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaatt
-gSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWg
-RtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatt
-tctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcata
-cRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagat
-agtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaat
-HattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattg
-taatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStag
-WaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtg
-cVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtag
-caYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgcta
-aaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatcca
-gNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMga
-gttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYg
-BatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactac
-HVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRD
-aVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYatt
-McaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcag
-tatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMta
-agNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaat
-gttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtac
-agtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatKagStaNgtatac
-tatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRc
-cRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaY
-KBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaa
-tRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattB
-tctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacg
-acDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYS
-NttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNta
-tVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattt
-tRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaag
-ttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHa
-SttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaDaagattttctat
-MtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatat
-WKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaW
-tgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatc
-ggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgt
-tatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDtcNatataattct
-McStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgS
-gggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKg
-HcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtY
-gctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaa
-NgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctca
-gDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgacca
-tgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWac
-ttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVg
-gcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSa
-attccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaa
-aRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccggttRttcatagtt
-VYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtK
-aatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaN
-NctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttgg
-NtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtc
-gttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgc
-aDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMaga
-atgHMatcttatacgtatttttatattacHactgttataMgStYaattYaccaattgagt
-caaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHt
-BgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagt
-attDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtt
-tDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcct
-RagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttN
-cttagcaatttattaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBt
-ctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKc
-gWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRR
-aRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaa
-ttRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttH
-gSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDct
-aaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataatt
-attataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKca
-SYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattttatatatgatBc
-DtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctat
-ctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaa
-HacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBct
-KaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaattt
-DRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaa
-agaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaB
-cKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWattagttttNagg
-tctcaagtcactattcttctaagKggaataMgtttcataagataaaaatagattatDgcB
-VHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctSt
-attaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacS
-attgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgta
-acgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMg
-tgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgca
-acaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSg
-KStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRM
-ggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccc
-cYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcg
-VttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaa
-ttaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgtta
-aBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVa
-tgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgca
-gtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMt
-ctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatt
-tgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttV
-tagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMccca
-SttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDgga
-WgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtat
-agtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDc
-YKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaaca
-MttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDN
-aaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYga
-tattttaaatttccattttacatttDaaRctattttWctttacgtDatYtttcagacgca
-aVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgta
-tttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaY
-ggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagt
-YccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcV
-tgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggag
-RRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaata
-aHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagact
-actggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaB
-tgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattac
-NgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttaca
-HcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaK
-aatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgc
-aaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggc
-agMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHct
-DWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaa
-taMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtc
-DtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattc
-YNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtt
-tVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaa
-WSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttggaacaatDagtat
-tRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagW
-aaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtt
-tcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatM
-taacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKga
-RaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaa
-tNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaH
-acttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagV
-agRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWa
-atctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWt
-atttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBttt
-aKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBa
-acYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHa
-tattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgtta
-acaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatM
-gacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDc
-gtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaa
-SWccgtatWatggDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatc
-aataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNg
-tcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacata
-atcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgSt
-gattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaa
-taMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaa
-ttaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScat
-agcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgM
-taMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDt
-tgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttg
-ctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDc
-catttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttM
-atacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaa
-SaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcg
-gaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggW
-VtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttc
-WtatKctagDtYtMcctagagHcactttactatacaaacattaacttaHatcVMYattYg
-VgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttK
-cWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccgg
-ggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcata
-RDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttcctt
-acSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgag
-gatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYtt
-cctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMV
-cMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaa
-taaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactS
-aKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaa
-WgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYat
-taaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatY
-gttttgtVaatttaatagcagMatRaacttBctattgtMagagattaaactaMatVtHta
-aatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcH
-KaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKH
-acMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaR
-tatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctM
-tcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaag
-gaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRg
-tYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatat
-ttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatK
-acttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactB
-aagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgta
-catcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaa
-agataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatN
-YataactctSatatatattgcHRRYttStggaactHgttttYtttaWtatMcttttctat
-ctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtW
-tttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDctt
-cgtaWtaattctcgttttScttggtaatctttYgtctaactKataHacctMctcttacHt
-KataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgt
-tatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtg
-aNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtt
-tacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWcca
-agtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWK
-cctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtc
-aMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcg
-NaatttMatatgttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgca
-aYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtH
-WKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggt
-attHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagta
-ataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDa
-aVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattg
-StKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcD
-ttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaa
-VatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSa
-agKgttaatMggtataatgttWYttatgagaaacctNVataatHcccKtDctcctaatac
-tggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgR
-agacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcg
-tgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDt
-atDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVg
-tRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMt
-KtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattB
-atVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattK
-tggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYatt
-cHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRtt
-caMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaY
-aacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttac
-catRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKc
-agtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaN
-aKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataB
-tttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtat
-cRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRat
-ttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaa
-taaHaagagaatScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagW
-atctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaa
-ctttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaa
-RRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMV
-aacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcac
-tDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacW
-ttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggt
-taacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagc
-caaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgtttt
-HtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaa
-tatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNa
-gctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaY
-gttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRt
-aaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacct
-ataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagta
-ttaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDt
-aacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYa
-acaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagca
-aagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDt
-gtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttata
-tVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaK
-actaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVa
-aRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgSccta
-tttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNc
-gHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaat
-ggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgH
-RtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMt
-cgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttM
-aataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgc
-ttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVt
-tatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWM
-atttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatctt
-YtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccat
-cNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttctatattYWtcatt
-BtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSt
-tKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYga
-tDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaa
-BtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttcc
-KagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMt
-aHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataag
-atgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDW
-gtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgt
-aVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRt
-atttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgc
-gatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctat
-BagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRg
-gatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaag
-WBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDg
-tttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaa
-agattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVc
-RtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatS
-aaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMct
-gStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNa
-cgtaatctttMRtgacttttDacctataaacgaaatatgattagaactccSYtaBcttta
-ataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagctt
-atVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVt
-agKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctc
-cctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcat
-acYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaB
-cgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSa
-aaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaactttt
-HaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacD
-attgatattttacVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacat
-aYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattca
-HagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggtt
-aaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggta
-NatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMag
-cattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaa
-HgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaac
-WaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMcRggctttMttag
-acRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKt
-MYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDa
-gcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBac
-ttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgatt
-ctccatSaaRttaaYctacacNtaRtaactggatgaccYtacactttaattaattgattY
-gttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaa
-cVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagt
-cgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatggg
-MagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcg
-tgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcc
-tccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgB
-ttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSatt
-aacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBct
-gagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgK
-agtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWat
-cBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaata
-tcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNtt
-BaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactg
-MtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDa
-gtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYc
-WaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagY
-MttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaK
-tMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgt
-tatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgac
-ctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatg
-acacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVN
-tcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaag
-aBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcD
-aHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctH
-atgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagttagMVgtatagac
-taactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYS
-tgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHct
-aRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaV
-cgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHK
-tatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaa
-tcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagc
-tWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacattt
-aaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaac
-gVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDt
-atttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDa
-KaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSag
-tttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattct
-cctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWa
-aaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBaga
-ggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHc
-RagattttaSataggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaac
-HgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtN
-tcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtN
-RaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagta
-YtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataac
-cctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaaca
-cagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaat
-tataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttg
-ggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMac
-actYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgta
-tttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcg
-RtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaa
-ttgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaaga
-actSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaa
-NattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcK
-cYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaa
-aaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWt
-ctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttc
-tgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaB
-gWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSS
-aaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRg
-caSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaa
-aVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaY
-gHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacg
-gHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagg
-gatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaH
-atBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSa
-VttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgatt
-aatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatg
-gtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtB
-WtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaatagattcctScac
-ctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVK
-atttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttga
-gttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatR
-VYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRga
-atatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagca
-cHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacac
-YtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaW
-tSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHggataatYttYatca
-taDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMg
-gaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMt
-tcttKtgtctaacVtatctatatBRataactcgKatStatattcatHHRttKtccaacgt
-gggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatc
-gVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaacta
-atgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRcta
-taYcttatataaagtatattaatttataVaacacaDHatctatttttKYVatHRacttta
-BHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttg
-McattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNag
-ctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttg
-tDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBt
-aattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgc
-gccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHt
-MNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYg
-RDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaa
-aaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYat
-taataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgca
-attcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtatt
-aattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgt
-tgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattg
-ttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacga
-gaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWa
-cKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaat
-DMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttaga
-ccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtSctt
-ccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNt
-cagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcga
-ttatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYct
-MaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttc
-cgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtStt
-gaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDatatDcataaaat
-BBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgB
-tSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYta
-ttctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaa
-atSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYga
-tgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtac
-catNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttat
-YtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDta
-MatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtc
-gKtgatccttNcttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaY
-atatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatW
-tYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaa
-atgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWta
-WVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtat
-DNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDt
-ataaattaaccaactMtacataaattgRataatacgBtKtaataattRgtatDagDtcRD
-acctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgY
-gRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatS
-gtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttagg
-tttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaa
-taaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatga
-gMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcat
-tatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaStaactScattatta
-acgatttaaatgDtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStR
-tagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtN
-aNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatataacgHaaaRagK
-attSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtattt
-ttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatD
-ataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSac
-gagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMY
-tatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctgg
-tttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcat
-ctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaa
-gtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttW
-cgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctact
-tctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttata
-tcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccata
-tttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagctt
-cattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaW
-aataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWa
-cDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHa
-tattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRt
-aacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgaca
-gaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaat
-aataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattH
-tatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKt
-atcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBtt
-aaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctS
-gcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatcagttttYttagY
-aacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgt
-tggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttD
-ttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaa
-ttaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacag
-tHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatg
-tagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYa
-tgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaS
-acgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWR
-BtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatSt
-ScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaa
-YMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtca
-gaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWa
-tcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgac
-cttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagatta
-tNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYag
-aggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttca
-acttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacM
-atagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNgg
-ttaYVatgaactttttgccatataaataRatSaBctagttataBccgaaacaagatactt
-aattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWag
-attWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBc
-MWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaa
-MctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDt
-ttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcM
-ggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatc
-VgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatH
-gNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMa
-gSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaa
-gtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaatt
-DaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtc
-YtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSY
-gataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHc
-ttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgc
-ScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBg
-KgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaD
-HacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcW
-caRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtB
-taaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcgga
-gttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatgg
-aaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKK
-atgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMa
-tgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVtt
-ccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVat
-tttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgt
-aacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHt
-agBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctcc
-VgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttac
-aaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaat
-aDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtt
-tggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRt
-taccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVta
-KatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccN
-ttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDt
-tggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacg
-NBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVH
-aKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDt
-MtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHat
-cgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNtt
-aagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSc
-taaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKt
-caaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDta
-ttctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgat
-MtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBa
-tatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatc
-gaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatS
-taKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHt
-gatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtg
-tSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWR
-tRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYS
-tattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDa
-gttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagactt
-attgattaaYttatcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaW
-gcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaN
-tttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaa
-atcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMatt
-ttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatc
-ctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattat
-tttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRac
-aaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStag
-cBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRt
-tSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaatt
-atcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttg
-NactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRt
-RataaattttcatHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgK
-tcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactcgctctatttaga
-McgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaa
-ttgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNct
-taDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYact
-cKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaat
-RaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgag
-aRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcS
-agaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttH
-ttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcS
-MRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagctaDagMtataccY
-gaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaD
-tgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMga
-aYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattH
-aRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatatt
-aaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaatta
-KaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNg
-cDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKca
-aatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaa
-YtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccK
-aHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaag
-tcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtt
-tVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHa
-aWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNat
-tgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaV
-tgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgW
-tactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaag
-VtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNa
-aaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgat
-ttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaa
-tattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtY
-aNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaa
-YacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactct
-WtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggtt
-gtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactag
-KtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctt
-tagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgta
-ataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtat
-acgttttacgacgKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaat
-tVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMg
-tKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcg
-NatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattg
-cBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatag
-aataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtattta
-aYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYgga
-ctSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagactMatgttRgata
-cccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatag
-tagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttac
-tBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaH
-WBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaatt
-BaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtag
-tVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtata
-actgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacat
-cgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatac
-YacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtcc
-gYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYc
-ctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgctScSatNatacaY
-ttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaa
-gtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKB
-tacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDggg
-aatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaS
-DtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHa
-tBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDt
-ttDaccattatatSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccag
-ttttgtcHacMattcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRa
-KggtaYcaagttDttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMat
-BgKtttgHtHactaatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDct
-NttaDBaBgatagMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaW
-tctcSSaaatcSKattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHg
-ccttaScatMRcaccWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttt
-tRgWcttMtctaHacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgt
-BatcttacVcYacNgaattaacgagttgYgacttDattatacBattMgctagcctagatV
-caactNttcctaatgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVg
-taScMagatNNtttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKY
-gagttaHtgcDYataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagca
-DctaatgcBatttacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBga
-ctaatgtccWaaHataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtca
-gcatBgNNBVttttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaac
-tgttaatYatgDctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaag
-gacactctDggcgtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaa
-atcaWggcNSBagttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaa
-attgRgcBagtNtcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSattt
-NHaMcggcagSctcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatK
-YSgDaacNtcVgtttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcN
-HagtNtgtKtttgatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttg
-DttWcaaRaKgaaatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtc
-ggcatMttgaaggDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatc
-atNgYgStggactatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagacta
-agaggtatWtataaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStctt
-aWataatcHttataRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRt
-taataaRRttgtaagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSactt
-agcgtKtgtYWatatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttatt
-ttgMBgKaacaDataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagct
-HYaatgcaNaaRcaatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattN
-ctcNaKggWtMatcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNt
-cgtgtctaattaaacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNSc
-gDYaWtatDatMKgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYR
-WtatttDtaNMYMttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaa
-gctgcatctagcttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttK
-gttttttagtgtDHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWct
-aataaattatYttagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgatt
-acgRctctccaatgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtaga
-KHVtacctVtcaaccaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMc
-tgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKat
-atYDcBgNtRaRacattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtca
-tYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgt
-taVatttgcatctaatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMtt
-ttcatKSctNacHcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVca
-aaaNHaaaatcgctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataB
-atBttttWtaactNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactg
-tagVKtNRtcctagcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgD
-MttaHcaaYYtcactgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattat
-aggttaattgtaatYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgS
-atcaaactaattDtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBtta
-aaaMSaDattKRcctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVg
-tcHcttccgcctattDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtca
-WaYMttacttagVWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaag
-ttgaaBBaSHacVcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaM
-ccaaYStaataRttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggc
-cHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtatagg
-NggtgaatagBgagYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaa
-tgWtcStagcVatNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDattta
-atttataaHtagtVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaa
-gcctRgaNVgggttcataatagNatcctacactacgcatgtcggaYgtaKcatggattga
-ctttHtaattWNRaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVt
-atttWgcctaKtatBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgctt
-gcRagcgctSaatagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDV
-gRaMgcDgtaattttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattca
-KtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatga
-NccaaaaWaKatVgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatct
-acttatatcacYRaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRc
-StYSYaWRgMtacaHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttgggga
-BggtNtgtcaaWBaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRN
-aNtHRttatttattgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtata
-gSccaagctKttaaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttga
-aBcctVagcaaaatgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRtta
-ttggHtNtataatggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcY
-gcgagagRgcHMgcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttatt
-RaattaagaccMKtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgV
-tcatKcgcaatVaactatgcgaaactccNctatatMgactatttatSaaVttNttRttag
-HtccKtHtaaaNatttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYccta
-attcMNtgtYtgagttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattact
-VagaYtgaVVcgcaNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaB
-tcYYcatcgtgtcHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBac
-DcBgatttaaaNtggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKaga
-tataaYVMtaaDtaaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataK
-YagaYaVatcWcSattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattc
-SaDagVaMattattYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttc
-aatgtaMHSWaRtggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagt
-tDtttatatgttWBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaa
-gKtaKaWaataacKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMg
-tgccaBaRaaaBVtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttc
-SttttKKcgacBgggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDt
-gBatgactBaVtaagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaa
-NtNttcaaatagtaatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKat
-ttgatcgtVcatgaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctW
-SKttaMacaaDattccaRaYttttagttaatattcctYaacVactgctMcgagcaMYttt
-gaagctagtKgNWttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtN
-tNWatttSaHactagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSaga
-HatYDccagtBtgaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNca
-ttataDVDactatattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcH
-aacgttaccDaKtatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatV
-actDttSKtcMtDSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttac
-acaaatactcaatSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVat
-aggaagWSaaaaKatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHtt
-VtcattatctagttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNa
-VatcactVttBKcttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSa
-tVcggactMatatccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMa
-aaKDBttDNccatttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHN
-caaMaHttgtggctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNc
-gtWaWgaccgRSttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaa
-KDaWactWagBgctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMc
-aYcKtaataMatttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYg
-tagattgcgagtcaagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttcta
-WtatctYacactgBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttat
-gaccMaatgtaHtStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaa
-gatDctacggaNctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaa
-tcVttNKtaaWtYacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatct
-acaacKgttBatYatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgN
-tRtHaagcaataHcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRt
-tctacKaaVttcVcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtg
-attgSgaBtgccBtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRc
-aSgcatattatStatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtN
-YcRaYtVtggtDcKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaa
-MaKattgaagtBaaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatgg
-caWaaaaVaBgtaSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttY
-MtagtaactDtaagWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtc
-RtRggNagtYMattaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStag
-McctcatgattaWRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtM
-aDYatgDatttatagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgt
-catactcaaVcYBgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHa
-HtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgtt
-YattttNagMHaaRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcg
-cYgacgNtacNtccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaatt
-aactagRttaVcSaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWV
-ataatcgaatatgHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaa
-tMBttRRcRatccatagagggacatcgccWttagttgWttatKagtaaaagHtttccttS
-atVatKtgagcaatttattaaYVattcaaattctgSattRaMtgaatMgttattattaca
-NcggVagccttaaKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgact
-tKYtBacatgctDcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctY
-gcgcaaaccaHttVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaata
-aagacgKttcaaaWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgK
-tVVaaacaRaattgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVH
-aatVSVtccggatgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcS
-tNcatttVgctatacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtM
-gatStStcagatatYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcag
-catVttSgaaaaaatatatgttYttcattatacataatVcacgattataDggttBtRaag
-tHMtatagaDgNttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDat
-tgaaagggaagaHattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtK
-WaggtatttaWaaRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBB
-aNatRcDattcgaactataaattataactcagtSgatataagRaYaKHctggtaaNttta
-aNgaRHtttattatacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaa
-aaVcBgtWNtRMttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctN
-SacRtMatDactStVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDat
-cgtatVcaatWRtaggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKY
-tgctWgagYtWcctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagtt
-accttattHRgtacggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSt
-tagKtKttttgNHVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttt
-tKggacaWKaattKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHg
-ataatatgtattWataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttt
-tKaSttactWYtgBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWagga
-VccttNgtgagtcatataWttYScMtWgVRgattWtaSggacggWWctBHatattataaK
-aagttactaMRaaataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatc
-atggBWaagHtagtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDgg
-DNVcaacgSgtggcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatga
-VHtNMtcttactDaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatH
-NttgaatSaagtKBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggttt
-atggBgtcaaaYaDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMa
-atBgaatSttMtNaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNa
-aBtMgagNgKcttWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtg
-MctatcccacMcactcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagH
-tgtttctcttgtggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaa
-MYctNaKWtactaacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaa
-actacaggMatgtYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMac
-tcaaacStaaagctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattR
-acKagttattgaMtaatgaNatacDataaggactttccNtStatatKaagaataKtatgg
-tcctctatgaggttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNt
-agtWKatctaaWBactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtag
-ttaBaRRgatttaagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWt
-tgVgcHaWttcaNtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBB
-WttcttRaWgaatBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttK
-tcaYWatKtaaDtttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaactt
-ctcBtMtgDtgtttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDt
-cKtagRtNWaacVgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcY
-aSatNStcaatDNgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHcc
-aactKttYtatHYttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtSc
-aacggYtHtgcatctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaR
-atttStcaatatgcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaB
-tgcDacatcaHKtRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBat
-ctDatKaMcattMatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaat
-gtaaaactNgtagaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaa
-taSgttKgtcatKaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgW
-YcacDgaatcaatactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaa
-atcaccBtgttgNctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtSca
-HtctcHacVatagtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWW
-aaaVaRtcHNtctcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatcc
-ttattcttNggtBgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagY
-tttaatKcScctgaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattt
-tRSatagttSacataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtc
-aKYtaaatatggattataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBt
-tgtaWgagtaatWKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgac
-tMtgaaDaggaaaSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWa
-gatHttMHactaRacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaY
-ggctRWttaaKtRttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYt
-aRNgBDttMcNtggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgt
-YtDtgWaatcHgatDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagtta
-gtStYatYtttccgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNt
-aaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataa
-aaMBaaDtaMatDaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtca
-YKaRacagttHDagccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRt
-ccVtgtgaagVNttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBa
-tBtgaYSagHttSYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaK
-WactgaaYgaYactatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaa
-attSgttaStatggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgta
-gtctattttaaggHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYc
-ctaVKtttaYaaatYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgat
-caatttaagggctctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatH
-HgtacatgcaMagtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWt
-aaStcacgtctNaagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStN
-aMgDtaacKtMtacctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatc
-tgVatcacYctcVHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaat
-tSctYatctaagDgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaM
-atggatgtWagRctStagagaagaacagctWtNtataaaataRatHatKgctNactHgtt
-RgRgVcRacatgHYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgat
-cttctagctctHMaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctt
-tgaggHcYNaaMHtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcat
-tttcgacctctcacVttNtttattgtcttctaVcatagaattMttgtHtMgacataaata
-gttctMtgtWgWctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcaca
-tcHVaDtgttBtBacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgc
-taatatatgRtWVttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWt
-atcBtcataacNcgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgag
-agaNttgaattaataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRW
-cggctacDaYSgaaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgt
-aBRtttaactattctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYt
-atccgattcYtgaaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgc
-gYttgaaatgatKBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSat
-taaatttggtaagcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcag
-gNcaccctcBtgcKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcag
-NtcagaatYgttWgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNg
-tgcHagtacagctgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaa
-acWccggtaaRcattgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgac
-HgacgttcaMcctcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctS
-aKaagaatWVtcgttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaact
-gtgagcVtttaRcttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYa
-aagKtataMtWStcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatStta
-VgRtWgSggcaatSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttB
-actatWStaNtcStcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaat
-aatHKgaWgataYcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDc
-aacNttactattacggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgat
-aatMaccWagagatRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaB
-cctaagaSMttcMtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaa
-YRtgctSctaaaaNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtt
-tVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgH
-YtcatagaaRtaaBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgct
-aHtgacagcSNattcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtga
-tNagYttHtYtagccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKt
-aMHgaBcaWtBNYaWgtttStttaSttgataatgactMKatHBtttaVcYatgggtttta
-DKcSatttMatatcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaag
-aVtctccgaRgtRtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgca
-tcaaWatgttacatgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaac
-NWRHaaBaattDaagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBat
-aattgDtagccWtcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtSt
-BHactaaRaactNctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRa
-gaaacacgcttcKatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWac
-ggttcaaVgagaaacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatctt
-cgaatacggaHtaatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttY
-ctcWtRaaaaKtaatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaa
-aBcKcacMactMHHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggt
-aatatDSatgcctKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttg
-DaaaagttBRatHgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgg
-gcttgaHRDaWgatttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgc
-taatMaVBccaHtDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgB
-ttRNtNggaagcWtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDt
-aRatttDaaagNttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgB
-gaataggtWtKaaMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtK
-VccaaatcgaYVtaaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaat
-atacSaacctSatNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggta
-taaaggctcctaSatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatt
-tattRWgcgatcttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHg
-BgNcccataDtaaaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNa
-cgVRVctttttaacttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtac
-NatttttgaNcgacaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgY
-BggMScgaMcctagcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcM
-ttgatKgNgaNBatcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgt
-tacatacttYacaataNaagaaaagttataNaataSatacagttScacVaScaccSWtcc
-agKHtaatcaaatVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtg
-aatWaataaaaacatttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaN
-taNVBgcaataagaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgag
-atYactggttatgtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcD
-atKaacgtttggVDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttK
-agacWgHgatataaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttac
-gRRaaMactcatBacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaV
-tctDVataWtSgatagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagt
-atcaacBaWYctgaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacV
-actcaVaagtggtattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRM
-tacRYNataagatcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaSca
-taactRattMtDacVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactc
-gDaacDtaWctatRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKt
-VWtgacagKWattcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacac
-cBNaacagaaStctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRt
-agcatgtgcgagcScaMgtaatBaKataactMttttattaRcattattatacgtaagSNa
-tVRgcttcgaVaacHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacg
-tgcaBgccaWgaVataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtct
-cagBMKatgattgaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccac
-aaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaacta
-gctttcacaaatYtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaSc
-HYaKcaYacactVcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacc
-tattacRcaaMacHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKN
-tattcaagWKttgatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatN
-KSBcKactatacStcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaactta
-RtaaDSttVBYtaatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaac
-aacactDttVttgacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcga
-cYacttaaggVHcaagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcat
-gYgtgaVMtMaactaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBg
-ccNacKMaHggcBMttctgNctHggagaataYMgtaMccaataattHttYttKggtKacc
-aactcccHtMSaatNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDa
-ttgWcctcactcYccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDgg
-KtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaaca
-tgagatVtttaaggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacata
-aactactBgcacaacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaa
-DScaKtcaBVtaMVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgK
-cHVtatattSaaaatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKcca
-WVWtaVcggttatNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaat
-agagacttgHYatattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtc
-tcggatttatgtgatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcB
-cDcaggcactattHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaS
-aWMattttMacKtgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagag
-aSttgattgtSaaacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNca
-aBtattKaVNaWaNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaY
-ctcacKKgaSMgcRgKtgccagNMataatccaVgatcttHagttttcttaaccatagggg
-cttaDtYatcgaaaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgt
-gNttattYctVaaactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcK
-agtHaBtgaagBcggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaa
-NgtcaBMgggaatgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctatt
-aaagggaagDWVccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctg
-cctKWgttDDaSKactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttD
-NgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaatac
-cgBDaYRaggatatSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaK
-VgccRYctcRaKBKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSga
-cggtggVgtBtgacatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctS
-MKattcatagcacagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaata
-atMaYagatgVtatccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactga
-attaaaaaNattRNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactac
-ScattgKVtataaKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaY
-ttatacSttgYaYttcDNagggttVDagHatSgtacYVatataVattataSataacgKga
-tVtVacHYRWttatcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVg
-gaaggcYgSWaaattcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVt
-taccgaMatRaaaBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggtt
-ccaaagRRtaWtVctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctc
-cBtgtataYctatgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDa
-StatKtataBgcVaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDatta
-tKtVacgVcScaactSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKta
-ttaatgtKHacttcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBg
-BaMacaattaDaactNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataag
-agaagRgatatttcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtg
-ttaaRtatgtaMaggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMt
-aKccYacgNNctttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatg
-caattcMcttatKgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScSt
-BtagctWtHaaWattaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVag
-HttVtaagMaNatcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaa
-SaKtatttttMtctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaat
-gVSctgctYgaKgKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStca
-attWtRcttttaaSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDt
-SVgatgaacatgcacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtt
-tagtcaaSSaagaaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDg
-ttcgtgRtaMgaattttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgtta
-caDacaHDDagWtgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaa
-attcagcatagSgttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcct
-ttKcttWaggctttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcga
-caVtatataggataKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagtt
-caDtHtatattaacYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWt
-aVatttgttggactaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYgga
-tgNgaatcaatcRtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVact
-BMtatgaagtaaaaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtc
-accgatgagMtgttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSatt
-gKttaaBaKttatttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaat
-ttccBatBgYBRtSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtB
-ttatgaDtatKtcKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMa
-tcagaaccgaatKgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaa
-attDStDtcKggtMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtata
-gcKgWgttgaacgagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRatac
-cWctctcgBcgaggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDat
-RgMBaBacSaataSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYta
-DactttSgtKtRattgatttatatattattataattBatagattctaacDcRMaaggttc
-gtcatattRVYcttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacY
-atKatBaccMaMaaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKY
-tHtacttgtacaaaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaa
-WtaaaataDYtcaMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgata
-NBtaattggaatgcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSat
-tttaacHtgtagtBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRt
-WgtttaVtggcaaactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaD
-aaagtactgtcgatttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggata
-ctctaBgtYHMcttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatS
-gtatcYtaWcatgtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaagg
-ttgacgtRattKgaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaa
-gNKgaagacgDaRgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcSta
-ctcaatSMataHcaKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagat
-tagcatcctaMaaMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagtta
-WaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatR
-tYaMWDttatcNtVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDN
-atcYaggKRacaatcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagK
-VgcttSWaaHatagHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgttt
-gcRaVNttaDgtcttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatD
-agVaaaYgWtNDBgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacc
-cVaHatcBRtcttttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWa
-tMcMatatttDctttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttg
-gcctataaDgtcBctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgct
-atKttRatcattMaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattcca
-cgtacgaDStatatctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttW
-ccttgKgagtctagatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgt
-tactaaggtDaaggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRcta
-gatttDtaaatRcDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBa
-tggaDMgaBgatatcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgattttt
-aagaRaaggatggYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcW
-aagtaaggWcgMDaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaa
-ataMcttaWtatgNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRa
-gSgattctatgtYtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtat
-aYaatWHSttattgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatgga
-gWtaMatcRcccacRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcct
-aVcttaYBDBctRgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBK
-gagaatttataaaMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaSt
-acaVttBttcttgBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMt
-aaHtBgaaacaaccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttV
-catgaaBacaYgagHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtY
-aSaactgaaNWVagtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgt
-tcaSVtttacctaatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttD
-tgtcNtgacKagcactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaa
-ttWBctttgKgVcatttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgag
-ttctacgaaBgWccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHg
-gNatNttWaaacaSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaa
-gctMcaaagaYtHVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaS
-aaaWtSNBtttYataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaR
-tctcYgaatDtRcHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtat
-KaaggtaNcataKRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataa
-StHtacttaYaDaMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVga
-caWgaaaaaVYcRKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaa
-taactSttRggtcVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatac
-agctBgagcttcHcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMa
-gtaattggattgYYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaag
-ScaDaSttcactaattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHca
-WagctgtgcYatMHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgM
-atDaWtcBatagtaaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaagg
-tgNtttVBgccttgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgttt
-aagccaRtatRMcgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaag
-aggttttcDaRagtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMc
-BDgYactWgSgacBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaa
-BacDcttDtttBcatVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNt
-ttttaggMcWttNaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacM
-cattHtacaatttctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatc
-MaHtcMtaSctgtaYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBK
-gtSWVYtttctWttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWa
-gttSttttttaMaRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcac
-ggaatRatactVgaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDt
-taKBHccgtaHaacaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatc
-RgttttHaNgtKctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaa
-cKaKKtaaNtNataaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSc
-tgtaHcgccgaMBaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatc
-KaattcgHVNatNgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNg
-tcaaacgDttaaggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaD
-tRaBSaWcNacgYaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgY
-aatattgttttaNggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKB
-tNHtttctWWtattgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttga
-gtcVaMVgaatNtaaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactgg
-aaKaWYRgcatgcgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVK
-StaNcMtgatataatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVa
-tactgcctcHcataDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataatt
-caDtcaDgttgtatRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaat
-tcggaDcgaVtYattaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStB
-aaatRgaacMSaagaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaSt
-actgDBagVSggtSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgc
-McggVtgtRtcatctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttac
-aataggttWcttataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccct
-atatgcWtNttacctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMt
-gcaVRaaHgtaataattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYt
-taaaaacagatataaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBa
-tactataVttDttDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgN
-tgDKYcaatcataWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNt
-gaagMttSttttgDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcgg
-DtgtRDRcaaatagcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaK
-ataaacttKaaaMVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRt
-BtaataattgtttgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYat
-ccccHtaNcattcacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBt
-aaaYgatattcgaaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtac
-tRMttactgtBggcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVt
-aaRgKcttggatSYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYta
-ggaaKtYHcttgKattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattat
-BgcaKWKtagaatagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNa
-tRcYYHtaacMaSStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctc
-caDRcaHtBSWcYtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatS
-gatgatHKgttgcaaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatSt
-gNgWaaaaMttgcYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatg
-ttaaYcagYtgKtYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaS
-tttagaaataatgcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaV
-tYggtaaaactgcaagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRc
-ctgttaHgWRaattgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgttt
-atgaHaaggattStaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcW
-gaaaaMcagttctgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaN
-tggttSattttcaacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagca
-atatcagWatgcRVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactt
-tgtttgaccatagHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatc
-agaatgtHattcaVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtat
-ttggaSatttcHcgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaac
-aSacctgtaaRgtcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKag
-ctDWtttatatWgDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYt
-gttNDggcHScaaYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHt
-agataNaattatcVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDg
-DMacttattatgaDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtat
-HagtttaaHtcagtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtK
-taSaaBatMtttgttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBcta
-BaaaataatttttNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaa
-tgaYtKaatYtaaggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtact
-tNtaagHaSacgWggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgt
-atacgatKatataaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacct
-KSttBttaatMtgcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcg
-WtWBaRKVtYWWWgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgS
-aaBaVtcttNgtcgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtH
-ttSMactatHcaagaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcS
-BtatgacBcctcgggtaatWaaWtacacaattctRVgattctatgtgtatHagataggga
-cVaattttDtNaWKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaH
-tcWgctagtgHaatBatSataDatatcacccaagattttcSatKgatWtgaagtcBMata
-aHaaMaattatgcttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttK
-atgtctctBMggacatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRatt
-aaBttVaHtggattagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBa
-taKacStHRatctVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWg
-ctgtacttttatgaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttataga
-aacacScccSaNtaaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaa
-ScccSggaMDBSgcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgK
-StaaaHaKatatgBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccag
-tatWWtaRtKagatagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatt
-tBtatHtctNactKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSa
-aDBaaaaagaWaDtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataat
-tcNctactWaatNaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaV
-tctcgVctagctcgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatY
-taagcattgaatttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaag
-MtDatgWgYaataKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYa
-aWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStct
-ggaatVtactaSNtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaa
-tVtgttacBcctStgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDa
-YtaactaNgtccaattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaa
-RMagataMatgVtVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgt
-NgYatgtgcYtaatgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBtttt
-cttttYatataNaWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSat
-tgBatSRtgKHttacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDt
-taacSatttaatttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBa
-atDttatgKRKagataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttat
-aaacaaatttcccttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgat
-tBcSagaDKtttHtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVg
-gttYaaggattccaNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYgg
-DSgKRaSttHStcatgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHg
-ataYttNattatcVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNag
-aNtKtaDtgDtatgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacatta
-aHgMttatcgtHMNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatga
-attgatatgaWgccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatata
-caaaatttcgNHgMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKag
-tKactatMRtgtDtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVcc
-ttagRgWaNaKWttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaH
-NtcRNRKaatactcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtt
-tYtatgtaaaggattttagatattKMcatgYaaatcaVactcagagtRYtgtaactatag
-tBaDtVaWatDatctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVata
-VagatatgtaggcWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggct
-aaatVtctcagRagDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMac
-RaattaHBacRcNaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgc
-gHattStSKYRggtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVac
-atacacaaattaattacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgca
-tgHRtcStVtaatHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaa
-ctMKttatRcgaataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVB
-taattWtMHgNaWDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattg
-SWcttagttcgtHtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaS
-tgccBacctaaBagttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSa
-gttcacgtaDaYaaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRt
-tttBMHgRMgHagtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattag
-tggcactactVattagatctctgtttatcattYttgatHcHttagStgatgactctDaaa
-tcagtgttgtttttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKact
-tctgaaNaYacctNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWct
-DtgtgctataKagtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaY
-tagWtggtgBcStacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSg
-caggtgttRaYcaaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKtt
-ttatMaaaNgMatYattgaatNtatVaggtKctttHattcatttatYtattagtataYtt
-tagYcattagaaataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctV
-caaVagaatttaagaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataag
-tatVgtDgHaYttcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSa
-caagctaNttRYagMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgc
-tacNKaKtagttgVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWta
-cgWtaYattaaatMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattga
-gatccNcaaaHttccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccc
-tctcttaccDtHcttcctBatcStVaactaatctacatgtacataacDgcgaVttataag
-caaRWataattcggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaa
-VgattVDtaaNaccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgca
-WtgagYtacttNtaagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKt
-DtRtNYNtctactatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKM
-RtagKttaatagtggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagR
-tYacgaDaaMMtcagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtg
-tgttRtgacataaagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatc
-caatacaNtgcgctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatc
-WgtatScattactSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgta
-acSaaagYaMataYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVttt
-aDtgttatattagWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatat
-taNaDtcaatttaVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggtt
-ScaaccVKHaaatacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWctt
-ggatcRctctaDagWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgt
-tHSMaWttacaSaatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDN
-acattcMDaNVagatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWt
-acgaaHatatBaaSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaac
-cttRtatNactMtcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaS
-RtHgaaaNcaWYBggataatBactgaataYgcgtaacccactHataagaaWgcgRaccca
-gagaVtataggcttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtK
-ctcgaaWctDttttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagt
-aRctttaactattNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgtt
-aaatRaBRttcatcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHaga
-tttctNtWatcaaaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWc
-tctggaccatcaBgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaat
-actgWcKaMacRSaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgc
-tHKttgVtgacgattgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatt
-tMttaaWBtctcgaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMt
-ttaHacctVacctaaagtcactttcWcaatggatSaataHattacaMggtgaaWaacaga
-aattgttggRggcgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcD
-attcaaacHaacttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttg
-tVatgacaHtgtacatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttD
-BggHgDtgaatcaagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRat
-acagattSMttaattYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggS
-agaKKttRggtttgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDta
-aaWtttagHMSSaagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagag
-gatWcatttgctatcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDga
-NYttcattRtagNDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcag
-ttattcataaccNaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaN
-catVtgatcBaRtttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattc
-atatWcHtagtagatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctg
-DcacattMctNgWattatatctSttaScctaDaatatDYataaaaatataatNctKaNaa
-tatcSgagttaagtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNta
-VggatattatagtBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaa
-caacgRtaattgggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDtta
-cggagagtMtaNHatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtat
-acgatVttKcVtagtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDt
-catMaNKtNacagMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRW
-gtYtYBatDcattggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtga
-tgattgcRcgtgSaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHta
-DaaDtttccaatMcaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgt
-aacctagatggYKRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYc
-KtttttgatatacataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttga
-tcaagaDatgaWtRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYR
-atcggaagaRtattaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctc
-ctaVttRtBattaatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtga
-ataacggHtaaaatatataYtacBcattttSaaSttgatcatccacatatgcYaVcatta
-tcaagacYcMaataagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHca
-caatatKatgRMgatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDctt
-HaDcctttgggMtcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtV
-gaHagDNtccBVaaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatat
-ttaYgaaSccaRacgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKa
-atcaggaDYatgVcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggt
-MaattaRcaaggaatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaB
-tattVtatttttatYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWac
-tatataaVccaNtcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagta
-tYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScM
-RMaBttctSgacKaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtc
-KKtBYgtagNtatgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtc
-VagaagcaaaaStaaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagt
-ttgcctatRtttNtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaa
-gtgHgtgtcScaataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVg
-tcaatctaccaDMtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDc
-KtgcaccttccBccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRt
-gtYcYttaagataaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaaca
-DttcaKggcVcgtSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaat
-gtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtY
-MtcatcgttcRatgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHB
-gaVaVattaatNNgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattN
-ttttaaVctYagtRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaata
-tMgtgNtcttNtgattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaaga
-gtactccattMatataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgK
-aWaacagttYaMtNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctW
-aaggcacatgWtttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtac
-SaMStattBgcatttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataat
-acaMtYgcggcatYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcatt
-MtatccgattaggtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWa
-MYgatNacKNNMatcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaa
-gBaaatBVactagaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVa
-aatgcaYaaggatgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRN
-aKRtKcaatttgatWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYc
-cctBtWttttYVtttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttca
-ttMtttWcgtNgcgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVc
-aHatattNcactttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaag
-taaRaaRttggtaVSaagaattattcaatNttWcaWtaggattScaStgattBagVBtta
-NcNaSagttagtcttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDat
-cSaVgtgMttaHttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagac
-cKggRattttaNcgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVca
-gatccccStaatRMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtct
-aaBDVcKSKVatSagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatN
-ttggttDtgcDataKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBat
-gacBRctgatDcMaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatg
-agcatStaBtcctgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYc
-ataVtagVagtVtNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBN
-RatttacatttHctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaa
-BNtNacRgtttBSVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtg
-aRtMttgccVttatNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtY
-DcDactttRYtaaatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMc
-HgtaactHaaWattKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSag
-BaaaVtYtgVtaNtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatM
-attVaSatSBtagVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDttt
-cattVctccagYtcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRa
-tgaaacVccgtcaKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHt
-SagaaacgtaSaatctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBgg
-aHaDWWcYctYtcatctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBt
-aWaatYcVVcacMatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaW
-atSScMMgctatctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtcca
-tttcagctactccacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttV
-attRacatctgaaccataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaaga
-DaaattKttNtaataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgt
-gttcctBtBtgttatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHa
-caaattgttcSttBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKa
-SNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttK
-tBttttttagcttcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaK
-aacttgattttatctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgS
-gtatcaactgHataacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHM
-gYgtagatctctWttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcg
-aSctcactcaaaaYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagag
-gttaKagtcYtNtgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYat
-tcVSBaMDcagatVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttM
-NVaactWWKcaaataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNB
-VtYagKacHRggYMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNtta
-atatgcaaacttWgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgaca
-WatYcSacaRaMgttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBN
-KNatccgaacgtKgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYct
-accMcgDtgBaRtaaattaaagctKtaaatatatVgctgaatatctMatccaattacaSY
-gcactWttaRacattgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBt
-aaagataNaagtaaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttat
-tSatacSatttRtBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatattt
-gtaaKBgcacattttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSg
-WtttataDMcttRScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHt
-ttDtaattHaatctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgtta
-NaacagNWtagtaNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaM
-aaagattKgaaaaKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctc
-YtaacgtgtatacttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtt
-tttattttatMggaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKga
-MtgtgataBagttMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHH
-DtgattaaccttttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDtt
-agaacSatcccaYtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVa
-WgtaBtaaStVtDYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYa
-atctatSatagttDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDg
-BactaMttctVcaacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatH
-tacaaMatHDttcaagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataa
-BHagggccHagtaaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataa
-WactVtRtaatgtHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaac
-taVttHcatccgctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtR
-VattaaagtHtaBgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtg
-taaaRatYtcgggtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYt
-YactgtatWaaWtaaggtacaDacaDgttStgcttatctattatgttgStaaDaaattag
-ttRgtgcBgRDtaWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgat
-tataWctcWMgaHgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaND
-NggaaacgataatttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtM
-taYtttaaYgaHttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgttt
-atagacataMgttgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNt
-atcMagYaacacMcaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgY
-atHcggatactDDctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgc
-aMaagaacSctHRtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNac
-aaaaagaaatgatacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcR
-YtggtatccBatcaccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScB
-tcagKBgYtaRKttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVat
-attKactatcttDacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaat
-cgMStttaatKacaVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMcca
-gRtacaatatcttatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtY
-RaHagYtcVgaagaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaa
-acaRRBaVtRtgHacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNaca
-ttacWcttacBacgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaW
-aSMttgataatctataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgc
-ggacaBaRattttcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctY
-ggcMtactatgtgaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHtt
-ttttatRYYaccagatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttc
-attattgYcHtgatcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMt
-tccNtWgtVaatNtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatcc
-ttaattagttaaatactgctgNcttgctcatatatactaDtagctagRcataBcgccRaa
-caagcacaagtaHYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactaca
-ccacggaagcStHgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWat
-attaccYaagWtgaataatgatttgtatBYSaDctatRattgaatDgWtMacggtatttt
-RgtaagtgWtRtagtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHa
-ggtattacBHMcacKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYt
-SSBgaKatcMVHcDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaa
-VWtgHtaMgaattaHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDga
-StattBtBNHRHacaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYt
-catcaaKtctaNtgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMa
-gtgatgcgtattKHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaM
-NaacattctcaacgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataa
-atgtaaVtaSatcccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDtta
-ccaataSaDgcggtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaac
-ctatgaWagacaYttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtct
-caNcaagttttctacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatK
-tattRtWttaVagtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatat
-aatcVtDBHgtNaRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatN
-VtagctgtatVtaaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatc
-tattaKgtattcMttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagat
-gtagttataaagtctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaM
-agaataRWacgSactctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKt
-HctatMcttctgtHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtct
-atcYctDtagHKBNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtt
-tcYaacBcagaMttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttat
-ttgYatttDgtcaatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggcta
-ggcaacYBtatWctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcga
-tatttcaDHMMttVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMgg
-tKSctagKtaBYMggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgat
-agagaMtacacNacacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatat
-acVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYW
-ccaacttagaagaaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNatt
-attcaatctBcttatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcat
-WgaVataatatgYYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtc
-cHcaatgtWtctttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaat
-tMatcaaBtBcagatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtag
-ctaBVNtStWBgctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcg
-HgaRattaatDtNcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYg
-taattaactagctatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaa
-aataVWHMcaYcagcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttag
-tatYaaatcaccgaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKV
-atatattaaatccggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagt
-ctataHcRRScSagcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaa
-aaatatagaNaSgattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDa
-MctgtYcDtgaattRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBB
-YagSagcaaatcKgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaat
-VacggStctaKaRaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRc
-aVataattKattaaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataB
-aVgttNBcgtagSttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcD
-aacSDStcaRtcDcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaa
-RtcaRactHgaaatccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHt
-tBctaattctNggBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtH
-ScaBctRccataataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgt
-atcatBtDtaWatcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSga
-ttRataYaYatagaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHSt
-attaKcttatNNSataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHa
-ttattcaaaaBatataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacg
-aBcaaBttgagtKtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatga
-taMKttVHVBacataKaatcggWtaccagMtttcKgScgcaactattVctHScccaaccc
-HDtgttacgttHVaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWat
-aWggacVgtggWtatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHat
-ttVacttagcgtHagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYc
-caYKVttDttBctYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaag
-cacaNttctataYMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgtt
-acBtctBttaRtSMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNta
-cgatagtcgaVtaacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatca
-atatNttagttMttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgttt
-aagBcccgBtgcgtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtt
-tMYMtaaaaaattcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtg
-cataYtaaaaagStcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagc
-gVHcgtcatgaHgtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatB
-tgttagNDggtcRttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNt
-atBgaaaggcgNttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatB
-cSactaKYaDVaVtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtM
-NaatttattaaVgaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcct
-agHatttttVaattttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWttta
-taWtaatVttKaKMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMt
-tScaggRttgtcttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRg
-tctaWDtagWtaaWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYa
-catttBaattKaaaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSac
-DKcacaaHgaggaaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttY
-taattBMtaggtacatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcM
-gtaNacSatcWBWtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaatt
-gMatcttaVaacVYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKcc
-actgattatccatBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKg
-aYttHtatggaaaatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataN
-tattcVtcataacMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcg
-agtMVaHDHtatgcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgD
-attKtHKSVStgMtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattK
-aaYWtYaHctataKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttcc
-gtttHcgtKtcttaatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaV
-taggttYgaNagYcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBatt
-atatKDacaacBgVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggV
-aacYDgtttDtggKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaM
-gSattgtacctatataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaaca
-gaYaagtaMatDaatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtg
-gtKtRcatagHattcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVt
-NDgatKtHaaattaattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcc
-cttttBgHccatcgaWctataSttBgataacagtacggcccDcScaactgattttaSWYt
-aaaMaVatttagctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYa
-tBtaWaattgaaYattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcgg
-tcaDcVttgataMNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgt
-aYaggctataBtcRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttac
-WNtgcaWtaaVaNctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttc
-caccaNgtgcatRgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacac
-tHWtNtgctcgtNaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggc
-taccDMctacVaattBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVN
-tacgVttKaaHtgagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatR
-tttagttMctacKgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBa
-HgNtggaRaWataacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttaccc
-aaaKRaaatattcKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtgga
-aHSVacggttaHaWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtct
-gHagatcaSacaatKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNg
-aattWccgattcttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaacc
-aYacMDtaYaaaatttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNa
-gcatNNatgttcRaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtg
-tgWaagDKattttttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYagga
-gcYatacYaKaagaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgta
-VaacDBaattacaNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgca
-ttaNgatgaaDaBBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatM
-attgtagRDacaaacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatga
-NBtcKgBttRtattVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcat
-aaWaKHaataaagYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatc
-gaaaKaaVcDttcVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacB
-ataRYRDgttcttttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaV
-aHtDcaYKacgKtcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtag
-atgcatYatVaaYWaSactgatccatatNMaNagNtaatcgttaSttattWattaggaga
-atcNaaccaaaWatRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaa
-cgaSWcatcaVgatataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttg
-aggSgagcKttaaatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgtt
-ctcctaactBaaSRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgK
-accgtcYtcctBccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaa
-DccWHcctttaatcWactaatactcttacttgttcttatttatcaaagatWacYctacKt
-aSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattg
-aacttaaKaYcSBSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBD
-DcMgcatagaVNttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtac
-aatgtgctttatatttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaM
-MaaWggBataaKtttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataata
-acagaacDRWDgWaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtS
-DtHacKtNgtgacaaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctata
-VctNttKgRtatataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKga
-aggBDtttacttHttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttcc
-KaRgaWccRataVtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccY
-gtWatDcMYtaaRtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttaga
-gBcttKacaaMtagaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccag
-cMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatat
-gWaaatcgMaaaatcctgttactDtDagaccYWacttctRatgataaKtaaatcaMtttt
-caaRtScaWgatMactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMc
-atgaatYgattatacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRa
-KgVagatatWtcMKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKa
-gtgtBBNctacaaacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDa
-tgBtaYaaaggttaMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNt
-tatSVttMScNaaattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaag
-actBYgMgNaBttaaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKg
-ggYtgagattaMaaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWt
-ataattDtaactttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatg
-caBccKctaHcBtctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagat
-ttVaMagaagaWWgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataag
-tgctctttacYataRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataa
-KKtgtaaaRMVtctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccB
-gBtWcataataKctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDga
-VgctagtMNVtaattaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNt
-KBaScagttctgcMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattt
-taacSttaaactaaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNg
-tgaaaNcagataatcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtaccttta
-cKtMWtaaaatWtcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaa
-atgatRBtRctVctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgt
-tttaaacgttgBggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagta
-aatatcgMcttatRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgttt
-aatagagWgDKaYatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattat
-aBVccaNMHttacgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcatta
-tctattatcgtcKtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgt
-ttgMcStgttcaaSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDc
-aaaataKgtatgtgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtactt
-ctccttatatHatgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgct
-tgaVctaataMRttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtD
-ttVcataacSVtattagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVa
-taHatttttgaBtcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYac
-acggtaaMtatgttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWcta
-gatataaNtaccgaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMcc
-aDaaSatBattagcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYct
-HctgtcttaccBattVaYtttHatgaVgttcRgaHtttagttttataatRWggattYata
-tMaaaactWaDRaggataaWgMataggtactatatttVctataattaaatatgtgttDtc
-ctaKataaaaacggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggY
-agtNactttaaNaStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSY
-gtctRaatVagcaWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtaca
-NcSRttagaatcatVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttcta
-DtcttaWttaatcatatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaat
-ttcttDaNtRagttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYt
-NctgatcRttgaYaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataH
-WVKaattVtKcgatcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttata
-ctaatcMaaaWcgcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBV
-ccNcRgagatctgtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtg
-tcaHNYaagStKcaDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaa
-cttattSgttNaKagttctcataagtaatgactgaVStaatcctcDagtcataagWtata
-atattacagScHaatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctat
-tRaatattNgVaatacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHa
-NWSgVtgNttVgtattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctS
-tHWttcYagtgNtBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRR
-atattaHaaggaagaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctM
-McacagcgtYatSctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDt
-catHtgaVcYttctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtH
-acttttgDaBWDtcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgc
-cBSttataaNctttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaa
-ttattatYKtNcggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVtt
-gaacBagtattctatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgt
-actaagtRtattBMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNgga
-acgtMRtaaHctatacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtY
-aacaacRgtSgtacNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggt
-gaacttNBBYaaccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKa
-cagcacagcgKSattaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMa
-gcatgcDcatcBagaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNSttt
-aKaNggtBtaKtgHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgW
-SNacttSBaggMtNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaa
-agYtMaagaKctgtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaa
-ctaRcaBRtMttRgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatat
-VHKKagaaRSattaacgttMattgtatagBagtatctttgaagaBctgattattHgRtta
-cDgMgtWtaggcaatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgt
-aBacctgaaWgtKatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNK
-gNaBHaaKcKaaatStBcattgagggcRSttttctaaatcacaRBattccacatagacat
-SaDtaaaSNtttgtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVt
-aRtacWggctcaaaacVctWtacatagttaattBBttMacatDtatttaaRggattatBV
-cacattattaagWctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgatta
-WtMDWaRccaaWaagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatt
-taSttaWRgtctaaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBH
-tccagaMctaagaWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKaca
-ggtgMaaMtatVaVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcg
-ttagHKSgcWtWcaatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRg
-gtYcgaWcgcccataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaa
-gactRttgtgattBagBtaataattBStcaatttaWcattaatVtacatgtatttBataV
-YWStagcaYKDaagYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaR
-tagatatcYWtSataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRat
-tataaatatctattHSctttggNctaagtSacgagatatatatRataagtttcatgcSaa
-KttctHaRgaaDatgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcaga
-cKtaBtggcaacHtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaa
-taVacgaaatttaBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctac
-aaagcWgDtVtctaBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVa
-gtttaaStgttgRHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccg
-KaRgtgaatcgtaWcatYtWaBtaBatcgRattcaagtHctctaatcttcctattaaYga
-NaaaaRaDtactDtMNagatMtttRacKaccWaYtatcagaaKcttVtVaaaatgttgtN
-YgtHtaDactaggaRttaccVaagMacgcKtatataHaMtcaattcctMaRtttttcatg
-tctcaacatggtgacatcaBatHaaMagaatttattaaaactYgMttaKHBccgactttt
-aVaaVtcScHaNccttacccatataMgggDtactagKgtcacRtacMacYgBaatttcag
-YcacaaataaaaggagYaaMHtataaaHtKgaaHtctcaVatcgStcatHtcaYctttWc
-ttattBactataatWctcctRKaaHtaaHYcttcaYataaaHtNcaSctgattaagaKaa
-tWagRaVaNSHDaactaYVRaatgttatVYttatDcctRtgcgaacStaWttgaYcatYt
-ggtatWNataMtDNRtgtttgggtHcWtatHaaataatVtaaWaVgcaatagDatgScgN
-cagggagtcaDtgagataKtgtctataattgtgaNatcaNatDgtagctaaaNtgtagtc
-BatgWcagagtgtWtaagWtaKgattHagWRaNatacaagtactYtaWgatataRctcNK
-cttttgaRtgKWtgtgRagcNtKtYtgatatgatBDKVtaaaaatttWtcaatacgRtaa
-ctttaaaaMtaMattaVNHRKttattattaaVaatagatYaggattVaaaRactcaagcc
-ccRtagtScgDWgVSagtggtaacataVatttcagtttRtattcttcYaccaaaagttNt
-tKtggBttBcSaWaattataatcataBtgtMtMtaaagataYtacgMtWaaacBtttatc
-KacaaaatattMagtKccaaWccatttgtgacctttMSataMgBtcttaVgtNttttSaa
-ctatgaggaSWataRtHtcgaMagSMccSaMctcgNtatgtataaVtBatHcHtattaac
-gactgNKtttaMtVaaaagaatVgttMWcttacacgtacScttcttcWtaatccatactc
-taacaHHaaaatDctNtgatMcRaaWRtMgttgttatRagtaNtatgRtaMttggaaKWt
-taRtHKMaDDaacatgcgttaaaccaaaDttatagVRBatacMaatacMaaatWcNcaaH
-ttBgttgtacggRKaaaMtcHgttaattattttaHgKtgttaatDaHatctggtaatMtY
-aRgMccKRaRKaDaagaggatBtSacatactccaKgVaaRMaBttgcataaacYtKgaVD
-tttgcatSaatattatNattataWatWgBttaggtBttaaYataaSHtRtaccaacMtta
-ccattccKggKNtMatacctctgtaYctaaccttgagtataaRatagaatRBtttttMtg
-WNtKtgcttatgactcSaatattgtBRBtSWVWYagtaWBcNatttcNNgSKacctgaaM
-KgatWcYHgRataYggtctaMtggcagaRgaaYaYgKgaaHVtaattMgaaWaWaDataa
-gaaaaBDatacatatgatcNtagagMtactcatgatgtHataaggtaHaWatMgtagctt
-aWtcStataSttagttttgcaagtgctgacDtgctcDtgaSgVMtagttKtaacgtacat
-taaatctHgatYatttcgggcaDtVttcaaacccgDgtatBggcttcBcWtacttgaatB
-aRNcgYtgtaaaaaRDctKctagtaKSatRtRatMaMtaacVYaKtactgRDcaataaat
-SacagctDaatggttttaaacNttBaattgattaaMgVBKtBaacctYNcaKcaVtDYtc
-BaaataNSaBgatacccgtVtaatactSgtttgMSYtttgKtgtKacgtKatgataaVcc
-aMgtaVaWatttatattgBNtgtVgVNtYStMtgtatBcgagaBaVatgatgBcStttgt
-agDgYMgaattacacHtaaaaaBttKaaggHttctaggKagRNtMBaatWcagMSBaaVt
-gaatgtgatNaatSagcaatttHctatWMtgVcNtSaNRHatVaVacVtHattcaataat
-gSKttttttgtataRKYaatccRYaatggtaVtttaaaaaWBKtatatttatgtagtcNa
-tSaatatcMDRtgtBttYtatKaattaaaaYtcWccVattcDaaatgattgtHccactgN
-gctttBtgagatWDgVgtactgtRtaaggtBgacctaaatctRtDttaBRaYacaaaYYt
-caaagaWaSDttctttggacttcBcgaDacHataNtNgWtVMVtRactggaaagSgtggg
-tgaggcctccataaatNttaYYgtcBatattWMaacMRctcgttaaaVatatagagataK
-atRMtHaVagaaBBtStttaatcaaatgagtatcaagtRMtaccgtBagaWKtagaaaYt
-tcSScttaVttttcatatcaSgtcWNgtttagccaaaVgaatgtgttatgaaYaatgaat
-aaaagagatcttcYacaaatataDgRttcMtcataYaBtctStgaatgagDaDgtRNaMt
-YMatatagWNggaNtcattatgacYgtBKYttttagccttataaNRaatggaatccaBac
-gttacttatMNggaaaMtaaRtctagtttttKKKgcBttgccgtHKatcgatVtttacat
-aMtagNaMttctKHNctaaNatttWaRNgRatctagatSctaactctDttaagacgcata
-gcRNgagatttgtacattSattaacttttcgttgattWatKtgaatttaMtSBattKKct
-taaSggcactaataaatcactcaMgacggtRcaDScNctYtBRYVgttgtttaVtacHWa
-ttattcatttVaKtgKaacctaggStatttacaactcKNtaaacaagSttcgattatttc
-aRttVtaVaaacRgDtaatgtccMaacNtcggttgcctaattaaaNaWcgKataaYcctS
-gMcataaatttgaaatttHtagSBgKYggcgYaagagataaWBcMgatRBNRaYctgHat
-ctatHttgaHtgcHKBKVaWaacacWNRactWBVttaatttVccaagBSWacaaaatcDg
-ttattBtHaMtMtHacKgWtcctcctttHaatagtYttaagccaHtYatatttacgtcaS
-gtgtYttgBcatcatttaNRgaKgBtgattttaaatgaattVaKtVYgNaatgDaacaaV
-tHaaatggtttgaYYatgctgcacatttttctacVtacaNatataHtgtcVtaacVgtYc
-cgaactaKaaaatcagtttaKNRtaaataMatgtacatatcKScctDatDcKttSatttt
-agatgttHtcBtKgNVRagctaRVtttaNYWttcWYRatgatMgaMKRctNVMgttVagW
-caVStcDgtttctcRatBVggaccgaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccN
-gcacaggVYtMcaaaatgBtaKcgaRacccgStattcHttgaYttattattctaVMttga
-acDaWtNccDtcHBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHt
-gcgaaStttctacttcgMagagtaaaacaDctgcagHctHtWaacgaatgtggtDacgtc
-acataSaatKtcWBtataccaaScttNgDgcctacgBaNWtagataBaNtRcSggtaMat
-tgaatgtRHtgHaaNWtgttaccatacctBataaMWatttNttVaaRagMataVtgtacc
-attYVcKYcgagtaaYtttgDaKDgVacMtttaVttcYcgtMattctatatataaggaag
-agttaaatHgtWctatttgaaatHttgScgtBataatgatRWgtttVgatMBcgctttat
-gtctgWKtaacaaHttaMtctttatcDtccaHaNYtSWcWNtHNacaaatactNggtgSt
-acKatgtgKVctaBcaHcttaccaaWatHaaYtattatYtttDgtBaKcataaaatcaNg
-ttNYcatVSgtgatatYDMMtggaatKMaagcttVtaNNYctKcctagMWtttatttBat
-tNagccggaRgagtattaKatgatctacatcaKVaaagttYgcStagtctacttttcatK
-tWtKtctRaRDtcggtataMcMDcaattNcacattattgaBaHattHgcYattagaatta
-taaBtattBKHtgtaacHtHaacaaRYaBttaRVSaagttHVtatMtcacaWctgVtgaa
-tcVtcctcNataacacgWtattDWccatDDYtcgtaHaaKaacaYaHaataBtaaBKagt
-ttcStWataccgNcaDtWNaaRgctcNaacttatttgttaaacaaStttagtgVaKgggt
-atNaatVagtataVVaHtaRaccacaRatacNStaacaYDgaWaRtaKttgtaatacggt
-ttgccaaggMWtcaaccttcgctaMSaattaatgaaVDagttBcatccattttccaaBgg
-RttgKgccaaaYNcDcaSatMcaattYDcatcWatStttggaaWtttHtatVaggttDgV
-WatttaBWMagtcagcgaSaaSgtattctacHtaaSaVacaataNKtatagRMagtKYBK
-ggtttKatDacaWaYDaactagcaDttctctttHtagtMtWtttatYatWNaBgHtaBgS
-ttRgattatgKcccaaBtWcccataaNattaYtRYWgRccNatatHttWgttatacttta
-cBYHaaaKaHYaNttaatagKatacaaatWSMctttcKacatMattgcaRctBataaVaH
-tataSctDVtRaacttcggScYctataHRHtgttctgtgattYatatYtcYHaataaata
-YtMMgttaaatgatcttaaattaKRtttaaRtaacttaBtgtcatgtctNcaaKactMtK
-atagRaDKaatgSaHcRtMDctagatcaYtRatMSVRMYKYaggataaatYtDBaDacDt
-aVtacggaKttattNaggScgWcaYtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNa
-tNttSgaaactctBaggtHHtgaSagYKNcataaMcatagaSttctNBYcttattcatag
-agagtHWWDtctgMtRHtactgggagcKcacctggaYattatttgaaWgtcaVaataaga
-aNatRgtttacNtWYMBcNScgggataataaagtWYKDYcVWVggtttMcttYaatagaa
-KaaataDcaYMVcaVtgtStctctWaagtaRtaagtaaatWacSKaaatYaScctggtgM
-KtYMtctacDatctcaMatVtNaataaNtaattgaagaNaataataagcttaagtgtgcg
-tVgttataYaagVgNaaRctSctgWKVaYKgctNWMaaRaHatcgctHaaYMtccggatt
-gtgBacatHaacttggtggDVgtcaaaggSatWRaKtKacNVggaatYttatttattcaa
-SttttttttcaatgttatttgttttaBgcatacWKDgtYNtcYtgtcttttttgtcaaat
-gatacttWagatDatttcacctaaaaggtgagttatWgtgHctaatMtRKagccagcgcV
-gagYagtactgtactttagVctaBBaYNggtYtaattttcRtaaagatctMtaVYatctY
-gNMaVtaWtcattgRtaNataagaaaacVSctHNtcNaMaRYcgagttaHcgacNgagag
-BgtKaactaaatatYRcggatgtKtttactgDctcVaYaaSaacBcacatagaaataaaa
-WDctVcNtttRtcataatNagatVMctBgttcHtVgagaNaaaHaaSccggatSctaHgt
-gaYRagattDcSDtMStNYtgtgaagcttgggaatttttDgcaatHatgaBttHttaaca
-tBcaaagtaggtKgagacaattaataHcaNaaHataMtccaKagagtttBYSagDDtaNa
-RtWtWagatSgcSKtcttttcaaRgtMattatRtYSHgaMccttttttBtHactaattca
-HtMatagaattVtBtDatcttVgagtatttaaaattacYSattatttaYtagcaVSHatt
-DctKcVattataagagRaccccWcaBtYYtctaaaaYccSgattaaaMDRtHatMaYtHt
-cgcaaggWgBaNVDatataaatWtcMYSVtacBYaaatactcgtacttttWgaacRNaat
-tctHagcYtaSttaaataatttttaaSDtKaaMcWgBaagBgaatDagaaatactcctNt
-gRaattaNWcattgYVMtRtHgBaatcaagRcagtStaaWRgtaaatHcaMacDctatNa
-agtactVHaaVagMgttgKtgtHatcMacatagMgaBtSaaaBtagttaaNaYgStRRct
-YWYVtttMNBgcctgMctcacttagtgtttDagacaYaattagaggKtttacaatMttct
-ttatKagaaNtBtttKSHWSaVtVtgttaRSaYccgtaBgggMtKtttctYWttcaVaag
-ctttttMBgDKccatagVactWDgtRtKMtgBKaDaVaggtttRaataBgttYtattatg
-ttatgtcMMaatcagaatagHaacaattRcBcDatttaYWttagattggttgaMcgtYRg
-agMtcactaRctcBMaaNgcaStgcgNtgagVttaBaaagaatacgcatYMaaatDtacg
-atatataMtYKatctScatattNgStYWgtttaYcttgtagaHaHaYtaRaaagttcMHa
-StatcatYtttKBtctataaaatcaStcatatStattatMtSatcataHcaWaccagHta
-aggaHatatgagaaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcctttMttttagta
-aaBHBaaattWKgtaaccDataactgatatgtaaRVtaHgaattctcRttcgcatHtaag
-ttYYctaaattttgWDacBtataatttctVaYHtMtagMaHWtagatttcaVgtKaaacc
-tgHagSgtacSWttMaBcHttaatcttMaStYatatatattagtttggMaYaatHgaaaH
-HgatggccctactatSgacaatcVMcatactBBMtaattaaatattBNDacYtgYattBt
-tHtNcaatgcggacccctDcYcDtttaKaSggtatcaBYaaBttctDSRgacHttagMcg
-gtWgagtcctRatatRcttgattggaaaKggaaaagaaSNtattcNtataatVttgagBa
-MaaBctWtHatgcDaatHccgMDcgcWaaDaacWgaagcaatattactcaaaatMgttgt
-aaMatatYtctRSctctWcatttVatgBNtaaYagNtaMatcSgSgaVttSaccaatacc
-KRNcataaggYcDMWaSKVcccaaaggVtHtgHagMaggtKVatVtVMDVatBgttWagc
-ctagagacaaaggtataatttgcttgtSaaccttctccttcaatgNaacaBtttaVcaac
-agWaHMttgttaagttNWaaYcgaaVtatacBatgagHtSattacBgttYgtNRRcttga
-tcttaHcaataattattttccttgaYgacVgNcttaRattatatctcagWWatNcDgaca
-cgttaatRattaYcKtggtSggWgatMcaaDBttgaacNttctcaaHtHaagcgVtDaaD
-tNMcagaaatWaNtatcttcattSgatatgatactattWatSaattWccgtctaatcttg
-KDacatRatggBttatggKgaagtttcBaKtgttaaaKtcgatagcNgtatVDagaDtaV
-tcaactttYgaBYcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtttacMaVaaagaa
-ggtVtKNYtWcYaVtRVccgaattatacttatattagcatcKBattttgVDggcKaHaYt
-tgcggcNaatRactWagWgttcagtgWMctaataBHtttgHaggcctgacMcYaRtRtcg
-gcaatBagttaagcDatatatNttgtMcVtaaaHMgattVgaYgtattatatSaDaaaaa
-taWacaaNttKttcatttttHaMagatYtgtttcattaatatVacgcHRttacaYtaagt
-tacaBtcgaagcgttWtatVWRaaSacggWaBgSgcttaScatNaHcaatWacaMatagt
-tcagYBagYgVactWtgtStNatacatYgSYDtaaacSaaatBtttKaKRSWRcRYMgcY
-gVataSNNtWgVtSaMgBcactaaatYaKattVggacaWaaatgHtatHccacStaatag
-aYaaaVaMaaacYYMctcagaNattatctattaaatatgMaRgggtatgaMcttaHgatt
-gtScgtgtatVatHNgcYttNatatBWaaactNVtHScgataaNcBataggtaagagatt
-tMatVtaagtaaatYgctgttttaagatagaWaaYcgctaacttaaagaattggtSYgtV
-aStttRtcKtHaVcWaYaWVSccRactDaattgWaBSKtaDgtataaRcttaaaatKcag
-tNgtaaataaatgattcatgtcKRctatHaYtMacaWNgagatcDcgDtatKaHgaBcaa
-aNWaRataYtYYacttgcactaaYDcKDttWcYataStKcgcaaaaaRaaNtttatttgc
-tYatgtcVctttcBKcgtcttatSttattYMttaatcatattcatSaYtgWaDacgaata
-actctggaDccattacgSagaaattgatttaDtHacgtcMgaMHaaNDKttgtaMgRNta
-cataWgttccStgaaatDaagYRtDagcatcHttcVNWWataatataaccKaatWtYgcc
-tacVaagttWtHactaRaagatatMMtYattMttccatactHgStagHcaattaagacag
-aMDtttagcHtgccctttattatSatWataBaaSMaccVVgtggatgtgttgYgtDHSaa
-MaKcagaagcWacaaaBagRactKacDaDgagagagcgKcaBggtgtaYttatgcDatga
-NgatagagtBtNtaWatagcacgcgcatDRSacHttcataBtaWaNtgtaatcDctBaSt
-tttaggcWtBacgacaVYtRttaacttatgKcggDStacgtagaYtaagtaatgacggVM
-KtWagcatatagtcataagMgatVagVttSaacHataatatacaatRYaHacaWaaactR
-tHRaatagcaVtcMataaacatattHaStattDcMWVtYaacYagaaHaaWaccNHcatg
-tcccgaNttataaNaacatctBtaDNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDc
-aaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcDgtWaactactgttagaKcccDctc
-NcgtagtgStacgtataNcgVaHHagYttStaaccWacaKctgctttaactagtVattta
-aatKttRcgactaHttSaKtcagBBaWaacccgRatKagNagKaWtHttttcWtatattt
-attacagacSBagDgtagtatHtgcattgcaMaRgtagatYacactYSBDgctgatcMat
-tStSgattcNttaBWaacatgcttSattttctatNttaHNtSctgtcWttKgttgttttt
-KaMHNMcaacaagNattRtcBaccatKgtVtaaDcttgattaaaatHgaataKYtgagMt
-gcWaWgtRttcDaatgRtDgcNWSgtagtatRttDcggatHWgaagtacgcVtcaatHtt
-tttttgaKggaSaStaataWBMtgcaaatacgWttctagccRtaaaattNWaMggataRR
-aaHaaMcagaaacacacgDaatctactaactDgatgtttaaDacacVaNgagKaBcatat
-aaattcgRtSNaatDttKgKDgcaaactBDtaatatagWaBgagtgtYaaVatatMtaac
-aggtataacgKMtaKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaS
-HgtatttataaYtcaKatgNacgtcWWatgDttRaacaaDWaatDgagaStaVScctgca
-caaBtatacttctgtctttcactacWcaaaWcactKattaKtatWagttacttgBtgaBM
-agaattgtYYttttVatttWtcBagaatcctcWtatYcVttattMgNgYStaBgtttctt
-WtagcaggtMatgtRaaDtDKttgataDggtttatgctaataVYcSttBtYcatctVtBt
-YaVagtaaDtgagacctgaaatcNKDactgKtacgBtDKgattaaatagattatagacta
-tggacgacgRgaaYKgYaRtgaaaagRgBaacatctctMttgacNaWtctVagtStMaac
-tacaatttcVgatacKctaKgcSactaDaatHgBgtHgYttaagtNYtRcaRgYtBaact
-aatatDctaacSKatSDMatWtagKtttagaaHKattaVactttSgtgtagWctaggagc
-tttgaScatcggSttaggtgHtgYatgtctNtaggaaatDttcctgagagaHagttKctt
-ttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcgtatttHtatctggaHWSataWaVt
-tgKgtKBaaaggtaMNaatttRDtcDattaStctaaatKgtaagtcVgccaHKgtgtcga
-SVtaaaaHtatgaaVcatacacVtKattaWaKDgttctattgNcaagaacaKYaHttWcD
-accattttagacttttMttaRaMtaHtacNgccgaaaaacKctNgaaagagggaVttttg
-tBVcatttatttVaHcgattWttMaWcattagtaYcMagaatKaYtcatttagacttStD
-tcagacattctcYaaKMttcagtSNtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaat
-aaVataacaDtaaggtcSgtDatttaKtgSNHcgctVaaaatatagacRaBgaNtaattV
-WaKtgcaattHttctaNRWtaHtttaaSgWBctVacaNVcKtaaagHDaaaNagtYcYKa
-VKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgMaMccagcttRgtVggaaWgagtag
-gYctRtaaWtgtacaaMNtagtacggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYta
-DHgaVtWaaNagDtagggtHagHgctRagaNacacaStaNttMaatgaataaSgagBgag
-tgWccDtVgagcDWVctBttccaWcacgHttgtcYtttacttaatVatgtKtaaatttaN
-aYttaStMtVaStggattgtVgaMRNHtacaaNttRScRtVcgttcScatMtBtttcDtc
-atVctDaScttagacaaDaaBtaHtacRgRgaRNtKataNgcaaScactcWtKggRagtg
-taaYtaaattWgNagatatYtHattWtYWatagatatttKatgtcgDagaVcgKVagaca
-gagatVgHWtaagttgcatgaKaatggattaHcaatatgKtMaWtWaYSVtNBDttaaHa
-McaRctWScNcggtggYSttcagaattattggaaaattVccMtgggWatatHMaYtaMaa
-caHaagVtgDtggcHtRaagtHaagVMWacaaagggataBRcaaBcttKtHtMgcKaVta
-acaRatKRaMaRtMtcagcaataaaaVccNcttMtctattaagacacgagatNtatttat
-aaaSagaaatatSccaRHKatYMacgttaWKtgttgHtgagatBBaRRWSacatacWtNt
-cWgttcaaaccactVcaSaYtaactaHgtcVWgactaNaatRgNattatagacHatgcYW
-cttatctaagcttaatatgaaRcaDVaSaHatgaatttBDacatBtttHactacaNaNta
-taVcaVtattKgMaSaSggttggDNcgtgatactaccYHttaaaMaVcBSacctgatata
-taBgcaattaatBaHtttgtaagggataaacatgcgcaaataatattaaBVcaWgttagt
-VaaWctRgBtgYtttccgYattttYMaVMtaHatRDaatgVacaatatVBccgttaagac
-tcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSaccVgRaaBtgataaatttcaVtta
-taSMatacKtaWttgcaRcgtgNattatttaatagaatNctcatHtSWttaVtRattcaR
-YtaaattDcaKagcWggaWcStaatNVgHaMaBKttaaatYRMHaRtcgtagMRgtattc
-ctHtcacaaaKtaNttcaRcatRtccgatNDagaBttDHtcttggccttaNtattaaSta
-WgKtVWNaMccaVgVgtatcKacDaYcccactcattcacYtattggatVgaWttctgSDa
-gaWDattctacataaaDggtactatagcNcSgagtgtMtaacNtVtcStttSgNDaDYga
-aWVgtactRtaNcYgataHagaDtagttggaHtgtNtcgcHYgaDttgRtgStatcattt
-tKtWVaYattgNtaaYgYccHgWactgtaaaVBtaBattaMBtHtttYttVgtaYMWatW
-gWtNaccVtgMWaSDaatcYWccaaaHtacgKagtNcMKactcgtaaaVtaMatttcRct
-tgHtattattcRaaaWaWactgDttttccttttaKVNaVggataagaagWttcgBtBtVa
-YcataRtaacBgNaaYctggtatctacaaaagatttagttaaaaNaaattgctcaacttt
-BKagatctgctgaMgtBttgtKaSatVgcacgaHNatVDgttacVBacKBaaKaBctccD
-tagctataWKttagtcttYgtaSccaatcBttggaBtMaaaagaYtMgtgtNatgacacc
-tWcKattctgaNtaSgaaataatatVSaattaaWattagDtgagBaHaaNHtBgttctta
-tHaggaBtatcHtSttgccaatNgtaHtttBattaacatcactgaWaaaaaatggatagM
-HtSgaaBSatacBSaagMaDcaattttcgtctaacgHtaaaBtatcttaattagtttatc
-ttcgtWVttatatcgccgaagBgRaDcBaatHVDtataacaccVgttHaaSgaagaaatc
-MSaHBattgcaSgaSVaRttcaMtgtgcaatKaatWggatBVgtataNWgNctttacctt
-tgaaRatSaKttHgaaaYSaBttVacWttcctgctDgBSgYcagcgggWRataaaatgca
-ctagaaHStacaatHtggtgtBgcNDttggattatgaagaKaatStgcttHtgKNMNRag
-taNtaDattgaDDcKtaaatcVVBtcSgNcRtcHataRcggctVBtccaWcaDgaaRaRc
-tgaatMtaRtgBcaWNaNatatWScYYaWttatScYtSgcataDtWcacBtactaWgcYt
-cgtataagctataNSgBctagattaNgaKgatVKgtagttttcaaagtgcgcYattcaga
-tggaKcMBtacgtttaacctaaattaaatattcatRaggtcgcccattMttaaaaaaact
-ggSgtcccgtctaNtWattcaattVHDagRtggVSSaaHtattatWctatKatHtHattY
-BtaVaMRatgYagcHtaSataaStKaaacattaagggttggVYaaDgttWSttcattaRB
-cMttttaacatRDaataaMttRgataaagVDKatcatacaacgMtaatYctKcgggcBKN
-gtggttcttaagttYgcataVMaaVBgtVMSNagttatSttgtDtgtMgMDtNKtBgcta
-ttacagataMWtcSggtcHgggcgagtcRtcRattaaaatgaaYYattgtaaccttgata
-cgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaVtKScaYagtttctagNBtcMcDgK
-aDHtVtMaMacMgtagtaaWtaYtgHtttttgtctagYHtRaagacDRaatgctVMtttW
-aYaaNtttatatttStcgactaDatKaatatattHggttgtRtattaattaaaaRtaNac
-KattctVaatgattcttacWatgDgagggtggScatNtcMggaagggHtaaccttcWcat
-WaStagHtttgatHaRVaaSVNNtcaRacaNaKttgctgggcVattatccatVatataDt
-DcNgMBMgHSagggaaagKctgggtcacgaatcaataaVtDttaRRgtctStattNBaaa
-BHatcgttaaWMagatagacatatVgDBttYMacaatttKtttaataaaagcacgVgaaa
-ctDBtaaccgtagaNtgagaaaRttcKKagtYKttttaStataaHgtcNDcgttYccaaa
-aMcaWtgggttatcaaRaaggaataaVWcacatattaRYaaVagagVtcHggaBtaataN
-attagKtcVRtgactatcgHDaBgRBStVtSgNBccWDgaatgaggaaNctttNttttac
-aaggagaaDDaVtcgaataaataagttaattStBDccaaaBgVaDtctScgtgtttttgc
-tgtcacgtttWgacStMtttVaVgaBtacDWtttagttDctaSDVtttNaDDcHatatac
-YtKataaatagttgaacaagaatacaDDcacatttgtaaaggHattaaatgttacgtcag
-tNStttcVatttaBtHtVggttattaaHcgaWagaYtVaataaatcaBgaccctHcatKa
-DatRttHRMcgtcgggSMtaatNagtYtgaYtggMYttgtaaactacgKgStttaaaYat
-atDtaaSaVVcHgtagatgaggtcaHggMtaMWaWaHctgaatctaaBaWaDtcgggtcc
-ctaagtaVYDaNactataaNcctKcBcataaatttcaWSttttgacHtctRggagRaaga
-cagWVNtctcatHtDHaRagctStatattggcattcattttMaNaSaRaNDHaagNtMgt
-VWtgtMccaactKNaaaVaStatcgtStgtgtaBgBgtaatcNtccgaagtttaWgactN
-gtaaccaatgNatWttgWagtaaKgtctRgtctaataagttVDHgStgttcVttgtSWat
-cYaggMatgMRcBaStgtaaaaaMttaYagccggtgaRRatgatccaaaggtttctaaKg
-acaDagagatgctcMgaaaMcgRaacaaatataaaagcagtgtatDHgRaVtWBVtggac
-atStctKccttVttatgtKattttYcatctgttatgtcDKHYcctSHMttgSDRNgtaMN
-HaggatBcSBtHatDMBcttMacNaVMKtctgtttcgaHSgtMgcacagaStaBttcWca
-ttctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcgaDYccacKtatg
-atgtcaRttattYttctaMBggcaYctaNtBactgattStaDaHccYaDtgcaRDgSYtY
-tatBSaYaaataaagtctcgcgttcagaaKtttctVattagtWcacgaaVaaVtctcaVg
-tagttNaaacaatgtccttaactaaaStaKWagttaNttatacaaaKattBctgaagaag
-tYDNtagatataDtHcKcctaBaggcaatctHttctaaDNtgtgaaaagRaattataaBM
-aggtDgtMaWHacBStSMtcgaacYttRMatNacScgaaRtttctattcMaaBggtaKtt
-aRcgtBattcgatatYtVaccSacacgtaaagtctNatYttgcSSattttcKccttataa
-tcRtHNctttMcatBtacatgtYtctagcNttYacaatgtaBgcgttVtattaaWtaDRt
-KNaNDttDWaaaataatDgcgcKtaatatcgctMctatcatcgtaaaaYNRttSaNtWgg
-atRgtgtcttataVgaaaatcWDcttDRaatMKctcatatRttBtccaattBSacctgMt
-aDDRagtcagacBNtttattttagtDacaagcaHcacgRttVtatcatatacStaatMaW
-agttRccKtRctcgaagttgaatttNtttatHaHttagctatSBaBtcaagtDaaaRtga
-ttcatStagttcaRattacaVgtatWRttWggttttctaactttSaaaVHRatttYHMKV
-VcgttMtatBtaSaaMctgMtcaagaMtactcDatSaaaacNgatttNcaagttRgacga
-taVtaacYNataStRtgaattactgtaKtNagaaccDaatgNDaaHcataDSYattatgt
-ctgYWaaRaHtttWggcKatgcgtagDSVtMactataKMSttaHaaaacaHatVaDKtSa
-aaRtcaNWHtatttctWataagctttcccaacctNtaaacattcgagaBKVattaWtcVa
-KtWcggtaatcaatgttcaaatccDttctcaaSaWNDataaKatBcaYttRtcataMVtK
-ttggcaaNgtgttatMaccgttgMNagtgVtNBWggaacacaKaaKctagtctacttSaK
-YMacaWtWDttatagHBacttRttcctgttagtScVNaRtaacgScaStttatctttttS
-gtBgNtttStRatNDWtctgatcKtgHcattatctaaaaattNaaaWgWaDWttWRtHRN
-cHacBVgWttgtNggtWtWcttgSatRtaaYtYtNaDttYagactStacYaYtNHBatgg
-atacVtBatgccaHcgtagaaMatgataHagtKgHaWcgtaccKaNatagWtDttcgtag
-ggcSgtRatatNgaRtYataaataRtBtcttaSatcagatgaaSgtVtHtgtaaDtVact
-gattcgcatctctBaWWtaagBttVgacHattWWgcKataHtBtagScWtcaNtHStBKM
-HBRtRagcataaYtNtttatacttaMgacccattgagtDYggKccNaaRgataWaaaNWD
-MttMacttaatgStDYgtattaBatBttKcSaactagtaccgttggaKacRtDaataSBa
-atacaKtgagDtNcttattaagYcagacttNNttatcBtHtgRatgccacctaSaatcca
-RSgtWggtgaaMcgcaMaagSagaaDatHcttgaaDgNRttaDKacgcataagYaagtMR
-ttNaMMMgcggttcgtRaSgacaStaaVgStcaRBKcaMtctKtctatNaactaHtaact
-aaatNWaKtWaStRSKcatggtgBtgRBtagaatagataSBagMtDVataaDtaattgaY
-gaBaagWagaacaggaagtctgacgMgtgagaRVacMcBaaDatKatcNtKaRtcatDNB
-aaHatatacattaWRBtcaccattctctaaWttWacgtccgcgtMctcaaaccHYtNDat
-ttSaDMccaStRttWgttattaSVKtgttttgtcWatgtgStttgttttatcaagacMtt
-gtRDgcRtctctgtgggggcSaagcatVattMacattSgttaacctaaaaccgcagtgag
-NgtctataatBtHtacaaSccccMgagRVctYagcgaatttacMagVttaRDcctRgSSt
-tttcHtVaacatagBgaMRagatRcDBaMtaNtcatggHgaDYgaVgWaaaaMKattBta
-DYBaHRccagttatacVaDcacactcgtaSctaaatatRDaccagctttttaatgtagaM
-aRaaKaaataaaatacaRagaaYaNtatKcDttgHgcVtaYgDacagMBagtgttatgMc
-SgWDWYWtSaKaagcatKatatctcaRHacagttaKtgBKtDRggtcaYcattcgcYatt
-ttgtccaagtVgcattttttaVaagtaaaagtWccttgacYcaagtaatataYBaatata
-BtaaatacacttttRHagtttaDSHgNtNVcatKgaKtgagttgaaaHcgBattatHgRK
-tcaBaagttgtttgtVatYattaattBatYgaatgMgtttatagtKcVctagttaaYWtt
-WaRKWggYttgaRgagaaMKtaggtattaMVttataVcagHYacaaMaattRRtataWaa
-RacHcattaVaBtHgtatBaRtttaccaaggNgtaDMtatYtaYVtNtcBRKMgaatRaa
-agaatactRattttNcaaaDDaagtagtacaNtSHttaaataattggtaaKtttaaBaNg
-taagtcaYttacVaataataatDtgHSSgtSDNaattcRMBgHttctaagaYVcHcactK
-gaaNHcgWaWttaaBactcgYtDaacgactMtaYKacBgttcttgttataBacatScBca
-ttKaaattacttSSDaRgKtHHagRNRMtttBDtcaagcBcgcYattactcgtttacSaa
-NVagtacacgtggtSaWatBtgatttWttScaaDtttggtKtNKaMtMgcttaHKaRacc
-gatccctgtgggagRMttaaMaWccggtttBtgttaaVtagMWctNtctHgtBgcttatS
-MYccttgHaatatctgNgVttagcttagggaBBSStaYgYatYgtaaaaattHatctatg
-tWRNgtVcSgtgcgtcYBagtRHgacttaaagSHatatBaaDgcaKtcccDgcacMttat
-RaacaataaccWtNBaYatttYacYtagagattRtatagKcatattDgKtNNgtttWNag
-ggtacStataRtVDYaacgtaBtVKtagaagRttttttatataSaagaaKtaatatKtat
-tagBtHataatatcWNaacagtgWaccatatStcYcaaNRctcKacKttgtStaaKRaWD
-DaatBtttgtcagggBgtggSctaaWtttYVWttNtctaacatagVYatcagatctVaHM
-gWtcaagtataHtgacaagttSacgtNRataaatgttgNtaattagaattgctMaRttBt
-acBatNgacatttcaMcgtaaacctctagHctaaKNttBatatttaatattBaKtRagYt
-atattSgtgtccBaNSattgaaattgYggcaaataatatHcaaaatcMBaagYattttta
-YttYaStatttDtacRtgRattttttgDcRaggagcaccaattcRcttttataHcggatc
-atNSatgtagtHHcactgtWgtaggtNgactactHagagHattcaggggSaatgcaaaac
-SSKDtaggcDtatVagMtggactaBSatagMttaggatSYttaacBtagaNSVtaSaNcS
-ScaaatattVctcYaWYtBcttcgaYBagWtRgagHKagagMaatttMatgtDtaYNagD
-taBagcKcKcaMttKaaaaatVaatHDaataacgRatBNVKtMaccYaaccMgttgtact
-agcttMatKgKBtMagtcttMWgaatRcacaaaaSgcgVtSatggcaggcgKaYaatgct
-cattaaaggDVacStgttaMaaaaacNVtBtgcttaacgtDNaaRcgWaKtatactagca
-ctgKVttaatcttRcgDHHattcStatgatcWataagtattttacgtcaRgaaMcDattY
-HattYgatatcacNNWtDatgaaaactgaatHaggaNcttcctKggNgatBaaatttgca
-aaDtgctcaatgtYagacMgtVVtgDBaacVaatNaDtatctgaaggKcagSggVtacga
-tgNWtKWaggMacctagaatattcttYaatDatcgttgatggtcaacgttatatgcttaW
-VttccRgVcaDcgagMtacattaMtaVWcgttRcatRacaRcMcaNtaYWNYgMtatMgc
-cctaKctagHtttaaBVMaaWcSaccgMttBRgNcRWMtHMaccaatgataaggagVttY
-gaatcttagtgtcMtgcctVtaRtgcaccaDaagHactNYcNcttaaggcMBagaWtatt
-gtgctaccacgcWataRaHtDtacgaaVttagttVacctatatStDgtggtaMgaSattc
-atgMcaRctatgWgatKatYYaaataNYcSaDtttgtcYttttttaBScatRtctgtaWt
-taatagMaacatDttaaaNgaacttacYttagaaccctgNgagMNHaaKacccNatgKcc
-ttaKcatDStaaStNaaVBatagttcacRtYcRcKaagMgctKtBagSaagNcKRttaaa
-aKaaRttttttatHHNHaHRtcaRcMataKDDtNcKtKatctaaataaatRatYttMcca
-aaNaaWgctgattcaaaKgaatScaNaaaKaBaaaaRNtataVcYDattagctattaaat
-WtgBWHgggtatcatattatcVttcgHacgcgatMattDcaRggDYtYttNaaaatBKtt
-KccStYVDatatYcctSacVcattttatMtWRctaYagRgctcttttaacVtagaNaVRa
-ccgRaattaaVcaattgcgKRctMaKtttHgctttVMaNaRaNMKacHSagtWagtgNat
-KttatctataaHatgSaSattcagtDctWaataaYtcagtaYtctatHcgattSRttaaa
-NDgagatatacttVttatcataSSaBNaDataRtRRaattcaRataaRtattttNaRYta
-KttaccaaaaaHVaBtttWtttgatRagctaMattgcttactctgatKtgatgRBttaat
-aagYttcStKaNgcNatacgWatYaatctggVtaaattYccKagaVagggatttatttWa
-cgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHgtacaatattgcM
-DNNataatagaaaataatNtNgccgaaMaagtgNttacgVHaacSgStBBtRagtBgtaa
-WgacttcKgactaaatgaagVaacaBtggtacattcaaagtgattagKagNatatVaKBa
-caMMctccatcgcgggRctttKaaBatcacaScaNaaaaatVgHaattaatatcWcacac
-actcatgctcgaRggVgcatatcaDcatYgaggttDgWNagagaaagagaYttHKaatgt
-aVtYttSNaDtcgaatctattSKgtgtaggaMgtaccWcaMRtHttaaatgWtgtccgtK
-tacggacaNgaacgaSgcYagcKBttNacaagatacgaagaVcBgStMacMtgKaactat
-aSgWtaaaatDRataaaNaSaagHttHWYgaccWMtatataaaaagatgtaKtVtgtcBN
-MtRaSaRacVataaNaaaDtaatgtaaagaDgtataVDaacagatttWtDtcBgatggBc
-gagctcKWgtHcBgcMaatDNatcaYtctBgaHtccagHctttMtattgtBccaHMctat
-ctNaaatacgcgtacatacatctaDactactcKtacctataDccMattRgRggHtaaaaN
-YcVtatccgttSaagYcgMatttaVattttHagVatVtttKattaagttaNaacaccHSt
-tagDactSNgtgtttaNtVtatttatgaaacSaKtactctacgagttgaagtcaSBaDgt
-agatNaaactRKttcatcWtaBaggKtKcYttaDttatMaWcStgattKattgtatatDt
-tatDtKatgtaNtgtcgtcttttttaBtDBcaaaaSgDatgHtctacaattcgMtVYtat
-gcattaaaattcaVgatRtcagBtcaMaNctHgtatVatcHttcaDNKgtWcgagHttta
-ccattNgaactYacaKgaaagtggtttgtgatcgaKaHgaatYNtBgcaaVatWacNgga
-taccaDtaaaWttBMaBccagaHDaataaBaagYVacYaScctYVgagWagaYagtgatg
-tttWatSaaaMYDcactYtaStWgaaattacHgKDaYtttttgttcaaaaatttgYatat
-VcMatcactggRaaMVtStBtaaaagggatYaagtBtatcatgcDttDaaaaMatagtct
-aataNtcttWHaaatcaVttaRaKtcgatttataWRtaatatcDWcctaNMatgtttDaY
-aaWtMaagtcagaKtaMKacgccaaVatgWtSagtagctatttcactaaNcaaaNaaatt
-aggattatMWgtgacgtcttcattacaYttctRRtttgMatggNtatacaataataNgat
-NcMttaggBcDgRHgatctttagtNtacaaccgBatgtHaatgttttgatatccgttatc
-ataStaKRaKgttgNaagagKttgNYMaggaattcagaactcaRataDttaagcttacct
-tttgVttaWWgacYggStacYcgatgcSccaacHcaYNtgRaHtcaYaacHctYacatag
-atBgtgacDaNgatMacgKgBaWagacaSgttaKcatactatatcaHaatataattctgg
-tcNttaYggDRtDaSHgNttYaatWagagtagaacKtWtHtBatNtScttttacaattag
-taMaatttHgtctagMctaccagagttcaKcStaccKggaggtctgcNatctctDgYcca
-aVgttgaatgacVcatagtgtattttccttcatctacttSgaaStcagHtMaataWNDag
-tatttttataggcatNKataNaMtgctgtttVaacctVBDWattgHttatattaKtatSV
-SttgtaScgcMcccattgggtagaKMgaSaSttYgcaaMaatVaVaKgtatgYNattctt
-agWgtcBaaagSaaatRatttNctacaStggtYcaaggttBtgaDWBtRtgaaDccacaa
-aVSatatBcaaScWccgaKttttcgtMaVttgatgtMatacatgNttBaNaagtaggaRa
-BagaagtaRtaagttacWatgHtttaagSaatgataNWattgtaSggHDtttBataaNNB
-RaatKWBgtaDcBaMaKtctaYatVaKataaaattWYcgtaHcttagtgYtgcKDtccat
-MSaaagatYcSaHatcaDtaatgMMatgcaaatgtttagaDDNtatttgaaKcNtagKYc
-aBMattaaagttaaWDacgRaRtaKttaaattaVVKaMaBtaKctaaWcatctRMtgKcB
-aBaaagattHcgMcgaSNgactaccRatHtaSNtctYcaaBDtaggaagcMatttcaBcD
-aaatggWtcaHctaKtHcHMcRgattgaMtNVaDagttaggcttYctcatDacWDaaaaa
-KtaBgtBaatcaataaKgactgactcNcattMcacatNMattgtaaaNaaacttgctaRt
-ttacttaatKYgcttgaSStgtaDaNgtaKgBgMaKgccagtgtMgatHDtgacaWDttH
-KaDgMacttaKaagBtttgtcttaagMagtaHcttWcacaatSatgYtgacHgHcaHDgt
-agaDccVaKcaataNttccHYctctaSRtaYagtNgDagatWtRttSttNtRNagacata
-ttttatggactacYMagtMacYaagYgVgKgtNtaVcgtgaatcataatcgattYtaaat
-YtctgBaMgNWNKMgDttttaWtaBaaHatNHaDacctccNKtgaVcWattYtgccaVRa
-ttMacBtcccNagYttBYNgaBaaaStWacMgcttccatgHaacttYagMtNaaVSYgcg
-atatHcaatatttgtgBcatWMtaaaaDRttHaBaHttgaacaaataaWaMcaDctgBta
-tWttaacaaWacacWtDtatttatWaaHacaVagVgKaaaDttWgRBVagttVNttctgc
-ttgacatttSHHMKScSgSaMtDtaMcgtcaWaacactMcaHWRgaactWtcgcMNcact
-VDaatHcDSttWtagactatgaRNcttagataYgaggaagagcaSHcWtMaKStatgYat
-ttttVaattgtttWataaaDaDgataMcaMtatttctVKaKgcttcctDagtgatWatac
-aRtttaaaBSMctHaaatcagStatStgaaVttaattatttgctaagcgagaWaaWtccg
-caaSgaatVgtaStMcSNcgtWggMVWNatHctggRtttaacNagtttRtaMBgatatHt
-aatcMaaaYgatMtaccttaagYatcgaaattMataaHatYMcccaaaDaYaVaWgRaHa
-aaMcHSattcatWSatttcaMtgataKBYtactgaNttgaaDactgBatgYgttaagVga
-agDagaatttKNtgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaYtBMctVBWtttt
-aSagRHBtaHtcgtactHggagtaatttaaaVVattWDgtaaHaYgDtaacatDtacWtt
-ttttatgccacttaDtagtaaKgYNcttMNDaBcaVMcMctWgatactaRcaaWagaatg
-cWcRtattccagKgaNgtctcKtWgaNtSttagVaagaSYtcctWatatSgaDaKcactc
-gBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRDaRgatatacattagtgccSttctD
-gcgatNcatttcHgcKtagcYgttttgNKWRattgBtaaNcRaatcNaagcgaaVKttYt
-WttaBttttttNggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaaaattYactactB
-attWcgccgWaaMtaBYtgtaHagtcttVttaggaHVaaNaNaatcttgtgcattttatM
-DYKccataScaWgNttccttttMaRcVtWHgaaatgBaaRatgcgatataaaWYacYggt
-acttaaaaDaaattgatcWaatgtttRcatatcaggaBcttttcttVKatKccaccYtDa
-tMtcttacMtSattaatatagaatgSgagYgWNtttagtatgRggYKacaatattgggVt
-ttaSaYcaRtBcggtDaggYaaactNataggaggaDgaKcaaataagatMKaattaaNag
-tagttcWctataaDtttcgtcgtattaccStgYgatgKtgcccYatDctYtttttYttaa
-aagaactcaNVaaYaYtccagacBttKcaatKataatKVWcBataaatgttcctatYaac
-ttaSVtgataggVatgagttgatcttacgMMgtWtYtagcacaSctcHYtataattMtta
-taYaaccKgtgtaaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBtctgcaattaWgM
-cgYttMctWtaDNcDatggWaattggaVDagKattttgaaaRHattgMaaMgtaatcatt
-ctKgNaacacccNHataaaatgaaagagSatKtacVagttggtcgtgcBtgtgcatgagc
-aacataagKtcagtttgtDBBHWcgaDtatYttgattcttaaagcMMttaKgDaHtatVg
-WHccgatKttcaaNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaR
-gKgcWgattNaaattaataNcaRtagtRgaacagataDKgtatScattaDgatcatMtcg
-YcgtttaaaRctcagcRattaacatccStcBtgaccgtgWaaagaaatgaaWtattaVtH
-acctaccaaatgBgtaVVYaaaatccKgtcaactataDgNagtcaSgtKttacHtccMKK
-WattagtatNctattagtttWttRtgaKaBHStgRagattaKRtWaKttaaWaagtaVcc
-ctgcgMRWatgttNKgtcSggSHtaBttgtaYaatDtaVtaatgtHcatWaYcMttataV
-gaaaaagBgaagRattccggcttDgggcttcttaacttRgaStaMBaaMtctMBHBactt
-VgKggcttgcgBcBtgDtttcctattaaRcatStNgcKgctatcccacSctcHtaHWtgW
-aYatgVaRRYtgctaaaatggagacctMcttgttMagBaKctttYWBtaYKgcccYttaM
-gtHaaNYgtgtagagDttcBatgtStttMtBWtaaBctaggaaNgaRgcttttttgtaga
-cRttHSagaatDaYgcctMBtgtNSNaaBttgVtWtttKgacaatatVttVatagatttg
-cgtcgDtVgtSattaaaVHtaDaatYttatKSWtcattagtaaNatctcagcgtgcKcat
-DtaBccaaccctgaYcattaNaagNaKgagttttcattaHMaVKMDDtaSHScaDattgc
-aggcccMattatacYtMatWgatttcBcBtBctKacccaaWctatccctcaacaataaat
-aaMttgtaHHcgatKgaggBtRYattatacgtaYNBacagacaaatVtMcttttRtVcaa
-ttgtttgaWtaaSacaRccMcaaacttttaaacgtacVBtcWcSaYHgtattacgRtgtg
-taKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaagaVMNaacagatt
-aHRaaMWcVgMtctgcatgaagRDattactgcKHtcactYtccttatgHtKgMgKcDtac
-NtcaStgYccaaDagttDtttgYcaagcacWWttaMgccaStaaWtVactgaagtKtttc
-aWaatgMattatKcctctttttcatgtaaactttNcaaKgttttMaMcYtgWctMtttac
-tttagaKtMgttDYttctatagWcRttatYSagacttcaScaacaYtSaattcaaagtgc
-tSaagctattaaagggtaactcacgDKgttaMRgggattttMcgttattaVtccaNagaR
-gMaataaagaStcSaacgtaWttatatHgttHBcgtacggKBtSatDactRggaRgccBR
-ttctaaaatSactcKtttVaWRatatttWaHaKMatgtacatcagctaatggBgaBNSNa
-tatcYStagaatSNattaccgtcaataaggYMRtaDaatVgYaDaattataRgVaagtgc
-aNKtgttgacttatHccacHaacVcWcNMDtatcatttttaHacatKtatagtgccWtta
-attttBSDaKaHaDttYacDtBgtMNgggBaaaaattDaaVMaKgatcggKtgtctatct
-ctVatcDtaagaagtgtaMcWatDggaaaaaYtcDVtNttcNacgaYtcgatHctctaWg
-aaggtMttcKtcttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaBgtaRagcacggc
-aHHagcagaaaaacgggtataatcaaWtacYcWtcctaBgVVaBagHaaaaaatataRYa
-gaacgggVtttcHaMtNtMgcgaaatKtattaagtMttatcttWttttRaatatgttatg
-tatttRaagKtBgtgHtHDggaBDtWccattcKtttagtttagtBYcDaMBtgatcttga
-catKctBcaaaacaHtatggaNaVttcgttatttttttcaaDtDDaatcaaaYaaBHtta
-MKMVgctgWtacVtRaaactgYtcatggcVHtgattRttataBtcgaaRataDttaatca
-ttHtatatccNattcaaHtgKRtRtagtKaRWaataYaggatccacttcacaatgtgatM
-aggactNaaccaaMaaKtagaaMctacttDSaaaWSgctcagtWaataWaHtStMactta
-DtgagWaaaatatttatcaacaactRtDgYcYtatatgtataatWtagccaagcgtttat
-aatDgctgVaaagHaattagaatBWggttctBaNtactHtKBtcgaaaRttHBatDaaKc
-caSHgtgctWttcBaatcctYttgaHacgtatgagStatRtMaacKacacggaaSctagD
-agNttgaKKSgtttctacgtagSataHttDctggBcYtttaaatcgRgagagaDtgRSaV
-StggVtgacgtMtatgaaNtWtHgtDaDtgttNaSVagaattccgcttVatatacattat
-ataYtaggYaaaRDHttHYDtNgcatHggctattYtaMcWaaVtaNtatttHaagBtatc
-agatHtttgaaWWtttKaaaggBtattHagtaacactDggtattttScttaaaacaStca
-acHttMtatcagatSaHtaVtBaNYcttHcatgHatagaaggggaWgtgBtttagtVttg
-acatYtKtattaYSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgYtNHtgNgctttt
-ataWatttKWaaKtHattgRtBtMMccgtBtYttgaKaWBatcBgaaacaBgaagatYgK
-WaaacBgatgtDaaacttDcacgatSKtaVaRDWtVKgHtcRattactctattBacaaac
-taatgDtaatcatatKRattSggtcggRMaaHVtgttMcgatatcccgVctKMgBactVt
-WtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgStgtatNStaaccgttaaaaYactBg
-aaaaattacacVttKattVNgaMattNccctaVtaaStctgaaVatactgtctaaaKYND
-tataWtattaaNgtHtaWgaBMttttccaaaDcgctgagBacacttctDSctcMtBtNcc
-aacaaatSVtatWggagSattKatRBaaaNtNtttagacttaagtHttaatcgtWctHaM
-BaHtaaagKaaKttgatattttgKcgtcDtgtKtHagDtMtatgatcttgtcSgtWgcta
-aaaattDaaaNgNYtMttNHgtHBataatMgMttctDcgtNtNatggKatHtaaRtRtDS
-tttRVcaatKgaaRSRtBttatccataaMttagcaaWtagtVgaVBatcVtYtagttgta
-MactaaataDatagNttttactagcgcKctDatatDgaHtRatVWagaDtttcggSKata
-acaggaaKggMtttctaVttMaatgattcgaagcgattaNNtYactttKgaatWttNNgc
-tatatgttacKaMtaaDgtKgttBttHtDacaagaaRgDgttWtaatgVBcaaccatgcY
-ggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgcHttRctattVtattgttcKaaata
-gtacccttgcVtaaHttaagaKtaagSaYtgcacttDattYttaVgRcacaattDDttag
-attttcHagccaYaataKaatccVDKctNcctcaaBccaaBaYgKacWVtWttatgcSat
-cDHttattaacaagaacRSactBHttDaBBBcacgttactHaKgacaKtaWMcHtaVHtt
-aattcgttatatBaaagatgaactaaYgDNattNaHgHKtaatcctcttcHttagaatVc
-agaHtagBgtMataattaagtcSRcatSagMagaaaacgYacgagcacgBcggacaHKaa
-BatSatagtatcDttRHtcagtDtaStYtagaaagtYNHtgaacaatgcgataaNgtNVa
-gtacccctBcgaYWaactRtDtatttKatBccVKtHttNcttVtgaKMtgcttggcgaNa
-tctcKggtcttttataaacWaBttcgHtcaHtcgatcgcggccaHaagcVgKattBaaWt
-tKcttaVaagYaVacagaacgcScDcgatataagttttacaaKcaaaBcYcHKctRagcg
-aatgtScBagMttYHtaatHcKKtgggatgKSaaatactgWBHVcagHcttVBgYDtaVt
-cctcatRcVKcNaaYaBtattttatRtVtDaaScgtatacMatcaaactagtaKataaat
-StHtacaagagttgtYatctagaBaHSYtaaataaaStacaHagWSRSDtagtatggctg
-aKtaRctaaagBtactcttatgBcHcNtNRNtHataaccRttagatataaHtacScgtat
-tgttgtDcctaYRaattccaNatgtgctaaaactMcaWttgttgVMaSgtaVaSctMcag
-tcacNaWacgaatWtaRtaatSgatgaaWtaaWcgtttHtWcttgatKtgDtDMcagtca
-ttcacttgaaatactWgtattcHttcataactgctgtgtKatRagtaatttYgNcaatcB
-ctgtStaggtaMatacgtYaRNtgNaHtNccRtgcSHgRcaatttVcctattaBKtgYta
-MaactRaaaaBaattHHtatVNWYHaatcagtaMVtttctattWHtttacaaVccDctYt
-ttVtNtRRKtBgatHtBcaatHYaSgaagaagHagtttDaVaattVactactYcaDtKtt
-gVVVtaWtggctaSttgtaataDctWactcaRttWcMSYtWagaagttctKHcgKtDaYg
-gaDttgtgtataacaRKctaacttcYaDtccNaNttaYtaatagRttaSagaatBtVRta
-atcttatgcgtWtataaWgHataatttYYSttYcggKKtaHcttttagHDDBtggtttaa
-acatagaRagtVagactttacKaWDMacgYaacctgctKaNattggatggNgtKcYSttt
-tcctttDtYttBcatgattSHaaccVtccatctcccacDBtgaWBaMaaccgttttctta
-aMgScBNatBtagtcttccttatKBRcctggtVStatagcDgMgtacattacccattKKt
-aRcRatRctYVaSagttatatYtcgNDDggKaHggcccgcRtacgDtcYctgaaacHtat
-attaVtcaattaaatgaWaBggYtHYYaVagWacaNtDtaRattgRacRtacacatgHta
-gagtaatatttctgDDcttgNDagcctaaHtatYHtKtRaScgtattMttacaacHggtt
-ttatSgaHVVgaattaatagttattactgtRtaWgataMDaaaactgNYacYtagKtaRc
-aYDHatatVatggctKtWatHaNttaatttttgtaagcctggcgKataaNtttRMNggDt
-ataaaatVcMRataacagctMatBgMtaaVcgagattcaaaSgtgKacgtDHatWaatgt
-tcDtWatgYcWRttcatBSHtttgaatatBgaaWgggaaBcctSSVaagctSctagYatD
-ggtatatgtaatatgtatgHYcRtagagtHcgggcataDHattcaaattcRgcaaaataa
-gattcaaYVtaBtaagRagtttgSRtgRYKgWggtttaaHgcHStgtggtctaHaccacc
-SaaaattaHatgttVtataccagaatDKVtctagtttcaatgtNctaccgDcacgaatta
-cactatgaaggccKVatccaSWaaKHtttSggatgagMagttgcaatatKYtacBttacc
-atHRttaacttacaDKKtaKaDcHHcaYatatgMagaRaNNttcggagYRtacMtHgact
-tagacBaagggBatcttgaRDactgatacatatcSBggtaaaVWgMaatttaYtaWacHa
-ttDMtttaaaRRScatcttctaatacagtBVgtgtttBagtatgBNcaagHaaaSaSYKc
-acMtKatggcacgcctSRaagcataattaYacctMaaKtcggaBaVaaWaDMttgcctta
-aacttDaaHacNVtgagaataccactctMttaatcttHcctttaggaKgaggWtaNataY
-gtaggtgaagtcWDcWaBatattRtVgtRgVtataacDDNttatcYaaaagcaVgtYgga
-DattccgtccDcSttaaWtttcaaaatggataSatctRYcaaBctMMtcttaacMaSgDa
-tgagatcaYgctcacHccMgaacatcDNgtNRcgBaaatagaYgatgcttRaattStcct
-tgagcctaVaagggatatcagtaNMttaaHcMaatccScBtYaYttatgaMNagtgHaat
-HacaHaBaaDtaRNDNcBtagBgacatStagacttgtaatMtYaNaKSaccBtttHcDaH
-NBttBaacSaggagaacgWcMgtRcaagattSctgtaBtcaatMtaHgcaaccataVgta
-agDRcDcggaaccaBtacVMgSttgtcataaaaacaMataHatgttaacaaMgtacgtMV
-catagYtKgtgtcctaBcYKattcaggBaaHagStcNcattatRRaSYtYDRaHYttttg
-gaRggggttatKcVtHgctggaNttaagagBaacattggYaaDcSacggYaRttacaaca
-ctcDcacBDtYataaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHcta
-acBgattttagHaScDctHttaaaatVaHttggttatttDtatHtcaHcBagSttttDct
-ttWtctaaataaWtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKaaDaVatatYaRa
-HDtataKaNtagtacataggSaatMtctMtccctWgaYtaggataMttcgtacgccYgBS
-gttaaHgctRgRgtDVSRattttttaaKtRMtatSgRaatKacMaYgggtagBgNHcgYR
-agHcatatgtgaacMtacSDRMHaaacHaagtWSMcaattcagtDctBattgttcatttM
-BaDVHVDBtaatKactNacgcBYtttgatctatVVtatcKaKSgtaWcgtcgNYatSaRt
-caggaRtctattagattKHttYaaBtcacatataattMgtatcataKKatDVtWtaHtHH
-VaggaaHagWaHtattgtDaHRgatgtaaaWaaSStMatttgNtgtcagDWgagaBagtc
-attaataggagttcagcHttgWagaWcRttaKttaDgaDWtYacMWgRaatatccMtaaa
-ttRaatacaKYcgcatgtatgtNaccataSttSatttttcgatcttcaaKcMDatgaatt
-caMWctKNcHtctacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaacYataacgcDgt
-aacMtSaaKcKttttDVgttgtaaNcaattctcaataaatcSVcKaacattgggacatga
-aaacggaggagtacDYgatMYttaaaBBctccYgcgagccHattttaWtataYcaKaaDY
-aaaStMctSattaatataNaWcacaataVtcatacaHcgMgaatYgaataatRcWcgttt
-cNDYcacaaacacaNttttaatctaKtRttHDSttccWatatagtKtgtcgaccaBgtVa
-cNaYBHgtttSSagcNtctacctttaacgacaDcWVacSHcaNacatttgBYaaagatWa
-gaacYMatcKgBYcBggtaWatataKcNgaaaattHYtSaYDVHSactgttNRgaaaMBt
-atataaaaacVtctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtcgaaacatggagY
-KtaaaacagttNtttatcatgctagYcctctNgttctgctaYttBataaRtattgatgaa
-actagttBgagtcttccatBagatctBaaagSacagtaaStaaatatataataatcttaa
-ctatVtaaBattHcHgcttSSaaDRaKtataagggKaacRagBaggtaMYttggtacMat
-MttttYttaacttaBaYaaaatKgtactactKDctcttgaDtMgattgVgcRaaaKatta
-atataagWgttcaWgtcaKtatcgacatDaaSatHtttcagcNtatSggtgtaRtgattt
-StBaNaHgcagttaggggatWtttgattttatcgaBtctaggcgtgtgtWttttaaSaWK
-ctWggtgataaaattacBtMRtatccattaaSWttaSMcYtHtaacttaaBaDattctat
-KatctttcatDtcgNcgacttgtaaaattDcaVatRacatgaaagtcctgtctcatacat
-atcSWgNDttgaaVKatNacDggagWaaatgaaVNtttBataaagVttVataataYcNMV
-aNaKaatRMcagNacVRactcWgctttNatHaRaBRtaaatRtaKtNgYWattaatctta
-RttgttcttaaWaaagttcNVtagMaBatcVcgccDaaBMgKttgaVaaccgYtRaactt
-tYtcatgattgtWSaaBatagtagSataDgatgNtaWatcaMttaHattagVtggagaNH
-taatatctNaagaDBatcttttaRaaNtBYagtaacVttYBtaagcaaaMatcNgKagga
-cagagtgaRatWaDaaSaDaaattVgcWttatBNctgSagtctgcSttacSRtgatHDgg
-gcBagccDtatYaaagaataDgatDaBttagctatcHtcWtagggagtDtSaaacagtag
-cttVatgttggcStataacttVtaatWKtatDatcttcDaagactgtgDNBaccaattaa
-caaagaaHWtatttaacattWaatgttcMttaNNcYaRccHtacRagatccKaaYactcV
-RDtcHVtgaaNaSatctRSaWtagagtcgcaataDcagBaagtctSNagaaaKgttataS
-taatagStaatSatataWttctcgtaDgtYRcgtHttaKtcDttRaatNacYgtagVaat
-tNttttatDgKcttttSaaattYcgYBaaggttctagYcBataacVcagggaWtaKtaca
-tgcYcctatccDatatagtcRaaaSMgtggaatcaaMaatWcgctagggtcattaVtcta
-atgHcaSHtcacttBaagaMDtactYgtttgWgacccStDtagaDaBtgctctttKaaaa
-tMttNStggtttatWttYttatKMKgtctaKcgaBaaaattcccgacYtBcaKaKttRcc
-aaBaWgMaMatgtWtcRDWttcggacNctataaacKaaatHatggDatSaaKtgcgRaaa
-cgtgttcatNtgHtcaataaacaaWMKatattcWaKcNaccWtggttcctBaMttgRtgg
-tWtaaVggDgttaDaScgWccWHatacaagtaHtaacttWaNatgtgttaacKaVtcata
-DMattgtaKccttttttStaaDDtHYattNtcgatataBattctWRatMVtStaSaWttN
-RacgatagtRcgcRtcctttacagBKaaVcYtRaKatVtaWttaVggBBatcaaWatgtg
-gagattDgWtttcaataDtactRaatBattWVacttWVNtVagHaHtatttaVagtRMMt
-aBattatataaNaagatHBtgtatVtaaacatttagtccaKDcacgWaaHagttVKBgcg
-RaSYtttVcgaacaBatttaatctaSYtccNtcatctatttatBaHcattcaBgDMYtac
-tgScccttRctaagtaaNtaaaaattatggtVataaagVStcaatcacgcDaatgtaaca
-tDBagtcgaaRDaSactgcagaHgttYatgaVgtNccttcaKHgcgataDcgYtgtgBat
-cacScgctBcVttttcYaaNtttttatcBaatgataYgtgttgtatgaVcBagtatagtN
-aRaaatKVtcRtcWatctaattgtVgataaMataWagaDttaatRcgctaKHgaRagtDc
-tScatNgHgtKgtDtHBVgYcagatgttagcgaataaNBactBaaRaWcRcMctctBtWK
-aggcaataatSYtccagtRtaSVtRgatctaBgDNDtBgtttgtaNtWtaatatDtataa
-cgccDttcaMaMatgRtgaaaMHatgBaatgcccDagNgttRDcWtaaaKtMSaBgctgc
-aatgtSVattRWcBtDaaMKRcccWtVttaaatatttctgtcatNBgaaaatHtttWtYt
-ttcaacaaagaaNYBaatatctgatNtgaacaaMaaYcNgtgatttWtNaatWcYMScMc
-taaStttNgHtMacgtMDtgagcattcacWtttKttBtKaKcHaBtttaBacgaaNYaaa
-atBaatNHgaaatMtagatDcaagMtaattctKtgNtScaatagcaHDagtagagSRcag
-caagaccYHtaNtBatKtStcRagtgttMaYgtgggtNatSaatStcYtaBaSBtaggtc
-tMtatcatgaattactcYtNagaaaDtggaaatKBattaaatcWgKtStKtcaWMggaat
-tYtggccgaWcacagaNWaNgaacaYaHgaVtMctVHttaKDcctNccBKMDagtatgcH
-tttaaaDaggtgHtattcatatttaagcBaaaRcSgttaaatgWacRatacaaatgBatY
-atatRBcacaVataRaKWMcDWtSaatatHattcVgMKYtgtaVBtgagattRgaatgaD
-gtcaStacgctaggRggtSagKcWYctacaagtttBtgaBttacgaStHgVaStgtaRta
-caDccNDattSRgttatMtNttttWHacDtttVtgacgYattccWctaagtgaaaMMatg
-NtctaataRctgaacatttVcNtgtttgaggcaaagtatgVgtaVtgRDcttBDtataaM
-BatatNgataataHaaaNacaStgaNaHgYtgacagtcYDggagattNcaDtKgtagMaa
-cSHRtcagNagatKcatataVatactgRVatgBtatcgttattHtHcKaDtagRagtgHt
-aDcVtatacattacggcaKttattgacatDaatgtctcattVcaRcttttgDtNHSggct
-taYDcHaatcDYacccWaMttgRtNggYtttttggDgctacVDtBMgBaDgtMaaBgctB
-VttVagaHBaaaaatgNactaattattNagaagNVaBgVtRgggatacgctgMtgaccat
-MaaDYDaagctggtcaatggtatBtNtccWtWKcaNcBttactgtgBYDaMtMtcWaatc
-tWYHatccgWtataaaNNacNgctYagtaaaRtaaYggcagaMaagggttHaatatcacc
-VtagtggcgtMtagtcaYaaRttWgBtctgaaBtKattaatYtacaatcKcacNcMDtgt
-actatcDcgRtaaYagattgccMtgtYKaRaWHgtaccttagcRaWaagDataccagcat
-cYtcaaSgVacatttaSttSVDSctactgaNctatVattttacgaggWgtaaaKtcNgat
-gttgcaaNVttagRtttttRttYYaYcaaagcVDMaaRaRtccVcSattttcaattagWa
-ttMMctataWatggtaagagRaaattYKKtgatagcMYgcVcgggStattacgBBctNtR
-gacaacYHctctNtataattBttStaRaaaatctgtWatcRacaaMtattYttKtccaat
-cSttatgtaWttcgcaaWgtWNcBccRgtBagNgYtDctatccMaagtgcYMtYctYttg
-tcVaaHtatgcBaaBcgaataattcttcDaacaaacBtagWYaagcaVacYcKYttgSaK
-VcttccgcctcattctcaatgVgaaacatWWctgcagtttctttttMagWttatRggcat
-tattVaagaBBttatctattatMcNtaacagttgaaaBaRtaRRtNtataYNtttNtcct
-aVBtatNtNgBtaHHYDttKctaDctcaNcatgDaYatgYagaDcaHgactHgWWaagWt
-SttctagKaaggYtcataYgBtccRaggggaaaHagaacaDatgaaaatcaKtattgWac
-gtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatctggaMMRaaaataatctaaacgat
-atgDaggaVKcttttaatgacBttNYttagtatDagYttWctttNgtHtcVtattHtcHa
-cattatHgNStgtSaNaactVMcaatcccBHNatcttDtcgaKccKttatttctVRaagt
-taMtaYtcttcatMYRctttRtaMgSaaaactgWacHagtacccatttcgcatgagtaaa
-gtHcaKgVBtaattatBtttWatgMctccattgactattcttgtcatSttaaHaVtKtDc
-atcatatccaacKatattatNggNaRatcMSDHRtcctYRaatccacYaatBattcttBV
-ctatatttRNtgaNtcaaaRgtaBcttaaDRcgctacWcttgatatctHttttgtNtYat
-atacgaVBgYHgattgggtcgacacDtttKVcaattWRcaagBtgctDKDaYtttcKgNg
-ggtcacVagatMgtMVgVgatttcagtcgtgKgtKYgtYSaMtgataatNggattKNgaS
-ggactaaBagataacactcataVgttataaSacaatcRRaagtaDaagDYtcactgtgaV
-ttWtBaMttttgaHtKaYtattccagccaaBaggataaRtBatNcatgtatatttcttac
-aaYVNatagaaagaSaaaagaaatSaBgtcgattacattgWccttHNattataacgVRDt
-YcWgaaYaVgMttcttgtDtKaYVttctgggSNtaYHWaaHactaaSSagttgSaaactY
-aMttaMaHVRtcgattaccHtcgcgatgNcaYtatattacgcHaaaMNMtaYDgacaggR
-gaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBtatccatgaScHtYtgactcattga
-YatRtacttYtctttgBgtattaaDtcaHgcNcaVatagtttggggRaaaccWcNNttRB
-gaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgagtaatcgttttaatcgaaaagttDc
-aatgtggtBaBcNtgNatBtggactttagYttBcgttRttatSgacNaDttatRKacact
-gcSKaVaaaRgHaattaaaRctgatKaWcctWggWWagccgaactaYccttgtgaBHggc
-YttttBccttaggaKtaaaBacVDcBYYgaWagaKtaHaaactaNttatagtcttttacg
-accctttKattWcgHgcaDccctHttatVVaagKaatatgggMaNHagattgNStatBat
-cgaaYgcVcagaatcctcYtBKDatatcNKgacaatKDatgaaacgaaatYYcgNBDtat
-aatMcRWtaagtataHgMaVggcaaDtggttcVattattaaaatSVaMaNcDBttataYg
-ttttStacattgagagtccaNtgaatttttKtStatatttRaatttcgBDccctaaSWat
-ttaaMBStcatacctgctctatctatKatatgaacaactctWBaNagtcgYaaaaRtctM
-tDgtaBaacaNtacagtcgataNgaVccgtttattatgatctagtDSgaHNcctKtctta
-tNtgatYKaaStctWDVcaaccgaVttScaagaaaaVcccggagWatcVaNtVaRcNtca
-gatcMMatactaaaWaagatYHRWcaSagcgMtttatSBtBtBgacRaVgtgattaagtB
-gtatcgtNggggDaWgagctgatctatttHaactttcgcttttccatttNaaYgtatttt
-actttacttRataBttgatagggacattattaaSaaaYtgatggaDaMttacttattttt
-ttaaWttttaataaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgcatccaMtggWgg
-HggagSttacaYHatYtgtaatcatttgVtataaDVttcaYttctHtHtagttWHNYYtV
-RVccatacaattaaaYatcgcatBagcaatDaWacVaBWattagaaBataatgtKaaaNK
-cagaactNaagaNatgKtBSctgattgWcNaaSataggtataaacVaatDttcRaRtVtV
-tgtataagMtSccaSScagttgatYattcagcMaaWctaagtYcSattNccgtcgtaBta
-attgttgacaaaDttttattaatacSKtcgcatNttatWatacgRtgcataactYtcacH
-gVgHttYaataaWacgSVKatactagDggcattKctggataagtVgKYtatgttagcgta
-RtttaaagacHgacacattcHKaMKtcgKtcacggtgatcaaBtMttcttattcttDaKK
-VgWagtaacatgKatVgacattagWtaRtaccRaaVHtttttRtgBccagtcgctagtRt
-aBcMVWMtaBtaggttaYcttagaSgYgttttcaaNNgtttVaagctgStttactaacWa
-ttcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVcagKatgaMttWDRatgtaatctag
-acWaccgcaNgtctgtgagtMttgaaatNtttattaRKcgtaWatcaWccaKtttNacta
-atNcgVaaBcgRgDttcDcatttgagWNattttNaYtttatgcHtttBBacgttgRgtca
-taNtatatcaWVcatgaacatRgtNaWaatcaggttaaSctttcaacatHttVKaHtNtM
-tcttcHattYatcgatgtacSaaataVtcttYStaagattDagtKccgaccHBYatMtcg
-gBacatVtaaagMcttBgtSagKgNttttcNtSaaMaStHgtattttKaRttaMtDtcKt
-cgagDKgaaaacttaaaWNaattgaWWaaggaaacKtttVggMBcatattDacctaMgaa
-KgcgcaaMRtaatcgataaatRDttataNtVgtaVDggttaNgatBgtggcaaYWtagct
-cWgtSaacgtattKcgcBtttDacaaaaaStKMtatNccagKatgtVtHtWaSBgDttgW
-gaattWagttttaagcctNcttaBtYttaRactaattggagagggtctagtatgggttta
-cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
-tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
-NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
-cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
-gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
-HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
-tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
-tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
-acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
-tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
-gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
-accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
-RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
-tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
-cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
-ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
-actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
-YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
-KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
-aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
-aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
-gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
-tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
-tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
-ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
-ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
-BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
-aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
-tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
-cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
-aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
-tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
-aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
-gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
-ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
-taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
-ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
-gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
-gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
-tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
-tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
-taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
-cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
-aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
-cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
-ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
-attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
-ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
-attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
-tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
-aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
-cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
-gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
-attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
-BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
-DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
-tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
-tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
-tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
-taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
-aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
-DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
-VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
-agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
-gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
-tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
-catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
-tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
-aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
-aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
-acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
-tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
-aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
-acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
-RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
-RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
-tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
-gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
-YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
-ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
-ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
-gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
-KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
-aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
-gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
-taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
-VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
-NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
-MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
-cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
-ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
-tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
-aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
-actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
-tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
-gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
-BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
-aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
-aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
-YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
-aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
-cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
-tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
-tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
-MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
-taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
-tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
-RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
-agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
-NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
-gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
-aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
-ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
-cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
-tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
-RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
-tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
-gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
-tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
-ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
-tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
-ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
-BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
-gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
-acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
-gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
-taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
-acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
-tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
-catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
-tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
-atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
-ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
-ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
-cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
-SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
-VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
-BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
-NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
-tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
-ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
-cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
-VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
-atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
-aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
-tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
-RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
-gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
-tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
-attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
-atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
-cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
-NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
-ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
-cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
-aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
-agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
-tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
-ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
-ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
-tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
-taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
-tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
-YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
-ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
-tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
-ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
-attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
-atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
-YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
-gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
-MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
-tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
-ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
-aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
-BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
-tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
-StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
-cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
-atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
-atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
-ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
-gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
-tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
-BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
-agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
-HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
-tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
-aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
-catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
-aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
-tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
-cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
-DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
-gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
-tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
-atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
-KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
-tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
-tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
-taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
-NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
-HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
-ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
-tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
-cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
-ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
-HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
-gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
-BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
-gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
-KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
-cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
-tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
-taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
-gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
-aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
-acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
-RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
-attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
-KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
-KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
-gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
-aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
-aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
-ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
-tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
-aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
-tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
-MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
-cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
-caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
-ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
-acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
-tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
-gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
-atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
-aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
-NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
-taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
-aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
-ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
-DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
-tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
-aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
-ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
-ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
-RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
-aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
-aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
-aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
-tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
-atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
-BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
-gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
-cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
-RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
-taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
-aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
-gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
-gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
-aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
-gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
-ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
-MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
-SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
-aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
-VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
-HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
-agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
-gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
-agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
-tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
-gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
-VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
-tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
-MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
-actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
-WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
-tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
-KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
-BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
-attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
-VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
-aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
-tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
-tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
-tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
-VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
-tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
-ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
-tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
-WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
-tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
-tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
-MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
-tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
-atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
-aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
-aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
-aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
-YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
-WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
-ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
-aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
-ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
-gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
-NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
-atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
-tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
-aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
-gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
-gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
-tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
-aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
-ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
-tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
-catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
-cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
-aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
-NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
-ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
-RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
-SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
-RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
-agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
-gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
-MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
-aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
-cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
-ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
-accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
-tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
-acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
-SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
-tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
-gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
-attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
-DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
-aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
-tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
-ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
-ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
-tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
-tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
-attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
-aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
-cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
-aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
-VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
-catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
-taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
-cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
-DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
-tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
-acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
-tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
-YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
-cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
-actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
-KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
-WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
-ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
-aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
-aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
-agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
-NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
-taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
-RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
-aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
-tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
-aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
-tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
-aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
-tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
-DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
-YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
-tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
-ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
-cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
-atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
-cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
-aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
-acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
-tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
-ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
-gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
-ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
-aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
-cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
-MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
-atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
-taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
-taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
-ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
-cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
-BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
-tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
-gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
-gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
-ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
-aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
-taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
-atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
-atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
-aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
-cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
-tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
-aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
-acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
-gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
-gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
-gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
-MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
-cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
-agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
-taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
-ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
-aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
-VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
-ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
-tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
-tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
-gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
-tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
-DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
-acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
-aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
-gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
-agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
-aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
-gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
-ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
-gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
-SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
-tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
-aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
-MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
-aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
-ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
-aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
-YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
-aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
-aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
-ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
-atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
-cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
-attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
-BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
-aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
-agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
-BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
-agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
-KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
-attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
-BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
-StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
-atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
-HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
-gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
-gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
-caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
-gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
-aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
-aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
-HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
-gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
-ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
-taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
-atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
-gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
-YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
-aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
-tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
-tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
-HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
-gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
-SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
-HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
-tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
-tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
-caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
-atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
-ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
-aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
-acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
-aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
-ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
-tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
-actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
-cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
-ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
-tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
-tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
-YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
-ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
-aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
-DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
-tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
-ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
-atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
-gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
-MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
-BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
-tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
-MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
-SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
-cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
-ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
-ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
-cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
-attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
-tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
-MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
-tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
-aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
-KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
-cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
-YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
-aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
-tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
-cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
-ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
-atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
-agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
-gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
-ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
-ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
-aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
-RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
-atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
-cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
-SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
-caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
-YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
-cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
-RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
-aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
-acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
-VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
-tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
-ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
-gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
-tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
-cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
-cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
-WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
-tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
-tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
-HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
-caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
-tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
-agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
-gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
-HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
-MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
-VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
-ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
-aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
-WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
-tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
-tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
-gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
-ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
-tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
-cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
-cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
-ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
-taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
-HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
-aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
-ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
-tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
-tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
-tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
-aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
-tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
-cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
-VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
-HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
-gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
-aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
-tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
-aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
-RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
-tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
-aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
-atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
-gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
-gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
-tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
-ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
-ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
-tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
-atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
-ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
-acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
-WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
-gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
-aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
-ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
-tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
-gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
-aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
-caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
-cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
-tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
-gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
-tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
-cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
-attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
-cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
-gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
-atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
-gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
-atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
-gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
-aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
-atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
-gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
-atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
-tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
-tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
-taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
-tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
-tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
-gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
-atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
-taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
-NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
-VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
-gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
-tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
-aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
-tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
-WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
-aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
-aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
-taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
-attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
-aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
-HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
-HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
-taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
-gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
-RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
-gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
-ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
-gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
-ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
-VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
-gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
-tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
-NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
-DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
-BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
-atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
-ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
-gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
-ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
-WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
-tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
-ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
-tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
-atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
-aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
-RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
-atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
-acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
-tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
-ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
-DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
-taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
-gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
-KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
-accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
-HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
-cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
-atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
-ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
-ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
-tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
-HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
-ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
-ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
-gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
-gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
-tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
-tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
-tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
-gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
-aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
-gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
-tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
-aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
-taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
-aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
-tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
-ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
-caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
-tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
-aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
-KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
-MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
-ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
-DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
-tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
-tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
-accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
-MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
-acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
-aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
-taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
-HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
-ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
-tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
-agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
-actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
-atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
-DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
-cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
-attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
-VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
-VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
-ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
-tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
-agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
-tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
-tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
-ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
-RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
-atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
-tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
-tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
-acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
-VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
-RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
-caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
-BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
-ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
-aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
-atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
-tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
-gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
-KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
-aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
-atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
-agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
-caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
-cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
-tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
-taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
-SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
-ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
-tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
-WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
-cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
-VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
-gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
-aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
-taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
-gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
-ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
-WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
-tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
-gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
-tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
-tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
-DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
-tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
-KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
-ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
-cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
-tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
-tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
-ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
-ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
-ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
-ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
-caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
-gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
-tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
-ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
-YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
-YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
-HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
-VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
-BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
-tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
-cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
-aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
-aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
-agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
-ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
-WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
-tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
-BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
-aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
-aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
-ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
-SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
-gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
-catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
-atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
-aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
-DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
-tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
-aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
-tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
-tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
-tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
-atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
-aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
-ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
-HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
-aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
-aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
-atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
-ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
-StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
-taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
-ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
-acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
-HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
-tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
-WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
-gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
-catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
-aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
-gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
-gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
-DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
-KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
-aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
-NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
-tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
-actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
-ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
-aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
-tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
-ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
-MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
-ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
-BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
-aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
-NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
-tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
-tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
-ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
-VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
-NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
-YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
-tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
-gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
-tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
-MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
-gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
-KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
-tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
-NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
-gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
-tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
-BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
-gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
-ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
-attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
-WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
-aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
-RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
-RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
-ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
-atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
-cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
-cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
-DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
-agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
-ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
-SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
-ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
-ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
-gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
-atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
-tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
-gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
-aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
-acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
-VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
-DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
-ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
-HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
-MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
-HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
-acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
-ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
-BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
-VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
-cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
-ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
-aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
-tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
-aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
-KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
-gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
-cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
-WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
-tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
-attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
-tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
-gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
-cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
-tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
-tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
-StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
-YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
-acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
-atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
-MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
-aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
-tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
-aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
-ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
-gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
-YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
-tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
-RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
-atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
-aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
-tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
-NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
-KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
-aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
-aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
-aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
-HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
-tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
-HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
-atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
-tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
-WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
-ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
-aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
-taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
-tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
-SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
-ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
-aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
-acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
-acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
-agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
-atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
-aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
-tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
-catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
-gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
-gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
-VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
-aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
-BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
-atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
-gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
-tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
-tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
-acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
-tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
-tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
-ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
-cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
-acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
-VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
-gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
-WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
-YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
-VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
-cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
-gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
-StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
-aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
-gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
-caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
-ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
-BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
-atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
-YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
-tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
-ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
-aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
-MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
-aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
-tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
-tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
-gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
-tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
-tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
-aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
-aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
-cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
-aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
-aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
-cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
-tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
-ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
-KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
-tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
-atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
-BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
-acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
-cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
-atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
-RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
-aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
-YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
-atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
-attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
-aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
-VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
-tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
-VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
-actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
-tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
-actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
-tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
-aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
-ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
-KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
-attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
-tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
-ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
-gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
-aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
-cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
-aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
-attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
-tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
-gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
-ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
-taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
-acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
-ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
-RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
-aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
-ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
-tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
-tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
-cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
-KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
-tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
-gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
-ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
-aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
-attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
-ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
-aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
-aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
-aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
-gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
-tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
-aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
-atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
-ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
-gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
-gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
-RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
-caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
-aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
-tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
-tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
-atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
-agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
-cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
-BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
-tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
-tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
-BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
-MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
-atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
-agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
-ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
-cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
-atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
-gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
-DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
-gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
-YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
-tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
-acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
-RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
-aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
-gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
-ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
-agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
-agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
-aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
-cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
-catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
-ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
-aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
-HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
-ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
-cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
-KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
-aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
-RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
-cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
-HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
-YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
-aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
-MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
-taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
-tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
-cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
-gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
-cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
-catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
-NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
-tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
-taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
-ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
-aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
-gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
-acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
-ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
-taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
-BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
-NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
-ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
-YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
-NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
-ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
-taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
-cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
-aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
-taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
-atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
-attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
-agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
-tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
-tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
-ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
-cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
-taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
-taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
-tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
-aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
-gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
-agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
-MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
-tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
-cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
-aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
-gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
-SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
-KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
-tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
-SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
-YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
-caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
-cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
-tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
-gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
-caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
-ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
-StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
-tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
-aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
-RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
-gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
-aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
-cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
-tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
-gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
-aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
-cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
-aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
-gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
-gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
-tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
-aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
-WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
-aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
-gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
-WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
-cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
-agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
-gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
-WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
-atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
-cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
-acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
-ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
-tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
-gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
-taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
-gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
-gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
-atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
-tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
-DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
-NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
-cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
-ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
-aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
-gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
-NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
-StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
-aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
-tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
-atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
-aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
-tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
-ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
-gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
-cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
-HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
-caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
-catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
-cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
-tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
-MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
-ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
-gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
-DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
-ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
-tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
-attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
-tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
-cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
-agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
-NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
-gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
-attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
-tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
-ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
-WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
-HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
-agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
-aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
-gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
-ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
-ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
-tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
-gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
-tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
-aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
-tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
-ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
-agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
-tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
-agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
-gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
-tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
-tccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtH
-cttcctBatcStVaactaatctacatgtacataacDgcgaVttataagcaaRWataattc
-ggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNa
-ccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttN
-taagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctac
-tatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatag
-tggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMt
-cagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacata
-aagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcg
-ctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattac
-tSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMat
-aYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatatta
-gWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaattt
-aVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaa
-tacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaD
-agWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaS
-aatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVa
-gatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBa
-aSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaaccttRtatNactM
-tcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWY
-BggataatBactgaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggc
-ttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDtt
-ttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactat
-tNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttca
-tcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatca
-aaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatca
-BgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacR
-SaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacg
-attgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctc
-gaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacc
-taaagtcactttcWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRgg
-cgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaac
-ttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgt
-acatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatc
-aagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMtta
-attYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtt
-tgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSS
-aagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgct
-atcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtag
-NDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataacc
-NaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaR
-tttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagta
-gatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNg
-WattatatctSttaScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaa
-gtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatag
-tBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattg
-ggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaN
-HatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVt
-agtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNaca
-gMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcat
-tggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtg
-SaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaat
-McaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggY
-KRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatata
-cataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaW
-tRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRta
-ttaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBatt
-aatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaa
-atatataYtacBcattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaa
-taagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRM
-gatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggM
-tcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBV
-aaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaR
-acgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatg
-VcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaagg
-aatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtattttt
-atYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaN
-tcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaH
-taaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgac
-KaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNta
-tgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaS
-taaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagtttgcctatRttt
-NtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcSca
-ataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaD
-MtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccB
-ccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagat
-aaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcg
-tSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagat
-caHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRa
-tgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatN
-NgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYag
-tRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNt
-gattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMa
-tataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaM
-tNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWt
-ttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgca
-tttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggca
-tYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcattMtatccgattag
-gtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNM
-atcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVacta
-gaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaagga
-tgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttg
-atWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYV
-tttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNg
-cgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcact
-ttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggt
-aVSaagaattattcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagt
-cttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaH
-ttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaN
-cgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaat
-RMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVat
-SagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDa
-taKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDc
-MaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcc
-tgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtV
-tNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttH
-ctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttB
-SVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVtt
-atNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYta
-aatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWa
-ttKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVta
-NtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBta
-gVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagY
-tcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtc
-aKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSa
-atctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYt
-catctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcac
-MatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctat
-ctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtccatttcagctactc
-cacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctga
-accataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNta
-ataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgt
-tatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSt
-tBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaa
-aDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagct
-tcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgatttta
-tctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHa
-taacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctct
-WttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaa
-aYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtN
-tgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcaga
-tVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaa
-ataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRgg
-YMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaactt
-WgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaM
-gttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgt
-KgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaR
-taaattaaagctKtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRac
-attgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagt
-aaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttattSatacSatttR
-tBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacat
-tttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMctt
-RScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaat
-ctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgttaNaacagNWtagt
-aNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaa
-aKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtata
-cttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMg
-gaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagt
-tMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaacctt
-ttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatccca
-YtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVt
-DYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagt
-tDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVc
-aacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDtt
-caagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagt
-aaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatg
-tHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccg
-ctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHta
-BgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgg
-gtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaW
-taaggtacaDacaDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDt
-aWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMga
-HgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataa
-tttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaH
-ttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgt
-tgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacac
-McaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactD
-DctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctH
-RtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatga
-tacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBat
-caccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRK
-ttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatctt
-DacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKa
-caVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatct
-tatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaa
-gaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtg
-HacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBa
-cgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatc
-tataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattt
-tcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgt
-gaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYacc
-agatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtg
-atcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaat
-NtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaa
-atactgctgNcttgctcatatatactaDtagctagRcataBcgccRaacaagcacaagta
-HYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcSt
-HgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWatattaccYaagWt
-gaataatgatttgtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRt
-agtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMc
-acKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVH
-cDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaat
-taHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRH
-acaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaN
-tgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtatt
-KHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaa
-cgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSat
-cccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcg
-gtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagaca
-YttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttc
-tacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVa
-gtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtN
-aRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVt
-aaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattc
-MttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaag
-tctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgS
-actctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctg
-tHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHK
-BNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaM
-ttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtc
-aatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatW
-ctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMt
-tVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBY
-MggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacN
-acacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBta
-agattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaag
-aaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBct
-tatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatg
-YYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtct
-ttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBca
-gatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBg
-ctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDt
-NcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagc
-tatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYc
-agcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcacc
-gaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatc
-cggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScS
-agcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaS
-gattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaa
-ttRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatc
-KgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKa
-RaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRcaVataattKatt
-aaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtag
-SttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtc
-DcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaa
-atccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNg
-gBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccata
-ataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWa
-tcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSgattRataYaYata
-gaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNN
-SataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBa
-tataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagt
-KtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBac
-ataKaatcggWtaccagMtttcKgScgcaactattVctHScccaacccHDtgttacgttH
-VaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggW
-tatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgt
-HagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBc
-tYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctata
-YMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRt
-SMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVt
-aacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttM
-ttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgc
-gtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaat
-tcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaag
-StcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaH
-gtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtc
-RttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgN
-ttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVa
-VtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaV
-gaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaa
-ttttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKa
-KMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtc
-ttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWta
-aWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKa
-aaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgagg
-aaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggt
-acatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWB
-WtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaac
-VYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatcca
-tBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaa
-aatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataNtattcVtcataa
-cMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtat
-gcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStg
-MtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctat
-aKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtct
-taatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNag
-YcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacB
-gVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtg
-gKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaMgSattgtaccta
-tataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatD
-aatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHa
-ttcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaat
-taattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccat
-cgaWctataSttBgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttag
-ctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaa
-YattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgata
-MNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBt
-cRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVa
-NctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcat
-RgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgt
-NaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVa
-attBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHt
-gagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctac
-KgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWat
-aacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatatt
-cKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaH
-aWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSaca
-atKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattc
-ttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaa
-atttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttc
-RaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattt
-tttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaa
-gaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattac
-aNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDa
-BBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDaca
-aacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRta
-ttVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaa
-gYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDtt
-cVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttct
-tttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgK
-tcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaa
-YWaSactgatccatatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaW
-atRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVg
-atataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKtta
-aatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaa
-SRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctB
-ccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaa
-tcWactaatactcttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaV
-caYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcS
-BSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVN
-ttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtacaatgtgctttat
-atttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaK
-tttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDg
-WaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtga
-caaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtat
-ataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttactt
-HttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRata
-VtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaa
-RtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMt
-agaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaa
-aggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaa
-atcctgttactDtDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgat
-MactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgatta
-tacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtc
-MKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctaca
-aacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggt
-taMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNa
-aattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBt
-taaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaM
-aaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaact
-ttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcB
-tctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaW
-WgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYa
-taRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVt
-ctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataK
-ctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVta
-attaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctg
-cMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaact
-aaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagata
-atcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatW
-tcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctV
-ctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgB
-ggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMctta
-tRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKa
-YatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHtta
-cgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtc
-KtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttca
-aSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatg
-tgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHa
-tgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMR
-ttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVt
-attagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaB
-tcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatg
-ttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWctagatataaNtacc
-gaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBatta
-gcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccB
-attVaYtttHatgaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDR
-aggataaWgMataggtactatatttVctataattaaatatgtgttDtcctaKataaaaac
-ggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaN
-aStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagc
-aWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatc
-atVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaat
-catatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRag
-ttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttga
-YaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcg
-atcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWc
-gcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatct
-gtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStK
-caDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNa
-KagttctcataagtaatgactgaVStaatcctcDagtcataagWtataatattacagScH
-aatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVa
-atacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVg
-tattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgN
-tBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaagga
-agaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYat
-SctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYtt
-ctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWD
-tcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNct
-ttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNc
-ggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattc
-tatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtatt
-BMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHct
-atacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgt
-acNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaa
-ccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKS
-attaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcB
-agaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKt
-gHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggM
-tNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKct
-gtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMtt
-RgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSat
-taacgttMattgtatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggc
-aatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgt
-KatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaa
-atStBcattgagggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNttt
-gtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctca
-aaacVctWtacatagttaattBBttMacatDtatttaaRggattatBVcacattattaag
-WctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaW
-aagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtct
-aaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaag
-aWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatV
-aVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtW
-caatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgccc
-ataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgat
-tBagBtaataattBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDa
-agYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtS
-ataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRattataaatatcta
-ttHSctttggNctaagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaD
-atgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaac
-HtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaataVacgaaattt
-aBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtc
-taBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttg
-RHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgt
-aWcatYtWaBtaBatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtact
-DtMNagatMtttRacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactag
-gaRttaccVaagMacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggt
-gacatcaBatHaaMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaN
-ccttacccatataMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaa
-ggagYaaMHtataaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactata
-atWctcctRKaaHtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHD
-aactaYVRaatgttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMt
-DNRtgtttgggtHcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDt
-gagataKtgtctataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtg
-tWtaagWtaKgattHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKW
-tgtgRagcNtKtYtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaM
-attaVNHRKttattattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDW
-gVSagtggtaacataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSa
-WaattataatcataBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattM
-agtKccaaWccatttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWa
-taRtHtcgaMagSMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaM
-tVaaaagaatVgttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaat
-DctNtgatMcRaaWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaa
-catgcgttaaaccaaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacgg
-RKaaaMtcHgttaattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKa
-DaagaggatBtSacatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaata
-ttatNattataWatWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKN
-tMatacctctgtaYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatg
-actcSaatattgtBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRat
-aYggtctaMtggcagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDataca
-tatgatcNtagagMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataStt
-agttttgcaagtgctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatY
-atttcgggcaDtVttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaa
-aaRDctKctagtaKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatg
-gttttaaacNttBaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBga
-tacccgtVtaatactSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWattt
-atattgBNtgtVgVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaatta
-cacHtaaaaaBttKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaa
-tSagcaatttHctatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgta
-taRKYaatccRYaatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRt
-gtBttYtatKaattaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagat
-WDgVgtactgtRtaaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDtt
-ctttggacttcBcgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccat
-aaatNttaYYgtcBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaa
-BBtStttaatcaaatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttt
-tcatatcaSgtcWNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatctt
-cYacaaatataDgRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNgg
-aNtcattatgacYgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNg
-gaaaMtaaRtctagtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttct
-KHNctaaNatttWaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttg
-tacattSattaacttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaa
-taaatcactcaMgacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVa
-KtgKaacctaggStatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaac
-RgDtaatgtccMaacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttg
-aaatttHtagSBgKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtg
-cHKBKVaWaacacWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtM
-tHacKgWtcctcctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcat
-catttaNRgaKgBtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttg
-aYYatgctgcacatttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaa
-tcagtttaKNRtaaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBt
-KgNVRagctaRVtttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttc
-tcRatBVggaccgaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMc
-aaaatgBtaKcgaRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtc
-HBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttcta
-cttcgMagagtaaaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtc
-WBtataccaaScttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgH
-aaNWtgttaccatacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgag
-taaYtttgDaKDgVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtW
-ctatttgaaatHttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaaca
-aHttaMtctttatcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVct
-aBcaHcttaccaaWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtg
-atatYDMMtggaatKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRga
-gtattaKatgatctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDt
-cggtataMcMDcaattNcacattattgaBaHattHgcYattagaattataaBtattBKHt
-gtaacHtHaacaaRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNata
-acacgWtattDWccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccg
-NcaDtWNaaRgctcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtat
-aVVaHtaRaccacaRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWt
-caaccttcgctaMSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaY
-NcDcaSatMcaattYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagt
-cagcgaSaaSgtattctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDaca
-WaYDaactagcaDttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKc
-ccaaBtWcccataaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYa
-NttaatagKatacaaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRa
-acttcggScYctataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatg
-atcttaaattaKRtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatg
-SaHcRtMDctagatcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKtta
-ttNaggScgWcaYtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactc
-tBaggtHHtgaSagYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtct
-gMtRHtactgggagcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacN
-tWYMBcNScgggataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMV
-caVtgtStctctWaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDat
-ctcaMatVtNaataaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaag
-VgNaaRctSctgWKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaac
-ttggtggDVgtcaaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaa
-tgttatttgttttaBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagat
-DatttcacctaaaaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgt
-actttagVctaBBaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcat
-tgRtaNataagaaaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaat
-atYRcggatgtKtttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRt
-cataatNagatVMctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcS
-DtMStNYtgtgaagcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggt
-KgagacaattaataHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgc
-SKtcttttcaaRgtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattV
-tBtDatcttVgagtatttaaaattacYSattatttaYtagcaVSHattDctKcVattata
-agagRaccccWcaBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaN
-VDatataaatWtcMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSt
-taaataatttttaaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcat
-tgYVMtRtHgBaatcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVa
-gMgttgKtgtHatcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgc
-ctgMctcacttagtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtB
-tttKSHWSaVtVtgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKc
-catagVactWDgtRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaat
-cagaatagHaacaattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRct
-cBMaaNgcaStgcgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKa
-tctScatattNgStYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttK
-BtctataaaatcaStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgag
-aaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWK
-gtaaccDataactgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattt
-tgWDacBtataatttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSW
-ttMaBcHttaatcttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctac
-tatSgacaatcVMcatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcgg
-acccctDcYcDtttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRa
-tatRcttgattggaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatg
-cDaatHccgMDcgcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctR
-SctctWcatttVatgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYc
-DMWaSKVcccaaaggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaag
-gtataatttgcttgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgtta
-agttNWaaYcgaaVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataa
-ttattttccttgaYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRatta
-YcKtggtSggWgatMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWa
-NtatcttcattSgatatgatactattWatSaattWccgtctaatcttgKDacatRatggB
-ttatggKgaagtttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaB
-YcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcY
-aVtRVccgaattatacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRa
-ctWagWgttcagtgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaa
-gcDatatatNttgtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKt
-tcatttttHaMagatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagc
-gttWtatVWRaaSacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVa
-ctWtgtStNatacatYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgV
-tSaMgBcactaaatYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaac
-YYMctcagaNattatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVa
-tHNgcYttNatatBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaa
-atYgctgttttaagatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHa
-VcWaYaWVSccRactDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaat
-gattcatgtcKRctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYY
-acttgcactaaYDcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVcttt
-cBKcgtcttatSttattYMttaatcatattcatSaYtgWaDacgaataactctggaDcca
-ttacgSagaaattgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccSt
-gaaatDaagYRtDagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtH
-actaRaagatatMMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtg
-ccctttattatSatWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWa
-caaaBagRactKacDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtN
-taWatagcacgcgcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBac
-gacaVYtRttaacttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatag
-tcataagMgatVagVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVt
-cMataaacatattHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttata
-aNaacatctBtaDNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtgg
-cgRgtHtVtatHgtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStac
-gtataNcgVaHHagYttStaaccWacaKctgctttaactagtVatttaaatKttRcgact
-aHttSaKtcagBBaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBa
-gDgtagtatHtgcattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNtt
-aBWaacatgcttSattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaa
-gNattRtcBaccatKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcD
-aatgRtDgcNWSgtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaS
-aStaataWBMtgcaaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaa
-cacacgDaatctactaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNa
-atDttKgKDgcaaactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKM
-taKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaY
-tcaKatgNacgtcWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttc
-tgtctttcactacWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYtt
-ttVatttWtcBagaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMat
-gtRaaDtDKttgataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtga
-gacctgaaatcNKDactgKtacgBtDKgattaaatagattatagactatggacgacgRga
-aYKgYaRtgaaaagRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVga
-tacKctaKgcSactaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacS
-KatSDMatWtagKtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcgg
-SttaggtgHtgYatgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtc
-gKtatcaatgcgStVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaagg
-taMNaatttRDtcDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatg
-aaVcatacacVtKattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagac
-ttttMttaRaMtaHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttattt
-VaHcgattWttMaWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctc
-YaaKMttcagtSNtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDta
-aggtcSgtDatttaKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHt
-tctaNRWtaHtttaaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaS
-aVaMtcSgtaaacctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgt
-acaaMNtagtacggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNag
-DtagggtHagHgctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagc
-DWVctBttccaWcacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaS
-tggattgtVgaMRNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaSctta
-gacaaDaaBtaHtacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWg
-NagatatYtHattWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaa
-gttgcatgaKaatggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcg
-gtggYSttcagaattattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtg
-gcHtRaagtHaagVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaR
-tMtcagcaataaaaVccNcttMtctattaagacacgagatNtatttataaaSagaaatat
-SccaRHKatYMacgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaacca
-ctVcaSaYtaactaHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagct
-taatatgaaRcaDVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKg
-MaSaSggttggDNcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaat
-BaHtttgtaagggataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgY
-tttccgYattttYMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBa
-aRctaVgggaacRaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaW
-ttgcaRcgtgNattatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKa
-gcWggaWcStaatNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKt
-aNttcaRcatRtccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMcca
-VgVgtatcKacDaYcccactcattcacYtattggatVgaWttctgSDagaWDattctaca
-taaaDggtactatagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaN
-cYgataHagaDtagttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgN
-taaYgYccHgWactgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMW
-aSDaatcYWccaaaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcR
-aaaWaWactgDttttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBg
-NaaYctggtatctacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctg
-aMgtBttgtKaSatVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKtt
-agtcttYgtaSccaatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaN
-taSgaaataatatVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcH
-tSttgccaatNgtaHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatac
-BSaagMaDcaattttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttata
-tcgccgaagBgRaDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaS
-gaSVaRttcaMtgtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKtt
-HgaaaYSaBttVacWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStaca
-atHtggtgtBgcNDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaD
-DcKtaaatcVVBtcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgB
-caWNaNatatWScYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctat
-aNSgBctagattaNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacg
-tttaacctaaattaaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtct
-aNtWattcaattVHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYa
-gcHtaSataaStKaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatR
-DaataaMttRgataaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaag
-ttYgcataVMaaVBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWt
-cSggtcHgggcgagtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVa
-gNcSgBKtaaMtcaStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacM
-gtagtaaWtaYtgHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatat
-ttStcgactaDatKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatga
-ttcttacWatgDgagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttga
-tHaRVaaSVNNtcaRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSag
-ggaaagKctgggtcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWM
-agatagacatatVgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgta
-gaNtgagaaaRttcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggtta
-tcaaRaaggaataaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtg
-actatcgHDaBgRBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaV
-tcgaataaataagttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWg
-acStMtttVaVgaBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagt
-tgaacaagaatacaDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVattt
-aBtHtVggttattaaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgt
-cgggSMtaatNagtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcH
-gtagatgaggtcaHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaN
-actataaNcctKcBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcat
-HtDHaRagctStatattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaact
-KNaaaVaStatcgtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNa
-tWttgWagtaaKgtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRc
-BaStgtaaaaaMttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgc
-tcMgaaaMcgRaacaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttV
-ttatgtKattttYcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtH
-atDMBcttMacNaVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtD
-KBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttatt
-YttctaMBggcaYctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaata
-aagtctcgcgttcagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaa
-tgtccttaactaaaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatata
-DtHcKcctaBaggcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHa
-cBStSMtcgaacYttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcga
-tatYtVaccSacacgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMc
-atBtacatgtYtctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaa
-ataatDgcgcKtaatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttat
-aVgaaaatcWDcttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagac
-BNtttattttagtDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRct
-cgaagttgaatttNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttc
-aRattacaVgtatWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBta
-SaaMctgMtcaagaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNata
-StRtgaattactgtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtt
-tWggcKatgcgtagDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtat
-ttctWataagctttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatca
-atgttcaaatccDttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgt
-tatMaccgttgMNagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDtta
-tagHBacttRttcctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRa
-tNDWtctgatcKtgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgt
-NggtWtWcttgSatRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgcc
-aHcgtagaaMatgataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatN
-gaRtYataaataRtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctc
-tBaWWtaagBttVgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataa
-YtNtttatacttaMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatg
-StDYgtattaBatBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDt
-NcttattaagYcagacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaM
-cgcaMaagSagaaDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggt
-tcgtRaSgacaStaaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaS
-tRSKcatggtgBtgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaac
-aggaagtctgacgMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacatt
-aWRBtcaccattctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStR
-ttWgttattaSVKtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctct
-gtgggggcSaagcatVattMacattSgttaacctaaaaccgcagtgagNgtctataatBt
-HtacaaSccccMgagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacat
-agBgaMRagatRcDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagtt
-atacVaDcacactcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaa
-atacaRagaaYaNtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKa
-agcatKatatctcaRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVg
-cattttttaVaagtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacactt
-ttRHagtttaDSHgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtt
-tgtVatYattaattBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttga
-RgagaaMKtaggtattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaB
-tHgtatBaRtttaccaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRatt
-ttNcaaaDDaagtagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttac
-VaataataatDtgHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWtt
-aaBactcgYtDaacgactMtaYKacBgttcttgttataBacatScBcattKaaattactt
-SSDaRgKtHHagRNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtg
-gtSaWatBtgatttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtggg
-agRMttaaMaWccggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaata
-tctgNgVttagcttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtg
-cgtcYBagtRHgacttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccW
-tNBaYatttYacYtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRt
-VDYaacgtaBtVKtagaagRttttttatataSaagaaKtaatatKtattagBtHataata
-tcWNaacagtgWaccatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtca
-gggBgtggSctaaWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataH
-tgacaagttSacgtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatt
-tcaMcgtaaacctctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtcc
-BaNSattgaaattgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttD
-tacRtgRattttttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtH
-HcactgtWgtaggtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDta
-tVagMtggactaBSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVct
-cYaWYtBcttcgaYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaM
-ttKaaaaatVaatHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKB
-tMagtcttMWgaatRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVa
-cStgttaMaaaaacNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatct
-tRcgDHHattcStatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatca
-cNNWtDatgaaaactgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatg
-tYagacMgtVVtgDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMa
-cctagaatattcttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDc
-gagMtacattaMtaVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtt
-taaBVMaaWcSaccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgt
-cMtgcctVtaRtgcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgc
-WataRaHtDtacgaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatg
-WgatKatYYaaataNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacat
-DttaaaNgaacttacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaa
-StNaaVBatagttcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRtttttta
-tHHNHaHRtcaRcMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgat
-tcaaaKgaatScaNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtat
-catattatcVttcgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatat
-YcctSacVcattttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVc
-aattgcgKRctMaKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaH
-atgSaSattcagtDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatact
-tVttatcataSSaBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaH
-VaBtttWtttgatRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaN
-gcNatacgWatYaatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDt
-tttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaa
-aataatNtNgccgaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgact
-aaatgaagVaacaBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcg
-cgggRctttKaaBatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcga
-RggVgcatatcaDcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtc
-gaatctattSKgtgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaa
-cgaSgcYagcKBttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDR
-ataaaNaSaagHttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVat
-aaNaaaDtaatgtaaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHc
-BgcMaatDNatcaYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcg
-tacatacatctaDactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttS
-aagYcgMatttaVattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtg
-tttaNtVtatttatgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRK
-ttcatcWtaBaggKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaN
-tgtcgtcttttttaBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattc
-aVgatRtcagBtcaMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactY
-acaKgaaagtggtttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWt
-tBMaBccagaHDaataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMY
-DcactYtaStWgaaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggR
-aaMVtStBtaaaagggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHa
-aatcaVttaRaKtcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcag
-aKtaMKacgccaaVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgt
-gacgtcttcattacaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDg
-RHgatctttagtNtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgt
-tgNaagagKttgNYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWga
-cYggStacYcgatgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNg
-atMacgKgBaWagacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRt
-DaSHgNttYaatWagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtc
-tagMctaccagagttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgac
-VcatagtgtattttccttcatctacttSgaaStcagHtMaataWNDagtatttttatagg
-catNKataNaMtgctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMc
-ccattgggtagaKMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagS
-aaatRatttNctacaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaS
-cWccgaKttttcgtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaa
-gttacWatgHtttaagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDc
-BaMaKtctaYatVaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSa
-HatcaDtaatgMMatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagtt
-aaWDacgRaRtaKttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcg
-McgaSNgactaccRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHc
-taKtHcHMcRgattgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatca
-ataaKgactgactcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYg
-cttgaSStgtaDaNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKa
-agBtttgtcttaagMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaa
-taNttccHYctctaSRtaYagtNgDagatWtRttSttNtRNagacatattttatggacta
-cYMagtMacYaagYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWN
-KMgDttttaWtaBaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNa
-gYttBYNgaBaaaStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatt
-tgtgBcatWMtaaaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWac
-acWtDtatttatWaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHH
-MKScSgSaMtDtaMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttW
-tagactatgaRNcttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtt
-tWataaaDaDgataMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMc
-tHaaatcagStatStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgta
-StMcSNcgtWggMVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgat
-MtaccttaagYatcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcat
-WSatttcaMtgataKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKN
-tgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtc
-gtactHggagtaatttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccact
-taDtagtaaKgYNcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccag
-KgaNgtctcKtWgaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaK
-ggtKcDtRtRgSaNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttc
-HgcKtagcYgttttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttN
-ggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaa
-MtaBYtgtaHagtcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaW
-gNttccttttMaRcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaa
-ttgatcWaatgtttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSa
-ttaatatagaatgSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBc
-ggtDaggYaaactNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctata
-aDtttcgtcgtattaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVa
-aYaYtccagacBttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgatagg
-VatgagttgatcttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgt
-aaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaD
-NcDatggWaattggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacaccc
-NHataaaatgaaagagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtca
-gtttgtDBBHWcgaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttca
-aNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaa
-attaataNcaRtagtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRct
-cagcRattaacatccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatg
-BgtaVVYaaaatccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNct
-attagtttWttRtgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgt
-tNKgtcSggSHtaBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaag
-RattccggcttDgggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgB
-cBtgDtttcctattaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtg
-ctaaaatggagacctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgta
-gagDttcBatgtStttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatD
-aYgcctMBtgtNSNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSa
-ttaaaVHtaDaatYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccct
-gaYcattaNaagNaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattat
-acYtMatWgatttcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcg
-atKgaggBtRYattatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaa
-SacaRccMcaaacttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatcta
-BtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMt
-ctgcatgaagRDattactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaa
-DagttDtttgYcaagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattat
-KcctctttttcatgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgtt
-DYttctatagWcRttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaa
-agggtaactcacgDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaSt
-cSaacgtaWttatatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSac
-tcKtttVaWRatatttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaat
-SNattaccgtcaataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgactt
-atHccacHaacVcWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaH
-aDttYacDtBgtMNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaaga
-agtgtaMcWatDggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtc
-ttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaa
-acgggtataatcaaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttc
-HaMtNtMgcgaaatKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtB
-gtgHtHDggaBDtWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaa
-caHtatggaNaVttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtac
-VtRaaactgYtcatggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNa
-ttcaaHtgKRtRtagtKaRWaataYaggatccacttcacaatgtgatMaggactNaacca
-aMaaKtagaaMctacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaata
-tttatcaacaactRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaa
-gHaattagaatBWggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWtt
-cBaatcctYttgaHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgt
-ttctacgtagSataHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtM
-tatgaaNtWtHgtDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaa
-RDHttHYDtNgcatHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaW
-WtttKaaaggBtattHagtaacactDggtattttScttaaaacaStcaacHttMtatcag
-atSaHtaVtBaNYcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtatta
-YSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaa
-KtHattgRtBtMMccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtD
-aaacttDcacgatSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatca
-tatKRattSggtcggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaV
-aatRgKatttKSaYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacV
-ttKattVNgaMattNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaN
-gtHtaWgaBMttttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtat
-WggagSattKatRBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaK
-ttgatattttgKcgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNg
-NYtMttNHgtHBataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKga
-aRSRtBttatccataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDat
-agNttttactagcgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMt
-ttctaVttMaatgattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKa
-MtaaDgtKgttBttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaa
-HcatYNaaVDNtBgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVt
-aaHttaagaKtaagSaYtgcacttDattYttaVgRcacaattDDttagattttcHagcca
-YaataKaatccVDKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaaca
-agaacRSactBHttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatat
-BaaagatgaactaaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMa
-taattaagtcSRcatSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatc
-DttRHtcagtDtaStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcga
-YWaactRtDtatttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttt
-tataaacWaBttcgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYa
-VacagaacgcScDcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMt
-tYHtaatHcKKtgggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcN
-aaYaBtattttatRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagt
-tgtYatctagaBaHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagB
-tactcttatgBcHcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaY
-RaattccaNatgtgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaa
-tWtaRtaatSgatgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaat
-actWgtattcHttcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaM
-atacgtYaRNtgNaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBa
-attHHtatVNWYHaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBg
-atHtBcaatHYaSgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggct
-aSttgtaataDctWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtata
-acaRKctaacttcYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtW
-tataaWgHataatttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtV
-agactttacKaWDMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttB
-catgattSHaaccVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBta
-gtcttccttatKBRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVa
-SagttatatYtcgNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaatta
-aatgaWaBggYtHYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttc
-tgDDcttgNDagcctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVga
-attaatagttattactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatg
-gctKtWatHaNttaatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRa
-taacagctMatBgMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWR
-ttcatBSHtttgaatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaat
-atgtatgHYcRtagagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaB
-taagRagtttgSRtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatg
-ttVtataccagaatDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggc
-cKVatccaSWaaKHtttSggatgagMagttgcaatatKYtacBttaccatHRttaactta
-caDKKtaKaDcHHcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggB
-atcttgaRDactgatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRR
-ScatcttctaatacagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcac
-gcctSRaagcataattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacN
-VtgagaataccactctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtc
-WDcWaBatattRtVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDc
-SttaaWtttcaaaatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgct
-cacHccMgaacatcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaag
-ggatatcagtaNMttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDta
-RNDNcBtagBgacatStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSagg
-agaacgWcMgtRcaagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaac
-caBtacVMgSttgtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgt
-cctaBcYKattcaggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatK
-cVtHgctggaNttaagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYa
-taaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagH
-aScDctHttaaaatVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataa
-WtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtag
-tacataggSaatMtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgR
-gtDVSRattttttaaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtga
-acMtacSDRMHaaacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaat
-KactNacgcBYtttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctatt
-agattKHttYaaBtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaH
-tattgtDaHRgatgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagt
-tcagcHttgWagaWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYc
-gcatgtatgtNaccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtc
-tacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKt
-tttDVgttgtaaNcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagt
-acDYgatMYttaaaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSatt
-aatataNaWcacaataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaaca
-caNttttaatctaKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSS
-agcNtctacctttaacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgB
-YcBggtaWatataKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVt
-ctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttN
-tttatcatgctagYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagt
-cttccatBagatctBaaagSacagtaaStaaatatataataatcttaactatVtaaBatt
-HcHgcttSSaaDRaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaact
-taBaYaaaatKgtactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttc
-aWgtcaKtatcgacatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagt
-taggggatWtttgattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaa
-attacBtMRtatccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDt
-cgNcgacttgtaaaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttga
-aVKatNacDggagWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcag
-NacVRactcWgctttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaW
-aaagttcNVtagMaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgt
-WSaaBatagtagSataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaag
-aDBatcttttaRaaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatW
-aDaaSaDaaattVgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatY
-aaagaataDgatDaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggc
-StataacttVtaatWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtat
-ttaacattWaatgttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNa
-SatctRSaWtagagtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatS
-atataWttctcgtaDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKc
-ttttSaaattYcgYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccD
-atatagtcRaaaSMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcac
-ttBaagaMDtactYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggttt
-atWttYttatKMKgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatg
-tWtcRDWttcggacNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtg
-HtcaataaacaaWMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgtt
-aDaScgWccWHatacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKcct
-tttttStaaDDtHYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcg
-cRtcctttacagBKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWttt
-caataDtactRaatBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaN
-aagatHBtgtatVtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaa
-caBatttaatctaSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRcta
-agtaaNtaaaaattatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRD
-aSactgcagaHgttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVt
-tttcYaaNtttttatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRt
-cWatctaattgtVgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKg
-tDtHBVgYcagatgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSY
-tccagtRtaSVtRgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaM
-atgRtgaaaMHatgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRW
-cBtDaaMKRcccWtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaa
-NYBaatatctgatNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtM
-acgtMDtgagcattcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaa
-tMtagatDcaagMtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaN
-tBatKtStcRagtgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaat
-tactcYtNagaaaDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWca
-cagaNWaNgaacaYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtg
-HtattcatatttaagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVa
-taRaKWMcDWtSaatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgcta
-ggRggtSagKcWYctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSR
-gttatMtNttttWHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctg
-aacatttVcNtgtttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataat
-aHaaaNacaStgaNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNaga
-tKcatataVatactgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacatt
-acggcaKttattgacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDY
-acccWaMttgRtNggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaa
-aatgNactaattattNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctg
-gtcaatggtatBtNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWta
-taaaNNacNgctYagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMt
-agtcaYaaRttWgBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRta
-aYagattgccMtgtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVaca
-tttaSttSVDSctactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVtta
-gRtttttRttYYaYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWat
-ggtaagagRaaattYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctct
-NtataattBttStaRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWtt
-cgcaaWgtWNcBccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcB
-aaBcgaataattcttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctca
-ttctcaatgVgaaacatWWctgcagtttctttttMagWttatRggcattattVaagaBBt
-tatctattatMcNtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBt
-aHHYDttKctaDctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaagg
-YtcataYgBtccRaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYg
-cWYNgagtaMgtSccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKct
-tttaatgacBttNYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStg
-tSaNaactVMcaatcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttca
-tMYRctttRtaMgSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaa
-ttatBtttWatgMctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaac
-KatattatNggNaRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtg
-aNtcaaaRgtaBcttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHg
-attgggtcgacacDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatM
-gtMVgVgatttcagtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagat
-aacactcataVgttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttg
-aHtKaYtattccagccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaa
-gaSaaaagaaatSaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMt
-tcttgtDtKaYVttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtc
-gattaccHtcgcgatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVc
-WMBBaWaWcagtatHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtc
-tttgBgtattaaDtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMa
-agcVacgtgttaaMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBc
-NtgNatBtggactttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgH
-aattaaaRctgatKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttag
-gaKtaaaBacVDcBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattW
-cgHgcaDccctHttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcaga
-atcctcYtBKDatatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagt
-ataHgMaVggcaaDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattg
-agagtccaNtgaatttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcata
-cctgctctatctatKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNt
-acagtcgataNgaVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaSt
-ctWDVcaaccgaVttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatacta
-aaWaagatYHRWcaSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNgggg
-DaWgagctgatctatttHaactttcgcttttccatttNaaYgtattttactttacttRat
-aBttgatagggacattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaat
-aaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaY
-HatYtgtaatcatttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaatt
-aaaYatcgcatBagcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaaga
-NatgKtBSctgattgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSc
-caSScagttgatYattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaa
-DttttattaatacSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataa
-WacgSVKatactagDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHg
-acacattcHKaMKtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatg
-KatVgacattagWtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBta
-ggttaYcttagaSgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKc
-gtYaaaaaKtaSaattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgt
-ctgtgagtMttgaaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgR
-gDttcDcatttgagWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWV
-catgaacatRgtNaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYat
-cgatgtacSaaataVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaag
-McttBgtSagKgNttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaac
-ttaaaWNaattgaWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaa
-tcgataaatRDttataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtat
-tKcgcBtttDacaaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagtttt
-aagcctNcttaBtYttaRactaattggagagggtctagtatgggtttacttBtatcatat
-gctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcct
-atttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYt
-cMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcS
-tgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttt
-tcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatc
-MtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtW
-gtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDa
-WaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaN
-MtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaat
-tVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagat
-tattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaa
-ctaccScattRatatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgc
-acatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatB
-tgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacagcccccacatYSc
-aMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaat
-aRattagHacacaagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagt
-attMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVa
-tactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHK
-ttactatccctcatgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtag
-aYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaK
-ctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtt
-tctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaY
-tgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcc
-tagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtg
-aaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYa
-gactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactg
-atttcctttaNcgatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtS
-KacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttac
-tttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccag
-ccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBa
-accgggttattaaBcKatDagttactcttcattVtttHaaggctKKgatacatcBggSca
-gtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagtta
-RatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaa
-HgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattB
-tgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcD
-RaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaaccctcccctaga
-WBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaa
-cgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaa
-catKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSt
-taHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctc
-ctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataa
-actaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatV
-ttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcac
-RHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaa
-tttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaa
-agtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSa
-MatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgat
-caccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaa
-aacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBt
-cttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcagga
-ttHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgat
-gaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatH
-aactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatg
-caaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaa
-aaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKR
-gRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWag
-cNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNag
-gaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaat
-atVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRcta
-VtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBgg
-actaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRcc
-ctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagt
-VttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMa
-ctacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStatt
-attMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaa
-gtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcH
-VagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcS
-atcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaa
-cRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWa
-YttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVN
-tataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaa
-taWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttc
-gagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatt
-tctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaat
-gttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMta
-gaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttata
-aHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaataga
-taatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggS
-BNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtg
-KgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKc
-ctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacgggg
-tNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatg
-aatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctcc
-gggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKtt
-MWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDc
-RNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMa
-YaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSt
-tacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaS
-aBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHtt
-YaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacg
-tgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctc
-tDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacS
-gaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDa
-cSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVag
-DVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaa
-cgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRaBaStNagatagg
-cgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtg
-catagtttWYaagBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaR
-ttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctat
-KaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtgggga
-cttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctct
-gaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVg
-BMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMcct
-tatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVattMMDtMactatta
-ttgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNa
-atactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcY
-ttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVa
-cataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccSt
-YtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatca
-MatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHaga
-gSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaN
-aHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtN
-taStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWW
-attBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcR
-VaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNg
-DWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgtt
-ataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaatt
-acgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcR
-gYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgH
-gttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDac
-ttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHa
-taaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcS
-cSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKt
-tcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNaga
-actcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcD
-tatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattD
-aWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttat
-attacHactgttataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgg
-gtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBct
-atctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataa
-gatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctR
-taBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccg
-tttaStagaacaMtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaat
-ctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaa
-gtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccN
-ctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKat
-tgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKga
-tgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYtta
-ttNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacg
-caRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaM
-acNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBa
-cNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBta
-taRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatg
-aagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaW
-gaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVag
-aatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctt
-tcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcattt
-atgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaattt
-acaatcactSWacgtaatgKttWattagttttNaggtctcaagtcactattcttctaagK
-ggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcR
-aattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatat
-tttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgt
-ttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYa
-tDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYc
-tRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStc
-tatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDV
-ttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKK
-acttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBD
-ttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKctt
-RggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHa
-YVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaa
-gacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBa
-tgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRa
-cttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgta
-tWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVc
-YttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaa
-agNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaB
-aBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtag
-ttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagt
-acNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKc
-atDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVta
-MaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHa
-MctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaatttccattttacatt
-tDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataB
-ggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHca
-VgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttatttt
-gWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVta
-gaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaa
-gtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKStt
-DaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgc
-YtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctR
-gatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttc
-ttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaa
-RgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatg
-KtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNt
-HagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaN
-ccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttt
-taacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaS
-gtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaac
-acattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgtt
-aDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatR
-tgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgt
-ccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMt
-ttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataatgccVgacccgat
-actatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttcttt
-atVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaa
-StNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVa
-aaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRag
-aNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttt
-tttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttt
-tcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRtta
-HctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaB
-ttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactt
-tgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRac
-MMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccatt
-aRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYcttt
-KttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKt
-cttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattg
-acttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacata
-tacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattg
-cccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcY
-tttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYt
-MttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgata
-tatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRca
-gcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcH
-tcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtatt
-gaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgc
-tatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBH
-tYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHK
-taMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYta
-gBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagSKaWttataHact
-aHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataM
-ggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVB
-ttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaa
-atgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgt
-ttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHca
-ctttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHg
-tHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWa
-aagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNc
-cKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatt
-taWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMtt
-atgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtc
-NatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatg
-RcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtct
-tcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaSca
-KgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMa
-ttttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtat
-taWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKat
-aStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMat
-RaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaac
-aYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaK
-agattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggt
-tBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaH
-MWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaR
-gattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNt
-ttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaa
-aatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgt
-aYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctgg
-acaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgta
-HcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtc
-cNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataa
-acttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRR
-YttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaat
-YRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSc
-tcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttgg
-taatctttYgtctaactKataHacctMctcttacHtKataacacagcNRatgKatttttS
-aaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHg
-ttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaK
-ttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcN
-tctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHc
-VBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtY
-aaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaat
-tttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWY
-taRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttR
-aWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRa
-WataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgag
-VtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagt
-gKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNg
-HtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatt
-tctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaata
-aHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWg
-actKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYt
-tatgagaaacctNVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattc
-gSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtac
-NaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctg
-cMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVc
-aaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagS
-aaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaV
-cDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBca
-cggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRc
-tatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataa
-tMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHt
-WMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRagg
-BaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSc
-tatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBga
-agBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaag
-cgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSa
-YctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaa
-gatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHa
-cHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaR
-ttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWa
-gHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtt
-tctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgacc
-YatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRK
-DttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtY
-tMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttt
-tDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWc
-ttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWatta
-KttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatat
-BtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtat
-NtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVN
-tcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatc
-ccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggt
-tWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatgaDatataSttag
-BaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcK
-ccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttg
-tcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttR
-gctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaa
-DcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataW
-ctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaa
-ggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNac
-ttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMc
-caggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHa
-atgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaa
-aHKtaNBctagBtgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtg
-MRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDtt
-YatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataD
-DatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgc
-DtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgc
-gggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtga
-atatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtataca
-atctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagt
-aaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctg
-tccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagt
-YtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtt
-tttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataag
-HacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtB
-atgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatg
-ctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBtta
-cNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHH
-WHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaa
-ggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggt
-gKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtat
-aatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaagg
-agtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataa
-KNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagta
-ttaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWt
-ataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaa
-taacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtct
-taaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattt
-tHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaa
-acaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcat
-atVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacc
-tataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYatagatgWttcat
-KtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKt
-attaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaK
-atggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcga
-aacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBc
-tgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaa
-WaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHc
-tKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHB
-ccatccattcNHtDaYtaataMttacggctNVaacDattgatattttacVttSaattaca
-aRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMcc
-MttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYa
-tgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcgga
-atDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKa
-gggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaa
-ctMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBt
-atDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaatt
-gcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttM
-gYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaa
-HttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcY
-NggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgag
-agtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNta
-RtaactggatgaccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaa
-BtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttD
-aVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRca
-gagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaW
-aMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgV
-ttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaR
-gctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVct
-RaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcM
-tcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYg
-DHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSata
-atttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYat
-SatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVt
-tgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSa
-DcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaa
-taHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgat
-WatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtgga
-RaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggc
-acBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtat
-tNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVa
-gSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactc
-ttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagta
-RDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMtttt
-gMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaa
-MKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWt
-tHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagN
-SStHcctRRNtattgtccttagttagMVgtatagactaactctVcaatMctgtttgtgtt
-gccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagB
-tVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcY
-HaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaa
-tDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaat
-aagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcM
-acHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNa
-agaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNg
-attgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgt
-VttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgta
-SaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttY
-tagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttV
-acaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtB
-cacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtc
-ctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaa
-KNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSataggttattcVta
-aagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDc
-tctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaaga
-WtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKt
-gagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaa
-gaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataS
-tgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcat
-acactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcB
-tYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactg
-tctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgc
-atttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNta
-aattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttB
-WgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYS
-KaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgac
-caagtgttttctaacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggN
-MtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttc
-NtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRc
-McgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgt
-aNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacg
-ccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWta
-HtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatg
-YcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcac
-catctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRtt
-aagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBM
-aBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaa
-tVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagK
-atagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaa
-NgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRag
-gSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatR
-ggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaRSataBatMttta
-aatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaacct
-taacgttBtWatttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBctt
-aaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaH
-tVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtatt
-gaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaac
-caBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHc
-tRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatSt
-ttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagt
-WattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaactt
-aWgtatctagacaagNtattHggataatYttYatcataDcgHgttBttctttVttgccga
-aWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaS
-acataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatB
-RataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctat
-cgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtN
-ttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatatt
-aggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataaagtatattaatt
-tataVaacacaDHatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgt
-tRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtc
-aDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctt
-tRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNaca
-VcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNt
-actWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtc
-aBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatag
-DVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaW
-SRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMtt
-NtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccg
-atttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactW
-atVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctY
-aMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttc
-KgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatat
-tgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYa
-KagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKS
-actctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSc
-tgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcH
-agacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgac
-tctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRtt
-agtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMg
-tDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBt
-tgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtattt
-VtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStctatttccSagatgt
-tccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNagg
-ctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHtt
-cSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaR
-aaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaa
-aatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagta
-acgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaD
-atMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagat
-ttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYt
-cDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVg
-gtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaY
-taataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacN
-WgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYY
-atggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaa
-HHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBM
-aaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaa
-ttgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScN
-tttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgct
-tYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcaga
-aSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttt
-tttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaa
-tSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDa
-cataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataR
-gttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatgDtaattagatHg
-aYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVact
-YtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBacta
-gtaDctatagtaatatttatatataacgHaaaRagKattSagttYtStatatatagtctt
-aaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRa
-aaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaa
-YSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtg
-cgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttata
-tKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVt
-WctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKa
-aHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaaga
-gttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDc
-ctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaat
-cccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBct
-HgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBt
-acaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgB
-aVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBga
-tgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMt
-tatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNt
-atttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatg
-RtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaag
-cDttatNRgattKaaattttcatctaatgccgcaataataattgttatYtagtRNtaagt
-tggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKg
-ttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRca
-gtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaa
-tgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgac
-tacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBg
-attaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSg
-atcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatN
-ctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactct
-aMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHt
-atgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSacaattgtattgca
-gatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWt
-tagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHg
-cVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaac
-NttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatc
-tgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVa
-acattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMc
-HgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatK
-aSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtag
-gKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDY
-actaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgta
-VgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcacctt
-agMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKg
-actaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatata
-aataRatSaBctagttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYt
-aaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaat
-cgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHa
-YYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttg
-tatatYtStatctagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVact
-YtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaat
-aRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaY
-tWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgtt
-aVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYaccta
-DStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBac
-aattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaa
-tccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaa
-NaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSg
-aaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtg
-BRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWta
-gcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttSc
-ggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagt
-ataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggR
-ctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaV
-aMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMact
-acHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccg
-BaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgcc
-gcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataa
-taaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttct
-ttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKStt
-aYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHactggatatatct
-gagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgt
-VcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMat
-atatattNVttWtWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagV
-taccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtt
-tatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactc
-BtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatW
-cgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRa
-NatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacR
-BgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggttWaacgatacat
-tBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtct
-tagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaa
-ataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatc
-aaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKB
-taaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaac
-atagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccat
-atagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagt
-agctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaa
-gYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRK
-tgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatag
-aHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaK
-actttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatt
-tagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaY
-gcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKacc
-gNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttg
-VaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaac
-cMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttg
-agtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYttatcttattattS
-taattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKac
-ttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgag
-aataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNa
-aaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattaca
-gctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRta
-HacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaa
-tctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtB
-tatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgD
-HaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttacta
-NtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaa
-acggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaa
-cactHattaattcactatYttaagacactaKaagRtRataaattttcatHggtaataaat
-gataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttc
-cgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaa
-aagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactV
-tttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttac
-HtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaa
-tggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWca
-aagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaa
-DaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttat
-cNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaa
-VaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMt
-agctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctga
-tgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtat
-cNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKK
-aaacaaaatRatttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHg
-aaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaa
-aMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSR
-ctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacg
-ctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacg
-gWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgat
-attagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKa
-MttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtg
-aagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagc
-cgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYctt
-MtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWa
-cgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMt
-VggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttca
-cttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKataagtagttaagH
-MRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgV
-atagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaa
-atBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaa
-RgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaN
-tKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataa
-tatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStc
-gaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBt
-tagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaact
-cggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScata
-cMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWata
-StcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDcta
-tRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttS
-ttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattg
-BaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDSc
-atactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttg
-ttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtg
-aSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcc
-caaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatatt
-BDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRc
-HttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVa
-RaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRat
-gaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaV
-attaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgatt
-SatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMctattatatDttagg
-tctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcggagtgHgtVttc
-ttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgS
-caWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNa
-atNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaat
-tBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgaca
-aaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKagg
-ccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBg
-aacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacR
-ttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNat
-tVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgatttta
-acgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgt
-cStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaag
-ttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgt
-tKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRta
-tgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWa
-atKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcY
-ggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaa
-cagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttat
-RtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctga
-BagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacga
-gttgYgacttDattatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaN
-atagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtN
-tRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaW
-WtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgS
-MMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWt
-tDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWttt
-WtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHt
-aaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgR
-cHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStK
-gtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcc
-tttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSa
-gWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgV
-ctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSt
-tattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagta
-WacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgH
-tacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtD
-aDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtataaactaYaHRct
-StgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtg
-ggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgt
-atacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKac
-cacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBR
-tVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgg
-gggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaat
-atatNctaYBggKaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaa
-ctDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgN
-cgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataat
-gcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttata
-gcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVta
-tttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccgg
-aatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaN
-aatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNa
-atgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWta
-gYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHg
-aaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaW
-gaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaag
-aagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRattt
-gatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVtt
-agaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaactNaattttcttt
-aaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctK
-ccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacR
-aacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctct
-tgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgtt
-ttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaa
-ttaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaac
-ttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatc
-gWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRW
-ggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVK
-aacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaND
-tgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKt
-HcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRa
-RBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaa
-caatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNa
-tcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaa
-aggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcatta
-gDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRac
-SccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaa
-WcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaB
-atWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcg
-ttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacYRaaVagataagt
-aattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNSc
-attNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaata
-BNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSa
-BagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattatt
-gtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaB
-ccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYga
-McYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVStt
-gDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBa
-gKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaa
-ctccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatt
-taaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtc
-RgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKR
-cSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattc
-tgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNca
-KagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtg
-tgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYt
-tYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcN
-aaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtt
-tWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccS
-gtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagcc
-aaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKttt
-StgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBS
-tcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgt
-caWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWt
-tgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttct
-aacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDattccaRaYtttt
-agttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatca
-McttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaa
-aaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaag
-ataattgatcgacctgcaacgttttattacNMWNcattataDVDactatattatYatttt
-gcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDt
-taacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMta
-tattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaD
-ttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagttt
-gcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctagttttNcataaac
-DttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMt
-atcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatctttt
-ttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVt
-ccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtg
-aagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKa
-tYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtg
-aaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgY
-gtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagat
-BgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgta
-tYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagc
-caWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgK
-gattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgtt
-gWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtc
-tKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNH
-tHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRK
-tattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaData
-cttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgt
-attcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaM
-cacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaD
-tttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaa
-ataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtatt
-ttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYga
-atgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRg
-ttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaa
-aaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYc
-ctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDt
-gKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWatt
-atatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttc
-DVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHg
-HatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttct
-taaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggaca
-tcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVa
-ttcaaattctgSattRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDat
-tWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaat
-atctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaat
-HaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcac
-WHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaK
-acVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRattt
-gtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaK
-BDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacR
-caggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYt
-tcattatacataatVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBca
-aRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggt
-aHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStg
-aaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaatta
-taactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDc
-cttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaa
-aatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYS
-RgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcat
-RtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaac
-taRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgtacggcactDBgg
-tMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtV
-YNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRg
-tcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaM
-tgRttcHctaagctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgN
-tactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYSc
-MtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDa
-aatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcat
-ggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaa
-tattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattR
-WDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaa
-RVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcg
-MtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgctt
-ctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYg
-ttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatt
-tagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgcta
-atWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgag
-aactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaat
-tMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttc
-gtSagtSaRctacaataKatattctaVgtgtaattRacKagttattgaMtaatgaNatac
-DataaggactttccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattg
-ataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtac
-aWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtV
-YRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcV
-atKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWga
-ccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYc
-tSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtac
-ttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttSt
-NtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatt
-taSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgac
-tMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWta
-SatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaag
-accDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataa
-RacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaa
-gRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRa
-atcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaR
-ttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaa
-ctaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattt
-taaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtccc
-SagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaK
-ttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtY
-gtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtt
-tttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccac
-ttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHa
-tcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBat
-tcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatat
-DttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaN
-tataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatc
-aattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgt
-tDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtct
-tatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagK
-caaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMg
-taKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtR
-cacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaa
-tataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcW
-ataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgca
-gaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaac
-tgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWc
-caaactattgccgttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSa
-VgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaa
-VttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattg
-BtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWtt
-RKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaD
-tactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattgg
-tttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtc
-ccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSga
-WtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaaga
-acagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtatt
-aNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHg
-taagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagt
-SccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttatt
-gtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcg
-tNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttD
-agaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBg
-actcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKa
-ctRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRH
-NtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaa
-gctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMttt
-ctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNct
-aYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatg
-accHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVca
-ttMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBa
-tgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtat
-agRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaa
-tRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgt
-tVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBtt
-ttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaa
-YaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatat
-atttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgc
-tacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgct
-BttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattSt
-acctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacK
-agaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctattta
-aaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMc
-gatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattca
-NaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaSc
-ttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRB
-caSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBcca
-atcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagacc
-BggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaa
-tcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttSttta
-SttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVa
-caatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtca
-cttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMt
-agtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatcctt
-caDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtM
-gHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggca
-tgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgY
-DaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatag
-aagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDa
-HtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgcccca
-tgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHD
-aDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttaga
-cKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcW
-ataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtV
-tgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataR
-cacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagt
-HaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcM
-gaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgag
-ttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaata
-atgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtact
-KagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKat
-taNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttac
-tatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtaca
-tatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStat
-RScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtga
-KStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttc
-VatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRct
-tttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaa
-gttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBc
-tccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaacatttcacctta
-HtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRtt
-gtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaa
-DtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttat
-gtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatataaatcttagatN
-KtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRttt
-gaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctD
-tBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgY
-tStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaa
-gtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcat
-aaacttVcatatgWtacaaaWttggaaactttaScataactRattMtDacVYataaaagM
-aattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWa
-ScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWg
-agcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVttt
-MtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBa
-KataactMttttattaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKY
-gKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBW
-aattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatD
-aSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDc
-cgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaa
-ttaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBc
-aRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNc
-tacagtgagacgaaaggKttacattgggacaataKNtattcaagWKttgatNagNtgcta
-NgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVt
-caaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaa
-cRttagaaccRBatataWaatKctcattcSacWaacaacactDttVttgacYaagagtaS
-gcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagat
-aaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgD
-tHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHg
-gagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttc
-atgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHa
-aKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtD
-NcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaS
-tWtattgYaggtSatBMBDactVtggttDagacataaactactBgcacaacMaagaStcc
-aWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttR
-BgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttc
-DgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYc
-BaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgttt
-atRatctatttagacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRgggg
-catWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStata
-ttcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctg
-RatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatac
-aRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYatt
-aaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNM
-ataatccaVgatcttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaa
-tBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtK
-atMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaa
-DaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaat
-gtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatR
-ccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRta
-SWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctct
-tMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMt
-aatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaH
-gBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtB
-gatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataac
-aatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVtatccttttHaSc
-gtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctat
-tcaaagccVVcatattttagMcgtattNtVBactacScattgKVtataaKtttgNaWctt
-NacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggtt
-VDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgta
-aDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaV
-WaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatD
-HWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttat
-acgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtN
-ggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYctt
-aaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHt
-tYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgtt
-gtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatc
-VtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatttcccaataHgtt
-ttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMacca
-MaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYt
-aagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatc
-YtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcg
-tBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcY
-KttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaatt
-DttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtgg
-agcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBW
-WgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDY
-attBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtc
-tctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVct
-tctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaa
-BRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSV
-WatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBac
-taaVaaKtaaacctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgH
-SatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcc
-tacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDt
-YcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVg
-ttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNt
-tcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHtt
-NgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttt
-taaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatg
-atatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagatt
-attagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccR
-aKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtca
-aVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKa
-aaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaH
-YtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactat
-tgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatat
-attattataattBatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaat
-cgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaY
-gYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagN
-RcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaY
-agaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaa
-ttctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNN
-aYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaa
-gtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagN
-ggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgt
-tHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatcta
-atRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtt
-tctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaa
-ttggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNa
-cagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaR
-cgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRt
-aHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagct
-RgtgcNaatctgattatagattagtatatgaataDNatcYaggKRacaatcaHcaagtta
-gtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDt
-SaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYa
-VaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctca
-RtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHg
-acMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVScta
-gttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaat
-NactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVa
-attKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggta
-cgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRc
-ctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcat
-caatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgt
-tctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMt
-aaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtB
-VBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWta
-tcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWt
-gKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYB
-atccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtg
-HgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcag
-atgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatt
-tcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVg
-tttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaaga
-gtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaa
-tctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcc
-tSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNg
-atctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcag
-acaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDN
-cccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgt
-atHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRt
-WtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatga
-cNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKat
-tVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSg
-cBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaac
-DtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDc
-tcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaa
-aaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWc
-tcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatK
-ataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcg
-ctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRY
-aacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKtta
-McHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgtt
-YctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVg
-VatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgta
-aacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgat
-aatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcat
-aagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSa
-RHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtg
-tMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaact
-RgaatagSVHtaataagttStccaatcHataatacMcattHtacaatttctgatggacat
-atgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtca
-tDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYtttt
-aBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgtttta
-ttaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWac
-aMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaa
-taaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaa
-DNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtag
-aattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKg
-ttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHa
-caaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNac
-cctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtatt
-agVStaccgatgSStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttR
-cgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaW
-atataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgt
-aatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttgg
-tVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcg
-catgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNca
-gaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgt
-ttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaatt
-aHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNct
-caatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgt
-MaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaat
-atYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctV
-taaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtt
-taggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtc
-tcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDW
-ccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaa
-DSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgR
-tcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaB
-gtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgt
-gVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaa
-acttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctc
-aatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVD
-taDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacac
-atRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttct
-attaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgtt
-acaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaa
-gHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaM
-tattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcg
-ataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaM
-aataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHt
-gaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaY
-gaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagc
-gtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtg
-MMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaac
-ctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHt
-accagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDV
-tMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaac
-tgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcg
-aactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWa
-VVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcga
-cagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKa
-tNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaa
-tattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtD
-tagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStD
-tKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgta
-HgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaa
-aaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcaca
-aRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcat
-gRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattc
-aaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaa
-aaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtW
-gggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcc
-tgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaa
-gcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaaga
-VaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaa
-tKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtct
-atKtatVggKaSaagtttattttatgtactactHtHttSMactatHcaagaattVataaa
-MKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWt
-acacaattctRVgattctatgtgtatHagatagggacVaattttDtNaWKagtatatHta
-gacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDat
-atcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVK
-YNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSg
-aKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaa
-atgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaR
-ctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccg
-attattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaagg
-cDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatat
-acgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVa
-BggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatg
-aaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatc
-acgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacattt
-DcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaa
-acttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVt
-McaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKga
-aggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatK
-BtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgV
-VgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatca
-attaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaa
-HcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaR
-gtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtca
-gMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMc
-cVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMt
-gaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggt
-aaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatata
-attggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagta
-KgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagta
-gttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttV
-ttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtg
-taBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWac
-acRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttg
-gtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBg
-atacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgc
-caVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHt
-ttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYc
-ttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaa
-KSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaat
-gMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcV
-VggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatatt
-KMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSggg
-tactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattc
-tgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtV
-cStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYa
-attcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccat
-tttagtMaccctggVattHaatVagaaMaattaVacatacacaaattaattacgtKtaga
-aaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtg
-aatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNg
-aMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggS
-tcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMact
-tBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBta
-aaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKatt
-ctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaag
-ttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVattagatctctgt
-ttatcattYttgatHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtata
-tcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaa
-agttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagY
-gatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataa
-aNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtat
-HgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNta
-tVaggtKctttHattcatttatYtattagtataYtttagYcattagaaataHtaacctta
-ctcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacR
-agtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatR
-gtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaY
-NgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatS
-DtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKat
-ttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHt
-NgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcSt
-VaactaatctacatgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgR
-ctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatK
-cgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagc
-tgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaa
-cDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtV
-ataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScat
-tYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgtta
-NaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatH
-tNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatD
-ataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagt
-KgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttg
-ccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaatt
-agMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataac
-cMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMS
-tBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttgg
-ccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcat
-agtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaa
-agtVacatKtatatataVtagcgWccacagctcaaccttRtatNactMtcattaaatttN
-aaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBact
-gaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHata
-catttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgata
-gcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtg
-aSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaN
-SWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWa
-ataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHa
-cHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSg
-SRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccW
-cMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcag
-YKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcacttt
-cWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKt
-ScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMtt
-aYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtK
-catgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgR
-WKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgt
-taaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttt
-tggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaa
-ggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgctatcgcccBacac
-ttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctg
-gDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYW
-catBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaK
-YaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWH
-tctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSt
-taScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaa
-HtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKca
-cRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWa
-taactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaa
-acattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDta
-gtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaac
-KaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttca
-NagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacB
-WgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWgg
-tgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgtt
-aagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaac
-WgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBa
-ttcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaa
-taatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDt
-ggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacB
-cattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBata
-BattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaatt
-ctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNa
-cttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaa
-cgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctt
-tStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtc
-HctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSR
-ctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKc
-gcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMaga
-taatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDg
-taaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWat
-tHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcR
-aWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtt
-tDttttagNMgVttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggV
-cgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgc
-VWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMt
-KgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMS
-gaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataatt
-aattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaat
-tcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgt
-aYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKt
-SagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtca
-BaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaa
-aVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaag
-atWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBt
-gaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRt
-gYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagata
-tacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcD
-gcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDt
-caacBtgHttggctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacg
-ttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVt
-ataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHt
-tgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRat
-aaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtg
-YVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVa
-gHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMg
-aVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtY
-ggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattat
-tcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagtcttDccctatBa
-tHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatc
-aYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatK
-cVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKt
-cDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatc
-ttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWH
-gttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaK
-tRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHa
-cgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgtt
-atcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcN
-caaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaD
-gcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaa
-agWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaatt
-ggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYata
-agaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtag
-ttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYac
-aKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatac
-attNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRt
-gtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaatt
-agagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtc
-tBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSg
-tWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgt
-taKaatagBtttcttagaggVttcaatRattNtccatttcagctactccacMatSHtaga
-taaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaa
-tcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYct
-tDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaact
-ataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaact
-tKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtac
-NtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcK
-WatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgattttatctaatRagttt
-ggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcK
-ttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgR
-cMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtat
-taNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWga
-WtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMattt
-atctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatg
-aatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKta
-tVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNc
-atctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVca
-aWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaS
-KcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagct
-KtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaac
-tatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtg
-gttatttagDScttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKV
-SttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWag
-gaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaM
-gatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagR
-gWaccattgaStttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaac
-BgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNa
-WNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtat
-gcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaa
-tMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtS
-NtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaa
-HBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcg
-DcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgtt
-cttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKag
-tctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYctt
-gYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgta
-agtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttag
-YaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatgtHatctagacat
-ttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMc
-cttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcc
-tKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttg
-ataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDac
-aDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttV
-RtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgV
-agtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatata
-aaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctac
-ttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMac
-ttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRat
-DtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctt
-tRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatac
-gtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMata
-KacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccag
-aaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaa
-HYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBca
-ctattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaa
-agacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaR
-tctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaa
-cgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMt
-tWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggc
-KNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaK
-tcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKY
-gttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDt
-tggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgac
-gcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSa
-taactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVct
-tatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaaatactgctgNct
-tgctcatatatactaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaR
-gacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKc
-aacctctgDVRaYaatattWttattcttataatWatattaccYaagWtgaataatgattt
-gtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgt
-tScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatM
-aaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVg
-tWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKR
-aVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagca
-tacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgY
-agNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattca
-catccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaac
-tagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataac
-aVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaa
-McatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaa
-MtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttg
-ttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaatt
-HtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacH
-tRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtg
-tcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatc
-aaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgata
-NgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgta
-aaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgtt
-attcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRg
-taDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgtt
-KaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNatt
-ggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcg
-ttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtD
-acYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNg
-aacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVa
-attHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaH
-DgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaa
-cacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHtt
-atacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacact
-WHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctg
-WaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatataga
-tttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNa
-tatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSat
-actgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKca
-ttttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagt
-tBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBt
-ttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacaca
-SatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatat
-aggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtc
-tMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgt
-tggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHat
-aaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgK
-VcattttHgctttgtgacgaBttttccatccMatRcaVataattKattaaaagDatVtta
-SRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWc
-gagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatca
-DRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaac
-ttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaD
-aatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatga
-atatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagc
-taaaWttBatDgMatgagatctKttaHactataSgattRataYaYatagaatDagtaDaa
-gatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBta
-KgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaa
-caYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttga
-acgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWt
-accagMtttcKgScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgtt
-catBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHN
-ctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttca
-tcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgY
-taVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcg
-VaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRa
-tgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttgga
-taaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRH
-YtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBata
-ctYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgW
-WtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattW
-gcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcS
-aaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctt
-tStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgM
-gatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStag
-ttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagcta
-WgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaattttSBttScgt
-BSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaat
-tattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMac
-tagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacga
-tRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHat
-HtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHta
-ttgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttc
-MacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagt
-ttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaa
-ctctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMc
-taaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBta
-tgccacattactcaaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDt
-ctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaa
-tttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSat
-ggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctR
-ttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaattt
-cVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattD
-gtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaaga
-ttgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWca
-cgSatacaggtagVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtct
-YMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctN
-aacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaa
-KaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaag
-WaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccatcgaWctataStt
-BgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNa
-BRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSa
-ctWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMW
-aVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHD
-atDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRc
-acttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaa
-ttttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMc
-WtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYc
-tWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgta
-DcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttat
-aKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaa
-ctcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaV
-cataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctct
-VattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagD
-gtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRg
-caatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtc
-acaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRa
-ataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatD
-HattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaV
-tDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgc
-aDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttR
-tctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBc
-tctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKac
-taWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStB
-attKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattgg
-aYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHa
-tgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttg
-HWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatcc
-atatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaatt
-aNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWM
-agKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaa
-ttgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttK
-VgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSaca
-taaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatact
-cttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtS
-aaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaata
-KDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgt
-tttttttgacattatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVt
-YVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcK
-gtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattB
-cRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcac
-aKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacag
-gttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRat
-gaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRataVtggaScgattt
-DMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDt
-MtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDtta
-atatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaV
-NatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactD
-tDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNat
-aaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKR
-gaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDattt
-aaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSt
-tHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVttt
-ctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHc
-NgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagattt
-ttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtga
-BaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaB
-aYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatc
-RgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRgg
-tttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgY
-BtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatt
-tgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttg
-VcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMY
-NcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRa
-YtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtc
-tactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagt
-gacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataa
-ttacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataV
-NactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWac
-gaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtH
-KattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgc
-taaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRt
-RaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtcKtaataaattag
-ggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWt
-tataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDt
-DccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKtt
-gaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtg
-agVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDt
-atcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcR
-YttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRca
-aBaacaVaKattHgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSa
-SYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaH
-RgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHat
-gaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDRaggataaWgMat
-aggtactatatttVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaat
-ccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaa
-cHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctN
-HatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaY
-acWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDaca
-tgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWN
-VHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatca
-cgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagR
-gccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttattt
-gtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgta
-attatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBt
-tacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataa
-gtaatgactgaVStaatcctcDagtcataagWtataatattacagScHaatatagcaHYa
-aSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaS
-aaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNat
-VttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgt
-HcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggttta
-cctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRt
-KKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaa
-MNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttca
-HtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRg
-aataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBa
-ctgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaat
-DWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaa
-WtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtatttta
-ccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYc
-agStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgct
-aaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatt
-tagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWt
-aataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatD
-MtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaata
-gattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcat
-ctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaB
-YcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattg
-tatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttag
-agaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctt
-taRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgag
-ggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcata
-cgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtaca
-tagttaattBBttMacatDtatttaaRggattatBVcacattattaagWctactVcaBgc
-ttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWg
-VgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatag
-YaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRN
-aaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgt
-attcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaat
-NcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBta
-ataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataat
-tBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgag
-atVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagag
-tcaDSggYatttDaaatcactKatWatcDatatRattataaatatctattHSctttggNc
-taagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaa
-aatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttac
-tatRWaataVcccaRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtK
-StStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacg
-atatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYY
-aaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBta
-BatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMttt
-RacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaag
-MacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHa
-aMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatat
-aMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtat
-aaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaa
-HtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatg
-ttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggt
-HcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtct
-ataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKga
-ttHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKt
-YtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKtta
-ttattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaac
-ataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatca
-taBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWcca
-tttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMag
-SMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVg
-ttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRa
-aWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaac
-caaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgtt
-aattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtS
-acatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataW
-atWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgt
-aYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattg
-tBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtgg
-cagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtaga
-gMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagt
-gctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDt
-VttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagt
-aKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNtt
-BaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaat
-actSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtV
-gVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBt
-tKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHc
-tatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRY
-aatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaa
-ttaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtR
-taaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcB
-cgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgt
-cBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatca
-aatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtc
-WNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataD
-gRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgac
-YgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtct
-agtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNattt
-WaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttgtacattSattaa
-cttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaM
-gacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctagg
-StatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccM
-aacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSB
-gKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaaca
-cWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctc
-ctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKg
-BtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcac
-atttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRt
-aaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRV
-tttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggacc
-gaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcg
-aRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaa
-NBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagta
-aaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaSc
-ttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttacca
-tacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKD
-gVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatH
-ttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtcttta
-tcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttacca
-aWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtgga
-atKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgat
-ctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDc
-aattNcacattattgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaaca
-aRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDW
-ccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgc
-tcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRacca
-caRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgcta
-MSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaa
-ttYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgt
-attctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagca
-DttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccat
-aaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKata
-caaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYct
-ataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaK
-RtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctag
-atcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWca
-YtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaS
-agYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactggg
-agcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScggg
-ataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctct
-WaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaa
-taaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctg
-WKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtc
-aaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaatgttatttgttt
-taBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaa
-aaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaB
-BaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataaga
-aaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtK
-tttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatV
-MctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtga
-agcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaa
-taHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaR
-gtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVga
-gtatttaaaattacYSattatttaYtagcaVSHattDctKcVattataagagRaccccWc
-aBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWt
-cMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSttaaataattttt
-aaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBa
-atcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHa
-tcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcactta
-gtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtV
-tgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDg
-tRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaac
-aattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStg
-cgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNg
-StYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatc
-aStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSt
-tgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataac
-tgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataa
-tttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaat
-cttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcV
-McatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDt
-ttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattg
-gaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDc
-gcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttV
-atgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaa
-aggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgct
-tgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcga
-aVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttg
-aYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWg
-atMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattS
-gatatgatactattWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagt
-ttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWta
-aaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaatt
-atacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcag
-tgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNtt
-gtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMa
-gatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaa
-SacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNata
-catYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaa
-atYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNat
-tatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNata
-tBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaaatYgctgtttta
-agatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccR
-actDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKR
-ctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaY
-DcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatS
-ttattYMttaatcatattcatSaYtgWaDacgaataactctggaDccattacgSagaaat
-tgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRt
-DagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatat
-MMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtgccctttattatS
-atWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactK
-acDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgc
-gcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaa
-cttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatV
-agVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatat
-tHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBta
-DNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatH
-gtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHH
-agYttStaaccWacaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagB
-BaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtg
-cattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNttaBWaacatgctt
-SattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBacc
-atKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWS
-gtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtg
-caaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatct
-actaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgca
-aactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtR
-aaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgt
-cWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcacta
-cWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBa
-gaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttg
-ataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcN
-KDactgKtacgBtDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaa
-agRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSa
-ctaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtag
-KtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgY
-atgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcg
-StVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDt
-cDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVt
-KattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMt
-aHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttM
-aWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtS
-NtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatt
-taKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtt
-taaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaa
-cctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtac
-ggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHg
-ctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaW
-cacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaM
-RNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaH
-tacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHat
-tWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaa
-tggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcaga
-attattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaa
-gVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataa
-aaVccNcttMtctattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMa
-cgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaac
-taHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRca
-DVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggD
-NcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagg
-gataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYatttt
-YMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaac
-RaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNa
-ttatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaa
-tNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRt
-ccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacD
-aYcccactcattcacYtattggatVgaWttctgSDagaWDattctacataaaDggtacta
-tagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDt
-agttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWa
-ctgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWcca
-aaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDt
-tttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatc
-tacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaS
-atVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSc
-caatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataata
-tVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNg
-taHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaat
-tttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgR
-aDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMt
-gtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttV
-acWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgc
-NDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVB
-tcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWS
-cYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagatt
-aNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaat
-taaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaatt
-VHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaSt
-KaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRga
-taaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaa
-VBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcg
-agtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMt
-caStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYt
-gHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDa
-tKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgD
-gagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNt
-caRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctggg
-tcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatat
-VgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRt
-tcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaat
-aaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBg
-RBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataa
-gttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVg
-aBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaata
-caDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttat
-taaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNa
-gtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtc
-aHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctK
-cBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctSt
-atattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatc
-gtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaK
-gtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaM
-ttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRa
-acaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKatttt
-YcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacN
-aVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaD
-gaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggca
-YctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgtt
-cagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaacta
-aaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBag
-gcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaac
-YttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSac
-acgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYt
-ctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKt
-aatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDc
-ttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttag
-tDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatt
-tNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgta
-tWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaa
-gaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattact
-gtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgt
-agDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagct
-ttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatcc
-DttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgM
-NagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRtt
-cctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcK
-tgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgS
-atRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMat
-gataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaata
-RtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBtt
-VgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatactt
-aMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBa
-tBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYc
-agacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSaga
-aDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaS
-taaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgB
-tgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgac
-gMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccatt
-ctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSV
-KtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaag
-catVattMacattSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccM
-gagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatR
-cDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacac
-tcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYa
-NtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatct
-caRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaa
-gtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDS
-HgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaa
-ttBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtagg
-tattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRttt
-accaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaag
-tagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDt
-gHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDa
-acgactMtaYKacBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHag
-RNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgat
-ttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWc
-cggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagc
-ttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHg
-acttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYac
-YtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtV
-KtagaagRttttttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgW
-accatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggScta
-aWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSac
-gtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacc
-tctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaat
-tgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRatttt
-ttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtag
-gtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggacta
-BSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcg
-aYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaa
-tHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWga
-atRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaa
-acNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcS
-tatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaa
-actgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVt
-gDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattc
-ttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaM
-taVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSa
-ccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRt
-gcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtac
-gaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaa
-taNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaact
-tacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagt
-tcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaR
-cMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatSc
-aNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVtt
-cgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcatt
-ttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctM
-aKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcag
-tDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSS
-aBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttga
-tRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatY
-aatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDga
-aSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgcc
-gaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaac
-aBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaa
-BatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatca
-DcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKg
-tgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKB
-ttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagH
-ttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatg
-taaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatc
-aYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcgtacatacatcta
-DactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMattta
-VattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtattt
-atgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBag
-gKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttt
-taBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBt
-caMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtgg
-tttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHD
-aataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWg
-aaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaa
-agggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaK
-tcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgcca
-aVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcatt
-acaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagt
-NtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttg
-NYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcga
-tgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWa
-gacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaat
-WagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccaga
-gttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtatt
-ttccttcatctacttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMt
-gctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtaga
-KMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNct
-acaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttc
-gtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtt
-taagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYat
-VaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgM
-MatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRta
-KttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactac
-cRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRga
-ttgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgac
-tcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaD
-aNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtctta
-agMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctc
-taSRtaYagtNgDagatWtRttSttNtRNagacatattttatggactacYMagtMacYaa
-gYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWta
-BaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaa
-aStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMta
-aaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttat
-WaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDt
-aMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRN
-cttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDga
-taMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagSta
-tStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWgg
-MVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYa
-tcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtga
-taKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaH
-RgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagta
-atttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgY
-NcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtW
-gaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgS
-aNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgtt
-ttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtN
-cNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHag
-tcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMa
-RcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgt
-ttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaat
-gSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaac
-tNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgta
-ttaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacB
-ttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatc
-ttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtc
-BKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaatt
-ggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaa
-agagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWc
-gaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDa
-tcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRt
-agtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaaca
-tccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaat
-ccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttR
-tgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHt
-aBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttD
-gggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttccta
-ttaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggaga
-cctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgt
-StttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtN
-SNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaa
-tYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaag
-NaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatt
-tcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYa
-ttatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaa
-cttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWW
-VBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRD
-attactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYc
-aagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttca
-tgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWc
-RttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcac
-gDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWtta
-tatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRat
-atttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtca
-ataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacV
-cWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgt
-MNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatD
-ggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNag
-cRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatc
-aaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaa
-atKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBD
-tWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaV
-ttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtc
-atggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtR
-tagtKaRWaataYaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMc
-tacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaac
-tRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatB
-WggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttg
-aHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSa
-taHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHg
-tDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgc
-atHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBt
-attHagtaacactDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaN
-YcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgca
-ggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtM
-MccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacga
-tSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatcatatKRattSggt
-cggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKS
-aYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMa
-ttNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMtt
-ttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKat
-RBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgK
-cgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHB
-ataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatcc
-ataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactag
-cgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaat
-gattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttB
-ttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNt
-BgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKta
-agSaYtgcacttDattYttaVgRcacaattDDttagattttcHagccaYaataKaatccV
-DKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBH
-ttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaact
-aaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSR
-catSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDt
-aStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtat
-ttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBtt
-cgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcSc
-DcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKt
-gggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtatttta
-tRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagttgtYatctagaB
-aHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBc
-HcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaYRaattccaNatg
-tgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSga
-tgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHt
-tcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtg
-NaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWY
-HaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYa
-SgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDc
-tWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaactt
-cYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataa
-tttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaW
-DMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaac
-cVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatK
-BRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtc
-gNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYt
-HYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDag
-cctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttat
-tactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNt
-taatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatB
-gMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttg
-aatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRt
-agagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgS
-RtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccaga
-atDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaa
-KHtttSggatgagMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcH
-HcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDact
-gatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaat
-acagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcat
-aattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaatacca
-ctctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattR
-tVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaa
-aatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaaca
-tcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaN
-MttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBga
-catStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtR
-caagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgStt
-gtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattc
-aggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNt
-taagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctca
-ggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaa
-atVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccS
-aaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaat
-MtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttt
-taaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHa
-aacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYt
-ttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaa
-BtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRga
-tgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWag
-aWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNa
-ccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaB
-tDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaa
-NcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYtta
-aaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcac
-aataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatct
-aKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctt
-taacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatat
-aKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatD
-BgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgcta
-gYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagtcttccatBagat
-ctBaaagSacagtaaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaD
-RaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKg
-tactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcg
-acatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWttt
-gattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtat
-ccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgta
-aaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDgga
-gWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgc
-tttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtag
-MaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtag
-SataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaR
-aaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaatt
-VgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgat
-DaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVta
-atWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaat
-gttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtag
-agtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatSatataWttctcg
-taDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYc
-gYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaa
-SMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtac
-tYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKM
-KgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcgg
-acNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaa
-WMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHa
-tacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDt
-HYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacag
-BKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRa
-atBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtat
-VtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatct
-aSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaa
-ttatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHg
-ttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttt
-tatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgt
-VgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcaga
-tgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVt
-RgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHa
-tgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRccc
-WtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctga
-tNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagca
-ttcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaag
-MtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRag
-tgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaa
-aDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaac
-aYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatattt
-aagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtS
-aatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcW
-YctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNtttt
-WHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtg
-tttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStg
-aNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVata
-ctgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttatt
-gacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRt
-NggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaatt
-attNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatB
-tNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgct
-YagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttW
-gBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMt
-gtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSc
-tactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYY
-aYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaa
-ttYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttS
-taRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcB
-ccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataatt
-cttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVga
-aacatWWctgcagtttctttttMagWttatRggcattattVaagaBBttatctattatMc
-NtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaD
-ctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtcc
-RaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgt
-SccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBtt
-NYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMca
-atcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaM
-gSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatg
-MctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggN
-aRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaB
-cttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgaca
-cDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttc
-agtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagataacactcataVg
-ttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattcc
-agccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaat
-SaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYV
-ttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgc
-gatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagt
-atHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaa
-DtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgtta
-aMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggac
-tttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctga
-tKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVD
-cBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctH
-ttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDa
-tatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggca
-aDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtga
-atttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatct
-atKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNg
-aVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccga
-VttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRW
-caSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatc
-tatttHaactttcgcttttccatttNaaYgtattttactttacttRataBttgataggga
-cattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgta
-BtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatca
-tttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatB
-agcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctga
-ttgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgat
-YattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaata
-cSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatact
-agDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaM
-KtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattag
-WtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttaga
-SgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaS
-aattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttg
-aaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttg
-agWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgt
-NaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaa
-taVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKg
-NttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattg
-aWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDt
-tataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDac
-aaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaB
-tYttaRactaattggagagggtctagtatgggtttacttBtatcatatgctaKggNcata
-aaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttK
-tgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctW
-BacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSga
-YaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBca
-tWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccR
-cctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSaga
-ctYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgac
-atgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKat
-cttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMttt
-aStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMa
-acattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRa
-tatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKa
-cgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDW
-gagctgcgaggggVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNg
-ttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaataRattagHacac
-aagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMg
-cataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWg
-KgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctc
-atgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctat
-tcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaac
-taWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaa
-ttcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagct
-ctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgW
-BaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRt
-ttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYagactNaatgttt
-gKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNc
-gatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtW
-ataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaa
-acatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgt
-gcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttatta
-aBcKatDagttactcttcattVtttHaaggctKKgatacatcBggScagtVcacattttg
-aHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttag
-attVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttS
-cactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggt
-tgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHa
-YRttagatMatgcatttNattaDttaattgttctaaccctcccctagaWBtttHtBcctt
-agaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcg
-gattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNatt
-gctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVa
-cVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaa
-KaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagta
-aVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVca
-attHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcact
-tacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaata
-tttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRta
-acBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgR
-SacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSR
-cgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccY
-tatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtV
-tgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaat
-gcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaat
-taaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatat
-DttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctS
-actHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBM
-aatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtc
-gaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaa
-agctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatW
-actcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtat
-gtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHa
-tttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctK
-gttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRH
-SctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtB
-tatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHg
-aWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgtt
-KaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgc
-attaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaS
-ggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcSatcttagcaatg
-aVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgt
-WacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatga
-aaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatR
-aVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgt
-cDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKa
-aDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNa
-caScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtg
-atSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgR
-ttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaa
-aatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaa
-atSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBag
-BttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattY
-atagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatgg
-KttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNt
-atNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgat
-tYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWt
-StaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBM
-aDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattS
-DttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaatt
-gRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDt
-gaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctacca
-cagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttcc
-gatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSg
-agtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaY
-aSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataM
-HttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataH
-gYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYat
-tDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaa
-tcaRaagataatagatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtaga
-atgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaa
-gBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHca
-YYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVa
-acgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcg
-tNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaaga
-tBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttD
-HaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctg
-gacStttcNtggcaVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBtt
-StStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgac
-HaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWa
-tgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaa
-tttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYt
-caaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatcaMatactataggD
-aHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVctta
-tKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNt
-accaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataa
-acaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatca
-aatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRt
-gtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBc
-taaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaS
-agtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaac
-caYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgta
-tBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYg
-tRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcat
-tggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtR
-YtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVt
-ggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtV
-aataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtc
-DtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaB
-tatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaV
-cHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttatattacHactgtt
-ataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcat
-gWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcatt
-MttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccat
-tVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYata
-tNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaaca
-MtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttgg
-SagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWt
-aRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcat
-cttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNa
-ttBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgH
-caaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYt
-aKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtgg
-taMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKat
-MctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaat
-tattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaat
-aMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNg
-HttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaa
-ctcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacag
-YtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttata
-aatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVct
-taBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWa
-cgtaatgKttWattagttttNaggtctcaagtcactattcttctaagKggaataMgtttc
-ataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtM
-atatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRat
-agSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDc
-gctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaK
-ccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaM
-gtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaa
-aaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHtt
-RaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagN
-aBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccH
-caRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattga
-RagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHt
-caaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggtta
-WatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWag
-caKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattccc
-RtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaag
-aaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttat
-acYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttSt
-VatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNc
-tgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMag
-ttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatB
-gtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKcatDaattgatta
-tDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaa
-cataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgt
-cgYtactDcgcctaNgagagcYgatattttaaatttccattttacatttDaaRctatttt
-WctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgt
-ttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNgg
-tcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgM
-DKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDt
-cacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgM
-tctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttS
-attgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaat
-gMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctRgatgttacccta
-HgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWtt
-McNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHt
-VtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNa
-ttccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctag
-aaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacga
-VtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaV
-tVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgB
-tctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcg
-gtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttctt
-ccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaW
-tgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacag
-cMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcN
-cSattNacttggaacaatDagtattRtgSHaataatgccVgacccgatactatccctgtR
-ctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgac
-taagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaa
-DtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgt
-aYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcaca
-gtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRS
-tctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHca
-tgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatg
-taggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKt
-aaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaag
-taagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRt
-ctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNa
-SaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacg
-HtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtct
-gctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacac
-acaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatc
-ttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSg
-YataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaatacc
-RgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKW
-tgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgatatatttttgtStW
-aaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagta
-aDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaac
-ggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccacc
-gagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaat
-tataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBt
-gtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcg
-cgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBa
-ttHcBWcaactgatttaatttWDccatttatcgagSKaWttataHactaHMttaatHtgg
-aHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacc
-tttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaata
-agtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaa
-WattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgS
-gaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHcactttactataca
-aacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaat
-cttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtc
-tttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcM
-gattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaa
-aaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYt
-caaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcc
-caNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaa
-tRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgt
-gRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagt
-taKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcR
-ctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctac
-atKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKataStRaatatatt
-cctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctatt
-gtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattM
-atgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagag
-gtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaS
-atttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKga
-gtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaRgattctttaata
-aagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYta
-atatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcc
-cRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagac
-atgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaa
-tatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactga
-taNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVg
-tccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVB
-tcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRRYttStggaactH
-gttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatg
-gaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDc
-aHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtc
-taactKataHacctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDtta
-MRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBt
-VgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWag
-gtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttt
-tNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMt
-aatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStg
-tgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRH
-VYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKag
-YNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaa
-aaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaK
-taataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttca
-aDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBB
-aattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgtt
-DgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBg
-HHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagta
-taatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaa
-gSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacct
-NVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttaga
-ggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagtt
-ggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWt
-gataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcga
-ttaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtact
-VaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtc
-gttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatt
-taRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaat
-MNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttM
-DataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKa
-BtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttac
-ataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatata
-ttaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtac
-gatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaD
-ataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNta
-WctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattc
-tSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtaca
-cHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHa
-taKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaa
-atgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaata
-aaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKat
-NYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNt
-ataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaN
-acgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYta
-tatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtata
-ttgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMagg
-BBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaa
-taaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHta
-gVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaH
-HcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtctta
-acgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatY
-DatcggagagcWBataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDW
-cWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagS
-attaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtattt
-ttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatN
-atcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacg
-tagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVa
-HatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttt
-tttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcct
-ctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgacc
-gtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRttta
-gtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagB
-tgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatc
-tgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBc
-ttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggtt
-gaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtca
-acHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaac
-gNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRa
-taHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYt
-aagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcga
-taatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcct
-aataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBR
-tcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaSt
-atccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKH
-ccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgta
-tgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtcta
-aagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgt
-KtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttN
-KtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaa
-tHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacag
-DRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHt
-tatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaa
-ttScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaa
-acgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaY
-MtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaH
-agcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtac
-aVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKga
-tacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattttHggNagSctac
-HgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgac
-cttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKa
-tWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaat
-atgattagaactccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttca
-agHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagV
-aDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgt
-BtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtH
-ccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaag
-attaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMc
-VatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaa
-VctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNH
-tDaYtaataMttacggctNVaacDattgatattttacVttSaattacaaRtataNDgacV
-tgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatg
-agaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBS
-tWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWc
-taacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaac
-ttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBD
-RaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtg
-atVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaa
-tatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRg
-ttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagc
-agtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMt
-StggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaN
-RacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatga
-ccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKM
-BaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatggga
-tttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgt
-acatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSS
-aHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVa
-tgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaatt
-gcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaat
-HtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtK
-acgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRD
-atMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactgg
-atDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttag
-aaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaact
-cRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKB
-tttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYt
-tcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBa
-SctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcW
-ttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNH
-tgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagt
-WMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaR
-aSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNt
-VtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRat
-gttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBt
-actgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttac
-taaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataSt
-ccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNta
-ttgtccttagttagMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaB
-VtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMc
-tatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatg
-gcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSata
-tcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSt
-taHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatg
-DatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaY
-taWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaa
-KaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNc
-tDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagtt
-cHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNca
-tgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaW
-ttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccc
-cBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatK
-ttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatc
-cttgaYctattcaaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattat
-tKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYag
-cactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatat
-gMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYt
-taNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHB
-ctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBg
-WagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYt
-YcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtS
-HcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttata
-VgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaa
-tttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcK
-taNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagt
-cSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRact
-aaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttct
-aacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctca
-agaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttR
-tBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtca
-VYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccga
-tattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaR
-BtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWta
-aagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattR
-aYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatatt
-ccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBc
-ScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWt
-gNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVga
-cctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaa
-atttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggS
-aRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaat
-DcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtt
-taYtagcagBagHaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSa
-aaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWat
-ttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaa
-ttatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataata
-tcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaat
-aDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWa
-aaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcB
-ttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaa
-DaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDa
-aWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagac
-aagNtattHggataatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgt
-atctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtt
-tKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKat
-StatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBD
-tcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBa
-cHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtat
-acttttKcgtcggSYtcttgRctataYcttatataaagtatattaatttataVaacacaD
-HatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVg
-tSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRgg
-WatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDt
-gMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDat
-caHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKtta
-aatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatga
-gDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatc
-ggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatag
-BattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcg
-KMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaR
-aMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagcctt
-MaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatat
-tataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtata
-agttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacct
-gggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatag
-acgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBgg
-tataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKac
-cHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcHagacBWatagca
-MtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNac
-tHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVM
-tcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgtt
-aataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaa
-NttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRa
-tMattRagataaccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNt
-tHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggag
-ttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaa
-SttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVct
-MtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNct
-WttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaa
-tctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRg
-gctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttt
-tYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgt
-MatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctata
-gccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaat
-HcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSa
-gctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagcc
-NctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMta
-gtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtga
-tgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaattgRataatacg
-BtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaag
-gaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaa
-atgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgcc
-aHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKt
-WRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKS
-aatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagY
-RagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKtt
-NtKagaaYaStaactScattattaacgatttaaatgDtaattagatHgaYataaactatg
-gggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatg
-atWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagta
-atatttatatataacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgtt
-caaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYt
-DcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgtt
-atgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatB
-tttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgt
-RaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDW
-ctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWt
-gttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWac
-gRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaY
-aHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaaca
-tgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtS
-gKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagD
-aataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStctt
-agtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtaga
-SRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVc
-DtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaH
-ctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKcc
-HaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgatt
-KaaattttcatctaatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMt
-DKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaaga
-acaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcN
-ctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtg
-BataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattN
-VtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaB
-cttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcga
-atgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttc
-aacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactctaMaVRattacag
-tgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgc
-aaaVKtagttataatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaat
-KKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaW
-gcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttc
-cStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctatt
-WttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaa
-tgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBta
-atttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttac
-tggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatKaSgctttattta
-gtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaH
-ctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBH
-tcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNa
-tacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttga
-SttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttatta
-WgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatataaataRatSaBct
-agttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYg
-aBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttgga
-MtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYY
-aWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatc
-tagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttga
-aMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYtta
-ttttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctca
-gctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctB
-YaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaattta
-tcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtat
-RKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKa
-attgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgt
-aataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaM
-tgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMag
-NcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaScta
-KatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcS
-aagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtg
-aaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttg
-actttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagt
-DRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaa
-tStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVg
-DtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDg
-aDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNt
-tNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWcc
-WKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaB
-tHgatgttacatgcatatMtttgtaacScWHBatHactggatatatctgagMgRSatcta
-aSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHM
-tcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttW
-tWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaata
-RaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWga
-tDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgS
-aaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatWcgaactacacta
-actNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtac
-agacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaat
-atgcataacccaSattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRtt
-atgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWc
-aaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaa
-tacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVa
-acSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRW
-gaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYg
-gtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgcc
-SNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVg
-aagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaag
-tcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtc
-atatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttat
-gaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacac
-tatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKca
-tgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctct
-acaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatW
-tYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYt
-tgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatStt
-ctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYc
-cagcaHatKctaKaDgctagacttattgattaaYttatcttattattStaattWaRaYBW
-agYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaa
-VaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDtt
-gaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgtta
-WtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKg
-YtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKag
-VcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtV
-cRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtatttt
-gcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRa
-RtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDt
-acttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgt
-gagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaatt
-cactatYttaagacactaKaagRtRataaattttcatHggtaataaatgataHtggctaa
-cBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgaca
-tVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggtta
-aBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactVtttatBaKHaga
-WgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatact
-tSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHa
-ggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKa
-aatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttS
-MaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataS
-aataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYagga
-tWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDV
-tatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcct
-gataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcat
-tRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRat
-ttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattS
-aaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNM
-aWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttc
-cWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacgctMgaagtaaca
-acagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBW
-aagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNct
-cttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSa
-ttctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBK
-cggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaH
-KagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttB
-tSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRg
-aDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHt
-BSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttc
-agcttWtttagtgataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaV
-cctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatg
-aBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRtt
-NWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctga
-aSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDR
-WBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataatatagtcttttt
-atgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVa
-atMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWa
-aMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBg
-VgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatR
-tgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaa
-VagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaa
-actagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWag
-tgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtY
-agSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtg
-tcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYt
-agtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttat
-tHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggat
-KtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNM
-atBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtS
-tccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgtt
-ctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNt
-cStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactga
-aaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgc
-cagtSttatatRaBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBag
-acgttatRKtgatctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaY
-atBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcM
-ttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaK
-gHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaat
-ttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatataca
-taatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDcta
-agagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaa
-ctccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtaca
-RHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaa
-aaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatgg
-ttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtata
-tttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattD
-tYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtg
-cSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMt
-KttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcc
-tVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaa
-gatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagaca
-gtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNat
-aaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttD
-atNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDa
-ttatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYB
-aaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaa
-aaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtga
-aScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYt
-ggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMc
-tMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaS
-acgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagac
-aKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaScttta
-ttgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaag
-gtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgct
-gcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatS
-RgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgat
-ccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatW
-aVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatg
-tgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaB
-tagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaV
-attgatttaagYctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKt
-YtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtgggagccaattct
-cDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatctt
-BtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgat
-tBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaata
-tttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgaga
-BgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBgg
-KaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgat
-atgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagat
-atcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYa
-gttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtH
-cMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaat
-atgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattg
-gatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaB
-BacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgat
-gWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgct
-YtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWt
-tggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaa
-acaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtag
-RgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHa
-aScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagt
-gKtatgattHcYcttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaa
-ccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDc
-atYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBM
-agBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaat
-actRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNc
-cagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataK
-caHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcM
-cgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaa
-aYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDt
-HatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtR
-atcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgH
-aRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKga
-HWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtSt
-aVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDa
-RSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacg
-catgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgc
-HcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccg
-YaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMat
-aatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtat
-MRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYc
-gccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaag
-tgttcacatataaagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtB
-ctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBta
-gtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatca
-cMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgtt
-cctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgSttt
-NaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttt
-tcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattagg
-taatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatM
-ttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNt
-aYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatM
-gactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtS
-acgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtact
-ctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgta
-tccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKB
-BattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRt
-MtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWa
-ggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKag
-WattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggta
-NgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcV
-tBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtB
-tagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcg
-ctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKt
-aaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataW
-taWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcg
-atacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgN
-atSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttS
-agccatRtatatcactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcc
-tYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaa
-tgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagt
-aHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcga
-cctgcaacgttttattacNMWNcattataDVDactatattatYattttgcgaagtgagYV
-tagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaaca
-tccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactg
-tNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaDttWactttgaSt
-aaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccg
-gNWaacatacatgttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYt
-aggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYa
-MaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagt
-ttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgt
-cagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgac
-aaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtc
-gctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaag
-SacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgc
-HctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSW
-tctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatY
-SaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBa
-YtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgKgattgacgaccc
-ccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgc
-caactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgct
-tatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNt
-ggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacg
-aagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNa
-tttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtg
-StcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgc
-ttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagcta
-aagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBcca
-NagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStS
-cRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSgga
-aaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacat
-cgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatc
-tggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcM
-gNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaa
-aaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatat
-catttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgc
-aMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaa
-gtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgtt
-gtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggacatcgccWttagtt
-gWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgS
-attRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMac
-WttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKt
-aactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgtt
-ggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBN
-WtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactag
-cgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataV
-aggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaata
-gttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggta
-WSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacata
-atVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgc
-cttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtcc
-agaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaaca
-tKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaattataactcagtSga
-tataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacag
-gaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaB
-taggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttK
-ggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMg
-gMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRc
-atctSDcHcMgcaactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKc
-tSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBa
-BtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMt
-MaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaag
-ctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKt
-ttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWt
-aSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatg
-gaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaH
-NHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaag
-RttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaa
-aaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacK
-taacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatga
-attatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNB
-aatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattt
-tcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNt
-ttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgctaatWDataattta
-gaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaa
-ctHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggt
-HBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRcta
-caataKatattctaVgtgtaattRacKagttattgaMtaatgaNatacDataaggacttt
-ccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattgataaaactggat
-cactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaatta
-ttWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagt
-MWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDc
-ccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaatt
-gSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcct
-BtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtM
-tKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVa
-tgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNac
-attRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBata
-tgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcg
-cagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcH
-YtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccData
-NactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttc
-gtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcga
-atSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSa
-tRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatataca
-atacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggata
-WMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaat
-HHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYt
-atKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaR
-aaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtata
-gKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccacttttctatacta
-gtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactg
-ttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaa
-tWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcata
-gBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataK
-tatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHa
-aaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatY
-tacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRY
-aDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatV
-atcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDt
-tgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctN
-ataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagg
-gaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaa
-tVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtt
-tggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgt
-ctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgcc
-gttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKta
-cgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgB
-tcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKc
-tctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMc
-tttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgcttttt
-catcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatga
-aattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaac
-ctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYa
-tatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtat
-aaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgta
-gaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggt
-aactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMS
-tatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcat
-agaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVH
-aaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMtta
-gcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgta
-aaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatB
-tgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBR
-BttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtataca
-ttaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtct
-ttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRt
-tWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaa
-tgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaa
-aaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaY
-BgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaH
-ScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKac
-aBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaaga
-gaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDac
-tccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaatac
-cgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVa
-tDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgact
-acaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRga
-actgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattStacctgaattctW
-atNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaatt
-ttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttH
-aatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaag
-atgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVc
-MNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaa
-MacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWH
-ttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagW
-gcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctg
-VcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMS
-gDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgac
-tMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMccc
-gtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgND
-HaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatg
-atttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaa
-gScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaag
-tgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatc
-SccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWt
-KgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaN
-HYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHctta
-catcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVM
-tWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttattta
-gtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgttt
-aaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaV
-atcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaa
-tcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatB
-gaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaB
-tgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatM
-aaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaD
-agttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtg
-VcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcg
-aaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgct
-ataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVB
-tgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaat
-taaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNa
-KagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgW
-ttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWH
-tcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggt
-NttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaagttataNaataS
-atacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYt
-MtacKacHttttKtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaat
-cccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMt
-aacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtac
-taVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaat
-caYtSgttttataaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaata
-ttacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcD
-MggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWc
-tYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtg
-gaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtacta
-tatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatat
-gWtacaaaWttggaaactttaScataactRattMtDacVYataaaagMaattttKtgaBt
-tKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaa
-tKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaa
-tatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYc
-gtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMtttt
-attaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttaga
-gcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacW
-tttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgcc
-atatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHK
-ttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactc
-ctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBat
-ttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacg
-aaaggKttacattgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSat
-ctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctat
-tKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRB
-atataWaatKctcattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNg
-RVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtat
-RatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatS
-taaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgta
-MccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcac
-ttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagK
-tWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgt
-ctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggt
-SatBMBDactVtggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgt
-aKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttga
-acNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBR
-ttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatga
-NHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgtttatRatctattta
-gacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaR
-tcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVata
-aSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtS
-aHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDt
-caMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMc
-KaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgat
-cttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHaga
-cagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaa
-agggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgV
-atccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggct
-taHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatt
-tMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaa
-aNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaat
-tcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaacca
-tgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcata
-taatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcat
-VtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaa
-aatagStcggRttaattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgB
-tgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVca
-tattttagMcgtattNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNa
-aDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtac
-YVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttatt
-WtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHB
-gttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaat
-KtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNH
-tacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMa
-atNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHct
-aaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcD
-tMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaag
-ttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatg
-NatSYaattRatgcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRt
-ctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYct
-aWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHa
-aStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYctta
-ctttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctc
-ccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSat
-tVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacg
-ttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaR
-YtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHtttt
-BaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctct
-tNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBc
-aagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgt
-ccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcg
-aaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgg
-gRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaac
-ctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtga
-BtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcctacgagatcacc
-gtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaM
-taattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcattt
-aagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaa
-DtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaa
-ttKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYt
-tttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcg
-tttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaa
-KgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagt
-BgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagt
-NtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttcca
-tatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtag
-cagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtt
-tHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatatattattataatt
-BatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDcta
-caaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcat
-tatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaa
-gactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgc
-DagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaattctctaaMata
-ctaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDta
-gaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcg
-tgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaat
-gaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaa
-agaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtcc
-attataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSSt
-NtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSV
-YKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagY
-HaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaatt
-DtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBg
-gcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctg
-attatagattagtatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgtta
-agaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcattt
-aNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBat
-taYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaactttt
-acaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKD
-ttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgttt
-KRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRW
-cgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtat
-ccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaag
-gtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaa
-YtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagcca
-gcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBS
-gtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatD
-aYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBt
-acctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRcta
-KtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataag
-tgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacH
-agHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagc
-tRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatt
-tVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVB
-ttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagaga
-aaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcN
-attgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttt
-tacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtN
-MttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaD
-acataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVtta
-agaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKc
-aaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctag
-tatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtc
-WaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgat
-ttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaW
-gaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattc
-ctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRctt
-NgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWca
-tcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHa
-atgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtac
-gaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMta
-cttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaH
-aggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNK
-gatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYa
-tKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDta
-KgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRta
-RaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgt
-aacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagag
-StHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBtta
-BgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaY
-aDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtc
-gMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHta
-ataagttStccaatcHataatacMcattHtacaatttctgatggacatatgcaaacaKBa
-tgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRga
-gaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtB
-RaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVta
-taSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHct
-HtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSa
-atcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagtt
-VacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacN
-taHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacg
-DatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagta
-tatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagV
-YVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatg
-SStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStg
-aagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatB
-ttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggca
-gtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHag
-tcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNg
-StggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYt
-gtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagc
-NttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacD
-ttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNtta
-VtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRM
-gaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKW
-tDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctVtaaVggatccta
-HVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccata
-ttacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgS
-aaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggta
-aagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDac
-acVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaat
-agaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDt
-WtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRac
-VataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaa
-tMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaa
-aattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYW
-cSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggag
-ggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttcc
-KtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagag
-aSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcat
-taaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHc
-WgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNat
-gaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactcc
-gSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSaga
-tcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgt
-aaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatW
-tHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNat
-tacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKt
-ctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagac
-cKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMW
-YctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNca
-MWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYtt
-cYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRta
-NgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVg
-RgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaag
-MaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBV
-atHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNttt
-gatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaa
-KtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRt
-aatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgt
-cRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMt
-aaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaa
-ataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtgga
-tBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHa
-atBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacga
-RaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggt
-ttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSa
-gcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSa
-aWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtS
-BMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaS
-aagtttattttatgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtga
-tDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRV
-gattctatgtgtatHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgt
-cagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagat
-tttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtact
-tcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKV
-YaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWM
-aDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtc
-aDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccgattattRStcca
-aaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMY
-SWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWact
-ccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaa
-tgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNK
-aaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaK
-taatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtD
-ttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccat
-atKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHSt
-ttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttc
-WaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaV
-cacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKg
-atcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDatt
-HDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtSta
-VttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRS
-NtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNtt
-agaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaa
-agtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaa
-atgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNg
-McgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatataattggVgaRctR
-tcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatca
-MSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaa
-aagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacg
-taaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtata
-aatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtt
-taacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaB
-acgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDat
-ttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttat
-tcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWN
-WgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDV
-taatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBt
-ctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYt
-ctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagttta
-aKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatc
-aVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWag
-aaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcY
-attgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagN
-tgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacK
-cttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccct
-ggVattHaatVagaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWcca
-tYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtatta
-YcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggcca
-cgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYaga
-HtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaa
-aaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBgg
-ttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgta
-tggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtH
-tHttatYaaagcagatgtgattagtggcactactVattagatctctgtttatcattYttg
-atHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVt
-tcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcc
-tBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaa
-gactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactcca
-ggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaat
-aKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttH
-attcatttatYtattagtataYtttagYcattagaaataHtaaccttactcatYttHMRa
-gttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaB
-aaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaa
-aattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNta
-atatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWat
-ccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWc
-tttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccV
-WaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctac
-atgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBa
-ggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcag
-ctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgt
-caWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactS
-HctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatat
-aatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBW
-aBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctg
-tcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaD
-tKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaW
-ataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatSt
-RgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgt
-ctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDt
-tcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtat
-ttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggta
-gtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgc
-tctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtg
-tSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtat
-atataVtagcgWccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctct
-acatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaa
-cccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatH
-attgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgat
-ataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtg
-gRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacB
-tWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtat
-gDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgt
-RtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttat
-tcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHaca
-aaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttag
-HcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSa
-ataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttctt
-gtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaa
-aaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRc
-VctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNM
-actactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaat
-aagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYc
-aaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcM
-aatttWMggtctatttggaKagaggatWcatttgctatcgcccBacacttataagaYtcN
-cagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaa
-aHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRt
-tMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttR
-agaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgH
-atgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaata
-tDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRat
-aBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRa
-HtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccg
-aMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgc
-taVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcaggg
-RRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaact
-aatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRat
-BtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagac
-gaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacg
-gcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHB
-cgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHa
-ggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKga
-atatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaataatatgttttt
-aagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNtt
-DWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaStt
-gatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatg
-taRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatN
-ttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYB
-aHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatM
-gaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatV
-WaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggt
-atRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBa
-taaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVB
-tagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMagataatgactMBat
-BctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaa
-ccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaag
-RSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgttta
-DccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgV
-ttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatD
-tVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSgg
-agttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVt
-aattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaW
-tattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcg
-atHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtN
-attStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKS
-acaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKcc
-gHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaa
-tatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNatt
-ataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDgga
-aagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaV
-taattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacaga
-taaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttg
-gtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataat
-WNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttgg
-ctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaat
-acaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaa
-BMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctt
-tgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcatt
-caattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattac
-aWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttc
-gaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgag
-KRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggc
-taggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaW
-taggattScaStgattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBY
-KKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNa
-RgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggc
-aaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttc
-cRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtct
-gRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWt
-catHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacgg
-aaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWa
-tgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatg
-KgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggc
-tcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtc
-aaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatca
-DMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatV
-ctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttatta
-WMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggat
-acaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHc
-taaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatacattNgttagagN
-ctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaa
-aRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtat
-aMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagc
-atgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattca
-ctaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBttt
-cttagaggVttcaatRattNtccatttcagctactccacMatSHtagataaaWgaagttt
-gDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgS
-acctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaac
-NgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagSt
-aaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBt
-cccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMN
-NcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcg
-ccttttgtBtatatttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaV
-VcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcata
-cgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDa
-NtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactcta
-agtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStc
-atgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgc
-ScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgcca
-ttacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHata
-tMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggat
-gVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaD
-taaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttK
-caaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVg
-ctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYc
-StactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDSc
-ttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNa
-ttMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWt
-BataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccg
-acKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaSt
-ttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVat
-ataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctg
-caMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaH
-DtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaag
-KtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctca
-SSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcM
-tMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNta
-agctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWB
-SNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttt
-taccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWt
-tgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDta
-cStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaa
-attatYNtYctagtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgt
-tttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccatta
-caBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKt
-catctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattat
-cMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgctta
-tctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgtt
-BDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNc
-aaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDt
-gtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtct
-ttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatN
-ttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaa
-tcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaacc
-agtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagta
-gatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcg
-cNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacH
-RgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDa
-DVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHg
-gtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagta
-attWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaa
-ttcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcga
-WgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDa
-NtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgact
-ttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaKtcactWaataat
-YgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataR
-aaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBcta
-ctacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMa
-ggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtg
-tgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRSca
-gDtaKtatttYaSctttctcatccttaattagttaaatactgctgNcttgctcatatata
-ctaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcK
-tacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRa
-YaatattWttattcttataatWatattaccYaagWtgaataatgatttgtatBYSaDcta
-tRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYY
-atattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtV
-VgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRt
-gctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDR
-agBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctg
-cMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaa
-tBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWatt
-gcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgt
-agtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgc
-cggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDa
-caccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattD
-taagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatSc
-gatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWc
-tcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBt
-aScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSga
-aWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcac
-atatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaa
-gKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBat
-aRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYtta
-gNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgt
-aMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWS
-gWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagat
-acNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaH
-aYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMa
-cagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgatta
-aKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatB
-taattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMR
-tgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScga
-tgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgt
-ttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatat
-gDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaa
-gagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatca
-aaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaY
-tctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaH
-KaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaac
-SttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgata
-cSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYac
-taaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHcc
-acatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaa
-gtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggt
-SaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaata
-WacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttW
-agtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctt
-tgtgacgaBttttccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKH
-aacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgct
-agagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtac
-BtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataSca
-DaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataH
-tgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtW
-gatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDg
-MatgagatctKttaHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWS
-gtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtac
-gtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgc
-ggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWD
-tSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKg
-ScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaa
-ctattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaag
-tcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtc
-KaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVat
-BaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccR
-tHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVta
-aYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaN
-tDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHta
-ggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVtt
-aWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaV
-VgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaa
-taacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHB
-catcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccB
-tccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatM
-aaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaH
-aacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatg
-MacataWaaMtataggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacg
-aVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgt
-atRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaD
-taattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcat
-taSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWa
-taactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtY
-tctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaK
-gaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHttt
-DtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaS
-atYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaat
-BgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattact
-caaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWt
-aVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMac
-tKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacat
-aWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHa
-ggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgD
-DcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRac
-tHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBg
-cattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggta
-gVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaB
-gDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNt
-ttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaa
-ttgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaa
-tRcacttgttttcaaattctggcccttttBgHccatcgaWctataSttBgataacagtac
-ggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBt
-atcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaata
-gaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccY
-tgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgc
-agNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRM
-tgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDc
-agaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVat
-ttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcgg
-aMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtact
-ctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttat
-gtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaD
-agScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWg
-HBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMat
-HWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatV
-tatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcatta
-BaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcc
-tcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctK
-tDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacStttt
-atWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgttt
-KMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgt
-YtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNta
-aatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMS
-tgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMta
-DtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKtta
-cMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacR
-taDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactc
-atVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKS
-atcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNt
-aatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWc
-tWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatat
-ctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatacta
-aWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctca
-ScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtV
-StaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttct
-tatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHt
-ttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaa
-attKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacat
-tatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtga
-tataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgta
-tWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagct
-NgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaa
-aNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgD
-gcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaaga
-tMcacatBatgtStctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYa
-YtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHcc
-RBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRatt
-NcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRB
-ctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWact
-tctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWH
-tYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWa
-attcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagt
-aaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgH
-ttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacag
-gtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatg
-DKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYt
-atVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagt
-aDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRa
-atctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRta
-agtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtc
-caMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgYBtggcatRtact
-tBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaagg
-ttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacS
-RtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMt
-tRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVct
-ttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMc
-VaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgt
-aaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacg
-SaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatg
-gtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaac
-agaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttga
-tgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagc
-cgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaN
-tWVcctacatacYtctgKtcattatctattatcgtcKtaataaattagggHctcatgHtt
-SNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBca
-tcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaa
-gttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcat
-tggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBgg
-tccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaa
-BaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcRYttagcatactt
-tagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKatt
-HgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtca
-tactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatag
-caaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHt
-ttagttttataatRWggattYatatMaaaactWaDRaggataaWgMataggtactatatt
-tVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaatta
-caKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgat
-tYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaa
-cWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtc
-taatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaata
-cgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYta
-gataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatgg
-tacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagct
-cVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRaca
-VcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgc
-WtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaat
-DttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaV
-StaatcctcDagtcataagWtataatattacagScHaatatagcaHYaaSagaaaaactY
-tRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKt
-tccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNg
-caSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHg
-WggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBa
-aatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMt
-attagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWat
-tatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHt
-SaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVD
-ggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctStt
-ttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYY
-acSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKat
-aaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcag
-ctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaa
-RttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttga
-gaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMV
-ctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtD
-aHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMt
-aaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagta
-BttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaag
-tagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgH
-actatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatc
-tttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtt
-tBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaB
-ttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttcta
-aatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagN
-aggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBt
-tMacatDtatttaaRggattatBVcacattattaagWctactVcaBgcttKagagttatR
-BgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacD
-aaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcatta
-acSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaSc
-aSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattag
-gagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatc
-RRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtct
-ttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataattBStcaatttaW
-cattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtc
-atagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYattt
-DaaatcactKatWatcDatatRattataaatatctattHSctttggNctaagtSacgaga
-tatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRa
-VgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcc
-caRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaata
-cccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaH
-acaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWK
-cagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaa
-gtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYta
-tcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatata
-HaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttatt
-aaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactag
-KgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtc
-tcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaY
-ataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDc
-ctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaata
-atVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNa
-tcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNata
-caagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBD
-KVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaata
-gatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagt
-ttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaa
-agataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWccatttgtgaccttt
-MSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgN
-tatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacg
-tacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgtta
-tRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagV
-RBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHg
-KtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKg
-VaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtB
-ttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttga
-gtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYag
-taWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYg
-KgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgat
-gtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctc
-DtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgD
-gtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMa
-MtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaM
-gVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSY
-tttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgta
-tBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttcta
-ggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtS
-aNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRYaatggtaVttta
-aaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWcc
-VattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacct
-aaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNt
-NgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaac
-MRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaa
-gtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaa
-aVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataY
-aBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttag
-ccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgc
-BttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctag
-atSctaactctDttaagacgcatagcRNgagatttgtacattSattaacttttcgttgat
-tWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDSc
-NctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctaggStatttacaact
-cKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgc
-ctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaaga
-gataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVtt
-aatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtY
-ttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaat
-gaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVt
-acaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtac
-atatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWY
-RatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgaga
-BDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStatt
-cHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMa
-DctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcag
-HctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacg
-BaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMW
-atttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVtt
-cYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataa
-tgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYt
-SWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtatt
-atYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVt
-aNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaa
-agttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacatta
-ttgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSa
-agttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgta
-HaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttattt
-gttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaa
-caYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaa
-VDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatS
-tttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaS
-aVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHta
-gtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYW
-gRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMcttt
-cKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttct
-gtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaact
-taBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSV
-RMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaN
-VtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMc
-atagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctgga
-YattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWY
-KDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagt
-aaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaa
-gaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWM
-aaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaK
-tKacNVggaatYttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKD
-gtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttat
-WgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaat
-tttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtc
-NaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcV
-aYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVg
-agaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatt
-tttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHata
-MtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYS
-HgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaatt
-acYSattatttaYtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaa
-YccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaa
-atactcgtacttttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWg
-BaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtS
-taaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMga
-BtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagaca
-YaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccg
-taBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDa
-VaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatt
-taYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaB
-aaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYct
-tgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStat
-tatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaN
-NccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRV
-taHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMt
-agMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatat
-atattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMta
-attaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatc
-aBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaag
-aaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWga
-agcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagN
-taMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagM
-aggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttct
-ccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatga
-gHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNctta
-RattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttga
-acNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatacta
-ttWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaa
-aKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtg
-ggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatatta
-gcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBH
-tttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMg
-attVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcat
-taatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgc
-ttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaa
-cSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVgga
-caWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaat
-atgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtH
-ScgataaNcBataggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYc
-gctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaB
-SKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMaca
-WNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYata
-StKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaat
-catattcatSaYtgWaDacgaataactctggaDccattacgSagaaattgatttaDtHac
-gtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcV
-NWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttcc
-atactHgStagHcaattaagacagaMDtttagcHtgccctttattatSatWataBaaSMa
-ccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagag
-cgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHtt
-cataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDS
-tacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHat
-aatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMW
-VtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMg
-tatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcD
-gtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccW
-acaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRat
-KagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgt
-agatYacactYSBDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNt
-taHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDct
-tgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDc
-ggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttc
-tagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatg
-tttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatat
-agWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKct
-aaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaa
-caaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactK
-attaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtat
-YcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatg
-ctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgB
-tDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatct
-ctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgt
-HgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKat
-taVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtagga
-aatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcg
-tatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaa
-atKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgtt
-ctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaa
-aaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYc
-MagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWN
-aactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgct
-VaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVac
-aNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgM
-aMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgN
-aaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacaca
-StaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYt
-ttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttR
-ScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtK
-ataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagata
-tttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaat
-atgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaa
-ttVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaaggg
-ataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtc
-tattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttg
-HtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgact
-aNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaat
-ttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactac
-cYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcg
-caaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRD
-aatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSa
-ccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaataga
-atNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKtt
-aaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBt
-tDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcatt
-cacYtattggatVgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtg
-tMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtN
-tcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaB
-attaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtN
-cMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKV
-NaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagattt
-agttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNa
-tVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaB
-tMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWat
-tagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaa
-catcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacg
-HtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDta
-taacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatW
-ggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctD
-gBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatg
-aagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHat
-aRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScY
-tSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgt
-agttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatR
-aggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSS
-aaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagg
-gttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatca
-tacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagtt
-atSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRatta
-aaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaV
-tKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtcta
-gYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHg
-gttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScat
-NtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttg
-ctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaat
-aaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaa
-tttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttt
-taStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatatt
-aRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBcc
-WDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDc
-caaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttag
-ttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttg
-taaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaY
-tVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMY
-ttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWa
-HctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttc
-aWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattc
-attttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgB
-gtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaat
-aagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtg
-aRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaa
-gcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatg
-tcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttc
-gaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBc
-WVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactga
-ttStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctV
-attagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagtta
-NttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttct
-aaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacSc
-gaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctN
-atYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYaca
-atgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMct
-atcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctc
-atatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHca
-cgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHtt
-agctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggtttt
-ctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatS
-aaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattactgtaKtNagaacc
-DaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactat
-aKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNt
-aaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWN
-DataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWgg
-aacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScV
-NaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatcta
-aaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNa
-DttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHa
-WcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatc
-agatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgc
-KataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattga
-gtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaacta
-gtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttat
-cBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaD
-gNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBK
-caMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatag
-ataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVac
-McBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWac
-gtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWa
-tgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacat
-tSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcg
-aatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcat
-ggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaat
-atRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHg
-cVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaK
-tgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWcct
-tgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKga
-KtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgM
-gtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttata
-VcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaD
-MtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHt
-taaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaat
-tcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKa
-cBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtca
-agcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtt
-tggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgtta
-aVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSSt
-aYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHat
-atBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRta
-tagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRtttt
-ttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYc
-aaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNt
-ctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgt
-tgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKN
-ttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataa
-tatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagc
-accaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHa
-gagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttagg
-atSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagH
-KagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRa
-tBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSg
-cgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgctta
-acgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataa
-gtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHagga
-NcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNa
-DtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgt
-tgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcat
-RacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcR
-WMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHa
-ctNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVa
-cctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttg
-tcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaacc
-ctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKa
-agMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcK
-tKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaa
-RNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMa
-ttDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaY
-agRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttV
-MaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYt
-cagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRR
-aattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattg
-cttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaa
-ttYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKt
-gaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNtt
-acgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattc
-aaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNa
-aaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttD
-gWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtac
-cWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatac
-gaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMt
-atataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtata
-VDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtcc
-agHctttMtattgtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtac
-ctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVat
-VtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKta
-ctctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDtt
-atMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaS
-gDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtat
-VatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaK
-aHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVa
-cYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDa
-YtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtB
-tatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWR
-taatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagta
-gctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtt
-tgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBat
-gtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattca
-gaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHca
-YNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKca
-tactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacK
-tWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccagagttcaKcStacc
-KggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtattttccttcatcta
-cttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacc
-tVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgc
-aaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaa
-ggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgt
-MatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgata
-NWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattW
-YcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtt
-tagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVK
-aMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtct
-YcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDag
-ttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcaca
-tNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaK
-gccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttW
-cacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNg
-DagatWtRttSttNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaV
-cgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDac
-ctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttc
-catgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaH
-ttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVg
-KaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaaca
-ctMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgag
-gaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttc
-tVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaat
-tatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggR
-tttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMata
-aHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaN
-ttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYta
-ccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVatt
-WDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaV
-McMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaa
-gaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRD
-aRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgB
-taaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBN
-aKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaH
-VaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatg
-BaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcagg
-aBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNttt
-agtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaD
-gaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgat
-gKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataa
-tKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtY
-tagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaK
-caKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattt
-tgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacV
-agttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgat
-tcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgct
-aaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagat
-aDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgacc
-gtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactat
-aDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRa
-gattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatD
-taVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaac
-ttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNg
-cKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMa
-gBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaB
-ctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWt
-ttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtca
-ttagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttca
-ttaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKac
-ccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNB
-acagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgta
-cVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgY
-taaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtc
-actYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaM
-gccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNc
-aaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagact
-tcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRggg
-attttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgt
-acggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMat
-gtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaD
-aatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcat
-ttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaat
-tDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDV
-tNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDa
-tYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcc
-taBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtM
-ttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKttt
-agtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttattttt
-ttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgatt
-RttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaata
-YaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWS
-gctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtata
-tgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNta
-ctHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagS
-tatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBc
-YtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSV
-agaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYt
-aMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacac
-tDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHat
-agaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgta
-aDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttga
-KaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtV
-KgHtcRattactctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgt
-tMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgSt
-gtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaa
-StctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgct
-gagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNttta
-gacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHa
-gDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttct
-DcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaa
-WtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatD
-gaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcga
-ttaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaa
-RgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgc
-HttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcactt
-DattYttaVgRcacaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaB
-ccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgt
-tactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaH
-gHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaa
-acgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagt
-YNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtH
-ttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgat
-cgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagtt
-ttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaat
-actgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgt
-atacMatcaaactagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaa
-StacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHata
-accRttagatataaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMc
-aWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgt
-ttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctg
-tgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcS
-HgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVt
-ttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagt
-ttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWc
-MSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNtt
-aYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcgg
-KKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctg
-ctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctccc
-acDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVSta
-tagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggc
-ccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaN
-tDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHt
-KtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWga
-taMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaa
-gcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagat
-tcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgg
-gaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggca
-taDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtt
-taaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtt
-tcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatga
-gMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMag
-aRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSB
-ggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtt
-tBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMa
-aKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatct
-tHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataa
-cDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatc
-tRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBa
-aatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatc
-cScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttg
-taatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgt
-aBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaaca
-MataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStc
-NcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacat
-tggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaV
-KtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggtta
-tttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSt
-taaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWg
-aYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSg
-RaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMc
-aattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVt
-atcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataat
-tMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSSt
-MatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaD
-gaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatt
-tttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaY
-aatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaat
-aaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcg
-agccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcataca
-HcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttc
-cWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWV
-acSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattH
-YtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWt
-YYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttc
-tgctaYttBataaRtattgatgaaactagttBgagtcttccatBagatctBaaagSacag
-taaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggK
-aacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctc
-ttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHt
-ttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaB
-tctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWtta
-SMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatR
-acatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNt
-ttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBR
-taaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccD
-aaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNta
-WatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaac
-VttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNct
-gSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatc
-HtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatct
-tcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcY
-aRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDc
-agBaagtctSNagaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHt
-taKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttcta
-gYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaa
-MaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacc
-cStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBa
-aaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacK
-aaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaK
-cNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaa
-cttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgata
-taBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKa
-tVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRaatBattWVactt
-WVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttag
-tccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatc
-tatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataa
-agVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNc
-cttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgata
-YgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWa
-gaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaata
-aNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDND
-tBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDa
-gNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatt
-tctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaa
-YcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKtt
-BtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgN
-tScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtggg
-tNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBa
-ttaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctV
-HttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSg
-ttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVg
-MKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttB
-tgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtga
-cgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaag
-tatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacag
-tcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtat
-cgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtc
-tcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggD
-gctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVa
-BgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaN
-cBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaY
-ggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKa
-ttaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgta
-ccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatV
-attttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMa
-aRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaattYKKtgatagc
-MYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgt
-WatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYt
-DctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaac
-BtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgca
-gtttctttttMagWttatRggcattattVaagaBBttatctattatMcNtaacagttgaa
-aBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaY
-atgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHag
-aacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatc
-tggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDag
-YttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatct
-tDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWac
-HagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgact
-attcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtc
-ctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgcta
-cWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaatt
-WRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKY
-gtYSaMtgataatNggattKNgaSggactaaBagataacactcataVgttataaSacaat
-cRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggat
-aaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattac
-attgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaY
-HWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtata
-ttacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBt
-atccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVa
-tagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgag
-taatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgt
-tRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWW
-agccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKt
-aHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaa
-tatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaat
-KDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVatt
-attaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtgaatttttKtStat
-atttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatctatKatatgaaca
-actctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttatta
-tgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaa
-VcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMttta
-tSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaacttt
-cgcttttccatttNaaYgtattttactttacttRataBttgatagggacattattaaSaa
-aYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaa
-MtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDV
-ttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacV
-aBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSata
-ggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaW
-ctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNtt
-atWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKct
-ggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggt
-gatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaV
-HtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaN
-NgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVc
-agKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttatta
-RKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaY
-tttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggtt
-aaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaa
-gattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaM
-aStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacK
-tttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVD
-ggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtat
-NccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaat
-tggagagggtctagtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDc
-DRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgW
-aHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatag
-ScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBt
-tgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttacta
-BgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataS
-tcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMt
-WatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaa
-RaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaa
-agVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagat
-tWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBS
-gaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRatatKVtactata
-tttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattaca
-RNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggg
-gVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNa
-MRaacaaacaKctacatagYWctgttWaaataaaataRattagHacacaagcgKatacBt
-tRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaB
-SaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagt
-gcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRct
-tactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataN
-DaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYV
-tNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWt
-actNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtat
-agYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaata
-YtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtc
-attttcWattRSHcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccg
-SKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctata
-ScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactN
-tatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaaacatacaHactM
-acacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgt
-cagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagtta
-ctcttcattVtttHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMa
-HWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYtta
-aatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgtta
-tcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKca
-VtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatg
-catttNattaDttaattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHa
-gaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNH
-ttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVg
-agctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgat
-taVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatc
-tgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagtaaVctaggaScca
-atMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaatta
-aattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgct
-WtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHH
-KaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaac
-cactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaD
-MtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacga
-NtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaata
-KgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcat
-aWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYac
-ccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgV
-HDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVcc
-YcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWa
-cattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcg
-actatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtatt
-aMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRV
-taaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtact
-aKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWY
-NgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVg
-gacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgD
-gttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggW
-YaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaat
-taatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagatt
-acVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYt
-tattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWct
-gcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRc
-caVgggStctDaacataKttKatttggacYtattcSatcttagcaatgaVBMcttDattc
-tYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctg
-ttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRct
-WatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagt
-aatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaa
-aaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKK
-agcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatct
-RatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMg
-atNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgD
-tttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVct
-agtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtt
-tatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaat
-tYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctga
-aMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaagg
-tYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaa
-VgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaattt
-acDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttca
-aMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcac
-DaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaN
-SYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattct
-MKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaac
-attYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatM
-ataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatR
-aVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttcca
-KtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtat
-ttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDS
-KatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatK
-agStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtcta
-tggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataat
-agatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaa
-tgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgccttt
-atMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatc
-tNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtg
-ttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggt
-VtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatact
-tgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHac
-cHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtgg
-caVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaD
-aagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaa
-aatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHata
-agtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHt
-aKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMt
-tttcRaYDttgttatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDt
-cNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttg
-gtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKN
-taaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaB
-WggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDN
-atttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSW
-DRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttB
-aaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWa
-tBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaD
-ttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaat
-taagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaa
-aacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccgg
-ttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMa
-taHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatW
-ccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKD
-cttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctg
-aaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYat
-WtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacY
-gtaatataMagaatgHMatcttatacgtatttttatattacHactgttataMgStYaatt
-YaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatR
-acacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaV
-YatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatg
-ctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMga
-gSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagttt
-VctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttggSagagctacHta
-aRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaW
-gttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKtta
-cHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRg
-cggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatat
-DtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtg
-agaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgat
-aatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaa
-ttataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattt
-tatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDctt
-attNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgc
-NtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNc
-aNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcg
-tttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtg
-tKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaY
-gBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWa
-ttagttttNaggtctcaagtcactattcttctaagKggaataMgtttcataagataaaaa
-tagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtc
-aDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtc
-attcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtB
-ctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcat
-aVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttg
-atttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaa
-gaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBt
-tattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtc
-cattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMc
-NBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNta
-tttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBV
-agcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVta
-DtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgt
-aattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattag
-cSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtN
-agtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaaca
-StaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaact
-atatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtc
-agScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYga
-actcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDt
-aaactacagWDcYKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKt
-cgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatV
-YaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcc
-taNgagagcYgatattttaaatttccattttacatttDaaRctattttWctttacgtDat
-YtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWt
-aWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaR
-tagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaagg
-aaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacW
-DYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKa
-aaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYa
-tggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRa
-NaacHKtagactactggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactc
-acYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatc
-tYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgatta
-gcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgta
-gtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBct
-atcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacD
-cttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNM
-aVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRag
-agYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaac
-BatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaac
-ggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaa
-tagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggat
-ttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttgg
-aacaatDagtattRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgat
-catatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcat
-VgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRg
-aBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcK
-tcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgt
-taNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKaga
-ttaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttN
-ctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBata
-NaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaD
-BtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSt
-tMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacat
-tattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVa
-atacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMga
-acagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtt
-tcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKa
-aBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaat
-aHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSgYataBttBaact
-attBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKa
-gaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttt
-tgactatacataatcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgag
-aRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYt
-agSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtt
-tatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVN
-gctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaa
-gWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggc
-VaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRa
-cVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactg
-atttaatttWDccatttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtK
-taaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYa
-ttttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaag
-actcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKta
-aaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaa
-ggMaaaattttcWtatKctagDtYtMcctagagHcactttactatacaaacattaactta
-HatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYa
-tgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgt
-tcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagat
-HaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacS
-NtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSa
-acttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaa
-cagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKg
-gataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgc
-cgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVa
-actaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagM
-ttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaa
-HttRatctaYattaaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVa
-gttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctattgtMagagattaa
-actaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKW
-BattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacat
-cWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYR
-VacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttg
-attVRatNtctMtcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgca
-tgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcSt
-cWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtatt
-aaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtc
-aaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYa
-aVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtD
-cDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMac
-cDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDac
-gaKatgtatatNYataactctSatatatattgcHRRYttStggaactHgttttYtttaWt
-atMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDcta
-MtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgc
-aatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtctaactKataHac
-ctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattact
-MtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBa
-atactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWtt
-SttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaV
-ctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDct
-MYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaK
-atattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaa
-aHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKagYNKcattataNa
-RtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKD
-tStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaS
-taNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgtta
-gacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaatt
-gctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWat
-cgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBga
-cVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYga
-RttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgaga
-tYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacctNVataatHcccK
-tDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgc
-tcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWtta
-atctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgc
-tBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatg
-aatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaa
-cccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHattt
-BNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgta
-HDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBY
-RaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKt
-gaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaK
-atKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgt
-RattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYag
-tgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcga
-tttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaK
-caataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttY
-aKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYg
-tMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaV
-accaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHataKgDacatWcc
-ccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtc
-aatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaH
-ttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctag
-taWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtcccca
-agtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcg
-caRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMg
-tBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcat
-tSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttR
-tgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDa
-atactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataN
-ggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKa
-cataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKt
-NtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcW
-BataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattaca
-gKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataD
-atatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgD
-tYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNN
-VtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcH
-MVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDg
-tNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctg
-VtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVtt
-aagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaH
-cRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatct
-gtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaa
-ttttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatY
-gaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaK
-cKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtt
-taBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagV
-WcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtat
-tatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgt
-aNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtat
-SttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaatacc
-gtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttct
-atattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaa
-cagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctH
-tatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaac
-gttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWg
-ataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVa
-ctWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacB
-cgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatat
-gctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatga
-gcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtga
-ttDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaac
-aaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYB
-YaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcatttttta
-aBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttY
-gaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatc
-aagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaM
-gaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYg
-aatacaWVacVcRtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgt
-gattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattg
-YtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagtt
-aaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaatatgattagaact
-ccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaD
-aagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgat
-tgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcact
-ttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRV
-ttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRa
-tHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgc
-gatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttM
-ggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMtt
-acggctNVaacDattgatattttacVttSaattacaaRtataNDgacVtgaacataVRtt
-ttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtatt
-HccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccata
-RMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaV
-cacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKata
-tcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHa
-attagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctS
-gMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMc
-RggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaV
-VcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBat
-atatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctac
-ttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatact
-aaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatgaccYtacacttta
-attaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMta
-tWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatW
-tctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaStt
-gtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtat
-cgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatca
-KgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgt
-gNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMta
-gSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSa
-ctgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgt
-taacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttca
-RtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatH
-catcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgta
-ttMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaa
-HctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatc
-tggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDt
-tacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaD
-aaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttt
-taaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaK
-gttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaac
-aaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtctt
-RttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatH
-tgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttct
-ccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBt
-ttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagat
-aagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagtt
-agMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaa
-KgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKa
-aaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVc
-aDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagtt
-ggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttg
-tagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgS
-tatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaat
-ttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHactt
-ggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHac
-BttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaatt
-aHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtg
-ttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtg
-cgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtgg
-aatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaata
-taaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattc
-aaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattattKtRttNcggcR
-gtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRt
-BttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgata
-tatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHca
-caacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtat
-gaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgatt
-gaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttca
-tRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttt
-tRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttt
-taBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNta
-ctBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacg
-atttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaB
-ccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMt
-ttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVa
-atcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgt
-ttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctca
-atttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatc
-tttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNa
-aacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDc
-ctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStg
-gRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgt
-atgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcga
-DagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatc
-DaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgat
-tcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaW
-tctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaatttta
-tttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtat
-taNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttag
-aHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBag
-HaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWc
-WRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaat
-agattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcct
-gtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaat
-BNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaH
-cattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDt
-tgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataY
-aYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatact
-aNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcg
-aaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHgga
-taatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtc
-cDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataV
-aattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKatStatattcatHH
-RttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaat
-RHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKc
-taagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcg
-gSYtcttgRctataYcttatataaagtatattaatttataVaacacaDHatctatttttK
-YVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattc
-tgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSt
-tgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaD
-tagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaatta
-MtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtR
-aaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWt
-gtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMR
-taHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgH
-WNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHa
-NagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgac
-MtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagt
-ctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDc
-ttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgt
-tatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagY
-ataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNg
-acttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRt
-tVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagta
-gHagBagttagaccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaa
-BatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgc
-atggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMa
-aaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagK
-YYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaM
-ataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataa
-ccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDa
-tatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVa
-tBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgtt
-NBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcg
-taatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKc
-tVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatca
-ScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYc
-acgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKa
-RagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaa
-gWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctatagccctYttggta
-attKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWH
-ttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNa
-ctaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctt
-tagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaa
-RatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHt
-tttMgMagatDtataaattaaccaactMtacataaattgRataatacgBtKtaataattR
-gtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttg
-ttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMa
-ttBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattW
-tgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatag
-tgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgag
-DttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKD
-gatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaSta
-actScattattaacgatttaaatgDtaattagatHgaYataaactatggggatVHtgccg
-tNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggag
-tatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatat
-aacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttc
-taagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttH
-catSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaa
-tctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaN
-atcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaY
-gcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVa
-tgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBa
-cacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatV
-StgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVa
-VtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgc
-BHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgt
-RStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatat
-tagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgcc
-ttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatca
-ccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtca
-VtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaY
-agattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacg
-aWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatc
-taatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcg
-RggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgt
-gttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataac
-tWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggt
-atgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatc
-agttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtcctttta
-cDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctcctt
-NtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSY
-gctttcaHcRaattaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgct
-cttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttat
-aatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcg
-actatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataY
-tDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgta
-tgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMt
-agaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaa
-tYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtag
-taaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYattt
-ttgcDacHctWatcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaW
-YaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcSt
-atMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtaca
-tataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaat
-ttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagtt
-aggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSat
-atgcgttaBNggttaYVatgaactttttgccatataaataRatSaBctagttataBccga
-aacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVta
-gcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaa
-NaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtc
-tttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVtt
-ccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaa
-aHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataa
-BgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRV
-tcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccV
-StttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaata
-cccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaW
-atBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDatt
-atttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagt
-ccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttB
-gRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaW
-ttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaR
-DccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcac
-actBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBta
-HtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaa
-tggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatctttt
-aMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHca
-cSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaM
-atggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacM
-ttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaH
-ccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMct
-DaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacat
-gcatatMtttgtaacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRc
-ttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgW
-attgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRag
-KataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMt
-tcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKa
-tcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaV
-tatagcccaNRttaccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVt
-NagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgca
-HaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataaccca
-SattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtat
-tDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMS
-gKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVata
-tgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcga
-HttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttg
-gBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYa
-BtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNt
-gtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcD
-KKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgt
-gaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagt
-tMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaR
-taDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaW
-gtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaat
-aactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaB
-actWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDa
-ScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDg
-aggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcg
-MtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKcta
-KaDgctagacttattgattaaYttatcttattattStaattWaRaYBWagYaatatgttR
-gScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttM
-aaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMtt
-aaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNta
-cgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVa
-tDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMta
-aYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNcttta
-taggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaaga
-MtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactg
-cacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSa
-cYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWK
-gcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaag
-acactaKaagRtRataaattttcatHggtaataaatgataHtggctaacBacDgtaatat
-tRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactc
-gctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatga
-atttattcaaaattgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBta
-aSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgt
-NcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRK
-taRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcac
-aaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccD
-BtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgta
-DtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDa
-tccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagct
-aDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaac
-caKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtW
-ttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagc
-RattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaa
-aYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDgg
-aactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHatt
-atagWtKttaNgcDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYV
-tKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagt
-atagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaY
-DcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHag
-gKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgH
-ccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgY
-SatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaat
-tSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttatt
-aataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaat
-gMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagt
-gataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYc
-aataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtc
-gHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKg
-tgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagt
-NagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaatt
-SMctatatagaaYacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaaca
-aNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVK
-WaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgt
-HagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVg
-agtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttD
-ggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagt
-accNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaaactagatgVatt
-tagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcact
-gHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttattta
-VtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgagg
-tHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaa
-MccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDt
-aatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBga
-YtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagac
-tMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaN
-KHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgt
-DtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacag
-atgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactN
-WtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatR
-aBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtga
-tctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatat
-tgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRS
-tYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatK
-WatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKa
-tcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgct
-ScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaa
-tcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHtt
-YgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBc
-ttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtg
-tgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWttt
-MtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagct
-tccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattDtYaatattDacc
-atcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtgcSataaatattg
-aKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMtKttcatattaaD
-aSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcctVttaaNaggaa
-aagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaagatRDtVRacta
-YagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagacagtgtaattcaSt
-YttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNataaWtMNtDVgWt
-tgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttDatNttaaaDgRt
-atNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDattatacBattMg
-ctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYBaaaRtgMtatSR
-gaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaD
-NcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtgaaScaacctttRN
-atcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYtggattttcataW
-ttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMctMDtaaaatRtB
-aaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaSacgBtaaataaa
-gtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagacaKtagDtaaHaD
-gttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaSctttattgtcttttcct
-tRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaaggtcaSBttaaca
-aKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgctgcatttactttg
-tgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatSRgKagattgaVa
-tKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgatccatgagttgtW
-catYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatWaVgNHcagStVH
-cggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatgtgaatgacagtg
-aRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaBtagHactgKaat
-RtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaVattgatttaagY
-ctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKtYtYtagacgatt
-RaaYBtaStcttaWataatcHttataRcactgagtgggagccaattctcDtgDaggHcDR
-VaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatcttBtcttRgaWcaV
-RKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgattBtggacgtctg
-acaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaatatttgtWtttata
-gtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgagaBgRaaNttttMt
-MagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBggKaataBattYta
-attataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgatatgMtgataacW
-ctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagatatcYBttaatta
-ctcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYagttgBagNcaag
-aaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtHcMaBttcagtct
-tgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaatatgctatMcatg
-aaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattggatttaacBtct
-SMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaBBacaKtHtttca
-tgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgatgWcagggtcMBt
-gSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgctYtgcgaaHatDt
-atgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWttggSatBagagc
-HgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYc
-attgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtagRgagtHDgaVcg
-tgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHaaScataataatg
-tttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagtgKtatgattHcY
-cttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaaccgStcHaVBaa
-tcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDcatYHatatgcaa
-taaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBMagBctaaBaWtg
-atgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaatactRSgcataKc
-agcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNccagWttcgtatB
-cgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataKcaHVaggaatat
-aBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcMcgtcctaaVHtg
-WtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaaaYttgtagtcaa
-cWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDtHatattcgatNt
-tacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtRatcatctaaatc
-cMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgHaRttacatgaWc
-DtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKgaHWagattRData
-tcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMW
-aaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDaRSgaaKDtVaBa
-tcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacgcatgtcggaYgt
-aKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgcHcaaaattBtag
-cttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccgYaYRaaMaattR
-aagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMataatHgRtagcga
-KgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtatMRcgKccYcagt
-YcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYcgccagactcttc
-SatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaagtgttcacatata
-aagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtBctaataggtaRt
-aaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBtagtgatYcaaaSt
-actggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatcacMcScccVcgtV
-RRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgttcctaDNaattgc
-tVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgStttNaccattBMYat
-RtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttttcMtgaRYNaat
-aDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattaggtaatVcaNggaR
-tNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatMttYWtWttcctg
-aKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagW
-tHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatMgactatttatSa
-aVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtSacgaaaHggaaa
-tcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtactctagaacgcKaa
-DWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgtatccattgtggHc
-aatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKBBattaatggctg
-tHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRtMtWgggatcNta
-cacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWaggaYacttttKa
-cgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKagWattKtttaWgt
-agaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggtaNgtWactaWcgH
-ctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcVtBtctStWtaWM
-aBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtBtagaDacBtaag
-aataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcgctSRtacKgcac
-tacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKtaaKaccHaccac
-ccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataWtaWaMtgaataa
-gaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcgatacgtgtttat
-ttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgNatSaagtttHtt
-aNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttSagccatRtatat
-cactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcctYaacVactgct
-McgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaatgtNactaaBag
-atagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagtaHgacgMaaacM
-tacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcgacctgcaacgttt
-tattacNMWNcattataDVDactatattatYattttgcgaagtgagYVtagYaWaHaatc
-tgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaacatccgtYaBtVtN
-ccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactgtNaagNBcagHa
-DattaaaWttacacaaatactcaatSDatagctcaDttWactttgaStaaDtagatSaaD
-tgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccggNWaacatacat
-gttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYtaggctttggtat
-gagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYaMaYggttgtcaa
-agSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagtttgaMtcgcatc
-aaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgtcagMVSattatt
-taWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgacaaVRHttcSaSa
-atactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtcgctBtgagccat
-atScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaagSacScaaagagt
-agcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgcHctBcgYgaaVa
-cRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSWtctDgactaSHt
-tctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatYSaNgSagtatag
-atgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBaYtaaNaBtaNat
-actggcttWcaagatDctacggaNctatcacatSgKgattgacgacccccgagtNDtatt
-gagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgccaactKaattaR
-gacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgcttatKtcaVtVca
-gDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNtggWagSVaRttc
-MVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacgaagtcccRDVaa
-cBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNatttacgtcagtg
-aggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtgStcttWgtattK
-tSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgcttctatatHtaa
-tggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagctaaagtccMMtgag
-aagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBccaNagcSBgaMaDa
-VaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStScRaKatattaca
-cctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSggaaaaBcaggtHta
-tWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacatcgctcgDDtRaa
-tatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatctggtctttattt
-tatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcMgNgcgggagtct
-tRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagS
-DtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatatcatttatKtKaa
-aagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgcaMtcttSaaWaa
-aWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaagtgcgSSgaaVt
-gYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgttgtBcNtaatgtc
-acVatactgaaatMBttRRcRatccatagagggacatcgccWttagttgWttatKagtaa
-aagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgSattRaMtgaatM
-gttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMacWttccMVgtgaa
-ttctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKtaactttaatNaa
-ggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgttggtSatHtNNaa
-VagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBNWtaNMKcVcVSW
-tSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactagcgMNaaactgat
-aDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataVaggcaagHgaaS
-MSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaatagttHttattMBg
-agctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggtaWSatKgatatga
-gcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacataatVcacgattat
-aDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgccttacaaaWatt
-YWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtccagaKttSatatc
-aStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaacatKctacatHtaa
-aBtcNWatttBBaNatRcDattcgaactataaattataactcagtSgatataagRaYaKH
-ctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacaggaagtgataaac
-atBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaBtaggtaVatYac
-cNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttKggccagaaBcat
-agtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMggMtttataagta
-BgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRcatctSDcHcMgc
-aactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKctSHacctacacc
-actaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBaBtaatttSRcgt
-BgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMtMaVcgaattaNa
-agMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaagctaagatatatt
-McggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKtttcaYBaBttaV
-agtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWtaSggacggWWct
-BHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatggaaBDgWgHtcK
-StVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaHNHagcDatRcaa
-attcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaagRttaBcagVaYa
-HcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaaaaSKatHHttVD
-gtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacKtaacHtgHataS
-gVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatgaattatYcttKta
-caatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNBaatcDtacgatt
-gacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattttcttgaaaaact
-acccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNtttcttgYKaWta
-aBtttcWttagHtgtttctcttgtggctatgDgctaatWDataatttagaNcgcRRNata
-KtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaactHgaggctaga
-gHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggtHBVgttaattgK
-ttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRctacaataKatattc
-taVgtgtaattRacKagttattgaMtaatgaNatacDataaggactttccNtStatatKa
-agaataKtatggtcctctatgaggttaaDtgtattgataaaactggatcactKBtttggc
-gtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaattattWgaaBgactg
-aKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagtMWtcHgcattca
-caaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDcccctatgatVtt
-ttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaattgSttaaMcVtDa
-tttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcctBtccMaMMtaMY
-HaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtMtKcBtaNKaHSt
-gSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVatgagaaggtcaK
-SttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNacattRatNtgStt
-HVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBatatgSgattttacg
-tatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcgcagtgtgtMgta
-ttctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcHYtWMaMcgaacK
-caNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccDataNactttatBSDY
-atDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttcgtgataHDYaag
-ttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcgaatSctMaggVaV
-aaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSatRtagttttagc
-aaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatatacaatacactaNatc
-aVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggataWMtaattgtaaH
-tgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaatHHtaagRttDag
-tMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYtatKDtcatttga
-acctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcg
-cKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtatagKctaNtKaSVg
-ttcgagacattttRSatagttSacataMtaYHccacttttctatactagtatgaBaagct
-ttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactgttgacttYaHtS
-tcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaatWStaatacgNa
-agtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcatagBcaataVcHcR
-gcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataKtatgatcgtcVa
-aWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHaaaaNgaatggSt
-HgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatYtacVaNttctcW
-tactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRYaDgaatgSYcga
-ctgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatVatcttaaacRaD
-atRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtD
-gHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctNataaaaatatWN
-MtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagggaaSatgMYBcK
-BBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaatVgVaKctttNg
-tttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtttggtctacNttg
-NgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgtctSttYctgatt
-VaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgccgttacgcNatcH
-ctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKtacgtttStagKgt
-ctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgBtcctaatttNaa
-ttgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKctctttNtaacHa
-cNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMctttaNVgaNtcM
-atcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgctttttcatcYacttaKt
-tatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatgaaattaattacgV
-NaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaacctcWctHaatct
-tWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYatatcKBgtcttt
-atgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtataaaataRatHat
-KgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgtagaHcVctcYggg
-ccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggtaactBcaMNNct
-agaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMStatacDttataa
-aVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcatagaattMttgtH
-tMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVHaaStMtaaagcc
-ccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMttagcttacNcgaag
-atRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgtaaaaagttaaWaa
-agtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatBtgaaatttcgcD
-actttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBRBttgWttagSat
-gacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtatacattaMctttgSga
-catBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtctttcDcgtaaMta
-ggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRttWctWttaaacc
-aatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaatgtVgccatcaB
-SatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaaaaaataYNDtDa
-atcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaYBgBgataaHNta
-cRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaHScagttcYcatc
-SYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKacaBRtagHtaaaN
-cVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaagagaatcaaaaaag
-YScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDactccgBatHYgtt
-catcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaataccgcKMtatgKtg
-ScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVatDaatttgcttt
-aaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgactacaNaatBcagt
-cattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRgaactgtgHtgacH
-WSactYNgtttBactatWStaNtcStcMttgattStacctgaattctWatNaaHgMatat
-tcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaattttWttDaMtggt
-tgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttHaatggaatatYW
-gtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaagatgttBBcNaYa
-ttcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVcMNgaacKagatc
-gNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaaMacNgttNtKHM
-cctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMt
-WaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagWgcBHRtacaaDt
-tcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctgVcRDgVtaagtt
-taattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMSgDaaaatttgHa
-HtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgactMKatHBtttaV
-cYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMcccgtaataatagDa
-taatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgNDHaSNRcggtaSa
-agcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatgatttttRcWttS
-gtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaagScSSHaaYHWc
-HcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaagtgtaRgtgggaV
-MatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatcSccttggSaWat
-WtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWtKgaacgtNttac
-tgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaNHYaMacagWagt
-aatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHcttacatcDKttMDKa
-WggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVMtWRKKDctaata
-tDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttatttagtcaaVatccKW
-tacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgtttaaSaaaYtgatt
-gtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaVatcYgWttaDat
-catNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaatcgttcgKgRca
-BaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatBgaNtgaNgKHtt
-ctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaBtgttaNctaata
-ctKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatMaaatYtcacVaa
-cgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaDagttNMataatt
-taSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtgVcttatttYtga
-HgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcgaaDattttagtH
-cKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgctataKggatWtta
-ggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVBtgcaYaaRtDaa
-tacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaattaaaacgctctc
-tcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNaKagtatcattRt
-tNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgWttNSacaaKcaD
-aatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWHtcctWDtatttt
-tNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggtNttDYNYgaaaK
-ctcacacYHRgttacatacttYacaataNaagaaaagttataNaataSatacagttScac
-VaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYtMtacKacHtttt
-KtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaatcccgRBaWgatK
-gagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMtaacatataDBgt
-aaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtactaVtHactttNt
-tcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaatcaYtSgttttat
-aaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaatattacSHaRgttt
-ScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcDMggcVaSBagaa
-tcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWctYgaaStccgVa
-aaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtggaNYgaRtMaac
-ataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtactatatgatRSgttt
-gccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatatgWtacaaaWttg
-gaaactttaScataactRattMtDacVYataaaagMaattttKtgaBttKcaacatattV
-tagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaatKtagacataat
-ggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaatatgtaaacgtt
-cactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYcgtttBcRtaYac
-ttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMttttattaRcattatt
-atacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttagagcccaVgatttg
-ttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacWtttttaatDtMg
-aactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgccatatgctaattg
-YacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHKttDtttaggcta
-gRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactcctcatgtScttc
-aaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBatttgtaactttgR
-ggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacgaaaggKttacat
-tgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSatctNatttatcta
-tRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctattKtWNttcRaca
-aaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRBatataWaatKct
-cattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNgRVagKDcttctt
-cNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtatRatDtKaaSDga
-ttcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatStaaaaMctVDDt
-gttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgtaMccaataattHt
-tYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcacttcatSaatata
-ctttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagKtWtcatRcaact
-attaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgtctagtatSctaB
-cacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggtSatBMBDactVt
-ggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaa
-atatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttgaacNaatgttWgt
-ggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBRttaVagBctRca
-agcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHc
-gtgtcataaaatagagacttgHYatattctaBgtttatRatctatttagacattttNtWa
-aSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaRtcatgKattgRc
-atMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVataaSacVacKHatg
-gttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVtt
-agatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDtcaMtKaaSttta
-tKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMcKaSagatSactc
-tatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgatcttHagttttct
-taaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHagacagagaggcacW
-tacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaaagggatgaVNMa
-tgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgVatccaRaSatat
-tNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggcttaHaataaHSag
-atagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatttMtatStgtWag
-tStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaaaNMaaaccgcac
-NtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaattcWgHcgtacat
-WaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaaccatgHgtagDaggt
-gtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcatataatgaDttcat
-ttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcatVtNattataaaH
-aSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaaaatagStcggRt
-taattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgBtgcctatcgtaa
-WHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVcatattttagMcgt
-attNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNaaDcagtaWgKgg
-aaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtacYVatataVatta
-taSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttattWtaaDttggatc
-attNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHBgttttaatctaW
-aagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaatKtMataYttSRH
-HcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNHtacgaattBaat
-HtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMaatNtKcttSYSc
-taDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHctaaccaactttgg
-gttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcDtMcactaNSBtM
-RBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaagttKaacttctHc
-gcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatgNatSYaattRat
-gcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRtctaaBtWcHHcD
-gaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYctaWtStaNtgRKa
-BtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHaaStVKHatgttR
-VWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYcttactttctcttcat
-ggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctcccaacttBgtWS
-tVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSattVcgBcBVYttH
-NtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacgttagYgacWaSa
-DKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaRYtgYWYSaatac
-BgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHttttBaMcMtKccagt
-attttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctcttNcNtaaaatRc
-tgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBcaagaBatgtatt
-gacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgtccatatctgatY
-atNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcgaaattcSMagYg
-WacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgggRcHtataSaat
-tBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaacctcgcgccatta
-ctKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtgaBtSYtgaBataa
-tStaaccaagttcaDtHtatattaacYatattatcctacgagatcaccgtVSttctYgtc
-ataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaMtaattatWRtWc
-aNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcatttaagttctHtcgM
-RHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaaDtcgMacgDcaM
-atttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaattKcagttcNca
-aaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYttttMVRtYVgRa
-tKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcgtttgacHagtaa
-ttatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaaKgcgMtHtttKt
-DtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagtBgtgccWaaagg
-tYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcSc
-gBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttccatatatttttMga
-KagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtagcagtttKtYaac
-aaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtttHatWaacWtVa
-HaaBDtactYtaDactttSgtKtRattgatttatatattattataattBatagattctaa
-cDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDctacaaaagaattHa
-atctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcattatattNgSaaH
-tgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaagactgtcWDtYa
-atVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgcDagWSaStattt
-taatNcacgataNBtaattggaatgcMgacattHaattctctaaMatactaBaaattaca
-HWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSt
-tgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcgtgtcttagcNtR
-ctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaatgaaYaaHaattg
-gttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaaagaBtaRtaaWa
-ggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtccattataBacttW
-tcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSStNtYtWaWtgtag
-tcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSVYKctSKKcatag
-ttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagYHaagtaNaaVVD
-gatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaattDtttYttcgata
-aagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgg
-gtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctgattatagattag
-tatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgttaagaaaatacVct
-aaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcatttaNKgKHataKBc
-tatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBattaYcNtgcaBtH
-aacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaacttttacaaggaSRaaa
-tagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKDttctgYctctcN
-agaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgtttKRaVaaKtacaa
-caKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRWcgattgVNcWaa
-tctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtatccgaaRatcHMa
-aaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaaggtHYtatWagKV
-KgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaaYtRtaacWgaaa
-MttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagccagcgaatatagtg
-ttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBSgtggaaagHNtt
-HtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatDaYgHDBaagBat
-tWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBtacctYaNYttgc
-tgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRctaKtBgKWDacDga
-aaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataagtgttgacgaKga
-NgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacHagHtacVcVaca
-acaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagctRSDtgattagg
-aDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatttVBBcaaMtctc
-taWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVBttaRaggtaagg
-HcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagagaaaMtgDtttYtt
-ggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcNattgaaacRcac
-tDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttttacttagcRttt
-acatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtNMttRgNtgcatc
-acgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaDacataHtaWtta
-atHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVttaagaSSKBYtgHt
-DtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKcaaatttctRVaa
-cagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctagtatagcBtBtgt
-atgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtcWaHtgattYDat
-WRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgatttcBHcctaagg
-WactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaWgaKattatgMaa
-ttBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattcctctagRtatta
-tctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRcttNgcgaDtVctWt
-acHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWcatcDgatatBtaa
-tHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHaatgcBcttaBcg
-tMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtacgaagtYtccttt
-ttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMtacttcgcttVBaY
-RaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaHaggctaDtSgat
-attggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNKgatVaWSDWaca
-tVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYatKataMcKNgat
-tgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDtaKgcBttgagtKt
-acatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRtaRaaNBttggaat
-VgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgtaacctatatgga
-SYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagagStHttBgctaBa
-gatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBttaBgactaRatgaa
-DYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaYaDgttcataYKc
-ttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHt
-aaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHtaataagttStcca
-atcHataatacMcattHtacaatttctgatggacatatgcaaacaKBatgcagacagVcc
-tccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRgagaaHatVcttYW
-gaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtBRaNcgttKgtgV
-KgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVtataSctRWtgcMa
-caattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHctHtaatacacgaY
-agtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSaatcatgaNaaBt
-acggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagttVacKtcYgcatt
-catacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacNtaHtataBDttB
-ctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacgDatataaagcaW
-tgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagtatatDStgcNgcR
-taaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagVYVaMtBgtatac
-SacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatgSStMattctWta
-ttHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStgaagactcacaaa
-tcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatBttgggtatYttt
-YtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggcagtgRttgtgaca
-ctaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHagtcaatctcggaN
-WtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNgStggagcBtggM
-gccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYtgtagatDaagaH
-aaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagcNttgcVttcact
-taMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacDttaRaSWactcB
-gaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNttaVtgctgtttgYc
-ttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRMgaaaactHaatW
-WtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKWtDDDaaactaag
-tacRHtcKttacaataggttWcttataSaYctgctVtaaVggatcctaHVttgWtgHtWt
-taDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccatattacKggattVa
-tatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgSaaaagatDtaaV
-tYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggtaaagtccgaKtat
-DKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDacacVatcttNtga
-tKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaatagaVtagcttga
-KagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDtWtaHcctatHat
-ttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRacVataBWacSYWV
-ctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaatMaaatMaagta
-tcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaaaattgaaaatta
-ttgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtg
-ctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggagggDMtatDttaa
-tttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttccKtVttMacttWt
-ctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagagaSatattWcagD
-ttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcattaaaaaYtHgtt
-caaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHcWgYcacgttagt
-gtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNatgaaatttVtKcR
-tKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactccgSgtYattDtaW
-ctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSagatcBcggcatcat
-YVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgtaaMRagSaSacB
-aagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatWtHgtHKNDtcNa
-KaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNattacMYgtgctNg
-VcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKtctcatataMtgg
-BtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagaccKaaBctaagta
-tWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMWYctDtagatttR
-ctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNcaMWtWccYgtttN
-aatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYttcYDVMttcgatt
-aKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRtaNgRagttDYata
-acDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaa
-ttSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaagMaacataDgata
-WHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBVatHacactaMDa
-taaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNtttgatDacDgcaga
-DcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaaKtaacgaccgMg
-aSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRtaatccagtDaaa
-cHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaK
-caBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMtaaactagaacag
-VaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaaataagWVtcHct
-gtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtggatBtgaggDagtg
-cacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHaatBaagaHgtta
-agcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacgaRaaattSttWta
-ataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggtttHggtNtMttt
-DatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSagcaaMttttgaK
-tMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSaaWcBVacYKtac
-aNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtSBMBHDtBtaggD
-tcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaSaagtttatttta
-tgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtgatDaHcaacttRa
-taacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRVgattctatgtgt
-atHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgtcagtgagHcccc
-aatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagattttcSatKgatW
-tgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtacttcaaMaVNcctc
-HatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKVYaaagtaaSgaa
-aHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWMaDactScgRYtg
-aVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtcaDcttgaaacBB
-ataatacYMgWgctgtacttttatgaSaaatYcccgattattRStccaaaBagaacaaaV
-tttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMYSWatcgtaacgt
-StBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWactccgVctNttMaY
-taaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaatgagtatHcYag
-ctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNKaaagataWaatH
-aaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaKtaatcgaaMHtY
-KNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtDttaaSMtcagct
-tttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccatatKtaKcNVgtt
-YagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHStttNtcattRaat
-gtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttcWaagcgWaKctt
-cYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaVcacgctHStaac
-aSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKgatcagttgtaKc
-gttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDattHDBaHKDHctVg
-gcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtStaVttttcDaNagt
-DVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRSNtgatBaccctt
-MtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNttagaagaatggga
-atcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaaagtaMtacaKaM
-NaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaaatgtaDactatt
-tNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNgMcgHaVDtgtag
-aagatBaaagDttaacSatttaatttaccagatataattggVgaRctRtcgccVatRNtD
-gcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatcaMSagttccRctt
-aaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaaaagHatYKactt
-tRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacgtaaBMRgatcgt
-ctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtataaatBaaatKRta
-MtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtttaacYatatgtg
-ttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaBacgtttaBacca
-BaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDatttYtKggMtYNt
-aactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttattcBaagtgaWta
-RtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWNWgtacaggctac
-ttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDVtaatttacagaR
-ttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBtctatagaKaVtt
-ttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYtctgVagaccgcg
-VgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtN
-NgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatcaVactcagagtR
-YtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWagaaaaataaatta
-tagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcYattgtaDggMat
-gagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagNtgatSNgatcYV
-tHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacKcttSagtctgKM
-NagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccctggVattHaatVa
-gaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWccatYtagacKatct
-KatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtattaYcRagatgatca
-taacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggccacgaYYMcaKatt
-RagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYagaHtacagttccMc
-gtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaaaaVtDgataaDg
-tatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBggttagcMaYattt
-BgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgtatggVBcctctgt
-gaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtHtHttatYaaagc
-agatgtgattagtggcactactVattagatctctgtttatcattYttgatHcHttagStg
-atgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVttcgWtatKaaaH
-WtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcctBcaBtctttaa
-aKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaagactgacactta
-RaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactccaggagttaatcat
-RttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaataKtaggaaatat
-gcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttHattcatttatYt
-attagtataYtttagYcattagaaataHtaaccttactcatYttHMRagttctDagNSVg
-cgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaBaaMtaScKgVaR
-cNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaaaattRtcWtacD
-DaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNtaatatHMtMWRaR
-acaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWatccBgaaVtgtaW
-ttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWctttaHtggHaBB
-SRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccVWaagattgKcaa
-cgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctacatgtacataacD
-gcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBaggacMaaaNgct
-gttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcagctattcaagaga
-atHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgtcaWgaattKttg
-tcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactSHctDataKtcaa
-gtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatataatcatNMRtDY
-aYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBWaBatgDtBaKaH
-acagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctgtcBBaVttctHg
-VttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaDtKagtHatacct
-HgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaWataataYacgta
-cgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatStRgtatVgttctt
-KSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgtctgagtRtatRS
-MWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDttcaaagMgagaV
-HtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtatttgaatBtNttg
-aaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggtagtgaagaMKata
-cttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgctctttgaRRVVt
-DaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtgtSactctSHaMa
-WtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtatatataVtagcgW
-ccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctctacatcaVgcMHa
-agaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaacccactHataag
-aaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatHattgaatgtNct
-tatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgatataaataataBg
-aatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtggRccatttatgt
-MtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMga
-gaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtatgDaMaWDataNt
-ctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgtRtaYattactNt
-WgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttattcattaagtctg
-tctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHacaaaDaaaRVgcac
-atgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttagHcKaacaBcagg
-taacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSaataHattacaMg
-gtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttcttgtcMaRgYYaca
-cggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaaaaataBataWaa
-tatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRcVctttagNttaa
-tKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNMactactgacaDg
-VgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaataagttatgHaSc
-YaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYcaaataattSctD
-accatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcMaatttWMggtct
-atttggaKagaggatWcatttgctatcgcccBacacttataagaYtcNcagaNatcaYHg
-NgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaaaHgaYagtRtca
-aDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRttMgtaattctWt
-tMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttRagaMcDYgcaKc
-ataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgHatgaHMtNtaac
-tgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaatatDYataaaaata
-taatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRataBtaVcBtcDWW
-aaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRaHtatBcaaacNa
-taKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccgaMcacNHKtatt
-StaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgctaVSttaRaMag
-atcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcagggRRttKtcgtKDR
-aaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaactaatgagatttta
-BattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRatBtaagHtctctt
-RatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagacgaaSatBNtHMc
-KagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacggcgcWttcBcta
-aVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHBcgNtctMKDcYt
-aVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHaggatcgtggcat
-aagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKgaatatWBBcttKV
-HtgcagtagaYRatcggaagaRtattaBNttattaataatatgtttttaagMggggMttc
-tBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNttDWaVtaaaaact
-HcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaSttgatcatccacat
-atgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatgtaRgtKgattaS
-ttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatNttttagYRtgtg
-YttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYBaHMgcccgggtW
-ttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatMgaacBaSacNaa
-aBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatVWaatKtaBtaaa
-taVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggtatRatttttaaa
-tDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBataaBaaKattSc
-SVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVBtagcttYBtgtg
-ttaataataWactatataaVccaNtcaBtttcMagataatgactMBatBctaaRtatata
-aaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaaccBttMaaMDVa
-aaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaagRSgcgcaRgagt
-acMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgtttaDccttMVtatgH
-agaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgVttcWagacDgaM
-atataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatDtVaDgttaaacg
-aagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSggagttattatgcc
-tMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVtaattRBattgcc
-catgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaWtattgaHgcDaa
-gVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcgatHWaaRRSHct
-ggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtNattStRSaaatt
-VtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKSacaatacRgDct
-aSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKccgHtBRgttStgt
-BaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaatatttDatcWat
-agRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNattataKSRcgcagM
-gaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDggaaagaNttttNtt
-tSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaVtaattgtacctc
-tctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacagataaacgtaVatN
-aaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttggtVBagatctRa
-tKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataatWNtaDStRaacH
-tacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttggctttHNtRcgat
-ctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaatacaVaaaHttct
-cMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaaBMtaaaatBtaa
-acttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctttgaNgaDDtatc
-VWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcattcaattgtaBcMt
-gYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattacaWttgaataaaa
-WgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttcgaggaWtDtgat
-attaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgagKRatWtggtcgt
-WaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggctaggNVgDcgaa
-cttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaWtaggattScaSt
-gattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBYKKtattHVcHag
-StaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNaRgWtgtaYcaaB
-aagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggcaaaSYacaKatt
-gSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttccRaaacttHtaR
-caaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtctgRataKgcaaga
-ctSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWtcatHagcgattc
-BBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacggaaagVNBaaaaa
-attKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWatgctWWattttg
-YaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatgKgaaagNSattK
-tttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggctcaaHagaaSaa
-gcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtcaaacNMcaBtag
-aWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatcaDMaWtcHgaaNa
-MMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatVctBtHctYNaca
-aactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttattaWMDgStMKKata
-tDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggatacaaSRaataaa
-tagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHctaaaSaaagNtt
-gactaSacDtttcattVctccagYtcNcagtWatacattNgttagagNctaYaYNttKgt
-tttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaaaRtNgcaSagtS
-tgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtataMtgataaDaaa
-aaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagcatgWcacgcaaa
-aDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattcactaaagcHgaat
-cHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBtttcttagaggVttc
-aatRattNtccatttcagctactccacMatSHtagataaaWgaagtttgDcctaagtMaa
-aYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgSacctBcaHcgtM
-cccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaacNgcaRccDKtca
-tgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagStaaaaaatgHaaa
-caacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBtcccttaaVaaca
-MaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaW
-ttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcgccttttgtBtat
-atttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaVVcaattMataaS
-BtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcatacgcgaagNYaNg
-aaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDaNtScgStWgtga
-caacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactctaagtWtKSgYtat
-ataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStcatgNNtttagMt
-RDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgcScYtaaccaaHc
-attgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgccattacHNgVataa
-YtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHatatMgttScgaaVH
-agaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggatgVKaaVgNcacc
-agtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaDtaaaatcgVacc
-atcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttKcaaYtagcagat
-VcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVgctgaatatctMa
-tccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYcStactctatatc
-WSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDScttttMMWctagc
-aactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNattMBcaacagtt
-tcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWtBataattVacWa
-aattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccgacKMagVtWcMt
-BaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaStttattctattcV
-acctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVatataatKNKaagt
-ttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctgcaMggScBaRgM
-MctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaHDtaaVcgaagaa
-aggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaagKtctgBtKacaa
-taYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaD
-ctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcMtMtagaHactaS
-gBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNtaagctagBVWaBa
-aMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWBSNcagatttgBt
-cVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttttaccattcccct
-aaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWttgaaaYgagata
-atgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDtacStVaHcaacta
-tgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaaattatYNtYcta
-gtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgttttaaagtDttM
-tgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccattacaBcHctVcttc
-tYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKtcatctatagNSa
-acHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattatcMaggcWWRttc
-cgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgcttatctattatgttg
-StaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgttBDgVgatttKga
-aaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNcaaaataSttatt
-ttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDtgtggttctatRa
-tgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtctttaagtcaHaWY
-tKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatNttagatcagaat
-cttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaatcRaBtKttgaM
-KgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaaccagtttacVtatt
-tBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagtagatataaWKcgg
-gacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcgcNacaaHNatta
-ggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacHRgttKctDaggM
-aKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDaDVacaagKaaRY
-attaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHggtaSctaaaaag
-tttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagtaattWactttacW
-aaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaattcKYaaMacgc
-aatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcgaWgaYtKataaDc
-aBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDaNtgKtaaKDccK
-gctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgactttcKHNcWBYag
-ttgataaYagaWaSMttgataatctataatRtggaKtcactWaataatYgtgcHgYKtta
-aaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataRaaSactKatSgg
-atgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBctactacBcVacaag
-tgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMaggWgYtatctgt
-gtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtgtgaRWaacgatS
-gaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRScagDtaKtatttYa
-SctttctcatccttaattagttaaatactgctgNcttgctcatatatactaDtagctagR
-cataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcKtacataBtWtaa
-aDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRaYaatattWttat
-tcttataatWatattaccYaagWtgaataatgatttgtatBYSaDctatRattgaatDgW
-tMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYYatattaRaagga
-ataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtVVgacctgttaaH
-agtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRtgctRtgaacatD
-ctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDRagBHttgNcNaR
-DcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctgcMattaMaaWgK
-ttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaatBattctaStYg
-ttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWattgcacMattattg
-DcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgtagtcagtYtcKt
-MVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgccggBVYtacRgH
-atagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDacaccagYgtatt
-acWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattDtaagKtYMMaca
-gcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatScgatgcgagggSa
-cttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWctcctggNgatgM
-ataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBtaScWtttMKcSt
-gRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSgaaWcgttaMcttW
-DWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcacatatVaatcSgt
-gDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaagKcYgcNYtVtt
-YtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBataRSVatccYact
-tcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYttagNtVtDatattg
-catYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgtaMagcBgaaagt
-SctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWSgWcNRcaVgSaa
-aBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagatacNtaacaWtBH
-gtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaHaYtcgattgtgc
-caagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMacagatHcttcag
-actcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgattaaKWNaaYggaaa
-acgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatBtaattaaYttgD
-aacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMRtgcataVgtaat
-caagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScgatgDtWaaVtata
-catggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgtttagSSatgata
-cccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatatgDactaaggcgc
-aKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaagagtYHttBgaD
-KMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatcaaaatctgaaSNa
-agatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaYtctatatgaata
-ctcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaHKaKaactctcHc
-KHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaacSttgHRaagacN
-aBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgatacSDaNtttgaag
-RtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYactaaactaaattt
-cNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHccacatgatNtatg
-KaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaagtKKaaaKtBtt
-YRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggtSaYtttaatctt
-aagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaataWacaaYaNtacH
-NtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttWagtRtcNagHct
-taatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctttgtgacgaBttt
-tccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKHaacaatgagRaW
-cgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgctagagacatacaa
-ggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtacBtatDMagtatc
-ctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataScaDaatYaaaWaRN
-cagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataHtgtcKaWctaVt
-NWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtWgatggattgaNt
-tataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDgMatgagatctKt
-taHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWSgtttttaYKtSa
-tttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtacgtttccaaVtaV
-aHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgcggYHagtactNa
-gaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWDtSttgNHDMgaa
-aaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKgScgcaactattV
-ctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaactattcttaaac
-taYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaagtcgHgWStttaW
-DacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtcKaagaRRacaat
-NgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVatBaYKSSVaNNcc
-gctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccRtHMttHgBactt
-YScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVtaaYgVgcVaaYSa
-NcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaNtDttgcBacata
-ttaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHtaggatDggStgSW
-tVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVttaWtSttgKtctt
-cgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaVVgatagaRtYat
-aatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaataacaMNataga
-tattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHBcatcatcHaatt
-attDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccBtccaBgBRgaDa
-atttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatMaaWctatttaaa
-acYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaHaacagctNcatt
-tKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatgMacataWaaMta
-taggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacgaVtMaaaactKH
-atatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgtatRtaVgaaDta
-cacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaDtaattttaBWca
-taaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcattaSDBBKttttc
-taYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWataactctcVNYt
-ttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtYtctttMttatcD
-aNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaKgaaatcacaNtt
-gtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHtttDtcgtggBggcK
-acaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaSatYVHRaaatcc
-MMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaatBgaagttaattt
-tgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattactcaaagctctcBK
-caagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWtaVatatataWgt
-aWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMactKtcgtDaDVWt
-taccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacataWtatWaVttct
-SRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHaggYWtcgatKtt
-KaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgDDcaattcagtca
-taccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRactHattgatttaa
-SKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBgcattatcaaaac
-agNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggtagVgatacctBtt
-caattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaBgDctRtttaRHg
-cRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNtttaBtMtScVtV
-tSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaattgtatttMcat
-gcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaatRcacttgtttt
-caaattctggcccttttBgHccatcgaWctataSttBgataacagtacggcccDcScaac
-tgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMt
-StWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaatagaaatgNttHtg
-tcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccYtgccattaaHVg
-aaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgcagNcatWggNtg
-RMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRMtgtccatttgKa
-gttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDcagaHaaaatStc
-aMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVatttaatttYSDgR
-ccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcggaMKaacSagtat
-taaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtactctttacatSgta
-gtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttatgtgtgaStaaga
-aRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaDagScKgtgSagt
-cMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWgHBWagctaagtt
-atcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMatHWcgccttaYta
-gtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatVtatStctYaYNt
-gtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcattaBaaMtattNSSt
-tHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcctcatcgtgWata
-agcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctKtDgaBactaggt
-WgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacSttttatWaataatDaD
-aaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVat
-gccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgtYtDtSgccaaaa
-YcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNtaaatBtaMaVatt
-cctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMStgtttSatNaga
-acaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMtaDtYtatHattSc
-ggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKttacMaRacaSaRaa
-WtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacRtaDaactNatYc
-agtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactcatVVtttaaaHg
-ctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKSatcgYaNVaatt
-acRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNtaatcgttaStta
-ttWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWctWtDataaagHc
-tMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatatctcgHSaaNBct
-gVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatactaaWaBYtKttacW
-taaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctcaScaataNgaaVa
-gaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtVStaVBgtcgNat
-gtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttcttatttatcaaag
-atWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHtttgMcgatSaag
-ttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaaattKKttttgac
-DtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacattatagBDacgat
-NatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtgatataatHagttt
-ccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgtatWWaataaHgat
-ttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagctNgtScagMcccH
-aBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaaaNgtagWtttYt
-gaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgDgcaYctattNca
-NtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaagatMcacatBatgt
-StctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYaYtaDaatctatg
-aVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHccRBWatatcctta
-tMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRattNcHSgaaHtaDc
-agctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRBctgcattatMaW
-aNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWacttctRatgataaK
-taaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWHtYaattaWacat
-tgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWaattcgDaRaaac
-gVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagtaaaaKttVWMgg
-ctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgHttatSataaWtM
-HttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacaggtttDDVMtNSg
-catataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatgDKctttgVVaaB
-gataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYtatVtccgtaagD
-cNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagtaDctctcVtaSc
-tgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRaatctgctattDS
-NDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRtaagtaSatatgat
-caaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtccaMRMaaattaS
-gBccggNataagtgctctttacYataRtcattgtgYBtggcatRtacttBaacDacaKtH
-DtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaaggttRatagtagaa
-ttVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacSRtattgcggtcc
-tcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMttRtYgacttgtt
-agggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVctttatcttggtYc
-tctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMcVaaMctaKRctt
-cRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgtaaVctaBatgta
-agtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacgSaWgaHcagtag
-NWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatggtatctacaaat
-gtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaacagaaRVtttKBa
-cttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttgatgttaRgacHca
-ttcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagccgttcatYattc
-agSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaNtWVcctacatac
-YtctgKtcattatctattatcgtcKtaataaattagggHctcatgHttSNacctYaKttM
-HtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBcatcaagtBtagcM
-agtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaagttaHSWataga
-aaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcattggttgWcatYa
-gtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBggtccatMattBaa
-tgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaaBaaagaaWBHSt
-tgattttKRcVataHatttttgaBtcctctacctcRYttagcatactttagaMHgtcatg
-tHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKattHgataNatatac
-gtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtcatactaaWWtata
-taaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatagcaaacacWacag
-aaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHtttagttttataa
-tRWggattYatatMaaaactWaDRaggataaWgMataggtactatatttVctataattaa
-atatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaattacaKtKYtgStRa
-agaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgattYttaacDacaH
-tcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaacWaaYatcaHaa
-agttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtctaatttcactBt
-gNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaatacgDgHttaNgga
-tDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYtagataagHtccat
-tcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatggtacacctttatR
-cgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagctcVNtttatgRtg
-gggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRacaVcSgatcagcaa
-cccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgcWtcKatattMKW
-taaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaatDttcttgatMag
-tagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaVStaatcctcDag
-tcataagWtataatattacagScHaatatagcaHYaaSagaaaaactYtRYaatcggaaH
-cVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKttccgtaWttcta
-aWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNgcaSgRVtcYtgt
-ctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHgWggKatMtaHcg
-tKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBaaatSttYgtagB
-aSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMtattagcgagaMc
-tNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWattatagaKtcWtH
-aMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHtSaVRYVgcagaa
-tWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVDggacagBYtBcR
-acDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctSttttttDtcSgtca
-aataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYYacSccVcataaa
-gacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKataaaMBgtYtaWa
-aKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcagctttatacgtSW
-BaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaaRttaDttctcaa
-BgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttgagaaMtatacttg
-tgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMVctaaBtgBaatt
-ttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtDaHaggctgtVat
-tDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMtaaacttccNBgc
-tacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagtaBttaggactYta
-aaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaagtagaattBcaga
-DcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgHactatNctacga
-VataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatctttgaagaBctg
-attattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtttBtgRtgaNtHc
-gStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaBttStHVMaccgg
-taVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttctaaatcacaRBatt
-ccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagNaggaHtttagcc
-ttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBttMacatDtattt
-aaRggattatBVcacattattaagWctactVcaBgcttKagagttatRBgctagaHtgDg
-aaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacDaaaaKcacaRKa
-agttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcattaacSttcacDtSt
-tgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaScaSDcaatMaaaa
-aaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattaggagtYBaaattt
-agaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatcRRtcataaaYct
-NtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtctttaggNtatatg
-NaagtMttccaagactRttgtgattBagBtaataattBStcaatttaWcattaatVtaca
-tgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtcatagtNcagtBa
-gagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYatttDaaatcactKat
-WatcDatatRattataaatatctattHSctttggNctaagtSacgagatatatatRataa
-gtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRaVgaYcHaagWgg
-ttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcccaRaagattNtt
-ggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaatacccYaDVYaVaY
-KVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaHacaaataaatat
-accaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWKcagttgcaacga
-gBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaagtHctctaatct
-tcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYtatcagaaKcttVt
-VaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatataHaMtcaattcct
-MaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttattaaaactYgMtta
-KHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactagKgtcacRtacMa
-cYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtctcaVatcgStca
-tHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaYataaaHtNcaSc
-tgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDcctRtgcgaacSt
-aWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaataatVtaaWaVgca
-atagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNatcaNatDgtagc
-taaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNatacaagtactYtaW
-gatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBDKVtaaaaatttW
-tcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaatagatYaggattVa
-aaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagtttRtattcttcY
-accaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaaagataYtacgMt
-WaaacBtttatcKacaaaatattMagtKccaaWccatttgtgacctttMSataMgBtctt
-aVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgNtatgtataaVtB
-atHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacgtacScttcttcW
-taatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgttatRagtaNtatgR
-taMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagVRBatacMaatac
-MaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHgKtgttaatDaHa
-tctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKgVaaRMaBttgca
-taaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtBttaaYataaSHt
-RtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttgagtataaRataga
-atRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYagtaWBcNatttcN
-NgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYgKgaaHVtaattM
-gaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgatgtHataaggtaH
-aWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctcDtgaSgVMtagt
-tKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgDgtatBggcttcB
-cWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMaMtaacVYaKtac
-tgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaMgVBKtBaacctY
-NcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSYtttgKtgtKacg
-tKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgtatBcgagaBaVat
-gatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttctaggKagRNtMBaa
-tWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtSaNRHatVaVacV
-tHattcaataatgSKttttttgtataRKYaatccRYaatggtaVtttaaaaaWBKtatat
-ttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWccVattcDaaatga
-ttgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacctaaatctRtDtta
-BRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNtNgWtVMVtRact
-ggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaacMRctcgttaaaV
-atatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaagtRMtaccgtBa
-gaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaaaVgaatgtgtta
-tgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataYaBtctStgaatg
-agDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttagccttataaNRaa
-tggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgcBttgccgtHKat
-cgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctagatSctaactctD
-ttaagacgcatagcRNgagatttgtacattSattaacttttcgttgattWatKtgaattt
-aMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDScNctYtBRYVgtt
-gtttaVtacHWattattcatttVaKtgKaacctaggStatttacaactcKNtaaacaagS
-ttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgcctaattaaaNaW
-cgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaagagataaWBcMgat
-RBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVttaatttVccaagB
-SWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtYttaagccaHtYa
-tatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaatgaattVaKtVYg
-NaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVtacaNatataHtg
-tcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtacatatcKScctDa
-tDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWYRatgatMgaMKR
-ctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgagaBDgtNMgKKRBN
-SMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStattcHttgaYttatt
-attctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHa
-aattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcagHctHtWaacgaa
-tgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacgBaNWtagataBa
-NtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMWatttNttVaaRa
-gMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVttcYcgtMattcta
-tatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataatgatRWgtttVg
-atMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYtSWcWNtHNacaa
-atactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtattatYtttDgtBaK
-cataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVtaNNYctKcctag
-MWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaaagttYgcStagt
-ctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacattattgaBaHattHg
-cYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSaagttHVtatMtc
-acaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgtaHaaKaacaYaHa
-ataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttatttgttaaacaaStt
-tagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaacaYDgaWaRtaK
-ttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaaVDagttBcatcc
-attttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatStttggaaWtttH
-tatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaSaVacaataNKta
-tagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHtagtMtWtttatYa
-tWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYWgRccNatatHtt
-WgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMctttcKacatMattgc
-aRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttctgtgattYatatY
-tcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaacttaBtgtcatgtc
-tNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSVRMYKYaggataa
-atYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaNVtHVagtBaatg
-aBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMcatagaSttctNB
-YcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctggaYattatttgaaW
-gtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWYKDYcVWVggttt
-McttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagtaaatWacSKaaa
-tYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaagaNaataataag
-cttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWMaaRaHatcgctH
-aaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaKtKacNVggaatY
-ttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKDgtYNtcYtgtct
-tttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttatWgtgHctaatMt
-RKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaattttcRtaaagat
-ctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtcNaMaRYcgagtt
-aHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcVaYaaSaacBcac
-atagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVgagaNaaaHaaSc
-cggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatttttDgcaatHat
-gaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHataMtccaKagagtt
-tBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYSHgaMcctttttt
-BtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaattacYSattattta
-YtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaaYccSgattaaaM
-DRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaaatactcgtactt
-ttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWgBaagBgaatDag
-aaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtStaaWRgtaaatH
-caMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMgaBtSaaaBtagtt
-aaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagacaYaattagaggKt
-ttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccgtaBgggMtKttt
-ctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDaVaggtttRaata
-BgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatttaYWttagattg
-gttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaBaaagaatacgca
-tYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYcttgtagaHaHaYt
-aRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStattatMtSatcata
-HcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcc
-tttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRVtaHgaattctcR
-ttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMtagMaHWtagatt
-tcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatatatattagtttgg
-MaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMtaattaaatattBN
-DacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatcaBYaaBttctDS
-RgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaagaaSNtattcNta
-taatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWgaagcaatattact
-caaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagNtaMatcSgSgaV
-ttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagMaggtKVatVtVM
-DVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttctccttcaatgNaa
-caBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatgagHtSattacBgt
-tYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNcttaRattatatctca
-gWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttgaacNttctcaaHt
-HaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatactattWatSaattWc
-cgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaaaKtcgatagcNg
-tatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtt
-tacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatattagcatcKBatttt
-gVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBHtttgHaggcctg
-acMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMgattVgaYgtatt
-atatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcattaatatVacgcH
-RttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgcttaScatNaHca
-atWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaacSaaatBtttKa
-KRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVggacaWaaatgHtat
-HccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaatatgMaRgggtat
-gaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtHScgataaNcBat
-aggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYcgctaacttaaag
-aattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaBSKtaDgtataaR
-cttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMacaWNgagatcDcgD
-tatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYataStKcgcaaaaaR
-aaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaatcatattcatSaY
-tgWaDacgaataactctggaDccattacgSagaaattgatttaDtHacgtcMgaMHaaND
-KttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcVNWWataatataa
-ccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttccatactHgStagH
-caattaagacagaMDtttagcHtgccctttattatSatWataBaaSMaccVVgtggatgt
-gttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagagcgKcaBggtgta
-YttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHttcataBtaWaNtg
-taatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDStacgtagaYtaa
-gtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHataatatacaatRY
-aHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMWVtYaacYagaaH
-aaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMgtatgKgSatDSg
-MtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcDgtWaactactgt
-tagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccWacaKctgcttta
-actagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRatKagNagKaWtHt
-tttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgtagatYacactYS
-BDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNttaHNtSctgtcW
-ttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDcttgattaaaatHg
-aataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDcggatHWgaagta
-cgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttctagccRtaaaat
-tNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatgtttaaDacacVa
-NgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatatagWaBgagtgtY
-aaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRa
-acKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaacaaDWaatDgag
-aStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactKattaKtatWagt
-tacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtatYcVttattMgNg
-YStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatgctaataVYcStt
-BtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgBtDKgattaaata
-gattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatctctMttgacNaWt
-ctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgtHgYttaagtNYt
-RcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKattaVactttSgtg
-tagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtaggaaatDttcctgag
-agaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcgtatttHtatctg
-gaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaaatKgtaagtcVg
-ccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgttctattgNcaaga
-acaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaaaaacKctNgaaa
-gagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYcMagaatKaYtca
-tttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWNaactVaMgtcNg
-McVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgctVaaaatatagac
-RaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVacaNVcKtaaagHD
-aaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgMaMccagcttRgt
-VggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgNaaatgtatgaSg
-DcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacacaStaNttMaatga
-ataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYtttacttaatVat
-gtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttRScRtVcgttcSc
-atMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtKataNgcaaScac
-tcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagatatttKatgtcgDa
-gaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaatatgKtMaWtWaY
-SVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaattVccMtgggWa
-tatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaagggataBRcaaBctt
-KtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtctattaagacacg
-agatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttgHtgagatBBaRR
-WSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgactaNaatRgNatta
-tagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaatttBDacatBttt
-HactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactaccYHttaaaMaVc
-BSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcgcaaataatatta
-aBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRDaatgVacaatat
-VBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSaccVgRaaBtgat
-aaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaatagaatNctcatHtSW
-ttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKttaaatYRMHaRtc
-gtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBttDHtcttggcct
-taNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcattcacYtattggat
-VgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtgtMtaacNtVtcS
-tttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtNtcgcHYgaDttg
-RtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaBattaMBtHtttY
-ttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtNcMKactcgtaaa
-VtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKVNaVggataagaa
-gWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagatttagttaaaaNaaa
-ttgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNatVDgttacVBac
-KBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaBtMaaaagaYtMg
-tgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWattagDtgagBaHa
-aNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaacatcactgaWaa
-aaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacgHtaaaBtatctt
-aattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDtataacaccVgttH
-aaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatWggatBVgtataN
-WgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctDgBSgYcagcggg
-WRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatgaagaKaatStgc
-ttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHataRcggctVBtcc
-aWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScYtSgcataDtWca
-cBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgtagttttcaaagt
-gcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatRaggtcgcccatt
-MttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSSaaHtattatWct
-atKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagggttggVYaaDgt
-tWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatcatacaacgMtaat
-YctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagttatSttgtDtgtM
-gMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRattaaaatgaaYYatt
-gtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaVtKScaYagtttc
-tagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtctagYHtRaagacDR
-aatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHggttgtRtattaa
-ttaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScatNtcMggaagggH
-taaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttgctgggcVattat
-ccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaataaVtDttaRRgt
-ctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaatttKtttaataa
-aagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttttaStataaHgtc
-NDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatattaRYaaVagagVt
-cHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBccWDgaatgaggaa
-NctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDccaaaBgVaDtct
-ScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttagttDctaSDVttt
-NaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttgtaaaggHattaa
-atgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaYtVaataaatcaB
-gaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMYttgtaaactacg
-KgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWaHctgaatctaaB
-aWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttcaWSttttgacHt
-ctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattcattttMaNaSaR
-aNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgBgtaatcNtccga
-agtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaataagttVDHgStg
-ttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtgaRRatgatccaa
-aggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaagcagtgtatDHg
-RaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatgtcDKHYcctSHM
-ttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttcgaHSgtMgcaca
-gaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcg
-aDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactgattStaDaHccYa
-DtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctVattagtWcacga
-aVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagttaNttatacaaaKa
-ttBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttctaaDNtgtgaaaa
-gRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacScgaaRtttctatt
-cMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctNatYttgcSSatt
-ttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYacaatgtaBgcgttV
-tattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMctatcatcgtaaaa
-YNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctcatatRttBtcca
-attBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHcacgRttVtatcat
-atacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHttagctatSBaBtc
-aagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggttttctaactttSaaa
-VHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatSaaaacNgatttN
-caagttRgacgataVtaacYNataStRtgaattactgtaKtNagaaccDaatgNDaaHca
-taDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactataKMSttaHaaaa
-caHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNtaaacattcgaga
-BKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWNDataaKatBcaY
-ttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWggaacacaKaaKct
-agtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScVNaRtaacgScaS
-tttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatctaaaaattNaaaWg
-WaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNaDttYagactSta
-cYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHaWcgtaccKaNat
-agWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatcagatgaaSgtVt
-HtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgcKataHtBtagSc
-WtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattgagtDYggKccNaa
-RgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaactagtaccgttggaK
-acRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttatcBtHtgRatgcc
-acctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaDgNRttaDKacgc
-ataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBKcaMtctKtctat
-NaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatagataSBagMtDVa
-taaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVacMcBaaDatKatc
-NtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWacgtccgcgtMctc
-aaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWatgtgStttgttt
-tatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacattSgttaacctaa
-aaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcgaatttacMagVt
-taRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcatggHgaDYgaVgW
-aaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaatatRDaccagctt
-tttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHgcVtaYgDacagM
-BagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaKtgBKtDRggtca
-YcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWccttgacYcaagtaa
-tataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKgaKtgagttgaaaH
-cgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgMgtttatagtKcV
-ctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttataVcagHYacaaMa
-attRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaDMtatYtaYVtNt
-cBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHttaaataattggt
-aaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaattcRMBgHttcta
-agaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKacBgttcttgtta
-taBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtcaagcBcgcYatta
-ctcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtttggtKtNKaMtM
-gcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgttaaVtagMWctNtc
-tHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSStaYgYatYgtaaa
-aattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHatatBaaDgcaKtc
-ccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRtatagKcatattDg
-KtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRttttttatataSaaga
-aKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYcaaNRctcKacKt
-tgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNtctaacatagVYa
-tcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgttgNtaattagaa
-ttgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKNttBatatttaat
-attBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataatatHcaaaatcM
-BaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagcaccaattcRctt
-ttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHagagHattcaggg
-gSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttaggatSYttaacBta
-gaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagHKagagMaatttM
-atgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRatBNVKtMaccYa
-accMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSgcgVtSatggcag
-gcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgcttaacgtDNaaRcgW
-aKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataagtattttacgtc
-aRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHaggaNcttcctKggNg
-atBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNaDtatctgaaggK
-cagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgttgatggtcaacg
-ttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcatRacaRcMcaNta
-YWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcRWMtHMaccaatg
-ataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHactNYcNcttaag
-gcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVacctatatStDgt
-ggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttgtcYttttttaBS
-catRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaaccctgNgagMNHaa
-KacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKaagMgctKtBagS
-aagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcKtKatctaaataa
-atRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaaRNtataVcYDat
-tagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMattDcaRggDYtY
-ttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaYagRgctctttta
-acVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttVMaNaRaNMKacH
-SagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYtcagtaYtctatH
-cgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRRaattcaRataaR
-tattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattgcttactctgatK
-tgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaattYccKagaVag
-ggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHg
-tacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNttacgVHaacSgSt
-BBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattcaaagtgattagK
-agNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNaaaaatVgHaatt
-aatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttDgWNagagaaaga
-gaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtaccWcaMRtHttaa
-atgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatacgaagaVcBgStM
-acMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMtatataaaaagat
-gtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtataVDaacagatttW
-tDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtccagHctttMtatt
-gtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtacctataDccMatt
-RgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVatVtttKattaagt
-taNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKtactctacgagttg
-aagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDttatMaWcStgatt
-KattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaSgDatgHtctaca
-attcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtatVatcHttcaDNK
-gtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaKaHgaatYNtBgc
-aaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVacYaScctYVgag
-WagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDaYtttttgttcaa
-aaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtBtatcatgcDttD
-aaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWRtaatatcDWcct
-aNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagtagctatttcacta
-aNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtttgMatggNtata
-caataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBatgtHaatgttttg
-atatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattcagaactcaRataD
-ttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHcaYNtgRaHtcaYa
-acHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKcatactatatcaHa
-atataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacKtWtHtBatNtSc
-ttttacaattagtaMaatttHgtctagMctaccagagttcaKcStaccKggaggtctgcN
-atctctDgYccaaVgttgaatgacVcatagtgtattttccttcatctacttSgaaStcag
-HtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacctVBDWattgHtt
-atattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgcaaMaatVaVaKg
-tatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaaggttBtgaDWBt
-RtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgtMatacatgNttB
-aNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgataNWattgtaSggH
-DtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattWYcgtaHcttagt
-gYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtttagaDDNtattt
-gaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVKaMaBtaKctaaW
-catctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtctYcaaBDtaggaa
-gcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDagttaggcttYctc
-atDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcacatNMattgtaaaN
-aaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaKgccagtgtMgat
-HDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttWcacaatSatgYt
-gacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNgDagatWtRttSt
-tNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaVcgtgaatcataa
-tcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDacctccNKtgaVcW
-attYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttccatgHaacttYa
-gMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaHttgaacaaataa
-WaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVgKaaaDttWgRBV
-agttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaacactMcaHWRgaac
-tWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgaggaagagcaSHcW
-tMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttctVKaKgcttcct
-DagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaattatttgctaagc
-gagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggRtttaacNagttt
-RtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMataaHatYMcccaaa
-DaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaNttgaaDactgBa
-tgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaY
-tBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVattWDgtaaHaYgDt
-aacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaVMcMctWgatact
-aRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaagaSYtcctWata
-tSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRDaRgatatacatt
-agtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgBtaaNcRaatcNa
-agcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaa
-aattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaHVaaNaNaatctt
-gtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatgBaaRatgcgata
-taaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcaggaBcttttcttVK
-atKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNtttagtatgRggYKa
-caatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaDgaKcaaataaga
-tMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgatgKtgcccYatDc
-tYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataatKVWcBataaat
-gttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtYtagcacaSctcH
-YtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBt
-ctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattttgaaaRHattgM
-aaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacVagttggtcgtgc
-BtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgattcttaaagcMMt
-taKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNK
-cRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagataDKgtatScatt
-aDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgaccgtgWaaagaaat
-gaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactataDgNagtcaSgt
-KttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRagattaKRtWaKt
-taaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatDtaVtaatgtHca
-tWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaacttRgaStaMBaa
-MtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNgcKgctatcccac
-SctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMagBaKctttYWBt
-aYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaBctaggaaNgaRg
-cttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWtttKgacaatatV
-ttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtcattagtaaNatct
-cagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttcattaHMaVKMDDt
-aSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKacccaaWctatccc
-tcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNBacagacaaatVt
-McttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgtacVBtcWcSaYHg
-tattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaag
-aVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtcactYtccttatg
-HtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaMgccaStaaWtVa
-ctgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNcaaKgttttMaMc
-YtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagacttcaScaacaYtS
-aattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRgggattttMcgttat
-taVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgtacggKBtSatDa
-ctRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMatgtacatcagcta
-atggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaDaatVgYaDaatt
-ataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcatttttaHacatKt
-atagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaattDaaVMaKgatc
-ggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDVtNttcNacgaYt
-cgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaB
-gtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcctaBgVVaBagHa
-aaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtMttatcttWtttt
-RaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKtttagtttagtBYcD
-aMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttatttttttcaaDtDDaat
-caaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgattRttataBtcgaa
-RataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaataYaggatccactt
-cacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWSgctcagtWaata
-WaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtatatgtataatWtag
-ccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNtactHtKBtcgaaa
-RttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagStatRtMaacKac
-acggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBcYtttaaatcgRg
-agagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSVagaattccgctt
-VatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYtaMcWaaVtaNta
-tttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacactDggtattttSc
-ttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHatagaaggggaWgt
-gBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgY
-tNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttgaKaWBatcBgaaa
-caBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtVKgHtcRattact
-ctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgttMcgatatcccg
-VctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgStgtatNStaaccg
-ttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaaStctgaaVatac
-tgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgctgagBacacttct
-DSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNtttagacttaagtHtt
-aatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHagDtMtatgatct
-tgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttctDcgtNtNatggK
-atHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaaWtagtVgaVBat
-cVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatDgaHtRatVWaga
-DtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcgattaNNtYacttt
-KgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaaRgDgttWtaatg
-VBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgcHttRctattVta
-ttgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcacttDattYttaVgRc
-acaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaBccaaBaYgKacW
-VtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgttactHaKgacaK
-taWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaHgHKtaatcctct
-tcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaaacgYacgagcac
-gBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagtYNHtgaacaatg
-cgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtHttNcttVtgaKM
-tgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgatcgcggccaHaag
-cVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagttttacaaKcaaaB
-cYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaatactgWBHVcagH
-cttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgtatacMatcaaac
-tagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaaStacaHagWSRS
-DtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHataaccRttagatat
-aaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMcaWttgttgVMaS
-gtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgtttHtWcttgatK
-tgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctgtgtKatRagtaa
-tttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcSHgRcaatttVcc
-tattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVtttctattWHttt
-acaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagtttDaVaattVac
-tactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWcMSYtWagaagtt
-ctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNttaYtaatagRtta
-SagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcggKKtaHcttttag
-HDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctgctKaNattggat
-ggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctcccacDBtgaWBaMa
-accgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVStatagcDgMgtaca
-ttacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggcccgcRtacgDtc
-YctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaNtDtaRattgRac
-RtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHtKtRaScgtattM
-ttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWgataMDaaaactgN
-YacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaagcctggcgKata
-aNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagattcaaaSgtgKac
-gtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgggaaBcctSSVaa
-gctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggcataDHattcaaat
-tcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtttaaHgcHStgtg
-gtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtttcaatgtNctac
-cgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatgagMagttgcaata
-tKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMagaRaNNttcggag
-YRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSBggtaaaVWgMaa
-tttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtttBagtatgBNca
-agHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMaaKtcggaBaVaa
-WaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatcttHcctttaggaK
-gaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataacDDNttatcYaa
-aagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatctRYcaaBctMMt
-cttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBaaatagaYgatgc
-ttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatccScBtYaYttat
-gaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttgtaatMtYaNaKS
-accBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgtaBtcaatMtaHg
-caaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaacaMataHatgttaa
-caaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStcNcattatRRaSY
-tYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacattggYaaDcSacg
-gYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcg
-taacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggttatttDtatHtcaH
-cBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKa
-aDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWgaYtaggataMtt
-cgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSgRaatKacMaYgg
-gtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMcaattcagtDctB
-attgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVtatcKaKSgtaWc
-gtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataattMgtatcataKK
-atDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSStMatttgNtgtca
-gDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaDgaDWtYacMWgR
-aatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatttttcgatcttca
-aKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaa
-cYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaataaatcSVcKaac
-attgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcgagccHattttaW
-tataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcatacaHcgMgaatYgaa
-taatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttccWatatagtKtg
-tcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWVacSHcaNacatt
-tgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattHYtSaYDVHSact
-gttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtc
-gaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttctgctaYttBata
-aRtattgatgaaactagttBgagtcttccatBagatctBaaagSacagtaaStaaatata
-taataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggKaacRagBaggta
-MYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctcttgaDtMgattg
-VgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHtttcagcNtatSg
-gtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaBtctaggcgtgtg
-tWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWttaSMcYtHtaactt
-aaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatRacatgaaagtcc
-tgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNtttBataaagVtt
-VataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBRtaaatRtaKtNg
-YWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccDaaBMgKttgaVa
-accgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNtaWatcaMttaHat
-tagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaacVttYBtaagcaa
-aMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNctgSagtctgcStt
-acSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatcHtcWtagggagt
-DtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatcttcDaagactgtg
-DNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcYaRccHtacRaga
-tccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDcagBaagtctSNa
-gaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHttaKtcDttRaat
-NacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttctagYcBataacVca
-gggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaaMaatWcgctagg
-gtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacccStDtagaDaBt
-gctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBaaaattcccgacY
-tBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacKaaatHatggDat
-SaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaKcNaccWtggttc
-ctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaacttWaNatgtgt
-taacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgatataBattctWRat
-MVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKatVtaWttaVggB
-BatcaaWatgtggagattDgWtttcaataDtactRaatBattWVacttWVNtVagHaHta
-tttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttagtccaKDcacgWa
-aHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatctatttatBaHca
-ttcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataaagVStcaatcac
-gcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNccttcaKHgcgat
-aDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgataYgtgttgtatga
-VcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWagaDttaatRcgc
-taKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaataaNBactBaaRaW
-cRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDNDtBgtttgtaNtW
-taatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDagNgttRDcWtaa
-aKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatttctgtcatNBga
-aaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaaYcNgtgatttWt
-NaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKttBtKaKcHaBttt
-aBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgNtScaatagcaHD
-agtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtgggtNatSaatStcY
-taBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBattaaatcWgKtS
-tKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctVHttaKDcctNcc
-BKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSgttaaatgWacRa
-tacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVgMKYtgtaVBtga
-gattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttBtgaBttacgaSt
-HgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtgacgYattccWcta
-agtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaagtatgVgtaVtgR
-DcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacagtcYDggagattN
-caDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtatcgttattHtHcK
-aDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtctcattVcaRctt
-ttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggDgctacVDtBMgB
-aDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVaBgVtRgggatac
-gctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaNcBttactgtgBY
-DaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaYggcagaMaaggg
-ttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKattaatYtacaat
-cKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgtaccttagcRaWaa
-gDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatVattttacgaggW
-gtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMaaRaRtccVcSat
-tttcaattagWattMMctataWatggtaagagRaaattYKKtgatagcMYgcVcgggSta
-ttacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgtWatcRacaaMta
-ttYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYtDctatccMaagt
-gcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaacBtagWYaagcaV
-acYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgcagtttctttttMa
-gWttatRggcattattVaagaBBttatctattatMcNtaacagttgaaaBaRtaRRtNta
-taYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaYatgYagaDcaHg
-actHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHagaacaDatgaaaa
-tcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatctggaMMRaaaat
-aatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDagYttWctttNgtH
-tcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatcttDtcgaKccKtt
-atttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWacHagtacccattt
-cgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgactattcttgtcatS
-ttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtcctYRaatccacY
-aatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgctacWcttgatatct
-HttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaattWRcaagBtgctD
-KDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKYgtYSaMtgataa
-tNggattKNgaSggactaaBagataacactcataVgttataaSacaatcRRaagtaDaag
-DYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggataaRtBatNcatg
-tatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattacattgWccttHNa
-ttataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaYHWaaHactaaSS
-agttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtatattacgcHaaaMN
-MtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBtatccatgaScHt
-YtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVatagtttggggRa
-aaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgagtaatcgttttaa
-tcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgttRttatSgacNa
-DttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWWagccgaactaYc
-cttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKtaHaaactaNtta
-tagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaatatgggMaNHag
-attgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaatKDatgaaacgaa
-atYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVattattaaaatSVaM
-aNcDBttataYgttttStacattgagagtccaNtgaatttttKtStatatttRaatttcg
-BDccctaaSWatttaaMBStcatacctgctctatctatKatatgaacaactctWBaNagt
-cgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttattatgatctagtDSg
-aHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaaVcccggagWatc
-VaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMtttatSBtBtBgacRa
-VgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaactttcgcttttccatt
-tNaaYgtattttactttacttRataBttgatagggacattattaaSaaaYtgatggaDaM
-ttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgc
-atccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDVttcaYttctHtH
-tagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacVaBWattagaaBa
-taatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSataggtataaacVaa
-tDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaWctaagtYcSatt
-NccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNttatWatacgRtgc
-ataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKctggataagtVgKY
-tatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggtgatcaaBtMttc
-ttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaVHtttttRtgBcc
-agtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaNNgtttVaagctg
-StttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVcagKatgaMttWD
-RatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttattaRKcgtaWatcaW
-ccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaYtttatgcHtttB
-BacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggttaaSctttcaaca
-tHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaagattDagtKccg
-accHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaMaStHgtattttK
-aRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacKtttVggMBcata
-ttDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVDggttaNgatBgt
-ggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtatNccagKatgtVt
-HtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaattggagagggtct
-agtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtcttt
-ataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagac
-atWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagac
-acatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYat
-cWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttt
-tttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDt
-tgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYtta
-RgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaM
-ttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtt
-tttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYag
-WVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKH
-aatKWcBScSWaaccRVacacaaactaccScattRatatKVtactatatttHttaagttt
-SKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttSt
-gttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNattt
-acttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKc
-tacatagYWctgttWaaataaaataRattagHacacaagcgKatacBttRttaagtattt
-ccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttga
-tHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacat
-VtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatcta
-taDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgc
-ggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgR
-tcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctt
-taYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtg
-BattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMR
-taataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRS
-HcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStata
-tNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctataScaHtataRagt
-cRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataV
-tttRNKtgRacctttYtatgttactttttcctttaaacatacaHactMacacggtWataM
-tBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaa
-cKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtt
-tHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgc
-cDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRt
-tRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtac
-cagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYg
-gVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDt
-taattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVtt
-cBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttg
-WatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHt
-YcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcH
-HggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaaca
-StttMtcgactttaSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVa
-ttttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatat
-taaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSat
-cataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWat
-YaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaag
-aaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaS
-atcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtH
-tMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaR
-VatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacY
-gatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWD
-BtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactca
-aatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgH
-aaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHtt
-cgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtatta
-ScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBg
-gWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataa
-ccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYY
-atKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaK
-aYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWag
-BgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgt
-taatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBta
-aactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRt
-ttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaS
-ttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcW
-tctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSg
-aNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDa
-acataKttKatttggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcat
-tttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaa
-DcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttY
-aattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaa
-aataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatct
-atgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaatt
-gSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWg
-RtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatt
-tctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcata
-cRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagat
-agtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaat
-HattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattg
-taatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStag
-WaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtg
-cVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtag
-caYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgcta
-aaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatcca
-gNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMga
-gttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYg
-BatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactac
-HVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRD
-aVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYatt
-McaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcag
-tatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMta
-agNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaat
-gttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtac
-agtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatKagStaNgtatac
-tatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRc
-cRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaY
-KBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaa
-tRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattB
-tctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacg
-acDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYS
-NttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNta
-tVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattt
-tRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaag
-ttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHa
-SttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaDaagattttctat
-MtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatat
-WKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaW
-tgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatc
-ggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgt
-tatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDtcNatataattct
-McStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgS
-gggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKg
-HcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtY
-gctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaa
-NgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctca
-gDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgacca
-tgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWac
-ttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVg
-gcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSa
-attccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaa
-aRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccggttRttcatagtt
-VYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtK
-aatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaN
-NctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttgg
-NtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtc
-gttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgc
-aDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMaga
-atgHMatcttatacgtatttttatattacHactgttataMgStYaattYaccaattgagt
-caaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHt
-BgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagt
-attDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtt
-tDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcct
-RagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttN
-cttagcaatttattaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBt
-ctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKc
-gWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRR
-aRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaa
-ttRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttH
-gSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDct
-aaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataatt
-attataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKca
-SYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattttatatatgatBc
-DtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctat
-ctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaa
-HacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBct
-KaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaattt
-DRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaa
-agaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaB
-cKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWattagttttNagg
-tctcaagtcactattcttctaagKggaataMgtttcataagataaaaatagattatDgcB
-VHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctSt
-attaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacS
-attgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgta
-acgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMg
-tgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgca
-acaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSg
-KStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRM
-ggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccc
-cYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcg
-VttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaa
-ttaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgtta
-aBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVa
-tgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgca
-gtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMt
-ctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatt
-tgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttV
-tagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMccca
-SttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDgga
-WgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtat
-agtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDc
-YKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaaca
-MttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDN
-aaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYga
-tattttaaatttccattttacatttDaaRctattttWctttacgtDatYtttcagacgca
-aVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgta
-tttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaY
-ggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagt
-YccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcV
-tgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggag
-RRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaata
-aHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagact
-actggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaB
-tgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattac
-NgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttaca
-HcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaK
-aatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgc
-aaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggc
-agMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHct
-DWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaa
-taMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtc
-DtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattc
-YNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtt
-tVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaa
-WSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttggaacaatDagtat
-tRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagW
-aaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtt
-tcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatM
-taacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKga
-RaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaa
-tNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaH
-acttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagV
-agRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWa
-atctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWt
-atttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBttt
-aKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBa
-acYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHa
-tattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgtta
-acaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatM
-gacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDc
-gtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaa
-SWccgtatWatggDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatc
-aataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNg
-tcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacata
-atcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgSt
-gattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaa
-taMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaa
-ttaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScat
-agcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgM
-taMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDt
-tgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttg
-ctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDc
-catttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttM
-atacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaa
-SaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcg
-gaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggW
-VtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttc
-WtatKctagDtYtMcctagagHcactttactatacaaacattaacttaHatcVMYattYg
-VgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttK
-cWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccgg
-ggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcata
-RDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttcctt
-acSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgag
-gatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYtt
-cctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMV
-cMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaa
-taaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactS
-aKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaa
-WgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYat
-taaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatY
-gttttgtVaatttaatagcagMatRaacttBctattgtMagagattaaactaMatVtHta
-aatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcH
-KaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKH
-acMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaR
-tatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctM
-tcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaag
-gaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRg
-tYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatat
-ttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatK
-acttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactB
-aagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgta
-catcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaa
-agataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatN
-YataactctSatatatattgcHRRYttStggaactHgttttYtttaWtatMcttttctat
-ctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtW
-tttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDctt
-cgtaWtaattctcgttttScttggtaatctttYgtctaactKataHacctMctcttacHt
-KataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgt
-tatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtg
-aNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtt
-tacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWcca
-agtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWK
-cctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtc
-aMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcg
-NaatttMatatgttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgca
-aYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtH
-WKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggt
-attHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagta
-ataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDa
-aVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattg
-StKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcD
-ttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaa
-VatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSa
-agKgttaatMggtataatgttWYttatgagaaacctNVataatHcccKtDctcctaatac
-tggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgR
-agacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcg
-tgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDt
-atDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVg
-tRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMt
-KtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattB
-atVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattK
-tggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYatt
-cHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRtt
-caMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaY
-aacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttac
-catRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKc
-agtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaN
-aKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataB
-tttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtat
-cRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRat
-ttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaa
-taaHaagagaatScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagW
-atctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaa
-ctttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaa
-RRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMV
-aacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcac
-tDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacW
-ttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggt
-taacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagc
-caaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgtttt
-HtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaa
-tatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNa
-gctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaY
-gttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRt
-aaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacct
-ataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagta
-ttaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDt
-aacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYa
-acaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagca
-aagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDt
-gtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttata
-tVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaK
-actaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVa
-aRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgSccta
-tttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNc
-gHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaat
-ggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgH
-RtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMt
-cgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttM
-aataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgc
-ttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVt
-tatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWM
-atttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatctt
-YtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccat
-cNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttctatattYWtcatt
-BtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSt
-tKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYga
-tDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaa
-BtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttcc
-KagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMt
-aHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataag
-atgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDW
-gtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgt
-aVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRt
-atttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgc
-gatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctat
-BagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRg
-gatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaag
-WBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDg
-tttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaa
-agattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVc
-RtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatS
-aaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMct
-gStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNa
-cgtaatctttMRtgacttttDacctataaacgaaatatgattagaactccSYtaBcttta
-ataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagctt
-atVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVt
-agKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctc
-cctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcat
-acYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaB
-cgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSa
-aaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaactttt
-HaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacD
-attgatattttacVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacat
-aYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattca
-HagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggtt
-aaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggta
-NatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMag
-cattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaa
-HgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaac
-WaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMcRggctttMttag
-acRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKt
-MYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDa
-gcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBac
-ttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgatt
-ctccatSaaRttaaYctacacNtaRtaactggatgaccYtacactttaattaattgattY
-gttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaa
-cVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagt
-cgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatggg
-MagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcg
-tgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcc
-tccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgB
-ttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSatt
-aacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBct
-gagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgK
-agtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWat
-cBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaata
-tcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNtt
-BaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactg
-MtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDa
-gtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYc
-WaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagY
-MttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaK
-tMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgt
-tatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgac
-ctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatg
-acacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVN
-tcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaag
-aBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcD
-aHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctH
-atgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagttagMVgtatagac
-taactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYS
-tgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHct
-aRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaV
-cgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHK
-tatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaa
-tcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagc
-tWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacattt
-aaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaac
-gVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDt
-atttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDa
-KaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSag
-tttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattct
-cctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWa
-aaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBaga
-ggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHc
-RagattttaSataggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaac
-HgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtN
-tcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtN
-RaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagta
-YtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataac
-cctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaaca
-cagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaat
-tataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttg
-ggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMac
-actYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgta
-tttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcg
-RtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaa
-ttgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaaga
-actSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaa
-NattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcK
-cYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaa
-aaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWt
-ctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttc
-tgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaB
-gWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSS
-aaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRg
-caSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaa
-aVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaY
-gHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacg
-gHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagg
-gatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaH
-atBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSa
-VttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgatt
-aatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatg
-gtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtB
-WtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaatagattcctScac
-ctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVK
-atttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttga
-gttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatR
-VYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRga
-atatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagca
-cHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacac
-YtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaW
-tSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHggataatYttYatca
-taDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMg
-gaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMt
-tcttKtgtctaacVtatctatatBRataactcgKatStatattcatHHRttKtccaacgt
-gggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatc
-gVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaacta
-atgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRcta
-taYcttatataaagtatattaatttataVaacacaDHatctatttttKYVatHRacttta
-BHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttg
-McattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNag
-ctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttg
-tDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBt
-aattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgc
-gccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHt
-MNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYg
-RDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaa
-aaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYat
-taataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgca
-attcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtatt
-aattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgt
-tgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattg
-ttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacga
-gaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWa
-cKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaat
-DMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttaga
-ccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtSctt
-ccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNt
-cagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcga
-ttatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYct
-MaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttc
-cgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtStt
-gaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDatatDcataaaat
-BBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgB
-tSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYta
-ttctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaa
-atSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYga
-tgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtac
-catNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttat
-YtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDta
-MatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtc
-gKtgatccttNcttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaY
-atatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatW
-tYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaa
-atgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWta
-WVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtat
-DNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDt
-ataaattaaccaactMtacataaattgRataatacgBtKtaataattRgtatDagDtcRD
-acctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgY
-gRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatS
-gtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttagg
-tttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaa
-taaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatga
-gMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcat
-tatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaStaactScattatta
-acgatttaaatgDtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStR
-tagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtN
-aNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatataacgHaaaRagK
-attSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtattt
-ttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatD
-ataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSac
-gagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMY
-tatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctgg
-tttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcat
-ctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaa
-gtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttW
-cgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctact
-tctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttata
-tcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccata
-tttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagctt
-cattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaW
-aataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWa
-cDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHa
-tattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRt
-aacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgaca
-gaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaat
-aataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattH
-tatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKt
-atcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBtt
-aaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctS
-gcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatcagttttYttagY
-aacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgt
-tggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttD
-ttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaa
-ttaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacag
-tHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatg
-tagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYa
-tgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaS
-acgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWR
-BtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatSt
-ScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaa
-YMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtca
-gaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWa
-tcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgac
-cttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagatta
-tNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYag
-aggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttca
-acttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacM
-atagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNgg
-ttaYVatgaactttttgccatataaataRatSaBctagttataBccgaaacaagatactt
-aattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWag
-attWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBc
-MWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaa
-MctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDt
-ttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcM
-ggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatc
-VgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatH
-gNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMa
-gSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaa
-gtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaatt
-DaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtc
-YtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSY
-gataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHc
-ttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgc
-ScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBg
-KgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaD
-HacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcW
-caRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtB
-taaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcgga
-gttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatgg
-aaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKK
-atgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMa
-tgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVtt
-ccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVat
-tttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgt
-aacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHt
-agBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctcc
-VgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttac
-aaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaat
-aDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtt
-tggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRt
-taccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVta
-KatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccN
-ttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDt
-tggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacg
-NBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVH
-aKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDt
-MtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHat
-cgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNtt
-aagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSc
-taaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKt
-caaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDta
-ttctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgat
-MtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBa
-tatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatc
-gaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatS
-taKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHt
-gatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtg
-tSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWR
-tRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYS
-tattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDa
-gttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagactt
-attgattaaYttatcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaW
-gcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaN
-tttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaa
-atcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMatt
-ttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatc
-ctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattat
-tttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRac
-aaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStag
-cBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRt
-tSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaatt
-atcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttg
-NactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRt
-RataaattttcatHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgK
-tcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactcgctctatttaga
-McgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaa
-ttgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNct
-taDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYact
-cKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaat
-RaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgag
-aRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcS
-agaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttH
-ttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcS
-MRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagctaDagMtataccY
-gaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaD
-tgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMga
-aYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattH
-aRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatatt
-aaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaatta
-KaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNg
-cDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKca
-aatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaa
-YtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccK
-aHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaag
-tcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtt
-tVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHa
-aWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNat
-tgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaV
-tgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgW
-tactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaag
-VtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNa
-aaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgat
-ttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaa
-tattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtY
-aNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaa
-YacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactct
-WtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggtt
-gtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactag
-KtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctt
-tagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgta
-ataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtat
-acgttttacgacgKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaat
-tVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMg
-tKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcg
-NatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattg
-cBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatag
-aataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtattta
-aYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYgga
-ctSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagactMatgttRgata
-cccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatag
-tagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttac
-tBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaH
-WBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaatt
-BaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtag
-tVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtata
-actgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacat
-cgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatac
-YacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtcc
-gYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYc
-ctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgctScSatNatacaY
-ttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaa
-gtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKB
-tacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDggg
-aatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaS
-DtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHa
-tBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDt
-ttDaccattatatSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccag
-ttttgtcHacMattcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRa
-KggtaYcaagttDttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMat
-BgKtttgHtHactaatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDct
-NttaDBaBgatagMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaW
-tctcSSaaatcSKattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHg
-ccttaScatMRcaccWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttt
-tRgWcttMtctaHacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgt
-BatcttacVcYacNgaattaacgagttgYgacttDattatacBattMgctagcctagatV
-caactNttcctaatgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVg
-taScMagatNNtttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKY
-gagttaHtgcDYataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagca
-DctaatgcBatttacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBga
-ctaatgtccWaaHataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtca
-gcatBgNNBVttttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaac
-tgttaatYatgDctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaag
-gacactctDggcgtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaa
-atcaWggcNSBagttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaa
-attgRgcBagtNtcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSattt
-NHaMcggcagSctcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatK
-YSgDaacNtcVgtttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcN
-HagtNtgtKtttgatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttg
-DttWcaaRaKgaaatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtc
-ggcatMttgaaggDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatc
-atNgYgStggactatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagacta
-agaggtatWtataaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStctt
-aWataatcHttataRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRt
-taataaRRttgtaagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSactt
-agcgtKtgtYWatatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttatt
-ttgMBgKaacaDataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagct
-HYaatgcaNaaRcaatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattN
-ctcNaKggWtMatcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNt
-cgtgtctaattaaacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNSc
-gDYaWtatDatMKgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYR
-WtatttDtaNMYMttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaa
-gctgcatctagcttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttK
-gttttttagtgtDHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWct
-aataaattatYttagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgatt
-acgRctctccaatgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtaga
-KHVtacctVtcaaccaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMc
-tgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKat
-atYDcBgNtRaRacattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtca
-tYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgt
-taVatttgcatctaatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMtt
-ttcatKSctNacHcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVca
-aaaNHaaaatcgctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataB
-atBttttWtaactNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactg
-tagVKtNRtcctagcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgD
-MttaHcaaYYtcactgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattat
-aggttaattgtaatYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgS
-atcaaactaattDtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBtta
-aaaMSaDattKRcctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVg
-tcHcttccgcctattDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtca
-WaYMttacttagVWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaag
-ttgaaBBaSHacVcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaM
-ccaaYStaataRttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggc
-cHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtatagg
-NggtgaatagBgagYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaa
-tgWtcStagcVatNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDattta
-atttataaHtagtVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaa
-gcctRgaNVgggttcataatagNatcctacactacgcatgtcggaYgtaKcatggattga
-ctttHtaattWNRaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVt
-atttWgcctaKtatBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgctt
-gcRagcgctSaatagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDV
-gRaMgcDgtaattttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattca
-KtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatga
-NccaaaaWaKatVgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatct
-acttatatcacYRaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRc
-StYSYaWRgMtacaHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttgggga
-BggtNtgtcaaWBaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRN
-aNtHRttatttattgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtata
-gSccaagctKttaaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttga
-aBcctVagcaaaatgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRtta
-ttggHtNtataatggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcY
-gcgagagRgcHMgcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttatt
-RaattaagaccMKtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgV
-tcatKcgcaatVaactatgcgaaactccNctatatMgactatttatSaaVttNttRttag
-HtccKtHtaaaNatttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYccta
-attcMNtgtYtgagttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattact
-VagaYtgaVVcgcaNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaB
-tcYYcatcgtgtcHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBac
-DcBgatttaaaNtggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKaga
-tataaYVMtaaDtaaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataK
-YagaYaVatcWcSattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattc
-SaDagVaMattattYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttc
-aatgtaMHSWaRtggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagt
-tDtttatatgttWBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaa
-gKtaKaWaataacKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMg
-tgccaBaRaaaBVtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttc
-SttttKKcgacBgggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDt
-gBatgactBaVtaagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaa
-NtNttcaaatagtaatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKat
-ttgatcgtVcatgaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctW
-SKttaMacaaDattccaRaYttttagttaatattcctYaacVactgctMcgagcaMYttt
-gaagctagtKgNWttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtN
-tNWatttSaHactagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSaga
-HatYDccagtBtgaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNca
-ttataDVDactatattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcH
-aacgttaccDaKtatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatV
-actDttSKtcMtDSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttac
-acaaatactcaatSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVat
-aggaagWSaaaaKatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHtt
-VtcattatctagttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNa
-VatcactVttBKcttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSa
-tVcggactMatatccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMa
-aaKDBttDNccatttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHN
-caaMaHttgtggctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNc
-gtWaWgaccgRSttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaa
-KDaWactWagBgctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMc
-aYcKtaataMatttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYg
-tagattgcgagtcaagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttcta
-WtatctYacactgBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttat
-gaccMaatgtaHtStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaa
-gatDctacggaNctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaa
-tcVttNKtaaWtYacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatct
-acaacKgttBatYatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgN
-tRtHaagcaataHcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRt
-tctacKaaVttcVcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtg
-attgSgaBtgccBtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRc
-aSgcatattatStatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtN
-YcRaYtVtggtDcKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaa
-MaKattgaagtBaaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatgg
-caWaaaaVaBgtaSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttY
-MtagtaactDtaagWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtc
-RtRggNagtYMattaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStag
-McctcatgattaWRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtM
-aDYatgDatttatagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgt
-catactcaaVcYBgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHa
-HtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgtt
-YattttNagMHaaRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcg
-cYgacgNtacNtccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaatt
-aactagRttaVcSaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWV
-ataatcgaatatgHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaa
-tMBttRRcRatccatagagggacatcgccWttagttgWttatKagtaaaagHtttccttS
-atVatKtgagcaatttattaaYVattcaaattctgSattRaMtgaatMgttattattaca
-NcggVagccttaaKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgact
-tKYtBacatgctDcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctY
-gcgcaaaccaHttVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaata
-aagacgKttcaaaWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgK
-tVVaaacaRaattgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVH
-aatVSVtccggatgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcS
-tNcatttVgctatacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtM
-gatStStcagatatYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcag
-catVttSgaaaaaatatatgttYttcattatacataatVcacgattataDggttBtRaag
-tHMtatagaDgNttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDat
-tgaaagggaagaHattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtK
-WaggtatttaWaaRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBB
-aNatRcDattcgaactataaattataactcagtSgatataagRaYaKHctggtaaNttta
-aNgaRHtttattatacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaa
-aaVcBgtWNtRMttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctN
-SacRtMatDactStVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDat
-cgtatVcaatWRtaggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKY
-tgctWgagYtWcctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagtt
-accttattHRgtacggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSt
-tagKtKttttgNHVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttt
-tKggacaWKaattKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHg
-ataatatgtattWataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttt
-tKaSttactWYtgBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWagga
-VccttNgtgagtcatataWttYScMtWgVRgattWtaSggacggWWctBHatattataaK
-aagttactaMRaaataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatc
-atggBWaagHtagtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDgg
-DNVcaacgSgtggcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatga
-VHtNMtcttactDaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatH
-NttgaatSaagtKBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggttt
-atggBgtcaaaYaDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMa
-atBgaatSttMtNaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNa
-aBtMgagNgKcttWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtg
-MctatcccacMcactcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagH
-tgtttctcttgtggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaa
-MYctNaKWtactaacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaa
-actacaggMatgtYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMac
-tcaaacStaaagctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattR
-acKagttattgaMtaatgaNatacDataaggactttccNtStatatKaagaataKtatgg
-tcctctatgaggttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNt
-agtWKatctaaWBactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtag
-ttaBaRRgatttaagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWt
-tgVgcHaWttcaNtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBB
-WttcttRaWgaatBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttK
-tcaYWatKtaaDtttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaactt
-ctcBtMtgDtgtttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDt
-cKtagRtNWaacVgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcY
-aSatNStcaatDNgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHcc
-aactKttYtatHYttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtSc
-aacggYtHtgcatctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaR
-atttStcaatatgcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaB
-tgcDacatcaHKtRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBat
-ctDatKaMcattMatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaat
-gtaaaactNgtagaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaa
-taSgttKgtcatKaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgW
-YcacDgaatcaatactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaa
-atcaccBtgttgNctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtSca
-HtctcHacVatagtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWW
-aaaVaRtcHNtctcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatcc
-ttattcttNggtBgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagY
-tttaatKcScctgaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattt
-tRSatagttSacataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtc
-aKYtaaatatggattataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBt
-tgtaWgagtaatWKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgac
-tMtgaaDaggaaaSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWa
-gatHttMHactaRacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaY
-ggctRWttaaKtRttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYt
-aRNgBDttMcNtggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgt
-YtDtgWaatcHgatDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagtta
-gtStYatYtttccgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNt
-aaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataa
-aaMBaaDtaMatDaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtca
-YKaRacagttHDagccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRt
-ccVtgtgaagVNttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBa
-tBtgaYSagHttSYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaK
-WactgaaYgaYactatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaa
-attSgttaStatggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgta
-gtctattttaaggHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYc
-ctaVKtttaYaaatYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgat
-caatttaagggctctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatH
-HgtacatgcaMagtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWt
-aaStcacgtctNaagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStN
-aMgDtaacKtMtacctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatc
-tgVatcacYctcVHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaat
-tSctYatctaagDgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaM
-atggatgtWagRctStagagaagaacagctWtNtataaaataRatHatKgctNactHgtt
-RgRgVcRacatgHYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgat
-cttctagctctHMaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctt
-tgaggHcYNaaMHtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcat
-tttcgacctctcacVttNtttattgtcttctaVcatagaattMttgtHtMgacataaata
-gttctMtgtWgWctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcaca
-tcHVaDtgttBtBacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgc
-taatatatgRtWVttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWt
-atcBtcataacNcgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgag
-agaNttgaattaataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRW
-cggctacDaYSgaaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgt
-aBRtttaactattctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYt
-atccgattcYtgaaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgc
-gYttgaaatgatKBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSat
-taaatttggtaagcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcag
-gNcaccctcBtgcKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcag
-NtcagaatYgttWgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNg
-tgcHagtacagctgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaa
-acWccggtaaRcattgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgac
-HgacgttcaMcctcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctS
-aKaagaatWVtcgttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaact
-gtgagcVtttaRcttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYa
-aagKtataMtWStcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatStta
-VgRtWgSggcaatSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttB
-actatWStaNtcStcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaat
-aatHKgaWgataYcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDc
-aacNttactattacggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgat
-aatMaccWagagatRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaB
-cctaagaSMttcMtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaa
-YRtgctSctaaaaNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtt
-tVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgH
-YtcatagaaRtaaBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgct
-aHtgacagcSNattcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtga
-tNagYttHtYtagccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKt
-aMHgaBcaWtBNYaWgtttStttaSttgataatgactMKatHBtttaVcYatgggtttta
-DKcSatttMatatcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaag
-aVtctccgaRgtRtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgca
-tcaaWatgttacatgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaac
-NWRHaaBaattDaagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBat
-aattgDtagccWtcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtSt
-BHactaaRaactNctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRa
-gaaacacgcttcKatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWac
-ggttcaaVgagaaacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatctt
-cgaatacggaHtaatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttY
-ctcWtRaaaaKtaatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaa
-aBcKcacMactMHHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggt
-aatatDSatgcctKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttg
-DaaaagttBRatHgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgg
-gcttgaHRDaWgatttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgc
-taatMaVBccaHtDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgB
-ttRNtNggaagcWtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDt
-aRatttDaaagNttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgB
-gaataggtWtKaaMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtK
-VccaaatcgaYVtaaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaat
-atacSaacctSatNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggta
-taaaggctcctaSatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatt
-tattRWgcgatcttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHg
-BgNcccataDtaaaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNa
-cgVRVctttttaacttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtac
-NatttttgaNcgacaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgY
-BggMScgaMcctagcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcM
-ttgatKgNgaNBatcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgt
-tacatacttYacaataNaagaaaagttataNaataSatacagttScacVaScaccSWtcc
-agKHtaatcaaatVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtg
-aatWaataaaaacatttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaN
-taNVBgcaataagaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgag
-atYactggttatgtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcD
-atKaacgtttggVDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttK
-agacWgHgatataaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttac
-gRRaaMactcatBacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaV
-tctDVataWtSgatagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagt
-atcaacBaWYctgaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacV
-actcaVaagtggtattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRM
-tacRYNataagatcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaSca
-taactRattMtDacVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactc
-gDaacDtaWctatRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKt
-VWtgacagKWattcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacac
-cBNaacagaaStctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRt
-agcatgtgcgagcScaMgtaatBaKataactMttttattaRcattattatacgtaagSNa
-tVRgcttcgaVaacHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacg
-tgcaBgccaWgaVataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtct
-cagBMKatgattgaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccac
-aaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaacta
-gctttcacaaatYtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaSc
-HYaKcaYacactVcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacc
-tattacRcaaMacHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKN
-tattcaagWKttgatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatN
-KSBcKactatacStcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaactta
-RtaaDSttVBYtaatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaac
-aacactDttVttgacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcga
-cYacttaaggVHcaagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcat
-gYgtgaVMtMaactaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBg
-ccNacKMaHggcBMttctgNctHggagaataYMgtaMccaataattHttYttKggtKacc
-aactcccHtMSaatNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDa
-ttgWcctcactcYccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDgg
-KtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaaca
-tgagatVtttaaggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacata
-aactactBgcacaacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaa
-DScaKtcaBVtaMVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgK
-cHVtatattSaaaatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKcca
-WVWtaVcggttatNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaat
-agagacttgHYatattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtc
-tcggatttatgtgatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcB
-cDcaggcactattHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaS
-aWMattttMacKtgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagag
-aSttgattgtSaaacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNca
-aBtattKaVNaWaNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaY
-ctcacKKgaSMgcRgKtgccagNMataatccaVgatcttHagttttcttaaccatagggg
-cttaDtYatcgaaaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgt
-gNttattYctVaaactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcK
-agtHaBtgaagBcggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaa
-NgtcaBMgggaatgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctatt
-aaagggaagDWVccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctg
-cctKWgttDDaSKactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttD
-NgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaatac
-cgBDaYRaggatatSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaK
-VgccRYctcRaKBKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSga
-cggtggVgtBtgacatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctS
-MKattcatagcacagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaata
-atMaYagatgVtatccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactga
-attaaaaaNattRNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactac
-ScattgKVtataaKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaY
-ttatacSttgYaYttcDNagggttVDagHatSgtacYVatataVattataSataacgKga
-tVtVacHYRWttatcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVg
-gaaggcYgSWaaattcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVt
-taccgaMatRaaaBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggtt
-ccaaagRRtaWtVctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctc
-cBtgtataYctatgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDa
-StatKtataBgcVaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDatta
-tKtVacgVcScaactSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKta
-ttaatgtKHacttcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBg
-BaMacaattaDaactNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataag
-agaagRgatatttcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtg
-ttaaRtatgtaMaggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMt
-aKccYacgNNctttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatg
-caattcMcttatKgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScSt
-BtagctWtHaaWattaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVag
-HttVtaagMaNatcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaa
-SaKtatttttMtctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaat
-gVSctgctYgaKgKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStca
-attWtRcttttaaSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDt
-SVgatgaacatgcacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtt
-tagtcaaSSaagaaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDg
-ttcgtgRtaMgaattttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgtta
-caDacaHDDagWtgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaa
-attcagcatagSgttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcct
-ttKcttWaggctttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcga
-caVtatataggataKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagtt
-caDtHtatattaacYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWt
-aVatttgttggactaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYgga
-tgNgaatcaatcRtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVact
-BMtatgaagtaaaaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtc
-accgatgagMtgttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSatt
-gKttaaBaKttatttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaat
-ttccBatBgYBRtSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtB
-ttatgaDtatKtcKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMa
-tcagaaccgaatKgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaa
-attDStDtcKggtMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtata
-gcKgWgttgaacgagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRatac
-cWctctcgBcgaggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDat
-RgMBaBacSaataSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYta
-DactttSgtKtRattgatttatatattattataattBatagattctaacDcRMaaggttc
-gtcatattRVYcttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacY
-atKatBaccMaMaaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKY
-tHtacttgtacaaaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaa
-WtaaaataDYtcaMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgata
-NBtaattggaatgcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSat
-tttaacHtgtagtBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRt
-WgtttaVtggcaaactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaD
-aaagtactgtcgatttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggata
-ctctaBgtYHMcttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatS
-gtatcYtaWcatgtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaagg
-ttgacgtRattKgaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaa
-gNKgaagacgDaRgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcSta
-ctcaatSMataHcaKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagat
-tagcatcctaMaaMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagtta
-WaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatR
-tYaMWDttatcNtVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDN
-atcYaggKRacaatcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagK
-VgcttSWaaHatagHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgttt
-gcRaVNttaDgtcttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatD
-agVaaaYgWtNDBgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacc
-cVaHatcBRtcttttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWa
-tMcMatatttDctttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttg
-gcctataaDgtcBctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgct
-atKttRatcattMaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattcca
-cgtacgaDStatatctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttW
-ccttgKgagtctagatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgt
-tactaaggtDaaggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRcta
-gatttDtaaatRcDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBa
-tggaDMgaBgatatcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgattttt
-aagaRaaggatggYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcW
-aagtaaggWcgMDaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaa
-ataMcttaWtatgNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRa
-gSgattctatgtYtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtat
-aYaatWHSttattgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatgga
-gWtaMatcRcccacRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcct
-aVcttaYBDBctRgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBK
-gagaatttataaaMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaSt
-acaVttBttcttgBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMt
-aaHtBgaaacaaccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttV
-catgaaBacaYgagHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtY
-aSaactgaaNWVagtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgt
-tcaSVtttacctaatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttD
-tgtcNtgacKagcactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaa
-ttWBctttgKgVcatttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgag
-ttctacgaaBgWccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHg
-gNatNttWaaacaSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaa
-gctMcaaagaYtHVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaS
-aaaWtSNBtttYataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaR
-tctcYgaatDtRcHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtat
-KaaggtaNcataKRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataa
-StHtacttaYaDaMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVga
-caWgaaaaaVYcRKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaa
-taactSttRggtcVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatac
-agctBgagcttcHcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMa
-gtaattggattgYYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaag
-ScaDaSttcactaattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHca
-WagctgtgcYatMHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgM
-atDaWtcBatagtaaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaagg
-tgNtttVBgccttgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgttt
-aagccaRtatRMcgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaag
-aggttttcDaRagtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMc
-BDgYactWgSgacBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaa
-BacDcttDtttBcatVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNt
-ttttaggMcWttNaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacM
-cattHtacaatttctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatc
-MaHtcMtaSctgtaYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBK
-gtSWVYtttctWttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWa
-gttSttttttaMaRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcac
-ggaatRatactVgaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDt
-taKBHccgtaHaacaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatc
-RgttttHaNgtKctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaa
-cKaKKtaaNtNataaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSc
-tgtaHcgccgaMBaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatc
-KaattcgHVNatNgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNg
-tcaaacgDttaaggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaD
-tRaBSaWcNacgYaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgY
-aatattgttttaNggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKB
-tNHtttctWWtattgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttga
-gtcVaMVgaatNtaaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactgg
-aaKaWYRgcatgcgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVK
-StaNcMtgatataatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVa
-tactgcctcHcataDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataatt
-caDtcaDgttgtatRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaat
-tcggaDcgaVtYattaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStB
-aaatRgaacMSaagaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaSt
-actgDBagVSggtSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgc
-McggVtgtRtcatctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttac
-aataggttWcttataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccct
-atatgcWtNttacctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMt
-gcaVRaaHgtaataattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYt
-taaaaacagatataaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBa
-tactataVttDttDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgN
-tgDKYcaatcataWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNt
-gaagMttSttttgDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcgg
-DtgtRDRcaaatagcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaK
-ataaacttKaaaMVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRt
-BtaataattgtttgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYat
-ccccHtaNcattcacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBt
-aaaYgatattcgaaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtac
-tRMttactgtBggcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVt
-aaRgKcttggatSYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYta
-ggaaKtYHcttgKattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattat
-BgcaKWKtagaatagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNa
-tRcYYHtaacMaSStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctc
-caDRcaHtBSWcYtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatS
-gatgatHKgttgcaaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatSt
-gNgWaaaaMttgcYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatg
-ttaaYcagYtgKtYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaS
-tttagaaataatgcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaV
-tYggtaaaactgcaagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRc
-ctgttaHgWRaattgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgttt
-atgaHaaggattStaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcW
-gaaaaMcagttctgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaN
-tggttSattttcaacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagca
-atatcagWatgcRVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactt
-tgtttgaccatagHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatc
-agaatgtHattcaVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtat
-ttggaSatttcHcgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaac
-aSacctgtaaRgtcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKag
-ctDWtttatatWgDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYt
-gttNDggcHScaaYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHt
-agataNaattatcVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDg
-DMacttattatgaDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtat
-HagtttaaHtcagtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtK
-taSaaBatMtttgttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBcta
-BaaaataatttttNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaa
-tgaYtKaatYtaaggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtact
-tNtaagHaSacgWggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgt
-atacgatKatataaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacct
-KSttBttaatMtgcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcg
-WtWBaRKVtYWWWgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgS
-aaBaVtcttNgtcgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtH
-ttSMactatHcaagaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcS
-BtatgacBcctcgggtaatWaaWtacacaattctRVgattctatgtgtatHagataggga
-cVaattttDtNaWKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaH
-tcWgctagtgHaatBatSataDatatcacccaagattttcSatKgatWtgaagtcBMata
-aHaaMaattatgcttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttK
-atgtctctBMggacatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRatt
-aaBttVaHtggattagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBa
-taKacStHRatctVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWg
-ctgtacttttatgaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttataga
-aacacScccSaNtaaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaa
-ScccSggaMDBSgcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgK
-StaaaHaKatatgBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccag
-tatWWtaRtKagatagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatt
-tBtatHtctNactKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSa
-aDBaaaaagaWaDtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataat
-tcNctactWaatNaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaV
-tctcgVctagctcgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatY
-taagcattgaatttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaag
-MtDatgWgYaataKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYa
-aWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStct
-ggaatVtactaSNtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaa
-tVtgttacBcctStgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDa
-YtaactaNgtccaattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaa
-RMagataMatgVtVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgt
-NgYatgtgcYtaatgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBtttt
-cttttYatataNaWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSat
-tgBatSRtgKHttacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDt
-taacSatttaatttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBa
-atDttatgKRKagataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttat
-aaacaaatttcccttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgat
-tBcSagaDKtttHtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVg
-gttYaaggattccaNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYgg
-DSgKRaSttHStcatgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHg
-ataYttNattatcVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNag
-aNtKtaDtgDtatgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacatta
-aHgMttatcgtHMNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatga
-attgatatgaWgccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatata
-caaaatttcgNHgMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKag
-tKactatMRtgtDtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVcc
-ttagRgWaNaKWttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaH
-NtcRNRKaatactcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtt
-tYtatgtaaaggattttagatattKMcatgYaaatcaVactcagagtRYtgtaactatag
-tBaDtVaWatDatctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVata
-VagatatgtaggcWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggct
-aaatVtctcagRagDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMac
-RaattaHBacRcNaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgc
-gHattStSKYRggtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVac
-atacacaaattaattacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgca
-tgHRtcStVtaatHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaa
-ctMKttatRcgaataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVB
-taattWtMHgNaWDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattg
-SWcttagttcgtHtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaS
-tgccBacctaaBagttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSa
-gttcacgtaDaYaaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRt
-tttBMHgRMgHagtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattag
-tggcactactVattagatctctgtttatcattYttgatHcHttagStgatgactctDaaa
-tcagtgttgtttttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKact
-tctgaaNaYacctNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWct
-DtgtgctataKagtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaY
-tagWtggtgBcStacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSg
-caggtgttRaYcaaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKtt
-ttatMaaaNgMatYattgaatNtatVaggtKctttHattcatttatYtattagtataYtt
-tagYcattagaaataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctV
-caaVagaatttaagaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataag
-tatVgtDgHaYttcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSa
-caagctaNttRYagMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgc
-tacNKaKtagttgVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWta
-cgWtaYattaaatMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattga
-gatccNcaaaHttccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccc
-tctcttaccDtHcttcctBatcStVaactaatctacatgtacataacDgcgaVttataag
-caaRWataattcggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaa
-VgattVDtaaNaccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgca
-WtgagYtacttNtaagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKt
-DtRtNYNtctactatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKM
-RtagKttaatagtggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagR
-tYacgaDaaMMtcagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtg
-tgttRtgacataaagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatc
-caatacaNtgcgctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatc
-WgtatScattactSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgta
-acSaaagYaMataYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVttt
-aDtgttatattagWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatat
-taNaDtcaatttaVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggtt
-ScaaccVKHaaatacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWctt
-ggatcRctctaDagWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgt
-tHSMaWttacaSaatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDN
-acattcMDaNVagatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWt
-acgaaHatatBaaSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaac
-cttRtatNactMtcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaS
-RtHgaaaNcaWYBggataatBactgaataYgcgtaacccactHataagaaWgcgRaccca
-gagaVtataggcttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtK
-ctcgaaWctDttttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagt
-aRctttaactattNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgtt
-aaatRaBRttcatcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHaga
-tttctNtWatcaaaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWc
-tctggaccatcaBgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaat
-actgWcKaMacRSaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgc
-tHKttgVtgacgattgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatt
-tMttaaWBtctcgaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMt
-ttaHacctVacctaaagtcactttcWcaatggatSaataHattacaMggtgaaWaacaga
-aattgttggRggcgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcD
-attcaaacHaacttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttg
-tVatgacaHtgtacatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttD
-BggHgDtgaatcaagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRat
-acagattSMttaattYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggS
-agaKKttRggtttgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDta
-aaWtttagHMSSaagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagag
-gatWcatttgctatcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDga
-NYttcattRtagNDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcag
-ttattcataaccNaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaN
-catVtgatcBaRtttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattc
-atatWcHtagtagatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctg
-DcacattMctNgWattatatctSttaScctaDaatatDYataaaaatataatNctKaNaa
-tatcSgagttaagtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNta
-VggatattatagtBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaa
-caacgRtaattgggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDtta
-cggagagtMtaNHatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtat
-acgatVttKcVtagtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDt
-catMaNKtNacagMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRW
-gtYtYBatDcattggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtga
-tgattgcRcgtgSaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHta
-DaaDtttccaatMcaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgt
-aacctagatggYKRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYc
-KtttttgatatacataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttga
-tcaagaDatgaWtRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYR
-atcggaagaRtattaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctc
-ctaVttRtBattaatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtga
-ataacggHtaaaatatataYtacBcattttSaaSttgatcatccacatatgcYaVcatta
-tcaagacYcMaataagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHca
-caatatKatgRMgatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDctt
-HaDcctttgggMtcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtV
-gaHagDNtccBVaaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatat
-ttaYgaaSccaRacgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKa
-atcaggaDYatgVcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggt
-MaattaRcaaggaatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaB
-tattVtatttttatYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWac
-tatataaVccaNtcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagta
-tYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScM
-RMaBttctSgacKaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtc
-KKtBYgtagNtatgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtc
-VagaagcaaaaStaaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagt
-ttgcctatRtttNtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaa
-gtgHgtgtcScaataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVg
-tcaatctaccaDMtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDc
-KtgcaccttccBccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRt
-gtYcYttaagataaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaaca
-DttcaKggcVcgtSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaat
-gtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtY
-MtcatcgttcRatgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHB
-gaVaVattaatNNgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattN
-ttttaaVctYagtRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaata
-tMgtgNtcttNtgattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaaga
-gtactccattMatataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgK
-aWaacagttYaMtNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctW
-aaggcacatgWtttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtac
-SaMStattBgcatttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataat
-acaMtYgcggcatYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcatt
-MtatccgattaggtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWa
-MYgatNacKNNMatcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaa
-gBaaatBVactagaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVa
-aatgcaYaaggatgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRN
-aKRtKcaatttgatWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYc
-cctBtWttttYVtttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttca
-ttMtttWcgtNgcgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVc
-aHatattNcactttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaag
-taaRaaRttggtaVSaagaattattcaatNttWcaWtaggattScaStgattBagVBtta
-NcNaSagttagtcttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDat
-cSaVgtgMttaHttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagac
-cKggRattttaNcgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVca
-gatccccStaatRMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtct
-aaBDVcKSKVatSagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatN
-ttggttDtgcDataKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBat
-gacBRctgatDcMaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatg
-agcatStaBtcctgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYc
-ataVtagVagtVtNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBN
-RatttacatttHctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaa
-BNtNacRgtttBSVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtg
-aRtMttgccVttatNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtY
-DcDactttRYtaaatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMc
-HgtaactHaaWattKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSag
-BaaaVtYtgVtaNtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatM
-attVaSatSBtagVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDttt
-cattVctccagYtcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRa
-tgaaacVccgtcaKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHt
-SagaaacgtaSaatctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBgg
-aHaDWWcYctYtcatctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBt
-aWaatYcVVcacMatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaW
-atSScMMgctatctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtcca
-tttcagctactccacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttV
-attRacatctgaaccataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaaga
-DaaattKttNtaataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgt
-gttcctBtBtgttatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHa
-caaattgttcSttBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKa
-SNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttK
-tBttttttagcttcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaK
-aacttgattttatctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgS
-gtatcaactgHataacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHM
-gYgtagatctctWttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcg
-aSctcactcaaaaYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagag
-gttaKagtcYtNtgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYat
-tcVSBaMDcagatVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttM
-NVaactWWKcaaataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNB
-VtYagKacHRggYMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNtta
-atatgcaaacttWgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgaca
-WatYcSacaRaMgttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBN
-KNatccgaacgtKgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYct
-accMcgDtgBaRtaaattaaagctKtaaatatatVgctgaatatctMatccaattacaSY
-gcactWttaRacattgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBt
-aaagataNaagtaaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttat
-tSatacSatttRtBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatattt
-gtaaKBgcacattttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSg
-WtttataDMcttRScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHt
-ttDtaattHaatctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgtta
-NaacagNWtagtaNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaM
-aaagattKgaaaaKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctc
-YtaacgtgtatacttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtt
-tttattttatMggaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKga
-MtgtgataBagttMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHH
-DtgattaaccttttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDtt
-agaacSatcccaYtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVa
-WgtaBtaaStVtDYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYa
-atctatSatagttDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDg
-BactaMttctVcaacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatH
-tacaaMatHDttcaagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataa
-BHagggccHagtaaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataa
-WactVtRtaatgtHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaac
-taVttHcatccgctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtR
-VattaaagtHtaBgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtg
-taaaRatYtcgggtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYt
-YactgtatWaaWtaaggtacaDacaDgttStgcttatctattatgttgStaaDaaattag
-ttRgtgcBgRDtaWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgat
-tataWctcWMgaHgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaND
-NggaaacgataatttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtM
-taYtttaaYgaHttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgttt
-atagacataMgttgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNt
-atcMagYaacacMcaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgY
-atHcggatactDDctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgc
-aMaagaacSctHRtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNac
-aaaaagaaatgatacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcR
-YtggtatccBatcaccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScB
-tcagKBgYtaRKttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVat
-attKactatcttDacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaat
-cgMStttaatKacaVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMcca
-gRtacaatatcttatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtY
-RaHagYtcVgaagaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaa
-acaRRBaVtRtgHacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNaca
-ttacWcttacBacgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaW
-aSMttgataatctataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgc
-ggacaBaRattttcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctY
-ggcMtactatgtgaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHtt
-ttttatRYYaccagatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttc
-attattgYcHtgatcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMt
-tccNtWgtVaatNtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatcc
-ttaattagttaaatactgctgNcttgctcatatatactaDtagctagRcataBcgccRaa
-caagcacaagtaHYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactaca
-ccacggaagcStHgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWat
-attaccYaagWtgaataatgatttgtatBYSaDctatRattgaatDgWtMacggtatttt
-RgtaagtgWtRtagtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHa
-ggtattacBHMcacKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYt
-SSBgaKatcMVHcDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaa
-VWtgHtaMgaattaHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDga
-StattBtBNHRHacaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYt
-catcaaKtctaNtgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMa
-gtgatgcgtattKHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaM
-NaacattctcaacgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataa
-atgtaaVtaSatcccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDtta
-ccaataSaDgcggtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaac
-ctatgaWagacaYttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtct
-caNcaagttttctacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatK
-tattRtWttaVagtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatat
-aatcVtDBHgtNaRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatN
-VtagctgtatVtaaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatc
-tattaKgtattcMttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagat
-gtagttataaagtctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaM
-agaataRWacgSactctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKt
-HctatMcttctgtHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtct
-atcYctDtagHKBNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtt
-tcYaacBcagaMttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttat
-ttgYatttDgtcaatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggcta
-ggcaacYBtatWctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcga
-tatttcaDHMMttVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMgg
-tKSctagKtaBYMggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgat
-agagaMtacacNacacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatat
-acVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYW
-ccaacttagaagaaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNatt
-attcaatctBcttatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcat
-WgaVataatatgYYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtc
-cHcaatgtWtctttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaat
-tMatcaaBtBcagatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtag
-ctaBVNtStWBgctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcg
-HgaRattaatDtNcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYg
-taattaactagctatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaa
-aataVWHMcaYcagcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttag
-tatYaaatcaccgaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKV
-atatattaaatccggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagt
-ctataHcRRScSagcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaa
-aaatatagaNaSgattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDa
-MctgtYcDtgaattRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBB
-YagSagcaaatcKgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaat
-VacggStctaKaRaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRc
-aVataattKattaaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataB
-aVgttNBcgtagSttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcD
-aacSDStcaRtcDcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaa
-RtcaRactHgaaatccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHt
-tBctaattctNggBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtH
-ScaBctRccataataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgt
-atcatBtDtaWatcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSga
-ttRataYaYatagaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHSt
-attaKcttatNNSataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHa
-ttattcaaaaBatataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacg
-aBcaaBttgagtKtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatga
-taMKttVHVBacataKaatcggWtaccagMtttcKgScgcaactattVctHScccaaccc
-HDtgttacgttHVaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWat
-aWggacVgtggWtatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHat
-ttVacttagcgtHagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYc
-caYKVttDttBctYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaag
-cacaNttctataYMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgtt
-acBtctBttaRtSMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNta
-cgatagtcgaVtaacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatca
-atatNttagttMttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgttt
-aagBcccgBtgcgtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtt
-tMYMtaaaaaattcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtg
-cataYtaaaaagStcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagc
-gVHcgtcatgaHgtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatB
-tgttagNDggtcRttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNt
-atBgaaaggcgNttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatB
-cSactaKYaDVaVtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtM
-NaatttattaaVgaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcct
-agHatttttVaattttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWttta
-taWtaatVttKaKMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMt
-tScaggRttgtcttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRg
-tctaWDtagWtaaWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYa
-catttBaattKaaaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSac
-DKcacaaHgaggaaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttY
-taattBMtaggtacatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcM
-gtaNacSatcWBWtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaatt
-gMatcttaVaacVYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKcc
-actgattatccatBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKg
-aYttHtatggaaaatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataN
-tattcVtcataacMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcg
-agtMVaHDHtatgcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgD
-attKtHKSVStgMtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattK
-aaYWtYaHctataKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttcc
-gtttHcgtKtcttaatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaV
-taggttYgaNagYcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBatt
-atatKDacaacBgVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggV
-aacYDgtttDtggKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaM
-gSattgtacctatataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaaca
-gaYaagtaMatDaatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtg
-gtKtRcatagHattcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVt
-NDgatKtHaaattaattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcc
-cttttBgHccatcgaWctataSttBgataacagtacggcccDcScaactgattttaSWYt
-aaaMaVatttagctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYa
-tBtaWaattgaaYattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcgg
-tcaDcVttgataMNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgt
-aYaggctataBtcRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttac
-WNtgcaWtaaVaNctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttc
-caccaNgtgcatRgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacac
-tHWtNtgctcgtNaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggc
-taccDMctacVaattBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVN
-tacgVttKaaHtgagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatR
-tttagttMctacKgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBa
-HgNtggaRaWataacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttaccc
-aaaKRaaatattcKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtgga
-aHSVacggttaHaWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtct
-gHagatcaSacaatKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNg
-aattWccgattcttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaacc
-aYacMDtaYaaaatttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNa
-gcatNNatgttcRaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtg
-tgWaagDKattttttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYagga
-gcYatacYaKaagaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgta
-VaacDBaattacaNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgca
-ttaNgatgaaDaBBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatM
-attgtagRDacaaacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatga
-NBtcKgBttRtattVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcat
-aaWaKHaataaagYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatc
-gaaaKaaVcDttcVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacB
-ataRYRDgttcttttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaV
-aHtDcaYKacgKtcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtag
-atgcatYatVaaYWaSactgatccatatNMaNagNtaatcgttaSttattWattaggaga
-atcNaaccaaaWatRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaa
-cgaSWcatcaVgatataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttg
-aggSgagcKttaaatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgtt
-ctcctaactBaaSRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgK
-accgtcYtcctBccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaa
-DccWHcctttaatcWactaatactcttacttgttcttatttatcaaagatWacYctacKt
-aSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattg
-aacttaaKaYcSBSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBD
-DcMgcatagaVNttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtac
-aatgtgctttatatttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaM
-MaaWggBataaKtttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataata
-acagaacDRWDgWaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtS
-DtHacKtNgtgacaaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctata
-VctNttKgRtatataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKga
-aggBDtttacttHttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttcc
-KaRgaWccRataVtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccY
-gtWatDcMYtaaRtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttaga
-gBcttKacaaMtagaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccag
-cMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatat
-gWaaatcgMaaaatcctgttactDtDagaccYWacttctRatgataaKtaaatcaMtttt
-caaRtScaWgatMactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMc
-atgaatYgattatacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRa
-KgVagatatWtcMKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKa
-gtgtBBNctacaaacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDa
-tgBtaYaaaggttaMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNt
-tatSVttMScNaaattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaag
-actBYgMgNaBttaaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKg
-ggYtgagattaMaaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWt
-ataattDtaactttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatg
-caBccKctaHcBtctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagat
-ttVaMagaagaWWgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataag
-tgctctttacYataRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataa
-KKtgtaaaRMVtctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccB
-gBtWcataataKctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDga
-VgctagtMNVtaattaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNt
-KBaScagttctgcMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattt
-taacSttaaactaaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNg
-tgaaaNcagataatcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtaccttta
-cKtMWtaaaatWtcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaa
-atgatRBtRctVctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgt
-tttaaacgttgBggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagta
-aatatcgMcttatRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgttt
-aatagagWgDKaYatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattat
-aBVccaNMHttacgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcatta
-tctattatcgtcKtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgt
-ttgMcStgttcaaSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDc
-aaaataKgtatgtgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtactt
-ctccttatatHatgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgct
-tgaVctaataMRttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtD
-ttVcataacSVtattagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVa
-taHatttttgaBtcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYac
-acggtaaMtatgttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWcta
-gatataaNtaccgaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMcc
-aDaaSatBattagcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYct
-HctgtcttaccBattVaYtttHatgaVgttcRgaHtttagttttataatRWggattYata
-tMaaaactWaDRaggataaWgMataggtactatatttVctataattaaatatgtgttDtc
-ctaKataaaaacggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggY
-agtNactttaaNaStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSY
-gtctRaatVagcaWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtaca
-NcSRttagaatcatVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttcta
-DtcttaWttaatcatatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaat
-ttcttDaNtRagttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYt
-NctgatcRttgaYaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataH
-WVKaattVtKcgatcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttata
-ctaatcMaaaWcgcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBV
-ccNcRgagatctgtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtg
-tcaHNYaagStKcaDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaa
-cttattSgttNaKagttctcataagtaatgactgaVStaatcctcDagtcataagWtata
-atattacagScHaatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctat
-tRaatattNgVaatacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHa
-NWSgVtgNttVgtattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctS
-tHWttcYagtgNtBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRR
-atattaHaaggaagaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctM
-McacagcgtYatSctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDt
-catHtgaVcYttctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtH
-acttttgDaBWDtcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgc
-cBSttataaNctttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaa
-ttattatYKtNcggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVtt
-gaacBagtattctatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgt
-actaagtRtattBMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNgga
-acgtMRtaaHctatacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtY
-aacaacRgtSgtacNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggt
-gaacttNBBYaaccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKa
-cagcacagcgKSattaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMa
-gcatgcDcatcBagaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNSttt
-aKaNggtBtaKtgHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgW
-SNacttSBaggMtNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaa
-agYtMaagaKctgtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaa
-ctaRcaBRtMttRgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatat
-VHKKagaaRSattaacgttMattgtatagBagtatctttgaagaBctgattattHgRtta
-cDgMgtWtaggcaatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgt
-aBacctgaaWgtKatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNK
-gNaBHaaKcKaaatStBcattgagggcRSttttctaaatcacaRBattccacatagacat
-SaDtaaaSNtttgtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVt
-aRtacWggctcaaaacVctWtacatagttaattBBttMacatDtatttaaRggattatBV
-cacattattaagWctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgatta
-WtMDWaRccaaWaagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatt
-taSttaWRgtctaaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBH
-tccagaMctaagaWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKaca
-ggtgMaaMtatVaVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcg
-ttagHKSgcWtWcaatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRg
-gtYcgaWcgcccataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaa
-gactRttgtgattBagBtaataattBStcaatttaWcattaatVtacatgtatttBataV
-YWStagcaYKDaagYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaR
-tagatatcYWtSataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRat
-tataaatatctattHSctttggNctaagtSacgagatatatatRataagtttcatgcSaa
-KttctHaRgaaDatgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcaga
-cKtaBtggcaacHtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaa
-taVacgaaatttaBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctac
-aaagcWgDtVtctaBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVa
-gtttaaStgttgRHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccg
-KaRgtgaatcgtaWcatYtWaBtaBatcgRattcaagtHctctaatcttcctattaaYga
-NaaaaRaDtactDtMNagatMtttRacKaccWaYtatcagaaKcttVtVaaaatgttgtN
-YgtHtaDactaggaRttaccVaagMacgcKtatataHaMtcaattcctMaRtttttcatg
-tctcaacatggtgacatcaBatHaaMagaatttattaaaactYgMttaKHBccgactttt
-aVaaVtcScHaNccttacccatataMgggDtactagKgtcacRtacMacYgBaatttcag
-YcacaaataaaaggagYaaMHtataaaHtKgaaHtctcaVatcgStcatHtcaYctttWc
-ttattBactataatWctcctRKaaHtaaHYcttcaYataaaHtNcaSctgattaagaKaa
-tWagRaVaNSHDaactaYVRaatgttatVYttatDcctRtgcgaacStaWttgaYcatYt
-ggtatWNataMtDNRtgtttgggtHcWtatHaaataatVtaaWaVgcaatagDatgScgN
-cagggagtcaDtgagataKtgtctataattgtgaNatcaNatDgtagctaaaNtgtagtc
-BatgWcagagtgtWtaagWtaKgattHagWRaNatacaagtactYtaWgatataRctcNK
-cttttgaRtgKWtgtgRagcNtKtYtgatatgatBDKVtaaaaatttWtcaatacgRtaa
-ctttaaaaMtaMattaVNHRKttattattaaVaatagatYaggattVaaaRactcaagcc
-ccRtagtScgDWgVSagtggtaacataVatttcagtttRtattcttcYaccaaaagttNt
-tKtggBttBcSaWaattataatcataBtgtMtMtaaagataYtacgMtWaaacBtttatc
-KacaaaatattMagtKccaaWccatttgtgacctttMSataMgBtcttaVgtNttttSaa
-ctatgaggaSWataRtHtcgaMagSMccSaMctcgNtatgtataaVtBatHcHtattaac
-gactgNKtttaMtVaaaagaatVgttMWcttacacgtacScttcttcWtaatccatactc
-taacaHHaaaatDctNtgatMcRaaWRtMgttgttatRagtaNtatgRtaMttggaaKWt
-taRtHKMaDDaacatgcgttaaaccaaaDttatagVRBatacMaatacMaaatWcNcaaH
-ttBgttgtacggRKaaaMtcHgttaattattttaHgKtgttaatDaHatctggtaatMtY
-aRgMccKRaRKaDaagaggatBtSacatactccaKgVaaRMaBttgcataaacYtKgaVD
-tttgcatSaatattatNattataWatWgBttaggtBttaaYataaSHtRtaccaacMtta
-ccattccKggKNtMatacctctgtaYctaaccttgagtataaRatagaatRBtttttMtg
-WNtKtgcttatgactcSaatattgtBRBtSWVWYagtaWBcNatttcNNgSKacctgaaM
-KgatWcYHgRataYggtctaMtggcagaRgaaYaYgKgaaHVtaattMgaaWaWaDataa
-gaaaaBDatacatatgatcNtagagMtactcatgatgtHataaggtaHaWatMgtagctt
-aWtcStataSttagttttgcaagtgctgacDtgctcDtgaSgVMtagttKtaacgtacat
-taaatctHgatYatttcgggcaDtVttcaaacccgDgtatBggcttcBcWtacttgaatB
-aRNcgYtgtaaaaaRDctKctagtaKSatRtRatMaMtaacVYaKtactgRDcaataaat
-SacagctDaatggttttaaacNttBaattgattaaMgVBKtBaacctYNcaKcaVtDYtc
-BaaataNSaBgatacccgtVtaatactSgtttgMSYtttgKtgtKacgtKatgataaVcc
-aMgtaVaWatttatattgBNtgtVgVNtYStMtgtatBcgagaBaVatgatgBcStttgt
-agDgYMgaattacacHtaaaaaBttKaaggHttctaggKagRNtMBaatWcagMSBaaVt
-gaatgtgatNaatSagcaatttHctatWMtgVcNtSaNRHatVaVacVtHattcaataat
-gSKttttttgtataRKYaatccRYaatggtaVtttaaaaaWBKtatatttatgtagtcNa
-tSaatatcMDRtgtBttYtatKaattaaaaYtcWccVattcDaaatgattgtHccactgN
-gctttBtgagatWDgVgtactgtRtaaggtBgacctaaatctRtDttaBRaYacaaaYYt
-caaagaWaSDttctttggacttcBcgaDacHataNtNgWtVMVtRactggaaagSgtggg
-tgaggcctccataaatNttaYYgtcBatattWMaacMRctcgttaaaVatatagagataK
-atRMtHaVagaaBBtStttaatcaaatgagtatcaagtRMtaccgtBagaWKtagaaaYt
-tcSScttaVttttcatatcaSgtcWNgtttagccaaaVgaatgtgttatgaaYaatgaat
-aaaagagatcttcYacaaatataDgRttcMtcataYaBtctStgaatgagDaDgtRNaMt
-YMatatagWNggaNtcattatgacYgtBKYttttagccttataaNRaatggaatccaBac
-gttacttatMNggaaaMtaaRtctagtttttKKKgcBttgccgtHKatcgatVtttacat
-aMtagNaMttctKHNctaaNatttWaRNgRatctagatSctaactctDttaagacgcata
-gcRNgagatttgtacattSattaacttttcgttgattWatKtgaatttaMtSBattKKct
-taaSggcactaataaatcactcaMgacggtRcaDScNctYtBRYVgttgtttaVtacHWa
-ttattcatttVaKtgKaacctaggStatttacaactcKNtaaacaagSttcgattatttc
-aRttVtaVaaacRgDtaatgtccMaacNtcggttgcctaattaaaNaWcgKataaYcctS
-gMcataaatttgaaatttHtagSBgKYggcgYaagagataaWBcMgatRBNRaYctgHat
-ctatHttgaHtgcHKBKVaWaacacWNRactWBVttaatttVccaagBSWacaaaatcDg
-ttattBtHaMtMtHacKgWtcctcctttHaatagtYttaagccaHtYatatttacgtcaS
-gtgtYttgBcatcatttaNRgaKgBtgattttaaatgaattVaKtVYgNaatgDaacaaV
-tHaaatggtttgaYYatgctgcacatttttctacVtacaNatataHtgtcVtaacVgtYc
-cgaactaKaaaatcagtttaKNRtaaataMatgtacatatcKScctDatDcKttSatttt
-agatgttHtcBtKgNVRagctaRVtttaNYWttcWYRatgatMgaMKRctNVMgttVagW
-caVStcDgtttctcRatBVggaccgaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccN
-gcacaggVYtMcaaaatgBtaKcgaRacccgStattcHttgaYttattattctaVMttga
-acDaWtNccDtcHBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHt
-gcgaaStttctacttcgMagagtaaaacaDctgcagHctHtWaacgaatgtggtDacgtc
-acataSaatKtcWBtataccaaScttNgDgcctacgBaNWtagataBaNtRcSggtaMat
-tgaatgtRHtgHaaNWtgttaccatacctBataaMWatttNttVaaRagMataVtgtacc
-attYVcKYcgagtaaYtttgDaKDgVacMtttaVttcYcgtMattctatatataaggaag
-agttaaatHgtWctatttgaaatHttgScgtBataatgatRWgtttVgatMBcgctttat
-gtctgWKtaacaaHttaMtctttatcDtccaHaNYtSWcWNtHNacaaatactNggtgSt
-acKatgtgKVctaBcaHcttaccaaWatHaaYtattatYtttDgtBaKcataaaatcaNg
-ttNYcatVSgtgatatYDMMtggaatKMaagcttVtaNNYctKcctagMWtttatttBat
-tNagccggaRgagtattaKatgatctacatcaKVaaagttYgcStagtctacttttcatK
-tWtKtctRaRDtcggtataMcMDcaattNcacattattgaBaHattHgcYattagaatta
-taaBtattBKHtgtaacHtHaacaaRYaBttaRVSaagttHVtatMtcacaWctgVtgaa
-tcVtcctcNataacacgWtattDWccatDDYtcgtaHaaKaacaYaHaataBtaaBKagt
-ttcStWataccgNcaDtWNaaRgctcNaacttatttgttaaacaaStttagtgVaKgggt
-atNaatVagtataVVaHtaRaccacaRatacNStaacaYDgaWaRtaKttgtaatacggt
-ttgccaaggMWtcaaccttcgctaMSaattaatgaaVDagttBcatccattttccaaBgg
-RttgKgccaaaYNcDcaSatMcaattYDcatcWatStttggaaWtttHtatVaggttDgV
-WatttaBWMagtcagcgaSaaSgtattctacHtaaSaVacaataNKtatagRMagtKYBK
-ggtttKatDacaWaYDaactagcaDttctctttHtagtMtWtttatYatWNaBgHtaBgS
-ttRgattatgKcccaaBtWcccataaNattaYtRYWgRccNatatHttWgttatacttta
-cBYHaaaKaHYaNttaatagKatacaaatWSMctttcKacatMattgcaRctBataaVaH
-tataSctDVtRaacttcggScYctataHRHtgttctgtgattYatatYtcYHaataaata
-YtMMgttaaatgatcttaaattaKRtttaaRtaacttaBtgtcatgtctNcaaKactMtK
-atagRaDKaatgSaHcRtMDctagatcaYtRatMSVRMYKYaggataaatYtDBaDacDt
-aVtacggaKttattNaggScgWcaYtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNa
-tNttSgaaactctBaggtHHtgaSagYKNcataaMcatagaSttctNBYcttattcatag
-agagtHWWDtctgMtRHtactgggagcKcacctggaYattatttgaaWgtcaVaataaga
-aNatRgtttacNtWYMBcNScgggataataaagtWYKDYcVWVggtttMcttYaatagaa
-KaaataDcaYMVcaVtgtStctctWaagtaRtaagtaaatWacSKaaatYaScctggtgM
-KtYMtctacDatctcaMatVtNaataaNtaattgaagaNaataataagcttaagtgtgcg
-tVgttataYaagVgNaaRctSctgWKVaYKgctNWMaaRaHatcgctHaaYMtccggatt
-gtgBacatHaacttggtggDVgtcaaaggSatWRaKtKacNVggaatYttatttattcaa
-SttttttttcaatgttatttgttttaBgcatacWKDgtYNtcYtgtcttttttgtcaaat
-gatacttWagatDatttcacctaaaaggtgagttatWgtgHctaatMtRKagccagcgcV
-gagYagtactgtactttagVctaBBaYNggtYtaattttcRtaaagatctMtaVYatctY
-gNMaVtaWtcattgRtaNataagaaaacVSctHNtcNaMaRYcgagttaHcgacNgagag
-BgtKaactaaatatYRcggatgtKtttactgDctcVaYaaSaacBcacatagaaataaaa
-WDctVcNtttRtcataatNagatVMctBgttcHtVgagaNaaaHaaSccggatSctaHgt
-gaYRagattDcSDtMStNYtgtgaagcttgggaatttttDgcaatHatgaBttHttaaca
-tBcaaagtaggtKgagacaattaataHcaNaaHataMtccaKagagtttBYSagDDtaNa
-RtWtWagatSgcSKtcttttcaaRgtMattatRtYSHgaMccttttttBtHactaattca
-HtMatagaattVtBtDatcttVgagtatttaaaattacYSattatttaYtagcaVSHatt
-DctKcVattataagagRaccccWcaBtYYtctaaaaYccSgattaaaMDRtHatMaYtHt
-cgcaaggWgBaNVDatataaatWtcMYSVtacBYaaatactcgtacttttWgaacRNaat
-tctHagcYtaSttaaataatttttaaSDtKaaMcWgBaagBgaatDagaaatactcctNt
-gRaattaNWcattgYVMtRtHgBaatcaagRcagtStaaWRgtaaatHcaMacDctatNa
-agtactVHaaVagMgttgKtgtHatcMacatagMgaBtSaaaBtagttaaNaYgStRRct
-YWYVtttMNBgcctgMctcacttagtgtttDagacaYaattagaggKtttacaatMttct
-ttatKagaaNtBtttKSHWSaVtVtgttaRSaYccgtaBgggMtKtttctYWttcaVaag
-ctttttMBgDKccatagVactWDgtRtKMtgBKaDaVaggtttRaataBgttYtattatg
-ttatgtcMMaatcagaatagHaacaattRcBcDatttaYWttagattggttgaMcgtYRg
-agMtcactaRctcBMaaNgcaStgcgNtgagVttaBaaagaatacgcatYMaaatDtacg
-atatataMtYKatctScatattNgStYWgtttaYcttgtagaHaHaYtaRaaagttcMHa
-StatcatYtttKBtctataaaatcaStcatatStattatMtSatcataHcaWaccagHta
-aggaHatatgagaaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcctttMttttagta
-aaBHBaaattWKgtaaccDataactgatatgtaaRVtaHgaattctcRttcgcatHtaag
-ttYYctaaattttgWDacBtataatttctVaYHtMtagMaHWtagatttcaVgtKaaacc
-tgHagSgtacSWttMaBcHttaatcttMaStYatatatattagtttggMaYaatHgaaaH
-HgatggccctactatSgacaatcVMcatactBBMtaattaaatattBNDacYtgYattBt
-tHtNcaatgcggacccctDcYcDtttaKaSggtatcaBYaaBttctDSRgacHttagMcg
-gtWgagtcctRatatRcttgattggaaaKggaaaagaaSNtattcNtataatVttgagBa
-MaaBctWtHatgcDaatHccgMDcgcWaaDaacWgaagcaatattactcaaaatMgttgt
-aaMatatYtctRSctctWcatttVatgBNtaaYagNtaMatcSgSgaVttSaccaatacc
-KRNcataaggYcDMWaSKVcccaaaggVtHtgHagMaggtKVatVtVMDVatBgttWagc
-ctagagacaaaggtataatttgcttgtSaaccttctccttcaatgNaacaBtttaVcaac
-agWaHMttgttaagttNWaaYcgaaVtatacBatgagHtSattacBgttYgtNRRcttga
-tcttaHcaataattattttccttgaYgacVgNcttaRattatatctcagWWatNcDgaca
-cgttaatRattaYcKtggtSggWgatMcaaDBttgaacNttctcaaHtHaagcgVtDaaD
-tNMcagaaatWaNtatcttcattSgatatgatactattWatSaattWccgtctaatcttg
-KDacatRatggBttatggKgaagtttcBaKtgttaaaKtcgatagcNgtatVDagaDtaV
-tcaactttYgaBYcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtttacMaVaaagaa
-ggtVtKNYtWcYaVtRVccgaattatacttatattagcatcKBattttgVDggcKaHaYt
-tgcggcNaatRactWagWgttcagtgWMctaataBHtttgHaggcctgacMcYaRtRtcg
-gcaatBagttaagcDatatatNttgtMcVtaaaHMgattVgaYgtattatatSaDaaaaa
-taWacaaNttKttcatttttHaMagatYtgtttcattaatatVacgcHRttacaYtaagt
-tacaBtcgaagcgttWtatVWRaaSacggWaBgSgcttaScatNaHcaatWacaMatagt
-tcagYBagYgVactWtgtStNatacatYgSYDtaaacSaaatBtttKaKRSWRcRYMgcY
-gVataSNNtWgVtSaMgBcactaaatYaKattVggacaWaaatgHtatHccacStaatag
-aYaaaVaMaaacYYMctcagaNattatctattaaatatgMaRgggtatgaMcttaHgatt
-gtScgtgtatVatHNgcYttNatatBWaaactNVtHScgataaNcBataggtaagagatt
-tMatVtaagtaaatYgctgttttaagatagaWaaYcgctaacttaaagaattggtSYgtV
-aStttRtcKtHaVcWaYaWVSccRactDaattgWaBSKtaDgtataaRcttaaaatKcag
-tNgtaaataaatgattcatgtcKRctatHaYtMacaWNgagatcDcgDtatKaHgaBcaa
-aNWaRataYtYYacttgcactaaYDcKDttWcYataStKcgcaaaaaRaaNtttatttgc
-tYatgtcVctttcBKcgtcttatSttattYMttaatcatattcatSaYtgWaDacgaata
-actctggaDccattacgSagaaattgatttaDtHacgtcMgaMHaaNDKttgtaMgRNta
-cataWgttccStgaaatDaagYRtDagcatcHttcVNWWataatataaccKaatWtYgcc
-tacVaagttWtHactaRaagatatMMtYattMttccatactHgStagHcaattaagacag
-aMDtttagcHtgccctttattatSatWataBaaSMaccVVgtggatgtgttgYgtDHSaa
-MaKcagaagcWacaaaBagRactKacDaDgagagagcgKcaBggtgtaYttatgcDatga
-NgatagagtBtNtaWatagcacgcgcatDRSacHttcataBtaWaNtgtaatcDctBaSt
-tttaggcWtBacgacaVYtRttaacttatgKcggDStacgtagaYtaagtaatgacggVM
-KtWagcatatagtcataagMgatVagVttSaacHataatatacaatRYaHacaWaaactR
-tHRaatagcaVtcMataaacatattHaStattDcMWVtYaacYagaaHaaWaccNHcatg
-tcccgaNttataaNaacatctBtaDNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDc
-aaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcDgtWaactactgttagaKcccDctc
-NcgtagtgStacgtataNcgVaHHagYttStaaccWacaKctgctttaactagtVattta
-aatKttRcgactaHttSaKtcagBBaWaacccgRatKagNagKaWtHttttcWtatattt
-attacagacSBagDgtagtatHtgcattgcaMaRgtagatYacactYSBDgctgatcMat
-tStSgattcNttaBWaacatgcttSattttctatNttaHNtSctgtcWttKgttgttttt
-KaMHNMcaacaagNattRtcBaccatKgtVtaaDcttgattaaaatHgaataKYtgagMt
-gcWaWgtRttcDaatgRtDgcNWSgtagtatRttDcggatHWgaagtacgcVtcaatHtt
-tttttgaKggaSaStaataWBMtgcaaatacgWttctagccRtaaaattNWaMggataRR
-aaHaaMcagaaacacacgDaatctactaactDgatgtttaaDacacVaNgagKaBcatat
-aaattcgRtSNaatDttKgKDgcaaactBDtaatatagWaBgagtgtYaaVatatMtaac
-aggtataacgKMtaKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaS
-HgtatttataaYtcaKatgNacgtcWWatgDttRaacaaDWaatDgagaStaVScctgca
-caaBtatacttctgtctttcactacWcaaaWcactKattaKtatWagttacttgBtgaBM
-agaattgtYYttttVatttWtcBagaatcctcWtatYcVttattMgNgYStaBgtttctt
-WtagcaggtMatgtRaaDtDKttgataDggtttatgctaataVYcSttBtYcatctVtBt
-YaVagtaaDtgagacctgaaatcNKDactgKtacgBtDKgattaaatagattatagacta
-tggacgacgRgaaYKgYaRtgaaaagRgBaacatctctMttgacNaWtctVagtStMaac
-tacaatttcVgatacKctaKgcSactaDaatHgBgtHgYttaagtNYtRcaRgYtBaact
-aatatDctaacSKatSDMatWtagKtttagaaHKattaVactttSgtgtagWctaggagc
-tttgaScatcggSttaggtgHtgYatgtctNtaggaaatDttcctgagagaHagttKctt
-ttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcgtatttHtatctggaHWSataWaVt
-tgKgtKBaaaggtaMNaatttRDtcDattaStctaaatKgtaagtcVgccaHKgtgtcga
-SVtaaaaHtatgaaVcatacacVtKattaWaKDgttctattgNcaagaacaKYaHttWcD
-accattttagacttttMttaRaMtaHtacNgccgaaaaacKctNgaaagagggaVttttg
-tBVcatttatttVaHcgattWttMaWcattagtaYcMagaatKaYtcatttagacttStD
-tcagacattctcYaaKMttcagtSNtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaat
-aaVataacaDtaaggtcSgtDatttaKtgSNHcgctVaaaatatagacRaBgaNtaattV
-WaKtgcaattHttctaNRWtaHtttaaSgWBctVacaNVcKtaaagHDaaaNagtYcYKa
-VKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgMaMccagcttRgtVggaaWgagtag
-gYctRtaaWtgtacaaMNtagtacggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYta
-DHgaVtWaaNagDtagggtHagHgctRagaNacacaStaNttMaatgaataaSgagBgag
-tgWccDtVgagcDWVctBttccaWcacgHttgtcYtttacttaatVatgtKtaaatttaN
-aYttaStMtVaStggattgtVgaMRNHtacaaNttRScRtVcgttcScatMtBtttcDtc
-atVctDaScttagacaaDaaBtaHtacRgRgaRNtKataNgcaaScactcWtKggRagtg
-taaYtaaattWgNagatatYtHattWtYWatagatatttKatgtcgDagaVcgKVagaca
-gagatVgHWtaagttgcatgaKaatggattaHcaatatgKtMaWtWaYSVtNBDttaaHa
-McaRctWScNcggtggYSttcagaattattggaaaattVccMtgggWatatHMaYtaMaa
-caHaagVtgDtggcHtRaagtHaagVMWacaaagggataBRcaaBcttKtHtMgcKaVta
-acaRatKRaMaRtMtcagcaataaaaVccNcttMtctattaagacacgagatNtatttat
-aaaSagaaatatSccaRHKatYMacgttaWKtgttgHtgagatBBaRRWSacatacWtNt
-cWgttcaaaccactVcaSaYtaactaHgtcVWgactaNaatRgNattatagacHatgcYW
-cttatctaagcttaatatgaaRcaDVaSaHatgaatttBDacatBtttHactacaNaNta
-taVcaVtattKgMaSaSggttggDNcgtgatactaccYHttaaaMaVcBSacctgatata
-taBgcaattaatBaHtttgtaagggataaacatgcgcaaataatattaaBVcaWgttagt
-VaaWctRgBtgYtttccgYattttYMaVMtaHatRDaatgVacaatatVBccgttaagac
-tcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSaccVgRaaBtgataaatttcaVtta
-taSMatacKtaWttgcaRcgtgNattatttaatagaatNctcatHtSWttaVtRattcaR
-YtaaattDcaKagcWggaWcStaatNVgHaMaBKttaaatYRMHaRtcgtagMRgtattc
-ctHtcacaaaKtaNttcaRcatRtccgatNDagaBttDHtcttggccttaNtattaaSta
-WgKtVWNaMccaVgVgtatcKacDaYcccactcattcacYtattggatVgaWttctgSDa
-gaWDattctacataaaDggtactatagcNcSgagtgtMtaacNtVtcStttSgNDaDYga
-aWVgtactRtaNcYgataHagaDtagttggaHtgtNtcgcHYgaDttgRtgStatcattt
-tKtWVaYattgNtaaYgYccHgWactgtaaaVBtaBattaMBtHtttYttVgtaYMWatW
-gWtNaccVtgMWaSDaatcYWccaaaHtacgKagtNcMKactcgtaaaVtaMatttcRct
-tgHtattattcRaaaWaWactgDttttccttttaKVNaVggataagaagWttcgBtBtVa
-YcataRtaacBgNaaYctggtatctacaaaagatttagttaaaaNaaattgctcaacttt
-BKagatctgctgaMgtBttgtKaSatVgcacgaHNatVDgttacVBacKBaaKaBctccD
-tagctataWKttagtcttYgtaSccaatcBttggaBtMaaaagaYtMgtgtNatgacacc
-tWcKattctgaNtaSgaaataatatVSaattaaWattagDtgagBaHaaNHtBgttctta
-tHaggaBtatcHtSttgccaatNgtaHtttBattaacatcactgaWaaaaaatggatagM
-HtSgaaBSatacBSaagMaDcaattttcgtctaacgHtaaaBtatcttaattagtttatc
-ttcgtWVttatatcgccgaagBgRaDcBaatHVDtataacaccVgttHaaSgaagaaatc
-MSaHBattgcaSgaSVaRttcaMtgtgcaatKaatWggatBVgtataNWgNctttacctt
-tgaaRatSaKttHgaaaYSaBttVacWttcctgctDgBSgYcagcgggWRataaaatgca
-ctagaaHStacaatHtggtgtBgcNDttggattatgaagaKaatStgcttHtgKNMNRag
-taNtaDattgaDDcKtaaatcVVBtcSgNcRtcHataRcggctVBtccaWcaDgaaRaRc
-tgaatMtaRtgBcaWNaNatatWScYYaWttatScYtSgcataDtWcacBtactaWgcYt
-cgtataagctataNSgBctagattaNgaKgatVKgtagttttcaaagtgcgcYattcaga
-tggaKcMBtacgtttaacctaaattaaatattcatRaggtcgcccattMttaaaaaaact
-ggSgtcccgtctaNtWattcaattVHDagRtggVSSaaHtattatWctatKatHtHattY
-BtaVaMRatgYagcHtaSataaStKaaacattaagggttggVYaaDgttWSttcattaRB
-cMttttaacatRDaataaMttRgataaagVDKatcatacaacgMtaatYctKcgggcBKN
-gtggttcttaagttYgcataVMaaVBgtVMSNagttatSttgtDtgtMgMDtNKtBgcta
-ttacagataMWtcSggtcHgggcgagtcRtcRattaaaatgaaYYattgtaaccttgata
-cgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaVtKScaYagtttctagNBtcMcDgK
-aDHtVtMaMacMgtagtaaWtaYtgHtttttgtctagYHtRaagacDRaatgctVMtttW
-aYaaNtttatatttStcgactaDatKaatatattHggttgtRtattaattaaaaRtaNac
-KattctVaatgattcttacWatgDgagggtggScatNtcMggaagggHtaaccttcWcat
-WaStagHtttgatHaRVaaSVNNtcaRacaNaKttgctgggcVattatccatVatataDt
-DcNgMBMgHSagggaaagKctgggtcacgaatcaataaVtDttaRRgtctStattNBaaa
-BHatcgttaaWMagatagacatatVgDBttYMacaatttKtttaataaaagcacgVgaaa
-ctDBtaaccgtagaNtgagaaaRttcKKagtYKttttaStataaHgtcNDcgttYccaaa
-aMcaWtgggttatcaaRaaggaataaVWcacatattaRYaaVagagVtcHggaBtaataN
-attagKtcVRtgactatcgHDaBgRBStVtSgNBccWDgaatgaggaaNctttNttttac
-aaggagaaDDaVtcgaataaataagttaattStBDccaaaBgVaDtctScgtgtttttgc
-tgtcacgtttWgacStMtttVaVgaBtacDWtttagttDctaSDVtttNaDDcHatatac
-YtKataaatagttgaacaagaatacaDDcacatttgtaaaggHattaaatgttacgtcag
-tNStttcVatttaBtHtVggttattaaHcgaWagaYtVaataaatcaBgaccctHcatKa
-DatRttHRMcgtcgggSMtaatNagtYtgaYtggMYttgtaaactacgKgStttaaaYat
-atDtaaSaVVcHgtagatgaggtcaHggMtaMWaWaHctgaatctaaBaWaDtcgggtcc
-ctaagtaVYDaNactataaNcctKcBcataaatttcaWSttttgacHtctRggagRaaga
-cagWVNtctcatHtDHaRagctStatattggcattcattttMaNaSaRaNDHaagNtMgt
-VWtgtMccaactKNaaaVaStatcgtStgtgtaBgBgtaatcNtccgaagtttaWgactN
-gtaaccaatgNatWttgWagtaaKgtctRgtctaataagttVDHgStgttcVttgtSWat
-cYaggMatgMRcBaStgtaaaaaMttaYagccggtgaRRatgatccaaaggtttctaaKg
-acaDagagatgctcMgaaaMcgRaacaaatataaaagcagtgtatDHgRaVtWBVtggac
-atStctKccttVttatgtKattttYcatctgttatgtcDKHYcctSHMttgSDRNgtaMN
-HaggatBcSBtHatDMBcttMacNaVMKtctgtttcgaHSgtMgcacagaStaBttcWca
-ttctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcgaDYccacKtatg
-atgtcaRttattYttctaMBggcaYctaNtBactgattStaDaHccYaDtgcaRDgSYtY
-tatBSaYaaataaagtctcgcgttcagaaKtttctVattagtWcacgaaVaaVtctcaVg
-tagttNaaacaatgtccttaactaaaStaKWagttaNttatacaaaKattBctgaagaag
-tYDNtagatataDtHcKcctaBaggcaatctHttctaaDNtgtgaaaagRaattataaBM
-aggtDgtMaWHacBStSMtcgaacYttRMatNacScgaaRtttctattcMaaBggtaKtt
-aRcgtBattcgatatYtVaccSacacgtaaagtctNatYttgcSSattttcKccttataa
-tcRtHNctttMcatBtacatgtYtctagcNttYacaatgtaBgcgttVtattaaWtaDRt
-KNaNDttDWaaaataatDgcgcKtaatatcgctMctatcatcgtaaaaYNRttSaNtWgg
-atRgtgtcttataVgaaaatcWDcttDRaatMKctcatatRttBtccaattBSacctgMt
-aDDRagtcagacBNtttattttagtDacaagcaHcacgRttVtatcatatacStaatMaW
-agttRccKtRctcgaagttgaatttNtttatHaHttagctatSBaBtcaagtDaaaRtga
-ttcatStagttcaRattacaVgtatWRttWggttttctaactttSaaaVHRatttYHMKV
-VcgttMtatBtaSaaMctgMtcaagaMtactcDatSaaaacNgatttNcaagttRgacga
-taVtaacYNataStRtgaattactgtaKtNagaaccDaatgNDaaHcataDSYattatgt
-ctgYWaaRaHtttWggcKatgcgtagDSVtMactataKMSttaHaaaacaHatVaDKtSa
-aaRtcaNWHtatttctWataagctttcccaacctNtaaacattcgagaBKVattaWtcVa
-KtWcggtaatcaatgttcaaatccDttctcaaSaWNDataaKatBcaYttRtcataMVtK
-ttggcaaNgtgttatMaccgttgMNagtgVtNBWggaacacaKaaKctagtctacttSaK
-YMacaWtWDttatagHBacttRttcctgttagtScVNaRtaacgScaStttatctttttS
-gtBgNtttStRatNDWtctgatcKtgHcattatctaaaaattNaaaWgWaDWttWRtHRN
-cHacBVgWttgtNggtWtWcttgSatRtaaYtYtNaDttYagactStacYaYtNHBatgg
-atacVtBatgccaHcgtagaaMatgataHagtKgHaWcgtaccKaNatagWtDttcgtag
-ggcSgtRatatNgaRtYataaataRtBtcttaSatcagatgaaSgtVtHtgtaaDtVact
-gattcgcatctctBaWWtaagBttVgacHattWWgcKataHtBtagScWtcaNtHStBKM
-HBRtRagcataaYtNtttatacttaMgacccattgagtDYggKccNaaRgataWaaaNWD
-MttMacttaatgStDYgtattaBatBttKcSaactagtaccgttggaKacRtDaataSBa
-atacaKtgagDtNcttattaagYcagacttNNttatcBtHtgRatgccacctaSaatcca
-RSgtWggtgaaMcgcaMaagSagaaDatHcttgaaDgNRttaDKacgcataagYaagtMR
-ttNaMMMgcggttcgtRaSgacaStaaVgStcaRBKcaMtctKtctatNaactaHtaact
-aaatNWaKtWaStRSKcatggtgBtgRBtagaatagataSBagMtDVataaDtaattgaY
-gaBaagWagaacaggaagtctgacgMgtgagaRVacMcBaaDatKatcNtKaRtcatDNB
-aaHatatacattaWRBtcaccattctctaaWttWacgtccgcgtMctcaaaccHYtNDat
-ttSaDMccaStRttWgttattaSVKtgttttgtcWatgtgStttgttttatcaagacMtt
-gtRDgcRtctctgtgggggcSaagcatVattMacattSgttaacctaaaaccgcagtgag
-NgtctataatBtHtacaaSccccMgagRVctYagcgaatttacMagVttaRDcctRgSSt
-tttcHtVaacatagBgaMRagatRcDBaMtaNtcatggHgaDYgaVgWaaaaMKattBta
-DYBaHRccagttatacVaDcacactcgtaSctaaatatRDaccagctttttaatgtagaM
-aRaaKaaataaaatacaRagaaYaNtatKcDttgHgcVtaYgDacagMBagtgttatgMc
-SgWDWYWtSaKaagcatKatatctcaRHacagttaKtgBKtDRggtcaYcattcgcYatt
-ttgtccaagtVgcattttttaVaagtaaaagtWccttgacYcaagtaatataYBaatata
-BtaaatacacttttRHagtttaDSHgNtNVcatKgaKtgagttgaaaHcgBattatHgRK
-tcaBaagttgtttgtVatYattaattBatYgaatgMgtttatagtKcVctagttaaYWtt
-WaRKWggYttgaRgagaaMKtaggtattaMVttataVcagHYacaaMaattRRtataWaa
-RacHcattaVaBtHgtatBaRtttaccaaggNgtaDMtatYtaYVtNtcBRKMgaatRaa
-agaatactRattttNcaaaDDaagtagtacaNtSHttaaataattggtaaKtttaaBaNg
-taagtcaYttacVaataataatDtgHSSgtSDNaattcRMBgHttctaagaYVcHcactK
-gaaNHcgWaWttaaBactcgYtDaacgactMtaYKacBgttcttgttataBacatScBca
-ttKaaattacttSSDaRgKtHHagRNRMtttBDtcaagcBcgcYattactcgtttacSaa
-NVagtacacgtggtSaWatBtgatttWttScaaDtttggtKtNKaMtMgcttaHKaRacc
-gatccctgtgggagRMttaaMaWccggtttBtgttaaVtagMWctNtctHgtBgcttatS
-MYccttgHaatatctgNgVttagcttagggaBBSStaYgYatYgtaaaaattHatctatg
-tWRNgtVcSgtgcgtcYBagtRHgacttaaagSHatatBaaDgcaKtcccDgcacMttat
-RaacaataaccWtNBaYatttYacYtagagattRtatagKcatattDgKtNNgtttWNag
-ggtacStataRtVDYaacgtaBtVKtagaagRttttttatataSaagaaKtaatatKtat
-tagBtHataatatcWNaacagtgWaccatatStcYcaaNRctcKacKttgtStaaKRaWD
-DaatBtttgtcagggBgtggSctaaWtttYVWttNtctaacatagVYatcagatctVaHM
-gWtcaagtataHtgacaagttSacgtNRataaatgttgNtaattagaattgctMaRttBt
-acBatNgacatttcaMcgtaaacctctagHctaaKNttBatatttaatattBaKtRagYt
-atattSgtgtccBaNSattgaaattgYggcaaataatatHcaaaatcMBaagYattttta
-YttYaStatttDtacRtgRattttttgDcRaggagcaccaattcRcttttataHcggatc
-atNSatgtagtHHcactgtWgtaggtNgactactHagagHattcaggggSaatgcaaaac
-SSKDtaggcDtatVagMtggactaBSatagMttaggatSYttaacBtagaNSVtaSaNcS
-ScaaatattVctcYaWYtBcttcgaYBagWtRgagHKagagMaatttMatgtDtaYNagD
-taBagcKcKcaMttKaaaaatVaatHDaataacgRatBNVKtMaccYaaccMgttgtact
-agcttMatKgKBtMagtcttMWgaatRcacaaaaSgcgVtSatggcaggcgKaYaatgct
-cattaaaggDVacStgttaMaaaaacNVtBtgcttaacgtDNaaRcgWaKtatactagca
-ctgKVttaatcttRcgDHHattcStatgatcWataagtattttacgtcaRgaaMcDattY
-HattYgatatcacNNWtDatgaaaactgaatHaggaNcttcctKggNgatBaaatttgca
-aaDtgctcaatgtYagacMgtVVtgDBaacVaatNaDtatctgaaggKcagSggVtacga
-tgNWtKWaggMacctagaatattcttYaatDatcgttgatggtcaacgttatatgcttaW
-VttccRgVcaDcgagMtacattaMtaVWcgttRcatRacaRcMcaNtaYWNYgMtatMgc
-cctaKctagHtttaaBVMaaWcSaccgMttBRgNcRWMtHMaccaatgataaggagVttY
-gaatcttagtgtcMtgcctVtaRtgcaccaDaagHactNYcNcttaaggcMBagaWtatt
-gtgctaccacgcWataRaHtDtacgaaVttagttVacctatatStDgtggtaMgaSattc
-atgMcaRctatgWgatKatYYaaataNYcSaDtttgtcYttttttaBScatRtctgtaWt
-taatagMaacatDttaaaNgaacttacYttagaaccctgNgagMNHaaKacccNatgKcc
-ttaKcatDStaaStNaaVBatagttcacRtYcRcKaagMgctKtBagSaagNcKRttaaa
-aKaaRttttttatHHNHaHRtcaRcMataKDDtNcKtKatctaaataaatRatYttMcca
-aaNaaWgctgattcaaaKgaatScaNaaaKaBaaaaRNtataVcYDattagctattaaat
-WtgBWHgggtatcatattatcVttcgHacgcgatMattDcaRggDYtYttNaaaatBKtt
-KccStYVDatatYcctSacVcattttatMtWRctaYagRgctcttttaacVtagaNaVRa
-ccgRaattaaVcaattgcgKRctMaKtttHgctttVMaNaRaNMKacHSagtWagtgNat
-KttatctataaHatgSaSattcagtDctWaataaYtcagtaYtctatHcgattSRttaaa
-NDgagatatacttVttatcataSSaBNaDataRtRRaattcaRataaRtattttNaRYta
-KttaccaaaaaHVaBtttWtttgatRagctaMattgcttactctgatKtgatgRBttaat
-aagYttcStKaNgcNatacgWatYaatctggVtaaattYccKagaVagggatttatttWa
-cgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHgtacaatattgcM
-DNNataatagaaaataatNtNgccgaaMaagtgNttacgVHaacSgStBBtRagtBgtaa
-WgacttcKgactaaatgaagVaacaBtggtacattcaaagtgattagKagNatatVaKBa
-caMMctccatcgcgggRctttKaaBatcacaScaNaaaaatVgHaattaatatcWcacac
-actcatgctcgaRggVgcatatcaDcatYgaggttDgWNagagaaagagaYttHKaatgt
-aVtYttSNaDtcgaatctattSKgtgtaggaMgtaccWcaMRtHttaaatgWtgtccgtK
-tacggacaNgaacgaSgcYagcKBttNacaagatacgaagaVcBgStMacMtgKaactat
-aSgWtaaaatDRataaaNaSaagHttHWYgaccWMtatataaaaagatgtaKtVtgtcBN
-MtRaSaRacVataaNaaaDtaatgtaaagaDgtataVDaacagatttWtDtcBgatggBc
-gagctcKWgtHcBgcMaatDNatcaYtctBgaHtccagHctttMtattgtBccaHMctat
-ctNaaatacgcgtacatacatctaDactactcKtacctataDccMattRgRggHtaaaaN
-YcVtatccgttSaagYcgMatttaVattttHagVatVtttKattaagttaNaacaccHSt
-tagDactSNgtgtttaNtVtatttatgaaacSaKtactctacgagttgaagtcaSBaDgt
-agatNaaactRKttcatcWtaBaggKtKcYttaDttatMaWcStgattKattgtatatDt
-tatDtKatgtaNtgtcgtcttttttaBtDBcaaaaSgDatgHtctacaattcgMtVYtat
-gcattaaaattcaVgatRtcagBtcaMaNctHgtatVatcHttcaDNKgtWcgagHttta
-ccattNgaactYacaKgaaagtggtttgtgatcgaKaHgaatYNtBgcaaVatWacNgga
-taccaDtaaaWttBMaBccagaHDaataaBaagYVacYaScctYVgagWagaYagtgatg
-tttWatSaaaMYDcactYtaStWgaaattacHgKDaYtttttgttcaaaaatttgYatat
-VcMatcactggRaaMVtStBtaaaagggatYaagtBtatcatgcDttDaaaaMatagtct
-aataNtcttWHaaatcaVttaRaKtcgatttataWRtaatatcDWcctaNMatgtttDaY
-aaWtMaagtcagaKtaMKacgccaaVatgWtSagtagctatttcactaaNcaaaNaaatt
-aggattatMWgtgacgtcttcattacaYttctRRtttgMatggNtatacaataataNgat
-NcMttaggBcDgRHgatctttagtNtacaaccgBatgtHaatgttttgatatccgttatc
-ataStaKRaKgttgNaagagKttgNYMaggaattcagaactcaRataDttaagcttacct
-tttgVttaWWgacYggStacYcgatgcSccaacHcaYNtgRaHtcaYaacHctYacatag
-atBgtgacDaNgatMacgKgBaWagacaSgttaKcatactatatcaHaatataattctgg
-tcNttaYggDRtDaSHgNttYaatWagagtagaacKtWtHtBatNtScttttacaattag
-taMaatttHgtctagMctaccagagttcaKcStaccKggaggtctgcNatctctDgYcca
-aVgttgaatgacVcatagtgtattttccttcatctacttSgaaStcagHtMaataWNDag
-tatttttataggcatNKataNaMtgctgtttVaacctVBDWattgHttatattaKtatSV
-SttgtaScgcMcccattgggtagaKMgaSaSttYgcaaMaatVaVaKgtatgYNattctt
-agWgtcBaaagSaaatRatttNctacaStggtYcaaggttBtgaDWBtRtgaaDccacaa
-aVSatatBcaaScWccgaKttttcgtMaVttgatgtMatacatgNttBaNaagtaggaRa
-BagaagtaRtaagttacWatgHtttaagSaatgataNWattgtaSggHDtttBataaNNB
-RaatKWBgtaDcBaMaKtctaYatVaKataaaattWYcgtaHcttagtgYtgcKDtccat
-MSaaagatYcSaHatcaDtaatgMMatgcaaatgtttagaDDNtatttgaaKcNtagKYc
-aBMattaaagttaaWDacgRaRtaKttaaattaVVKaMaBtaKctaaWcatctRMtgKcB
-aBaaagattHcgMcgaSNgactaccRatHtaSNtctYcaaBDtaggaagcMatttcaBcD
-aaatggWtcaHctaKtHcHMcRgattgaMtNVaDagttaggcttYctcatDacWDaaaaa
-KtaBgtBaatcaataaKgactgactcNcattMcacatNMattgtaaaNaaacttgctaRt
-ttacttaatKYgcttgaSStgtaDaNgtaKgBgMaKgccagtgtMgatHDtgacaWDttH
-KaDgMacttaKaagBtttgtcttaagMagtaHcttWcacaatSatgYtgacHgHcaHDgt
-agaDccVaKcaataNttccHYctctaSRtaYagtNgDagatWtRttSttNtRNagacata
-ttttatggactacYMagtMacYaagYgVgKgtNtaVcgtgaatcataatcgattYtaaat
-YtctgBaMgNWNKMgDttttaWtaBaaHatNHaDacctccNKtgaVcWattYtgccaVRa
-ttMacBtcccNagYttBYNgaBaaaStWacMgcttccatgHaacttYagMtNaaVSYgcg
-atatHcaatatttgtgBcatWMtaaaaDRttHaBaHttgaacaaataaWaMcaDctgBta
-tWttaacaaWacacWtDtatttatWaaHacaVagVgKaaaDttWgRBVagttVNttctgc
-ttgacatttSHHMKScSgSaMtDtaMcgtcaWaacactMcaHWRgaactWtcgcMNcact
-VDaatHcDSttWtagactatgaRNcttagataYgaggaagagcaSHcWtMaKStatgYat
-ttttVaattgtttWataaaDaDgataMcaMtatttctVKaKgcttcctDagtgatWatac
-aRtttaaaBSMctHaaatcagStatStgaaVttaattatttgctaagcgagaWaaWtccg
-caaSgaatVgtaStMcSNcgtWggMVWNatHctggRtttaacNagtttRtaMBgatatHt
-aatcMaaaYgatMtaccttaagYatcgaaattMataaHatYMcccaaaDaYaVaWgRaHa
-aaMcHSattcatWSatttcaMtgataKBYtactgaNttgaaDactgBatgYgttaagVga
-agDagaatttKNtgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaYtBMctVBWtttt
-aSagRHBtaHtcgtactHggagtaatttaaaVVattWDgtaaHaYgDtaacatDtacWtt
-ttttatgccacttaDtagtaaKgYNcttMNDaBcaVMcMctWgatactaRcaaWagaatg
-cWcRtattccagKgaNgtctcKtWgaNtSttagVaagaSYtcctWatatSgaDaKcactc
-gBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRDaRgatatacattagtgccSttctD
-gcgatNcatttcHgcKtagcYgttttgNKWRattgBtaaNcRaatcNaagcgaaVKttYt
-WttaBttttttNggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaaaattYactactB
-attWcgccgWaaMtaBYtgtaHagtcttVttaggaHVaaNaNaatcttgtgcattttatM
-DYKccataScaWgNttccttttMaRcVtWHgaaatgBaaRatgcgatataaaWYacYggt
-acttaaaaDaaattgatcWaatgtttRcatatcaggaBcttttcttVKatKccaccYtDa
-tMtcttacMtSattaatatagaatgSgagYgWNtttagtatgRggYKacaatattgggVt
-ttaSaYcaRtBcggtDaggYaaactNataggaggaDgaKcaaataagatMKaattaaNag
-tagttcWctataaDtttcgtcgtattaccStgYgatgKtgcccYatDctYtttttYttaa
-aagaactcaNVaaYaYtccagacBttKcaatKataatKVWcBataaatgttcctatYaac
-ttaSVtgataggVatgagttgatcttacgMMgtWtYtagcacaSctcHYtataattMtta
-taYaaccKgtgtaaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBtctgcaattaWgM
-cgYttMctWtaDNcDatggWaattggaVDagKattttgaaaRHattgMaaMgtaatcatt
-ctKgNaacacccNHataaaatgaaagagSatKtacVagttggtcgtgcBtgtgcatgagc
-aacataagKtcagtttgtDBBHWcgaDtatYttgattcttaaagcMMttaKgDaHtatVg
-WHccgatKttcaaNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaR
-gKgcWgattNaaattaataNcaRtagtRgaacagataDKgtatScattaDgatcatMtcg
-YcgtttaaaRctcagcRattaacatccStcBtgaccgtgWaaagaaatgaaWtattaVtH
-acctaccaaatgBgtaVVYaaaatccKgtcaactataDgNagtcaSgtKttacHtccMKK
-WattagtatNctattagtttWttRtgaKaBHStgRagattaKRtWaKttaaWaagtaVcc
-ctgcgMRWatgttNKgtcSggSHtaBttgtaYaatDtaVtaatgtHcatWaYcMttataV
-gaaaaagBgaagRattccggcttDgggcttcttaacttRgaStaMBaaMtctMBHBactt
-VgKggcttgcgBcBtgDtttcctattaaRcatStNgcKgctatcccacSctcHtaHWtgW
-aYatgVaRRYtgctaaaatggagacctMcttgttMagBaKctttYWBtaYKgcccYttaM
-gtHaaNYgtgtagagDttcBatgtStttMtBWtaaBctaggaaNgaRgcttttttgtaga
-cRttHSagaatDaYgcctMBtgtNSNaaBttgVtWtttKgacaatatVttVatagatttg
-cgtcgDtVgtSattaaaVHtaDaatYttatKSWtcattagtaaNatctcagcgtgcKcat
-DtaBccaaccctgaYcattaNaagNaKgagttttcattaHMaVKMDDtaSHScaDattgc
-aggcccMattatacYtMatWgatttcBcBtBctKacccaaWctatccctcaacaataaat
-aaMttgtaHHcgatKgaggBtRYattatacgtaYNBacagacaaatVtMcttttRtVcaa
-ttgtttgaWtaaSacaRccMcaaacttttaaacgtacVBtcWcSaYHgtattacgRtgtg
-taKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaagaVMNaacagatt
-aHRaaMWcVgMtctgcatgaagRDattactgcKHtcactYtccttatgHtKgMgKcDtac
-NtcaStgYccaaDagttDtttgYcaagcacWWttaMgccaStaaWtVactgaagtKtttc
-aWaatgMattatKcctctttttcatgtaaactttNcaaKgttttMaMcYtgWctMtttac
-tttagaKtMgttDYttctatagWcRttatYSagacttcaScaacaYtSaattcaaagtgc
-tSaagctattaaagggtaactcacgDKgttaMRgggattttMcgttattaVtccaNagaR
-gMaataaagaStcSaacgtaWttatatHgttHBcgtacggKBtSatDactRggaRgccBR
-ttctaaaatSactcKtttVaWRatatttWaHaKMatgtacatcagctaatggBgaBNSNa
-tatcYStagaatSNattaccgtcaataaggYMRtaDaatVgYaDaattataRgVaagtgc
-aNKtgttgacttatHccacHaacVcWcNMDtatcatttttaHacatKtatagtgccWtta
-attttBSDaKaHaDttYacDtBgtMNgggBaaaaattDaaVMaKgatcggKtgtctatct
-ctVatcDtaagaagtgtaMcWatDggaaaaaYtcDVtNttcNacgaYtcgatHctctaWg
-aaggtMttcKtcttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaBgtaRagcacggc
-aHHagcagaaaaacgggtataatcaaWtacYcWtcctaBgVVaBagHaaaaaatataRYa
-gaacgggVtttcHaMtNtMgcgaaatKtattaagtMttatcttWttttRaatatgttatg
-tatttRaagKtBgtgHtHDggaBDtWccattcKtttagtttagtBYcDaMBtgatcttga
-catKctBcaaaacaHtatggaNaVttcgttatttttttcaaDtDDaatcaaaYaaBHtta
-MKMVgctgWtacVtRaaactgYtcatggcVHtgattRttataBtcgaaRataDttaatca
-ttHtatatccNattcaaHtgKRtRtagtKaRWaataYaggatccacttcacaatgtgatM
-aggactNaaccaaMaaKtagaaMctacttDSaaaWSgctcagtWaataWaHtStMactta
-DtgagWaaaatatttatcaacaactRtDgYcYtatatgtataatWtagccaagcgtttat
-aatDgctgVaaagHaattagaatBWggttctBaNtactHtKBtcgaaaRttHBatDaaKc
-caSHgtgctWttcBaatcctYttgaHacgtatgagStatRtMaacKacacggaaSctagD
-agNttgaKKSgtttctacgtagSataHttDctggBcYtttaaatcgRgagagaDtgRSaV
-StggVtgacgtMtatgaaNtWtHgtDaDtgttNaSVagaattccgcttVatatacattat
-ataYtaggYaaaRDHttHYDtNgcatHggctattYtaMcWaaVtaNtatttHaagBtatc
-agatHtttgaaWWtttKaaaggBtattHagtaacactDggtattttScttaaaacaStca
-acHttMtatcagatSaHtaVtBaNYcttHcatgHatagaaggggaWgtgBtttagtVttg
-acatYtKtattaYSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgYtNHtgNgctttt
-ataWatttKWaaKtHattgRtBtMMccgtBtYttgaKaWBatcBgaaacaBgaagatYgK
-WaaacBgatgtDaaacttDcacgatSKtaVaRDWtVKgHtcRattactctattBacaaac
-taatgDtaatcatatKRattSggtcggRMaaHVtgttMcgatatcccgVctKMgBactVt
-WtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgStgtatNStaaccgttaaaaYactBg
-aaaaattacacVttKattVNgaMattNccctaVtaaStctgaaVatactgtctaaaKYND
-tataWtattaaNgtHtaWgaBMttttccaaaDcgctgagBacacttctDSctcMtBtNcc
-aacaaatSVtatWggagSattKatRBaaaNtNtttagacttaagtHttaatcgtWctHaM
-BaHtaaagKaaKttgatattttgKcgtcDtgtKtHagDtMtatgatcttgtcSgtWgcta
-aaaattDaaaNgNYtMttNHgtHBataatMgMttctDcgtNtNatggKatHtaaRtRtDS
-tttRVcaatKgaaRSRtBttatccataaMttagcaaWtagtVgaVBatcVtYtagttgta
-MactaaataDatagNttttactagcgcKctDatatDgaHtRatVWagaDtttcggSKata
-acaggaaKggMtttctaVttMaatgattcgaagcgattaNNtYactttKgaatWttNNgc
-tatatgttacKaMtaaDgtKgttBttHtDacaagaaRgDgttWtaatgVBcaaccatgcY
-ggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgcHttRctattVtattgttcKaaata
-gtacccttgcVtaaHttaagaKtaagSaYtgcacttDattYttaVgRcacaattDDttag
-attttcHagccaYaataKaatccVDKctNcctcaaBccaaBaYgKacWVtWttatgcSat
-cDHttattaacaagaacRSactBHttDaBBBcacgttactHaKgacaKtaWMcHtaVHtt
-aattcgttatatBaaagatgaactaaYgDNattNaHgHKtaatcctcttcHttagaatVc
-agaHtagBgtMataattaagtcSRcatSagMagaaaacgYacgagcacgBcggacaHKaa
-BatSatagtatcDttRHtcagtDtaStYtagaaagtYNHtgaacaatgcgataaNgtNVa
-gtacccctBcgaYWaactRtDtatttKatBccVKtHttNcttVtgaKMtgcttggcgaNa
-tctcKggtcttttataaacWaBttcgHtcaHtcgatcgcggccaHaagcVgKattBaaWt
-tKcttaVaagYaVacagaacgcScDcgatataagttttacaaKcaaaBcYcHKctRagcg
-aatgtScBagMttYHtaatHcKKtgggatgKSaaatactgWBHVcagHcttVBgYDtaVt
-cctcatRcVKcNaaYaBtattttatRtVtDaaScgtatacMatcaaactagtaKataaat
-StHtacaagagttgtYatctagaBaHSYtaaataaaStacaHagWSRSDtagtatggctg
-aKtaRctaaagBtactcttatgBcHcNtNRNtHataaccRttagatataaHtacScgtat
-tgttgtDcctaYRaattccaNatgtgctaaaactMcaWttgttgVMaSgtaVaSctMcag
-tcacNaWacgaatWtaRtaatSgatgaaWtaaWcgtttHtWcttgatKtgDtDMcagtca
-ttcacttgaaatactWgtattcHttcataactgctgtgtKatRagtaatttYgNcaatcB
-ctgtStaggtaMatacgtYaRNtgNaHtNccRtgcSHgRcaatttVcctattaBKtgYta
-MaactRaaaaBaattHHtatVNWYHaatcagtaMVtttctattWHtttacaaVccDctYt
-ttVtNtRRKtBgatHtBcaatHYaSgaagaagHagtttDaVaattVactactYcaDtKtt
-gVVVtaWtggctaSttgtaataDctWactcaRttWcMSYtWagaagttctKHcgKtDaYg
-gaDttgtgtataacaRKctaacttcYaDtccNaNttaYtaatagRttaSagaatBtVRta
-atcttatgcgtWtataaWgHataatttYYSttYcggKKtaHcttttagHDDBtggtttaa
-acatagaRagtVagactttacKaWDMacgYaacctgctKaNattggatggNgtKcYSttt
-tcctttDtYttBcatgattSHaaccVtccatctcccacDBtgaWBaMaaccgttttctta
-aMgScBNatBtagtcttccttatKBRcctggtVStatagcDgMgtacattacccattKKt
-aRcRatRctYVaSagttatatYtcgNDDggKaHggcccgcRtacgDtcYctgaaacHtat
-attaVtcaattaaatgaWaBggYtHYYaVagWacaNtDtaRattgRacRtacacatgHta
-gagtaatatttctgDDcttgNDagcctaaHtatYHtKtRaScgtattMttacaacHggtt
-ttatSgaHVVgaattaatagttattactgtRtaWgataMDaaaactgNYacYtagKtaRc
-aYDHatatVatggctKtWatHaNttaatttttgtaagcctggcgKataaNtttRMNggDt
-ataaaatVcMRataacagctMatBgMtaaVcgagattcaaaSgtgKacgtDHatWaatgt
-tcDtWatgYcWRttcatBSHtttgaatatBgaaWgggaaBcctSSVaagctSctagYatD
-ggtatatgtaatatgtatgHYcRtagagtHcgggcataDHattcaaattcRgcaaaataa
-gattcaaYVtaBtaagRagtttgSRtgRYKgWggtttaaHgcHStgtggtctaHaccacc
-SaaaattaHatgttVtataccagaatDKVtctagtttcaatgtNctaccgDcacgaatta
-cactatgaaggccKVatccaSWaaKHtttSggatgagMagttgcaatatKYtacBttacc
-atHRttaacttacaDKKtaKaDcHHcaYatatgMagaRaNNttcggagYRtacMtHgact
-tagacBaagggBatcttgaRDactgatacatatcSBggtaaaVWgMaatttaYtaWacHa
-ttDMtttaaaRRScatcttctaatacagtBVgtgtttBagtatgBNcaagHaaaSaSYKc
-acMtKatggcacgcctSRaagcataattaYacctMaaKtcggaBaVaaWaDMttgcctta
-aacttDaaHacNVtgagaataccactctMttaatcttHcctttaggaKgaggWtaNataY
-gtaggtgaagtcWDcWaBatattRtVgtRgVtataacDDNttatcYaaaagcaVgtYgga
-DattccgtccDcSttaaWtttcaaaatggataSatctRYcaaBctMMtcttaacMaSgDa
-tgagatcaYgctcacHccMgaacatcDNgtNRcgBaaatagaYgatgcttRaattStcct
-tgagcctaVaagggatatcagtaNMttaaHcMaatccScBtYaYttatgaMNagtgHaat
-HacaHaBaaDtaRNDNcBtagBgacatStagacttgtaatMtYaNaKSaccBtttHcDaH
-NBttBaacSaggagaacgWcMgtRcaagattSctgtaBtcaatMtaHgcaaccataVgta
-agDRcDcggaaccaBtacVMgSttgtcataaaaacaMataHatgttaacaaMgtacgtMV
-catagYtKgtgtcctaBcYKattcaggBaaHagStcNcattatRRaSYtYDRaHYttttg
-gaRggggttatKcVtHgctggaNttaagagBaacattggYaaDcSacggYaRttacaaca
-ctcDcacBDtYataaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHcta
-acBgattttagHaScDctHttaaaatVaHttggttatttDtatHtcaHcBagSttttDct
-ttWtctaaataaWtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKaaDaVatatYaRa
-HDtataKaNtagtacataggSaatMtctMtccctWgaYtaggataMttcgtacgccYgBS
-gttaaHgctRgRgtDVSRattttttaaKtRMtatSgRaatKacMaYgggtagBgNHcgYR
-agHcatatgtgaacMtacSDRMHaaacHaagtWSMcaattcagtDctBattgttcatttM
-BaDVHVDBtaatKactNacgcBYtttgatctatVVtatcKaKSgtaWcgtcgNYatSaRt
-caggaRtctattagattKHttYaaBtcacatataattMgtatcataKKatDVtWtaHtHH
-VaggaaHagWaHtattgtDaHRgatgtaaaWaaSStMatttgNtgtcagDWgagaBagtc
-attaataggagttcagcHttgWagaWcRttaKttaDgaDWtYacMWgRaatatccMtaaa
-ttRaatacaKYcgcatgtatgtNaccataSttSatttttcgatcttcaaKcMDatgaatt
-caMWctKNcHtctacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaacYataacgcDgt
-aacMtSaaKcKttttDVgttgtaaNcaattctcaataaatcSVcKaacattgggacatga
-aaacggaggagtacDYgatMYttaaaBBctccYgcgagccHattttaWtataYcaKaaDY
-aaaStMctSattaatataNaWcacaataVtcatacaHcgMgaatYgaataatRcWcgttt
-cNDYcacaaacacaNttttaatctaKtRttHDSttccWatatagtKtgtcgaccaBgtVa
-cNaYBHgtttSSagcNtctacctttaacgacaDcWVacSHcaNacatttgBYaaagatWa
-gaacYMatcKgBYcBggtaWatataKcNgaaaattHYtSaYDVHSactgttNRgaaaMBt
-atataaaaacVtctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtcgaaacatggagY
-KtaaaacagttNtttatcatgctagYcctctNgttctgctaYttBataaRtattgatgaa
-actagttBgagtcttccatBagatctBaaagSacagtaaStaaatatataataatcttaa
-ctatVtaaBattHcHgcttSSaaDRaKtataagggKaacRagBaggtaMYttggtacMat
-MttttYttaacttaBaYaaaatKgtactactKDctcttgaDtMgattgVgcRaaaKatta
-atataagWgttcaWgtcaKtatcgacatDaaSatHtttcagcNtatSggtgtaRtgattt
-StBaNaHgcagttaggggatWtttgattttatcgaBtctaggcgtgtgtWttttaaSaWK
-ctWggtgataaaattacBtMRtatccattaaSWttaSMcYtHtaacttaaBaDattctat
-KatctttcatDtcgNcgacttgtaaaattDcaVatRacatgaaagtcctgtctcatacat
-atcSWgNDttgaaVKatNacDggagWaaatgaaVNtttBataaagVttVataataYcNMV
-aNaKaatRMcagNacVRactcWgctttNatHaRaBRtaaatRtaKtNgYWattaatctta
-RttgttcttaaWaaagttcNVtagMaBatcVcgccDaaBMgKttgaVaaccgYtRaactt
-tYtcatgattgtWSaaBatagtagSataDgatgNtaWatcaMttaHattagVtggagaNH
-taatatctNaagaDBatcttttaRaaNtBYagtaacVttYBtaagcaaaMatcNgKagga
-cagagtgaRatWaDaaSaDaaattVgcWttatBNctgSagtctgcSttacSRtgatHDgg
-gcBagccDtatYaaagaataDgatDaBttagctatcHtcWtagggagtDtSaaacagtag
-cttVatgttggcStataacttVtaatWKtatDatcttcDaagactgtgDNBaccaattaa
-caaagaaHWtatttaacattWaatgttcMttaNNcYaRccHtacRagatccKaaYactcV
-RDtcHVtgaaNaSatctRSaWtagagtcgcaataDcagBaagtctSNagaaaKgttataS
-taatagStaatSatataWttctcgtaDgtYRcgtHttaKtcDttRaatNacYgtagVaat
-tNttttatDgKcttttSaaattYcgYBaaggttctagYcBataacVcagggaWtaKtaca
-tgcYcctatccDatatagtcRaaaSMgtggaatcaaMaatWcgctagggtcattaVtcta
-atgHcaSHtcacttBaagaMDtactYgtttgWgacccStDtagaDaBtgctctttKaaaa
-tMttNStggtttatWttYttatKMKgtctaKcgaBaaaattcccgacYtBcaKaKttRcc
-aaBaWgMaMatgtWtcRDWttcggacNctataaacKaaatHatggDatSaaKtgcgRaaa
-cgtgttcatNtgHtcaataaacaaWMKatattcWaKcNaccWtggttcctBaMttgRtgg
-tWtaaVggDgttaDaScgWccWHatacaagtaHtaacttWaNatgtgttaacKaVtcata
-DMattgtaKccttttttStaaDDtHYattNtcgatataBattctWRatMVtStaSaWttN
-RacgatagtRcgcRtcctttacagBKaaVcYtRaKatVtaWttaVggBBatcaaWatgtg
-gagattDgWtttcaataDtactRaatBattWVacttWVNtVagHaHtatttaVagtRMMt
-aBattatataaNaagatHBtgtatVtaaacatttagtccaKDcacgWaaHagttVKBgcg
-RaSYtttVcgaacaBatttaatctaSYtccNtcatctatttatBaHcattcaBgDMYtac
-tgScccttRctaagtaaNtaaaaattatggtVataaagVStcaatcacgcDaatgtaaca
-tDBagtcgaaRDaSactgcagaHgttYatgaVgtNccttcaKHgcgataDcgYtgtgBat
-cacScgctBcVttttcYaaNtttttatcBaatgataYgtgttgtatgaVcBagtatagtN
-aRaaatKVtcRtcWatctaattgtVgataaMataWagaDttaatRcgctaKHgaRagtDc
-tScatNgHgtKgtDtHBVgYcagatgttagcgaataaNBactBaaRaWcRcMctctBtWK
-aggcaataatSYtccagtRtaSVtRgatctaBgDNDtBgtttgtaNtWtaatatDtataa
-cgccDttcaMaMatgRtgaaaMHatgBaatgcccDagNgttRDcWtaaaKtMSaBgctgc
-aatgtSVattRWcBtDaaMKRcccWtVttaaatatttctgtcatNBgaaaatHtttWtYt
-ttcaacaaagaaNYBaatatctgatNtgaacaaMaaYcNgtgatttWtNaatWcYMScMc
-taaStttNgHtMacgtMDtgagcattcacWtttKttBtKaKcHaBtttaBacgaaNYaaa
-atBaatNHgaaatMtagatDcaagMtaattctKtgNtScaatagcaHDagtagagSRcag
-caagaccYHtaNtBatKtStcRagtgttMaYgtgggtNatSaatStcYtaBaSBtaggtc
-tMtatcatgaattactcYtNagaaaDtggaaatKBattaaatcWgKtStKtcaWMggaat
-tYtggccgaWcacagaNWaNgaacaYaHgaVtMctVHttaKDcctNccBKMDagtatgcH
-tttaaaDaggtgHtattcatatttaagcBaaaRcSgttaaatgWacRatacaaatgBatY
-atatRBcacaVataRaKWMcDWtSaatatHattcVgMKYtgtaVBtgagattRgaatgaD
-gtcaStacgctaggRggtSagKcWYctacaagtttBtgaBttacgaStHgVaStgtaRta
-caDccNDattSRgttatMtNttttWHacDtttVtgacgYattccWctaagtgaaaMMatg
-NtctaataRctgaacatttVcNtgtttgaggcaaagtatgVgtaVtgRDcttBDtataaM
-BatatNgataataHaaaNacaStgaNaHgYtgacagtcYDggagattNcaDtKgtagMaa
-cSHRtcagNagatKcatataVatactgRVatgBtatcgttattHtHcKaDtagRagtgHt
-aDcVtatacattacggcaKttattgacatDaatgtctcattVcaRcttttgDtNHSggct
-taYDcHaatcDYacccWaMttgRtNggYtttttggDgctacVDtBMgBaDgtMaaBgctB
-VttVagaHBaaaaatgNactaattattNagaagNVaBgVtRgggatacgctgMtgaccat
-MaaDYDaagctggtcaatggtatBtNtccWtWKcaNcBttactgtgBYDaMtMtcWaatc
-tWYHatccgWtataaaNNacNgctYagtaaaRtaaYggcagaMaagggttHaatatcacc
-VtagtggcgtMtagtcaYaaRttWgBtctgaaBtKattaatYtacaatcKcacNcMDtgt
-actatcDcgRtaaYagattgccMtgtYKaRaWHgtaccttagcRaWaagDataccagcat
-cYtcaaSgVacatttaSttSVDSctactgaNctatVattttacgaggWgtaaaKtcNgat
-gttgcaaNVttagRtttttRttYYaYcaaagcVDMaaRaRtccVcSattttcaattagWa
-ttMMctataWatggtaagagRaaattYKKtgatagcMYgcVcgggStattacgBBctNtR
-gacaacYHctctNtataattBttStaRaaaatctgtWatcRacaaMtattYttKtccaat
-cSttatgtaWttcgcaaWgtWNcBccRgtBagNgYtDctatccMaagtgcYMtYctYttg
-tcVaaHtatgcBaaBcgaataattcttcDaacaaacBtagWYaagcaVacYcKYttgSaK
-VcttccgcctcattctcaatgVgaaacatWWctgcagtttctttttMagWttatRggcat
-tattVaagaBBttatctattatMcNtaacagttgaaaBaRtaRRtNtataYNtttNtcct
-aVBtatNtNgBtaHHYDttKctaDctcaNcatgDaYatgYagaDcaHgactHgWWaagWt
-SttctagKaaggYtcataYgBtccRaggggaaaHagaacaDatgaaaatcaKtattgWac
-gtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatctggaMMRaaaataatctaaacgat
-atgDaggaVKcttttaatgacBttNYttagtatDagYttWctttNgtHtcVtattHtcHa
-cattatHgNStgtSaNaactVMcaatcccBHNatcttDtcgaKccKttatttctVRaagt
-taMtaYtcttcatMYRctttRtaMgSaaaactgWacHagtacccatttcgcatgagtaaa
-gtHcaKgVBtaattatBtttWatgMctccattgactattcttgtcatSttaaHaVtKtDc
-atcatatccaacKatattatNggNaRatcMSDHRtcctYRaatccacYaatBattcttBV
-ctatatttRNtgaNtcaaaRgtaBcttaaDRcgctacWcttgatatctHttttgtNtYat
-atacgaVBgYHgattgggtcgacacDtttKVcaattWRcaagBtgctDKDaYtttcKgNg
-ggtcacVagatMgtMVgVgatttcagtcgtgKgtKYgtYSaMtgataatNggattKNgaS
-ggactaaBagataacactcataVgttataaSacaatcRRaagtaDaagDYtcactgtgaV
-ttWtBaMttttgaHtKaYtattccagccaaBaggataaRtBatNcatgtatatttcttac
-aaYVNatagaaagaSaaaagaaatSaBgtcgattacattgWccttHNattataacgVRDt
-YcWgaaYaVgMttcttgtDtKaYVttctgggSNtaYHWaaHactaaSSagttgSaaactY
-aMttaMaHVRtcgattaccHtcgcgatgNcaYtatattacgcHaaaMNMtaYDgacaggR
-gaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBtatccatgaScHtYtgactcattga
-YatRtacttYtctttgBgtattaaDtcaHgcNcaVatagtttggggRaaaccWcNNttRB
-gaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgagtaatcgttttaatcgaaaagttDc
-aatgtggtBaBcNtgNatBtggactttagYttBcgttRttatSgacNaDttatRKacact
-gcSKaVaaaRgHaattaaaRctgatKaWcctWggWWagccgaactaYccttgtgaBHggc
-YttttBccttaggaKtaaaBacVDcBYYgaWagaKtaHaaactaNttatagtcttttacg
-accctttKattWcgHgcaDccctHttatVVaagKaatatgggMaNHagattgNStatBat
-cgaaYgcVcagaatcctcYtBKDatatcNKgacaatKDatgaaacgaaatYYcgNBDtat
-aatMcRWtaagtataHgMaVggcaaDtggttcVattattaaaatSVaMaNcDBttataYg
-ttttStacattgagagtccaNtgaatttttKtStatatttRaatttcgBDccctaaSWat
-ttaaMBStcatacctgctctatctatKatatgaacaactctWBaNagtcgYaaaaRtctM
-tDgtaBaacaNtacagtcgataNgaVccgtttattatgatctagtDSgaHNcctKtctta
-tNtgatYKaaStctWDVcaaccgaVttScaagaaaaVcccggagWatcVaNtVaRcNtca
-gatcMMatactaaaWaagatYHRWcaSagcgMtttatSBtBtBgacRaVgtgattaagtB
-gtatcgtNggggDaWgagctgatctatttHaactttcgcttttccatttNaaYgtatttt
-actttacttRataBttgatagggacattattaaSaaaYtgatggaDaMttacttattttt
-ttaaWttttaataaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgcatccaMtggWgg
-HggagSttacaYHatYtgtaatcatttgVtataaDVttcaYttctHtHtagttWHNYYtV
-RVccatacaattaaaYatcgcatBagcaatDaWacVaBWattagaaBataatgtKaaaNK
-cagaactNaagaNatgKtBSctgattgWcNaaSataggtataaacVaatDttcRaRtVtV
-tgtataagMtSccaSScagttgatYattcagcMaaWctaagtYcSattNccgtcgtaBta
-attgttgacaaaDttttattaatacSKtcgcatNttatWatacgRtgcataactYtcacH
-gVgHttYaataaWacgSVKatactagDggcattKctggataagtVgKYtatgttagcgta
-RtttaaagacHgacacattcHKaMKtcgKtcacggtgatcaaBtMttcttattcttDaKK
-VgWagtaacatgKatVgacattagWtaRtaccRaaVHtttttRtgBccagtcgctagtRt
-aBcMVWMtaBtaggttaYcttagaSgYgttttcaaNNgtttVaagctgStttactaacWa
-ttcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVcagKatgaMttWDRatgtaatctag
-acWaccgcaNgtctgtgagtMttgaaatNtttattaRKcgtaWatcaWccaKtttNacta
-atNcgVaaBcgRgDttcDcatttgagWNattttNaYtttatgcHtttBBacgttgRgtca
-taNtatatcaWVcatgaacatRgtNaWaatcaggttaaSctttcaacatHttVKaHtNtM
-tcttcHattYatcgatgtacSaaataVtcttYStaagattDagtKccgaccHBYatMtcg
-gBacatVtaaagMcttBgtSagKgNttttcNtSaaMaStHgtattttKaRttaMtDtcKt
-cgagDKgaaaacttaaaWNaattgaWWaaggaaacKtttVggMBcatattDacctaMgaa
-KgcgcaaMRtaatcgataaatRDttataNtVgtaVDggttaNgatBgtggcaaYWtagct
-cWgtSaacgtattKcgcBtttDacaaaaaStKMtatNccagKatgtVtHtWaSBgDttgW
-gaattWagttttaagcctNcttaBtYttaRactaattggagagggtctagtatgggttta
-cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
-tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
-NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
-cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
-gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
-HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
-tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
-tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
-acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
-tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
-gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
-accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
-RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
-tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
-cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
-ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
-actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
-YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
-KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
-aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
-aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
-gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
-tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
-tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
-ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
-ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
-BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
-aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
-tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
-cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
-aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
-tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
-aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
-gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
-ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
-taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
-ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
-gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
-gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
-tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
-tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
-taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
-cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
-aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
-cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
-ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
-attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
-ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
-attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
-tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
-aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
-cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
-gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
-attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
-BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
-DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
-tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
-tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
-tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
-taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
-aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
-DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
-VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
-agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
-gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
-tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
-catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
-tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
-aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
-aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
-acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
-tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
-aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
-acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
-RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
-RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
-tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
-gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
-YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
-ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
-ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
-gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
-KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
-aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
-gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
-taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
-VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
-NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
-MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
-cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
-ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
-tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
-aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
-actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
-tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
-gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
-BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
-aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
-aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
-YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
-aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
-cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
-tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
-tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
-MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
-taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
-tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
-RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
-agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
-NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
-gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
-aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
-ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
-cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
-tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
-RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
-tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
-gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
-tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
-ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
-tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
-ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
-BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
-gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
-acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
-gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
-taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
-acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
-tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
-catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
-tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
-atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
-ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
-ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
-cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
-SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
-VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
-BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
-NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
-tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
-ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
-cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
-VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
-atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
-aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
-tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
-RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
-gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
-tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
-attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
-atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
-cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
-NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
-ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
-cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
-aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
-agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
-tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
-ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
-ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
-tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
-taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
-tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
-YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
-ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
-tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
-ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
-attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
-atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
-YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
-gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
-MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
-tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
-ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
-aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
-BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
-tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
-StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
-cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
-atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
-atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
-ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
-gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
-tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
-BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
-agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
-HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
-tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
-aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
-catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
-aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
-tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
-cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
-DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
-gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
-tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
-atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
-KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
-tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
-tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
-taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
-NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
-HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
-ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
-tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
-cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
-ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
-HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
-gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
-BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
-gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
-KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
-cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
-tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
-taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
-gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
-aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
-acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
-RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
-attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
-KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
-KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
-gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
-aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
-aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
-ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
-tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
-aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
-tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
-MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
-cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
-caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
-ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
-acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
-tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
-gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
-atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
-aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
-NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
-taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
-aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
-ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
-DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
-tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
-aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
-ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
-ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
-RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
-aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
-aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
-aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
-tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
-atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
-BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
-gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
-cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
-RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
-taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
-aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
-gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
-gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
-aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
-gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
-ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
-MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
-SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
-aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
-VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
-HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
-agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
-gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
-agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
-tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
-gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
-VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
-tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
-MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
-actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
-WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
-tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
-KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
-BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
-attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
-VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
-aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
-tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
-tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
-tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
-VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
-tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
-ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
-tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
-WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
-tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
-tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
-MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
-tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
-atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
-aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
-aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
-aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
-YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
-WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
-ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
-aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
-ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
-gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
-NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
-atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
-tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
-aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
-gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
-gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
-tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
-aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
-ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
-tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
-catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
-cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
-aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
-NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
-ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
-RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
-SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
-RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
-agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
-gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
-MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
-aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
-cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
-ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
-accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
-tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
-acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
-SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
-tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
-gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
-attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
-DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
-aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
-tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
-ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
-ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
-tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
-tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
-attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
-aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
-cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
-aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
-VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
-catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
-taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
-cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
-DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
-tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
-acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
-tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
-YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
-cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
-actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
-KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
-WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
-ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
-aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
-aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
-agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
-NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
-taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
-RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
-aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
-tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
-aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
-tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
-aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
-tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
-DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
-YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
-tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
-ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
-cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
-atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
-cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
-aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
-acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
-tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
-ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
-gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
-ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
-aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
-cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
-MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
-atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
-taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
-taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
-ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
-cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
-BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
-tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
-gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
-gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
-ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
-aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
-taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
-atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
-atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
-aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
-cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
-tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
-aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
-acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
-gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
-gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
-gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
-MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
-cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
-agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
-taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
-ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
-aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
-VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
-ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
-tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
-tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
-gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
-tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
-DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
-acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
-aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
-gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
-agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
-aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
-gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
-ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
-gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
-SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
-tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
-aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
-MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
-aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
-ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
-aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
-YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
-aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
-aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
-ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
-atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
-cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
-attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
-BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
-aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
-agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
-BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
-agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
-KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
-attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
-BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
-StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
-atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
-HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
-gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
-gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
-caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
-gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
-aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
-aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
-HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
-gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
-ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
-taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
-atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
-gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
-YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
-aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
-tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
-tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
-HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
-gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
-SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
-HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
-tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
-tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
-caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
-atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
-ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
-aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
-acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
-aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
-ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
-tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
-actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
-cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
-ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
-tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
-tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
-YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
-ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
-aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
-DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
-tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
-ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
-atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
-gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
-MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
-BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
-tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
-MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
-SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
-cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
-ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
-ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
-cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
-attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
-tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
-MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
-tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
-aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
-KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
-cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
-YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
-aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
-tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
-cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
-ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
-atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
-agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
-gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
-ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
-ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
-aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
-RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
-atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
-cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
-SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
-caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
-YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
-cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
-RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
-aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
-acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
-VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
-tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
-ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
-gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
-tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
-cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
-cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
-WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
-tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
-tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
-HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
-caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
-tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
-agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
-gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
-HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
-MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
-VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
-ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
-aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
-WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
-tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
-tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
-gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
-ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
-tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
-cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
-cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
-ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
-taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
-HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
-aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
-ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
-tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
-tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
-tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
-aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
-tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
-cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
-VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
-HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
-gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
-aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
-tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
-aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
-RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
-tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
-aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
-atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
-gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
-gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
-tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
-ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
-ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
-tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
-atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
-ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
-acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
-WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
-gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
-aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
-ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
-tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
-gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
-aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
-caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
-cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
-tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
-gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
-tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
-cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
-attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
-cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
-gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
-atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
-gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
-atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
-gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
-aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
-atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
-gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
-atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
-tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
-tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
-taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
-tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
-tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
-gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
-atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
-taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
-NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
-VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
-gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
-tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
-aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
-tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
-WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
-aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
-aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
-taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
-attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
-aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
-HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
-HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
-taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
-gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
-RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
-gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
-ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
-gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
-ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
-VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
-gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
-tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
-NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
-DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
-BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
-atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
-ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
-gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
-ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
-WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
-tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
-ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
-tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
-atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
-aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
-RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
-atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
-acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
-tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
-ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
-DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
-taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
-gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
-KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
-accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
-HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
-cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
-atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
-ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
-ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
-tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
-HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
-ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
-ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
-gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
-gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
-tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
-tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
-tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
-gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
-aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
-gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
-tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
-aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
-taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
-aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
-tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
-ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
-caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
-tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
-aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
-KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
-MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
-ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
-DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
-tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
-tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
-accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
-MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
-acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
-aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
-taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
-HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
-ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
-tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
-agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
-actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
-atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
-DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
-cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
-attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
-VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
-VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
-ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
-tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
-agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
-tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
-tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
-ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
-RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
-atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
-tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
-tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
-acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
-VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
-RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
-caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
-BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
-ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
-aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
-atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
-tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
-gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
-KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
-aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
-atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
-agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
-caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
-cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
-tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
-taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
-SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
-ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
-tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
-WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
-cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
-VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
-gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
-aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
-taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
-gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
-ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
-WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
-tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
-gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
-tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
-tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
-DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
-tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
-KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
-ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
-cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
-tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
-tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
-ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
-ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
-ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
-ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
-caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
-gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
-tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
-ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
-YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
-YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
-HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
-VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
-BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
-tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
-cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
-aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
-aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
-agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
-ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
-WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
-tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
-BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
-aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
-aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
-ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
-SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
-gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
-catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
-atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
-aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
-DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
-tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
-aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
-tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
-tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
-tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
-atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
-aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
-ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
-HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
-aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
-aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
-atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
-ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
-StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
-taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
-ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
-acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
-HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
-tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
-WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
-gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
-catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
-aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
-gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
-gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
-DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
-KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
-aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
-NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
-tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
-actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
-ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
-aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
-tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
-ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
-MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
-ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
-BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
-aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
-NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
-tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
-tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
-ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
-VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
-NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
-YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
-tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
-gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
-tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
-MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
-gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
-KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
-tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
-NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
-gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
-tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
-BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
-gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
-ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
-attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
-WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
-aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
-RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
-RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
-ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
-atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
-cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
-cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
-DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
-agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
-ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
-SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
-ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
-ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
-gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
-atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
-tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
-gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
-aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
-acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
-VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
-DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
-ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
-HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
-MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
-HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
-acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
-ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
-BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
-VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
-cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
-ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
-aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
-tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
-aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
-KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
-gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
-cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
-WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
-tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
-attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
-tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
-gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
-cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
-tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
-tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
-StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
-YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
-acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
-atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
-MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
-aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
-tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
-aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
-ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
-gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
-YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
-tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
-RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
-atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
-aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
-tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
-NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
-KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
-aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
-aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
-aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
-HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
-tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
-HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
-atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
-tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
-WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
-ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
-aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
-taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
-tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
-SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
-ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
-aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
-acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
-acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
-agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
-atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
-aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
-tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
-catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
-gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
-gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
-VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
-aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
-BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
-atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
-gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
-tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
-tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
-acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
-tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
-tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
-ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
-cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
-acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
-VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
-gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
-WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
-YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
-VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
-cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
-gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
-StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
-aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
-gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
-caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
-ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
-BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
-atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
-YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
-tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
-ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
-aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
-MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
-aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
-tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
-tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
-gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
-tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
-tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
-aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
-aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
-cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
-aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
-aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
-cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
-tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
-ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
-KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
-tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
-atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
-BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
-acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
-cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
-atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
-RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
-aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
-YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
-atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
-attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
-aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
-VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
-tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
-VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
-actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
-tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
-actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
-tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
-aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
-ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
-KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
-attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
-tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
-ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
-gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
-aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
-cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
-aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
-attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
-tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
-gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
-ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
-taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
-acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
-ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
-RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
-aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
-ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
-tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
-tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
-cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
-KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
-tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
-gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
-ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
-aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
-attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
-ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
-aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
-aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
-aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
-gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
-tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
-aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
-atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
-ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
-gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
-gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
-RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
-caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
-aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
-tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
-tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
-atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
-agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
-cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
-BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
-tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
-tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
-BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
-MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
-atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
-agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
-ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
-cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
-atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
-gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
-DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
-gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
-YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
-tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
-acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
-RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
-aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
-gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
-ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
-agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
-agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
-aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
-cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
-catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
-ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
-aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
-HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
-ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
-cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
-KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
-aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
-RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
-cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
-HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
-YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
-aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
-MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
-taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
-tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
-cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
-gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
-cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
-catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
-NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
-tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
-taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
-ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
-aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
-gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
-acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
-ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
-taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
-BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
-NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
-ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
-YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
-NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
-ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
-taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
-cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
-aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
-taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
-atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
-attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
-agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
-tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
-tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
-ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
-cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
-taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
-taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
-tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
-aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
-gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
-agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
-MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
-tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
-cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
-aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
-gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
-SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
-KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
-tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
-SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
-YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
-caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
-cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
-tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
-gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
-caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
-ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
-StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
-tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
-aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
-RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
-gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
-aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
-cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
-tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
-gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
-aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
-cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
-aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
-gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
-gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
-tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
-aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
-WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
-aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
-gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
-WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
-cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
-agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
-gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
-WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
-atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
-cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
-acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
-ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
-tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
-gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
-taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
-gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
-gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
-atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
-tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
-DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
-NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
-cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
-ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
-aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
-gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
-NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
-StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
-aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
-tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
-atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
-aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
-tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
-ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
-gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
-cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
-HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
-caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
-catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
-cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
-tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
-MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
-ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
-gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
-DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
-ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
-tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
-attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
-tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
-cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
-agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
-NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
-gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
-attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
-tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
-ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
-WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
-HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
-agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
-aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
-gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
-ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
-ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
-tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
-gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
-tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
-aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
-tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
-ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
-agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
-tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
-agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
-gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
-tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
-tccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtH
-cttcctBatcStVaactaatctacatgtacataacDgcgaVttataagcaaRWataattc
-ggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNa
-ccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttN
-taagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctac
-tatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatag
-tggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMt
-cagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacata
-aagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcg
-ctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattac
-tSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMat
-aYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatatta
-gWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaattt
-aVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaa
-tacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaD
-agWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaS
-aatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVa
-gatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBa
-aSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaaccttRtatNactM
-tcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWY
-BggataatBactgaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggc
-ttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDtt
-ttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactat
-tNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttca
-tcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatca
-aaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatca
-BgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacR
-SaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacg
-attgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctc
-gaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacc
-taaagtcactttcWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRgg
-cgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaac
-ttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgt
-acatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatc
-aagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMtta
-attYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtt
-tgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSS
-aagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgct
-atcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtag
-NDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataacc
-NaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaR
-tttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagta
-gatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNg
-WattatatctSttaScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaa
-gtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatag
-tBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattg
-ggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaN
-HatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVt
-agtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNaca
-gMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcat
-tggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtg
-SaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaat
-McaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggY
-KRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatata
-cataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaW
-tRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRta
-ttaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBatt
-aatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaa
-atatataYtacBcattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaa
-taagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRM
-gatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggM
-tcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBV
-aaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaR
-acgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatg
-VcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaagg
-aatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtattttt
-atYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaN
-tcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaH
-taaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgac
-KaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNta
-tgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaS
-taaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagtttgcctatRttt
-NtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcSca
-ataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaD
-MtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccB
-ccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagat
-aaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcg
-tSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagat
-caHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRa
-tgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatN
-NgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYag
-tRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNt
-gattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMa
-tataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaM
-tNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWt
-ttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgca
-tttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggca
-tYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcattMtatccgattag
-gtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNM
-atcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVacta
-gaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaagga
-tgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttg
-atWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYV
-tttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNg
-cgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcact
-ttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggt
-aVSaagaattattcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagt
-cttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaH
-ttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaN
-cgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaat
-RMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVat
-SagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDa
-taKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDc
-MaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcc
-tgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtV
-tNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttH
-ctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttB
-SVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVtt
-atNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYta
-aatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWa
-ttKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVta
-NtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBta
-gVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagY
-tcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtc
-aKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSa
-atctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYt
-catctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcac
-MatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctat
-ctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtccatttcagctactc
-cacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctga
-accataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNta
-ataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgt
-tatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSt
-tBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaa
-aDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagct
-tcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgatttta
-tctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHa
-taacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctct
-WttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaa
-aYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtN
-tgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcaga
-tVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaa
-ataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRgg
-YMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaactt
-WgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaM
-gttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgt
-KgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaR
-taaattaaagctKtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRac
-attgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagt
-aaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttattSatacSatttR
-tBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacat
-tttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMctt
-RScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaat
-ctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgttaNaacagNWtagt
-aNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaa
-aKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtata
-cttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMg
-gaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagt
-tMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaacctt
-ttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatccca
-YtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVt
-DYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagt
-tDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVc
-aacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDtt
-caagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagt
-aaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatg
-tHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccg
-ctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHta
-BgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgg
-gtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaW
-taaggtacaDacaDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDt
-aWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMga
-HgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataa
-tttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaH
-ttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgt
-tgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacac
-McaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactD
-DctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctH
-RtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatga
-tacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBat
-caccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRK
-ttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatctt
-DacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKa
-caVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatct
-tatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaa
-gaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtg
-HacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBa
-cgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatc
-tataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattt
-tcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgt
-gaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYacc
-agatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtg
-atcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaat
-NtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaa
-atactgctgNcttgctcatatatactaDtagctagRcataBcgccRaacaagcacaagta
-HYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcSt
-HgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWatattaccYaagWt
-gaataatgatttgtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRt
-agtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMc
-acKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVH
-cDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaat
-taHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRH
-acaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaN
-tgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtatt
-KHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaa
-cgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSat
-cccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcg
-gtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagaca
-YttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttc
-tacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVa
-gtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtN
-aRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVt
-aaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattc
-MttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaag
-tctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgS
-actctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctg
-tHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHK
-BNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaM
-ttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtc
-aatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatW
-ctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMt
-tVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBY
-MggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacN
-acacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBta
-agattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaag
-aaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBct
-tatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatg
-YYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtct
-ttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBca
-gatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBg
-ctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDt
-NcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagc
-tatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYc
-agcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcacc
-gaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatc
-cggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScS
-agcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaS
-gattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaa
-ttRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatc
-KgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKa
-RaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRcaVataattKatt
-aaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtag
-SttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtc
-DcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaa
-atccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNg
-gBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccata
-ataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWa
-tcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSgattRataYaYata
-gaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNN
-SataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBa
-tataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagt
-KtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBac
-ataKaatcggWtaccagMtttcKgScgcaactattVctHScccaacccHDtgttacgttH
-VaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggW
-tatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgt
-HagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBc
-tYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctata
-YMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRt
-SMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVt
-aacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttM
-ttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgc
-gtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaat
-tcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaag
-StcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaH
-gtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtc
-RttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgN
-ttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVa
-VtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaV
-gaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaa
-ttttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKa
-KMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtc
-ttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWta
-aWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKa
-aaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgagg
-aaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggt
-acatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWB
-WtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaac
-VYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatcca
-tBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaa
-aatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataNtattcVtcataa
-cMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtat
-gcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStg
-MtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctat
-aKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtct
-taatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNag
-YcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacB
-gVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtg
-gKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaMgSattgtaccta
-tataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatD
-aatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHa
-ttcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaat
-taattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccat
-cgaWctataSttBgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttag
-ctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaa
-YattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgata
-MNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBt
-cRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVa
-NctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcat
-RgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgt
-NaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVa
-attBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHt
-gagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctac
-KgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWat
-aacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatatt
-cKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaH
-aWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSaca
-atKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattc
-ttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaa
-atttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttc
-RaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattt
-tttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaa
-gaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattac
-aNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDa
-BBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDaca
-aacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRta
-ttVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaa
-gYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDtt
-cVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttct
-tttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgK
-tcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaa
-YWaSactgatccatatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaW
-atRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVg
-atataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKtta
-aatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaa
-SRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctB
-ccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaa
-tcWactaatactcttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaV
-caYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcS
-BSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVN
-ttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtacaatgtgctttat
-atttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaK
-tttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDg
-WaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtga
-caaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtat
-ataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttactt
-HttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRata
-VtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaa
-RtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMt
-agaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaa
-aggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaa
-atcctgttactDtDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgat
-MactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgatta
-tacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtc
-MKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctaca
-aacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggt
-taMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNa
-aattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBt
-taaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaM
-aaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaact
-ttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcB
-tctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaW
-WgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYa
-taRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVt
-ctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataK
-ctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVta
-attaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctg
-cMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaact
-aaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagata
-atcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatW
-tcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctV
-ctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgB
-ggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMctta
-tRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKa
-YatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHtta
-cgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtc
-KtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttca
-aSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatg
-tgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHa
-tgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMR
-ttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVt
-attagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaB
-tcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatg
-ttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWctagatataaNtacc
-gaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBatta
-gcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccB
-attVaYtttHatgaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDR
-aggataaWgMataggtactatatttVctataattaaatatgtgttDtcctaKataaaaac
-ggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaN
-aStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagc
-aWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatc
-atVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaat
-catatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRag
-ttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttga
-YaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcg
-atcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWc
-gcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatct
-gtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStK
-caDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNa
-KagttctcataagtaatgactgaVStaatcctcDagtcataagWtataatattacagScH
-aatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVa
-atacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVg
-tattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgN
-tBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaagga
-agaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYat
-SctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYtt
-ctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWD
-tcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNct
-ttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNc
-ggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattc
-tatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtatt
-BMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHct
-atacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgt
-acNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaa
-ccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKS
-attaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcB
-agaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKt
-gHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggM
-tNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKct
-gtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMtt
-RgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSat
-taacgttMattgtatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggc
-aatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgt
-KatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaa
-atStBcattgagggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNttt
-gtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctca
-aaacVctWtacatagttaattBBttMacatDtatttaaRggattatBVcacattattaag
-WctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaW
-aagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtct
-aaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaag
-aWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatV
-aVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtW
-caatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgccc
-ataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgat
-tBagBtaataattBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDa
-agYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtS
-ataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRattataaatatcta
-ttHSctttggNctaagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaD
-atgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaac
-HtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaataVacgaaattt
-aBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtc
-taBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttg
-RHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgt
->THREE Homo sapiens frequency
-atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
-tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
-catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
-caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
-actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
-ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
-agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
-aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
-ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
-cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
-gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
-gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
-attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
-cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
-taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
-acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
-gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
-ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
-tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
-cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
-ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
-taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
-ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
-gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
-acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
-atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
-gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
-acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
-agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
-aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
-ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
-gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
-agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
-aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
-gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
-gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
-ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
-ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
-cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
-aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
-ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
-gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
-atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
-atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
-caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
-tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
-taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
-gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
-ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
-tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
-aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
-ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
-gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
-caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
-attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
-gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
-tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
-gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
-aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
-ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
-cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
-ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
-aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
-gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
-cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
-atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
-atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
-agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
-cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
-cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
-ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
-acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
-tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
-attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
-caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
-tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
-aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
-tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
-ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
-tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
-acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
-agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
-tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
-ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
-gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
-ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
-gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
-cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
-cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
-tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
-ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
-tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
-tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
-aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
-gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
-agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
-cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
-tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
-tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
-ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
-gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
-acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
-ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
-gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
-gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
-ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
-agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
-tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
-aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
-cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
-attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
-gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
-ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
-aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
-ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
-tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
-ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
-gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
-acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
-gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
-ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
-tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
-tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
-cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
-acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
-ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
-tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
-tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
-tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
-tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
-attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
-cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
-cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
-gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
-ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
-cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
-gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
-tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
-gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
-agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
-tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
-caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
-acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
-cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
-gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
-caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
-acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
-cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
-aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
-gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
-cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
-gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
-atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
-ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
-actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
-ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
-attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
-ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
-attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
-ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
-aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
-atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
-caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
-attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
-tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
-tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
-gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
-ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
-cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
-caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
-attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
-tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
-tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
-tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
-ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
-gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
-aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
-ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
-tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
-taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
-accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
-gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
-atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
-acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
-tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
-tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
-gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
-cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
-tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
-cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
-cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
-cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
-ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
-tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
-cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
-gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
-tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
-tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
-tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
-atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
-gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
-cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
-atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
-tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
-gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
-ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
-gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
-attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
-aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
-taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
-atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
-agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
-gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
-gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
-ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
-gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
-cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
-tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
-agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
-tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
-cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
-attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
-gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
-atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
-ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
-taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
-gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
-ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
-ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
-ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
-ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
-ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
-gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
-ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
-acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
-cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
-gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
-actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
-gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
-actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
-gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
-atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
-ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
-ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
-actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
-ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
-ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
-gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
-tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
-gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
-gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
-agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
-ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
-tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
-aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
-gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
-tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
-cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
-gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
-agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
-agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
-atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
-ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
-cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
-ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
-taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
-tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
-gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
-ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
-agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
-gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
-gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
-gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
-tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
-atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
-gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
-gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
-tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
-ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
-taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
-cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
-tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
-gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
-accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
-atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
-ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
-cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
-ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
-actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
-atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
-agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
-accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
-catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
-gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
-tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
-tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
-ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
-ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
-taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
-aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
-tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
-cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
-acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
-tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
-ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
-gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
-tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
-tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
-ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
-gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
-gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
-tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
-taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
-tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
-gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
-atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
-ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
-ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
-atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
-gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
-ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
-ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
-acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
-cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
-gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
-cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
-tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
-tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
-tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
-tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
-tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
-taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
-cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
-tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
-aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
-agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
-gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
-tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
-cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
-tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
-aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
-aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
-cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
-tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
-caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
-ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
-ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
-aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
-tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
-gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
-aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
-gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
-ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
-gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
-atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
-acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
-gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
-tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
-aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
-aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
-atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
-gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
-ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
-tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
-ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
-agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
-tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
-gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
-tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
-catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
-aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
-aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
-ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
-cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
-tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
-tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
-aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
-tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
-tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
-agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
-cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
-actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
-gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
-cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
-ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
-gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
-tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
-actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
-tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
-gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
-ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
-gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
-tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
-ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
-ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
-ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
-cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
-gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
-tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
-ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
-tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
-cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
-tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
-ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
-ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
-ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
-ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
-attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
-atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
-tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
-aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
-tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
-ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
-cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
-atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
-atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
-cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
-tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
-agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
-gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
-tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
-cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
-cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
-cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
-atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
-ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
-catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
-actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
-agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
-tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
-ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
-atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
-tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
-tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
-ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
-agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
-ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
-tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
-ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
-agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
-attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
-acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
-ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
-acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
-tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
-cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
-catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
-tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
-tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
-ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
-ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
-ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
-ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
-ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
-gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
-tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
-tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
-agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
-ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
-tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
-aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
-gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
-aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
-tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
-cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
-tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
-ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
-ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
-atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
-actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
-tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
-tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
-tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
-aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
-taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
-acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
-taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
-gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
-tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
-ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
-gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
-taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
-gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
-aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
-gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
-tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
-taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
-gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
-acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
-agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
-aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
-attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
-attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
-acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
-gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
-acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
-cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
-ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
-taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
-aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
-tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
-atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
-ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
-gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
-ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
-agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
-taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
-ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
-cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
-catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
-agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
-taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
-cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
-ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
-ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
-tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
-aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
-ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
-ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
-acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
-cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
-ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
-atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
-taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
-atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
-tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
-gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
-cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
-aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
-tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
-acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
-gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
-gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
-ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
-gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
-ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
-acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
-aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
-catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
-acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
-tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
-cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
-gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
-cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
-tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
-gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
-atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
-tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
-aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
-cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
-attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
-tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
-aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
-ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
-attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
-ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
-aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
-tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
-ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
-tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
-agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
-ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
-agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
-tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
-agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
-gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
-tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
-atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
-tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
-ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
-caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
-aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
-catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
-actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
-ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
-ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
-ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
-gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
-gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
-agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
-ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
-tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
-acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
-gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
-gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
-tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
-cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
-tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
-tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
-cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
-cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
-aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
-ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
-gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
-acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
-acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
-aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
-cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
-gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
-actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
-atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
-gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
-ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
-ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
-tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
-cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
-aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
-tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
-gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
-attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
-ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
-ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
-tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
-gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
-gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
-tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
-tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
-attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
-aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
-cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
-aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
-atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
-cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
-taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
-caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
-ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
-tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
-agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
-tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
-aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
-catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
-actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
-agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
-agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
-acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
-cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
-acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
-cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
-aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
-tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
-attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
-aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
-tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
-aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
-tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
-aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
-tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
-tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
-acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
-tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
-ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
-ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
-ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
-cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
-aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
-acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
-tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
-ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
-gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
-ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
-aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
-ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
-agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
-atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
-tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
-tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
-ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
-cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
-tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
-tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
-gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
-gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
-ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
-acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
-gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
-atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
-atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
-aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
-gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
-tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
-attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
-cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
-gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
-gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
-gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
-aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
-caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
-agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
-tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
-ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
-cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
-aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
-cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
-tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
-tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
-gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
-taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
-ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
-ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
-cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
-gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
-cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
-actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
-gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
-ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
-gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
-actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
-tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
-cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
-aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
-aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
-ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
-cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
-aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
-aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
-aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
-ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
-ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
-catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
-attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
-tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
-acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
-cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
-tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
-cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
-agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
-cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
-tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
-atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
-atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
-tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
-gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
-gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
-cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
-gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
-cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
-caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
-atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
-gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
-ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
-tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
-cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
-gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
-aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
-cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
-ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
-tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
-taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
-gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
-attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
-tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
-tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
-tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
-caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
-ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
-ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
-cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
-ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
-cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
-gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
-taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
-agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
-catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
-ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
-tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
-ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
-atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
-ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
-cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
-ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
-tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
-ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
-atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
-gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
-atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
-tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
-tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
-ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
-acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
-ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
-ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
-ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
-gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
-ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
-tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
-acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
-tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
-attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
-atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
-ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
-atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
-cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
-tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
-ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
-ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
-ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
-cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
-gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
-gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
-ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
-cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
-aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
-ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
-gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
-aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
-caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
-aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
-gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
-agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
-acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
-ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
-aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
-tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
-ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
-gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
-ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
-gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
-ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
-acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
-tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
-tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
-ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
-cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
-tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
-aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
-gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
-tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
-acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
-atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
-ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
-acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
-attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
-tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
-tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
-gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
-ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
-tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
-ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
-caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
-ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
-taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
-tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
-cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
-ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
-tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
-tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
-taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
-aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
-taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
-ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
-aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
-atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
-gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
-ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
-tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
-acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
-agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
-tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
-aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
-atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
-gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
-gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
-tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
-ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
-gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
-tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
-atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
-ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
-cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
-aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
-gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
-aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
-gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
-tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
-gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
-ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
-gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
-catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
-taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
-gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
-tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
-cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
-attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
-ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
-gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
-atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
-gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
-atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
-gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
-aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
-ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
-gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
-atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
-tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
-tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
-tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
-tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
-ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
-gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
-atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
-taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
-atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
-acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
-gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
-ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
-cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
-ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
-aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
-attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
-acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
-taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
-cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
-aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
-tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
-ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
-tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
-gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
-aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
-ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
-ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
-gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
-ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
-aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
-gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
-tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
-atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
-tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
-tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
-ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
-tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
-gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
-ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
-acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
-taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
-gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
-tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
-atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
-aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
-aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
-ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
-cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
-tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
-ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
-tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
-taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
-gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
-actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
-ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
-tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
-cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
-atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
-ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
-ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
-gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
-tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
-tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
-gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
-gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
-ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
-tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
-tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
-tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
-gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
-cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
-gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
-tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
-cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
-taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
-cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
-tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
-ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
-ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
-ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
-cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
-aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
-attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
-ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
-tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
-tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
-tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
-cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
-atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
-agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
-aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
-tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
-tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
-gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
-taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
-agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
-agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
-ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
-ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
-cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
-cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
-aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
-acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
-ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
-tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
-agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
-taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
-taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
-ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
-acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
-atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
-gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
-tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
-aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
-agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
-aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
-gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
-taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
-ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
-ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
-atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
-tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
-gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
-atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
-ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
-cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
-agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
-ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
-gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
-tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
-tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
-acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
-ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
-tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
-attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
-cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
-atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
-gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
-ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
-taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
-gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
-ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
-atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
-tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
-gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
-tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
-tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
-tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
-tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
-actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
-ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
-cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
-tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
-tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
-ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
-ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
-gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
-ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
-cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
-gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
-tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
-gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
-aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
-actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
-acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
-aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
-ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
-tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
-gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
-aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
-cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
-cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
-ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
-aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
-gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
-tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
-cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
-catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
-gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
-acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
-gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
-gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
-agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
-aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
-tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
-taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
-caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
-tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
-tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
-tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
-atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
-cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
-ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
-tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
-cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
-aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
-atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
-gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
-atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
-tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
-gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
-ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
-aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
-taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
-aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
-gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
-catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
-cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
-gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
-ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
-taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
-atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
-atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
-acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
-tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
-agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
-ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
-accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
-tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
-gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
-ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
-gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
-tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
-acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
-atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
-ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
-tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
-tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
-aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
-agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
-attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
-tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
-gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
-tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
-actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
-gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
-acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
-gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
-actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
-gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
-tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
-tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
-gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
-atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
-attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
-aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
-aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
-accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
-atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
-ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
-cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
-cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
-gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
-tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
-agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
-ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
-aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
-gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
-ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
-gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
-atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
-tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
-gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
-cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
-cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
-atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
-tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
-cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
-aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
-aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
-ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
-ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
-gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
-tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
-attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
-cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
-ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
-ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
-tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
-acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
-atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
-gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
-gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
-agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
-tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
-attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
-ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
-gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
-cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
-tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
-tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
-atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
-agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
-cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
-atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
-agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
-cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
-tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
-ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
-ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
-gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
-acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
-tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
-atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
-ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
-acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
-tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
-actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
-actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
-aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
-aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
-actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
-tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
-tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
-tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
-atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
-ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
-attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
-ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
-aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
-tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
-taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
-aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
-ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
-caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
-ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
-agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
-cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
-atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
-actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
-taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
-cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
-gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
-ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
-atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
-cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
-tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
-atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
-gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
-gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
-tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
-ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
-tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
-tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
-gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
-gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
-agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
-aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
-gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
-atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
-ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
-accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
-ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
-gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
-atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
-actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
-gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
-gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
-ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
-tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
-ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
-acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
-taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
-ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
-aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
-aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
-ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
-tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
-tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
-gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
-tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
-tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
-aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
-aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
-cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
-ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
-aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
-gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
-tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
-ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
-aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
-taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
-ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
-taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
-acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
-gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
-ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
-aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
-aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
-attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
-ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
-cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
-ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
-agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
-tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
-aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
-cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
-tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
-actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
-tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
-cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
-ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
-agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
-attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
-tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
-gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
-gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
-caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
-gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
-ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
-cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
-tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
-gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
-ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
-taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
-agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
-gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
-atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
-caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
-ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
-ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
-taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
-caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
-aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
-taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
-gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
-ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
-catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
-attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
-ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
-aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
-acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
-aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
-ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
-tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
-acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
-ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
-ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
-gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
-gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
-agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
-ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
-aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
-tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
-tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
-ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
-agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
-gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
-tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
-tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
-ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
-tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
-aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
-ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
-cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
-gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
-ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
-ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
-gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
-tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
-gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
-atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
-tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
-ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
-agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
-cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
-gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
-ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
-agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
-cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
-acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
-gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
-catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
-gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
-aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
-aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
-atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
-ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
-aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
-catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
-aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
-cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
-acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
-aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
-cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
-aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
-gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
-ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
-ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
-gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
-ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
-cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
-aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
-tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
-taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
-ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
-caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
-gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
-accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
-ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
-tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
-taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
-agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
-ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
-aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
-aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
-ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
-tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
-ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
-ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
-tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
-ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
-cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
-cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
-taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
-tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
-ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
-gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
-tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
-tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
-ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
-aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
-gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
-cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
-aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
-tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
-gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
-aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
-gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
-aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
-acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
-tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
-aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
-ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
-cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
-gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
-tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
-ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
-cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
-ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
-atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
-tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
-accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
-aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
-gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
-aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
-cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
-tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
-gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
-cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
-catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
-ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
-gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
-gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
-gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
-cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
-aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
-cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
-gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
-agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
-ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
-agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
-gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
-aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
-attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
-cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
-agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
-ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
-tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
-gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
-taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
-ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
-gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
-atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
-tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
-ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
-actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
-ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
-ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
-cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
-gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
-atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
-atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
-aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
-taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
-atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
-aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
-tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
-ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
-gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
-gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
-tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
-gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
-gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
-gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
-tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
-aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
-cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
-gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
-ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
-ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
-tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
-cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
-tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
-gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
-agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
-aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
-gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
-cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
-tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
-ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
-atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
-ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
-agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
-aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
-gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
-gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
-ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
-tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
-gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
-tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
-acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
-taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
-ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
-agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
-ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
-cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
-gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
-tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
-tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
-cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
-ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
-ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
-tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
-tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
-tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
-gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
-aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
-gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
-tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
-aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
-gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
-cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
-tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
-agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
-catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
-gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
-caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
-tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
-tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
-ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
-ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
-tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
-tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
-ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
-tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
-acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
-attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
-gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
-tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
-cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
-ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
-acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
-acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
-cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
-tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
-cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
-cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
-atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
-aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
-tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
-gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
-acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
-gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
-gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
-ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
-tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
-agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
-gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
-tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
-accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
-acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
-aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
-cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
-tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
-ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
-aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
-atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
-tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
-gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
-tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
-caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
-aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
-acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
-catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
-ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
-tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
-taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
-aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
-tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
-tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
-atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
-ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
-ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
-gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
-cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
-tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
-catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
-tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
-agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
-tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
-gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
-tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
-gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
-ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
-tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
-tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
-gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
-ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
-gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
-tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
-ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
-tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
-cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
-ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
-caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
-gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
-ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
-cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
-aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
-aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
-taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
-accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
-tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
-tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
-ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
-aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
-atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
-cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
-ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
-atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
-gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
-tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
-caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
-ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
-catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
-aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
-gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
-cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
-agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
-atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
-tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
-tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
-attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
-tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
-tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
-taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
-attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
-cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
-tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
-tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
-atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
-aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
-agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
-gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
-agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
-taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
-cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
-cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
-ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
-gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
-aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
-ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
-cagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaac
-aagtggtctaaaaagactgccctggaaggagtaagaagtatacagctgatccggtgtatc
-cttcagtcatctgccctatactaattacacgacgcaaggaaaaataggtttattttctag
-gcaaacccttcataggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgt
-taccgacggataataacgatctccaatgaaccaaatgtagaatgtctattgattaccctt
-ttactattcgacttagagataggagatagaacctcagtgtacttttttagccgaatggga
-atctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatat
-tatatcgttgttcgtggaatcgataacagatttgttgacccatagtaaatgtatactagt
-ttatgttgtaagtgtagattgttttccgattgccgtccaaactttatgtcgtaattgtag
-accagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaattttt
-ccagtcactgtaagtgtaggtttagataaagccgtatgagttatatcataagggcctcgg
-aaagcagcttcgaaccaaagttcccttataatagtagtttaactataaaagtatatactg
-gtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacgtcattagagcgg
-ctccaatttaaggttaacggcttccatgtgtagttgtatacaaggataacttaaagtatc
-tgttcagcgagctagttaagttatcctcgatagaacacaactcagaggtcccaagatcgg
-gtttgcaacttgctaatttattctcaaggcaaattgggaattatcgatacctgtatacca
-taaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttagttagtgctgatt
-aacggaacattaatgtttatcgttttgagatttagccaattctctgattctaactcaaga
-tgccttatctgacgtgctatgcagcccctaagtattttacattgtaataggacacgctcc
-tttaaaactcgccaaaaggtcgttgtggttctctactggttaactatataatttacagct
-ttgttgagctagttcctctttggtttaagtcctcaatattagttggttcgagcgataagt
-tggctagttaccttagtcactatattagatccgaatgttatgcttcatctgaagaccgcc
-accctccaaaatttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtt
-tctcaagtggtgtatctgtacacgagtttccatattttcatcaacagccaccgcacactt
-atgtcactctaggtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgc
-tagtcaaaaataaacatagcgaggcaccactaattcggccgcttatcaatgggatgctct
-gcgcgagacgcgccagagctcagtagttagttcggacatacatttacttcagatgatcaa
-ttagttttctacaaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctt
-tagtatccttccgtcttatataaggtcagtcccccgtttcggtaccctggaatttactaa
-gaataatgaaacagcccccaaggacgtacgtttacaaatgatagaccagatcgcctagct
-tattccgacgcatgttgcatagaattgaaccaacggaatgtgagagtaactagatgagcc
-gaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatg
-tcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctc
-ggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatg
-gctcatatggaatgcctacctcatagtgctgaattaacacagcactgcggacctaacttt
-tcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgtagggatcctcggt
-gaatttgtgattgggtttgttgtagtactgaccaagtgaatattctttttttctaaaagc
-agatctgctgccgggcactacgaaggagatctctgtgtatcattattgcttcttgacatg
-atgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacat
-attgttgatacttcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaa
-atactggtgacttggtcctatctactattagctagacctctggggaaccacgcccccgta
-aaacctgtgcaagagagggggtcatacatcttagacatcgcgcctccaccagggaagcat
-tgggtgattgaccaggtgtgtaacaaatatgattattcttatactaatattagcaaagat
-gcataatgatttgtattaaatgtataattgaattgataagggtcttttagtcagtgatag
-agtagtataaggtagacattagaactcttaaccggacgcagatttttcggtcttagtaag
-ccaattagtcgacaaaacaaggtaagagcggttactagtagtacctataatgcactgaat
-cttcggtcgaagtatagttctaatgctatgcagattgtgacggcgacaaatgttcagact
-tatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattgaatatttttaaat
-acaaaatgcgcctacttattaggggaattaaccagattgaaggccaatcctcacatgtaa
-tgagataatagacgataaatgaaattcttgtaatagttgaactgctacgtgatgggtatt
-atatatgattgagatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaa
-cgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcact
-ccgaagtataagcaataataatgcgggtaatccagactagatcttttcggactcaatgcg
-gtttcacggtaaacatgattaataccggagagtagtcgagcttatcagcgatgcaagcga
-attcattgtgccaggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttg
-gcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaa
-gtccattaccttttagtttcagactggtggagctgactaaagttatatcatcattttgta
-cactggtttagttaacgataatttcagatttaacatgaccagacgataatcgctgtatat
-ccagttggaatgtggtttgccagaaaggttaacttataatcaagcctctcttcagtcttg
-attcgtcgtatcccatccattgcgctatacctcagtgtatttggagctgtagttataccg
-tgtgctaagatcagtagacatgacgagagcaatattatctaccttacaagcatcaacgga
-cgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatatactatagttctg
-tattcagcagttattcttatattcgatattatcttgcctattggatgtctgactttagta
-tattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaa
-ttataaacggttacaaccattaaagacaacaagaccctatagctttatttgaattttgtc
-aatgcgcaacttggagctcgcgatacatcccaattagtctatagggtcgggacgattcta
-cggcatttctggttataatgacaacatggattgtggcccgagaatcgctctttcattaat
-taagcaatcattacagtcttataagcgctacttccgagtggtagcaggtaactcgatata
-aggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgatagagaataccga
-ccacagcgcaacctttgattactttcattaaattgtacggctcactcgacatcaagctta
-agattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcag
-aaagcgtacccagagaagatacgctgttacaatatacagggtgaaattattgcctgttct
-tcgtaaccatttcgccaaacttggttagaaatgatagccattcatgatagaaataagctg
-aatgataccagtatctttaactatgtagtcagggggaagataacgatggtccatgtatgt
-ttctgatatgtgacagtattggccgcgtaatttgctaacgaagctacttaatgcctttga
-gcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgagctataatatatg
-ctagtagagaactctggaccatcatctatatgaatactgattcgagcgtgcaattacttt
-agcctgcgtactactgactctacaaaacactctgagataagtttgtagtcagtaagtcgc
-tctctataaaccttttggatgaccattgtacagccacttatagatcccaataaatagcac
-aggagacagagtttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagg
-gcacctattatttgatacctaacctaacggccctttcacaatggagaaatatatgacatc
-gggacaaacacaaatggtgggtggccaggagatatgacatggtggcgtctctaagaaaca
-cggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaa
-gattttgccgtgtaatgacctggtacattgactggtcaggaatacatcactgtagttgcc
-gtagtgtcctgttggtgttccatcaagacacatcgtataacgcaatttacgacggacatc
-agatcaagttatacagattatttaagtatcacgtgtgcattgggacataagggatctcac
-acatgccttggaacatttttgctttgtgccgctttttcgctgcactaccaatccttactt
-accagtatattcaaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcg
-attgggatagacgagacatttgcgagcgccctccacggatacgaatctcccatatcaatg
-tgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagca
-ctcgcatagcagttattcagaacctaatacacaaaaccgtcaaacattttctaattctag
-gtatgggccgatcataggagctaaggtgaaactcataaatgttttgttagatctagcatc
-ctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgtatcctttttaac
-tgaactagtcggtcccatttcgtgactgagatctattaaccgataagattaataacactc
-gcattcgtatcagctcagagtgaagtttttcaataatttgactgatatattaacttctaa
-aataaccctttaagcctcggatccgtttcccaatcacatcaaaaattcttattccaacta
-tctacggattaacaacgtgcatggggatcgtagtaagaacttgttccgatcactttgagt
-atatcaagttgacggcccggttattattgaatagaaacattcacctgctaaattaaatac
-cgcacatcggatacccgatttcagagggccgtcttactaagggcaggctttgttcggttt
-aactgagatgttcattattttacagtatgcttcaactaatatgtaacgaaggacagtgga
-tctgtctccatagtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgt
-tcgagttgttgatcatggcacgtgaaagcaacccctagtattctagacgaaaattttttc
-tagttcatctgataatttgccaattcaaaaacaaccgctggtttcccggcgcattctcta
-aaatggaagtcgaacctagagccattatttgtcggtaacccatgagttccttcttttcag
-aagttaatacactgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcat
-aacaacattggatcaagatagcaatttggctacctattctaattctcactagattcggta
-ttccactacaatatcggcagattaggattggatgaataatcggtgtttaagtccggttgc
-gtctccaatctcctaatttttattaatattgatcttggtgacctattgtaaataaaaact
-tcaagactttgaataacggtgaaaagatagaagactcatttgaaaatggatcatccacag
-atccaaacattagcaagacactaatccccaactagctattctgatcgcgatcgtgctgca
-gtactcctgtcacaatagtctgttcatgatctaattctttttgggctttgttcgatggtg
-attcagaatctttatccggtcgcttccctgtagctactttgtggggatattgcccgggga
-ttatagggttgagatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactac
-atcagaacatcgtgaagacaccatacgcggtacctttatttaccgataacatttcttcaa
-gaaataccggtaagcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaa
-ttttatttaggttactgctcaaggaataaaaactaactatttaatttataataatattac
-aaggctcacactgattagatttgtctataagacttcgcgatcccccattaccggattgtc
-ttaagaataaactagataaaccatgcattttctagataaggcctttagtctaattagata
-caaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaaccttttaattac
-ccgcaaatcactttatgtcgagactacctctgaaatttattatctacctaccgcatgagg
-acttgaaccatcttgtaggagttatgtttattagctaagattcgtttatcctgtagcggt
-ccatgtatattcaacaagcaaaaagcactcagaattgtttttagttgagtcaagactgat
-atataaataagtttccctagttttttcgtggtgggacgatattgaattgaatcttaaccg
-aagagtttcccactctgtcgcacaataatacacgccaatatttccagccctgcttatgcc
-ttaatcggttactcaatctcccattgaagttcattttgatctgcatagaagtttcgggcc
-cagccttttttctgccaccttcctccaagctctgtagacgcactctaagattgatgctca
-catgtattaattctacattaacataaatatataagtcatgcatcttcgagtaaaatatct
-ggttctccaacatgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatg
-attgggttaactggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtct
-caagaccgtgtattcctcgtgctcggaagggctattacgcttacttccgttttggtatct
-taatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaag
-agtataaaagttgtttaaacgaactacttgctttacaataccggtcgtatatatcgccgt
-gaatccagaagattgtcttctttggattatcaaccgagatcctgtggaccgatgttttgg
-gaccttcacagaggactccaggtagagctcgcttttgcattaatctaagaattgtacctc
-tctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaatt
-actttaggccgaaaggcacatgagttattatacatatacgagatggtggtatacatcgaa
-ttcggggcatacactatagttgcattgtatttagctgctttaaataatatgatattacct
-tccttacataagacattaccggcataccctggttttcaacttgtggggctttttgacgat
-cgcactctcatttgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcg
-ctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaatttaaaattgaa
-acttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgc
-aagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatctt
-gatttcattcttcttgtcaattgccgacataggatgaaatcagattccaatgcaatacac
-agtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggat
-agtatacgggccttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgt
-acaatctcacacatagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaa
-ctttattagaagtaaaaatgtgggcaaaagaaggattccattttacaagacgattacaat
-gagttacatgtctctcaacgtagtctttccctagtagtctttgaactatttaggtactcc
-agaaaattttagcaaagggtttctgtgtgaatccgccattcatgtttatgatggaacaat
-aagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatatt
-caatttagtacagatccccagaagttaagctaagtgctctaaaatggcctaaacggttat
-caaagtaggtctaattactatactaacgggtgcatcgtaataactgctgtcgatgcaaca
-ctatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattc
-ttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaa
-atttaatctatgagcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttg
-acaaccgcacacataatcgaactattgatagtcgggagcataaccaggtgaacgtacttt
-gttcacgacatttattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaac
-gcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgag
-aactttagctggcttttggccagtatttagggaccaagagcactagccttaagctgaata
-ttttgccatttatctactgttataactttaaaacttggtggcaccagacttgtcgataca
-cacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttata
-ttatatttaaactaaaagatgatattagcttctgagggcgatagggctccaaatcataaa
-gaggaatatattattacacgattagaaacccacaacatacctcgaatcgcccaaaagttt
-gacgaaacttggcagtactccacatctcagtaatacagttgggagagtctcaaatgttgt
-tttattactcaatgaaccaccctcataatttcactgctgttccattaaatttgcaaacga
-tcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtagatgcataataaa
-aaaaactgctcgctataacacgatcatcgtgcattcttacttaggagcatcacccgcaca
-ataacgtaccttaaactacaacactattagaccgagtactgtaattcacgaaagctcaag
-ctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttgcggagaggattc
-aattattttccattgcacctactccactagattcgataaaagaaggtggtcctcccttaa
-aaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatcctt
-ccctaagaaacataaaggtttttaataatgtcgactgtgaactataactgcatcctttcc
-tgacctactccggttccttgttgttatttctgaacgagaccagtagataaacaatgtaaa
-ccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaaca
-taagaagtcataatcttacttgaaattaattttgccttttattttttttcaggctcgaaa
-ttaatgatttgttttttttgaccttctagttacgctaatatgcggtcgcctgtggtttct
-attgagtcctataacgggatgggatctaatacgtttggttactagtaaacaaggtataaa
-tttgataccggagtatcaactgtataacatcaagctttatgactcatacgcgaagtaatg
-acacaaggctttcaggagatcgcgagtacagagccactaaggggtgtattacgatagtga
-caccaccgagcgcactcactccccaagtagatttatgatcctacgctaagtattagatat
-ataaccaaagaggttctagtcagtgcaactcttagaataataattagccggttttgcctt
-tttaggcctaatgcaatattcagctagcccttatgtatctcgcgttccacagcaccactc
-atggcacgcgtttaaactaatcaaatataatctatgaatgttatgccagtacttgaataa
-atcaggttttttataagtccttgcatactctcgttatatactgttagagtcttaccccat
-agaaattctttcatctgcaaacttagaagaattctcagctacggggagcataaagtcccc
-aggatgttgacaaatacaacaaatgtggcttatacaaacactccatatgaaaatcgaacc
-ctcgtggtagttttagccgaaccttgtacggataaatccctccattttccaatagcagat
-acctatcctactacctcgtggtattaaattaaagcttgaaatatagagctgcatagctta
-tccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagc
-aaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagc
-aacttcgcttattaagacaattgtttataagccataattaaaaacatatgttcaacaggt
-tcattgatatttgtaattgcacaggtttttaataaggatctacgtaagtataatgaacaa
-actttttaccagagttatattctgtactttgaaaatgctcctctaccgccttagagactt
-tcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattca
-accgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaatataattttcagt
-tttcgaacacataaccctttgaaaatctgctatttaatgtctcacctgcatgcactatct
-tctatactgctcagaacggctatacgtcactatgctccaagtgacgatttaaacgaagca
-aggaataataggtttattttagtgcaaaacaattaagtgcggactacgtgctctttacaa
-taagccttgtgattgggctataggttaagtcccatattaacgatctccaatgtacaaaat
-cgacaatcgctttgcattacccggttactagtcgaattacagatagctgttagatactca
-ctctaattttggacaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatc
-cttccatcttaaacgattacatattatagacttgttcggggtagagatatcacagttgtg
-caaacattgtaaatcgatactagtttatgttggtagtctagttgcttttaccattccccg
-aaaaacttgatctactatttcgacaacagtaaacttgaactaggtaagtgaaaacagaga
-atgcctcatagtgccactatttgtccactatatgtaagtgtagctttacataatccacta
-tgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcccggatattacga
-ctgtaactataaaactagttactggtagcgcgccatgtatagatttgttttaccggttgt
-ggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttc
-tataaaacgataaagtaaagttgatgttcagcctccttcttatggttgcatcgagagtac
-actactcagtgggaaatagatcggggttcctacttcagattgtattatctaggcaattgc
-cgattgtgccatacctggataaaataagctacctacatgtgatgcttatctattatcgtc
-atactaccttagggtgtcctgttgaacgctacattaatctttagccgtttgagatgttcc
-aatggataggagtctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatg
-tgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtccttctggttctattc
-tgctgaactattgaatggaaagattggttgacctacgtactatttgcttgaagtcatcaa
-tttgacggggtgagagacatatggtgcatactttacggactctatattttagatcagaag
-cttagcagtcttctctacaccccctcacgacataattgcttttaagaatctatgtttgat
-tcctctacgggaattcggatccgttcgcatgtgcggtttatctaaaccaggggacatatg
-ttcagctaaagcatacgaacactttgctaactagacgtatgtatagtagctataaatccc
-gacgatatttacaaaaagaaatgagactcaaatatatacatagcgaccctacacttattc
-gcaccctgatctaggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgt
-attaaatttactgcagttgagattttagttgtctactaaggattactctaacccgtaata
-aggatcaagactcggtactagctttactatcattccctatgtgttttcctaactcacaag
-ggtacgtaccagcctatgtaattacaataatgataaagacacaaaggaagtaactttaca
-aatgagtctccagttacactagcttagtccctcccatcttgctttgaagtctaaatacgc
-aatctctgaggatatacagcagaagaacactcataacgttggagtccaagaattagactc
-atagggcccccaacatttaatatgtactgtgagtttgaaggtgttctattgttaattcct
-gctcttgatacatgacacgtactccgtgtttaaggcttcggactgactttctttcataag
-ttgagcaacgaaaatttcagaatcgataagttggattcactaactaatacggctgattga
-aaactccactccggacctatatggtcgacctttatacgtaaccgatataaaacttatagg
-ctggtatatcgagccttcctagcgcaatttcggatggggtttcttctactactcaacaac
-ggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgt
-ggagcatgtgtcattatggactggagcactcttaaatcactctgcgtgtgctaaacgata
-gatcataacatgtcctgagtaaattttcttgatacgtcgcaatataccgttattagttaa
-acgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgact
-catctcgcctaacacgcacacgtataaactcggaatgactgccgctcttacatattagaa
-atacagactacaccacggaagcattgggtcattctcaaccgctgtataaaagatgattag
-tcttataataagattaccaaagaggcagaatcatgggtagtaaatctattattcaagtga
-ttaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaaatattaaccgga
-cgaagtggtttacgtcgtactttcactattagtagtaaatacaaggtaacaccggggaat
-agtactaaatataatgatatctatcttcgggagaacgagtcgtctattgctttgaacatt
-ctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgttacttttgtctat
-tcaaaagattgaatagttttttatacaaaagccgcatacttatgacggctagtatacagt
-ttcatcccctagcatcaatgctatggacagtattgaacttataggaaattcttctaatag
-ggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatggcactagtattg
-tcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctt
-taacgaagcgacagcgacagaactcccatggataaccaattataaggcccgtaatcctct
-agacatcgtttaccaataaatccgctttctccgtaatcatgttgaataccccagagtagt
-ccagatgataaccgatgaaacacaagtctttctcaatgcacttacggtgaacttattacc
-gccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaa
-cttcatcaactttcgtatattcaacgccttgtaattttactttaagacgcctggtgatgt
-agattcttagataatcagtttgttatcggctgtactttaccataatttcacaggtttcag
-gtcaagaagattatagctgtatatacagttccatgctcggtgcacagaaacgtgatcgga
-taataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagt
-gtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagatt
-agattccttaatagaatataccgacctctagtccgaactaaactatagataacgccaact
-tcaggttaattgtctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggc
-catattggttcgagcactttagtttttgatgcataggatatgcaatgtatagctgaaagt
-actttatctgtttcaaactcacattgattaaaccggtaaacctttaaagactacaagaaa
-atattcagtgagggcaattttgtcaatcacaatcttccagctagagatacttcacaattt
-gtcttgaggctacgcaacattagacggattttcgcgttttattgaaataatcgaggggcc
-caagagtatccatagttcattttgtaagatttctttacaggcttattacagcttcttcag
-actcctacatgcttacgagttatatgctagcatgtgaacaatagattaatatacaggaaa
-acgtacattgagagagatgaccctacacagcgcaaccgttgagtactttcattaaagggt
-aacgctctcgagacagcatccttaagatggccttattgtcaaatcatttgcagaagtacg
-caagatccctaaccaacgtagaagaatccctacaaacacatgagacgcggtgaaaataga
-cagggtgttagtattcaatcttcggagtatcaatttcgccaatcttggtgagaaagcata
-ccctttcttcagagaaagaagatcaatcataacactatctttaacgaggtacgcacgcgc
-atcattacctgcctccatggatctttaggatagcggaaagtattggcagcgtattgtgat
-ttcgttcctactttatcaatttcacattcatatacatgtcttttatcaaaatcgccaata
-agataggatgagctatattagatgctagtagagttcgcgccaacatcatcgataggaata
-ctcaggacagcgtgataggacttttcaatccctaatactctctataattataactctctc
-ttaagtttggaggcagtaacgcgctctatataatcagtttgctgcaccattcttcagcct
-ctgatacatacaaataaattccacagcagtaagagggtttaattgagacatcttgggaac
-ttaggattttactctaacatcaccgaaacgattattggataccgtacctaaacgaacttt
-ctcaaggcagtaatataggacatccgcaataacacaaatgctgcctccccaggagttatg
-tcttcctggaggctatatcttacacccactcactataggcaaactaaagtttaaatgttg
-attgtctaaaaaaaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgt
-aagctataattctctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcct
-ttaaagctatttacgacgcacatctcagcaagttataaacatgttggaagtttctagtcg
-gaattcccaaagaacggatctatctaatgcattcctacatttttcctgtctgccgatggt
-gccatcctattcaaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaa
-ccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccgagccacatacac
-ggagaacattctaacatagcattctcaactcgatcatttgcaggttacttctttcctatc
-ctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacctaagaaacaatt
-cagtaaaacatgttcgaattcttggtatgggaacatcattgcagctatggtctaacgcat
-taatgtttgggtacatcttccatcatataaacaggaagagtctgacgacagggagtgctt
-gcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtg
-tatccgataagatttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaa
-tgtgaagcatatatgatctgctttaataaaactttatccataggatacgtttccaaatca
-attcaataattattagtcaaaatagataaggatgaacaacctgaaggccgatcggacgta
-gaaagtggtcccatcactttgagttgatattgttgaaccacacgttattatggttttcaa
-acagtctcaggatattgtatatacagataatccgataccagttgtctgacgcccctctta
-cgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaac
-taatttggaaagaagcacagtggatatgtctaaattcttgttattcaggcctgaatttaa
-tacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctctaagctaccact
-tctatgatacaccaatagttgttctacggaatctgataattggccaagtcataaacttcc
-gctgcgttcaacccccttgctcgaatatccaactcgaaaagacagccttttggtgtccgg
-aacaaatcagttacttcttttctgatgttaattctctgtggtcagatacagaccaaaaac
-tccgcggatttaccatcctccaagaacaaatttgcatcaacatagcattttggctacata
-ttctaagtctcaatagtttaggttttcaactacattatcccaacattaggattggaggaa
-taatagctgggtaagtccccttgcgtctacaatcgactattttttatgaatatgcttctg
-ccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaat
-caggtgtaatggcagcagccaaagagcatataattagcaacactctaagaacattataga
-tatgatgatagcgatcgtcatgatgttatccggtcacaatagtagcttcatcagctaatt
-cgttttgccagtggtgacttgcgctggaagaatcgttatacggtcccttccctcttgata
-cggtgggggcttattcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaa
-ccatctagtagtcaactatactaaatcacaaaatagtgatcaatacatacccgcttcatg
-gttttaaccatttaattgattaaagatattccgctaagaaccattatctacctaaactga
-tcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgtt
-atattgtatgtagaataataggtcttggagctaaatgatgtgattggtagtgaagactta
-cccttacaactttaccggtttctcggaagaatatactagagaatcaatgcatgggctaca
-taagcactttagtctaatgagataaaaaatacacgagtcttccatcatgaattttttgtc
-gaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaataactctcatat
-gttttatataacttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagct
-atgaggccgggatccggttgagctacatctatttgctacaagaaaaatgaaagcacattt
-gttgggagttctggctacactcatagagaaataagtggcccgagtgggtgcggcctgcct
-ccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcc
-tttatttcctccacggagtagcccgtaatccggttcgaaagagaccattgaagttaattt
-tcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctctt
-caaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacataaatatagaagg
-aatgattcggcgagttaattttcgccttctccaacatggcatccctacgttcgttataag
-gaccatacatgtaggttttaaaggtttgcggttaatcgatatttacatcatagaaattct
-atagtcaaatttacaagactctagatactcactcgttgcagccggctaggaagcgctttg
-taccttacttcccttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactca
-tacctccgtgaagagggtagatagactattaaagttgtttaatagtacgtattgatggaa
-atgacccgtaggagatttaccactcaatccacaagattcgctgctgtgcattatcaaaac
-agtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggtagagatacctttg
-caatttttcgatgaaggcgaccgagataaatgagctataacactgtatgtcttttgattg
-ctataaaacacagaaacggatattaatttaggccgtaaccaacatctgttatttgacata
-gaacagatggtcctttacagcgtattccggccttaatattgaggtccagtgtattgtcct
-cctttaaagaagttgattgtaactgacttaaataagacatgtcacccattcactgggttg
-caactgctggccctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacc
-tgcgtttaaaagacataaatgtcgctatgaaggttattcattaattttagctgttttctt
-agaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttg
-tcaagtaggcgggcatcattgagattgtaagaaataaagccataaccagccccggaatag
-aaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttc
-ttatcagaggacattgcaataaaatctaacaccctcccttgtgtggttgggccatttgta
-cttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtcccataaacgatc
-attctcgcccacttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgt
-ccaatgttaggctaccttctccaactttagtacaacgaataatgtccgattaacaaggag
-tcaatttgtcatgaccagttcattcaggtacttgtatctatacggacgcgttccagagta
-gtatttgaaattttgaggttctactgataagtttagctatcgctgtatgtctgaataaga
-atttaatgtttatcttcgataaataacaattaacaactcctaggtgatacactgtgaagt
-ctgctgttccccaaattacatatgctattttgttcacataccatgaagttaagctaagtg
-ctctataatggcataaacggttatcaaactagctcgaatttcttttattacgccggaagc
-ggattaactgctgtagatcaaacacgttaggatagtgtcgttttcatatatatctaaatt
-cggtctaacatgcattacccatgcttgataacgtagcacttcgcagtctaattatgtaat
-gtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgacta
-cccggatctttagcctttagggtctaaacagaactaatattactacgtgtcatactccgg
-agcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtat
-caaattaacccagcaatacaataagcatgaaaataattgtaatcgggtttgggccggaat
-cccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactggattgagccacaa
-actcaactagcattatgctcaatatttggccagtgttctacggtttgaaatttataaagg
-ccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaataggtttaattaga
-acatccgtaggatttctgtttatagtagatttatactaaatgttctgattagattctgac
-ggccttacccatacaattaataaagacgaatatattagttatagtttactatccaaataa
-attaagcgaatcgaaataaactgtcacgatactgggcagttatcaacttatcacttatac
-agttcggacactctatattggtctgtgagtactctatcaaactaactcataagttaactg
-cgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatg
-acacatatggagatgcataataaaaaaaacggctccatatttctcgttaatcgggcattc
-ttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaactattagaccgtc
-ttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattct
-gataatactgggcggacagctggaaattagttgccagtgcacctacgcaaatagtttaca
-taaatcaacgggctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaa
-gcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtag
-gtcaactataactccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacg
-agaacactactgaaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaag
-ttggtggtagtgcacggaataacataacaaggaatattatttattcaaattttttgtgac
-tgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgct
-tatttcaggtccacggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgt
-cctttagactattcaaggtagaattttgataacgctctataaaaggtagaaaatcatgat
-tgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccct
-ataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttat
-gatcagacgctaacttgttcttagagaaaaatacacgggatactctgtgcaacgatttca
-ttaataaggtgcagcttgggacttttttggccgtaggctttattaacattcacagtaggt
-agcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaaatataagctagg
-aagcgtttgccaggacttctataatgcaccgttttttttagtacttccttactagcctta
-gtttatgttagagtctttccaattacaaaggattgaatagccaaaatttctacaattctc
-agcgaacgccagcttaatctaaacacgagcttcaaatattctacatatcggcaggagtca
-atatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataat
-taaatcctttttcaattaccacagtacgtgcattagaactactgctatgaaagtaaacct
-tgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaac
-gagttgatgttctgacgctagagcttaccattcgttaaacagataactaaaatttaatgg
-ctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatt
-tttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtac
-catagaagtatgtataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaat
-cagactagtcacacttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaact
-ctacaaggcatgggatgagattctaccgactccggataacactttacgatcgcgcataac
-tctagctcttagataagtttaacttgtcgatctcataaacagttcaaaatctgcgattta
-ttgtatcaaatccatcctctatcttctataatcatctgaaccgcgatacggcactatgag
-ccaagtgaagattgaatccaagaaagctataattggtttattttagtccatttaaattaa
-gtccggtataagtgctctgtacaatatgcagtctcatgggcatatacgttaactaccttt
-tgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaa
-ttactctttcctgttacatacgatctcttagtttggacaactagcccatgatggcgctcc
-tctagcgcatgaacctactttataattacatctttatcgatgaatttttttagactgcgg
-aggccttgagttttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtac
-gctacttgcttggaacaggcaccgaaaatattgatctactattgcgtcaactctattctg
-ctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgtcaactatatcta
-agtcgacctttactgtatcaacgatcacggagagaattaccgaatacgaaacctcaggac
-taaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagggtagcgacacag
-gtatactttgggtgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttc
-cggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactcc
-ttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttc
-agatggtaggagataccatttggcccattgtgactttacgcgattaattaaccgacatac
-atctgttcctgagctatgatcgtctgaataaattacggtctcctcttgatacctaatggt
-ttctggagacgtttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagct
-acgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaagggataaagaga
-aataacggacttctccgtagattagcctgatattttgatgggaatcatggcggcacatac
-gtaagagttgcgtgaacgaatattttggacggcgggagacacatatcggccattcgttaa
-ggtctctatattggacatcacaagcttagcagtatgagctactaacactcaagacattat
-tgattttttcaagatatgtttcattcctctaccgctattcccatacgttcgattcgccgg
-gtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgttgcgatagagac
-ctatgtatactagagagaattccccaacatttttacaaaaacaaagcagactaaaataga
-tacagtccctccatacaattaggaccaacatgttattgccgatcctagcacacacaccac
-aaactcagaacttctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaa
-ttagcattaatattaaaactaattaggataaactataggtacgagctttactataagtca
-ctaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataa
-agaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagagtagtacctacat
-gcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataa
-agttggactccatcatttagaatcatagggaccaaaacatttatttgctactgtcacttt
-gtaggtgttctattctgaattcctcatattgatacatgaatcggaatacctgtggatccc
-ttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatcgagaagttccat
-gcaattaagaattcgcctctttgaaaactcatatccccacatatagggtccaccgttatt
-cggaaacgatataataattattccagcgttgagcgtcccttaagagcgcattttcgcttg
-gcctttcttctacgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcac
-cccatagaactacctctgagagcgcgagatggtggcagtatgctctgcagctagcgttta
-gaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaattgtcggcattag
-gagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctag
-tccgcagagatacgattacagactcagatcccctaacaagcaaaacgattaaatcggaat
-cactccccctatgacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctc
-aaccgcgctttataagatgttgagtctgagaattagatgacctaactgcaagaatcatgg
-cgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcg
-gtctaaggacttagatgataaccaagaactggtttaccgagtactttcactattaggagt
-aattacatgcgttcaccgcggaatacgacgaaattttttcatatctttatgagcgagatc
-gtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaattatagattcatt
-atacagatgcttacttttctctattcaatactgtcatgagttgtttttaaataagcacca
-gaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgatggacagtattct
-actgattgcaaagtagtctatttcggcttagcagtacgcatgcctatttttttgcaggca
-cagaataatatgcaactaggattctcggcatccaattaacaggctaaaacaccaccgaaa
-gacaggtaatctacgaagttgatgtttactacagaaagcgaatgatatcacttggagaac
-attttagatgcccccttttaatctagactgagtgtaccaatatatcaccggtctaccgaa
-tcagcttgaataaaccactctagtactcatgataaccgagcatacacatgtatttctcaa
-tgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggcgacttatacttc
-tgtctttgagtacagcacaccctaatgaatctaagttagttgttgatacgaattgtaatt
-tgactggatctcgcctcctcatctagattcttagagaagatgtttcttatagccggtact
-gtaactttattgatctggtttatggtaatcaacattttacctctatttaaacgtccttgc
-gccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtctggaggccgaga
-aaagaaatgcacagagtaagctctctattgcgacatctacgtagaaactcgcatttcaga
-tcgagtaagcaactctcattgtgttgattcagtaatacaagattacctacgcttctacga
-aatatactatagatttagcctacgtcacctttagtgtcgagtcggagctttgaagatcgg
-atgcggtgtggactgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtc
-gatatcaatgggatacctcaaacgtctttatctctggataactcacattgagtataccgg
-taaaaatttattctattcatctaaatagtcagtgagggctagggtcgcaatcacattagg
-ccacatacacatacttaacatgttctattgacccgacccaactttagtagcattgtagcc
-gtttatgcaaatatgccaggcgccaaacactagccagagggcattttgttacatttattt
-aatcgattattacacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtc
-aacaattcagtaatttaatccaaaacctaaagtcagagacatgacactaaaatcacatta
-aggtcagttagtgaaggaatggctaaccagctagagaatgcatcattaacaggcacttat
-tgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaa
-cacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgt
-agacaatagtcgggacttagcagacactggatgcagtcatagaagatcttgcataacacg
-ttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgc
-taacttttccaacacgtttgtgatttcgttcataatgtatcaatttcacagtcatataca
-gggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttcagagttcagtta
-gagcctaatgattcgagagcaataatcaggacagcctcataggaagtgtcaatcacttag
-aagctatattattataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatca
-gttgcctgcaactggcttaacaatatgatacataaaaatattttcatcaccactaagacg
-gtggaattcagacttattggcaacttaggatgggactattaaataacccataagatgttg
-ggataaagttacgaaacgaaagggatatagcctgttagataggaaatccccaataaaaca
-tagccggcctccacagcagtgatctattccgccacgcgatatctttataccacgcaatat
-accaataataaaggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgc
-gtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagct
-tcctctgcaagatacaatatgactttttagcttttttactaccaaatctcagaatcttag
-aaacaggttggtacgtgctactcggaattcccaaagtaccctgctatatatgccattcct
-tcattggtccgggctcaccatggggccatcatagtaatagaaggtagtaaaactagttga
-tttccgacttttaacaatcactatcctgacccagatatgggttccgactggcccttactc
-cagtaagggcagacacacagacaacgagaacttgataactttgaattctcaaatcgatca
-ttgcaacgtgacttatttactagcctactcctataattcatacgtcaaatacatttcaac
-ggaggaagataataagtaaatattcactaaataatggtcgaaggagtcctttgccaacat
-aagtccacatatgcgctatagattttttcttggggttcatattcaataagataaacagca
-agagtatcacgtcagcgagtcattgagatcttggctagcattgtgatagcatattctacc
-taaatggtagtctagcacagagtggataagatatcagttagatatagacaagtactataa
-cagatctcgcttcgttggattgtatggctagctttgatgatatgattttataaaaattga
-tccagacctgacctggccaattatattcattttttatgagtaaaaatagataaccatgaa
-aatactcaagccccttaggacgtacaaagtggtaacataaatttcaggtgttattctgca
-accacacctgttttgggttttcaaaaaggctaagcagattggttttacagataatccctg
-aacactggtatctcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctg
-aagttttgtaaactaggcggaaaatatgttcgatagatccactcgcctgaggtagaaatt
-cgtcttagtaacgcctctttggattacacagaatagtgtactgacacgtacactgctgca
-gcagccatacgctaacattaaaattcgttgagtctacatttgttgttattcggattatgt
-tattgggaatagtatttttattcccctgcgtgaaaccacatggatagattagcctactcc
-taaagactcccttttggtctacggttcaattctcttactgagtttatgttcgtaattata
-tcggcgcagtgaatctcctaattatcaccggagttaccagacgccatgaacttatggcca
-gaaacattgcatgtggcctacataggattagtatcaagagtttacgtttgcaacgacatt
-tgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgcacgcgactataga
-agttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgct
-tgatacctgaattgagacatgtataagggctattgccagatgaaaaactgcatataaggt
-caaacaatataagaacattatacataggatcttagcgttcctcaggatggtatacgctat
-aaagtctagcttcagcagctaaggagttttgccagtgcggacttccgctggaagattagg
-tttaaccgccctgacatcttcataaggtcgggcctgattcaaacccctggagtgccgtct
-catacttgaattaatcgatggaaaacttcttctagtctaatattattattaacaaatgac
-ggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaatcattttaaccta
-tcatccattagctacagataatgataccccgatccgactagggggtaagtggttgttccg
-ttaggataaaccatgtaaaacgttagagggtttgtagattaattggtattccagataaat
-gaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaa
-gacagtataaatgaaggggattcagaagcaagtttctcgattgactgaatttataaacca
-gtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatat
-ttatcgagtctataaatatctttggttgtatattacttcacaatcaccaattctaaatga
-ttcttccactgtgcgggtggagatatcaggacgggttaaggttgacctacatcgttttga
-tacaacaaaaatcaaagcacatggctggggacttctcgatactatctttgagatagtacg
-ggcaagagtgggtgacgcctccctacattttcaagtctatcggataacttctcggtaaaa
-cgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaagttttaccggtc
-gaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggtta
-tccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatg
-cgtatggttctgatatatagatcgatgcatgaggacactttattttagccggcgaattaa
-tggaatccatacgttacttatttggacatgacttctaggtgtttttgctgtcccgtttag
-cgatatttacagattagtatttcgtttctcatagttaattgtatctagatactaactcgt
-tgaagacgcataccttgccatttgtacaggacttaactgttccgtgcgtaatttgaattt
-cttataggttcttcaaggcacgaatacctcactcatgaccgttcatactctagttaaggt
-cgggaatactacgtatgcagggaattgtaacctaggagatttacaactctttaaacaaga
-gtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatca
-cctagaaacctactcatacatttgcaattttgagatgtaggcgaaagagagaaatctgct
-ttttaacggtatctcttgggattccttttaaaaacacataacgatagtaatgtaccaagt
-aaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaa
-tattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaac
-taatgtcaccaagtaaagggggtgaaaatgctccccagggttctacagacatagagatgg
-tcagaacacgacccccctctcaacgcagtgtatttgaaatatatggacatatctacctta
-ttctgtaattttagatgtgttctgtgtataccgatattgataagtcaataggcttgatta
-cgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcagattgtttcttttt
-atgccataacctgcccaggaattcaaaaggttatcgatacccgatatgctgtgaattatt
-attctaatggccactcattcctgcttatatctggaattggcatgaatatcttacaaccta
-aagtctggcgttgcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaa
-ggtgggtacgtcacataaaagttcattagaccacactttgtgccgacgtatatagatata
-ttacacgtatagggaatgttttctcctaggtgacccgaccttctactaaggttgtacatc
-gtataatggcccattaactacgaggaaagtggtattgacctggtaatgcacgttcttcga
-tatataccgacgaggtaaagtctactattgcaaagtttgacgttatactgataagtttag
-atttccctggatcgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaa
-atccttggggatactatcgctactatcatcggaccaaaattaaataggctagtgtcttat
-cagaacatcatgtttaccgaactgatctattttccaatttaagctgatattacgtccgcg
-tatttattttagttccccggatgacgattatctgagctacatcatacaagttagcatact
-cgccggtgcattgatttcttatttcgctatatcttcaagttcacaggcttcatatagttc
-caattagcagtataattaggttttgtaactttaaccatactttataaaaggttatattgc
-acaactgatcaagcatccgctataacccgagctttaccagttagcggctaataacaaata
-agatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatt
-taggcaatgggtagtaataagtataaaatgataccacatatactataacaatgaaattat
-ttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgacatagggtcatcc
-atgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgt
-tataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaaaaccaatattta
-tcgttcgttattgctggtagtacaacatcacgagcatttctcttttgagttgatttatac
-tatatctgctgatgtgattatgtcccacttacccagaatattaagaaagtcctagattgt
-aggtatacttgactataaatataatttaagactatacaaataatctggctacattatgcc
-atcgtagaaactgataacgtagtaacgtcggacactagattttggtcggggagtaatcta
-gcatactaacgaatttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtc
-ttcaatacgtttagactattaaggactcatttcgagatccagtattaattatacgcatcc
-atatttatactgaagacggattgagttaggacgacaagctaaacaaatattaagttaagg
-attagtattatattgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgtt
-acttattcagagagacttaattcggttatgactggcagctcacctggaaagtaggtgaaa
-ggcaacagaagaatattgttgactgaattctacgggctacgaacgtaattacaaagcggt
-tcgtaaagagcataaagatcaatacaatggatctctacagtattacgtaaataacataca
-taaacctggtgttgattcgactagctcatagattaatcattaattgaagctacgaagacg
-cggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttataatatcgcgctt
-aaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatatttactaggaata
-ttagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacattggatgcatggct
-gtgggggcacaggatacttaccattagttcacctacaagcggcgtgagagggtctcagtt
-ttagccagcgcagagaagtacgggcctttagacgattaatgctagaattgtcataaacct
-cgtgaaaagctagttaataatcatggtgctagaagaacacaacttttctataaaccagtt
-ctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcac
-atagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgagagataaatacac
-cggatacgatctgcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtag
-cattttttaacagtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggt
-ttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtt
-tgtactaattcctttatagactgagtgtatcgtacactcggtacaattacaaaggatgga
-agagcaaataggtcttcaattataacagtaccccaccttaatctaaaaaccagcttcaat
-tagtattaatttcgccaggagtatatatataaatatctaaagactaaaagactcgtactt
-ttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattag
-aaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaatt
-catactcgattaaggcctataaaactgttgttggtatctacagagtgattaaaattagtg
-aatcagattacgaaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtg
-gtacaattggctgtagtagaattttggtataaaataggtgataaaccggatgggtgtggg
-cgaattcaaaagcggtttttgttccatagaactatgtagttggttataaaggttgtaatc
-tcggagattaggttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtg
-ggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggataaacaatacgca
-tataacttgacgatcgagcttatatcgacctatttgagaagtttaacgggtcgatataat
-atacaggtcttaatagccgattttttctagaaaagcaatcctatatcttagttaatcaga
-tcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacattcctttttgtcc
-gggtggggactccatttaaagtatctcacctagaactcagcggtaatagatgcagtctct
-tgcccagttacggtaactaaatgttgatacttagaattgctaaattttagtctagacatt
-tccaggtaaaccggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgc
-tcaaattgcaattgagggccctactatagacaatcatcagactttttaattaaatagttt
-tccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgta
-tgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttc
-taagatggactataatcgattaggctaattccgttcgcaaatcacagaagcaatcttact
-caaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaa
-ttacccaatacctatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagat
-taagtctgaagcctagagacaaagggatactgggcggggaaacctgctccttcacggtaa
-catggtaacaacagaatttggttaaggttaaaacgaaatatactcggagtgaattactgt
-taggtttcgtcatcggatcaataagtagtttccgtgaagacactcttatattagatctcc
-gaaattctgacccgtgcattaggcacttggtaggagattccatttggaacttgctcaatg
-taagccagtaatgttccgaaataattcgctgcaggagcgaggagccgctgaataaaggac
-cctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtcaattccagagctg
-gagatacattcatcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttt
-tcctaaacacaacggatttagacaaattaccgaatgcgccggagagtagcatcttagtgt
-catgcctatcatggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgc
-actcaaagttccgccattaggtaagctatatattgtggtcagaacttgaggacaactatg
-agctactaaaaataaacaattttgtcatttgttctagatatgtggcattcatcgaacgct
-tgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatca
-ataacatatagttcagatagagaacgaggtattcgacagagaattacccaacattggtta
-ttaatctatgcagaataatttagataatgtcactacataatattaggaccaaaaggtgat
-tccccagaagacaaaacaataaacaatctcacatattcgctagtacctatgtatgggtat
-gatcttctgattggacggggataatttccaggtatattaaaacttattaccataatctag
-acctaagagaggttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaag
-acttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaatattctgtataaa
-ctgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgt
-tattctgatcaactaatatcataaactgccactacatcttgtacaatcattcgcaacaat
-acttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaatcagattcataaa
-ggaatacgaataactctggatccattaccacgcaagggatttatttacggctgattactt
-tttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgcataaataatagca
-cctaatatagccgacaaagtgattccgataacagattttaagttgtccagccttgagact
-ccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatcccaagtggatgg
-ggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcga
-aggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattg
-gaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaa
-ggaagcacgcattgaagcagctacgcagaactgagaagatgacactctaagatacaatta
-atacaaaaacgttttaagcccaatctatcaacagatgtaagatgtctaatacacaagaat
-aaaaccttcatgtcccgatgtataataacagctttatttctgctggtcgaggtgaagtag
-tggaaattactccatcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcg
-tccatccctctctcctagtgatccgtatatccaattagaggataaccaacatctgcgtta
-ccgacgaatttaaatttttcgactatttaattccgttcaaacccgtattcgtagtaagtg
-tttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaa
-ttgctgatctaggatacatgctttataaacatgcttacttggctattttatttactgtca
-tgtgggggtttttattttcaacaagtatgtgctaccattggataatctggcttcaaattg
-aagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtcccattagaacta
-cgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaat
-ttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaa
-tgcgtatcatagaaattcgtgataatttttgttccaacctttgaatctagactgagtgga
-aaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcgaatcatcttata
-actgcattcaaatggatttctcaatcatctgtacgtcaactgttttaacaataacgtcag
-aataaaccggcacaatgagacggcggtctttcactacaccacacccttaggattataagt
-gacgtgtggattcgaattctaaggtgacgggatctacaagcctcagctacattaggtctg
-aagatctttcgtatagccgcgtatgttactgtttggatatgggttatgctaatcaacagt
-tgacagcgagtgaaacggccttgcgacctgaaatctttacggttaccttttgattcaaga
-caggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcag
-cgaccgagtaacgacaagttcacatcctctatgcaactatcattgtggtcattaaggtat
-tcaagattaactaagagtcgaccatatattctagagttttacaattaggaaccgttagtc
-tagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgac
-acatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgg
-gataaataacatggtgtttaaccctattaatggtttctattaatctaaattgtaaggcag
-cccttgggtcgaaagcacattaggccacatacacagtatgaaattgttcgagtgtccaga
-ccataattgactaccatggtacacggtgttgctattatgactcccgcaaaactcttgaca
-gagggaattttggtacattgatgtaatcgatgatttaacagtaggaactagacgtcatcc
-gttagactgagttccgacatgctcaaattgtcaggatttttatccaataactaatggctc
-tcacatgtaaataaaatcacattaacgtcacttagtgatggattcgctaaacagatagac
-tatcattcatgaactggcactgtttcgattatatttgcaacatcgaacatacttaaagtt
-aaatacgacatcattcaattaaaaaaattcagtacacctctaatgagtatcccgctttgg
-aggaaagagtagcactttaaatggacaatttaggccggactttcctgtaaatggatgaag
-tcattgtacagcttgaataaatcgttagggttagtccttacatccaccatatgttaatga
-ataaagcctgagggaccttagagctaacttgtccaacacgttgctcatttacttaataag
-gttgaaatgtatcagtaagtgacagcgagtgtagattttgaccatttaactgaccttcac
-agttttgtcttcagacgtcacttacaccataatgatgacagagcttgtagatgcacacac
-tcattcctagtgtaaatcaagtagtagctagattattataaagagatattttctggcgtc
-gaacgtaacacagagagagtataaggggcatgataatggcttatcaatatgtgtaagaaa
-aagtttttaatatcatctaactcggtggaatgcacacttatggccaactgaccttgggac
-gagttaagataccataagaggttgcctgtaagttaagataacaaagggatattccatctt
-tgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgctatgcagccacc
-agagttatttatacaaagaaagagaccatttagatacgttaattctgcttgcgatttatt
-aaacagacatttcacgtccaaccactacaaaagccctatcgcaagacgatcattgtatta
-tagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaattgttacattgtt
-tactacatatgatcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaac
-taacctgagatatatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagta
-atacaaggtaggaaaacttctggatttcccaaggttataatgctctatactgaccaagag
-atccgttacgactcgcaatgaatactctaagggcactcacaaagaaaaccactaattgat
-aaatttcaatgataatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaa
-tgaattagtcatagaaatgtcatagcaggaacataattactatattttaacgatttaatc
-gtagttggagtcctttcccaaattatgtcatcagttccgatttagatgttttcgggccct
-tcttagtaaagaagttaatatccaagactagctcctcacccacgcatgcacatattcgcg
-agaagtctgatagaatattcgacagaaatgcgactctagctcacactcgttaactgatca
-ggtacttatagacaagtacgttatcagatatcgcttcggggcattgttgcgctacctttg
-tgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgatattattttttta
-ggaggaataatacagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaac
-atatatggcacgtgttattcggctaacaaaactgttgtgccttttctataaggataagca
-gattcgttttaaacatatgacctgtaaactgggatctacaaaagaggtacttaaaataaa
-ttgcgcaacggtttagatctgcggatctttggttaaagagcaccattagatgtgccatac
-ttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggatttaaaacaattc
-ggttaggacacctactcggcggatgaagcaatacgataacattaaaagtcgttcagtcta
-attttggtcgtagtacgatgagctgatggccaattgtatttttattaacagcactgaaac
-aaaatggagactttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcgg
-aatgaggggatcttcggaagtatagcgccgaagtgtatctcattattataacaccagtgt
-acagacgacatctaattatggccagaaactgtcattgtgccattaagaggattagtagat
-agtctggaccgtggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcg
-atctaaactgcacgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgc
-gtttgtttttacgattctagtgcttcttaacgcaattcagtcttctagatccgctattcc
-aacatcaatatctcaatttaaggtcaatatatataacaaaattagacagagcagctgaca
-cttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagt
-ccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatg
-tgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctact
-attagtttattatgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgt
-taaggcaggaatctttgtaacagttcataatgttgctaaagattatcagaccccgtgaag
-acttcgggctttgggcttcgtaccgtagcataatacatctatatagttagaggcttgcgt
-gttgttgtgctattccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatg
-gtaacctggcgacctacttgttaagtcagtttaattcaaggggattaagtaccaagggtc
-gagtttctctgtatttattatactgtaggcaagaagcttttttggcgagatttaagactt
-aagcctatggtaaaaatttgatagtgagcgactatagtaagagatttgggtggttagtaa
-ttaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgt
-gaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattggcggggcacttat
-ccataatagatttctgtttgtacgccaaactctgcctcacccctccataaattgtattgg
-ctagaggttaaattctccgtaaatagagacacatatagttttatacaattgtttgaatca
-aagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggggcagagcatctc
-ttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagattatacaaagagat
-ctggatgaagatattcgtgcaatcactatcgttatgttagagagttccatgcatgaggac
-tcgttttttgaccaggagaattaagccaagaaataactgacgtatttccaaatgaattct
-acgtgtttttcctgtcacctttagccagtgttaaagatgactatggagtttcgaataggt
-tattctatagacattataacgagtggaacacccataccttcacagtgctaaaggtaggaa
-cgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaagaaataacgcat
-cacccgtcattctattgttttcgtcgggattacttagtaggcagggtattctaacctacc
-tgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcct
-aaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgactt
-cttcccctaacacagaattctcagttttatagctatctagtggcattcctttttataaaa
-ctttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgc
-cgtgtaagacttggaacccatgtatattgacggcatggcgtggctaagcaggtattgatc
-ttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccggggattagccgccaa
-aggggtctaatgacatagagatgctctgaaatcgtaccaactataaaagcacgggatttg
-aaatatagcgacagatcttccgtattctgttagttgacatctgtgctgtctttaccgatt
-gtgatttggctttagcagtcatttagtttcgttactcattgctcgtgcgatagttccacc
-gaatatggcacattcgttctttttttccattttactgcaaaccttttcaaaagctgatcg
-ataccactgatgatggcattgattagtcgattggcaactatgtcctgcttatatctccaa
-ttgcattgaatatagtaaaaaataaaggctcgccttcccaatgggctacggagtacacga
-aaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtgattgagacaaata
-gttctccagacgtattgagatatatgtctcctataggcaagcgtttctaattgctgacca
-gaaattagaattaggttgttaatactatattcgaccattttattccacgaatgtgctatt
-ctactggtattgctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagt
-ggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggta
-tctgccatattgttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaa
-atattaatgaggattgggtcgtataagaaaatcatcttttcagttcgcagatttttgcca
-atttaaccggttatttcgtcagacttggtagtgtagttacaagcatcacgattatatcag
-ctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattgcgctatatattc
-aaggtaacaggaggcatataggtcatagtacaaggataatgaggtttgctaactttaaaa
-attattgatttaacggttgattgaaaatctctgcaagatgacgctagaacacctgatgtt
-caagtttgccgataataacatataagatgaattactgtctttagaccctcatgttaatcc
-gctaacttagggcggaaacaatgttaggctatgcggagtaagtactatattatgatacca
-catagaatttaacattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccga
-ttaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaa
-ggttcagctattttggcaatgggtgagtaccgttcttagtgatttacgaacccataatct
-aggcgacttaatatacaagatttagagttacgttttccgggtagtacatattaacgacca
-tggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccag
-aatattatgtttctactagagtgttcgtatactggaatttaaatattatgtaagactaga
-caaattttatggatacattaggccatcgtagaatatgatatagttgtaacgtccctctat
-agattttcggagggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggat
-ttgtaattaactgatgcgcagcgcttaaataagtttagactattaagctatatgttcgac
-agcatgtagttttttttaccagaaagtgttatactgatgacccatggaggtagctcctca
-tgataaaaatattgttacttaagcattactattatagtgttcaaactagtaccgttgcat
-actttaagaatcagacatggcgtttcttatgcagacacacttttttagctgttgacgccc
-acctcacatccatagtaggtcaatcgcataagaacaatattctggactgttttattaccc
-agaagaaagttttttctttccggttcgttaagacaataaagatcatttcattcgttctct
-taacgatgaactaaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaa
-taattaaggcaagataagaagaacaggaacgcgcacgtcggagataactctaatagtctc
-tttattccgtttaatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgc
-aaacctatttatgtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttt
-tatcaagactttcgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaa
-aaccgcagggagtcgctctaagtgttaccaacccctcactactacgcgaaggtactcgat
-tattccttgaatgggctgaaacatcgtgattagcgtcttatgattcaggctgatagaaga
-aaacttattttctatattccacgtatacaatcacactcgtaactaaatagttcccagcgt
-tgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtgcataagtacagt
-tagtcgtctgtcacataaataatccgcagtcgatctcattacaggtattgttgttggtca
-accttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaa
-tatcataatagatgccatacacggttttacttgatatgtttacagtccttgagttgcaat
-cgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtca
-ctaggtaaaatgacttaggatggatgagcatttaggtattctatgataacactaaccatc
-atgtttctaaaatcctcaggaaatttgtattattttaccaacctgtatttatagaaagtg
-cttttgacttaaagaagccgaagtgttcaaattaaggagtacctgattgaaagaatgggg
-aattgtaatctgtaactcaattacaaataagccgttctaaggattaaggctttgtgtcta
-agcaactcacgtgaattcgaaattcatactcgattaacgactttaatactcttctgcgta
-tctacagactcatttaaattacggaatatgttttcgtttttggtttccagctcgcacgta
-cgcgtttacaaataaggacacctggtacaattggctggagtacaatgttggtttttattt
-gctgattatcccgatccctgtgggcgttggcataaccgggttttcttcaagactactttc
-gtgttgcttatatacctggtaatatcggtgagtagcttagggcttaatcacaatactaac
-aagttctctatggattggacagggcggcatccgttgactgaacgatctattaatccattc
-cctgcactggataaacaagacccatttaaattgaccatagagatgttagcgtcatatttc
-tgttcgtgatagggtacatatattataaacggattatgagcagtggttttctagaaaagc
-attcatagttaggagtgtatcagatcataccactgaaccatagagcacaattctctactg
-gctatacttcattcctttttgtccgggtggggacgaaatttaaaggttctaacctagaac
-gcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaa
-ttgcgtattttgactattgacagggcatcgtaaaccgctactcgacttggtatctgtaat
-ctgtatgtagatagagtacgggcctataattcaaattcagccaccgaagattcacaatct
-tcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagccccacccattctctg
-ttatatccgagcattaatgtagtttcactgtactacggtcacgccgtagagtcggcaggg
-caaatccaaaacaatttaggctgagaagtggcactataatagtttagcctaagtcccttc
-gctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggt
-atcttgaatactgatagctctcatggtaccaagaactttcataacctctttatttaccaa
-acctgttctactagcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccg
-gcgtaaccggcgcctgcaagctaacatgggatcaaaactattggcttaacgtttaatcga
-atgagactagcactgtattactctttcgtttcggcagcggatcaataaggaggtgacggc
-atcactctcttatagtagatatcacttattctcacaacggaagtaggatcttccgtcctc
-attaaatttgcaactggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggt
-cagagcagacgatgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacg
-ggctatgcggaaattccagacctcgagttacattatgaaacgtgtcattccatctcatta
-aatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtctattttcccaagg
-agaaggagagtagcagcttagtggcttgcctatatggccccctaagtacgtactcggcac
-gcttagaagattgggctaccccgcactatatgttcccaaagtaggtaacctagatagtgt
-cgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttggcaggggttata
-cattgcgggcatgaagagtaacattggacatgaacggacattcgaaccctgtgagtttaa
-taccctatctccggatcattataaagtaaatatacgtcacttactctacgtgcgtttaga
-cagtctttgaaactaaattggttatttttctttcatctagatttgtctgtatctaactaa
-attatagttccacataaagctgattcaactgaagacataaatataaactttctaacatag
-tagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagtagttcctggtaga
-gttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtga
-acatacataataccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcct
-acgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgctt
-cgagtatgtacattcagatctccttagtatcatcaaattatagattttacggccacgaat
-tattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagt
-tgaggttggaagaagagtcattatgctataccaagaactctccatccagtacctagaaag
-gcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttg
-taccagatggcttttataatagaaactaagtttcccgaataacggtgtacgataacagat
-ttttaggtgtacagacgtctgactcaatgaacacacattgggacctgccccgggaggagt
-agtagataattaccttctccagcgcgggtcttttaatatcacaacataaaaatactaatt
-aatatcacacaccctcatcctcgatggagcctagcatcatacacgtttgatagacaacgc
-caattttactgtaatatgatattcgaatctagtatgtggacgctgtaccacattgtttaa
-aggagctccctttaccgacatgaacgaagcaagctttgtacaagatacgaagaactcagt
-actggtaactataagagacaatttatacataaaagtgttaagaccattatataaaaagag
-gtatgaggtctttgtaactacaataatacattcatcgaacgatggagaataacagagtta
-tttctgctgctcgagctctagttctgctaatttctcaatcttgatgccactcgtttgagt
-cttccattcgctcttaacgacgcgtacatccctctctcctactcttacctatatcctatt
-actggttaacctacatctccgggaaagacgtaggtaaagtggtccacgattgtattcact
-tataacacctagtagtactatgtgttgctgagagtgaggacacacttactctacgagttc
-aagtccatatggacattacactttttcagcatctaggtgtcatgatgtattaacagccgt
-taggggctatttgattttatcgattgtcggcgtgtgtattttcaacaactaggtgctaca
-attcgtgaataggcatgaaaattcaagattgcagttcctatcttgtataatctttccttt
-ggacgagttgtaccatttcaactaacctgcaagtggggggtcatccatatgaagatttgc
-caaatacctggagaccctgaaaagtttatccagattaataataacaaacaaacctaagcg
-aagaacgtcagctttaataaactatcactatcatagaaattcctgttaattgttcttcca
-aacgttgaatagactatcacgggtaatagattgaacacggagaacgtttatccggcttgt
-aaaatatcgtcgaatctgctgataactcaattatattcgatggagaattcatatctaccg
-cttagcttttaaaaattaagtcagattattccgccacaatgagaaggcgcgagtgcacta
-atcaaatcacttaggattattacggacgtctgcattacaatgctttggggtagggttata
-caagcatatgattctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggc
-atatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatct
-ttaagctgacctgttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaa
-actctaacatagcgtggcactatgagtacgtgtaacgacaaggtctcatactcgatccta
-agataattctcgtctggaaggttttaatctttaactaagagtagaacttagtttattgac
-ttttacaattaggatacggttcgcgactctaccacagggcatcatacctggagctctgct
-atctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatctactgagcaatccc
-tttaagcattcctagtttgagagccatttagatattgctgtttaaaccgattaatggttt
-ctattattataaagtgtaacgctcccattcgggacattgaaaattagcaataagacaatg
-tatgatattcggcgagtctcaacaacattatggtctaccatgggacaaggggttgatatg
-atgaatccacaaaaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgtt
-ataaggacgatctagaagtattcaggtacacggtgttcagacatgctctaattgtcaggt
-tgtttataatttaacgtatcgctctctattctaaataatataaaattaaccgctcgtagg
-gatgctttccagtaaaagatacactatcattaaggttatgcaaatgtggcgatttgattt
-gaatcttagtacattcttaaacttaaatacgtattatttaaagtaaatatattatctaaa
-ccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgac
-cctctttcatctaaagcgatcatctatttcttctgattgatgtaatactgacccttactc
-cgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaat
-caactggcgctggtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcat
-tttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgat
-gactctcattgtagatccaatcacgctttcctacgctaatgaaagttctagatagtgtag
-gtgttagacagaggttagcgcctacatccttacacacacagtgttgaacggcaagcataa
-tcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcccgcctttgaaca
-atgatgccaaaatgtcctgccctagagttatgataaaataactgctgccctgtaacttaa
-gtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaa
-aatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagagtacatttagtta
-ccggattgcggcttgacatttattttacagaattttatcggcaaaacacttcatatgaac
-tatcgcttcacgataagtctatgatagactagcattcgtagagaacaggaagagcaatca
-ttatatatgaagtgttacagtgggtactacatatgagatcattaggtctatatccggcct
-tcctcataagaccttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacc
-cagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggttttaactagggg
-ttattgatatttaagctaaaagagttccctgaacactcgaaatgtataatctatcccaac
-taaaaaagtatacctctaattcagaaatgtcattgagattagactgatgtcaatacgcta
-ggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaatacctccatcttaa
-gttctatattttaaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtg
-cccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaatctctagctact
-atcccacgaatgcactgatgccagtcatggcgcttacattagtcgacagaaatccgacga
-tacctatcacgcgtgaactgttctggttcttattcaattcgaagtgatctcagatacatt
-acggccatgcttgcccttcatgtctgctgagcagttttgttataggctgaatctcctcta
-agcgaaattgataggatttttggtggtcgatttagtctgtacctgcttattaagattcaa
-aatgacctacttcttacgccgaaatgatagggatcggctgaggaggataaatatacgctg
-gtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactctaatctccgaga
-taaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtat
-agtccaccattagttctgacttacttaatatagactgaccgagattgtagtatgtggatc
-caagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaaga
-gttaattaatagtactgcactataattgtcggcggagtaccatgagctgttgcccaattc
-gatgtttattaacagcacgcataaaaaatccagacttttcaattagaattaactataaat
-ggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtatagaccccaactct
-atctaatttttataacacctctgtaatcaacaaatcttattatgccatcattatgtcatt
-cgccaagtaagtccagttcgagattctctggaccgtgcaatagtattgtcaaattatggt
-aatggaatccttcttctaacacccttagaaaagccacgagaattgacaagttgggcgtgc
-ttgtccaggagcaacataagtgccgtttctttttacgatgatagggattcttaaagcttt
-tctctattctagatcccagttgccatcatcaatatctcaattgatgctcattatatagtt
-cttatttagtatgtccagatgtcactgaagatcctgcctagaaccgatattctcgacagg
-atcatcagttcgacggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaag
-gaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagt
-tttactgcctttaattagtagtcgattagtgtagtttgatattatctaccttatagaatg
-taaacagtaacccggccttaatggtttggcaggattctttgtaaaagttaataatgttca
-taaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaa
-ttcgttttacggagtggcttgcgtcttgttgtccgagtacacatattgctcctctccccc
-actcttctaggaaaatcaattatgctaacctgcagaccttcttctttactatctttaatg
-catgcccagtatgttcatagggtagacttgctatctattttgtataatctacgaatgatg
-cttggggcgcgacttttaacaattaagccgttgggtataatttgagagggtgccacgata
-gtaagagatttccggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagct
-caccctcctcagttctccaaccctgaaccggctaagtatgactgtgcagtattaattttg
-aatacatattgcagcccctaggatacattatagatgtctctttcttacccaaactcgccc
-gcaccaagaaagaatgtggattcgattgaggttaaattagccggaattacagacacagat
-tcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatg
-gattacgttggggatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaag
-aattcacagaggattaatacacttctccatgaagataggactgcttgcactatccttatc
-tttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataa
-cggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatc
-atgactttggactttagatttgggtattctagagactgtagaaagactgcaacaacaaga
-cattcacagggcgaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttag
-gaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcggccccttgaatta
-cgtgcatgcctttgctaaaagacctctgggaaatagattgaatattctggacagcagcga
-atcctgattatatctcaagcgaatatatgacccgcaagaaggatttatactagaataagt
-ctaagaaagggcattgggtcacttcttccactaacacacttttatcagttttataccttg
-agagtcccatgcatttttatatatatttaactttcgttgcgtaaaactttaaatatgatc
-cgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaat
-cgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttctatgctaaaaat
-gtatagccccgcattagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgta
-acaaagataaaacaacgcgatttctatgtttgccaaagtgattaagttgtatcgtagggg
-tcagcgctgatgtcttttcagtttgggttttggatttaccagtcttttagtttcggtact
-atttgatcgggacattcgtccaaacatgatggctcattcgttctttttttcaattttaat
-caaaaccttgtatttacctgatacattaaactgagcatcgcatggaggtggagattccca
-tatatgtaatcatttgatatcctattccattctttttagttataaataaacgctccactg
-cacaatgggagtaggacttcaccaataattagcatctactgtaaacaagcgccgtaacga
-aatgattactgattgagaaaaataggtctcaacaacttttgacagatatgtatccgatac
-ccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaa
-tggttattactccaatgggctattctaatccgatggatacgtaggagagagtgtacctac
-accgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtg
-cgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaaagaagtcccctg
-aatagcccttagataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattc
-ggttaagttcgcagagttttgccaagtttacaggtgatttactaacacttgggagggtac
-gtacaaccatcacctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagt
-gtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtcataggacatcga
-gtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtgataatagctgcaa
-catgaagatagtaaaactgaggttaaactttcaccatattaaattatatgttcaattacg
-cgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgggtccctatcccg
-actttgtacgagattttgataaaaaatagtattgtaaattcatttgatggcgtagaaccg
-ggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcc
-tggctcaatatttataatagtaatggttaagattgtggcccaatcgctgagtacccgtct
-tacgctttttccaacacataatcgacgagaatgtatttaaatgtttgagacttacgtttt
-ccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgtagttttctcatct
-gctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggct
-atttaatttttatggtacacttgaatatgtttagccataatgtagccaatactacaatat
-cagatacttgtatacgacctatagacttttgccgaccgctcgtagagtgatttagaaaga
-tgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgt
-tgactattttgctatatgttactctgaatgttgttttttttaccagaatgtgttataatg
-atcaaccatgcacgttcctactaatcatataaattttgttacgtaagcttttctatgata
-gtggtctaaagactacccttgcatactttaagattaagacatgcactttaggaggaactc
-acacgttttgagctgttctagcccacctataagccattcgtccgcaatcccataactaca
-atagtcggcaatcttttattacccagaactaacgtttttatttcccggtacgtatcacat
-taatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgct
-tcttgagaatacagattactgttagaatgaaggcatcataactagaacaccaacgcgcac
-ctcgcacattactctaatagtagctttattcagtttaatatagacagtatttgaaccagg
-cgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatt
-tgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataac
-cagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacat
-cacttcgtaccgaagggactactgtattccgtcttggggatgtaacagactgattacagt
-cttatgatgaagcctcattcatctaaaattagttgatttattccacggatactatcacac
-tcctatagaaagagttaccaccgtgggaagctagatataataaataaaagacatacaata
-ttagtatggctcatgatctacacttactcggatctctctttttttataaccagtagatcg
-cattacacgtattgttgttccgcatcaggccctaggggctcaaacttccatggtggataa
-ctaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgggtttacttgatt
-tctgttcagtcattcacgggaaatcctaggagtctttcataacggcggtcttagtaggaa
-tgtagtcaagctctgtagaggtctcgacggaattggtatttcctggcatcacaatttacc
-tagtattggagatcacttaaaataatgttgagataataatcaggatatttctagtatgtg
-acaaacctctatttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaac
-gactacatgttggaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtg
-ctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgtaatactactgta
-accaagttattactcggctgcgtagataaagtctcatgtaaatgacggtttatctgttac
-ttttgggtttcaacctagctaggacgccggtactaattacgacacctgcgtatagtgcag
-ggtgttcaatgtgcctttttatgtccggattataaccatccctctcccacttggaatatc
-accgggttcttaatgacttagttcgtcttccttattttccgggtaagatcgctgtggacc
-ggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttc
-actgaaacttagattaatcaatgcactgcactggattaacaagaacatgttatagtgtac
-tgacacatgttagactaagaggtctgttcgggttagccgacttatatgtttaaccgattt
-tgacaactgggttgagagataacaatgaagagtgaggactgtagaagatcttaaaactgt
-accatagtgctcaattcgctaatggcttgaattatttaattgttctaaccctggcgtcga
-atttttttggttcgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtac
-cgttagaaagcggcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaa
-gctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaat
-tctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtg
-gtctataccaccaaaaagtatatgggatatcccagaatttatcgactttcaatcgtctac
-cgtcacgacgtacactaggcagccctaatccaaaacttttgaggatgagtactgccacta
-ttatactgtaccatttgtaacttacattttatatcttcaaagaggtagatattgtcggcc
-attactgtcacttacactaagggtagcttgattactgatacctctcatggtaaaaagtaa
-tttaagaacctatttttttacataacctctgctactaccgttagtgttttagtcggttca
-agtcacaaaatccctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaa
-acttttgccggaaccgttaatcctatgagaataccactcttggaatcggtcctttaggct
-gaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaa
-acgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatcttacactctttt
-cttaactaagtatgagagcaacctcactcctgaacagcttgttacctaacgagaagaggc
-tttaagtagcctggagcctcaaccggatatccggatttgactctcatccacttacatgat
-gattacggtcattacatctcatgattttctgagtgccctatagactgggaatttaatcta
-ccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatg
-ccaccataagtaagttctcggaacccttacatgattggcctaccaacctatatatgtgac
-caatgtacggtacatagagtgtggcctatcatattcaggtcatcgagctcagtatttaaa
-gattatatggtcgctgggggtattcagtgcgcgatggaagactaacattggaaatcaacg
-gaattgacaacacgctcactttaataacctatctcaggataagtttaatgtaattagacg
-gaactttctctaactccgtgtactaactctttgaaaataatgtgggtatttttatttcat
-ctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtc
-ataaatataaaatttagatcttaggacagaggaaagtgctttcccgagcataggatctgg
-cctacgccagtagttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagg
-gtagtgttcgatactcagcggggaactgacatattacactaaggaatcaaggcccttcgt
-atgggtcatgtttatatatttaattacttacgctatttgatcgagaatagctatagtaac
-gtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatactgtgtatcatatt
-attatagatgttaaggcatagaattattggtattgatgtacaaaaaattatgggtgggca
-gtaccgataggcattacgagcagtgcagcttggaagaactggatgtatcctataactagt
-aagagccttaaaggtactacatacccagggatgttaccatcattaatttggccatcttca
-atcttcgcaatgcatactttcttctacaagatgccttttagaagacaaaataagtgtcaa
-caataacgctgtaacttaactctgttgtacgtggaatcaagtctcactaaagcaactaac
-attccgacatgcaaacgcaggactactagattattaaattcgccagcccgcctcgtttaa
-tataacatcataaaaattctaagtaatatctcacacactaatccgccatcgtccatagca
-tcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgccaagctagtttc
-gcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaaccatcctacctt
-tgtacaacagaccaacatctctgtactggtaaatagatctgaaaagttataaatataact
-gttttcacattgatagaaaaacagctatgtgctatttgtatatactataataaattaagc
-gaaacatggagattaaaacagtgttttctcatcctccacctcttgttctgctaatttata
-attcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaacccgacataaataga
-tacgacgctgaacgagatcctatttctcctgaaaattattagcacggtaactcctaggga
-tagtggtactagttggtatgaacgtataaaaacttgtactactttctcgggatgtgaggg
-agcaaactattactcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatac
-ctgtctggatggattatatgcaggtaggcgagagtggattgtagcgatgctcggcggggg
-tattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactg
-catatcgtcgattagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtcc
-gggcgcatccatatcaagttttgcaatagtactccagaccatgaaatggttatccagatt
-aataataacttaatatactttcactacatactcagcgggtattaaatttcactttatgtc
-aaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaa
-accgagtaacttgatcagccttgtaaaatatagtagaatatgatgttaaatcatttatat
-tccagggagattgaatagcttacgattagctggtataatttaactcacatgattaagcaa
-atatctgtaggaccgagggaaagaataaaataaagtaccatgagttcggaacgctgcatt
-acatggcgttgggctagcctgatacaagaagatgagtatggagctctcttcatcgggacg
-tgacaaccctagcgtaatcttggcagatcccggagcagatgattatcgtctaacactgtc
-tttaccaatgcacaacgcatagatttaacctgaactgttctggattcactcctgactaca
-gcctacaactcatttctatgcataactcttaaagacagtcgcaatatcagtacctctata
-cacatcggatcagactagatcataagataagtctcctctggatccttgtattctgttaag
-tacactacaaatttgtttagtgtctgggacaattacgataagggtcgcgactagaccaca
-gggcatatgacctccaccgctcctagcgagtctccaatctgcaagcactcatacgctagg
-ggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacccatttagatatg
-cctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatcaaattcccgaca
-ttcatattgtccaataagtatatctagcttattcggactcgctaaactaaattatggtat
-aaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggc
-cttatggcagcgtatacagctggtataacgaccatatacaactatgaacggactagctgt
-gaactaagcagattattggatccttgtgtataattttaagtttcgatctatatgctatag
-tatagaaaatgttccgatcgtacgcttcctttacagttaaacagtctatatcatgaagct
-tatccaaagctggacatttgatggcaatcttacttaattatgaaacttaattacctatta
-ttgaaagtatttatatgatcgaataagatttgctctataaacaggtcgtccattcacgac
-ctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatctatttcttatca
-ttcatgttatactgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcac
-gctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgat
-atcgatgtctatcccacgcgtcattttcaaattggttatctacggataactgtgcgatga
-actactataggtcaaaattatcttcaatctcattctagatcatataaagatgtccttcgc
-gattgatacgtctacagtgtgttggtgttacacagagggtagcgactacttacttactaa
-ctctctcttgatccgcaagcataagccaggttaaagtgctctatctttttctgtggatta
-taatagttataccgccttgcatctaggtgcccattaggtaatgccctagtgttttcataa
-atttactcctgccatctaacgttactttaatttcccagattcaataggtctctcatttga
-aaattgttatatgtcaacaaagaatataatagctgagtggaacaatacactgtgagggag
-taatacatactctaaattttctttacggtttgcgcctgcacagttttttttatctatgtg
-atccgcataaaaagtaatttcaacgttccattcaagttaagtcttggtgacactagcatt
-aggagagatcaccaagaccattatttatttagctagggtttaagtcggttagaaatatca
-gataatgaggtctttatccggccttacgcagtagaaattggaaatttcgtaaagcactga
-gttcaatggaagtatggccgaacccacataatgcacaaatcaagtcgatttcttccgtcc
-ttttagtctcctgggaactacgggttattcatagttaagctaaatcagttaacggaacta
-gacaaatgtataatagttcccaaatatatatctataaatcttatgcagttagggaatgca
-gatttgaatcatggcaatacgctagctcggaactcaactacaagtgttggatgtacgaat
-tcaaaggtattacatccttatgatgttcttttttggatacttttatgacgacttccacga
-agtgaaattatgttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgt
-tctgtttataattctcgtcataatataaatacaagcatatgaggccagtcatggagcttt
-catttggactaacatttccgtagagtcatatcacgcctgtaatctgatccgtctttttct
-attcgaagtgttatcagatacatgacgcccttgcgtgacattcatggctcctgacatcgg
-gtcttttaggctgaatctaatctaacccaatttgtttggattgtgggtcctccattttgt
-ctgttaatgcttattaagattaaaaatgtactacgtatttagacctaatgattgcgatac
-gctgtggaccattaatataagctgcgccaggggatttttccagatcatctggcctgtgta
-tatgttcaaatctaatagccgagagaaattactccgacggaaaataaaggcagataagcg
-tttcagagcaccatcgtggcgtttagtcaacctttagttcggaatttattaatatacaat
-ctcactctttggacgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaa
-gtataccagcatcatcaaagaacagttaaggaatacgactgctctataattgtccgagga
-gtaccttctcatctgccaatagtcgttgggttggaaaacaacgcattaatatgccacact
-tgtcaattagaagtttctataaaggggacgagtaactgatttgagacctagcacggcaga
-ggacgttcgtgtgacaacatctctttataagtttgagataaaatcgctaatctacaatga
-ttatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaagg
-ccattactatggtcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaa
-acactattgaatactgccgccgcattcgccagcaccaacataactgcacgtgcttttttc
-catgattggcattatgaaagatttgatctatgattcttaccagttgcaatattcaattta
-gcatgtgttcctaattattgtgttattatggtctatctcatcatgtaaatgaagatcatg
-acgtcaacacagattctagtcaggatcatcagttcctcggggaaatcgcacctaggaaca
-gccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaag
-cctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcgagtactgttggt
-tcatatttgctacatgattgtatgtaataacgatcccgccctttatcggttcgatccttt
-atggcgataagttatgaatcgtcagtatctttagatcaaaaactcaactagtacccagtt
-ccccggaggaacggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcaga
-ggaatcagtttcatccgatcccactcgatgattggtatagctatttgccgaaaagccaca
-acgtattcggtactatcttgtttgattcccctgtatcttaattcgcgacacttgatatct
-tttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaattatccagttgcgt
-ttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataa
-ttggagtttgcaggacgaatagctcacccgcctaagtgatccaaccctcatcaggataac
-tatcactgggcagtattatttttgatttcatatgccaccccctaggagactgtagtcatg
-tatctttcttacccaatctagcccgaaacaagaaagaatgtcgattccagtcacctttta
-ttagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaa
-agttgaaaacgacttgctctattcgattaccttcgcgatctcaatcgattacgctaaatt
-ttaatgcccgctgaaatatccaacatttaaaacaggattaattctctgatccatgaactt
-aggactcattgcacgtgacttatctttctctcttaattcatgctccaatacggtgggcta
-aaccacttttatcacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggca
-gcgaaacgggtcaatctgggtatcttctattgggacggtacatttcggttttatagacta
-tgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcac
-cttgggattgccatgtgtccggaggattacatacatctaagaaacattctaaactatgta
-tagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtactctgggtattag
-agtgtatattatcgacagcaccgaatcctcattttatagcttgacaatttatgacccgaa
-agaaccttttataagtctataagtatatctaacgcaattgcggcactgagtccactaact
-atctttgagcagtgttatacagtgagacgccatggaaggggtttatatattttactgtcg
-ttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagt
-cgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttac
-attccttgcttatttgcgataaatcgatacaaccccattaccagaaaaacccggagaatc
-aattactctgcagatcttatactaaaaaagagattacaacccctgttctatgtgtcccaa
-agtgagtaacgtggagcgttggggtaagagcggagcgattttaactttcgcttttccatt
-ttccagtattgtactttacgttatatttgagcggcacattcgtcaaaacatgatccatat
-ggactgaggtgtttaaatgttaatcaaataattgtattttcagctgactttaaaatctgc
-agccattggaggtggagattccaatagatgtaagcaggtgatatcatatgcaattcttgt
-gacttattaagataccagacacggcacaatcgcagtagcacgtaaacaataatgacaatc
-gacggttaaattccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaac
-gtttctctgagatgtataagttaccaaacactggagaattccgctaaactaaggacaatt
-tccgtcgtattaattgttgacaaatggttagtaatacattcgcagtggataatccgttgc
-atacctagcactgagtgtaaataaaaccaatcgactactggcatttcgggctaacgacta
-gatgttagcctatgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttc
-ttattcgttattagaagtcacctgtagagacagtagagatgacctaaatttggtttgtcc
-agtcccgaggtgatctaatgattaggttaacttagaacagtggtcaattggttaaagctg
-atttacgaacacttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtat
-tcggtcatctagacaaccccatcgctgggagtttggacagtgttatgattcgtaaatcca
-ccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaatttaggcttttt
-tacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgtaaacggtcacca
-gttgatatttgttctgctaggaagcgatgtacaaaataagcttaataagatttaggtccg
-accttaatttcggtccatagcacctctttctaagtgttttgcttaaataattgtattgtt
-attgattttctgcgagttgaacacggaaaataagtcaaaaaggacacttttaggttcata
-tgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgt
-ggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttagtccactaggtat
-ttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaatggcagaggggct
-cctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatcttttggttcttt
-ataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagcc
-agaatggaccaattacgtcattagctgttacgtctatacgaaatatagactgtggacgac
-ccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaag
-caggacaacacagtattgtactggtcaattggttcatagatctgactatgaatcttcgtt
-tttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttt
-tcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggccttaatgtaacatta
-actattccactgtaggtggatctaacaaggttggacatgtgctaccaataagataagaat
-ttcgtccgcaatacaatatctacttttgtagcctatcttggattaacaacaacttacgtt
-ggtatttcaccggacgtatcaaatgattctgattttaatgactgagagtaaacatcaacg
-aatcttatgtatctttaagccgctgcttgacaagtcacattactgttagaatgaacgctt
-cattactacaaaacctaccaccaactcccacattaatattatactagatgtttgaagttt
-atttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttag
-ggtattaattgtggtcggtgcatttccggccccatagcgctccgcggggagaaactatgg
-ccttcatgacagcccccccataacatctaggtaatggtcggataactataaacaaccctc
-tccagagaactgtgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttg
-cccatcttaaagactcttttcactattttcttgatgcctcattcttctaatattaggtga
-ttttttaatccgagaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacat
-attttaaagaaatgaaatactttttgactatccctcatgatctaaacttacgcggagcta
-tctttttgtataacatgtacagagaattaatccgatgcttcttccgattaaggacatagc
-gccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaagtgattaagtga
-tcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaatacttggagtctt
-gaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgc
-tatttcctgccttctcaattgtccgaggattgctgataacttaaaataaggttgagtttt
-taataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagtta
-tcaagaactacgggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatc
-gtacgaatggtatttgtacaactgctttcctttatcgattgctcgagaacattataaagt
-ctattactatggattaagactgtatacaagtgtttaagcggagcccgtgataatctataa
-ggttttggtacctttatctgttacttttgccttgaaacatacatacgtacacgggaatat
-ttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaa
-ctgaaagcgcccacttgcattataacccggtgcggaatctcttagtgactcgtcaggagt
-ttacgcctttgagacctctcgacaggacccattttgatctagtcgttataggtagagtgc
-ctttcctatcgcaccattaccttctagcaaacttagagtattcaatgaaatcatatcctg
-tttatactaaatgttataggctaatgacacagctgacactaagaggtctcttcgggttac
-ccgaatgagttgtttatacgatgttgacaactcgggggagtcatttcaatgaagactgag
-gactcttgatcagattaaaacgcttaatgactgataatttagattatgccgtgtattatt
-taagtgggcgaaccctcccctagaatgggtttcctgagaaaagtcttagaacacagtatt
-ctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtc
-aatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaagagctatgttctg
-acacgtccccaatattaggcaaaggctccaaaagaacagtcaattgattaactacgggct
-tggtttctccgtgaatccttgcgccgctataccacataaaaggatagcggtgataccaca
-agtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaa
-ttttgtccatcactactgccaagagttgactggaccagttggaaatgacatttgatatat
-taatagagctacatattgtaccactttactgtcacttacactaaccctagcgtgattact
-catacatatattcgtaaattctaagttatgatactagttttgtaaatttaatcggcgaag
-acacgttctcttgtacgagcttcaactaaatatttcactgtagccaaccactttaaccag
-aaggataccttaatgccgatataatattgtccaggaaacgttaatactttcacaagacaa
-agcttggaagaggtactttacgatcacctgatagatcgaccggaacgattctatataggt
-ttggtctgagaaatttgtagctaaaaccatgttccataggaactcctctgtaatgggcaa
-aatgcagatagcgttcaatcgttgcttaactatctatcacagcatcctaactcctcaaca
-gcttctttcctaaagacatcagcaggtaagttgacggcacccgataacccagagcacgat
-tggaatctaatactctgtatggatcattacgctaagtaaatataatgattttctgactca
-aagttacactgcgaattttatattaactggttctatttgttaaataccacaacctctcgt
-caacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaaccattacttctgg
-cgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcgccgatcttagga
-acctaatactgctcagtagttattgtttatttgggccatccccggattatgtcagccatg
-gaacactaaaagtcctaatctaacctatggacaaaaagctcacttttataaaattgctca
-ccttatgttgattgttatttgtccgaaatgtctataactcagtgtactatctattggaaa
-attatggccggagttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaat
-aattatcagctggaaaatcatctaatatatattatattgagatattacgacagacctaag
-tgctttcccgtcatgagcagatggactaacactcttggtaatccttctcgttttagttgg
-taatgtttagtctaagtaatatcccgactcttacttactcagagcggaaatgacttttta
-aactaacgtttaaaggcacttagtatgcgtcagggttatttttttaattacgtacccttg
-tgcagagagtttagctattcgatcctacttagtatgaaccatgagagtacaggttggtaa
-ttcacagagaaggtcgagaagattatttttgatgtttaccaatactatgaggcgtattca
-tcgaaataattttatggctgcgcacttcacatacgcaggaagaccactgcagcttgctag
-atctggatgtatcattgtacttctaagagcctgaaaggtaatacattcccagcgagcgta
-acagattgtatggggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcat
-ttttgatgtcataagttctgtcaactataaccctggaactttaatctgttgttcgtcgaa
-tcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccactacttcagtttta
-aattagaatcacaccctagggtattagataataattaaatgtcttaggaagagatatcaa
-aagatgcagacatcctcaagtgaataagtctccggtctttcacaaacacatggttaagcg
-atgtggttttgactagagacgttcgccaccatcgtaatatttctggttacctgcgaacgt
-gaaccaaatcttacttcatacattgcttaaacagtacaacttatctcttatcctatagag
-atctcaaaagtttgtatttttactggtttcaaattgagagaaaaactgcgttctccgatt
-tctatattattgtttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccga
-ctcagattcgtatcctatgttagaatgagtcatcaaactacggtcacgcgtacattacag
-agtaaactacacgaatgaaagagataagaagatgaaagagttaataggtctcctgttaat
-tatgagaaccctaactactacggattggcctactagtgggttggaacggatataaaattc
-gactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatcc
-acagtaatagttggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtg
-cagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgag
-caaggaattggattctgtgaacggaatatagtcgagtagatggaatttcctacactgcga
-aaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggcaattagtactcca
-ctaaatcaattggttataaacttttagaatatctttatataagttcactacttacgctgc
-gggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaataaacggcttgac
-tatagataccctaattctggcataaccctgtaacgtgtgaagcatgctttaatagacgac
-tagatcagcttatagaatggatatgactgccacattgaagagattaacattagcgggtat
-aatgttacgaacttgtttaacaaaatagctctaccacacacgcatagtataatataaagg
-tcctggagttcgctacgagcctggaattgcagttcccctaccctgagtaaacaagatcag
-tatggacctatcttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtga
-agttgattatcggctaacactcgctttaccaaggaacaaacaattgatggaacaggtaag
-cggctggattctatcctgaatacagcataataatatttgctttcaatatatagttatgac
-actcccaatatcactaactctttacaaatcggatatgaagagtgaattagagatggagcc
-gatcgttccttgtattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtc
-cttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcatagagactctaaa
-ttcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaactgtaacatttac
-gtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtt
-tcgcgatacataaaaggccccactttcatatggtcaaatatctatatcgtgctttggacg
-actcgataaactaaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaa
-tttagagtatatataacttccggacgtatggctgccttgaatcctcggatatcgtcctta
-tacaacgatgaacggtatagctcggaactatgcagattaggcgatccttgggttgaattt
-ttagtttccatagatatgagttagttttgatatggttaccatacgtccctgcattgaaac
-ttaatctgtatattgattgatccttagcaatagcggcacatttctgggcaatatgactta
-attaggttacggtttttactatgatggatacgttttatatgatagaataacagttgctat
-ttaaacaggtactacattcaactaatactgtttcactattgtgtccaacatagggaatat
-attgcctgaatagatgtattatcaggcatcttttacgctccaggtagaactaattaaaaa
-tgatccttagaaactttcaagcaacataagctaaaagttacgccaattataagccacatc
-ggtaggatcttcaggcattcccatatccttctctatcaatcccgtctgttgctaattggt
-tatctaagcatatcgcggcgagcatctacgataggtataaagttgctgctatctaattcg
-tcataatatatacatggaattacagattcatacgtcttcagtctcgtggtgtttctaaga
-gcggacccaagaattacgtaatatctctctcgtgttacccaagaagttgacacgtgattg
-tcagctatctttttctggcgatgttaatagttataaacaattgcatatagctgcaaatta
-gctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcac
-tgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgca
-gtgcaaaaataatatctcagggtgtaattatttctctaattggtctttacggttggacca
-ggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaagtgacattaaac
-ttaagtattgctgtcaagaccattacgacacttcaccaacacatttatgtattgtgctac
-gcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaa
-atgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaac
-atatcatgtcgttgtattacgtccttttactagcctgggaaataccggtgattcagagtg
-aacataaatctctgaaagctactagacaaagctagtatagttaaaatatatatttctttt
-aatattaggatctttgcgattgcacatttcaagcatcgcattaacctacctccgtactct
-tctacaacggttgcatgtacgatttctatgcgatgaaatacttatgttcttagtttgggg
-ttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgc
-gggcaccaaaacgatctcgattcttaggtttataattatagtcagaagataaatacatgc
-atatctggacactcttccacatgtcatgtcgactaactttgaactacagtcatatataga
-ctgttatctgatccgtatgtgtctattactactcttatctgagaaaggacccaatggagt
-cacagtaagcgatcatgtcatcggggctttttccctgattataagattacactattgctg
-tgcttggggcctcctactttttctatcttaatcattttgtacattaaaaagctaagaagt
-aggtacaacttatctttcccatacgagctggaccattaatttaacagccgcaaggcgagt
-tttaatgttaatctggaagggctttatgttctaagcttttagcactgagaaattaatccg
-taggaaattaatcccacataacccggtaagagaaccttacgccccgttactaataatgtt
-ctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctccttaatacaggccctg
-cgttatattcgaccgtacctataactagaccaccatcttaaatgtacagttatggttttc
-gacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgtactgggggtggtt
-atcaaacatttaatatgaatctatggtaaagtactagtttatagatagccgaacactaaa
-ggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggt
-gataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattgcccaatcgttct
-actcgtactctttatagcctaacgccttttcttggcgctaattagcctaatccaagaagg
-agtctaacaaaattacttaaccatactcttgtctattcggcccacgcatgcgcaagctca
-aaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattggatctatgagtc
-ttaacagtggaaatatgatttttagattgtgttcagatttattgtcttattttggtctat
-ctcatcagctatagctacataatgacgtcttaactgtttcgactaaccttcagatctgac
-taccccaaatacaacatagcaaaagaatgatgctaacgcttaactatcctttcacgatct
-taacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcgtggaatcaattt
-ttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttca
-agcactttagcggttccatccttgatggcgttaactgatgatgcgtaagtttatggtgat
-ctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttagg
-tctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcct
-atagctttttgcagttaagccactaagtaggcggttctatagggtttcattcaaatcgat
-cgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttcaggcccgccaca
-atggtttcaagtttcaacttccgtttattggctgtccctcaatagagtcgttctcagggc
-acgactctcgttcgttattcataagtccagtttgatccacgaatacagaacacgcatatc
-tgataataaaagcttaacgataactttcacgcgcatggtttatttttgatttattaggca
-accaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaag
-tatcgccattacagtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtatt
-ggcgcccttgatttaataataattacggctaaacgtattgatattttccaggaactgccc
-catctcatgagatgaccctaaattttattcacacctcatttttaattcttttatatcacg
-attatttatctgagcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaa
-tgcatgctaatatacggtgcgctaaacatattggttcaattcaatgtaagctacctcgga
-atttgcttgcactaagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaa
-gggacttgtccgttggagtcactatggagttacaagcattataaatctaaggaaatcgca
-gtatcagtccttaccccaaagatacttcgcattccctggggtacggaccatgaaatactt
-ctttcatacatgataaacgatggagactcggttaccaccctggtagttactccatcaatt
-ggagttaactaagatcgctattacaggctttattagccaatcatcacaagcctcttttta
-gagattcacaagttagcaaaccaaagttcctttgataagtctttaacgagatctatccca
-attccggctaggagtaaaatttatatatttgagatcggggttaaagtcacacgcaatgca
-aggggtttttatatggtaatgtccttccctaattaggtaattttcagacctccgagagag
-agtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatgacactacagatc
-atccctggatgagcatcgactttcattacttgattagttcagttaattcgtttcaaacca
-ttttcaacaaaatcccccagtagatatgtatatgcacatcttagactaaataacagtttt
-cataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagc
-gagggtaactggccctgttccattgtaatcgatgggacgggacgttatattgcagaccca
-aagtagtaataaattcagccatatggacggagggggggaattgttaagaatataattcga
-ttttcagctgaatgtaaaagctccagccattcctcctccacttgacattagttcgaagaa
-ggtctgagaattggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagt
-accaagtataatattatgacaatagaagcttaaattcacaacgtaacatatctgttagca
-tgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcag
-tagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaatggttagtaata
-atttcccagtggagtagaagtggcataacgtgcactctctgttaataatacctttagact
-actcccatttcgccagaacgtcttgatggtaccctatgggaaacactcacacatgcttat
-tgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggac
-tgatgacctaattttggtttctcaagtccagacgtgatattttgatgaccgtatctgaca
-tctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgat
-aatgctgtcatcactatcatgttttagctaagctacactaccccatcgctcgcacgtggc
-aaagtgtgaggattccgatatcatccatgtgtacgaattcctaatactcttgctcagggc
-acttagggttattgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtct
-tataatcaccgtaatcggtaaacagttgttatttgttctgataggtagacagctaataaa
-gatgctgttgaacagttacgtcccacctttattgccctacagtgaaactagttcttactc
-tgttgctgtaatatgtctagggttattgatttgctgccacttcaaaacggaaattaagtc
-attaacgaaaatggttccttcataggtaaagatcaatccccaattgaagccagaaatttt
-gagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaa
-aaaaatgttgagtccactagcttgtttattctggctcaaggtacgtggaacacgtagtat
-tttgatactaatgccagacccgctacgatccctgtactgtgagcagagccgatcctcaga
-aatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgtt
-gcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgt
-taacaaagatactctgggcaacacacatacttctctcatgttgtttcttcggacctttca
-taacctttcctggcacatggttagctgcacatcacaggattgtaagggtctagtggttca
-gtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcat
-ccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttaga
-cgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatctatatacgttgcac
-agcggatacaaataagataagaatttactaacatttaaattttcttattgtcgagcatag
-attggaggaaaaacttatttacttggtatttaaacggaagtttctaatgtttatgattgg
-atgcacggacagtttactgcttactttcttaggtttcttgaacaacaggatgcactagta
-acatgtctcgttcatgcttccattaagttcttcttaaacttacacaaactacctaattta
-gagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgtta
-ccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacatt
-cacatcccacccctgaatatatggactgaatcacacacaccaaatttcatctaccttatc
-gtagcataactattaacaaacatatacagacttcgcggtaaataaaatatattagtacac
-aaccgtatactggttgaactattgcccagctttaagacgcttttaactaggtgcttgatc
-aagaagtattattatatgacggcagtgtgtaatacctgaatagatatagacgttagattg
-tctgaaaacacgccgtagagacatttttgttagatatgtatttctttttgacgagccagc
-atcttagtatctgaagacgagctatatgtttgtagaaaatcgactgacattgtatacgag
-gcggcgtaagattaaccaaattccccagaattagtaatggcgccttatcgatttactaac
-gatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaa
-ggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacat
-agcgtcaccgatactacgttttgctatgtaatccattctaatgggtaagaggattcctct
-tatagtaaaatatgcttgactttttaagaaccattgggagtggttggcaaaataatagtg
-ggtgtctttctcagtgtatagttttctacaactacccctattaggttacaagtaatctgg
-ctttcttgccacttggcgatgatagttagattcgtatttctacaacgcagttactgtatc
-catggcgcgagataattagatacgatttgaatttggatgtagactcgttactactgttgt
-agaccagcacgtgagtatctagatgggtttgctaccttgttagcggacttttgccgggaa
-aaagacatacgtacaaccgtatattttactataagcagtattggccaccctcgtattgcg
-gcagggtgtgctcacctggttaaaatgaaagagaaaaattccattttaaaacccggagga
-atctattactgacgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttc
-atattctagttattccgagagtcactttcctatccaaacatgaactgatagcataatgac
-aggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgt
-cacgaactcggagcttacccttacaactatgtgttctgtttaccaggtgctaatatcccg
-gcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcata
-ttttacagtagccagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctg
-acataagtattacatatcacttgtctgattacacagcaaaatcgctaaccttactttgcg
-catgtagctattggaactttgggctagtgtctatcccattaagtttaacagtagactagt
-ccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttggatcaaaaacta
-ctcgatattcatgatctacgggcttcctttctccgggtatcattgcgccgagattaaaaa
-taaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacga
-atagaccatccaatttgaattttattgggtccagcacttcgccatagtgttgaatggtaa
-agttcgaaaggaaatttgttatattaattctgctacattttcgaccacttgtatctcaag
-gacaatatcccttgaggcttttagcagaaagagatgccgtaattctaagggatgataata
-ggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaaactatatattta
-aatctagccaaacaagttaacaacaaccataaagttatgaccttattatattggcaagct
-taacgttttaattgctctagtaatagagtggtagaggtaagggaccatcacctgattctt
-cctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataaaacattcgtcct
-tagcaacgaatatcgaatggcaattagccacattgagttaaatagttgaggatatttctt
-gcacagaatcagatctaatctaatgattcgttactaaacacttcaccaggtatcgtgaag
-gctcaagattacccagagaacctttgcaatataagaatatgtatgcagcattaccctaag
-taattatattctttttctgactcaaagtgacaagccctagtgtatattaaatcggtatat
-ttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgt
-acttataccatacatgaattctggccaagtaaaaaatagattgcgcaaaattcgtacctt
-aagtctctcgccaagatattaggatcctattactcatatcgtgtttttctttattgccgc
-catccccggagtatctcacccatccttctcttaaaggcctaatattacctatgcaaataa
-acatatattgttgaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagt
-aatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaatattctgggctag
-cgtgagatagtttcttgtcctaatatttttcagatcgaatagcttctatttttgtgttta
-ttgacatatgtcgaaactccttactcagtgaaagtcatgaccagatccacgaacaatctt
-cggaatcagtctcgttttacggcggaatcttgagtctaacttatatcccgtcgcttactt
-tctaacaccccttatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgt
-tattttttgaagtaagttacattgggcagactcttgacattttcgatacgactttctttc
-atccatcacaggactcgttcgtattgatatcagaagctcgtgatgattagttgtcttctt
-taccaatactttgaggcctattctgcgaaatttttgttgccctgcgaacttcacatacca
-aggaacacctcgcaacatgccttcatatccatcgttcattgtaattcttacacaatgaat
-cctaagtaattacatccctgcgtaaaagatggtaggggcactgaggatatattaccaagc
-atttagttatgagtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcg
-taatgttatctcgggttccgcgaataaacgagatagattcattatatatggccctaagca
-aaaacctcctcgtattctgttggtaattagaatcacacaatacgggttgagatattaatt
-atttgtagtacgaagagatataaaaagatgaacaattactcaagtcaagatgtatacggg
-atttataataaaaatcgggtagagatctgctttgcaattcagacgtgccactaaatcgta
-atatgtcgcgttacatcagaaagggtaactattattaattaataaagggcttaatcacta
-catattagatcttatccgatagtcttatctattcgttgtatttttaagcggttctaattc
-agtcattatatcagtgctccgagttctttattattgttttaaggatgacaaaatgcctct
-tgttataacgctgggagaagcagactaagagtcggagcagttggtagaatgaggctgcaa
-aagacggtctcgacgaatggacagactttactaaaccaatgaaagacagaagtagagcaa
-agtctgaagtggtatcagcttaattatgacaacccttaatacttccctttcgccgaatac
-tggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgctcataaataggt
-agactactcgcaatccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcg
-tgtttatcaaccgtccccactcgcctggggagacatgagaccacccccgtggggattatt
-agtccgcagtaatcgactcttgacaatccttttcgattatgtcatagcaatttacgacag
-ttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaacccacatgaatg
-tgattcttggcaatttctaatccactaaagcttttccgttgaatctggttgtagatattt
-atataagttcactaattaagatcacggtagtatattgatagtgatgtctttgcaagaggt
-tggccgaggaatttacggattctctattgatacaatttgtctggcttataactcttaagg
-ctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttggactccctcttt
-catgtcagtaacatttcagccgttattgttacgatatgcttgaacaatattgatctacca
-cacacccatagtatattttataggtcatgctgttacctacgagcatggtattccacttcc
-cattcaatgagtattcaacatcactagcctcagagatgatgacccacctctaataacgtc
-acgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcat
-ataacatttgagggtaaagctaagcggatgctttatataatcaatactcaataataagat
-ttgattgcattttagagttatgacacgacatagttcactaacgagttactattcccagat
-ctagactgaagtactgatcgagacgatccttacgtcgatgatcgttagttatcgacttag
-gtcgggtctctagcggtattggtacttaaccggacactatactaataacccatgatcaaa
-gcataacagaatacagacgataatttcgccaacatatatgtacagaccccaagcatgaga
-agctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaa
-ctggttcccgggagtcctggagtttcgacttacataaatggaaacaatgtattttgctaa
-tttatctatagcgtcatttggaccaatacagaatattatgttgcctagtaatccactata
-acccgcaagtgctgatagaaaatttttagacgatttataaatgccccaagtatccctccc
-gtgaatcctccgttatactaattagtattcgttcatacgtataccgcgcatatatgaaca
-tttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggt
-taacagacgtacatgaagggaaactttatatctatagtgatgcttccgtagaaataccgc
-cactggtctgccaatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttg
-tttgcagagtataacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcac
-tattggctacaaaatagggaagagtttcaatcatgagagggagtatatggatgctttgta
-gctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagatacataagcgataa
-gttacgacaattataagcaacatccctaccttcgtaacgatttcactgttactgcgcttg
-aaatacactatggggctattggcggagagaagcagatcgcgccgagcatatacgagacct
-ataatgttgatgatagagaaggcgtctgaattgatacatcgaagtacactttctttcgta
-gtatctctcgtcctctttctatctccggacacaagaattaagttatatatatagagtctt
-accaatcatgttgaatcctgattctcagagttctttggcgggccttgtgatgactgagaa
-acaatgcaatattgctccaaatttcctaagcaaattctcggttatgttatgttatcagca
-aagcgttacgttatgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtg
-ggaataattcttttgaagacagcactccttaaataatatcgctccgtgtttgtatttatc
-gaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcggataacaattaat
-acgatgttcatagtgacagtatactgatcgagtcctctaaagtcaattacctcacttaac
-aatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccga
-gtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctctctgaattccttc
-gtgccaacttaaaacattatcaaaatttcttctacttggattaactacttttacgagcat
-ggcaaattcccctgtggaagacggttcattattatcggaaaccttatagaaattgcgtgt
-tgactgaaattagatttttattgtaagagttgcatctttgcgattcctctggtctagctt
-ccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgt
-aataattaggttcggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgc
-tgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaat
-gagactcagtagttaaataaatccatatctgcaatcgattccacaggtattgtccactat
-ctttgaactactctaagagatacaagcttagctgagaccgaggtgtatatgactacgctg
-atatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaataccggctgtttccag
-ctttataagattaaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagt
-tggttcattaattagctaagtacgaggtacaacttatctgtcccagaacagctccacaag
-tttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattaga
-gtttacaactcagtattttatcagtacgttttgtttccaacattacccggtatgacaaaa
-tgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcc
-tacacatactgaattcaggcaatgcgttttattcgaaaggtcatataactagaaaacatg
-atgaattcttatcggatccttttactagcatagtgttggcgaacacctcgtaatgctcag
-cggcaaattggactgcgggtccttatcatacattttttttcaatataggcgattggtcta
-ggttagtgattccccaacacttaaggtttgctgacattcataccctcagcaacttcctct
-caaaaattagagtgagttggtggtcttataagaccgttgattatttgaggtggtcaaatg
-atggtgcgatgcacaaatcgttataatcgtactctgtagacaataacccattgtagtgcc
-gattttgtgcataatacaagaaggaggatataaaaatgacttttcaataatattggctat
-tagcaacaagaaggagaatcctcattaagttagcaaccgcagggggtactgcagtccaag
-gaggtttcattggagagagcagtatgaaaacggcaattatgattgtgagattcgctgaag
-attgtgtctctgattttcctagatagaataagctatagctacttaatcaactcttaactg
-tggagactatcctgatgatctgaataccccatttacaaaattccatatcaatgaggctaa
-cgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatacaagacaaaacac
-tgcttccattacgggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgata
-aagctgtcttgcgtttatacttaaacaaattttgacctgacataatggagcgacttatcg
-gatgttgccgatctttagggtcatctattaagcttatacgaaaaagggacaagcacgtta
-cgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaactccaatatctgta
-agaacagaaaaatacaggagtccttttcatttttcaagttaacaatataagtaggagctt
-agagaggcttgcatgaaaatcgttaggaattacagaataggcagagagtggggcgtgtag
-actacattcttcaggccccacaatatgggttataggttaaactgcactttttgcgatctc
-ccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcat
-ccaactattcagataaacaagatcgcagaattaaagcttaaccatatcttgatagcccat
-cgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaa
-aatttagacaaacataattcattctttcgactggacacgctaaggtttggacaaactttg
-tatctatatctggaggcctgtattccagcccttcttttaataagatttacggcttaaact
-atggatatttgccaggaaatgacactgctattgacaggaacataattttgattcaaacct
-cattgttaattattttatatctcctgtttttatatcagaatgcttctgtcctagaaggca
-tactcaaggtgagggctcgaggaatgaatcataatagaccggcccctattaatattggtt
-caattctttcttacataacgcggaatttgattgcacgaacaccgggaacacataaccgta
-tagcgcccgttatgctagtgcctagcgactgggaccgtggagtctatatcgtctttctac
-cattattaatctaaggatataccactttaagtcctttcaactaacataaggcgcattcca
-tgcgctaaggaccttgaatttattatttcttacatgataaaagatcgagtcgacgggaac
-aaaaggctacgtactcaataaagtgcagtttactaagagccctttttctggcttgtggag
-actatcataacatgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtg
-tagtattgaacgagatctttccaattgccccatagcaggaatagttatatattgcagatc
-gcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattac
-ggtttttgatcaaagcacagtgagagttgagcaaattacagttatacgacttaattcagt
-ctccataaattgaaacgacacttcttaacgggaggaccagacacgttcattaagtgagga
-gtgcactttttgactttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaa
-cagatttgaagttatttctgttttaatacactgggagttctgtcaatatcgcaggaaccg
-cctgacgtcccctatcacacctcagagggtaaagggacaggggaaagggtaatcgagggg
-tagggaacgtagttggcacacccaatggacgaataaatgctgccatatccacggagggcg
-ggattgcggttgattttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcc
-tccactggaaattactgcgtacatccgctgagaattgcaatggagtgtctcggtttttct
-ttaaacaaaaccaaattgacaacttcatagtataatttttgcacattacaagcgttaatt
-aacaaacttactttgctgttagctgcctatatttgtccgacaatataactggatatctct
-gcgagaactgtaaattaacggcacttggaacataatagttcctattggtaacgacgttgt
-aggcggcaattatccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaat
-ctctcgtaagtataactttagaagactccaaggtacccagaacctcttcagcggacacga
-tcgctatcaatcaataaggattattcactgaaaccgctcatatctggaggtggacgtttt
-tcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctg
-ttattttcatgaccggataggacatctcgcggaaattcgggtaacagctgggtagatata
-ggacctcccctacgtattaatgataagcctgtcataactagcttggtttaccgaagagac
-aataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaaca
-tgtactattactctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgat
-gttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtct
-gagcattcgtacactgcgtattaagatcaggttgaacaggttcctaacaaattttgtgac
-ctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctg
-acacttctaaaaccaaattaaggctttatccaatatgggtccttaagtgctaaacatcat
-tcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcgccaaattgacac
-atcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtgtgtattctggct
-ctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgt
-aggtcacatcagcagatcctaagtaattccgttttattgtcctgagggagtaggatcgac
-gaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaa
-tgaactattgtcatctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcg
-atggttctttatgcggacctgtcatatcattgactggcacttgcttacatccaaataaca
-cgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatt
-tcgccctctacatgataaatgaataagtaagaagatgatctttttgtggcggtaccttaa
-gcgtactcctgtcgacgagttactactaaaggaatgtagggttctggatctatgaaaagc
-gacctccatatatatacgggcctaagcggagtaaaataagtgatcaatggactaacattg
-aaatgttagtattgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaac
-gaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttactttagttggttg
-cgggaacaacaggaggctatactaactggtagcgttcttgcttccattatgttattatta
-taattaaaaataagacatatggtagagttgtagtcagggtggatcgggttgtctataacg
-ttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcg
-cctacctcatgtgcaccacacattcacagcacacccctcattataggcaaggaagcaaac
-aaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaatagaaacacttagc
-ggtaatgaaaagataggactaaaattcactagtatcctggaacgaggcaacagagttatc
-tagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacc
-tctattgatatacaagtgactttctcggtaataacgcacttcacaatgtgttgtttcttt
-tctatgtattttgcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgt
-aaatcgtatcacatggtataactgcaggaggaacattatccaaattcaccacaattacta
-atccacccttttacttttactaaagatatattaattctcatgttgtctgaattgtataac
-ccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaaca
-cacgacttccttccgtctattcagacactcaacgagactaacttttcctaggtaatcaat
-gatattgggtaactcgtggcatcttatagttattgatccggctcttttgtagatcctgtg
-cgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtttattctacgtac
-ccgatttggttactactaagcggcctttcttcaaacttgcagttgtgacttacattccta
-tttcttcaaagcagggaagggttacagggagagacttattgagatacgattggaatttcc
-atgtacaatcgttaatacgcttgtagaccagcaactcagtatagagatccgtttcctaaa
-gggtgagcggtaggggcaaggcaataagaaattactaaaaccctagttgttaatataaga
-acgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaa
-taggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttct
-caaagatcctaacctaaaaggggcttattctactttttccgacactcaatggacgagaca
-aacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatcgttattattaat
-cggtttccattatctatatgcggtatagatctccgagaggaccctgtaaactagctctgc
-ggtttaactggtgctaatagaccgccactatgttattgcttctagctcctagcgtcttat
-catgttatacattaatgtcgcatattggacagtagccaggcttggatggatcgccgacaa
-aaagaaaagactttccctgtaaggacttaactattacatataacttggatcattaatctg
-caaattagagtaacggtctttcaccagcttcatattccaacgtggcgctagtcgatatcc
-catgaagtttaaaactagaattggcagtctcacttcacagtgcgtatctatacgacaaaa
-gtggtcgatttgcataaatatcttatcgatattcaggttattaccgattccttgctaacg
-ctagaagtcacaccagagtaataataattccagacacctgtgaaataatcggtcactacg
-gatagactagtaacgataatacgtatagtccataaaagttgaattttaggggctaaagat
-attagcaatactggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctac
-attttcgaccaattgtatcgataggaatagttacagtcacgcttgtagatgtaagagatg
-acgttattcttagggttcttaagtcggggggtaatttaagaccactagtaaaggtagagg
-cgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagtt
-agcaactgattttagtggcaaccttaacggttgaattgatctactaatacaggcctacac
-cgaagggtacagataatgattcttactaccctaacatgatagagtcctgtcctatctcat
-aggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattca
-cttatagacttcaggttatttcgtgctaacattaagatagaatataatcagtcgttaaga
-aactattatccagctttcgtcaaccataaagattaaaaactgaaacttggcaagatatga
-atagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagca
-cttgtgtttagtaaagcgggagagtgcggtaattaatattaatatactattaagctacac
-agcaaaggctgcaataatgttagtaagtagaacataaaggtattctccacaagtaataaa
-tagtgtgagctaattgactaacttaactctcgcgacaagtgatgtggataagatgactca
-tatcgtctttttctgtagtgccgacatcccacctggatcgaacaattccttctagttatc
-gactttgattacctatcctattaaacagatagggttgtaaagtcagaaaatgatcggctt
-gcgttggtctaccatagctagagttagaacgcgtagatagaggccttttgttgccaacgt
-gggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatc
-cattagattagatgtttgtgttttgggtctgatgtcctaactactttctcagtgaaacta
-atgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtcta
-taacgtatataaagtcgctgaatttagaacacaccttatctatgttgtaaagttacttta
-ttccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttg
-tcagtgtagataagaatttctttcatacttcactggaatccggcgtatggatatctctac
-cgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttg
-gtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtg
-aagtctaattatttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgc
-gccaatgaggatagaggacattgcatgtacgtaggactattctccaaggggtcttctatt
-ttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactttataccagatac
-tttcattagatatgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaa
-aaaagacccgttgtgatatgatgtttttctagttcgttctcatatatatagatcaacaat
-gaataatctcatgatctataaccgatgtatatttatattccggttgactgctccggtgca
-attcactacggacactaatgactaatatggcgcctttcatcagaaacgctaaatatgatt
-aatgaattaagggagtattatctaattattagagagtagcagttagtctgatattttcgg
-tgtatgtgttagccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtg
-ttgtatgcttcactttatgactctggttatatccctcggagaacaagaataagagtacga
-gaagttcggtcattgaggatgaaatagaaccgctagacgaatggactcacgtttataaaa
-ctatgtatcacagtactacagctaactctgaagtccgagaagcttttgtaggacaaaacg
-ttataagtacctttcgcagaatacggccgtgcatacctgttataaggcgtagtagggaca
-ccatgctatccctcatatagagctacactaataccattacatggtgactatcgtttacgg
-ccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactg
-cagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctcaatccttttcca
-ttatggcatagcaagtgacgactcgtcagccatgggaataatagcactaatccgattact
-tatgaattagaacccacatgaatgtgattctgcgaattgtctaagaatctaatgattttc
-cggtgaatatggttgttgttatttattgaacttatattattaacatcacccttcgttagt
-gatagtcagctatttccaagaggttccccgagcatttttaccattctctagtcatacaag
-ttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaattctgcagatgt
-tagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtttttcgttacata
-tgctggtaaaatattcatagtaataactacaatacttgatttgttacgtaatgctcgtac
-ataacacaatcgtattccacggaacagtaaagctctattattctgatcgagcctaagaga
-ggatcacactacgctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgac
-cagttatagacagtgtaattccatattacatgtcaggcttaagctaacccgagcctttat
-ataagctataatcaagaattagattggagtgcattttagacttatctatcgaaatagtga
-tagtaagagtttatatgacctgatctagactgatgttctcttccacaacagccttaaggc
-gtggagcctttcttatactattaggtcgcgtcgagagccctattcgtaatgttaacgaca
-ctagactaatatacaatgagctaagaataacacaagtcacaagataatttacaaatcata
-tatctacagtccacaaccatcactagcgattgcaaagcgttattggtactaccgctctaa
-atcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgtgagactgaaaga
-aatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttag
-tttggtcaagactatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattg
-ataaatgccccaacgttccatcacgtctataagccgtgttactaatgtgtattagtgcat
-acctattcagaccatagttcaactgttggactgaaggcccgtcttggggttcgtgaatga
-gagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatcggtttatctaga
-gtcatgcttaaggtgaatttcagccaatgggctcccattgagctagtatggtgctttacc
-tttgtaagtggtggctttccttggtgtgctgactttaacacggcagagtgattatccgaa
-gaatggataataagacgctggcaatattggctaataaagtccgatgagtttcaatcatga
-ctgcgaggagatccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcat
-tcttgatacataaagatccgatatcggtccactttgtttaccaaaagccctaccttcgta
-acgatggaaatgtgaatgagagtgaaatacacgatggggatattgccggtgagtacaagt
-tagaccacacattagaactgacctatattcgtcatcatagagatggagtatgaattgatt
-ctgcgaagtacactggctttacgagtatctagacgccgcggtatatctcccgtcaatact
-atgaaggtatatatatagaggctgaaaattcatgttcaatcctctttctaagagtgagtg
-ggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagt
-atacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaatctcgattcacc
-gagagaagtgattttggcggtgtgcgattaattcttttgatgacagatctcattatttta
-tatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggg
-gggagagtgcgctgaacattttatacgatgtgattactcaaaggataaggttcgaggcct
-ctatactcatggaactatcttataattataatggatcgtggctcattccacctatccaaa
-cttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttggga
-cgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaaattgattctact
-gcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttata
-gcaaacattattcaatttcagtcttgactgaaattagtttgttagtgttagaggtccata
-tgtcacatgcatatggtctagatgccattgtacagtaataccttagattagtattagcgg
-catgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgca
-aataggaatacttacaatttttgatgacttgttagcatatcgctatcacccataaaaaac
-ctgatacttgatgagcgggtgattgagactatgtactgatataattcaatagctccaata
-gatgaaacagctatgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctg
-aacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacgaaatcgatccca
-gaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacg
-aagaatgggtagagagtttgaaggtgcttctggattttcctaagtacgtggtaaaaattt
-gatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgggtgaatctgatt
-agccaacccagtgatctgatttcagttgtcaaatctcttttttataactaccttttgttt
-ccataatttaaccggatctcataatgaacaaacgggtagaataatggtagcacatagcga
-gcttgtctattcagaaatatggcctactcagaatgtattctccaaatcagtgttatgcga
-aacgtaattttacgtgtaataatgatgatttcttatcggttccttgtactacaatactct
-tgcccaacaaatactaagcataacagcaaaattcgaatccccctccttttaataaatggt
-ttttcaatatagccgattcgtattcgttagtctttcaccaactattaacctggcatctaa
-ttaataaaatcaccaaaggactctataatatgacagtcacttcggcctcttttaagacag
-ttgattattgcaggtccgcaattgatggtgacatgcacaattagttagaatccgactatg
-gagacaattaacaattgtagtgcccatttggtccagttgacttcaaccacgagttataaa
-ggtattttaatttatagtcgatagtaccaacaacaagcacaatcataattatgttagaaa
-acccagggggtaatgctctaaatccagctttaaggccagagtgcactatgaaatcgccat
-tgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagat
-accttatgaagcaacgattatatctggactagatcatgatgatcggaataaaacattgaa
-ataagtccttatcaaggagcataaacattttatttaatttatacttcgtaaataaattca
-gaattttttttcaagacattaatctgagtaaatgacggctagaaagggttcctactcgaa
-tcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcac
-cggaaagaaggctgccacttttagcttcttgacgatctttagcgtcatatttttagatta
-gtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaag
-agcaggacaactccttgatcgggaagaactgaaatagacagctgtcattttcattggtca
-acttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaact
-atagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcg
-ttaaaaggaacgggttgccagctacagatatactctaggtatatcccaaacaagagacgt
-cctttggctgttgtaatcggtcataatacttgtcacataaacaagatcgctgaattaaac
-attaaacagttagtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatc
-tatcgtctatcacagagcgacgtaaatttagacaaacattattatttcttgacaatggaa
-tcgataagcgttcctctaacttggtatatatatctcgaccccgggattccagccattctt
-gtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaaatgatattgact
-gcaacagattttggatgcaaaaatatttgtgaattattggttatatactggttgtatagc
-acaatcattaggtcctagaaggcatactcaacctcagcgagagagctagcatgcataatt
-gtaccgcccatattaatattcctgaaatgatttcttacattacgcccaatttcagtcatc
-gaacacccccatcaatttacccgatagagaacgtgatcatacgcaataccctatgcgaac
-gtccactctatagcgtctgtatacaatgattattcgttccatttacaacgttaagtaatt
-taaacttacataaggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgc
-agttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaa
-gagacctttgtatccattgtggagaatatcataaattcaagatggggtgtcatgctattc
-ggtcctaaacattcttaatggctgttctattgttagtctgatttaaaatggaaccatagc
-acgaatagttagatagggctcatacccctgtaacgatctacaaatccttccccgggtgtg
-tgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcacacgtcagattat
-tacactgatacgaattatttcagtcgacagtaattgaatagaaacttattaacgccagca
-cctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttt
-taaaaatcttgatttctatatcaaatgatgtgtagttttttctctgttattaaaatccca
-gtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatcacacgcgttagcg
-aaagcggaatggctaatacagccctacgcaacgtagtgggatcaacatatggacgaattt
-atgctcaatgagccaacctcccccgcattgcggttcattttaaggcctgggtaacatcta
-tcgtttagataatcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagt
-ccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcgtaatacgataat
-tgttgctattgactacaggttatgaaaaaacttactttgcgggtacatgcatatttttgt
-accacattattacgcgatatctctcagtgtactctaaattaaaccctcttcgaacatttt
-agttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtagaatggacaactcc
-agttcaactgcatgtaactcatagctcgcgttagtataaattgactagtagccatgggac
-aaagtaactagtcagcggaaaagatccctttaaagatatatgcaggttgcaagcataaag
-ctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaatttt
-gggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaatatcgcccattt
-tcccgtataagctccgtacttatacgaactacacgaccttttaagcattagccgctcata
-tcgtgattcgtgtacagatgagtctattaaaattacagacatactccatatctcgctcct
-tgaactttgaataatgcgctaacttgtactatgaataggcagaacccaactttcccgttt
-gcgtcaagcggggaaacgatacatgttgtcagatttatgattatctagttttagatcacg
-tttaccgataatcggctgtggtctgagcagtcctacactgagtatttacttcagcttcat
-atcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatctttt
-ttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacgatttttactatag
-cggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtggctcttgtccttg
-aagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaattatttggtgac
-taatagtccgtgggtttgagccatatacctaacgccataaactacgtggtgctttagatg
-caatctaaacagaacagaaagcgtagcgctcatcagcacagactaactttttcagtttga
-gtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgat
-tgggcggctcaatcttgcctaatttctactattgtcagctgtacgactgtactaagtgta
-tagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagc
-gcacttccgttcatcaaattaaatcctggcttacccgattctccggaagtctgacctaga
-gattgacgacggccgcgtattattgagacctcttcaggattaatcaataacgaagtagtt
-gatctgtttggcgacgtaccttaagccgactccgctacacgagtttctactaaaccaatg
-tagccttatgcttagatgaataccgtcctaattagatattccggcataacagcagtaaat
-tatctgttcaatggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaa
-tattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctc
-gttaatcattaatttaggtgcgtgagggttaaacaccagcatattctatatgctagacgt
-cttccttaaaggatcgtagtattataattaataataagaaatatggttgacgtctagtca
-gcgggcatacgctgctctatatactggcattattcaaaacttgacggtaaaaaaacgaat
-tttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacac
-ctctttattgccaagcatgcaataaaaaaaatgttaatagtacgtttacgacattttatt
-ttataataaagagaaactattacacctattgatatgataggacgtaaattaacgagtagc
-ctgcatagaggcaaatgaggtttctacatggtatagacctgatgctgaaacatcgatgag
-ttttggtcccctcgctcgttgaaatctagtcatttactactgtctttcgagctattatac
-cacttcactatgtggtgtttctttgctatgtatggggctagtcaaacatgatgactatag
-ctacaactcagagagcgggcgtgttaagagtatctcatgctagaactgcacgacgaactt
-gatacaaagtaacaacatttacgattccacaaggtgactttgaagaaacatagtttaatt
-ctctgcttcgatcatttctataaaccggtaccatcgcagcggatagatgcataacatttc
-tactactccaggcatcttaaaacacacgtagtacttcactagattaagacacgataagtg
-tataacttggcagtgggaagcaaggagattggcgaactcctggcatctgttacgttttgt
-tcaggctcggttgttgataatgtccgactcctgccatattgaagactcgctcgagggaga
-tcgggattcgttgattataagtacacgtgttccgtaatactatgaggcagtgattcaaaa
-tggcacttctgacttacatgactaggtattattaccacggaagcgttaaaggcacactct
-tatggacttaagattgcaagtgccttcttctagcctgaattcgcgggttcaacacaaact
-ctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtact
-aaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcg
-aaaatcgggttaagcaaacacaaataggaattgtgataaaccccaccttgagaggtcgca
-agaccaacctcgggaacaacggctctaagagaataacctaaatccggatgagtagactgt
-gtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgca
-ttcaattgaatcgtttgtattatgagctgtacagtagctatatcagctatagttatccca
-gaggaacaggtaaactagctctgagcgtgaaatccggatattagaacccctagatgggat
-tgattctagctaatacaggcttatctggttttacagttatctagatgattggtaaggtga
-aacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagctattttctaggt
-attataaagtcgagcattaatatcaatttgacagtaaaggtctttcaccagcttcatatg
-ccatagggcccatactcgatttaaattgaacggtttaacgagtattggaactctcactta
-taactgagtagctatacgaaaaatctggtccatttccagaaatttattatcgatttgctg
-cttagtacccaggaagtgataacccttgaaggcacaacactgtaataagttttcctgtca
-catctgtaatattcggtcactacgcattcacgactaaagataattactatactaattaaa
-agttcaatgttagggccgaatcatagtagaaattctcgtctagcctaatcggacttacct
-atgggctgtgaggatttatcagtatgtggacaaaaatgctagagataggtatagttaaag
-tcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgg
-gatgacaactactatacgtagagccgtactcaggattagatagtgtgaaagagtcaaata
-aaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtag
-ggatattctaatacaggccttcaccgaaccctaatgataatctgtcttaataacattaaa
-tgattgtctccgctacgagctcttagggcctcattttaaatgactaatgtccaaagaaga
-gactttcccaatttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaag
-atagaagattatcaggagggaagtttctattatcaaccgttacgcaaccataaactttta
-aatctcataatggcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgct
-ggggagctagatatcggtataccacttcggttgtggtaagcccgagtgggccgttagtaa
-tattaatagacgattatccgacaatgcattcgctgaaataatcttacttaggagaaatta
-atgctatgagccaaaactatttatgtctgtcacattattgactaaagtatctatcgacaa
-aactgatgtccataagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcg
-agcgaaaaatgaattatagttatccaatttgagtaaattgcctattatacagataggctt
-gtttagtcagataaggttccgcttgaggtgctctaacttagcgagagttagaaagcctag
-tgagaggcattttggtgccaaactccggctcgcatgagtaggccagagagtcactttctt
-tcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgtggctatgtgcta
-ctatataagttagaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgag
-acggggtacgccgttgaggctcgagatagtagataaactagaggaatgtagataaaacat
-tagctagggggtttagttactggattacataggaagtgcaccatcacggtgtgggggttc
-gtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcc
-tatacggactttgcatatctctaccgactcatctggtcgtctatgcgggtaattgtattg
-ctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaatccttataatag
-cataagcaattattagactgcgtgaagtcttagtagttctcaagctttacgttgtatgta
-aataactcacgtaatcagccgtccccaaatcaccattgaggtcattgaatgtacggagca
-ctattatcaatgcggtatgcgattttctgagcgattattgttaaagacttagcgttgagc
-cccggaacacttgattacagattctttaaggagttatccaaatatcattttaaataatag
-tagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtac
-ttctctgatatatacttcaactatgaagattctattcatcgataacccaggtatatttat
-atgcccgttcactgcgcagggcaaattatctacggacaataatgacgtagttggacccgg
-taagaactaacgcttaatatgattaaggatgtatgccagtattatcttattatgtcagag
-tagaagtttctctgagattttccgtcgttgtggtacaccggatttggctctctttttaga
-actgagaactcggagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccg
-ccctcatcaactataacaggacgacaagttccgtcttgctccatcatatactaccgatac
-accaatcgtatcaagtttagtatacttgctttctctcttctacagcttactcgcttgtcc
-gagaagcggttggtgctcataaagttagtagtaaatgtacaactagtagccagtccttac
-ctgtttttacgactactacggacaccatgagatacagaagttagtgctacaattatacca
-ttacatgctcaatatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatac
-gtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttgactaacatcttt
-tacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcgg
-aagaataccacttttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaa
-ttgtagtagaatatattcatttgaccgtcattagccttcttcttaggttgtgtacggata
-gtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttt
-tttaccaggctagagtcagaaaagttggagccatgttaaatagttaccatcataaaccac
-tgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaa
-tggtaacaactgttgcgttacttaggctggttaatttgtcagagtaataaatacatgtct
-tgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaaaagtaaagctct
-tttattctgatagtgactaactcaggatctaaatacgcgattatactaaccttcaccaaa
-gctcaaaaatcatctgctggtgaccagttatagacagggtaattcaatatttaatgtctc
-ccttaacatttcaccagcatggattgaagatagtataaagttttacatggcagtcattgt
-gtcacggttctatacaaattctgatagttagacggtatttgaaatgtgcttctagcatgg
-tatcttacacaactgaatgaacgactggagccgttcgtatactatttgcgagcctcgaga
-ccccgtttcctaatgttaacgaatatagtataatataaattgtgatatgaataacacaag
-taactacagtttggacaattaattgttctaaactaaaaatcattcacttcagatggcata
-gagttatggctactacacatataaagcggtatgtgaaacacccgttttagccggaaaccc
-tctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtga
-ctcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgca
-gcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaac
-tgtgaataatgtctattactgattaactagtaagacattagtgcatctggtccactgaag
-cacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaa
-agcaagcctataggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcac
-attgtgctaggttcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttg
-ttatcggcagactctttatcccaagaatggataatatgtacatggaaagtgtccataatt
-aagtcccttcactgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgact
-tacttgctttttgatcaacttaattatggattcataaagttcagatatcggtacaattgg
-tgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatc
-cccatttgcccggtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagc
-attgagatccacgatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacga
-agaggtatatataacctaaatactaggtacgttgttagagagacgatgaaaattaatcgt
-caatacgctggcgaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtg
-tcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaattcacggaacgt
-agcgttgggaaatatcctttctaccacacatcggattttcgccctctcccattatttatt
-gtgttctcacatagaattattgtttagacatccctcgttgtatggagagttgcccgagcg
-taaaggcataatccatataccgccgggtgagtgacctgaaattgtttttagttgggattt
-cgctatggattagcttacacgaagagattctaatggtactataggataattataatgctg
-cgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatac
-ctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattat
-atatgttgattatttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaa
-gctgcatctcgcttaagtttgagagcttacattagtctatttcagtcttctaggaaatgt
-ctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatgacatgctaaact
-aagaaagtagattactattaccggcatgcctaatgcgattgcactgctatgaaggtgcgg
-acgtcgcgcccatgtagccctgataataccaatacttacatttggtcagcaattctgaca
-ttatacctagcacccataaatttactcagacttgaggacaggctcttggagtcgatcttc
-tgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagttagggcatagtat
-agatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagctgagatctatcc
-taaaatgcaaccatatcgttcacacatgatatgaacccagggggaaacattgagttcagt
-taaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacgggcttatggttt
-ttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaaca
-acattaaaatcgcggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatat
-ctttggtagaacttactttgctttaaatatgttaaaccgatctaataatctacaaaacgg
-tagattttgcctagcacattgcgtccttctctattcagatagaggcaatactcagaaggt
-tttatccaaagcactgtgttgactaacctaagttttagtctaataatcatgattgattat
-aggtgccgtggactacatgactcgtccacaaataatacttagcagatcagcaattggcca
-agcacccgacttttatttaatggttgtgcaatagtccagattcgtattcgggactctttc
-aaataatagtttcctggcatctaagtaagaaaagctcataaggaagcgatattatgacac
-gctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttca
-aaatttactgagaagacgaagatcgactaaagttaaaatgctagtccacagttggtcaag
-ttgaattcatccacgagttatatagctattttaatttatagtcgagtgtacaaaaaacat
-ccacaataagatttatcttagaataacaacccccgtatcatcgaaatcctccgttatggc
-ctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgagg
-tggtgacgagtgagatgatcagtttcattatgatgatacgattttatcgcgactagttaa
-tcatcatagcaagtaaaatttgaattatgtcattatcatgctccattaacaggttattta
-attgatactgacgaaattttttcacaatgggttttctagaatttaatatcagtaattgaa
-gccttcataggggtcctactagtatcctacacgacgcaggtccgcagtatcctggaggga
-cgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccat
-agtgagccgatgagttttacattagtactaaatcccaaatcatactttacgatgaggctt
-gctagcgctaaagagaatacatacaccaccacatagaattgttagcgatgatatcaaata
-gactcctggaagtgtcagggggaaactgttcaatatttcgtccacaggactgaccaggca
-tggaaaagactgacgttggaaactataccatctcacgcccgacgcttcactaattgatga
-tccaaaaaatatagcccggattcctgattagcaaagggttcacagagaaagatattatcg
-acgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatc
-ataaaaatgtgacctctagtatacaggttaatgttagtgatacacaatactcgtgggcca
-tgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgtatttggtctaatt
-atgttttatttagtgacaatccaatagataaccggtcctattaagggctatatttttagc
-gaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaattgccagtgggca
-atcctaagcaaaatgagattctatcctaaagtttgggcttgatataagatttcggatgta
-tgggttttataatcgttggagagctcaatcatgagctaatacatggatttcgctacctca
-ccgagagaccttgcatgaagaattctaaccaaaagtttaataggccggattggattgagt
-taattaagaccttgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtga
-gcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgag
-ttcctttgaaatagttaactaatttaaaattaattaacgacatggaaatcacagaaccta
-atgctttgtaggagttatttatgctgtttactgcctctacaaccctaataaagcagtcct
-aagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtcaatttaataaat
-tcaacatcgggtctcaggatattcggtcatataatttattaagggctcttcgagtcttac
-tctgagtgaaattggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcga
-tatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatat
-aagaaaactcacacgtctcattattaaactgagtacaatttttgcacgagaaagtaatgc
-aatacaatatgatgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgc
-actggattaaaatccgattatttttaaaaatattcagtgctagagcatatcaggtctact
-tttttatctggtatgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaa
-gttataacataactcccgttagccaaagcccaatcccgattactgccctaccctaacgtc
-tgccatctaaatatcgaacttgttatgatcaatgtgactacctcccaccctttccccttc
-atttgttccactggggataagctagcgttttcagaatcaatgcaataagaatagccaatt
-gtctcacttcatcagagctcttggcaattccaggcgctacgtggttctggaatatattca
-tttttcaaatagtaatacgtttagtgttgctattgtctacacgtttggatattacgttat
-gtgagcggacatcaatagttgtctaactctttagtaagccagagatagcactcttagcga
-atggataccatcttccataagtttagttaatagtccgaaacaactgcttcgagcatattt
-gaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatagatagagtttgtt
-ttaagggactactagaaatgggacaatcttaatagtatgacctaaactgacatttaaaga
-tatatccaggtggcaagcataaagatcattgcgccacctccaccgtgggattacttatca
-gtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagctgagttgatgct
-aaccttacctatgataccccattggaccggttaacagccctacttattccaaataaaaga
-acttttatgctgtagaagctattatagtgatgcctggtaacttcagtatattaaaatgac
-acacatacgccatatagagctcctggaactttgaataatgagcgaacttcgaagttgaag
-agcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattg
-atcattatcgaggttttcataaccttgacccattatcggctgtgcgcggacaagtactta
-aatcactagtttcttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataa
-gacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggatttta
-aattttgttccatttttaatttagccgtaaggatgtccgtaaatgattgaaaattggatt
-caatctttgggcctatgctactggaacctgatcgacaaaatttcaaacatacgttaactc
-cgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccatataccttaccac
-ttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagactaccgatcatatc
-aactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaag
-taccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaattgctaagaggctc
-agagctaccactgtaatttctctagagcccataataaatgaacgatacatccgtaggtag
-cacctaagggattataatggaagccaaatgcagttaataatattatatactggcgtacac
-gattcgacggatctctcacatagtgattcacgacccccccctttgattgacacagcgtca
-gcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagct
-acaactgggtataatttaccatgcttccctgatgctgagtgcaatacactaagaatgagt
-ttttaccccatatcaccagtatttgttctgttattgcgaagaaatggctatgctgagttg
-gcgactaaagtcacccatcctttttattaggtaaccccctcccttaaactaactgatttg
-ctggagctgccctgcatacatatactttatcatttatggacgtccgtgacgcttattatc
-caccatagtcgatatgctacacggattcattaatggatcgtaggagtttaagttatattt
-actaagatcggtctcggctactatcccgccttacccggcgctatttacggccatttttaa
-tatattgacggtaattattcctatggtttcgaccgcacgtccttggacaagaaagaatgg
-caaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtga
-tgagtaacttgacgaaatgttagtggttattaaagactatctattacaccttttgttttc
-tgtcgtagtatattaaagtctagaagccttacaggaaaatcagggttatacagccgatac
-tccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgt
-atactgtatttagaccttttatacaaagtaaatatctcggctttatgtgattgggagggg
-cctactcaaacatgatgacttgacctaataatcactgtgcgggcgtcttatgactagcta
-ttccttgaaatccaccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtg
-aatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcg
-cacacgttacttccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaatt
-cacgagtttaacaaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaa
-ctactcgaagatgtttcgttttcttaaccataggggcttcttaatggcccactacgcaca
-ttttgttcaagcccgagagggacatccccattacgggagtattactaaaactgttccgta
-atacgttcagcaagggatgaaaaaggccactgctcaagttattgacgtgggagtattaca
-tcggaagcctgaatcccacactatgatggtctgtacaggcctagggactgcgtctagacg
-gtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaaggctcacaccta
-ccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaata
-aagacgtggcaaaaacccccgcacataagccgctttagatttcacaaataccaatgcggt
-taaaaacatccttgagtcgtacatacaccatactcgcgttaaacggatataacagaagat
-aataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaataatgcttacca
-gtcatttagctatacggctttcatttcatgtcaagagggtggagtttgacctgtacagtt
-gatatatcaccgatacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccg
-catattacaaacaatagatgggattcattatacataagacacgatgatctgctttttcag
-gttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtat
-tgacagggaacctattttcgaggtattatatagtccagcttgaatatcaatttgacagtt
-aacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaaattctacgggtt
-atcgtctagtccaactatcaattataactcacgagatataagtaaattctcgtacttggc
-ctgatttttattatactttggatccttagtaaacaggaagggagaaaccttcaacgaaaa
-acactggattttgttttactctcaaagctcttatatgacggaaataccctgtcaagtctt
-aactttattactagactaatgaaatgggcttggggtggccagaatcatagtacaatttag
-cggatacactattcggactttcctatcggctgtctggttggataagtatggggactaata
-ggctagacatacctatacttaaactatacaggcgtcatctatctctgcaactttggagtt
-ccctgatgttctcccgccctttgggttcacatcttctataccgacacccctaataacgat
-tagtttgtgggttagagtaaattaatacggttaatattaatgtatcgttgaaaagctggt
-gtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtataactaccctaatg
-ataagctgtaggaataaaattaatgctgtctctaagcgaagagatatttccgactctgtt
-ttaatgacgaatctcattacttctgacttgcaaatgttcaatatggcacggtttcacggc
-acctttgtgacgcatataatgaacttagaagattataacgacggaactttatatgataat
-ccgttacgattaaagaatctgttaaatatcataatggcattcagttctagaccgtgcatc
-atggtaaacttactttctctgcatggcgacatacatttcgctattcaaattcgcgtgtgg
-ttacacccactcgcacctttggaatattaagagaagatgatcagaaaatccattcgctca
-atttttctgacgtacgtctaatttatcctaggagacaaatcgttttatgtctctcacatt
-tttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaagatactcggtgg
-agcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttccaagttcagtta
-agtgaatatgtttaacatacccggcttttcgatcttaagctgacgctggacgtgcgagta
-atgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacgccccctcccttc
-tcgagcccactcacgctatgtattgacgcgaacttgttcgggatcagacttttcaggagt
-tcggtcgcgtgtccctatgtgctaatatataagttagatcgcattagatgctaatctgaa
-tacttatagacgaccttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaa
-acgacaggtagggacatataaaatttgagtgcggctttagttaagggtttaattacctac
-tcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgt
-actaggtagtgattaatgatatcctagacgcacgtgccttagatcttcagactctgatgg
-tccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaatt
-acgatatctaaatacttataatacaataaccaaggatgagaatgactcatcgcgttggag
-ttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcccaatatctccag
-tgagctaattcattggacggtccactttgatcaatccccgaggagatgttcggacacttt
-agtctgtaacacttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttt
-tccaaagttcattttaaataagactacgataggcctttcctattgatataaactacccgg
-ctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatagcaagattcgatt
-cttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcataggatctaagca
-aaattatcaagttgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcc
-cacgttgatagtatgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtac
-accggatttgcatcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgat
-atttagcaagaggcgttgataaagccctcatcatctagatctcgacctcatctgccctct
-tgctccatcattttctacacagactactttcctatctacgttagtataattgctttctat
-cttagtatcatttagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaag
-ggacaacttgtagcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaa
-gaagtttgtcattctattagacattgaattgcgcaattgacttgtaccacttatgatcga
-acactgaatcaagactgtgattaactaaaatagacaagccactatatcaactaataaaaa
-cgcccctggtggtcgaacatagttgactacaggataattaattggactggagccattaca
-ttctctacaatcgtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaa
-aaaaatgctttcgcaggagcacattggtagttcaatagtttcatgggaacctcttgagcc
-gtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgaga
-gggaattcaccggaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgt
-ttaagagttaccagcttaatccacggtgctctactagtatcatcagctgtcttgcctcgc
-ctagaaatatgcattctatcgttatcctatcaacggttgccgtactgagcagccttattg
-tggaagagtaatatataaatgtagtcttgtctttacgaagcagacgtaagtaataatgac
-ttggaataccaaaactaaacatagtggattatcatactcaagaactctccagataaataa
-cagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaa
-cgctaattcatttgttattggatccagtatcagttaaactgaatggagtgaagattgtag
-aatgttgttctggcctcgcatggggtctaggtgatatacaatttctcatacttacacggt
-agtggaaatctgattctagcttcgtagctgactatactcaaggaaccactgctcaaggta
-ggagactagttccgaccctacagtcaaagtggccgaagcttaaactatagactagttgtt
-aaatgctgatttcaagatatcatctatatacagtttggacaattatgtgtgcgaaactaa
-aattcatgctattcagatggatttcacttatgccttagaaacagatattgcccgagctca
-atcaacagttttagccggaaacaatcgaagcatagggacaatgtatcttttcctaaattg
-ccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactc
-gttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaat
-aactgaaagaaacgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacac
-attagtgaatatcggccaatgaaccaaacgcttcccggtacgctatctctctcatcggga
-ggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaac
-ctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtccgggcgtactcct
-ccatggaagggcgcgcatctagtgttataccaactcgctttttaactactatgctgtagt
-tctacaggcatagtggccagtattttctaacttctctggatagatgctctcactcctcat
-ccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatggaggcattaagt
-atcttcactgttccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagc
-tcaagcacactcattgaatactgccccagttgcaacctcacttaatctgacaaaaataat
-gactactctaagtgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtat
-aggcatgtaactcgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtg
-tgtgacaccaggtaattgatgcggatataagctggagatcactcacgcccacacaaggcg
-ctgctacctctttattccaatgtgtaagaatttgctaacttcatttctagaccgcagctt
-tgcggtcataatttcacggtacggacccttgggttagagacttgataacacacttcgcag
-tttccaccgcgcacatgttttagtggcttctaacatagaatttttgttgtgacataaaga
-gtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagccccgtgagtcaca
-tctaattggttgtactgcgcatttagctatcctttagctgactcgaagagattcgattcc
-taatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcag
-atctgcataactcgcgcttaattacttatgagtagttccaagttcgctacgttatgagag
-agattggaattaagcaaatatgttttatggtgattttgggatgagaaggactgctaagta
-cggctactaaacaaatttctaaaaccgccatctaccttatcttggagacatttaagttgt
-atatgtcactagtctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaag
-agccgattcatcaaatgcttatctaagaaagtagtggactattacaccaagcacgaatgc
-cagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaat
-tacatttggtcagcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcag
-ctcacccgcttgctctagatcttatctttgtatgaatgtcagaatttactgcaatatccg
-ttccgaatagtgagggcttagtatagttctctgtatacaggtcacatcaaactccccctg
-tcctagtacagctctgagctttaattaattgcatacatttccttcaatcatcagatgaaa
-acaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaacaactagcccgac
-tcacgttcatccgccgtatccttgttcagttcttactccgtattaggtcagcgaaatcta
-atcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacg
-ctgagcagttatcggctattagatagtggggtgaaagtaattggctggaattatgttaaa
-acgtgatattaagctaaaatacgctacttgttgccgacctaattcagtcattcgatattc
-agttagagccaagaataacaagcttgtataaattgaacggggtgcactaaacgatgtgtt
-actctaatattcagcttggagtatacctgaaggcgaattcatgtatcggccaataataag
-acgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgtggggattgagtc
-cactgtacgagtacggtctctggaaaattataggttcagggaatataaggaagtaaagat
-aattaccaagagatttttggtatcgctatgacccagaggtgttctaacgtctgttttgat
-ccgcagaatttctgcctcaatgcatatttgacggacttgaactagagcctctaaagttaa
-atggcgacgcaactgttcctaaacttcaattattactactctttttttcctagggtattg
-tagaggccagtggacaaaataaatcaaatttaagatgtttcggacattaacatcccccgt
-agcatagaaatcatcagttatccaatctctcatcgagcttttacaatttctgctggcgct
-atggacagcatatgccgcgagacctccgcaagactcacttgatcactgtaagtatcttca
-ttagaggttagagcctatagttaagctgctgacctagtaaaattggtattttctaatttt
-attgctcaagttaaaggttagtgaagggataatgacgttatttttgaacaatgggttgta
-ttcaattttatatcacgaatggaacccttcattcccggcataatactagacgacacgaac
-aagctccgatctatcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagca
-tcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcaggactacttattacc
-tattaataagttaacatgagccttcataccccgtaagacaatacatactccaccaattag
-aattctgagccatcttatctttttgtatcatcgaagggtatggccgaataggttaattag
-ttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctc
-gccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttccggattaccaaac
-gcggcaaagagaaacattgtatcgacggagataacttaatacagaaggaaggggcatctt
-cgaatacggatgaataattctatctgtttattctgacatcttgttttcaggttaatctta
-cgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaatattgacgagagca
-atctcactccttttgggtctatttatgttttattgaggcacaagcctatacagaacaggt
-actattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttgg
-tacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgg
-gctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgacc
-gaattcatccatgtagattcagatcacacactcattccttgatgttgtctaaacaaaagt
-tgttgtggacgcattggagggagttaagtaacaacttgggatcgcatacttataaaaatt
-atatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagt
-cactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgt
-accaaatcgaaagaacacttaataaggcttgcttgcacggaggtatgatgtttactgact
-ctacaaccctaattttccagtacgtacattcattccaataggttagttctcaaagtgcta
-tacaggctcctcaattgatgatatgcttcagccgctctatggatattagctcattttatt
-taggaagcccgcttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtg
-tgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctctcccgttcacta
-ccatacttggtaccgtgcgcatattacatatagatataggatcattttttaaagctgtac
-taggtttgatcgacaatcttatgctatactatatgatgtaaccctcataatcaataccga
-tcgtacgatcctagcataggtggcaagcgattttatgccgattattgtgttaaatagtct
-gtgagtgtgattatcagggctacgttggtagaggggttgtatagacctcgcacacattgt
-gacatacttaacaatatacgaaaactgatataataaatccccttacccaaacaccaatcc
-cgttgaatcaactaccataacgtctcccatataaattgcctacttgtttgcataaatctg
-aatacataacaccattgcaccttcttgtgttccaatcccgttaagattgccttgtcagat
-gatatgcaagaacaatagcatttgctagcaattattaacagctcttcgaattgcctccac
-ataacgcgggagggtatattttaatttggcaaatactaagtactgttggcgtcatatgct
-attaacggttggatattaagttatgtcagccgtaagcaagagtgggcgaaatattttgtt
-acccagtgagagcactcttagagtttggatacaataggccatatgttgacttaagaggac
-gtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaa
-tcttaagaatagagacacgttcgtgttagggtatactacaaatccgaaaatcttaagagg
-atcacctaaactgaaatttatacatatttcaacgtggatagatttaacataattcagcca
-cctccaacctgggagtaattttcagtagatttactagatgattagtggcccaacgcactt
-gactatataagatctggggatcctaacctgacctatgagacaaaattggaaacgttaaca
-gcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgc
-gtaacttcactatagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatg
-aatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccc
-cttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttg
-agcaggtccgagcacatggaagtatatcacgtgtttctgaaccggcttatccctaagata
-tatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttgtgcgactccacg
-tgcatgcccagaaatacgagtttaaatttggttacatggttaattttgaccgaagcatcg
-cactttatgattgataattggattcaatatgtcgccctatgcgaatgcaacatgatccac
-aatttggctataagacgtttaatccgtatcacactttgtttgcggctagtatagtaacgc
-ccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttcaaatataaaaac
-taatcaaacacgacccatatgatcatctgaagatatttggaactttctcgacaaccaccc
-tcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatatt
-gagtcaagatttgcttagtggcgatgagcgtacacgcttatttctctagtcacaattagt
-tatctacgagacatcacgagggagcaaataagcgatgttatggctacacataggcacgta
-tgaatatgatataagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacc
-cacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccc
-caacgtaaggatcaactagaagagaaaactcggtattagtttaaatgcgtcacggagcat
-gagtgcatttcactaagaatgtctgtgtaaccaatataacatctatttgttatctgattg
-cctacttatggctttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtacc
-aactccctttaaattacgctgtgcaggctcatgcactgcatacatatacggtagcaggta
-gggacctcacgcacccttattataatcaatagtagttatcagtcaacgaggcaggaatgc
-tgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactatcacgcattacca
-ggcgagatttaagccaattttgaatatagtcaacgtaatttttactatgggttccaccga
-aacgccttgcacaactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaa
-taccttcatatatattttttcggttgactaacgtgaactaaggttaggggttttgtatgt
-ctatataggaaacagtttcttttctgtcctactttagtaaagtcttcaagccttactcca
-aaatcacggtgattaagccgttactcagcagcatgattctgcctgctcgggtcctaaaat
-ccagccttgtaagagtcgctgtgtattagctagggagacctttgttaaaaaggatatatc
-gcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatct
-ctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaa
-aatattggtacttgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagag
-aattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggcttagaagactcc
-atgatttaataaatactacgaaggaaagactggatctaaagataactctagtaaggccaa
-ctcccttcaatgctgttgccagttataatccaagagctgtccttttctgaaccatagcgg
-cttctgaagcgaactagaagcaaagttggttctagccagacagccacataccctgtacgg
-gtgtattactaaaactggtccggtattagttcaccaagggaggaattaggcaaaggatct
-aggtatgcaagtcggagtattacatccctaccctgaatccatcaataggttcctctgtac
-tggccttcgcaatgagtattcaaggttgtacagccgtataataataagatagtgactatg
-aacgggaagtaacccgctcaccttccccaaaacattgttatatctaagtattaaagtctg
-ccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcacttaagccgcttt
-tgatttatatttttccaatgcgcttttaaaaataattcagtcctacatactaattaagac
-ccttaaacggagatatcacaagttaagttttaaccatctcgactaggtggaactatagat
-acccaactcaatttatcattacctgtaatgttcctagaaggattgcatttcatgtcaaga
-cggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaatcacctaaaccta
-ttagtcagagcacccggttagaaccagttgtcaaaaaatagagcggttgcatgagacaga
-agtaacgatgagatccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcc
-cttaaaaatatttttaaatactaggcaaacccaacataggttagtcctatgtgatacgcc
-acatggtatatcattttgtaacgttacctagggataatcaggaagtggaattacgcaaaa
-gtagacagtgaaatgcttagggttatagtctagtccaaagataaaggataaagcacgtca
-gagaactatattagccgaatgggaatcattgttaggagactgtggatcatgtctaaaaag
-caacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgat
-gaccgatagtacctgtatactagttactgtattacgtgtctaatgatttcggattggggt
-ccccagaatcagacgtcattgtagacgattcaagtttaccaatttaatttcccagctctc
-cttggagaactatcgccaataattgcagtcactttccttttctgaaacgataaagccgtc
-agagttctctgcaacgttggacttacctgaggttctaacccactttcggttctaatagta
-gttaacgacacaacgaataacctttactgtggggctttcacgatattttttcgcttatta
-ttaatggttacgtcataagctggtgtccaaattaaggttaccggcttcgcagagtagttg
-tatccaagtataacttccctaatcataagatcgaggtagaaaattaatgctgtctctaac
-cgaacagatatgtcccactatgtggtatggacgttgctaattacttctgaagggaaattg
-gtcattatggatacgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttg
-atccaccgttctttataggataataactgacgattaaagattatggtaaatagattaagc
-caattctcttcttgtcagtgaagcatccttaactgacttgctctgcagcccctcatacat
-ttagctattcaaagtaccggctcgtttcaaactctcccacctttggaagaggttgtcaac
-ttgataagtatatcatttacagcattttttcggacgtacctctaatgtttcattgcagaa
-aattagttttttctatcgcacattttgcaagtaacgttagagacacaattatctgcgaat
-gaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatca
-aggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccggcgtttcgatctt
-aagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtctgtctccaaggg
-tcggcaaaaaagacccctccattctcgagcccactcacgatatgtagggacgacaacttg
-tgcggcttatgaattgtctggactgcgggcgagggtccatatctccgaagttagaaggga
-catacctttagatgataagatcaattcttattgacgaaattcatccacaacggggaacaa
-cttcaccctagacttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccg
-tttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcga
-caagatagaggctatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtg
-cctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggcataaaactccag
-caatttgggggccgaaaacaaatgacgttagctaattaattatatgacatgatcaaagga
-ggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaact
-tttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcctagttgataattc
-cccgagcagtggttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaatt
-ctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcag
-ttcctattgatttattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgt
-ttatgattattgctactttagatgctgactgttaactccgtgttgtttttcaaccgtata
-tcacaaccgaattggatagaacctatagtttcaagttctgccacaaggtatcatatttac
-agttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtaga
-gctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtgatagcacatatac
-cacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaacacatattattat
-tgttatccaactaatcggacctatgcataaagcattgtctaaacagaataattgcctata
-tacggtagttttagtgatttatatcttagtatcagttagagcttcgaactcttcaggttc
-ctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttcca
-agtagtacctataaatcacagaaagatctgtctcagtatagttgaaatggtattcagcta
-gtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaacgaatatagaca
-agacactatatcatataataaaaaagaacatggtgctcgaacatagttgaattcaccata
-ttgaaggggaatgctgacatgtaattcgctactagacgatcaattccctacttgtcaaag
-ttgaactggtacgttcttggaattaaatatgattgcgctggaccaaattgcgacttcttg
-agtttcagggcaaacgattgagccggaggatgtccgtctcttacctttcttgcttatgat
-aaacgacggtccctgtacatcactgggaattctcagcaaaaataattgggtaaatcgaga
-ctcgatgtattcggccacaaaggtgttagacgttaaagattattcaacggggcgataata
-ggatcataaccggtatgcaagcgcattgaaagagccatgagatccttatccgataaacgc
-tgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaa
-gttgaagacctaagttataatgaagtgcaataccaaatcgattcatagtggattatcaga
-ctcaagatatctcctgataaattacagttgttaagatacggataaaatgagatttaagat
-tagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagtta
-aaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagt
-taatatgtagcttacgttctagcttgtgctaatctgagtatagattcgtagaggaatatt
-atcaagcttccacgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagt
-agcgtaaactatagtctagttgttaaatgctcagttcttgttatattcgatatactcttg
-gctaatttatgtctgagtatataaaattaatgatattaacttgcatttcacggatccctt
-agaaaaagattttgaccgagcgcattataaacggttacaccgaatcaatagaagcatacc
-caatagctttctttgaatttattgcctgcgcaacttggctgactctctagatccgaataa
-ttctatatggtcgtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgg
-gccgataatggctctttgcaaaattactcaatgatacgattgatcaaagcggtagttgct
-agtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttccaaaagagtcca
-cgtaccatatctatctcatagcgacgcgaggggaaccttatctaactatcattccattta
-ccgggtgactctcgatgcaggatccgattgggataaattgcccagaaatggctcattcct
-gactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggcttataccatcta
-gattgttaactacttgcctgtagttctacagccatactggacagttgtttctaaatgatc
-gggattcatgctagcactcctctgaatgcaccgcgtaagtttaactattacgtccgtggg
-cagataaggatggaggctgtatgtatcttaactgttacctaatatggctggtaattatca
-aagtaaggaccttaatgccatagcgctagcaatcgctttgtatactgaccatgtgccaac
-ctctcttaatctgtaaaatataatgtcttagctaactgtggacgatcatgtctctgccta
-gagcttcgctgtatcaattcctatagccagcgtactagtgacacaacaacaccgtgtgag
-aaaagatattagtccttacgtctgtctctctacagcttattgatgaggattgaacatgga
-catatagctccccctcaaaagcagatgctacctctttattccattctcgaacatttgccg
-aacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacgtcacgtcccttt
-gagactggataaatatattaccaggggccaacgagcaattgttggaggcgcttctataat
-acaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatatt
-aatgtgaaacccccctctctcacatcttatgcggtgtactgccctggtacatttcctgta
-caggactccaacagtgtagattcctaagatagctgttggagttgcctcacgccagatcga
-aaaactgaataaactagtgagctgagctgcagaaataccgcttaattacttatgactagt
-tcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattt
-tggctggactagcactccttacttcccctactattcaaatgtcgtaaacagcatgagaca
-ggatcgtgctgacatttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcg
-ttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctg
-gtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaa
-gcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaa
-aaaatatttttaagcagtaggcacctaacccgattcctctacttagtagctttctttgat
-tctcagaattgactgcaatatcactgcacaattctgtgccattactagacttctctgtat
-taacgtctcatcttactaacactcgcctaggacacatctgagagtgaagtatttcaatac
-atttactgaaatcttcagttctaaaatccccgaataaggctcttatcggtttggccaaca
-caagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaa
-taactatttcggcagacaaagcttataacaagttgccggcgcgtataatatttaaaagac
-cccttgagctgctcaattaaaacgctcacctggtataggctattagatagtgccgtctta
-gtaaggggcgggaattatcggataaactgatattttgataaaataaccgacttgttcacg
-acataagtcactaaggagattttatctttctccaaagtatatcttccttggataatttca
-aagcgctgcaatttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgt
-agtaatctagaggcaaattataagaagttcatcatatcattttcgactacaaaaacaagg
-tgttgtatgccggcgcattgtgtaaactggacgagtaccctagatggaaaattatacgtt
-aagccaagatttcgatgtaatgataattacctacacatttttgctatccataggaacaag
-agctgttctataggctcgtggcatacgaacatttgctgccgctatgaatattggaagctc
-ttcaactacagactctattcttaattgccgtcgaaaatgggccgaatcggctattattaa
-tactcggtttttccgaggggattgttgtcgacagtcgtaattattattaatattgatgtt
-ggtgaggtcatttaaatacaaccttgcagacaatgaataagggatccaatctctcatact
-ccttttacaattgctcatgcccctatgcaaaccttatgccgccacacctccgcaactctc
-tcttctgaactgtaagtagcttcattactggtttgagactatactgaagctgatgacatt
-ctaaaatggctattttcgaatgtgattcataatgtttatcgtttgggatggcagaatcac
-gttatttttgatatagcccgggtattctattgtatagaacgtatgctacaagtcattccc
-cgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctt
-tatttcccgataacctatcttccataaatagcggacagcaggatactgacgctcaacatc
-agtggttatggtctaatttttaacttttaataaggtaacttcagcaggcatacacagtaa
-ctctttaatttataatcaaattagaagtctgacacttcttatatttttctatcatccaac
-gcgatcgcccattagcttattgtgttactaataacgtatctaaaccaatccttttcaagc
-tactgcctatattgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattg
-tcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagacaacgagtgaaat
-ttatacactacgaagggccagcgtacaagacccatgaattaggcgatatgtttattctga
-catattggtttatccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaatt
-ttttttcgaagattcacgactgaaatataaatacgtttggctatatttatgttggaggga
-ggcaatagcctttactgttaaccgaagatttagccagtgagtgtgacactaaaacactgg
-aataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatat
-agctctggatataattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaa
-gccggcctctcatattgaaggtccgaagtattccatgtacattaagatcactctctcatt
-catgcatcttggcttaacaaatctggttgtccaagctttccaggcacgtatggtacaaat
-tcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagt
-aaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaat
-acggttagaagggattagttatgttacaaatccattgaaaacttaagaagcattgcgtgc
-tcggagggtgcatcttttatcaagagactaacattattttcaacgacgtacatgctttac
-aatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccg
-atatccattggaccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtatt
-gccataatgtaatacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaat
-gaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgatttcatatagata
-tacgataagttggtatagctctactaggtggcatccacaatcgttgcatttactatagct
-ggttacaatcataatctataccgttccttacatactaccatagcgggatagcgttttttt
-gccgttgattgggtttaagaggatgtcagtctcattatatccgattcggtgggagagccg
-ttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaactgatataagat
-ataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatt
-tgactaattgggtgcagatttctcaattaataaaaaaatggcaccggatgggcttacaag
-ccccttatcattcacttgtatcatgatttccaagaacaatagaatttgctagcaagtatg
-aacagagattcgaattgcatccacagtacgccggagcgtttattttaatgtggatatgac
-gatgtactgttggcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaag
-catgtctgggagaaatatggtggtacaatctcagagaaagattacagtttggtttaaata
-ggacttatcgggtcggaagtggaacttaataagcagtacacaattgggcaacagacgtct
-tgcctattacaataggattacaatgcgttagatttcagacacgttcgtgtttggctattc
-gtcaattccctaaatagttagacgatcaactattatcaaagtgattctttgttcatcctc
-cattcatgtaacagatggcacactacgcataacgccgaggaattttaacgagatttaaga
-gagcagttcgggcacaacccacttgactttataacagctcggcagcataaacggtaatat
-gtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaactaagtggttcatg
-ttcaacagatgtgacgcagcaagcctaacttatctattggttttgctataaaagaacaaa
-gttacacagaatcctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaa
-tagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactc
-cgggtatgataatggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggtt
-aggataaggatgagaccgaacttatttccggccataactttagattttctacctagtaca
-caacatcagggcggacacgaaaccgccatcacatcatataccaggtttaatttgcttaat
-gggggaagtgtcaacgaaccttcgaactttagcaggcatatggccattatatatggcccc
-agagcagaatgctacagcagacaaaatttggatttatgtagtttaatacctatcaaactt
-ggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaattattactactc
-agcagcttctgcaatgataaaatcttatcatacacgtcacatatgataatatctacttag
-ggggaacgggctccacaacctacatagtactcaatacttacactattcgacaggcacacc
-aaacctgtacagtcccaaaagattgagtcaactttgcagtactgcagatcacagtaatag
-cttagttagcgagtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgat
-gtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaactgtacaacctt
-agagataagtctcaggctactaaaaacacgttgtggcactaacaggatcatggttgattc
-ttacttattcggctgaccggcccaataagtaaccttcaactagaacagaataatcgggag
-tagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagt
-taaaatcgttttcttagcggattccctacttatggatttgagctcgtccacaatattcga
-tacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaa
-ggaattaatagaaggttgatggtaggctccgaacgctccatgattataatcaagtggact
-gtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccct
-atacgagtagataaaccatgaacagcacagtgtgaacccatggttgattttaggctacct
-tatttttaatttccgttacacagaaacgaattccacaactaacatgccattaatttttcg
-atatcttataaaagatggtcgaaattcattcatttattttttttcggttctcgaaagtca
-actaagctgtcgcgttttgtttctctttagaggtaaaagtggctttgatctcctacgttt
-ggatactagtcaaccattactccatttgatccgtgagtatcacctgtctaacatccagca
-ttatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgtattagctaggga
-cacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccccagtagatttat
-tcagctagtgtaagtataagatatctcacccacgaggttcaagtgatatgcagtcttaga
-ataatacttatcctgaatttcgatattatgggtacttcaataatccgctagcgctacttt
-atgtctcgttggacagcaggacacatggcagtcttaaacactaaagacatcacctgaatg
-aatgtaatgggattacaagaatcaatgaggtattatatacgacgtaggaaactctggata
-tatacagtaatctagttacgccatcgcacttcattcctctggaaacttagaagacatcag
-ctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaagttgcttataca
-aacacacccaatgacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaa
-acccagcatttagcaataggagctacgtatgcaactcccacgtggtaataccttcaagct
-atcaatatataggtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccag
-tataataattacagaggctctatgaaacccaactttccagctaaaagtcccaattaaatg
-gttatttcgtacttttaaagtcgcccgttctgttattacgcgaattgattctactccaaa
-attaaacacaaattatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataag
-gctctactaaattataattaagacacttattaccagatttctctagttaagtttgaacca
-gctcgactaccgcgaaagatacattcccttctctatttttcagttcatctatgggtcaga
-gaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcag
-tgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaa
-aagactgccctggaaggagtaagaagtatacagctgatccggtgtatccttcagtcatct
-gccctatactaattacacgacgcaaggaaaaataggtttattttctaggcaaacccttca
-taggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggata
-ataacgatctccaatgaaccaaatgtagaatgtctattgattacccttttactattcgac
-ttagagataggagatagaacctcagtgtacttttttagccgaatgggaatctttgggagg
-tgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgtt
-cgtggaatcgataacagatttgttgacccatagtaaatgtatactagtttatgttgtaag
-tgtagattgttttccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagtt
-gaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgta
-agtgtaggtttagataaagccgtatgagttatatcataagggcctcggaaagcagcttcg
-aaccaaagttcccttataatagtagtttaactataaaagtatatactggtctgtcgccct
-ttcacgatttgttttaccggtttatgaagcgttacgtcattagagcggctccaatttaag
-gttaacggcttccatgtgtagttgtatacaaggataacttaaagtatctgttcagcgagc
-tagttaagttatcctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttg
-ctaatttattctcaaggcaaattgggaattatcgatacctgtataccataaggtcgctcg
-atgtgatgcttatgtcttctggtgatcctaccttagttagtgctgattaacggaacatta
-atgtttatcgttttgagatttagccaattctctgattctaactcaagatgccttatctga
-cgtgctatgcagcccctaagtattttacattgtaataggacacgctcctttaaaactcgc
-caaaaggtcgttgtggttctctactggttaactatataatttacagctttgttgagctag
-ttcctctttggtttaagtcctcaatattagttggttcgagcgataagttggctagttacc
-ttagtcactatattagatccgaatgttatgcttcatctgaagaccgccaccctccaaaat
-ttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtg
-tatctgtacacgagtttccatattttcatcaacagccaccgcacacttatgtcactctag
-gtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgctagtcaaaaata
-aacatagcgaggcaccactaattcggccgcttatcaatgggatgctctgcgcgagacgcg
-ccagagctcagtagttagttcggacatacatttacttcagatgatcaattagttttctac
-aaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctttagtatccttcc
-gtcttatataaggtcagtcccccgtttcggtaccctggaatttactaagaataatgaaac
-agcccccaaggacgtacgtttacaaatgatagaccagatcgcctagcttattccgacgca
-tgttgcatagaattgaaccaacggaatgtgagagtaactagatgagccgaccacagcacc
-cgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatgtcctttgagtat
-taagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctcggatattcaggg
-aacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaa
-tgcctacctcatagtgctgaattaacacagcactgcggacctaacttttcgaggtttcaa
-gttcacgtctcaaaacctaataggctggaatatgtagggatcctcggtgaatttgtgatt
-gggtttgttgtagtactgaccaagtgaatattctttttttctaaaagcagatctgctgcc
-gggcactacgaaggagatctctgtgtatcattattgcttcttgacatgatgactcttaaa
-tcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacatattgttgatact
-tcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaaatactggtgact
-tggtcctatctactattagctagacctctggggaaccacgcccccgtaaaacctgtgcaa
-gagagggggtcatacatcttagacatcgcgcctccaccagggaagcattgggtgattgac
-caggtgtgtaacaaatatgattattcttatactaatattagcaaagatgcataatgattt
-gtattaaatgtataattgaattgataagggtcttttagtcagtgatagagtagtataagg
-tagacattagaactcttaaccggacgcagatttttcggtcttagtaagccaattagtcga
-caaaacaaggtaagagcggttactagtagtacctataatgcactgaatcttcggtcgaag
-tatagttctaatgctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaa
-caagctcttgtaagtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcc
-tacttattaggggaattaaccagattgaaggccaatcctcacatgtaatgagataataga
-cgataaatgaaattcttgtaatagttgaactgctacgtgatgggtattatatatgattga
-gatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccc
-tcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcactccgaagtataag
-caataataatgcgggtaatccagactagatcttttcggactcaatgcggtttcacggtaa
-acatgattaataccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgcc
-aggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttg
-tttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaagtccattacctt
-ttagtttcagactggtggagctgactaaagttatatcatcattttgtacactggtttagt
-taacgataatttcagatttaacatgaccagacgataatcgctgtatatccagttggaatg
-tggtttgccagaaaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatc
-ccatccattgcgctatacctcagtgtatttggagctgtagttataccgtgtgctaagatc
-agtagacatgacgagagcaatattatctaccttacaagcatcaacggacgtctagtcgga
-acaaaagactctaaaactcgaacttcaggttaatatactatagttctgtattcagcagtt
-attcttatattcgatattatcttgcctattggatgtctgactttagtatattaatcatag
-tatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaattataaacggtt
-acaaccattaaagacaacaagaccctatagctttatttgaattttgtcaatgcgcaactt
-ggagctcgcgatacatcccaattagtctatagggtcgggacgattctacggcatttctgg
-ttataatgacaacatggattgtggcccgagaatcgctctttcattaattaagcaatcatt
-acagtcttataagcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgag
-ccgaatagcttaaaaaacaggccaccgaacattgatagagaataccgaccacagcgcaac
-ctttgattactttcattaaattgtacggctcactcgacatcaagcttaagattgcgataa
-tgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcagaaagcgtaccca
-gagaagatacgctgttacaatatacagggtgaaattattgcctgttcttcgtaaccattt
-cgccaaacttggttagaaatgatagccattcatgatagaaataagctgaatgataccagt
-atctttaactatgtagtcagggggaagataacgatggtccatgtatgtttctgatatgtg
-acagtattggccgcgtaatttgctaacgaagctacttaatgcctttgagcttcatataga
-tttctttaatcaaaatcggcaaaaagatagtatgagctataatatatgctagtagagaac
-tctggaccatcatctatatgaatactgattcgagcgtgcaattactttagcctgcgtact
-actgactctacaaaacactctgagataagtttgtagtcagtaagtcgctctctataaacc
-ttttggatgaccattgtacagccacttatagatcccaataaatagcacaggagacagagt
-ttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagggcacctattatt
-tgatacctaacctaacggccctttcacaatggagaaatatatgacatcgggacaaacaca
-aatggtgggtggccaggagatatgacatggtggcgtctctaagaaacacggactccctct
-aggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtg
-taatgacctggtacattgactggtcaggaatacatcactgtagttgccgtagtgtcctgt
-tggtgttccatcaagacacatcgtataacgcaatttacgacggacatcagatcaagttat
-acagattatttaagtatcacgtgtgcattgggacataagggatctcacacatgccttgga
-acatttttgctttgtgccgctttttcgctgcactaccaatccttacttaccagtatattc
-aaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcgattgggatagac
-gagacatttgcgagcgccctccacggatacgaatctcccatatcaatgtgaactggatgc
-tatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcag
-ttattcagaacctaatacacaaaaccgtcaaacattttctaattctaggtatgggccgat
-cataggagctaaggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgc
-atatactgagtagctggcgtgcattctctcaattgtatcctttttaactgaactagtcgg
-tcccatttcgtgactgagatctattaaccgataagattaataacactcgcattcgtatca
-gctcagagtgaagtttttcaataatttgactgatatattaacttctaaaataacccttta
-agcctcggatccgtttcccaatcacatcaaaaattcttattccaactatctacggattaa
-caacgtgcatggggatcgtagtaagaacttgttccgatcactttgagtatatcaagttga
-cggcccggttattattgaatagaaacattcacctgctaaattaaataccgcacatcggat
-acccgatttcagagggccgtcttactaagggcaggctttgttcggtttaactgagatgtt
-cattattttacagtatgcttcaactaatatgtaacgaaggacagtggatctgtctccata
-gtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttga
-tcatggcacgtgaaagcaacccctagtattctagacgaaaattttttctagttcatctga
-taatttgccaattcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcg
-aacctagagccattatttgtcggtaacccatgagttccttcttttcagaagttaatacac
-tgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcataacaacattgga
-tcaagatagcaatttggctacctattctaattctcactagattcggtattccactacaat
-atcggcagattaggattggatgaataatcggtgtttaagtccggttgcgtctccaatctc
-ctaatttttattaatattgatcttggtgacctattgtaaataaaaacttcaagactttga
-ataacggtgaaaagatagaagactcatttgaaaatggatcatccacagatccaaacatta
-gcaagacactaatccccaactagctattctgatcgcgatcgtgctgcagtactcctgtca
-caatagtctgttcatgatctaattctttttgggctttgttcgatggtgattcagaatctt
-tatccggtcgcttccctgtagctactttgtggggatattgcccggggattatagggttga
-gatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactacatcagaacatcg
-tgaagacaccatacgcggtacctttatttaccgataacatttcttcaagaaataccggta
-agcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaattttatttaggt
-tactgctcaaggaataaaaactaactatttaatttataataatattacaaggctcacact
-gattagatttgtctataagacttcgcgatcccccattaccggattgtcttaagaataaac
-tagataaaccatgcattttctagataaggcctttagtctaattagatacaaaaaacacga
-tagttgcatccttaatttattgtgtcaaacctggaaccttttaattacccgcaaatcact
-ttatgtcgagactacctctgaaatttattatctacctaccgcatgaggacttgaaccatc
-ttgtaggagttatgtttattagctaagattcgtttatcctgtagcggtccatgtatattc
-aacaagcaaaaagcactcagaattgtttttagttgagtcaagactgatatataaataagt
-ttccctagttttttcgtggtgggacgatattgaattgaatcttaaccgaagagtttccca
-ctctgtcgcacaataatacacgccaatatttccagccctgcttatgccttaatcggttac
-tcaatctcccattgaagttcattttgatctgcatagaagtttcgggcccagccttttttc
-tgccaccttcctccaagctctgtagacgcactctaagattgatgctcacatgtattaatt
-ctacattaacataaatatataagtcatgcatcttcgagtaaaatatctggttctccaaca
-tgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatgattgggttaact
-ggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgta
-ttcctcgtgctcggaagggctattacgcttacttccgttttggtatcttaatatgacttt
-caaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagtt
-gtttaaacgaactacttgctttacaataccggtcgtatatatcgccgtgaatccagaaga
-ttgtcttctttggattatcaaccgagatcctgtggaccgatgttttgggaccttcacaga
-ggactccaggtagagctcgcttttgcattaatctaagaattgtacctctctaaaagatct
-aaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaattactttaggccga
-aaggcacatgagttattatacatatacgagatggtggtatacatcgaattcggggcatac
-actatagttgcattgtatttagctgctttaaataatatgatattaccttccttacataag
-acattaccggcataccctggttttcaacttgtggggctttttgacgatcgcactctcatt
-tgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaa
-tagattacttttcgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaa
-gtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaa
-aaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatcttgatttcattctt
-cttgtcaattgccgacataggatgaaatcagattccaatgcaatacacagtaacccccac
-ccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggcc
-ttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgtacaatctcacac
-atagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaactttattagaag
-taaaaatgtgggcaaaagaaggattccattttacaagacgattacaatgagttacatgtc
-tctcaacgtagtctttccctagtagtctttgaactatttaggtactccagaaaattttag
-caaagggtttctgtgtgaatccgccattcatgtttatgatggaacaataagaataacgcc
-ctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatattcaatttagtaca
-gatccccagaagttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtct
-aattactatactaacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagt
-gtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttag
-gacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatg
-agcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacac
-ataatcgaactattgatagtcgggagcataaccaggtgaacgtactttgttcacgacatt
-tattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatca
-ttgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgagaactttagctgg
-cttttggccagtatttagggaccaagagcactagccttaagctgaatattttgccattta
-tctactgttataactttaaaacttggtggcaccagacttgtcgatacacacgcatcaatc
-tgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttatattatatttaaac
-taaaagatgatattagcttctgagggcgatagggctccaaatcataaagaggaatatatt
-attacacgattagaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttgg
-cagtactccacatctcagtaatacagttgggagagtctcaaatgttgttttattactcaa
-tgaaccaccctcataatttcactgctgttccattaaatttgcaaacgatcatttgctttg
-aagaaacgtaaaatcgacaaaattacagataagtagatgcataataaaaaaaactgctcg
-ctataacacgatcatcgtgcattcttacttaggagcatcacccgcacaataacgtacctt
-aaactacaacactattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaa
-agaacttgctctctcgtaaaatgtgataatagtttgcggagaggattcaattattttcca
-ttgcacctactccactagattcgataaaagaaggtggtcctcccttaaaaagaaatgtta
-agtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatccttccctaagaaaca
-taaaggtttttaataatgtcgactgtgaactataactgcatcctttcctgacctactccg
-gttccttgttgttatttctgaacgagaccagtagataaacaatgtaaaccacagtgggta
-ccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcata
-atcttacttgaaattaattttgccttttattttttttcaggctcgaaattaatgatttgt
-tttttttgaccttctagttacgctaatatgcggtcgcctgtggtttctattgagtcctat
-aacgggatgggatctaatacgtttggttactagtaaacaaggtataaatttgataccgga
-gtatcaactgtataacatcaagctttatgactcatacgcgaagtaatgacacaaggcttt
-caggagatcgcgagtacagagccactaaggggtgtattacgatagtgacaccaccgagcg
-cactcactccccaagtagatttatgatcctacgctaagtattagatatataaccaaagag
-gttctagtcagtgcaactcttagaataataattagccggttttgcctttttaggcctaat
-gcaatattcagctagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtt
-taaactaatcaaatataatctatgaatgttatgccagtacttgaataaatcaggtttttt
-ataagtccttgcatactctcgttatatactgttagagtcttaccccatagaaattctttc
-atctgcaaacttagaagaattctcagctacggggagcataaagtccccaggatgttgaca
-aatacaacaaatgtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagtt
-ttagccgaaccttgtacggataaatccctccattttccaatagcagatacctatcctact
-acctcgtggtattaaattaaagcttgaaatatagagctgcatagcttatccaattcccaa
-gcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagcaaacccatcttt
-aaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttat
-taagacaattgtttataagccataattaaaaacatatgttcaacaggttcattgatattt
-gtaattgcacaggtttttaataaggatctacgtaagtataatgaacaaactttttaccag
-agttatattctgtactttgaaaatgctcctctaccgccttagagactttcaattagattt
-tttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgc
-taaccctatcgtctgtctcataactgtaggtctaatataattttcagttttcgaacacat
-aaccctttgaaaatctgctatttaatgtctcacctgcatgcactatcttctatactgctc
-agaacggctatacgtcactatgctccaagtgacgatttaaacgaagcaaggaataatagg
-tttattttagtgcaaaacaattaagtgcggactacgtgctctttacaataagccttgtga
-ttgggctataggttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctt
-tgcattacccggttactagtcgaattacagatagctgttagatactcactctaattttgg
-acaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaa
-acgattacatattatagacttgttcggggtagagatatcacagttgtgcaaacattgtaa
-atcgatactagtttatgttggtagtctagttgcttttaccattccccgaaaaacttgatc
-tactatttcgacaacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagt
-gccactatttgtccactatatgtaagtgtagctttacataatccactatgactgagatca
-ttacggcctaggaaagcagcgtagaaaaaaagggcccggatattacgactgtaactataa
-aactagttactggtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaac
-gaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttctataaaacgata
-aagtaaagttgatgttcagcctccttcttatggttgcatcgagagtacactactcagtgg
-gaaatagatcggggttcctacttcagattgtattatctaggcaattgccgattgtgccat
-acctggataaaataagctacctacatgtgatgcttatctattatcgtcatactaccttag
-ggtgtcctgttgaacgctacattaatctttagccgtttgagatgttccaatggataggag
-tctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatt
-tcgaaacgagacgttataaatagaaaaaaggtccttctggttctattctgctgaactatt
-gaatggaaagattggttgacctacgtactatttgcttgaagtcatcaatttgacggggtg
-agagacatatggtgcatactttacggactctatattttagatcagaagcttagcagtctt
-ctctacaccccctcacgacataattgcttttaagaatctatgtttgattcctctacggga
-attcggatccgttcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagc
-atacgaacactttgctaactagacgtatgtatagtagctataaatcccgacgatatttac
-aaaaagaaatgagactcaaatatatacatagcgaccctacacttattcgcaccctgatct
-aggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgtattaaatttact
-gcagttgagattttagttgtctactaaggattactctaacccgtaataaggatcaagact
-cggtactagctttactatcattccctatgtgttttcctaactcacaagggtacgtaccag
-cctatgtaattacaataatgataaagacacaaaggaagtaactttacaaatgagtctcca
-gttacactagcttagtccctcccatcttgctttgaagtctaaatacgcaatctctgagga
-tatacagcagaagaacactcataacgttggagtccaagaattagactcatagggccccca
-acatttaatatgtactgtgagtttgaaggtgttctattgttaattcctgctcttgataca
-tgacacgtactccgtgtttaaggcttcggactgactttctttcataagttgagcaacgaa
-aatttcagaatcgataagttggattcactaactaatacggctgattgaaaactccactcc
-ggacctatatggtcgacctttatacgtaaccgatataaaacttataggctggtatatcga
-gccttcctagcgcaatttcggatggggtttcttctactactcaacaacggaatagtcttt
-gtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtc
-attatggactggagcactcttaaatcactctgcgtgtgctaaacgatagatcataacatg
-tcctgagtaaattttcttgatacgtcgcaatataccgttattagttaaacgttctcatcc
-gtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgactcatctcgcctaa
-cacgcacacgtataaactcggaatgactgccgctcttacatattagaaatacagactaca
-ccacggaagcattgggtcattctcaaccgctgtataaaagatgattagtcttataataag
-attaccaaagaggcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgt
-aggcagggagtgaggacgagatggtactcaggacaaatattaaccggacgaagtggttta
-cgtcgtactttcactattagtagtaaatacaaggtaacaccggggaatagtactaaatat
-aatgatatctatcttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaa
-aatgtgctgacttatagcatgatacaaccgattgttacttttgtctattcaaaagattga
-atagttttttatacaaaagccgcatacttatgacggctagtatacagtttcatcccctag
-catcaatgctatggacagtattgaacttataggaaattcttctaatagggcaaatccgtc
-gtgatgcctattttttttcagtcacatcctcaaatggcactagtattgtcgggatcccat
-taacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgac
-agcgacagaactcccatggataaccaattataaggcccgtaatcctctagacatcgttta
-ccaataaatccgctttctccgtaatcatgttgaataccccagagtagtccagatgataac
-cgatgaaacacaagtctttctcaatgcacttacggtgaacttattaccgccaacgtagct
-catcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactt
-tcgtatattcaacgccttgtaattttactttaagacgcctggtgatgtagattcttagat
-aatcagtttgttatcggctgtactttaccataatttcacaggtttcaggtcaagaagatt
-atagctgtatatacagttccatgctcggtgcacagaaacgtgatcggataataatcaatc
-gcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagtgtatttcgacat
-gtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagattagattccttaat
-agaatataccgacctctagtccgaactaaactatagataacgccaacttcaggttaattg
-tctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggccatattggttcg
-agcactttagtttttgatgcataggatatgcaatgtatagctgaaagtactttatctgtt
-tcaaactcacattgattaaaccggtaaacctttaaagactacaagaaaatattcagtgag
-ggcaattttgtcaatcacaatcttccagctagagatacttcacaatttgtcttgaggcta
-cgcaacattagacggattttcgcgttttattgaaataatcgaggggcccaagagtatcca
-tagttcattttgtaagatttctttacaggcttattacagcttcttcagactcctacatgc
-ttacgagttatatgctagcatgtgaacaatagattaatatacaggaaaacgtacattgag
-agagatgaccctacacagcgcaaccgttgagtactttcattaaagggtaacgctctcgag
-acagcatccttaagatggccttattgtcaaatcatttgcagaagtacgcaagatccctaa
-ccaacgtagaagaatccctacaaacacatgagacgcggtgaaaatagacagggtgttagt
-attcaatcttcggagtatcaatttcgccaatcttggtgagaaagcataccctttcttcag
-agaaagaagatcaatcataacactatctttaacgaggtacgcacgcgcatcattacctgc
-ctccatggatctttaggatagcggaaagtattggcagcgtattgtgatttcgttcctact
-ttatcaatttcacattcatatacatgtcttttatcaaaatcgccaataagataggatgag
-ctatattagatgctagtagagttcgcgccaacatcatcgataggaatactcaggacagcg
-tgataggacttttcaatccctaatactctctataattataactctctcttaagtttggag
-gcagtaacgcgctctatataatcagtttgctgcaccattcttcagcctctgatacataca
-aataaattccacagcagtaagagggtttaattgagacatcttgggaacttaggattttac
-tctaacatcaccgaaacgattattggataccgtacctaaacgaactttctcaaggcagta
-atataggacatccgcaataacacaaatgctgcctccccaggagttatgtcttcctggagg
-ctatatcttacacccactcactataggcaaactaaagtttaaatgttgattgtctaaaaa
-aaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattc
-tctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcctttaaagctattt
-acgacgcacatctcagcaagttataaacatgttggaagtttctagtcggaattcccaaag
-aacggatctatctaatgcattcctacatttttcctgtctgccgatggtgccatcctattc
-aaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaaccttacgcctct
-aagggttcctcgagtgccatacaccagtcaggtccgagccacatacacggagaacattct
-aacatagcattctcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaa
-atcatacttgcaatcccatagcacggattaagaacctaagaaacaattcagtaaaacatg
-ttcgaattcttggtatgggaacatcattgcagctatggtctaacgcattaatgtttgggt
-acatcttccatcatataaacaggaagagtctgacgacagggagtgcttgcgatcatgtct
-atcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataaga
-tttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatat
-atgatctgctttaataaaactttatccataggatacgtttccaaatcaattcaataatta
-ttagtcaaaatagataaggatgaacaacctgaaggccgatcggacgtagaaagtggtccc
-atcactttgagttgatattgttgaaccacacgttattatggttttcaaacagtctcagga
-tattgtatatacagataatccgataccagttgtctgacgcccctcttacgtaccccaccc
-tttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaactaatttggaaag
-aagcacagtggatatgtctaaattcttgttattcaggcctgaatttaatacaccgcatag
-ttaacttcgcggtagagttgttcatcatgcctcctctaagctaccacttctatgatacac
-caatagttgttctacggaatctgataattggccaagtcataaacttccgctgcgttcaac
-ccccttgctcgaatatccaactcgaaaagacagccttttggtgtccggaacaaatcagtt
-acttcttttctgatgttaattctctgtggtcagatacagaccaaaaactccgcggattta
-ccatcctccaagaacaaatttgcatcaacatagcattttggctacatattctaagtctca
-atagtttaggttttcaactacattatcccaacattaggattggaggaataatagctgggt
-aagtccccttgcgtctacaatcgactattttttatgaatatgcttctgccgcacctatgg
-ttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatgg
-cagcagccaaagagcatataattagcaacactctaagaacattatagatatgatgatagc
-gatcgtcatgatgttatccggtcacaatagtagcttcatcagctaattcgttttgccagt
-ggtgacttgcgctggaagaatcgttatacggtcccttccctcttgatacggtgggggctt
-attcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagt
-caactatactaaatcacaaaatagtgatcaatacatacccgcttcatggttttaaccatt
-taattgattaaagatattccgctaagaaccattatctacctaaactgatcgccgtatcct
-agtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgta
-gaataataggtcttggagctaaatgatgtgattggtagtgaagacttacccttacaactt
-taccggtttctcggaagaatatactagagaatcaatgcatgggctacataagcactttag
-tctaatgagataaaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaa
-cctggtaatttaaaccatatatctttatgtcgtcaataactctcatatgttttatataac
-ttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagctatgaggccggga
-tccggttgagctacatctatttgctacaagaaaaatgaaagcacatttgttgggagttct
-ggctacactcatagagaaataagtggcccgagtgggtgcggcctgcctccatattcaagt
-gtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcctttatttcctcc
-acggagtagcccgtaatccggttcgaaagagaccattgaagttaattttcatatccagtg
-aagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatat
-gattcatcctaacttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcg
-agttaattttcgccttctccaacatggcatccctacgttcgttataaggaccatacatgt
-aggttttaaaggtttgcggttaatcgatatttacatcatagaaattctatagtcaaattt
-acaagactctagatactcactcgttgcagccggctaggaagcgctttgtaccttacttcc
-cttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactcatacctccgtgaa
-gagggtagatagactattaaagttgtttaatagtacgtattgatggaaatgacccgtagg
-agatttaccactcaatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcga
-aacatgggttgggtccttcaaacacgaatccaggtagagatacctttgcaatttttcgat
-gaaggcgaccgagataaatgagctataacactgtatgtcttttgattgctataaaacaca
-gaaacggatattaatttaggccgtaaccaacatctgttatttgacatagaacagatggtc
-ctttacagcgtattccggccttaatattgaggtccagtgtattgtcctcctttaaagaag
-ttgattgtaactgacttaaataagacatgtcacccattcactgggttgcaactgctggcc
-ctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaag
-acataaatgtcgctatgaaggttattcattaattttagctgttttcttagaaaaggtaaa
-tttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgg
-gcatcattgagattgtaagaaataaagccataaccagccccggaatagaaaatgttaagg
-aaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggac
-attgcaataaaatctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtc
-caccatgtgcagaggataacggaatgtggttccgtcccataaacgatcattctcgcccac
-ttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggc
-taccttctccaactttagtacaacgaataatgtccgattaacaaggagtcaatttgtcat
-gaccagttcattcaggtacttgtatctatacggacgcgttccagagtagtatttgaaatt
-ttgaggttctactgataagtttagctatcgctgtatgtctgaataagaatttaatgttta
-tcttcgataaataacaattaacaactcctaggtgatacactgtgaagtctgctgttcccc
-aaattacatatgctattttgttcacataccatgaagttaagctaagtgctctataatggc
-ataaacggttatcaaactagctcgaatttcttttattacgccggaagcggattaactgct
-gtagatcaaacacgttaggatagtgtcgttttcatatatatctaaattcggtctaacatg
-cattacccatgcttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaacc
-aaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgactacccggatcttta
-gcctttagggtctaaacagaactaatattactacgtgtcatactccggagcttaaccagg
-tgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtatcaaattaaccca
-gcaatacaataagcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcga
-aaacttaatgacatagtgtgatgcattttgcactggattgagccacaaactcaactagca
-ttatgctcaatatttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagt
-cttgtagttacaaacgcataaatctcgaacgtaataggtttaattagaacatccgtagga
-tttctgtttatagtagatttatactaaatgttctgattagattctgacggccttacccat
-acaattaataaagacgaatatattagttatagtttactatccaaataaattaagcgaatc
-gaaataaactgtcacgatactgggcagttatcaacttatcacttatacagttcggacact
-ctatattggtctgtgagtactctatcaaactaactcataagttaactgcgcttccattaa
-atttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatgacacatatggag
-atgcataataaaaaaaacggctccatatttctcgttaatcgggcattcttaaggaggagc
-atctcaccaaaaataacgttcctgataagtcttaactattagaccgtcttcgggaatgaa
-cgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattctgataatactggg
-cggacagctggaaattagttgccagtgcacctacgcaaatagtttacataaatcaacggg
-ctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtct
-accgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataac
-tccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactg
-aaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtg
-cacggaataacataacaaggaatattatttattcaaattttttgtgactgttatttgttt
-tctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtcc
-acggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgtcctttagactat
-tcaaggtagaattttgataacgctctataaaaggtagaaaatcatgattgagcaataaga
-ccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgta
-tttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttatgatcagacgcta
-acttgttcttagagaaaaatacacgggatactctgtgcaacgatttcattaataaggtgc
-agcttgggacttttttggccgtaggctttattaacattcacagtaggtagcgagacttcc
-tatgaaccaatcatgccacgcgttttaacgtttcaaatataagctaggaagcgtttgcca
-ggacttctataatgcaccgttttttttagtacttccttactagccttagtttatgttaga
-gtctttccaattacaaaggattgaatagccaaaatttctacaattctcagcgaacgccag
-cttaatctaaacacgagcttcaaatattctacatatcggcaggagtcaatatataaatat
-gaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataattaaatccttttt
-caattaccacagtacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtc
-ctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttc
-tgacgctagagcttaccattcgttaaacagataactaaaatttaatggctgagtgactta
-gtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatttttaaaaacata
-tgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtaccatagaagtatg
-tataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcac
-acttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaactctacaaggcatg
-ggatgagattctaccgactccggataacactttacgatcgcgcataactctagctcttag
-ataagtttaacttgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatc
-catcctctatcttctataatcatctgaaccgcgatacggcactatgagccaagtgaagat
-tgaatccaagaaagctataattggtttattttagtccatttaaattaagtccggtataag
-tgctctgtacaatatgcagtctcatgggcatatacgttaactaccttttgatacttcgaa
-ttggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaattactctttcct
-gttacatacgatctcttagtttggacaactagcccatgatggcgctcctctagcgcatga
-acctactttataattacatctttatcgatgaatttttttagactgcggaggccttgagtt
-ttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttg
-gaacaggcaccgaaaatattgatctactattgcgtcaactctattctgctaatagcgatg
-gcaaatcacagaagccctcttagtgacaatagttgtcaactatatctaagtcgaccttta
-ctgtatcaacgatcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaa
-aggatttgtcgacggtaaatataatacttgttaagggtagcgacacaggtatactttggg
-tgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttccggtaaccagga
-aatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactccttcttttcgttg
-cagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttcagatggtaggag
-ataccatttggcccattgtgactttacgcgattaattaaccgacatacatctgttcctga
-gctatgatcgtctgaataaattacggtctcctcttgatacctaatggtttctggagacgt
-ttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagctacgcagagcatc
-aaaatatgtatgggaaagtcgatttccaaaccagaagggataaagagaaataacggactt
-ctccgtagattagcctgatattttgatgggaatcatggcggcacatacgtaagagttgcg
-tgaacgaatattttggacggcgggagacacatatcggccattcgttaaggtctctatatt
-ggacatcacaagcttagcagtatgagctactaacactcaagacattattgattttttcaa
-gatatgtttcattcctctaccgctattcccatacgttcgattcgccgggtgagcgaaacc
-acgggactgaggttaagctaatcaataacaactcgttgcgatagagacctatgtatacta
-gagagaattccccaacatttttacaaaaacaaagcagactaaaatagatacagtccctcc
-atacaattaggaccaacatgttattgccgatcctagcacacacaccacaaactcagaact
-tctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaattagcattaata
-ttaaaactaattaggataaactataggtacgagctttactataagtcactaggtgttttc
-cgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataaagaaaaaaagga
-aggtacgtgactaatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaa
-gtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataaagttggactcca
-tcatttagaatcatagggaccaaaacatttatttgctactgtcactttgtaggtgttcta
-ttctgaattcctcatattgatacatgaatcggaatacctgtggatcccttaggacgcacg
-tgctttctttacgtcagaatacatattgtcagaatcgagaagttccatgcaattaagaat
-tcgcctctttgaaaactcatatccccacatatagggtccaccgttattcggaaacgatat
-aataattattccagcgttgagcgtcccttaagagcgcattttcgcttggcctttcttcta
-cgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcaccccatagaacta
-cctctgagagcgcgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgc
-gcattaaccagtcatattaaaatggactgtcttaattgtcggcattaggagcaatattaa
-ctgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagata
-cgattacagactcagatcccctaacaagcaaaacgattaaatcggaatcactccccctat
-gacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctcaaccgcgcttta
-taagatgttgagtctgagaattagatgacctaactgcaagaatcatggcgagtttatcta
-gtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggactt
-agatgataaccaagaactggtttaccgagtactttcactattaggagtaattacatgcgt
-tcaccgcggaatacgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttg
-cattgcaacagtcgctaccagtaattgctgatcaattatagattcattatacagatgctt
-acttttctctattcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgc
-ctagtataatcttgcttccacttgaatcaatgcgatggacagtattctactgattgcaaa
-gtagtctatttcggcttagcagtacgcatgcctatttttttgcaggcacagaataatatg
-caactaggattctcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatct
-acgaagttgatgtttactacagaaagcgaatgatatcacttggagaacattttagatgcc
-cccttttaatctagactgagtgtaccaatatatcaccggtctaccgaatcagcttgaata
-aaccactctagtactcatgataaccgagcatacacatgtatttctcaatgcactgaaggt
-gaactgtttacaccataccttgcgaatcaacgtggcgacttatacttctgtctttgagta
-cagcacaccctaatgaatctaagttagttgttgatacgaattgtaatttgactggatctc
-gcctcctcatctagattcttagagaagatgtttcttatagccggtactgtaactttattg
-atctggtttatggtaatcaacattttacctctatttaaacgtccttgcgccgtgcactca
-atcctgatcggtttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcac
-agagtaagctctctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaa
-ctctcattgtgttgattcagtaatacaagattacctacgcttctacgaaatatactatag
-atttagcctacgtcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtgga
-ctgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtcgatatcaatggg
-atacctcaaacgtctttatctctggataactcacattgagtataccggtaaaaatttatt
-ctattcatctaaatagtcagtgagggctagggtcgcaatcacattaggccacatacacat
-acttaacatgttctattgacccgacccaactttagtagcattgtagccgtttatgcaaat
-atgccaggcgccaaacactagccagagggcattttgttacatttatttaatcgattatta
-cacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtcaacaattcagta
-atttaatccaaaacctaaagtcagagacatgacactaaaatcacattaaggtcagttagt
-gaaggaatggctaaccagctagagaatgcatcattaacaggcacttattgtcaaatattt
-tccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaacacatcagtcca
-ggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcg
-ggacttagcagacactggatgcagtcatagaagatcttgcataacacgttagggttagag
-ctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaa
-cacgtttgtgatttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaa
-aaatcgcaattaacatacgttgacctatttttgttcagagttcagttagagcctaatgat
-tcgagagcaataatcaggacagcctcataggaagtgtcaatcacttagaagctatattat
-tataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaac
-tggcttaacaatatgatacataaaaatattttcatcaccactaagacggtggaattcaga
-cttattggcaacttaggatgggactattaaataacccataagatgttgggataaagttac
-gaaacgaaagggatatagcctgttagataggaaatccccaataaaacatagccggcctcc
-acagcagtgatctattccgccacgcgatatctttataccacgcaatataccaataataaa
-ggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccg
-tatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagcttcctctgcaaga
-tacaatatgactttttagcttttttactaccaaatctcagaatcttagaaacaggttggt
-acgtgctactcggaattcccaaagtaccctgctatatatgccattccttcattggtccgg
-gctcaccatggggccatcatagtaatagaaggtagtaaaactagttgatttccgactttt
-aacaatcactatcctgacccagatatgggttccgactggcccttactccagtaagggcag
-acacacagacaacgagaacttgataactttgaattctcaaatcgatcattgcaacgtgac
-ttatttactagcctactcctataattcatacgtcaaatacatttcaacggaggaagataa
-taagtaaatattcactaaataatggtcgaaggagtcctttgccaacataagtccacatat
-gcgctatagattttttcttggggttcatattcaataagataaacagcaagagtatcacgt
-cagcgagtcattgagatcttggctagcattgtgatagcatattctacctaaatggtagtc
-tagcacagagtggataagatatcagttagatatagacaagtactataacagatctcgctt
-cgttggattgtatggctagctttgatgatatgattttataaaaattgatccagacctgac
-ctggccaattatattcattttttatgagtaaaaatagataaccatgaaaatactcaagcc
-ccttaggacgtacaaagtggtaacataaatttcaggtgttattctgcaaccacacctgtt
-ttgggttttcaaaaaggctaagcagattggttttacagataatccctgaacactggtatc
-tcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaa
-ctaggcggaaaatatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaac
-gcctctttggattacacagaatagtgtactgacacgtacactgctgcagcagccatacgc
-taacattaaaattcgttgagtctacatttgttgttattcggattatgttattgggaatag
-tatttttattcccctgcgtgaaaccacatggatagattagcctactcctaaagactccct
-tttggtctacggttcaattctcttactgagtttatgttcgtaattatatcggcgcagtga
-atctcctaattatcaccggagttaccagacgccatgaacttatggccagaaacattgcat
-gtggcctacataggattagtatcaagagtttacgtttgcaacgacatttgaccaacttga
-ccattcctgcttgtagaccgcgggaactcccctgcacgcgactatagaagttggtggtgg
-atgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaat
-tgagacatgtataagggctattgccagatgaaaaactgcatataaggtcaaacaatataa
-gaacattatacataggatcttagcgttcctcaggatggtatacgctataaagtctagctt
-cagcagctaaggagttttgccagtgcggacttccgctggaagattaggtttaaccgccct
-gacatcttcataaggtcgggcctgattcaaacccctggagtgccgtctcatacttgaatt
-aatcgatggaaaacttcttctagtctaatattattattaacaaatgacggttcaataaat
-aacaccgtaagggtgggaaactgttaagtgatgaatcattttaacctatcatccattagc
-tacagataatgataccccgatccgactagggggtaagtggttgttccgttaggataaacc
-atgtaaaacgttagagggtttgtagattaattggtattccagataaatgaggtcagggcg
-agtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaat
-gaaggggattcagaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcat
-gatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatatttatcgagtcta
-taaatatctttggttgtatattacttcacaatcaccaattctaaatgattcttccactgt
-gcgggtggagatatcaggacgggttaaggttgacctacatcgttttgatacaacaaaaat
-caaagcacatggctggggacttctcgatactatctttgagatagtacgggcaagagtggg
-tgacgcctccctacattttcaagtctatcggataacttctcggtaaaacgctcgcgatat
-agttttaaagcattgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaat
-tcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggttatccaaaaggaat
-aaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatgcgtatggttctg
-atatatagatcgatgcatgaggacactttattttagccggcgaattaatggaatccatac
-gttacttatttggacatgacttctaggtgtttttgctgtcccgtttagcgatatttacag
-attagtatttcgtttctcatagttaattgtatctagatactaactcgttgaagacgcata
-ccttgccatttgtacaggacttaactgttccgtgcgtaatttgaatttcttataggttct
-tcaaggcacgaatacctcactcatgaccgttcatactctagttaaggtcgggaatactac
-gtatgcagggaattgtaacctaggagatttacaactctttaaacaagagtcgctgaggtc
-caggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatcacctagaaaccta
-ctcatacatttgcaattttgagatgtaggcgaaagagagaaatctgctttttaacggtat
-ctcttgggattccttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctg
-ggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaa
-ggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaa
-gtaaagggggtgaaaatgctccccagggttctacagacatagagatggtcagaacacgac
-ccccctctcaacgcagtgtatttgaaatatatggacatatctaccttattctgtaatttt
-agatgtgttctgtgtataccgatattgataagtcaataggcttgattacgtatcttaaga
-caaatctgtttcgcaagtaggaccgcatctttcagattgtttctttttatgccataacct
-gcccaggaattcaaaaggttatcgatacccgatatgctgtgaattattattctaatggcc
-actcattcctgcttatatctggaattggcatgaatatcttacaacctaaagtctggcgtt
-gcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtc
-acataaaagttcattagaccacactttgtgccgacgtatatagatatattacacgtatag
-ggaatgttttctcctaggtgacccgaccttctactaaggttgtacatcgtataatggccc
-attaactacgaggaaagtggtattgacctggtaatgcacgttcttcgatatataccgacg
-aggtaaagtctactattgcaaagtttgacgttatactgataagtttagatttccctggat
-cgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaaatccttggggat
-actatcgctactatcatcggaccaaaattaaataggctagtgtcttatcagaacatcatg
-tttaccgaactgatctattttccaatttaagctgatattacgtccgcgtatttattttag
-ttccccggatgacgattatctgagctacatcatacaagttagcatactcgccggtgcatt
-gatttcttatttcgctatatcttcaagttcacaggcttcatatagttccaattagcagta
-taattaggttttgtaactttaaccatactttataaaaggttatattgcacaactgatcaa
-gcatccgctataacccgagctttaccagttagcggctaataacaaataagatgacttcgt
-gtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggt
-agtaataagtataaaatgataccacatatactataacaatgaaattatttgtaatccggt
-ttgccaacgtatcccccttcgcgataaattaatgacatagggtcatccatgtgccaatcg
-tgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgttataagcgttga
-aagtgatataggccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttatt
-gctggtagtacaacatcacgagcatttctcttttgagttgatttatactatatctgctga
-tgtgattatgtcccacttacccagaatattaagaaagtcctagattgtaggtatacttga
-ctataaatataatttaagactatacaaataatctggctacattatgccatcgtagaaact
-gataacgtagtaacgtcggacactagattttggtcggggagtaatctagcatactaacga
-atttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgttt
-agactattaaggactcatttcgagatccagtattaattatacgcatccatatttatactg
-aagacggattgagttaggacgacaagctaaacaaatattaagttaaggattagtattata
-ttgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgttacttattcagag
-agacttaattcggttatgactggcagctcacctggaaagtaggtgaaaggcaacagaaga
-atattgttgactgaattctacgggctacgaacgtaattacaaagcggttcgtaaagagca
-taaagatcaatacaatggatctctacagtattacgtaaataacatacataaacctggtgt
-tgattcgactagctcatagattaatcattaattgaagctacgaagacgcggaagtctgcg
-gagtgagcaaacagtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatg
-gtgtacattaacgtgggggtagtcaaaggaatatatttactaggaatattagttatgcaa
-atgttgtgtcaatgtgatgtgttttatccagacattggatgcatggctgtgggggcacag
-gatacttaccattagttcacctacaagcggcgtgagagggtctcagttttagccagcgca
-gagaagtacgggcctttagacgattaatgctagaattgtcataaacctcgtgaaaagcta
-gttaataatcatggtgctagaagaacacaacttttctataaaccagttctcgactgacag
-tcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaa
-atctactgggtgcatcagtagagatcgtgttctgagagataaatacaccggatacgatct
-gcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtagcattttttaaca
-gtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggtttaaagtttata
-tgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcc
-tttatagactgagtgtatcgtacactcggtacaattacaaaggatggaagagcaaatagg
-tcttcaattataacagtaccccaccttaatctaaaaaccagcttcaattagtattaattt
-cgccaggagtatatatataaatatctaaagactaaaagactcgtacttttacaacttacg
-tcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattagaaatactccttt
-gtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgatta
-aggcctataaaactgttgttggtatctacagagtgattaaaattagtgaatcagattacg
-aaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggct
-gtagtagaattttggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaag
-cggtttttgttccatagaactatgtagttggttataaaggttgtaatctcggagattagg
-ttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatg
-agttcacgaactcttaatgccatgcctggacaggataaacaatacgcatataacttgacg
-atcgagcttatatcgacctatttgagaagtttaacgggtcgatataatatacaggtctta
-atagccgattttttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtga
-acgatatatcagcaaactgaacattgtatacaacattcctttttgtccgggtggggactc
-catttaaagtatctcacctagaactcagcggtaatagatgcagtctcttgcccagttacg
-gtaactaaatgttgatacttagaattgctaaattttagtctagacatttccaggtaaacc
-ggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaat
-tgagggccctactatagacaatcatcagactttttaattaaatagttttccatgaatgtg
-ttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgtatgactgtagtcg
-gtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttctaagatggacta
-taatcgattaggctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttgg
-aatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacc
-tatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagc
-ctagagacaaagggatactgggcggggaaacctgctccttcacggtaacatggtaacaac
-agaatttggttaaggttaaaacgaaatatactcggagtgaattactgttaggtttcgtca
-tcggatcaataagtagtttccgtgaagacactcttatattagatctccgaaattctgacc
-cgtgcattaggcacttggtaggagattccatttggaacttgctcaatgtaagccagtaat
-gttccgaaataattcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttg
-ttaccttatggttgagggtcaccgttctctgcgtcaattccagagctggagatacattca
-tcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaa
-cggatttagacaaattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcat
-ggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttcc
-gccattaggtaagctatatattgtggtcagaacttgaggacaactatgagctactaaaaa
-taaacaattttgtcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagt
-tacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatcaataacatatagt
-tcagatagagaacgaggtattcgacagagaattacccaacattggttattaatctatgca
-gaataatttagataatgtcactacataatattaggaccaaaaggtgattccccagaagac
-aaaacaataaacaatctcacatattcgctagtacctatgtatgggtatgatcttctgatt
-ggacggggataatttccaggtatattaaaacttattaccataatctagacctaagagagg
-ttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagta
-aattttgctttaacaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcag
-gtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaa
-ctaatatcataaactgccactacatcttgtacaatcattcgcaacaatacttttatgtgc
-taaggtcacgtgcttcctctgctatgctgatttaatcagattcataaaggaatacgaata
-actctggatccattaccacgcaagggatttatttacggctgattactttttggctgttga
-cagaactgccatgaaagtaagatgtcgcatcttgcataaataatagcacctaatatagcc
-gacaaagtgattccgataacagattttaagttgtccagccttgagactccatgaagaccg
-cttgggagcttccccgtgattagaagaatctaaatcccaagtggatggggggagtttaaa
-tctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcc
-tgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaag
-tgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaaggaagcacgcat
-tgaagcagctacgcagaactgagaagatgacactctaagatacaattaatacaaaaacgt
-tttaagcccaatctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatg
-tcccgatgtataataacagctttatttctgctggtcgaggtgaagtagtggaaattactc
-catcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcgtccatccctctc
-tcctagtgatccgtatatccaattagaggataaccaacatctgcgttaccgacgaattta
-aatttttcgactatttaattccgttcaaacccgtattcgtagtaagtgtttcatagattt
-atgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaattgctgatctag
-gatacatgctttataaacatgcttacttggctattttatttactgtcatgtgggggtttt
-tattttcaacaagtatgtgctaccattggataatctggcttcaaattgaagatatgcgtt
-ccaaacttgtctactgtttgctaagtaggagttgtcccattagaactacgcagcacgtgg
-tttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaatttaatgcagatt
-actcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatag
-aaattcgtgataatttttgttccaacctttgaatctagactgagtggaaaaagatttcac
-cgggataccgtttatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaa
-tggatttctcaatcatctgtacgtcaactgttttaacaataacgtcagaataaaccggca
-caatgagacggcggtctttcactacaccacacccttaggattataagtgacgtgtggatt
-cgaattctaaggtgacgggatctacaagcctcagctacattaggtctgaagatctttcgt
-atagccgcgtatgttactgtttggatatgggttatgctaatcaacagttgacagcgagtg
-aaacggccttgcgacctgaaatctttacggttaccttttgattcaagacaggatcgacga
-tggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaac
-gacaagttcacatcctctatgcaactatcattgtggtcattaaggtattcaagattaact
-aagagtcgaccatatattctagagttttacaattaggaaccgttagtctagactaggagc
-gtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgacacatagtgtctt
-ttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgggataaataacat
-ggtgtttaaccctattaatggtttctattaatctaaattgtaaggcagcccttgggtcga
-aagcacattaggccacatacacagtatgaaattgttcgagtgtccagaccataattgact
-accatggtacacggtgttgctattatgactcccgcaaaactcttgacagagggaattttg
-gtacattgatgtaatcgatgatttaacagtaggaactagacgtcatccgttagactgagt
-tccgacatgctcaaattgtcaggatttttatccaataactaatggctctcacatgtaaat
-aaaatcacattaacgtcacttagtgatggattcgctaaacagatagactatcattcatga
-actggcactgtttcgattatatttgcaacatcgaacatacttaaagttaaatacgacatc
-attcaattaaaaaaattcagtacacctctaatgagtatcccgctttggaggaaagagtag
-cactttaaatggacaatttaggccggactttcctgtaaatggatgaagtcattgtacagc
-ttgaataaatcgttagggttagtccttacatccaccatatgttaatgaataaagcctgag
-ggaccttagagctaacttgtccaacacgttgctcatttacttaataaggttgaaatgtat
-cagtaagtgacagcgagtgtagattttgaccatttaactgaccttcacagttttgtcttc
-agacgtcacttacaccataatgatgacagagcttgtagatgcacacactcattcctagtg
-taaatcaagtagtagctagattattataaagagatattttctggcgtcgaacgtaacaca
-gagagagtataaggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaata
-tcatctaactcggtggaatgcacacttatggccaactgaccttgggacgagttaagatac
-cataagaggttgcctgtaagttaagataacaaagggatattccatctttgtgtgctaaga
-acctatttatatttgcagccataaaaacctctgtgctatgcagccaccagagttatttat
-acaaagaaagagaccatttagatacgttaattctgcttgcgatttattaaacagacattt
-cacgtccaaccactacaaaagccctatcgcaagacgatcattgtattatagcctatgcaa
-cgtagctaagcggccgaggaatcataaaatatgaattgttacattgtttactacatatga
-tcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaactaacctgagata
-tatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtagg
-aaaacttctggatttcccaaggttataatgctctatactgaccaagagatccgttacgac
-tcgcaatgaatactctaagggcactcacaaagaaaaccactaattgataaatttcaatga
-taatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcat
-agaaatgtcatagcaggaacataattactatattttaacgatttaatcgtagttggagtc
-ctttcccaaattatgtcatcagttccgatttagatgttttcgggcccttcttagtaaaga
-agttaatatccaagactagctcctcacccacgcatgcacatattcgcgagaagtctgata
-gaatattcgacagaaatgcgactctagctcacactcgttaactgatcaggtacttataga
-caagtacgttatcagatatcgcttcggggcattgttgcgctacctttgtgcatagcagtt
-ttgaaaaattgttcaagacctgaacgggaaaatgatattatttttttaggaggaataata
-cagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaacatatatggcacg
-tgttattcggctaacaaaactgttgtgccttttctataaggataagcagattcgttttaa
-acatatgacctgtaaactgggatctacaaaagaggtacttaaaataaattgcgcaacggt
-ttagatctgcggatctttggttaaagagcaccattagatgtgccatacttcctatcgcct
-gagcgagaatttagtctgaggaaccactcttgggatttaaaacaattcggttaggacacc
-tactcggcggatgaagcaatacgataacattaaaagtcgttcagtctaattttggtcgta
-gtacgatgagctgatggccaattgtatttttattaacagcactgaaacaaaatggagact
-ttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatc
-ttcggaagtatagcgccgaagtgtatctcattattataacaccagtgtacagacgacatc
-taattatggccagaaactgtcattgtgccattaagaggattagtagatagtctggaccgt
-ggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgca
-cgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttac
-gattctagtgcttcttaacgcaattcagtcttctagatccgctattccaacatcaatatc
-tcaatttaaggtcaatatatataacaaaattagacagagcagctgacacttacgaagcat
-cgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagtccgcacttccga
-tgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccact
-cgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctactattagtttatta
-tgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaat
-ctttgtaacagttcataatgttgctaaagattatcagaccccgtgaagacttcgggcttt
-gggcttcgtaccgtagcataatacatctatatagttagaggcttgcgtgttgttgtgcta
-ttccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcga
-cctacttgttaagtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgt
-atttattatactgtaggcaagaagcttttttggcgagatttaagacttaagcctatggta
-aaaatttgatagtgagcgactatagtaagagatttgggtggttagtaattaaaattctcc
-tatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccg
-aaagcgtgtggattatacaaatttcaaacatattggcggggcacttatccataatagatt
-tctgtttgtacgccaaactctgcctcacccctccataaattgtattggctagaggttaaa
-ttctccgtaaatagagacacatatagttttatacaattgtttgaatcaaagcacgagaaa
-cttttaaccgtacattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaa
-atcaatcgctgagcaataagcaagaaaacacagattatacaaagagatctggatgaagat
-attcgtgcaatcactatcgttatgttagagagttccatgcatgaggactcgttttttgac
-caggagaattaagccaagaaataactgacgtatttccaaatgaattctacgtgtttttcc
-tgtcacctttagccagtgttaaagatgactatggagtttcgaataggttattctatagac
-attataacgagtggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcag
-gtagttcaagggattttaggttcttaatccaacgaagaaataacgcatcacccgtcattc
-tattgttttcgtcgggattacttagtaggcagggtattctaacctacctgagttacaaat
-ctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtcc
-ctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgacttcttcccctaaca
-cagaattctcagttttatagctatctagtggcattcctttttataaaactttacgtttgt
-aagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagactt
-ggaacccatgtatattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaag
-caaggtatgttctaatctaacaatgtaaagccggggattagccgccaaaggggtctaatg
-acatagagatgctctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgac
-agatcttccgtattctgttagttgacatctgtgctgtctttaccgattgtgatttggctt
-tagcagtcatttagtttcgttactcattgctcgtgcgatagttccaccgaatatggcaca
-ttcgttctttttttccattttactgcaaaccttttcaaaagctgatcgataccactgatg
-atggcattgattagtcgattggcaactatgtcctgcttatatctccaattgcattgaata
-tagtaaaaaataaaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaac
-tcgtttaaccaagcgccgtacctaacatataagtgattgagacaaatagttctccagacg
-tattgagatatatgtctcctataggcaagcgtttctaattgctgaccagaaattagaatt
-aggttgttaatactatattcgaccattttattccacgaatgtgctattctactggtattg
-ctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaa
-tcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggtatctgccatattg
-ttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaaatattaatgagg
-attgggtcgtataagaaaatcatcttttcagttcgcagatttttgccaatttaaccggtt
-atttcgtcagacttggtagtgtagttacaagcatcacgattatatcagctacagaattaa
-actgtcctgactcgacggggcagtgtgtgagtattgcgctatatattcaaggtaacagga
-ggcatataggtcatagtacaaggataatgaggtttgctaactttaaaaattattgattta
-acggttgattgaaaatctctgcaagatgacgctagaacacctgatgttcaagtttgccga
-taataacatataagatgaattactgtctttagaccctcatgttaatccgctaacttaggg
-cggaaacaatgttaggctatgcggagtaagtactatattatgataccacatagaatttaa
-cattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaa
-ttacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaaggttcagctatt
-ttggcaatgggtgagtaccgttcttagtgatttacgaacccataatctaggcgacttaat
-atacaagatttagagttacgttttccgggtagtacatattaacgaccatggatcgggtga
-ggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccagaatattatgttt
-ctactagagtgttcgtatactggaatttaaatattatgtaagactagacaaattttatgg
-atacattaggccatcgtagaatatgatatagttgtaacgtccctctatagattttcggag
-ggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggatttgtaattaact
-gatgcgcagcgcttaaataagtttagactattaagctatatgttcgacagcatgtagttt
-tttttaccagaaagtgttatactgatgacccatggaggtagctcctcatgataaaaatat
-tgttacttaagcattactattatagtgttcaaactagtaccgttgcatactttaagaatc
-agacatggcgtttcttatgcagacacacttttttagctgttgacgcccacctcacatcca
-tagtaggtcaatcgcataagaacaatattctggactgttttattacccagaagaaagttt
-tttctttccggttcgttaagacaataaagatcatttcattcgttctcttaacgatgaact
-aaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaa
-gataagaagaacaggaacgcgcacgtcggagataactctaatagtctctttattccgttt
-aatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgcaaacctatttat
-gtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttttatcaagacttt
-cgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggag
-tcgctctaagtgttaccaacccctcactactacgcgaaggtactcgattattccttgaat
-gggctgaaacatcgtgattagcgtcttatgattcaggctgatagaagaaaacttattttc
-tatattccacgtatacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgct
-ataataaataaaatacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtc
-acataaataatccgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaagg
-tggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaatatcataataga
-tgccatacacggttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtt
-tcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatg
-acttaggatggatgagcatttaggtattctatgataacactaaccatcatgtttctaaaa
-tcctcaggaaatttgtattattttaccaacctgtatttatagaaagtgcttttgacttaa
-agaagccgaagtgttcaaattaaggagtacctgattgaaagaatggggaattgtaatctg
-taactcaattacaaataagccgttctaaggattaaggctttgtgtctaagcaactcacgt
-gaattcgaaattcatactcgattaacgactttaatactcttctgcgtatctacagactca
-tttaaattacggaatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaa
-taaggacacctggtacaattggctggagtacaatgttggtttttatttgctgattatccc
-gatccctgtgggcgttggcataaccgggttttcttcaagactactttcgtgttgcttata
-tacctggtaatatcggtgagtagcttagggcttaatcacaatactaacaagttctctatg
-gattggacagggcggcatccgttgactgaacgatctattaatccattccctgcactggat
-aaacaagacccatttaaattgaccatagagatgttagcgtcatatttctgttcgtgatag
-ggtacatatattataaacggattatgagcagtggttttctagaaaagcattcatagttag
-gagtgtatcagatcataccactgaaccatagagcacaattctctactggctatacttcat
-tcctttttgtccgggtggggacgaaatttaaaggttctaacctagaacgcagagcgaatt
-gatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttg
-actattgacagggcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagat
-agagtacgggcctataattcaaattcagccaccgaagattcacaatcttcagacgtttga
-aggaaagaggtttactggtatgtggtgtcaagccccacccattctctgttatatccgagc
-attaatgtagtttcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaac
-aatttaggctgagaagtggcactataatagtttagcctaagtcccttcgctaataactca
-acaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatact
-gatagctctcatggtaccaagaactttcataacctctttatttaccaaacctgttctact
-agcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcg
-cctgcaagctaacatgggatcaaaactattggcttaacgtttaatcgaatgagactagca
-ctgtattactctttcgtttcggcagcggatcaataaggaggtgacggcatcactctctta
-tagtagatatcacttattctcacaacggaagtaggatcttccgtcctcattaaatttgca
-actggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggtcagagcagacga
-tgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaa
-attccagacctcgagttacattatgaaacgtgtcattccatctcattaaatagttcgtgc
-cctatcgccttgtaatataaacaaccgtttttgtctattttcccaaggagaaggagagta
-gcagcttagtggcttgcctatatggccccctaagtacgtactcggcacgcttagaagatt
-gggctaccccgcactatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattc
-aggtcatcgatgagagtataaaaatatacaattttggcaggggttatacattgcgggcat
-gaagagtaacattggacatgaacggacattcgaaccctgtgagtttaataccctatctcc
-ggatcattataaagtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaa
-ctaaattggttatttttctttcatctagatttgtctgtatctaactaaattatagttcca
-cataaagctgattcaactgaagacataaatataaactttctaacatagtagcgaggaaag
-agctatgcctagcatcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttt
-tccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtgaacatacataata
-ccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcctacgtaaggctat
-ttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtaca
-ttcagatctccttagtatcatcaaattatagattttacggccacgaattattggtctaga
-tgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaag
-aagagtcattatgctataccaagaactctccatccagtacctagaaaggcaggtatgtac
-cgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggct
-tttataatagaaactaagtttcccgaataacggtgtacgataacagatttttaggtgtac
-agacgtctgactcaatgaacacacattgggacctgccccgggaggagtagtagataatta
-ccttctccagcgcgggtcttttaatatcacaacataaaaatactaattaatatcacacac
-cctcatcctcgatggagcctagcatcatacacgtttgatagacaacgccaattttactgt
-aatatgatattcgaatctagtatgtggacgctgtaccacattgtttaaaggagctccctt
-taccgacatgaacgaagcaagctttgtacaagatacgaagaactcagtactggtaactat
-aagagacaatttatacataaaagtgttaagaccattatataaaaagaggtatgaggtctt
-tgtaactacaataatacattcatcgaacgatggagaataacagagttatttctgctgctc
-gagctctagttctgctaatttctcaatcttgatgccactcgtttgagtcttccattcgct
-cttaacgacgcgtacatccctctctcctactcttacctatatcctattactggttaacct
-acatctccgggaaagacgtaggtaaagtggtccacgattgtattcacttataacacctag
-tagtactatgtgttgctgagagtgaggacacacttactctacgagttcaagtccatatgg
-acattacactttttcagcatctaggtgtcatgatgtattaacagccgttaggggctattt
-gattttatcgattgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaatag
-gcatgaaaattcaagattgcagttcctatcttgtataatctttcctttggacgagttgta
-ccatttcaactaacctgcaagtggggggtcatccatatgaagatttgccaaatacctgga
-gaccctgaaaagtttatccagattaataataacaaacaaacctaagcgaagaacgtcagc
-tttaataaactatcactatcatagaaattcctgttaattgttcttccaaacgttgaatag
-actatcacgggtaatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcg
-aatctgctgataactcaattatattcgatggagaattcatatctaccgcttagcttttaa
-aaattaagtcagattattccgccacaatgagaaggcgcgagtgcactaatcaaatcactt
-aggattattacggacgtctgcattacaatgctttggggtagggttatacaagcatatgat
-tctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatc
-ctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacct
-gttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaaactctaacatag
-cgtggcactatgagtacgtgtaacgacaaggtctcatactcgatcctaagataattctcg
-tctggaaggttttaatctttaactaagagtagaacttagtttattgacttttacaattag
-gatacggttcgcgactctaccacagggcatcatacctggagctctgctatctcgtgacca
-aagtggcagcacacatagggtcgggtcctgcatctactgagcaatccctttaagcattcc
-tagtttgagagccatttagatattgctgtttaaaccgattaatggtttctattattataa
-agtgtaacgctcccattcgggacattgaaaattagcaataagacaatgtatgatattcgg
-cgagtctcaacaacattatggtctaccatgggacaaggggttgatatgatgaatccacaa
-aaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgttataaggacgatc
-tagaagtattcaggtacacggtgttcagacatgctctaattgtcaggttgtttataattt
-aacgtatcgctctctattctaaataatataaaattaaccgctcgtagggatgctttccag
-taaaagatacactatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtac
-attcttaaacttaaatacgtattatttaaagtaaatatattatctaaaccgcttttgtct
-atccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatct
-aaagcgatcatctatttcttctgattgatgtaatactgacccttactccgtacatacaaa
-tgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctg
-gtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcattttgacaatttt
-tctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgt
-agatccaatcacgctttcctacgctaatgaaagttctagatagtgtaggtgttagacaga
-ggttagcgcctacatccttacacacacagtgttgaacggcaagcataatcgagtatcaat
-agctgtatgtatttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaa
-tgtcctgccctagagttatgataaaataactgctgccctgtaacttaagtttacaaaccg
-atattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgc
-gatgaacaaaacacagtgatttataaatacaaagagtacatttagttaccggattgcggc
-ttgacatttattttacagaattttatcggcaaaacacttcatatgaactatcgcttcacg
-ataagtctatgatagactagcattcgtagagaacaggaagagcaatcattatatatgaag
-tgttacagtgggtactacatatgagatcattaggtctatatccggccttcctcataagac
-cttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccc
-caaagaatagtaattcatcggacgtaatagtctggttttaactaggggttattgatattt
-aagctaaaagagttccctgaacactcgaaatgtataatctatcccaactaaaaaagtata
-cctctaattcagaaatgtcattgagattagactgatgtcaatacgctaggaggtaagaca
-agtagaagtttttgatttaggaattgaaatgtaatacctccatcttaagttctatatttt
-aaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatg
-tttgcggccccgtatgagtaatgatctgtttatcaatctctagctactatcccacgaatg
-cactgatgccagtcatggcgcttacattagtcgacagaaatccgacgatacctatcacgc
-gtgaactgttctggttcttattcaattcgaagtgatctcagatacattacggccatgctt
-gcccttcatgtctgctgagcagttttgttataggctgaatctcctctaagcgaaattgat
-aggatttttggtggtcgatttagtctgtacctgcttattaagattcaaaatgacctactt
-cttacgccgaaatgatagggatcggctgaggaggataaatatacgctggtgcctggtatt
-tatccagaacaagttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggt
-acgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtatagtccaccatta
-gttctgacttacttaatatagactgaccgagattgtagtatgtggatccaagcttgccat
-gtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaagagttaattaatag
-tactgcactataattgtcggcggagtaccatgagctgttgcccaattcgatgtttattaa
-cagcacgcataaaaaatccagacttttcaattagaattaactataaatggtccgcgaacc
-ttaaatgatcggaaggacgggatctgccgttgtatagaccccaactctatctaattttta
-taacacctctgtaatcaacaaatcttattatgccatcattatgtcattcgccaagtaagt
-ccagttcgagattctctggaccgtgcaatagtattgtcaaattatggtaatggaatcctt
-cttctaacacccttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagc
-aacataagtgccgtttctttttacgatgatagggattcttaaagcttttctctattctag
-atcccagttgccatcatcaatatctcaattgatgctcattatatagttcttatttagtat
-gtccagatgtcactgaagatcctgcctagaaccgatattctcgacaggatcatcagttcg
-acggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagt
-accgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagttttactgccttt
-aattagtagtcgattagtgtagtttgatattatctaccttatagaatgtaaacagtaacc
-cggccttaatggtttggcaggattctttgtaaaagttaataatgttcataaactttatca
-gaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacgg
-agtggcttgcgtcttgttgtccgagtacacatattgctcctctcccccactcttctagga
-aaatcaattatgctaacctgcagaccttcttctttactatctttaatgcatgcccagtat
-gttcatagggtagacttgctatctattttgtataatctacgaatgatgcttggggcgcga
-cttttaacaattaagccgttgggtataatttgagagggtgccacgatagtaagagatttc
-cggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagctcaccctcctcag
-ttctccaaccctgaaccggctaagtatgactgtgcagtattaattttgaatacatattgc
-agcccctaggatacattatagatgtctctttcttacccaaactcgcccgcaccaagaaag
-aatgtggattcgattgaggttaaattagccggaattacagacacagattcttgtttacaa
-ttgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatggattacgttggg
-gatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaagaattcacagagg
-attaatacacttctccatgaagataggactgcttgcactatccttatctttgtgtcttcc
-ttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataacggaaggtgttc
-caaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggac
-tttagatttgggtattctagagactgtagaaagactgcaacaacaagacattcacagggc
-gaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttaggaatccatacat
-gtaagaaagaatcaaccgtaattatagtgttttcggccccttgaattacgtgcatgcctt
-tgctaaaagacctctgggaaatagattgaatattctggacagcagcgaatcctgattata
-tctcaagcgaatatatgacccgcaagaaggatttatactagaataagtctaagaaagggc
-attgggtcacttcttccactaacacacttttatcagttttataccttgagagtcccatgc
-atttttatatatatttaactttcgttgcgtaaaactttaaatatgatccgtgctctatct
-ctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaag
-aacggtttcttctgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgc
-attagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaa
-caacgcgatttctatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatg
-tcttttcagtttgggttttggatttaccagtcttttagtttcggtactatttgatcggga
-cattcgtccaaacatgatggctcattcgttctttttttcaattttaatcaaaaccttgta
-tttacctgatacattaaactgagcatcgcatggaggtggagattcccatatatgtaatca
-tttgatatcctattccattctttttagttataaataaacgctccactgcacaatgggagt
-aggacttcaccaataattagcatctactgtaaacaagcgccgtaacgaaatgattactga
-ttgagaaaaataggtctcaacaacttttgacagatatgtatccgatacccaagcgttgct
-aattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaatggttattactc
-caatgggctattctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgt
-agtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaa
-atcgatcacggtgatgaattattgttattgtttaaaagaagtcccctgaatagcccttag
-ataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgc
-agagttttgccaagtttacaggtgatttactaacacttgggagggtacgtacaaccatca
-cctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattg
-accgagttattaaacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttg
-cgaaatgttaaatttatggttttttccgttgagtgataatagctgcaacatgaagatagt
-aaaactgaggttaaactttcaccatattaaattatatgttcaattacgcgatgtacaaac
-taatgttaatcagatttaggagcgcgcttaatatgggtccctatcccgactttgtacgag
-attttgataaaaaatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttg
-aaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcctggctcaatatt
-tataatagtaatggttaagattgtggcccaatcgctgagtacccgtcttacgctttttcc
-aacacataatcgacgagaatgtatttaaatgtttgagacttacgttttccgcgtacttat
-tattaaagtcattggagagggtgtcgtctgggtgtagttttctcatctgctcaggagcta
-aaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggctatttaattttta
-tggtacacttgaatatgtttagccataatgtagccaatactacaatatcagatacttgta
-tacgacctatagacttttgccgaccgctcgtagagtgatttagaaagatgttcggatagc
-acagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgc
-tatatgttactctgaatgttgttttttttaccagaatgtgttataatgatcaaccatgca
-cgttcctactaatcatataaattttgttacgtaagcttttctatgatagtggtctaaaga
-ctacccttgcatactttaagattaagacatgcactttaggaggaactcacacgttttgag
-ctgttctagcccacctataagccattcgtccgcaatcccataactacaatagtcggcaat
-cttttattacccagaactaacgtttttatttcccggtacgtatcacattaatcttaattt
-aatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgcttcttgagaatac
-agattactgttagaatgaaggcatcataactagaacaccaacgcgcacctcgcacattac
-tctaatagtagctttattcagtttaatatagacagtatttgaaccaggcgctaatgttaa
-ggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatttgcggggcgata
-gcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacag
-ttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccg
-aagggactactgtattccgtcttggggatgtaacagactgattacagtcttatgatgaag
-cctcattcatctaaaattagttgatttattccacggatactatcacactcctatagaaag
-agttaccaccgtgggaagctagatataataaataaaagacatacaatattagtatggctc
-atgatctacacttactcggatctctctttttttataaccagtagatcgcattacacgtat
-tgttgttccgcatcaggccctaggggctcaaacttccatggtggataactaaaacgtccg
-tcactaaacgaagatattaatagatgaaatacacgggtttacttgatttctgttcagtca
-ttcacgggaaatcctaggagtctttcataacggcggtcttagtaggaatgtagtcaagct
-ctgtagaggtctcgacggaattggtatttcctggcatcacaatttacctagtattggaga
-tcacttaaaataatgttgagataataatcaggatatttctagtatgtgacaaacctctat
-ttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaacgactacatgttg
-gaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtgctttcgtttaag
-gctttctgtctaacattctaacgtcaattcctatgtaatactactgtaaccaagttatta
-ctcggctgcgtagataaagtctcatgtaaatgacggtttatctgttacttttgggtttca
-acctagctaggacgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgt
-gcctttttatgtccggattataaccatccctctcccacttggaatatcaccgggttctta
-atgacttagttcgtcttccttattttccgggtaagatcgctgtggaccggacccattttg
-atctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttag
-attaatcaatgcactgcactggattaacaagaacatgttatagtgtactgacacatgtta
-gactaagaggtctgttcgggttagccgacttatatgtttaaccgattttgacaactgggt
-tgagagataacaatgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctc
-aattcgctaatggcttgaattatttaattgttctaaccctggcgtcgaatttttttggtt
-cgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcg
-gcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaagctactcgaatt
-ggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaa
-gagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtggtctataccacc
-aaaaagtatatgggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgta
-cactaggcagccctaatccaaaacttttgaggatgagtactgccactattatactgtacc
-atttgtaacttacattttatatcttcaaagaggtagatattgtcggccattactgtcact
-tacactaagggtagcttgattactgatacctctcatggtaaaaagtaatttaagaaccta
-tttttttacataacctctgctactaccgttagtgttttagtcggttcaagtcacaaaatc
-cctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaaacttttgccgga
-accgttaatcctatgagaataccactcttggaatcggtcctttaggctgaggatatagaa
-cgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaaacgcaagtacca
-tatgccgtcctcagtaaattgccaaatgcagaaatcttacactcttttcttaactaagta
-tgagagcaacctcactcctgaacagcttgttacctaacgagaagaggctttaagtagcct
-ggagcctcaaccggatatccggatttgactctcatccacttacatgatgattacggtcat
-tacatctcatgattttctgagtgccctatagactgggaatttaatctaccctgtttctat
-ttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatgccaccataagta
-agttctcggaacccttacatgattggcctaccaacctatatatgtgaccaatgtacggta
-catagagtgtggcctatcatattcaggtcatcgagctcagtatttaaagattatatggtc
-gctgggggtattcagtgcgcgatggaagactaacattggaaatcaacggaattgacaaca
-cgctcactttaataacctatctcaggataagtttaatgtaattagacggaactttctcta
-actccgtgtactaactctttgaaaataatgtgggtatttttatttcatctagatttgtct
-gtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtcataaatataaaa
-tttagatcttaggacagaggaaagtgctttcccgagcataggatctggcctacgccagta
-gttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagggtagtgttcgat
-actcagcggggaactgacatattacactaaggaatcaaggcccttcgtatgggtcatgtt
-tatatatttaattacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatg
-caggatgcgattcgagtttgtaaattcacagatactgtgtatcatattattatagatgtt
-aaggcatagaattattggtattgatgtacaaaaaattatgggtgggcagtaccgataggc
-attacgagcagtgcagcttggaagaactggatgtatcctataactagtaagagccttaaa
-ggtactacatacccagggatgttaccatcattaatttggccatcttcaatcttcgcaatg
-catactttcttctacaagatgccttttagaagacaaaataagtgtcaacaataacgctgt
-aacttaactctgttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgc
-aaacgcaggactactagattattaaattcgccagcccgcctcgtttaatataacatcata
-aaaattctaagtaatatctcacacactaatccgccatcgtccatagcatcagtcacctgt
-cttacacaaacacatgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaa
-ctaattgtggaaagctgctaccttgaacgacatcaaccatcctacctttgtacaacagac
-caacatctctgtactggtaaatagatctgaaaagttataaatataactgttttcacattg
-atagaaaaacagctatgtgctatttgtatatactataataaattaagcgaaacatggaga
-ttaaaacagtgttttctcatcctccacctcttgttctgctaatttataattcttgatgcc
-actcgtgtgagtcgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaa
-cgagatcctatttctcctgaaaattattagcacggtaactcctagggatagtggtactag
-ttggtatgaacgtataaaaacttgtactactttctcgggatgtgagggagcaaactatta
-ctcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatacctgtctggatgg
-attatatgcaggtaggcgagagtggattgtagcgatgctcggcgggggtattttaaaaat
-ctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgat
-tagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccat
-atcaagttttgcaatagtactccagaccatgaaatggttatccagattaataataactta
-atatactttcactacatactcagcgggtattaaatttcactttatgtcaaaggactctta
-tgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaactt
-gatcagccttgtaaaatatagtagaatatgatgttaaatcatttatattccagggagatt
-gaatagcttacgattagctggtataatttaactcacatgattaagcaaatatctgtagga
-ccgagggaaagaataaaataaagtaccatgagttcggaacgctgcattacatggcgttgg
-gctagcctgatacaagaagatgagtatggagctctcttcatcgggacgtgacaaccctag
-cgtaatcttggcagatcccggagcagatgattatcgtctaacactgtctttaccaatgca
-caacgcatagatttaacctgaactgttctggattcactcctgactacagcctacaactca
-tttctatgcataactcttaaagacagtcgcaatatcagtacctctatacacatcggatca
-gactagatcataagataagtctcctctggatccttgtattctgttaagtacactacaaat
-ttgtttagtgtctgggacaattacgataagggtcgcgactagaccacagggcatatgacc
-tccaccgctcctagcgagtctccaatctgcaagcactcatacgctaggggcatgaatcga
-ctgtcaatgcactgtaagatttacgagggtgagacccatttagatatgcctcgtttaacc
-gttttaggcttgataggatgagtttgtcgatccatcaaattcccgacattcatattgtcc
-aataagtatatctagcttattcggactcgctaaactaaattatggtataaatgccgtcaa
-ccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggccttatggcagcg
-tatacagctggtataacgaccatatacaactatgaacggactagctgtgaactaagcaga
-ttattggatccttgtgtataattttaagtttcgatctatatgctatagtatagaaaatgt
-tccgatcgtacgcttcctttacagttaaacagtctatatcatgaagcttatccaaagctg
-gacatttgatggcaatcttacttaattatgaaacttaattacctattattgaaagtattt
-atatgatcgaataagatttgctctataaacaggtcgtccattcacgacctagtgattgcg
-taaattgaccaacctaggtaatctaaagcctgcatctatttcttatcattcatgttatac
-tgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcaca
-tttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctat
-cccacgcgtcattttcaaattggttatctacggataactgtgcgatgaactactataggt
-caaaattatcttcaatctcattctagatcatataaagatgtccttcgcgattgatacgtc
-tacagtgtgttggtgttacacagagggtagcgactacttacttactaactctctcttgat
-ccgcaagcataagccaggttaaagtgctctatctttttctgtggattataatagttatac
-cgccttgcatctaggtgcccattaggtaatgccctagtgttttcataaatttactcctgc
-catctaacgttactttaatttcccagattcaataggtctctcatttgaaaattgttatat
-gtcaacaaagaatataatagctgagtggaacaatacactgtgagggagtaatacatactc
-taaattttctttacggtttgcgcctgcacagttttttttatctatgtgatccgcataaaa
-agtaatttcaacgttccattcaagttaagtcttggtgacactagcattaggagagatcac
-caagaccattatttatttagctagggtttaagtcggttagaaatatcagataatgaggtc
-tttatccggccttacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaag
-tatggccgaacccacataatgcacaaatcaagtcgatttcttccgtccttttagtctcct
-gggaactacgggttattcatagttaagctaaatcagttaacggaactagacaaatgtata
-atagttcccaaatatatatctataaatcttatgcagttagggaatgcagatttgaatcat
-ggcaatacgctagctcggaactcaactacaagtgttggatgtacgaattcaaaggtatta
-catccttatgatgttcttttttggatacttttatgacgacttccacgaagtgaaattatg
-ttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgttctgtttataat
-tctcgtcataatataaatacaagcatatgaggccagtcatggagctttcatttggactaa
-catttccgtagagtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgtt
-atcagatacatgacgcccttgcgtgacattcatggctcctgacatcgggtcttttaggct
-gaatctaatctaacccaatttgtttggattgtgggtcctccattttgtctgttaatgctt
-attaagattaaaaatgtactacgtatttagacctaatgattgcgatacgctgtggaccat
-taatataagctgcgccaggggatttttccagatcatctggcctgtgtatatgttcaaatc
-taatagccgagagaaattactccgacggaaaataaaggcagataagcgtttcagagcacc
-atcgtggcgtttagtcaacctttagttcggaatttattaatatacaatctcactctttgg
-acgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcat
-catcaaagaacagttaaggaatacgactgctctataattgtccgaggagtaccttctcat
-ctgccaatagtcgttgggttggaaaacaacgcattaatatgccacacttgtcaattagaa
-gtttctataaaggggacgagtaactgatttgagacctagcacggcagaggacgttcgtgt
-gacaacatctctttataagtttgagataaaatcgctaatctacaatgattatttgccaat
-cattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaaggccattactatgg
-tcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaaacactattgaat
-actgccgccgcattcgccagcaccaacataactgcacgtgcttttttccatgattggcat
-tatgaaagatttgatctatgattcttaccagttgcaatattcaatttagcatgtgttcct
-aattattgtgttattatggtctatctcatcatgtaaatgaagatcatgacgtcaacacag
-attctagtcaggatcatcagttcctcggggaaatcgcacctaggaacagccttatgcaac
-cgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgag
-atgtacgaatcgtttactgccttttatgaggagtcgagtactgttggttcatatttgcta
-catgattgtatgtaataacgatcccgccctttatcggttcgatcctttatggcgataagt
-tatgaatcgtcagtatctttagatcaaaaactcaactagtacccagttccccggaggaac
-ggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttc
-atccgatcccactcgatgattggtatagctatttgccgaaaagccacaacgtattcggta
-ctatcttgtttgattcccctgtatcttaattcgcgacacttgatatcttttgtgtttaat
-cgacgaatcatcctgggggcgacacttgttacaattatccagttgcgtttaatggctgtg
-ggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgca
-ggacgaatagctcacccgcctaagtgatccaaccctcatcaggataactatcactgggca
-gtattatttttgatttcatatgccaccccctaggagactgtagtcatgtatctttcttac
-ccaatctagcccgaaacaagaaagaatgtcgattccagtcaccttttattagaccgattt
-acacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacga
-cttgctctattcgattaccttcgcgatctcaatcgattacgctaaattttaatgcccgct
-gaaatatccaacatttaaaacaggattaattctctgatccatgaacttaggactcattgc
-acgtgacttatctttctctcttaattcatgctccaatacggtgggctaaaccacttttat
-cacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtc
-aatctgggtatcttctattgggacggtacatttcggttttatagactatgtagttacacg
-gcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgcc
-atgtgtccggaggattacatacatctaagaaacattctaaactatgtatagtcgtttacg
-acccttgtagtacgtgcatcccttggcgaaaagtactctgggtattagagtgtatattat
-cgacagcaccgaatcctcattttatagcttgacaatttatgacccgaaagaaccttttat
-aagtctataagtatatctaacgcaattgcggcactgagtccactaactatctttgagcag
-tgttatacagtgagacgccatggaaggggtttatatattttactgtcgttccctaaaaag
-ttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgctt
-gtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttacattccttgctta
-tttgcgataaatcgatacaaccccattaccagaaaaacccggagaatcaattactctgca
-gatcttatactaaaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgt
-ggagcgttggggtaagagcggagcgattttaactttcgcttttccattttccagtattgt
-actttacgttatatttgagcggcacattcgtcaaaacatgatccatatggactgaggtgt
-ttaaatgttaatcaaataattgtattttcagctgactttaaaatctgcagccattggagg
-tggagattccaatagatgtaagcaggtgatatcatatgcaattcttgtgacttattaaga
-taccagacacggcacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaatt
-ccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaacgtttctctgaga
-tgtataagttaccaaacactggagaattccgctaaactaaggacaatttccgtcgtatta
-attgttgacaaatggttagtaatacattcgcagtggataatccgttgcatacctagcact
-gagtgtaaataaaaccaatcgactactggcatttcgggctaacgactagatgttagccta
-tgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttcttattcgttatt
-agaagtcacctgtagagacagtagagatgacctaaatttggtttgtccagtcccgaggtg
-atctaatgattaggttaacttagaacagtggtcaattggttaaagctgatttacgaacac
-ttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtattcggtcatctag
-acaaccccatcgctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccga
-attcgaaatcctgttgctccggggagatagggttaatttaggcttttttacggtgtggca
-tattagctcaaacatcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgt
-tctgctaggaagcgatgtacaaaataagcttaataagatttaggtccgaccttaatttcg
-gtccatagcacctctttctaagtgttttgcttaaataattgtattgttattgattttctg
-cgagttgaacacggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaa
-tgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccg
-cactaaacggctttcgctgtttccaaaaaattttagtccactaggtatttaaatgttgga
-cactgaacgtggaagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgta
-ctttgagcagatgctatcgtcagaaaaaggtaaatcttttggttctttataattctggcg
-tccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaa
-ttacgtcattagctgttacgtctatacgaaatatagactgtggacgacccatcgtagagt
-catgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacaca
-gtattgtactggtcaattggttcatagatctgactatgaatcttcgtttttgtacaacaa
-tctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcc
-tgttcgaggttagtcgtataaagacgaaacggccttaatgtaacattaactattccactg
-taggtggatctaacaaggttggacatgtgctaccaataagataagaatttcgtccgcaat
-acaatatctacttttgtagcctatcttggattaacaacaacttacgttggtatttcaccg
-gacgtatcaaatgattctgattttaatgactgagagtaaacatcaacgaatcttatgtat
-ctttaagccgctgcttgacaagtcacattactgttagaatgaacgcttcattactacaaa
-acctaccaccaactcccacattaatattatactagatgtttgaagtttatttgacaaagg
-ttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttagggtattaattgt
-ggtcggtgcatttccggccccatagcgctccgcggggagaaactatggccttcatgacag
-cccccccataacatctaggtaatggtcggataactataaacaaccctctccagagaactg
-tgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaag
-actcttttcactattttcttgatgcctcattcttctaatattaggtgattttttaatccg
-agaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaa
-tgaaatactttttgactatccctcatgatctaaacttacgcggagctatctttttgtata
-acatgtacagagaattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtc
-atggcggcttatcgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacg
-ggtttcgggatttctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgc
-gcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgcct
-tctcaattgtccgaggattgctgataacttaaaataaggttgagtttttaataacgattt
-gtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacg
-ggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggta
-tttgtacaactgctttcctttatcgattgctcgagaacattataaagtctattactatgg
-attaagactgtatacaagtgtttaagcggagcccgtgataatctataaggttttggtacc
-tttatctgttacttttgccttgaaacatacatacgtacacgggaatatttacctaaacgc
-cgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgccc
-acttgcattataacccggtgcggaatctcttagtgactcgtcaggagtttacgcctttga
-gacctctcgacaggacccattttgatctagtcgttataggtagagtgcctttcctatcgc
-accattaccttctagcaaacttagagtattcaatgaaatcatatcctgtttatactaaat
-gttataggctaatgacacagctgacactaagaggtctcttcgggttacccgaatgagttg
-tttatacgatgttgacaactcgggggagtcatttcaatgaagactgaggactcttgatca
-gattaaaacgcttaatgactgataatttagattatgccgtgtattatttaagtgggcgaa
-ccctcccctagaatgggtttcctgagaaaagtcttagaacacagtattctgaatccagat
-gcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcg
-caatccgtttaaccgtctactattcctagagcgaagagctatgttctgacacgtccccaa
-tattaggcaaaggctccaaaagaacagtcaattgattaactacgggcttggtttctccgt
-gaatccttgcgccgctataccacataaaaggatagcggtgataccacaagtttgcgacgt
-taaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaattttgtccatca
-ctactgccaagagttgactggaccagttggaaatgacatttgatatattaatagagctac
-atattgtaccactttactgtcacttacactaaccctagcgtgattactcatacatatatt
-cgtaaattctaagttatgatactagttttgtaaatttaatcggcgaagacacgttctctt
-gtacgagcttcaactaaatatttcactgtagccaaccactttaaccagaaggatacctta
-atgccgatataatattgtccaggaaacgttaatactttcacaagacaaagcttggaagag
-gtactttacgatcacctgatagatcgaccggaacgattctatataggtttggtctgagaa
-atttgtagctaaaaccatgttccataggaactcctctgtaatgggcaaaatgcagatagc
-gttcaatcgttgcttaactatctatcacagcatcctaactcctcaacagcttctttccta
-aagacatcagcaggtaagttgacggcacccgataacccagagcacgattggaatctaata
-ctctgtatggatcattacgctaagtaaatataatgattttctgactcaaagttacactgc
-gaattttatattaactggttctatttgttaaataccacaacctctcgtcaacaggtcgcg
-atgcaagtgatccaaaaatatctaacttataccaaccattacttctggcgcagaaaaaca
-tagatatctgaacaatcgaccgttaagactgtctcgccgatcttaggaacctaatactgc
-tcagtagttattgtttatttgggccatccccggattatgtcagccatggaacactaaaag
-tcctaatctaacctatggacaaaaagctcacttttataaaattgctcaccttatgttgat
-tgttatttgtccgaaatgtctataactcagtgtactatctattggaaaattatggccgga
-gttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaataattatcagctg
-gaaaatcatctaatatatattatattgagatattacgacagacctaagtgctttcccgtc
-atgagcagatggactaacactcttggtaatccttctcgttttagttggtaatgtttagtc
-taagtaatatcccgactcttacttactcagagcggaaatgactttttaaactaacgttta
-aaggcacttagtatgcgtcagggttatttttttaattacgtacccttgtgcagagagttt
-agctattcgatcctacttagtatgaaccatgagagtacaggttggtaattcacagagaag
-gtcgagaagattatttttgatgtttaccaatactatgaggcgtattcatcgaaataattt
-tatggctgcgcacttcacatacgcaggaagaccactgcagcttgctagatctggatgtat
-cattgtacttctaagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatg
-gggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcat
-aagttctgtcaactataaccctggaactttaatctgttgttcgtcgaatcaaggatcaag
-aaagcttctaaaaggcccaaagcaaaacccaccactacttcagttttaaattagaatcac
-accctagggtattagataataattaaatgtcttaggaagagatatcaaaagatgcagaca
-tcctcaagtgaataagtctccggtctttcacaaacacatggttaagcgatgtggttttga
-ctagagacgttcgccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatctt
-acttcatacattgcttaaacagtacaacttatctcttatcctatagagatctcaaaagtt
-tgtatttttactggtttcaaattgagagaaaaactgcgttctccgatttctatattattg
-tttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccgactcagattcgta
-tcctatgttagaatgagtcatcaaactacggtcacgcgtacattacagagtaaactacac
-gaatgaaagagataagaagatgaaagagttaataggtctcctgttaattatgagaaccct
-aactactacggattggcctactagtgggttggaacggatataaaattcgactaagttcgc
-ggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatccacagtaatagtt
-ggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccat
-gcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgagcaaggaattgga
-ttctgtgaacggaatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagt
-aaatcaaacgccgcgcgcagacatatcttcttggcaattagtactccactaaatcaattg
-gttataaacttttagaatatctttatataagttcactacttacgctgcgggtagtatatt
-taaagtgatgtcttaggaatcttatggcggcggaataaacggcttgactatagataccct
-aattctggcataaccctgtaacgtgtgaagcatgctttaatagacgactagatcagctta
-tagaatggatatgactgccacattgaagagattaacattagcgggtataatgttacgaac
-ttgtttaacaaaatagctctaccacacacgcatagtataatataaaggtcctggagttcg
-ctacgagcctggaattgcagttcccctaccctgagtaaacaagatcagtatggacctatc
-ttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcg
-gctaacactcgctttaccaaggaacaaacaattgatggaacaggtaagcggctggattct
-atcctgaatacagcataataatatttgctttcaatatatagttatgacactcccaatatc
-actaactctttacaaatcggatatgaagagtgaattagagatggagccgatcgttccttg
-tattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcga
-gtctagaactcacgcattatgaaatcctccgagcatagagactctaaattcgccaagcaa
-taagtcccgacgcgaaggatgagaagctcattgaactgtaacatttacgtcgggctcacc
-atgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacata
-aaaggccccactttcatatggtcaaatatctatatcgtgctttggacgactcgataaact
-aaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatat
-ataacttccggacgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaa
-cggtatagctcggaactatgcagattaggcgatccttgggttgaatttttagtttccata
-gatatgagttagttttgatatggttaccatacgtccctgcattgaaacttaatctgtata
-ttgattgatccttagcaatagcggcacatttctgggcaatatgacttaattaggttacgg
-tttttactatgatggatacgttttatatgatagaataacagttgctatttaaacaggtac
-tacattcaactaatactgtttcactattgtgtccaacatagggaatatattgcctgaata
-gatgtattatcaggcatcttttacgctccaggtagaactaattaaaaatgatccttagaa
-actttcaagcaacataagctaaaagttacgccaattataagccacatcggtaggatcttc
-aggcattcccatatccttctctatcaatcccgtctgttgctaattggttatctaagcata
-tcgcggcgagcatctacgataggtataaagttgctgctatctaattcgtcataatatata
-catggaattacagattcatacgtcttcagtctcgtggtgtttctaagagcggacccaaga
-attacgtaatatctctctcgtgttacccaagaagttgacacgtgattgtcagctatcttt
-ttctggcgatgttaatagttataaacaattgcatatagctgcaaattagctaatcaaata
-ctcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagg
-gcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataa
-tatctcagggtgtaattatttctctaattggtctttacggttggaccaggcaatgggttt
-tttatctatgtgataccaattaaaagtaatttcaaagtgacattaaacttaagtattgct
-gtcaagaccattacgacacttcaccaacacatttatgtattgtgctacgcggtatggccc
-gtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaaatgccaaattta
-gtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgt
-tgtattacgtccttttactagcctgggaaataccggtgattcagagtgaacataaatctc
-tgaaagctactagacaaagctagtatagttaaaatatatatttcttttaatattaggatc
-tttgcgattgcacatttcaagcatcgcattaacctacctccgtactcttctacaacggtt
-gcatgtacgatttctatgcgatgaaatacttatgttcttagtttggggttactttgttca
-cctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaac
-gatctcgattcttaggtttataattatagtcagaagataaatacatgcatatctggacac
-tcttccacatgtcatgtcgactaactttgaactacagtcatatatagactgttatctgat
-ccgtatgtgtctattactactcttatctgagaaaggacccaatggagtcacagtaagcga
-tcatgtcatcggggctttttccctgattataagattacactattgctgtgcttggggcct
-cctactttttctatcttaatcattttgtacattaaaaagctaagaagtaggtacaactta
-tctttcccatacgagctggaccattaatttaacagccgcaaggcgagttttaatgttaat
-ctggaagggctttatgttctaagcttttagcactgagaaattaatccgtaggaaattaat
-cccacataacccggtaagagaaccttacgccccgttactaataatgttctgcgcaatgta
-ggaagtgacaagctcactcttgcgacgagctccttaatacaggccctgcgttatattcga
-ccgtacctataactagaccaccatcttaaatgtacagttatggttttcgacgcatagagt
-atgggaccacctcgaaatgctcagctgcaaattgtactgggggtggttatcaaacattta
-atatgaatctatggtaaagtactagtttatagatagccgaacactaaaggtttgcagacc
-ttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcg
-tatctacaatgatttggtgcaaatatttatcgattgcccaatcgttctactcgtactctt
-tatagcctaacgccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaa
-ttacttaaccatactcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaa
-cgggcgtttttacttgagtcccaggaggtaacattggatctatgagtcttaacagtggaa
-atatgatttttagattgtgttcagatttattgtcttattttggtctatctcatcagctat
-agctacataatgacgtcttaactgtttcgactaaccttcagatctgactaccccaaatac
-aacatagcaaaagaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagc
-tccatttaaaagaatcgaaaacagatctaccattcgtggaatcaatttttggacgagtac
-tggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttcaagcactttagcg
-gttccatccttgatggcgttaactgatgatgcgtaagtttatggtgatctaaaactctac
-tacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttaggtctccaggcact
-aggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcctatagctttttgc
-agttaagccactaagtaggcggttctatagggtttcattcaaatcgatcgtaattcccga
-ctctgcatagcgtgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagt
-ttcaacttccgtttattggctgtccctcaatagagtcgttctcagggcacgactctcgtt
-cgttattcataagtccagtttgatccacgaatacagaacacgcatatctgataataaaag
-cttaacgataactttcacgcgcatggtttatttttgatttattaggcaaccaaataccag
-aatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaagtatcgccattac
-agtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgat
-ttaataataattacggctaaacgtattgatattttccaggaactgccccatctcatgaga
-tgaccctaaattttattcacacctcatttttaattcttttatatcacgattatttatctg
-agcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaata
-tacggtgcgctaaacatattggttcaattcaatgtaagctacctcggaatttgcttgcac
-taagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccg
-ttggagtcactatggagttacaagcattataaatctaaggaaatcgcagtatcagtcctt
-accccaaagatacttcgcattccctggggtacggaccatgaaatacttctttcatacatg
-ataaacgatggagactcggttaccaccctggtagttactccatcaattggagttaactaa
-gatcgctattacaggctttattagccaatcatcacaagcctctttttagagattcacaag
-ttagcaaaccaaagttcctttgataagtctttaacgagatctatcccaattccggctagg
-agtaaaatttatatatttgagatcggggttaaagtcacacgcaatgcaaggggtttttat
-atggtaatgtccttccctaattaggtaattttcagacctccgagagagagtagatcaaca
-acgcgttatactcctaaaatgcttgtcgataacatgacactacagatcatccctggatga
-gcatcgactttcattacttgattagttcagttaattcgtttcaaaccattttcaacaaaa
-tcccccagtagatatgtatatgcacatcttagactaaataacagttttcataccctggga
-tttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactgg
-ccctgttccattgtaatcgatgggacgggacgttatattgcagacccaaagtagtaataa
-attcagccatatggacggagggggggaattgttaagaatataattcgattttcagctgaa
-tgtaaaagctccagccattcctcctccacttgacattagttcgaagaaggtctgagaatt
-ggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagtaccaagtataat
-attatgacaatagaagcttaaattcacaacgtaacatatctgttagcatgctctaataga
-ccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaat
-ctaacgtctagttcccgactatgaagtcttcacaaatggttagtaataatttcccagtgg
-agtagaagtggcataacgtgcactctctgttaataatacctttagactactcccatttcg
-ccagaacgtcttgatggtaccctatgggaaacactcacacatgcttattgcctgcaacct
-cagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggactgatgacctaat
-tttggtttctcaagtccagacgtgatattttgatgaccgtatctgacatctctgggcaat
-tcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatc
-actatcatgttttagctaagctacactaccccatcgctcgcacgtggcaaagtgtgagga
-ttccgatatcatccatgtgtacgaattcctaatactcttgctcagggcacttagggttat
-tgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtcttataatcaccgt
-aatcggtaaacagttgttatttgttctgataggtagacagctaataaagatgctgttgaa
-cagttacgtcccacctttattgccctacagtgaaactagttcttactctgttgctgtaat
-atgtctagggttattgatttgctgccacttcaaaacggaaattaagtcattaacgaaaat
-ggttccttcataggtaaagatcaatccccaattgaagccagaaattttgagatgtcgatt
-cctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgag
-tccactagcttgtttattctggctcaaggtacgtggaacacgtagtattttgatactaat
-gccagacccgctacgatccctgtactgtgagcagagccgatcctcagaaatagctaaatc
-ttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtct
-atttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatac
-tctgggcaacacacatacttctctcatgttgtttcttcggacctttcataacctttcctg
-gcacatggttagctgcacatcacaggattgtaagggtctagtggttcagtgagcggaata
-tcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatat
-tatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatg
-tatggatcttgatctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaa
-taagataagaatttactaacatttaaattttcttattgtcgagcatagattggaggaaaa
-acttatttacttggtatttaaacggaagtttctaatgtttatgattggatgcacggacag
-tttactgcttactttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgtt
-catgcttccattaagttcttcttaaacttacacaaactacctaatttagagttgacgaga
-tggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtaca
-tttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacattcacatcccaccc
-ctgaatatatggactgaatcacacacaccaaatttcatctaccttatcgtagcataacta
-ttaacaaacatatacagacttcgcggtaaataaaatatattagtacacaaccgtatactg
-gttgaactattgcccagctttaagacgcttttaactaggtgcttgatcaagaagtattat
-tatatgacggcagtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacg
-ccgtagagacatttttgttagatatgtatttctttttgacgagccagcatcttagtatct
-gaagacgagctatatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagat
-taaccaaattccccagaattagtaatggcgccttatcgatttactaacgatatataactt
-gtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattg
-aagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgat
-actacgttttgctatgtaatccattctaatgggtaagaggattcctcttatagtaaaata
-tgcttgactttttaagaaccattgggagtggttggcaaaataatagtgggtgtctttctc
-agtgtatagttttctacaactacccctattaggttacaagtaatctggctttcttgccac
-ttggcgatgatagttagattcgtatttctacaacgcagttactgtatccatggcgcgaga
-taattagatacgatttgaatttggatgtagactcgttactactgttgtagaccagcacgt
-gagtatctagatgggtttgctaccttgttagcggacttttgccgggaaaaagacatacgt
-acaaccgtatattttactataagcagtattggccaccctcgtattgcggcagggtgtgct
-cacctggttaaaatgaaagagaaaaattccattttaaaacccggaggaatctattactga
-cgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttcatattctagtta
-ttccgagagtcactttcctatccaaacatgaactgatagcataatgacaggttgaatgga
-aagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgtcacgaactcgga
-gcttacccttacaactatgtgttctgtttaccaggtgctaatatcccggcactcttttca
-tgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcatattttacagtagc
-cagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctgacataagtatta
-catatcacttgtctgattacacagcaaaatcgctaaccttactttgcgcatgtagctatt
-ggaactttgggctagtgtctatcccattaagtttaacagtagactagtccgtgagcgatc
-accgagcttatgtctcgtacccaagttttggatttggatcaaaaactactcgatattcat
-gatctacgggcttcctttctccgggtatcattgcgccgagattaaaaataaaacgatagc
-gctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacgaatagaccatcca
-atttgaattttattgggtccagcacttcgccatagtgttgaatggtaaagttcgaaagga
-aatttgttatattaattctgctacattttcgaccacttgtatctcaaggacaatatccct
-tgaggcttttagcagaaagagatgccgtaattctaagggatgataataggttgggaaatt
-taagagcagtagtaacggtcgcgggttcgaccttaaactatatatttaaatctagccaaa
-caagttaacaacaaccataaagttatgaccttattatattggcaagcttaacgttttaat
-tgctctagtaatagagtggtagaggtaagggaccatcacctgattcttcctccgcaacca
-ttatatagacgtgtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaata
-tcgaatggcaattagccacattgagttaaatagttgaggatatttcttgcacagaatcag
-atctaatctaatgattcgttactaaacacttcaccaggtatcgtgaaggctcaagattac
-ccagagaacctttgcaatataagaatatgtatgcagcattaccctaagtaattatattct
-ttttctgactcaaagtgacaagccctagtgtatattaaatcggtatatttgggaaattcc
-tcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccata
-catgaattctggccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgcc
-aagatattaggatcctattactcatatcgtgtttttctttattgccgccatccccggagt
-atctcacccatccttctcttaaaggcctaatattacctatgcaaataaacatatattgtt
-gaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgact
-atatagtgctttagtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtt
-tcttgtcctaatatttttcagatcgaatagcttctatttttgtgtttattgacatatgtc
-gaaactccttactcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtct
-cgttttacggcggaatcttgagtctaacttatatcccgtcgcttactttctaacacccct
-tatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgttattttttgaag
-taagttacattgggcagactcttgacattttcgatacgactttctttcatccatcacagg
-actcgttcgtattgatatcagaagctcgtgatgattagttgtcttctttaccaatacttt
-gaggcctattctgcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcg
-caacatgccttcatatccatcgttcattgtaattcttacacaatgaatcctaagtaatta
-catccctgcgtaaaagatggtaggggcactgaggatatattaccaagcatttagttatga
-gtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcgtaatgttatctc
-gggttccgcgaataaacgagatagattcattatatatggccctaagcaaaaacctcctcg
-tattctgttggtaattagaatcacacaatacgggttgagatattaattatttgtagtacg
-aagagatataaaaagatgaacaattactcaagtcaagatgtatacgggatttataataaa
-aatcgggtagagatctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgtt
-acatcagaaagggtaactattattaattaataaagggcttaatcactacatattagatct
-tatccgatagtcttatctattcgttgtatttttaagcggttctaattcagtcattatatc
-agtgctccgagttctttattattgttttaaggatgacaaaatgcctcttgttataacgct
-gggagaagcagactaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcg
-acgaatggacagactttactaaaccaatgaaagacagaagtagagcaaagtctgaagtgg
-tatcagcttaattatgacaacccttaatacttccctttcgccgaatactggcgtggaaag
-gttttaaaagtcgaagtagttagaggcatctctcgctcataaataggtagactactcgca
-atccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaacc
-gtccccactcgcctggggagacatgagaccacccccgtggggattattagtccgcagtaa
-tcgactcttgacaatccttttcgattatgtcatagcaatttacgacagttcagcgaagtg
-actactcggcgaaatggtattactaaagcattcgaacccacatgaatgtgattcttggca
-atttctaatccactaaagcttttccgttgaatctggttgtagatatttatataagttcac
-taattaagatcacggtagtatattgatagtgatgtctttgcaagaggttggccgaggaat
-ttacggattctctattgatacaatttgtctggcttataactcttaaggctgaaccaggcg
-tttttagacgacttgatcagctgttagaatggtttggactccctctttcatgtcagtaac
-atttcagccgttattgttacgatatgcttgaacaatattgatctaccacacacccatagt
-atattttataggtcatgctgttacctacgagcatggtattccacttcccattcaatgagt
-attcaacatcactagcctcagagatgatgacccacctctaataacgtcacgttgcggcca
-tgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcatataacatttgag
-ggtaaagctaagcggatgctttatataatcaatactcaataataagatttgattgcattt
-tagagttatgacacgacatagttcactaacgagttactattcccagatctagactgaagt
-actgatcgagacgatccttacgtcgatgatcgttagttatcgacttaggtcgggtctcta
-gcggtattggtacttaaccggacactatactaataacccatgatcaaagcataacagaat
-acagacgataatttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaa
-gctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaactggttcccggg
-agtcctggagtttcgacttacataaatggaaacaatgtattttgctaatttatctatagc
-gtcatttggaccaatacagaatattatgttgcctagtaatccactataacccgcaagtgc
-tgatagaaaatttttagacgatttataaatgccccaagtatccctcccgtgaatcctccg
-ttatactaattagtattcgttcatacgtataccgcgcatatatgaacatttggcgataag
-gcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggttaacagacgtac
-atgaagggaaactttatatctatagtgatgcttccgtagaaataccgccactggtctgcc
-aatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtat
-aacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcactattggctacaa
-aatagggaagagtttcaatcatgagagggagtatatggatgctttgtagctaaaggtaga
-acgtatgtatatgctgccgttcattcttgaaagatacataagcgataagttacgacaatt
-ataagcaacatccctaccttcgtaacgatttcactgttactgcgcttgaaatacactatg
-gggctattggcggagagaagcagatcgcgccgagcatatacgagacctataatgttgatg
-atagagaaggcgtctgaattgatacatcgaagtacactttctttcgtagtatctctcgtc
-ctctttctatctccggacacaagaattaagttatatatatagagtcttaccaatcatgtt
-gaatcctgattctcagagttctttggcgggccttgtgatgactgagaaacaatgcaatat
-tgctccaaatttcctaagcaaattctcggttatgttatgttatcagcaaagcgttacgtt
-atgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtgggaataattctt
-ttgaagacagcactccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgt
-aaccttgcacaagcaaatcggtggtgtatatatcggataacaattaatacgatgttcata
-gtgacagtatactgatcgagtcctctaaagtcaattacctcacttaacaatctcattgat
-gttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaag
-gaacatctactaatgcctttgttaggtaagatctctctgaattccttcgtgccaacttaa
-aacattatcaaaatttcttctacttggattaactacttttacgagcatggcaaattcccc
-tgtggaagacggttcattattatcggaaaccttatagaaattgcgtgttgactgaaatta
-gatttttattgtaagagttgcatctttgcgattcctctggtctagcttccaatgaacagt
-cctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggtt
-cggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagc
-aaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtag
-ttaaataaatccatatctgcaatcgattccacaggtattgtccactatctttgaactact
-ctaagagatacaagcttagctgagaccgaggtgtatatgactacgctgatatctgtaagg
-taccaatgcaggcaaagtatgcgagaagctaataccggctgtttccagctttataagatt
-aaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagttggttcattaat
-tagctaagtacgaggtacaacttatctgtcccagaacagctccacaagtttttttacagc
-cgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattagagtttacaactca
-gtattttatcagtacgttttgtttccaacattacccggtatgacaaaatgacgccacgtg
-tcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcctacacatactga
-attcaggcaatgcgttttattcgaaaggtcatataactagaaaacatgatgaattcttat
-cggatccttttactagcatagtgttggcgaacacctcgtaatgctcagcggcaaattgga
-ctgcgggtccttatcatacattttttttcaatataggcgattggtctaggttagtgattc
-cccaacacttaaggtttgctgacattcataccctcagcaacttcctctcaaaaattagag
-tgagttggtggtcttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgc
-acaaatcgttataatcgtactctgtagacaataacccattgtagtgccgattttgtgcat
-aatacaagaaggaggatataaaaatgacttttcaataatattggctattagcaacaagaa
-ggagaatcctcattaagttagcaaccgcagggggtactgcagtccaaggaggtttcattg
-gagagagcagtatgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctg
-attttcctagatagaataagctatagctacttaatcaactcttaactgtggagactatcc
-tgatgatctgaataccccatttacaaaattccatatcaatgaggctaacgcttaaatttc
-atttctccatcgtaacaaaaatcagcctttttatacaagacaaaacactgcttccattac
-gggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgc
-gtttatacttaaacaaattttgacctgacataatggagcgacttatcggatgttgccgat
-ctttagggtcatctattaagcttatacgaaaaagggacaagcacgttacgtaatctggta
-ggactgggtacctagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaa
-tacaggagtccttttcatttttcaagttaacaatataagtaggagcttagagaggcttgc
-atgaaaatcgttaggaattacagaataggcagagagtggggcgtgtagactacattcttc
-aggccccacaatatgggttataggttaaactgcactttttgcgatctcccgaaatactgt
-cgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcatccaactattcag
-ataaacaagatcgcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggc
-atgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaa
-cataattcattctttcgactggacacgctaaggtttggacaaactttgtatctatatctg
-gaggcctgtattccagcccttcttttaataagatttacggcttaaactatggatatttgc
-caggaaatgacactgctattgacaggaacataattttgattcaaacctcattgttaatta
-ttttatatctcctgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtga
-gggctcgaggaatgaatcataatagaccggcccctattaatattggttcaattctttctt
-acataacgcggaatttgattgcacgaacaccgggaacacataaccgtatagcgcccgtta
-tgctagtgcctagcgactgggaccgtggagtctatatcgtctttctaccattattaatct
-aaggatataccactttaagtcctttcaactaacataaggcgcattccatgcgctaaggac
-cttgaatttattatttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgt
-actcaataaagtgcagtttactaagagccctttttctggcttgtggagactatcataaca
-tgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacg
-agatctttccaattgccccatagcaggaatagttatatattgcagatcgcggtgtaacgc
-actccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatca
-aagcacagtgagagttgagcaaattacagttatacgacttaattcagtctccataaattg
-aaacgacacttcttaacgggaggaccagacacgttcattaagtgaggagtgcactttttg
-actttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagt
-tatttctgttttaatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccc
-tatcacacctcagagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtag
-ttggcacacccaatggacgaataaatgctgccatatccacggagggcgggattgcggttg
-attttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaat
-tactgcgtacatccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaacc
-aaattgacaacttcatagtataatttttgcacattacaagcgttaattaacaaacttact
-ttgctgttagctgcctatatttgtccgacaatataactggatatctctgcgagaactgta
-aattaacggcacttggaacataatagttcctattggtaacgacgttgtaggcggcaatta
-tccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagta
-taactttagaagactccaaggtacccagaacctcttcagcggacacgatcgctatcaatc
-aataaggattattcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagc
-ttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctgttattttcatga
-ccggataggacatctcgcggaaattcgggtaacagctgggtagatataggacctccccta
-cgtattaatgataagcctgtcataactagcttggtttaccgaagagacaataaacattcg
-agcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaacatgtactattact
-ctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgatgttgacagaatt
-atgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtctgagcattcgtac
-actgcgtattaagatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaac
-taggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaa
-ccaaattaaggctttatccaatatgggtccttaagtgctaaacatcattcacaatttcaa
-gacagattgttggtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccag
-gtacatcggtaattatatgttgactaaactaccgtgtgtattctggctctaggtacggcg
-aacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcag
-cagatcctaagtaattccgttttattgtcctgagggagtaggatcgacgaactctacaag
-tcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtc
-atctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcgatggttctttat
-gcggacctgtcatatcattgactggcacttgcttacatccaaataacacgtttgttagcg
-gatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctaca
-tgataaatgaataagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgt
-cgacgagttactactaaaggaatgtagggttctggatctatgaaaagcgacctccatata
-tatacgggcctaagcggagtaaaataagtgatcaatggactaacattgaaatgttagtat
-tgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatg
-gtttagcatgggatgcaagcactcgttaatgcttactttagttggttgcgggaacaacag
-gaggctatactaactggtagcgttcttgcttccattatgttattattataattaaaaata
-agacatatggtagagttgtagtcagggtggatcgggttgtctataacgttggaataatca
-aaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgt
-gcaccacacattcacagcacacccctcattataggcaaggaagcaaacaaaaaaaagtta
-atcgaccgtatccgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaag
-ataggactaaaattcactagtatcctggaacgaggcaacagagttatctagatggtaacg
-aggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacctctattgatata
-caagtgactttctcggtaataacgcacttcacaatgtgttgtttcttttctatgtatttt
-gcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcac
-atggtataactgcaggaggaacattatccaaattcaccacaattactaatccaccctttt
-acttttactaaagatatattaattctcatgttgtctgaattgtataacccggtaccctgg
-gagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaacacacgacttcctt
-ccgtctattcagacactcaacgagactaacttttcctaggtaatcaatgatattgggtaa
-ctcgtggcatcttatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgc
-taattaagactggctctcttgcgcaggggatacgtttattctacgtacccgatttggtta
-ctactaagcggcctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagc
-agggaagggttacagggagagacttattgagatacgattggaatttccatgtacaatcgt
-taatacgcttgtagaccagcaactcagtatagagatccgtttcctaaagggtgagcggta
-ggggcaaggcaataagaaattactaaaaccctagttgttaatataagaacgattcgaaac
-aataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaataggcattgtta
-aaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaa
-cctaaaaggggcttattctactttttccgacactcaatggacgagacaaacatgaacgga
-tagctttaggtctcgttgaatgcaaagaatagaatcgttattattaatcggtttccatta
-tctatatgcggtatagatctccgagaggaccctgtaaactagctctgcggtttaactggt
-gctaatagaccgccactatgttattgcttctagctcctagcgtcttatcatgttatacat
-taatgtcgcatattggacagtagccaggcttggatggatcgccgacaaaaagaaaagact
-ttccctgtaaggacttaactattacatataacttggatcattaatctgcaaattagagta
-acggtctttcaccagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaa
-aactagaattggcagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttg
-cataaatatcttatcgatattcaggttattaccgattccttgctaacgctagaagtcaca
-ccagagtaataataattccagacacctgtgaaataatcggtcactacggatagactagta
-acgataatacgtatagtccataaaagttgaattttaggggctaaagatattagcaatact
-ggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaa
-ttgtatcgataggaatagttacagtcacgcttgtagatgtaagagatgacgttattctta
-gggttcttaagtcggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaa
-acgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattt
-tagtggcaaccttaacggttgaattgatctactaatacaggcctacaccgaagggtacag
-ataatgattcttactaccctaacatgatagagtcctgtcctatctcataggtcgacattt
-taaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattcacttatagacttc
-aggttatttcgtgctaacattaagatagaatataatcagtcgttaagaaactattatcca
-gctttcgtcaaccataaagattaaaaactgaaacttggcaagatatgaatagctatcctg
-ctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagt
-aaagcgggagagtgcggtaattaatattaatatactattaagctacacagcaaaggctgc
-aataatgttagtaagtagaacataaaggtattctccacaagtaataaatagtgtgagcta
-attgactaacttaactctcgcgacaagtgatgtggataagatgactcatatcgtcttttt
-ctgtagtgccgacatcccacctggatcgaacaattccttctagttatcgactttgattac
-ctatcctattaaacagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctac
-catagctagagttagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatg
-agtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatccattagattaga
-tgtttgtgttttgggtctgatgtcctaactactttctcagtgaaactaatgtcatcatcc
-aagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtctataacgtatataa
-agtcgctgaatttagaacacaccttatctatgttgtaaagttactttattccaaaggacg
-tgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagata
-agaatttctttcatacttcactggaatccggcgtatggatatctctaccgcgtcatctgg
-tggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacat
-cgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtgaagtctaattat
-ttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggat
-agaggacattgcatgtacgtaggactattctccaaggggtcttctattttgttagcgaaa
-attgttacagcctaatgttagagcggcgtacgactttataccagatactttcattagata
-tgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgtt
-gtgatatgatgtttttctagttcgttctcatatatatagatcaacaatgaataatctcat
-gatctataaccgatgtatatttatattccggttgactgctccggtgcaattcactacgga
-cactaatgactaatatggcgcctttcatcagaaacgctaaatatgattaatgaattaagg
-gagtattatctaattattagagagtagcagttagtctgatattttcggtgtatgtgttag
-ccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttca
-ctttatgactctggttatatccctcggagaacaagaataagagtacgagaagttcggtca
-ttgaggatgaaatagaaccgctagacgaatggactcacgtttataaaactatgtatcaca
-gtactacagctaactctgaagtccgagaagcttttgtaggacaaaacgttataagtacct
-ttcgcagaatacggccgtgcatacctgttataaggcgtagtagggacaccatgctatccc
-tcatatagagctacactaataccattacatggtgactatcgtttacggccatcatctgta
-agcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaacccc
-gtgcggattttgagtcagaactattcgaagcttctcaatccttttccattatggcatagc
-aagtgacgactcgtcagccatgggaataatagcactaatccgattacttatgaattagaa
-cccacatgaatgtgattctgcgaattgtctaagaatctaatgattttccggtgaatatgg
-ttgttgttatttattgaacttatattattaacatcacccttcgttagtgatagtcagcta
-tttccaagaggttccccgagcatttttaccattctctagtcatacaagttggagcgcttt
-taaatctttaggctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtg
-caatccctcttgcatgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaat
-attcatagtaataactacaatacttgatttgttacgtaatgctcgtacataacacaatcg
-tattccacggaacagtaaagctctattattctgatcgagcctaagagaggatcacactac
-gctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgaccagttatagaca
-gtgtaattccatattacatgtcaggcttaagctaacccgagcctttatataagctataat
-caagaattagattggagtgcattttagacttatctatcgaaatagtgatagtaagagttt
-atatgacctgatctagactgatgttctcttccacaacagccttaaggcgtggagcctttc
-ttatactattaggtcgcgtcgagagccctattcgtaatgttaacgacactagactaatat
-acaatgagctaagaataacacaagtcacaagataatttacaaatcatatatctacagtcc
-acaaccatcactagcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgc
-aagacgcgttaactggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatat
-ggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagac
-tatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattgataaatgcccca
-acgttccatcacgtctataagccgtgttactaatgtgtattagtgcatacctattcagac
-catagttcaactgttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttc
-ttgtcttttccttaactgacctaaatgaaggcaatcggtttatctagagtcatgcttaag
-gtgaatttcagccaatgggctcccattgagctagtatggtgctttacctttgtaagtggt
-ggctttccttggtgtgctgactttaacacggcagagtgattatccgaagaatggataata
-agacgctggcaatattggctaataaagtccgatgagtttcaatcatgactgcgaggagat
-ccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcattcttgatacata
-aagatccgatatcggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatg
-tgaatgagagtgaaatacacgatggggatattgccggtgagtacaagttagaccacacat
-tagaactgacctatattcgtcatcatagagatggagtatgaattgattctgcgaagtaca
-ctggctttacgagtatctagacgccgcggtatatctcccgtcaatactatgaaggtatat
-atatagaggctgaaaattcatgttcaatcctctttctaagagtgagtgggagccccttct
-gttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtt
-tgcttagaacaaaagagttaccttagggtaggtaaatctcgattcaccgagagaagtgat
-tttggcggtgtgcgattaattcttttgatgacagatctcattattttatatagctccctc
-tttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgc
-tgaacattttatacgatgtgattactcaaaggataaggttcgaggcctctatactcatgg
-aactatcttataattataatggatcgtggctcattccacctatccaaacttctttgtgat
-ctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagct
-cgcatttcattcctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaa
-ggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttatagcaaacattatt
-caatttcagtcttgactgaaattagtttgttagtgttagaggtccatatgtcacatgcat
-atggtctagatgccattgtacagtaataccttagattagtattagcggcatgcgtacttg
-gatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgcaaataggaatact
-tacaatttttgatgacttgttagcatatcgctatcacccataaaaaacctgatacttgat
-gagcgggtgattgagactatgtactgatataattcaatagctccaatagatgaaacagct
-atgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgag
-tggaattagcggtgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacc
-cgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacgaagaatgggtag
-agagtttgaaggtgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaa
-cacctcctaatggttgtgttaaccacaaacccctgggtgaatctgattagccaacccagt
-gatctgatttcagttgtcaaatctcttttttataactaccttttgtttccataatttaac
-cggatctcataatgaacaaacgggtagaataatggtagcacatagcgagcttgtctattc
-agaaatatggcctactcagaatgtattctccaaatcagtgttatgcgaaacgtaatttta
-cgtgtaataatgatgatttcttatcggttccttgtactacaatactcttgcccaacaaat
-actaagcataacagcaaaattcgaatccccctccttttaataaatggtttttcaatatag
-ccgattcgtattcgttagtctttcaccaactattaacctggcatctaattaataaaatca
-ccaaaggactctataatatgacagtcacttcggcctcttttaagacagttgattattgca
-ggtccgcaattgatggtgacatgcacaattagttagaatccgactatggagacaattaac
-aattgtagtgcccatttggtccagttgacttcaaccacgagttataaaggtattttaatt
-tatagtcgatagtaccaacaacaagcacaatcataattatgttagaaaacccagggggta
-atgctctaaatccagctttaaggccagagtgcactatgaaatcgccattgatcattgtgt
-cattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagc
-aacgattatatctggactagatcatgatgatcggaataaaacattgaaataagtccttat
-caaggagcataaacattttatttaatttatacttcgtaaataaattcagaattttttttc
-aagacattaatctgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacg
-catgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggc
-tgccacttttagcttcttgacgatctttagcgtcatatttttagattagtcgaaaaacgg
-aaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaagagcaggacaact
-ccttgatcgggaagaactgaaatagacagctgtcattttcattggtcaacttatcaatat
-aacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcag
-gcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacg
-ggttgccagctacagatatactctaggtatatcccaaacaagagacgtcctttggctgtt
-gtaatcggtcataatacttgtcacataaacaagatcgctgaattaaacattaaacagtta
-gtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatca
-cagagcgacgtaaatttagacaaacattattatttcttgacaatggaatcgataagcgtt
-cctctaacttggtatatatatctcgaccccgggattccagccattcttgtatgaagattt
-aaccatttaactatgcatagttgaatggtaaggaaaatgatattgactgcaacagatttt
-ggatgcaaaaatatttgtgaattattggttatatactggttgtatagcacaatcattagg
-tcctagaaggcatactcaacctcagcgagagagctagcatgcataattgtaccgcccata
-ttaatattcctgaaatgatttcttacattacgcccaatttcagtcatcgaacacccccat
-caatttacccgatagagaacgtgatcatacgcaataccctatgcgaacgtccactctata
-gcgtctgtatacaatgattattcgttccatttacaacgttaagtaatttaaacttacata
-aggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgt
-ctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgta
-tccattgtggagaatatcataaattcaagatggggtgtcatgctattcggtcctaaacat
-tcttaatggctgttctattgttagtctgatttaaaatggaaccatagcacgaatagttag
-atagggctcatacccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgac
-ggaaagttttacggtttgtgatcaaagaacactcacacgtcagattattacactgatacg
-aattatttcagtcgacagtaattgaatagaaacttattaacgccagcacctgacacggta
-agtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttga
-tttctatatcaaatgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatt
-tagatcgttacgactcacgtacaagatcacacatcacacgcgttagcgaaagcggaatgg
-ctaatacagccctacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgag
-ccaacctcccccgcattgcggttcattttaaggcctgggtaacatctatcgtttagataa
-tcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcg
-ctacgtgtttctttaatcaataccatattgaaatcgtaatacgataattgttgctattga
-ctacaggttatgaaaaaacttactttgcgggtacatgcatatttttgtaccacattatta
-cgcgatatctctcagtgtactctaaattaaaccctcttcgaacattttagttcctattcg
-taaacacgtgctacgcggcaatttgccggtcgtagaatggacaactccagttcaactgca
-tgtaactcatagctcgcgttagtataaattgactagtagccatgggacaaagtaactagt
-cagcggaaaagatccctttaaagatatatgcaggttgcaagcataaagctcattgctcga
-ggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaa
-tcgaaactactctgatttgctgcacacgttaggtaatatcgcccattttcccgtataagc
-tccgtacttatacgaactacacgaccttttaagcattagccgctcatatcgtgattcgtg
-tacagatgagtctattaaaattacagacatactccatatctcgctccttgaactttgaat
-aatgcgctaacttgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggg
-gaaacgatacatgttgtcagatttatgattatctagttttagatcacgtttaccgataat
-cggctgtggtctgagcagtcctacactgagtatttacttcagcttcatatcggtccgaaa
-aaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcgg
-ttgcagggcagcaaaaggcttaaaccatttttacgatttttactatagcggtcatgaagt
-gcgaaactgcttgcaaattttctacacacattgtggctcttgtccttgaagcttatggcg
-aaaatttgaaacatagtataccagggaaagcgcgaattatttggtgactaatagtccgtg
-ggtttgagccatatacctaacgccataaactacgtggtgctttagatgcaatctaaacag
-aacagaaagcgtagcgctcatcagcacagactaactttttcagtttgagtcgccggaggg
-acttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaa
-tcttgcctaatttctactattgtcagctgtacgactgtactaagtgtatagccccaaata
-aaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttc
-atcaaattaaatcctggcttacccgattctccggaagtctgacctagagattgacgacgg
-ccgcgtattattgagacctcttcaggattaatcaataacgaagtagttgatctgtttggc
-gacgtaccttaagccgactccgctacacgagtttctactaaaccaatgtagccttatgct
-tagatgaataccgtcctaattagatattccggcataacagcagtaaattatctgttcaat
-ggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaatattaggtaagg
-ccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaa
-tttaggtgcgtgagggttaaacaccagcatattctatatgctagacgtcttccttaaagg
-atcgtagtattataattaataataagaaatatggttgacgtctagtcagcgggcatacgc
-tgctctatatactggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctc
-acgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgcc
-aagcatgcaataaaaaaaatgttaatagtacgtttacgacattttattttataataaaga
-gaaactattacacctattgatatgataggacgtaaattaacgagtagcctgcatagaggc
-aaatgaggtttctacatggtatagacctgatgctgaaacatcgatgagttttggtcccct
-cgctcgttgaaatctagtcatttactactgtctttcgagctattataccacttcactatg
-tggtgtttctttgctatgtatggggctagtcaaacatgatgactatagctacaactcaga
-gagcgggcgtgttaagagtatctcatgctagaactgcacgacgaacttgatacaaagtaa
-caacatttacgattccacaaggtgactttgaagaaacatagtttaattctctgcttcgat
-catttctataaaccggtaccatcgcagcggatagatgcataacatttctactactccagg
-catcttaaaacacacgtagtacttcactagattaagacacgataagtgtataacttggca
-gtgggaagcaaggagattggcgaactcctggcatctgttacgttttgttcaggctcggtt
-gttgataatgtccgactcctgccatattgaagactcgctcgagggagatcgggattcgtt
-gattataagtacacgtgttccgtaatactatgaggcagtgattcaaaatggcacttctga
-cttacatgactaggtattattaccacggaagcgttaaaggcacactcttatggacttaag
-attgcaagtgccttcttctagcctgaattcgcgggttcaacacaaactctctttagacat
-ccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtactaaaaaactagtt
-ggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggtta
-agcaaacacaaataggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcg
-ggaacaacggctctaagagaataacctaaatccggatgagtagactgtgtaactctctaa
-agggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgcattcaattgaatc
-gtttgtattatgagctgtacagtagctatatcagctatagttatcccagaggaacaggta
-aactagctctgagcgtgaaatccggatattagaacccctagatgggattgattctagcta
-atacaggcttatctggttttacagttatctagatgattggtaaggtgaaacgcttggtgc
-cttccaccacttaaacaaaagtattgcccgggaagctattttctaggtattataaagtcg
-agcattaatatcaatttgacagtaaaggtctttcaccagcttcatatgccatagggccca
-tactcgatttaaattgaacggtttaacgagtattggaactctcacttataactgagtagc
-tatacgaaaaatctggtccatttccagaaatttattatcgatttgctgcttagtacccag
-gaagtgataacccttgaaggcacaacactgtaataagttttcctgtcacatctgtaatat
-tcggtcactacgcattcacgactaaagataattactatactaattaaaagttcaatgtta
-gggccgaatcatagtagaaattctcgtctagcctaatcggacttacctatgggctgtgag
-gatttatcagtatgtggacaaaaatgctagagataggtatagttaaagtcaccatggtac
-atctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgggatgacaactac
-tatacgtagagccgtactcaggattagatagtgtgaaagagtcaaataaaagggttaata
-ttaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaat
-acaggccttcaccgaaccctaatgataatctgtcttaataacattaaatgattgtctccg
-ctacgagctcttagggcctcattttaaatgactaatgtccaaagaagagactttcccaat
-ttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaagatagaagattat
-caggagggaagtttctattatcaaccgttacgcaaccataaacttttaaatctcataatg
-gcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgctggggagctagat
-atcggtataccacttcggttgtggtaagcccgagtgggccgttagtaatattaatagacg
-attatccgacaatgcattcgctgaaataatcttacttaggagaaattaatgctatgagcc
-aaaactatttatgtctgtcacattattgactaaagtatctatcgacaaaactgatgtcca
-taagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatga
-attatagttatccaatttgagtaaattgcctattatacagataggcttgtttagtcagat
-aaggttccgcttgaggtgctctaacttagcgagagttagaaagcctagtgagaggcattt
-tggtgccaaactccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaag
-ttggtgaacagccttttgattagttgtttgtcttgtggctatgtgctactatataagtta
-gaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgagacggggtacgcc
-gttgaggctcgagatagtagataaactagaggaatgtagataaaacattagctagggggt
-ttagttactggattacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtc
-gcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcctatacggacttt
-gcatatctctaccgactcatctggtcgtctatgcgggtaattgtattgctccaagtggat
-gactattttggcgtcccagcacatagtaaatgtaaatccttataatagcataagcaatta
-ttagactgcgtgaagtcttagtagttctcaagctttacgttgtatgtaaataactcacgt
-aatcagccgtccccaaatcaccattgaggtcattgaatgtacggagcactattatcaatg
-cggtatgcgattttctgagcgattattgttaaagacttagcgttgagccccggaacactt
-gattacagattctttaaggagttatccaaatatcattttaaataatagtagtatcgtgct
-ttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtacttctctgatata
-tacttcaactatgaagattctattcatcgataacccaggtatatttatatgcccgttcac
-tgcgcagggcaaattatctacggacaataatgacgtagttggacccggtaagaactaacg
-cttaatatgattaaggatgtatgccagtattatcttattatgtcagagtagaagtttctc
-tgagattttccgtcgttgtggtacaccggatttggctctctttttagaactgagaactcg
-gagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccgccctcatcaact
-ataacaggacgacaagttccgtcttgctccatcatatactaccgatacaccaatcgtatc
-aagtttagtatacttgctttctctcttctacagcttactcgcttgtccgagaagcggttg
-gtgctcataaagttagtagtaaatgtacaactagtagccagtccttacctgtttttacga
-ctactacggacaccatgagatacagaagttagtgctacaattataccattacatgctcaa
-tatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctacc
-atcccgtcaatgcacaaaaacacactccccttgttgactaacatcttttacaagaggcta
-aatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcggaagaataccact
-tttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaat
-atattcatttgaccgtcattagccttcttcttaggttgtgtacggatagtaggtacataa
-accgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttttttaccaggcta
-gagtcagaaaagttggagccatgttaaatagttaccatcataaaccactgttgtctacta
-gtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactg
-ttgcgttacttaggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcc
-taatcctcggaaagtacacaagcctaggaataggaaaagtaaagctcttttattctgata
-gtgactaactcaggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatca
-tctgctggtgaccagttatagacagggtaattcaatatttaatgtctcccttaacatttc
-accagcatggattgaagatagtataaagttttacatggcagtcattgtgtcacggttcta
-tacaaattctgatagttagacggtatttgaaatgtgcttctagcatggtatcttacacaa
-ctgaatgaacgactggagccgttcgtatactatttgcgagcctcgagaccccgtttccta
-atgttaacgaatatagtataatataaattgtgatatgaataacacaagtaactacagttt
-ggacaattaattgttctaaactaaaaatcattcacttcagatggcatagagttatggcta
-ctacacatataaagcggtatgtgaaacacccgttttagccggaaaccctctactgctcgg
-gacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaa
-tagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatt
-tggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgt
-ctattactgattaactagtaagacattagtgcatctggtccactgaagcacccgcttggc
-gttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctata
-ggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggt
-tcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagac
-tctttatcccaagaatggataatatgtacatggaaagtgtccataattaagtcccttcac
-tgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgacttacttgcttttt
-gatcaacttaattatggattcataaagttcagatatcggtacaattggtgtacaatatga
-aattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatccccatttgcccg
-gtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagcattgagatccac
-gatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacgaagaggtatatat
-aacctaaatactaggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggc
-gaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggt
-cagttcaaaagtagaccggatctttgcggagaacaattcacggaacgtagcgttgggaaa
-tatcctttctaccacacatcggattttcgccctctcccattatttattgtgttctcacat
-agaattattgtttagacatccctcgttgtatggagagttgcccgagcgtaaaggcataat
-ccatataccgccgggtgagtgacctgaaattgtttttagttgggatttcgctatggatta
-gcttacacgaagagattctaatggtactataggataattataatgctgcgtggcgcagta
-caccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatt
-tgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattatatatgttgatta
-tttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgc
-ttaagtttgagagcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtgg
-ttgtcgtccataggtcactggcatatgcgattcatgacatgctaaactaagaaagtagat
-tactattaccggcatgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgccca
-tgtagccctgataataccaatacttacatttggtcagcaattctgacattatacctagca
-cccataaatttactcagacttgaggacaggctcttggagtcgatcttctgtttgtatgca
-tgtgatcatatagatgaataagcgatgcgactagttagggcatagtatagatctgtgtat
-acagttcagctgaacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaacc
-atatcgttcacacatgatatgaacccagggggaaacattgagttcagttaaattggcagc
-gaatcccccaagaagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcc
-tccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcg
-cggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatatctttggtagaac
-ttactttgctttaaatatgttaaaccgatctaataatctacaaaacggtagattttgcct
-agcacattgcgtccttctctattcagatagaggcaatactcagaaggttttatccaaagc
-actgtgttgactaacctaagttttagtctaataatcatgattgattataggtgccgtgga
-ctacatgactcgtccacaaataatacttagcagatcagcaattggccaagcacccgactt
-ttatttaatggttgtgcaatagtccagattcgtattcgggactctttcaaataatagttt
-cctggcatctaagtaagaaaagctcataaggaagcgatattatgacacgctcttccgccg
-ctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgag
-aagacgaagatcgactaaagttaaaatgctagtccacagttggtcaagttgaattcatcc
-acgagttatatagctattttaatttatagtcgagtgtacaaaaaacatccacaataagat
-ttatcttagaataacaacccccgtatcatcgaaatcctccgttatggcctgactcctcga
-gcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtg
-agatgatcagtttcattatgatgatacgattttatcgcgactagttaatcatcatagcaa
-gtaaaatttgaattatgtcattatcatgctccattaacaggttatttaattgatactgac
-gaaattttttcacaatgggttttctagaatttaatatcagtaattgaagccttcataggg
-gtcctactagtatcctacacgacgcaggtccgcagtatcctggagggacgtgttactgat
-taaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatg
-agttttacattagtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaa
-gagaatacatacaccaccacatagaattgttagcgatgatatcaaatagactcctggaag
-tgtcagggggaaactgttcaatatttcgtccacaggactgaccaggcatggaaaagactg
-acgttggaaactataccatctcacgcccgacgcttcactaattgatgatccaaaaaatat
-agcccggattcctgattagcaaagggttcacagagaaagatattatcgacgtatatccca
-aaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtga
-cctctagtatacaggttaatgttagtgatacacaatactcgtgggccatgggttctcaaa
-taaaatgtaatattgcgtcgatcactcacccacgtatttggtctaattatgttttattta
-gtgacaatccaatagataaccggtcctattaagggctatatttttagcgaccacgcgttt
-aaacaaaggattgtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaa
-atgagattctatcctaaagtttgggcttgatataagatttcggatgtatgggttttataa
-tcgttggagagctcaatcatgagctaatacatggatttcgctacctcaccgagagacctt
-gcatgaagaattctaaccaaaagtttaataggccggattggattgagttaattaagacct
-tgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaata
-ccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaat
-agttaactaatttaaaattaattaacgacatggaaatcacagaacctaatgctttgtagg
-agttatttatgctgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacg
-catcttttagttcagaaagtggtatccagggtggtcaatttaataaattcaacatcgggt
-ctcaggatattcggtcatataatttattaagggctcttcgagtcttactctgagtgaaat
-tggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcat
-tccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatataagaaaactcac
-acgtctcattattaaactgagtacaatttttgcacgagaaagtaatgcaatacaatatga
-tgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgcactggattaaaa
-tccgattatttttaaaaatattcagtgctagagcatatcaggtctacttttttatctggt
-atgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaagttataacataa
-ctcccgttagccaaagcccaatcccgattactgccctaccctaacgtctgccatctaaat
-atcgaacttgttatgatcaatgtgactacctcccaccctttccccttcatttgttccact
-ggggataagctagcgttttcagaatcaatgcaataagaatagccaattgtctcacttcat
-cagagctcttggcaattccaggcgctacgtggttctggaatatattcatttttcaaatag
-taatacgtttagtgttgctattgtctacacgtttggatattacgttatgtgagcggacat
-caatagttgtctaactctttagtaagccagagatagcactcttagcgaatggataccatc
-ttccataagtttagttaatagtccgaaacaactgcttcgagcatatttgaacctccttgt
-aggcaaatagcctcttcaaagcaatcttactaatagatagagtttgttttaagggactac
-tagaaatgggacaatcttaatagtatgacctaaactgacatttaaagatatatccaggtg
-gcaagcataaagatcattgcgccacctccaccgtgggattacttatcagtcgatatccta
-tatgctaagtttgcgacggcagaatacaaactaagctgagttgatgctaaccttacctat
-gataccccattggaccggttaacagccctacttattccaaataaaagaacttttatgctg
-tagaagctattatagtgatgcctggtaacttcagtatattaaaatgacacacatacgcca
-tatagagctcctggaactttgaataatgagcgaacttcgaagttgaagagcaagaaacca
-tatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattgatcattatcgag
-gttttcataaccttgacccattatcggctgtgcgcggacaagtacttaaatcactagttt
-cttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataagacggacgtaga
-gccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggattttaaattttgttcca
-tttttaatttagccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggc
-ctatgctactggaacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgta
-tttttgcggctagaatagtcagtcgcttggagccatataccttaccacttaaacgacgtg
-ctcctgtagttgaaatataaacagaacacaaagactaccgatcatatcaactgaagatct
-ttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccg
-caaggagtcgattgggaccctaaatcttgacgaattgctaagaggctcagagctaccact
-gtaatttctctagagcccataataaatgaacgatacatccgtaggtagcacctaagggat
-tataatggaagccaaatgcagttaataatattatatactggcgtacacgattcgacggat
-ctctcacatagtgattcacgacccccccctttgattgacacagcgtcagcattttgcaag
-aacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtat
-aatttaccatgcttccctgatgctgagtgcaatacactaagaatgagtttttaccccata
-tcaccagtatttgttctgttattgcgaagaaatggctatgctgagttggcgactaaagtc
-acccatcctttttattaggtaaccccctcccttaaactaactgatttgctggagctgccc
-tgcatacatatactttatcatttatggacgtccgtgacgcttattatccaccatagtcga
-tatgctacacggattcattaatggatcgtaggagtttaagttatatttactaagatcggt
-ctcggctactatcccgccttacccggcgctatttacggccatttttaatatattgacggt
-aattattcctatggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgt
-aaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtgatgagtaacttga
-cgaaatgttagtggttattaaagactatctattacaccttttgttttctgtcgtagtata
-ttaaagtctagaagccttacaggaaaatcagggttatacagccgatactccgcagcatga
-atcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtattta
-gaccttttatacaaagtaaatatctcggctttatgtgattgggaggggcctactcaaaca
-tgatgacttgacctaataatcactgtgcgggcgtcttatgactagctattccttgaaatc
-caccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagtta
-ctttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttactt
-ccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaac
-aaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaactactcgaagat
-gtttcgttttcttaaccataggggcttcttaatggcccactacgcacattttgttcaagc
-ccgagagggacatccccattacgggagtattactaaaactgttccgtaatacgttcagca
-agggatgaaaaaggccactgctcaagttattgacgtgggagtattacatcggaagcctga
-atcccacactatgatggtctgtacaggcctagggactgcgtctagacggtattaccggct
-tctaatcatacgatcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatt
-tatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaa
-aaacccccgcacataagccgctttagatttcacaaataccaatgcggttaaaaacatcct
-tgagtcgtacatacaccatactcgcgttaaacggatataacagaagataataaatccgga
-tgtggagtcggtgtaactatagaaagccaagtgaaataatgcttaccagtcatttagcta
-tacggctttcatttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccg
-atacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaac
-aatagatgggattcattatacataagacacgatgatctgctttttcaggttgcgagatgt
-tgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtattgacagggaacc
-tattttcgaggtattatatagtccagcttgaatatcaatttgacagttaacctagtgaaa
-atcagtaagaggaaatacgccacattctccagtgaaattctacgggttatcgtctagtcc
-aactatcaattataactcacgagatataagtaaattctcgtacttggcctgatttttatt
-atactttggatccttagtaaacaggaagggagaaaccttcaacgaaaaacactggatttt
-gttttactctcaaagctcttatatgacggaaataccctgtcaagtcttaactttattact
-agactaatgaaatgggcttggggtggccagaatcatagtacaatttagcggatacactat
-tcggactttcctatcggctgtctggttggataagtatggggactaataggctagacatac
-ctatacttaaactatacaggcgtcatctatctctgcaactttggagttccctgatgttct
-cccgccctttgggttcacatcttctataccgacacccctaataacgattagtttgtgggt
-tagagtaaattaatacggttaatattaatgtatcgttgaaaagctggtgtcgccaataag
-gtaaccggctaggcagagtatatgtcacgaagtataactaccctaatgataagctgtagg
-aataaaattaatgctgtctctaagcgaagagatatttccgactctgttttaatgacgaat
-ctcattacttctgacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacg
-catataatgaacttagaagattataacgacggaactttatatgataatccgttacgatta
-aagaatctgttaaatatcataatggcattcagttctagaccgtgcatcatggtaaactta
-ctttctctgcatggcgacatacatttcgctattcaaattcgcgtgtggttacacccactc
-gcacctttggaatattaagagaagatgatcagaaaatccattcgctcaatttttctgacg
-tacgtctaatttatcctaggagacaaatcgttttatgtctctcacatttttgaagaaagg
-ttcgagagacaatactcaggtcctgaactgctagaagatactcggtggagcgtggcaaca
-atgaaaaactcgtgacataaatgaatgatacttttccaagttcagttaagtgaatatgtt
-taacatacccggcttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctct
-tacatacactagtgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactc
-acgctatgtattgacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgt
-ccctatgtgctaatatataagttagatcgcattagatgctaatctgaatacttatagacg
-accttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagg
-gacatataaaatttgagtgcggctttagttaagggtttaattacctactcaaacatcacg
-ctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgtactaggtagtga
-ttaatgatatcctagacgcacgtgccttagatcttcagactctgatggtccgcgatcacc
-gtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaa
-tacttataatacaataaccaaggatgagaatgactcatcgcgttggagttatattgcttg
-aagttctatggaatgaaagcacgttatctgccgtcccaatatctccagtgagctaattca
-ttggacggtccactttgatcaatccccgaggagatgttcggacactttagtctgtaacac
-ttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttttccaaagttcat
-tttaaataagactacgataggcctttcctattgatataaactacccggctctgttgttcg
-tgtgagtcgtacttctctgtgtttttctgattatagcaagattcgattcttagtgtaaac
-agcgatttttatttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagt
-tgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcccacgttgatagt
-atgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgca
-tcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgatatttagcaagag
-gcgttgataaagccctcatcatctagatctcgacctcatctgccctcttgctccatcatt
-ttctacacagactactttcctatctacgttagtataattgctttctatcttagtatcatt
-tagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgta
-gcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaagaagtttgtcat
-tctattagacattgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaa
-gactgtgattaactaaaatagacaagccactatatcaactaataaaaacgcccctggtgg
-tcgaacatagttgactacaggataattaattggactggagccattacattctctacaatc
-gtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttc
-gcaggagcacattggtagttcaatagtttcatgggaacctcttgagccgtcttctgtggg
-tgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccg
-gaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgtttaagagttacc
-agcttaatccacggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgc
-attctatcgttatcctatcaacggttgccgtactgagcagccttattgtggaagagtaat
-atataaatgtagtcttgtctttacgaagcagacgtaagtaataatgacttggaataccaa
-aactaaacatagtggattatcatactcaagaactctccagataaataacagtttttacga
-tacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaacgctaattcatt
-tgttattggatccagtatcagttaaactgaatggagtgaagattgtagaatgttgttctg
-gcctcgcatggggtctaggtgatatacaatttctcatacttacacggtagtggaaatctg
-attctagcttcgtagctgactatactcaaggaaccactgctcaaggtaggagactagttc
-cgaccctacagtcaaagtggccgaagcttaaactatagactagttgttaaatgctgattt
-caagatatcatctatatacagtttggacaattatgtgtgcgaaactaaaattcatgctat
-tcagatggatttcacttatgccttagaaacagatattgcccgagctcaatcaacagtttt
-agccggaaacaatcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagat
-ttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagttt
-aaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaa
-cgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacacattagtgaatat
-cggccaatgaaccaaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcag
-gttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaacctcattgtaaca
-atagcccagcaaattctcatacgtgcctcagggtccgggcgtactcctccatggaagggc
-gcgcatctagtgttataccaactcgctttttaactactatgctgtagttctacaggcata
-gtggccagtattttctaacttctctggatagatgctctcactcctcatccatcacggctt
-cagtttacgtcttacttgcttgttcagcaacggatggaggcattaagtatcttcactgtt
-ccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactc
-attgaatactgccccagttgcaacctcacttaatctgacaaaaataatgactactctaag
-tgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtataggcatgtaact
-cgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccagg
-taattgatgcggatataagctggagatcactcacgcccacacaaggcgctgctacctctt
-tattccaatgtgtaagaatttgctaacttcatttctagaccgcagctttgcggtcataat
-ttcacggtacggacccttgggttagagacttgataacacacttcgcagtttccaccgcgc
-acatgttttagtggcttctaacatagaatttttgttgtgacataaagagtgcgtgggaga
-cttgcccgaccgttaagccataatcaattgaaagccccgtgagtcacatctaattggttg
-tactgcgcatttagctatcctttagctgactcgaagagattcgattcctaatataggtta
-attagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataact
-cgcgcttaattacttatgagtagttccaagttcgctacgttatgagagagattggaatta
-agcaaatatgttttatggtgattttgggatgagaaggactgctaagtacggctactaaac
-aaatttctaaaaccgccatctaccttatcttggagacatttaagttgtatatgtcactag
-tctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatc
-aaatgcttatctaagaaagtagtggactattacaccaagcacgaatgccagggaactgct
-ttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaattacatttggtca
-gcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttg
-ctctagatcttatctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtg
-agggcttagtatagttctctgtatacaggtcacatcaaactccccctgtcctagtacagc
-tctgagctttaattaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatc
-atgctcttctcgtatagggcaagagaagcaacaaacaactagcccgactcacgttcatcc
-gccgtatccttgttcagttcttactccgtattaggtcagcgaaatctaatcagaataatc
-ggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttat
-cggctattagatagtggggtgaaagtaattggctggaattatgttaaaacgtgatattaa
-gctaaaatacgctacttgttgccgacctaattcagtcattcgatattcagttagagccaa
-gaataacaagcttgtataaattgaacggggtgcactaaacgatgtgttactctaatattc
-agcttggagtatacctgaaggcgaattcatgtatcggccaataataagacgttgaagatc
-acaatttggactagcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagt
-acggtctctggaaaattataggttcagggaatataaggaagtaaagataattaccaagag
-atttttggtatcgctatgacccagaggtgttctaacgtctgttttgatccgcagaatttc
-tgcctcaatgcatatttgacggacttgaactagagcctctaaagttaaatggcgacgcaa
-ctgttcctaaacttcaattattactactctttttttcctagggtattgtagaggccagtg
-gacaaaataaatcaaatttaagatgtttcggacattaacatcccccgtagcatagaaatc
-atcagttatccaatctctcatcgagcttttacaatttctgctggcgctatggacagcata
-tgccgcgagacctccgcaagactcacttgatcactgtaagtatcttcattagaggttaga
-gcctatagttaagctgctgacctagtaaaattggtattttctaattttattgctcaagtt
-aaaggttagtgaagggataatgacgttatttttgaacaatgggttgtattcaattttata
-tcacgaatggaacccttcattcccggcataatactagacgacacgaacaagctccgatct
-atcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgac
-ctgatgcaacttagggtcacgatgagtttttcaggactacttattacctattaataagtt
-aacatgagccttcataccccgtaagacaatacatactccaccaattagaattctgagcca
-tcttatctttttgtatcatcgaagggtatggccgaataggttaattagttactcctaacg
-tctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtc
-tagtatgcagcatcaaaaatatagtccacggtttccggattaccaaacgcggcaaagaga
-aacattgtatcgacggagataacttaatacagaaggaaggggcatcttcgaatacggatg
-aataattctatctgtttattctgacatcttgttttcaggttaatcttacgcattcaaatg
-acgcctgccccatgcgtgcgcaattattttctaatattgacgagagcaatctcactcctt
-ttgggtctatttatgttttattgaggcacaagcctatacagaacaggtactattaaggcc
-gtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttag
-tgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgggctgcatttaag
-atggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccat
-gtagattcagatcacacactcattccttgatgttgtctaaacaaaagttgttgtggacgc
-attggagggagttaagtaacaacttgggatcgcatacttataaaaattatatgttaaact
-ttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagtcactaggtatta
-atggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaa
-gaacacttaataaggcttgcttgcacggaggtatgatgtttactgactctacaaccctaa
-ttttccagtacgtacattcattccaataggttagttctcaaagtgctatacaggctcctc
-aattgatgatatgcttcagccgctctatggatattagctcattttatttaggaagcccgc
-ttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatga
-caccgctttacatagaatttgaattaaaacgcgctctcccgttcactaccatacttggta
-ccgtgcgcatattacatatagatataggatcattttttaaagctgtactaggtttgatcg
-acaatcttatgctatactatatgatgtaaccctcataatcaataccgatcgtacgatcct
-agcataggtggcaagcgattttatgccgattattgtgttaaatagtctgtgagtgtgatt
-atcagggctacgttggtagaggggttgtatagacctcgcacacattgtgacatacttaac
-aatatacgaaaactgatataataaatccccttacccaaacaccaatcccgttgaatcaac
-taccataacgtctcccatataaattgcctacttgtttgcataaatctgaatacataacac
-cattgcaccttcttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaa
-caatagcatttgctagcaattattaacagctcttcgaattgcctccacataacgcgggag
-ggtatattttaatttggcaaatactaagtactgttggcgtcatatgctattaacggttgg
-atattaagttatgtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagag
-cactcttagagtttggatacaataggccatatgttgacttaagaggacgtaactacgccg
-tacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaatcttaagaatag
-agacacgttcgtgttagggtatactacaaatccgaaaatcttaagaggatcacctaaact
-gaaatttatacatatttcaacgtggatagatttaacataattcagccacctccaacctgg
-gagtaattttcagtagatttactagatgattagtggcccaacgcacttgactatataaga
-tctggggatcctaacctgacctatgagacaaaattggaaacgttaacagcccttatgtgt
-acaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgcgtaacttcacta
-tagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatgaatgacagtaat
-tcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaag
-ctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgag
-cacatggaagtatatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaa
-actttcgatttagtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccaga
-aatacgagtttaaatttggttacatggttaattttgaccgaagcatcgcactttatgatt
-gataattggattcaatatgtcgccctatgcgaatgcaacatgatccacaatttggctata
-agacgtttaatccgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaag
-agtcagtaacaattataagtactccgcaggtacttcaaatataaaaactaatcaaacacg
-acccatatgatcatctgaagatatttggaactttctcgacaaccaccctcgtactcaata
-cttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagattt
-gcttagtggcgatgagcgtacacgcttatttctctagtcacaattagttatctacgagac
-atcacgagggagcaaataagcgatgttatggctacacataggcacgtatgaatatgatat
-aagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgagg
-cacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggat
-caactagaagagaaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttca
-ctaagaatgtctgtgtaaccaatataacatctatttgttatctgattgcctacttatggc
-tttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtaccaactccctttaa
-attacgctgtgcaggctcatgcactgcatacatatacggtagcaggtagggacctcacgc
-acccttattataatcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggt
-gttggtatattttctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaa
-gccaattttgaatatagtcaacgtaatttttactatgggttccaccgaaacgccttgcac
-aactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaataccttcatata
-tattttttcggttgactaacgtgaactaaggttaggggttttgtatgtctatataggaaa
-cagtttcttttctgtcctactttagtaaagtcttcaagccttactccaaaatcacggtga
-ttaagccgttactcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaa
-gagtcgctgtgtattagctagggagacctttgttaaaaaggatatatcgcggcgggatgt
-gagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatctctcccccacgct
-tttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtact
-tgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagagaattgagtgtaa
-aaccgtaaagccctcacctgacttcatgtaaatggcttagaagactccatgatttaataa
-atactacgaaggaaagactggatctaaagataactctagtaaggccaactcccttcaatg
-ctgttgccagttataatccaagagctgtccttttctgaaccatagcggcttctgaagcga
-actagaagcaaagttggttctagccagacagccacataccctgtacgggtgtattactaa
-aactggtccggtattagttcaccaagggaggaattaggcaaaggatctaggtatgcaagt
-cggagtattacatccctaccctgaatccatcaataggttcctctgtactggccttcgcaa
-tgagtattcaaggttgtacagccgtataataataagatagtgactatgaacgggaagtaa
-cccgctcaccttccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaa
-tactcgaaaataaacaactggcaaattacaccgcacttaagccgcttttgatttatattt
-ttccaatgcgcttttaaaaataattcagtcctacatactaattaagacccttaaacggag
-atatcacaagttaagttttaaccatctcgactaggtggaactatagatacccaactcaat
-ttatcattacctgtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttc
-acagcgaaacttcagtgtgaacagattctgagaaatcacctaaacctattagtcagagca
-cccggttagaaccagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgag
-atccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatt
-tttaaatactaggcaaacccaacataggttagtcctatgtgatacgccacatggtatatc
-attttgtaacgttacctagggataatcaggaagtggaattacgcaaaagtagacagtgaa
-atgcttagggttatagtctagtccaaagataaaggataaagcacgtcagagaactatatt
-agccgaatgggaatcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaac
-agtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtac
-ctgtatactagttactgtattacgtgtctaatgatttcggattggggtccccagaatcag
-acgtcattgtagacgattcaagtttaccaatttaatttcccagctctccttggagaacta
-tcgccaataattgcagtcactttccttttctgaaacgataaagccgtcagagttctctgc
-aacgttggacttacctgaggttctaacccactttcggttctaatagtagttaacgacaca
-acgaataacctttactgtggggctttcacgatattttttcgcttattattaatggttacg
-tcataagctggtgtccaaattaaggttaccggcttcgcagagtagttgtatccaagtata
-acttccctaatcataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatg
-tcccactatgtggtatggacgttgctaattacttctgaagggaaattggtcattatggat
-acgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttgatccaccgttct
-ttataggataataactgacgattaaagattatggtaaatagattaagccaattctcttct
-tgtcagtgaagcatccttaactgacttgctctgcagcccctcatacatttagctattcaa
-agtaccggctcgtttcaaactctcccacctttggaagaggttgtcaacttgataagtata
-tcatttacagcattttttcggacgtacctctaatgtttcattgcagaaaattagtttttt
-ctatcgcacattttgcaagtaacgttagagacacaattatctgcgaatgaactgctagat
-ctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttga
-caagtgctggtaagtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatg
-cacggcagagtaatgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaag
-acccctccattctcgagcccactcacgatatgtagggacgacaacttgtgcggcttatga
-attgtctggactgcgggcgagggtccatatctccgaagttagaagggacatacctttaga
-tgataagatcaattcttattgacgaaattcatccacaacggggaacaacttcaccctaga
-cttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggct
-ggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggc
-tatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtgcctgtgatatta
-acaagatgatccgacgcgagcaccgtaattctaggcataaaactccagcaatttgggggc
-cgaaaacaaatgacgttagctaattaattatatgacatgatcaaaggaggtcaatcacgc
-atcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggca
-aaattgatcctgtctcctatttcatgcgtacctcctagttgataattccccgagcagtgg
-ttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgta
-tggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcagttcctattgatt
-tattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgtttatgattattg
-ctactttagatgctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaat
-tggatagaacctatagtttcaagttctgccacaaggtatcatatttacagttagtgctgg
-ttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggacc
-gagtgcgcgttcaaccctgttccagagagggtgtgatagcacatataccacgctcgtcga
-ggcgttcatgatagtttgcaagagccggtgttaaacacatattattattgttatccaact
-aatcggacctatgcataaagcattgtctaaacagaataattgcctatatacggtagtttt
-agtgatttatatcttagtatcagttagagcttcgaactcttcaggttcctcatatttaac
-gttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctat
-aaatcacagaaagatctgtctcagtatagttgaaatggtattcagctagtgacgtgtacc
-aattatcatagttcactcaagcaagacgctcattaacgaatatagacaagacactatatc
-atataataaaaaagaacatggtgctcgaacatagttgaattcaccatattgaaggggaat
-gctgacatgtaattcgctactagacgatcaattccctacttgtcaaagttgaactggtac
-gttcttggaattaaatatgattgcgctggaccaaattgcgacttcttgagtttcagggca
-aacgattgagccggaggatgtccgtctcttacctttcttgcttatgataaacgacggtcc
-ctgtacatcactgggaattctcagcaaaaataattgggtaaatcgagactcgatgtattc
-ggccacaaaggtgttagacgttaaagattattcaacggggcgataataggatcataaccg
-gtatgcaagcgcattgaaagagccatgagatccttatccgataaacgctgcacggtatgt
-gcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaagttgaagaccta
-agttataatgaagtgcaataccaaatcgattcatagtggattatcagactcaagatatct
-cctgataaattacagttgttaagatacggataaaatgagatttaagattagcagcctcta
-atctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctg
-tcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagttaatatgtagct
-tacgttctagcttgtgctaatctgagtatagattcgtagaggaatattatcaagcttcca
-cgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactat
-agtctagttgttaaatgctcagttcttgttatattcgatatactcttggctaatttatgt
-ctgagtatataaaattaatgatattaacttgcatttcacggatcccttagaaaaagattt
-tgaccgagcgcattataaacggttacaccgaatcaatagaagcatacccaatagctttct
-ttgaatttattgcctgcgcaacttggctgactctctagatccgaataattctatatggtc
-gtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgggccgataatggc
-tctttgcaaaattactcaatgatacgattgatcaaagcggtagttgctagtggtagcatg
-taagtctatcaaatgtctgattatccgaaaatcttccaaaagagtccacgtaccatatct
-atctcatagcgacgcgaggggaaccttatctaactatcattccatttaccgggtgactct
-cgatgcaggatccgattgggataaattgcccagaaatggctcattcctgactaagggtaa
-ggccgttctcagcaagggaaccccgcgaatctaggcttataccatctagattgttaacta
-cttgcctgtagttctacagccatactggacagttgtttctaaatgatcgggattcatgct
-agcactcctctgaatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatg
-gaggctgtatgtatcttaactgttacctaatatggctggtaattatcaaagtaaggacct
-taatgccatagcgctagcaatcgctttgtatactgaccatgtgccaacctctcttaatct
-gtaaaatataatgtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgt
-atcaattcctatagccagcgtactagtgacacaacaacaccgtgtgagaaaagatattag
-tccttacgtctgtctctctacagcttattgatgaggattgaacatggacatatagctccc
-cctcaaaagcagatgctacctctttattccattctcgaacatttgccgaacttaatttcg
-acaaacctgaggtcacgtcttaatttatcggtaacgtcacgtccctttgagactggataa
-atatattaccaggggccaacgagcaattgttggaggcgcttctataatacaaggtgtctt
-gtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaaccc
-ccctctctcacatcttatgcggtgtactgccctggtacatttcctgtacaggactccaac
-agtgtagattcctaagatagctgttggagttgcctcacgccagatcgaaaaactgaataa
-actagtgagctgagctgcagaaataccgcttaattacttatgactagttcaaagggacct
-acgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattttggctggactag
-cactccttacttcccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctga
-catttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatga
-ccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctggtcgttgaaacc
-aagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcat
-tagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaaaaaatattttta
-agcagtaggcacctaacccgattcctctacttagtagctttctttgattctcagaattga
-ctgcaatatcactgcacaattctgtgccattactagacttctctgtattaacgtctcatc
-ttactaacactcgcctaggacacatctgagagtgaagtatttcaatacatttactgaaat
-cttcagttctaaaatccccgaataaggctcttatcggtttggccaacacaagaaaaaaac
-ttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaataactatttcgg
-cagacaaagcttataacaagttgccggcgcgtataatatttaaaagaccccttgagctgc
-tcaattaaaacgctcacctggtataggctattagatagtgccgtcttagtaaggggcggg
-aattatcggataaactgatattttgataaaataaccgacttgttcacgacataagtcact
-aaggagattttatctttctccaaagtatatcttccttggataatttcaaagcgctgcaat
-ttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgtagtaatctagag
-gcaaattataagaagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccg
-gcgcattgtgtaaactggacgagtaccctagatggaaaattatacgttaagccaagattt
-cgatgtaatgataattacctacacatttttgctatccataggaacaagagctgttctata
-ggctcgtggcatacgaacatttgctgccgctatgaatattggaagctcttcaactacaga
-ctctattcttaattgccgtcgaaaatgggccgaatcggctattattaatactcggttttt
-ccgaggggattgttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatt
-taaatacaaccttgcagacaatgaataagggatccaatctctcatactccttttacaatt
-gctcatgcccctatgcaaaccttatgccgccacacctccgcaactctctcttctgaactg
-taagtagcttcattactggtttgagactatactgaagctgatgacattctaaaatggcta
-ttttcgaatgtgattcataatgtttatcgtttgggatggcagaatcacgttatttttgat
-atagcccgggtattctattgtatagaacgtatgctacaagtcattccccgaagaagacta
-gaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctttatttcccgata
-acctatcttccataaatagcggacagcaggatactgacgctcaacatcagtggttatggt
-ctaatttttaacttttaataaggtaacttcagcaggcatacacagtaactctttaattta
-taatcaaattagaagtctgacacttcttatatttttctatcatccaacgcgatcgcccat
-tagcttattgtgttactaataacgtatctaaaccaatccttttcaagctactgcctatat
-tgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtac
-gctttacaatacccggaaatcacaaactttgtagacaacgagtgaaatttatacactacg
-aagggccagcgtacaagacccatgaattaggcgatatgtttattctgacatattggttta
-tccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaaga
-ttcacgactgaaatataaatacgtttggctatatttatgttggagggaggcaatagcctt
-tactgttaaccgaagatttagccagtgagtgtgacactaaaacactggaataaatgcagg
-cgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatatagctctggatat
-aattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaagccggcctctca
-tattgaaggtccgaagtattccatgtacattaagatcactctctcattcatgcatcttgg
-cttaacaaatctggttgtccaagctttccaggcacgtatggtacaaattcggatcgaata
-cttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaa
-ccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagg
-gattagttatgttacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgca
-tcttttatcaagagactaacattattttcaacgacgtacatgctttacaatagggtactt
-atcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccgatatccattgga
-ccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtattgccataatgtaa
-tacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgc
-gcaacgtcaatacctttaggggtaacggccgctgatttcatatagatatacgataagttg
-gtatagctctactaggtggcatccacaatcgttgcatttactatagctggttacaatcat
-aatctataccgttccttacatactaccatagcgggatagcgtttttttgccgttgattgg
-gtttaagaggatgtcagtctcattatatccgattcggtgggagagccgttgttttcaaat
-cgcacactttgtgacataatgtacaagataacaaaactgatataagatataaactgtcaa
-tatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatttgactaattggg
-tgcagatttctcaattaataaaaaaatggcaccggatgggcttacaagccccttatcatt
-cacttgtatcatgatttccaagaacaatagaatttgctagcaagtatgaacagagattcg
-aattgcatccacagtacgccggagcgtttattttaatgtggatatgacgatgtactgttg
-gcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggag
-aaatatggtggtacaatctcagagaaagattacagtttggtttaaataggacttatcggg
-tcggaagtggaacttaataagcagtacacaattgggcaacagacgtcttgcctattacaa
-taggattacaatgcgttagatttcagacacgttcgtgtttggctattcgtcaattcccta
-aatagttagacgatcaactattatcaaagtgattctttgttcatcctccattcatgtaac
-agatggcacactacgcataacgccgaggaattttaacgagatttaagagagcagttcggg
-cacaacccacttgactttataacagctcggcagcataaacggtaatatgtgacaaatttc
-caaacgttataagaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgt
-gacgcagcaagcctaacttatctattggttttgctataaaagaacaaagttacacagaat
-cctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccgg
-cacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactccgggtatgataa
-tggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggttaggataaggatg
-agaccgaacttatttccggccataactttagattttctacctagtacacaacatcagggc
-ggacacgaaaccgccatcacatcatataccaggtttaatttgcttaatgggggaagtgtc
-aacgaaccttcgaactttagcaggcatatggccattatatatggccccagagcagaatgc
-tacagcagacaaaatttggatttatgtagtttaatacctatcaaacttggtgtgaccata
-cttgtctaacgacagtgcacaaagtgtaagttacaattattactactcagcagcttctgc
-aatgataaaatcttatcatacacgtcacatatgataatatctacttagggggaacgggct
-ccacaacctacatagtactcaatacttacactattcgacaggcacaccaaacctgtacag
-tcccaaaagattgagtcaactttgcagtactgcagatcacagtaatagcttagttagcga
-gtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgatgtgttggctaca
-aatagcaacgtatgaatttgtttgaagccacgtaaactgtacaaccttagagataagtct
-caggctactaaaaacacgttgtggcactaacaggatcatggttgattcttacttattcgg
-ctgaccggcccaataagtaaccttcaactagaacagaataatcgggagtagtttaattca
-gtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgtttt
-cttagcggattccctacttatggatttgagctcgtccacaatattcgatacaagaagttt
-gtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaaggaattaataga
-aggttgatggtaggctccgaacgctccatgattataatcaagtggactgtgcagtaaacg
-aggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagat
-aaaccatgaacagcacagtgtgaacccatggttgattttaggctaccttatttttaattt
-ccgttacacagaaacgaattccacaactaacatgccattaatttttcgatatcttataaa
-agatggtcgaaattcattcatttattttttttcggttctcgaaagtcaactaagctgtcg
-cgttttgtttctctttagaggtaaaagtggctttgatctcctacgtttggatactagtca
-accattactccatttgatccgtgagtatcacctgtctaacatccagcattatgactcctc
-ggcgaagaaaagacacacttcttagagtcgatgtgtattagctagggacacagttgttta
-atacgatagtgagcccagggagggcagtgcgtcccccagtagatttattcagctagtgta
-agtataagatatctcacccacgaggttcaagtgatatgcagtcttagaataatacttatc
-ctgaatttcgatattatgggtacttcaataatccgctagcgctactttatgtctcgttgg
-acagcaggacacatggcagtcttaaacactaaagacatcacctgaatgaatgtaatggga
-ttacaagaatcaatgaggtattatatacgacgtaggaaactctggatatatacagtaatc
-tagttacgccatcgcacttcattcctctggaaacttagaagacatcagctgtacgtggag
-gaaccagacccccgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaat
-gacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaaacccagcattta
-gcaataggagctacgtatgcaactcccacgtggtaataccttcaagctatcaatatatag
-gtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccagtataataattac
-agaggctctatgaaacccaactttccagctaaaagtcccaattaaatggttatttcgtac
-ttttaaagtcgcccgttctgttattacgcgaattgattctactccaaaattaaacacaaa
-ttatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataaggctctactaaat
-tataattaagacacttattaccagatttctctagttaagtttgaaccagctcgactaccg
-cgaaagatacattcccttctctatttttcagttcatctatgggtcagagaagcattgaat
-ttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaat
-atcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctg
-gaaggagtaagaagtatacagctgatccggtgtatccttcagtcatctgccctatactaa
-ttacacgacgcaaggaaaaataggtttattttctaggcaaacccttcataggtgactccg
-atgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggataataacgatctcc
-aatgaaccaaatgtagaatgtctattgattacccttttactattcgacttagagatagga
-gatagaacctcagtgtacttttttagccgaatgggaatctttgggaggtgaatggccata
-aggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgttcgtggaatcgat
-aacagatttgttgacccatagtaaatgtatactagtttatgttgtaagtgtagattgttt
-tccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaag
-tgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggttta
-gataaagccgtatgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcc
-cttataatagtagtttaactataaaagtatatactggtctgtcgccctttcacgatttgt
-tttaccggtttatgaagcgttacgtcattagagcggctccaatttaaggttaacggcttc
-catgtgtagttgtatacaaggataacttaaagtatctgttcagcgagctagttaagttat
-cctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttgctaatttattct
-caaggcaaattgggaattatcgatacctgtataccataaggtcgctcgatgtgatgctta
-tgtcttctggtgatcctaccttagttagtgctgattaacggaacattaatgtttatcgtt
-ttgagatttagccaattctctgattctaactcaagatgccttatctgacgtgctatgcag
-cccctaagtattttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgtt
-gtggttctctactggttaactatataatttacagctttgttgagctagttcctctttggt
-ttaagtcctcaatattagttggttcgagcgataagttggctagttaccttagtcactata
-ttagatccgaatgttatgcttcatctgaagaccgccaccctccaaaatttcttttaagac
-tcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacg
-agtttccatattttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtc
-gctctacaaggggacgcaattaagaaacagacatgctagtcaaaaataaacatagcgagg
-caccactaattcggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagt
-agttagttcggacatacatttacttcagatgatcaattagttttctacaaatgcttactc
-taccccgaaaaaagtcaccagactcttacgtctctttagtatccttccgtcttatataag
-gtcagtcccccgtttcggtaccctggaatttactaagaataatgaaacagcccccaagga
-cgtacgtttacaaatgatagaccagatcgcctagcttattccgacgcatgttgcatagaa
-ttgaaccaacggaatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgc
-agaatacgcctgatagttcggccacgaaatcatatgtcctttgagtattaagtatttgta
-atgatcaatcgagctcaagcaagcttacacttcctcggatattcagggaacttagtgcct
-ttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaatgcctacctcat
-agtgctgaattaacacagcactgcggacctaacttttcgaggtttcaagttcacgtctca
-aaacctaataggctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgta
-gtactgaccaagtgaatattctttttttctaaaagcagatctgctgccgggcactacgaa
-ggagatctctgtgtatcattattgcttcttgacatgatgactcttaaatcactgtgggtg
-tgcaaaacgatagcacaacccaattcgatagtacatattgttgatacttcgcactaaacc
-gttcatatttaaaggttgtgctccttccttcgttaaatactggtgacttggtcctatcta
-ctattagctagacctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtca
-tacatcttagacatcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaac
-aaatatgattattcttatactaatattagcaaagatgcataatgatttgtattaaatgta
-taattgaattgataagggtcttttagtcagtgatagagtagtataaggtagacattagaa
-ctcttaaccggacgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggta
-agagcggttactagtagtacctataatgcactgaatcttcggtcgaagtatagttctaat
-gctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgta
-agtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggg
-gaattaaccagattgaaggccaatcctcacatgtaatgagataatagacgataaatgaaa
-ttcttgtaatagttgaactgctacgtgatgggtattatatatgattgagatcctccaatt
-gccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgt
-cgtccgtatcataaacgacgcgacatgtacagcactccgaagtataagcaataataatgc
-gggtaatccagactagatcttttcggactcaatgcggtttcacggtaaacatgattaata
-ccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgtt
-gcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgac
-gaggcgcgggaacttcaagaactatcgtatattcaagtccattaccttttagtttcagac
-tggtggagctgactaaagttatatcatcattttgtacactggtttagttaacgataattt
-cagatttaacatgaccagacgataatcgctgtatatccagttggaatgtggtttgccaga
-aaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcg
-ctatacctcagtgtatttggagctgtagttataccgtgtgctaagatcagtagacatgac
-gagagcaatattatctaccttacaagcatcaacggacgtctagtcggaacaaaagactct
-aaaactcgaacttcaggttaatatactatagttctgtattcagcagttattcttatattc
-gatattatcttgcctattggatgtctgactttagtatattaatcatagtatctgccatgt
-aaaggtgccagtactaaatctgtttcacagtgcgaattataaacggttacaaccattaaa
-gacaacaagaccctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgat
-acatcccaattagtctatagggtcgggacgattctacggcatttctggttataatgacaa
-catggattgtggcccgagaatcgctctttcattaattaagcaatcattacagtcttataa
-gcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgagccgaatagctta
-aaaaacaggccaccgaacattgatagagaataccgaccacagcgcaacctttgattactt
-tcattaaattgtacggctcactcgacatcaagcttaagattgcgataatgtgaactcaaa
-tggatcagtactgaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgc
-tgttacaatatacagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttgg
-ttagaaatgatagccattcatgatagaaataagctgaatgataccagtatctttaactat
-gtagtcagggggaagataacgatggtccatgtatgtttctgatatgtgacagtattggcc
-gcgtaatttgctaacgaagctacttaatgcctttgagcttcatatagatttctttaatca
-aaatcggcaaaaagatagtatgagctataatatatgctagtagagaactctggaccatca
-tctatatgaatactgattcgagcgtgcaattactttagcctgcgtactactgactctaca
-aaacactctgagataagtttgtagtcagtaagtcgctctctataaaccttttggatgacc
-attgtacagccacttatagatcccaataaatagcacaggagacagagtttttcaatgctc
-gatcatttgccgatagtattttcgtctaacctcagggcacctattatttgatacctaacc
-taacggccctttcacaatggagaaatatatgacatcgggacaaacacaaatggtgggtgg
-ccaggagatatgacatggtggcgtctctaagaaacacggactccctctaggcaaactcac
-gtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggt
-acattgactggtcaggaatacatcactgtagttgccgtagtgtcctgttggtgttccatc
-aagacacatcgtataacgcaatttacgacggacatcagatcaagttatacagattattta
-agtatcacgtgtgcattgggacataagggatctcacacatgccttggaacatttttgctt
-tgtgccgctttttcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaa
-cagaatgagaaaggttagggctctaagttatcgtcgattgggatagacgagacatttgcg
-agcgccctccacggatacgaatctcccatatcaatgtgaactggatgctatgcagtttag
-ttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacc
-taatacacaaaaccgtcaaacattttctaattctaggtatgggccgatcataggagctaa
-ggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgcatatactgagta
-gctggcgtgcattctctcaattgtatcctttttaactgaactagtcggtcccatttcgtg
-actgagatctattaaccgataagattaataacactcgcattcgtatcagctcagagtgaa
-gtttttcaataatttgactgatatattaacttctaaaataaccctttaagcctcggatcc
-gtttcccaatcacatcaaaaattcttattccaactatctacggattaacaacgtgcatgg
-ggatcgtagtaagaacttgttccgatcactttgagtatatcaagttgacggcccggttat
-tattgaatagaaacattcacctgctaaattaaataccgcacatcggatacccgatttcag
-agggccgtcttactaagggcaggctttgttcggtttaactgagatgttcattattttaca
-gtatgcttcaactaatatgtaacgaaggacagtggatctgtctccatagtagatcttcag
-tcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtg
-aaagcaacccctagtattctagacgaaaattttttctagttcatctgataatttgccaat
-tcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcgaacctagagcca
-ttatttgtcggtaacccatgagttccttcttttcagaagttaatacactgtggtcctata
-cagaggaaaaacagcggttatatacgatcgtggcataacaacattggatcaagatagcaa
-tttggctacctattctaattctcactagattcggtattccactacaatatcggcagatta
-ggattggatgaataatcggtgtttaagtccggttgcgtctccaatctcctaatttttatt
-aatattgatcttggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaa
-agatagaagactcatttgaaaatggatcatccacagatccaaacattagcaagacactaa
-tccccaactagctattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgtt
-catgatctaattctttttgggctttgttcgatggtgattcagaatctttatccggtcgct
-tccctgtagctactttgtggggatattgcccggggattatagggttgagatcgtttccta
-aaagtatttaaaccaagtagacttcaactaaactacatcagaacatcgtgaagacaccat
-acgcggtacctttatttaccgataacatttcttcaagaaataccggtaagcagcataatg
-accctaaacagctcggggtatcgtcgtagttttaaattttatttaggttactgctcaagg
-aataaaaactaactatttaatttataataatattacaaggctcacactgattagatttgt
-ctataagacttcgcgatcccccattaccggattgtcttaagaataaactagataaaccat
-gcattttctagataaggcctttagtctaattagatacaaaaaacacgatagttgcatcct
-taatttattgtgtcaaacctggaaccttttaattacccgcaaatcactttatgtcgagac
-tacctctgaaatttattatctacctaccgcatgaggacttgaaccatcttgtaggagtta
-tgtttattagctaagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaa
-gcactcagaattgtttttagttgagtcaagactgatatataaataagtttccctagtttt
-ttcgtggtgggacgatattgaattgaatcttaaccgaagagtttcccactctgtcgcaca
-ataatacacgccaatatttccagccctgcttatgccttaatcggttactcaatctcccat
-tgaagttcattttgatctgcatagaagtttcgggcccagccttttttctgccaccttcct
-ccaagctctgtagacgcactctaagattgatgctcacatgtattaattctacattaacat
-aaatatataagtcatgcatcttcgagtaaaatatctggttctccaacatgtcctggcacg
-tatcgttataatgcccatacatgtagtattaaaatgattgggttaactggatattaagat
-catcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctc
-ggaagggctattacgcttacttccgttttggtatcttaatatgactttcaaaaattaagt
-tgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaac
-tacttgctttacaataccggtcgtatatatcgccgtgaatccagaagattgtcttctttg
-gattatcaaccgagatcctgtggaccgatgttttgggaccttcacagaggactccaggta
-gagctcgcttttgcattaatctaagaattgtacctctctaaaagatctaaaacagtgaat
-gtgtatttcatggaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgag
-ttattatacatatacgagatggtggtatacatcgaattcggggcatacactatagttgca
-ttgtatttagctgctttaaataatatgatattaccttccttacataagacattaccggca
-taccctggttttcaacttgtggggctttttgacgatcgcactctcatttgatccgagtag
-ggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaatagattactttt
-cgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacga
-gaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaagga
-tgcgcggaatagaaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgc
-cgacataggatgaaatcagattccaatgcaatacacagtaacccccacccttgattgtaa
-tgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtg
-cgatcaactatgaatctcggcgagttagatggtcgtacaatctcacacatagaggtcact
-tgcctgtaatgacgaattttcggctaggtactcgaactttattagaagtaaaaatgtggg
-caaaagaaggattccattttacaagacgattacaatgagttacatgtctctcaacgtagt
-ctttccctagtagtctttgaactatttaggtactccagaaaattttagcaaagggtttct
-gtgtgaatccgccattcatgtttatgatggaacaataagaataacgccctcgtatgttat
-cgacagtgaagtcagcagttcggccaaaaacatattcaatttagtacagatccccagaag
-ttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtctaattactatact
-aacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagtgtcgttttgcta
-tatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttaggacttcggattc
-tcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcc
-tgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaacta
-ttgatagtcgggagcataaccaggtgaacgtactttgttcacgacatttattgacatgtt
-ctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggttt
-aagggccgtaatgccggtagtgtcaaacttcatgagaactttagctggcttttggccagt
-atttagggaccaagagcactagccttaagctgaatattttgccatttatctactgttata
-actttaaaacttggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaa
-ggtttactaagaacaagcgtaggaattgagtttatattatatttaaactaaaagatgata
-ttagcttctgagggcgatagggctccaaatcataaagaggaatatattattacacgatta
-gaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttggcagtactccaca
-tctcagtaatacagttgggagagtctcaaatgttgttttattactcaatgaaccaccctc
-ataatttcactgctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaa
-atcgacaaaattacagataagtagatgcataataaaaaaaactgctcgctataacacgat
-catcgtgcattcttacttaggagcatcacccgcacaataacgtaccttaaactacaacac
-tattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctct
-ctcgtaaaatgtgataatagtttgcggagaggattcaattattttccattgcacctactc
-cactagattcgataaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcgga
-accataagcaaagcatgtaagtgaaccgtcatccttccctaagaaacataaaggttttta
-ataatgtcgactgtgaactataactgcatcctttcctgacctactccggttccttgttgt
-tatttctgaacgagaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcat
-gtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaa
-attaattttgccttttattttttttcaggctcgaaattaatgatttgttttttttgacct
-tctagttacgctaatatgcggtcgcctgtggtttctattgagtcctataacgggatggga
-tctaatacgtttggttactagtaaacaaggtataaatttgataccggagtatcaactgta
-taacatcaagctttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcg
-agtacagagccactaaggggtgtattacgatagtgacaccaccgagcgcactcactcccc
-aagtagatttatgatcctacgctaagtattagatatataaccaaagaggttctagtcagt
-gcaactcttagaataataattagccggttttgcctttttaggcctaatgcaatattcagc
-tagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaa
-atataatctatgaatgttatgccagtacttgaataaatcaggttttttataagtccttgc
-atactctcgttatatactgttagagtcttaccccatagaaattctttcatctgcaaactt
-agaagaattctcagctacggggagcataaagtccccaggatgttgacaaatacaacaaat
-gtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagttttagccgaacct
-tgtacggataaatccctccattttccaatagcagatacctatcctactacctcgtggtat
-taaattaaagcttgaaatatagagctgcatagcttatccaattcccaagcacgagtctac
-cgtcgtaaccacgatttgatttacagacgctagagcaaacccatctttaaacatataagt
-aaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgt
-ttataagccataattaaaaacatatgttcaacaggttcattgatatttgtaattgcacag
-gtttttaataaggatctacgtaagtataatgaacaaactttttaccagagttatattctg
-tactttgaaaatgctcctctaccgccttagagactttcaattagattttttgcagttaat
-ctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgt
-ctgtctcataactgtaggtctaatataattttcagttttcgaacacataaccctttgaaa
-atctgctatttaatgtctcacctgcatgcactatcttctatactgctcagaacggctata
-cgtcactatgctccaagtgacgatttaaacgaagcaaggaataataggtttattttagtg
-caaaacaattaagtgcggactacgtgctctttacaataagccttgtgattgggctatagg
-ttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctttgcattacccgg
-ttactagtcgaattacagatagctgttagatactcactctaattttggacaacaatccca
-atcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaaacgattacatat
-tatagacttgttcggggtagagatatcacagttgtgcaaacattgtaaatcgatactagt
-ttatgttggtagtctagttgcttttaccattccccgaaaaacttgatctactatttcgac
-aacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgt
-ccactatatgtaagtgtagctttacataatccactatgactgagatcattacggcctagg
-aaagcagcgtagaaaaaaagggcccggatattacgactgtaactataaaactagttactg
-gtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaacgaatttcagccg
-cgaaaattgatccgttaaccagtccatctcgacttctataaaacgataaagtaaagttga
-tgttcagcctccttcttatggttgcatcgagagtacactactcagtgggaaatagatcgg
-ggttcctacttcagattgtattatctaggcaattgccgattgtgccatacctggataaaa
-taagctacctacatgtgatgcttatctattatcgtcatactaccttagggtgtcctgttg
-aacgctacattaatctttagccgtttgagatgttccaatggataggagtctaacgcatga
-tgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagac
-gttataaatagaaaaaaggtccttctggttctattctgctgaactattgaatggaaagat
-tggttgacctacgtactatttgcttgaagtcatcaatttgacggggtgagagacatatgg
-tgcatactttacggactctatattttagatcagaagcttagcagtcttctctacaccccc
-tcacgacataattgcttttaagaatctatgtttgattcctctacgggaattcggatccgt
-tcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagcatacgaacactt
-tgctaactagacgtatgtatagtagctataaatcccgacgatatttacaaaaagaaatga
-gactcaaatatatacatagcgaccctacacttattcgcaccctgatctaggcgatcctag
-cacccacacccgaaagtgagcactagtgtcttccgtattaaatttactgcagttgagatt
-ttagttgtctactaaggattactctaacccgtaataaggatcaagactcggtactagctt
-tactatcattccctatgtgttttcctaactcacaagggtacgtaccagcctatgtaatta
-caataatgataaagacacaaaggaagtaactttacaaatgagtctccagttacactagct
-tagtccctcccatcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaa
-gaacactcataacgttggagtccaagaattagactcatagggcccccaacatttaatatg
-tactgtgagtttgaaggtgttctattgttaattcctgctcttgatacatgacacgtactc
-cgtgtttaaggcttcggactgactttctttcataagttgagcaacgaaaatttcagaatc
-gataagttggattcactaactaatacggctgattgaaaactccactccggacctatatgg
-tcgacctttatacgtaaccgatataaaacttataggctggtatatcgagccttcctagcg
-caatttcggatggggtttcttctactactcaacaacggaatagtctttgtttagtaaacc
-agagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtcattatggactgg
-agcactcttaaatcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaat
-tttcttgatacgtcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaa
-atacggctgtcgtgctcagatatactattagcgactcatctcgcctaacacgcacacgta
-taaactcggaatgactgccgctcttacatattagaaatacagactacaccacggaagcat
-tgggtcattctcaaccgctgtataaaagatgattagtcttataataagattaccaaagag
-gcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtg
-aggacgagatggtactcaggacaaatattaaccggacgaagtggtttacgtcgtactttc
-actattagtagtaaatacaaggtaacaccggggaatagtactaaatataatgatatctat
-cttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgact
-tatagcatgatacaaccgattgttacttttgtctattcaaaagattgaatagttttttat
-acaaaagccgcatacttatgacggctagtatacagtttcatcccctagcatcaatgctat
-ggacagtattgaacttataggaaattcttctaatagggcaaatccgtcgtgatgcctatt
-ttttttcagtcacatcctcaaatggcactagtattgtcgggatcccattaacaggctcaa
-ccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaact
-cccatggataaccaattataaggcccgtaatcctctagacatcgtttaccaataaatccg
-ctttctccgtaatcatgttgaataccccagagtagtccagatgataaccgatgaaacaca
-agtctttctcaatgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgc
-gacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaa
-cgccttgtaattttactttaagacgcctggtgatgtagattcttagataatcagtttgtt
-atcggctgtactttaccataatttcacaggtttcaggtcaagaagattatagctgtatat
-acagttccatgctcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtc
-tttaggcgtatccaatacatgccccgataccgcagtgtatttcgacatgtaggtataccg
-tcgcatttgagctcgagtcaggacgtcagctagattagattccttaatagaatataccga
-cctctagtccgaactaaactatagataacgccaacttcaggttaattgtctagtcgtctg
-tttgcagatgggattcttagatgagtgagtatcggccatattggttcgagcactttagtt
-tttgatgcataggatatgcaatgtatagctgaaagtactttatctgtttcaaactcacat
-tgattaaaccggtaaacctttaaagactacaagaaaatattcagtgagggcaattttgtc
-aatcacaatcttccagctagagatacttcacaatttgtcttgaggctacgcaacattaga
-cggattttcgcgttttattgaaataatcgaggggcccaagagtatccatagttcattttg
-taagatttctttacaggcttattacagcttcttcagactcctacatgcttacgagttata
-tgctagcatgtgaacaatagattaatatacaggaaaacgtacattgagagagatgaccct
-acacagcgcaaccgttgagtactttcattaaagggtaacgctctcgagacagcatcctta
-agatggccttattgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaag
-aatccctacaaacacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcg
-gagtatcaatttcgccaatcttggtgagaaagcataccctttcttcagagaaagaagatc
-aatcataacactatctttaacgaggtacgcacgcgcatcattacctgcctccatggatct
-ttaggatagcggaaagtattggcagcgtattgtgatttcgttcctactttatcaatttca
-cattcatatacatgtcttttatcaaaatcgccaataagataggatgagctatattagatg
-ctagtagagttcgcgccaacatcatcgataggaatactcaggacagcgtgataggacttt
-tcaatccctaatactctctataattataactctctcttaagtttggaggcagtaacgcgc
-tctatataatcagtttgctgcaccattcttcagcctctgatacatacaaataaattccac
-agcagtaagagggtttaattgagacatcttgggaacttaggattttactctaacatcacc
-gaaacgattattggataccgtacctaaacgaactttctcaaggcagtaatataggacatc
-cgcaataacacaaatgctgcctccccaggagttatgtcttcctggaggctatatcttaca
-cccactcactataggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataa
-gagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaa
-gttctgtcctgttcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatc
-tcagcaagttataaacatgttggaagtttctagtcggaattcccaaagaacggatctatc
-taatgcattcctacatttttcctgtctgccgatggtgccatcctattcaaagaatttctt
-aaaagtagattaaatgggacttttaacaatgagtaaccttacgcctctaagggttcctcg
-agtgccatacaccagtcaggtccgagccacatacacggagaacattctaacatagcattc
-tcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaaatcatacttgca
-atcccatagcacggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttg
-gtatgggaacatcattgcagctatggtctaacgcattaatgtttgggtacatcttccatc
-atataaacaggaagagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaa
-tcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaata
-gaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatatatgatctgcttt
-aataaaactttatccataggatacgtttccaaatcaattcaataattattagtcaaaata
-gataaggatgaacaacctgaaggccgatcggacgtagaaagtggtcccatcactttgagt
-tgatattgttgaaccacacgttattatggttttcaaacagtctcaggatattgtatatac
-agataatccgataccagttgtctgacgcccctcttacgtaccccaccctttgtgacgttt
-aaagcagttgttcagtattttaaactaggcggcaactaatttggaaagaagcacagtgga
-tatgtctaaattcttgttattcaggcctgaatttaatacaccgcatagttaacttcgcgg
-tagagttgttcatcatgcctcctctaagctaccacttctatgatacaccaatagttgttc
-tacggaatctgataattggccaagtcataaacttccgctgcgttcaacccccttgctcga
-atatccaactcgaaaagacagccttttggtgtccggaacaaatcagttacttcttttctg
-atgttaattctctgtggtcagatacagaccaaaaactccgcggatttaccatcctccaag
-aacaaatttgcatcaacatagcattttggctacatattctaagtctcaatagtttaggtt
-ttcaactacattatcccaacattaggattggaggaataatagctgggtaagtccccttgc
-gtctacaatcgactattttttatgaatatgcttctgccgcacctatggttattaaaaaag
-tcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaag
-agcatataattagcaacactctaagaacattatagatatgatgatagcgatcgtcatgat
-gttatccggtcacaatagtagcttcatcagctaattcgttttgccagtggtgacttgcgc
-tggaagaatcgttatacggtcccttccctcttgatacggtgggggcttattcaaccgcgt
-ggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagtcaactatactaa
-atcacaaaatagtgatcaatacatacccgcttcatggttttaaccatttaattgattaaa
-gatattccgctaagaaccattatctacctaaactgatcgccgtatcctagtagtttgaaa
-tttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgtagaataataggtc
-ttggagctaaatgatgtgattggtagtgaagacttacccttacaactttaccggtttctc
-ggaagaatatactagagaatcaatgcatgggctacataagcactttagtctaatgagata
-aaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaacctggtaattta
-aaccatatatctttatgtcgtcaataactctcatatgttttatataacttcccaatcacg
-acttgtaactgcttgttcgactgagctgtttgagctatgaggccgggatccggttgagct
-acatctatttgctacaagaaaaatgaaagcacatttgttgggagttctggctacactcat
-agagaaataagtggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaacc
-aagtggttccaacgctcgcgctaaagaattaaagcctttatttcctccacggagtagccc
-gtaatccggttcgaaagagaccattgaagttaattttcatatccagtgaagtttaggcac
-aagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaa
-cttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcgagttaattttcg
-ccttctccaacatggcatccctacgttcgttataaggaccatacatgtaggttttaaagg
-tttgcggttaatcgatatttacatcatagaaattctatagtcaaatttacaagactctag
-atactcactcgttgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcg
-taatatgaatttcatatagtaagttcaaggcactcatacctccgtgaagagggtagatag
-actattaaagttgtttaatagtacgtattgatggaaatgacccgtaggagatttaccact
-caatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgg
-gtccttcaaacacgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccga
-gataaatgagctataacactgtatgtcttttgattgctataaaacacagaaacggatatt
-aatttaggccgtaaccaacatctgttatttgacatagaacagatggtcctttacagcgta
-ttccggccttaatattgaggtccagtgtattgtcctcctttaaagaagttgattgtaact
-gacttaaataagacatgtcacccattcactgggttgcaactgctggccctttttgtccat
-cgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcg
-ctatgaaggttattcattaattttagctgttttcttagaaaaggtaaatttaaaattgaa
-aaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgaga
-ttgtaagaaataaagccataaccagccccggaatagaaaatgttaaggaaaggcgatctt
-ctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaa
-tctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcag
-aggataacggaatgtggttccgtcccataaacgatcattctcgcccacttagtggcgcgg
-taaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggctaccttctccaa
-ctttagtacaacgaataatgtccgattaacaaggagtcaatttgtcatgaccagttcatt
-caggtacttgtatctatacggacgcgttccagagtagtatttgaaattttgaggttctac
-tgataagtttagctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaat
-aacaattaacaactcctaggtgatacactgtgaagtctgctgttccccaaattacatatg
-ctattttgttcacataccatgaagttaagctaagtgctctataatggcataaacggttat
-caaactagctcgaatttcttttattacgccggaagcggattaactgctgtagatcaaaca
-cgttaggatagtgtcgttttcatatatatctaaattcggtctaacatgcattacccatgc
-ttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaa
-agtttatctatcaccagtgatgcctcatcgtgactacccggatctttagcctttagggtc
-taaacagaactaatattactacgtgtcatactccggagcttaaccaggtgaaacttattt
-gttaaccaaatttagtgacagggtagaaatacgtatcaaattaacccagcaatacaataa
-gcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgac
-atagtgtgatgcattttgcactggattgagccacaaactcaactagcattatgctcaata
-tttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttaca
-aacgcataaatctcgaacgtaataggtttaattagaacatccgtaggatttctgtttata
-gtagatttatactaaatgttctgattagattctgacggccttacccatacaattaataaa
-gacgaatatattagttatagtttactatccaaataaattaagcgaatcgaaataaactgt
-cacgatactgggcagttatcaacttatcacttatacagttcggacactctatattggtct
-gtgagtactctatcaaactaactcataagttaactgcgcttccattaaatttcaatacgt
-tcttgtgctgtgtacaaacctataatcgaataaatgacacatatggagatgcataataaa
-aaaaacggctccatatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaa
-ataacgttcctgataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaag
-ctagcatggtatagttcttgatagcgcgtaaattctgataatactgggcggacagctgga
-aattagttgccagtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaa
-atacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgt
-ccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataactccatccttgaa
-gcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaa
-caactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtgcacggaataaca
-taacaaggaatattatttattcaaattttttgtgactgttatttgttttctgcctagaat
-gtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgag
-agtgtgtcctataacggcaggggagcgaagtagtgtcctttagactattcaaggtagaat
-tttgataacgctctataaaaggtagaaaatcatgattgagcaataagaccccaacttatc
-aaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtca
-caacaccctcccatcgcactcaaaatgtagatttatgatcagacgctaacttgttcttag
-agaaaaatacacgggatactctgtgcaacgatttcattaataaggtgcagcttgggactt
-ttttggccgtaggctttattaacattcacagtaggtagcgagacttcctatgaaccaatc
-atgccacgcgttttaacgtttcaaatataagctaggaagcgtttgccaggacttctataa
-tgcaccgttttttttagtacttccttactagccttagtttatgttagagtctttccaatt
-acaaaggattgaatagccaaaatttctacaattctcagcgaacgccagcttaatctaaac
-acgagcttcaaatattctacatatcggcaggagtcaatatataaatatgaaaatcgtacc
-atcctcgtacttttagaccaaacgtcttcggataattaaatcctttttcaattaccacag
-tacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgta
-tccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagc
-ttaccattcgttaaacagataactaaaatttaatggctgagtgacttagtgttttcgaca
-aacgtcgcggatgtagactattgtttataagcaatttttaaaaacatatgttcaaaacgg
-tatgggatatgtcgaattccacaggggtttatgtaccatagaagtatgtataaggtacta
-aaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctg
-taaattagattgggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattct
-accgactccggataacactttacgatcgcgcataactctagctcttagataagtttaact
-tgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatccatcctctatct
-tctataatcatctgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaa
-agctataattggtttattttagtccatttaaattaagtccggtataagtgctctgtacaa
-tatgcagtctcatgggcatatacgttaactaccttttgatacttcgaattggtaaaatat
-cgactatcgatttgcagtaaaaggtgtagagtccaattactctttcctgttacatacgat
-ctcttagtttggacaactagcccatgatggcgctcctctagcgcatgaacctactttata
-attacatctttatcgatgaatttttttagactgcggaggccttgagttttaacagggctg
-ctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccg
-aaaatattgatctactattgcgtcaactctattctgctaatagcgatggcaaatcacaga
-agccctcttagtgacaatagttgtcaactatatctaagtcgacctttactgtatcaacga
-tcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcga
-cggtaaatataatacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggt
-gcttcccggaacgattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgc
-gttaattcgtgttagtaaacttgatcttcagactccttcttttcgttgcagcgagactta
-aattatatctgcgaaatagtgccccgtgcatacttcagatggtaggagataccatttggc
-ccattgtgactttacgcgattaattaaccgacatacatctgttcctgagctatgatcgtc
-tgaataaattacggtctcctcttgatacctaatggtttctggagacgtttctcatgttca
-aatggatagcaggagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatg
-ggaaagtcgatttccaaaccagaagggataaagagaaataacggacttctccgtagatta
-gcctgatattttgatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatatt
-ttggacggcgggagacacatatcggccattcgttaaggtctctatattggacatcacaag
-cttagcagtatgagctactaacactcaagacattattgattttttcaagatatgtttcat
-tcctctaccgctattcccatacgttcgattcgccgggtgagcgaaaccacgggactgagg
-ttaagctaatcaataacaactcgttgcgatagagacctatgtatactagagagaattccc
-caacatttttacaaaaacaaagcagactaaaatagatacagtccctccatacaattagga
-ccaacatgttattgccgatcctagcacacacaccacaaactcagaacttctgtcttacct
-atgaaagggtctgcacttctgattgtacgtgtctaattagcattaatattaaaactaatt
-aggataaactataggtacgagctttactataagtcactaggtgttttccgatcgaaaaac
-gggaccttcaagccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgact
-aatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgc
-aagcgctctcgttatactgctcaacaaaactcataaagttggactccatcatttagaatc
-atagggaccaaaacatttatttgctactgtcactttgtaggtgttctattctgaattcct
-catattgatacatgaatcggaatacctgtggatcccttaggacgcacgtgctttctttac
-gtcagaatacatattgtcagaatcgagaagttccatgcaattaagaattcgcctctttga
-aaactcatatccccacatatagggtccaccgttattcggaaacgatataataattattcc
-agcgttgagcgtcccttaagagcgcattttcgcttggcctttcttctacgactctacaac
-gcaagtggctgtgtggagtttaccacagcgcagcaccccatagaactacctctgagagcg
-cgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagt
-catattaaaatggactgtcttaattgtcggcattaggagcaatattaactgatgagggta
-tcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagatacgattacagact
-cagatcccctaacaagcaaaacgattaaatcggaatcactccccctatgacatatttgaa
-atacacaagaaaccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgag
-tctgagaattagatgacctaactgcaagaatcatggcgagtttatctagtaggcaagtct
-gtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataacca
-agaactggtttaccgagtactttcactattaggagtaattacatgcgttcaccgcggaat
-acgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagt
-cgctaccagtaattgctgatcaattatagattcattatacagatgcttacttttctctat
-tcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgcctagtataatct
-tgcttccacttgaatcaatgcgatggacagtattctactgattgcaaagtagtctatttc
-ggcttagcagtacgcatgcctatttttttgcaggcacagaataatatgcaactaggattc
-tcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatg
-tttactacagaaagcgaatgatatcacttggagaacattttagatgcccccttttaatct
-agactgagtgtaccaatatatcaccggtctaccgaatcagcttgaataaaccactctagt
-actcatgataaccgagcatacacatgtatttctcaatgcactgaaggtgaactgtttaca
-ccataccttgcgaatcaacgtggcgacttatacttctgtctttgagtacagcacacccta
-atgaatctaagttagttgttgatacgaattgtaatttgactggatctcgcctcctcatct
-agattcttagagaagatgtttcttatagccggtactgtaactttattgatctggtttatg
-gtaatcaacattttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggt
-ttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcacagagtaagctct
-ctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgt
-tgattcagtaatacaagattacctacgcttctacgaaatatactatagatttagcctacg
-tcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggc
-aattttgctgcgagctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacg
-tctttatctctggataactcacattgagtataccggtaaaaatttattctattcatctaa
-atagtcagtgagggctagggtcgcaatcacattaggccacatacacatacttaacatgtt
-ctattgacccgacccaactttagtagcattgtagccgtttatgcaaatatgccaggcgcc
-aaacactagccagagggcattttgttacatttatttaatcgattattacacagtcggaac
-acgcctacatgcgttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaa
-acctaaagtcagagacatgacactaaaatcacattaaggtcagttagtgaaggaatggct
-aaccagctagagaatgcatcattaacaggcacttattgtcaaatattttccagatctaag
-caacatcacgttaaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattaga
-aagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcgggacttagcaga
-cactggatgcagtcatagaagatcttgcataacacgttagggttagagctacgaacgccc
-atcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgat
-ttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaatta
-acatacgttgacctatttttgttcagagttcagttagagcctaatgattcgagagcaata
-atcaggacagcctcataggaagtgtcaatcacttagaagctatattattataaatcgctc
-tttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaat
-atgatacataaaaatattttcatcaccactaagacggtggaattcagacttattggcaac
-ttaggatgggactattaaataacccataagatgttgggataaagttacgaaacgaaaggg
-atatagcctgttagataggaaatccccaataaaacatagccggcctccacagcagtgatc
-tattccgccacgcgatatctttataccacgcaatataccaataataaaggttaaatgtgg
-ttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgt
-aacctagaattatagcgtctgcaagttctctaagcttcctctgcaagatacaatatgact
-ttttagcttttttactaccaaatctcagaatcttagaaacaggttggtacgtgctactcg
-gaattcccaaagtaccctgctatatatgccattccttcattggtccgggctcaccatggg
-gccatcatagtaatagaaggtagtaaaactagttgatttccgacttttaacaatcactat
-cctgacccagatatgggttccgactggcccttactccagtaagggcagacacacagacaa
-cgagaacttgataactttgaattctcaaatcgatcattgcaacgtgacttatttactagc
-ctactcctataattcatacgtcaaatacatttcaacggaggaagataataagtaaatatt
-cactaaataatggtcgaaggagtcctttgccaacataagtccacatatgcgctatagatt
-ttttcttggggttcatattcaataagataaacagcaagagtatcacgtcagcgagtcatt
-gagatcttggctagcattgtgatagcatattctacctaaatggtagtctagcacagagtg
-gataagatatcagttagatatagacaagtactataacagatctcgcttcgttggattgta
-tggctagctttgatgatatgattttataaaaattgatccagacctgacctggccaattat
-attcattttttatgagtaaaaatagataaccatgaaaatactcaagccccttaggacgta
-caaagtggtaacataaatttcaggtgttattctgcaaccacacctgttttgggttttcaa
-aaaggctaagcagattggttttacagataatccctgaacactggtatctcccaacgatgt
-cgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaa
-tatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaacgcctctttggat
-tacacagaatagtgtactgacacgtacactgctgcagcagccatacgctaacattaaaat
-tcgttgagtctacatttgttgttattcggattatgttattgggaatagtatttttattcc
-cctgcgtgaaaccacatggatagattagcctactcctaaagactcccttttggtctacgg
-ttcaattctcttactgagtttatgttcgtaattatatcggcgcagtgaatctcctaatta
-tcaccggagttaccagacgccatgaacttatggccagaaacattgcatgtggcctacata
-ggattagtatcaagagtttacgtttgcaacgacatttgaccaacttgaccattcctgctt
-gtagaccgcgggaactcccctgcacgcgactatagaagttggtggtggatgtggcttatg
-ccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtat
-aagggctattgccagatgaaaaactgcatataaggtcaaacaatataagaacattataca
-taggatcttagcgttcctcaggatggtatacgctataaagtctagcttcagcagctaagg
-agttttgccagtgcggacttccgctggaagattaggtttaaccgccctgacatcttcata
-aggtcgggcctgattcaaacccctggagtgccgtctcatacttgaattaatcgatggaaa
-acttcttctagtctaatattattattaacaaatgacggttcaataaataacaccgtaagg
-gtgggaaactgttaagtgatgaatcattttaacctatcatccattagctacagataatga
-taccccgatccgactagggggtaagtggttgttccgttaggataaaccatgtaaaacgtt
-agagggtttgtagattaattggtattccagataaatgaggtcagggcgagtgatcaatta
-cactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaatgaaggggattca
-gaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtc
-gattaaagcctaaatggtaatttaaaccattgatatttatcgagtctataaatatctttg
-gttgtatattacttcacaatcaccaattctaaatgattcttccactgtgcgggtggagat
-atcaggacgggttaaggttgacctacatcgttttgatacaacaaaaatcaaagcacatgg
-ctggggacttctcgatactatctttgagatagtacgggcaagagtgggtgacgcctccct
-acattttcaagtctatcggataacttctcggtaaaacgctcgcgatatagttttaaagca
-ttgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtg
-tcatatccagtcatggttagccaaaagcatgggttatccaaaaggaataaaacagctctt
-caacaaagagatgaggcttcataacttcgatgaatgcgtatggttctgatatatagatcg
-atgcatgaggacactttattttagccggcgaattaatggaatccatacgttacttatttg
-gacatgacttctaggtgtttttgctgtcccgtttagcgatatttacagattagtatttcg
-tttctcatagttaattgtatctagatactaactcgttgaagacgcataccttgccatttg
-tacaggacttaactgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaa
-tacctcactcatgaccgttcatactctagttaaggtcgggaatactacgtatgcagggaa
-ttgtaacctaggagatttacaactctttaaacaagagtcgctgaggtccaggatcaaaac
-actgaatctcctaacttcgggtgcctccgtaaatcacctagaaacctactcatacatttg
-caattttgagatgtaggcgaaagagagaaatctgctttttaacggtatctcttgggattc
-cttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgt
-gtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcat
-caggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtg
-aaaatgctccccagggttctacagacatagagatggtcagaacacgacccccctctcaac
-gcagtgtatttgaaatatatggacatatctaccttattctgtaattttagatgtgttctg
-tgtataccgatattgataagtcaataggcttgattacgtatcttaagacaaatctgtttc
-gcaagtaggaccgcatctttcagattgtttctttttatgccataacctgcccaggaattc
-aaaaggttatcgatacccgatatgctgtgaattattattctaatggccactcattcctgc
-ttatatctggaattggcatgaatatcttacaacctaaagtctggcgttgcgccagttcta
-cttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttc
-attagaccacactttgtgccgacgtatatagatatattacacgtatagggaatgttttct
-cctaggtgacccgaccttctactaaggttgtacatcgtataatggcccattaactacgag
-gaaagtggtattgacctggtaatgcacgttcttcgatatataccgacgaggtaaagtcta
-ctattgcaaagtttgacgttatactgataagtttagatttccctggatcgcgcatgaaca
-atgtatgcgttatctgccatatataacatgttacaaatccttggggatactatcgctact
-atcatcggaccaaaattaaataggctagtgtcttatcagaacatcatgtttaccgaactg
-atctattttccaatttaagctgatattacgtccgcgtatttattttagttccccggatga
-cgattatctgagctacatcatacaagttagcatactcgccggtgcattgatttcttattt
-cgctatatcttcaagttcacaggcttcatatagttccaattagcagtataattaggtttt
-gtaactttaaccatactttataaaaggttatattgcacaactgatcaagcatccgctata
-acccgagctttaccagttagcggctaataacaaataagatgacttcgtgtcatacgaccg
-tcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtat
-aaaatgataccacatatactataacaatgaaattatttgtaatccggtttgccaacgtat
-cccccttcgcgataaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaa
-tctcaaattcaattatcatcaatattggccaagtgttataagcgttgaaagtgatatagg
-ccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttattgctggtagtaca
-acatcacgagcatttctcttttgagttgatttatactatatctgctgatgtgattatgtc
-ccacttacccagaatattaagaaagtcctagattgtaggtatacttgactataaatataa
-tttaagactatacaaataatctggctacattatgccatcgtagaaactgataacgtagta
-acgtcggacactagattttggtcggggagtaatctagcatactaacgaatttgttaaatc
-cgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgtttagactattaagg
-actcatttcgagatccagtattaattatacgcatccatatttatactgaagacggattga
-gttaggacgacaagctaaacaaatattaagttaaggattagtattatattgtagaaactc
-gtcgggttggaacgattcatcatcatagaatgcgttacttattcagagagacttaattcg
-gttatgactggcagctcacctggaaagtaggtgaaaggcaacagaagaatattgttgact
-gaattctacgggctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaata
-caatggatctctacagtattacgtaaataacatacataaacctggtgttgattcgactag
-ctcatagattaatcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaac
-agtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaac
-gtgggggtagtcaaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaa
-tgtgatgtgttttatccagacattggatgcatggctgtgggggcacaggatacttaccat
-tagttcacctacaagcggcgtgagagggtctcagttttagccagcgcagagaagtacggg
-cctttagacgattaatgctagaattgtcataaacctcgtgaaaagctagttaataatcat
-ggtgctagaagaacacaacttttctataaaccagttctcgactgacagtcgtaactcact
-atatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtg
-catcagtagagatcgtgttctgagagataaatacaccggatacgatctgcatcgagttca
-tgtattaggtcaagcttgggactgttgtgccagtagcattttttaacagtcaaagtaggg
-tgagacacgtcatatcataatatatgccatcgaggtttaaagtttatatgataagctagc
-atgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcctttatagactga
-gtgtatcgtacactcggtacaattacaaaggatggaagagcaaataggtcttcaattata
-acagtaccccaccttaatctaaaaaccagcttcaattagtattaatttcgccaggagtat
-atatataaatatctaaagactaaaagactcgtacttttacaacttacgtcgtagcataat
-taaatcatgggtaaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacag
-tgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgattaaggcctataaaa
-ctgttgttggtatctacagagtgattaaaattagtgaatcagattacgaaaatgttttcc
-cgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattt
-tggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttc
-catagaactatgtagttggttataaaggttgtaatctcggagattaggttagggcttaat
-cagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaact
-cttaatgccatgcctggacaggataaacaatacgcatataacttgacgatcgagcttata
-tcgacctatttgagaagtttaacgggtcgatataatatacaggtcttaatagccgatttt
-ttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtgaacgatatatcag
-caaactgaacattgtatacaacattcctttttgtccgggtggggactccatttaaagtat
-ctcacctagaactcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgt
-tgatacttagaattgctaaattttagtctagacatttccaggtaaaccggtagacgacaa
-tttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctac
-tatagacaatcatcagactttttaattaaatagttttccatgaatgtgttgtcaaggcgg
-accccttcacttttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttc
-gagtcttcaggggaaatggaaaagaaattaggcttctaagatggactataatcgattagg
-ctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcga
-acgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacctatcatcacgac
-ttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaag
-ggatactgggcggggaaacctgctccttcacggtaacatggtaacaacagaatttggtta
-aggttaaaacgaaatatactcggagtgaattactgttaggtttcgtcatcggatcaataa
-gtagtttccgtgaagacactcttatattagatctccgaaattctgacccgtgcattaggc
-acttggtaggagattccatttggaacttgctcaatgtaagccagtaatgttccgaaataa
-ttcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggt
-tgagggtcaccgttctctgcgtcaattccagagctggagatacattcatcaacgttacct
-acgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaacggatttagaca
-aattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcatggcggctcagta
-cgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaa
-gctatatattgtggtcagaacttgaggacaactatgagctactaaaaataaacaattttg
-tcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagc
-gtgagcgaataaacccgaatgagcgtaacattatcaataacatatagttcagatagagaa
-cgaggtattcgacagagaattacccaacattggttattaatctatgcagaataatttaga
-taatgtcactacataatattaggaccaaaaggtgattccccagaagacaaaacaataaac
-aatctcacatattcgctagtacctatgtatgggtatgatcttctgattggacggggataa
-tttccaggtatattaaaacttattaccataatctagacctaagagaggttatataagtaa
-agagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagtaaattttgcttta
-acaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcaggtgtaactacat
-gagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaactaatatcataa
-actgccactacatcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtg
-cttcctctgctatgctgatttaatcagattcataaaggaatacgaataactctggatcca
-ttaccacgcaagggatttatttacggctgattactttttggctgttgacagaactgccat
-gaaagtaagatgtcgcatcttgcataaataatagcacctaatatagccgacaaagtgatt
-ccgataacagattttaagttgtccagccttgagactccatgaagaccgcttgggagcttc
-cccgtgattagaagaatctaaatcccaagtggatggggggagtttaaatctcagcaccaa
-caaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggttt
-gaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtac
-gacaaattttaactgatgtcggtatacggagaagaaggaagcacgcattgaagcagctac
-gcagaactgagaagatgacactctaagatacaattaatacaaaaacgttttaagcccaat
-ctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtata
-ataacagctttatttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcg
-cgtctttatagtgttggctactctgtaaccgacgcgtccatccctctctcctagtgatcc
-gtatatccaattagaggataaccaacatctgcgttaccgacgaatttaaatttttcgact
-atttaattccgttcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatc
-gtgtacgagttgcagtgcatatgtagataccactaattgctgatctaggatacatgcttt
-ataaacatgcttacttggctattttatttactgtcatgtgggggtttttattttcaacaa
-gtatgtgctaccattggataatctggcttcaaattgaagatatgcgttccaaacttgtct
-actgtttgctaagtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaa
-aagaataattggcaaatacgaggctagccttcaaatttaatgcagattactcctcagaaa
-cacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgata
-atttttgttccaacctttgaatctagactgagtggaaaaagatttcaccgggataccgtt
-tatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaa
-tcatctgtacgtcaactgttttaacaataacgtcagaataaaccggcacaatgagacggc
-ggtctttcactacaccacacccttaggattataagtgacgtgtggattcgaattctaagg
-tgacgggatctacaagcctcagctacattaggtctgaagatctttcgtatagccgcgtat
-gttactgtttggatatgggttatgctaatcaacagttgacagcgagtgaaacggccttgc
-gacctgaaatctttacggttaccttttgattcaagacaggatcgacgatggaccacgtga
-aatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcaca
-tcctctatgcaactatcattgtggtcattaaggtattcaagattaactaagagtcgacca
-tatattctagagttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgc
-aggaggtgtggactgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtc
-cttagcaatgcgatacctcaatcgtagttttatcgggataaataacatggtgtttaaccc
-tattaatggtttctattaatctaaattgtaaggcagcccttgggtcgaaagcacattagg
-ccacatacacagtatgaaattgttcgagtgtccagaccataattgactaccatggtacac
-ggtgttgctattatgactcccgcaaaactcttgacagagggaattttggtacattgatgt
-aatcgatgatttaacagtaggaactagacgtcatccgttagactgagttccgacatgctc
-aaattgtcaggatttttatccaataactaatggctctcacatgtaaataaaatcacatta
-acgtcacttagtgatggattcgctaaacagatagactatcattcatgaactggcactgtt
-tcgattatatttgcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaa
-aaattcagtacacctctaatgagtatcccgctttggaggaaagagtagcactttaaatgg
-acaatttaggccggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcg
-ttagggttagtccttacatccaccatatgttaatgaataaagcctgagggaccttagagc
-taacttgtccaacacgttgctcatttacttaataaggttgaaatgtatcagtaagtgaca
-gcgagtgtagattttgaccatttaactgaccttcacagttttgtcttcagacgtcactta
-caccataatgatgacagagcttgtagatgcacacactcattcctagtgtaaatcaagtag
-tagctagattattataaagagatattttctggcgtcgaacgtaacacagagagagtataa
-ggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcg
-gtggaatgcacacttatggccaactgaccttgggacgagttaagataccataagaggttg
-cctgtaagttaagataacaaagggatattccatctttgtgtgctaagaacctatttatat
-ttgcagccataaaaacctctgtgctatgcagccaccagagttatttatacaaagaaagag
-accatttagatacgttaattctgcttgcgatttattaaacagacatttcacgtccaacca
-ctacaaaagccctatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcg
-gccgaggaatcataaaatatgaattgttacattgtttactacatatgatcacaatctttg
-taaaaggttcgttcgtgatactaccatgtacctaactaacctgagatatatgcaatgact
-tatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctgga
-tttcccaaggttataatgctctatactgaccaagagatccgttacgactcgcaatgaata
-ctctaagggcactcacaaagaaaaccactaattgataaatttcaatgataatatcctgaa
-ttgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcata
-gcaggaacataattactatattttaacgatttaatcgtagttggagtcctttcccaaatt
-atgtcatcagttccgatttagatgttttcgggcccttcttagtaaagaagttaatatcca
-agactagctcctcacccacgcatgcacatattcgcgagaagtctgatagaatattcgaca
-gaaatgcgactctagctcacactcgttaactgatcaggtacttatagacaagtacgttat
-cagatatcgcttcggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgt
-tcaagacctgaacgggaaaatgatattatttttttaggaggaataatacagtaccatgta
-aatactcaaccaccttacgtacttcttacgccgaacatatatggcacgtgttattcggct
-aacaaaactgttgtgccttttctataaggataagcagattcgttttaaacatatgacctg
-taaactgggatctacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcgg
-atctttggttaaagagcaccattagatgtgccatacttcctatcgcctgagcgagaattt
-agtctgaggaaccactcttgggatttaaaacaattcggttaggacacctactcggcggat
-gaagcaatacgataacattaaaagtcgttcagtctaattttggtcgtagtacgatgagct
-gatggccaattgtatttttattaacagcactgaaacaaaatggagactttagactaatac
-taaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtata
-gcgccgaagtgtatctcattattataacaccagtgtacagacgacatctaattatggcca
-gaaactgtcattgtgccattaagaggattagtagatagtctggaccgtggaatagaattt
-tgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgcacgagaatataca
-agttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgct
-tcttaacgcaattcagtcttctagatccgctattccaacatcaatatctcaatttaaggt
-caatatatataacaaaattagacagagcagctgacacttacgaagcatcgtagaaccgat
-atagtcgaccttatgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacg
-gtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtct
-ctgaagtcaagtattactgcgaaaaattcgtctactattagtttattatgaacttatgac
-gcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagt
-tcataatgttgctaaagattatcagaccccgtgaagacttcgggctttgggcttcgtacc
-gtagcataatacatctatatagttagaggcttgcgtgttgttgtgctattccacatatag
-cagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaa
-gtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgtatttattatact
-gtaggcaagaagcttttttggcgagatttaagacttaagcctatggtaaaaatttgatag
-tgagcgactatagtaagagatttgggtggttagtaattaaaattctcctatgctaaatca
-ggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtgga
-ttatacaaatttcaaacatattggcggggcacttatccataatagatttctgtttgtacg
-ccaaactctgcctcacccctccataaattgtattggctagaggttaaattctccgtaaat
-agagacacatatagttttatacaattgtttgaatcaaagcacgagaaacttttaaccgta
-cattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctga
-gcaataagcaagaaaacacagattatacaaagagatctggatgaagatattcgtgcaatc
-actatcgttatgttagagagttccatgcatgaggactcgttttttgaccaggagaattaa
-gccaagaaataactgacgtatttccaaatgaattctacgtgtttttcctgtcacctttag
-ccagtgttaaagatgactatggagtttcgaataggttattctatagacattataacgagt
-ggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaaggg
-attttaggttcttaatccaacgaagaaataacgcatcacccgtcattctattgttttcgt
-cgggattacttagtaggcagggtattctaacctacctgagttacaaatctttaaaaaact
-ggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatat
-actagaatccgtctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcag
-ttttatagctatctagtggcattcctttttataaaactttacgtttgtaagggtccaact
-ttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgta
-tattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttc
-taatctaacaatgtaaagccggggattagccgccaaaggggtctaatgacatagagatgc
-tctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgacagatcttccgta
-ttctgttagttgacatctgtgctgtctttaccgattgtgatttggctttagcagtcattt
-agtttcgttactcattgctcgtgcgatagttccaccgaatatggcacattcgttcttttt
-ttccattttactgcaaaccttttcaaaagctgatcgataccactgatgatggcattgatt
-agtcgattggcaactatgtcctgcttatatctccaattgcattgaatatagtaaaaaata
-aaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaa
-gcgccgtacctaacatataagtgattgagacaaatagttctccagacgtattgagatata
-tgtctcctataggcaagcgtttctaattgctgaccagaaattagaattaggttgttaata
-ctatattcgaccattttattccacgaatgtgctattctactggtattgctccgtatgcga
-tatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtc
-atttaccgggagcgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaa
-agacttccgcttactatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtat
-aagaaaatcatcttttcagttcgcagatttttgccaatttaaccggttatttcgtcagac
-ttggtagtgtagttacaagcatcacgattatatcagctacagaattaaactgtcctgact
-cgacggggcagtgtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtc
-atagtacaaggataatgaggtttgctaactttaaaaattattgatttaacggttgattga
-aaatctctgcaagatgacgctagaacacctgatgttcaagtttgccgataataacatata
-agatgaattactgtctttagaccctcatgttaatccgctaacttagggcggaaacaatgt
-taggctatgcggagtaagtactatattatgataccacatagaatttaacattcatatgat
-gtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatca
-atgggccaatcctgtctcaaaaattatcatattcaaggttcagctattttggcaatgggt
-gagtaccgttcttagtgatttacgaacccataatctaggcgacttaatatacaagattta
-gagttacgttttccgggtagtacatattaacgaccatggatcgggtgaggtgttgtatta
-gttatctgatcttgtcagtagctcccaatgtcccagaatattatgtttctactagagtgt
-tcgtatactggaatttaaatattatgtaagactagacaaattttatggatacattaggcc
-atcgtagaatatgatatagttgtaacgtccctctatagattttcggagggcaggtatatt
-gcttaataaagatgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgc
-ttaaataagtttagactattaagctatatgttcgacagcatgtagttttttttaccagaa
-agtgttatactgatgacccatggaggtagctcctcatgataaaaatattgttacttaagc
-attactattatagtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtt
-tcttatgcagacacacttttttagctgttgacgcccacctcacatccatagtaggtcaat
-cgcataagaacaatattctggactgttttattacccagaagaaagttttttctttccggt
-tcgttaagacaataaagatcatttcattcgttctcttaacgatgaactaaagtacttaaa
-gtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaagataagaagaac
-aggaacgcgcacgtcggagataactctaatagtctctttattccgtttaatatagcccgt
-aattgcaccatgcgctacagtaacggccgccttcgcaaacctatttatgtaattccaagt
-ttaggtatgcaatggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcg
-gggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtg
-ttaccaacccctcactactacgcgaaggtactcgattattccttgaatgggctgaaacat
-cgtgattagcgtcttatgattcaggctgatagaagaaaacttattttctatattccacgt
-atacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaa
-atacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtcacataaataatc
-cgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtag
-cattgttgaacagtaaaactaccgtcacacaaggaatatcataatagatgccatacacgg
-ttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtg
-tgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatgga
-tgagcatttaggtattctatgataacactaaccatcatgtttctaaaatcctcaggaaat
-ttgtattattttaccaacctgtatttatagaaagtgcttttgacttaaagaagccgaagt
-gttcaaattaaggagtacctgattgaaagaatggggaattgtaatctgtaactcaattac
-aaataagccgttctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaatt
-catactcgattaacgactttaatactcttctgcgtatctacagactcatttaaattacgg
-aatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaataaggacacctg
-gtacaattggctggagtacaatgttggtttttatttgctgattatcccgatccctgtggg
-cgttggcataaccgggttttcttcaagactactttcgtgttgcttatatacctggtaata
-tcggtgagtagcttagggcttaatcacaatactaacaagttctctatggattggacaggg
-cggcatccgttgactgaacgatctattaatccattccctgcactggataaacaagaccca
-tttaaattgaccatagagatgttagcgtcatatttctgttcgtgatagggtacatatatt
-ataaacggattatgagcagtggttttctagaaaagcattcatagttaggagtgtatcaga
-tcataccactgaaccatagagcacaattctctactggctatacttcattcctttttgtcc
-gggtggggacgaaatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgct
-ggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttgactattgacagg
-gcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagatagagtacgggcc
-tataattcaaattcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtt
-tactggtatgtggtgtcaagccccacccattctctgttatatccgagcattaatgtagtt
-tcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctga
-gaagtggcactataatagtttagcctaagtcccttcgctaataactcaacaaagatgacg
-caaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatactgatagctctcat
-ggtaccaagaactttcataacctctttatttaccaaacctgttctactagcgttagtgtt
-ttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaa
-catgggatcaaaactattggcttaacgtttaatcgaatgagactagcactgtattactct
-ttcgtttcggcagcggatcaataaggaggtgacggcatcactctcttatagtagatatca
-cttattctcacaacggaagtaggatcttccgtcctcattaaatttgcaactggctcaatg
-taacactgtaatgttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtc
-cctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaaattccagacctc
-gagttacattatgaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttg
-taatataaacaaccgtttttgtctattttcccaaggagaaggagagtagcagcttagtgg
-cttgcctatatggccccctaagtacgtactcggcacgcttagaagattgggctaccccgc
-actatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatg
-agagtataaaaatatacaattttggcaggggttatacattgcgggcatgaagagtaacat
-tggacatgaacggacattcgaaccctgtgagtttaataccctatctccggatcattataa
-agtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaactaaattggtta
-tttttctttcatctagatttgtctgtatctaactaaattatagttccacataaagctgat
-tcaactgaagacataaatataaactttctaacatagtagcgaggaaagagctatgcctag
-catcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttttccagaatctag
-accgaacacagggtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaac
-aattccgttcgtattgttgctgtatctatatttcctacgtaaggctatttgatctataat
-atgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctcct
-tagtatcatcaaattatagattttacggccacgaattattggtctagatgtcccaaaaat
-aatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattat
-gctataccaagaactctccatccagtacctagaaaggcaggtatgtaccgctcattaatt
-ttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggcttttataatagaa
-actaagtttcccgaataacggtgtacgataacagatttttaggtgtacagacgtctgact
-caatgaacacacattgggacctgccccgggaggagtagtagataattaccttctccagcg
-cgggtcttttaatatcacaacataaaaatactaattaatatcacacaccctcatcctcga
-tggagcctagcatcatacacgtttgatagacaacgccaattttactgtaatatgatattc
-gaatctagtatgtggacgctgtaccacattgtttaaaggagctccctttaccgacatgaa
-cgaagcaagctttgtacaagatacgaagaactcagtactggtaactataagagacaattt
-atacataaaagtgttaagaccattatataaaaagaggtatgaggtctttgtaactacaat
-aatacattcatcgaacgatggagaataacagagttatttctgctgctcgagctctagttc
-tgctaatttctcaatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcg
-tacatccctctctcctactcttacctatatcctattactggttaacctacatctccggga
-aagacgtaggtaaagtggtccacgattgtattcacttataacacctagtagtactatgtg
-ttgctgagagtgaggacacacttactctacgagttcaagtccatatggacattacacttt
-ttcagcatctaggtgtcatgatgtattaacagccgttaggggctatttgattttatcgat
-tgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaataggcatgaaaattc
-aagattgcagttcctatcttgtataatctttcctttggacgagttgtaccatttcaacta
-acctgcaagtggggggtcatccatatgaagatttgccaaatacctggagaccctgaaaag
-tttatccagattaataataacaaacaaacctaagcgaagaacgtcagctttaataaacta
-tcactatcatagaaattcctgttaattgttcttccaaacgttgaatagactatcacgggt
-aatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgata
-actcaattatattcgatggagaattcatatctaccgcttagcttttaaaaattaagtcag
-attattccgccacaatgagaaggcgcgagtgcactaatcaaatcacttaggattattacg
-gacgtctgcattacaatgctttggggtagggttatacaagcatatgattctttaggtctc
-ttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgt
-tgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacctgttcatgaaaga
-caggagacacgaggcaccacctcaattctatgcaaaactctaacatagcgtggcactatg
-agtacgtgtaacgacaaggtctcatactcgatcctaagataattctcgtctggaaggttt
-taatctttaactaagagtagaacttagtttattgacttttacaattaggatacggttcgc
-gactctaccacagggcatcatacctggagctctgctatctcgtgaccaaagtggcagcac
-acatagggtcgggtcctgcatctactgagcaatccctttaagcattcctagtttgagagc
-catttagatattgctgtttaaaccgattaatggtttctattattataaagtgtaacgctc
-ccattcgggacattgaaaattagcaataagacaatgtatgatattcggcgagtctcaaca
-acattatggtctaccatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaa
-cacccatggttcgttaagtgagggtatccaggtgttataaggacgatctagaagtattca
-ggtacacggtgttcagacatgctctaattgtcaggttgtttataatttaacgtatcgctc
-tctattctaaataatataaaattaaccgctcgtagggatgctttccagtaaaagatacac
-tatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtacattcttaaactt
-aaatacgtattatttaaagtaaatatattatctaaaccgcttttgtctatccacatttcg
-tcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatc
-tatttcttctgattgatgtaatactgacccttactccgtacatacaaatgatggtaagca
-agaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtag
-cttgaaagggatatggatgtgtatgccaggcttcattttgacaatttttctgtcctgctc
-agtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgtagatccaatcac
-gctttcctacgctaatgaaagttctagatagtgtaggtgttagacagaggttagcgccta
-catccttacacacacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtat
-ttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaatgtcctgcccta
-gagttatgataaaataactgctgccctgtaacttaagtttacaaaccgatattcaatcgt
-tgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaac
-acagtgatttataaatacaaagagtacatttagttaccggattgcggcttgacatttatt
-ttacagaattttatcggcaaaacacttcatatgaactatcgcttcacgataagtctatga
-tagactagcattcgtagagaacaggaagagcaatcattatatatgaagtgttacagtggg
-tactacatatgagatcattaggtctatatccggccttcctcataagaccttggaaatatc
-ttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagta
-attcatcggacgtaatagtctggttttaactaggggttattgatatttaagctaaaagag
-ttccctgaacactcgaaatgtataatctatcccaactaaaaaagtatacctctaattcag
-aaatgtcattgagattagactgatgtcaatacgctaggaggtaagacaagtagaagtttt
-tgatttaggaattgaaatgtaatacctccatcttaagttctatattttaaagttttatgc
-ggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatgtttgcggccccg
-tatgagtaatgatctgtttatcaatctctagctactatcccacgaatgcactgatgccag
-tcatggcgcttacattagtcgacagaaatccgacgatacctatcacgcgtgaactgttct
-ggttcttattcaattcgaagtgatctcagatacattacggccatgcttgcccttcatgtc
-tgctgagcagttttgttataggctgaatctcctctaagcgaaattgataggatttttggt
-ggtcgatttagtctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaa
-tgatagggatcggctgaggaggataaatatacgctggtgcctggtatttatccagaacaa
-gttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaa
-ggccgcaaagggttacatctcaggatcgtggcgtatagtccaccattagttctgacttac
-ttaatatagactgaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtc
-ggttagcaaaacgtataggagcatgatcaaagaagagttaattaatagtactgcactata
-attgtcggcggagtaccatgagctgttgcccaattcgatgtttattaacagcacgcataa
-aaaatccagacttttcaattagaattaactataaatggtccgcgaaccttaaatgatcgg
-aaggacgggatctgccgttgtatagaccccaactctatctaatttttataacacctctgt
-aatcaacaaatcttattatgccatcattatgtcattcgccaagtaagtccagttcgagat
-tctctggaccgtgcaatagtattgtcaaattatggtaatggaatccttcttctaacaccc
-ttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgcc
-gtttctttttacgatgatagggattcttaaagcttttctctattctagatcccagttgcc
-atcatcaatatctcaattgatgctcattatatagttcttatttagtatgtccagatgtca
-ctgaagatcctgcctagaaccgatattctcgacaggatcatcagttcgacggggcaaacg
-cacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatg
-tggaaaaaaactcctgtccacgatatgtaggcaagttttactgcctttaattagtagtcg
-attagtgtagtttgatattatctaccttatagaatgtaaacagtaacccggccttaatgg
-tttggcaggattctttgtaaaagttaataatgttcataaactttatcagaaaacctgaag
-tagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgt
-cttgttgtccgagtacacatattgctcctctcccccactcttctaggaaaatcaattatg
-ctaacctgcagaccttcttctttactatctttaatgcatgcccagtatgttcatagggta
-gacttgctatctattttgtataatctacgaatgatgcttggggcgcgacttttaacaatt
-aagccgttgggtataatttgagagggtgccacgatagtaagagatttccggcgtgagtaa
-ggaaaatgataataggattaagcaggcgtaatagctcaccctcctcagttctccaaccct
-gaaccggctaagtatgactgtgcagtattaattttgaatacatattgcagcccctaggat
-acattatagatgtctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcg
-attgaggttaaattagccggaattacagacacagattcttgtttacaattgtgggaagaa
-aaccacctcaaacgttgaaacctacattcacaaatggattacgttggggatgagaatcga
-ttccggtcaaaaatcatgcccggagcaataaccaagaattcacagaggattaatacactt
-ctccatgaagataggactgcttgcactatccttatctttgtgtcttccttcaagcaccaa
-tcgtttggggacaaccacaattatgccaagaaataacggaaggtgttccaaatctatgag
-tccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggactttagatttggg
-tattctagagactgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaa
-aggggaccgcacgttgtgctagggatgtttccttaggaatccatacatgtaagaaagaat
-caaccgtaattatagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacc
-tctgggaaatagattgaatattctggacagcagcgaatcctgattatatctcaagcgaat
-atatgacccgcaagaaggatttatactagaataagtctaagaaagggcattgggtcactt
-cttccactaacacacttttatcagttttataccttgagagtcccatgcatttttatatat
-atttaactttcgttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaaca
-acggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttc
-tgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaa
-accgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttc
-tatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagttt
-gggttttggatttaccagtcttttagtttcggtactatttgatcgggacattcgtccaaa
-catgatggctcattcgttctttttttcaattttaatcaaaaccttgtatttacctgatac
-attaaactgagcatcgcatggaggtggagattcccatatatgtaatcatttgatatccta
-ttccattctttttagttataaataaacgctccactgcacaatgggagtaggacttcacca
-ataattagcatctactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaata
-ggtctcaacaacttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaa
-gtaagtagaattacggtcgtattacttgttgccaaatggttattactccaatgggctatt
-ctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagt
-ggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggt
-gatgaattattgttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaa
-tttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgcagagttttgcca
-agtttacaggtgatttactaacacttgggagggtacgtacaaccatcacctggttagcag
-agaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttatta
-aacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaa
-tttatggttttttccgttgagtgataatagctgcaacatgaagatagtaaaactgaggtt
-aaactttcaccatattaaattatatgttcaattacgcgatgtacaaactaatgttaatca
-gatttaggagcgcgcttaatatgggtccctatcccgactttgtacgagattttgataaaa
-aatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacaca
-tttaggatgctatttccctaagaaagcggaaaatcctggctcaatatttataatagtaat
-ggttaagattgtggcccaatcgctgagtacccgtcttacgctttttccaacacataatcg
-acgagaatgtatttaaatgtttgagacttacgttttccgcgtacttattattaaagtcat
-tggagagggtgtcgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatc
-tattggttgtttctaattctgtcgtccgtgtaggctatttaatttttatggtacacttga
-atatgtttagccataatgtagccaatactacaatatcagatacttgtatacgacctatag
-acttttgccgaccgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtt
-tgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgctatatgttactc
-tgaatgttgttttttttaccagaatgtgttataatgatcaaccatgcacgttcctactaa
-tcatataaattttgttacgtaagcttttctatgatagtggtctaaagactacccttgcat
-actttaagattaagacatgcactttaggaggaactcacacgttttgagctgttctagccc
-acctataagccattcgtccgcaatcccataactacaatagtcggcaatcttttattaccc
-agaactaacgtttttatttcccggtacgtatcacattaatcttaatttaatgcgtgagag
-taacgatgaacgaaagttatttatgtttaagccgcttcttgagaatacagattactgtta
-gaatgaaggcatcataactagaacaccaacgcgcacctcgcacattactctaatagtagc
-tttattcagtttaatatagacagtatttgaaccaggcgctaatgttaaggcccccttcga
-aaaccttgttatgttattccatgtggtcggaggatttgcggggcgatagcgctgggcggg
-gatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaa
-aaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccgaagggactactg
-tattccgtcttggggatgtaacagactgattacagtcttatgatgaagcctcattcatct
-aaaattagttgatttattccacggatactatcacactcctatagaaagagttaccaccgt
-gggaagctagatataataaataaaagacatacaatattagtatggctcatgatctacact
-tactcggatctctctttttttataaccagtagatcgcattacacgtattgttgttccgca
-tcaggccctaggggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaa
-gatattaatagatgaaatacacgggtttacttgatttctgttcagtcattcacgggaaat
-cctaggagtctttcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtct
-cgacggaattggtatttcctggcatcacaatttacctagtattggagatcacttaaaata
-atgttgagataataatcaggatatttctagtatgtgacaaacctctatttagtgattgtg
-attttcaattaaacaagacgtaggggtcaaattaacgactacatgttggaaagaaggccg
-aattgtaatatctaactcatgtactaagaagaagtgctttcgtttaaggctttctgtcta
-acattctaacgtcaattcctatgtaatactactgtaaccaagttattactcggctgcgta
-gataaagtctcatgtaaatgacggtttatctgttacttttgggtttcaacctagctagga
-cgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgt
-ccggattataaccatccctctcccacttggaatatcaccgggttcttaatgacttagttc
-gtcttccttattttccgggtaagatcgctgtggaccggacccattttgatctagtctaaa
-aaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgc
-actgcactggattaacaagaacatgttatagtgtactgacacatgttagactaagaggtc
-tgttcgggttagccgacttatatgtttaaccgattttgacaactgggttgagagataaca
-atgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatg
-gcttgaattatttaattgttctaaccctggcgtcgaatttttttggttcgaaaatactta
-gcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaa
-ggcagtattgtgactattgacagggaatcctaaaaagctactcgaattggtatatggaag
-aggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagct
-taactagtttgatggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatg
-ggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgtacactaggcagcc
-ctaatccaaaacttttgaggatgagtactgccactattatactgtaccatttgtaactta
-cattttatatcttcaaagaggtagatattgtcggccattactgtcacttacactaagggt
-agcttgattactgatacctctcatggtaaaaagtaatttaagaacctatttttttacata
-acctctgctactaccgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcac
-ccctataagcagaaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcct
-atgagaataccactcttggaatcggtcctttaggctgaggatatagaacgaggggaacgc
-atcaatctaggttaggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctc
-agtaaattgccaaatgcagaaatcttacactcttttcttaactaagtatgagagcaacct
-cactcctgaacagcttgttacctaacgagaagaggctttaagtagcctggagcctcaacc
-ggatatccggatttgactctcatccacttacatgatgattacggtcattacatctcatga
-ttttctgagtgccctatagactgggaatttaatctaccctgtttctatttgttaacaagg
-agaaccactggtcaagatgacgcgcttccatttatgccaccataagtaagttctcggaac
-ccttacatgattggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtgg
-cctatcatattcaggtcatcgagctcagtatttaaagattatatggtcgctgggggtatt
-cagtgcgcgatggaagactaacattggaaatcaacggaattgacaacacgctcactttaa
-taacctatctcaggataagtttaatgtaattagacggaactttctctaactccgtgtact
-aactctttgaaaataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaa
-agtattggtccaaataatcctcagtaaaatcaagtcataaatataaaatttagatcttag
-gacagaggaaagtgctttcccgagcataggatctggcctacgccagtagttcatgcttgt
-gttaaaagttgttactgtttatagtccgtactcagggtagtgttcgatactcagcgggga
-actgacatattacactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaat
-tacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgatt
-cgagtttgtaaattcacagatactgtgtatcatattattatagatgttaaggcatagaat
-tattggtattgatgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagt
-gcagcttggaagaactggatgtatcctataactagtaagagccttaaaggtactacatac
-ccagggatgttaccatcattaatttggccatcttcaatcttcgcaatgcatactttcttc
-tacaagatgccttttagaagacaaaataagtgtcaacaataacgctgtaacttaactctg
-ttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgcaaacgcaggact
-actagattattaaattcgccagcccgcctcgtttaatataacatcataaaaattctaagt
-aatatctcacacactaatccgccatcgtccatagcatcagtcacctgtcttacacaaaca
-catgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaa
-agctgctaccttgaacgacatcaaccatcctacctttgtacaacagaccaacatctctgt
-actggtaaatagatctgaaaagttataaatataactgttttcacattgatagaaaaacag
-ctatgtgctatttgtatatactataataaattaagcgaaacatggagattaaaacagtgt
-tttctcatcctccacctcttgttctgctaatttataattcttgatgccactcgtgtgagt
-cgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaacgagatcctatt
-tctcctgaaaattattagcacggtaactcctagggatagtggtactagttggtatgaacg
-tataaaaacttgtactactttctcgggatgtgagggagcaaactattactcgaccagtgc
-aacgcattatcgacagtaaaagttttcagctgatacctgtctggatggattatatgcagg
-taggcgagagtggattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaa
-agtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcattt
-cgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgc
-aatagtactccagaccatgaaatggttatccagattaataataacttaatatactttcac
-tacatactcagcgggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaa
-aaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgt
-aaaatatagtagaatatgatgttaaatcatttatattccagggagattgaatagcttacg
-attagctggtataatttaactcacatgattaagcaaatatctgtaggaccgagggaaaga
-ataaaataaagtaccatgagttcggaacgctgcattacatggcgttgggctagcctgata
-caagaagatgagtatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggc
-agatcccggagcagatgattatcgtctaacactgtctttaccaatgcacaacgcatagat
-ttaacctgaactgttctggattcactcctgactacagcctacaactcatttctatgcata
-actcttaaagacagtcgcaatatcagtacctctatacacatcggatcagactagatcata
-agataagtctcctctggatccttgtattctgttaagtacactacaaatttgtttagtgtc
-tgggacaattacgataagggtcgcgactagaccacagggcatatgacctccaccgctcct
-agcgagtctccaatctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcac
-tgtaagatttacgagggtgagacccatttagatatgcctcgtttaaccgttttaggcttg
-ataggatgagtttgtcgatccatcaaattcccgacattcatattgtccaataagtatatc
-tagcttattcggactcgctaaactaaattatggtataaatgccgtcaaccggtgcatttg
-ttcaatcaacaaattatagtcaatctcccatggggccttatggcagcgtatacagctggt
-ataacgaccatatacaactatgaacggactagctgtgaactaagcagattattggatcct
-tgtgtataattttaagtttcgatctatatgctatagtatagaaaatgttccgatcgtacg
-cttcctttacagttaaacagtctatatcatgaagcttatccaaagctggacatttgatgg
-caatcttacttaattatgaaacttaattacctattattgaaagtatttatatgatcgaat
-aagatttgctctataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaa
-cctaggtaatctaaagcctgcatctatttcttatcattcatgttatactgacccgttctc
-agtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaat
-aaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcat
-tttcaaattggttatctacggataactgtgcgatgaactactataggtcaaaattatctt
-caatctcattctagatcatataaagatgtccttcgcgattgatacgtctacagtgtgttg
-gtgttacacagagggtagcgactacttacttactaactctctcttgatccgcaagcataa
-gccaggttaaagtgctctatctttttctgtggattataatagttataccgccttgcatct
-aggtgcccattaggtaatgccctagtgttttcataaatttactcctgccatctaacgtta
-ctttaatttcccagattcaataggtctctcatttgaaaattgttatatgtcaacaaagaa
-tataatagctgagtggaacaatacactgtgagggagtaatacatactctaaattttcttt
-acggtttgcgcctgcacagttttttttatctatgtgatccgcataaaaagtaatttcaac
-gttccattcaagttaagtcttggtgacactagcattaggagagatcaccaagaccattat
-ttatttagctagggtttaagtcggttagaaatatcagataatgaggtctttatccggcct
-tacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaagtatggccgaacc
-cacataatgcacaaatcaagtcgatttcttccgtccttttagtctcctgggaactacggg
-ttattcatagttaagctaaatcagttaacggaactagacaaatgtataatagttcccaaa
-tatatatctataaatcttatgcagttagggaatgcagatttgaatcatggcaatacgcta
-gctcggaactcaactacaagtgttggatgtacgaattcaaaggtattacatccttatgat
-gttcttttttggatacttttatgacgacttccacgaagtgaaattatgttcgaatatctg
-aacagttacttggttgagcccaaggatgacgaatgttctgtttataattctcgtcataat
-ataaatacaagcatatgaggccagtcatggagctttcatttggactaacatttccgtaga
-gtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgttatcagatacatg
-acgcccttgcgtgacattcatggctcctgacatcgggtcttttaggctgaatctaatcta
-acccaatttgtttggattgtgggtcctccattttgtctgttaatgcttattaagattaaa
-aatgtactacgtatttagacctaatgattgcgatacgctgtggaccattaatataagctg
-cgccaggggatttttccagatcatctggcctgtgtatatgttcaaatctaatagccgaga
-gaaattactccgacggaaaataaaggcagataagcgtttcagagcaccatcgtggcgttt
-agtcaacctttagttcggaatttattaatatacaatctcactctttggacgagctcctta
-aaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaaca
-gttaaggaatacgactgctctataattgtccgaggagtaccttctcatctgccaatagtc
-gttgggttggaaaacaacgcattaatatgccacacttgtcaattagaagtttctataaag
-gggacgagtaactgatttgagacctagcacggcagaggacgttcgtgtgacaacatctct
-ttataagtttgagataaaatcgctaatctacaatgattatttgccaatcattatcgaatg
-cgcaaagtatctcctgttcgtgattctagcctaaggccattactatggtcaaattatgct
-aatcgaagcagtcttctaacacccttagaaaagcaaacactattgaatactgccgccgca
-ttcgccagcaccaacataactgcacgtgcttttttccatgattggcattatgaaagattt
-gatctatgattcttaccagttgcaatattcaatttagcatgtgttcctaattattgtgtt
-attatggtctatctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcagg
-atcatcagttcctcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaag
-caatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcg
-tttactgccttttatgaggagtcgagtactgttggttcatatttgctacatgattgtatg
-taataacgatcccgccctttatcggttcgatcctttatggcgataagttatgaatcgtca
-gtatctttagatcaaaaactcaactagtacccagttccccggaggaacggtcatgattaa
-tgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccac
-tcgatgattggtatagctatttgccgaaaagccacaacgtattcggtactatcttgtttg
-attcccctgtatcttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatc
-ctgggggcgacacttgttacaattatccagttgcgtttaatggctgtgggtcacaagatt
-gttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagct
-cacccgcctaagtgatccaaccctcatcaggataactatcactgggcagtattatttttg
-atttcatatgccaccccctaggagactgtagtcatgtatctttcttacccaatctagccc
-gaaacaagaaagaatgtcgattccagtcaccttttattagaccgatttacacacaaagtg
-tcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacgacttgctctattc
-gattaccttcgcgatctcaatcgattacgctaaattttaatgcccgctgaaatatccaac
-atttaaaacaggattaattctctgatccatgaacttaggactcattgcacgtgacttatc
-tttctctcttaattcatgctccaatacggtgggctaaaccacttttatcacatgaatgta
-cgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatc
-ttctattgggacggtacatttcggttttatagactatgtagttacacggcatcaacatgt
-aattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggag
-gattacatacatctaagaaacattctaaactatgtatagtcgtttacgacccttgtagta
-cgtgcatcccttggcgaaaagtactctgggtattagagtgtatattatcgacagcaccga
-atcctcattttatagcttgacaatttatgacccgaaagaaccttttataagtctataagt
-atatctaacgcaattgcggcactgagtccactaactatctttgagcagtgttatacagtg
-agacgccatggaaggggtttatatattttactgtcgttccctaaaaagttaattatcaga
-cctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccatt
-ccagtcgagatcaaccgtttctgcggatcgcgttacattccttgcttatttgcgataaat
-cgatacaaccccattaccagaaaaacccggagaatcaattactctgcagatcttatacta
-aaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgtggagcgttgggg
-taagagcggagcgattttaactttcgcttttccattttccagtattgtactttacgttat
-atttgagcggcacattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaat
-caaataattgtattttcagctgactttaaaatctgcagccattggaggtggagattccaa
-tagatgtaagcaggtgatatcatatgcaattcttgtgacttattaagataccagacacgg
-cacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaattccgaacgtaaga
-tatgtttacggatgcactaaaataggtagcaacaacgtttctctgagatgtataagttac
-caaacactggagaattccgctaaactaaggacaatttccgtcgtattaattgttgacaaa
-tggttagtaatacattcgcagtggataatccgttgcatacctagcactgagtgtaaataa
-aaccaatcgactactggcatttcgggctaacgactagatgttagcctatgtgaaagcctc
-acacatgcttattgccttcacggtgagcaatgtttcttattcgttattagaagtcacctg
-tagagacagtagagatgacctaaatttggtttgtccagtcccgaggtgatctaatgatta
-ggttaacttagaacagtggtcaattggttaaagctgatttacgaacacttccgaggggtc
-gtaaaacattaaactggtgagaacagtatgatgtattcggtcatctagacaaccccatcg
-ctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcct
-gttgctccggggagatagggttaatttaggcttttttacggtgtggcatattagctcaaa
-catcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaag
-cgatgtacaaaataagcttaataagatttaggtccgaccttaatttcggtccatagcacc
-tctttctaagtgttttgcttaaataattgtattgttattgattttctgcgagttgaacac
-ggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaa
-tcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccgcactaaacggct
-ttcgctgtttccaaaaaattttagtccactaggtatttaaatgttggacactgaacgtgg
-aagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgtactttgagcagat
-gctatcgtcagaaaaaggtaaatcttttggttctttataattctggcgtccgtgtagcct
-agtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaattacgtcattag
-ctgttacgtctatacgaaatatagactgtggacgacccatcgtagagtcatgtagttaca
-tgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactgg
-tcaattggttcatagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagc
-ttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcctgttcgaggtta
-gtcgtataaagacgaaacggccttaatgtaacattaactattccactgtaggtggatcta
-acaaggttggacatgtgctaccaataagataagaatttcgtccgcaatacaatatctact
-tttgtagcctatcttggattaacaacaacttacgttggtatttcaccggacgtatcaaat
-gattctgattttaatgactgagagtaaacatcaacgaatcttatgtatctttaagccgct
-gcttgacaagtcacattactgttagaatgaacgcttcattactacaaaacctaccaccaa
-ctcccacattaatattatactagatgtttgaagtttatttgacaaaggttttcaaaaagc
-acagaatcgttacgaacacgtacattaaattgttagggtattaattgtggtcggtgcatt
-tccggccccatagcgctccgcggggagaaactatggccttcatgacagcccccccataac
-atctaggtaatggtcggataactataaacaaccctctccagagaactgtgaaaataaaat
-ctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaagactcttttcact
-attttcttgatgcctcattcttctaatattaggtgattttttaatccgagaatataaaaa
-gacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttt
-tgactatccctcatgatctaaacttacgcggagctatctttttgtataacatgtacagag
-aattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttat
-cgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacgggtttcgggatt
-tctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaa
-ggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtcc
-gaggattgctgataacttaaaataaggttgagtttttaataacgatttgtcgagtttggg
-aaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacgggtataatttac
-gacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactg
-ctttcctttatcgattgctcgagaacattataaagtctattactatggattaagactgta
-tacaagtgtttaagcggagcccgtgataatctataaggttttggtacctttatctgttac
-ttttgccttgaaacatacatacgtacacgggaatatttacctaaacgccgtatagtccag
-cctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgcccacttgcattata
-acccggtgcggaatctcttagtgactcgtcaggagtttacgcctttgagacctctcgaca
-ggacccattttgatctagtcgttataggtagagtgcctttcctatcgcaccattaccttc
-tagcaaacttagagtattcaatgaaatcatatcctgtttatactaaatgttataggctaa
-tgacacagctgacactaagaggtctcttcgggttacccgaatgagttgtttatacgatgt
-tgacaactcgggggagtcatttcaatgaagactgaggactcttgatcagattaaaacgct
-taatgactgataatttagattatgccgtgtattatttaagtgggcgaaccctcccctaga
-atgggtttcctgagaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaa
-cgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaa
-ccgtctactattcctagagcgaagagctatgttctgacacgtccccaatattaggcaaag
-gctccaaaagaacagtcaattgattaactacgggcttggtttctccgtgaatccttgcgc
-cgctataccacataaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgac
-cctcaacaagtacactagcaaccccttagcaattaattttgtccatcactactgccaaga
-gttgactggaccagttggaaatgacatttgatatattaatagagctacatattgtaccac
-tttactgtcacttacactaaccctagcgtgattactcatacatatattcgtaaattctaa
-gttatgatactagttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttca
-actaaatatttcactgtagccaaccactttaaccagaaggataccttaatgccgatataa
-tattgtccaggaaacgttaatactttcacaagacaaagcttggaagaggtactttacgat
-cacctgatagatcgaccggaacgattctatataggtttggtctgagaaatttgtagctaa
-aaccatgttccataggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttg
-cttaactatctatcacagcatcctaactcctcaacagcttctttcctaaagacatcagca
-ggtaagttgacggcacccgataacccagagcacgattggaatctaatactctgtatggat
-cattacgctaagtaaatataatgattttctgactcaaagttacactgcgaattttatatt
-aactggttctatttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatc
-caaaaatatctaacttataccaaccattacttctggcgcagaaaaacatagatatctgaa
-caatcgaccgttaagactgtctcgccgatcttaggaacctaatactgctcagtagttatt
-gtttatttgggccatccccggattatgtcagccatggaacactaaaagtcctaatctaac
-ctatggacaaaaagctcacttttataaaattgctcaccttatgttgattgttatttgtcc
-gaaatgtctataactcagtgtactatctattggaaaattatggccggagttttattgaat
-atacttttgtatgttgagaaagaatgttgtcgtaataattatcagctggaaaatcatcta
-atatatattatattgagatattacgacagacctaagtgctttcccgtcatgagcagatgg
-actaacactcttggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcc
-cgactcttacttactcagagcggaaatgactttttaaactaacgtttaaaggcacttagt
-atgcgtcagggttatttttttaattacgtacccttgtgcagagagtttagctattcgatc
-ctacttagtatgaaccatgagagtacaggttggtaattcacagagaaggtcgagaagatt
-atttttgatgtttaccaatactatgaggcgtattcatcgaaataattttatggctgcgca
-cttcacatacgcaggaagaccactgcagcttgctagatctggatgtatcattgtacttct
-aagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatggggacatattca
-atcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaa
-ctataaccctggaactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaa
-aggcccaaagcaaaacccaccactacttcagttttaaattagaatcacaccctagggtat
-tagataataattaaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaa
-taagtctccggtctttcacaaacacatggttaagcgatgtggttttgactagagacgttc
-gccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatcttacttcatacatt
-gcttaaacagtacaacttatctcttatcctatagagatctcaaaagtttgtatttttact
-ggtttcaaattgagagaaaaactgcgttctccgatttctatattattgtttaaatgatgc
-caaacatccagtttaaaacacggtgtgatcagccgactcagattcgtatcctatgttaga
-atgagtcatcaaactacggtcacgcgtacattacagagtaaactacacgaatgaaagaga
-taagaagatgaaagagttaataggtctcctgttaattatgagaaccctaactactacgga
-ttggcctactagtgggttggaacggatataaaattcgactaagttcgcggcatgtcaggc
-tcctaaatatgaagagaactcggcatcgaattatccacagtaatagttggaacatgattc
-ctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggc
-gttgtgaatattcttcctcagaaaaggactgttgagcaaggaattggattctgtgaacgg
-aatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgcc
-gcgcgcagacatatcttcttggcaattagtactccactaaatcaattggttataaacttt
-tagaatatctttatataagttcactacttacgctgcgggtagtatatttaaagtgatgtc
-ttaggaatcttatggcggcggaataaacggcttgactatagataccctaattctggcata
-accctgtaacgtgtgaagcatgctttaatagacgactagatcagcttatagaatggatat
-gactgccacattgaagagattaacattagcgggtataatgttacgaacttgtttaacaaa
-atagctctaccacacacgcatagtataatataaaggtcctggagttcgctacgagcctgg
-aattgcagttcccctaccctgagtaaacaagatcagtatggacctatcttctgacccacg
-tgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcggctaacactcgc
-tttaccaaggaacaaacaattgatggaacaggtaagcggctggattctatcctgaataca
-gcataataatatttgctttcaatatatagttatgacactcccaatatcactaactcttta
-caaatcggatatgaagagtgaattagagatggagccgatcgttccttgtattctggtaag
-tactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactca
-cgcattatgaaatcctccgagcatagagactctaaattcgccaagcaataagtcccgacg
-cgaaggatgagaagctcattgaactgtaacatttacgtcgggctcaccatgttacatatg
-cagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacataaaaggccccact
-ttcatatggtcaaatatctatatcgtgctttggacgactcgataaactaaagtagcctag
-taatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatatataacttccgga
-cgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcg
-gaactatgcagattaggcgatccttgggttgaatttttagtttccatagatatgagttag
-ttttgatatggttaccatacgtccctgcattgaaacttaatctgtatattgattgatcct
-tagcaatagcggcacatttctgggcaatatgacttaattaggttacggtttttactatga
-tggatacgttttatatgatagaataacagttgctatttaaacaggtactacattcaacta
-atactgtttcactattgtgtccaacatagggaatatattgcctgaatagatgtattatca
-ggcatcttttacgctccaggtagaactaattaaaaatgatccttagaaactttcaagcaa
-cataagctaaaagttacgccaattataagccacatcggtaggatcttcaggcattcccat
-atccttctctatcaatcccgtctgttgctaattggttatctaagcatatcgcggcgagca
-tctacgataggtataaagttgctgctatctaattcgtcataatatatacatggaattaca
-gattcatacgtcttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatat
-ctctctcgtgttacccaagaagttgacacgtgattgtcagctatctttttctggcgatgt
-taatagttataaacaattgcatatagctgcaaattagctaatcaaatactcgtttcttaa
-atgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagggcgctaagttca
-aaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtg
-taattatttctctaattggtctttacggttggaccaggcaatgggttttttatctatgtg
-ataccaattaaaagtaatttcaaagtgacattaaacttaagtattgctgtcaagaccatt
-acgacacttcaccaacacatttatgtattgtgctacgcggtatggcccgtagtaatttct
-gatattgaccgcgttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgt
-gtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgttgtattacgtcc
-ttttactagcctgggaaataccggtgattcagagtgaacataaatctctgaaagctacta
-gacaaagctagtatagttaaaatatatatttcttttaatattaggatctttgcgattgca
-catttcaagcatcgcattaacctacctccgtactcttctacaacggttgcatgtacgatt
-tctatgcgatgaaatacttatgttcttagtttggggttactttgttcacctagtcctcga
-acgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattct
-taggtttataattatagtcagaagataaatacatgcatatctggacactcttccacatgt
-catgtcgactaactttgaactacagtcatatatagactgttatctgatccgtatgtgtct
-attactactcttatctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcgg
-ggctttttccctgattataagattacactattgctgtgcttggggcctcctactttttct
-atcttaatcattttgtacattaaaaagctaagaagtaggtacaacttatctttcccatac
-gagctggaccattaatttaacagccgcaaggcgagttttaatgttaatctggaagggctt
-tatgttctaagcttttagcactgagaaattaatccgtaggaaattaatcccacataaccc
-ggtaagagaaccttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaag
-ctcactcttgcgacgagctccttaatacaggccctgcgttatattcgaccgtacctataa
-ctagaccaccatcttaaatgtacagttatggttttcgacgcatagagtatgggaccacct
-cgaaatgctcagctgcaaattgtactgggggtggttatcaaacatttaatatgaatctat
-ggtaaagtactagtttatagatagccgaacactaaaggtttgcagaccttcctcccctga
-ggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcgtatctacaatga
-tttggtgcaaatatttatcgattgcccaatcgttctactcgtactctttatagcctaacg
-ccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaattacttaaccat
-actcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgttttta
-cttgagtcccaggaggtaacattggatctatgagtcttaacagtggaaatatgattttta
-gattgtgttcagatttattgtcttattttggtctatctcatcagctatagctacataatg
-acgtcttaactgtttcgactaaccttcagatctgactaccccaaatacaacatagcaaaa
-gaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaag
-aatcgaaaacagatctaccattcgtggaatcaatttttggacgagtactggtcgggtcgt
-gcttatttgctacaggattgtttcgtataacgttcaagcactttagcggttccatccttg
-atggcgttaactgatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggt
-cccagcacgaaacgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagt
-ggaatatgtgtcatcagagacaaatagatgattcctatagctttttgcagttaagccact
-aagtaggcggttctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcg
-tgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagtttcaacttccgt
-ttattggctgtccctcaatagagtcgttctcagggcacgactctcgttcgttattcataa
-gtccagtttgatccacgaatacagaacacgcatatctgataataaaagcttaacgataac
-tttcacgcgcatggtttatttttgatttattaggcaaccaaataccagaatgtagtcagc
-gatatgtagtaaaatttagacaaacataaaacaaagtatcgccattacagtctcctgtta
-ggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgatttaataataatt
-acggctaaacgtattgatattttccaggaactgccccatctcatgagatgaccctaaatt
-ttattcacacctcatttttaattcttttatatcacgattatttatctgagcaagcatctt
-tgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgcta
-aacatattggttcaattcaatgtaagctacctcggaatttgcttgcactaagacggggaa
-gccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccgttggagtcacta
-tggagttacaagcattataaatctaaggaaatcgcagtatcagtccttaccccaaagata
-cttcgcattccctggggtacggaccatgaaatacttctttcatacatgataaacgatgga
-gactcggttaccaccctggtagttactccatcaattggagttaactaagatcgctattac
-aggctttattagccaatcatcacaagcctctttttagagattcacaagttagcaaaccaa
-agttcctttgataagtctttaacgagatctatcccaattccggctaggagtaaaatttat
-atatttgagatcggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtcc
-ttccctaattaggtaattttcagacctccgagagagagtagatcaacaacgcgttatact
-cctaaaatgcttgtcgataacatgacactacagatcatccctggatgagcatcgactttc
-attacttgattagttcagttaattcgtttcaaaccattttcaacaaaatcccccagtaga
-tatgtatatgcacatcttagactaaataacagttttcataccctgggatttgtgtcacta
-tctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactggccctgttccatt
-gtaatcgatgggacgggacgttatattgcagacccaaagtagtaataaattcagccatat
-ggacggagggggggaattgttaagaatataattcgattttcagctgaatgtaaaagctcc
-agccattcctcctccacttgacattagttcgaagaaggtctgagaattggaattgcttgt
-gacgttttttgtttccagacaaggaaatagcccagtaccaagtataatattatgacaata
-gaagcttaaattcacaacgtaacatatctgttagcatgctctaatagaccgagaaaataa
-gtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagt
-tcccgactatgaagtcttcacaaatggttagtaataatttcccagtggagtagaagtggc
-ataacgtgcactctctgttaataatacctttagactactcccatttcgccagaacgtctt
-gatggtaccctatgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtc
-gtatgcggtatttctacgaacagctagtgaaaggactgatgacctaattttggtttctca
-agtccagacgtgatattttgatgaccgtatctgacatctctgggcaattcggttaacctc
-tggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttt
-tagctaagctacactaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcat
-ccatgtgtacgaattcctaatactcttgctcagggcacttagggttattgtagcctgtgt
-taccgtctcgcatattagatcattaatcaacagtcttataatcaccgtaatcggtaaaca
-gttgttatttgttctgataggtagacagctaataaagatgctgttgaacagttacgtccc
-acctttattgccctacagtgaaactagttcttactctgttgctgtaatatgtctagggtt
-attgatttgctgccacttcaaaacggaaattaagtcattaacgaaaatggttccttcata
-ggtaaagatcaatccccaattgaagccagaaattttgagatgtcgattcctgatcattcg
-ccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttg
-tttattctggctcaaggtacgtggaacacgtagtattttgatactaatgccagacccgct
-acgatccctgtactgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgtt
-agaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacac
-agtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatactctgggcaacac
-acatacttctctcatgttgtttcttcggacctttcataacctttcctggcacatggttag
-ctgcacatcacaggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggt
-ggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatattatgtttatttg
-tcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttga
-tctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaataagataagaat
-ttactaacatttaaattttcttattgtcgagcatagattggaggaaaaacttatttactt
-ggtatttaaacggaagtttctaatgtttatgattggatgcacggacagtttactgcttac
-tttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgttcatgcttccatt
-aagttcttcttaaacttacacaaactacctaatttagagttgacgagatggttgaacgtg
-ttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtg
-cgtaggaattctgctacgtccattgcaggccacattcacatcccacccctgaatatatgg
-actgaatcacacacaccaaatttcatctaccttatcgtagcataactattaacaaacata
-tacagacttcgcggtaaataaaatatattagtacacaaccgtatactggttgaactattg
-cccagctttaagacgcttttaactaggtgcttgatcaagaagtattattatatgacggca
-gtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacgccgtagagacat
-ttttgttagatatgtatttctttttgacgagccagcatcttagtatctgaagacgagcta
-tatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagattaaccaaattcc
-ccagaattagtaatggcgccttatcgatttactaacgatatataacttgtgatgttgtct
-gcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctg
-gatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgc
-tatgtaatccattctaatgggtaagaggattcctcttatagtaaaatatgcttgactttt
-taagaaccattgggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttt
-tctacaactacccctattaggttacaagtaatctggctttcttgccacttggcgatgata
-gttagattcgtatttctacaacgcagttactgtatccatggcgcgagataattagatacg
-atttgaatttggatgtagactcgttactactgttgtagaccagcacgtgagtatctagat
-gggtttgctaccttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatat
-tttactataagcagtattggccaccctcgtattgcggcagggtgtgctcacctggttaaa
-atgaaagagaaaaattccattttaaaacccggaggaatctattactgacgaggaaggtgt
-ttaacccgttgagacatctcctaacgtaaaaggttcatattctagttattccgagagtca
-ctttcctatccaaacatgaactgatagcataatgacaggttgaatggaaagcatatcctg
-tttattctaaatctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttac
-aactatgtgttctgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctc
-ctagcgtcatctgatttaatagcttaatgtctcatattttacagtagccagtgtagtatg
-gaaggcggcgaaccagcccctacattgggtttcctgacataagtattacatatcacttgt
-ctgattacacagcaaaatcgctaaccttactttgcgcatgtagctattggaactttgggc
-tagtgtctatcccattaagtttaacagtagactagtccgtgagcgatcaccgagcttatg
-tctcgtacccaagttttggatttggatcaaaaactactcgatattcatgatctacgggct
-tcctttctccgggtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaaca
-tgtttgacacgggatagcgtagaaactaaacaacgaatagaccatccaatttgaatttta
-ttgggtccagcacttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatat
-taattctgctacattttcgaccacttgtatctcaaggacaatatcccttgaggcttttag
-cagaaagagatgccgtaattctaagggatgataataggttgggaaatttaagagcagtag
-taacggtcgcgggttcgaccttaaactatatatttaaatctagccaaacaagttaacaac
-aaccataaagttatgaccttattatattggcaagcttaacgttttaattgctctagtaat
-agagtggtagaggtaagggaccatcacctgattcttcctccgcaaccattatatagacgt
-gtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaatatcgaatggcaat
-tagccacattgagttaaatagttgaggatatttcttgcacagaatcagatctaatctaat
-gattcgttactaaacacttcaccaggtatcgtgaaggctcaagattacccagagaacctt
-tgcaatataagaatatgtatgcagcattaccctaagtaattatattctttttctgactca
-aagtgacaagccctagtgtatattaaatcggtatatttgggaaattcctcaaactatcct
-aatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccatacatgaattctgg
-ccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgccaagatattagga
-tcctattactcatatcgtgtttttctttattgccgccatccccggagtatctcacccatc
-cttctcttaaaggcctaatattacctatgcaaataaacatatattgttgaaaattgagaa
-cctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgactatatagtgcttt
-agtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaat
-atttttcagatcgaatagcttctatttttgtgtttattgacatatgtcgaaactccttac
-tcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtctcgttttacggcg
-gaatcttgagtctaacttatatcccgtcgcttactttctaacaccccttatgtattttta
-aaattacgtttattcgaacgtacttggcggaagcgttattttttgaagtaagttacattg
-ggcagactcttgacattttcgatacgactttctttcatccatcacaggactcgttcgtat
-tgatatcagaagctcgtgatgattagttgtcttctttaccaatactttgaggcctattct
-gcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttc
-atatccatcgttcattgtaattcttacacaatgaatcctaagtaattacatccctgcgta
-aaagatggtaggggcactgaggatatattaccaagcatttagttatgagtaatcagcaat
-gtttcttgtattaagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaa
-taaacgagatagattcattatatatggccctaagcaaaaacctcctcgtattctgttggt
-aattagaatcacacaatacgggttgagatattaattatttgtagtacgaagagatataaa
-aagatgaacaattactcaagtcaagatgtatacgggatttataataaaaatcgggtagag
-atctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagg
-gtaactattattaattaataaagggcttaatcactacatattagatcttatccgatagtc
-ttatctattcgttgtatttttaagcggttctaattcagtcattatatcagtgctccgagt
-tctttattattgttttaaggatgacaaaatgcctcttgttataacgctgggagaagcaga
-ctaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacag
-actttactaaaccaatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaat
-tatgacaacccttaatacttccctttcgccgaatactggcgtggaaaggttttaaaagtc
-gaagtagttagaggcatctctcgctcataaataggtagactactcgcaatccaatgtgac
-tatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgc
-ctggggagacatgagaccacccccgtggggattattagtccgcagtaatcgactcttgac
-aatccttttcgattatgtcatagcaatttacgacagttcagcgaagtgactactcggcga
-aatggtattactaaagcattcgaacccacatgaatgtgattcttggcaatttctaatcca
-ctaaagcttttccgttgaatctggttgtagatatttatataagttcactaattaagatca
-cggtagtatattgatagtgatgtctttgcaagaggttggccgaggaatttacggattctc
-tattgatacaatttgtctggcttataactcttaaggctgaaccaggcgtttttagacgac
-ttgatcagctgttagaatggtttggactccctctttcatgtcagtaacatttcagccgtt
-attgttacgatatgcttgaacaatattgatctaccacacacccatagtatattttatagg
-tcatgctgttacctacgagcatggtattccacttcccattcaatgagtattcaacatcac
-tagcctcagagatgatgacccacctctaataacgtcacgttgcggccatgtgaaacctga
-acttgagtagacgatatcaagcgctttaaattgcatataacatttgagggtaaagctaag
-cggatgctttatataatcaatactcaataataagatttgattgcattttagagttatgac
-acgacatagttcactaacgagttactattcccagatctagactgaagtactgatcgagac
-gatccttacgtcgatgatcgttagttatcgacttaggtcgggtctctagcggtattggta
-cttaaccggacactatactaataacccatgatcaaagcataacagaatacagacgataat
-ttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaagctatcattgaa
-gtcccgctcacaatgtgtcttttccagacggtttaactggttcccgggagtcctggagtt
-tcgacttacataaatggaaacaatgtattttgctaatttatctatagcgtcatttggacc
-aatacagaatattatgttgcctagtaatccactataacccgcaagtgctgatagaaaatt
-tttagacgatttataaatgccccaagtatccctcccgtgaatcctccgttatactaatta
-gtattcgttcatacgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattg
-ttacgtgacagagatagcagtttcttgtgatatggttaacagacgtacatgaagggaaac
-tttatatctatagtgatgcttccgtagaaataccgccactggtctgccaatgatgaagta
-tgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtataacagttgcgag
-tgaaaaaccgacgaatttatactaatacgctttcactattggctacaaaatagggaagag
-tttcaatcatgagagggagtatatggatgctttgtagctaaaggtagaacgtatgtatat
-gctgccgttcattcttgaaagatacataagcgataagttacgacaattataagcaacatc
-cctaccttcgtaacgatttcactgttactgcgcttgaaatacactatggggctattggcg
-gagagaagcagatcgcgccgagcatatacgagacctataatgttgatgatagagaaggcg
-tctgaattgatacatcgaagtacactttctttcgtagtatctctcgtcctctttctatct
-ccggacacaagaattaagttatatatatagagtcttaccaatcatgttgaatcctgattc
-tcagagttctttggcgggccttgtgatgactgagaaacaatgcaatattgctccaaattt
-cctaagcaaattctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaa
-tctggaatgacggagcgaagttcttatgtcggtgtgggaataattcttttgaagacagca
-ctccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaa
-gcaaatcggtggtgtatatatcggataacaattaatacgatgttcatagtgacagtatac
-tgatcgagtcctctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattc
-ccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctacta
-atgcctttgttaggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaa
-atttcttctacttggattaactacttttacgagcatggcaaattcccctgtggaagacgg
-ttcattattatcggaaaccttatagaaattgcgtgttgactgaaattagatttttattgt
-aagagttgcatctttgcgattcctctggtctagcttccaatgaacagtcctcccttctat
-tcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggcc
-ttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgc
-cggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtagttaaataaatcc
-atatctgcaatcgattccacaggtattgtccactatctttgaactactctaagagataca
-agcttagctgagaccgaggtgtatatgactacgctgatatctgtaaggtaccaatgcagg
-caaagtatgcgagaagctaataccggctgtttccagctttataagattaaaatttggctg
-tcctggcggcctcagaattgttctatcgtaatcagttggttcattaattagctaagtacg
-aggtacaacttatctgtcccagaacagctccacaagtttttttacagccgaaacccctgt
-gtgaatcttaatatccaagcgcgttatctgattagagtttacaactcagtattttatcag
-tacgttttgtttccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggt
-ctgaccaatgtaggaagtgaaaagataaatattgcctacacatactgaattcaggcaatg
-cgttttattcgaaaggtcatataactagaaaacatgatgaattcttatcggatcctttta
-ctagcatagtgttggcgaacacctcgtaatgctcagcggcaaattggactgcgggtcctt
-atcatacattttttttcaatataggcgattggtctaggttagtgattccccaacacttaa
-ggtttgctgacattcataccctcagcaacttcctctcaaaaattagagtgagttggtggt
-cttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttat
-aatcgtactctgtagacaataacccattgtagtgccgattttgtgcataatacaagaagg
-aggatataaaaatgacttttcaataatattggctattagcaacaagaaggagaatcctca
-ttaagttagcaaccgcagggggtactgcagtccaaggaggtttcattggagagagcagta
-tgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctgattttcctagat
-agaataagctatagctacttaatcaactcttaactgtggagactatcctgatgatctgaa
-taccccatttacaaaattccatatcaatgaggctaacgcttaaatttcatttctccatcg
-taacaaaaatcagcctttttatacaagacaaaacactgcttccattacgggtagcaatgg
-ttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaa
-acaaattttgacctgacataatggagcgacttatcggatgttgccgatctttagggtcat
-ctattaagcttatacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacc
-tagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaatacaggagtcct
-tttcatttttcaagttaacaatataagtaggagcttagagaggcttgcatgaaaatcgtt
-aggaattacagaataggcagagagtggggcgtgtagactacattcttcaggccccacaat
-atgggttataggttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcga
-accacgctcgttccttttgctgtagtccacgttcatccaactattcagataaacaagatc
-gcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaa
-acaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaacataattcattc
-tttcgactggacacgctaaggtttggacaaactttgtatctatatctggaggcctgtatt
-ccagcccttcttttaataagatttacggcttaaactatggatatttgccaggaaatgaca
-ctgctattgacaggaacataattttgattcaaacctcattgttaattattttatatctcc
-tgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaa
-tgaatcataatagaccggcccctattaatattggttcaattctttcttacataacgcgga
-atttgattgcacgaacaccgggaacacataaccgtatagcgcccgttatgctagtgccta
-gcgactgggaccgtggagtctatatcgtctttctaccattattaatctaaggatatacca
-ctttaagtcctttcaactaacataaggcgcattccatgcgctaaggaccttgaatttatt
-atttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagt
-gcagtttactaagagccctttttctggcttgtggagactatcataacatgaagatgtttt
-gacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaa
-ttgccccatagcaggaatagttatatattgcagatcgcggtgtaacgcactccaaatcca
-tcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatcaaagcacagtgag
-agttgagcaaattacagttatacgacttaattcagtctccataaattgaaacgacacttc
-ttaacgggaggaccagacacgttcattaagtgaggagtgcactttttgactttaaaaaca
-tggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagttatttctgtttt
-aatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctca
-gagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtagttggcacaccca
-atggacgaataaatgctgccatatccacggagggcgggattgcggttgattttaaggcga
-tggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaattactgcgtacat
-ccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaact
-tcatagtataatttttgcacattacaagcgttaattaacaaacttactttgctgttagct
-gcctatatttgtccgacaatataactggatatctctgcgagaactgtaaattaacggcac
-ttggaacataatagttcctattggtaacgacgttgtaggcggcaattatccggtggaaga
-attgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagtataactttagaag
-actccaaggtacccagaacctcttcagcggacacgatcgctatcaatcaataaggattat
-tcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggac
-tcatcaaatttttggccgtgctaatcgacacacctgttattttcatgaccggataggaca
-tctcgcggaaattcgggtaacagctgggtagatataggacctcccctacgtattaatgat
-aagcctgtcataactagcttggtttaccgaagagacaataaacattcgagcgctcgtgcc
-aaactcggtgcattacgtttgaataaatcggtaacatgtactattactctgcctaacggc
-acttacccgtttgggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcg
-tttaagatcccgattaccgaaaatctggttatgtctgagcattcgtacactgcgtattaa
-gatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactc
-tgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggc
-tttatccaatatgggtccttaagtgctaaacatcattcacaatttcaagacagattgttg
-gtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaa
-ttatatgttgactaaactaccgtgtgtattctggctctaggtacggcgaacaagtacgat
-gtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagt
-aattccgttttattgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgt
-gccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagt
-taactaagtgtctatcgccaactaaaagacgtctcgatggttctttatgcggacctgtca
-tatcattgactggcacttgcttacatccaaataacacgtttgttagcggatagtcgttaa
-gtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctacatgataaatgaat
-aagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgtcgacgagttact
-actaaaggaatgtagggttctggatctatgaaaagcgacctccatatatatacgggccta
-agcggagtaaaataagtgatcaatggactaacattgaaatgttagtattgtcgaccattg
-agggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatggg
-atgcaagcactcgttaatgcttactttagttggttgcgggaacaacaggaggctatacta
-actggtagcgttcttgcttccattatgttattattataattaaaaataagacatatggta
-gagttgtagtcagggtggatcgggttgtctataacgttggaataatcaaaactatcgtta
-acaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacatt
-cacagcacacccctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatc
-cgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaa
-ttcactagtatcctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatc
-aagatgtatgatttttggtccgctgtgtggaatacctctattgatatacaagtgactttc
-tcggtaataacgcacttcacaatgtgttgtttcttttctatgtattttgcaagagaaaga
-agcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactg
-caggaggaacattatccaaattcaccacaattactaatccacccttttacttttactaaa
-gatatattaattctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaa
-ggataccaattgaagtcctcgaggcatgttacaacacacgacttccttccgtctattcag
-acactcaacgagactaacttttcctaggtaatcaatgatattgggtaactcgtggcatct
-tatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactg
-gctctcttgcgcaggggatacgtttattctacgtacccgatttggttactactaagcggc
-ctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagcagggaagggtta
-cagggagagacttattgagatacgattggaatttccatgtacaatcgttaatacgcttgt
-agaccagcaactcagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaa
-taagaaattactaaaaccctagttgttaatataagaacgattcgaaacaataggattgcc
-caagggggtgcgaacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgt
-ttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggc
-ttattctactttttccgacactcaatggacgagacaaacatgaacggatagctttaggtc
-tcgttgaatgcaaagaatagaatcgttattattaatcggtttccattatctatatgcggt
-atagatctccgagaggaccctgtaaactagctctgcggtttaactggtgctaatagaccg
-ccactatgttattgcttctagctcctagcgtcttatcatgttatacattaatgtcgcata
-ttggacagtagccaggcttggatggatcgccgacaaaaagaaaagactttccctgtaagg
-acttaactattacatataacttggatcattaatctgcaaattagagtaacggtctttcac
-cagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattgg
-cagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttgcataaatatctt
-atcgatattcaggttattaccgattccttgctaacgctagaagtcacaccagagtaataa
-taattccagacacctgtgaaataatcggtcactacggatagactagtaacgataatacgt
-atagtccataaaagttgaattttaggggctaaagatattagcaatactggtctagcctaa
-tcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaattgtatcgatag
-gaatagttacagtcacgcttgtagatgtaagagatgacgttattcttagggttcttaagt
-cggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaaacgatattttga
-aatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattttagtggcaacct
-taacggttgaattgatctactaatacaggcctacaccgaagggtacagataatgattctt
-actaccctaacatgatagagtcctgtcctatctcataggtcgacattttaaattcgtaat
-gagcaacgaagatcgtttcccaatttgcaacattcacttatagacttcaggttatttcgt
-gctaacattaagatagaatataatcagtcgttaagaaactattatccagctttcgtcaac
-cataaagattaaaaactgaaacttggcaagatatgaatagctatcctgctttaaccgatc
-gtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagag
-tgcggtaattaatattaatatactattaagctacacagcaaaggctgcaataatgttagt
-aagtagaacataaaggtattctccacaagtaataaatagtgtgagctaattgactaactt
-aactctcgcgacaagtgatgtggataagatgactcatatcgtctttttctgtagtgccga
-catcccacctggatcgaacaattccttctagttatcgactttgattacctatcctattaa
-acagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagt
-tagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatgagtctgggcgag
-cgtgactttctttcgtgtccgaatttgtttaacatccattagattagatgtttgtgtttt
-gggtctgatgtcctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagt
-ccgatgaagtctccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatt
-tagaacacaccttatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgt
-gagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagataagaatttctttc
-atacttcactggaatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcgg
-taaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtaca
-acgaacaaatagcatcaggccttcttatccagcgtgaagtctaattatttcacaagcttt
-cctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggatagaggacattgc
-atgtacgtaggactattctccaaggggtcttctattttgttagcgaaaattgttacagcc
-taatgttagagcggcgtacgactttataccagatactttcattagatatgcaaatatcca
-attaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgt
-ttttctagttcgttctcatatatatagatcaacaatgaataatctcatgatctataaccg
-atgtatatttatattccggttgactgctccggtgcaattcactacggacactaatgacta
-atatggcgcctttcatcagaaacgctaaatatgattaatgaattaagggagtattatcta
-attattagagagtagcagttagtctgatattttcggtgtatgtgttagccgttataatgc
-tgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttcactttatgactct
-ggttatatccctcggagaacaagaataagagtacgagaagttcggtcattgaggatgaaa
-tagaaccgctagacgaatggactcacgtttataaaactatgtatcacagtactacagcta
-actctgaagtccgagaagcttttgtaggacaaaacgttataagtacctttcgcagaatac
-ggccgtgcatacctgttataaggcgtagtagggacaccatgctatccctcatatagagct
-acactaataccattacatggtgactatcgtttacggccatcatctgtaagcgatcatgcc
-tcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttg
-agtcagaactattcgaagcttctcaatccttttccattatggcatagcaagtgacgactc
-gtcagccatgggaataatagcactaatccgattacttatgaattagaacccacatgaatg
-tgattctgcgaattgtctaagaatctaatgattttccggtgaatatggttgttgttattt
-attgaacttatattattaacatcacccttcgttagtgatagtcagctatttccaagaggt
-tccccgagcatttttaccattctctagtcatacaagttggagcgcttttaaatctttagg
-ctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttg
-catgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaatattcatagtaat
-aactacaatacttgatttgttacgtaatgctcgtacataacacaatcgtattccacggaa
-cagtaaagctctattattctgatcgagcctaagagaggatcacactacgctattaaagtc
-acgttcacgaaatctcaaacctcaactgctggtgaccagttatagacagtgtaattccat
-attacatgtcaggcttaagctaacccgagcctttatataagctataatcaagaattagat
-tggagtgcattttagacttatctatcgaaatagtgatagtaagagtttatatgacctgat
-ctagactgatgttctcttccacaacagccttaaggcgtggagcctttcttatactattag
-gtcgcgtcgagagccctattcgtaatgttaacgacactagactaatatacaatgagctaa
-gaataacacaagtcacaagataatttacaaatcatatatctacagtccacaaccatcact
-agcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaa
-ctggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaa
-ttgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagactatgcaactatt
-aacagcatgtgcgcattgaatatttggtgtcgattgataaatgccccaacgttccatcac
-gtctataagccgtgttactaatgtgtattagtgcatacctattcagaccatagttcaact
-gttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttcct
-taactgacctaaatgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagc
-caatgggctcccattgagctagtatggtgctttacctttgtaagtggtggctttccttgg
-tgtgctgactttaacacggcagagtgattatccgaagaatggataataagacgctggcaa
-tattggctaataaagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgta
-cctaaacctacatcgtatgtatttgctgacgttcattcttgatacataaagatccgatat
-cggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtg
-aaatacacgatggggatattgccggtgagtacaagttagaccacacattagaactgacct
-atattcgtcatcatagagatggagtatgaattgattctgcgaagtacactggctttacga
-gtatctagacgccgcggtatatctcccgtcaatactatgaaggtatatatatagaggctg
-aaaattcatgttcaatcctctttctaagagtgagtgggagccccttctgttgtcggagta
-aaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaa
-aagagttaccttagggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtg
-cgattaattcttttgatgacagatctcattattttatatagctccctctttgtatttaga
-gtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgctgaacattttat
-acgatgtgattactcaaaggataaggttcgaggcctctatactcatggaactatcttata
-attataatggatcgtggctcattccacctatccaaacttctttgtgatctgatgctacga
-gtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagctcgcatttcattc
-ctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaaggtgtagacaag
-cccttagtaaccggtggatgtcgcttcagttttatagcaaacattattcaatttcagtct
-tgactgaaattagtttgttagtgttagaggtccatatgtcacatgcatatggtctagatg
-ccattgtacagtaataccttagattagtattagcggcatgcgtacttggatttcacttgt
-aagaatgagcttaggacggtcgcctgtagggctgcaaataggaatacttacaatttttga
-tgacttgttagcatatcgctatcacccataaaaaacctgatacttgatgagcgggtgatt
-gagactatgtactgatataattcaatagctccaatagatgaaacagctatgcgcctattt
-atgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcgg
-tgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaag
-cttgagttcagttaaatttgcatctcatgccccacgaagaatgggtagagagtttgaagg
-tgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatg
-gttgtgttaaccacaaacccctgggtgaatctgattagccaacccagtgatctgatttca
-gttgtcaaatctcttttttataactaccttttgtttccataatttaaccggatctcataa
-tgaacaaacgggtagaataatggtagcacatagcgagcttgtctattcagaaatatggcc
-tactcagaatgtattctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatg
-atgatttcttatcggttccttgtactacaatactcttgcccaacaaatactaagcataac
-agcaaaattcgaatccccctccttttaataaatggtttttcaatatagccgattcgtatt
-cgttagtctttcaccaactattaacctggcatctaattaataaaatcaccaaaggactct
-ataatatgacagtcacttcggcctcttttaagacagttgattattgcaggtccgcaattg
-atggtgacatgcacaattagttagaatccgactatggagacaattaacaattgtagtgcc
-catttggtccagttgacttcaaccacgagttataaaggtattttaatttatagtcgatag
-taccaacaacaagcacaatcataattatgttagaaaacccagggggtaatgctctaaatc
-cagctttaaggccagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaac
-ttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagcaacgattatatc
-tggactagatcatgatgatcggaataaaacattgaaataagtccttatcaaggagcataa
-acattttatttaatttatacttcgtaaataaattcagaattttttttcaagacattaatc
-tgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagt
-aacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggctgccacttttag
-cttcttgacgatctttagcgtcatatttttagattagtcgaaaaacggaaaacaaactta
-acgaagctggttgcacggggtaccgagaaaccaaagagcaggacaactccttgatcggga
-agaactgaaatagacagctgtcattttcattggtcaacttatcaatataacgaccaccgt
-agtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttg
-actaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacgggttgccagcta
-cagatatactctaggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcat
-aatacttgtcacataaacaagatcgctgaattaaacattaaacagttagtgatacacaat
-cgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgta
-aatttagacaaacattattatttcttgacaatggaatcgataagcgttcctctaacttgg
-tatatatatctcgaccccgggattccagccattcttgtatgaagatttaaccatttaact
-atgcatagttgaatggtaaggaaaatgatattgactgcaacagattttggatgcaaaaat
-atttgtgaattattggttatatactggttgtatagcacaatcattaggtcctagaaggca
-tactcaacctcagcgagagagctagcatgcataattgtaccgcccatattaatattcctg
-aaatgatttcttacattacgcccaatttcagtcatcgaacacccccatcaatttacccga
-tagagaacgtgatcatacgcaataccctatgcgaacgtccactctatagcgtctgtatac
-aatgattattcgttccatttacaacgttaagtaatttaaacttacataaggacaaggaaa
-tccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaac
-taaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgtatccattgtggag
-aatatcataaattcaagatggggtgtcatgctattcggtcctaaacattcttaatggctg
-ttctattgttagtctgatttaaaatggaaccatagcacgaatagttagatagggctcata
-cccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttac
-ggtttgtgatcaaagaacactcacacgtcagattattacactgatacgaattatttcagt
-cgacagtaattgaatagaaacttattaacgccagcacctgacacggtaagtaaggcaggt
-ctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaa
-atgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacg
-actcacgtacaagatcacacatcacacgcgttagcgaaagcggaatggctaatacagccc
-tacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgagccaacctccccc
-gcattgcggttcattttaaggcctgggtaacatctatcgtttagataatcaaaggaatcc
-gactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttct
-ttaatcaataccatattgaaatcgtaatacgataattgttgctattgactacaggttatg
-aaaaaacttactttgcgggtacatgcatatttttgtaccacattattacgcgatatctct
-cagtgtactctaaattaaaccctcttcgaacattttagttcctattcgtaaacacgtgct
-acgcggcaatttgccggtcgtagaatggacaactccagttcaactgcatgtaactcatag
-ctcgcgttagtataaattgactagtagccatgggacaaagtaactagtcagcggaaaaga
-tccctttaaagatatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtgg
-tattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaatcgaaactactc
-tgatttgctgcacacgttaggtaatatcgcccattttcccgtataagctccgtacttata
-cgaactacacgaccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtc
-tattaaaattacagacatactccatatctcgctccttgaactttgaataatgcgctaact
-tgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacat
-gttgtcagatttatgattatctagttttagatcacgtttaccgataatcggctgtggtct
-gagcagtcctacactgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgac
-cgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagc
-aaaaggcttaaaccatttttacgatttttactatagcggtcatgaagtgcgaaactgctt
-gcaaattttctacacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaac
-atagtataccagggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccat
-atacctaacgccataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgt
-agcgctcatcagcacagactaactttttcagtttgagtcgccggagggacttcgagacaa
-gaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatt
-tctactattgtcagctgtacgactgtactaagtgtatagccccaaataaaagaagtatcg
-atgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaat
-cctggcttacccgattctccggaagtctgacctagagattgacgacggccgcgtattatt
-gagacctcttcaggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaa
-gccgactccgctacacgagtttctactaaaccaatgtagccttatgcttagatgaatacc
-gtcctaattagatattccggcataacagcagtaaattatctgttcaatggacgaacattg
-aattgttagtattctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataac
-ctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtg
-agggttaaacaccagcatattctatatgctagacgtcttccttaaaggatcgtagtatta
-taattaataataagaaatatggttgacgtctagtcagcgggcatacgctgctctatatac
-tggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgag
-ccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaata
-aaaaaaatgttaatagtacgtttacgacattttattttataataaagagaaactattaca
-cctattgatatgataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttc
-tacatggtatagacctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaa
-tctagtcatttactactgtctttcgagctattataccacttcactatgtggtgtttcttt
-gctatgtatggggctagtcaaacatgatgactatagctacaactcagagagcgggcgtgt
-taagagtatctcatgctagaactgcacgacgaacttgatacaaagtaacaacatttacga
-ttccacaaggtgactttgaagaaacatagtttaattctctgcttcgatcatttctataaa
-ccggtaccatcgcagcggatagatgcataacatttctactactccaggcatcttaaaaca
-cacgtagtacttcactagattaagacacgataagtgtataacttggcagtgggaagcaag
-gagattggcgaactcctggcatctgttacgttttgttcaggctcggttgttgataatgtc
-cgactcctgccatattgaagactcgctcgagggagatcgggattcgttgattataagtac
-acgtgttccgtaatactatgaggcagtgattcaaaatggcacttctgacttacatgacta
-ggtattattaccacggaagcgttaaaggcacactcttatggacttaagattgcaagtgcc
-ttcttctagcctgaattcgcgggttcaacacaaactctctttagacatccgttgcctaaa
-ggctgagacgtaggggcaaccctttaactatgtactaaaaaactagttggtaatttaaca
-acgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaa
-taggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggct
-ctaagagaataacctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaa
-aaaagctaagcatacatttaggtctcctgcattgcattcaattgaatcgtttgtattatg
-agctgtacagtagctatatcagctatagttatcccagaggaacaggtaaactagctctga
-gcgtgaaatccggatattagaacccctagatgggattgattctagctaatacaggcttat
-ctggttttacagttatctagatgattggtaaggtgaaacgcttggtgccttccaccactt
-aaacaaaagtattgcccgggaagctattttctaggtattataaagtcgagcattaatatc
-aatttgacagtaaaggtctttcaccagcttcatatgccatagggcccatactcgatttaa
-attgaacggtttaacgagtattggaactctcacttataactgagtagctatacgaaaaat
-ctggtccatttccagaaatttattatcgatttgctgcttagtacccaggaagtgataacc
-cttgaaggcacaacactgtaataagttttcctgtcacatctgtaatattcggtcactacg
-cattcacgactaaagataattactatactaattaaaagttcaatgttagggccgaatcat
-agtagaaattctcgtctagcctaatcggacttacctatgggctgtgaggatttatcagta
-tgtggacaaaaatgctagagataggtatagttaaagtcaccatggtacatctatgtgagg
-aagtttgtagttcgcttctttagtccgggcgtttgggatgacaactactatacgtagagc
-cgtactcaggattagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgt
-tgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaatacaggccttcac
-cgaaccctaatgataatctgtcttaataacattaaatgattgtctccgctacgagctctt
-agggcctcattttaaatgactaatgtccaaagaagagactttcccaatttcaatctgtca
-cgtatagacggcaccttagtgagtcatatcattaagatagaagattatcaggagggaagt
-ttctattatcaaccgttacgcaaccataaacttttaaatctcataatggcattgagatca
-agagctttcatgatggtaaagttcgtatgtgatgctggggagctagatatcggtatacca
-cttcggttgtggtaagcccgagtgggccgttagtaatattaatagacgattatccgacaa
-tgcattcgctgaaataatcttacttaggagaaattaatgctatgagccaaaactatttat
-gtctgtcacattattgactaaagtatctatcgacaaaactgatgtccataagttgtagca
-gatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatc
-caatttgagtaaattgcctattatacagataggcttgtttagtcagataaggttccgctt
-gaggtgctctaacttagcgagagttagaaagcctagtgagaggcattttggtgccaaact
-ccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaagttggtgaacagc
-cttttgattagttgtttgtcttgtggctatgtgctactatataagttagaacgcaaacta
-atctaatcagcaaagtaaaataggaccttgaacgagacggggtacgccgttgaggctcga
-gatagtagataaactagaggaatgtagataaaacattagctagggggtttagttactgga
-ttacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattg
-tcagtggacttaacaagttcgtgcataatgaaatcctatacggactttgcatatctctac
-cgactcatctggtcgtctatgcgggtaattgtattgctccaagtggatgactattttggc
-gtcccagcacatagtaaatgtaaatccttataatagcataagcaattattagactgcgtg
-aagtcttagtagttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtcc
-ccaaatcaccattgaggtcattgaatgtacggagcactattatcaatgcggtatgcgatt
-ttctgagcgattattgttaaagacttagcgttgagccccggaacacttgattacagattc
-tttaaggagttatccaaatatcattttaaataatagtagtatcgtgctttggacaataaa
-aaaagacccgttctcttatgttgttttgcgacgtacttctctgatatatacttcaactat
-gaagattctattcatcgataacccaggtatatttatatgcccgttcactgcgcagggcaa
-attatctacggacaataatgacgtagttggacccggtaagaactaacgcttaatatgatt
-aaggatgtatgccagtattatcttattatgtcagagtagaagtttctctgagattttccg
-tcgttgtggtacaccggatttggctctctttttagaactgagaactcggagtgtgtagtc
-ttgtttccttcaatttatcaatatgcttttataccgccctcatcaactataacaggacga
-caagttccgtcttgctccatcatatactaccgatacaccaatcgtatcaagtttagtata
-cttgctttctctcttctacagcttactcgcttgtccgagaagcggttggtgctcataaag
-ttagtagtaaatgtacaactagtagccagtccttacctgtttttacgactactacggaca
-ccatgagatacagaagttagtgctacaattataccattacatgctcaatatcgttgtcgg
-ccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatg
-cacaaaaacacactccccttgttgactaacatcttttacaagaggctaaatcattgtcca
-ggatcgaataccttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtag
-tatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaatatattcatttga
-ccgtcattagccttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtgg
-catacgctgcgatttcatacagctgccaacaccttttttaccaggctagagtcagaaaag
-ttggagccatgttaaatagttaccatcataaaccactgttgtctactagtctgatcagct
-ttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactgttgcgttactta
-ggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaa
-agtacacaagcctaggaataggaaaagtaaagctcttttattctgatagtgactaactca
-ggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgac
-cagttatagacagggtaattcaatatttaatgtctcccttaacatttcaccagcatggat
-tgaagatagtataaagttttacatggcagtcattgtgtcacggttctatacaaattctga
-tagttagacggtatttgaaatgtgcttctagcatggtatcttacacaactgaatgaacga
-ctggagccgttcgtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaat
-atagtataatataaattgtgatatgaataacacaagtaactacagtttggacaattaatt
-gttctaaactaaaaatcattcacttcagatggcatagagttatggctactacacatataa
-agcggtatgtgaaacacccgttttagccggaaaccctctactgctcgggacaatgaatga
-tttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaatagacactttag
-tttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatttggtctacattg
-agaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgtctattactgatt
-aactagtaagacattagtgcatctggtccactgaagcacccgcttggcgttaggcaatct
-ctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagt
-cgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggttcgtcctttacc
-ttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagactctttatcccaa
-gaatggataatatgtacatggaaagtgtccataattaagtcccttcactgtaaagaatga
-ctgccacgtgatccatgaggtctacagaaaccgacttacttgctttttgatcaacttaat
-tatggattcataaagttcagatatcggtacaattggtgtacaatatgaaattaatgagga
-aacatggaaatctgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgt
-tacaccactcattagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgttt
-atgccttcgaaactggatgtacgacgatcgagacgaagaggtatatataacctaaatact
-aggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggcgaacactgaggg
-ggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagt
-agaccggatctttgcggagaacaattcacggaacgtagcgttgggaaatatcctttctac
-cacacatcggattttcgccctctcccattatttattgtgttctcacatagaattattgtt
-tagacatccctcgttgtatggagagttgcccgagcgtaaaggcataatccatataccgcc
-gggtgagtgacctgaaattgtttttagttgggatttcgctatggattagcttacacgaag
-agattctaatggtactataggataattataatgctgcgtggcgcagtacaccgttacaaa
-cgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggt
-cgtttcatagagcgcattgaattactcaaaaattatatatgttgattatttgattagact
-gcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgaga
-gcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccata
-ggtcactggcatatgcgattcatgacatgctaaactaagaaagtagattactattaccgg
-catgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgat
-aataccaatacttacatttggtcagcaattctgacattatacctagcacccataaattta
-ctcagacttgaggacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatata
-gatgaataagcgatgcgactagttagggcatagtatagatctgtgtatacagttcagctg
-aacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaaccatatcgttcaca
-catgatatgaacccagggggaaacattgagttcagttaaattggcagcgaatcccccaag
-aagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcctccgtataagtt
-gagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatg
-agaatacacagtgtgagcatttcacttgtaaaatatctttggtagaacttactttgcttt
-aaatatgttaaaccgatctaataatctacaaaacggtagattttgcctagcacattgcgt
-ccttctctattcagatagaggcaatactcagaaggttttatccaaagcactgtgttgact
-aacctaagttttagtctaataatcatgattgattataggtgccgtggactacatgactcg
-tccacaaataatacttagcagatcagcaattggccaagcacccgacttttatttaatggt
-tgtgcaatagtccagattcgtattcgggactctttcaaataatagtttcctggcatctaa
-gtaagaaaagctcataaggaagcgatattatgacacgctcttccgccgctgttttgaaac
-ttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatc
-gactaaagttaaaatgctagtccacagttggtcaagttgaattcatccacgagttatata
-gctattttaatttatagtcgagtgtacaaaaaacatccacaataagatttatcttagaat
-aacaacccccgtatcatcgaaatcctccgttatggcctgactcctcgagcttatagcatt
-tgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtt
-tcattatgatgatacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaa
-ttatgtcattatcatgctccattaacaggttatttaattgatactgacgaaattttttca
-caatgggttttctagaatttaatatcagtaattgaagccttcataggggtcctactagta
-tcctacacgacgcaggtccgcagtatcctggagggacgtgttactgattaaaagggtcaa
-aggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatgagttttacatta
-gtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaagagaatacatac
-accaccacatagaattgttagcgatgatatcaaatagactcctggaagtgtcagggggaa
-actgttcaatatttcgtccacaggactgaccaggcatggaaaagactgacgttggaaact
-ataccatctcacgcccgacgcttcactaattgatgatccaaaaaatatagcccggattcc
-tgattagcaaagggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgt
-aatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatac
-aggttaatgttagtgatacacaatactcgtgggccatgggttctcaaataaaatgtaata
-ttgcgtcgatcactcacccacgtatttggtctaattatgttttatttagtgacaatccaa
-tagataaccggtcctattaagggctatatttttagcgaccacgcgtttaaacaaaggatt
-gtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaaatgagattctat
-cctaaagtttgggcttgatataagatttcggatgtatgggttttataatcgttggagagc
-tcaatcatgagctaatacatggatttcgctacctcaccgagagaccttgcatgaagaatt
-ctaaccaaaagtttaataggccggattggattgagttaattaagaccttgttcagtcata
-gtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaa
-cgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaatagttaactaatt
-taaaattaattaacgacatggaaatcacagaacctaatgctttgtaggagttatttatgc
-tgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagtt
-cagaaagtggtatccagggtggtcaatttaataaattcaacatcgggtctcaggatattc
-ggtcatataatttattaagggctcttcgagtcttactctgagtgaaattggaaacagtca
-tccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtg
-tcccgtacacaaggaaacttgttaccttggggatataagaaaactcacacgtctcattat
-taaactgagtacaatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagct
-aatgaaaagggatggaacgcacctcggatctgttgcactggattaaaatccgattatttt
-taaaaatattcagtgctagagcatatcaggtctacttttttatctggtatgtaaagccca
-cggagcgatagtgagatccttacgactcaacgaaaagttataacataactcccgttagcc
-aaagcccaatcccgattactgccctaccctaacgtctgccatctaaatatcgaacttgtt
-atgatcaatgtgactacctcccaccctttccccttcatttgttccactggggataagcta
-gcgttttcagaatcaatgcaataagaatagccaattgtctcacttcatcagagctcttgg
-caattccaggcgctacgtggttctggaatatattcatttttcaaatagtaatacgtttag
-tgttgctattgtctacacgtttggatattacgttatgtgagcggacatcaatagttgtct
-aactctttagtaagccagagatagcactcttagcgaatggataccatcttccataagttt
-agttaatagtccgaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcc
-tcttcaaagcaatcttactaatagatagagtttgttttaagggactactagaaatgggac
-aatcttaatagtatgacctaaactgacatttaaagatatatccaggtggcaagcataaag
-atcattgcgccacctccaccgtgggattacttatcagtcgatatcctatatgctaagttt
-gcgacggcagaatacaaactaagctgagttgatgctaaccttacctatgataccccattg
-gaccggttaacagccctacttattccaaataaaagaacttttatgctgtagaagctatta
-tagtgatgcctggtaacttcagtatattaaaatgacacacatacgccatatagagctcct
-ggaactttgaataatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggtt
-gcctaaagcccggtaaccagacatgtgctatcattgatcattatcgaggttttcataacc
-ttgacccattatcggctgtgcgcggacaagtacttaaatcactagtttcttcacctgctt
-atcggtaagaaataaggttggcaaagaatcgcataagacggacgtagagccgcagcgttg
-tgcgagtccaggtgcatgcgcagcaataggattttaaattttgttccatttttaatttag
-ccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggcctatgctactgg
-aacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgtatttttgcggcta
-gaatagtcagtcgcttggagccatataccttaccacttaaacgacgtgctcctgtagttg
-aaatataaacagaacacaaagactaccgatcatatcaactgaagatctttgtaactttga
-ggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgat
-tgggaccctaaatcttgacgaattgctaagaggctcagagctaccactgtaatttctcta
-gagcccataataaatgaacgatacatccgtaggtagcacctaagggattataatggaagc
-caaatgcagttaataatattatatactggcgtacacgattcgacggatctctcacatagt
-gattcacgacccccccctttgattgacacagcgtcagcattttgcaagaacgatcttctg
-catagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtataatttaccatgc
-ttccctgatgctgagtgcaatacactaagaatgagtttttaccccatatcaccagtattt
-gttctgttattgcgaagaaatggctatgctgagttggcgactaaagtcacccatcctttt
-tattaggtaaccccctcccttaaactaactgatttgctggagctgccctgcatacatata
-ctttatcatttatggacgtccgtgacgcttattatccaccatagtcgatatgctacacgg
-attcattaatggatcgtaggagtttaagttatatttactaagatcggtctcggctactat
-cccgccttacccggcgctatttacggccatttttaatatattgacggtaattattcctat
-ggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaa
-atattgagtccctaccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagt
-ggttattaaagactatctattacaccttttgttttctgtcgtagtatattaaagtctaga
-agccttacaggaaaatcagggttatacagccgatactccgcagcatgaatcatcgaggag
-gtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatac
-aaagtaaatatctcggctttatgtgattgggaggggcctactcaaacatgatgacttgac
-ctaataatcactgtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatg
-gttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaatt
-agctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttc
-tacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactg
-tataaagtggaagtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttct
-taaccataggggcttcttaatggcccactacgcacattttgttcaagcccgagagggaca
-tccccattacgggagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaa
-ggccactgctcaagttattgacgtgggagtattacatcggaagcctgaatcccacactat
-gatggtctgtacaggcctagggactgcgtctagacggtattaccggcttctaatcatacg
-atcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatttatctatgtaag
-tataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcac
-ataagccgctttagatttcacaaataccaatgcggttaaaaacatccttgagtcgtacat
-acaccatactcgcgttaaacggatataacagaagataataaatccggatgtggagtcggt
-gtaactatagaaagccaagtgaaataatgcttaccagtcatttagctatacggctttcat
-ttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccgatacttagaact
-cacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggat
-tcattatacataagacacgatgatctgctttttcaggttgcgagatgttgcctatcgtca
-atcgagtcctgccttacaccacttaaacaaaagtattgacagggaacctattttcgaggt
-attatatagtccagcttgaatatcaatttgacagttaacctagtgaaaatcagtaagagg
-aaatacgccacattctccagtgaaattctacgggttatcgtctagtccaactatcaatta
-taactcacgagatataagtaaattctcgtacttggcctgatttttattatactttggatc
-cttagtaaacaggaagggagaaaccttcaacgaaaaacactggattttgttttactctca
-aagctcttatatgacggaaataccctgtcaagtcttaactttattactagactaatgaaa
-tgggcttggggtggccagaatcatagtacaatttagcggatacactattcggactttcct
-atcggctgtctggttggataagtatggggactaataggctagacatacctatacttaaac
-tatacaggcgtcatctatctctgcaactttggagttccctgatgttctcccgccctttgg
-gttcacatcttctataccgacacccctaataacgattagtttgtgggttagagtaaatta
-atacggttaatattaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctag
-gcagagtatatgtcacgaagtataactaccctaatgataagctgtaggaataaaattaat
-gctgtctctaagcgaagagatatttccgactctgttttaatgacgaatctcattacttct
-gacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacgcatataatgaac
-ttagaagattataacgacggaactttatatgataatccgttacgattaaagaatctgtta
-aatatcataatggcattcagttctagaccgtgcatcatggtaaacttactttctctgcat
-ggcgacatacatttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaa
-tattaagagaagatgatcagaaaatccattcgctcaatttttctgacgtacgtctaattt
-atcctaggagacaaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaa
-tactcaggtcctgaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcg
-tgacataaatgaatgatacttttccaagttcagttaagtgaatatgtttaacatacccgg
-cttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctcttacatacactag
-tgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtatt
-gacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgcta
-atatataagttagatcgcattagatgctaatctgaatacttatagacgaccttcaacgag
-aacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagggacatataaaat
-ttgagtgcggctttagttaagggtttaattacctactcaaacatcacgctcgcgcccttc
-gtacgtaatcgaccatctagaggctaaggggactgtactaggtagtgattaatgatatcc
-tagacgcacgtgccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtc
-ctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaatacttataatac
-aataaccaaggatgagaatgactcatcgcgttggagttatattgcttgaagttctatgga
-atgaaagcacgttatctgccgtcccaatatctccagtgagctaattcattggacggtcca
-ctttgatcaatccccgaggagatgttcggacactttagtctgtaacacttagcgttgaga
-ccacgaacaattgattactcagtcttgaaggtgttttccaaagttcattttaaataagac
-tacgataggcctttcctattgatataaactacccggctctgttgttcgtgtgagtcgtac
-ttctctgtgtttttctgattatagcaagattcgattcttagtgtaaacagcgatttttat
-ttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagttgtgccacaagg
-taagatctttccagttattgcaggtaggatgtatcccacgttgatagtatgaggtctgac
-gtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgaga
-acgcagaactcccactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaag
-ccctcatcatctagatctcgacctcatctgccctcttgctccatcattttctacacagac
-tactttcctatctacgttagtataattgctttctatcttagtatcatttagagcttctcc
-gtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgtagcaacgcattta
-atcggttttcgactacttcgcacaaaatcagataaagaagtttgtcattctattagacat
-tgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaagactgtgattaa
-ctaaaatagacaagccactatatcaactaataaaaacgcccctggtggtcgaacatagtt
-gactacaggataattaattggactggagccattacattctctacaatcgtatcacttccc
-aagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacat
-tggtagttcaatagtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggata
-gtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttg
-gttaacaggatagtctatgtaaacttcgagacatgtttaagagttaccagcttaatccac
-ggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgtta
-tcctatcaacggttgccgtactgagcagccttattgtggaagagtaatatataaatgtag
-tcttgtctttacgaagcagacgtaagtaataatgacttggaataccaaaactaaacatag
-tggattatcatactcaagaactctccagataaataacagtttttacgatacgtcaccaat
-gagcttaaagattaggatcctcaaaactgatacaaacgctaattcatttgttattggatc
-cagtatcagttaaactgaatggagtgaagattgtagaatgttgttctggcctcgcatggg
-gtctaggtgatatacaatttctcatacttacacggtagtggaaatctgattctagcttcg
-tagctgactatactcaaggaaccactgctcaaggtaggagactagttccgaccctacagt
-caaagtggccgaagcttaaactatagactagttgttaaatgctgatttcaagatatcatc
-tatatacagtttggacaattatgtgtgcgaaactaaaattcatgctattcagatggattt
-cacttatgccttagaaacagatattgcccgagctcaatcaacagttttagccggaaacaa
-tcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtca
-cgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgca
-gcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaac
-tctgaagtagctcgagtactcattaaagtgtaacacattagtgaatatcggccaatgaac
-caaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaa
-agcatccctttacgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaa
-attctcatacgtgcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtg
-ttataccaactcgctttttaactactatgctgtagttctacaggcatagtggccagtatt
-ttctaacttctctggatagatgctctcactcctcatccatcacggcttcagtttacgtct
-tacttgcttgttcagcaacggatggaggcattaagtatcttcactgttccctaaaattgc
-tgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactcattgaatactgc
-cccagttgcaacctcacttaatctgacaaaaataatgactactctaagtgttgcggaagc
-agtctcttccacgagcttgtctgtatcacttcgtataggcatgtaactcgatagacacga
-acaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcgg
-atataagctggagatcactcacgcccacacaaggcgctgctacctctttattccaatgtg
-taagaatttgctaacttcatttctagaccgcagctttgcggtcataatttcacggtacgg
-acccttgggttagagacttgataacacacttcgcagtttccaccgcgcacatgttttagt
-ggcttctaacatagaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccg
-ttaagccataatcaattgaaagccccgtgagtcacatctaattggttgtactgcgcattt
-agctatcctttagctgactcgaagagattcgattcctaatataggttaattagatggctg
-ccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaatta
-cttatgagtagttccaagttcgctacgttatgagagagattggaattaagcaaatatgtt
-ttatggtgattttgggatgagaaggactgctaagtacggctactaaacaaatttctaaaa
-ccgccatctaccttatcttggagacatttaagttgtatatgtcactagtctagcttttgt
-ctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatct
-aagaaagtagtggactattacaccaagcacgaatgccagggaactgctttcttgctcagg
-acctcgcgacaaggtaccccgcataagtcctagaattacatttggtcagcaatgctgaca
-tttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttgctctagatctta
-tctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtgagggcttagtat
-agttctctgtatacaggtcacatcaaactccccctgtcctagtacagctctgagctttaa
-ttaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcg
-tatagggcaagagaagcaacaaacaactagcccgactcacgttcatccgccgtatccttg
-ttcagttcttactccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatca
-aaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttatcggctattagat
-agtggggtgaaagtaattggctggaattatgttaaaacgtgatattaagctaaaatacgc
-tacttgttgccgacctaattcagtcattcgatattcagttagagccaagaataacaagct
-tgtataaattgaacggggtgcactaaacgatgtgttactctaatattcagcttggagtat
-acctgaaggcgaattcatgtatcggccaataataagacgttgaagatcacaatttggact
-agcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagtacggtctctgga
-aaattataggttcagggaatataaggaagtaaagataattaccaagagatttttggtatc
-gctatgacccagaggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgca
-tatttgacggacttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaac
-ttcaattattactactctttttttcctagggtattgtagaggccagtggacaaaataaat
-caaatttaagatgtttcggacattaacatcccccgtagcatagaaatcatcagttatcca
-atctctcatcgagcttttacaatttctgctggcgctatggacagcatatgccgcgagacc
-tccgcaagactcacttgatcactgtaagtatcttcattagaggttagagcctatagttaa
-gctgctgacctagtaaaattggtattttctaattttattgctcaagttaaaggttagtga
-agggataatgacgttatttttgaacaatgggttgtattcaattttatatcacgaatggaa
-cccttcattcccggcataatactagacgacacgaacaagctccgatctatcagccaggca
-cgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaactt
-agggtcacgatgagtttttcaggactacttattacctattaataagttaacatgagcctt
-cataccccgtaagacaatacatactccaccaattagaattctgagccatcttatcttttt
-gtatcatcgaagggtatggccgaataggttaattagttactcctaacgtctctacaggca
-tgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagca
-tcaaaaatatagtccacggtttccggattaccaaacgcggcaaagagaaacattgtatcg
-acggagataacttaatacagaaggaaggggcatcttcgaatacggatgaataattctatc
-tgtttattctgacatcttgttttcaggttaatcttacgcattcaaatgacgcctgcccca
-tgcgtgcgcaattattttctaatattgacgagagcaatctcactccttttgggtctattt
-atgttttattgaggcacaagcctatacagaacaggtactattaaggccgtgagtgtgaga
-ctcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggca
-atccttaccaaaatcagatgctatccttaactttgggctgcatttaagatggcggttgga
-ggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagat
-cacacactcattccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagt
-taagtaacaacttgggatcgcatacttataaaaattatatgttaaactttcacaaacgct
-gaagtccaaagtaactagcccaaacgcctcgagagtcactaggtattaatggtgtttgag
-ttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaata
-aggcttgcttgcacggaggtatgatgtttactgactctacaaccctaattttccagtacg
-tacattcattccaataggttagttctcaaagtgctatacaggctcctcaattgatgatat
-gcttcagccgctctatggatattagctcattttatttaggaagcccgcttagaggcttac
-tatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttaca
-tagaatttgaattaaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatat
-tacatatagatataggatcattttttaaagctgtactaggtttgatcgacaatcttatgc
-tatactatatgatgtaaccctcataatcaataccgatcgtacgatcctagcataggtggc
-aagcgattttatgccgattattgtgttaaatagtctgtgagtgtgattatcagggctacg
-ttggtagaggggttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaa
-ctgatataataaatccccttacccaaacaccaatcccgttgaatcaactaccataacgtc
-tcccatataaattgcctacttgtttgcataaatctgaatacataacaccattgcaccttc
-ttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaacaatagcatttg
-ctagcaattattaacagctcttcgaattgcctccacataacgcgggagggtatattttaa
-tttggcaaatactaagtactgttggcgtcatatgctattaacggttggatattaagttat
-gtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagagcactcttagagt
-ttggatacaataggccatatgttgacttaagaggacgtaactacgccgtacaccattgtt
-caaccgacttcttggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgt
-gttagggtatactacaaatccgaaaatcttaagaggatcacctaaactgaaatttataca
-tatttcaacgtggatagatttaacataattcagccacctccaacctgggagtaattttca
-gtagatttactagatgattagtggcccaacgcacttgactatataagatctggggatcct
-aacctgacctatgagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagt
-aagttgttgctgttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaa
-acaaatacgcaatttagacagaatggtacggtcatgaatgacagtaattcgaagtgctag
-accaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatgg
-tgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagta
-tatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaaactttcgattta
-gtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagttta
-aatttggttacatggttaattttgaccgaagcatcgcactttatgattgataattggatt
-caatatgtcgccctatgcgaatgcaacatgatccacaatttggctataagacgtttaatc
-cgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaa
-ttataagtactccgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatc
-atctgaagatatttggaactttctcgacaaccaccctcgtactcaatacttacactaatc
-gacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcga
-tgagcgtacacgcttatttctctagtcacaattagttatctacgagacatcacgagggag
-caaataagcgatgttatggctacacataggcacgtatgaatatgatataagccagttaaa
-cagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaa
-gctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggatcaactagaagag
-aaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtct
-gtgtaaccaatataacatctatttgttatctgattgcctacttatggctttgcggtcgtg
-gcgactaatgtctccaatccttttgaggtcggtaccaactccctttaaattacgctgtgc
-aggctcatgcactgcatacatatacggtagcaggtagggacctcacgcacccttattata
-atcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattt
-tctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaagccaattttgaa
-tatagtcaacgtaatttttactatgggttccaccgaaacgccttgcacaactaagaatcc
-cataaaatatcgatatcaaataaaagattgtgtcaataccttcatatatattttttcggt
-tgactaacgtgaactaaggttaggggttttgtatgtctatataggaaacagtttcttttc
-tgtcctactttagtaaagtcttcaagccttactccaaaatcacggtgattaagccgttac
-tcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgt
-attagctagggagacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcg
-catactcaatcttcagctcgtgtcattataatatctctcccccacgcttttcactagata
-tgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctg
-taggggtacttaatgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagcc
-ctcacctgacttcatgtaaatggcttagaagactccatgatttaataaatactacgaagg
-aaagactggatctaaagataactctagtaaggccaactcccttcaatgctgttgccagtt
-ataatccaagagctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaa
-gttggttctagccagacagccacataccctgtacgggtgtattactaaaactggtccggt
-attagttcaccaagggaggaattaggcaaaggatctaggtatgcaagtcggagtattaca
-tccctaccctgaatccatcaataggttcctctgtactggccttcgcaatgagtattcaag
-gttgtacagccgtataataataagatagtgactatgaacgggaagtaacccgctcacctt
-ccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaatactcgaaaata
-aacaactggcaaattacaccgcacttaagccgcttttgatttatatttttccaatgcgct
-tttaaaaataattcagtcctacatactaattaagacccttaaacggagatatcacaagtt
-aagttttaaccatctcgactaggtggaactatagatacccaactcaatttatcattacct
-gtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttcacagcgaaactt
-cagtgtgaacagattctgagaaatcacctaaacctattagtcagagcacccggttagaac
-cagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgagatccgttgtaac
-gttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactag
-gcaaacccaacataggttagtcctatgtgatacgccacatggtatatcattttgtaacgt
-tacctagggataatcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggtt
-atagtctagtccaaagataaaggataaagcacgtcagagaactatattagccgaatggga
-atcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaa
-aatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtacctgtatactagt
-tactgtattacgtgtctaatgatttcggattggggtccccagaatcagacgtcattgtag
-acgattcaagtttaccaatttaatttcccagctctccttggagaactatcgccaataatt
-gcagtcactttccttttctgaaacgataaagccgtcagagttctctgcaacgttggactt
-acctgaggttctaacccactttcggttctaatagtagttaacgacacaacgaataacctt
-tactgtggggctttcacgatattttttcgcttattattaatggttacgtcataagctggt
-gtccaaattaaggttaccggcttcgcagagtagttgtatccaagtataacttccctaatc
-ataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtg
-gtatggacgttgctaattacttctgaagggaaattggtcattatggatacgtgtctacca
-tcaggtcggacgcagatatggttctgtcttcagttgatccaccgttctttataggataat
-aactgacgattaaagattatggtaaatagattaagccaattctcttcttgtcagtgaagc
-atccttaactgacttgctctgcagcccctcatacatttagctattcaaagtaccggctcg
-tttcaaactctcccacctttggaagaggttgtcaacttgataagtatatcatttacagca
-ttttttcggacgtacctctaatgtttcattgcagaaaattagttttttctatcgcacatt
-ttgcaagtaacgttagagacacaattatctgcgaatgaactgctagatctgacgaccggg
-agcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggta
-agtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagta
-atgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattc
-tcgagcccactcacgatatgtagggacgacaacttgtgcggcttatgaattgtctggact
-gcgggcgagggtccatatctccgaagttagaagggacatacctttagatgataagatcaa
-ttcttattgacgaaattcatccacaacggggaacaacttcaccctagacttacgtctgaa
-aagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctac
-gcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgt
-actacggaggcatgaatcatatactagaaccaagtgcctgtgatattaacaagatgatcc
-gacgcgagcaccgtaattctaggcataaaactccagcaatttgggggccgaaaacaaatg
-acgttagctaattaattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgac
-gtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctg
-tctcctatttcatgcgtacctcctagttgataattccccgagcagtggttaggacacttt
-tgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgt
-gaattagttaatttttatgaagtcgtcgagacgcagttcctattgatttattctaaacgg
-agatgtgcttcgtgggactcggaagtagatctgtgtttatgattattgctactttagatg
-ctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacct
-atagtttcaagttctgccacaaggtatcatatttacagttagtgctggttgcttctttca
-aacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttc
-aaccctgttccagagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgat
-agtttgcaagagccggtgttaaacacatattattattgttatccaactaatcggacctat
-gcataaagcattgtctaaacagaataattgcctatatacggtagttttagtgatttatat
-cttagtatcagttagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaag
-cgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctataaatcacagaaa
-gatctgtctcagtatagttgaaatggtattcagctagtgacgtgtaccaattatcatagt
-tcactcaagcaagacgctcattaacgaatatagacaagacactatatcatataataaaaa
-agaacatggtgctcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaa
-ttcgctactagacgatcaattccctacttgtcaaagttgaactggtacgttcttggaatt
-aaatatgattgcgctggaccaaattgcgacttcttgagtttcagggcaaacgattgagcc
-ggaggatgtccgtctcttacctttcttgcttatgataaacgacggtccctgtacatcact
-gggaattctcagcaaaaataattgggtaaatcgagactcgatgtattcggccacaaaggt
-gttagacgttaaagattattcaacggggcgataataggatcataaccggtatgcaagcgc
-attgaaagagccatgagatccttatccgataaacgctgcacggtatgtgcagccttattg
-tcgatcacgaatttataaatgtagtctgggctgtaagttgaagacctaagttataatgaa
-gtgcaataccaaatcgattcatagtggattatcagactcaagatatctcctgataaatta
-cagttgttaagatacggataaaatgagatttaagattagcagcctctaatctgtttcaat
-cccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttg
-attcttgttctgccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagct
-tgtgctaatctgagtatagattcgtagaggaatattatcaagcttccacgcctcaacgta
-cgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactatagtctagttgtt
-aaatgctcagttcttgttatattcgatatactcttggctaatttatgtctgagtatataa
-aattaatgatattaacttgcatttcacggatcccttagaaaaagattttgaccgagcgca
-ttataaacggttacaccgaatcaatagaagcatacccaatagctttctttgaatttattg
-cctgcgcaacttggctgactctctagatccgaataattctatatggtcgtgacgaaacta
-gttcattactgtttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaat
-tactcaatgatacgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaa
-atgtctgattatccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcga
-cgcgaggggaaccttatctaactatcattccatttaccgggtgactctcgatgcaggatc
-cgattgggataaattgcccagaaatggctcattcctgactaagggtaaggccgttctcag
-caagggaaccccgcgaatctaggcttataccatctagattgttaactacttgcctgtagt
-tctacagccatactggacagttgtttctaaatgatcgggattcatgctagcactcctctg
-aatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatggaggctgtatgt
-atcttaactgttacctaatatggctggtaattatcaaagtaaggaccttaatgccatagc
-gctagcaatcgctttgtatactgaccatgtgccaacctctcttaatctgtaaaatataat
-gtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctat
-agccagcgtactagtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctg
-tctctctacagcttattgatgaggattgaacatggacatatagctccccctcaaaagcag
-atgctacctctttattccattctcgaacatttgccgaacttaatttcgacaaacctgagg
-tcacgtcttaatttatcggtaacgtcacgtccctttgagactggataaatatattaccag
-gggccaacgagcaattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaaga
-cggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaacccccctctctcaca
-tcttatgcggtgtactgccctggtacatttcctgtacaggactccaacagtgtagattcc
-taagatagctgttggagttgcctcacgccagatcgaaaaactgaataaactagtgagctg
-agctgcagaaataccgcttaattacttatgactagttcaaagggacctacgtgatgtcag
-acattgcaaggaagaaattaggtttgtgcgtcattttggctggactagcactccttactt
-cccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtct
-attgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatg
-agcacagtatgcaattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggc
-ctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtag
-taaatgtccgaacctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcac
-ctaacccgattcctctacttagtagctttctttgattctcagaattgactgcaatatcac
-tgcacaattctgtgccattactagacttctctgtattaacgtctcatcttactaacactc
-gcctaggacacatctgagagtgaagtatttcaatacatttactgaaatcttcagttctaa
-aatccccgaataaggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccac
-tcaccttcatacgcaggagcctggggaacttagtaataactatttcggcagacaaagctt
-ataacaagttgccggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacg
-ctcacctggtataggctattagatagtgccgtcttagtaaggggcgggaattatcggata
-aactgatattttgataaaataaccgacttgttcacgacataagtcactaaggagatttta
-tctttctccaaagtatatcttccttggataatttcaaagcgctgcaatttaagttctgtt
-actagtttatgctgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataag
-aagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgta
-aactggacgagtaccctagatggaaaattatacgttaagccaagatttcgatgtaatgat
-aattacctacacatttttgctatccataggaacaagagctgttctataggctcgtggcat
-acgaacatttgctgccgctatgaatattggaagctcttcaactacagactctattcttaa
-ttgccgtcgaaaatgggccgaatcggctattattaatactcggtttttccgaggggattg
-ttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatttaaatacaacct
-tgcagacaatgaataagggatccaatctctcatactccttttacaattgctcatgcccct
-atgcaaaccttatgccgccacacctccgcaactctctcttctgaactgtaagtagcttca
-ttactggtttgagactatactgaagctgatgacattctaaaatggctattttcgaatgtg
-attcataatgtttatcgtttgggatggcagaatcacgttatttttgatatagcccgggta
-ttctattgtatagaacgtatgctacaagtcattccccgaagaagactagaagtaaacaac
-atgcgaccatcgttaagccacgcaaggctgtagctttatttcccgataacctatcttcca
-taaatagcggacagcaggatactgacgctcaacatcagtggttatggtctaatttttaac
-ttttaataaggtaacttcagcaggcatacacagtaactctttaatttataatcaaattag
-aagtctgacacttcttatatttttctatcatccaacgcgatcgcccattagcttattgtg
-ttactaataacgtatctaaaccaatccttttcaagctactgcctatattgtcaatatata
-caaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatac
-ccggaaatcacaaactttgtagacaacgagtgaaatttatacactacgaagggccagcgt
-acaagacccatgaattaggcgatatgtttattctgacatattggtttatccttaatctgt
-cgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaagattcacgactgaa
-atataaatacgtttggctatatttatgttggagggaggcaatagcctttactgttaaccg
-aagatttagccagtgagtgtgacactaaaacactggaataaatgcaggcgttcttctggg
-taaaaggtttagtcaatctcgcctataagttcatatagctctggatataattatctggcc
-catgcatttatcatggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtcc
-gaagtattccatgtacattaagatcactctctcattcatgcatcttggcttaacaaatct
-ggttgtccaagctttccaggcacgtatggtacaaattcggatcgaatacttataaaaatg
-atatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtct
-caagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagggattagttatgt
-tacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaag
-agactaacattattttcaacgacgtacatgctttacaatagggtacttatcaaacgccga
-gaaacgcgcctatagtgatgttatgattatgacccgatatccattggaccgaattttatg
-taggttcccagcgtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtc
-tctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaata
-cctttaggggtaacggccgctgatttcatatagatatacgataagttggtatagctctac
-taggtggcatccacaatcgttgcatttactatagctggttacaatcataatctataccgt
-tccttacatactaccatagcgggatagcgtttttttgccgttgattgggtttaagaggat
-gtcagtctcattatatccgattcggtgggagagccgttgttttcaaatcgcacactttgt
-gacataatgtacaagataacaaaactgatataagatataaactgtcaatatcaccttgac
-acttgaatcaaagtaaattaactcgcaaatataatttgactaattgggtgcagatttctc
-aattaataaaaaaatggcaccggatgggcttacaagccccttatcattcacttgtatcat
-gatttccaagaacaatagaatttgctagcaagtatgaacagagattcgaattgcatccac
-agtacgccggagcgtttattttaatgtggatatgacgatgtactgttggcggcatttgct
-agtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggt
-acaatctcagagaaagattacagtttggtttaaataggacttatcgggtcggaagtggaa
-cttaataagcagtacacaattgggcaacagacgtcttgcctattacaataggattacaat
-gcgttagatttcagacacgttcgtgtttggctattcgtcaattccctaaatagttagacg
-atcaactattatcaaagtgattctttgttcatcctccattcatgtaacagatggcacact
-acgcataacgccgaggaattttaacgagatttaagagagcagttcgggcacaacccactt
-gactttataacagctcggcagcataaacggtaatatgtgacaaatttccaaacgttataa
-gaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagc
-ctaacttatctattggttttgctataaaagaacaaagttacacagaatcctaagggcttg
-tttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaac
-cttaaaacaatgcgcagatattggtgatggtgactccgggtatgataatggtaactgttg
-accagcgcccacctcatcgaagtatagaaagtggttaggataaggatgagaccgaactta
-tttccggccataactttagattttctacctagtacacaacatcagggcggacacgaaacc
-gccatcacatcatataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcg
-aactttagcaggcatatggccattatatatggccccagagcagaatgctacagcagacaa
-aatttggatttatgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacga
-cagtgcacaaagtgtaagttacaattattactactcagcagcttctgcaatgataaaatc
-ttatcatacacgtcacatatgataatatctacttagggggaacgggctccacaacctaca
-tagtactcaatacttacactattcgacaggcacaccaaacctgtacagtcccaaaagatt
-gagtcaactttgcagtactgcagatcacagtaatagcttagttagcgagtcaaaattagt
-tttctacgagactgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgta
-tgaatttgtttgaagccacgtaaactgtacaaccttagagataagtctcaggctactaaa
-aacacgttgtggcactaacaggatcatggttgattcttacttattcggctgaccggccca
-ataagtaaccttcaactagaacagaataatcgggagtagtttaattcagtcaaggtgcag
-gtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattc
-cctacttatggatttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaac
-aacgaaattttaattacgctgtgcagcctcatccaaggaattaatagaaggttgatggta
-ggctccgaacgctccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcc
-tgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagataaaccatgaaca
-gcacagtgtgaacccatggttgattttaggctaccttatttttaatttccgttacacaga
-aacgaattccacaactaacatgccattaatttttcgatatcttataaaagatggtcgaaa
-ttcattcatttattttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttct
-ctttagaggtaaaagtggctttgatctcctacgtttggatactagtcaaccattactcca
-tttgatccgtgagtatcacctgtctaacatccagcattatgactcctcggcgaagaaaag
-acacacttcttagagtcgatgtgtattagctagggacacagttgtttaatacgatagtga
-gcccagggagggcagtgcgtcccccagtagatttattcagctagtgtaagtataagatat
-ctcacccacgaggttcaagtgatatgcagtcttagaataatacttatcctgaatttcgat
-attatgggtacttcaataatccgctagcgctactttatgtctcgttggacagcaggacac
-atggcagtcttaaacactaaagacatcacctgaatgaatgtaatgggattacaagaatca
-atgaggtattatatacgacgtaggaaactctggatatatacagtaatctagttacgccat
-cgcacttcattcctctggaaacttagaagacatcagctgtacgtggaggaaccagacccc
-cgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaatgacaatggaccg
-ctggagttcgtaaactcggaacgtagtactgcacaaacccagcatttagcaataggagct
-acgtatgcaactcccacgtggtaataccttcaagctatcaatatataggtgcctagctaa
-tcgcattcgcaagcagtattcaagcttgtaaaccagtataataattacagaggctctatg
-aaacccaactttccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgc
-ccgttctgttattacgcgaattgattctactccaaaattaaacacaaattatcaaccgtt
-tcatttatatttgtcaatgcagctgtttaaaataaggctctactaaattataattaagac
-acttattaccagatttctctagttaagtttgaaccagctcgactaccgcgaaagatacat
-tcccttctctatttttcagttcatctatgggtcagagaagcattgaatttattctattca
-ccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgt
-ttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctggaaggagtaaga
-agtatacagctgatccggtgtatccttcagtcatctgccctatactaattacacgacgca
-aggaaaaataggtttattttctaggcaaacccttcataggtgactccgatgtgttacgaa
-tcatgcttgagaatgtgctatcgttaccgacggataataacgatctccaatgaaccaaat
-gtagaatgtctattgattacccttttactattcgacttagagataggagatagaacctca
-gtgtacttttttagccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatc
-caaccctcttaaagtcttccatattatatcgttgttcgtggaatcgataacagatttgtt
-gacccatagtaaatgtatactagtttatgttgtaagtgtagattgttttccgattgccgt
-ccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatc
-ctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggtttagataaagccgta
-tgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcccttataatagta
-gtttaactataaaagtatatactggtctgtcgccctttcacgatttgttttaccggttta
-tgaagcgttacgtcattagagcggctccaatttaaggttaacggcttccatgtgtagttg
-tatacaaggataacttaaagtatctgttcagcgagctagttaagttatcctcgatagaac
-acaactcagaggtcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattg
-ggaattatcgatacctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtg
-atcctaccttagttagtgctgattaacggaacattaatgtttatcgttttgagatttagc
-caattctctgattctaactcaagatgccttatctgacgtgctatgcagcccctaagtatt
-ttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctac
-tggttaactatataatttacagctttgttgagctagttcctctttggtttaagtcctcaa
-tattagttggttcgagcgataagttggctagttaccttagtcactatattagatccgaat
-gttatgcttcatctgaagaccgccaccctccaaaatttcttttaagactcacttattgca
-aggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacgagtttccatatt
-ttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtcgctctacaaggg
-gacgcaattaagaaacagacatgctagtcaaaaataaacatagcgaggcaccactaattc
-ggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagtagttagttcgga
-catacatttacttcagatgatcaattagttttctacaaatgcttactctaccccgaaaaa
-agtcaccagactcttacgtctctttagtatccttccgtcttatataaggtcagtcccccg
-tttcggtaccctggaatttactaagaataatgaaacagcccccaaggacgtacgtttaca
-aatgatagaccagatcgcctagcttattccgacgcatgttgcatagaattgaaccaacgg
-aatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctg
-atagttcggccacgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcga
-gctcaagcaagcttacacttcctcggatattcagggaacttagtgcctttgaaagatacg
-ttgatcaacgaaaaattgataatggctcatatggaatgcctacctcatagtgctgaatta
-acacagcactgcggacctaacttttcgaggtttcaagttcacgtctcaaaacctaatagg
-ctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaag
-tgaatattctttttttctaaaagcagatctgctgccgggcactacgaaggagatctctgt
-gtatcattattgcttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgata
-gcacaacccaattcgatagtacatattgttgatacttcgcactaaaccgttcatatttaa
-aggttgtgctccttccttcgttaaatactggtgacttggtcctatctactattagctaga
-cctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagac
-atcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattat
-tcttatactaatattagcaaagatgcataatgatttgtattaaatgtataattgaattga
-taagggtcttttagtcagtgatagagtagtataaggtagacattagaactcttaaccgga
-cgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttact
-agtagtacctataatgcactgaatcttcggtcgaagtatagttctaatgctatgcagatt
-gtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaa
-tgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggggaattaaccaga
-ttgaaggccaatcctcacatgtaatgagataatagacgataaatgaaattcttgtaatag
-ttgaactgctacgtgatgggtattatatatgattgagatcctccaattgccgacgtcttg
-tcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcat
-aaacgacgcgacatgtacagcactccgaagtataagcaataataatgcgggtaatccaga
-ctagatcttttcggactcaatgcggtttcacggtaaacatgattaataccggagagtagt
-cgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgttgcagataaaacc
-ggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaa
-cttcaagaactatcgtatattcaagtccattaccttttagtttcagactggtggagctga
-ctaaagttatatcatcattttgtacactggtttagttaacgataatttcagatttaacat
-gaccagacgataatcgctgtatatccagttggaatgtggtttgccagaaaggttaactta
-taatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagt
-gtatttggagctgtagttataccgtgtgctaagatcagtagacatgacgagagcaatatt
-atctaccttacaagcatcaacggacgtctagtcggaacaaaagactctaaaactcgaact
-tcaggttaatatactatagttctgtattcagcagttattcttatattcgatattatcttg
-cctattggatgtctgactttagtatattaatcatagtatctgccatgtaaaggtgccagt
-actaaatctgtttcacagtgcgaattataaacggttacaaccattaaagacaacaagacc
-ctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaatta
-gtctatagggtcgggacgattctacggcatttctggttataatgacaacatggattgtgg
-cccgagaatcgctctttcattaattaagcaatcattacagtcttataagcgctacttccg
-agtggtagcaggtaactcgatataaggtcgcatgagccgaatagcttaaaaaacaggcca
-ccgaacattgatagagaataccgaccacagcgcaacctttgattactttcattaaattgt
-acggctcactcgacatcaagcttaagattgcgataatgtgaactcaaatggatcagtact
-gaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgctgttacaatata
-cagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttggttagaaatgata
-gccattcatgatagaaataagctgaatgataccagtatctttaactatgtagtcaggggg
-aagataacgatggtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgct
-aacgaagctacttaatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaa
-agatagtatgagctataatatatgctagtagagaactctggaccatcatctatatgaata
-ctgattcgagcgtgcaattactttagcctgcgtactactgactctacaaaacactctgag
-ataagtttgtagtcagtaagtcgctctctataaaccttttggatgaccattgtacagcca
-cttatagatcccaataaatagcacaggagacagagtttttcaatgctcgatcatttgccg
-atagtattttcgtctaacctcagggcacctattatttgatacctaacctaacggcccttt
-cacaatggagaaatatatgacatcgggacaaacacaaatggtgggtggccaggagatatg
-acatggtggcgtctctaagaaacacggactccctctaggcaaactcacgtaaccaatttt
-aatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggtacattgactggt
-caggaatacatcactgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgt
-ataacgcaatttacgacggacatcagatcaagttatacagattatttaagtatcacgtgt
-gcattgggacataagggatctcacacatgccttggaacatttttgctttgtgccgctttt
-tcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaacagaatgagaaa
-ggttagggctctaagttatcgtcgattgggatagacgagacatttgcgagcgccctccac
-ggatacgaatctcccatatcaatgtgaactggatgctatgcagtttagttcttacgtctc
-ctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacctaatacacaaaa
-ccgtcaaacattttctaattctaggtatgggccgatcataggagctaaggtgaaactcat
-aaatgttttgttagatctagcatcctaaaaagatgcatatactgagtagctggcgtgcat
-tctctcaattgtatcctttttaactgaactagtcggtcccatttcgtgactgagatctat
-taaccgataagattaataacactcgcattcgtatcagctcagagtgaagtttttcaataa
-tttgactgatatattaacttctaaaataaccctttaagcctcggatccgtttcccaatca
-catcaaaaattcttattccaactatctacggattaacaacgtgcatggggatcgtagtaa
-gaacttgttccgatcactttgagtatatcaagttgacggcccggttattattgaatagaa
-acattcacctgctaaattaaataccgcacatcggatacccgatttcagagggccgtctta
-ctaagggcaggctttgttcggtttaactgagatgttcattattttacagtatgcttcaac
-taatatgtaacgaaggacagtggatctgtctccatagtagatcttcagtcgtgaatttca
-taccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccct
-agtattctagacgaaaattttttctagttcatctgataatttgccaattcaaaaacaacc
-gctggtttcccggcgcattctctaaaatggaagtcgaacctagagccattatttgtcggt
-aacccatgagttccttcttttcagaagttaatacactgtggtcctatacagaggaaaaac
-agcggttatatacgatcgtggcataacaacattggatcaagatagcaatttggctaccta
-ttctaattctcactagattcggtattccactacaatatcggcagattaggattggatgaa
-taatcggtgtttaagtccggttgcgtctccaatctcctaatttttattaatattgatctt
-ggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaaagatagaagact
-catttgaaaatggatcatccacagatccaaacattagcaagacactaatccccaactagc
-tattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaatt
-ctttttgggctttgttcgatggtgattcagaatctttatccggtcgcttccctgtagcta
-ctttgtggggatattgcccggggattatagggttgagatcgtttcctaaaagtatttaaa
-ccaagtagacttcaactaaactacatcagaacatcgtgaagacaccatacgcggtacctt
-tatttaccgataacatttcttcaagaaataccggtaagcagcataatgaccctaaacagc
-tcggggtatcgtcgtagttttaaattttatttaggttactgctcaaggaataaaaactaa
-ctatttaatttataataatattacaaggctcacactgattagatttgtctataagacttc
-gcgatcccccattaccggattgtcttaagaataaactagataaaccatgcattttctaga
-taaggcctttagtctaattagatacaaaaaacacgatagttgcatccttaatttattgtg
-tcaaacctggaaccttttaattacccgcaaatcactttatgtcgagactacctctgaaat
-ttattatctacctaccgcatgaggacttgaaccatcttgtaggagttatgtttattagct
-aagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaatt
-gtttttagttgagtcaagactgatatataaataagtttccctagttttttcgtggtggga
-cgatattgaattgaatcttaaccgaagagtttcccactctgtcgcacaataatacacgcc
-aatatttccagccctgcttatgccttaatcggttactcaatctcccattgaagttcattt
-tgatctgcatagaagtttcgggcccagccttttttctgccaccttcctccaagctctgta
-gacgcactctaagattgatgctcacatgtattaattctacattaacataaatatataagt
-catgcatcttcgagtaaaatatctggttctccaacatgtcctggcacgtatcgttataat
-gcccatacatgtagtattaaaatgattgggttaactggatattaagatcatcgaaattgt
-aaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctcggaagggctatt
-acgcttacttccgttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcc
-tacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaactacttgctttac
-aataccggtcgtatatatcgccgtgaatccagaagattgtcttctttggattatcaaccg
-agatcctgtggaccgatgttttgggaccttcacagaggactccaggtagagctcgctttt
-gcattaatctaagaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatg
-gaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgagttattatacata
-tacgagatggtggtatacatcgaattcggggcatacactatagttgcattgtatttagct
-gctttaaataatatgatattaccttccttacataagacattaccggcataccctggtttt
-caacttgtggggctttttgacgatcgcactctcatttgatccgagtagggcggtgacccc
-tgcttttcaaatacaaaaatttcgctatgaaggtaatagattacttttcgctgttatgat
-agaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttg
-tgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatag
-aaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgccgacataggatg
-aaatcagattccaatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaa
-gttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtgcgatcaactatg
-aatctcggcgagttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatga
-cgaattttcggctaggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggat
-tccattttacaagacgattacaatgagttacatgtctctcaacgtagtctttccctagta
-gtctttgaactatttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgc
-cattcatgtttatgatggaacaataagaataacgccctcgtatgttatcgacagtgaagt
-cagcagttcggccaaaaacatattcaatttagtacagatccccagaagttaagctaagtg
-ctctaaaatggcctaaacggttatcaaagtaggtctaattactatactaacgggtgcatc
-gtaataactgctgtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaat
-gtgacaaagaagccttagcgattcttgcaaacttaggacttcggattctcaatcttaaat
-gtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcctgatggtgacta
-cgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaactattgatagtcggg
-agcataaccaggtgaacgtactttgttcacgacatttattgacatgttctaaatacgtct
-caaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaat
-gccggtagtgtcaaacttcatgagaactttagctggcttttggccagtatttagggacca
-agagcactagccttaagctgaatattttgccatttatctactgttataactttaaaactt
-ggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaaga
-acaagcgtaggaattgagtttatattatatttaaactaaaagatgatattagcttctgag
-ggcgatagggctccaaatcataaagaggaatatattattacacgattagaaacccacaac
-atacctcgaatcgcccaaaagtttgacgaaacttggcagtactccacatctcagtaatac
-agttgggagagtctcaaatgttgttttattactcaatgaaccaccctcataatttcactg
-ctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaatt
-acagataagtagatgcataataaaaaaaactgctcgctataacacgatcatcgtgcattc
-ttacttaggagcatcacccgcacaataacgtaccttaaactacaacactattagaccgag
-tactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgt
-gataatagtttgcggagaggattcaattattttccattgcacctactccactagattcga
-taaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaa
-gcatgtaagtgaaccgtcatccttccctaagaaacataaaggtttttaataatgtcgact
-gtgaactataactgcatcctttcctgacctactccggttccttgttgttatttctgaacg
-agaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccg
-ttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaaattaattttgcc
-ttttattttttttcaggctcgaaattaatgatttgttttttttgaccttctagttacgct
-aatatgcggtcgcctgtggtttctattgagtcctataacgggatgggatctaatacgttt
-ggttactagtaaacaaggtataaatttgataccggagtatcaactgtataacatcaagct
-ttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagcca
-ctaaggggtgtattacgatagtgacaccaccgagcgcactcactccccaagtagatttat
-gatcctacgctaagtattagatatataaccaaagaggttctagtcagtgcaactcttaga
-ataataattagccggttttgcctttttaggcctaatgcaatattcagctagcccttatgt
-atctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaaatataatctatg
-aatgttatgccagtacttgaataaatcaggttttttataagtccttgcatactctcgtta
-tatactgttagagtcttaccccatagaaattctttcatctgcaaacttagaagaattctc
-agctacggggagcataaagtccccaggatgttgacaaatacaacaaatgtggcttataca
-aacactccatatgaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaa
-tccctccattttccaatagcagatacctatcctactacctcgtggtattaaattaaagct
-tgaaatatagagctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccac
-gatttgatttacagacgctagagcaaacccatctttaaacatataagtaaaaattaaagg
-gtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgtttataagccata
-attaaaaacatatgttcaacaggttcattgatatttgtaattgcacaggtttttaataag
-gatctacgtaagtataatgaacaaactttttaccagagttatattctgtactttgaaaat
-gctcctctaccgccttagagactttcaattagattttttgcagttaatctatgcgtaagt
-gaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataac
-tgtaggtctaatataattttcagttttcgaacacataaccctttgaaaatctgctattta
-atgtctcacctgcatgcactatcttctatactgctcagaacggctatacgtcactatgct
-ccaagtgacgatttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaa
-gtgcggactacgtgctctttacaataagccttgtgattgggctataggttaagtcccata
-ttaacgatctccaatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaa
-ttacagatagctgttagatactcactctaattttggacaacaatcccaatcttggggtcg
-tctatcgcctgaagctcgtaaatccttccatcttaaacgattacatattatagacttgtt
-cggggtagagatatcacagttgtgcaaacattgtaaatcgatactagtttatgttggtag
-tctagttgcttttaccattccccgaaaaacttgatctactatttcgacaacagtaaactt
-gaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgtccactatatgta
-agtgtagctttacataatccactatgactgagatcattacggcctaggaaagcagcgtag
-aaaaaaagggcccggatattacgactgtaactataaaactagttactggtagcgcgccat
-gtatagatttgttttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatc
-cgttaaccagtccatctcgacttctataaaacgataaagtaaagttgatgttcagcctcc
-ttcttatggttgcatcgagagtacactactcagtgggaaatagatcggggttcctacttc
-agattgtattatctaggcaattgccgattgtgccatacctggataaaataagctacctac
-atgtgatgcttatctattatcgtcatactaccttagggtgtcctgttgaacgctacatta
-atctttagccgtttgagatgttccaatggataggagtctaacgcatgatgaagtttagga
-aggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagacgttataaataga
-aaaaaggtccttctggttctattctgctgaactattgaatggaaagattggttgacctac
-gtactatttgcttgaagtcatcaatttgacggggtgagagacatatggtgcatactttac
-ggactctatattttagatcagaagcttagcagtcttctctacaccccctcacgacataat
-tgcttttaagaatctatgtttgattcctctacgggaattcggatccgttcgcatgtgcgg
-tttatctaaaccaggggacatatgttcagctaaagcatacgaacactttgctaactagac
-gtatgtatagtagctataaatcccgacgatatttacaaaaagaaatgagactcaaatata
-tacatagcgaccctacacttattcgcaccctgatctaggcgatcctagcacccacacccg
-aaagtgagcactagtgtcttccgtattaaatttactgcagttgagattttagttgtctac
-taaggattactctaacccgtaataaggatcaagactcggtactagctttactatcattcc
-ctatgtgttttcctaactcacaagggtacgtaccagcctatgtaattacaataatgataa
-agacacaaaggaagtaactttacaaatgagtctccagttacactagcttagtccctccca
-tcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaagaacactcataa
-cgttggagtccaagaattagactcatagggcccccaacatttaatatgtactgtgagttt
-gaaggtgttctattgttaattcctgctcttgatacatgacacgtactccgtgtttaaggc
-ttcggactgactttctttcataagttgagcaacgaaaatttcagaatcgataagttggat
-tcactaactaatacggctgattgaaaactccactccggacctatatggtcgacctttata
-cgtaaccgatataaaacttataggctggtatatcgagccttcctagcgcaatttcggatg
-gggtttcttctactactcaacaacggaatagtctttgtttagtaaaccagagctcaggac
-gcccaatacgtaggagagcgctgtggagcatgtgtcattatggactggagcactcttaaa
-tcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaattttcttgatacg
-tcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcg
-tgctcagatatactattagcgactcatctcgcctaacacgcacacgtataaactcggaat
-gactgccgctcttacatattagaaatacagactacaccacggaagcattgggtcattctc
-aaccgctgtataaaagatgattagtcttataataagattaccaaagaggcagaatcatgg
-gtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatgg
-tactcaggacaaatattaaccggacgaagtggtttacgtcgtactttcactattagtagt
-aaatacaaggtaacaccggggaatagtactaaatataatgatatctatcttcgggagaac
-gagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgata
-caaccgattgttacttttgtctattcaaaagattgaatagttttttatacaaaagccgca
-tacttatgacggctagtatacagtttcatcccctagcatcaatgctatggacagtattga
-acttataggaaattcttctaatagggcaaatccgtcgtgatgcctattttttttcagtca
-catcctcaaatggcactagtattgtcgggatcccattaacaggctcaaccacgagctcac
-gcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaactcccatggataac
-caattataaggcccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaa
-tcatgttgaataccccagagtagtccagatgataaccgatgaaacacaagtctttctcaa
-tgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgcgacatctagttg
-tgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaacgccttgtaatt
-ttactttaagacgcctggtgatgtagattcttagataatcagtttgttatcggctgtact
-ttaccataatttcacaggtttcaggtcaagaagattatagctgtatatacagttccatgc
-tcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatc
-caatacatgccccgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagc
-tcgagtcaggacgtcagctagattagattccttaatagaatataccgacctctagtccga
-actaaactatagataacgccaacttcaggttaattgtctagtcgtctgtttgcagatggg
-attcttagatgagtgagtatcggccatattggttcgagcactttagtttttgatgcatag
-gatatgcaatgtatagctgaaagtactttatctgtttcaaactcacattgattaaaccgg
-taaacctttaaagactacaagaaaatattcagtgagggcaattttgtcaatcacaatctt
-ccagctagagatacttcacaatttgtcttgaggctacgcaacattagacggattttcgcg
-ttttattgaaataatcgaggggcccaagagtatccatagttcattttgtaagatttcttt
-acaggcttattacagcttcttcagactcctacatgcttacgagttatatgctagcatgtg
-aacaatagattaatatacaggaaaacgtacattgagagagatgaccctacacagcgcaac
-cgttgagtactttcattaaagggtaacgctctcgagacagcatccttaagatggccttat
-tgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaa
-cacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcggagtatcaattt
-cgccaatcttggtgagaaagcataccctttcttcagagaaagaagatcaatcataacact
-atctttaacgaggtacgcacgcgcatcattacctgcctccatggatctttaggatagcgg
-aaagtattggcagcgtattgtgatttcgttcctactttatcaatttcacattcatataca
-tgtcttttatcaaaatcgccaataagataggatgagctatattagatgctagtagagttc
-gcgccaacatcatcgataggaatactcaggacagcgtgataggacttttcaatccctaat
-actctctataattataactctctcttaagtttggaggcagtaacgcgctctatataatca
-gtttgctgcaccattcttcagcctctgatacatacaaataaattccacagcagtaagagg
-gtttaattgagacatcttgggaacttaggattttactctaacatcaccgaaacgattatt
-ggataccgtacctaaacgaactttctcaaggcagtaatataggacatccgcaataacaca
-aatgctgcctccccaggagttatgtcttcctggaggctatatcttacacccactcactat
-aggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataagagttggccggc
-gtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaagttctgtcctgt
-tcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatctcagcaagttat
-aaacatgttggaagtttctagtcggaattcccaaagaacggatctatctaatgcattcct
-acatttttcctgtctgccgatggtgccatcctattcaaagaatttcttaaaagtagatta
-aatgggacttttaacaatgagtaaccttacgcctctaagggttcctcgagtgccatacac
-cagtcaggtccgagccacatacacggagaacattctaacatagcattctcaactcgatca
-tttgcaggttacttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcac
-ggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttggtatgggaacat
-cattgcagctatggtctaacgcattaatgtttgggtacatcttccatcatataaacagga
-agagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagc
-tcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataa
-gatctcactgaacttttgaatgaatgtgaagcatatatgatctgctttaataaaacttta
-tccataggatacgtttccaaatcaattcaataattattagtcaaaatagataaggatgaa
-caacctgaaggccgatcggacgtagaaagtggtcccatcactttgagttgatattgttga
-accacacgttattatggttttcaaacagtctcaggatattgtatatacagataatccgat
-accagttgtctgacgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgtt
-cagtattttaaactaggcggcaactaatttggaaagaagcacagtggatatgtctaaatt
-cttgttattcaggcctgaatttaatacaccgcatagttaacttcgcggtagagttgttca
-tcatgcctcctctaagctaccacttctatgatacaccaatagttgttctacggaatctga
-taattggccaagtcataaacttccgctgcgttcaacccccttgctcgaatatccaactcg
-aaaagacagccttttggtgtccggaacaaatcagttacttcttttctgatgttaattctc
-tgtggtcagatacagaccaaaaactccgcggatttaccatcctccaagaacaaatttgca
-tcaacatagcattttggctacatattctaagtctcaatagtttaggttttcaactacatt
-atcccaacattaggattggaggaataatagctgggtaagtccccttgcgtctacaatcga
-ctattttttatgaatatgcttctgccgcacctatggttattaaaaaagtcatgactttga
-agaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaagagcatataatta
-gcaacactctaagaacattatagatatgatgatagcgatcgtcatgatgttatccggtca
-caatagtagcttcatcagctaattcgttttgccagtggtgacttgcgctggaagaatcgt
-tatacggtcccttccctcttgatacggtgggggcttattcaaccgcgtggattgggttgt
-catacttgcattaaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatag
-tgatcaatacatacccgcttcatggttttaaccatttaattgattaaagatattccgcta
-agaaccattatctacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccg
-taatgatcaacgaagtaaaacgttatattgtatgtagaataataggtcttggagctaaat
-gatgtgattggtagtgaagacttacccttacaactttaccggtttctcggaagaatatac
-tagagaatcaatgcatgggctacataagcactttagtctaatgagataaaaaatacacga
-gtcttccatcatgaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatct
-ttatgtcgtcaataactctcatatgttttatataacttcccaatcacgacttgtaactgc
-ttgttcgactgagctgtttgagctatgaggccgggatccggttgagctacatctatttgc
-tacaagaaaaatgaaagcacatttgttgggagttctggctacactcatagagaaataagt
-ggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaa
-cgctcgcgctaaagaattaaagcctttatttcctccacggagtagcccgtaatccggttc
-gaaagagaccattgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttc
-tgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatg
-cgtctgtaacataaatatagaaggaatgattcggcgagttaattttcgccttctccaaca
-tggcatccctacgttcgttataaggaccatacatgtaggttttaaaggtttgcggttaat
-cgatatttacatcatagaaattctatagtcaaatttacaagactctagatactcactcgt
-tgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaattt
-catatagtaagttcaaggcactcatacctccgtgaagagggtagatagactattaaagtt
-gtttaatagtacgtattgatggaaatgacccgtaggagatttaccactcaatccacaaga
-ttcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaaca
-cgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccgagataaatgagct
-ataacactgtatgtcttttgattgctataaaacacagaaacggatattaatttaggccgt
-aaccaacatctgttatttgacatagaacagatggtcctttacagcgtattccggccttaa
-tattgaggtccagtgtattgtcctcctttaaagaagttgattgtaactgacttaaataag
-acatgtcacccattcactgggttgcaactgctggccctttttgtccatcgcacgctaatg
-tgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggtta
-ttcattaattttagctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaa
-ctaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaata
-aagccataaccagccccggaatagaaaatgttaaggaaaggcgatcttctttgaattctt
-attgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaatctaacaccctc
-ccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaa
-tgtggttccgtcccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctc
-atagaggtaactggcctgtaatgtccaatgttaggctaccttctccaactttagtacaac
-gaataatgtccgattaacaaggagtcaatttgtcatgaccagttcattcaggtacttgta
-tctatacggacgcgttccagagtagtatttgaaattttgaggttctactgataagtttag
-ctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaataacaattaacaa
-ctcctaggtgatacactgtgaagtctgctgttccccaaattacatatgctattttgttca
-cataccatgaagttaagctaagtgctctataatggcataaacggttatcaaactagctcg
-aatttcttttattacgccggaagcggattaactgctgtagatcaaacacgttaggatagt
-gtcgttttcatatatatctaaattcggtctaacatgcattacccatgcttgataacgtag
-cacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatc
-accagtgatgcctcatcgtgactacccggatctttagcctttagggtctaaacagaacta
-atattactacgtgtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatt
-tagtgacagggtagaaatacgtatcaaattaacccagcaatacaataagcatgaaaataa
-ttgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgc
-attttgcactggattgagccacaaactcaactagcattatgctcaatatttggccagtgt
-tctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatc
-tcgaacgtaataggtttaattagaacatccgtaggatttctgtttatagtagatttatac
-taaatgttctgattagattctgacggccttacccatacaattaataaagacgaatatatt
-agttatagtttactatccaaataaattaagcgaatcgaaataaactgtcacgatactggg
-cagttatcaacttatcacttatacagttcggacactctatattggtctgtgagtactcta
-tcaaactaactcataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtg
-tacaaacctataatcgaataaatgacacatatggagatgcataataaaaaaaacggctcc
-atatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctg
-ataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtat
-agttcttgatagcgcgtaaattctgataatactgggcggacagctggaaattagttgcca
-gtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaaatacaaagggtt
-agttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaaca
-taaaggtggtgaagaatctcgtaggtcaactataactccatccttgaagcaactactccg
-cgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaacaactctcggta
-caaatgcggcttgtgtcgataaagttggtggtagtgcacggaataacataacaaggaata
-ttatttattcaaattttttgtgactgttatttgttttctgcctagaatgtaaggatgtgt
-tttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctat
-aacggcaggggagcgaagtagtgtcctttagactattcaaggtagaattttgataacgct
-ctataaaaggtagaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagtt
-ctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtcacaacaccctccc
-atcgcactcaaaatgtagatttatgatcagacgctaacttgttcttagagaaaaatacac
-gggatactctgtgcaacgatttcattaataaggtgcagcttgggacttttttggccgtag
-gctttattaacattcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgtt
-ttaacgtttcaaatataagctaggaagcgtttgccaggacttctataatgcaccgttttt
-tttagtacttccttactagccttagtttatgttagagtctttccaattacaaaggattga
-atagccaaaatttctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaa
-tattctacatatcggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtactt
-ttagaccaaacgtcttcggataattaaatcctttttcaattaccacagtacgtgcattag
-aactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacatt
-gcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagcttaccattcgtt
-aaacagataactaaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggat
-gtagactattgtttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgt
-cgaattccacaggggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatc
-tgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattg
-ggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattctaccgactccgga
-taacactttacgatcgcgcataactctagctcttagataagtttaacttgtcgatctcat
-aaacagttcaaaatctgcgatttattgtatcaaatccatcctctatcttctataatcatc
-tgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaaagctataattgg
-tttattttagtccatttaaattaagtccggtataagtgctctgtacaatatgcagtctca
-tgggcatatacgttaactaccttttgatacttcgaattggtaaaatatcgactatcgatt
-tgcagtaaaaggtgtagagtccaattactctttcctgttacatacgatctcttagtttgg
-acaactagcccatgatggcgctcctctagcgcatgaacctactttataattacatcttta
-tcgatgaatttttttagactgcggaggccttgagttttaacagggctgctaaatttctta
-agcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatc
-tactattgcgtcaactctattctgctaatagcgatggcaaatcacagaagccctcttagt
-gacaatagttgtcaactatatctaagtcgacctttactgtatcaacgatcacggagagaa
-ttaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataa
-tacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaac
-gattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgt
-tagtaaacttgatcttcagactccttcttttcgttgcagcgagacttaaattatatctgc
-gaaatagtgccccgtgcatacttcagatggtaggagataccatttggcccattgtgactt
-tacgcgattaattaaccgacatacatctgttcctgagctatgatcgtctgaataaattac
-ggtctcctcttgatacctaatggtttctggagacgtttctcatgttcaaatggatagcag
-gagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatt
-tccaaaccagaagggataaagagaaataacggacttctccgtagattagcctgatatttt
-gatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatattttggacggcggg
-agacacatatcggccattcgttaaggtctctatattggacatcacaagcttagcagtatg
-agctactaacactcaagacattattgattttttcaagatatgtttcattcctctaccgct
-attcccatacgttcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatca
-ataacaactcgttgcgatagagacctatgtatactagagagaattccccaacatttttac
-aaaaacaaagcagactaaaatagatacagtccctccatacaattaggaccaacatgttat
-tgccgatcctagcacacacaccacaaactcagaacttctgtcttacctatgaaagggtct
-gcacttctgattgtacgtgtctaattagcattaatattaaaactaattaggataaactat
-aggtacgagctttactataagtcactaggtgttttccgatcgaaaaacgggaccttcaag
-ccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaa
-ctgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgt
-tatactgctcaacaaaactcataaagttggactccatcatttagaatcatagggaccaaa
-acatttatttgctactgtcactttgtaggtgttctattctgaattcctcatattgataca
-tgaatcggaatacctgtggatcccttaggacgcacgtgctttctttacgtcagaatacat
-attgtcagaatcgagaagttccatgcaattaagaattcgcctctttgaaaactcatatcc
-ccacatatagggtccaccgttattcggaaacgatataataattattccagcgttgagcgt
-cccttaagagcgcattttcgcttggcctttcttctacgactctacaacgcaagtggctgt
-gtggagtttaccacagcgcagcaccccatagaactacctctgagagcgcgagatggtggc
-agtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatg
-gactgtcttaattgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaa
-gtaatgacggaaatacgcctctagtccgcagagatacgattacagactcagatcccctaa
-caagcaaaacgattaaatcggaatcactccccctatgacatatttgaaatacacaagaaa
-ccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgagtctgagaattag
-atgacctaactgcaagaatcatggcgagtttatctagtaggcaagtctgtaccctagggt
-tcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataaccaagaactggttta
-ccgagtactttcactattaggagtaattacatgcgttcaccgcggaatacgacgaaattt
-tttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaa
-ttgctgatcaattatagattcattatacagatgcttacttttctctattcaatactgtca
-tgagttgtttttaaataagcaccagaattatgtcgcctagtataatcttgcttccacttg
-aatcaatgcgatggacagtattctactgattgcaaagtagtctatttcggcttagcagta
-cgcatgcctatttttttgcaggcacagaataatatgcaactaggattctcggcatccaat
-taacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatgtttactacagaa
-agcgaatgatatcacttggagaacattttagatgcccccttttaatctagactgagtgta
-ccaatatatcaccggtctaccgaatcagcttgaataaaccactctagtactcatgataac
-cgagcatacacatgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcg
-aatcaacgtggcgacttatacttctgtctttgagtacagcacaccctaatgaatctaagt
-tagttgttgatacgaattgtaatttgactggatctcgcctcctcatctagattcttagag
-aagatgtttcttatagccggtactgtaactttattgatctggtttatggtaatcaacatt
-ttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagc
-gattatcgagtctggaggccgagaaaagaaatgcacagagtaagctctctattgcgacat
-ctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaat
-acaagattacctacgcttctacgaaatatactatagatttagcctacgtcacctttagtg
-tcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcg
-agctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctg
-gataactcacattgagtataccggtaaaaatttattctattcatctaaatagtcagtgag
-ggctagggtcgcaatcacattaggccacatacacatacttaacatgttctattgacccga
-cccaactttagtagcattgtagccgtttatgcaaatatgccaggcgccaaacactagcca
-gagggcattttgttacatttatttaatcgattattacacagtcggaacacgcctacatgc
-gttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcag
-agacatgacactaaaatcacattaaggtcagttagtgaaggaatggctaaccagctagag
-aatgcatcattaacaggcacttattgtcaaatattttccagatctaagcaacatcacgtt
-aaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagt
-aggcaagcgtaggagtataaatgtagacaatagtcgggacttagcagacactggatgcag
-tcatagaagatcttgcataacacgttagggttagagctacgaacgcccatcattaactgc
-ctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgatttcgttcataat
-gtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgac
-ctatttttgttcagagttcagttagagcctaatgattcgagagcaataatcaggacagcc
-tcataggaagtgtcaatcacttagaagctatattattataaatcgctctttactgtcgtc
-gaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaatatgatacataaa
-aatattttcatcaccactaagacggtggaattcagacttattggcaacttaggatgggac
-tattaaataacccataagatgttgggataaagttacgaaacgaaagggatatagcctgtt
-agataggaaatccccaataaaacatagccggcctccacagcagtgatctattccgccacg
-cgatatctttataccacgcaatataccaataataaaggttaaatgtggttgcgatttaaa
-aaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaatta
-tagcgtctgcaagttctctaagcttcctctgcaagatacaatatgactttttagcttttt
-tactaccaaatctcagaatcttagaaacaggttggtacgtgctactcggaattcccaaag
-taccctgctatatatgccattccttcattggtccgggctcaccatggggccatcatagta
-atagaaggtagtaaaactagttgatttccgacttttaacaatcactatcctgacccagat
-atgggttccgactggcccttactccagtaagggcagacacacagacaacgagaacttgat
-aactttgaattctcaaatcgatcattgcaacgtgacttatttactagcctactcctataa
-ttcatacgtcaaatacatttcaacggaggaagataataagtaaatattcactaaataatg
-gtcgaaggagtcctttgccaacataagtccacatatgcgctatagattttttcttggggt
-tcatattcaataagataaacagcaagagtatcacgtcagcgagtcattgagatcttggct
-agcattgtgatagcatattctacctaaatggtagtctagcacagagtggataagatatca
-gttagatatagacaagtactataacagatctcgcttcgttggattgtatggctagctttg
-atgatatgattttataaaaattgatccagacctgacctggccaattatattcatttttta
-tgagtaaaaatagataaccatgaaaatactcaagccccttaggacgtacaaagtggtaac
-ataaatttcaggtgttattctgcaaccacacctgttttgggttttcaaaaaggctaagca
-gattggttttacagataatccctgaacactggtatctcccaacgatgtcgttcccaaccc
-ttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaatatgttcgatag
-atccactcgcctgaggtagaaattcgtcttagtaacgcctctttggattacacagaatag
-tgtactgacacgtacactgctgcagcagccatacgctaacattaaaattcgttgagtcta
-catttgttgttattcggattatgttattgggaatagtatttttattcccctgcgtgaaac
-cacatggatagattagcctactcctaaagactcccttttggtctacggttcaattctctt
-actgagtttatgttcgtaattatatcggcgcagtgaatctcctaattatcaccggagtta
-ccagacgccatgaacttatggccagaaacattgcatgtggcctacataggattagtatca
-agagtttacgtttgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcggg
-aactcccctgcacgcgactatagaagttggtggtggatgtggcttatgccgcaaatatgg
-ttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtataagggctattgc
-cagatgaaaaactgcatataaggtcaaacaatataagaacattatacataggatcttagc
-gttcctcaggatggtatacgctataaagtctagcttcagcagctaaggagttttgccagt
-gcggacttccgctggaagattaggtttaaccgccctgacatcttcataaggtcgggcctg
-attcaaacccctggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagt
-ctaatattattattaacaaatgacggttcaataaataacaccgtaagggtgggaaactgt
-taagtgatgaatcattttaacctatcatccattagctacagataatgataccccgatccg
-actagggggtaagtggttgttccgttaggataaaccatgtaaaacgttagagggtttgta
-gattaattggtattccagataaatgaggtcagggcgagtgatcaattacactgaaaaatt
-gtcagcttgcgcggtagttgttaagacagtataaatgaaggggattcagaagcaagtttc
-tcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtcgattaaagccta
-aatggtaatttaaaccattgatatttatcgagtctataaatatctttggttgtatattac
-ttcacaatcaccaattctaaatgattcttccactgtgcgggtggagatatcaggacgggt
-taaggttgacctacatcgttttgatacaacaaaaatcaaagcacatggctggggacttct
-cgatactatctttgagatagtacgggcaagagtgggtgacgcctccctacattttcaagt
-ctatcggataacttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatcc
-acgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtc
-atggttagccaaaagcatgggttatccaaaaggaataaaacagctcttcaacaaagagat
-gaggcttcataacttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggac
-actttattttagccggcgaattaatggaatccatacgttacttatttggacatgacttct
-aggtgtttttgctgtcccgtttagcgatatttacagattagtatttcgtttctcatagtt
-aattgtatctagatactaactcgttgaagacgcataccttgccatttgtacaggacttaa
-ctgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaatacctcactcat
-gaccgttcatactctagttaaggtcgggaatactacgtatgcagggaattgtaacctagg
-agatttacaactctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcct
-aacttcgggtgcctccgtaaatcacctagaaacctactcatacatttgcaattttgagat
-gtaggcgaaagagagaaatctgctttttaacggtatctcttgggattccttttaaaaaca
-cataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgc
-cgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatg
-ttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctcccc
-agggttctacagacatagagatggtcagaacacgacccccctctcaacgcagtgtatttg
-aaatatatggacatatctaccttattctgtaattttagatgtgttctgtgtataccgata
-ttgataagtcaataggcttgattacgtatcttaagacaaatctgtttcgcaagtaggacc
-gcatctttcagattgtttctttttatgccataacctgcccaggaattcaaaaggttatcg
-atacccgatatgctgtgaattattattctaatggccactcattcctgcttatatctggaa
-ttggcatgaatatcttacaacctaaagtctggcgttgcgccagttctacttcgtaccgga
-caccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacac
-tttgtgccgacgtatatagatatattacacgtatagggaatgttttctcctaggtgaccc
-gaccttctactaaggttgtacatcgtataatggcccattaactacgaggaaagtggtatt
-gacctggtaatgcacgttcttcgatatataccgacgaggtaaagtctactattgcaaagt
-ttgacgttatactgataagtttagatttccctggatcgcgcatgaacaatgtatgcgtta
-tctgccatatataacatgttacaaatccttggggatactatcgctactatcatcggacca
-aaattaaataggctagtgtcttatcagaacatcatgtttaccgaactgatctattttcca
-atttaagctgatattacgtccgcgtatttattttagttccccggatgacgattatctgag
-ctacatcatacaagttagcatactcgccggtgcattgatttcttatttcgctatatcttc
-aagttcacaggcttcatatagttccaattagcagtataattaggttttgtaactttaacc
-atactttataaaaggttatattgcacaactgatcaagcatccgctataacccgagcttta
-ccagttagcggctaataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgc
-tctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtataaaatgatacca
-catatactataacaatgaaattatttgtaatccggtttgccaacgtatcccccttcgcga
-taaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaa
-ttatcatcaatattggccaagtgttataagcgttgaaagtgatataggccgccaaaaagt
-agtctacttaaaaaccaatatttatcgttcgttattgctggtagtacaacatcacgagca
-tttctcttttgagttgatttatactatatctgctgatgtgattatgtcccacttacccag
-aatattaagaaagtcctagattgtaggtatacttgactataaatataatttaagactata
-caaataatctggctacattatgccatcgtagaaactgataacgtagtaacgtcggacact
-agattttggtcggggagtaatctagcatactaacgaatttgttaaatccgctgaaagtat
-atgtcattacctgcttggcctgtcttcaatacgtttagactattaaggactcatttcgag
-atccagtattaattatacgcatccatatttatactgaagacggattgagttaggacgaca
-agctaaacaaatattaagttaaggattagtattatattgtagaaactcgtcgggttggaa
-cgattcatcatcatagaatgcgttacttattcagagagacttaattcggttatgactggc
-agctcacctggaaagtaggtgaaaggcaacagaagaatattgttgactgaattctacggg
-ctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaatacaatggatctct
-acagtattacgtaaataacatacataaacctggtgttgattcgactagctcatagattaa
-tcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactg
-ataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtc
-aaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttt
-tatccagacattggatgcatggctgtgggggcacaggatacttaccattagttcacctac
-aagcggcgtgagagggtctcagttttagccagcgcagagaagtacgggcctttagacgat
-taatgctagaattgtcataaacctcgtgaaaagctagttaataatcatggtgctagaaga
-acacaacttttctataaaccagttctcgactgacagtcgtaactcactatatcgccgctt
-tgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagaga
-tcgtgttctgagagataaatacaccggatacgatctgcatcgagttcatgtattaggtca
-agcttgggactgttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtca
-tatcataatatatgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaat
-cgtattcttgaatgctccgtggtttgtactaattcctttatagactgagtgtatcgtaca
-ctcggtacaattacaaaggatggaagagcaaataggtcttcaattataacagtaccccac
-cttaatctaaaaaccagcttcaattagtattaatttcgccaggagtatatatataaatat
-ctaaagactaaaagactcgtacttttacaacttacgtcgtagcataattaaatcatgggt
-aaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctc
-agcaagtcagtagaaatggaaattcatactcgattaaggcctataaaactgttgttggta
-tctacagagtgattaaaattagtgaatcagattacgaaaatgttttcccgctcgcactta
-cgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattttggtataaaata
-ggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatg
-tagttggttataaaggttgtaatctcggagattaggttagggcttaatcagaatagtaac
-aatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatg
-cctggacaggataaacaatacgcatataacttgacgatcgagcttatatcgacctatttg
-agaagtttaacgggtcgatataatatacaggtcttaatagccgattttttctagaaaagc
-aatcctatatcttagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacat
-tgtatacaacattcctttttgtccgggtggggactccatttaaagtatctcacctagaac
-tcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgttgatacttagaa
-ttgctaaattttagtctagacatttccaggtaaaccggtagacgacaatttctctgtcat
-ctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctactatagacaatca
-tcagactttttaattaaatagttttccatgaatgtgttgtcaaggcggaccccttcactt
-ttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggg
-gaaatggaaaagaaattaggcttctaagatggactataatcgattaggctaattccgttc
-gcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtga
-atgtttaaaagtgctcgcacagaattacccaatacctatcatcacgacttaaatacccaa
-agcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaagggatactgggcg
-gggaaacctgctccttcacggtaacatggtaacaacagaatttggttaaggttaaaacga
-aatatactcggagtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtg
-aagacactcttatattagatctccgaaattctgacccgtgcattaggcacttggtaggag
-attccatttggaacttgctcaatgtaagccagtaatgttccgaaataattcgctgcagga
-gcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccg
-ttctctgcgtcaattccagagctggagatacattcatcaacgttacctacgcacagaata
-aaaagatcgagcgctaactcgttttcctaaacacaacggatttagacaaattaccgaatg
-cgccggagagtagcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcag
-gcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaagctatatattgt
-ggtcagaacttgaggacaactatgagctactaaaaataaacaattttgtcatttgttcta
-gatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataa
-acccgaatgagcgtaacattatcaataacatatagttcagatagagaacgaggtattcga
-cagagaattacccaacattggttattaatctatgcagaataatttagataatgtcactac
-ataatattaggaccaaaaggtgattccccagaagacaaaacaataaacaatctcacatat
-tcgctagtacctatgtatgggtatgatcttctgattggacggggataatttccaggtata
-ttaaaacttattaccataatctagacctaagagaggttatataagtaaagagctgtgttc
-cgatagaaaaacccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacct
-acgtaagggaatattctgtataaactgaaaagtcaggtgtaactacatgagtcatgtctt
-cgattaattacaatgcgatctcgttattctgatcaactaatatcataaactgccactaca
-tcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgcta
-tgctgatttaatcagattcataaaggaatacgaataactctggatccattaccacgcaag
-ggatttatttacggctgattactttttggctgttgacagaactgccatgaaagtaagatg
-tcgcatcttgcataaataatagcacctaatatagccgacaaagtgattccgataacagat
-tttaagttgtccagccttgagactccatgaagaccgcttgggagcttccccgtgattaga
-agaatctaaatcccaagtggatggggggagtttaaatctcagcaccaacaaatagtactt
-cctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgc
-gcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtacgacaaattttaa
-ctgatgtcggtatacggagaagaaggaagcacgcattgaagcagctacgcagaactgaga
-agatgacactctaagatacaattaatacaaaaacgttttaagcccaatctatcaacagat
-gtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtataataacagcttta
-tttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagt
-gttggctactctgtaaccgacgcgtccatccctctctcctagtgatccgtatatccaatt
-agaggataaccaacatctgcgttaccgacgaatttaaatttttcgactatttaattccgt
-tcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttg
-cagtgcatatgtagataccactaattgctgatctaggatacatgctttataaacatgctt
-acttggctattttatttactgtcatgtgggggtttttattttcaacaagtatgtgctacc
-attggataatctggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaa
-gtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaaaagaataattgg
-caaatacgaggctagccttcaaatttaatgcagattactcctcagaaacacacgtaagcg
-acgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgataatttttgttcca
-acctttgaatctagactgagtggaaaaagatttcaccgggataccgtttatgctggtttt
-aaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaatcatctgtacgt
-caactgttttaacaataacgtcagaataaaccggcacaatgagacggcggtctttcacta
-caccacacccttaggattataagtgacgtgtggattcgaattctaaggtgacgggatcta
-caagcctcagctacattaggtctgaagatctttcgtatagccgcgtatgttactgtttgg
-atatgggttatgctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatct
-ttacggttaccttttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaa
-actgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaa
-ctatcattgtggtcattaaggtattcaagattaactaagagtcgaccatatattctagag
-ttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtgga
-ctgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcg
-atacctcaatcgtagttttatcgggataaataacatggtgtttaaccctattaatggttt
-ctattaatctaaattgtaaggcagcccttgggtcgaaagcacattaggccacatacacag
-tatgaaattgttcgagtgtccagaccataattgactaccatggtacacggtgttgctatt
-atgactcccgcaaaactcttgacagagggaattttggtacattgatgtaatcgatgattt
-aacagtaggaactagacgtcatccgttagactgagttccgacatgctcaaattgtcagga
-tttttatccaataactaatggctctcacatgtaaataaaatcacattaacgtcacttagt
-gatggattcgctaaacagatagactatcattcatgaactggcactgtttcgattatattt
-gcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaaaaattcagtaca
-cctctaatgagtatcccgctttggaggaaagagtagcactttaaatggacaatttaggcc
-ggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcgttagggttagtc
-cttacatccaccatatgttaatgaataaagcctgagggaccttagagctaacttgtccaa
-cacgttgctcatttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagat
-tttgaccatttaactgaccttcacagttttgtcttcagacgtcacttacaccataatgat
-gacagagcttgtagatgcacacactcattcctagtgtaaatcaagtagtagctagattat
-tataaagagatattttctggcgtcgaacgtaacacagagagagtataaggggcatgataa
-tggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcaca
-cttatggccaactgaccttgggacgagttaagataccataagaggttgcctgtaagttaa
-gataacaaagggatattccatctttgtgtgctaagaacctatttatatttgcagccataa
-aaacctctgtgctatgcagccaccagagttatttatacaaagaaagagaccatttagata
-cgttaattctgcttgcgatttattaaacagacatttcacgtccaaccactacaaaagccc
-tatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcggccgaggaatca
-taaaatatgaattgttacattgtttactacatatgatcacaatctttgtaaaaggttcgt
-tcgtgatactaccatgtacctaactaacctgagatatatgcaatgacttatggggtcagc
-gcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctggatttcccaaggtt
-ataatgctctatactgaccaagagatccgttacgactcgcaatgaatactctaagggcac
-tcacaaagaaaaccactaattgataaatttcaatgataatatcctgaattgcatcgtgta
-tgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataa
-ttactatattttaacgatttaatcgtagttggagtcctttcccaaattatgtcatcagtt
-ccgatttagatgttttcgggcccttcttagtaaagaagttaatatccaagactagctcct
-cacccacgcatgcacatattcgcgagaagtctgatagaatattcgacagaaatgcgactc
-tagctcacactcgttaactgatcaggtacttatagacaagtacgttatcagatatcgctt
-cggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaa
-cgggaaaatgatattatttttttaggaggaataatacagtaccatgtaaatactcaacca
-ccttacgtacttcttacgccgaacatatatggcacgtgttattcggctaacaaaactgtt
-gtgccttttctataaggataagcagattcgttttaaacatatgacctgtaaactgggatc
-tacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcggatctttggttaa
-agagcaccattagatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaac
-cactcttgggatttaaaacaattcggttaggacacctactcggcggatgaagcaatacga
-taacattaaaagtcgttcagtctaattttggtcgtagtacgatgagctgatggccaattg
-tatttttattaacagcactgaaacaaaatggagactttagactaatactaaagtctcaat
-gttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgt
-atctcattattataacaccagtgtacagacgacatctaattatggccagaaactgtcatt
-gtgccattaagaggattagtagatagtctggaccgtggaatagaattttgaccaaattga
-ccagtcctgcttgtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgc
-ttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaat
-tcagtcttctagatccgctattccaacatcaatatctcaatttaaggtcaatatatataa
-caaaattagacagagcagctgacacttacgaagcatcgtagaaccgatatagtcgacctt
-atgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaat
-gaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagt
-attactgcgaaaaattcgtctactattagtttattatgaacttatgacgcttaaataaat
-taaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgc
-taaagattatcagaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatac
-atctatatagttagaggcttgcgtgttgttgtgctattccacatatagcagctctgggcg
-actcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaatt
-caaggggattaagtaccaagggtcgagtttctctgtatttattatactgtaggcaagaag
-cttttttggcgagatttaagacttaagcctatggtaaaaatttgatagtgagcgactata
-gtaagagatttgggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatct
-gagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaattt
-caaacatattggcggggcacttatccataatagatttctgtttgtacgccaaactctgcc
-tcacccctccataaattgtattggctagaggttaaattctccgtaaatagagacacatat
-agttttatacaattgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatg
-tcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaag
-aaaacacagattatacaaagagatctggatgaagatattcgtgcaatcactatcgttatg
-ttagagagttccatgcatgaggactcgttttttgaccaggagaattaagccaagaaataa
-ctgacgtatttccaaatgaattctacgtgtttttcctgtcacctttagccagtgttaaag
-atgactatggagtttcgaataggttattctatagacattataacgagtggaacacccata
-ccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaagggattttaggttct
-taatccaacgaagaaataacgcatcacccgtcattctattgttttcgtcgggattactta
-gtaggcagggtattctaacctacctgagttacaaatctttaaaaaactggccatgaggtc
-atggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgt
-ctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcagttttatagctat
-ctagtggcattcctttttataaaactttacgtttgtaagggtccaactttacaaaagctc
-ggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgtatattgacggcat
-ggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaat
-gtaaagccggggattagccgccaaaggggtctaatgacatagagatgctctgaaatcgta
-ccaactataaaagcacgggatttgaaatatagcgacagatcttccgtattctgttagttg
-acatctgtgctgtctttaccgattgtgatttggctttagcagtcatttagtttcgttact
-cattgctcgtgcgatagttccaccgaatatggcacattcgttctttttttccattttact
-gcaaaccttttcaaaagctgatcgataccactgatgatggcattgattagtcgattggca
-actatgtcctgcttatatctccaattgcattgaatatagtaaaaaataaaggctcgcctt
-cccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtaccta
-acatataagtgattgagacaaatagttctccagacgtattgagatatatgtctcctatag
-gcaagcgtttctaattgctgaccagaaattagaattaggttgttaatactatattcgacc
-attttattccacgaatgtgctattctactggtattgctccgtatgcgatatataaccaac
-acggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtcatttaccgggag
-cgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaaagacttccgctt
-actatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatc
-ttttcagttcgcagatttttgccaatttaaccggttatttcgtcagacttggtagtgtag
-ttacaagcatcacgattatatcagctacagaattaaactgtcctgactcgacggggcagt
-gtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtcatagtacaagga
-taatgaggtttgctaactttaaaaattattgatttaacggttgattgaaaatctctgcaa
-gatgacgctagaacacctgatgttcaagtttgccgataataacatataagatgaattact
-gtctttagaccctcatgttaatccgctaacttagggcggaaacaatgttaggctatgcgg
-agtaagtactatattatgataccacatagaatttaacattcatatgatgtctaatacccg
-ttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatcaatgggccaatcc
-tgtctcaaaaattatcatattcaaggttcagctattttggcaatgggtgagtaccgttct
-tagtgatttacgaacccataatctaggcgacttaatatacaagatttagagttacgtttt
-ccgggtagtacatattaacgaccatggatcgggtgaggtgttgtattagttatctgatct
-tgtcagtagctcccaatgtcccagaatattatgtttctactagagtgttcgtatactgga
-atttaaatattatgtaagactagacaaattttatggatacattaggccatcgtagaatat
-gatatagttgtaacgtccctctatagattttcggagggcaggtatattgcttaataaaga
-tgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgcttaaataagttt
-agactattaagctatatgttcgacagcatgtagttttttttaccagaaagtgttatactg
-atgacccatggaggtagctcctcatgataaaaatattgttacttaagcattactattata
-gtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtttcttatgcagac
-acacttttttagctgttgacgcccacctcacatccatagtaggtcaatcgcataagaaca
-atattctggactgttttattacccagaagaaagttttttctttccggttcgttaagacaa
-taaagatcatttcattcgttctcttaacgatgaactaaagtacttaaagtatccgcctct
-tgtttcgactagcgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcac
-gtcggagataactctaatagtctctttattccgtttaatatagcccgtaattgcaccatg
-cgctacagtaacggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaa
-tggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaag
-cagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccct
-cactactacgcgaaggtactcgattattccttgaatgggctgaaacatcgtgattagcgt
-cttatgattcaggctgatagaagaaaacttattttctatattccacgtatacaatcacac
-tcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaa
-ttcgtctgggtgcataagtacagttagtcgtctgtcacataaataatccgcagtcgatct
-cattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaaca
-gtaaaactaccgtcacacaaggaatatcataatagatgccatacacggttttacttgata
-tgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaa
-tttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatggatgagcatttagg
-tattctatgataacactaaccatcatgtttctaaaatcctcaggaaatttgtattatttt
-accaacctgtatttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaag
-gagtacctgattgaaagaatggggaattgtaatctgtaactcaattacaaataagccgtt
-ctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaattcatactcgatta
-acgactttaatactcttctgcgtatctacagactcatttaaattacggaatatgttttcg
-tttttggtttccagctcgcacgtacgcgtttacaaataaggacacctggtacaattggct
-ggagtacaatgttggtttttatttgctgattatcccgatccctgtgggcgttggcataac
-cgggttttcttcaagactactttcgtgttgcttatatacctggtaatatcggtgagtagc
-ttagggcttaatcacaatactaacaagttctctatggattggacagggcggcatccgttg
-actgaacgatctattaatccattccctgcactggataaacaagacccatttaaattgacc
-atagagatgttagcgtcatatttctgttcgtgatagggtacatatattataaacggatta
-tgagcagtggttttctagaaaagcattcatagttaggagtgtatcagatcataccactga
-accatagagcacaattctctactggctatacttcattcctttttgtccgggtggggacga
-aatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaac
-ggttctaaatgttcttaatgagaattgcgtattttgactattgacagggcatcgtaaacc
-gctactcgacttggtatctgtaatctgtatgtagatagagtacgggcctataattcaaat
-tcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtg
-gtgtcaagccccacccattctctgttatatccgagcattaatgtagtttcactgtactac
-ggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctgagaagtggcacta
-taatagtttagcctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcg
-aatagattgcgttcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaac
-tttcataacctctttatttaccaaacctgttctactagcgttagtgttttagtctgtagc
-cgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaa
-actattggcttaacgtttaatcgaatgagactagcactgtattactctttcgtttcggca
-gcggatcaataaggaggtgacggcatcactctcttatagtagatatcacttattctcaca
-acggaagtaggatcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaat
-gttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgc
-ttacagtatccttgaggctcaacgggctatgcggaaattccagacctcgagttacattat
-gaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttgtaatataaacaa
-ccgtttttgtctattttcccaaggagaaggagagtagcagcttagtggcttgcctatatg
-gccccctaagtacgtactcggcacgcttagaagattgggctaccccgcactatatgttcc
-caaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaa
-tatacaattttggcaggggttatacattgcgggcatgaagagtaacattggacatgaacg
-gacattcgaaccctgtgagtttaataccctatctccggatcattataaagtaaatatacg
-tcacttactctacgtgcgtttagacagtctttgaaactaaattggttatttttctttcat
-ctagatttgtctgtatctaactaaattatagttccacataaagctgattcaactgaagac
-ataaatataaactttctaacatagtagcgaggaaagagctatgcctagcatcggatcatg
-cgtccgcgagtagttcctggtagagttaaaagtttttccagaatctagaccgaacacagg
-gtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgt
-attgttgctgtatctatatttcctacgtaaggctatttgatctataatatgaaaagtcac
-gtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctccttagtatcatcaa
-attatagattttacggccacgaattattggtctagatgtcccaaaaataatttgatgtca
-gtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattatgctataccaaga
-actctccatccagtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttga
-cagatctgcatgcaaagtaacttgtaccagatggcttttataatagaaactaagtttccc
-gaataacggtgtacgataacagatttttaggtgtacagacgtctgactcaatgaacacac
-attgggacctgccccgggaggagtagtagataattaccttctccagcgcgggtcttttaa
-tatcacaacataaaaatactaattaatatcacacaccctcatcctcgatggagcctagca
-tcatacacgtttgatagacaacgccaattttactgtaatatgatattcgaatctagtatg
-tggacgctgtaccacattgtttaaaggagctccctttaccgacatgaacgaagcaagctt
-tgtacaagatacgaagaactcagtactggtaactataagagacaatttatacataaaagt
-gttaagaccattatataaaaagaggtatgaggtctttgtaactacaataatacattcatc
-gaacgatggagaataacagagttatttctgctgctcgagctctagttctgctaatttctc
-aatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcgtacatccctctc
-tcctactcttacctatatcctattactggttaacctacatctccgggaaagacgtaggta
-aagtggtccacgattgtattcacttataacacctagtagtactatgtgttgctgagagtg
-aggacacacttactctacgagttcaagtccatatggacattacactttttcagcatctag
-gtgtcatgatgtattaacagccgttaggggctatttgattttatcgattgtcggcgtgtg
-tattttcaacaactaggtgctacaattcgtgaataggcatgaaaattcaagattgcagtt
-cctatcttgtataatctttcctttggacgagttgtaccatttcaactaacctgcaagtgg
-ggggtcatccatatgaagatttgccaaatacctggagaccctgaaaagtttatccagatt
-aataataacaaacaaacctaagcgaagaacgtcagctttaataaactatcactatcatag
-aaattcctgttaattgttcttccaaacgttgaatagactatcacgggtaatagattgaac
-acggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgataactcaattatat
-tcgatggagaattcatatctaccgcttagcttttaaaaattaagtcagattattccgcca
-caatgagaaggcgcgagtgcactaatcaaatcacttaggattattacggacgtctgcatt
-acaatgctttggggtagggttatacaagcatatgattctttaggtctcttgatcgggcgt
-ttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtg
-tataggaatgcacaacgcaaatctttaagctgacctgttcatgaaagacaggagacacga
-ggcaccacctcaattctatgcaaaactctaacatagcgtggcactatgagtacgtgtaac
-gacaaggtctcatactcgatcctaagataattctcgtctggaaggttttaatctttaact
-aagagtagaacttagtttattgacttttacaattaggatacggttcgcgactctaccaca
-gggcatcatacctggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgg
-gtcctgcatctactgagcaatccctttaagcattcctagtttgagagccatttagatatt
-gctgtttaaaccgattaatggtttctattattataaagtgtaacgctcccattcgggaca
-ttgaaaattagcaataagacaatgtatgatattcggcgagtctcaacaacattatggtct
-accatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttc
-gttaagtgagggtatccaggtgttataaggacgatctagaagtattcaggtacacggtgt
-tcagacatgctctaattgtcaggttgtttataatttaacgtatcgctctctattctaaat
-aatataaaattaaccgctcgtagggatgctttccagtaaaagatacactatcattaaggt
-tatgcaaatgtggcgatttgatttgaatcttagtacattcttaaacttaaatacgtatta
-tttaaagtaaatatattatctaaaccgcttttgtctatccacatttcgtcgaatcacgac
-ctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatctatttcttctga
-ttgatgtaatactgacccttactccgtacatacaaatgatggtaagcaagaatgactgac
-gctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggat
-atggatgtgtatgccaggcttcattttgacaatttttctgtcctgctcagtgttgtctga
-agtcgtatcgtacacaataatgatgactctcattgtagatccaatcacgctttcctacgc
-taatgaaagttctagatagtgtaggtgttagacagaggttagcgcctacatccttacaca
-cacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtatttgtttggaata
-tcatatttctcccgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataa
-aataactgctgccctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatga
-aaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttat
-aaatacaaagagtacatttagttaccggattgcggcttgacatttattttacagaatttt
-atcggcaaaacacttcatatgaactatcgcttcacgataagtctatgatagactagcatt
-cgtagagaacaggaagagcaatcattatatatgaagtgttacagtgggtactacatatga
-gatcattaggtctatatccggccttcctcataagaccttggaaatatcttacatcagaga
-tatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacg
-taatagtctggttttaactaggggttattgatatttaagctaaaagagttccctgaacac
-tcgaaatgtataatctatcccaactaaaaaagtatacctctaattcagaaatgtcattga
-gattagactgatgtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaat
-tgaaatgtaatacctccatcttaagttctatattttaaagttttatgcggacttcgagta
-agtgcacaaatgatggcataagtgcccagttacatgtttgcggccccgtatgagtaatga
-tctgtttatcaatctctagctactatcccacgaatgcactgatgccagtcatggcgctta
-cattagtcgacagaaatccgacgatacctatcacgcgtgaactgttctggttcttattca
-attcgaagtgatctcagatacattacggccatgcttgcccttcatgtctgctgagcagtt
-ttgttataggctgaatctcctctaagcgaaattgataggatttttggtggtcgatttagt
-ctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaatgatagggatcg
-gctgaggaggataaatatacgctggtgcctggtatttatccagaacaagttgcctgtgta
-tcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaaggccgcaaaggg
-ttacatctcaggatcgtggcgtatagtccaccattagttctgacttacttaatatagact
-gaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaac
-gtataggagcatgatcaaagaagagttaattaatagtactgcactataattgtcggcgga
-gtaccatgagctgttgcccaattcgatgtttattaacagcacgcataaaaaatccagact
-tttcaattagaattaactataaatggtccgcgaaccttaaatgatcggaaggacgggatc
-tgccgttgtatagaccccaactctatctaatttttataacacctctgtaatcaacaaatc
-ttattatgccatcattatgtcattcgccaagtaagtccagttcgagattctctggaccgt
-gcaatagtattgtcaaattatggtaatggaatccttcttctaacacccttagaaaagcca
-cgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgccgtttctttttac
-gatgatagggattcttaaagcttttctctattctagatcccagttgccatcatcaatatc
-tcaattgatgctcattatatagttcttatttagtatgtccagatgtcactgaagatcctg
-cctagaaccgatattctcgacaggatcatcagttcgacggggcaaacgcacctatgcaca
-tccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaact
-cctgtccacgatatgtaggcaagttttactgcctttaattagtagtcgattagtgtagtt
-tgatattatctaccttatagaatgtaaacagtaacccggccttaatggtttggcaggatt
-ctttgtaaaagttaataatgttcataaactttatcagaaaacctgaagtagtccgccttt
-cgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgtcttgttgtccga
-gtacacatattgctcctctcccccactcttctaggaaaatcaattatgctaacctgcaga
-ccttcttctttactatctttaatgcatgcccagtatgttcatagggtagacttgctatct
-attttgtataatctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggt
-ataatttgagagggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataa
-taggattaagcaggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaag
-tatgactgtgcagtattaattttgaatacatattgcagcccctaggatacattatagatg
-tctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaa
-ttagccggaattacagacacagattcttgtttacaattgtgggaagaaaaccacctcaaa
-cgttgaaacctacattcacaaatggattacgttggggatgagaatcgattccggtcaaaa
-atcatgcccggagcaataaccaagaattcacagaggattaatacacttctccatgaagat
-aggactgcttgcactatccttatctttgtgtcttccttcaagcaccaatcgtttggggac
-aaccacaattatgccaagaaataacggaaggtgttccaaatctatgagtccgcggtttca
-tcgcaacgtttcactgtgggtatcatgactttggactttagatttgggtattctagagac
-tgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcac
-gttgtgctagggatgtttccttaggaatccatacatgtaagaaagaatcaaccgtaatta
-tagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatag
-attgaatattctggacagcagcgaatcctgattatatctcaagcgaatatatgacccgca
-agaaggatttatactagaataagtctaagaaagggcattgggtcacttcttccactaaca
-cacttttatcagttttataccttgagagtcccatgcatttttatatatatttaactttcg
-ttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgt
-cgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttag
-ctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatc
-aaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaa
-agtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatt
-taccagtcttttagtttcggtactatttgatcgggacattcgtccaaacatgatggctca
-ttcgttctttttttcaattttaatcaaaaccttgtatttacctgatacattaaactgagc
-atcgcatggaggtggagattcccatatatgtaatcatttgatatcctattccattctttt
-tagttataaataaacgctccactgcacaatgggagtaggacttcaccaataattagcatc
-tactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaac
-ttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaatt
-acggtcgtattacttgttgccaaatggttattactccaatgggctattctaatccgatgg
-atacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaa
-gctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattg
-ttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaatttgttatgtcc
-agtcgctcgtatatcaaaagattcggttaagttcgcagagttttgccaagtttacaggtg
-atttactaacacttgggagggtacgtacaaccatcacctggttagcagagaatgaattat
-acggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgca
-ggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttt
-tccgttgagtgataatagctgcaacatgaagatagtaaaactgaggttaaactttcacca
-tattaaattatatgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcg
-cgcttaatatgggtccctatcccgactttgtacgagattttgataaaaaatagtattgta
-aattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgcta
-tttccctaagaaagcggaaaatcctggctcaatatttataatagtaatggttaagattgt
-ggcccaatcgctgagtacccgtcttacgctttttccaacacataatcgacgagaatgtat
-ttaaatgtttgagacttacgttttccgcgtacttattattaaagtcattggagagggtgt
-cgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatctattggttgttt
-ctaattctgtcgtccgtgtaggctatttaatttttatggtacacttgaatatgtttagcc
-ataatgtagccaatactacaatatcagatacttgtatacgacctatagacttttgccgac
-cgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaag
-catgcgaagcgagtatttaactgttgactattttgctatatgttactctgaatgttgttt
-tttttaccagaatgtgttataatgatcaaccatgcacgttcctactaatcatataaattt
-tgttacgtaagcttttctatgatagtggtctaaagactacccttgcatactttaagatta
-agacatgcactttaggaggaactcacacgttttgagctgttctagcccacctataagcca
-ttcgtccgcaatcccataactacaatagtcggcaatcttttattacccagaactaacgtt
-tttatttcccggtacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacg
-aaagttatttatgtttaagccgcttcttgagaatacagattactgttagaatgaaggcat
-cataactagaacaccaacgcgcacctcgcacattactctaatagtagctttattcagttt
-aatatagacagtatttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttat
-gttattccatgtggtcggaggatttgcggggcgatagcgctgggcggggatcaacaattt
-cgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcac
-tcgctagaagtgttacaatcacatcacttcgtaccgaagggactactgtattccgtcttg
-gggatgtaacagactgattacagtcttatgatgaagcctcattcatctaaaattagttga
-tttattccacggatactatcacactcctatagaaagagttaccaccgtgggaagctagat
-ataataaataaaagacatacaatattagtatggctcatgatctacacttactcggatctc
-tctttttttataaccagtagatcgcattacacgtattgttgttccgcatcaggccctagg
-ggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaagatattaataga
-tgaaatacacgggtttacttgatttctgttcagtcattcacgggaaatcctaggagtctt
-tcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattgg
-tatttcctggcatcacaatttacctagtattggagatcacttaaaataatgttgagataa
-taatcaggatatttctagtatgtgacaaacctctatttagtgattgtgattttcaattaa
-acaagacgtaggggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatc
-taactcatgtactaagaagaagtgctttcgtttaaggctttctgtctaacattctaacgt
-caattcctatgtaatactactgtaaccaagttattactcggctgcgtagataaagtctca
-tgtaaatgacggtttatctgttacttttgggtttcaacctagctaggacgccggtactaa
-ttacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgtccggattataac
-catccctctcccacttggaatatcaccgggttcttaatgacttagttcgtcttccttatt
-ttccgggtaagatcgctgtggaccggacccattttgatctagtctaaaaaggtatatagc
-gtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgcactgcactggat
-taacaagaacatgttatagtgtactgacacatgttagactaagaggtctgttcgggttag
-ccgacttatatgtttaaccgattttgacaactgggttgagagataacaatgaagagtgag
-gactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatt
-taattgttctaaccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtatt
-gttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtg
-actattgacagggaatcctaaaaagctactcgaattggtatatggaagaggtatgtactg
-agaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagcttaactagtttga
-tggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatgggatatcccaga
-atttatcgactttcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaac
-ttttgaggatgagtactgccactattatactgtaccatttgtaacttacattttatatct
-tcaaagaggtagatattgtcggccattactgtcacttacactaagggtagcttgattact
-gatacctctcatggtaaaaagtaatttaagaacctatttttttacataacctctgctact
-accgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcag
-aaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcctatgagaatacca
-ctcttggaatcggtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggt
-taggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgcca
-aatgcagaaatcttacactcttttcttaactaagtatgagagcaacctcactcctgaaca
-gcttgttacctaacgagaagaggctttaagtagcctggagcctcaaccggatatccggat
-ttgactctcatccacttacatgatgattacggtcattacatctcatgattttctgagtgc
-cctatagactgggaatttaatctaccctgtttctatttgttaacaaggagaaccactggt
-caagatgacgcgcttccatttatgccaccataagtaagttctcggaacccttacatgatt
-ggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtggcctatcatattc
-aggtcatcgagctcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatg
-gaagactaacattggaaatcaacggaattgacaacacgctcactttaataacctatctca
-ggataagtttaatgtaattagacggaactttctctaactccgtgtactaactctttgaaa
-ataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaaagtattggtcca
-aataatcctcagtaaaatcaagtcataaatataaaatttagatcttaggacagaggaaag
-tgctttcccgagcataggatctggcctacgccagtagttcatgcttgtgttaaaagttgt
-tactgtttatagtccgtactcagggtagtgttcgatactcagcggggaactgacatatta
-cactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaattacttacgctat
-ttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaa
-ttcacagatactgtgtatcatattattatagatgttaaggcatagaattattggtattga
-tgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagtgcagcttggaag
-aactggatgtatcctataactagtaagagccttaaaggtactacatacccagggatgtta
-ccatcattaatttggccatcttcaatcttcgcaatgcatactttcttctacaagatgcct
-tttagaagacaaaataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaa
-tcaagtctcactaaagcaactaacattccgacatgcaaacgcaggactactagattatta
-aattcgccagcccgcctcgtttaatataacatcataaaaattctaagtaatatctcacac
-actaatccgccatcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcg
-atgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaaagctgctacctt
-gaacgacatcaaccatcctacctttgtacaacagaccaacatctctgtactggtaaatag
-atctgaaaagttataaatataactgttttcacattgatagaaaaacagctatgtgctatt
-tgtatatactataataaattaagcgaaacatggagattaaaacagtgttttctcatcctc
-cacctcttgttctgctaatttataattcttgatgccactcgtgtgagtcgtccattcgat
-cgtaaagaacccgacataaatagatacgacgctgaacgagatcctatttctcctgaaaat
-tattagcacggtaactcctagggatagtggtactagttggtatgaacgtataaaaacttg
-tactactttctcgggatgtgagggagcaaactattactcgaccagtgcaacgcattatcg
-acagtaaaagttttcagctgatacctgtctggatggattatatgcaggtaggcgagagtg
-gattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttag
-ccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcatttcgtccactggta
-ccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgcaatagtactcca
-gaccatgaaatggttatccagattaataataacttaatatactttcactacatactcagc
-gggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagag
-tctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtag
-aatatgatgttaaatcatttatattccagggagattgaatagcttacgattagctggtat
-aatttaactcacatgattaagcaaatatctgtaggaccgagggaaagaataaaataaagt
-accatgagttcggaacgctgcattacatggcgttgggctagcctgatacaagaagatgag
-tatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagc
-agatgattatcgtctaacactgtctttaccaatgcacaacgcatagatttaacctgaact
-gttctggattcactcctgactacagcctacaactcatttctatgcataactcttaaagac
-agtcgcaatatcagtacctctatacacatcggatcagactagatcataagataagtctcc
-tctggatccttgtattctgttaagtacactacaaatttgtttagtgtctgggacaattac
-gataagggtcgcgactagaccacagggcatatgacctccaccgctcctagcgagtctcca
-atctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttac
-gagggtgagacccatttagatatgcctcgtttaaccgttttaggcttgataggatgagtt
-tgtcgatccatcaaattcccgacattcatattgtccaataagtatatctagcttattcgg
-actcgctaaactaaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaa
-attatagtcaatctcccatggggccttatggcagcgtatacagctggtataacgaccata
-tacaactatgaacggactagctgtgaactaagcagattattggatccttgtgtataattt
-taagtttcgatctatatgctatagtatagaaaatgttccgatcgtacgcttcctttacag
-ttaaacagtctatatcatgaagcttatccaaagctggacatttgatggcaatcttactta
-attatgaaacttaattacctattattgaaagtatttatatgatcgaataagatttgctct
-ataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaacctaggtaatct
-aaagcctgcatctatttcttatcattcatgttatactgacccgttctcagtacttaaaaa
-tgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaataaactgccgatg
-ggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggt
-tatctacggataactgtgcgatgaactactataggtcaaaattatcttcaatctcattct
-agatcatataaagatgtccttcgcgattgatacgtctacagtgtgttggtgttacacaga
-gggtagcgactacttacttactaactctctcttgatccgcaagcataagccaggttaaag
-tgctctatctttttctgtggattataatagttataccgccttgcatctaggtgcccatta
-ggtaatgccctagtgttttcataaatttactcctgccatctaacgttactttaatttccc
-agattcaataggtctctcatttgaaaattgttatatgtcaacaaagaatataatagctga
-gtggaacaatacactgtgagggagtaatacatactctaaattttctttacggtttgcgcc
-tgcacagttttttttatctatgtgatccgcataaaaagtaatttcaacgttccattcaag
-ttaagtcttggtgacactagcattaggagagatcaccaagaccattatttatttagctag
-ggtttaagtcggttagaaatatcagataatgaggtctttatccggccttacgcagtagaa
-attggaaatttcgtaaagcactgagttcaatggaagtatggccgaacccacataatgcac
-aaatcaagtcgatttcttccgtccttttagtctcctgggaactacgggttattcatagtt
-aagctaaatcagttaacggaactagacaaatgtataatagttcccaaatatatatctata
-aatcttatgcagttagggaatgcagatttgaatcatggcaatacgctagctcggaactca
-actacaagtgttggatgtacgaattcaaaggtattacatccttatgatgttcttttttgg
-atacttttatgacgacttccacgaagtgaaattatgttcgaatatctgaacagttacttg
-gttgagcccaaggatgacgaatgttctgtttataattctcgtcataatataaatacaagc
-atatgaggccagtcatggagctttcatttggactaacatttccgtagagtcatatcacgc
-ctgtaatctgatccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgt
-gacattcatggctcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtt
-tggattgtgggtcctccattttgtctgttaatgcttattaagattaaaaatgtactacgt
-atttagacctaatgattgcgatacgctgtggaccattaatataagctgcgccaggggatt
-tttccagatcatctggcctgtgtatatgttcaaatctaatagccgagagaaattactccg
-acggaaaataaaggcagataagcgtttcagagcaccatcgtggcgtttagtcaaccttta
-gttcggaatttattaatatacaatctcactctttggacgagctccttaaaagatgccctt
-gtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatac
-gactgctctataattgtccgaggagtaccttctcatctgccaatagtcgttgggttggaa
-aacaacgcattaatatgccacacttgtcaattagaagtttctataaaggggacgagtaac
-tgatttgagacctagcacggcagaggacgttcgtgtgacaacatctctttataagtttga
-gataaaatcgctaatctacaatgattatttgccaatcattatcgaatgcgcaaagtatct
-cctgttcgtgattctagcctaaggccattactatggtcaaattatgctaatcgaagcagt
-cttctaacacccttagaaaagcaaacactattgaatactgccgccgcattcgccagcacc
-aacataactgcacgtgcttttttccatgattggcattatgaaagatttgatctatgattc
-ttaccagttgcaatattcaatttagcatgtgttcctaattattgtgttattatggtctat
-ctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcaggatcatcagttcc
-tcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgt
-accgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttt
-tatgaggagtcgagtactgttggttcatatttgctacatgattgtatgtaataacgatcc
-cgccctttatcggttcgatcctttatggcgataagttatgaatcgtcagtatctttagat
-caaaaactcaactagtacccagttccccggaggaacggtcatgattaatgcgttttacgg
-tctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccactcgatgattggt
-atagctatttgccgaaaagccacaacgtattcggtactatcttgtttgattcccctgtat
-cttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgaca
-cttgttacaattatccagttgcgtttaatggctgtgggtcacaagattgttagacaggtc
-ccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagctcacccgcctaag
-tgatccaaccctcatcaggataactatcactgggcagtattatttttgatttcatatgcc
-accccctaggagactgtagtcatgtatctttcttacccaatctagcccgaaacaagaaag
-aatgtcgattccagtcaccttttattagaccgatttacacacaaagtgtcttggtttaaa
-ggctggcatgaatacatactcaaaagttgaaaacgacttgctctattcgattaccttcgc
-gatctcaatcgattacgctaaattttaatgcccgctgaaatatccaacatttaaaacagg
-attaattctctgatccatgaacttaggactcattgcacgtgacttatctttctctcttaa
-ttcatgctccaatacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgtta
-ataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggac
-ggtacatttcggttttatagactatgtagttacacggcatcaacatgtaattaaaacggc
-gtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggaggattacatacat
-ctaagaaacattctaaactatgtatagtcgtttacgacccttgtagtacgtgcatccctt
-ggcgaaaagtactctgggtattagagtgtatattatcgacagcaccgaatcctcatttta
-tagcttgacaatttatgacccgaaagaaccttttataagtctataagtatatctaacgca
-attgcggcactgagtccactaactatctttgagcagtgttatacagtgagacgccatgga
-aggggtttatatattttactgtcgttccctaaaaagttaattatcagacctgcgcgatct
-cgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatc
-aaccgtttctgcggatcgcgttacattccttgcttatttgcgataaatcgatacaacccc
-attaccagaaaaacccggagaatcaattactctgcagatcttatactaaaaaagagatta
-caacccctgttctatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagc
-gattttaactttcgcttttccattttccagtattgtactttacgttatatttgagcggca
-cattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaatcaaataattgta
-ttttcagctgactttaaaatctgcagccattggaggtggagattccaatagatgtaagca
-ggtgatatcatatgcaattcttgtgacttattaagataccagacacggcacaatcgcagt
-agcacgtaaacaataatgacaatcgacggttaaattccgaacgtaagatatgtttacgga
-tgcactaaaataggtagcaacaacgtttctctgagatgtataagttaccaaacactggag
-aattccgctaaactaaggacaatttccgtcgtattaattgttgacaaatggttagtaata
-cattcgcagtggataatccgttgcatacctagcactgagtgtaaataaaaccaatcgact
-actggcatttcgggctaacgactagatgttagcctatgtgaaagcctcacacatgcttat
-tgccttcacggtgagcaatgtttcttattcgttattagaagtcacctgtagagacagtag
-agatgacctaaatttggtttgtccagtcccgaggtgatctaatgattaggttaacttaga
-acagtggtcaattggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaa
-actggtgagaacagtatgatgtattcggtcatctagacaaccccatcgctgggagtttgg
-acagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccgggg
-agatagggttaatttaggcttttttacggtgtggcatattagctcaaacatcaacattct
-taaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaa
-taagcttaataagatttaggtccgaccttaatttcggtccatagcacctctttctaagtg
-ttttgcttaaataattgtattgttattgattttctgcgagttgaacacggaaaataagtc
-aaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttt
-tagattagtaatcgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttcc
-aaaaaattttagtccactaggtatttaaatgttggacactgaacgtggaagccgtcgtat
-tatgaaactaatggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcaga
-aaaaggtaaatcttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtt
-tggttcaagtgaatttgtttagccagaatggaccaattacgtcattagctgttacgtcta
-tacgaaatatagactgtggacgacccatcgtagagtcatgtagttacatgtgaccttaga
-acaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactggtcaattggttca
-tagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcct
-ccttcctaataatcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaaga
-cgaaacggccttaatgtaacattaactattccactgtaggtggatctaacaaggttggac
-atgtgctaccaataagataagaatttcgtccgcaatacaatatctacttttgtagcctat
-cttggattaacaacaacttacgttggtatttcaccggacgtatcaaatgattctgatttt
-aatgactgagagtaaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtc
-acattactgttagaatgaacgcttcattactacaaaacctaccaccaactcccacattaa
-tattatactagatgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgtta
-cgaacacgtacattaaattgttagggtattaattgtggtcggtgcatttccggccccata
-gcgctccgcggggagaaactatggccttcatgacagcccccccataacatctaggtaatg
-gtcggataactataaacaaccctctccagagaactgtgaaaataaaatctcttagtacac
-aagcgtatactggtttaagtcttgcccatcttaaagactcttttcactattttcttgatg
-cctcattcttctaatattaggtgattttttaatccgagaatataaaaagacgatagaaag
-tgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttttgactatccctc
-atgatctaaacttacgcggagctatctttttgtataacatgtacagagaattaatccgat
-gcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaac
-gcactataccaagtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtca
-tgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagct
-cgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtccgaggattgctga
-taacttaaaataaggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtt
-tgtgtgtttgtcattttcaagttatcaagaactacgggtataatttacgacgtaatgttg
-gtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactgctttcctttatc
-gattgctcgagaacattataaagtctattactatggattaagactgtatacaagtgttta
-agcggagcccgtgataatctataaggttttggtacctttatctgttacttttgccttgaa
-acatacatacgtacacgggaatatttacctaaacgccgtatagtccagcctcgtatttgg
-gccgtgttttgtcagcattttaaactgaaagcgcccacttgcattataacccggtgcgga
-atctcttagtgactcgtcaggagtttacgcctttgagacctctcgacaggacccattttg
-atctagtcgttataggtagagtgcctttcctatcgcaccattaccttctagcaaacttag
-agtattcaatgaaatcatatcctgtttatactaaatgttataggctaatgacacagctga
-cactaagaggtctcttcgggttacccgaatgagttgtttatacgatgttgacaactcggg
-ggagtcatttcaatgaagactgaggactcttgatcagattaaaacgcttaatgactgata
-atttagattatgccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctg
-agaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcg
-gctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactatt
-cctagagcgaagagctatgttctgacacgtccccaatattaggcaaaggctccaaaagaa
-cagtcaattgattaactacgggcttggtttctccgtgaatccttgcgccgctataccaca
-taaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagta
-cactagcaaccccttagcaattaattttgtccatcactactgccaagagttgactggacc
-agttggaaatgacatttgatatattaatagagctacatattgtaccactttactgtcact
-tacactaaccctagcgtgattactcatacatatattcgtaaattctaagttatgatacta
-gttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttcaactaaatatttc
-actgtagccaaccactttaaccagaaggataccttaatgccgatataatattgtccagga
-aacgttaatactttcacaagacaaagcttggaagaggtactttacgatcacctgatagat
-cgaccggaacgattctatataggtttggtctgagaaatttgtagctaaaaccatgttcca
-taggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatcta
-tcacagcatcctaactcctcaacagcttctttcctaaagacatcagcaggtaagttgacg
-gcacccgataacccagagcacgattggaatctaatactctgtatggatcattacgctaag
-taaatataatgattttctgactcaaagttacactgcgaattttatattaactggttctat
-ttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatcta
-acttataccaaccattacttctggcgcagaaaaacatagatatctgaacaatcgaccgtt
-aagactgtctcgccgatcttaggaacctaatactgctcagtagttattgtttatttgggc
-catccccggattatgtcagccatggaacactaaaagtcctaatctaacctatggacaaaa
-agctcacttttataaaattgctcaccttatgttgattgttatttgtccgaaatgtctata
-actcagtgtactatctattggaaaattatggccggagttttattgaatatacttttgtat
-gttgagaaagaatgttgtcgtaataattatcagctggaaaatcatctaatatatattata
-ttgagatattacgacagacctaagtgctttcccgtcatgagcagatggactaacactctt
-ggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcccgactcttactt
-actcagagcggaaatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggt
-tatttttttaattacgtacccttgtgcagagagtttagctattcgatcctacttagtatg
-aaccatgagagtacaggttggtaattcacagagaaggtcgagaagattatttttgatgtt
-taccaatactatgaggcgtattcatcgaaataattttatggctgcgcacttcacatacgc
-aggaagaccactgcagcttgctagatctggatgtatcattgtacttctaagagcctgaaa
-ggtaatacattcccagcgagcgtaacagattgtatggggacatattcaatcttagcaatg
-cattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaactataaccctgg
-aactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagca
-aaacccaccactacttcagttttaaattagaatcacaccctagggtattagataataatt
-aaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaataagtctccggt
-ctttcacaaacacatggttaagcgatgtggttttgactagagacgttcgccaccatcgta
-atatttctggttacctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagta
-caacttatctcttatcctatagagatctcaaaagtttgtatttttactggtttcaaattg
-agagaaaaactgcgttctccgatttctatattattgtttaaatgatgccaaacatccagt
-ttaaaacacggtgtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaa
-actacggtcacgcgtacattacagagtaaactacacgaatgaaagagataagaagatgaa
-agagttaataggtctcctgttaattatgagaaccctaactactacggattggcctactag
-tgggttggaacggatataaaattcgactaagttcgcggcatgtcaggctcctaaatatga
-agagaactcggcatcgaattatccacagtaatagttggaacatgattcctctatgcatgg
-tgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatatt
-cttcctcagaaaaggactgttgagcaaggaattggattctgtgaacggaatatagtcgag
-tagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacat
-atcttcttggcaattagtactccactaaatcaattggttataaacttttagaatatcttt
-atataagttcactacttacgctgcgggtagtatatttaaagtgatgtcttaggaatctta
-tggcggcggaataaacggcttgactatagataccctaattctggcataaccctgtaacgt
-gtgaagcatgctttaatagacgactagatcagcttatagaatggatatgactgccacatt
-gaagagattaacattagcgggtataatgttacgaacttgtttaacaaaatagctctacca
-cacacgcatagtataatataaaggtcctggagttcgctacgagcctggaattgcagttcc
-cctaccctgagtaaacaagatcagtatggacctatcttctgacccacgtgtaaaaactac
-cgttagcggccctgagaacggtgaagttgattatcggctaacactcgctttaccaaggaa
-caaacaattgatggaacaggtaagcggctggattctatcctgaatacagcataataatat
-ttgctttcaatatatagttatgacactcccaatatcactaactctttacaaatcggatat
-gaagagtgaattagagatggagccgatcgttccttgtattctggtaagtactcgactaat
-gtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaa
-tcctccgagcatagagactctaaattcgccaagcaataagtcccgacgcgaaggatgaga
-agctcattgaactgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaa
-gtttttgcctggagtggttgagtttcgcgatacataaaaggccccactttcatatggtca
-aatatctatatcgtgctttggacgactcgataaactaaagtagcctagtaatgccctaaa
-ccgctgcatttgtgcaataaaaaatttagagtatatataacttccggacgtatggctgcc
-ttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcggaactatgcaga
-ttaggcgatccttgggttgaatttttagtttccatagatatgagttagttttgatatggt
-taccatacgtccctgcattgaaacttaatctgtatattgattgatccttagcaatagcgg
-cacatttctgggcaatatgacttaattaggttacggtttttactatgatggatacgtttt
-atatgatagaataacagttgctatttaaacaggtactacattcaactaatactgtttcac
-tattgtgtccaacatagggaatatattgcctgaatagatgtattatcaggcatcttttac
-gctccaggtagaactaattaaaaatgatccttagaaactttcaagcaacataagctaaaa
-gttacgccaattataagccacatcggtaggatcttcaggcattcccatatccttctctat
-caatcccgtctgttgctaattggttatctaagcatatcgcggcgagcatctacgataggt
-ataaagttgctgctatctaattcgtcataatatatacatggaattacagattcatacgtc
-ttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatatctctctcgtgtt
-acccaagaagttgacacgtgattgtcagctatctttttctggcgatgttaatagttataa
-acaattgcatatagctgcaaattagctaatcaaatactcgtttcttaaatgttatcagca
-aagctttaggttctgtaatttcactgtgtaaagagggcgctaagttcaaaattggttttt
-ggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctc
-taattggtctttacggttggaccaggcaatgggttttttatctatgtgataccaattaaa
-agtaatttcaaagtgacattaaacttaagtattgctgtcaagaccattacgacacttcac
-caacacatttatgtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgc
-gttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaag
-gtgcccacatcacacattatcaacatatcatgtcgttgtattacgtccttttactagcct
-gggaaataccggtgattcagagtgaacataaatctctgaaagctactagacaaagctagt
-atagttaaaatatatatttcttttaatattaggatctttgcgattgcacatttcaagcat
-cgcattaacctacctccgtactcttctacaacggttgcatgtacgatttctatgcgatga
-aatacttatgttcttagtttggggttactttgttcacctagtcctcgaacgcaaattagc
-ttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataat
-tatagtcagaagataaatacatgcatatctggacactcttccacatgtcatgtcgactaa
-ctttgaactacagtcatatatagactgttatctgatccgtatgtgtctattactactctt
-atctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcggggctttttccct
-gattataagattacactattgctgtgcttggggcctcctactttttctatcttaatcatt
-ttgtacattaaaaagctaagaagtaggtacaacttatctttcccatacgagctggaccat
-taatttaacagccgcaaggcgagttttaatgttaatctggaagggctttatgttctaagc
-ttttagcactgagaaattaatccgtaggaaattaatcccacataacccggtaagagaacc
-ttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcg
-acgagctccttaatacaggccctgcgttatattcgaccgtacctataactagaccaccat
-cttaaatgtacagttatggttttcgacgcatagagtatgggaccacctcgaaatgctcag
-ctgcaaattgtactgggggtggttatcaaacatttaatatgaatctatggtaaagtacta
-gtttatagatagccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgt
-cacaaattagattgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaat
-atttatcgattgcccaatcgttctactcgtactctttatagcctaacgccttttcttggc
-gctaattagcctaatccaagaaggagtctaacaaaattacttaaccatactcttgtctat
-tcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccag
-gaggtaacattggatctatgagtcttaacagtggaaatatgatttttagattgtgttcag
-atttattgtcttattttggtctatctcatcagctatagctacataatgacgtcttaactg
-tttcgactaaccttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaa
-cgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacag
-atctaccattcgtggaatcaatttttggacgagtactggtcgggtcgtgcttatttgcta
-caggattgtttcgtataacgttcaagcactttagcggttccatccttgatggcgttaact
-gatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaa
-cgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtc
-atcagagacaaatagatgattcctatagctttttgcagttaagccactaagtaggcggtt
-ctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtat
-agaccattcttcaggcccgccacaatggtttcaagtttcaacttccgtttattggctgtc
-cctcaatagagtcgttctcagggcacgactctcgttcgttattcataagtccagtttgat
-ccacgaatacagaacacgcatatctgataataaaagcttaacgataactttcacgcgcat
-ggtttatttttgatttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaa
-aatttagacaaacataaaacaaagtatcgccattacagtctcctgttaggagaacctttt
-tatcaatatgtgtaggcgtgtattggcgcccttgatttaataataattacggctaaacgt
-attgatattttccaggaactgccccatctcatgagatgaccctaaattttattcacacct
-catttttaattcttttatatcacgattatttatctgagcaagcatctttgcaagcattca
-tagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgctaaacatattggtt
-caattcaatgtaagctacctcggaatttgcttgcactaagacggggaagccaaaacggta
-aatcgccgtatatgctagtgccaagggacttgtccgttggagtcactatggagttacaag
-cattataaatctaaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccc
-tggggtacggaccatgaaatacttctttcatacatgataaacgatggagactcggttacc
-accctggtagttactccatcaattggagttaactaagatcgctattacaggctttattag
-ccaatcatcacaagcctctttttagagattcacaagttagcaaaccaaagttcctttgat
-aagtctttaacgagatctatcccaattccggctaggagtaaaatttatatatttgagatc
-ggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtccttccctaattag
-gtaattttcagacctccgagagagagtagatcaacaacgcgttatactcctaaaatgctt
-gtcgataacatgacactacagatcatccctggatgagcatcgactttcattacttgatta
-gttcagttaattcgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgca
-catcttagactaaataacagttttcataccctgggatttgtgtcactatctcaggaacgt
-cgagacgtcccctatcaccgcagcgagggtaactggccctgttccattgtaatcgatggg
-acgggacgttatattgcagacccaaagtagtaataaattcagccatatggacggaggggg
-ggaattgttaagaatataattcgattttcagctgaatgtaaaagctccagccattcctcc
-tccacttgacattagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgt
-ttccagacaaggaaatagcccagtaccaagtataatattatgacaatagaagcttaaatt
-cacaacgtaacatatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgt
-gcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagttcccgactatga
-agtcttcacaaatggttagtaataatttcccagtggagtagaagtggcataacgtgcact
-ctctgttaataatacctttagactactcccatttcgccagaacgtcttgatggtacccta
-tgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatt
-tctacgaacagctagtgaaaggactgatgacctaattttggtttctcaagtccagacgtg
-atattttgatgaccgtatctgacatctctgggcaattcggttaacctctggtacgaaata
-gtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttttagctaagctac
-actaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacga
-attcctaatactcttgctcagggcacttagggttattgtagcctgtgttaccgtctcgca
-tattagatcattaatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgt
-tctgataggtagacagctaataaagatgctgttgaacagttacgtcccacctttattgcc
-ctacagtgaaactagttcttactctgttgctgtaatatgtctagggttattgatttgctg
-ccacttcaaaacggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaa
-tccccaattgaagccagaaattttgagatgtcgattcctgatcattcgccaaatttacag
-ctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggct
-caaggtacgtggaacacgtagtattttgatactaatgccagacccgctacgatccctgta
-ctgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgac
-tacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaa
-tgacgtcttttgatctgacggcgttaacaaagatactctgggcaacacacatacttctct
-catgttgtttcttcggacctttcataacctttcctggcacatggttagctgcacatcaca
-ggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggtggtgttaatcta
-tctcggtgtagcttataaatgcatccgtaagaatattatgtttatttgtcggtacgttca
-tggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaagg
-taggtccatctatatacgttgcacagcggatacaaataagataagaatttactaacattt
-aaattttcttattgtcgagcatagattggaggaaaaacttatttacttggtatttaaacg
-gaagtttctaatgtttatgattggatgcacggacagtttactgcttactttcttaggttt
-cttgaacaacaggatgcactagtaacatgtctcgttcatgcttccattaagttcttctta
-aacttacacaaactacctaatttagagttgacgagatggttgaacgtgttgtgacaaacg
-tttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattct
-gctacgtccattgcaggccacattcacatcccacccctgaatatatggactgaatcacac
-acaccaaatttcatctaccttatcgtagcataactattaacaaacatatacagacttcgc
-ggtaaataaaatatattagtacacaaccgtatactggttgaactattgcccagctttaag
-acgcttttaactaggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacc
-tgaatagatatagacgttagattgtctgaaaacacgccgtagagacatttttgttagata
-tgtatttctttttgacgagccagcatcttagtatctgaagacgagctatatgtttgtaga
-aaatcgactgacattgtatacgaggcggcgtaagattaaccaaattccccagaattagta
-atggcgccttatcgatttactaacgatatataacttgtgatgttgtctgcaatgtatacc
-cgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccacc
-gcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgctatgtaatccat
-tctaatgggtaagaggattcctcttatagtaaaatatgcttgactttttaagaaccattg
-ggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttttctacaactacc
-cctattaggttacaagtaatctggctttcttgccacttggcgatgatagttagattcgta
-tttctacaacgcagttactgtatccatggcgcgagataattagatacgatttgaatttgg
-atgtagactcgttactactgttgtagaccagcacgtgagtatctagatgggtttgctacc
-ttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatattttactataagc
-agtattggccaccctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaa
-aattccattttaaaacccggaggaatctattactgacgaggaaggtgtttaacccgttga
-gacatctcctaacgtaaaaggttcatattctagttattccgagagtcactttcctatcca
-aacatgaactgatagcataatgacaggttgaatggaaagcatatcctgtttattctaaat
-ctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttacaactatgtgttc
-tgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatct
-gatttaatagcttaatgtctcatattttacagtagccagtgtagtatggaaggcggcgaa
-ccagcccctacattgggtttcctgacataagtattacatatcacttgtctgattacacag
-caaaatcgctaaccttactttgcgcatgtagctattggaactttgggctagtgtctatcc
-cattaagtttaacagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaa
-gttttggatttggatcaaaaactactcgatattcatgatctacgggcttcctttctccgg
-gtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgg
-gatagcgtagaaactaaacaacgaatagaccatccaatttgaattttattgggtccagca
-cttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatattaattctgctac
-attttcgaccacttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatg
-ccgtaattctaagggatgataataggttgggaaatttaagagcagtagtaacggtcgcgg
-gttcgaccttaaactatatatttaaatctagccaaacaagttaacaacaaccataaagtt
-atgaccttattatattggcaagcttaacgttttaattgctctagtaatagagtggtagag
-gtaagggaccatcacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaa
-atttcgagataaaacattcgtccttagcaacgaatatcgaatggcaattagccacattga
-gttaaatagttgaggatatttcttgcacagaatcagatctaatctaatgattcgttacta
-aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
-atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
-ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
-atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
-tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
-tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
-gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
-tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
-gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
-gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
-atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
-taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
-ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
-acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
-ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
-ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
-cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
-ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
-aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
-attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
-acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
-tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
-attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
-aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
-tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
-ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
-gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
-caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
-taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
-ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
-ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
-gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
-ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
-aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
-cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
-gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
-ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
-tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
-tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
-ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
-tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
-gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
-ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
-actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
-gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
-ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
-tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
-atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
-aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
-tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
-ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
-acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
-gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
-gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
-tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
-gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
-gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
-tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
-acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
-tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
-catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
-attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
-ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
-ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
-gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
-tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
-tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
-ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
-gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
-ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
-tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
-ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
-tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
-ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
-actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
-gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
-gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
-accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
-gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
-cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
-tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
-atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
-ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
-ggaagtgaaaagataaatattgcctacacatactgaattcaggcaatgcgttttattcga
-aaggtcatataactagaaaacatgatgaattcttatcggatccttttactagcatagtgt
-tggcgaacacctcgtaatgctcagcggcaaattggactgcgggtccttatcatacatttt
-ttttcaatataggcgattggtctaggttagtgattccccaacacttaaggtttgctgaca
-ttcataccctcagcaacttcctctcaaaaattagagtgagttggtggtcttataagaccg
-ttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctg
-tagacaataacccattgtagtgccgattttgtgcataatacaagaaggaggatataaaaa
-tgacttttcaataatattggctattagcaacaagaaggagaatcctcattaagttagcaa
-ccgcagggggtactgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaa
-ttatgattgtgagattcgctgaagattgtgtctctgattttcctagatagaataagctat
-agctacttaatcaactcttaactgtggagactatcctgatgatctgaataccccatttac
-aaaattccatatcaatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatca
-gcctttttatacaagacaaaacactgcttccattacgggtagcaatggttgctcgactac
-tggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgac
-ctgacataatggagcgacttatcggatgttgccgatctttagggtcatctattaagctta
-tacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacctagaaacgcaag
-aggaggcgaactccaatatctgtaagaacagaaaaatacaggagtccttttcatttttca
-agttaacaatataagtaggagcttagagaggcttgcatgaaaatcgttaggaattacaga
-ataggcagagagtggggcgtgtagactacattcttcaggccccacaatatgggttatagg
-ttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgtt
-ccttttgctgtagtccacgttcatccaactattcagataaacaagatcgcagaattaaag
-cttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctc
-aatcttgtctgcgagagggaggaaaatttagacaaacataattcattctttcgactggac
-acgctaaggtttggacaaactttgtatctatatctggaggcctgtattccagcccttctt
-ttaataagatttacggcttaaactatggatatttgccaggaaatgacactgctattgaca
-ggaacataattttgattcaaacctcattgttaattattttatatctcctgtttttatatc
-agaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaatgaatcataata
-gaccggcccctattaatattggttcaattctttcttacataacgcggaatttgattgcac
-gaacaccgggaacacataaccgtatagcgcccgttatgctagtgcctagcgactgggacc
-gtggagtctatatcgtctttctaccattattaatctaaggatataccactttaagtcctt
-tcaactaacataaggcgcattccatgcgctaaggaccttgaatttattatttcttacatg
-ataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaa
-gagccctttttctggcttgtggagactatcataacatgaagatgttttgacattcaatag
-tttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaattgccccatagc
-aggaatagttatatattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtg
-agggtaagcgacttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaat
-tacagttatacgacttaattcagtctccataaattgaaacgacacttcttaacgggagga
-ccagacacgttcattaagtgaggagtgcactttttgactttaaaaacatggtaatcaatt
-taaaccacttgatatgtatatgaacagatttgaagttatttctgttttaatacactggga
-gttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaaggg
-acaggggaaagggtaatcgaggggtagggaacgtagttggcacacccaatggacgaataa
-atgctgccatatccacggagggcgggattgcggttgattttaaggcgatggtaacctgaa
-tgtaatagatcatcaaatgcctcctccactggaaattactgcgtacatccgctgagaatt
-gcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaacttcatagtataat
-ttttgcacattacaagcgttaattaacaaacttactttgctgttagctgcctatatttgt
-ccgacaatataactggatatctctgcgagaactgtaaattaacggcacttggaacataat
-agttcctattggtaacgacgttgtaggcggcaattatccggtggaagaattgacaactgc
-agttgaactgcatgaaagtcaaatctctcgtaagtataactttagaagactccaaggtac
-ccagaacctcttcagcggacacgatcgctatcaatcaataaggattattcactgaaaccg
-ctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttt
-tggccgtgctaatcgacacacctgttattttcatgaccggataggacatctcgcggaaat
-tcgggtaacagctgggtagatataggacctcccctacgtattaatgataagcctgtcata
-actagcttggtttaccgaagagacaataaacattcgagcgctcgtgccaaactcggtgca
-ttacgtttgaataaatcggtaacatgtactattactctgcctaacggcacttacccgttt
-gggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccg
-attaccgaaaatctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaa
-caggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactctgggcatgtttt
-atgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggctttatccaatat
-gggtccttaagtgctaaacatcattcacaatttcaagacagattgttggtcttgtcgatt
-ccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgac
-taaactaccgtgtgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaag
-ccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagtaattccgtttta
-ttgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgtgccttataggct
-atttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtc
-tatcgccaactaaaagacgtctcgatggttctttatgcggacctgtcatatcattgactg
-gcacttgcttacatccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaaga
-tcatgaggcggggggggtaatatttcgccctctacatgataaatgaataagtaagaagat
-gatctttttgtggcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatg
-tagggttctggatctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaa
-taagtgatcaatggactaacattgaaatgttagtattgtcgaccattgagggctggtaaa
-tcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactc
-gttaatgcttactttagttggttgcgggaacaacaggaggctatactaactggtagcgtt
-cttgcttccattatgttattattataattaaaaataagacatatggtagagttgtagtca
-gggtggatcgggttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaa
-tttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacattcacagcacaccc
-ctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaatt
-ttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaattcactagtatc
-ctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatcaagatgtatgat
-ttttggtccgctgtgtggaatacctctattgatatacaagtgactttctcggtaataacg
-cacttcacaatgtgttgtttcttttctatgtattttgcaagagaaagaagcttagtatag
-gtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacat
-tatccaaattcaccacaattactaatccacccttttacttttactaaagatatattaatt
-ctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaaggataccaattg
-aagtcctcgaggcatgttacaacacacgacttccttccgtctattcagacactcaacgag
-actaacttttcctaggtaatcaatgatattgggtaactcgtggcatcttatagttattga
-tccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgc
-aggggatacgtttattctacgtacccgatttggttactactaagcggcctttcttcaaac
-ttgcagttgtgacttacattcctatttcttcaaagcagggaagggttacagggagagact
-tattgagatacgattggaatttccatgtacaatcgttaatacgcttgtagaccagcaact
-cagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattact
-aaaaccctagttgttaatataagaacgattcgaaacaataggattgcccaagggggtgcg
-aacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgtttctagtacgca
-agaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggcttattctacttt
-ttccgacactcaatggacgagacaaacatgaacggatagctttaggtctcgttgaatgca
-aagaatagaatcgttattattaatcggtttccattatctatatgcggtatagatctccga
-gaggaccctgtaaactagctctgcggtttaactggtgctaatagaccgccactatgttat
-tgcttctagctcctagcgtcttatcatgttatacattaatgtcgcatattggacagtagc
-caggcttggatggatcgccgacaaaaagaaaagactttccctgtaaggacttaactatta
-catataacttggatcattaatctgcaaattagagtaacggtctttcaccagcttcatatt
-ccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattggcagtctcacttc
-acagtgcgtatctatacgacaaaagtggtcgatttgcataaatatcttatcgatattcag
-gttattaccgattccttgctaacgctagaagtcacaccagagtaataataattccagaca
-cctgtgaaataatcggtcactacggatagactagtaacgataatacgtatagtccataaa
-agttgaattttaggggctaaagatattagcaatactggtctagcctaatcgtcgatagca
-aagggctgtgaggatttctcctacattttcgaccaattgtatcgataggaatagttacag
-tcacgcttgtagatgtaagagatgacgttattcttagggttcttaagtcggggggtaatt
-taagaccactagtaaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaa
-aaagtttacaacatcctttaagttagcaactgattttagtggcaaccttaacggttgaat
-tgatctactaatacaggcctacaccgaagggtacagataatgattcttactaccctaaca
-tgatagagtcctgtcctatctcataggtcgacattttaaattcgtaatgagcaacgaaga
-tcgtttcccaatttgcaacattcacttatagacttcaggttatttcgtgctaacattaag
-atagaatataatcagtcgttaagaaactattatccagctttcgtcaaccataaagattaa
-aaactgaaacttggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgct
-ttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaa
-tattaatatactattaagctacacagcaaaggctgcaataatgttagtaagtagaacata
-aaggtattctccacaagtaataaatagtgtgagctaattgactaacttaactctcgcgac
-aagtgatgtggataagatgactcatatcgtctttttctgtagtgccgacatcccacctgg
-atcgaacaattccttctagttatcgactttgattacctatcctattaaacagatagggtt
-gtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagttagaacgcgtag
-atagaggccttttgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctt
-tcgtgtccgaatttgtttaacatccattagattagatgtttgtgttttgggtctgatgtc
-ctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtct
-ccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatttagaacacacct
-tatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaag
-gaacttaaagtcggatcactcttgtcagtgtagataagaatttctttcatacttcactgg
-aatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttg
-ctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatag
-catcaggccttcttatccagcgtgaagtctaattatttcacaagctttcctaagtatgta
-aatccctcacttaatgatgcttgcgccaatgaggatagaggacattgcatgtacgtagga
-ctattctccaaggggtcttctattttgttagcgaaaattgttacagcctaatgttagagc
-ggcgtacgactttataccagatactttcattagatatgcaaatatccaattaaatcatag
-tagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcg
-ttctcatatatatagatcaacaatgaataatctcatgatctataaccgatgtatatttat
-attccggttgactgctccggtgcaattcactacggacactaatgactaatatggcgcctt
-tcatcagaaacgctaaatatgattaatgaattaagggagtattatctaattattagagag
-tagcagttagtctgatattttcggtgtatgtgttagccgttataatgctgtctttttatc
-agtgagaacagggagtgtgtagtgttgtatgcttcactttatgactctggttatatccct
-cggagaacaagaataagagtacgagaagttcggtcattgaggatgaaatagaaccgctag
-acgaatggactcacgtttataaaactatgtatcacagtactacagctaactctgaagtcc
-gagaagcttttgtaggacaaaacgttataagtacctttcgcagaatacggccgtgcatac
-ctgttataaggcgtagtagggacaccatgctatccctcatatagagctacactaatacca
-ttacatggtgactatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatcc
-gtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactat
-tcgaagcttctcaatccttttccattatggcatagcaagtgacgactcgtcagccatggg
-aataatagcactaatccgattacttatgaattagaacccacatgaatgtgattctgcgaa
-ttgtctaagaatctaatgattttccggtgaatatggttgttgttatttattgaacttata
-ttattaacatcacccttcgttagtgatagtcagctatttccaagaggttccccgagcatt
-tttaccattctctagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcg
-ttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaac
-aggtcacccgtttttcgttacatatgctggtaaaatattcatagtaataactacaatact
-tgatttgttacgtaatgctcgtacataacacaatcgtattccacggaacagtaaagctct
-attattctgatcgagcctaagagaggatcacactacgctattaaagtcacgttcacgaaa
-tctcaaacctcaactgctggtgaccagttatagacagtgtaattccatattacatgtcag
-gcttaagctaacccgagcctttatataagctataatcaagaattagattggagtgcattt
-tagacttatctatcgaaatagtgatagtaagagtttatatgacctgatctagactgatgt
-tctcttccacaacagccttaaggcgtggagcctttcttatactattaggtcgcgtcgaga
-gccctattcgtaatgttaacgacactagactaatatacaatgagctaagaataacacaag
-tcacaagataatttacaaatcatatatctacagtccacaaccatcactagcgattgcaaa
-gcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcc
-tctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtga
-gtcatgtgcaactatacagtttagtttggtcaagactatgcaactattaacagcatgtgc
-gcattgaatatttggtgtcgattgataaatgccccaacgttccatcacgtctataagccg
-tgttactaatgtgtattagtgcatacctattcagaccatagttcaactgttggactgaag
-gcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaa
-atgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagccaatgggctccc
-attgagctagtatggtgctttacctttgtaagtggtggctttccttggtgtgctgacttt
-aacacggcagagtgattatccgaagaatggataataagacgctggcaatattggctaata
-aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca
-tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg
-tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg
-gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc
-atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc
-cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt
-caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat
-tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt
-agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt
-ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt
-aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta
-ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat
-cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac
-gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa
-atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc
-ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta
-gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt
-aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt
-aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc
-atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac
-tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat
-cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc
-taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt
-taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt
-ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc
-acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct
-cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg
-tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt
-attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat
-cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga
-atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc
-accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag
-tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc
-acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag
-ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa
-gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc
-cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg
-aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca
-tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta
-atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac
-ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc
-gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat
-ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt
-gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata
-gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc
-atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga
-agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct
-aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac
-ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc
-tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa
-cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc
-gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga
-atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta
-ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca
-gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt
-acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga
-tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg
-ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc
-ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt
-acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat
-tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag
-tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga
-tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca
-aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg
-aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg
-actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt
-tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa
-gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag
-tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc
-attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt
-gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc
-atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact
-ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta
-aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt
-gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta
-taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga
-tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc
-gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca
-cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga
-ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac
-agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat
-aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt
-atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac
-actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa
-tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa
-ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta
-cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag
-ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc
-ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag
-cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag
-tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc
-agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat
-gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc
-gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca
-ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct
-acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga
-tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat
-tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg
-cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac
-cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata
-agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca
-aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg
-gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta
-atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg
-ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag
-acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta
-ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg
-gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc
-atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg
-actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg
-cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt
-cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa
-ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca
-tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta
-atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc
-acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct
-gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta
-ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc
-aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga
-taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa
-cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca
-tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta
-gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg
-gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag
-ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat
-tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta
-aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt
-aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc
-cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca
-acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta
-aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct
-cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa
-tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt
-cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat
-tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt
-taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg
-ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt
-taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc
-accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa
-ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg
-atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg
-taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga
-aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt
-attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt
-atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa
-attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa
-cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg
-agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt
-tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca
-aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa
-actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag
-tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta
-acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg
-tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat
-agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag
-ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat
-tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt
-attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta
-tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt
-ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt
-catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga
-caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc
-cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac
-accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca
-atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct
-tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct
-cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat
-gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca
-gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga
-agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca
-ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc
-ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa
-aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc
-ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga
-tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt
-taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg
-caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt
-tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc
-taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac
-gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca
-gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat
-aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt
-atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc
-gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat
-aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa
-aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga
-aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat
-ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc
-gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa
-acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac
-attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc
-gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag
-gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct
-gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata
-tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat
-ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata
-aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc
-tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat
-tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa
-ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt
-agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
-cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
-tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
-tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
-gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
-tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
-tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
-atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
-cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
-ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
-ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
-atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
-gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
-tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
-gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
-atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
-tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
-ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
-tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
-aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
-gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
-ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
-agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
-agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
-acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
-cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
-cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
-cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
-aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
-tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
-atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
-cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
-tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
-catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
-tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
-caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
-tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
-aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
-aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
-ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
-gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
-ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
-cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
-gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
-ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
-cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
-taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
-gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
-taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
-ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
-aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
-gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
-acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
-ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
-tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
-tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
-tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
-ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
-aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
-tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
-gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
-gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
-cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
-actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
-tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
-ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
-ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
-agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
-gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
-tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
-atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
-cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
-tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
-gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
-gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
-aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
-gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
-cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
-taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
-tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
-ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
-aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
-gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
-aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
-tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
-tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
-aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
-ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
-ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
-caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
-gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
-cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
-ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
-tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
-atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
-ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
-acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
-taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
-ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
-aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
-cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
-tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
-gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
-aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
-cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
-cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
-gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
-cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
-gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
-agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
-aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
-aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
-cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
-agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
-cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
-agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
-gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
-aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
-agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
-cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
-agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
-ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
-tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
-gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
-gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
-ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
-gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
-atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
-tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
-ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
-tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
-cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
-ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
-aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
-gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
-ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
-atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
-aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
-gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
-atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
-aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
-tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
-ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
-gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
-cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
-ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
-ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
-ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
-cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
-tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
-tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
-cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
-gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
-ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
-ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
-tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
-agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
-ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
-cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
-agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
-tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
-gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
-ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
-ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
-agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
-attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
-ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
-agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
-aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
-gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
-gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
-ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
-gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
-ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
-taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
-aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
-tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
-ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
-agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
-ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
-agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
-gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
-tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
-gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
-cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
-ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
-cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
-gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
-gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
-tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
-cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
-aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
-ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
-gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
-aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
-gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
-aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
-gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
-agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
-caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
-gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
-aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
-tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
-tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
-ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
-ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
-gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
-ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
-aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
-tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
-acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
-atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
-gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
-tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
-cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
-gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
-acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
-acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
-attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
-tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
-cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
-aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
-ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
-tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
-gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
-gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
-acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
-gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
-gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
-ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
-taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
-agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
-gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
-ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
-accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
-tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
-taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
-catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
-tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
-ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
-aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
-atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
-tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
-ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
-tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
-aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
-agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
-acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
-aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
-ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
-gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
-taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
-taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
-tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
-gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
-ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
-atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
-tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
-cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
-aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
-taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
-caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
-ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
-tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
-tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
-gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
-gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
-gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
-ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
-tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
-taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
-gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
-ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
-gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
-tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
-ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
-tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
-cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
-ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
-caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
-cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
-gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
-cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
-taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
-tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
-taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
-tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
-tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
-tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
-ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
-aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
-atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
-actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
-gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
-ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
-gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
-tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
-aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
-atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
-catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
-taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
-ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
-cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
-agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
-atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
-tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
-gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
-attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
-tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
-tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
-gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
-attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
-aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
-ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
-taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
-atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
-aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
-agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
-gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
-tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
-taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
-cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
-aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
-ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
-gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
-tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
-ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
-cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
-aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
-cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
-ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
-tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
-ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
-atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
-tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
-ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
-acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
-ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
-aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
-gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
-ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
-tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
-gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
-taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
-aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
-tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
-gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
-ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
-tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
-tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
-tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
-ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
-gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
-ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
-gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
-tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
-caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
-tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
-gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
-tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
-cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
-gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
-tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
-caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
-agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
-atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
-ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
-atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
-tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
-tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
-ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
-agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
-acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
-cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
-taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
-acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
-ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
-ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
-cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
-ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
-cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
-attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
-gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
-ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
-aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
-acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
-tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
-tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
-agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
-ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
-tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
-ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
-aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
-cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
-tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
-tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
-accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
-agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
-aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
-gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
-aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
-ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
-cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
-ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
-tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
-tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
-aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
-gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
-cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
-aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
-gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
-gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
-tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
-tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
-accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
-atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
-tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
-atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
-gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
-ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
-tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
-gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
-tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
-gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
-ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
-agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
-aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
-tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
-tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
-tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
-aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
-aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
-aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
-ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
-gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
-tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
-atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
-gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
-tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
-gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
-atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
-gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
-ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
-tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
-gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
-aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
-acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
-acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
-accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
-atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
-aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
-gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
-aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
-caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
-cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
-ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
-aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
-tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
-agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
-caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
-gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
-gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
-acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
-ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
-gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
-cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
-ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
-actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
-tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
-catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
-tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
-tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
-tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
-cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
-cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
-tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
-aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
-cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
-caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
-ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
-tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
-attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
-tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
-gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
-cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
-aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
-ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
-aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
-gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
-gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
-cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
-gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
-tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
-aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
-atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
-ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
-aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
-aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
-cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
-gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
-ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
-tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
-gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
-atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
-ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
-acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
-cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
-atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
-tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
-atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
-ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
-agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
-agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
-atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
-tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
-tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
-taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
-aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
-tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
-acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
-tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
-acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
-ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
-tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
-aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
-taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
-cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
-ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
-attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
-caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
-aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
-atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
-tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
-cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
-ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
-gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
-actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
-cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
-ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
-aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
-ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
-gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
-ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
-cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
-tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
-ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
-cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
-ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
-attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
-agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
-ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
-aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
-aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
-atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
-cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
-gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
-aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
-atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
-ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
-cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
-caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
-tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
-catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
-atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
-tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
-gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
-agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
-actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
-ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
-tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
-ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
-gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
-tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
-taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
-agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
-acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
-cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
-attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
-agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
-gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
-taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
-ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
-tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
-tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
-aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
-tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
-atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
-ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
-aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
-actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
-acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
-aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
-caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
-aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
-cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
-atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
-ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
-agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
-atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
-ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
-attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
-ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
-atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
-taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
-tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
-aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
-ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
-gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
-gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
-ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
-cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
-ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
-aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
-taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
-gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
-gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
-tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
-attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
-caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
-acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
-cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
-taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
-taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
-tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
-ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
-taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
-tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
-gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
-gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
-cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
-aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
-gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
-agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
-agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
-acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
-gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
-tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
-atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
-ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
-gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
-gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
-gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
-atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
-ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
-acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
-tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
-tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
-cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
-aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
-gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
-ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
-taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
-gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
-tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
-tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
-caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
-ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
-gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
-ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
-aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
-ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
-tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
-gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
-aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
-ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
-cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
-attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
-ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
-gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
-ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
-atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
-atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
-atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
-cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
-cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
-gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
-accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
-tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
-aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
-cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
-tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
-cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
-acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
-cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
-ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
-agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
-cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
-acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
-gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
-gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
-cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
-gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
-ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
-ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
-agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
-gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
-tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
-tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
-ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
-ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
-ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
-catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
-ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
-tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
-aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
-gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
-agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
-atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
-taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
-tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
-cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
-cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
-tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
-catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
-catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
-ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
-tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
-ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
-ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
-ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
-tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
-ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
-tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
-aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
-gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
-ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
-agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
-taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
-ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
-agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
-gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
-agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
-ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
-ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
-acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
-aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
-ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
-ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
-tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
-gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
-ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
-tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
-aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
-ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
-atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
-acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
-gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
-acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
-ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
-ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
-gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
-agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
-ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
-ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
-gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
-gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
-gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
-cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
-aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
-cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
-gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
-ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
-gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
-atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
-gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
-acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
-aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
-cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
-atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
-tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
-tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
-ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
-tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
-gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
-gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
-aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
-tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
-tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
-attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
-catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
-taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
-ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
-gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
-aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
-aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
-agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
-tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
-aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
-agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
-ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
-taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
-ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
-cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
-tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
-cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
-gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
-cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
-tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
-acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
-ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
-gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
-taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
-tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
-tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
-cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
-tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
-ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
-aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
-agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
-gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
-catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
-tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
-aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
-acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
-tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
-aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
-agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
-gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
-gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
-taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
-gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
-gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
-tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
-agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
-tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
-caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
-aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
-gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
-catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
-ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
-tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
-gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
-cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
-gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
-gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
-ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
-gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
-ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
-cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
-agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
-caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
-gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
-agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
-gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
-ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
-ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
-attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
-cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
-gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
-acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
-ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
-tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
-tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
-taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
-tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
-gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
-agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
-ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
-attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
-aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
-ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
-ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
-ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
-tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
-ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
-atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
-aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
-tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
-cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
-aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
-acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
-agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
-tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
-gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
-attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
-gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
-gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
-gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
-tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
-atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
-gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
-ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
-atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
-ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
-tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
-cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
-tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
-gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
-agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
-aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
-ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
-gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
-ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
-cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
-atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
-atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
-cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
-catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
-ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
-tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
-tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
-tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
-gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
-aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
-caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
-aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
-gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
-agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
-tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
-cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
-taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
-atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
-tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
-gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
-ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
-gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
-tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
-tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
-tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
-gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
-cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
-gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
-tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
-catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
-tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
-caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
-tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
-cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
-gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
-tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
-cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
-acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
-agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
-tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
-atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
-ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
-tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
-caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
-acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
-actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
-atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
-tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
-aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
-ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
-tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
-acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
-cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
-cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
-tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
-gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
-cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
-atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
-aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
-tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
-tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
-acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
-tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
-ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
-tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
-aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
-agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
-ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
-tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
-aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
-acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
-aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
-gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
-ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
-tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
-cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
-agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
-tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
-gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
-accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
-cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
-cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
-accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
-cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
-gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
-tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
-tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
-aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
-tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
-tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
-atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
-ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
-agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
-gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
-caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
-tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
-gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
-tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
-agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
-taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
-gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
-tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
-ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
-ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
-ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
-aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
-tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
-cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
-taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
-tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
-ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
-tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
-ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
-ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
-cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
-gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
-ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
-ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
-atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
-aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
-aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
-acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
-tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
-ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
-gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
-aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
-cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
-ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
-tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
-atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
-taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
-tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
-ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
-ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
-gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
-aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
-gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
-gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
-acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
-atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
-taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
-ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
-ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
-tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
-tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
-tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
-aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
-cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
-tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
-aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
-ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
-attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
-agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
-ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
-aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
-taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
-gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
-caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
-atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
-ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
-aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
-gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
-gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
-ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
-gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
-gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
-ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
-attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
-atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
-aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
-ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
-aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
-gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
-aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
-ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
-ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
-agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
-tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
-tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
-aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
-agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
-ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
-tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
-tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
-acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
-accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
-agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
-taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
-gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
-ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
-aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
-gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
-aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
-taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
-aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
-ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
-tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
-tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
-gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
-agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
-cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
-attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
-ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
-aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
-agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
-gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
-cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
-ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
-gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
-tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
-acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
-tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
-attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
-gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
-gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
-gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
-aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
-tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
-gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
-caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
-ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
-atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
-accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
-ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
-attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
-atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
-attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
-cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
-ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
-taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
-agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
-ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
-cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
-catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
-tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
-aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
-atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
-gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
-gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
-acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
-tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
-agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
-tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
-ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
-ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
-tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
-tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
-agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
-aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
-caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
-aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
-acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
-ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
-tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
-cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
-tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
-gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
-aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
-tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
-attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
-cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
-aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
-tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
-aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
-aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
-atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
-atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
-aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
-atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
-ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
-actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
-agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
-ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
-atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
-tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
-atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
-tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
-ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
-atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
-tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
-catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
-caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
-actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
-ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
-agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
-aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
-ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
-cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
-gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
-gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
-attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
-cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
-taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
-acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
-gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
-ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
-tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
-cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
-ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
-taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
-ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
-gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
-acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
-atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
-gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
-acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
-agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
-aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
-ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
-gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
-agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
-aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
-gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
-gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
-ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
-ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
-cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
-aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
-ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
-gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
-atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
-atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
-caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
-tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
-taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
-gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
-ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
-tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
-aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
-ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
-gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
-caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
-attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
-gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
-tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
-gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
-aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
-ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
-cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
-ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
-aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
-gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
-cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
-atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
-atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
-agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
-cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
-cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
-ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
-acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
-tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
-attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
-caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
-tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
-aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
-tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
-ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
-tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
-acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
-agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
-tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
-ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
-gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
-ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
-gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
-cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
-cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
-tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
-ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
-tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
-tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
-aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
-gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
-agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
-cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
-tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
-tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
-ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
-gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
-acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
-ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
-gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
-gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
-ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
-agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
-tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
-aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
-cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
-attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
-gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
-ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
-aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
-ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
-tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
-ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
-gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
-acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
-gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
-ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
-tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
-tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
-cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
-acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
-ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
-tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
-tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
-tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
-tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
-attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
-cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
-cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
-gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
-ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
-cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
-gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
-tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
-gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
-agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
-tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
-caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
-acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
-cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
-gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
-caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
-acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
-cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
-aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
-gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
-cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
-gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
-atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
-ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
-actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
-ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
-attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
-ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
-attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
-ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
-aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
-atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
-caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
-attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
-tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
-tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
-gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
-ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
-cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
-caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
-attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
-tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
-tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
-tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
-ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
-gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
-aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
-ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
-tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
-taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
-accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
-gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
-atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
-acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
-tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
-tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
-gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
-cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
-tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
-cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
-cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
-cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
-ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
-tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
-cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
-gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
-tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
-tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
-tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
-atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
-gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
-cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
-atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
-tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
-gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
-ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
-gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
-attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
-aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
-taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
-atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
-agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
-gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
-gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
-ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
-gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
-cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
-tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
-agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
-tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
-cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
-attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
-gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
-atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
-ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
-taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
-gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
-ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
-ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
-ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
-ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
-ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
-gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
-ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
-acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
-cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
-gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
-actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
-gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
-actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
-gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
-atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
-ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
-ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
-actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
-ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
-ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
-gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
-tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
-gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
-gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
-agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
-ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
-tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
-aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
-gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
-tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
-cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
-gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
-agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
-agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
-atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
-ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
-cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
-ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
-taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
-tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
-gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
-ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
-agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
-gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
-gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
-gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
-tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
-atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
-gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
-gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
-tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
-ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
-taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
-cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
-tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
-gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
-accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
-atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
-ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
-cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
-ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
-actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
-atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
-agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
-accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
-catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
-gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
-tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
-tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
-ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
-ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
-taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
-aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
-tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
-cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
-acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
-tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
-ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
-gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
-tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
-tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
-ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
-gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
-gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
-tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
-taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
-tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
-gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
-atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
-ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
-ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
-atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
-gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
-ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
-ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
-acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
-cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
-gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
-cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
-tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
-tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
-tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
-tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
-tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
-taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
-cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
-tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
-aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
-agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
-gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
-tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
-cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
-tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
-aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
-aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
-cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
-tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
-caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
-ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
-ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
-aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
-tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
-gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
-aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
-gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
-ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
-gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
-atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
-acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
-gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
-tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
-aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
-aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
-atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
-gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
-ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
-tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
-ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
-agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
-tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
-gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
-tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
-catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
-aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
-aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
-ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
-cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
-tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
-tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
-aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
-tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
-tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
-agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
-cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
-actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
-gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
-cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
-ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
-gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
-tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
-actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
-tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
-gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
-ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
-gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
-tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
-ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
-ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
-ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
-cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
-gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
-tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
-ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
-tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
-cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
-tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
-ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
-ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
-ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
-ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
-attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
-atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
-tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
-aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
-tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
-ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
-cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
-atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
-atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
-cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
-tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
-agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
-gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
-tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
-cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
-cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
-cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
-atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
-ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
-catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
-actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
-agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
-tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
-ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
-atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
-tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
-tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
-ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
-agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
-ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
-tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
-ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
-agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
-attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
-acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
-ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
-acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
-tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
-cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
-catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
-tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
-tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
-ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
-ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
-ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
-ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
-ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
-gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
-tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
-tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
-agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
-ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
-tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
-aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
-gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
-aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
-tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
-cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
-tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
-ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
-ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
-atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
-actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
-tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
-tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
-tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
-aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
-taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
-acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
-taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
-gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
-tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
-ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
-gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
-taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
-gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
-aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
-gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
-tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
-taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
-gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
-acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
-agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
-aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
-attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
-attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
-acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
-gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
-acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
-cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
-ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
-taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
-aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
-tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
-atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
-ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
-gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
-ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
-agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
-taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
-ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
-cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
-catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
-agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
-taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
-cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
-ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
-ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
-tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
-aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
-ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
-ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
-acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
-cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
-ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
-atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
-taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
-atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
-tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
-gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
-cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
-aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
-tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
-acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
-gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
-gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
-ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
-gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
-ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
-acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
-aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
-catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
-acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
-tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
-cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
-gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
-cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
-tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
-gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
-atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
-tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
-aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
-cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
-attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
-tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
-aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
-ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
-attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
-ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
-aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
-tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
-ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
-tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
-agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
-ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
-agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
-tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
-agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
-gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
-tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
-atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
-tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
-ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
-caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
-aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
-catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
-actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
-ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
-ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
-ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
-gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
-gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
-agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
-ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
-tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
-acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
-gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
-gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
-tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
-cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
-tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
-tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
-cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
-cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
-aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
-ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
-gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
-acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
-acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
-aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
-cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
-gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
-actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
-atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
-gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
-ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
-ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
-tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
-cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
-aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
-tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
-gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
-attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
-ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
-ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
-tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
-gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
-gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
-tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
-tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
-attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
-aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
-cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
-aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
-atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
-cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
-taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
-caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
-ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
-tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
-agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
-tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
-aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
-catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
-actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
-agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
-agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
-acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
-cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
-acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
-cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
-aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
-tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
-attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
-aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
-tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
-aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
-tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
-aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
-tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
-tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
-acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
-tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
-ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
-ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
-ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
-cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
-aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
-acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
-tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
-ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
-gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
-ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
-aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
-ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
-agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
-atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
-tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
-tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
-ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
-cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
-tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
-tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
-gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
-gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
-ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
-acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
-gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
-atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
-atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
-aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
-gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
-tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
-attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
-cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
-gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
-gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
-gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
-aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
-caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
-agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
-tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
-ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
-cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
-aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
-cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
-tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
-tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
-gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
-taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
-ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
-ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
-cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
-gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
-cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
-actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
-gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
-ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
-gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
-actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
-tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
-cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
-aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
-aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
-ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
-cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
-aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
-aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
-aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
-ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
-ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
-catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
-attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
-tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
-acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
-cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
-tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
-cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
-agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
-cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
-tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
-atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
-atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
-tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
-gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
-gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
-cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
-gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
-cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
-caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
-atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
-gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
-ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
-tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
-cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
-gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
-aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
-cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
-ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
-tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
-taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
-gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
-attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
-tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
-tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
-tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
-caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
-ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
-ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
-cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
-ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
-cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
-gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
-taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
-agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
-catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
-ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
-tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
-ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
-atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
-ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
-cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
-ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
-tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
-ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
-atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
-gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
-atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
-tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
-tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
-ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
-acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
-ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
-ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
-ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
-gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
-ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
-tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
-acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
-tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
-attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
-atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
-ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
-atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
-cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
-tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
-ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
-ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
-ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
-cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
-gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
-gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
-ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
-cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
-aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
-ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
-gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
-aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
-caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
-aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
-gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
-agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
-acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
-ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
-aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
-tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
-ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
-gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
-ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
-gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
-ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
-acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
-tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
-tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
-ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
-cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
-tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
-aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
-gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
-tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
-acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
-atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
-ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
-acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
-attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
-tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
-tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
-gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
-ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
-tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
-ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
-caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
-ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
-taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
-tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
-cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
-ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
-tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
-tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
-taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
-aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
-taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
-ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
-aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
-atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
-gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
-ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
-tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
-acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
-agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
-tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
-aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
-atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
-gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
-gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
-tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
-ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
-gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
-tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
-atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
-ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
-cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
-aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
-gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
-aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
-gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
-tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
-gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
-ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
-gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
-catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
-taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
-gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
-tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
-cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
-attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
-ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
-gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
-atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
-gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
-atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
-gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
-aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
-ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
-gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
-atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
-tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
-tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
-tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
-tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
-ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
-gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
-atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
-taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
-atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
-acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
-gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
-ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
-cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
-ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
-aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
-attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
-acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
-taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
-cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
-aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
-tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
-ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
-tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
-gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
-aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
-ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
-ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
-gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
-ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
-aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
-gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
-tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
-atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
-tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
-tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
-ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
-tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
-gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
-ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
-acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
-taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
-gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
-tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
-atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
-aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
-aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
-ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
-cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
-tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
-ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
-tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
-taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
-gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
-actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
-ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
-tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
-cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
-atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
-ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
-ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
-gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
-tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
-tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
-gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
-gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
-ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
-tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
-tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
-tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
-gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
-cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
-gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
-tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
-cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
-taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
-cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
-tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
-ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
-ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
-ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
-cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
-aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
-attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
-ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
-tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
-tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
-tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
-cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
-atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
-agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
-aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
-tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
-tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
-gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
-taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
-agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
-agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
-ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
-ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
-cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
-cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
-aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
-acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
-ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
-tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
-agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
-taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
-taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
-ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
-acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
-atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
-gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
-tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
-aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
-agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
-aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
-gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
-taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
-ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
-ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
-atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
-tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
-gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
-atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
-ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
-cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
-agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
-ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
-gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
-tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
-tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
-acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
-ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
-tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
-attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
-cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
-atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
-gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
-ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
-taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
-gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
-ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
-atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
-tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
-gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
-tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
-tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
-tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
-tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
-actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
-ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
-cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
-tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
-tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
-ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
-ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
-gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
-ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
-cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
-gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
-tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
-gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
-aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
-actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
-acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
-aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
-ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
-tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
-gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
-aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
-cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
-cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
-ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
-aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
-gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
-tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
-cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
-catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
-gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
-acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
-gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
-gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
-agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
-aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
-tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
-taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
-caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
-tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
-tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
-tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
-atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
-cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
-ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
-tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
-cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
-aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
-atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
-gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
-atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
-tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
-gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
-ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
-aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
-taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
-aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
-gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
-catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
-cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
-gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
-ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
-taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
-atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
-atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
-acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
-tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
-agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
-ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
-accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
-tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
-gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
-ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
-gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
-tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
-acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
-atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
-ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
-tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
-tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
-aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
-agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
-attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
-tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
-gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
-tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
-actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
-gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
-acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
-gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
-actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
-gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
-tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
-tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
-gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
-atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
-attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
-aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
-aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
-accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
-atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
-ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
-cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
-cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
-gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
-tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
-agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
-ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
-aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
-gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
-ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
-gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
-atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
-tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
-gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
-cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
-cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
-atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
-tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
-cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
-aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
-aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
-ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
-ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
-gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
-tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
-attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
-cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
-ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
-ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
-tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
-acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
-atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
-gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
-gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
-agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
-tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
-attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
-ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
-gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
-cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
-tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
-tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
-atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
-agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
-cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
-atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
-agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
-cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
-tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
-ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
-ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
-gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
-acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
-tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
-atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
-ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
-acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
-tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
-actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
-actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
-aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
-aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
-actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
-tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
-tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
-tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
-atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
-ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
-attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
-ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
-aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
-tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
-taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
-aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
-ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
-caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
-ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
-agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
-cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
-atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
-actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
-taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
-cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
-gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
-ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
-atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
-cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
-tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
-atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
-gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
-gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
-tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
-ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
-tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
-tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
-gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
-gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
-agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
-aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
-gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
-atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
-ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
-accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
-ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
-gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
-atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
-actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
-gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
-gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
-ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
-tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
-ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
-acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
-taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
-ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
-aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
-aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
-ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
-tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
-tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
-gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
-tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
-tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
-aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
-aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
-cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
-ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
-aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
-gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
-tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
-ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
-aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
-taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
-ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
-taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
-acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
-gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
-ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
-aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
-aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
-attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
-ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
-cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
-ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
-agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
-tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
-aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
-cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
-tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
-actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
-tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
-cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
-ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
-agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
-attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
-tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
-gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
-gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
-caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
-gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
-ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
-cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
-tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
-gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
-ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
-taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
-agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
-gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
-atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
-caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
-ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
-ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
-taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
-caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
-aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
-taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
-gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
-ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
-catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
-attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
-ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
-aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
-acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
-aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
-ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
-tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
-acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
-ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
-ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
-gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
-gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
-agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
-ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
-aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
-tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
-tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
-ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
-agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
-gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
-tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
-tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
-ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
-tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
-aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
-ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
-cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
-gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
-ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
-ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
-gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
-tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
-gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
-atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
-tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
-ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
-agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
-cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
-gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
-ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
-agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
-cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
-acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
-gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
-catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
-gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
-aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
-aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
-atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
-ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
-aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
-catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
-aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
-cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
-acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
-aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
-cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
-aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
-gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
-ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
-ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
-gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
-ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
-cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
-aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
-tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
-taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
-ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
-caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
-gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
-accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
-ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
-tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
-taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
-agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
-ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
-aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
-aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
-ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
-tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
-ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
-ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
-tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
-ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
-cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
-cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
-taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
-tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
-ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
-gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
-tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
-tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
-ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
-aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
-gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
-cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
-aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
-tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
-gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
-aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
-gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
-aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
-acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
-tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
-aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
-ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
-cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
-gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
-tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
-ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
-cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
-ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
-atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
-tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
-accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
-aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
-gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
-aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
-cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
-tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
-gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
-cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
-catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
-ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
-gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
-gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
-gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
-cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
-aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
-cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
-gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
-agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
-ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
-agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
-gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
-aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
-attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
-cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
-agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
-ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
-tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
-gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
-taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
-ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
-gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
-atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
-tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
-ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
-actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
-ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
-ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
-cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
-gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
-atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
-atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
-aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
-taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
-atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
-aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
-tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
-ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
-gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
-gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
-tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
-gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
-gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
-gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
-tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
-aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
-cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
-gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
-ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
-ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
-tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
-cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
-tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
-gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
-agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
-aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
-gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
-cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
-tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
-ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
-atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
-ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
-agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
-aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
-gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
-gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
-ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
-tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
-gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
-tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
-acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
-taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
-ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
-agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
-ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
-cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
-gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
-tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
-tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
-cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
-ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
-ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
-tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
-tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
-tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
-gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
-aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
-gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
-tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
-aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
-gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
-cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
-tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
-agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
-catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
-gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
-caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
-tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
-tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
-ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
-ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
-tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
-tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
-ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
-tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
-acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
-attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
-gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
-tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
-cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
-ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
-acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
-acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
-cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
-tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
-cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
-cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
-atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
-aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
-tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
-gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
-acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
-gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
-gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
-ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
-tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
-agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
-gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
-tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
-accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
-acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
-aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
-cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
-tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
-ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
-aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
-atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
-tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
-gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
-tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
-caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
-aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
-acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
-catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
-ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
-tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
-taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
-aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
-tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
-tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
-atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
-ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
-ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
-gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
-cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
-tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
-catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
-tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
-agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
-tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
-gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
-tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
-gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
-ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
-tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
-tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
-gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
-ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
-gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
-tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
-ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
-tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
-cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
-ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
-caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
-gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
-ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
-cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
-aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
-aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
-taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
-accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
-tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
-tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
-ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
-aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
-atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
-cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
-ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
-atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
-gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
-tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
-caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
-ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
-catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
-aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
-gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
-cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
-agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
-atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
-tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
-tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
-attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
-tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
-tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
-taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
-attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
-cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
-tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
-tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
-atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
-aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
-agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
-gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
-agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
-taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
-cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
-cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
-ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
-gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
-aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
-ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
-cagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaac
-aagtggtctaaaaagactgccctggaaggagtaagaagtatacagctgatccggtgtatc
-cttcagtcatctgccctatactaattacacgacgcaaggaaaaataggtttattttctag
-gcaaacccttcataggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgt
-taccgacggataataacgatctccaatgaaccaaatgtagaatgtctattgattaccctt
-ttactattcgacttagagataggagatagaacctcagtgtacttttttagccgaatggga
-atctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatat
-tatatcgttgttcgtggaatcgataacagatttgttgacccatagtaaatgtatactagt
-ttatgttgtaagtgtagattgttttccgattgccgtccaaactttatgtcgtaattgtag
-accagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaattttt
-ccagtcactgtaagtgtaggtttagataaagccgtatgagttatatcataagggcctcgg
-aaagcagcttcgaaccaaagttcccttataatagtagtttaactataaaagtatatactg
-gtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacgtcattagagcgg
-ctccaatttaaggttaacggcttccatgtgtagttgtatacaaggataacttaaagtatc
-tgttcagcgagctagttaagttatcctcgatagaacacaactcagaggtcccaagatcgg
-gtttgcaacttgctaatttattctcaaggcaaattgggaattatcgatacctgtatacca
-taaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttagttagtgctgatt
-aacggaacattaatgtttatcgttttgagatttagccaattctctgattctaactcaaga
-tgccttatctgacgtgctatgcagcccctaagtattttacattgtaataggacacgctcc
-tttaaaactcgccaaaaggtcgttgtggttctctactggttaactatataatttacagct
-ttgttgagctagttcctctttggtttaagtcctcaatattagttggttcgagcgataagt
-tggctagttaccttagtcactatattagatccgaatgttatgcttcatctgaagaccgcc
-accctccaaaatttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtt
-tctcaagtggtgtatctgtacacgagtttccatattttcatcaacagccaccgcacactt
-atgtcactctaggtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgc
-tagtcaaaaataaacatagcgaggcaccactaattcggccgcttatcaatgggatgctct
-gcgcgagacgcgccagagctcagtagttagttcggacatacatttacttcagatgatcaa
-ttagttttctacaaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctt
-tagtatccttccgtcttatataaggtcagtcccccgtttcggtaccctggaatttactaa
-gaataatgaaacagcccccaaggacgtacgtttacaaatgatagaccagatcgcctagct
-tattccgacgcatgttgcatagaattgaaccaacggaatgtgagagtaactagatgagcc
-gaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatg
-tcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctc
-ggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatg
-gctcatatggaatgcctacctcatagtgctgaattaacacagcactgcggacctaacttt
-tcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgtagggatcctcggt
-gaatttgtgattgggtttgttgtagtactgaccaagtgaatattctttttttctaaaagc
-agatctgctgccgggcactacgaaggagatctctgtgtatcattattgcttcttgacatg
-atgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacat
-attgttgatacttcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaa
-atactggtgacttggtcctatctactattagctagacctctggggaaccacgcccccgta
-aaacctgtgcaagagagggggtcatacatcttagacatcgcgcctccaccagggaagcat
-tgggtgattgaccaggtgtgtaacaaatatgattattcttatactaatattagcaaagat
-gcataatgatttgtattaaatgtataattgaattgataagggtcttttagtcagtgatag
-agtagtataaggtagacattagaactcttaaccggacgcagatttttcggtcttagtaag
-ccaattagtcgacaaaacaaggtaagagcggttactagtagtacctataatgcactgaat
-cttcggtcgaagtatagttctaatgctatgcagattgtgacggcgacaaatgttcagact
-tatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattgaatatttttaaat
-acaaaatgcgcctacttattaggggaattaaccagattgaaggccaatcctcacatgtaa
-tgagataatagacgataaatgaaattcttgtaatagttgaactgctacgtgatgggtatt
-atatatgattgagatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaa
-cgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcact
-ccgaagtataagcaataataatgcgggtaatccagactagatcttttcggactcaatgcg
-gtttcacggtaaacatgattaataccggagagtagtcgagcttatcagcgatgcaagcga
-attcattgtgccaggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttg
-gcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaa
-gtccattaccttttagtttcagactggtggagctgactaaagttatatcatcattttgta
-cactggtttagttaacgataatttcagatttaacatgaccagacgataatcgctgtatat
-ccagttggaatgtggtttgccagaaaggttaacttataatcaagcctctcttcagtcttg
-attcgtcgtatcccatccattgcgctatacctcagtgtatttggagctgtagttataccg
-tgtgctaagatcagtagacatgacgagagcaatattatctaccttacaagcatcaacgga
-cgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatatactatagttctg
-tattcagcagttattcttatattcgatattatcttgcctattggatgtctgactttagta
-tattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaa
-ttataaacggttacaaccattaaagacaacaagaccctatagctttatttgaattttgtc
-aatgcgcaacttggagctcgcgatacatcccaattagtctatagggtcgggacgattcta
-cggcatttctggttataatgacaacatggattgtggcccgagaatcgctctttcattaat
-taagcaatcattacagtcttataagcgctacttccgagtggtagcaggtaactcgatata
-aggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgatagagaataccga
-ccacagcgcaacctttgattactttcattaaattgtacggctcactcgacatcaagctta
-agattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcag
-aaagcgtacccagagaagatacgctgttacaatatacagggtgaaattattgcctgttct
-tcgtaaccatttcgccaaacttggttagaaatgatagccattcatgatagaaataagctg
-aatgataccagtatctttaactatgtagtcagggggaagataacgatggtccatgtatgt
-ttctgatatgtgacagtattggccgcgtaatttgctaacgaagctacttaatgcctttga
-gcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgagctataatatatg
-ctagtagagaactctggaccatcatctatatgaatactgattcgagcgtgcaattacttt
-agcctgcgtactactgactctacaaaacactctgagataagtttgtagtcagtaagtcgc
-tctctataaaccttttggatgaccattgtacagccacttatagatcccaataaatagcac
-aggagacagagtttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagg
-gcacctattatttgatacctaacctaacggccctttcacaatggagaaatatatgacatc
-gggacaaacacaaatggtgggtggccaggagatatgacatggtggcgtctctaagaaaca
-cggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaa
-gattttgccgtgtaatgacctggtacattgactggtcaggaatacatcactgtagttgcc
-gtagtgtcctgttggtgttccatcaagacacatcgtataacgcaatttacgacggacatc
-agatcaagttatacagattatttaagtatcacgtgtgcattgggacataagggatctcac
-acatgccttggaacatttttgctttgtgccgctttttcgctgcactaccaatccttactt
-accagtatattcaaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcg
-attgggatagacgagacatttgcgagcgccctccacggatacgaatctcccatatcaatg
-tgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagca
-ctcgcatagcagttattcagaacctaatacacaaaaccgtcaaacattttctaattctag
-gtatgggccgatcataggagctaaggtgaaactcataaatgttttgttagatctagcatc
-ctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgtatcctttttaac
-tgaactagtcggtcccatttcgtgactgagatctattaaccgataagattaataacactc
-gcattcgtatcagctcagagtgaagtttttcaataatttgactgatatattaacttctaa
-aataaccctttaagcctcggatccgtttcccaatcacatcaaaaattcttattccaacta
-tctacggattaacaacgtgcatggggatcgtagtaagaacttgttccgatcactttgagt
-atatcaagttgacggcccggttattattgaatagaaacattcacctgctaaattaaatac
-cgcacatcggatacccgatttcagagggccgtcttactaagggcaggctttgttcggttt
-aactgagatgttcattattttacagtatgcttcaactaatatgtaacgaaggacagtgga
-tctgtctccatagtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgt
-tcgagttgttgatcatggcacgtgaaagcaacccctagtattctagacgaaaattttttc
-tagttcatctgataatttgccaattcaaaaacaaccgctggtttcccggcgcattctcta
-aaatggaagtcgaacctagagccattatttgtcggtaacccatgagttccttcttttcag
-aagttaatacactgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcat
-aacaacattggatcaagatagcaatttggctacctattctaattctcactagattcggta
-ttccactacaatatcggcagattaggattggatgaataatcggtgtttaagtccggttgc
-gtctccaatctcctaatttttattaatattgatcttggtgacctattgtaaataaaaact
-tcaagactttgaataacggtgaaaagatagaagactcatttgaaaatggatcatccacag
-atccaaacattagcaagacactaatccccaactagctattctgatcgcgatcgtgctgca
-gtactcctgtcacaatagtctgttcatgatctaattctttttgggctttgttcgatggtg
-attcagaatctttatccggtcgcttccctgtagctactttgtggggatattgcccgggga
-ttatagggttgagatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactac
-atcagaacatcgtgaagacaccatacgcggtacctttatttaccgataacatttcttcaa
-gaaataccggtaagcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaa
-ttttatttaggttactgctcaaggaataaaaactaactatttaatttataataatattac
-aaggctcacactgattagatttgtctataagacttcgcgatcccccattaccggattgtc
-ttaagaataaactagataaaccatgcattttctagataaggcctttagtctaattagata
-caaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaaccttttaattac
-ccgcaaatcactttatgtcgagactacctctgaaatttattatctacctaccgcatgagg
-acttgaaccatcttgtaggagttatgtttattagctaagattcgtttatcctgtagcggt
-ccatgtatattcaacaagcaaaaagcactcagaattgtttttagttgagtcaagactgat
-atataaataagtttccctagttttttcgtggtgggacgatattgaattgaatcttaaccg
-aagagtttcccactctgtcgcacaataatacacgccaatatttccagccctgcttatgcc
-ttaatcggttactcaatctcccattgaagttcattttgatctgcatagaagtttcgggcc
-cagccttttttctgccaccttcctccaagctctgtagacgcactctaagattgatgctca
-catgtattaattctacattaacataaatatataagtcatgcatcttcgagtaaaatatct
-ggttctccaacatgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatg
-attgggttaactggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtct
-caagaccgtgtattcctcgtgctcggaagggctattacgcttacttccgttttggtatct
-taatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaag
-agtataaaagttgtttaaacgaactacttgctttacaataccggtcgtatatatcgccgt
-gaatccagaagattgtcttctttggattatcaaccgagatcctgtggaccgatgttttgg
-gaccttcacagaggactccaggtagagctcgcttttgcattaatctaagaattgtacctc
-tctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaatt
-actttaggccgaaaggcacatgagttattatacatatacgagatggtggtatacatcgaa
-ttcggggcatacactatagttgcattgtatttagctgctttaaataatatgatattacct
-tccttacataagacattaccggcataccctggttttcaacttgtggggctttttgacgat
-cgcactctcatttgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcg
-ctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaatttaaaattgaa
-acttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgc
-aagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatctt
-gatttcattcttcttgtcaattgccgacataggatgaaatcagattccaatgcaatacac
-agtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggat
-agtatacgggccttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgt
-acaatctcacacatagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaa
-ctttattagaagtaaaaatgtgggcaaaagaaggattccattttacaagacgattacaat
-gagttacatgtctctcaacgtagtctttccctagtagtctttgaactatttaggtactcc
-agaaaattttagcaaagggtttctgtgtgaatccgccattcatgtttatgatggaacaat
-aagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatatt
-caatttagtacagatccccagaagttaagctaagtgctctaaaatggcctaaacggttat
-caaagtaggtctaattactatactaacgggtgcatcgtaataactgctgtcgatgcaaca
-ctatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattc
-ttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaa
-atttaatctatgagcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttg
-acaaccgcacacataatcgaactattgatagtcgggagcataaccaggtgaacgtacttt
-gttcacgacatttattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaac
-gcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgag
-aactttagctggcttttggccagtatttagggaccaagagcactagccttaagctgaata
-ttttgccatttatctactgttataactttaaaacttggtggcaccagacttgtcgataca
-cacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttata
-ttatatttaaactaaaagatgatattagcttctgagggcgatagggctccaaatcataaa
-gaggaatatattattacacgattagaaacccacaacatacctcgaatcgcccaaaagttt
-gacgaaacttggcagtactccacatctcagtaatacagttgggagagtctcaaatgttgt
-tttattactcaatgaaccaccctcataatttcactgctgttccattaaatttgcaaacga
-tcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtagatgcataataaa
-aaaaactgctcgctataacacgatcatcgtgcattcttacttaggagcatcacccgcaca
-ataacgtaccttaaactacaacactattagaccgagtactgtaattcacgaaagctcaag
-ctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttgcggagaggattc
-aattattttccattgcacctactccactagattcgataaaagaaggtggtcctcccttaa
-aaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatcctt
-ccctaagaaacataaaggtttttaataatgtcgactgtgaactataactgcatcctttcc
-tgacctactccggttccttgttgttatttctgaacgagaccagtagataaacaatgtaaa
-ccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaaca
-taagaagtcataatcttacttgaaattaattttgccttttattttttttcaggctcgaaa
-ttaatgatttgttttttttgaccttctagttacgctaatatgcggtcgcctgtggtttct
-attgagtcctataacgggatgggatctaatacgtttggttactagtaaacaaggtataaa
-tttgataccggagtatcaactgtataacatcaagctttatgactcatacgcgaagtaatg
-acacaaggctttcaggagatcgcgagtacagagccactaaggggtgtattacgatagtga
-caccaccgagcgcactcactccccaagtagatttatgatcctacgctaagtattagatat
-ataaccaaagaggttctagtcagtgcaactcttagaataataattagccggttttgcctt
-tttaggcctaatgcaatattcagctagcccttatgtatctcgcgttccacagcaccactc
-atggcacgcgtttaaactaatcaaatataatctatgaatgttatgccagtacttgaataa
-atcaggttttttataagtccttgcatactctcgttatatactgttagagtcttaccccat
-agaaattctttcatctgcaaacttagaagaattctcagctacggggagcataaagtcccc
-aggatgttgacaaatacaacaaatgtggcttatacaaacactccatatgaaaatcgaacc
-ctcgtggtagttttagccgaaccttgtacggataaatccctccattttccaatagcagat
-acctatcctactacctcgtggtattaaattaaagcttgaaatatagagctgcatagctta
-tccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagc
-aaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagc
-aacttcgcttattaagacaattgtttataagccataattaaaaacatatgttcaacaggt
-tcattgatatttgtaattgcacaggtttttaataaggatctacgtaagtataatgaacaa
-actttttaccagagttatattctgtactttgaaaatgctcctctaccgccttagagactt
-tcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattca
-accgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaatataattttcagt
-tttcgaacacataaccctttgaaaatctgctatttaatgtctcacctgcatgcactatct
-tctatactgctcagaacggctatacgtcactatgctccaagtgacgatttaaacgaagca
-aggaataataggtttattttagtgcaaaacaattaagtgcggactacgtgctctttacaa
-taagccttgtgattgggctataggttaagtcccatattaacgatctccaatgtacaaaat
-cgacaatcgctttgcattacccggttactagtcgaattacagatagctgttagatactca
-ctctaattttggacaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatc
-cttccatcttaaacgattacatattatagacttgttcggggtagagatatcacagttgtg
-caaacattgtaaatcgatactagtttatgttggtagtctagttgcttttaccattccccg
-aaaaacttgatctactatttcgacaacagtaaacttgaactaggtaagtgaaaacagaga
-atgcctcatagtgccactatttgtccactatatgtaagtgtagctttacataatccacta
-tgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcccggatattacga
-ctgtaactataaaactagttactggtagcgcgccatgtatagatttgttttaccggttgt
-ggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttc
-tataaaacgataaagtaaagttgatgttcagcctccttcttatggttgcatcgagagtac
-actactcagtgggaaatagatcggggttcctacttcagattgtattatctaggcaattgc
-cgattgtgccatacctggataaaataagctacctacatgtgatgcttatctattatcgtc
-atactaccttagggtgtcctgttgaacgctacattaatctttagccgtttgagatgttcc
-aatggataggagtctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatg
-tgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtccttctggttctattc
-tgctgaactattgaatggaaagattggttgacctacgtactatttgcttgaagtcatcaa
-tttgacggggtgagagacatatggtgcatactttacggactctatattttagatcagaag
-cttagcagtcttctctacaccccctcacgacataattgcttttaagaatctatgtttgat
-tcctctacgggaattcggatccgttcgcatgtgcggtttatctaaaccaggggacatatg
-ttcagctaaagcatacgaacactttgctaactagacgtatgtatagtagctataaatccc
-gacgatatttacaaaaagaaatgagactcaaatatatacatagcgaccctacacttattc
-gcaccctgatctaggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgt
-attaaatttactgcagttgagattttagttgtctactaaggattactctaacccgtaata
-aggatcaagactcggtactagctttactatcattccctatgtgttttcctaactcacaag
-ggtacgtaccagcctatgtaattacaataatgataaagacacaaaggaagtaactttaca
-aatgagtctccagttacactagcttagtccctcccatcttgctttgaagtctaaatacgc
-aatctctgaggatatacagcagaagaacactcataacgttggagtccaagaattagactc
-atagggcccccaacatttaatatgtactgtgagtttgaaggtgttctattgttaattcct
-gctcttgatacatgacacgtactccgtgtttaaggcttcggactgactttctttcataag
-ttgagcaacgaaaatttcagaatcgataagttggattcactaactaatacggctgattga
-aaactccactccggacctatatggtcgacctttatacgtaaccgatataaaacttatagg
-ctggtatatcgagccttcctagcgcaatttcggatggggtttcttctactactcaacaac
-ggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgt
-ggagcatgtgtcattatggactggagcactcttaaatcactctgcgtgtgctaaacgata
-gatcataacatgtcctgagtaaattttcttgatacgtcgcaatataccgttattagttaa
-acgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgact
-catctcgcctaacacgcacacgtataaactcggaatgactgccgctcttacatattagaa
-atacagactacaccacggaagcattgggtcattctcaaccgctgtataaaagatgattag
-tcttataataagattaccaaagaggcagaatcatgggtagtaaatctattattcaagtga
-ttaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaaatattaaccgga
-cgaagtggtttacgtcgtactttcactattagtagtaaatacaaggtaacaccggggaat
-agtactaaatataatgatatctatcttcgggagaacgagtcgtctattgctttgaacatt
-ctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgttacttttgtctat
-tcaaaagattgaatagttttttatacaaaagccgcatacttatgacggctagtatacagt
-ttcatcccctagcatcaatgctatggacagtattgaacttataggaaattcttctaatag
-ggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatggcactagtattg
-tcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctt
-taacgaagcgacagcgacagaactcccatggataaccaattataaggcccgtaatcctct
-agacatcgtttaccaataaatccgctttctccgtaatcatgttgaataccccagagtagt
-ccagatgataaccgatgaaacacaagtctttctcaatgcacttacggtgaacttattacc
-gccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaa
-cttcatcaactttcgtatattcaacgccttgtaattttactttaagacgcctggtgatgt
-agattcttagataatcagtttgttatcggctgtactttaccataatttcacaggtttcag
-gtcaagaagattatagctgtatatacagttccatgctcggtgcacagaaacgtgatcgga
-taataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagt
-gtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagatt
-agattccttaatagaatataccgacctctagtccgaactaaactatagataacgccaact
-tcaggttaattgtctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggc
-catattggttcgagcactttagtttttgatgcataggatatgcaatgtatagctgaaagt
-actttatctgtttcaaactcacattgattaaaccggtaaacctttaaagactacaagaaa
-atattcagtgagggcaattttgtcaatcacaatcttccagctagagatacttcacaattt
-gtcttgaggctacgcaacattagacggattttcgcgttttattgaaataatcgaggggcc
-caagagtatccatagttcattttgtaagatttctttacaggcttattacagcttcttcag
-actcctacatgcttacgagttatatgctagcatgtgaacaatagattaatatacaggaaa
-acgtacattgagagagatgaccctacacagcgcaaccgttgagtactttcattaaagggt
-aacgctctcgagacagcatccttaagatggccttattgtcaaatcatttgcagaagtacg
-caagatccctaaccaacgtagaagaatccctacaaacacatgagacgcggtgaaaataga
-cagggtgttagtattcaatcttcggagtatcaatttcgccaatcttggtgagaaagcata
-ccctttcttcagagaaagaagatcaatcataacactatctttaacgaggtacgcacgcgc
-atcattacctgcctccatggatctttaggatagcggaaagtattggcagcgtattgtgat
-ttcgttcctactttatcaatttcacattcatatacatgtcttttatcaaaatcgccaata
-agataggatgagctatattagatgctagtagagttcgcgccaacatcatcgataggaata
-ctcaggacagcgtgataggacttttcaatccctaatactctctataattataactctctc
-ttaagtttggaggcagtaacgcgctctatataatcagtttgctgcaccattcttcagcct
-ctgatacatacaaataaattccacagcagtaagagggtttaattgagacatcttgggaac
-ttaggattttactctaacatcaccgaaacgattattggataccgtacctaaacgaacttt
-ctcaaggcagtaatataggacatccgcaataacacaaatgctgcctccccaggagttatg
-tcttcctggaggctatatcttacacccactcactataggcaaactaaagtttaaatgttg
-attgtctaaaaaaaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgt
-aagctataattctctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcct
-ttaaagctatttacgacgcacatctcagcaagttataaacatgttggaagtttctagtcg
-gaattcccaaagaacggatctatctaatgcattcctacatttttcctgtctgccgatggt
-gccatcctattcaaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaa
-ccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccgagccacatacac
-ggagaacattctaacatagcattctcaactcgatcatttgcaggttacttctttcctatc
-ctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacctaagaaacaatt
-cagtaaaacatgttcgaattcttggtatgggaacatcattgcagctatggtctaacgcat
-taatgtttgggtacatcttccatcatataaacaggaagagtctgacgacagggagtgctt
-gcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtg
-tatccgataagatttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaa
-tgtgaagcatatatgatctgctttaataaaactttatccataggatacgtttccaaatca
-attcaataattattagtcaaaatagataaggatgaacaacctgaaggccgatcggacgta
-gaaagtggtcccatcactttgagttgatattgttgaaccacacgttattatggttttcaa
-acagtctcaggatattgtatatacagataatccgataccagttgtctgacgcccctctta
-cgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaac
-taatttggaaagaagcacagtggatatgtctaaattcttgttattcaggcctgaatttaa
-tacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctctaagctaccact
-tctatgatacaccaatagttgttctacggaatctgataattggccaagtcataaacttcc
-gctgcgttcaacccccttgctcgaatatccaactcgaaaagacagccttttggtgtccgg
-aacaaatcagttacttcttttctgatgttaattctctgtggtcagatacagaccaaaaac
-tccgcggatttaccatcctccaagaacaaatttgcatcaacatagcattttggctacata
-ttctaagtctcaatagtttaggttttcaactacattatcccaacattaggattggaggaa
-taatagctgggtaagtccccttgcgtctacaatcgactattttttatgaatatgcttctg
-ccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaat
-caggtgtaatggcagcagccaaagagcatataattagcaacactctaagaacattataga
-tatgatgatagcgatcgtcatgatgttatccggtcacaatagtagcttcatcagctaatt
-cgttttgccagtggtgacttgcgctggaagaatcgttatacggtcccttccctcttgata
-cggtgggggcttattcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaa
-ccatctagtagtcaactatactaaatcacaaaatagtgatcaatacatacccgcttcatg
-gttttaaccatttaattgattaaagatattccgctaagaaccattatctacctaaactga
-tcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgtt
-atattgtatgtagaataataggtcttggagctaaatgatgtgattggtagtgaagactta
-cccttacaactttaccggtttctcggaagaatatactagagaatcaatgcatgggctaca
-taagcactttagtctaatgagataaaaaatacacgagtcttccatcatgaattttttgtc
-gaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaataactctcatat
-gttttatataacttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagct
-atgaggccgggatccggttgagctacatctatttgctacaagaaaaatgaaagcacattt
-gttgggagttctggctacactcatagagaaataagtggcccgagtgggtgcggcctgcct
-ccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcc
-tttatttcctccacggagtagcccgtaatccggttcgaaagagaccattgaagttaattt
-tcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctctt
-caaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacataaatatagaagg
-aatgattcggcgagttaattttcgccttctccaacatggcatccctacgttcgttataag
-gaccatacatgtaggttttaaaggtttgcggttaatcgatatttacatcatagaaattct
-atagtcaaatttacaagactctagatactcactcgttgcagccggctaggaagcgctttg
-taccttacttcccttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactca
-tacctccgtgaagagggtagatagactattaaagttgtttaatagtacgtattgatggaa
-atgacccgtaggagatttaccactcaatccacaagattcgctgctgtgcattatcaaaac
-agtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggtagagatacctttg
-caatttttcgatgaaggcgaccgagataaatgagctataacactgtatgtcttttgattg
-ctataaaacacagaaacggatattaatttaggccgtaaccaacatctgttatttgacata
-gaacagatggtcctttacagcgtattccggccttaatattgaggtccagtgtattgtcct
-cctttaaagaagttgattgtaactgacttaaataagacatgtcacccattcactgggttg
-caactgctggccctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacc
-tgcgtttaaaagacataaatgtcgctatgaaggttattcattaattttagctgttttctt
-agaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttg
-tcaagtaggcgggcatcattgagattgtaagaaataaagccataaccagccccggaatag
-aaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttc
-ttatcagaggacattgcaataaaatctaacaccctcccttgtgtggttgggccatttgta
-cttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtcccataaacgatc
-attctcgcccacttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgt
-ccaatgttaggctaccttctccaactttagtacaacgaataatgtccgattaacaaggag
-tcaatttgtcatgaccagttcattcaggtacttgtatctatacggacgcgttccagagta
-gtatttgaaattttgaggttctactgataagtttagctatcgctgtatgtctgaataaga
-atttaatgtttatcttcgataaataacaattaacaactcctaggtgatacactgtgaagt
-ctgctgttccccaaattacatatgctattttgttcacataccatgaagttaagctaagtg
-ctctataatggcataaacggttatcaaactagctcgaatttcttttattacgccggaagc
-ggattaactgctgtagatcaaacacgttaggatagtgtcgttttcatatatatctaaatt
-cggtctaacatgcattacccatgcttgataacgtagcacttcgcagtctaattatgtaat
-gtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgacta
-cccggatctttagcctttagggtctaaacagaactaatattactacgtgtcatactccgg
-agcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtat
-caaattaacccagcaatacaataagcatgaaaataattgtaatcgggtttgggccggaat
-cccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactggattgagccacaa
-actcaactagcattatgctcaatatttggccagtgttctacggtttgaaatttataaagg
-ccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaataggtttaattaga
-acatccgtaggatttctgtttatagtagatttatactaaatgttctgattagattctgac
-ggccttacccatacaattaataaagacgaatatattagttatagtttactatccaaataa
-attaagcgaatcgaaataaactgtcacgatactgggcagttatcaacttatcacttatac
-agttcggacactctatattggtctgtgagtactctatcaaactaactcataagttaactg
-cgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatg
-acacatatggagatgcataataaaaaaaacggctccatatttctcgttaatcgggcattc
-ttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaactattagaccgtc
-ttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattct
-gataatactgggcggacagctggaaattagttgccagtgcacctacgcaaatagtttaca
-taaatcaacgggctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaa
-gcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtag
-gtcaactataactccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacg
-agaacactactgaaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaag
-ttggtggtagtgcacggaataacataacaaggaatattatttattcaaattttttgtgac
-tgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgct
-tatttcaggtccacggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgt
-cctttagactattcaaggtagaattttgataacgctctataaaaggtagaaaatcatgat
-tgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccct
-ataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttat
-gatcagacgctaacttgttcttagagaaaaatacacgggatactctgtgcaacgatttca
-ttaataaggtgcagcttgggacttttttggccgtaggctttattaacattcacagtaggt
-agcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaaatataagctagg
-aagcgtttgccaggacttctataatgcaccgttttttttagtacttccttactagcctta
-gtttatgttagagtctttccaattacaaaggattgaatagccaaaatttctacaattctc
-agcgaacgccagcttaatctaaacacgagcttcaaatattctacatatcggcaggagtca
-atatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataat
-taaatcctttttcaattaccacagtacgtgcattagaactactgctatgaaagtaaacct
-tgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaac
-gagttgatgttctgacgctagagcttaccattcgttaaacagataactaaaatttaatgg
-ctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatt
-tttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtac
-catagaagtatgtataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaat
-cagactagtcacacttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaact
-ctacaaggcatgggatgagattctaccgactccggataacactttacgatcgcgcataac
-tctagctcttagataagtttaacttgtcgatctcataaacagttcaaaatctgcgattta
-ttgtatcaaatccatcctctatcttctataatcatctgaaccgcgatacggcactatgag
-ccaagtgaagattgaatccaagaaagctataattggtttattttagtccatttaaattaa
-gtccggtataagtgctctgtacaatatgcagtctcatgggcatatacgttaactaccttt
-tgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaa
-ttactctttcctgttacatacgatctcttagtttggacaactagcccatgatggcgctcc
-tctagcgcatgaacctactttataattacatctttatcgatgaatttttttagactgcgg
-aggccttgagttttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtac
-gctacttgcttggaacaggcaccgaaaatattgatctactattgcgtcaactctattctg
-ctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgtcaactatatcta
-agtcgacctttactgtatcaacgatcacggagagaattaccgaatacgaaacctcaggac
-taaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagggtagcgacacag
-gtatactttgggtgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttc
-cggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactcc
-ttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttc
-agatggtaggagataccatttggcccattgtgactttacgcgattaattaaccgacatac
-atctgttcctgagctatgatcgtctgaataaattacggtctcctcttgatacctaatggt
-ttctggagacgtttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagct
-acgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaagggataaagaga
-aataacggacttctccgtagattagcctgatattttgatgggaatcatggcggcacatac
-gtaagagttgcgtgaacgaatattttggacggcgggagacacatatcggccattcgttaa
-ggtctctatattggacatcacaagcttagcagtatgagctactaacactcaagacattat
-tgattttttcaagatatgtttcattcctctaccgctattcccatacgttcgattcgccgg
-gtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgttgcgatagagac
-ctatgtatactagagagaattccccaacatttttacaaaaacaaagcagactaaaataga
-tacagtccctccatacaattaggaccaacatgttattgccgatcctagcacacacaccac
-aaactcagaacttctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaa
-ttagcattaatattaaaactaattaggataaactataggtacgagctttactataagtca
-ctaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataa
-agaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagagtagtacctacat
-gcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataa
-agttggactccatcatttagaatcatagggaccaaaacatttatttgctactgtcacttt
-gtaggtgttctattctgaattcctcatattgatacatgaatcggaatacctgtggatccc
-ttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatcgagaagttccat
-gcaattaagaattcgcctctttgaaaactcatatccccacatatagggtccaccgttatt
-cggaaacgatataataattattccagcgttgagcgtcccttaagagcgcattttcgcttg
-gcctttcttctacgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcac
-cccatagaactacctctgagagcgcgagatggtggcagtatgctctgcagctagcgttta
-gaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaattgtcggcattag
-gagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctag
-tccgcagagatacgattacagactcagatcccctaacaagcaaaacgattaaatcggaat
-cactccccctatgacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctc
-aaccgcgctttataagatgttgagtctgagaattagatgacctaactgcaagaatcatgg
-cgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcg
-gtctaaggacttagatgataaccaagaactggtttaccgagtactttcactattaggagt
-aattacatgcgttcaccgcggaatacgacgaaattttttcatatctttatgagcgagatc
-gtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaattatagattcatt
-atacagatgcttacttttctctattcaatactgtcatgagttgtttttaaataagcacca
-gaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgatggacagtattct
-actgattgcaaagtagtctatttcggcttagcagtacgcatgcctatttttttgcaggca
-cagaataatatgcaactaggattctcggcatccaattaacaggctaaaacaccaccgaaa
-gacaggtaatctacgaagttgatgtttactacagaaagcgaatgatatcacttggagaac
-attttagatgcccccttttaatctagactgagtgtaccaatatatcaccggtctaccgaa
-tcagcttgaataaaccactctagtactcatgataaccgagcatacacatgtatttctcaa
-tgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggcgacttatacttc
-tgtctttgagtacagcacaccctaatgaatctaagttagttgttgatacgaattgtaatt
-tgactggatctcgcctcctcatctagattcttagagaagatgtttcttatagccggtact
-gtaactttattgatctggtttatggtaatcaacattttacctctatttaaacgtccttgc
-gccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtctggaggccgaga
-aaagaaatgcacagagtaagctctctattgcgacatctacgtagaaactcgcatttcaga
-tcgagtaagcaactctcattgtgttgattcagtaatacaagattacctacgcttctacga
-aatatactatagatttagcctacgtcacctttagtgtcgagtcggagctttgaagatcgg
-atgcggtgtggactgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtc
-gatatcaatgggatacctcaaacgtctttatctctggataactcacattgagtataccgg
-taaaaatttattctattcatctaaatagtcagtgagggctagggtcgcaatcacattagg
-ccacatacacatacttaacatgttctattgacccgacccaactttagtagcattgtagcc
-gtttatgcaaatatgccaggcgccaaacactagccagagggcattttgttacatttattt
-aatcgattattacacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtc
-aacaattcagtaatttaatccaaaacctaaagtcagagacatgacactaaaatcacatta
-aggtcagttagtgaaggaatggctaaccagctagagaatgcatcattaacaggcacttat
-tgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaa
-cacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgt
-agacaatagtcgggacttagcagacactggatgcagtcatagaagatcttgcataacacg
-ttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgc
-taacttttccaacacgtttgtgatttcgttcataatgtatcaatttcacagtcatataca
-gggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttcagagttcagtta
-gagcctaatgattcgagagcaataatcaggacagcctcataggaagtgtcaatcacttag
-aagctatattattataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatca
-gttgcctgcaactggcttaacaatatgatacataaaaatattttcatcaccactaagacg
-gtggaattcagacttattggcaacttaggatgggactattaaataacccataagatgttg
-ggataaagttacgaaacgaaagggatatagcctgttagataggaaatccccaataaaaca
-tagccggcctccacagcagtgatctattccgccacgcgatatctttataccacgcaatat
-accaataataaaggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgc
-gtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagct
-tcctctgcaagatacaatatgactttttagcttttttactaccaaatctcagaatcttag
-aaacaggttggtacgtgctactcggaattcccaaagtaccctgctatatatgccattcct
-tcattggtccgggctcaccatggggccatcatagtaatagaaggtagtaaaactagttga
-tttccgacttttaacaatcactatcctgacccagatatgggttccgactggcccttactc
-cagtaagggcagacacacagacaacgagaacttgataactttgaattctcaaatcgatca
-ttgcaacgtgacttatttactagcctactcctataattcatacgtcaaatacatttcaac
-ggaggaagataataagtaaatattcactaaataatggtcgaaggagtcctttgccaacat
-aagtccacatatgcgctatagattttttcttggggttcatattcaataagataaacagca
-agagtatcacgtcagcgagtcattgagatcttggctagcattgtgatagcatattctacc
-taaatggtagtctagcacagagtggataagatatcagttagatatagacaagtactataa
-cagatctcgcttcgttggattgtatggctagctttgatgatatgattttataaaaattga
-tccagacctgacctggccaattatattcattttttatgagtaaaaatagataaccatgaa
-aatactcaagccccttaggacgtacaaagtggtaacataaatttcaggtgttattctgca
-accacacctgttttgggttttcaaaaaggctaagcagattggttttacagataatccctg
-aacactggtatctcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctg
-aagttttgtaaactaggcggaaaatatgttcgatagatccactcgcctgaggtagaaatt
-cgtcttagtaacgcctctttggattacacagaatagtgtactgacacgtacactgctgca
-gcagccatacgctaacattaaaattcgttgagtctacatttgttgttattcggattatgt
-tattgggaatagtatttttattcccctgcgtgaaaccacatggatagattagcctactcc
-taaagactcccttttggtctacggttcaattctcttactgagtttatgttcgtaattata
-tcggcgcagtgaatctcctaattatcaccggagttaccagacgccatgaacttatggcca
-gaaacattgcatgtggcctacataggattagtatcaagagtttacgtttgcaacgacatt
-tgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgcacgcgactataga
-agttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgct
-tgatacctgaattgagacatgtataagggctattgccagatgaaaaactgcatataaggt
-caaacaatataagaacattatacataggatcttagcgttcctcaggatggtatacgctat
-aaagtctagcttcagcagctaaggagttttgccagtgcggacttccgctggaagattagg
-tttaaccgccctgacatcttcataaggtcgggcctgattcaaacccctggagtgccgtct
-catacttgaattaatcgatggaaaacttcttctagtctaatattattattaacaaatgac
-ggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaatcattttaaccta
-tcatccattagctacagataatgataccccgatccgactagggggtaagtggttgttccg
-ttaggataaaccatgtaaaacgttagagggtttgtagattaattggtattccagataaat
-gaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaa
-gacagtataaatgaaggggattcagaagcaagtttctcgattgactgaatttataaacca
-gtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatat
-ttatcgagtctataaatatctttggttgtatattacttcacaatcaccaattctaaatga
-ttcttccactgtgcgggtggagatatcaggacgggttaaggttgacctacatcgttttga
-tacaacaaaaatcaaagcacatggctggggacttctcgatactatctttgagatagtacg
-ggcaagagtgggtgacgcctccctacattttcaagtctatcggataacttctcggtaaaa
-cgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaagttttaccggtc
-gaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggtta
-tccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatg
-cgtatggttctgatatatagatcgatgcatgaggacactttattttagccggcgaattaa
-tggaatccatacgttacttatttggacatgacttctaggtgtttttgctgtcccgtttag
-cgatatttacagattagtatttcgtttctcatagttaattgtatctagatactaactcgt
-tgaagacgcataccttgccatttgtacaggacttaactgttccgtgcgtaatttgaattt
-cttataggttcttcaaggcacgaatacctcactcatgaccgttcatactctagttaaggt
-cgggaatactacgtatgcagggaattgtaacctaggagatttacaactctttaaacaaga
-gtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatca
-cctagaaacctactcatacatttgcaattttgagatgtaggcgaaagagagaaatctgct
-ttttaacggtatctcttgggattccttttaaaaacacataacgatagtaatgtaccaagt
-aaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaa
-tattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaac
-taatgtcaccaagtaaagggggtgaaaatgctccccagggttctacagacatagagatgg
-tcagaacacgacccccctctcaacgcagtgtatttgaaatatatggacatatctacctta
-ttctgtaattttagatgtgttctgtgtataccgatattgataagtcaataggcttgatta
-cgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcagattgtttcttttt
-atgccataacctgcccaggaattcaaaaggttatcgatacccgatatgctgtgaattatt
-attctaatggccactcattcctgcttatatctggaattggcatgaatatcttacaaccta
-aagtctggcgttgcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaa
-ggtgggtacgtcacataaaagttcattagaccacactttgtgccgacgtatatagatata
-ttacacgtatagggaatgttttctcctaggtgacccgaccttctactaaggttgtacatc
-gtataatggcccattaactacgaggaaagtggtattgacctggtaatgcacgttcttcga
-tatataccgacgaggtaaagtctactattgcaaagtttgacgttatactgataagtttag
-atttccctggatcgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaa
-atccttggggatactatcgctactatcatcggaccaaaattaaataggctagtgtcttat
-cagaacatcatgtttaccgaactgatctattttccaatttaagctgatattacgtccgcg
-tatttattttagttccccggatgacgattatctgagctacatcatacaagttagcatact
-cgccggtgcattgatttcttatttcgctatatcttcaagttcacaggcttcatatagttc
-caattagcagtataattaggttttgtaactttaaccatactttataaaaggttatattgc
-acaactgatcaagcatccgctataacccgagctttaccagttagcggctaataacaaata
-agatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatt
-taggcaatgggtagtaataagtataaaatgataccacatatactataacaatgaaattat
-ttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgacatagggtcatcc
-atgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgt
-tataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaaaaccaatattta
-tcgttcgttattgctggtagtacaacatcacgagcatttctcttttgagttgatttatac
-tatatctgctgatgtgattatgtcccacttacccagaatattaagaaagtcctagattgt
-aggtatacttgactataaatataatttaagactatacaaataatctggctacattatgcc
-atcgtagaaactgataacgtagtaacgtcggacactagattttggtcggggagtaatcta
-gcatactaacgaatttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtc
-ttcaatacgtttagactattaaggactcatttcgagatccagtattaattatacgcatcc
-atatttatactgaagacggattgagttaggacgacaagctaaacaaatattaagttaagg
-attagtattatattgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgtt
-acttattcagagagacttaattcggttatgactggcagctcacctggaaagtaggtgaaa
-ggcaacagaagaatattgttgactgaattctacgggctacgaacgtaattacaaagcggt
-tcgtaaagagcataaagatcaatacaatggatctctacagtattacgtaaataacataca
-taaacctggtgttgattcgactagctcatagattaatcattaattgaagctacgaagacg
-cggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttataatatcgcgctt
-aaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatatttactaggaata
-ttagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacattggatgcatggct
-gtgggggcacaggatacttaccattagttcacctacaagcggcgtgagagggtctcagtt
-ttagccagcgcagagaagtacgggcctttagacgattaatgctagaattgtcataaacct
-cgtgaaaagctagttaataatcatggtgctagaagaacacaacttttctataaaccagtt
-ctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcac
-atagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgagagataaatacac
-cggatacgatctgcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtag
-cattttttaacagtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggt
-ttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtt
-tgtactaattcctttatagactgagtgtatcgtacactcggtacaattacaaaggatgga
-agagcaaataggtcttcaattataacagtaccccaccttaatctaaaaaccagcttcaat
-tagtattaatttcgccaggagtatatatataaatatctaaagactaaaagactcgtactt
-ttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattag
-aaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaatt
-catactcgattaaggcctataaaactgttgttggtatctacagagtgattaaaattagtg
-aatcagattacgaaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtg
-gtacaattggctgtagtagaattttggtataaaataggtgataaaccggatgggtgtggg
-cgaattcaaaagcggtttttgttccatagaactatgtagttggttataaaggttgtaatc
-tcggagattaggttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtg
-ggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggataaacaatacgca
-tataacttgacgatcgagcttatatcgacctatttgagaagtttaacgggtcgatataat
-atacaggtcttaatagccgattttttctagaaaagcaatcctatatcttagttaatcaga
-tcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacattcctttttgtcc
-gggtggggactccatttaaagtatctcacctagaactcagcggtaatagatgcagtctct
-tgcccagttacggtaactaaatgttgatacttagaattgctaaattttagtctagacatt
-tccaggtaaaccggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgc
-tcaaattgcaattgagggccctactatagacaatcatcagactttttaattaaatagttt
-tccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgta
-tgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttc
-taagatggactataatcgattaggctaattccgttcgcaaatcacagaagcaatcttact
-caaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaa
-ttacccaatacctatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagat
-taagtctgaagcctagagacaaagggatactgggcggggaaacctgctccttcacggtaa
-catggtaacaacagaatttggttaaggttaaaacgaaatatactcggagtgaattactgt
-taggtttcgtcatcggatcaataagtagtttccgtgaagacactcttatattagatctcc
-gaaattctgacccgtgcattaggcacttggtaggagattccatttggaacttgctcaatg
-taagccagtaatgttccgaaataattcgctgcaggagcgaggagccgctgaataaaggac
-cctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtcaattccagagctg
-gagatacattcatcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttt
-tcctaaacacaacggatttagacaaattaccgaatgcgccggagagtagcatcttagtgt
-catgcctatcatggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgc
-actcaaagttccgccattaggtaagctatatattgtggtcagaacttgaggacaactatg
-agctactaaaaataaacaattttgtcatttgttctagatatgtggcattcatcgaacgct
-tgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatca
-ataacatatagttcagatagagaacgaggtattcgacagagaattacccaacattggtta
-ttaatctatgcagaataatttagataatgtcactacataatattaggaccaaaaggtgat
-tccccagaagacaaaacaataaacaatctcacatattcgctagtacctatgtatgggtat
-gatcttctgattggacggggataatttccaggtatattaaaacttattaccataatctag
-acctaagagaggttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaag
-acttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaatattctgtataaa
-ctgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgt
-tattctgatcaactaatatcataaactgccactacatcttgtacaatcattcgcaacaat
-acttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaatcagattcataaa
-ggaatacgaataactctggatccattaccacgcaagggatttatttacggctgattactt
-tttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgcataaataatagca
-cctaatatagccgacaaagtgattccgataacagattttaagttgtccagccttgagact
-ccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatcccaagtggatgg
-ggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcga
-aggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattg
-gaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaa
-ggaagcacgcattgaagcagctacgcagaactgagaagatgacactctaagatacaatta
-atacaaaaacgttttaagcccaatctatcaacagatgtaagatgtctaatacacaagaat
-aaaaccttcatgtcccgatgtataataacagctttatttctgctggtcgaggtgaagtag
-tggaaattactccatcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcg
-tccatccctctctcctagtgatccgtatatccaattagaggataaccaacatctgcgtta
-ccgacgaatttaaatttttcgactatttaattccgttcaaacccgtattcgtagtaagtg
-tttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaa
-ttgctgatctaggatacatgctttataaacatgcttacttggctattttatttactgtca
-tgtgggggtttttattttcaacaagtatgtgctaccattggataatctggcttcaaattg
-aagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtcccattagaacta
-cgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaat
-ttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaa
-tgcgtatcatagaaattcgtgataatttttgttccaacctttgaatctagactgagtgga
-aaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcgaatcatcttata
-actgcattcaaatggatttctcaatcatctgtacgtcaactgttttaacaataacgtcag
-aataaaccggcacaatgagacggcggtctttcactacaccacacccttaggattataagt
-gacgtgtggattcgaattctaaggtgacgggatctacaagcctcagctacattaggtctg
-aagatctttcgtatagccgcgtatgttactgtttggatatgggttatgctaatcaacagt
-tgacagcgagtgaaacggccttgcgacctgaaatctttacggttaccttttgattcaaga
-caggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcag
-cgaccgagtaacgacaagttcacatcctctatgcaactatcattgtggtcattaaggtat
-tcaagattaactaagagtcgaccatatattctagagttttacaattaggaaccgttagtc
-tagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgac
-acatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgg
-gataaataacatggtgtttaaccctattaatggtttctattaatctaaattgtaaggcag
-cccttgggtcgaaagcacattaggccacatacacagtatgaaattgttcgagtgtccaga
-ccataattgactaccatggtacacggtgttgctattatgactcccgcaaaactcttgaca
-gagggaattttggtacattgatgtaatcgatgatttaacagtaggaactagacgtcatcc
-gttagactgagttccgacatgctcaaattgtcaggatttttatccaataactaatggctc
-tcacatgtaaataaaatcacattaacgtcacttagtgatggattcgctaaacagatagac
-tatcattcatgaactggcactgtttcgattatatttgcaacatcgaacatacttaaagtt
-aaatacgacatcattcaattaaaaaaattcagtacacctctaatgagtatcccgctttgg
-aggaaagagtagcactttaaatggacaatttaggccggactttcctgtaaatggatgaag
-tcattgtacagcttgaataaatcgttagggttagtccttacatccaccatatgttaatga
-ataaagcctgagggaccttagagctaacttgtccaacacgttgctcatttacttaataag
-gttgaaatgtatcagtaagtgacagcgagtgtagattttgaccatttaactgaccttcac
-agttttgtcttcagacgtcacttacaccataatgatgacagagcttgtagatgcacacac
-tcattcctagtgtaaatcaagtagtagctagattattataaagagatattttctggcgtc
-gaacgtaacacagagagagtataaggggcatgataatggcttatcaatatgtgtaagaaa
-aagtttttaatatcatctaactcggtggaatgcacacttatggccaactgaccttgggac
-gagttaagataccataagaggttgcctgtaagttaagataacaaagggatattccatctt
-tgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgctatgcagccacc
-agagttatttatacaaagaaagagaccatttagatacgttaattctgcttgcgatttatt
-aaacagacatttcacgtccaaccactacaaaagccctatcgcaagacgatcattgtatta
-tagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaattgttacattgtt
-tactacatatgatcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaac
-taacctgagatatatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagta
-atacaaggtaggaaaacttctggatttcccaaggttataatgctctatactgaccaagag
-atccgttacgactcgcaatgaatactctaagggcactcacaaagaaaaccactaattgat
-aaatttcaatgataatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaa
-tgaattagtcatagaaatgtcatagcaggaacataattactatattttaacgatttaatc
-gtagttggagtcctttcccaaattatgtcatcagttccgatttagatgttttcgggccct
-tcttagtaaagaagttaatatccaagactagctcctcacccacgcatgcacatattcgcg
-agaagtctgatagaatattcgacagaaatgcgactctagctcacactcgttaactgatca
-ggtacttatagacaagtacgttatcagatatcgcttcggggcattgttgcgctacctttg
-tgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgatattattttttta
-ggaggaataatacagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaac
-atatatggcacgtgttattcggctaacaaaactgttgtgccttttctataaggataagca
-gattcgttttaaacatatgacctgtaaactgggatctacaaaagaggtacttaaaataaa
-ttgcgcaacggtttagatctgcggatctttggttaaagagcaccattagatgtgccatac
-ttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggatttaaaacaattc
-ggttaggacacctactcggcggatgaagcaatacgataacattaaaagtcgttcagtcta
-attttggtcgtagtacgatgagctgatggccaattgtatttttattaacagcactgaaac
-aaaatggagactttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcgg
-aatgaggggatcttcggaagtatagcgccgaagtgtatctcattattataacaccagtgt
-acagacgacatctaattatggccagaaactgtcattgtgccattaagaggattagtagat
-agtctggaccgtggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcg
-atctaaactgcacgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgc
-gtttgtttttacgattctagtgcttcttaacgcaattcagtcttctagatccgctattcc
-aacatcaatatctcaatttaaggtcaatatatataacaaaattagacagagcagctgaca
-cttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagt
-ccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatg
-tgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctact
-attagtttattatgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgt
-taaggcaggaatctttgtaacagttcataatgttgctaaagattatcagaccccgtgaag
-acttcgggctttgggcttcgtaccgtagcataatacatctatatagttagaggcttgcgt
-gttgttgtgctattccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatg
-gtaacctggcgacctacttgttaagtcagtttaattcaaggggattaagtaccaagggtc
-gagtttctctgtatttattatactgtaggcaagaagcttttttggcgagatttaagactt
-aagcctatggtaaaaatttgatagtgagcgactatagtaagagatttgggtggttagtaa
-ttaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgt
-gaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattggcggggcacttat
-ccataatagatttctgtttgtacgccaaactctgcctcacccctccataaattgtattgg
-ctagaggttaaattctccgtaaatagagacacatatagttttatacaattgtttgaatca
-aagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggggcagagcatctc
-ttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagattatacaaagagat
-ctggatgaagatattcgtgcaatcactatcgttatgttagagagttccatgcatgaggac
-tcgttttttgaccaggagaattaagccaagaaataactgacgtatttccaaatgaattct
-acgtgtttttcctgtcacctttagccagtgttaaagatgactatggagtttcgaataggt
-tattctatagacattataacgagtggaacacccataccttcacagtgctaaaggtaggaa
-cgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaagaaataacgcat
-cacccgtcattctattgttttcgtcgggattacttagtaggcagggtattctaacctacc
-tgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcct
-aaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgactt
-cttcccctaacacagaattctcagttttatagctatctagtggcattcctttttataaaa
-ctttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgc
-cgtgtaagacttggaacccatgtatattgacggcatggcgtggctaagcaggtattgatc
-ttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccggggattagccgccaa
-aggggtctaatgacatagagatgctctgaaatcgtaccaactataaaagcacgggatttg
-aaatatagcgacagatcttccgtattctgttagttgacatctgtgctgtctttaccgatt
-gtgatttggctttagcagtcatttagtttcgttactcattgctcgtgcgatagttccacc
-gaatatggcacattcgttctttttttccattttactgcaaaccttttcaaaagctgatcg
-ataccactgatgatggcattgattagtcgattggcaactatgtcctgcttatatctccaa
-ttgcattgaatatagtaaaaaataaaggctcgccttcccaatgggctacggagtacacga
-aaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtgattgagacaaata
-gttctccagacgtattgagatatatgtctcctataggcaagcgtttctaattgctgacca
-gaaattagaattaggttgttaatactatattcgaccattttattccacgaatgtgctatt
-ctactggtattgctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagt
-ggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggta
-tctgccatattgttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaa
-atattaatgaggattgggtcgtataagaaaatcatcttttcagttcgcagatttttgcca
-atttaaccggttatttcgtcagacttggtagtgtagttacaagcatcacgattatatcag
-ctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattgcgctatatattc
-aaggtaacaggaggcatataggtcatagtacaaggataatgaggtttgctaactttaaaa
-attattgatttaacggttgattgaaaatctctgcaagatgacgctagaacacctgatgtt
-caagtttgccgataataacatataagatgaattactgtctttagaccctcatgttaatcc
-gctaacttagggcggaaacaatgttaggctatgcggagtaagtactatattatgatacca
-catagaatttaacattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccga
-ttaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaa
-ggttcagctattttggcaatgggtgagtaccgttcttagtgatttacgaacccataatct
-aggcgacttaatatacaagatttagagttacgttttccgggtagtacatattaacgacca
-tggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccag
-aatattatgtttctactagagtgttcgtatactggaatttaaatattatgtaagactaga
-caaattttatggatacattaggccatcgtagaatatgatatagttgtaacgtccctctat
-agattttcggagggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggat
-ttgtaattaactgatgcgcagcgcttaaataagtttagactattaagctatatgttcgac
-agcatgtagttttttttaccagaaagtgttatactgatgacccatggaggtagctcctca
-tgataaaaatattgttacttaagcattactattatagtgttcaaactagtaccgttgcat
-actttaagaatcagacatggcgtttcttatgcagacacacttttttagctgttgacgccc
-acctcacatccatagtaggtcaatcgcataagaacaatattctggactgttttattaccc
-agaagaaagttttttctttccggttcgttaagacaataaagatcatttcattcgttctct
-taacgatgaactaaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaa
-taattaaggcaagataagaagaacaggaacgcgcacgtcggagataactctaatagtctc
-tttattccgtttaatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgc
-aaacctatttatgtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttt
-tatcaagactttcgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaa
-aaccgcagggagtcgctctaagtgttaccaacccctcactactacgcgaaggtactcgat
-tattccttgaatgggctgaaacatcgtgattagcgtcttatgattcaggctgatagaaga
-aaacttattttctatattccacgtatacaatcacactcgtaactaaatagttcccagcgt
-tgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtgcataagtacagt
-tagtcgtctgtcacataaataatccgcagtcgatctcattacaggtattgttgttggtca
-accttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaa
-tatcataatagatgccatacacggttttacttgatatgtttacagtccttgagttgcaat
-cgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtca
-ctaggtaaaatgacttaggatggatgagcatttaggtattctatgataacactaaccatc
-atgtttctaaaatcctcaggaaatttgtattattttaccaacctgtatttatagaaagtg
-cttttgacttaaagaagccgaagtgttcaaattaaggagtacctgattgaaagaatgggg
-aattgtaatctgtaactcaattacaaataagccgttctaaggattaaggctttgtgtcta
-agcaactcacgtgaattcgaaattcatactcgattaacgactttaatactcttctgcgta
-tctacagactcatttaaattacggaatatgttttcgtttttggtttccagctcgcacgta
-cgcgtttacaaataaggacacctggtacaattggctggagtacaatgttggtttttattt
-gctgattatcccgatccctgtgggcgttggcataaccgggttttcttcaagactactttc
-gtgttgcttatatacctggtaatatcggtgagtagcttagggcttaatcacaatactaac
-aagttctctatggattggacagggcggcatccgttgactgaacgatctattaatccattc
-cctgcactggataaacaagacccatttaaattgaccatagagatgttagcgtcatatttc
-tgttcgtgatagggtacatatattataaacggattatgagcagtggttttctagaaaagc
-attcatagttaggagtgtatcagatcataccactgaaccatagagcacaattctctactg
-gctatacttcattcctttttgtccgggtggggacgaaatttaaaggttctaacctagaac
-gcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaa
-ttgcgtattttgactattgacagggcatcgtaaaccgctactcgacttggtatctgtaat
-ctgtatgtagatagagtacgggcctataattcaaattcagccaccgaagattcacaatct
-tcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagccccacccattctctg
-ttatatccgagcattaatgtagtttcactgtactacggtcacgccgtagagtcggcaggg
-caaatccaaaacaatttaggctgagaagtggcactataatagtttagcctaagtcccttc
-gctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggt
-atcttgaatactgatagctctcatggtaccaagaactttcataacctctttatttaccaa
-acctgttctactagcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccg
-gcgtaaccggcgcctgcaagctaacatgggatcaaaactattggcttaacgtttaatcga
-atgagactagcactgtattactctttcgtttcggcagcggatcaataaggaggtgacggc
-atcactctcttatagtagatatcacttattctcacaacggaagtaggatcttccgtcctc
-attaaatttgcaactggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggt
-cagagcagacgatgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacg
-ggctatgcggaaattccagacctcgagttacattatgaaacgtgtcattccatctcatta
-aatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtctattttcccaagg
-agaaggagagtagcagcttagtggcttgcctatatggccccctaagtacgtactcggcac
-gcttagaagattgggctaccccgcactatatgttcccaaagtaggtaacctagatagtgt
-cgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttggcaggggttata
-cattgcgggcatgaagagtaacattggacatgaacggacattcgaaccctgtgagtttaa
-taccctatctccggatcattataaagtaaatatacgtcacttactctacgtgcgtttaga
-cagtctttgaaactaaattggttatttttctttcatctagatttgtctgtatctaactaa
-attatagttccacataaagctgattcaactgaagacataaatataaactttctaacatag
-tagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagtagttcctggtaga
-gttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtga
-acatacataataccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcct
-acgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgctt
-cgagtatgtacattcagatctccttagtatcatcaaattatagattttacggccacgaat
-tattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagt
-tgaggttggaagaagagtcattatgctataccaagaactctccatccagtacctagaaag
-gcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttg
-taccagatggcttttataatagaaactaagtttcccgaataacggtgtacgataacagat
-ttttaggtgtacagacgtctgactcaatgaacacacattgggacctgccccgggaggagt
-agtagataattaccttctccagcgcgggtcttttaatatcacaacataaaaatactaatt
-aatatcacacaccctcatcctcgatggagcctagcatcatacacgtttgatagacaacgc
-caattttactgtaatatgatattcgaatctagtatgtggacgctgtaccacattgtttaa
-aggagctccctttaccgacatgaacgaagcaagctttgtacaagatacgaagaactcagt
-actggtaactataagagacaatttatacataaaagtgttaagaccattatataaaaagag
-gtatgaggtctttgtaactacaataatacattcatcgaacgatggagaataacagagtta
-tttctgctgctcgagctctagttctgctaatttctcaatcttgatgccactcgtttgagt
-cttccattcgctcttaacgacgcgtacatccctctctcctactcttacctatatcctatt
-actggttaacctacatctccgggaaagacgtaggtaaagtggtccacgattgtattcact
-tataacacctagtagtactatgtgttgctgagagtgaggacacacttactctacgagttc
-aagtccatatggacattacactttttcagcatctaggtgtcatgatgtattaacagccgt
-taggggctatttgattttatcgattgtcggcgtgtgtattttcaacaactaggtgctaca
-attcgtgaataggcatgaaaattcaagattgcagttcctatcttgtataatctttccttt
-ggacgagttgtaccatttcaactaacctgcaagtggggggtcatccatatgaagatttgc
-caaatacctggagaccctgaaaagtttatccagattaataataacaaacaaacctaagcg
-aagaacgtcagctttaataaactatcactatcatagaaattcctgttaattgttcttcca
-aacgttgaatagactatcacgggtaatagattgaacacggagaacgtttatccggcttgt
-aaaatatcgtcgaatctgctgataactcaattatattcgatggagaattcatatctaccg
-cttagcttttaaaaattaagtcagattattccgccacaatgagaaggcgcgagtgcacta
-atcaaatcacttaggattattacggacgtctgcattacaatgctttggggtagggttata
-caagcatatgattctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggc
-atatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatct
-ttaagctgacctgttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaa
-actctaacatagcgtggcactatgagtacgtgtaacgacaaggtctcatactcgatccta
-agataattctcgtctggaaggttttaatctttaactaagagtagaacttagtttattgac
-ttttacaattaggatacggttcgcgactctaccacagggcatcatacctggagctctgct
-atctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatctactgagcaatccc
-tttaagcattcctagtttgagagccatttagatattgctgtttaaaccgattaatggttt
-ctattattataaagtgtaacgctcccattcgggacattgaaaattagcaataagacaatg
-tatgatattcggcgagtctcaacaacattatggtctaccatgggacaaggggttgatatg
-atgaatccacaaaaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgtt
-ataaggacgatctagaagtattcaggtacacggtgttcagacatgctctaattgtcaggt
-tgtttataatttaacgtatcgctctctattctaaataatataaaattaaccgctcgtagg
-gatgctttccagtaaaagatacactatcattaaggttatgcaaatgtggcgatttgattt
-gaatcttagtacattcttaaacttaaatacgtattatttaaagtaaatatattatctaaa
-ccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgac
-cctctttcatctaaagcgatcatctatttcttctgattgatgtaatactgacccttactc
-cgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaat
-caactggcgctggtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcat
-tttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgat
-gactctcattgtagatccaatcacgctttcctacgctaatgaaagttctagatagtgtag
-gtgttagacagaggttagcgcctacatccttacacacacagtgttgaacggcaagcataa
-tcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcccgcctttgaaca
-atgatgccaaaatgtcctgccctagagttatgataaaataactgctgccctgtaacttaa
-gtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaa
-aatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagagtacatttagtta
-ccggattgcggcttgacatttattttacagaattttatcggcaaaacacttcatatgaac
-tatcgcttcacgataagtctatgatagactagcattcgtagagaacaggaagagcaatca
-ttatatatgaagtgttacagtgggtactacatatgagatcattaggtctatatccggcct
-tcctcataagaccttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacc
-cagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggttttaactagggg
-ttattgatatttaagctaaaagagttccctgaacactcgaaatgtataatctatcccaac
-taaaaaagtatacctctaattcagaaatgtcattgagattagactgatgtcaatacgcta
-ggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaatacctccatcttaa
-gttctatattttaaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtg
-cccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaatctctagctact
-atcccacgaatgcactgatgccagtcatggcgcttacattagtcgacagaaatccgacga
-tacctatcacgcgtgaactgttctggttcttattcaattcgaagtgatctcagatacatt
-acggccatgcttgcccttcatgtctgctgagcagttttgttataggctgaatctcctcta
-agcgaaattgataggatttttggtggtcgatttagtctgtacctgcttattaagattcaa
-aatgacctacttcttacgccgaaatgatagggatcggctgaggaggataaatatacgctg
-gtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactctaatctccgaga
-taaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtat
-agtccaccattagttctgacttacttaatatagactgaccgagattgtagtatgtggatc
-caagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaaga
-gttaattaatagtactgcactataattgtcggcggagtaccatgagctgttgcccaattc
-gatgtttattaacagcacgcataaaaaatccagacttttcaattagaattaactataaat
-ggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtatagaccccaactct
-atctaatttttataacacctctgtaatcaacaaatcttattatgccatcattatgtcatt
-cgccaagtaagtccagttcgagattctctggaccgtgcaatagtattgtcaaattatggt
-aatggaatccttcttctaacacccttagaaaagccacgagaattgacaagttgggcgtgc
-ttgtccaggagcaacataagtgccgtttctttttacgatgatagggattcttaaagcttt
-tctctattctagatcccagttgccatcatcaatatctcaattgatgctcattatatagtt
-cttatttagtatgtccagatgtcactgaagatcctgcctagaaccgatattctcgacagg
-atcatcagttcgacggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaag
-gaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagt
-tttactgcctttaattagtagtcgattagtgtagtttgatattatctaccttatagaatg
-taaacagtaacccggccttaatggtttggcaggattctttgtaaaagttaataatgttca
-taaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaa
-ttcgttttacggagtggcttgcgtcttgttgtccgagtacacatattgctcctctccccc
-actcttctaggaaaatcaattatgctaacctgcagaccttcttctttactatctttaatg
-catgcccagtatgttcatagggtagacttgctatctattttgtataatctacgaatgatg
-cttggggcgcgacttttaacaattaagccgttgggtataatttgagagggtgccacgata
-gtaagagatttccggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagct
-caccctcctcagttctccaaccctgaaccggctaagtatgactgtgcagtattaattttg
-aatacatattgcagcccctaggatacattatagatgtctctttcttacccaaactcgccc
-gcaccaagaaagaatgtggattcgattgaggttaaattagccggaattacagacacagat
-tcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatg
-gattacgttggggatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaag
-aattcacagaggattaatacacttctccatgaagataggactgcttgcactatccttatc
-tttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataa
-cggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatc
-atgactttggactttagatttgggtattctagagactgtagaaagactgcaacaacaaga
-cattcacagggcgaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttag
-gaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcggccccttgaatta
-cgtgcatgcctttgctaaaagacctctgggaaatagattgaatattctggacagcagcga
-atcctgattatatctcaagcgaatatatgacccgcaagaaggatttatactagaataagt
-ctaagaaagggcattgggtcacttcttccactaacacacttttatcagttttataccttg
-agagtcccatgcatttttatatatatttaactttcgttgcgtaaaactttaaatatgatc
-cgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaat
-cgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttctatgctaaaaat
-gtatagccccgcattagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgta
-acaaagataaaacaacgcgatttctatgtttgccaaagtgattaagttgtatcgtagggg
-tcagcgctgatgtcttttcagtttgggttttggatttaccagtcttttagtttcggtact
-atttgatcgggacattcgtccaaacatgatggctcattcgttctttttttcaattttaat
-caaaaccttgtatttacctgatacattaaactgagcatcgcatggaggtggagattccca
-tatatgtaatcatttgatatcctattccattctttttagttataaataaacgctccactg
-cacaatgggagtaggacttcaccaataattagcatctactgtaaacaagcgccgtaacga
-aatgattactgattgagaaaaataggtctcaacaacttttgacagatatgtatccgatac
-ccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaa
-tggttattactccaatgggctattctaatccgatggatacgtaggagagagtgtacctac
-accgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtg
-cgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaaagaagtcccctg
-aatagcccttagataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattc
-ggttaagttcgcagagttttgccaagtttacaggtgatttactaacacttgggagggtac
-gtacaaccatcacctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagt
-gtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtcataggacatcga
-gtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtgataatagctgcaa
-catgaagatagtaaaactgaggttaaactttcaccatattaaattatatgttcaattacg
-cgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgggtccctatcccg
-actttgtacgagattttgataaaaaatagtattgtaaattcatttgatggcgtagaaccg
-ggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcc
-tggctcaatatttataatagtaatggttaagattgtggcccaatcgctgagtacccgtct
-tacgctttttccaacacataatcgacgagaatgtatttaaatgtttgagacttacgtttt
-ccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgtagttttctcatct
-gctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggct
-atttaatttttatggtacacttgaatatgtttagccataatgtagccaatactacaatat
-cagatacttgtatacgacctatagacttttgccgaccgctcgtagagtgatttagaaaga
-tgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgt
-tgactattttgctatatgttactctgaatgttgttttttttaccagaatgtgttataatg
-atcaaccatgcacgttcctactaatcatataaattttgttacgtaagcttttctatgata
-gtggtctaaagactacccttgcatactttaagattaagacatgcactttaggaggaactc
-acacgttttgagctgttctagcccacctataagccattcgtccgcaatcccataactaca
-atagtcggcaatcttttattacccagaactaacgtttttatttcccggtacgtatcacat
-taatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgct
-tcttgagaatacagattactgttagaatgaaggcatcataactagaacaccaacgcgcac
-ctcgcacattactctaatagtagctttattcagtttaatatagacagtatttgaaccagg
-cgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatt
-tgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataac
-cagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacat
-cacttcgtaccgaagggactactgtattccgtcttggggatgtaacagactgattacagt
-cttatgatgaagcctcattcatctaaaattagttgatttattccacggatactatcacac
-tcctatagaaagagttaccaccgtgggaagctagatataataaataaaagacatacaata
-ttagtatggctcatgatctacacttactcggatctctctttttttataaccagtagatcg
-cattacacgtattgttgttccgcatcaggccctaggggctcaaacttccatggtggataa
-ctaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgggtttacttgatt
-tctgttcagtcattcacgggaaatcctaggagtctttcataacggcggtcttagtaggaa
-tgtagtcaagctctgtagaggtctcgacggaattggtatttcctggcatcacaatttacc
-tagtattggagatcacttaaaataatgttgagataataatcaggatatttctagtatgtg
-acaaacctctatttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaac
-gactacatgttggaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtg
-ctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgtaatactactgta
-accaagttattactcggctgcgtagataaagtctcatgtaaatgacggtttatctgttac
-ttttgggtttcaacctagctaggacgccggtactaattacgacacctgcgtatagtgcag
-ggtgttcaatgtgcctttttatgtccggattataaccatccctctcccacttggaatatc
-accgggttcttaatgacttagttcgtcttccttattttccgggtaagatcgctgtggacc
-ggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttc
-actgaaacttagattaatcaatgcactgcactggattaacaagaacatgttatagtgtac
-tgacacatgttagactaagaggtctgttcgggttagccgacttatatgtttaaccgattt
-tgacaactgggttgagagataacaatgaagagtgaggactgtagaagatcttaaaactgt
-accatagtgctcaattcgctaatggcttgaattatttaattgttctaaccctggcgtcga
-atttttttggttcgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtac
-cgttagaaagcggcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaa
-gctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaat
-tctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtg
-gtctataccaccaaaaagtatatgggatatcccagaatttatcgactttcaatcgtctac
-cgtcacgacgtacactaggcagccctaatccaaaacttttgaggatgagtactgccacta
-ttatactgtaccatttgtaacttacattttatatcttcaaagaggtagatattgtcggcc
-attactgtcacttacactaagggtagcttgattactgatacctctcatggtaaaaagtaa
-tttaagaacctatttttttacataacctctgctactaccgttagtgttttagtcggttca
-agtcacaaaatccctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaa
-acttttgccggaaccgttaatcctatgagaataccactcttggaatcggtcctttaggct
-gaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaa
-acgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatcttacactctttt
-cttaactaagtatgagagcaacctcactcctgaacagcttgttacctaacgagaagaggc
-tttaagtagcctggagcctcaaccggatatccggatttgactctcatccacttacatgat
-gattacggtcattacatctcatgattttctgagtgccctatagactgggaatttaatcta
-ccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatg
-ccaccataagtaagttctcggaacccttacatgattggcctaccaacctatatatgtgac
-caatgtacggtacatagagtgtggcctatcatattcaggtcatcgagctcagtatttaaa
-gattatatggtcgctgggggtattcagtgcgcgatggaagactaacattggaaatcaacg
-gaattgacaacacgctcactttaataacctatctcaggataagtttaatgtaattagacg
-gaactttctctaactccgtgtactaactctttgaaaataatgtgggtatttttatttcat
-ctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtc
-ataaatataaaatttagatcttaggacagaggaaagtgctttcccgagcataggatctgg
-cctacgccagtagttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagg
-gtagtgttcgatactcagcggggaactgacatattacactaaggaatcaaggcccttcgt
-atgggtcatgtttatatatttaattacttacgctatttgatcgagaatagctatagtaac
-gtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatactgtgtatcatatt
-attatagatgttaaggcatagaattattggtattgatgtacaaaaaattatgggtgggca
-gtaccgataggcattacgagcagtgcagcttggaagaactggatgtatcctataactagt
-aagagccttaaaggtactacatacccagggatgttaccatcattaatttggccatcttca
-atcttcgcaatgcatactttcttctacaagatgccttttagaagacaaaataagtgtcaa
-caataacgctgtaacttaactctgttgtacgtggaatcaagtctcactaaagcaactaac
-attccgacatgcaaacgcaggactactagattattaaattcgccagcccgcctcgtttaa
-tataacatcataaaaattctaagtaatatctcacacactaatccgccatcgtccatagca
-tcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgccaagctagtttc
-gcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaaccatcctacctt
-tgtacaacagaccaacatctctgtactggtaaatagatctgaaaagttataaatataact
-gttttcacattgatagaaaaacagctatgtgctatttgtatatactataataaattaagc
-gaaacatggagattaaaacagtgttttctcatcctccacctcttgttctgctaatttata
-attcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaacccgacataaataga
-tacgacgctgaacgagatcctatttctcctgaaaattattagcacggtaactcctaggga
-tagtggtactagttggtatgaacgtataaaaacttgtactactttctcgggatgtgaggg
-agcaaactattactcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatac
-ctgtctggatggattatatgcaggtaggcgagagtggattgtagcgatgctcggcggggg
-tattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactg
-catatcgtcgattagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtcc
-gggcgcatccatatcaagttttgcaatagtactccagaccatgaaatggttatccagatt
-aataataacttaatatactttcactacatactcagcgggtattaaatttcactttatgtc
-aaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaa
-accgagtaacttgatcagccttgtaaaatatagtagaatatgatgttaaatcatttatat
-tccagggagattgaatagcttacgattagctggtataatttaactcacatgattaagcaa
-atatctgtaggaccgagggaaagaataaaataaagtaccatgagttcggaacgctgcatt
-acatggcgttgggctagcctgatacaagaagatgagtatggagctctcttcatcgggacg
-tgacaaccctagcgtaatcttggcagatcccggagcagatgattatcgtctaacactgtc
-tttaccaatgcacaacgcatagatttaacctgaactgttctggattcactcctgactaca
-gcctacaactcatttctatgcataactcttaaagacagtcgcaatatcagtacctctata
-cacatcggatcagactagatcataagataagtctcctctggatccttgtattctgttaag
-tacactacaaatttgtttagtgtctgggacaattacgataagggtcgcgactagaccaca
-gggcatatgacctccaccgctcctagcgagtctccaatctgcaagcactcatacgctagg
-ggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacccatttagatatg
-cctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatcaaattcccgaca
-ttcatattgtccaataagtatatctagcttattcggactcgctaaactaaattatggtat
-aaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggc
-cttatggcagcgtatacagctggtataacgaccatatacaactatgaacggactagctgt
-gaactaagcagattattggatccttgtgtataattttaagtttcgatctatatgctatag
-tatagaaaatgttccgatcgtacgcttcctttacagttaaacagtctatatcatgaagct
-tatccaaagctggacatttgatggcaatcttacttaattatgaaacttaattacctatta
-ttgaaagtatttatatgatcgaataagatttgctctataaacaggtcgtccattcacgac
-ctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatctatttcttatca
-ttcatgttatactgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcac
-gctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgat
-atcgatgtctatcccacgcgtcattttcaaattggttatctacggataactgtgcgatga
-actactataggtcaaaattatcttcaatctcattctagatcatataaagatgtccttcgc
-gattgatacgtctacagtgtgttggtgttacacagagggtagcgactacttacttactaa
-ctctctcttgatccgcaagcataagccaggttaaagtgctctatctttttctgtggatta
-taatagttataccgccttgcatctaggtgcccattaggtaatgccctagtgttttcataa
-atttactcctgccatctaacgttactttaatttcccagattcaataggtctctcatttga
-aaattgttatatgtcaacaaagaatataatagctgagtggaacaatacactgtgagggag
-taatacatactctaaattttctttacggtttgcgcctgcacagttttttttatctatgtg
-atccgcataaaaagtaatttcaacgttccattcaagttaagtcttggtgacactagcatt
-aggagagatcaccaagaccattatttatttagctagggtttaagtcggttagaaatatca
-gataatgaggtctttatccggccttacgcagtagaaattggaaatttcgtaaagcactga
-gttcaatggaagtatggccgaacccacataatgcacaaatcaagtcgatttcttccgtcc
-ttttagtctcctgggaactacgggttattcatagttaagctaaatcagttaacggaacta
-gacaaatgtataatagttcccaaatatatatctataaatcttatgcagttagggaatgca
-gatttgaatcatggcaatacgctagctcggaactcaactacaagtgttggatgtacgaat
-tcaaaggtattacatccttatgatgttcttttttggatacttttatgacgacttccacga
-agtgaaattatgttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgt
-tctgtttataattctcgtcataatataaatacaagcatatgaggccagtcatggagcttt
-catttggactaacatttccgtagagtcatatcacgcctgtaatctgatccgtctttttct
-attcgaagtgttatcagatacatgacgcccttgcgtgacattcatggctcctgacatcgg
-gtcttttaggctgaatctaatctaacccaatttgtttggattgtgggtcctccattttgt
-ctgttaatgcttattaagattaaaaatgtactacgtatttagacctaatgattgcgatac
-gctgtggaccattaatataagctgcgccaggggatttttccagatcatctggcctgtgta
-tatgttcaaatctaatagccgagagaaattactccgacggaaaataaaggcagataagcg
-tttcagagcaccatcgtggcgtttagtcaacctttagttcggaatttattaatatacaat
-ctcactctttggacgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaa
-gtataccagcatcatcaaagaacagttaaggaatacgactgctctataattgtccgagga
-gtaccttctcatctgccaatagtcgttgggttggaaaacaacgcattaatatgccacact
-tgtcaattagaagtttctataaaggggacgagtaactgatttgagacctagcacggcaga
-ggacgttcgtgtgacaacatctctttataagtttgagataaaatcgctaatctacaatga
-ttatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaagg
-ccattactatggtcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaa
-acactattgaatactgccgccgcattcgccagcaccaacataactgcacgtgcttttttc
-catgattggcattatgaaagatttgatctatgattcttaccagttgcaatattcaattta
-gcatgtgttcctaattattgtgttattatggtctatctcatcatgtaaatgaagatcatg
-acgtcaacacagattctagtcaggatcatcagttcctcggggaaatcgcacctaggaaca
-gccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaag
-cctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcgagtactgttggt
-tcatatttgctacatgattgtatgtaataacgatcccgccctttatcggttcgatccttt
-atggcgataagttatgaatcgtcagtatctttagatcaaaaactcaactagtacccagtt
-ccccggaggaacggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcaga
-ggaatcagtttcatccgatcccactcgatgattggtatagctatttgccgaaaagccaca
-acgtattcggtactatcttgtttgattcccctgtatcttaattcgcgacacttgatatct
-tttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaattatccagttgcgt
-ttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataa
-ttggagtttgcaggacgaatagctcacccgcctaagtgatccaaccctcatcaggataac
-tatcactgggcagtattatttttgatttcatatgccaccccctaggagactgtagtcatg
-tatctttcttacccaatctagcccgaaacaagaaagaatgtcgattccagtcacctttta
-ttagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaa
-agttgaaaacgacttgctctattcgattaccttcgcgatctcaatcgattacgctaaatt
-ttaatgcccgctgaaatatccaacatttaaaacaggattaattctctgatccatgaactt
-aggactcattgcacgtgacttatctttctctcttaattcatgctccaatacggtgggcta
-aaccacttttatcacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggca
-gcgaaacgggtcaatctgggtatcttctattgggacggtacatttcggttttatagacta
-tgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcac
-cttgggattgccatgtgtccggaggattacatacatctaagaaacattctaaactatgta
-tagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtactctgggtattag
-agtgtatattatcgacagcaccgaatcctcattttatagcttgacaatttatgacccgaa
-agaaccttttataagtctataagtatatctaacgcaattgcggcactgagtccactaact
-atctttgagcagtgttatacagtgagacgccatggaaggggtttatatattttactgtcg
-ttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagt
-cgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttac
-attccttgcttatttgcgataaatcgatacaaccccattaccagaaaaacccggagaatc
-aattactctgcagatcttatactaaaaaagagattacaacccctgttctatgtgtcccaa
-agtgagtaacgtggagcgttggggtaagagcggagcgattttaactttcgcttttccatt
-ttccagtattgtactttacgttatatttgagcggcacattcgtcaaaacatgatccatat
-ggactgaggtgtttaaatgttaatcaaataattgtattttcagctgactttaaaatctgc
-agccattggaggtggagattccaatagatgtaagcaggtgatatcatatgcaattcttgt
-gacttattaagataccagacacggcacaatcgcagtagcacgtaaacaataatgacaatc
-gacggttaaattccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaac
-gtttctctgagatgtataagttaccaaacactggagaattccgctaaactaaggacaatt
-tccgtcgtattaattgttgacaaatggttagtaatacattcgcagtggataatccgttgc
-atacctagcactgagtgtaaataaaaccaatcgactactggcatttcgggctaacgacta
-gatgttagcctatgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttc
-ttattcgttattagaagtcacctgtagagacagtagagatgacctaaatttggtttgtcc
-agtcccgaggtgatctaatgattaggttaacttagaacagtggtcaattggttaaagctg
-atttacgaacacttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtat
-tcggtcatctagacaaccccatcgctgggagtttggacagtgttatgattcgtaaatcca
-ccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaatttaggcttttt
-tacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgtaaacggtcacca
-gttgatatttgttctgctaggaagcgatgtacaaaataagcttaataagatttaggtccg
-accttaatttcggtccatagcacctctttctaagtgttttgcttaaataattgtattgtt
-attgattttctgcgagttgaacacggaaaataagtcaaaaaggacacttttaggttcata
-tgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgt
-ggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttagtccactaggtat
-ttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaatggcagaggggct
-cctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatcttttggttcttt
-ataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagcc
-agaatggaccaattacgtcattagctgttacgtctatacgaaatatagactgtggacgac
-ccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaag
-caggacaacacagtattgtactggtcaattggttcatagatctgactatgaatcttcgtt
-tttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttt
-tcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggccttaatgtaacatta
-actattccactgtaggtggatctaacaaggttggacatgtgctaccaataagataagaat
-ttcgtccgcaatacaatatctacttttgtagcctatcttggattaacaacaacttacgtt
-ggtatttcaccggacgtatcaaatgattctgattttaatgactgagagtaaacatcaacg
-aatcttatgtatctttaagccgctgcttgacaagtcacattactgttagaatgaacgctt
-cattactacaaaacctaccaccaactcccacattaatattatactagatgtttgaagttt
-atttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttag
-ggtattaattgtggtcggtgcatttccggccccatagcgctccgcggggagaaactatgg
-ccttcatgacagcccccccataacatctaggtaatggtcggataactataaacaaccctc
-tccagagaactgtgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttg
-cccatcttaaagactcttttcactattttcttgatgcctcattcttctaatattaggtga
-ttttttaatccgagaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacat
-attttaaagaaatgaaatactttttgactatccctcatgatctaaacttacgcggagcta
-tctttttgtataacatgtacagagaattaatccgatgcttcttccgattaaggacatagc
-gccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaagtgattaagtga
-tcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaatacttggagtctt
-gaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgc
-tatttcctgccttctcaattgtccgaggattgctgataacttaaaataaggttgagtttt
-taataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagtta
-tcaagaactacgggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatc
-gtacgaatggtatttgtacaactgctttcctttatcgattgctcgagaacattataaagt
-ctattactatggattaagactgtatacaagtgtttaagcggagcccgtgataatctataa
-ggttttggtacctttatctgttacttttgccttgaaacatacatacgtacacgggaatat
-ttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaa
-ctgaaagcgcccacttgcattataacccggtgcggaatctcttagtgactcgtcaggagt
-ttacgcctttgagacctctcgacaggacccattttgatctagtcgttataggtagagtgc
-ctttcctatcgcaccattaccttctagcaaacttagagtattcaatgaaatcatatcctg
-tttatactaaatgttataggctaatgacacagctgacactaagaggtctcttcgggttac
-ccgaatgagttgtttatacgatgttgacaactcgggggagtcatttcaatgaagactgag
-gactcttgatcagattaaaacgcttaatgactgataatttagattatgccgtgtattatt
-taagtgggcgaaccctcccctagaatgggtttcctgagaaaagtcttagaacacagtatt
-ctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtc
-aatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaagagctatgttctg
-acacgtccccaatattaggcaaaggctccaaaagaacagtcaattgattaactacgggct
-tggtttctccgtgaatccttgcgccgctataccacataaaaggatagcggtgataccaca
-agtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaa
-ttttgtccatcactactgccaagagttgactggaccagttggaaatgacatttgatatat
-taatagagctacatattgtaccactttactgtcacttacactaaccctagcgtgattact
-catacatatattcgtaaattctaagttatgatactagttttgtaaatttaatcggcgaag
-acacgttctcttgtacgagcttcaactaaatatttcactgtagccaaccactttaaccag
-aaggataccttaatgccgatataatattgtccaggaaacgttaatactttcacaagacaa
-agcttggaagaggtactttacgatcacctgatagatcgaccggaacgattctatataggt
-ttggtctgagaaatttgtagctaaaaccatgttccataggaactcctctgtaatgggcaa
-aatgcagatagcgttcaatcgttgcttaactatctatcacagcatcctaactcctcaaca
-gcttctttcctaaagacatcagcaggtaagttgacggcacccgataacccagagcacgat
-tggaatctaatactctgtatggatcattacgctaagtaaatataatgattttctgactca
-aagttacactgcgaattttatattaactggttctatttgttaaataccacaacctctcgt
-caacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaaccattacttctgg
-cgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcgccgatcttagga
-acctaatactgctcagtagttattgtttatttgggccatccccggattatgtcagccatg
-gaacactaaaagtcctaatctaacctatggacaaaaagctcacttttataaaattgctca
-ccttatgttgattgttatttgtccgaaatgtctataactcagtgtactatctattggaaa
-attatggccggagttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaat
-aattatcagctggaaaatcatctaatatatattatattgagatattacgacagacctaag
-tgctttcccgtcatgagcagatggactaacactcttggtaatccttctcgttttagttgg
-taatgtttagtctaagtaatatcccgactcttacttactcagagcggaaatgacttttta
-aactaacgtttaaaggcacttagtatgcgtcagggttatttttttaattacgtacccttg
-tgcagagagtttagctattcgatcctacttagtatgaaccatgagagtacaggttggtaa
-ttcacagagaaggtcgagaagattatttttgatgtttaccaatactatgaggcgtattca
-tcgaaataattttatggctgcgcacttcacatacgcaggaagaccactgcagcttgctag
-atctggatgtatcattgtacttctaagagcctgaaaggtaatacattcccagcgagcgta
-acagattgtatggggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcat
-ttttgatgtcataagttctgtcaactataaccctggaactttaatctgttgttcgtcgaa
-tcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccactacttcagtttta
-aattagaatcacaccctagggtattagataataattaaatgtcttaggaagagatatcaa
-aagatgcagacatcctcaagtgaataagtctccggtctttcacaaacacatggttaagcg
-atgtggttttgactagagacgttcgccaccatcgtaatatttctggttacctgcgaacgt
-gaaccaaatcttacttcatacattgcttaaacagtacaacttatctcttatcctatagag
-atctcaaaagtttgtatttttactggtttcaaattgagagaaaaactgcgttctccgatt
-tctatattattgtttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccga
-ctcagattcgtatcctatgttagaatgagtcatcaaactacggtcacgcgtacattacag
-agtaaactacacgaatgaaagagataagaagatgaaagagttaataggtctcctgttaat
-tatgagaaccctaactactacggattggcctactagtgggttggaacggatataaaattc
-gactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatcc
-acagtaatagttggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtg
-cagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgag
-caaggaattggattctgtgaacggaatatagtcgagtagatggaatttcctacactgcga
-aaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggcaattagtactcca
-ctaaatcaattggttataaacttttagaatatctttatataagttcactacttacgctgc
-gggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaataaacggcttgac
-tatagataccctaattctggcataaccctgtaacgtgtgaagcatgctttaatagacgac
-tagatcagcttatagaatggatatgactgccacattgaagagattaacattagcgggtat
-aatgttacgaacttgtttaacaaaatagctctaccacacacgcatagtataatataaagg
-tcctggagttcgctacgagcctggaattgcagttcccctaccctgagtaaacaagatcag
-tatggacctatcttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtga
-agttgattatcggctaacactcgctttaccaaggaacaaacaattgatggaacaggtaag
-cggctggattctatcctgaatacagcataataatatttgctttcaatatatagttatgac
-actcccaatatcactaactctttacaaatcggatatgaagagtgaattagagatggagcc
-gatcgttccttgtattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtc
-cttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcatagagactctaaa
-ttcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaactgtaacatttac
-gtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtt
-tcgcgatacataaaaggccccactttcatatggtcaaatatctatatcgtgctttggacg
-actcgataaactaaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaa
-tttagagtatatataacttccggacgtatggctgccttgaatcctcggatatcgtcctta
-tacaacgatgaacggtatagctcggaactatgcagattaggcgatccttgggttgaattt
-ttagtttccatagatatgagttagttttgatatggttaccatacgtccctgcattgaaac
-ttaatctgtatattgattgatccttagcaatagcggcacatttctgggcaatatgactta
-attaggttacggtttttactatgatggatacgttttatatgatagaataacagttgctat
-ttaaacaggtactacattcaactaatactgtttcactattgtgtccaacatagggaatat
-attgcctgaatagatgtattatcaggcatcttttacgctccaggtagaactaattaaaaa
-tgatccttagaaactttcaagcaacataagctaaaagttacgccaattataagccacatc
-ggtaggatcttcaggcattcccatatccttctctatcaatcccgtctgttgctaattggt
-tatctaagcatatcgcggcgagcatctacgataggtataaagttgctgctatctaattcg
-tcataatatatacatggaattacagattcatacgtcttcagtctcgtggtgtttctaaga
-gcggacccaagaattacgtaatatctctctcgtgttacccaagaagttgacacgtgattg
-tcagctatctttttctggcgatgttaatagttataaacaattgcatatagctgcaaatta
-gctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcac
-tgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgca
-gtgcaaaaataatatctcagggtgtaattatttctctaattggtctttacggttggacca
-ggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaagtgacattaaac
-ttaagtattgctgtcaagaccattacgacacttcaccaacacatttatgtattgtgctac
-gcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaa
-atgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaac
-atatcatgtcgttgtattacgtccttttactagcctgggaaataccggtgattcagagtg
-aacataaatctctgaaagctactagacaaagctagtatagttaaaatatatatttctttt
-aatattaggatctttgcgattgcacatttcaagcatcgcattaacctacctccgtactct
-tctacaacggttgcatgtacgatttctatgcgatgaaatacttatgttcttagtttgggg
-ttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgc
-gggcaccaaaacgatctcgattcttaggtttataattatagtcagaagataaatacatgc
-atatctggacactcttccacatgtcatgtcgactaactttgaactacagtcatatataga
-ctgttatctgatccgtatgtgtctattactactcttatctgagaaaggacccaatggagt
-cacagtaagcgatcatgtcatcggggctttttccctgattataagattacactattgctg
-tgcttggggcctcctactttttctatcttaatcattttgtacattaaaaagctaagaagt
-aggtacaacttatctttcccatacgagctggaccattaatttaacagccgcaaggcgagt
-tttaatgttaatctggaagggctttatgttctaagcttttagcactgagaaattaatccg
-taggaaattaatcccacataacccggtaagagaaccttacgccccgttactaataatgtt
-ctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctccttaatacaggccctg
-cgttatattcgaccgtacctataactagaccaccatcttaaatgtacagttatggttttc
-gacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgtactgggggtggtt
-atcaaacatttaatatgaatctatggtaaagtactagtttatagatagccgaacactaaa
-ggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggt
-gataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattgcccaatcgttct
-actcgtactctttatagcctaacgccttttcttggcgctaattagcctaatccaagaagg
-agtctaacaaaattacttaaccatactcttgtctattcggcccacgcatgcgcaagctca
-aaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattggatctatgagtc
-ttaacagtggaaatatgatttttagattgtgttcagatttattgtcttattttggtctat
-ctcatcagctatagctacataatgacgtcttaactgtttcgactaaccttcagatctgac
-taccccaaatacaacatagcaaaagaatgatgctaacgcttaactatcctttcacgatct
-taacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcgtggaatcaattt
-ttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttca
-agcactttagcggttccatccttgatggcgttaactgatgatgcgtaagtttatggtgat
-ctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttagg
-tctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcct
-atagctttttgcagttaagccactaagtaggcggttctatagggtttcattcaaatcgat
-cgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttcaggcccgccaca
-atggtttcaagtttcaacttccgtttattggctgtccctcaatagagtcgttctcagggc
-acgactctcgttcgttattcataagtccagtttgatccacgaatacagaacacgcatatc
-tgataataaaagcttaacgataactttcacgcgcatggtttatttttgatttattaggca
-accaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaag
-tatcgccattacagtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtatt
-ggcgcccttgatttaataataattacggctaaacgtattgatattttccaggaactgccc
-catctcatgagatgaccctaaattttattcacacctcatttttaattcttttatatcacg
-attatttatctgagcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaa
-tgcatgctaatatacggtgcgctaaacatattggttcaattcaatgtaagctacctcgga
-atttgcttgcactaagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaa
-gggacttgtccgttggagtcactatggagttacaagcattataaatctaaggaaatcgca
-gtatcagtccttaccccaaagatacttcgcattccctggggtacggaccatgaaatactt
-ctttcatacatgataaacgatggagactcggttaccaccctggtagttactccatcaatt
-ggagttaactaagatcgctattacaggctttattagccaatcatcacaagcctcttttta
-gagattcacaagttagcaaaccaaagttcctttgataagtctttaacgagatctatccca
-attccggctaggagtaaaatttatatatttgagatcggggttaaagtcacacgcaatgca
-aggggtttttatatggtaatgtccttccctaattaggtaattttcagacctccgagagag
-agtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatgacactacagatc
-atccctggatgagcatcgactttcattacttgattagttcagttaattcgtttcaaacca
-ttttcaacaaaatcccccagtagatatgtatatgcacatcttagactaaataacagtttt
-cataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagc
-gagggtaactggccctgttccattgtaatcgatgggacgggacgttatattgcagaccca
-aagtagtaataaattcagccatatggacggagggggggaattgttaagaatataattcga
-ttttcagctgaatgtaaaagctccagccattcctcctccacttgacattagttcgaagaa
-ggtctgagaattggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagt
-accaagtataatattatgacaatagaagcttaaattcacaacgtaacatatctgttagca
-tgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcag
-tagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaatggttagtaata
-atttcccagtggagtagaagtggcataacgtgcactctctgttaataatacctttagact
-actcccatttcgccagaacgtcttgatggtaccctatgggaaacactcacacatgcttat
-tgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggac
-tgatgacctaattttggtttctcaagtccagacgtgatattttgatgaccgtatctgaca
-tctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgat
-aatgctgtcatcactatcatgttttagctaagctacactaccccatcgctcgcacgtggc
-aaagtgtgaggattccgatatcatccatgtgtacgaattcctaatactcttgctcagggc
-acttagggttattgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtct
-tataatcaccgtaatcggtaaacagttgttatttgttctgataggtagacagctaataaa
-gatgctgttgaacagttacgtcccacctttattgccctacagtgaaactagttcttactc
-tgttgctgtaatatgtctagggttattgatttgctgccacttcaaaacggaaattaagtc
-attaacgaaaatggttccttcataggtaaagatcaatccccaattgaagccagaaatttt
-gagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaa
-aaaaatgttgagtccactagcttgtttattctggctcaaggtacgtggaacacgtagtat
-tttgatactaatgccagacccgctacgatccctgtactgtgagcagagccgatcctcaga
-aatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgtt
-gcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgt
-taacaaagatactctgggcaacacacatacttctctcatgttgtttcttcggacctttca
-taacctttcctggcacatggttagctgcacatcacaggattgtaagggtctagtggttca
-gtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcat
-ccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttaga
-cgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatctatatacgttgcac
-agcggatacaaataagataagaatttactaacatttaaattttcttattgtcgagcatag
-attggaggaaaaacttatttacttggtatttaaacggaagtttctaatgtttatgattgg
-atgcacggacagtttactgcttactttcttaggtttcttgaacaacaggatgcactagta
-acatgtctcgttcatgcttccattaagttcttcttaaacttacacaaactacctaattta
-gagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgtta
-ccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacatt
-cacatcccacccctgaatatatggactgaatcacacacaccaaatttcatctaccttatc
-gtagcataactattaacaaacatatacagacttcgcggtaaataaaatatattagtacac
-aaccgtatactggttgaactattgcccagctttaagacgcttttaactaggtgcttgatc
-aagaagtattattatatgacggcagtgtgtaatacctgaatagatatagacgttagattg
-tctgaaaacacgccgtagagacatttttgttagatatgtatttctttttgacgagccagc
-atcttagtatctgaagacgagctatatgtttgtagaaaatcgactgacattgtatacgag
-gcggcgtaagattaaccaaattccccagaattagtaatggcgccttatcgatttactaac
-gatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaa
-ggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacat
-agcgtcaccgatactacgttttgctatgtaatccattctaatgggtaagaggattcctct
-tatagtaaaatatgcttgactttttaagaaccattgggagtggttggcaaaataatagtg
-ggtgtctttctcagtgtatagttttctacaactacccctattaggttacaagtaatctgg
-ctttcttgccacttggcgatgatagttagattcgtatttctacaacgcagttactgtatc
-catggcgcgagataattagatacgatttgaatttggatgtagactcgttactactgttgt
-agaccagcacgtgagtatctagatgggtttgctaccttgttagcggacttttgccgggaa
-aaagacatacgtacaaccgtatattttactataagcagtattggccaccctcgtattgcg
-gcagggtgtgctcacctggttaaaatgaaagagaaaaattccattttaaaacccggagga
-atctattactgacgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttc
-atattctagttattccgagagtcactttcctatccaaacatgaactgatagcataatgac
-aggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgt
-cacgaactcggagcttacccttacaactatgtgttctgtttaccaggtgctaatatcccg
-gcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcata
-ttttacagtagccagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctg
-acataagtattacatatcacttgtctgattacacagcaaaatcgctaaccttactttgcg
-catgtagctattggaactttgggctagtgtctatcccattaagtttaacagtagactagt
-ccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttggatcaaaaacta
-ctcgatattcatgatctacgggcttcctttctccgggtatcattgcgccgagattaaaaa
-taaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacga
-atagaccatccaatttgaattttattgggtccagcacttcgccatagtgttgaatggtaa
-agttcgaaaggaaatttgttatattaattctgctacattttcgaccacttgtatctcaag
-gacaatatcccttgaggcttttagcagaaagagatgccgtaattctaagggatgataata
-ggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaaactatatattta
-aatctagccaaacaagttaacaacaaccataaagttatgaccttattatattggcaagct
-taacgttttaattgctctagtaatagagtggtagaggtaagggaccatcacctgattctt
-cctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataaaacattcgtcct
-tagcaacgaatatcgaatggcaattagccacattgagttaaatagttgaggatatttctt
-gcacagaatcagatctaatctaatgattcgttactaaacacttcaccaggtatcgtgaag
-gctcaagattacccagagaacctttgcaatataagaatatgtatgcagcattaccctaag
-taattatattctttttctgactcaaagtgacaagccctagtgtatattaaatcggtatat
-ttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgt
-acttataccatacatgaattctggccaagtaaaaaatagattgcgcaaaattcgtacctt
-aagtctctcgccaagatattaggatcctattactcatatcgtgtttttctttattgccgc
-catccccggagtatctcacccatccttctcttaaaggcctaatattacctatgcaaataa
-acatatattgttgaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagt
-aatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaatattctgggctag
-cgtgagatagtttcttgtcctaatatttttcagatcgaatagcttctatttttgtgttta
-ttgacatatgtcgaaactccttactcagtgaaagtcatgaccagatccacgaacaatctt
-cggaatcagtctcgttttacggcggaatcttgagtctaacttatatcccgtcgcttactt
-tctaacaccccttatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgt
-tattttttgaagtaagttacattgggcagactcttgacattttcgatacgactttctttc
-atccatcacaggactcgttcgtattgatatcagaagctcgtgatgattagttgtcttctt
-taccaatactttgaggcctattctgcgaaatttttgttgccctgcgaacttcacatacca
-aggaacacctcgcaacatgccttcatatccatcgttcattgtaattcttacacaatgaat
-cctaagtaattacatccctgcgtaaaagatggtaggggcactgaggatatattaccaagc
-atttagttatgagtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcg
-taatgttatctcgggttccgcgaataaacgagatagattcattatatatggccctaagca
-aaaacctcctcgtattctgttggtaattagaatcacacaatacgggttgagatattaatt
-atttgtagtacgaagagatataaaaagatgaacaattactcaagtcaagatgtatacggg
-atttataataaaaatcgggtagagatctgctttgcaattcagacgtgccactaaatcgta
-atatgtcgcgttacatcagaaagggtaactattattaattaataaagggcttaatcacta
-catattagatcttatccgatagtcttatctattcgttgtatttttaagcggttctaattc
-agtcattatatcagtgctccgagttctttattattgttttaaggatgacaaaatgcctct
-tgttataacgctgggagaagcagactaagagtcggagcagttggtagaatgaggctgcaa
-aagacggtctcgacgaatggacagactttactaaaccaatgaaagacagaagtagagcaa
-agtctgaagtggtatcagcttaattatgacaacccttaatacttccctttcgccgaatac
-tggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgctcataaataggt
-agactactcgcaatccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcg
-tgtttatcaaccgtccccactcgcctggggagacatgagaccacccccgtggggattatt
-agtccgcagtaatcgactcttgacaatccttttcgattatgtcatagcaatttacgacag
-ttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaacccacatgaatg
-tgattcttggcaatttctaatccactaaagcttttccgttgaatctggttgtagatattt
-atataagttcactaattaagatcacggtagtatattgatagtgatgtctttgcaagaggt
-tggccgaggaatttacggattctctattgatacaatttgtctggcttataactcttaagg
-ctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttggactccctcttt
-catgtcagtaacatttcagccgttattgttacgatatgcttgaacaatattgatctacca
-cacacccatagtatattttataggtcatgctgttacctacgagcatggtattccacttcc
-cattcaatgagtattcaacatcactagcctcagagatgatgacccacctctaataacgtc
-acgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcat
-ataacatttgagggtaaagctaagcggatgctttatataatcaatactcaataataagat
-ttgattgcattttagagttatgacacgacatagttcactaacgagttactattcccagat
-ctagactgaagtactgatcgagacgatccttacgtcgatgatcgttagttatcgacttag
-gtcgggtctctagcggtattggtacttaaccggacactatactaataacccatgatcaaa
-gcataacagaatacagacgataatttcgccaacatatatgtacagaccccaagcatgaga
-agctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaa
-ctggttcccgggagtcctggagtttcgacttacataaatggaaacaatgtattttgctaa
-tttatctatagcgtcatttggaccaatacagaatattatgttgcctagtaatccactata
-acccgcaagtgctgatagaaaatttttagacgatttataaatgccccaagtatccctccc
-gtgaatcctccgttatactaattagtattcgttcatacgtataccgcgcatatatgaaca
-tttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggt
-taacagacgtacatgaagggaaactttatatctatagtgatgcttccgtagaaataccgc
-cactggtctgccaatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttg
-tttgcagagtataacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcac
-tattggctacaaaatagggaagagtttcaatcatgagagggagtatatggatgctttgta
-gctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagatacataagcgataa
-gttacgacaattataagcaacatccctaccttcgtaacgatttcactgttactgcgcttg
-aaatacactatggggctattggcggagagaagcagatcgcgccgagcatatacgagacct
-ataatgttgatgatagagaaggcgtctgaattgatacatcgaagtacactttctttcgta
-gtatctctcgtcctctttctatctccggacacaagaattaagttatatatatagagtctt
-accaatcatgttgaatcctgattctcagagttctttggcgggccttgtgatgactgagaa
-acaatgcaatattgctccaaatttcctaagcaaattctcggttatgttatgttatcagca
-aagcgttacgttatgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtg
-ggaataattcttttgaagacagcactccttaaataatatcgctccgtgtttgtatttatc
-gaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcggataacaattaat
-acgatgttcatagtgacagtatactgatcgagtcctctaaagtcaattacctcacttaac
-aatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccga
-gtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctctctgaattccttc
-gtgccaacttaaaacattatcaaaatttcttctacttggattaactacttttacgagcat
-ggcaaattcccctgtggaagacggttcattattatcggaaaccttatagaaattgcgtgt
-tgactgaaattagatttttattgtaagagttgcatctttgcgattcctctggtctagctt
-ccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgt
-aataattaggttcggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgc
-tgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaat
-gagactcagtagttaaataaatccatatctgcaatcgattccacaggtattgtccactat
-ctttgaactactctaagagatacaagcttagctgagaccgaggtgtatatgactacgctg
-atatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaataccggctgtttccag
-ctttataagattaaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagt
-tggttcattaattagctaagtacgaggtacaacttatctgtcccagaacagctccacaag
-tttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattaga
-gtttacaactcagtattttatcagtacgttttgtttccaacattacccggtatgacaaaa
-tgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcc
-tacacatactgaattcaggcaatgcgttttattcgaaaggtcatataactagaaaacatg
-atgaattcttatcggatccttttactagcatagtgttggcgaacacctcgtaatgctcag
-cggcaaattggactgcgggtccttatcatacattttttttcaatataggcgattggtcta
-ggttagtgattccccaacacttaaggtttgctgacattcataccctcagcaacttcctct
-caaaaattagagtgagttggtggtcttataagaccgttgattatttgaggtggtcaaatg
-atggtgcgatgcacaaatcgttataatcgtactctgtagacaataacccattgtagtgcc
-gattttgtgcataatacaagaaggaggatataaaaatgacttttcaataatattggctat
-tagcaacaagaaggagaatcctcattaagttagcaaccgcagggggtactgcagtccaag
-gaggtttcattggagagagcagtatgaaaacggcaattatgattgtgagattcgctgaag
-attgtgtctctgattttcctagatagaataagctatagctacttaatcaactcttaactg
-tggagactatcctgatgatctgaataccccatttacaaaattccatatcaatgaggctaa
-cgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatacaagacaaaacac
-tgcttccattacgggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgata
-aagctgtcttgcgtttatacttaaacaaattttgacctgacataatggagcgacttatcg
-gatgttgccgatctttagggtcatctattaagcttatacgaaaaagggacaagcacgtta
-cgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaactccaatatctgta
-agaacagaaaaatacaggagtccttttcatttttcaagttaacaatataagtaggagctt
-agagaggcttgcatgaaaatcgttaggaattacagaataggcagagagtggggcgtgtag
-actacattcttcaggccccacaatatgggttataggttaaactgcactttttgcgatctc
-ccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcat
-ccaactattcagataaacaagatcgcagaattaaagcttaaccatatcttgatagcccat
-cgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaa
-aatttagacaaacataattcattctttcgactggacacgctaaggtttggacaaactttg
-tatctatatctggaggcctgtattccagcccttcttttaataagatttacggcttaaact
-atggatatttgccaggaaatgacactgctattgacaggaacataattttgattcaaacct
-cattgttaattattttatatctcctgtttttatatcagaatgcttctgtcctagaaggca
-tactcaaggtgagggctcgaggaatgaatcataatagaccggcccctattaatattggtt
-caattctttcttacataacgcggaatttgattgcacgaacaccgggaacacataaccgta
-tagcgcccgttatgctagtgcctagcgactgggaccgtggagtctatatcgtctttctac
-cattattaatctaaggatataccactttaagtcctttcaactaacataaggcgcattcca
-tgcgctaaggaccttgaatttattatttcttacatgataaaagatcgagtcgacgggaac
-aaaaggctacgtactcaataaagtgcagtttactaagagccctttttctggcttgtggag
-actatcataacatgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtg
-tagtattgaacgagatctttccaattgccccatagcaggaatagttatatattgcagatc
-gcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattac
-ggtttttgatcaaagcacagtgagagttgagcaaattacagttatacgacttaattcagt
-ctccataaattgaaacgacacttcttaacgggaggaccagacacgttcattaagtgagga
-gtgcactttttgactttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaa
-cagatttgaagttatttctgttttaatacactgggagttctgtcaatatcgcaggaaccg
-cctgacgtcccctatcacacctcagagggtaaagggacaggggaaagggtaatcgagggg
-tagggaacgtagttggcacacccaatggacgaataaatgctgccatatccacggagggcg
-ggattgcggttgattttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcc
-tccactggaaattactgcgtacatccgctgagaattgcaatggagtgtctcggtttttct
-ttaaacaaaaccaaattgacaacttcatagtataatttttgcacattacaagcgttaatt
-aacaaacttactttgctgttagctgcctatatttgtccgacaatataactggatatctct
-gcgagaactgtaaattaacggcacttggaacataatagttcctattggtaacgacgttgt
-aggcggcaattatccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaat
-ctctcgtaagtataactttagaagactccaaggtacccagaacctcttcagcggacacga
-tcgctatcaatcaataaggattattcactgaaaccgctcatatctggaggtggacgtttt
-tcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctg
-ttattttcatgaccggataggacatctcgcggaaattcgggtaacagctgggtagatata
-ggacctcccctacgtattaatgataagcctgtcataactagcttggtttaccgaagagac
-aataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaaca
-tgtactattactctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgat
-gttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtct
-gagcattcgtacactgcgtattaagatcaggttgaacaggttcctaacaaattttgtgac
-ctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctg
-acacttctaaaaccaaattaaggctttatccaatatgggtccttaagtgctaaacatcat
-tcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcgccaaattgacac
-atcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtgtgtattctggct
-ctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgt
-aggtcacatcagcagatcctaagtaattccgttttattgtcctgagggagtaggatcgac
-gaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaa
-tgaactattgtcatctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcg
-atggttctttatgcggacctgtcatatcattgactggcacttgcttacatccaaataaca
-cgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatt
-tcgccctctacatgataaatgaataagtaagaagatgatctttttgtggcggtaccttaa
-gcgtactcctgtcgacgagttactactaaaggaatgtagggttctggatctatgaaaagc
-gacctccatatatatacgggcctaagcggagtaaaataagtgatcaatggactaacattg
-aaatgttagtattgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaac
-gaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttactttagttggttg
-cgggaacaacaggaggctatactaactggtagcgttcttgcttccattatgttattatta
-taattaaaaataagacatatggtagagttgtagtcagggtggatcgggttgtctataacg
-ttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcg
-cctacctcatgtgcaccacacattcacagcacacccctcattataggcaaggaagcaaac
-aaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaatagaaacacttagc
-ggtaatgaaaagataggactaaaattcactagtatcctggaacgaggcaacagagttatc
-tagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacc
-tctattgatatacaagtgactttctcggtaataacgcacttcacaatgtgttgtttcttt
-tctatgtattttgcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgt
-aaatcgtatcacatggtataactgcaggaggaacattatccaaattcaccacaattacta
-atccacccttttacttttactaaagatatattaattctcatgttgtctgaattgtataac
-ccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaaca
-cacgacttccttccgtctattcagacactcaacgagactaacttttcctaggtaatcaat
-gatattgggtaactcgtggcatcttatagttattgatccggctcttttgtagatcctgtg
-cgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtttattctacgtac
-ccgatttggttactactaagcggcctttcttcaaacttgcagttgtgacttacattccta
-tttcttcaaagcagggaagggttacagggagagacttattgagatacgattggaatttcc
-atgtacaatcgttaatacgcttgtagaccagcaactcagtatagagatccgtttcctaaa
-gggtgagcggtaggggcaaggcaataagaaattactaaaaccctagttgttaatataaga
-acgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaa
-taggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttct
-caaagatcctaacctaaaaggggcttattctactttttccgacactcaatggacgagaca
-aacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatcgttattattaat
-cggtttccattatctatatgcggtatagatctccgagaggaccctgtaaactagctctgc
-ggtttaactggtgctaatagaccgccactatgttattgcttctagctcctagcgtcttat
-catgttatacattaatgtcgcatattggacagtagccaggcttggatggatcgccgacaa
-aaagaaaagactttccctgtaaggacttaactattacatataacttggatcattaatctg
-caaattagagtaacggtctttcaccagcttcatattccaacgtggcgctagtcgatatcc
-catgaagtttaaaactagaattggcagtctcacttcacagtgcgtatctatacgacaaaa
-gtggtcgatttgcataaatatcttatcgatattcaggttattaccgattccttgctaacg
-ctagaagtcacaccagagtaataataattccagacacctgtgaaataatcggtcactacg
-gatagactagtaacgataatacgtatagtccataaaagttgaattttaggggctaaagat
-attagcaatactggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctac
-attttcgaccaattgtatcgataggaatagttacagtcacgcttgtagatgtaagagatg
-acgttattcttagggttcttaagtcggggggtaatttaagaccactagtaaaggtagagg
-cgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagtt
-agcaactgattttagtggcaaccttaacggttgaattgatctactaatacaggcctacac
-cgaagggtacagataatgattcttactaccctaacatgatagagtcctgtcctatctcat
-aggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattca
-cttatagacttcaggttatttcgtgctaacattaagatagaatataatcagtcgttaaga
-aactattatccagctttcgtcaaccataaagattaaaaactgaaacttggcaagatatga
-atagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagca
-cttgtgtttagtaaagcgggagagtgcggtaattaatattaatatactattaagctacac
-agcaaaggctgcaataatgttagtaagtagaacataaaggtattctccacaagtaataaa
-tagtgtgagctaattgactaacttaactctcgcgacaagtgatgtggataagatgactca
-tatcgtctttttctgtagtgccgacatcccacctggatcgaacaattccttctagttatc
-gactttgattacctatcctattaaacagatagggttgtaaagtcagaaaatgatcggctt
-gcgttggtctaccatagctagagttagaacgcgtagatagaggccttttgttgccaacgt
-gggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatc
-cattagattagatgtttgtgttttgggtctgatgtcctaactactttctcagtgaaacta
-atgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtcta
-taacgtatataaagtcgctgaatttagaacacaccttatctatgttgtaaagttacttta
-ttccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttg
-tcagtgtagataagaatttctttcatacttcactggaatccggcgtatggatatctctac
-cgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttg
-gtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtg
-aagtctaattatttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgc
-gccaatgaggatagaggacattgcatgtacgtaggactattctccaaggggtcttctatt
-ttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactttataccagatac
-tttcattagatatgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaa
-aaaagacccgttgtgatatgatgtttttctagttcgttctcatatatatagatcaacaat
-gaataatctcatgatctataaccgatgtatatttatattccggttgactgctccggtgca
-attcactacggacactaatgactaatatggcgcctttcatcagaaacgctaaatatgatt
-aatgaattaagggagtattatctaattattagagagtagcagttagtctgatattttcgg
-tgtatgtgttagccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtg
-ttgtatgcttcactttatgactctggttatatccctcggagaacaagaataagagtacga
-gaagttcggtcattgaggatgaaatagaaccgctagacgaatggactcacgtttataaaa
-ctatgtatcacagtactacagctaactctgaagtccgagaagcttttgtaggacaaaacg
-ttataagtacctttcgcagaatacggccgtgcatacctgttataaggcgtagtagggaca
-ccatgctatccctcatatagagctacactaataccattacatggtgactatcgtttacgg
-ccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactg
-cagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctcaatccttttcca
-ttatggcatagcaagtgacgactcgtcagccatgggaataatagcactaatccgattact
-tatgaattagaacccacatgaatgtgattctgcgaattgtctaagaatctaatgattttc
-cggtgaatatggttgttgttatttattgaacttatattattaacatcacccttcgttagt
-gatagtcagctatttccaagaggttccccgagcatttttaccattctctagtcatacaag
-ttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaattctgcagatgt
-tagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtttttcgttacata
-tgctggtaaaatattcatagtaataactacaatacttgatttgttacgtaatgctcgtac
-ataacacaatcgtattccacggaacagtaaagctctattattctgatcgagcctaagaga
-ggatcacactacgctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgac
-cagttatagacagtgtaattccatattacatgtcaggcttaagctaacccgagcctttat
-ataagctataatcaagaattagattggagtgcattttagacttatctatcgaaatagtga
-tagtaagagtttatatgacctgatctagactgatgttctcttccacaacagccttaaggc
-gtggagcctttcttatactattaggtcgcgtcgagagccctattcgtaatgttaacgaca
-ctagactaatatacaatgagctaagaataacacaagtcacaagataatttacaaatcata
-tatctacagtccacaaccatcactagcgattgcaaagcgttattggtactaccgctctaa
-atcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgtgagactgaaaga
-aatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttag
-tttggtcaagactatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattg
-ataaatgccccaacgttccatcacgtctataagccgtgttactaatgtgtattagtgcat
-acctattcagaccatagttcaactgttggactgaaggcccgtcttggggttcgtgaatga
-gagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatcggtttatctaga
-gtcatgcttaaggtgaatttcagccaatgggctcccattgagctagtatggtgctttacc
-tttgtaagtggtggctttccttggtgtgctgactttaacacggcagagtgattatccgaa
-gaatggataataagacgctggcaatattggctaataaagtccgatgagtttcaatcatga
-ctgcgaggagatccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcat
-tcttgatacataaagatccgatatcggtccactttgtttaccaaaagccctaccttcgta
-acgatggaaatgtgaatgagagtgaaatacacgatggggatattgccggtgagtacaagt
-tagaccacacattagaactgacctatattcgtcatcatagagatggagtatgaattgatt
-ctgcgaagtacactggctttacgagtatctagacgccgcggtatatctcccgtcaatact
-atgaaggtatatatatagaggctgaaaattcatgttcaatcctctttctaagagtgagtg
-ggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagt
-atacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaatctcgattcacc
-gagagaagtgattttggcggtgtgcgattaattcttttgatgacagatctcattatttta
-tatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggg
-gggagagtgcgctgaacattttatacgatgtgattactcaaaggataaggttcgaggcct
-ctatactcatggaactatcttataattataatggatcgtggctcattccacctatccaaa
-cttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttggga
-cgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaaattgattctact
-gcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttata
-gcaaacattattcaatttcagtcttgactgaaattagtttgttagtgttagaggtccata
-tgtcacatgcatatggtctagatgccattgtacagtaataccttagattagtattagcgg
-catgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgca
-aataggaatacttacaatttttgatgacttgttagcatatcgctatcacccataaaaaac
-ctgatacttgatgagcgggtgattgagactatgtactgatataattcaatagctccaata
-gatgaaacagctatgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctg
-aacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacgaaatcgatccca
-gaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacg
-aagaatgggtagagagtttgaaggtgcttctggattttcctaagtacgtggtaaaaattt
-gatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgggtgaatctgatt
-agccaacccagtgatctgatttcagttgtcaaatctcttttttataactaccttttgttt
-ccataatttaaccggatctcataatgaacaaacgggtagaataatggtagcacatagcga
-gcttgtctattcagaaatatggcctactcagaatgtattctccaaatcagtgttatgcga
-aacgtaattttacgtgtaataatgatgatttcttatcggttccttgtactacaatactct
-tgcccaacaaatactaagcataacagcaaaattcgaatccccctccttttaataaatggt
-ttttcaatatagccgattcgtattcgttagtctttcaccaactattaacctggcatctaa
-ttaataaaatcaccaaaggactctataatatgacagtcacttcggcctcttttaagacag
-ttgattattgcaggtccgcaattgatggtgacatgcacaattagttagaatccgactatg
-gagacaattaacaattgtagtgcccatttggtccagttgacttcaaccacgagttataaa
-ggtattttaatttatagtcgatagtaccaacaacaagcacaatcataattatgttagaaa
-acccagggggtaatgctctaaatccagctttaaggccagagtgcactatgaaatcgccat
-tgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagat
-accttatgaagcaacgattatatctggactagatcatgatgatcggaataaaacattgaa
-ataagtccttatcaaggagcataaacattttatttaatttatacttcgtaaataaattca
-gaattttttttcaagacattaatctgagtaaatgacggctagaaagggttcctactcgaa
-tcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcac
-cggaaagaaggctgccacttttagcttcttgacgatctttagcgtcatatttttagatta
-gtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaag
-agcaggacaactccttgatcgggaagaactgaaatagacagctgtcattttcattggtca
-acttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaact
-atagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcg
-ttaaaaggaacgggttgccagctacagatatactctaggtatatcccaaacaagagacgt
-cctttggctgttgtaatcggtcataatacttgtcacataaacaagatcgctgaattaaac
-attaaacagttagtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatc
-tatcgtctatcacagagcgacgtaaatttagacaaacattattatttcttgacaatggaa
-tcgataagcgttcctctaacttggtatatatatctcgaccccgggattccagccattctt
-gtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaaatgatattgact
-gcaacagattttggatgcaaaaatatttgtgaattattggttatatactggttgtatagc
-acaatcattaggtcctagaaggcatactcaacctcagcgagagagctagcatgcataatt
-gtaccgcccatattaatattcctgaaatgatttcttacattacgcccaatttcagtcatc
-gaacacccccatcaatttacccgatagagaacgtgatcatacgcaataccctatgcgaac
-gtccactctatagcgtctgtatacaatgattattcgttccatttacaacgttaagtaatt
-taaacttacataaggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgc
-agttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaa
-gagacctttgtatccattgtggagaatatcataaattcaagatggggtgtcatgctattc
-ggtcctaaacattcttaatggctgttctattgttagtctgatttaaaatggaaccatagc
-acgaatagttagatagggctcatacccctgtaacgatctacaaatccttccccgggtgtg
-tgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcacacgtcagattat
-tacactgatacgaattatttcagtcgacagtaattgaatagaaacttattaacgccagca
-cctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttt
-taaaaatcttgatttctatatcaaatgatgtgtagttttttctctgttattaaaatccca
-gtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatcacacgcgttagcg
-aaagcggaatggctaatacagccctacgcaacgtagtgggatcaacatatggacgaattt
-atgctcaatgagccaacctcccccgcattgcggttcattttaaggcctgggtaacatcta
-tcgtttagataatcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagt
-ccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcgtaatacgataat
-tgttgctattgactacaggttatgaaaaaacttactttgcgggtacatgcatatttttgt
-accacattattacgcgatatctctcagtgtactctaaattaaaccctcttcgaacatttt
-agttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtagaatggacaactcc
-agttcaactgcatgtaactcatagctcgcgttagtataaattgactagtagccatgggac
-aaagtaactagtcagcggaaaagatccctttaaagatatatgcaggttgcaagcataaag
-ctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaatttt
-gggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaatatcgcccattt
-tcccgtataagctccgtacttatacgaactacacgaccttttaagcattagccgctcata
-tcgtgattcgtgtacagatgagtctattaaaattacagacatactccatatctcgctcct
-tgaactttgaataatgcgctaacttgtactatgaataggcagaacccaactttcccgttt
-gcgtcaagcggggaaacgatacatgttgtcagatttatgattatctagttttagatcacg
-tttaccgataatcggctgtggtctgagcagtcctacactgagtatttacttcagcttcat
-atcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatctttt
-ttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacgatttttactatag
-cggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtggctcttgtccttg
-aagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaattatttggtgac
-taatagtccgtgggtttgagccatatacctaacgccataaactacgtggtgctttagatg
-caatctaaacagaacagaaagcgtagcgctcatcagcacagactaactttttcagtttga
-gtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgat
-tgggcggctcaatcttgcctaatttctactattgtcagctgtacgactgtactaagtgta
-tagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagc
-gcacttccgttcatcaaattaaatcctggcttacccgattctccggaagtctgacctaga
-gattgacgacggccgcgtattattgagacctcttcaggattaatcaataacgaagtagtt
-gatctgtttggcgacgtaccttaagccgactccgctacacgagtttctactaaaccaatg
-tagccttatgcttagatgaataccgtcctaattagatattccggcataacagcagtaaat
-tatctgttcaatggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaa
-tattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctc
-gttaatcattaatttaggtgcgtgagggttaaacaccagcatattctatatgctagacgt
-cttccttaaaggatcgtagtattataattaataataagaaatatggttgacgtctagtca
-gcgggcatacgctgctctatatactggcattattcaaaacttgacggtaaaaaaacgaat
-tttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacac
-ctctttattgccaagcatgcaataaaaaaaatgttaatagtacgtttacgacattttatt
-ttataataaagagaaactattacacctattgatatgataggacgtaaattaacgagtagc
-ctgcatagaggcaaatgaggtttctacatggtatagacctgatgctgaaacatcgatgag
-ttttggtcccctcgctcgttgaaatctagtcatttactactgtctttcgagctattatac
-cacttcactatgtggtgtttctttgctatgtatggggctagtcaaacatgatgactatag
-ctacaactcagagagcgggcgtgttaagagtatctcatgctagaactgcacgacgaactt
-gatacaaagtaacaacatttacgattccacaaggtgactttgaagaaacatagtttaatt
-ctctgcttcgatcatttctataaaccggtaccatcgcagcggatagatgcataacatttc
-tactactccaggcatcttaaaacacacgtagtacttcactagattaagacacgataagtg
-tataacttggcagtgggaagcaaggagattggcgaactcctggcatctgttacgttttgt
-tcaggctcggttgttgataatgtccgactcctgccatattgaagactcgctcgagggaga
-tcgggattcgttgattataagtacacgtgttccgtaatactatgaggcagtgattcaaaa
-tggcacttctgacttacatgactaggtattattaccacggaagcgttaaaggcacactct
-tatggacttaagattgcaagtgccttcttctagcctgaattcgcgggttcaacacaaact
-ctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtact
-aaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcg
-aaaatcgggttaagcaaacacaaataggaattgtgataaaccccaccttgagaggtcgca
-agaccaacctcgggaacaacggctctaagagaataacctaaatccggatgagtagactgt
-gtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgca
-ttcaattgaatcgtttgtattatgagctgtacagtagctatatcagctatagttatccca
-gaggaacaggtaaactagctctgagcgtgaaatccggatattagaacccctagatgggat
-tgattctagctaatacaggcttatctggttttacagttatctagatgattggtaaggtga
-aacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagctattttctaggt
-attataaagtcgagcattaatatcaatttgacagtaaaggtctttcaccagcttcatatg
-ccatagggcccatactcgatttaaattgaacggtttaacgagtattggaactctcactta
-taactgagtagctatacgaaaaatctggtccatttccagaaatttattatcgatttgctg
-cttagtacccaggaagtgataacccttgaaggcacaacactgtaataagttttcctgtca
-catctgtaatattcggtcactacgcattcacgactaaagataattactatactaattaaa
-agttcaatgttagggccgaatcatagtagaaattctcgtctagcctaatcggacttacct
-atgggctgtgaggatttatcagtatgtggacaaaaatgctagagataggtatagttaaag
-tcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgg
-gatgacaactactatacgtagagccgtactcaggattagatagtgtgaaagagtcaaata
-aaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtag
-ggatattctaatacaggccttcaccgaaccctaatgataatctgtcttaataacattaaa
-tgattgtctccgctacgagctcttagggcctcattttaaatgactaatgtccaaagaaga
-gactttcccaatttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaag
-atagaagattatcaggagggaagtttctattatcaaccgttacgcaaccataaactttta
-aatctcataatggcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgct
-ggggagctagatatcggtataccacttcggttgtggtaagcccgagtgggccgttagtaa
-tattaatagacgattatccgacaatgcattcgctgaaataatcttacttaggagaaatta
-atgctatgagccaaaactatttatgtctgtcacattattgactaaagtatctatcgacaa
-aactgatgtccataagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcg
-agcgaaaaatgaattatagttatccaatttgagtaaattgcctattatacagataggctt
-gtttagtcagataaggttccgcttgaggtgctctaacttagcgagagttagaaagcctag
-tgagaggcattttggtgccaaactccggctcgcatgagtaggccagagagtcactttctt
-tcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgtggctatgtgcta
-ctatataagttagaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgag
-acggggtacgccgttgaggctcgagatagtagataaactagaggaatgtagataaaacat
-tagctagggggtttagttactggattacataggaagtgcaccatcacggtgtgggggttc
-gtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcc
-tatacggactttgcatatctctaccgactcatctggtcgtctatgcgggtaattgtattg
-ctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaatccttataatag
-cataagcaattattagactgcgtgaagtcttagtagttctcaagctttacgttgtatgta
-aataactcacgtaatcagccgtccccaaatcaccattgaggtcattgaatgtacggagca
-ctattatcaatgcggtatgcgattttctgagcgattattgttaaagacttagcgttgagc
-cccggaacacttgattacagattctttaaggagttatccaaatatcattttaaataatag
-tagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtac
-ttctctgatatatacttcaactatgaagattctattcatcgataacccaggtatatttat
-atgcccgttcactgcgcagggcaaattatctacggacaataatgacgtagttggacccgg
-taagaactaacgcttaatatgattaaggatgtatgccagtattatcttattatgtcagag
-tagaagtttctctgagattttccgtcgttgtggtacaccggatttggctctctttttaga
-actgagaactcggagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccg
-ccctcatcaactataacaggacgacaagttccgtcttgctccatcatatactaccgatac
-accaatcgtatcaagtttagtatacttgctttctctcttctacagcttactcgcttgtcc
-gagaagcggttggtgctcataaagttagtagtaaatgtacaactagtagccagtccttac
-ctgtttttacgactactacggacaccatgagatacagaagttagtgctacaattatacca
-ttacatgctcaatatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatac
-gtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttgactaacatcttt
-tacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcgg
-aagaataccacttttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaa
-ttgtagtagaatatattcatttgaccgtcattagccttcttcttaggttgtgtacggata
-gtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttt
-tttaccaggctagagtcagaaaagttggagccatgttaaatagttaccatcataaaccac
-tgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaa
-tggtaacaactgttgcgttacttaggctggttaatttgtcagagtaataaatacatgtct
-tgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaaaagtaaagctct
-tttattctgatagtgactaactcaggatctaaatacgcgattatactaaccttcaccaaa
-gctcaaaaatcatctgctggtgaccagttatagacagggtaattcaatatttaatgtctc
-ccttaacatttcaccagcatggattgaagatagtataaagttttacatggcagtcattgt
-gtcacggttctatacaaattctgatagttagacggtatttgaaatgtgcttctagcatgg
-tatcttacacaactgaatgaacgactggagccgttcgtatactatttgcgagcctcgaga
-ccccgtttcctaatgttaacgaatatagtataatataaattgtgatatgaataacacaag
-taactacagtttggacaattaattgttctaaactaaaaatcattcacttcagatggcata
-gagttatggctactacacatataaagcggtatgtgaaacacccgttttagccggaaaccc
-tctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtga
-ctcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgca
-gcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaac
-tgtgaataatgtctattactgattaactagtaagacattagtgcatctggtccactgaag
-cacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaa
-agcaagcctataggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcac
-attgtgctaggttcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttg
-ttatcggcagactctttatcccaagaatggataatatgtacatggaaagtgtccataatt
-aagtcccttcactgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgact
-tacttgctttttgatcaacttaattatggattcataaagttcagatatcggtacaattgg
-tgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatc
-cccatttgcccggtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagc
-attgagatccacgatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacga
-agaggtatatataacctaaatactaggtacgttgttagagagacgatgaaaattaatcgt
-caatacgctggcgaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtg
-tcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaattcacggaacgt
-agcgttgggaaatatcctttctaccacacatcggattttcgccctctcccattatttatt
-gtgttctcacatagaattattgtttagacatccctcgttgtatggagagttgcccgagcg
-taaaggcataatccatataccgccgggtgagtgacctgaaattgtttttagttgggattt
-cgctatggattagcttacacgaagagattctaatggtactataggataattataatgctg
-cgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatac
-ctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattat
-atatgttgattatttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaa
-gctgcatctcgcttaagtttgagagcttacattagtctatttcagtcttctaggaaatgt
-ctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatgacatgctaaact
-aagaaagtagattactattaccggcatgcctaatgcgattgcactgctatgaaggtgcgg
-acgtcgcgcccatgtagccctgataataccaatacttacatttggtcagcaattctgaca
-ttatacctagcacccataaatttactcagacttgaggacaggctcttggagtcgatcttc
-tgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagttagggcatagtat
-agatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagctgagatctatcc
-taaaatgcaaccatatcgttcacacatgatatgaacccagggggaaacattgagttcagt
-taaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacgggcttatggttt
-ttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaaca
-acattaaaatcgcggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatat
-ctttggtagaacttactttgctttaaatatgttaaaccgatctaataatctacaaaacgg
-tagattttgcctagcacattgcgtccttctctattcagatagaggcaatactcagaaggt
-tttatccaaagcactgtgttgactaacctaagttttagtctaataatcatgattgattat
-aggtgccgtggactacatgactcgtccacaaataatacttagcagatcagcaattggcca
-agcacccgacttttatttaatggttgtgcaatagtccagattcgtattcgggactctttc
-aaataatagtttcctggcatctaagtaagaaaagctcataaggaagcgatattatgacac
-gctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttca
-aaatttactgagaagacgaagatcgactaaagttaaaatgctagtccacagttggtcaag
-ttgaattcatccacgagttatatagctattttaatttatagtcgagtgtacaaaaaacat
-ccacaataagatttatcttagaataacaacccccgtatcatcgaaatcctccgttatggc
-ctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgagg
-tggtgacgagtgagatgatcagtttcattatgatgatacgattttatcgcgactagttaa
-tcatcatagcaagtaaaatttgaattatgtcattatcatgctccattaacaggttattta
-attgatactgacgaaattttttcacaatgggttttctagaatttaatatcagtaattgaa
-gccttcataggggtcctactagtatcctacacgacgcaggtccgcagtatcctggaggga
-cgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccat
-agtgagccgatgagttttacattagtactaaatcccaaatcatactttacgatgaggctt
-gctagcgctaaagagaatacatacaccaccacatagaattgttagcgatgatatcaaata
-gactcctggaagtgtcagggggaaactgttcaatatttcgtccacaggactgaccaggca
-tggaaaagactgacgttggaaactataccatctcacgcccgacgcttcactaattgatga
-tccaaaaaatatagcccggattcctgattagcaaagggttcacagagaaagatattatcg
-acgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatc
-ataaaaatgtgacctctagtatacaggttaatgttagtgatacacaatactcgtgggcca
-tgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgtatttggtctaatt
-atgttttatttagtgacaatccaatagataaccggtcctattaagggctatatttttagc
-gaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaattgccagtgggca
-atcctaagcaaaatgagattctatcctaaagtttgggcttgatataagatttcggatgta
-tgggttttataatcgttggagagctcaatcatgagctaatacatggatttcgctacctca
-ccgagagaccttgcatgaagaattctaaccaaaagtttaataggccggattggattgagt
-taattaagaccttgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtga
-gcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgag
-ttcctttgaaatagttaactaatttaaaattaattaacgacatggaaatcacagaaccta
-atgctttgtaggagttatttatgctgtttactgcctctacaaccctaataaagcagtcct
-aagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtcaatttaataaat
-tcaacatcgggtctcaggatattcggtcatataatttattaagggctcttcgagtcttac
-tctgagtgaaattggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcga
-tatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatat
-aagaaaactcacacgtctcattattaaactgagtacaatttttgcacgagaaagtaatgc
-aatacaatatgatgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgc
-actggattaaaatccgattatttttaaaaatattcagtgctagagcatatcaggtctact
-tttttatctggtatgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaa
-gttataacataactcccgttagccaaagcccaatcccgattactgccctaccctaacgtc
-tgccatctaaatatcgaacttgttatgatcaatgtgactacctcccaccctttccccttc
-atttgttccactggggataagctagcgttttcagaatcaatgcaataagaatagccaatt
-gtctcacttcatcagagctcttggcaattccaggcgctacgtggttctggaatatattca
-tttttcaaatagtaatacgtttagtgttgctattgtctacacgtttggatattacgttat
-gtgagcggacatcaatagttgtctaactctttagtaagccagagatagcactcttagcga
-atggataccatcttccataagtttagttaatagtccgaaacaactgcttcgagcatattt
-gaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatagatagagtttgtt
-ttaagggactactagaaatgggacaatcttaatagtatgacctaaactgacatttaaaga
-tatatccaggtggcaagcataaagatcattgcgccacctccaccgtgggattacttatca
-gtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagctgagttgatgct
-aaccttacctatgataccccattggaccggttaacagccctacttattccaaataaaaga
-acttttatgctgtagaagctattatagtgatgcctggtaacttcagtatattaaaatgac
-acacatacgccatatagagctcctggaactttgaataatgagcgaacttcgaagttgaag
-agcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattg
-atcattatcgaggttttcataaccttgacccattatcggctgtgcgcggacaagtactta
-aatcactagtttcttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataa
-gacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggatttta
-aattttgttccatttttaatttagccgtaaggatgtccgtaaatgattgaaaattggatt
-caatctttgggcctatgctactggaacctgatcgacaaaatttcaaacatacgttaactc
-cgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccatataccttaccac
-ttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagactaccgatcatatc
-aactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaag
-taccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaattgctaagaggctc
-agagctaccactgtaatttctctagagcccataataaatgaacgatacatccgtaggtag
-cacctaagggattataatggaagccaaatgcagttaataatattatatactggcgtacac
-gattcgacggatctctcacatagtgattcacgacccccccctttgattgacacagcgtca
-gcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagct
-acaactgggtataatttaccatgcttccctgatgctgagtgcaatacactaagaatgagt
-ttttaccccatatcaccagtatttgttctgttattgcgaagaaatggctatgctgagttg
-gcgactaaagtcacccatcctttttattaggtaaccccctcccttaaactaactgatttg
-ctggagctgccctgcatacatatactttatcatttatggacgtccgtgacgcttattatc
-caccatagtcgatatgctacacggattcattaatggatcgtaggagtttaagttatattt
-actaagatcggtctcggctactatcccgccttacccggcgctatttacggccatttttaa
-tatattgacggtaattattcctatggtttcgaccgcacgtccttggacaagaaagaatgg
-caaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtga
-tgagtaacttgacgaaatgttagtggttattaaagactatctattacaccttttgttttc
-tgtcgtagtatattaaagtctagaagccttacaggaaaatcagggttatacagccgatac
-tccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgt
-atactgtatttagaccttttatacaaagtaaatatctcggctttatgtgattgggagggg
-cctactcaaacatgatgacttgacctaataatcactgtgcgggcgtcttatgactagcta
-ttccttgaaatccaccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtg
-aatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcg
-cacacgttacttccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaatt
-cacgagtttaacaaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaa
-ctactcgaagatgtttcgttttcttaaccataggggcttcttaatggcccactacgcaca
-ttttgttcaagcccgagagggacatccccattacgggagtattactaaaactgttccgta
-atacgttcagcaagggatgaaaaaggccactgctcaagttattgacgtgggagtattaca
-tcggaagcctgaatcccacactatgatggtctgtacaggcctagggactgcgtctagacg
-gtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaaggctcacaccta
-ccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaata
-aagacgtggcaaaaacccccgcacataagccgctttagatttcacaaataccaatgcggt
-taaaaacatccttgagtcgtacatacaccatactcgcgttaaacggatataacagaagat
-aataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaataatgcttacca
-gtcatttagctatacggctttcatttcatgtcaagagggtggagtttgacctgtacagtt
-gatatatcaccgatacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccg
-catattacaaacaatagatgggattcattatacataagacacgatgatctgctttttcag
-gttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtat
-tgacagggaacctattttcgaggtattatatagtccagcttgaatatcaatttgacagtt
-aacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaaattctacgggtt
-atcgtctagtccaactatcaattataactcacgagatataagtaaattctcgtacttggc
-ctgatttttattatactttggatccttagtaaacaggaagggagaaaccttcaacgaaaa
-acactggattttgttttactctcaaagctcttatatgacggaaataccctgtcaagtctt
-aactttattactagactaatgaaatgggcttggggtggccagaatcatagtacaatttag
-cggatacactattcggactttcctatcggctgtctggttggataagtatggggactaata
-ggctagacatacctatacttaaactatacaggcgtcatctatctctgcaactttggagtt
-ccctgatgttctcccgccctttgggttcacatcttctataccgacacccctaataacgat
-tagtttgtgggttagagtaaattaatacggttaatattaatgtatcgttgaaaagctggt
-gtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtataactaccctaatg
-ataagctgtaggaataaaattaatgctgtctctaagcgaagagatatttccgactctgtt
-ttaatgacgaatctcattacttctgacttgcaaatgttcaatatggcacggtttcacggc
-acctttgtgacgcatataatgaacttagaagattataacgacggaactttatatgataat
-ccgttacgattaaagaatctgttaaatatcataatggcattcagttctagaccgtgcatc
-atggtaaacttactttctctgcatggcgacatacatttcgctattcaaattcgcgtgtgg
-ttacacccactcgcacctttggaatattaagagaagatgatcagaaaatccattcgctca
-atttttctgacgtacgtctaatttatcctaggagacaaatcgttttatgtctctcacatt
-tttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaagatactcggtgg
-agcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttccaagttcagtta
-agtgaatatgtttaacatacccggcttttcgatcttaagctgacgctggacgtgcgagta
-atgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacgccccctcccttc
-tcgagcccactcacgctatgtattgacgcgaacttgttcgggatcagacttttcaggagt
-tcggtcgcgtgtccctatgtgctaatatataagttagatcgcattagatgctaatctgaa
-tacttatagacgaccttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaa
-acgacaggtagggacatataaaatttgagtgcggctttagttaagggtttaattacctac
-tcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgt
-actaggtagtgattaatgatatcctagacgcacgtgccttagatcttcagactctgatgg
-tccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaatt
-acgatatctaaatacttataatacaataaccaaggatgagaatgactcatcgcgttggag
-ttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcccaatatctccag
-tgagctaattcattggacggtccactttgatcaatccccgaggagatgttcggacacttt
-agtctgtaacacttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttt
-tccaaagttcattttaaataagactacgataggcctttcctattgatataaactacccgg
-ctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatagcaagattcgatt
-cttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcataggatctaagca
-aaattatcaagttgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcc
-cacgttgatagtatgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtac
-accggatttgcatcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgat
-atttagcaagaggcgttgataaagccctcatcatctagatctcgacctcatctgccctct
-tgctccatcattttctacacagactactttcctatctacgttagtataattgctttctat
-cttagtatcatttagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaag
-ggacaacttgtagcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaa
-gaagtttgtcattctattagacattgaattgcgcaattgacttgtaccacttatgatcga
-acactgaatcaagactgtgattaactaaaatagacaagccactatatcaactaataaaaa
-cgcccctggtggtcgaacatagttgactacaggataattaattggactggagccattaca
-ttctctacaatcgtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaa
-aaaaatgctttcgcaggagcacattggtagttcaatagtttcatgggaacctcttgagcc
-gtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgaga
-gggaattcaccggaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgt
-ttaagagttaccagcttaatccacggtgctctactagtatcatcagctgtcttgcctcgc
-ctagaaatatgcattctatcgttatcctatcaacggttgccgtactgagcagccttattg
-tggaagagtaatatataaatgtagtcttgtctttacgaagcagacgtaagtaataatgac
-ttggaataccaaaactaaacatagtggattatcatactcaagaactctccagataaataa
-cagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaa
-cgctaattcatttgttattggatccagtatcagttaaactgaatggagtgaagattgtag
-aatgttgttctggcctcgcatggggtctaggtgatatacaatttctcatacttacacggt
-agtggaaatctgattctagcttcgtagctgactatactcaaggaaccactgctcaaggta
-ggagactagttccgaccctacagtcaaagtggccgaagcttaaactatagactagttgtt
-aaatgctgatttcaagatatcatctatatacagtttggacaattatgtgtgcgaaactaa
-aattcatgctattcagatggatttcacttatgccttagaaacagatattgcccgagctca
-atcaacagttttagccggaaacaatcgaagcatagggacaatgtatcttttcctaaattg
-ccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactc
-gttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaat
-aactgaaagaaacgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacac
-attagtgaatatcggccaatgaaccaaacgcttcccggtacgctatctctctcatcggga
-ggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaac
-ctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtccgggcgtactcct
-ccatggaagggcgcgcatctagtgttataccaactcgctttttaactactatgctgtagt
-tctacaggcatagtggccagtattttctaacttctctggatagatgctctcactcctcat
-ccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatggaggcattaagt
-atcttcactgttccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagc
-tcaagcacactcattgaatactgccccagttgcaacctcacttaatctgacaaaaataat
-gactactctaagtgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtat
-aggcatgtaactcgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtg
-tgtgacaccaggtaattgatgcggatataagctggagatcactcacgcccacacaaggcg
-ctgctacctctttattccaatgtgtaagaatttgctaacttcatttctagaccgcagctt
-tgcggtcataatttcacggtacggacccttgggttagagacttgataacacacttcgcag
-tttccaccgcgcacatgttttagtggcttctaacatagaatttttgttgtgacataaaga
-gtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagccccgtgagtcaca
-tctaattggttgtactgcgcatttagctatcctttagctgactcgaagagattcgattcc
-taatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcag
-atctgcataactcgcgcttaattacttatgagtagttccaagttcgctacgttatgagag
-agattggaattaagcaaatatgttttatggtgattttgggatgagaaggactgctaagta
-cggctactaaacaaatttctaaaaccgccatctaccttatcttggagacatttaagttgt
-atatgtcactagtctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaag
-agccgattcatcaaatgcttatctaagaaagtagtggactattacaccaagcacgaatgc
-cagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaat
-tacatttggtcagcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcag
-ctcacccgcttgctctagatcttatctttgtatgaatgtcagaatttactgcaatatccg
-ttccgaatagtgagggcttagtatagttctctgtatacaggtcacatcaaactccccctg
-tcctagtacagctctgagctttaattaattgcatacatttccttcaatcatcagatgaaa
-acaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaacaactagcccgac
-tcacgttcatccgccgtatccttgttcagttcttactccgtattaggtcagcgaaatcta
-atcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacg
-ctgagcagttatcggctattagatagtggggtgaaagtaattggctggaattatgttaaa
-acgtgatattaagctaaaatacgctacttgttgccgacctaattcagtcattcgatattc
-agttagagccaagaataacaagcttgtataaattgaacggggtgcactaaacgatgtgtt
-actctaatattcagcttggagtatacctgaaggcgaattcatgtatcggccaataataag
-acgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgtggggattgagtc
-cactgtacgagtacggtctctggaaaattataggttcagggaatataaggaagtaaagat
-aattaccaagagatttttggtatcgctatgacccagaggtgttctaacgtctgttttgat
-ccgcagaatttctgcctcaatgcatatttgacggacttgaactagagcctctaaagttaa
-atggcgacgcaactgttcctaaacttcaattattactactctttttttcctagggtattg
-tagaggccagtggacaaaataaatcaaatttaagatgtttcggacattaacatcccccgt
-agcatagaaatcatcagttatccaatctctcatcgagcttttacaatttctgctggcgct
-atggacagcatatgccgcgagacctccgcaagactcacttgatcactgtaagtatcttca
-ttagaggttagagcctatagttaagctgctgacctagtaaaattggtattttctaatttt
-attgctcaagttaaaggttagtgaagggataatgacgttatttttgaacaatgggttgta
-ttcaattttatatcacgaatggaacccttcattcccggcataatactagacgacacgaac
-aagctccgatctatcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagca
-tcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcaggactacttattacc
-tattaataagttaacatgagccttcataccccgtaagacaatacatactccaccaattag
-aattctgagccatcttatctttttgtatcatcgaagggtatggccgaataggttaattag
-ttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctc
-gccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttccggattaccaaac
-gcggcaaagagaaacattgtatcgacggagataacttaatacagaaggaaggggcatctt
-cgaatacggatgaataattctatctgtttattctgacatcttgttttcaggttaatctta
-cgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaatattgacgagagca
-atctcactccttttgggtctatttatgttttattgaggcacaagcctatacagaacaggt
-actattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttgg
-tacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgg
-gctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgacc
-gaattcatccatgtagattcagatcacacactcattccttgatgttgtctaaacaaaagt
-tgttgtggacgcattggagggagttaagtaacaacttgggatcgcatacttataaaaatt
-atatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagt
-cactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgt
-accaaatcgaaagaacacttaataaggcttgcttgcacggaggtatgatgtttactgact
-ctacaaccctaattttccagtacgtacattcattccaataggttagttctcaaagtgcta
-tacaggctcctcaattgatgatatgcttcagccgctctatggatattagctcattttatt
-taggaagcccgcttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtg
-tgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctctcccgttcacta
-ccatacttggtaccgtgcgcatattacatatagatataggatcattttttaaagctgtac
-taggtttgatcgacaatcttatgctatactatatgatgtaaccctcataatcaataccga
-tcgtacgatcctagcataggtggcaagcgattttatgccgattattgtgttaaatagtct
-gtgagtgtgattatcagggctacgttggtagaggggttgtatagacctcgcacacattgt
-gacatacttaacaatatacgaaaactgatataataaatccccttacccaaacaccaatcc
-cgttgaatcaactaccataacgtctcccatataaattgcctacttgtttgcataaatctg
-aatacataacaccattgcaccttcttgtgttccaatcccgttaagattgccttgtcagat
-gatatgcaagaacaatagcatttgctagcaattattaacagctcttcgaattgcctccac
-ataacgcgggagggtatattttaatttggcaaatactaagtactgttggcgtcatatgct
-attaacggttggatattaagttatgtcagccgtaagcaagagtgggcgaaatattttgtt
-acccagtgagagcactcttagagtttggatacaataggccatatgttgacttaagaggac
-gtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaa
-tcttaagaatagagacacgttcgtgttagggtatactacaaatccgaaaatcttaagagg
-atcacctaaactgaaatttatacatatttcaacgtggatagatttaacataattcagcca
-cctccaacctgggagtaattttcagtagatttactagatgattagtggcccaacgcactt
-gactatataagatctggggatcctaacctgacctatgagacaaaattggaaacgttaaca
-gcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgc
-gtaacttcactatagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatg
-aatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccc
-cttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttg
-agcaggtccgagcacatggaagtatatcacgtgtttctgaaccggcttatccctaagata
-tatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttgtgcgactccacg
-tgcatgcccagaaatacgagtttaaatttggttacatggttaattttgaccgaagcatcg
-cactttatgattgataattggattcaatatgtcgccctatgcgaatgcaacatgatccac
-aatttggctataagacgtttaatccgtatcacactttgtttgcggctagtatagtaacgc
-ccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttcaaatataaaaac
-taatcaaacacgacccatatgatcatctgaagatatttggaactttctcgacaaccaccc
-tcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatatt
-gagtcaagatttgcttagtggcgatgagcgtacacgcttatttctctagtcacaattagt
-tatctacgagacatcacgagggagcaaataagcgatgttatggctacacataggcacgta
-tgaatatgatataagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacc
-cacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccc
-caacgtaaggatcaactagaagagaaaactcggtattagtttaaatgcgtcacggagcat
-gagtgcatttcactaagaatgtctgtgtaaccaatataacatctatttgttatctgattg
-cctacttatggctttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtacc
-aactccctttaaattacgctgtgcaggctcatgcactgcatacatatacggtagcaggta
-gggacctcacgcacccttattataatcaatagtagttatcagtcaacgaggcaggaatgc
-tgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactatcacgcattacca
-ggcgagatttaagccaattttgaatatagtcaacgtaatttttactatgggttccaccga
-aacgccttgcacaactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaa
-taccttcatatatattttttcggttgactaacgtgaactaaggttaggggttttgtatgt
-ctatataggaaacagtttcttttctgtcctactttagtaaagtcttcaagccttactcca
-aaatcacggtgattaagccgttactcagcagcatgattctgcctgctcgggtcctaaaat
-ccagccttgtaagagtcgctgtgtattagctagggagacctttgttaaaaaggatatatc
-gcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatct
-ctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaa
-aatattggtacttgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagag
-aattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggcttagaagactcc
-atgatttaataaatactacgaaggaaagactggatctaaagataactctagtaaggccaa
-ctcccttcaatgctgttgccagttataatccaagagctgtccttttctgaaccatagcgg
-cttctgaagcgaactagaagcaaagttggttctagccagacagccacataccctgtacgg
-gtgtattactaaaactggtccggtattagttcaccaagggaggaattaggcaaaggatct
-aggtatgcaagtcggagtattacatccctaccctgaatccatcaataggttcctctgtac
-tggccttcgcaatgagtattcaaggttgtacagccgtataataataagatagtgactatg
-aacgggaagtaacccgctcaccttccccaaaacattgttatatctaagtattaaagtctg
-ccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcacttaagccgcttt
-tgatttatatttttccaatgcgcttttaaaaataattcagtcctacatactaattaagac
-ccttaaacggagatatcacaagttaagttttaaccatctcgactaggtggaactatagat
-acccaactcaatttatcattacctgtaatgttcctagaaggattgcatttcatgtcaaga
-cggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaatcacctaaaccta
-ttagtcagagcacccggttagaaccagttgtcaaaaaatagagcggttgcatgagacaga
-agtaacgatgagatccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcc
-cttaaaaatatttttaaatactaggcaaacccaacataggttagtcctatgtgatacgcc
-acatggtatatcattttgtaacgttacctagggataatcaggaagtggaattacgcaaaa
-gtagacagtgaaatgcttagggttatagtctagtccaaagataaaggataaagcacgtca
-gagaactatattagccgaatgggaatcattgttaggagactgtggatcatgtctaaaaag
-caacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgat
-gaccgatagtacctgtatactagttactgtattacgtgtctaatgatttcggattggggt
-ccccagaatcagacgtcattgtagacgattcaagtttaccaatttaatttcccagctctc
-cttggagaactatcgccaataattgcagtcactttccttttctgaaacgataaagccgtc
-agagttctctgcaacgttggacttacctgaggttctaacccactttcggttctaatagta
-gttaacgacacaacgaataacctttactgtggggctttcacgatattttttcgcttatta
-ttaatggttacgtcataagctggtgtccaaattaaggttaccggcttcgcagagtagttg
-tatccaagtataacttccctaatcataagatcgaggtagaaaattaatgctgtctctaac
-cgaacagatatgtcccactatgtggtatggacgttgctaattacttctgaagggaaattg
-gtcattatggatacgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttg
-atccaccgttctttataggataataactgacgattaaagattatggtaaatagattaagc
-caattctcttcttgtcagtgaagcatccttaactgacttgctctgcagcccctcatacat
-ttagctattcaaagtaccggctcgtttcaaactctcccacctttggaagaggttgtcaac
-ttgataagtatatcatttacagcattttttcggacgtacctctaatgtttcattgcagaa
-aattagttttttctatcgcacattttgcaagtaacgttagagacacaattatctgcgaat
-gaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatca
-aggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccggcgtttcgatctt
-aagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtctgtctccaaggg
-tcggcaaaaaagacccctccattctcgagcccactcacgatatgtagggacgacaacttg
-tgcggcttatgaattgtctggactgcgggcgagggtccatatctccgaagttagaaggga
-catacctttagatgataagatcaattcttattgacgaaattcatccacaacggggaacaa
-cttcaccctagacttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccg
-tttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcga
-caagatagaggctatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtg
-cctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggcataaaactccag
-caatttgggggccgaaaacaaatgacgttagctaattaattatatgacatgatcaaagga
-ggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaact
-tttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcctagttgataattc
-cccgagcagtggttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaatt
-ctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcag
-ttcctattgatttattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgt
-ttatgattattgctactttagatgctgactgttaactccgtgttgtttttcaaccgtata
-tcacaaccgaattggatagaacctatagtttcaagttctgccacaaggtatcatatttac
-agttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtaga
-gctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtgatagcacatatac
-cacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaacacatattattat
-tgttatccaactaatcggacctatgcataaagcattgtctaaacagaataattgcctata
-tacggtagttttagtgatttatatcttagtatcagttagagcttcgaactcttcaggttc
-ctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttcca
-agtagtacctataaatcacagaaagatctgtctcagtatagttgaaatggtattcagcta
-gtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaacgaatatagaca
-agacactatatcatataataaaaaagaacatggtgctcgaacatagttgaattcaccata
-ttgaaggggaatgctgacatgtaattcgctactagacgatcaattccctacttgtcaaag
-ttgaactggtacgttcttggaattaaatatgattgcgctggaccaaattgcgacttcttg
-agtttcagggcaaacgattgagccggaggatgtccgtctcttacctttcttgcttatgat
-aaacgacggtccctgtacatcactgggaattctcagcaaaaataattgggtaaatcgaga
-ctcgatgtattcggccacaaaggtgttagacgttaaagattattcaacggggcgataata
-ggatcataaccggtatgcaagcgcattgaaagagccatgagatccttatccgataaacgc
-tgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaa
-gttgaagacctaagttataatgaagtgcaataccaaatcgattcatagtggattatcaga
-ctcaagatatctcctgataaattacagttgttaagatacggataaaatgagatttaagat
-tagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagtta
-aaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagt
-taatatgtagcttacgttctagcttgtgctaatctgagtatagattcgtagaggaatatt
-atcaagcttccacgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagt
-agcgtaaactatagtctagttgttaaatgctcagttcttgttatattcgatatactcttg
-gctaatttatgtctgagtatataaaattaatgatattaacttgcatttcacggatccctt
-agaaaaagattttgaccgagcgcattataaacggttacaccgaatcaatagaagcatacc
-caatagctttctttgaatttattgcctgcgcaacttggctgactctctagatccgaataa
-ttctatatggtcgtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgg
-gccgataatggctctttgcaaaattactcaatgatacgattgatcaaagcggtagttgct
-agtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttccaaaagagtcca
-cgtaccatatctatctcatagcgacgcgaggggaaccttatctaactatcattccattta
-ccgggtgactctcgatgcaggatccgattgggataaattgcccagaaatggctcattcct
-gactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggcttataccatcta
-gattgttaactacttgcctgtagttctacagccatactggacagttgtttctaaatgatc
-gggattcatgctagcactcctctgaatgcaccgcgtaagtttaactattacgtccgtggg
-cagataaggatggaggctgtatgtatcttaactgttacctaatatggctggtaattatca
-aagtaaggaccttaatgccatagcgctagcaatcgctttgtatactgaccatgtgccaac
-ctctcttaatctgtaaaatataatgtcttagctaactgtggacgatcatgtctctgccta
-gagcttcgctgtatcaattcctatagccagcgtactagtgacacaacaacaccgtgtgag
-aaaagatattagtccttacgtctgtctctctacagcttattgatgaggattgaacatgga
-catatagctccccctcaaaagcagatgctacctctttattccattctcgaacatttgccg
-aacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacgtcacgtcccttt
-gagactggataaatatattaccaggggccaacgagcaattgttggaggcgcttctataat
-acaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatatt
-aatgtgaaacccccctctctcacatcttatgcggtgtactgccctggtacatttcctgta
-caggactccaacagtgtagattcctaagatagctgttggagttgcctcacgccagatcga
-aaaactgaataaactagtgagctgagctgcagaaataccgcttaattacttatgactagt
-tcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattt
-tggctggactagcactccttacttcccctactattcaaatgtcgtaaacagcatgagaca
-ggatcgtgctgacatttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcg
-ttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctg
-gtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaa
-gcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaa
-aaaatatttttaagcagtaggcacctaacccgattcctctacttagtagctttctttgat
-tctcagaattgactgcaatatcactgcacaattctgtgccattactagacttctctgtat
-taacgtctcatcttactaacactcgcctaggacacatctgagagtgaagtatttcaatac
-atttactgaaatcttcagttctaaaatccccgaataaggctcttatcggtttggccaaca
-caagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaa
-taactatttcggcagacaaagcttataacaagttgccggcgcgtataatatttaaaagac
-cccttgagctgctcaattaaaacgctcacctggtataggctattagatagtgccgtctta
-gtaaggggcgggaattatcggataaactgatattttgataaaataaccgacttgttcacg
-acataagtcactaaggagattttatctttctccaaagtatatcttccttggataatttca
-aagcgctgcaatttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgt
-agtaatctagaggcaaattataagaagttcatcatatcattttcgactacaaaaacaagg
-tgttgtatgccggcgcattgtgtaaactggacgagtaccctagatggaaaattatacgtt
-aagccaagatttcgatgtaatgataattacctacacatttttgctatccataggaacaag
-agctgttctataggctcgtggcatacgaacatttgctgccgctatgaatattggaagctc
-ttcaactacagactctattcttaattgccgtcgaaaatgggccgaatcggctattattaa
-tactcggtttttccgaggggattgttgtcgacagtcgtaattattattaatattgatgtt
-ggtgaggtcatttaaatacaaccttgcagacaatgaataagggatccaatctctcatact
-ccttttacaattgctcatgcccctatgcaaaccttatgccgccacacctccgcaactctc
-tcttctgaactgtaagtagcttcattactggtttgagactatactgaagctgatgacatt
-ctaaaatggctattttcgaatgtgattcataatgtttatcgtttgggatggcagaatcac
-gttatttttgatatagcccgggtattctattgtatagaacgtatgctacaagtcattccc
-cgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctt
-tatttcccgataacctatcttccataaatagcggacagcaggatactgacgctcaacatc
-agtggttatggtctaatttttaacttttaataaggtaacttcagcaggcatacacagtaa
-ctctttaatttataatcaaattagaagtctgacacttcttatatttttctatcatccaac
-gcgatcgcccattagcttattgtgttactaataacgtatctaaaccaatccttttcaagc
-tactgcctatattgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattg
-tcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagacaacgagtgaaat
-ttatacactacgaagggccagcgtacaagacccatgaattaggcgatatgtttattctga
-catattggtttatccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaatt
-ttttttcgaagattcacgactgaaatataaatacgtttggctatatttatgttggaggga
-ggcaatagcctttactgttaaccgaagatttagccagtgagtgtgacactaaaacactgg
-aataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatat
-agctctggatataattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaa
-gccggcctctcatattgaaggtccgaagtattccatgtacattaagatcactctctcatt
-catgcatcttggcttaacaaatctggttgtccaagctttccaggcacgtatggtacaaat
-tcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagt
-aaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaat
-acggttagaagggattagttatgttacaaatccattgaaaacttaagaagcattgcgtgc
-tcggagggtgcatcttttatcaagagactaacattattttcaacgacgtacatgctttac
-aatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccg
-atatccattggaccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtatt
-gccataatgtaatacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaat
-gaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgatttcatatagata
-tacgataagttggtatagctctactaggtggcatccacaatcgttgcatttactatagct
-ggttacaatcataatctataccgttccttacatactaccatagcgggatagcgttttttt
-gccgttgattgggtttaagaggatgtcagtctcattatatccgattcggtgggagagccg
-ttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaactgatataagat
-ataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatt
-tgactaattgggtgcagatttctcaattaataaaaaaatggcaccggatgggcttacaag
-ccccttatcattcacttgtatcatgatttccaagaacaatagaatttgctagcaagtatg
-aacagagattcgaattgcatccacagtacgccggagcgtttattttaatgtggatatgac
-gatgtactgttggcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaag
-catgtctgggagaaatatggtggtacaatctcagagaaagattacagtttggtttaaata
-ggacttatcgggtcggaagtggaacttaataagcagtacacaattgggcaacagacgtct
-tgcctattacaataggattacaatgcgttagatttcagacacgttcgtgtttggctattc
-gtcaattccctaaatagttagacgatcaactattatcaaagtgattctttgttcatcctc
-cattcatgtaacagatggcacactacgcataacgccgaggaattttaacgagatttaaga
-gagcagttcgggcacaacccacttgactttataacagctcggcagcataaacggtaatat
-gtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaactaagtggttcatg
-ttcaacagatgtgacgcagcaagcctaacttatctattggttttgctataaaagaacaaa
-gttacacagaatcctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaa
-tagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactc
-cgggtatgataatggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggtt
-aggataaggatgagaccgaacttatttccggccataactttagattttctacctagtaca
-caacatcagggcggacacgaaaccgccatcacatcatataccaggtttaatttgcttaat
-gggggaagtgtcaacgaaccttcgaactttagcaggcatatggccattatatatggcccc
-agagcagaatgctacagcagacaaaatttggatttatgtagtttaatacctatcaaactt
-ggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaattattactactc
-agcagcttctgcaatgataaaatcttatcatacacgtcacatatgataatatctacttag
-ggggaacgggctccacaacctacatagtactcaatacttacactattcgacaggcacacc
-aaacctgtacagtcccaaaagattgagtcaactttgcagtactgcagatcacagtaatag
-cttagttagcgagtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgat
-gtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaactgtacaacctt
-agagataagtctcaggctactaaaaacacgttgtggcactaacaggatcatggttgattc
-ttacttattcggctgaccggcccaataagtaaccttcaactagaacagaataatcgggag
-tagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagt
-taaaatcgttttcttagcggattccctacttatggatttgagctcgtccacaatattcga
-tacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaa
-ggaattaatagaaggttgatggtaggctccgaacgctccatgattataatcaagtggact
-gtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccct
-atacgagtagataaaccatgaacagcacagtgtgaacccatggttgattttaggctacct
-tatttttaatttccgttacacagaaacgaattccacaactaacatgccattaatttttcg
-atatcttataaaagatggtcgaaattcattcatttattttttttcggttctcgaaagtca
-actaagctgtcgcgttttgtttctctttagaggtaaaagtggctttgatctcctacgttt
-ggatactagtcaaccattactccatttgatccgtgagtatcacctgtctaacatccagca
-ttatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgtattagctaggga
-cacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccccagtagatttat
-tcagctagtgtaagtataagatatctcacccacgaggttcaagtgatatgcagtcttaga
-ataatacttatcctgaatttcgatattatgggtacttcaataatccgctagcgctacttt
-atgtctcgttggacagcaggacacatggcagtcttaaacactaaagacatcacctgaatg
-aatgtaatgggattacaagaatcaatgaggtattatatacgacgtaggaaactctggata
-tatacagtaatctagttacgccatcgcacttcattcctctggaaacttagaagacatcag
-ctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaagttgcttataca
-aacacacccaatgacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaa
-acccagcatttagcaataggagctacgtatgcaactcccacgtggtaataccttcaagct
-atcaatatataggtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccag
-tataataattacagaggctctatgaaacccaactttccagctaaaagtcccaattaaatg
-gttatttcgtacttttaaagtcgcccgttctgttattacgcgaattgattctactccaaa
-attaaacacaaattatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataag
-gctctactaaattataattaagacacttattaccagatttctctagttaagtttgaacca
-gctcgactaccgcgaaagatacattcccttctctatttttcagttcatctatgggtcaga
-gaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcag
-tgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaa
-aagactgccctggaaggagtaagaagtatacagctgatccggtgtatccttcagtcatct
-gccctatactaattacacgacgcaaggaaaaataggtttattttctaggcaaacccttca
-taggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggata
-ataacgatctccaatgaaccaaatgtagaatgtctattgattacccttttactattcgac
-ttagagataggagatagaacctcagtgtacttttttagccgaatgggaatctttgggagg
-tgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgtt
-cgtggaatcgataacagatttgttgacccatagtaaatgtatactagtttatgttgtaag
-tgtagattgttttccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagtt
-gaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgta
-agtgtaggtttagataaagccgtatgagttatatcataagggcctcggaaagcagcttcg
-aaccaaagttcccttataatagtagtttaactataaaagtatatactggtctgtcgccct
-ttcacgatttgttttaccggtttatgaagcgttacgtcattagagcggctccaatttaag
-gttaacggcttccatgtgtagttgtatacaaggataacttaaagtatctgttcagcgagc
-tagttaagttatcctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttg
-ctaatttattctcaaggcaaattgggaattatcgatacctgtataccataaggtcgctcg
-atgtgatgcttatgtcttctggtgatcctaccttagttagtgctgattaacggaacatta
-atgtttatcgttttgagatttagccaattctctgattctaactcaagatgccttatctga
-cgtgctatgcagcccctaagtattttacattgtaataggacacgctcctttaaaactcgc
-caaaaggtcgttgtggttctctactggttaactatataatttacagctttgttgagctag
-ttcctctttggtttaagtcctcaatattagttggttcgagcgataagttggctagttacc
-ttagtcactatattagatccgaatgttatgcttcatctgaagaccgccaccctccaaaat
-ttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtg
-tatctgtacacgagtttccatattttcatcaacagccaccgcacacttatgtcactctag
-gtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgctagtcaaaaata
-aacatagcgaggcaccactaattcggccgcttatcaatgggatgctctgcgcgagacgcg
-ccagagctcagtagttagttcggacatacatttacttcagatgatcaattagttttctac
-aaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctttagtatccttcc
-gtcttatataaggtcagtcccccgtttcggtaccctggaatttactaagaataatgaaac
-agcccccaaggacgtacgtttacaaatgatagaccagatcgcctagcttattccgacgca
-tgttgcatagaattgaaccaacggaatgtgagagtaactagatgagccgaccacagcacc
-cgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatgtcctttgagtat
-taagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctcggatattcaggg
-aacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaa
-tgcctacctcatagtgctgaattaacacagcactgcggacctaacttttcgaggtttcaa
-gttcacgtctcaaaacctaataggctggaatatgtagggatcctcggtgaatttgtgatt
-gggtttgttgtagtactgaccaagtgaatattctttttttctaaaagcagatctgctgcc
-gggcactacgaaggagatctctgtgtatcattattgcttcttgacatgatgactcttaaa
-tcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacatattgttgatact
-tcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaaatactggtgact
-tggtcctatctactattagctagacctctggggaaccacgcccccgtaaaacctgtgcaa
-gagagggggtcatacatcttagacatcgcgcctccaccagggaagcattgggtgattgac
-caggtgtgtaacaaatatgattattcttatactaatattagcaaagatgcataatgattt
-gtattaaatgtataattgaattgataagggtcttttagtcagtgatagagtagtataagg
-tagacattagaactcttaaccggacgcagatttttcggtcttagtaagccaattagtcga
-caaaacaaggtaagagcggttactagtagtacctataatgcactgaatcttcggtcgaag
-tatagttctaatgctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaa
-caagctcttgtaagtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcc
-tacttattaggggaattaaccagattgaaggccaatcctcacatgtaatgagataataga
-cgataaatgaaattcttgtaatagttgaactgctacgtgatgggtattatatatgattga
-gatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccc
-tcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcactccgaagtataag
-caataataatgcgggtaatccagactagatcttttcggactcaatgcggtttcacggtaa
-acatgattaataccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgcc
-aggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttg
-tttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaagtccattacctt
-ttagtttcagactggtggagctgactaaagttatatcatcattttgtacactggtttagt
-taacgataatttcagatttaacatgaccagacgataatcgctgtatatccagttggaatg
-tggtttgccagaaaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatc
-ccatccattgcgctatacctcagtgtatttggagctgtagttataccgtgtgctaagatc
-agtagacatgacgagagcaatattatctaccttacaagcatcaacggacgtctagtcgga
-acaaaagactctaaaactcgaacttcaggttaatatactatagttctgtattcagcagtt
-attcttatattcgatattatcttgcctattggatgtctgactttagtatattaatcatag
-tatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaattataaacggtt
-acaaccattaaagacaacaagaccctatagctttatttgaattttgtcaatgcgcaactt
-ggagctcgcgatacatcccaattagtctatagggtcgggacgattctacggcatttctgg
-ttataatgacaacatggattgtggcccgagaatcgctctttcattaattaagcaatcatt
-acagtcttataagcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgag
-ccgaatagcttaaaaaacaggccaccgaacattgatagagaataccgaccacagcgcaac
-ctttgattactttcattaaattgtacggctcactcgacatcaagcttaagattgcgataa
-tgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcagaaagcgtaccca
-gagaagatacgctgttacaatatacagggtgaaattattgcctgttcttcgtaaccattt
-cgccaaacttggttagaaatgatagccattcatgatagaaataagctgaatgataccagt
-atctttaactatgtagtcagggggaagataacgatggtccatgtatgtttctgatatgtg
-acagtattggccgcgtaatttgctaacgaagctacttaatgcctttgagcttcatataga
-tttctttaatcaaaatcggcaaaaagatagtatgagctataatatatgctagtagagaac
-tctggaccatcatctatatgaatactgattcgagcgtgcaattactttagcctgcgtact
-actgactctacaaaacactctgagataagtttgtagtcagtaagtcgctctctataaacc
-ttttggatgaccattgtacagccacttatagatcccaataaatagcacaggagacagagt
-ttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagggcacctattatt
-tgatacctaacctaacggccctttcacaatggagaaatatatgacatcgggacaaacaca
-aatggtgggtggccaggagatatgacatggtggcgtctctaagaaacacggactccctct
-aggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtg
-taatgacctggtacattgactggtcaggaatacatcactgtagttgccgtagtgtcctgt
-tggtgttccatcaagacacatcgtataacgcaatttacgacggacatcagatcaagttat
-acagattatttaagtatcacgtgtgcattgggacataagggatctcacacatgccttgga
-acatttttgctttgtgccgctttttcgctgcactaccaatccttacttaccagtatattc
-aaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcgattgggatagac
-gagacatttgcgagcgccctccacggatacgaatctcccatatcaatgtgaactggatgc
-tatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcag
-ttattcagaacctaatacacaaaaccgtcaaacattttctaattctaggtatgggccgat
-cataggagctaaggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgc
-atatactgagtagctggcgtgcattctctcaattgtatcctttttaactgaactagtcgg
-tcccatttcgtgactgagatctattaaccgataagattaataacactcgcattcgtatca
-gctcagagtgaagtttttcaataatttgactgatatattaacttctaaaataacccttta
-agcctcggatccgtttcccaatcacatcaaaaattcttattccaactatctacggattaa
-caacgtgcatggggatcgtagtaagaacttgttccgatcactttgagtatatcaagttga
-cggcccggttattattgaatagaaacattcacctgctaaattaaataccgcacatcggat
-acccgatttcagagggccgtcttactaagggcaggctttgttcggtttaactgagatgtt
-cattattttacagtatgcttcaactaatatgtaacgaaggacagtggatctgtctccata
-gtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttga
-tcatggcacgtgaaagcaacccctagtattctagacgaaaattttttctagttcatctga
-taatttgccaattcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcg
-aacctagagccattatttgtcggtaacccatgagttccttcttttcagaagttaatacac
-tgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcataacaacattgga
-tcaagatagcaatttggctacctattctaattctcactagattcggtattccactacaat
-atcggcagattaggattggatgaataatcggtgtttaagtccggttgcgtctccaatctc
-ctaatttttattaatattgatcttggtgacctattgtaaataaaaacttcaagactttga
-ataacggtgaaaagatagaagactcatttgaaaatggatcatccacagatccaaacatta
-gcaagacactaatccccaactagctattctgatcgcgatcgtgctgcagtactcctgtca
-caatagtctgttcatgatctaattctttttgggctttgttcgatggtgattcagaatctt
-tatccggtcgcttccctgtagctactttgtggggatattgcccggggattatagggttga
-gatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactacatcagaacatcg
-tgaagacaccatacgcggtacctttatttaccgataacatttcttcaagaaataccggta
-agcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaattttatttaggt
-tactgctcaaggaataaaaactaactatttaatttataataatattacaaggctcacact
-gattagatttgtctataagacttcgcgatcccccattaccggattgtcttaagaataaac
-tagataaaccatgcattttctagataaggcctttagtctaattagatacaaaaaacacga
-tagttgcatccttaatttattgtgtcaaacctggaaccttttaattacccgcaaatcact
-ttatgtcgagactacctctgaaatttattatctacctaccgcatgaggacttgaaccatc
-ttgtaggagttatgtttattagctaagattcgtttatcctgtagcggtccatgtatattc
-aacaagcaaaaagcactcagaattgtttttagttgagtcaagactgatatataaataagt
-ttccctagttttttcgtggtgggacgatattgaattgaatcttaaccgaagagtttccca
-ctctgtcgcacaataatacacgccaatatttccagccctgcttatgccttaatcggttac
-tcaatctcccattgaagttcattttgatctgcatagaagtttcgggcccagccttttttc
-tgccaccttcctccaagctctgtagacgcactctaagattgatgctcacatgtattaatt
-ctacattaacataaatatataagtcatgcatcttcgagtaaaatatctggttctccaaca
-tgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatgattgggttaact
-ggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgta
-ttcctcgtgctcggaagggctattacgcttacttccgttttggtatcttaatatgacttt
-caaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagtt
-gtttaaacgaactacttgctttacaataccggtcgtatatatcgccgtgaatccagaaga
-ttgtcttctttggattatcaaccgagatcctgtggaccgatgttttgggaccttcacaga
-ggactccaggtagagctcgcttttgcattaatctaagaattgtacctctctaaaagatct
-aaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaattactttaggccga
-aaggcacatgagttattatacatatacgagatggtggtatacatcgaattcggggcatac
-actatagttgcattgtatttagctgctttaaataatatgatattaccttccttacataag
-acattaccggcataccctggttttcaacttgtggggctttttgacgatcgcactctcatt
-tgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaa
-tagattacttttcgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaa
-gtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaa
-aaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatcttgatttcattctt
-cttgtcaattgccgacataggatgaaatcagattccaatgcaatacacagtaacccccac
-ccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggcc
-ttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgtacaatctcacac
-atagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaactttattagaag
-taaaaatgtgggcaaaagaaggattccattttacaagacgattacaatgagttacatgtc
-tctcaacgtagtctttccctagtagtctttgaactatttaggtactccagaaaattttag
-caaagggtttctgtgtgaatccgccattcatgtttatgatggaacaataagaataacgcc
-ctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatattcaatttagtaca
-gatccccagaagttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtct
-aattactatactaacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagt
-gtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttag
-gacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatg
-agcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacac
-ataatcgaactattgatagtcgggagcataaccaggtgaacgtactttgttcacgacatt
-tattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatca
-ttgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgagaactttagctgg
-cttttggccagtatttagggaccaagagcactagccttaagctgaatattttgccattta
-tctactgttataactttaaaacttggtggcaccagacttgtcgatacacacgcatcaatc
-tgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttatattatatttaaac
-taaaagatgatattagcttctgagggcgatagggctccaaatcataaagaggaatatatt
-attacacgattagaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttgg
-cagtactccacatctcagtaatacagttgggagagtctcaaatgttgttttattactcaa
-tgaaccaccctcataatttcactgctgttccattaaatttgcaaacgatcatttgctttg
-aagaaacgtaaaatcgacaaaattacagataagtagatgcataataaaaaaaactgctcg
-ctataacacgatcatcgtgcattcttacttaggagcatcacccgcacaataacgtacctt
-aaactacaacactattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaa
-agaacttgctctctcgtaaaatgtgataatagtttgcggagaggattcaattattttcca
-ttgcacctactccactagattcgataaaagaaggtggtcctcccttaaaaagaaatgtta
-agtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatccttccctaagaaaca
-taaaggtttttaataatgtcgactgtgaactataactgcatcctttcctgacctactccg
-gttccttgttgttatttctgaacgagaccagtagataaacaatgtaaaccacagtgggta
-ccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcata
-atcttacttgaaattaattttgccttttattttttttcaggctcgaaattaatgatttgt
-tttttttgaccttctagttacgctaatatgcggtcgcctgtggtttctattgagtcctat
-aacgggatgggatctaatacgtttggttactagtaaacaaggtataaatttgataccgga
-gtatcaactgtataacatcaagctttatgactcatacgcgaagtaatgacacaaggcttt
-caggagatcgcgagtacagagccactaaggggtgtattacgatagtgacaccaccgagcg
-cactcactccccaagtagatttatgatcctacgctaagtattagatatataaccaaagag
-gttctagtcagtgcaactcttagaataataattagccggttttgcctttttaggcctaat
-gcaatattcagctagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtt
-taaactaatcaaatataatctatgaatgttatgccagtacttgaataaatcaggtttttt
-ataagtccttgcatactctcgttatatactgttagagtcttaccccatagaaattctttc
-atctgcaaacttagaagaattctcagctacggggagcataaagtccccaggatgttgaca
-aatacaacaaatgtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagtt
-ttagccgaaccttgtacggataaatccctccattttccaatagcagatacctatcctact
-acctcgtggtattaaattaaagcttgaaatatagagctgcatagcttatccaattcccaa
-gcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagcaaacccatcttt
-aaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttat
-taagacaattgtttataagccataattaaaaacatatgttcaacaggttcattgatattt
-gtaattgcacaggtttttaataaggatctacgtaagtataatgaacaaactttttaccag
-agttatattctgtactttgaaaatgctcctctaccgccttagagactttcaattagattt
-tttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgc
-taaccctatcgtctgtctcataactgtaggtctaatataattttcagttttcgaacacat
-aaccctttgaaaatctgctatttaatgtctcacctgcatgcactatcttctatactgctc
-agaacggctatacgtcactatgctccaagtgacgatttaaacgaagcaaggaataatagg
-tttattttagtgcaaaacaattaagtgcggactacgtgctctttacaataagccttgtga
-ttgggctataggttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctt
-tgcattacccggttactagtcgaattacagatagctgttagatactcactctaattttgg
-acaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaa
-acgattacatattatagacttgttcggggtagagatatcacagttgtgcaaacattgtaa
-atcgatactagtttatgttggtagtctagttgcttttaccattccccgaaaaacttgatc
-tactatttcgacaacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagt
-gccactatttgtccactatatgtaagtgtagctttacataatccactatgactgagatca
-ttacggcctaggaaagcagcgtagaaaaaaagggcccggatattacgactgtaactataa
-aactagttactggtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaac
-gaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttctataaaacgata
-aagtaaagttgatgttcagcctccttcttatggttgcatcgagagtacactactcagtgg
-gaaatagatcggggttcctacttcagattgtattatctaggcaattgccgattgtgccat
-acctggataaaataagctacctacatgtgatgcttatctattatcgtcatactaccttag
-ggtgtcctgttgaacgctacattaatctttagccgtttgagatgttccaatggataggag
-tctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatt
-tcgaaacgagacgttataaatagaaaaaaggtccttctggttctattctgctgaactatt
-gaatggaaagattggttgacctacgtactatttgcttgaagtcatcaatttgacggggtg
-agagacatatggtgcatactttacggactctatattttagatcagaagcttagcagtctt
-ctctacaccccctcacgacataattgcttttaagaatctatgtttgattcctctacggga
-attcggatccgttcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagc
-atacgaacactttgctaactagacgtatgtatagtagctataaatcccgacgatatttac
-aaaaagaaatgagactcaaatatatacatagcgaccctacacttattcgcaccctgatct
-aggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgtattaaatttact
-gcagttgagattttagttgtctactaaggattactctaacccgtaataaggatcaagact
-cggtactagctttactatcattccctatgtgttttcctaactcacaagggtacgtaccag
-cctatgtaattacaataatgataaagacacaaaggaagtaactttacaaatgagtctcca
-gttacactagcttagtccctcccatcttgctttgaagtctaaatacgcaatctctgagga
-tatacagcagaagaacactcataacgttggagtccaagaattagactcatagggccccca
-acatttaatatgtactgtgagtttgaaggtgttctattgttaattcctgctcttgataca
-tgacacgtactccgtgtttaaggcttcggactgactttctttcataagttgagcaacgaa
-aatttcagaatcgataagttggattcactaactaatacggctgattgaaaactccactcc
-ggacctatatggtcgacctttatacgtaaccgatataaaacttataggctggtatatcga
-gccttcctagcgcaatttcggatggggtttcttctactactcaacaacggaatagtcttt
-gtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtc
-attatggactggagcactcttaaatcactctgcgtgtgctaaacgatagatcataacatg
-tcctgagtaaattttcttgatacgtcgcaatataccgttattagttaaacgttctcatcc
-gtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgactcatctcgcctaa
-cacgcacacgtataaactcggaatgactgccgctcttacatattagaaatacagactaca
-ccacggaagcattgggtcattctcaaccgctgtataaaagatgattagtcttataataag
-attaccaaagaggcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgt
-aggcagggagtgaggacgagatggtactcaggacaaatattaaccggacgaagtggttta
-cgtcgtactttcactattagtagtaaatacaaggtaacaccggggaatagtactaaatat
-aatgatatctatcttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaa
-aatgtgctgacttatagcatgatacaaccgattgttacttttgtctattcaaaagattga
-atagttttttatacaaaagccgcatacttatgacggctagtatacagtttcatcccctag
-catcaatgctatggacagtattgaacttataggaaattcttctaatagggcaaatccgtc
-gtgatgcctattttttttcagtcacatcctcaaatggcactagtattgtcgggatcccat
-taacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgac
-agcgacagaactcccatggataaccaattataaggcccgtaatcctctagacatcgttta
-ccaataaatccgctttctccgtaatcatgttgaataccccagagtagtccagatgataac
-cgatgaaacacaagtctttctcaatgcacttacggtgaacttattaccgccaacgtagct
-catcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactt
-tcgtatattcaacgccttgtaattttactttaagacgcctggtgatgtagattcttagat
-aatcagtttgttatcggctgtactttaccataatttcacaggtttcaggtcaagaagatt
-atagctgtatatacagttccatgctcggtgcacagaaacgtgatcggataataatcaatc
-gcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagtgtatttcgacat
-gtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagattagattccttaat
-agaatataccgacctctagtccgaactaaactatagataacgccaacttcaggttaattg
-tctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggccatattggttcg
-agcactttagtttttgatgcataggatatgcaatgtatagctgaaagtactttatctgtt
-tcaaactcacattgattaaaccggtaaacctttaaagactacaagaaaatattcagtgag
-ggcaattttgtcaatcacaatcttccagctagagatacttcacaatttgtcttgaggcta
-cgcaacattagacggattttcgcgttttattgaaataatcgaggggcccaagagtatcca
-tagttcattttgtaagatttctttacaggcttattacagcttcttcagactcctacatgc
-ttacgagttatatgctagcatgtgaacaatagattaatatacaggaaaacgtacattgag
-agagatgaccctacacagcgcaaccgttgagtactttcattaaagggtaacgctctcgag
-acagcatccttaagatggccttattgtcaaatcatttgcagaagtacgcaagatccctaa
-ccaacgtagaagaatccctacaaacacatgagacgcggtgaaaatagacagggtgttagt
-attcaatcttcggagtatcaatttcgccaatcttggtgagaaagcataccctttcttcag
-agaaagaagatcaatcataacactatctttaacgaggtacgcacgcgcatcattacctgc
-ctccatggatctttaggatagcggaaagtattggcagcgtattgtgatttcgttcctact
-ttatcaatttcacattcatatacatgtcttttatcaaaatcgccaataagataggatgag
-ctatattagatgctagtagagttcgcgccaacatcatcgataggaatactcaggacagcg
-tgataggacttttcaatccctaatactctctataattataactctctcttaagtttggag
-gcagtaacgcgctctatataatcagtttgctgcaccattcttcagcctctgatacataca
-aataaattccacagcagtaagagggtttaattgagacatcttgggaacttaggattttac
-tctaacatcaccgaaacgattattggataccgtacctaaacgaactttctcaaggcagta
-atataggacatccgcaataacacaaatgctgcctccccaggagttatgtcttcctggagg
-ctatatcttacacccactcactataggcaaactaaagtttaaatgttgattgtctaaaaa
-aaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattc
-tctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcctttaaagctattt
-acgacgcacatctcagcaagttataaacatgttggaagtttctagtcggaattcccaaag
-aacggatctatctaatgcattcctacatttttcctgtctgccgatggtgccatcctattc
-aaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaaccttacgcctct
-aagggttcctcgagtgccatacaccagtcaggtccgagccacatacacggagaacattct
-aacatagcattctcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaa
-atcatacttgcaatcccatagcacggattaagaacctaagaaacaattcagtaaaacatg
-ttcgaattcttggtatgggaacatcattgcagctatggtctaacgcattaatgtttgggt
-acatcttccatcatataaacaggaagagtctgacgacagggagtgcttgcgatcatgtct
-atcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataaga
-tttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatat
-atgatctgctttaataaaactttatccataggatacgtttccaaatcaattcaataatta
-ttagtcaaaatagataaggatgaacaacctgaaggccgatcggacgtagaaagtggtccc
-atcactttgagttgatattgttgaaccacacgttattatggttttcaaacagtctcagga
-tattgtatatacagataatccgataccagttgtctgacgcccctcttacgtaccccaccc
-tttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaactaatttggaaag
-aagcacagtggatatgtctaaattcttgttattcaggcctgaatttaatacaccgcatag
-ttaacttcgcggtagagttgttcatcatgcctcctctaagctaccacttctatgatacac
-caatagttgttctacggaatctgataattggccaagtcataaacttccgctgcgttcaac
-ccccttgctcgaatatccaactcgaaaagacagccttttggtgtccggaacaaatcagtt
-acttcttttctgatgttaattctctgtggtcagatacagaccaaaaactccgcggattta
-ccatcctccaagaacaaatttgcatcaacatagcattttggctacatattctaagtctca
-atagtttaggttttcaactacattatcccaacattaggattggaggaataatagctgggt
-aagtccccttgcgtctacaatcgactattttttatgaatatgcttctgccgcacctatgg
-ttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatgg
-cagcagccaaagagcatataattagcaacactctaagaacattatagatatgatgatagc
-gatcgtcatgatgttatccggtcacaatagtagcttcatcagctaattcgttttgccagt
-ggtgacttgcgctggaagaatcgttatacggtcccttccctcttgatacggtgggggctt
-attcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagt
-caactatactaaatcacaaaatagtgatcaatacatacccgcttcatggttttaaccatt
-taattgattaaagatattccgctaagaaccattatctacctaaactgatcgccgtatcct
-agtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgta
-gaataataggtcttggagctaaatgatgtgattggtagtgaagacttacccttacaactt
-taccggtttctcggaagaatatactagagaatcaatgcatgggctacataagcactttag
-tctaatgagataaaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaa
-cctggtaatttaaaccatatatctttatgtcgtcaataactctcatatgttttatataac
-ttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagctatgaggccggga
-tccggttgagctacatctatttgctacaagaaaaatgaaagcacatttgttgggagttct
-ggctacactcatagagaaataagtggcccgagtgggtgcggcctgcctccatattcaagt
-gtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcctttatttcctcc
-acggagtagcccgtaatccggttcgaaagagaccattgaagttaattttcatatccagtg
-aagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatat
-gattcatcctaacttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcg
-agttaattttcgccttctccaacatggcatccctacgttcgttataaggaccatacatgt
-aggttttaaaggtttgcggttaatcgatatttacatcatagaaattctatagtcaaattt
-acaagactctagatactcactcgttgcagccggctaggaagcgctttgtaccttacttcc
-cttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactcatacctccgtgaa
-gagggtagatagactattaaagttgtttaatagtacgtattgatggaaatgacccgtagg
-agatttaccactcaatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcga
-aacatgggttgggtccttcaaacacgaatccaggtagagatacctttgcaatttttcgat
-gaaggcgaccgagataaatgagctataacactgtatgtcttttgattgctataaaacaca
-gaaacggatattaatttaggccgtaaccaacatctgttatttgacatagaacagatggtc
-ctttacagcgtattccggccttaatattgaggtccagtgtattgtcctcctttaaagaag
-ttgattgtaactgacttaaataagacatgtcacccattcactgggttgcaactgctggcc
-ctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaag
-acataaatgtcgctatgaaggttattcattaattttagctgttttcttagaaaaggtaaa
-tttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgg
-gcatcattgagattgtaagaaataaagccataaccagccccggaatagaaaatgttaagg
-aaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggac
-attgcaataaaatctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtc
-caccatgtgcagaggataacggaatgtggttccgtcccataaacgatcattctcgcccac
-ttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggc
-taccttctccaactttagtacaacgaataatgtccgattaacaaggagtcaatttgtcat
-gaccagttcattcaggtacttgtatctatacggacgcgttccagagtagtatttgaaatt
-ttgaggttctactgataagtttagctatcgctgtatgtctgaataagaatttaatgttta
-tcttcgataaataacaattaacaactcctaggtgatacactgtgaagtctgctgttcccc
-aaattacatatgctattttgttcacataccatgaagttaagctaagtgctctataatggc
-ataaacggttatcaaactagctcgaatttcttttattacgccggaagcggattaactgct
-gtagatcaaacacgttaggatagtgtcgttttcatatatatctaaattcggtctaacatg
-cattacccatgcttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaacc
-aaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgactacccggatcttta
-gcctttagggtctaaacagaactaatattactacgtgtcatactccggagcttaaccagg
-tgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtatcaaattaaccca
-gcaatacaataagcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcga
-aaacttaatgacatagtgtgatgcattttgcactggattgagccacaaactcaactagca
-ttatgctcaatatttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagt
-cttgtagttacaaacgcataaatctcgaacgtaataggtttaattagaacatccgtagga
-tttctgtttatagtagatttatactaaatgttctgattagattctgacggccttacccat
-acaattaataaagacgaatatattagttatagtttactatccaaataaattaagcgaatc
-gaaataaactgtcacgatactgggcagttatcaacttatcacttatacagttcggacact
-ctatattggtctgtgagtactctatcaaactaactcataagttaactgcgcttccattaa
-atttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatgacacatatggag
-atgcataataaaaaaaacggctccatatttctcgttaatcgggcattcttaaggaggagc
-atctcaccaaaaataacgttcctgataagtcttaactattagaccgtcttcgggaatgaa
-cgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattctgataatactggg
-cggacagctggaaattagttgccagtgcacctacgcaaatagtttacataaatcaacggg
-ctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtct
-accgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataac
-tccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactg
-aaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtg
-cacggaataacataacaaggaatattatttattcaaattttttgtgactgttatttgttt
-tctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtcc
-acggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgtcctttagactat
-tcaaggtagaattttgataacgctctataaaaggtagaaaatcatgattgagcaataaga
-ccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgta
-tttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttatgatcagacgcta
-acttgttcttagagaaaaatacacgggatactctgtgcaacgatttcattaataaggtgc
-agcttgggacttttttggccgtaggctttattaacattcacagtaggtagcgagacttcc
-tatgaaccaatcatgccacgcgttttaacgtttcaaatataagctaggaagcgtttgcca
-ggacttctataatgcaccgttttttttagtacttccttactagccttagtttatgttaga
-gtctttccaattacaaaggattgaatagccaaaatttctacaattctcagcgaacgccag
-cttaatctaaacacgagcttcaaatattctacatatcggcaggagtcaatatataaatat
-gaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataattaaatccttttt
-caattaccacagtacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtc
-ctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttc
-tgacgctagagcttaccattcgttaaacagataactaaaatttaatggctgagtgactta
-gtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatttttaaaaacata
-tgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtaccatagaagtatg
-tataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcac
-acttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaactctacaaggcatg
-ggatgagattctaccgactccggataacactttacgatcgcgcataactctagctcttag
-ataagtttaacttgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatc
-catcctctatcttctataatcatctgaaccgcgatacggcactatgagccaagtgaagat
-tgaatccaagaaagctataattggtttattttagtccatttaaattaagtccggtataag
-tgctctgtacaatatgcagtctcatgggcatatacgttaactaccttttgatacttcgaa
-ttggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaattactctttcct
-gttacatacgatctcttagtttggacaactagcccatgatggcgctcctctagcgcatga
-acctactttataattacatctttatcgatgaatttttttagactgcggaggccttgagtt
-ttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttg
-gaacaggcaccgaaaatattgatctactattgcgtcaactctattctgctaatagcgatg
-gcaaatcacagaagccctcttagtgacaatagttgtcaactatatctaagtcgaccttta
-ctgtatcaacgatcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaa
-aggatttgtcgacggtaaatataatacttgttaagggtagcgacacaggtatactttggg
-tgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttccggtaaccagga
-aatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactccttcttttcgttg
-cagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttcagatggtaggag
-ataccatttggcccattgtgactttacgcgattaattaaccgacatacatctgttcctga
-gctatgatcgtctgaataaattacggtctcctcttgatacctaatggtttctggagacgt
-ttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagctacgcagagcatc
-aaaatatgtatgggaaagtcgatttccaaaccagaagggataaagagaaataacggactt
-ctccgtagattagcctgatattttgatgggaatcatggcggcacatacgtaagagttgcg
-tgaacgaatattttggacggcgggagacacatatcggccattcgttaaggtctctatatt
-ggacatcacaagcttagcagtatgagctactaacactcaagacattattgattttttcaa
-gatatgtttcattcctctaccgctattcccatacgttcgattcgccgggtgagcgaaacc
-acgggactgaggttaagctaatcaataacaactcgttgcgatagagacctatgtatacta
-gagagaattccccaacatttttacaaaaacaaagcagactaaaatagatacagtccctcc
-atacaattaggaccaacatgttattgccgatcctagcacacacaccacaaactcagaact
-tctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaattagcattaata
-ttaaaactaattaggataaactataggtacgagctttactataagtcactaggtgttttc
-cgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataaagaaaaaaagga
-aggtacgtgactaatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaa
-gtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataaagttggactcca
-tcatttagaatcatagggaccaaaacatttatttgctactgtcactttgtaggtgttcta
-ttctgaattcctcatattgatacatgaatcggaatacctgtggatcccttaggacgcacg
-tgctttctttacgtcagaatacatattgtcagaatcgagaagttccatgcaattaagaat
-tcgcctctttgaaaactcatatccccacatatagggtccaccgttattcggaaacgatat
-aataattattccagcgttgagcgtcccttaagagcgcattttcgcttggcctttcttcta
-cgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcaccccatagaacta
-cctctgagagcgcgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgc
-gcattaaccagtcatattaaaatggactgtcttaattgtcggcattaggagcaatattaa
-ctgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagata
-cgattacagactcagatcccctaacaagcaaaacgattaaatcggaatcactccccctat
-gacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctcaaccgcgcttta
-taagatgttgagtctgagaattagatgacctaactgcaagaatcatggcgagtttatcta
-gtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggactt
-agatgataaccaagaactggtttaccgagtactttcactattaggagtaattacatgcgt
-tcaccgcggaatacgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttg
-cattgcaacagtcgctaccagtaattgctgatcaattatagattcattatacagatgctt
-acttttctctattcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgc
-ctagtataatcttgcttccacttgaatcaatgcgatggacagtattctactgattgcaaa
-gtagtctatttcggcttagcagtacgcatgcctatttttttgcaggcacagaataatatg
-caactaggattctcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatct
-acgaagttgatgtttactacagaaagcgaatgatatcacttggagaacattttagatgcc
-cccttttaatctagactgagtgtaccaatatatcaccggtctaccgaatcagcttgaata
-aaccactctagtactcatgataaccgagcatacacatgtatttctcaatgcactgaaggt
-gaactgtttacaccataccttgcgaatcaacgtggcgacttatacttctgtctttgagta
-cagcacaccctaatgaatctaagttagttgttgatacgaattgtaatttgactggatctc
-gcctcctcatctagattcttagagaagatgtttcttatagccggtactgtaactttattg
-atctggtttatggtaatcaacattttacctctatttaaacgtccttgcgccgtgcactca
-atcctgatcggtttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcac
-agagtaagctctctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaa
-ctctcattgtgttgattcagtaatacaagattacctacgcttctacgaaatatactatag
-atttagcctacgtcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtgga
-ctgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtcgatatcaatggg
-atacctcaaacgtctttatctctggataactcacattgagtataccggtaaaaatttatt
-ctattcatctaaatagtcagtgagggctagggtcgcaatcacattaggccacatacacat
-acttaacatgttctattgacccgacccaactttagtagcattgtagccgtttatgcaaat
-atgccaggcgccaaacactagccagagggcattttgttacatttatttaatcgattatta
-cacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtcaacaattcagta
-atttaatccaaaacctaaagtcagagacatgacactaaaatcacattaaggtcagttagt
-gaaggaatggctaaccagctagagaatgcatcattaacaggcacttattgtcaaatattt
-tccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaacacatcagtcca
-ggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcg
-ggacttagcagacactggatgcagtcatagaagatcttgcataacacgttagggttagag
-ctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaa
-cacgtttgtgatttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaa
-aaatcgcaattaacatacgttgacctatttttgttcagagttcagttagagcctaatgat
-tcgagagcaataatcaggacagcctcataggaagtgtcaatcacttagaagctatattat
-tataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaac
-tggcttaacaatatgatacataaaaatattttcatcaccactaagacggtggaattcaga
-cttattggcaacttaggatgggactattaaataacccataagatgttgggataaagttac
-gaaacgaaagggatatagcctgttagataggaaatccccaataaaacatagccggcctcc
-acagcagtgatctattccgccacgcgatatctttataccacgcaatataccaataataaa
-ggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccg
-tatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagcttcctctgcaaga
-tacaatatgactttttagcttttttactaccaaatctcagaatcttagaaacaggttggt
-acgtgctactcggaattcccaaagtaccctgctatatatgccattccttcattggtccgg
-gctcaccatggggccatcatagtaatagaaggtagtaaaactagttgatttccgactttt
-aacaatcactatcctgacccagatatgggttccgactggcccttactccagtaagggcag
-acacacagacaacgagaacttgataactttgaattctcaaatcgatcattgcaacgtgac
-ttatttactagcctactcctataattcatacgtcaaatacatttcaacggaggaagataa
-taagtaaatattcactaaataatggtcgaaggagtcctttgccaacataagtccacatat
-gcgctatagattttttcttggggttcatattcaataagataaacagcaagagtatcacgt
-cagcgagtcattgagatcttggctagcattgtgatagcatattctacctaaatggtagtc
-tagcacagagtggataagatatcagttagatatagacaagtactataacagatctcgctt
-cgttggattgtatggctagctttgatgatatgattttataaaaattgatccagacctgac
-ctggccaattatattcattttttatgagtaaaaatagataaccatgaaaatactcaagcc
-ccttaggacgtacaaagtggtaacataaatttcaggtgttattctgcaaccacacctgtt
-ttgggttttcaaaaaggctaagcagattggttttacagataatccctgaacactggtatc
-tcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaa
-ctaggcggaaaatatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaac
-gcctctttggattacacagaatagtgtactgacacgtacactgctgcagcagccatacgc
-taacattaaaattcgttgagtctacatttgttgttattcggattatgttattgggaatag
-tatttttattcccctgcgtgaaaccacatggatagattagcctactcctaaagactccct
-tttggtctacggttcaattctcttactgagtttatgttcgtaattatatcggcgcagtga
-atctcctaattatcaccggagttaccagacgccatgaacttatggccagaaacattgcat
-gtggcctacataggattagtatcaagagtttacgtttgcaacgacatttgaccaacttga
-ccattcctgcttgtagaccgcgggaactcccctgcacgcgactatagaagttggtggtgg
-atgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaat
-tgagacatgtataagggctattgccagatgaaaaactgcatataaggtcaaacaatataa
-gaacattatacataggatcttagcgttcctcaggatggtatacgctataaagtctagctt
-cagcagctaaggagttttgccagtgcggacttccgctggaagattaggtttaaccgccct
-gacatcttcataaggtcgggcctgattcaaacccctggagtgccgtctcatacttgaatt
-aatcgatggaaaacttcttctagtctaatattattattaacaaatgacggttcaataaat
-aacaccgtaagggtgggaaactgttaagtgatgaatcattttaacctatcatccattagc
-tacagataatgataccccgatccgactagggggtaagtggttgttccgttaggataaacc
-atgtaaaacgttagagggtttgtagattaattggtattccagataaatgaggtcagggcg
-agtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaat
-gaaggggattcagaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcat
-gatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatatttatcgagtcta
-taaatatctttggttgtatattacttcacaatcaccaattctaaatgattcttccactgt
-gcgggtggagatatcaggacgggttaaggttgacctacatcgttttgatacaacaaaaat
-caaagcacatggctggggacttctcgatactatctttgagatagtacgggcaagagtggg
-tgacgcctccctacattttcaagtctatcggataacttctcggtaaaacgctcgcgatat
-agttttaaagcattgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaat
-tcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggttatccaaaaggaat
-aaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatgcgtatggttctg
-atatatagatcgatgcatgaggacactttattttagccggcgaattaatggaatccatac
-gttacttatttggacatgacttctaggtgtttttgctgtcccgtttagcgatatttacag
-attagtatttcgtttctcatagttaattgtatctagatactaactcgttgaagacgcata
-ccttgccatttgtacaggacttaactgttccgtgcgtaatttgaatttcttataggttct
-tcaaggcacgaatacctcactcatgaccgttcatactctagttaaggtcgggaatactac
-gtatgcagggaattgtaacctaggagatttacaactctttaaacaagagtcgctgaggtc
-caggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatcacctagaaaccta
-ctcatacatttgcaattttgagatgtaggcgaaagagagaaatctgctttttaacggtat
-ctcttgggattccttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctg
-ggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaa
-ggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaa
-gtaaagggggtgaaaatgctccccagggttctacagacatagagatggtcagaacacgac
-ccccctctcaacgcagtgtatttgaaatatatggacatatctaccttattctgtaatttt
-agatgtgttctgtgtataccgatattgataagtcaataggcttgattacgtatcttaaga
-caaatctgtttcgcaagtaggaccgcatctttcagattgtttctttttatgccataacct
-gcccaggaattcaaaaggttatcgatacccgatatgctgtgaattattattctaatggcc
-actcattcctgcttatatctggaattggcatgaatatcttacaacctaaagtctggcgtt
-gcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtc
-acataaaagttcattagaccacactttgtgccgacgtatatagatatattacacgtatag
-ggaatgttttctcctaggtgacccgaccttctactaaggttgtacatcgtataatggccc
-attaactacgaggaaagtggtattgacctggtaatgcacgttcttcgatatataccgacg
-aggtaaagtctactattgcaaagtttgacgttatactgataagtttagatttccctggat
-cgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaaatccttggggat
-actatcgctactatcatcggaccaaaattaaataggctagtgtcttatcagaacatcatg
-tttaccgaactgatctattttccaatttaagctgatattacgtccgcgtatttattttag
-ttccccggatgacgattatctgagctacatcatacaagttagcatactcgccggtgcatt
-gatttcttatttcgctatatcttcaagttcacaggcttcatatagttccaattagcagta
-taattaggttttgtaactttaaccatactttataaaaggttatattgcacaactgatcaa
-gcatccgctataacccgagctttaccagttagcggctaataacaaataagatgacttcgt
-gtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggt
-agtaataagtataaaatgataccacatatactataacaatgaaattatttgtaatccggt
-ttgccaacgtatcccccttcgcgataaattaatgacatagggtcatccatgtgccaatcg
-tgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgttataagcgttga
-aagtgatataggccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttatt
-gctggtagtacaacatcacgagcatttctcttttgagttgatttatactatatctgctga
-tgtgattatgtcccacttacccagaatattaagaaagtcctagattgtaggtatacttga
-ctataaatataatttaagactatacaaataatctggctacattatgccatcgtagaaact
-gataacgtagtaacgtcggacactagattttggtcggggagtaatctagcatactaacga
-atttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgttt
-agactattaaggactcatttcgagatccagtattaattatacgcatccatatttatactg
-aagacggattgagttaggacgacaagctaaacaaatattaagttaaggattagtattata
-ttgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgttacttattcagag
-agacttaattcggttatgactggcagctcacctggaaagtaggtgaaaggcaacagaaga
-atattgttgactgaattctacgggctacgaacgtaattacaaagcggttcgtaaagagca
-taaagatcaatacaatggatctctacagtattacgtaaataacatacataaacctggtgt
-tgattcgactagctcatagattaatcattaattgaagctacgaagacgcggaagtctgcg
-gagtgagcaaacagtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatg
-gtgtacattaacgtgggggtagtcaaaggaatatatttactaggaatattagttatgcaa
-atgttgtgtcaatgtgatgtgttttatccagacattggatgcatggctgtgggggcacag
-gatacttaccattagttcacctacaagcggcgtgagagggtctcagttttagccagcgca
-gagaagtacgggcctttagacgattaatgctagaattgtcataaacctcgtgaaaagcta
-gttaataatcatggtgctagaagaacacaacttttctataaaccagttctcgactgacag
-tcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaa
-atctactgggtgcatcagtagagatcgtgttctgagagataaatacaccggatacgatct
-gcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtagcattttttaaca
-gtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggtttaaagtttata
-tgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcc
-tttatagactgagtgtatcgtacactcggtacaattacaaaggatggaagagcaaatagg
-tcttcaattataacagtaccccaccttaatctaaaaaccagcttcaattagtattaattt
-cgccaggagtatatatataaatatctaaagactaaaagactcgtacttttacaacttacg
-tcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattagaaatactccttt
-gtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgatta
-aggcctataaaactgttgttggtatctacagagtgattaaaattagtgaatcagattacg
-aaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggct
-gtagtagaattttggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaag
-cggtttttgttccatagaactatgtagttggttataaaggttgtaatctcggagattagg
-ttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatg
-agttcacgaactcttaatgccatgcctggacaggataaacaatacgcatataacttgacg
-atcgagcttatatcgacctatttgagaagtttaacgggtcgatataatatacaggtctta
-atagccgattttttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtga
-acgatatatcagcaaactgaacattgtatacaacattcctttttgtccgggtggggactc
-catttaaagtatctcacctagaactcagcggtaatagatgcagtctcttgcccagttacg
-gtaactaaatgttgatacttagaattgctaaattttagtctagacatttccaggtaaacc
-ggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaat
-tgagggccctactatagacaatcatcagactttttaattaaatagttttccatgaatgtg
-ttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgtatgactgtagtcg
-gtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttctaagatggacta
-taatcgattaggctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttgg
-aatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacc
-tatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagc
-ctagagacaaagggatactgggcggggaaacctgctccttcacggtaacatggtaacaac
-agaatttggttaaggttaaaacgaaatatactcggagtgaattactgttaggtttcgtca
-tcggatcaataagtagtttccgtgaagacactcttatattagatctccgaaattctgacc
-cgtgcattaggcacttggtaggagattccatttggaacttgctcaatgtaagccagtaat
-gttccgaaataattcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttg
-ttaccttatggttgagggtcaccgttctctgcgtcaattccagagctggagatacattca
-tcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaa
-cggatttagacaaattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcat
-ggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttcc
-gccattaggtaagctatatattgtggtcagaacttgaggacaactatgagctactaaaaa
-taaacaattttgtcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagt
-tacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatcaataacatatagt
-tcagatagagaacgaggtattcgacagagaattacccaacattggttattaatctatgca
-gaataatttagataatgtcactacataatattaggaccaaaaggtgattccccagaagac
-aaaacaataaacaatctcacatattcgctagtacctatgtatgggtatgatcttctgatt
-ggacggggataatttccaggtatattaaaacttattaccataatctagacctaagagagg
-ttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagta
-aattttgctttaacaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcag
-gtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaa
-ctaatatcataaactgccactacatcttgtacaatcattcgcaacaatacttttatgtgc
-taaggtcacgtgcttcctctgctatgctgatttaatcagattcataaaggaatacgaata
-actctggatccattaccacgcaagggatttatttacggctgattactttttggctgttga
-cagaactgccatgaaagtaagatgtcgcatcttgcataaataatagcacctaatatagcc
-gacaaagtgattccgataacagattttaagttgtccagccttgagactccatgaagaccg
-cttgggagcttccccgtgattagaagaatctaaatcccaagtggatggggggagtttaaa
-tctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcc
-tgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaag
-tgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaaggaagcacgcat
-tgaagcagctacgcagaactgagaagatgacactctaagatacaattaatacaaaaacgt
-tttaagcccaatctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatg
-tcccgatgtataataacagctttatttctgctggtcgaggtgaagtagtggaaattactc
-catcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcgtccatccctctc
-tcctagtgatccgtatatccaattagaggataaccaacatctgcgttaccgacgaattta
-aatttttcgactatttaattccgttcaaacccgtattcgtagtaagtgtttcatagattt
-atgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaattgctgatctag
-gatacatgctttataaacatgcttacttggctattttatttactgtcatgtgggggtttt
-tattttcaacaagtatgtgctaccattggataatctggcttcaaattgaagatatgcgtt
-ccaaacttgtctactgtttgctaagtaggagttgtcccattagaactacgcagcacgtgg
-tttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaatttaatgcagatt
-actcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatag
-aaattcgtgataatttttgttccaacctttgaatctagactgagtggaaaaagatttcac
-cgggataccgtttatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaa
-tggatttctcaatcatctgtacgtcaactgttttaacaataacgtcagaataaaccggca
-caatgagacggcggtctttcactacaccacacccttaggattataagtgacgtgtggatt
-cgaattctaaggtgacgggatctacaagcctcagctacattaggtctgaagatctttcgt
-atagccgcgtatgttactgtttggatatgggttatgctaatcaacagttgacagcgagtg
-aaacggccttgcgacctgaaatctttacggttaccttttgattcaagacaggatcgacga
-tggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaac
-gacaagttcacatcctctatgcaactatcattgtggtcattaaggtattcaagattaact
-aagagtcgaccatatattctagagttttacaattaggaaccgttagtctagactaggagc
-gtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgacacatagtgtctt
-ttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgggataaataacat
-ggtgtttaaccctattaatggtttctattaatctaaattgtaaggcagcccttgggtcga
-aagcacattaggccacatacacagtatgaaattgttcgagtgtccagaccataattgact
-accatggtacacggtgttgctattatgactcccgcaaaactcttgacagagggaattttg
-gtacattgatgtaatcgatgatttaacagtaggaactagacgtcatccgttagactgagt
-tccgacatgctcaaattgtcaggatttttatccaataactaatggctctcacatgtaaat
-aaaatcacattaacgtcacttagtgatggattcgctaaacagatagactatcattcatga
-actggcactgtttcgattatatttgcaacatcgaacatacttaaagttaaatacgacatc
-attcaattaaaaaaattcagtacacctctaatgagtatcccgctttggaggaaagagtag
-cactttaaatggacaatttaggccggactttcctgtaaatggatgaagtcattgtacagc
-ttgaataaatcgttagggttagtccttacatccaccatatgttaatgaataaagcctgag
-ggaccttagagctaacttgtccaacacgttgctcatttacttaataaggttgaaatgtat
-cagtaagtgacagcgagtgtagattttgaccatttaactgaccttcacagttttgtcttc
-agacgtcacttacaccataatgatgacagagcttgtagatgcacacactcattcctagtg
-taaatcaagtagtagctagattattataaagagatattttctggcgtcgaacgtaacaca
-gagagagtataaggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaata
-tcatctaactcggtggaatgcacacttatggccaactgaccttgggacgagttaagatac
-cataagaggttgcctgtaagttaagataacaaagggatattccatctttgtgtgctaaga
-acctatttatatttgcagccataaaaacctctgtgctatgcagccaccagagttatttat
-acaaagaaagagaccatttagatacgttaattctgcttgcgatttattaaacagacattt
-cacgtccaaccactacaaaagccctatcgcaagacgatcattgtattatagcctatgcaa
-cgtagctaagcggccgaggaatcataaaatatgaattgttacattgtttactacatatga
-tcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaactaacctgagata
-tatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtagg
-aaaacttctggatttcccaaggttataatgctctatactgaccaagagatccgttacgac
-tcgcaatgaatactctaagggcactcacaaagaaaaccactaattgataaatttcaatga
-taatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcat
-agaaatgtcatagcaggaacataattactatattttaacgatttaatcgtagttggagtc
-ctttcccaaattatgtcatcagttccgatttagatgttttcgggcccttcttagtaaaga
-agttaatatccaagactagctcctcacccacgcatgcacatattcgcgagaagtctgata
-gaatattcgacagaaatgcgactctagctcacactcgttaactgatcaggtacttataga
-caagtacgttatcagatatcgcttcggggcattgttgcgctacctttgtgcatagcagtt
-ttgaaaaattgttcaagacctgaacgggaaaatgatattatttttttaggaggaataata
-cagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaacatatatggcacg
-tgttattcggctaacaaaactgttgtgccttttctataaggataagcagattcgttttaa
-acatatgacctgtaaactgggatctacaaaagaggtacttaaaataaattgcgcaacggt
-ttagatctgcggatctttggttaaagagcaccattagatgtgccatacttcctatcgcct
-gagcgagaatttagtctgaggaaccactcttgggatttaaaacaattcggttaggacacc
-tactcggcggatgaagcaatacgataacattaaaagtcgttcagtctaattttggtcgta
-gtacgatgagctgatggccaattgtatttttattaacagcactgaaacaaaatggagact
-ttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatc
-ttcggaagtatagcgccgaagtgtatctcattattataacaccagtgtacagacgacatc
-taattatggccagaaactgtcattgtgccattaagaggattagtagatagtctggaccgt
-ggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgca
-cgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttac
-gattctagtgcttcttaacgcaattcagtcttctagatccgctattccaacatcaatatc
-tcaatttaaggtcaatatatataacaaaattagacagagcagctgacacttacgaagcat
-cgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagtccgcacttccga
-tgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccact
-cgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctactattagtttatta
-tgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaat
-ctttgtaacagttcataatgttgctaaagattatcagaccccgtgaagacttcgggcttt
-gggcttcgtaccgtagcataatacatctatatagttagaggcttgcgtgttgttgtgcta
-ttccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcga
-cctacttgttaagtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgt
-atttattatactgtaggcaagaagcttttttggcgagatttaagacttaagcctatggta
-aaaatttgatagtgagcgactatagtaagagatttgggtggttagtaattaaaattctcc
-tatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccg
-aaagcgtgtggattatacaaatttcaaacatattggcggggcacttatccataatagatt
-tctgtttgtacgccaaactctgcctcacccctccataaattgtattggctagaggttaaa
-ttctccgtaaatagagacacatatagttttatacaattgtttgaatcaaagcacgagaaa
-cttttaaccgtacattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaa
-atcaatcgctgagcaataagcaagaaaacacagattatacaaagagatctggatgaagat
-attcgtgcaatcactatcgttatgttagagagttccatgcatgaggactcgttttttgac
-caggagaattaagccaagaaataactgacgtatttccaaatgaattctacgtgtttttcc
-tgtcacctttagccagtgttaaagatgactatggagtttcgaataggttattctatagac
-attataacgagtggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcag
-gtagttcaagggattttaggttcttaatccaacgaagaaataacgcatcacccgtcattc
-tattgttttcgtcgggattacttagtaggcagggtattctaacctacctgagttacaaat
-ctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtcc
-ctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgacttcttcccctaaca
-cagaattctcagttttatagctatctagtggcattcctttttataaaactttacgtttgt
-aagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagactt
-ggaacccatgtatattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaag
-caaggtatgttctaatctaacaatgtaaagccggggattagccgccaaaggggtctaatg
-acatagagatgctctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgac
-agatcttccgtattctgttagttgacatctgtgctgtctttaccgattgtgatttggctt
-tagcagtcatttagtttcgttactcattgctcgtgcgatagttccaccgaatatggcaca
-ttcgttctttttttccattttactgcaaaccttttcaaaagctgatcgataccactgatg
-atggcattgattagtcgattggcaactatgtcctgcttatatctccaattgcattgaata
-tagtaaaaaataaaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaac
-tcgtttaaccaagcgccgtacctaacatataagtgattgagacaaatagttctccagacg
-tattgagatatatgtctcctataggcaagcgtttctaattgctgaccagaaattagaatt
-aggttgttaatactatattcgaccattttattccacgaatgtgctattctactggtattg
-ctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaa
-tcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggtatctgccatattg
-ttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaaatattaatgagg
-attgggtcgtataagaaaatcatcttttcagttcgcagatttttgccaatttaaccggtt
-atttcgtcagacttggtagtgtagttacaagcatcacgattatatcagctacagaattaa
-actgtcctgactcgacggggcagtgtgtgagtattgcgctatatattcaaggtaacagga
-ggcatataggtcatagtacaaggataatgaggtttgctaactttaaaaattattgattta
-acggttgattgaaaatctctgcaagatgacgctagaacacctgatgttcaagtttgccga
-taataacatataagatgaattactgtctttagaccctcatgttaatccgctaacttaggg
-cggaaacaatgttaggctatgcggagtaagtactatattatgataccacatagaatttaa
-cattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaa
-ttacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaaggttcagctatt
-ttggcaatgggtgagtaccgttcttagtgatttacgaacccataatctaggcgacttaat
-atacaagatttagagttacgttttccgggtagtacatattaacgaccatggatcgggtga
-ggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccagaatattatgttt
-ctactagagtgttcgtatactggaatttaaatattatgtaagactagacaaattttatgg
-atacattaggccatcgtagaatatgatatagttgtaacgtccctctatagattttcggag
-ggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggatttgtaattaact
-gatgcgcagcgcttaaataagtttagactattaagctatatgttcgacagcatgtagttt
-tttttaccagaaagtgttatactgatgacccatggaggtagctcctcatgataaaaatat
-tgttacttaagcattactattatagtgttcaaactagtaccgttgcatactttaagaatc
-agacatggcgtttcttatgcagacacacttttttagctgttgacgcccacctcacatcca
-tagtaggtcaatcgcataagaacaatattctggactgttttattacccagaagaaagttt
-tttctttccggttcgttaagacaataaagatcatttcattcgttctcttaacgatgaact
-aaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaa
-gataagaagaacaggaacgcgcacgtcggagataactctaatagtctctttattccgttt
-aatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgcaaacctatttat
-gtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttttatcaagacttt
-cgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggag
-tcgctctaagtgttaccaacccctcactactacgcgaaggtactcgattattccttgaat
-gggctgaaacatcgtgattagcgtcttatgattcaggctgatagaagaaaacttattttc
-tatattccacgtatacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgct
-ataataaataaaatacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtc
-acataaataatccgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaagg
-tggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaatatcataataga
-tgccatacacggttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtt
-tcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatg
-acttaggatggatgagcatttaggtattctatgataacactaaccatcatgtttctaaaa
-tcctcaggaaatttgtattattttaccaacctgtatttatagaaagtgcttttgacttaa
-agaagccgaagtgttcaaattaaggagtacctgattgaaagaatggggaattgtaatctg
-taactcaattacaaataagccgttctaaggattaaggctttgtgtctaagcaactcacgt
-gaattcgaaattcatactcgattaacgactttaatactcttctgcgtatctacagactca
-tttaaattacggaatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaa
-taaggacacctggtacaattggctggagtacaatgttggtttttatttgctgattatccc
-gatccctgtgggcgttggcataaccgggttttcttcaagactactttcgtgttgcttata
-tacctggtaatatcggtgagtagcttagggcttaatcacaatactaacaagttctctatg
-gattggacagggcggcatccgttgactgaacgatctattaatccattccctgcactggat
-aaacaagacccatttaaattgaccatagagatgttagcgtcatatttctgttcgtgatag
-ggtacatatattataaacggattatgagcagtggttttctagaaaagcattcatagttag
-gagtgtatcagatcataccactgaaccatagagcacaattctctactggctatacttcat
-tcctttttgtccgggtggggacgaaatttaaaggttctaacctagaacgcagagcgaatt
-gatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttg
-actattgacagggcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagat
-agagtacgggcctataattcaaattcagccaccgaagattcacaatcttcagacgtttga
-aggaaagaggtttactggtatgtggtgtcaagccccacccattctctgttatatccgagc
-attaatgtagtttcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaac
-aatttaggctgagaagtggcactataatagtttagcctaagtcccttcgctaataactca
-acaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatact
-gatagctctcatggtaccaagaactttcataacctctttatttaccaaacctgttctact
-agcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcg
-cctgcaagctaacatgggatcaaaactattggcttaacgtttaatcgaatgagactagca
-ctgtattactctttcgtttcggcagcggatcaataaggaggtgacggcatcactctctta
-tagtagatatcacttattctcacaacggaagtaggatcttccgtcctcattaaatttgca
-actggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggtcagagcagacga
-tgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaa
-attccagacctcgagttacattatgaaacgtgtcattccatctcattaaatagttcgtgc
-cctatcgccttgtaatataaacaaccgtttttgtctattttcccaaggagaaggagagta
-gcagcttagtggcttgcctatatggccccctaagtacgtactcggcacgcttagaagatt
-gggctaccccgcactatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattc
-aggtcatcgatgagagtataaaaatatacaattttggcaggggttatacattgcgggcat
-gaagagtaacattggacatgaacggacattcgaaccctgtgagtttaataccctatctcc
-ggatcattataaagtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaa
-ctaaattggttatttttctttcatctagatttgtctgtatctaactaaattatagttcca
-cataaagctgattcaactgaagacataaatataaactttctaacatagtagcgaggaaag
-agctatgcctagcatcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttt
-tccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtgaacatacataata
-ccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcctacgtaaggctat
-ttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtaca
-ttcagatctccttagtatcatcaaattatagattttacggccacgaattattggtctaga
-tgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaag
-aagagtcattatgctataccaagaactctccatccagtacctagaaaggcaggtatgtac
-cgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggct
-tttataatagaaactaagtttcccgaataacggtgtacgataacagatttttaggtgtac
-agacgtctgactcaatgaacacacattgggacctgccccgggaggagtagtagataatta
-ccttctccagcgcgggtcttttaatatcacaacataaaaatactaattaatatcacacac
-cctcatcctcgatggagcctagcatcatacacgtttgatagacaacgccaattttactgt
-aatatgatattcgaatctagtatgtggacgctgtaccacattgtttaaaggagctccctt
-taccgacatgaacgaagcaagctttgtacaagatacgaagaactcagtactggtaactat
-aagagacaatttatacataaaagtgttaagaccattatataaaaagaggtatgaggtctt
-tgtaactacaataatacattcatcgaacgatggagaataacagagttatttctgctgctc
-gagctctagttctgctaatttctcaatcttgatgccactcgtttgagtcttccattcgct
-cttaacgacgcgtacatccctctctcctactcttacctatatcctattactggttaacct
-acatctccgggaaagacgtaggtaaagtggtccacgattgtattcacttataacacctag
-tagtactatgtgttgctgagagtgaggacacacttactctacgagttcaagtccatatgg
-acattacactttttcagcatctaggtgtcatgatgtattaacagccgttaggggctattt
-gattttatcgattgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaatag
-gcatgaaaattcaagattgcagttcctatcttgtataatctttcctttggacgagttgta
-ccatttcaactaacctgcaagtggggggtcatccatatgaagatttgccaaatacctgga
-gaccctgaaaagtttatccagattaataataacaaacaaacctaagcgaagaacgtcagc
-tttaataaactatcactatcatagaaattcctgttaattgttcttccaaacgttgaatag
-actatcacgggtaatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcg
-aatctgctgataactcaattatattcgatggagaattcatatctaccgcttagcttttaa
-aaattaagtcagattattccgccacaatgagaaggcgcgagtgcactaatcaaatcactt
-aggattattacggacgtctgcattacaatgctttggggtagggttatacaagcatatgat
-tctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatc
-ctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacct
-gttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaaactctaacatag
-cgtggcactatgagtacgtgtaacgacaaggtctcatactcgatcctaagataattctcg
-tctggaaggttttaatctttaactaagagtagaacttagtttattgacttttacaattag
-gatacggttcgcgactctaccacagggcatcatacctggagctctgctatctcgtgacca
-aagtggcagcacacatagggtcgggtcctgcatctactgagcaatccctttaagcattcc
-tagtttgagagccatttagatattgctgtttaaaccgattaatggtttctattattataa
-agtgtaacgctcccattcgggacattgaaaattagcaataagacaatgtatgatattcgg
-cgagtctcaacaacattatggtctaccatgggacaaggggttgatatgatgaatccacaa
-aaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgttataaggacgatc
-tagaagtattcaggtacacggtgttcagacatgctctaattgtcaggttgtttataattt
-aacgtatcgctctctattctaaataatataaaattaaccgctcgtagggatgctttccag
-taaaagatacactatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtac
-attcttaaacttaaatacgtattatttaaagtaaatatattatctaaaccgcttttgtct
-atccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatct
-aaagcgatcatctatttcttctgattgatgtaatactgacccttactccgtacatacaaa
-tgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctg
-gtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcattttgacaatttt
-tctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgt
-agatccaatcacgctttcctacgctaatgaaagttctagatagtgtaggtgttagacaga
-ggttagcgcctacatccttacacacacagtgttgaacggcaagcataatcgagtatcaat
-agctgtatgtatttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaa
-tgtcctgccctagagttatgataaaataactgctgccctgtaacttaagtttacaaaccg
-atattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgc
-gatgaacaaaacacagtgatttataaatacaaagagtacatttagttaccggattgcggc
-ttgacatttattttacagaattttatcggcaaaacacttcatatgaactatcgcttcacg
-ataagtctatgatagactagcattcgtagagaacaggaagagcaatcattatatatgaag
-tgttacagtgggtactacatatgagatcattaggtctatatccggccttcctcataagac
-cttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccc
-caaagaatagtaattcatcggacgtaatagtctggttttaactaggggttattgatattt
-aagctaaaagagttccctgaacactcgaaatgtataatctatcccaactaaaaaagtata
-cctctaattcagaaatgtcattgagattagactgatgtcaatacgctaggaggtaagaca
-agtagaagtttttgatttaggaattgaaatgtaatacctccatcttaagttctatatttt
-aaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatg
-tttgcggccccgtatgagtaatgatctgtttatcaatctctagctactatcccacgaatg
-cactgatgccagtcatggcgcttacattagtcgacagaaatccgacgatacctatcacgc
-gtgaactgttctggttcttattcaattcgaagtgatctcagatacattacggccatgctt
-gcccttcatgtctgctgagcagttttgttataggctgaatctcctctaagcgaaattgat
-aggatttttggtggtcgatttagtctgtacctgcttattaagattcaaaatgacctactt
-cttacgccgaaatgatagggatcggctgaggaggataaatatacgctggtgcctggtatt
-tatccagaacaagttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggt
-acgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtatagtccaccatta
-gttctgacttacttaatatagactgaccgagattgtagtatgtggatccaagcttgccat
-gtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaagagttaattaatag
-tactgcactataattgtcggcggagtaccatgagctgttgcccaattcgatgtttattaa
-cagcacgcataaaaaatccagacttttcaattagaattaactataaatggtccgcgaacc
-ttaaatgatcggaaggacgggatctgccgttgtatagaccccaactctatctaattttta
-taacacctctgtaatcaacaaatcttattatgccatcattatgtcattcgccaagtaagt
-ccagttcgagattctctggaccgtgcaatagtattgtcaaattatggtaatggaatcctt
-cttctaacacccttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagc
-aacataagtgccgtttctttttacgatgatagggattcttaaagcttttctctattctag
-atcccagttgccatcatcaatatctcaattgatgctcattatatagttcttatttagtat
-gtccagatgtcactgaagatcctgcctagaaccgatattctcgacaggatcatcagttcg
-acggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagt
-accgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagttttactgccttt
-aattagtagtcgattagtgtagtttgatattatctaccttatagaatgtaaacagtaacc
-cggccttaatggtttggcaggattctttgtaaaagttaataatgttcataaactttatca
-gaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacgg
-agtggcttgcgtcttgttgtccgagtacacatattgctcctctcccccactcttctagga
-aaatcaattatgctaacctgcagaccttcttctttactatctttaatgcatgcccagtat
-gttcatagggtagacttgctatctattttgtataatctacgaatgatgcttggggcgcga
-cttttaacaattaagccgttgggtataatttgagagggtgccacgatagtaagagatttc
-cggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagctcaccctcctcag
-ttctccaaccctgaaccggctaagtatgactgtgcagtattaattttgaatacatattgc
-agcccctaggatacattatagatgtctctttcttacccaaactcgcccgcaccaagaaag
-aatgtggattcgattgaggttaaattagccggaattacagacacagattcttgtttacaa
-ttgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatggattacgttggg
-gatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaagaattcacagagg
-attaatacacttctccatgaagataggactgcttgcactatccttatctttgtgtcttcc
-ttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataacggaaggtgttc
-caaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggac
-tttagatttgggtattctagagactgtagaaagactgcaacaacaagacattcacagggc
-gaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttaggaatccatacat
-gtaagaaagaatcaaccgtaattatagtgttttcggccccttgaattacgtgcatgcctt
-tgctaaaagacctctgggaaatagattgaatattctggacagcagcgaatcctgattata
-tctcaagcgaatatatgacccgcaagaaggatttatactagaataagtctaagaaagggc
-attgggtcacttcttccactaacacacttttatcagttttataccttgagagtcccatgc
-atttttatatatatttaactttcgttgcgtaaaactttaaatatgatccgtgctctatct
-ctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaag
-aacggtttcttctgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgc
-attagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaa
-caacgcgatttctatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatg
-tcttttcagtttgggttttggatttaccagtcttttagtttcggtactatttgatcggga
-cattcgtccaaacatgatggctcattcgttctttttttcaattttaatcaaaaccttgta
-tttacctgatacattaaactgagcatcgcatggaggtggagattcccatatatgtaatca
-tttgatatcctattccattctttttagttataaataaacgctccactgcacaatgggagt
-aggacttcaccaataattagcatctactgtaaacaagcgccgtaacgaaatgattactga
-ttgagaaaaataggtctcaacaacttttgacagatatgtatccgatacccaagcgttgct
-aattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaatggttattactc
-caatgggctattctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgt
-agtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaa
-atcgatcacggtgatgaattattgttattgtttaaaagaagtcccctgaatagcccttag
-ataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgc
-agagttttgccaagtttacaggtgatttactaacacttgggagggtacgtacaaccatca
-cctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattg
-accgagttattaaacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttg
-cgaaatgttaaatttatggttttttccgttgagtgataatagctgcaacatgaagatagt
-aaaactgaggttaaactttcaccatattaaattatatgttcaattacgcgatgtacaaac
-taatgttaatcagatttaggagcgcgcttaatatgggtccctatcccgactttgtacgag
-attttgataaaaaatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttg
-aaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcctggctcaatatt
-tataatagtaatggttaagattgtggcccaatcgctgagtacccgtcttacgctttttcc
-aacacataatcgacgagaatgtatttaaatgtttgagacttacgttttccgcgtacttat
-tattaaagtcattggagagggtgtcgtctgggtgtagttttctcatctgctcaggagcta
-aaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggctatttaattttta
-tggtacacttgaatatgtttagccataatgtagccaatactacaatatcagatacttgta
-tacgacctatagacttttgccgaccgctcgtagagtgatttagaaagatgttcggatagc
-acagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgc
-tatatgttactctgaatgttgttttttttaccagaatgtgttataatgatcaaccatgca
-cgttcctactaatcatataaattttgttacgtaagcttttctatgatagtggtctaaaga
-ctacccttgcatactttaagattaagacatgcactttaggaggaactcacacgttttgag
-ctgttctagcccacctataagccattcgtccgcaatcccataactacaatagtcggcaat
-cttttattacccagaactaacgtttttatttcccggtacgtatcacattaatcttaattt
-aatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgcttcttgagaatac
-agattactgttagaatgaaggcatcataactagaacaccaacgcgcacctcgcacattac
-tctaatagtagctttattcagtttaatatagacagtatttgaaccaggcgctaatgttaa
-ggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatttgcggggcgata
-gcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacag
-ttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccg
-aagggactactgtattccgtcttggggatgtaacagactgattacagtcttatgatgaag
-cctcattcatctaaaattagttgatttattccacggatactatcacactcctatagaaag
-agttaccaccgtgggaagctagatataataaataaaagacatacaatattagtatggctc
-atgatctacacttactcggatctctctttttttataaccagtagatcgcattacacgtat
-tgttgttccgcatcaggccctaggggctcaaacttccatggtggataactaaaacgtccg
-tcactaaacgaagatattaatagatgaaatacacgggtttacttgatttctgttcagtca
-ttcacgggaaatcctaggagtctttcataacggcggtcttagtaggaatgtagtcaagct
-ctgtagaggtctcgacggaattggtatttcctggcatcacaatttacctagtattggaga
-tcacttaaaataatgttgagataataatcaggatatttctagtatgtgacaaacctctat
-ttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaacgactacatgttg
-gaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtgctttcgtttaag
-gctttctgtctaacattctaacgtcaattcctatgtaatactactgtaaccaagttatta
-ctcggctgcgtagataaagtctcatgtaaatgacggtttatctgttacttttgggtttca
-acctagctaggacgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgt
-gcctttttatgtccggattataaccatccctctcccacttggaatatcaccgggttctta
-atgacttagttcgtcttccttattttccgggtaagatcgctgtggaccggacccattttg
-atctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttag
-attaatcaatgcactgcactggattaacaagaacatgttatagtgtactgacacatgtta
-gactaagaggtctgttcgggttagccgacttatatgtttaaccgattttgacaactgggt
-tgagagataacaatgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctc
-aattcgctaatggcttgaattatttaattgttctaaccctggcgtcgaatttttttggtt
-cgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcg
-gcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaagctactcgaatt
-ggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaa
-gagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtggtctataccacc
-aaaaagtatatgggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgta
-cactaggcagccctaatccaaaacttttgaggatgagtactgccactattatactgtacc
-atttgtaacttacattttatatcttcaaagaggtagatattgtcggccattactgtcact
-tacactaagggtagcttgattactgatacctctcatggtaaaaagtaatttaagaaccta
-tttttttacataacctctgctactaccgttagtgttttagtcggttcaagtcacaaaatc
-cctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaaacttttgccgga
-accgttaatcctatgagaataccactcttggaatcggtcctttaggctgaggatatagaa
-cgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaaacgcaagtacca
-tatgccgtcctcagtaaattgccaaatgcagaaatcttacactcttttcttaactaagta
-tgagagcaacctcactcctgaacagcttgttacctaacgagaagaggctttaagtagcct
-ggagcctcaaccggatatccggatttgactctcatccacttacatgatgattacggtcat
-tacatctcatgattttctgagtgccctatagactgggaatttaatctaccctgtttctat
-ttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatgccaccataagta
-agttctcggaacccttacatgattggcctaccaacctatatatgtgaccaatgtacggta
-catagagtgtggcctatcatattcaggtcatcgagctcagtatttaaagattatatggtc
-gctgggggtattcagtgcgcgatggaagactaacattggaaatcaacggaattgacaaca
-cgctcactttaataacctatctcaggataagtttaatgtaattagacggaactttctcta
-actccgtgtactaactctttgaaaataatgtgggtatttttatttcatctagatttgtct
-gtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtcataaatataaaa
-tttagatcttaggacagaggaaagtgctttcccgagcataggatctggcctacgccagta
-gttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagggtagtgttcgat
-actcagcggggaactgacatattacactaaggaatcaaggcccttcgtatgggtcatgtt
-tatatatttaattacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatg
-caggatgcgattcgagtttgtaaattcacagatactgtgtatcatattattatagatgtt
-aaggcatagaattattggtattgatgtacaaaaaattatgggtgggcagtaccgataggc
-attacgagcagtgcagcttggaagaactggatgtatcctataactagtaagagccttaaa
-ggtactacatacccagggatgttaccatcattaatttggccatcttcaatcttcgcaatg
-catactttcttctacaagatgccttttagaagacaaaataagtgtcaacaataacgctgt
-aacttaactctgttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgc
-aaacgcaggactactagattattaaattcgccagcccgcctcgtttaatataacatcata
-aaaattctaagtaatatctcacacactaatccgccatcgtccatagcatcagtcacctgt
-cttacacaaacacatgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaa
-ctaattgtggaaagctgctaccttgaacgacatcaaccatcctacctttgtacaacagac
-caacatctctgtactggtaaatagatctgaaaagttataaatataactgttttcacattg
-atagaaaaacagctatgtgctatttgtatatactataataaattaagcgaaacatggaga
-ttaaaacagtgttttctcatcctccacctcttgttctgctaatttataattcttgatgcc
-actcgtgtgagtcgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaa
-cgagatcctatttctcctgaaaattattagcacggtaactcctagggatagtggtactag
-ttggtatgaacgtataaaaacttgtactactttctcgggatgtgagggagcaaactatta
-ctcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatacctgtctggatgg
-attatatgcaggtaggcgagagtggattgtagcgatgctcggcgggggtattttaaaaat
-ctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgat
-tagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccat
-atcaagttttgcaatagtactccagaccatgaaatggttatccagattaataataactta
-atatactttcactacatactcagcgggtattaaatttcactttatgtcaaaggactctta
-tgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaactt
-gatcagccttgtaaaatatagtagaatatgatgttaaatcatttatattccagggagatt
-gaatagcttacgattagctggtataatttaactcacatgattaagcaaatatctgtagga
-ccgagggaaagaataaaataaagtaccatgagttcggaacgctgcattacatggcgttgg
-gctagcctgatacaagaagatgagtatggagctctcttcatcgggacgtgacaaccctag
-cgtaatcttggcagatcccggagcagatgattatcgtctaacactgtctttaccaatgca
-caacgcatagatttaacctgaactgttctggattcactcctgactacagcctacaactca
-tttctatgcataactcttaaagacagtcgcaatatcagtacctctatacacatcggatca
-gactagatcataagataagtctcctctggatccttgtattctgttaagtacactacaaat
-ttgtttagtgtctgggacaattacgataagggtcgcgactagaccacagggcatatgacc
-tccaccgctcctagcgagtctccaatctgcaagcactcatacgctaggggcatgaatcga
-ctgtcaatgcactgtaagatttacgagggtgagacccatttagatatgcctcgtttaacc
-gttttaggcttgataggatgagtttgtcgatccatcaaattcccgacattcatattgtcc
-aataagtatatctagcttattcggactcgctaaactaaattatggtataaatgccgtcaa
-ccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggccttatggcagcg
-tatacagctggtataacgaccatatacaactatgaacggactagctgtgaactaagcaga
-ttattggatccttgtgtataattttaagtttcgatctatatgctatagtatagaaaatgt
-tccgatcgtacgcttcctttacagttaaacagtctatatcatgaagcttatccaaagctg
-gacatttgatggcaatcttacttaattatgaaacttaattacctattattgaaagtattt
-atatgatcgaataagatttgctctataaacaggtcgtccattcacgacctagtgattgcg
-taaattgaccaacctaggtaatctaaagcctgcatctatttcttatcattcatgttatac
-tgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcaca
-tttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctat
-cccacgcgtcattttcaaattggttatctacggataactgtgcgatgaactactataggt
-caaaattatcttcaatctcattctagatcatataaagatgtccttcgcgattgatacgtc
-tacagtgtgttggtgttacacagagggtagcgactacttacttactaactctctcttgat
-ccgcaagcataagccaggttaaagtgctctatctttttctgtggattataatagttatac
-cgccttgcatctaggtgcccattaggtaatgccctagtgttttcataaatttactcctgc
-catctaacgttactttaatttcccagattcaataggtctctcatttgaaaattgttatat
-gtcaacaaagaatataatagctgagtggaacaatacactgtgagggagtaatacatactc
-taaattttctttacggtttgcgcctgcacagttttttttatctatgtgatccgcataaaa
-agtaatttcaacgttccattcaagttaagtcttggtgacactagcattaggagagatcac
-caagaccattatttatttagctagggtttaagtcggttagaaatatcagataatgaggtc
-tttatccggccttacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaag
-tatggccgaacccacataatgcacaaatcaagtcgatttcttccgtccttttagtctcct
-gggaactacgggttattcatagttaagctaaatcagttaacggaactagacaaatgtata
-atagttcccaaatatatatctataaatcttatgcagttagggaatgcagatttgaatcat
-ggcaatacgctagctcggaactcaactacaagtgttggatgtacgaattcaaaggtatta
-catccttatgatgttcttttttggatacttttatgacgacttccacgaagtgaaattatg
-ttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgttctgtttataat
-tctcgtcataatataaatacaagcatatgaggccagtcatggagctttcatttggactaa
-catttccgtagagtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgtt
-atcagatacatgacgcccttgcgtgacattcatggctcctgacatcgggtcttttaggct
-gaatctaatctaacccaatttgtttggattgtgggtcctccattttgtctgttaatgctt
-attaagattaaaaatgtactacgtatttagacctaatgattgcgatacgctgtggaccat
-taatataagctgcgccaggggatttttccagatcatctggcctgtgtatatgttcaaatc
-taatagccgagagaaattactccgacggaaaataaaggcagataagcgtttcagagcacc
-atcgtggcgtttagtcaacctttagttcggaatttattaatatacaatctcactctttgg
-acgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcat
-catcaaagaacagttaaggaatacgactgctctataattgtccgaggagtaccttctcat
-ctgccaatagtcgttgggttggaaaacaacgcattaatatgccacacttgtcaattagaa
-gtttctataaaggggacgagtaactgatttgagacctagcacggcagaggacgttcgtgt
-gacaacatctctttataagtttgagataaaatcgctaatctacaatgattatttgccaat
-cattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaaggccattactatgg
-tcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaaacactattgaat
-actgccgccgcattcgccagcaccaacataactgcacgtgcttttttccatgattggcat
-tatgaaagatttgatctatgattcttaccagttgcaatattcaatttagcatgtgttcct
-aattattgtgttattatggtctatctcatcatgtaaatgaagatcatgacgtcaacacag
-attctagtcaggatcatcagttcctcggggaaatcgcacctaggaacagccttatgcaac
-cgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgag
-atgtacgaatcgtttactgccttttatgaggagtcgagtactgttggttcatatttgcta
-catgattgtatgtaataacgatcccgccctttatcggttcgatcctttatggcgataagt
-tatgaatcgtcagtatctttagatcaaaaactcaactagtacccagttccccggaggaac
-ggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttc
-atccgatcccactcgatgattggtatagctatttgccgaaaagccacaacgtattcggta
-ctatcttgtttgattcccctgtatcttaattcgcgacacttgatatcttttgtgtttaat
-cgacgaatcatcctgggggcgacacttgttacaattatccagttgcgtttaatggctgtg
-ggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgca
-ggacgaatagctcacccgcctaagtgatccaaccctcatcaggataactatcactgggca
-gtattatttttgatttcatatgccaccccctaggagactgtagtcatgtatctttcttac
-ccaatctagcccgaaacaagaaagaatgtcgattccagtcaccttttattagaccgattt
-acacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacga
-cttgctctattcgattaccttcgcgatctcaatcgattacgctaaattttaatgcccgct
-gaaatatccaacatttaaaacaggattaattctctgatccatgaacttaggactcattgc
-acgtgacttatctttctctcttaattcatgctccaatacggtgggctaaaccacttttat
-cacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtc
-aatctgggtatcttctattgggacggtacatttcggttttatagactatgtagttacacg
-gcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgcc
-atgtgtccggaggattacatacatctaagaaacattctaaactatgtatagtcgtttacg
-acccttgtagtacgtgcatcccttggcgaaaagtactctgggtattagagtgtatattat
-cgacagcaccgaatcctcattttatagcttgacaatttatgacccgaaagaaccttttat
-aagtctataagtatatctaacgcaattgcggcactgagtccactaactatctttgagcag
-tgttatacagtgagacgccatggaaggggtttatatattttactgtcgttccctaaaaag
-ttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgctt
-gtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttacattccttgctta
-tttgcgataaatcgatacaaccccattaccagaaaaacccggagaatcaattactctgca
-gatcttatactaaaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgt
-ggagcgttggggtaagagcggagcgattttaactttcgcttttccattttccagtattgt
-actttacgttatatttgagcggcacattcgtcaaaacatgatccatatggactgaggtgt
-ttaaatgttaatcaaataattgtattttcagctgactttaaaatctgcagccattggagg
-tggagattccaatagatgtaagcaggtgatatcatatgcaattcttgtgacttattaaga
-taccagacacggcacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaatt
-ccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaacgtttctctgaga
-tgtataagttaccaaacactggagaattccgctaaactaaggacaatttccgtcgtatta
-attgttgacaaatggttagtaatacattcgcagtggataatccgttgcatacctagcact
-gagtgtaaataaaaccaatcgactactggcatttcgggctaacgactagatgttagccta
-tgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttcttattcgttatt
-agaagtcacctgtagagacagtagagatgacctaaatttggtttgtccagtcccgaggtg
-atctaatgattaggttaacttagaacagtggtcaattggttaaagctgatttacgaacac
-ttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtattcggtcatctag
-acaaccccatcgctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccga
-attcgaaatcctgttgctccggggagatagggttaatttaggcttttttacggtgtggca
-tattagctcaaacatcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgt
-tctgctaggaagcgatgtacaaaataagcttaataagatttaggtccgaccttaatttcg
-gtccatagcacctctttctaagtgttttgcttaaataattgtattgttattgattttctg
-cgagttgaacacggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaa
-tgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccg
-cactaaacggctttcgctgtttccaaaaaattttagtccactaggtatttaaatgttgga
-cactgaacgtggaagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgta
-ctttgagcagatgctatcgtcagaaaaaggtaaatcttttggttctttataattctggcg
-tccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaa
-ttacgtcattagctgttacgtctatacgaaatatagactgtggacgacccatcgtagagt
-catgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacaca
-gtattgtactggtcaattggttcatagatctgactatgaatcttcgtttttgtacaacaa
-tctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcc
-tgttcgaggttagtcgtataaagacgaaacggccttaatgtaacattaactattccactg
-taggtggatctaacaaggttggacatgtgctaccaataagataagaatttcgtccgcaat
-acaatatctacttttgtagcctatcttggattaacaacaacttacgttggtatttcaccg
-gacgtatcaaatgattctgattttaatgactgagagtaaacatcaacgaatcttatgtat
-ctttaagccgctgcttgacaagtcacattactgttagaatgaacgcttcattactacaaa
-acctaccaccaactcccacattaatattatactagatgtttgaagtttatttgacaaagg
-ttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttagggtattaattgt
-ggtcggtgcatttccggccccatagcgctccgcggggagaaactatggccttcatgacag
-cccccccataacatctaggtaatggtcggataactataaacaaccctctccagagaactg
-tgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaag
-actcttttcactattttcttgatgcctcattcttctaatattaggtgattttttaatccg
-agaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaa
-tgaaatactttttgactatccctcatgatctaaacttacgcggagctatctttttgtata
-acatgtacagagaattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtc
-atggcggcttatcgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacg
-ggtttcgggatttctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgc
-gcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgcct
-tctcaattgtccgaggattgctgataacttaaaataaggttgagtttttaataacgattt
-gtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacg
-ggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggta
-tttgtacaactgctttcctttatcgattgctcgagaacattataaagtctattactatgg
-attaagactgtatacaagtgtttaagcggagcccgtgataatctataaggttttggtacc
-tttatctgttacttttgccttgaaacatacatacgtacacgggaatatttacctaaacgc
-cgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgccc
-acttgcattataacccggtgcggaatctcttagtgactcgtcaggagtttacgcctttga
-gacctctcgacaggacccattttgatctagtcgttataggtagagtgcctttcctatcgc
-accattaccttctagcaaacttagagtattcaatgaaatcatatcctgtttatactaaat
-gttataggctaatgacacagctgacactaagaggtctcttcgggttacccgaatgagttg
-tttatacgatgttgacaactcgggggagtcatttcaatgaagactgaggactcttgatca
-gattaaaacgcttaatgactgataatttagattatgccgtgtattatttaagtgggcgaa
-ccctcccctagaatgggtttcctgagaaaagtcttagaacacagtattctgaatccagat
-gcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcg
-caatccgtttaaccgtctactattcctagagcgaagagctatgttctgacacgtccccaa
-tattaggcaaaggctccaaaagaacagtcaattgattaactacgggcttggtttctccgt
-gaatccttgcgccgctataccacataaaaggatagcggtgataccacaagtttgcgacgt
-taaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaattttgtccatca
-ctactgccaagagttgactggaccagttggaaatgacatttgatatattaatagagctac
-atattgtaccactttactgtcacttacactaaccctagcgtgattactcatacatatatt
-cgtaaattctaagttatgatactagttttgtaaatttaatcggcgaagacacgttctctt
-gtacgagcttcaactaaatatttcactgtagccaaccactttaaccagaaggatacctta
-atgccgatataatattgtccaggaaacgttaatactttcacaagacaaagcttggaagag
-gtactttacgatcacctgatagatcgaccggaacgattctatataggtttggtctgagaa
-atttgtagctaaaaccatgttccataggaactcctctgtaatgggcaaaatgcagatagc
-gttcaatcgttgcttaactatctatcacagcatcctaactcctcaacagcttctttccta
-aagacatcagcaggtaagttgacggcacccgataacccagagcacgattggaatctaata
-ctctgtatggatcattacgctaagtaaatataatgattttctgactcaaagttacactgc
-gaattttatattaactggttctatttgttaaataccacaacctctcgtcaacaggtcgcg
-atgcaagtgatccaaaaatatctaacttataccaaccattacttctggcgcagaaaaaca
-tagatatctgaacaatcgaccgttaagactgtctcgccgatcttaggaacctaatactgc
-tcagtagttattgtttatttgggccatccccggattatgtcagccatggaacactaaaag
-tcctaatctaacctatggacaaaaagctcacttttataaaattgctcaccttatgttgat
-tgttatttgtccgaaatgtctataactcagtgtactatctattggaaaattatggccgga
-gttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaataattatcagctg
-gaaaatcatctaatatatattatattgagatattacgacagacctaagtgctttcccgtc
-atgagcagatggactaacactcttggtaatccttctcgttttagttggtaatgtttagtc
-taagtaatatcccgactcttacttactcagagcggaaatgactttttaaactaacgttta
-aaggcacttagtatgcgtcagggttatttttttaattacgtacccttgtgcagagagttt
-agctattcgatcctacttagtatgaaccatgagagtacaggttggtaattcacagagaag
-gtcgagaagattatttttgatgtttaccaatactatgaggcgtattcatcgaaataattt
-tatggctgcgcacttcacatacgcaggaagaccactgcagcttgctagatctggatgtat
-cattgtacttctaagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatg
-gggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcat
-aagttctgtcaactataaccctggaactttaatctgttgttcgtcgaatcaaggatcaag
-aaagcttctaaaaggcccaaagcaaaacccaccactacttcagttttaaattagaatcac
-accctagggtattagataataattaaatgtcttaggaagagatatcaaaagatgcagaca
-tcctcaagtgaataagtctccggtctttcacaaacacatggttaagcgatgtggttttga
-ctagagacgttcgccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatctt
-acttcatacattgcttaaacagtacaacttatctcttatcctatagagatctcaaaagtt
-tgtatttttactggtttcaaattgagagaaaaactgcgttctccgatttctatattattg
-tttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccgactcagattcgta
-tcctatgttagaatgagtcatcaaactacggtcacgcgtacattacagagtaaactacac
-gaatgaaagagataagaagatgaaagagttaataggtctcctgttaattatgagaaccct
-aactactacggattggcctactagtgggttggaacggatataaaattcgactaagttcgc
-ggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatccacagtaatagtt
-ggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccat
-gcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgagcaaggaattgga
-ttctgtgaacggaatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagt
-aaatcaaacgccgcgcgcagacatatcttcttggcaattagtactccactaaatcaattg
-gttataaacttttagaatatctttatataagttcactacttacgctgcgggtagtatatt
-taaagtgatgtcttaggaatcttatggcggcggaataaacggcttgactatagataccct
-aattctggcataaccctgtaacgtgtgaagcatgctttaatagacgactagatcagctta
-tagaatggatatgactgccacattgaagagattaacattagcgggtataatgttacgaac
-ttgtttaacaaaatagctctaccacacacgcatagtataatataaaggtcctggagttcg
-ctacgagcctggaattgcagttcccctaccctgagtaaacaagatcagtatggacctatc
-ttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcg
-gctaacactcgctttaccaaggaacaaacaattgatggaacaggtaagcggctggattct
-atcctgaatacagcataataatatttgctttcaatatatagttatgacactcccaatatc
-actaactctttacaaatcggatatgaagagtgaattagagatggagccgatcgttccttg
-tattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcga
-gtctagaactcacgcattatgaaatcctccgagcatagagactctaaattcgccaagcaa
-taagtcccgacgcgaaggatgagaagctcattgaactgtaacatttacgtcgggctcacc
-atgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacata
-aaaggccccactttcatatggtcaaatatctatatcgtgctttggacgactcgataaact
-aaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatat
-ataacttccggacgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaa
-cggtatagctcggaactatgcagattaggcgatccttgggttgaatttttagtttccata
-gatatgagttagttttgatatggttaccatacgtccctgcattgaaacttaatctgtata
-ttgattgatccttagcaatagcggcacatttctgggcaatatgacttaattaggttacgg
-tttttactatgatggatacgttttatatgatagaataacagttgctatttaaacaggtac
-tacattcaactaatactgtttcactattgtgtccaacatagggaatatattgcctgaata
-gatgtattatcaggcatcttttacgctccaggtagaactaattaaaaatgatccttagaa
-actttcaagcaacataagctaaaagttacgccaattataagccacatcggtaggatcttc
-aggcattcccatatccttctctatcaatcccgtctgttgctaattggttatctaagcata
-tcgcggcgagcatctacgataggtataaagttgctgctatctaattcgtcataatatata
-catggaattacagattcatacgtcttcagtctcgtggtgtttctaagagcggacccaaga
-attacgtaatatctctctcgtgttacccaagaagttgacacgtgattgtcagctatcttt
-ttctggcgatgttaatagttataaacaattgcatatagctgcaaattagctaatcaaata
-ctcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagg
-gcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataa
-tatctcagggtgtaattatttctctaattggtctttacggttggaccaggcaatgggttt
-tttatctatgtgataccaattaaaagtaatttcaaagtgacattaaacttaagtattgct
-gtcaagaccattacgacacttcaccaacacatttatgtattgtgctacgcggtatggccc
-gtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaaatgccaaattta
-gtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgt
-tgtattacgtccttttactagcctgggaaataccggtgattcagagtgaacataaatctc
-tgaaagctactagacaaagctagtatagttaaaatatatatttcttttaatattaggatc
-tttgcgattgcacatttcaagcatcgcattaacctacctccgtactcttctacaacggtt
-gcatgtacgatttctatgcgatgaaatacttatgttcttagtttggggttactttgttca
-cctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaac
-gatctcgattcttaggtttataattatagtcagaagataaatacatgcatatctggacac
-tcttccacatgtcatgtcgactaactttgaactacagtcatatatagactgttatctgat
-ccgtatgtgtctattactactcttatctgagaaaggacccaatggagtcacagtaagcga
-tcatgtcatcggggctttttccctgattataagattacactattgctgtgcttggggcct
-cctactttttctatcttaatcattttgtacattaaaaagctaagaagtaggtacaactta
-tctttcccatacgagctggaccattaatttaacagccgcaaggcgagttttaatgttaat
-ctggaagggctttatgttctaagcttttagcactgagaaattaatccgtaggaaattaat
-cccacataacccggtaagagaaccttacgccccgttactaataatgttctgcgcaatgta
-ggaagtgacaagctcactcttgcgacgagctccttaatacaggccctgcgttatattcga
-ccgtacctataactagaccaccatcttaaatgtacagttatggttttcgacgcatagagt
-atgggaccacctcgaaatgctcagctgcaaattgtactgggggtggttatcaaacattta
-atatgaatctatggtaaagtactagtttatagatagccgaacactaaaggtttgcagacc
-ttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcg
-tatctacaatgatttggtgcaaatatttatcgattgcccaatcgttctactcgtactctt
-tatagcctaacgccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaa
-ttacttaaccatactcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaa
-cgggcgtttttacttgagtcccaggaggtaacattggatctatgagtcttaacagtggaa
-atatgatttttagattgtgttcagatttattgtcttattttggtctatctcatcagctat
-agctacataatgacgtcttaactgtttcgactaaccttcagatctgactaccccaaatac
-aacatagcaaaagaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagc
-tccatttaaaagaatcgaaaacagatctaccattcgtggaatcaatttttggacgagtac
-tggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttcaagcactttagcg
-gttccatccttgatggcgttaactgatgatgcgtaagtttatggtgatctaaaactctac
-tacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttaggtctccaggcact
-aggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcctatagctttttgc
-agttaagccactaagtaggcggttctatagggtttcattcaaatcgatcgtaattcccga
-ctctgcatagcgtgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagt
-ttcaacttccgtttattggctgtccctcaatagagtcgttctcagggcacgactctcgtt
-cgttattcataagtccagtttgatccacgaatacagaacacgcatatctgataataaaag
-cttaacgataactttcacgcgcatggtttatttttgatttattaggcaaccaaataccag
-aatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaagtatcgccattac
-agtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgat
-ttaataataattacggctaaacgtattgatattttccaggaactgccccatctcatgaga
-tgaccctaaattttattcacacctcatttttaattcttttatatcacgattatttatctg
-agcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaata
-tacggtgcgctaaacatattggttcaattcaatgtaagctacctcggaatttgcttgcac
-taagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccg
-ttggagtcactatggagttacaagcattataaatctaaggaaatcgcagtatcagtcctt
-accccaaagatacttcgcattccctggggtacggaccatgaaatacttctttcatacatg
-ataaacgatggagactcggttaccaccctggtagttactccatcaattggagttaactaa
-gatcgctattacaggctttattagccaatcatcacaagcctctttttagagattcacaag
-ttagcaaaccaaagttcctttgataagtctttaacgagatctatcccaattccggctagg
-agtaaaatttatatatttgagatcggggttaaagtcacacgcaatgcaaggggtttttat
-atggtaatgtccttccctaattaggtaattttcagacctccgagagagagtagatcaaca
-acgcgttatactcctaaaatgcttgtcgataacatgacactacagatcatccctggatga
-gcatcgactttcattacttgattagttcagttaattcgtttcaaaccattttcaacaaaa
-tcccccagtagatatgtatatgcacatcttagactaaataacagttttcataccctggga
-tttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactgg
-ccctgttccattgtaatcgatgggacgggacgttatattgcagacccaaagtagtaataa
-attcagccatatggacggagggggggaattgttaagaatataattcgattttcagctgaa
-tgtaaaagctccagccattcctcctccacttgacattagttcgaagaaggtctgagaatt
-ggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagtaccaagtataat
-attatgacaatagaagcttaaattcacaacgtaacatatctgttagcatgctctaataga
-ccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaat
-ctaacgtctagttcccgactatgaagtcttcacaaatggttagtaataatttcccagtgg
-agtagaagtggcataacgtgcactctctgttaataatacctttagactactcccatttcg
-ccagaacgtcttgatggtaccctatgggaaacactcacacatgcttattgcctgcaacct
-cagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggactgatgacctaat
-tttggtttctcaagtccagacgtgatattttgatgaccgtatctgacatctctgggcaat
-tcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatc
-actatcatgttttagctaagctacactaccccatcgctcgcacgtggcaaagtgtgagga
-ttccgatatcatccatgtgtacgaattcctaatactcttgctcagggcacttagggttat
-tgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtcttataatcaccgt
-aatcggtaaacagttgttatttgttctgataggtagacagctaataaagatgctgttgaa
-cagttacgtcccacctttattgccctacagtgaaactagttcttactctgttgctgtaat
-atgtctagggttattgatttgctgccacttcaaaacggaaattaagtcattaacgaaaat
-ggttccttcataggtaaagatcaatccccaattgaagccagaaattttgagatgtcgatt
-cctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgag
-tccactagcttgtttattctggctcaaggtacgtggaacacgtagtattttgatactaat
-gccagacccgctacgatccctgtactgtgagcagagccgatcctcagaaatagctaaatc
-ttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtct
-atttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatac
-tctgggcaacacacatacttctctcatgttgtttcttcggacctttcataacctttcctg
-gcacatggttagctgcacatcacaggattgtaagggtctagtggttcagtgagcggaata
-tcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatat
-tatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatg
-tatggatcttgatctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaa
-taagataagaatttactaacatttaaattttcttattgtcgagcatagattggaggaaaa
-acttatttacttggtatttaaacggaagtttctaatgtttatgattggatgcacggacag
-tttactgcttactttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgtt
-catgcttccattaagttcttcttaaacttacacaaactacctaatttagagttgacgaga
-tggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtaca
-tttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacattcacatcccaccc
-ctgaatatatggactgaatcacacacaccaaatttcatctaccttatcgtagcataacta
-ttaacaaacatatacagacttcgcggtaaataaaatatattagtacacaaccgtatactg
-gttgaactattgcccagctttaagacgcttttaactaggtgcttgatcaagaagtattat
-tatatgacggcagtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacg
-ccgtagagacatttttgttagatatgtatttctttttgacgagccagcatcttagtatct
-gaagacgagctatatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagat
-taaccaaattccccagaattagtaatggcgccttatcgatttactaacgatatataactt
-gtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattg
-aagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgat
-actacgttttgctatgtaatccattctaatgggtaagaggattcctcttatagtaaaata
-tgcttgactttttaagaaccattgggagtggttggcaaaataatagtgggtgtctttctc
-agtgtatagttttctacaactacccctattaggttacaagtaatctggctttcttgccac
-ttggcgatgatagttagattcgtatttctacaacgcagttactgtatccatggcgcgaga
-taattagatacgatttgaatttggatgtagactcgttactactgttgtagaccagcacgt
-gagtatctagatgggtttgctaccttgttagcggacttttgccgggaaaaagacatacgt
-acaaccgtatattttactataagcagtattggccaccctcgtattgcggcagggtgtgct
-cacctggttaaaatgaaagagaaaaattccattttaaaacccggaggaatctattactga
-cgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttcatattctagtta
-ttccgagagtcactttcctatccaaacatgaactgatagcataatgacaggttgaatgga
-aagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgtcacgaactcgga
-gcttacccttacaactatgtgttctgtttaccaggtgctaatatcccggcactcttttca
-tgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcatattttacagtagc
-cagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctgacataagtatta
-catatcacttgtctgattacacagcaaaatcgctaaccttactttgcgcatgtagctatt
-ggaactttgggctagtgtctatcccattaagtttaacagtagactagtccgtgagcgatc
-accgagcttatgtctcgtacccaagttttggatttggatcaaaaactactcgatattcat
-gatctacgggcttcctttctccgggtatcattgcgccgagattaaaaataaaacgatagc
-gctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacgaatagaccatcca
-atttgaattttattgggtccagcacttcgccatagtgttgaatggtaaagttcgaaagga
-aatttgttatattaattctgctacattttcgaccacttgtatctcaaggacaatatccct
-tgaggcttttagcagaaagagatgccgtaattctaagggatgataataggttgggaaatt
-taagagcagtagtaacggtcgcgggttcgaccttaaactatatatttaaatctagccaaa
-caagttaacaacaaccataaagttatgaccttattatattggcaagcttaacgttttaat
-tgctctagtaatagagtggtagaggtaagggaccatcacctgattcttcctccgcaacca
-ttatatagacgtgtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaata
-tcgaatggcaattagccacattgagttaaatagttgaggatatttcttgcacagaatcag
-atctaatctaatgattcgttactaaacacttcaccaggtatcgtgaaggctcaagattac
-ccagagaacctttgcaatataagaatatgtatgcagcattaccctaagtaattatattct
-ttttctgactcaaagtgacaagccctagtgtatattaaatcggtatatttgggaaattcc
-tcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccata
-catgaattctggccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgcc
-aagatattaggatcctattactcatatcgtgtttttctttattgccgccatccccggagt
-atctcacccatccttctcttaaaggcctaatattacctatgcaaataaacatatattgtt
-gaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgact
-atatagtgctttagtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtt
-tcttgtcctaatatttttcagatcgaatagcttctatttttgtgtttattgacatatgtc
-gaaactccttactcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtct
-cgttttacggcggaatcttgagtctaacttatatcccgtcgcttactttctaacacccct
-tatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgttattttttgaag
-taagttacattgggcagactcttgacattttcgatacgactttctttcatccatcacagg
-actcgttcgtattgatatcagaagctcgtgatgattagttgtcttctttaccaatacttt
-gaggcctattctgcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcg
-caacatgccttcatatccatcgttcattgtaattcttacacaatgaatcctaagtaatta
-catccctgcgtaaaagatggtaggggcactgaggatatattaccaagcatttagttatga
-gtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcgtaatgttatctc
-gggttccgcgaataaacgagatagattcattatatatggccctaagcaaaaacctcctcg
-tattctgttggtaattagaatcacacaatacgggttgagatattaattatttgtagtacg
-aagagatataaaaagatgaacaattactcaagtcaagatgtatacgggatttataataaa
-aatcgggtagagatctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgtt
-acatcagaaagggtaactattattaattaataaagggcttaatcactacatattagatct
-tatccgatagtcttatctattcgttgtatttttaagcggttctaattcagtcattatatc
-agtgctccgagttctttattattgttttaaggatgacaaaatgcctcttgttataacgct
-gggagaagcagactaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcg
-acgaatggacagactttactaaaccaatgaaagacagaagtagagcaaagtctgaagtgg
-tatcagcttaattatgacaacccttaatacttccctttcgccgaatactggcgtggaaag
-gttttaaaagtcgaagtagttagaggcatctctcgctcataaataggtagactactcgca
-atccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaacc
-gtccccactcgcctggggagacatgagaccacccccgtggggattattagtccgcagtaa
-tcgactcttgacaatccttttcgattatgtcatagcaatttacgacagttcagcgaagtg
-actactcggcgaaatggtattactaaagcattcgaacccacatgaatgtgattcttggca
-atttctaatccactaaagcttttccgttgaatctggttgtagatatttatataagttcac
-taattaagatcacggtagtatattgatagtgatgtctttgcaagaggttggccgaggaat
-ttacggattctctattgatacaatttgtctggcttataactcttaaggctgaaccaggcg
-tttttagacgacttgatcagctgttagaatggtttggactccctctttcatgtcagtaac
-atttcagccgttattgttacgatatgcttgaacaatattgatctaccacacacccatagt
-atattttataggtcatgctgttacctacgagcatggtattccacttcccattcaatgagt
-attcaacatcactagcctcagagatgatgacccacctctaataacgtcacgttgcggcca
-tgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcatataacatttgag
-ggtaaagctaagcggatgctttatataatcaatactcaataataagatttgattgcattt
-tagagttatgacacgacatagttcactaacgagttactattcccagatctagactgaagt
-actgatcgagacgatccttacgtcgatgatcgttagttatcgacttaggtcgggtctcta
-gcggtattggtacttaaccggacactatactaataacccatgatcaaagcataacagaat
-acagacgataatttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaa
-gctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaactggttcccggg
-agtcctggagtttcgacttacataaatggaaacaatgtattttgctaatttatctatagc
-gtcatttggaccaatacagaatattatgttgcctagtaatccactataacccgcaagtgc
-tgatagaaaatttttagacgatttataaatgccccaagtatccctcccgtgaatcctccg
-ttatactaattagtattcgttcatacgtataccgcgcatatatgaacatttggcgataag
-gcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggttaacagacgtac
-atgaagggaaactttatatctatagtgatgcttccgtagaaataccgccactggtctgcc
-aatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtat
-aacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcactattggctacaa
-aatagggaagagtttcaatcatgagagggagtatatggatgctttgtagctaaaggtaga
-acgtatgtatatgctgccgttcattcttgaaagatacataagcgataagttacgacaatt
-ataagcaacatccctaccttcgtaacgatttcactgttactgcgcttgaaatacactatg
-gggctattggcggagagaagcagatcgcgccgagcatatacgagacctataatgttgatg
-atagagaaggcgtctgaattgatacatcgaagtacactttctttcgtagtatctctcgtc
-ctctttctatctccggacacaagaattaagttatatatatagagtcttaccaatcatgtt
-gaatcctgattctcagagttctttggcgggccttgtgatgactgagaaacaatgcaatat
-tgctccaaatttcctaagcaaattctcggttatgttatgttatcagcaaagcgttacgtt
-atgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtgggaataattctt
-ttgaagacagcactccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgt
-aaccttgcacaagcaaatcggtggtgtatatatcggataacaattaatacgatgttcata
-gtgacagtatactgatcgagtcctctaaagtcaattacctcacttaacaatctcattgat
-gttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaag
-gaacatctactaatgcctttgttaggtaagatctctctgaattccttcgtgccaacttaa
-aacattatcaaaatttcttctacttggattaactacttttacgagcatggcaaattcccc
-tgtggaagacggttcattattatcggaaaccttatagaaattgcgtgttgactgaaatta
-gatttttattgtaagagttgcatctttgcgattcctctggtctagcttccaatgaacagt
-cctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggtt
-cggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagc
-aaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtag
-ttaaataaatccatatctgcaatcgattccacaggtattgtccactatctttgaactact
-ctaagagatacaagcttagctgagaccgaggtgtatatgactacgctgatatctgtaagg
-taccaatgcaggcaaagtatgcgagaagctaataccggctgtttccagctttataagatt
-aaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagttggttcattaat
-tagctaagtacgaggtacaacttatctgtcccagaacagctccacaagtttttttacagc
-cgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattagagtttacaactca
-gtattttatcagtacgttttgtttccaacattacccggtatgacaaaatgacgccacgtg
-tcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcctacacatactga
-attcaggcaatgcgttttattcgaaaggtcatataactagaaaacatgatgaattcttat
-cggatccttttactagcatagtgttggcgaacacctcgtaatgctcagcggcaaattgga
-ctgcgggtccttatcatacattttttttcaatataggcgattggtctaggttagtgattc
-cccaacacttaaggtttgctgacattcataccctcagcaacttcctctcaaaaattagag
-tgagttggtggtcttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgc
-acaaatcgttataatcgtactctgtagacaataacccattgtagtgccgattttgtgcat
-aatacaagaaggaggatataaaaatgacttttcaataatattggctattagcaacaagaa
-ggagaatcctcattaagttagcaaccgcagggggtactgcagtccaaggaggtttcattg
-gagagagcagtatgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctg
-attttcctagatagaataagctatagctacttaatcaactcttaactgtggagactatcc
-tgatgatctgaataccccatttacaaaattccatatcaatgaggctaacgcttaaatttc
-atttctccatcgtaacaaaaatcagcctttttatacaagacaaaacactgcttccattac
-gggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgc
-gtttatacttaaacaaattttgacctgacataatggagcgacttatcggatgttgccgat
-ctttagggtcatctattaagcttatacgaaaaagggacaagcacgttacgtaatctggta
-ggactgggtacctagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaa
-tacaggagtccttttcatttttcaagttaacaatataagtaggagcttagagaggcttgc
-atgaaaatcgttaggaattacagaataggcagagagtggggcgtgtagactacattcttc
-aggccccacaatatgggttataggttaaactgcactttttgcgatctcccgaaatactgt
-cgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcatccaactattcag
-ataaacaagatcgcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggc
-atgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaa
-cataattcattctttcgactggacacgctaaggtttggacaaactttgtatctatatctg
-gaggcctgtattccagcccttcttttaataagatttacggcttaaactatggatatttgc
-caggaaatgacactgctattgacaggaacataattttgattcaaacctcattgttaatta
-ttttatatctcctgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtga
-gggctcgaggaatgaatcataatagaccggcccctattaatattggttcaattctttctt
-acataacgcggaatttgattgcacgaacaccgggaacacataaccgtatagcgcccgtta
-tgctagtgcctagcgactgggaccgtggagtctatatcgtctttctaccattattaatct
-aaggatataccactttaagtcctttcaactaacataaggcgcattccatgcgctaaggac
-cttgaatttattatttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgt
-actcaataaagtgcagtttactaagagccctttttctggcttgtggagactatcataaca
-tgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacg
-agatctttccaattgccccatagcaggaatagttatatattgcagatcgcggtgtaacgc
-actccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatca
-aagcacagtgagagttgagcaaattacagttatacgacttaattcagtctccataaattg
-aaacgacacttcttaacgggaggaccagacacgttcattaagtgaggagtgcactttttg
-actttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagt
-tatttctgttttaatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccc
-tatcacacctcagagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtag
-ttggcacacccaatggacgaataaatgctgccatatccacggagggcgggattgcggttg
-attttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaat
-tactgcgtacatccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaacc
-aaattgacaacttcatagtataatttttgcacattacaagcgttaattaacaaacttact
-ttgctgttagctgcctatatttgtccgacaatataactggatatctctgcgagaactgta
-aattaacggcacttggaacataatagttcctattggtaacgacgttgtaggcggcaatta
-tccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagta
-taactttagaagactccaaggtacccagaacctcttcagcggacacgatcgctatcaatc
-aataaggattattcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagc
-ttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctgttattttcatga
-ccggataggacatctcgcggaaattcgggtaacagctgggtagatataggacctccccta
-cgtattaatgataagcctgtcataactagcttggtttaccgaagagacaataaacattcg
-agcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaacatgtactattact
-ctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgatgttgacagaatt
-atgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtctgagcattcgtac
-actgcgtattaagatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaac
-taggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaa
-ccaaattaaggctttatccaatatgggtccttaagtgctaaacatcattcacaatttcaa
-gacagattgttggtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccag
-gtacatcggtaattatatgttgactaaactaccgtgtgtattctggctctaggtacggcg
-aacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcag
-cagatcctaagtaattccgttttattgtcctgagggagtaggatcgacgaactctacaag
-tcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtc
-atctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcgatggttctttat
-gcggacctgtcatatcattgactggcacttgcttacatccaaataacacgtttgttagcg
-gatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctaca
-tgataaatgaataagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgt
-cgacgagttactactaaaggaatgtagggttctggatctatgaaaagcgacctccatata
-tatacgggcctaagcggagtaaaataagtgatcaatggactaacattgaaatgttagtat
-tgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatg
-gtttagcatgggatgcaagcactcgttaatgcttactttagttggttgcgggaacaacag
-gaggctatactaactggtagcgttcttgcttccattatgttattattataattaaaaata
-agacatatggtagagttgtagtcagggtggatcgggttgtctataacgttggaataatca
-aaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgt
-gcaccacacattcacagcacacccctcattataggcaaggaagcaaacaaaaaaaagtta
-atcgaccgtatccgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaag
-ataggactaaaattcactagtatcctggaacgaggcaacagagttatctagatggtaacg
-aggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacctctattgatata
-caagtgactttctcggtaataacgcacttcacaatgtgttgtttcttttctatgtatttt
-gcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcac
-atggtataactgcaggaggaacattatccaaattcaccacaattactaatccaccctttt
-acttttactaaagatatattaattctcatgttgtctgaattgtataacccggtaccctgg
-gagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaacacacgacttcctt
-ccgtctattcagacactcaacgagactaacttttcctaggtaatcaatgatattgggtaa
-ctcgtggcatcttatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgc
-taattaagactggctctcttgcgcaggggatacgtttattctacgtacccgatttggtta
-ctactaagcggcctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagc
-agggaagggttacagggagagacttattgagatacgattggaatttccatgtacaatcgt
-taatacgcttgtagaccagcaactcagtatagagatccgtttcctaaagggtgagcggta
-ggggcaaggcaataagaaattactaaaaccctagttgttaatataagaacgattcgaaac
-aataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaataggcattgtta
-aaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaa
-cctaaaaggggcttattctactttttccgacactcaatggacgagacaaacatgaacgga
-tagctttaggtctcgttgaatgcaaagaatagaatcgttattattaatcggtttccatta
-tctatatgcggtatagatctccgagaggaccctgtaaactagctctgcggtttaactggt
-gctaatagaccgccactatgttattgcttctagctcctagcgtcttatcatgttatacat
-taatgtcgcatattggacagtagccaggcttggatggatcgccgacaaaaagaaaagact
-ttccctgtaaggacttaactattacatataacttggatcattaatctgcaaattagagta
-acggtctttcaccagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaa
-aactagaattggcagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttg
-cataaatatcttatcgatattcaggttattaccgattccttgctaacgctagaagtcaca
-ccagagtaataataattccagacacctgtgaaataatcggtcactacggatagactagta
-acgataatacgtatagtccataaaagttgaattttaggggctaaagatattagcaatact
-ggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaa
-ttgtatcgataggaatagttacagtcacgcttgtagatgtaagagatgacgttattctta
-gggttcttaagtcggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaa
-acgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattt
-tagtggcaaccttaacggttgaattgatctactaatacaggcctacaccgaagggtacag
-ataatgattcttactaccctaacatgatagagtcctgtcctatctcataggtcgacattt
-taaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattcacttatagacttc
-aggttatttcgtgctaacattaagatagaatataatcagtcgttaagaaactattatcca
-gctttcgtcaaccataaagattaaaaactgaaacttggcaagatatgaatagctatcctg
-ctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagt
-aaagcgggagagtgcggtaattaatattaatatactattaagctacacagcaaaggctgc
-aataatgttagtaagtagaacataaaggtattctccacaagtaataaatagtgtgagcta
-attgactaacttaactctcgcgacaagtgatgtggataagatgactcatatcgtcttttt
-ctgtagtgccgacatcccacctggatcgaacaattccttctagttatcgactttgattac
-ctatcctattaaacagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctac
-catagctagagttagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatg
-agtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatccattagattaga
-tgtttgtgttttgggtctgatgtcctaactactttctcagtgaaactaatgtcatcatcc
-aagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtctataacgtatataa
-agtcgctgaatttagaacacaccttatctatgttgtaaagttactttattccaaaggacg
-tgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagata
-agaatttctttcatacttcactggaatccggcgtatggatatctctaccgcgtcatctgg
-tggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacat
-cgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtgaagtctaattat
-ttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggat
-agaggacattgcatgtacgtaggactattctccaaggggtcttctattttgttagcgaaa
-attgttacagcctaatgttagagcggcgtacgactttataccagatactttcattagata
-tgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgtt
-gtgatatgatgtttttctagttcgttctcatatatatagatcaacaatgaataatctcat
-gatctataaccgatgtatatttatattccggttgactgctccggtgcaattcactacgga
-cactaatgactaatatggcgcctttcatcagaaacgctaaatatgattaatgaattaagg
-gagtattatctaattattagagagtagcagttagtctgatattttcggtgtatgtgttag
-ccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttca
-ctttatgactctggttatatccctcggagaacaagaataagagtacgagaagttcggtca
-ttgaggatgaaatagaaccgctagacgaatggactcacgtttataaaactatgtatcaca
-gtactacagctaactctgaagtccgagaagcttttgtaggacaaaacgttataagtacct
-ttcgcagaatacggccgtgcatacctgttataaggcgtagtagggacaccatgctatccc
-tcatatagagctacactaataccattacatggtgactatcgtttacggccatcatctgta
-agcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaacccc
-gtgcggattttgagtcagaactattcgaagcttctcaatccttttccattatggcatagc
-aagtgacgactcgtcagccatgggaataatagcactaatccgattacttatgaattagaa
-cccacatgaatgtgattctgcgaattgtctaagaatctaatgattttccggtgaatatgg
-ttgttgttatttattgaacttatattattaacatcacccttcgttagtgatagtcagcta
-tttccaagaggttccccgagcatttttaccattctctagtcatacaagttggagcgcttt
-taaatctttaggctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtg
-caatccctcttgcatgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaat
-attcatagtaataactacaatacttgatttgttacgtaatgctcgtacataacacaatcg
-tattccacggaacagtaaagctctattattctgatcgagcctaagagaggatcacactac
-gctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgaccagttatagaca
-gtgtaattccatattacatgtcaggcttaagctaacccgagcctttatataagctataat
-caagaattagattggagtgcattttagacttatctatcgaaatagtgatagtaagagttt
-atatgacctgatctagactgatgttctcttccacaacagccttaaggcgtggagcctttc
-ttatactattaggtcgcgtcgagagccctattcgtaatgttaacgacactagactaatat
-acaatgagctaagaataacacaagtcacaagataatttacaaatcatatatctacagtcc
-acaaccatcactagcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgc
-aagacgcgttaactggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatat
-ggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagac
-tatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattgataaatgcccca
-acgttccatcacgtctataagccgtgttactaatgtgtattagtgcatacctattcagac
-catagttcaactgttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttc
-ttgtcttttccttaactgacctaaatgaaggcaatcggtttatctagagtcatgcttaag
-gtgaatttcagccaatgggctcccattgagctagtatggtgctttacctttgtaagtggt
-ggctttccttggtgtgctgactttaacacggcagagtgattatccgaagaatggataata
-agacgctggcaatattggctaataaagtccgatgagtttcaatcatgactgcgaggagat
-ccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcattcttgatacata
-aagatccgatatcggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatg
-tgaatgagagtgaaatacacgatggggatattgccggtgagtacaagttagaccacacat
-tagaactgacctatattcgtcatcatagagatggagtatgaattgattctgcgaagtaca
-ctggctttacgagtatctagacgccgcggtatatctcccgtcaatactatgaaggtatat
-atatagaggctgaaaattcatgttcaatcctctttctaagagtgagtgggagccccttct
-gttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtt
-tgcttagaacaaaagagttaccttagggtaggtaaatctcgattcaccgagagaagtgat
-tttggcggtgtgcgattaattcttttgatgacagatctcattattttatatagctccctc
-tttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgc
-tgaacattttatacgatgtgattactcaaaggataaggttcgaggcctctatactcatgg
-aactatcttataattataatggatcgtggctcattccacctatccaaacttctttgtgat
-ctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagct
-cgcatttcattcctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaa
-ggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttatagcaaacattatt
-caatttcagtcttgactgaaattagtttgttagtgttagaggtccatatgtcacatgcat
-atggtctagatgccattgtacagtaataccttagattagtattagcggcatgcgtacttg
-gatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgcaaataggaatact
-tacaatttttgatgacttgttagcatatcgctatcacccataaaaaacctgatacttgat
-gagcgggtgattgagactatgtactgatataattcaatagctccaatagatgaaacagct
-atgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgag
-tggaattagcggtgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacc
-cgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacgaagaatgggtag
-agagtttgaaggtgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaa
-cacctcctaatggttgtgttaaccacaaacccctgggtgaatctgattagccaacccagt
-gatctgatttcagttgtcaaatctcttttttataactaccttttgtttccataatttaac
-cggatctcataatgaacaaacgggtagaataatggtagcacatagcgagcttgtctattc
-agaaatatggcctactcagaatgtattctccaaatcagtgttatgcgaaacgtaatttta
-cgtgtaataatgatgatttcttatcggttccttgtactacaatactcttgcccaacaaat
-actaagcataacagcaaaattcgaatccccctccttttaataaatggtttttcaatatag
-ccgattcgtattcgttagtctttcaccaactattaacctggcatctaattaataaaatca
-ccaaaggactctataatatgacagtcacttcggcctcttttaagacagttgattattgca
-ggtccgcaattgatggtgacatgcacaattagttagaatccgactatggagacaattaac
-aattgtagtgcccatttggtccagttgacttcaaccacgagttataaaggtattttaatt
-tatagtcgatagtaccaacaacaagcacaatcataattatgttagaaaacccagggggta
-atgctctaaatccagctttaaggccagagtgcactatgaaatcgccattgatcattgtgt
-cattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagc
-aacgattatatctggactagatcatgatgatcggaataaaacattgaaataagtccttat
-caaggagcataaacattttatttaatttatacttcgtaaataaattcagaattttttttc
-aagacattaatctgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacg
-catgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggc
-tgccacttttagcttcttgacgatctttagcgtcatatttttagattagtcgaaaaacgg
-aaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaagagcaggacaact
-ccttgatcgggaagaactgaaatagacagctgtcattttcattggtcaacttatcaatat
-aacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcag
-gcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacg
-ggttgccagctacagatatactctaggtatatcccaaacaagagacgtcctttggctgtt
-gtaatcggtcataatacttgtcacataaacaagatcgctgaattaaacattaaacagtta
-gtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatca
-cagagcgacgtaaatttagacaaacattattatttcttgacaatggaatcgataagcgtt
-cctctaacttggtatatatatctcgaccccgggattccagccattcttgtatgaagattt
-aaccatttaactatgcatagttgaatggtaaggaaaatgatattgactgcaacagatttt
-ggatgcaaaaatatttgtgaattattggttatatactggttgtatagcacaatcattagg
-tcctagaaggcatactcaacctcagcgagagagctagcatgcataattgtaccgcccata
-ttaatattcctgaaatgatttcttacattacgcccaatttcagtcatcgaacacccccat
-caatttacccgatagagaacgtgatcatacgcaataccctatgcgaacgtccactctata
-gcgtctgtatacaatgattattcgttccatttacaacgttaagtaatttaaacttacata
-aggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgt
-ctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgta
-tccattgtggagaatatcataaattcaagatggggtgtcatgctattcggtcctaaacat
-tcttaatggctgttctattgttagtctgatttaaaatggaaccatagcacgaatagttag
-atagggctcatacccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgac
-ggaaagttttacggtttgtgatcaaagaacactcacacgtcagattattacactgatacg
-aattatttcagtcgacagtaattgaatagaaacttattaacgccagcacctgacacggta
-agtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttga
-tttctatatcaaatgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatt
-tagatcgttacgactcacgtacaagatcacacatcacacgcgttagcgaaagcggaatgg
-ctaatacagccctacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgag
-ccaacctcccccgcattgcggttcattttaaggcctgggtaacatctatcgtttagataa
-tcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcg
-ctacgtgtttctttaatcaataccatattgaaatcgtaatacgataattgttgctattga
-ctacaggttatgaaaaaacttactttgcgggtacatgcatatttttgtaccacattatta
-cgcgatatctctcagtgtactctaaattaaaccctcttcgaacattttagttcctattcg
-taaacacgtgctacgcggcaatttgccggtcgtagaatggacaactccagttcaactgca
-tgtaactcatagctcgcgttagtataaattgactagtagccatgggacaaagtaactagt
-cagcggaaaagatccctttaaagatatatgcaggttgcaagcataaagctcattgctcga
-ggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaa
-tcgaaactactctgatttgctgcacacgttaggtaatatcgcccattttcccgtataagc
-tccgtacttatacgaactacacgaccttttaagcattagccgctcatatcgtgattcgtg
-tacagatgagtctattaaaattacagacatactccatatctcgctccttgaactttgaat
-aatgcgctaacttgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggg
-gaaacgatacatgttgtcagatttatgattatctagttttagatcacgtttaccgataat
-cggctgtggtctgagcagtcctacactgagtatttacttcagcttcatatcggtccgaaa
-aaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcgg
-ttgcagggcagcaaaaggcttaaaccatttttacgatttttactatagcggtcatgaagt
-gcgaaactgcttgcaaattttctacacacattgtggctcttgtccttgaagcttatggcg
-aaaatttgaaacatagtataccagggaaagcgcgaattatttggtgactaatagtccgtg
-ggtttgagccatatacctaacgccataaactacgtggtgctttagatgcaatctaaacag
-aacagaaagcgtagcgctcatcagcacagactaactttttcagtttgagtcgccggaggg
-acttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaa
-tcttgcctaatttctactattgtcagctgtacgactgtactaagtgtatagccccaaata
-aaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttc
-atcaaattaaatcctggcttacccgattctccggaagtctgacctagagattgacgacgg
-ccgcgtattattgagacctcttcaggattaatcaataacgaagtagttgatctgtttggc
-gacgtaccttaagccgactccgctacacgagtttctactaaaccaatgtagccttatgct
-tagatgaataccgtcctaattagatattccggcataacagcagtaaattatctgttcaat
-ggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaatattaggtaagg
-ccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaa
-tttaggtgcgtgagggttaaacaccagcatattctatatgctagacgtcttccttaaagg
-atcgtagtattataattaataataagaaatatggttgacgtctagtcagcgggcatacgc
-tgctctatatactggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctc
-acgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgcc
-aagcatgcaataaaaaaaatgttaatagtacgtttacgacattttattttataataaaga
-gaaactattacacctattgatatgataggacgtaaattaacgagtagcctgcatagaggc
-aaatgaggtttctacatggtatagacctgatgctgaaacatcgatgagttttggtcccct
-cgctcgttgaaatctagtcatttactactgtctttcgagctattataccacttcactatg
-tggtgtttctttgctatgtatggggctagtcaaacatgatgactatagctacaactcaga
-gagcgggcgtgttaagagtatctcatgctagaactgcacgacgaacttgatacaaagtaa
-caacatttacgattccacaaggtgactttgaagaaacatagtttaattctctgcttcgat
-catttctataaaccggtaccatcgcagcggatagatgcataacatttctactactccagg
-catcttaaaacacacgtagtacttcactagattaagacacgataagtgtataacttggca
-gtgggaagcaaggagattggcgaactcctggcatctgttacgttttgttcaggctcggtt
-gttgataatgtccgactcctgccatattgaagactcgctcgagggagatcgggattcgtt
-gattataagtacacgtgttccgtaatactatgaggcagtgattcaaaatggcacttctga
-cttacatgactaggtattattaccacggaagcgttaaaggcacactcttatggacttaag
-attgcaagtgccttcttctagcctgaattcgcgggttcaacacaaactctctttagacat
-ccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtactaaaaaactagtt
-ggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggtta
-agcaaacacaaataggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcg
-ggaacaacggctctaagagaataacctaaatccggatgagtagactgtgtaactctctaa
-agggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgcattcaattgaatc
-gtttgtattatgagctgtacagtagctatatcagctatagttatcccagaggaacaggta
-aactagctctgagcgtgaaatccggatattagaacccctagatgggattgattctagcta
-atacaggcttatctggttttacagttatctagatgattggtaaggtgaaacgcttggtgc
-cttccaccacttaaacaaaagtattgcccgggaagctattttctaggtattataaagtcg
-agcattaatatcaatttgacagtaaaggtctttcaccagcttcatatgccatagggccca
-tactcgatttaaattgaacggtttaacgagtattggaactctcacttataactgagtagc
-tatacgaaaaatctggtccatttccagaaatttattatcgatttgctgcttagtacccag
-gaagtgataacccttgaaggcacaacactgtaataagttttcctgtcacatctgtaatat
-tcggtcactacgcattcacgactaaagataattactatactaattaaaagttcaatgtta
-gggccgaatcatagtagaaattctcgtctagcctaatcggacttacctatgggctgtgag
-gatttatcagtatgtggacaaaaatgctagagataggtatagttaaagtcaccatggtac
-atctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgggatgacaactac
-tatacgtagagccgtactcaggattagatagtgtgaaagagtcaaataaaagggttaata
-ttaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaat
-acaggccttcaccgaaccctaatgataatctgtcttaataacattaaatgattgtctccg
-ctacgagctcttagggcctcattttaaatgactaatgtccaaagaagagactttcccaat
-ttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaagatagaagattat
-caggagggaagtttctattatcaaccgttacgcaaccataaacttttaaatctcataatg
-gcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgctggggagctagat
-atcggtataccacttcggttgtggtaagcccgagtgggccgttagtaatattaatagacg
-attatccgacaatgcattcgctgaaataatcttacttaggagaaattaatgctatgagcc
-aaaactatttatgtctgtcacattattgactaaagtatctatcgacaaaactgatgtcca
-taagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatga
-attatagttatccaatttgagtaaattgcctattatacagataggcttgtttagtcagat
-aaggttccgcttgaggtgctctaacttagcgagagttagaaagcctagtgagaggcattt
-tggtgccaaactccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaag
-ttggtgaacagccttttgattagttgtttgtcttgtggctatgtgctactatataagtta
-gaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgagacggggtacgcc
-gttgaggctcgagatagtagataaactagaggaatgtagataaaacattagctagggggt
-ttagttactggattacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtc
-gcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcctatacggacttt
-gcatatctctaccgactcatctggtcgtctatgcgggtaattgtattgctccaagtggat
-gactattttggcgtcccagcacatagtaaatgtaaatccttataatagcataagcaatta
-ttagactgcgtgaagtcttagtagttctcaagctttacgttgtatgtaaataactcacgt
-aatcagccgtccccaaatcaccattgaggtcattgaatgtacggagcactattatcaatg
-cggtatgcgattttctgagcgattattgttaaagacttagcgttgagccccggaacactt
-gattacagattctttaaggagttatccaaatatcattttaaataatagtagtatcgtgct
-ttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtacttctctgatata
-tacttcaactatgaagattctattcatcgataacccaggtatatttatatgcccgttcac
-tgcgcagggcaaattatctacggacaataatgacgtagttggacccggtaagaactaacg
-cttaatatgattaaggatgtatgccagtattatcttattatgtcagagtagaagtttctc
-tgagattttccgtcgttgtggtacaccggatttggctctctttttagaactgagaactcg
-gagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccgccctcatcaact
-ataacaggacgacaagttccgtcttgctccatcatatactaccgatacaccaatcgtatc
-aagtttagtatacttgctttctctcttctacagcttactcgcttgtccgagaagcggttg
-gtgctcataaagttagtagtaaatgtacaactagtagccagtccttacctgtttttacga
-ctactacggacaccatgagatacagaagttagtgctacaattataccattacatgctcaa
-tatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctacc
-atcccgtcaatgcacaaaaacacactccccttgttgactaacatcttttacaagaggcta
-aatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcggaagaataccact
-tttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaat
-atattcatttgaccgtcattagccttcttcttaggttgtgtacggatagtaggtacataa
-accgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttttttaccaggcta
-gagtcagaaaagttggagccatgttaaatagttaccatcataaaccactgttgtctacta
-gtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactg
-ttgcgttacttaggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcc
-taatcctcggaaagtacacaagcctaggaataggaaaagtaaagctcttttattctgata
-gtgactaactcaggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatca
-tctgctggtgaccagttatagacagggtaattcaatatttaatgtctcccttaacatttc
-accagcatggattgaagatagtataaagttttacatggcagtcattgtgtcacggttcta
-tacaaattctgatagttagacggtatttgaaatgtgcttctagcatggtatcttacacaa
-ctgaatgaacgactggagccgttcgtatactatttgcgagcctcgagaccccgtttccta
-atgttaacgaatatagtataatataaattgtgatatgaataacacaagtaactacagttt
-ggacaattaattgttctaaactaaaaatcattcacttcagatggcatagagttatggcta
-ctacacatataaagcggtatgtgaaacacccgttttagccggaaaccctctactgctcgg
-gacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaa
-tagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatt
-tggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgt
-ctattactgattaactagtaagacattagtgcatctggtccactgaagcacccgcttggc
-gttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctata
-ggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggt
-tcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagac
-tctttatcccaagaatggataatatgtacatggaaagtgtccataattaagtcccttcac
-tgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgacttacttgcttttt
-gatcaacttaattatggattcataaagttcagatatcggtacaattggtgtacaatatga
-aattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatccccatttgcccg
-gtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagcattgagatccac
-gatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacgaagaggtatatat
-aacctaaatactaggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggc
-gaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggt
-cagttcaaaagtagaccggatctttgcggagaacaattcacggaacgtagcgttgggaaa
-tatcctttctaccacacatcggattttcgccctctcccattatttattgtgttctcacat
-agaattattgtttagacatccctcgttgtatggagagttgcccgagcgtaaaggcataat
-ccatataccgccgggtgagtgacctgaaattgtttttagttgggatttcgctatggatta
-gcttacacgaagagattctaatggtactataggataattataatgctgcgtggcgcagta
-caccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatt
-tgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattatatatgttgatta
-tttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgc
-ttaagtttgagagcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtgg
-ttgtcgtccataggtcactggcatatgcgattcatgacatgctaaactaagaaagtagat
-tactattaccggcatgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgccca
-tgtagccctgataataccaatacttacatttggtcagcaattctgacattatacctagca
-cccataaatttactcagacttgaggacaggctcttggagtcgatcttctgtttgtatgca
-tgtgatcatatagatgaataagcgatgcgactagttagggcatagtatagatctgtgtat
-acagttcagctgaacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaacc
-atatcgttcacacatgatatgaacccagggggaaacattgagttcagttaaattggcagc
-gaatcccccaagaagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcc
-tccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcg
-cggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatatctttggtagaac
-ttactttgctttaaatatgttaaaccgatctaataatctacaaaacggtagattttgcct
-agcacattgcgtccttctctattcagatagaggcaatactcagaaggttttatccaaagc
-actgtgttgactaacctaagttttagtctaataatcatgattgattataggtgccgtgga
-ctacatgactcgtccacaaataatacttagcagatcagcaattggccaagcacccgactt
-ttatttaatggttgtgcaatagtccagattcgtattcgggactctttcaaataatagttt
-cctggcatctaagtaagaaaagctcataaggaagcgatattatgacacgctcttccgccg
-ctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgag
-aagacgaagatcgactaaagttaaaatgctagtccacagttggtcaagttgaattcatcc
-acgagttatatagctattttaatttatagtcgagtgtacaaaaaacatccacaataagat
-ttatcttagaataacaacccccgtatcatcgaaatcctccgttatggcctgactcctcga
-gcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtg
-agatgatcagtttcattatgatgatacgattttatcgcgactagttaatcatcatagcaa
-gtaaaatttgaattatgtcattatcatgctccattaacaggttatttaattgatactgac
-gaaattttttcacaatgggttttctagaatttaatatcagtaattgaagccttcataggg
-gtcctactagtatcctacacgacgcaggtccgcagtatcctggagggacgtgttactgat
-taaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatg
-agttttacattagtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaa
-gagaatacatacaccaccacatagaattgttagcgatgatatcaaatagactcctggaag
-tgtcagggggaaactgttcaatatttcgtccacaggactgaccaggcatggaaaagactg
-acgttggaaactataccatctcacgcccgacgcttcactaattgatgatccaaaaaatat
-agcccggattcctgattagcaaagggttcacagagaaagatattatcgacgtatatccca
-aaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtga
-cctctagtatacaggttaatgttagtgatacacaatactcgtgggccatgggttctcaaa
-taaaatgtaatattgcgtcgatcactcacccacgtatttggtctaattatgttttattta
-gtgacaatccaatagataaccggtcctattaagggctatatttttagcgaccacgcgttt
-aaacaaaggattgtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaa
-atgagattctatcctaaagtttgggcttgatataagatttcggatgtatgggttttataa
-tcgttggagagctcaatcatgagctaatacatggatttcgctacctcaccgagagacctt
-gcatgaagaattctaaccaaaagtttaataggccggattggattgagttaattaagacct
-tgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaata
-ccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaat
-agttaactaatttaaaattaattaacgacatggaaatcacagaacctaatgctttgtagg
-agttatttatgctgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacg
-catcttttagttcagaaagtggtatccagggtggtcaatttaataaattcaacatcgggt
-ctcaggatattcggtcatataatttattaagggctcttcgagtcttactctgagtgaaat
-tggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcat
-tccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatataagaaaactcac
-acgtctcattattaaactgagtacaatttttgcacgagaaagtaatgcaatacaatatga
-tgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgcactggattaaaa
-tccgattatttttaaaaatattcagtgctagagcatatcaggtctacttttttatctggt
-atgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaagttataacataa
-ctcccgttagccaaagcccaatcccgattactgccctaccctaacgtctgccatctaaat
-atcgaacttgttatgatcaatgtgactacctcccaccctttccccttcatttgttccact
-ggggataagctagcgttttcagaatcaatgcaataagaatagccaattgtctcacttcat
-cagagctcttggcaattccaggcgctacgtggttctggaatatattcatttttcaaatag
-taatacgtttagtgttgctattgtctacacgtttggatattacgttatgtgagcggacat
-caatagttgtctaactctttagtaagccagagatagcactcttagcgaatggataccatc
-ttccataagtttagttaatagtccgaaacaactgcttcgagcatatttgaacctccttgt
-aggcaaatagcctcttcaaagcaatcttactaatagatagagtttgttttaagggactac
-tagaaatgggacaatcttaatagtatgacctaaactgacatttaaagatatatccaggtg
-gcaagcataaagatcattgcgccacctccaccgtgggattacttatcagtcgatatccta
-tatgctaagtttgcgacggcagaatacaaactaagctgagttgatgctaaccttacctat
-gataccccattggaccggttaacagccctacttattccaaataaaagaacttttatgctg
-tagaagctattatagtgatgcctggtaacttcagtatattaaaatgacacacatacgcca
-tatagagctcctggaactttgaataatgagcgaacttcgaagttgaagagcaagaaacca
-tatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattgatcattatcgag
-gttttcataaccttgacccattatcggctgtgcgcggacaagtacttaaatcactagttt
-cttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataagacggacgtaga
-gccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggattttaaattttgttcca
-tttttaatttagccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggc
-ctatgctactggaacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgta
-tttttgcggctagaatagtcagtcgcttggagccatataccttaccacttaaacgacgtg
-ctcctgtagttgaaatataaacagaacacaaagactaccgatcatatcaactgaagatct
-ttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccg
-caaggagtcgattgggaccctaaatcttgacgaattgctaagaggctcagagctaccact
-gtaatttctctagagcccataataaatgaacgatacatccgtaggtagcacctaagggat
-tataatggaagccaaatgcagttaataatattatatactggcgtacacgattcgacggat
-ctctcacatagtgattcacgacccccccctttgattgacacagcgtcagcattttgcaag
-aacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtat
-aatttaccatgcttccctgatgctgagtgcaatacactaagaatgagtttttaccccata
-tcaccagtatttgttctgttattgcgaagaaatggctatgctgagttggcgactaaagtc
-acccatcctttttattaggtaaccccctcccttaaactaactgatttgctggagctgccc
-tgcatacatatactttatcatttatggacgtccgtgacgcttattatccaccatagtcga
-tatgctacacggattcattaatggatcgtaggagtttaagttatatttactaagatcggt
-ctcggctactatcccgccttacccggcgctatttacggccatttttaatatattgacggt
-aattattcctatggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgt
-aaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtgatgagtaacttga
-cgaaatgttagtggttattaaagactatctattacaccttttgttttctgtcgtagtata
-ttaaagtctagaagccttacaggaaaatcagggttatacagccgatactccgcagcatga
-atcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtattta
-gaccttttatacaaagtaaatatctcggctttatgtgattgggaggggcctactcaaaca
-tgatgacttgacctaataatcactgtgcgggcgtcttatgactagctattccttgaaatc
-caccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagtta
-ctttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttactt
-ccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaac
-aaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaactactcgaagat
-gtttcgttttcttaaccataggggcttcttaatggcccactacgcacattttgttcaagc
-ccgagagggacatccccattacgggagtattactaaaactgttccgtaatacgttcagca
-agggatgaaaaaggccactgctcaagttattgacgtgggagtattacatcggaagcctga
-atcccacactatgatggtctgtacaggcctagggactgcgtctagacggtattaccggct
-tctaatcatacgatcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatt
-tatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaa
-aaacccccgcacataagccgctttagatttcacaaataccaatgcggttaaaaacatcct
-tgagtcgtacatacaccatactcgcgttaaacggatataacagaagataataaatccgga
-tgtggagtcggtgtaactatagaaagccaagtgaaataatgcttaccagtcatttagcta
-tacggctttcatttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccg
-atacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaac
-aatagatgggattcattatacataagacacgatgatctgctttttcaggttgcgagatgt
-tgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtattgacagggaacc
-tattttcgaggtattatatagtccagcttgaatatcaatttgacagttaacctagtgaaa
-atcagtaagaggaaatacgccacattctccagtgaaattctacgggttatcgtctagtcc
-aactatcaattataactcacgagatataagtaaattctcgtacttggcctgatttttatt
-atactttggatccttagtaaacaggaagggagaaaccttcaacgaaaaacactggatttt
-gttttactctcaaagctcttatatgacggaaataccctgtcaagtcttaactttattact
-agactaatgaaatgggcttggggtggccagaatcatagtacaatttagcggatacactat
-tcggactttcctatcggctgtctggttggataagtatggggactaataggctagacatac
-ctatacttaaactatacaggcgtcatctatctctgcaactttggagttccctgatgttct
-cccgccctttgggttcacatcttctataccgacacccctaataacgattagtttgtgggt
-tagagtaaattaatacggttaatattaatgtatcgttgaaaagctggtgtcgccaataag
-gtaaccggctaggcagagtatatgtcacgaagtataactaccctaatgataagctgtagg
-aataaaattaatgctgtctctaagcgaagagatatttccgactctgttttaatgacgaat
-ctcattacttctgacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacg
-catataatgaacttagaagattataacgacggaactttatatgataatccgttacgatta
-aagaatctgttaaatatcataatggcattcagttctagaccgtgcatcatggtaaactta
-ctttctctgcatggcgacatacatttcgctattcaaattcgcgtgtggttacacccactc
-gcacctttggaatattaagagaagatgatcagaaaatccattcgctcaatttttctgacg
-tacgtctaatttatcctaggagacaaatcgttttatgtctctcacatttttgaagaaagg
-ttcgagagacaatactcaggtcctgaactgctagaagatactcggtggagcgtggcaaca
-atgaaaaactcgtgacataaatgaatgatacttttccaagttcagttaagtgaatatgtt
-taacatacccggcttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctct
-tacatacactagtgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactc
-acgctatgtattgacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgt
-ccctatgtgctaatatataagttagatcgcattagatgctaatctgaatacttatagacg
-accttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagg
-gacatataaaatttgagtgcggctttagttaagggtttaattacctactcaaacatcacg
-ctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgtactaggtagtga
-ttaatgatatcctagacgcacgtgccttagatcttcagactctgatggtccgcgatcacc
-gtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaa
-tacttataatacaataaccaaggatgagaatgactcatcgcgttggagttatattgcttg
-aagttctatggaatgaaagcacgttatctgccgtcccaatatctccagtgagctaattca
-ttggacggtccactttgatcaatccccgaggagatgttcggacactttagtctgtaacac
-ttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttttccaaagttcat
-tttaaataagactacgataggcctttcctattgatataaactacccggctctgttgttcg
-tgtgagtcgtacttctctgtgtttttctgattatagcaagattcgattcttagtgtaaac
-agcgatttttatttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagt
-tgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcccacgttgatagt
-atgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgca
-tcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgatatttagcaagag
-gcgttgataaagccctcatcatctagatctcgacctcatctgccctcttgctccatcatt
-ttctacacagactactttcctatctacgttagtataattgctttctatcttagtatcatt
-tagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgta
-gcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaagaagtttgtcat
-tctattagacattgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaa
-gactgtgattaactaaaatagacaagccactatatcaactaataaaaacgcccctggtgg
-tcgaacatagttgactacaggataattaattggactggagccattacattctctacaatc
-gtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttc
-gcaggagcacattggtagttcaatagtttcatgggaacctcttgagccgtcttctgtggg
-tgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccg
-gaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgtttaagagttacc
-agcttaatccacggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgc
-attctatcgttatcctatcaacggttgccgtactgagcagccttattgtggaagagtaat
-atataaatgtagtcttgtctttacgaagcagacgtaagtaataatgacttggaataccaa
-aactaaacatagtggattatcatactcaagaactctccagataaataacagtttttacga
-tacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaacgctaattcatt
-tgttattggatccagtatcagttaaactgaatggagtgaagattgtagaatgttgttctg
-gcctcgcatggggtctaggtgatatacaatttctcatacttacacggtagtggaaatctg
-attctagcttcgtagctgactatactcaaggaaccactgctcaaggtaggagactagttc
-cgaccctacagtcaaagtggccgaagcttaaactatagactagttgttaaatgctgattt
-caagatatcatctatatacagtttggacaattatgtgtgcgaaactaaaattcatgctat
-tcagatggatttcacttatgccttagaaacagatattgcccgagctcaatcaacagtttt
-agccggaaacaatcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagat
-ttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagttt
-aaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaa
-cgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacacattagtgaatat
-cggccaatgaaccaaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcag
-gttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaacctcattgtaaca
-atagcccagcaaattctcatacgtgcctcagggtccgggcgtactcctccatggaagggc
-gcgcatctagtgttataccaactcgctttttaactactatgctgtagttctacaggcata
-gtggccagtattttctaacttctctggatagatgctctcactcctcatccatcacggctt
-cagtttacgtcttacttgcttgttcagcaacggatggaggcattaagtatcttcactgtt
-ccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactc
-attgaatactgccccagttgcaacctcacttaatctgacaaaaataatgactactctaag
-tgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtataggcatgtaact
-cgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccagg
-taattgatgcggatataagctggagatcactcacgcccacacaaggcgctgctacctctt
-tattccaatgtgtaagaatttgctaacttcatttctagaccgcagctttgcggtcataat
-ttcacggtacggacccttgggttagagacttgataacacacttcgcagtttccaccgcgc
-acatgttttagtggcttctaacatagaatttttgttgtgacataaagagtgcgtgggaga
-cttgcccgaccgttaagccataatcaattgaaagccccgtgagtcacatctaattggttg
-tactgcgcatttagctatcctttagctgactcgaagagattcgattcctaatataggtta
-attagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataact
-cgcgcttaattacttatgagtagttccaagttcgctacgttatgagagagattggaatta
-agcaaatatgttttatggtgattttgggatgagaaggactgctaagtacggctactaaac
-aaatttctaaaaccgccatctaccttatcttggagacatttaagttgtatatgtcactag
-tctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatc
-aaatgcttatctaagaaagtagtggactattacaccaagcacgaatgccagggaactgct
-ttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaattacatttggtca
-gcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttg
-ctctagatcttatctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtg
-agggcttagtatagttctctgtatacaggtcacatcaaactccccctgtcctagtacagc
-tctgagctttaattaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatc
-atgctcttctcgtatagggcaagagaagcaacaaacaactagcccgactcacgttcatcc
-gccgtatccttgttcagttcttactccgtattaggtcagcgaaatctaatcagaataatc
-ggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttat
-cggctattagatagtggggtgaaagtaattggctggaattatgttaaaacgtgatattaa
-gctaaaatacgctacttgttgccgacctaattcagtcattcgatattcagttagagccaa
-gaataacaagcttgtataaattgaacggggtgcactaaacgatgtgttactctaatattc
-agcttggagtatacctgaaggcgaattcatgtatcggccaataataagacgttgaagatc
-acaatttggactagcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagt
-acggtctctggaaaattataggttcagggaatataaggaagtaaagataattaccaagag
-atttttggtatcgctatgacccagaggtgttctaacgtctgttttgatccgcagaatttc
-tgcctcaatgcatatttgacggacttgaactagagcctctaaagttaaatggcgacgcaa
-ctgttcctaaacttcaattattactactctttttttcctagggtattgtagaggccagtg
-gacaaaataaatcaaatttaagatgtttcggacattaacatcccccgtagcatagaaatc
-atcagttatccaatctctcatcgagcttttacaatttctgctggcgctatggacagcata
-tgccgcgagacctccgcaagactcacttgatcactgtaagtatcttcattagaggttaga
-gcctatagttaagctgctgacctagtaaaattggtattttctaattttattgctcaagtt
-aaaggttagtgaagggataatgacgttatttttgaacaatgggttgtattcaattttata
-tcacgaatggaacccttcattcccggcataatactagacgacacgaacaagctccgatct
-atcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgac
-ctgatgcaacttagggtcacgatgagtttttcaggactacttattacctattaataagtt
-aacatgagccttcataccccgtaagacaatacatactccaccaattagaattctgagcca
-tcttatctttttgtatcatcgaagggtatggccgaataggttaattagttactcctaacg
-tctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtc
-tagtatgcagcatcaaaaatatagtccacggtttccggattaccaaacgcggcaaagaga
-aacattgtatcgacggagataacttaatacagaaggaaggggcatcttcgaatacggatg
-aataattctatctgtttattctgacatcttgttttcaggttaatcttacgcattcaaatg
-acgcctgccccatgcgtgcgcaattattttctaatattgacgagagcaatctcactcctt
-ttgggtctatttatgttttattgaggcacaagcctatacagaacaggtactattaaggcc
-gtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttag
-tgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgggctgcatttaag
-atggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccat
-gtagattcagatcacacactcattccttgatgttgtctaaacaaaagttgttgtggacgc
-attggagggagttaagtaacaacttgggatcgcatacttataaaaattatatgttaaact
-ttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagtcactaggtatta
-atggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaa
-gaacacttaataaggcttgcttgcacggaggtatgatgtttactgactctacaaccctaa
-ttttccagtacgtacattcattccaataggttagttctcaaagtgctatacaggctcctc
-aattgatgatatgcttcagccgctctatggatattagctcattttatttaggaagcccgc
-ttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatga
-caccgctttacatagaatttgaattaaaacgcgctctcccgttcactaccatacttggta
-ccgtgcgcatattacatatagatataggatcattttttaaagctgtactaggtttgatcg
-acaatcttatgctatactatatgatgtaaccctcataatcaataccgatcgtacgatcct
-agcataggtggcaagcgattttatgccgattattgtgttaaatagtctgtgagtgtgatt
-atcagggctacgttggtagaggggttgtatagacctcgcacacattgtgacatacttaac
-aatatacgaaaactgatataataaatccccttacccaaacaccaatcccgttgaatcaac
-taccataacgtctcccatataaattgcctacttgtttgcataaatctgaatacataacac
-cattgcaccttcttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaa
-caatagcatttgctagcaattattaacagctcttcgaattgcctccacataacgcgggag
-ggtatattttaatttggcaaatactaagtactgttggcgtcatatgctattaacggttgg
-atattaagttatgtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagag
-cactcttagagtttggatacaataggccatatgttgacttaagaggacgtaactacgccg
-tacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaatcttaagaatag
-agacacgttcgtgttagggtatactacaaatccgaaaatcttaagaggatcacctaaact
-gaaatttatacatatttcaacgtggatagatttaacataattcagccacctccaacctgg
-gagtaattttcagtagatttactagatgattagtggcccaacgcacttgactatataaga
-tctggggatcctaacctgacctatgagacaaaattggaaacgttaacagcccttatgtgt
-acaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgcgtaacttcacta
-tagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatgaatgacagtaat
-tcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaag
-ctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgag
-cacatggaagtatatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaa
-actttcgatttagtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccaga
-aatacgagtttaaatttggttacatggttaattttgaccgaagcatcgcactttatgatt
-gataattggattcaatatgtcgccctatgcgaatgcaacatgatccacaatttggctata
-agacgtttaatccgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaag
-agtcagtaacaattataagtactccgcaggtacttcaaatataaaaactaatcaaacacg
-acccatatgatcatctgaagatatttggaactttctcgacaaccaccctcgtactcaata
-cttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagattt
-gcttagtggcgatgagcgtacacgcttatttctctagtcacaattagttatctacgagac
-atcacgagggagcaaataagcgatgttatggctacacataggcacgtatgaatatgatat
-aagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgagg
-cacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggat
-caactagaagagaaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttca
-ctaagaatgtctgtgtaaccaatataacatctatttgttatctgattgcctacttatggc
-tttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtaccaactccctttaa
-attacgctgtgcaggctcatgcactgcatacatatacggtagcaggtagggacctcacgc
-acccttattataatcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggt
-gttggtatattttctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaa
-gccaattttgaatatagtcaacgtaatttttactatgggttccaccgaaacgccttgcac
-aactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaataccttcatata
-tattttttcggttgactaacgtgaactaaggttaggggttttgtatgtctatataggaaa
-cagtttcttttctgtcctactttagtaaagtcttcaagccttactccaaaatcacggtga
-ttaagccgttactcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaa
-gagtcgctgtgtattagctagggagacctttgttaaaaaggatatatcgcggcgggatgt
-gagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatctctcccccacgct
-tttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtact
-tgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagagaattgagtgtaa
-aaccgtaaagccctcacctgacttcatgtaaatggcttagaagactccatgatttaataa
-atactacgaaggaaagactggatctaaagataactctagtaaggccaactcccttcaatg
-ctgttgccagttataatccaagagctgtccttttctgaaccatagcggcttctgaagcga
-actagaagcaaagttggttctagccagacagccacataccctgtacgggtgtattactaa
-aactggtccggtattagttcaccaagggaggaattaggcaaaggatctaggtatgcaagt
-cggagtattacatccctaccctgaatccatcaataggttcctctgtactggccttcgcaa
-tgagtattcaaggttgtacagccgtataataataagatagtgactatgaacgggaagtaa
-cccgctcaccttccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaa
-tactcgaaaataaacaactggcaaattacaccgcacttaagccgcttttgatttatattt
-ttccaatgcgcttttaaaaataattcagtcctacatactaattaagacccttaaacggag
-atatcacaagttaagttttaaccatctcgactaggtggaactatagatacccaactcaat
-ttatcattacctgtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttc
-acagcgaaacttcagtgtgaacagattctgagaaatcacctaaacctattagtcagagca
-cccggttagaaccagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgag
-atccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatt
-tttaaatactaggcaaacccaacataggttagtcctatgtgatacgccacatggtatatc
-attttgtaacgttacctagggataatcaggaagtggaattacgcaaaagtagacagtgaa
-atgcttagggttatagtctagtccaaagataaaggataaagcacgtcagagaactatatt
-agccgaatgggaatcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaac
-agtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtac
-ctgtatactagttactgtattacgtgtctaatgatttcggattggggtccccagaatcag
-acgtcattgtagacgattcaagtttaccaatttaatttcccagctctccttggagaacta
-tcgccaataattgcagtcactttccttttctgaaacgataaagccgtcagagttctctgc
-aacgttggacttacctgaggttctaacccactttcggttctaatagtagttaacgacaca
-acgaataacctttactgtggggctttcacgatattttttcgcttattattaatggttacg
-tcataagctggtgtccaaattaaggttaccggcttcgcagagtagttgtatccaagtata
-acttccctaatcataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatg
-tcccactatgtggtatggacgttgctaattacttctgaagggaaattggtcattatggat
-acgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttgatccaccgttct
-ttataggataataactgacgattaaagattatggtaaatagattaagccaattctcttct
-tgtcagtgaagcatccttaactgacttgctctgcagcccctcatacatttagctattcaa
-agtaccggctcgtttcaaactctcccacctttggaagaggttgtcaacttgataagtata
-tcatttacagcattttttcggacgtacctctaatgtttcattgcagaaaattagtttttt
-ctatcgcacattttgcaagtaacgttagagacacaattatctgcgaatgaactgctagat
-ctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttga
-caagtgctggtaagtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatg
-cacggcagagtaatgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaag
-acccctccattctcgagcccactcacgatatgtagggacgacaacttgtgcggcttatga
-attgtctggactgcgggcgagggtccatatctccgaagttagaagggacatacctttaga
-tgataagatcaattcttattgacgaaattcatccacaacggggaacaacttcaccctaga
-cttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggct
-ggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggc
-tatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtgcctgtgatatta
-acaagatgatccgacgcgagcaccgtaattctaggcataaaactccagcaatttgggggc
-cgaaaacaaatgacgttagctaattaattatatgacatgatcaaaggaggtcaatcacgc
-atcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggca
-aaattgatcctgtctcctatttcatgcgtacctcctagttgataattccccgagcagtgg
-ttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgta
-tggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcagttcctattgatt
-tattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgtttatgattattg
-ctactttagatgctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaat
-tggatagaacctatagtttcaagttctgccacaaggtatcatatttacagttagtgctgg
-ttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggacc
-gagtgcgcgttcaaccctgttccagagagggtgtgatagcacatataccacgctcgtcga
-ggcgttcatgatagtttgcaagagccggtgttaaacacatattattattgttatccaact
-aatcggacctatgcataaagcattgtctaaacagaataattgcctatatacggtagtttt
-agtgatttatatcttagtatcagttagagcttcgaactcttcaggttcctcatatttaac
-gttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctat
-aaatcacagaaagatctgtctcagtatagttgaaatggtattcagctagtgacgtgtacc
-aattatcatagttcactcaagcaagacgctcattaacgaatatagacaagacactatatc
-atataataaaaaagaacatggtgctcgaacatagttgaattcaccatattgaaggggaat
-gctgacatgtaattcgctactagacgatcaattccctacttgtcaaagttgaactggtac
-gttcttggaattaaatatgattgcgctggaccaaattgcgacttcttgagtttcagggca
-aacgattgagccggaggatgtccgtctcttacctttcttgcttatgataaacgacggtcc
-ctgtacatcactgggaattctcagcaaaaataattgggtaaatcgagactcgatgtattc
-ggccacaaaggtgttagacgttaaagattattcaacggggcgataataggatcataaccg
-gtatgcaagcgcattgaaagagccatgagatccttatccgataaacgctgcacggtatgt
-gcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaagttgaagaccta
-agttataatgaagtgcaataccaaatcgattcatagtggattatcagactcaagatatct
-cctgataaattacagttgttaagatacggataaaatgagatttaagattagcagcctcta
-atctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctg
-tcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagttaatatgtagct
-tacgttctagcttgtgctaatctgagtatagattcgtagaggaatattatcaagcttcca
-cgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactat
-agtctagttgttaaatgctcagttcttgttatattcgatatactcttggctaatttatgt
-ctgagtatataaaattaatgatattaacttgcatttcacggatcccttagaaaaagattt
-tgaccgagcgcattataaacggttacaccgaatcaatagaagcatacccaatagctttct
-ttgaatttattgcctgcgcaacttggctgactctctagatccgaataattctatatggtc
-gtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgggccgataatggc
-tctttgcaaaattactcaatgatacgattgatcaaagcggtagttgctagtggtagcatg
-taagtctatcaaatgtctgattatccgaaaatcttccaaaagagtccacgtaccatatct
-atctcatagcgacgcgaggggaaccttatctaactatcattccatttaccgggtgactct
-cgatgcaggatccgattgggataaattgcccagaaatggctcattcctgactaagggtaa
-ggccgttctcagcaagggaaccccgcgaatctaggcttataccatctagattgttaacta
-cttgcctgtagttctacagccatactggacagttgtttctaaatgatcgggattcatgct
-agcactcctctgaatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatg
-gaggctgtatgtatcttaactgttacctaatatggctggtaattatcaaagtaaggacct
-taatgccatagcgctagcaatcgctttgtatactgaccatgtgccaacctctcttaatct
-gtaaaatataatgtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgt
-atcaattcctatagccagcgtactagtgacacaacaacaccgtgtgagaaaagatattag
-tccttacgtctgtctctctacagcttattgatgaggattgaacatggacatatagctccc
-cctcaaaagcagatgctacctctttattccattctcgaacatttgccgaacttaatttcg
-acaaacctgaggtcacgtcttaatttatcggtaacgtcacgtccctttgagactggataa
-atatattaccaggggccaacgagcaattgttggaggcgcttctataatacaaggtgtctt
-gtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaaccc
-ccctctctcacatcttatgcggtgtactgccctggtacatttcctgtacaggactccaac
-agtgtagattcctaagatagctgttggagttgcctcacgccagatcgaaaaactgaataa
-actagtgagctgagctgcagaaataccgcttaattacttatgactagttcaaagggacct
-acgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattttggctggactag
-cactccttacttcccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctga
-catttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatga
-ccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctggtcgttgaaacc
-aagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcat
-tagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaaaaaatattttta
-agcagtaggcacctaacccgattcctctacttagtagctttctttgattctcagaattga
-ctgcaatatcactgcacaattctgtgccattactagacttctctgtattaacgtctcatc
-ttactaacactcgcctaggacacatctgagagtgaagtatttcaatacatttactgaaat
-cttcagttctaaaatccccgaataaggctcttatcggtttggccaacacaagaaaaaaac
-ttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaataactatttcgg
-cagacaaagcttataacaagttgccggcgcgtataatatttaaaagaccccttgagctgc
-tcaattaaaacgctcacctggtataggctattagatagtgccgtcttagtaaggggcggg
-aattatcggataaactgatattttgataaaataaccgacttgttcacgacataagtcact
-aaggagattttatctttctccaaagtatatcttccttggataatttcaaagcgctgcaat
-ttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgtagtaatctagag
-gcaaattataagaagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccg
-gcgcattgtgtaaactggacgagtaccctagatggaaaattatacgttaagccaagattt
-cgatgtaatgataattacctacacatttttgctatccataggaacaagagctgttctata
-ggctcgtggcatacgaacatttgctgccgctatgaatattggaagctcttcaactacaga
-ctctattcttaattgccgtcgaaaatgggccgaatcggctattattaatactcggttttt
-ccgaggggattgttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatt
-taaatacaaccttgcagacaatgaataagggatccaatctctcatactccttttacaatt
-gctcatgcccctatgcaaaccttatgccgccacacctccgcaactctctcttctgaactg
-taagtagcttcattactggtttgagactatactgaagctgatgacattctaaaatggcta
-ttttcgaatgtgattcataatgtttatcgtttgggatggcagaatcacgttatttttgat
-atagcccgggtattctattgtatagaacgtatgctacaagtcattccccgaagaagacta
-gaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctttatttcccgata
-acctatcttccataaatagcggacagcaggatactgacgctcaacatcagtggttatggt
-ctaatttttaacttttaataaggtaacttcagcaggcatacacagtaactctttaattta
-taatcaaattagaagtctgacacttcttatatttttctatcatccaacgcgatcgcccat
-tagcttattgtgttactaataacgtatctaaaccaatccttttcaagctactgcctatat
-tgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtac
-gctttacaatacccggaaatcacaaactttgtagacaacgagtgaaatttatacactacg
-aagggccagcgtacaagacccatgaattaggcgatatgtttattctgacatattggttta
-tccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaaga
-ttcacgactgaaatataaatacgtttggctatatttatgttggagggaggcaatagcctt
-tactgttaaccgaagatttagccagtgagtgtgacactaaaacactggaataaatgcagg
-cgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatatagctctggatat
-aattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaagccggcctctca
-tattgaaggtccgaagtattccatgtacattaagatcactctctcattcatgcatcttgg
-cttaacaaatctggttgtccaagctttccaggcacgtatggtacaaattcggatcgaata
-cttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaa
-ccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagg
-gattagttatgttacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgca
-tcttttatcaagagactaacattattttcaacgacgtacatgctttacaatagggtactt
-atcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccgatatccattgga
-ccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtattgccataatgtaa
-tacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgc
-gcaacgtcaatacctttaggggtaacggccgctgatttcatatagatatacgataagttg
-gtatagctctactaggtggcatccacaatcgttgcatttactatagctggttacaatcat
-aatctataccgttccttacatactaccatagcgggatagcgtttttttgccgttgattgg
-gtttaagaggatgtcagtctcattatatccgattcggtgggagagccgttgttttcaaat
-cgcacactttgtgacataatgtacaagataacaaaactgatataagatataaactgtcaa
-tatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatttgactaattggg
-tgcagatttctcaattaataaaaaaatggcaccggatgggcttacaagccccttatcatt
-cacttgtatcatgatttccaagaacaatagaatttgctagcaagtatgaacagagattcg
-aattgcatccacagtacgccggagcgtttattttaatgtggatatgacgatgtactgttg
-gcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggag
-aaatatggtggtacaatctcagagaaagattacagtttggtttaaataggacttatcggg
-tcggaagtggaacttaataagcagtacacaattgggcaacagacgtcttgcctattacaa
-taggattacaatgcgttagatttcagacacgttcgtgtttggctattcgtcaattcccta
-aatagttagacgatcaactattatcaaagtgattctttgttcatcctccattcatgtaac
-agatggcacactacgcataacgccgaggaattttaacgagatttaagagagcagttcggg
-cacaacccacttgactttataacagctcggcagcataaacggtaatatgtgacaaatttc
-caaacgttataagaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgt
-gacgcagcaagcctaacttatctattggttttgctataaaagaacaaagttacacagaat
-cctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccgg
-cacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactccgggtatgataa
-tggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggttaggataaggatg
-agaccgaacttatttccggccataactttagattttctacctagtacacaacatcagggc
-ggacacgaaaccgccatcacatcatataccaggtttaatttgcttaatgggggaagtgtc
-aacgaaccttcgaactttagcaggcatatggccattatatatggccccagagcagaatgc
-tacagcagacaaaatttggatttatgtagtttaatacctatcaaacttggtgtgaccata
-cttgtctaacgacagtgcacaaagtgtaagttacaattattactactcagcagcttctgc
-aatgataaaatcttatcatacacgtcacatatgataatatctacttagggggaacgggct
-ccacaacctacatagtactcaatacttacactattcgacaggcacaccaaacctgtacag
-tcccaaaagattgagtcaactttgcagtactgcagatcacagtaatagcttagttagcga
-gtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgatgtgttggctaca
-aatagcaacgtatgaatttgtttgaagccacgtaaactgtacaaccttagagataagtct
-caggctactaaaaacacgttgtggcactaacaggatcatggttgattcttacttattcgg
-ctgaccggcccaataagtaaccttcaactagaacagaataatcgggagtagtttaattca
-gtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgtttt
-cttagcggattccctacttatggatttgagctcgtccacaatattcgatacaagaagttt
-gtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaaggaattaataga
-aggttgatggtaggctccgaacgctccatgattataatcaagtggactgtgcagtaaacg
-aggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagat
-aaaccatgaacagcacagtgtgaacccatggttgattttaggctaccttatttttaattt
-ccgttacacagaaacgaattccacaactaacatgccattaatttttcgatatcttataaa
-agatggtcgaaattcattcatttattttttttcggttctcgaaagtcaactaagctgtcg
-cgttttgtttctctttagaggtaaaagtggctttgatctcctacgtttggatactagtca
-accattactccatttgatccgtgagtatcacctgtctaacatccagcattatgactcctc
-ggcgaagaaaagacacacttcttagagtcgatgtgtattagctagggacacagttgttta
-atacgatagtgagcccagggagggcagtgcgtcccccagtagatttattcagctagtgta
-agtataagatatctcacccacgaggttcaagtgatatgcagtcttagaataatacttatc
-ctgaatttcgatattatgggtacttcaataatccgctagcgctactttatgtctcgttgg
-acagcaggacacatggcagtcttaaacactaaagacatcacctgaatgaatgtaatggga
-ttacaagaatcaatgaggtattatatacgacgtaggaaactctggatatatacagtaatc
-tagttacgccatcgcacttcattcctctggaaacttagaagacatcagctgtacgtggag
-gaaccagacccccgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaat
-gacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaaacccagcattta
-gcaataggagctacgtatgcaactcccacgtggtaataccttcaagctatcaatatatag
-gtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccagtataataattac
-agaggctctatgaaacccaactttccagctaaaagtcccaattaaatggttatttcgtac
-ttttaaagtcgcccgttctgttattacgcgaattgattctactccaaaattaaacacaaa
-ttatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataaggctctactaaat
-tataattaagacacttattaccagatttctctagttaagtttgaaccagctcgactaccg
-cgaaagatacattcccttctctatttttcagttcatctatgggtcagagaagcattgaat
-ttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaat
-atcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctg
-gaaggagtaagaagtatacagctgatccggtgtatccttcagtcatctgccctatactaa
-ttacacgacgcaaggaaaaataggtttattttctaggcaaacccttcataggtgactccg
-atgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggataataacgatctcc
-aatgaaccaaatgtagaatgtctattgattacccttttactattcgacttagagatagga
-gatagaacctcagtgtacttttttagccgaatgggaatctttgggaggtgaatggccata
-aggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgttcgtggaatcgat
-aacagatttgttgacccatagtaaatgtatactagtttatgttgtaagtgtagattgttt
-tccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaag
-tgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggttta
-gataaagccgtatgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcc
-cttataatagtagtttaactataaaagtatatactggtctgtcgccctttcacgatttgt
-tttaccggtttatgaagcgttacgtcattagagcggctccaatttaaggttaacggcttc
-catgtgtagttgtatacaaggataacttaaagtatctgttcagcgagctagttaagttat
-cctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttgctaatttattct
-caaggcaaattgggaattatcgatacctgtataccataaggtcgctcgatgtgatgctta
-tgtcttctggtgatcctaccttagttagtgctgattaacggaacattaatgtttatcgtt
-ttgagatttagccaattctctgattctaactcaagatgccttatctgacgtgctatgcag
-cccctaagtattttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgtt
-gtggttctctactggttaactatataatttacagctttgttgagctagttcctctttggt
-ttaagtcctcaatattagttggttcgagcgataagttggctagttaccttagtcactata
-ttagatccgaatgttatgcttcatctgaagaccgccaccctccaaaatttcttttaagac
-tcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacg
-agtttccatattttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtc
-gctctacaaggggacgcaattaagaaacagacatgctagtcaaaaataaacatagcgagg
-caccactaattcggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagt
-agttagttcggacatacatttacttcagatgatcaattagttttctacaaatgcttactc
-taccccgaaaaaagtcaccagactcttacgtctctttagtatccttccgtcttatataag
-gtcagtcccccgtttcggtaccctggaatttactaagaataatgaaacagcccccaagga
-cgtacgtttacaaatgatagaccagatcgcctagcttattccgacgcatgttgcatagaa
-ttgaaccaacggaatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgc
-agaatacgcctgatagttcggccacgaaatcatatgtcctttgagtattaagtatttgta
-atgatcaatcgagctcaagcaagcttacacttcctcggatattcagggaacttagtgcct
-ttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaatgcctacctcat
-agtgctgaattaacacagcactgcggacctaacttttcgaggtttcaagttcacgtctca
-aaacctaataggctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgta
-gtactgaccaagtgaatattctttttttctaaaagcagatctgctgccgggcactacgaa
-ggagatctctgtgtatcattattgcttcttgacatgatgactcttaaatcactgtgggtg
-tgcaaaacgatagcacaacccaattcgatagtacatattgttgatacttcgcactaaacc
-gttcatatttaaaggttgtgctccttccttcgttaaatactggtgacttggtcctatcta
-ctattagctagacctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtca
-tacatcttagacatcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaac
-aaatatgattattcttatactaatattagcaaagatgcataatgatttgtattaaatgta
-taattgaattgataagggtcttttagtcagtgatagagtagtataaggtagacattagaa
-ctcttaaccggacgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggta
-agagcggttactagtagtacctataatgcactgaatcttcggtcgaagtatagttctaat
-gctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgta
-agtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggg
-gaattaaccagattgaaggccaatcctcacatgtaatgagataatagacgataaatgaaa
-ttcttgtaatagttgaactgctacgtgatgggtattatatatgattgagatcctccaatt
-gccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgt
-cgtccgtatcataaacgacgcgacatgtacagcactccgaagtataagcaataataatgc
-gggtaatccagactagatcttttcggactcaatgcggtttcacggtaaacatgattaata
-ccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgtt
-gcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgac
-gaggcgcgggaacttcaagaactatcgtatattcaagtccattaccttttagtttcagac
-tggtggagctgactaaagttatatcatcattttgtacactggtttagttaacgataattt
-cagatttaacatgaccagacgataatcgctgtatatccagttggaatgtggtttgccaga
-aaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcg
-ctatacctcagtgtatttggagctgtagttataccgtgtgctaagatcagtagacatgac
-gagagcaatattatctaccttacaagcatcaacggacgtctagtcggaacaaaagactct
-aaaactcgaacttcaggttaatatactatagttctgtattcagcagttattcttatattc
-gatattatcttgcctattggatgtctgactttagtatattaatcatagtatctgccatgt
-aaaggtgccagtactaaatctgtttcacagtgcgaattataaacggttacaaccattaaa
-gacaacaagaccctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgat
-acatcccaattagtctatagggtcgggacgattctacggcatttctggttataatgacaa
-catggattgtggcccgagaatcgctctttcattaattaagcaatcattacagtcttataa
-gcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgagccgaatagctta
-aaaaacaggccaccgaacattgatagagaataccgaccacagcgcaacctttgattactt
-tcattaaattgtacggctcactcgacatcaagcttaagattgcgataatgtgaactcaaa
-tggatcagtactgaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgc
-tgttacaatatacagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttgg
-ttagaaatgatagccattcatgatagaaataagctgaatgataccagtatctttaactat
-gtagtcagggggaagataacgatggtccatgtatgtttctgatatgtgacagtattggcc
-gcgtaatttgctaacgaagctacttaatgcctttgagcttcatatagatttctttaatca
-aaatcggcaaaaagatagtatgagctataatatatgctagtagagaactctggaccatca
-tctatatgaatactgattcgagcgtgcaattactttagcctgcgtactactgactctaca
-aaacactctgagataagtttgtagtcagtaagtcgctctctataaaccttttggatgacc
-attgtacagccacttatagatcccaataaatagcacaggagacagagtttttcaatgctc
-gatcatttgccgatagtattttcgtctaacctcagggcacctattatttgatacctaacc
-taacggccctttcacaatggagaaatatatgacatcgggacaaacacaaatggtgggtgg
-ccaggagatatgacatggtggcgtctctaagaaacacggactccctctaggcaaactcac
-gtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggt
-acattgactggtcaggaatacatcactgtagttgccgtagtgtcctgttggtgttccatc
-aagacacatcgtataacgcaatttacgacggacatcagatcaagttatacagattattta
-agtatcacgtgtgcattgggacataagggatctcacacatgccttggaacatttttgctt
-tgtgccgctttttcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaa
-cagaatgagaaaggttagggctctaagttatcgtcgattgggatagacgagacatttgcg
-agcgccctccacggatacgaatctcccatatcaatgtgaactggatgctatgcagtttag
-ttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacc
-taatacacaaaaccgtcaaacattttctaattctaggtatgggccgatcataggagctaa
-ggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgcatatactgagta
-gctggcgtgcattctctcaattgtatcctttttaactgaactagtcggtcccatttcgtg
-actgagatctattaaccgataagattaataacactcgcattcgtatcagctcagagtgaa
-gtttttcaataatttgactgatatattaacttctaaaataaccctttaagcctcggatcc
-gtttcccaatcacatcaaaaattcttattccaactatctacggattaacaacgtgcatgg
-ggatcgtagtaagaacttgttccgatcactttgagtatatcaagttgacggcccggttat
-tattgaatagaaacattcacctgctaaattaaataccgcacatcggatacccgatttcag
-agggccgtcttactaagggcaggctttgttcggtttaactgagatgttcattattttaca
-gtatgcttcaactaatatgtaacgaaggacagtggatctgtctccatagtagatcttcag
-tcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtg
-aaagcaacccctagtattctagacgaaaattttttctagttcatctgataatttgccaat
-tcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcgaacctagagcca
-ttatttgtcggtaacccatgagttccttcttttcagaagttaatacactgtggtcctata
-cagaggaaaaacagcggttatatacgatcgtggcataacaacattggatcaagatagcaa
-tttggctacctattctaattctcactagattcggtattccactacaatatcggcagatta
-ggattggatgaataatcggtgtttaagtccggttgcgtctccaatctcctaatttttatt
-aatattgatcttggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaa
-agatagaagactcatttgaaaatggatcatccacagatccaaacattagcaagacactaa
-tccccaactagctattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgtt
-catgatctaattctttttgggctttgttcgatggtgattcagaatctttatccggtcgct
-tccctgtagctactttgtggggatattgcccggggattatagggttgagatcgtttccta
-aaagtatttaaaccaagtagacttcaactaaactacatcagaacatcgtgaagacaccat
-acgcggtacctttatttaccgataacatttcttcaagaaataccggtaagcagcataatg
-accctaaacagctcggggtatcgtcgtagttttaaattttatttaggttactgctcaagg
-aataaaaactaactatttaatttataataatattacaaggctcacactgattagatttgt
-ctataagacttcgcgatcccccattaccggattgtcttaagaataaactagataaaccat
-gcattttctagataaggcctttagtctaattagatacaaaaaacacgatagttgcatcct
-taatttattgtgtcaaacctggaaccttttaattacccgcaaatcactttatgtcgagac
-tacctctgaaatttattatctacctaccgcatgaggacttgaaccatcttgtaggagtta
-tgtttattagctaagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaa
-gcactcagaattgtttttagttgagtcaagactgatatataaataagtttccctagtttt
-ttcgtggtgggacgatattgaattgaatcttaaccgaagagtttcccactctgtcgcaca
-ataatacacgccaatatttccagccctgcttatgccttaatcggttactcaatctcccat
-tgaagttcattttgatctgcatagaagtttcgggcccagccttttttctgccaccttcct
-ccaagctctgtagacgcactctaagattgatgctcacatgtattaattctacattaacat
-aaatatataagtcatgcatcttcgagtaaaatatctggttctccaacatgtcctggcacg
-tatcgttataatgcccatacatgtagtattaaaatgattgggttaactggatattaagat
-catcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctc
-ggaagggctattacgcttacttccgttttggtatcttaatatgactttcaaaaattaagt
-tgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaac
-tacttgctttacaataccggtcgtatatatcgccgtgaatccagaagattgtcttctttg
-gattatcaaccgagatcctgtggaccgatgttttgggaccttcacagaggactccaggta
-gagctcgcttttgcattaatctaagaattgtacctctctaaaagatctaaaacagtgaat
-gtgtatttcatggaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgag
-ttattatacatatacgagatggtggtatacatcgaattcggggcatacactatagttgca
-ttgtatttagctgctttaaataatatgatattaccttccttacataagacattaccggca
-taccctggttttcaacttgtggggctttttgacgatcgcactctcatttgatccgagtag
-ggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaatagattactttt
-cgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacga
-gaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaagga
-tgcgcggaatagaaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgc
-cgacataggatgaaatcagattccaatgcaatacacagtaacccccacccttgattgtaa
-tgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtg
-cgatcaactatgaatctcggcgagttagatggtcgtacaatctcacacatagaggtcact
-tgcctgtaatgacgaattttcggctaggtactcgaactttattagaagtaaaaatgtggg
-caaaagaaggattccattttacaagacgattacaatgagttacatgtctctcaacgtagt
-ctttccctagtagtctttgaactatttaggtactccagaaaattttagcaaagggtttct
-gtgtgaatccgccattcatgtttatgatggaacaataagaataacgccctcgtatgttat
-cgacagtgaagtcagcagttcggccaaaaacatattcaatttagtacagatccccagaag
-ttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtctaattactatact
-aacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagtgtcgttttgcta
-tatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttaggacttcggattc
-tcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcc
-tgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaacta
-ttgatagtcgggagcataaccaggtgaacgtactttgttcacgacatttattgacatgtt
-ctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggttt
-aagggccgtaatgccggtagtgtcaaacttcatgagaactttagctggcttttggccagt
-atttagggaccaagagcactagccttaagctgaatattttgccatttatctactgttata
-actttaaaacttggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaa
-ggtttactaagaacaagcgtaggaattgagtttatattatatttaaactaaaagatgata
-ttagcttctgagggcgatagggctccaaatcataaagaggaatatattattacacgatta
-gaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttggcagtactccaca
-tctcagtaatacagttgggagagtctcaaatgttgttttattactcaatgaaccaccctc
-ataatttcactgctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaa
-atcgacaaaattacagataagtagatgcataataaaaaaaactgctcgctataacacgat
-catcgtgcattcttacttaggagcatcacccgcacaataacgtaccttaaactacaacac
-tattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctct
-ctcgtaaaatgtgataatagtttgcggagaggattcaattattttccattgcacctactc
-cactagattcgataaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcgga
-accataagcaaagcatgtaagtgaaccgtcatccttccctaagaaacataaaggttttta
-ataatgtcgactgtgaactataactgcatcctttcctgacctactccggttccttgttgt
-tatttctgaacgagaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcat
-gtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaa
-attaattttgccttttattttttttcaggctcgaaattaatgatttgttttttttgacct
-tctagttacgctaatatgcggtcgcctgtggtttctattgagtcctataacgggatggga
-tctaatacgtttggttactagtaaacaaggtataaatttgataccggagtatcaactgta
-taacatcaagctttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcg
-agtacagagccactaaggggtgtattacgatagtgacaccaccgagcgcactcactcccc
-aagtagatttatgatcctacgctaagtattagatatataaccaaagaggttctagtcagt
-gcaactcttagaataataattagccggttttgcctttttaggcctaatgcaatattcagc
-tagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaa
-atataatctatgaatgttatgccagtacttgaataaatcaggttttttataagtccttgc
-atactctcgttatatactgttagagtcttaccccatagaaattctttcatctgcaaactt
-agaagaattctcagctacggggagcataaagtccccaggatgttgacaaatacaacaaat
-gtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagttttagccgaacct
-tgtacggataaatccctccattttccaatagcagatacctatcctactacctcgtggtat
-taaattaaagcttgaaatatagagctgcatagcttatccaattcccaagcacgagtctac
-cgtcgtaaccacgatttgatttacagacgctagagcaaacccatctttaaacatataagt
-aaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgt
-ttataagccataattaaaaacatatgttcaacaggttcattgatatttgtaattgcacag
-gtttttaataaggatctacgtaagtataatgaacaaactttttaccagagttatattctg
-tactttgaaaatgctcctctaccgccttagagactttcaattagattttttgcagttaat
-ctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgt
-ctgtctcataactgtaggtctaatataattttcagttttcgaacacataaccctttgaaa
-atctgctatttaatgtctcacctgcatgcactatcttctatactgctcagaacggctata
-cgtcactatgctccaagtgacgatttaaacgaagcaaggaataataggtttattttagtg
-caaaacaattaagtgcggactacgtgctctttacaataagccttgtgattgggctatagg
-ttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctttgcattacccgg
-ttactagtcgaattacagatagctgttagatactcactctaattttggacaacaatccca
-atcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaaacgattacatat
-tatagacttgttcggggtagagatatcacagttgtgcaaacattgtaaatcgatactagt
-ttatgttggtagtctagttgcttttaccattccccgaaaaacttgatctactatttcgac
-aacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgt
-ccactatatgtaagtgtagctttacataatccactatgactgagatcattacggcctagg
-aaagcagcgtagaaaaaaagggcccggatattacgactgtaactataaaactagttactg
-gtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaacgaatttcagccg
-cgaaaattgatccgttaaccagtccatctcgacttctataaaacgataaagtaaagttga
-tgttcagcctccttcttatggttgcatcgagagtacactactcagtgggaaatagatcgg
-ggttcctacttcagattgtattatctaggcaattgccgattgtgccatacctggataaaa
-taagctacctacatgtgatgcttatctattatcgtcatactaccttagggtgtcctgttg
-aacgctacattaatctttagccgtttgagatgttccaatggataggagtctaacgcatga
-tgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagac
-gttataaatagaaaaaaggtccttctggttctattctgctgaactattgaatggaaagat
-tggttgacctacgtactatttgcttgaagtcatcaatttgacggggtgagagacatatgg
-tgcatactttacggactctatattttagatcagaagcttagcagtcttctctacaccccc
-tcacgacataattgcttttaagaatctatgtttgattcctctacgggaattcggatccgt
-tcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagcatacgaacactt
-tgctaactagacgtatgtatagtagctataaatcccgacgatatttacaaaaagaaatga
-gactcaaatatatacatagcgaccctacacttattcgcaccctgatctaggcgatcctag
-cacccacacccgaaagtgagcactagtgtcttccgtattaaatttactgcagttgagatt
-ttagttgtctactaaggattactctaacccgtaataaggatcaagactcggtactagctt
-tactatcattccctatgtgttttcctaactcacaagggtacgtaccagcctatgtaatta
-caataatgataaagacacaaaggaagtaactttacaaatgagtctccagttacactagct
-tagtccctcccatcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaa
-gaacactcataacgttggagtccaagaattagactcatagggcccccaacatttaatatg
-tactgtgagtttgaaggtgttctattgttaattcctgctcttgatacatgacacgtactc
-cgtgtttaaggcttcggactgactttctttcataagttgagcaacgaaaatttcagaatc
-gataagttggattcactaactaatacggctgattgaaaactccactccggacctatatgg
-tcgacctttatacgtaaccgatataaaacttataggctggtatatcgagccttcctagcg
-caatttcggatggggtttcttctactactcaacaacggaatagtctttgtttagtaaacc
-agagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtcattatggactgg
-agcactcttaaatcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaat
-tttcttgatacgtcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaa
-atacggctgtcgtgctcagatatactattagcgactcatctcgcctaacacgcacacgta
-taaactcggaatgactgccgctcttacatattagaaatacagactacaccacggaagcat
-tgggtcattctcaaccgctgtataaaagatgattagtcttataataagattaccaaagag
-gcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtg
-aggacgagatggtactcaggacaaatattaaccggacgaagtggtttacgtcgtactttc
-actattagtagtaaatacaaggtaacaccggggaatagtactaaatataatgatatctat
-cttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgact
-tatagcatgatacaaccgattgttacttttgtctattcaaaagattgaatagttttttat
-acaaaagccgcatacttatgacggctagtatacagtttcatcccctagcatcaatgctat
-ggacagtattgaacttataggaaattcttctaatagggcaaatccgtcgtgatgcctatt
-ttttttcagtcacatcctcaaatggcactagtattgtcgggatcccattaacaggctcaa
-ccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaact
-cccatggataaccaattataaggcccgtaatcctctagacatcgtttaccaataaatccg
-ctttctccgtaatcatgttgaataccccagagtagtccagatgataaccgatgaaacaca
-agtctttctcaatgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgc
-gacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaa
-cgccttgtaattttactttaagacgcctggtgatgtagattcttagataatcagtttgtt
-atcggctgtactttaccataatttcacaggtttcaggtcaagaagattatagctgtatat
-acagttccatgctcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtc
-tttaggcgtatccaatacatgccccgataccgcagtgtatttcgacatgtaggtataccg
-tcgcatttgagctcgagtcaggacgtcagctagattagattccttaatagaatataccga
-cctctagtccgaactaaactatagataacgccaacttcaggttaattgtctagtcgtctg
-tttgcagatgggattcttagatgagtgagtatcggccatattggttcgagcactttagtt
-tttgatgcataggatatgcaatgtatagctgaaagtactttatctgtttcaaactcacat
-tgattaaaccggtaaacctttaaagactacaagaaaatattcagtgagggcaattttgtc
-aatcacaatcttccagctagagatacttcacaatttgtcttgaggctacgcaacattaga
-cggattttcgcgttttattgaaataatcgaggggcccaagagtatccatagttcattttg
-taagatttctttacaggcttattacagcttcttcagactcctacatgcttacgagttata
-tgctagcatgtgaacaatagattaatatacaggaaaacgtacattgagagagatgaccct
-acacagcgcaaccgttgagtactttcattaaagggtaacgctctcgagacagcatcctta
-agatggccttattgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaag
-aatccctacaaacacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcg
-gagtatcaatttcgccaatcttggtgagaaagcataccctttcttcagagaaagaagatc
-aatcataacactatctttaacgaggtacgcacgcgcatcattacctgcctccatggatct
-ttaggatagcggaaagtattggcagcgtattgtgatttcgttcctactttatcaatttca
-cattcatatacatgtcttttatcaaaatcgccaataagataggatgagctatattagatg
-ctagtagagttcgcgccaacatcatcgataggaatactcaggacagcgtgataggacttt
-tcaatccctaatactctctataattataactctctcttaagtttggaggcagtaacgcgc
-tctatataatcagtttgctgcaccattcttcagcctctgatacatacaaataaattccac
-agcagtaagagggtttaattgagacatcttgggaacttaggattttactctaacatcacc
-gaaacgattattggataccgtacctaaacgaactttctcaaggcagtaatataggacatc
-cgcaataacacaaatgctgcctccccaggagttatgtcttcctggaggctatatcttaca
-cccactcactataggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataa
-gagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaa
-gttctgtcctgttcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatc
-tcagcaagttataaacatgttggaagtttctagtcggaattcccaaagaacggatctatc
-taatgcattcctacatttttcctgtctgccgatggtgccatcctattcaaagaatttctt
-aaaagtagattaaatgggacttttaacaatgagtaaccttacgcctctaagggttcctcg
-agtgccatacaccagtcaggtccgagccacatacacggagaacattctaacatagcattc
-tcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaaatcatacttgca
-atcccatagcacggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttg
-gtatgggaacatcattgcagctatggtctaacgcattaatgtttgggtacatcttccatc
-atataaacaggaagagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaa
-tcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaata
-gaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatatatgatctgcttt
-aataaaactttatccataggatacgtttccaaatcaattcaataattattagtcaaaata
-gataaggatgaacaacctgaaggccgatcggacgtagaaagtggtcccatcactttgagt
-tgatattgttgaaccacacgttattatggttttcaaacagtctcaggatattgtatatac
-agataatccgataccagttgtctgacgcccctcttacgtaccccaccctttgtgacgttt
-aaagcagttgttcagtattttaaactaggcggcaactaatttggaaagaagcacagtgga
-tatgtctaaattcttgttattcaggcctgaatttaatacaccgcatagttaacttcgcgg
-tagagttgttcatcatgcctcctctaagctaccacttctatgatacaccaatagttgttc
-tacggaatctgataattggccaagtcataaacttccgctgcgttcaacccccttgctcga
-atatccaactcgaaaagacagccttttggtgtccggaacaaatcagttacttcttttctg
-atgttaattctctgtggtcagatacagaccaaaaactccgcggatttaccatcctccaag
-aacaaatttgcatcaacatagcattttggctacatattctaagtctcaatagtttaggtt
-ttcaactacattatcccaacattaggattggaggaataatagctgggtaagtccccttgc
-gtctacaatcgactattttttatgaatatgcttctgccgcacctatggttattaaaaaag
-tcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaag
-agcatataattagcaacactctaagaacattatagatatgatgatagcgatcgtcatgat
-gttatccggtcacaatagtagcttcatcagctaattcgttttgccagtggtgacttgcgc
-tggaagaatcgttatacggtcccttccctcttgatacggtgggggcttattcaaccgcgt
-ggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagtcaactatactaa
-atcacaaaatagtgatcaatacatacccgcttcatggttttaaccatttaattgattaaa
-gatattccgctaagaaccattatctacctaaactgatcgccgtatcctagtagtttgaaa
-tttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgtagaataataggtc
-ttggagctaaatgatgtgattggtagtgaagacttacccttacaactttaccggtttctc
-ggaagaatatactagagaatcaatgcatgggctacataagcactttagtctaatgagata
-aaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaacctggtaattta
-aaccatatatctttatgtcgtcaataactctcatatgttttatataacttcccaatcacg
-acttgtaactgcttgttcgactgagctgtttgagctatgaggccgggatccggttgagct
-acatctatttgctacaagaaaaatgaaagcacatttgttgggagttctggctacactcat
-agagaaataagtggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaacc
-aagtggttccaacgctcgcgctaaagaattaaagcctttatttcctccacggagtagccc
-gtaatccggttcgaaagagaccattgaagttaattttcatatccagtgaagtttaggcac
-aagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaa
-cttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcgagttaattttcg
-ccttctccaacatggcatccctacgttcgttataaggaccatacatgtaggttttaaagg
-tttgcggttaatcgatatttacatcatagaaattctatagtcaaatttacaagactctag
-atactcactcgttgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcg
-taatatgaatttcatatagtaagttcaaggcactcatacctccgtgaagagggtagatag
-actattaaagttgtttaatagtacgtattgatggaaatgacccgtaggagatttaccact
-caatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgg
-gtccttcaaacacgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccga
-gataaatgagctataacactgtatgtcttttgattgctataaaacacagaaacggatatt
-aatttaggccgtaaccaacatctgttatttgacatagaacagatggtcctttacagcgta
-ttccggccttaatattgaggtccagtgtattgtcctcctttaaagaagttgattgtaact
-gacttaaataagacatgtcacccattcactgggttgcaactgctggccctttttgtccat
-cgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcg
-ctatgaaggttattcattaattttagctgttttcttagaaaaggtaaatttaaaattgaa
-aaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgaga
-ttgtaagaaataaagccataaccagccccggaatagaaaatgttaaggaaaggcgatctt
-ctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaa
-tctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcag
-aggataacggaatgtggttccgtcccataaacgatcattctcgcccacttagtggcgcgg
-taaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggctaccttctccaa
-ctttagtacaacgaataatgtccgattaacaaggagtcaatttgtcatgaccagttcatt
-caggtacttgtatctatacggacgcgttccagagtagtatttgaaattttgaggttctac
-tgataagtttagctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaat
-aacaattaacaactcctaggtgatacactgtgaagtctgctgttccccaaattacatatg
-ctattttgttcacataccatgaagttaagctaagtgctctataatggcataaacggttat
-caaactagctcgaatttcttttattacgccggaagcggattaactgctgtagatcaaaca
-cgttaggatagtgtcgttttcatatatatctaaattcggtctaacatgcattacccatgc
-ttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaa
-agtttatctatcaccagtgatgcctcatcgtgactacccggatctttagcctttagggtc
-taaacagaactaatattactacgtgtcatactccggagcttaaccaggtgaaacttattt
-gttaaccaaatttagtgacagggtagaaatacgtatcaaattaacccagcaatacaataa
-gcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgac
-atagtgtgatgcattttgcactggattgagccacaaactcaactagcattatgctcaata
-tttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttaca
-aacgcataaatctcgaacgtaataggtttaattagaacatccgtaggatttctgtttata
-gtagatttatactaaatgttctgattagattctgacggccttacccatacaattaataaa
-gacgaatatattagttatagtttactatccaaataaattaagcgaatcgaaataaactgt
-cacgatactgggcagttatcaacttatcacttatacagttcggacactctatattggtct
-gtgagtactctatcaaactaactcataagttaactgcgcttccattaaatttcaatacgt
-tcttgtgctgtgtacaaacctataatcgaataaatgacacatatggagatgcataataaa
-aaaaacggctccatatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaa
-ataacgttcctgataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaag
-ctagcatggtatagttcttgatagcgcgtaaattctgataatactgggcggacagctgga
-aattagttgccagtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaa
-atacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgt
-ccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataactccatccttgaa
-gcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaa
-caactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtgcacggaataaca
-taacaaggaatattatttattcaaattttttgtgactgttatttgttttctgcctagaat
-gtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgag
-agtgtgtcctataacggcaggggagcgaagtagtgtcctttagactattcaaggtagaat
-tttgataacgctctataaaaggtagaaaatcatgattgagcaataagaccccaacttatc
-aaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtca
-caacaccctcccatcgcactcaaaatgtagatttatgatcagacgctaacttgttcttag
-agaaaaatacacgggatactctgtgcaacgatttcattaataaggtgcagcttgggactt
-ttttggccgtaggctttattaacattcacagtaggtagcgagacttcctatgaaccaatc
-atgccacgcgttttaacgtttcaaatataagctaggaagcgtttgccaggacttctataa
-tgcaccgttttttttagtacttccttactagccttagtttatgttagagtctttccaatt
-acaaaggattgaatagccaaaatttctacaattctcagcgaacgccagcttaatctaaac
-acgagcttcaaatattctacatatcggcaggagtcaatatataaatatgaaaatcgtacc
-atcctcgtacttttagaccaaacgtcttcggataattaaatcctttttcaattaccacag
-tacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgta
-tccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagc
-ttaccattcgttaaacagataactaaaatttaatggctgagtgacttagtgttttcgaca
-aacgtcgcggatgtagactattgtttataagcaatttttaaaaacatatgttcaaaacgg
-tatgggatatgtcgaattccacaggggtttatgtaccatagaagtatgtataaggtacta
-aaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctg
-taaattagattgggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattct
-accgactccggataacactttacgatcgcgcataactctagctcttagataagtttaact
-tgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatccatcctctatct
-tctataatcatctgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaa
-agctataattggtttattttagtccatttaaattaagtccggtataagtgctctgtacaa
-tatgcagtctcatgggcatatacgttaactaccttttgatacttcgaattggtaaaatat
-cgactatcgatttgcagtaaaaggtgtagagtccaattactctttcctgttacatacgat
-ctcttagtttggacaactagcccatgatggcgctcctctagcgcatgaacctactttata
-attacatctttatcgatgaatttttttagactgcggaggccttgagttttaacagggctg
-ctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccg
-aaaatattgatctactattgcgtcaactctattctgctaatagcgatggcaaatcacaga
-agccctcttagtgacaatagttgtcaactatatctaagtcgacctttactgtatcaacga
-tcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcga
-cggtaaatataatacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggt
-gcttcccggaacgattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgc
-gttaattcgtgttagtaaacttgatcttcagactccttcttttcgttgcagcgagactta
-aattatatctgcgaaatagtgccccgtgcatacttcagatggtaggagataccatttggc
-ccattgtgactttacgcgattaattaaccgacatacatctgttcctgagctatgatcgtc
-tgaataaattacggtctcctcttgatacctaatggtttctggagacgtttctcatgttca
-aatggatagcaggagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatg
-ggaaagtcgatttccaaaccagaagggataaagagaaataacggacttctccgtagatta
-gcctgatattttgatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatatt
-ttggacggcgggagacacatatcggccattcgttaaggtctctatattggacatcacaag
-cttagcagtatgagctactaacactcaagacattattgattttttcaagatatgtttcat
-tcctctaccgctattcccatacgttcgattcgccgggtgagcgaaaccacgggactgagg
-ttaagctaatcaataacaactcgttgcgatagagacctatgtatactagagagaattccc
-caacatttttacaaaaacaaagcagactaaaatagatacagtccctccatacaattagga
-ccaacatgttattgccgatcctagcacacacaccacaaactcagaacttctgtcttacct
-atgaaagggtctgcacttctgattgtacgtgtctaattagcattaatattaaaactaatt
-aggataaactataggtacgagctttactataagtcactaggtgttttccgatcgaaaaac
-gggaccttcaagccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgact
-aatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgc
-aagcgctctcgttatactgctcaacaaaactcataaagttggactccatcatttagaatc
-atagggaccaaaacatttatttgctactgtcactttgtaggtgttctattctgaattcct
-catattgatacatgaatcggaatacctgtggatcccttaggacgcacgtgctttctttac
-gtcagaatacatattgtcagaatcgagaagttccatgcaattaagaattcgcctctttga
-aaactcatatccccacatatagggtccaccgttattcggaaacgatataataattattcc
-agcgttgagcgtcccttaagagcgcattttcgcttggcctttcttctacgactctacaac
-gcaagtggctgtgtggagtttaccacagcgcagcaccccatagaactacctctgagagcg
-cgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagt
-catattaaaatggactgtcttaattgtcggcattaggagcaatattaactgatgagggta
-tcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagatacgattacagact
-cagatcccctaacaagcaaaacgattaaatcggaatcactccccctatgacatatttgaa
-atacacaagaaaccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgag
-tctgagaattagatgacctaactgcaagaatcatggcgagtttatctagtaggcaagtct
-gtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataacca
-agaactggtttaccgagtactttcactattaggagtaattacatgcgttcaccgcggaat
-acgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagt
-cgctaccagtaattgctgatcaattatagattcattatacagatgcttacttttctctat
-tcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgcctagtataatct
-tgcttccacttgaatcaatgcgatggacagtattctactgattgcaaagtagtctatttc
-ggcttagcagtacgcatgcctatttttttgcaggcacagaataatatgcaactaggattc
-tcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatg
-tttactacagaaagcgaatgatatcacttggagaacattttagatgcccccttttaatct
-agactgagtgtaccaatatatcaccggtctaccgaatcagcttgaataaaccactctagt
-actcatgataaccgagcatacacatgtatttctcaatgcactgaaggtgaactgtttaca
-ccataccttgcgaatcaacgtggcgacttatacttctgtctttgagtacagcacacccta
-atgaatctaagttagttgttgatacgaattgtaatttgactggatctcgcctcctcatct
-agattcttagagaagatgtttcttatagccggtactgtaactttattgatctggtttatg
-gtaatcaacattttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggt
-ttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcacagagtaagctct
-ctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgt
-tgattcagtaatacaagattacctacgcttctacgaaatatactatagatttagcctacg
-tcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggc
-aattttgctgcgagctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacg
-tctttatctctggataactcacattgagtataccggtaaaaatttattctattcatctaa
-atagtcagtgagggctagggtcgcaatcacattaggccacatacacatacttaacatgtt
-ctattgacccgacccaactttagtagcattgtagccgtttatgcaaatatgccaggcgcc
-aaacactagccagagggcattttgttacatttatttaatcgattattacacagtcggaac
-acgcctacatgcgttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaa
-acctaaagtcagagacatgacactaaaatcacattaaggtcagttagtgaaggaatggct
-aaccagctagagaatgcatcattaacaggcacttattgtcaaatattttccagatctaag
-caacatcacgttaaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattaga
-aagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcgggacttagcaga
-cactggatgcagtcatagaagatcttgcataacacgttagggttagagctacgaacgccc
-atcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgat
-ttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaatta
-acatacgttgacctatttttgttcagagttcagttagagcctaatgattcgagagcaata
-atcaggacagcctcataggaagtgtcaatcacttagaagctatattattataaatcgctc
-tttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaat
-atgatacataaaaatattttcatcaccactaagacggtggaattcagacttattggcaac
-ttaggatgggactattaaataacccataagatgttgggataaagttacgaaacgaaaggg
-atatagcctgttagataggaaatccccaataaaacatagccggcctccacagcagtgatc
-tattccgccacgcgatatctttataccacgcaatataccaataataaaggttaaatgtgg
-ttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgt
-aacctagaattatagcgtctgcaagttctctaagcttcctctgcaagatacaatatgact
-ttttagcttttttactaccaaatctcagaatcttagaaacaggttggtacgtgctactcg
-gaattcccaaagtaccctgctatatatgccattccttcattggtccgggctcaccatggg
-gccatcatagtaatagaaggtagtaaaactagttgatttccgacttttaacaatcactat
-cctgacccagatatgggttccgactggcccttactccagtaagggcagacacacagacaa
-cgagaacttgataactttgaattctcaaatcgatcattgcaacgtgacttatttactagc
-ctactcctataattcatacgtcaaatacatttcaacggaggaagataataagtaaatatt
-cactaaataatggtcgaaggagtcctttgccaacataagtccacatatgcgctatagatt
-ttttcttggggttcatattcaataagataaacagcaagagtatcacgtcagcgagtcatt
-gagatcttggctagcattgtgatagcatattctacctaaatggtagtctagcacagagtg
-gataagatatcagttagatatagacaagtactataacagatctcgcttcgttggattgta
-tggctagctttgatgatatgattttataaaaattgatccagacctgacctggccaattat
-attcattttttatgagtaaaaatagataaccatgaaaatactcaagccccttaggacgta
-caaagtggtaacataaatttcaggtgttattctgcaaccacacctgttttgggttttcaa
-aaaggctaagcagattggttttacagataatccctgaacactggtatctcccaacgatgt
-cgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaa
-tatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaacgcctctttggat
-tacacagaatagtgtactgacacgtacactgctgcagcagccatacgctaacattaaaat
-tcgttgagtctacatttgttgttattcggattatgttattgggaatagtatttttattcc
-cctgcgtgaaaccacatggatagattagcctactcctaaagactcccttttggtctacgg
-ttcaattctcttactgagtttatgttcgtaattatatcggcgcagtgaatctcctaatta
-tcaccggagttaccagacgccatgaacttatggccagaaacattgcatgtggcctacata
-ggattagtatcaagagtttacgtttgcaacgacatttgaccaacttgaccattcctgctt
-gtagaccgcgggaactcccctgcacgcgactatagaagttggtggtggatgtggcttatg
-ccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtat
-aagggctattgccagatgaaaaactgcatataaggtcaaacaatataagaacattataca
-taggatcttagcgttcctcaggatggtatacgctataaagtctagcttcagcagctaagg
-agttttgccagtgcggacttccgctggaagattaggtttaaccgccctgacatcttcata
-aggtcgggcctgattcaaacccctggagtgccgtctcatacttgaattaatcgatggaaa
-acttcttctagtctaatattattattaacaaatgacggttcaataaataacaccgtaagg
-gtgggaaactgttaagtgatgaatcattttaacctatcatccattagctacagataatga
-taccccgatccgactagggggtaagtggttgttccgttaggataaaccatgtaaaacgtt
-agagggtttgtagattaattggtattccagataaatgaggtcagggcgagtgatcaatta
-cactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaatgaaggggattca
-gaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtc
-gattaaagcctaaatggtaatttaaaccattgatatttatcgagtctataaatatctttg
-gttgtatattacttcacaatcaccaattctaaatgattcttccactgtgcgggtggagat
-atcaggacgggttaaggttgacctacatcgttttgatacaacaaaaatcaaagcacatgg
-ctggggacttctcgatactatctttgagatagtacgggcaagagtgggtgacgcctccct
-acattttcaagtctatcggataacttctcggtaaaacgctcgcgatatagttttaaagca
-ttgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtg
-tcatatccagtcatggttagccaaaagcatgggttatccaaaaggaataaaacagctctt
-caacaaagagatgaggcttcataacttcgatgaatgcgtatggttctgatatatagatcg
-atgcatgaggacactttattttagccggcgaattaatggaatccatacgttacttatttg
-gacatgacttctaggtgtttttgctgtcccgtttagcgatatttacagattagtatttcg
-tttctcatagttaattgtatctagatactaactcgttgaagacgcataccttgccatttg
-tacaggacttaactgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaa
-tacctcactcatgaccgttcatactctagttaaggtcgggaatactacgtatgcagggaa
-ttgtaacctaggagatttacaactctttaaacaagagtcgctgaggtccaggatcaaaac
-actgaatctcctaacttcgggtgcctccgtaaatcacctagaaacctactcatacatttg
-caattttgagatgtaggcgaaagagagaaatctgctttttaacggtatctcttgggattc
-cttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgt
-gtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcat
-caggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtg
-aaaatgctccccagggttctacagacatagagatggtcagaacacgacccccctctcaac
-gcagtgtatttgaaatatatggacatatctaccttattctgtaattttagatgtgttctg
-tgtataccgatattgataagtcaataggcttgattacgtatcttaagacaaatctgtttc
-gcaagtaggaccgcatctttcagattgtttctttttatgccataacctgcccaggaattc
-aaaaggttatcgatacccgatatgctgtgaattattattctaatggccactcattcctgc
-ttatatctggaattggcatgaatatcttacaacctaaagtctggcgttgcgccagttcta
-cttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttc
-attagaccacactttgtgccgacgtatatagatatattacacgtatagggaatgttttct
-cctaggtgacccgaccttctactaaggttgtacatcgtataatggcccattaactacgag
-gaaagtggtattgacctggtaatgcacgttcttcgatatataccgacgaggtaaagtcta
-ctattgcaaagtttgacgttatactgataagtttagatttccctggatcgcgcatgaaca
-atgtatgcgttatctgccatatataacatgttacaaatccttggggatactatcgctact
-atcatcggaccaaaattaaataggctagtgtcttatcagaacatcatgtttaccgaactg
-atctattttccaatttaagctgatattacgtccgcgtatttattttagttccccggatga
-cgattatctgagctacatcatacaagttagcatactcgccggtgcattgatttcttattt
-cgctatatcttcaagttcacaggcttcatatagttccaattagcagtataattaggtttt
-gtaactttaaccatactttataaaaggttatattgcacaactgatcaagcatccgctata
-acccgagctttaccagttagcggctaataacaaataagatgacttcgtgtcatacgaccg
-tcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtat
-aaaatgataccacatatactataacaatgaaattatttgtaatccggtttgccaacgtat
-cccccttcgcgataaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaa
-tctcaaattcaattatcatcaatattggccaagtgttataagcgttgaaagtgatatagg
-ccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttattgctggtagtaca
-acatcacgagcatttctcttttgagttgatttatactatatctgctgatgtgattatgtc
-ccacttacccagaatattaagaaagtcctagattgtaggtatacttgactataaatataa
-tttaagactatacaaataatctggctacattatgccatcgtagaaactgataacgtagta
-acgtcggacactagattttggtcggggagtaatctagcatactaacgaatttgttaaatc
-cgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgtttagactattaagg
-actcatttcgagatccagtattaattatacgcatccatatttatactgaagacggattga
-gttaggacgacaagctaaacaaatattaagttaaggattagtattatattgtagaaactc
-gtcgggttggaacgattcatcatcatagaatgcgttacttattcagagagacttaattcg
-gttatgactggcagctcacctggaaagtaggtgaaaggcaacagaagaatattgttgact
-gaattctacgggctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaata
-caatggatctctacagtattacgtaaataacatacataaacctggtgttgattcgactag
-ctcatagattaatcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaac
-agtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaac
-gtgggggtagtcaaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaa
-tgtgatgtgttttatccagacattggatgcatggctgtgggggcacaggatacttaccat
-tagttcacctacaagcggcgtgagagggtctcagttttagccagcgcagagaagtacggg
-cctttagacgattaatgctagaattgtcataaacctcgtgaaaagctagttaataatcat
-ggtgctagaagaacacaacttttctataaaccagttctcgactgacagtcgtaactcact
-atatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtg
-catcagtagagatcgtgttctgagagataaatacaccggatacgatctgcatcgagttca
-tgtattaggtcaagcttgggactgttgtgccagtagcattttttaacagtcaaagtaggg
-tgagacacgtcatatcataatatatgccatcgaggtttaaagtttatatgataagctagc
-atgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcctttatagactga
-gtgtatcgtacactcggtacaattacaaaggatggaagagcaaataggtcttcaattata
-acagtaccccaccttaatctaaaaaccagcttcaattagtattaatttcgccaggagtat
-atatataaatatctaaagactaaaagactcgtacttttacaacttacgtcgtagcataat
-taaatcatgggtaaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacag
-tgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgattaaggcctataaaa
-ctgttgttggtatctacagagtgattaaaattagtgaatcagattacgaaaatgttttcc
-cgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattt
-tggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttc
-catagaactatgtagttggttataaaggttgtaatctcggagattaggttagggcttaat
-cagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaact
-cttaatgccatgcctggacaggataaacaatacgcatataacttgacgatcgagcttata
-tcgacctatttgagaagtttaacgggtcgatataatatacaggtcttaatagccgatttt
-ttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtgaacgatatatcag
-caaactgaacattgtatacaacattcctttttgtccgggtggggactccatttaaagtat
-ctcacctagaactcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgt
-tgatacttagaattgctaaattttagtctagacatttccaggtaaaccggtagacgacaa
-tttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctac
-tatagacaatcatcagactttttaattaaatagttttccatgaatgtgttgtcaaggcgg
-accccttcacttttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttc
-gagtcttcaggggaaatggaaaagaaattaggcttctaagatggactataatcgattagg
-ctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcga
-acgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacctatcatcacgac
-ttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaag
-ggatactgggcggggaaacctgctccttcacggtaacatggtaacaacagaatttggtta
-aggttaaaacgaaatatactcggagtgaattactgttaggtttcgtcatcggatcaataa
-gtagtttccgtgaagacactcttatattagatctccgaaattctgacccgtgcattaggc
-acttggtaggagattccatttggaacttgctcaatgtaagccagtaatgttccgaaataa
-ttcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggt
-tgagggtcaccgttctctgcgtcaattccagagctggagatacattcatcaacgttacct
-acgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaacggatttagaca
-aattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcatggcggctcagta
-cgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaa
-gctatatattgtggtcagaacttgaggacaactatgagctactaaaaataaacaattttg
-tcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagc
-gtgagcgaataaacccgaatgagcgtaacattatcaataacatatagttcagatagagaa
-cgaggtattcgacagagaattacccaacattggttattaatctatgcagaataatttaga
-taatgtcactacataatattaggaccaaaaggtgattccccagaagacaaaacaataaac
-aatctcacatattcgctagtacctatgtatgggtatgatcttctgattggacggggataa
-tttccaggtatattaaaacttattaccataatctagacctaagagaggttatataagtaa
-agagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagtaaattttgcttta
-acaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcaggtgtaactacat
-gagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaactaatatcataa
-actgccactacatcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtg
-cttcctctgctatgctgatttaatcagattcataaaggaatacgaataactctggatcca
-ttaccacgcaagggatttatttacggctgattactttttggctgttgacagaactgccat
-gaaagtaagatgtcgcatcttgcataaataatagcacctaatatagccgacaaagtgatt
-ccgataacagattttaagttgtccagccttgagactccatgaagaccgcttgggagcttc
-cccgtgattagaagaatctaaatcccaagtggatggggggagtttaaatctcagcaccaa
-caaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggttt
-gaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtac
-gacaaattttaactgatgtcggtatacggagaagaaggaagcacgcattgaagcagctac
-gcagaactgagaagatgacactctaagatacaattaatacaaaaacgttttaagcccaat
-ctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtata
-ataacagctttatttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcg
-cgtctttatagtgttggctactctgtaaccgacgcgtccatccctctctcctagtgatcc
-gtatatccaattagaggataaccaacatctgcgttaccgacgaatttaaatttttcgact
-atttaattccgttcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatc
-gtgtacgagttgcagtgcatatgtagataccactaattgctgatctaggatacatgcttt
-ataaacatgcttacttggctattttatttactgtcatgtgggggtttttattttcaacaa
-gtatgtgctaccattggataatctggcttcaaattgaagatatgcgttccaaacttgtct
-actgtttgctaagtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaa
-aagaataattggcaaatacgaggctagccttcaaatttaatgcagattactcctcagaaa
-cacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgata
-atttttgttccaacctttgaatctagactgagtggaaaaagatttcaccgggataccgtt
-tatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaa
-tcatctgtacgtcaactgttttaacaataacgtcagaataaaccggcacaatgagacggc
-ggtctttcactacaccacacccttaggattataagtgacgtgtggattcgaattctaagg
-tgacgggatctacaagcctcagctacattaggtctgaagatctttcgtatagccgcgtat
-gttactgtttggatatgggttatgctaatcaacagttgacagcgagtgaaacggccttgc
-gacctgaaatctttacggttaccttttgattcaagacaggatcgacgatggaccacgtga
-aatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcaca
-tcctctatgcaactatcattgtggtcattaaggtattcaagattaactaagagtcgacca
-tatattctagagttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgc
-aggaggtgtggactgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtc
-cttagcaatgcgatacctcaatcgtagttttatcgggataaataacatggtgtttaaccc
-tattaatggtttctattaatctaaattgtaaggcagcccttgggtcgaaagcacattagg
-ccacatacacagtatgaaattgttcgagtgtccagaccataattgactaccatggtacac
-ggtgttgctattatgactcccgcaaaactcttgacagagggaattttggtacattgatgt
-aatcgatgatttaacagtaggaactagacgtcatccgttagactgagttccgacatgctc
-aaattgtcaggatttttatccaataactaatggctctcacatgtaaataaaatcacatta
-acgtcacttagtgatggattcgctaaacagatagactatcattcatgaactggcactgtt
-tcgattatatttgcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaa
-aaattcagtacacctctaatgagtatcccgctttggaggaaagagtagcactttaaatgg
-acaatttaggccggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcg
-ttagggttagtccttacatccaccatatgttaatgaataaagcctgagggaccttagagc
-taacttgtccaacacgttgctcatttacttaataaggttgaaatgtatcagtaagtgaca
-gcgagtgtagattttgaccatttaactgaccttcacagttttgtcttcagacgtcactta
-caccataatgatgacagagcttgtagatgcacacactcattcctagtgtaaatcaagtag
-tagctagattattataaagagatattttctggcgtcgaacgtaacacagagagagtataa
-ggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcg
-gtggaatgcacacttatggccaactgaccttgggacgagttaagataccataagaggttg
-cctgtaagttaagataacaaagggatattccatctttgtgtgctaagaacctatttatat
-ttgcagccataaaaacctctgtgctatgcagccaccagagttatttatacaaagaaagag
-accatttagatacgttaattctgcttgcgatttattaaacagacatttcacgtccaacca
-ctacaaaagccctatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcg
-gccgaggaatcataaaatatgaattgttacattgtttactacatatgatcacaatctttg
-taaaaggttcgttcgtgatactaccatgtacctaactaacctgagatatatgcaatgact
-tatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctgga
-tttcccaaggttataatgctctatactgaccaagagatccgttacgactcgcaatgaata
-ctctaagggcactcacaaagaaaaccactaattgataaatttcaatgataatatcctgaa
-ttgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcata
-gcaggaacataattactatattttaacgatttaatcgtagttggagtcctttcccaaatt
-atgtcatcagttccgatttagatgttttcgggcccttcttagtaaagaagttaatatcca
-agactagctcctcacccacgcatgcacatattcgcgagaagtctgatagaatattcgaca
-gaaatgcgactctagctcacactcgttaactgatcaggtacttatagacaagtacgttat
-cagatatcgcttcggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgt
-tcaagacctgaacgggaaaatgatattatttttttaggaggaataatacagtaccatgta
-aatactcaaccaccttacgtacttcttacgccgaacatatatggcacgtgttattcggct
-aacaaaactgttgtgccttttctataaggataagcagattcgttttaaacatatgacctg
-taaactgggatctacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcgg
-atctttggttaaagagcaccattagatgtgccatacttcctatcgcctgagcgagaattt
-agtctgaggaaccactcttgggatttaaaacaattcggttaggacacctactcggcggat
-gaagcaatacgataacattaaaagtcgttcagtctaattttggtcgtagtacgatgagct
-gatggccaattgtatttttattaacagcactgaaacaaaatggagactttagactaatac
-taaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtata
-gcgccgaagtgtatctcattattataacaccagtgtacagacgacatctaattatggcca
-gaaactgtcattgtgccattaagaggattagtagatagtctggaccgtggaatagaattt
-tgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgcacgagaatataca
-agttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgct
-tcttaacgcaattcagtcttctagatccgctattccaacatcaatatctcaatttaaggt
-caatatatataacaaaattagacagagcagctgacacttacgaagcatcgtagaaccgat
-atagtcgaccttatgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacg
-gtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtct
-ctgaagtcaagtattactgcgaaaaattcgtctactattagtttattatgaacttatgac
-gcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagt
-tcataatgttgctaaagattatcagaccccgtgaagacttcgggctttgggcttcgtacc
-gtagcataatacatctatatagttagaggcttgcgtgttgttgtgctattccacatatag
-cagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaa
-gtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgtatttattatact
-gtaggcaagaagcttttttggcgagatttaagacttaagcctatggtaaaaatttgatag
-tgagcgactatagtaagagatttgggtggttagtaattaaaattctcctatgctaaatca
-ggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtgga
-ttatacaaatttcaaacatattggcggggcacttatccataatagatttctgtttgtacg
-ccaaactctgcctcacccctccataaattgtattggctagaggttaaattctccgtaaat
-agagacacatatagttttatacaattgtttgaatcaaagcacgagaaacttttaaccgta
-cattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctga
-gcaataagcaagaaaacacagattatacaaagagatctggatgaagatattcgtgcaatc
-actatcgttatgttagagagttccatgcatgaggactcgttttttgaccaggagaattaa
-gccaagaaataactgacgtatttccaaatgaattctacgtgtttttcctgtcacctttag
-ccagtgttaaagatgactatggagtttcgaataggttattctatagacattataacgagt
-ggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaaggg
-attttaggttcttaatccaacgaagaaataacgcatcacccgtcattctattgttttcgt
-cgggattacttagtaggcagggtattctaacctacctgagttacaaatctttaaaaaact
-ggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatat
-actagaatccgtctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcag
-ttttatagctatctagtggcattcctttttataaaactttacgtttgtaagggtccaact
-ttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgta
-tattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttc
-taatctaacaatgtaaagccggggattagccgccaaaggggtctaatgacatagagatgc
-tctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgacagatcttccgta
-ttctgttagttgacatctgtgctgtctttaccgattgtgatttggctttagcagtcattt
-agtttcgttactcattgctcgtgcgatagttccaccgaatatggcacattcgttcttttt
-ttccattttactgcaaaccttttcaaaagctgatcgataccactgatgatggcattgatt
-agtcgattggcaactatgtcctgcttatatctccaattgcattgaatatagtaaaaaata
-aaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaa
-gcgccgtacctaacatataagtgattgagacaaatagttctccagacgtattgagatata
-tgtctcctataggcaagcgtttctaattgctgaccagaaattagaattaggttgttaata
-ctatattcgaccattttattccacgaatgtgctattctactggtattgctccgtatgcga
-tatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtc
-atttaccgggagcgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaa
-agacttccgcttactatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtat
-aagaaaatcatcttttcagttcgcagatttttgccaatttaaccggttatttcgtcagac
-ttggtagtgtagttacaagcatcacgattatatcagctacagaattaaactgtcctgact
-cgacggggcagtgtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtc
-atagtacaaggataatgaggtttgctaactttaaaaattattgatttaacggttgattga
-aaatctctgcaagatgacgctagaacacctgatgttcaagtttgccgataataacatata
-agatgaattactgtctttagaccctcatgttaatccgctaacttagggcggaaacaatgt
-taggctatgcggagtaagtactatattatgataccacatagaatttaacattcatatgat
-gtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatca
-atgggccaatcctgtctcaaaaattatcatattcaaggttcagctattttggcaatgggt
-gagtaccgttcttagtgatttacgaacccataatctaggcgacttaatatacaagattta
-gagttacgttttccgggtagtacatattaacgaccatggatcgggtgaggtgttgtatta
-gttatctgatcttgtcagtagctcccaatgtcccagaatattatgtttctactagagtgt
-tcgtatactggaatttaaatattatgtaagactagacaaattttatggatacattaggcc
-atcgtagaatatgatatagttgtaacgtccctctatagattttcggagggcaggtatatt
-gcttaataaagatgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgc
-ttaaataagtttagactattaagctatatgttcgacagcatgtagttttttttaccagaa
-agtgttatactgatgacccatggaggtagctcctcatgataaaaatattgttacttaagc
-attactattatagtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtt
-tcttatgcagacacacttttttagctgttgacgcccacctcacatccatagtaggtcaat
-cgcataagaacaatattctggactgttttattacccagaagaaagttttttctttccggt
-tcgttaagacaataaagatcatttcattcgttctcttaacgatgaactaaagtacttaaa
-gtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaagataagaagaac
-aggaacgcgcacgtcggagataactctaatagtctctttattccgtttaatatagcccgt
-aattgcaccatgcgctacagtaacggccgccttcgcaaacctatttatgtaattccaagt
-ttaggtatgcaatggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcg
-gggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtg
-ttaccaacccctcactactacgcgaaggtactcgattattccttgaatgggctgaaacat
-cgtgattagcgtcttatgattcaggctgatagaagaaaacttattttctatattccacgt
-atacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaa
-atacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtcacataaataatc
-cgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtag
-cattgttgaacagtaaaactaccgtcacacaaggaatatcataatagatgccatacacgg
-ttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtg
-tgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatgga
-tgagcatttaggtattctatgataacactaaccatcatgtttctaaaatcctcaggaaat
-ttgtattattttaccaacctgtatttatagaaagtgcttttgacttaaagaagccgaagt
-gttcaaattaaggagtacctgattgaaagaatggggaattgtaatctgtaactcaattac
-aaataagccgttctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaatt
-catactcgattaacgactttaatactcttctgcgtatctacagactcatttaaattacgg
-aatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaataaggacacctg
-gtacaattggctggagtacaatgttggtttttatttgctgattatcccgatccctgtggg
-cgttggcataaccgggttttcttcaagactactttcgtgttgcttatatacctggtaata
-tcggtgagtagcttagggcttaatcacaatactaacaagttctctatggattggacaggg
-cggcatccgttgactgaacgatctattaatccattccctgcactggataaacaagaccca
-tttaaattgaccatagagatgttagcgtcatatttctgttcgtgatagggtacatatatt
-ataaacggattatgagcagtggttttctagaaaagcattcatagttaggagtgtatcaga
-tcataccactgaaccatagagcacaattctctactggctatacttcattcctttttgtcc
-gggtggggacgaaatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgct
-ggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttgactattgacagg
-gcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagatagagtacgggcc
-tataattcaaattcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtt
-tactggtatgtggtgtcaagccccacccattctctgttatatccgagcattaatgtagtt
-tcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctga
-gaagtggcactataatagtttagcctaagtcccttcgctaataactcaacaaagatgacg
-caaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatactgatagctctcat
-ggtaccaagaactttcataacctctttatttaccaaacctgttctactagcgttagtgtt
-ttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaa
-catgggatcaaaactattggcttaacgtttaatcgaatgagactagcactgtattactct
-ttcgtttcggcagcggatcaataaggaggtgacggcatcactctcttatagtagatatca
-cttattctcacaacggaagtaggatcttccgtcctcattaaatttgcaactggctcaatg
-taacactgtaatgttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtc
-cctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaaattccagacctc
-gagttacattatgaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttg
-taatataaacaaccgtttttgtctattttcccaaggagaaggagagtagcagcttagtgg
-cttgcctatatggccccctaagtacgtactcggcacgcttagaagattgggctaccccgc
-actatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatg
-agagtataaaaatatacaattttggcaggggttatacattgcgggcatgaagagtaacat
-tggacatgaacggacattcgaaccctgtgagtttaataccctatctccggatcattataa
-agtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaactaaattggtta
-tttttctttcatctagatttgtctgtatctaactaaattatagttccacataaagctgat
-tcaactgaagacataaatataaactttctaacatagtagcgaggaaagagctatgcctag
-catcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttttccagaatctag
-accgaacacagggtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaac
-aattccgttcgtattgttgctgtatctatatttcctacgtaaggctatttgatctataat
-atgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctcct
-tagtatcatcaaattatagattttacggccacgaattattggtctagatgtcccaaaaat
-aatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattat
-gctataccaagaactctccatccagtacctagaaaggcaggtatgtaccgctcattaatt
-ttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggcttttataatagaa
-actaagtttcccgaataacggtgtacgataacagatttttaggtgtacagacgtctgact
-caatgaacacacattgggacctgccccgggaggagtagtagataattaccttctccagcg
-cgggtcttttaatatcacaacataaaaatactaattaatatcacacaccctcatcctcga
-tggagcctagcatcatacacgtttgatagacaacgccaattttactgtaatatgatattc
-gaatctagtatgtggacgctgtaccacattgtttaaaggagctccctttaccgacatgaa
-cgaagcaagctttgtacaagatacgaagaactcagtactggtaactataagagacaattt
-atacataaaagtgttaagaccattatataaaaagaggtatgaggtctttgtaactacaat
-aatacattcatcgaacgatggagaataacagagttatttctgctgctcgagctctagttc
-tgctaatttctcaatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcg
-tacatccctctctcctactcttacctatatcctattactggttaacctacatctccggga
-aagacgtaggtaaagtggtccacgattgtattcacttataacacctagtagtactatgtg
-ttgctgagagtgaggacacacttactctacgagttcaagtccatatggacattacacttt
-ttcagcatctaggtgtcatgatgtattaacagccgttaggggctatttgattttatcgat
-tgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaataggcatgaaaattc
-aagattgcagttcctatcttgtataatctttcctttggacgagttgtaccatttcaacta
-acctgcaagtggggggtcatccatatgaagatttgccaaatacctggagaccctgaaaag
-tttatccagattaataataacaaacaaacctaagcgaagaacgtcagctttaataaacta
-tcactatcatagaaattcctgttaattgttcttccaaacgttgaatagactatcacgggt
-aatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgata
-actcaattatattcgatggagaattcatatctaccgcttagcttttaaaaattaagtcag
-attattccgccacaatgagaaggcgcgagtgcactaatcaaatcacttaggattattacg
-gacgtctgcattacaatgctttggggtagggttatacaagcatatgattctttaggtctc
-ttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgt
-tgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacctgttcatgaaaga
-caggagacacgaggcaccacctcaattctatgcaaaactctaacatagcgtggcactatg
-agtacgtgtaacgacaaggtctcatactcgatcctaagataattctcgtctggaaggttt
-taatctttaactaagagtagaacttagtttattgacttttacaattaggatacggttcgc
-gactctaccacagggcatcatacctggagctctgctatctcgtgaccaaagtggcagcac
-acatagggtcgggtcctgcatctactgagcaatccctttaagcattcctagtttgagagc
-catttagatattgctgtttaaaccgattaatggtttctattattataaagtgtaacgctc
-ccattcgggacattgaaaattagcaataagacaatgtatgatattcggcgagtctcaaca
-acattatggtctaccatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaa
-cacccatggttcgttaagtgagggtatccaggtgttataaggacgatctagaagtattca
-ggtacacggtgttcagacatgctctaattgtcaggttgtttataatttaacgtatcgctc
-tctattctaaataatataaaattaaccgctcgtagggatgctttccagtaaaagatacac
-tatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtacattcttaaactt
-aaatacgtattatttaaagtaaatatattatctaaaccgcttttgtctatccacatttcg
-tcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatc
-tatttcttctgattgatgtaatactgacccttactccgtacatacaaatgatggtaagca
-agaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtag
-cttgaaagggatatggatgtgtatgccaggcttcattttgacaatttttctgtcctgctc
-agtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgtagatccaatcac
-gctttcctacgctaatgaaagttctagatagtgtaggtgttagacagaggttagcgccta
-catccttacacacacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtat
-ttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaatgtcctgcccta
-gagttatgataaaataactgctgccctgtaacttaagtttacaaaccgatattcaatcgt
-tgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaac
-acagtgatttataaatacaaagagtacatttagttaccggattgcggcttgacatttatt
-ttacagaattttatcggcaaaacacttcatatgaactatcgcttcacgataagtctatga
-tagactagcattcgtagagaacaggaagagcaatcattatatatgaagtgttacagtggg
-tactacatatgagatcattaggtctatatccggccttcctcataagaccttggaaatatc
-ttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagta
-attcatcggacgtaatagtctggttttaactaggggttattgatatttaagctaaaagag
-ttccctgaacactcgaaatgtataatctatcccaactaaaaaagtatacctctaattcag
-aaatgtcattgagattagactgatgtcaatacgctaggaggtaagacaagtagaagtttt
-tgatttaggaattgaaatgtaatacctccatcttaagttctatattttaaagttttatgc
-ggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatgtttgcggccccg
-tatgagtaatgatctgtttatcaatctctagctactatcccacgaatgcactgatgccag
-tcatggcgcttacattagtcgacagaaatccgacgatacctatcacgcgtgaactgttct
-ggttcttattcaattcgaagtgatctcagatacattacggccatgcttgcccttcatgtc
-tgctgagcagttttgttataggctgaatctcctctaagcgaaattgataggatttttggt
-ggtcgatttagtctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaa
-tgatagggatcggctgaggaggataaatatacgctggtgcctggtatttatccagaacaa
-gttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaa
-ggccgcaaagggttacatctcaggatcgtggcgtatagtccaccattagttctgacttac
-ttaatatagactgaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtc
-ggttagcaaaacgtataggagcatgatcaaagaagagttaattaatagtactgcactata
-attgtcggcggagtaccatgagctgttgcccaattcgatgtttattaacagcacgcataa
-aaaatccagacttttcaattagaattaactataaatggtccgcgaaccttaaatgatcgg
-aaggacgggatctgccgttgtatagaccccaactctatctaatttttataacacctctgt
-aatcaacaaatcttattatgccatcattatgtcattcgccaagtaagtccagttcgagat
-tctctggaccgtgcaatagtattgtcaaattatggtaatggaatccttcttctaacaccc
-ttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgcc
-gtttctttttacgatgatagggattcttaaagcttttctctattctagatcccagttgcc
-atcatcaatatctcaattgatgctcattatatagttcttatttagtatgtccagatgtca
-ctgaagatcctgcctagaaccgatattctcgacaggatcatcagttcgacggggcaaacg
-cacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatg
-tggaaaaaaactcctgtccacgatatgtaggcaagttttactgcctttaattagtagtcg
-attagtgtagtttgatattatctaccttatagaatgtaaacagtaacccggccttaatgg
-tttggcaggattctttgtaaaagttaataatgttcataaactttatcagaaaacctgaag
-tagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgt
-cttgttgtccgagtacacatattgctcctctcccccactcttctaggaaaatcaattatg
-ctaacctgcagaccttcttctttactatctttaatgcatgcccagtatgttcatagggta
-gacttgctatctattttgtataatctacgaatgatgcttggggcgcgacttttaacaatt
-aagccgttgggtataatttgagagggtgccacgatagtaagagatttccggcgtgagtaa
-ggaaaatgataataggattaagcaggcgtaatagctcaccctcctcagttctccaaccct
-gaaccggctaagtatgactgtgcagtattaattttgaatacatattgcagcccctaggat
-acattatagatgtctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcg
-attgaggttaaattagccggaattacagacacagattcttgtttacaattgtgggaagaa
-aaccacctcaaacgttgaaacctacattcacaaatggattacgttggggatgagaatcga
-ttccggtcaaaaatcatgcccggagcaataaccaagaattcacagaggattaatacactt
-ctccatgaagataggactgcttgcactatccttatctttgtgtcttccttcaagcaccaa
-tcgtttggggacaaccacaattatgccaagaaataacggaaggtgttccaaatctatgag
-tccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggactttagatttggg
-tattctagagactgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaa
-aggggaccgcacgttgtgctagggatgtttccttaggaatccatacatgtaagaaagaat
-caaccgtaattatagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacc
-tctgggaaatagattgaatattctggacagcagcgaatcctgattatatctcaagcgaat
-atatgacccgcaagaaggatttatactagaataagtctaagaaagggcattgggtcactt
-cttccactaacacacttttatcagttttataccttgagagtcccatgcatttttatatat
-atttaactttcgttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaaca
-acggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttc
-tgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaa
-accgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttc
-tatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagttt
-gggttttggatttaccagtcttttagtttcggtactatttgatcgggacattcgtccaaa
-catgatggctcattcgttctttttttcaattttaatcaaaaccttgtatttacctgatac
-attaaactgagcatcgcatggaggtggagattcccatatatgtaatcatttgatatccta
-ttccattctttttagttataaataaacgctccactgcacaatgggagtaggacttcacca
-ataattagcatctactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaata
-ggtctcaacaacttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaa
-gtaagtagaattacggtcgtattacttgttgccaaatggttattactccaatgggctatt
-ctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagt
-ggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggt
-gatgaattattgttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaa
-tttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgcagagttttgcca
-agtttacaggtgatttactaacacttgggagggtacgtacaaccatcacctggttagcag
-agaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttatta
-aacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaa
-tttatggttttttccgttgagtgataatagctgcaacatgaagatagtaaaactgaggtt
-aaactttcaccatattaaattatatgttcaattacgcgatgtacaaactaatgttaatca
-gatttaggagcgcgcttaatatgggtccctatcccgactttgtacgagattttgataaaa
-aatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacaca
-tttaggatgctatttccctaagaaagcggaaaatcctggctcaatatttataatagtaat
-ggttaagattgtggcccaatcgctgagtacccgtcttacgctttttccaacacataatcg
-acgagaatgtatttaaatgtttgagacttacgttttccgcgtacttattattaaagtcat
-tggagagggtgtcgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatc
-tattggttgtttctaattctgtcgtccgtgtaggctatttaatttttatggtacacttga
-atatgtttagccataatgtagccaatactacaatatcagatacttgtatacgacctatag
-acttttgccgaccgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtt
-tgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgctatatgttactc
-tgaatgttgttttttttaccagaatgtgttataatgatcaaccatgcacgttcctactaa
-tcatataaattttgttacgtaagcttttctatgatagtggtctaaagactacccttgcat
-actttaagattaagacatgcactttaggaggaactcacacgttttgagctgttctagccc
-acctataagccattcgtccgcaatcccataactacaatagtcggcaatcttttattaccc
-agaactaacgtttttatttcccggtacgtatcacattaatcttaatttaatgcgtgagag
-taacgatgaacgaaagttatttatgtttaagccgcttcttgagaatacagattactgtta
-gaatgaaggcatcataactagaacaccaacgcgcacctcgcacattactctaatagtagc
-tttattcagtttaatatagacagtatttgaaccaggcgctaatgttaaggcccccttcga
-aaaccttgttatgttattccatgtggtcggaggatttgcggggcgatagcgctgggcggg
-gatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaa
-aaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccgaagggactactg
-tattccgtcttggggatgtaacagactgattacagtcttatgatgaagcctcattcatct
-aaaattagttgatttattccacggatactatcacactcctatagaaagagttaccaccgt
-gggaagctagatataataaataaaagacatacaatattagtatggctcatgatctacact
-tactcggatctctctttttttataaccagtagatcgcattacacgtattgttgttccgca
-tcaggccctaggggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaa
-gatattaatagatgaaatacacgggtttacttgatttctgttcagtcattcacgggaaat
-cctaggagtctttcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtct
-cgacggaattggtatttcctggcatcacaatttacctagtattggagatcacttaaaata
-atgttgagataataatcaggatatttctagtatgtgacaaacctctatttagtgattgtg
-attttcaattaaacaagacgtaggggtcaaattaacgactacatgttggaaagaaggccg
-aattgtaatatctaactcatgtactaagaagaagtgctttcgtttaaggctttctgtcta
-acattctaacgtcaattcctatgtaatactactgtaaccaagttattactcggctgcgta
-gataaagtctcatgtaaatgacggtttatctgttacttttgggtttcaacctagctagga
-cgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgt
-ccggattataaccatccctctcccacttggaatatcaccgggttcttaatgacttagttc
-gtcttccttattttccgggtaagatcgctgtggaccggacccattttgatctagtctaaa
-aaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgc
-actgcactggattaacaagaacatgttatagtgtactgacacatgttagactaagaggtc
-tgttcgggttagccgacttatatgtttaaccgattttgacaactgggttgagagataaca
-atgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatg
-gcttgaattatttaattgttctaaccctggcgtcgaatttttttggttcgaaaatactta
-gcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaa
-ggcagtattgtgactattgacagggaatcctaaaaagctactcgaattggtatatggaag
-aggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagct
-taactagtttgatggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatg
-ggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgtacactaggcagcc
-ctaatccaaaacttttgaggatgagtactgccactattatactgtaccatttgtaactta
-cattttatatcttcaaagaggtagatattgtcggccattactgtcacttacactaagggt
-agcttgattactgatacctctcatggtaaaaagtaatttaagaacctatttttttacata
-acctctgctactaccgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcac
-ccctataagcagaaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcct
-atgagaataccactcttggaatcggtcctttaggctgaggatatagaacgaggggaacgc
-atcaatctaggttaggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctc
-agtaaattgccaaatgcagaaatcttacactcttttcttaactaagtatgagagcaacct
-cactcctgaacagcttgttacctaacgagaagaggctttaagtagcctggagcctcaacc
-ggatatccggatttgactctcatccacttacatgatgattacggtcattacatctcatga
-ttttctgagtgccctatagactgggaatttaatctaccctgtttctatttgttaacaagg
-agaaccactggtcaagatgacgcgcttccatttatgccaccataagtaagttctcggaac
-ccttacatgattggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtgg
-cctatcatattcaggtcatcgagctcagtatttaaagattatatggtcgctgggggtatt
-cagtgcgcgatggaagactaacattggaaatcaacggaattgacaacacgctcactttaa
-taacctatctcaggataagtttaatgtaattagacggaactttctctaactccgtgtact
-aactctttgaaaataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaa
-agtattggtccaaataatcctcagtaaaatcaagtcataaatataaaatttagatcttag
-gacagaggaaagtgctttcccgagcataggatctggcctacgccagtagttcatgcttgt
-gttaaaagttgttactgtttatagtccgtactcagggtagtgttcgatactcagcgggga
-actgacatattacactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaat
-tacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgatt
-cgagtttgtaaattcacagatactgtgtatcatattattatagatgttaaggcatagaat
-tattggtattgatgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagt
-gcagcttggaagaactggatgtatcctataactagtaagagccttaaaggtactacatac
-ccagggatgttaccatcattaatttggccatcttcaatcttcgcaatgcatactttcttc
-tacaagatgccttttagaagacaaaataagtgtcaacaataacgctgtaacttaactctg
-ttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgcaaacgcaggact
-actagattattaaattcgccagcccgcctcgtttaatataacatcataaaaattctaagt
-aatatctcacacactaatccgccatcgtccatagcatcagtcacctgtcttacacaaaca
-catgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaa
-agctgctaccttgaacgacatcaaccatcctacctttgtacaacagaccaacatctctgt
-actggtaaatagatctgaaaagttataaatataactgttttcacattgatagaaaaacag
-ctatgtgctatttgtatatactataataaattaagcgaaacatggagattaaaacagtgt
-tttctcatcctccacctcttgttctgctaatttataattcttgatgccactcgtgtgagt
-cgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaacgagatcctatt
-tctcctgaaaattattagcacggtaactcctagggatagtggtactagttggtatgaacg
-tataaaaacttgtactactttctcgggatgtgagggagcaaactattactcgaccagtgc
-aacgcattatcgacagtaaaagttttcagctgatacctgtctggatggattatatgcagg
-taggcgagagtggattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaa
-agtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcattt
-cgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgc
-aatagtactccagaccatgaaatggttatccagattaataataacttaatatactttcac
-tacatactcagcgggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaa
-aaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgt
-aaaatatagtagaatatgatgttaaatcatttatattccagggagattgaatagcttacg
-attagctggtataatttaactcacatgattaagcaaatatctgtaggaccgagggaaaga
-ataaaataaagtaccatgagttcggaacgctgcattacatggcgttgggctagcctgata
-caagaagatgagtatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggc
-agatcccggagcagatgattatcgtctaacactgtctttaccaatgcacaacgcatagat
-ttaacctgaactgttctggattcactcctgactacagcctacaactcatttctatgcata
-actcttaaagacagtcgcaatatcagtacctctatacacatcggatcagactagatcata
-agataagtctcctctggatccttgtattctgttaagtacactacaaatttgtttagtgtc
-tgggacaattacgataagggtcgcgactagaccacagggcatatgacctccaccgctcct
-agcgagtctccaatctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcac
-tgtaagatttacgagggtgagacccatttagatatgcctcgtttaaccgttttaggcttg
-ataggatgagtttgtcgatccatcaaattcccgacattcatattgtccaataagtatatc
-tagcttattcggactcgctaaactaaattatggtataaatgccgtcaaccggtgcatttg
-ttcaatcaacaaattatagtcaatctcccatggggccttatggcagcgtatacagctggt
-ataacgaccatatacaactatgaacggactagctgtgaactaagcagattattggatcct
-tgtgtataattttaagtttcgatctatatgctatagtatagaaaatgttccgatcgtacg
-cttcctttacagttaaacagtctatatcatgaagcttatccaaagctggacatttgatgg
-caatcttacttaattatgaaacttaattacctattattgaaagtatttatatgatcgaat
-aagatttgctctataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaa
-cctaggtaatctaaagcctgcatctatttcttatcattcatgttatactgacccgttctc
-agtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaat
-aaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcat
-tttcaaattggttatctacggataactgtgcgatgaactactataggtcaaaattatctt
-caatctcattctagatcatataaagatgtccttcgcgattgatacgtctacagtgtgttg
-gtgttacacagagggtagcgactacttacttactaactctctcttgatccgcaagcataa
-gccaggttaaagtgctctatctttttctgtggattataatagttataccgccttgcatct
-aggtgcccattaggtaatgccctagtgttttcataaatttactcctgccatctaacgtta
-ctttaatttcccagattcaataggtctctcatttgaaaattgttatatgtcaacaaagaa
-tataatagctgagtggaacaatacactgtgagggagtaatacatactctaaattttcttt
-acggtttgcgcctgcacagttttttttatctatgtgatccgcataaaaagtaatttcaac
-gttccattcaagttaagtcttggtgacactagcattaggagagatcaccaagaccattat
-ttatttagctagggtttaagtcggttagaaatatcagataatgaggtctttatccggcct
-tacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaagtatggccgaacc
-cacataatgcacaaatcaagtcgatttcttccgtccttttagtctcctgggaactacggg
-ttattcatagttaagctaaatcagttaacggaactagacaaatgtataatagttcccaaa
-tatatatctataaatcttatgcagttagggaatgcagatttgaatcatggcaatacgcta
-gctcggaactcaactacaagtgttggatgtacgaattcaaaggtattacatccttatgat
-gttcttttttggatacttttatgacgacttccacgaagtgaaattatgttcgaatatctg
-aacagttacttggttgagcccaaggatgacgaatgttctgtttataattctcgtcataat
-ataaatacaagcatatgaggccagtcatggagctttcatttggactaacatttccgtaga
-gtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgttatcagatacatg
-acgcccttgcgtgacattcatggctcctgacatcgggtcttttaggctgaatctaatcta
-acccaatttgtttggattgtgggtcctccattttgtctgttaatgcttattaagattaaa
-aatgtactacgtatttagacctaatgattgcgatacgctgtggaccattaatataagctg
-cgccaggggatttttccagatcatctggcctgtgtatatgttcaaatctaatagccgaga
-gaaattactccgacggaaaataaaggcagataagcgtttcagagcaccatcgtggcgttt
-agtcaacctttagttcggaatttattaatatacaatctcactctttggacgagctcctta
-aaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaaca
-gttaaggaatacgactgctctataattgtccgaggagtaccttctcatctgccaatagtc
-gttgggttggaaaacaacgcattaatatgccacacttgtcaattagaagtttctataaag
-gggacgagtaactgatttgagacctagcacggcagaggacgttcgtgtgacaacatctct
-ttataagtttgagataaaatcgctaatctacaatgattatttgccaatcattatcgaatg
-cgcaaagtatctcctgttcgtgattctagcctaaggccattactatggtcaaattatgct
-aatcgaagcagtcttctaacacccttagaaaagcaaacactattgaatactgccgccgca
-ttcgccagcaccaacataactgcacgtgcttttttccatgattggcattatgaaagattt
-gatctatgattcttaccagttgcaatattcaatttagcatgtgttcctaattattgtgtt
-attatggtctatctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcagg
-atcatcagttcctcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaag
-caatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcg
-tttactgccttttatgaggagtcgagtactgttggttcatatttgctacatgattgtatg
-taataacgatcccgccctttatcggttcgatcctttatggcgataagttatgaatcgtca
-gtatctttagatcaaaaactcaactagtacccagttccccggaggaacggtcatgattaa
-tgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccac
-tcgatgattggtatagctatttgccgaaaagccacaacgtattcggtactatcttgtttg
-attcccctgtatcttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatc
-ctgggggcgacacttgttacaattatccagttgcgtttaatggctgtgggtcacaagatt
-gttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagct
-cacccgcctaagtgatccaaccctcatcaggataactatcactgggcagtattatttttg
-atttcatatgccaccccctaggagactgtagtcatgtatctttcttacccaatctagccc
-gaaacaagaaagaatgtcgattccagtcaccttttattagaccgatttacacacaaagtg
-tcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacgacttgctctattc
-gattaccttcgcgatctcaatcgattacgctaaattttaatgcccgctgaaatatccaac
-atttaaaacaggattaattctctgatccatgaacttaggactcattgcacgtgacttatc
-tttctctcttaattcatgctccaatacggtgggctaaaccacttttatcacatgaatgta
-cgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatc
-ttctattgggacggtacatttcggttttatagactatgtagttacacggcatcaacatgt
-aattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggag
-gattacatacatctaagaaacattctaaactatgtatagtcgtttacgacccttgtagta
-cgtgcatcccttggcgaaaagtactctgggtattagagtgtatattatcgacagcaccga
-atcctcattttatagcttgacaatttatgacccgaaagaaccttttataagtctataagt
-atatctaacgcaattgcggcactgagtccactaactatctttgagcagtgttatacagtg
-agacgccatggaaggggtttatatattttactgtcgttccctaaaaagttaattatcaga
-cctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccatt
-ccagtcgagatcaaccgtttctgcggatcgcgttacattccttgcttatttgcgataaat
-cgatacaaccccattaccagaaaaacccggagaatcaattactctgcagatcttatacta
-aaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgtggagcgttgggg
-taagagcggagcgattttaactttcgcttttccattttccagtattgtactttacgttat
-atttgagcggcacattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaat
-caaataattgtattttcagctgactttaaaatctgcagccattggaggtggagattccaa
-tagatgtaagcaggtgatatcatatgcaattcttgtgacttattaagataccagacacgg
-cacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaattccgaacgtaaga
-tatgtttacggatgcactaaaataggtagcaacaacgtttctctgagatgtataagttac
-caaacactggagaattccgctaaactaaggacaatttccgtcgtattaattgttgacaaa
-tggttagtaatacattcgcagtggataatccgttgcatacctagcactgagtgtaaataa
-aaccaatcgactactggcatttcgggctaacgactagatgttagcctatgtgaaagcctc
-acacatgcttattgccttcacggtgagcaatgtttcttattcgttattagaagtcacctg
-tagagacagtagagatgacctaaatttggtttgtccagtcccgaggtgatctaatgatta
-ggttaacttagaacagtggtcaattggttaaagctgatttacgaacacttccgaggggtc
-gtaaaacattaaactggtgagaacagtatgatgtattcggtcatctagacaaccccatcg
-ctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcct
-gttgctccggggagatagggttaatttaggcttttttacggtgtggcatattagctcaaa
-catcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaag
-cgatgtacaaaataagcttaataagatttaggtccgaccttaatttcggtccatagcacc
-tctttctaagtgttttgcttaaataattgtattgttattgattttctgcgagttgaacac
-ggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaa
-tcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccgcactaaacggct
-ttcgctgtttccaaaaaattttagtccactaggtatttaaatgttggacactgaacgtgg
-aagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgtactttgagcagat
-gctatcgtcagaaaaaggtaaatcttttggttctttataattctggcgtccgtgtagcct
-agtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaattacgtcattag
-ctgttacgtctatacgaaatatagactgtggacgacccatcgtagagtcatgtagttaca
-tgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactgg
-tcaattggttcatagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagc
-ttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcctgttcgaggtta
-gtcgtataaagacgaaacggccttaatgtaacattaactattccactgtaggtggatcta
-acaaggttggacatgtgctaccaataagataagaatttcgtccgcaatacaatatctact
-tttgtagcctatcttggattaacaacaacttacgttggtatttcaccggacgtatcaaat
-gattctgattttaatgactgagagtaaacatcaacgaatcttatgtatctttaagccgct
-gcttgacaagtcacattactgttagaatgaacgcttcattactacaaaacctaccaccaa
-ctcccacattaatattatactagatgtttgaagtttatttgacaaaggttttcaaaaagc
-acagaatcgttacgaacacgtacattaaattgttagggtattaattgtggtcggtgcatt
-tccggccccatagcgctccgcggggagaaactatggccttcatgacagcccccccataac
-atctaggtaatggtcggataactataaacaaccctctccagagaactgtgaaaataaaat
-ctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaagactcttttcact
-attttcttgatgcctcattcttctaatattaggtgattttttaatccgagaatataaaaa
-gacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttt
-tgactatccctcatgatctaaacttacgcggagctatctttttgtataacatgtacagag
-aattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttat
-cgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacgggtttcgggatt
-tctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaa
-ggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtcc
-gaggattgctgataacttaaaataaggttgagtttttaataacgatttgtcgagtttggg
-aaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacgggtataatttac
-gacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactg
-ctttcctttatcgattgctcgagaacattataaagtctattactatggattaagactgta
-tacaagtgtttaagcggagcccgtgataatctataaggttttggtacctttatctgttac
-ttttgccttgaaacatacatacgtacacgggaatatttacctaaacgccgtatagtccag
-cctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgcccacttgcattata
-acccggtgcggaatctcttagtgactcgtcaggagtttacgcctttgagacctctcgaca
-ggacccattttgatctagtcgttataggtagagtgcctttcctatcgcaccattaccttc
-tagcaaacttagagtattcaatgaaatcatatcctgtttatactaaatgttataggctaa
-tgacacagctgacactaagaggtctcttcgggttacccgaatgagttgtttatacgatgt
-tgacaactcgggggagtcatttcaatgaagactgaggactcttgatcagattaaaacgct
-taatgactgataatttagattatgccgtgtattatttaagtgggcgaaccctcccctaga
-atgggtttcctgagaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaa
-cgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaa
-ccgtctactattcctagagcgaagagctatgttctgacacgtccccaatattaggcaaag
-gctccaaaagaacagtcaattgattaactacgggcttggtttctccgtgaatccttgcgc
-cgctataccacataaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgac
-cctcaacaagtacactagcaaccccttagcaattaattttgtccatcactactgccaaga
-gttgactggaccagttggaaatgacatttgatatattaatagagctacatattgtaccac
-tttactgtcacttacactaaccctagcgtgattactcatacatatattcgtaaattctaa
-gttatgatactagttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttca
-actaaatatttcactgtagccaaccactttaaccagaaggataccttaatgccgatataa
-tattgtccaggaaacgttaatactttcacaagacaaagcttggaagaggtactttacgat
-cacctgatagatcgaccggaacgattctatataggtttggtctgagaaatttgtagctaa
-aaccatgttccataggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttg
-cttaactatctatcacagcatcctaactcctcaacagcttctttcctaaagacatcagca
-ggtaagttgacggcacccgataacccagagcacgattggaatctaatactctgtatggat
-cattacgctaagtaaatataatgattttctgactcaaagttacactgcgaattttatatt
-aactggttctatttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatc
-caaaaatatctaacttataccaaccattacttctggcgcagaaaaacatagatatctgaa
-caatcgaccgttaagactgtctcgccgatcttaggaacctaatactgctcagtagttatt
-gtttatttgggccatccccggattatgtcagccatggaacactaaaagtcctaatctaac
-ctatggacaaaaagctcacttttataaaattgctcaccttatgttgattgttatttgtcc
-gaaatgtctataactcagtgtactatctattggaaaattatggccggagttttattgaat
-atacttttgtatgttgagaaagaatgttgtcgtaataattatcagctggaaaatcatcta
-atatatattatattgagatattacgacagacctaagtgctttcccgtcatgagcagatgg
-actaacactcttggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcc
-cgactcttacttactcagagcggaaatgactttttaaactaacgtttaaaggcacttagt
-atgcgtcagggttatttttttaattacgtacccttgtgcagagagtttagctattcgatc
-ctacttagtatgaaccatgagagtacaggttggtaattcacagagaaggtcgagaagatt
-atttttgatgtttaccaatactatgaggcgtattcatcgaaataattttatggctgcgca
-cttcacatacgcaggaagaccactgcagcttgctagatctggatgtatcattgtacttct
-aagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatggggacatattca
-atcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaa
-ctataaccctggaactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaa
-aggcccaaagcaaaacccaccactacttcagttttaaattagaatcacaccctagggtat
-tagataataattaaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaa
-taagtctccggtctttcacaaacacatggttaagcgatgtggttttgactagagacgttc
-gccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatcttacttcatacatt
-gcttaaacagtacaacttatctcttatcctatagagatctcaaaagtttgtatttttact
-ggtttcaaattgagagaaaaactgcgttctccgatttctatattattgtttaaatgatgc
-caaacatccagtttaaaacacggtgtgatcagccgactcagattcgtatcctatgttaga
-atgagtcatcaaactacggtcacgcgtacattacagagtaaactacacgaatgaaagaga
-taagaagatgaaagagttaataggtctcctgttaattatgagaaccctaactactacgga
-ttggcctactagtgggttggaacggatataaaattcgactaagttcgcggcatgtcaggc
-tcctaaatatgaagagaactcggcatcgaattatccacagtaatagttggaacatgattc
-ctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggc
-gttgtgaatattcttcctcagaaaaggactgttgagcaaggaattggattctgtgaacgg
-aatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgcc
-gcgcgcagacatatcttcttggcaattagtactccactaaatcaattggttataaacttt
-tagaatatctttatataagttcactacttacgctgcgggtagtatatttaaagtgatgtc
-ttaggaatcttatggcggcggaataaacggcttgactatagataccctaattctggcata
-accctgtaacgtgtgaagcatgctttaatagacgactagatcagcttatagaatggatat
-gactgccacattgaagagattaacattagcgggtataatgttacgaacttgtttaacaaa
-atagctctaccacacacgcatagtataatataaaggtcctggagttcgctacgagcctgg
-aattgcagttcccctaccctgagtaaacaagatcagtatggacctatcttctgacccacg
-tgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcggctaacactcgc
-tttaccaaggaacaaacaattgatggaacaggtaagcggctggattctatcctgaataca
-gcataataatatttgctttcaatatatagttatgacactcccaatatcactaactcttta
-caaatcggatatgaagagtgaattagagatggagccgatcgttccttgtattctggtaag
-tactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactca
-cgcattatgaaatcctccgagcatagagactctaaattcgccaagcaataagtcccgacg
-cgaaggatgagaagctcattgaactgtaacatttacgtcgggctcaccatgttacatatg
-cagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacataaaaggccccact
-ttcatatggtcaaatatctatatcgtgctttggacgactcgataaactaaagtagcctag
-taatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatatataacttccgga
-cgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcg
-gaactatgcagattaggcgatccttgggttgaatttttagtttccatagatatgagttag
-ttttgatatggttaccatacgtccctgcattgaaacttaatctgtatattgattgatcct
-tagcaatagcggcacatttctgggcaatatgacttaattaggttacggtttttactatga
-tggatacgttttatatgatagaataacagttgctatttaaacaggtactacattcaacta
-atactgtttcactattgtgtccaacatagggaatatattgcctgaatagatgtattatca
-ggcatcttttacgctccaggtagaactaattaaaaatgatccttagaaactttcaagcaa
-cataagctaaaagttacgccaattataagccacatcggtaggatcttcaggcattcccat
-atccttctctatcaatcccgtctgttgctaattggttatctaagcatatcgcggcgagca
-tctacgataggtataaagttgctgctatctaattcgtcataatatatacatggaattaca
-gattcatacgtcttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatat
-ctctctcgtgttacccaagaagttgacacgtgattgtcagctatctttttctggcgatgt
-taatagttataaacaattgcatatagctgcaaattagctaatcaaatactcgtttcttaa
-atgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagggcgctaagttca
-aaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtg
-taattatttctctaattggtctttacggttggaccaggcaatgggttttttatctatgtg
-ataccaattaaaagtaatttcaaagtgacattaaacttaagtattgctgtcaagaccatt
-acgacacttcaccaacacatttatgtattgtgctacgcggtatggcccgtagtaatttct
-gatattgaccgcgttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgt
-gtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgttgtattacgtcc
-ttttactagcctgggaaataccggtgattcagagtgaacataaatctctgaaagctacta
-gacaaagctagtatagttaaaatatatatttcttttaatattaggatctttgcgattgca
-catttcaagcatcgcattaacctacctccgtactcttctacaacggttgcatgtacgatt
-tctatgcgatgaaatacttatgttcttagtttggggttactttgttcacctagtcctcga
-acgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattct
-taggtttataattatagtcagaagataaatacatgcatatctggacactcttccacatgt
-catgtcgactaactttgaactacagtcatatatagactgttatctgatccgtatgtgtct
-attactactcttatctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcgg
-ggctttttccctgattataagattacactattgctgtgcttggggcctcctactttttct
-atcttaatcattttgtacattaaaaagctaagaagtaggtacaacttatctttcccatac
-gagctggaccattaatttaacagccgcaaggcgagttttaatgttaatctggaagggctt
-tatgttctaagcttttagcactgagaaattaatccgtaggaaattaatcccacataaccc
-ggtaagagaaccttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaag
-ctcactcttgcgacgagctccttaatacaggccctgcgttatattcgaccgtacctataa
-ctagaccaccatcttaaatgtacagttatggttttcgacgcatagagtatgggaccacct
-cgaaatgctcagctgcaaattgtactgggggtggttatcaaacatttaatatgaatctat
-ggtaaagtactagtttatagatagccgaacactaaaggtttgcagaccttcctcccctga
-ggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcgtatctacaatga
-tttggtgcaaatatttatcgattgcccaatcgttctactcgtactctttatagcctaacg
-ccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaattacttaaccat
-actcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgttttta
-cttgagtcccaggaggtaacattggatctatgagtcttaacagtggaaatatgattttta
-gattgtgttcagatttattgtcttattttggtctatctcatcagctatagctacataatg
-acgtcttaactgtttcgactaaccttcagatctgactaccccaaatacaacatagcaaaa
-gaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaag
-aatcgaaaacagatctaccattcgtggaatcaatttttggacgagtactggtcgggtcgt
-gcttatttgctacaggattgtttcgtataacgttcaagcactttagcggttccatccttg
-atggcgttaactgatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggt
-cccagcacgaaacgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagt
-ggaatatgtgtcatcagagacaaatagatgattcctatagctttttgcagttaagccact
-aagtaggcggttctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcg
-tgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagtttcaacttccgt
-ttattggctgtccctcaatagagtcgttctcagggcacgactctcgttcgttattcataa
-gtccagtttgatccacgaatacagaacacgcatatctgataataaaagcttaacgataac
-tttcacgcgcatggtttatttttgatttattaggcaaccaaataccagaatgtagtcagc
-gatatgtagtaaaatttagacaaacataaaacaaagtatcgccattacagtctcctgtta
-ggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgatttaataataatt
-acggctaaacgtattgatattttccaggaactgccccatctcatgagatgaccctaaatt
-ttattcacacctcatttttaattcttttatatcacgattatttatctgagcaagcatctt
-tgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgcta
-aacatattggttcaattcaatgtaagctacctcggaatttgcttgcactaagacggggaa
-gccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccgttggagtcacta
-tggagttacaagcattataaatctaaggaaatcgcagtatcagtccttaccccaaagata
-cttcgcattccctggggtacggaccatgaaatacttctttcatacatgataaacgatgga
-gactcggttaccaccctggtagttactccatcaattggagttaactaagatcgctattac
-aggctttattagccaatcatcacaagcctctttttagagattcacaagttagcaaaccaa
-agttcctttgataagtctttaacgagatctatcccaattccggctaggagtaaaatttat
-atatttgagatcggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtcc
-ttccctaattaggtaattttcagacctccgagagagagtagatcaacaacgcgttatact
-cctaaaatgcttgtcgataacatgacactacagatcatccctggatgagcatcgactttc
-attacttgattagttcagttaattcgtttcaaaccattttcaacaaaatcccccagtaga
-tatgtatatgcacatcttagactaaataacagttttcataccctgggatttgtgtcacta
-tctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactggccctgttccatt
-gtaatcgatgggacgggacgttatattgcagacccaaagtagtaataaattcagccatat
-ggacggagggggggaattgttaagaatataattcgattttcagctgaatgtaaaagctcc
-agccattcctcctccacttgacattagttcgaagaaggtctgagaattggaattgcttgt
-gacgttttttgtttccagacaaggaaatagcccagtaccaagtataatattatgacaata
-gaagcttaaattcacaacgtaacatatctgttagcatgctctaatagaccgagaaaataa
-gtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagt
-tcccgactatgaagtcttcacaaatggttagtaataatttcccagtggagtagaagtggc
-ataacgtgcactctctgttaataatacctttagactactcccatttcgccagaacgtctt
-gatggtaccctatgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtc
-gtatgcggtatttctacgaacagctagtgaaaggactgatgacctaattttggtttctca
-agtccagacgtgatattttgatgaccgtatctgacatctctgggcaattcggttaacctc
-tggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttt
-tagctaagctacactaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcat
-ccatgtgtacgaattcctaatactcttgctcagggcacttagggttattgtagcctgtgt
-taccgtctcgcatattagatcattaatcaacagtcttataatcaccgtaatcggtaaaca
-gttgttatttgttctgataggtagacagctaataaagatgctgttgaacagttacgtccc
-acctttattgccctacagtgaaactagttcttactctgttgctgtaatatgtctagggtt
-attgatttgctgccacttcaaaacggaaattaagtcattaacgaaaatggttccttcata
-ggtaaagatcaatccccaattgaagccagaaattttgagatgtcgattcctgatcattcg
-ccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttg
-tttattctggctcaaggtacgtggaacacgtagtattttgatactaatgccagacccgct
-acgatccctgtactgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgtt
-agaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacac
-agtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatactctgggcaacac
-acatacttctctcatgttgtttcttcggacctttcataacctttcctggcacatggttag
-ctgcacatcacaggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggt
-ggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatattatgtttatttg
-tcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttga
-tctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaataagataagaat
-ttactaacatttaaattttcttattgtcgagcatagattggaggaaaaacttatttactt
-ggtatttaaacggaagtttctaatgtttatgattggatgcacggacagtttactgcttac
-tttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgttcatgcttccatt
-aagttcttcttaaacttacacaaactacctaatttagagttgacgagatggttgaacgtg
-ttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtg
-cgtaggaattctgctacgtccattgcaggccacattcacatcccacccctgaatatatgg
-actgaatcacacacaccaaatttcatctaccttatcgtagcataactattaacaaacata
-tacagacttcgcggtaaataaaatatattagtacacaaccgtatactggttgaactattg
-cccagctttaagacgcttttaactaggtgcttgatcaagaagtattattatatgacggca
-gtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacgccgtagagacat
-ttttgttagatatgtatttctttttgacgagccagcatcttagtatctgaagacgagcta
-tatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagattaaccaaattcc
-ccagaattagtaatggcgccttatcgatttactaacgatatataacttgtgatgttgtct
-gcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctg
-gatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgc
-tatgtaatccattctaatgggtaagaggattcctcttatagtaaaatatgcttgactttt
-taagaaccattgggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttt
-tctacaactacccctattaggttacaagtaatctggctttcttgccacttggcgatgata
-gttagattcgtatttctacaacgcagttactgtatccatggcgcgagataattagatacg
-atttgaatttggatgtagactcgttactactgttgtagaccagcacgtgagtatctagat
-gggtttgctaccttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatat
-tttactataagcagtattggccaccctcgtattgcggcagggtgtgctcacctggttaaa
-atgaaagagaaaaattccattttaaaacccggaggaatctattactgacgaggaaggtgt
-ttaacccgttgagacatctcctaacgtaaaaggttcatattctagttattccgagagtca
-ctttcctatccaaacatgaactgatagcataatgacaggttgaatggaaagcatatcctg
-tttattctaaatctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttac
-aactatgtgttctgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctc
-ctagcgtcatctgatttaatagcttaatgtctcatattttacagtagccagtgtagtatg
-gaaggcggcgaaccagcccctacattgggtttcctgacataagtattacatatcacttgt
-ctgattacacagcaaaatcgctaaccttactttgcgcatgtagctattggaactttgggc
-tagtgtctatcccattaagtttaacagtagactagtccgtgagcgatcaccgagcttatg
-tctcgtacccaagttttggatttggatcaaaaactactcgatattcatgatctacgggct
-tcctttctccgggtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaaca
-tgtttgacacgggatagcgtagaaactaaacaacgaatagaccatccaatttgaatttta
-ttgggtccagcacttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatat
-taattctgctacattttcgaccacttgtatctcaaggacaatatcccttgaggcttttag
-cagaaagagatgccgtaattctaagggatgataataggttgggaaatttaagagcagtag
-taacggtcgcgggttcgaccttaaactatatatttaaatctagccaaacaagttaacaac
-aaccataaagttatgaccttattatattggcaagcttaacgttttaattgctctagtaat
-agagtggtagaggtaagggaccatcacctgattcttcctccgcaaccattatatagacgt
-gtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaatatcgaatggcaat
-tagccacattgagttaaatagttgaggatatttcttgcacagaatcagatctaatctaat
-gattcgttactaaacacttcaccaggtatcgtgaaggctcaagattacccagagaacctt
-tgcaatataagaatatgtatgcagcattaccctaagtaattatattctttttctgactca
-aagtgacaagccctagtgtatattaaatcggtatatttgggaaattcctcaaactatcct
-aatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccatacatgaattctgg
-ccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgccaagatattagga
-tcctattactcatatcgtgtttttctttattgccgccatccccggagtatctcacccatc
-cttctcttaaaggcctaatattacctatgcaaataaacatatattgttgaaaattgagaa
-cctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgactatatagtgcttt
-agtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaat
-atttttcagatcgaatagcttctatttttgtgtttattgacatatgtcgaaactccttac
-tcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtctcgttttacggcg
-gaatcttgagtctaacttatatcccgtcgcttactttctaacaccccttatgtattttta
-aaattacgtttattcgaacgtacttggcggaagcgttattttttgaagtaagttacattg
-ggcagactcttgacattttcgatacgactttctttcatccatcacaggactcgttcgtat
-tgatatcagaagctcgtgatgattagttgtcttctttaccaatactttgaggcctattct
-gcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttc
-atatccatcgttcattgtaattcttacacaatgaatcctaagtaattacatccctgcgta
-aaagatggtaggggcactgaggatatattaccaagcatttagttatgagtaatcagcaat
-gtttcttgtattaagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaa
-taaacgagatagattcattatatatggccctaagcaaaaacctcctcgtattctgttggt
-aattagaatcacacaatacgggttgagatattaattatttgtagtacgaagagatataaa
-aagatgaacaattactcaagtcaagatgtatacgggatttataataaaaatcgggtagag
-atctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagg
-gtaactattattaattaataaagggcttaatcactacatattagatcttatccgatagtc
-ttatctattcgttgtatttttaagcggttctaattcagtcattatatcagtgctccgagt
-tctttattattgttttaaggatgacaaaatgcctcttgttataacgctgggagaagcaga
-ctaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacag
-actttactaaaccaatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaat
-tatgacaacccttaatacttccctttcgccgaatactggcgtggaaaggttttaaaagtc
-gaagtagttagaggcatctctcgctcataaataggtagactactcgcaatccaatgtgac
-tatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgc
-ctggggagacatgagaccacccccgtggggattattagtccgcagtaatcgactcttgac
-aatccttttcgattatgtcatagcaatttacgacagttcagcgaagtgactactcggcga
-aatggtattactaaagcattcgaacccacatgaatgtgattcttggcaatttctaatcca
-ctaaagcttttccgttgaatctggttgtagatatttatataagttcactaattaagatca
-cggtagtatattgatagtgatgtctttgcaagaggttggccgaggaatttacggattctc
-tattgatacaatttgtctggcttataactcttaaggctgaaccaggcgtttttagacgac
-ttgatcagctgttagaatggtttggactccctctttcatgtcagtaacatttcagccgtt
-attgttacgatatgcttgaacaatattgatctaccacacacccatagtatattttatagg
-tcatgctgttacctacgagcatggtattccacttcccattcaatgagtattcaacatcac
-tagcctcagagatgatgacccacctctaataacgtcacgttgcggccatgtgaaacctga
-acttgagtagacgatatcaagcgctttaaattgcatataacatttgagggtaaagctaag
-cggatgctttatataatcaatactcaataataagatttgattgcattttagagttatgac
-acgacatagttcactaacgagttactattcccagatctagactgaagtactgatcgagac
-gatccttacgtcgatgatcgttagttatcgacttaggtcgggtctctagcggtattggta
-cttaaccggacactatactaataacccatgatcaaagcataacagaatacagacgataat
-ttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaagctatcattgaa
-gtcccgctcacaatgtgtcttttccagacggtttaactggttcccgggagtcctggagtt
-tcgacttacataaatggaaacaatgtattttgctaatttatctatagcgtcatttggacc
-aatacagaatattatgttgcctagtaatccactataacccgcaagtgctgatagaaaatt
-tttagacgatttataaatgccccaagtatccctcccgtgaatcctccgttatactaatta
-gtattcgttcatacgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattg
-ttacgtgacagagatagcagtttcttgtgatatggttaacagacgtacatgaagggaaac
-tttatatctatagtgatgcttccgtagaaataccgccactggtctgccaatgatgaagta
-tgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtataacagttgcgag
-tgaaaaaccgacgaatttatactaatacgctttcactattggctacaaaatagggaagag
-tttcaatcatgagagggagtatatggatgctttgtagctaaaggtagaacgtatgtatat
-gctgccgttcattcttgaaagatacataagcgataagttacgacaattataagcaacatc
-cctaccttcgtaacgatttcactgttactgcgcttgaaatacactatggggctattggcg
-gagagaagcagatcgcgccgagcatatacgagacctataatgttgatgatagagaaggcg
-tctgaattgatacatcgaagtacactttctttcgtagtatctctcgtcctctttctatct
-ccggacacaagaattaagttatatatatagagtcttaccaatcatgttgaatcctgattc
-tcagagttctttggcgggccttgtgatgactgagaaacaatgcaatattgctccaaattt
-cctaagcaaattctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaa
-tctggaatgacggagcgaagttcttatgtcggtgtgggaataattcttttgaagacagca
-ctccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaa
-gcaaatcggtggtgtatatatcggataacaattaatacgatgttcatagtgacagtatac
-tgatcgagtcctctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattc
-ccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctacta
-atgcctttgttaggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaa
-atttcttctacttggattaactacttttacgagcatggcaaattcccctgtggaagacgg
-ttcattattatcggaaaccttatagaaattgcgtgttgactgaaattagatttttattgt
-aagagttgcatctttgcgattcctctggtctagcttccaatgaacagtcctcccttctat
-tcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggcc
-ttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgc
-cggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtagttaaataaatcc
-atatctgcaatcgattccacaggtattgtccactatctttgaactactctaagagataca
-agcttagctgagaccgaggtgtatatgactacgctgatatctgtaaggtaccaatgcagg
-caaagtatgcgagaagctaataccggctgtttccagctttataagattaaaatttggctg
-tcctggcggcctcagaattgttctatcgtaatcagttggttcattaattagctaagtacg
-aggtacaacttatctgtcccagaacagctccacaagtttttttacagccgaaacccctgt
-gtgaatcttaatatccaagcgcgttatctgattagagtttacaactcagtattttatcag
-tacgttttgtttccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggt
-ctgaccaatgtaggaagtgaaaagataaatattgcctacacatactgaattcaggcaatg
-cgttttattcgaaaggtcatataactagaaaacatgatgaattcttatcggatcctttta
-ctagcatagtgttggcgaacacctcgtaatgctcagcggcaaattggactgcgggtcctt
-atcatacattttttttcaatataggcgattggtctaggttagtgattccccaacacttaa
-ggtttgctgacattcataccctcagcaacttcctctcaaaaattagagtgagttggtggt
-cttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttat
-aatcgtactctgtagacaataacccattgtagtgccgattttgtgcataatacaagaagg
-aggatataaaaatgacttttcaataatattggctattagcaacaagaaggagaatcctca
-ttaagttagcaaccgcagggggtactgcagtccaaggaggtttcattggagagagcagta
-tgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctgattttcctagat
-agaataagctatagctacttaatcaactcttaactgtggagactatcctgatgatctgaa
-taccccatttacaaaattccatatcaatgaggctaacgcttaaatttcatttctccatcg
-taacaaaaatcagcctttttatacaagacaaaacactgcttccattacgggtagcaatgg
-ttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaa
-acaaattttgacctgacataatggagcgacttatcggatgttgccgatctttagggtcat
-ctattaagcttatacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacc
-tagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaatacaggagtcct
-tttcatttttcaagttaacaatataagtaggagcttagagaggcttgcatgaaaatcgtt
-aggaattacagaataggcagagagtggggcgtgtagactacattcttcaggccccacaat
-atgggttataggttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcga
-accacgctcgttccttttgctgtagtccacgttcatccaactattcagataaacaagatc
-gcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaa
-acaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaacataattcattc
-tttcgactggacacgctaaggtttggacaaactttgtatctatatctggaggcctgtatt
-ccagcccttcttttaataagatttacggcttaaactatggatatttgccaggaaatgaca
-ctgctattgacaggaacataattttgattcaaacctcattgttaattattttatatctcc
-tgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaa
-tgaatcataatagaccggcccctattaatattggttcaattctttcttacataacgcgga
-atttgattgcacgaacaccgggaacacataaccgtatagcgcccgttatgctagtgccta
-gcgactgggaccgtggagtctatatcgtctttctaccattattaatctaaggatatacca
-ctttaagtcctttcaactaacataaggcgcattccatgcgctaaggaccttgaatttatt
-atttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagt
-gcagtttactaagagccctttttctggcttgtggagactatcataacatgaagatgtttt
-gacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaa
-ttgccccatagcaggaatagttatatattgcagatcgcggtgtaacgcactccaaatcca
-tcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatcaaagcacagtgag
-agttgagcaaattacagttatacgacttaattcagtctccataaattgaaacgacacttc
-ttaacgggaggaccagacacgttcattaagtgaggagtgcactttttgactttaaaaaca
-tggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagttatttctgtttt
-aatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctca
-gagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtagttggcacaccca
-atggacgaataaatgctgccatatccacggagggcgggattgcggttgattttaaggcga
-tggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaattactgcgtacat
-ccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaact
-tcatagtataatttttgcacattacaagcgttaattaacaaacttactttgctgttagct
-gcctatatttgtccgacaatataactggatatctctgcgagaactgtaaattaacggcac
-ttggaacataatagttcctattggtaacgacgttgtaggcggcaattatccggtggaaga
-attgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagtataactttagaag
-actccaaggtacccagaacctcttcagcggacacgatcgctatcaatcaataaggattat
-tcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggac
-tcatcaaatttttggccgtgctaatcgacacacctgttattttcatgaccggataggaca
-tctcgcggaaattcgggtaacagctgggtagatataggacctcccctacgtattaatgat
-aagcctgtcataactagcttggtttaccgaagagacaataaacattcgagcgctcgtgcc
-aaactcggtgcattacgtttgaataaatcggtaacatgtactattactctgcctaacggc
-acttacccgtttgggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcg
-tttaagatcccgattaccgaaaatctggttatgtctgagcattcgtacactgcgtattaa
-gatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactc
-tgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggc
-tttatccaatatgggtccttaagtgctaaacatcattcacaatttcaagacagattgttg
-gtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaa
-ttatatgttgactaaactaccgtgtgtattctggctctaggtacggcgaacaagtacgat
-gtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagt
-aattccgttttattgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgt
-gccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagt
-taactaagtgtctatcgccaactaaaagacgtctcgatggttctttatgcggacctgtca
-tatcattgactggcacttgcttacatccaaataacacgtttgttagcggatagtcgttaa
-gtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctacatgataaatgaat
-aagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgtcgacgagttact
-actaaaggaatgtagggttctggatctatgaaaagcgacctccatatatatacgggccta
-agcggagtaaaataagtgatcaatggactaacattgaaatgttagtattgtcgaccattg
-agggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatggg
-atgcaagcactcgttaatgcttactttagttggttgcgggaacaacaggaggctatacta
-actggtagcgttcttgcttccattatgttattattataattaaaaataagacatatggta
-gagttgtagtcagggtggatcgggttgtctataacgttggaataatcaaaactatcgtta
-acaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacatt
-cacagcacacccctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatc
-cgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaa
-ttcactagtatcctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatc
-aagatgtatgatttttggtccgctgtgtggaatacctctattgatatacaagtgactttc
-tcggtaataacgcacttcacaatgtgttgtttcttttctatgtattttgcaagagaaaga
-agcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactg
-caggaggaacattatccaaattcaccacaattactaatccacccttttacttttactaaa
-gatatattaattctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaa
-ggataccaattgaagtcctcgaggcatgttacaacacacgacttccttccgtctattcag
-acactcaacgagactaacttttcctaggtaatcaatgatattgggtaactcgtggcatct
-tatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactg
-gctctcttgcgcaggggatacgtttattctacgtacccgatttggttactactaagcggc
-ctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagcagggaagggtta
-cagggagagacttattgagatacgattggaatttccatgtacaatcgttaatacgcttgt
-agaccagcaactcagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaa
-taagaaattactaaaaccctagttgttaatataagaacgattcgaaacaataggattgcc
-caagggggtgcgaacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgt
-ttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggc
-ttattctactttttccgacactcaatggacgagacaaacatgaacggatagctttaggtc
-tcgttgaatgcaaagaatagaatcgttattattaatcggtttccattatctatatgcggt
-atagatctccgagaggaccctgtaaactagctctgcggtttaactggtgctaatagaccg
-ccactatgttattgcttctagctcctagcgtcttatcatgttatacattaatgtcgcata
-ttggacagtagccaggcttggatggatcgccgacaaaaagaaaagactttccctgtaagg
-acttaactattacatataacttggatcattaatctgcaaattagagtaacggtctttcac
-cagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattgg
-cagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttgcataaatatctt
-atcgatattcaggttattaccgattccttgctaacgctagaagtcacaccagagtaataa
-taattccagacacctgtgaaataatcggtcactacggatagactagtaacgataatacgt
-atagtccataaaagttgaattttaggggctaaagatattagcaatactggtctagcctaa
-tcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaattgtatcgatag
-gaatagttacagtcacgcttgtagatgtaagagatgacgttattcttagggttcttaagt
-cggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaaacgatattttga
-aatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattttagtggcaacct
-taacggttgaattgatctactaatacaggcctacaccgaagggtacagataatgattctt
-actaccctaacatgatagagtcctgtcctatctcataggtcgacattttaaattcgtaat
-gagcaacgaagatcgtttcccaatttgcaacattcacttatagacttcaggttatttcgt
-gctaacattaagatagaatataatcagtcgttaagaaactattatccagctttcgtcaac
-cataaagattaaaaactgaaacttggcaagatatgaatagctatcctgctttaaccgatc
-gtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagag
-tgcggtaattaatattaatatactattaagctacacagcaaaggctgcaataatgttagt
-aagtagaacataaaggtattctccacaagtaataaatagtgtgagctaattgactaactt
-aactctcgcgacaagtgatgtggataagatgactcatatcgtctttttctgtagtgccga
-catcccacctggatcgaacaattccttctagttatcgactttgattacctatcctattaa
-acagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagt
-tagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatgagtctgggcgag
-cgtgactttctttcgtgtccgaatttgtttaacatccattagattagatgtttgtgtttt
-gggtctgatgtcctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagt
-ccgatgaagtctccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatt
-tagaacacaccttatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgt
-gagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagataagaatttctttc
-atacttcactggaatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcgg
-taaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtaca
-acgaacaaatagcatcaggccttcttatccagcgtgaagtctaattatttcacaagcttt
-cctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggatagaggacattgc
-atgtacgtaggactattctccaaggggtcttctattttgttagcgaaaattgttacagcc
-taatgttagagcggcgtacgactttataccagatactttcattagatatgcaaatatcca
-attaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgt
-ttttctagttcgttctcatatatatagatcaacaatgaataatctcatgatctataaccg
-atgtatatttatattccggttgactgctccggtgcaattcactacggacactaatgacta
-atatggcgcctttcatcagaaacgctaaatatgattaatgaattaagggagtattatcta
-attattagagagtagcagttagtctgatattttcggtgtatgtgttagccgttataatgc
-tgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttcactttatgactct
-ggttatatccctcggagaacaagaataagagtacgagaagttcggtcattgaggatgaaa
-tagaaccgctagacgaatggactcacgtttataaaactatgtatcacagtactacagcta
-actctgaagtccgagaagcttttgtaggacaaaacgttataagtacctttcgcagaatac
-ggccgtgcatacctgttataaggcgtagtagggacaccatgctatccctcatatagagct
-acactaataccattacatggtgactatcgtttacggccatcatctgtaagcgatcatgcc
-tcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttg
-agtcagaactattcgaagcttctcaatccttttccattatggcatagcaagtgacgactc
-gtcagccatgggaataatagcactaatccgattacttatgaattagaacccacatgaatg
-tgattctgcgaattgtctaagaatctaatgattttccggtgaatatggttgttgttattt
-attgaacttatattattaacatcacccttcgttagtgatagtcagctatttccaagaggt
-tccccgagcatttttaccattctctagtcatacaagttggagcgcttttaaatctttagg
-ctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttg
-catgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaatattcatagtaat
-aactacaatacttgatttgttacgtaatgctcgtacataacacaatcgtattccacggaa
-cagtaaagctctattattctgatcgagcctaagagaggatcacactacgctattaaagtc
-acgttcacgaaatctcaaacctcaactgctggtgaccagttatagacagtgtaattccat
-attacatgtcaggcttaagctaacccgagcctttatataagctataatcaagaattagat
-tggagtgcattttagacttatctatcgaaatagtgatagtaagagtttatatgacctgat
-ctagactgatgttctcttccacaacagccttaaggcgtggagcctttcttatactattag
-gtcgcgtcgagagccctattcgtaatgttaacgacactagactaatatacaatgagctaa
-gaataacacaagtcacaagataatttacaaatcatatatctacagtccacaaccatcact
-agcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaa
-ctggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaa
-ttgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagactatgcaactatt
-aacagcatgtgcgcattgaatatttggtgtcgattgataaatgccccaacgttccatcac
-gtctataagccgtgttactaatgtgtattagtgcatacctattcagaccatagttcaact
-gttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttcct
-taactgacctaaatgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagc
-caatgggctcccattgagctagtatggtgctttacctttgtaagtggtggctttccttgg
-tgtgctgactttaacacggcagagtgattatccgaagaatggataataagacgctggcaa
-tattggctaataaagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgta
-cctaaacctacatcgtatgtatttgctgacgttcattcttgatacataaagatccgatat
-cggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtg
-aaatacacgatggggatattgccggtgagtacaagttagaccacacattagaactgacct
-atattcgtcatcatagagatggagtatgaattgattctgcgaagtacactggctttacga
-gtatctagacgccgcggtatatctcccgtcaatactatgaaggtatatatatagaggctg
-aaaattcatgttcaatcctctttctaagagtgagtgggagccccttctgttgtcggagta
-aaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaa
-aagagttaccttagggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtg
-cgattaattcttttgatgacagatctcattattttatatagctccctctttgtatttaga
-gtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgctgaacattttat
-acgatgtgattactcaaaggataaggttcgaggcctctatactcatggaactatcttata
-attataatggatcgtggctcattccacctatccaaacttctttgtgatctgatgctacga
-gtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagctcgcatttcattc
-ctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaaggtgtagacaag
-cccttagtaaccggtggatgtcgcttcagttttatagcaaacattattcaatttcagtct
-tgactgaaattagtttgttagtgttagaggtccatatgtcacatgcatatggtctagatg
-ccattgtacagtaataccttagattagtattagcggcatgcgtacttggatttcacttgt
-aagaatgagcttaggacggtcgcctgtagggctgcaaataggaatacttacaatttttga
-tgacttgttagcatatcgctatcacccataaaaaacctgatacttgatgagcgggtgatt
-gagactatgtactgatataattcaatagctccaatagatgaaacagctatgcgcctattt
-atgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcgg
-tgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaag
-cttgagttcagttaaatttgcatctcatgccccacgaagaatgggtagagagtttgaagg
-tgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatg
-gttgtgttaaccacaaacccctgggtgaatctgattagccaacccagtgatctgatttca
-gttgtcaaatctcttttttataactaccttttgtttccataatttaaccggatctcataa
-tgaacaaacgggtagaataatggtagcacatagcgagcttgtctattcagaaatatggcc
-tactcagaatgtattctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatg
-atgatttcttatcggttccttgtactacaatactcttgcccaacaaatactaagcataac
-agcaaaattcgaatccccctccttttaataaatggtttttcaatatagccgattcgtatt
-cgttagtctttcaccaactattaacctggcatctaattaataaaatcaccaaaggactct
-ataatatgacagtcacttcggcctcttttaagacagttgattattgcaggtccgcaattg
-atggtgacatgcacaattagttagaatccgactatggagacaattaacaattgtagtgcc
-catttggtccagttgacttcaaccacgagttataaaggtattttaatttatagtcgatag
-taccaacaacaagcacaatcataattatgttagaaaacccagggggtaatgctctaaatc
-cagctttaaggccagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaac
-ttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagcaacgattatatc
-tggactagatcatgatgatcggaataaaacattgaaataagtccttatcaaggagcataa
-acattttatttaatttatacttcgtaaataaattcagaattttttttcaagacattaatc
-tgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagt
-aacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggctgccacttttag
-cttcttgacgatctttagcgtcatatttttagattagtcgaaaaacggaaaacaaactta
-acgaagctggttgcacggggtaccgagaaaccaaagagcaggacaactccttgatcggga
-agaactgaaatagacagctgtcattttcattggtcaacttatcaatataacgaccaccgt
-agtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttg
-actaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacgggttgccagcta
-cagatatactctaggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcat
-aatacttgtcacataaacaagatcgctgaattaaacattaaacagttagtgatacacaat
-cgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgta
-aatttagacaaacattattatttcttgacaatggaatcgataagcgttcctctaacttgg
-tatatatatctcgaccccgggattccagccattcttgtatgaagatttaaccatttaact
-atgcatagttgaatggtaaggaaaatgatattgactgcaacagattttggatgcaaaaat
-atttgtgaattattggttatatactggttgtatagcacaatcattaggtcctagaaggca
-tactcaacctcagcgagagagctagcatgcataattgtaccgcccatattaatattcctg
-aaatgatttcttacattacgcccaatttcagtcatcgaacacccccatcaatttacccga
-tagagaacgtgatcatacgcaataccctatgcgaacgtccactctatagcgtctgtatac
-aatgattattcgttccatttacaacgttaagtaatttaaacttacataaggacaaggaaa
-tccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaac
-taaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgtatccattgtggag
-aatatcataaattcaagatggggtgtcatgctattcggtcctaaacattcttaatggctg
-ttctattgttagtctgatttaaaatggaaccatagcacgaatagttagatagggctcata
-cccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttac
-ggtttgtgatcaaagaacactcacacgtcagattattacactgatacgaattatttcagt
-cgacagtaattgaatagaaacttattaacgccagcacctgacacggtaagtaaggcaggt
-ctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaa
-atgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacg
-actcacgtacaagatcacacatcacacgcgttagcgaaagcggaatggctaatacagccc
-tacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgagccaacctccccc
-gcattgcggttcattttaaggcctgggtaacatctatcgtttagataatcaaaggaatcc
-gactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttct
-ttaatcaataccatattgaaatcgtaatacgataattgttgctattgactacaggttatg
-aaaaaacttactttgcgggtacatgcatatttttgtaccacattattacgcgatatctct
-cagtgtactctaaattaaaccctcttcgaacattttagttcctattcgtaaacacgtgct
-acgcggcaatttgccggtcgtagaatggacaactccagttcaactgcatgtaactcatag
-ctcgcgttagtataaattgactagtagccatgggacaaagtaactagtcagcggaaaaga
-tccctttaaagatatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtgg
-tattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaatcgaaactactc
-tgatttgctgcacacgttaggtaatatcgcccattttcccgtataagctccgtacttata
-cgaactacacgaccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtc
-tattaaaattacagacatactccatatctcgctccttgaactttgaataatgcgctaact
-tgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacat
-gttgtcagatttatgattatctagttttagatcacgtttaccgataatcggctgtggtct
-gagcagtcctacactgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgac
-cgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagc
-aaaaggcttaaaccatttttacgatttttactatagcggtcatgaagtgcgaaactgctt
-gcaaattttctacacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaac
-atagtataccagggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccat
-atacctaacgccataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgt
-agcgctcatcagcacagactaactttttcagtttgagtcgccggagggacttcgagacaa
-gaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatt
-tctactattgtcagctgtacgactgtactaagtgtatagccccaaataaaagaagtatcg
-atgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaat
-cctggcttacccgattctccggaagtctgacctagagattgacgacggccgcgtattatt
-gagacctcttcaggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaa
-gccgactccgctacacgagtttctactaaaccaatgtagccttatgcttagatgaatacc
-gtcctaattagatattccggcataacagcagtaaattatctgttcaatggacgaacattg
-aattgttagtattctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataac
-ctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtg
-agggttaaacaccagcatattctatatgctagacgtcttccttaaaggatcgtagtatta
-taattaataataagaaatatggttgacgtctagtcagcgggcatacgctgctctatatac
-tggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgag
-ccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaata
-aaaaaaatgttaatagtacgtttacgacattttattttataataaagagaaactattaca
-cctattgatatgataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttc
-tacatggtatagacctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaa
-tctagtcatttactactgtctttcgagctattataccacttcactatgtggtgtttcttt
-gctatgtatggggctagtcaaacatgatgactatagctacaactcagagagcgggcgtgt
-taagagtatctcatgctagaactgcacgacgaacttgatacaaagtaacaacatttacga
-ttccacaaggtgactttgaagaaacatagtttaattctctgcttcgatcatttctataaa
-ccggtaccatcgcagcggatagatgcataacatttctactactccaggcatcttaaaaca
-cacgtagtacttcactagattaagacacgataagtgtataacttggcagtgggaagcaag
-gagattggcgaactcctggcatctgttacgttttgttcaggctcggttgttgataatgtc
-cgactcctgccatattgaagactcgctcgagggagatcgggattcgttgattataagtac
-acgtgttccgtaatactatgaggcagtgattcaaaatggcacttctgacttacatgacta
-ggtattattaccacggaagcgttaaaggcacactcttatggacttaagattgcaagtgcc
-ttcttctagcctgaattcgcgggttcaacacaaactctctttagacatccgttgcctaaa
-ggctgagacgtaggggcaaccctttaactatgtactaaaaaactagttggtaatttaaca
-acgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaa
-taggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggct
-ctaagagaataacctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaa
-aaaagctaagcatacatttaggtctcctgcattgcattcaattgaatcgtttgtattatg
-agctgtacagtagctatatcagctatagttatcccagaggaacaggtaaactagctctga
-gcgtgaaatccggatattagaacccctagatgggattgattctagctaatacaggcttat
-ctggttttacagttatctagatgattggtaaggtgaaacgcttggtgccttccaccactt
-aaacaaaagtattgcccgggaagctattttctaggtattataaagtcgagcattaatatc
-aatttgacagtaaaggtctttcaccagcttcatatgccatagggcccatactcgatttaa
-attgaacggtttaacgagtattggaactctcacttataactgagtagctatacgaaaaat
-ctggtccatttccagaaatttattatcgatttgctgcttagtacccaggaagtgataacc
-cttgaaggcacaacactgtaataagttttcctgtcacatctgtaatattcggtcactacg
-cattcacgactaaagataattactatactaattaaaagttcaatgttagggccgaatcat
-agtagaaattctcgtctagcctaatcggacttacctatgggctgtgaggatttatcagta
-tgtggacaaaaatgctagagataggtatagttaaagtcaccatggtacatctatgtgagg
-aagtttgtagttcgcttctttagtccgggcgtttgggatgacaactactatacgtagagc
-cgtactcaggattagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgt
-tgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaatacaggccttcac
-cgaaccctaatgataatctgtcttaataacattaaatgattgtctccgctacgagctctt
-agggcctcattttaaatgactaatgtccaaagaagagactttcccaatttcaatctgtca
-cgtatagacggcaccttagtgagtcatatcattaagatagaagattatcaggagggaagt
-ttctattatcaaccgttacgcaaccataaacttttaaatctcataatggcattgagatca
-agagctttcatgatggtaaagttcgtatgtgatgctggggagctagatatcggtatacca
-cttcggttgtggtaagcccgagtgggccgttagtaatattaatagacgattatccgacaa
-tgcattcgctgaaataatcttacttaggagaaattaatgctatgagccaaaactatttat
-gtctgtcacattattgactaaagtatctatcgacaaaactgatgtccataagttgtagca
-gatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatc
-caatttgagtaaattgcctattatacagataggcttgtttagtcagataaggttccgctt
-gaggtgctctaacttagcgagagttagaaagcctagtgagaggcattttggtgccaaact
-ccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaagttggtgaacagc
-cttttgattagttgtttgtcttgtggctatgtgctactatataagttagaacgcaaacta
-atctaatcagcaaagtaaaataggaccttgaacgagacggggtacgccgttgaggctcga
-gatagtagataaactagaggaatgtagataaaacattagctagggggtttagttactgga
-ttacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattg
-tcagtggacttaacaagttcgtgcataatgaaatcctatacggactttgcatatctctac
-cgactcatctggtcgtctatgcgggtaattgtattgctccaagtggatgactattttggc
-gtcccagcacatagtaaatgtaaatccttataatagcataagcaattattagactgcgtg
-aagtcttagtagttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtcc
-ccaaatcaccattgaggtcattgaatgtacggagcactattatcaatgcggtatgcgatt
-ttctgagcgattattgttaaagacttagcgttgagccccggaacacttgattacagattc
-tttaaggagttatccaaatatcattttaaataatagtagtatcgtgctttggacaataaa
-aaaagacccgttctcttatgttgttttgcgacgtacttctctgatatatacttcaactat
-gaagattctattcatcgataacccaggtatatttatatgcccgttcactgcgcagggcaa
-attatctacggacaataatgacgtagttggacccggtaagaactaacgcttaatatgatt
-aaggatgtatgccagtattatcttattatgtcagagtagaagtttctctgagattttccg
-tcgttgtggtacaccggatttggctctctttttagaactgagaactcggagtgtgtagtc
-ttgtttccttcaatttatcaatatgcttttataccgccctcatcaactataacaggacga
-caagttccgtcttgctccatcatatactaccgatacaccaatcgtatcaagtttagtata
-cttgctttctctcttctacagcttactcgcttgtccgagaagcggttggtgctcataaag
-ttagtagtaaatgtacaactagtagccagtccttacctgtttttacgactactacggaca
-ccatgagatacagaagttagtgctacaattataccattacatgctcaatatcgttgtcgg
-ccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatg
-cacaaaaacacactccccttgttgactaacatcttttacaagaggctaaatcattgtcca
-ggatcgaataccttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtag
-tatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaatatattcatttga
-ccgtcattagccttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtgg
-catacgctgcgatttcatacagctgccaacaccttttttaccaggctagagtcagaaaag
-ttggagccatgttaaatagttaccatcataaaccactgttgtctactagtctgatcagct
-ttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactgttgcgttactta
-ggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaa
-agtacacaagcctaggaataggaaaagtaaagctcttttattctgatagtgactaactca
-ggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgac
-cagttatagacagggtaattcaatatttaatgtctcccttaacatttcaccagcatggat
-tgaagatagtataaagttttacatggcagtcattgtgtcacggttctatacaaattctga
-tagttagacggtatttgaaatgtgcttctagcatggtatcttacacaactgaatgaacga
-ctggagccgttcgtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaat
-atagtataatataaattgtgatatgaataacacaagtaactacagtttggacaattaatt
-gttctaaactaaaaatcattcacttcagatggcatagagttatggctactacacatataa
-agcggtatgtgaaacacccgttttagccggaaaccctctactgctcgggacaatgaatga
-tttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaatagacactttag
-tttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatttggtctacattg
-agaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgtctattactgatt
-aactagtaagacattagtgcatctggtccactgaagcacccgcttggcgttaggcaatct
-ctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagt
-cgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggttcgtcctttacc
-ttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagactctttatcccaa
-gaatggataatatgtacatggaaagtgtccataattaagtcccttcactgtaaagaatga
-ctgccacgtgatccatgaggtctacagaaaccgacttacttgctttttgatcaacttaat
-tatggattcataaagttcagatatcggtacaattggtgtacaatatgaaattaatgagga
-aacatggaaatctgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgt
-tacaccactcattagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgttt
-atgccttcgaaactggatgtacgacgatcgagacgaagaggtatatataacctaaatact
-aggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggcgaacactgaggg
-ggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagt
-agaccggatctttgcggagaacaattcacggaacgtagcgttgggaaatatcctttctac
-cacacatcggattttcgccctctcccattatttattgtgttctcacatagaattattgtt
-tagacatccctcgttgtatggagagttgcccgagcgtaaaggcataatccatataccgcc
-gggtgagtgacctgaaattgtttttagttgggatttcgctatggattagcttacacgaag
-agattctaatggtactataggataattataatgctgcgtggcgcagtacaccgttacaaa
-cgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggt
-cgtttcatagagcgcattgaattactcaaaaattatatatgttgattatttgattagact
-gcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgaga
-gcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccata
-ggtcactggcatatgcgattcatgacatgctaaactaagaaagtagattactattaccgg
-catgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgat
-aataccaatacttacatttggtcagcaattctgacattatacctagcacccataaattta
-ctcagacttgaggacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatata
-gatgaataagcgatgcgactagttagggcatagtatagatctgtgtatacagttcagctg
-aacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaaccatatcgttcaca
-catgatatgaacccagggggaaacattgagttcagttaaattggcagcgaatcccccaag
-aagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcctccgtataagtt
-gagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatg
-agaatacacagtgtgagcatttcacttgtaaaatatctttggtagaacttactttgcttt
-aaatatgttaaaccgatctaataatctacaaaacggtagattttgcctagcacattgcgt
-ccttctctattcagatagaggcaatactcagaaggttttatccaaagcactgtgttgact
-aacctaagttttagtctaataatcatgattgattataggtgccgtggactacatgactcg
-tccacaaataatacttagcagatcagcaattggccaagcacccgacttttatttaatggt
-tgtgcaatagtccagattcgtattcgggactctttcaaataatagtttcctggcatctaa
-gtaagaaaagctcataaggaagcgatattatgacacgctcttccgccgctgttttgaaac
-ttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatc
-gactaaagttaaaatgctagtccacagttggtcaagttgaattcatccacgagttatata
-gctattttaatttatagtcgagtgtacaaaaaacatccacaataagatttatcttagaat
-aacaacccccgtatcatcgaaatcctccgttatggcctgactcctcgagcttatagcatt
-tgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtt
-tcattatgatgatacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaa
-ttatgtcattatcatgctccattaacaggttatttaattgatactgacgaaattttttca
-caatgggttttctagaatttaatatcagtaattgaagccttcataggggtcctactagta
-tcctacacgacgcaggtccgcagtatcctggagggacgtgttactgattaaaagggtcaa
-aggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatgagttttacatta
-gtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaagagaatacatac
-accaccacatagaattgttagcgatgatatcaaatagactcctggaagtgtcagggggaa
-actgttcaatatttcgtccacaggactgaccaggcatggaaaagactgacgttggaaact
-ataccatctcacgcccgacgcttcactaattgatgatccaaaaaatatagcccggattcc
-tgattagcaaagggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgt
-aatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatac
-aggttaatgttagtgatacacaatactcgtgggccatgggttctcaaataaaatgtaata
-ttgcgtcgatcactcacccacgtatttggtctaattatgttttatttagtgacaatccaa
-tagataaccggtcctattaagggctatatttttagcgaccacgcgtttaaacaaaggatt
-gtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaaatgagattctat
-cctaaagtttgggcttgatataagatttcggatgtatgggttttataatcgttggagagc
-tcaatcatgagctaatacatggatttcgctacctcaccgagagaccttgcatgaagaatt
-ctaaccaaaagtttaataggccggattggattgagttaattaagaccttgttcagtcata
-gtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaa
-cgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaatagttaactaatt
-taaaattaattaacgacatggaaatcacagaacctaatgctttgtaggagttatttatgc
-tgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagtt
-cagaaagtggtatccagggtggtcaatttaataaattcaacatcgggtctcaggatattc
-ggtcatataatttattaagggctcttcgagtcttactctgagtgaaattggaaacagtca
-tccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtg
-tcccgtacacaaggaaacttgttaccttggggatataagaaaactcacacgtctcattat
-taaactgagtacaatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagct
-aatgaaaagggatggaacgcacctcggatctgttgcactggattaaaatccgattatttt
-taaaaatattcagtgctagagcatatcaggtctacttttttatctggtatgtaaagccca
-cggagcgatagtgagatccttacgactcaacgaaaagttataacataactcccgttagcc
-aaagcccaatcccgattactgccctaccctaacgtctgccatctaaatatcgaacttgtt
-atgatcaatgtgactacctcccaccctttccccttcatttgttccactggggataagcta
-gcgttttcagaatcaatgcaataagaatagccaattgtctcacttcatcagagctcttgg
-caattccaggcgctacgtggttctggaatatattcatttttcaaatagtaatacgtttag
-tgttgctattgtctacacgtttggatattacgttatgtgagcggacatcaatagttgtct
-aactctttagtaagccagagatagcactcttagcgaatggataccatcttccataagttt
-agttaatagtccgaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcc
-tcttcaaagcaatcttactaatagatagagtttgttttaagggactactagaaatgggac
-aatcttaatagtatgacctaaactgacatttaaagatatatccaggtggcaagcataaag
-atcattgcgccacctccaccgtgggattacttatcagtcgatatcctatatgctaagttt
-gcgacggcagaatacaaactaagctgagttgatgctaaccttacctatgataccccattg
-gaccggttaacagccctacttattccaaataaaagaacttttatgctgtagaagctatta
-tagtgatgcctggtaacttcagtatattaaaatgacacacatacgccatatagagctcct
-ggaactttgaataatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggtt
-gcctaaagcccggtaaccagacatgtgctatcattgatcattatcgaggttttcataacc
-ttgacccattatcggctgtgcgcggacaagtacttaaatcactagtttcttcacctgctt
-atcggtaagaaataaggttggcaaagaatcgcataagacggacgtagagccgcagcgttg
-tgcgagtccaggtgcatgcgcagcaataggattttaaattttgttccatttttaatttag
-ccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggcctatgctactgg
-aacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgtatttttgcggcta
-gaatagtcagtcgcttggagccatataccttaccacttaaacgacgtgctcctgtagttg
-aaatataaacagaacacaaagactaccgatcatatcaactgaagatctttgtaactttga
-ggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgat
-tgggaccctaaatcttgacgaattgctaagaggctcagagctaccactgtaatttctcta
-gagcccataataaatgaacgatacatccgtaggtagcacctaagggattataatggaagc
-caaatgcagttaataatattatatactggcgtacacgattcgacggatctctcacatagt
-gattcacgacccccccctttgattgacacagcgtcagcattttgcaagaacgatcttctg
-catagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtataatttaccatgc
-ttccctgatgctgagtgcaatacactaagaatgagtttttaccccatatcaccagtattt
-gttctgttattgcgaagaaatggctatgctgagttggcgactaaagtcacccatcctttt
-tattaggtaaccccctcccttaaactaactgatttgctggagctgccctgcatacatata
-ctttatcatttatggacgtccgtgacgcttattatccaccatagtcgatatgctacacgg
-attcattaatggatcgtaggagtttaagttatatttactaagatcggtctcggctactat
-cccgccttacccggcgctatttacggccatttttaatatattgacggtaattattcctat
-ggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaa
-atattgagtccctaccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagt
-ggttattaaagactatctattacaccttttgttttctgtcgtagtatattaaagtctaga
-agccttacaggaaaatcagggttatacagccgatactccgcagcatgaatcatcgaggag
-gtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatac
-aaagtaaatatctcggctttatgtgattgggaggggcctactcaaacatgatgacttgac
-ctaataatcactgtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatg
-gttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaatt
-agctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttc
-tacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactg
-tataaagtggaagtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttct
-taaccataggggcttcttaatggcccactacgcacattttgttcaagcccgagagggaca
-tccccattacgggagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaa
-ggccactgctcaagttattgacgtgggagtattacatcggaagcctgaatcccacactat
-gatggtctgtacaggcctagggactgcgtctagacggtattaccggcttctaatcatacg
-atcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatttatctatgtaag
-tataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcac
-ataagccgctttagatttcacaaataccaatgcggttaaaaacatccttgagtcgtacat
-acaccatactcgcgttaaacggatataacagaagataataaatccggatgtggagtcggt
-gtaactatagaaagccaagtgaaataatgcttaccagtcatttagctatacggctttcat
-ttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccgatacttagaact
-cacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggat
-tcattatacataagacacgatgatctgctttttcaggttgcgagatgttgcctatcgtca
-atcgagtcctgccttacaccacttaaacaaaagtattgacagggaacctattttcgaggt
-attatatagtccagcttgaatatcaatttgacagttaacctagtgaaaatcagtaagagg
-aaatacgccacattctccagtgaaattctacgggttatcgtctagtccaactatcaatta
-taactcacgagatataagtaaattctcgtacttggcctgatttttattatactttggatc
-cttagtaaacaggaagggagaaaccttcaacgaaaaacactggattttgttttactctca
-aagctcttatatgacggaaataccctgtcaagtcttaactttattactagactaatgaaa
-tgggcttggggtggccagaatcatagtacaatttagcggatacactattcggactttcct
-atcggctgtctggttggataagtatggggactaataggctagacatacctatacttaaac
-tatacaggcgtcatctatctctgcaactttggagttccctgatgttctcccgccctttgg
-gttcacatcttctataccgacacccctaataacgattagtttgtgggttagagtaaatta
-atacggttaatattaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctag
-gcagagtatatgtcacgaagtataactaccctaatgataagctgtaggaataaaattaat
-gctgtctctaagcgaagagatatttccgactctgttttaatgacgaatctcattacttct
-gacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacgcatataatgaac
-ttagaagattataacgacggaactttatatgataatccgttacgattaaagaatctgtta
-aatatcataatggcattcagttctagaccgtgcatcatggtaaacttactttctctgcat
-ggcgacatacatttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaa
-tattaagagaagatgatcagaaaatccattcgctcaatttttctgacgtacgtctaattt
-atcctaggagacaaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaa
-tactcaggtcctgaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcg
-tgacataaatgaatgatacttttccaagttcagttaagtgaatatgtttaacatacccgg
-cttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctcttacatacactag
-tgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtatt
-gacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgcta
-atatataagttagatcgcattagatgctaatctgaatacttatagacgaccttcaacgag
-aacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagggacatataaaat
-ttgagtgcggctttagttaagggtttaattacctactcaaacatcacgctcgcgcccttc
-gtacgtaatcgaccatctagaggctaaggggactgtactaggtagtgattaatgatatcc
-tagacgcacgtgccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtc
-ctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaatacttataatac
-aataaccaaggatgagaatgactcatcgcgttggagttatattgcttgaagttctatgga
-atgaaagcacgttatctgccgtcccaatatctccagtgagctaattcattggacggtcca
-ctttgatcaatccccgaggagatgttcggacactttagtctgtaacacttagcgttgaga
-ccacgaacaattgattactcagtcttgaaggtgttttccaaagttcattttaaataagac
-tacgataggcctttcctattgatataaactacccggctctgttgttcgtgtgagtcgtac
-ttctctgtgtttttctgattatagcaagattcgattcttagtgtaaacagcgatttttat
-ttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagttgtgccacaagg
-taagatctttccagttattgcaggtaggatgtatcccacgttgatagtatgaggtctgac
-gtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgaga
-acgcagaactcccactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaag
-ccctcatcatctagatctcgacctcatctgccctcttgctccatcattttctacacagac
-tactttcctatctacgttagtataattgctttctatcttagtatcatttagagcttctcc
-gtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgtagcaacgcattta
-atcggttttcgactacttcgcacaaaatcagataaagaagtttgtcattctattagacat
-tgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaagactgtgattaa
-ctaaaatagacaagccactatatcaactaataaaaacgcccctggtggtcgaacatagtt
-gactacaggataattaattggactggagccattacattctctacaatcgtatcacttccc
-aagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacat
-tggtagttcaatagtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggata
-gtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttg
-gttaacaggatagtctatgtaaacttcgagacatgtttaagagttaccagcttaatccac
-ggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgtta
-tcctatcaacggttgccgtactgagcagccttattgtggaagagtaatatataaatgtag
-tcttgtctttacgaagcagacgtaagtaataatgacttggaataccaaaactaaacatag
-tggattatcatactcaagaactctccagataaataacagtttttacgatacgtcaccaat
-gagcttaaagattaggatcctcaaaactgatacaaacgctaattcatttgttattggatc
-cagtatcagttaaactgaatggagtgaagattgtagaatgttgttctggcctcgcatggg
-gtctaggtgatatacaatttctcatacttacacggtagtggaaatctgattctagcttcg
-tagctgactatactcaaggaaccactgctcaaggtaggagactagttccgaccctacagt
-caaagtggccgaagcttaaactatagactagttgttaaatgctgatttcaagatatcatc
-tatatacagtttggacaattatgtgtgcgaaactaaaattcatgctattcagatggattt
-cacttatgccttagaaacagatattgcccgagctcaatcaacagttttagccggaaacaa
-tcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtca
-cgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgca
-gcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaac
-tctgaagtagctcgagtactcattaaagtgtaacacattagtgaatatcggccaatgaac
-caaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaa
-agcatccctttacgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaa
-attctcatacgtgcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtg
-ttataccaactcgctttttaactactatgctgtagttctacaggcatagtggccagtatt
-ttctaacttctctggatagatgctctcactcctcatccatcacggcttcagtttacgtct
-tacttgcttgttcagcaacggatggaggcattaagtatcttcactgttccctaaaattgc
-tgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactcattgaatactgc
-cccagttgcaacctcacttaatctgacaaaaataatgactactctaagtgttgcggaagc
-agtctcttccacgagcttgtctgtatcacttcgtataggcatgtaactcgatagacacga
-acaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcgg
-atataagctggagatcactcacgcccacacaaggcgctgctacctctttattccaatgtg
-taagaatttgctaacttcatttctagaccgcagctttgcggtcataatttcacggtacgg
-acccttgggttagagacttgataacacacttcgcagtttccaccgcgcacatgttttagt
-ggcttctaacatagaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccg
-ttaagccataatcaattgaaagccccgtgagtcacatctaattggttgtactgcgcattt
-agctatcctttagctgactcgaagagattcgattcctaatataggttaattagatggctg
-ccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaatta
-cttatgagtagttccaagttcgctacgttatgagagagattggaattaagcaaatatgtt
-ttatggtgattttgggatgagaaggactgctaagtacggctactaaacaaatttctaaaa
-ccgccatctaccttatcttggagacatttaagttgtatatgtcactagtctagcttttgt
-ctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatct
-aagaaagtagtggactattacaccaagcacgaatgccagggaactgctttcttgctcagg
-acctcgcgacaaggtaccccgcataagtcctagaattacatttggtcagcaatgctgaca
-tttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttgctctagatctta
-tctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtgagggcttagtat
-agttctctgtatacaggtcacatcaaactccccctgtcctagtacagctctgagctttaa
-ttaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcg
-tatagggcaagagaagcaacaaacaactagcccgactcacgttcatccgccgtatccttg
-ttcagttcttactccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatca
-aaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttatcggctattagat
-agtggggtgaaagtaattggctggaattatgttaaaacgtgatattaagctaaaatacgc
-tacttgttgccgacctaattcagtcattcgatattcagttagagccaagaataacaagct
-tgtataaattgaacggggtgcactaaacgatgtgttactctaatattcagcttggagtat
-acctgaaggcgaattcatgtatcggccaataataagacgttgaagatcacaatttggact
-agcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagtacggtctctgga
-aaattataggttcagggaatataaggaagtaaagataattaccaagagatttttggtatc
-gctatgacccagaggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgca
-tatttgacggacttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaac
-ttcaattattactactctttttttcctagggtattgtagaggccagtggacaaaataaat
-caaatttaagatgtttcggacattaacatcccccgtagcatagaaatcatcagttatcca
-atctctcatcgagcttttacaatttctgctggcgctatggacagcatatgccgcgagacc
-tccgcaagactcacttgatcactgtaagtatcttcattagaggttagagcctatagttaa
-gctgctgacctagtaaaattggtattttctaattttattgctcaagttaaaggttagtga
-agggataatgacgttatttttgaacaatgggttgtattcaattttatatcacgaatggaa
-cccttcattcccggcataatactagacgacacgaacaagctccgatctatcagccaggca
-cgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaactt
-agggtcacgatgagtttttcaggactacttattacctattaataagttaacatgagcctt
-cataccccgtaagacaatacatactccaccaattagaattctgagccatcttatcttttt
-gtatcatcgaagggtatggccgaataggttaattagttactcctaacgtctctacaggca
-tgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagca
-tcaaaaatatagtccacggtttccggattaccaaacgcggcaaagagaaacattgtatcg
-acggagataacttaatacagaaggaaggggcatcttcgaatacggatgaataattctatc
-tgtttattctgacatcttgttttcaggttaatcttacgcattcaaatgacgcctgcccca
-tgcgtgcgcaattattttctaatattgacgagagcaatctcactccttttgggtctattt
-atgttttattgaggcacaagcctatacagaacaggtactattaaggccgtgagtgtgaga
-ctcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggca
-atccttaccaaaatcagatgctatccttaactttgggctgcatttaagatggcggttgga
-ggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagat
-cacacactcattccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagt
-taagtaacaacttgggatcgcatacttataaaaattatatgttaaactttcacaaacgct
-gaagtccaaagtaactagcccaaacgcctcgagagtcactaggtattaatggtgtttgag
-ttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaata
-aggcttgcttgcacggaggtatgatgtttactgactctacaaccctaattttccagtacg
-tacattcattccaataggttagttctcaaagtgctatacaggctcctcaattgatgatat
-gcttcagccgctctatggatattagctcattttatttaggaagcccgcttagaggcttac
-tatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttaca
-tagaatttgaattaaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatat
-tacatatagatataggatcattttttaaagctgtactaggtttgatcgacaatcttatgc
-tatactatatgatgtaaccctcataatcaataccgatcgtacgatcctagcataggtggc
-aagcgattttatgccgattattgtgttaaatagtctgtgagtgtgattatcagggctacg
-ttggtagaggggttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaa
-ctgatataataaatccccttacccaaacaccaatcccgttgaatcaactaccataacgtc
-tcccatataaattgcctacttgtttgcataaatctgaatacataacaccattgcaccttc
-ttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaacaatagcatttg
-ctagcaattattaacagctcttcgaattgcctccacataacgcgggagggtatattttaa
-tttggcaaatactaagtactgttggcgtcatatgctattaacggttggatattaagttat
-gtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagagcactcttagagt
-ttggatacaataggccatatgttgacttaagaggacgtaactacgccgtacaccattgtt
-caaccgacttcttggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgt
-gttagggtatactacaaatccgaaaatcttaagaggatcacctaaactgaaatttataca
-tatttcaacgtggatagatttaacataattcagccacctccaacctgggagtaattttca
-gtagatttactagatgattagtggcccaacgcacttgactatataagatctggggatcct
-aacctgacctatgagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagt
-aagttgttgctgttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaa
-acaaatacgcaatttagacagaatggtacggtcatgaatgacagtaattcgaagtgctag
-accaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatgg
-tgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagta
-tatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaaactttcgattta
-gtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagttta
-aatttggttacatggttaattttgaccgaagcatcgcactttatgattgataattggatt
-caatatgtcgccctatgcgaatgcaacatgatccacaatttggctataagacgtttaatc
-cgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaa
-ttataagtactccgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatc
-atctgaagatatttggaactttctcgacaaccaccctcgtactcaatacttacactaatc
-gacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcga
-tgagcgtacacgcttatttctctagtcacaattagttatctacgagacatcacgagggag
-caaataagcgatgttatggctacacataggcacgtatgaatatgatataagccagttaaa
-cagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaa
-gctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggatcaactagaagag
-aaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtct
-gtgtaaccaatataacatctatttgttatctgattgcctacttatggctttgcggtcgtg
-gcgactaatgtctccaatccttttgaggtcggtaccaactccctttaaattacgctgtgc
-aggctcatgcactgcatacatatacggtagcaggtagggacctcacgcacccttattata
-atcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattt
-tctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaagccaattttgaa
-tatagtcaacgtaatttttactatgggttccaccgaaacgccttgcacaactaagaatcc
-cataaaatatcgatatcaaataaaagattgtgtcaataccttcatatatattttttcggt
-tgactaacgtgaactaaggttaggggttttgtatgtctatataggaaacagtttcttttc
-tgtcctactttagtaaagtcttcaagccttactccaaaatcacggtgattaagccgttac
-tcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgt
-attagctagggagacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcg
-catactcaatcttcagctcgtgtcattataatatctctcccccacgcttttcactagata
-tgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctg
-taggggtacttaatgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagcc
-ctcacctgacttcatgtaaatggcttagaagactccatgatttaataaatactacgaagg
-aaagactggatctaaagataactctagtaaggccaactcccttcaatgctgttgccagtt
-ataatccaagagctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaa
-gttggttctagccagacagccacataccctgtacgggtgtattactaaaactggtccggt
-attagttcaccaagggaggaattaggcaaaggatctaggtatgcaagtcggagtattaca
-tccctaccctgaatccatcaataggttcctctgtactggccttcgcaatgagtattcaag
-gttgtacagccgtataataataagatagtgactatgaacgggaagtaacccgctcacctt
-ccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaatactcgaaaata
-aacaactggcaaattacaccgcacttaagccgcttttgatttatatttttccaatgcgct
-tttaaaaataattcagtcctacatactaattaagacccttaaacggagatatcacaagtt
-aagttttaaccatctcgactaggtggaactatagatacccaactcaatttatcattacct
-gtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttcacagcgaaactt
-cagtgtgaacagattctgagaaatcacctaaacctattagtcagagcacccggttagaac
-cagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgagatccgttgtaac
-gttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactag
-gcaaacccaacataggttagtcctatgtgatacgccacatggtatatcattttgtaacgt
-tacctagggataatcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggtt
-atagtctagtccaaagataaaggataaagcacgtcagagaactatattagccgaatggga
-atcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaa
-aatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtacctgtatactagt
-tactgtattacgtgtctaatgatttcggattggggtccccagaatcagacgtcattgtag
-acgattcaagtttaccaatttaatttcccagctctccttggagaactatcgccaataatt
-gcagtcactttccttttctgaaacgataaagccgtcagagttctctgcaacgttggactt
-acctgaggttctaacccactttcggttctaatagtagttaacgacacaacgaataacctt
-tactgtggggctttcacgatattttttcgcttattattaatggttacgtcataagctggt
-gtccaaattaaggttaccggcttcgcagagtagttgtatccaagtataacttccctaatc
-ataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtg
-gtatggacgttgctaattacttctgaagggaaattggtcattatggatacgtgtctacca
-tcaggtcggacgcagatatggttctgtcttcagttgatccaccgttctttataggataat
-aactgacgattaaagattatggtaaatagattaagccaattctcttcttgtcagtgaagc
-atccttaactgacttgctctgcagcccctcatacatttagctattcaaagtaccggctcg
-tttcaaactctcccacctttggaagaggttgtcaacttgataagtatatcatttacagca
-ttttttcggacgtacctctaatgtttcattgcagaaaattagttttttctatcgcacatt
-ttgcaagtaacgttagagacacaattatctgcgaatgaactgctagatctgacgaccggg
-agcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggta
-agtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagta
-atgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattc
-tcgagcccactcacgatatgtagggacgacaacttgtgcggcttatgaattgtctggact
-gcgggcgagggtccatatctccgaagttagaagggacatacctttagatgataagatcaa
-ttcttattgacgaaattcatccacaacggggaacaacttcaccctagacttacgtctgaa
-aagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctac
-gcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgt
-actacggaggcatgaatcatatactagaaccaagtgcctgtgatattaacaagatgatcc
-gacgcgagcaccgtaattctaggcataaaactccagcaatttgggggccgaaaacaaatg
-acgttagctaattaattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgac
-gtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctg
-tctcctatttcatgcgtacctcctagttgataattccccgagcagtggttaggacacttt
-tgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgt
-gaattagttaatttttatgaagtcgtcgagacgcagttcctattgatttattctaaacgg
-agatgtgcttcgtgggactcggaagtagatctgtgtttatgattattgctactttagatg
-ctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacct
-atagtttcaagttctgccacaaggtatcatatttacagttagtgctggttgcttctttca
-aacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttc
-aaccctgttccagagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgat
-agtttgcaagagccggtgttaaacacatattattattgttatccaactaatcggacctat
-gcataaagcattgtctaaacagaataattgcctatatacggtagttttagtgatttatat
-cttagtatcagttagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaag
-cgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctataaatcacagaaa
-gatctgtctcagtatagttgaaatggtattcagctagtgacgtgtaccaattatcatagt
-tcactcaagcaagacgctcattaacgaatatagacaagacactatatcatataataaaaa
-agaacatggtgctcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaa
-ttcgctactagacgatcaattccctacttgtcaaagttgaactggtacgttcttggaatt
-aaatatgattgcgctggaccaaattgcgacttcttgagtttcagggcaaacgattgagcc
-ggaggatgtccgtctcttacctttcttgcttatgataaacgacggtccctgtacatcact
-gggaattctcagcaaaaataattgggtaaatcgagactcgatgtattcggccacaaaggt
-gttagacgttaaagattattcaacggggcgataataggatcataaccggtatgcaagcgc
-attgaaagagccatgagatccttatccgataaacgctgcacggtatgtgcagccttattg
-tcgatcacgaatttataaatgtagtctgggctgtaagttgaagacctaagttataatgaa
-gtgcaataccaaatcgattcatagtggattatcagactcaagatatctcctgataaatta
-cagttgttaagatacggataaaatgagatttaagattagcagcctctaatctgtttcaat
-cccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttg
-attcttgttctgccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagct
-tgtgctaatctgagtatagattcgtagaggaatattatcaagcttccacgcctcaacgta
-cgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactatagtctagttgtt
-aaatgctcagttcttgttatattcgatatactcttggctaatttatgtctgagtatataa
-aattaatgatattaacttgcatttcacggatcccttagaaaaagattttgaccgagcgca
-ttataaacggttacaccgaatcaatagaagcatacccaatagctttctttgaatttattg
-cctgcgcaacttggctgactctctagatccgaataattctatatggtcgtgacgaaacta
-gttcattactgtttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaat
-tactcaatgatacgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaa
-atgtctgattatccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcga
-cgcgaggggaaccttatctaactatcattccatttaccgggtgactctcgatgcaggatc
-cgattgggataaattgcccagaaatggctcattcctgactaagggtaaggccgttctcag
-caagggaaccccgcgaatctaggcttataccatctagattgttaactacttgcctgtagt
-tctacagccatactggacagttgtttctaaatgatcgggattcatgctagcactcctctg
-aatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatggaggctgtatgt
-atcttaactgttacctaatatggctggtaattatcaaagtaaggaccttaatgccatagc
-gctagcaatcgctttgtatactgaccatgtgccaacctctcttaatctgtaaaatataat
-gtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctat
-agccagcgtactagtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctg
-tctctctacagcttattgatgaggattgaacatggacatatagctccccctcaaaagcag
-atgctacctctttattccattctcgaacatttgccgaacttaatttcgacaaacctgagg
-tcacgtcttaatttatcggtaacgtcacgtccctttgagactggataaatatattaccag
-gggccaacgagcaattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaaga
-cggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaacccccctctctcaca
-tcttatgcggtgtactgccctggtacatttcctgtacaggactccaacagtgtagattcc
-taagatagctgttggagttgcctcacgccagatcgaaaaactgaataaactagtgagctg
-agctgcagaaataccgcttaattacttatgactagttcaaagggacctacgtgatgtcag
-acattgcaaggaagaaattaggtttgtgcgtcattttggctggactagcactccttactt
-cccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtct
-attgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatg
-agcacagtatgcaattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggc
-ctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtag
-taaatgtccgaacctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcac
-ctaacccgattcctctacttagtagctttctttgattctcagaattgactgcaatatcac
-tgcacaattctgtgccattactagacttctctgtattaacgtctcatcttactaacactc
-gcctaggacacatctgagagtgaagtatttcaatacatttactgaaatcttcagttctaa
-aatccccgaataaggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccac
-tcaccttcatacgcaggagcctggggaacttagtaataactatttcggcagacaaagctt
-ataacaagttgccggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacg
-ctcacctggtataggctattagatagtgccgtcttagtaaggggcgggaattatcggata
-aactgatattttgataaaataaccgacttgttcacgacataagtcactaaggagatttta
-tctttctccaaagtatatcttccttggataatttcaaagcgctgcaatttaagttctgtt
-actagtttatgctgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataag
-aagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgta
-aactggacgagtaccctagatggaaaattatacgttaagccaagatttcgatgtaatgat
-aattacctacacatttttgctatccataggaacaagagctgttctataggctcgtggcat
-acgaacatttgctgccgctatgaatattggaagctcttcaactacagactctattcttaa
-ttgccgtcgaaaatgggccgaatcggctattattaatactcggtttttccgaggggattg
-ttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatttaaatacaacct
-tgcagacaatgaataagggatccaatctctcatactccttttacaattgctcatgcccct
-atgcaaaccttatgccgccacacctccgcaactctctcttctgaactgtaagtagcttca
-ttactggtttgagactatactgaagctgatgacattctaaaatggctattttcgaatgtg
-attcataatgtttatcgtttgggatggcagaatcacgttatttttgatatagcccgggta
-ttctattgtatagaacgtatgctacaagtcattccccgaagaagactagaagtaaacaac
-atgcgaccatcgttaagccacgcaaggctgtagctttatttcccgataacctatcttcca
-taaatagcggacagcaggatactgacgctcaacatcagtggttatggtctaatttttaac
-ttttaataaggtaacttcagcaggcatacacagtaactctttaatttataatcaaattag
-aagtctgacacttcttatatttttctatcatccaacgcgatcgcccattagcttattgtg
-ttactaataacgtatctaaaccaatccttttcaagctactgcctatattgtcaatatata
-caaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatac
-ccggaaatcacaaactttgtagacaacgagtgaaatttatacactacgaagggccagcgt
-acaagacccatgaattaggcgatatgtttattctgacatattggtttatccttaatctgt
-cgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaagattcacgactgaa
-atataaatacgtttggctatatttatgttggagggaggcaatagcctttactgttaaccg
-aagatttagccagtgagtgtgacactaaaacactggaataaatgcaggcgttcttctggg
-taaaaggtttagtcaatctcgcctataagttcatatagctctggatataattatctggcc
-catgcatttatcatggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtcc
-gaagtattccatgtacattaagatcactctctcattcatgcatcttggcttaacaaatct
-ggttgtccaagctttccaggcacgtatggtacaaattcggatcgaatacttataaaaatg
-atatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtct
-caagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagggattagttatgt
-tacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaag
-agactaacattattttcaacgacgtacatgctttacaatagggtacttatcaaacgccga
-gaaacgcgcctatagtgatgttatgattatgacccgatatccattggaccgaattttatg
-taggttcccagcgtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtc
-tctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaata
-cctttaggggtaacggccgctgatttcatatagatatacgataagttggtatagctctac
-taggtggcatccacaatcgttgcatttactatagctggttacaatcataatctataccgt
-tccttacatactaccatagcgggatagcgtttttttgccgttgattgggtttaagaggat
-gtcagtctcattatatccgattcggtgggagagccgttgttttcaaatcgcacactttgt
-gacataatgtacaagataacaaaactgatataagatataaactgtcaatatcaccttgac
-acttgaatcaaagtaaattaactcgcaaatataatttgactaattgggtgcagatttctc
-aattaataaaaaaatggcaccggatgggcttacaagccccttatcattcacttgtatcat
-gatttccaagaacaatagaatttgctagcaagtatgaacagagattcgaattgcatccac
-agtacgccggagcgtttattttaatgtggatatgacgatgtactgttggcggcatttgct
-agtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggt
-acaatctcagagaaagattacagtttggtttaaataggacttatcgggtcggaagtggaa
-cttaataagcagtacacaattgggcaacagacgtcttgcctattacaataggattacaat
-gcgttagatttcagacacgttcgtgtttggctattcgtcaattccctaaatagttagacg
-atcaactattatcaaagtgattctttgttcatcctccattcatgtaacagatggcacact
-acgcataacgccgaggaattttaacgagatttaagagagcagttcgggcacaacccactt
-gactttataacagctcggcagcataaacggtaatatgtgacaaatttccaaacgttataa
-gaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagc
-ctaacttatctattggttttgctataaaagaacaaagttacacagaatcctaagggcttg
-tttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaac
-cttaaaacaatgcgcagatattggtgatggtgactccgggtatgataatggtaactgttg
-accagcgcccacctcatcgaagtatagaaagtggttaggataaggatgagaccgaactta
-tttccggccataactttagattttctacctagtacacaacatcagggcggacacgaaacc
-gccatcacatcatataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcg
-aactttagcaggcatatggccattatatatggccccagagcagaatgctacagcagacaa
-aatttggatttatgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacga
-cagtgcacaaagtgtaagttacaattattactactcagcagcttctgcaatgataaaatc
-ttatcatacacgtcacatatgataatatctacttagggggaacgggctccacaacctaca
-tagtactcaatacttacactattcgacaggcacaccaaacctgtacagtcccaaaagatt
-gagtcaactttgcagtactgcagatcacagtaatagcttagttagcgagtcaaaattagt
-tttctacgagactgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgta
-tgaatttgtttgaagccacgtaaactgtacaaccttagagataagtctcaggctactaaa
-aacacgttgtggcactaacaggatcatggttgattcttacttattcggctgaccggccca
-ataagtaaccttcaactagaacagaataatcgggagtagtttaattcagtcaaggtgcag
-gtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattc
-cctacttatggatttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaac
-aacgaaattttaattacgctgtgcagcctcatccaaggaattaatagaaggttgatggta
-ggctccgaacgctccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcc
-tgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagataaaccatgaaca
-gcacagtgtgaacccatggttgattttaggctaccttatttttaatttccgttacacaga
-aacgaattccacaactaacatgccattaatttttcgatatcttataaaagatggtcgaaa
-ttcattcatttattttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttct
-ctttagaggtaaaagtggctttgatctcctacgtttggatactagtcaaccattactcca
-tttgatccgtgagtatcacctgtctaacatccagcattatgactcctcggcgaagaaaag
-acacacttcttagagtcgatgtgtattagctagggacacagttgtttaatacgatagtga
-gcccagggagggcagtgcgtcccccagtagatttattcagctagtgtaagtataagatat
-ctcacccacgaggttcaagtgatatgcagtcttagaataatacttatcctgaatttcgat
-attatgggtacttcaataatccgctagcgctactttatgtctcgttggacagcaggacac
-atggcagtcttaaacactaaagacatcacctgaatgaatgtaatgggattacaagaatca
-atgaggtattatatacgacgtaggaaactctggatatatacagtaatctagttacgccat
-cgcacttcattcctctggaaacttagaagacatcagctgtacgtggaggaaccagacccc
-cgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaatgacaatggaccg
-ctggagttcgtaaactcggaacgtagtactgcacaaacccagcatttagcaataggagct
-acgtatgcaactcccacgtggtaataccttcaagctatcaatatataggtgcctagctaa
-tcgcattcgcaagcagtattcaagcttgtaaaccagtataataattacagaggctctatg
-aaacccaactttccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgc
-ccgttctgttattacgcgaattgattctactccaaaattaaacacaaattatcaaccgtt
-tcatttatatttgtcaatgcagctgtttaaaataaggctctactaaattataattaagac
-acttattaccagatttctctagttaagtttgaaccagctcgactaccgcgaaagatacat
-tcccttctctatttttcagttcatctatgggtcagagaagcattgaatttattctattca
-ccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgt
-ttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctggaaggagtaaga
-agtatacagctgatccggtgtatccttcagtcatctgccctatactaattacacgacgca
-aggaaaaataggtttattttctaggcaaacccttcataggtgactccgatgtgttacgaa
-tcatgcttgagaatgtgctatcgttaccgacggataataacgatctccaatgaaccaaat
-gtagaatgtctattgattacccttttactattcgacttagagataggagatagaacctca
-gtgtacttttttagccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatc
-caaccctcttaaagtcttccatattatatcgttgttcgtggaatcgataacagatttgtt
-gacccatagtaaatgtatactagtttatgttgtaagtgtagattgttttccgattgccgt
-ccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatc
-ctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggtttagataaagccgta
-tgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcccttataatagta
-gtttaactataaaagtatatactggtctgtcgccctttcacgatttgttttaccggttta
-tgaagcgttacgtcattagagcggctccaatttaaggttaacggcttccatgtgtagttg
-tatacaaggataacttaaagtatctgttcagcgagctagttaagttatcctcgatagaac
-acaactcagaggtcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattg
-ggaattatcgatacctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtg
-atcctaccttagttagtgctgattaacggaacattaatgtttatcgttttgagatttagc
-caattctctgattctaactcaagatgccttatctgacgtgctatgcagcccctaagtatt
-ttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctac
-tggttaactatataatttacagctttgttgagctagttcctctttggtttaagtcctcaa
-tattagttggttcgagcgataagttggctagttaccttagtcactatattagatccgaat
-gttatgcttcatctgaagaccgccaccctccaaaatttcttttaagactcacttattgca
-aggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacgagtttccatatt
-ttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtcgctctacaaggg
-gacgcaattaagaaacagacatgctagtcaaaaataaacatagcgaggcaccactaattc
-ggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagtagttagttcgga
-catacatttacttcagatgatcaattagttttctacaaatgcttactctaccccgaaaaa
-agtcaccagactcttacgtctctttagtatccttccgtcttatataaggtcagtcccccg
-tttcggtaccctggaatttactaagaataatgaaacagcccccaaggacgtacgtttaca
-aatgatagaccagatcgcctagcttattccgacgcatgttgcatagaattgaaccaacgg
-aatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctg
-atagttcggccacgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcga
-gctcaagcaagcttacacttcctcggatattcagggaacttagtgcctttgaaagatacg
-ttgatcaacgaaaaattgataatggctcatatggaatgcctacctcatagtgctgaatta
-acacagcactgcggacctaacttttcgaggtttcaagttcacgtctcaaaacctaatagg
-ctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaag
-tgaatattctttttttctaaaagcagatctgctgccgggcactacgaaggagatctctgt
-gtatcattattgcttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgata
-gcacaacccaattcgatagtacatattgttgatacttcgcactaaaccgttcatatttaa
-aggttgtgctccttccttcgttaaatactggtgacttggtcctatctactattagctaga
-cctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagac
-atcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattat
-tcttatactaatattagcaaagatgcataatgatttgtattaaatgtataattgaattga
-taagggtcttttagtcagtgatagagtagtataaggtagacattagaactcttaaccgga
-cgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttact
-agtagtacctataatgcactgaatcttcggtcgaagtatagttctaatgctatgcagatt
-gtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaa
-tgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggggaattaaccaga
-ttgaaggccaatcctcacatgtaatgagataatagacgataaatgaaattcttgtaatag
-ttgaactgctacgtgatgggtattatatatgattgagatcctccaattgccgacgtcttg
-tcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcat
-aaacgacgcgacatgtacagcactccgaagtataagcaataataatgcgggtaatccaga
-ctagatcttttcggactcaatgcggtttcacggtaaacatgattaataccggagagtagt
-cgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgttgcagataaaacc
-ggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaa
-cttcaagaactatcgtatattcaagtccattaccttttagtttcagactggtggagctga
-ctaaagttatatcatcattttgtacactggtttagttaacgataatttcagatttaacat
-gaccagacgataatcgctgtatatccagttggaatgtggtttgccagaaaggttaactta
-taatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagt
-gtatttggagctgtagttataccgtgtgctaagatcagtagacatgacgagagcaatatt
-atctaccttacaagcatcaacggacgtctagtcggaacaaaagactctaaaactcgaact
-tcaggttaatatactatagttctgtattcagcagttattcttatattcgatattatcttg
-cctattggatgtctgactttagtatattaatcatagtatctgccatgtaaaggtgccagt
-actaaatctgtttcacagtgcgaattataaacggttacaaccattaaagacaacaagacc
-ctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaatta
-gtctatagggtcgggacgattctacggcatttctggttataatgacaacatggattgtgg
-cccgagaatcgctctttcattaattaagcaatcattacagtcttataagcgctacttccg
-agtggtagcaggtaactcgatataaggtcgcatgagccgaatagcttaaaaaacaggcca
-ccgaacattgatagagaataccgaccacagcgcaacctttgattactttcattaaattgt
-acggctcactcgacatcaagcttaagattgcgataatgtgaactcaaatggatcagtact
-gaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgctgttacaatata
-cagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttggttagaaatgata
-gccattcatgatagaaataagctgaatgataccagtatctttaactatgtagtcaggggg
-aagataacgatggtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgct
-aacgaagctacttaatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaa
-agatagtatgagctataatatatgctagtagagaactctggaccatcatctatatgaata
-ctgattcgagcgtgcaattactttagcctgcgtactactgactctacaaaacactctgag
-ataagtttgtagtcagtaagtcgctctctataaaccttttggatgaccattgtacagcca
-cttatagatcccaataaatagcacaggagacagagtttttcaatgctcgatcatttgccg
-atagtattttcgtctaacctcagggcacctattatttgatacctaacctaacggcccttt
-cacaatggagaaatatatgacatcgggacaaacacaaatggtgggtggccaggagatatg
-acatggtggcgtctctaagaaacacggactccctctaggcaaactcacgtaaccaatttt
-aatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggtacattgactggt
-caggaatacatcactgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgt
-ataacgcaatttacgacggacatcagatcaagttatacagattatttaagtatcacgtgt
-gcattgggacataagggatctcacacatgccttggaacatttttgctttgtgccgctttt
-tcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaacagaatgagaaa
-ggttagggctctaagttatcgtcgattgggatagacgagacatttgcgagcgccctccac
-ggatacgaatctcccatatcaatgtgaactggatgctatgcagtttagttcttacgtctc
-ctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacctaatacacaaaa
-ccgtcaaacattttctaattctaggtatgggccgatcataggagctaaggtgaaactcat
-aaatgttttgttagatctagcatcctaaaaagatgcatatactgagtagctggcgtgcat
-tctctcaattgtatcctttttaactgaactagtcggtcccatttcgtgactgagatctat
-taaccgataagattaataacactcgcattcgtatcagctcagagtgaagtttttcaataa
-tttgactgatatattaacttctaaaataaccctttaagcctcggatccgtttcccaatca
-catcaaaaattcttattccaactatctacggattaacaacgtgcatggggatcgtagtaa
-gaacttgttccgatcactttgagtatatcaagttgacggcccggttattattgaatagaa
-acattcacctgctaaattaaataccgcacatcggatacccgatttcagagggccgtctta
-ctaagggcaggctttgttcggtttaactgagatgttcattattttacagtatgcttcaac
-taatatgtaacgaaggacagtggatctgtctccatagtagatcttcagtcgtgaatttca
-taccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccct
-agtattctagacgaaaattttttctagttcatctgataatttgccaattcaaaaacaacc
-gctggtttcccggcgcattctctaaaatggaagtcgaacctagagccattatttgtcggt
-aacccatgagttccttcttttcagaagttaatacactgtggtcctatacagaggaaaaac
-agcggttatatacgatcgtggcataacaacattggatcaagatagcaatttggctaccta
-ttctaattctcactagattcggtattccactacaatatcggcagattaggattggatgaa
-taatcggtgtttaagtccggttgcgtctccaatctcctaatttttattaatattgatctt
-ggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaaagatagaagact
-catttgaaaatggatcatccacagatccaaacattagcaagacactaatccccaactagc
-tattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaatt
-ctttttgggctttgttcgatggtgattcagaatctttatccggtcgcttccctgtagcta
-ctttgtggggatattgcccggggattatagggttgagatcgtttcctaaaagtatttaaa
-ccaagtagacttcaactaaactacatcagaacatcgtgaagacaccatacgcggtacctt
-tatttaccgataacatttcttcaagaaataccggtaagcagcataatgaccctaaacagc
-tcggggtatcgtcgtagttttaaattttatttaggttactgctcaaggaataaaaactaa
-ctatttaatttataataatattacaaggctcacactgattagatttgtctataagacttc
-gcgatcccccattaccggattgtcttaagaataaactagataaaccatgcattttctaga
-taaggcctttagtctaattagatacaaaaaacacgatagttgcatccttaatttattgtg
-tcaaacctggaaccttttaattacccgcaaatcactttatgtcgagactacctctgaaat
-ttattatctacctaccgcatgaggacttgaaccatcttgtaggagttatgtttattagct
-aagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaatt
-gtttttagttgagtcaagactgatatataaataagtttccctagttttttcgtggtggga
-cgatattgaattgaatcttaaccgaagagtttcccactctgtcgcacaataatacacgcc
-aatatttccagccctgcttatgccttaatcggttactcaatctcccattgaagttcattt
-tgatctgcatagaagtttcgggcccagccttttttctgccaccttcctccaagctctgta
-gacgcactctaagattgatgctcacatgtattaattctacattaacataaatatataagt
-catgcatcttcgagtaaaatatctggttctccaacatgtcctggcacgtatcgttataat
-gcccatacatgtagtattaaaatgattgggttaactggatattaagatcatcgaaattgt
-aaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctcggaagggctatt
-acgcttacttccgttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcc
-tacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaactacttgctttac
-aataccggtcgtatatatcgccgtgaatccagaagattgtcttctttggattatcaaccg
-agatcctgtggaccgatgttttgggaccttcacagaggactccaggtagagctcgctttt
-gcattaatctaagaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatg
-gaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgagttattatacata
-tacgagatggtggtatacatcgaattcggggcatacactatagttgcattgtatttagct
-gctttaaataatatgatattaccttccttacataagacattaccggcataccctggtttt
-caacttgtggggctttttgacgatcgcactctcatttgatccgagtagggcggtgacccc
-tgcttttcaaatacaaaaatttcgctatgaaggtaatagattacttttcgctgttatgat
-agaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttg
-tgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatag
-aaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgccgacataggatg
-aaatcagattccaatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaa
-gttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtgcgatcaactatg
-aatctcggcgagttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatga
-cgaattttcggctaggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggat
-tccattttacaagacgattacaatgagttacatgtctctcaacgtagtctttccctagta
-gtctttgaactatttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgc
-cattcatgtttatgatggaacaataagaataacgccctcgtatgttatcgacagtgaagt
-cagcagttcggccaaaaacatattcaatttagtacagatccccagaagttaagctaagtg
-ctctaaaatggcctaaacggttatcaaagtaggtctaattactatactaacgggtgcatc
-gtaataactgctgtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaat
-gtgacaaagaagccttagcgattcttgcaaacttaggacttcggattctcaatcttaaat
-gtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcctgatggtgacta
-cgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaactattgatagtcggg
-agcataaccaggtgaacgtactttgttcacgacatttattgacatgttctaaatacgtct
-caaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaat
-gccggtagtgtcaaacttcatgagaactttagctggcttttggccagtatttagggacca
-agagcactagccttaagctgaatattttgccatttatctactgttataactttaaaactt
-ggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaaga
-acaagcgtaggaattgagtttatattatatttaaactaaaagatgatattagcttctgag
-ggcgatagggctccaaatcataaagaggaatatattattacacgattagaaacccacaac
-atacctcgaatcgcccaaaagtttgacgaaacttggcagtactccacatctcagtaatac
-agttgggagagtctcaaatgttgttttattactcaatgaaccaccctcataatttcactg
-ctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaatt
-acagataagtagatgcataataaaaaaaactgctcgctataacacgatcatcgtgcattc
-ttacttaggagcatcacccgcacaataacgtaccttaaactacaacactattagaccgag
-tactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgt
-gataatagtttgcggagaggattcaattattttccattgcacctactccactagattcga
-taaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaa
-gcatgtaagtgaaccgtcatccttccctaagaaacataaaggtttttaataatgtcgact
-gtgaactataactgcatcctttcctgacctactccggttccttgttgttatttctgaacg
-agaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccg
-ttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaaattaattttgcc
-ttttattttttttcaggctcgaaattaatgatttgttttttttgaccttctagttacgct
-aatatgcggtcgcctgtggtttctattgagtcctataacgggatgggatctaatacgttt
-ggttactagtaaacaaggtataaatttgataccggagtatcaactgtataacatcaagct
-ttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagcca
-ctaaggggtgtattacgatagtgacaccaccgagcgcactcactccccaagtagatttat
-gatcctacgctaagtattagatatataaccaaagaggttctagtcagtgcaactcttaga
-ataataattagccggttttgcctttttaggcctaatgcaatattcagctagcccttatgt
-atctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaaatataatctatg
-aatgttatgccagtacttgaataaatcaggttttttataagtccttgcatactctcgtta
-tatactgttagagtcttaccccatagaaattctttcatctgcaaacttagaagaattctc
-agctacggggagcataaagtccccaggatgttgacaaatacaacaaatgtggcttataca
-aacactccatatgaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaa
-tccctccattttccaatagcagatacctatcctactacctcgtggtattaaattaaagct
-tgaaatatagagctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccac
-gatttgatttacagacgctagagcaaacccatctttaaacatataagtaaaaattaaagg
-gtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgtttataagccata
-attaaaaacatatgttcaacaggttcattgatatttgtaattgcacaggtttttaataag
-gatctacgtaagtataatgaacaaactttttaccagagttatattctgtactttgaaaat
-gctcctctaccgccttagagactttcaattagattttttgcagttaatctatgcgtaagt
-gaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataac
-tgtaggtctaatataattttcagttttcgaacacataaccctttgaaaatctgctattta
-atgtctcacctgcatgcactatcttctatactgctcagaacggctatacgtcactatgct
-ccaagtgacgatttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaa
-gtgcggactacgtgctctttacaataagccttgtgattgggctataggttaagtcccata
-ttaacgatctccaatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaa
-ttacagatagctgttagatactcactctaattttggacaacaatcccaatcttggggtcg
-tctatcgcctgaagctcgtaaatccttccatcttaaacgattacatattatagacttgtt
-cggggtagagatatcacagttgtgcaaacattgtaaatcgatactagtttatgttggtag
-tctagttgcttttaccattccccgaaaaacttgatctactatttcgacaacagtaaactt
-gaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgtccactatatgta
-agtgtagctttacataatccactatgactgagatcattacggcctaggaaagcagcgtag
-aaaaaaagggcccggatattacgactgtaactataaaactagttactggtagcgcgccat
-gtatagatttgttttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatc
-cgttaaccagtccatctcgacttctataaaacgataaagtaaagttgatgttcagcctcc
-ttcttatggttgcatcgagagtacactactcagtgggaaatagatcggggttcctacttc
-agattgtattatctaggcaattgccgattgtgccatacctggataaaataagctacctac
-atgtgatgcttatctattatcgtcatactaccttagggtgtcctgttgaacgctacatta
-atctttagccgtttgagatgttccaatggataggagtctaacgcatgatgaagtttagga
-aggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagacgttataaataga
-aaaaaggtccttctggttctattctgctgaactattgaatggaaagattggttgacctac
-gtactatttgcttgaagtcatcaatttgacggggtgagagacatatggtgcatactttac
-ggactctatattttagatcagaagcttagcagtcttctctacaccccctcacgacataat
-tgcttttaagaatctatgtttgattcctctacgggaattcggatccgttcgcatgtgcgg
-tttatctaaaccaggggacatatgttcagctaaagcatacgaacactttgctaactagac
-gtatgtatagtagctataaatcccgacgatatttacaaaaagaaatgagactcaaatata
-tacatagcgaccctacacttattcgcaccctgatctaggcgatcctagcacccacacccg
-aaagtgagcactagtgtcttccgtattaaatttactgcagttgagattttagttgtctac
-taaggattactctaacccgtaataaggatcaagactcggtactagctttactatcattcc
-ctatgtgttttcctaactcacaagggtacgtaccagcctatgtaattacaataatgataa
-agacacaaaggaagtaactttacaaatgagtctccagttacactagcttagtccctccca
-tcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaagaacactcataa
-cgttggagtccaagaattagactcatagggcccccaacatttaatatgtactgtgagttt
-gaaggtgttctattgttaattcctgctcttgatacatgacacgtactccgtgtttaaggc
-ttcggactgactttctttcataagttgagcaacgaaaatttcagaatcgataagttggat
-tcactaactaatacggctgattgaaaactccactccggacctatatggtcgacctttata
-cgtaaccgatataaaacttataggctggtatatcgagccttcctagcgcaatttcggatg
-gggtttcttctactactcaacaacggaatagtctttgtttagtaaaccagagctcaggac
-gcccaatacgtaggagagcgctgtggagcatgtgtcattatggactggagcactcttaaa
-tcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaattttcttgatacg
-tcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcg
-tgctcagatatactattagcgactcatctcgcctaacacgcacacgtataaactcggaat
-gactgccgctcttacatattagaaatacagactacaccacggaagcattgggtcattctc
-aaccgctgtataaaagatgattagtcttataataagattaccaaagaggcagaatcatgg
-gtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatgg
-tactcaggacaaatattaaccggacgaagtggtttacgtcgtactttcactattagtagt
-aaatacaaggtaacaccggggaatagtactaaatataatgatatctatcttcgggagaac
-gagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgata
-caaccgattgttacttttgtctattcaaaagattgaatagttttttatacaaaagccgca
-tacttatgacggctagtatacagtttcatcccctagcatcaatgctatggacagtattga
-acttataggaaattcttctaatagggcaaatccgtcgtgatgcctattttttttcagtca
-catcctcaaatggcactagtattgtcgggatcccattaacaggctcaaccacgagctcac
-gcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaactcccatggataac
-caattataaggcccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaa
-tcatgttgaataccccagagtagtccagatgataaccgatgaaacacaagtctttctcaa
-tgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgcgacatctagttg
-tgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaacgccttgtaatt
-ttactttaagacgcctggtgatgtagattcttagataatcagtttgttatcggctgtact
-ttaccataatttcacaggtttcaggtcaagaagattatagctgtatatacagttccatgc
-tcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatc
-caatacatgccccgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagc
-tcgagtcaggacgtcagctagattagattccttaatagaatataccgacctctagtccga
-actaaactatagataacgccaacttcaggttaattgtctagtcgtctgtttgcagatggg
-attcttagatgagtgagtatcggccatattggttcgagcactttagtttttgatgcatag
-gatatgcaatgtatagctgaaagtactttatctgtttcaaactcacattgattaaaccgg
-taaacctttaaagactacaagaaaatattcagtgagggcaattttgtcaatcacaatctt
-ccagctagagatacttcacaatttgtcttgaggctacgcaacattagacggattttcgcg
-ttttattgaaataatcgaggggcccaagagtatccatagttcattttgtaagatttcttt
-acaggcttattacagcttcttcagactcctacatgcttacgagttatatgctagcatgtg
-aacaatagattaatatacaggaaaacgtacattgagagagatgaccctacacagcgcaac
-cgttgagtactttcattaaagggtaacgctctcgagacagcatccttaagatggccttat
-tgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaa
-cacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcggagtatcaattt
-cgccaatcttggtgagaaagcataccctttcttcagagaaagaagatcaatcataacact
-atctttaacgaggtacgcacgcgcatcattacctgcctccatggatctttaggatagcgg
-aaagtattggcagcgtattgtgatttcgttcctactttatcaatttcacattcatataca
-tgtcttttatcaaaatcgccaataagataggatgagctatattagatgctagtagagttc
-gcgccaacatcatcgataggaatactcaggacagcgtgataggacttttcaatccctaat
-actctctataattataactctctcttaagtttggaggcagtaacgcgctctatataatca
-gtttgctgcaccattcttcagcctctgatacatacaaataaattccacagcagtaagagg
-gtttaattgagacatcttgggaacttaggattttactctaacatcaccgaaacgattatt
-ggataccgtacctaaacgaactttctcaaggcagtaatataggacatccgcaataacaca
-aatgctgcctccccaggagttatgtcttcctggaggctatatcttacacccactcactat
-aggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataagagttggccggc
-gtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaagttctgtcctgt
-tcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatctcagcaagttat
-aaacatgttggaagtttctagtcggaattcccaaagaacggatctatctaatgcattcct
-acatttttcctgtctgccgatggtgccatcctattcaaagaatttcttaaaagtagatta
-aatgggacttttaacaatgagtaaccttacgcctctaagggttcctcgagtgccatacac
-cagtcaggtccgagccacatacacggagaacattctaacatagcattctcaactcgatca
-tttgcaggttacttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcac
-ggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttggtatgggaacat
-cattgcagctatggtctaacgcattaatgtttgggtacatcttccatcatataaacagga
-agagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagc
-tcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataa
-gatctcactgaacttttgaatgaatgtgaagcatatatgatctgctttaataaaacttta
-tccataggatacgtttccaaatcaattcaataattattagtcaaaatagataaggatgaa
-caacctgaaggccgatcggacgtagaaagtggtcccatcactttgagttgatattgttga
-accacacgttattatggttttcaaacagtctcaggatattgtatatacagataatccgat
-accagttgtctgacgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgtt
-cagtattttaaactaggcggcaactaatttggaaagaagcacagtggatatgtctaaatt
-cttgttattcaggcctgaatttaatacaccgcatagttaacttcgcggtagagttgttca
-tcatgcctcctctaagctaccacttctatgatacaccaatagttgttctacggaatctga
-taattggccaagtcataaacttccgctgcgttcaacccccttgctcgaatatccaactcg
-aaaagacagccttttggtgtccggaacaaatcagttacttcttttctgatgttaattctc
-tgtggtcagatacagaccaaaaactccgcggatttaccatcctccaagaacaaatttgca
-tcaacatagcattttggctacatattctaagtctcaatagtttaggttttcaactacatt
-atcccaacattaggattggaggaataatagctgggtaagtccccttgcgtctacaatcga
-ctattttttatgaatatgcttctgccgcacctatggttattaaaaaagtcatgactttga
-agaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaagagcatataatta
-gcaacactctaagaacattatagatatgatgatagcgatcgtcatgatgttatccggtca
-caatagtagcttcatcagctaattcgttttgccagtggtgacttgcgctggaagaatcgt
-tatacggtcccttccctcttgatacggtgggggcttattcaaccgcgtggattgggttgt
-catacttgcattaaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatag
-tgatcaatacatacccgcttcatggttttaaccatttaattgattaaagatattccgcta
-agaaccattatctacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccg
-taatgatcaacgaagtaaaacgttatattgtatgtagaataataggtcttggagctaaat
-gatgtgattggtagtgaagacttacccttacaactttaccggtttctcggaagaatatac
-tagagaatcaatgcatgggctacataagcactttagtctaatgagataaaaaatacacga
-gtcttccatcatgaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatct
-ttatgtcgtcaataactctcatatgttttatataacttcccaatcacgacttgtaactgc
-ttgttcgactgagctgtttgagctatgaggccgggatccggttgagctacatctatttgc
-tacaagaaaaatgaaagcacatttgttgggagttctggctacactcatagagaaataagt
-ggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaa
-cgctcgcgctaaagaattaaagcctttatttcctccacggagtagcccgtaatccggttc
-gaaagagaccattgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttc
-tgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatg
-cgtctgtaacataaatatagaaggaatgattcggcgagttaattttcgccttctccaaca
-tggcatccctacgttcgttataaggaccatacatgtaggttttaaaggtttgcggttaat
-cgatatttacatcatagaaattctatagtcaaatttacaagactctagatactcactcgt
-tgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaattt
-catatagtaagttcaaggcactcatacctccgtgaagagggtagatagactattaaagtt
-gtttaatagtacgtattgatggaaatgacccgtaggagatttaccactcaatccacaaga
-ttcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaaca
-cgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccgagataaatgagct
-ataacactgtatgtcttttgattgctataaaacacagaaacggatattaatttaggccgt
-aaccaacatctgttatttgacatagaacagatggtcctttacagcgtattccggccttaa
-tattgaggtccagtgtattgtcctcctttaaagaagttgattgtaactgacttaaataag
-acatgtcacccattcactgggttgcaactgctggccctttttgtccatcgcacgctaatg
-tgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggtta
-ttcattaattttagctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaa
-ctaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaata
-aagccataaccagccccggaatagaaaatgttaaggaaaggcgatcttctttgaattctt
-attgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaatctaacaccctc
-ccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaa
-tgtggttccgtcccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctc
-atagaggtaactggcctgtaatgtccaatgttaggctaccttctccaactttagtacaac
-gaataatgtccgattaacaaggagtcaatttgtcatgaccagttcattcaggtacttgta
-tctatacggacgcgttccagagtagtatttgaaattttgaggttctactgataagtttag
-ctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaataacaattaacaa
-ctcctaggtgatacactgtgaagtctgctgttccccaaattacatatgctattttgttca
-cataccatgaagttaagctaagtgctctataatggcataaacggttatcaaactagctcg
-aatttcttttattacgccggaagcggattaactgctgtagatcaaacacgttaggatagt
-gtcgttttcatatatatctaaattcggtctaacatgcattacccatgcttgataacgtag
-cacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatc
-accagtgatgcctcatcgtgactacccggatctttagcctttagggtctaaacagaacta
-atattactacgtgtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatt
-tagtgacagggtagaaatacgtatcaaattaacccagcaatacaataagcatgaaaataa
-ttgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgc
-attttgcactggattgagccacaaactcaactagcattatgctcaatatttggccagtgt
-tctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatc
-tcgaacgtaataggtttaattagaacatccgtaggatttctgtttatagtagatttatac
-taaatgttctgattagattctgacggccttacccatacaattaataaagacgaatatatt
-agttatagtttactatccaaataaattaagcgaatcgaaataaactgtcacgatactggg
-cagttatcaacttatcacttatacagttcggacactctatattggtctgtgagtactcta
-tcaaactaactcataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtg
-tacaaacctataatcgaataaatgacacatatggagatgcataataaaaaaaacggctcc
-atatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctg
-ataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtat
-agttcttgatagcgcgtaaattctgataatactgggcggacagctggaaattagttgcca
-gtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaaatacaaagggtt
-agttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaaca
-taaaggtggtgaagaatctcgtaggtcaactataactccatccttgaagcaactactccg
-cgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaacaactctcggta
-caaatgcggcttgtgtcgataaagttggtggtagtgcacggaataacataacaaggaata
-ttatttattcaaattttttgtgactgttatttgttttctgcctagaatgtaaggatgtgt
-tttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctat
-aacggcaggggagcgaagtagtgtcctttagactattcaaggtagaattttgataacgct
-ctataaaaggtagaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagtt
-ctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtcacaacaccctccc
-atcgcactcaaaatgtagatttatgatcagacgctaacttgttcttagagaaaaatacac
-gggatactctgtgcaacgatttcattaataaggtgcagcttgggacttttttggccgtag
-gctttattaacattcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgtt
-ttaacgtttcaaatataagctaggaagcgtttgccaggacttctataatgcaccgttttt
-tttagtacttccttactagccttagtttatgttagagtctttccaattacaaaggattga
-atagccaaaatttctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaa
-tattctacatatcggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtactt
-ttagaccaaacgtcttcggataattaaatcctttttcaattaccacagtacgtgcattag
-aactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacatt
-gcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagcttaccattcgtt
-aaacagataactaaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggat
-gtagactattgtttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgt
-cgaattccacaggggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatc
-tgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattg
-ggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattctaccgactccgga
-taacactttacgatcgcgcataactctagctcttagataagtttaacttgtcgatctcat
-aaacagttcaaaatctgcgatttattgtatcaaatccatcctctatcttctataatcatc
-tgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaaagctataattgg
-tttattttagtccatttaaattaagtccggtataagtgctctgtacaatatgcagtctca
-tgggcatatacgttaactaccttttgatacttcgaattggtaaaatatcgactatcgatt
-tgcagtaaaaggtgtagagtccaattactctttcctgttacatacgatctcttagtttgg
-acaactagcccatgatggcgctcctctagcgcatgaacctactttataattacatcttta
-tcgatgaatttttttagactgcggaggccttgagttttaacagggctgctaaatttctta
-agcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatc
-tactattgcgtcaactctattctgctaatagcgatggcaaatcacagaagccctcttagt
-gacaatagttgtcaactatatctaagtcgacctttactgtatcaacgatcacggagagaa
-ttaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataa
-tacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaac
-gattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgt
-tagtaaacttgatcttcagactccttcttttcgttgcagcgagacttaaattatatctgc
-gaaatagtgccccgtgcatacttcagatggtaggagataccatttggcccattgtgactt
-tacgcgattaattaaccgacatacatctgttcctgagctatgatcgtctgaataaattac
-ggtctcctcttgatacctaatggtttctggagacgtttctcatgttcaaatggatagcag
-gagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatt
-tccaaaccagaagggataaagagaaataacggacttctccgtagattagcctgatatttt
-gatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatattttggacggcggg
-agacacatatcggccattcgttaaggtctctatattggacatcacaagcttagcagtatg
-agctactaacactcaagacattattgattttttcaagatatgtttcattcctctaccgct
-attcccatacgttcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatca
-ataacaactcgttgcgatagagacctatgtatactagagagaattccccaacatttttac
-aaaaacaaagcagactaaaatagatacagtccctccatacaattaggaccaacatgttat
-tgccgatcctagcacacacaccacaaactcagaacttctgtcttacctatgaaagggtct
-gcacttctgattgtacgtgtctaattagcattaatattaaaactaattaggataaactat
-aggtacgagctttactataagtcactaggtgttttccgatcgaaaaacgggaccttcaag
-ccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaa
-ctgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgt
-tatactgctcaacaaaactcataaagttggactccatcatttagaatcatagggaccaaa
-acatttatttgctactgtcactttgtaggtgttctattctgaattcctcatattgataca
-tgaatcggaatacctgtggatcccttaggacgcacgtgctttctttacgtcagaatacat
-attgtcagaatcgagaagttccatgcaattaagaattcgcctctttgaaaactcatatcc
-ccacatatagggtccaccgttattcggaaacgatataataattattccagcgttgagcgt
-cccttaagagcgcattttcgcttggcctttcttctacgactctacaacgcaagtggctgt
-gtggagtttaccacagcgcagcaccccatagaactacctctgagagcgcgagatggtggc
-agtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatg
-gactgtcttaattgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaa
-gtaatgacggaaatacgcctctagtccgcagagatacgattacagactcagatcccctaa
-caagcaaaacgattaaatcggaatcactccccctatgacatatttgaaatacacaagaaa
-ccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgagtctgagaattag
-atgacctaactgcaagaatcatggcgagtttatctagtaggcaagtctgtaccctagggt
-tcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataaccaagaactggttta
-ccgagtactttcactattaggagtaattacatgcgttcaccgcggaatacgacgaaattt
-tttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaa
-ttgctgatcaattatagattcattatacagatgcttacttttctctattcaatactgtca
-tgagttgtttttaaataagcaccagaattatgtcgcctagtataatcttgcttccacttg
-aatcaatgcgatggacagtattctactgattgcaaagtagtctatttcggcttagcagta
-cgcatgcctatttttttgcaggcacagaataatatgcaactaggattctcggcatccaat
-taacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatgtttactacagaa
-agcgaatgatatcacttggagaacattttagatgcccccttttaatctagactgagtgta
-ccaatatatcaccggtctaccgaatcagcttgaataaaccactctagtactcatgataac
-cgagcatacacatgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcg
-aatcaacgtggcgacttatacttctgtctttgagtacagcacaccctaatgaatctaagt
-tagttgttgatacgaattgtaatttgactggatctcgcctcctcatctagattcttagag
-aagatgtttcttatagccggtactgtaactttattgatctggtttatggtaatcaacatt
-ttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagc
-gattatcgagtctggaggccgagaaaagaaatgcacagagtaagctctctattgcgacat
-ctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaat
-acaagattacctacgcttctacgaaatatactatagatttagcctacgtcacctttagtg
-tcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcg
-agctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctg
-gataactcacattgagtataccggtaaaaatttattctattcatctaaatagtcagtgag
-ggctagggtcgcaatcacattaggccacatacacatacttaacatgttctattgacccga
-cccaactttagtagcattgtagccgtttatgcaaatatgccaggcgccaaacactagcca
-gagggcattttgttacatttatttaatcgattattacacagtcggaacacgcctacatgc
-gttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcag
-agacatgacactaaaatcacattaaggtcagttagtgaaggaatggctaaccagctagag
-aatgcatcattaacaggcacttattgtcaaatattttccagatctaagcaacatcacgtt
-aaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagt
-aggcaagcgtaggagtataaatgtagacaatagtcgggacttagcagacactggatgcag
-tcatagaagatcttgcataacacgttagggttagagctacgaacgcccatcattaactgc
-ctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgatttcgttcataat
-gtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgac
-ctatttttgttcagagttcagttagagcctaatgattcgagagcaataatcaggacagcc
-tcataggaagtgtcaatcacttagaagctatattattataaatcgctctttactgtcgtc
-gaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaatatgatacataaa
-aatattttcatcaccactaagacggtggaattcagacttattggcaacttaggatgggac
-tattaaataacccataagatgttgggataaagttacgaaacgaaagggatatagcctgtt
-agataggaaatccccaataaaacatagccggcctccacagcagtgatctattccgccacg
-cgatatctttataccacgcaatataccaataataaaggttaaatgtggttgcgatttaaa
-aaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaatta
-tagcgtctgcaagttctctaagcttcctctgcaagatacaatatgactttttagcttttt
-tactaccaaatctcagaatcttagaaacaggttggtacgtgctactcggaattcccaaag
-taccctgctatatatgccattccttcattggtccgggctcaccatggggccatcatagta
-atagaaggtagtaaaactagttgatttccgacttttaacaatcactatcctgacccagat
-atgggttccgactggcccttactccagtaagggcagacacacagacaacgagaacttgat
-aactttgaattctcaaatcgatcattgcaacgtgacttatttactagcctactcctataa
-ttcatacgtcaaatacatttcaacggaggaagataataagtaaatattcactaaataatg
-gtcgaaggagtcctttgccaacataagtccacatatgcgctatagattttttcttggggt
-tcatattcaataagataaacagcaagagtatcacgtcagcgagtcattgagatcttggct
-agcattgtgatagcatattctacctaaatggtagtctagcacagagtggataagatatca
-gttagatatagacaagtactataacagatctcgcttcgttggattgtatggctagctttg
-atgatatgattttataaaaattgatccagacctgacctggccaattatattcatttttta
-tgagtaaaaatagataaccatgaaaatactcaagccccttaggacgtacaaagtggtaac
-ataaatttcaggtgttattctgcaaccacacctgttttgggttttcaaaaaggctaagca
-gattggttttacagataatccctgaacactggtatctcccaacgatgtcgttcccaaccc
-ttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaatatgttcgatag
-atccactcgcctgaggtagaaattcgtcttagtaacgcctctttggattacacagaatag
-tgtactgacacgtacactgctgcagcagccatacgctaacattaaaattcgttgagtcta
-catttgttgttattcggattatgttattgggaatagtatttttattcccctgcgtgaaac
-cacatggatagattagcctactcctaaagactcccttttggtctacggttcaattctctt
-actgagtttatgttcgtaattatatcggcgcagtgaatctcctaattatcaccggagtta
-ccagacgccatgaacttatggccagaaacattgcatgtggcctacataggattagtatca
-agagtttacgtttgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcggg
-aactcccctgcacgcgactatagaagttggtggtggatgtggcttatgccgcaaatatgg
-ttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtataagggctattgc
-cagatgaaaaactgcatataaggtcaaacaatataagaacattatacataggatcttagc
-gttcctcaggatggtatacgctataaagtctagcttcagcagctaaggagttttgccagt
-gcggacttccgctggaagattaggtttaaccgccctgacatcttcataaggtcgggcctg
-attcaaacccctggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagt
-ctaatattattattaacaaatgacggttcaataaataacaccgtaagggtgggaaactgt
-taagtgatgaatcattttaacctatcatccattagctacagataatgataccccgatccg
-actagggggtaagtggttgttccgttaggataaaccatgtaaaacgttagagggtttgta
-gattaattggtattccagataaatgaggtcagggcgagtgatcaattacactgaaaaatt
-gtcagcttgcgcggtagttgttaagacagtataaatgaaggggattcagaagcaagtttc
-tcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtcgattaaagccta
-aatggtaatttaaaccattgatatttatcgagtctataaatatctttggttgtatattac
-ttcacaatcaccaattctaaatgattcttccactgtgcgggtggagatatcaggacgggt
-taaggttgacctacatcgttttgatacaacaaaaatcaaagcacatggctggggacttct
-cgatactatctttgagatagtacgggcaagagtgggtgacgcctccctacattttcaagt
-ctatcggataacttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatcc
-acgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtc
-atggttagccaaaagcatgggttatccaaaaggaataaaacagctcttcaacaaagagat
-gaggcttcataacttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggac
-actttattttagccggcgaattaatggaatccatacgttacttatttggacatgacttct
-aggtgtttttgctgtcccgtttagcgatatttacagattagtatttcgtttctcatagtt
-aattgtatctagatactaactcgttgaagacgcataccttgccatttgtacaggacttaa
-ctgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaatacctcactcat
-gaccgttcatactctagttaaggtcgggaatactacgtatgcagggaattgtaacctagg
-agatttacaactctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcct
-aacttcgggtgcctccgtaaatcacctagaaacctactcatacatttgcaattttgagat
-gtaggcgaaagagagaaatctgctttttaacggtatctcttgggattccttttaaaaaca
-cataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgc
-cgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatg
-ttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctcccc
-agggttctacagacatagagatggtcagaacacgacccccctctcaacgcagtgtatttg
-aaatatatggacatatctaccttattctgtaattttagatgtgttctgtgtataccgata
-ttgataagtcaataggcttgattacgtatcttaagacaaatctgtttcgcaagtaggacc
-gcatctttcagattgtttctttttatgccataacctgcccaggaattcaaaaggttatcg
-atacccgatatgctgtgaattattattctaatggccactcattcctgcttatatctggaa
-ttggcatgaatatcttacaacctaaagtctggcgttgcgccagttctacttcgtaccgga
-caccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacac
-tttgtgccgacgtatatagatatattacacgtatagggaatgttttctcctaggtgaccc
-gaccttctactaaggttgtacatcgtataatggcccattaactacgaggaaagtggtatt
-gacctggtaatgcacgttcttcgatatataccgacgaggtaaagtctactattgcaaagt
-ttgacgttatactgataagtttagatttccctggatcgcgcatgaacaatgtatgcgtta
-tctgccatatataacatgttacaaatccttggggatactatcgctactatcatcggacca
-aaattaaataggctagtgtcttatcagaacatcatgtttaccgaactgatctattttcca
-atttaagctgatattacgtccgcgtatttattttagttccccggatgacgattatctgag
-ctacatcatacaagttagcatactcgccggtgcattgatttcttatttcgctatatcttc
-aagttcacaggcttcatatagttccaattagcagtataattaggttttgtaactttaacc
-atactttataaaaggttatattgcacaactgatcaagcatccgctataacccgagcttta
-ccagttagcggctaataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgc
-tctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtataaaatgatacca
-catatactataacaatgaaattatttgtaatccggtttgccaacgtatcccccttcgcga
-taaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaa
-ttatcatcaatattggccaagtgttataagcgttgaaagtgatataggccgccaaaaagt
-agtctacttaaaaaccaatatttatcgttcgttattgctggtagtacaacatcacgagca
-tttctcttttgagttgatttatactatatctgctgatgtgattatgtcccacttacccag
-aatattaagaaagtcctagattgtaggtatacttgactataaatataatttaagactata
-caaataatctggctacattatgccatcgtagaaactgataacgtagtaacgtcggacact
-agattttggtcggggagtaatctagcatactaacgaatttgttaaatccgctgaaagtat
-atgtcattacctgcttggcctgtcttcaatacgtttagactattaaggactcatttcgag
-atccagtattaattatacgcatccatatttatactgaagacggattgagttaggacgaca
-agctaaacaaatattaagttaaggattagtattatattgtagaaactcgtcgggttggaa
-cgattcatcatcatagaatgcgttacttattcagagagacttaattcggttatgactggc
-agctcacctggaaagtaggtgaaaggcaacagaagaatattgttgactgaattctacggg
-ctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaatacaatggatctct
-acagtattacgtaaataacatacataaacctggtgttgattcgactagctcatagattaa
-tcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactg
-ataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtc
-aaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttt
-tatccagacattggatgcatggctgtgggggcacaggatacttaccattagttcacctac
-aagcggcgtgagagggtctcagttttagccagcgcagagaagtacgggcctttagacgat
-taatgctagaattgtcataaacctcgtgaaaagctagttaataatcatggtgctagaaga
-acacaacttttctataaaccagttctcgactgacagtcgtaactcactatatcgccgctt
-tgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagaga
-tcgtgttctgagagataaatacaccggatacgatctgcatcgagttcatgtattaggtca
-agcttgggactgttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtca
-tatcataatatatgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaat
-cgtattcttgaatgctccgtggtttgtactaattcctttatagactgagtgtatcgtaca
-ctcggtacaattacaaaggatggaagagcaaataggtcttcaattataacagtaccccac
-cttaatctaaaaaccagcttcaattagtattaatttcgccaggagtatatatataaatat
-ctaaagactaaaagactcgtacttttacaacttacgtcgtagcataattaaatcatgggt
-aaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctc
-agcaagtcagtagaaatggaaattcatactcgattaaggcctataaaactgttgttggta
-tctacagagtgattaaaattagtgaatcagattacgaaaatgttttcccgctcgcactta
-cgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattttggtataaaata
-ggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatg
-tagttggttataaaggttgtaatctcggagattaggttagggcttaatcagaatagtaac
-aatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatg
-cctggacaggataaacaatacgcatataacttgacgatcgagcttatatcgacctatttg
-agaagtttaacgggtcgatataatatacaggtcttaatagccgattttttctagaaaagc
-aatcctatatcttagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacat
-tgtatacaacattcctttttgtccgggtggggactccatttaaagtatctcacctagaac
-tcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgttgatacttagaa
-ttgctaaattttagtctagacatttccaggtaaaccggtagacgacaatttctctgtcat
-ctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctactatagacaatca
-tcagactttttaattaaatagttttccatgaatgtgttgtcaaggcggaccccttcactt
-ttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggg
-gaaatggaaaagaaattaggcttctaagatggactataatcgattaggctaattccgttc
-gcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtga
-atgtttaaaagtgctcgcacagaattacccaatacctatcatcacgacttaaatacccaa
-agcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaagggatactgggcg
-gggaaacctgctccttcacggtaacatggtaacaacagaatttggttaaggttaaaacga
-aatatactcggagtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtg
-aagacactcttatattagatctccgaaattctgacccgtgcattaggcacttggtaggag
-attccatttggaacttgctcaatgtaagccagtaatgttccgaaataattcgctgcagga
-gcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccg
-ttctctgcgtcaattccagagctggagatacattcatcaacgttacctacgcacagaata
-aaaagatcgagcgctaactcgttttcctaaacacaacggatttagacaaattaccgaatg
-cgccggagagtagcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcag
-gcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaagctatatattgt
-ggtcagaacttgaggacaactatgagctactaaaaataaacaattttgtcatttgttcta
-gatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataa
-acccgaatgagcgtaacattatcaataacatatagttcagatagagaacgaggtattcga
-cagagaattacccaacattggttattaatctatgcagaataatttagataatgtcactac
-ataatattaggaccaaaaggtgattccccagaagacaaaacaataaacaatctcacatat
-tcgctagtacctatgtatgggtatgatcttctgattggacggggataatttccaggtata
-ttaaaacttattaccataatctagacctaagagaggttatataagtaaagagctgtgttc
-cgatagaaaaacccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacct
-acgtaagggaatattctgtataaactgaaaagtcaggtgtaactacatgagtcatgtctt
-cgattaattacaatgcgatctcgttattctgatcaactaatatcataaactgccactaca
-tcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgcta
-tgctgatttaatcagattcataaaggaatacgaataactctggatccattaccacgcaag
-ggatttatttacggctgattactttttggctgttgacagaactgccatgaaagtaagatg
-tcgcatcttgcataaataatagcacctaatatagccgacaaagtgattccgataacagat
-tttaagttgtccagccttgagactccatgaagaccgcttgggagcttccccgtgattaga
-agaatctaaatcccaagtggatggggggagtttaaatctcagcaccaacaaatagtactt
-cctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgc
-gcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtacgacaaattttaa
-ctgatgtcggtatacggagaagaaggaagcacgcattgaagcagctacgcagaactgaga
-agatgacactctaagatacaattaatacaaaaacgttttaagcccaatctatcaacagat
-gtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtataataacagcttta
-tttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagt
-gttggctactctgtaaccgacgcgtccatccctctctcctagtgatccgtatatccaatt
-agaggataaccaacatctgcgttaccgacgaatttaaatttttcgactatttaattccgt
-tcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttg
-cagtgcatatgtagataccactaattgctgatctaggatacatgctttataaacatgctt
-acttggctattttatttactgtcatgtgggggtttttattttcaacaagtatgtgctacc
-attggataatctggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaa
-gtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaaaagaataattgg
-caaatacgaggctagccttcaaatttaatgcagattactcctcagaaacacacgtaagcg
-acgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgataatttttgttcca
-acctttgaatctagactgagtggaaaaagatttcaccgggataccgtttatgctggtttt
-aaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaatcatctgtacgt
-caactgttttaacaataacgtcagaataaaccggcacaatgagacggcggtctttcacta
-caccacacccttaggattataagtgacgtgtggattcgaattctaaggtgacgggatcta
-caagcctcagctacattaggtctgaagatctttcgtatagccgcgtatgttactgtttgg
-atatgggttatgctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatct
-ttacggttaccttttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaa
-actgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaa
-ctatcattgtggtcattaaggtattcaagattaactaagagtcgaccatatattctagag
-ttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtgga
-ctgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcg
-atacctcaatcgtagttttatcgggataaataacatggtgtttaaccctattaatggttt
-ctattaatctaaattgtaaggcagcccttgggtcgaaagcacattaggccacatacacag
-tatgaaattgttcgagtgtccagaccataattgactaccatggtacacggtgttgctatt
-atgactcccgcaaaactcttgacagagggaattttggtacattgatgtaatcgatgattt
-aacagtaggaactagacgtcatccgttagactgagttccgacatgctcaaattgtcagga
-tttttatccaataactaatggctctcacatgtaaataaaatcacattaacgtcacttagt
-gatggattcgctaaacagatagactatcattcatgaactggcactgtttcgattatattt
-gcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaaaaattcagtaca
-cctctaatgagtatcccgctttggaggaaagagtagcactttaaatggacaatttaggcc
-ggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcgttagggttagtc
-cttacatccaccatatgttaatgaataaagcctgagggaccttagagctaacttgtccaa
-cacgttgctcatttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagat
-tttgaccatttaactgaccttcacagttttgtcttcagacgtcacttacaccataatgat
-gacagagcttgtagatgcacacactcattcctagtgtaaatcaagtagtagctagattat
-tataaagagatattttctggcgtcgaacgtaacacagagagagtataaggggcatgataa
-tggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcaca
-cttatggccaactgaccttgggacgagttaagataccataagaggttgcctgtaagttaa
-gataacaaagggatattccatctttgtgtgctaagaacctatttatatttgcagccataa
-aaacctctgtgctatgcagccaccagagttatttatacaaagaaagagaccatttagata
-cgttaattctgcttgcgatttattaaacagacatttcacgtccaaccactacaaaagccc
-tatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcggccgaggaatca
-taaaatatgaattgttacattgtttactacatatgatcacaatctttgtaaaaggttcgt
-tcgtgatactaccatgtacctaactaacctgagatatatgcaatgacttatggggtcagc
-gcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctggatttcccaaggtt
-ataatgctctatactgaccaagagatccgttacgactcgcaatgaatactctaagggcac
-tcacaaagaaaaccactaattgataaatttcaatgataatatcctgaattgcatcgtgta
-tgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataa
-ttactatattttaacgatttaatcgtagttggagtcctttcccaaattatgtcatcagtt
-ccgatttagatgttttcgggcccttcttagtaaagaagttaatatccaagactagctcct
-cacccacgcatgcacatattcgcgagaagtctgatagaatattcgacagaaatgcgactc
-tagctcacactcgttaactgatcaggtacttatagacaagtacgttatcagatatcgctt
-cggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaa
-cgggaaaatgatattatttttttaggaggaataatacagtaccatgtaaatactcaacca
-ccttacgtacttcttacgccgaacatatatggcacgtgttattcggctaacaaaactgtt
-gtgccttttctataaggataagcagattcgttttaaacatatgacctgtaaactgggatc
-tacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcggatctttggttaa
-agagcaccattagatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaac
-cactcttgggatttaaaacaattcggttaggacacctactcggcggatgaagcaatacga
-taacattaaaagtcgttcagtctaattttggtcgtagtacgatgagctgatggccaattg
-tatttttattaacagcactgaaacaaaatggagactttagactaatactaaagtctcaat
-gttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgt
-atctcattattataacaccagtgtacagacgacatctaattatggccagaaactgtcatt
-gtgccattaagaggattagtagatagtctggaccgtggaatagaattttgaccaaattga
-ccagtcctgcttgtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgc
-ttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaat
-tcagtcttctagatccgctattccaacatcaatatctcaatttaaggtcaatatatataa
-caaaattagacagagcagctgacacttacgaagcatcgtagaaccgatatagtcgacctt
-atgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaat
-gaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagt
-attactgcgaaaaattcgtctactattagtttattatgaacttatgacgcttaaataaat
-taaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgc
-taaagattatcagaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatac
-atctatatagttagaggcttgcgtgttgttgtgctattccacatatagcagctctgggcg
-actcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaatt
-caaggggattaagtaccaagggtcgagtttctctgtatttattatactgtaggcaagaag
-cttttttggcgagatttaagacttaagcctatggtaaaaatttgatagtgagcgactata
-gtaagagatttgggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatct
-gagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaattt
-caaacatattggcggggcacttatccataatagatttctgtttgtacgccaaactctgcc
-tcacccctccataaattgtattggctagaggttaaattctccgtaaatagagacacatat
-agttttatacaattgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatg
-tcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaag
-aaaacacagattatacaaagagatctggatgaagatattcgtgcaatcactatcgttatg
-ttagagagttccatgcatgaggactcgttttttgaccaggagaattaagccaagaaataa
-ctgacgtatttccaaatgaattctacgtgtttttcctgtcacctttagccagtgttaaag
-atgactatggagtttcgaataggttattctatagacattataacgagtggaacacccata
-ccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaagggattttaggttct
-taatccaacgaagaaataacgcatcacccgtcattctattgttttcgtcgggattactta
-gtaggcagggtattctaacctacctgagttacaaatctttaaaaaactggccatgaggtc
-atggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgt
-ctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcagttttatagctat
-ctagtggcattcctttttataaaactttacgtttgtaagggtccaactttacaaaagctc
-ggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgtatattgacggcat
-ggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaat
-gtaaagccggggattagccgccaaaggggtctaatgacatagagatgctctgaaatcgta
-ccaactataaaagcacgggatttgaaatatagcgacagatcttccgtattctgttagttg
-acatctgtgctgtctttaccgattgtgatttggctttagcagtcatttagtttcgttact
-cattgctcgtgcgatagttccaccgaatatggcacattcgttctttttttccattttact
-gcaaaccttttcaaaagctgatcgataccactgatgatggcattgattagtcgattggca
-actatgtcctgcttatatctccaattgcattgaatatagtaaaaaataaaggctcgcctt
-cccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtaccta
-acatataagtgattgagacaaatagttctccagacgtattgagatatatgtctcctatag
-gcaagcgtttctaattgctgaccagaaattagaattaggttgttaatactatattcgacc
-attttattccacgaatgtgctattctactggtattgctccgtatgcgatatataaccaac
-acggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtcatttaccgggag
-cgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaaagacttccgctt
-actatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatc
-ttttcagttcgcagatttttgccaatttaaccggttatttcgtcagacttggtagtgtag
-ttacaagcatcacgattatatcagctacagaattaaactgtcctgactcgacggggcagt
-gtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtcatagtacaagga
-taatgaggtttgctaactttaaaaattattgatttaacggttgattgaaaatctctgcaa
-gatgacgctagaacacctgatgttcaagtttgccgataataacatataagatgaattact
-gtctttagaccctcatgttaatccgctaacttagggcggaaacaatgttaggctatgcgg
-agtaagtactatattatgataccacatagaatttaacattcatatgatgtctaatacccg
-ttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatcaatgggccaatcc
-tgtctcaaaaattatcatattcaaggttcagctattttggcaatgggtgagtaccgttct
-tagtgatttacgaacccataatctaggcgacttaatatacaagatttagagttacgtttt
-ccgggtagtacatattaacgaccatggatcgggtgaggtgttgtattagttatctgatct
-tgtcagtagctcccaatgtcccagaatattatgtttctactagagtgttcgtatactgga
-atttaaatattatgtaagactagacaaattttatggatacattaggccatcgtagaatat
-gatatagttgtaacgtccctctatagattttcggagggcaggtatattgcttaataaaga
-tgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgcttaaataagttt
-agactattaagctatatgttcgacagcatgtagttttttttaccagaaagtgttatactg
-atgacccatggaggtagctcctcatgataaaaatattgttacttaagcattactattata
-gtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtttcttatgcagac
-acacttttttagctgttgacgcccacctcacatccatagtaggtcaatcgcataagaaca
-atattctggactgttttattacccagaagaaagttttttctttccggttcgttaagacaa
-taaagatcatttcattcgttctcttaacgatgaactaaagtacttaaagtatccgcctct
-tgtttcgactagcgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcac
-gtcggagataactctaatagtctctttattccgtttaatatagcccgtaattgcaccatg
-cgctacagtaacggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaa
-tggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaag
-cagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccct
-cactactacgcgaaggtactcgattattccttgaatgggctgaaacatcgtgattagcgt
-cttatgattcaggctgatagaagaaaacttattttctatattccacgtatacaatcacac
-tcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaa
-ttcgtctgggtgcataagtacagttagtcgtctgtcacataaataatccgcagtcgatct
-cattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaaca
-gtaaaactaccgtcacacaaggaatatcataatagatgccatacacggttttacttgata
-tgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaa
-tttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatggatgagcatttagg
-tattctatgataacactaaccatcatgtttctaaaatcctcaggaaatttgtattatttt
-accaacctgtatttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaag
-gagtacctgattgaaagaatggggaattgtaatctgtaactcaattacaaataagccgtt
-ctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaattcatactcgatta
-acgactttaatactcttctgcgtatctacagactcatttaaattacggaatatgttttcg
-tttttggtttccagctcgcacgtacgcgtttacaaataaggacacctggtacaattggct
-ggagtacaatgttggtttttatttgctgattatcccgatccctgtgggcgttggcataac
-cgggttttcttcaagactactttcgtgttgcttatatacctggtaatatcggtgagtagc
-ttagggcttaatcacaatactaacaagttctctatggattggacagggcggcatccgttg
-actgaacgatctattaatccattccctgcactggataaacaagacccatttaaattgacc
-atagagatgttagcgtcatatttctgttcgtgatagggtacatatattataaacggatta
-tgagcagtggttttctagaaaagcattcatagttaggagtgtatcagatcataccactga
-accatagagcacaattctctactggctatacttcattcctttttgtccgggtggggacga
-aatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaac
-ggttctaaatgttcttaatgagaattgcgtattttgactattgacagggcatcgtaaacc
-gctactcgacttggtatctgtaatctgtatgtagatagagtacgggcctataattcaaat
-tcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtg
-gtgtcaagccccacccattctctgttatatccgagcattaatgtagtttcactgtactac
-ggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctgagaagtggcacta
-taatagtttagcctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcg
-aatagattgcgttcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaac
-tttcataacctctttatttaccaaacctgttctactagcgttagtgttttagtctgtagc
-cgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaa
-actattggcttaacgtttaatcgaatgagactagcactgtattactctttcgtttcggca
-gcggatcaataaggaggtgacggcatcactctcttatagtagatatcacttattctcaca
-acggaagtaggatcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaat
-gttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgc
-ttacagtatccttgaggctcaacgggctatgcggaaattccagacctcgagttacattat
-gaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttgtaatataaacaa
-ccgtttttgtctattttcccaaggagaaggagagtagcagcttagtggcttgcctatatg
-gccccctaagtacgtactcggcacgcttagaagattgggctaccccgcactatatgttcc
-caaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaa
-tatacaattttggcaggggttatacattgcgggcatgaagagtaacattggacatgaacg
-gacattcgaaccctgtgagtttaataccctatctccggatcattataaagtaaatatacg
-tcacttactctacgtgcgtttagacagtctttgaaactaaattggttatttttctttcat
-ctagatttgtctgtatctaactaaattatagttccacataaagctgattcaactgaagac
-ataaatataaactttctaacatagtagcgaggaaagagctatgcctagcatcggatcatg
-cgtccgcgagtagttcctggtagagttaaaagtttttccagaatctagaccgaacacagg
-gtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgt
-attgttgctgtatctatatttcctacgtaaggctatttgatctataatatgaaaagtcac
-gtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctccttagtatcatcaa
-attatagattttacggccacgaattattggtctagatgtcccaaaaataatttgatgtca
-gtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattatgctataccaaga
-actctccatccagtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttga
-cagatctgcatgcaaagtaacttgtaccagatggcttttataatagaaactaagtttccc
-gaataacggtgtacgataacagatttttaggtgtacagacgtctgactcaatgaacacac
-attgggacctgccccgggaggagtagtagataattaccttctccagcgcgggtcttttaa
-tatcacaacataaaaatactaattaatatcacacaccctcatcctcgatggagcctagca
-tcatacacgtttgatagacaacgccaattttactgtaatatgatattcgaatctagtatg
-tggacgctgtaccacattgtttaaaggagctccctttaccgacatgaacgaagcaagctt
-tgtacaagatacgaagaactcagtactggtaactataagagacaatttatacataaaagt
-gttaagaccattatataaaaagaggtatgaggtctttgtaactacaataatacattcatc
-gaacgatggagaataacagagttatttctgctgctcgagctctagttctgctaatttctc
-aatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcgtacatccctctc
-tcctactcttacctatatcctattactggttaacctacatctccgggaaagacgtaggta
-aagtggtccacgattgtattcacttataacacctagtagtactatgtgttgctgagagtg
-aggacacacttactctacgagttcaagtccatatggacattacactttttcagcatctag
-gtgtcatgatgtattaacagccgttaggggctatttgattttatcgattgtcggcgtgtg
-tattttcaacaactaggtgctacaattcgtgaataggcatgaaaattcaagattgcagtt
-cctatcttgtataatctttcctttggacgagttgtaccatttcaactaacctgcaagtgg
-ggggtcatccatatgaagatttgccaaatacctggagaccctgaaaagtttatccagatt
-aataataacaaacaaacctaagcgaagaacgtcagctttaataaactatcactatcatag
-aaattcctgttaattgttcttccaaacgttgaatagactatcacgggtaatagattgaac
-acggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgataactcaattatat
-tcgatggagaattcatatctaccgcttagcttttaaaaattaagtcagattattccgcca
-caatgagaaggcgcgagtgcactaatcaaatcacttaggattattacggacgtctgcatt
-acaatgctttggggtagggttatacaagcatatgattctttaggtctcttgatcgggcgt
-ttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtg
-tataggaatgcacaacgcaaatctttaagctgacctgttcatgaaagacaggagacacga
-ggcaccacctcaattctatgcaaaactctaacatagcgtggcactatgagtacgtgtaac
-gacaaggtctcatactcgatcctaagataattctcgtctggaaggttttaatctttaact
-aagagtagaacttagtttattgacttttacaattaggatacggttcgcgactctaccaca
-gggcatcatacctggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgg
-gtcctgcatctactgagcaatccctttaagcattcctagtttgagagccatttagatatt
-gctgtttaaaccgattaatggtttctattattataaagtgtaacgctcccattcgggaca
-ttgaaaattagcaataagacaatgtatgatattcggcgagtctcaacaacattatggtct
-accatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttc
-gttaagtgagggtatccaggtgttataaggacgatctagaagtattcaggtacacggtgt
-tcagacatgctctaattgtcaggttgtttataatttaacgtatcgctctctattctaaat
-aatataaaattaaccgctcgtagggatgctttccagtaaaagatacactatcattaaggt
-tatgcaaatgtggcgatttgatttgaatcttagtacattcttaaacttaaatacgtatta
-tttaaagtaaatatattatctaaaccgcttttgtctatccacatttcgtcgaatcacgac
-ctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatctatttcttctga
-ttgatgtaatactgacccttactccgtacatacaaatgatggtaagcaagaatgactgac
-gctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggat
-atggatgtgtatgccaggcttcattttgacaatttttctgtcctgctcagtgttgtctga
-agtcgtatcgtacacaataatgatgactctcattgtagatccaatcacgctttcctacgc
-taatgaaagttctagatagtgtaggtgttagacagaggttagcgcctacatccttacaca
-cacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtatttgtttggaata
-tcatatttctcccgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataa
-aataactgctgccctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatga
-aaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttat
-aaatacaaagagtacatttagttaccggattgcggcttgacatttattttacagaatttt
-atcggcaaaacacttcatatgaactatcgcttcacgataagtctatgatagactagcatt
-cgtagagaacaggaagagcaatcattatatatgaagtgttacagtgggtactacatatga
-gatcattaggtctatatccggccttcctcataagaccttggaaatatcttacatcagaga
-tatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacg
-taatagtctggttttaactaggggttattgatatttaagctaaaagagttccctgaacac
-tcgaaatgtataatctatcccaactaaaaaagtatacctctaattcagaaatgtcattga
-gattagactgatgtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaat
-tgaaatgtaatacctccatcttaagttctatattttaaagttttatgcggacttcgagta
-agtgcacaaatgatggcataagtgcccagttacatgtttgcggccccgtatgagtaatga
-tctgtttatcaatctctagctactatcccacgaatgcactgatgccagtcatggcgctta
-cattagtcgacagaaatccgacgatacctatcacgcgtgaactgttctggttcttattca
-attcgaagtgatctcagatacattacggccatgcttgcccttcatgtctgctgagcagtt
-ttgttataggctgaatctcctctaagcgaaattgataggatttttggtggtcgatttagt
-ctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaatgatagggatcg
-gctgaggaggataaatatacgctggtgcctggtatttatccagaacaagttgcctgtgta
-tcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaaggccgcaaaggg
-ttacatctcaggatcgtggcgtatagtccaccattagttctgacttacttaatatagact
-gaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaac
-gtataggagcatgatcaaagaagagttaattaatagtactgcactataattgtcggcgga
-gtaccatgagctgttgcccaattcgatgtttattaacagcacgcataaaaaatccagact
-tttcaattagaattaactataaatggtccgcgaaccttaaatgatcggaaggacgggatc
-tgccgttgtatagaccccaactctatctaatttttataacacctctgtaatcaacaaatc
-ttattatgccatcattatgtcattcgccaagtaagtccagttcgagattctctggaccgt
-gcaatagtattgtcaaattatggtaatggaatccttcttctaacacccttagaaaagcca
-cgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgccgtttctttttac
-gatgatagggattcttaaagcttttctctattctagatcccagttgccatcatcaatatc
-tcaattgatgctcattatatagttcttatttagtatgtccagatgtcactgaagatcctg
-cctagaaccgatattctcgacaggatcatcagttcgacggggcaaacgcacctatgcaca
-tccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaact
-cctgtccacgatatgtaggcaagttttactgcctttaattagtagtcgattagtgtagtt
-tgatattatctaccttatagaatgtaaacagtaacccggccttaatggtttggcaggatt
-ctttgtaaaagttaataatgttcataaactttatcagaaaacctgaagtagtccgccttt
-cgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgtcttgttgtccga
-gtacacatattgctcctctcccccactcttctaggaaaatcaattatgctaacctgcaga
-ccttcttctttactatctttaatgcatgcccagtatgttcatagggtagacttgctatct
-attttgtataatctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggt
-ataatttgagagggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataa
-taggattaagcaggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaag
-tatgactgtgcagtattaattttgaatacatattgcagcccctaggatacattatagatg
-tctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaa
-ttagccggaattacagacacagattcttgtttacaattgtgggaagaaaaccacctcaaa
-cgttgaaacctacattcacaaatggattacgttggggatgagaatcgattccggtcaaaa
-atcatgcccggagcaataaccaagaattcacagaggattaatacacttctccatgaagat
-aggactgcttgcactatccttatctttgtgtcttccttcaagcaccaatcgtttggggac
-aaccacaattatgccaagaaataacggaaggtgttccaaatctatgagtccgcggtttca
-tcgcaacgtttcactgtgggtatcatgactttggactttagatttgggtattctagagac
-tgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcac
-gttgtgctagggatgtttccttaggaatccatacatgtaagaaagaatcaaccgtaatta
-tagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatag
-attgaatattctggacagcagcgaatcctgattatatctcaagcgaatatatgacccgca
-agaaggatttatactagaataagtctaagaaagggcattgggtcacttcttccactaaca
-cacttttatcagttttataccttgagagtcccatgcatttttatatatatttaactttcg
-ttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgt
-cgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttag
-ctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatc
-aaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaa
-agtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatt
-taccagtcttttagtttcggtactatttgatcgggacattcgtccaaacatgatggctca
-ttcgttctttttttcaattttaatcaaaaccttgtatttacctgatacattaaactgagc
-atcgcatggaggtggagattcccatatatgtaatcatttgatatcctattccattctttt
-tagttataaataaacgctccactgcacaatgggagtaggacttcaccaataattagcatc
-tactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaac
-ttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaatt
-acggtcgtattacttgttgccaaatggttattactccaatgggctattctaatccgatgg
-atacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaa
-gctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattg
-ttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaatttgttatgtcc
-agtcgctcgtatatcaaaagattcggttaagttcgcagagttttgccaagtttacaggtg
-atttactaacacttgggagggtacgtacaaccatcacctggttagcagagaatgaattat
-acggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgca
-ggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttt
-tccgttgagtgataatagctgcaacatgaagatagtaaaactgaggttaaactttcacca
-tattaaattatatgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcg
-cgcttaatatgggtccctatcccgactttgtacgagattttgataaaaaatagtattgta
-aattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgcta
-tttccctaagaaagcggaaaatcctggctcaatatttataatagtaatggttaagattgt
-ggcccaatcgctgagtacccgtcttacgctttttccaacacataatcgacgagaatgtat
-ttaaatgtttgagacttacgttttccgcgtacttattattaaagtcattggagagggtgt
-cgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatctattggttgttt
-ctaattctgtcgtccgtgtaggctatttaatttttatggtacacttgaatatgtttagcc
-ataatgtagccaatactacaatatcagatacttgtatacgacctatagacttttgccgac
-cgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaag
-catgcgaagcgagtatttaactgttgactattttgctatatgttactctgaatgttgttt
-tttttaccagaatgtgttataatgatcaaccatgcacgttcctactaatcatataaattt
-tgttacgtaagcttttctatgatagtggtctaaagactacccttgcatactttaagatta
-agacatgcactttaggaggaactcacacgttttgagctgttctagcccacctataagcca
-ttcgtccgcaatcccataactacaatagtcggcaatcttttattacccagaactaacgtt
-tttatttcccggtacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacg
-aaagttatttatgtttaagccgcttcttgagaatacagattactgttagaatgaaggcat
-cataactagaacaccaacgcgcacctcgcacattactctaatagtagctttattcagttt
-aatatagacagtatttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttat
-gttattccatgtggtcggaggatttgcggggcgatagcgctgggcggggatcaacaattt
-cgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcac
-tcgctagaagtgttacaatcacatcacttcgtaccgaagggactactgtattccgtcttg
-gggatgtaacagactgattacagtcttatgatgaagcctcattcatctaaaattagttga
-tttattccacggatactatcacactcctatagaaagagttaccaccgtgggaagctagat
-ataataaataaaagacatacaatattagtatggctcatgatctacacttactcggatctc
-tctttttttataaccagtagatcgcattacacgtattgttgttccgcatcaggccctagg
-ggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaagatattaataga
-tgaaatacacgggtttacttgatttctgttcagtcattcacgggaaatcctaggagtctt
-tcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattgg
-tatttcctggcatcacaatttacctagtattggagatcacttaaaataatgttgagataa
-taatcaggatatttctagtatgtgacaaacctctatttagtgattgtgattttcaattaa
-acaagacgtaggggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatc
-taactcatgtactaagaagaagtgctttcgtttaaggctttctgtctaacattctaacgt
-caattcctatgtaatactactgtaaccaagttattactcggctgcgtagataaagtctca
-tgtaaatgacggtttatctgttacttttgggtttcaacctagctaggacgccggtactaa
-ttacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgtccggattataac
-catccctctcccacttggaatatcaccgggttcttaatgacttagttcgtcttccttatt
-ttccgggtaagatcgctgtggaccggacccattttgatctagtctaaaaaggtatatagc
-gtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgcactgcactggat
-taacaagaacatgttatagtgtactgacacatgttagactaagaggtctgttcgggttag
-ccgacttatatgtttaaccgattttgacaactgggttgagagataacaatgaagagtgag
-gactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatt
-taattgttctaaccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtatt
-gttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtg
-actattgacagggaatcctaaaaagctactcgaattggtatatggaagaggtatgtactg
-agaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagcttaactagtttga
-tggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatgggatatcccaga
-atttatcgactttcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaac
-ttttgaggatgagtactgccactattatactgtaccatttgtaacttacattttatatct
-tcaaagaggtagatattgtcggccattactgtcacttacactaagggtagcttgattact
-gatacctctcatggtaaaaagtaatttaagaacctatttttttacataacctctgctact
-accgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcag
-aaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcctatgagaatacca
-ctcttggaatcggtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggt
-taggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgcca
-aatgcagaaatcttacactcttttcttaactaagtatgagagcaacctcactcctgaaca
-gcttgttacctaacgagaagaggctttaagtagcctggagcctcaaccggatatccggat
-ttgactctcatccacttacatgatgattacggtcattacatctcatgattttctgagtgc
-cctatagactgggaatttaatctaccctgtttctatttgttaacaaggagaaccactggt
-caagatgacgcgcttccatttatgccaccataagtaagttctcggaacccttacatgatt
-ggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtggcctatcatattc
-aggtcatcgagctcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatg
-gaagactaacattggaaatcaacggaattgacaacacgctcactttaataacctatctca
-ggataagtttaatgtaattagacggaactttctctaactccgtgtactaactctttgaaa
-ataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaaagtattggtcca
-aataatcctcagtaaaatcaagtcataaatataaaatttagatcttaggacagaggaaag
-tgctttcccgagcataggatctggcctacgccagtagttcatgcttgtgttaaaagttgt
-tactgtttatagtccgtactcagggtagtgttcgatactcagcggggaactgacatatta
-cactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaattacttacgctat
-ttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaa
-ttcacagatactgtgtatcatattattatagatgttaaggcatagaattattggtattga
-tgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagtgcagcttggaag
-aactggatgtatcctataactagtaagagccttaaaggtactacatacccagggatgtta
-ccatcattaatttggccatcttcaatcttcgcaatgcatactttcttctacaagatgcct
-tttagaagacaaaataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaa
-tcaagtctcactaaagcaactaacattccgacatgcaaacgcaggactactagattatta
-aattcgccagcccgcctcgtttaatataacatcataaaaattctaagtaatatctcacac
-actaatccgccatcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcg
-atgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaaagctgctacctt
-gaacgacatcaaccatcctacctttgtacaacagaccaacatctctgtactggtaaatag
-atctgaaaagttataaatataactgttttcacattgatagaaaaacagctatgtgctatt
-tgtatatactataataaattaagcgaaacatggagattaaaacagtgttttctcatcctc
-cacctcttgttctgctaatttataattcttgatgccactcgtgtgagtcgtccattcgat
-cgtaaagaacccgacataaatagatacgacgctgaacgagatcctatttctcctgaaaat
-tattagcacggtaactcctagggatagtggtactagttggtatgaacgtataaaaacttg
-tactactttctcgggatgtgagggagcaaactattactcgaccagtgcaacgcattatcg
-acagtaaaagttttcagctgatacctgtctggatggattatatgcaggtaggcgagagtg
-gattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttag
-ccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcatttcgtccactggta
-ccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgcaatagtactcca
-gaccatgaaatggttatccagattaataataacttaatatactttcactacatactcagc
-gggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagag
-tctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtag
-aatatgatgttaaatcatttatattccagggagattgaatagcttacgattagctggtat
-aatttaactcacatgattaagcaaatatctgtaggaccgagggaaagaataaaataaagt
-accatgagttcggaacgctgcattacatggcgttgggctagcctgatacaagaagatgag
-tatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagc
-agatgattatcgtctaacactgtctttaccaatgcacaacgcatagatttaacctgaact
-gttctggattcactcctgactacagcctacaactcatttctatgcataactcttaaagac
-agtcgcaatatcagtacctctatacacatcggatcagactagatcataagataagtctcc
-tctggatccttgtattctgttaagtacactacaaatttgtttagtgtctgggacaattac
-gataagggtcgcgactagaccacagggcatatgacctccaccgctcctagcgagtctcca
-atctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttac
-gagggtgagacccatttagatatgcctcgtttaaccgttttaggcttgataggatgagtt
-tgtcgatccatcaaattcccgacattcatattgtccaataagtatatctagcttattcgg
-actcgctaaactaaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaa
-attatagtcaatctcccatggggccttatggcagcgtatacagctggtataacgaccata
-tacaactatgaacggactagctgtgaactaagcagattattggatccttgtgtataattt
-taagtttcgatctatatgctatagtatagaaaatgttccgatcgtacgcttcctttacag
-ttaaacagtctatatcatgaagcttatccaaagctggacatttgatggcaatcttactta
-attatgaaacttaattacctattattgaaagtatttatatgatcgaataagatttgctct
-ataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaacctaggtaatct
-aaagcctgcatctatttcttatcattcatgttatactgacccgttctcagtacttaaaaa
-tgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaataaactgccgatg
-ggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggt
-tatctacggataactgtgcgatgaactactataggtcaaaattatcttcaatctcattct
-agatcatataaagatgtccttcgcgattgatacgtctacagtgtgttggtgttacacaga
-gggtagcgactacttacttactaactctctcttgatccgcaagcataagccaggttaaag
-tgctctatctttttctgtggattataatagttataccgccttgcatctaggtgcccatta
-ggtaatgccctagtgttttcataaatttactcctgccatctaacgttactttaatttccc
-agattcaataggtctctcatttgaaaattgttatatgtcaacaaagaatataatagctga
-gtggaacaatacactgtgagggagtaatacatactctaaattttctttacggtttgcgcc
-tgcacagttttttttatctatgtgatccgcataaaaagtaatttcaacgttccattcaag
-ttaagtcttggtgacactagcattaggagagatcaccaagaccattatttatttagctag
-ggtttaagtcggttagaaatatcagataatgaggtctttatccggccttacgcagtagaa
-attggaaatttcgtaaagcactgagttcaatggaagtatggccgaacccacataatgcac
-aaatcaagtcgatttcttccgtccttttagtctcctgggaactacgggttattcatagtt
-aagctaaatcagttaacggaactagacaaatgtataatagttcccaaatatatatctata
-aatcttatgcagttagggaatgcagatttgaatcatggcaatacgctagctcggaactca
-actacaagtgttggatgtacgaattcaaaggtattacatccttatgatgttcttttttgg
-atacttttatgacgacttccacgaagtgaaattatgttcgaatatctgaacagttacttg
-gttgagcccaaggatgacgaatgttctgtttataattctcgtcataatataaatacaagc
-atatgaggccagtcatggagctttcatttggactaacatttccgtagagtcatatcacgc
-ctgtaatctgatccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgt
-gacattcatggctcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtt
-tggattgtgggtcctccattttgtctgttaatgcttattaagattaaaaatgtactacgt
-atttagacctaatgattgcgatacgctgtggaccattaatataagctgcgccaggggatt
-tttccagatcatctggcctgtgtatatgttcaaatctaatagccgagagaaattactccg
-acggaaaataaaggcagataagcgtttcagagcaccatcgtggcgtttagtcaaccttta
-gttcggaatttattaatatacaatctcactctttggacgagctccttaaaagatgccctt
-gtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatac
-gactgctctataattgtccgaggagtaccttctcatctgccaatagtcgttgggttggaa
-aacaacgcattaatatgccacacttgtcaattagaagtttctataaaggggacgagtaac
-tgatttgagacctagcacggcagaggacgttcgtgtgacaacatctctttataagtttga
-gataaaatcgctaatctacaatgattatttgccaatcattatcgaatgcgcaaagtatct
-cctgttcgtgattctagcctaaggccattactatggtcaaattatgctaatcgaagcagt
-cttctaacacccttagaaaagcaaacactattgaatactgccgccgcattcgccagcacc
-aacataactgcacgtgcttttttccatgattggcattatgaaagatttgatctatgattc
-ttaccagttgcaatattcaatttagcatgtgttcctaattattgtgttattatggtctat
-ctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcaggatcatcagttcc
-tcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgt
-accgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttt
-tatgaggagtcgagtactgttggttcatatttgctacatgattgtatgtaataacgatcc
-cgccctttatcggttcgatcctttatggcgataagttatgaatcgtcagtatctttagat
-caaaaactcaactagtacccagttccccggaggaacggtcatgattaatgcgttttacgg
-tctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccactcgatgattggt
-atagctatttgccgaaaagccacaacgtattcggtactatcttgtttgattcccctgtat
-cttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgaca
-cttgttacaattatccagttgcgtttaatggctgtgggtcacaagattgttagacaggtc
-ccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagctcacccgcctaag
-tgatccaaccctcatcaggataactatcactgggcagtattatttttgatttcatatgcc
-accccctaggagactgtagtcatgtatctttcttacccaatctagcccgaaacaagaaag
-aatgtcgattccagtcaccttttattagaccgatttacacacaaagtgtcttggtttaaa
-ggctggcatgaatacatactcaaaagttgaaaacgacttgctctattcgattaccttcgc
-gatctcaatcgattacgctaaattttaatgcccgctgaaatatccaacatttaaaacagg
-attaattctctgatccatgaacttaggactcattgcacgtgacttatctttctctcttaa
-ttcatgctccaatacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgtta
-ataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggac
-ggtacatttcggttttatagactatgtagttacacggcatcaacatgtaattaaaacggc
-gtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggaggattacatacat
-ctaagaaacattctaaactatgtatagtcgtttacgacccttgtagtacgtgcatccctt
-ggcgaaaagtactctgggtattagagtgtatattatcgacagcaccgaatcctcatttta
-tagcttgacaatttatgacccgaaagaaccttttataagtctataagtatatctaacgca
-attgcggcactgagtccactaactatctttgagcagtgttatacagtgagacgccatgga
-aggggtttatatattttactgtcgttccctaaaaagttaattatcagacctgcgcgatct
-cgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatc
-aaccgtttctgcggatcgcgttacattccttgcttatttgcgataaatcgatacaacccc
-attaccagaaaaacccggagaatcaattactctgcagatcttatactaaaaaagagatta
-caacccctgttctatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagc
-gattttaactttcgcttttccattttccagtattgtactttacgttatatttgagcggca
-cattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaatcaaataattgta
-ttttcagctgactttaaaatctgcagccattggaggtggagattccaatagatgtaagca
-ggtgatatcatatgcaattcttgtgacttattaagataccagacacggcacaatcgcagt
-agcacgtaaacaataatgacaatcgacggttaaattccgaacgtaagatatgtttacgga
-tgcactaaaataggtagcaacaacgtttctctgagatgtataagttaccaaacactggag
-aattccgctaaactaaggacaatttccgtcgtattaattgttgacaaatggttagtaata
-cattcgcagtggataatccgttgcatacctagcactgagtgtaaataaaaccaatcgact
-actggcatttcgggctaacgactagatgttagcctatgtgaaagcctcacacatgcttat
-tgccttcacggtgagcaatgtttcttattcgttattagaagtcacctgtagagacagtag
-agatgacctaaatttggtttgtccagtcccgaggtgatctaatgattaggttaacttaga
-acagtggtcaattggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaa
-actggtgagaacagtatgatgtattcggtcatctagacaaccccatcgctgggagtttgg
-acagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccgggg
-agatagggttaatttaggcttttttacggtgtggcatattagctcaaacatcaacattct
-taaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaa
-taagcttaataagatttaggtccgaccttaatttcggtccatagcacctctttctaagtg
-ttttgcttaaataattgtattgttattgattttctgcgagttgaacacggaaaataagtc
-aaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttt
-tagattagtaatcgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttcc
-aaaaaattttagtccactaggtatttaaatgttggacactgaacgtggaagccgtcgtat
-tatgaaactaatggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcaga
-aaaaggtaaatcttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtt
-tggttcaagtgaatttgtttagccagaatggaccaattacgtcattagctgttacgtcta
-tacgaaatatagactgtggacgacccatcgtagagtcatgtagttacatgtgaccttaga
-acaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactggtcaattggttca
-tagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcct
-ccttcctaataatcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaaga
-cgaaacggccttaatgtaacattaactattccactgtaggtggatctaacaaggttggac
-atgtgctaccaataagataagaatttcgtccgcaatacaatatctacttttgtagcctat
-cttggattaacaacaacttacgttggtatttcaccggacgtatcaaatgattctgatttt
-aatgactgagagtaaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtc
-acattactgttagaatgaacgcttcattactacaaaacctaccaccaactcccacattaa
-tattatactagatgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgtta
-cgaacacgtacattaaattgttagggtattaattgtggtcggtgcatttccggccccata
-gcgctccgcggggagaaactatggccttcatgacagcccccccataacatctaggtaatg
-gtcggataactataaacaaccctctccagagaactgtgaaaataaaatctcttagtacac
-aagcgtatactggtttaagtcttgcccatcttaaagactcttttcactattttcttgatg
-cctcattcttctaatattaggtgattttttaatccgagaatataaaaagacgatagaaag
-tgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttttgactatccctc
-atgatctaaacttacgcggagctatctttttgtataacatgtacagagaattaatccgat
-gcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaac
-gcactataccaagtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtca
-tgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagct
-cgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtccgaggattgctga
-taacttaaaataaggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtt
-tgtgtgtttgtcattttcaagttatcaagaactacgggtataatttacgacgtaatgttg
-gtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactgctttcctttatc
-gattgctcgagaacattataaagtctattactatggattaagactgtatacaagtgttta
-agcggagcccgtgataatctataaggttttggtacctttatctgttacttttgccttgaa
-acatacatacgtacacgggaatatttacctaaacgccgtatagtccagcctcgtatttgg
-gccgtgttttgtcagcattttaaactgaaagcgcccacttgcattataacccggtgcgga
-atctcttagtgactcgtcaggagtttacgcctttgagacctctcgacaggacccattttg
-atctagtcgttataggtagagtgcctttcctatcgcaccattaccttctagcaaacttag
-agtattcaatgaaatcatatcctgtttatactaaatgttataggctaatgacacagctga
-cactaagaggtctcttcgggttacccgaatgagttgtttatacgatgttgacaactcggg
-ggagtcatttcaatgaagactgaggactcttgatcagattaaaacgcttaatgactgata
-atttagattatgccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctg
-agaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcg
-gctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactatt
-cctagagcgaagagctatgttctgacacgtccccaatattaggcaaaggctccaaaagaa
-cagtcaattgattaactacgggcttggtttctccgtgaatccttgcgccgctataccaca
-taaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagta
-cactagcaaccccttagcaattaattttgtccatcactactgccaagagttgactggacc
-agttggaaatgacatttgatatattaatagagctacatattgtaccactttactgtcact
-tacactaaccctagcgtgattactcatacatatattcgtaaattctaagttatgatacta
-gttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttcaactaaatatttc
-actgtagccaaccactttaaccagaaggataccttaatgccgatataatattgtccagga
-aacgttaatactttcacaagacaaagcttggaagaggtactttacgatcacctgatagat
-cgaccggaacgattctatataggtttggtctgagaaatttgtagctaaaaccatgttcca
-taggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatcta
-tcacagcatcctaactcctcaacagcttctttcctaaagacatcagcaggtaagttgacg
-gcacccgataacccagagcacgattggaatctaatactctgtatggatcattacgctaag
-taaatataatgattttctgactcaaagttacactgcgaattttatattaactggttctat
-ttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatcta
-acttataccaaccattacttctggcgcagaaaaacatagatatctgaacaatcgaccgtt
-aagactgtctcgccgatcttaggaacctaatactgctcagtagttattgtttatttgggc
-catccccggattatgtcagccatggaacactaaaagtcctaatctaacctatggacaaaa
-agctcacttttataaaattgctcaccttatgttgattgttatttgtccgaaatgtctata
-actcagtgtactatctattggaaaattatggccggagttttattgaatatacttttgtat
-gttgagaaagaatgttgtcgtaataattatcagctggaaaatcatctaatatatattata
-ttgagatattacgacagacctaagtgctttcccgtcatgagcagatggactaacactctt
-ggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcccgactcttactt
-actcagagcggaaatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggt
-tatttttttaattacgtacccttgtgcagagagtttagctattcgatcctacttagtatg
-aaccatgagagtacaggttggtaattcacagagaaggtcgagaagattatttttgatgtt
-taccaatactatgaggcgtattcatcgaaataattttatggctgcgcacttcacatacgc
-aggaagaccactgcagcttgctagatctggatgtatcattgtacttctaagagcctgaaa
-ggtaatacattcccagcgagcgtaacagattgtatggggacatattcaatcttagcaatg
-cattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaactataaccctgg
-aactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagca
-aaacccaccactacttcagttttaaattagaatcacaccctagggtattagataataatt
-aaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaataagtctccggt
-ctttcacaaacacatggttaagcgatgtggttttgactagagacgttcgccaccatcgta
-atatttctggttacctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagta
-caacttatctcttatcctatagagatctcaaaagtttgtatttttactggtttcaaattg
-agagaaaaactgcgttctccgatttctatattattgtttaaatgatgccaaacatccagt
-ttaaaacacggtgtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaa
-actacggtcacgcgtacattacagagtaaactacacgaatgaaagagataagaagatgaa
-agagttaataggtctcctgttaattatgagaaccctaactactacggattggcctactag
-tgggttggaacggatataaaattcgactaagttcgcggcatgtcaggctcctaaatatga
-agagaactcggcatcgaattatccacagtaatagttggaacatgattcctctatgcatgg
-tgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatatt
-cttcctcagaaaaggactgttgagcaaggaattggattctgtgaacggaatatagtcgag
-tagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacat
-atcttcttggcaattagtactccactaaatcaattggttataaacttttagaatatcttt
-atataagttcactacttacgctgcgggtagtatatttaaagtgatgtcttaggaatctta
-tggcggcggaataaacggcttgactatagataccctaattctggcataaccctgtaacgt
-gtgaagcatgctttaatagacgactagatcagcttatagaatggatatgactgccacatt
-gaagagattaacattagcgggtataatgttacgaacttgtttaacaaaatagctctacca
-cacacgcatagtataatataaaggtcctggagttcgctacgagcctggaattgcagttcc
-cctaccctgagtaaacaagatcagtatggacctatcttctgacccacgtgtaaaaactac
-cgttagcggccctgagaacggtgaagttgattatcggctaacactcgctttaccaaggaa
-caaacaattgatggaacaggtaagcggctggattctatcctgaatacagcataataatat
-ttgctttcaatatatagttatgacactcccaatatcactaactctttacaaatcggatat
-gaagagtgaattagagatggagccgatcgttccttgtattctggtaagtactcgactaat
-gtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaa
-tcctccgagcatagagactctaaattcgccaagcaataagtcccgacgcgaaggatgaga
-agctcattgaactgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaa
-gtttttgcctggagtggttgagtttcgcgatacataaaaggccccactttcatatggtca
-aatatctatatcgtgctttggacgactcgataaactaaagtagcctagtaatgccctaaa
-ccgctgcatttgtgcaataaaaaatttagagtatatataacttccggacgtatggctgcc
-ttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcggaactatgcaga
-ttaggcgatccttgggttgaatttttagtttccatagatatgagttagttttgatatggt
-taccatacgtccctgcattgaaacttaatctgtatattgattgatccttagcaatagcgg
-cacatttctgggcaatatgacttaattaggttacggtttttactatgatggatacgtttt
-atatgatagaataacagttgctatttaaacaggtactacattcaactaatactgtttcac
-tattgtgtccaacatagggaatatattgcctgaatagatgtattatcaggcatcttttac
-gctccaggtagaactaattaaaaatgatccttagaaactttcaagcaacataagctaaaa
-gttacgccaattataagccacatcggtaggatcttcaggcattcccatatccttctctat
-caatcccgtctgttgctaattggttatctaagcatatcgcggcgagcatctacgataggt
-ataaagttgctgctatctaattcgtcataatatatacatggaattacagattcatacgtc
-ttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatatctctctcgtgtt
-acccaagaagttgacacgtgattgtcagctatctttttctggcgatgttaatagttataa
-acaattgcatatagctgcaaattagctaatcaaatactcgtttcttaaatgttatcagca
-aagctttaggttctgtaatttcactgtgtaaagagggcgctaagttcaaaattggttttt
-ggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctc
-taattggtctttacggttggaccaggcaatgggttttttatctatgtgataccaattaaa
-agtaatttcaaagtgacattaaacttaagtattgctgtcaagaccattacgacacttcac
-caacacatttatgtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgc
-gttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaag
-gtgcccacatcacacattatcaacatatcatgtcgttgtattacgtccttttactagcct
-gggaaataccggtgattcagagtgaacataaatctctgaaagctactagacaaagctagt
-atagttaaaatatatatttcttttaatattaggatctttgcgattgcacatttcaagcat
-cgcattaacctacctccgtactcttctacaacggttgcatgtacgatttctatgcgatga
-aatacttatgttcttagtttggggttactttgttcacctagtcctcgaacgcaaattagc
-ttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataat
-tatagtcagaagataaatacatgcatatctggacactcttccacatgtcatgtcgactaa
-ctttgaactacagtcatatatagactgttatctgatccgtatgtgtctattactactctt
-atctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcggggctttttccct
-gattataagattacactattgctgtgcttggggcctcctactttttctatcttaatcatt
-ttgtacattaaaaagctaagaagtaggtacaacttatctttcccatacgagctggaccat
-taatttaacagccgcaaggcgagttttaatgttaatctggaagggctttatgttctaagc
-ttttagcactgagaaattaatccgtaggaaattaatcccacataacccggtaagagaacc
-ttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcg
-acgagctccttaatacaggccctgcgttatattcgaccgtacctataactagaccaccat
-cttaaatgtacagttatggttttcgacgcatagagtatgggaccacctcgaaatgctcag
-ctgcaaattgtactgggggtggttatcaaacatttaatatgaatctatggtaaagtacta
-gtttatagatagccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgt
-cacaaattagattgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaat
-atttatcgattgcccaatcgttctactcgtactctttatagcctaacgccttttcttggc
-gctaattagcctaatccaagaaggagtctaacaaaattacttaaccatactcttgtctat
-tcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccag
-gaggtaacattggatctatgagtcttaacagtggaaatatgatttttagattgtgttcag
-atttattgtcttattttggtctatctcatcagctatagctacataatgacgtcttaactg
-tttcgactaaccttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaa
-cgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacag
-atctaccattcgtggaatcaatttttggacgagtactggtcgggtcgtgcttatttgcta
-caggattgtttcgtataacgttcaagcactttagcggttccatccttgatggcgttaact
-gatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaa
-cgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtc
-atcagagacaaatagatgattcctatagctttttgcagttaagccactaagtaggcggtt
-ctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtat
-agaccattcttcaggcccgccacaatggtttcaagtttcaacttccgtttattggctgtc
-cctcaatagagtcgttctcagggcacgactctcgttcgttattcataagtccagtttgat
-ccacgaatacagaacacgcatatctgataataaaagcttaacgataactttcacgcgcat
-ggtttatttttgatttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaa
-aatttagacaaacataaaacaaagtatcgccattacagtctcctgttaggagaacctttt
-tatcaatatgtgtaggcgtgtattggcgcccttgatttaataataattacggctaaacgt
-attgatattttccaggaactgccccatctcatgagatgaccctaaattttattcacacct
-catttttaattcttttatatcacgattatttatctgagcaagcatctttgcaagcattca
-tagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgctaaacatattggtt
-caattcaatgtaagctacctcggaatttgcttgcactaagacggggaagccaaaacggta
-aatcgccgtatatgctagtgccaagggacttgtccgttggagtcactatggagttacaag
-cattataaatctaaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccc
-tggggtacggaccatgaaatacttctttcatacatgataaacgatggagactcggttacc
-accctggtagttactccatcaattggagttaactaagatcgctattacaggctttattag
-ccaatcatcacaagcctctttttagagattcacaagttagcaaaccaaagttcctttgat
-aagtctttaacgagatctatcccaattccggctaggagtaaaatttatatatttgagatc
-ggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtccttccctaattag
-gtaattttcagacctccgagagagagtagatcaacaacgcgttatactcctaaaatgctt
-gtcgataacatgacactacagatcatccctggatgagcatcgactttcattacttgatta
-gttcagttaattcgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgca
-catcttagactaaataacagttttcataccctgggatttgtgtcactatctcaggaacgt
-cgagacgtcccctatcaccgcagcgagggtaactggccctgttccattgtaatcgatggg
-acgggacgttatattgcagacccaaagtagtaataaattcagccatatggacggaggggg
-ggaattgttaagaatataattcgattttcagctgaatgtaaaagctccagccattcctcc
-tccacttgacattagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgt
-ttccagacaaggaaatagcccagtaccaagtataatattatgacaatagaagcttaaatt
-cacaacgtaacatatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgt
-gcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagttcccgactatga
-agtcttcacaaatggttagtaataatttcccagtggagtagaagtggcataacgtgcact
-ctctgttaataatacctttagactactcccatttcgccagaacgtcttgatggtacccta
-tgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatt
-tctacgaacagctagtgaaaggactgatgacctaattttggtttctcaagtccagacgtg
-atattttgatgaccgtatctgacatctctgggcaattcggttaacctctggtacgaaata
-gtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttttagctaagctac
-actaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacga
-attcctaatactcttgctcagggcacttagggttattgtagcctgtgttaccgtctcgca
-tattagatcattaatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgt
-tctgataggtagacagctaataaagatgctgttgaacagttacgtcccacctttattgcc
-ctacagtgaaactagttcttactctgttgctgtaatatgtctagggttattgatttgctg
-ccacttcaaaacggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaa
-tccccaattgaagccagaaattttgagatgtcgattcctgatcattcgccaaatttacag
-ctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggct
-caaggtacgtggaacacgtagtattttgatactaatgccagacccgctacgatccctgta
-ctgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgac
-tacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaa
-tgacgtcttttgatctgacggcgttaacaaagatactctgggcaacacacatacttctct
-catgttgtttcttcggacctttcataacctttcctggcacatggttagctgcacatcaca
-ggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggtggtgttaatcta
-tctcggtgtagcttataaatgcatccgtaagaatattatgtttatttgtcggtacgttca
-tggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaagg
-taggtccatctatatacgttgcacagcggatacaaataagataagaatttactaacattt
-aaattttcttattgtcgagcatagattggaggaaaaacttatttacttggtatttaaacg
-gaagtttctaatgtttatgattggatgcacggacagtttactgcttactttcttaggttt
-cttgaacaacaggatgcactagtaacatgtctcgttcatgcttccattaagttcttctta
-aacttacacaaactacctaatttagagttgacgagatggttgaacgtgttgtgacaaacg
-tttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattct
-gctacgtccattgcaggccacattcacatcccacccctgaatatatggactgaatcacac
-acaccaaatttcatctaccttatcgtagcataactattaacaaacatatacagacttcgc
-ggtaaataaaatatattagtacacaaccgtatactggttgaactattgcccagctttaag
-acgcttttaactaggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacc
-tgaatagatatagacgttagattgtctgaaaacacgccgtagagacatttttgttagata
-tgtatttctttttgacgagccagcatcttagtatctgaagacgagctatatgtttgtaga
-aaatcgactgacattgtatacgaggcggcgtaagattaaccaaattccccagaattagta
-atggcgccttatcgatttactaacgatatataacttgtgatgttgtctgcaatgtatacc
-cgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccacc
-gcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgctatgtaatccat
-tctaatgggtaagaggattcctcttatagtaaaatatgcttgactttttaagaaccattg
-ggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttttctacaactacc
-cctattaggttacaagtaatctggctttcttgccacttggcgatgatagttagattcgta
-tttctacaacgcagttactgtatccatggcgcgagataattagatacgatttgaatttgg
-atgtagactcgttactactgttgtagaccagcacgtgagtatctagatgggtttgctacc
-ttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatattttactataagc
-agtattggccaccctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaa
-aattccattttaaaacccggaggaatctattactgacgaggaaggtgtttaacccgttga
-gacatctcctaacgtaaaaggttcatattctagttattccgagagtcactttcctatcca
-aacatgaactgatagcataatgacaggttgaatggaaagcatatcctgtttattctaaat
-ctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttacaactatgtgttc
-tgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatct
-gatttaatagcttaatgtctcatattttacagtagccagtgtagtatggaaggcggcgaa
-ccagcccctacattgggtttcctgacataagtattacatatcacttgtctgattacacag
-caaaatcgctaaccttactttgcgcatgtagctattggaactttgggctagtgtctatcc
-cattaagtttaacagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaa
-gttttggatttggatcaaaaactactcgatattcatgatctacgggcttcctttctccgg
-gtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgg
-gatagcgtagaaactaaacaacgaatagaccatccaatttgaattttattgggtccagca
-cttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatattaattctgctac
-attttcgaccacttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatg
-ccgtaattctaagggatgataataggttgggaaatttaagagcagtagtaacggtcgcgg
-gttcgaccttaaactatatatttaaatctagccaaacaagttaacaacaaccataaagtt
-atgaccttattatattggcaagcttaacgttttaattgctctagtaatagagtggtagag
-gtaagggaccatcacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaa
-atttcgagataaaacattcgtccttagcaacgaatatcgaatggcaattagccacattga
-gttaaatagttgaggatatttcttgcacagaatcagatctaatctaatgattcgttacta
-aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
-atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
-ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
-atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
-tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
-tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
-gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
-tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
-gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
-gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
-atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
-taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
-ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
-acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
-ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
-ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
-cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
-ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
-aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
-attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
-acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
-tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
-attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
-aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
-tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
-ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
-gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
-caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
-taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
-ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
-ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
-gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
-ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
-aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
-cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
-gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
-ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
-tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
-tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
-ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
-tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
-gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
-ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
-actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
-gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
-ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
-tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
-atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
-aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
-tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
-ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
-acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
-gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
-gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
-tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
-gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
-gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
-tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
-acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
-tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
-catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
-attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
-ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
-ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
-gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
-tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
-tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
-ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
-gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
-ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
-tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
-ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
-tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
-ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
-actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
-gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
-gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
-accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
-gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
-cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
-tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
-atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
-ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
-ggaagtgaaaagataaatattgcctacacatactgaattcaggcaatgcgttttattcga
-aaggtcatataactagaaaacatgatgaattcttatcggatccttttactagcatagtgt
-tggcgaacacctcgtaatgctcagcggcaaattggactgcgggtccttatcatacatttt
-ttttcaatataggcgattggtctaggttagtgattccccaacacttaaggtttgctgaca
-ttcataccctcagcaacttcctctcaaaaattagagtgagttggtggtcttataagaccg
-ttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctg
-tagacaataacccattgtagtgccgattttgtgcataatacaagaaggaggatataaaaa
-tgacttttcaataatattggctattagcaacaagaaggagaatcctcattaagttagcaa
-ccgcagggggtactgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaa
-ttatgattgtgagattcgctgaagattgtgtctctgattttcctagatagaataagctat
-agctacttaatcaactcttaactgtggagactatcctgatgatctgaataccccatttac
-aaaattccatatcaatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatca
-gcctttttatacaagacaaaacactgcttccattacgggtagcaatggttgctcgactac
-tggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgac
-ctgacataatggagcgacttatcggatgttgccgatctttagggtcatctattaagctta
-tacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacctagaaacgcaag
-aggaggcgaactccaatatctgtaagaacagaaaaatacaggagtccttttcatttttca
-agttaacaatataagtaggagcttagagaggcttgcatgaaaatcgttaggaattacaga
-ataggcagagagtggggcgtgtagactacattcttcaggccccacaatatgggttatagg
-ttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgtt
-ccttttgctgtagtccacgttcatccaactattcagataaacaagatcgcagaattaaag
-cttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctc
-aatcttgtctgcgagagggaggaaaatttagacaaacataattcattctttcgactggac
-acgctaaggtttggacaaactttgtatctatatctggaggcctgtattccagcccttctt
-ttaataagatttacggcttaaactatggatatttgccaggaaatgacactgctattgaca
-ggaacataattttgattcaaacctcattgttaattattttatatctcctgtttttatatc
-agaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaatgaatcataata
-gaccggcccctattaatattggttcaattctttcttacataacgcggaatttgattgcac
-gaacaccgggaacacataaccgtatagcgcccgttatgctagtgcctagcgactgggacc
-gtggagtctatatcgtctttctaccattattaatctaaggatataccactttaagtcctt
-tcaactaacataaggcgcattccatgcgctaaggaccttgaatttattatttcttacatg
-ataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaa
-gagccctttttctggcttgtggagactatcataacatgaagatgttttgacattcaatag
-tttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaattgccccatagc
-aggaatagttatatattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtg
-agggtaagcgacttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaat
-tacagttatacgacttaattcagtctccataaattgaaacgacacttcttaacgggagga
-ccagacacgttcattaagtgaggagtgcactttttgactttaaaaacatggtaatcaatt
-taaaccacttgatatgtatatgaacagatttgaagttatttctgttttaatacactggga
-gttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaaggg
-acaggggaaagggtaatcgaggggtagggaacgtagttggcacacccaatggacgaataa
-atgctgccatatccacggagggcgggattgcggttgattttaaggcgatggtaacctgaa
-tgtaatagatcatcaaatgcctcctccactggaaattactgcgtacatccgctgagaatt
-gcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaacttcatagtataat
-ttttgcacattacaagcgttaattaacaaacttactttgctgttagctgcctatatttgt
-ccgacaatataactggatatctctgcgagaactgtaaattaacggcacttggaacataat
-agttcctattggtaacgacgttgtaggcggcaattatccggtggaagaattgacaactgc
-agttgaactgcatgaaagtcaaatctctcgtaagtataactttagaagactccaaggtac
-ccagaacctcttcagcggacacgatcgctatcaatcaataaggattattcactgaaaccg
-ctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttt
-tggccgtgctaatcgacacacctgttattttcatgaccggataggacatctcgcggaaat
-tcgggtaacagctgggtagatataggacctcccctacgtattaatgataagcctgtcata
-actagcttggtttaccgaagagacaataaacattcgagcgctcgtgccaaactcggtgca
-ttacgtttgaataaatcggtaacatgtactattactctgcctaacggcacttacccgttt
-gggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccg
-attaccgaaaatctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaa
-caggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactctgggcatgtttt
-atgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggctttatccaatat
-gggtccttaagtgctaaacatcattcacaatttcaagacagattgttggtcttgtcgatt
-ccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgac
-taaactaccgtgtgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaag
-ccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagtaattccgtttta
-ttgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgtgccttataggct
-atttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtc
-tatcgccaactaaaagacgtctcgatggttctttatgcggacctgtcatatcattgactg
-gcacttgcttacatccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaaga
-tcatgaggcggggggggtaatatttcgccctctacatgataaatgaataagtaagaagat
-gatctttttgtggcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatg
-tagggttctggatctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaa
-taagtgatcaatggactaacattgaaatgttagtattgtcgaccattgagggctggtaaa
-tcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactc
-gttaatgcttactttagttggttgcgggaacaacaggaggctatactaactggtagcgtt
-cttgcttccattatgttattattataattaaaaataagacatatggtagagttgtagtca
-gggtggatcgggttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaa
-tttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacattcacagcacaccc
-ctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaatt
-ttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaattcactagtatc
-ctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatcaagatgtatgat
-ttttggtccgctgtgtggaatacctctattgatatacaagtgactttctcggtaataacg
-cacttcacaatgtgttgtttcttttctatgtattttgcaagagaaagaagcttagtatag
-gtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacat
-tatccaaattcaccacaattactaatccacccttttacttttactaaagatatattaatt
-ctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaaggataccaattg
-aagtcctcgaggcatgttacaacacacgacttccttccgtctattcagacactcaacgag
-actaacttttcctaggtaatcaatgatattgggtaactcgtggcatcttatagttattga
-tccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgc
-aggggatacgtttattctacgtacccgatttggttactactaagcggcctttcttcaaac
-ttgcagttgtgacttacattcctatttcttcaaagcagggaagggttacagggagagact
-tattgagatacgattggaatttccatgtacaatcgttaatacgcttgtagaccagcaact
-cagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattact
-aaaaccctagttgttaatataagaacgattcgaaacaataggattgcccaagggggtgcg
-aacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgtttctagtacgca
-agaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggcttattctacttt
-ttccgacactcaatggacgagacaaacatgaacggatagctttaggtctcgttgaatgca
-aagaatagaatcgttattattaatcggtttccattatctatatgcggtatagatctccga
-gaggaccctgtaaactagctctgcggtttaactggtgctaatagaccgccactatgttat
-tgcttctagctcctagcgtcttatcatgttatacattaatgtcgcatattggacagtagc
-caggcttggatggatcgccgacaaaaagaaaagactttccctgtaaggacttaactatta
-catataacttggatcattaatctgcaaattagagtaacggtctttcaccagcttcatatt
-ccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattggcagtctcacttc
-acagtgcgtatctatacgacaaaagtggtcgatttgcataaatatcttatcgatattcag
-gttattaccgattccttgctaacgctagaagtcacaccagagtaataataattccagaca
-cctgtgaaataatcggtcactacggatagactagtaacgataatacgtatagtccataaa
-agttgaattttaggggctaaagatattagcaatactggtctagcctaatcgtcgatagca
-aagggctgtgaggatttctcctacattttcgaccaattgtatcgataggaatagttacag
-tcacgcttgtagatgtaagagatgacgttattcttagggttcttaagtcggggggtaatt
-taagaccactagtaaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaa
-aaagtttacaacatcctttaagttagcaactgattttagtggcaaccttaacggttgaat
-tgatctactaatacaggcctacaccgaagggtacagataatgattcttactaccctaaca
-tgatagagtcctgtcctatctcataggtcgacattttaaattcgtaatgagcaacgaaga
-tcgtttcccaatttgcaacattcacttatagacttcaggttatttcgtgctaacattaag
-atagaatataatcagtcgttaagaaactattatccagctttcgtcaaccataaagattaa
-aaactgaaacttggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgct
-ttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaa
-tattaatatactattaagctacacagcaaaggctgcaataatgttagtaagtagaacata
-aaggtattctccacaagtaataaatagtgtgagctaattgactaacttaactctcgcgac
-aagtgatgtggataagatgactcatatcgtctttttctgtagtgccgacatcccacctgg
-atcgaacaattccttctagttatcgactttgattacctatcctattaaacagatagggtt
-gtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagttagaacgcgtag
-atagaggccttttgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctt
-tcgtgtccgaatttgtttaacatccattagattagatgtttgtgttttgggtctgatgtc
-ctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtct
-ccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatttagaacacacct
-tatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaag
-gaacttaaagtcggatcactcttgtcagtgtagataagaatttctttcatacttcactgg
-aatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttg
-ctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatag
-catcaggccttcttatccagcgtgaagtctaattatttcacaagctttcctaagtatgta
-aatccctcacttaatgatgcttgcgccaatgaggatagaggacattgcatgtacgtagga
-ctattctccaaggggtcttctattttgttagcgaaaattgttacagcctaatgttagagc
-ggcgtacgactttataccagatactttcattagatatgcaaatatccaattaaatcatag
-tagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcg
-ttctcatatatatagatcaacaatgaataatctcatgatctataaccgatgtatatttat
-attccggttgactgctccggtgcaattcactacggacactaatgactaatatggcgcctt
-tcatcagaaacgctaaatatgattaatgaattaagggagtattatctaattattagagag
-tagcagttagtctgatattttcggtgtatgtgttagccgttataatgctgtctttttatc
-agtgagaacagggagtgtgtagtgttgtatgcttcactttatgactctggttatatccct
-cggagaacaagaataagagtacgagaagttcggtcattgaggatgaaatagaaccgctag
-acgaatggactcacgtttataaaactatgtatcacagtactacagctaactctgaagtcc
-gagaagcttttgtaggacaaaacgttataagtacctttcgcagaatacggccgtgcatac
-ctgttataaggcgtagtagggacaccatgctatccctcatatagagctacactaatacca
-ttacatggtgactatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatcc
-gtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactat
-tcgaagcttctcaatccttttccattatggcatagcaagtgacgactcgtcagccatggg
-aataatagcactaatccgattacttatgaattagaacccacatgaatgtgattctgcgaa
-ttgtctaagaatctaatgattttccggtgaatatggttgttgttatttattgaacttata
-ttattaacatcacccttcgttagtgatagtcagctatttccaagaggttccccgagcatt
-tttaccattctctagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcg
-ttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaac
-aggtcacccgtttttcgttacatatgctggtaaaatattcatagtaataactacaatact
-tgatttgttacgtaatgctcgtacataacacaatcgtattccacggaacagtaaagctct
-attattctgatcgagcctaagagaggatcacactacgctattaaagtcacgttcacgaaa
-tctcaaacctcaactgctggtgaccagttatagacagtgtaattccatattacatgtcag
-gcttaagctaacccgagcctttatataagctataatcaagaattagattggagtgcattt
-tagacttatctatcgaaatagtgatagtaagagtttatatgacctgatctagactgatgt
-tctcttccacaacagccttaaggcgtggagcctttcttatactattaggtcgcgtcgaga
-gccctattcgtaatgttaacgacactagactaatatacaatgagctaagaataacacaag
-tcacaagataatttacaaatcatatatctacagtccacaaccatcactagcgattgcaaa
-gcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcc
-tctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtga
-gtcatgtgcaactatacagtttagtttggtcaagactatgcaactattaacagcatgtgc
-gcattgaatatttggtgtcgattgataaatgccccaacgttccatcacgtctataagccg
-tgttactaatgtgtattagtgcatacctattcagaccatagttcaactgttggactgaag
-gcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaa
-atgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagccaatgggctccc
-attgagctagtatggtgctttacctttgtaagtggtggctttccttggtgtgctgacttt
-aacacggcagagtgattatccgaagaatggataataagacgctggcaatattggctaata
-aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca
-tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg
-tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg
-gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc
-atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc
-cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt
-caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat
-tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt
-agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt
-ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt
-aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta
-ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat
-cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac
-gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa
-atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc
-ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta
-gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt
-aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt
-aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc
-atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac
-tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat
-cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc
-taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt
-taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt
-ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc
-acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct
-cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg
-tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt
-attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat
-cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga
-atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc
-accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag
-tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc
-acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag
-ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa
-gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc
-cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg
-aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca
-tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta
-atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac
-ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc
-gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat
-ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt
-gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata
-gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc
-atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga
-agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct
-aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac
-ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc
-tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa
-cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc
-gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga
-atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta
-ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca
-gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt
-acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga
-tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg
-ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc
-ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt
-acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat
-tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag
-tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga
-tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca
-aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg
-aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg
-actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt
-tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa
-gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag
-tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc
-attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt
-gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc
-atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact
-ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta
-aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt
-gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta
-taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga
-tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc
-gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca
-cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga
-ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac
-agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat
-aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt
-atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac
-actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa
-tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa
-ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta
-cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag
-ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc
-ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag
-cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag
-tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc
-agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat
-gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc
-gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca
-ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct
-acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga
-tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat
-tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg
-cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac
-cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata
-agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca
-aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg
-gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta
-atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg
-ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag
-acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta
-ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg
-gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc
-atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg
-actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg
-cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt
-cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa
-ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca
-tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta
-atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc
-acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct
-gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta
-ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc
-aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga
-taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa
-cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca
-tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta
-gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg
-gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag
-ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat
-tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta
-aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt
-aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc
-cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca
-acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta
-aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct
-cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa
-tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt
-cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat
-tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt
-taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg
-ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt
-taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc
-accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa
-ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg
-atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg
-taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga
-aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt
-attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt
-atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa
-attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa
-cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg
-agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt
-tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca
-aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa
-actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag
-tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta
-acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg
-tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat
-agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag
-ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat
-tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt
-attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta
-tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt
-ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt
-catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga
-caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc
-cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac
-accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca
-atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct
-tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct
-cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat
-gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca
-gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga
-agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca
-ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc
-ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa
-aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc
-ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga
-tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt
-taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg
-caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt
-tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc
-taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac
-gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca
-gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat
-aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt
-atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc
-gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat
-aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa
-aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga
-aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat
-ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc
-gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa
-acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac
-attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc
-gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag
-gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct
-gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata
-tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat
-ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata
-aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc
-tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat
-tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa
-ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt
-agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
-cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
-tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
-tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
-gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
-tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
-tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
-atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
-cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
-ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
-ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
-atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
-gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
-tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
-gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
-atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
-tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
-ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
-tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
-aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
-gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
-ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
-agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
-agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
-acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
-cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
-cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
-cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
-aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
-tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
-atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
-cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
-tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
-catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
-tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
-caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
-tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
-aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
-aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
-ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
-gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
-ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
-cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
-gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
-ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
-cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
-taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
-gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
-taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
-ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
-aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
-gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
-acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
-ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
-tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
-tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
-tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
-ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
-aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
-tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
-gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
-gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
-cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
-actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
-tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
-ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
-ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
-agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
-gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
-tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
-atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
-cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
-tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
-gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
-gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
-aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
-gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
-cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
-taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
-tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
-ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
-aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
-gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
-aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
-tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
-tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
-aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
-ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
-ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
-caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
-gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
-cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
-ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
-tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
-atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
-ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
-acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
-taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
-ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
-aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
-cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
-tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
-gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
-aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
-cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
-cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
-gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
-cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
-gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
-agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
-aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
-aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
-cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
-agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
-cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
-agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
-gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
-aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
-agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
-cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
-agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
-ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
-tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
-gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
-gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
-ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
-gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
-atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
-tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
-ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
-tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
-cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
-ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
-aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
-gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
-ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
-atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
-aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
-gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
-atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
-aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
-tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
-ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
-gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
-cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
-ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
-ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
-ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
-cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
-tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
-tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
-cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
-gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
-ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
-ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
-tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
-agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
-ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
-cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
-agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
-tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
-gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
-ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
-ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
-agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
-attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
-ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
-agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
-aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
-gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
-gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
-ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
-gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
-ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
-taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
-aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
-tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
-ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
-agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
-ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
-agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
-gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
-tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
-gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
-cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
-ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
-cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
-gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
-gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
-tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
-cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
-aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
-ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
-gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
-aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
-gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
-aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
-gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
-agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
-caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
-gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
-aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
-tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
-tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
-ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
-ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
-gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
-ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
-aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
-tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
-acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
-atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
-gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
-tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
-cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
-gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
-acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
-acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
-attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
-tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
-cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
-aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
-ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
-tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
-gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
-gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
-acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
-gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
-gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
-ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
-taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
-agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
-gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
-ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
-accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
-tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
-taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
-catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
-tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
-ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
-aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
-atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
-tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
-ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
-tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
-aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
-agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
-acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
-aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
-ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
-gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
-taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
-taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
-tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
-gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
-ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
-atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
-tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
-cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
-aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
-taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
-caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
-ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
-tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
-tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
-gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
-gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
-gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
-ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
-tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
-taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
-gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
-ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
-gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
-tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
-ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
-tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
-cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
-ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
-caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
-cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
-gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
-cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
-taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
-tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
-taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
-tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
-tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
-tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
-ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
-aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
-atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
-actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
-gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
-ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
-gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
-tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
-aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
-atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
-catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
-taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
-ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
-cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
-agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
-atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
-tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
-gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
-attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
-tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
-tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
-gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
-attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
-aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
-ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
-taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
-atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
-aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
-agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
-gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
-tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
-taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
-cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
-aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
-ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
-gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
-tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
-ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
-cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
-aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
-cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
-ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
-tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
-ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
-atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
-tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
-ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
-acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
-ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
-aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
-gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
-ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
-tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
-gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
-taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
-aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
-tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
-gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
-ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
-tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
-tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
-tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
-ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
-gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
-ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
-gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
-tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
-caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
-tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
-gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
-tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
-cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
-gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
-tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
-caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
-agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
-atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
-ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
-atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
-tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
-tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
-ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
-agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
-acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
-cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
-taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
-acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
-ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
-ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
-cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
-ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
-cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
-attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
-gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
-ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
-aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
-acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
-tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
-tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
-agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
-ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
-tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
-ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
-aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
-cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
-tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
-tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
-accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
-agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
-aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
-gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
-aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
-ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
-cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
-ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
-tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
-tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
-aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
-gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
-cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
-aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
-gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
-gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
-tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
-tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
-accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
-atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
-tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
-atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
-gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
-ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
-tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
-gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
-tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
-gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
-ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
-agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
-aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
-tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
-tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
-tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
-aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
-aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
-aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
-ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
-gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
-tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
-atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
-gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
-tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
-gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
-atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
-gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
-ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
-tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
-gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
-aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
-acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
-acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
-accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
-atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
-aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
-gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
-aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
-caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
-cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
-ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
-aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
-tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
-agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
-caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
-gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
-gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
-acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
-ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
-gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
-cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
-ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
-actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
-tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
-catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
-tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
-tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
-tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
-cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
-cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
-tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
-aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
-cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
-caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
-ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
-tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
-attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
-tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
-gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
-cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
-aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
-ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
-aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
-gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
-gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
-cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
-gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
-tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
-aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
-atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
-ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
-aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
-aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
-cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
-gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
-ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
-tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
-gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
-atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
-ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
-acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
-cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
-atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
-tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
-atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
-ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
-agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
-agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
-atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
-tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
-tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
-taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
-aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
-tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
-acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
-tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
-acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
-ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
-tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
-aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
-taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
-cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
-ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
-attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
-caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
-aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
-atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
-tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
-cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
-ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
-gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
-actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
-cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
-ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
-aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
-ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
-gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
-ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
-cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
-tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
-ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
-cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
-ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
-attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
-agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
-ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
-aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
-aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
-atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
-cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
-gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
-aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
-atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
-ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
-cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
-caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
-tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
-catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
-atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
-tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
-gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
-agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
-actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
-ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
-tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
-ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
-gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
-tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
-taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
-agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
-acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
-cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
-attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
-agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
-gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
-taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
-ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
-tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
-tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
-aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
-tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
-atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
-ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
-aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
-actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
-acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
-aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
-caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
-aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
-cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
-atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
-ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
-agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
-atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
-ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
-attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
-ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
-atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
-taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
-tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
-aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
-ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
-gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
-gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
-ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
-cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
-ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
-aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
-taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
-gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
-gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
-tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
-attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
-caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
-acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
-cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
-taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
-taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
-tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
-ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
-taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
-tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
-gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
-gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
-cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
-aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
-gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
-agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
-agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
-acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
-gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
-tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
-atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
-ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
-gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
-gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
-gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
-atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
-ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
-acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
-tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
-tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
-cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
-aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
-gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
-ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
-taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
-gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
-tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
-tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
-caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
-ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
-gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
-ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
-aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
-ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
-tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
-gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
-aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
-ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
-cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
-attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
-ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
-gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
-ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
-atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
-atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
-atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
-cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
-cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
-gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
-accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
-tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
-aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
-cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
-tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
-cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
-acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
-cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
-ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
-agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
-cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
-acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
-gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
-gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
-cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
-gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
-ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
-ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
-agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
-gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
-tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
-tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
-ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
-ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
-ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
-catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
-ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
-tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
-aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
-gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
-agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
-atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
-taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
-tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
-cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
-cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
-tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
-catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
-catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
-ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
-tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
-ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
-ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
-ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
-tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
-ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
-tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
-aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
-gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
-ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
-agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
-taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
-ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
-agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
-gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
-agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
-ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
-ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
-acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
-aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
-ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
-ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
-tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
-gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
-ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
-tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
-aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
-ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
-atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
-acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
-gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
-acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
-ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
-ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
-gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
-agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
-ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
-ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
-gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
-gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
-gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
-cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
-aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
-cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
-gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
-ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
-gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
-atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
-gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
-acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
-aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
-cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
-atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
-tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
-tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
-ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
-tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
-gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
-gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
-aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
-tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
-tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
-attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
-catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
-taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
-ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
-gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
-aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
-aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
-agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
-tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
-aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
-agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
-ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
-taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
-ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
-cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
-tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
-cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
-gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
-cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
-tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
-acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
-ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
-gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
-taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
-tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
-tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
-cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
-tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
-ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
-aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
-agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
-gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
-catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
-tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
-aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
-acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
-tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
-aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
-agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
-gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
-gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
-taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
-gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
-gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
-tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
-agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
-tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
-caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
-aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
-gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
-catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
-ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
-tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
-gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
-cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
-gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
-gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
-ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
-gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
-ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
-cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
-agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
-caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
-gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
-agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
-gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
-ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
-ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
-attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
-cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
-gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
-acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
-ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
-tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
-tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
-taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
-tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
-gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
-agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
-ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
-attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
-aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
-ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
-ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
-ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
-tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
-ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
-atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
-aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
-tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
-cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
-aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
-acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
-agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
-tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
-gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
-attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
-gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
-gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
-gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
-tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
-atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
-gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
-ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
-atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
-ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
-tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
-cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
-tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
-gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
-agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
-aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
-ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
-gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
-ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
-cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
-atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
-atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
-cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
-catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
-ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
-tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
-tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
-tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
-gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
-aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
-caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
-aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
-gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
-agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
-tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
-cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
-taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
-atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
-tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
-gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
-ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
-gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
-tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
-tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
-tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
-gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
-cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
-gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
-tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
-catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
-tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
-caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
-tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
-cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
-gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
-tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
-cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
-acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
-agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
-tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
-atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
-ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
-tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
-caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
-acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
-actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
-atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
-tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
-aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
-ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
-tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
-acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
-cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
-cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
-tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
-gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
-cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
-atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
-aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
-tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
-tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
-acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
-tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
-ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
-tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
-aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
-agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
-ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
-tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
-aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
-acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
-aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
-gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
-ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
-tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
-cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
-agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
-tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
-gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
-accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
-cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
-cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
-accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
-cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
-gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
-tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
-tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
-aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
-tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
-tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
-atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
-ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
-agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
-gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
-caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
-tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
-gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
-tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
-agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
-taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
-gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
-tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
-ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
-ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
-ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
-aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
-tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
-cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
-taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
-tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
-ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
-tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
-ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
-ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
-cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
-gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
-ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
-ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
-atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
-aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
-aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
-acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
-tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
-ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
-gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
-aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
-cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
-ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
-tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
-atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
-taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
-tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
-ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
-ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
-gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
-aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
-gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
-gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
-acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
-atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
-taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
-ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
-ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
-tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
-tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
-tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
-aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
-cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
-tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
-aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
-ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
-attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
-agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
-ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
-aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
-taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
-gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
-caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
-atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
-ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
-aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
-gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
-gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
-ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
-gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
-gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
-ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
-attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
-atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
-aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
-ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
-aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
-gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
-aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
-ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
-ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
-agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
-tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
-tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
-aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
-agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
-ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
-tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
-tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
-acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
-accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
-agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
-taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
-gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
-ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
-aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
-gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
-aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
-taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
-aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
-ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
-tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
-tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
-gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
-agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
-cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
-attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
-ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
-aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
-agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
-gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
-cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
-ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
-gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
-tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
-acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
-tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
-attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
-gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
-gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
-gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
-aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
-tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
-gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
-caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
-ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
-atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
-accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
-ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
-attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
-atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
-attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
-cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
-ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
-taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
-agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
-ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
-cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
-catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
-tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
-aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
-atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
-gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
-gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
-acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
-tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
-agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
-tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
-ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
-ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
-tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
-tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
-agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
-aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
-caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
-aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
-acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
-ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
-tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
-cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
-tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
-gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
-aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
-tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
-attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
-cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
-aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
-tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
-aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
-aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
-atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
-atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
-aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
-atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
-ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
-actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
-agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
-ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
-atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
-tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
-atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
-tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
-ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
-atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
-tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
-catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
-caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
-actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
-ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
-agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
-aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
-ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
-cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
-gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
-gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
-attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
-cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
-taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
-acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
-gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
-ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
-tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
-cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
-ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
-taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
-ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
-gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
-acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
-atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
-gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
-acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
-agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
-aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
-ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
-gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
-agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
-aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
-gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
-gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
-ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
-ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
-cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
-aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
-ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
-gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
-atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
-atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
-caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
-tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
-taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
-gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
-ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
-tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
-aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
-ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
-gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
-caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
-attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
-gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
-tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
-gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
-aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
-ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
-cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
-ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
-aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
-gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
-cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
-atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
-atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
-agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
-cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
-cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
-ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
-acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
-tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
-attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
-caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
-tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
-aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
-tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
-ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
-tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
-acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
-agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
-tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
-ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
-gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
-ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
-gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
-cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
-cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
-tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
-ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
-tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
-tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
-aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
-gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
-agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
-cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
-tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
-tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
-ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
-gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
-acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
-ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
-gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
-gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
-ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
-agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
-tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
-aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
-cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
-attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
-gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
-ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
-aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
-ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
-tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
-ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
-gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
-acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
-gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
-ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
-tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
-tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
-cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
-acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
-ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
-tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
-tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
-tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
-tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
-attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
-cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
-cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
-gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
-ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
-cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
-gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
-tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
-gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
-agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
-tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
-caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
-acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
-cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
-gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
-caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
-acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
-cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
-aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
-gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
-cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
-gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
-atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
-ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
-actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
-ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
-attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
-ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
-attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
-ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
-aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
-atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
-caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
-attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
-tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
-tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
-gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
-ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
-cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
-caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
-attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
-tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
-tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
-tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
-ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
-gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
-aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
-ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
-tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
-taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
-accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
-gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
-atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
-acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
-tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
-tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
-gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
-cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
-tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
-cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
-cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
-cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
-ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
-tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
-cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
-gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
-tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
-tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
-tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
-atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
-gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
-cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
-atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
-tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
-gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
-ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
-gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
-attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
-aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
-taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
-atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
-agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
-gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
-gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
-ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
-gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
-cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
-tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
-agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
-tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
-cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
-attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
-gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
-atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
-ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
-taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
-gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
-ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
-ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
-ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
-ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
-ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
-gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
-ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
-acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
-cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
-gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
-actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
-gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
-actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
-gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
-atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
-ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
-ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
-actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
-ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
-ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
-gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
-tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
-gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
-gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
-agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
-ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
-tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
-aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
-gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
-tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
-cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
-gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
-agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
-agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
-atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
-ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
-cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
-ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
-taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
-tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
-gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
-ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
-agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
-gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
-gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
-gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
-tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
-atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
-gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
-gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
-tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
-ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
-taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
-cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
-tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
-gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
-accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
-atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
-ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
-cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
-ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
-actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
-atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
-agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
-accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
-catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
-gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
-tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
-tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
-ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
-ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
-taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
-aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
-tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
-cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
-acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
-tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
-ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
-gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
-tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
-tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
-ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
-gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
-gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
-tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
-taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
-tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
-gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
-atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
-ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
-ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
-atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
-gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
-ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
-ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
-acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
-cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
-gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
-cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
-tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
-tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
-tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
-tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
-tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
-taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
-cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
-tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
-aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
-agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
-gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
-tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
-cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
-tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
-aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
-aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
-cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
-tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
-caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
-ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
-ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
-aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
-tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
-gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
-aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
-gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
-ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
-gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
-atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
-acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
-gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
-tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
-aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
-aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
-atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
-gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
-ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
-tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
-ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
-agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
-tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
-gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
-tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
-catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
-aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
-aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
-ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
-cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
-tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
-tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
-aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
-tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
-tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
-agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
-cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
-actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
-gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
-cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
-ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
-gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
-tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
-actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
-tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
-gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
-ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
-gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
-tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
-ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
-ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
-ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
-cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
-gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
-tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
-ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
-tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
-cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
-tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
-ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
-ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
-ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
-ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
-attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
-atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
-tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
-aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
-tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
-ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
-cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
-atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
-atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
-cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
-tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
-agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
-gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
-tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
-cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
-cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
-cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
-atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
-ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
-catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
-actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
-agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
-tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
-ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
-atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
-tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
-tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
-ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
-agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
-ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
-tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
-ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
-agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
-attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
-acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
-ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
-acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
-tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
-cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
-catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
-tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
-tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
-ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
-ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
-ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
-ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
-ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
-gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
-tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
-tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
-agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
-ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
-tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
-aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
-gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
-aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
-tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
-cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
-tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
-ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
-ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
-atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
-actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
-tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
-tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
-tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
-aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
-taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
-acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
-taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
-gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
-tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
-ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
-gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
-taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
-gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
-aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
-gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
-tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
-taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
-gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
-acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
-agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
-aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
-attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
-attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
-acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
-gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
-acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
-cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
-ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
-taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
-aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
-tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
-atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
-ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
-gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
-ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
-agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
-taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
-ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
-cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
-catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
-agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
-taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
-cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
-ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
-ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
-tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
-aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
-ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
-ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
-acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
-cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
-ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
-atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
-taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
-atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
-tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
-gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
-cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
-aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
-tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
-acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
-gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
-gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
-ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
-gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
-ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
-acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
-aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
-catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
-acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
-tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
-cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
-gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
-cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
-tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
-gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
-atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
-tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
-aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
-cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
-attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
-tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
-aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
-ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
-attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
-ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
-aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
-tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
-ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
-tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
-agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
-ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
-agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
-tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
-agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
-gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
-tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
-atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
-tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
-ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
-caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
-aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
-catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
-actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
-ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
-ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
-ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
-gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
-gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
-agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
-ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
-tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
-acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
-gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
-gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
-tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
-cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
-tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
-tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
-cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
-cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
-aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
-ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
-gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
-acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
-acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
-aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
-cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
-gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
-actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
-atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
-gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
-ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
-ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
-tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
-cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
-aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
-tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
-gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
-attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
-ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
-ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
-tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
-gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
-gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
-tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
-tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
-attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
-aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
-cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
-aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
-atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
-cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
-taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
-caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
-ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
-tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
-agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
-tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
-aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
-catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
-actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
-agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
-agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
-acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
-cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
-acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
-cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
-aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
-tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
-attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
-aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
-tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
-aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
-tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
-aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
-tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
-tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
-acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
-tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
-ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
-ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
-ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
-cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
-aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
-acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
-tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
-ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
-gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
-ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
-aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
-ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
-agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
-atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
-tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
-tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
-ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
-cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
-tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
-tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
-gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
-gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
-ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
-acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
-gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
-atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
-atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
-aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
-gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
-tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
-attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
-cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
-gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
-gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
-gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
-aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
-caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
-agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
-tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
-ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
-cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
-aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
-cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
-tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
-tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
-gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
-taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
-ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
-ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
-cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
-gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
-cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
-actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
-gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
-ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
-gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
-actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
-tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
-cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
-aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
-aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
-ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
-cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
-aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
-aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
-aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
-ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
-ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
-catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
-attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
-tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
-acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
-cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
-tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
-cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
-agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
-cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
-tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
-atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
-atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
-tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
-gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
-gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
-cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
-gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
-cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
-caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
-atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
-gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
-ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
-tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
-cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
-gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
-aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
-cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
-ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
-tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
-taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
-gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
-attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
-tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
-tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
-tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
-caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
-ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
-ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
-cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
-ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
-cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
-gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
-taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
-agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
-catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
-ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
-tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
-ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
-atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
-ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
-cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
-ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
-tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
-ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
-atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
-gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
-atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
-tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
-tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
-ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
-acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
-ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
-ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
-ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
-gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
-ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
-tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
-acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
-tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
-attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
-atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
-ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
-atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
-cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
-tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
-ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
-ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
-ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
-cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
-gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
-gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
-ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
-cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
-aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
-ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
-gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
-aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
-caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
-aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
-gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
-agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
-acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
-ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
-aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
-tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
-ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
-gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
-ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
-gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
-ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
-acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
-tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
-tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
-ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
-cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
-tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
-aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
-gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
-tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
-acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
-atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
-ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
-acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
-attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
-tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
-tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
-gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
-ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
-tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
-ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
-caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
-ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
-taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
-tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
-cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
-ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
-tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
-tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
-taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
-aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
-taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
-ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
-aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
-atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
-gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
-ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
-tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
-acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
-agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
-tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
-aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
-atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
-gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
-gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
-tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
-ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
-gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
-tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
-atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
-ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
-cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
-aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
-gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
-aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
-gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
-tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
-gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
-ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
-gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
-catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
-taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
-gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
-tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
-cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
-attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
-ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
-gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
-atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
-gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
-atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
-gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
-aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
-ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
-gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
-atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
-tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
-tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
-tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
-tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
-ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
-gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
-atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
-taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
-atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
-acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
-gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
-ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
-cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
-ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
-aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
-attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
-acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
-taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
-cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
-aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
-tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
-ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
-tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
-gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
-aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
-ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
-ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
-gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
-ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
-aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
-gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
-tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
-atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
-tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
-tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
-ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
-tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
-gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
-ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
-acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
-taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
-gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
-tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
-atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
-aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
-aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
-ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
-cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
-tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
-ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
-tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
-taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
-gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
-actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
-ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
-tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
-cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
-atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
-ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
-ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
-gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
-tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
-tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
-gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
-gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
-ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
-tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
-tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
-tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
-gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
-cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
-gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
-tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
-cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
-taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
-cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
-tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
-ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
-ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
-ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
-cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
-aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
-attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
-ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
-tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
-tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
-tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
-cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
-atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
-agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
-aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
-tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
-tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
-gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
-taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
-agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
-agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
-ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
-ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
-cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
-cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
-aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
-acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
-ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
-tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
-agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
-taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
-taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
-ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
-acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
-atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
-gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
-tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
-aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
-agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
-aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
-gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
-taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
-ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
-ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
-atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
-tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
-gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
-atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
-ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
-cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
-agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
-ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
-gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
-tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
-tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
-acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
-ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
-tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
-attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
-cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
-atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
-gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
-ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
-taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
-gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
-ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
-atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
-tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
-gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
-tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
-tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
-tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
-tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
-actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
-ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
-cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
-tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
-tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
-ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
-ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
-gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
-ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
-cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
-gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
-tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
-gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
-aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
-actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
-acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
-aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
-ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
-tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
-gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
-aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
-cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
-cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
-ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
-aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
-gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
-tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
-cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
-catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
-gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
-acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
-gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
-gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
-agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
-aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
-tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
-taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
-caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
-tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
-tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
-tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
-atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
-cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
-ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
-tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
-cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
-aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
-atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
-gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
-atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
-tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
-gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
-ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
-aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
-taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
-aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
-gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
-catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
-cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
-gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
-ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
-taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
-atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
-atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
-acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
-tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
-agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
-ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
-accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
-tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
-gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
-ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
-gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
-tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
-acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
-atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
-ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
-tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
-tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
-aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
-agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
-attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
-tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
-gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
-tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
-actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
-gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
-acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
-gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
-actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
-gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
-tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
-tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
-gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
-atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
-attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
-aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
-aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
-accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
-atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
-ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
-cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
-cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
-gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
-tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
-agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
-ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
-aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
-gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
-ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
-gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
-atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
-tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
-gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
-cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
-cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
-atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
-tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
-cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
-aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
-aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
-ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
-ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
-gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
-tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
-attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
-cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
-ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
-ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
-tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
-acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
-atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
-gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
-gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
-agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
-tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
-attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
-ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
-gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
-cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
-tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
-tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
-atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
-agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
-cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
-atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
-agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
-cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
-tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
-ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
-ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
-gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
-acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
-tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
-atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
-ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
-acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
-tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
-actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
-actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
-aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
-aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
-actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
-tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
-tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
-tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
-atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
-ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
-attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
-ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
-aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
-tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
-taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
-aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
-ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
-caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
-ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
-agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
-cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
-atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
-actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
-taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
-cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
-gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
-ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
-atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
-cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
-tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
-atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
-gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
-gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
-tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
-ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
-tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
-tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
-gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
-gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
-agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
-aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
-gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
-atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
-ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
-accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
-ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
-gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
-atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
-actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
-gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
-gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
-ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
-tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
-ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
-acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
-taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
-ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
-aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
-aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
-ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
-tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
-tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
-gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
-tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
-tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
-aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
-aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
-cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
-ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
-aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
-gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
-tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
-ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
-aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
-taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
-ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
-taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
-acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
-gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
-ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
-aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
-aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
-attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
-ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
-cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
-ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
-agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
-tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
-aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
-cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
-tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
-actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
-tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
-cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
-ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
-agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
-attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
-tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
-gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
-gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
-caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
-gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
-ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
-cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
-tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
-gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
-ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
-taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
-agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
-gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
-atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
-caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
-ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
-ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
-taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
-caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
-aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
-taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
-gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
-ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
-catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
-attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
-ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
-aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
-acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
-aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
-ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
-tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
-acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
-ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
-ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
-gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
-gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
-agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
-ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
-aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
-tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
-tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
-ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
-agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
-gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
-tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
-tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
-ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
-tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
-aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
-ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
-cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
-gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
-ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
-ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
-gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
-tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
-gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
-atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
-tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
-ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
-agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
-cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
-gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
-ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
-agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
-cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
-acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
-gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
-catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
-gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
-aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
-aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
-atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
-ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
-aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
-catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
-aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
-cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
-acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
-aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
-cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
-aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
-gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
-ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
-ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
-gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
-ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
-cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
-aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
-tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
-taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
-ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
-caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
-gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
-accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
-ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
-tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
-taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
-agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
-ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
-aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
-aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
-ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
-tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
-ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
-ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
-tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
-ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
-cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
-cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
-taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
-tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
-ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
-gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
-tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
-tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
-ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
-aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
-gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
-cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
-aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
-tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
-gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
-aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
-gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
-aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
-acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
-tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
-aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
-ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
-cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
-gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
-tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
-ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
-cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
-ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
-atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
-tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
-accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
-aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
-gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
-aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
-cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
-tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
-gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
-cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
-catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
-ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
-gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
-gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
-gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
-cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
-aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
-cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
-gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
-agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
-ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
-agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
-gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
-aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
-attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
-cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
-agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
-ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
-tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
-gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
-taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
-ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
-gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
-atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
-tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
-ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
-actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
-ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
-ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
-cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
-gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
-atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
-atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
-aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
-taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
-atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
-aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
-tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
-ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
-gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
-gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
-tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
-gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
-gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
-gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
-tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
-aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
-cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
-gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
-ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
-ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
-tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
-cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
-tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
-gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
-agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
-aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
-gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
-cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
-tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
-ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
-atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
-ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
-agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
-aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
-gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
-gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
-ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
-tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
-gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
-tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
-acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
-taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
-ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
-agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
-ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
-cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
-gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
-tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
-tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
-cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
-ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
-ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
-tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
-tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
-tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
-gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
-aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
-gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
-tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
-aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
-gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
-cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
-tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
-agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
-catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
-gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
-caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
-tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
-tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
-ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
-ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
-tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
-tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
-ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
-tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
-acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
-attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
-gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
-tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
-cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
-ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
-acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
-acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
-cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
-tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
-cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
-cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
-atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
-aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
-tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
-gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
-acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
-gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
-gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
-ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
-tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
-agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
-gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
-tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
-accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
-acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
-aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
-cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
-tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
-ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
-aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
-atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
-tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
-gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
-tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
-caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
-aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
-acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
-catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
-ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
-tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
-taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
-aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
-tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
-tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
-atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
-ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
-ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
-gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
-cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
-tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
-catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
-tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
-agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
-tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
-gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
-tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
-gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
-ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
-tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
-tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
-gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
-ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
-gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
-tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
-ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
-tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
-cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
-ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
-caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
-gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
-ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
-cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
-aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
-aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
-taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
-accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
-tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
-tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
-ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
-aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
-atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
-cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
-ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
-atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
-gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
-tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
-caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
-ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
-catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
-aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
-gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
-cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
-agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
-atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
-tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
-tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
-attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
-tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
-tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
-taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
-attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
-cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
-tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
-tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
-atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
-aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
-agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
-gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
-agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
-taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
-cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
-cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
-ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
-gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
-aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
-ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
-cagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaac
-aagtggtctaaaaagactgccctggaaggagtaagaagtatacagctgatccggtgtatc
-cttcagtcatctgccctatactaattacacgacgcaaggaaaaataggtttattttctag
-gcaaacccttcataggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgt
-taccgacggataataacgatctccaatgaaccaaatgtagaatgtctattgattaccctt
-ttactattcgacttagagataggagatagaacctcagtgtacttttttagccgaatggga
-atctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatat
-tatatcgttgttcgtggaatcgataacagatttgttgacccatagtaaatgtatactagt
-ttatgttgtaagtgtagattgttttccgattgccgtccaaactttatgtcgtaattgtag
-accagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaattttt
-ccagtcactgtaagtgtaggtttagataaagccgtatgagttatatcataagggcctcgg
-aaagcagcttcgaaccaaagttcccttataatagtagtttaactataaaagtatatactg
-gtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacgtcattagagcgg
-ctccaatttaaggttaacggcttccatgtgtagttgtatacaaggataacttaaagtatc
-tgttcagcgagctagttaagttatcctcgatagaacacaactcagaggtcccaagatcgg
-gtttgcaacttgctaatttattctcaaggcaaattgggaattatcgatacctgtatacca
-taaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttagttagtgctgatt
-aacggaacattaatgtttatcgttttgagatttagccaattctctgattctaactcaaga
-tgccttatctgacgtgctatgcagcccctaagtattttacattgtaataggacacgctcc
-tttaaaactcgccaaaaggtcgttgtggttctctactggttaactatataatttacagct
-ttgttgagctagttcctctttggtttaagtcctcaatattagttggttcgagcgataagt
-tggctagttaccttagtcactatattagatccgaatgttatgcttcatctgaagaccgcc
-accctccaaaatttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtt
-tctcaagtggtgtatctgtacacgagtttccatattttcatcaacagccaccgcacactt
-atgtcactctaggtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgc
-tagtcaaaaataaacatagcgaggcaccactaattcggccgcttatcaatgggatgctct
-gcgcgagacgcgccagagctcagtagttagttcggacatacatttacttcagatgatcaa
-ttagttttctacaaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctt
-tagtatccttccgtcttatataaggtcagtcccccgtttcggtaccctggaatttactaa
-gaataatgaaacagcccccaaggacgtacgtttacaaatgatagaccagatcgcctagct
-tattccgacgcatgttgcatagaattgaaccaacggaatgtgagagtaactagatgagcc
-gaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatg
-tcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctc
-ggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatg
-gctcatatggaatgcctacctcatagtgctgaattaacacagcactgcggacctaacttt
-tcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgtagggatcctcggt
-gaatttgtgattgggtttgttgtagtactgaccaagtgaatattctttttttctaaaagc
-agatctgctgccgggcactacgaaggagatctctgtgtatcattattgcttcttgacatg
-atgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacat
-attgttgatacttcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaa
-atactggtgacttggtcctatctactattagctagacctctggggaaccacgcccccgta
-aaacctgtgcaagagagggggtcatacatcttagacatcgcgcctccaccagggaagcat
-tgggtgattgaccaggtgtgtaacaaatatgattattcttatactaatattagcaaagat
-gcataatgatttgtattaaatgtataattgaattgataagggtcttttagtcagtgatag
-agtagtataaggtagacattagaactcttaaccggacgcagatttttcggtcttagtaag
-ccaattagtcgacaaaacaaggtaagagcggttactagtagtacctataatgcactgaat
-cttcggtcgaagtatagttctaatgctatgcagattgtgacggcgacaaatgttcagact
-tatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattgaatatttttaaat
-acaaaatgcgcctacttattaggggaattaaccagattgaaggccaatcctcacatgtaa
-tgagataatagacgataaatgaaattcttgtaatagttgaactgctacgtgatgggtatt
-atatatgattgagatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaa
-cgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcact
-ccgaagtataagcaataataatgcgggtaatccagactagatcttttcggactcaatgcg
-gtttcacggtaaacatgattaataccggagagtagtcgagcttatcagcgatgcaagcga
-attcattgtgccaggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttg
-gcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaa
-gtccattaccttttagtttcagactggtggagctgactaaagttatatcatcattttgta
-cactggtttagttaacgataatttcagatttaacatgaccagacgataatcgctgtatat
-ccagttggaatgtggtttgccagaaaggttaacttataatcaagcctctcttcagtcttg
-attcgtcgtatcccatccattgcgctatacctcagtgtatttggagctgtagttataccg
-tgtgctaagatcagtagacatgacgagagcaatattatctaccttacaagcatcaacgga
-cgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatatactatagttctg
-tattcagcagttattcttatattcgatattatcttgcctattggatgtctgactttagta
-tattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaa
-ttataaacggttacaaccattaaagacaacaagaccctatagctttatttgaattttgtc
-aatgcgcaacttggagctcgcgatacatcccaattagtctatagggtcgggacgattcta
-cggcatttctggttataatgacaacatggattgtggcccgagaatcgctctttcattaat
-taagcaatcattacagtcttataagcgctacttccgagtggtagcaggtaactcgatata
-aggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgatagagaataccga
-ccacagcgcaacctttgattactttcattaaattgtacggctcactcgacatcaagctta
-agattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcag
-aaagcgtacccagagaagatacgctgttacaatatacagggtgaaattattgcctgttct
-tcgtaaccatttcgccaaacttggttagaaatgatagccattcatgatagaaataagctg
-aatgataccagtatctttaactatgtagtcagggggaagataacgatggtccatgtatgt
-ttctgatatgtgacagtattggccgcgtaatttgctaacgaagctacttaatgcctttga
-gcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgagctataatatatg
-ctagtagagaactctggaccatcatctatatgaatactgattcgagcgtgcaattacttt
-agcctgcgtactactgactctacaaaacactctgagataagtttgtagtcagtaagtcgc
-tctctataaaccttttggatgaccattgtacagccacttatagatcccaataaatagcac
-aggagacagagtttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagg
-gcacctattatttgatacctaacctaacggccctttcacaatggagaaatatatgacatc
-gggacaaacacaaatggtgggtggccaggagatatgacatggtggcgtctctaagaaaca
-cggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaa
-gattttgccgtgtaatgacctggtacattgactggtcaggaatacatcactgtagttgcc
-gtagtgtcctgttggtgttccatcaagacacatcgtataacgcaatttacgacggacatc
-agatcaagttatacagattatttaagtatcacgtgtgcattgggacataagggatctcac
-acatgccttggaacatttttgctttgtgccgctttttcgctgcactaccaatccttactt
-accagtatattcaaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcg
-attgggatagacgagacatttgcgagcgccctccacggatacgaatctcccatatcaatg
-tgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagca
-ctcgcatagcagttattcagaacctaatacacaaaaccgtcaaacattttctaattctag
-gtatgggccgatcataggagctaaggtgaaactcataaatgttttgttagatctagcatc
-ctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgtatcctttttaac
-tgaactagtcggtcccatttcgtgactgagatctattaaccgataagattaataacactc
-gcattcgtatcagctcagagtgaagtttttcaataatttgactgatatattaacttctaa
-aataaccctttaagcctcggatccgtttcccaatcacatcaaaaattcttattccaacta
-tctacggattaacaacgtgcatggggatcgtagtaagaacttgttccgatcactttgagt
-atatcaagttgacggcccggttattattgaatagaaacattcacctgctaaattaaatac
-cgcacatcggatacccgatttcagagggccgtcttactaagggcaggctttgttcggttt
-aactgagatgttcattattttacagtatgcttcaactaatatgtaacgaaggacagtgga
-tctgtctccatagtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgt
-tcgagttgttgatcatggcacgtgaaagcaacccctagtattctagacgaaaattttttc
-tagttcatctgataatttgccaattcaaaaacaaccgctggtttcccggcgcattctcta
-aaatggaagtcgaacctagagccattatttgtcggtaacccatgagttccttcttttcag
-aagttaatacactgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcat
-aacaacattggatcaagatagcaatttggctacctattctaattctcactagattcggta
-ttccactacaatatcggcagattaggattggatgaataatcggtgtttaagtccggttgc
-gtctccaatctcctaatttttattaatattgatcttggtgacctattgtaaataaaaact
-tcaagactttgaataacggtgaaaagatagaagactcatttgaaaatggatcatccacag
-atccaaacattagcaagacactaatccccaactagctattctgatcgcgatcgtgctgca
-gtactcctgtcacaatagtctgttcatgatctaattctttttgggctttgttcgatggtg
-attcagaatctttatccggtcgcttccctgtagctactttgtggggatattgcccgggga
-ttatagggttgagatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactac
-atcagaacatcgtgaagacaccatacgcggtacctttatttaccgataacatttcttcaa
-gaaataccggtaagcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaa
-ttttatttaggttactgctcaaggaataaaaactaactatttaatttataataatattac
-aaggctcacactgattagatttgtctataagacttcgcgatcccccattaccggattgtc
-ttaagaataaactagataaaccatgcattttctagataaggcctttagtctaattagata
-caaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaaccttttaattac
-ccgcaaatcactttatgtcgagactacctctgaaatttattatctacctaccgcatgagg
-acttgaaccatcttgtaggagttatgtttattagctaagattcgtttatcctgtagcggt
-ccatgtatattcaacaagcaaaaagcactcagaattgtttttagttgagtcaagactgat
-atataaataagtttccctagttttttcgtggtgggacgatattgaattgaatcttaaccg
-aagagtttcccactctgtcgcacaataatacacgccaatatttccagccctgcttatgcc
-ttaatcggttactcaatctcccattgaagttcattttgatctgcatagaagtttcgggcc
-cagccttttttctgccaccttcctccaagctctgtagacgcactctaagattgatgctca
-catgtattaattctacattaacataaatatataagtcatgcatcttcgagtaaaatatct
-ggttctccaacatgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatg
-attgggttaactggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtct
-caagaccgtgtattcctcgtgctcggaagggctattacgcttacttccgttttggtatct
-taatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaag
-agtataaaagttgtttaaacgaactacttgctttacaataccggtcgtatatatcgccgt
-gaatccagaagattgtcttctttggattatcaaccgagatcctgtggaccgatgttttgg
-gaccttcacagaggactccaggtagagctcgcttttgcattaatctaagaattgtacctc
-tctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaatt
-actttaggccgaaaggcacatgagttattatacatatacgagatggtggtatacatcgaa
-ttcggggcatacactatagttgcattgtatttagctgctttaaataatatgatattacct
-tccttacataagacattaccggcataccctggttttcaacttgtggggctttttgacgat
-cgcactctcatttgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcg
-ctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaatttaaaattgaa
-acttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgc
-aagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatctt
-gatttcattcttcttgtcaattgccgacataggatgaaatcagattccaatgcaatacac
-agtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggat
-agtatacgggccttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgt
-acaatctcacacatagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaa
-ctttattagaagtaaaaatgtgggcaaaagaaggattccattttacaagacgattacaat
-gagttacatgtctctcaacgtagtctttccctagtagtctttgaactatttaggtactcc
-agaaaattttagcaaagggtttctgtgtgaatccgccattcatgtttatgatggaacaat
-aagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatatt
-caatttagtacagatccccagaagttaagctaagtgctctaaaatggcctaaacggttat
-caaagtaggtctaattactatactaacgggtgcatcgtaataactgctgtcgatgcaaca
-ctatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattc
-ttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaa
-atttaatctatgagcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttg
-acaaccgcacacataatcgaactattgatagtcgggagcataaccaggtgaacgtacttt
-gttcacgacatttattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaac
-gcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgag
-aactttagctggcttttggccagtatttagggaccaagagcactagccttaagctgaata
-ttttgccatttatctactgttataactttaaaacttggtggcaccagacttgtcgataca
-cacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttata
-ttatatttaaactaaaagatgatattagcttctgagggcgatagggctccaaatcataaa
-gaggaatatattattacacgattagaaacccacaacatacctcgaatcgcccaaaagttt
-gacgaaacttggcagtactccacatctcagtaatacagttgggagagtctcaaatgttgt
-tttattactcaatgaaccaccctcataatttcactgctgttccattaaatttgcaaacga
-tcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtagatgcataataaa
-aaaaactgctcgctataacacgatcatcgtgcattcttacttaggagcatcacccgcaca
-ataacgtaccttaaactacaacactattagaccgagtactgtaattcacgaaagctcaag
-ctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttgcggagaggattc
-aattattttccattgcacctactccactagattcgataaaagaaggtggtcctcccttaa
-aaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatcctt
-ccctaagaaacataaaggtttttaataatgtcgactgtgaactataactgcatcctttcc
-tgacctactccggttccttgttgttatttctgaacgagaccagtagataaacaatgtaaa
-ccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaaca
-taagaagtcataatcttacttgaaattaattttgccttttattttttttcaggctcgaaa
-ttaatgatttgttttttttgaccttctagttacgctaatatgcggtcgcctgtggtttct
-attgagtcctataacgggatgggatctaatacgtttggttactagtaaacaaggtataaa
-tttgataccggagtatcaactgtataacatcaagctttatgactcatacgcgaagtaatg
-acacaaggctttcaggagatcgcgagtacagagccactaaggggtgtattacgatagtga
-caccaccgagcgcactcactccccaagtagatttatgatcctacgctaagtattagatat
-ataaccaaagaggttctagtcagtgcaactcttagaataataattagccggttttgcctt
-tttaggcctaatgcaatattcagctagcccttatgtatctcgcgttccacagcaccactc
-atggcacgcgtttaaactaatcaaatataatctatgaatgttatgccagtacttgaataa
-atcaggttttttataagtccttgcatactctcgttatatactgttagagtcttaccccat
-agaaattctttcatctgcaaacttagaagaattctcagctacggggagcataaagtcccc
-aggatgttgacaaatacaacaaatgtggcttatacaaacactccatatgaaaatcgaacc
-ctcgtggtagttttagccgaaccttgtacggataaatccctccattttccaatagcagat
-acctatcctactacctcgtggtattaaattaaagcttgaaatatagagctgcatagctta
-tccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagc
-aaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagc
-aacttcgcttattaagacaattgtttataagccataattaaaaacatatgttcaacaggt
-tcattgatatttgtaattgcacaggtttttaataaggatctacgtaagtataatgaacaa
-actttttaccagagttatattctgtactttgaaaatgctcctctaccgccttagagactt
-tcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattca
-accgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaatataattttcagt
-tttcgaacacataaccctttgaaaatctgctatttaatgtctcacctgcatgcactatct
-tctatactgctcagaacggctatacgtcactatgctccaagtgacgatttaaacgaagca
-aggaataataggtttattttagtgcaaaacaattaagtgcggactacgtgctctttacaa
-taagccttgtgattgggctataggttaagtcccatattaacgatctccaatgtacaaaat
-cgacaatcgctttgcattacccggttactagtcgaattacagatagctgttagatactca
-ctctaattttggacaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatc
-cttccatcttaaacgattacatattatagacttgttcggggtagagatatcacagttgtg
-caaacattgtaaatcgatactagtttatgttggtagtctagttgcttttaccattccccg
-aaaaacttgatctactatttcgacaacagtaaacttgaactaggtaagtgaaaacagaga
-atgcctcatagtgccactatttgtccactatatgtaagtgtagctttacataatccacta
-tgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcccggatattacga
-ctgtaactataaaactagttactggtagcgcgccatgtatagatttgttttaccggttgt
-ggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttc
-tataaaacgataaagtaaagttgatgttcagcctccttcttatggttgcatcgagagtac
-actactcagtgggaaatagatcggggttcctacttcagattgtattatctaggcaattgc
-cgattgtgccatacctggataaaataagctacctacatgtgatgcttatctattatcgtc
-atactaccttagggtgtcctgttgaacgctacattaatctttagccgtttgagatgttcc
-aatggataggagtctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatg
-tgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtccttctggttctattc
-tgctgaactattgaatggaaagattggttgacctacgtactatttgcttgaagtcatcaa
-tttgacggggtgagagacatatggtgcatactttacggactctatattttagatcagaag
-cttagcagtcttctctacaccccctcacgacataattgcttttaagaatctatgtttgat
-tcctctacgggaattcggatccgttcgcatgtgcggtttatctaaaccaggggacatatg
-ttcagctaaagcatacgaacactttgctaactagacgtatgtatagtagctataaatccc
-gacgatatttacaaaaagaaatgagactcaaatatatacatagcgaccctacacttattc
-gcaccctgatctaggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgt
-attaaatttactgcagttgagattttagttgtctactaaggattactctaacccgtaata
-aggatcaagactcggtactagctttactatcattccctatgtgttttcctaactcacaag
-ggtacgtaccagcctatgtaattacaataatgataaagacacaaaggaagtaactttaca
-aatgagtctccagttacactagcttagtccctcccatcttgctttgaagtctaaatacgc
-aatctctgaggatatacagcagaagaacactcataacgttggagtccaagaattagactc
-atagggcccccaacatttaatatgtactgtgagtttgaaggtgttctattgttaattcct
-gctcttgatacatgacacgtactccgtgtttaaggcttcggactgactttctttcataag
-ttgagcaacgaaaatttcagaatcgataagttggattcactaactaatacggctgattga
-aaactccactccggacctatatggtcgacctttatacgtaaccgatataaaacttatagg
-ctggtatatcgagccttcctagcgcaatttcggatggggtttcttctactactcaacaac
-ggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgt
-ggagcatgtgtcattatggactggagcactcttaaatcactctgcgtgtgctaaacgata
-gatcataacatgtcctgagtaaattttcttgatacgtcgcaatataccgttattagttaa
-acgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgact
-catctcgcctaacacgcacacgtataaactcggaatgactgccgctcttacatattagaa
-atacagactacaccacggaagcattgggtcattctcaaccgctgtataaaagatgattag
-tcttataataagattaccaaagaggcagaatcatgggtagtaaatctattattcaagtga
-ttaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaaatattaaccgga
-cgaagtggtttacgtcgtactttcactattagtagtaaatacaaggtaacaccggggaat
-agtactaaatataatgatatctatcttcgggagaacgagtcgtctattgctttgaacatt
-ctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgttacttttgtctat
-tcaaaagattgaatagttttttatacaaaagccgcatacttatgacggctagtatacagt
-ttcatcccctagcatcaatgctatggacagtattgaacttataggaaattcttctaatag
-ggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatggcactagtattg
-tcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctt
-taacgaagcgacagcgacagaactcccatggataaccaattataaggcccgtaatcctct
-agacatcgtttaccaataaatccgctttctccgtaatcatgttgaataccccagagtagt
-ccagatgataaccgatgaaacacaagtctttctcaatgcacttacggtgaacttattacc
-gccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaa
-cttcatcaactttcgtatattcaacgccttgtaattttactttaagacgcctggtgatgt
-agattcttagataatcagtttgttatcggctgtactttaccataatttcacaggtttcag
-gtcaagaagattatagctgtatatacagttccatgctcggtgcacagaaacgtgatcgga
-taataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagt
-gtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagatt
-agattccttaatagaatataccgacctctagtccgaactaaactatagataacgccaact
-tcaggttaattgtctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggc
-catattggttcgagcactttagtttttgatgcataggatatgcaatgtatagctgaaagt
-actttatctgtttcaaactcacattgattaaaccggtaaacctttaaagactacaagaaa
-atattcagtgagggcaattttgtcaatcacaatcttccagctagagatacttcacaattt
-gtcttgaggctacgcaacattagacggattttcgcgttttattgaaataatcgaggggcc
-caagagtatccatagttcattttgtaagatttctttacaggcttattacagcttcttcag
-actcctacatgcttacgagttatatgctagcatgtgaacaatagattaatatacaggaaa
-acgtacattgagagagatgaccctacacagcgcaaccgttgagtactttcattaaagggt
-aacgctctcgagacagcatccttaagatggccttattgtcaaatcatttgcagaagtacg
-caagatccctaaccaacgtagaagaatccctacaaacacatgagacgcggtgaaaataga
-cagggtgttagtattcaatcttcggagtatcaatttcgccaatcttggtgagaaagcata
-ccctttcttcagagaaagaagatcaatcataacactatctttaacgaggtacgcacgcgc
-atcattacctgcctccatggatctttaggatagcggaaagtattggcagcgtattgtgat
-ttcgttcctactttatcaatttcacattcatatacatgtcttttatcaaaatcgccaata
-agataggatgagctatattagatgctagtagagttcgcgccaacatcatcgataggaata
-ctcaggacagcgtgataggacttttcaatccctaatactctctataattataactctctc
-ttaagtttggaggcagtaacgcgctctatataatcagtttgctgcaccattcttcagcct
-ctgatacatacaaataaattccacagcagtaagagggtttaattgagacatcttgggaac
-ttaggattttactctaacatcaccgaaacgattattggataccgtacctaaacgaacttt
-ctcaaggcagtaatataggacatccgcaataacacaaatgctgcctccccaggagttatg
-tcttcctggaggctatatcttacacccactcactataggcaaactaaagtttaaatgttg
-attgtctaaaaaaaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgt
-aagctataattctctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcct
-ttaaagctatttacgacgcacatctcagcaagttataaacatgttggaagtttctagtcg
-gaattcccaaagaacggatctatctaatgcattcctacatttttcctgtctgccgatggt
-gccatcctattcaaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaa
-ccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccgagccacatacac
-ggagaacattctaacatagcattctcaactcgatcatttgcaggttacttctttcctatc
-ctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacctaagaaacaatt
-cagtaaaacatgttcgaattcttggtatgggaacatcattgcagctatggtctaacgcat
-taatgtttgggtacatcttccatcatataaacaggaagagtctgacgacagggagtgctt
-gcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtg
-tatccgataagatttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaa
-tgtgaagcatatatgatctgctttaataaaactttatccataggatacgtttccaaatca
-attcaataattattagtcaaaatagataaggatgaacaacctgaaggccgatcggacgta
-gaaagtggtcccatcactttgagttgatattgttgaaccacacgttattatggttttcaa
-acagtctcaggatattgtatatacagataatccgataccagttgtctgacgcccctctta
-cgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaac
-taatttggaaagaagcacagtggatatgtctaaattcttgttattcaggcctgaatttaa
-tacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctctaagctaccact
-tctatgatacaccaatagttgttctacggaatctgataattggccaagtcataaacttcc
-gctgcgttcaacccccttgctcgaatatccaactcgaaaagacagccttttggtgtccgg
-aacaaatcagttacttcttttctgatgttaattctctgtggtcagatacagaccaaaaac
-tccgcggatttaccatcctccaagaacaaatttgcatcaacatagcattttggctacata
-ttctaagtctcaatagtttaggttttcaactacattatcccaacattaggattggaggaa
-taatagctgggtaagtccccttgcgtctacaatcgactattttttatgaatatgcttctg
-ccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaat
-caggtgtaatggcagcagccaaagagcatataattagcaacactctaagaacattataga
-tatgatgatagcgatcgtcatgatgttatccggtcacaatagtagcttcatcagctaatt
-cgttttgccagtggtgacttgcgctggaagaatcgttatacggtcccttccctcttgata
-cggtgggggcttattcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaa
-ccatctagtagtcaactatactaaatcacaaaatagtgatcaatacatacccgcttcatg
-gttttaaccatttaattgattaaagatattccgctaagaaccattatctacctaaactga
-tcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgtt
-atattgtatgtagaataataggtcttggagctaaatgatgtgattggtagtgaagactta
-cccttacaactttaccggtttctcggaagaatatactagagaatcaatgcatgggctaca
-taagcactttagtctaatgagataaaaaatacacgagtcttccatcatgaattttttgtc
-gaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaataactctcatat
-gttttatataacttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagct
-atgaggccgggatccggttgagctacatctatttgctacaagaaaaatgaaagcacattt
-gttgggagttctggctacactcatagagaaataagtggcccgagtgggtgcggcctgcct
-ccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcc
-tttatttcctccacggagtagcccgtaatccggttcgaaagagaccattgaagttaattt
-tcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctctt
-caaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacataaatatagaagg
-aatgattcggcgagttaattttcgccttctccaacatggcatccctacgttcgttataag
-gaccatacatgtaggttttaaaggtttgcggttaatcgatatttacatcatagaaattct
-atagtcaaatttacaagactctagatactcactcgttgcagccggctaggaagcgctttg
-taccttacttcccttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactca
-tacctccgtgaagagggtagatagactattaaagttgtttaatagtacgtattgatggaa
-atgacccgtaggagatttaccactcaatccacaagattcgctgctgtgcattatcaaaac
-agtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggtagagatacctttg
-caatttttcgatgaaggcgaccgagataaatgagctataacactgtatgtcttttgattg
-ctataaaacacagaaacggatattaatttaggccgtaaccaacatctgttatttgacata
-gaacagatggtcctttacagcgtattccggccttaatattgaggtccagtgtattgtcct
-cctttaaagaagttgattgtaactgacttaaataagacatgtcacccattcactgggttg
-caactgctggccctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacc
-tgcgtttaaaagacataaatgtcgctatgaaggttattcattaattttagctgttttctt
-agaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttg
-tcaagtaggcgggcatcattgagattgtaagaaataaagccataaccagccccggaatag
-aaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttc
-ttatcagaggacattgcaataaaatctaacaccctcccttgtgtggttgggccatttgta
-cttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtcccataaacgatc
-attctcgcccacttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgt
-ccaatgttaggctaccttctccaactttagtacaacgaataatgtccgattaacaaggag
-tcaatttgtcatgaccagttcattcaggtacttgtatctatacggacgcgttccagagta
-gtatttgaaattttgaggttctactgataagtttagctatcgctgtatgtctgaataaga
-atttaatgtttatcttcgataaataacaattaacaactcctaggtgatacactgtgaagt
-ctgctgttccccaaattacatatgctattttgttcacataccatgaagttaagctaagtg
-ctctataatggcataaacggttatcaaactagctcgaatttcttttattacgccggaagc
-ggattaactgctgtagatcaaacacgttaggatagtgtcgttttcatatatatctaaatt
-cggtctaacatgcattacccatgcttgataacgtagcacttcgcagtctaattatgtaat
-gtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgacta
-cccggatctttagcctttagggtctaaacagaactaatattactacgtgtcatactccgg
-agcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtat
-caaattaacccagcaatacaataagcatgaaaataattgtaatcgggtttgggccggaat
-cccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactggattgagccacaa
-actcaactagcattatgctcaatatttggccagtgttctacggtttgaaatttataaagg
-ccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaataggtttaattaga
-acatccgtaggatttctgtttatagtagatttatactaaatgttctgattagattctgac
-ggccttacccatacaattaataaagacgaatatattagttatagtttactatccaaataa
-attaagcgaatcgaaataaactgtcacgatactgggcagttatcaacttatcacttatac
-agttcggacactctatattggtctgtgagtactctatcaaactaactcataagttaactg
-cgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatg
-acacatatggagatgcataataaaaaaaacggctccatatttctcgttaatcgggcattc
-ttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaactattagaccgtc
-ttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattct
-gataatactgggcggacagctggaaattagttgccagtgcacctacgcaaatagtttaca
-taaatcaacgggctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaa
-gcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtag
-gtcaactataactccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacg
-agaacactactgaaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaag
-ttggtggtagtgcacggaataacataacaaggaatattatttattcaaattttttgtgac
-tgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgct
-tatttcaggtccacggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgt
-cctttagactattcaaggtagaattttgataacgctctataaaaggtagaaaatcatgat
-tgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccct
-ataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttat
-gatcagacgctaacttgttcttagagaaaaatacacgggatactctgtgcaacgatttca
-ttaataaggtgcagcttgggacttttttggccgtaggctttattaacattcacagtaggt
-agcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaaatataagctagg
-aagcgtttgccaggacttctataatgcaccgttttttttagtacttccttactagcctta
-gtttatgttagagtctttccaattacaaaggattgaatagccaaaatttctacaattctc
-agcgaacgccagcttaatctaaacacgagcttcaaatattctacatatcggcaggagtca
-atatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataat
-taaatcctttttcaattaccacagtacgtgcattagaactactgctatgaaagtaaacct
-tgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaac
-gagttgatgttctgacgctagagcttaccattcgttaaacagataactaaaatttaatgg
-ctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatt
-tttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtac
-catagaagtatgtataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaat
-cagactagtcacacttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaact
-ctacaaggcatgggatgagattctaccgactccggataacactttacgatcgcgcataac
-tctagctcttagataagtttaacttgtcgatctcataaacagttcaaaatctgcgattta
-ttgtatcaaatccatcctctatcttctataatcatctgaaccgcgatacggcactatgag
-ccaagtgaagattgaatccaagaaagctataattggtttattttagtccatttaaattaa
-gtccggtataagtgctctgtacaatatgcagtctcatgggcatatacgttaactaccttt
-tgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaa
-ttactctttcctgttacatacgatctcttagtttggacaactagcccatgatggcgctcc
-tctagcgcatgaacctactttataattacatctttatcgatgaatttttttagactgcgg
-aggccttgagttttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtac
-gctacttgcttggaacaggcaccgaaaatattgatctactattgcgtcaactctattctg
-ctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgtcaactatatcta
-agtcgacctttactgtatcaacgatcacggagagaattaccgaatacgaaacctcaggac
-taaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagggtagcgacacag
-gtatactttgggtgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttc
-cggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactcc
-ttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttc
-agatggtaggagataccatttggcccattgtgactttacgcgattaattaaccgacatac
-atctgttcctgagctatgatcgtctgaataaattacggtctcctcttgatacctaatggt
-ttctggagacgtttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagct
-acgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaagggataaagaga
-aataacggacttctccgtagattagcctgatattttgatgggaatcatggcggcacatac
-gtaagagttgcgtgaacgaatattttggacggcgggagacacatatcggccattcgttaa
-ggtctctatattggacatcacaagcttagcagtatgagctactaacactcaagacattat
-tgattttttcaagatatgtttcattcctctaccgctattcccatacgttcgattcgccgg
-gtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgttgcgatagagac
-ctatgtatactagagagaattccccaacatttttacaaaaacaaagcagactaaaataga
-tacagtccctccatacaattaggaccaacatgttattgccgatcctagcacacacaccac
-aaactcagaacttctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaa
-ttagcattaatattaaaactaattaggataaactataggtacgagctttactataagtca
-ctaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataa
-agaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagagtagtacctacat
-gcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataa
-agttggactccatcatttagaatcatagggaccaaaacatttatttgctactgtcacttt
-gtaggtgttctattctgaattcctcatattgatacatgaatcggaatacctgtggatccc
-ttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatcgagaagttccat
-gcaattaagaattcgcctctttgaaaactcatatccccacatatagggtccaccgttatt
-cggaaacgatataataattattccagcgttgagcgtcccttaagagcgcattttcgcttg
-gcctttcttctacgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcac
-cccatagaactacctctgagagcgcgagatggtggcagtatgctctgcagctagcgttta
-gaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaattgtcggcattag
-gagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctag
-tccgcagagatacgattacagactcagatcccctaacaagcaaaacgattaaatcggaat
-cactccccctatgacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctc
-aaccgcgctttataagatgttgagtctgagaattagatgacctaactgcaagaatcatgg
-cgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcg
-gtctaaggacttagatgataaccaagaactggtttaccgagtactttcactattaggagt
-aattacatgcgttcaccgcggaatacgacgaaattttttcatatctttatgagcgagatc
-gtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaattatagattcatt
-atacagatgcttacttttctctattcaatactgtcatgagttgtttttaaataagcacca
-gaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgatggacagtattct
-actgattgcaaagtagtctatttcggcttagcagtacgcatgcctatttttttgcaggca
-cagaataatatgcaactaggattctcggcatccaattaacaggctaaaacaccaccgaaa
-gacaggtaatctacgaagttgatgtttactacagaaagcgaatgatatcacttggagaac
-attttagatgcccccttttaatctagactgagtgtaccaatatatcaccggtctaccgaa
-tcagcttgaataaaccactctagtactcatgataaccgagcatacacatgtatttctcaa
-tgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggcgacttatacttc
-tgtctttgagtacagcacaccctaatgaatctaagttagttgttgatacgaattgtaatt
-tgactggatctcgcctcctcatctagattcttagagaagatgtttcttatagccggtact
-gtaactttattgatctggtttatggtaatcaacattttacctctatttaaacgtccttgc
-gccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtctggaggccgaga
-aaagaaatgcacagagtaagctctctattgcgacatctacgtagaaactcgcatttcaga
-tcgagtaagcaactctcattgtgttgattcagtaatacaagattacctacgcttctacga
-aatatactatagatttagcctacgtcacctttagtgtcgagtcggagctttgaagatcgg
-atgcggtgtggactgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtc
-gatatcaatgggatacctcaaacgtctttatctctggataactcacattgagtataccgg
-taaaaatttattctattcatctaaatagtcagtgagggctagggtcgcaatcacattagg
-ccacatacacatacttaacatgttctattgacccgacccaactttagtagcattgtagcc
-gtttatgcaaatatgccaggcgccaaacactagccagagggcattttgttacatttattt
-aatcgattattacacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtc
-aacaattcagtaatttaatccaaaacctaaagtcagagacatgacactaaaatcacatta
-aggtcagttagtgaaggaatggctaaccagctagagaatgcatcattaacaggcacttat
-tgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaa
-cacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgt
-agacaatagtcgggacttagcagacactggatgcagtcatagaagatcttgcataacacg
-ttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgc
-taacttttccaacacgtttgtgatttcgttcataatgtatcaatttcacagtcatataca
-gggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttcagagttcagtta
-gagcctaatgattcgagagcaataatcaggacagcctcataggaagtgtcaatcacttag
-aagctatattattataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatca
-gttgcctgcaactggcttaacaatatgatacataaaaatattttcatcaccactaagacg
-gtggaattcagacttattggcaacttaggatgggactattaaataacccataagatgttg
-ggataaagttacgaaacgaaagggatatagcctgttagataggaaatccccaataaaaca
-tagccggcctccacagcagtgatctattccgccacgcgatatctttataccacgcaatat
-accaataataaaggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgc
-gtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagct
-tcctctgcaagatacaatatgactttttagcttttttactaccaaatctcagaatcttag
-aaacaggttggtacgtgctactcggaattcccaaagtaccctgctatatatgccattcct
-tcattggtccgggctcaccatggggccatcatagtaatagaaggtagtaaaactagttga
-tttccgacttttaacaatcactatcctgacccagatatgggttccgactggcccttactc
-cagtaagggcagacacacagacaacgagaacttgataactttgaattctcaaatcgatca
-ttgcaacgtgacttatttactagcctactcctataattcatacgtcaaatacatttcaac
-ggaggaagataataagtaaatattcactaaataatggtcgaaggagtcctttgccaacat
-aagtccacatatgcgctatagattttttcttggggttcatattcaataagataaacagca
-agagtatcacgtcagcgagtcattgagatcttggctagcattgtgatagcatattctacc
-taaatggtagtctagcacagagtggataagatatcagttagatatagacaagtactataa
-cagatctcgcttcgttggattgtatggctagctttgatgatatgattttataaaaattga
-tccagacctgacctggccaattatattcattttttatgagtaaaaatagataaccatgaa
-aatactcaagccccttaggacgtacaaagtggtaacataaatttcaggtgttattctgca
-accacacctgttttgggttttcaaaaaggctaagcagattggttttacagataatccctg
-aacactggtatctcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctg
-aagttttgtaaactaggcggaaaatatgttcgatagatccactcgcctgaggtagaaatt
-cgtcttagtaacgcctctttggattacacagaatagtgtactgacacgtacactgctgca
-gcagccatacgctaacattaaaattcgttgagtctacatttgttgttattcggattatgt
-tattgggaatagtatttttattcccctgcgtgaaaccacatggatagattagcctactcc
-taaagactcccttttggtctacggttcaattctcttactgagtttatgttcgtaattata
-tcggcgcagtgaatctcctaattatcaccggagttaccagacgccatgaacttatggcca
-gaaacattgcatgtggcctacataggattagtatcaagagtttacgtttgcaacgacatt
-tgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgcacgcgactataga
-agttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgct
-tgatacctgaattgagacatgtataagggctattgccagatgaaaaactgcatataaggt
-caaacaatataagaacattatacataggatcttagcgttcctcaggatggtatacgctat
-aaagtctagcttcagcagctaaggagttttgccagtgcggacttccgctggaagattagg
-tttaaccgccctgacatcttcataaggtcgggcctgattcaaacccctggagtgccgtct
-catacttgaattaatcgatggaaaacttcttctagtctaatattattattaacaaatgac
-ggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaatcattttaaccta
-tcatccattagctacagataatgataccccgatccgactagggggtaagtggttgttccg
-ttaggataaaccatgtaaaacgttagagggtttgtagattaattggtattccagataaat
-gaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaa
-gacagtataaatgaaggggattcagaagcaagtttctcgattgactgaatttataaacca
-gtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatat
-ttatcgagtctataaatatctttggttgtatattacttcacaatcaccaattctaaatga
-ttcttccactgtgcgggtggagatatcaggacgggttaaggttgacctacatcgttttga
-tacaacaaaaatcaaagcacatggctggggacttctcgatactatctttgagatagtacg
-ggcaagagtgggtgacgcctccctacattttcaagtctatcggataacttctcggtaaaa
-cgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaagttttaccggtc
-gaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggtta
-tccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatg
-cgtatggttctgatatatagatcgatgcatgaggacactttattttagccggcgaattaa
-tggaatccatacgttacttatttggacatgacttctaggtgtttttgctgtcccgtttag
-cgatatttacagattagtatttcgtttctcatagttaattgtatctagatactaactcgt
-tgaagacgcataccttgccatttgtacaggacttaactgttccgtgcgtaatttgaattt
-cttataggttcttcaaggcacgaatacctcactcatgaccgttcatactctagttaaggt
-cgggaatactacgtatgcagggaattgtaacctaggagatttacaactctttaaacaaga
-gtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatca
-cctagaaacctactcatacatttgcaattttgagatgtaggcgaaagagagaaatctgct
-ttttaacggtatctcttgggattccttttaaaaacacataacgatagtaatgtaccaagt
-aaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaa
-tattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaac
-taatgtcaccaagtaaagggggtgaaaatgctccccagggttctacagacatagagatgg
-tcagaacacgacccccctctcaacgcagtgtatttgaaatatatggacatatctacctta
-ttctgtaattttagatgtgttctgtgtataccgatattgataagtcaataggcttgatta
-cgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcagattgtttcttttt
-atgccataacctgcccaggaattcaaaaggttatcgatacccgatatgctgtgaattatt
-attctaatggccactcattcctgcttatatctggaattggcatgaatatcttacaaccta
-aagtctggcgttgcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaa
-ggtgggtacgtcacataaaagttcattagaccacactttgtgccgacgtatatagatata
-ttacacgtatagggaatgttttctcctaggtgacccgaccttctactaaggttgtacatc
-gtataatggcccattaactacgaggaaagtggtattgacctggtaatgcacgttcttcga
-tatataccgacgaggtaaagtctactattgcaaagtttgacgttatactgataagtttag
-atttccctggatcgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaa
-atccttggggatactatcgctactatcatcggaccaaaattaaataggctagtgtcttat
-cagaacatcatgtttaccgaactgatctattttccaatttaagctgatattacgtccgcg
-tatttattttagttccccggatgacgattatctgagctacatcatacaagttagcatact
-cgccggtgcattgatttcttatttcgctatatcttcaagttcacaggcttcatatagttc
-caattagcagtataattaggttttgtaactttaaccatactttataaaaggttatattgc
-acaactgatcaagcatccgctataacccgagctttaccagttagcggctaataacaaata
-agatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatt
-taggcaatgggtagtaataagtataaaatgataccacatatactataacaatgaaattat
-ttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgacatagggtcatcc
-atgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgt
-tataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaaaaccaatattta
-tcgttcgttattgctggtagtacaacatcacgagcatttctcttttgagttgatttatac
-tatatctgctgatgtgattatgtcccacttacccagaatattaagaaagtcctagattgt
-aggtatacttgactataaatataatttaagactatacaaataatctggctacattatgcc
-atcgtagaaactgataacgtagtaacgtcggacactagattttggtcggggagtaatcta
-gcatactaacgaatttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtc
-ttcaatacgtttagactattaaggactcatttcgagatccagtattaattatacgcatcc
-atatttatactgaagacggattgagttaggacgacaagctaaacaaatattaagttaagg
-attagtattatattgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgtt
-acttattcagagagacttaattcggttatgactggcagctcacctggaaagtaggtgaaa
-ggcaacagaagaatattgttgactgaattctacgggctacgaacgtaattacaaagcggt
-tcgtaaagagcataaagatcaatacaatggatctctacagtattacgtaaataacataca
-taaacctggtgttgattcgactagctcatagattaatcattaattgaagctacgaagacg
-cggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttataatatcgcgctt
-aaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatatttactaggaata
-ttagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacattggatgcatggct
-gtgggggcacaggatacttaccattagttcacctacaagcggcgtgagagggtctcagtt
-ttagccagcgcagagaagtacgggcctttagacgattaatgctagaattgtcataaacct
-cgtgaaaagctagttaataatcatggtgctagaagaacacaacttttctataaaccagtt
-ctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcac
-atagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgagagataaatacac
-cggatacgatctgcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtag
-cattttttaacagtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggt
-ttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtt
-tgtactaattcctttatagactgagtgtatcgtacactcggtacaattacaaaggatgga
-agagcaaataggtcttcaattataacagtaccccaccttaatctaaaaaccagcttcaat
-tagtattaatttcgccaggagtatatatataaatatctaaagactaaaagactcgtactt
-ttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattag
-aaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaatt
-catactcgattaaggcctataaaactgttgttggtatctacagagtgattaaaattagtg
-aatcagattacgaaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtg
-gtacaattggctgtagtagaattttggtataaaataggtgataaaccggatgggtgtggg
-cgaattcaaaagcggtttttgttccatagaactatgtagttggttataaaggttgtaatc
-tcggagattaggttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtg
-ggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggataaacaatacgca
-tataacttgacgatcgagcttatatcgacctatttgagaagtttaacgggtcgatataat
-atacaggtcttaatagccgattttttctagaaaagcaatcctatatcttagttaatcaga
-tcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacattcctttttgtcc
-gggtggggactccatttaaagtatctcacctagaactcagcggtaatagatgcagtctct
-tgcccagttacggtaactaaatgttgatacttagaattgctaaattttagtctagacatt
-tccaggtaaaccggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgc
-tcaaattgcaattgagggccctactatagacaatcatcagactttttaattaaatagttt
-tccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgta
-tgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttc
-taagatggactataatcgattaggctaattccgttcgcaaatcacagaagcaatcttact
-caaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaa
-ttacccaatacctatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagat
-taagtctgaagcctagagacaaagggatactgggcggggaaacctgctccttcacggtaa
-catggtaacaacagaatttggttaaggttaaaacgaaatatactcggagtgaattactgt
-taggtttcgtcatcggatcaataagtagtttccgtgaagacactcttatattagatctcc
-gaaattctgacccgtgcattaggcacttggtaggagattccatttggaacttgctcaatg
-taagccagtaatgttccgaaataattcgctgcaggagcgaggagccgctgaataaaggac
-cctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtcaattccagagctg
-gagatacattcatcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttt
-tcctaaacacaacggatttagacaaattaccgaatgcgccggagagtagcatcttagtgt
-catgcctatcatggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgc
-actcaaagttccgccattaggtaagctatatattgtggtcagaacttgaggacaactatg
-agctactaaaaataaacaattttgtcatttgttctagatatgtggcattcatcgaacgct
-tgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatca
-ataacatatagttcagatagagaacgaggtattcgacagagaattacccaacattggtta
-ttaatctatgcagaataatttagataatgtcactacataatattaggaccaaaaggtgat
-tccccagaagacaaaacaataaacaatctcacatattcgctagtacctatgtatgggtat
-gatcttctgattggacggggataatttccaggtatattaaaacttattaccataatctag
-acctaagagaggttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaag
-acttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaatattctgtataaa
-ctgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgt
-tattctgatcaactaatatcataaactgccactacatcttgtacaatcattcgcaacaat
-acttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaatcagattcataaa
-ggaatacgaataactctggatccattaccacgcaagggatttatttacggctgattactt
-tttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgcataaataatagca
-cctaatatagccgacaaagtgattccgataacagattttaagttgtccagccttgagact
-ccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatcccaagtggatgg
-ggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcga
-aggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattg
-gaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaa
-ggaagcacgcattgaagcagctacgcagaactgagaagatgacactctaagatacaatta
-atacaaaaacgttttaagcccaatctatcaacagatgtaagatgtctaatacacaagaat
-aaaaccttcatgtcccgatgtataataacagctttatttctgctggtcgaggtgaagtag
-tggaaattactccatcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcg
-tccatccctctctcctagtgatccgtatatccaattagaggataaccaacatctgcgtta
-ccgacgaatttaaatttttcgactatttaattccgttcaaacccgtattcgtagtaagtg
-tttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaa
-ttgctgatctaggatacatgctttataaacatgcttacttggctattttatttactgtca
-tgtgggggtttttattttcaacaagtatgtgctaccattggataatctggcttcaaattg
-aagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtcccattagaacta
-cgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaat
-ttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaa
-tgcgtatcatagaaattcgtgataatttttgttccaacctttgaatctagactgagtgga
-aaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcgaatcatcttata
-actgcattcaaatggatttctcaatcatctgtacgtcaactgttttaacaataacgtcag
-aataaaccggcacaatgagacggcggtctttcactacaccacacccttaggattataagt
-gacgtgtggattcgaattctaaggtgacgggatctacaagcctcagctacattaggtctg
-aagatctttcgtatagccgcgtatgttactgtttggatatgggttatgctaatcaacagt
-tgacagcgagtgaaacggccttgcgacctgaaatctttacggttaccttttgattcaaga
-caggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcag
-cgaccgagtaacgacaagttcacatcctctatgcaactatcattgtggtcattaaggtat
-tcaagattaactaagagtcgaccatatattctagagttttacaattaggaaccgttagtc
-tagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgac
-acatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgg
-gataaataacatggtgtttaaccctattaatggtttctattaatctaaattgtaaggcag
-cccttgggtcgaaagcacattaggccacatacacagtatgaaattgttcgagtgtccaga
-ccataattgactaccatggtacacggtgttgctattatgactcccgcaaaactcttgaca
-gagggaattttggtacattgatgtaatcgatgatttaacagtaggaactagacgtcatcc
-gttagactgagttccgacatgctcaaattgtcaggatttttatccaataactaatggctc
-tcacatgtaaataaaatcacattaacgtcacttagtgatggattcgctaaacagatagac
-tatcattcatgaactggcactgtttcgattatatttgcaacatcgaacatacttaaagtt
-aaatacgacatcattcaattaaaaaaattcagtacacctctaatgagtatcccgctttgg
-aggaaagagtagcactttaaatggacaatttaggccggactttcctgtaaatggatgaag
-tcattgtacagcttgaataaatcgttagggttagtccttacatccaccatatgttaatga
-ataaagcctgagggaccttagagctaacttgtccaacacgttgctcatttacttaataag
-gttgaaatgtatcagtaagtgacagcgagtgtagattttgaccatttaactgaccttcac
-agttttgtcttcagacgtcacttacaccataatgatgacagagcttgtagatgcacacac
-tcattcctagtgtaaatcaagtagtagctagattattataaagagatattttctggcgtc
-gaacgtaacacagagagagtataaggggcatgataatggcttatcaatatgtgtaagaaa
-aagtttttaatatcatctaactcggtggaatgcacacttatggccaactgaccttgggac
-gagttaagataccataagaggttgcctgtaagttaagataacaaagggatattccatctt
-tgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgctatgcagccacc
-agagttatttatacaaagaaagagaccatttagatacgttaattctgcttgcgatttatt
-aaacagacatttcacgtccaaccactacaaaagccctatcgcaagacgatcattgtatta
-tagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaattgttacattgtt
-tactacatatgatcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaac
-taacctgagatatatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagta
-atacaaggtaggaaaacttctggatttcccaaggttataatgctctatactgaccaagag
-atccgttacgactcgcaatgaatactctaagggcactcacaaagaaaaccactaattgat
-aaatttcaatgataatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaa
-tgaattagtcatagaaatgtcatagcaggaacataattactatattttaacgatttaatc
-gtagttggagtcctttcccaaattatgtcatcagttccgatttagatgttttcgggccct
-tcttagtaaagaagttaatatccaagactagctcctcacccacgcatgcacatattcgcg
-agaagtctgatagaatattcgacagaaatgcgactctagctcacactcgttaactgatca
-ggtacttatagacaagtacgttatcagatatcgcttcggggcattgttgcgctacctttg
-tgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgatattattttttta
-ggaggaataatacagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaac
-atatatggcacgtgttattcggctaacaaaactgttgtgccttttctataaggataagca
-gattcgttttaaacatatgacctgtaaactgggatctacaaaagaggtacttaaaataaa
-ttgcgcaacggtttagatctgcggatctttggttaaagagcaccattagatgtgccatac
-ttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggatttaaaacaattc
-ggttaggacacctactcggcggatgaagcaatacgataacattaaaagtcgttcagtcta
-attttggtcgtagtacgatgagctgatggccaattgtatttttattaacagcactgaaac
-aaaatggagactttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcgg
-aatgaggggatcttcggaagtatagcgccgaagtgtatctcattattataacaccagtgt
-acagacgacatctaattatggccagaaactgtcattgtgccattaagaggattagtagat
-agtctggaccgtggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcg
-atctaaactgcacgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgc
-gtttgtttttacgattctagtgcttcttaacgcaattcagtcttctagatccgctattcc
-aacatcaatatctcaatttaaggtcaatatatataacaaaattagacagagcagctgaca
-cttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagt
-ccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatg
-tgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctact
-attagtttattatgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgt
-taaggcaggaatctttgtaacagttcataatgttgctaaagattatcagaccccgtgaag
-acttcgggctttgggcttcgtaccgtagcataatacatctatatagttagaggcttgcgt
-gttgttgtgctattccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatg
-gtaacctggcgacctacttgttaagtcagtttaattcaaggggattaagtaccaagggtc
-gagtttctctgtatttattatactgtaggcaagaagcttttttggcgagatttaagactt
-aagcctatggtaaaaatttgatagtgagcgactatagtaagagatttgggtggttagtaa
-ttaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgt
-gaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattggcggggcacttat
-ccataatagatttctgtttgtacgccaaactctgcctcacccctccataaattgtattgg
-ctagaggttaaattctccgtaaatagagacacatatagttttatacaattgtttgaatca
-aagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggggcagagcatctc
-ttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagattatacaaagagat
-ctggatgaagatattcgtgcaatcactatcgttatgttagagagttccatgcatgaggac
-tcgttttttgaccaggagaattaagccaagaaataactgacgtatttccaaatgaattct
-acgtgtttttcctgtcacctttagccagtgttaaagatgactatggagtttcgaataggt
-tattctatagacattataacgagtggaacacccataccttcacagtgctaaaggtaggaa
-cgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaagaaataacgcat
-cacccgtcattctattgttttcgtcgggattacttagtaggcagggtattctaacctacc
-tgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcct
-aaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgactt
-cttcccctaacacagaattctcagttttatagctatctagtggcattcctttttataaaa
-ctttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgc
-cgtgtaagacttggaacccatgtatattgacggcatggcgtggctaagcaggtattgatc
-ttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccggggattagccgccaa
-aggggtctaatgacatagagatgctctgaaatcgtaccaactataaaagcacgggatttg
-aaatatagcgacagatcttccgtattctgttagttgacatctgtgctgtctttaccgatt
-gtgatttggctttagcagtcatttagtttcgttactcattgctcgtgcgatagttccacc
-gaatatggcacattcgttctttttttccattttactgcaaaccttttcaaaagctgatcg
-ataccactgatgatggcattgattagtcgattggcaactatgtcctgcttatatctccaa
-ttgcattgaatatagtaaaaaataaaggctcgccttcccaatgggctacggagtacacga
-aaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtgattgagacaaata
-gttctccagacgtattgagatatatgtctcctataggcaagcgtttctaattgctgacca
-gaaattagaattaggttgttaatactatattcgaccattttattccacgaatgtgctatt
-ctactggtattgctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagt
-ggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggta
-tctgccatattgttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaa
-atattaatgaggattgggtcgtataagaaaatcatcttttcagttcgcagatttttgcca
-atttaaccggttatttcgtcagacttggtagtgtagttacaagcatcacgattatatcag
-ctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattgcgctatatattc
-aaggtaacaggaggcatataggtcatagtacaaggataatgaggtttgctaactttaaaa
-attattgatttaacggttgattgaaaatctctgcaagatgacgctagaacacctgatgtt
-caagtttgccgataataacatataagatgaattactgtctttagaccctcatgttaatcc
-gctaacttagggcggaaacaatgttaggctatgcggagtaagtactatattatgatacca
-catagaatttaacattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccga
-ttaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaa
-ggttcagctattttggcaatgggtgagtaccgttcttagtgatttacgaacccataatct
-aggcgacttaatatacaagatttagagttacgttttccgggtagtacatattaacgacca
-tggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccag
-aatattatgtttctactagagtgttcgtatactggaatttaaatattatgtaagactaga
-caaattttatggatacattaggccatcgtagaatatgatatagttgtaacgtccctctat
-agattttcggagggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggat
-ttgtaattaactgatgcgcagcgcttaaataagtttagactattaagctatatgttcgac
-agcatgtagttttttttaccagaaagtgttatactgatgacccatggaggtagctcctca
-tgataaaaatattgttacttaagcattactattatagtgttcaaactagtaccgttgcat
-actttaagaatcagacatggcgtttcttatgcagacacacttttttagctgttgacgccc
-acctcacatccatagtaggtcaatcgcataagaacaatattctggactgttttattaccc
-agaagaaagttttttctttccggttcgttaagacaataaagatcatttcattcgttctct
-taacgatgaactaaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaa
-taattaaggcaagataagaagaacaggaacgcgcacgtcggagataactctaatagtctc
-tttattccgtttaatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgc
-aaacctatttatgtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttt
-tatcaagactttcgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaa
-aaccgcagggagtcgctctaagtgttaccaacccctcactactacgcgaaggtactcgat
-tattccttgaatgggctgaaacatcgtgattagcgtcttatgattcaggctgatagaaga
-aaacttattttctatattccacgtatacaatcacactcgtaactaaatagttcccagcgt
-tgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtgcataagtacagt
-tagtcgtctgtcacataaataatccgcagtcgatctcattacaggtattgttgttggtca
-accttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaa
-tatcataatagatgccatacacggttttacttgatatgtttacagtccttgagttgcaat
-cgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtca
-ctaggtaaaatgacttaggatggatgagcatttaggtattctatgataacactaaccatc
-atgtttctaaaatcctcaggaaatttgtattattttaccaacctgtatttatagaaagtg
-cttttgacttaaagaagccgaagtgttcaaattaaggagtacctgattgaaagaatgggg
-aattgtaatctgtaactcaattacaaataagccgttctaaggattaaggctttgtgtcta
-agcaactcacgtgaattcgaaattcatactcgattaacgactttaatactcttctgcgta
-tctacagactcatttaaattacggaatatgttttcgtttttggtttccagctcgcacgta
-cgcgtttacaaataaggacacctggtacaattggctggagtacaatgttggtttttattt
-gctgattatcccgatccctgtgggcgttggcataaccgggttttcttcaagactactttc
-gtgttgcttatatacctggtaatatcggtgagtagcttagggcttaatcacaatactaac
-aagttctctatggattggacagggcggcatccgttgactgaacgatctattaatccattc
-cctgcactggataaacaagacccatttaaattgaccatagagatgttagcgtcatatttc
-tgttcgtgatagggtacatatattataaacggattatgagcagtggttttctagaaaagc
-attcatagttaggagtgtatcagatcataccactgaaccatagagcacaattctctactg
-gctatacttcattcctttttgtccgggtggggacgaaatttaaaggttctaacctagaac
-gcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaa
-ttgcgtattttgactattgacagggcatcgtaaaccgctactcgacttggtatctgtaat
-ctgtatgtagatagagtacgggcctataattcaaattcagccaccgaagattcacaatct
-tcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagccccacccattctctg
-ttatatccgagcattaatgtagtttcactgtactacggtcacgccgtagagtcggcaggg
-caaatccaaaacaatttaggctgagaagtggcactataatagtttagcctaagtcccttc
-gctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggt
-atcttgaatactgatagctctcatggtaccaagaactttcataacctctttatttaccaa
-acctgttctactagcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccg
-gcgtaaccggcgcctgcaagctaacatgggatcaaaactattggcttaacgtttaatcga
-atgagactagcactgtattactctttcgtttcggcagcggatcaataaggaggtgacggc
-atcactctcttatagtagatatcacttattctcacaacggaagtaggatcttccgtcctc
-attaaatttgcaactggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggt
-cagagcagacgatgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacg
-ggctatgcggaaattccagacctcgagttacattatgaaacgtgtcattccatctcatta
-aatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtctattttcccaagg
-agaaggagagtagcagcttagtggcttgcctatatggccccctaagtacgtactcggcac
-gcttagaagattgggctaccccgcactatatgttcccaaagtaggtaacctagatagtgt
-cgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttggcaggggttata
-cattgcgggcatgaagagtaacattggacatgaacggacattcgaaccctgtgagtttaa
-taccctatctccggatcattataaagtaaatatacgtcacttactctacgtgcgtttaga
-cagtctttgaaactaaattggttatttttctttcatctagatttgtctgtatctaactaa
-attatagttccacataaagctgattcaactgaagacataaatataaactttctaacatag
-tagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagtagttcctggtaga
-gttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtga
-acatacataataccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcct
-acgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgctt
-cgagtatgtacattcagatctccttagtatcatcaaattatagattttacggccacgaat
-tattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagt
-tgaggttggaagaagagtcattatgctataccaagaactctccatccagtacctagaaag
-gcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttg
-taccagatggcttttataatagaaactaagtttcccgaataacggtgtacgataacagat
-ttttaggtgtacagacgtctgactcaatgaacacacattgggacctgccccgggaggagt
-agtagataattaccttctccagcgcgggtcttttaatatcacaacataaaaatactaatt
-aatatcacacaccctcatcctcgatggagcctagcatcatacacgtttgatagacaacgc
-caattttactgtaatatgatattcgaatctagtatgtggacgctgtaccacattgtttaa
-aggagctccctttaccgacatgaacgaagcaagctttgtacaagatacgaagaactcagt
-actggtaactataagagacaatttatacataaaagtgttaagaccattatataaaaagag
-gtatgaggtctttgtaactacaataatacattcatcgaacgatggagaataacagagtta
-tttctgctgctcgagctctagttctgctaatttctcaatcttgatgccactcgtttgagt
-cttccattcgctcttaacgacgcgtacatccctctctcctactcttacctatatcctatt
-actggttaacctacatctccgggaaagacgtaggtaaagtggtccacgattgtattcact
-tataacacctagtagtactatgtgttgctgagagtgaggacacacttactctacgagttc
-aagtccatatggacattacactttttcagcatctaggtgtcatgatgtattaacagccgt
-taggggctatttgattttatcgattgtcggcgtgtgtattttcaacaactaggtgctaca
-attcgtgaataggcatgaaaattcaagattgcagttcctatcttgtataatctttccttt
-ggacgagttgtaccatttcaactaacctgcaagtggggggtcatccatatgaagatttgc
-caaatacctggagaccctgaaaagtttatccagattaataataacaaacaaacctaagcg
-aagaacgtcagctttaataaactatcactatcatagaaattcctgttaattgttcttcca
-aacgttgaatagactatcacgggtaatagattgaacacggagaacgtttatccggcttgt
-aaaatatcgtcgaatctgctgataactcaattatattcgatggagaattcatatctaccg
-cttagcttttaaaaattaagtcagattattccgccacaatgagaaggcgcgagtgcacta
-atcaaatcacttaggattattacggacgtctgcattacaatgctttggggtagggttata
-caagcatatgattctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggc
-atatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatct
-ttaagctgacctgttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaa
-actctaacatagcgtggcactatgagtacgtgtaacgacaaggtctcatactcgatccta
-agataattctcgtctggaaggttttaatctttaactaagagtagaacttagtttattgac
-ttttacaattaggatacggttcgcgactctaccacagggcatcatacctggagctctgct
-atctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatctactgagcaatccc
-tttaagcattcctagtttgagagccatttagatattgctgtttaaaccgattaatggttt
-ctattattataaagtgtaacgctcccattcgggacattgaaaattagcaataagacaatg
-tatgatattcggcgagtctcaacaacattatggtctaccatgggacaaggggttgatatg
-atgaatccacaaaaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgtt
-ataaggacgatctagaagtattcaggtacacggtgttcagacatgctctaattgtcaggt
-tgtttataatttaacgtatcgctctctattctaaataatataaaattaaccgctcgtagg
-gatgctttccagtaaaagatacactatcattaaggttatgcaaatgtggcgatttgattt
-gaatcttagtacattcttaaacttaaatacgtattatttaaagtaaatatattatctaaa
-ccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgac
-cctctttcatctaaagcgatcatctatttcttctgattgatgtaatactgacccttactc
-cgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaat
-caactggcgctggtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcat
-tttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgat
-gactctcattgtagatccaatcacgctttcctacgctaatgaaagttctagatagtgtag
-gtgttagacagaggttagcgcctacatccttacacacacagtgttgaacggcaagcataa
-tcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcccgcctttgaaca
-atgatgccaaaatgtcctgccctagagttatgataaaataactgctgccctgtaacttaa
-gtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaa
-aatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagagtacatttagtta
-ccggattgcggcttgacatttattttacagaattttatcggcaaaacacttcatatgaac
-tatcgcttcacgataagtctatgatagactagcattcgtagagaacaggaagagcaatca
-ttatatatgaagtgttacagtgggtactacatatgagatcattaggtctatatccggcct
-tcctcataagaccttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacc
-cagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggttttaactagggg
-ttattgatatttaagctaaaagagttccctgaacactcgaaatgtataatctatcccaac
-taaaaaagtatacctctaattcagaaatgtcattgagattagactgatgtcaatacgcta
-ggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaatacctccatcttaa
-gttctatattttaaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtg
-cccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaatctctagctact
-atcccacgaatgcactgatgccagtcatggcgcttacattagtcgacagaaatccgacga
-tacctatcacgcgtgaactgttctggttcttattcaattcgaagtgatctcagatacatt
-acggccatgcttgcccttcatgtctgctgagcagttttgttataggctgaatctcctcta
-agcgaaattgataggatttttggtggtcgatttagtctgtacctgcttattaagattcaa
-aatgacctacttcttacgccgaaatgatagggatcggctgaggaggataaatatacgctg
-gtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactctaatctccgaga
-taaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtat
-agtccaccattagttctgacttacttaatatagactgaccgagattgtagtatgtggatc
-caagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaaga
-gttaattaatagtactgcactataattgtcggcggagtaccatgagctgttgcccaattc
-gatgtttattaacagcacgcataaaaaatccagacttttcaattagaattaactataaat
-ggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtatagaccccaactct
-atctaatttttataacacctctgtaatcaacaaatcttattatgccatcattatgtcatt
-cgccaagtaagtccagttcgagattctctggaccgtgcaatagtattgtcaaattatggt
-aatggaatccttcttctaacacccttagaaaagccacgagaattgacaagttgggcgtgc
-ttgtccaggagcaacataagtgccgtttctttttacgatgatagggattcttaaagcttt
-tctctattctagatcccagttgccatcatcaatatctcaattgatgctcattatatagtt
-cttatttagtatgtccagatgtcactgaagatcctgcctagaaccgatattctcgacagg
-atcatcagttcgacggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaag
-gaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagt
-tttactgcctttaattagtagtcgattagtgtagtttgatattatctaccttatagaatg
-taaacagtaacccggccttaatggtttggcaggattctttgtaaaagttaataatgttca
-taaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaa
-ttcgttttacggagtggcttgcgtcttgttgtccgagtacacatattgctcctctccccc
-actcttctaggaaaatcaattatgctaacctgcagaccttcttctttactatctttaatg
-catgcccagtatgttcatagggtagacttgctatctattttgtataatctacgaatgatg
-cttggggcgcgacttttaacaattaagccgttgggtataatttgagagggtgccacgata
-gtaagagatttccggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagct
-caccctcctcagttctccaaccctgaaccggctaagtatgactgtgcagtattaattttg
-aatacatattgcagcccctaggatacattatagatgtctctttcttacccaaactcgccc
-gcaccaagaaagaatgtggattcgattgaggttaaattagccggaattacagacacagat
-tcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatg
-gattacgttggggatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaag
-aattcacagaggattaatacacttctccatgaagataggactgcttgcactatccttatc
-tttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataa
-cggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatc
-atgactttggactttagatttgggtattctagagactgtagaaagactgcaacaacaaga
-cattcacagggcgaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttag
-gaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcggccccttgaatta
-cgtgcatgcctttgctaaaagacctctgggaaatagattgaatattctggacagcagcga
-atcctgattatatctcaagcgaatatatgacccgcaagaaggatttatactagaataagt
-ctaagaaagggcattgggtcacttcttccactaacacacttttatcagttttataccttg
-agagtcccatgcatttttatatatatttaactttcgttgcgtaaaactttaaatatgatc
-cgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaat
-cgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttctatgctaaaaat
-gtatagccccgcattagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgta
-acaaagataaaacaacgcgatttctatgtttgccaaagtgattaagttgtatcgtagggg
-tcagcgctgatgtcttttcagtttgggttttggatttaccagtcttttagtttcggtact
-atttgatcgggacattcgtccaaacatgatggctcattcgttctttttttcaattttaat
-caaaaccttgtatttacctgatacattaaactgagcatcgcatggaggtggagattccca
-tatatgtaatcatttgatatcctattccattctttttagttataaataaacgctccactg
-cacaatgggagtaggacttcaccaataattagcatctactgtaaacaagcgccgtaacga
-aatgattactgattgagaaaaataggtctcaacaacttttgacagatatgtatccgatac
-ccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaa
-tggttattactccaatgggctattctaatccgatggatacgtaggagagagtgtacctac
-accgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtg
-cgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaaagaagtcccctg
-aatagcccttagataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattc
-ggttaagttcgcagagttttgccaagtttacaggtgatttactaacacttgggagggtac
-gtacaaccatcacctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagt
-gtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtcataggacatcga
-gtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtgataatagctgcaa
-catgaagatagtaaaactgaggttaaactttcaccatattaaattatatgttcaattacg
-cgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgggtccctatcccg
-actttgtacgagattttgataaaaaatagtattgtaaattcatttgatggcgtagaaccg
-ggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcc
-tggctcaatatttataatagtaatggttaagattgtggcccaatcgctgagtacccgtct
-tacgctttttccaacacataatcgacgagaatgtatttaaatgtttgagacttacgtttt
-ccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgtagttttctcatct
-gctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggct
-atttaatttttatggtacacttgaatatgtttagccataatgtagccaatactacaatat
-cagatacttgtatacgacctatagacttttgccgaccgctcgtagagtgatttagaaaga
-tgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgt
-tgactattttgctatatgttactctgaatgttgttttttttaccagaatgtgttataatg
-atcaaccatgcacgttcctactaatcatataaattttgttacgtaagcttttctatgata
-gtggtctaaagactacccttgcatactttaagattaagacatgcactttaggaggaactc
-acacgttttgagctgttctagcccacctataagccattcgtccgcaatcccataactaca
-atagtcggcaatcttttattacccagaactaacgtttttatttcccggtacgtatcacat
-taatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgct
-tcttgagaatacagattactgttagaatgaaggcatcataactagaacaccaacgcgcac
-ctcgcacattactctaatagtagctttattcagtttaatatagacagtatttgaaccagg
-cgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatt
-tgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataac
-cagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacat
-cacttcgtaccgaagggactactgtattccgtcttggggatgtaacagactgattacagt
-cttatgatgaagcctcattcatctaaaattagttgatttattccacggatactatcacac
-tcctatagaaagagttaccaccgtgggaagctagatataataaataaaagacatacaata
-ttagtatggctcatgatctacacttactcggatctctctttttttataaccagtagatcg
-cattacacgtattgttgttccgcatcaggccctaggggctcaaacttccatggtggataa
-ctaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgggtttacttgatt
-tctgttcagtcattcacgggaaatcctaggagtctttcataacggcggtcttagtaggaa
-tgtagtcaagctctgtagaggtctcgacggaattggtatttcctggcatcacaatttacc
-tagtattggagatcacttaaaataatgttgagataataatcaggatatttctagtatgtg
-acaaacctctatttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaac
-gactacatgttggaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtg
-ctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgtaatactactgta
-accaagttattactcggctgcgtagataaagtctcatgtaaatgacggtttatctgttac
-ttttgggtttcaacctagctaggacgccggtactaattacgacacctgcgtatagtgcag
-ggtgttcaatgtgcctttttatgtccggattataaccatccctctcccacttggaatatc
-accgggttcttaatgacttagttcgtcttccttattttccgggtaagatcgctgtggacc
-ggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttc
-actgaaacttagattaatcaatgcactgcactggattaacaagaacatgttatagtgtac
-tgacacatgttagactaagaggtctgttcgggttagccgacttatatgtttaaccgattt
-tgacaactgggttgagagataacaatgaagagtgaggactgtagaagatcttaaaactgt
-accatagtgctcaattcgctaatggcttgaattatttaattgttctaaccctggcgtcga
-atttttttggttcgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtac
-cgttagaaagcggcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaa
-gctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaat
-tctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtg
-gtctataccaccaaaaagtatatgggatatcccagaatttatcgactttcaatcgtctac
-cgtcacgacgtacactaggcagccctaatccaaaacttttgaggatgagtactgccacta
-ttatactgtaccatttgtaacttacattttatatcttcaaagaggtagatattgtcggcc
-attactgtcacttacactaagggtagcttgattactgatacctctcatggtaaaaagtaa
-tttaagaacctatttttttacataacctctgctactaccgttagtgttttagtcggttca
-agtcacaaaatccctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaa
-acttttgccggaaccgttaatcctatgagaataccactcttggaatcggtcctttaggct
-gaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaa
-acgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatcttacactctttt
-cttaactaagtatgagagcaacctcactcctgaacagcttgttacctaacgagaagaggc
-tttaagtagcctggagcctcaaccggatatccggatttgactctcatccacttacatgat
-gattacggtcattacatctcatgattttctgagtgccctatagactgggaatttaatcta
-ccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatg
-ccaccataagtaagttctcggaacccttacatgattggcctaccaacctatatatgtgac
-caatgtacggtacatagagtgtggcctatcatattcaggtcatcgagctcagtatttaaa
-gattatatggtcgctgggggtattcagtgcgcgatggaagactaacattggaaatcaacg
-gaattgacaacacgctcactttaataacctatctcaggataagtttaatgtaattagacg
-gaactttctctaactccgtgtactaactctttgaaaataatgtgggtatttttatttcat
-ctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtc
-ataaatataaaatttagatcttaggacagaggaaagtgctttcccgagcataggatctgg
-cctacgccagtagttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagg
-gtagtgttcgatactcagcggggaactgacatattacactaaggaatcaaggcccttcgt
-atgggtcatgtttatatatttaattacttacgctatttgatcgagaatagctatagtaac
-gtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatactgtgtatcatatt
-attatagatgttaaggcatagaattattggtattgatgtacaaaaaattatgggtgggca
-gtaccgataggcattacgagcagtgcagcttggaagaactggatgtatcctataactagt
-aagagccttaaaggtactacatacccagggatgttaccatcattaatttggccatcttca
-atcttcgcaatgcatactttcttctacaagatgccttttagaagacaaaataagtgtcaa
-caataacgctgtaacttaactctgttgtacgtggaatcaagtctcactaaagcaactaac
-attccgacatgcaaacgcaggactactagattattaaattcgccagcccgcctcgtttaa
-tataacatcataaaaattctaagtaatatctcacacactaatccgccatcgtccatagca
-tcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgccaagctagtttc
-gcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaaccatcctacctt
-tgtacaacagaccaacatctctgtactggtaaatagatctgaaaagttataaatataact
-gttttcacattgatagaaaaacagctatgtgctatttgtatatactataataaattaagc
-gaaacatggagattaaaacagtgttttctcatcctccacctcttgttctgctaatttata
-attcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaacccgacataaataga
-tacgacgctgaacgagatcctatttctcctgaaaattattagcacggtaactcctaggga
-tagtggtactagttggtatgaacgtataaaaacttgtactactttctcgggatgtgaggg
-agcaaactattactcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatac
-ctgtctggatggattatatgcaggtaggcgagagtggattgtagcgatgctcggcggggg
-tattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactg
-catatcgtcgattagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtcc
-gggcgcatccatatcaagttttgcaatagtactccagaccatgaaatggttatccagatt
-aataataacttaatatactttcactacatactcagcgggtattaaatttcactttatgtc
-aaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaa
-accgagtaacttgatcagccttgtaaaatatagtagaatatgatgttaaatcatttatat
-tccagggagattgaatagcttacgattagctggtataatttaactcacatgattaagcaa
-atatctgtaggaccgagggaaagaataaaataaagtaccatgagttcggaacgctgcatt
-acatggcgttgggctagcctgatacaagaagatgagtatggagctctcttcatcgggacg
-tgacaaccctagcgtaatcttggcagatcccggagcagatgattatcgtctaacactgtc
-tttaccaatgcacaacgcatagatttaacctgaactgttctggattcactcctgactaca
-gcctacaactcatttctatgcataactcttaaagacagtcgcaatatcagtacctctata
-cacatcggatcagactagatcataagataagtctcctctggatccttgtattctgttaag
-tacactacaaatttgtttagtgtctgggacaattacgataagggtcgcgactagaccaca
-gggcatatgacctccaccgctcctagcgagtctccaatctgcaagcactcatacgctagg
-ggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacccatttagatatg
-cctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatcaaattcccgaca
-ttcatattgtccaataagtatatctagcttattcggactcgctaaactaaattatggtat
-aaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggc
-cttatggcagcgtatacagctggtataacgaccatatacaactatgaacggactagctgt
-gaactaagcagattattggatccttgtgtataattttaagtttcgatctatatgctatag
-tatagaaaatgttccgatcgtacgcttcctttacagttaaacagtctatatcatgaagct
-tatccaaagctggacatttgatggcaatcttacttaattatgaaacttaattacctatta
-ttgaaagtatttatatgatcgaataagatttgctctataaacaggtcgtccattcacgac
-ctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatctatttcttatca
-ttcatgttatactgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcac
-gctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgat
-atcgatgtctatcccacgcgtcattttcaaattggttatctacggataactgtgcgatga
-actactataggtcaaaattatcttcaatctcattctagatcatataaagatgtccttcgc
-gattgatacgtctacagtgtgttggtgttacacagagggtagcgactacttacttactaa
-ctctctcttgatccgcaagcataagccaggttaaagtgctctatctttttctgtggatta
-taatagttataccgccttgcatctaggtgcccattaggtaatgccctagtgttttcataa
-atttactcctgccatctaacgttactttaatttcccagattcaataggtctctcatttga
-aaattgttatatgtcaacaaagaatataatagctgagtggaacaatacactgtgagggag
-taatacatactctaaattttctttacggtttgcgcctgcacagttttttttatctatgtg
-atccgcataaaaagtaatttcaacgttccattcaagttaagtcttggtgacactagcatt
-aggagagatcaccaagaccattatttatttagctagggtttaagtcggttagaaatatca
-gataatgaggtctttatccggccttacgcagtagaaattggaaatttcgtaaagcactga
-gttcaatggaagtatggccgaacccacataatgcacaaatcaagtcgatttcttccgtcc
-ttttagtctcctgggaactacgggttattcatagttaagctaaatcagttaacggaacta
-gacaaatgtataatagttcccaaatatatatctataaatcttatgcagttagggaatgca
-gatttgaatcatggcaatacgctagctcggaactcaactacaagtgttggatgtacgaat
-tcaaaggtattacatccttatgatgttcttttttggatacttttatgacgacttccacga
-agtgaaattatgttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgt
-tctgtttataattctcgtcataatataaatacaagcatatgaggccagtcatggagcttt
-catttggactaacatttccgtagagtcatatcacgcctgtaatctgatccgtctttttct
-attcgaagtgttatcagatacatgacgcccttgcgtgacattcatggctcctgacatcgg
-gtcttttaggctgaatctaatctaacccaatttgtttggattgtgggtcctccattttgt
-ctgttaatgcttattaagattaaaaatgtactacgtatttagacctaatgattgcgatac
-gctgtggaccattaatataagctgcgccaggggatttttccagatcatctggcctgtgta
-tatgttcaaatctaatagccgagagaaattactccgacggaaaataaaggcagataagcg
-tttcagagcaccatcgtggcgtttagtcaacctttagttcggaatttattaatatacaat
-ctcactctttggacgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaa
-gtataccagcatcatcaaagaacagttaaggaatacgactgctctataattgtccgagga
-gtaccttctcatctgccaatagtcgttgggttggaaaacaacgcattaatatgccacact
-tgtcaattagaagtttctataaaggggacgagtaactgatttgagacctagcacggcaga
-ggacgttcgtgtgacaacatctctttataagtttgagataaaatcgctaatctacaatga
-ttatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaagg
-ccattactatggtcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaa
-acactattgaatactgccgccgcattcgccagcaccaacataactgcacgtgcttttttc
-catgattggcattatgaaagatttgatctatgattcttaccagttgcaatattcaattta
-gcatgtgttcctaattattgtgttattatggtctatctcatcatgtaaatgaagatcatg
-acgtcaacacagattctagtcaggatcatcagttcctcggggaaatcgcacctaggaaca
-gccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaag
-cctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcgagtactgttggt
-tcatatttgctacatgattgtatgtaataacgatcccgccctttatcggttcgatccttt
-atggcgataagttatgaatcgtcagtatctttagatcaaaaactcaactagtacccagtt
-ccccggaggaacggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcaga
-ggaatcagtttcatccgatcccactcgatgattggtatagctatttgccgaaaagccaca
-acgtattcggtactatcttgtttgattcccctgtatcttaattcgcgacacttgatatct
-tttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaattatccagttgcgt
-ttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataa
-ttggagtttgcaggacgaatagctcacccgcctaagtgatccaaccctcatcaggataac
-tatcactgggcagtattatttttgatttcatatgccaccccctaggagactgtagtcatg
-tatctttcttacccaatctagcccgaaacaagaaagaatgtcgattccagtcacctttta
-ttagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaa
-agttgaaaacgacttgctctattcgattaccttcgcgatctcaatcgattacgctaaatt
-ttaatgcccgctgaaatatccaacatttaaaacaggattaattctctgatccatgaactt
-aggactcattgcacgtgacttatctttctctcttaattcatgctccaatacggtgggcta
-aaccacttttatcacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggca
-gcgaaacgggtcaatctgggtatcttctattgggacggtacatttcggttttatagacta
-tgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcac
-cttgggattgccatgtgtccggaggattacatacatctaagaaacattctaaactatgta
-tagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtactctgggtattag
-agtgtatattatcgacagcaccgaatcctcattttatagcttgacaatttatgacccgaa
-agaaccttttataagtctataagtatatctaacgcaattgcggcactgagtccactaact
-atctttgagcagtgttatacagtgagacgccatggaaggggtttatatattttactgtcg
-ttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagt
-cgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttac
-attccttgcttatttgcgataaatcgatacaaccccattaccagaaaaacccggagaatc
-aattactctgcagatcttatactaaaaaagagattacaacccctgttctatgtgtcccaa
-agtgagtaacgtggagcgttggggtaagagcggagcgattttaactttcgcttttccatt
-ttccagtattgtactttacgttatatttgagcggcacattcgtcaaaacatgatccatat
-ggactgaggtgtttaaatgttaatcaaataattgtattttcagctgactttaaaatctgc
-agccattggaggtggagattccaatagatgtaagcaggtgatatcatatgcaattcttgt
-gacttattaagataccagacacggcacaatcgcagtagcacgtaaacaataatgacaatc
-gacggttaaattccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaac
-gtttctctgagatgtataagttaccaaacactggagaattccgctaaactaaggacaatt
-tccgtcgtattaattgttgacaaatggttagtaatacattcgcagtggataatccgttgc
-atacctagcactgagtgtaaataaaaccaatcgactactggcatttcgggctaacgacta
-gatgttagcctatgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttc
-ttattcgttattagaagtcacctgtagagacagtagagatgacctaaatttggtttgtcc
-agtcccgaggtgatctaatgattaggttaacttagaacagtggtcaattggttaaagctg
-atttacgaacacttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtat
-tcggtcatctagacaaccccatcgctgggagtttggacagtgttatgattcgtaaatcca
-ccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaatttaggcttttt
-tacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgtaaacggtcacca
-gttgatatttgttctgctaggaagcgatgtacaaaataagcttaataagatttaggtccg
-accttaatttcggtccatagcacctctttctaagtgttttgcttaaataattgtattgtt
-attgattttctgcgagttgaacacggaaaataagtcaaaaaggacacttttaggttcata
-tgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgt
-ggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttagtccactaggtat
-ttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaatggcagaggggct
-cctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatcttttggttcttt
-ataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagcc
-agaatggaccaattacgtcattagctgttacgtctatacgaaatatagactgtggacgac
-ccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaag
-caggacaacacagtattgtactggtcaattggttcatagatctgactatgaatcttcgtt
-tttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttt
-tcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggccttaatgtaacatta
-actattccactgtaggtggatctaacaaggttggacatgtgctaccaataagataagaat
-ttcgtccgcaatacaatatctacttttgtagcctatcttggattaacaacaacttacgtt
-ggtatttcaccggacgtatcaaatgattctgattttaatgactgagagtaaacatcaacg
-aatcttatgtatctttaagccgctgcttgacaagtcacattactgttagaatgaacgctt
-cattactacaaaacctaccaccaactcccacattaatattatactagatgtttgaagttt
-atttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttag
-ggtattaattgtggtcggtgcatttccggccccatagcgctccgcggggagaaactatgg
-ccttcatgacagcccccccataacatctaggtaatggtcggataactataaacaaccctc
-tccagagaactgtgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttg
-cccatcttaaagactcttttcactattttcttgatgcctcattcttctaatattaggtga
-ttttttaatccgagaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacat
-attttaaagaaatgaaatactttttgactatccctcatgatctaaacttacgcggagcta
-tctttttgtataacatgtacagagaattaatccgatgcttcttccgattaaggacatagc
-gccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaagtgattaagtga
-tcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaatacttggagtctt
-gaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgc
-tatttcctgccttctcaattgtccgaggattgctgataacttaaaataaggttgagtttt
-taataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagtta
-tcaagaactacgggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatc
-gtacgaatggtatttgtacaactgctttcctttatcgattgctcgagaacattataaagt
-ctattactatggattaagactgtatacaagtgtttaagcggagcccgtgataatctataa
-ggttttggtacctttatctgttacttttgccttgaaacatacatacgtacacgggaatat
-ttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaa
-ctgaaagcgcccacttgcattataacccggtgcggaatctcttagtgactcgtcaggagt
-ttacgcctttgagacctctcgacaggacccattttgatctagtcgttataggtagagtgc
-ctttcctatcgcaccattaccttctagcaaacttagagtattcaatgaaatcatatcctg
-tttatactaaatgttataggctaatgacacagctgacactaagaggtctcttcgggttac
-ccgaatgagttgtttatacgatgttgacaactcgggggagtcatttcaatgaagactgag
-gactcttgatcagattaaaacgcttaatgactgataatttagattatgccgtgtattatt
-taagtgggcgaaccctcccctagaatgggtttcctgagaaaagtcttagaacacagtatt
-ctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtc
-aatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaagagctatgttctg
-acacgtccccaatattaggcaaaggctccaaaagaacagtcaattgattaactacgggct
-tggtttctccgtgaatccttgcgccgctataccacataaaaggatagcggtgataccaca
-agtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaa
-ttttgtccatcactactgccaagagttgactggaccagttggaaatgacatttgatatat
-taatagagctacatattgtaccactttactgtcacttacactaaccctagcgtgattact
-catacatatattcgtaaattctaagttatgatactagttttgtaaatttaatcggcgaag
-acacgttctcttgtacgagcttcaactaaatatttcactgtagccaaccactttaaccag
-aaggataccttaatgccgatataatattgtccaggaaacgttaatactttcacaagacaa
-agcttggaagaggtactttacgatcacctgatagatcgaccggaacgattctatataggt
-ttggtctgagaaatttgtagctaaaaccatgttccataggaactcctctgtaatgggcaa
-aatgcagatagcgttcaatcgttgcttaactatctatcacagcatcctaactcctcaaca
-gcttctttcctaaagacatcagcaggtaagttgacggcacccgataacccagagcacgat
-tggaatctaatactctgtatggatcattacgctaagtaaatataatgattttctgactca
-aagttacactgcgaattttatattaactggttctatttgttaaataccacaacctctcgt
-caacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaaccattacttctgg
-cgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcgccgatcttagga
-acctaatactgctcagtagttattgtttatttgggccatccccggattatgtcagccatg
-gaacactaaaagtcctaatctaacctatggacaaaaagctcacttttataaaattgctca
-ccttatgttgattgttatttgtccgaaatgtctataactcagtgtactatctattggaaa
-attatggccggagttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaat
-aattatcagctggaaaatcatctaatatatattatattgagatattacgacagacctaag
-tgctttcccgtcatgagcagatggactaacactcttggtaatccttctcgttttagttgg
-taatgtttagtctaagtaatatcccgactcttacttactcagagcggaaatgacttttta
-aactaacgtttaaaggcacttagtatgcgtcagggttatttttttaattacgtacccttg
-tgcagagagtttagctattcgatcctacttagtatgaaccatgagagtacaggttggtaa
-ttcacagagaaggtcgagaagattatttttgatgtttaccaatactatgaggcgtattca
-tcgaaataattttatggctgcgcacttcacatacgcaggaagaccactgcagcttgctag
-atctggatgtatcattgtacttctaagagcctgaaaggtaatacattcccagcgagcgta
-acagattgtatggggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcat
-ttttgatgtcataagttctgtcaactataaccctggaactttaatctgttgttcgtcgaa
-tcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccactacttcagtttta
-aattagaatcacaccctagggtattagataataattaaatgtcttaggaagagatatcaa
-aagatgcagacatcctcaagtgaataagtctccggtctttcacaaacacatggttaagcg
-atgtggttttgactagagacgttcgccaccatcgtaatatttctggttacctgcgaacgt
-gaaccaaatcttacttcatacattgcttaaacagtacaacttatctcttatcctatagag
-atctcaaaagtttgtatttttactggtttcaaattgagagaaaaactgcgttctccgatt
-tctatattattgtttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccga
-ctcagattcgtatcctatgttagaatgagtcatcaaactacggtcacgcgtacattacag
-agtaaactacacgaatgaaagagataagaagatgaaagagttaataggtctcctgttaat
-tatgagaaccctaactactacggattggcctactagtgggttggaacggatataaaattc
-gactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatcc
-acagtaatagttggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtg
-cagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgag
-caaggaattggattctgtgaacggaatatagtcgagtagatggaatttcctacactgcga
-aaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggcaattagtactcca
-ctaaatcaattggttataaacttttagaatatctttatataagttcactacttacgctgc
-gggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaataaacggcttgac
-tatagataccctaattctggcataaccctgtaacgtgtgaagcatgctttaatagacgac
-tagatcagcttatagaatggatatgactgccacattgaagagattaacattagcgggtat
-aatgttacgaacttgtttaacaaaatagctctaccacacacgcatagtataatataaagg
-tcctggagttcgctacgagcctggaattgcagttcccctaccctgagtaaacaagatcag
-tatggacctatcttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtga
-agttgattatcggctaacactcgctttaccaaggaacaaacaattgatggaacaggtaag
-cggctggattctatcctgaatacagcataataatatttgctttcaatatatagttatgac
-actcccaatatcactaactctttacaaatcggatatgaagagtgaattagagatggagcc
-gatcgttccttgtattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtc
-cttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcatagagactctaaa
-ttcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaactgtaacatttac
-gtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtt
-tcgcgatacataaaaggccccactttcatatggtcaaatatctatatcgtgctttggacg
-actcgataaactaaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaa
-tttagagtatatataacttccggacgtatggctgccttgaatcctcggatatcgtcctta
-tacaacgatgaacggtatagctcggaactatgcagattaggcgatccttgggttgaattt
-ttagtttccatagatatgagttagttttgatatggttaccatacgtccctgcattgaaac
-ttaatctgtatattgattgatccttagcaatagcggcacatttctgggcaatatgactta
-attaggttacggtttttactatgatggatacgttttatatgatagaataacagttgctat
-ttaaacaggtactacattcaactaatactgtttcactattgtgtccaacatagggaatat
-attgcctgaatagatgtattatcaggcatcttttacgctccaggtagaactaattaaaaa
-tgatccttagaaactttcaagcaacataagctaaaagttacgccaattataagccacatc
-ggtaggatcttcaggcattcccatatccttctctatcaatcccgtctgttgctaattggt
-tatctaagcatatcgcggcgagcatctacgataggtataaagttgctgctatctaattcg
-tcataatatatacatggaattacagattcatacgtcttcagtctcgtggtgtttctaaga
-gcggacccaagaattacgtaatatctctctcgtgttacccaagaagttgacacgtgattg
-tcagctatctttttctggcgatgttaatagttataaacaattgcatatagctgcaaatta
-gctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcac
-tgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgca
-gtgcaaaaataatatctcagggtgtaattatttctctaattggtctttacggttggacca
-ggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaagtgacattaaac
-ttaagtattgctgtcaagaccattacgacacttcaccaacacatttatgtattgtgctac
-gcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaa
-atgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaac
-atatcatgtcgttgtattacgtccttttactagcctgggaaataccggtgattcagagtg
-aacataaatctctgaaagctactagacaaagctagtatagttaaaatatatatttctttt
-aatattaggatctttgcgattgcacatttcaagcatcgcattaacctacctccgtactct
-tctacaacggttgcatgtacgatttctatgcgatgaaatacttatgttcttagtttgggg
-ttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgc
-gggcaccaaaacgatctcgattcttaggtttataattatagtcagaagataaatacatgc
-atatctggacactcttccacatgtcatgtcgactaactttgaactacagtcatatataga
-ctgttatctgatccgtatgtgtctattactactcttatctgagaaaggacccaatggagt
-cacagtaagcgatcatgtcatcggggctttttccctgattataagattacactattgctg
-tgcttggggcctcctactttttctatcttaatcattttgtacattaaaaagctaagaagt
-aggtacaacttatctttcccatacgagctggaccattaatttaacagccgcaaggcgagt
-tttaatgttaatctggaagggctttatgttctaagcttttagcactgagaaattaatccg
-taggaaattaatcccacataacccggtaagagaaccttacgccccgttactaataatgtt
-ctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctccttaatacaggccctg
-cgttatattcgaccgtacctataactagaccaccatcttaaatgtacagttatggttttc
-gacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgtactgggggtggtt
-atcaaacatttaatatgaatctatggtaaagtactagtttatagatagccgaacactaaa
-ggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggt
-gataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattgcccaatcgttct
-actcgtactctttatagcctaacgccttttcttggcgctaattagcctaatccaagaagg
-agtctaacaaaattacttaaccatactcttgtctattcggcccacgcatgcgcaagctca
-aaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattggatctatgagtc
-ttaacagtggaaatatgatttttagattgtgttcagatttattgtcttattttggtctat
-ctcatcagctatagctacataatgacgtcttaactgtttcgactaaccttcagatctgac
-taccccaaatacaacatagcaaaagaatgatgctaacgcttaactatcctttcacgatct
-taacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcgtggaatcaattt
-ttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttca
-agcactttagcggttccatccttgatggcgttaactgatgatgcgtaagtttatggtgat
-ctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttagg
-tctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcct
-atagctttttgcagttaagccactaagtaggcggttctatagggtttcattcaaatcgat
-cgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttcaggcccgccaca
-atggtttcaagtttcaacttccgtttattggctgtccctcaatagagtcgttctcagggc
-acgactctcgttcgttattcataagtccagtttgatccacgaatacagaacacgcatatc
-tgataataaaagcttaacgataactttcacgcgcatggtttatttttgatttattaggca
-accaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaag
-tatcgccattacagtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtatt
-ggcgcccttgatttaataataattacggctaaacgtattgatattttccaggaactgccc
-catctcatgagatgaccctaaattttattcacacctcatttttaattcttttatatcacg
-attatttatctgagcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaa
-tgcatgctaatatacggtgcgctaaacatattggttcaattcaatgtaagctacctcgga
-atttgcttgcactaagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaa
-gggacttgtccgttggagtcactatggagttacaagcattataaatctaaggaaatcgca
-gtatcagtccttaccccaaagatacttcgcattccctggggtacggaccatgaaatactt
-ctttcatacatgataaacgatggagactcggttaccaccctggtagttactccatcaatt
-ggagttaactaagatcgctattacaggctttattagccaatcatcacaagcctcttttta
-gagattcacaagttagcaaaccaaagttcctttgataagtctttaacgagatctatccca
-attccggctaggagtaaaatttatatatttgagatcggggttaaagtcacacgcaatgca
-aggggtttttatatggtaatgtccttccctaattaggtaattttcagacctccgagagag
-agtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatgacactacagatc
-atccctggatgagcatcgactttcattacttgattagttcagttaattcgtttcaaacca
-ttttcaacaaaatcccccagtagatatgtatatgcacatcttagactaaataacagtttt
-cataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagc
-gagggtaactggccctgttccattgtaatcgatgggacgggacgttatattgcagaccca
-aagtagtaataaattcagccatatggacggagggggggaattgttaagaatataattcga
-ttttcagctgaatgtaaaagctccagccattcctcctccacttgacattagttcgaagaa
-ggtctgagaattggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagt
-accaagtataatattatgacaatagaagcttaaattcacaacgtaacatatctgttagca
-tgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcag
-tagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaatggttagtaata
-atttcccagtggagtagaagtggcataacgtgcactctctgttaataatacctttagact
-actcccatttcgccagaacgtcttgatggtaccctatgggaaacactcacacatgcttat
-tgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggac
-tgatgacctaattttggtttctcaagtccagacgtgatattttgatgaccgtatctgaca
-tctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgat
-aatgctgtcatcactatcatgttttagctaagctacactaccccatcgctcgcacgtggc
-aaagtgtgaggattccgatatcatccatgtgtacgaattcctaatactcttgctcagggc
-acttagggttattgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtct
-tataatcaccgtaatcggtaaacagttgttatttgttctgataggtagacagctaataaa
-gatgctgttgaacagttacgtcccacctttattgccctacagtgaaactagttcttactc
-tgttgctgtaatatgtctagggttattgatttgctgccacttcaaaacggaaattaagtc
-attaacgaaaatggttccttcataggtaaagatcaatccccaattgaagccagaaatttt
-gagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaa
-aaaaatgttgagtccactagcttgtttattctggctcaaggtacgtggaacacgtagtat
-tttgatactaatgccagacccgctacgatccctgtactgtgagcagagccgatcctcaga
-aatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgtt
-gcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgt
-taacaaagatactctgggcaacacacatacttctctcatgttgtttcttcggacctttca
-taacctttcctggcacatggttagctgcacatcacaggattgtaagggtctagtggttca
-gtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcat
-ccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttaga
-cgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatctatatacgttgcac
-agcggatacaaataagataagaatttactaacatttaaattttcttattgtcgagcatag
-attggaggaaaaacttatttacttggtatttaaacggaagtttctaatgtttatgattgg
-atgcacggacagtttactgcttactttcttaggtttcttgaacaacaggatgcactagta
-acatgtctcgttcatgcttccattaagttcttcttaaacttacacaaactacctaattta
-gagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgtta
-ccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacatt
-cacatcccacccctgaatatatggactgaatcacacacaccaaatttcatctaccttatc
-gtagcataactattaacaaacatatacagacttcgcggtaaataaaatatattagtacac
-aaccgtatactggttgaactattgcccagctttaagacgcttttaactaggtgcttgatc
-aagaagtattattatatgacggcagtgtgtaatacctgaatagatatagacgttagattg
-tctgaaaacacgccgtagagacatttttgttagatatgtatttctttttgacgagccagc
-atcttagtatctgaagacgagctatatgtttgtagaaaatcgactgacattgtatacgag
-gcggcgtaagattaaccaaattccccagaattagtaatggcgccttatcgatttactaac
-gatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaa
-ggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacat
-agcgtcaccgatactacgttttgctatgtaatccattctaatgggtaagaggattcctct
-tatagtaaaatatgcttgactttttaagaaccattgggagtggttggcaaaataatagtg
-ggtgtctttctcagtgtatagttttctacaactacccctattaggttacaagtaatctgg
-ctttcttgccacttggcgatgatagttagattcgtatttctacaacgcagttactgtatc
-catggcgcgagataattagatacgatttgaatttggatgtagactcgttactactgttgt
-agaccagcacgtgagtatctagatgggtttgctaccttgttagcggacttttgccgggaa
-aaagacatacgtacaaccgtatattttactataagcagtattggccaccctcgtattgcg
-gcagggtgtgctcacctggttaaaatgaaagagaaaaattccattttaaaacccggagga
-atctattactgacgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttc
-atattctagttattccgagagtcactttcctatccaaacatgaactgatagcataatgac
-aggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgt
-cacgaactcggagcttacccttacaactatgtgttctgtttaccaggtgctaatatcccg
-gcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcata
-ttttacagtagccagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctg
-acataagtattacatatcacttgtctgattacacagcaaaatcgctaaccttactttgcg
-catgtagctattggaactttgggctagtgtctatcccattaagtttaacagtagactagt
-ccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttggatcaaaaacta
-ctcgatattcatgatctacgggcttcctttctccgggtatcattgcgccgagattaaaaa
-taaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacga
-atagaccatccaatttgaattttattgggtccagcacttcgccatagtgttgaatggtaa
-agttcgaaaggaaatttgttatattaattctgctacattttcgaccacttgtatctcaag
-gacaatatcccttgaggcttttagcagaaagagatgccgtaattctaagggatgataata
-ggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaaactatatattta
-aatctagccaaacaagttaacaacaaccataaagttatgaccttattatattggcaagct
-taacgttttaattgctctagtaatagagtggtagaggtaagggaccatcacctgattctt
-cctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataaaacattcgtcct
-tagcaacgaatatcgaatggcaattagccacattgagttaaatagttgaggatatttctt
-gcacagaatcagatctaatctaatgattcgttactaaacacttcaccaggtatcgtgaag
-gctcaagattacccagagaacctttgcaatataagaatatgtatgcagcattaccctaag
-taattatattctttttctgactcaaagtgacaagccctagtgtatattaaatcggtatat
-ttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgt
-acttataccatacatgaattctggccaagtaaaaaatagattgcgcaaaattcgtacctt
-aagtctctcgccaagatattaggatcctattactcatatcgtgtttttctttattgccgc
-catccccggagtatctcacccatccttctcttaaaggcctaatattacctatgcaaataa
-acatatattgttgaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagt
-aatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaatattctgggctag
-cgtgagatagtttcttgtcctaatatttttcagatcgaatagcttctatttttgtgttta
-ttgacatatgtcgaaactccttactcagtgaaagtcatgaccagatccacgaacaatctt
-cggaatcagtctcgttttacggcggaatcttgagtctaacttatatcccgtcgcttactt
-tctaacaccccttatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgt
-tattttttgaagtaagttacattgggcagactcttgacattttcgatacgactttctttc
-atccatcacaggactcgttcgtattgatatcagaagctcgtgatgattagttgtcttctt
-taccaatactttgaggcctattctgcgaaatttttgttgccctgcgaacttcacatacca
-aggaacacctcgcaacatgccttcatatccatcgttcattgtaattcttacacaatgaat
-cctaagtaattacatccctgcgtaaaagatggtaggggcactgaggatatattaccaagc
-atttagttatgagtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcg
-taatgttatctcgggttccgcgaataaacgagatagattcattatatatggccctaagca
-aaaacctcctcgtattctgttggtaattagaatcacacaatacgggttgagatattaatt
-atttgtagtacgaagagatataaaaagatgaacaattactcaagtcaagatgtatacggg
-atttataataaaaatcgggtagagatctgctttgcaattcagacgtgccactaaatcgta
-atatgtcgcgttacatcagaaagggtaactattattaattaataaagggcttaatcacta
-catattagatcttatccgatagtcttatctattcgttgtatttttaagcggttctaattc
-agtcattatatcagtgctccgagttctttattattgttttaaggatgacaaaatgcctct
-tgttataacgctgggagaagcagactaagagtcggagcagttggtagaatgaggctgcaa
-aagacggtctcgacgaatggacagactttactaaaccaatgaaagacagaagtagagcaa
-agtctgaagtggtatcagcttaattatgacaacccttaatacttccctttcgccgaatac
-tggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgctcataaataggt
-agactactcgcaatccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcg
-tgtttatcaaccgtccccactcgcctggggagacatgagaccacccccgtggggattatt
-agtccgcagtaatcgactcttgacaatccttttcgattatgtcatagcaatttacgacag
-ttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaacccacatgaatg
-tgattcttggcaatttctaatccactaaagcttttccgttgaatctggttgtagatattt
-atataagttcactaattaagatcacggtagtatattgatagtgatgtctttgcaagaggt
-tggccgaggaatttacggattctctattgatacaatttgtctggcttataactcttaagg
-ctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttggactccctcttt
-catgtcagtaacatttcagccgttattgttacgatatgcttgaacaatattgatctacca
-cacacccatagtatattttataggtcatgctgttacctacgagcatggtattccacttcc
-cattcaatgagtattcaacatcactagcctcagagatgatgacccacctctaataacgtc
-acgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcat
-ataacatttgagggtaaagctaagcggatgctttatataatcaatactcaataataagat
-ttgattgcattttagagttatgacacgacatagttcactaacgagttactattcccagat
-ctagactgaagtactgatcgagacgatccttacgtcgatgatcgttagttatcgacttag
-gtcgggtctctagcggtattggtacttaaccggacactatactaataacccatgatcaaa
-gcataacagaatacagacgataatttcgccaacatatatgtacagaccccaagcatgaga
-agctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaa
-ctggttcccgggagtcctggagtttcgacttacataaatggaaacaatgtattttgctaa
-tttatctatagcgtcatttggaccaatacagaatattatgttgcctagtaatccactata
-acccgcaagtgctgatagaaaatttttagacgatttataaatgccccaagtatccctccc
-gtgaatcctccgttatactaattagtattcgttcatacgtataccgcgcatatatgaaca
-tttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggt
-taacagacgtacatgaagggaaactttatatctatagtgatgcttccgtagaaataccgc
-cactggtctgccaatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttg
-tttgcagagtataacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcac
-tattggctacaaaatagggaagagtttcaatcatgagagggagtatatggatgctttgta
-gctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagatacataagcgataa
-gttacgacaattataagcaacatccctaccttcgtaacgatttcactgttactgcgcttg
-aaatacactatggggctattggcggagagaagcagatcgcgccgagcatatacgagacct
-ataatgttgatgatagagaaggcgtctgaattgatacatcgaagtacactttctttcgta
-gtatctctcgtcctctttctatctccggacacaagaattaagttatatatatagagtctt
-accaatcatgttgaatcctgattctcagagttctttggcgggccttgtgatgactgagaa
-acaatgcaatattgctccaaatttcctaagcaaattctcggttatgttatgttatcagca
-aagcgttacgttatgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtg
-ggaataattcttttgaagacagcactccttaaataatatcgctccgtgtttgtatttatc
-gaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcggataacaattaat
-acgatgttcatagtgacagtatactgatcgagtcctctaaagtcaattacctcacttaac
-aatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccga
-gtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctctctgaattccttc
-gtgccaacttaaaacattatcaaaatttcttctacttggattaactacttttacgagcat
-ggcaaattcccctgtggaagacggttcattattatcggaaaccttatagaaattgcgtgt
-tgactgaaattagatttttattgtaagagttgcatctttgcgattcctctggtctagctt
-ccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgt
-aataattaggttcggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgc
-tgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaat
-gagactcagtagttaaataaatccatatctgcaatcgattccacaggtattgtccactat
-ctttgaactactctaagagatacaagcttagctgagaccgaggtgtatatgactacgctg
-atatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaataccggctgtttccag
-ctttataagattaaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagt
-tggttcattaattagctaagtacgaggtacaacttatctgtcccagaacagctccacaag
-tttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattaga
-gtttacaactcagtattttatcagtacgttttgtttccaacattacccggtatgacaaaa
-tgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcc
-tacacatactgaattcaggcaatgcgttttattcgaaaggtcatataactagaaaacatg
-atgaattcttatcggatccttttactagcatagtgttggcgaacacctcgtaatgctcag
-cggcaaattggactgcgggtccttatcatacattttttttcaatataggcgattggtcta
-ggttagtgattccccaacacttaaggtttgctgacattcataccctcagcaacttcctct
-caaaaattagagtgagttggtggtcttataagaccgttgattatttgaggtggtcaaatg
-atggtgcgatgcacaaatcgttataatcgtactctgtagacaataacccattgtagtgcc
-gattttgtgcataatacaagaaggaggatataaaaatgacttttcaataatattggctat
-tagcaacaagaaggagaatcctcattaagttagcaaccgcagggggtactgcagtccaag
-gaggtttcattggagagagcagtatgaaaacggcaattatgattgtgagattcgctgaag
-attgtgtctctgattttcctagatagaataagctatagctacttaatcaactcttaactg
-tggagactatcctgatgatctgaataccccatttacaaaattccatatcaatgaggctaa
-cgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatacaagacaaaacac
-tgcttccattacgggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgata
-aagctgtcttgcgtttatacttaaacaaattttgacctgacataatggagcgacttatcg
-gatgttgccgatctttagggtcatctattaagcttatacgaaaaagggacaagcacgtta
-cgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaactccaatatctgta
-agaacagaaaaatacaggagtccttttcatttttcaagttaacaatataagtaggagctt
-agagaggcttgcatgaaaatcgttaggaattacagaataggcagagagtggggcgtgtag
-actacattcttcaggccccacaatatgggttataggttaaactgcactttttgcgatctc
-ccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcat
-ccaactattcagataaacaagatcgcagaattaaagcttaaccatatcttgatagcccat
-cgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaa
-aatttagacaaacataattcattctttcgactggacacgctaaggtttggacaaactttg
-tatctatatctggaggcctgtattccagcccttcttttaataagatttacggcttaaact
-atggatatttgccaggaaatgacactgctattgacaggaacataattttgattcaaacct
-cattgttaattattttatatctcctgtttttatatcagaatgcttctgtcctagaaggca
-tactcaaggtgagggctcgaggaatgaatcataatagaccggcccctattaatattggtt
-caattctttcttacataacgcggaatttgattgcacgaacaccgggaacacataaccgta
-tagcgcccgttatgctagtgcctagcgactgggaccgtggagtctatatcgtctttctac
-cattattaatctaaggatataccactttaagtcctttcaactaacataaggcgcattcca
-tgcgctaaggaccttgaatttattatttcttacatgataaaagatcgagtcgacgggaac
-aaaaggctacgtactcaataaagtgcagtttactaagagccctttttctggcttgtggag
-actatcataacatgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtg
-tagtattgaacgagatctttccaattgccccatagcaggaatagttatatattgcagatc
-gcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattac
-ggtttttgatcaaagcacagtgagagttgagcaaattacagttatacgacttaattcagt
-ctccataaattgaaacgacacttcttaacgggaggaccagacacgttcattaagtgagga
-gtgcactttttgactttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaa
-cagatttgaagttatttctgttttaatacactgggagttctgtcaatatcgcaggaaccg
-cctgacgtcccctatcacacctcagagggtaaagggacaggggaaagggtaatcgagggg
-tagggaacgtagttggcacacccaatggacgaataaatgctgccatatccacggagggcg
-ggattgcggttgattttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcc
-tccactggaaattactgcgtacatccgctgagaattgcaatggagtgtctcggtttttct
-ttaaacaaaaccaaattgacaacttcatagtataatttttgcacattacaagcgttaatt
-aacaaacttactttgctgttagctgcctatatttgtccgacaatataactggatatctct
-gcgagaactgtaaattaacggcacttggaacataatagttcctattggtaacgacgttgt
-aggcggcaattatccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaat
-ctctcgtaagtataactttagaagactccaaggtacccagaacctcttcagcggacacga
-tcgctatcaatcaataaggattattcactgaaaccgctcatatctggaggtggacgtttt
-tcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctg
-ttattttcatgaccggataggacatctcgcggaaattcgggtaacagctgggtagatata
-ggacctcccctacgtattaatgataagcctgtcataactagcttggtttaccgaagagac
-aataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaaca
-tgtactattactctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgat
-gttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtct
-gagcattcgtacactgcgtattaagatcaggttgaacaggttcctaacaaattttgtgac
-ctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctg
-acacttctaaaaccaaattaaggctttatccaatatgggtccttaagtgctaaacatcat
-tcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcgccaaattgacac
-atcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtgtgtattctggct
-ctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgt
-aggtcacatcagcagatcctaagtaattccgttttattgtcctgagggagtaggatcgac
-gaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaa
-tgaactattgtcatctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcg
-atggttctttatgcggacctgtcatatcattgactggcacttgcttacatccaaataaca
-cgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatt
-tcgccctctacatgataaatgaataagtaagaagatgatctttttgtggcggtaccttaa
-gcgtactcctgtcgacgagttactactaaaggaatgtagggttctggatctatgaaaagc
-gacctccatatatatacgggcctaagcggagtaaaataagtgatcaatggactaacattg
-aaatgttagtattgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaac
-gaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttactttagttggttg
-cgggaacaacaggaggctatactaactggtagcgttcttgcttccattatgttattatta
-taattaaaaataagacatatggtagagttgtagtcagggtggatcgggttgtctataacg
-ttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcg
-cctacctcatgtgcaccacacattcacagcacacccctcattataggcaaggaagcaaac
-aaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaatagaaacacttagc
-ggtaatgaaaagataggactaaaattcactagtatcctggaacgaggcaacagagttatc
-tagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacc
-tctattgatatacaagtgactttctcggtaataacgcacttcacaatgtgttgtttcttt
-tctatgtattttgcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgt
-aaatcgtatcacatggtataactgcaggaggaacattatccaaattcaccacaattacta
-atccacccttttacttttactaaagatatattaattctcatgttgtctgaattgtataac
-ccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaaca
-cacgacttccttccgtctattcagacactcaacgagactaacttttcctaggtaatcaat
-gatattgggtaactcgtggcatcttatagttattgatccggctcttttgtagatcctgtg
-cgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtttattctacgtac
-ccgatttggttactactaagcggcctttcttcaaacttgcagttgtgacttacattccta
-tttcttcaaagcagggaagggttacagggagagacttattgagatacgattggaatttcc
-atgtacaatcgttaatacgcttgtagaccagcaactcagtatagagatccgtttcctaaa
-gggtgagcggtaggggcaaggcaataagaaattactaaaaccctagttgttaatataaga
-acgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaa
-taggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttct
-caaagatcctaacctaaaaggggcttattctactttttccgacactcaatggacgagaca
-aacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatcgttattattaat
-cggtttccattatctatatgcggtatagatctccgagaggaccctgtaaactagctctgc
-ggtttaactggtgctaatagaccgccactatgttattgcttctagctcctagcgtcttat
-catgttatacattaatgtcgcatattggacagtagccaggcttggatggatcgccgacaa
-aaagaaaagactttccctgtaaggacttaactattacatataacttggatcattaatctg
-caaattagagtaacggtctttcaccagcttcatattccaacgtggcgctagtcgatatcc
-catgaagtttaaaactagaattggcagtctcacttcacagtgcgtatctatacgacaaaa
-gtggtcgatttgcataaatatcttatcgatattcaggttattaccgattccttgctaacg
-ctagaagtcacaccagagtaataataattccagacacctgtgaaataatcggtcactacg
-gatagactagtaacgataatacgtatagtccataaaagttgaattttaggggctaaagat
-attagcaatactggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctac
-attttcgaccaattgtatcgataggaatagttacagtcacgcttgtagatgtaagagatg
-acgttattcttagggttcttaagtcggggggtaatttaagaccactagtaaaggtagagg
-cgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagtt
-agcaactgattttagtggcaaccttaacggttgaattgatctactaatacaggcctacac
-cgaagggtacagataatgattcttactaccctaacatgatagagtcctgtcctatctcat
-aggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattca
-cttatagacttcaggttatttcgtgctaacattaagatagaatataatcagtcgttaaga
-aactattatccagctttcgtcaaccataaagattaaaaactgaaacttggcaagatatga
-atagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagca
-cttgtgtttagtaaagcgggagagtgcggtaattaatattaatatactattaagctacac
-agcaaaggctgcaataatgttagtaagtagaacataaaggtattctccacaagtaataaa
-tagtgtgagctaattgactaacttaactctcgcgacaagtgatgtggataagatgactca
-tatcgtctttttctgtagtgccgacatcccacctggatcgaacaattccttctagttatc
-gactttgattacctatcctattaaacagatagggttgtaaagtcagaaaatgatcggctt
-gcgttggtctaccatagctagagttagaacgcgtagatagaggccttttgttgccaacgt
-gggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatc
-cattagattagatgtttgtgttttgggtctgatgtcctaactactttctcagtgaaacta
-atgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtcta
-taacgtatataaagtcgctgaatttagaacacaccttatctatgttgtaaagttacttta
-ttccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttg
-tcagtgtagataagaatttctttcatacttcactggaatccggcgtatggatatctctac
-cgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttg
-gtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtg
-aagtctaattatttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgc
-gccaatgaggatagaggacattgcatgtacgtaggactattctccaaggggtcttctatt
-ttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactttataccagatac
-tttcattagatatgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaa
-aaaagacccgttgtgatatgatgtttttctagttcgttctcatatatatagatcaacaat
-gaataatctcatgatctataaccgatgtatatttatattccggttgactgctccggtgca
-attcactacggacactaatgactaatatggcgcctttcatcagaaacgctaaatatgatt
-aatgaattaagggagtattatctaattattagagagtagcagttagtctgatattttcgg
-tgtatgtgttagccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtg
-ttgtatgcttcactttatgactctggttatatccctcggagaacaagaataagagtacga
-gaagttcggtcattgaggatgaaatagaaccgctagacgaatggactcacgtttataaaa
-ctatgtatcacagtactacagctaactctgaagtccgagaagcttttgtaggacaaaacg
-ttataagtacctttcgcagaatacggccgtgcatacctgttataaggcgtagtagggaca
-ccatgctatccctcatatagagctacactaataccattacatggtgactatcgtttacgg
-ccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactg
-cagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctcaatccttttcca
-ttatggcatagcaagtgacgactcgtcagccatgggaataatagcactaatccgattact
-tatgaattagaacccacatgaatgtgattctgcgaattgtctaagaatctaatgattttc
-cggtgaatatggttgttgttatttattgaacttatattattaacatcacccttcgttagt
-gatagtcagctatttccaagaggttccccgagcatttttaccattctctagtcatacaag
-ttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaattctgcagatgt
-tagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtttttcgttacata
-tgctggtaaaatattcatagtaataactacaatacttgatttgttacgtaatgctcgtac
-ataacacaatcgtattccacggaacagtaaagctctattattctgatcgagcctaagaga
-ggatcacactacgctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgac
-cagttatagacagtgtaattccatattacatgtcaggcttaagctaacccgagcctttat
-ataagctataatcaagaattagattggagtgcattttagacttatctatcgaaatagtga
-tagtaagagtttatatgacctgatctagactgatgttctcttccacaacagccttaaggc
-gtggagcctttcttatactattaggtcgcgtcgagagccctattcgtaatgttaacgaca
-ctagactaatatacaatgagctaagaataacacaagtcacaagataatttacaaatcata
-tatctacagtccacaaccatcactagcgattgcaaagcgttattggtactaccgctctaa
-atcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgtgagactgaaaga
-aatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttag
-tttggtcaagactatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattg
-ataaatgccccaacgttccatcacgtctataagccgtgttactaatgtgtattagtgcat
-acctattcagaccatagttcaactgttggactgaaggcccgtcttggggttcgtgaatga
-gagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatcggtttatctaga
-gtcatgcttaaggtgaatttcagccaatgggctcccattgagctagtatggtgctttacc
-tttgtaagtggtggctttccttggtgtgctgactttaacacggcagagtgattatccgaa
-gaatggataataagacgctggcaatattggctaataaagtccgatgagtttcaatcatga
-ctgcgaggagatccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcat
-tcttgatacataaagatccgatatcggtccactttgtttaccaaaagccctaccttcgta
-acgatggaaatgtgaatgagagtgaaatacacgatggggatattgccggtgagtacaagt
-tagaccacacattagaactgacctatattcgtcatcatagagatggagtatgaattgatt
-ctgcgaagtacactggctttacgagtatctagacgccgcggtatatctcccgtcaatact
-atgaaggtatatatatagaggctgaaaattcatgttcaatcctctttctaagagtgagtg
-ggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagt
-atacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaatctcgattcacc
-gagagaagtgattttggcggtgtgcgattaattcttttgatgacagatctcattatttta
-tatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggg
-gggagagtgcgctgaacattttatacgatgtgattactcaaaggataaggttcgaggcct
-ctatactcatggaactatcttataattataatggatcgtggctcattccacctatccaaa
-cttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttggga
-cgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaaattgattctact
-gcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttata
-gcaaacattattcaatttcagtcttgactgaaattagtttgttagtgttagaggtccata
-tgtcacatgcatatggtctagatgccattgtacagtaataccttagattagtattagcgg
-catgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgca
-aataggaatacttacaatttttgatgacttgttagcatatcgctatcacccataaaaaac
-ctgatacttgatgagcgggtgattgagactatgtactgatataattcaatagctccaata
-gatgaaacagctatgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctg
-aacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacgaaatcgatccca
-gaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacg
-aagaatgggtagagagtttgaaggtgcttctggattttcctaagtacgtggtaaaaattt
-gatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgggtgaatctgatt
-agccaacccagtgatctgatttcagttgtcaaatctcttttttataactaccttttgttt
-ccataatttaaccggatctcataatgaacaaacgggtagaataatggtagcacatagcga
-gcttgtctattcagaaatatggcctactcagaatgtattctccaaatcagtgttatgcga
-aacgtaattttacgtgtaataatgatgatttcttatcggttccttgtactacaatactct
-tgcccaacaaatactaagcataacagcaaaattcgaatccccctccttttaataaatggt
-ttttcaatatagccgattcgtattcgttagtctttcaccaactattaacctggcatctaa
-ttaataaaatcaccaaaggactctataatatgacagtcacttcggcctcttttaagacag
-ttgattattgcaggtccgcaattgatggtgacatgcacaattagttagaatccgactatg
-gagacaattaacaattgtagtgcccatttggtccagttgacttcaaccacgagttataaa
-ggtattttaatttatagtcgatagtaccaacaacaagcacaatcataattatgttagaaa
-acccagggggtaatgctctaaatccagctttaaggccagagtgcactatgaaatcgccat
-tgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagat
-accttatgaagcaacgattatatctggactagatcatgatgatcggaataaaacattgaa
-ataagtccttatcaaggagcataaacattttatttaatttatacttcgtaaataaattca
-gaattttttttcaagacattaatctgagtaaatgacggctagaaagggttcctactcgaa
-tcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcac
-cggaaagaaggctgccacttttagcttcttgacgatctttagcgtcatatttttagatta
-gtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaag
-agcaggacaactccttgatcgggaagaactgaaatagacagctgtcattttcattggtca
-acttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaact
-atagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcg
-ttaaaaggaacgggttgccagctacagatatactctaggtatatcccaaacaagagacgt
-cctttggctgttgtaatcggtcataatacttgtcacataaacaagatcgctgaattaaac
-attaaacagttagtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatc
-tatcgtctatcacagagcgacgtaaatttagacaaacattattatttcttgacaatggaa
-tcgataagcgttcctctaacttggtatatatatctcgaccccgggattccagccattctt
-gtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaaatgatattgact
-gcaacagattttggatgcaaaaatatttgtgaattattggttatatactggttgtatagc
-acaatcattaggtcctagaaggcatactcaacctcagcgagagagctagcatgcataatt
-gtaccgcccatattaatattcctgaaatgatttcttacattacgcccaatttcagtcatc
-gaacacccccatcaatttacccgatagagaacgtgatcatacgcaataccctatgcgaac
-gtccactctatagcgtctgtatacaatgattattcgttccatttacaacgttaagtaatt
-taaacttacataaggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgc
-agttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaa
-gagacctttgtatccattgtggagaatatcataaattcaagatggggtgtcatgctattc
-ggtcctaaacattcttaatggctgttctattgttagtctgatttaaaatggaaccatagc
-acgaatagttagatagggctcatacccctgtaacgatctacaaatccttccccgggtgtg
-tgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcacacgtcagattat
-tacactgatacgaattatttcagtcgacagtaattgaatagaaacttattaacgccagca
-cctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttt
-taaaaatcttgatttctatatcaaatgatgtgtagttttttctctgttattaaaatccca
-gtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatcacacgcgttagcg
-aaagcggaatggctaatacagccctacgcaacgtagtgggatcaacatatggacgaattt
-atgctcaatgagccaacctcccccgcattgcggttcattttaaggcctgggtaacatcta
-tcgtttagataatcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagt
-ccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcgtaatacgataat
-tgttgctattgactacaggttatgaaaaaacttactttgcgggtacatgcatatttttgt
-accacattattacgcgatatctctcagtgtactctaaattaaaccctcttcgaacatttt
-agttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtagaatggacaactcc
-agttcaactgcatgtaactcatagctcgcgttagtataaattgactagtagccatgggac
-aaagtaactagtcagcggaaaagatccctttaaagatatatgcaggttgcaagcataaag
-ctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaatttt
-gggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaatatcgcccattt
-tcccgtataagctccgtacttatacgaactacacgaccttttaagcattagccgctcata
-tcgtgattcgtgtacagatgagtctattaaaattacagacatactccatatctcgctcct
-tgaactttgaataatgcgctaacttgtactatgaataggcagaacccaactttcccgttt
-gcgtcaagcggggaaacgatacatgttgtcagatttatgattatctagttttagatcacg
-tttaccgataatcggctgtggtctgagcagtcctacactgagtatttacttcagcttcat
-atcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatctttt
-ttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacgatttttactatag
-cggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtggctcttgtccttg
-aagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaattatttggtgac
-taatagtccgtgggtttgagccatatacctaacgccataaactacgtggtgctttagatg
-caatctaaacagaacagaaagcgtagcgctcatcagcacagactaactttttcagtttga
-gtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgat
-tgggcggctcaatcttgcctaatttctactattgtcagctgtacgactgtactaagtgta
-tagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagc
-gcacttccgttcatcaaattaaatcctggcttacccgattctccggaagtctgacctaga
-gattgacgacggccgcgtattattgagacctcttcaggattaatcaataacgaagtagtt
-gatctgtttggcgacgtaccttaagccgactccgctacacgagtttctactaaaccaatg
-tagccttatgcttagatgaataccgtcctaattagatattccggcataacagcagtaaat
-tatctgttcaatggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaa
-tattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctc
-gttaatcattaatttaggtgcgtgagggttaaacaccagcatattctatatgctagacgt
-cttccttaaaggatcgtagtattataattaataataagaaatatggttgacgtctagtca
-gcgggcatacgctgctctatatactggcattattcaaaacttgacggtaaaaaaacgaat
-tttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacac
-ctctttattgccaagcatgcaataaaaaaaatgttaatagtacgtttacgacattttatt
-ttataataaagagaaactattacacctattgatatgataggacgtaaattaacgagtagc
-ctgcatagaggcaaatgaggtttctacatggtatagacctgatgctgaaacatcgatgag
-ttttggtcccctcgctcgttgaaatctagtcatttactactgtctttcgagctattatac
-cacttcactatgtggtgtttctttgctatgtatggggctagtcaaacatgatgactatag
-ctacaactcagagagcgggcgtgttaagagtatctcatgctagaactgcacgacgaactt
-gatacaaagtaacaacatttacgattccacaaggtgactttgaagaaacatagtttaatt
-ctctgcttcgatcatttctataaaccggtaccatcgcagcggatagatgcataacatttc
-tactactccaggcatcttaaaacacacgtagtacttcactagattaagacacgataagtg
-tataacttggcagtgggaagcaaggagattggcgaactcctggcatctgttacgttttgt
-tcaggctcggttgttgataatgtccgactcctgccatattgaagactcgctcgagggaga
-tcgggattcgttgattataagtacacgtgttccgtaatactatgaggcagtgattcaaaa
-tggcacttctgacttacatgactaggtattattaccacggaagcgttaaaggcacactct
-tatggacttaagattgcaagtgccttcttctagcctgaattcgcgggttcaacacaaact
-ctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtact
-aaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcg
-aaaatcgggttaagcaaacacaaataggaattgtgataaaccccaccttgagaggtcgca
-agaccaacctcgggaacaacggctctaagagaataacctaaatccggatgagtagactgt
-gtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgca
-ttcaattgaatcgtttgtattatgagctgtacagtagctatatcagctatagttatccca
-gaggaacaggtaaactagctctgagcgtgaaatccggatattagaacccctagatgggat
-tgattctagctaatacaggcttatctggttttacagttatctagatgattggtaaggtga
-aacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagctattttctaggt
-attataaagtcgagcattaatatcaatttgacagtaaaggtctttcaccagcttcatatg
-ccatagggcccatactcgatttaaattgaacggtttaacgagtattggaactctcactta
-taactgagtagctatacgaaaaatctggtccatttccagaaatttattatcgatttgctg
-cttagtacccaggaagtgataacccttgaaggcacaacactgtaataagttttcctgtca
-catctgtaatattcggtcactacgcattcacgactaaagataattactatactaattaaa
-agttcaatgttagggccgaatcatagtagaaattctcgtctagcctaatcggacttacct
-atgggctgtgaggatttatcagtatgtggacaaaaatgctagagataggtatagttaaag
-tcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgg
-gatgacaactactatacgtagagccgtactcaggattagatagtgtgaaagagtcaaata
-aaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtag
-ggatattctaatacaggccttcaccgaaccctaatgataatctgtcttaataacattaaa
-tgattgtctccgctacgagctcttagggcctcattttaaatgactaatgtccaaagaaga
-gactttcccaatttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaag
-atagaagattatcaggagggaagtttctattatcaaccgttacgcaaccataaactttta
-aatctcataatggcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgct
-ggggagctagatatcggtataccacttcggttgtggtaagcccgagtgggccgttagtaa
-tattaatagacgattatccgacaatgcattcgctgaaataatcttacttaggagaaatta
-atgctatgagccaaaactatttatgtctgtcacattattgactaaagtatctatcgacaa
-aactgatgtccataagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcg
-agcgaaaaatgaattatagttatccaatttgagtaaattgcctattatacagataggctt
-gtttagtcagataaggttccgcttgaggtgctctaacttagcgagagttagaaagcctag
-tgagaggcattttggtgccaaactccggctcgcatgagtaggccagagagtcactttctt
-tcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgtggctatgtgcta
-ctatataagttagaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgag
-acggggtacgccgttgaggctcgagatagtagataaactagaggaatgtagataaaacat
-tagctagggggtttagttactggattacataggaagtgcaccatcacggtgtgggggttc
-gtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcc
-tatacggactttgcatatctctaccgactcatctggtcgtctatgcgggtaattgtattg
-ctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaatccttataatag
-cataagcaattattagactgcgtgaagtcttagtagttctcaagctttacgttgtatgta
-aataactcacgtaatcagccgtccccaaatcaccattgaggtcattgaatgtacggagca
-ctattatcaatgcggtatgcgattttctgagcgattattgttaaagacttagcgttgagc
-cccggaacacttgattacagattctttaaggagttatccaaatatcattttaaataatag
-tagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtac
-ttctctgatatatacttcaactatgaagattctattcatcgataacccaggtatatttat
-atgcccgttcactgcgcagggcaaattatctacggacaataatgacgtagttggacccgg
-taagaactaacgcttaatatgattaaggatgtatgccagtattatcttattatgtcagag
-tagaagtttctctgagattttccgtcgttgtggtacaccggatttggctctctttttaga
-actgagaactcggagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccg
-ccctcatcaactataacaggacgacaagttccgtcttgctccatcatatactaccgatac
-accaatcgtatcaagtttagtatacttgctttctctcttctacagcttactcgcttgtcc
-gagaagcggttggtgctcataaagttagtagtaaatgtacaactagtagccagtccttac
-ctgtttttacgactactacggacaccatgagatacagaagttagtgctacaattatacca
-ttacatgctcaatatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatac
-gtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttgactaacatcttt
-tacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcgg
-aagaataccacttttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaa
-ttgtagtagaatatattcatttgaccgtcattagccttcttcttaggttgtgtacggata
-gtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttt
-tttaccaggctagagtcagaaaagttggagccatgttaaatagttaccatcataaaccac
-tgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaa
-tggtaacaactgttgcgttacttaggctggttaatttgtcagagtaataaatacatgtct
-tgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaaaagtaaagctct
-tttattctgatagtgactaactcaggatctaaatacgcgattatactaaccttcaccaaa
-gctcaaaaatcatctgctggtgaccagttatagacagggtaattcaatatttaatgtctc
-ccttaacatttcaccagcatggattgaagatagtataaagttttacatggcagtcattgt
-gtcacggttctatacaaattctgatagttagacggtatttgaaatgtgcttctagcatgg
-tatcttacacaactgaatgaacgactggagccgttcgtatactatttgcgagcctcgaga
-ccccgtttcctaatgttaacgaatatagtataatataaattgtgatatgaataacacaag
-taactacagtttggacaattaattgttctaaactaaaaatcattcacttcagatggcata
-gagttatggctactacacatataaagcggtatgtgaaacacccgttttagccggaaaccc
-tctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtga
-ctcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgca
-gcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaac
-tgtgaataatgtctattactgattaactagtaagacattagtgcatctggtccactgaag
-cacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaa
-agcaagcctataggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcac
-attgtgctaggttcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttg
-ttatcggcagactctttatcccaagaatggataatatgtacatggaaagtgtccataatt
-aagtcccttcactgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgact
-tacttgctttttgatcaacttaattatggattcataaagttcagatatcggtacaattgg
-tgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatc
-cccatttgcccggtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagc
-attgagatccacgatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacga
-agaggtatatataacctaaatactaggtacgttgttagagagacgatgaaaattaatcgt
-caatacgctggcgaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtg
-tcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaattcacggaacgt
-agcgttgggaaatatcctttctaccacacatcggattttcgccctctcccattatttatt
-gtgttctcacatagaattattgtttagacatccctcgttgtatggagagttgcccgagcg
-taaaggcataatccatataccgccgggtgagtgacctgaaattgtttttagttgggattt
-cgctatggattagcttacacgaagagattctaatggtactataggataattataatgctg
-cgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatac
-ctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattat
-atatgttgattatttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaa
-gctgcatctcgcttaagtttgagagcttacattagtctatttcagtcttctaggaaatgt
-ctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatgacatgctaaact
-aagaaagtagattactattaccggcatgcctaatgcgattgcactgctatgaaggtgcgg
-acgtcgcgcccatgtagccctgataataccaatacttacatttggtcagcaattctgaca
-ttatacctagcacccataaatttactcagacttgaggacaggctcttggagtcgatcttc
-tgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagttagggcatagtat
-agatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagctgagatctatcc
-taaaatgcaaccatatcgttcacacatgatatgaacccagggggaaacattgagttcagt
-taaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacgggcttatggttt
-ttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaaca
-acattaaaatcgcggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatat
-ctttggtagaacttactttgctttaaatatgttaaaccgatctaataatctacaaaacgg
-tagattttgcctagcacattgcgtccttctctattcagatagaggcaatactcagaaggt
-tttatccaaagcactgtgttgactaacctaagttttagtctaataatcatgattgattat
-aggtgccgtggactacatgactcgtccacaaataatacttagcagatcagcaattggcca
-agcacccgacttttatttaatggttgtgcaatagtccagattcgtattcgggactctttc
-aaataatagtttcctggcatctaagtaagaaaagctcataaggaagcgatattatgacac
-gctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttca
-aaatttactgagaagacgaagatcgactaaagttaaaatgctagtccacagttggtcaag
-ttgaattcatccacgagttatatagctattttaatttatagtcgagtgtacaaaaaacat
-ccacaataagatttatcttagaataacaacccccgtatcatcgaaatcctccgttatggc
-ctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgagg
-tggtgacgagtgagatgatcagtttcattatgatgatacgattttatcgcgactagttaa
-tcatcatagcaagtaaaatttgaattatgtcattatcatgctccattaacaggttattta
-attgatactgacgaaattttttcacaatgggttttctagaatttaatatcagtaattgaa
-gccttcataggggtcctactagtatcctacacgacgcaggtccgcagtatcctggaggga
-cgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccat
-agtgagccgatgagttttacattagtactaaatcccaaatcatactttacgatgaggctt
-gctagcgctaaagagaatacatacaccaccacatagaattgttagcgatgatatcaaata
-gactcctggaagtgtcagggggaaactgttcaatatttcgtccacaggactgaccaggca
-tggaaaagactgacgttggaaactataccatctcacgcccgacgcttcactaattgatga
-tccaaaaaatatagcccggattcctgattagcaaagggttcacagagaaagatattatcg
-acgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatc
-ataaaaatgtgacctctagtatacaggttaatgttagtgatacacaatactcgtgggcca
-tgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgtatttggtctaatt
-atgttttatttagtgacaatccaatagataaccggtcctattaagggctatatttttagc
-gaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaattgccagtgggca
-atcctaagcaaaatgagattctatcctaaagtttgggcttgatataagatttcggatgta
-tgggttttataatcgttggagagctcaatcatgagctaatacatggatttcgctacctca
-ccgagagaccttgcatgaagaattctaaccaaaagtttaataggccggattggattgagt
-taattaagaccttgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtga
-gcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgag
-ttcctttgaaatagttaactaatttaaaattaattaacgacatggaaatcacagaaccta
-atgctttgtaggagttatttatgctgtttactgcctctacaaccctaataaagcagtcct
-aagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtcaatttaataaat
-tcaacatcgggtctcaggatattcggtcatataatttattaagggctcttcgagtcttac
-tctgagtgaaattggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcga
-tatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatat
-aagaaaactcacacgtctcattattaaactgagtacaatttttgcacgagaaagtaatgc
-aatacaatatgatgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgc
-actggattaaaatccgattatttttaaaaatattcagtgctagagcatatcaggtctact
-tttttatctggtatgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaa
-gttataacataactcccgttagccaaagcccaatcccgattactgccctaccctaacgtc
-tgccatctaaatatcgaacttgttatgatcaatgtgactacctcccaccctttccccttc
-atttgttccactggggataagctagcgttttcagaatcaatgcaataagaatagccaatt
-gtctcacttcatcagagctcttggcaattccaggcgctacgtggttctggaatatattca
-tttttcaaatagtaatacgtttagtgttgctattgtctacacgtttggatattacgttat
-gtgagcggacatcaatagttgtctaactctttagtaagccagagatagcactcttagcga
-atggataccatcttccataagtttagttaatagtccgaaacaactgcttcgagcatattt
-gaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatagatagagtttgtt
-ttaagggactactagaaatgggacaatcttaatagtatgacctaaactgacatttaaaga
-tatatccaggtggcaagcataaagatcattgcgccacctccaccgtgggattacttatca
-gtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagctgagttgatgct
-aaccttacctatgataccccattggaccggttaacagccctacttattccaaataaaaga
-acttttatgctgtagaagctattatagtgatgcctggtaacttcagtatattaaaatgac
-acacatacgccatatagagctcctggaactttgaataatgagcgaacttcgaagttgaag
-agcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattg
-atcattatcgaggttttcataaccttgacccattatcggctgtgcgcggacaagtactta
-aatcactagtttcttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataa
-gacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggatttta
-aattttgttccatttttaatttagccgtaaggatgtccgtaaatgattgaaaattggatt
-caatctttgggcctatgctactggaacctgatcgacaaaatttcaaacatacgttaactc
-cgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccatataccttaccac
-ttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagactaccgatcatatc
-aactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaag
-taccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaattgctaagaggctc
-agagctaccactgtaatttctctagagcccataataaatgaacgatacatccgtaggtag
-cacctaagggattataatggaagccaaatgcagttaataatattatatactggcgtacac
-gattcgacggatctctcacatagtgattcacgacccccccctttgattgacacagcgtca
-gcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagct
-acaactgggtataatttaccatgcttccctgatgctgagtgcaatacactaagaatgagt
-ttttaccccatatcaccagtatttgttctgttattgcgaagaaatggctatgctgagttg
-gcgactaaagtcacccatcctttttattaggtaaccccctcccttaaactaactgatttg
-ctggagctgccctgcatacatatactttatcatttatggacgtccgtgacgcttattatc
-caccatagtcgatatgctacacggattcattaatggatcgtaggagtttaagttatattt
-actaagatcggtctcggctactatcccgccttacccggcgctatttacggccatttttaa
-tatattgacggtaattattcctatggtttcgaccgcacgtccttggacaagaaagaatgg
-caaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtga
-tgagtaacttgacgaaatgttagtggttattaaagactatctattacaccttttgttttc
-tgtcgtagtatattaaagtctagaagccttacaggaaaatcagggttatacagccgatac
-tccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgt
-atactgtatttagaccttttatacaaagtaaatatctcggctttatgtgattgggagggg
-cctactcaaacatgatgacttgacctaataatcactgtgcgggcgtcttatgactagcta
-ttccttgaaatccaccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtg
-aatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcg
-cacacgttacttccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaatt
-cacgagtttaacaaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaa
-ctactcgaagatgtttcgttttcttaaccataggggcttcttaatggcccactacgcaca
-ttttgttcaagcccgagagggacatccccattacgggagtattactaaaactgttccgta
-atacgttcagcaagggatgaaaaaggccactgctcaagttattgacgtgggagtattaca
-tcggaagcctgaatcccacactatgatggtctgtacaggcctagggactgcgtctagacg
-gtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaaggctcacaccta
-ccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaata
-aagacgtggcaaaaacccccgcacataagccgctttagatttcacaaataccaatgcggt
-taaaaacatccttgagtcgtacatacaccatactcgcgttaaacggatataacagaagat
-aataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaataatgcttacca
-gtcatttagctatacggctttcatttcatgtcaagagggtggagtttgacctgtacagtt
-gatatatcaccgatacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccg
-catattacaaacaatagatgggattcattatacataagacacgatgatctgctttttcag
-gttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtat
-tgacagggaacctattttcgaggtattatatagtccagcttgaatatcaatttgacagtt
-aacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaaattctacgggtt
-atcgtctagtccaactatcaattataactcacgagatataagtaaattctcgtacttggc
-ctgatttttattatactttggatccttagtaaacaggaagggagaaaccttcaacgaaaa
-acactggattttgttttactctcaaagctcttatatgacggaaataccctgtcaagtctt
-aactttattactagactaatgaaatgggcttggggtggccagaatcatagtacaatttag
-cggatacactattcggactttcctatcggctgtctggttggataagtatggggactaata
-ggctagacatacctatacttaaactatacaggcgtcatctatctctgcaactttggagtt
-ccctgatgttctcccgccctttgggttcacatcttctataccgacacccctaataacgat
-tagtttgtgggttagagtaaattaatacggttaatattaatgtatcgttgaaaagctggt
-gtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtataactaccctaatg
-ataagctgtaggaataaaattaatgctgtctctaagcgaagagatatttccgactctgtt
-ttaatgacgaatctcattacttctgacttgcaaatgttcaatatggcacggtttcacggc
-acctttgtgacgcatataatgaacttagaagattataacgacggaactttatatgataat
-ccgttacgattaaagaatctgttaaatatcataatggcattcagttctagaccgtgcatc
-atggtaaacttactttctctgcatggcgacatacatttcgctattcaaattcgcgtgtgg
-ttacacccactcgcacctttggaatattaagagaagatgatcagaaaatccattcgctca
-atttttctgacgtacgtctaatttatcctaggagacaaatcgttttatgtctctcacatt
-tttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaagatactcggtgg
-agcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttccaagttcagtta
-agtgaatatgtttaacatacccggcttttcgatcttaagctgacgctggacgtgcgagta
-atgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacgccccctcccttc
-tcgagcccactcacgctatgtattgacgcgaacttgttcgggatcagacttttcaggagt
-tcggtcgcgtgtccctatgtgctaatatataagttagatcgcattagatgctaatctgaa
-tacttatagacgaccttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaa
-acgacaggtagggacatataaaatttgagtgcggctttagttaagggtttaattacctac
-tcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgt
-actaggtagtgattaatgatatcctagacgcacgtgccttagatcttcagactctgatgg
-tccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaatt
-acgatatctaaatacttataatacaataaccaaggatgagaatgactcatcgcgttggag
-ttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcccaatatctccag
-tgagctaattcattggacggtccactttgatcaatccccgaggagatgttcggacacttt
-agtctgtaacacttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttt
-tccaaagttcattttaaataagactacgataggcctttcctattgatataaactacccgg
-ctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatagcaagattcgatt
-cttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcataggatctaagca
-aaattatcaagttgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcc
-cacgttgatagtatgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtac
-accggatttgcatcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgat
-atttagcaagaggcgttgataaagccctcatcatctagatctcgacctcatctgccctct
-tgctccatcattttctacacagactactttcctatctacgttagtataattgctttctat
-cttagtatcatttagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaag
-ggacaacttgtagcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaa
-gaagtttgtcattctattagacattgaattgcgcaattgacttgtaccacttatgatcga
-acactgaatcaagactgtgattaactaaaatagacaagccactatatcaactaataaaaa
-cgcccctggtggtcgaacatagttgactacaggataattaattggactggagccattaca
-ttctctacaatcgtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaa
-aaaaatgctttcgcaggagcacattggtagttcaatagtttcatgggaacctcttgagcc
-gtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgaga
-gggaattcaccggaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgt
-ttaagagttaccagcttaatccacggtgctctactagtatcatcagctgtcttgcctcgc
-ctagaaatatgcattctatcgttatcctatcaacggttgccgtactgagcagccttattg
-tggaagagtaatatataaatgtagtcttgtctttacgaagcagacgtaagtaataatgac
-ttggaataccaaaactaaacatagtggattatcatactcaagaactctccagataaataa
-cagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaa
-cgctaattcatttgttattggatccagtatcagttaaactgaatggagtgaagattgtag
-aatgttgttctggcctcgcatggggtctaggtgatatacaatttctcatacttacacggt
-agtggaaatctgattctagcttcgtagctgactatactcaaggaaccactgctcaaggta
-ggagactagttccgaccctacagtcaaagtggccgaagcttaaactatagactagttgtt
-aaatgctgatttcaagatatcatctatatacagtttggacaattatgtgtgcgaaactaa
-aattcatgctattcagatggatttcacttatgccttagaaacagatattgcccgagctca
-atcaacagttttagccggaaacaatcgaagcatagggacaatgtatcttttcctaaattg
-ccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactc
-gttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaat
-aactgaaagaaacgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacac
-attagtgaatatcggccaatgaaccaaacgcttcccggtacgctatctctctcatcggga
-ggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaac
-ctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtccgggcgtactcct
-ccatggaagggcgcgcatctagtgttataccaactcgctttttaactactatgctgtagt
-tctacaggcatagtggccagtattttctaacttctctggatagatgctctcactcctcat
-ccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatggaggcattaagt
-atcttcactgttccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagc
-tcaagcacactcattgaatactgccccagttgcaacctcacttaatctgacaaaaataat
-gactactctaagtgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtat
-aggcatgtaactcgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtg
-tgtgacaccaggtaattgatgcggatataagctggagatcactcacgcccacacaaggcg
-ctgctacctctttattccaatgtgtaagaatttgctaacttcatttctagaccgcagctt
-tgcggtcataatttcacggtacggacccttgggttagagacttgataacacacttcgcag
-tttccaccgcgcacatgttttagtggcttctaacatagaatttttgttgtgacataaaga
-gtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagccccgtgagtcaca
-tctaattggttgtactgcgcatttagctatcctttagctgactcgaagagattcgattcc
-taatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcag
-atctgcataactcgcgcttaattacttatgagtagttccaagttcgctacgttatgagag
-agattggaattaagcaaatatgttttatggtgattttgggatgagaaggactgctaagta
-cggctactaaacaaatttctaaaaccgccatctaccttatcttggagacatttaagttgt
-atatgtcactagtctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaag
-agccgattcatcaaatgcttatctaagaaagtagtggactattacaccaagcacgaatgc
-cagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaat
-tacatttggtcagcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcag
-ctcacccgcttgctctagatcttatctttgtatgaatgtcagaatttactgcaatatccg
-ttccgaatagtgagggcttagtatagttctctgtatacaggtcacatcaaactccccctg
-tcctagtacagctctgagctttaattaattgcatacatttccttcaatcatcagatgaaa
-acaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaacaactagcccgac
-tcacgttcatccgccgtatccttgttcagttcttactccgtattaggtcagcgaaatcta
-atcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacg
-ctgagcagttatcggctattagatagtggggtgaaagtaattggctggaattatgttaaa
-acgtgatattaagctaaaatacgctacttgttgccgacctaattcagtcattcgatattc
-agttagagccaagaataacaagcttgtataaattgaacggggtgcactaaacgatgtgtt
-actctaatattcagcttggagtatacctgaaggcgaattcatgtatcggccaataataag
-acgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgtggggattgagtc
-cactgtacgagtacggtctctggaaaattataggttcagggaatataaggaagtaaagat
-aattaccaagagatttttggtatcgctatgacccagaggtgttctaacgtctgttttgat
-ccgcagaatttctgcctcaatgcatatttgacggacttgaactagagcctctaaagttaa
-atggcgacgcaactgttcctaaacttcaattattactactctttttttcctagggtattg
-tagaggccagtggacaaaataaatcaaatttaagatgtttcggacattaacatcccccgt
-agcatagaaatcatcagttatccaatctctcatcgagcttttacaatttctgctggcgct
-atggacagcatatgccgcgagacctccgcaagactcacttgatcactgtaagtatcttca
-ttagaggttagagcctatagttaagctgctgacctagtaaaattggtattttctaatttt
-attgctcaagttaaaggttagtgaagggataatgacgttatttttgaacaatgggttgta
-ttcaattttatatcacgaatggaacccttcattcccggcataatactagacgacacgaac
-aagctccgatctatcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagca
-tcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcaggactacttattacc
-tattaataagttaacatgagccttcataccccgtaagacaatacatactccaccaattag
-aattctgagccatcttatctttttgtatcatcgaagggtatggccgaataggttaattag
-ttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctc
-gccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttccggattaccaaac
-gcggcaaagagaaacattgtatcgacggagataacttaatacagaaggaaggggcatctt
-cgaatacggatgaataattctatctgtttattctgacatcttgttttcaggttaatctta
-cgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaatattgacgagagca
-atctcactccttttgggtctatttatgttttattgaggcacaagcctatacagaacaggt
-actattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttgg
-tacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgg
-gctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgacc
-gaattcatccatgtagattcagatcacacactcattccttgatgttgtctaaacaaaagt
-tgttgtggacgcattggagggagttaagtaacaacttgggatcgcatacttataaaaatt
-atatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagt
-cactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgt
-accaaatcgaaagaacacttaataaggcttgcttgcacggaggtatgatgtttactgact
-ctacaaccctaattttccagtacgtacattcattccaataggttagttctcaaagtgcta
-tacaggctcctcaattgatgatatgcttcagccgctctatggatattagctcattttatt
-taggaagcccgcttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtg
-tgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctctcccgttcacta
-ccatacttggtaccgtgcgcatattacatatagatataggatcattttttaaagctgtac
-taggtttgatcgacaatcttatgctatactatatgatgtaaccctcataatcaataccga
-tcgtacgatcctagcataggtggcaagcgattttatgccgattattgtgttaaatagtct
-gtgagtgtgattatcagggctacgttggtagaggggttgtatagacctcgcacacattgt
-gacatacttaacaatatacgaaaactgatataataaatccccttacccaaacaccaatcc
-cgttgaatcaactaccataacgtctcccatataaattgcctacttgtttgcataaatctg
-aatacataacaccattgcaccttcttgtgttccaatcccgttaagattgccttgtcagat
-gatatgcaagaacaatagcatttgctagcaattattaacagctcttcgaattgcctccac
-ataacgcgggagggtatattttaatttggcaaatactaagtactgttggcgtcatatgct
-attaacggttggatattaagttatgtcagccgtaagcaagagtgggcgaaatattttgtt
-acccagtgagagcactcttagagtttggatacaataggccatatgttgacttaagaggac
-gtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaa
-tcttaagaatagagacacgttcgtgttagggtatactacaaatccgaaaatcttaagagg
-atcacctaaactgaaatttatacatatttcaacgtggatagatttaacataattcagcca
-cctccaacctgggagtaattttcagtagatttactagatgattagtggcccaacgcactt
-gactatataagatctggggatcctaacctgacctatgagacaaaattggaaacgttaaca
-gcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgc
-gtaacttcactatagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatg
-aatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccc
-cttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttg
-agcaggtccgagcacatggaagtatatcacgtgtttctgaaccggcttatccctaagata
-tatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttgtgcgactccacg
-tgcatgcccagaaatacgagtttaaatttggttacatggttaattttgaccgaagcatcg
-cactttatgattgataattggattcaatatgtcgccctatgcgaatgcaacatgatccac
-aatttggctataagacgtttaatccgtatcacactttgtttgcggctagtatagtaacgc
-ccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttcaaatataaaaac
-taatcaaacacgacccatatgatcatctgaagatatttggaactttctcgacaaccaccc
-tcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatatt
-gagtcaagatttgcttagtggcgatgagcgtacacgcttatttctctagtcacaattagt
-tatctacgagacatcacgagggagcaaataagcgatgttatggctacacataggcacgta
-tgaatatgatataagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacc
-cacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccc
-caacgtaaggatcaactagaagagaaaactcggtattagtttaaatgcgtcacggagcat
-gagtgcatttcactaagaatgtctgtgtaaccaatataacatctatttgttatctgattg
-cctacttatggctttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtacc
-aactccctttaaattacgctgtgcaggctcatgcactgcatacatatacggtagcaggta
-gggacctcacgcacccttattataatcaatagtagttatcagtcaacgaggcaggaatgc
-tgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactatcacgcattacca
-ggcgagatttaagccaattttgaatatagtcaacgtaatttttactatgggttccaccga
-aacgccttgcacaactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaa
-taccttcatatatattttttcggttgactaacgtgaactaaggttaggggttttgtatgt
-ctatataggaaacagtttcttttctgtcctactttagtaaagtcttcaagccttactcca
-aaatcacggtgattaagccgttactcagcagcatgattctgcctgctcgggtcctaaaat
-ccagccttgtaagagtcgctgtgtattagctagggagacctttgttaaaaaggatatatc
-gcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatct
-ctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaa
-aatattggtacttgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagag
-aattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggcttagaagactcc
-atgatttaataaatactacgaaggaaagactggatctaaagataactctagtaaggccaa
-ctcccttcaatgctgttgccagttataatccaagagctgtccttttctgaaccatagcgg
-cttctgaagcgaactagaagcaaagttggttctagccagacagccacataccctgtacgg
-gtgtattactaaaactggtccggtattagttcaccaagggaggaattaggcaaaggatct
-aggtatgcaagtcggagtattacatccctaccctgaatccatcaataggttcctctgtac
-tggccttcgcaatgagtattcaaggttgtacagccgtataataataagatagtgactatg
-aacgggaagtaacccgctcaccttccccaaaacattgttatatctaagtattaaagtctg
-ccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcacttaagccgcttt
-tgatttatatttttccaatgcgcttttaaaaataattcagtcctacatactaattaagac
-ccttaaacggagatatcacaagttaagttttaaccatctcgactaggtggaactatagat
-acccaactcaatttatcattacctgtaatgttcctagaaggattgcatttcatgtcaaga
-cggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaatcacctaaaccta
-ttagtcagagcacccggttagaaccagttgtcaaaaaatagagcggttgcatgagacaga
-agtaacgatgagatccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcc
-cttaaaaatatttttaaatactaggcaaacccaacataggttagtcctatgtgatacgcc
-acatggtatatcattttgtaacgttacctagggataatcaggaagtggaattacgcaaaa
-gtagacagtgaaatgcttagggttatagtctagtccaaagataaaggataaagcacgtca
-gagaactatattagccgaatgggaatcattgttaggagactgtggatcatgtctaaaaag
-caacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgat
-gaccgatagtacctgtatactagttactgtattacgtgtctaatgatttcggattggggt
-ccccagaatcagacgtcattgtagacgattcaagtttaccaatttaatttcccagctctc
-cttggagaactatcgccaataattgcagtcactttccttttctgaaacgataaagccgtc
-agagttctctgcaacgttggacttacctgaggttctaacccactttcggttctaatagta
-gttaacgacacaacgaataacctttactgtggggctttcacgatattttttcgcttatta
-ttaatggttacgtcataagctggtgtccaaattaaggttaccggcttcgcagagtagttg
-tatccaagtataacttccctaatcataagatcgaggtagaaaattaatgctgtctctaac
-cgaacagatatgtcccactatgtggtatggacgttgctaattacttctgaagggaaattg
-gtcattatggatacgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttg
-atccaccgttctttataggataataactgacgattaaagattatggtaaatagattaagc
-caattctcttcttgtcagtgaagcatccttaactgacttgctctgcagcccctcatacat
-ttagctattcaaagtaccggctcgtttcaaactctcccacctttggaagaggttgtcaac
-ttgataagtatatcatttacagcattttttcggacgtacctctaatgtttcattgcagaa
-aattagttttttctatcgcacattttgcaagtaacgttagagacacaattatctgcgaat
-gaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatca
-aggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccggcgtttcgatctt
-aagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtctgtctccaaggg
-tcggcaaaaaagacccctccattctcgagcccactcacgatatgtagggacgacaacttg
-tgcggcttatgaattgtctggactgcgggcgagggtccatatctccgaagttagaaggga
-catacctttagatgataagatcaattcttattgacgaaattcatccacaacggggaacaa
-cttcaccctagacttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccg
-tttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcga
-caagatagaggctatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtg
-cctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggcataaaactccag
-caatttgggggccgaaaacaaatgacgttagctaattaattatatgacatgatcaaagga
-ggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaact
-tttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcctagttgataattc
-cccgagcagtggttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaatt
-ctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcag
-ttcctattgatttattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgt
-ttatgattattgctactttagatgctgactgttaactccgtgttgtttttcaaccgtata
-tcacaaccgaattggatagaacctatagtttcaagttctgccacaaggtatcatatttac
-agttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtaga
-gctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtgatagcacatatac
-cacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaacacatattattat
-tgttatccaactaatcggacctatgcataaagcattgtctaaacagaataattgcctata
-tacggtagttttagtgatttatatcttagtatcagttagagcttcgaactcttcaggttc
-ctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttcca
-agtagtacctataaatcacagaaagatctgtctcagtatagttgaaatggtattcagcta
-gtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaacgaatatagaca
-agacactatatcatataataaaaaagaacatggtgctcgaacatagttgaattcaccata
-ttgaaggggaatgctgacatgtaattcgctactagacgatcaattccctacttgtcaaag
-ttgaactggtacgttcttggaattaaatatgattgcgctggaccaaattgcgacttcttg
-agtttcagggcaaacgattgagccggaggatgtccgtctcttacctttcttgcttatgat
-aaacgacggtccctgtacatcactgggaattctcagcaaaaataattgggtaaatcgaga
-ctcgatgtattcggccacaaaggtgttagacgttaaagattattcaacggggcgataata
-ggatcataaccggtatgcaagcgcattgaaagagccatgagatccttatccgataaacgc
-tgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaa
-gttgaagacctaagttataatgaagtgcaataccaaatcgattcatagtggattatcaga
-ctcaagatatctcctgataaattacagttgttaagatacggataaaatgagatttaagat
-tagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagtta
-aaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagt
-taatatgtagcttacgttctagcttgtgctaatctgagtatagattcgtagaggaatatt
-atcaagcttccacgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagt
-agcgtaaactatagtctagttgttaaatgctcagttcttgttatattcgatatactcttg
-gctaatttatgtctgagtatataaaattaatgatattaacttgcatttcacggatccctt
-agaaaaagattttgaccgagcgcattataaacggttacaccgaatcaatagaagcatacc
-caatagctttctttgaatttattgcctgcgcaacttggctgactctctagatccgaataa
-ttctatatggtcgtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgg
-gccgataatggctctttgcaaaattactcaatgatacgattgatcaaagcggtagttgct
-agtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttccaaaagagtcca
-cgtaccatatctatctcatagcgacgcgaggggaaccttatctaactatcattccattta
-ccgggtgactctcgatgcaggatccgattgggataaattgcccagaaatggctcattcct
-gactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggcttataccatcta
-gattgttaactacttgcctgtagttctacagccatactggacagttgtttctaaatgatc
-gggattcatgctagcactcctctgaatgcaccgcgtaagtttaactattacgtccgtggg
-cagataaggatggaggctgtatgtatcttaactgttacctaatatggctggtaattatca
-aagtaaggaccttaatgccatagcgctagcaatcgctttgtatactgaccatgtgccaac
-ctctcttaatctgtaaaatataatgtcttagctaactgtggacgatcatgtctctgccta
-gagcttcgctgtatcaattcctatagccagcgtactagtgacacaacaacaccgtgtgag
-aaaagatattagtccttacgtctgtctctctacagcttattgatgaggattgaacatgga
-catatagctccccctcaaaagcagatgctacctctttattccattctcgaacatttgccg
-aacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacgtcacgtcccttt
-gagactggataaatatattaccaggggccaacgagcaattgttggaggcgcttctataat
-acaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatatt
-aatgtgaaacccccctctctcacatcttatgcggtgtactgccctggtacatttcctgta
-caggactccaacagtgtagattcctaagatagctgttggagttgcctcacgccagatcga
-aaaactgaataaactagtgagctgagctgcagaaataccgcttaattacttatgactagt
-tcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattt
-tggctggactagcactccttacttcccctactattcaaatgtcgtaaacagcatgagaca
-ggatcgtgctgacatttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcg
-ttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctg
-gtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaa
-gcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaa
-aaaatatttttaagcagtaggcacctaacccgattcctctacttagtagctttctttgat
-tctcagaattgactgcaatatcactgcacaattctgtgccattactagacttctctgtat
-taacgtctcatcttactaacactcgcctaggacacatctgagagtgaagtatttcaatac
-atttactgaaatcttcagttctaaaatccccgaataaggctcttatcggtttggccaaca
-caagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaa
-taactatttcggcagacaaagcttataacaagttgccggcgcgtataatatttaaaagac
-cccttgagctgctcaattaaaacgctcacctggtataggctattagatagtgccgtctta
-gtaaggggcgggaattatcggataaactgatattttgataaaataaccgacttgttcacg
-acataagtcactaaggagattttatctttctccaaagtatatcttccttggataatttca
-aagcgctgcaatttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgt
-agtaatctagaggcaaattataagaagttcatcatatcattttcgactacaaaaacaagg
-tgttgtatgccggcgcattgtgtaaactggacgagtaccctagatggaaaattatacgtt
-aagccaagatttcgatgtaatgataattacctacacatttttgctatccataggaacaag
-agctgttctataggctcgtggcatacgaacatttgctgccgctatgaatattggaagctc
-ttcaactacagactctattcttaattgccgtcgaaaatgggccgaatcggctattattaa
-tactcggtttttccgaggggattgttgtcgacagtcgtaattattattaatattgatgtt
-ggtgaggtcatttaaatacaaccttgcagacaatgaataagggatccaatctctcatact
-ccttttacaattgctcatgcccctatgcaaaccttatgccgccacacctccgcaactctc
-tcttctgaactgtaagtagcttcattactggtttgagactatactgaagctgatgacatt
-ctaaaatggctattttcgaatgtgattcataatgtttatcgtttgggatggcagaatcac
-gttatttttgatatagcccgggtattctattgtatagaacgtatgctacaagtcattccc
-cgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctt
-tatttcccgataacctatcttccataaatagcggacagcaggatactgacgctcaacatc
-agtggttatggtctaatttttaacttttaataaggtaacttcagcaggcatacacagtaa
-ctctttaatttataatcaaattagaagtctgacacttcttatatttttctatcatccaac
-gcgatcgcccattagcttattgtgttactaataacgtatctaaaccaatccttttcaagc
-tactgcctatattgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattg
-tcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagacaacgagtgaaat
-ttatacactacgaagggccagcgtacaagacccatgaattaggcgatatgtttattctga
-catattggtttatccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaatt
-ttttttcgaagattcacgactgaaatataaatacgtttggctatatttatgttggaggga
-ggcaatagcctttactgttaaccgaagatttagccagtgagtgtgacactaaaacactgg
-aataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatat
-agctctggatataattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaa
-gccggcctctcatattgaaggtccgaagtattccatgtacattaagatcactctctcatt
-catgcatcttggcttaacaaatctggttgtccaagctttccaggcacgtatggtacaaat
-tcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagt
-aaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaat
-acggttagaagggattagttatgttacaaatccattgaaaacttaagaagcattgcgtgc
-tcggagggtgcatcttttatcaagagactaacattattttcaacgacgtacatgctttac
-aatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccg
-atatccattggaccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtatt
-gccataatgtaatacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaat
-gaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgatttcatatagata
-tacgataagttggtatagctctactaggtggcatccacaatcgttgcatttactatagct
-ggttacaatcataatctataccgttccttacatactaccatagcgggatagcgttttttt
-gccgttgattgggtttaagaggatgtcagtctcattatatccgattcggtgggagagccg
-ttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaactgatataagat
-ataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatt
-tgactaattgggtgcagatttctcaattaataaaaaaatggcaccggatgggcttacaag
-ccccttatcattcacttgtatcatgatttccaagaacaatagaatttgctagcaagtatg
-aacagagattcgaattgcatccacagtacgccggagcgtttattttaatgtggatatgac
-gatgtactgttggcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaag
-catgtctgggagaaatatggtggtacaatctcagagaaagattacagtttggtttaaata
-ggacttatcgggtcggaagtggaacttaataagcagtacacaattgggcaacagacgtct
-tgcctattacaataggattacaatgcgttagatttcagacacgttcgtgtttggctattc
-gtcaattccctaaatagttagacgatcaactattatcaaagtgattctttgttcatcctc
-cattcatgtaacagatggcacactacgcataacgccgaggaattttaacgagatttaaga
-gagcagttcgggcacaacccacttgactttataacagctcggcagcataaacggtaatat
-gtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaactaagtggttcatg
-ttcaacagatgtgacgcagcaagcctaacttatctattggttttgctataaaagaacaaa
-gttacacagaatcctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaa
-tagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactc
-cgggtatgataatggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggtt
-aggataaggatgagaccgaacttatttccggccataactttagattttctacctagtaca
-caacatcagggcggacacgaaaccgccatcacatcatataccaggtttaatttgcttaat
-gggggaagtgtcaacgaaccttcgaactttagcaggcatatggccattatatatggcccc
-agagcagaatgctacagcagacaaaatttggatttatgtagtttaatacctatcaaactt
-ggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaattattactactc
-agcagcttctgcaatgataaaatcttatcatacacgtcacatatgataatatctacttag
-ggggaacgggctccacaacctacatagtactcaatacttacactattcgacaggcacacc
-aaacctgtacagtcccaaaagattgagtcaactttgcagtactgcagatcacagtaatag
-cttagttagcgagtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgat
-gtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaactgtacaacctt
-agagataagtctcaggctactaaaaacacgttgtggcactaacaggatcatggttgattc
-ttacttattcggctgaccggcccaataagtaaccttcaactagaacagaataatcgggag
-tagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagt
-taaaatcgttttcttagcggattccctacttatggatttgagctcgtccacaatattcga
-tacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaa
-ggaattaatagaaggttgatggtaggctccgaacgctccatgattataatcaagtggact
-gtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccct
-atacgagtagataaaccatgaacagcacagtgtgaacccatggttgattttaggctacct
-tatttttaatttccgttacacagaaacgaattccacaactaacatgccattaatttttcg
-atatcttataaaagatggtcgaaattcattcatttattttttttcggttctcgaaagtca
-actaagctgtcgcgttttgtttctctttagaggtaaaagtggctttgatctcctacgttt
-ggatactagtcaaccattactccatttgatccgtgagtatcacctgtctaacatccagca
-ttatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgtattagctaggga
-cacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccccagtagatttat
-tcagctagtgtaagtataagatatctcacccacgaggttcaagtgatatgcagtcttaga
-ataatacttatcctgaatttcgatattatgggtacttcaataatccgctagcgctacttt
-atgtctcgttggacagcaggacacatggcagtcttaaacactaaagacatcacctgaatg
-aatgtaatgggattacaagaatcaatgaggtattatatacgacgtaggaaactctggata
-tatacagtaatctagttacgccatcgcacttcattcctctggaaacttagaagacatcag
-ctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaagttgcttataca
-aacacacccaatgacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaa
-acccagcatttagcaataggagctacgtatgcaactcccacgtggtaataccttcaagct
-atcaatatataggtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccag
-tataataattacagaggctctatgaaacccaactttccagctaaaagtcccaattaaatg
-gttatttcgtacttttaaagtcgcccgttctgttattacgcgaattgattctactccaaa
-attaaacacaaattatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataag
-gctctactaaattataattaagacacttattaccagatttctctagttaagtttgaacca
-gctcgactaccgcgaaagatacattcccttctctatttttcagttcatctatgggtcaga
-gaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcag
-tgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaa
-aagactgccctggaaggagtaagaagtatacagctgatccggtgtatccttcagtcatct
-gccctatactaattacacgacgcaaggaaaaataggtttattttctaggcaaacccttca
-taggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggata
-ataacgatctccaatgaaccaaatgtagaatgtctattgattacccttttactattcgac
-ttagagataggagatagaacctcagtgtacttttttagccgaatgggaatctttgggagg
-tgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgtt
-cgtggaatcgataacagatttgttgacccatagtaaatgtatactagtttatgttgtaag
-tgtagattgttttccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagtt
-gaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgta
-agtgtaggtttagataaagccgtatgagttatatcataagggcctcggaaagcagcttcg
-aaccaaagttcccttataatagtagtttaactataaaagtatatactggtctgtcgccct
-ttcacgatttgttttaccggtttatgaagcgttacgtcattagagcggctccaatttaag
-gttaacggcttccatgtgtagttgtatacaaggataacttaaagtatctgttcagcgagc
-tagttaagttatcctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttg
-ctaatttattctcaaggcaaattgggaattatcgatacctgtataccataaggtcgctcg
-atgtgatgcttatgtcttctggtgatcctaccttagttagtgctgattaacggaacatta
-atgtttatcgttttgagatttagccaattctctgattctaactcaagatgccttatctga
-cgtgctatgcagcccctaagtattttacattgtaataggacacgctcctttaaaactcgc
-caaaaggtcgttgtggttctctactggttaactatataatttacagctttgttgagctag
-ttcctctttggtttaagtcctcaatattagttggttcgagcgataagttggctagttacc
-ttagtcactatattagatccgaatgttatgcttcatctgaagaccgccaccctccaaaat
-ttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtg
-tatctgtacacgagtttccatattttcatcaacagccaccgcacacttatgtcactctag
-gtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgctagtcaaaaata
-aacatagcgaggcaccactaattcggccgcttatcaatgggatgctctgcgcgagacgcg
-ccagagctcagtagttagttcggacatacatttacttcagatgatcaattagttttctac
-aaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctttagtatccttcc
-gtcttatataaggtcagtcccccgtttcggtaccctggaatttactaagaataatgaaac
-agcccccaaggacgtacgtttacaaatgatagaccagatcgcctagcttattccgacgca
-tgttgcatagaattgaaccaacggaatgtgagagtaactagatgagccgaccacagcacc
-cgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatgtcctttgagtat
-taagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctcggatattcaggg
-aacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaa
-tgcctacctcatagtgctgaattaacacagcactgcggacctaacttttcgaggtttcaa
-gttcacgtctcaaaacctaataggctggaatatgtagggatcctcggtgaatttgtgatt
-gggtttgttgtagtactgaccaagtgaatattctttttttctaaaagcagatctgctgcc
-gggcactacgaaggagatctctgtgtatcattattgcttcttgacatgatgactcttaaa
-tcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacatattgttgatact
-tcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaaatactggtgact
-tggtcctatctactattagctagacctctggggaaccacgcccccgtaaaacctgtgcaa
-gagagggggtcatacatcttagacatcgcgcctccaccagggaagcattgggtgattgac
-caggtgtgtaacaaatatgattattcttatactaatattagcaaagatgcataatgattt
-gtattaaatgtataattgaattgataagggtcttttagtcagtgatagagtagtataagg
-tagacattagaactcttaaccggacgcagatttttcggtcttagtaagccaattagtcga
-caaaacaaggtaagagcggttactagtagtacctataatgcactgaatcttcggtcgaag
-tatagttctaatgctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaa
-caagctcttgtaagtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcc
-tacttattaggggaattaaccagattgaaggccaatcctcacatgtaatgagataataga
-cgataaatgaaattcttgtaatagttgaactgctacgtgatgggtattatatatgattga
-gatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccc
-tcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcactccgaagtataag
-caataataatgcgggtaatccagactagatcttttcggactcaatgcggtttcacggtaa
-acatgattaataccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgcc
-aggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttg
-tttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaagtccattacctt
-ttagtttcagactggtggagctgactaaagttatatcatcattttgtacactggtttagt
-taacgataatttcagatttaacatgaccagacgataatcgctgtatatccagttggaatg
-tggtttgccagaaaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatc
-ccatccattgcgctatacctcagtgtatttggagctgtagttataccgtgtgctaagatc
-agtagacatgacgagagcaatattatctaccttacaagcatcaacggacgtctagtcgga
-acaaaagactctaaaactcgaacttcaggttaatatactatagttctgtattcagcagtt
-attcttatattcgatattatcttgcctattggatgtctgactttagtatattaatcatag
-tatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaattataaacggtt
-acaaccattaaagacaacaagaccctatagctttatttgaattttgtcaatgcgcaactt
-ggagctcgcgatacatcccaattagtctatagggtcgggacgattctacggcatttctgg
-ttataatgacaacatggattgtggcccgagaatcgctctttcattaattaagcaatcatt
-acagtcttataagcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgag
-ccgaatagcttaaaaaacaggccaccgaacattgatagagaataccgaccacagcgcaac
-ctttgattactttcattaaattgtacggctcactcgacatcaagcttaagattgcgataa
-tgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcagaaagcgtaccca
-gagaagatacgctgttacaatatacagggtgaaattattgcctgttcttcgtaaccattt
-cgccaaacttggttagaaatgatagccattcatgatagaaataagctgaatgataccagt
-atctttaactatgtagtcagggggaagataacgatggtccatgtatgtttctgatatgtg
-acagtattggccgcgtaatttgctaacgaagctacttaatgcctttgagcttcatataga
-tttctttaatcaaaatcggcaaaaagatagtatgagctataatatatgctagtagagaac
-tctggaccatcatctatatgaatactgattcgagcgtgcaattactttagcctgcgtact
-actgactctacaaaacactctgagataagtttgtagtcagtaagtcgctctctataaacc
-ttttggatgaccattgtacagccacttatagatcccaataaatagcacaggagacagagt
-ttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagggcacctattatt
-tgatacctaacctaacggccctttcacaatggagaaatatatgacatcgggacaaacaca
-aatggtgggtggccaggagatatgacatggtggcgtctctaagaaacacggactccctct
-aggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtg
-taatgacctggtacattgactggtcaggaatacatcactgtagttgccgtagtgtcctgt
-tggtgttccatcaagacacatcgtataacgcaatttacgacggacatcagatcaagttat
-acagattatttaagtatcacgtgtgcattgggacataagggatctcacacatgccttgga
-acatttttgctttgtgccgctttttcgctgcactaccaatccttacttaccagtatattc
-aaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcgattgggatagac
-gagacatttgcgagcgccctccacggatacgaatctcccatatcaatgtgaactggatgc
-tatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcag
-ttattcagaacctaatacacaaaaccgtcaaacattttctaattctaggtatgggccgat
-cataggagctaaggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgc
-atatactgagtagctggcgtgcattctctcaattgtatcctttttaactgaactagtcgg
-tcccatttcgtgactgagatctattaaccgataagattaataacactcgcattcgtatca
-gctcagagtgaagtttttcaataatttgactgatatattaacttctaaaataacccttta
-agcctcggatccgtttcccaatcacatcaaaaattcttattccaactatctacggattaa
-caacgtgcatggggatcgtagtaagaacttgttccgatcactttgagtatatcaagttga
-cggcccggttattattgaatagaaacattcacctgctaaattaaataccgcacatcggat
-acccgatttcagagggccgtcttactaagggcaggctttgttcggtttaactgagatgtt
-cattattttacagtatgcttcaactaatatgtaacgaaggacagtggatctgtctccata
-gtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttga
-tcatggcacgtgaaagcaacccctagtattctagacgaaaattttttctagttcatctga
-taatttgccaattcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcg
-aacctagagccattatttgtcggtaacccatgagttccttcttttcagaagttaatacac
-tgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcataacaacattgga
-tcaagatagcaatttggctacctattctaattctcactagattcggtattccactacaat
-atcggcagattaggattggatgaataatcggtgtttaagtccggttgcgtctccaatctc
-ctaatttttattaatattgatcttggtgacctattgtaaataaaaacttcaagactttga
-ataacggtgaaaagatagaagactcatttgaaaatggatcatccacagatccaaacatta
-gcaagacactaatccccaactagctattctgatcgcgatcgtgctgcagtactcctgtca
-caatagtctgttcatgatctaattctttttgggctttgttcgatggtgattcagaatctt
-tatccggtcgcttccctgtagctactttgtggggatattgcccggggattatagggttga
-gatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactacatcagaacatcg
-tgaagacaccatacgcggtacctttatttaccgataacatttcttcaagaaataccggta
-agcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaattttatttaggt
-tactgctcaaggaataaaaactaactatttaatttataataatattacaaggctcacact
-gattagatttgtctataagacttcgcgatcccccattaccggattgtcttaagaataaac
-tagataaaccatgcattttctagataaggcctttagtctaattagatacaaaaaacacga
-tagttgcatccttaatttattgtgtcaaacctggaaccttttaattacccgcaaatcact
-ttatgtcgagactacctctgaaatttattatctacctaccgcatgaggacttgaaccatc
-ttgtaggagttatgtttattagctaagattcgtttatcctgtagcggtccatgtatattc
-aacaagcaaaaagcactcagaattgtttttagttgagtcaagactgatatataaataagt
-ttccctagttttttcgtggtgggacgatattgaattgaatcttaaccgaagagtttccca
-ctctgtcgcacaataatacacgccaatatttccagccctgcttatgccttaatcggttac
-tcaatctcccattgaagttcattttgatctgcatagaagtttcgggcccagccttttttc
-tgccaccttcctccaagctctgtagacgcactctaagattgatgctcacatgtattaatt
-ctacattaacataaatatataagtcatgcatcttcgagtaaaatatctggttctccaaca
-tgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatgattgggttaact
-ggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgta
-ttcctcgtgctcggaagggctattacgcttacttccgttttggtatcttaatatgacttt
-caaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagtt
-gtttaaacgaactacttgctttacaataccggtcgtatatatcgccgtgaatccagaaga
-ttgtcttctttggattatcaaccgagatcctgtggaccgatgttttgggaccttcacaga
-ggactccaggtagagctcgcttttgcattaatctaagaattgtacctctctaaaagatct
-aaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaattactttaggccga
-aaggcacatgagttattatacatatacgagatggtggtatacatcgaattcggggcatac
-actatagttgcattgtatttagctgctttaaataatatgatattaccttccttacataag
-acattaccggcataccctggttttcaacttgtggggctttttgacgatcgcactctcatt
-tgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaa
-tagattacttttcgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaa
-gtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaa
-aaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatcttgatttcattctt
-cttgtcaattgccgacataggatgaaatcagattccaatgcaatacacagtaacccccac
-ccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggcc
-ttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgtacaatctcacac
-atagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaactttattagaag
-taaaaatgtgggcaaaagaaggattccattttacaagacgattacaatgagttacatgtc
-tctcaacgtagtctttccctagtagtctttgaactatttaggtactccagaaaattttag
-caaagggtttctgtgtgaatccgccattcatgtttatgatggaacaataagaataacgcc
-ctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatattcaatttagtaca
-gatccccagaagttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtct
-aattactatactaacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagt
-gtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttag
-gacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatg
-agcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacac
-ataatcgaactattgatagtcgggagcataaccaggtgaacgtactttgttcacgacatt
-tattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatca
-ttgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgagaactttagctgg
-cttttggccagtatttagggaccaagagcactagccttaagctgaatattttgccattta
-tctactgttataactttaaaacttggtggcaccagacttgtcgatacacacgcatcaatc
-tgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttatattatatttaaac
-taaaagatgatattagcttctgagggcgatagggctccaaatcataaagaggaatatatt
-attacacgattagaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttgg
-cagtactccacatctcagtaatacagttgggagagtctcaaatgttgttttattactcaa
-tgaaccaccctcataatttcactgctgttccattaaatttgcaaacgatcatttgctttg
-aagaaacgtaaaatcgacaaaattacagataagtagatgcataataaaaaaaactgctcg
-ctataacacgatcatcgtgcattcttacttaggagcatcacccgcacaataacgtacctt
-aaactacaacactattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaa
-agaacttgctctctcgtaaaatgtgataatagtttgcggagaggattcaattattttcca
-ttgcacctactccactagattcgataaaagaaggtggtcctcccttaaaaagaaatgtta
-agtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatccttccctaagaaaca
-taaaggtttttaataatgtcgactgtgaactataactgcatcctttcctgacctactccg
-gttccttgttgttatttctgaacgagaccagtagataaacaatgtaaaccacagtgggta
-ccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcata
-atcttacttgaaattaattttgccttttattttttttcaggctcgaaattaatgatttgt
-tttttttgaccttctagttacgctaatatgcggtcgcctgtggtttctattgagtcctat
-aacgggatgggatctaatacgtttggttactagtaaacaaggtataaatttgataccgga
-gtatcaactgtataacatcaagctttatgactcatacgcgaagtaatgacacaaggcttt
-caggagatcgcgagtacagagccactaaggggtgtattacgatagtgacaccaccgagcg
-cactcactccccaagtagatttatgatcctacgctaagtattagatatataaccaaagag
-gttctagtcagtgcaactcttagaataataattagccggttttgcctttttaggcctaat
-gcaatattcagctagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtt
-taaactaatcaaatataatctatgaatgttatgccagtacttgaataaatcaggtttttt
-ataagtccttgcatactctcgttatatactgttagagtcttaccccatagaaattctttc
-atctgcaaacttagaagaattctcagctacggggagcataaagtccccaggatgttgaca
-aatacaacaaatgtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagtt
-ttagccgaaccttgtacggataaatccctccattttccaatagcagatacctatcctact
-acctcgtggtattaaattaaagcttgaaatatagagctgcatagcttatccaattcccaa
-gcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagcaaacccatcttt
-aaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttat
-taagacaattgtttataagccataattaaaaacatatgttcaacaggttcattgatattt
-gtaattgcacaggtttttaataaggatctacgtaagtataatgaacaaactttttaccag
-agttatattctgtactttgaaaatgctcctctaccgccttagagactttcaattagattt
-tttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgc
-taaccctatcgtctgtctcataactgtaggtctaatataattttcagttttcgaacacat
-aaccctttgaaaatctgctatttaatgtctcacctgcatgcactatcttctatactgctc
-agaacggctatacgtcactatgctccaagtgacgatttaaacgaagcaaggaataatagg
-tttattttagtgcaaaacaattaagtgcggactacgtgctctttacaataagccttgtga
-ttgggctataggttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctt
-tgcattacccggttactagtcgaattacagatagctgttagatactcactctaattttgg
-acaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaa
-acgattacatattatagacttgttcggggtagagatatcacagttgtgcaaacattgtaa
-atcgatactagtttatgttggtagtctagttgcttttaccattccccgaaaaacttgatc
-tactatttcgacaacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagt
-gccactatttgtccactatatgtaagtgtagctttacataatccactatgactgagatca
-ttacggcctaggaaagcagcgtagaaaaaaagggcccggatattacgactgtaactataa
-aactagttactggtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaac
-gaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttctataaaacgata
-aagtaaagttgatgttcagcctccttcttatggttgcatcgagagtacactactcagtgg
-gaaatagatcggggttcctacttcagattgtattatctaggcaattgccgattgtgccat
-acctggataaaataagctacctacatgtgatgcttatctattatcgtcatactaccttag
-ggtgtcctgttgaacgctacattaatctttagccgtttgagatgttccaatggataggag
-tctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatt
-tcgaaacgagacgttataaatagaaaaaaggtccttctggttctattctgctgaactatt
-gaatggaaagattggttgacctacgtactatttgcttgaagtcatcaatttgacggggtg
-agagacatatggtgcatactttacggactctatattttagatcagaagcttagcagtctt
-ctctacaccccctcacgacataattgcttttaagaatctatgtttgattcctctacggga
-attcggatccgttcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagc
-atacgaacactttgctaactagacgtatgtatagtagctataaatcccgacgatatttac
-aaaaagaaatgagactcaaatatatacatagcgaccctacacttattcgcaccctgatct
-aggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgtattaaatttact
-gcagttgagattttagttgtctactaaggattactctaacccgtaataaggatcaagact
-cggtactagctttactatcattccctatgtgttttcctaactcacaagggtacgtaccag
-cctatgtaattacaataatgataaagacacaaaggaagtaactttacaaatgagtctcca
-gttacactagcttagtccctcccatcttgctttgaagtctaaatacgcaatctctgagga
-tatacagcagaagaacactcataacgttggagtccaagaattagactcatagggccccca
-acatttaatatgtactgtgagtttgaaggtgttctattgttaattcctgctcttgataca
-tgacacgtactccgtgtttaaggcttcggactgactttctttcataagttgagcaacgaa
-aatttcagaatcgataagttggattcactaactaatacggctgattgaaaactccactcc
-ggacctatatggtcgacctttatacgtaaccgatataaaacttataggctggtatatcga
-gccttcctagcgcaatttcggatggggtttcttctactactcaacaacggaatagtcttt
-gtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtc
-attatggactggagcactcttaaatcactctgcgtgtgctaaacgatagatcataacatg
-tcctgagtaaattttcttgatacgtcgcaatataccgttattagttaaacgttctcatcc
-gtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgactcatctcgcctaa
-cacgcacacgtataaactcggaatgactgccgctcttacatattagaaatacagactaca
-ccacggaagcattgggtcattctcaaccgctgtataaaagatgattagtcttataataag
-attaccaaagaggcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgt
-aggcagggagtgaggacgagatggtactcaggacaaatattaaccggacgaagtggttta
-cgtcgtactttcactattagtagtaaatacaaggtaacaccggggaatagtactaaatat
-aatgatatctatcttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaa
-aatgtgctgacttatagcatgatacaaccgattgttacttttgtctattcaaaagattga
-atagttttttatacaaaagccgcatacttatgacggctagtatacagtttcatcccctag
-catcaatgctatggacagtattgaacttataggaaattcttctaatagggcaaatccgtc
-gtgatgcctattttttttcagtcacatcctcaaatggcactagtattgtcgggatcccat
-taacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgac
-agcgacagaactcccatggataaccaattataaggcccgtaatcctctagacatcgttta
-ccaataaatccgctttctccgtaatcatgttgaataccccagagtagtccagatgataac
-cgatgaaacacaagtctttctcaatgcacttacggtgaacttattaccgccaacgtagct
-catcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactt
-tcgtatattcaacgccttgtaattttactttaagacgcctggtgatgtagattcttagat
-aatcagtttgttatcggctgtactttaccataatttcacaggtttcaggtcaagaagatt
-atagctgtatatacagttccatgctcggtgcacagaaacgtgatcggataataatcaatc
-gcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagtgtatttcgacat
-gtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagattagattccttaat
-agaatataccgacctctagtccgaactaaactatagataacgccaacttcaggttaattg
-tctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggccatattggttcg
-agcactttagtttttgatgcataggatatgcaatgtatagctgaaagtactttatctgtt
-tcaaactcacattgattaaaccggtaaacctttaaagactacaagaaaatattcagtgag
-ggcaattttgtcaatcacaatcttccagctagagatacttcacaatttgtcttgaggcta
-cgcaacattagacggattttcgcgttttattgaaataatcgaggggcccaagagtatcca
-tagttcattttgtaagatttctttacaggcttattacagcttcttcagactcctacatgc
-ttacgagttatatgctagcatgtgaacaatagattaatatacaggaaaacgtacattgag
-agagatgaccctacacagcgcaaccgttgagtactttcattaaagggtaacgctctcgag
-acagcatccttaagatggccttattgtcaaatcatttgcagaagtacgcaagatccctaa
-ccaacgtagaagaatccctacaaacacatgagacgcggtgaaaatagacagggtgttagt
-attcaatcttcggagtatcaatttcgccaatcttggtgagaaagcataccctttcttcag
-agaaagaagatcaatcataacactatctttaacgaggtacgcacgcgcatcattacctgc
-ctccatggatctttaggatagcggaaagtattggcagcgtattgtgatttcgttcctact
-ttatcaatttcacattcatatacatgtcttttatcaaaatcgccaataagataggatgag
-ctatattagatgctagtagagttcgcgccaacatcatcgataggaatactcaggacagcg
-tgataggacttttcaatccctaatactctctataattataactctctcttaagtttggag
-gcagtaacgcgctctatataatcagtttgctgcaccattcttcagcctctgatacataca
-aataaattccacagcagtaagagggtttaattgagacatcttgggaacttaggattttac
-tctaacatcaccgaaacgattattggataccgtacctaaacgaactttctcaaggcagta
-atataggacatccgcaataacacaaatgctgcctccccaggagttatgtcttcctggagg
-ctatatcttacacccactcactataggcaaactaaagtttaaatgttgattgtctaaaaa
-aaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattc
-tctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcctttaaagctattt
-acgacgcacatctcagcaagttataaacatgttggaagtttctagtcggaattcccaaag
-aacggatctatctaatgcattcctacatttttcctgtctgccgatggtgccatcctattc
-aaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaaccttacgcctct
-aagggttcctcgagtgccatacaccagtcaggtccgagccacatacacggagaacattct
-aacatagcattctcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaa
-atcatacttgcaatcccatagcacggattaagaacctaagaaacaattcagtaaaacatg
-ttcgaattcttggtatgggaacatcattgcagctatggtctaacgcattaatgtttgggt
-acatcttccatcatataaacaggaagagtctgacgacagggagtgcttgcgatcatgtct
-atcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataaga
-tttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatat
-atgatctgctttaataaaactttatccataggatacgtttccaaatcaattcaataatta
-ttagtcaaaatagataaggatgaacaacctgaaggccgatcggacgtagaaagtggtccc
-atcactttgagttgatattgttgaaccacacgttattatggttttcaaacagtctcagga
-tattgtatatacagataatccgataccagttgtctgacgcccctcttacgtaccccaccc
-tttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaactaatttggaaag
-aagcacagtggatatgtctaaattcttgttattcaggcctgaatttaatacaccgcatag
-ttaacttcgcggtagagttgttcatcatgcctcctctaagctaccacttctatgatacac
-caatagttgttctacggaatctgataattggccaagtcataaacttccgctgcgttcaac
-ccccttgctcgaatatccaactcgaaaagacagccttttggtgtccggaacaaatcagtt
-acttcttttctgatgttaattctctgtggtcagatacagaccaaaaactccgcggattta
-ccatcctccaagaacaaatttgcatcaacatagcattttggctacatattctaagtctca
-atagtttaggttttcaactacattatcccaacattaggattggaggaataatagctgggt
-aagtccccttgcgtctacaatcgactattttttatgaatatgcttctgccgcacctatgg
-ttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatgg
-cagcagccaaagagcatataattagcaacactctaagaacattatagatatgatgatagc
-gatcgtcatgatgttatccggtcacaatagtagcttcatcagctaattcgttttgccagt
-ggtgacttgcgctggaagaatcgttatacggtcccttccctcttgatacggtgggggctt
-attcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagt
-caactatactaaatcacaaaatagtgatcaatacatacccgcttcatggttttaaccatt
-taattgattaaagatattccgctaagaaccattatctacctaaactgatcgccgtatcct
-agtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgta
-gaataataggtcttggagctaaatgatgtgattggtagtgaagacttacccttacaactt
-taccggtttctcggaagaatatactagagaatcaatgcatgggctacataagcactttag
-tctaatgagataaaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaa
-cctggtaatttaaaccatatatctttatgtcgtcaataactctcatatgttttatataac
-ttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagctatgaggccggga
-tccggttgagctacatctatttgctacaagaaaaatgaaagcacatttgttgggagttct
-ggctacactcatagagaaataagtggcccgagtgggtgcggcctgcctccatattcaagt
-gtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcctttatttcctcc
-acggagtagcccgtaatccggttcgaaagagaccattgaagttaattttcatatccagtg
-aagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatat
-gattcatcctaacttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcg
-agttaattttcgccttctccaacatggcatccctacgttcgttataaggaccatacatgt
-aggttttaaaggtttgcggttaatcgatatttacatcatagaaattctatagtcaaattt
-acaagactctagatactcactcgttgcagccggctaggaagcgctttgtaccttacttcc
-cttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactcatacctccgtgaa
-gagggtagatagactattaaagttgtttaatagtacgtattgatggaaatgacccgtagg
-agatttaccactcaatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcga
-aacatgggttgggtccttcaaacacgaatccaggtagagatacctttgcaatttttcgat
-gaaggcgaccgagataaatgagctataacactgtatgtcttttgattgctataaaacaca
-gaaacggatattaatttaggccgtaaccaacatctgttatttgacatagaacagatggtc
-ctttacagcgtattccggccttaatattgaggtccagtgtattgtcctcctttaaagaag
-ttgattgtaactgacttaaataagacatgtcacccattcactgggttgcaactgctggcc
-ctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaag
-acataaatgtcgctatgaaggttattcattaattttagctgttttcttagaaaaggtaaa
-tttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgg
-gcatcattgagattgtaagaaataaagccataaccagccccggaatagaaaatgttaagg
-aaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggac
-attgcaataaaatctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtc
-caccatgtgcagaggataacggaatgtggttccgtcccataaacgatcattctcgcccac
-ttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggc
-taccttctccaactttagtacaacgaataatgtccgattaacaaggagtcaatttgtcat
-gaccagttcattcaggtacttgtatctatacggacgcgttccagagtagtatttgaaatt
-ttgaggttctactgataagtttagctatcgctgtatgtctgaataagaatttaatgttta
-tcttcgataaataacaattaacaactcctaggtgatacactgtgaagtctgctgttcccc
-aaattacatatgctattttgttcacataccatgaagttaagctaagtgctctataatggc
-ataaacggttatcaaactagctcgaatttcttttattacgccggaagcggattaactgct
-gtagatcaaacacgttaggatagtgtcgttttcatatatatctaaattcggtctaacatg
-cattacccatgcttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaacc
-aaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgactacccggatcttta
-gcctttagggtctaaacagaactaatattactacgtgtcatactccggagcttaaccagg
-tgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtatcaaattaaccca
-gcaatacaataagcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcga
-aaacttaatgacatagtgtgatgcattttgcactggattgagccacaaactcaactagca
-ttatgctcaatatttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagt
-cttgtagttacaaacgcataaatctcgaacgtaataggtttaattagaacatccgtagga
-tttctgtttatagtagatttatactaaatgttctgattagattctgacggccttacccat
-acaattaataaagacgaatatattagttatagtttactatccaaataaattaagcgaatc
-gaaataaactgtcacgatactgggcagttatcaacttatcacttatacagttcggacact
-ctatattggtctgtgagtactctatcaaactaactcataagttaactgcgcttccattaa
-atttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatgacacatatggag
-atgcataataaaaaaaacggctccatatttctcgttaatcgggcattcttaaggaggagc
-atctcaccaaaaataacgttcctgataagtcttaactattagaccgtcttcgggaatgaa
-cgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattctgataatactggg
-cggacagctggaaattagttgccagtgcacctacgcaaatagtttacataaatcaacggg
-ctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtct
-accgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataac
-tccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactg
-aaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtg
-cacggaataacataacaaggaatattatttattcaaattttttgtgactgttatttgttt
-tctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtcc
-acggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgtcctttagactat
-tcaaggtagaattttgataacgctctataaaaggtagaaaatcatgattgagcaataaga
-ccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgta
-tttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttatgatcagacgcta
-acttgttcttagagaaaaatacacgggatactctgtgcaacgatttcattaataaggtgc
-agcttgggacttttttggccgtaggctttattaacattcacagtaggtagcgagacttcc
-tatgaaccaatcatgccacgcgttttaacgtttcaaatataagctaggaagcgtttgcca
-ggacttctataatgcaccgttttttttagtacttccttactagccttagtttatgttaga
-gtctttccaattacaaaggattgaatagccaaaatttctacaattctcagcgaacgccag
-cttaatctaaacacgagcttcaaatattctacatatcggcaggagtcaatatataaatat
-gaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataattaaatccttttt
-caattaccacagtacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtc
-ctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttc
-tgacgctagagcttaccattcgttaaacagataactaaaatttaatggctgagtgactta
-gtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatttttaaaaacata
-tgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtaccatagaagtatg
-tataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcac
-acttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaactctacaaggcatg
-ggatgagattctaccgactccggataacactttacgatcgcgcataactctagctcttag
-ataagtttaacttgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatc
-catcctctatcttctataatcatctgaaccgcgatacggcactatgagccaagtgaagat
-tgaatccaagaaagctataattggtttattttagtccatttaaattaagtccggtataag
-tgctctgtacaatatgcagtctcatgggcatatacgttaactaccttttgatacttcgaa
-ttggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaattactctttcct
-gttacatacgatctcttagtttggacaactagcccatgatggcgctcctctagcgcatga
-acctactttataattacatctttatcgatgaatttttttagactgcggaggccttgagtt
-ttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttg
-gaacaggcaccgaaaatattgatctactattgcgtcaactctattctgctaatagcgatg
-gcaaatcacagaagccctcttagtgacaatagttgtcaactatatctaagtcgaccttta
-ctgtatcaacgatcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaa
-aggatttgtcgacggtaaatataatacttgttaagggtagcgacacaggtatactttggg
-tgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttccggtaaccagga
-aatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactccttcttttcgttg
-cagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttcagatggtaggag
-ataccatttggcccattgtgactttacgcgattaattaaccgacatacatctgttcctga
-gctatgatcgtctgaataaattacggtctcctcttgatacctaatggtttctggagacgt
-ttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagctacgcagagcatc
-aaaatatgtatgggaaagtcgatttccaaaccagaagggataaagagaaataacggactt
-ctccgtagattagcctgatattttgatgggaatcatggcggcacatacgtaagagttgcg
-tgaacgaatattttggacggcgggagacacatatcggccattcgttaaggtctctatatt
-ggacatcacaagcttagcagtatgagctactaacactcaagacattattgattttttcaa
-gatatgtttcattcctctaccgctattcccatacgttcgattcgccgggtgagcgaaacc
-acgggactgaggttaagctaatcaataacaactcgttgcgatagagacctatgtatacta
-gagagaattccccaacatttttacaaaaacaaagcagactaaaatagatacagtccctcc
-atacaattaggaccaacatgttattgccgatcctagcacacacaccacaaactcagaact
-tctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaattagcattaata
-ttaaaactaattaggataaactataggtacgagctttactataagtcactaggtgttttc
-cgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataaagaaaaaaagga
-aggtacgtgactaatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaa
-gtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataaagttggactcca
-tcatttagaatcatagggaccaaaacatttatttgctactgtcactttgtaggtgttcta
-ttctgaattcctcatattgatacatgaatcggaatacctgtggatcccttaggacgcacg
-tgctttctttacgtcagaatacatattgtcagaatcgagaagttccatgcaattaagaat
-tcgcctctttgaaaactcatatccccacatatagggtccaccgttattcggaaacgatat
-aataattattccagcgttgagcgtcccttaagagcgcattttcgcttggcctttcttcta
-cgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcaccccatagaacta
-cctctgagagcgcgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgc
-gcattaaccagtcatattaaaatggactgtcttaattgtcggcattaggagcaatattaa
-ctgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagata
-cgattacagactcagatcccctaacaagcaaaacgattaaatcggaatcactccccctat
-gacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctcaaccgcgcttta
-taagatgttgagtctgagaattagatgacctaactgcaagaatcatggcgagtttatcta
-gtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggactt
-agatgataaccaagaactggtttaccgagtactttcactattaggagtaattacatgcgt
-tcaccgcggaatacgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttg
-cattgcaacagtcgctaccagtaattgctgatcaattatagattcattatacagatgctt
-acttttctctattcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgc
-ctagtataatcttgcttccacttgaatcaatgcgatggacagtattctactgattgcaaa
-gtagtctatttcggcttagcagtacgcatgcctatttttttgcaggcacagaataatatg
-caactaggattctcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatct
-acgaagttgatgtttactacagaaagcgaatgatatcacttggagaacattttagatgcc
-cccttttaatctagactgagtgtaccaatatatcaccggtctaccgaatcagcttgaata
-aaccactctagtactcatgataaccgagcatacacatgtatttctcaatgcactgaaggt
-gaactgtttacaccataccttgcgaatcaacgtggcgacttatacttctgtctttgagta
-cagcacaccctaatgaatctaagttagttgttgatacgaattgtaatttgactggatctc
-gcctcctcatctagattcttagagaagatgtttcttatagccggtactgtaactttattg
-atctggtttatggtaatcaacattttacctctatttaaacgtccttgcgccgtgcactca
-atcctgatcggtttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcac
-agagtaagctctctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaa
-ctctcattgtgttgattcagtaatacaagattacctacgcttctacgaaatatactatag
-atttagcctacgtcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtgga
-ctgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtcgatatcaatggg
-atacctcaaacgtctttatctctggataactcacattgagtataccggtaaaaatttatt
-ctattcatctaaatagtcagtgagggctagggtcgcaatcacattaggccacatacacat
-acttaacatgttctattgacccgacccaactttagtagcattgtagccgtttatgcaaat
-atgccaggcgccaaacactagccagagggcattttgttacatttatttaatcgattatta
-cacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtcaacaattcagta
-atttaatccaaaacctaaagtcagagacatgacactaaaatcacattaaggtcagttagt
-gaaggaatggctaaccagctagagaatgcatcattaacaggcacttattgtcaaatattt
-tccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaacacatcagtcca
-ggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcg
-ggacttagcagacactggatgcagtcatagaagatcttgcataacacgttagggttagag
-ctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaa
-cacgtttgtgatttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaa
-aaatcgcaattaacatacgttgacctatttttgttcagagttcagttagagcctaatgat
-tcgagagcaataatcaggacagcctcataggaagtgtcaatcacttagaagctatattat
-tataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaac
-tggcttaacaatatgatacataaaaatattttcatcaccactaagacggtggaattcaga
-cttattggcaacttaggatgggactattaaataacccataagatgttgggataaagttac
-gaaacgaaagggatatagcctgttagataggaaatccccaataaaacatagccggcctcc
-acagcagtgatctattccgccacgcgatatctttataccacgcaatataccaataataaa
-ggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccg
-tatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagcttcctctgcaaga
-tacaatatgactttttagcttttttactaccaaatctcagaatcttagaaacaggttggt
-acgtgctactcggaattcccaaagtaccctgctatatatgccattccttcattggtccgg
-gctcaccatggggccatcatagtaatagaaggtagtaaaactagttgatttccgactttt
-aacaatcactatcctgacccagatatgggttccgactggcccttactccagtaagggcag
-acacacagacaacgagaacttgataactttgaattctcaaatcgatcattgcaacgtgac
-ttatttactagcctactcctataattcatacgtcaaatacatttcaacggaggaagataa
-taagtaaatattcactaaataatggtcgaaggagtcctttgccaacataagtccacatat
-gcgctatagattttttcttggggttcatattcaataagataaacagcaagagtatcacgt
-cagcgagtcattgagatcttggctagcattgtgatagcatattctacctaaatggtagtc
-tagcacagagtggataagatatcagttagatatagacaagtactataacagatctcgctt
-cgttggattgtatggctagctttgatgatatgattttataaaaattgatccagacctgac
-ctggccaattatattcattttttatgagtaaaaatagataaccatgaaaatactcaagcc
-ccttaggacgtacaaagtggtaacataaatttcaggtgttattctgcaaccacacctgtt
-ttgggttttcaaaaaggctaagcagattggttttacagataatccctgaacactggtatc
-tcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaa
-ctaggcggaaaatatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaac
-gcctctttggattacacagaatagtgtactgacacgtacactgctgcagcagccatacgc
-taacattaaaattcgttgagtctacatttgttgttattcggattatgttattgggaatag
-tatttttattcccctgcgtgaaaccacatggatagattagcctactcctaaagactccct
-tttggtctacggttcaattctcttactgagtttatgttcgtaattatatcggcgcagtga
-atctcctaattatcaccggagttaccagacgccatgaacttatggccagaaacattgcat
-gtggcctacataggattagtatcaagagtttacgtttgcaacgacatttgaccaacttga
-ccattcctgcttgtagaccgcgggaactcccctgcacgcgactatagaagttggtggtgg
-atgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaat
-tgagacatgtataagggctattgccagatgaaaaactgcatataaggtcaaacaatataa
-gaacattatacataggatcttagcgttcctcaggatggtatacgctataaagtctagctt
-cagcagctaaggagttttgccagtgcggacttccgctggaagattaggtttaaccgccct
-gacatcttcataaggtcgggcctgattcaaacccctggagtgccgtctcatacttgaatt
-aatcgatggaaaacttcttctagtctaatattattattaacaaatgacggttcaataaat
-aacaccgtaagggtgggaaactgttaagtgatgaatcattttaacctatcatccattagc
-tacagataatgataccccgatccgactagggggtaagtggttgttccgttaggataaacc
-atgtaaaacgttagagggtttgtagattaattggtattccagataaatgaggtcagggcg
-agtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaat
-gaaggggattcagaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcat
-gatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatatttatcgagtcta
-taaatatctttggttgtatattacttcacaatcaccaattctaaatgattcttccactgt
-gcgggtggagatatcaggacgggttaaggttgacctacatcgttttgatacaacaaaaat
-caaagcacatggctggggacttctcgatactatctttgagatagtacgggcaagagtggg
-tgacgcctccctacattttcaagtctatcggataacttctcggtaaaacgctcgcgatat
-agttttaaagcattgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaat
-tcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggttatccaaaaggaat
-aaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatgcgtatggttctg
-atatatagatcgatgcatgaggacactttattttagccggcgaattaatggaatccatac
-gttacttatttggacatgacttctaggtgtttttgctgtcccgtttagcgatatttacag
-attagtatttcgtttctcatagttaattgtatctagatactaactcgttgaagacgcata
-ccttgccatttgtacaggacttaactgttccgtgcgtaatttgaatttcttataggttct
-tcaaggcacgaatacctcactcatgaccgttcatactctagttaaggtcgggaatactac
-gtatgcagggaattgtaacctaggagatttacaactctttaaacaagagtcgctgaggtc
-caggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatcacctagaaaccta
-ctcatacatttgcaattttgagatgtaggcgaaagagagaaatctgctttttaacggtat
-ctcttgggattccttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctg
-ggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaa
-ggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaa
-gtaaagggggtgaaaatgctccccagggttctacagacatagagatggtcagaacacgac
-ccccctctcaacgcagtgtatttgaaatatatggacatatctaccttattctgtaatttt
-agatgtgttctgtgtataccgatattgataagtcaataggcttgattacgtatcttaaga
-caaatctgtttcgcaagtaggaccgcatctttcagattgtttctttttatgccataacct
-gcccaggaattcaaaaggttatcgatacccgatatgctgtgaattattattctaatggcc
-actcattcctgcttatatctggaattggcatgaatatcttacaacctaaagtctggcgtt
-gcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtc
-acataaaagttcattagaccacactttgtgccgacgtatatagatatattacacgtatag
-ggaatgttttctcctaggtgacccgaccttctactaaggttgtacatcgtataatggccc
-attaactacgaggaaagtggtattgacctggtaatgcacgttcttcgatatataccgacg
-aggtaaagtctactattgcaaagtttgacgttatactgataagtttagatttccctggat
-cgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaaatccttggggat
-actatcgctactatcatcggaccaaaattaaataggctagtgtcttatcagaacatcatg
-tttaccgaactgatctattttccaatttaagctgatattacgtccgcgtatttattttag
-ttccccggatgacgattatctgagctacatcatacaagttagcatactcgccggtgcatt
-gatttcttatttcgctatatcttcaagttcacaggcttcatatagttccaattagcagta
-taattaggttttgtaactttaaccatactttataaaaggttatattgcacaactgatcaa
-gcatccgctataacccgagctttaccagttagcggctaataacaaataagatgacttcgt
-gtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggt
-agtaataagtataaaatgataccacatatactataacaatgaaattatttgtaatccggt
-ttgccaacgtatcccccttcgcgataaattaatgacatagggtcatccatgtgccaatcg
-tgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgttataagcgttga
-aagtgatataggccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttatt
-gctggtagtacaacatcacgagcatttctcttttgagttgatttatactatatctgctga
-tgtgattatgtcccacttacccagaatattaagaaagtcctagattgtaggtatacttga
-ctataaatataatttaagactatacaaataatctggctacattatgccatcgtagaaact
-gataacgtagtaacgtcggacactagattttggtcggggagtaatctagcatactaacga
-atttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgttt
-agactattaaggactcatttcgagatccagtattaattatacgcatccatatttatactg
-aagacggattgagttaggacgacaagctaaacaaatattaagttaaggattagtattata
-ttgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgttacttattcagag
-agacttaattcggttatgactggcagctcacctggaaagtaggtgaaaggcaacagaaga
-atattgttgactgaattctacgggctacgaacgtaattacaaagcggttcgtaaagagca
-taaagatcaatacaatggatctctacagtattacgtaaataacatacataaacctggtgt
-tgattcgactagctcatagattaatcattaattgaagctacgaagacgcggaagtctgcg
-gagtgagcaaacagtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatg
-gtgtacattaacgtgggggtagtcaaaggaatatatttactaggaatattagttatgcaa
-atgttgtgtcaatgtgatgtgttttatccagacattggatgcatggctgtgggggcacag
-gatacttaccattagttcacctacaagcggcgtgagagggtctcagttttagccagcgca
-gagaagtacgggcctttagacgattaatgctagaattgtcataaacctcgtgaaaagcta
-gttaataatcatggtgctagaagaacacaacttttctataaaccagttctcgactgacag
-tcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaa
-atctactgggtgcatcagtagagatcgtgttctgagagataaatacaccggatacgatct
-gcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtagcattttttaaca
-gtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggtttaaagtttata
-tgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcc
-tttatagactgagtgtatcgtacactcggtacaattacaaaggatggaagagcaaatagg
-tcttcaattataacagtaccccaccttaatctaaaaaccagcttcaattagtattaattt
-cgccaggagtatatatataaatatctaaagactaaaagactcgtacttttacaacttacg
-tcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattagaaatactccttt
-gtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgatta
-aggcctataaaactgttgttggtatctacagagtgattaaaattagtgaatcagattacg
-aaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggct
-gtagtagaattttggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaag
-cggtttttgttccatagaactatgtagttggttataaaggttgtaatctcggagattagg
-ttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatg
-agttcacgaactcttaatgccatgcctggacaggataaacaatacgcatataacttgacg
-atcgagcttatatcgacctatttgagaagtttaacgggtcgatataatatacaggtctta
-atagccgattttttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtga
-acgatatatcagcaaactgaacattgtatacaacattcctttttgtccgggtggggactc
-catttaaagtatctcacctagaactcagcggtaatagatgcagtctcttgcccagttacg
-gtaactaaatgttgatacttagaattgctaaattttagtctagacatttccaggtaaacc
-ggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaat
-tgagggccctactatagacaatcatcagactttttaattaaatagttttccatgaatgtg
-ttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgtatgactgtagtcg
-gtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttctaagatggacta
-taatcgattaggctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttgg
-aatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacc
-tatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagc
-ctagagacaaagggatactgggcggggaaacctgctccttcacggtaacatggtaacaac
-agaatttggttaaggttaaaacgaaatatactcggagtgaattactgttaggtttcgtca
-tcggatcaataagtagtttccgtgaagacactcttatattagatctccgaaattctgacc
-cgtgcattaggcacttggtaggagattccatttggaacttgctcaatgtaagccagtaat
-gttccgaaataattcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttg
-ttaccttatggttgagggtcaccgttctctgcgtcaattccagagctggagatacattca
-tcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaa
-cggatttagacaaattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcat
-ggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttcc
-gccattaggtaagctatatattgtggtcagaacttgaggacaactatgagctactaaaaa
-taaacaattttgtcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagt
-tacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatcaataacatatagt
-tcagatagagaacgaggtattcgacagagaattacccaacattggttattaatctatgca
-gaataatttagataatgtcactacataatattaggaccaaaaggtgattccccagaagac
-aaaacaataaacaatctcacatattcgctagtacctatgtatgggtatgatcttctgatt
-ggacggggataatttccaggtatattaaaacttattaccataatctagacctaagagagg
-ttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagta
-aattttgctttaacaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcag
-gtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaa
-ctaatatcataaactgccactacatcttgtacaatcattcgcaacaatacttttatgtgc
-taaggtcacgtgcttcctctgctatgctgatttaatcagattcataaaggaatacgaata
-actctggatccattaccacgcaagggatttatttacggctgattactttttggctgttga
-cagaactgccatgaaagtaagatgtcgcatcttgcataaataatagcacctaatatagcc
-gacaaagtgattccgataacagattttaagttgtccagccttgagactccatgaagaccg
-cttgggagcttccccgtgattagaagaatctaaatcccaagtggatggggggagtttaaa
-tctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcc
-tgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaag
-tgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaaggaagcacgcat
-tgaagcagctacgcagaactgagaagatgacactctaagatacaattaatacaaaaacgt
-tttaagcccaatctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatg
-tcccgatgtataataacagctttatttctgctggtcgaggtgaagtagtggaaattactc
-catcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcgtccatccctctc
-tcctagtgatccgtatatccaattagaggataaccaacatctgcgttaccgacgaattta
-aatttttcgactatttaattccgttcaaacccgtattcgtagtaagtgtttcatagattt
-atgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaattgctgatctag
-gatacatgctttataaacatgcttacttggctattttatttactgtcatgtgggggtttt
-tattttcaacaagtatgtgctaccattggataatctggcttcaaattgaagatatgcgtt
-ccaaacttgtctactgtttgctaagtaggagttgtcccattagaactacgcagcacgtgg
-tttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaatttaatgcagatt
-actcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatag
-aaattcgtgataatttttgttccaacctttgaatctagactgagtggaaaaagatttcac
-cgggataccgtttatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaa
-tggatttctcaatcatctgtacgtcaactgttttaacaataacgtcagaataaaccggca
-caatgagacggcggtctttcactacaccacacccttaggattataagtgacgtgtggatt
-cgaattctaaggtgacgggatctacaagcctcagctacattaggtctgaagatctttcgt
-atagccgcgtatgttactgtttggatatgggttatgctaatcaacagttgacagcgagtg
-aaacggccttgcgacctgaaatctttacggttaccttttgattcaagacaggatcgacga
-tggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaac
-gacaagttcacatcctctatgcaactatcattgtggtcattaaggtattcaagattaact
-aagagtcgaccatatattctagagttttacaattaggaaccgttagtctagactaggagc
-gtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgacacatagtgtctt
-ttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgggataaataacat
-ggtgtttaaccctattaatggtttctattaatctaaattgtaaggcagcccttgggtcga
-aagcacattaggccacatacacagtatgaaattgttcgagtgtccagaccataattgact
-accatggtacacggtgttgctattatgactcccgcaaaactcttgacagagggaattttg
-gtacattgatgtaatcgatgatttaacagtaggaactagacgtcatccgttagactgagt
-tccgacatgctcaaattgtcaggatttttatccaataactaatggctctcacatgtaaat
-aaaatcacattaacgtcacttagtgatggattcgctaaacagatagactatcattcatga
-actggcactgtttcgattatatttgcaacatcgaacatacttaaagttaaatacgacatc
-attcaattaaaaaaattcagtacacctctaatgagtatcccgctttggaggaaagagtag
-cactttaaatggacaatttaggccggactttcctgtaaatggatgaagtcattgtacagc
-ttgaataaatcgttagggttagtccttacatccaccatatgttaatgaataaagcctgag
-ggaccttagagctaacttgtccaacacgttgctcatttacttaataaggttgaaatgtat
-cagtaagtgacagcgagtgtagattttgaccatttaactgaccttcacagttttgtcttc
-agacgtcacttacaccataatgatgacagagcttgtagatgcacacactcattcctagtg
-taaatcaagtagtagctagattattataaagagatattttctggcgtcgaacgtaacaca
-gagagagtataaggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaata
-tcatctaactcggtggaatgcacacttatggccaactgaccttgggacgagttaagatac
-cataagaggttgcctgtaagttaagataacaaagggatattccatctttgtgtgctaaga
-acctatttatatttgcagccataaaaacctctgtgctatgcagccaccagagttatttat
-acaaagaaagagaccatttagatacgttaattctgcttgcgatttattaaacagacattt
-cacgtccaaccactacaaaagccctatcgcaagacgatcattgtattatagcctatgcaa
-cgtagctaagcggccgaggaatcataaaatatgaattgttacattgtttactacatatga
-tcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaactaacctgagata
-tatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtagg
-aaaacttctggatttcccaaggttataatgctctatactgaccaagagatccgttacgac
-tcgcaatgaatactctaagggcactcacaaagaaaaccactaattgataaatttcaatga
-taatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcat
-agaaatgtcatagcaggaacataattactatattttaacgatttaatcgtagttggagtc
-ctttcccaaattatgtcatcagttccgatttagatgttttcgggcccttcttagtaaaga
-agttaatatccaagactagctcctcacccacgcatgcacatattcgcgagaagtctgata
-gaatattcgacagaaatgcgactctagctcacactcgttaactgatcaggtacttataga
-caagtacgttatcagatatcgcttcggggcattgttgcgctacctttgtgcatagcagtt
-ttgaaaaattgttcaagacctgaacgggaaaatgatattatttttttaggaggaataata
-cagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaacatatatggcacg
-tgttattcggctaacaaaactgttgtgccttttctataaggataagcagattcgttttaa
-acatatgacctgtaaactgggatctacaaaagaggtacttaaaataaattgcgcaacggt
-ttagatctgcggatctttggttaaagagcaccattagatgtgccatacttcctatcgcct
-gagcgagaatttagtctgaggaaccactcttgggatttaaaacaattcggttaggacacc
-tactcggcggatgaagcaatacgataacattaaaagtcgttcagtctaattttggtcgta
-gtacgatgagctgatggccaattgtatttttattaacagcactgaaacaaaatggagact
-ttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatc
-ttcggaagtatagcgccgaagtgtatctcattattataacaccagtgtacagacgacatc
-taattatggccagaaactgtcattgtgccattaagaggattagtagatagtctggaccgt
-ggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgca
-cgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttac
-gattctagtgcttcttaacgcaattcagtcttctagatccgctattccaacatcaatatc
-tcaatttaaggtcaatatatataacaaaattagacagagcagctgacacttacgaagcat
-cgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagtccgcacttccga
-tgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccact
-cgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctactattagtttatta
-tgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaat
-ctttgtaacagttcataatgttgctaaagattatcagaccccgtgaagacttcgggcttt
-gggcttcgtaccgtagcataatacatctatatagttagaggcttgcgtgttgttgtgcta
-ttccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcga
-cctacttgttaagtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgt
-atttattatactgtaggcaagaagcttttttggcgagatttaagacttaagcctatggta
-aaaatttgatagtgagcgactatagtaagagatttgggtggttagtaattaaaattctcc
-tatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccg
-aaagcgtgtggattatacaaatttcaaacatattggcggggcacttatccataatagatt
-tctgtttgtacgccaaactctgcctcacccctccataaattgtattggctagaggttaaa
-ttctccgtaaatagagacacatatagttttatacaattgtttgaatcaaagcacgagaaa
-cttttaaccgtacattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaa
-atcaatcgctgagcaataagcaagaaaacacagattatacaaagagatctggatgaagat
-attcgtgcaatcactatcgttatgttagagagttccatgcatgaggactcgttttttgac
-caggagaattaagccaagaaataactgacgtatttccaaatgaattctacgtgtttttcc
-tgtcacctttagccagtgttaaagatgactatggagtttcgaataggttattctatagac
-attataacgagtggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcag
-gtagttcaagggattttaggttcttaatccaacgaagaaataacgcatcacccgtcattc
-tattgttttcgtcgggattacttagtaggcagggtattctaacctacctgagttacaaat
-ctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtcc
-ctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgacttcttcccctaaca
-cagaattctcagttttatagctatctagtggcattcctttttataaaactttacgtttgt
-aagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagactt
-ggaacccatgtatattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaag
-caaggtatgttctaatctaacaatgtaaagccggggattagccgccaaaggggtctaatg
-acatagagatgctctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgac
-agatcttccgtattctgttagttgacatctgtgctgtctttaccgattgtgatttggctt
-tagcagtcatttagtttcgttactcattgctcgtgcgatagttccaccgaatatggcaca
-ttcgttctttttttccattttactgcaaaccttttcaaaagctgatcgataccactgatg
-atggcattgattagtcgattggcaactatgtcctgcttatatctccaattgcattgaata
-tagtaaaaaataaaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaac
-tcgtttaaccaagcgccgtacctaacatataagtgattgagacaaatagttctccagacg
-tattgagatatatgtctcctataggcaagcgtttctaattgctgaccagaaattagaatt
-aggttgttaatactatattcgaccattttattccacgaatgtgctattctactggtattg
-ctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaa
-tcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggtatctgccatattg
-ttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaaatattaatgagg
-attgggtcgtataagaaaatcatcttttcagttcgcagatttttgccaatttaaccggtt
-atttcgtcagacttggtagtgtagttacaagcatcacgattatatcagctacagaattaa
-actgtcctgactcgacggggcagtgtgtgagtattgcgctatatattcaaggtaacagga
-ggcatataggtcatagtacaaggataatgaggtttgctaactttaaaaattattgattta
-acggttgattgaaaatctctgcaagatgacgctagaacacctgatgttcaagtttgccga
-taataacatataagatgaattactgtctttagaccctcatgttaatccgctaacttaggg
-cggaaacaatgttaggctatgcggagtaagtactatattatgataccacatagaatttaa
-cattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaa
-ttacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaaggttcagctatt
-ttggcaatgggtgagtaccgttcttagtgatttacgaacccataatctaggcgacttaat
-atacaagatttagagttacgttttccgggtagtacatattaacgaccatggatcgggtga
-ggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccagaatattatgttt
-ctactagagtgttcgtatactggaatttaaatattatgtaagactagacaaattttatgg
-atacattaggccatcgtagaatatgatatagttgtaacgtccctctatagattttcggag
-ggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggatttgtaattaact
-gatgcgcagcgcttaaataagtttagactattaagctatatgttcgacagcatgtagttt
-tttttaccagaaagtgttatactgatgacccatggaggtagctcctcatgataaaaatat
-tgttacttaagcattactattatagtgttcaaactagtaccgttgcatactttaagaatc
-agacatggcgtttcttatgcagacacacttttttagctgttgacgcccacctcacatcca
-tagtaggtcaatcgcataagaacaatattctggactgttttattacccagaagaaagttt
-tttctttccggttcgttaagacaataaagatcatttcattcgttctcttaacgatgaact
-aaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaa
-gataagaagaacaggaacgcgcacgtcggagataactctaatagtctctttattccgttt
-aatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgcaaacctatttat
-gtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttttatcaagacttt
-cgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggag
-tcgctctaagtgttaccaacccctcactactacgcgaaggtactcgattattccttgaat
-gggctgaaacatcgtgattagcgtcttatgattcaggctgatagaagaaaacttattttc
-tatattccacgtatacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgct
-ataataaataaaatacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtc
-acataaataatccgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaagg
-tggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaatatcataataga
-tgccatacacggttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtt
-tcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatg
-acttaggatggatgagcatttaggtattctatgataacactaaccatcatgtttctaaaa
-tcctcaggaaatttgtattattttaccaacctgtatttatagaaagtgcttttgacttaa
-agaagccgaagtgttcaaattaaggagtacctgattgaaagaatggggaattgtaatctg
-taactcaattacaaataagccgttctaaggattaaggctttgtgtctaagcaactcacgt
-gaattcgaaattcatactcgattaacgactttaatactcttctgcgtatctacagactca
-tttaaattacggaatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaa
-taaggacacctggtacaattggctggagtacaatgttggtttttatttgctgattatccc
-gatccctgtgggcgttggcataaccgggttttcttcaagactactttcgtgttgcttata
-tacctggtaatatcggtgagtagcttagggcttaatcacaatactaacaagttctctatg
-gattggacagggcggcatccgttgactgaacgatctattaatccattccctgcactggat
-aaacaagacccatttaaattgaccatagagatgttagcgtcatatttctgttcgtgatag
-ggtacatatattataaacggattatgagcagtggttttctagaaaagcattcatagttag
-gagtgtatcagatcataccactgaaccatagagcacaattctctactggctatacttcat
-tcctttttgtccgggtggggacgaaatttaaaggttctaacctagaacgcagagcgaatt
-gatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttg
-actattgacagggcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagat
-agagtacgggcctataattcaaattcagccaccgaagattcacaatcttcagacgtttga
-aggaaagaggtttactggtatgtggtgtcaagccccacccattctctgttatatccgagc
-attaatgtagtttcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaac
-aatttaggctgagaagtggcactataatagtttagcctaagtcccttcgctaataactca
-acaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatact
-gatagctctcatggtaccaagaactttcataacctctttatttaccaaacctgttctact
-agcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcg
-cctgcaagctaacatgggatcaaaactattggcttaacgtttaatcgaatgagactagca
-ctgtattactctttcgtttcggcagcggatcaataaggaggtgacggcatcactctctta
-tagtagatatcacttattctcacaacggaagtaggatcttccgtcctcattaaatttgca
-actggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggtcagagcagacga
-tgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaa
-attccagacctcgagttacattatgaaacgtgtcattccatctcattaaatagttcgtgc
-cctatcgccttgtaatataaacaaccgtttttgtctattttcccaaggagaaggagagta
-gcagcttagtggcttgcctatatggccccctaagtacgtactcggcacgcttagaagatt
-gggctaccccgcactatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattc
-aggtcatcgatgagagtataaaaatatacaattttggcaggggttatacattgcgggcat
-gaagagtaacattggacatgaacggacattcgaaccctgtgagtttaataccctatctcc
-ggatcattataaagtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaa
-ctaaattggttatttttctttcatctagatttgtctgtatctaactaaattatagttcca
-cataaagctgattcaactgaagacataaatataaactttctaacatagtagcgaggaaag
-agctatgcctagcatcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttt
-tccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtgaacatacataata
-ccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcctacgtaaggctat
-ttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtaca
-ttcagatctccttagtatcatcaaattatagattttacggccacgaattattggtctaga
-tgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaag
-aagagtcattatgctataccaagaactctccatccagtacctagaaaggcaggtatgtac
-cgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggct
-tttataatagaaactaagtttcccgaataacggtgtacgataacagatttttaggtgtac
-agacgtctgactcaatgaacacacattgggacctgccccgggaggagtagtagataatta
-ccttctccagcgcgggtcttttaatatcacaacataaaaatactaattaatatcacacac
-cctcatcctcgatggagcctagcatcatacacgtttgatagacaacgccaattttactgt
-aatatgatattcgaatctagtatgtggacgctgtaccacattgtttaaaggagctccctt
-taccgacatgaacgaagcaagctttgtacaagatacgaagaactcagtactggtaactat
-aagagacaatttatacataaaagtgttaagaccattatataaaaagaggtatgaggtctt
-tgtaactacaataatacattcatcgaacgatggagaataacagagttatttctgctgctc
-gagctctagttctgctaatttctcaatcttgatgccactcgtttgagtcttccattcgct
-cttaacgacgcgtacatccctctctcctactcttacctatatcctattactggttaacct
-acatctccgggaaagacgtaggtaaagtggtccacgattgtattcacttataacacctag
-tagtactatgtgttgctgagagtgaggacacacttactctacgagttcaagtccatatgg
-acattacactttttcagcatctaggtgtcatgatgtattaacagccgttaggggctattt
-gattttatcgattgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaatag
-gcatgaaaattcaagattgcagttcctatcttgtataatctttcctttggacgagttgta
-ccatttcaactaacctgcaagtggggggtcatccatatgaagatttgccaaatacctgga
-gaccctgaaaagtttatccagattaataataacaaacaaacctaagcgaagaacgtcagc
-tttaataaactatcactatcatagaaattcctgttaattgttcttccaaacgttgaatag
-actatcacgggtaatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcg
-aatctgctgataactcaattatattcgatggagaattcatatctaccgcttagcttttaa
-aaattaagtcagattattccgccacaatgagaaggcgcgagtgcactaatcaaatcactt
-aggattattacggacgtctgcattacaatgctttggggtagggttatacaagcatatgat
-tctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatc
-ctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacct
-gttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaaactctaacatag
-cgtggcactatgagtacgtgtaacgacaaggtctcatactcgatcctaagataattctcg
-tctggaaggttttaatctttaactaagagtagaacttagtttattgacttttacaattag
-gatacggttcgcgactctaccacagggcatcatacctggagctctgctatctcgtgacca
-aagtggcagcacacatagggtcgggtcctgcatctactgagcaatccctttaagcattcc
-tagtttgagagccatttagatattgctgtttaaaccgattaatggtttctattattataa
-agtgtaacgctcccattcgggacattgaaaattagcaataagacaatgtatgatattcgg
-cgagtctcaacaacattatggtctaccatgggacaaggggttgatatgatgaatccacaa
-aaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgttataaggacgatc
-tagaagtattcaggtacacggtgttcagacatgctctaattgtcaggttgtttataattt
-aacgtatcgctctctattctaaataatataaaattaaccgctcgtagggatgctttccag
-taaaagatacactatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtac
-attcttaaacttaaatacgtattatttaaagtaaatatattatctaaaccgcttttgtct
-atccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatct
-aaagcgatcatctatttcttctgattgatgtaatactgacccttactccgtacatacaaa
-tgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctg
-gtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcattttgacaatttt
-tctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgt
-agatccaatcacgctttcctacgctaatgaaagttctagatagtgtaggtgttagacaga
-ggttagcgcctacatccttacacacacagtgttgaacggcaagcataatcgagtatcaat
-agctgtatgtatttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaa
-tgtcctgccctagagttatgataaaataactgctgccctgtaacttaagtttacaaaccg
-atattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgc
-gatgaacaaaacacagtgatttataaatacaaagagtacatttagttaccggattgcggc
-ttgacatttattttacagaattttatcggcaaaacacttcatatgaactatcgcttcacg
-ataagtctatgatagactagcattcgtagagaacaggaagagcaatcattatatatgaag
-tgttacagtgggtactacatatgagatcattaggtctatatccggccttcctcataagac
-cttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccc
-caaagaatagtaattcatcggacgtaatagtctggttttaactaggggttattgatattt
-aagctaaaagagttccctgaacactcgaaatgtataatctatcccaactaaaaaagtata
-cctctaattcagaaatgtcattgagattagactgatgtcaatacgctaggaggtaagaca
-agtagaagtttttgatttaggaattgaaatgtaatacctccatcttaagttctatatttt
-aaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatg
-tttgcggccccgtatgagtaatgatctgtttatcaatctctagctactatcccacgaatg
-cactgatgccagtcatggcgcttacattagtcgacagaaatccgacgatacctatcacgc
-gtgaactgttctggttcttattcaattcgaagtgatctcagatacattacggccatgctt
-gcccttcatgtctgctgagcagttttgttataggctgaatctcctctaagcgaaattgat
-aggatttttggtggtcgatttagtctgtacctgcttattaagattcaaaatgacctactt
-cttacgccgaaatgatagggatcggctgaggaggataaatatacgctggtgcctggtatt
-tatccagaacaagttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggt
-acgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtatagtccaccatta
-gttctgacttacttaatatagactgaccgagattgtagtatgtggatccaagcttgccat
-gtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaagagttaattaatag
-tactgcactataattgtcggcggagtaccatgagctgttgcccaattcgatgtttattaa
-cagcacgcataaaaaatccagacttttcaattagaattaactataaatggtccgcgaacc
-ttaaatgatcggaaggacgggatctgccgttgtatagaccccaactctatctaattttta
-taacacctctgtaatcaacaaatcttattatgccatcattatgtcattcgccaagtaagt
-ccagttcgagattctctggaccgtgcaatagtattgtcaaattatggtaatggaatcctt
-cttctaacacccttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagc
-aacataagtgccgtttctttttacgatgatagggattcttaaagcttttctctattctag
-atcccagttgccatcatcaatatctcaattgatgctcattatatagttcttatttagtat
-gtccagatgtcactgaagatcctgcctagaaccgatattctcgacaggatcatcagttcg
-acggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagt
-accgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagttttactgccttt
-aattagtagtcgattagtgtagtttgatattatctaccttatagaatgtaaacagtaacc
-cggccttaatggtttggcaggattctttgtaaaagttaataatgttcataaactttatca
-gaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacgg
-agtggcttgcgtcttgttgtccgagtacacatattgctcctctcccccactcttctagga
-aaatcaattatgctaacctgcagaccttcttctttactatctttaatgcatgcccagtat
-gttcatagggtagacttgctatctattttgtataatctacgaatgatgcttggggcgcga
-cttttaacaattaagccgttgggtataatttgagagggtgccacgatagtaagagatttc
-cggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagctcaccctcctcag
-ttctccaaccctgaaccggctaagtatgactgtgcagtattaattttgaatacatattgc
-agcccctaggatacattatagatgtctctttcttacccaaactcgcccgcaccaagaaag
-aatgtggattcgattgaggttaaattagccggaattacagacacagattcttgtttacaa
-ttgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatggattacgttggg
-gatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaagaattcacagagg
-attaatacacttctccatgaagataggactgcttgcactatccttatctttgtgtcttcc
-ttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataacggaaggtgttc
-caaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggac
-tttagatttgggtattctagagactgtagaaagactgcaacaacaagacattcacagggc
-gaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttaggaatccatacat
-gtaagaaagaatcaaccgtaattatagtgttttcggccccttgaattacgtgcatgcctt
-tgctaaaagacctctgggaaatagattgaatattctggacagcagcgaatcctgattata
-tctcaagcgaatatatgacccgcaagaaggatttatactagaataagtctaagaaagggc
-attgggtcacttcttccactaacacacttttatcagttttataccttgagagtcccatgc
-atttttatatatatttaactttcgttgcgtaaaactttaaatatgatccgtgctctatct
-ctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaag
-aacggtttcttctgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgc
-attagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaa
-caacgcgatttctatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatg
-tcttttcagtttgggttttggatttaccagtcttttagtttcggtactatttgatcggga
-cattcgtccaaacatgatggctcattcgttctttttttcaattttaatcaaaaccttgta
-tttacctgatacattaaactgagcatcgcatggaggtggagattcccatatatgtaatca
-tttgatatcctattccattctttttagttataaataaacgctccactgcacaatgggagt
-aggacttcaccaataattagcatctactgtaaacaagcgccgtaacgaaatgattactga
-ttgagaaaaataggtctcaacaacttttgacagatatgtatccgatacccaagcgttgct
-aattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaatggttattactc
-caatgggctattctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgt
-agtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaa
-atcgatcacggtgatgaattattgttattgtttaaaagaagtcccctgaatagcccttag
-ataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgc
-agagttttgccaagtttacaggtgatttactaacacttgggagggtacgtacaaccatca
-cctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattg
-accgagttattaaacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttg
-cgaaatgttaaatttatggttttttccgttgagtgataatagctgcaacatgaagatagt
-aaaactgaggttaaactttcaccatattaaattatatgttcaattacgcgatgtacaaac
-taatgttaatcagatttaggagcgcgcttaatatgggtccctatcccgactttgtacgag
-attttgataaaaaatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttg
-aaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcctggctcaatatt
-tataatagtaatggttaagattgtggcccaatcgctgagtacccgtcttacgctttttcc
-aacacataatcgacgagaatgtatttaaatgtttgagacttacgttttccgcgtacttat
-tattaaagtcattggagagggtgtcgtctgggtgtagttttctcatctgctcaggagcta
-aaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggctatttaattttta
-tggtacacttgaatatgtttagccataatgtagccaatactacaatatcagatacttgta
-tacgacctatagacttttgccgaccgctcgtagagtgatttagaaagatgttcggatagc
-acagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgc
-tatatgttactctgaatgttgttttttttaccagaatgtgttataatgatcaaccatgca
-cgttcctactaatcatataaattttgttacgtaagcttttctatgatagtggtctaaaga
-ctacccttgcatactttaagattaagacatgcactttaggaggaactcacacgttttgag
-ctgttctagcccacctataagccattcgtccgcaatcccataactacaatagtcggcaat
-cttttattacccagaactaacgtttttatttcccggtacgtatcacattaatcttaattt
-aatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgcttcttgagaatac
-agattactgttagaatgaaggcatcataactagaacaccaacgcgcacctcgcacattac
-tctaatagtagctttattcagtttaatatagacagtatttgaaccaggcgctaatgttaa
-ggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatttgcggggcgata
-gcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacag
-ttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccg
-aagggactactgtattccgtcttggggatgtaacagactgattacagtcttatgatgaag
-cctcattcatctaaaattagttgatttattccacggatactatcacactcctatagaaag
-agttaccaccgtgggaagctagatataataaataaaagacatacaatattagtatggctc
-atgatctacacttactcggatctctctttttttataaccagtagatcgcattacacgtat
-tgttgttccgcatcaggccctaggggctcaaacttccatggtggataactaaaacgtccg
-tcactaaacgaagatattaatagatgaaatacacgggtttacttgatttctgttcagtca
-ttcacgggaaatcctaggagtctttcataacggcggtcttagtaggaatgtagtcaagct
-ctgtagaggtctcgacggaattggtatttcctggcatcacaatttacctagtattggaga
-tcacttaaaataatgttgagataataatcaggatatttctagtatgtgacaaacctctat
-ttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaacgactacatgttg
-gaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtgctttcgtttaag
-gctttctgtctaacattctaacgtcaattcctatgtaatactactgtaaccaagttatta
-ctcggctgcgtagataaagtctcatgtaaatgacggtttatctgttacttttgggtttca
-acctagctaggacgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgt
-gcctttttatgtccggattataaccatccctctcccacttggaatatcaccgggttctta
-atgacttagttcgtcttccttattttccgggtaagatcgctgtggaccggacccattttg
-atctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttag
-attaatcaatgcactgcactggattaacaagaacatgttatagtgtactgacacatgtta
-gactaagaggtctgttcgggttagccgacttatatgtttaaccgattttgacaactgggt
-tgagagataacaatgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctc
-aattcgctaatggcttgaattatttaattgttctaaccctggcgtcgaatttttttggtt
-cgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcg
-gcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaagctactcgaatt
-ggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaa
-gagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtggtctataccacc
-aaaaagtatatgggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgta
-cactaggcagccctaatccaaaacttttgaggatgagtactgccactattatactgtacc
-atttgtaacttacattttatatcttcaaagaggtagatattgtcggccattactgtcact
-tacactaagggtagcttgattactgatacctctcatggtaaaaagtaatttaagaaccta
-tttttttacataacctctgctactaccgttagtgttttagtcggttcaagtcacaaaatc
-cctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaaacttttgccgga
-accgttaatcctatgagaataccactcttggaatcggtcctttaggctgaggatatagaa
-cgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaaacgcaagtacca
-tatgccgtcctcagtaaattgccaaatgcagaaatcttacactcttttcttaactaagta
-tgagagcaacctcactcctgaacagcttgttacctaacgagaagaggctttaagtagcct
-ggagcctcaaccggatatccggatttgactctcatccacttacatgatgattacggtcat
-tacatctcatgattttctgagtgccctatagactgggaatttaatctaccctgtttctat
-ttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatgccaccataagta
-agttctcggaacccttacatgattggcctaccaacctatatatgtgaccaatgtacggta
-catagagtgtggcctatcatattcaggtcatcgagctcagtatttaaagattatatggtc
-gctgggggtattcagtgcgcgatggaagactaacattggaaatcaacggaattgacaaca
-cgctcactttaataacctatctcaggataagtttaatgtaattagacggaactttctcta
-actccgtgtactaactctttgaaaataatgtgggtatttttatttcatctagatttgtct
-gtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtcataaatataaaa
-tttagatcttaggacagaggaaagtgctttcccgagcataggatctggcctacgccagta
-gttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagggtagtgttcgat
-actcagcggggaactgacatattacactaaggaatcaaggcccttcgtatgggtcatgtt
-tatatatttaattacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatg
-caggatgcgattcgagtttgtaaattcacagatactgtgtatcatattattatagatgtt
-aaggcatagaattattggtattgatgtacaaaaaattatgggtgggcagtaccgataggc
-attacgagcagtgcagcttggaagaactggatgtatcctataactagtaagagccttaaa
-ggtactacatacccagggatgttaccatcattaatttggccatcttcaatcttcgcaatg
-catactttcttctacaagatgccttttagaagacaaaataagtgtcaacaataacgctgt
-aacttaactctgttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgc
-aaacgcaggactactagattattaaattcgccagcccgcctcgtttaatataacatcata
-aaaattctaagtaatatctcacacactaatccgccatcgtccatagcatcagtcacctgt
-cttacacaaacacatgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaa
-ctaattgtggaaagctgctaccttgaacgacatcaaccatcctacctttgtacaacagac
-caacatctctgtactggtaaatagatctgaaaagttataaatataactgttttcacattg
-atagaaaaacagctatgtgctatttgtatatactataataaattaagcgaaacatggaga
-ttaaaacagtgttttctcatcctccacctcttgttctgctaatttataattcttgatgcc
-actcgtgtgagtcgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaa
-cgagatcctatttctcctgaaaattattagcacggtaactcctagggatagtggtactag
-ttggtatgaacgtataaaaacttgtactactttctcgggatgtgagggagcaaactatta
-ctcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatacctgtctggatgg
-attatatgcaggtaggcgagagtggattgtagcgatgctcggcgggggtattttaaaaat
-ctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgat
-tagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccat
-atcaagttttgcaatagtactccagaccatgaaatggttatccagattaataataactta
-atatactttcactacatactcagcgggtattaaatttcactttatgtcaaaggactctta
-tgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaactt
-gatcagccttgtaaaatatagtagaatatgatgttaaatcatttatattccagggagatt
-gaatagcttacgattagctggtataatttaactcacatgattaagcaaatatctgtagga
-ccgagggaaagaataaaataaagtaccatgagttcggaacgctgcattacatggcgttgg
-gctagcctgatacaagaagatgagtatggagctctcttcatcgggacgtgacaaccctag
-cgtaatcttggcagatcccggagcagatgattatcgtctaacactgtctttaccaatgca
-caacgcatagatttaacctgaactgttctggattcactcctgactacagcctacaactca
-tttctatgcataactcttaaagacagtcgcaatatcagtacctctatacacatcggatca
-gactagatcataagataagtctcctctggatccttgtattctgttaagtacactacaaat
-ttgtttagtgtctgggacaattacgataagggtcgcgactagaccacagggcatatgacc
-tccaccgctcctagcgagtctccaatctgcaagcactcatacgctaggggcatgaatcga
-ctgtcaatgcactgtaagatttacgagggtgagacccatttagatatgcctcgtttaacc
-gttttaggcttgataggatgagtttgtcgatccatcaaattcccgacattcatattgtcc
-aataagtatatctagcttattcggactcgctaaactaaattatggtataaatgccgtcaa
-ccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggccttatggcagcg
-tatacagctggtataacgaccatatacaactatgaacggactagctgtgaactaagcaga
-ttattggatccttgtgtataattttaagtttcgatctatatgctatagtatagaaaatgt
-tccgatcgtacgcttcctttacagttaaacagtctatatcatgaagcttatccaaagctg
-gacatttgatggcaatcttacttaattatgaaacttaattacctattattgaaagtattt
-atatgatcgaataagatttgctctataaacaggtcgtccattcacgacctagtgattgcg
-taaattgaccaacctaggtaatctaaagcctgcatctatttcttatcattcatgttatac
-tgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcaca
-tttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctat
-cccacgcgtcattttcaaattggttatctacggataactgtgcgatgaactactataggt
-caaaattatcttcaatctcattctagatcatataaagatgtccttcgcgattgatacgtc
-tacagtgtgttggtgttacacagagggtagcgactacttacttactaactctctcttgat
-ccgcaagcataagccaggttaaagtgctctatctttttctgtggattataatagttatac
-cgccttgcatctaggtgcccattaggtaatgccctagtgttttcataaatttactcctgc
-catctaacgttactttaatttcccagattcaataggtctctcatttgaaaattgttatat
-gtcaacaaagaatataatagctgagtggaacaatacactgtgagggagtaatacatactc
-taaattttctttacggtttgcgcctgcacagttttttttatctatgtgatccgcataaaa
-agtaatttcaacgttccattcaagttaagtcttggtgacactagcattaggagagatcac
-caagaccattatttatttagctagggtttaagtcggttagaaatatcagataatgaggtc
-tttatccggccttacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaag
-tatggccgaacccacataatgcacaaatcaagtcgatttcttccgtccttttagtctcct
-gggaactacgggttattcatagttaagctaaatcagttaacggaactagacaaatgtata
-atagttcccaaatatatatctataaatcttatgcagttagggaatgcagatttgaatcat
-ggcaatacgctagctcggaactcaactacaagtgttggatgtacgaattcaaaggtatta
-catccttatgatgttcttttttggatacttttatgacgacttccacgaagtgaaattatg
-ttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgttctgtttataat
-tctcgtcataatataaatacaagcatatgaggccagtcatggagctttcatttggactaa
-catttccgtagagtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgtt
-atcagatacatgacgcccttgcgtgacattcatggctcctgacatcgggtcttttaggct
-gaatctaatctaacccaatttgtttggattgtgggtcctccattttgtctgttaatgctt
-attaagattaaaaatgtactacgtatttagacctaatgattgcgatacgctgtggaccat
-taatataagctgcgccaggggatttttccagatcatctggcctgtgtatatgttcaaatc
-taatagccgagagaaattactccgacggaaaataaaggcagataagcgtttcagagcacc
-atcgtggcgtttagtcaacctttagttcggaatttattaatatacaatctcactctttgg
-acgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcat
-catcaaagaacagttaaggaatacgactgctctataattgtccgaggagtaccttctcat
-ctgccaatagtcgttgggttggaaaacaacgcattaatatgccacacttgtcaattagaa
-gtttctataaaggggacgagtaactgatttgagacctagcacggcagaggacgttcgtgt
-gacaacatctctttataagtttgagataaaatcgctaatctacaatgattatttgccaat
-cattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaaggccattactatgg
-tcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaaacactattgaat
-actgccgccgcattcgccagcaccaacataactgcacgtgcttttttccatgattggcat
-tatgaaagatttgatctatgattcttaccagttgcaatattcaatttagcatgtgttcct
-aattattgtgttattatggtctatctcatcatgtaaatgaagatcatgacgtcaacacag
-attctagtcaggatcatcagttcctcggggaaatcgcacctaggaacagccttatgcaac
-cgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgag
-atgtacgaatcgtttactgccttttatgaggagtcgagtactgttggttcatatttgcta
-catgattgtatgtaataacgatcccgccctttatcggttcgatcctttatggcgataagt
-tatgaatcgtcagtatctttagatcaaaaactcaactagtacccagttccccggaggaac
-ggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttc
-atccgatcccactcgatgattggtatagctatttgccgaaaagccacaacgtattcggta
-ctatcttgtttgattcccctgtatcttaattcgcgacacttgatatcttttgtgtttaat
-cgacgaatcatcctgggggcgacacttgttacaattatccagttgcgtttaatggctgtg
-ggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgca
-ggacgaatagctcacccgcctaagtgatccaaccctcatcaggataactatcactgggca
-gtattatttttgatttcatatgccaccccctaggagactgtagtcatgtatctttcttac
-ccaatctagcccgaaacaagaaagaatgtcgattccagtcaccttttattagaccgattt
-acacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacga
-cttgctctattcgattaccttcgcgatctcaatcgattacgctaaattttaatgcccgct
-gaaatatccaacatttaaaacaggattaattctctgatccatgaacttaggactcattgc
-acgtgacttatctttctctcttaattcatgctccaatacggtgggctaaaccacttttat
-cacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtc
-aatctgggtatcttctattgggacggtacatttcggttttatagactatgtagttacacg
-gcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgcc
-atgtgtccggaggattacatacatctaagaaacattctaaactatgtatagtcgtttacg
-acccttgtagtacgtgcatcccttggcgaaaagtactctgggtattagagtgtatattat
-cgacagcaccgaatcctcattttatagcttgacaatttatgacccgaaagaaccttttat
-aagtctataagtatatctaacgcaattgcggcactgagtccactaactatctttgagcag
-tgttatacagtgagacgccatggaaggggtttatatattttactgtcgttccctaaaaag
-ttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgctt
-gtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttacattccttgctta
-tttgcgataaatcgatacaaccccattaccagaaaaacccggagaatcaattactctgca
-gatcttatactaaaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgt
-ggagcgttggggtaagagcggagcgattttaactttcgcttttccattttccagtattgt
-actttacgttatatttgagcggcacattcgtcaaaacatgatccatatggactgaggtgt
-ttaaatgttaatcaaataattgtattttcagctgactttaaaatctgcagccattggagg
-tggagattccaatagatgtaagcaggtgatatcatatgcaattcttgtgacttattaaga
-taccagacacggcacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaatt
-ccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaacgtttctctgaga
-tgtataagttaccaaacactggagaattccgctaaactaaggacaatttccgtcgtatta
-attgttgacaaatggttagtaatacattcgcagtggataatccgttgcatacctagcact
-gagtgtaaataaaaccaatcgactactggcatttcgggctaacgactagatgttagccta
-tgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttcttattcgttatt
-agaagtcacctgtagagacagtagagatgacctaaatttggtttgtccagtcccgaggtg
-atctaatgattaggttaacttagaacagtggtcaattggttaaagctgatttacgaacac
-ttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtattcggtcatctag
-acaaccccatcgctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccga
-attcgaaatcctgttgctccggggagatagggttaatttaggcttttttacggtgtggca
-tattagctcaaacatcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgt
-tctgctaggaagcgatgtacaaaataagcttaataagatttaggtccgaccttaatttcg
-gtccatagcacctctttctaagtgttttgcttaaataattgtattgttattgattttctg
-cgagttgaacacggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaa
-tgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccg
-cactaaacggctttcgctgtttccaaaaaattttagtccactaggtatttaaatgttgga
-cactgaacgtggaagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgta
-ctttgagcagatgctatcgtcagaaaaaggtaaatcttttggttctttataattctggcg
-tccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaa
-ttacgtcattagctgttacgtctatacgaaatatagactgtggacgacccatcgtagagt
-catgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacaca
-gtattgtactggtcaattggttcatagatctgactatgaatcttcgtttttgtacaacaa
-tctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcc
-tgttcgaggttagtcgtataaagacgaaacggccttaatgtaacattaactattccactg
-taggtggatctaacaaggttggacatgtgctaccaataagataagaatttcgtccgcaat
-acaatatctacttttgtagcctatcttggattaacaacaacttacgttggtatttcaccg
-gacgtatcaaatgattctgattttaatgactgagagtaaacatcaacgaatcttatgtat
-ctttaagccgctgcttgacaagtcacattactgttagaatgaacgcttcattactacaaa
-acctaccaccaactcccacattaatattatactagatgtttgaagtttatttgacaaagg
-ttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttagggtattaattgt
-ggtcggtgcatttccggccccatagcgctccgcggggagaaactatggccttcatgacag
-cccccccataacatctaggtaatggtcggataactataaacaaccctctccagagaactg
-tgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaag
-actcttttcactattttcttgatgcctcattcttctaatattaggtgattttttaatccg
-agaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaa
-tgaaatactttttgactatccctcatgatctaaacttacgcggagctatctttttgtata
-acatgtacagagaattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtc
-atggcggcttatcgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacg
-ggtttcgggatttctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgc
-gcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgcct
-tctcaattgtccgaggattgctgataacttaaaataaggttgagtttttaataacgattt
-gtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacg
-ggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggta
-tttgtacaactgctttcctttatcgattgctcgagaacattataaagtctattactatgg
-attaagactgtatacaagtgtttaagcggagcccgtgataatctataaggttttggtacc
-tttatctgttacttttgccttgaaacatacatacgtacacgggaatatttacctaaacgc
-cgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgccc
-acttgcattataacccggtgcggaatctcttagtgactcgtcaggagtttacgcctttga
-gacctctcgacaggacccattttgatctagtcgttataggtagagtgcctttcctatcgc
-accattaccttctagcaaacttagagtattcaatgaaatcatatcctgtttatactaaat
-gttataggctaatgacacagctgacactaagaggtctcttcgggttacccgaatgagttg
-tttatacgatgttgacaactcgggggagtcatttcaatgaagactgaggactcttgatca
-gattaaaacgcttaatgactgataatttagattatgccgtgtattatttaagtgggcgaa
-ccctcccctagaatgggtttcctgagaaaagtcttagaacacagtattctgaatccagat
-gcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcg
-caatccgtttaaccgtctactattcctagagcgaagagctatgttctgacacgtccccaa
-tattaggcaaaggctccaaaagaacagtcaattgattaactacgggcttggtttctccgt
-gaatccttgcgccgctataccacataaaaggatagcggtgataccacaagtttgcgacgt
-taaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaattttgtccatca
-ctactgccaagagttgactggaccagttggaaatgacatttgatatattaatagagctac
-atattgtaccactttactgtcacttacactaaccctagcgtgattactcatacatatatt
-cgtaaattctaagttatgatactagttttgtaaatttaatcggcgaagacacgttctctt
-gtacgagcttcaactaaatatttcactgtagccaaccactttaaccagaaggatacctta
-atgccgatataatattgtccaggaaacgttaatactttcacaagacaaagcttggaagag
-gtactttacgatcacctgatagatcgaccggaacgattctatataggtttggtctgagaa
-atttgtagctaaaaccatgttccataggaactcctctgtaatgggcaaaatgcagatagc
-gttcaatcgttgcttaactatctatcacagcatcctaactcctcaacagcttctttccta
-aagacatcagcaggtaagttgacggcacccgataacccagagcacgattggaatctaata
-ctctgtatggatcattacgctaagtaaatataatgattttctgactcaaagttacactgc
-gaattttatattaactggttctatttgttaaataccacaacctctcgtcaacaggtcgcg
-atgcaagtgatccaaaaatatctaacttataccaaccattacttctggcgcagaaaaaca
-tagatatctgaacaatcgaccgttaagactgtctcgccgatcttaggaacctaatactgc
-tcagtagttattgtttatttgggccatccccggattatgtcagccatggaacactaaaag
-tcctaatctaacctatggacaaaaagctcacttttataaaattgctcaccttatgttgat
-tgttatttgtccgaaatgtctataactcagtgtactatctattggaaaattatggccgga
-gttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaataattatcagctg
-gaaaatcatctaatatatattatattgagatattacgacagacctaagtgctttcccgtc
-atgagcagatggactaacactcttggtaatccttctcgttttagttggtaatgtttagtc
-taagtaatatcccgactcttacttactcagagcggaaatgactttttaaactaacgttta
-aaggcacttagtatgcgtcagggttatttttttaattacgtacccttgtgcagagagttt
-agctattcgatcctacttagtatgaaccatgagagtacaggttggtaattcacagagaag
-gtcgagaagattatttttgatgtttaccaatactatgaggcgtattcatcgaaataattt
-tatggctgcgcacttcacatacgcaggaagaccactgcagcttgctagatctggatgtat
-cattgtacttctaagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatg
-gggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcat
-aagttctgtcaactataaccctggaactttaatctgttgttcgtcgaatcaaggatcaag
-aaagcttctaaaaggcccaaagcaaaacccaccactacttcagttttaaattagaatcac
-accctagggtattagataataattaaatgtcttaggaagagatatcaaaagatgcagaca
-tcctcaagtgaataagtctccggtctttcacaaacacatggttaagcgatgtggttttga
-ctagagacgttcgccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatctt
-acttcatacattgcttaaacagtacaacttatctcttatcctatagagatctcaaaagtt
-tgtatttttactggtttcaaattgagagaaaaactgcgttctccgatttctatattattg
-tttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccgactcagattcgta
-tcctatgttagaatgagtcatcaaactacggtcacgcgtacattacagagtaaactacac
-gaatgaaagagataagaagatgaaagagttaataggtctcctgttaattatgagaaccct
-aactactacggattggcctactagtgggttggaacggatataaaattcgactaagttcgc
-ggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatccacagtaatagtt
-ggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccat
-gcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgagcaaggaattgga
-ttctgtgaacggaatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagt
-aaatcaaacgccgcgcgcagacatatcttcttggcaattagtactccactaaatcaattg
-gttataaacttttagaatatctttatataagttcactacttacgctgcgggtagtatatt
-taaagtgatgtcttaggaatcttatggcggcggaataaacggcttgactatagataccct
-aattctggcataaccctgtaacgtgtgaagcatgctttaatagacgactagatcagctta
-tagaatggatatgactgccacattgaagagattaacattagcgggtataatgttacgaac
-ttgtttaacaaaatagctctaccacacacgcatagtataatataaaggtcctggagttcg
-ctacgagcctggaattgcagttcccctaccctgagtaaacaagatcagtatggacctatc
-ttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcg
-gctaacactcgctttaccaaggaacaaacaattgatggaacaggtaagcggctggattct
-atcctgaatacagcataataatatttgctttcaatatatagttatgacactcccaatatc
-actaactctttacaaatcggatatgaagagtgaattagagatggagccgatcgttccttg
-tattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcga
-gtctagaactcacgcattatgaaatcctccgagcatagagactctaaattcgccaagcaa
-taagtcccgacgcgaaggatgagaagctcattgaactgtaacatttacgtcgggctcacc
-atgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacata
-aaaggccccactttcatatggtcaaatatctatatcgtgctttggacgactcgataaact
-aaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatat
-ataacttccggacgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaa
-cggtatagctcggaactatgcagattaggcgatccttgggttgaatttttagtttccata
-gatatgagttagttttgatatggttaccatacgtccctgcattgaaacttaatctgtata
-ttgattgatccttagcaatagcggcacatttctgggcaatatgacttaattaggttacgg
-tttttactatgatggatacgttttatatgatagaataacagttgctatttaaacaggtac
-tacattcaactaatactgtttcactattgtgtccaacatagggaatatattgcctgaata
-gatgtattatcaggcatcttttacgctccaggtagaactaattaaaaatgatccttagaa
-actttcaagcaacataagctaaaagttacgccaattataagccacatcggtaggatcttc
-aggcattcccatatccttctctatcaatcccgtctgttgctaattggttatctaagcata
-tcgcggcgagcatctacgataggtataaagttgctgctatctaattcgtcataatatata
-catggaattacagattcatacgtcttcagtctcgtggtgtttctaagagcggacccaaga
-attacgtaatatctctctcgtgttacccaagaagttgacacgtgattgtcagctatcttt
-ttctggcgatgttaatagttataaacaattgcatatagctgcaaattagctaatcaaata
-ctcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagg
-gcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataa
-tatctcagggtgtaattatttctctaattggtctttacggttggaccaggcaatgggttt
-tttatctatgtgataccaattaaaagtaatttcaaagtgacattaaacttaagtattgct
-gtcaagaccattacgacacttcaccaacacatttatgtattgtgctacgcggtatggccc
-gtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaaatgccaaattta
-gtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgt
-tgtattacgtccttttactagcctgggaaataccggtgattcagagtgaacataaatctc
-tgaaagctactagacaaagctagtatagttaaaatatatatttcttttaatattaggatc
-tttgcgattgcacatttcaagcatcgcattaacctacctccgtactcttctacaacggtt
-gcatgtacgatttctatgcgatgaaatacttatgttcttagtttggggttactttgttca
-cctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaac
-gatctcgattcttaggtttataattatagtcagaagataaatacatgcatatctggacac
-tcttccacatgtcatgtcgactaactttgaactacagtcatatatagactgttatctgat
-ccgtatgtgtctattactactcttatctgagaaaggacccaatggagtcacagtaagcga
-tcatgtcatcggggctttttccctgattataagattacactattgctgtgcttggggcct
-cctactttttctatcttaatcattttgtacattaaaaagctaagaagtaggtacaactta
-tctttcccatacgagctggaccattaatttaacagccgcaaggcgagttttaatgttaat
-ctggaagggctttatgttctaagcttttagcactgagaaattaatccgtaggaaattaat
-cccacataacccggtaagagaaccttacgccccgttactaataatgttctgcgcaatgta
-ggaagtgacaagctcactcttgcgacgagctccttaatacaggccctgcgttatattcga
-ccgtacctataactagaccaccatcttaaatgtacagttatggttttcgacgcatagagt
-atgggaccacctcgaaatgctcagctgcaaattgtactgggggtggttatcaaacattta
-atatgaatctatggtaaagtactagtttatagatagccgaacactaaaggtttgcagacc
-ttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcg
-tatctacaatgatttggtgcaaatatttatcgattgcccaatcgttctactcgtactctt
-tatagcctaacgccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaa
-ttacttaaccatactcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaa
-cgggcgtttttacttgagtcccaggaggtaacattggatctatgagtcttaacagtggaa
-atatgatttttagattgtgttcagatttattgtcttattttggtctatctcatcagctat
-agctacataatgacgtcttaactgtttcgactaaccttcagatctgactaccccaaatac
-aacatagcaaaagaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagc
-tccatttaaaagaatcgaaaacagatctaccattcgtggaatcaatttttggacgagtac
-tggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttcaagcactttagcg
-gttccatccttgatggcgttaactgatgatgcgtaagtttatggtgatctaaaactctac
-tacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttaggtctccaggcact
-aggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcctatagctttttgc
-agttaagccactaagtaggcggttctatagggtttcattcaaatcgatcgtaattcccga
-ctctgcatagcgtgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagt
-ttcaacttccgtttattggctgtccctcaatagagtcgttctcagggcacgactctcgtt
-cgttattcataagtccagtttgatccacgaatacagaacacgcatatctgataataaaag
-cttaacgataactttcacgcgcatggtttatttttgatttattaggcaaccaaataccag
-aatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaagtatcgccattac
-agtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgat
-ttaataataattacggctaaacgtattgatattttccaggaactgccccatctcatgaga
-tgaccctaaattttattcacacctcatttttaattcttttatatcacgattatttatctg
-agcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaata
-tacggtgcgctaaacatattggttcaattcaatgtaagctacctcggaatttgcttgcac
-taagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccg
-ttggagtcactatggagttacaagcattataaatctaaggaaatcgcagtatcagtcctt
-accccaaagatacttcgcattccctggggtacggaccatgaaatacttctttcatacatg
-ataaacgatggagactcggttaccaccctggtagttactccatcaattggagttaactaa
-gatcgctattacaggctttattagccaatcatcacaagcctctttttagagattcacaag
-ttagcaaaccaaagttcctttgataagtctttaacgagatctatcccaattccggctagg
-agtaaaatttatatatttgagatcggggttaaagtcacacgcaatgcaaggggtttttat
-atggtaatgtccttccctaattaggtaattttcagacctccgagagagagtagatcaaca
-acgcgttatactcctaaaatgcttgtcgataacatgacactacagatcatccctggatga
-gcatcgactttcattacttgattagttcagttaattcgtttcaaaccattttcaacaaaa
-tcccccagtagatatgtatatgcacatcttagactaaataacagttttcataccctggga
-tttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactgg
-ccctgttccattgtaatcgatgggacgggacgttatattgcagacccaaagtagtaataa
-attcagccatatggacggagggggggaattgttaagaatataattcgattttcagctgaa
-tgtaaaagctccagccattcctcctccacttgacattagttcgaagaaggtctgagaatt
-ggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagtaccaagtataat
-attatgacaatagaagcttaaattcacaacgtaacatatctgttagcatgctctaataga
-ccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaat
-ctaacgtctagttcccgactatgaagtcttcacaaatggttagtaataatttcccagtgg
-agtagaagtggcataacgtgcactctctgttaataatacctttagactactcccatttcg
-ccagaacgtcttgatggtaccctatgggaaacactcacacatgcttattgcctgcaacct
-cagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggactgatgacctaat
-tttggtttctcaagtccagacgtgatattttgatgaccgtatctgacatctctgggcaat
-tcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatc
-actatcatgttttagctaagctacactaccccatcgctcgcacgtggcaaagtgtgagga
-ttccgatatcatccatgtgtacgaattcctaatactcttgctcagggcacttagggttat
-tgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtcttataatcaccgt
-aatcggtaaacagttgttatttgttctgataggtagacagctaataaagatgctgttgaa
-cagttacgtcccacctttattgccctacagtgaaactagttcttactctgttgctgtaat
-atgtctagggttattgatttgctgccacttcaaaacggaaattaagtcattaacgaaaat
-ggttccttcataggtaaagatcaatccccaattgaagccagaaattttgagatgtcgatt
-cctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgag
-tccactagcttgtttattctggctcaaggtacgtggaacacgtagtattttgatactaat
-gccagacccgctacgatccctgtactgtgagcagagccgatcctcagaaatagctaaatc
-ttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtct
-atttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatac
-tctgggcaacacacatacttctctcatgttgtttcttcggacctttcataacctttcctg
-gcacatggttagctgcacatcacaggattgtaagggtctagtggttcagtgagcggaata
-tcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatat
-tatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatg
-tatggatcttgatctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaa
-taagataagaatttactaacatttaaattttcttattgtcgagcatagattggaggaaaa
-acttatttacttggtatttaaacggaagtttctaatgtttatgattggatgcacggacag
-tttactgcttactttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgtt
-catgcttccattaagttcttcttaaacttacacaaactacctaatttagagttgacgaga
-tggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtaca
-tttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacattcacatcccaccc
-ctgaatatatggactgaatcacacacaccaaatttcatctaccttatcgtagcataacta
-ttaacaaacatatacagacttcgcggtaaataaaatatattagtacacaaccgtatactg
-gttgaactattgcccagctttaagacgcttttaactaggtgcttgatcaagaagtattat
-tatatgacggcagtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacg
-ccgtagagacatttttgttagatatgtatttctttttgacgagccagcatcttagtatct
-gaagacgagctatatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagat
-taaccaaattccccagaattagtaatggcgccttatcgatttactaacgatatataactt
-gtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattg
-aagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgat
-actacgttttgctatgtaatccattctaatgggtaagaggattcctcttatagtaaaata
-tgcttgactttttaagaaccattgggagtggttggcaaaataatagtgggtgtctttctc
-agtgtatagttttctacaactacccctattaggttacaagtaatctggctttcttgccac
-ttggcgatgatagttagattcgtatttctacaacgcagttactgtatccatggcgcgaga
-taattagatacgatttgaatttggatgtagactcgttactactgttgtagaccagcacgt
-gagtatctagatgggtttgctaccttgttagcggacttttgccgggaaaaagacatacgt
-acaaccgtatattttactataagcagtattggccaccctcgtattgcggcagggtgtgct
-cacctggttaaaatgaaagagaaaaattccattttaaaacccggaggaatctattactga
-cgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttcatattctagtta
-ttccgagagtcactttcctatccaaacatgaactgatagcataatgacaggttgaatgga
-aagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgtcacgaactcgga
-gcttacccttacaactatgtgttctgtttaccaggtgctaatatcccggcactcttttca
-tgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcatattttacagtagc
-cagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctgacataagtatta
-catatcacttgtctgattacacagcaaaatcgctaaccttactttgcgcatgtagctatt
-ggaactttgggctagtgtctatcccattaagtttaacagtagactagtccgtgagcgatc
-accgagcttatgtctcgtacccaagttttggatttggatcaaaaactactcgatattcat
-gatctacgggcttcctttctccgggtatcattgcgccgagattaaaaataaaacgatagc
-gctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacgaatagaccatcca
-atttgaattttattgggtccagcacttcgccatagtgttgaatggtaaagttcgaaagga
-aatttgttatattaattctgctacattttcgaccacttgtatctcaaggacaatatccct
-tgaggcttttagcagaaagagatgccgtaattctaagggatgataataggttgggaaatt
-taagagcagtagtaacggtcgcgggttcgaccttaaactatatatttaaatctagccaaa
-caagttaacaacaaccataaagttatgaccttattatattggcaagcttaacgttttaat
-tgctctagtaatagagtggtagaggtaagggaccatcacctgattcttcctccgcaacca
-ttatatagacgtgtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaata
-tcgaatggcaattagccacattgagttaaatagttgaggatatttcttgcacagaatcag
-atctaatctaatgattcgttactaaacacttcaccaggtatcgtgaaggctcaagattac
-ccagagaacctttgcaatataagaatatgtatgcagcattaccctaagtaattatattct
-ttttctgactcaaagtgacaagccctagtgtatattaaatcggtatatttgggaaattcc
-tcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccata
-catgaattctggccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgcc
-aagatattaggatcctattactcatatcgtgtttttctttattgccgccatccccggagt
-atctcacccatccttctcttaaaggcctaatattacctatgcaaataaacatatattgtt
-gaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgact
-atatagtgctttagtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtt
-tcttgtcctaatatttttcagatcgaatagcttctatttttgtgtttattgacatatgtc
-gaaactccttactcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtct
-cgttttacggcggaatcttgagtctaacttatatcccgtcgcttactttctaacacccct
-tatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgttattttttgaag
-taagttacattgggcagactcttgacattttcgatacgactttctttcatccatcacagg
-actcgttcgtattgatatcagaagctcgtgatgattagttgtcttctttaccaatacttt
-gaggcctattctgcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcg
-caacatgccttcatatccatcgttcattgtaattcttacacaatgaatcctaagtaatta
-catccctgcgtaaaagatggtaggggcactgaggatatattaccaagcatttagttatga
-gtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcgtaatgttatctc
-gggttccgcgaataaacgagatagattcattatatatggccctaagcaaaaacctcctcg
-tattctgttggtaattagaatcacacaatacgggttgagatattaattatttgtagtacg
-aagagatataaaaagatgaacaattactcaagtcaagatgtatacgggatttataataaa
-aatcgggtagagatctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgtt
-acatcagaaagggtaactattattaattaataaagggcttaatcactacatattagatct
-tatccgatagtcttatctattcgttgtatttttaagcggttctaattcagtcattatatc
-agtgctccgagttctttattattgttttaaggatgacaaaatgcctcttgttataacgct
-gggagaagcagactaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcg
-acgaatggacagactttactaaaccaatgaaagacagaagtagagcaaagtctgaagtgg
-tatcagcttaattatgacaacccttaatacttccctttcgccgaatactggcgtggaaag
-gttttaaaagtcgaagtagttagaggcatctctcgctcataaataggtagactactcgca
-atccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaacc
-gtccccactcgcctggggagacatgagaccacccccgtggggattattagtccgcagtaa
-tcgactcttgacaatccttttcgattatgtcatagcaatttacgacagttcagcgaagtg
-actactcggcgaaatggtattactaaagcattcgaacccacatgaatgtgattcttggca
-atttctaatccactaaagcttttccgttgaatctggttgtagatatttatataagttcac
-taattaagatcacggtagtatattgatagtgatgtctttgcaagaggttggccgaggaat
-ttacggattctctattgatacaatttgtctggcttataactcttaaggctgaaccaggcg
-tttttagacgacttgatcagctgttagaatggtttggactccctctttcatgtcagtaac
-atttcagccgttattgttacgatatgcttgaacaatattgatctaccacacacccatagt
-atattttataggtcatgctgttacctacgagcatggtattccacttcccattcaatgagt
-attcaacatcactagcctcagagatgatgacccacctctaataacgtcacgttgcggcca
-tgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcatataacatttgag
-ggtaaagctaagcggatgctttatataatcaatactcaataataagatttgattgcattt
-tagagttatgacacgacatagttcactaacgagttactattcccagatctagactgaagt
-actgatcgagacgatccttacgtcgatgatcgttagttatcgacttaggtcgggtctcta
-gcggtattggtacttaaccggacactatactaataacccatgatcaaagcataacagaat
-acagacgataatttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaa
-gctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaactggttcccggg
-agtcctggagtttcgacttacataaatggaaacaatgtattttgctaatttatctatagc
-gtcatttggaccaatacagaatattatgttgcctagtaatccactataacccgcaagtgc
-tgatagaaaatttttagacgatttataaatgccccaagtatccctcccgtgaatcctccg
-ttatactaattagtattcgttcatacgtataccgcgcatatatgaacatttggcgataag
-gcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggttaacagacgtac
-atgaagggaaactttatatctatagtgatgcttccgtagaaataccgccactggtctgcc
-aatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtat
-aacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcactattggctacaa
-aatagggaagagtttcaatcatgagagggagtatatggatgctttgtagctaaaggtaga
-acgtatgtatatgctgccgttcattcttgaaagatacataagcgataagttacgacaatt
-ataagcaacatccctaccttcgtaacgatttcactgttactgcgcttgaaatacactatg
-gggctattggcggagagaagcagatcgcgccgagcatatacgagacctataatgttgatg
-atagagaaggcgtctgaattgatacatcgaagtacactttctttcgtagtatctctcgtc
-ctctttctatctccggacacaagaattaagttatatatatagagtcttaccaatcatgtt
-gaatcctgattctcagagttctttggcgggccttgtgatgactgagaaacaatgcaatat
-tgctccaaatttcctaagcaaattctcggttatgttatgttatcagcaaagcgttacgtt
-atgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtgggaataattctt
-ttgaagacagcactccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgt
-aaccttgcacaagcaaatcggtggtgtatatatcggataacaattaatacgatgttcata
-gtgacagtatactgatcgagtcctctaaagtcaattacctcacttaacaatctcattgat
-gttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaag
-gaacatctactaatgcctttgttaggtaagatctctctgaattccttcgtgccaacttaa
-aacattatcaaaatttcttctacttggattaactacttttacgagcatggcaaattcccc
-tgtggaagacggttcattattatcggaaaccttatagaaattgcgtgttgactgaaatta
-gatttttattgtaagagttgcatctttgcgattcctctggtctagcttccaatgaacagt
-cctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggtt
-cggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagc
-aaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtag
-ttaaataaatccatatctgcaatcgattccacaggtattgtccactatctttgaactact
-ctaagagatacaagcttagctgagaccgaggtgtatatgactacgctgatatctgtaagg
-taccaatgcaggcaaagtatgcgagaagctaataccggctgtttccagctttataagatt
-aaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagttggttcattaat
-tagctaagtacgaggtacaacttatctgtcccagaacagctccacaagtttttttacagc
-cgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattagagtttacaactca
-gtattttatcagtacgttttgtttccaacattacccggtatgacaaaatgacgccacgtg
-tcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcctacacatactga
-attcaggcaatgcgttttattcgaaaggtcatataactagaaaacatgatgaattcttat
-cggatccttttactagcatagtgttggcgaacacctcgtaatgctcagcggcaaattgga
-ctgcgggtccttatcatacattttttttcaatataggcgattggtctaggttagtgattc
-cccaacacttaaggtttgctgacattcataccctcagcaacttcctctcaaaaattagag
-tgagttggtggtcttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgc
-acaaatcgttataatcgtactctgtagacaataacccattgtagtgccgattttgtgcat
-aatacaagaaggaggatataaaaatgacttttcaataatattggctattagcaacaagaa
-ggagaatcctcattaagttagcaaccgcagggggtactgcagtccaaggaggtttcattg
-gagagagcagtatgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctg
-attttcctagatagaataagctatagctacttaatcaactcttaactgtggagactatcc
-tgatgatctgaataccccatttacaaaattccatatcaatgaggctaacgcttaaatttc
-atttctccatcgtaacaaaaatcagcctttttatacaagacaaaacactgcttccattac
-gggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgc
-gtttatacttaaacaaattttgacctgacataatggagcgacttatcggatgttgccgat
-ctttagggtcatctattaagcttatacgaaaaagggacaagcacgttacgtaatctggta
-ggactgggtacctagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaa
-tacaggagtccttttcatttttcaagttaacaatataagtaggagcttagagaggcttgc
-atgaaaatcgttaggaattacagaataggcagagagtggggcgtgtagactacattcttc
-aggccccacaatatgggttataggttaaactgcactttttgcgatctcccgaaatactgt
-cgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcatccaactattcag
-ataaacaagatcgcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggc
-atgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaa
-cataattcattctttcgactggacacgctaaggtttggacaaactttgtatctatatctg
-gaggcctgtattccagcccttcttttaataagatttacggcttaaactatggatatttgc
-caggaaatgacactgctattgacaggaacataattttgattcaaacctcattgttaatta
-ttttatatctcctgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtga
-gggctcgaggaatgaatcataatagaccggcccctattaatattggttcaattctttctt
-acataacgcggaatttgattgcacgaacaccgggaacacataaccgtatagcgcccgtta
-tgctagtgcctagcgactgggaccgtggagtctatatcgtctttctaccattattaatct
-aaggatataccactttaagtcctttcaactaacataaggcgcattccatgcgctaaggac
-cttgaatttattatttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgt
-actcaataaagtgcagtttactaagagccctttttctggcttgtggagactatcataaca
-tgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacg
-agatctttccaattgccccatagcaggaatagttatatattgcagatcgcggtgtaacgc
-actccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatca
-aagcacagtgagagttgagcaaattacagttatacgacttaattcagtctccataaattg
-aaacgacacttcttaacgggaggaccagacacgttcattaagtgaggagtgcactttttg
-actttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagt
-tatttctgttttaatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccc
-tatcacacctcagagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtag
-ttggcacacccaatggacgaataaatgctgccatatccacggagggcgggattgcggttg
-attttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaat
-tactgcgtacatccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaacc
-aaattgacaacttcatagtataatttttgcacattacaagcgttaattaacaaacttact
-ttgctgttagctgcctatatttgtccgacaatataactggatatctctgcgagaactgta
-aattaacggcacttggaacataatagttcctattggtaacgacgttgtaggcggcaatta
-tccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagta
-taactttagaagactccaaggtacccagaacctcttcagcggacacgatcgctatcaatc
-aataaggattattcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagc
-ttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctgttattttcatga
-ccggataggacatctcgcggaaattcgggtaacagctgggtagatataggacctccccta
-cgtattaatgataagcctgtcataactagcttggtttaccgaagagacaataaacattcg
-agcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaacatgtactattact
-ctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgatgttgacagaatt
-atgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtctgagcattcgtac
-actgcgtattaagatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaac
-taggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaa
-ccaaattaaggctttatccaatatgggtccttaagtgctaaacatcattcacaatttcaa
-gacagattgttggtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccag
-gtacatcggtaattatatgttgactaaactaccgtgtgtattctggctctaggtacggcg
-aacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcag
-cagatcctaagtaattccgttttattgtcctgagggagtaggatcgacgaactctacaag
-tcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtc
-atctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcgatggttctttat
-gcggacctgtcatatcattgactggcacttgcttacatccaaataacacgtttgttagcg
-gatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctaca
-tgataaatgaataagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgt
-cgacgagttactactaaaggaatgtagggttctggatctatgaaaagcgacctccatata
-tatacgggcctaagcggagtaaaataagtgatcaatggactaacattgaaatgttagtat
-tgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatg
-gtttagcatgggatgcaagcactcgttaatgcttactttagttggttgcgggaacaacag
-gaggctatactaactggtagcgttcttgcttccattatgttattattataattaaaaata
-agacatatggtagagttgtagtcagggtggatcgggttgtctataacgttggaataatca
-aaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgt
-gcaccacacattcacagcacacccctcattataggcaaggaagcaaacaaaaaaaagtta
-atcgaccgtatccgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaag
-ataggactaaaattcactagtatcctggaacgaggcaacagagttatctagatggtaacg
-aggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacctctattgatata
-caagtgactttctcggtaataacgcacttcacaatgtgttgtttcttttctatgtatttt
-gcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcac
-atggtataactgcaggaggaacattatccaaattcaccacaattactaatccaccctttt
-acttttactaaagatatattaattctcatgttgtctgaattgtataacccggtaccctgg
-gagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaacacacgacttcctt
-ccgtctattcagacactcaacgagactaacttttcctaggtaatcaatgatattgggtaa
-ctcgtggcatcttatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgc
-taattaagactggctctcttgcgcaggggatacgtttattctacgtacccgatttggtta
-ctactaagcggcctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagc
-agggaagggttacagggagagacttattgagatacgattggaatttccatgtacaatcgt
-taatacgcttgtagaccagcaactcagtatagagatccgtttcctaaagggtgagcggta
-ggggcaaggcaataagaaattactaaaaccctagttgttaatataagaacgattcgaaac
-aataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaataggcattgtta
-aaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaa
-cctaaaaggggcttattctactttttccgacactcaatggacgagacaaacatgaacgga
-tagctttaggtctcgttgaatgcaaagaatagaatcgttattattaatcggtttccatta
-tctatatgcggtatagatctccgagaggaccctgtaaactagctctgcggtttaactggt
-gctaatagaccgccactatgttattgcttctagctcctagcgtcttatcatgttatacat
-taatgtcgcatattggacagtagccaggcttggatggatcgccgacaaaaagaaaagact
-ttccctgtaaggacttaactattacatataacttggatcattaatctgcaaattagagta
-acggtctttcaccagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaa
-aactagaattggcagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttg
-cataaatatcttatcgatattcaggttattaccgattccttgctaacgctagaagtcaca
-ccagagtaataataattccagacacctgtgaaataatcggtcactacggatagactagta
-acgataatacgtatagtccataaaagttgaattttaggggctaaagatattagcaatact
-ggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaa
-ttgtatcgataggaatagttacagtcacgcttgtagatgtaagagatgacgttattctta
-gggttcttaagtcggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaa
-acgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattt
-tagtggcaaccttaacggttgaattgatctactaatacaggcctacaccgaagggtacag
-ataatgattcttactaccctaacatgatagagtcctgtcctatctcataggtcgacattt
-taaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattcacttatagacttc
-aggttatttcgtgctaacattaagatagaatataatcagtcgttaagaaactattatcca
-gctttcgtcaaccataaagattaaaaactgaaacttggcaagatatgaatagctatcctg
-ctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagt
-aaagcgggagagtgcggtaattaatattaatatactattaagctacacagcaaaggctgc
-aataatgttagtaagtagaacataaaggtattctccacaagtaataaatagtgtgagcta
-attgactaacttaactctcgcgacaagtgatgtggataagatgactcatatcgtcttttt
-ctgtagtgccgacatcccacctggatcgaacaattccttctagttatcgactttgattac
-ctatcctattaaacagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctac
-catagctagagttagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatg
-agtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatccattagattaga
-tgtttgtgttttgggtctgatgtcctaactactttctcagtgaaactaatgtcatcatcc
-aagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtctataacgtatataa
-agtcgctgaatttagaacacaccttatctatgttgtaaagttactttattccaaaggacg
-tgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagata
-agaatttctttcatacttcactggaatccggcgtatggatatctctaccgcgtcatctgg
-tggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacat
-cgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtgaagtctaattat
-ttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggat
-agaggacattgcatgtacgtaggactattctccaaggggtcttctattttgttagcgaaa
-attgttacagcctaatgttagagcggcgtacgactttataccagatactttcattagata
-tgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgtt
-gtgatatgatgtttttctagttcgttctcatatatatagatcaacaatgaataatctcat
-gatctataaccgatgtatatttatattccggttgactgctccggtgcaattcactacgga
-cactaatgactaatatggcgcctttcatcagaaacgctaaatatgattaatgaattaagg
-gagtattatctaattattagagagtagcagttagtctgatattttcggtgtatgtgttag
-ccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttca
-ctttatgactctggttatatccctcggagaacaagaataagagtacgagaagttcggtca
-ttgaggatgaaatagaaccgctagacgaatggactcacgtttataaaactatgtatcaca
-gtactacagctaactctgaagtccgagaagcttttgtaggacaaaacgttataagtacct
-ttcgcagaatacggccgtgcatacctgttataaggcgtagtagggacaccatgctatccc
-tcatatagagctacactaataccattacatggtgactatcgtttacggccatcatctgta
-agcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaacccc
-gtgcggattttgagtcagaactattcgaagcttctcaatccttttccattatggcatagc
-aagtgacgactcgtcagccatgggaataatagcactaatccgattacttatgaattagaa
-cccacatgaatgtgattctgcgaattgtctaagaatctaatgattttccggtgaatatgg
-ttgttgttatttattgaacttatattattaacatcacccttcgttagtgatagtcagcta
-tttccaagaggttccccgagcatttttaccattctctagtcatacaagttggagcgcttt
-taaatctttaggctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtg
-caatccctcttgcatgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaat
-attcatagtaataactacaatacttgatttgttacgtaatgctcgtacataacacaatcg
-tattccacggaacagtaaagctctattattctgatcgagcctaagagaggatcacactac
-gctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgaccagttatagaca
-gtgtaattccatattacatgtcaggcttaagctaacccgagcctttatataagctataat
-caagaattagattggagtgcattttagacttatctatcgaaatagtgatagtaagagttt
-atatgacctgatctagactgatgttctcttccacaacagccttaaggcgtggagcctttc
-ttatactattaggtcgcgtcgagagccctattcgtaatgttaacgacactagactaatat
-acaatgagctaagaataacacaagtcacaagataatttacaaatcatatatctacagtcc
-acaaccatcactagcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgc
-aagacgcgttaactggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatat
-ggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagac
-tatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattgataaatgcccca
-acgttccatcacgtctataagccgtgttactaatgtgtattagtgcatacctattcagac
-catagttcaactgttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttc
-ttgtcttttccttaactgacctaaatgaaggcaatcggtttatctagagtcatgcttaag
-gtgaatttcagccaatgggctcccattgagctagtatggtgctttacctttgtaagtggt
-ggctttccttggtgtgctgactttaacacggcagagtgattatccgaagaatggataata
-agacgctggcaatattggctaataaagtccgatgagtttcaatcatgactgcgaggagat
-ccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcattcttgatacata
-aagatccgatatcggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatg
-tgaatgagagtgaaatacacgatggggatattgccggtgagtacaagttagaccacacat
-tagaactgacctatattcgtcatcatagagatggagtatgaattgattctgcgaagtaca
-ctggctttacgagtatctagacgccgcggtatatctcccgtcaatactatgaaggtatat
-atatagaggctgaaaattcatgttcaatcctctttctaagagtgagtgggagccccttct
-gttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtt
-tgcttagaacaaaagagttaccttagggtaggtaaatctcgattcaccgagagaagtgat
-tttggcggtgtgcgattaattcttttgatgacagatctcattattttatatagctccctc
-tttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgc
-tgaacattttatacgatgtgattactcaaaggataaggttcgaggcctctatactcatgg
-aactatcttataattataatggatcgtggctcattccacctatccaaacttctttgtgat
-ctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagct
-cgcatttcattcctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaa
-ggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttatagcaaacattatt
-caatttcagtcttgactgaaattagtttgttagtgttagaggtccatatgtcacatgcat
-atggtctagatgccattgtacagtaataccttagattagtattagcggcatgcgtacttg
-gatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgcaaataggaatact
-tacaatttttgatgacttgttagcatatcgctatcacccataaaaaacctgatacttgat
-gagcgggtgattgagactatgtactgatataattcaatagctccaatagatgaaacagct
-atgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgag
-tggaattagcggtgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacc
-cgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacgaagaatgggtag
-agagtttgaaggtgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaa
-cacctcctaatggttgtgttaaccacaaacccctgggtgaatctgattagccaacccagt
-gatctgatttcagttgtcaaatctcttttttataactaccttttgtttccataatttaac
-cggatctcataatgaacaaacgggtagaataatggtagcacatagcgagcttgtctattc
-agaaatatggcctactcagaatgtattctccaaatcagtgttatgcgaaacgtaatttta
-cgtgtaataatgatgatttcttatcggttccttgtactacaatactcttgcccaacaaat
-actaagcataacagcaaaattcgaatccccctccttttaataaatggtttttcaatatag
-ccgattcgtattcgttagtctttcaccaactattaacctggcatctaattaataaaatca
-ccaaaggactctataatatgacagtcacttcggcctcttttaagacagttgattattgca
-ggtccgcaattgatggtgacatgcacaattagttagaatccgactatggagacaattaac
-aattgtagtgcccatttggtccagttgacttcaaccacgagttataaaggtattttaatt
-tatagtcgatagtaccaacaacaagcacaatcataattatgttagaaaacccagggggta
-atgctctaaatccagctttaaggccagagtgcactatgaaatcgccattgatcattgtgt
-cattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagc
-aacgattatatctggactagatcatgatgatcggaataaaacattgaaataagtccttat
-caaggagcataaacattttatttaatttatacttcgtaaataaattcagaattttttttc
-aagacattaatctgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacg
-catgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggc
-tgccacttttagcttcttgacgatctttagcgtcatatttttagattagtcgaaaaacgg
-aaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaagagcaggacaact
-ccttgatcgggaagaactgaaatagacagctgtcattttcattggtcaacttatcaatat
-aacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcag
-gcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacg
-ggttgccagctacagatatactctaggtatatcccaaacaagagacgtcctttggctgtt
-gtaatcggtcataatacttgtcacataaacaagatcgctgaattaaacattaaacagtta
-gtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatca
-cagagcgacgtaaatttagacaaacattattatttcttgacaatggaatcgataagcgtt
-cctctaacttggtatatatatctcgaccccgggattccagccattcttgtatgaagattt
-aaccatttaactatgcatagttgaatggtaaggaaaatgatattgactgcaacagatttt
-ggatgcaaaaatatttgtgaattattggttatatactggttgtatagcacaatcattagg
-tcctagaaggcatactcaacctcagcgagagagctagcatgcataattgtaccgcccata
-ttaatattcctgaaatgatttcttacattacgcccaatttcagtcatcgaacacccccat
-caatttacccgatagagaacgtgatcatacgcaataccctatgcgaacgtccactctata
-gcgtctgtatacaatgattattcgttccatttacaacgttaagtaatttaaacttacata
-aggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgt
-ctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgta
-tccattgtggagaatatcataaattcaagatggggtgtcatgctattcggtcctaaacat
-tcttaatggctgttctattgttagtctgatttaaaatggaaccatagcacgaatagttag
-atagggctcatacccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgac
-ggaaagttttacggtttgtgatcaaagaacactcacacgtcagattattacactgatacg
-aattatttcagtcgacagtaattgaatagaaacttattaacgccagcacctgacacggta
-agtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttga
-tttctatatcaaatgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatt
-tagatcgttacgactcacgtacaagatcacacatcacacgcgttagcgaaagcggaatgg
-ctaatacagccctacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgag
-ccaacctcccccgcattgcggttcattttaaggcctgggtaacatctatcgtttagataa
-tcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcg
-ctacgtgtttctttaatcaataccatattgaaatcgtaatacgataattgttgctattga
-ctacaggttatgaaaaaacttactttgcgggtacatgcatatttttgtaccacattatta
-cgcgatatctctcagtgtactctaaattaaaccctcttcgaacattttagttcctattcg
-taaacacgtgctacgcggcaatttgccggtcgtagaatggacaactccagttcaactgca
-tgtaactcatagctcgcgttagtataaattgactagtagccatgggacaaagtaactagt
-cagcggaaaagatccctttaaagatatatgcaggttgcaagcataaagctcattgctcga
-ggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaa
-tcgaaactactctgatttgctgcacacgttaggtaatatcgcccattttcccgtataagc
-tccgtacttatacgaactacacgaccttttaagcattagccgctcatatcgtgattcgtg
-tacagatgagtctattaaaattacagacatactccatatctcgctccttgaactttgaat
-aatgcgctaacttgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggg
-gaaacgatacatgttgtcagatttatgattatctagttttagatcacgtttaccgataat
-cggctgtggtctgagcagtcctacactgagtatttacttcagcttcatatcggtccgaaa
-aaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcgg
-ttgcagggcagcaaaaggcttaaaccatttttacgatttttactatagcggtcatgaagt
-gcgaaactgcttgcaaattttctacacacattgtggctcttgtccttgaagcttatggcg
-aaaatttgaaacatagtataccagggaaagcgcgaattatttggtgactaatagtccgtg
-ggtttgagccatatacctaacgccataaactacgtggtgctttagatgcaatctaaacag
-aacagaaagcgtagcgctcatcagcacagactaactttttcagtttgagtcgccggaggg
-acttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaa
-tcttgcctaatttctactattgtcagctgtacgactgtactaagtgtatagccccaaata
-aaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttc
-atcaaattaaatcctggcttacccgattctccggaagtctgacctagagattgacgacgg
-ccgcgtattattgagacctcttcaggattaatcaataacgaagtagttgatctgtttggc
-gacgtaccttaagccgactccgctacacgagtttctactaaaccaatgtagccttatgct
-tagatgaataccgtcctaattagatattccggcataacagcagtaaattatctgttcaat
-ggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaatattaggtaagg
-ccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaa
-tttaggtgcgtgagggttaaacaccagcatattctatatgctagacgtcttccttaaagg
-atcgtagtattataattaataataagaaatatggttgacgtctagtcagcgggcatacgc
-tgctctatatactggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctc
-acgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgcc
-aagcatgcaataaaaaaaatgttaatagtacgtttacgacattttattttataataaaga
-gaaactattacacctattgatatgataggacgtaaattaacgagtagcctgcatagaggc
-aaatgaggtttctacatggtatagacctgatgctgaaacatcgatgagttttggtcccct
-cgctcgttgaaatctagtcatttactactgtctttcgagctattataccacttcactatg
-tggtgtttctttgctatgtatggggctagtcaaacatgatgactatagctacaactcaga
-gagcgggcgtgttaagagtatctcatgctagaactgcacgacgaacttgatacaaagtaa
-caacatttacgattccacaaggtgactttgaagaaacatagtttaattctctgcttcgat
-catttctataaaccggtaccatcgcagcggatagatgcataacatttctactactccagg
-catcttaaaacacacgtagtacttcactagattaagacacgataagtgtataacttggca
-gtgggaagcaaggagattggcgaactcctggcatctgttacgttttgttcaggctcggtt
-gttgataatgtccgactcctgccatattgaagactcgctcgagggagatcgggattcgtt
-gattataagtacacgtgttccgtaatactatgaggcagtgattcaaaatggcacttctga
-cttacatgactaggtattattaccacggaagcgttaaaggcacactcttatggacttaag
-attgcaagtgccttcttctagcctgaattcgcgggttcaacacaaactctctttagacat
-ccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtactaaaaaactagtt
-ggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggtta
-agcaaacacaaataggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcg
-ggaacaacggctctaagagaataacctaaatccggatgagtagactgtgtaactctctaa
-agggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgcattcaattgaatc
-gtttgtattatgagctgtacagtagctatatcagctatagttatcccagaggaacaggta
-aactagctctgagcgtgaaatccggatattagaacccctagatgggattgattctagcta
-atacaggcttatctggttttacagttatctagatgattggtaaggtgaaacgcttggtgc
-cttccaccacttaaacaaaagtattgcccgggaagctattttctaggtattataaagtcg
-agcattaatatcaatttgacagtaaaggtctttcaccagcttcatatgccatagggccca
-tactcgatttaaattgaacggtttaacgagtattggaactctcacttataactgagtagc
-tatacgaaaaatctggtccatttccagaaatttattatcgatttgctgcttagtacccag
-gaagtgataacccttgaaggcacaacactgtaataagttttcctgtcacatctgtaatat
-tcggtcactacgcattcacgactaaagataattactatactaattaaaagttcaatgtta
-gggccgaatcatagtagaaattctcgtctagcctaatcggacttacctatgggctgtgag
-gatttatcagtatgtggacaaaaatgctagagataggtatagttaaagtcaccatggtac
-atctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgggatgacaactac
-tatacgtagagccgtactcaggattagatagtgtgaaagagtcaaataaaagggttaata
-ttaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaat
-acaggccttcaccgaaccctaatgataatctgtcttaataacattaaatgattgtctccg
-ctacgagctcttagggcctcattttaaatgactaatgtccaaagaagagactttcccaat
-ttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaagatagaagattat
-caggagggaagtttctattatcaaccgttacgcaaccataaacttttaaatctcataatg
-gcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgctggggagctagat
-atcggtataccacttcggttgtggtaagcccgagtgggccgttagtaatattaatagacg
-attatccgacaatgcattcgctgaaataatcttacttaggagaaattaatgctatgagcc
-aaaactatttatgtctgtcacattattgactaaagtatctatcgacaaaactgatgtcca
-taagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatga
-attatagttatccaatttgagtaaattgcctattatacagataggcttgtttagtcagat
-aaggttccgcttgaggtgctctaacttagcgagagttagaaagcctagtgagaggcattt
-tggtgccaaactccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaag
-ttggtgaacagccttttgattagttgtttgtcttgtggctatgtgctactatataagtta
-gaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgagacggggtacgcc
-gttgaggctcgagatagtagataaactagaggaatgtagataaaacattagctagggggt
-ttagttactggattacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtc
-gcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcctatacggacttt
-gcatatctctaccgactcatctggtcgtctatgcgggtaattgtattgctccaagtggat
-gactattttggcgtcccagcacatagtaaatgtaaatccttataatagcataagcaatta
-ttagactgcgtgaagtcttagtagttctcaagctttacgttgtatgtaaataactcacgt
-aatcagccgtccccaaatcaccattgaggtcattgaatgtacggagcactattatcaatg
-cggtatgcgattttctgagcgattattgttaaagacttagcgttgagccccggaacactt
-gattacagattctttaaggagttatccaaatatcattttaaataatagtagtatcgtgct
-ttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtacttctctgatata
-tacttcaactatgaagattctattcatcgataacccaggtatatttatatgcccgttcac
-tgcgcagggcaaattatctacggacaataatgacgtagttggacccggtaagaactaacg
-cttaatatgattaaggatgtatgccagtattatcttattatgtcagagtagaagtttctc
-tgagattttccgtcgttgtggtacaccggatttggctctctttttagaactgagaactcg
-gagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccgccctcatcaact
-ataacaggacgacaagttccgtcttgctccatcatatactaccgatacaccaatcgtatc
-aagtttagtatacttgctttctctcttctacagcttactcgcttgtccgagaagcggttg
-gtgctcataaagttagtagtaaatgtacaactagtagccagtccttacctgtttttacga
-ctactacggacaccatgagatacagaagttagtgctacaattataccattacatgctcaa
-tatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctacc
-atcccgtcaatgcacaaaaacacactccccttgttgactaacatcttttacaagaggcta
-aatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcggaagaataccact
-tttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaat
-atattcatttgaccgtcattagccttcttcttaggttgtgtacggatagtaggtacataa
-accgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttttttaccaggcta
-gagtcagaaaagttggagccatgttaaatagttaccatcataaaccactgttgtctacta
-gtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactg
-ttgcgttacttaggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcc
-taatcctcggaaagtacacaagcctaggaataggaaaagtaaagctcttttattctgata
-gtgactaactcaggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatca
-tctgctggtgaccagttatagacagggtaattcaatatttaatgtctcccttaacatttc
-accagcatggattgaagatagtataaagttttacatggcagtcattgtgtcacggttcta
-tacaaattctgatagttagacggtatttgaaatgtgcttctagcatggtatcttacacaa
-ctgaatgaacgactggagccgttcgtatactatttgcgagcctcgagaccccgtttccta
-atgttaacgaatatagtataatataaattgtgatatgaataacacaagtaactacagttt
-ggacaattaattgttctaaactaaaaatcattcacttcagatggcatagagttatggcta
-ctacacatataaagcggtatgtgaaacacccgttttagccggaaaccctctactgctcgg
-gacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaa
-tagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatt
-tggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgt
-ctattactgattaactagtaagacattagtgcatctggtccactgaagcacccgcttggc
-gttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctata
-ggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggt
-tcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagac
-tctttatcccaagaatggataatatgtacatggaaagtgtccataattaagtcccttcac
-tgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgacttacttgcttttt
-gatcaacttaattatggattcataaagttcagatatcggtacaattggtgtacaatatga
-aattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatccccatttgcccg
-gtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagcattgagatccac
-gatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacgaagaggtatatat
-aacctaaatactaggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggc
-gaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggt
-cagttcaaaagtagaccggatctttgcggagaacaattcacggaacgtagcgttgggaaa
-tatcctttctaccacacatcggattttcgccctctcccattatttattgtgttctcacat
-agaattattgtttagacatccctcgttgtatggagagttgcccgagcgtaaaggcataat
-ccatataccgccgggtgagtgacctgaaattgtttttagttgggatttcgctatggatta
-gcttacacgaagagattctaatggtactataggataattataatgctgcgtggcgcagta
-caccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatt
-tgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattatatatgttgatta
-tttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgc
-ttaagtttgagagcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtgg
-ttgtcgtccataggtcactggcatatgcgattcatgacatgctaaactaagaaagtagat
-tactattaccggcatgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgccca
-tgtagccctgataataccaatacttacatttggtcagcaattctgacattatacctagca
-cccataaatttactcagacttgaggacaggctcttggagtcgatcttctgtttgtatgca
-tgtgatcatatagatgaataagcgatgcgactagttagggcatagtatagatctgtgtat
-acagttcagctgaacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaacc
-atatcgttcacacatgatatgaacccagggggaaacattgagttcagttaaattggcagc
-gaatcccccaagaagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcc
-tccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcg
-cggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatatctttggtagaac
-ttactttgctttaaatatgttaaaccgatctaataatctacaaaacggtagattttgcct
-agcacattgcgtccttctctattcagatagaggcaatactcagaaggttttatccaaagc
-actgtgttgactaacctaagttttagtctaataatcatgattgattataggtgccgtgga
-ctacatgactcgtccacaaataatacttagcagatcagcaattggccaagcacccgactt
-ttatttaatggttgtgcaatagtccagattcgtattcgggactctttcaaataatagttt
-cctggcatctaagtaagaaaagctcataaggaagcgatattatgacacgctcttccgccg
-ctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgag
-aagacgaagatcgactaaagttaaaatgctagtccacagttggtcaagttgaattcatcc
-acgagttatatagctattttaatttatagtcgagtgtacaaaaaacatccacaataagat
-ttatcttagaataacaacccccgtatcatcgaaatcctccgttatggcctgactcctcga
-gcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtg
-agatgatcagtttcattatgatgatacgattttatcgcgactagttaatcatcatagcaa
-gtaaaatttgaattatgtcattatcatgctccattaacaggttatttaattgatactgac
-gaaattttttcacaatgggttttctagaatttaatatcagtaattgaagccttcataggg
-gtcctactagtatcctacacgacgcaggtccgcagtatcctggagggacgtgttactgat
-taaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatg
-agttttacattagtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaa
-gagaatacatacaccaccacatagaattgttagcgatgatatcaaatagactcctggaag
-tgtcagggggaaactgttcaatatttcgtccacaggactgaccaggcatggaaaagactg
-acgttggaaactataccatctcacgcccgacgcttcactaattgatgatccaaaaaatat
-agcccggattcctgattagcaaagggttcacagagaaagatattatcgacgtatatccca
-aaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtga
-cctctagtatacaggttaatgttagtgatacacaatactcgtgggccatgggttctcaaa
-taaaatgtaatattgcgtcgatcactcacccacgtatttggtctaattatgttttattta
-gtgacaatccaatagataaccggtcctattaagggctatatttttagcgaccacgcgttt
-aaacaaaggattgtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaa
-atgagattctatcctaaagtttgggcttgatataagatttcggatgtatgggttttataa
-tcgttggagagctcaatcatgagctaatacatggatttcgctacctcaccgagagacctt
-gcatgaagaattctaaccaaaagtttaataggccggattggattgagttaattaagacct
-tgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaata
-ccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaat
-agttaactaatttaaaattaattaacgacatggaaatcacagaacctaatgctttgtagg
-agttatttatgctgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacg
-catcttttagttcagaaagtggtatccagggtggtcaatttaataaattcaacatcgggt
-ctcaggatattcggtcatataatttattaagggctcttcgagtcttactctgagtgaaat
-tggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcat
-tccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatataagaaaactcac
-acgtctcattattaaactgagtacaatttttgcacgagaaagtaatgcaatacaatatga
-tgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgcactggattaaaa
-tccgattatttttaaaaatattcagtgctagagcatatcaggtctacttttttatctggt
-atgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaagttataacataa
-ctcccgttagccaaagcccaatcccgattactgccctaccctaacgtctgccatctaaat
-atcgaacttgttatgatcaatgtgactacctcccaccctttccccttcatttgttccact
-ggggataagctagcgttttcagaatcaatgcaataagaatagccaattgtctcacttcat
-cagagctcttggcaattccaggcgctacgtggttctggaatatattcatttttcaaatag
-taatacgtttagtgttgctattgtctacacgtttggatattacgttatgtgagcggacat
-caatagttgtctaactctttagtaagccagagatagcactcttagcgaatggataccatc
-ttccataagtttagttaatagtccgaaacaactgcttcgagcatatttgaacctccttgt
-aggcaaatagcctcttcaaagcaatcttactaatagatagagtttgttttaagggactac
-tagaaatgggacaatcttaatagtatgacctaaactgacatttaaagatatatccaggtg
-gcaagcataaagatcattgcgccacctccaccgtgggattacttatcagtcgatatccta
-tatgctaagtttgcgacggcagaatacaaactaagctgagttgatgctaaccttacctat
-gataccccattggaccggttaacagccctacttattccaaataaaagaacttttatgctg
-tagaagctattatagtgatgcctggtaacttcagtatattaaaatgacacacatacgcca
-tatagagctcctggaactttgaataatgagcgaacttcgaagttgaagagcaagaaacca
-tatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattgatcattatcgag
-gttttcataaccttgacccattatcggctgtgcgcggacaagtacttaaatcactagttt
-cttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataagacggacgtaga
-gccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggattttaaattttgttcca
-tttttaatttagccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggc
-ctatgctactggaacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgta
-tttttgcggctagaatagtcagtcgcttggagccatataccttaccacttaaacgacgtg
-ctcctgtagttgaaatataaacagaacacaaagactaccgatcatatcaactgaagatct
-ttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccg
-caaggagtcgattgggaccctaaatcttgacgaattgctaagaggctcagagctaccact
-gtaatttctctagagcccataataaatgaacgatacatccgtaggtagcacctaagggat
-tataatggaagccaaatgcagttaataatattatatactggcgtacacgattcgacggat
-ctctcacatagtgattcacgacccccccctttgattgacacagcgtcagcattttgcaag
-aacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtat
-aatttaccatgcttccctgatgctgagtgcaatacactaagaatgagtttttaccccata
-tcaccagtatttgttctgttattgcgaagaaatggctatgctgagttggcgactaaagtc
-acccatcctttttattaggtaaccccctcccttaaactaactgatttgctggagctgccc
-tgcatacatatactttatcatttatggacgtccgtgacgcttattatccaccatagtcga
-tatgctacacggattcattaatggatcgtaggagtttaagttatatttactaagatcggt
-ctcggctactatcccgccttacccggcgctatttacggccatttttaatatattgacggt
-aattattcctatggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgt
-aaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtgatgagtaacttga
-cgaaatgttagtggttattaaagactatctattacaccttttgttttctgtcgtagtata
-ttaaagtctagaagccttacaggaaaatcagggttatacagccgatactccgcagcatga
-atcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtattta
-gaccttttatacaaagtaaatatctcggctttatgtgattgggaggggcctactcaaaca
-tgatgacttgacctaataatcactgtgcgggcgtcttatgactagctattccttgaaatc
-caccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagtta
-ctttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttactt
-ccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaac
-aaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaactactcgaagat
-gtttcgttttcttaaccataggggcttcttaatggcccactacgcacattttgttcaagc
-ccgagagggacatccccattacgggagtattactaaaactgttccgtaatacgttcagca
-agggatgaaaaaggccactgctcaagttattgacgtgggagtattacatcggaagcctga
-atcccacactatgatggtctgtacaggcctagggactgcgtctagacggtattaccggct
-tctaatcatacgatcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatt
-tatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaa
-aaacccccgcacataagccgctttagatttcacaaataccaatgcggttaaaaacatcct
-tgagtcgtacatacaccatactcgcgttaaacggatataacagaagataataaatccgga
-tgtggagtcggtgtaactatagaaagccaagtgaaataatgcttaccagtcatttagcta
-tacggctttcatttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccg
-atacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaac
-aatagatgggattcattatacataagacacgatgatctgctttttcaggttgcgagatgt
-tgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtattgacagggaacc
-tattttcgaggtattatatagtccagcttgaatatcaatttgacagttaacctagtgaaa
-atcagtaagaggaaatacgccacattctccagtgaaattctacgggttatcgtctagtcc
-aactatcaattataactcacgagatataagtaaattctcgtacttggcctgatttttatt
-atactttggatccttagtaaacaggaagggagaaaccttcaacgaaaaacactggatttt
-gttttactctcaaagctcttatatgacggaaataccctgtcaagtcttaactttattact
-agactaatgaaatgggcttggggtggccagaatcatagtacaatttagcggatacactat
-tcggactttcctatcggctgtctggttggataagtatggggactaataggctagacatac
-ctatacttaaactatacaggcgtcatctatctctgcaactttggagttccctgatgttct
-cccgccctttgggttcacatcttctataccgacacccctaataacgattagtttgtgggt
-tagagtaaattaatacggttaatattaatgtatcgttgaaaagctggtgtcgccaataag
-gtaaccggctaggcagagtatatgtcacgaagtataactaccctaatgataagctgtagg
-aataaaattaatgctgtctctaagcgaagagatatttccgactctgttttaatgacgaat
-ctcattacttctgacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacg
-catataatgaacttagaagattataacgacggaactttatatgataatccgttacgatta
-aagaatctgttaaatatcataatggcattcagttctagaccgtgcatcatggtaaactta
-ctttctctgcatggcgacatacatttcgctattcaaattcgcgtgtggttacacccactc
-gcacctttggaatattaagagaagatgatcagaaaatccattcgctcaatttttctgacg
-tacgtctaatttatcctaggagacaaatcgttttatgtctctcacatttttgaagaaagg
-ttcgagagacaatactcaggtcctgaactgctagaagatactcggtggagcgtggcaaca
-atgaaaaactcgtgacataaatgaatgatacttttccaagttcagttaagtgaatatgtt
-taacatacccggcttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctct
-tacatacactagtgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactc
-acgctatgtattgacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgt
-ccctatgtgctaatatataagttagatcgcattagatgctaatctgaatacttatagacg
-accttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagg
-gacatataaaatttgagtgcggctttagttaagggtttaattacctactcaaacatcacg
-ctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgtactaggtagtga
-ttaatgatatcctagacgcacgtgccttagatcttcagactctgatggtccgcgatcacc
-gtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaa
-tacttataatacaataaccaaggatgagaatgactcatcgcgttggagttatattgcttg
-aagttctatggaatgaaagcacgttatctgccgtcccaatatctccagtgagctaattca
-ttggacggtccactttgatcaatccccgaggagatgttcggacactttagtctgtaacac
-ttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttttccaaagttcat
-tttaaataagactacgataggcctttcctattgatataaactacccggctctgttgttcg
-tgtgagtcgtacttctctgtgtttttctgattatagcaagattcgattcttagtgtaaac
-agcgatttttatttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagt
-tgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcccacgttgatagt
-atgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgca
-tcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgatatttagcaagag
-gcgttgataaagccctcatcatctagatctcgacctcatctgccctcttgctccatcatt
-ttctacacagactactttcctatctacgttagtataattgctttctatcttagtatcatt
-tagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgta
-gcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaagaagtttgtcat
-tctattagacattgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaa
-gactgtgattaactaaaatagacaagccactatatcaactaataaaaacgcccctggtgg
-tcgaacatagttgactacaggataattaattggactggagccattacattctctacaatc
-gtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttc
-gcaggagcacattggtagttcaatagtttcatgggaacctcttgagccgtcttctgtggg
-tgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccg
-gaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgtttaagagttacc
-agcttaatccacggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgc
-attctatcgttatcctatcaacggttgccgtactgagcagccttattgtggaagagtaat
-atataaatgtagtcttgtctttacgaagcagacgtaagtaataatgacttggaataccaa
-aactaaacatagtggattatcatactcaagaactctccagataaataacagtttttacga
-tacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaacgctaattcatt
-tgttattggatccagtatcagttaaactgaatggagtgaagattgtagaatgttgttctg
-gcctcgcatggggtctaggtgatatacaatttctcatacttacacggtagtggaaatctg
-attctagcttcgtagctgactatactcaaggaaccactgctcaaggtaggagactagttc
-cgaccctacagtcaaagtggccgaagcttaaactatagactagttgttaaatgctgattt
-caagatatcatctatatacagtttggacaattatgtgtgcgaaactaaaattcatgctat
-tcagatggatttcacttatgccttagaaacagatattgcccgagctcaatcaacagtttt
-agccggaaacaatcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagat
-ttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagttt
-aaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaa
-cgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacacattagtgaatat
-cggccaatgaaccaaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcag
-gttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaacctcattgtaaca
-atagcccagcaaattctcatacgtgcctcagggtccgggcgtactcctccatggaagggc
-gcgcatctagtgttataccaactcgctttttaactactatgctgtagttctacaggcata
-gtggccagtattttctaacttctctggatagatgctctcactcctcatccatcacggctt
-cagtttacgtcttacttgcttgttcagcaacggatggaggcattaagtatcttcactgtt
-ccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactc
-attgaatactgccccagttgcaacctcacttaatctgacaaaaataatgactactctaag
-tgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtataggcatgtaact
-cgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccagg
-taattgatgcggatataagctggagatcactcacgcccacacaaggcgctgctacctctt
-tattccaatgtgtaagaatttgctaacttcatttctagaccgcagctttgcggtcataat
-ttcacggtacggacccttgggttagagacttgataacacacttcgcagtttccaccgcgc
-acatgttttagtggcttctaacatagaatttttgttgtgacataaagagtgcgtgggaga
-cttgcccgaccgttaagccataatcaattgaaagccccgtgagtcacatctaattggttg
-tactgcgcatttagctatcctttagctgactcgaagagattcgattcctaatataggtta
-attagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataact
-cgcgcttaattacttatgagtagttccaagttcgctacgttatgagagagattggaatta
-agcaaatatgttttatggtgattttgggatgagaaggactgctaagtacggctactaaac
-aaatttctaaaaccgccatctaccttatcttggagacatttaagttgtatatgtcactag
-tctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatc
-aaatgcttatctaagaaagtagtggactattacaccaagcacgaatgccagggaactgct
-ttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaattacatttggtca
-gcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttg
-ctctagatcttatctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtg
-agggcttagtatagttctctgtatacaggtcacatcaaactccccctgtcctagtacagc
-tctgagctttaattaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatc
-atgctcttctcgtatagggcaagagaagcaacaaacaactagcccgactcacgttcatcc
-gccgtatccttgttcagttcttactccgtattaggtcagcgaaatctaatcagaataatc
-ggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttat
-cggctattagatagtggggtgaaagtaattggctggaattatgttaaaacgtgatattaa
-gctaaaatacgctacttgttgccgacctaattcagtcattcgatattcagttagagccaa
-gaataacaagcttgtataaattgaacggggtgcactaaacgatgtgttactctaatattc
-agcttggagtatacctgaaggcgaattcatgtatcggccaataataagacgttgaagatc
-acaatttggactagcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagt
-acggtctctggaaaattataggttcagggaatataaggaagtaaagataattaccaagag
-atttttggtatcgctatgacccagaggtgttctaacgtctgttttgatccgcagaatttc
-tgcctcaatgcatatttgacggacttgaactagagcctctaaagttaaatggcgacgcaa
-ctgttcctaaacttcaattattactactctttttttcctagggtattgtagaggccagtg
-gacaaaataaatcaaatttaagatgtttcggacattaacatcccccgtagcatagaaatc
-atcagttatccaatctctcatcgagcttttacaatttctgctggcgctatggacagcata
-tgccgcgagacctccgcaagactcacttgatcactgtaagtatcttcattagaggttaga
-gcctatagttaagctgctgacctagtaaaattggtattttctaattttattgctcaagtt
-aaaggttagtgaagggataatgacgttatttttgaacaatgggttgtattcaattttata
-tcacgaatggaacccttcattcccggcataatactagacgacacgaacaagctccgatct
-atcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgac
-ctgatgcaacttagggtcacgatgagtttttcaggactacttattacctattaataagtt
-aacatgagccttcataccccgtaagacaatacatactccaccaattagaattctgagcca
-tcttatctttttgtatcatcgaagggtatggccgaataggttaattagttactcctaacg
-tctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtc
-tagtatgcagcatcaaaaatatagtccacggtttccggattaccaaacgcggcaaagaga
-aacattgtatcgacggagataacttaatacagaaggaaggggcatcttcgaatacggatg
-aataattctatctgtttattctgacatcttgttttcaggttaatcttacgcattcaaatg
-acgcctgccccatgcgtgcgcaattattttctaatattgacgagagcaatctcactcctt
-ttgggtctatttatgttttattgaggcacaagcctatacagaacaggtactattaaggcc
-gtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttag
-tgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgggctgcatttaag
-atggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccat
-gtagattcagatcacacactcattccttgatgttgtctaaacaaaagttgttgtggacgc
-attggagggagttaagtaacaacttgggatcgcatacttataaaaattatatgttaaact
-ttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagtcactaggtatta
-atggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaa
-gaacacttaataaggcttgcttgcacggaggtatgatgtttactgactctacaaccctaa
-ttttccagtacgtacattcattccaataggttagttctcaaagtgctatacaggctcctc
-aattgatgatatgcttcagccgctctatggatattagctcattttatttaggaagcccgc
-ttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatga
-caccgctttacatagaatttgaattaaaacgcgctctcccgttcactaccatacttggta
-ccgtgcgcatattacatatagatataggatcattttttaaagctgtactaggtttgatcg
-acaatcttatgctatactatatgatgtaaccctcataatcaataccgatcgtacgatcct
-agcataggtggcaagcgattttatgccgattattgtgttaaatagtctgtgagtgtgatt
-atcagggctacgttggtagaggggttgtatagacctcgcacacattgtgacatacttaac
-aatatacgaaaactgatataataaatccccttacccaaacaccaatcccgttgaatcaac
-taccataacgtctcccatataaattgcctacttgtttgcataaatctgaatacataacac
-cattgcaccttcttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaa
-caatagcatttgctagcaattattaacagctcttcgaattgcctccacataacgcgggag
-ggtatattttaatttggcaaatactaagtactgttggcgtcatatgctattaacggttgg
-atattaagttatgtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagag
-cactcttagagtttggatacaataggccatatgttgacttaagaggacgtaactacgccg
-tacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaatcttaagaatag
-agacacgttcgtgttagggtatactacaaatccgaaaatcttaagaggatcacctaaact
-gaaatttatacatatttcaacgtggatagatttaacataattcagccacctccaacctgg
-gagtaattttcagtagatttactagatgattagtggcccaacgcacttgactatataaga
-tctggggatcctaacctgacctatgagacaaaattggaaacgttaacagcccttatgtgt
-acaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgcgtaacttcacta
-tagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatgaatgacagtaat
-tcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaag
-ctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgag
-cacatggaagtatatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaa
-actttcgatttagtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccaga
-aatacgagtttaaatttggttacatggttaattttgaccgaagcatcgcactttatgatt
-gataattggattcaatatgtcgccctatgcgaatgcaacatgatccacaatttggctata
-agacgtttaatccgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaag
-agtcagtaacaattataagtactccgcaggtacttcaaatataaaaactaatcaaacacg
-acccatatgatcatctgaagatatttggaactttctcgacaaccaccctcgtactcaata
-cttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagattt
-gcttagtggcgatgagcgtacacgcttatttctctagtcacaattagttatctacgagac
-atcacgagggagcaaataagcgatgttatggctacacataggcacgtatgaatatgatat
-aagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgagg
-cacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggat
-caactagaagagaaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttca
-ctaagaatgtctgtgtaaccaatataacatctatttgttatctgattgcctacttatggc
-tttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtaccaactccctttaa
-attacgctgtgcaggctcatgcactgcatacatatacggtagcaggtagggacctcacgc
-acccttattataatcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggt
-gttggtatattttctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaa
-gccaattttgaatatagtcaacgtaatttttactatgggttccaccgaaacgccttgcac
-aactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaataccttcatata
-tattttttcggttgactaacgtgaactaaggttaggggttttgtatgtctatataggaaa
-cagtttcttttctgtcctactttagtaaagtcttcaagccttactccaaaatcacggtga
-ttaagccgttactcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaa
-gagtcgctgtgtattagctagggagacctttgttaaaaaggatatatcgcggcgggatgt
-gagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatctctcccccacgct
-tttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtact
-tgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagagaattgagtgtaa
-aaccgtaaagccctcacctgacttcatgtaaatggcttagaagactccatgatttaataa
-atactacgaaggaaagactggatctaaagataactctagtaaggccaactcccttcaatg
-ctgttgccagttataatccaagagctgtccttttctgaaccatagcggcttctgaagcga
-actagaagcaaagttggttctagccagacagccacataccctgtacgggtgtattactaa
-aactggtccggtattagttcaccaagggaggaattaggcaaaggatctaggtatgcaagt
-cggagtattacatccctaccctgaatccatcaataggttcctctgtactggccttcgcaa
-tgagtattcaaggttgtacagccgtataataataagatagtgactatgaacgggaagtaa
-cccgctcaccttccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaa
-tactcgaaaataaacaactggcaaattacaccgcacttaagccgcttttgatttatattt
-ttccaatgcgcttttaaaaataattcagtcctacatactaattaagacccttaaacggag
-atatcacaagttaagttttaaccatctcgactaggtggaactatagatacccaactcaat
-ttatcattacctgtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttc
-acagcgaaacttcagtgtgaacagattctgagaaatcacctaaacctattagtcagagca
-cccggttagaaccagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgag
-atccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatt
-tttaaatactaggcaaacccaacataggttagtcctatgtgatacgccacatggtatatc
-attttgtaacgttacctagggataatcaggaagtggaattacgcaaaagtagacagtgaa
-atgcttagggttatagtctagtccaaagataaaggataaagcacgtcagagaactatatt
-agccgaatgggaatcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaac
-agtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtac
-ctgtatactagttactgtattacgtgtctaatgatttcggattggggtccccagaatcag
-acgtcattgtagacgattcaagtttaccaatttaatttcccagctctccttggagaacta
-tcgccaataattgcagtcactttccttttctgaaacgataaagccgtcagagttctctgc
-aacgttggacttacctgaggttctaacccactttcggttctaatagtagttaacgacaca
-acgaataacctttactgtggggctttcacgatattttttcgcttattattaatggttacg
-tcataagctggtgtccaaattaaggttaccggcttcgcagagtagttgtatccaagtata
-acttccctaatcataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatg
-tcccactatgtggtatggacgttgctaattacttctgaagggaaattggtcattatggat
-acgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttgatccaccgttct
-ttataggataataactgacgattaaagattatggtaaatagattaagccaattctcttct
-tgtcagtgaagcatccttaactgacttgctctgcagcccctcatacatttagctattcaa
-agtaccggctcgtttcaaactctcccacctttggaagaggttgtcaacttgataagtata
-tcatttacagcattttttcggacgtacctctaatgtttcattgcagaaaattagtttttt
-ctatcgcacattttgcaagtaacgttagagacacaattatctgcgaatgaactgctagat
-ctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttga
-caagtgctggtaagtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatg
-cacggcagagtaatgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaag
-acccctccattctcgagcccactcacgatatgtagggacgacaacttgtgcggcttatga
-attgtctggactgcgggcgagggtccatatctccgaagttagaagggacatacctttaga
-tgataagatcaattcttattgacgaaattcatccacaacggggaacaacttcaccctaga
-cttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggct
-ggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggc
-tatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtgcctgtgatatta
-acaagatgatccgacgcgagcaccgtaattctaggcataaaactccagcaatttgggggc
-cgaaaacaaatgacgttagctaattaattatatgacatgatcaaaggaggtcaatcacgc
-atcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggca
-aaattgatcctgtctcctatttcatgcgtacctcctagttgataattccccgagcagtgg
-ttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgta
-tggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcagttcctattgatt
-tattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgtttatgattattg
-ctactttagatgctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaat
-tggatagaacctatagtttcaagttctgccacaaggtatcatatttacagttagtgctgg
-ttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggacc
-gagtgcgcgttcaaccctgttccagagagggtgtgatagcacatataccacgctcgtcga
-ggcgttcatgatagtttgcaagagccggtgttaaacacatattattattgttatccaact
-aatcggacctatgcataaagcattgtctaaacagaataattgcctatatacggtagtttt
-agtgatttatatcttagtatcagttagagcttcgaactcttcaggttcctcatatttaac
-gttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctat
-aaatcacagaaagatctgtctcagtatagttgaaatggtattcagctagtgacgtgtacc
-aattatcatagttcactcaagcaagacgctcattaacgaatatagacaagacactatatc
-atataataaaaaagaacatggtgctcgaacatagttgaattcaccatattgaaggggaat
-gctgacatgtaattcgctactagacgatcaattccctacttgtcaaagttgaactggtac
-gttcttggaattaaatatgattgcgctggaccaaattgcgacttcttgagtttcagggca
-aacgattgagccggaggatgtccgtctcttacctttcttgcttatgataaacgacggtcc
-ctgtacatcactgggaattctcagcaaaaataattgggtaaatcgagactcgatgtattc
-ggccacaaaggtgttagacgttaaagattattcaacggggcgataataggatcataaccg
-gtatgcaagcgcattgaaagagccatgagatccttatccgataaacgctgcacggtatgt
-gcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaagttgaagaccta
-agttataatgaagtgcaataccaaatcgattcatagtggattatcagactcaagatatct
-cctgataaattacagttgttaagatacggataaaatgagatttaagattagcagcctcta
-atctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctg
-tcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagttaatatgtagct
-tacgttctagcttgtgctaatctgagtatagattcgtagaggaatattatcaagcttcca
-cgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactat
-agtctagttgttaaatgctcagttcttgttatattcgatatactcttggctaatttatgt
-ctgagtatataaaattaatgatattaacttgcatttcacggatcccttagaaaaagattt
-tgaccgagcgcattataaacggttacaccgaatcaatagaagcatacccaatagctttct
-ttgaatttattgcctgcgcaacttggctgactctctagatccgaataattctatatggtc
-gtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgggccgataatggc
-tctttgcaaaattactcaatgatacgattgatcaaagcggtagttgctagtggtagcatg
-taagtctatcaaatgtctgattatccgaaaatcttccaaaagagtccacgtaccatatct
-atctcatagcgacgcgaggggaaccttatctaactatcattccatttaccgggtgactct
-cgatgcaggatccgattgggataaattgcccagaaatggctcattcctgactaagggtaa
-ggccgttctcagcaagggaaccccgcgaatctaggcttataccatctagattgttaacta
-cttgcctgtagttctacagccatactggacagttgtttctaaatgatcgggattcatgct
-agcactcctctgaatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatg
-gaggctgtatgtatcttaactgttacctaatatggctggtaattatcaaagtaaggacct
-taatgccatagcgctagcaatcgctttgtatactgaccatgtgccaacctctcttaatct
-gtaaaatataatgtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgt
-atcaattcctatagccagcgtactagtgacacaacaacaccgtgtgagaaaagatattag
-tccttacgtctgtctctctacagcttattgatgaggattgaacatggacatatagctccc
-cctcaaaagcagatgctacctctttattccattctcgaacatttgccgaacttaatttcg
-acaaacctgaggtcacgtcttaatttatcggtaacgtcacgtccctttgagactggataa
-atatattaccaggggccaacgagcaattgttggaggcgcttctataatacaaggtgtctt
-gtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaaccc
-ccctctctcacatcttatgcggtgtactgccctggtacatttcctgtacaggactccaac
-agtgtagattcctaagatagctgttggagttgcctcacgccagatcgaaaaactgaataa
-actagtgagctgagctgcagaaataccgcttaattacttatgactagttcaaagggacct
-acgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattttggctggactag
-cactccttacttcccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctga
-catttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatga
-ccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctggtcgttgaaacc
-aagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcat
-tagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaaaaaatattttta
-agcagtaggcacctaacccgattcctctacttagtagctttctttgattctcagaattga
-ctgcaatatcactgcacaattctgtgccattactagacttctctgtattaacgtctcatc
-ttactaacactcgcctaggacacatctgagagtgaagtatttcaatacatttactgaaat
-cttcagttctaaaatccccgaataaggctcttatcggtttggccaacacaagaaaaaaac
-ttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaataactatttcgg
-cagacaaagcttataacaagttgccggcgcgtataatatttaaaagaccccttgagctgc
-tcaattaaaacgctcacctggtataggctattagatagtgccgtcttagtaaggggcggg
-aattatcggataaactgatattttgataaaataaccgacttgttcacgacataagtcact
-aaggagattttatctttctccaaagtatatcttccttggataatttcaaagcgctgcaat
-ttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgtagtaatctagag
-gcaaattataagaagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccg
-gcgcattgtgtaaactggacgagtaccctagatggaaaattatacgttaagccaagattt
-cgatgtaatgataattacctacacatttttgctatccataggaacaagagctgttctata
-ggctcgtggcatacgaacatttgctgccgctatgaatattggaagctcttcaactacaga
-ctctattcttaattgccgtcgaaaatgggccgaatcggctattattaatactcggttttt
-ccgaggggattgttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatt
-taaatacaaccttgcagacaatgaataagggatccaatctctcatactccttttacaatt
-gctcatgcccctatgcaaaccttatgccgccacacctccgcaactctctcttctgaactg
-taagtagcttcattactggtttgagactatactgaagctgatgacattctaaaatggcta
-ttttcgaatgtgattcataatgtttatcgtttgggatggcagaatcacgttatttttgat
-atagcccgggtattctattgtatagaacgtatgctacaagtcattccccgaagaagacta
-gaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctttatttcccgata
-acctatcttccataaatagcggacagcaggatactgacgctcaacatcagtggttatggt
-ctaatttttaacttttaataaggtaacttcagcaggcatacacagtaactctttaattta
-taatcaaattagaagtctgacacttcttatatttttctatcatccaacgcgatcgcccat
-tagcttattgtgttactaataacgtatctaaaccaatccttttcaagctactgcctatat
-tgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtac
-gctttacaatacccggaaatcacaaactttgtagacaacgagtgaaatttatacactacg
-aagggccagcgtacaagacccatgaattaggcgatatgtttattctgacatattggttta
-tccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaaga
-ttcacgactgaaatataaatacgtttggctatatttatgttggagggaggcaatagcctt
-tactgttaaccgaagatttagccagtgagtgtgacactaaaacactggaataaatgcagg
-cgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatatagctctggatat
-aattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaagccggcctctca
-tattgaaggtccgaagtattccatgtacattaagatcactctctcattcatgcatcttgg
-cttaacaaatctggttgtccaagctttccaggcacgtatggtacaaattcggatcgaata
-cttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaa
-ccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagg
-gattagttatgttacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgca
-tcttttatcaagagactaacattattttcaacgacgtacatgctttacaatagggtactt
-atcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccgatatccattgga
-ccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtattgccataatgtaa
-tacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgc
-gcaacgtcaatacctttaggggtaacggccgctgatttcatatagatatacgataagttg
-gtatagctctactaggtggcatccacaatcgttgcatttactatagctggttacaatcat
-aatctataccgttccttacatactaccatagcgggatagcgtttttttgccgttgattgg
-gtttaagaggatgtcagtctcattatatccgattcggtgggagagccgttgttttcaaat
-cgcacactttgtgacataatgtacaagataacaaaactgatataagatataaactgtcaa
-tatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatttgactaattggg
-tgcagatttctcaattaataaaaaaatggcaccggatgggcttacaagccccttatcatt
-cacttgtatcatgatttccaagaacaatagaatttgctagcaagtatgaacagagattcg
-aattgcatccacagtacgccggagcgtttattttaatgtggatatgacgatgtactgttg
-gcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggag
-aaatatggtggtacaatctcagagaaagattacagtttggtttaaataggacttatcggg
-tcggaagtggaacttaataagcagtacacaattgggcaacagacgtcttgcctattacaa
-taggattacaatgcgttagatttcagacacgttcgtgtttggctattcgtcaattcccta
-aatagttagacgatcaactattatcaaagtgattctttgttcatcctccattcatgtaac
-agatggcacactacgcataacgccgaggaattttaacgagatttaagagagcagttcggg
-cacaacccacttgactttataacagctcggcagcataaacggtaatatgtgacaaatttc
-caaacgttataagaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgt
-gacgcagcaagcctaacttatctattggttttgctataaaagaacaaagttacacagaat
-cctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccgg
-cacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactccgggtatgataa
-tggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggttaggataaggatg
-agaccgaacttatttccggccataactttagattttctacctagtacacaacatcagggc
-ggacacgaaaccgccatcacatcatataccaggtttaatttgcttaatgggggaagtgtc
-aacgaaccttcgaactttagcaggcatatggccattatatatggccccagagcagaatgc
-tacagcagacaaaatttggatttatgtagtttaatacctatcaaacttggtgtgaccata
-cttgtctaacgacagtgcacaaagtgtaagttacaattattactactcagcagcttctgc
-aatgataaaatcttatcatacacgtcacatatgataatatctacttagggggaacgggct
-ccacaacctacatagtactcaatacttacactattcgacaggcacaccaaacctgtacag
-tcccaaaagattgagtcaactttgcagtactgcagatcacagtaatagcttagttagcga
-gtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgatgtgttggctaca
-aatagcaacgtatgaatttgtttgaagccacgtaaactgtacaaccttagagataagtct
-caggctactaaaaacacgttgtggcactaacaggatcatggttgattcttacttattcgg
-ctgaccggcccaataagtaaccttcaactagaacagaataatcgggagtagtttaattca
-gtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgtttt
-cttagcggattccctacttatggatttgagctcgtccacaatattcgatacaagaagttt
-gtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaaggaattaataga
-aggttgatggtaggctccgaacgctccatgattataatcaagtggactgtgcagtaaacg
-aggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagat
-aaaccatgaacagcacagtgtgaacccatggttgattttaggctaccttatttttaattt
-ccgttacacagaaacgaattccacaactaacatgccattaatttttcgatatcttataaa
-agatggtcgaaattcattcatttattttttttcggttctcgaaagtcaactaagctgtcg
-cgttttgtttctctttagaggtaaaagtggctttgatctcctacgtttggatactagtca
-accattactccatttgatccgtgagtatcacctgtctaacatccagcattatgactcctc
-ggcgaagaaaagacacacttcttagagtcgatgtgtattagctagggacacagttgttta
-atacgatagtgagcccagggagggcagtgcgtcccccagtagatttattcagctagtgta
-agtataagatatctcacccacgaggttcaagtgatatgcagtcttagaataatacttatc
-ctgaatttcgatattatgggtacttcaataatccgctagcgctactttatgtctcgttgg
-acagcaggacacatggcagtcttaaacactaaagacatcacctgaatgaatgtaatggga
-ttacaagaatcaatgaggtattatatacgacgtaggaaactctggatatatacagtaatc
-tagttacgccatcgcacttcattcctctggaaacttagaagacatcagctgtacgtggag
-gaaccagacccccgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaat
-gacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaaacccagcattta
-gcaataggagctacgtatgcaactcccacgtggtaataccttcaagctatcaatatatag
-gtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccagtataataattac
-agaggctctatgaaacccaactttccagctaaaagtcccaattaaatggttatttcgtac
-ttttaaagtcgcccgttctgttattacgcgaattgattctactccaaaattaaacacaaa
-ttatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataaggctctactaaat
-tataattaagacacttattaccagatttctctagttaagtttgaaccagctcgactaccg
-cgaaagatacattcccttctctatttttcagttcatctatgggtcagagaagcattgaat
-ttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaat
-atcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctg
-gaaggagtaagaagtatacagctgatccggtgtatccttcagtcatctgccctatactaa
-ttacacgacgcaaggaaaaataggtttattttctaggcaaacccttcataggtgactccg
-atgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggataataacgatctcc
-aatgaaccaaatgtagaatgtctattgattacccttttactattcgacttagagatagga
-gatagaacctcagtgtacttttttagccgaatgggaatctttgggaggtgaatggccata
-aggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgttcgtggaatcgat
-aacagatttgttgacccatagtaaatgtatactagtttatgttgtaagtgtagattgttt
-tccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaag
-tgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggttta
-gataaagccgtatgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcc
-cttataatagtagtttaactataaaagtatatactggtctgtcgccctttcacgatttgt
-tttaccggtttatgaagcgttacgtcattagagcggctccaatttaaggttaacggcttc
-catgtgtagttgtatacaaggataacttaaagtatctgttcagcgagctagttaagttat
-cctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttgctaatttattct
-caaggcaaattgggaattatcgatacctgtataccataaggtcgctcgatgtgatgctta
-tgtcttctggtgatcctaccttagttagtgctgattaacggaacattaatgtttatcgtt
-ttgagatttagccaattctctgattctaactcaagatgccttatctgacgtgctatgcag
-cccctaagtattttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgtt
-gtggttctctactggttaactatataatttacagctttgttgagctagttcctctttggt
-ttaagtcctcaatattagttggttcgagcgataagttggctagttaccttagtcactata
-ttagatccgaatgttatgcttcatctgaagaccgccaccctccaaaatttcttttaagac
-tcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacg
-agtttccatattttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtc
-gctctacaaggggacgcaattaagaaacagacatgctagtcaaaaataaacatagcgagg
-caccactaattcggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagt
-agttagttcggacatacatttacttcagatgatcaattagttttctacaaatgcttactc
-taccccgaaaaaagtcaccagactcttacgtctctttagtatccttccgtcttatataag
-gtcagtcccccgtttcggtaccctggaatttactaagaataatgaaacagcccccaagga
-cgtacgtttacaaatgatagaccagatcgcctagcttattccgacgcatgttgcatagaa
-ttgaaccaacggaatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgc
-agaatacgcctgatagttcggccacgaaatcatatgtcctttgagtattaagtatttgta
-atgatcaatcgagctcaagcaagcttacacttcctcggatattcagggaacttagtgcct
-ttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaatgcctacctcat
-agtgctgaattaacacagcactgcggacctaacttttcgaggtttcaagttcacgtctca
-aaacctaataggctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgta
-gtactgaccaagtgaatattctttttttctaaaagcagatctgctgccgggcactacgaa
-ggagatctctgtgtatcattattgcttcttgacatgatgactcttaaatcactgtgggtg
-tgcaaaacgatagcacaacccaattcgatagtacatattgttgatacttcgcactaaacc
-gttcatatttaaaggttgtgctccttccttcgttaaatactggtgacttggtcctatcta
-ctattagctagacctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtca
-tacatcttagacatcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaac
-aaatatgattattcttatactaatattagcaaagatgcataatgatttgtattaaatgta
-taattgaattgataagggtcttttagtcagtgatagagtagtataaggtagacattagaa
-ctcttaaccggacgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggta
-agagcggttactagtagtacctataatgcactgaatcttcggtcgaagtatagttctaat
-gctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgta
-agtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggg
-gaattaaccagattgaaggccaatcctcacatgtaatgagataatagacgataaatgaaa
-ttcttgtaatagttgaactgctacgtgatgggtattatatatgattgagatcctccaatt
-gccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgt
-cgtccgtatcataaacgacgcgacatgtacagcactccgaagtataagcaataataatgc
-gggtaatccagactagatcttttcggactcaatgcggtttcacggtaaacatgattaata
-ccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgtt
-gcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgac
-gaggcgcgggaacttcaagaactatcgtatattcaagtccattaccttttagtttcagac
-tggtggagctgactaaagttatatcatcattttgtacactggtttagttaacgataattt
-cagatttaacatgaccagacgataatcgctgtatatccagttggaatgtggtttgccaga
-aaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcg
-ctatacctcagtgtatttggagctgtagttataccgtgtgctaagatcagtagacatgac
-gagagcaatattatctaccttacaagcatcaacggacgtctagtcggaacaaaagactct
-aaaactcgaacttcaggttaatatactatagttctgtattcagcagttattcttatattc
-gatattatcttgcctattggatgtctgactttagtatattaatcatagtatctgccatgt
-aaaggtgccagtactaaatctgtttcacagtgcgaattataaacggttacaaccattaaa
-gacaacaagaccctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgat
-acatcccaattagtctatagggtcgggacgattctacggcatttctggttataatgacaa
-catggattgtggcccgagaatcgctctttcattaattaagcaatcattacagtcttataa
-gcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgagccgaatagctta
-aaaaacaggccaccgaacattgatagagaataccgaccacagcgcaacctttgattactt
-tcattaaattgtacggctcactcgacatcaagcttaagattgcgataatgtgaactcaaa
-tggatcagtactgaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgc
-tgttacaatatacagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttgg
-ttagaaatgatagccattcatgatagaaataagctgaatgataccagtatctttaactat
-gtagtcagggggaagataacgatggtccatgtatgtttctgatatgtgacagtattggcc
-gcgtaatttgctaacgaagctacttaatgcctttgagcttcatatagatttctttaatca
-aaatcggcaaaaagatagtatgagctataatatatgctagtagagaactctggaccatca
-tctatatgaatactgattcgagcgtgcaattactttagcctgcgtactactgactctaca
-aaacactctgagataagtttgtagtcagtaagtcgctctctataaaccttttggatgacc
-attgtacagccacttatagatcccaataaatagcacaggagacagagtttttcaatgctc
-gatcatttgccgatagtattttcgtctaacctcagggcacctattatttgatacctaacc
-taacggccctttcacaatggagaaatatatgacatcgggacaaacacaaatggtgggtgg
-ccaggagatatgacatggtggcgtctctaagaaacacggactccctctaggcaaactcac
-gtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggt
-acattgactggtcaggaatacatcactgtagttgccgtagtgtcctgttggtgttccatc
-aagacacatcgtataacgcaatttacgacggacatcagatcaagttatacagattattta
-agtatcacgtgtgcattgggacataagggatctcacacatgccttggaacatttttgctt
-tgtgccgctttttcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaa
-cagaatgagaaaggttagggctctaagttatcgtcgattgggatagacgagacatttgcg
-agcgccctccacggatacgaatctcccatatcaatgtgaactggatgctatgcagtttag
-ttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacc
-taatacacaaaaccgtcaaacattttctaattctaggtatgggccgatcataggagctaa
-ggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgcatatactgagta
-gctggcgtgcattctctcaattgtatcctttttaactgaactagtcggtcccatttcgtg
-actgagatctattaaccgataagattaataacactcgcattcgtatcagctcagagtgaa
-gtttttcaataatttgactgatatattaacttctaaaataaccctttaagcctcggatcc
-gtttcccaatcacatcaaaaattcttattccaactatctacggattaacaacgtgcatgg
-ggatcgtagtaagaacttgttccgatcactttgagtatatcaagttgacggcccggttat
-tattgaatagaaacattcacctgctaaattaaataccgcacatcggatacccgatttcag
-agggccgtcttactaagggcaggctttgttcggtttaactgagatgttcattattttaca
-gtatgcttcaactaatatgtaacgaaggacagtggatctgtctccatagtagatcttcag
-tcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtg
-aaagcaacccctagtattctagacgaaaattttttctagttcatctgataatttgccaat
-tcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcgaacctagagcca
-ttatttgtcggtaacccatgagttccttcttttcagaagttaatacactgtggtcctata
-cagaggaaaaacagcggttatatacgatcgtggcataacaacattggatcaagatagcaa
-tttggctacctattctaattctcactagattcggtattccactacaatatcggcagatta
-ggattggatgaataatcggtgtttaagtccggttgcgtctccaatctcctaatttttatt
-aatattgatcttggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaa
-agatagaagactcatttgaaaatggatcatccacagatccaaacattagcaagacactaa
-tccccaactagctattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgtt
-catgatctaattctttttgggctttgttcgatggtgattcagaatctttatccggtcgct
-tccctgtagctactttgtggggatattgcccggggattatagggttgagatcgtttccta
-aaagtatttaaaccaagtagacttcaactaaactacatcagaacatcgtgaagacaccat
-acgcggtacctttatttaccgataacatttcttcaagaaataccggtaagcagcataatg
-accctaaacagctcggggtatcgtcgtagttttaaattttatttaggttactgctcaagg
-aataaaaactaactatttaatttataataatattacaaggctcacactgattagatttgt
-ctataagacttcgcgatcccccattaccggattgtcttaagaataaactagataaaccat
-gcattttctagataaggcctttagtctaattagatacaaaaaacacgatagttgcatcct
-taatttattgtgtcaaacctggaaccttttaattacccgcaaatcactttatgtcgagac
-tacctctgaaatttattatctacctaccgcatgaggacttgaaccatcttgtaggagtta
-tgtttattagctaagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaa
-gcactcagaattgtttttagttgagtcaagactgatatataaataagtttccctagtttt
-ttcgtggtgggacgatattgaattgaatcttaaccgaagagtttcccactctgtcgcaca
-ataatacacgccaatatttccagccctgcttatgccttaatcggttactcaatctcccat
-tgaagttcattttgatctgcatagaagtttcgggcccagccttttttctgccaccttcct
-ccaagctctgtagacgcactctaagattgatgctcacatgtattaattctacattaacat
-aaatatataagtcatgcatcttcgagtaaaatatctggttctccaacatgtcctggcacg
-tatcgttataatgcccatacatgtagtattaaaatgattgggttaactggatattaagat
-catcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctc
-ggaagggctattacgcttacttccgttttggtatcttaatatgactttcaaaaattaagt
-tgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaac
-tacttgctttacaataccggtcgtatatatcgccgtgaatccagaagattgtcttctttg
-gattatcaaccgagatcctgtggaccgatgttttgggaccttcacagaggactccaggta
-gagctcgcttttgcattaatctaagaattgtacctctctaaaagatctaaaacagtgaat
-gtgtatttcatggaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgag
-ttattatacatatacgagatggtggtatacatcgaattcggggcatacactatagttgca
-ttgtatttagctgctttaaataatatgatattaccttccttacataagacattaccggca
-taccctggttttcaacttgtggggctttttgacgatcgcactctcatttgatccgagtag
-ggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaatagattactttt
-cgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacga
-gaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaagga
-tgcgcggaatagaaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgc
-cgacataggatgaaatcagattccaatgcaatacacagtaacccccacccttgattgtaa
-tgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtg
-cgatcaactatgaatctcggcgagttagatggtcgtacaatctcacacatagaggtcact
-tgcctgtaatgacgaattttcggctaggtactcgaactttattagaagtaaaaatgtggg
-caaaagaaggattccattttacaagacgattacaatgagttacatgtctctcaacgtagt
-ctttccctagtagtctttgaactatttaggtactccagaaaattttagcaaagggtttct
-gtgtgaatccgccattcatgtttatgatggaacaataagaataacgccctcgtatgttat
-cgacagtgaagtcagcagttcggccaaaaacatattcaatttagtacagatccccagaag
-ttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtctaattactatact
-aacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagtgtcgttttgcta
-tatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttaggacttcggattc
-tcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcc
-tgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaacta
-ttgatagtcgggagcataaccaggtgaacgtactttgttcacgacatttattgacatgtt
-ctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggttt
-aagggccgtaatgccggtagtgtcaaacttcatgagaactttagctggcttttggccagt
-atttagggaccaagagcactagccttaagctgaatattttgccatttatctactgttata
-actttaaaacttggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaa
-ggtttactaagaacaagcgtaggaattgagtttatattatatttaaactaaaagatgata
-ttagcttctgagggcgatagggctccaaatcataaagaggaatatattattacacgatta
-gaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttggcagtactccaca
-tctcagtaatacagttgggagagtctcaaatgttgttttattactcaatgaaccaccctc
-ataatttcactgctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaa
-atcgacaaaattacagataagtagatgcataataaaaaaaactgctcgctataacacgat
-catcgtgcattcttacttaggagcatcacccgcacaataacgtaccttaaactacaacac
-tattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctct
-ctcgtaaaatgtgataatagtttgcggagaggattcaattattttccattgcacctactc
-cactagattcgataaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcgga
-accataagcaaagcatgtaagtgaaccgtcatccttccctaagaaacataaaggttttta
-ataatgtcgactgtgaactataactgcatcctttcctgacctactccggttccttgttgt
-tatttctgaacgagaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcat
-gtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaa
-attaattttgccttttattttttttcaggctcgaaattaatgatttgttttttttgacct
-tctagttacgctaatatgcggtcgcctgtggtttctattgagtcctataacgggatggga
-tctaatacgtttggttactagtaaacaaggtataaatttgataccggagtatcaactgta
-taacatcaagctttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcg
-agtacagagccactaaggggtgtattacgatagtgacaccaccgagcgcactcactcccc
-aagtagatttatgatcctacgctaagtattagatatataaccaaagaggttctagtcagt
-gcaactcttagaataataattagccggttttgcctttttaggcctaatgcaatattcagc
-tagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaa
-atataatctatgaatgttatgccagtacttgaataaatcaggttttttataagtccttgc
-atactctcgttatatactgttagagtcttaccccatagaaattctttcatctgcaaactt
-agaagaattctcagctacggggagcataaagtccccaggatgttgacaaatacaacaaat
-gtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagttttagccgaacct
-tgtacggataaatccctccattttccaatagcagatacctatcctactacctcgtggtat
-taaattaaagcttgaaatatagagctgcatagcttatccaattcccaagcacgagtctac
-cgtcgtaaccacgatttgatttacagacgctagagcaaacccatctttaaacatataagt
-aaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgt
-ttataagccataattaaaaacatatgttcaacaggttcattgatatttgtaattgcacag
-gtttttaataaggatctacgtaagtataatgaacaaactttttaccagagttatattctg
-tactttgaaaatgctcctctaccgccttagagactttcaattagattttttgcagttaat
-ctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgt
-ctgtctcataactgtaggtctaatataattttcagttttcgaacacataaccctttgaaa
-atctgctatttaatgtctcacctgcatgcactatcttctatactgctcagaacggctata
-cgtcactatgctccaagtgacgatttaaacgaagcaaggaataataggtttattttagtg
-caaaacaattaagtgcggactacgtgctctttacaataagccttgtgattgggctatagg
-ttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctttgcattacccgg
-ttactagtcgaattacagatagctgttagatactcactctaattttggacaacaatccca
-atcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaaacgattacatat
-tatagacttgttcggggtagagatatcacagttgtgcaaacattgtaaatcgatactagt
-ttatgttggtagtctagttgcttttaccattccccgaaaaacttgatctactatttcgac
-aacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgt
-ccactatatgtaagtgtagctttacataatccactatgactgagatcattacggcctagg
-aaagcagcgtagaaaaaaagggcccggatattacgactgtaactataaaactagttactg
-gtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaacgaatttcagccg
-cgaaaattgatccgttaaccagtccatctcgacttctataaaacgataaagtaaagttga
-tgttcagcctccttcttatggttgcatcgagagtacactactcagtgggaaatagatcgg
-ggttcctacttcagattgtattatctaggcaattgccgattgtgccatacctggataaaa
-taagctacctacatgtgatgcttatctattatcgtcatactaccttagggtgtcctgttg
-aacgctacattaatctttagccgtttgagatgttccaatggataggagtctaacgcatga
-tgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagac
-gttataaatagaaaaaaggtccttctggttctattctgctgaactattgaatggaaagat
-tggttgacctacgtactatttgcttgaagtcatcaatttgacggggtgagagacatatgg
-tgcatactttacggactctatattttagatcagaagcttagcagtcttctctacaccccc
-tcacgacataattgcttttaagaatctatgtttgattcctctacgggaattcggatccgt
-tcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagcatacgaacactt
-tgctaactagacgtatgtatagtagctataaatcccgacgatatttacaaaaagaaatga
-gactcaaatatatacatagcgaccctacacttattcgcaccctgatctaggcgatcctag
-cacccacacccgaaagtgagcactagtgtcttccgtattaaatttactgcagttgagatt
-ttagttgtctactaaggattactctaacccgtaataaggatcaagactcggtactagctt
-tactatcattccctatgtgttttcctaactcacaagggtacgtaccagcctatgtaatta
-caataatgataaagacacaaaggaagtaactttacaaatgagtctccagttacactagct
-tagtccctcccatcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaa
-gaacactcataacgttggagtccaagaattagactcatagggcccccaacatttaatatg
-tactgtgagtttgaaggtgttctattgttaattcctgctcttgatacatgacacgtactc
-cgtgtttaaggcttcggactgactttctttcataagttgagcaacgaaaatttcagaatc
-gataagttggattcactaactaatacggctgattgaaaactccactccggacctatatgg
-tcgacctttatacgtaaccgatataaaacttataggctggtatatcgagccttcctagcg
-caatttcggatggggtttcttctactactcaacaacggaatagtctttgtttagtaaacc
-agagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtcattatggactgg
-agcactcttaaatcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaat
-tttcttgatacgtcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaa
-atacggctgtcgtgctcagatatactattagcgactcatctcgcctaacacgcacacgta
-taaactcggaatgactgccgctcttacatattagaaatacagactacaccacggaagcat
-tgggtcattctcaaccgctgtataaaagatgattagtcttataataagattaccaaagag
-gcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtg
-aggacgagatggtactcaggacaaatattaaccggacgaagtggtttacgtcgtactttc
-actattagtagtaaatacaaggtaacaccggggaatagtactaaatataatgatatctat
-cttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgact
-tatagcatgatacaaccgattgttacttttgtctattcaaaagattgaatagttttttat
-acaaaagccgcatacttatgacggctagtatacagtttcatcccctagcatcaatgctat
-ggacagtattgaacttataggaaattcttctaatagggcaaatccgtcgtgatgcctatt
-ttttttcagtcacatcctcaaatggcactagtattgtcgggatcccattaacaggctcaa
-ccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaact
-cccatggataaccaattataaggcccgtaatcctctagacatcgtttaccaataaatccg
-ctttctccgtaatcatgttgaataccccagagtagtccagatgataaccgatgaaacaca
-agtctttctcaatgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgc
-gacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaa
-cgccttgtaattttactttaagacgcctggtgatgtagattcttagataatcagtttgtt
-atcggctgtactttaccataatttcacaggtttcaggtcaagaagattatagctgtatat
-acagttccatgctcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtc
-tttaggcgtatccaatacatgccccgataccgcagtgtatttcgacatgtaggtataccg
-tcgcatttgagctcgagtcaggacgtcagctagattagattccttaatagaatataccga
-cctctagtccgaactaaactatagataacgccaacttcaggttaattgtctagtcgtctg
-tttgcagatgggattcttagatgagtgagtatcggccatattggttcgagcactttagtt
-tttgatgcataggatatgcaatgtatagctgaaagtactttatctgtttcaaactcacat
-tgattaaaccggtaaacctttaaagactacaagaaaatattcagtgagggcaattttgtc
-aatcacaatcttccagctagagatacttcacaatttgtcttgaggctacgcaacattaga
-cggattttcgcgttttattgaaataatcgaggggcccaagagtatccatagttcattttg
-taagatttctttacaggcttattacagcttcttcagactcctacatgcttacgagttata
-tgctagcatgtgaacaatagattaatatacaggaaaacgtacattgagagagatgaccct
-acacagcgcaaccgttgagtactttcattaaagggtaacgctctcgagacagcatcctta
-agatggccttattgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaag
-aatccctacaaacacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcg
-gagtatcaatttcgccaatcttggtgagaaagcataccctttcttcagagaaagaagatc
-aatcataacactatctttaacgaggtacgcacgcgcatcattacctgcctccatggatct
-ttaggatagcggaaagtattggcagcgtattgtgatttcgttcctactttatcaatttca
-cattcatatacatgtcttttatcaaaatcgccaataagataggatgagctatattagatg
-ctagtagagttcgcgccaacatcatcgataggaatactcaggacagcgtgataggacttt
-tcaatccctaatactctctataattataactctctcttaagtttggaggcagtaacgcgc
-tctatataatcagtttgctgcaccattcttcagcctctgatacatacaaataaattccac
-agcagtaagagggtttaattgagacatcttgggaacttaggattttactctaacatcacc
-gaaacgattattggataccgtacctaaacgaactttctcaaggcagtaatataggacatc
-cgcaataacacaaatgctgcctccccaggagttatgtcttcctggaggctatatcttaca
-cccactcactataggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataa
-gagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaa
-gttctgtcctgttcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatc
-tcagcaagttataaacatgttggaagtttctagtcggaattcccaaagaacggatctatc
-taatgcattcctacatttttcctgtctgccgatggtgccatcctattcaaagaatttctt
-aaaagtagattaaatgggacttttaacaatgagtaaccttacgcctctaagggttcctcg
-agtgccatacaccagtcaggtccgagccacatacacggagaacattctaacatagcattc
-tcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaaatcatacttgca
-atcccatagcacggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttg
-gtatgggaacatcattgcagctatggtctaacgcattaatgtttgggtacatcttccatc
-atataaacaggaagagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaa
-tcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaata
-gaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatatatgatctgcttt
-aataaaactttatccataggatacgtttccaaatcaattcaataattattagtcaaaata
-gataaggatgaacaacctgaaggccgatcggacgtagaaagtggtcccatcactttgagt
-tgatattgttgaaccacacgttattatggttttcaaacagtctcaggatattgtatatac
-agataatccgataccagttgtctgacgcccctcttacgtaccccaccctttgtgacgttt
-aaagcagttgttcagtattttaaactaggcggcaactaatttggaaagaagcacagtgga
-tatgtctaaattcttgttattcaggcctgaatttaatacaccgcatagttaacttcgcgg
-tagagttgttcatcatgcctcctctaagctaccacttctatgatacaccaatagttgttc
-tacggaatctgataattggccaagtcataaacttccgctgcgttcaacccccttgctcga
-atatccaactcgaaaagacagccttttggtgtccggaacaaatcagttacttcttttctg
-atgttaattctctgtggtcagatacagaccaaaaactccgcggatttaccatcctccaag
-aacaaatttgcatcaacatagcattttggctacatattctaagtctcaatagtttaggtt
-ttcaactacattatcccaacattaggattggaggaataatagctgggtaagtccccttgc
-gtctacaatcgactattttttatgaatatgcttctgccgcacctatggttattaaaaaag
-tcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaag
-agcatataattagcaacactctaagaacattatagatatgatgatagcgatcgtcatgat
-gttatccggtcacaatagtagcttcatcagctaattcgttttgccagtggtgacttgcgc
-tggaagaatcgttatacggtcccttccctcttgatacggtgggggcttattcaaccgcgt
-ggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagtcaactatactaa
-atcacaaaatagtgatcaatacatacccgcttcatggttttaaccatttaattgattaaa
-gatattccgctaagaaccattatctacctaaactgatcgccgtatcctagtagtttgaaa
-tttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgtagaataataggtc
-ttggagctaaatgatgtgattggtagtgaagacttacccttacaactttaccggtttctc
-ggaagaatatactagagaatcaatgcatgggctacataagcactttagtctaatgagata
-aaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaacctggtaattta
-aaccatatatctttatgtcgtcaataactctcatatgttttatataacttcccaatcacg
-acttgtaactgcttgttcgactgagctgtttgagctatgaggccgggatccggttgagct
-acatctatttgctacaagaaaaatgaaagcacatttgttgggagttctggctacactcat
-agagaaataagtggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaacc
-aagtggttccaacgctcgcgctaaagaattaaagcctttatttcctccacggagtagccc
-gtaatccggttcgaaagagaccattgaagttaattttcatatccagtgaagtttaggcac
-aagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaa
-cttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcgagttaattttcg
-ccttctccaacatggcatccctacgttcgttataaggaccatacatgtaggttttaaagg
-tttgcggttaatcgatatttacatcatagaaattctatagtcaaatttacaagactctag
-atactcactcgttgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcg
-taatatgaatttcatatagtaagttcaaggcactcatacctccgtgaagagggtagatag
-actattaaagttgtttaatagtacgtattgatggaaatgacccgtaggagatttaccact
-caatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgg
-gtccttcaaacacgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccga
-gataaatgagctataacactgtatgtcttttgattgctataaaacacagaaacggatatt
-aatttaggccgtaaccaacatctgttatttgacatagaacagatggtcctttacagcgta
-ttccggccttaatattgaggtccagtgtattgtcctcctttaaagaagttgattgtaact
-gacttaaataagacatgtcacccattcactgggttgcaactgctggccctttttgtccat
-cgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcg
-ctatgaaggttattcattaattttagctgttttcttagaaaaggtaaatttaaaattgaa
-aaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgaga
-ttgtaagaaataaagccataaccagccccggaatagaaaatgttaaggaaaggcgatctt
-ctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaa
-tctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcag
-aggataacggaatgtggttccgtcccataaacgatcattctcgcccacttagtggcgcgg
-taaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggctaccttctccaa
-ctttagtacaacgaataatgtccgattaacaaggagtcaatttgtcatgaccagttcatt
-caggtacttgtatctatacggacgcgttccagagtagtatttgaaattttgaggttctac
-tgataagtttagctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaat
-aacaattaacaactcctaggtgatacactgtgaagtctgctgttccccaaattacatatg
-ctattttgttcacataccatgaagttaagctaagtgctctataatggcataaacggttat
-caaactagctcgaatttcttttattacgccggaagcggattaactgctgtagatcaaaca
-cgttaggatagtgtcgttttcatatatatctaaattcggtctaacatgcattacccatgc
-ttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaa
-agtttatctatcaccagtgatgcctcatcgtgactacccggatctttagcctttagggtc
-taaacagaactaatattactacgtgtcatactccggagcttaaccaggtgaaacttattt
-gttaaccaaatttagtgacagggtagaaatacgtatcaaattaacccagcaatacaataa
-gcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgac
-atagtgtgatgcattttgcactggattgagccacaaactcaactagcattatgctcaata
-tttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttaca
-aacgcataaatctcgaacgtaataggtttaattagaacatccgtaggatttctgtttata
-gtagatttatactaaatgttctgattagattctgacggccttacccatacaattaataaa
-gacgaatatattagttatagtttactatccaaataaattaagcgaatcgaaataaactgt
-cacgatactgggcagttatcaacttatcacttatacagttcggacactctatattggtct
-gtgagtactctatcaaactaactcataagttaactgcgcttccattaaatttcaatacgt
-tcttgtgctgtgtacaaacctataatcgaataaatgacacatatggagatgcataataaa
-aaaaacggctccatatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaa
-ataacgttcctgataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaag
-ctagcatggtatagttcttgatagcgcgtaaattctgataatactgggcggacagctgga
-aattagttgccagtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaa
-atacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgt
-ccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataactccatccttgaa
-gcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaa
-caactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtgcacggaataaca
-taacaaggaatattatttattcaaattttttgtgactgttatttgttttctgcctagaat
-gtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgag
-agtgtgtcctataacggcaggggagcgaagtagtgtcctttagactattcaaggtagaat
-tttgataacgctctataaaaggtagaaaatcatgattgagcaataagaccccaacttatc
-aaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtca
-caacaccctcccatcgcactcaaaatgtagatttatgatcagacgctaacttgttcttag
-agaaaaatacacgggatactctgtgcaacgatttcattaataaggtgcagcttgggactt
-ttttggccgtaggctttattaacattcacagtaggtagcgagacttcctatgaaccaatc
-atgccacgcgttttaacgtttcaaatataagctaggaagcgtttgccaggacttctataa
-tgcaccgttttttttagtacttccttactagccttagtttatgttagagtctttccaatt
-acaaaggattgaatagccaaaatttctacaattctcagcgaacgccagcttaatctaaac
-acgagcttcaaatattctacatatcggcaggagtcaatatataaatatgaaaatcgtacc
-atcctcgtacttttagaccaaacgtcttcggataattaaatcctttttcaattaccacag
-tacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgta
-tccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagc
-ttaccattcgttaaacagataactaaaatttaatggctgagtgacttagtgttttcgaca
-aacgtcgcggatgtagactattgtttataagcaatttttaaaaacatatgttcaaaacgg
-tatgggatatgtcgaattccacaggggtttatgtaccatagaagtatgtataaggtacta
-aaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctg
-taaattagattgggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattct
-accgactccggataacactttacgatcgcgcataactctagctcttagataagtttaact
-tgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatccatcctctatct
-tctataatcatctgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaa
-agctataattggtttattttagtccatttaaattaagtccggtataagtgctctgtacaa
-tatgcagtctcatgggcatatacgttaactaccttttgatacttcgaattggtaaaatat
-cgactatcgatttgcagtaaaaggtgtagagtccaattactctttcctgttacatacgat
-ctcttagtttggacaactagcccatgatggcgctcctctagcgcatgaacctactttata
-attacatctttatcgatgaatttttttagactgcggaggccttgagttttaacagggctg
-ctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccg
-aaaatattgatctactattgcgtcaactctattctgctaatagcgatggcaaatcacaga
-agccctcttagtgacaatagttgtcaactatatctaagtcgacctttactgtatcaacga
-tcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcga
-cggtaaatataatacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggt
-gcttcccggaacgattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgc
-gttaattcgtgttagtaaacttgatcttcagactccttcttttcgttgcagcgagactta
-aattatatctgcgaaatagtgccccgtgcatacttcagatggtaggagataccatttggc
-ccattgtgactttacgcgattaattaaccgacatacatctgttcctgagctatgatcgtc
-tgaataaattacggtctcctcttgatacctaatggtttctggagacgtttctcatgttca
-aatggatagcaggagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatg
-ggaaagtcgatttccaaaccagaagggataaagagaaataacggacttctccgtagatta
-gcctgatattttgatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatatt
-ttggacggcgggagacacatatcggccattcgttaaggtctctatattggacatcacaag
-cttagcagtatgagctactaacactcaagacattattgattttttcaagatatgtttcat
-tcctctaccgctattcccatacgttcgattcgccgggtgagcgaaaccacgggactgagg
-ttaagctaatcaataacaactcgttgcgatagagacctatgtatactagagagaattccc
-caacatttttacaaaaacaaagcagactaaaatagatacagtccctccatacaattagga
-ccaacatgttattgccgatcctagcacacacaccacaaactcagaacttctgtcttacct
-atgaaagggtctgcacttctgattgtacgtgtctaattagcattaatattaaaactaatt
-aggataaactataggtacgagctttactataagtcactaggtgttttccgatcgaaaaac
-gggaccttcaagccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgact
-aatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgc
-aagcgctctcgttatactgctcaacaaaactcataaagttggactccatcatttagaatc
-atagggaccaaaacatttatttgctactgtcactttgtaggtgttctattctgaattcct
-catattgatacatgaatcggaatacctgtggatcccttaggacgcacgtgctttctttac
-gtcagaatacatattgtcagaatcgagaagttccatgcaattaagaattcgcctctttga
-aaactcatatccccacatatagggtccaccgttattcggaaacgatataataattattcc
-agcgttgagcgtcccttaagagcgcattttcgcttggcctttcttctacgactctacaac
-gcaagtggctgtgtggagtttaccacagcgcagcaccccatagaactacctctgagagcg
-cgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagt
-catattaaaatggactgtcttaattgtcggcattaggagcaatattaactgatgagggta
-tcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagatacgattacagact
-cagatcccctaacaagcaaaacgattaaatcggaatcactccccctatgacatatttgaa
-atacacaagaaaccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgag
-tctgagaattagatgacctaactgcaagaatcatggcgagtttatctagtaggcaagtct
-gtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataacca
-agaactggtttaccgagtactttcactattaggagtaattacatgcgttcaccgcggaat
-acgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagt
-cgctaccagtaattgctgatcaattatagattcattatacagatgcttacttttctctat
-tcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgcctagtataatct
-tgcttccacttgaatcaatgcgatggacagtattctactgattgcaaagtagtctatttc
-ggcttagcagtacgcatgcctatttttttgcaggcacagaataatatgcaactaggattc
-tcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatg
-tttactacagaaagcgaatgatatcacttggagaacattttagatgcccccttttaatct
-agactgagtgtaccaatatatcaccggtctaccgaatcagcttgaataaaccactctagt
-actcatgataaccgagcatacacatgtatttctcaatgcactgaaggtgaactgtttaca
-ccataccttgcgaatcaacgtggcgacttatacttctgtctttgagtacagcacacccta
-atgaatctaagttagttgttgatacgaattgtaatttgactggatctcgcctcctcatct
-agattcttagagaagatgtttcttatagccggtactgtaactttattgatctggtttatg
-gtaatcaacattttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggt
-ttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcacagagtaagctct
-ctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgt
-tgattcagtaatacaagattacctacgcttctacgaaatatactatagatttagcctacg
-tcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggc
-aattttgctgcgagctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacg
-tctttatctctggataactcacattgagtataccggtaaaaatttattctattcatctaa
-atagtcagtgagggctagggtcgcaatcacattaggccacatacacatacttaacatgtt
-ctattgacccgacccaactttagtagcattgtagccgtttatgcaaatatgccaggcgcc
-aaacactagccagagggcattttgttacatttatttaatcgattattacacagtcggaac
-acgcctacatgcgttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaa
-acctaaagtcagagacatgacactaaaatcacattaaggtcagttagtgaaggaatggct
-aaccagctagagaatgcatcattaacaggcacttattgtcaaatattttccagatctaag
-caacatcacgttaaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattaga
-aagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcgggacttagcaga
-cactggatgcagtcatagaagatcttgcataacacgttagggttagagctacgaacgccc
-atcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgat
-ttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaatta
-acatacgttgacctatttttgttcagagttcagttagagcctaatgattcgagagcaata
-atcaggacagcctcataggaagtgtcaatcacttagaagctatattattataaatcgctc
-tttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaat
-atgatacataaaaatattttcatcaccactaagacggtggaattcagacttattggcaac
-ttaggatgggactattaaataacccataagatgttgggataaagttacgaaacgaaaggg
-atatagcctgttagataggaaatccccaataaaacatagccggcctccacagcagtgatc
-tattccgccacgcgatatctttataccacgcaatataccaataataaaggttaaatgtgg
-ttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgt
-aacctagaattatagcgtctgcaagttctctaagcttcctctgcaagatacaatatgact
-ttttagcttttttactaccaaatctcagaatcttagaaacaggttggtacgtgctactcg
-gaattcccaaagtaccctgctatatatgccattccttcattggtccgggctcaccatggg
-gccatcatagtaatagaaggtagtaaaactagttgatttccgacttttaacaatcactat
-cctgacccagatatgggttccgactggcccttactccagtaagggcagacacacagacaa
-cgagaacttgataactttgaattctcaaatcgatcattgcaacgtgacttatttactagc
-ctactcctataattcatacgtcaaatacatttcaacggaggaagataataagtaaatatt
-cactaaataatggtcgaaggagtcctttgccaacataagtccacatatgcgctatagatt
-ttttcttggggttcatattcaataagataaacagcaagagtatcacgtcagcgagtcatt
-gagatcttggctagcattgtgatagcatattctacctaaatggtagtctagcacagagtg
-gataagatatcagttagatatagacaagtactataacagatctcgcttcgttggattgta
-tggctagctttgatgatatgattttataaaaattgatccagacctgacctggccaattat
-attcattttttatgagtaaaaatagataaccatgaaaatactcaagccccttaggacgta
-caaagtggtaacataaatttcaggtgttattctgcaaccacacctgttttgggttttcaa
-aaaggctaagcagattggttttacagataatccctgaacactggtatctcccaacgatgt
-cgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaa
-tatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaacgcctctttggat
-tacacagaatagtgtactgacacgtacactgctgcagcagccatacgctaacattaaaat
-tcgttgagtctacatttgttgttattcggattatgttattgggaatagtatttttattcc
-cctgcgtgaaaccacatggatagattagcctactcctaaagactcccttttggtctacgg
-ttcaattctcttactgagtttatgttcgtaattatatcggcgcagtgaatctcctaatta
-tcaccggagttaccagacgccatgaacttatggccagaaacattgcatgtggcctacata
-ggattagtatcaagagtttacgtttgcaacgacatttgaccaacttgaccattcctgctt
-gtagaccgcgggaactcccctgcacgcgactatagaagttggtggtggatgtggcttatg
-ccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtat
-aagggctattgccagatgaaaaactgcatataaggtcaaacaatataagaacattataca
-taggatcttagcgttcctcaggatggtatacgctataaagtctagcttcagcagctaagg
-agttttgccagtgcggacttccgctggaagattaggtttaaccgccctgacatcttcata
-aggtcgggcctgattcaaacccctggagtgccgtctcatacttgaattaatcgatggaaa
-acttcttctagtctaatattattattaacaaatgacggttcaataaataacaccgtaagg
-gtgggaaactgttaagtgatgaatcattttaacctatcatccattagctacagataatga
-taccccgatccgactagggggtaagtggttgttccgttaggataaaccatgtaaaacgtt
-agagggtttgtagattaattggtattccagataaatgaggtcagggcgagtgatcaatta
-cactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaatgaaggggattca
-gaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtc
-gattaaagcctaaatggtaatttaaaccattgatatttatcgagtctataaatatctttg
-gttgtatattacttcacaatcaccaattctaaatgattcttccactgtgcgggtggagat
-atcaggacgggttaaggttgacctacatcgttttgatacaacaaaaatcaaagcacatgg
-ctggggacttctcgatactatctttgagatagtacgggcaagagtgggtgacgcctccct
-acattttcaagtctatcggataacttctcggtaaaacgctcgcgatatagttttaaagca
-ttgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtg
-tcatatccagtcatggttagccaaaagcatgggttatccaaaaggaataaaacagctctt
-caacaaagagatgaggcttcataacttcgatgaatgcgtatggttctgatatatagatcg
-atgcatgaggacactttattttagccggcgaattaatggaatccatacgttacttatttg
-gacatgacttctaggtgtttttgctgtcccgtttagcgatatttacagattagtatttcg
-tttctcatagttaattgtatctagatactaactcgttgaagacgcataccttgccatttg
-tacaggacttaactgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaa
-tacctcactcatgaccgttcatactctagttaaggtcgggaatactacgtatgcagggaa
-ttgtaacctaggagatttacaactctttaaacaagagtcgctgaggtccaggatcaaaac
-actgaatctcctaacttcgggtgcctccgtaaatcacctagaaacctactcatacatttg
-caattttgagatgtaggcgaaagagagaaatctgctttttaacggtatctcttgggattc
-cttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgt
-gtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcat
-caggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtg
-aaaatgctccccagggttctacagacatagagatggtcagaacacgacccccctctcaac
-gcagtgtatttgaaatatatggacatatctaccttattctgtaattttagatgtgttctg
-tgtataccgatattgataagtcaataggcttgattacgtatcttaagacaaatctgtttc
-gcaagtaggaccgcatctttcagattgtttctttttatgccataacctgcccaggaattc
-aaaaggttatcgatacccgatatgctgtgaattattattctaatggccactcattcctgc
-ttatatctggaattggcatgaatatcttacaacctaaagtctggcgttgcgccagttcta
-cttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttc
-attagaccacactttgtgccgacgtatatagatatattacacgtatagggaatgttttct
-cctaggtgacccgaccttctactaaggttgtacatcgtataatggcccattaactacgag
-gaaagtggtattgacctggtaatgcacgttcttcgatatataccgacgaggtaaagtcta
-ctattgcaaagtttgacgttatactgataagtttagatttccctggatcgcgcatgaaca
-atgtatgcgttatctgccatatataacatgttacaaatccttggggatactatcgctact
-atcatcggaccaaaattaaataggctagtgtcttatcagaacatcatgtttaccgaactg
-atctattttccaatttaagctgatattacgtccgcgtatttattttagttccccggatga
-cgattatctgagctacatcatacaagttagcatactcgccggtgcattgatttcttattt
-cgctatatcttcaagttcacaggcttcatatagttccaattagcagtataattaggtttt
-gtaactttaaccatactttataaaaggttatattgcacaactgatcaagcatccgctata
-acccgagctttaccagttagcggctaataacaaataagatgacttcgtgtcatacgaccg
-tcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtat
-aaaatgataccacatatactataacaatgaaattatttgtaatccggtttgccaacgtat
-cccccttcgcgataaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaa
-tctcaaattcaattatcatcaatattggccaagtgttataagcgttgaaagtgatatagg
-ccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttattgctggtagtaca
-acatcacgagcatttctcttttgagttgatttatactatatctgctgatgtgattatgtc
-ccacttacccagaatattaagaaagtcctagattgtaggtatacttgactataaatataa
-tttaagactatacaaataatctggctacattatgccatcgtagaaactgataacgtagta
-acgtcggacactagattttggtcggggagtaatctagcatactaacgaatttgttaaatc
-cgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgtttagactattaagg
-actcatttcgagatccagtattaattatacgcatccatatttatactgaagacggattga
-gttaggacgacaagctaaacaaatattaagttaaggattagtattatattgtagaaactc
-gtcgggttggaacgattcatcatcatagaatgcgttacttattcagagagacttaattcg
-gttatgactggcagctcacctggaaagtaggtgaaaggcaacagaagaatattgttgact
-gaattctacgggctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaata
-caatggatctctacagtattacgtaaataacatacataaacctggtgttgattcgactag
-ctcatagattaatcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaac
-agtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaac
-gtgggggtagtcaaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaa
-tgtgatgtgttttatccagacattggatgcatggctgtgggggcacaggatacttaccat
-tagttcacctacaagcggcgtgagagggtctcagttttagccagcgcagagaagtacggg
-cctttagacgattaatgctagaattgtcataaacctcgtgaaaagctagttaataatcat
-ggtgctagaagaacacaacttttctataaaccagttctcgactgacagtcgtaactcact
-atatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtg
-catcagtagagatcgtgttctgagagataaatacaccggatacgatctgcatcgagttca
-tgtattaggtcaagcttgggactgttgtgccagtagcattttttaacagtcaaagtaggg
-tgagacacgtcatatcataatatatgccatcgaggtttaaagtttatatgataagctagc
-atgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcctttatagactga
-gtgtatcgtacactcggtacaattacaaaggatggaagagcaaataggtcttcaattata
-acagtaccccaccttaatctaaaaaccagcttcaattagtattaatttcgccaggagtat
-atatataaatatctaaagactaaaagactcgtacttttacaacttacgtcgtagcataat
-taaatcatgggtaaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacag
-tgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgattaaggcctataaaa
-ctgttgttggtatctacagagtgattaaaattagtgaatcagattacgaaaatgttttcc
-cgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattt
-tggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttc
-catagaactatgtagttggttataaaggttgtaatctcggagattaggttagggcttaat
-cagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaact
-cttaatgccatgcctggacaggataaacaatacgcatataacttgacgatcgagcttata
-tcgacctatttgagaagtttaacgggtcgatataatatacaggtcttaatagccgatttt
-ttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtgaacgatatatcag
-caaactgaacattgtatacaacattcctttttgtccgggtggggactccatttaaagtat
-ctcacctagaactcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgt
-tgatacttagaattgctaaattttagtctagacatttccaggtaaaccggtagacgacaa
-tttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctac
-tatagacaatcatcagactttttaattaaatagttttccatgaatgtgttgtcaaggcgg
-accccttcacttttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttc
-gagtcttcaggggaaatggaaaagaaattaggcttctaagatggactataatcgattagg
-ctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcga
-acgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacctatcatcacgac
-ttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaag
-ggatactgggcggggaaacctgctccttcacggtaacatggtaacaacagaatttggtta
-aggttaaaacgaaatatactcggagtgaattactgttaggtttcgtcatcggatcaataa
-gtagtttccgtgaagacactcttatattagatctccgaaattctgacccgtgcattaggc
-acttggtaggagattccatttggaacttgctcaatgtaagccagtaatgttccgaaataa
-ttcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggt
-tgagggtcaccgttctctgcgtcaattccagagctggagatacattcatcaacgttacct
-acgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaacggatttagaca
-aattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcatggcggctcagta
-cgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaa
-gctatatattgtggtcagaacttgaggacaactatgagctactaaaaataaacaattttg
-tcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagc
-gtgagcgaataaacccgaatgagcgtaacattatcaataacatatagttcagatagagaa
-cgaggtattcgacagagaattacccaacattggttattaatctatgcagaataatttaga
-taatgtcactacataatattaggaccaaaaggtgattccccagaagacaaaacaataaac
-aatctcacatattcgctagtacctatgtatgggtatgatcttctgattggacggggataa
-tttccaggtatattaaaacttattaccataatctagacctaagagaggttatataagtaa
-agagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagtaaattttgcttta
-acaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcaggtgtaactacat
-gagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaactaatatcataa
-actgccactacatcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtg
-cttcctctgctatgctgatttaatcagattcataaaggaatacgaataactctggatcca
-ttaccacgcaagggatttatttacggctgattactttttggctgttgacagaactgccat
-gaaagtaagatgtcgcatcttgcataaataatagcacctaatatagccgacaaagtgatt
-ccgataacagattttaagttgtccagccttgagactccatgaagaccgcttgggagcttc
-cccgtgattagaagaatctaaatcccaagtggatggggggagtttaaatctcagcaccaa
-caaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggttt
-gaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtac
-gacaaattttaactgatgtcggtatacggagaagaaggaagcacgcattgaagcagctac
-gcagaactgagaagatgacactctaagatacaattaatacaaaaacgttttaagcccaat
-ctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtata
-ataacagctttatttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcg
-cgtctttatagtgttggctactctgtaaccgacgcgtccatccctctctcctagtgatcc
-gtatatccaattagaggataaccaacatctgcgttaccgacgaatttaaatttttcgact
-atttaattccgttcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatc
-gtgtacgagttgcagtgcatatgtagataccactaattgctgatctaggatacatgcttt
-ataaacatgcttacttggctattttatttactgtcatgtgggggtttttattttcaacaa
-gtatgtgctaccattggataatctggcttcaaattgaagatatgcgttccaaacttgtct
-actgtttgctaagtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaa
-aagaataattggcaaatacgaggctagccttcaaatttaatgcagattactcctcagaaa
-cacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgata
-atttttgttccaacctttgaatctagactgagtggaaaaagatttcaccgggataccgtt
-tatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaa
-tcatctgtacgtcaactgttttaacaataacgtcagaataaaccggcacaatgagacggc
-ggtctttcactacaccacacccttaggattataagtgacgtgtggattcgaattctaagg
-tgacgggatctacaagcctcagctacattaggtctgaagatctttcgtatagccgcgtat
-gttactgtttggatatgggttatgctaatcaacagttgacagcgagtgaaacggccttgc
-gacctgaaatctttacggttaccttttgattcaagacaggatcgacgatggaccacgtga
-aatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcaca
-tcctctatgcaactatcattgtggtcattaaggtattcaagattaactaagagtcgacca
-tatattctagagttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgc
-aggaggtgtggactgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtc
-cttagcaatgcgatacctcaatcgtagttttatcgggataaataacatggtgtttaaccc
-tattaatggtttctattaatctaaattgtaaggcagcccttgggtcgaaagcacattagg
-ccacatacacagtatgaaattgttcgagtgtccagaccataattgactaccatggtacac
-ggtgttgctattatgactcccgcaaaactcttgacagagggaattttggtacattgatgt
-aatcgatgatttaacagtaggaactagacgtcatccgttagactgagttccgacatgctc
-aaattgtcaggatttttatccaataactaatggctctcacatgtaaataaaatcacatta
-acgtcacttagtgatggattcgctaaacagatagactatcattcatgaactggcactgtt
-tcgattatatttgcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaa
-aaattcagtacacctctaatgagtatcccgctttggaggaaagagtagcactttaaatgg
-acaatttaggccggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcg
-ttagggttagtccttacatccaccatatgttaatgaataaagcctgagggaccttagagc
-taacttgtccaacacgttgctcatttacttaataaggttgaaatgtatcagtaagtgaca
-gcgagtgtagattttgaccatttaactgaccttcacagttttgtcttcagacgtcactta
-caccataatgatgacagagcttgtagatgcacacactcattcctagtgtaaatcaagtag
-tagctagattattataaagagatattttctggcgtcgaacgtaacacagagagagtataa
-ggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcg
-gtggaatgcacacttatggccaactgaccttgggacgagttaagataccataagaggttg
-cctgtaagttaagataacaaagggatattccatctttgtgtgctaagaacctatttatat
-ttgcagccataaaaacctctgtgctatgcagccaccagagttatttatacaaagaaagag
-accatttagatacgttaattctgcttgcgatttattaaacagacatttcacgtccaacca
-ctacaaaagccctatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcg
-gccgaggaatcataaaatatgaattgttacattgtttactacatatgatcacaatctttg
-taaaaggttcgttcgtgatactaccatgtacctaactaacctgagatatatgcaatgact
-tatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctgga
-tttcccaaggttataatgctctatactgaccaagagatccgttacgactcgcaatgaata
-ctctaagggcactcacaaagaaaaccactaattgataaatttcaatgataatatcctgaa
-ttgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcata
-gcaggaacataattactatattttaacgatttaatcgtagttggagtcctttcccaaatt
-atgtcatcagttccgatttagatgttttcgggcccttcttagtaaagaagttaatatcca
-agactagctcctcacccacgcatgcacatattcgcgagaagtctgatagaatattcgaca
-gaaatgcgactctagctcacactcgttaactgatcaggtacttatagacaagtacgttat
-cagatatcgcttcggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgt
-tcaagacctgaacgggaaaatgatattatttttttaggaggaataatacagtaccatgta
-aatactcaaccaccttacgtacttcttacgccgaacatatatggcacgtgttattcggct
-aacaaaactgttgtgccttttctataaggataagcagattcgttttaaacatatgacctg
-taaactgggatctacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcgg
-atctttggttaaagagcaccattagatgtgccatacttcctatcgcctgagcgagaattt
-agtctgaggaaccactcttgggatttaaaacaattcggttaggacacctactcggcggat
-gaagcaatacgataacattaaaagtcgttcagtctaattttggtcgtagtacgatgagct
-gatggccaattgtatttttattaacagcactgaaacaaaatggagactttagactaatac
-taaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtata
-gcgccgaagtgtatctcattattataacaccagtgtacagacgacatctaattatggcca
-gaaactgtcattgtgccattaagaggattagtagatagtctggaccgtggaatagaattt
-tgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgcacgagaatataca
-agttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgct
-tcttaacgcaattcagtcttctagatccgctattccaacatcaatatctcaatttaaggt
-caatatatataacaaaattagacagagcagctgacacttacgaagcatcgtagaaccgat
-atagtcgaccttatgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacg
-gtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtct
-ctgaagtcaagtattactgcgaaaaattcgtctactattagtttattatgaacttatgac
-gcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagt
-tcataatgttgctaaagattatcagaccccgtgaagacttcgggctttgggcttcgtacc
-gtagcataatacatctatatagttagaggcttgcgtgttgttgtgctattccacatatag
-cagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaa
-gtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgtatttattatact
-gtaggcaagaagcttttttggcgagatttaagacttaagcctatggtaaaaatttgatag
-tgagcgactatagtaagagatttgggtggttagtaattaaaattctcctatgctaaatca
-ggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtgga
-ttatacaaatttcaaacatattggcggggcacttatccataatagatttctgtttgtacg
-ccaaactctgcctcacccctccataaattgtattggctagaggttaaattctccgtaaat
-agagacacatatagttttatacaattgtttgaatcaaagcacgagaaacttttaaccgta
-cattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctga
-gcaataagcaagaaaacacagattatacaaagagatctggatgaagatattcgtgcaatc
-actatcgttatgttagagagttccatgcatgaggactcgttttttgaccaggagaattaa
-gccaagaaataactgacgtatttccaaatgaattctacgtgtttttcctgtcacctttag
-ccagtgttaaagatgactatggagtttcgaataggttattctatagacattataacgagt
-ggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaaggg
-attttaggttcttaatccaacgaagaaataacgcatcacccgtcattctattgttttcgt
-cgggattacttagtaggcagggtattctaacctacctgagttacaaatctttaaaaaact
-ggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatat
-actagaatccgtctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcag
-ttttatagctatctagtggcattcctttttataaaactttacgtttgtaagggtccaact
-ttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgta
-tattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttc
-taatctaacaatgtaaagccggggattagccgccaaaggggtctaatgacatagagatgc
-tctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgacagatcttccgta
-ttctgttagttgacatctgtgctgtctttaccgattgtgatttggctttagcagtcattt
-agtttcgttactcattgctcgtgcgatagttccaccgaatatggcacattcgttcttttt
-ttccattttactgcaaaccttttcaaaagctgatcgataccactgatgatggcattgatt
-agtcgattggcaactatgtcctgcttatatctccaattgcattgaatatagtaaaaaata
-aaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaa
-gcgccgtacctaacatataagtgattgagacaaatagttctccagacgtattgagatata
-tgtctcctataggcaagcgtttctaattgctgaccagaaattagaattaggttgttaata
-ctatattcgaccattttattccacgaatgtgctattctactggtattgctccgtatgcga
-tatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtc
-atttaccgggagcgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaa
-agacttccgcttactatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtat
-aagaaaatcatcttttcagttcgcagatttttgccaatttaaccggttatttcgtcagac
-ttggtagtgtagttacaagcatcacgattatatcagctacagaattaaactgtcctgact
-cgacggggcagtgtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtc
-atagtacaaggataatgaggtttgctaactttaaaaattattgatttaacggttgattga
-aaatctctgcaagatgacgctagaacacctgatgttcaagtttgccgataataacatata
-agatgaattactgtctttagaccctcatgttaatccgctaacttagggcggaaacaatgt
-taggctatgcggagtaagtactatattatgataccacatagaatttaacattcatatgat
-gtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatca
-atgggccaatcctgtctcaaaaattatcatattcaaggttcagctattttggcaatgggt
-gagtaccgttcttagtgatttacgaacccataatctaggcgacttaatatacaagattta
-gagttacgttttccgggtagtacatattaacgaccatggatcgggtgaggtgttgtatta
-gttatctgatcttgtcagtagctcccaatgtcccagaatattatgtttctactagagtgt
-tcgtatactggaatttaaatattatgtaagactagacaaattttatggatacattaggcc
-atcgtagaatatgatatagttgtaacgtccctctatagattttcggagggcaggtatatt
-gcttaataaagatgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgc
-ttaaataagtttagactattaagctatatgttcgacagcatgtagttttttttaccagaa
-agtgttatactgatgacccatggaggtagctcctcatgataaaaatattgttacttaagc
-attactattatagtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtt
-tcttatgcagacacacttttttagctgttgacgcccacctcacatccatagtaggtcaat
-cgcataagaacaatattctggactgttttattacccagaagaaagttttttctttccggt
-tcgttaagacaataaagatcatttcattcgttctcttaacgatgaactaaagtacttaaa
-gtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaagataagaagaac
-aggaacgcgcacgtcggagataactctaatagtctctttattccgtttaatatagcccgt
-aattgcaccatgcgctacagtaacggccgccttcgcaaacctatttatgtaattccaagt
-ttaggtatgcaatggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcg
-gggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtg
-ttaccaacccctcactactacgcgaaggtactcgattattccttgaatgggctgaaacat
-cgtgattagcgtcttatgattcaggctgatagaagaaaacttattttctatattccacgt
-atacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaa
-atacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtcacataaataatc
-cgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtag
-cattgttgaacagtaaaactaccgtcacacaaggaatatcataatagatgccatacacgg
-ttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtg
-tgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatgga
-tgagcatttaggtattctatgataacactaaccatcatgtttctaaaatcctcaggaaat
-ttgtattattttaccaacctgtatttatagaaagtgcttttgacttaaagaagccgaagt
-gttcaaattaaggagtacctgattgaaagaatggggaattgtaatctgtaactcaattac
-aaataagccgttctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaatt
-catactcgattaacgactttaatactcttctgcgtatctacagactcatttaaattacgg
-aatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaataaggacacctg
-gtacaattggctggagtacaatgttggtttttatttgctgattatcccgatccctgtggg
-cgttggcataaccgggttttcttcaagactactttcgtgttgcttatatacctggtaata
-tcggtgagtagcttagggcttaatcacaatactaacaagttctctatggattggacaggg
-cggcatccgttgactgaacgatctattaatccattccctgcactggataaacaagaccca
-tttaaattgaccatagagatgttagcgtcatatttctgttcgtgatagggtacatatatt
-ataaacggattatgagcagtggttttctagaaaagcattcatagttaggagtgtatcaga
-tcataccactgaaccatagagcacaattctctactggctatacttcattcctttttgtcc
-gggtggggacgaaatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgct
-ggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttgactattgacagg
-gcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagatagagtacgggcc
-tataattcaaattcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtt
-tactggtatgtggtgtcaagccccacccattctctgttatatccgagcattaatgtagtt
-tcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctga
-gaagtggcactataatagtttagcctaagtcccttcgctaataactcaacaaagatgacg
-caaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatactgatagctctcat
-ggtaccaagaactttcataacctctttatttaccaaacctgttctactagcgttagtgtt
-ttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaa
-catgggatcaaaactattggcttaacgtttaatcgaatgagactagcactgtattactct
-ttcgtttcggcagcggatcaataaggaggtgacggcatcactctcttatagtagatatca
-cttattctcacaacggaagtaggatcttccgtcctcattaaatttgcaactggctcaatg
-taacactgtaatgttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtc
-cctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaaattccagacctc
-gagttacattatgaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttg
-taatataaacaaccgtttttgtctattttcccaaggagaaggagagtagcagcttagtgg
-cttgcctatatggccccctaagtacgtactcggcacgcttagaagattgggctaccccgc
-actatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatg
-agagtataaaaatatacaattttggcaggggttatacattgcgggcatgaagagtaacat
-tggacatgaacggacattcgaaccctgtgagtttaataccctatctccggatcattataa
-agtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaactaaattggtta
-tttttctttcatctagatttgtctgtatctaactaaattatagttccacataaagctgat
-tcaactgaagacataaatataaactttctaacatagtagcgaggaaagagctatgcctag
-catcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttttccagaatctag
-accgaacacagggtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaac
-aattccgttcgtattgttgctgtatctatatttcctacgtaaggctatttgatctataat
-atgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctcct
-tagtatcatcaaattatagattttacggccacgaattattggtctagatgtcccaaaaat
-aatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattat
-gctataccaagaactctccatccagtacctagaaaggcaggtatgtaccgctcattaatt
-ttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggcttttataatagaa
-actaagtttcccgaataacggtgtacgataacagatttttaggtgtacagacgtctgact
-caatgaacacacattgggacctgccccgggaggagtagtagataattaccttctccagcg
-cgggtcttttaatatcacaacataaaaatactaattaatatcacacaccctcatcctcga
-tggagcctagcatcatacacgtttgatagacaacgccaattttactgtaatatgatattc
-gaatctagtatgtggacgctgtaccacattgtttaaaggagctccctttaccgacatgaa
-cgaagcaagctttgtacaagatacgaagaactcagtactggtaactataagagacaattt
-atacataaaagtgttaagaccattatataaaaagaggtatgaggtctttgtaactacaat
-aatacattcatcgaacgatggagaataacagagttatttctgctgctcgagctctagttc
-tgctaatttctcaatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcg
-tacatccctctctcctactcttacctatatcctattactggttaacctacatctccggga
-aagacgtaggtaaagtggtccacgattgtattcacttataacacctagtagtactatgtg
-ttgctgagagtgaggacacacttactctacgagttcaagtccatatggacattacacttt
-ttcagcatctaggtgtcatgatgtattaacagccgttaggggctatttgattttatcgat
-tgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaataggcatgaaaattc
-aagattgcagttcctatcttgtataatctttcctttggacgagttgtaccatttcaacta
-acctgcaagtggggggtcatccatatgaagatttgccaaatacctggagaccctgaaaag
-tttatccagattaataataacaaacaaacctaagcgaagaacgtcagctttaataaacta
-tcactatcatagaaattcctgttaattgttcttccaaacgttgaatagactatcacgggt
-aatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgata
-actcaattatattcgatggagaattcatatctaccgcttagcttttaaaaattaagtcag
-attattccgccacaatgagaaggcgcgagtgcactaatcaaatcacttaggattattacg
-gacgtctgcattacaatgctttggggtagggttatacaagcatatgattctttaggtctc
-ttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgt
-tgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacctgttcatgaaaga
-caggagacacgaggcaccacctcaattctatgcaaaactctaacatagcgtggcactatg
-agtacgtgtaacgacaaggtctcatactcgatcctaagataattctcgtctggaaggttt
-taatctttaactaagagtagaacttagtttattgacttttacaattaggatacggttcgc
-gactctaccacagggcatcatacctggagctctgctatctcgtgaccaaagtggcagcac
-acatagggtcgggtcctgcatctactgagcaatccctttaagcattcctagtttgagagc
-catttagatattgctgtttaaaccgattaatggtttctattattataaagtgtaacgctc
-ccattcgggacattgaaaattagcaataagacaatgtatgatattcggcgagtctcaaca
-acattatggtctaccatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaa
-cacccatggttcgttaagtgagggtatccaggtgttataaggacgatctagaagtattca
-ggtacacggtgttcagacatgctctaattgtcaggttgtttataatttaacgtatcgctc
-tctattctaaataatataaaattaaccgctcgtagggatgctttccagtaaaagatacac
-tatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtacattcttaaactt
-aaatacgtattatttaaagtaaatatattatctaaaccgcttttgtctatccacatttcg
-tcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatc
-tatttcttctgattgatgtaatactgacccttactccgtacatacaaatgatggtaagca
-agaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtag
-cttgaaagggatatggatgtgtatgccaggcttcattttgacaatttttctgtcctgctc
-agtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgtagatccaatcac
-gctttcctacgctaatgaaagttctagatagtgtaggtgttagacagaggttagcgccta
-catccttacacacacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtat
-ttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaatgtcctgcccta
-gagttatgataaaataactgctgccctgtaacttaagtttacaaaccgatattcaatcgt
-tgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaac
-acagtgatttataaatacaaagagtacatttagttaccggattgcggcttgacatttatt
-ttacagaattttatcggcaaaacacttcatatgaactatcgcttcacgataagtctatga
-tagactagcattcgtagagaacaggaagagcaatcattatatatgaagtgttacagtggg
-tactacatatgagatcattaggtctatatccggccttcctcataagaccttggaaatatc
-ttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagta
-attcatcggacgtaatagtctggttttaactaggggttattgatatttaagctaaaagag
-ttccctgaacactcgaaatgtataatctatcccaactaaaaaagtatacctctaattcag
-aaatgtcattgagattagactgatgtcaatacgctaggaggtaagacaagtagaagtttt
-tgatttaggaattgaaatgtaatacctccatcttaagttctatattttaaagttttatgc
-ggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatgtttgcggccccg
-tatgagtaatgatctgtttatcaatctctagctactatcccacgaatgcactgatgccag
-tcatggcgcttacattagtcgacagaaatccgacgatacctatcacgcgtgaactgttct
-ggttcttattcaattcgaagtgatctcagatacattacggccatgcttgcccttcatgtc
-tgctgagcagttttgttataggctgaatctcctctaagcgaaattgataggatttttggt
-ggtcgatttagtctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaa
-tgatagggatcggctgaggaggataaatatacgctggtgcctggtatttatccagaacaa
-gttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaa
-ggccgcaaagggttacatctcaggatcgtggcgtatagtccaccattagttctgacttac
-ttaatatagactgaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtc
-ggttagcaaaacgtataggagcatgatcaaagaagagttaattaatagtactgcactata
-attgtcggcggagtaccatgagctgttgcccaattcgatgtttattaacagcacgcataa
-aaaatccagacttttcaattagaattaactataaatggtccgcgaaccttaaatgatcgg
-aaggacgggatctgccgttgtatagaccccaactctatctaatttttataacacctctgt
-aatcaacaaatcttattatgccatcattatgtcattcgccaagtaagtccagttcgagat
-tctctggaccgtgcaatagtattgtcaaattatggtaatggaatccttcttctaacaccc
-ttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgcc
-gtttctttttacgatgatagggattcttaaagcttttctctattctagatcccagttgcc
-atcatcaatatctcaattgatgctcattatatagttcttatttagtatgtccagatgtca
-ctgaagatcctgcctagaaccgatattctcgacaggatcatcagttcgacggggcaaacg
-cacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatg
-tggaaaaaaactcctgtccacgatatgtaggcaagttttactgcctttaattagtagtcg
-attagtgtagtttgatattatctaccttatagaatgtaaacagtaacccggccttaatgg
-tttggcaggattctttgtaaaagttaataatgttcataaactttatcagaaaacctgaag
-tagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgt
-cttgttgtccgagtacacatattgctcctctcccccactcttctaggaaaatcaattatg
-ctaacctgcagaccttcttctttactatctttaatgcatgcccagtatgttcatagggta
-gacttgctatctattttgtataatctacgaatgatgcttggggcgcgacttttaacaatt
-aagccgttgggtataatttgagagggtgccacgatagtaagagatttccggcgtgagtaa
-ggaaaatgataataggattaagcaggcgtaatagctcaccctcctcagttctccaaccct
-gaaccggctaagtatgactgtgcagtattaattttgaatacatattgcagcccctaggat
-acattatagatgtctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcg
-attgaggttaaattagccggaattacagacacagattcttgtttacaattgtgggaagaa
-aaccacctcaaacgttgaaacctacattcacaaatggattacgttggggatgagaatcga
-ttccggtcaaaaatcatgcccggagcaataaccaagaattcacagaggattaatacactt
-ctccatgaagataggactgcttgcactatccttatctttgtgtcttccttcaagcaccaa
-tcgtttggggacaaccacaattatgccaagaaataacggaaggtgttccaaatctatgag
-tccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggactttagatttggg
-tattctagagactgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaa
-aggggaccgcacgttgtgctagggatgtttccttaggaatccatacatgtaagaaagaat
-caaccgtaattatagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacc
-tctgggaaatagattgaatattctggacagcagcgaatcctgattatatctcaagcgaat
-atatgacccgcaagaaggatttatactagaataagtctaagaaagggcattgggtcactt
-cttccactaacacacttttatcagttttataccttgagagtcccatgcatttttatatat
-atttaactttcgttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaaca
-acggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttc
-tgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaa
-accgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttc
-tatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagttt
-gggttttggatttaccagtcttttagtttcggtactatttgatcgggacattcgtccaaa
-catgatggctcattcgttctttttttcaattttaatcaaaaccttgtatttacctgatac
-attaaactgagcatcgcatggaggtggagattcccatatatgtaatcatttgatatccta
-ttccattctttttagttataaataaacgctccactgcacaatgggagtaggacttcacca
-ataattagcatctactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaata
-ggtctcaacaacttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaa
-gtaagtagaattacggtcgtattacttgttgccaaatggttattactccaatgggctatt
-ctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagt
-ggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggt
-gatgaattattgttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaa
-tttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgcagagttttgcca
-agtttacaggtgatttactaacacttgggagggtacgtacaaccatcacctggttagcag
-agaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttatta
-aacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaa
-tttatggttttttccgttgagtgataatagctgcaacatgaagatagtaaaactgaggtt
-aaactttcaccatattaaattatatgttcaattacgcgatgtacaaactaatgttaatca
-gatttaggagcgcgcttaatatgggtccctatcccgactttgtacgagattttgataaaa
-aatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacaca
-tttaggatgctatttccctaagaaagcggaaaatcctggctcaatatttataatagtaat
-ggttaagattgtggcccaatcgctgagtacccgtcttacgctttttccaacacataatcg
-acgagaatgtatttaaatgtttgagacttacgttttccgcgtacttattattaaagtcat
-tggagagggtgtcgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatc
-tattggttgtttctaattctgtcgtccgtgtaggctatttaatttttatggtacacttga
-atatgtttagccataatgtagccaatactacaatatcagatacttgtatacgacctatag
-acttttgccgaccgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtt
-tgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgctatatgttactc
-tgaatgttgttttttttaccagaatgtgttataatgatcaaccatgcacgttcctactaa
-tcatataaattttgttacgtaagcttttctatgatagtggtctaaagactacccttgcat
-actttaagattaagacatgcactttaggaggaactcacacgttttgagctgttctagccc
-acctataagccattcgtccgcaatcccataactacaatagtcggcaatcttttattaccc
-agaactaacgtttttatttcccggtacgtatcacattaatcttaatttaatgcgtgagag
-taacgatgaacgaaagttatttatgtttaagccgcttcttgagaatacagattactgtta
-gaatgaaggcatcataactagaacaccaacgcgcacctcgcacattactctaatagtagc
-tttattcagtttaatatagacagtatttgaaccaggcgctaatgttaaggcccccttcga
-aaaccttgttatgttattccatgtggtcggaggatttgcggggcgatagcgctgggcggg
-gatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaa
-aaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccgaagggactactg
-tattccgtcttggggatgtaacagactgattacagtcttatgatgaagcctcattcatct
-aaaattagttgatttattccacggatactatcacactcctatagaaagagttaccaccgt
-gggaagctagatataataaataaaagacatacaatattagtatggctcatgatctacact
-tactcggatctctctttttttataaccagtagatcgcattacacgtattgttgttccgca
-tcaggccctaggggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaa
-gatattaatagatgaaatacacgggtttacttgatttctgttcagtcattcacgggaaat
-cctaggagtctttcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtct
-cgacggaattggtatttcctggcatcacaatttacctagtattggagatcacttaaaata
-atgttgagataataatcaggatatttctagtatgtgacaaacctctatttagtgattgtg
-attttcaattaaacaagacgtaggggtcaaattaacgactacatgttggaaagaaggccg
-aattgtaatatctaactcatgtactaagaagaagtgctttcgtttaaggctttctgtcta
-acattctaacgtcaattcctatgtaatactactgtaaccaagttattactcggctgcgta
-gataaagtctcatgtaaatgacggtttatctgttacttttgggtttcaacctagctagga
-cgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgt
-ccggattataaccatccctctcccacttggaatatcaccgggttcttaatgacttagttc
-gtcttccttattttccgggtaagatcgctgtggaccggacccattttgatctagtctaaa
-aaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgc
-actgcactggattaacaagaacatgttatagtgtactgacacatgttagactaagaggtc
-tgttcgggttagccgacttatatgtttaaccgattttgacaactgggttgagagataaca
-atgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatg
-gcttgaattatttaattgttctaaccctggcgtcgaatttttttggttcgaaaatactta
-gcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaa
-ggcagtattgtgactattgacagggaatcctaaaaagctactcgaattggtatatggaag
-aggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagct
-taactagtttgatggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatg
-ggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgtacactaggcagcc
-ctaatccaaaacttttgaggatgagtactgccactattatactgtaccatttgtaactta
-cattttatatcttcaaagaggtagatattgtcggccattactgtcacttacactaagggt
-agcttgattactgatacctctcatggtaaaaagtaatttaagaacctatttttttacata
-acctctgctactaccgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcac
-ccctataagcagaaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcct
-atgagaataccactcttggaatcggtcctttaggctgaggatatagaacgaggggaacgc
-atcaatctaggttaggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctc
-agtaaattgccaaatgcagaaatcttacactcttttcttaactaagtatgagagcaacct
-cactcctgaacagcttgttacctaacgagaagaggctttaagtagcctggagcctcaacc
-ggatatccggatttgactctcatccacttacatgatgattacggtcattacatctcatga
-ttttctgagtgccctatagactgggaatttaatctaccctgtttctatttgttaacaagg
-agaaccactggtcaagatgacgcgcttccatttatgccaccataagtaagttctcggaac
-ccttacatgattggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtgg
-cctatcatattcaggtcatcgagctcagtatttaaagattatatggtcgctgggggtatt
-cagtgcgcgatggaagactaacattggaaatcaacggaattgacaacacgctcactttaa
-taacctatctcaggataagtttaatgtaattagacggaactttctctaactccgtgtact
-aactctttgaaaataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaa
-agtattggtccaaataatcctcagtaaaatcaagtcataaatataaaatttagatcttag
-gacagaggaaagtgctttcccgagcataggatctggcctacgccagtagttcatgcttgt
-gttaaaagttgttactgtttatagtccgtactcagggtagtgttcgatactcagcgggga
-actgacatattacactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaat
-tacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgatt
-cgagtttgtaaattcacagatactgtgtatcatattattatagatgttaaggcatagaat
-tattggtattgatgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagt
-gcagcttggaagaactggatgtatcctataactagtaagagccttaaaggtactacatac
-ccagggatgttaccatcattaatttggccatcttcaatcttcgcaatgcatactttcttc
-tacaagatgccttttagaagacaaaataagtgtcaacaataacgctgtaacttaactctg
-ttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgcaaacgcaggact
-actagattattaaattcgccagcccgcctcgtttaatataacatcataaaaattctaagt
-aatatctcacacactaatccgccatcgtccatagcatcagtcacctgtcttacacaaaca
-catgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaa
-agctgctaccttgaacgacatcaaccatcctacctttgtacaacagaccaacatctctgt
-actggtaaatagatctgaaaagttataaatataactgttttcacattgatagaaaaacag
-ctatgtgctatttgtatatactataataaattaagcgaaacatggagattaaaacagtgt
-tttctcatcctccacctcttgttctgctaatttataattcttgatgccactcgtgtgagt
-cgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaacgagatcctatt
-tctcctgaaaattattagcacggtaactcctagggatagtggtactagttggtatgaacg
-tataaaaacttgtactactttctcgggatgtgagggagcaaactattactcgaccagtgc
-aacgcattatcgacagtaaaagttttcagctgatacctgtctggatggattatatgcagg
-taggcgagagtggattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaa
-agtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcattt
-cgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgc
-aatagtactccagaccatgaaatggttatccagattaataataacttaatatactttcac
-tacatactcagcgggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaa
-aaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgt
-aaaatatagtagaatatgatgttaaatcatttatattccagggagattgaatagcttacg
-attagctggtataatttaactcacatgattaagcaaatatctgtaggaccgagggaaaga
-ataaaataaagtaccatgagttcggaacgctgcattacatggcgttgggctagcctgata
-caagaagatgagtatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggc
-agatcccggagcagatgattatcgtctaacactgtctttaccaatgcacaacgcatagat
-ttaacctgaactgttctggattcactcctgactacagcctacaactcatttctatgcata
-actcttaaagacagtcgcaatatcagtacctctatacacatcggatcagactagatcata
-agataagtctcctctggatccttgtattctgttaagtacactacaaatttgtttagtgtc
-tgggacaattacgataagggtcgcgactagaccacagggcatatgacctccaccgctcct
-agcgagtctccaatctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcac
-tgtaagatttacgagggtgagacccatttagatatgcctcgtttaaccgttttaggcttg
-ataggatgagtttgtcgatccatcaaattcccgacattcatattgtccaataagtatatc
-tagcttattcggactcgctaaactaaattatggtataaatgccgtcaaccggtgcatttg
-ttcaatcaacaaattatagtcaatctcccatggggccttatggcagcgtatacagctggt
-ataacgaccatatacaactatgaacggactagctgtgaactaagcagattattggatcct
-tgtgtataattttaagtttcgatctatatgctatagtatagaaaatgttccgatcgtacg
-cttcctttacagttaaacagtctatatcatgaagcttatccaaagctggacatttgatgg
-caatcttacttaattatgaaacttaattacctattattgaaagtatttatatgatcgaat
-aagatttgctctataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaa
-cctaggtaatctaaagcctgcatctatttcttatcattcatgttatactgacccgttctc
-agtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaat
-aaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcat
-tttcaaattggttatctacggataactgtgcgatgaactactataggtcaaaattatctt
-caatctcattctagatcatataaagatgtccttcgcgattgatacgtctacagtgtgttg
-gtgttacacagagggtagcgactacttacttactaactctctcttgatccgcaagcataa
-gccaggttaaagtgctctatctttttctgtggattataatagttataccgccttgcatct
-aggtgcccattaggtaatgccctagtgttttcataaatttactcctgccatctaacgtta
-ctttaatttcccagattcaataggtctctcatttgaaaattgttatatgtcaacaaagaa
-tataatagctgagtggaacaatacactgtgagggagtaatacatactctaaattttcttt
-acggtttgcgcctgcacagttttttttatctatgtgatccgcataaaaagtaatttcaac
-gttccattcaagttaagtcttggtgacactagcattaggagagatcaccaagaccattat
-ttatttagctagggtttaagtcggttagaaatatcagataatgaggtctttatccggcct
-tacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaagtatggccgaacc
-cacataatgcacaaatcaagtcgatttcttccgtccttttagtctcctgggaactacggg
-ttattcatagttaagctaaatcagttaacggaactagacaaatgtataatagttcccaaa
-tatatatctataaatcttatgcagttagggaatgcagatttgaatcatggcaatacgcta
-gctcggaactcaactacaagtgttggatgtacgaattcaaaggtattacatccttatgat
-gttcttttttggatacttttatgacgacttccacgaagtgaaattatgttcgaatatctg
-aacagttacttggttgagcccaaggatgacgaatgttctgtttataattctcgtcataat
-ataaatacaagcatatgaggccagtcatggagctttcatttggactaacatttccgtaga
-gtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgttatcagatacatg
-acgcccttgcgtgacattcatggctcctgacatcgggtcttttaggctgaatctaatcta
-acccaatttgtttggattgtgggtcctccattttgtctgttaatgcttattaagattaaa
-aatgtactacgtatttagacctaatgattgcgatacgctgtggaccattaatataagctg
-cgccaggggatttttccagatcatctggcctgtgtatatgttcaaatctaatagccgaga
-gaaattactccgacggaaaataaaggcagataagcgtttcagagcaccatcgtggcgttt
-agtcaacctttagttcggaatttattaatatacaatctcactctttggacgagctcctta
-aaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaaca
-gttaaggaatacgactgctctataattgtccgaggagtaccttctcatctgccaatagtc
-gttgggttggaaaacaacgcattaatatgccacacttgtcaattagaagtttctataaag
-gggacgagtaactgatttgagacctagcacggcagaggacgttcgtgtgacaacatctct
-ttataagtttgagataaaatcgctaatctacaatgattatttgccaatcattatcgaatg
-cgcaaagtatctcctgttcgtgattctagcctaaggccattactatggtcaaattatgct
-aatcgaagcagtcttctaacacccttagaaaagcaaacactattgaatactgccgccgca
-ttcgccagcaccaacataactgcacgtgcttttttccatgattggcattatgaaagattt
-gatctatgattcttaccagttgcaatattcaatttagcatgtgttcctaattattgtgtt
-attatggtctatctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcagg
-atcatcagttcctcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaag
-caatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcg
-tttactgccttttatgaggagtcgagtactgttggttcatatttgctacatgattgtatg
-taataacgatcccgccctttatcggttcgatcctttatggcgataagttatgaatcgtca
-gtatctttagatcaaaaactcaactagtacccagttccccggaggaacggtcatgattaa
-tgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccac
-tcgatgattggtatagctatttgccgaaaagccacaacgtattcggtactatcttgtttg
-attcccctgtatcttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatc
-ctgggggcgacacttgttacaattatccagttgcgtttaatggctgtgggtcacaagatt
-gttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagct
-cacccgcctaagtgatccaaccctcatcaggataactatcactgggcagtattatttttg
-atttcatatgccaccccctaggagactgtagtcatgtatctttcttacccaatctagccc
-gaaacaagaaagaatgtcgattccagtcaccttttattagaccgatttacacacaaagtg
-tcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacgacttgctctattc
-gattaccttcgcgatctcaatcgattacgctaaattttaatgcccgctgaaatatccaac
-atttaaaacaggattaattctctgatccatgaacttaggactcattgcacgtgacttatc
-tttctctcttaattcatgctccaatacggtgggctaaaccacttttatcacatgaatgta
-cgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatc
-ttctattgggacggtacatttcggttttatagactatgtagttacacggcatcaacatgt
-aattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggag
-gattacatacatctaagaaacattctaaactatgtatagtcgtttacgacccttgtagta
-cgtgcatcccttggcgaaaagtactctgggtattagagtgtatattatcgacagcaccga
-atcctcattttatagcttgacaatttatgacccgaaagaaccttttataagtctataagt
-atatctaacgcaattgcggcactgagtccactaactatctttgagcagtgttatacagtg
-agacgccatggaaggggtttatatattttactgtcgttccctaaaaagttaattatcaga
-cctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccatt
-ccagtcgagatcaaccgtttctgcggatcgcgttacattccttgcttatttgcgataaat
-cgatacaaccccattaccagaaaaacccggagaatcaattactctgcagatcttatacta
-aaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgtggagcgttgggg
-taagagcggagcgattttaactttcgcttttccattttccagtattgtactttacgttat
-atttgagcggcacattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaat
-caaataattgtattttcagctgactttaaaatctgcagccattggaggtggagattccaa
-tagatgtaagcaggtgatatcatatgcaattcttgtgacttattaagataccagacacgg
-cacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaattccgaacgtaaga
-tatgtttacggatgcactaaaataggtagcaacaacgtttctctgagatgtataagttac
-caaacactggagaattccgctaaactaaggacaatttccgtcgtattaattgttgacaaa
-tggttagtaatacattcgcagtggataatccgttgcatacctagcactgagtgtaaataa
-aaccaatcgactactggcatttcgggctaacgactagatgttagcctatgtgaaagcctc
-acacatgcttattgccttcacggtgagcaatgtttcttattcgttattagaagtcacctg
-tagagacagtagagatgacctaaatttggtttgtccagtcccgaggtgatctaatgatta
-ggttaacttagaacagtggtcaattggttaaagctgatttacgaacacttccgaggggtc
-gtaaaacattaaactggtgagaacagtatgatgtattcggtcatctagacaaccccatcg
-ctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcct
-gttgctccggggagatagggttaatttaggcttttttacggtgtggcatattagctcaaa
-catcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaag
-cgatgtacaaaataagcttaataagatttaggtccgaccttaatttcggtccatagcacc
-tctttctaagtgttttgcttaaataattgtattgttattgattttctgcgagttgaacac
-ggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaa
-tcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccgcactaaacggct
-ttcgctgtttccaaaaaattttagtccactaggtatttaaatgttggacactgaacgtgg
-aagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgtactttgagcagat
-gctatcgtcagaaaaaggtaaatcttttggttctttataattctggcgtccgtgtagcct
-agtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaattacgtcattag
-ctgttacgtctatacgaaatatagactgtggacgacccatcgtagagtcatgtagttaca
-tgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactgg
-tcaattggttcatagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagc
-ttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcctgttcgaggtta
-gtcgtataaagacgaaacggccttaatgtaacattaactattccactgtaggtggatcta
-acaaggttggacatgtgctaccaataagataagaatttcgtccgcaatacaatatctact
-tttgtagcctatcttggattaacaacaacttacgttggtatttcaccggacgtatcaaat
-gattctgattttaatgactgagagtaaacatcaacgaatcttatgtatctttaagccgct
-gcttgacaagtcacattactgttagaatgaacgcttcattactacaaaacctaccaccaa
-ctcccacattaatattatactagatgtttgaagtttatttgacaaaggttttcaaaaagc
-acagaatcgttacgaacacgtacattaaattgttagggtattaattgtggtcggtgcatt
-tccggccccatagcgctccgcggggagaaactatggccttcatgacagcccccccataac
-atctaggtaatggtcggataactataaacaaccctctccagagaactgtgaaaataaaat
-ctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaagactcttttcact
-attttcttgatgcctcattcttctaatattaggtgattttttaatccgagaatataaaaa
-gacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttt
-tgactatccctcatgatctaaacttacgcggagctatctttttgtataacatgtacagag
-aattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttat
-cgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacgggtttcgggatt
-tctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaa
-ggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtcc
-gaggattgctgataacttaaaataaggttgagtttttaataacgatttgtcgagtttggg
-aaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacgggtataatttac
-gacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactg
-ctttcctttatcgattgctcgagaacattataaagtctattactatggattaagactgta
-tacaagtgtttaagcggagcccgtgataatctataaggttttggtacctttatctgttac
-ttttgccttgaaacatacatacgtacacgggaatatttacctaaacgccgtatagtccag
-cctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgcccacttgcattata
-acccggtgcggaatctcttagtgactcgtcaggagtttacgcctttgagacctctcgaca
-ggacccattttgatctagtcgttataggtagagtgcctttcctatcgcaccattaccttc
-tagcaaacttagagtattcaatgaaatcatatcctgtttatactaaatgttataggctaa
-tgacacagctgacactaagaggtctcttcgggttacccgaatgagttgtttatacgatgt
-tgacaactcgggggagtcatttcaatgaagactgaggactcttgatcagattaaaacgct
-taatgactgataatttagattatgccgtgtattatttaagtgggcgaaccctcccctaga
-atgggtttcctgagaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaa
-cgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaa
-ccgtctactattcctagagcgaagagctatgttctgacacgtccccaatattaggcaaag
-gctccaaaagaacagtcaattgattaactacgggcttggtttctccgtgaatccttgcgc
-cgctataccacataaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgac
-cctcaacaagtacactagcaaccccttagcaattaattttgtccatcactactgccaaga
-gttgactggaccagttggaaatgacatttgatatattaatagagctacatattgtaccac
-tttactgtcacttacactaaccctagcgtgattactcatacatatattcgtaaattctaa
-gttatgatactagttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttca
-actaaatatttcactgtagccaaccactttaaccagaaggataccttaatgccgatataa
-tattgtccaggaaacgttaatactttcacaagacaaagcttggaagaggtactttacgat
-cacctgatagatcgaccggaacgattctatataggtttggtctgagaaatttgtagctaa
-aaccatgttccataggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttg
-cttaactatctatcacagcatcctaactcctcaacagcttctttcctaaagacatcagca
-ggtaagttgacggcacccgataacccagagcacgattggaatctaatactctgtatggat
-cattacgctaagtaaatataatgattttctgactcaaagttacactgcgaattttatatt
-aactggttctatttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatc
-caaaaatatctaacttataccaaccattacttctggcgcagaaaaacatagatatctgaa
-caatcgaccgttaagactgtctcgccgatcttaggaacctaatactgctcagtagttatt
-gtttatttgggccatccccggattatgtcagccatggaacactaaaagtcctaatctaac
-ctatggacaaaaagctcacttttataaaattgctcaccttatgttgattgttatttgtcc
-gaaatgtctataactcagtgtactatctattggaaaattatggccggagttttattgaat
-atacttttgtatgttgagaaagaatgttgtcgtaataattatcagctggaaaatcatcta
-atatatattatattgagatattacgacagacctaagtgctttcccgtcatgagcagatgg
-actaacactcttggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcc
-cgactcttacttactcagagcggaaatgactttttaaactaacgtttaaaggcacttagt
-atgcgtcagggttatttttttaattacgtacccttgtgcagagagtttagctattcgatc
-ctacttagtatgaaccatgagagtacaggttggtaattcacagagaaggtcgagaagatt
-atttttgatgtttaccaatactatgaggcgtattcatcgaaataattttatggctgcgca
-cttcacatacgcaggaagaccactgcagcttgctagatctggatgtatcattgtacttct
-aagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatggggacatattca
-atcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaa
-ctataaccctggaactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaa
-aggcccaaagcaaaacccaccactacttcagttttaaattagaatcacaccctagggtat
-tagataataattaaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaa
-taagtctccggtctttcacaaacacatggttaagcgatgtggttttgactagagacgttc
-gccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatcttacttcatacatt
-gcttaaacagtacaacttatctcttatcctatagagatctcaaaagtttgtatttttact
-ggtttcaaattgagagaaaaactgcgttctccgatttctatattattgtttaaatgatgc
-caaacatccagtttaaaacacggtgtgatcagccgactcagattcgtatcctatgttaga
-atgagtcatcaaactacggtcacgcgtacattacagagtaaactacacgaatgaaagaga
-taagaagatgaaagagttaataggtctcctgttaattatgagaaccctaactactacgga
-ttggcctactagtgggttggaacggatataaaattcgactaagttcgcggcatgtcaggc
-tcctaaatatgaagagaactcggcatcgaattatccacagtaatagttggaacatgattc
-ctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggc
-gttgtgaatattcttcctcagaaaaggactgttgagcaaggaattggattctgtgaacgg
-aatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgcc
-gcgcgcagacatatcttcttggcaattagtactccactaaatcaattggttataaacttt
-tagaatatctttatataagttcactacttacgctgcgggtagtatatttaaagtgatgtc
-ttaggaatcttatggcggcggaataaacggcttgactatagataccctaattctggcata
-accctgtaacgtgtgaagcatgctttaatagacgactagatcagcttatagaatggatat
-gactgccacattgaagagattaacattagcgggtataatgttacgaacttgtttaacaaa
-atagctctaccacacacgcatagtataatataaaggtcctggagttcgctacgagcctgg
-aattgcagttcccctaccctgagtaaacaagatcagtatggacctatcttctgacccacg
-tgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcggctaacactcgc
-tttaccaaggaacaaacaattgatggaacaggtaagcggctggattctatcctgaataca
-gcataataatatttgctttcaatatatagttatgacactcccaatatcactaactcttta
-caaatcggatatgaagagtgaattagagatggagccgatcgttccttgtattctggtaag
-tactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactca
-cgcattatgaaatcctccgagcatagagactctaaattcgccaagcaataagtcccgacg
-cgaaggatgagaagctcattgaactgtaacatttacgtcgggctcaccatgttacatatg
-cagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacataaaaggccccact
-ttcatatggtcaaatatctatatcgtgctttggacgactcgataaactaaagtagcctag
-taatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatatataacttccgga
-cgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcg
-gaactatgcagattaggcgatccttgggttgaatttttagtttccatagatatgagttag
-ttttgatatggttaccatacgtccctgcattgaaacttaatctgtatattgattgatcct
-tagcaatagcggcacatttctgggcaatatgacttaattaggttacggtttttactatga
-tggatacgttttatatgatagaataacagttgctatttaaacaggtactacattcaacta
-atactgtttcactattgtgtccaacatagggaatatattgcctgaatagatgtattatca
-ggcatcttttacgctccaggtagaactaattaaaaatgatccttagaaactttcaagcaa
-cataagctaaaagttacgccaattataagccacatcggtaggatcttcaggcattcccat
-atccttctctatcaatcccgtctgttgctaattggttatctaagcatatcgcggcgagca
-tctacgataggtataaagttgctgctatctaattcgtcataatatatacatggaattaca
-gattcatacgtcttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatat
-ctctctcgtgttacccaagaagttgacacgtgattgtcagctatctttttctggcgatgt
-taatagttataaacaattgcatatagctgcaaattagctaatcaaatactcgtttcttaa
-atgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagggcgctaagttca
-aaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtg
-taattatttctctaattggtctttacggttggaccaggcaatgggttttttatctatgtg
-ataccaattaaaagtaatttcaaagtgacattaaacttaagtattgctgtcaagaccatt
-acgacacttcaccaacacatttatgtattgtgctacgcggtatggcccgtagtaatttct
-gatattgaccgcgttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgt
-gtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgttgtattacgtcc
-ttttactagcctgggaaataccggtgattcagagtgaacataaatctctgaaagctacta
-gacaaagctagtatagttaaaatatatatttcttttaatattaggatctttgcgattgca
-catttcaagcatcgcattaacctacctccgtactcttctacaacggttgcatgtacgatt
-tctatgcgatgaaatacttatgttcttagtttggggttactttgttcacctagtcctcga
-acgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattct
-taggtttataattatagtcagaagataaatacatgcatatctggacactcttccacatgt
-catgtcgactaactttgaactacagtcatatatagactgttatctgatccgtatgtgtct
-attactactcttatctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcgg
-ggctttttccctgattataagattacactattgctgtgcttggggcctcctactttttct
-atcttaatcattttgtacattaaaaagctaagaagtaggtacaacttatctttcccatac
-gagctggaccattaatttaacagccgcaaggcgagttttaatgttaatctggaagggctt
-tatgttctaagcttttagcactgagaaattaatccgtaggaaattaatcccacataaccc
-ggtaagagaaccttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaag
-ctcactcttgcgacgagctccttaatacaggccctgcgttatattcgaccgtacctataa
-ctagaccaccatcttaaatgtacagttatggttttcgacgcatagagtatgggaccacct
-cgaaatgctcagctgcaaattgtactgggggtggttatcaaacatttaatatgaatctat
-ggtaaagtactagtttatagatagccgaacactaaaggtttgcagaccttcctcccctga
-ggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcgtatctacaatga
-tttggtgcaaatatttatcgattgcccaatcgttctactcgtactctttatagcctaacg
-ccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaattacttaaccat
-actcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgttttta
-cttgagtcccaggaggtaacattggatctatgagtcttaacagtggaaatatgattttta
-gattgtgttcagatttattgtcttattttggtctatctcatcagctatagctacataatg
-acgtcttaactgtttcgactaaccttcagatctgactaccccaaatacaacatagcaaaa
-gaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaag
-aatcgaaaacagatctaccattcgtggaatcaatttttggacgagtactggtcgggtcgt
-gcttatttgctacaggattgtttcgtataacgttcaagcactttagcggttccatccttg
-atggcgttaactgatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggt
-cccagcacgaaacgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagt
-ggaatatgtgtcatcagagacaaatagatgattcctatagctttttgcagttaagccact
-aagtaggcggttctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcg
-tgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagtttcaacttccgt
-ttattggctgtccctcaatagagtcgttctcagggcacgactctcgttcgttattcataa
-gtccagtttgatccacgaatacagaacacgcatatctgataataaaagcttaacgataac
-tttcacgcgcatggtttatttttgatttattaggcaaccaaataccagaatgtagtcagc
-gatatgtagtaaaatttagacaaacataaaacaaagtatcgccattacagtctcctgtta
-ggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgatttaataataatt
-acggctaaacgtattgatattttccaggaactgccccatctcatgagatgaccctaaatt
-ttattcacacctcatttttaattcttttatatcacgattatttatctgagcaagcatctt
-tgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgcta
-aacatattggttcaattcaatgtaagctacctcggaatttgcttgcactaagacggggaa
-gccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccgttggagtcacta
-tggagttacaagcattataaatctaaggaaatcgcagtatcagtccttaccccaaagata
-cttcgcattccctggggtacggaccatgaaatacttctttcatacatgataaacgatgga
-gactcggttaccaccctggtagttactccatcaattggagttaactaagatcgctattac
-aggctttattagccaatcatcacaagcctctttttagagattcacaagttagcaaaccaa
-agttcctttgataagtctttaacgagatctatcccaattccggctaggagtaaaatttat
-atatttgagatcggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtcc
-ttccctaattaggtaattttcagacctccgagagagagtagatcaacaacgcgttatact
-cctaaaatgcttgtcgataacatgacactacagatcatccctggatgagcatcgactttc
-attacttgattagttcagttaattcgtttcaaaccattttcaacaaaatcccccagtaga
-tatgtatatgcacatcttagactaaataacagttttcataccctgggatttgtgtcacta
-tctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactggccctgttccatt
-gtaatcgatgggacgggacgttatattgcagacccaaagtagtaataaattcagccatat
-ggacggagggggggaattgttaagaatataattcgattttcagctgaatgtaaaagctcc
-agccattcctcctccacttgacattagttcgaagaaggtctgagaattggaattgcttgt
-gacgttttttgtttccagacaaggaaatagcccagtaccaagtataatattatgacaata
-gaagcttaaattcacaacgtaacatatctgttagcatgctctaatagaccgagaaaataa
-gtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagt
-tcccgactatgaagtcttcacaaatggttagtaataatttcccagtggagtagaagtggc
-ataacgtgcactctctgttaataatacctttagactactcccatttcgccagaacgtctt
-gatggtaccctatgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtc
-gtatgcggtatttctacgaacagctagtgaaaggactgatgacctaattttggtttctca
-agtccagacgtgatattttgatgaccgtatctgacatctctgggcaattcggttaacctc
-tggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttt
-tagctaagctacactaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcat
-ccatgtgtacgaattcctaatactcttgctcagggcacttagggttattgtagcctgtgt
-taccgtctcgcatattagatcattaatcaacagtcttataatcaccgtaatcggtaaaca
-gttgttatttgttctgataggtagacagctaataaagatgctgttgaacagttacgtccc
-acctttattgccctacagtgaaactagttcttactctgttgctgtaatatgtctagggtt
-attgatttgctgccacttcaaaacggaaattaagtcattaacgaaaatggttccttcata
-ggtaaagatcaatccccaattgaagccagaaattttgagatgtcgattcctgatcattcg
-ccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttg
-tttattctggctcaaggtacgtggaacacgtagtattttgatactaatgccagacccgct
-acgatccctgtactgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgtt
-agaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacac
-agtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatactctgggcaacac
-acatacttctctcatgttgtttcttcggacctttcataacctttcctggcacatggttag
-ctgcacatcacaggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggt
-ggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatattatgtttatttg
-tcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttga
-tctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaataagataagaat
-ttactaacatttaaattttcttattgtcgagcatagattggaggaaaaacttatttactt
-ggtatttaaacggaagtttctaatgtttatgattggatgcacggacagtttactgcttac
-tttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgttcatgcttccatt
-aagttcttcttaaacttacacaaactacctaatttagagttgacgagatggttgaacgtg
-ttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtg
-cgtaggaattctgctacgtccattgcaggccacattcacatcccacccctgaatatatgg
-actgaatcacacacaccaaatttcatctaccttatcgtagcataactattaacaaacata
-tacagacttcgcggtaaataaaatatattagtacacaaccgtatactggttgaactattg
-cccagctttaagacgcttttaactaggtgcttgatcaagaagtattattatatgacggca
-gtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacgccgtagagacat
-ttttgttagatatgtatttctttttgacgagccagcatcttagtatctgaagacgagcta
-tatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagattaaccaaattcc
-ccagaattagtaatggcgccttatcgatttactaacgatatataacttgtgatgttgtct
-gcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctg
-gatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgc
-tatgtaatccattctaatgggtaagaggattcctcttatagtaaaatatgcttgactttt
-taagaaccattgggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttt
-tctacaactacccctattaggttacaagtaatctggctttcttgccacttggcgatgata
-gttagattcgtatttctacaacgcagttactgtatccatggcgcgagataattagatacg
-atttgaatttggatgtagactcgttactactgttgtagaccagcacgtgagtatctagat
-gggtttgctaccttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatat
-tttactataagcagtattggccaccctcgtattgcggcagggtgtgctcacctggttaaa
-atgaaagagaaaaattccattttaaaacccggaggaatctattactgacgaggaaggtgt
-ttaacccgttgagacatctcctaacgtaaaaggttcatattctagttattccgagagtca
-ctttcctatccaaacatgaactgatagcataatgacaggttgaatggaaagcatatcctg
-tttattctaaatctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttac
-aactatgtgttctgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctc
-ctagcgtcatctgatttaatagcttaatgtctcatattttacagtagccagtgtagtatg
-gaaggcggcgaaccagcccctacattgggtttcctgacataagtattacatatcacttgt
-ctgattacacagcaaaatcgctaaccttactttgcgcatgtagctattggaactttgggc
-tagtgtctatcccattaagtttaacagtagactagtccgtgagcgatcaccgagcttatg
-tctcgtacccaagttttggatttggatcaaaaactactcgatattcatgatctacgggct
-tcctttctccgggtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaaca
-tgtttgacacgggatagcgtagaaactaaacaacgaatagaccatccaatttgaatttta
-ttgggtccagcacttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatat
-taattctgctacattttcgaccacttgtatctcaaggacaatatcccttgaggcttttag
-cagaaagagatgccgtaattctaagggatgataataggttgggaaatttaagagcagtag
-taacggtcgcgggttcgaccttaaactatatatttaaatctagccaaacaagttaacaac
-aaccataaagttatgaccttattatattggcaagcttaacgttttaattgctctagtaat
-agagtggtagaggtaagggaccatcacctgattcttcctccgcaaccattatatagacgt
-gtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaatatcgaatggcaat
-tagccacattgagttaaatagttgaggatatttcttgcacagaatcagatctaatctaat
-gattcgttactaaacacttcaccaggtatcgtgaaggctcaagattacccagagaacctt
-tgcaatataagaatatgtatgcagcattaccctaagtaattatattctttttctgactca
-aagtgacaagccctagtgtatattaaatcggtatatttgggaaattcctcaaactatcct
-aatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccatacatgaattctgg
-ccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgccaagatattagga
-tcctattactcatatcgtgtttttctttattgccgccatccccggagtatctcacccatc
-cttctcttaaaggcctaatattacctatgcaaataaacatatattgttgaaaattgagaa
-cctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgactatatagtgcttt
-agtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaat
-atttttcagatcgaatagcttctatttttgtgtttattgacatatgtcgaaactccttac
-tcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtctcgttttacggcg
-gaatcttgagtctaacttatatcccgtcgcttactttctaacaccccttatgtattttta
-aaattacgtttattcgaacgtacttggcggaagcgttattttttgaagtaagttacattg
-ggcagactcttgacattttcgatacgactttctttcatccatcacaggactcgttcgtat
-tgatatcagaagctcgtgatgattagttgtcttctttaccaatactttgaggcctattct
-gcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttc
-atatccatcgttcattgtaattcttacacaatgaatcctaagtaattacatccctgcgta
-aaagatggtaggggcactgaggatatattaccaagcatttagttatgagtaatcagcaat
-gtttcttgtattaagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaa
-taaacgagatagattcattatatatggccctaagcaaaaacctcctcgtattctgttggt
-aattagaatcacacaatacgggttgagatattaattatttgtagtacgaagagatataaa
-aagatgaacaattactcaagtcaagatgtatacgggatttataataaaaatcgggtagag
-atctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagg
-gtaactattattaattaataaagggcttaatcactacatattagatcttatccgatagtc
-ttatctattcgttgtatttttaagcggttctaattcagtcattatatcagtgctccgagt
-tctttattattgttttaaggatgacaaaatgcctcttgttataacgctgggagaagcaga
-ctaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacag
-actttactaaaccaatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaat
-tatgacaacccttaatacttccctttcgccgaatactggcgtggaaaggttttaaaagtc
-gaagtagttagaggcatctctcgctcataaataggtagactactcgcaatccaatgtgac
-tatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgc
-ctggggagacatgagaccacccccgtggggattattagtccgcagtaatcgactcttgac
-aatccttttcgattatgtcatagcaatttacgacagttcagcgaagtgactactcggcga
-aatggtattactaaagcattcgaacccacatgaatgtgattcttggcaatttctaatcca
-ctaaagcttttccgttgaatctggttgtagatatttatataagttcactaattaagatca
-cggtagtatattgatagtgatgtctttgcaagaggttggccgaggaatttacggattctc
-tattgatacaatttgtctggcttataactcttaaggctgaaccaggcgtttttagacgac
-ttgatcagctgttagaatggtttggactccctctttcatgtcagtaacatttcagccgtt
-attgttacgatatgcttgaacaatattgatctaccacacacccatagtatattttatagg
-tcatgctgttacctacgagcatggtattccacttcccattcaatgagtattcaacatcac
-tagcctcagagatgatgacccacctctaataacgtcacgttgcggccatgtgaaacctga
-acttgagtagacgatatcaagcgctttaaattgcatataacatttgagggtaaagctaag
-cggatgctttatataatcaatactcaataataagatttgattgcattttagagttatgac
-acgacatagttcactaacgagttactattcccagatctagactgaagtactgatcgagac
-gatccttacgtcgatgatcgttagttatcgacttaggtcgggtctctagcggtattggta
-cttaaccggacactatactaataacccatgatcaaagcataacagaatacagacgataat
-ttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaagctatcattgaa
-gtcccgctcacaatgtgtcttttccagacggtttaactggttcccgggagtcctggagtt
-tcgacttacataaatggaaacaatgtattttgctaatttatctatagcgtcatttggacc
-aatacagaatattatgttgcctagtaatccactataacccgcaagtgctgatagaaaatt
-tttagacgatttataaatgccccaagtatccctcccgtgaatcctccgttatactaatta
-gtattcgttcatacgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattg
-ttacgtgacagagatagcagtttcttgtgatatggttaacagacgtacatgaagggaaac
-tttatatctatagtgatgcttccgtagaaataccgccactggtctgccaatgatgaagta
-tgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtataacagttgcgag
-tgaaaaaccgacgaatttatactaatacgctttcactattggctacaaaatagggaagag
-tttcaatcatgagagggagtatatggatgctttgtagctaaaggtagaacgtatgtatat
-gctgccgttcattcttgaaagatacataagcgataagttacgacaattataagcaacatc
-cctaccttcgtaacgatttcactgttactgcgcttgaaatacactatggggctattggcg
-gagagaagcagatcgcgccgagcatatacgagacctataatgttgatgatagagaaggcg
-tctgaattgatacatcgaagtacactttctttcgtagtatctctcgtcctctttctatct
-ccggacacaagaattaagttatatatatagagtcttaccaatcatgttgaatcctgattc
-tcagagttctttggcgggccttgtgatgactgagaaacaatgcaatattgctccaaattt
-cctaagcaaattctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaa
-tctggaatgacggagcgaagttcttatgtcggtgtgggaataattcttttgaagacagca
-ctccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaa
-gcaaatcggtggtgtatatatcggataacaattaatacgatgttcatagtgacagtatac
-tgatcgagtcctctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattc
-ccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctacta
-atgcctttgttaggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaa
-atttcttctacttggattaactacttttacgagcatggcaaattcccctgtggaagacgg
-ttcattattatcggaaaccttatagaaattgcgtgttgactgaaattagatttttattgt
-aagagttgcatctttgcgattcctctggtctagcttccaatgaacagtcctcccttctat
-tcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggcc
-ttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgc
-cggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtagttaaataaatcc
-atatctgcaatcgattccacaggtattgtccactatctttgaactactctaagagataca
-agcttagctgagaccgaggtgtatatgactacgctgatatctgtaaggtaccaatgcagg
-caaagtatgcgagaagctaataccggctgtttccagctttataagattaaaatttggctg
-tcctggcggcctcagaattgttctatcgtaatcagttggttcattaattagctaagtacg
-aggtacaacttatctgtcccagaacagctccacaagtttttttacagccgaaacccctgt
-gtgaatcttaatatccaagcgcgttatctgattagagtttacaactcagtattttatcag
-tacgttttgtttccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggt
-ctgaccaatgtaggaagtgaaaagataaatattgcctacacatactgaattcaggcaatg
-cgttttattcgaaaggtcatataactagaaaacatgatgaattcttatcggatcctttta
-ctagcatagtgttggcgaacacctcgtaatgctcagcggcaaattggactgcgggtcctt
-atcatacattttttttcaatataggcgattggtctaggttagtgattccccaacacttaa
-ggtttgctgacattcataccctcagcaacttcctctcaaaaattagagtgagttggtggt
-cttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttat
-aatcgtactctgtagacaataacccattgtagtgccgattttgtgcataatacaagaagg
-aggatataaaaatgacttttcaataatattggctattagcaacaagaaggagaatcctca
-ttaagttagcaaccgcagggggtactgcagtccaaggaggtttcattggagagagcagta
-tgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctgattttcctagat
-agaataagctatagctacttaatcaactcttaactgtggagactatcctgatgatctgaa
-taccccatttacaaaattccatatcaatgaggctaacgcttaaatttcatttctccatcg
-taacaaaaatcagcctttttatacaagacaaaacactgcttccattacgggtagcaatgg
-ttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaa
-acaaattttgacctgacataatggagcgacttatcggatgttgccgatctttagggtcat
-ctattaagcttatacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacc
-tagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaatacaggagtcct
-tttcatttttcaagttaacaatataagtaggagcttagagaggcttgcatgaaaatcgtt
-aggaattacagaataggcagagagtggggcgtgtagactacattcttcaggccccacaat
-atgggttataggttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcga
-accacgctcgttccttttgctgtagtccacgttcatccaactattcagataaacaagatc
-gcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaa
-acaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaacataattcattc
-tttcgactggacacgctaaggtttggacaaactttgtatctatatctggaggcctgtatt
-ccagcccttcttttaataagatttacggcttaaactatggatatttgccaggaaatgaca
-ctgctattgacaggaacataattttgattcaaacctcattgttaattattttatatctcc
-tgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaa
-tgaatcataatagaccggcccctattaatattggttcaattctttcttacataacgcgga
-atttgattgcacgaacaccgggaacacataaccgtatagcgcccgttatgctagtgccta
-gcgactgggaccgtggagtctatatcgtctttctaccattattaatctaaggatatacca
-ctttaagtcctttcaactaacataaggcgcattccatgcgctaaggaccttgaatttatt
-atttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagt
-gcagtttactaagagccctttttctggcttgtggagactatcataacatgaagatgtttt
-gacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaa
-ttgccccatagcaggaatagttatatattgcagatcgcggtgtaacgcactccaaatcca
-tcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatcaaagcacagtgag
-agttgagcaaattacagttatacgacttaattcagtctccataaattgaaacgacacttc
-ttaacgggaggaccagacacgttcattaagtgaggagtgcactttttgactttaaaaaca
-tggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagttatttctgtttt
-aatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctca
-gagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtagttggcacaccca
-atggacgaataaatgctgccatatccacggagggcgggattgcggttgattttaaggcga
-tggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaattactgcgtacat
-ccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaact
-tcatagtataatttttgcacattacaagcgttaattaacaaacttactttgctgttagct
-gcctatatttgtccgacaatataactggatatctctgcgagaactgtaaattaacggcac
-ttggaacataatagttcctattggtaacgacgttgtaggcggcaattatccggtggaaga
-attgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagtataactttagaag
-actccaaggtacccagaacctcttcagcggacacgatcgctatcaatcaataaggattat
-tcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggac
-tcatcaaatttttggccgtgctaatcgacacacctgttattttcatgaccggataggaca
-tctcgcggaaattcgggtaacagctgggtagatataggacctcccctacgtattaatgat
-aagcctgtcataactagcttggtttaccgaagagacaataaacattcgagcgctcgtgcc
-aaactcggtgcattacgtttgaataaatcggtaacatgtactattactctgcctaacggc
-acttacccgtttgggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcg
-tttaagatcccgattaccgaaaatctggttatgtctgagcattcgtacactgcgtattaa
-gatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactc
-tgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggc
-tttatccaatatgggtccttaagtgctaaacatcattcacaatttcaagacagattgttg
-gtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaa
-ttatatgttgactaaactaccgtgtgtattctggctctaggtacggcgaacaagtacgat
-gtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagt
-aattccgttttattgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgt
-gccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagt
-taactaagtgtctatcgccaactaaaagacgtctcgatggttctttatgcggacctgtca
-tatcattgactggcacttgcttacatccaaataacacgtttgttagcggatagtcgttaa
-gtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctacatgataaatgaat
-aagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgtcgacgagttact
-actaaaggaatgtagggttctggatctatgaaaagcgacctccatatatatacgggccta
-agcggagtaaaataagtgatcaatggactaacattgaaatgttagtattgtcgaccattg
-agggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatggg
-atgcaagcactcgttaatgcttactttagttggttgcgggaacaacaggaggctatacta
-actggtagcgttcttgcttccattatgttattattataattaaaaataagacatatggta
-gagttgtagtcagggtggatcgggttgtctataacgttggaataatcaaaactatcgtta
-acaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacatt
-cacagcacacccctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatc
-cgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaa
-ttcactagtatcctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatc
-aagatgtatgatttttggtccgctgtgtggaatacctctattgatatacaagtgactttc
-tcggtaataacgcacttcacaatgtgttgtttcttttctatgtattttgcaagagaaaga
-agcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactg
-caggaggaacattatccaaattcaccacaattactaatccacccttttacttttactaaa
-gatatattaattctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaa
-ggataccaattgaagtcctcgaggcatgttacaacacacgacttccttccgtctattcag
-acactcaacgagactaacttttcctaggtaatcaatgatattgggtaactcgtggcatct
-tatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactg
-gctctcttgcgcaggggatacgtttattctacgtacccgatttggttactactaagcggc
-ctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagcagggaagggtta
-cagggagagacttattgagatacgattggaatttccatgtacaatcgttaatacgcttgt
-agaccagcaactcagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaa
-taagaaattactaaaaccctagttgttaatataagaacgattcgaaacaataggattgcc
-caagggggtgcgaacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgt
-ttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggc
-ttattctactttttccgacactcaatggacgagacaaacatgaacggatagctttaggtc
-tcgttgaatgcaaagaatagaatcgttattattaatcggtttccattatctatatgcggt
-atagatctccgagaggaccctgtaaactagctctgcggtttaactggtgctaatagaccg
-ccactatgttattgcttctagctcctagcgtcttatcatgttatacattaatgtcgcata
-ttggacagtagccaggcttggatggatcgccgacaaaaagaaaagactttccctgtaagg
-acttaactattacatataacttggatcattaatctgcaaattagagtaacggtctttcac
-cagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattgg
-cagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttgcataaatatctt
-atcgatattcaggttattaccgattccttgctaacgctagaagtcacaccagagtaataa
-taattccagacacctgtgaaataatcggtcactacggatagactagtaacgataatacgt
-atagtccataaaagttgaattttaggggctaaagatattagcaatactggtctagcctaa
-tcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaattgtatcgatag
-gaatagttacagtcacgcttgtagatgtaagagatgacgttattcttagggttcttaagt
-cggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaaacgatattttga
-aatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattttagtggcaacct
-taacggttgaattgatctactaatacaggcctacaccgaagggtacagataatgattctt
-actaccctaacatgatagagtcctgtcctatctcataggtcgacattttaaattcgtaat
-gagcaacgaagatcgtttcccaatttgcaacattcacttatagacttcaggttatttcgt
-gctaacattaagatagaatataatcagtcgttaagaaactattatccagctttcgtcaac
-cataaagattaaaaactgaaacttggcaagatatgaatagctatcctgctttaaccgatc
-gtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagag
-tgcggtaattaatattaatatactattaagctacacagcaaaggctgcaataatgttagt
-aagtagaacataaaggtattctccacaagtaataaatagtgtgagctaattgactaactt
-aactctcgcgacaagtgatgtggataagatgactcatatcgtctttttctgtagtgccga
-catcccacctggatcgaacaattccttctagttatcgactttgattacctatcctattaa
-acagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagt
-tagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatgagtctgggcgag
-cgtgactttctttcgtgtccgaatttgtttaacatccattagattagatgtttgtgtttt
-gggtctgatgtcctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagt
-ccgatgaagtctccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatt
-tagaacacaccttatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgt
-gagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagataagaatttctttc
-atacttcactggaatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcgg
-taaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtaca
-acgaacaaatagcatcaggccttcttatccagcgtgaagtctaattatttcacaagcttt
-cctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggatagaggacattgc
-atgtacgtaggactattctccaaggggtcttctattttgttagcgaaaattgttacagcc
-taatgttagagcggcgtacgactttataccagatactttcattagatatgcaaatatcca
-attaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgt
-ttttctagttcgttctcatatatatagatcaacaatgaataatctcatgatctataaccg
-atgtatatttatattccggttgactgctccggtgcaattcactacggacactaatgacta
-atatggcgcctttcatcagaaacgctaaatatgattaatgaattaagggagtattatcta
-attattagagagtagcagttagtctgatattttcggtgtatgtgttagccgttataatgc
-tgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttcactttatgactct
-ggttatatccctcggagaacaagaataagagtacgagaagttcggtcattgaggatgaaa
-tagaaccgctagacgaatggactcacgtttataaaactatgtatcacagtactacagcta
-actctgaagtccgagaagcttttgtaggacaaaacgttataagtacctttcgcagaatac
-ggccgtgcatacctgttataaggcgtagtagggacaccatgctatccctcatatagagct
-acactaataccattacatggtgactatcgtttacggccatcatctgtaagcgatcatgcc
-tcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttg
-agtcagaactattcgaagcttctcaatccttttccattatggcatagcaagtgacgactc
-gtcagccatgggaataatagcactaatccgattacttatgaattagaacccacatgaatg
-tgattctgcgaattgtctaagaatctaatgattttccggtgaatatggttgttgttattt
-attgaacttatattattaacatcacccttcgttagtgatagtcagctatttccaagaggt
-tccccgagcatttttaccattctctagtcatacaagttggagcgcttttaaatctttagg
-ctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttg
-catgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaatattcatagtaat
-aactacaatacttgatttgttacgtaatgctcgtacataacacaatcgtattccacggaa
-cagtaaagctctattattctgatcgagcctaagagaggatcacactacgctattaaagtc
-acgttcacgaaatctcaaacctcaactgctggtgaccagttatagacagtgtaattccat
-attacatgtcaggcttaagctaacccgagcctttatataagctataatcaagaattagat
-tggagtgcattttagacttatctatcgaaatagtgatagtaagagtttatatgacctgat
-ctagactgatgttctcttccacaacagccttaaggcgtggagcctttcttatactattag
-gtcgcgtcgagagccctattcgtaatgttaacgacactagactaatatacaatgagctaa
-gaataacacaagtcacaagataatttacaaatcatatatctacagtccacaaccatcact
-agcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaa
-ctggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaa
-ttgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagactatgcaactatt
-aacagcatgtgcgcattgaatatttggtgtcgattgataaatgccccaacgttccatcac
-gtctataagccgtgttactaatgtgtattagtgcatacctattcagaccatagttcaact
-gttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttcct
-taactgacctaaatgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagc
-caatgggctcccattgagctagtatggtgctttacctttgtaagtggtggctttccttgg
-tgtgctgactttaacacggcagagtgattatccgaagaatggataataagacgctggcaa
-tattggctaataaagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgta
-cctaaacctacatcgtatgtatttgctgacgttcattcttgatacataaagatccgatat
-cggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtg
-aaatacacgatggggatattgccggtgagtacaagttagaccacacattagaactgacct
-atattcgtcatcatagagatggagtatgaattgattctgcgaagtacactggctttacga
-gtatctagacgccgcggtatatctcccgtcaatactatgaaggtatatatatagaggctg
-aaaattcatgttcaatcctctttctaagagtgagtgggagccccttctgttgtcggagta
-aaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaa
-aagagttaccttagggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtg
-cgattaattcttttgatgacagatctcattattttatatagctccctctttgtatttaga
-gtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgctgaacattttat
-acgatgtgattactcaaaggataaggttcgaggcctctatactcatggaactatcttata
-attataatggatcgtggctcattccacctatccaaacttctttgtgatctgatgctacga
-gtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagctcgcatttcattc
-ctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaaggtgtagacaag
-cccttagtaaccggtggatgtcgcttcagttttatagcaaacattattcaatttcagtct
-tgactgaaattagtttgttagtgttagaggtccatatgtcacatgcatatggtctagatg
-ccattgtacagtaataccttagattagtattagcggcatgcgtacttggatttcacttgt
-aagaatgagcttaggacggtcgcctgtagggctgcaaataggaatacttacaatttttga
-tgacttgttagcatatcgctatcacccataaaaaacctgatacttgatgagcgggtgatt
-gagactatgtactgatataattcaatagctccaatagatgaaacagctatgcgcctattt
-atgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcgg
-tgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaag
-cttgagttcagttaaatttgcatctcatgccccacgaagaatgggtagagagtttgaagg
-tgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatg
-gttgtgttaaccacaaacccctgggtgaatctgattagccaacccagtgatctgatttca
-gttgtcaaatctcttttttataactaccttttgtttccataatttaaccggatctcataa
-tgaacaaacgggtagaataatggtagcacatagcgagcttgtctattcagaaatatggcc
-tactcagaatgtattctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatg
-atgatttcttatcggttccttgtactacaatactcttgcccaacaaatactaagcataac
-agcaaaattcgaatccccctccttttaataaatggtttttcaatatagccgattcgtatt
-cgttagtctttcaccaactattaacctggcatctaattaataaaatcaccaaaggactct
-ataatatgacagtcacttcggcctcttttaagacagttgattattgcaggtccgcaattg
-atggtgacatgcacaattagttagaatccgactatggagacaattaacaattgtagtgcc
-catttggtccagttgacttcaaccacgagttataaaggtattttaatttatagtcgatag
-taccaacaacaagcacaatcataattatgttagaaaacccagggggtaatgctctaaatc
-cagctttaaggccagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaac
-ttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagcaacgattatatc
-tggactagatcatgatgatcggaataaaacattgaaataagtccttatcaaggagcataa
-acattttatttaatttatacttcgtaaataaattcagaattttttttcaagacattaatc
-tgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagt
-aacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggctgccacttttag
-cttcttgacgatctttagcgtcatatttttagattagtcgaaaaacggaaaacaaactta
-acgaagctggttgcacggggtaccgagaaaccaaagagcaggacaactccttgatcggga
-agaactgaaatagacagctgtcattttcattggtcaacttatcaatataacgaccaccgt
-agtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttg
-actaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacgggttgccagcta
-cagatatactctaggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcat
-aatacttgtcacataaacaagatcgctgaattaaacattaaacagttagtgatacacaat
-cgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgta
-aatttagacaaacattattatttcttgacaatggaatcgataagcgttcctctaacttgg
-tatatatatctcgaccccgggattccagccattcttgtatgaagatttaaccatttaact
-atgcatagttgaatggtaaggaaaatgatattgactgcaacagattttggatgcaaaaat
-atttgtgaattattggttatatactggttgtatagcacaatcattaggtcctagaaggca
-tactcaacctcagcgagagagctagcatgcataattgtaccgcccatattaatattcctg
-aaatgatttcttacattacgcccaatttcagtcatcgaacacccccatcaatttacccga
-tagagaacgtgatcatacgcaataccctatgcgaacgtccactctatagcgtctgtatac
-aatgattattcgttccatttacaacgttaagtaatttaaacttacataaggacaaggaaa
-tccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaac
-taaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgtatccattgtggag
-aatatcataaattcaagatggggtgtcatgctattcggtcctaaacattcttaatggctg
-ttctattgttagtctgatttaaaatggaaccatagcacgaatagttagatagggctcata
-cccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttac
-ggtttgtgatcaaagaacactcacacgtcagattattacactgatacgaattatttcagt
-cgacagtaattgaatagaaacttattaacgccagcacctgacacggtaagtaaggcaggt
-ctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaa
-atgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacg
-actcacgtacaagatcacacatcacacgcgttagcgaaagcggaatggctaatacagccc
-tacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgagccaacctccccc
-gcattgcggttcattttaaggcctgggtaacatctatcgtttagataatcaaaggaatcc
-gactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttct
-ttaatcaataccatattgaaatcgtaatacgataattgttgctattgactacaggttatg
-aaaaaacttactttgcgggtacatgcatatttttgtaccacattattacgcgatatctct
-cagtgtactctaaattaaaccctcttcgaacattttagttcctattcgtaaacacgtgct
-acgcggcaatttgccggtcgtagaatggacaactccagttcaactgcatgtaactcatag
-ctcgcgttagtataaattgactagtagccatgggacaaagtaactagtcagcggaaaaga
-tccctttaaagatatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtgg
-tattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaatcgaaactactc
-tgatttgctgcacacgttaggtaatatcgcccattttcccgtataagctccgtacttata
-cgaactacacgaccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtc
-tattaaaattacagacatactccatatctcgctccttgaactttgaataatgcgctaact
-tgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacat
-gttgtcagatttatgattatctagttttagatcacgtttaccgataatcggctgtggtct
-gagcagtcctacactgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgac
-cgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagc
-aaaaggcttaaaccatttttacgatttttactatagcggtcatgaagtgcgaaactgctt
-gcaaattttctacacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaac
-atagtataccagggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccat
-atacctaacgccataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgt
-agcgctcatcagcacagactaactttttcagtttgagtcgccggagggacttcgagacaa
-gaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatt
-tctactattgtcagctgtacgactgtactaagtgtatagccccaaataaaagaagtatcg
-atgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaat
-cctggcttacccgattctccggaagtctgacctagagattgacgacggccgcgtattatt
-gagacctcttcaggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaa
-gccgactccgctacacgagtttctactaaaccaatgtagccttatgcttagatgaatacc
-gtcctaattagatattccggcataacagcagtaaattatctgttcaatggacgaacattg
-aattgttagtattctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataac
-ctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtg
-agggttaaacaccagcatattctatatgctagacgtcttccttaaaggatcgtagtatta
-taattaataataagaaatatggttgacgtctagtcagcgggcatacgctgctctatatac
-tggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgag
-ccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaata
-aaaaaaatgttaatagtacgtttacgacattttattttataataaagagaaactattaca
-cctattgatatgataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttc
-tacatggtatagacctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaa
-tctagtcatttactactgtctttcgagctattataccacttcactatgtggtgtttcttt
-gctatgtatggggctagtcaaacatgatgactatagctacaactcagagagcgggcgtgt
-taagagtatctcatgctagaactgcacgacgaacttgatacaaagtaacaacatttacga
-ttccacaaggtgactttgaagaaacatagtttaattctctgcttcgatcatttctataaa
-ccggtaccatcgcagcggatagatgcataacatttctactactccaggcatcttaaaaca
-cacgtagtacttcactagattaagacacgataagtgtataacttggcagtgggaagcaag
-gagattggcgaactcctggcatctgttacgttttgttcaggctcggttgttgataatgtc
-cgactcctgccatattgaagactcgctcgagggagatcgggattcgttgattataagtac
-acgtgttccgtaatactatgaggcagtgattcaaaatggcacttctgacttacatgacta
-ggtattattaccacggaagcgttaaaggcacactcttatggacttaagattgcaagtgcc
-ttcttctagcctgaattcgcgggttcaacacaaactctctttagacatccgttgcctaaa
-ggctgagacgtaggggcaaccctttaactatgtactaaaaaactagttggtaatttaaca
-acgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaa
-taggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggct
-ctaagagaataacctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaa
-aaaagctaagcatacatttaggtctcctgcattgcattcaattgaatcgtttgtattatg
-agctgtacagtagctatatcagctatagttatcccagaggaacaggtaaactagctctga
-gcgtgaaatccggatattagaacccctagatgggattgattctagctaatacaggcttat
-ctggttttacagttatctagatgattggtaaggtgaaacgcttggtgccttccaccactt
-aaacaaaagtattgcccgggaagctattttctaggtattataaagtcgagcattaatatc
-aatttgacagtaaaggtctttcaccagcttcatatgccatagggcccatactcgatttaa
-attgaacggtttaacgagtattggaactctcacttataactgagtagctatacgaaaaat
-ctggtccatttccagaaatttattatcgatttgctgcttagtacccaggaagtgataacc
-cttgaaggcacaacactgtaataagttttcctgtcacatctgtaatattcggtcactacg
-cattcacgactaaagataattactatactaattaaaagttcaatgttagggccgaatcat
-agtagaaattctcgtctagcctaatcggacttacctatgggctgtgaggatttatcagta
-tgtggacaaaaatgctagagataggtatagttaaagtcaccatggtacatctatgtgagg
-aagtttgtagttcgcttctttagtccgggcgtttgggatgacaactactatacgtagagc
-cgtactcaggattagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgt
-tgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaatacaggccttcac
-cgaaccctaatgataatctgtcttaataacattaaatgattgtctccgctacgagctctt
-agggcctcattttaaatgactaatgtccaaagaagagactttcccaatttcaatctgtca
-cgtatagacggcaccttagtgagtcatatcattaagatagaagattatcaggagggaagt
-ttctattatcaaccgttacgcaaccataaacttttaaatctcataatggcattgagatca
-agagctttcatgatggtaaagttcgtatgtgatgctggggagctagatatcggtatacca
-cttcggttgtggtaagcccgagtgggccgttagtaatattaatagacgattatccgacaa
-tgcattcgctgaaataatcttacttaggagaaattaatgctatgagccaaaactatttat
-gtctgtcacattattgactaaagtatctatcgacaaaactgatgtccataagttgtagca
-gatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatc
-caatttgagtaaattgcctattatacagataggcttgtttagtcagataaggttccgctt
-gaggtgctctaacttagcgagagttagaaagcctagtgagaggcattttggtgccaaact
-ccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaagttggtgaacagc
-cttttgattagttgtttgtcttgtggctatgtgctactatataagttagaacgcaaacta
-atctaatcagcaaagtaaaataggaccttgaacgagacggggtacgccgttgaggctcga
-gatagtagataaactagaggaatgtagataaaacattagctagggggtttagttactgga
-ttacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattg
-tcagtggacttaacaagttcgtgcataatgaaatcctatacggactttgcatatctctac
-cgactcatctggtcgtctatgcgggtaattgtattgctccaagtggatgactattttggc
-gtcccagcacatagtaaatgtaaatccttataatagcataagcaattattagactgcgtg
-aagtcttagtagttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtcc
-ccaaatcaccattgaggtcattgaatgtacggagcactattatcaatgcggtatgcgatt
-ttctgagcgattattgttaaagacttagcgttgagccccggaacacttgattacagattc
-tttaaggagttatccaaatatcattttaaataatagtagtatcgtgctttggacaataaa
-aaaagacccgttctcttatgttgttttgcgacgtacttctctgatatatacttcaactat
-gaagattctattcatcgataacccaggtatatttatatgcccgttcactgcgcagggcaa
-attatctacggacaataatgacgtagttggacccggtaagaactaacgcttaatatgatt
-aaggatgtatgccagtattatcttattatgtcagagtagaagtttctctgagattttccg
-tcgttgtggtacaccggatttggctctctttttagaactgagaactcggagtgtgtagtc
-ttgtttccttcaatttatcaatatgcttttataccgccctcatcaactataacaggacga
-caagttccgtcttgctccatcatatactaccgatacaccaatcgtatcaagtttagtata
-cttgctttctctcttctacagcttactcgcttgtccgagaagcggttggtgctcataaag
-ttagtagtaaatgtacaactagtagccagtccttacctgtttttacgactactacggaca
-ccatgagatacagaagttagtgctacaattataccattacatgctcaatatcgttgtcgg
-ccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatg
-cacaaaaacacactccccttgttgactaacatcttttacaagaggctaaatcattgtcca
-ggatcgaataccttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtag
-tatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaatatattcatttga
-ccgtcattagccttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtgg
-catacgctgcgatttcatacagctgccaacaccttttttaccaggctagagtcagaaaag
-ttggagccatgttaaatagttaccatcataaaccactgttgtctactagtctgatcagct
-ttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactgttgcgttactta
-ggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaa
-agtacacaagcctaggaataggaaaagtaaagctcttttattctgatagtgactaactca
-ggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgac
-cagttatagacagggtaattcaatatttaatgtctcccttaacatttcaccagcatggat
-tgaagatagtataaagttttacatggcagtcattgtgtcacggttctatacaaattctga
-tagttagacggtatttgaaatgtgcttctagcatggtatcttacacaactgaatgaacga
-ctggagccgttcgtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaat
-atagtataatataaattgtgatatgaataacacaagtaactacagtttggacaattaatt
-gttctaaactaaaaatcattcacttcagatggcatagagttatggctactacacatataa
-agcggtatgtgaaacacccgttttagccggaaaccctctactgctcgggacaatgaatga
-tttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaatagacactttag
-tttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatttggtctacattg
-agaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgtctattactgatt
-aactagtaagacattagtgcatctggtccactgaagcacccgcttggcgttaggcaatct
-ctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagt
-cgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggttcgtcctttacc
-ttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagactctttatcccaa
-gaatggataatatgtacatggaaagtgtccataattaagtcccttcactgtaaagaatga
-ctgccacgtgatccatgaggtctacagaaaccgacttacttgctttttgatcaacttaat
-tatggattcataaagttcagatatcggtacaattggtgtacaatatgaaattaatgagga
-aacatggaaatctgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgt
-tacaccactcattagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgttt
-atgccttcgaaactggatgtacgacgatcgagacgaagaggtatatataacctaaatact
-aggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggcgaacactgaggg
-ggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagt
-agaccggatctttgcggagaacaattcacggaacgtagcgttgggaaatatcctttctac
-cacacatcggattttcgccctctcccattatttattgtgttctcacatagaattattgtt
-tagacatccctcgttgtatggagagttgcccgagcgtaaaggcataatccatataccgcc
-gggtgagtgacctgaaattgtttttagttgggatttcgctatggattagcttacacgaag
-agattctaatggtactataggataattataatgctgcgtggcgcagtacaccgttacaaa
-cgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggt
-cgtttcatagagcgcattgaattactcaaaaattatatatgttgattatttgattagact
-gcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgaga
-gcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccata
-ggtcactggcatatgcgattcatgacatgctaaactaagaaagtagattactattaccgg
-catgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgat
-aataccaatacttacatttggtcagcaattctgacattatacctagcacccataaattta
-ctcagacttgaggacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatata
-gatgaataagcgatgcgactagttagggcatagtatagatctgtgtatacagttcagctg
-aacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaaccatatcgttcaca
-catgatatgaacccagggggaaacattgagttcagttaaattggcagcgaatcccccaag
-aagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcctccgtataagtt
-gagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatg
-agaatacacagtgtgagcatttcacttgtaaaatatctttggtagaacttactttgcttt
-aaatatgttaaaccgatctaataatctacaaaacggtagattttgcctagcacattgcgt
-ccttctctattcagatagaggcaatactcagaaggttttatccaaagcactgtgttgact
-aacctaagttttagtctaataatcatgattgattataggtgccgtggactacatgactcg
-tccacaaataatacttagcagatcagcaattggccaagcacccgacttttatttaatggt
-tgtgcaatagtccagattcgtattcgggactctttcaaataatagtttcctggcatctaa
-gtaagaaaagctcataaggaagcgatattatgacacgctcttccgccgctgttttgaaac
-ttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatc
-gactaaagttaaaatgctagtccacagttggtcaagttgaattcatccacgagttatata
-gctattttaatttatagtcgagtgtacaaaaaacatccacaataagatttatcttagaat
-aacaacccccgtatcatcgaaatcctccgttatggcctgactcctcgagcttatagcatt
-tgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtt
-tcattatgatgatacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaa
-ttatgtcattatcatgctccattaacaggttatttaattgatactgacgaaattttttca
-caatgggttttctagaatttaatatcagtaattgaagccttcataggggtcctactagta
-tcctacacgacgcaggtccgcagtatcctggagggacgtgttactgattaaaagggtcaa
-aggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatgagttttacatta
-gtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaagagaatacatac
-accaccacatagaattgttagcgatgatatcaaatagactcctggaagtgtcagggggaa
-actgttcaatatttcgtccacaggactgaccaggcatggaaaagactgacgttggaaact
-ataccatctcacgcccgacgcttcactaattgatgatccaaaaaatatagcccggattcc
-tgattagcaaagggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgt
-aatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatac
-aggttaatgttagtgatacacaatactcgtgggccatgggttctcaaataaaatgtaata
-ttgcgtcgatcactcacccacgtatttggtctaattatgttttatttagtgacaatccaa
-tagataaccggtcctattaagggctatatttttagcgaccacgcgtttaaacaaaggatt
-gtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaaatgagattctat
-cctaaagtttgggcttgatataagatttcggatgtatgggttttataatcgttggagagc
-tcaatcatgagctaatacatggatttcgctacctcaccgagagaccttgcatgaagaatt
-ctaaccaaaagtttaataggccggattggattgagttaattaagaccttgttcagtcata
-gtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaa
-cgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaatagttaactaatt
-taaaattaattaacgacatggaaatcacagaacctaatgctttgtaggagttatttatgc
-tgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagtt
-cagaaagtggtatccagggtggtcaatttaataaattcaacatcgggtctcaggatattc
-ggtcatataatttattaagggctcttcgagtcttactctgagtgaaattggaaacagtca
-tccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtg
-tcccgtacacaaggaaacttgttaccttggggatataagaaaactcacacgtctcattat
-taaactgagtacaatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagct
-aatgaaaagggatggaacgcacctcggatctgttgcactggattaaaatccgattatttt
-taaaaatattcagtgctagagcatatcaggtctacttttttatctggtatgtaaagccca
-cggagcgatagtgagatccttacgactcaacgaaaagttataacataactcccgttagcc
-aaagcccaatcccgattactgccctaccctaacgtctgccatctaaatatcgaacttgtt
-atgatcaatgtgactacctcccaccctttccccttcatttgttccactggggataagcta
-gcgttttcagaatcaatgcaataagaatagccaattgtctcacttcatcagagctcttgg
-caattccaggcgctacgtggttctggaatatattcatttttcaaatagtaatacgtttag
-tgttgctattgtctacacgtttggatattacgttatgtgagcggacatcaatagttgtct
-aactctttagtaagccagagatagcactcttagcgaatggataccatcttccataagttt
-agttaatagtccgaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcc
-tcttcaaagcaatcttactaatagatagagtttgttttaagggactactagaaatgggac
-aatcttaatagtatgacctaaactgacatttaaagatatatccaggtggcaagcataaag
-atcattgcgccacctccaccgtgggattacttatcagtcgatatcctatatgctaagttt
-gcgacggcagaatacaaactaagctgagttgatgctaaccttacctatgataccccattg
-gaccggttaacagccctacttattccaaataaaagaacttttatgctgtagaagctatta
-tagtgatgcctggtaacttcagtatattaaaatgacacacatacgccatatagagctcct
-ggaactttgaataatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggtt
-gcctaaagcccggtaaccagacatgtgctatcattgatcattatcgaggttttcataacc
-ttgacccattatcggctgtgcgcggacaagtacttaaatcactagtttcttcacctgctt
-atcggtaagaaataaggttggcaaagaatcgcataagacggacgtagagccgcagcgttg
-tgcgagtccaggtgcatgcgcagcaataggattttaaattttgttccatttttaatttag
-ccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggcctatgctactgg
-aacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgtatttttgcggcta
-gaatagtcagtcgcttggagccatataccttaccacttaaacgacgtgctcctgtagttg
-aaatataaacagaacacaaagactaccgatcatatcaactgaagatctttgtaactttga
-ggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgat
-tgggaccctaaatcttgacgaattgctaagaggctcagagctaccactgtaatttctcta
-gagcccataataaatgaacgatacatccgtaggtagcacctaagggattataatggaagc
-caaatgcagttaataatattatatactggcgtacacgattcgacggatctctcacatagt
-gattcacgacccccccctttgattgacacagcgtcagcattttgcaagaacgatcttctg
-catagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtataatttaccatgc
-ttccctgatgctgagtgcaatacactaagaatgagtttttaccccatatcaccagtattt
-gttctgttattgcgaagaaatggctatgctgagttggcgactaaagtcacccatcctttt
-tattaggtaaccccctcccttaaactaactgatttgctggagctgccctgcatacatata
-ctttatcatttatggacgtccgtgacgcttattatccaccatagtcgatatgctacacgg
-attcattaatggatcgtaggagtttaagttatatttactaagatcggtctcggctactat
-cccgccttacccggcgctatttacggccatttttaatatattgacggtaattattcctat
-ggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaa
-atattgagtccctaccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagt
-ggttattaaagactatctattacaccttttgttttctgtcgtagtatattaaagtctaga
-agccttacaggaaaatcagggttatacagccgatactccgcagcatgaatcatcgaggag
-gtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatac
-aaagtaaatatctcggctttatgtgattgggaggggcctactcaaacatgatgacttgac
-ctaataatcactgtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatg
-gttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaatt
-agctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttc
-tacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactg
-tataaagtggaagtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttct
-taaccataggggcttcttaatggcccactacgcacattttgttcaagcccgagagggaca
-tccccattacgggagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaa
-ggccactgctcaagttattgacgtgggagtattacatcggaagcctgaatcccacactat
-gatggtctgtacaggcctagggactgcgtctagacggtattaccggcttctaatcatacg
-atcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatttatctatgtaag
-tataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcac
-ataagccgctttagatttcacaaataccaatgcggttaaaaacatccttgagtcgtacat
-acaccatactcgcgttaaacggatataacagaagataataaatccggatgtggagtcggt
-gtaactatagaaagccaagtgaaataatgcttaccagtcatttagctatacggctttcat
-ttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccgatacttagaact
-cacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggat
-tcattatacataagacacgatgatctgctttttcaggttgcgagatgttgcctatcgtca
-atcgagtcctgccttacaccacttaaacaaaagtattgacagggaacctattttcgaggt
-attatatagtccagcttgaatatcaatttgacagttaacctagtgaaaatcagtaagagg
-aaatacgccacattctccagtgaaattctacgggttatcgtctagtccaactatcaatta
-taactcacgagatataagtaaattctcgtacttggcctgatttttattatactttggatc
-cttagtaaacaggaagggagaaaccttcaacgaaaaacactggattttgttttactctca
-aagctcttatatgacggaaataccctgtcaagtcttaactttattactagactaatgaaa
-tgggcttggggtggccagaatcatagtacaatttagcggatacactattcggactttcct
-atcggctgtctggttggataagtatggggactaataggctagacatacctatacttaaac
-tatacaggcgtcatctatctctgcaactttggagttccctgatgttctcccgccctttgg
-gttcacatcttctataccgacacccctaataacgattagtttgtgggttagagtaaatta
-atacggttaatattaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctag
-gcagagtatatgtcacgaagtataactaccctaatgataagctgtaggaataaaattaat
-gctgtctctaagcgaagagatatttccgactctgttttaatgacgaatctcattacttct
-gacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacgcatataatgaac
-ttagaagattataacgacggaactttatatgataatccgttacgattaaagaatctgtta
-aatatcataatggcattcagttctagaccgtgcatcatggtaaacttactttctctgcat
-ggcgacatacatttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaa
-tattaagagaagatgatcagaaaatccattcgctcaatttttctgacgtacgtctaattt
-atcctaggagacaaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaa
-tactcaggtcctgaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcg
-tgacataaatgaatgatacttttccaagttcagttaagtgaatatgtttaacatacccgg
-cttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctcttacatacactag
-tgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtatt
-gacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgcta
-atatataagttagatcgcattagatgctaatctgaatacttatagacgaccttcaacgag
-aacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagggacatataaaat
-ttgagtgcggctttagttaagggtttaattacctactcaaacatcacgctcgcgcccttc
-gtacgtaatcgaccatctagaggctaaggggactgtactaggtagtgattaatgatatcc
-tagacgcacgtgccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtc
-ctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaatacttataatac
-aataaccaaggatgagaatgactcatcgcgttggagttatattgcttgaagttctatgga
-atgaaagcacgttatctgccgtcccaatatctccagtgagctaattcattggacggtcca
-ctttgatcaatccccgaggagatgttcggacactttagtctgtaacacttagcgttgaga
-ccacgaacaattgattactcagtcttgaaggtgttttccaaagttcattttaaataagac
-tacgataggcctttcctattgatataaactacccggctctgttgttcgtgtgagtcgtac
-ttctctgtgtttttctgattatagcaagattcgattcttagtgtaaacagcgatttttat
-ttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagttgtgccacaagg
-taagatctttccagttattgcaggtaggatgtatcccacgttgatagtatgaggtctgac
-gtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgaga
-acgcagaactcccactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaag
-ccctcatcatctagatctcgacctcatctgccctcttgctccatcattttctacacagac
-tactttcctatctacgttagtataattgctttctatcttagtatcatttagagcttctcc
-gtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgtagcaacgcattta
-atcggttttcgactacttcgcacaaaatcagataaagaagtttgtcattctattagacat
-tgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaagactgtgattaa
-ctaaaatagacaagccactatatcaactaataaaaacgcccctggtggtcgaacatagtt
-gactacaggataattaattggactggagccattacattctctacaatcgtatcacttccc
-aagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacat
-tggtagttcaatagtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggata
-gtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttg
-gttaacaggatagtctatgtaaacttcgagacatgtttaagagttaccagcttaatccac
-ggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgtta
-tcctatcaacggttgccgtactgagcagccttattgtggaagagtaatatataaatgtag
-tcttgtctttacgaagcagacgtaagtaataatgacttggaataccaaaactaaacatag
-tggattatcatactcaagaactctccagataaataacagtttttacgatacgtcaccaat
-gagcttaaagattaggatcctcaaaactgatacaaacgctaattcatttgttattggatc
-cagtatcagttaaactgaatggagtgaagattgtagaatgttgttctggcctcgcatggg
-gtctaggtgatatacaatttctcatacttacacggtagtggaaatctgattctagcttcg
-tagctgactatactcaaggaaccactgctcaaggtaggagactagttccgaccctacagt
-caaagtggccgaagcttaaactatagactagttgttaaatgctgatttcaagatatcatc
-tatatacagtttggacaattatgtgtgcgaaactaaaattcatgctattcagatggattt
-cacttatgccttagaaacagatattgcccgagctcaatcaacagttttagccggaaacaa
-tcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtca
-cgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgca
-gcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaac
-tctgaagtagctcgagtactcattaaagtgtaacacattagtgaatatcggccaatgaac
-caaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaa
-agcatccctttacgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaa
-attctcatacgtgcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtg
-ttataccaactcgctttttaactactatgctgtagttctacaggcatagtggccagtatt
-ttctaacttctctggatagatgctctcactcctcatccatcacggcttcagtttacgtct
-tacttgcttgttcagcaacggatggaggcattaagtatcttcactgttccctaaaattgc
-tgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactcattgaatactgc
-cccagttgcaacctcacttaatctgacaaaaataatgactactctaagtgttgcggaagc
-agtctcttccacgagcttgtctgtatcacttcgtataggcatgtaactcgatagacacga
-acaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcgg
-atataagctggagatcactcacgcccacacaaggcgctgctacctctttattccaatgtg
-taagaatttgctaacttcatttctagaccgcagctttgcggtcataatttcacggtacgg
-acccttgggttagagacttgataacacacttcgcagtttccaccgcgcacatgttttagt
-ggcttctaacatagaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccg
-ttaagccataatcaattgaaagccccgtgagtcacatctaattggttgtactgcgcattt
-agctatcctttagctgactcgaagagattcgattcctaatataggttaattagatggctg
-ccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaatta
-cttatgagtagttccaagttcgctacgttatgagagagattggaattaagcaaatatgtt
-ttatggtgattttgggatgagaaggactgctaagtacggctactaaacaaatttctaaaa
-ccgccatctaccttatcttggagacatttaagttgtatatgtcactagtctagcttttgt
-ctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatct
-aagaaagtagtggactattacaccaagcacgaatgccagggaactgctttcttgctcagg
-acctcgcgacaaggtaccccgcataagtcctagaattacatttggtcagcaatgctgaca
-tttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttgctctagatctta
-tctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtgagggcttagtat
-agttctctgtatacaggtcacatcaaactccccctgtcctagtacagctctgagctttaa
-ttaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcg
-tatagggcaagagaagcaacaaacaactagcccgactcacgttcatccgccgtatccttg
-ttcagttcttactccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatca
-aaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttatcggctattagat
-agtggggtgaaagtaattggctggaattatgttaaaacgtgatattaagctaaaatacgc
-tacttgttgccgacctaattcagtcattcgatattcagttagagccaagaataacaagct
-tgtataaattgaacggggtgcactaaacgatgtgttactctaatattcagcttggagtat
-acctgaaggcgaattcatgtatcggccaataataagacgttgaagatcacaatttggact
-agcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagtacggtctctgga
-aaattataggttcagggaatataaggaagtaaagataattaccaagagatttttggtatc
-gctatgacccagaggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgca
-tatttgacggacttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaac
-ttcaattattactactctttttttcctagggtattgtagaggccagtggacaaaataaat
-caaatttaagatgtttcggacattaacatcccccgtagcatagaaatcatcagttatcca
-atctctcatcgagcttttacaatttctgctggcgctatggacagcatatgccgcgagacc
-tccgcaagactcacttgatcactgtaagtatcttcattagaggttagagcctatagttaa
-gctgctgacctagtaaaattggtattttctaattttattgctcaagttaaaggttagtga
-agggataatgacgttatttttgaacaatgggttgtattcaattttatatcacgaatggaa
-cccttcattcccggcataatactagacgacacgaacaagctccgatctatcagccaggca
-cgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaactt
-agggtcacgatgagtttttcaggactacttattacctattaataagttaacatgagcctt
-cataccccgtaagacaatacatactccaccaattagaattctgagccatcttatcttttt
-gtatcatcgaagggtatggccgaataggttaattagttactcctaacgtctctacaggca
-tgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagca
-tcaaaaatatagtccacggtttccggattaccaaacgcggcaaagagaaacattgtatcg
-acggagataacttaatacagaaggaaggggcatcttcgaatacggatgaataattctatc
-tgtttattctgacatcttgttttcaggttaatcttacgcattcaaatgacgcctgcccca
-tgcgtgcgcaattattttctaatattgacgagagcaatctcactccttttgggtctattt
-atgttttattgaggcacaagcctatacagaacaggtactattaaggccgtgagtgtgaga
-ctcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggca
-atccttaccaaaatcagatgctatccttaactttgggctgcatttaagatggcggttgga
-ggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagat
-cacacactcattccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagt
-taagtaacaacttgggatcgcatacttataaaaattatatgttaaactttcacaaacgct
-gaagtccaaagtaactagcccaaacgcctcgagagtcactaggtattaatggtgtttgag
-ttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaata
-aggcttgcttgcacggaggtatgatgtttactgactctacaaccctaattttccagtacg
-tacattcattccaataggttagttctcaaagtgctatacaggctcctcaattgatgatat
-gcttcagccgctctatggatattagctcattttatttaggaagcccgcttagaggcttac
-tatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttaca
-tagaatttgaattaaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatat
-tacatatagatataggatcattttttaaagctgtactaggtttgatcgacaatcttatgc
-tatactatatgatgtaaccctcataatcaataccgatcgtacgatcctagcataggtggc
-aagcgattttatgccgattattgtgttaaatagtctgtgagtgtgattatcagggctacg
-ttggtagaggggttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaa
-ctgatataataaatccccttacccaaacaccaatcccgttgaatcaactaccataacgtc
-tcccatataaattgcctacttgtttgcataaatctgaatacataacaccattgcaccttc
-ttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaacaatagcatttg
-ctagcaattattaacagctcttcgaattgcctccacataacgcgggagggtatattttaa
-tttggcaaatactaagtactgttggcgtcatatgctattaacggttggatattaagttat
-gtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagagcactcttagagt
-ttggatacaataggccatatgttgacttaagaggacgtaactacgccgtacaccattgtt
-caaccgacttcttggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgt
-gttagggtatactacaaatccgaaaatcttaagaggatcacctaaactgaaatttataca
-tatttcaacgtggatagatttaacataattcagccacctccaacctgggagtaattttca
-gtagatttactagatgattagtggcccaacgcacttgactatataagatctggggatcct
-aacctgacctatgagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagt
-aagttgttgctgttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaa
-acaaatacgcaatttagacagaatggtacggtcatgaatgacagtaattcgaagtgctag
-accaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatgg
-tgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagta
-tatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaaactttcgattta
-gtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagttta
-aatttggttacatggttaattttgaccgaagcatcgcactttatgattgataattggatt
-caatatgtcgccctatgcgaatgcaacatgatccacaatttggctataagacgtttaatc
-cgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaa
-ttataagtactccgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatc
-atctgaagatatttggaactttctcgacaaccaccctcgtactcaatacttacactaatc
-gacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcga
-tgagcgtacacgcttatttctctagtcacaattagttatctacgagacatcacgagggag
-caaataagcgatgttatggctacacataggcacgtatgaatatgatataagccagttaaa
-cagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaa
-gctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggatcaactagaagag
-aaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtct
-gtgtaaccaatataacatctatttgttatctgattgcctacttatggctttgcggtcgtg
-gcgactaatgtctccaatccttttgaggtcggtaccaactccctttaaattacgctgtgc
-aggctcatgcactgcatacatatacggtagcaggtagggacctcacgcacccttattata
-atcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattt
-tctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaagccaattttgaa
-tatagtcaacgtaatttttactatgggttccaccgaaacgccttgcacaactaagaatcc
-cataaaatatcgatatcaaataaaagattgtgtcaataccttcatatatattttttcggt
-tgactaacgtgaactaaggttaggggttttgtatgtctatataggaaacagtttcttttc
-tgtcctactttagtaaagtcttcaagccttactccaaaatcacggtgattaagccgttac
-tcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgt
-attagctagggagacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcg
-catactcaatcttcagctcgtgtcattataatatctctcccccacgcttttcactagata
-tgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctg
-taggggtacttaatgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagcc
-ctcacctgacttcatgtaaatggcttagaagactccatgatttaataaatactacgaagg
-aaagactggatctaaagataactctagtaaggccaactcccttcaatgctgttgccagtt
-ataatccaagagctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaa
-gttggttctagccagacagccacataccctgtacgggtgtattactaaaactggtccggt
-attagttcaccaagggaggaattaggcaaaggatctaggtatgcaagtcggagtattaca
-tccctaccctgaatccatcaataggttcctctgtactggccttcgcaatgagtattcaag
-gttgtacagccgtataataataagatagtgactatgaacgggaagtaacccgctcacctt
-ccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaatactcgaaaata
-aacaactggcaaattacaccgcacttaagccgcttttgatttatatttttccaatgcgct
-tttaaaaataattcagtcctacatactaattaagacccttaaacggagatatcacaagtt
-aagttttaaccatctcgactaggtggaactatagatacccaactcaatttatcattacct
-gtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttcacagcgaaactt
-cagtgtgaacagattctgagaaatcacctaaacctattagtcagagcacccggttagaac
-cagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgagatccgttgtaac
-gttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactag
-gcaaacccaacataggttagtcctatgtgatacgccacatggtatatcattttgtaacgt
-tacctagggataatcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggtt
-atagtctagtccaaagataaaggataaagcacgtcagagaactatattagccgaatggga
-atcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaa
-aatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtacctgtatactagt
-tactgtattacgtgtctaatgatttcggattggggtccccagaatcagacgtcattgtag
-acgattcaagtttaccaatttaatttcccagctctccttggagaactatcgccaataatt
-gcagtcactttccttttctgaaacgataaagccgtcagagttctctgcaacgttggactt
-acctgaggttctaacccactttcggttctaatagtagttaacgacacaacgaataacctt
-tactgtggggctttcacgatattttttcgcttattattaatggttacgtcataagctggt
-gtccaaattaaggttaccggcttcgcagagtagttgtatccaagtataacttccctaatc
-ataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtg
-gtatggacgttgctaattacttctgaagggaaattggtcattatggatacgtgtctacca
-tcaggtcggacgcagatatggttctgtcttcagttgatccaccgttctttataggataat
-aactgacgattaaagattatggtaaatagattaagccaattctcttcttgtcagtgaagc
-atccttaactgacttgctctgcagcccctcatacatttagctattcaaagtaccggctcg
-tttcaaactctcccacctttggaagaggttgtcaacttgataagtatatcatttacagca
-ttttttcggacgtacctctaatgtttcattgcagaaaattagttttttctatcgcacatt
-ttgcaagtaacgttagagacacaattatctgcgaatgaactgctagatctgacgaccggg
-agcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggta
-agtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagta
-atgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattc
-tcgagcccactcacgatatgtagggacgacaacttgtgcggcttatgaattgtctggact
-gcgggcgagggtccatatctccgaagttagaagggacatacctttagatgataagatcaa
-ttcttattgacgaaattcatccacaacggggaacaacttcaccctagacttacgtctgaa
-aagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctac
-gcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgt
-actacggaggcatgaatcatatactagaaccaagtgcctgtgatattaacaagatgatcc
-gacgcgagcaccgtaattctaggcataaaactccagcaatttgggggccgaaaacaaatg
-acgttagctaattaattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgac
-gtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctg
-tctcctatttcatgcgtacctcctagttgataattccccgagcagtggttaggacacttt
-tgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgt
-gaattagttaatttttatgaagtcgtcgagacgcagttcctattgatttattctaaacgg
-agatgtgcttcgtgggactcggaagtagatctgtgtttatgattattgctactttagatg
-ctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacct
-atagtttcaagttctgccacaaggtatcatatttacagttagtgctggttgcttctttca
-aacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttc
-aaccctgttccagagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgat
-agtttgcaagagccggtgttaaacacatattattattgttatccaactaatcggacctat
-gcataaagcattgtctaaacagaataattgcctatatacggtagttttagtgatttatat
-cttagtatcagttagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaag
-cgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctataaatcacagaaa
-gatctgtctcagtatagttgaaatggtattcagctagtgacgtgtaccaattatcatagt
-tcactcaagcaagacgctcattaacgaatatagacaagacactatatcatataataaaaa
-agaacatggtgctcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaa
-ttcgctactagacgatcaattccctacttgtcaaagttgaactggtacgttcttggaatt
-aaatatgattgcgctggaccaaattgcgacttcttgagtttcagggcaaacgattgagcc
-ggaggatgtccgtctcttacctttcttgcttatgataaacgacggtccctgtacatcact
-gggaattctcagcaaaaataattgggtaaatcgagactcgatgtattcggccacaaaggt
-gttagacgttaaagattattcaacggggcgataataggatcataaccggtatgcaagcgc
-attgaaagagccatgagatccttatccgataaacgctgcacggtatgtgcagccttattg
-tcgatcacgaatttataaatgtagtctgggctgtaagttgaagacctaagttataatgaa
-gtgcaataccaaatcgattcatagtggattatcagactcaagatatctcctgataaatta
-cagttgttaagatacggataaaatgagatttaagattagcagcctctaatctgtttcaat
-cccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttg
-attcttgttctgccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagct
-tgtgctaatctgagtatagattcgtagaggaatattatcaagcttccacgcctcaacgta
-cgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactatagtctagttgtt
-aaatgctcagttcttgttatattcgatatactcttggctaatttatgtctgagtatataa
-aattaatgatattaacttgcatttcacggatcccttagaaaaagattttgaccgagcgca
-ttataaacggttacaccgaatcaatagaagcatacccaatagctttctttgaatttattg
-cctgcgcaacttggctgactctctagatccgaataattctatatggtcgtgacgaaacta
-gttcattactgtttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaat
-tactcaatgatacgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaa
-atgtctgattatccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcga
-cgcgaggggaaccttatctaactatcattccatttaccgggtgactctcgatgcaggatc
-cgattgggataaattgcccagaaatggctcattcctgactaagggtaaggccgttctcag
-caagggaaccccgcgaatctaggcttataccatctagattgttaactacttgcctgtagt
-tctacagccatactggacagttgtttctaaatgatcgggattcatgctagcactcctctg
-aatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatggaggctgtatgt
-atcttaactgttacctaatatggctggtaattatcaaagtaaggaccttaatgccatagc
-gctagcaatcgctttgtatactgaccatgtgccaacctctcttaatctgtaaaatataat
-gtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctat
-agccagcgtactagtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctg
-tctctctacagcttattgatgaggattgaacatggacatatagctccccctcaaaagcag
-atgctacctctttattccattctcgaacatttgccgaacttaatttcgacaaacctgagg
-tcacgtcttaatttatcggtaacgtcacgtccctttgagactggataaatatattaccag
-gggccaacgagcaattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaaga
-cggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaacccccctctctcaca
-tcttatgcggtgtactgccctggtacatttcctgtacaggactccaacagtgtagattcc
-taagatagctgttggagttgcctcacgccagatcgaaaaactgaataaactagtgagctg
-agctgcagaaataccgcttaattacttatgactagttcaaagggacctacgtgatgtcag
-acattgcaaggaagaaattaggtttgtgcgtcattttggctggactagcactccttactt
-cccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtct
-attgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatg
-agcacagtatgcaattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggc
-ctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtag
-taaatgtccgaacctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcac
-ctaacccgattcctctacttagtagctttctttgattctcagaattgactgcaatatcac
-tgcacaattctgtgccattactagacttctctgtattaacgtctcatcttactaacactc
-gcctaggacacatctgagagtgaagtatttcaatacatttactgaaatcttcagttctaa
-aatccccgaataaggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccac
-tcaccttcatacgcaggagcctggggaacttagtaataactatttcggcagacaaagctt
-ataacaagttgccggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacg
-ctcacctggtataggctattagatagtgccgtcttagtaaggggcgggaattatcggata
-aactgatattttgataaaataaccgacttgttcacgacataagtcactaaggagatttta
-tctttctccaaagtatatcttccttggataatttcaaagcgctgcaatttaagttctgtt
-actagtttatgctgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataag
-aagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgta
-aactggacgagtaccctagatggaaaattatacgttaagccaagatttcgatgtaatgat
-aattacctacacatttttgctatccataggaacaagagctgttctataggctcgtggcat
-acgaacatttgctgccgctatgaatattggaagctcttcaactacagactctattcttaa
-ttgccgtcgaaaatgggccgaatcggctattattaatactcggtttttccgaggggattg
-ttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatttaaatacaacct
-tgcagacaatgaataagggatccaatctctcatactccttttacaattgctcatgcccct
-atgcaaaccttatgccgccacacctccgcaactctctcttctgaactgtaagtagcttca
-ttactggtttgagactatactgaagctgatgacattctaaaatggctattttcgaatgtg
-attcataatgtttatcgtttgggatggcagaatcacgttatttttgatatagcccgggta
-ttctattgtatagaacgtatgctacaagtcattccccgaagaagactagaagtaaacaac
-atgcgaccatcgttaagccacgcaaggctgtagctttatttcccgataacctatcttcca
-taaatagcggacagcaggatactgacgctcaacatcagtggttatggtctaatttttaac
-ttttaataaggtaacttcagcaggcatacacagtaactctttaatttataatcaaattag
-aagtctgacacttcttatatttttctatcatccaacgcgatcgcccattagcttattgtg
-ttactaataacgtatctaaaccaatccttttcaagctactgcctatattgtcaatatata
-caaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatac
-ccggaaatcacaaactttgtagacaacgagtgaaatttatacactacgaagggccagcgt
-acaagacccatgaattaggcgatatgtttattctgacatattggtttatccttaatctgt
-cgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaagattcacgactgaa
-atataaatacgtttggctatatttatgttggagggaggcaatagcctttactgttaaccg
-aagatttagccagtgagtgtgacactaaaacactggaataaatgcaggcgttcttctggg
-taaaaggtttagtcaatctcgcctataagttcatatagctctggatataattatctggcc
-catgcatttatcatggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtcc
-gaagtattccatgtacattaagatcactctctcattcatgcatcttggcttaacaaatct
-ggttgtccaagctttccaggcacgtatggtacaaattcggatcgaatacttataaaaatg
-atatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtct
-caagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagggattagttatgt
-tacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaag
-agactaacattattttcaacgacgtacatgctttacaatagggtacttatcaaacgccga
-gaaacgcgcctatagtgatgttatgattatgacccgatatccattggaccgaattttatg
-taggttcccagcgtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtc
-tctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaata
-cctttaggggtaacggccgctgatttcatatagatatacgataagttggtatagctctac
-taggtggcatccacaatcgttgcatttactatagctggttacaatcataatctataccgt
-tccttacatactaccatagcgggatagcgtttttttgccgttgattgggtttaagaggat
-gtcagtctcattatatccgattcggtgggagagccgttgttttcaaatcgcacactttgt
-gacataatgtacaagataacaaaactgatataagatataaactgtcaatatcaccttgac
-acttgaatcaaagtaaattaactcgcaaatataatttgactaattgggtgcagatttctc
-aattaataaaaaaatggcaccggatgggcttacaagccccttatcattcacttgtatcat
-gatttccaagaacaatagaatttgctagcaagtatgaacagagattcgaattgcatccac
-agtacgccggagcgtttattttaatgtggatatgacgatgtactgttggcggcatttgct
-agtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggt
-acaatctcagagaaagattacagtttggtttaaataggacttatcgggtcggaagtggaa
-cttaataagcagtacacaattgggcaacagacgtcttgcctattacaataggattacaat
-gcgttagatttcagacacgttcgtgtttggctattcgtcaattccctaaatagttagacg
-atcaactattatcaaagtgattctttgttcatcctccattcatgtaacagatggcacact
-acgcataacgccgaggaattttaacgagatttaagagagcagttcgggcacaacccactt
-gactttataacagctcggcagcataaacggtaatatgtgacaaatttccaaacgttataa
-gaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagc
-ctaacttatctattggttttgctataaaagaacaaagttacacagaatcctaagggcttg
-tttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaac
-cttaaaacaatgcgcagatattggtgatggtgactccgggtatgataatggtaactgttg
-accagcgcccacctcatcgaagtatagaaagtggttaggataaggatgagaccgaactta
-tttccggccataactttagattttctacctagtacacaacatcagggcggacacgaaacc
-gccatcacatcatataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcg
-aactttagcaggcatatggccattatatatggccccagagcagaatgctacagcagacaa
-aatttggatttatgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacga
-cagtgcacaaagtgtaagttacaattattactactcagcagcttctgcaatgataaaatc
-ttatcatacacgtcacatatgataatatctacttagggggaacgggctccacaacctaca
-tagtactcaatacttacactattcgacaggcacaccaaacctgtacagtcccaaaagatt
-gagtcaactttgcagtactgcagatcacagtaatagcttagttagcgagtcaaaattagt
-tttctacgagactgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgta
-tgaatttgtttgaagccacgtaaactgtacaaccttagagataagtctcaggctactaaa
-aacacgttgtggcactaacaggatcatggttgattcttacttattcggctgaccggccca
-ataagtaaccttcaactagaacagaataatcgggagtagtttaattcagtcaaggtgcag
-gtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattc
-cctacttatggatttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaac
-aacgaaattttaattacgctgtgcagcctcatccaaggaattaatagaaggttgatggta
-ggctccgaacgctccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcc
-tgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagataaaccatgaaca
-gcacagtgtgaacccatggttgattttaggctaccttatttttaatttccgttacacaga
-aacgaattccacaactaacatgccattaatttttcgatatcttataaaagatggtcgaaa
-ttcattcatttattttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttct
-ctttagaggtaaaagtggctttgatctcctacgtttggatactagtcaaccattactcca
-tttgatccgtgagtatcacctgtctaacatccagcattatgactcctcggcgaagaaaag
-acacacttcttagagtcgatgtgtattagctagggacacagttgtttaatacgatagtga
-gcccagggagggcagtgcgtcccccagtagatttattcagctagtgtaagtataagatat
-ctcacccacgaggttcaagtgatatgcagtcttagaataatacttatcctgaatttcgat
-attatgggtacttcaataatccgctagcgctactttatgtctcgttggacagcaggacac
-atggcagtcttaaacactaaagacatcacctgaatgaatgtaatgggattacaagaatca
-atgaggtattatatacgacgtaggaaactctggatatatacagtaatctagttacgccat
-cgcacttcattcctctggaaacttagaagacatcagctgtacgtggaggaaccagacccc
-cgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaatgacaatggaccg
-ctggagttcgtaaactcggaacgtagtactgcacaaacccagcatttagcaataggagct
-acgtatgcaactcccacgtggtaataccttcaagctatcaatatataggtgcctagctaa
-tcgcattcgcaagcagtattcaagcttgtaaaccagtataataattacagaggctctatg
-aaacccaactttccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgc
-ccgttctgttattacgcgaattgattctactccaaaattaaacacaaattatcaaccgtt
-tcatttatatttgtcaatgcagctgtttaaaataaggctctactaaattataattaagac
-acttattaccagatttctctagttaagtttgaaccagctcgactaccgcgaaagatacat
-tcccttctctatttttcagttcatctatgggtcagagaagcattgaatttattctattca
-ccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgt
-ttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctggaaggagtaaga
-agtatacagctgatccggtgtatccttcagtcatctgccctatactaattacacgacgca
-aggaaaaataggtttattttctaggcaaacccttcataggtgactccgatgtgttacgaa
-tcatgcttgagaatgtgctatcgttaccgacggataataacgatctccaatgaaccaaat
-gtagaatgtctattgattacccttttactattcgacttagagataggagatagaacctca
-gtgtacttttttagccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatc
-caaccctcttaaagtcttccatattatatcgttgttcgtggaatcgataacagatttgtt
-gacccatagtaaatgtatactagtttatgttgtaagtgtagattgttttccgattgccgt
-ccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatc
-ctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggtttagataaagccgta
-tgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcccttataatagta
-gtttaactataaaagtatatactggtctgtcgccctttcacgatttgttttaccggttta
-tgaagcgttacgtcattagagcggctccaatttaaggttaacggcttccatgtgtagttg
-tatacaaggataacttaaagtatctgttcagcgagctagttaagttatcctcgatagaac
-acaactcagaggtcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattg
-ggaattatcgatacctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtg
-atcctaccttagttagtgctgattaacggaacattaatgtttatcgttttgagatttagc
-caattctctgattctaactcaagatgccttatctgacgtgctatgcagcccctaagtatt
-ttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctac
-tggttaactatataatttacagctttgttgagctagttcctctttggtttaagtcctcaa
-tattagttggttcgagcgataagttggctagttaccttagtcactatattagatccgaat
-gttatgcttcatctgaagaccgccaccctccaaaatttcttttaagactcacttattgca
-aggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacgagtttccatatt
-ttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtcgctctacaaggg
-gacgcaattaagaaacagacatgctagtcaaaaataaacatagcgaggcaccactaattc
-ggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagtagttagttcgga
-catacatttacttcagatgatcaattagttttctacaaatgcttactctaccccgaaaaa
-agtcaccagactcttacgtctctttagtatccttccgtcttatataaggtcagtcccccg
-tttcggtaccctggaatttactaagaataatgaaacagcccccaaggacgtacgtttaca
-aatgatagaccagatcgcctagcttattccgacgcatgttgcatagaattgaaccaacgg
-aatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctg
-atagttcggccacgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcga
-gctcaagcaagcttacacttcctcggatattcagggaacttagtgcctttgaaagatacg
-ttgatcaacgaaaaattgataatggctcatatggaatgcctacctcatagtgctgaatta
-acacagcactgcggacctaacttttcgaggtttcaagttcacgtctcaaaacctaatagg
-ctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaag
-tgaatattctttttttctaaaagcagatctgctgccgggcactacgaaggagatctctgt
-gtatcattattgcttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgata
-gcacaacccaattcgatagtacatattgttgatacttcgcactaaaccgttcatatttaa
-aggttgtgctccttccttcgttaaatactggtgacttggtcctatctactattagctaga
-cctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagac
-atcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattat
-tcttatactaatattagcaaagatgcataatgatttgtattaaatgtataattgaattga
-taagggtcttttagtcagtgatagagtagtataaggtagacattagaactcttaaccgga
-cgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttact
-agtagtacctataatgcactgaatcttcggtcgaagtatagttctaatgctatgcagatt
-gtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaa
-tgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggggaattaaccaga
-ttgaaggccaatcctcacatgtaatgagataatagacgataaatgaaattcttgtaatag
-ttgaactgctacgtgatgggtattatatatgattgagatcctccaattgccgacgtcttg
-tcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcat
-aaacgacgcgacatgtacagcactccgaagtataagcaataataatgcgggtaatccaga
-ctagatcttttcggactcaatgcggtttcacggtaaacatgattaataccggagagtagt
-cgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgttgcagataaaacc
-ggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaa
-cttcaagaactatcgtatattcaagtccattaccttttagtttcagactggtggagctga
-ctaaagttatatcatcattttgtacactggtttagttaacgataatttcagatttaacat
-gaccagacgataatcgctgtatatccagttggaatgtggtttgccagaaaggttaactta
-taatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagt
-gtatttggagctgtagttataccgtgtgctaagatcagtagacatgacgagagcaatatt
-atctaccttacaagcatcaacggacgtctagtcggaacaaaagactctaaaactcgaact
-tcaggttaatatactatagttctgtattcagcagttattcttatattcgatattatcttg
-cctattggatgtctgactttagtatattaatcatagtatctgccatgtaaaggtgccagt
-actaaatctgtttcacagtgcgaattataaacggttacaaccattaaagacaacaagacc
-ctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaatta
-gtctatagggtcgggacgattctacggcatttctggttataatgacaacatggattgtgg
-cccgagaatcgctctttcattaattaagcaatcattacagtcttataagcgctacttccg
-agtggtagcaggtaactcgatataaggtcgcatgagccgaatagcttaaaaaacaggcca
-ccgaacattgatagagaataccgaccacagcgcaacctttgattactttcattaaattgt
-acggctcactcgacatcaagcttaagattgcgataatgtgaactcaaatggatcagtact
-gaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgctgttacaatata
-cagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttggttagaaatgata
-gccattcatgatagaaataagctgaatgataccagtatctttaactatgtagtcaggggg
-aagataacgatggtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgct
-aacgaagctacttaatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaa
-agatagtatgagctataatatatgctagtagagaactctggaccatcatctatatgaata
-ctgattcgagcgtgcaattactttagcctgcgtactactgactctacaaaacactctgag
-ataagtttgtagtcagtaagtcgctctctataaaccttttggatgaccattgtacagcca
-cttatagatcccaataaatagcacaggagacagagtttttcaatgctcgatcatttgccg
-atagtattttcgtctaacctcagggcacctattatttgatacctaacctaacggcccttt
-cacaatggagaaatatatgacatcgggacaaacacaaatggtgggtggccaggagatatg
-acatggtggcgtctctaagaaacacggactccctctaggcaaactcacgtaaccaatttt
-aatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggtacattgactggt
-caggaatacatcactgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgt
-ataacgcaatttacgacggacatcagatcaagttatacagattatttaagtatcacgtgt
-gcattgggacataagggatctcacacatgccttggaacatttttgctttgtgccgctttt
-tcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaacagaatgagaaa
-ggttagggctctaagttatcgtcgattgggatagacgagacatttgcgagcgccctccac
-ggatacgaatctcccatatcaatgtgaactggatgctatgcagtttagttcttacgtctc
-ctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacctaatacacaaaa
-ccgtcaaacattttctaattctaggtatgggccgatcataggagctaaggtgaaactcat
-aaatgttttgttagatctagcatcctaaaaagatgcatatactgagtagctggcgtgcat
-tctctcaattgtatcctttttaactgaactagtcggtcccatttcgtgactgagatctat
-taaccgataagattaataacactcgcattcgtatcagctcagagtgaagtttttcaataa
-tttgactgatatattaacttctaaaataaccctttaagcctcggatccgtttcccaatca
-catcaaaaattcttattccaactatctacggattaacaacgtgcatggggatcgtagtaa
-gaacttgttccgatcactttgagtatatcaagttgacggcccggttattattgaatagaa
-acattcacctgctaaattaaataccgcacatcggatacccgatttcagagggccgtctta
-ctaagggcaggctttgttcggtttaactgagatgttcattattttacagtatgcttcaac
-taatatgtaacgaaggacagtggatctgtctccatagtagatcttcagtcgtgaatttca
-taccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccct
-agtattctagacgaaaattttttctagttcatctgataatttgccaattcaaaaacaacc
-gctggtttcccggcgcattctctaaaatggaagtcgaacctagagccattatttgtcggt
-aacccatgagttccttcttttcagaagttaatacactgtggtcctatacagaggaaaaac
-agcggttatatacgatcgtggcataacaacattggatcaagatagcaatttggctaccta
-ttctaattctcactagattcggtattccactacaatatcggcagattaggattggatgaa
-taatcggtgtttaagtccggttgcgtctccaatctcctaatttttattaatattgatctt
-ggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaaagatagaagact
-catttgaaaatggatcatccacagatccaaacattagcaagacactaatccccaactagc
-tattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaatt
-ctttttgggctttgttcgatggtgattcagaatctttatccggtcgcttccctgtagcta
-ctttgtggggatattgcccggggattatagggttgagatcgtttcctaaaagtatttaaa
-ccaagtagacttcaactaaactacatcagaacatcgtgaagacaccatacgcggtacctt
-tatttaccgataacatttcttcaagaaataccggtaagcagcataatgaccctaaacagc
-tcggggtatcgtcgtagttttaaattttatttaggttactgctcaaggaataaaaactaa
-ctatttaatttataataatattacaaggctcacactgattagatttgtctataagacttc
-gcgatcccccattaccggattgtcttaagaataaactagataaaccatgcattttctaga
-taaggcctttagtctaattagatacaaaaaacacgatagttgcatccttaatttattgtg
-tcaaacctggaaccttttaattacccgcaaatcactttatgtcgagactacctctgaaat
-ttattatctacctaccgcatgaggacttgaaccatcttgtaggagttatgtttattagct
-aagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaatt
-gtttttagttgagtcaagactgatatataaataagtttccctagttttttcgtggtggga
-cgatattgaattgaatcttaaccgaagagtttcccactctgtcgcacaataatacacgcc
-aatatttccagccctgcttatgccttaatcggttactcaatctcccattgaagttcattt
-tgatctgcatagaagtttcgggcccagccttttttctgccaccttcctccaagctctgta
-gacgcactctaagattgatgctcacatgtattaattctacattaacataaatatataagt
-catgcatcttcgagtaaaatatctggttctccaacatgtcctggcacgtatcgttataat
-gcccatacatgtagtattaaaatgattgggttaactggatattaagatcatcgaaattgt
-aaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctcggaagggctatt
-acgcttacttccgttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcc
-tacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaactacttgctttac
-aataccggtcgtatatatcgccgtgaatccagaagattgtcttctttggattatcaaccg
-agatcctgtggaccgatgttttgggaccttcacagaggactccaggtagagctcgctttt
-gcattaatctaagaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatg
-gaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgagttattatacata
-tacgagatggtggtatacatcgaattcggggcatacactatagttgcattgtatttagct
-gctttaaataatatgatattaccttccttacataagacattaccggcataccctggtttt
-caacttgtggggctttttgacgatcgcactctcatttgatccgagtagggcggtgacccc
-tgcttttcaaatacaaaaatttcgctatgaaggtaatagattacttttcgctgttatgat
-agaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttg
-tgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatag
-aaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgccgacataggatg
-aaatcagattccaatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaa
-gttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtgcgatcaactatg
-aatctcggcgagttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatga
-cgaattttcggctaggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggat
-tccattttacaagacgattacaatgagttacatgtctctcaacgtagtctttccctagta
-gtctttgaactatttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgc
-cattcatgtttatgatggaacaataagaataacgccctcgtatgttatcgacagtgaagt
-cagcagttcggccaaaaacatattcaatttagtacagatccccagaagttaagctaagtg
-ctctaaaatggcctaaacggttatcaaagtaggtctaattactatactaacgggtgcatc
-gtaataactgctgtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaat
-gtgacaaagaagccttagcgattcttgcaaacttaggacttcggattctcaatcttaaat
-gtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcctgatggtgacta
-cgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaactattgatagtcggg
-agcataaccaggtgaacgtactttgttcacgacatttattgacatgttctaaatacgtct
-caaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaat
-gccggtagtgtcaaacttcatgagaactttagctggcttttggccagtatttagggacca
-agagcactagccttaagctgaatattttgccatttatctactgttataactttaaaactt
-ggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaaga
-acaagcgtaggaattgagtttatattatatttaaactaaaagatgatattagcttctgag
-ggcgatagggctccaaatcataaagaggaatatattattacacgattagaaacccacaac
-atacctcgaatcgcccaaaagtttgacgaaacttggcagtactccacatctcagtaatac
-agttgggagagtctcaaatgttgttttattactcaatgaaccaccctcataatttcactg
-ctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaatt
-acagataagtagatgcataataaaaaaaactgctcgctataacacgatcatcgtgcattc
-ttacttaggagcatcacccgcacaataacgtaccttaaactacaacactattagaccgag
-tactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgt
-gataatagtttgcggagaggattcaattattttccattgcacctactccactagattcga
-taaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaa
-gcatgtaagtgaaccgtcatccttccctaagaaacataaaggtttttaataatgtcgact
-gtgaactataactgcatcctttcctgacctactccggttccttgttgttatttctgaacg
-agaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccg
-ttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaaattaattttgcc
-ttttattttttttcaggctcgaaattaatgatttgttttttttgaccttctagttacgct
-aatatgcggtcgcctgtggtttctattgagtcctataacgggatgggatctaatacgttt
-ggttactagtaaacaaggtataaatttgataccggagtatcaactgtataacatcaagct
-ttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagcca
-ctaaggggtgtattacgatagtgacaccaccgagcgcactcactccccaagtagatttat
-gatcctacgctaagtattagatatataaccaaagaggttctagtcagtgcaactcttaga
-ataataattagccggttttgcctttttaggcctaatgcaatattcagctagcccttatgt
-atctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaaatataatctatg
-aatgttatgccagtacttgaataaatcaggttttttataagtccttgcatactctcgtta
-tatactgttagagtcttaccccatagaaattctttcatctgcaaacttagaagaattctc
-agctacggggagcataaagtccccaggatgttgacaaatacaacaaatgtggcttataca
-aacactccatatgaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaa
-tccctccattttccaatagcagatacctatcctactacctcgtggtattaaattaaagct
-tgaaatatagagctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccac
-gatttgatttacagacgctagagcaaacccatctttaaacatataagtaaaaattaaagg
-gtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgtttataagccata
-attaaaaacatatgttcaacaggttcattgatatttgtaattgcacaggtttttaataag
-gatctacgtaagtataatgaacaaactttttaccagagttatattctgtactttgaaaat
-gctcctctaccgccttagagactttcaattagattttttgcagttaatctatgcgtaagt
-gaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataac
-tgtaggtctaatataattttcagttttcgaacacataaccctttgaaaatctgctattta
-atgtctcacctgcatgcactatcttctatactgctcagaacggctatacgtcactatgct
-ccaagtgacgatttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaa
-gtgcggactacgtgctctttacaataagccttgtgattgggctataggttaagtcccata
-ttaacgatctccaatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaa
-ttacagatagctgttagatactcactctaattttggacaacaatcccaatcttggggtcg
-tctatcgcctgaagctcgtaaatccttccatcttaaacgattacatattatagacttgtt
-cggggtagagatatcacagttgtgcaaacattgtaaatcgatactagtttatgttggtag
-tctagttgcttttaccattccccgaaaaacttgatctactatttcgacaacagtaaactt
-gaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgtccactatatgta
-agtgtagctttacataatccactatgactgagatcattacggcctaggaaagcagcgtag
-aaaaaaagggcccggatattacgactgtaactataaaactagttactggtagcgcgccat
-gtatagatttgttttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatc
-cgttaaccagtccatctcgacttctataaaacgataaagtaaagttgatgttcagcctcc
-ttcttatggttgcatcgagagtacactactcagtgggaaatagatcggggttcctacttc
-agattgtattatctaggcaattgccgattgtgccatacctggataaaataagctacctac
-atgtgatgcttatctattatcgtcatactaccttagggtgtcctgttgaacgctacatta
-atctttagccgtttgagatgttccaatggataggagtctaacgcatgatgaagtttagga
-aggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagacgttataaataga
-aaaaaggtccttctggttctattctgctgaactattgaatggaaagattggttgacctac
-gtactatttgcttgaagtcatcaatttgacggggtgagagacatatggtgcatactttac
-ggactctatattttagatcagaagcttagcagtcttctctacaccccctcacgacataat
-tgcttttaagaatctatgtttgattcctctacgggaattcggatccgttcgcatgtgcgg
-tttatctaaaccaggggacatatgttcagctaaagcatacgaacactttgctaactagac
-gtatgtatagtagctataaatcccgacgatatttacaaaaagaaatgagactcaaatata
-tacatagcgaccctacacttattcgcaccctgatctaggcgatcctagcacccacacccg
-aaagtgagcactagtgtcttccgtattaaatttactgcagttgagattttagttgtctac
-taaggattactctaacccgtaataaggatcaagactcggtactagctttactatcattcc
-ctatgtgttttcctaactcacaagggtacgtaccagcctatgtaattacaataatgataa
-agacacaaaggaagtaactttacaaatgagtctccagttacactagcttagtccctccca
-tcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaagaacactcataa
-cgttggagtccaagaattagactcatagggcccccaacatttaatatgtactgtgagttt
-gaaggtgttctattgttaattcctgctcttgatacatgacacgtactccgtgtttaaggc
-ttcggactgactttctttcataagttgagcaacgaaaatttcagaatcgataagttggat
-tcactaactaatacggctgattgaaaactccactccggacctatatggtcgacctttata
-cgtaaccgatataaaacttataggctggtatatcgagccttcctagcgcaatttcggatg
-gggtttcttctactactcaacaacggaatagtctttgtttagtaaaccagagctcaggac
-gcccaatacgtaggagagcgctgtggagcatgtgtcattatggactggagcactcttaaa
-tcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaattttcttgatacg
-tcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcg
-tgctcagatatactattagcgactcatctcgcctaacacgcacacgtataaactcggaat
-gactgccgctcttacatattagaaatacagactacaccacggaagcattgggtcattctc
-aaccgctgtataaaagatgattagtcttataataagattaccaaagaggcagaatcatgg
-gtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatgg
-tactcaggacaaatattaaccggacgaagtggtttacgtcgtactttcactattagtagt
-aaatacaaggtaacaccggggaatagtactaaatataatgatatctatcttcgggagaac
-gagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgata
-caaccgattgttacttttgtctattcaaaagattgaatagttttttatacaaaagccgca
-tacttatgacggctagtatacagtttcatcccctagcatcaatgctatggacagtattga
-acttataggaaattcttctaatagggcaaatccgtcgtgatgcctattttttttcagtca
-catcctcaaatggcactagtattgtcgggatcccattaacaggctcaaccacgagctcac
-gcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaactcccatggataac
-caattataaggcccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaa
-tcatgttgaataccccagagtagtccagatgataaccgatgaaacacaagtctttctcaa
-tgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgcgacatctagttg
-tgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaacgccttgtaatt
-ttactttaagacgcctggtgatgtagattcttagataatcagtttgttatcggctgtact
-ttaccataatttcacaggtttcaggtcaagaagattatagctgtatatacagttccatgc
-tcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatc
-caatacatgccccgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagc
-tcgagtcaggacgtcagctagattagattccttaatagaatataccgacctctagtccga
-actaaactatagataacgccaacttcaggttaattgtctagtcgtctgtttgcagatggg
-attcttagatgagtgagtatcggccatattggttcgagcactttagtttttgatgcatag
-gatatgcaatgtatagctgaaagtactttatctgtttcaaactcacattgattaaaccgg
-taaacctttaaagactacaagaaaatattcagtgagggcaattttgtcaatcacaatctt
-ccagctagagatacttcacaatttgtcttgaggctacgcaacattagacggattttcgcg
-ttttattgaaataatcgaggggcccaagagtatccatagttcattttgtaagatttcttt
-acaggcttattacagcttcttcagactcctacatgcttacgagttatatgctagcatgtg
-aacaatagattaatatacaggaaaacgtacattgagagagatgaccctacacagcgcaac
-cgttgagtactttcattaaagggtaacgctctcgagacagcatccttaagatggccttat
-tgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaa
-cacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcggagtatcaattt
-cgccaatcttggtgagaaagcataccctttcttcagagaaagaagatcaatcataacact
-atctttaacgaggtacgcacgcgcatcattacctgcctccatggatctttaggatagcgg
-aaagtattggcagcgtattgtgatttcgttcctactttatcaatttcacattcatataca
-tgtcttttatcaaaatcgccaataagataggatgagctatattagatgctagtagagttc
-gcgccaacatcatcgataggaatactcaggacagcgtgataggacttttcaatccctaat
-actctctataattataactctctcttaagtttggaggcagtaacgcgctctatataatca
-gtttgctgcaccattcttcagcctctgatacatacaaataaattccacagcagtaagagg
-gtttaattgagacatcttgggaacttaggattttactctaacatcaccgaaacgattatt
-ggataccgtacctaaacgaactttctcaaggcagtaatataggacatccgcaataacaca
-aatgctgcctccccaggagttatgtcttcctggaggctatatcttacacccactcactat
-aggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataagagttggccggc
-gtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaagttctgtcctgt
-tcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatctcagcaagttat
-aaacatgttggaagtttctagtcggaattcccaaagaacggatctatctaatgcattcct
-acatttttcctgtctgccgatggtgccatcctattcaaagaatttcttaaaagtagatta
-aatgggacttttaacaatgagtaaccttacgcctctaagggttcctcgagtgccatacac
-cagtcaggtccgagccacatacacggagaacattctaacatagcattctcaactcgatca
-tttgcaggttacttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcac
-ggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttggtatgggaacat
-cattgcagctatggtctaacgcattaatgtttgggtacatcttccatcatataaacagga
-agagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagc
-tcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataa
-gatctcactgaacttttgaatgaatgtgaagcatatatgatctgctttaataaaacttta
-tccataggatacgtttccaaatcaattcaataattattagtcaaaatagataaggatgaa
-caacctgaaggccgatcggacgtagaaagtggtcccatcactttgagttgatattgttga
-accacacgttattatggttttcaaacagtctcaggatattgtatatacagataatccgat
-accagttgtctgacgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgtt
-cagtattttaaactaggcggcaactaatttggaaagaagcacagtggatatgtctaaatt
-cttgttattcaggcctgaatttaatacaccgcatagttaacttcgcggtagagttgttca
-tcatgcctcctctaagctaccacttctatgatacaccaatagttgttctacggaatctga
-taattggccaagtcataaacttccgctgcgttcaacccccttgctcgaatatccaactcg
-aaaagacagccttttggtgtccggaacaaatcagttacttcttttctgatgttaattctc
-tgtggtcagatacagaccaaaaactccgcggatttaccatcctccaagaacaaatttgca
-tcaacatagcattttggctacatattctaagtctcaatagtttaggttttcaactacatt
-atcccaacattaggattggaggaataatagctgggtaagtccccttgcgtctacaatcga
-ctattttttatgaatatgcttctgccgcacctatggttattaaaaaagtcatgactttga
-agaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaagagcatataatta
-gcaacactctaagaacattatagatatgatgatagcgatcgtcatgatgttatccggtca
-caatagtagcttcatcagctaattcgttttgccagtggtgacttgcgctggaagaatcgt
-tatacggtcccttccctcttgatacggtgggggcttattcaaccgcgtggattgggttgt
-catacttgcattaaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatag
-tgatcaatacatacccgcttcatggttttaaccatttaattgattaaagatattccgcta
-agaaccattatctacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccg
-taatgatcaacgaagtaaaacgttatattgtatgtagaataataggtcttggagctaaat
-gatgtgattggtagtgaagacttacccttacaactttaccggtttctcggaagaatatac
-tagagaatcaatgcatgggctacataagcactttagtctaatgagataaaaaatacacga
-gtcttccatcatgaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatct
-ttatgtcgtcaataactctcatatgttttatataacttcccaatcacgacttgtaactgc
-ttgttcgactgagctgtttgagctatgaggccgggatccggttgagctacatctatttgc
-tacaagaaaaatgaaagcacatttgttgggagttctggctacactcatagagaaataagt
-ggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaa
-cgctcgcgctaaagaattaaagcctttatttcctccacggagtagcccgtaatccggttc
-gaaagagaccattgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttc
-tgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatg
-cgtctgtaacataaatatagaaggaatgattcggcgagttaattttcgccttctccaaca
-tggcatccctacgttcgttataaggaccatacatgtaggttttaaaggtttgcggttaat
-cgatatttacatcatagaaattctatagtcaaatttacaagactctagatactcactcgt
-tgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaattt
-catatagtaagttcaaggcactcatacctccgtgaagagggtagatagactattaaagtt
-gtttaatagtacgtattgatggaaatgacccgtaggagatttaccactcaatccacaaga
-ttcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaaca
-cgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccgagataaatgagct
-ataacactgtatgtcttttgattgctataaaacacagaaacggatattaatttaggccgt
-aaccaacatctgttatttgacatagaacagatggtcctttacagcgtattccggccttaa
-tattgaggtccagtgtattgtcctcctttaaagaagttgattgtaactgacttaaataag
-acatgtcacccattcactgggttgcaactgctggccctttttgtccatcgcacgctaatg
-tgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggtta
-ttcattaattttagctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaa
-ctaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaata
-aagccataaccagccccggaatagaaaatgttaaggaaaggcgatcttctttgaattctt
-attgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaatctaacaccctc
-ccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaa
-tgtggttccgtcccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctc
-atagaggtaactggcctgtaatgtccaatgttaggctaccttctccaactttagtacaac
-gaataatgtccgattaacaaggagtcaatttgtcatgaccagttcattcaggtacttgta
-tctatacggacgcgttccagagtagtatttgaaattttgaggttctactgataagtttag
-ctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaataacaattaacaa
-ctcctaggtgatacactgtgaagtctgctgttccccaaattacatatgctattttgttca
-cataccatgaagttaagctaagtgctctataatggcataaacggttatcaaactagctcg
-aatttcttttattacgccggaagcggattaactgctgtagatcaaacacgttaggatagt
-gtcgttttcatatatatctaaattcggtctaacatgcattacccatgcttgataacgtag
-cacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatc
-accagtgatgcctcatcgtgactacccggatctttagcctttagggtctaaacagaacta
-atattactacgtgtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatt
-tagtgacagggtagaaatacgtatcaaattaacccagcaatacaataagcatgaaaataa
-ttgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgc
-attttgcactggattgagccacaaactcaactagcattatgctcaatatttggccagtgt
-tctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatc
-tcgaacgtaataggtttaattagaacatccgtaggatttctgtttatagtagatttatac
-taaatgttctgattagattctgacggccttacccatacaattaataaagacgaatatatt
-agttatagtttactatccaaataaattaagcgaatcgaaataaactgtcacgatactggg
-cagttatcaacttatcacttatacagttcggacactctatattggtctgtgagtactcta
-tcaaactaactcataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtg
-tacaaacctataatcgaataaatgacacatatggagatgcataataaaaaaaacggctcc
-atatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctg
-ataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtat
-agttcttgatagcgcgtaaattctgataatactgggcggacagctggaaattagttgcca
-gtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaaatacaaagggtt
-agttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaaca
-taaaggtggtgaagaatctcgtaggtcaactataactccatccttgaagcaactactccg
-cgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaacaactctcggta
-caaatgcggcttgtgtcgataaagttggtggtagtgcacggaataacataacaaggaata
-ttatttattcaaattttttgtgactgttatttgttttctgcctagaatgtaaggatgtgt
-tttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctat
-aacggcaggggagcgaagtagtgtcctttagactattcaaggtagaattttgataacgct
-ctataaaaggtagaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagtt
-ctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtcacaacaccctccc
-atcgcactcaaaatgtagatttatgatcagacgctaacttgttcttagagaaaaatacac
-gggatactctgtgcaacgatttcattaataaggtgcagcttgggacttttttggccgtag
-gctttattaacattcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgtt
-ttaacgtttcaaatataagctaggaagcgtttgccaggacttctataatgcaccgttttt
-tttagtacttccttactagccttagtttatgttagagtctttccaattacaaaggattga
-atagccaaaatttctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaa
-tattctacatatcggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtactt
-ttagaccaaacgtcttcggataattaaatcctttttcaattaccacagtacgtgcattag
-aactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacatt
-gcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagcttaccattcgtt
-aaacagataactaaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggat
-gtagactattgtttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgt
-cgaattccacaggggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatc
-tgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattg
-ggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattctaccgactccgga
-taacactttacgatcgcgcataactctagctcttagataagtttaacttgtcgatctcat
-aaacagttcaaaatctgcgatttattgtatcaaatccatcctctatcttctataatcatc
-tgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaaagctataattgg
-tttattttagtccatttaaattaagtccggtataagtgctctgtacaatatgcagtctca
-tgggcatatacgttaactaccttttgatacttcgaattggtaaaatatcgactatcgatt
-tgcagtaaaaggtgtagagtccaattactctttcctgttacatacgatctcttagtttgg
-acaactagcccatgatggcgctcctctagcgcatgaacctactttataattacatcttta
-tcgatgaatttttttagactgcggaggccttgagttttaacagggctgctaaatttctta
-agcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatc
-tactattgcgtcaactctattctgctaatagcgatggcaaatcacagaagccctcttagt
-gacaatagttgtcaactatatctaagtcgacctttactgtatcaacgatcacggagagaa
-ttaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataa
-tacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaac
-gattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgt
-tagtaaacttgatcttcagactccttcttttcgttgcagcgagacttaaattatatctgc
-gaaatagtgccccgtgcatacttcagatggtaggagataccatttggcccattgtgactt
-tacgcgattaattaaccgacatacatctgttcctgagctatgatcgtctgaataaattac
-ggtctcctcttgatacctaatggtttctggagacgtttctcatgttcaaatggatagcag
-gagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatt
-tccaaaccagaagggataaagagaaataacggacttctccgtagattagcctgatatttt
-gatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatattttggacggcggg
-agacacatatcggccattcgttaaggtctctatattggacatcacaagcttagcagtatg
-agctactaacactcaagacattattgattttttcaagatatgtttcattcctctaccgct
-attcccatacgttcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatca
-ataacaactcgttgcgatagagacctatgtatactagagagaattccccaacatttttac
-aaaaacaaagcagactaaaatagatacagtccctccatacaattaggaccaacatgttat
-tgccgatcctagcacacacaccacaaactcagaacttctgtcttacctatgaaagggtct
-gcacttctgattgtacgtgtctaattagcattaatattaaaactaattaggataaactat
-aggtacgagctttactataagtcactaggtgttttccgatcgaaaaacgggaccttcaag
-ccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaa
-ctgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgt
-tatactgctcaacaaaactcataaagttggactccatcatttagaatcatagggaccaaa
-acatttatttgctactgtcactttgtaggtgttctattctgaattcctcatattgataca
-tgaatcggaatacctgtggatcccttaggacgcacgtgctttctttacgtcagaatacat
-attgtcagaatcgagaagttccatgcaattaagaattcgcctctttgaaaactcatatcc
-ccacatatagggtccaccgttattcggaaacgatataataattattccagcgttgagcgt
-cccttaagagcgcattttcgcttggcctttcttctacgactctacaacgcaagtggctgt
-gtggagtttaccacagcgcagcaccccatagaactacctctgagagcgcgagatggtggc
-agtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatg
-gactgtcttaattgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaa
-gtaatgacggaaatacgcctctagtccgcagagatacgattacagactcagatcccctaa
-caagcaaaacgattaaatcggaatcactccccctatgacatatttgaaatacacaagaaa
-ccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgagtctgagaattag
-atgacctaactgcaagaatcatggcgagtttatctagtaggcaagtctgtaccctagggt
-tcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataaccaagaactggttta
-ccgagtactttcactattaggagtaattacatgcgttcaccgcggaatacgacgaaattt
-tttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaa
-ttgctgatcaattatagattcattatacagatgcttacttttctctattcaatactgtca
-tgagttgtttttaaataagcaccagaattatgtcgcctagtataatcttgcttccacttg
-aatcaatgcgatggacagtattctactgattgcaaagtagtctatttcggcttagcagta
-cgcatgcctatttttttgcaggcacagaataatatgcaactaggattctcggcatccaat
-taacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatgtttactacagaa
-agcgaatgatatcacttggagaacattttagatgcccccttttaatctagactgagtgta
-ccaatatatcaccggtctaccgaatcagcttgaataaaccactctagtactcatgataac
-cgagcatacacatgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcg
-aatcaacgtggcgacttatacttctgtctttgagtacagcacaccctaatgaatctaagt
-tagttgttgatacgaattgtaatttgactggatctcgcctcctcatctagattcttagag
-aagatgtttcttatagccggtactgtaactttattgatctggtttatggtaatcaacatt
-ttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagc
-gattatcgagtctggaggccgagaaaagaaatgcacagagtaagctctctattgcgacat
-ctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaat
-acaagattacctacgcttctacgaaatatactatagatttagcctacgtcacctttagtg
-tcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcg
-agctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctg
-gataactcacattgagtataccggtaaaaatttattctattcatctaaatagtcagtgag
-ggctagggtcgcaatcacattaggccacatacacatacttaacatgttctattgacccga
-cccaactttagtagcattgtagccgtttatgcaaatatgccaggcgccaaacactagcca
-gagggcattttgttacatttatttaatcgattattacacagtcggaacacgcctacatgc
-gttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcag
-agacatgacactaaaatcacattaaggtcagttagtgaaggaatggctaaccagctagag
-aatgcatcattaacaggcacttattgtcaaatattttccagatctaagcaacatcacgtt
-aaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagt
-aggcaagcgtaggagtataaatgtagacaatagtcgggacttagcagacactggatgcag
-tcatagaagatcttgcataacacgttagggttagagctacgaacgcccatcattaactgc
-ctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgatttcgttcataat
-gtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgac
-ctatttttgttcagagttcagttagagcctaatgattcgagagcaataatcaggacagcc
-tcataggaagtgtcaatcacttagaagctatattattataaatcgctctttactgtcgtc
-gaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaatatgatacataaa
-aatattttcatcaccactaagacggtggaattcagacttattggcaacttaggatgggac
-tattaaataacccataagatgttgggataaagttacgaaacgaaagggatatagcctgtt
-agataggaaatccccaataaaacatagccggcctccacagcagtgatctattccgccacg
-cgatatctttataccacgcaatataccaataataaaggttaaatgtggttgcgatttaaa
-aaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaatta
-tagcgtctgcaagttctctaagcttcctctgcaagatacaatatgactttttagcttttt
-tactaccaaatctcagaatcttagaaacaggttggtacgtgctactcggaattcccaaag
-taccctgctatatatgccattccttcattggtccgggctcaccatggggccatcatagta
-atagaaggtagtaaaactagttgatttccgacttttaacaatcactatcctgacccagat
-atgggttccgactggcccttactccagtaagggcagacacacagacaacgagaacttgat
-aactttgaattctcaaatcgatcattgcaacgtgacttatttactagcctactcctataa
-ttcatacgtcaaatacatttcaacggaggaagataataagtaaatattcactaaataatg
-gtcgaaggagtcctttgccaacataagtccacatatgcgctatagattttttcttggggt
-tcatattcaataagataaacagcaagagtatcacgtcagcgagtcattgagatcttggct
-agcattgtgatagcatattctacctaaatggtagtctagcacagagtggataagatatca
-gttagatatagacaagtactataacagatctcgcttcgttggattgtatggctagctttg
-atgatatgattttataaaaattgatccagacctgacctggccaattatattcatttttta
-tgagtaaaaatagataaccatgaaaatactcaagccccttaggacgtacaaagtggtaac
-ataaatttcaggtgttattctgcaaccacacctgttttgggttttcaaaaaggctaagca
-gattggttttacagataatccctgaacactggtatctcccaacgatgtcgttcccaaccc
-ttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaatatgttcgatag
-atccactcgcctgaggtagaaattcgtcttagtaacgcctctttggattacacagaatag
-tgtactgacacgtacactgctgcagcagccatacgctaacattaaaattcgttgagtcta
-catttgttgttattcggattatgttattgggaatagtatttttattcccctgcgtgaaac
-cacatggatagattagcctactcctaaagactcccttttggtctacggttcaattctctt
-actgagtttatgttcgtaattatatcggcgcagtgaatctcctaattatcaccggagtta
-ccagacgccatgaacttatggccagaaacattgcatgtggcctacataggattagtatca
-agagtttacgtttgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcggg
-aactcccctgcacgcgactatagaagttggtggtggatgtggcttatgccgcaaatatgg
-ttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtataagggctattgc
-cagatgaaaaactgcatataaggtcaaacaatataagaacattatacataggatcttagc
-gttcctcaggatggtatacgctataaagtctagcttcagcagctaaggagttttgccagt
-gcggacttccgctggaagattaggtttaaccgccctgacatcttcataaggtcgggcctg
-attcaaacccctggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagt
-ctaatattattattaacaaatgacggttcaataaataacaccgtaagggtgggaaactgt
-taagtgatgaatcattttaacctatcatccattagctacagataatgataccccgatccg
-actagggggtaagtggttgttccgttaggataaaccatgtaaaacgttagagggtttgta
-gattaattggtattccagataaatgaggtcagggcgagtgatcaattacactgaaaaatt
-gtcagcttgcgcggtagttgttaagacagtataaatgaaggggattcagaagcaagtttc
-tcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtcgattaaagccta
-aatggtaatttaaaccattgatatttatcgagtctataaatatctttggttgtatattac
-ttcacaatcaccaattctaaatgattcttccactgtgcgggtggagatatcaggacgggt
-taaggttgacctacatcgttttgatacaacaaaaatcaaagcacatggctggggacttct
-cgatactatctttgagatagtacgggcaagagtgggtgacgcctccctacattttcaagt
-ctatcggataacttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatcc
-acgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtc
-atggttagccaaaagcatgggttatccaaaaggaataaaacagctcttcaacaaagagat
-gaggcttcataacttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggac
-actttattttagccggcgaattaatggaatccatacgttacttatttggacatgacttct
-aggtgtttttgctgtcccgtttagcgatatttacagattagtatttcgtttctcatagtt
-aattgtatctagatactaactcgttgaagacgcataccttgccatttgtacaggacttaa
-ctgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaatacctcactcat
-gaccgttcatactctagttaaggtcgggaatactacgtatgcagggaattgtaacctagg
-agatttacaactctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcct
-aacttcgggtgcctccgtaaatcacctagaaacctactcatacatttgcaattttgagat
-gtaggcgaaagagagaaatctgctttttaacggtatctcttgggattccttttaaaaaca
-cataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgc
-cgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatg
-ttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctcccc
-agggttctacagacatagagatggtcagaacacgacccccctctcaacgcagtgtatttg
-aaatatatggacatatctaccttattctgtaattttagatgtgttctgtgtataccgata
-ttgataagtcaataggcttgattacgtatcttaagacaaatctgtttcgcaagtaggacc
-gcatctttcagattgtttctttttatgccataacctgcccaggaattcaaaaggttatcg
-atacccgatatgctgtgaattattattctaatggccactcattcctgcttatatctggaa
-ttggcatgaatatcttacaacctaaagtctggcgttgcgccagttctacttcgtaccgga
-caccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacac
-tttgtgccgacgtatatagatatattacacgtatagggaatgttttctcctaggtgaccc
-gaccttctactaaggttgtacatcgtataatggcccattaactacgaggaaagtggtatt
-gacctggtaatgcacgttcttcgatatataccgacgaggtaaagtctactattgcaaagt
-ttgacgttatactgataagtttagatttccctggatcgcgcatgaacaatgtatgcgtta
-tctgccatatataacatgttacaaatccttggggatactatcgctactatcatcggacca
-aaattaaataggctagtgtcttatcagaacatcatgtttaccgaactgatctattttcca
-atttaagctgatattacgtccgcgtatttattttagttccccggatgacgattatctgag
-ctacatcatacaagttagcatactcgccggtgcattgatttcttatttcgctatatcttc
-aagttcacaggcttcatatagttccaattagcagtataattaggttttgtaactttaacc
-atactttataaaaggttatattgcacaactgatcaagcatccgctataacccgagcttta
-ccagttagcggctaataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgc
-tctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtataaaatgatacca
-catatactataacaatgaaattatttgtaatccggtttgccaacgtatcccccttcgcga
-taaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaa
-ttatcatcaatattggccaagtgttataagcgttgaaagtgatataggccgccaaaaagt
-agtctacttaaaaaccaatatttatcgttcgttattgctggtagtacaacatcacgagca
-tttctcttttgagttgatttatactatatctgctgatgtgattatgtcccacttacccag
-aatattaagaaagtcctagattgtaggtatacttgactataaatataatttaagactata
-caaataatctggctacattatgccatcgtagaaactgataacgtagtaacgtcggacact
-agattttggtcggggagtaatctagcatactaacgaatttgttaaatccgctgaaagtat
-atgtcattacctgcttggcctgtcttcaatacgtttagactattaaggactcatttcgag
-atccagtattaattatacgcatccatatttatactgaagacggattgagttaggacgaca
-agctaaacaaatattaagttaaggattagtattatattgtagaaactcgtcgggttggaa
-cgattcatcatcatagaatgcgttacttattcagagagacttaattcggttatgactggc
-agctcacctggaaagtaggtgaaaggcaacagaagaatattgttgactgaattctacggg
-ctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaatacaatggatctct
-acagtattacgtaaataacatacataaacctggtgttgattcgactagctcatagattaa
-tcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactg
-ataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtc
-aaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttt
-tatccagacattggatgcatggctgtgggggcacaggatacttaccattagttcacctac
-aagcggcgtgagagggtctcagttttagccagcgcagagaagtacgggcctttagacgat
-taatgctagaattgtcataaacctcgtgaaaagctagttaataatcatggtgctagaaga
-acacaacttttctataaaccagttctcgactgacagtcgtaactcactatatcgccgctt
-tgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagaga
-tcgtgttctgagagataaatacaccggatacgatctgcatcgagttcatgtattaggtca
-agcttgggactgttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtca
-tatcataatatatgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaat
-cgtattcttgaatgctccgtggtttgtactaattcctttatagactgagtgtatcgtaca
-ctcggtacaattacaaaggatggaagagcaaataggtcttcaattataacagtaccccac
-cttaatctaaaaaccagcttcaattagtattaatttcgccaggagtatatatataaatat
-ctaaagactaaaagactcgtacttttacaacttacgtcgtagcataattaaatcatgggt
-aaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctc
-agcaagtcagtagaaatggaaattcatactcgattaaggcctataaaactgttgttggta
-tctacagagtgattaaaattagtgaatcagattacgaaaatgttttcccgctcgcactta
-cgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattttggtataaaata
-ggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatg
-tagttggttataaaggttgtaatctcggagattaggttagggcttaatcagaatagtaac
-aatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatg
-cctggacaggataaacaatacgcatataacttgacgatcgagcttatatcgacctatttg
-agaagtttaacgggtcgatataatatacaggtcttaatagccgattttttctagaaaagc
-aatcctatatcttagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacat
-tgtatacaacattcctttttgtccgggtggggactccatttaaagtatctcacctagaac
-tcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgttgatacttagaa
-ttgctaaattttagtctagacatttccaggtaaaccggtagacgacaatttctctgtcat
-ctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctactatagacaatca
-tcagactttttaattaaatagttttccatgaatgtgttgtcaaggcggaccccttcactt
-ttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggg
-gaaatggaaaagaaattaggcttctaagatggactataatcgattaggctaattccgttc
-gcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtga
-atgtttaaaagtgctcgcacagaattacccaatacctatcatcacgacttaaatacccaa
-agcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaagggatactgggcg
-gggaaacctgctccttcacggtaacatggtaacaacagaatttggttaaggttaaaacga
-aatatactcggagtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtg
-aagacactcttatattagatctccgaaattctgacccgtgcattaggcacttggtaggag
-attccatttggaacttgctcaatgtaagccagtaatgttccgaaataattcgctgcagga
-gcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccg
-ttctctgcgtcaattccagagctggagatacattcatcaacgttacctacgcacagaata
-aaaagatcgagcgctaactcgttttcctaaacacaacggatttagacaaattaccgaatg
-cgccggagagtagcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcag
-gcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaagctatatattgt
-ggtcagaacttgaggacaactatgagctactaaaaataaacaattttgtcatttgttcta
-gatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataa
-acccgaatgagcgtaacattatcaataacatatagttcagatagagaacgaggtattcga
-cagagaattacccaacattggttattaatctatgcagaataatttagataatgtcactac
-ataatattaggaccaaaaggtgattccccagaagacaaaacaataaacaatctcacatat
-tcgctagtacctatgtatgggtatgatcttctgattggacggggataatttccaggtata
-ttaaaacttattaccataatctagacctaagagaggttatataagtaaagagctgtgttc
-cgatagaaaaacccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacct
-acgtaagggaatattctgtataaactgaaaagtcaggtgtaactacatgagtcatgtctt
-cgattaattacaatgcgatctcgttattctgatcaactaatatcataaactgccactaca
-tcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgcta
-tgctgatttaatcagattcataaaggaatacgaataactctggatccattaccacgcaag
-ggatttatttacggctgattactttttggctgttgacagaactgccatgaaagtaagatg
-tcgcatcttgcataaataatagcacctaatatagccgacaaagtgattccgataacagat
-tttaagttgtccagccttgagactccatgaagaccgcttgggagcttccccgtgattaga
-agaatctaaatcccaagtggatggggggagtttaaatctcagcaccaacaaatagtactt
-cctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgc
-gcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtacgacaaattttaa
-ctgatgtcggtatacggagaagaaggaagcacgcattgaagcagctacgcagaactgaga
-agatgacactctaagatacaattaatacaaaaacgttttaagcccaatctatcaacagat
-gtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtataataacagcttta
-tttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagt
-gttggctactctgtaaccgacgcgtccatccctctctcctagtgatccgtatatccaatt
-agaggataaccaacatctgcgttaccgacgaatttaaatttttcgactatttaattccgt
-tcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttg
-cagtgcatatgtagataccactaattgctgatctaggatacatgctttataaacatgctt
-acttggctattttatttactgtcatgtgggggtttttattttcaacaagtatgtgctacc
-attggataatctggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaa
-gtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaaaagaataattgg
-caaatacgaggctagccttcaaatttaatgcagattactcctcagaaacacacgtaagcg
-acgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgataatttttgttcca
-acctttgaatctagactgagtggaaaaagatttcaccgggataccgtttatgctggtttt
-aaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaatcatctgtacgt
-caactgttttaacaataacgtcagaataaaccggcacaatgagacggcggtctttcacta
-caccacacccttaggattataagtgacgtgtggattcgaattctaaggtgacgggatcta
-caagcctcagctacattaggtctgaagatctttcgtatagccgcgtatgttactgtttgg
-atatgggttatgctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatct
-ttacggttaccttttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaa
-actgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaa
-ctatcattgtggtcattaaggtattcaagattaactaagagtcgaccatatattctagag
-ttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtgga
-ctgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcg
-atacctcaatcgtagttttatcgggataaataacatggtgtttaaccctattaatggttt
-ctattaatctaaattgtaaggcagcccttgggtcgaaagcacattaggccacatacacag
-tatgaaattgttcgagtgtccagaccataattgactaccatggtacacggtgttgctatt
-atgactcccgcaaaactcttgacagagggaattttggtacattgatgtaatcgatgattt
-aacagtaggaactagacgtcatccgttagactgagttccgacatgctcaaattgtcagga
-tttttatccaataactaatggctctcacatgtaaataaaatcacattaacgtcacttagt
-gatggattcgctaaacagatagactatcattcatgaactggcactgtttcgattatattt
-gcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaaaaattcagtaca
-cctctaatgagtatcccgctttggaggaaagagtagcactttaaatggacaatttaggcc
-ggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcgttagggttagtc
-cttacatccaccatatgttaatgaataaagcctgagggaccttagagctaacttgtccaa
-cacgttgctcatttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagat
-tttgaccatttaactgaccttcacagttttgtcttcagacgtcacttacaccataatgat
-gacagagcttgtagatgcacacactcattcctagtgtaaatcaagtagtagctagattat
-tataaagagatattttctggcgtcgaacgtaacacagagagagtataaggggcatgataa
-tggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcaca
-cttatggccaactgaccttgggacgagttaagataccataagaggttgcctgtaagttaa
-gataacaaagggatattccatctttgtgtgctaagaacctatttatatttgcagccataa
-aaacctctgtgctatgcagccaccagagttatttatacaaagaaagagaccatttagata
-cgttaattctgcttgcgatttattaaacagacatttcacgtccaaccactacaaaagccc
-tatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcggccgaggaatca
-taaaatatgaattgttacattgtttactacatatgatcacaatctttgtaaaaggttcgt
-tcgtgatactaccatgtacctaactaacctgagatatatgcaatgacttatggggtcagc
-gcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctggatttcccaaggtt
-ataatgctctatactgaccaagagatccgttacgactcgcaatgaatactctaagggcac
-tcacaaagaaaaccactaattgataaatttcaatgataatatcctgaattgcatcgtgta
-tgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataa
-ttactatattttaacgatttaatcgtagttggagtcctttcccaaattatgtcatcagtt
-ccgatttagatgttttcgggcccttcttagtaaagaagttaatatccaagactagctcct
-cacccacgcatgcacatattcgcgagaagtctgatagaatattcgacagaaatgcgactc
-tagctcacactcgttaactgatcaggtacttatagacaagtacgttatcagatatcgctt
-cggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaa
-cgggaaaatgatattatttttttaggaggaataatacagtaccatgtaaatactcaacca
-ccttacgtacttcttacgccgaacatatatggcacgtgttattcggctaacaaaactgtt
-gtgccttttctataaggataagcagattcgttttaaacatatgacctgtaaactgggatc
-tacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcggatctttggttaa
-agagcaccattagatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaac
-cactcttgggatttaaaacaattcggttaggacacctactcggcggatgaagcaatacga
-taacattaaaagtcgttcagtctaattttggtcgtagtacgatgagctgatggccaattg
-tatttttattaacagcactgaaacaaaatggagactttagactaatactaaagtctcaat
-gttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgt
-atctcattattataacaccagtgtacagacgacatctaattatggccagaaactgtcatt
-gtgccattaagaggattagtagatagtctggaccgtggaatagaattttgaccaaattga
-ccagtcctgcttgtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgc
-ttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaat
-tcagtcttctagatccgctattccaacatcaatatctcaatttaaggtcaatatatataa
-caaaattagacagagcagctgacacttacgaagcatcgtagaaccgatatagtcgacctt
-atgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaat
-gaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagt
-attactgcgaaaaattcgtctactattagtttattatgaacttatgacgcttaaataaat
-taaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgc
-taaagattatcagaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatac
-atctatatagttagaggcttgcgtgttgttgtgctattccacatatagcagctctgggcg
-actcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaatt
-caaggggattaagtaccaagggtcgagtttctctgtatttattatactgtaggcaagaag
-cttttttggcgagatttaagacttaagcctatggtaaaaatttgatagtgagcgactata
-gtaagagatttgggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatct
-gagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaattt
-caaacatattggcggggcacttatccataatagatttctgtttgtacgccaaactctgcc
-tcacccctccataaattgtattggctagaggttaaattctccgtaaatagagacacatat
-agttttatacaattgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatg
-tcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaag
-aaaacacagattatacaaagagatctggatgaagatattcgtgcaatcactatcgttatg
-ttagagagttccatgcatgaggactcgttttttgaccaggagaattaagccaagaaataa
-ctgacgtatttccaaatgaattctacgtgtttttcctgtcacctttagccagtgttaaag
-atgactatggagtttcgaataggttattctatagacattataacgagtggaacacccata
-ccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaagggattttaggttct
-taatccaacgaagaaataacgcatcacccgtcattctattgttttcgtcgggattactta
-gtaggcagggtattctaacctacctgagttacaaatctttaaaaaactggccatgaggtc
-atggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgt
-ctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcagttttatagctat
-ctagtggcattcctttttataaaactttacgtttgtaagggtccaactttacaaaagctc
-ggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgtatattgacggcat
-ggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaat
-gtaaagccggggattagccgccaaaggggtctaatgacatagagatgctctgaaatcgta
-ccaactataaaagcacgggatttgaaatatagcgacagatcttccgtattctgttagttg
-acatctgtgctgtctttaccgattgtgatttggctttagcagtcatttagtttcgttact
-cattgctcgtgcgatagttccaccgaatatggcacattcgttctttttttccattttact
-gcaaaccttttcaaaagctgatcgataccactgatgatggcattgattagtcgattggca
-actatgtcctgcttatatctccaattgcattgaatatagtaaaaaataaaggctcgcctt
-cccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtaccta
-acatataagtgattgagacaaatagttctccagacgtattgagatatatgtctcctatag
-gcaagcgtttctaattgctgaccagaaattagaattaggttgttaatactatattcgacc
-attttattccacgaatgtgctattctactggtattgctccgtatgcgatatataaccaac
-acggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtcatttaccgggag
-cgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaaagacttccgctt
-actatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatc
-ttttcagttcgcagatttttgccaatttaaccggttatttcgtcagacttggtagtgtag
-ttacaagcatcacgattatatcagctacagaattaaactgtcctgactcgacggggcagt
-gtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtcatagtacaagga
-taatgaggtttgctaactttaaaaattattgatttaacggttgattgaaaatctctgcaa
-gatgacgctagaacacctgatgttcaagtttgccgataataacatataagatgaattact
-gtctttagaccctcatgttaatccgctaacttagggcggaaacaatgttaggctatgcgg
-agtaagtactatattatgataccacatagaatttaacattcatatgatgtctaatacccg
-ttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatcaatgggccaatcc
-tgtctcaaaaattatcatattcaaggttcagctattttggcaatgggtgagtaccgttct
-tagtgatttacgaacccataatctaggcgacttaatatacaagatttagagttacgtttt
-ccgggtagtacatattaacgaccatggatcgggtgaggtgttgtattagttatctgatct
-tgtcagtagctcccaatgtcccagaatattatgtttctactagagtgttcgtatactgga
-atttaaatattatgtaagactagacaaattttatggatacattaggccatcgtagaatat
-gatatagttgtaacgtccctctatagattttcggagggcaggtatattgcttaataaaga
-tgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgcttaaataagttt
-agactattaagctatatgttcgacagcatgtagttttttttaccagaaagtgttatactg
-atgacccatggaggtagctcctcatgataaaaatattgttacttaagcattactattata
-gtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtttcttatgcagac
-acacttttttagctgttgacgcccacctcacatccatagtaggtcaatcgcataagaaca
-atattctggactgttttattacccagaagaaagttttttctttccggttcgttaagacaa
-taaagatcatttcattcgttctcttaacgatgaactaaagtacttaaagtatccgcctct
-tgtttcgactagcgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcac
-gtcggagataactctaatagtctctttattccgtttaatatagcccgtaattgcaccatg
-cgctacagtaacggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaa
-tggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaag
-cagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccct
-cactactacgcgaaggtactcgattattccttgaatgggctgaaacatcgtgattagcgt
-cttatgattcaggctgatagaagaaaacttattttctatattccacgtatacaatcacac
-tcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaa
-ttcgtctgggtgcataagtacagttagtcgtctgtcacataaataatccgcagtcgatct
-cattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaaca
-gtaaaactaccgtcacacaaggaatatcataatagatgccatacacggttttacttgata
-tgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaa
-tttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatggatgagcatttagg
-tattctatgataacactaaccatcatgtttctaaaatcctcaggaaatttgtattatttt
-accaacctgtatttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaag
-gagtacctgattgaaagaatggggaattgtaatctgtaactcaattacaaataagccgtt
-ctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaattcatactcgatta
-acgactttaatactcttctgcgtatctacagactcatttaaattacggaatatgttttcg
-tttttggtttccagctcgcacgtacgcgtttacaaataaggacacctggtacaattggct
-ggagtacaatgttggtttttatttgctgattatcccgatccctgtgggcgttggcataac
-cgggttttcttcaagactactttcgtgttgcttatatacctggtaatatcggtgagtagc
-ttagggcttaatcacaatactaacaagttctctatggattggacagggcggcatccgttg
-actgaacgatctattaatccattccctgcactggataaacaagacccatttaaattgacc
-atagagatgttagcgtcatatttctgttcgtgatagggtacatatattataaacggatta
-tgagcagtggttttctagaaaagcattcatagttaggagtgtatcagatcataccactga
-accatagagcacaattctctactggctatacttcattcctttttgtccgggtggggacga
-aatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaac
-ggttctaaatgttcttaatgagaattgcgtattttgactattgacagggcatcgtaaacc
-gctactcgacttggtatctgtaatctgtatgtagatagagtacgggcctataattcaaat
-tcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtg
-gtgtcaagccccacccattctctgttatatccgagcattaatgtagtttcactgtactac
-ggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctgagaagtggcacta
-taatagtttagcctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcg
-aatagattgcgttcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaac
-tttcataacctctttatttaccaaacctgttctactagcgttagtgttttagtctgtagc
-cgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaa
-actattggcttaacgtttaatcgaatgagactagcactgtattactctttcgtttcggca
-gcggatcaataaggaggtgacggcatcactctcttatagtagatatcacttattctcaca
-acggaagtaggatcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaat
-gttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgc
-ttacagtatccttgaggctcaacgggctatgcggaaattccagacctcgagttacattat
-gaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttgtaatataaacaa
-ccgtttttgtctattttcccaaggagaaggagagtagcagcttagtggcttgcctatatg
-gccccctaagtacgtactcggcacgcttagaagattgggctaccccgcactatatgttcc
-caaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaa
-tatacaattttggcaggggttatacattgcgggcatgaagagtaacattggacatgaacg
-gacattcgaaccctgtgagtttaataccctatctccggatcattataaagtaaatatacg
-tcacttactctacgtgcgtttagacagtctttgaaactaaattggttatttttctttcat
-ctagatttgtctgtatctaactaaattatagttccacataaagctgattcaactgaagac
-ataaatataaactttctaacatagtagcgaggaaagagctatgcctagcatcggatcatg
-cgtccgcgagtagttcctggtagagttaaaagtttttccagaatctagaccgaacacagg
-gtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgt
-attgttgctgtatctatatttcctacgtaaggctatttgatctataatatgaaaagtcac
-gtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctccttagtatcatcaa
-attatagattttacggccacgaattattggtctagatgtcccaaaaataatttgatgtca
-gtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattatgctataccaaga
-actctccatccagtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttga
-cagatctgcatgcaaagtaacttgtaccagatggcttttataatagaaactaagtttccc
-gaataacggtgtacgataacagatttttaggtgtacagacgtctgactcaatgaacacac
-attgggacctgccccgggaggagtagtagataattaccttctccagcgcgggtcttttaa
-tatcacaacataaaaatactaattaatatcacacaccctcatcctcgatggagcctagca
-tcatacacgtttgatagacaacgccaattttactgtaatatgatattcgaatctagtatg
-tggacgctgtaccacattgtttaaaggagctccctttaccgacatgaacgaagcaagctt
-tgtacaagatacgaagaactcagtactggtaactataagagacaatttatacataaaagt
-gttaagaccattatataaaaagaggtatgaggtctttgtaactacaataatacattcatc
-gaacgatggagaataacagagttatttctgctgctcgagctctagttctgctaatttctc
-aatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcgtacatccctctc
-tcctactcttacctatatcctattactggttaacctacatctccgggaaagacgtaggta
-aagtggtccacgattgtattcacttataacacctagtagtactatgtgttgctgagagtg
-aggacacacttactctacgagttcaagtccatatggacattacactttttcagcatctag
-gtgtcatgatgtattaacagccgttaggggctatttgattttatcgattgtcggcgtgtg
-tattttcaacaactaggtgctacaattcgtgaataggcatgaaaattcaagattgcagtt
-cctatcttgtataatctttcctttggacgagttgtaccatttcaactaacctgcaagtgg
-ggggtcatccatatgaagatttgccaaatacctggagaccctgaaaagtttatccagatt
-aataataacaaacaaacctaagcgaagaacgtcagctttaataaactatcactatcatag
-aaattcctgttaattgttcttccaaacgttgaatagactatcacgggtaatagattgaac
-acggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgataactcaattatat
-tcgatggagaattcatatctaccgcttagcttttaaaaattaagtcagattattccgcca
-caatgagaaggcgcgagtgcactaatcaaatcacttaggattattacggacgtctgcatt
-acaatgctttggggtagggttatacaagcatatgattctttaggtctcttgatcgggcgt
-ttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtg
-tataggaatgcacaacgcaaatctttaagctgacctgttcatgaaagacaggagacacga
-ggcaccacctcaattctatgcaaaactctaacatagcgtggcactatgagtacgtgtaac
-gacaaggtctcatactcgatcctaagataattctcgtctggaaggttttaatctttaact
-aagagtagaacttagtttattgacttttacaattaggatacggttcgcgactctaccaca
-gggcatcatacctggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgg
-gtcctgcatctactgagcaatccctttaagcattcctagtttgagagccatttagatatt
-gctgtttaaaccgattaatggtttctattattataaagtgtaacgctcccattcgggaca
-ttgaaaattagcaataagacaatgtatgatattcggcgagtctcaacaacattatggtct
-accatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttc
-gttaagtgagggtatccaggtgttataaggacgatctagaagtattcaggtacacggtgt
-tcagacatgctctaattgtcaggttgtttataatttaacgtatcgctctctattctaaat
-aatataaaattaaccgctcgtagggatgctttccagtaaaagatacactatcattaaggt
-tatgcaaatgtggcgatttgatttgaatcttagtacattcttaaacttaaatacgtatta
-tttaaagtaaatatattatctaaaccgcttttgtctatccacatttcgtcgaatcacgac
-ctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatctatttcttctga
-ttgatgtaatactgacccttactccgtacatacaaatgatggtaagcaagaatgactgac
-gctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggat
-atggatgtgtatgccaggcttcattttgacaatttttctgtcctgctcagtgttgtctga
-agtcgtatcgtacacaataatgatgactctcattgtagatccaatcacgctttcctacgc
-taatgaaagttctagatagtgtaggtgttagacagaggttagcgcctacatccttacaca
-cacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtatttgtttggaata
-tcatatttctcccgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataa
-aataactgctgccctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatga
-aaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttat
-aaatacaaagagtacatttagttaccggattgcggcttgacatttattttacagaatttt
-atcggcaaaacacttcatatgaactatcgcttcacgataagtctatgatagactagcatt
-cgtagagaacaggaagagcaatcattatatatgaagtgttacagtgggtactacatatga
-gatcattaggtctatatccggccttcctcataagaccttggaaatatcttacatcagaga
-tatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacg
-taatagtctggttttaactaggggttattgatatttaagctaaaagagttccctgaacac
-tcgaaatgtataatctatcccaactaaaaaagtatacctctaattcagaaatgtcattga
-gattagactgatgtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaat
-tgaaatgtaatacctccatcttaagttctatattttaaagttttatgcggacttcgagta
-agtgcacaaatgatggcataagtgcccagttacatgtttgcggccccgtatgagtaatga
-tctgtttatcaatctctagctactatcccacgaatgcactgatgccagtcatggcgctta
-cattagtcgacagaaatccgacgatacctatcacgcgtgaactgttctggttcttattca
-attcgaagtgatctcagatacattacggccatgcttgcccttcatgtctgctgagcagtt
-ttgttataggctgaatctcctctaagcgaaattgataggatttttggtggtcgatttagt
-ctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaatgatagggatcg
-gctgaggaggataaatatacgctggtgcctggtatttatccagaacaagttgcctgtgta
-tcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaaggccgcaaaggg
-ttacatctcaggatcgtggcgtatagtccaccattagttctgacttacttaatatagact
-gaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaac
-gtataggagcatgatcaaagaagagttaattaatagtactgcactataattgtcggcgga
-gtaccatgagctgttgcccaattcgatgtttattaacagcacgcataaaaaatccagact
-tttcaattagaattaactataaatggtccgcgaaccttaaatgatcggaaggacgggatc
-tgccgttgtatagaccccaactctatctaatttttataacacctctgtaatcaacaaatc
-ttattatgccatcattatgtcattcgccaagtaagtccagttcgagattctctggaccgt
-gcaatagtattgtcaaattatggtaatggaatccttcttctaacacccttagaaaagcca
-cgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgccgtttctttttac
-gatgatagggattcttaaagcttttctctattctagatcccagttgccatcatcaatatc
-tcaattgatgctcattatatagttcttatttagtatgtccagatgtcactgaagatcctg
-cctagaaccgatattctcgacaggatcatcagttcgacggggcaaacgcacctatgcaca
-tccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaact
-cctgtccacgatatgtaggcaagttttactgcctttaattagtagtcgattagtgtagtt
-tgatattatctaccttatagaatgtaaacagtaacccggccttaatggtttggcaggatt
-ctttgtaaaagttaataatgttcataaactttatcagaaaacctgaagtagtccgccttt
-cgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgtcttgttgtccga
-gtacacatattgctcctctcccccactcttctaggaaaatcaattatgctaacctgcaga
-ccttcttctttactatctttaatgcatgcccagtatgttcatagggtagacttgctatct
-attttgtataatctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggt
-ataatttgagagggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataa
-taggattaagcaggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaag
-tatgactgtgcagtattaattttgaatacatattgcagcccctaggatacattatagatg
-tctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaa
-ttagccggaattacagacacagattcttgtttacaattgtgggaagaaaaccacctcaaa
-cgttgaaacctacattcacaaatggattacgttggggatgagaatcgattccggtcaaaa
-atcatgcccggagcaataaccaagaattcacagaggattaatacacttctccatgaagat
-aggactgcttgcactatccttatctttgtgtcttccttcaagcaccaatcgtttggggac
-aaccacaattatgccaagaaataacggaaggtgttccaaatctatgagtccgcggtttca
-tcgcaacgtttcactgtgggtatcatgactttggactttagatttgggtattctagagac
-tgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcac
-gttgtgctagggatgtttccttaggaatccatacatgtaagaaagaatcaaccgtaatta
-tagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatag
-attgaatattctggacagcagcgaatcctgattatatctcaagcgaatatatgacccgca
-agaaggatttatactagaataagtctaagaaagggcattgggtcacttcttccactaaca
-cacttttatcagttttataccttgagagtcccatgcatttttatatatatttaactttcg
-ttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgt
-cgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttag
-ctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatc
-aaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaa
-agtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatt
-taccagtcttttagtttcggtactatttgatcgggacattcgtccaaacatgatggctca
-ttcgttctttttttcaattttaatcaaaaccttgtatttacctgatacattaaactgagc
-atcgcatggaggtggagattcccatatatgtaatcatttgatatcctattccattctttt
-tagttataaataaacgctccactgcacaatgggagtaggacttcaccaataattagcatc
-tactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaac
-ttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaatt
-acggtcgtattacttgttgccaaatggttattactccaatgggctattctaatccgatgg
-atacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaa
-gctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattg
-ttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaatttgttatgtcc
-agtcgctcgtatatcaaaagattcggttaagttcgcagagttttgccaagtttacaggtg
-atttactaacacttgggagggtacgtacaaccatcacctggttagcagagaatgaattat
-acggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgca
-ggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttt
-tccgttgagtgataatagctgcaacatgaagatagtaaaactgaggttaaactttcacca
-tattaaattatatgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcg
-cgcttaatatgggtccctatcccgactttgtacgagattttgataaaaaatagtattgta
-aattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgcta
-tttccctaagaaagcggaaaatcctggctcaatatttataatagtaatggttaagattgt
-ggcccaatcgctgagtacccgtcttacgctttttccaacacataatcgacgagaatgtat
-ttaaatgtttgagacttacgttttccgcgtacttattattaaagtcattggagagggtgt
-cgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatctattggttgttt
-ctaattctgtcgtccgtgtaggctatttaatttttatggtacacttgaatatgtttagcc
-ataatgtagccaatactacaatatcagatacttgtatacgacctatagacttttgccgac
-cgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaag
-catgcgaagcgagtatttaactgttgactattttgctatatgttactctgaatgttgttt
-tttttaccagaatgtgttataatgatcaaccatgcacgttcctactaatcatataaattt
-tgttacgtaagcttttctatgatagtggtctaaagactacccttgcatactttaagatta
-agacatgcactttaggaggaactcacacgttttgagctgttctagcccacctataagcca
-ttcgtccgcaatcccataactacaatagtcggcaatcttttattacccagaactaacgtt
-tttatttcccggtacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacg
-aaagttatttatgtttaagccgcttcttgagaatacagattactgttagaatgaaggcat
-cataactagaacaccaacgcgcacctcgcacattactctaatagtagctttattcagttt
-aatatagacagtatttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttat
-gttattccatgtggtcggaggatttgcggggcgatagcgctgggcggggatcaacaattt
-cgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcac
-tcgctagaagtgttacaatcacatcacttcgtaccgaagggactactgtattccgtcttg
-gggatgtaacagactgattacagtcttatgatgaagcctcattcatctaaaattagttga
-tttattccacggatactatcacactcctatagaaagagttaccaccgtgggaagctagat
-ataataaataaaagacatacaatattagtatggctcatgatctacacttactcggatctc
-tctttttttataaccagtagatcgcattacacgtattgttgttccgcatcaggccctagg
-ggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaagatattaataga
-tgaaatacacgggtttacttgatttctgttcagtcattcacgggaaatcctaggagtctt
-tcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattgg
-tatttcctggcatcacaatttacctagtattggagatcacttaaaataatgttgagataa
-taatcaggatatttctagtatgtgacaaacctctatttagtgattgtgattttcaattaa
-acaagacgtaggggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatc
-taactcatgtactaagaagaagtgctttcgtttaaggctttctgtctaacattctaacgt
-caattcctatgtaatactactgtaaccaagttattactcggctgcgtagataaagtctca
-tgtaaatgacggtttatctgttacttttgggtttcaacctagctaggacgccggtactaa
-ttacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgtccggattataac
-catccctctcccacttggaatatcaccgggttcttaatgacttagttcgtcttccttatt
-ttccgggtaagatcgctgtggaccggacccattttgatctagtctaaaaaggtatatagc
-gtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgcactgcactggat
-taacaagaacatgttatagtgtactgacacatgttagactaagaggtctgttcgggttag
-ccgacttatatgtttaaccgattttgacaactgggttgagagataacaatgaagagtgag
-gactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatt
-taattgttctaaccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtatt
-gttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtg
-actattgacagggaatcctaaaaagctactcgaattggtatatggaagaggtatgtactg
-agaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagcttaactagtttga
-tggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatgggatatcccaga
-atttatcgactttcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaac
-ttttgaggatgagtactgccactattatactgtaccatttgtaacttacattttatatct
-tcaaagaggtagatattgtcggccattactgtcacttacactaagggtagcttgattact
-gatacctctcatggtaaaaagtaatttaagaacctatttttttacataacctctgctact
-accgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcag
-aaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcctatgagaatacca
-ctcttggaatcggtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggt
-taggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgcca
-aatgcagaaatcttacactcttttcttaactaagtatgagagcaacctcactcctgaaca
-gcttgttacctaacgagaagaggctttaagtagcctggagcctcaaccggatatccggat
-ttgactctcatccacttacatgatgattacggtcattacatctcatgattttctgagtgc
-cctatagactgggaatttaatctaccctgtttctatttgttaacaaggagaaccactggt
-caagatgacgcgcttccatttatgccaccataagtaagttctcggaacccttacatgatt
-ggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtggcctatcatattc
-aggtcatcgagctcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatg
-gaagactaacattggaaatcaacggaattgacaacacgctcactttaataacctatctca
-ggataagtttaatgtaattagacggaactttctctaactccgtgtactaactctttgaaa
-ataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaaagtattggtcca
-aataatcctcagtaaaatcaagtcataaatataaaatttagatcttaggacagaggaaag
-tgctttcccgagcataggatctggcctacgccagtagttcatgcttgtgttaaaagttgt
-tactgtttatagtccgtactcagggtagtgttcgatactcagcggggaactgacatatta
-cactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaattacttacgctat
-ttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaa
-ttcacagatactgtgtatcatattattatagatgttaaggcatagaattattggtattga
-tgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagtgcagcttggaag
-aactggatgtatcctataactagtaagagccttaaaggtactacatacccagggatgtta
-ccatcattaatttggccatcttcaatcttcgcaatgcatactttcttctacaagatgcct
-tttagaagacaaaataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaa
-tcaagtctcactaaagcaactaacattccgacatgcaaacgcaggactactagattatta
-aattcgccagcccgcctcgtttaatataacatcataaaaattctaagtaatatctcacac
-actaatccgccatcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcg
-atgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaaagctgctacctt
-gaacgacatcaaccatcctacctttgtacaacagaccaacatctctgtactggtaaatag
-atctgaaaagttataaatataactgttttcacattgatagaaaaacagctatgtgctatt
-tgtatatactataataaattaagcgaaacatggagattaaaacagtgttttctcatcctc
-cacctcttgttctgctaatttataattcttgatgccactcgtgtgagtcgtccattcgat
-cgtaaagaacccgacataaatagatacgacgctgaacgagatcctatttctcctgaaaat
-tattagcacggtaactcctagggatagtggtactagttggtatgaacgtataaaaacttg
-tactactttctcgggatgtgagggagcaaactattactcgaccagtgcaacgcattatcg
-acagtaaaagttttcagctgatacctgtctggatggattatatgcaggtaggcgagagtg
-gattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttag
-ccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcatttcgtccactggta
-ccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgcaatagtactcca
-gaccatgaaatggttatccagattaataataacttaatatactttcactacatactcagc
-gggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagag
-tctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtag
-aatatgatgttaaatcatttatattccagggagattgaatagcttacgattagctggtat
-aatttaactcacatgattaagcaaatatctgtaggaccgagggaaagaataaaataaagt
-accatgagttcggaacgctgcattacatggcgttgggctagcctgatacaagaagatgag
-tatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagc
-agatgattatcgtctaacactgtctttaccaatgcacaacgcatagatttaacctgaact
-gttctggattcactcctgactacagcctacaactcatttctatgcataactcttaaagac
-agtcgcaatatcagtacctctatacacatcggatcagactagatcataagataagtctcc
-tctggatccttgtattctgttaagtacactacaaatttgtttagtgtctgggacaattac
-gataagggtcgcgactagaccacagggcatatgacctccaccgctcctagcgagtctcca
-atctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttac
-gagggtgagacccatttagatatgcctcgtttaaccgttttaggcttgataggatgagtt
-tgtcgatccatcaaattcccgacattcatattgtccaataagtatatctagcttattcgg
-actcgctaaactaaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaa
-attatagtcaatctcccatggggccttatggcagcgtatacagctggtataacgaccata
-tacaactatgaacggactagctgtgaactaagcagattattggatccttgtgtataattt
-taagtttcgatctatatgctatagtatagaaaatgttccgatcgtacgcttcctttacag
-ttaaacagtctatatcatgaagcttatccaaagctggacatttgatggcaatcttactta
-attatgaaacttaattacctattattgaaagtatttatatgatcgaataagatttgctct
-ataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaacctaggtaatct
-aaagcctgcatctatttcttatcattcatgttatactgacccgttctcagtacttaaaaa
-tgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaataaactgccgatg
-ggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggt
-tatctacggataactgtgcgatgaactactataggtcaaaattatcttcaatctcattct
-agatcatataaagatgtccttcgcgattgatacgtctacagtgtgttggtgttacacaga
-gggtagcgactacttacttactaactctctcttgatccgcaagcataagccaggttaaag
-tgctctatctttttctgtggattataatagttataccgccttgcatctaggtgcccatta
-ggtaatgccctagtgttttcataaatttactcctgccatctaacgttactttaatttccc
-agattcaataggtctctcatttgaaaattgttatatgtcaacaaagaatataatagctga
-gtggaacaatacactgtgagggagtaatacatactctaaattttctttacggtttgcgcc
-tgcacagttttttttatctatgtgatccgcataaaaagtaatttcaacgttccattcaag
-ttaagtcttggtgacactagcattaggagagatcaccaagaccattatttatttagctag
-ggtttaagtcggttagaaatatcagataatgaggtctttatccggccttacgcagtagaa
-attggaaatttcgtaaagcactgagttcaatggaagtatggccgaacccacataatgcac
-aaatcaagtcgatttcttccgtccttttagtctcctgggaactacgggttattcatagtt
-aagctaaatcagttaacggaactagacaaatgtataatagttcccaaatatatatctata
-aatcttatgcagttagggaatgcagatttgaatcatggcaatacgctagctcggaactca
-actacaagtgttggatgtacgaattcaaaggtattacatccttatgatgttcttttttgg
-atacttttatgacgacttccacgaagtgaaattatgttcgaatatctgaacagttacttg
-gttgagcccaaggatgacgaatgttctgtttataattctcgtcataatataaatacaagc
-atatgaggccagtcatggagctttcatttggactaacatttccgtagagtcatatcacgc
-ctgtaatctgatccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgt
-gacattcatggctcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtt
-tggattgtgggtcctccattttgtctgttaatgcttattaagattaaaaatgtactacgt
-atttagacctaatgattgcgatacgctgtggaccattaatataagctgcgccaggggatt
-tttccagatcatctggcctgtgtatatgttcaaatctaatagccgagagaaattactccg
-acggaaaataaaggcagataagcgtttcagagcaccatcgtggcgtttagtcaaccttta
-gttcggaatttattaatatacaatctcactctttggacgagctccttaaaagatgccctt
-gtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatac
-gactgctctataattgtccgaggagtaccttctcatctgccaatagtcgttgggttggaa
-aacaacgcattaatatgccacacttgtcaattagaagtttctataaaggggacgagtaac
-tgatttgagacctagcacggcagaggacgttcgtgtgacaacatctctttataagtttga
-gataaaatcgctaatctacaatgattatttgccaatcattatcgaatgcgcaaagtatct
-cctgttcgtgattctagcctaaggccattactatggtcaaattatgctaatcgaagcagt
-cttctaacacccttagaaaagcaaacactattgaatactgccgccgcattcgccagcacc
-aacataactgcacgtgcttttttccatgattggcattatgaaagatttgatctatgattc
-ttaccagttgcaatattcaatttagcatgtgttcctaattattgtgttattatggtctat
-ctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcaggatcatcagttcc
-tcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgt
-accgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttt
-tatgaggagtcgagtactgttggttcatatttgctacatgattgtatgtaataacgatcc
-cgccctttatcggttcgatcctttatggcgataagttatgaatcgtcagtatctttagat
-caaaaactcaactagtacccagttccccggaggaacggtcatgattaatgcgttttacgg
-tctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccactcgatgattggt
-atagctatttgccgaaaagccacaacgtattcggtactatcttgtttgattcccctgtat
-cttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgaca
-cttgttacaattatccagttgcgtttaatggctgtgggtcacaagattgttagacaggtc
-ccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagctcacccgcctaag
-tgatccaaccctcatcaggataactatcactgggcagtattatttttgatttcatatgcc
-accccctaggagactgtagtcatgtatctttcttacccaatctagcccgaaacaagaaag
-aatgtcgattccagtcaccttttattagaccgatttacacacaaagtgtcttggtttaaa
-ggctggcatgaatacatactcaaaagttgaaaacgacttgctctattcgattaccttcgc
-gatctcaatcgattacgctaaattttaatgcccgctgaaatatccaacatttaaaacagg
-attaattctctgatccatgaacttaggactcattgcacgtgacttatctttctctcttaa
-ttcatgctccaatacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgtta
-ataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggac
-ggtacatttcggttttatagactatgtagttacacggcatcaacatgtaattaaaacggc
-gtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggaggattacatacat
-ctaagaaacattctaaactatgtatagtcgtttacgacccttgtagtacgtgcatccctt
-ggcgaaaagtactctgggtattagagtgtatattatcgacagcaccgaatcctcatttta
-tagcttgacaatttatgacccgaaagaaccttttataagtctataagtatatctaacgca
-attgcggcactgagtccactaactatctttgagcagtgttatacagtgagacgccatgga
-aggggtttatatattttactgtcgttccctaaaaagttaattatcagacctgcgcgatct
-cgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatc
-aaccgtttctgcggatcgcgttacattccttgcttatttgcgataaatcgatacaacccc
-attaccagaaaaacccggagaatcaattactctgcagatcttatactaaaaaagagatta
-caacccctgttctatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagc
-gattttaactttcgcttttccattttccagtattgtactttacgttatatttgagcggca
-cattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaatcaaataattgta
-ttttcagctgactttaaaatctgcagccattggaggtggagattccaatagatgtaagca
-ggtgatatcatatgcaattcttgtgacttattaagataccagacacggcacaatcgcagt
-agcacgtaaacaataatgacaatcgacggttaaattccgaacgtaagatatgtttacgga
-tgcactaaaataggtagcaacaacgtttctctgagatgtataagttaccaaacactggag
-aattccgctaaactaaggacaatttccgtcgtattaattgttgacaaatggttagtaata
-cattcgcagtggataatccgttgcatacctagcactgagtgtaaataaaaccaatcgact
-actggcatttcgggctaacgactagatgttagcctatgtgaaagcctcacacatgcttat
-tgccttcacggtgagcaatgtttcttattcgttattagaagtcacctgtagagacagtag
-agatgacctaaatttggtttgtccagtcccgaggtgatctaatgattaggttaacttaga
-acagtggtcaattggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaa
-actggtgagaacagtatgatgtattcggtcatctagacaaccccatcgctgggagtttgg
-acagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccgggg
-agatagggttaatttaggcttttttacggtgtggcatattagctcaaacatcaacattct
-taaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaa
-taagcttaataagatttaggtccgaccttaatttcggtccatagcacctctttctaagtg
-ttttgcttaaataattgtattgttattgattttctgcgagttgaacacggaaaataagtc
-aaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttt
-tagattagtaatcgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttcc
-aaaaaattttagtccactaggtatttaaatgttggacactgaacgtggaagccgtcgtat
-tatgaaactaatggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcaga
-aaaaggtaaatcttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtt
-tggttcaagtgaatttgtttagccagaatggaccaattacgtcattagctgttacgtcta
-tacgaaatatagactgtggacgacccatcgtagagtcatgtagttacatgtgaccttaga
-acaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactggtcaattggttca
-tagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcct
-ccttcctaataatcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaaga
-cgaaacggccttaatgtaacattaactattccactgtaggtggatctaacaaggttggac
-atgtgctaccaataagataagaatttcgtccgcaatacaatatctacttttgtagcctat
-cttggattaacaacaacttacgttggtatttcaccggacgtatcaaatgattctgatttt
-aatgactgagagtaaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtc
-acattactgttagaatgaacgcttcattactacaaaacctaccaccaactcccacattaa
-tattatactagatgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgtta
-cgaacacgtacattaaattgttagggtattaattgtggtcggtgcatttccggccccata
-gcgctccgcggggagaaactatggccttcatgacagcccccccataacatctaggtaatg
-gtcggataactataaacaaccctctccagagaactgtgaaaataaaatctcttagtacac
-aagcgtatactggtttaagtcttgcccatcttaaagactcttttcactattttcttgatg
-cctcattcttctaatattaggtgattttttaatccgagaatataaaaagacgatagaaag
-tgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttttgactatccctc
-atgatctaaacttacgcggagctatctttttgtataacatgtacagagaattaatccgat
-gcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaac
-gcactataccaagtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtca
-tgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagct
-cgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtccgaggattgctga
-taacttaaaataaggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtt
-tgtgtgtttgtcattttcaagttatcaagaactacgggtataatttacgacgtaatgttg
-gtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactgctttcctttatc
-gattgctcgagaacattataaagtctattactatggattaagactgtatacaagtgttta
-agcggagcccgtgataatctataaggttttggtacctttatctgttacttttgccttgaa
-acatacatacgtacacgggaatatttacctaaacgccgtatagtccagcctcgtatttgg
-gccgtgttttgtcagcattttaaactgaaagcgcccacttgcattataacccggtgcgga
-atctcttagtgactcgtcaggagtttacgcctttgagacctctcgacaggacccattttg
-atctagtcgttataggtagagtgcctttcctatcgcaccattaccttctagcaaacttag
-agtattcaatgaaatcatatcctgtttatactaaatgttataggctaatgacacagctga
-cactaagaggtctcttcgggttacccgaatgagttgtttatacgatgttgacaactcggg
-ggagtcatttcaatgaagactgaggactcttgatcagattaaaacgcttaatgactgata
-atttagattatgccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctg
-agaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcg
-gctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactatt
-cctagagcgaagagctatgttctgacacgtccccaatattaggcaaaggctccaaaagaa
-cagtcaattgattaactacgggcttggtttctccgtgaatccttgcgccgctataccaca
-taaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagta
-cactagcaaccccttagcaattaattttgtccatcactactgccaagagttgactggacc
-agttggaaatgacatttgatatattaatagagctacatattgtaccactttactgtcact
-tacactaaccctagcgtgattactcatacatatattcgtaaattctaagttatgatacta
-gttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttcaactaaatatttc
-actgtagccaaccactttaaccagaaggataccttaatgccgatataatattgtccagga
-aacgttaatactttcacaagacaaagcttggaagaggtactttacgatcacctgatagat
-cgaccggaacgattctatataggtttggtctgagaaatttgtagctaaaaccatgttcca
-taggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatcta
-tcacagcatcctaactcctcaacagcttctttcctaaagacatcagcaggtaagttgacg
-gcacccgataacccagagcacgattggaatctaatactctgtatggatcattacgctaag
-taaatataatgattttctgactcaaagttacactgcgaattttatattaactggttctat
-ttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatcta
-acttataccaaccattacttctggcgcagaaaaacatagatatctgaacaatcgaccgtt
-aagactgtctcgccgatcttaggaacctaatactgctcagtagttattgtttatttgggc
-catccccggattatgtcagccatggaacactaaaagtcctaatctaacctatggacaaaa
-agctcacttttataaaattgctcaccttatgttgattgttatttgtccgaaatgtctata
-actcagtgtactatctattggaaaattatggccggagttttattgaatatacttttgtat
-gttgagaaagaatgttgtcgtaataattatcagctggaaaatcatctaatatatattata
-ttgagatattacgacagacctaagtgctttcccgtcatgagcagatggactaacactctt
-ggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcccgactcttactt
-actcagagcggaaatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggt
-tatttttttaattacgtacccttgtgcagagagtttagctattcgatcctacttagtatg
-aaccatgagagtacaggttggtaattcacagagaaggtcgagaagattatttttgatgtt
-taccaatactatgaggcgtattcatcgaaataattttatggctgcgcacttcacatacgc
-aggaagaccactgcagcttgctagatctggatgtatcattgtacttctaagagcctgaaa
-ggtaatacattcccagcgagcgtaacagattgtatggggacatattcaatcttagcaatg
-cattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaactataaccctgg
-aactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagca
-aaacccaccactacttcagttttaaattagaatcacaccctagggtattagataataatt
-aaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaataagtctccggt
-ctttcacaaacacatggttaagcgatgtggttttgactagagacgttcgccaccatcgta
-atatttctggttacctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagta
-caacttatctcttatcctatagagatctcaaaagtttgtatttttactggtttcaaattg
-agagaaaaactgcgttctccgatttctatattattgtttaaatgatgccaaacatccagt
-ttaaaacacggtgtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaa
-actacggtcacgcgtacattacagagtaaactacacgaatgaaagagataagaagatgaa
-agagttaataggtctcctgttaattatgagaaccctaactactacggattggcctactag
-tgggttggaacggatataaaattcgactaagttcgcggcatgtcaggctcctaaatatga
-agagaactcggcatcgaattatccacagtaatagttggaacatgattcctctatgcatgg
-tgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatatt
-cttcctcagaaaaggactgttgagcaaggaattggattctgtgaacggaatatagtcgag
-tagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacat
-atcttcttggcaattagtactccactaaatcaattggttataaacttttagaatatcttt
-atataagttcactacttacgctgcgggtagtatatttaaagtgatgtcttaggaatctta
-tggcggcggaataaacggcttgactatagataccctaattctggcataaccctgtaacgt
-gtgaagcatgctttaatagacgactagatcagcttatagaatggatatgactgccacatt
-gaagagattaacattagcgggtataatgttacgaacttgtttaacaaaatagctctacca
-cacacgcatagtataatataaaggtcctggagttcgctacgagcctggaattgcagttcc
-cctaccctgagtaaacaagatcagtatggacctatcttctgacccacgtgtaaaaactac
-cgttagcggccctgagaacggtgaagttgattatcggctaacactcgctttaccaaggaa
-caaacaattgatggaacaggtaagcggctggattctatcctgaatacagcataataatat
-ttgctttcaatatatagttatgacactcccaatatcactaactctttacaaatcggatat
-gaagagtgaattagagatggagccgatcgttccttgtattctggtaagtactcgactaat
-gtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaa
-tcctccgagcatagagactctaaattcgccaagcaataagtcccgacgcgaaggatgaga
-agctcattgaactgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaa
-gtttttgcctggagtggttgagtttcgcgatacataaaaggccccactttcatatggtca
-aatatctatatcgtgctttggacgactcgataaactaaagtagcctagtaatgccctaaa
-ccgctgcatttgtgcaataaaaaatttagagtatatataacttccggacgtatggctgcc
-ttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcggaactatgcaga
-ttaggcgatccttgggttgaatttttagtttccatagatatgagttagttttgatatggt
-taccatacgtccctgcattgaaacttaatctgtatattgattgatccttagcaatagcgg
-cacatttctgggcaatatgacttaattaggttacggtttttactatgatggatacgtttt
-atatgatagaataacagttgctatttaaacaggtactacattcaactaatactgtttcac
-tattgtgtccaacatagggaatatattgcctgaatagatgtattatcaggcatcttttac
-gctccaggtagaactaattaaaaatgatccttagaaactttcaagcaacataagctaaaa
-gttacgccaattataagccacatcggtaggatcttcaggcattcccatatccttctctat
-caatcccgtctgttgctaattggttatctaagcatatcgcggcgagcatctacgataggt
-ataaagttgctgctatctaattcgtcataatatatacatggaattacagattcatacgtc
-ttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatatctctctcgtgtt
-acccaagaagttgacacgtgattgtcagctatctttttctggcgatgttaatagttataa
-acaattgcatatagctgcaaattagctaatcaaatactcgtttcttaaatgttatcagca
-aagctttaggttctgtaatttcactgtgtaaagagggcgctaagttcaaaattggttttt
-ggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctc
-taattggtctttacggttggaccaggcaatgggttttttatctatgtgataccaattaaa
-agtaatttcaaagtgacattaaacttaagtattgctgtcaagaccattacgacacttcac
-caacacatttatgtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgc
-gttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaag
-gtgcccacatcacacattatcaacatatcatgtcgttgtattacgtccttttactagcct
-gggaaataccggtgattcagagtgaacataaatctctgaaagctactagacaaagctagt
-atagttaaaatatatatttcttttaatattaggatctttgcgattgcacatttcaagcat
-cgcattaacctacctccgtactcttctacaacggttgcatgtacgatttctatgcgatga
-aatacttatgttcttagtttggggttactttgttcacctagtcctcgaacgcaaattagc
-ttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataat
-tatagtcagaagataaatacatgcatatctggacactcttccacatgtcatgtcgactaa
-ctttgaactacagtcatatatagactgttatctgatccgtatgtgtctattactactctt
-atctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcggggctttttccct
-gattataagattacactattgctgtgcttggggcctcctactttttctatcttaatcatt
-ttgtacattaaaaagctaagaagtaggtacaacttatctttcccatacgagctggaccat
-taatttaacagccgcaaggcgagttttaatgttaatctggaagggctttatgttctaagc
-ttttagcactgagaaattaatccgtaggaaattaatcccacataacccggtaagagaacc
-ttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcg
-acgagctccttaatacaggccctgcgttatattcgaccgtacctataactagaccaccat
-cttaaatgtacagttatggttttcgacgcatagagtatgggaccacctcgaaatgctcag
-ctgcaaattgtactgggggtggttatcaaacatttaatatgaatctatggtaaagtacta
-gtttatagatagccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgt
-cacaaattagattgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaat
-atttatcgattgcccaatcgttctactcgtactctttatagcctaacgccttttcttggc
-gctaattagcctaatccaagaaggagtctaacaaaattacttaaccatactcttgtctat
-tcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccag
-gaggtaacattggatctatgagtcttaacagtggaaatatgatttttagattgtgttcag
-atttattgtcttattttggtctatctcatcagctatagctacataatgacgtcttaactg
-tttcgactaaccttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaa
-cgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacag
-atctaccattcgtggaatcaatttttggacgagtactggtcgggtcgtgcttatttgcta
-caggattgtttcgtataacgttcaagcactttagcggttccatccttgatggcgttaact
-gatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaa
-cgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtc
-atcagagacaaatagatgattcctatagctttttgcagttaagccactaagtaggcggtt
-ctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtat
-agaccattcttcaggcccgccacaatggtttcaagtttcaacttccgtttattggctgtc
-cctcaatagagtcgttctcagggcacgactctcgttcgttattcataagtccagtttgat
-ccacgaatacagaacacgcatatctgataataaaagcttaacgataactttcacgcgcat
-ggtttatttttgatttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaa
-aatttagacaaacataaaacaaagtatcgccattacagtctcctgttaggagaacctttt
-tatcaatatgtgtaggcgtgtattggcgcccttgatttaataataattacggctaaacgt
-attgatattttccaggaactgccccatctcatgagatgaccctaaattttattcacacct
-catttttaattcttttatatcacgattatttatctgagcaagcatctttgcaagcattca
-tagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgctaaacatattggtt
-caattcaatgtaagctacctcggaatttgcttgcactaagacggggaagccaaaacggta
-aatcgccgtatatgctagtgccaagggacttgtccgttggagtcactatggagttacaag
-cattataaatctaaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccc
-tggggtacggaccatgaaatacttctttcatacatgataaacgatggagactcggttacc
-accctggtagttactccatcaattggagttaactaagatcgctattacaggctttattag
-ccaatcatcacaagcctctttttagagattcacaagttagcaaaccaaagttcctttgat
-aagtctttaacgagatctatcccaattccggctaggagtaaaatttatatatttgagatc
-ggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtccttccctaattag
-gtaattttcagacctccgagagagagtagatcaacaacgcgttatactcctaaaatgctt
-gtcgataacatgacactacagatcatccctggatgagcatcgactttcattacttgatta
-gttcagttaattcgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgca
-catcttagactaaataacagttttcataccctgggatttgtgtcactatctcaggaacgt
-cgagacgtcccctatcaccgcagcgagggtaactggccctgttccattgtaatcgatggg
-acgggacgttatattgcagacccaaagtagtaataaattcagccatatggacggaggggg
-ggaattgttaagaatataattcgattttcagctgaatgtaaaagctccagccattcctcc
-tccacttgacattagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgt
-ttccagacaaggaaatagcccagtaccaagtataatattatgacaatagaagcttaaatt
-cacaacgtaacatatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgt
-gcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagttcccgactatga
-agtcttcacaaatggttagtaataatttcccagtggagtagaagtggcataacgtgcact
-ctctgttaataatacctttagactactcccatttcgccagaacgtcttgatggtacccta
-tgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatt
-tctacgaacagctagtgaaaggactgatgacctaattttggtttctcaagtccagacgtg
-atattttgatgaccgtatctgacatctctgggcaattcggttaacctctggtacgaaata
-gtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttttagctaagctac
-actaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacga
-attcctaatactcttgctcagggcacttagggttattgtagcctgtgttaccgtctcgca
-tattagatcattaatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgt
-tctgataggtagacagctaataaagatgctgttgaacagttacgtcccacctttattgcc
-ctacagtgaaactagttcttactctgttgctgtaatatgtctagggttattgatttgctg
-ccacttcaaaacggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaa
-tccccaattgaagccagaaattttgagatgtcgattcctgatcattcgccaaatttacag
-ctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggct
-caaggtacgtggaacacgtagtattttgatactaatgccagacccgctacgatccctgta
-ctgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgac
-tacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaa
-tgacgtcttttgatctgacggcgttaacaaagatactctgggcaacacacatacttctct
-catgttgtttcttcggacctttcataacctttcctggcacatggttagctgcacatcaca
-ggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggtggtgttaatcta
-tctcggtgtagcttataaatgcatccgtaagaatattatgtttatttgtcggtacgttca
-tggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaagg
-taggtccatctatatacgttgcacagcggatacaaataagataagaatttactaacattt
-aaattttcttattgtcgagcatagattggaggaaaaacttatttacttggtatttaaacg
-gaagtttctaatgtttatgattggatgcacggacagtttactgcttactttcttaggttt
-cttgaacaacaggatgcactagtaacatgtctcgttcatgcttccattaagttcttctta
-aacttacacaaactacctaatttagagttgacgagatggttgaacgtgttgtgacaaacg
-tttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattct
-gctacgtccattgcaggccacattcacatcccacccctgaatatatggactgaatcacac
-acaccaaatttcatctaccttatcgtagcataactattaacaaacatatacagacttcgc
-ggtaaataaaatatattagtacacaaccgtatactggttgaactattgcccagctttaag
-acgcttttaactaggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacc
-tgaatagatatagacgttagattgtctgaaaacacgccgtagagacatttttgttagata
-tgtatttctttttgacgagccagcatcttagtatctgaagacgagctatatgtttgtaga
-aaatcgactgacattgtatacgaggcggcgtaagattaaccaaattccccagaattagta
-atggcgccttatcgatttactaacgatatataacttgtgatgttgtctgcaatgtatacc
-cgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccacc
-gcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgctatgtaatccat
-tctaatgggtaagaggattcctcttatagtaaaatatgcttgactttttaagaaccattg
-ggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttttctacaactacc
-cctattaggttacaagtaatctggctttcttgccacttggcgatgatagttagattcgta
-tttctacaacgcagttactgtatccatggcgcgagataattagatacgatttgaatttgg
-atgtagactcgttactactgttgtagaccagcacgtgagtatctagatgggtttgctacc
-ttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatattttactataagc
-agtattggccaccctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaa
-aattccattttaaaacccggaggaatctattactgacgaggaaggtgtttaacccgttga
-gacatctcctaacgtaaaaggttcatattctagttattccgagagtcactttcctatcca
-aacatgaactgatagcataatgacaggttgaatggaaagcatatcctgtttattctaaat
-ctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttacaactatgtgttc
-tgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatct
-gatttaatagcttaatgtctcatattttacagtagccagtgtagtatggaaggcggcgaa
-ccagcccctacattgggtttcctgacataagtattacatatcacttgtctgattacacag
-caaaatcgctaaccttactttgcgcatgtagctattggaactttgggctagtgtctatcc
-cattaagtttaacagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaa
-gttttggatttggatcaaaaactactcgatattcatgatctacgggcttcctttctccgg
-gtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgg
-gatagcgtagaaactaaacaacgaatagaccatccaatttgaattttattgggtccagca
-cttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatattaattctgctac
-attttcgaccacttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatg
-ccgtaattctaagggatgataataggttgggaaatttaagagcagtagtaacggtcgcgg
-gttcgaccttaaactatatatttaaatctagccaaacaagttaacaacaaccataaagtt
-atgaccttattatattggcaagcttaacgttttaattgctctagtaatagagtggtagag
-gtaagggaccatcacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaa
-atttcgagataaaacattcgtccttagcaacgaatatcgaatggcaattagccacattga
-gttaaatagttgaggatatttcttgcacagaatcagatctaatctaatgattcgttacta
-aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
-atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
-ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
-atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
-tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
-tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
-gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
-tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
-gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
-gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
-atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
-taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
-ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
-acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
-ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
-ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
-cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
-ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
-aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
-attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
-acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
-tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
-attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
-aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
-tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
-ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
-gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
-caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
-taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
-ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
-ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
-gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
-ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
-aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
-cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
-gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
-ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
-tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
-tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
-ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
-tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
-gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
-ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
-actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
-gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
-ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
-tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
-atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
-aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
-tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
-ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
-acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
-gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
-gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
-tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
-gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
-gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
-tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
-acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
-tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
-catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
-attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
-ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
-ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
-gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
-tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
-tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
-ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
-gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
-ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
-tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
-ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
-tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
-ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
-actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
-gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
-gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
-accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
-gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
-cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
-tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
-atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
-ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
-ggaagtgaaaagataaatattgcctacacatactgaattcaggcaatgcgttttattcga
-aaggtcatataactagaaaacatgatgaattcttatcggatccttttactagcatagtgt
-tggcgaacacctcgtaatgctcagcggcaaattggactgcgggtccttatcatacatttt
-ttttcaatataggcgattggtctaggttagtgattccccaacacttaaggtttgctgaca
-ttcataccctcagcaacttcctctcaaaaattagagtgagttggtggtcttataagaccg
-ttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctg
-tagacaataacccattgtagtgccgattttgtgcataatacaagaaggaggatataaaaa
-tgacttttcaataatattggctattagcaacaagaaggagaatcctcattaagttagcaa
-ccgcagggggtactgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaa
-ttatgattgtgagattcgctgaagattgtgtctctgattttcctagatagaataagctat
-agctacttaatcaactcttaactgtggagactatcctgatgatctgaataccccatttac
-aaaattccatatcaatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatca
-gcctttttatacaagacaaaacactgcttccattacgggtagcaatggttgctcgactac
-tggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgac
-ctgacataatggagcgacttatcggatgttgccgatctttagggtcatctattaagctta
-tacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacctagaaacgcaag
-aggaggcgaactccaatatctgtaagaacagaaaaatacaggagtccttttcatttttca
-agttaacaatataagtaggagcttagagaggcttgcatgaaaatcgttaggaattacaga
-ataggcagagagtggggcgtgtagactacattcttcaggccccacaatatgggttatagg
-ttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgtt
-ccttttgctgtagtccacgttcatccaactattcagataaacaagatcgcagaattaaag
-cttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctc
-aatcttgtctgcgagagggaggaaaatttagacaaacataattcattctttcgactggac
-acgctaaggtttggacaaactttgtatctatatctggaggcctgtattccagcccttctt
-ttaataagatttacggcttaaactatggatatttgccaggaaatgacactgctattgaca
-ggaacataattttgattcaaacctcattgttaattattttatatctcctgtttttatatc
-agaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaatgaatcataata
-gaccggcccctattaatattggttcaattctttcttacataacgcggaatttgattgcac
-gaacaccgggaacacataaccgtatagcgcccgttatgctagtgcctagcgactgggacc
-gtggagtctatatcgtctttctaccattattaatctaaggatataccactttaagtcctt
-tcaactaacataaggcgcattccatgcgctaaggaccttgaatttattatttcttacatg
-ataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaa
-gagccctttttctggcttgtggagactatcataacatgaagatgttttgacattcaatag
-tttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaattgccccatagc
-aggaatagttatatattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtg
-agggtaagcgacttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaat
-tacagttatacgacttaattcagtctccataaattgaaacgacacttcttaacgggagga
-ccagacacgttcattaagtgaggagtgcactttttgactttaaaaacatggtaatcaatt
-taaaccacttgatatgtatatgaacagatttgaagttatttctgttttaatacactggga
-gttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaaggg
-acaggggaaagggtaatcgaggggtagggaacgtagttggcacacccaatggacgaataa
-atgctgccatatccacggagggcgggattgcggttgattttaaggcgatggtaacctgaa
-tgtaatagatcatcaaatgcctcctccactggaaattactgcgtacatccgctgagaatt
-gcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaacttcatagtataat
-ttttgcacattacaagcgttaattaacaaacttactttgctgttagctgcctatatttgt
-ccgacaatataactggatatctctgcgagaactgtaaattaacggcacttggaacataat
-agttcctattggtaacgacgttgtaggcggcaattatccggtggaagaattgacaactgc
-agttgaactgcatgaaagtcaaatctctcgtaagtataactttagaagactccaaggtac
-ccagaacctcttcagcggacacgatcgctatcaatcaataaggattattcactgaaaccg
-ctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttt
-tggccgtgctaatcgacacacctgttattttcatgaccggataggacatctcgcggaaat
-tcgggtaacagctgggtagatataggacctcccctacgtattaatgataagcctgtcata
-actagcttggtttaccgaagagacaataaacattcgagcgctcgtgccaaactcggtgca
-ttacgtttgaataaatcggtaacatgtactattactctgcctaacggcacttacccgttt
-gggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccg
-attaccgaaaatctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaa
-caggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactctgggcatgtttt
-atgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggctttatccaatat
-gggtccttaagtgctaaacatcattcacaatttcaagacagattgttggtcttgtcgatt
-ccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgac
-taaactaccgtgtgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaag
-ccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagtaattccgtttta
-ttgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgtgccttataggct
-atttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtc
-tatcgccaactaaaagacgtctcgatggttctttatgcggacctgtcatatcattgactg
-gcacttgcttacatccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaaga
-tcatgaggcggggggggtaatatttcgccctctacatgataaatgaataagtaagaagat
-gatctttttgtggcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatg
-tagggttctggatctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaa
-taagtgatcaatggactaacattgaaatgttagtattgtcgaccattgagggctggtaaa
-tcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactc
-gttaatgcttactttagttggttgcgggaacaacaggaggctatactaactggtagcgtt
-cttgcttccattatgttattattataattaaaaataagacatatggtagagttgtagtca
-gggtggatcgggttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaa
-tttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacattcacagcacaccc
-ctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaatt
-ttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaattcactagtatc
-ctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatcaagatgtatgat
-ttttggtccgctgtgtggaatacctctattgatatacaagtgactttctcggtaataacg
-cacttcacaatgtgttgtttcttttctatgtattttgcaagagaaagaagcttagtatag
-gtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacat
-tatccaaattcaccacaattactaatccacccttttacttttactaaagatatattaatt
-ctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaaggataccaattg
-aagtcctcgaggcatgttacaacacacgacttccttccgtctattcagacactcaacgag
-actaacttttcctaggtaatcaatgatattgggtaactcgtggcatcttatagttattga
-tccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgc
-aggggatacgtttattctacgtacccgatttggttactactaagcggcctttcttcaaac
-ttgcagttgtgacttacattcctatttcttcaaagcagggaagggttacagggagagact
-tattgagatacgattggaatttccatgtacaatcgttaatacgcttgtagaccagcaact
-cagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattact
-aaaaccctagttgttaatataagaacgattcgaaacaataggattgcccaagggggtgcg
-aacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgtttctagtacgca
-agaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggcttattctacttt
-ttccgacactcaatggacgagacaaacatgaacggatagctttaggtctcgttgaatgca
-aagaatagaatcgttattattaatcggtttccattatctatatgcggtatagatctccga
-gaggaccctgtaaactagctctgcggtttaactggtgctaatagaccgccactatgttat
-tgcttctagctcctagcgtcttatcatgttatacattaatgtcgcatattggacagtagc
-caggcttggatggatcgccgacaaaaagaaaagactttccctgtaaggacttaactatta
-catataacttggatcattaatctgcaaattagagtaacggtctttcaccagcttcatatt
-ccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattggcagtctcacttc
-acagtgcgtatctatacgacaaaagtggtcgatttgcataaatatcttatcgatattcag
-gttattaccgattccttgctaacgctagaagtcacaccagagtaataataattccagaca
-cctgtgaaataatcggtcactacggatagactagtaacgataatacgtatagtccataaa
-agttgaattttaggggctaaagatattagcaatactggtctagcctaatcgtcgatagca
-aagggctgtgaggatttctcctacattttcgaccaattgtatcgataggaatagttacag
-tcacgcttgtagatgtaagagatgacgttattcttagggttcttaagtcggggggtaatt
-taagaccactagtaaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaa
-aaagtttacaacatcctttaagttagcaactgattttagtggcaaccttaacggttgaat
-tgatctactaatacaggcctacaccgaagggtacagataatgattcttactaccctaaca
-tgatagagtcctgtcctatctcataggtcgacattttaaattcgtaatgagcaacgaaga
-tcgtttcccaatttgcaacattcacttatagacttcaggttatttcgtgctaacattaag
-atagaatataatcagtcgttaagaaactattatccagctttcgtcaaccataaagattaa
-aaactgaaacttggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgct
-ttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaa
-tattaatatactattaagctacacagcaaaggctgcaataatgttagtaagtagaacata
-aaggtattctccacaagtaataaatagtgtgagctaattgactaacttaactctcgcgac
-aagtgatgtggataagatgactcatatcgtctttttctgtagtgccgacatcccacctgg
-atcgaacaattccttctagttatcgactttgattacctatcctattaaacagatagggtt
-gtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagttagaacgcgtag
-atagaggccttttgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctt
-tcgtgtccgaatttgtttaacatccattagattagatgtttgtgttttgggtctgatgtc
-ctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtct
-ccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatttagaacacacct
-tatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaag
-gaacttaaagtcggatcactcttgtcagtgtagataagaatttctttcatacttcactgg
-aatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttg
-ctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatag
-catcaggccttcttatccagcgtgaagtctaattatttcacaagctttcctaagtatgta
-aatccctcacttaatgatgcttgcgccaatgaggatagaggacattgcatgtacgtagga
-ctattctccaaggggtcttctattttgttagcgaaaattgttacagcctaatgttagagc
-ggcgtacgactttataccagatactttcattagatatgcaaatatccaattaaatcatag
-tagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcg
-ttctcatatatatagatcaacaatgaataatctcatgatctataaccgatgtatatttat
-attccggttgactgctccggtgcaattcactacggacactaatgactaatatggcgcctt
-tcatcagaaacgctaaatatgattaatgaattaagggagtattatctaattattagagag
-tagcagttagtctgatattttcggtgtatgtgttagccgttataatgctgtctttttatc
-agtgagaacagggagtgtgtagtgttgtatgcttcactttatgactctggttatatccct
-cggagaacaagaataagagtacgagaagttcggtcattgaggatgaaatagaaccgctag
-acgaatggactcacgtttataaaactatgtatcacagtactacagctaactctgaagtcc
-gagaagcttttgtaggacaaaacgttataagtacctttcgcagaatacggccgtgcatac
-ctgttataaggcgtagtagggacaccatgctatccctcatatagagctacactaatacca
-ttacatggtgactatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatcc
-gtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactat
-tcgaagcttctcaatccttttccattatggcatagcaagtgacgactcgtcagccatggg
-aataatagcactaatccgattacttatgaattagaacccacatgaatgtgattctgcgaa
-ttgtctaagaatctaatgattttccggtgaatatggttgttgttatttattgaacttata
-ttattaacatcacccttcgttagtgatagtcagctatttccaagaggttccccgagcatt
-tttaccattctctagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcg
-ttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaac
-aggtcacccgtttttcgttacatatgctggtaaaatattcatagtaataactacaatact
-tgatttgttacgtaatgctcgtacataacacaatcgtattccacggaacagtaaagctct
-attattctgatcgagcctaagagaggatcacactacgctattaaagtcacgttcacgaaa
-tctcaaacctcaactgctggtgaccagttatagacagtgtaattccatattacatgtcag
-gcttaagctaacccgagcctttatataagctataatcaagaattagattggagtgcattt
-tagacttatctatcgaaatagtgatagtaagagtttatatgacctgatctagactgatgt
-tctcttccacaacagccttaaggcgtggagcctttcttatactattaggtcgcgtcgaga
-gccctattcgtaatgttaacgacactagactaatatacaatgagctaagaataacacaag
-tcacaagataatttacaaatcatatatctacagtccacaaccatcactagcgattgcaaa
-gcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcc
-tctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtga
-gtcatgtgcaactatacagtttagtttggtcaagactatgcaactattaacagcatgtgc
-gcattgaatatttggtgtcgattgataaatgccccaacgttccatcacgtctataagccg
-tgttactaatgtgtattagtgcatacctattcagaccatagttcaactgttggactgaag
-gcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaa
-atgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagccaatgggctccc
-attgagctagtatggtgctttacctttgtaagtggtggctttccttggtgtgctgacttt
-aacacggcagagtgattatccgaagaatggataataagacgctggcaatattggctaata
-aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca
-tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg
-tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg
-gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc
-atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc
-cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt
-caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat
-tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt
-agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt
-ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt
-aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta
-ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat
-cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac
-gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa
-atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc
-ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta
-gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt
-aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt
-aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc
-atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac
-tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat
-cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc
-taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt
-taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt
-ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc
-acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct
-cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg
-tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt
-attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat
-cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga
-atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc
-accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag
-tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc
-acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag
-ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa
-gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc
-cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg
-aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca
-tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta
-atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac
-ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc
-gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat
-ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt
-gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata
-gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc
-atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga
-agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct
-aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac
-ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc
-tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa
-cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc
-gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga
-atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta
-ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca
-gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt
-acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga
-tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg
-ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc
-ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt
-acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat
-tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag
-tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga
-tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca
-aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg
-aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg
-actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt
-tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa
-gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag
-tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc
-attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt
-gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc
-atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact
-ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta
-aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt
-gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta
-taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga
-tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc
-gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca
-cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga
-ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac
-agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat
-aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt
-atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac
-actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa
-tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa
-ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta
-cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag
-ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc
-ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag
-cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag
-tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc
-agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat
-gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc
-gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca
-ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct
-acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga
-tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat
-tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg
-cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac
-cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata
-agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca
-aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg
-gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta
-atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg
-ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag
-acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta
-ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg
-gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc
-atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg
-actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg
-cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt
-cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa
-ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca
-tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta
-atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc
-acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct
-gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta
-ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc
-aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga
-taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa
-cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca
-tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta
-gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg
-gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag
-ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat
-tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta
-aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt
-aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc
-cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca
-acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta
-aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct
-cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa
-tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt
-cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat
-tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt
-taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg
-ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt
-taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc
-accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa
-ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg
-atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg
-taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga
-aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt
-attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt
-atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa
-attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa
-cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg
-agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt
-tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca
-aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa
-actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag
-tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta
-acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg
-tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat
-agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag
-ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat
-tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt
-attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta
-tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt
-ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt
-catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga
-caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc
-cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac
-accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca
-atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct
-tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct
-cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat
-gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca
-gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga
-agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca
-ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc
-ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa
-aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc
-ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga
-tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt
-taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg
-caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt
-tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc
-taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac
-gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca
-gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat
-aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt
-atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc
-gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat
-aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa
-aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga
-aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat
-ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc
-gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa
-acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac
-attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc
-gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag
-gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct
-gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata
-tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat
-ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata
-aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc
-tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat
-tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa
-ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt
-agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
-cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
-tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
-tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
-gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
-tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
-tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
-atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
-cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
-ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
-ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
-atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
-gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
-tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
-gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
-atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
-tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
-ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
-tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
-aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
-gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
-ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
-agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
-agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
-acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
-cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
-cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
-cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
-aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
-tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
-atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
-cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
-tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
-catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
-tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
-caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
-tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
-aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
-aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
-ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
-gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
-ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
-cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
-gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
-ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
-cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
-taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
-gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
-taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
-ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
-aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
-gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
-acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
-ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
-tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
-tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
-tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
-ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
-aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
-tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
-gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
-gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
-cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
-actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
-tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
-ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
-ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
-agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
-gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
-tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
-atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
-cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
-tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
-gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
-gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
-aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
-gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
-cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
-taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
-tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
-ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
-aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
-gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
-aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
-tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
-tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
-aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
-ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
-ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
-caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
-gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
-cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
-ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
-tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
-atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
-ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
-acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
-taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
-ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
-aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
-cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
-tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
-gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
-aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
-cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
-cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
-gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
-cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
-gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
-agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
-aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
-aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
-cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
-agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
-cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
-agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
-gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
-aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
-agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
-cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
-agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
-ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
-tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
-gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
-gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
-ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
-gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
-atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
-tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
-ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
-tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
-cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
-ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
-aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
-gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
-ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
-atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
-aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
-gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
-atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
-aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
-tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
-ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
-gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
-cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
-ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
-ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
-ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
-cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
-tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
-tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
-cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
-gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
-ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
-ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
-tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
-agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
-ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
-cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
-agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
-tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
-gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
-ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
-ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
-agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
-attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
-ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
-agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
-aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
-gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
-gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
-ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
-gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
-ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
-taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
-aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
-tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
-ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
-agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
-ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
-agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
-gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
-tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
-gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
-cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
-ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
-cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
-gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
-gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
-tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
-cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
-aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
-ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
-gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
-aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
-gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
-aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
-gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
-agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
-caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
-gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
-aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
-tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
-tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
-ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
-ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
-gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
-ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
-aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
-tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
-acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
-atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
-gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
-tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
-cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
-gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
-acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
-acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
-attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
-tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
-cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
-aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
-ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
-tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
-gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
-gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
-acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
-gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
-gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
-ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
-taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
-agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
-gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
-ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
-accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
-tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
-taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
-catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
-tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
-ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
-aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
-atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
-tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
-ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
-tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
-aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
-agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
-acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
-aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
-ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
-gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
-taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
-taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
-tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
-gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
-ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
-atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
-tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
-cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
-aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
-taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
-caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
-ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
-tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
-tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
-gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
-gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
-gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
-ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
-tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
-taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
-gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
-ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
-gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
-tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
-ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
-tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
-cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
-ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
-caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
-cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
-gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
-cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
-taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
-tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
-taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
-tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
-tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
-tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
-ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
-aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
-atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
-actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
-gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
-ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
-gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
-tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
-aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
-atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
-catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
-taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
-ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
-cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
-agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
-atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
-tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
-gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
-attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
-tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
-tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
-gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
-attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
-aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
-ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
-taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
-atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
-aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
-agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
-gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
-tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
-taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
-cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
-aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
-ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
-gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
-tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
-ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
-cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
-aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
-cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
-ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
-tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
-ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
-atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
-tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
-ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
-acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
-ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
-aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
-gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
-ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
-tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
-gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
-taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
-aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
-tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
-gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
-ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
-tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
-tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
-tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
-ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
-gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
-ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
-gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
-tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
-caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
-tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
-gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
-tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
-cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
-gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
-tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
-caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
-agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
-atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
-ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
-atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
-tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
-tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
-ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
-agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
-acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
-cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
-taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
-acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
-ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
-ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
-cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
-ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
-cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
-attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
-gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
-ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
-aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
-acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
-tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
-tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
-agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
-ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
-tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
-ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
-aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
-cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
-tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
-tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
-accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
-agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
-aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
-gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
-aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
-ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
-cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
-ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
-tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
-tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
-aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
-gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
-cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
-aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
-gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
-gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
-tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
-tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
-accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
-atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
-tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
-atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
-gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
-ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
-tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
-gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
-tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
-gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
-ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
-agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
-aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
-tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
-tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
-tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
-aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
-aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
-aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
-ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
-gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
-tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
-atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
-gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
-tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
-gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
-atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
-gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
-ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
-tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
-gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
-aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
-acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
-acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
-accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
-atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
-aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
-gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
-aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
-caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
-cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
-ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
-aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
-tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
-agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
-caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
-gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
-gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
-acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
-ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
-gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
-cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
-ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
-actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
-tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
-catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
-tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
-tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
-tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
-cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
-cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
-tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
-aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
-cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
-caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
-ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
-tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
-attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
-tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
-gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
-cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
-aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
-ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
-aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
-gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
-gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
-cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
-gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
-tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
-aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
-atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
-ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
-aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
-aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
-cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
-gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
-ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
-tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
-gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
-atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
-ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
-acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
-cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
-atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
-tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
-atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
-ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
-agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
-agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
-atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
-tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
-tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
-taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
-aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
-tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
-acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
-tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
-acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
-ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
-tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
-aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
-taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
-cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
-ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
-attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
-caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
-aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
-atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
-tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
-cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
-ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
-gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
-actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
-cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
-ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
-aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
-ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
-gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
-ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
-cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
-tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
-ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
-cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
-ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
-attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
-agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
-ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
-aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
-aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
-atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
-cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
-gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
-aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
-atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
-ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
-cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
-caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
-tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
-catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
-atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
-tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
-gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
-agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
-actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
-ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
-tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
-ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
-gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
-tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
-taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
-agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
-acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
-cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
-attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
-agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
-gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
-taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
-ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
-tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
-tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
-aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
-tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
-atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
-ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
-aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
-actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
-acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
-aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
-caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
-aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
-cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
-atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
-ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
-agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
-atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
-ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
-attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
-ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
-atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
-taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
-tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
-aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
-ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
-gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
-gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
-ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
-cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
-ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
-aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
-taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
-gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
-gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
-tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
-attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
-caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
-acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
-cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
-taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
-taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
-tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
-ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
-taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
-tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
-gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
-gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
-cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
-aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
-gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
-agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
-agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
-acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
-gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
-tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
-atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
-ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
-gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
-gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
-gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
-atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
-ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
-acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
-tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
-tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
-cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
-aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
-gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
-ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
-taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
-gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
-tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
-tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
-caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
-ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
-gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
-ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
-aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
-ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
-tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
-gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
-aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
-ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
-cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
-attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
-ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
-gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
-ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
-atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
-atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
-atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
-cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
-cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
-gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
-accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
-tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
-aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
-cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
-tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
-cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
-acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
-cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
-ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
-agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
-cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
-acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
-gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
-gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
-cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
-gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
-ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
-ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
-agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
-gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
-tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
-tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
-ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
-ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
-ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
-catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
-ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
-tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
-aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
-gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
-agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
-atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
-taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
-tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
-cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
-cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
-tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
-catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
-catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
-ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
-tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
-ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
-ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
-ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
-tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
-ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
-tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
-aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
-gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
-ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
-agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
-taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
-ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
-agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
-gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
-agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
-ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
-ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
-acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
-aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
-ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
-ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
-tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
-gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
-ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
-tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
-aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
-ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
-atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
-acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
-gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
-acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
-ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
-ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
-gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
-agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
-ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
-ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
-gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
-gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
-gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
-cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
-aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
-cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
-gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
-ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
-gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
-atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
-gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
-acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
-aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
-cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
-atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
-tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
-tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
-ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
-tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
-gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
-gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
-aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
-tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
-tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
-attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
-catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
-taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
-ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
-gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
-aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
-aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
-agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
-tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
-aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
-agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
-ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
-taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
-ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
-cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
-tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
-cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
-gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
-cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
-tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
-acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
-ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
-gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
-taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
-tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
-tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
-cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
-tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
-ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
-aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
-agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
-gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
-catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
-tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
-aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
-acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
-tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
-aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
-agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
-gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
-gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
-taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
-gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
-gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
-tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
-agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
-tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
-caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
-aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
-gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
-catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
-ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
-tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
-gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
-cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
-gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
-gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
-ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
-gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
-ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
-cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
-agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
-caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
-gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
-agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
-gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
-ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
-ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
-attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
-cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
-gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
-acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
-ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
-tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
-tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
-taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
-tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
-gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
-agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
-ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
-attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
-aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
-ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
-ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
-ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
-tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
-ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
-atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
-aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
-tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
-cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
-aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
-acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
-agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
-tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
-gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
-attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
-gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
-gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
-gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
-tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
-atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
-gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
-ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
-atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
-ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
-tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
-cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
-tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
-gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
-agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
-aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
-ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
-gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
-ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
-cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
-atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
-atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
-cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
-catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
-ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
-tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
-tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
-tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
-gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
-aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
-caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
-aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
-gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
-agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
-tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
-cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
-taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
-atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
-tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
-gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
-ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
-gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
-tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
-tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
-tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
-gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
-cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
-gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
-tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
-catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
-tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
-caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
-tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
-cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
-gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
-tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
-cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
-acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
-agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
-tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
-atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
-ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
-tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
-caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
-acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
-actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
-atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
-tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
-aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
-ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
-tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
-acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
-cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
-cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
-tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
-gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
-cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
-atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
-aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
-tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
-tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
-acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
-tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
-ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
-tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
-aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
-agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
-ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
-tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
-aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
-acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
-aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
-gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
-ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
-tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
-cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
-agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
-tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
-gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
-accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
-cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
-cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
-accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
-cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
-gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
-tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
-tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
-aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
-tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
-tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
-atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
-ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
-agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
-gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
-caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
-tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
-gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
-tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
-agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
-taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
-gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
-tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
-ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
-ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
-ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
-aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
-tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
-cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
-taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
-tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
-ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
-tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
-ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
-ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
-cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
-gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
-ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
-ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
-atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
-aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
-aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
-acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
-tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
-ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
-gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
-aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
-cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
-ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
-tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
-atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
-taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
-tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
-ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
-ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
-gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
-aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
-gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
-gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
-acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
-atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
-taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
-ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
-ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
-tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
-tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
-tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
-aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
-cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
-tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
-aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
-ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
-attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
-agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
-ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
-aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
-taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
-gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
-caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
-atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
-ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
-aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
-gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
-gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
-ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
-gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
-gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
-ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
-attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
-atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
-aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
-ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
-aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
-gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
-aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
-ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
-ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
-agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
-tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
-tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
-aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
-agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
-ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
-tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
-tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
-acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
-accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
-agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
-taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
-gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
-ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
-aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
-gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
-aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
-taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
-aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
-ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
-tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
-tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
-gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
-agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
-cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
-attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
-ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
-aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
-agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
-gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
-cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
-ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
-gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
-tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
-acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
-tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
-attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
-gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
-gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
-gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
-aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
-tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
-gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
-caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
-ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
-atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
-accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
-ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
-attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
-atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
-attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
-cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
-ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
-taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
-agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
-ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
-cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
-catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
-tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
-aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
-atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
-gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
-gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
-acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
-tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
-agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
-tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
-ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
-ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
-tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
-tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
-agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
-aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
-caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
-aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
-acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
-ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
-tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
-cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
-tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
-gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
-aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
-tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
-attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
-cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
-aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
-tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
-aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
-aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
-atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
-atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
-aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
-atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
-ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
-actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
-agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
-ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
-atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
-tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
-atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
-tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
-ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
-atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
-tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
-catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
-caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
-actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
-ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
-agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
-aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
-ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
-cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
-gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
-gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
-attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
-cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
-taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
-acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
-gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
-ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
-tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
-cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
-ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
-taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
-ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
-gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
-acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
-atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
-gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
-acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
-agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
-aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
-ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
-gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
-agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
-aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
-gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
-gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
-ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
-ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
-cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
-aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
-ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
-gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
-atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
-atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
-caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
-tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
-taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
-gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
-ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
-tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
-aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
-ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
-gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
-caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
-attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
-gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
-tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
-gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
-aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
-ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
-cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
-ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
-aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
-gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
-cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
-atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
-atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
-agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
-cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
-cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
-ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
-acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
-tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
-attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
-caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
-tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
-aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
-tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
-ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
-tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
-acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
-agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
-tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
-ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
-gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
-ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
-gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
-cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
-cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
-tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
-ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
-tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
-tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
-aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
-gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
-agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
-cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
-tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
-tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
-ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
-gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
-acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
-ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
-gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
-gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
-ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
-agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
-tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
-aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
-cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
-attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
-gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
-ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
-aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
-ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
-tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
-ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
-gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
-acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
-gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
-ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
-tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
-tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
-cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
-acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
-ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
-tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
-tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
-tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
-tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
-attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
-cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
-cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
-gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
-ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
-cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
-gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
-tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
-gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
-agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
-tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
-caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
-acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
-cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
-gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
-caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
-acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
-cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
-aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
-gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
-cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
-gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
-atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
-ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
-actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
-ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
-attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
-ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
-attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
-ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
-aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
-atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
-caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
-attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
-tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
-tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
-gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
-ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
-cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
-caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
-attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
-tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
-tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
-tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
-ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
-gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
-aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
-ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
-tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
-taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
-accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
-gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
-atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
-acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
-tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
-tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
-gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
-cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
-tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
-cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
-cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
-cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
-ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
-tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
-cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
-gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
-tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
-tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
-tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
-atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
-gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
-cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
-atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
-tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
-gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
-ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
-gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
-attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
-aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
-taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
-atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
-agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
-gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
-gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
-ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
-gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
-cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
-tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
-agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
-tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
-cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
-attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
-gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
-atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
-ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
-taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
-gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
-ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
-ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
-ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
-ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
-ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
-gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
-ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
-acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
-cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
-gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
-actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
-gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
-actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
-gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
-atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
-ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
-ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
-actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
-ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
-ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
-gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
-tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
-gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
-gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
-agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
-ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
-tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
-aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
-gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
-tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
-cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
-gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
-agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
-agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
-atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
-ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
-cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
-ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
-taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
-tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
-gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
-ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
-agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
-gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
-gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
-gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
-tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
-atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
-gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
-gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
-tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
-ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
-taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
-cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
-tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
-gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
-accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
-atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
-ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
-cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
-ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
-actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
-atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
-agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
-accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
-catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
-gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
-tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
-tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
-ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
-ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
-taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
-aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
-tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
-cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
-acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
-tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
-ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
-gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
-tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
-tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
-ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
-gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
-gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
-tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
-taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
-tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
-gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
-atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
-ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
-ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
-atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
-gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
-ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
-ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
-acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
-cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
-gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
-cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
-tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
-tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
-tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
-tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
-tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
-taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
-cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
-tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
-aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
-agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
-gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
-tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
-cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
-tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
-aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
-aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
-cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
-tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
-caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
-ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
-ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
-aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
-tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
-gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
-aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
-gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
-ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
-gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
-atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
-acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
-gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
-tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
-aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
-aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
-atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
-gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
-ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
-tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
-ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
-agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
-tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
-gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
-tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
-catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
-aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
-aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
-ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
-cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
-tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
-tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
-aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
-tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
-tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
-agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
-cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
-actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
-gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
-cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
-ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
-gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
-tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
-actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
-tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
-gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
-ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
-gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
-tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
-ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
-ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
-ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
-cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
-gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
-tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
-ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
-tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
-cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
-tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
-ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
-ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
-ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
-ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
-attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
-atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
-tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
-aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
-tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
-ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
-cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
-atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
-atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
-cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
-tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
-agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
-gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
-tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
-cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
-cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
-cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
-atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
-ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
-catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
-actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
-agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
-tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
-ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
-atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
-tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
-tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
-ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
-agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
-ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
-tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
-ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
-agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
-attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
-acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
-ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
-acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
-tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
-cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
-catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
-tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
-tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
-ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
-ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
-ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
-ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
-ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
-gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
-tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
-tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
-agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
-ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
-tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
-aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
-gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
-aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
-tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
-cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
-tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
-ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
-ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
-atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
-actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
-tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
-tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
-tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
-aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
-taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
-acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
-taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
-gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
-tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
-ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
-gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
-taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
-gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
-aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
-gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
-tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
-taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
-gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
-acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
-agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
-aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
-attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
-attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
-acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
-gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
-acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
-cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
-ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
-taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
-aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
-tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
-atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
-ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
-gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
-ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
-agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
-taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
-ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
-cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
-catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
-agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
-taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
-cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
-ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
-ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
-tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
-aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
-ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
-ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
-acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
-cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
-ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
-atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
-taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
-atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
-tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
-gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
-cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
-aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
-tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
-acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
-gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
-gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
-ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
-gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
-ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
-acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
-aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
-catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
-acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
-tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
-cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
-gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
-cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
-tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
-gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
-atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
-tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
-aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
-cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
-attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
-tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
-aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
-ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
-attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
-ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
-aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
-tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
-ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
-tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
-agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
-ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
-agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
-tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
-agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
-gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
-tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
-atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
-tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
-ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
-caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
-aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
-catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
-actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
-ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
-ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
-ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
-gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
-gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
-agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
-ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
-tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
-acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
-gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
-gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
-tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
-cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
-tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
-tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
-cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
-cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
-aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
-ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
-gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
-acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
-acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
-aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
-cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
-gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
-actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
-atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
-gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
-ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
-ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
-tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
-cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
-aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
-tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
-gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
-attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
-ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
-ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
-tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
-gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
-gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
-tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
-tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
-attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
-aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
-cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
-aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
-atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
-cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
-taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
-caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
-ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
-tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
-agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
-tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
-aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
-catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
-actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
-agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
-agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
-acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
-cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
-acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
-cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
-aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
-tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
-attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
-aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
-tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
-aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
-tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
-aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
-tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
-tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
-acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
-tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
-ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
-ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
-ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
-cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
-aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
-acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
-tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
-ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
-gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
-ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
-aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
-ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
-agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
-atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
-tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
-tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
-ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
-cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
-tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
-tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
-gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
-gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
-ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
-acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
-gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
-atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
-atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
-aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
-gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
-tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
-attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
-cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
-gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
-gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
-gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
-aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
-caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
-agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
-tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
-ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
-cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
-aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
-cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
-tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
-tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
-gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
-taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
-ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
-ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
-cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
-gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
-cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
-actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
-gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
-ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
-gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
-actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
-tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
-cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
-aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
-aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
-ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
-cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
-aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
-aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
-aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
-ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
-ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
-catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
-attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
-tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
-acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
-cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
-tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
-cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
-agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
-cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
-tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
-atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
-atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
-tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
-gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
-gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
-cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
-gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
-cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
-caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
-atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
-gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
-ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
-tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
-cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
-gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
-aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
-cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
-ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
-tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
-taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
-gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
-attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
-tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
-tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
-tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
-caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
-ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
-ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
-cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
-ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
-cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
-gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
-taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
-agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
-catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
-ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
-tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
-ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
-atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
-ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
-cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
-ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
-tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
-ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
-atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
-gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
-atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
-tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
-tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
-ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
-acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
-ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
-ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
-ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
-gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
-ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
-tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
-acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
-tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
-attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
-atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
-ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
-atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
-cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
-tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
-ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
-ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
-ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
-cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
-gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
-gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
-ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
-cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
-aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
-ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
-gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
-aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
-caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
-aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
-gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
-agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
-acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
-ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
-aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
-tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
-ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
-gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
-ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
-gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
-ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
-acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
-tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
-tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
-ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
-cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
-tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
-aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
-gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
-tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
-acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
-atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
-ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
-acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
-attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
-tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
-tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
-gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
-ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
-tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
-ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
-caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
-ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
-taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
-tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
-cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
-ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
-tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
-tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
-taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
-aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
-taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
-ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
-aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
-atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
-gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
-ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
-tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
-acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
-agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
-tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
-aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
-atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
-gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
-gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
-tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
-ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
-gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
-tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
-atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
-ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
-cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
-aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
-gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
-aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
-gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
-tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
-gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
-ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
-gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
-catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
-taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
-gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
-tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
-cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
-attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
-ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
-gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
-atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
-gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
-atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
-gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
-aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
-ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
-gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
-atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
-tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
-tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
-tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
-tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
-ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
-gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
-atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
-taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
-atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
-acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
-gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
-ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
-cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
-ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
-aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
-attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
-acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
-taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
-cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
-aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
-tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
-ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
-tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
-gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
-aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
-ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
-ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
-gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
-ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
-aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
-gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
-tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
-atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
-tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
-tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
-ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
-tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
-gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
-ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
-acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
-taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
-gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
-tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
-atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
-aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
-aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
-ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
-cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
-tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
-ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
-tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
-taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
-gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
-actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
-ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
-tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
-cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
-atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
-ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
-ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
-gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
-tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
-tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
-gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
-gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
-ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
-tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
-tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
-tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
-gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
-cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
-gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
-tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
-cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
-taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
-cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
-tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
-ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
-ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
-ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
-cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
-aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
-attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
-ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
-tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
-tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
-tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
-cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
-atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
-agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
-aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
-tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
-tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
-gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
-taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
-agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
-agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
-ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
-ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
-cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
-cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
-aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
-acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
-ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
-tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
-agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
-taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
-taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
-ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
-acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
-atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
-gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
-tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
-aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
-agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
-aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
-gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
-taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
-ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
-ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
-atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
-tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
-gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
-atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
-ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
-cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
-agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
-ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
-gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
-tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
-tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
-acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
-ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
-tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
-attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
-cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
-atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
-gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
-ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
-taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
-gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
-ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
-atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
-tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
-gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
-tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
-tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
-tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
-tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
-actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
-ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
-cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
-tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
-tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
-ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
-ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
-gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
-ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
-cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
-gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
-tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
-gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
-aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
-actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
-acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
-aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
-ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
-tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
-gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
-aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
-cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
-cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
-ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
-aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
-gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
-tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
-cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
-catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
-gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
-acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
-gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
-gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
-agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
-aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
-tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
-taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
-caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
-tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
-tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
-tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
-atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
-cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
-ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
-tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
-cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
-aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
-atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
-gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
-atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
-tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
-gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
-ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
-aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
-taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
-aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
-gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
-catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
-cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
-gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
-ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
-taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
-atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
-atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
-acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
-tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
-agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
-ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
-accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
-tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
-gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
-ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
-gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
-tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
-acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
-atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
-ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
-tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
-tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
-aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
-agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
-attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
-tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
-gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
-tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
-actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
-gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
-acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
-gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
-actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
-gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
-tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
-tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
-gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
-atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
-attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
-aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
-aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
-accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
-atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
-ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
-cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
-cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
-gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
-tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
-agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
-ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
-aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
-gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
-ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
-gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
-atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
-tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
-gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
-cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
-cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
-atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
-tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
-cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
-aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
-aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
-ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
-ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
-gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
-tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
-attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
-cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
-ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
-ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
-tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
-acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
-atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
-gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
-gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
-agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
-tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
-attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
-ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
-gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
-cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
-tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
-tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
-atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
-agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
-cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
-atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
-agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
-cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
-tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
-ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
-ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
-gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
-acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
-tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
-atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
-ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
-acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
-tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
-actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
-actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
-aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
-aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
-actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
-tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
-tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
-tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
-atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
-ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
-attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
-ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
-aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
-tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
-taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
-aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
-ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
-caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
-ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
-agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
-cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
-atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
-actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
-taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
-cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
-gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
-ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
-atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
-cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
-tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
-atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
-gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
-gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
-tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
-ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
-tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
-tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
-gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
-gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
-agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
-aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
-gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
-atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
-ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
-accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
-ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
-gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
-atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
-actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
-gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
-gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
-ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
-tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
-ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
-acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
-taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
-ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
-aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
-aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
-ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
-tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
-tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
-gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
-tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
-tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
-aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
-aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
-cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
-ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
-aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
-gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
-tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
-ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
-aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
-taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
-ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
-taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
-acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
-gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
-ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
-aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
-aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
-attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
-ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
-cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
-ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
-agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
-tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
-aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
-cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
-tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
-actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
-tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
-cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
-ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
-agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
-attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
-tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
-gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
-gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
-caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
-gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
-ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
-cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
-tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
-gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
-ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
-taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
-agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
-gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
-atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
-caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
-ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
-ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
-taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
-caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
-aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
-taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
-gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
-ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
-catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
-attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
-ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
-aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
-acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
-aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
-ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
-tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
-acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
-ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
-ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
-gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
-gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
-agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
-ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
-aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
-tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
-tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
-ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
-agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
-gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
-tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
-tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
-ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
-tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
-aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
-ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
-cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
-gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
-ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
-ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
-gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
-tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
-gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
-atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
-tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
-ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
-agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
-cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
-gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
-ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
-agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
-cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
-acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
-gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
-catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
-gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
-aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
-aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
-atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
-ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
-aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
-catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
-aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
-cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
-acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
-aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
-cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
-aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
-gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
-ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
-ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
-gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
-ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
-cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
-aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
-tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
-taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
-ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
-caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
-gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
-accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
-ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
-tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
-taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
-agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
-ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
-aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
-aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
-ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
-tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
-ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
-ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
-tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
-ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
-cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
-cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
-taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
-tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
-ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
-gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
-tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
-tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
-ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
-aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
-gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
-cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
-aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
-tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
-gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
-aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
-gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
-aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
-acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
-tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
-aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
-ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
-cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
-gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
-tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
-ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
-cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
-ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
-atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
-tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
-accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
-aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
-gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
-aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
-cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
-tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
-gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
-cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
-catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
-ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
-gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
-gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
-gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
-cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
-aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
-cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
-gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
-agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
-ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
-agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
-gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
-aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
-attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
-cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
-agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
-ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
-tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
-gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
-taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
-ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
-gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
-atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
-tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
-ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
-actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
-ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
-ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
-cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
-gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
-atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
-atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
-aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
-taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
-atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
-aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
-tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
-ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
-gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
-gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
-tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
-gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
-gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
-gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
-tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
-aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
-cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
-gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
-ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
-ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
-tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
-cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
-tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
-gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
-agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
-aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
-gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
-cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
-tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
-ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
-atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
-ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
-agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
-aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
-gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
-gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
-ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
-tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
-gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
-tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
-acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
-taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
-ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
-agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
-ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
-cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
-gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
-tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
-tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
-cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
-ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
-ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
-tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
-tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
-tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
-gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
-aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
-gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
-tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
-aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
-gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
-cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
-tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
-agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
-catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
-gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
-caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
-tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
-tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
-ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
-ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
-tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
-tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
-ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
-tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
-acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
-attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
-gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
-tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
-cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
-ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
-acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
-acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
-cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
-tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
-cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
-cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
-atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
-aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
-tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
-gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
-acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
-gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
-gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
-ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
-tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
-agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
-gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
-tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
-accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
-acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
-aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
-cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
-tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
-ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
-aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
-atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
-tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
-gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
-tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
-caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
-aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
-acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
-catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
-ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
-tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
-taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
-aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
-tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
-tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
-atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
-ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
-ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
-gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
-cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
-tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
-catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
-tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
-agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
-tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
-gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
-tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
-gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
-ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
-tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
-tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
-gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
-ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
-gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
-tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
-ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
-tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
-cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
-ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
-caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
-gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
-ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
-cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
-aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
-aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
-taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
-accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
-tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
-tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
-ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
-aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
-atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
-cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
-ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
-atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
-gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
-tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
-caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
-ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
-catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
-aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
-gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
-cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
-agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
-atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
-tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
-tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
-attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
-tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
-tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
-taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
-attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
-cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
-tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
-tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
-atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
-aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
-agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
-gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
-agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
-taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
-cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
-cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
-ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
-gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
-aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
-ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
-cagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaac
-aagtggtctaaaaagactgccctggaaggagtaagaagtatacagctgatccggtgtatc
-cttcagtcatctgccctatactaattacacgacgcaaggaaaaataggtttattttctag
-gcaaacccttcataggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgt
-taccgacggataataacgatctccaatgaaccaaatgtagaatgtctattgattaccctt
-ttactattcgacttagagataggagatagaacctcagtgtacttttttagccgaatggga
-atctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatat
-tatatcgttgttcgtggaatcgataacagatttgttgacccatagtaaatgtatactagt
-ttatgttgtaagtgtagattgttttccgattgccgtccaaactttatgtcgtaattgtag
-accagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaattttt
-ccagtcactgtaagtgtaggtttagataaagccgtatgagttatatcataagggcctcgg
-aaagcagcttcgaaccaaagttcccttataatagtagtttaactataaaagtatatactg
-gtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacgtcattagagcgg
-ctccaatttaaggttaacggcttccatgtgtagttgtatacaaggataacttaaagtatc
-tgttcagcgagctagttaagttatcctcgatagaacacaactcagaggtcccaagatcgg
-gtttgcaacttgctaatttattctcaaggcaaattgggaattatcgatacctgtatacca
-taaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttagttagtgctgatt
-aacggaacattaatgtttatcgttttgagatttagccaattctctgattctaactcaaga
-tgccttatctgacgtgctatgcagcccctaagtattttacattgtaataggacacgctcc
-tttaaaactcgccaaaaggtcgttgtggttctctactggttaactatataatttacagct
-ttgttgagctagttcctctttggtttaagtcctcaatattagttggttcgagcgataagt
-tggctagttaccttagtcactatattagatccgaatgttatgcttcatctgaagaccgcc
-accctccaaaatttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtt
-tctcaagtggtgtatctgtacacgagtttccatattttcatcaacagccaccgcacactt
-atgtcactctaggtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgc
-tagtcaaaaataaacatagcgaggcaccactaattcggccgcttatcaatgggatgctct
-gcgcgagacgcgccagagctcagtagttagttcggacatacatttacttcagatgatcaa
-ttagttttctacaaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctt
-tagtatccttccgtcttatataaggtcagtcccccgtttcggtaccctggaatttactaa
-gaataatgaaacagcccccaaggacgtacgtttacaaatgatagaccagatcgcctagct
-tattccgacgcatgttgcatagaattgaaccaacggaatgtgagagtaactagatgagcc
-gaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatg
-tcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctc
-ggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatg
-gctcatatggaatgcctacctcatagtgctgaattaacacagcactgcggacctaacttt
-tcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgtagggatcctcggt
-gaatttgtgattgggtttgttgtagtactgaccaagtgaatattctttttttctaaaagc
-agatctgctgccgggcactacgaaggagatctctgtgtatcattattgcttcttgacatg
-atgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacat
-attgttgatacttcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaa
-atactggtgacttggtcctatctactattagctagacctctggggaaccacgcccccgta
-aaacctgtgcaagagagggggtcatacatcttagacatcgcgcctccaccagggaagcat
-tgggtgattgaccaggtgtgtaacaaatatgattattcttatactaatattagcaaagat
-gcataatgatttgtattaaatgtataattgaattgataagggtcttttagtcagtgatag
-agtagtataaggtagacattagaactcttaaccggacgcagatttttcggtcttagtaag
-ccaattagtcgacaaaacaaggtaagagcggttactagtagtacctataatgcactgaat
-cttcggtcgaagtatagttctaatgctatgcagattgtgacggcgacaaatgttcagact
-tatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattgaatatttttaaat
-acaaaatgcgcctacttattaggggaattaaccagattgaaggccaatcctcacatgtaa
-tgagataatagacgataaatgaaattcttgtaatagttgaactgctacgtgatgggtatt
-atatatgattgagatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaa
-cgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcact
-ccgaagtataagcaataataatgcgggtaatccagactagatcttttcggactcaatgcg
-gtttcacggtaaacatgattaataccggagagtagtcgagcttatcagcgatgcaagcga
-attcattgtgccaggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttg
-gcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaa
-gtccattaccttttagtttcagactggtggagctgactaaagttatatcatcattttgta
-cactggtttagttaacgataatttcagatttaacatgaccagacgataatcgctgtatat
-ccagttggaatgtggtttgccagaaaggttaacttataatcaagcctctcttcagtcttg
-attcgtcgtatcccatccattgcgctatacctcagtgtatttggagctgtagttataccg
-tgtgctaagatcagtagacatgacgagagcaatattatctaccttacaagcatcaacgga
-cgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatatactatagttctg
-tattcagcagttattcttatattcgatattatcttgcctattggatgtctgactttagta
-tattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaa
-ttataaacggttacaaccattaaagacaacaagaccctatagctttatttgaattttgtc
-aatgcgcaacttggagctcgcgatacatcccaattagtctatagggtcgggacgattcta
-cggcatttctggttataatgacaacatggattgtggcccgagaatcgctctttcattaat
-taagcaatcattacagtcttataagcgctacttccgagtggtagcaggtaactcgatata
-aggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgatagagaataccga
-ccacagcgcaacctttgattactttcattaaattgtacggctcactcgacatcaagctta
-agattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcag
-aaagcgtacccagagaagatacgctgttacaatatacagggtgaaattattgcctgttct
-tcgtaaccatttcgccaaacttggttagaaatgatagccattcatgatagaaataagctg
-aatgataccagtatctttaactatgtagtcagggggaagataacgatggtccatgtatgt
-ttctgatatgtgacagtattggccgcgtaatttgctaacgaagctacttaatgcctttga
-gcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgagctataatatatg
-ctagtagagaactctggaccatcatctatatgaatactgattcgagcgtgcaattacttt
-agcctgcgtactactgactctacaaaacactctgagataagtttgtagtcagtaagtcgc
-tctctataaaccttttggatgaccattgtacagccacttatagatcccaataaatagcac
-aggagacagagtttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagg
-gcacctattatttgatacctaacctaacggccctttcacaatggagaaatatatgacatc
-gggacaaacacaaatggtgggtggccaggagatatgacatggtggcgtctctaagaaaca
-cggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaa
-gattttgccgtgtaatgacctggtacattgactggtcaggaatacatcactgtagttgcc
-gtagtgtcctgttggtgttccatcaagacacatcgtataacgcaatttacgacggacatc
-agatcaagttatacagattatttaagtatcacgtgtgcattgggacataagggatctcac
-acatgccttggaacatttttgctttgtgccgctttttcgctgcactaccaatccttactt
-accagtatattcaaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcg
-attgggatagacgagacatttgcgagcgccctccacggatacgaatctcccatatcaatg
-tgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagca
-ctcgcatagcagttattcagaacctaatacacaaaaccgtcaaacattttctaattctag
-gtatgggccgatcataggagctaaggtgaaactcataaatgttttgttagatctagcatc
-ctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgtatcctttttaac
-tgaactagtcggtcccatttcgtgactgagatctattaaccgataagattaataacactc
-gcattcgtatcagctcagagtgaagtttttcaataatttgactgatatattaacttctaa
-aataaccctttaagcctcggatccgtttcccaatcacatcaaaaattcttattccaacta
-tctacggattaacaacgtgcatggggatcgtagtaagaacttgttccgatcactttgagt
-atatcaagttgacggcccggttattattgaatagaaacattcacctgctaaattaaatac
-cgcacatcggatacccgatttcagagggccgtcttactaagggcaggctttgttcggttt
-aactgagatgttcattattttacagtatgcttcaactaatatgtaacgaaggacagtgga
-tctgtctccatagtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgt
-tcgagttgttgatcatggcacgtgaaagcaacccctagtattctagacgaaaattttttc
-tagttcatctgataatttgccaattcaaaaacaaccgctggtttcccggcgcattctcta
-aaatggaagtcgaacctagagccattatttgtcggtaacccatgagttccttcttttcag
-aagttaatacactgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcat
-aacaacattggatcaagatagcaatttggctacctattctaattctcactagattcggta
-ttccactacaatatcggcagattaggattggatgaataatcggtgtttaagtccggttgc
-gtctccaatctcctaatttttattaatattgatcttggtgacctattgtaaataaaaact
-tcaagactttgaataacggtgaaaagatagaagactcatttgaaaatggatcatccacag
-atccaaacattagcaagacactaatccccaactagctattctgatcgcgatcgtgctgca
-gtactcctgtcacaatagtctgttcatgatctaattctttttgggctttgttcgatggtg
-attcagaatctttatccggtcgcttccctgtagctactttgtggggatattgcccgggga
-ttatagggttgagatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactac
-atcagaacatcgtgaagacaccatacgcggtacctttatttaccgataacatttcttcaa
-gaaataccggtaagcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaa
-ttttatttaggttactgctcaaggaataaaaactaactatttaatttataataatattac
-aaggctcacactgattagatttgtctataagacttcgcgatcccccattaccggattgtc
-ttaagaataaactagataaaccatgcattttctagataaggcctttagtctaattagata
-caaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaaccttttaattac
-ccgcaaatcactttatgtcgagactacctctgaaatttattatctacctaccgcatgagg
-acttgaaccatcttgtaggagttatgtttattagctaagattcgtttatcctgtagcggt
-ccatgtatattcaacaagcaaaaagcactcagaattgtttttagttgagtcaagactgat
-atataaataagtttccctagttttttcgtggtgggacgatattgaattgaatcttaaccg
-aagagtttcccactctgtcgcacaataatacacgccaatatttccagccctgcttatgcc
-ttaatcggttactcaatctcccattgaagttcattttgatctgcatagaagtttcgggcc
-cagccttttttctgccaccttcctccaagctctgtagacgcactctaagattgatgctca
-catgtattaattctacattaacataaatatataagtcatgcatcttcgagtaaaatatct
-ggttctccaacatgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatg
-attgggttaactggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtct
-caagaccgtgtattcctcgtgctcggaagggctattacgcttacttccgttttggtatct
-taatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaag
-agtataaaagttgtttaaacgaactacttgctttacaataccggtcgtatatatcgccgt
-gaatccagaagattgtcttctttggattatcaaccgagatcctgtggaccgatgttttgg
-gaccttcacagaggactccaggtagagctcgcttttgcattaatctaagaattgtacctc
-tctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaatt
-actttaggccgaaaggcacatgagttattatacatatacgagatggtggtatacatcgaa
-ttcggggcatacactatagttgcattgtatttagctgctttaaataatatgatattacct
-tccttacataagacattaccggcataccctggttttcaacttgtggggctttttgacgat
-cgcactctcatttgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcg
-ctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaatttaaaattgaa
-acttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgc
-aagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatctt
-gatttcattcttcttgtcaattgccgacataggatgaaatcagattccaatgcaatacac
-agtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggat
-agtatacgggccttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgt
-acaatctcacacatagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaa
-ctttattagaagtaaaaatgtgggcaaaagaaggattccattttacaagacgattacaat
-gagttacatgtctctcaacgtagtctttccctagtagtctttgaactatttaggtactcc
-agaaaattttagcaaagggtttctgtgtgaatccgccattcatgtttatgatggaacaat
-aagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatatt
-caatttagtacagatccccagaagttaagctaagtgctctaaaatggcctaaacggttat
-caaagtaggtctaattactatactaacgggtgcatcgtaataactgctgtcgatgcaaca
-ctatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattc
-ttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaa
-atttaatctatgagcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttg
-acaaccgcacacataatcgaactattgatagtcgggagcataaccaggtgaacgtacttt
-gttcacgacatttattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaac
-gcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgag
-aactttagctggcttttggccagtatttagggaccaagagcactagccttaagctgaata
-ttttgccatttatctactgttataactttaaaacttggtggcaccagacttgtcgataca
-cacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttata
-ttatatttaaactaaaagatgatattagcttctgagggcgatagggctccaaatcataaa
-gaggaatatattattacacgattagaaacccacaacatacctcgaatcgcccaaaagttt
-gacgaaacttggcagtactccacatctcagtaatacagttgggagagtctcaaatgttgt
-tttattactcaatgaaccaccctcataatttcactgctgttccattaaatttgcaaacga
-tcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtagatgcataataaa
-aaaaactgctcgctataacacgatcatcgtgcattcttacttaggagcatcacccgcaca
-ataacgtaccttaaactacaacactattagaccgagtactgtaattcacgaaagctcaag
-ctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttgcggagaggattc
-aattattttccattgcacctactccactagattcgataaaagaaggtggtcctcccttaa
-aaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatcctt
-ccctaagaaacataaaggtttttaataatgtcgactgtgaactataactgcatcctttcc
-tgacctactccggttccttgttgttatttctgaacgagaccagtagataaacaatgtaaa
-ccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaaca
-taagaagtcataatcttacttgaaattaattttgccttttattttttttcaggctcgaaa
-ttaatgatttgttttttttgaccttctagttacgctaatatgcggtcgcctgtggtttct
-attgagtcctataacgggatgggatctaatacgtttggttactagtaaacaaggtataaa
-tttgataccggagtatcaactgtataacatcaagctttatgactcatacgcgaagtaatg
-acacaaggctttcaggagatcgcgagtacagagccactaaggggtgtattacgatagtga
-caccaccgagcgcactcactccccaagtagatttatgatcctacgctaagtattagatat
-ataaccaaagaggttctagtcagtgcaactcttagaataataattagccggttttgcctt
-tttaggcctaatgcaatattcagctagcccttatgtatctcgcgttccacagcaccactc
-atggcacgcgtttaaactaatcaaatataatctatgaatgttatgccagtacttgaataa
-atcaggttttttataagtccttgcatactctcgttatatactgttagagtcttaccccat
-agaaattctttcatctgcaaacttagaagaattctcagctacggggagcataaagtcccc
-aggatgttgacaaatacaacaaatgtggcttatacaaacactccatatgaaaatcgaacc
-ctcgtggtagttttagccgaaccttgtacggataaatccctccattttccaatagcagat
-acctatcctactacctcgtggtattaaattaaagcttgaaatatagagctgcatagctta
-tccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagc
-aaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagc
-aacttcgcttattaagacaattgtttataagccataattaaaaacatatgttcaacaggt
-tcattgatatttgtaattgcacaggtttttaataaggatctacgtaagtataatgaacaa
-actttttaccagagttatattctgtactttgaaaatgctcctctaccgccttagagactt
-tcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattca
-accgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaatataattttcagt
-tttcgaacacataaccctttgaaaatctgctatttaatgtctcacctgcatgcactatct
-tctatactgctcagaacggctatacgtcactatgctccaagtgacgatttaaacgaagca
-aggaataataggtttattttagtgcaaaacaattaagtgcggactacgtgctctttacaa
-taagccttgtgattgggctataggttaagtcccatattaacgatctccaatgtacaaaat
-cgacaatcgctttgcattacccggttactagtcgaattacagatagctgttagatactca
-ctctaattttggacaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatc
-cttccatcttaaacgattacatattatagacttgttcggggtagagatatcacagttgtg
-caaacattgtaaatcgatactagtttatgttggtagtctagttgcttttaccattccccg
-aaaaacttgatctactatttcgacaacagtaaacttgaactaggtaagtgaaaacagaga
-atgcctcatagtgccactatttgtccactatatgtaagtgtagctttacataatccacta
-tgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcccggatattacga
-ctgtaactataaaactagttactggtagcgcgccatgtatagatttgttttaccggttgt
-ggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttc
-tataaaacgataaagtaaagttgatgttcagcctccttcttatggttgcatcgagagtac
-actactcagtgggaaatagatcggggttcctacttcagattgtattatctaggcaattgc
-cgattgtgccatacctggataaaataagctacctacatgtgatgcttatctattatcgtc
-atactaccttagggtgtcctgttgaacgctacattaatctttagccgtttgagatgttcc
-aatggataggagtctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatg
-tgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtccttctggttctattc
-tgctgaactattgaatggaaagattggttgacctacgtactatttgcttgaagtcatcaa
-tttgacggggtgagagacatatggtgcatactttacggactctatattttagatcagaag
-cttagcagtcttctctacaccccctcacgacataattgcttttaagaatctatgtttgat
-tcctctacgggaattcggatccgttcgcatgtgcggtttatctaaaccaggggacatatg
-ttcagctaaagcatacgaacactttgctaactagacgtatgtatagtagctataaatccc
-gacgatatttacaaaaagaaatgagactcaaatatatacatagcgaccctacacttattc
-gcaccctgatctaggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgt
-attaaatttactgcagttgagattttagttgtctactaaggattactctaacccgtaata
-aggatcaagactcggtactagctttactatcattccctatgtgttttcctaactcacaag
-ggtacgtaccagcctatgtaattacaataatgataaagacacaaaggaagtaactttaca
-aatgagtctccagttacactagcttagtccctcccatcttgctttgaagtctaaatacgc
-aatctctgaggatatacagcagaagaacactcataacgttggagtccaagaattagactc
-atagggcccccaacatttaatatgtactgtgagtttgaaggtgttctattgttaattcct
-gctcttgatacatgacacgtactccgtgtttaaggcttcggactgactttctttcataag
-ttgagcaacgaaaatttcagaatcgataagttggattcactaactaatacggctgattga
-aaactccactccggacctatatggtcgacctttatacgtaaccgatataaaacttatagg
-ctggtatatcgagccttcctagcgcaatttcggatggggtttcttctactactcaacaac
-ggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgt
-ggagcatgtgtcattatggactggagcactcttaaatcactctgcgtgtgctaaacgata
-gatcataacatgtcctgagtaaattttcttgatacgtcgcaatataccgttattagttaa
-acgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgact
-catctcgcctaacacgcacacgtataaactcggaatgactgccgctcttacatattagaa
-atacagactacaccacggaagcattgggtcattctcaaccgctgtataaaagatgattag
-tcttataataagattaccaaagaggcagaatcatgggtagtaaatctattattcaagtga
-ttaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaaatattaaccgga
-cgaagtggtttacgtcgtactttcactattagtagtaaatacaaggtaacaccggggaat
-agtactaaatataatgatatctatcttcgggagaacgagtcgtctattgctttgaacatt
-ctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgttacttttgtctat
-tcaaaagattgaatagttttttatacaaaagccgcatacttatgacggctagtatacagt
-ttcatcccctagcatcaatgctatggacagtattgaacttataggaaattcttctaatag
-ggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatggcactagtattg
-tcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctt
-taacgaagcgacagcgacagaactcccatggataaccaattataaggcccgtaatcctct
-agacatcgtttaccaataaatccgctttctccgtaatcatgttgaataccccagagtagt
-ccagatgataaccgatgaaacacaagtctttctcaatgcacttacggtgaacttattacc
-gccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaa
-cttcatcaactttcgtatattcaacgccttgtaattttactttaagacgcctggtgatgt
-agattcttagataatcagtttgttatcggctgtactttaccataatttcacaggtttcag
-gtcaagaagattatagctgtatatacagttccatgctcggtgcacagaaacgtgatcgga
-taataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagt
-gtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagatt
-agattccttaatagaatataccgacctctagtccgaactaaactatagataacgccaact
-tcaggttaattgtctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggc
-catattggttcgagcactttagtttttgatgcataggatatgcaatgtatagctgaaagt
-actttatctgtttcaaactcacattgattaaaccggtaaacctttaaagactacaagaaa
-atattcagtgagggcaattttgtcaatcacaatcttccagctagagatacttcacaattt
-gtcttgaggctacgcaacattagacggattttcgcgttttattgaaataatcgaggggcc
-caagagtatccatagttcattttgtaagatttctttacaggcttattacagcttcttcag
-actcctacatgcttacgagttatatgctagcatgtgaacaatagattaatatacaggaaa
-acgtacattgagagagatgaccctacacagcgcaaccgttgagtactttcattaaagggt
-aacgctctcgagacagcatccttaagatggccttattgtcaaatcatttgcagaagtacg
-caagatccctaaccaacgtagaagaatccctacaaacacatgagacgcggtgaaaataga
-cagggtgttagtattcaatcttcggagtatcaatttcgccaatcttggtgagaaagcata
-ccctttcttcagagaaagaagatcaatcataacactatctttaacgaggtacgcacgcgc
-atcattacctgcctccatggatctttaggatagcggaaagtattggcagcgtattgtgat
-ttcgttcctactttatcaatttcacattcatatacatgtcttttatcaaaatcgccaata
-agataggatgagctatattagatgctagtagagttcgcgccaacatcatcgataggaata
-ctcaggacagcgtgataggacttttcaatccctaatactctctataattataactctctc
-ttaagtttggaggcagtaacgcgctctatataatcagtttgctgcaccattcttcagcct
-ctgatacatacaaataaattccacagcagtaagagggtttaattgagacatcttgggaac
-ttaggattttactctaacatcaccgaaacgattattggataccgtacctaaacgaacttt
-ctcaaggcagtaatataggacatccgcaataacacaaatgctgcctccccaggagttatg
-tcttcctggaggctatatcttacacccactcactataggcaaactaaagtttaaatgttg
-attgtctaaaaaaaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgt
-aagctataattctctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcct
-ttaaagctatttacgacgcacatctcagcaagttataaacatgttggaagtttctagtcg
-gaattcccaaagaacggatctatctaatgcattcctacatttttcctgtctgccgatggt
-gccatcctattcaaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaa
-ccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccgagccacatacac
-ggagaacattctaacatagcattctcaactcgatcatttgcaggttacttctttcctatc
-ctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacctaagaaacaatt
-cagtaaaacatgttcgaattcttggtatgggaacatcattgcagctatggtctaacgcat
-taatgtttgggtacatcttccatcatataaacaggaagagtctgacgacagggagtgctt
-gcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtg
-tatccgataagatttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaa
-tgtgaagcatatatgatctgctttaataaaactttatccataggatacgtttccaaatca
-attcaataattattagtcaaaatagataaggatgaacaacctgaaggccgatcggacgta
-gaaagtggtcccatcactttgagttgatattgttgaaccacacgttattatggttttcaa
-acagtctcaggatattgtatatacagataatccgataccagttgtctgacgcccctctta
-cgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaac
-taatttggaaagaagcacagtggatatgtctaaattcttgttattcaggcctgaatttaa
-tacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctctaagctaccact
-tctatgatacaccaatagttgttctacggaatctgataattggccaagtcataaacttcc
-gctgcgttcaacccccttgctcgaatatccaactcgaaaagacagccttttggtgtccgg
-aacaaatcagttacttcttttctgatgttaattctctgtggtcagatacagaccaaaaac
-tccgcggatttaccatcctccaagaacaaatttgcatcaacatagcattttggctacata
-ttctaagtctcaatagtttaggttttcaactacattatcccaacattaggattggaggaa
-taatagctgggtaagtccccttgcgtctacaatcgactattttttatgaatatgcttctg
-ccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaat
-caggtgtaatggcagcagccaaagagcatataattagcaacactctaagaacattataga
-tatgatgatagcgatcgtcatgatgttatccggtcacaatagtagcttcatcagctaatt
-cgttttgccagtggtgacttgcgctggaagaatcgttatacggtcccttccctcttgata
-cggtgggggcttattcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaa
-ccatctagtagtcaactatactaaatcacaaaatagtgatcaatacatacccgcttcatg
-gttttaaccatttaattgattaaagatattccgctaagaaccattatctacctaaactga
-tcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgtt
-atattgtatgtagaataataggtcttggagctaaatgatgtgattggtagtgaagactta
-cccttacaactttaccggtttctcggaagaatatactagagaatcaatgcatgggctaca
-taagcactttagtctaatgagataaaaaatacacgagtcttccatcatgaattttttgtc
-gaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaataactctcatat
-gttttatataacttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagct
-atgaggccgggatccggttgagctacatctatttgctacaagaaaaatgaaagcacattt
-gttgggagttctggctacactcatagagaaataagtggcccgagtgggtgcggcctgcct
-ccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcc
-tttatttcctccacggagtagcccgtaatccggttcgaaagagaccattgaagttaattt
-tcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctctt
-caaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacataaatatagaagg
-aatgattcggcgagttaattttcgccttctccaacatggcatccctacgttcgttataag
-gaccatacatgtaggttttaaaggtttgcggttaatcgatatttacatcatagaaattct
-atagtcaaatttacaagactctagatactcactcgttgcagccggctaggaagcgctttg
-taccttacttcccttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactca
-tacctccgtgaagagggtagatagactattaaagttgtttaatagtacgtattgatggaa
-atgacccgtaggagatttaccactcaatccacaagattcgctgctgtgcattatcaaaac
-agtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggtagagatacctttg
-caatttttcgatgaaggcgaccgagataaatgagctataacactgtatgtcttttgattg
-ctataaaacacagaaacggatattaatttaggccgtaaccaacatctgttatttgacata
-gaacagatggtcctttacagcgtattccggccttaatattgaggtccagtgtattgtcct
-cctttaaagaagttgattgtaactgacttaaataagacatgtcacccattcactgggttg
-caactgctggccctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacc
-tgcgtttaaaagacataaatgtcgctatgaaggttattcattaattttagctgttttctt
-agaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttg
-tcaagtaggcgggcatcattgagattgtaagaaataaagccataaccagccccggaatag
-aaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttc
-ttatcagaggacattgcaataaaatctaacaccctcccttgtgtggttgggccatttgta
-cttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtcccataaacgatc
-attctcgcccacttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgt
-ccaatgttaggctaccttctccaactttagtacaacgaataatgtccgattaacaaggag
-tcaatttgtcatgaccagttcattcaggtacttgtatctatacggacgcgttccagagta
-gtatttgaaattttgaggttctactgataagtttagctatcgctgtatgtctgaataaga
-atttaatgtttatcttcgataaataacaattaacaactcctaggtgatacactgtgaagt
-ctgctgttccccaaattacatatgctattttgttcacataccatgaagttaagctaagtg
-ctctataatggcataaacggttatcaaactagctcgaatttcttttattacgccggaagc
-ggattaactgctgtagatcaaacacgttaggatagtgtcgttttcatatatatctaaatt
-cggtctaacatgcattacccatgcttgataacgtagcacttcgcagtctaattatgtaat
-gtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgacta
-cccggatctttagcctttagggtctaaacagaactaatattactacgtgtcatactccgg
-agcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtat
-caaattaacccagcaatacaataagcatgaaaataattgtaatcgggtttgggccggaat
-cccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactggattgagccacaa
-actcaactagcattatgctcaatatttggccagtgttctacggtttgaaatttataaagg
-ccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaataggtttaattaga
-acatccgtaggatttctgtttatagtagatttatactaaatgttctgattagattctgac
-ggccttacccatacaattaataaagacgaatatattagttatagtttactatccaaataa
-attaagcgaatcgaaataaactgtcacgatactgggcagttatcaacttatcacttatac
-agttcggacactctatattggtctgtgagtactctatcaaactaactcataagttaactg
-cgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatg
-acacatatggagatgcataataaaaaaaacggctccatatttctcgttaatcgggcattc
-ttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaactattagaccgtc
-ttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattct
-gataatactgggcggacagctggaaattagttgccagtgcacctacgcaaatagtttaca
-taaatcaacgggctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaa
-gcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtag
-gtcaactataactccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacg
-agaacactactgaaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaag
-ttggtggtagtgcacggaataacataacaaggaatattatttattcaaattttttgtgac
-tgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgct
-tatttcaggtccacggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgt
-cctttagactattcaaggtagaattttgataacgctctataaaaggtagaaaatcatgat
-tgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccct
-ataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttat
-gatcagacgctaacttgttcttagagaaaaatacacgggatactctgtgcaacgatttca
-ttaataaggtgcagcttgggacttttttggccgtaggctttattaacattcacagtaggt
-agcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaaatataagctagg
-aagcgtttgccaggacttctataatgcaccgttttttttagtacttccttactagcctta
-gtttatgttagagtctttccaattacaaaggattgaatagccaaaatttctacaattctc
-agcgaacgccagcttaatctaaacacgagcttcaaatattctacatatcggcaggagtca
-atatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataat
-taaatcctttttcaattaccacagtacgtgcattagaactactgctatgaaagtaaacct
-tgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaac
-gagttgatgttctgacgctagagcttaccattcgttaaacagataactaaaatttaatgg
-ctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatt
-tttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtac
-catagaagtatgtataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaat
-cagactagtcacacttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaact
-ctacaaggcatgggatgagattctaccgactccggataacactttacgatcgcgcataac
-tctagctcttagataagtttaacttgtcgatctcataaacagttcaaaatctgcgattta
-ttgtatcaaatccatcctctatcttctataatcatctgaaccgcgatacggcactatgag
-ccaagtgaagattgaatccaagaaagctataattggtttattttagtccatttaaattaa
-gtccggtataagtgctctgtacaatatgcagtctcatgggcatatacgttaactaccttt
-tgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaa
-ttactctttcctgttacatacgatctcttagtttggacaactagcccatgatggcgctcc
-tctagcgcatgaacctactttataattacatctttatcgatgaatttttttagactgcgg
-aggccttgagttttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtac
-gctacttgcttggaacaggcaccgaaaatattgatctactattgcgtcaactctattctg
-ctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgtcaactatatcta
-agtcgacctttactgtatcaacgatcacggagagaattaccgaatacgaaacctcaggac
-taaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagggtagcgacacag
-gtatactttgggtgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttc
-cggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactcc
-ttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttc
-agatggtaggagataccatttggcccattgtgactttacgcgattaattaaccgacatac
-atctgttcctgagctatgatcgtctgaataaattacggtctcctcttgatacctaatggt
-ttctggagacgtttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagct
-acgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaagggataaagaga
-aataacggacttctccgtagattagcctgatattttgatgggaatcatggcggcacatac
-gtaagagttgcgtgaacgaatattttggacggcgggagacacatatcggccattcgttaa
-ggtctctatattggacatcacaagcttagcagtatgagctactaacactcaagacattat
-tgattttttcaagatatgtttcattcctctaccgctattcccatacgttcgattcgccgg
-gtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgttgcgatagagac
-ctatgtatactagagagaattccccaacatttttacaaaaacaaagcagactaaaataga
-tacagtccctccatacaattaggaccaacatgttattgccgatcctagcacacacaccac
-aaactcagaacttctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaa
-ttagcattaatattaaaactaattaggataaactataggtacgagctttactataagtca
-ctaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataa
-agaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagagtagtacctacat
-gcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataa
-agttggactccatcatttagaatcatagggaccaaaacatttatttgctactgtcacttt
-gtaggtgttctattctgaattcctcatattgatacatgaatcggaatacctgtggatccc
-ttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatcgagaagttccat
-gcaattaagaattcgcctctttgaaaactcatatccccacatatagggtccaccgttatt
-cggaaacgatataataattattccagcgttgagcgtcccttaagagcgcattttcgcttg
-gcctttcttctacgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcac
-cccatagaactacctctgagagcgcgagatggtggcagtatgctctgcagctagcgttta
-gaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaattgtcggcattag
-gagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctag
-tccgcagagatacgattacagactcagatcccctaacaagcaaaacgattaaatcggaat
-cactccccctatgacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctc
-aaccgcgctttataagatgttgagtctgagaattagatgacctaactgcaagaatcatgg
-cgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcg
-gtctaaggacttagatgataaccaagaactggtttaccgagtactttcactattaggagt
-aattacatgcgttcaccgcggaatacgacgaaattttttcatatctttatgagcgagatc
-gtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaattatagattcatt
-atacagatgcttacttttctctattcaatactgtcatgagttgtttttaaataagcacca
-gaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgatggacagtattct
-actgattgcaaagtagtctatttcggcttagcagtacgcatgcctatttttttgcaggca
-cagaataatatgcaactaggattctcggcatccaattaacaggctaaaacaccaccgaaa
-gacaggtaatctacgaagttgatgtttactacagaaagcgaatgatatcacttggagaac
-attttagatgcccccttttaatctagactgagtgtaccaatatatcaccggtctaccgaa
-tcagcttgaataaaccactctagtactcatgataaccgagcatacacatgtatttctcaa
-tgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggcgacttatacttc
-tgtctttgagtacagcacaccctaatgaatctaagttagttgttgatacgaattgtaatt
-tgactggatctcgcctcctcatctagattcttagagaagatgtttcttatagccggtact
-gtaactttattgatctggtttatggtaatcaacattttacctctatttaaacgtccttgc
-gccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtctggaggccgaga
-aaagaaatgcacagagtaagctctctattgcgacatctacgtagaaactcgcatttcaga
-tcgagtaagcaactctcattgtgttgattcagtaatacaagattacctacgcttctacga
-aatatactatagatttagcctacgtcacctttagtgtcgagtcggagctttgaagatcgg
-atgcggtgtggactgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtc
-gatatcaatgggatacctcaaacgtctttatctctggataactcacattgagtataccgg
-taaaaatttattctattcatctaaatagtcagtgagggctagggtcgcaatcacattagg
-ccacatacacatacttaacatgttctattgacccgacccaactttagtagcattgtagcc
-gtttatgcaaatatgccaggcgccaaacactagccagagggcattttgttacatttattt
-aatcgattattacacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtc
-aacaattcagtaatttaatccaaaacctaaagtcagagacatgacactaaaatcacatta
-aggtcagttagtgaaggaatggctaaccagctagagaatgcatcattaacaggcacttat
-tgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaa
-cacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgt
-agacaatagtcgggacttagcagacactggatgcagtcatagaagatcttgcataacacg
-ttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgc
-taacttttccaacacgtttgtgatttcgttcataatgtatcaatttcacagtcatataca
-gggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttcagagttcagtta
-gagcctaatgattcgagagcaataatcaggacagcctcataggaagtgtcaatcacttag
-aagctatattattataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatca
-gttgcctgcaactggcttaacaatatgatacataaaaatattttcatcaccactaagacg
-gtggaattcagacttattggcaacttaggatgggactattaaataacccataagatgttg
-ggataaagttacgaaacgaaagggatatagcctgttagataggaaatccccaataaaaca
-tagccggcctccacagcagtgatctattccgccacgcgatatctttataccacgcaatat
-accaataataaaggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgc
-gtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagct
-tcctctgcaagatacaatatgactttttagcttttttactaccaaatctcagaatcttag
-aaacaggttggtacgtgctactcggaattcccaaagtaccctgctatatatgccattcct
-tcattggtccgggctcaccatggggccatcatagtaatagaaggtagtaaaactagttga
-tttccgacttttaacaatcactatcctgacccagatatgggttccgactggcccttactc
-cagtaagggcagacacacagacaacgagaacttgataactttgaattctcaaatcgatca
-ttgcaacgtgacttatttactagcctactcctataattcatacgtcaaatacatttcaac
-ggaggaagataataagtaaatattcactaaataatggtcgaaggagtcctttgccaacat
-aagtccacatatgcgctatagattttttcttggggttcatattcaataagataaacagca
-agagtatcacgtcagcgagtcattgagatcttggctagcattgtgatagcatattctacc
-taaatggtagtctagcacagagtggataagatatcagttagatatagacaagtactataa
-cagatctcgcttcgttggattgtatggctagctttgatgatatgattttataaaaattga
-tccagacctgacctggccaattatattcattttttatgagtaaaaatagataaccatgaa
-aatactcaagccccttaggacgtacaaagtggtaacataaatttcaggtgttattctgca
-accacacctgttttgggttttcaaaaaggctaagcagattggttttacagataatccctg
-aacactggtatctcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctg
-aagttttgtaaactaggcggaaaatatgttcgatagatccactcgcctgaggtagaaatt
-cgtcttagtaacgcctctttggattacacagaatagtgtactgacacgtacactgctgca
-gcagccatacgctaacattaaaattcgttgagtctacatttgttgttattcggattatgt
-tattgggaatagtatttttattcccctgcgtgaaaccacatggatagattagcctactcc
-taaagactcccttttggtctacggttcaattctcttactgagtttatgttcgtaattata
-tcggcgcagtgaatctcctaattatcaccggagttaccagacgccatgaacttatggcca
-gaaacattgcatgtggcctacataggattagtatcaagagtttacgtttgcaacgacatt
-tgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgcacgcgactataga
-agttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgct
-tgatacctgaattgagacatgtataagggctattgccagatgaaaaactgcatataaggt
-caaacaatataagaacattatacataggatcttagcgttcctcaggatggtatacgctat
-aaagtctagcttcagcagctaaggagttttgccagtgcggacttccgctggaagattagg
-tttaaccgccctgacatcttcataaggtcgggcctgattcaaacccctggagtgccgtct
-catacttgaattaatcgatggaaaacttcttctagtctaatattattattaacaaatgac
-ggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaatcattttaaccta
-tcatccattagctacagataatgataccccgatccgactagggggtaagtggttgttccg
-ttaggataaaccatgtaaaacgttagagggtttgtagattaattggtattccagataaat
-gaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaa
-gacagtataaatgaaggggattcagaagcaagtttctcgattgactgaatttataaacca
-gtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatat
-ttatcgagtctataaatatctttggttgtatattacttcacaatcaccaattctaaatga
-ttcttccactgtgcgggtggagatatcaggacgggttaaggttgacctacatcgttttga
-tacaacaaaaatcaaagcacatggctggggacttctcgatactatctttgagatagtacg
-ggcaagagtgggtgacgcctccctacattttcaagtctatcggataacttctcggtaaaa
-cgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaagttttaccggtc
-gaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggtta
-tccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatg
-cgtatggttctgatatatagatcgatgcatgaggacactttattttagccggcgaattaa
-tggaatccatacgttacttatttggacatgacttctaggtgtttttgctgtcccgtttag
-cgatatttacagattagtatttcgtttctcatagttaattgtatctagatactaactcgt
-tgaagacgcataccttgccatttgtacaggacttaactgttccgtgcgtaatttgaattt
-cttataggttcttcaaggcacgaatacctcactcatgaccgttcatactctagttaaggt
-cgggaatactacgtatgcagggaattgtaacctaggagatttacaactctttaaacaaga
-gtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatca
-cctagaaacctactcatacatttgcaattttgagatgtaggcgaaagagagaaatctgct
-ttttaacggtatctcttgggattccttttaaaaacacataacgatagtaatgtaccaagt
-aaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaa
-tattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaac
-taatgtcaccaagtaaagggggtgaaaatgctccccagggttctacagacatagagatgg
-tcagaacacgacccccctctcaacgcagtgtatttgaaatatatggacatatctacctta
-ttctgtaattttagatgtgttctgtgtataccgatattgataagtcaataggcttgatta
-cgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcagattgtttcttttt
-atgccataacctgcccaggaattcaaaaggttatcgatacccgatatgctgtgaattatt
-attctaatggccactcattcctgcttatatctggaattggcatgaatatcttacaaccta
-aagtctggcgttgcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaa
-ggtgggtacgtcacataaaagttcattagaccacactttgtgccgacgtatatagatata
-ttacacgtatagggaatgttttctcctaggtgacccgaccttctactaaggttgtacatc
-gtataatggcccattaactacgaggaaagtggtattgacctggtaatgcacgttcttcga
-tatataccgacgaggtaaagtctactattgcaaagtttgacgttatactgataagtttag
-atttccctggatcgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaa
-atccttggggatactatcgctactatcatcggaccaaaattaaataggctagtgtcttat
-cagaacatcatgtttaccgaactgatctattttccaatttaagctgatattacgtccgcg
-tatttattttagttccccggatgacgattatctgagctacatcatacaagttagcatact
-cgccggtgcattgatttcttatttcgctatatcttcaagttcacaggcttcatatagttc
-caattagcagtataattaggttttgtaactttaaccatactttataaaaggttatattgc
-acaactgatcaagcatccgctataacccgagctttaccagttagcggctaataacaaata
-agatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatt
-taggcaatgggtagtaataagtataaaatgataccacatatactataacaatgaaattat
-ttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgacatagggtcatcc
-atgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgt
-tataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaaaaccaatattta
-tcgttcgttattgctggtagtacaacatcacgagcatttctcttttgagttgatttatac
-tatatctgctgatgtgattatgtcccacttacccagaatattaagaaagtcctagattgt
-aggtatacttgactataaatataatttaagactatacaaataatctggctacattatgcc
-atcgtagaaactgataacgtagtaacgtcggacactagattttggtcggggagtaatcta
-gcatactaacgaatttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtc
-ttcaatacgtttagactattaaggactcatttcgagatccagtattaattatacgcatcc
-atatttatactgaagacggattgagttaggacgacaagctaaacaaatattaagttaagg
-attagtattatattgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgtt
-acttattcagagagacttaattcggttatgactggcagctcacctggaaagtaggtgaaa
-ggcaacagaagaatattgttgactgaattctacgggctacgaacgtaattacaaagcggt
-tcgtaaagagcataaagatcaatacaatggatctctacagtattacgtaaataacataca
-taaacctggtgttgattcgactagctcatagattaatcattaattgaagctacgaagacg
-cggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttataatatcgcgctt
-aaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatatttactaggaata
-ttagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacattggatgcatggct
-gtgggggcacaggatacttaccattagttcacctacaagcggcgtgagagggtctcagtt
-ttagccagcgcagagaagtacgggcctttagacgattaatgctagaattgtcataaacct
-cgtgaaaagctagttaataatcatggtgctagaagaacacaacttttctataaaccagtt
-ctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcac
-atagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgagagataaatacac
-cggatacgatctgcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtag
-cattttttaacagtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggt
-ttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtt
-tgtactaattcctttatagactgagtgtatcgtacactcggtacaattacaaaggatgga
-agagcaaataggtcttcaattataacagtaccccaccttaatctaaaaaccagcttcaat
-tagtattaatttcgccaggagtatatatataaatatctaaagactaaaagactcgtactt
-ttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattag
-aaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaatt
-catactcgattaaggcctataaaactgttgttggtatctacagagtgattaaaattagtg
-aatcagattacgaaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtg
-gtacaattggctgtagtagaattttggtataaaataggtgataaaccggatgggtgtggg
-cgaattcaaaagcggtttttgttccatagaactatgtagttggttataaaggttgtaatc
-tcggagattaggttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtg
-ggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggataaacaatacgca
-tataacttgacgatcgagcttatatcgacctatttgagaagtttaacgggtcgatataat
-atacaggtcttaatagccgattttttctagaaaagcaatcctatatcttagttaatcaga
-tcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacattcctttttgtcc
-gggtggggactccatttaaagtatctcacctagaactcagcggtaatagatgcagtctct
-tgcccagttacggtaactaaatgttgatacttagaattgctaaattttagtctagacatt
-tccaggtaaaccggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgc
-tcaaattgcaattgagggccctactatagacaatcatcagactttttaattaaatagttt
-tccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgta
-tgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttc
-taagatggactataatcgattaggctaattccgttcgcaaatcacagaagcaatcttact
-caaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaa
-ttacccaatacctatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagat
-taagtctgaagcctagagacaaagggatactgggcggggaaacctgctccttcacggtaa
-catggtaacaacagaatttggttaaggttaaaacgaaatatactcggagtgaattactgt
-taggtttcgtcatcggatcaataagtagtttccgtgaagacactcttatattagatctcc
-gaaattctgacccgtgcattaggcacttggtaggagattccatttggaacttgctcaatg
-taagccagtaatgttccgaaataattcgctgcaggagcgaggagccgctgaataaaggac
-cctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtcaattccagagctg
-gagatacattcatcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttt
-tcctaaacacaacggatttagacaaattaccgaatgcgccggagagtagcatcttagtgt
-catgcctatcatggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgc
-actcaaagttccgccattaggtaagctatatattgtggtcagaacttgaggacaactatg
-agctactaaaaataaacaattttgtcatttgttctagatatgtggcattcatcgaacgct
-tgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatca
-ataacatatagttcagatagagaacgaggtattcgacagagaattacccaacattggtta
-ttaatctatgcagaataatttagataatgtcactacataatattaggaccaaaaggtgat
-tccccagaagacaaaacaataaacaatctcacatattcgctagtacctatgtatgggtat
-gatcttctgattggacggggataatttccaggtatattaaaacttattaccataatctag
-acctaagagaggttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaag
-acttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaatattctgtataaa
-ctgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgt
-tattctgatcaactaatatcataaactgccactacatcttgtacaatcattcgcaacaat
-acttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaatcagattcataaa
-ggaatacgaataactctggatccattaccacgcaagggatttatttacggctgattactt
-tttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgcataaataatagca
-cctaatatagccgacaaagtgattccgataacagattttaagttgtccagccttgagact
-ccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatcccaagtggatgg
-ggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcga
-aggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattg
-gaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaa
-ggaagcacgcattgaagcagctacgcagaactgagaagatgacactctaagatacaatta
-atacaaaaacgttttaagcccaatctatcaacagatgtaagatgtctaatacacaagaat
-aaaaccttcatgtcccgatgtataataacagctttatttctgctggtcgaggtgaagtag
-tggaaattactccatcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcg
-tccatccctctctcctagtgatccgtatatccaattagaggataaccaacatctgcgtta
-ccgacgaatttaaatttttcgactatttaattccgttcaaacccgtattcgtagtaagtg
-tttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaa
-ttgctgatctaggatacatgctttataaacatgcttacttggctattttatttactgtca
-tgtgggggtttttattttcaacaagtatgtgctaccattggataatctggcttcaaattg
-aagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtcccattagaacta
-cgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaat
-ttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaa
-tgcgtatcatagaaattcgtgataatttttgttccaacctttgaatctagactgagtgga
-aaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcgaatcatcttata
-actgcattcaaatggatttctcaatcatctgtacgtcaactgttttaacaataacgtcag
-aataaaccggcacaatgagacggcggtctttcactacaccacacccttaggattataagt
-gacgtgtggattcgaattctaaggtgacgggatctacaagcctcagctacattaggtctg
-aagatctttcgtatagccgcgtatgttactgtttggatatgggttatgctaatcaacagt
-tgacagcgagtgaaacggccttgcgacctgaaatctttacggttaccttttgattcaaga
-caggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcag
-cgaccgagtaacgacaagttcacatcctctatgcaactatcattgtggtcattaaggtat
-tcaagattaactaagagtcgaccatatattctagagttttacaattaggaaccgttagtc
-tagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgac
-acatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgg
-gataaataacatggtgtttaaccctattaatggtttctattaatctaaattgtaaggcag
-cccttgggtcgaaagcacattaggccacatacacagtatgaaattgttcgagtgtccaga
-ccataattgactaccatggtacacggtgttgctattatgactcccgcaaaactcttgaca
-gagggaattttggtacattgatgtaatcgatgatttaacagtaggaactagacgtcatcc
-gttagactgagttccgacatgctcaaattgtcaggatttttatccaataactaatggctc
-tcacatgtaaataaaatcacattaacgtcacttagtgatggattcgctaaacagatagac
-tatcattcatgaactggcactgtttcgattatatttgcaacatcgaacatacttaaagtt
-aaatacgacatcattcaattaaaaaaattcagtacacctctaatgagtatcccgctttgg
-aggaaagagtagcactttaaatggacaatttaggccggactttcctgtaaatggatgaag
-tcattgtacagcttgaataaatcgttagggttagtccttacatccaccatatgttaatga
-ataaagcctgagggaccttagagctaacttgtccaacacgttgctcatttacttaataag
-gttgaaatgtatcagtaagtgacagcgagtgtagattttgaccatttaactgaccttcac
-agttttgtcttcagacgtcacttacaccataatgatgacagagcttgtagatgcacacac
-tcattcctagtgtaaatcaagtagtagctagattattataaagagatattttctggcgtc
-gaacgtaacacagagagagtataaggggcatgataatggcttatcaatatgtgtaagaaa
-aagtttttaatatcatctaactcggtggaatgcacacttatggccaactgaccttgggac
-gagttaagataccataagaggttgcctgtaagttaagataacaaagggatattccatctt
-tgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgctatgcagccacc
-agagttatttatacaaagaaagagaccatttagatacgttaattctgcttgcgatttatt
-aaacagacatttcacgtccaaccactacaaaagccctatcgcaagacgatcattgtatta
-tagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaattgttacattgtt
-tactacatatgatcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaac
-taacctgagatatatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagta
-atacaaggtaggaaaacttctggatttcccaaggttataatgctctatactgaccaagag
-atccgttacgactcgcaatgaatactctaagggcactcacaaagaaaaccactaattgat
-aaatttcaatgataatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaa
-tgaattagtcatagaaatgtcatagcaggaacataattactatattttaacgatttaatc
-gtagttggagtcctttcccaaattatgtcatcagttccgatttagatgttttcgggccct
-tcttagtaaagaagttaatatccaagactagctcctcacccacgcatgcacatattcgcg
-agaagtctgatagaatattcgacagaaatgcgactctagctcacactcgttaactgatca
-ggtacttatagacaagtacgttatcagatatcgcttcggggcattgttgcgctacctttg
-tgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgatattattttttta
-ggaggaataatacagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaac
-atatatggcacgtgttattcggctaacaaaactgttgtgccttttctataaggataagca
-gattcgttttaaacatatgacctgtaaactgggatctacaaaagaggtacttaaaataaa
-ttgcgcaacggtttagatctgcggatctttggttaaagagcaccattagatgtgccatac
-ttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggatttaaaacaattc
-ggttaggacacctactcggcggatgaagcaatacgataacattaaaagtcgttcagtcta
-attttggtcgtagtacgatgagctgatggccaattgtatttttattaacagcactgaaac
-aaaatggagactttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcgg
-aatgaggggatcttcggaagtatagcgccgaagtgtatctcattattataacaccagtgt
-acagacgacatctaattatggccagaaactgtcattgtgccattaagaggattagtagat
-agtctggaccgtggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcg
-atctaaactgcacgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgc
-gtttgtttttacgattctagtgcttcttaacgcaattcagtcttctagatccgctattcc
-aacatcaatatctcaatttaaggtcaatatatataacaaaattagacagagcagctgaca
-cttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagt
-ccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatg
-tgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctact
-attagtttattatgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgt
-taaggcaggaatctttgtaacagttcataatgttgctaaagattatcagaccccgtgaag
-acttcgggctttgggcttcgtaccgtagcataatacatctatatagttagaggcttgcgt
-gttgttgtgctattccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatg
-gtaacctggcgacctacttgttaagtcagtttaattcaaggggattaagtaccaagggtc
-gagtttctctgtatttattatactgtaggcaagaagcttttttggcgagatttaagactt
-aagcctatggtaaaaatttgatagtgagcgactatagtaagagatttgggtggttagtaa
-ttaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgt
-gaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattggcggggcacttat
-ccataatagatttctgtttgtacgccaaactctgcctcacccctccataaattgtattgg
-ctagaggttaaattctccgtaaatagagacacatatagttttatacaattgtttgaatca
-aagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggggcagagcatctc
-ttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagattatacaaagagat
-ctggatgaagatattcgtgcaatcactatcgttatgttagagagttccatgcatgaggac
-tcgttttttgaccaggagaattaagccaagaaataactgacgtatttccaaatgaattct
-acgtgtttttcctgtcacctttagccagtgttaaagatgactatggagtttcgaataggt
-tattctatagacattataacgagtggaacacccataccttcacagtgctaaaggtaggaa
-cgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaagaaataacgcat
-cacccgtcattctattgttttcgtcgggattacttagtaggcagggtattctaacctacc
-tgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcct
-aaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgactt
-cttcccctaacacagaattctcagttttatagctatctagtggcattcctttttataaaa
-ctttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgc
-cgtgtaagacttggaacccatgtatattgacggcatggcgtggctaagcaggtattgatc
-ttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccggggattagccgccaa
-aggggtctaatgacatagagatgctctgaaatcgtaccaactataaaagcacgggatttg
-aaatatagcgacagatcttccgtattctgttagttgacatctgtgctgtctttaccgatt
-gtgatttggctttagcagtcatttagtttcgttactcattgctcgtgcgatagttccacc
-gaatatggcacattcgttctttttttccattttactgcaaaccttttcaaaagctgatcg
-ataccactgatgatggcattgattagtcgattggcaactatgtcctgcttatatctccaa
-ttgcattgaatatagtaaaaaataaaggctcgccttcccaatgggctacggagtacacga
-aaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtgattgagacaaata
-gttctccagacgtattgagatatatgtctcctataggcaagcgtttctaattgctgacca
-gaaattagaattaggttgttaatactatattcgaccattttattccacgaatgtgctatt
-ctactggtattgctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagt
-ggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggta
-tctgccatattgttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaa
-atattaatgaggattgggtcgtataagaaaatcatcttttcagttcgcagatttttgcca
-atttaaccggttatttcgtcagacttggtagtgtagttacaagcatcacgattatatcag
-ctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattgcgctatatattc
-aaggtaacaggaggcatataggtcatagtacaaggataatgaggtttgctaactttaaaa
-attattgatttaacggttgattgaaaatctctgcaagatgacgctagaacacctgatgtt
-caagtttgccgataataacatataagatgaattactgtctttagaccctcatgttaatcc
-gctaacttagggcggaaacaatgttaggctatgcggagtaagtactatattatgatacca
-catagaatttaacattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccga
-ttaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaa
-ggttcagctattttggcaatgggtgagtaccgttcttagtgatttacgaacccataatct
-aggcgacttaatatacaagatttagagttacgttttccgggtagtacatattaacgacca
-tggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccag
-aatattatgtttctactagagtgttcgtatactggaatttaaatattatgtaagactaga
-caaattttatggatacattaggccatcgtagaatatgatatagttgtaacgtccctctat
-agattttcggagggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggat
-ttgtaattaactgatgcgcagcgcttaaataagtttagactattaagctatatgttcgac
-agcatgtagttttttttaccagaaagtgttatactgatgacccatggaggtagctcctca
-tgataaaaatattgttacttaagcattactattatagtgttcaaactagtaccgttgcat
-actttaagaatcagacatggcgtttcttatgcagacacacttttttagctgttgacgccc
-acctcacatccatagtaggtcaatcgcataagaacaatattctggactgttttattaccc
-agaagaaagttttttctttccggttcgttaagacaataaagatcatttcattcgttctct
-taacgatgaactaaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaa
-taattaaggcaagataagaagaacaggaacgcgcacgtcggagataactctaatagtctc
-tttattccgtttaatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgc
-aaacctatttatgtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttt
-tatcaagactttcgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaa
-aaccgcagggagtcgctctaagtgttaccaacccctcactactacgcgaaggtactcgat
-tattccttgaatgggctgaaacatcgtgattagcgtcttatgattcaggctgatagaaga
-aaacttattttctatattccacgtatacaatcacactcgtaactaaatagttcccagcgt
-tgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtgcataagtacagt
-tagtcgtctgtcacataaataatccgcagtcgatctcattacaggtattgttgttggtca
-accttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaa
-tatcataatagatgccatacacggttttacttgatatgtttacagtccttgagttgcaat
-cgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtca
-ctaggtaaaatgacttaggatggatgagcatttaggtattctatgataacactaaccatc
-atgtttctaaaatcctcaggaaatttgtattattttaccaacctgtatttatagaaagtg
-cttttgacttaaagaagccgaagtgttcaaattaaggagtacctgattgaaagaatgggg
-aattgtaatctgtaactcaattacaaataagccgttctaaggattaaggctttgtgtcta
-agcaactcacgtgaattcgaaattcatactcgattaacgactttaatactcttctgcgta
-tctacagactcatttaaattacggaatatgttttcgtttttggtttccagctcgcacgta
-cgcgtttacaaataaggacacctggtacaattggctggagtacaatgttggtttttattt
-gctgattatcccgatccctgtgggcgttggcataaccgggttttcttcaagactactttc
-gtgttgcttatatacctggtaatatcggtgagtagcttagggcttaatcacaatactaac
-aagttctctatggattggacagggcggcatccgttgactgaacgatctattaatccattc
-cctgcactggataaacaagacccatttaaattgaccatagagatgttagcgtcatatttc
-tgttcgtgatagggtacatatattataaacggattatgagcagtggttttctagaaaagc
-attcatagttaggagtgtatcagatcataccactgaaccatagagcacaattctctactg
-gctatacttcattcctttttgtccgggtggggacgaaatttaaaggttctaacctagaac
-gcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaa
-ttgcgtattttgactattgacagggcatcgtaaaccgctactcgacttggtatctgtaat
-ctgtatgtagatagagtacgggcctataattcaaattcagccaccgaagattcacaatct
-tcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagccccacccattctctg
-ttatatccgagcattaatgtagtttcactgtactacggtcacgccgtagagtcggcaggg
-caaatccaaaacaatttaggctgagaagtggcactataatagtttagcctaagtcccttc
-gctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggt
-atcttgaatactgatagctctcatggtaccaagaactttcataacctctttatttaccaa
-acctgttctactagcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccg
-gcgtaaccggcgcctgcaagctaacatgggatcaaaactattggcttaacgtttaatcga
-atgagactagcactgtattactctttcgtttcggcagcggatcaataaggaggtgacggc
-atcactctcttatagtagatatcacttattctcacaacggaagtaggatcttccgtcctc
-attaaatttgcaactggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggt
-cagagcagacgatgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacg
-ggctatgcggaaattccagacctcgagttacattatgaaacgtgtcattccatctcatta
-aatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtctattttcccaagg
-agaaggagagtagcagcttagtggcttgcctatatggccccctaagtacgtactcggcac
-gcttagaagattgggctaccccgcactatatgttcccaaagtaggtaacctagatagtgt
-cgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttggcaggggttata
-cattgcgggcatgaagagtaacattggacatgaacggacattcgaaccctgtgagtttaa
-taccctatctccggatcattataaagtaaatatacgtcacttactctacgtgcgtttaga
-cagtctttgaaactaaattggttatttttctttcatctagatttgtctgtatctaactaa
-attatagttccacataaagctgattcaactgaagacataaatataaactttctaacatag
-tagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagtagttcctggtaga
-gttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtga
-acatacataataccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcct
-acgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgctt
-cgagtatgtacattcagatctccttagtatcatcaaattatagattttacggccacgaat
-tattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagt
-tgaggttggaagaagagtcattatgctataccaagaactctccatccagtacctagaaag
-gcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttg
-taccagatggcttttataatagaaactaagtttcccgaataacggtgtacgataacagat
-ttttaggtgtacagacgtctgactcaatgaacacacattgggacctgccccgggaggagt
-agtagataattaccttctccagcgcgggtcttttaatatcacaacataaaaatactaatt
-aatatcacacaccctcatcctcgatggagcctagcatcatacacgtttgatagacaacgc
-caattttactgtaatatgatattcgaatctagtatgtggacgctgtaccacattgtttaa
-aggagctccctttaccgacatgaacgaagcaagctttgtacaagatacgaagaactcagt
-actggtaactataagagacaatttatacataaaagtgttaagaccattatataaaaagag
-gtatgaggtctttgtaactacaataatacattcatcgaacgatggagaataacagagtta
-tttctgctgctcgagctctagttctgctaatttctcaatcttgatgccactcgtttgagt
-cttccattcgctcttaacgacgcgtacatccctctctcctactcttacctatatcctatt
-actggttaacctacatctccgggaaagacgtaggtaaagtggtccacgattgtattcact
-tataacacctagtagtactatgtgttgctgagagtgaggacacacttactctacgagttc
-aagtccatatggacattacactttttcagcatctaggtgtcatgatgtattaacagccgt
-taggggctatttgattttatcgattgtcggcgtgtgtattttcaacaactaggtgctaca
-attcgtgaataggcatgaaaattcaagattgcagttcctatcttgtataatctttccttt
-ggacgagttgtaccatttcaactaacctgcaagtggggggtcatccatatgaagatttgc
-caaatacctggagaccctgaaaagtttatccagattaataataacaaacaaacctaagcg
-aagaacgtcagctttaataaactatcactatcatagaaattcctgttaattgttcttcca
-aacgttgaatagactatcacgggtaatagattgaacacggagaacgtttatccggcttgt
-aaaatatcgtcgaatctgctgataactcaattatattcgatggagaattcatatctaccg
-cttagcttttaaaaattaagtcagattattccgccacaatgagaaggcgcgagtgcacta
-atcaaatcacttaggattattacggacgtctgcattacaatgctttggggtagggttata
-caagcatatgattctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggc
-atatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatct
-ttaagctgacctgttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaa
-actctaacatagcgtggcactatgagtacgtgtaacgacaaggtctcatactcgatccta
-agataattctcgtctggaaggttttaatctttaactaagagtagaacttagtttattgac
-ttttacaattaggatacggttcgcgactctaccacagggcatcatacctggagctctgct
-atctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatctactgagcaatccc
-tttaagcattcctagtttgagagccatttagatattgctgtttaaaccgattaatggttt
-ctattattataaagtgtaacgctcccattcgggacattgaaaattagcaataagacaatg
-tatgatattcggcgagtctcaacaacattatggtctaccatgggacaaggggttgatatg
-atgaatccacaaaaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgtt
-ataaggacgatctagaagtattcaggtacacggtgttcagacatgctctaattgtcaggt
-tgtttataatttaacgtatcgctctctattctaaataatataaaattaaccgctcgtagg
-gatgctttccagtaaaagatacactatcattaaggttatgcaaatgtggcgatttgattt
-gaatcttagtacattcttaaacttaaatacgtattatttaaagtaaatatattatctaaa
-ccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgac
-cctctttcatctaaagcgatcatctatttcttctgattgatgtaatactgacccttactc
-cgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaat
-caactggcgctggtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcat
-tttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgat
-gactctcattgtagatccaatcacgctttcctacgctaatgaaagttctagatagtgtag
-gtgttagacagaggttagcgcctacatccttacacacacagtgttgaacggcaagcataa
-tcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcccgcctttgaaca
-atgatgccaaaatgtcctgccctagagttatgataaaataactgctgccctgtaacttaa
-gtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaa
-aatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagagtacatttagtta
-ccggattgcggcttgacatttattttacagaattttatcggcaaaacacttcatatgaac
-tatcgcttcacgataagtctatgatagactagcattcgtagagaacaggaagagcaatca
-ttatatatgaagtgttacagtgggtactacatatgagatcattaggtctatatccggcct
-tcctcataagaccttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacc
-cagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggttttaactagggg
-ttattgatatttaagctaaaagagttccctgaacactcgaaatgtataatctatcccaac
-taaaaaagtatacctctaattcagaaatgtcattgagattagactgatgtcaatacgcta
-ggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaatacctccatcttaa
-gttctatattttaaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtg
-cccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaatctctagctact
-atcccacgaatgcactgatgccagtcatggcgcttacattagtcgacagaaatccgacga
-tacctatcacgcgtgaactgttctggttcttattcaattcgaagtgatctcagatacatt
-acggccatgcttgcccttcatgtctgctgagcagttttgttataggctgaatctcctcta
-agcgaaattgataggatttttggtggtcgatttagtctgtacctgcttattaagattcaa
-aatgacctacttcttacgccgaaatgatagggatcggctgaggaggataaatatacgctg
-gtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactctaatctccgaga
-taaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtat
-agtccaccattagttctgacttacttaatatagactgaccgagattgtagtatgtggatc
-caagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaaga
-gttaattaatagtactgcactataattgtcggcggagtaccatgagctgttgcccaattc
-gatgtttattaacagcacgcataaaaaatccagacttttcaattagaattaactataaat
-ggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtatagaccccaactct
-atctaatttttataacacctctgtaatcaacaaatcttattatgccatcattatgtcatt
-cgccaagtaagtccagttcgagattctctggaccgtgcaatagtattgtcaaattatggt
-aatggaatccttcttctaacacccttagaaaagccacgagaattgacaagttgggcgtgc
-ttgtccaggagcaacataagtgccgtttctttttacgatgatagggattcttaaagcttt
-tctctattctagatcccagttgccatcatcaatatctcaattgatgctcattatatagtt
-cttatttagtatgtccagatgtcactgaagatcctgcctagaaccgatattctcgacagg
-atcatcagttcgacggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaag
-gaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagt
-tttactgcctttaattagtagtcgattagtgtagtttgatattatctaccttatagaatg
-taaacagtaacccggccttaatggtttggcaggattctttgtaaaagttaataatgttca
-taaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaa
-ttcgttttacggagtggcttgcgtcttgttgtccgagtacacatattgctcctctccccc
-actcttctaggaaaatcaattatgctaacctgcagaccttcttctttactatctttaatg
-catgcccagtatgttcatagggtagacttgctatctattttgtataatctacgaatgatg
-cttggggcgcgacttttaacaattaagccgttgggtataatttgagagggtgccacgata
-gtaagagatttccggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagct
-caccctcctcagttctccaaccctgaaccggctaagtatgactgtgcagtattaattttg
-aatacatattgcagcccctaggatacattatagatgtctctttcttacccaaactcgccc
-gcaccaagaaagaatgtggattcgattgaggttaaattagccggaattacagacacagat
-tcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatg
-gattacgttggggatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaag
-aattcacagaggattaatacacttctccatgaagataggactgcttgcactatccttatc
-tttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataa
-cggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatc
-atgactttggactttagatttgggtattctagagactgtagaaagactgcaacaacaaga
-cattcacagggcgaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttag
-gaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcggccccttgaatta
-cgtgcatgcctttgctaaaagacctctgggaaatagattgaatattctggacagcagcga
-atcctgattatatctcaagcgaatatatgacccgcaagaaggatttatactagaataagt
-ctaagaaagggcattgggtcacttcttccactaacacacttttatcagttttataccttg
-agagtcccatgcatttttatatatatttaactttcgttgcgtaaaactttaaatatgatc
-cgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaat
-cgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttctatgctaaaaat
-gtatagccccgcattagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgta
-acaaagataaaacaacgcgatttctatgtttgccaaagtgattaagttgtatcgtagggg
-tcagcgctgatgtcttttcagtttgggttttggatttaccagtcttttagtttcggtact
-atttgatcgggacattcgtccaaacatgatggctcattcgttctttttttcaattttaat
-caaaaccttgtatttacctgatacattaaactgagcatcgcatggaggtggagattccca
-tatatgtaatcatttgatatcctattccattctttttagttataaataaacgctccactg
-cacaatgggagtaggacttcaccaataattagcatctactgtaaacaagcgccgtaacga
-aatgattactgattgagaaaaataggtctcaacaacttttgacagatatgtatccgatac
-ccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaa
-tggttattactccaatgggctattctaatccgatggatacgtaggagagagtgtacctac
-accgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtg
-cgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaaagaagtcccctg
-aatagcccttagataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattc
-ggttaagttcgcagagttttgccaagtttacaggtgatttactaacacttgggagggtac
-gtacaaccatcacctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagt
-gtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtcataggacatcga
-gtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtgataatagctgcaa
-catgaagatagtaaaactgaggttaaactttcaccatattaaattatatgttcaattacg
-cgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgggtccctatcccg
-actttgtacgagattttgataaaaaatagtattgtaaattcatttgatggcgtagaaccg
-ggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcc
-tggctcaatatttataatagtaatggttaagattgtggcccaatcgctgagtacccgtct
-tacgctttttccaacacataatcgacgagaatgtatttaaatgtttgagacttacgtttt
-ccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgtagttttctcatct
-gctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggct
-atttaatttttatggtacacttgaatatgtttagccataatgtagccaatactacaatat
-cagatacttgtatacgacctatagacttttgccgaccgctcgtagagtgatttagaaaga
-tgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgt
-tgactattttgctatatgttactctgaatgttgttttttttaccagaatgtgttataatg
-atcaaccatgcacgttcctactaatcatataaattttgttacgtaagcttttctatgata
-gtggtctaaagactacccttgcatactttaagattaagacatgcactttaggaggaactc
-acacgttttgagctgttctagcccacctataagccattcgtccgcaatcccataactaca
-atagtcggcaatcttttattacccagaactaacgtttttatttcccggtacgtatcacat
-taatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgct
-tcttgagaatacagattactgttagaatgaaggcatcataactagaacaccaacgcgcac
-ctcgcacattactctaatagtagctttattcagtttaatatagacagtatttgaaccagg
-cgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatt
-tgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataac
-cagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacat
-cacttcgtaccgaagggactactgtattccgtcttggggatgtaacagactgattacagt
-cttatgatgaagcctcattcatctaaaattagttgatttattccacggatactatcacac
-tcctatagaaagagttaccaccgtgggaagctagatataataaataaaagacatacaata
-ttagtatggctcatgatctacacttactcggatctctctttttttataaccagtagatcg
-cattacacgtattgttgttccgcatcaggccctaggggctcaaacttccatggtggataa
-ctaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgggtttacttgatt
-tctgttcagtcattcacgggaaatcctaggagtctttcataacggcggtcttagtaggaa
-tgtagtcaagctctgtagaggtctcgacggaattggtatttcctggcatcacaatttacc
-tagtattggagatcacttaaaataatgttgagataataatcaggatatttctagtatgtg
-acaaacctctatttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaac
-gactacatgttggaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtg
-ctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgtaatactactgta
-accaagttattactcggctgcgtagataaagtctcatgtaaatgacggtttatctgttac
-ttttgggtttcaacctagctaggacgccggtactaattacgacacctgcgtatagtgcag
-ggtgttcaatgtgcctttttatgtccggattataaccatccctctcccacttggaatatc
-accgggttcttaatgacttagttcgtcttccttattttccgggtaagatcgctgtggacc
-ggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttc
-actgaaacttagattaatcaatgcactgcactggattaacaagaacatgttatagtgtac
-tgacacatgttagactaagaggtctgttcgggttagccgacttatatgtttaaccgattt
-tgacaactgggttgagagataacaatgaagagtgaggactgtagaagatcttaaaactgt
-accatagtgctcaattcgctaatggcttgaattatttaattgttctaaccctggcgtcga
-atttttttggttcgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtac
-cgttagaaagcggcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaa
-gctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaat
-tctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtg
-gtctataccaccaaaaagtatatgggatatcccagaatttatcgactttcaatcgtctac
-cgtcacgacgtacactaggcagccctaatccaaaacttttgaggatgagtactgccacta
-ttatactgtaccatttgtaacttacattttatatcttcaaagaggtagatattgtcggcc
-attactgtcacttacactaagggtagcttgattactgatacctctcatggtaaaaagtaa
-tttaagaacctatttttttacataacctctgctactaccgttagtgttttagtcggttca
-agtcacaaaatccctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaa
-acttttgccggaaccgttaatcctatgagaataccactcttggaatcggtcctttaggct
-gaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaa
-acgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatcttacactctttt
-cttaactaagtatgagagcaacctcactcctgaacagcttgttacctaacgagaagaggc
-tttaagtagcctggagcctcaaccggatatccggatttgactctcatccacttacatgat
-gattacggtcattacatctcatgattttctgagtgccctatagactgggaatttaatcta
-ccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatg
-ccaccataagtaagttctcggaacccttacatgattggcctaccaacctatatatgtgac
-caatgtacggtacatagagtgtggcctatcatattcaggtcatcgagctcagtatttaaa
-gattatatggtcgctgggggtattcagtgcgcgatggaagactaacattggaaatcaacg
-gaattgacaacacgctcactttaataacctatctcaggataagtttaatgtaattagacg
-gaactttctctaactccgtgtactaactctttgaaaataatgtgggtatttttatttcat
-ctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtc
-ataaatataaaatttagatcttaggacagaggaaagtgctttcccgagcataggatctgg
-cctacgccagtagttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagg
-gtagtgttcgatactcagcggggaactgacatattacactaaggaatcaaggcccttcgt
-atgggtcatgtttatatatttaattacttacgctatttgatcgagaatagctatagtaac
-gtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatactgtgtatcatatt
-attatagatgttaaggcatagaattattggtattgatgtacaaaaaattatgggtgggca
-gtaccgataggcattacgagcagtgcagcttggaagaactggatgtatcctataactagt
-aagagccttaaaggtactacatacccagggatgttaccatcattaatttggccatcttca
-atcttcgcaatgcatactttcttctacaagatgccttttagaagacaaaataagtgtcaa
-caataacgctgtaacttaactctgttgtacgtggaatcaagtctcactaaagcaactaac
-attccgacatgcaaacgcaggactactagattattaaattcgccagcccgcctcgtttaa
-tataacatcataaaaattctaagtaatatctcacacactaatccgccatcgtccatagca
-tcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgccaagctagtttc
-gcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaaccatcctacctt
-tgtacaacagaccaacatctctgtactggtaaatagatctgaaaagttataaatataact
-gttttcacattgatagaaaaacagctatgtgctatttgtatatactataataaattaagc
-gaaacatggagattaaaacagtgttttctcatcctccacctcttgttctgctaatttata
-attcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaacccgacataaataga
-tacgacgctgaacgagatcctatttctcctgaaaattattagcacggtaactcctaggga
-tagtggtactagttggtatgaacgtataaaaacttgtactactttctcgggatgtgaggg
-agcaaactattactcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatac
-ctgtctggatggattatatgcaggtaggcgagagtggattgtagcgatgctcggcggggg
-tattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactg
-catatcgtcgattagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtcc
-gggcgcatccatatcaagttttgcaatagtactccagaccatgaaatggttatccagatt
-aataataacttaatatactttcactacatactcagcgggtattaaatttcactttatgtc
-aaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaa
-accgagtaacttgatcagccttgtaaaatatagtagaatatgatgttaaatcatttatat
-tccagggagattgaatagcttacgattagctggtataatttaactcacatgattaagcaa
-atatctgtaggaccgagggaaagaataaaataaagtaccatgagttcggaacgctgcatt
-acatggcgttgggctagcctgatacaagaagatgagtatggagctctcttcatcgggacg
-tgacaaccctagcgtaatcttggcagatcccggagcagatgattatcgtctaacactgtc
-tttaccaatgcacaacgcatagatttaacctgaactgttctggattcactcctgactaca
-gcctacaactcatttctatgcataactcttaaagacagtcgcaatatcagtacctctata
-cacatcggatcagactagatcataagataagtctcctctggatccttgtattctgttaag
-tacactacaaatttgtttagtgtctgggacaattacgataagggtcgcgactagaccaca
-gggcatatgacctccaccgctcctagcgagtctccaatctgcaagcactcatacgctagg
-ggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacccatttagatatg
-cctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatcaaattcccgaca
-ttcatattgtccaataagtatatctagcttattcggactcgctaaactaaattatggtat
-aaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggc
-cttatggcagcgtatacagctggtataacgaccatatacaactatgaacggactagctgt
-gaactaagcagattattggatccttgtgtataattttaagtttcgatctatatgctatag
-tatagaaaatgttccgatcgtacgcttcctttacagttaaacagtctatatcatgaagct
-tatccaaagctggacatttgatggcaatcttacttaattatgaaacttaattacctatta
-ttgaaagtatttatatgatcgaataagatttgctctataaacaggtcgtccattcacgac
-ctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatctatttcttatca
-ttcatgttatactgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcac
-gctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgat
-atcgatgtctatcccacgcgtcattttcaaattggttatctacggataactgtgcgatga
-actactataggtcaaaattatcttcaatctcattctagatcatataaagatgtccttcgc
-gattgatacgtctacagtgtgttggtgttacacagagggtagcgactacttacttactaa
-ctctctcttgatccgcaagcataagccaggttaaagtgctctatctttttctgtggatta
-taatagttataccgccttgcatctaggtgcccattaggtaatgccctagtgttttcataa
-atttactcctgccatctaacgttactttaatttcccagattcaataggtctctcatttga
-aaattgttatatgtcaacaaagaatataatagctgagtggaacaatacactgtgagggag
-taatacatactctaaattttctttacggtttgcgcctgcacagttttttttatctatgtg
-atccgcataaaaagtaatttcaacgttccattcaagttaagtcttggtgacactagcatt
-aggagagatcaccaagaccattatttatttagctagggtttaagtcggttagaaatatca
-gataatgaggtctttatccggccttacgcagtagaaattggaaatttcgtaaagcactga
-gttcaatggaagtatggccgaacccacataatgcacaaatcaagtcgatttcttccgtcc
-ttttagtctcctgggaactacgggttattcatagttaagctaaatcagttaacggaacta
-gacaaatgtataatagttcccaaatatatatctataaatcttatgcagttagggaatgca
-gatttgaatcatggcaatacgctagctcggaactcaactacaagtgttggatgtacgaat
-tcaaaggtattacatccttatgatgttcttttttggatacttttatgacgacttccacga
-agtgaaattatgttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgt
-tctgtttataattctcgtcataatataaatacaagcatatgaggccagtcatggagcttt
-catttggactaacatttccgtagagtcatatcacgcctgtaatctgatccgtctttttct
-attcgaagtgttatcagatacatgacgcccttgcgtgacattcatggctcctgacatcgg
-gtcttttaggctgaatctaatctaacccaatttgtttggattgtgggtcctccattttgt
-ctgttaatgcttattaagattaaaaatgtactacgtatttagacctaatgattgcgatac
-gctgtggaccattaatataagctgcgccaggggatttttccagatcatctggcctgtgta
-tatgttcaaatctaatagccgagagaaattactccgacggaaaataaaggcagataagcg
-tttcagagcaccatcgtggcgtttagtcaacctttagttcggaatttattaatatacaat
-ctcactctttggacgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaa
-gtataccagcatcatcaaagaacagttaaggaatacgactgctctataattgtccgagga
-gtaccttctcatctgccaatagtcgttgggttggaaaacaacgcattaatatgccacact
-tgtcaattagaagtttctataaaggggacgagtaactgatttgagacctagcacggcaga
-ggacgttcgtgtgacaacatctctttataagtttgagataaaatcgctaatctacaatga
-ttatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaagg
-ccattactatggtcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaa
-acactattgaatactgccgccgcattcgccagcaccaacataactgcacgtgcttttttc
-catgattggcattatgaaagatttgatctatgattcttaccagttgcaatattcaattta
-gcatgtgttcctaattattgtgttattatggtctatctcatcatgtaaatgaagatcatg
-acgtcaacacagattctagtcaggatcatcagttcctcggggaaatcgcacctaggaaca
-gccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaag
-cctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcgagtactgttggt
-tcatatttgctacatgattgtatgtaataacgatcccgccctttatcggttcgatccttt
-atggcgataagttatgaatcgtcagtatctttagatcaaaaactcaactagtacccagtt
-ccccggaggaacggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcaga
-ggaatcagtttcatccgatcccactcgatgattggtatagctatttgccgaaaagccaca
-acgtattcggtactatcttgtttgattcccctgtatcttaattcgcgacacttgatatct
-tttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaattatccagttgcgt
-ttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataa
-ttggagtttgcaggacgaatagctcacccgcctaagtgatccaaccctcatcaggataac
-tatcactgggcagtattatttttgatttcatatgccaccccctaggagactgtagtcatg
-tatctttcttacccaatctagcccgaaacaagaaagaatgtcgattccagtcacctttta
-ttagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaa
-agttgaaaacgacttgctctattcgattaccttcgcgatctcaatcgattacgctaaatt
-ttaatgcccgctgaaatatccaacatttaaaacaggattaattctctgatccatgaactt
-aggactcattgcacgtgacttatctttctctcttaattcatgctccaatacggtgggcta
-aaccacttttatcacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggca
-gcgaaacgggtcaatctgggtatcttctattgggacggtacatttcggttttatagacta
-tgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcac
-cttgggattgccatgtgtccggaggattacatacatctaagaaacattctaaactatgta
-tagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtactctgggtattag
-agtgtatattatcgacagcaccgaatcctcattttatagcttgacaatttatgacccgaa
-agaaccttttataagtctataagtatatctaacgcaattgcggcactgagtccactaact
-atctttgagcagtgttatacagtgagacgccatggaaggggtttatatattttactgtcg
-ttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagt
-cgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttac
-attccttgcttatttgcgataaatcgatacaaccccattaccagaaaaacccggagaatc
-aattactctgcagatcttatactaaaaaagagattacaacccctgttctatgtgtcccaa
-agtgagtaacgtggagcgttggggtaagagcggagcgattttaactttcgcttttccatt
-ttccagtattgtactttacgttatatttgagcggcacattcgtcaaaacatgatccatat
-ggactgaggtgtttaaatgttaatcaaataattgtattttcagctgactttaaaatctgc
-agccattggaggtggagattccaatagatgtaagcaggtgatatcatatgcaattcttgt
-gacttattaagataccagacacggcacaatcgcagtagcacgtaaacaataatgacaatc
-gacggttaaattccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaac
-gtttctctgagatgtataagttaccaaacactggagaattccgctaaactaaggacaatt
-tccgtcgtattaattgttgacaaatggttagtaatacattcgcagtggataatccgttgc
-atacctagcactgagtgtaaataaaaccaatcgactactggcatttcgggctaacgacta
-gatgttagcctatgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttc
-ttattcgttattagaagtcacctgtagagacagtagagatgacctaaatttggtttgtcc
-agtcccgaggtgatctaatgattaggttaacttagaacagtggtcaattggttaaagctg
-atttacgaacacttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtat
-tcggtcatctagacaaccccatcgctgggagtttggacagtgttatgattcgtaaatcca
-ccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaatttaggcttttt
-tacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgtaaacggtcacca
-gttgatatttgttctgctaggaagcgatgtacaaaataagcttaataagatttaggtccg
-accttaatttcggtccatagcacctctttctaagtgttttgcttaaataattgtattgtt
-attgattttctgcgagttgaacacggaaaataagtcaaaaaggacacttttaggttcata
-tgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgt
-ggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttagtccactaggtat
-ttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaatggcagaggggct
-cctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatcttttggttcttt
-ataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagcc
-agaatggaccaattacgtcattagctgttacgtctatacgaaatatagactgtggacgac
-ccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaag
-caggacaacacagtattgtactggtcaattggttcatagatctgactatgaatcttcgtt
-tttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttt
-tcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggccttaatgtaacatta
-actattccactgtaggtggatctaacaaggttggacatgtgctaccaataagataagaat
-ttcgtccgcaatacaatatctacttttgtagcctatcttggattaacaacaacttacgtt
-ggtatttcaccggacgtatcaaatgattctgattttaatgactgagagtaaacatcaacg
-aatcttatgtatctttaagccgctgcttgacaagtcacattactgttagaatgaacgctt
-cattactacaaaacctaccaccaactcccacattaatattatactagatgtttgaagttt
-atttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttag
-ggtattaattgtggtcggtgcatttccggccccatagcgctccgcggggagaaactatgg
-ccttcatgacagcccccccataacatctaggtaatggtcggataactataaacaaccctc
-tccagagaactgtgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttg
-cccatcttaaagactcttttcactattttcttgatgcctcattcttctaatattaggtga
-ttttttaatccgagaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacat
-attttaaagaaatgaaatactttttgactatccctcatgatctaaacttacgcggagcta
-tctttttgtataacatgtacagagaattaatccgatgcttcttccgattaaggacatagc
-gccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaagtgattaagtga
-tcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaatacttggagtctt
-gaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgc
-tatttcctgccttctcaattgtccgaggattgctgataacttaaaataaggttgagtttt
-taataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagtta
-tcaagaactacgggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatc
-gtacgaatggtatttgtacaactgctttcctttatcgattgctcgagaacattataaagt
-ctattactatggattaagactgtatacaagtgtttaagcggagcccgtgataatctataa
-ggttttggtacctttatctgttacttttgccttgaaacatacatacgtacacgggaatat
-ttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaa
-ctgaaagcgcccacttgcattataacccggtgcggaatctcttagtgactcgtcaggagt
-ttacgcctttgagacctctcgacaggacccattttgatctagtcgttataggtagagtgc
-ctttcctatcgcaccattaccttctagcaaacttagagtattcaatgaaatcatatcctg
-tttatactaaatgttataggctaatgacacagctgacactaagaggtctcttcgggttac
-ccgaatgagttgtttatacgatgttgacaactcgggggagtcatttcaatgaagactgag
-gactcttgatcagattaaaacgcttaatgactgataatttagattatgccgtgtattatt
-taagtgggcgaaccctcccctagaatgggtttcctgagaaaagtcttagaacacagtatt
-ctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtc
-aatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaagagctatgttctg
-acacgtccccaatattaggcaaaggctccaaaagaacagtcaattgattaactacgggct
-tggtttctccgtgaatccttgcgccgctataccacataaaaggatagcggtgataccaca
-agtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaa
-ttttgtccatcactactgccaagagttgactggaccagttggaaatgacatttgatatat
-taatagagctacatattgtaccactttactgtcacttacactaaccctagcgtgattact
-catacatatattcgtaaattctaagttatgatactagttttgtaaatttaatcggcgaag
-acacgttctcttgtacgagcttcaactaaatatttcactgtagccaaccactttaaccag
-aaggataccttaatgccgatataatattgtccaggaaacgttaatactttcacaagacaa
-agcttggaagaggtactttacgatcacctgatagatcgaccggaacgattctatataggt
-ttggtctgagaaatttgtagctaaaaccatgttccataggaactcctctgtaatgggcaa
-aatgcagatagcgttcaatcgttgcttaactatctatcacagcatcctaactcctcaaca
-gcttctttcctaaagacatcagcaggtaagttgacggcacccgataacccagagcacgat
-tggaatctaatactctgtatggatcattacgctaagtaaatataatgattttctgactca
-aagttacactgcgaattttatattaactggttctatttgttaaataccacaacctctcgt
-caacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaaccattacttctgg
-cgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcgccgatcttagga
-acctaatactgctcagtagttattgtttatttgggccatccccggattatgtcagccatg
-gaacactaaaagtcctaatctaacctatggacaaaaagctcacttttataaaattgctca
-ccttatgttgattgttatttgtccgaaatgtctataactcagtgtactatctattggaaa
-attatggccggagttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaat
-aattatcagctggaaaatcatctaatatatattatattgagatattacgacagacctaag
-tgctttcccgtcatgagcagatggactaacactcttggtaatccttctcgttttagttgg
-taatgtttagtctaagtaatatcccgactcttacttactcagagcggaaatgacttttta
-aactaacgtttaaaggcacttagtatgcgtcagggttatttttttaattacgtacccttg
-tgcagagagtttagctattcgatcctacttagtatgaaccatgagagtacaggttggtaa
-ttcacagagaaggtcgagaagattatttttgatgtttaccaatactatgaggcgtattca
-tcgaaataattttatggctgcgcacttcacatacgcaggaagaccactgcagcttgctag
-atctggatgtatcattgtacttctaagagcctgaaaggtaatacattcccagcgagcgta
-acagattgtatggggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcat
-ttttgatgtcataagttctgtcaactataaccctggaactttaatctgttgttcgtcgaa
-tcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccactacttcagtttta
-aattagaatcacaccctagggtattagataataattaaatgtcttaggaagagatatcaa
-aagatgcagacatcctcaagtgaataagtctccggtctttcacaaacacatggttaagcg
-atgtggttttgactagagacgttcgccaccatcgtaatatttctggttacctgcgaacgt
-gaaccaaatcttacttcatacattgcttaaacagtacaacttatctcttatcctatagag
-atctcaaaagtttgtatttttactggtttcaaattgagagaaaaactgcgttctccgatt
-tctatattattgtttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccga
-ctcagattcgtatcctatgttagaatgagtcatcaaactacggtcacgcgtacattacag
-agtaaactacacgaatgaaagagataagaagatgaaagagttaataggtctcctgttaat
-tatgagaaccctaactactacggattggcctactagtgggttggaacggatataaaattc
-gactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatcc
-acagtaatagttggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtg
-cagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgag
-caaggaattggattctgtgaacggaatatagtcgagtagatggaatttcctacactgcga
-aaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggcaattagtactcca
-ctaaatcaattggttataaacttttagaatatctttatataagttcactacttacgctgc
-gggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaataaacggcttgac
-tatagataccctaattctggcataaccctgtaacgtgtgaagcatgctttaatagacgac
-tagatcagcttatagaatggatatgactgccacattgaagagattaacattagcgggtat
-aatgttacgaacttgtttaacaaaatagctctaccacacacgcatagtataatataaagg
-tcctggagttcgctacgagcctggaattgcagttcccctaccctgagtaaacaagatcag
-tatggacctatcttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtga
-agttgattatcggctaacactcgctttaccaaggaacaaacaattgatggaacaggtaag
-cggctggattctatcctgaatacagcataataatatttgctttcaatatatagttatgac
-actcccaatatcactaactctttacaaatcggatatgaagagtgaattagagatggagcc
-gatcgttccttgtattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtc
-cttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcatagagactctaaa
-ttcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaactgtaacatttac
-gtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtt
-tcgcgatacataaaaggccccactttcatatggtcaaatatctatatcgtgctttggacg
-actcgataaactaaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaa
-tttagagtatatataacttccggacgtatggctgccttgaatcctcggatatcgtcctta
-tacaacgatgaacggtatagctcggaactatgcagattaggcgatccttgggttgaattt
-ttagtttccatagatatgagttagttttgatatggttaccatacgtccctgcattgaaac
-ttaatctgtatattgattgatccttagcaatagcggcacatttctgggcaatatgactta
-attaggttacggtttttactatgatggatacgttttatatgatagaataacagttgctat
-ttaaacaggtactacattcaactaatactgtttcactattgtgtccaacatagggaatat
-attgcctgaatagatgtattatcaggcatcttttacgctccaggtagaactaattaaaaa
-tgatccttagaaactttcaagcaacataagctaaaagttacgccaattataagccacatc
-ggtaggatcttcaggcattcccatatccttctctatcaatcccgtctgttgctaattggt
-tatctaagcatatcgcggcgagcatctacgataggtataaagttgctgctatctaattcg
-tcataatatatacatggaattacagattcatacgtcttcagtctcgtggtgtttctaaga
-gcggacccaagaattacgtaatatctctctcgtgttacccaagaagttgacacgtgattg
-tcagctatctttttctggcgatgttaatagttataaacaattgcatatagctgcaaatta
-gctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcac
-tgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgca
-gtgcaaaaataatatctcagggtgtaattatttctctaattggtctttacggttggacca
-ggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaagtgacattaaac
-ttaagtattgctgtcaagaccattacgacacttcaccaacacatttatgtattgtgctac
-gcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaa
-atgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaac
-atatcatgtcgttgtattacgtccttttactagcctgggaaataccggtgattcagagtg
-aacataaatctctgaaagctactagacaaagctagtatagttaaaatatatatttctttt
-aatattaggatctttgcgattgcacatttcaagcatcgcattaacctacctccgtactct
-tctacaacggttgcatgtacgatttctatgcgatgaaatacttatgttcttagtttgggg
-ttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgc
-gggcaccaaaacgatctcgattcttaggtttataattatagtcagaagataaatacatgc
-atatctggacactcttccacatgtcatgtcgactaactttgaactacagtcatatataga
-ctgttatctgatccgtatgtgtctattactactcttatctgagaaaggacccaatggagt
-cacagtaagcgatcatgtcatcggggctttttccctgattataagattacactattgctg
-tgcttggggcctcctactttttctatcttaatcattttgtacattaaaaagctaagaagt
-aggtacaacttatctttcccatacgagctggaccattaatttaacagccgcaaggcgagt
-tttaatgttaatctggaagggctttatgttctaagcttttagcactgagaaattaatccg
-taggaaattaatcccacataacccggtaagagaaccttacgccccgttactaataatgtt
-ctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctccttaatacaggccctg
-cgttatattcgaccgtacctataactagaccaccatcttaaatgtacagttatggttttc
-gacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgtactgggggtggtt
-atcaaacatttaatatgaatctatggtaaagtactagtttatagatagccgaacactaaa
-ggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggt
-gataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattgcccaatcgttct
-actcgtactctttatagcctaacgccttttcttggcgctaattagcctaatccaagaagg
-agtctaacaaaattacttaaccatactcttgtctattcggcccacgcatgcgcaagctca
-aaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattggatctatgagtc
-ttaacagtggaaatatgatttttagattgtgttcagatttattgtcttattttggtctat
-ctcatcagctatagctacataatgacgtcttaactgtttcgactaaccttcagatctgac
-taccccaaatacaacatagcaaaagaatgatgctaacgcttaactatcctttcacgatct
-taacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcgtggaatcaattt
-ttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttca
-agcactttagcggttccatccttgatggcgttaactgatgatgcgtaagtttatggtgat
-ctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttagg
-tctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcct
-atagctttttgcagttaagccactaagtaggcggttctatagggtttcattcaaatcgat
-cgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttcaggcccgccaca
-atggtttcaagtttcaacttccgtttattggctgtccctcaatagagtcgttctcagggc
-acgactctcgttcgttattcataagtccagtttgatccacgaatacagaacacgcatatc
-tgataataaaagcttaacgataactttcacgcgcatggtttatttttgatttattaggca
-accaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaag
-tatcgccattacagtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtatt
-ggcgcccttgatttaataataattacggctaaacgtattgatattttccaggaactgccc
-catctcatgagatgaccctaaattttattcacacctcatttttaattcttttatatcacg
-attatttatctgagcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaa
-tgcatgctaatatacggtgcgctaaacatattggttcaattcaatgtaagctacctcgga
-atttgcttgcactaagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaa
-gggacttgtccgttggagtcactatggagttacaagcattataaatctaaggaaatcgca
-gtatcagtccttaccccaaagatacttcgcattccctggggtacggaccatgaaatactt
-ctttcatacatgataaacgatggagactcggttaccaccctggtagttactccatcaatt
-ggagttaactaagatcgctattacaggctttattagccaatcatcacaagcctcttttta
-gagattcacaagttagcaaaccaaagttcctttgataagtctttaacgagatctatccca
-attccggctaggagtaaaatttatatatttgagatcggggttaaagtcacacgcaatgca
-aggggtttttatatggtaatgtccttccctaattaggtaattttcagacctccgagagag
-agtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatgacactacagatc
-atccctggatgagcatcgactttcattacttgattagttcagttaattcgtttcaaacca
-ttttcaacaaaatcccccagtagatatgtatatgcacatcttagactaaataacagtttt
-cataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagc
-gagggtaactggccctgttccattgtaatcgatgggacgggacgttatattgcagaccca
-aagtagtaataaattcagccatatggacggagggggggaattgttaagaatataattcga
-ttttcagctgaatgtaaaagctccagccattcctcctccacttgacattagttcgaagaa
-ggtctgagaattggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagt
-accaagtataatattatgacaatagaagcttaaattcacaacgtaacatatctgttagca
-tgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcag
-tagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaatggttagtaata
-atttcccagtggagtagaagtggcataacgtgcactctctgttaataatacctttagact
-actcccatttcgccagaacgtcttgatggtaccctatgggaaacactcacacatgcttat
-tgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggac
-tgatgacctaattttggtttctcaagtccagacgtgatattttgatgaccgtatctgaca
-tctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgat
-aatgctgtcatcactatcatgttttagctaagctacactaccccatcgctcgcacgtggc
-aaagtgtgaggattccgatatcatccatgtgtacgaattcctaatactcttgctcagggc
-acttagggttattgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtct
-tataatcaccgtaatcggtaaacagttgttatttgttctgataggtagacagctaataaa
-gatgctgttgaacagttacgtcccacctttattgccctacagtgaaactagttcttactc
-tgttgctgtaatatgtctagggttattgatttgctgccacttcaaaacggaaattaagtc
-attaacgaaaatggttccttcataggtaaagatcaatccccaattgaagccagaaatttt
-gagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaa
-aaaaatgttgagtccactagcttgtttattctggctcaaggtacgtggaacacgtagtat
-tttgatactaatgccagacccgctacgatccctgtactgtgagcagagccgatcctcaga
-aatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgtt
-gcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgt
-taacaaagatactctgggcaacacacatacttctctcatgttgtttcttcggacctttca
-taacctttcctggcacatggttagctgcacatcacaggattgtaagggtctagtggttca
-gtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcat
-ccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttaga
-cgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatctatatacgttgcac
-agcggatacaaataagataagaatttactaacatttaaattttcttattgtcgagcatag
-attggaggaaaaacttatttacttggtatttaaacggaagtttctaatgtttatgattgg
-atgcacggacagtttactgcttactttcttaggtttcttgaacaacaggatgcactagta
-acatgtctcgttcatgcttccattaagttcttcttaaacttacacaaactacctaattta
-gagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgtta
-ccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacatt
-cacatcccacccctgaatatatggactgaatcacacacaccaaatttcatctaccttatc
-gtagcataactattaacaaacatatacagacttcgcggtaaataaaatatattagtacac
-aaccgtatactggttgaactattgcccagctttaagacgcttttaactaggtgcttgatc
-aagaagtattattatatgacggcagtgtgtaatacctgaatagatatagacgttagattg
-tctgaaaacacgccgtagagacatttttgttagatatgtatttctttttgacgagccagc
-atcttagtatctgaagacgagctatatgtttgtagaaaatcgactgacattgtatacgag
-gcggcgtaagattaaccaaattccccagaattagtaatggcgccttatcgatttactaac
-gatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaa
-ggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacat
-agcgtcaccgatactacgttttgctatgtaatccattctaatgggtaagaggattcctct
-tatagtaaaatatgcttgactttttaagaaccattgggagtggttggcaaaataatagtg
-ggtgtctttctcagtgtatagttttctacaactacccctattaggttacaagtaatctgg
-ctttcttgccacttggcgatgatagttagattcgtatttctacaacgcagttactgtatc
-catggcgcgagataattagatacgatttgaatttggatgtagactcgttactactgttgt
-agaccagcacgtgagtatctagatgggtttgctaccttgttagcggacttttgccgggaa
-aaagacatacgtacaaccgtatattttactataagcagtattggccaccctcgtattgcg
-gcagggtgtgctcacctggttaaaatgaaagagaaaaattccattttaaaacccggagga
-atctattactgacgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttc
-atattctagttattccgagagtcactttcctatccaaacatgaactgatagcataatgac
-aggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgt
-cacgaactcggagcttacccttacaactatgtgttctgtttaccaggtgctaatatcccg
-gcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcata
-ttttacagtagccagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctg
-acataagtattacatatcacttgtctgattacacagcaaaatcgctaaccttactttgcg
-catgtagctattggaactttgggctagtgtctatcccattaagtttaacagtagactagt
-ccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttggatcaaaaacta
-ctcgatattcatgatctacgggcttcctttctccgggtatcattgcgccgagattaaaaa
-taaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacga
-atagaccatccaatttgaattttattgggtccagcacttcgccatagtgttgaatggtaa
-agttcgaaaggaaatttgttatattaattctgctacattttcgaccacttgtatctcaag
-gacaatatcccttgaggcttttagcagaaagagatgccgtaattctaagggatgataata
-ggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaaactatatattta
-aatctagccaaacaagttaacaacaaccataaagttatgaccttattatattggcaagct
-taacgttttaattgctctagtaatagagtggtagaggtaagggaccatcacctgattctt
-cctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataaaacattcgtcct
-tagcaacgaatatcgaatggcaattagccacattgagttaaatagttgaggatatttctt
-gcacagaatcagatctaatctaatgattcgttactaaacacttcaccaggtatcgtgaag
-gctcaagattacccagagaacctttgcaatataagaatatgtatgcagcattaccctaag
-taattatattctttttctgactcaaagtgacaagccctagtgtatattaaatcggtatat
-ttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgt
-acttataccatacatgaattctggccaagtaaaaaatagattgcgcaaaattcgtacctt
-aagtctctcgccaagatattaggatcctattactcatatcgtgtttttctttattgccgc
-catccccggagtatctcacccatccttctcttaaaggcctaatattacctatgcaaataa
-acatatattgttgaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagt
-aatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaatattctgggctag
-cgtgagatagtttcttgtcctaatatttttcagatcgaatagcttctatttttgtgttta
-ttgacatatgtcgaaactccttactcagtgaaagtcatgaccagatccacgaacaatctt
-cggaatcagtctcgttttacggcggaatcttgagtctaacttatatcccgtcgcttactt
-tctaacaccccttatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgt
-tattttttgaagtaagttacattgggcagactcttgacattttcgatacgactttctttc
-atccatcacaggactcgttcgtattgatatcagaagctcgtgatgattagttgtcttctt
-taccaatactttgaggcctattctgcgaaatttttgttgccctgcgaacttcacatacca
-aggaacacctcgcaacatgccttcatatccatcgttcattgtaattcttacacaatgaat
-cctaagtaattacatccctgcgtaaaagatggtaggggcactgaggatatattaccaagc
-atttagttatgagtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcg
-taatgttatctcgggttccgcgaataaacgagatagattcattatatatggccctaagca
-aaaacctcctcgtattctgttggtaattagaatcacacaatacgggttgagatattaatt
-atttgtagtacgaagagatataaaaagatgaacaattactcaagtcaagatgtatacggg
-atttataataaaaatcgggtagagatctgctttgcaattcagacgtgccactaaatcgta
-atatgtcgcgttacatcagaaagggtaactattattaattaataaagggcttaatcacta
-catattagatcttatccgatagtcttatctattcgttgtatttttaagcggttctaattc
-agtcattatatcagtgctccgagttctttattattgttttaaggatgacaaaatgcctct
-tgttataacgctgggagaagcagactaagagtcggagcagttggtagaatgaggctgcaa
-aagacggtctcgacgaatggacagactttactaaaccaatgaaagacagaagtagagcaa
-agtctgaagtggtatcagcttaattatgacaacccttaatacttccctttcgccgaatac
-tggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgctcataaataggt
-agactactcgcaatccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcg
-tgtttatcaaccgtccccactcgcctggggagacatgagaccacccccgtggggattatt
-agtccgcagtaatcgactcttgacaatccttttcgattatgtcatagcaatttacgacag
-ttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaacccacatgaatg
-tgattcttggcaatttctaatccactaaagcttttccgttgaatctggttgtagatattt
-atataagttcactaattaagatcacggtagtatattgatagtgatgtctttgcaagaggt
-tggccgaggaatttacggattctctattgatacaatttgtctggcttataactcttaagg
-ctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttggactccctcttt
-catgtcagtaacatttcagccgttattgttacgatatgcttgaacaatattgatctacca
-cacacccatagtatattttataggtcatgctgttacctacgagcatggtattccacttcc
-cattcaatgagtattcaacatcactagcctcagagatgatgacccacctctaataacgtc
-acgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcat
-ataacatttgagggtaaagctaagcggatgctttatataatcaatactcaataataagat
-ttgattgcattttagagttatgacacgacatagttcactaacgagttactattcccagat
-ctagactgaagtactgatcgagacgatccttacgtcgatgatcgttagttatcgacttag
-gtcgggtctctagcggtattggtacttaaccggacactatactaataacccatgatcaaa
-gcataacagaatacagacgataatttcgccaacatatatgtacagaccccaagcatgaga
-agctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaa
-ctggttcccgggagtcctggagtttcgacttacataaatggaaacaatgtattttgctaa
-tttatctatagcgtcatttggaccaatacagaatattatgttgcctagtaatccactata
-acccgcaagtgctgatagaaaatttttagacgatttataaatgccccaagtatccctccc
-gtgaatcctccgttatactaattagtattcgttcatacgtataccgcgcatatatgaaca
-tttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggt
-taacagacgtacatgaagggaaactttatatctatagtgatgcttccgtagaaataccgc
-cactggtctgccaatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttg
-tttgcagagtataacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcac
-tattggctacaaaatagggaagagtttcaatcatgagagggagtatatggatgctttgta
-gctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagatacataagcgataa
-gttacgacaattataagcaacatccctaccttcgtaacgatttcactgttactgcgcttg
-aaatacactatggggctattggcggagagaagcagatcgcgccgagcatatacgagacct
-ataatgttgatgatagagaaggcgtctgaattgatacatcgaagtacactttctttcgta
-gtatctctcgtcctctttctatctccggacacaagaattaagttatatatatagagtctt
-accaatcatgttgaatcctgattctcagagttctttggcgggccttgtgatgactgagaa
-acaatgcaatattgctccaaatttcctaagcaaattctcggttatgttatgttatcagca
-aagcgttacgttatgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtg
-ggaataattcttttgaagacagcactccttaaataatatcgctccgtgtttgtatttatc
-gaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcggataacaattaat
-acgatgttcatagtgacagtatactgatcgagtcctctaaagtcaattacctcacttaac
-aatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccga
-gtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctctctgaattccttc
-gtgccaacttaaaacattatcaaaatttcttctacttggattaactacttttacgagcat
-ggcaaattcccctgtggaagacggttcattattatcggaaaccttatagaaattgcgtgt
-tgactgaaattagatttttattgtaagagttgcatctttgcgattcctctggtctagctt
-ccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgt
-aataattaggttcggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgc
-tgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaat
-gagactcagtagttaaataaatccatatctgcaatcgattccacaggtattgtccactat
-ctttgaactactctaagagatacaagcttagctgagaccgaggtgtatatgactacgctg
-atatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaataccggctgtttccag
-ctttataagattaaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagt
-tggttcattaattagctaagtacgaggtacaacttatctgtcccagaacagctccacaag
-tttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattaga
-gtttacaactcagtattttatcagtacgttttgtttccaacattacccggtatgacaaaa
-tgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcc
-tacacatactgaattcaggcaatgcgttttattcgaaaggtcatataactagaaaacatg
-atgaattcttatcggatccttttactagcatagtgttggcgaacacctcgtaatgctcag
-cggcaaattggactgcgggtccttatcatacattttttttcaatataggcgattggtcta
-ggttagtgattccccaacacttaaggtttgctgacattcataccctcagcaacttcctct
-caaaaattagagtgagttggtggtcttataagaccgttgattatttgaggtggtcaaatg
-atggtgcgatgcacaaatcgttataatcgtactctgtagacaataacccattgtagtgcc
-gattttgtgcataatacaagaaggaggatataaaaatgacttttcaataatattggctat
-tagcaacaagaaggagaatcctcattaagttagcaaccgcagggggtactgcagtccaag
-gaggtttcattggagagagcagtatgaaaacggcaattatgattgtgagattcgctgaag
-attgtgtctctgattttcctagatagaataagctatagctacttaatcaactcttaactg
-tggagactatcctgatgatctgaataccccatttacaaaattccatatcaatgaggctaa
-cgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatacaagacaaaacac
-tgcttccattacgggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgata
-aagctgtcttgcgtttatacttaaacaaattttgacctgacataatggagcgacttatcg
-gatgttgccgatctttagggtcatctattaagcttatacgaaaaagggacaagcacgtta
-cgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaactccaatatctgta
-agaacagaaaaatacaggagtccttttcatttttcaagttaacaatataagtaggagctt
-agagaggcttgcatgaaaatcgttaggaattacagaataggcagagagtggggcgtgtag
-actacattcttcaggccccacaatatgggttataggttaaactgcactttttgcgatctc
-ccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcat
-ccaactattcagataaacaagatcgcagaattaaagcttaaccatatcttgatagcccat
-cgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaa
-aatttagacaaacataattcattctttcgactggacacgctaaggtttggacaaactttg
-tatctatatctggaggcctgtattccagcccttcttttaataagatttacggcttaaact
-atggatatttgccaggaaatgacactgctattgacaggaacataattttgattcaaacct
-cattgttaattattttatatctcctgtttttatatcagaatgcttctgtcctagaaggca
-tactcaaggtgagggctcgaggaatgaatcataatagaccggcccctattaatattggtt
-caattctttcttacataacgcggaatttgattgcacgaacaccgggaacacataaccgta
-tagcgcccgttatgctagtgcctagcgactgggaccgtggagtctatatcgtctttctac
-cattattaatctaaggatataccactttaagtcctttcaactaacataaggcgcattcca
-tgcgctaaggaccttgaatttattatttcttacatgataaaagatcgagtcgacgggaac
-aaaaggctacgtactcaataaagtgcagtttactaagagccctttttctggcttgtggag
-actatcataacatgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtg
-tagtattgaacgagatctttccaattgccccatagcaggaatagttatatattgcagatc
-gcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattac
-ggtttttgatcaaagcacagtgagagttgagcaaattacagttatacgacttaattcagt
-ctccataaattgaaacgacacttcttaacgggaggaccagacacgttcattaagtgagga
-gtgcactttttgactttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaa
-cagatttgaagttatttctgttttaatacactgggagttctgtcaatatcgcaggaaccg
-cctgacgtcccctatcacacctcagagggtaaagggacaggggaaagggtaatcgagggg
-tagggaacgtagttggcacacccaatggacgaataaatgctgccatatccacggagggcg
-ggattgcggttgattttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcc
-tccactggaaattactgcgtacatccgctgagaattgcaatggagtgtctcggtttttct
-ttaaacaaaaccaaattgacaacttcatagtataatttttgcacattacaagcgttaatt
-aacaaacttactttgctgttagctgcctatatttgtccgacaatataactggatatctct
-gcgagaactgtaaattaacggcacttggaacataatagttcctattggtaacgacgttgt
-aggcggcaattatccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaat
-ctctcgtaagtataactttagaagactccaaggtacccagaacctcttcagcggacacga
-tcgctatcaatcaataaggattattcactgaaaccgctcatatctggaggtggacgtttt
-tcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctg
-ttattttcatgaccggataggacatctcgcggaaattcgggtaacagctgggtagatata
-ggacctcccctacgtattaatgataagcctgtcataactagcttggtttaccgaagagac
-aataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaaca
-tgtactattactctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgat
-gttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtct
-gagcattcgtacactgcgtattaagatcaggttgaacaggttcctaacaaattttgtgac
-ctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctg
-acacttctaaaaccaaattaaggctttatccaatatgggtccttaagtgctaaacatcat
-tcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcgccaaattgacac
-atcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtgtgtattctggct
-ctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgt
-aggtcacatcagcagatcctaagtaattccgttttattgtcctgagggagtaggatcgac
-gaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaa
-tgaactattgtcatctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcg
-atggttctttatgcggacctgtcatatcattgactggcacttgcttacatccaaataaca
-cgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatt
-tcgccctctacatgataaatgaataagtaagaagatgatctttttgtggcggtaccttaa
-gcgtactcctgtcgacgagttactactaaaggaatgtagggttctggatctatgaaaagc
-gacctccatatatatacgggcctaagcggagtaaaataagtgatcaatggactaacattg
-aaatgttagtattgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaac
-gaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttactttagttggttg
-cgggaacaacaggaggctatactaactggtagcgttcttgcttccattatgttattatta
-taattaaaaataagacatatggtagagttgtagtcagggtggatcgggttgtctataacg
-ttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcg
-cctacctcatgtgcaccacacattcacagcacacccctcattataggcaaggaagcaaac
-aaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaatagaaacacttagc
-ggtaatgaaaagataggactaaaattcactagtatcctggaacgaggcaacagagttatc
-tagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacc
-tctattgatatacaagtgactttctcggtaataacgcacttcacaatgtgttgtttcttt
-tctatgtattttgcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgt
-aaatcgtatcacatggtataactgcaggaggaacattatccaaattcaccacaattacta
-atccacccttttacttttactaaagatatattaattctcatgttgtctgaattgtataac
-ccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaaca
-cacgacttccttccgtctattcagacactcaacgagactaacttttcctaggtaatcaat
-gatattgggtaactcgtggcatcttatagttattgatccggctcttttgtagatcctgtg
-cgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtttattctacgtac
-ccgatttggttactactaagcggcctttcttcaaacttgcagttgtgacttacattccta
-tttcttcaaagcagggaagggttacagggagagacttattgagatacgattggaatttcc
-atgtacaatcgttaatacgcttgtagaccagcaactcagtatagagatccgtttcctaaa
-gggtgagcggtaggggcaaggcaataagaaattactaaaaccctagttgttaatataaga
-acgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaa
-taggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttct
-caaagatcctaacctaaaaggggcttattctactttttccgacactcaatggacgagaca
-aacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatcgttattattaat
-cggtttccattatctatatgcggtatagatctccgagaggaccctgtaaactagctctgc
-ggtttaactggtgctaatagaccgccactatgttattgcttctagctcctagcgtcttat
-catgttatacattaatgtcgcatattggacagtagccaggcttggatggatcgccgacaa
-aaagaaaagactttccctgtaaggacttaactattacatataacttggatcattaatctg
-caaattagagtaacggtctttcaccagcttcatattccaacgtggcgctagtcgatatcc
-catgaagtttaaaactagaattggcagtctcacttcacagtgcgtatctatacgacaaaa
-gtggtcgatttgcataaatatcttatcgatattcaggttattaccgattccttgctaacg
-ctagaagtcacaccagagtaataataattccagacacctgtgaaataatcggtcactacg
-gatagactagtaacgataatacgtatagtccataaaagttgaattttaggggctaaagat
-attagcaatactggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctac
-attttcgaccaattgtatcgataggaatagttacagtcacgcttgtagatgtaagagatg
-acgttattcttagggttcttaagtcggggggtaatttaagaccactagtaaaggtagagg
-cgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagtt
-agcaactgattttagtggcaaccttaacggttgaattgatctactaatacaggcctacac
-cgaagggtacagataatgattcttactaccctaacatgatagagtcctgtcctatctcat
-aggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattca
-cttatagacttcaggttatttcgtgctaacattaagatagaatataatcagtcgttaaga
-aactattatccagctttcgtcaaccataaagattaaaaactgaaacttggcaagatatga
-atagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagca
-cttgtgtttagtaaagcgggagagtgcggtaattaatattaatatactattaagctacac
-agcaaaggctgcaataatgttagtaagtagaacataaaggtattctccacaagtaataaa
-tagtgtgagctaattgactaacttaactctcgcgacaagtgatgtggataagatgactca
-tatcgtctttttctgtagtgccgacatcccacctggatcgaacaattccttctagttatc
-gactttgattacctatcctattaaacagatagggttgtaaagtcagaaaatgatcggctt
-gcgttggtctaccatagctagagttagaacgcgtagatagaggccttttgttgccaacgt
-gggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatc
-cattagattagatgtttgtgttttgggtctgatgtcctaactactttctcagtgaaacta
-atgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtcta
-taacgtatataaagtcgctgaatttagaacacaccttatctatgttgtaaagttacttta
-ttccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttg
-tcagtgtagataagaatttctttcatacttcactggaatccggcgtatggatatctctac
-cgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttg
-gtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtg
-aagtctaattatttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgc
-gccaatgaggatagaggacattgcatgtacgtaggactattctccaaggggtcttctatt
-ttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactttataccagatac
-tttcattagatatgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaa
-aaaagacccgttgtgatatgatgtttttctagttcgttctcatatatatagatcaacaat
-gaataatctcatgatctataaccgatgtatatttatattccggttgactgctccggtgca
-attcactacggacactaatgactaatatggcgcctttcatcagaaacgctaaatatgatt
-aatgaattaagggagtattatctaattattagagagtagcagttagtctgatattttcgg
-tgtatgtgttagccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtg
-ttgtatgcttcactttatgactctggttatatccctcggagaacaagaataagagtacga
-gaagttcggtcattgaggatgaaatagaaccgctagacgaatggactcacgtttataaaa
-ctatgtatcacagtactacagctaactctgaagtccgagaagcttttgtaggacaaaacg
-ttataagtacctttcgcagaatacggccgtgcatacctgttataaggcgtagtagggaca
-ccatgctatccctcatatagagctacactaataccattacatggtgactatcgtttacgg
-ccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactg
-cagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctcaatccttttcca
-ttatggcatagcaagtgacgactcgtcagccatgggaataatagcactaatccgattact
-tatgaattagaacccacatgaatgtgattctgcgaattgtctaagaatctaatgattttc
-cggtgaatatggttgttgttatttattgaacttatattattaacatcacccttcgttagt
-gatagtcagctatttccaagaggttccccgagcatttttaccattctctagtcatacaag
-ttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaattctgcagatgt
-tagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtttttcgttacata
-tgctggtaaaatattcatagtaataactacaatacttgatttgttacgtaatgctcgtac
-ataacacaatcgtattccacggaacagtaaagctctattattctgatcgagcctaagaga
-ggatcacactacgctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgac
-cagttatagacagtgtaattccatattacatgtcaggcttaagctaacccgagcctttat
-ataagctataatcaagaattagattggagtgcattttagacttatctatcgaaatagtga
-tagtaagagtttatatgacctgatctagactgatgttctcttccacaacagccttaaggc
-gtggagcctttcttatactattaggtcgcgtcgagagccctattcgtaatgttaacgaca
-ctagactaatatacaatgagctaagaataacacaagtcacaagataatttacaaatcata
-tatctacagtccacaaccatcactagcgattgcaaagcgttattggtactaccgctctaa
-atcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgtgagactgaaaga
-aatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttag
-tttggtcaagactatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattg
-ataaatgccccaacgttccatcacgtctataagccgtgttactaatgtgtattagtgcat
-acctattcagaccatagttcaactgttggactgaaggcccgtcttggggttcgtgaatga
-gagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatcggtttatctaga
-gtcatgcttaaggtgaatttcagccaatgggctcccattgagctagtatggtgctttacc
-tttgtaagtggtggctttccttggtgtgctgactttaacacggcagagtgattatccgaa
-gaatggataataagacgctggcaatattggctaataaagtccgatgagtttcaatcatga
-ctgcgaggagatccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcat
-tcttgatacataaagatccgatatcggtccactttgtttaccaaaagccctaccttcgta
-acgatggaaatgtgaatgagagtgaaatacacgatggggatattgccggtgagtacaagt
-tagaccacacattagaactgacctatattcgtcatcatagagatggagtatgaattgatt
-ctgcgaagtacactggctttacgagtatctagacgccgcggtatatctcccgtcaatact
-atgaaggtatatatatagaggctgaaaattcatgttcaatcctctttctaagagtgagtg
-ggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagt
-atacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaatctcgattcacc
-gagagaagtgattttggcggtgtgcgattaattcttttgatgacagatctcattatttta
-tatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggg
-gggagagtgcgctgaacattttatacgatgtgattactcaaaggataaggttcgaggcct
-ctatactcatggaactatcttataattataatggatcgtggctcattccacctatccaaa
-cttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttggga
-cgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaaattgattctact
-gcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttata
-gcaaacattattcaatttcagtcttgactgaaattagtttgttagtgttagaggtccata
-tgtcacatgcatatggtctagatgccattgtacagtaataccttagattagtattagcgg
-catgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgca
-aataggaatacttacaatttttgatgacttgttagcatatcgctatcacccataaaaaac
-ctgatacttgatgagcgggtgattgagactatgtactgatataattcaatagctccaata
-gatgaaacagctatgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctg
-aacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacgaaatcgatccca
-gaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacg
-aagaatgggtagagagtttgaaggtgcttctggattttcctaagtacgtggtaaaaattt
-gatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgggtgaatctgatt
-agccaacccagtgatctgatttcagttgtcaaatctcttttttataactaccttttgttt
-ccataatttaaccggatctcataatgaacaaacgggtagaataatggtagcacatagcga
-gcttgtctattcagaaatatggcctactcagaatgtattctccaaatcagtgttatgcga
-aacgtaattttacgtgtaataatgatgatttcttatcggttccttgtactacaatactct
-tgcccaacaaatactaagcataacagcaaaattcgaatccccctccttttaataaatggt
-ttttcaatatagccgattcgtattcgttagtctttcaccaactattaacctggcatctaa
-ttaataaaatcaccaaaggactctataatatgacagtcacttcggcctcttttaagacag
-ttgattattgcaggtccgcaattgatggtgacatgcacaattagttagaatccgactatg
-gagacaattaacaattgtagtgcccatttggtccagttgacttcaaccacgagttataaa
-ggtattttaatttatagtcgatagtaccaacaacaagcacaatcataattatgttagaaa
-acccagggggtaatgctctaaatccagctttaaggccagagtgcactatgaaatcgccat
-tgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagat
-accttatgaagcaacgattatatctggactagatcatgatgatcggaataaaacattgaa
-ataagtccttatcaaggagcataaacattttatttaatttatacttcgtaaataaattca
-gaattttttttcaagacattaatctgagtaaatgacggctagaaagggttcctactcgaa
-tcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcac
-cggaaagaaggctgccacttttagcttcttgacgatctttagcgtcatatttttagatta
-gtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaag
-agcaggacaactccttgatcgggaagaactgaaatagacagctgtcattttcattggtca
-acttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaact
-atagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcg
-ttaaaaggaacgggttgccagctacagatatactctaggtatatcccaaacaagagacgt
-cctttggctgttgtaatcggtcataatacttgtcacataaacaagatcgctgaattaaac
-attaaacagttagtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatc
-tatcgtctatcacagagcgacgtaaatttagacaaacattattatttcttgacaatggaa
-tcgataagcgttcctctaacttggtatatatatctcgaccccgggattccagccattctt
-gtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaaatgatattgact
-gcaacagattttggatgcaaaaatatttgtgaattattggttatatactggttgtatagc
-acaatcattaggtcctagaaggcatactcaacctcagcgagagagctagcatgcataatt
-gtaccgcccatattaatattcctgaaatgatttcttacattacgcccaatttcagtcatc
-gaacacccccatcaatttacccgatagagaacgtgatcatacgcaataccctatgcgaac
-gtccactctatagcgtctgtatacaatgattattcgttccatttacaacgttaagtaatt
-taaacttacataaggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgc
-agttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaa
-gagacctttgtatccattgtggagaatatcataaattcaagatggggtgtcatgctattc
-ggtcctaaacattcttaatggctgttctattgttagtctgatttaaaatggaaccatagc
-acgaatagttagatagggctcatacccctgtaacgatctacaaatccttccccgggtgtg
-tgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcacacgtcagattat
-tacactgatacgaattatttcagtcgacagtaattgaatagaaacttattaacgccagca
-cctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttt
-taaaaatcttgatttctatatcaaatgatgtgtagttttttctctgttattaaaatccca
-gtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatcacacgcgttagcg
-aaagcggaatggctaatacagccctacgcaacgtagtgggatcaacatatggacgaattt
-atgctcaatgagccaacctcccccgcattgcggttcattttaaggcctgggtaacatcta
-tcgtttagataatcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagt
-ccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcgtaatacgataat
-tgttgctattgactacaggttatgaaaaaacttactttgcgggtacatgcatatttttgt
-accacattattacgcgatatctctcagtgtactctaaattaaaccctcttcgaacatttt
-agttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtagaatggacaactcc
-agttcaactgcatgtaactcatagctcgcgttagtataaattgactagtagccatgggac
-aaagtaactagtcagcggaaaagatccctttaaagatatatgcaggttgcaagcataaag
-ctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaatttt
-gggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaatatcgcccattt
-tcccgtataagctccgtacttatacgaactacacgaccttttaagcattagccgctcata
-tcgtgattcgtgtacagatgagtctattaaaattacagacatactccatatctcgctcct
-tgaactttgaataatgcgctaacttgtactatgaataggcagaacccaactttcccgttt
-gcgtcaagcggggaaacgatacatgttgtcagatttatgattatctagttttagatcacg
-tttaccgataatcggctgtggtctgagcagtcctacactgagtatttacttcagcttcat
-atcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatctttt
-ttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacgatttttactatag
-cggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtggctcttgtccttg
-aagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaattatttggtgac
-taatagtccgtgggtttgagccatatacctaacgccataaactacgtggtgctttagatg
-caatctaaacagaacagaaagcgtagcgctcatcagcacagactaactttttcagtttga
-gtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgat
-tgggcggctcaatcttgcctaatttctactattgtcagctgtacgactgtactaagtgta
-tagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagc
-gcacttccgttcatcaaattaaatcctggcttacccgattctccggaagtctgacctaga
-gattgacgacggccgcgtattattgagacctcttcaggattaatcaataacgaagtagtt
-gatctgtttggcgacgtaccttaagccgactccgctacacgagtttctactaaaccaatg
-tagccttatgcttagatgaataccgtcctaattagatattccggcataacagcagtaaat
-tatctgttcaatggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaa
-tattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctc
-gttaatcattaatttaggtgcgtgagggttaaacaccagcatattctatatgctagacgt
-cttccttaaaggatcgtagtattataattaataataagaaatatggttgacgtctagtca
-gcgggcatacgctgctctatatactggcattattcaaaacttgacggtaaaaaaacgaat
-tttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacac
-ctctttattgccaagcatgcaataaaaaaaatgttaatagtacgtttacgacattttatt
-ttataataaagagaaactattacacctattgatatgataggacgtaaattaacgagtagc
-ctgcatagaggcaaatgaggtttctacatggtatagacctgatgctgaaacatcgatgag
-ttttggtcccctcgctcgttgaaatctagtcatttactactgtctttcgagctattatac
-cacttcactatgtggtgtttctttgctatgtatggggctagtcaaacatgatgactatag
-ctacaactcagagagcgggcgtgttaagagtatctcatgctagaactgcacgacgaactt
-gatacaaagtaacaacatttacgattccacaaggtgactttgaagaaacatagtttaatt
-ctctgcttcgatcatttctataaaccggtaccatcgcagcggatagatgcataacatttc
-tactactccaggcatcttaaaacacacgtagtacttcactagattaagacacgataagtg
-tataacttggcagtgggaagcaaggagattggcgaactcctggcatctgttacgttttgt
-tcaggctcggttgttgataatgtccgactcctgccatattgaagactcgctcgagggaga
-tcgggattcgttgattataagtacacgtgttccgtaatactatgaggcagtgattcaaaa
-tggcacttctgacttacatgactaggtattattaccacggaagcgttaaaggcacactct
-tatggacttaagattgcaagtgccttcttctagcctgaattcgcgggttcaacacaaact
-ctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtact
-aaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcg
-aaaatcgggttaagcaaacacaaataggaattgtgataaaccccaccttgagaggtcgca
-agaccaacctcgggaacaacggctctaagagaataacctaaatccggatgagtagactgt
-gtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgca
-ttcaattgaatcgtttgtattatgagctgtacagtagctatatcagctatagttatccca
-gaggaacaggtaaactagctctgagcgtgaaatccggatattagaacccctagatgggat
-tgattctagctaatacaggcttatctggttttacagttatctagatgattggtaaggtga
-aacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagctattttctaggt
-attataaagtcgagcattaatatcaatttgacagtaaaggtctttcaccagcttcatatg
-ccatagggcccatactcgatttaaattgaacggtttaacgagtattggaactctcactta
-taactgagtagctatacgaaaaatctggtccatttccagaaatttattatcgatttgctg
-cttagtacccaggaagtgataacccttgaaggcacaacactgtaataagttttcctgtca
-catctgtaatattcggtcactacgcattcacgactaaagataattactatactaattaaa
-agttcaatgttagggccgaatcatagtagaaattctcgtctagcctaatcggacttacct
-atgggctgtgaggatttatcagtatgtggacaaaaatgctagagataggtatagttaaag
-tcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgg
-gatgacaactactatacgtagagccgtactcaggattagatagtgtgaaagagtcaaata
-aaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtag
-ggatattctaatacaggccttcaccgaaccctaatgataatctgtcttaataacattaaa
-tgattgtctccgctacgagctcttagggcctcattttaaatgactaatgtccaaagaaga
-gactttcccaatttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaag
-atagaagattatcaggagggaagtttctattatcaaccgttacgcaaccataaactttta
-aatctcataatggcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgct
-ggggagctagatatcggtataccacttcggttgtggtaagcccgagtgggccgttagtaa
-tattaatagacgattatccgacaatgcattcgctgaaataatcttacttaggagaaatta
-atgctatgagccaaaactatttatgtctgtcacattattgactaaagtatctatcgacaa
-aactgatgtccataagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcg
-agcgaaaaatgaattatagttatccaatttgagtaaattgcctattatacagataggctt
-gtttagtcagataaggttccgcttgaggtgctctaacttagcgagagttagaaagcctag
-tgagaggcattttggtgccaaactccggctcgcatgagtaggccagagagtcactttctt
-tcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgtggctatgtgcta
-ctatataagttagaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgag
-acggggtacgccgttgaggctcgagatagtagataaactagaggaatgtagataaaacat
-tagctagggggtttagttactggattacataggaagtgcaccatcacggtgtgggggttc
-gtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcc
-tatacggactttgcatatctctaccgactcatctggtcgtctatgcgggtaattgtattg
-ctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaatccttataatag
-cataagcaattattagactgcgtgaagtcttagtagttctcaagctttacgttgtatgta
-aataactcacgtaatcagccgtccccaaatcaccattgaggtcattgaatgtacggagca
-ctattatcaatgcggtatgcgattttctgagcgattattgttaaagacttagcgttgagc
-cccggaacacttgattacagattctttaaggagttatccaaatatcattttaaataatag
-tagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtac
-ttctctgatatatacttcaactatgaagattctattcatcgataacccaggtatatttat
-atgcccgttcactgcgcagggcaaattatctacggacaataatgacgtagttggacccgg
-taagaactaacgcttaatatgattaaggatgtatgccagtattatcttattatgtcagag
-tagaagtttctctgagattttccgtcgttgtggtacaccggatttggctctctttttaga
-actgagaactcggagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccg
-ccctcatcaactataacaggacgacaagttccgtcttgctccatcatatactaccgatac
-accaatcgtatcaagtttagtatacttgctttctctcttctacagcttactcgcttgtcc
-gagaagcggttggtgctcataaagttagtagtaaatgtacaactagtagccagtccttac
-ctgtttttacgactactacggacaccatgagatacagaagttagtgctacaattatacca
-ttacatgctcaatatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatac
-gtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttgactaacatcttt
-tacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcgg
-aagaataccacttttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaa
-ttgtagtagaatatattcatttgaccgtcattagccttcttcttaggttgtgtacggata
-gtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttt
-tttaccaggctagagtcagaaaagttggagccatgttaaatagttaccatcataaaccac
-tgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaa
-tggtaacaactgttgcgttacttaggctggttaatttgtcagagtaataaatacatgtct
-tgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaaaagtaaagctct
-tttattctgatagtgactaactcaggatctaaatacgcgattatactaaccttcaccaaa
-gctcaaaaatcatctgctggtgaccagttatagacagggtaattcaatatttaatgtctc
-ccttaacatttcaccagcatggattgaagatagtataaagttttacatggcagtcattgt
-gtcacggttctatacaaattctgatagttagacggtatttgaaatgtgcttctagcatgg
-tatcttacacaactgaatgaacgactggagccgttcgtatactatttgcgagcctcgaga
-ccccgtttcctaatgttaacgaatatagtataatataaattgtgatatgaataacacaag
-taactacagtttggacaattaattgttctaaactaaaaatcattcacttcagatggcata
-gagttatggctactacacatataaagcggtatgtgaaacacccgttttagccggaaaccc
-tctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtga
-ctcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgca
-gcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaac
-tgtgaataatgtctattactgattaactagtaagacattagtgcatctggtccactgaag
-cacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaa
-agcaagcctataggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcac
-attgtgctaggttcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttg
-ttatcggcagactctttatcccaagaatggataatatgtacatggaaagtgtccataatt
-aagtcccttcactgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgact
-tacttgctttttgatcaacttaattatggattcataaagttcagatatcggtacaattgg
-tgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatc
-cccatttgcccggtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagc
-attgagatccacgatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacga
-agaggtatatataacctaaatactaggtacgttgttagagagacgatgaaaattaatcgt
-caatacgctggcgaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtg
-tcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaattcacggaacgt
-agcgttgggaaatatcctttctaccacacatcggattttcgccctctcccattatttatt
-gtgttctcacatagaattattgtttagacatccctcgttgtatggagagttgcccgagcg
-taaaggcataatccatataccgccgggtgagtgacctgaaattgtttttagttgggattt
-cgctatggattagcttacacgaagagattctaatggtactataggataattataatgctg
-cgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatac
-ctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattat
-atatgttgattatttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaa
-gctgcatctcgcttaagtttgagagcttacattagtctatttcagtcttctaggaaatgt
-ctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatgacatgctaaact
-aagaaagtagattactattaccggcatgcctaatgcgattgcactgctatgaaggtgcgg
-acgtcgcgcccatgtagccctgataataccaatacttacatttggtcagcaattctgaca
-ttatacctagcacccataaatttactcagacttgaggacaggctcttggagtcgatcttc
-tgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagttagggcatagtat
-agatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagctgagatctatcc
-taaaatgcaaccatatcgttcacacatgatatgaacccagggggaaacattgagttcagt
-taaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacgggcttatggttt
-ttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaaca
-acattaaaatcgcggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatat
-ctttggtagaacttactttgctttaaatatgttaaaccgatctaataatctacaaaacgg
-tagattttgcctagcacattgcgtccttctctattcagatagaggcaatactcagaaggt
-tttatccaaagcactgtgttgactaacctaagttttagtctaataatcatgattgattat
-aggtgccgtggactacatgactcgtccacaaataatacttagcagatcagcaattggcca
-agcacccgacttttatttaatggttgtgcaatagtccagattcgtattcgggactctttc
-aaataatagtttcctggcatctaagtaagaaaagctcataaggaagcgatattatgacac
-gctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttca
-aaatttactgagaagacgaagatcgactaaagttaaaatgctagtccacagttggtcaag
-ttgaattcatccacgagttatatagctattttaatttatagtcgagtgtacaaaaaacat
-ccacaataagatttatcttagaataacaacccccgtatcatcgaaatcctccgttatggc
-ctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgagg
-tggtgacgagtgagatgatcagtttcattatgatgatacgattttatcgcgactagttaa
-tcatcatagcaagtaaaatttgaattatgtcattatcatgctccattaacaggttattta
-attgatactgacgaaattttttcacaatgggttttctagaatttaatatcagtaattgaa
-gccttcataggggtcctactagtatcctacacgacgcaggtccgcagtatcctggaggga
-cgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccat
-agtgagccgatgagttttacattagtactaaatcccaaatcatactttacgatgaggctt
-gctagcgctaaagagaatacatacaccaccacatagaattgttagcgatgatatcaaata
-gactcctggaagtgtcagggggaaactgttcaatatttcgtccacaggactgaccaggca
-tggaaaagactgacgttggaaactataccatctcacgcccgacgcttcactaattgatga
-tccaaaaaatatagcccggattcctgattagcaaagggttcacagagaaagatattatcg
-acgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatc
-ataaaaatgtgacctctagtatacaggttaatgttagtgatacacaatactcgtgggcca
-tgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgtatttggtctaatt
-atgttttatttagtgacaatccaatagataaccggtcctattaagggctatatttttagc
-gaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaattgccagtgggca
-atcctaagcaaaatgagattctatcctaaagtttgggcttgatataagatttcggatgta
-tgggttttataatcgttggagagctcaatcatgagctaatacatggatttcgctacctca
-ccgagagaccttgcatgaagaattctaaccaaaagtttaataggccggattggattgagt
-taattaagaccttgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtga
-gcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgag
-ttcctttgaaatagttaactaatttaaaattaattaacgacatggaaatcacagaaccta
-atgctttgtaggagttatttatgctgtttactgcctctacaaccctaataaagcagtcct
-aagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtcaatttaataaat
-tcaacatcgggtctcaggatattcggtcatataatttattaagggctcttcgagtcttac
-tctgagtgaaattggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcga
-tatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatat
-aagaaaactcacacgtctcattattaaactgagtacaatttttgcacgagaaagtaatgc
-aatacaatatgatgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgc
-actggattaaaatccgattatttttaaaaatattcagtgctagagcatatcaggtctact
-tttttatctggtatgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaa
-gttataacataactcccgttagccaaagcccaatcccgattactgccctaccctaacgtc
-tgccatctaaatatcgaacttgttatgatcaatgtgactacctcccaccctttccccttc
-atttgttccactggggataagctagcgttttcagaatcaatgcaataagaatagccaatt
-gtctcacttcatcagagctcttggcaattccaggcgctacgtggttctggaatatattca
-tttttcaaatagtaatacgtttagtgttgctattgtctacacgtttggatattacgttat
-gtgagcggacatcaatagttgtctaactctttagtaagccagagatagcactcttagcga
-atggataccatcttccataagtttagttaatagtccgaaacaactgcttcgagcatattt
-gaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatagatagagtttgtt
-ttaagggactactagaaatgggacaatcttaatagtatgacctaaactgacatttaaaga
-tatatccaggtggcaagcataaagatcattgcgccacctccaccgtgggattacttatca
-gtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagctgagttgatgct
-aaccttacctatgataccccattggaccggttaacagccctacttattccaaataaaaga
-acttttatgctgtagaagctattatagtgatgcctggtaacttcagtatattaaaatgac
-acacatacgccatatagagctcctggaactttgaataatgagcgaacttcgaagttgaag
-agcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattg
-atcattatcgaggttttcataaccttgacccattatcggctgtgcgcggacaagtactta
-aatcactagtttcttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataa
-gacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggatttta
-aattttgttccatttttaatttagccgtaaggatgtccgtaaatgattgaaaattggatt
-caatctttgggcctatgctactggaacctgatcgacaaaatttcaaacatacgttaactc
-cgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccatataccttaccac
-ttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagactaccgatcatatc
-aactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaag
-taccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaattgctaagaggctc
-agagctaccactgtaatttctctagagcccataataaatgaacgatacatccgtaggtag
-cacctaagggattataatggaagccaaatgcagttaataatattatatactggcgtacac
-gattcgacggatctctcacatagtgattcacgacccccccctttgattgacacagcgtca
-gcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagct
-acaactgggtataatttaccatgcttccctgatgctgagtgcaatacactaagaatgagt
-ttttaccccatatcaccagtatttgttctgttattgcgaagaaatggctatgctgagttg
-gcgactaaagtcacccatcctttttattaggtaaccccctcccttaaactaactgatttg
-ctggagctgccctgcatacatatactttatcatttatggacgtccgtgacgcttattatc
-caccatagtcgatatgctacacggattcattaatggatcgtaggagtttaagttatattt
-actaagatcggtctcggctactatcccgccttacccggcgctatttacggccatttttaa
-tatattgacggtaattattcctatggtttcgaccgcacgtccttggacaagaaagaatgg
-caaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtga
-tgagtaacttgacgaaatgttagtggttattaaagactatctattacaccttttgttttc
-tgtcgtagtatattaaagtctagaagccttacaggaaaatcagggttatacagccgatac
-tccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgt
-atactgtatttagaccttttatacaaagtaaatatctcggctttatgtgattgggagggg
-cctactcaaacatgatgacttgacctaataatcactgtgcgggcgtcttatgactagcta
-ttccttgaaatccaccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtg
-aatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcg
-cacacgttacttccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaatt
-cacgagtttaacaaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaa
-ctactcgaagatgtttcgttttcttaaccataggggcttcttaatggcccactacgcaca
-ttttgttcaagcccgagagggacatccccattacgggagtattactaaaactgttccgta
-atacgttcagcaagggatgaaaaaggccactgctcaagttattgacgtgggagtattaca
-tcggaagcctgaatcccacactatgatggtctgtacaggcctagggactgcgtctagacg
-gtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaaggctcacaccta
-ccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaata
-aagacgtggcaaaaacccccgcacataagccgctttagatttcacaaataccaatgcggt
-taaaaacatccttgagtcgtacatacaccatactcgcgttaaacggatataacagaagat
-aataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaataatgcttacca
-gtcatttagctatacggctttcatttcatgtcaagagggtggagtttgacctgtacagtt
-gatatatcaccgatacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccg
-catattacaaacaatagatgggattcattatacataagacacgatgatctgctttttcag
-gttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtat
-tgacagggaacctattttcgaggtattatatagtccagcttgaatatcaatttgacagtt
-aacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaaattctacgggtt
-atcgtctagtccaactatcaattataactcacgagatataagtaaattctcgtacttggc
-ctgatttttattatactttggatccttagtaaacaggaagggagaaaccttcaacgaaaa
-acactggattttgttttactctcaaagctcttatatgacggaaataccctgtcaagtctt
-aactttattactagactaatgaaatgggcttggggtggccagaatcatagtacaatttag
-cggatacactattcggactttcctatcggctgtctggttggataagtatggggactaata
-ggctagacatacctatacttaaactatacaggcgtcatctatctctgcaactttggagtt
-ccctgatgttctcccgccctttgggttcacatcttctataccgacacccctaataacgat
-tagtttgtgggttagagtaaattaatacggttaatattaatgtatcgttgaaaagctggt
-gtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtataactaccctaatg
-ataagctgtaggaataaaattaatgctgtctctaagcgaagagatatttccgactctgtt
-ttaatgacgaatctcattacttctgacttgcaaatgttcaatatggcacggtttcacggc
-acctttgtgacgcatataatgaacttagaagattataacgacggaactttatatgataat
-ccgttacgattaaagaatctgttaaatatcataatggcattcagttctagaccgtgcatc
-atggtaaacttactttctctgcatggcgacatacatttcgctattcaaattcgcgtgtgg
-ttacacccactcgcacctttggaatattaagagaagatgatcagaaaatccattcgctca
-atttttctgacgtacgtctaatttatcctaggagacaaatcgttttatgtctctcacatt
-tttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaagatactcggtgg
-agcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttccaagttcagtta
-agtgaatatgtttaacatacccggcttttcgatcttaagctgacgctggacgtgcgagta
-atgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacgccccctcccttc
-tcgagcccactcacgctatgtattgacgcgaacttgttcgggatcagacttttcaggagt
-tcggtcgcgtgtccctatgtgctaatatataagttagatcgcattagatgctaatctgaa
-tacttatagacgaccttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaa
-acgacaggtagggacatataaaatttgagtgcggctttagttaagggtttaattacctac
-tcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgt
-actaggtagtgattaatgatatcctagacgcacgtgccttagatcttcagactctgatgg
-tccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaatt
-acgatatctaaatacttataatacaataaccaaggatgagaatgactcatcgcgttggag
-ttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcccaatatctccag
-tgagctaattcattggacggtccactttgatcaatccccgaggagatgttcggacacttt
-agtctgtaacacttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttt
-tccaaagttcattttaaataagactacgataggcctttcctattgatataaactacccgg
-ctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatagcaagattcgatt
-cttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcataggatctaagca
-aaattatcaagttgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcc
-cacgttgatagtatgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtac
-accggatttgcatcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgat
-atttagcaagaggcgttgataaagccctcatcatctagatctcgacctcatctgccctct
-tgctccatcattttctacacagactactttcctatctacgttagtataattgctttctat
-cttagtatcatttagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaag
-ggacaacttgtagcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaa
-gaagtttgtcattctattagacattgaattgcgcaattgacttgtaccacttatgatcga
-acactgaatcaagactgtgattaactaaaatagacaagccactatatcaactaataaaaa
-cgcccctggtggtcgaacatagttgactacaggataattaattggactggagccattaca
-ttctctacaatcgtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaa
-aaaaatgctttcgcaggagcacattggtagttcaatagtttcatgggaacctcttgagcc
-gtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgaga
-gggaattcaccggaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgt
-ttaagagttaccagcttaatccacggtgctctactagtatcatcagctgtcttgcctcgc
-ctagaaatatgcattctatcgttatcctatcaacggttgccgtactgagcagccttattg
-tggaagagtaatatataaatgtagtcttgtctttacgaagcagacgtaagtaataatgac
-ttggaataccaaaactaaacatagtggattatcatactcaagaactctccagataaataa
-cagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaa
-cgctaattcatttgttattggatccagtatcagttaaactgaatggagtgaagattgtag
-aatgttgttctggcctcgcatggggtctaggtgatatacaatttctcatacttacacggt
-agtggaaatctgattctagcttcgtagctgactatactcaaggaaccactgctcaaggta
-ggagactagttccgaccctacagtcaaagtggccgaagcttaaactatagactagttgtt
-aaatgctgatttcaagatatcatctatatacagtttggacaattatgtgtgcgaaactaa
-aattcatgctattcagatggatttcacttatgccttagaaacagatattgcccgagctca
-atcaacagttttagccggaaacaatcgaagcatagggacaatgtatcttttcctaaattg
-ccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactc
-gttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaat
-aactgaaagaaacgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacac
-attagtgaatatcggccaatgaaccaaacgcttcccggtacgctatctctctcatcggga
-ggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaac
-ctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtccgggcgtactcct
-ccatggaagggcgcgcatctagtgttataccaactcgctttttaactactatgctgtagt
-tctacaggcatagtggccagtattttctaacttctctggatagatgctctcactcctcat
-ccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatggaggcattaagt
-atcttcactgttccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagc
-tcaagcacactcattgaatactgccccagttgcaacctcacttaatctgacaaaaataat
-gactactctaagtgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtat
-aggcatgtaactcgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtg
-tgtgacaccaggtaattgatgcggatataagctggagatcactcacgcccacacaaggcg
-ctgctacctctttattccaatgtgtaagaatttgctaacttcatttctagaccgcagctt
-tgcggtcataatttcacggtacggacccttgggttagagacttgataacacacttcgcag
-tttccaccgcgcacatgttttagtggcttctaacatagaatttttgttgtgacataaaga
-gtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagccccgtgagtcaca
-tctaattggttgtactgcgcatttagctatcctttagctgactcgaagagattcgattcc
-taatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcag
-atctgcataactcgcgcttaattacttatgagtagttccaagttcgctacgttatgagag
-agattggaattaagcaaatatgttttatggtgattttgggatgagaaggactgctaagta
-cggctactaaacaaatttctaaaaccgccatctaccttatcttggagacatttaagttgt
-atatgtcactagtctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaag
-agccgattcatcaaatgcttatctaagaaagtagtggactattacaccaagcacgaatgc
-cagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaat
-tacatttggtcagcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcag
-ctcacccgcttgctctagatcttatctttgtatgaatgtcagaatttactgcaatatccg
-ttccgaatagtgagggcttagtatagttctctgtatacaggtcacatcaaactccccctg
-tcctagtacagctctgagctttaattaattgcatacatttccttcaatcatcagatgaaa
-acaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaacaactagcccgac
-tcacgttcatccgccgtatccttgttcagttcttactccgtattaggtcagcgaaatcta
-atcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacg
-ctgagcagttatcggctattagatagtggggtgaaagtaattggctggaattatgttaaa
-acgtgatattaagctaaaatacgctacttgttgccgacctaattcagtcattcgatattc
-agttagagccaagaataacaagcttgtataaattgaacggggtgcactaaacgatgtgtt
-actctaatattcagcttggagtatacctgaaggcgaattcatgtatcggccaataataag
-acgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgtggggattgagtc
-cactgtacgagtacggtctctggaaaattataggttcagggaatataaggaagtaaagat
-aattaccaagagatttttggtatcgctatgacccagaggtgttctaacgtctgttttgat
-ccgcagaatttctgcctcaatgcatatttgacggacttgaactagagcctctaaagttaa
-atggcgacgcaactgttcctaaacttcaattattactactctttttttcctagggtattg
-tagaggccagtggacaaaataaatcaaatttaagatgtttcggacattaacatcccccgt
-agcatagaaatcatcagttatccaatctctcatcgagcttttacaatttctgctggcgct
-atggacagcatatgccgcgagacctccgcaagactcacttgatcactgtaagtatcttca
-ttagaggttagagcctatagttaagctgctgacctagtaaaattggtattttctaatttt
-attgctcaagttaaaggttagtgaagggataatgacgttatttttgaacaatgggttgta
-ttcaattttatatcacgaatggaacccttcattcccggcataatactagacgacacgaac
-aagctccgatctatcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagca
-tcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcaggactacttattacc
-tattaataagttaacatgagccttcataccccgtaagacaatacatactccaccaattag
-aattctgagccatcttatctttttgtatcatcgaagggtatggccgaataggttaattag
-ttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctc
-gccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttccggattaccaaac
-gcggcaaagagaaacattgtatcgacggagataacttaatacagaaggaaggggcatctt
-cgaatacggatgaataattctatctgtttattctgacatcttgttttcaggttaatctta
-cgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaatattgacgagagca
-atctcactccttttgggtctatttatgttttattgaggcacaagcctatacagaacaggt
-actattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttgg
-tacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgg
-gctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgacc
-gaattcatccatgtagattcagatcacacactcattccttgatgttgtctaaacaaaagt
-tgttgtggacgcattggagggagttaagtaacaacttgggatcgcatacttataaaaatt
-atatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagt
-cactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgt
-accaaatcgaaagaacacttaataaggcttgcttgcacggaggtatgatgtttactgact
-ctacaaccctaattttccagtacgtacattcattccaataggttagttctcaaagtgcta
-tacaggctcctcaattgatgatatgcttcagccgctctatggatattagctcattttatt
-taggaagcccgcttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtg
-tgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctctcccgttcacta
-ccatacttggtaccgtgcgcatattacatatagatataggatcattttttaaagctgtac
-taggtttgatcgacaatcttatgctatactatatgatgtaaccctcataatcaataccga
-tcgtacgatcctagcataggtggcaagcgattttatgccgattattgtgttaaatagtct
-gtgagtgtgattatcagggctacgttggtagaggggttgtatagacctcgcacacattgt
-gacatacttaacaatatacgaaaactgatataataaatccccttacccaaacaccaatcc
-cgttgaatcaactaccataacgtctcccatataaattgcctacttgtttgcataaatctg
-aatacataacaccattgcaccttcttgtgttccaatcccgttaagattgccttgtcagat
-gatatgcaagaacaatagcatttgctagcaattattaacagctcttcgaattgcctccac
-ataacgcgggagggtatattttaatttggcaaatactaagtactgttggcgtcatatgct
-attaacggttggatattaagttatgtcagccgtaagcaagagtgggcgaaatattttgtt
-acccagtgagagcactcttagagtttggatacaataggccatatgttgacttaagaggac
-gtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaa
-tcttaagaatagagacacgttcgtgttagggtatactacaaatccgaaaatcttaagagg
-atcacctaaactgaaatttatacatatttcaacgtggatagatttaacataattcagcca
-cctccaacctgggagtaattttcagtagatttactagatgattagtggcccaacgcactt
-gactatataagatctggggatcctaacctgacctatgagacaaaattggaaacgttaaca
-gcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgc
-gtaacttcactatagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatg
-aatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccc
-cttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttg
-agcaggtccgagcacatggaagtatatcacgtgtttctgaaccggcttatccctaagata
-tatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttgtgcgactccacg
-tgcatgcccagaaatacgagtttaaatttggttacatggttaattttgaccgaagcatcg
-cactttatgattgataattggattcaatatgtcgccctatgcgaatgcaacatgatccac
-aatttggctataagacgtttaatccgtatcacactttgtttgcggctagtatagtaacgc
-ccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttcaaatataaaaac
-taatcaaacacgacccatatgatcatctgaagatatttggaactttctcgacaaccaccc
-tcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatatt
-gagtcaagatttgcttagtggcgatgagcgtacacgcttatttctctagtcacaattagt
-tatctacgagacatcacgagggagcaaataagcgatgttatggctacacataggcacgta
-tgaatatgatataagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacc
-cacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccc
-caacgtaaggatcaactagaagagaaaactcggtattagtttaaatgcgtcacggagcat
-gagtgcatttcactaagaatgtctgtgtaaccaatataacatctatttgttatctgattg
-cctacttatggctttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtacc
-aactccctttaaattacgctgtgcaggctcatgcactgcatacatatacggtagcaggta
-gggacctcacgcacccttattataatcaatagtagttatcagtcaacgaggcaggaatgc
-tgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactatcacgcattacca
-ggcgagatttaagccaattttgaatatagtcaacgtaatttttactatgggttccaccga
-aacgccttgcacaactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaa
-taccttcatatatattttttcggttgactaacgtgaactaaggttaggggttttgtatgt
-ctatataggaaacagtttcttttctgtcctactttagtaaagtcttcaagccttactcca
-aaatcacggtgattaagccgttactcagcagcatgattctgcctgctcgggtcctaaaat
-ccagccttgtaagagtcgctgtgtattagctagggagacctttgttaaaaaggatatatc
-gcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatct
-ctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaa
-aatattggtacttgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagag
-aattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggcttagaagactcc
-atgatttaataaatactacgaaggaaagactggatctaaagataactctagtaaggccaa
-ctcccttcaatgctgttgccagttataatccaagagctgtccttttctgaaccatagcgg
-cttctgaagcgaactagaagcaaagttggttctagccagacagccacataccctgtacgg
-gtgtattactaaaactggtccggtattagttcaccaagggaggaattaggcaaaggatct
-aggtatgcaagtcggagtattacatccctaccctgaatccatcaataggttcctctgtac
-tggccttcgcaatgagtattcaaggttgtacagccgtataataataagatagtgactatg
-aacgggaagtaacccgctcaccttccccaaaacattgttatatctaagtattaaagtctg
-ccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcacttaagccgcttt
-tgatttatatttttccaatgcgcttttaaaaataattcagtcctacatactaattaagac
-ccttaaacggagatatcacaagttaagttttaaccatctcgactaggtggaactatagat
-acccaactcaatttatcattacctgtaatgttcctagaaggattgcatttcatgtcaaga
-cggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaatcacctaaaccta
-ttagtcagagcacccggttagaaccagttgtcaaaaaatagagcggttgcatgagacaga
-agtaacgatgagatccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcc
-cttaaaaatatttttaaatactaggcaaacccaacataggttagtcctatgtgatacgcc
-acatggtatatcattttgtaacgttacctagggataatcaggaagtggaattacgcaaaa
-gtagacagtgaaatgcttagggttatagtctagtccaaagataaaggataaagcacgtca
-gagaactatattagccgaatgggaatcattgttaggagactgtggatcatgtctaaaaag
-caacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgat
-gaccgatagtacctgtatactagttactgtattacgtgtctaatgatttcggattggggt
-ccccagaatcagacgtcattgtagacgattcaagtttaccaatttaatttcccagctctc
-cttggagaactatcgccaataattgcagtcactttccttttctgaaacgataaagccgtc
-agagttctctgcaacgttggacttacctgaggttctaacccactttcggttctaatagta
-gttaacgacacaacgaataacctttactgtggggctttcacgatattttttcgcttatta
-ttaatggttacgtcataagctggtgtccaaattaaggttaccggcttcgcagagtagttg
-tatccaagtataacttccctaatcataagatcgaggtagaaaattaatgctgtctctaac
-cgaacagatatgtcccactatgtggtatggacgttgctaattacttctgaagggaaattg
-gtcattatggatacgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttg
-atccaccgttctttataggataataactgacgattaaagattatggtaaatagattaagc
-caattctcttcttgtcagtgaagcatccttaactgacttgctctgcagcccctcatacat
-ttagctattcaaagtaccggctcgtttcaaactctcccacctttggaagaggttgtcaac
-ttgataagtatatcatttacagcattttttcggacgtacctctaatgtttcattgcagaa
-aattagttttttctatcgcacattttgcaagtaacgttagagacacaattatctgcgaat
-gaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatca
-aggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccggcgtttcgatctt
-aagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtctgtctccaaggg
-tcggcaaaaaagacccctccattctcgagcccactcacgatatgtagggacgacaacttg
-tgcggcttatgaattgtctggactgcgggcgagggtccatatctccgaagttagaaggga
-catacctttagatgataagatcaattcttattgacgaaattcatccacaacggggaacaa
-cttcaccctagacttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccg
-tttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcga
-caagatagaggctatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtg
-cctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggcataaaactccag
-caatttgggggccgaaaacaaatgacgttagctaattaattatatgacatgatcaaagga
-ggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaact
-tttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcctagttgataattc
-cccgagcagtggttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaatt
-ctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcag
-ttcctattgatttattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgt
-ttatgattattgctactttagatgctgactgttaactccgtgttgtttttcaaccgtata
-tcacaaccgaattggatagaacctatagtttcaagttctgccacaaggtatcatatttac
-agttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtaga
-gctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtgatagcacatatac
-cacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaacacatattattat
-tgttatccaactaatcggacctatgcataaagcattgtctaaacagaataattgcctata
-tacggtagttttagtgatttatatcttagtatcagttagagcttcgaactcttcaggttc
-ctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttcca
-agtagtacctataaatcacagaaagatctgtctcagtatagttgaaatggtattcagcta
-gtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaacgaatatagaca
-agacactatatcatataataaaaaagaacatggtgctcgaacatagttgaattcaccata
-ttgaaggggaatgctgacatgtaattcgctactagacgatcaattccctacttgtcaaag
-ttgaactggtacgttcttggaattaaatatgattgcgctggaccaaattgcgacttcttg
-agtttcagggcaaacgattgagccggaggatgtccgtctcttacctttcttgcttatgat
-aaacgacggtccctgtacatcactgggaattctcagcaaaaataattgggtaaatcgaga
-ctcgatgtattcggccacaaaggtgttagacgttaaagattattcaacggggcgataata
-ggatcataaccggtatgcaagcgcattgaaagagccatgagatccttatccgataaacgc
-tgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaa
-gttgaagacctaagttataatgaagtgcaataccaaatcgattcatagtggattatcaga
-ctcaagatatctcctgataaattacagttgttaagatacggataaaatgagatttaagat
-tagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagtta
-aaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagt
-taatatgtagcttacgttctagcttgtgctaatctgagtatagattcgtagaggaatatt
-atcaagcttccacgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagt
-agcgtaaactatagtctagttgttaaatgctcagttcttgttatattcgatatactcttg
-gctaatttatgtctgagtatataaaattaatgatattaacttgcatttcacggatccctt
-agaaaaagattttgaccgagcgcattataaacggttacaccgaatcaatagaagcatacc
-caatagctttctttgaatttattgcctgcgcaacttggctgactctctagatccgaataa
-ttctatatggtcgtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgg
-gccgataatggctctttgcaaaattactcaatgatacgattgatcaaagcggtagttgct
-agtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttccaaaagagtcca
-cgtaccatatctatctcatagcgacgcgaggggaaccttatctaactatcattccattta
-ccgggtgactctcgatgcaggatccgattgggataaattgcccagaaatggctcattcct
-gactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggcttataccatcta
-gattgttaactacttgcctgtagttctacagccatactggacagttgtttctaaatgatc
-gggattcatgctagcactcctctgaatgcaccgcgtaagtttaactattacgtccgtggg
-cagataaggatggaggctgtatgtatcttaactgttacctaatatggctggtaattatca
-aagtaaggaccttaatgccatagcgctagcaatcgctttgtatactgaccatgtgccaac
-ctctcttaatctgtaaaatataatgtcttagctaactgtggacgatcatgtctctgccta
-gagcttcgctgtatcaattcctatagccagcgtactagtgacacaacaacaccgtgtgag
-aaaagatattagtccttacgtctgtctctctacagcttattgatgaggattgaacatgga
-catatagctccccctcaaaagcagatgctacctctttattccattctcgaacatttgccg
-aacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacgtcacgtcccttt
-gagactggataaatatattaccaggggccaacgagcaattgttggaggcgcttctataat
-acaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatatt
-aatgtgaaacccccctctctcacatcttatgcggtgtactgccctggtacatttcctgta
-caggactccaacagtgtagattcctaagatagctgttggagttgcctcacgccagatcga
-aaaactgaataaactagtgagctgagctgcagaaataccgcttaattacttatgactagt
-tcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattt
-tggctggactagcactccttacttcccctactattcaaatgtcgtaaacagcatgagaca
-ggatcgtgctgacatttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcg
-ttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctg
-gtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaa
-gcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaa
-aaaatatttttaagcagtaggcacctaacccgattcctctacttagtagctttctttgat
-tctcagaattgactgcaatatcactgcacaattctgtgccattactagacttctctgtat
-taacgtctcatcttactaacactcgcctaggacacatctgagagtgaagtatttcaatac
-atttactgaaatcttcagttctaaaatccccgaataaggctcttatcggtttggccaaca
-caagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaa
-taactatttcggcagacaaagcttataacaagttgccggcgcgtataatatttaaaagac
-cccttgagctgctcaattaaaacgctcacctggtataggctattagatagtgccgtctta
-gtaaggggcgggaattatcggataaactgatattttgataaaataaccgacttgttcacg
-acataagtcactaaggagattttatctttctccaaagtatatcttccttggataatttca
-aagcgctgcaatttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgt
-agtaatctagaggcaaattataagaagttcatcatatcattttcgactacaaaaacaagg
-tgttgtatgccggcgcattgtgtaaactggacgagtaccctagatggaaaattatacgtt
-aagccaagatttcgatgtaatgataattacctacacatttttgctatccataggaacaag
-agctgttctataggctcgtggcatacgaacatttgctgccgctatgaatattggaagctc
-ttcaactacagactctattcttaattgccgtcgaaaatgggccgaatcggctattattaa
-tactcggtttttccgaggggattgttgtcgacagtcgtaattattattaatattgatgtt
-ggtgaggtcatttaaatacaaccttgcagacaatgaataagggatccaatctctcatact
-ccttttacaattgctcatgcccctatgcaaaccttatgccgccacacctccgcaactctc
-tcttctgaactgtaagtagcttcattactggtttgagactatactgaagctgatgacatt
-ctaaaatggctattttcgaatgtgattcataatgtttatcgtttgggatggcagaatcac
-gttatttttgatatagcccgggtattctattgtatagaacgtatgctacaagtcattccc
-cgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctt
-tatttcccgataacctatcttccataaatagcggacagcaggatactgacgctcaacatc
-agtggttatggtctaatttttaacttttaataaggtaacttcagcaggcatacacagtaa
-ctctttaatttataatcaaattagaagtctgacacttcttatatttttctatcatccaac
-gcgatcgcccattagcttattgtgttactaataacgtatctaaaccaatccttttcaagc
-tactgcctatattgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattg
-tcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagacaacgagtgaaat
-ttatacactacgaagggccagcgtacaagacccatgaattaggcgatatgtttattctga
-catattggtttatccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaatt
-ttttttcgaagattcacgactgaaatataaatacgtttggctatatttatgttggaggga
-ggcaatagcctttactgttaaccgaagatttagccagtgagtgtgacactaaaacactgg
-aataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatat
-agctctggatataattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaa
-gccggcctctcatattgaaggtccgaagtattccatgtacattaagatcactctctcatt
-catgcatcttggcttaacaaatctggttgtccaagctttccaggcacgtatggtacaaat
-tcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagt
-aaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaat
-acggttagaagggattagttatgttacaaatccattgaaaacttaagaagcattgcgtgc
-tcggagggtgcatcttttatcaagagactaacattattttcaacgacgtacatgctttac
-aatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccg
-atatccattggaccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtatt
-gccataatgtaatacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaat
-gaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgatttcatatagata
-tacgataagttggtatagctctactaggtggcatccacaatcgttgcatttactatagct
-ggttacaatcataatctataccgttccttacatactaccatagcgggatagcgttttttt
-gccgttgattgggtttaagaggatgtcagtctcattatatccgattcggtgggagagccg
-ttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaactgatataagat
-ataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatt
-tgactaattgggtgcagatttctcaattaataaaaaaatggcaccggatgggcttacaag
-ccccttatcattcacttgtatcatgatttccaagaacaatagaatttgctagcaagtatg
-aacagagattcgaattgcatccacagtacgccggagcgtttattttaatgtggatatgac
-gatgtactgttggcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaag
-catgtctgggagaaatatggtggtacaatctcagagaaagattacagtttggtttaaata
-ggacttatcgggtcggaagtggaacttaataagcagtacacaattgggcaacagacgtct
-tgcctattacaataggattacaatgcgttagatttcagacacgttcgtgtttggctattc
-gtcaattccctaaatagttagacgatcaactattatcaaagtgattctttgttcatcctc
-cattcatgtaacagatggcacactacgcataacgccgaggaattttaacgagatttaaga
-gagcagttcgggcacaacccacttgactttataacagctcggcagcataaacggtaatat
-gtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaactaagtggttcatg
-ttcaacagatgtgacgcagcaagcctaacttatctattggttttgctataaaagaacaaa
-gttacacagaatcctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaa
-tagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactc
-cgggtatgataatggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggtt
-aggataaggatgagaccgaacttatttccggccataactttagattttctacctagtaca
-caacatcagggcggacacgaaaccgccatcacatcatataccaggtttaatttgcttaat
-gggggaagtgtcaacgaaccttcgaactttagcaggcatatggccattatatatggcccc
-agagcagaatgctacagcagacaaaatttggatttatgtagtttaatacctatcaaactt
-ggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaattattactactc
-agcagcttctgcaatgataaaatcttatcatacacgtcacatatgataatatctacttag
-ggggaacgggctccacaacctacatagtactcaatacttacactattcgacaggcacacc
-aaacctgtacagtcccaaaagattgagtcaactttgcagtactgcagatcacagtaatag
-cttagttagcgagtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgat
-gtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaactgtacaacctt
-agagataagtctcaggctactaaaaacacgttgtggcactaacaggatcatggttgattc
-ttacttattcggctgaccggcccaataagtaaccttcaactagaacagaataatcgggag
-tagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagt
-taaaatcgttttcttagcggattccctacttatggatttgagctcgtccacaatattcga
-tacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaa
-ggaattaatagaaggttgatggtaggctccgaacgctccatgattataatcaagtggact
-gtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccct
-atacgagtagataaaccatgaacagcacagtgtgaacccatggttgattttaggctacct
-tatttttaatttccgttacacagaaacgaattccacaactaacatgccattaatttttcg
-atatcttataaaagatggtcgaaattcattcatttattttttttcggttctcgaaagtca
-actaagctgtcgcgttttgtttctctttagaggtaaaagtggctttgatctcctacgttt
-ggatactagtcaaccattactccatttgatccgtgagtatcacctgtctaacatccagca
-ttatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgtattagctaggga
-cacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccccagtagatttat
-tcagctagtgtaagtataagatatctcacccacgaggttcaagtgatatgcagtcttaga
-ataatacttatcctgaatttcgatattatgggtacttcaataatccgctagcgctacttt
-atgtctcgttggacagcaggacacatggcagtcttaaacactaaagacatcacctgaatg
-aatgtaatgggattacaagaatcaatgaggtattatatacgacgtaggaaactctggata
-tatacagtaatctagttacgccatcgcacttcattcctctggaaacttagaagacatcag
-ctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaagttgcttataca
-aacacacccaatgacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaa
-acccagcatttagcaataggagctacgtatgcaactcccacgtggtaataccttcaagct
-atcaatatataggtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccag
-tataataattacagaggctctatgaaacccaactttccagctaaaagtcccaattaaatg
-gttatttcgtacttttaaagtcgcccgttctgttattacgcgaattgattctactccaaa
-attaaacacaaattatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataag
-gctctactaaattataattaagacacttattaccagatttctctagttaagtttgaacca
-gctcgactaccgcgaaagatacattcccttctctatttttcagttcatctatgggtcaga
-gaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcag
-tgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaa
-aagactgccctggaaggagtaagaagtatacagctgatccggtgtatccttcagtcatct
-gccctatactaattacacgacgcaaggaaaaataggtttattttctaggcaaacccttca
-taggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggata
-ataacgatctccaatgaaccaaatgtagaatgtctattgattacccttttactattcgac
-ttagagataggagatagaacctcagtgtacttttttagccgaatgggaatctttgggagg
-tgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgtt
-cgtggaatcgataacagatttgttgacccatagtaaatgtatactagtttatgttgtaag
-tgtagattgttttccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagtt
-gaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgta
-agtgtaggtttagataaagccgtatgagttatatcataagggcctcggaaagcagcttcg
-aaccaaagttcccttataatagtagtttaactataaaagtatatactggtctgtcgccct
-ttcacgatttgttttaccggtttatgaagcgttacgtcattagagcggctccaatttaag
-gttaacggcttccatgtgtagttgtatacaaggataacttaaagtatctgttcagcgagc
-tagttaagttatcctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttg
-ctaatttattctcaaggcaaattgggaattatcgatacctgtataccataaggtcgctcg
-atgtgatgcttatgtcttctggtgatcctaccttagttagtgctgattaacggaacatta
-atgtttatcgttttgagatttagccaattctctgattctaactcaagatgccttatctga
-cgtgctatgcagcccctaagtattttacattgtaataggacacgctcctttaaaactcgc
-caaaaggtcgttgtggttctctactggttaactatataatttacagctttgttgagctag
-ttcctctttggtttaagtcctcaatattagttggttcgagcgataagttggctagttacc
-ttagtcactatattagatccgaatgttatgcttcatctgaagaccgccaccctccaaaat
-ttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtg
-tatctgtacacgagtttccatattttcatcaacagccaccgcacacttatgtcactctag
-gtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgctagtcaaaaata
-aacatagcgaggcaccactaattcggccgcttatcaatgggatgctctgcgcgagacgcg
-ccagagctcagtagttagttcggacatacatttacttcagatgatcaattagttttctac
-aaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctttagtatccttcc
-gtcttatataaggtcagtcccccgtttcggtaccctggaatttactaagaataatgaaac
-agcccccaaggacgtacgtttacaaatgatagaccagatcgcctagcttattccgacgca
-tgttgcatagaattgaaccaacggaatgtgagagtaactagatgagccgaccacagcacc
-cgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatgtcctttgagtat
-taagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctcggatattcaggg
-aacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaa
-tgcctacctcatagtgctgaattaacacagcactgcggacctaacttttcgaggtttcaa
-gttcacgtctcaaaacctaataggctggaatatgtagggatcctcggtgaatttgtgatt
-gggtttgttgtagtactgaccaagtgaatattctttttttctaaaagcagatctgctgcc
-gggcactacgaaggagatctctgtgtatcattattgcttcttgacatgatgactcttaaa
-tcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacatattgttgatact
-tcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaaatactggtgact
-tggtcctatctactattagctagacctctggggaaccacgcccccgtaaaacctgtgcaa
-gagagggggtcatacatcttagacatcgcgcctccaccagggaagcattgggtgattgac
-caggtgtgtaacaaatatgattattcttatactaatattagcaaagatgcataatgattt
-gtattaaatgtataattgaattgataagggtcttttagtcagtgatagagtagtataagg
-tagacattagaactcttaaccggacgcagatttttcggtcttagtaagccaattagtcga
-caaaacaaggtaagagcggttactagtagtacctataatgcactgaatcttcggtcgaag
-tatagttctaatgctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaa
-caagctcttgtaagtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcc
-tacttattaggggaattaaccagattgaaggccaatcctcacatgtaatgagataataga
-cgataaatgaaattcttgtaatagttgaactgctacgtgatgggtattatatatgattga
-gatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccc
-tcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcactccgaagtataag
-caataataatgcgggtaatccagactagatcttttcggactcaatgcggtttcacggtaa
-acatgattaataccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgcc
-aggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttg
-tttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaagtccattacctt
-ttagtttcagactggtggagctgactaaagttatatcatcattttgtacactggtttagt
-taacgataatttcagatttaacatgaccagacgataatcgctgtatatccagttggaatg
-tggtttgccagaaaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatc
-ccatccattgcgctatacctcagtgtatttggagctgtagttataccgtgtgctaagatc
-agtagacatgacgagagcaatattatctaccttacaagcatcaacggacgtctagtcgga
-acaaaagactctaaaactcgaacttcaggttaatatactatagttctgtattcagcagtt
-attcttatattcgatattatcttgcctattggatgtctgactttagtatattaatcatag
-tatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaattataaacggtt
-acaaccattaaagacaacaagaccctatagctttatttgaattttgtcaatgcgcaactt
-ggagctcgcgatacatcccaattagtctatagggtcgggacgattctacggcatttctgg
-ttataatgacaacatggattgtggcccgagaatcgctctttcattaattaagcaatcatt
-acagtcttataagcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgag
-ccgaatagcttaaaaaacaggccaccgaacattgatagagaataccgaccacagcgcaac
-ctttgattactttcattaaattgtacggctcactcgacatcaagcttaagattgcgataa
-tgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcagaaagcgtaccca
-gagaagatacgctgttacaatatacagggtgaaattattgcctgttcttcgtaaccattt
-cgccaaacttggttagaaatgatagccattcatgatagaaataagctgaatgataccagt
-atctttaactatgtagtcagggggaagataacgatggtccatgtatgtttctgatatgtg
-acagtattggccgcgtaatttgctaacgaagctacttaatgcctttgagcttcatataga
-tttctttaatcaaaatcggcaaaaagatagtatgagctataatatatgctagtagagaac
-tctggaccatcatctatatgaatactgattcgagcgtgcaattactttagcctgcgtact
-actgactctacaaaacactctgagataagtttgtagtcagtaagtcgctctctataaacc
-ttttggatgaccattgtacagccacttatagatcccaataaatagcacaggagacagagt
-ttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagggcacctattatt
-tgatacctaacctaacggccctttcacaatggagaaatatatgacatcgggacaaacaca
-aatggtgggtggccaggagatatgacatggtggcgtctctaagaaacacggactccctct
-aggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtg
-taatgacctggtacattgactggtcaggaatacatcactgtagttgccgtagtgtcctgt
-tggtgttccatcaagacacatcgtataacgcaatttacgacggacatcagatcaagttat
-acagattatttaagtatcacgtgtgcattgggacataagggatctcacacatgccttgga
-acatttttgctttgtgccgctttttcgctgcactaccaatccttacttaccagtatattc
-aaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcgattgggatagac
-gagacatttgcgagcgccctccacggatacgaatctcccatatcaatgtgaactggatgc
-tatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcag
-ttattcagaacctaatacacaaaaccgtcaaacattttctaattctaggtatgggccgat
-cataggagctaaggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgc
-atatactgagtagctggcgtgcattctctcaattgtatcctttttaactgaactagtcgg
-tcccatttcgtgactgagatctattaaccgataagattaataacactcgcattcgtatca
-gctcagagtgaagtttttcaataatttgactgatatattaacttctaaaataacccttta
-agcctcggatccgtttcccaatcacatcaaaaattcttattccaactatctacggattaa
-caacgtgcatggggatcgtagtaagaacttgttccgatcactttgagtatatcaagttga
-cggcccggttattattgaatagaaacattcacctgctaaattaaataccgcacatcggat
-acccgatttcagagggccgtcttactaagggcaggctttgttcggtttaactgagatgtt
-cattattttacagtatgcttcaactaatatgtaacgaaggacagtggatctgtctccata
-gtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttga
-tcatggcacgtgaaagcaacccctagtattctagacgaaaattttttctagttcatctga
-taatttgccaattcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcg
-aacctagagccattatttgtcggtaacccatgagttccttcttttcagaagttaatacac
-tgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcataacaacattgga
-tcaagatagcaatttggctacctattctaattctcactagattcggtattccactacaat
-atcggcagattaggattggatgaataatcggtgtttaagtccggttgcgtctccaatctc
-ctaatttttattaatattgatcttggtgacctattgtaaataaaaacttcaagactttga
-ataacggtgaaaagatagaagactcatttgaaaatggatcatccacagatccaaacatta
-gcaagacactaatccccaactagctattctgatcgcgatcgtgctgcagtactcctgtca
-caatagtctgttcatgatctaattctttttgggctttgttcgatggtgattcagaatctt
-tatccggtcgcttccctgtagctactttgtggggatattgcccggggattatagggttga
-gatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactacatcagaacatcg
-tgaagacaccatacgcggtacctttatttaccgataacatttcttcaagaaataccggta
-agcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaattttatttaggt
-tactgctcaaggaataaaaactaactatttaatttataataatattacaaggctcacact
-gattagatttgtctataagacttcgcgatcccccattaccggattgtcttaagaataaac
-tagataaaccatgcattttctagataaggcctttagtctaattagatacaaaaaacacga
-tagttgcatccttaatttattgtgtcaaacctggaaccttttaattacccgcaaatcact
-ttatgtcgagactacctctgaaatttattatctacctaccgcatgaggacttgaaccatc
-ttgtaggagttatgtttattagctaagattcgtttatcctgtagcggtccatgtatattc
-aacaagcaaaaagcactcagaattgtttttagttgagtcaagactgatatataaataagt
-ttccctagttttttcgtggtgggacgatattgaattgaatcttaaccgaagagtttccca
-ctctgtcgcacaataatacacgccaatatttccagccctgcttatgccttaatcggttac
-tcaatctcccattgaagttcattttgatctgcatagaagtttcgggcccagccttttttc
-tgccaccttcctccaagctctgtagacgcactctaagattgatgctcacatgtattaatt
-ctacattaacataaatatataagtcatgcatcttcgagtaaaatatctggttctccaaca
-tgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatgattgggttaact
-ggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgta
-ttcctcgtgctcggaagggctattacgcttacttccgttttggtatcttaatatgacttt
-caaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagtt
-gtttaaacgaactacttgctttacaataccggtcgtatatatcgccgtgaatccagaaga
-ttgtcttctttggattatcaaccgagatcctgtggaccgatgttttgggaccttcacaga
-ggactccaggtagagctcgcttttgcattaatctaagaattgtacctctctaaaagatct
-aaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaattactttaggccga
-aaggcacatgagttattatacatatacgagatggtggtatacatcgaattcggggcatac
-actatagttgcattgtatttagctgctttaaataatatgatattaccttccttacataag
-acattaccggcataccctggttttcaacttgtggggctttttgacgatcgcactctcatt
-tgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaa
-tagattacttttcgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaa
-gtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaa
-aaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatcttgatttcattctt
-cttgtcaattgccgacataggatgaaatcagattccaatgcaatacacagtaacccccac
-ccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggcc
-ttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgtacaatctcacac
-atagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaactttattagaag
-taaaaatgtgggcaaaagaaggattccattttacaagacgattacaatgagttacatgtc
-tctcaacgtagtctttccctagtagtctttgaactatttaggtactccagaaaattttag
-caaagggtttctgtgtgaatccgccattcatgtttatgatggaacaataagaataacgcc
-ctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatattcaatttagtaca
-gatccccagaagttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtct
-aattactatactaacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagt
-gtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttag
-gacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatg
-agcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacac
-ataatcgaactattgatagtcgggagcataaccaggtgaacgtactttgttcacgacatt
-tattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatca
-ttgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgagaactttagctgg
-cttttggccagtatttagggaccaagagcactagccttaagctgaatattttgccattta
-tctactgttataactttaaaacttggtggcaccagacttgtcgatacacacgcatcaatc
-tgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttatattatatttaaac
-taaaagatgatattagcttctgagggcgatagggctccaaatcataaagaggaatatatt
-attacacgattagaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttgg
-cagtactccacatctcagtaatacagttgggagagtctcaaatgttgttttattactcaa
-tgaaccaccctcataatttcactgctgttccattaaatttgcaaacgatcatttgctttg
-aagaaacgtaaaatcgacaaaattacagataagtagatgcataataaaaaaaactgctcg
-ctataacacgatcatcgtgcattcttacttaggagcatcacccgcacaataacgtacctt
-aaactacaacactattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaa
-agaacttgctctctcgtaaaatgtgataatagtttgcggagaggattcaattattttcca
-ttgcacctactccactagattcgataaaagaaggtggtcctcccttaaaaagaaatgtta
-agtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatccttccctaagaaaca
-taaaggtttttaataatgtcgactgtgaactataactgcatcctttcctgacctactccg
-gttccttgttgttatttctgaacgagaccagtagataaacaatgtaaaccacagtgggta
-ccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcata
-atcttacttgaaattaattttgccttttattttttttcaggctcgaaattaatgatttgt
-tttttttgaccttctagttacgctaatatgcggtcgcctgtggtttctattgagtcctat
-aacgggatgggatctaatacgtttggttactagtaaacaaggtataaatttgataccgga
-gtatcaactgtataacatcaagctttatgactcatacgcgaagtaatgacacaaggcttt
-caggagatcgcgagtacagagccactaaggggtgtattacgatagtgacaccaccgagcg
-cactcactccccaagtagatttatgatcctacgctaagtattagatatataaccaaagag
-gttctagtcagtgcaactcttagaataataattagccggttttgcctttttaggcctaat
-gcaatattcagctagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtt
-taaactaatcaaatataatctatgaatgttatgccagtacttgaataaatcaggtttttt
-ataagtccttgcatactctcgttatatactgttagagtcttaccccatagaaattctttc
-atctgcaaacttagaagaattctcagctacggggagcataaagtccccaggatgttgaca
-aatacaacaaatgtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagtt
-ttagccgaaccttgtacggataaatccctccattttccaatagcagatacctatcctact
-acctcgtggtattaaattaaagcttgaaatatagagctgcatagcttatccaattcccaa
-gcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagcaaacccatcttt
-aaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttat
-taagacaattgtttataagccataattaaaaacatatgttcaacaggttcattgatattt
-gtaattgcacaggtttttaataaggatctacgtaagtataatgaacaaactttttaccag
-agttatattctgtactttgaaaatgctcctctaccgccttagagactttcaattagattt
-tttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgc
-taaccctatcgtctgtctcataactgtaggtctaatataattttcagttttcgaacacat
-aaccctttgaaaatctgctatttaatgtctcacctgcatgcactatcttctatactgctc
-agaacggctatacgtcactatgctccaagtgacgatttaaacgaagcaaggaataatagg
-tttattttagtgcaaaacaattaagtgcggactacgtgctctttacaataagccttgtga
-ttgggctataggttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctt
-tgcattacccggttactagtcgaattacagatagctgttagatactcactctaattttgg
-acaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaa
-acgattacatattatagacttgttcggggtagagatatcacagttgtgcaaacattgtaa
-atcgatactagtttatgttggtagtctagttgcttttaccattccccgaaaaacttgatc
-tactatttcgacaacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagt
-gccactatttgtccactatatgtaagtgtagctttacataatccactatgactgagatca
-ttacggcctaggaaagcagcgtagaaaaaaagggcccggatattacgactgtaactataa
-aactagttactggtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaac
-gaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttctataaaacgata
-aagtaaagttgatgttcagcctccttcttatggttgcatcgagagtacactactcagtgg
-gaaatagatcggggttcctacttcagattgtattatctaggcaattgccgattgtgccat
-acctggataaaataagctacctacatgtgatgcttatctattatcgtcatactaccttag
-ggtgtcctgttgaacgctacattaatctttagccgtttgagatgttccaatggataggag
-tctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatt
-tcgaaacgagacgttataaatagaaaaaaggtccttctggttctattctgctgaactatt
-gaatggaaagattggttgacctacgtactatttgcttgaagtcatcaatttgacggggtg
-agagacatatggtgcatactttacggactctatattttagatcagaagcttagcagtctt
-ctctacaccccctcacgacataattgcttttaagaatctatgtttgattcctctacggga
-attcggatccgttcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagc
-atacgaacactttgctaactagacgtatgtatagtagctataaatcccgacgatatttac
-aaaaagaaatgagactcaaatatatacatagcgaccctacacttattcgcaccctgatct
-aggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgtattaaatttact
-gcagttgagattttagttgtctactaaggattactctaacccgtaataaggatcaagact
-cggtactagctttactatcattccctatgtgttttcctaactcacaagggtacgtaccag
-cctatgtaattacaataatgataaagacacaaaggaagtaactttacaaatgagtctcca
-gttacactagcttagtccctcccatcttgctttgaagtctaaatacgcaatctctgagga
-tatacagcagaagaacactcataacgttggagtccaagaattagactcatagggccccca
-acatttaatatgtactgtgagtttgaaggtgttctattgttaattcctgctcttgataca
-tgacacgtactccgtgtttaaggcttcggactgactttctttcataagttgagcaacgaa
-aatttcagaatcgataagttggattcactaactaatacggctgattgaaaactccactcc
-ggacctatatggtcgacctttatacgtaaccgatataaaacttataggctggtatatcga
-gccttcctagcgcaatttcggatggggtttcttctactactcaacaacggaatagtcttt
-gtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtc
-attatggactggagcactcttaaatcactctgcgtgtgctaaacgatagatcataacatg
-tcctgagtaaattttcttgatacgtcgcaatataccgttattagttaaacgttctcatcc
-gtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgactcatctcgcctaa
-cacgcacacgtataaactcggaatgactgccgctcttacatattagaaatacagactaca
-ccacggaagcattgggtcattctcaaccgctgtataaaagatgattagtcttataataag
-attaccaaagaggcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgt
-aggcagggagtgaggacgagatggtactcaggacaaatattaaccggacgaagtggttta
-cgtcgtactttcactattagtagtaaatacaaggtaacaccggggaatagtactaaatat
-aatgatatctatcttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaa
-aatgtgctgacttatagcatgatacaaccgattgttacttttgtctattcaaaagattga
-atagttttttatacaaaagccgcatacttatgacggctagtatacagtttcatcccctag
-catcaatgctatggacagtattgaacttataggaaattcttctaatagggcaaatccgtc
-gtgatgcctattttttttcagtcacatcctcaaatggcactagtattgtcgggatcccat
-taacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgac
-agcgacagaactcccatggataaccaattataaggcccgtaatcctctagacatcgttta
-ccaataaatccgctttctccgtaatcatgttgaataccccagagtagtccagatgataac
-cgatgaaacacaagtctttctcaatgcacttacggtgaacttattaccgccaacgtagct
-catcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactt
-tcgtatattcaacgccttgtaattttactttaagacgcctggtgatgtagattcttagat
-aatcagtttgttatcggctgtactttaccataatttcacaggtttcaggtcaagaagatt
-atagctgtatatacagttccatgctcggtgcacagaaacgtgatcggataataatcaatc
-gcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagtgtatttcgacat
-gtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagattagattccttaat
-agaatataccgacctctagtccgaactaaactatagataacgccaacttcaggttaattg
-tctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggccatattggttcg
-agcactttagtttttgatgcataggatatgcaatgtatagctgaaagtactttatctgtt
-tcaaactcacattgattaaaccggtaaacctttaaagactacaagaaaatattcagtgag
-ggcaattttgtcaatcacaatcttccagctagagatacttcacaatttgtcttgaggcta
-cgcaacattagacggattttcgcgttttattgaaataatcgaggggcccaagagtatcca
-tagttcattttgtaagatttctttacaggcttattacagcttcttcagactcctacatgc
-ttacgagttatatgctagcatgtgaacaatagattaatatacaggaaaacgtacattgag
-agagatgaccctacacagcgcaaccgttgagtactttcattaaagggtaacgctctcgag
-acagcatccttaagatggccttattgtcaaatcatttgcagaagtacgcaagatccctaa
-ccaacgtagaagaatccctacaaacacatgagacgcggtgaaaatagacagggtgttagt
-attcaatcttcggagtatcaatttcgccaatcttggtgagaaagcataccctttcttcag
-agaaagaagatcaatcataacactatctttaacgaggtacgcacgcgcatcattacctgc
-ctccatggatctttaggatagcggaaagtattggcagcgtattgtgatttcgttcctact
-ttatcaatttcacattcatatacatgtcttttatcaaaatcgccaataagataggatgag
-ctatattagatgctagtagagttcgcgccaacatcatcgataggaatactcaggacagcg
-tgataggacttttcaatccctaatactctctataattataactctctcttaagtttggag
-gcagtaacgcgctctatataatcagtttgctgcaccattcttcagcctctgatacataca
-aataaattccacagcagtaagagggtttaattgagacatcttgggaacttaggattttac
-tctaacatcaccgaaacgattattggataccgtacctaaacgaactttctcaaggcagta
-atataggacatccgcaataacacaaatgctgcctccccaggagttatgtcttcctggagg
-ctatatcttacacccactcactataggcaaactaaagtttaaatgttgattgtctaaaaa
-aaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattc
-tctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcctttaaagctattt
-acgacgcacatctcagcaagttataaacatgttggaagtttctagtcggaattcccaaag
-aacggatctatctaatgcattcctacatttttcctgtctgccgatggtgccatcctattc
-aaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaaccttacgcctct
-aagggttcctcgagtgccatacaccagtcaggtccgagccacatacacggagaacattct
-aacatagcattctcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaa
-atcatacttgcaatcccatagcacggattaagaacctaagaaacaattcagtaaaacatg
-ttcgaattcttggtatgggaacatcattgcagctatggtctaacgcattaatgtttgggt
-acatcttccatcatataaacaggaagagtctgacgacagggagtgcttgcgatcatgtct
-atcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataaga
-tttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatat
-atgatctgctttaataaaactttatccataggatacgtttccaaatcaattcaataatta
-ttagtcaaaatagataaggatgaacaacctgaaggccgatcggacgtagaaagtggtccc
-atcactttgagttgatattgttgaaccacacgttattatggttttcaaacagtctcagga
-tattgtatatacagataatccgataccagttgtctgacgcccctcttacgtaccccaccc
-tttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaactaatttggaaag
-aagcacagtggatatgtctaaattcttgttattcaggcctgaatttaatacaccgcatag
-ttaacttcgcggtagagttgttcatcatgcctcctctaagctaccacttctatgatacac
-caatagttgttctacggaatctgataattggccaagtcataaacttccgctgcgttcaac
-ccccttgctcgaatatccaactcgaaaagacagccttttggtgtccggaacaaatcagtt
-acttcttttctgatgttaattctctgtggtcagatacagaccaaaaactccgcggattta
-ccatcctccaagaacaaatttgcatcaacatagcattttggctacatattctaagtctca
-atagtttaggttttcaactacattatcccaacattaggattggaggaataatagctgggt
-aagtccccttgcgtctacaatcgactattttttatgaatatgcttctgccgcacctatgg
-ttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatgg
-cagcagccaaagagcatataattagcaacactctaagaacattatagatatgatgatagc
-gatcgtcatgatgttatccggtcacaatagtagcttcatcagctaattcgttttgccagt
-ggtgacttgcgctggaagaatcgttatacggtcccttccctcttgatacggtgggggctt
-attcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagt
-caactatactaaatcacaaaatagtgatcaatacatacccgcttcatggttttaaccatt
-taattgattaaagatattccgctaagaaccattatctacctaaactgatcgccgtatcct
-agtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgta
-gaataataggtcttggagctaaatgatgtgattggtagtgaagacttacccttacaactt
-taccggtttctcggaagaatatactagagaatcaatgcatgggctacataagcactttag
-tctaatgagataaaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaa
-cctggtaatttaaaccatatatctttatgtcgtcaataactctcatatgttttatataac
-ttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagctatgaggccggga
-tccggttgagctacatctatttgctacaagaaaaatgaaagcacatttgttgggagttct
-ggctacactcatagagaaataagtggcccgagtgggtgcggcctgcctccatattcaagt
-gtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcctttatttcctcc
-acggagtagcccgtaatccggttcgaaagagaccattgaagttaattttcatatccagtg
-aagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatat
-gattcatcctaacttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcg
-agttaattttcgccttctccaacatggcatccctacgttcgttataaggaccatacatgt
-aggttttaaaggtttgcggttaatcgatatttacatcatagaaattctatagtcaaattt
-acaagactctagatactcactcgttgcagccggctaggaagcgctttgtaccttacttcc
-cttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactcatacctccgtgaa
-gagggtagatagactattaaagttgtttaatagtacgtattgatggaaatgacccgtagg
-agatttaccactcaatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcga
-aacatgggttgggtccttcaaacacgaatccaggtagagatacctttgcaatttttcgat
-gaaggcgaccgagataaatgagctataacactgtatgtcttttgattgctataaaacaca
-gaaacggatattaatttaggccgtaaccaacatctgttatttgacatagaacagatggtc
-ctttacagcgtattccggccttaatattgaggtccagtgtattgtcctcctttaaagaag
-ttgattgtaactgacttaaataagacatgtcacccattcactgggttgcaactgctggcc
-ctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaag
-acataaatgtcgctatgaaggttattcattaattttagctgttttcttagaaaaggtaaa
-tttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgg
-gcatcattgagattgtaagaaataaagccataaccagccccggaatagaaaatgttaagg
-aaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggac
-attgcaataaaatctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtc
-caccatgtgcagaggataacggaatgtggttccgtcccataaacgatcattctcgcccac
-ttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggc
-taccttctccaactttagtacaacgaataatgtccgattaacaaggagtcaatttgtcat
-gaccagttcattcaggtacttgtatctatacggacgcgttccagagtagtatttgaaatt
-ttgaggttctactgataagtttagctatcgctgtatgtctgaataagaatttaatgttta
-tcttcgataaataacaattaacaactcctaggtgatacactgtgaagtctgctgttcccc
-aaattacatatgctattttgttcacataccatgaagttaagctaagtgctctataatggc
-ataaacggttatcaaactagctcgaatttcttttattacgccggaagcggattaactgct
-gtagatcaaacacgttaggatagtgtcgttttcatatatatctaaattcggtctaacatg
-cattacccatgcttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaacc
-aaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgactacccggatcttta
-gcctttagggtctaaacagaactaatattactacgtgtcatactccggagcttaaccagg
-tgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtatcaaattaaccca
-gcaatacaataagcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcga
-aaacttaatgacatagtgtgatgcattttgcactggattgagccacaaactcaactagca
-ttatgctcaatatttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagt
-cttgtagttacaaacgcataaatctcgaacgtaataggtttaattagaacatccgtagga
-tttctgtttatagtagatttatactaaatgttctgattagattctgacggccttacccat
-acaattaataaagacgaatatattagttatagtttactatccaaataaattaagcgaatc
-gaaataaactgtcacgatactgggcagttatcaacttatcacttatacagttcggacact
-ctatattggtctgtgagtactctatcaaactaactcataagttaactgcgcttccattaa
-atttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatgacacatatggag
-atgcataataaaaaaaacggctccatatttctcgttaatcgggcattcttaaggaggagc
-atctcaccaaaaataacgttcctgataagtcttaactattagaccgtcttcgggaatgaa
-cgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattctgataatactggg
-cggacagctggaaattagttgccagtgcacctacgcaaatagtttacataaatcaacggg
-ctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtct
-accgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataac
-tccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactg
-aaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtg
-cacggaataacataacaaggaatattatttattcaaattttttgtgactgttatttgttt
-tctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtcc
-acggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgtcctttagactat
-tcaaggtagaattttgataacgctctataaaaggtagaaaatcatgattgagcaataaga
-ccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgta
-tttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttatgatcagacgcta
-acttgttcttagagaaaaatacacgggatactctgtgcaacgatttcattaataaggtgc
-agcttgggacttttttggccgtaggctttattaacattcacagtaggtagcgagacttcc
-tatgaaccaatcatgccacgcgttttaacgtttcaaatataagctaggaagcgtttgcca
-ggacttctataatgcaccgttttttttagtacttccttactagccttagtttatgttaga
-gtctttccaattacaaaggattgaatagccaaaatttctacaattctcagcgaacgccag
-cttaatctaaacacgagcttcaaatattctacatatcggcaggagtcaatatataaatat
-gaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataattaaatccttttt
-caattaccacagtacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtc
-ctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttc
-tgacgctagagcttaccattcgttaaacagataactaaaatttaatggctgagtgactta
-gtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatttttaaaaacata
-tgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtaccatagaagtatg
-tataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcac
-acttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaactctacaaggcatg
-ggatgagattctaccgactccggataacactttacgatcgcgcataactctagctcttag
-ataagtttaacttgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatc
-catcctctatcttctataatcatctgaaccgcgatacggcactatgagccaagtgaagat
-tgaatccaagaaagctataattggtttattttagtccatttaaattaagtccggtataag
-tgctctgtacaatatgcagtctcatgggcatatacgttaactaccttttgatacttcgaa
-ttggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaattactctttcct
-gttacatacgatctcttagtttggacaactagcccatgatggcgctcctctagcgcatga
-acctactttataattacatctttatcgatgaatttttttagactgcggaggccttgagtt
-ttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttg
-gaacaggcaccgaaaatattgatctactattgcgtcaactctattctgctaatagcgatg
-gcaaatcacagaagccctcttagtgacaatagttgtcaactatatctaagtcgaccttta
-ctgtatcaacgatcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaa
-aggatttgtcgacggtaaatataatacttgttaagggtagcgacacaggtatactttggg
-tgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttccggtaaccagga
-aatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactccttcttttcgttg
-cagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttcagatggtaggag
-ataccatttggcccattgtgactttacgcgattaattaaccgacatacatctgttcctga
-gctatgatcgtctgaataaattacggtctcctcttgatacctaatggtttctggagacgt
-ttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagctacgcagagcatc
-aaaatatgtatgggaaagtcgatttccaaaccagaagggataaagagaaataacggactt
-ctccgtagattagcctgatattttgatgggaatcatggcggcacatacgtaagagttgcg
-tgaacgaatattttggacggcgggagacacatatcggccattcgttaaggtctctatatt
-ggacatcacaagcttagcagtatgagctactaacactcaagacattattgattttttcaa
-gatatgtttcattcctctaccgctattcccatacgttcgattcgccgggtgagcgaaacc
-acgggactgaggttaagctaatcaataacaactcgttgcgatagagacctatgtatacta
-gagagaattccccaacatttttacaaaaacaaagcagactaaaatagatacagtccctcc
-atacaattaggaccaacatgttattgccgatcctagcacacacaccacaaactcagaact
-tctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaattagcattaata
-ttaaaactaattaggataaactataggtacgagctttactataagtcactaggtgttttc
-cgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataaagaaaaaaagga
-aggtacgtgactaatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaa
-gtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataaagttggactcca
-tcatttagaatcatagggaccaaaacatttatttgctactgtcactttgtaggtgttcta
-ttctgaattcctcatattgatacatgaatcggaatacctgtggatcccttaggacgcacg
-tgctttctttacgtcagaatacatattgtcagaatcgagaagttccatgcaattaagaat
-tcgcctctttgaaaactcatatccccacatatagggtccaccgttattcggaaacgatat
-aataattattccagcgttgagcgtcccttaagagcgcattttcgcttggcctttcttcta
-cgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcaccccatagaacta
-cctctgagagcgcgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgc
-gcattaaccagtcatattaaaatggactgtcttaattgtcggcattaggagcaatattaa
-ctgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagata
-cgattacagactcagatcccctaacaagcaaaacgattaaatcggaatcactccccctat
-gacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctcaaccgcgcttta
-taagatgttgagtctgagaattagatgacctaactgcaagaatcatggcgagtttatcta
-gtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggactt
-agatgataaccaagaactggtttaccgagtactttcactattaggagtaattacatgcgt
-tcaccgcggaatacgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttg
-cattgcaacagtcgctaccagtaattgctgatcaattatagattcattatacagatgctt
-acttttctctattcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgc
-ctagtataatcttgcttccacttgaatcaatgcgatggacagtattctactgattgcaaa
-gtagtctatttcggcttagcagtacgcatgcctatttttttgcaggcacagaataatatg
-caactaggattctcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatct
-acgaagttgatgtttactacagaaagcgaatgatatcacttggagaacattttagatgcc
-cccttttaatctagactgagtgtaccaatatatcaccggtctaccgaatcagcttgaata
-aaccactctagtactcatgataaccgagcatacacatgtatttctcaatgcactgaaggt
-gaactgtttacaccataccttgcgaatcaacgtggcgacttatacttctgtctttgagta
-cagcacaccctaatgaatctaagttagttgttgatacgaattgtaatttgactggatctc
-gcctcctcatctagattcttagagaagatgtttcttatagccggtactgtaactttattg
-atctggtttatggtaatcaacattttacctctatttaaacgtccttgcgccgtgcactca
-atcctgatcggtttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcac
-agagtaagctctctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaa
-ctctcattgtgttgattcagtaatacaagattacctacgcttctacgaaatatactatag
-atttagcctacgtcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtgga
-ctgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtcgatatcaatggg
-atacctcaaacgtctttatctctggataactcacattgagtataccggtaaaaatttatt
-ctattcatctaaatagtcagtgagggctagggtcgcaatcacattaggccacatacacat
-acttaacatgttctattgacccgacccaactttagtagcattgtagccgtttatgcaaat
-atgccaggcgccaaacactagccagagggcattttgttacatttatttaatcgattatta
-cacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtcaacaattcagta
-atttaatccaaaacctaaagtcagagacatgacactaaaatcacattaaggtcagttagt
-gaaggaatggctaaccagctagagaatgcatcattaacaggcacttattgtcaaatattt
-tccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaacacatcagtcca
-ggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcg
-ggacttagcagacactggatgcagtcatagaagatcttgcataacacgttagggttagag
-ctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaa
-cacgtttgtgatttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaa
-aaatcgcaattaacatacgttgacctatttttgttcagagttcagttagagcctaatgat
-tcgagagcaataatcaggacagcctcataggaagtgtcaatcacttagaagctatattat
-tataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaac
-tggcttaacaatatgatacataaaaatattttcatcaccactaagacggtggaattcaga
-cttattggcaacttaggatgggactattaaataacccataagatgttgggataaagttac
-gaaacgaaagggatatagcctgttagataggaaatccccaataaaacatagccggcctcc
-acagcagtgatctattccgccacgcgatatctttataccacgcaatataccaataataaa
-ggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccg
-tatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagcttcctctgcaaga
-tacaatatgactttttagcttttttactaccaaatctcagaatcttagaaacaggttggt
-acgtgctactcggaattcccaaagtaccctgctatatatgccattccttcattggtccgg
-gctcaccatggggccatcatagtaatagaaggtagtaaaactagttgatttccgactttt
-aacaatcactatcctgacccagatatgggttccgactggcccttactccagtaagggcag
-acacacagacaacgagaacttgataactttgaattctcaaatcgatcattgcaacgtgac
-ttatttactagcctactcctataattcatacgtcaaatacatttcaacggaggaagataa
-taagtaaatattcactaaataatggtcgaaggagtcctttgccaacataagtccacatat
-gcgctatagattttttcttggggttcatattcaataagataaacagcaagagtatcacgt
-cagcgagtcattgagatcttggctagcattgtgatagcatattctacctaaatggtagtc
-tagcacagagtggataagatatcagttagatatagacaagtactataacagatctcgctt
-cgttggattgtatggctagctttgatgatatgattttataaaaattgatccagacctgac
-ctggccaattatattcattttttatgagtaaaaatagataaccatgaaaatactcaagcc
-ccttaggacgtacaaagtggtaacataaatttcaggtgttattctgcaaccacacctgtt
-ttgggttttcaaaaaggctaagcagattggttttacagataatccctgaacactggtatc
-tcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaa
-ctaggcggaaaatatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaac
-gcctctttggattacacagaatagtgtactgacacgtacactgctgcagcagccatacgc
-taacattaaaattcgttgagtctacatttgttgttattcggattatgttattgggaatag
-tatttttattcccctgcgtgaaaccacatggatagattagcctactcctaaagactccct
-tttggtctacggttcaattctcttactgagtttatgttcgtaattatatcggcgcagtga
-atctcctaattatcaccggagttaccagacgccatgaacttatggccagaaacattgcat
-gtggcctacataggattagtatcaagagtttacgtttgcaacgacatttgaccaacttga
-ccattcctgcttgtagaccgcgggaactcccctgcacgcgactatagaagttggtggtgg
-atgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaat
-tgagacatgtataagggctattgccagatgaaaaactgcatataaggtcaaacaatataa
-gaacattatacataggatcttagcgttcctcaggatggtatacgctataaagtctagctt
-cagcagctaaggagttttgccagtgcggacttccgctggaagattaggtttaaccgccct
-gacatcttcataaggtcgggcctgattcaaacccctggagtgccgtctcatacttgaatt
-aatcgatggaaaacttcttctagtctaatattattattaacaaatgacggttcaataaat
-aacaccgtaagggtgggaaactgttaagtgatgaatcattttaacctatcatccattagc
-tacagataatgataccccgatccgactagggggtaagtggttgttccgttaggataaacc
-atgtaaaacgttagagggtttgtagattaattggtattccagataaatgaggtcagggcg
-agtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaat
-gaaggggattcagaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcat
-gatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatatttatcgagtcta
-taaatatctttggttgtatattacttcacaatcaccaattctaaatgattcttccactgt
-gcgggtggagatatcaggacgggttaaggttgacctacatcgttttgatacaacaaaaat
-caaagcacatggctggggacttctcgatactatctttgagatagtacgggcaagagtggg
-tgacgcctccctacattttcaagtctatcggataacttctcggtaaaacgctcgcgatat
-agttttaaagcattgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaat
-tcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggttatccaaaaggaat
-aaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatgcgtatggttctg
-atatatagatcgatgcatgaggacactttattttagccggcgaattaatggaatccatac
-gttacttatttggacatgacttctaggtgtttttgctgtcccgtttagcgatatttacag
-attagtatttcgtttctcatagttaattgtatctagatactaactcgttgaagacgcata
-ccttgccatttgtacaggacttaactgttccgtgcgtaatttgaatttcttataggttct
-tcaaggcacgaatacctcactcatgaccgttcatactctagttaaggtcgggaatactac
-gtatgcagggaattgtaacctaggagatttacaactctttaaacaagagtcgctgaggtc
-caggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatcacctagaaaccta
-ctcatacatttgcaattttgagatgtaggcgaaagagagaaatctgctttttaacggtat
-ctcttgggattccttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctg
-ggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaa
-ggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaa
-gtaaagggggtgaaaatgctccccagggttctacagacatagagatggtcagaacacgac
-ccccctctcaacgcagtgtatttgaaatatatggacatatctaccttattctgtaatttt
-agatgtgttctgtgtataccgatattgataagtcaataggcttgattacgtatcttaaga
-caaatctgtttcgcaagtaggaccgcatctttcagattgtttctttttatgccataacct
-gcccaggaattcaaaaggttatcgatacccgatatgctgtgaattattattctaatggcc
-actcattcctgcttatatctggaattggcatgaatatcttacaacctaaagtctggcgtt
-gcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtc
-acataaaagttcattagaccacactttgtgccgacgtatatagatatattacacgtatag
-ggaatgttttctcctaggtgacccgaccttctactaaggttgtacatcgtataatggccc
-attaactacgaggaaagtggtattgacctggtaatgcacgttcttcgatatataccgacg
-aggtaaagtctactattgcaaagtttgacgttatactgataagtttagatttccctggat
-cgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaaatccttggggat
-actatcgctactatcatcggaccaaaattaaataggctagtgtcttatcagaacatcatg
-tttaccgaactgatctattttccaatttaagctgatattacgtccgcgtatttattttag
-ttccccggatgacgattatctgagctacatcatacaagttagcatactcgccggtgcatt
-gatttcttatttcgctatatcttcaagttcacaggcttcatatagttccaattagcagta
-taattaggttttgtaactttaaccatactttataaaaggttatattgcacaactgatcaa
-gcatccgctataacccgagctttaccagttagcggctaataacaaataagatgacttcgt
-gtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggt
-agtaataagtataaaatgataccacatatactataacaatgaaattatttgtaatccggt
-ttgccaacgtatcccccttcgcgataaattaatgacatagggtcatccatgtgccaatcg
-tgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgttataagcgttga
-aagtgatataggccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttatt
-gctggtagtacaacatcacgagcatttctcttttgagttgatttatactatatctgctga
-tgtgattatgtcccacttacccagaatattaagaaagtcctagattgtaggtatacttga
-ctataaatataatttaagactatacaaataatctggctacattatgccatcgtagaaact
-gataacgtagtaacgtcggacactagattttggtcggggagtaatctagcatactaacga
-atttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgttt
-agactattaaggactcatttcgagatccagtattaattatacgcatccatatttatactg
-aagacggattgagttaggacgacaagctaaacaaatattaagttaaggattagtattata
-ttgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgttacttattcagag
-agacttaattcggttatgactggcagctcacctggaaagtaggtgaaaggcaacagaaga
-atattgttgactgaattctacgggctacgaacgtaattacaaagcggttcgtaaagagca
-taaagatcaatacaatggatctctacagtattacgtaaataacatacataaacctggtgt
-tgattcgactagctcatagattaatcattaattgaagctacgaagacgcggaagtctgcg
-gagtgagcaaacagtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatg
-gtgtacattaacgtgggggtagtcaaaggaatatatttactaggaatattagttatgcaa
-atgttgtgtcaatgtgatgtgttttatccagacattggatgcatggctgtgggggcacag
-gatacttaccattagttcacctacaagcggcgtgagagggtctcagttttagccagcgca
-gagaagtacgggcctttagacgattaatgctagaattgtcataaacctcgtgaaaagcta
-gttaataatcatggtgctagaagaacacaacttttctataaaccagttctcgactgacag
-tcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaa
-atctactgggtgcatcagtagagatcgtgttctgagagataaatacaccggatacgatct
-gcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtagcattttttaaca
-gtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggtttaaagtttata
-tgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcc
-tttatagactgagtgtatcgtacactcggtacaattacaaaggatggaagagcaaatagg
-tcttcaattataacagtaccccaccttaatctaaaaaccagcttcaattagtattaattt
-cgccaggagtatatatataaatatctaaagactaaaagactcgtacttttacaacttacg
-tcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattagaaatactccttt
-gtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgatta
-aggcctataaaactgttgttggtatctacagagtgattaaaattagtgaatcagattacg
-aaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggct
-gtagtagaattttggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaag
-cggtttttgttccatagaactatgtagttggttataaaggttgtaatctcggagattagg
-ttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatg
-agttcacgaactcttaatgccatgcctggacaggataaacaatacgcatataacttgacg
-atcgagcttatatcgacctatttgagaagtttaacgggtcgatataatatacaggtctta
-atagccgattttttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtga
-acgatatatcagcaaactgaacattgtatacaacattcctttttgtccgggtggggactc
-catttaaagtatctcacctagaactcagcggtaatagatgcagtctcttgcccagttacg
-gtaactaaatgttgatacttagaattgctaaattttagtctagacatttccaggtaaacc
-ggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaat
-tgagggccctactatagacaatcatcagactttttaattaaatagttttccatgaatgtg
-ttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgtatgactgtagtcg
-gtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttctaagatggacta
-taatcgattaggctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttgg
-aatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacc
-tatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagc
-ctagagacaaagggatactgggcggggaaacctgctccttcacggtaacatggtaacaac
-agaatttggttaaggttaaaacgaaatatactcggagtgaattactgttaggtttcgtca
-tcggatcaataagtagtttccgtgaagacactcttatattagatctccgaaattctgacc
-cgtgcattaggcacttggtaggagattccatttggaacttgctcaatgtaagccagtaat
-gttccgaaataattcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttg
-ttaccttatggttgagggtcaccgttctctgcgtcaattccagagctggagatacattca
-tcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaa
-cggatttagacaaattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcat
-ggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttcc
-gccattaggtaagctatatattgtggtcagaacttgaggacaactatgagctactaaaaa
-taaacaattttgtcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagt
-tacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatcaataacatatagt
-tcagatagagaacgaggtattcgacagagaattacccaacattggttattaatctatgca
-gaataatttagataatgtcactacataatattaggaccaaaaggtgattccccagaagac
-aaaacaataaacaatctcacatattcgctagtacctatgtatgggtatgatcttctgatt
-ggacggggataatttccaggtatattaaaacttattaccataatctagacctaagagagg
-ttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagta
-aattttgctttaacaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcag
-gtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaa
-ctaatatcataaactgccactacatcttgtacaatcattcgcaacaatacttttatgtgc
-taaggtcacgtgcttcctctgctatgctgatttaatcagattcataaaggaatacgaata
-actctggatccattaccacgcaagggatttatttacggctgattactttttggctgttga
-cagaactgccatgaaagtaagatgtcgcatcttgcataaataatagcacctaatatagcc
-gacaaagtgattccgataacagattttaagttgtccagccttgagactccatgaagaccg
-cttgggagcttccccgtgattagaagaatctaaatcccaagtggatggggggagtttaaa
-tctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcc
-tgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaag
-tgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaaggaagcacgcat
-tgaagcagctacgcagaactgagaagatgacactctaagatacaattaatacaaaaacgt
-tttaagcccaatctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatg
-tcccgatgtataataacagctttatttctgctggtcgaggtgaagtagtggaaattactc
-catcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcgtccatccctctc
-tcctagtgatccgtatatccaattagaggataaccaacatctgcgttaccgacgaattta
-aatttttcgactatttaattccgttcaaacccgtattcgtagtaagtgtttcatagattt
-atgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaattgctgatctag
-gatacatgctttataaacatgcttacttggctattttatttactgtcatgtgggggtttt
-tattttcaacaagtatgtgctaccattggataatctggcttcaaattgaagatatgcgtt
-ccaaacttgtctactgtttgctaagtaggagttgtcccattagaactacgcagcacgtgg
-tttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaatttaatgcagatt
-actcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatag
-aaattcgtgataatttttgttccaacctttgaatctagactgagtggaaaaagatttcac
-cgggataccgtttatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaa
-tggatttctcaatcatctgtacgtcaactgttttaacaataacgtcagaataaaccggca
-caatgagacggcggtctttcactacaccacacccttaggattataagtgacgtgtggatt
-cgaattctaaggtgacgggatctacaagcctcagctacattaggtctgaagatctttcgt
-atagccgcgtatgttactgtttggatatgggttatgctaatcaacagttgacagcgagtg
-aaacggccttgcgacctgaaatctttacggttaccttttgattcaagacaggatcgacga
-tggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaac
-gacaagttcacatcctctatgcaactatcattgtggtcattaaggtattcaagattaact
-aagagtcgaccatatattctagagttttacaattaggaaccgttagtctagactaggagc
-gtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgacacatagtgtctt
-ttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgggataaataacat
-ggtgtttaaccctattaatggtttctattaatctaaattgtaaggcagcccttgggtcga
-aagcacattaggccacatacacagtatgaaattgttcgagtgtccagaccataattgact
-accatggtacacggtgttgctattatgactcccgcaaaactcttgacagagggaattttg
-gtacattgatgtaatcgatgatttaacagtaggaactagacgtcatccgttagactgagt
-tccgacatgctcaaattgtcaggatttttatccaataactaatggctctcacatgtaaat
-aaaatcacattaacgtcacttagtgatggattcgctaaacagatagactatcattcatga
-actggcactgtttcgattatatttgcaacatcgaacatacttaaagttaaatacgacatc
-attcaattaaaaaaattcagtacacctctaatgagtatcccgctttggaggaaagagtag
-cactttaaatggacaatttaggccggactttcctgtaaatggatgaagtcattgtacagc
-ttgaataaatcgttagggttagtccttacatccaccatatgttaatgaataaagcctgag
-ggaccttagagctaacttgtccaacacgttgctcatttacttaataaggttgaaatgtat
-cagtaagtgacagcgagtgtagattttgaccatttaactgaccttcacagttttgtcttc
-agacgtcacttacaccataatgatgacagagcttgtagatgcacacactcattcctagtg
-taaatcaagtagtagctagattattataaagagatattttctggcgtcgaacgtaacaca
-gagagagtataaggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaata
-tcatctaactcggtggaatgcacacttatggccaactgaccttgggacgagttaagatac
-cataagaggttgcctgtaagttaagataacaaagggatattccatctttgtgtgctaaga
-acctatttatatttgcagccataaaaacctctgtgctatgcagccaccagagttatttat
-acaaagaaagagaccatttagatacgttaattctgcttgcgatttattaaacagacattt
-cacgtccaaccactacaaaagccctatcgcaagacgatcattgtattatagcctatgcaa
-cgtagctaagcggccgaggaatcataaaatatgaattgttacattgtttactacatatga
-tcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaactaacctgagata
-tatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtagg
-aaaacttctggatttcccaaggttataatgctctatactgaccaagagatccgttacgac
-tcgcaatgaatactctaagggcactcacaaagaaaaccactaattgataaatttcaatga
-taatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcat
-agaaatgtcatagcaggaacataattactatattttaacgatttaatcgtagttggagtc
-ctttcccaaattatgtcatcagttccgatttagatgttttcgggcccttcttagtaaaga
-agttaatatccaagactagctcctcacccacgcatgcacatattcgcgagaagtctgata
-gaatattcgacagaaatgcgactctagctcacactcgttaactgatcaggtacttataga
-caagtacgttatcagatatcgcttcggggcattgttgcgctacctttgtgcatagcagtt
-ttgaaaaattgttcaagacctgaacgggaaaatgatattatttttttaggaggaataata
-cagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaacatatatggcacg
-tgttattcggctaacaaaactgttgtgccttttctataaggataagcagattcgttttaa
-acatatgacctgtaaactgggatctacaaaagaggtacttaaaataaattgcgcaacggt
-ttagatctgcggatctttggttaaagagcaccattagatgtgccatacttcctatcgcct
-gagcgagaatttagtctgaggaaccactcttgggatttaaaacaattcggttaggacacc
-tactcggcggatgaagcaatacgataacattaaaagtcgttcagtctaattttggtcgta
-gtacgatgagctgatggccaattgtatttttattaacagcactgaaacaaaatggagact
-ttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatc
-ttcggaagtatagcgccgaagtgtatctcattattataacaccagtgtacagacgacatc
-taattatggccagaaactgtcattgtgccattaagaggattagtagatagtctggaccgt
-ggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgca
-cgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttac
-gattctagtgcttcttaacgcaattcagtcttctagatccgctattccaacatcaatatc
-tcaatttaaggtcaatatatataacaaaattagacagagcagctgacacttacgaagcat
-cgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagtccgcacttccga
-tgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccact
-cgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctactattagtttatta
-tgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaat
-ctttgtaacagttcataatgttgctaaagattatcagaccccgtgaagacttcgggcttt
-gggcttcgtaccgtagcataatacatctatatagttagaggcttgcgtgttgttgtgcta
-ttccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcga
-cctacttgttaagtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgt
-atttattatactgtaggcaagaagcttttttggcgagatttaagacttaagcctatggta
-aaaatttgatagtgagcgactatagtaagagatttgggtggttagtaattaaaattctcc
-tatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccg
-aaagcgtgtggattatacaaatttcaaacatattggcggggcacttatccataatagatt
-tctgtttgtacgccaaactctgcctcacccctccataaattgtattggctagaggttaaa
-ttctccgtaaatagagacacatatagttttatacaattgtttgaatcaaagcacgagaaa
-cttttaaccgtacattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaa
-atcaatcgctgagcaataagcaagaaaacacagattatacaaagagatctggatgaagat
-attcgtgcaatcactatcgttatgttagagagttccatgcatgaggactcgttttttgac
-caggagaattaagccaagaaataactgacgtatttccaaatgaattctacgtgtttttcc
-tgtcacctttagccagtgttaaagatgactatggagtttcgaataggttattctatagac
-attataacgagtggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcag
-gtagttcaagggattttaggttcttaatccaacgaagaaataacgcatcacccgtcattc
-tattgttttcgtcgggattacttagtaggcagggtattctaacctacctgagttacaaat
-ctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtcc
-ctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgacttcttcccctaaca
-cagaattctcagttttatagctatctagtggcattcctttttataaaactttacgtttgt
-aagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagactt
-ggaacccatgtatattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaag
-caaggtatgttctaatctaacaatgtaaagccggggattagccgccaaaggggtctaatg
-acatagagatgctctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgac
-agatcttccgtattctgttagttgacatctgtgctgtctttaccgattgtgatttggctt
-tagcagtcatttagtttcgttactcattgctcgtgcgatagttccaccgaatatggcaca
-ttcgttctttttttccattttactgcaaaccttttcaaaagctgatcgataccactgatg
-atggcattgattagtcgattggcaactatgtcctgcttatatctccaattgcattgaata
-tagtaaaaaataaaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaac
-tcgtttaaccaagcgccgtacctaacatataagtgattgagacaaatagttctccagacg
-tattgagatatatgtctcctataggcaagcgtttctaattgctgaccagaaattagaatt
-aggttgttaatactatattcgaccattttattccacgaatgtgctattctactggtattg
-ctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaa
-tcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggtatctgccatattg
-ttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaaatattaatgagg
-attgggtcgtataagaaaatcatcttttcagttcgcagatttttgccaatttaaccggtt
-atttcgtcagacttggtagtgtagttacaagcatcacgattatatcagctacagaattaa
-actgtcctgactcgacggggcagtgtgtgagtattgcgctatatattcaaggtaacagga
-ggcatataggtcatagtacaaggataatgaggtttgctaactttaaaaattattgattta
-acggttgattgaaaatctctgcaagatgacgctagaacacctgatgttcaagtttgccga
-taataacatataagatgaattactgtctttagaccctcatgttaatccgctaacttaggg
-cggaaacaatgttaggctatgcggagtaagtactatattatgataccacatagaatttaa
-cattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaa
-ttacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaaggttcagctatt
-ttggcaatgggtgagtaccgttcttagtgatttacgaacccataatctaggcgacttaat
-atacaagatttagagttacgttttccgggtagtacatattaacgaccatggatcgggtga
-ggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccagaatattatgttt
-ctactagagtgttcgtatactggaatttaaatattatgtaagactagacaaattttatgg
-atacattaggccatcgtagaatatgatatagttgtaacgtccctctatagattttcggag
-ggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggatttgtaattaact
-gatgcgcagcgcttaaataagtttagactattaagctatatgttcgacagcatgtagttt
-tttttaccagaaagtgttatactgatgacccatggaggtagctcctcatgataaaaatat
-tgttacttaagcattactattatagtgttcaaactagtaccgttgcatactttaagaatc
-agacatggcgtttcttatgcagacacacttttttagctgttgacgcccacctcacatcca
-tagtaggtcaatcgcataagaacaatattctggactgttttattacccagaagaaagttt
-tttctttccggttcgttaagacaataaagatcatttcattcgttctcttaacgatgaact
-aaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaa
-gataagaagaacaggaacgcgcacgtcggagataactctaatagtctctttattccgttt
-aatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgcaaacctatttat
-gtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttttatcaagacttt
-cgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggag
-tcgctctaagtgttaccaacccctcactactacgcgaaggtactcgattattccttgaat
-gggctgaaacatcgtgattagcgtcttatgattcaggctgatagaagaaaacttattttc
-tatattccacgtatacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgct
-ataataaataaaatacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtc
-acataaataatccgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaagg
-tggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaatatcataataga
-tgccatacacggttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtt
-tcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatg
-acttaggatggatgagcatttaggtattctatgataacactaaccatcatgtttctaaaa
-tcctcaggaaatttgtattattttaccaacctgtatttatagaaagtgcttttgacttaa
-agaagccgaagtgttcaaattaaggagtacctgattgaaagaatggggaattgtaatctg
-taactcaattacaaataagccgttctaaggattaaggctttgtgtctaagcaactcacgt
-gaattcgaaattcatactcgattaacgactttaatactcttctgcgtatctacagactca
-tttaaattacggaatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaa
-taaggacacctggtacaattggctggagtacaatgttggtttttatttgctgattatccc
-gatccctgtgggcgttggcataaccgggttttcttcaagactactttcgtgttgcttata
-tacctggtaatatcggtgagtagcttagggcttaatcacaatactaacaagttctctatg
-gattggacagggcggcatccgttgactgaacgatctattaatccattccctgcactggat
-aaacaagacccatttaaattgaccatagagatgttagcgtcatatttctgttcgtgatag
-ggtacatatattataaacggattatgagcagtggttttctagaaaagcattcatagttag
-gagtgtatcagatcataccactgaaccatagagcacaattctctactggctatacttcat
-tcctttttgtccgggtggggacgaaatttaaaggttctaacctagaacgcagagcgaatt
-gatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttg
-actattgacagggcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagat
-agagtacgggcctataattcaaattcagccaccgaagattcacaatcttcagacgtttga
-aggaaagaggtttactggtatgtggtgtcaagccccacccattctctgttatatccgagc
-attaatgtagtttcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaac
-aatttaggctgagaagtggcactataatagtttagcctaagtcccttcgctaataactca
-acaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatact
-gatagctctcatggtaccaagaactttcataacctctttatttaccaaacctgttctact
-agcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcg
-cctgcaagctaacatgggatcaaaactattggcttaacgtttaatcgaatgagactagca
-ctgtattactctttcgtttcggcagcggatcaataaggaggtgacggcatcactctctta
-tagtagatatcacttattctcacaacggaagtaggatcttccgtcctcattaaatttgca
-actggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggtcagagcagacga
-tgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaa
-attccagacctcgagttacattatgaaacgtgtcattccatctcattaaatagttcgtgc
-cctatcgccttgtaatataaacaaccgtttttgtctattttcccaaggagaaggagagta
-gcagcttagtggcttgcctatatggccccctaagtacgtactcggcacgcttagaagatt
-gggctaccccgcactatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattc
-aggtcatcgatgagagtataaaaatatacaattttggcaggggttatacattgcgggcat
-gaagagtaacattggacatgaacggacattcgaaccctgtgagtttaataccctatctcc
-ggatcattataaagtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaa
-ctaaattggttatttttctttcatctagatttgtctgtatctaactaaattatagttcca
-cataaagctgattcaactgaagacataaatataaactttctaacatagtagcgaggaaag
-agctatgcctagcatcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttt
-tccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtgaacatacataata
-ccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcctacgtaaggctat
-ttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtaca
-ttcagatctccttagtatcatcaaattatagattttacggccacgaattattggtctaga
-tgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaag
-aagagtcattatgctataccaagaactctccatccagtacctagaaaggcaggtatgtac
-cgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggct
-tttataatagaaactaagtttcccgaataacggtgtacgataacagatttttaggtgtac
-agacgtctgactcaatgaacacacattgggacctgccccgggaggagtagtagataatta
-ccttctccagcgcgggtcttttaatatcacaacataaaaatactaattaatatcacacac
-cctcatcctcgatggagcctagcatcatacacgtttgatagacaacgccaattttactgt
-aatatgatattcgaatctagtatgtggacgctgtaccacattgtttaaaggagctccctt
-taccgacatgaacgaagcaagctttgtacaagatacgaagaactcagtactggtaactat
-aagagacaatttatacataaaagtgttaagaccattatataaaaagaggtatgaggtctt
-tgtaactacaataatacattcatcgaacgatggagaataacagagttatttctgctgctc
-gagctctagttctgctaatttctcaatcttgatgccactcgtttgagtcttccattcgct
-cttaacgacgcgtacatccctctctcctactcttacctatatcctattactggttaacct
-acatctccgggaaagacgtaggtaaagtggtccacgattgtattcacttataacacctag
-tagtactatgtgttgctgagagtgaggacacacttactctacgagttcaagtccatatgg
-acattacactttttcagcatctaggtgtcatgatgtattaacagccgttaggggctattt
-gattttatcgattgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaatag
-gcatgaaaattcaagattgcagttcctatcttgtataatctttcctttggacgagttgta
-ccatttcaactaacctgcaagtggggggtcatccatatgaagatttgccaaatacctgga
-gaccctgaaaagtttatccagattaataataacaaacaaacctaagcgaagaacgtcagc
-tttaataaactatcactatcatagaaattcctgttaattgttcttccaaacgttgaatag
-actatcacgggtaatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcg
-aatctgctgataactcaattatattcgatggagaattcatatctaccgcttagcttttaa
-aaattaagtcagattattccgccacaatgagaaggcgcgagtgcactaatcaaatcactt
-aggattattacggacgtctgcattacaatgctttggggtagggttatacaagcatatgat
-tctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatc
-ctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacct
-gttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaaactctaacatag
-cgtggcactatgagtacgtgtaacgacaaggtctcatactcgatcctaagataattctcg
-tctggaaggttttaatctttaactaagagtagaacttagtttattgacttttacaattag
-gatacggttcgcgactctaccacagggcatcatacctggagctctgctatctcgtgacca
-aagtggcagcacacatagggtcgggtcctgcatctactgagcaatccctttaagcattcc
-tagtttgagagccatttagatattgctgtttaaaccgattaatggtttctattattataa
-agtgtaacgctcccattcgggacattgaaaattagcaataagacaatgtatgatattcgg
-cgagtctcaacaacattatggtctaccatgggacaaggggttgatatgatgaatccacaa
-aaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgttataaggacgatc
-tagaagtattcaggtacacggtgttcagacatgctctaattgtcaggttgtttataattt
-aacgtatcgctctctattctaaataatataaaattaaccgctcgtagggatgctttccag
-taaaagatacactatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtac
-attcttaaacttaaatacgtattatttaaagtaaatatattatctaaaccgcttttgtct
-atccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatct
-aaagcgatcatctatttcttctgattgatgtaatactgacccttactccgtacatacaaa
-tgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctg
-gtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcattttgacaatttt
-tctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgt
-agatccaatcacgctttcctacgctaatgaaagttctagatagtgtaggtgttagacaga
-ggttagcgcctacatccttacacacacagtgttgaacggcaagcataatcgagtatcaat
-agctgtatgtatttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaa
-tgtcctgccctagagttatgataaaataactgctgccctgtaacttaagtttacaaaccg
-atattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgc
-gatgaacaaaacacagtgatttataaatacaaagagtacatttagttaccggattgcggc
-ttgacatttattttacagaattttatcggcaaaacacttcatatgaactatcgcttcacg
-ataagtctatgatagactagcattcgtagagaacaggaagagcaatcattatatatgaag
-tgttacagtgggtactacatatgagatcattaggtctatatccggccttcctcataagac
-cttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccc
-caaagaatagtaattcatcggacgtaatagtctggttttaactaggggttattgatattt
-aagctaaaagagttccctgaacactcgaaatgtataatctatcccaactaaaaaagtata
-cctctaattcagaaatgtcattgagattagactgatgtcaatacgctaggaggtaagaca
-agtagaagtttttgatttaggaattgaaatgtaatacctccatcttaagttctatatttt
-aaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatg
-tttgcggccccgtatgagtaatgatctgtttatcaatctctagctactatcccacgaatg
-cactgatgccagtcatggcgcttacattagtcgacagaaatccgacgatacctatcacgc
-gtgaactgttctggttcttattcaattcgaagtgatctcagatacattacggccatgctt
-gcccttcatgtctgctgagcagttttgttataggctgaatctcctctaagcgaaattgat
-aggatttttggtggtcgatttagtctgtacctgcttattaagattcaaaatgacctactt
-cttacgccgaaatgatagggatcggctgaggaggataaatatacgctggtgcctggtatt
-tatccagaacaagttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggt
-acgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtatagtccaccatta
-gttctgacttacttaatatagactgaccgagattgtagtatgtggatccaagcttgccat
-gtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaagagttaattaatag
-tactgcactataattgtcggcggagtaccatgagctgttgcccaattcgatgtttattaa
-cagcacgcataaaaaatccagacttttcaattagaattaactataaatggtccgcgaacc
-ttaaatgatcggaaggacgggatctgccgttgtatagaccccaactctatctaattttta
-taacacctctgtaatcaacaaatcttattatgccatcattatgtcattcgccaagtaagt
-ccagttcgagattctctggaccgtgcaatagtattgtcaaattatggtaatggaatcctt
-cttctaacacccttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagc
-aacataagtgccgtttctttttacgatgatagggattcttaaagcttttctctattctag
-atcccagttgccatcatcaatatctcaattgatgctcattatatagttcttatttagtat
-gtccagatgtcactgaagatcctgcctagaaccgatattctcgacaggatcatcagttcg
-acggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagt
-accgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagttttactgccttt
-aattagtagtcgattagtgtagtttgatattatctaccttatagaatgtaaacagtaacc
-cggccttaatggtttggcaggattctttgtaaaagttaataatgttcataaactttatca
-gaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacgg
-agtggcttgcgtcttgttgtccgagtacacatattgctcctctcccccactcttctagga
-aaatcaattatgctaacctgcagaccttcttctttactatctttaatgcatgcccagtat
-gttcatagggtagacttgctatctattttgtataatctacgaatgatgcttggggcgcga
-cttttaacaattaagccgttgggtataatttgagagggtgccacgatagtaagagatttc
-cggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagctcaccctcctcag
-ttctccaaccctgaaccggctaagtatgactgtgcagtattaattttgaatacatattgc
-agcccctaggatacattatagatgtctctttcttacccaaactcgcccgcaccaagaaag
-aatgtggattcgattgaggttaaattagccggaattacagacacagattcttgtttacaa
-ttgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatggattacgttggg
-gatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaagaattcacagagg
-attaatacacttctccatgaagataggactgcttgcactatccttatctttgtgtcttcc
-ttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataacggaaggtgttc
-caaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggac
-tttagatttgggtattctagagactgtagaaagactgcaacaacaagacattcacagggc
-gaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttaggaatccatacat
-gtaagaaagaatcaaccgtaattatagtgttttcggccccttgaattacgtgcatgcctt
-tgctaaaagacctctgggaaatagattgaatattctggacagcagcgaatcctgattata
-tctcaagcgaatatatgacccgcaagaaggatttatactagaataagtctaagaaagggc
-attgggtcacttcttccactaacacacttttatcagttttataccttgagagtcccatgc
-atttttatatatatttaactttcgttgcgtaaaactttaaatatgatccgtgctctatct
-ctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaag
-aacggtttcttctgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgc
-attagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaa
-caacgcgatttctatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatg
-tcttttcagtttgggttttggatttaccagtcttttagtttcggtactatttgatcggga
-cattcgtccaaacatgatggctcattcgttctttttttcaattttaatcaaaaccttgta
-tttacctgatacattaaactgagcatcgcatggaggtggagattcccatatatgtaatca
-tttgatatcctattccattctttttagttataaataaacgctccactgcacaatgggagt
-aggacttcaccaataattagcatctactgtaaacaagcgccgtaacgaaatgattactga
-ttgagaaaaataggtctcaacaacttttgacagatatgtatccgatacccaagcgttgct
-aattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaatggttattactc
-caatgggctattctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgt
-agtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaa
-atcgatcacggtgatgaattattgttattgtttaaaagaagtcccctgaatagcccttag
-ataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgc
-agagttttgccaagtttacaggtgatttactaacacttgggagggtacgtacaaccatca
-cctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattg
-accgagttattaaacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttg
-cgaaatgttaaatttatggttttttccgttgagtgataatagctgcaacatgaagatagt
-aaaactgaggttaaactttcaccatattaaattatatgttcaattacgcgatgtacaaac
-taatgttaatcagatttaggagcgcgcttaatatgggtccctatcccgactttgtacgag
-attttgataaaaaatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttg
-aaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcctggctcaatatt
-tataatagtaatggttaagattgtggcccaatcgctgagtacccgtcttacgctttttcc
-aacacataatcgacgagaatgtatttaaatgtttgagacttacgttttccgcgtacttat
-tattaaagtcattggagagggtgtcgtctgggtgtagttttctcatctgctcaggagcta
-aaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggctatttaattttta
-tggtacacttgaatatgtttagccataatgtagccaatactacaatatcagatacttgta
-tacgacctatagacttttgccgaccgctcgtagagtgatttagaaagatgttcggatagc
-acagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgc
-tatatgttactctgaatgttgttttttttaccagaatgtgttataatgatcaaccatgca
-cgttcctactaatcatataaattttgttacgtaagcttttctatgatagtggtctaaaga
-ctacccttgcatactttaagattaagacatgcactttaggaggaactcacacgttttgag
-ctgttctagcccacctataagccattcgtccgcaatcccataactacaatagtcggcaat
-cttttattacccagaactaacgtttttatttcccggtacgtatcacattaatcttaattt
-aatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgcttcttgagaatac
-agattactgttagaatgaaggcatcataactagaacaccaacgcgcacctcgcacattac
-tctaatagtagctttattcagtttaatatagacagtatttgaaccaggcgctaatgttaa
-ggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatttgcggggcgata
-gcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacag
-ttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccg
-aagggactactgtattccgtcttggggatgtaacagactgattacagtcttatgatgaag
-cctcattcatctaaaattagttgatttattccacggatactatcacactcctatagaaag
-agttaccaccgtgggaagctagatataataaataaaagacatacaatattagtatggctc
-atgatctacacttactcggatctctctttttttataaccagtagatcgcattacacgtat
-tgttgttccgcatcaggccctaggggctcaaacttccatggtggataactaaaacgtccg
-tcactaaacgaagatattaatagatgaaatacacgggtttacttgatttctgttcagtca
-ttcacgggaaatcctaggagtctttcataacggcggtcttagtaggaatgtagtcaagct
-ctgtagaggtctcgacggaattggtatttcctggcatcacaatttacctagtattggaga
-tcacttaaaataatgttgagataataatcaggatatttctagtatgtgacaaacctctat
-ttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaacgactacatgttg
-gaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtgctttcgtttaag
-gctttctgtctaacattctaacgtcaattcctatgtaatactactgtaaccaagttatta
-ctcggctgcgtagataaagtctcatgtaaatgacggtttatctgttacttttgggtttca
-acctagctaggacgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgt
-gcctttttatgtccggattataaccatccctctcccacttggaatatcaccgggttctta
-atgacttagttcgtcttccttattttccgggtaagatcgctgtggaccggacccattttg
-atctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttag
-attaatcaatgcactgcactggattaacaagaacatgttatagtgtactgacacatgtta
-gactaagaggtctgttcgggttagccgacttatatgtttaaccgattttgacaactgggt
-tgagagataacaatgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctc
-aattcgctaatggcttgaattatttaattgttctaaccctggcgtcgaatttttttggtt
-cgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcg
-gcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaagctactcgaatt
-ggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaa
-gagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtggtctataccacc
-aaaaagtatatgggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgta
-cactaggcagccctaatccaaaacttttgaggatgagtactgccactattatactgtacc
-atttgtaacttacattttatatcttcaaagaggtagatattgtcggccattactgtcact
-tacactaagggtagcttgattactgatacctctcatggtaaaaagtaatttaagaaccta
-tttttttacataacctctgctactaccgttagtgttttagtcggttcaagtcacaaaatc
-cctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaaacttttgccgga
-accgttaatcctatgagaataccactcttggaatcggtcctttaggctgaggatatagaa
-cgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaaacgcaagtacca
-tatgccgtcctcagtaaattgccaaatgcagaaatcttacactcttttcttaactaagta
-tgagagcaacctcactcctgaacagcttgttacctaacgagaagaggctttaagtagcct
-ggagcctcaaccggatatccggatttgactctcatccacttacatgatgattacggtcat
-tacatctcatgattttctgagtgccctatagactgggaatttaatctaccctgtttctat
-ttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatgccaccataagta
-agttctcggaacccttacatgattggcctaccaacctatatatgtgaccaatgtacggta
-catagagtgtggcctatcatattcaggtcatcgagctcagtatttaaagattatatggtc
-gctgggggtattcagtgcgcgatggaagactaacattggaaatcaacggaattgacaaca
-cgctcactttaataacctatctcaggataagtttaatgtaattagacggaactttctcta
-actccgtgtactaactctttgaaaataatgtgggtatttttatttcatctagatttgtct
-gtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtcataaatataaaa
-tttagatcttaggacagaggaaagtgctttcccgagcataggatctggcctacgccagta
-gttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagggtagtgttcgat
-actcagcggggaactgacatattacactaaggaatcaaggcccttcgtatgggtcatgtt
-tatatatttaattacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatg
-caggatgcgattcgagtttgtaaattcacagatactgtgtatcatattattatagatgtt
-aaggcatagaattattggtattgatgtacaaaaaattatgggtgggcagtaccgataggc
-attacgagcagtgcagcttggaagaactggatgtatcctataactagtaagagccttaaa
-ggtactacatacccagggatgttaccatcattaatttggccatcttcaatcttcgcaatg
-catactttcttctacaagatgccttttagaagacaaaataagtgtcaacaataacgctgt
-aacttaactctgttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgc
-aaacgcaggactactagattattaaattcgccagcccgcctcgtttaatataacatcata
-aaaattctaagtaatatctcacacactaatccgccatcgtccatagcatcagtcacctgt
-cttacacaaacacatgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaa
-ctaattgtggaaagctgctaccttgaacgacatcaaccatcctacctttgtacaacagac
-caacatctctgtactggtaaatagatctgaaaagttataaatataactgttttcacattg
-atagaaaaacagctatgtgctatttgtatatactataataaattaagcgaaacatggaga
-ttaaaacagtgttttctcatcctccacctcttgttctgctaatttataattcttgatgcc
-actcgtgtgagtcgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaa
-cgagatcctatttctcctgaaaattattagcacggtaactcctagggatagtggtactag
-ttggtatgaacgtataaaaacttgtactactttctcgggatgtgagggagcaaactatta
-ctcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatacctgtctggatgg
-attatatgcaggtaggcgagagtggattgtagcgatgctcggcgggggtattttaaaaat
-ctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgat
-tagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccat
-atcaagttttgcaatagtactccagaccatgaaatggttatccagattaataataactta
-atatactttcactacatactcagcgggtattaaatttcactttatgtcaaaggactctta
-tgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaactt
-gatcagccttgtaaaatatagtagaatatgatgttaaatcatttatattccagggagatt
-gaatagcttacgattagctggtataatttaactcacatgattaagcaaatatctgtagga
-ccgagggaaagaataaaataaagtaccatgagttcggaacgctgcattacatggcgttgg
-gctagcctgatacaagaagatgagtatggagctctcttcatcgggacgtgacaaccctag
-cgtaatcttggcagatcccggagcagatgattatcgtctaacactgtctttaccaatgca
-caacgcatagatttaacctgaactgttctggattcactcctgactacagcctacaactca
-tttctatgcataactcttaaagacagtcgcaatatcagtacctctatacacatcggatca
-gactagatcataagataagtctcctctggatccttgtattctgttaagtacactacaaat
-ttgtttagtgtctgggacaattacgataagggtcgcgactagaccacagggcatatgacc
-tccaccgctcctagcgagtctccaatctgcaagcactcatacgctaggggcatgaatcga
-ctgtcaatgcactgtaagatttacgagggtgagacccatttagatatgcctcgtttaacc
-gttttaggcttgataggatgagtttgtcgatccatcaaattcccgacattcatattgtcc
-aataagtatatctagcttattcggactcgctaaactaaattatggtataaatgccgtcaa
-ccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggccttatggcagcg
-tatacagctggtataacgaccatatacaactatgaacggactagctgtgaactaagcaga
-ttattggatccttgtgtataattttaagtttcgatctatatgctatagtatagaaaatgt
-tccgatcgtacgcttcctttacagttaaacagtctatatcatgaagcttatccaaagctg
-gacatttgatggcaatcttacttaattatgaaacttaattacctattattgaaagtattt
-atatgatcgaataagatttgctctataaacaggtcgtccattcacgacctagtgattgcg
-taaattgaccaacctaggtaatctaaagcctgcatctatttcttatcattcatgttatac
-tgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcaca
-tttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctat
-cccacgcgtcattttcaaattggttatctacggataactgtgcgatgaactactataggt
-caaaattatcttcaatctcattctagatcatataaagatgtccttcgcgattgatacgtc
-tacagtgtgttggtgttacacagagggtagcgactacttacttactaactctctcttgat
-ccgcaagcataagccaggttaaagtgctctatctttttctgtggattataatagttatac
-cgccttgcatctaggtgcccattaggtaatgccctagtgttttcataaatttactcctgc
-catctaacgttactttaatttcccagattcaataggtctctcatttgaaaattgttatat
-gtcaacaaagaatataatagctgagtggaacaatacactgtgagggagtaatacatactc
-taaattttctttacggtttgcgcctgcacagttttttttatctatgtgatccgcataaaa
-agtaatttcaacgttccattcaagttaagtcttggtgacactagcattaggagagatcac
-caagaccattatttatttagctagggtttaagtcggttagaaatatcagataatgaggtc
-tttatccggccttacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaag
-tatggccgaacccacataatgcacaaatcaagtcgatttcttccgtccttttagtctcct
-gggaactacgggttattcatagttaagctaaatcagttaacggaactagacaaatgtata
-atagttcccaaatatatatctataaatcttatgcagttagggaatgcagatttgaatcat
-ggcaatacgctagctcggaactcaactacaagtgttggatgtacgaattcaaaggtatta
-catccttatgatgttcttttttggatacttttatgacgacttccacgaagtgaaattatg
-ttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgttctgtttataat
-tctcgtcataatataaatacaagcatatgaggccagtcatggagctttcatttggactaa
-catttccgtagagtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgtt
-atcagatacatgacgcccttgcgtgacattcatggctcctgacatcgggtcttttaggct
-gaatctaatctaacccaatttgtttggattgtgggtcctccattttgtctgttaatgctt
-attaagattaaaaatgtactacgtatttagacctaatgattgcgatacgctgtggaccat
-taatataagctgcgccaggggatttttccagatcatctggcctgtgtatatgttcaaatc
-taatagccgagagaaattactccgacggaaaataaaggcagataagcgtttcagagcacc
-atcgtggcgtttagtcaacctttagttcggaatttattaatatacaatctcactctttgg
-acgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcat
-catcaaagaacagttaaggaatacgactgctctataattgtccgaggagtaccttctcat
-ctgccaatagtcgttgggttggaaaacaacgcattaatatgccacacttgtcaattagaa
-gtttctataaaggggacgagtaactgatttgagacctagcacggcagaggacgttcgtgt
-gacaacatctctttataagtttgagataaaatcgctaatctacaatgattatttgccaat
-cattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaaggccattactatgg
-tcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaaacactattgaat
-actgccgccgcattcgccagcaccaacataactgcacgtgcttttttccatgattggcat
-tatgaaagatttgatctatgattcttaccagttgcaatattcaatttagcatgtgttcct
-aattattgtgttattatggtctatctcatcatgtaaatgaagatcatgacgtcaacacag
-attctagtcaggatcatcagttcctcggggaaatcgcacctaggaacagccttatgcaac
-cgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgag
-atgtacgaatcgtttactgccttttatgaggagtcgagtactgttggttcatatttgcta
-catgattgtatgtaataacgatcccgccctttatcggttcgatcctttatggcgataagt
-tatgaatcgtcagtatctttagatcaaaaactcaactagtacccagttccccggaggaac
-ggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttc
-atccgatcccactcgatgattggtatagctatttgccgaaaagccacaacgtattcggta
-ctatcttgtttgattcccctgtatcttaattcgcgacacttgatatcttttgtgtttaat
-cgacgaatcatcctgggggcgacacttgttacaattatccagttgcgtttaatggctgtg
-ggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgca
-ggacgaatagctcacccgcctaagtgatccaaccctcatcaggataactatcactgggca
-gtattatttttgatttcatatgccaccccctaggagactgtagtcatgtatctttcttac
-ccaatctagcccgaaacaagaaagaatgtcgattccagtcaccttttattagaccgattt
-acacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacga
-cttgctctattcgattaccttcgcgatctcaatcgattacgctaaattttaatgcccgct
-gaaatatccaacatttaaaacaggattaattctctgatccatgaacttaggactcattgc
-acgtgacttatctttctctcttaattcatgctccaatacggtgggctaaaccacttttat
-cacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtc
-aatctgggtatcttctattgggacggtacatttcggttttatagactatgtagttacacg
-gcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgcc
-atgtgtccggaggattacatacatctaagaaacattctaaactatgtatagtcgtttacg
-acccttgtagtacgtgcatcccttggcgaaaagtactctgggtattagagtgtatattat
-cgacagcaccgaatcctcattttatagcttgacaatttatgacccgaaagaaccttttat
-aagtctataagtatatctaacgcaattgcggcactgagtccactaactatctttgagcag
-tgttatacagtgagacgccatggaaggggtttatatattttactgtcgttccctaaaaag
-ttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgctt
-gtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttacattccttgctta
-tttgcgataaatcgatacaaccccattaccagaaaaacccggagaatcaattactctgca
-gatcttatactaaaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgt
-ggagcgttggggtaagagcggagcgattttaactttcgcttttccattttccagtattgt
-actttacgttatatttgagcggcacattcgtcaaaacatgatccatatggactgaggtgt
-ttaaatgttaatcaaataattgtattttcagctgactttaaaatctgcagccattggagg
-tggagattccaatagatgtaagcaggtgatatcatatgcaattcttgtgacttattaaga
-taccagacacggcacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaatt
-ccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaacgtttctctgaga
-tgtataagttaccaaacactggagaattccgctaaactaaggacaatttccgtcgtatta
-attgttgacaaatggttagtaatacattcgcagtggataatccgttgcatacctagcact
-gagtgtaaataaaaccaatcgactactggcatttcgggctaacgactagatgttagccta
-tgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttcttattcgttatt
-agaagtcacctgtagagacagtagagatgacctaaatttggtttgtccagtcccgaggtg
-atctaatgattaggttaacttagaacagtggtcaattggttaaagctgatttacgaacac
-ttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtattcggtcatctag
-acaaccccatcgctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccga
-attcgaaatcctgttgctccggggagatagggttaatttaggcttttttacggtgtggca
-tattagctcaaacatcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgt
-tctgctaggaagcgatgtacaaaataagcttaataagatttaggtccgaccttaatttcg
-gtccatagcacctctttctaagtgttttgcttaaataattgtattgttattgattttctg
-cgagttgaacacggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaa
-tgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccg
-cactaaacggctttcgctgtttccaaaaaattttagtccactaggtatttaaatgttgga
-cactgaacgtggaagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgta
-ctttgagcagatgctatcgtcagaaaaaggtaaatcttttggttctttataattctggcg
-tccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaa
-ttacgtcattagctgttacgtctatacgaaatatagactgtggacgacccatcgtagagt
-catgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacaca
-gtattgtactggtcaattggttcatagatctgactatgaatcttcgtttttgtacaacaa
-tctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcc
-tgttcgaggttagtcgtataaagacgaaacggccttaatgtaacattaactattccactg
-taggtggatctaacaaggttggacatgtgctaccaataagataagaatttcgtccgcaat
-acaatatctacttttgtagcctatcttggattaacaacaacttacgttggtatttcaccg
-gacgtatcaaatgattctgattttaatgactgagagtaaacatcaacgaatcttatgtat
-ctttaagccgctgcttgacaagtcacattactgttagaatgaacgcttcattactacaaa
-acctaccaccaactcccacattaatattatactagatgtttgaagtttatttgacaaagg
-ttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttagggtattaattgt
-ggtcggtgcatttccggccccatagcgctccgcggggagaaactatggccttcatgacag
-cccccccataacatctaggtaatggtcggataactataaacaaccctctccagagaactg
-tgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaag
-actcttttcactattttcttgatgcctcattcttctaatattaggtgattttttaatccg
-agaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaa
-tgaaatactttttgactatccctcatgatctaaacttacgcggagctatctttttgtata
-acatgtacagagaattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtc
-atggcggcttatcgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacg
-ggtttcgggatttctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgc
-gcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgcct
-tctcaattgtccgaggattgctgataacttaaaataaggttgagtttttaataacgattt
-gtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacg
-ggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggta
-tttgtacaactgctttcctttatcgattgctcgagaacattataaagtctattactatgg
-attaagactgtatacaagtgtttaagcggagcccgtgataatctataaggttttggtacc
-tttatctgttacttttgccttgaaacatacatacgtacacgggaatatttacctaaacgc
-cgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgccc
-acttgcattataacccggtgcggaatctcttagtgactcgtcaggagtttacgcctttga
-gacctctcgacaggacccattttgatctagtcgttataggtagagtgcctttcctatcgc
-accattaccttctagcaaacttagagtattcaatgaaatcatatcctgtttatactaaat
-gttataggctaatgacacagctgacactaagaggtctcttcgggttacccgaatgagttg
-tttatacgatgttgacaactcgggggagtcatttcaatgaagactgaggactcttgatca
-gattaaaacgcttaatgactgataatttagattatgccgtgtattatttaagtgggcgaa
-ccctcccctagaatgggtttcctgagaaaagtcttagaacacagtattctgaatccagat
-gcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcg
-caatccgtttaaccgtctactattcctagagcgaagagctatgttctgacacgtccccaa
-tattaggcaaaggctccaaaagaacagtcaattgattaactacgggcttggtttctccgt
-gaatccttgcgccgctataccacataaaaggatagcggtgataccacaagtttgcgacgt
-taaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaattttgtccatca
-ctactgccaagagttgactggaccagttggaaatgacatttgatatattaatagagctac
-atattgtaccactttactgtcacttacactaaccctagcgtgattactcatacatatatt
-cgtaaattctaagttatgatactagttttgtaaatttaatcggcgaagacacgttctctt
-gtacgagcttcaactaaatatttcactgtagccaaccactttaaccagaaggatacctta
-atgccgatataatattgtccaggaaacgttaatactttcacaagacaaagcttggaagag
-gtactttacgatcacctgatagatcgaccggaacgattctatataggtttggtctgagaa
-atttgtagctaaaaccatgttccataggaactcctctgtaatgggcaaaatgcagatagc
-gttcaatcgttgcttaactatctatcacagcatcctaactcctcaacagcttctttccta
-aagacatcagcaggtaagttgacggcacccgataacccagagcacgattggaatctaata
-ctctgtatggatcattacgctaagtaaatataatgattttctgactcaaagttacactgc
-gaattttatattaactggttctatttgttaaataccacaacctctcgtcaacaggtcgcg
-atgcaagtgatccaaaaatatctaacttataccaaccattacttctggcgcagaaaaaca
-tagatatctgaacaatcgaccgttaagactgtctcgccgatcttaggaacctaatactgc
-tcagtagttattgtttatttgggccatccccggattatgtcagccatggaacactaaaag
-tcctaatctaacctatggacaaaaagctcacttttataaaattgctcaccttatgttgat
-tgttatttgtccgaaatgtctataactcagtgtactatctattggaaaattatggccgga
-gttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaataattatcagctg
-gaaaatcatctaatatatattatattgagatattacgacagacctaagtgctttcccgtc
-atgagcagatggactaacactcttggtaatccttctcgttttagttggtaatgtttagtc
-taagtaatatcccgactcttacttactcagagcggaaatgactttttaaactaacgttta
-aaggcacttagtatgcgtcagggttatttttttaattacgtacccttgtgcagagagttt
-agctattcgatcctacttagtatgaaccatgagagtacaggttggtaattcacagagaag
-gtcgagaagattatttttgatgtttaccaatactatgaggcgtattcatcgaaataattt
-tatggctgcgcacttcacatacgcaggaagaccactgcagcttgctagatctggatgtat
-cattgtacttctaagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatg
-gggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcat
-aagttctgtcaactataaccctggaactttaatctgttgttcgtcgaatcaaggatcaag
-aaagcttctaaaaggcccaaagcaaaacccaccactacttcagttttaaattagaatcac
-accctagggtattagataataattaaatgtcttaggaagagatatcaaaagatgcagaca
-tcctcaagtgaataagtctccggtctttcacaaacacatggttaagcgatgtggttttga
-ctagagacgttcgccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatctt
-acttcatacattgcttaaacagtacaacttatctcttatcctatagagatctcaaaagtt
-tgtatttttactggtttcaaattgagagaaaaactgcgttctccgatttctatattattg
-tttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccgactcagattcgta
-tcctatgttagaatgagtcatcaaactacggtcacgcgtacattacagagtaaactacac
-gaatgaaagagataagaagatgaaagagttaataggtctcctgttaattatgagaaccct
-aactactacggattggcctactagtgggttggaacggatataaaattcgactaagttcgc
-ggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatccacagtaatagtt
-ggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccat
-gcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgagcaaggaattgga
-ttctgtgaacggaatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagt
-aaatcaaacgccgcgcgcagacatatcttcttggcaattagtactccactaaatcaattg
-gttataaacttttagaatatctttatataagttcactacttacgctgcgggtagtatatt
-taaagtgatgtcttaggaatcttatggcggcggaataaacggcttgactatagataccct
-aattctggcataaccctgtaacgtgtgaagcatgctttaatagacgactagatcagctta
-tagaatggatatgactgccacattgaagagattaacattagcgggtataatgttacgaac
-ttgtttaacaaaatagctctaccacacacgcatagtataatataaaggtcctggagttcg
-ctacgagcctggaattgcagttcccctaccctgagtaaacaagatcagtatggacctatc
-ttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcg
-gctaacactcgctttaccaaggaacaaacaattgatggaacaggtaagcggctggattct
-atcctgaatacagcataataatatttgctttcaatatatagttatgacactcccaatatc
-actaactctttacaaatcggatatgaagagtgaattagagatggagccgatcgttccttg
-tattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcga
-gtctagaactcacgcattatgaaatcctccgagcatagagactctaaattcgccaagcaa
-taagtcccgacgcgaaggatgagaagctcattgaactgtaacatttacgtcgggctcacc
-atgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacata
-aaaggccccactttcatatggtcaaatatctatatcgtgctttggacgactcgataaact
-aaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatat
-ataacttccggacgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaa
-cggtatagctcggaactatgcagattaggcgatccttgggttgaatttttagtttccata
-gatatgagttagttttgatatggttaccatacgtccctgcattgaaacttaatctgtata
-ttgattgatccttagcaatagcggcacatttctgggcaatatgacttaattaggttacgg
-tttttactatgatggatacgttttatatgatagaataacagttgctatttaaacaggtac
-tacattcaactaatactgtttcactattgtgtccaacatagggaatatattgcctgaata
-gatgtattatcaggcatcttttacgctccaggtagaactaattaaaaatgatccttagaa
-actttcaagcaacataagctaaaagttacgccaattataagccacatcggtaggatcttc
-aggcattcccatatccttctctatcaatcccgtctgttgctaattggttatctaagcata
-tcgcggcgagcatctacgataggtataaagttgctgctatctaattcgtcataatatata
-catggaattacagattcatacgtcttcagtctcgtggtgtttctaagagcggacccaaga
-attacgtaatatctctctcgtgttacccaagaagttgacacgtgattgtcagctatcttt
-ttctggcgatgttaatagttataaacaattgcatatagctgcaaattagctaatcaaata
-ctcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagg
-gcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataa
-tatctcagggtgtaattatttctctaattggtctttacggttggaccaggcaatgggttt
-tttatctatgtgataccaattaaaagtaatttcaaagtgacattaaacttaagtattgct
-gtcaagaccattacgacacttcaccaacacatttatgtattgtgctacgcggtatggccc
-gtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaaatgccaaattta
-gtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgt
-tgtattacgtccttttactagcctgggaaataccggtgattcagagtgaacataaatctc
-tgaaagctactagacaaagctagtatagttaaaatatatatttcttttaatattaggatc
-tttgcgattgcacatttcaagcatcgcattaacctacctccgtactcttctacaacggtt
-gcatgtacgatttctatgcgatgaaatacttatgttcttagtttggggttactttgttca
-cctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaac
-gatctcgattcttaggtttataattatagtcagaagataaatacatgcatatctggacac
-tcttccacatgtcatgtcgactaactttgaactacagtcatatatagactgttatctgat
-ccgtatgtgtctattactactcttatctgagaaaggacccaatggagtcacagtaagcga
-tcatgtcatcggggctttttccctgattataagattacactattgctgtgcttggggcct
-cctactttttctatcttaatcattttgtacattaaaaagctaagaagtaggtacaactta
-tctttcccatacgagctggaccattaatttaacagccgcaaggcgagttttaatgttaat
-ctggaagggctttatgttctaagcttttagcactgagaaattaatccgtaggaaattaat
-cccacataacccggtaagagaaccttacgccccgttactaataatgttctgcgcaatgta
-ggaagtgacaagctcactcttgcgacgagctccttaatacaggccctgcgttatattcga
-ccgtacctataactagaccaccatcttaaatgtacagttatggttttcgacgcatagagt
-atgggaccacctcgaaatgctcagctgcaaattgtactgggggtggttatcaaacattta
-atatgaatctatggtaaagtactagtttatagatagccgaacactaaaggtttgcagacc
-ttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcg
-tatctacaatgatttggtgcaaatatttatcgattgcccaatcgttctactcgtactctt
-tatagcctaacgccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaa
-ttacttaaccatactcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaa
-cgggcgtttttacttgagtcccaggaggtaacattggatctatgagtcttaacagtggaa
-atatgatttttagattgtgttcagatttattgtcttattttggtctatctcatcagctat
-agctacataatgacgtcttaactgtttcgactaaccttcagatctgactaccccaaatac
-aacatagcaaaagaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagc
-tccatttaaaagaatcgaaaacagatctaccattcgtggaatcaatttttggacgagtac
-tggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttcaagcactttagcg
-gttccatccttgatggcgttaactgatgatgcgtaagtttatggtgatctaaaactctac
-tacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttaggtctccaggcact
-aggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcctatagctttttgc
-agttaagccactaagtaggcggttctatagggtttcattcaaatcgatcgtaattcccga
-ctctgcatagcgtgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagt
-ttcaacttccgtttattggctgtccctcaatagagtcgttctcagggcacgactctcgtt
-cgttattcataagtccagtttgatccacgaatacagaacacgcatatctgataataaaag
-cttaacgataactttcacgcgcatggtttatttttgatttattaggcaaccaaataccag
-aatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaagtatcgccattac
-agtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgat
-ttaataataattacggctaaacgtattgatattttccaggaactgccccatctcatgaga
-tgaccctaaattttattcacacctcatttttaattcttttatatcacgattatttatctg
-agcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaata
-tacggtgcgctaaacatattggttcaattcaatgtaagctacctcggaatttgcttgcac
-taagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccg
-ttggagtcactatggagttacaagcattataaatctaaggaaatcgcagtatcagtcctt
-accccaaagatacttcgcattccctggggtacggaccatgaaatacttctttcatacatg
-ataaacgatggagactcggttaccaccctggtagttactccatcaattggagttaactaa
-gatcgctattacaggctttattagccaatcatcacaagcctctttttagagattcacaag
-ttagcaaaccaaagttcctttgataagtctttaacgagatctatcccaattccggctagg
-agtaaaatttatatatttgagatcggggttaaagtcacacgcaatgcaaggggtttttat
-atggtaatgtccttccctaattaggtaattttcagacctccgagagagagtagatcaaca
-acgcgttatactcctaaaatgcttgtcgataacatgacactacagatcatccctggatga
-gcatcgactttcattacttgattagttcagttaattcgtttcaaaccattttcaacaaaa
-tcccccagtagatatgtatatgcacatcttagactaaataacagttttcataccctggga
-tttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactgg
-ccctgttccattgtaatcgatgggacgggacgttatattgcagacccaaagtagtaataa
-attcagccatatggacggagggggggaattgttaagaatataattcgattttcagctgaa
-tgtaaaagctccagccattcctcctccacttgacattagttcgaagaaggtctgagaatt
-ggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagtaccaagtataat
-attatgacaatagaagcttaaattcacaacgtaacatatctgttagcatgctctaataga
-ccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaat
-ctaacgtctagttcccgactatgaagtcttcacaaatggttagtaataatttcccagtgg
-agtagaagtggcataacgtgcactctctgttaataatacctttagactactcccatttcg
-ccagaacgtcttgatggtaccctatgggaaacactcacacatgcttattgcctgcaacct
-cagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggactgatgacctaat
-tttggtttctcaagtccagacgtgatattttgatgaccgtatctgacatctctgggcaat
-tcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatc
-actatcatgttttagctaagctacactaccccatcgctcgcacgtggcaaagtgtgagga
-ttccgatatcatccatgtgtacgaattcctaatactcttgctcagggcacttagggttat
-tgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtcttataatcaccgt
-aatcggtaaacagttgttatttgttctgataggtagacagctaataaagatgctgttgaa
-cagttacgtcccacctttattgccctacagtgaaactagttcttactctgttgctgtaat
-atgtctagggttattgatttgctgccacttcaaaacggaaattaagtcattaacgaaaat
-ggttccttcataggtaaagatcaatccccaattgaagccagaaattttgagatgtcgatt
-cctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgag
-tccactagcttgtttattctggctcaaggtacgtggaacacgtagtattttgatactaat
-gccagacccgctacgatccctgtactgtgagcagagccgatcctcagaaatagctaaatc
-ttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtct
-atttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatac
-tctgggcaacacacatacttctctcatgttgtttcttcggacctttcataacctttcctg
-gcacatggttagctgcacatcacaggattgtaagggtctagtggttcagtgagcggaata
-tcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatat
-tatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatg
-tatggatcttgatctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaa
-taagataagaatttactaacatttaaattttcttattgtcgagcatagattggaggaaaa
-acttatttacttggtatttaaacggaagtttctaatgtttatgattggatgcacggacag
-tttactgcttactttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgtt
-catgcttccattaagttcttcttaaacttacacaaactacctaatttagagttgacgaga
-tggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtaca
-tttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacattcacatcccaccc
-ctgaatatatggactgaatcacacacaccaaatttcatctaccttatcgtagcataacta
-ttaacaaacatatacagacttcgcggtaaataaaatatattagtacacaaccgtatactg
-gttgaactattgcccagctttaagacgcttttaactaggtgcttgatcaagaagtattat
-tatatgacggcagtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacg
-ccgtagagacatttttgttagatatgtatttctttttgacgagccagcatcttagtatct
-gaagacgagctatatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagat
-taaccaaattccccagaattagtaatggcgccttatcgatttactaacgatatataactt
-gtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattg
-aagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgat
-actacgttttgctatgtaatccattctaatgggtaagaggattcctcttatagtaaaata
-tgcttgactttttaagaaccattgggagtggttggcaaaataatagtgggtgtctttctc
-agtgtatagttttctacaactacccctattaggttacaagtaatctggctttcttgccac
-ttggcgatgatagttagattcgtatttctacaacgcagttactgtatccatggcgcgaga
-taattagatacgatttgaatttggatgtagactcgttactactgttgtagaccagcacgt
-gagtatctagatgggtttgctaccttgttagcggacttttgccgggaaaaagacatacgt
-acaaccgtatattttactataagcagtattggccaccctcgtattgcggcagggtgtgct
-cacctggttaaaatgaaagagaaaaattccattttaaaacccggaggaatctattactga
-cgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttcatattctagtta
-ttccgagagtcactttcctatccaaacatgaactgatagcataatgacaggttgaatgga
-aagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgtcacgaactcgga
-gcttacccttacaactatgtgttctgtttaccaggtgctaatatcccggcactcttttca
-tgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcatattttacagtagc
-cagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctgacataagtatta
-catatcacttgtctgattacacagcaaaatcgctaaccttactttgcgcatgtagctatt
-ggaactttgggctagtgtctatcccattaagtttaacagtagactagtccgtgagcgatc
-accgagcttatgtctcgtacccaagttttggatttggatcaaaaactactcgatattcat
-gatctacgggcttcctttctccgggtatcattgcgccgagattaaaaataaaacgatagc
-gctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacgaatagaccatcca
-atttgaattttattgggtccagcacttcgccatagtgttgaatggtaaagttcgaaagga
-aatttgttatattaattctgctacattttcgaccacttgtatctcaaggacaatatccct
-tgaggcttttagcagaaagagatgccgtaattctaagggatgataataggttgggaaatt
-taagagcagtagtaacggtcgcgggttcgaccttaaactatatatttaaatctagccaaa
-caagttaacaacaaccataaagttatgaccttattatattggcaagcttaacgttttaat
-tgctctagtaatagagtggtagaggtaagggaccatcacctgattcttcctccgcaacca
-ttatatagacgtgtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaata
-tcgaatggcaattagccacattgagttaaatagttgaggatatttcttgcacagaatcag
-atctaatctaatgattcgttactaaacacttcaccaggtatcgtgaaggctcaagattac
-ccagagaacctttgcaatataagaatatgtatgcagcattaccctaagtaattatattct
-ttttctgactcaaagtgacaagccctagtgtatattaaatcggtatatttgggaaattcc
-tcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccata
-catgaattctggccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgcc
-aagatattaggatcctattactcatatcgtgtttttctttattgccgccatccccggagt
-atctcacccatccttctcttaaaggcctaatattacctatgcaaataaacatatattgtt
-gaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgact
-atatagtgctttagtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtt
-tcttgtcctaatatttttcagatcgaatagcttctatttttgtgtttattgacatatgtc
-gaaactccttactcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtct
-cgttttacggcggaatcttgagtctaacttatatcccgtcgcttactttctaacacccct
-tatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgttattttttgaag
-taagttacattgggcagactcttgacattttcgatacgactttctttcatccatcacagg
-actcgttcgtattgatatcagaagctcgtgatgattagttgtcttctttaccaatacttt
-gaggcctattctgcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcg
-caacatgccttcatatccatcgttcattgtaattcttacacaatgaatcctaagtaatta
-catccctgcgtaaaagatggtaggggcactgaggatatattaccaagcatttagttatga
-gtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcgtaatgttatctc
-gggttccgcgaataaacgagatagattcattatatatggccctaagcaaaaacctcctcg
-tattctgttggtaattagaatcacacaatacgggttgagatattaattatttgtagtacg
-aagagatataaaaagatgaacaattactcaagtcaagatgtatacgggatttataataaa
-aatcgggtagagatctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgtt
-acatcagaaagggtaactattattaattaataaagggcttaatcactacatattagatct
-tatccgatagtcttatctattcgttgtatttttaagcggttctaattcagtcattatatc
-agtgctccgagttctttattattgttttaaggatgacaaaatgcctcttgttataacgct
-gggagaagcagactaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcg
-acgaatggacagactttactaaaccaatgaaagacagaagtagagcaaagtctgaagtgg
-tatcagcttaattatgacaacccttaatacttccctttcgccgaatactggcgtggaaag
-gttttaaaagtcgaagtagttagaggcatctctcgctcataaataggtagactactcgca
-atccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaacc
-gtccccactcgcctggggagacatgagaccacccccgtggggattattagtccgcagtaa
-tcgactcttgacaatccttttcgattatgtcatagcaatttacgacagttcagcgaagtg
-actactcggcgaaatggtattactaaagcattcgaacccacatgaatgtgattcttggca
-atttctaatccactaaagcttttccgttgaatctggttgtagatatttatataagttcac
-taattaagatcacggtagtatattgatagtgatgtctttgcaagaggttggccgaggaat
-ttacggattctctattgatacaatttgtctggcttataactcttaaggctgaaccaggcg
-tttttagacgacttgatcagctgttagaatggtttggactccctctttcatgtcagtaac
-atttcagccgttattgttacgatatgcttgaacaatattgatctaccacacacccatagt
-atattttataggtcatgctgttacctacgagcatggtattccacttcccattcaatgagt
-attcaacatcactagcctcagagatgatgacccacctctaataacgtcacgttgcggcca
-tgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcatataacatttgag
-ggtaaagctaagcggatgctttatataatcaatactcaataataagatttgattgcattt
-tagagttatgacacgacatagttcactaacgagttactattcccagatctagactgaagt
-actgatcgagacgatccttacgtcgatgatcgttagttatcgacttaggtcgggtctcta
-gcggtattggtacttaaccggacactatactaataacccatgatcaaagcataacagaat
-acagacgataatttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaa
-gctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaactggttcccggg
-agtcctggagtttcgacttacataaatggaaacaatgtattttgctaatttatctatagc
-gtcatttggaccaatacagaatattatgttgcctagtaatccactataacccgcaagtgc
-tgatagaaaatttttagacgatttataaatgccccaagtatccctcccgtgaatcctccg
-ttatactaattagtattcgttcatacgtataccgcgcatatatgaacatttggcgataag
-gcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggttaacagacgtac
-atgaagggaaactttatatctatagtgatgcttccgtagaaataccgccactggtctgcc
-aatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtat
-aacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcactattggctacaa
-aatagggaagagtttcaatcatgagagggagtatatggatgctttgtagctaaaggtaga
-acgtatgtatatgctgccgttcattcttgaaagatacataagcgataagttacgacaatt
-ataagcaacatccctaccttcgtaacgatttcactgttactgcgcttgaaatacactatg
-gggctattggcggagagaagcagatcgcgccgagcatatacgagacctataatgttgatg
-atagagaaggcgtctgaattgatacatcgaagtacactttctttcgtagtatctctcgtc
-ctctttctatctccggacacaagaattaagttatatatatagagtcttaccaatcatgtt
-gaatcctgattctcagagttctttggcgggccttgtgatgactgagaaacaatgcaatat
-tgctccaaatttcctaagcaaattctcggttatgttatgttatcagcaaagcgttacgtt
-atgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtgggaataattctt
-ttgaagacagcactccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgt
-aaccttgcacaagcaaatcggtggtgtatatatcggataacaattaatacgatgttcata
-gtgacagtatactgatcgagtcctctaaagtcaattacctcacttaacaatctcattgat
-gttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaag
-gaacatctactaatgcctttgttaggtaagatctctctgaattccttcgtgccaacttaa
-aacattatcaaaatttcttctacttggattaactacttttacgagcatggcaaattcccc
-tgtggaagacggttcattattatcggaaaccttatagaaattgcgtgttgactgaaatta
-gatttttattgtaagagttgcatctttgcgattcctctggtctagcttccaatgaacagt
-cctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggtt
-cggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagc
-aaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtag
-ttaaataaatccatatctgcaatcgattccacaggtattgtccactatctttgaactact
-ctaagagatacaagcttagctgagaccgaggtgtatatgactacgctgatatctgtaagg
-taccaatgcaggcaaagtatgcgagaagctaataccggctgtttccagctttataagatt
-aaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagttggttcattaat
-tagctaagtacgaggtacaacttatctgtcccagaacagctccacaagtttttttacagc
-cgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattagagtttacaactca
-gtattttatcagtacgttttgtttccaacattacccggtatgacaaaatgacgccacgtg
-tcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcctacacatactga
-attcaggcaatgcgttttattcgaaaggtcatataactagaaaacatgatgaattcttat
-cggatccttttactagcatagtgttggcgaacacctcgtaatgctcagcggcaaattgga
-ctgcgggtccttatcatacattttttttcaatataggcgattggtctaggttagtgattc
-cccaacacttaaggtttgctgacattcataccctcagcaacttcctctcaaaaattagag
-tgagttggtggtcttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgc
-acaaatcgttataatcgtactctgtagacaataacccattgtagtgccgattttgtgcat
-aatacaagaaggaggatataaaaatgacttttcaataatattggctattagcaacaagaa
-ggagaatcctcattaagttagcaaccgcagggggtactgcagtccaaggaggtttcattg
-gagagagcagtatgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctg
-attttcctagatagaataagctatagctacttaatcaactcttaactgtggagactatcc
-tgatgatctgaataccccatttacaaaattccatatcaatgaggctaacgcttaaatttc
-atttctccatcgtaacaaaaatcagcctttttatacaagacaaaacactgcttccattac
-gggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgc
-gtttatacttaaacaaattttgacctgacataatggagcgacttatcggatgttgccgat
-ctttagggtcatctattaagcttatacgaaaaagggacaagcacgttacgtaatctggta
-ggactgggtacctagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaa
-tacaggagtccttttcatttttcaagttaacaatataagtaggagcttagagaggcttgc
-atgaaaatcgttaggaattacagaataggcagagagtggggcgtgtagactacattcttc
-aggccccacaatatgggttataggttaaactgcactttttgcgatctcccgaaatactgt
-cgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcatccaactattcag
-ataaacaagatcgcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggc
-atgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaa
-cataattcattctttcgactggacacgctaaggtttggacaaactttgtatctatatctg
-gaggcctgtattccagcccttcttttaataagatttacggcttaaactatggatatttgc
-caggaaatgacactgctattgacaggaacataattttgattcaaacctcattgttaatta
-ttttatatctcctgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtga
-gggctcgaggaatgaatcataatagaccggcccctattaatattggttcaattctttctt
-acataacgcggaatttgattgcacgaacaccgggaacacataaccgtatagcgcccgtta
-tgctagtgcctagcgactgggaccgtggagtctatatcgtctttctaccattattaatct
-aaggatataccactttaagtcctttcaactaacataaggcgcattccatgcgctaaggac
-cttgaatttattatttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgt
-actcaataaagtgcagtttactaagagccctttttctggcttgtggagactatcataaca
-tgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacg
-agatctttccaattgccccatagcaggaatagttatatattgcagatcgcggtgtaacgc
-actccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatca
-aagcacagtgagagttgagcaaattacagttatacgacttaattcagtctccataaattg
-aaacgacacttcttaacgggaggaccagacacgttcattaagtgaggagtgcactttttg
-actttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagt
-tatttctgttttaatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccc
-tatcacacctcagagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtag
-ttggcacacccaatggacgaataaatgctgccatatccacggagggcgggattgcggttg
-attttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaat
-tactgcgtacatccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaacc
-aaattgacaacttcatagtataatttttgcacattacaagcgttaattaacaaacttact
-ttgctgttagctgcctatatttgtccgacaatataactggatatctctgcgagaactgta
-aattaacggcacttggaacataatagttcctattggtaacgacgttgtaggcggcaatta
-tccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagta
-taactttagaagactccaaggtacccagaacctcttcagcggacacgatcgctatcaatc
-aataaggattattcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagc
-ttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctgttattttcatga
-ccggataggacatctcgcggaaattcgggtaacagctgggtagatataggacctccccta
-cgtattaatgataagcctgtcataactagcttggtttaccgaagagacaataaacattcg
-agcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaacatgtactattact
-ctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgatgttgacagaatt
-atgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtctgagcattcgtac
-actgcgtattaagatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaac
-taggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaa
-ccaaattaaggctttatccaatatgggtccttaagtgctaaacatcattcacaatttcaa
-gacagattgttggtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccag
-gtacatcggtaattatatgttgactaaactaccgtgtgtattctggctctaggtacggcg
-aacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcag
-cagatcctaagtaattccgttttattgtcctgagggagtaggatcgacgaactctacaag
-tcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtc
-atctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcgatggttctttat
-gcggacctgtcatatcattgactggcacttgcttacatccaaataacacgtttgttagcg
-gatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctaca
-tgataaatgaataagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgt
-cgacgagttactactaaaggaatgtagggttctggatctatgaaaagcgacctccatata
-tatacgggcctaagcggagtaaaataagtgatcaatggactaacattgaaatgttagtat
-tgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatg
-gtttagcatgggatgcaagcactcgttaatgcttactttagttggttgcgggaacaacag
-gaggctatactaactggtagcgttcttgcttccattatgttattattataattaaaaata
-agacatatggtagagttgtagtcagggtggatcgggttgtctataacgttggaataatca
-aaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgt
-gcaccacacattcacagcacacccctcattataggcaaggaagcaaacaaaaaaaagtta
-atcgaccgtatccgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaag
-ataggactaaaattcactagtatcctggaacgaggcaacagagttatctagatggtaacg
-aggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacctctattgatata
-caagtgactttctcggtaataacgcacttcacaatgtgttgtttcttttctatgtatttt
-gcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcac
-atggtataactgcaggaggaacattatccaaattcaccacaattactaatccaccctttt
-acttttactaaagatatattaattctcatgttgtctgaattgtataacccggtaccctgg
-gagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaacacacgacttcctt
-ccgtctattcagacactcaacgagactaacttttcctaggtaatcaatgatattgggtaa
-ctcgtggcatcttatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgc
-taattaagactggctctcttgcgcaggggatacgtttattctacgtacccgatttggtta
-ctactaagcggcctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagc
-agggaagggttacagggagagacttattgagatacgattggaatttccatgtacaatcgt
-taatacgcttgtagaccagcaactcagtatagagatccgtttcctaaagggtgagcggta
-ggggcaaggcaataagaaattactaaaaccctagttgttaatataagaacgattcgaaac
-aataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaataggcattgtta
-aaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaa
-cctaaaaggggcttattctactttttccgacactcaatggacgagacaaacatgaacgga
-tagctttaggtctcgttgaatgcaaagaatagaatcgttattattaatcggtttccatta
-tctatatgcggtatagatctccgagaggaccctgtaaactagctctgcggtttaactggt
-gctaatagaccgccactatgttattgcttctagctcctagcgtcttatcatgttatacat
-taatgtcgcatattggacagtagccaggcttggatggatcgccgacaaaaagaaaagact
-ttccctgtaaggacttaactattacatataacttggatcattaatctgcaaattagagta
-acggtctttcaccagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaa
-aactagaattggcagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttg
-cataaatatcttatcgatattcaggttattaccgattccttgctaacgctagaagtcaca
-ccagagtaataataattccagacacctgtgaaataatcggtcactacggatagactagta
-acgataatacgtatagtccataaaagttgaattttaggggctaaagatattagcaatact
-ggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaa
-ttgtatcgataggaatagttacagtcacgcttgtagatgtaagagatgacgttattctta
-gggttcttaagtcggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaa
-acgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattt
-tagtggcaaccttaacggttgaattgatctactaatacaggcctacaccgaagggtacag
-ataatgattcttactaccctaacatgatagagtcctgtcctatctcataggtcgacattt
-taaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattcacttatagacttc
-aggttatttcgtgctaacattaagatagaatataatcagtcgttaagaaactattatcca
-gctttcgtcaaccataaagattaaaaactgaaacttggcaagatatgaatagctatcctg
-ctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagt
-aaagcgggagagtgcggtaattaatattaatatactattaagctacacagcaaaggctgc
-aataatgttagtaagtagaacataaaggtattctccacaagtaataaatagtgtgagcta
-attgactaacttaactctcgcgacaagtgatgtggataagatgactcatatcgtcttttt
-ctgtagtgccgacatcccacctggatcgaacaattccttctagttatcgactttgattac
-ctatcctattaaacagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctac
-catagctagagttagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatg
-agtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatccattagattaga
-tgtttgtgttttgggtctgatgtcctaactactttctcagtgaaactaatgtcatcatcc
-aagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtctataacgtatataa
-agtcgctgaatttagaacacaccttatctatgttgtaaagttactttattccaaaggacg
-tgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagata
-agaatttctttcatacttcactggaatccggcgtatggatatctctaccgcgtcatctgg
-tggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacat
-cgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtgaagtctaattat
-ttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggat
-agaggacattgcatgtacgtaggactattctccaaggggtcttctattttgttagcgaaa
-attgttacagcctaatgttagagcggcgtacgactttataccagatactttcattagata
-tgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgtt
-gtgatatgatgtttttctagttcgttctcatatatatagatcaacaatgaataatctcat
-gatctataaccgatgtatatttatattccggttgactgctccggtgcaattcactacgga
-cactaatgactaatatggcgcctttcatcagaaacgctaaatatgattaatgaattaagg
-gagtattatctaattattagagagtagcagttagtctgatattttcggtgtatgtgttag
-ccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttca
-ctttatgactctggttatatccctcggagaacaagaataagagtacgagaagttcggtca
-ttgaggatgaaatagaaccgctagacgaatggactcacgtttataaaactatgtatcaca
-gtactacagctaactctgaagtccgagaagcttttgtaggacaaaacgttataagtacct
-ttcgcagaatacggccgtgcatacctgttataaggcgtagtagggacaccatgctatccc
-tcatatagagctacactaataccattacatggtgactatcgtttacggccatcatctgta
-agcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaacccc
-gtgcggattttgagtcagaactattcgaagcttctcaatccttttccattatggcatagc
-aagtgacgactcgtcagccatgggaataatagcactaatccgattacttatgaattagaa
-cccacatgaatgtgattctgcgaattgtctaagaatctaatgattttccggtgaatatgg
-ttgttgttatttattgaacttatattattaacatcacccttcgttagtgatagtcagcta
-tttccaagaggttccccgagcatttttaccattctctagtcatacaagttggagcgcttt
-taaatctttaggctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtg
-caatccctcttgcatgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaat
-attcatagtaataactacaatacttgatttgttacgtaatgctcgtacataacacaatcg
-tattccacggaacagtaaagctctattattctgatcgagcctaagagaggatcacactac
-gctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgaccagttatagaca
-gtgtaattccatattacatgtcaggcttaagctaacccgagcctttatataagctataat
-caagaattagattggagtgcattttagacttatctatcgaaatagtgatagtaagagttt
-atatgacctgatctagactgatgttctcttccacaacagccttaaggcgtggagcctttc
-ttatactattaggtcgcgtcgagagccctattcgtaatgttaacgacactagactaatat
-acaatgagctaagaataacacaagtcacaagataatttacaaatcatatatctacagtcc
-acaaccatcactagcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgc
-aagacgcgttaactggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatat
-ggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagac
-tatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattgataaatgcccca
-acgttccatcacgtctataagccgtgttactaatgtgtattagtgcatacctattcagac
-catagttcaactgttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttc
-ttgtcttttccttaactgacctaaatgaaggcaatcggtttatctagagtcatgcttaag
-gtgaatttcagccaatgggctcccattgagctagtatggtgctttacctttgtaagtggt
-ggctttccttggtgtgctgactttaacacggcagagtgattatccgaagaatggataata
-agacgctggcaatattggctaataaagtccgatgagtttcaatcatgactgcgaggagat
-ccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcattcttgatacata
-aagatccgatatcggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatg
-tgaatgagagtgaaatacacgatggggatattgccggtgagtacaagttagaccacacat
-tagaactgacctatattcgtcatcatagagatggagtatgaattgattctgcgaagtaca
-ctggctttacgagtatctagacgccgcggtatatctcccgtcaatactatgaaggtatat
-atatagaggctgaaaattcatgttcaatcctctttctaagagtgagtgggagccccttct
-gttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtt
-tgcttagaacaaaagagttaccttagggtaggtaaatctcgattcaccgagagaagtgat
-tttggcggtgtgcgattaattcttttgatgacagatctcattattttatatagctccctc
-tttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgc
-tgaacattttatacgatgtgattactcaaaggataaggttcgaggcctctatactcatgg
-aactatcttataattataatggatcgtggctcattccacctatccaaacttctttgtgat
-ctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagct
-cgcatttcattcctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaa
-ggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttatagcaaacattatt
-caatttcagtcttgactgaaattagtttgttagtgttagaggtccatatgtcacatgcat
-atggtctagatgccattgtacagtaataccttagattagtattagcggcatgcgtacttg
-gatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgcaaataggaatact
-tacaatttttgatgacttgttagcatatcgctatcacccataaaaaacctgatacttgat
-gagcgggtgattgagactatgtactgatataattcaatagctccaatagatgaaacagct
-atgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgag
-tggaattagcggtgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacc
-cgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacgaagaatgggtag
-agagtttgaaggtgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaa
-cacctcctaatggttgtgttaaccacaaacccctgggtgaatctgattagccaacccagt
-gatctgatttcagttgtcaaatctcttttttataactaccttttgtttccataatttaac
-cggatctcataatgaacaaacgggtagaataatggtagcacatagcgagcttgtctattc
-agaaatatggcctactcagaatgtattctccaaatcagtgttatgcgaaacgtaatttta
-cgtgtaataatgatgatttcttatcggttccttgtactacaatactcttgcccaacaaat
-actaagcataacagcaaaattcgaatccccctccttttaataaatggtttttcaatatag
-ccgattcgtattcgttagtctttcaccaactattaacctggcatctaattaataaaatca
-ccaaaggactctataatatgacagtcacttcggcctcttttaagacagttgattattgca
-ggtccgcaattgatggtgacatgcacaattagttagaatccgactatggagacaattaac
-aattgtagtgcccatttggtccagttgacttcaaccacgagttataaaggtattttaatt
-tatagtcgatagtaccaacaacaagcacaatcataattatgttagaaaacccagggggta
-atgctctaaatccagctttaaggccagagtgcactatgaaatcgccattgatcattgtgt
-cattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagc
-aacgattatatctggactagatcatgatgatcggaataaaacattgaaataagtccttat
-caaggagcataaacattttatttaatttatacttcgtaaataaattcagaattttttttc
-aagacattaatctgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacg
-catgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggc
-tgccacttttagcttcttgacgatctttagcgtcatatttttagattagtcgaaaaacgg
-aaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaagagcaggacaact
-ccttgatcgggaagaactgaaatagacagctgtcattttcattggtcaacttatcaatat
-aacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcag
-gcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacg
-ggttgccagctacagatatactctaggtatatcccaaacaagagacgtcctttggctgtt
-gtaatcggtcataatacttgtcacataaacaagatcgctgaattaaacattaaacagtta
-gtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatca
-cagagcgacgtaaatttagacaaacattattatttcttgacaatggaatcgataagcgtt
-cctctaacttggtatatatatctcgaccccgggattccagccattcttgtatgaagattt
-aaccatttaactatgcatagttgaatggtaaggaaaatgatattgactgcaacagatttt
-ggatgcaaaaatatttgtgaattattggttatatactggttgtatagcacaatcattagg
-tcctagaaggcatactcaacctcagcgagagagctagcatgcataattgtaccgcccata
-ttaatattcctgaaatgatttcttacattacgcccaatttcagtcatcgaacacccccat
-caatttacccgatagagaacgtgatcatacgcaataccctatgcgaacgtccactctata
-gcgtctgtatacaatgattattcgttccatttacaacgttaagtaatttaaacttacata
-aggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgt
-ctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgta
-tccattgtggagaatatcataaattcaagatggggtgtcatgctattcggtcctaaacat
-tcttaatggctgttctattgttagtctgatttaaaatggaaccatagcacgaatagttag
-atagggctcatacccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgac
-ggaaagttttacggtttgtgatcaaagaacactcacacgtcagattattacactgatacg
-aattatttcagtcgacagtaattgaatagaaacttattaacgccagcacctgacacggta
-agtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttga
-tttctatatcaaatgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatt
-tagatcgttacgactcacgtacaagatcacacatcacacgcgttagcgaaagcggaatgg
-ctaatacagccctacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgag
-ccaacctcccccgcattgcggttcattttaaggcctgggtaacatctatcgtttagataa
-tcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcg
-ctacgtgtttctttaatcaataccatattgaaatcgtaatacgataattgttgctattga
-ctacaggttatgaaaaaacttactttgcgggtacatgcatatttttgtaccacattatta
-cgcgatatctctcagtgtactctaaattaaaccctcttcgaacattttagttcctattcg
-taaacacgtgctacgcggcaatttgccggtcgtagaatggacaactccagttcaactgca
-tgtaactcatagctcgcgttagtataaattgactagtagccatgggacaaagtaactagt
-cagcggaaaagatccctttaaagatatatgcaggttgcaagcataaagctcattgctcga
-ggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaa
-tcgaaactactctgatttgctgcacacgttaggtaatatcgcccattttcccgtataagc
-tccgtacttatacgaactacacgaccttttaagcattagccgctcatatcgtgattcgtg
-tacagatgagtctattaaaattacagacatactccatatctcgctccttgaactttgaat
-aatgcgctaacttgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggg
-gaaacgatacatgttgtcagatttatgattatctagttttagatcacgtttaccgataat
-cggctgtggtctgagcagtcctacactgagtatttacttcagcttcatatcggtccgaaa
-aaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcgg
-ttgcagggcagcaaaaggcttaaaccatttttacgatttttactatagcggtcatgaagt
-gcgaaactgcttgcaaattttctacacacattgtggctcttgtccttgaagcttatggcg
-aaaatttgaaacatagtataccagggaaagcgcgaattatttggtgactaatagtccgtg
-ggtttgagccatatacctaacgccataaactacgtggtgctttagatgcaatctaaacag
-aacagaaagcgtagcgctcatcagcacagactaactttttcagtttgagtcgccggaggg
-acttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaa
-tcttgcctaatttctactattgtcagctgtacgactgtactaagtgtatagccccaaata
-aaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttc
-atcaaattaaatcctggcttacccgattctccggaagtctgacctagagattgacgacgg
-ccgcgtattattgagacctcttcaggattaatcaataacgaagtagttgatctgtttggc
-gacgtaccttaagccgactccgctacacgagtttctactaaaccaatgtagccttatgct
-tagatgaataccgtcctaattagatattccggcataacagcagtaaattatctgttcaat
-ggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaatattaggtaagg
-ccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaa
-tttaggtgcgtgagggttaaacaccagcatattctatatgctagacgtcttccttaaagg
-atcgtagtattataattaataataagaaatatggttgacgtctagtcagcgggcatacgc
-tgctctatatactggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctc
-acgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgcc
-aagcatgcaataaaaaaaatgttaatagtacgtttacgacattttattttataataaaga
-gaaactattacacctattgatatgataggacgtaaattaacgagtagcctgcatagaggc
-aaatgaggtttctacatggtatagacctgatgctgaaacatcgatgagttttggtcccct
-cgctcgttgaaatctagtcatttactactgtctttcgagctattataccacttcactatg
-tggtgtttctttgctatgtatggggctagtcaaacatgatgactatagctacaactcaga
-gagcgggcgtgttaagagtatctcatgctagaactgcacgacgaacttgatacaaagtaa
-caacatttacgattccacaaggtgactttgaagaaacatagtttaattctctgcttcgat
-catttctataaaccggtaccatcgcagcggatagatgcataacatttctactactccagg
-catcttaaaacacacgtagtacttcactagattaagacacgataagtgtataacttggca
-gtgggaagcaaggagattggcgaactcctggcatctgttacgttttgttcaggctcggtt
-gttgataatgtccgactcctgccatattgaagactcgctcgagggagatcgggattcgtt
-gattataagtacacgtgttccgtaatactatgaggcagtgattcaaaatggcacttctga
-cttacatgactaggtattattaccacggaagcgttaaaggcacactcttatggacttaag
-attgcaagtgccttcttctagcctgaattcgcgggttcaacacaaactctctttagacat
-ccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtactaaaaaactagtt
-ggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggtta
-agcaaacacaaataggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcg
-ggaacaacggctctaagagaataacctaaatccggatgagtagactgtgtaactctctaa
-agggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgcattcaattgaatc
-gtttgtattatgagctgtacagtagctatatcagctatagttatcccagaggaacaggta
-aactagctctgagcgtgaaatccggatattagaacccctagatgggattgattctagcta
-atacaggcttatctggttttacagttatctagatgattggtaaggtgaaacgcttggtgc
-cttccaccacttaaacaaaagtattgcccgggaagctattttctaggtattataaagtcg
-agcattaatatcaatttgacagtaaaggtctttcaccagcttcatatgccatagggccca
-tactcgatttaaattgaacggtttaacgagtattggaactctcacttataactgagtagc
-tatacgaaaaatctggtccatttccagaaatttattatcgatttgctgcttagtacccag
-gaagtgataacccttgaaggcacaacactgtaataagttttcctgtcacatctgtaatat
-tcggtcactacgcattcacgactaaagataattactatactaattaaaagttcaatgtta
-gggccgaatcatagtagaaattctcgtctagcctaatcggacttacctatgggctgtgag
-gatttatcagtatgtggacaaaaatgctagagataggtatagttaaagtcaccatggtac
-atctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgggatgacaactac
-tatacgtagagccgtactcaggattagatagtgtgaaagagtcaaataaaagggttaata
-ttaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaat
-acaggccttcaccgaaccctaatgataatctgtcttaataacattaaatgattgtctccg
-ctacgagctcttagggcctcattttaaatgactaatgtccaaagaagagactttcccaat
-ttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaagatagaagattat
-caggagggaagtttctattatcaaccgttacgcaaccataaacttttaaatctcataatg
-gcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgctggggagctagat
-atcggtataccacttcggttgtggtaagcccgagtgggccgttagtaatattaatagacg
-attatccgacaatgcattcgctgaaataatcttacttaggagaaattaatgctatgagcc
-aaaactatttatgtctgtcacattattgactaaagtatctatcgacaaaactgatgtcca
-taagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatga
-attatagttatccaatttgagtaaattgcctattatacagataggcttgtttagtcagat
-aaggttccgcttgaggtgctctaacttagcgagagttagaaagcctagtgagaggcattt
-tggtgccaaactccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaag
-ttggtgaacagccttttgattagttgtttgtcttgtggctatgtgctactatataagtta
-gaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgagacggggtacgcc
-gttgaggctcgagatagtagataaactagaggaatgtagataaaacattagctagggggt
-ttagttactggattacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtc
-gcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcctatacggacttt
-gcatatctctaccgactcatctggtcgtctatgcgggtaattgtattgctccaagtggat
-gactattttggcgtcccagcacatagtaaatgtaaatccttataatagcataagcaatta
-ttagactgcgtgaagtcttagtagttctcaagctttacgttgtatgtaaataactcacgt
-aatcagccgtccccaaatcaccattgaggtcattgaatgtacggagcactattatcaatg
-cggtatgcgattttctgagcgattattgttaaagacttagcgttgagccccggaacactt
-gattacagattctttaaggagttatccaaatatcattttaaataatagtagtatcgtgct
-ttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtacttctctgatata
-tacttcaactatgaagattctattcatcgataacccaggtatatttatatgcccgttcac
-tgcgcagggcaaattatctacggacaataatgacgtagttggacccggtaagaactaacg
-cttaatatgattaaggatgtatgccagtattatcttattatgtcagagtagaagtttctc
-tgagattttccgtcgttgtggtacaccggatttggctctctttttagaactgagaactcg
-gagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccgccctcatcaact
-ataacaggacgacaagttccgtcttgctccatcatatactaccgatacaccaatcgtatc
-aagtttagtatacttgctttctctcttctacagcttactcgcttgtccgagaagcggttg
-gtgctcataaagttagtagtaaatgtacaactagtagccagtccttacctgtttttacga
-ctactacggacaccatgagatacagaagttagtgctacaattataccattacatgctcaa
-tatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctacc
-atcccgtcaatgcacaaaaacacactccccttgttgactaacatcttttacaagaggcta
-aatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcggaagaataccact
-tttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaat
-atattcatttgaccgtcattagccttcttcttaggttgtgtacggatagtaggtacataa
-accgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttttttaccaggcta
-gagtcagaaaagttggagccatgttaaatagttaccatcataaaccactgttgtctacta
-gtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactg
-ttgcgttacttaggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcc
-taatcctcggaaagtacacaagcctaggaataggaaaagtaaagctcttttattctgata
-gtgactaactcaggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatca
-tctgctggtgaccagttatagacagggtaattcaatatttaatgtctcccttaacatttc
-accagcatggattgaagatagtataaagttttacatggcagtcattgtgtcacggttcta
-tacaaattctgatagttagacggtatttgaaatgtgcttctagcatggtatcttacacaa
-ctgaatgaacgactggagccgttcgtatactatttgcgagcctcgagaccccgtttccta
-atgttaacgaatatagtataatataaattgtgatatgaataacacaagtaactacagttt
-ggacaattaattgttctaaactaaaaatcattcacttcagatggcatagagttatggcta
-ctacacatataaagcggtatgtgaaacacccgttttagccggaaaccctctactgctcgg
-gacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaa
-tagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatt
-tggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgt
-ctattactgattaactagtaagacattagtgcatctggtccactgaagcacccgcttggc
-gttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctata
-ggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggt
-tcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagac
-tctttatcccaagaatggataatatgtacatggaaagtgtccataattaagtcccttcac
-tgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgacttacttgcttttt
-gatcaacttaattatggattcataaagttcagatatcggtacaattggtgtacaatatga
-aattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatccccatttgcccg
-gtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagcattgagatccac
-gatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacgaagaggtatatat
-aacctaaatactaggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggc
-gaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggt
-cagttcaaaagtagaccggatctttgcggagaacaattcacggaacgtagcgttgggaaa
-tatcctttctaccacacatcggattttcgccctctcccattatttattgtgttctcacat
-agaattattgtttagacatccctcgttgtatggagagttgcccgagcgtaaaggcataat
-ccatataccgccgggtgagtgacctgaaattgtttttagttgggatttcgctatggatta
-gcttacacgaagagattctaatggtactataggataattataatgctgcgtggcgcagta
-caccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatt
-tgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattatatatgttgatta
-tttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgc
-ttaagtttgagagcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtgg
-ttgtcgtccataggtcactggcatatgcgattcatgacatgctaaactaagaaagtagat
-tactattaccggcatgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgccca
-tgtagccctgataataccaatacttacatttggtcagcaattctgacattatacctagca
-cccataaatttactcagacttgaggacaggctcttggagtcgatcttctgtttgtatgca
-tgtgatcatatagatgaataagcgatgcgactagttagggcatagtatagatctgtgtat
-acagttcagctgaacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaacc
-atatcgttcacacatgatatgaacccagggggaaacattgagttcagttaaattggcagc
-gaatcccccaagaagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcc
-tccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcg
-cggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatatctttggtagaac
-ttactttgctttaaatatgttaaaccgatctaataatctacaaaacggtagattttgcct
-agcacattgcgtccttctctattcagatagaggcaatactcagaaggttttatccaaagc
-actgtgttgactaacctaagttttagtctaataatcatgattgattataggtgccgtgga
-ctacatgactcgtccacaaataatacttagcagatcagcaattggccaagcacccgactt
-ttatttaatggttgtgcaatagtccagattcgtattcgggactctttcaaataatagttt
-cctggcatctaagtaagaaaagctcataaggaagcgatattatgacacgctcttccgccg
-ctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgag
-aagacgaagatcgactaaagttaaaatgctagtccacagttggtcaagttgaattcatcc
-acgagttatatagctattttaatttatagtcgagtgtacaaaaaacatccacaataagat
-ttatcttagaataacaacccccgtatcatcgaaatcctccgttatggcctgactcctcga
-gcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtg
-agatgatcagtttcattatgatgatacgattttatcgcgactagttaatcatcatagcaa
-gtaaaatttgaattatgtcattatcatgctccattaacaggttatttaattgatactgac
-gaaattttttcacaatgggttttctagaatttaatatcagtaattgaagccttcataggg
-gtcctactagtatcctacacgacgcaggtccgcagtatcctggagggacgtgttactgat
-taaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatg
-agttttacattagtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaa
-gagaatacatacaccaccacatagaattgttagcgatgatatcaaatagactcctggaag
-tgtcagggggaaactgttcaatatttcgtccacaggactgaccaggcatggaaaagactg
-acgttggaaactataccatctcacgcccgacgcttcactaattgatgatccaaaaaatat
-agcccggattcctgattagcaaagggttcacagagaaagatattatcgacgtatatccca
-aaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtga
-cctctagtatacaggttaatgttagtgatacacaatactcgtgggccatgggttctcaaa
-taaaatgtaatattgcgtcgatcactcacccacgtatttggtctaattatgttttattta
-gtgacaatccaatagataaccggtcctattaagggctatatttttagcgaccacgcgttt
-aaacaaaggattgtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaa
-atgagattctatcctaaagtttgggcttgatataagatttcggatgtatgggttttataa
-tcgttggagagctcaatcatgagctaatacatggatttcgctacctcaccgagagacctt
-gcatgaagaattctaaccaaaagtttaataggccggattggattgagttaattaagacct
-tgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaata
-ccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaat
-agttaactaatttaaaattaattaacgacatggaaatcacagaacctaatgctttgtagg
-agttatttatgctgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacg
-catcttttagttcagaaagtggtatccagggtggtcaatttaataaattcaacatcgggt
-ctcaggatattcggtcatataatttattaagggctcttcgagtcttactctgagtgaaat
-tggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcat
-tccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatataagaaaactcac
-acgtctcattattaaactgagtacaatttttgcacgagaaagtaatgcaatacaatatga
-tgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgcactggattaaaa
-tccgattatttttaaaaatattcagtgctagagcatatcaggtctacttttttatctggt
-atgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaagttataacataa
-ctcccgttagccaaagcccaatcccgattactgccctaccctaacgtctgccatctaaat
-atcgaacttgttatgatcaatgtgactacctcccaccctttccccttcatttgttccact
-ggggataagctagcgttttcagaatcaatgcaataagaatagccaattgtctcacttcat
-cagagctcttggcaattccaggcgctacgtggttctggaatatattcatttttcaaatag
-taatacgtttagtgttgctattgtctacacgtttggatattacgttatgtgagcggacat
-caatagttgtctaactctttagtaagccagagatagcactcttagcgaatggataccatc
-ttccataagtttagttaatagtccgaaacaactgcttcgagcatatttgaacctccttgt
-aggcaaatagcctcttcaaagcaatcttactaatagatagagtttgttttaagggactac
-tagaaatgggacaatcttaatagtatgacctaaactgacatttaaagatatatccaggtg
-gcaagcataaagatcattgcgccacctccaccgtgggattacttatcagtcgatatccta
-tatgctaagtttgcgacggcagaatacaaactaagctgagttgatgctaaccttacctat
-gataccccattggaccggttaacagccctacttattccaaataaaagaacttttatgctg
-tagaagctattatagtgatgcctggtaacttcagtatattaaaatgacacacatacgcca
-tatagagctcctggaactttgaataatgagcgaacttcgaagttgaagagcaagaaacca
-tatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattgatcattatcgag
-gttttcataaccttgacccattatcggctgtgcgcggacaagtacttaaatcactagttt
-cttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataagacggacgtaga
-gccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggattttaaattttgttcca
-tttttaatttagccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggc
-ctatgctactggaacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgta
-tttttgcggctagaatagtcagtcgcttggagccatataccttaccacttaaacgacgtg
-ctcctgtagttgaaatataaacagaacacaaagactaccgatcatatcaactgaagatct
-ttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccg
-caaggagtcgattgggaccctaaatcttgacgaattgctaagaggctcagagctaccact
-gtaatttctctagagcccataataaatgaacgatacatccgtaggtagcacctaagggat
-tataatggaagccaaatgcagttaataatattatatactggcgtacacgattcgacggat
-ctctcacatagtgattcacgacccccccctttgattgacacagcgtcagcattttgcaag
-aacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtat
-aatttaccatgcttccctgatgctgagtgcaatacactaagaatgagtttttaccccata
-tcaccagtatttgttctgttattgcgaagaaatggctatgctgagttggcgactaaagtc
-acccatcctttttattaggtaaccccctcccttaaactaactgatttgctggagctgccc
-tgcatacatatactttatcatttatggacgtccgtgacgcttattatccaccatagtcga
-tatgctacacggattcattaatggatcgtaggagtttaagttatatttactaagatcggt
-ctcggctactatcccgccttacccggcgctatttacggccatttttaatatattgacggt
-aattattcctatggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgt
-aaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtgatgagtaacttga
-cgaaatgttagtggttattaaagactatctattacaccttttgttttctgtcgtagtata
-ttaaagtctagaagccttacaggaaaatcagggttatacagccgatactccgcagcatga
-atcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtattta
-gaccttttatacaaagtaaatatctcggctttatgtgattgggaggggcctactcaaaca
-tgatgacttgacctaataatcactgtgcgggcgtcttatgactagctattccttgaaatc
-caccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagtta
-ctttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttactt
-ccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaac
-aaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaactactcgaagat
-gtttcgttttcttaaccataggggcttcttaatggcccactacgcacattttgttcaagc
-ccgagagggacatccccattacgggagtattactaaaactgttccgtaatacgttcagca
-agggatgaaaaaggccactgctcaagttattgacgtgggagtattacatcggaagcctga
-atcccacactatgatggtctgtacaggcctagggactgcgtctagacggtattaccggct
-tctaatcatacgatcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatt
-tatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaa
-aaacccccgcacataagccgctttagatttcacaaataccaatgcggttaaaaacatcct
-tgagtcgtacatacaccatactcgcgttaaacggatataacagaagataataaatccgga
-tgtggagtcggtgtaactatagaaagccaagtgaaataatgcttaccagtcatttagcta
-tacggctttcatttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccg
-atacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaac
-aatagatgggattcattatacataagacacgatgatctgctttttcaggttgcgagatgt
-tgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtattgacagggaacc
-tattttcgaggtattatatagtccagcttgaatatcaatttgacagttaacctagtgaaa
-atcagtaagaggaaatacgccacattctccagtgaaattctacgggttatcgtctagtcc
-aactatcaattataactcacgagatataagtaaattctcgtacttggcctgatttttatt
-atactttggatccttagtaaacaggaagggagaaaccttcaacgaaaaacactggatttt
-gttttactctcaaagctcttatatgacggaaataccctgtcaagtcttaactttattact
-agactaatgaaatgggcttggggtggccagaatcatagtacaatttagcggatacactat
-tcggactttcctatcggctgtctggttggataagtatggggactaataggctagacatac
-ctatacttaaactatacaggcgtcatctatctctgcaactttggagttccctgatgttct
-cccgccctttgggttcacatcttctataccgacacccctaataacgattagtttgtgggt
-tagagtaaattaatacggttaatattaatgtatcgttgaaaagctggtgtcgccaataag
-gtaaccggctaggcagagtatatgtcacgaagtataactaccctaatgataagctgtagg
-aataaaattaatgctgtctctaagcgaagagatatttccgactctgttttaatgacgaat
-ctcattacttctgacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacg
-catataatgaacttagaagattataacgacggaactttatatgataatccgttacgatta
-aagaatctgttaaatatcataatggcattcagttctagaccgtgcatcatggtaaactta
-ctttctctgcatggcgacatacatttcgctattcaaattcgcgtgtggttacacccactc
-gcacctttggaatattaagagaagatgatcagaaaatccattcgctcaatttttctgacg
-tacgtctaatttatcctaggagacaaatcgttttatgtctctcacatttttgaagaaagg
-ttcgagagacaatactcaggtcctgaactgctagaagatactcggtggagcgtggcaaca
-atgaaaaactcgtgacataaatgaatgatacttttccaagttcagttaagtgaatatgtt
-taacatacccggcttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctct
-tacatacactagtgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactc
-acgctatgtattgacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgt
-ccctatgtgctaatatataagttagatcgcattagatgctaatctgaatacttatagacg
-accttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagg
-gacatataaaatttgagtgcggctttagttaagggtttaattacctactcaaacatcacg
-ctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgtactaggtagtga
-ttaatgatatcctagacgcacgtgccttagatcttcagactctgatggtccgcgatcacc
-gtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaa
-tacttataatacaataaccaaggatgagaatgactcatcgcgttggagttatattgcttg
-aagttctatggaatgaaagcacgttatctgccgtcccaatatctccagtgagctaattca
-ttggacggtccactttgatcaatccccgaggagatgttcggacactttagtctgtaacac
-ttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttttccaaagttcat
-tttaaataagactacgataggcctttcctattgatataaactacccggctctgttgttcg
-tgtgagtcgtacttctctgtgtttttctgattatagcaagattcgattcttagtgtaaac
-agcgatttttatttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagt
-tgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcccacgttgatagt
-atgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgca
-tcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgatatttagcaagag
-gcgttgataaagccctcatcatctagatctcgacctcatctgccctcttgctccatcatt
-ttctacacagactactttcctatctacgttagtataattgctttctatcttagtatcatt
-tagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgta
-gcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaagaagtttgtcat
-tctattagacattgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaa
-gactgtgattaactaaaatagacaagccactatatcaactaataaaaacgcccctggtgg
-tcgaacatagttgactacaggataattaattggactggagccattacattctctacaatc
-gtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttc
-gcaggagcacattggtagttcaatagtttcatgggaacctcttgagccgtcttctgtggg
-tgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccg
-gaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgtttaagagttacc
-agcttaatccacggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgc
-attctatcgttatcctatcaacggttgccgtactgagcagccttattgtggaagagtaat
-atataaatgtagtcttgtctttacgaagcagacgtaagtaataatgacttggaataccaa
-aactaaacatagtggattatcatactcaagaactctccagataaataacagtttttacga
-tacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaacgctaattcatt
-tgttattggatccagtatcagttaaactgaatggagtgaagattgtagaatgttgttctg
-gcctcgcatggggtctaggtgatatacaatttctcatacttacacggtagtggaaatctg
-attctagcttcgtagctgactatactcaaggaaccactgctcaaggtaggagactagttc
-cgaccctacagtcaaagtggccgaagcttaaactatagactagttgttaaatgctgattt
-caagatatcatctatatacagtttggacaattatgtgtgcgaaactaaaattcatgctat
-tcagatggatttcacttatgccttagaaacagatattgcccgagctcaatcaacagtttt
-agccggaaacaatcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagat
-ttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagttt
-aaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaa
-cgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacacattagtgaatat
-cggccaatgaaccaaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcag
-gttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaacctcattgtaaca
-atagcccagcaaattctcatacgtgcctcagggtccgggcgtactcctccatggaagggc
-gcgcatctagtgttataccaactcgctttttaactactatgctgtagttctacaggcata
-gtggccagtattttctaacttctctggatagatgctctcactcctcatccatcacggctt
-cagtttacgtcttacttgcttgttcagcaacggatggaggcattaagtatcttcactgtt
-ccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactc
-attgaatactgccccagttgcaacctcacttaatctgacaaaaataatgactactctaag
-tgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtataggcatgtaact
-cgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccagg
-taattgatgcggatataagctggagatcactcacgcccacacaaggcgctgctacctctt
-tattccaatgtgtaagaatttgctaacttcatttctagaccgcagctttgcggtcataat
-ttcacggtacggacccttgggttagagacttgataacacacttcgcagtttccaccgcgc
-acatgttttagtggcttctaacatagaatttttgttgtgacataaagagtgcgtgggaga
-cttgcccgaccgttaagccataatcaattgaaagccccgtgagtcacatctaattggttg
-tactgcgcatttagctatcctttagctgactcgaagagattcgattcctaatataggtta
-attagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataact
-cgcgcttaattacttatgagtagttccaagttcgctacgttatgagagagattggaatta
-agcaaatatgttttatggtgattttgggatgagaaggactgctaagtacggctactaaac
-aaatttctaaaaccgccatctaccttatcttggagacatttaagttgtatatgtcactag
-tctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatc
-aaatgcttatctaagaaagtagtggactattacaccaagcacgaatgccagggaactgct
-ttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaattacatttggtca
-gcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttg
-ctctagatcttatctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtg
-agggcttagtatagttctctgtatacaggtcacatcaaactccccctgtcctagtacagc
-tctgagctttaattaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatc
-atgctcttctcgtatagggcaagagaagcaacaaacaactagcccgactcacgttcatcc
-gccgtatccttgttcagttcttactccgtattaggtcagcgaaatctaatcagaataatc
-ggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttat
-cggctattagatagtggggtgaaagtaattggctggaattatgttaaaacgtgatattaa
-gctaaaatacgctacttgttgccgacctaattcagtcattcgatattcagttagagccaa
-gaataacaagcttgtataaattgaacggggtgcactaaacgatgtgttactctaatattc
-agcttggagtatacctgaaggcgaattcatgtatcggccaataataagacgttgaagatc
-acaatttggactagcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagt
-acggtctctggaaaattataggttcagggaatataaggaagtaaagataattaccaagag
-atttttggtatcgctatgacccagaggtgttctaacgtctgttttgatccgcagaatttc
-tgcctcaatgcatatttgacggacttgaactagagcctctaaagttaaatggcgacgcaa
-ctgttcctaaacttcaattattactactctttttttcctagggtattgtagaggccagtg
-gacaaaataaatcaaatttaagatgtttcggacattaacatcccccgtagcatagaaatc
-atcagttatccaatctctcatcgagcttttacaatttctgctggcgctatggacagcata
-tgccgcgagacctccgcaagactcacttgatcactgtaagtatcttcattagaggttaga
-gcctatagttaagctgctgacctagtaaaattggtattttctaattttattgctcaagtt
-aaaggttagtgaagggataatgacgttatttttgaacaatgggttgtattcaattttata
-tcacgaatggaacccttcattcccggcataatactagacgacacgaacaagctccgatct
-atcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgac
-ctgatgcaacttagggtcacgatgagtttttcaggactacttattacctattaataagtt
-aacatgagccttcataccccgtaagacaatacatactccaccaattagaattctgagcca
-tcttatctttttgtatcatcgaagggtatggccgaataggttaattagttactcctaacg
-tctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtc
-tagtatgcagcatcaaaaatatagtccacggtttccggattaccaaacgcggcaaagaga
-aacattgtatcgacggagataacttaatacagaaggaaggggcatcttcgaatacggatg
-aataattctatctgtttattctgacatcttgttttcaggttaatcttacgcattcaaatg
-acgcctgccccatgcgtgcgcaattattttctaatattgacgagagcaatctcactcctt
-ttgggtctatttatgttttattgaggcacaagcctatacagaacaggtactattaaggcc
-gtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttag
-tgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgggctgcatttaag
-atggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccat
-gtagattcagatcacacactcattccttgatgttgtctaaacaaaagttgttgtggacgc
-attggagggagttaagtaacaacttgggatcgcatacttataaaaattatatgttaaact
-ttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagtcactaggtatta
-atggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaa
-gaacacttaataaggcttgcttgcacggaggtatgatgtttactgactctacaaccctaa
-ttttccagtacgtacattcattccaataggttagttctcaaagtgctatacaggctcctc
-aattgatgatatgcttcagccgctctatggatattagctcattttatttaggaagcccgc
-ttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatga
-caccgctttacatagaatttgaattaaaacgcgctctcccgttcactaccatacttggta
-ccgtgcgcatattacatatagatataggatcattttttaaagctgtactaggtttgatcg
-acaatcttatgctatactatatgatgtaaccctcataatcaataccgatcgtacgatcct
-agcataggtggcaagcgattttatgccgattattgtgttaaatagtctgtgagtgtgatt
-atcagggctacgttggtagaggggttgtatagacctcgcacacattgtgacatacttaac
-aatatacgaaaactgatataataaatccccttacccaaacaccaatcccgttgaatcaac
-taccataacgtctcccatataaattgcctacttgtttgcataaatctgaatacataacac
-cattgcaccttcttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaa
-caatagcatttgctagcaattattaacagctcttcgaattgcctccacataacgcgggag
-ggtatattttaatttggcaaatactaagtactgttggcgtcatatgctattaacggttgg
-atattaagttatgtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagag
-cactcttagagtttggatacaataggccatatgttgacttaagaggacgtaactacgccg
-tacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaatcttaagaatag
-agacacgttcgtgttagggtatactacaaatccgaaaatcttaagaggatcacctaaact
-gaaatttatacatatttcaacgtggatagatttaacataattcagccacctccaacctgg
-gagtaattttcagtagatttactagatgattagtggcccaacgcacttgactatataaga
-tctggggatcctaacctgacctatgagacaaaattggaaacgttaacagcccttatgtgt
-acaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgcgtaacttcacta
-tagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatgaatgacagtaat
-tcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaag
-ctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgag
-cacatggaagtatatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaa
-actttcgatttagtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccaga
-aatacgagtttaaatttggttacatggttaattttgaccgaagcatcgcactttatgatt
-gataattggattcaatatgtcgccctatgcgaatgcaacatgatccacaatttggctata
-agacgtttaatccgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaag
-agtcagtaacaattataagtactccgcaggtacttcaaatataaaaactaatcaaacacg
-acccatatgatcatctgaagatatttggaactttctcgacaaccaccctcgtactcaata
-cttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagattt
-gcttagtggcgatgagcgtacacgcttatttctctagtcacaattagttatctacgagac
-atcacgagggagcaaataagcgatgttatggctacacataggcacgtatgaatatgatat
-aagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgagg
-cacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggat
-caactagaagagaaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttca
-ctaagaatgtctgtgtaaccaatataacatctatttgttatctgattgcctacttatggc
-tttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtaccaactccctttaa
-attacgctgtgcaggctcatgcactgcatacatatacggtagcaggtagggacctcacgc
-acccttattataatcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggt
-gttggtatattttctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaa
-gccaattttgaatatagtcaacgtaatttttactatgggttccaccgaaacgccttgcac
-aactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaataccttcatata
-tattttttcggttgactaacgtgaactaaggttaggggttttgtatgtctatataggaaa
-cagtttcttttctgtcctactttagtaaagtcttcaagccttactccaaaatcacggtga
-ttaagccgttactcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaa
-gagtcgctgtgtattagctagggagacctttgttaaaaaggatatatcgcggcgggatgt
-gagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatctctcccccacgct
-tttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtact
-tgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagagaattgagtgtaa
-aaccgtaaagccctcacctgacttcatgtaaatggcttagaagactccatgatttaataa
-atactacgaaggaaagactggatctaaagataactctagtaaggccaactcccttcaatg
-ctgttgccagttataatccaagagctgtccttttctgaaccatagcggcttctgaagcga
-actagaagcaaagttggttctagccagacagccacataccctgtacgggtgtattactaa
-aactggtccggtattagttcaccaagggaggaattaggcaaaggatctaggtatgcaagt
-cggagtattacatccctaccctgaatccatcaataggttcctctgtactggccttcgcaa
-tgagtattcaaggttgtacagccgtataataataagatagtgactatgaacgggaagtaa
-cccgctcaccttccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaa
-tactcgaaaataaacaactggcaaattacaccgcacttaagccgcttttgatttatattt
-ttccaatgcgcttttaaaaataattcagtcctacatactaattaagacccttaaacggag
-atatcacaagttaagttttaaccatctcgactaggtggaactatagatacccaactcaat
-ttatcattacctgtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttc
-acagcgaaacttcagtgtgaacagattctgagaaatcacctaaacctattagtcagagca
-cccggttagaaccagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgag
-atccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatt
-tttaaatactaggcaaacccaacataggttagtcctatgtgatacgccacatggtatatc
-attttgtaacgttacctagggataatcaggaagtggaattacgcaaaagtagacagtgaa
-atgcttagggttatagtctagtccaaagataaaggataaagcacgtcagagaactatatt
-agccgaatgggaatcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaac
-agtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtac
-ctgtatactagttactgtattacgtgtctaatgatttcggattggggtccccagaatcag
-acgtcattgtagacgattcaagtttaccaatttaatttcccagctctccttggagaacta
-tcgccaataattgcagtcactttccttttctgaaacgataaagccgtcagagttctctgc
-aacgttggacttacctgaggttctaacccactttcggttctaatagtagttaacgacaca
-acgaataacctttactgtggggctttcacgatattttttcgcttattattaatggttacg
-tcataagctggtgtccaaattaaggttaccggcttcgcagagtagttgtatccaagtata
-acttccctaatcataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatg
-tcccactatgtggtatggacgttgctaattacttctgaagggaaattggtcattatggat
-acgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttgatccaccgttct
-ttataggataataactgacgattaaagattatggtaaatagattaagccaattctcttct
-tgtcagtgaagcatccttaactgacttgctctgcagcccctcatacatttagctattcaa
-agtaccggctcgtttcaaactctcccacctttggaagaggttgtcaacttgataagtata
-tcatttacagcattttttcggacgtacctctaatgtttcattgcagaaaattagtttttt
-ctatcgcacattttgcaagtaacgttagagacacaattatctgcgaatgaactgctagat
-ctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttga
-caagtgctggtaagtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatg
-cacggcagagtaatgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaag
-acccctccattctcgagcccactcacgatatgtagggacgacaacttgtgcggcttatga
-attgtctggactgcgggcgagggtccatatctccgaagttagaagggacatacctttaga
-tgataagatcaattcttattgacgaaattcatccacaacggggaacaacttcaccctaga
-cttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggct
-ggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggc
-tatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtgcctgtgatatta
-acaagatgatccgacgcgagcaccgtaattctaggcataaaactccagcaatttgggggc
-cgaaaacaaatgacgttagctaattaattatatgacatgatcaaaggaggtcaatcacgc
-atcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggca
-aaattgatcctgtctcctatttcatgcgtacctcctagttgataattccccgagcagtgg
-ttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgta
-tggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcagttcctattgatt
-tattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgtttatgattattg
-ctactttagatgctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaat
-tggatagaacctatagtttcaagttctgccacaaggtatcatatttacagttagtgctgg
-ttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggacc
-gagtgcgcgttcaaccctgttccagagagggtgtgatagcacatataccacgctcgtcga
-ggcgttcatgatagtttgcaagagccggtgttaaacacatattattattgttatccaact
-aatcggacctatgcataaagcattgtctaaacagaataattgcctatatacggtagtttt
-agtgatttatatcttagtatcagttagagcttcgaactcttcaggttcctcatatttaac
-gttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctat
-aaatcacagaaagatctgtctcagtatagttgaaatggtattcagctagtgacgtgtacc
-aattatcatagttcactcaagcaagacgctcattaacgaatatagacaagacactatatc
-atataataaaaaagaacatggtgctcgaacatagttgaattcaccatattgaaggggaat
-gctgacatgtaattcgctactagacgatcaattccctacttgtcaaagttgaactggtac
-gttcttggaattaaatatgattgcgctggaccaaattgcgacttcttgagtttcagggca
-aacgattgagccggaggatgtccgtctcttacctttcttgcttatgataaacgacggtcc
-ctgtacatcactgggaattctcagcaaaaataattgggtaaatcgagactcgatgtattc
-ggccacaaaggtgttagacgttaaagattattcaacggggcgataataggatcataaccg
-gtatgcaagcgcattgaaagagccatgagatccttatccgataaacgctgcacggtatgt
-gcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaagttgaagaccta
-agttataatgaagtgcaataccaaatcgattcatagtggattatcagactcaagatatct
-cctgataaattacagttgttaagatacggataaaatgagatttaagattagcagcctcta
-atctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctg
-tcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagttaatatgtagct
-tacgttctagcttgtgctaatctgagtatagattcgtagaggaatattatcaagcttcca
-cgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactat
-agtctagttgttaaatgctcagttcttgttatattcgatatactcttggctaatttatgt
-ctgagtatataaaattaatgatattaacttgcatttcacggatcccttagaaaaagattt
-tgaccgagcgcattataaacggttacaccgaatcaatagaagcatacccaatagctttct
-ttgaatttattgcctgcgcaacttggctgactctctagatccgaataattctatatggtc
-gtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgggccgataatggc
-tctttgcaaaattactcaatgatacgattgatcaaagcggtagttgctagtggtagcatg
-taagtctatcaaatgtctgattatccgaaaatcttccaaaagagtccacgtaccatatct
-atctcatagcgacgcgaggggaaccttatctaactatcattccatttaccgggtgactct
-cgatgcaggatccgattgggataaattgcccagaaatggctcattcctgactaagggtaa
-ggccgttctcagcaagggaaccccgcgaatctaggcttataccatctagattgttaacta
-cttgcctgtagttctacagccatactggacagttgtttctaaatgatcgggattcatgct
-agcactcctctgaatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatg
-gaggctgtatgtatcttaactgttacctaatatggctggtaattatcaaagtaaggacct
-taatgccatagcgctagcaatcgctttgtatactgaccatgtgccaacctctcttaatct
-gtaaaatataatgtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgt
-atcaattcctatagccagcgtactagtgacacaacaacaccgtgtgagaaaagatattag
-tccttacgtctgtctctctacagcttattgatgaggattgaacatggacatatagctccc
-cctcaaaagcagatgctacctctttattccattctcgaacatttgccgaacttaatttcg
-acaaacctgaggtcacgtcttaatttatcggtaacgtcacgtccctttgagactggataa
-atatattaccaggggccaacgagcaattgttggaggcgcttctataatacaaggtgtctt
-gtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaaccc
-ccctctctcacatcttatgcggtgtactgccctggtacatttcctgtacaggactccaac
-agtgtagattcctaagatagctgttggagttgcctcacgccagatcgaaaaactgaataa
-actagtgagctgagctgcagaaataccgcttaattacttatgactagttcaaagggacct
-acgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattttggctggactag
-cactccttacttcccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctga
-catttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatga
-ccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctggtcgttgaaacc
-aagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcat
-tagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaaaaaatattttta
-agcagtaggcacctaacccgattcctctacttagtagctttctttgattctcagaattga
-ctgcaatatcactgcacaattctgtgccattactagacttctctgtattaacgtctcatc
-ttactaacactcgcctaggacacatctgagagtgaagtatttcaatacatttactgaaat
-cttcagttctaaaatccccgaataaggctcttatcggtttggccaacacaagaaaaaaac
-ttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaataactatttcgg
-cagacaaagcttataacaagttgccggcgcgtataatatttaaaagaccccttgagctgc
-tcaattaaaacgctcacctggtataggctattagatagtgccgtcttagtaaggggcggg
-aattatcggataaactgatattttgataaaataaccgacttgttcacgacataagtcact
-aaggagattttatctttctccaaagtatatcttccttggataatttcaaagcgctgcaat
-ttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgtagtaatctagag
-gcaaattataagaagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccg
-gcgcattgtgtaaactggacgagtaccctagatggaaaattatacgttaagccaagattt
-cgatgtaatgataattacctacacatttttgctatccataggaacaagagctgttctata
-ggctcgtggcatacgaacatttgctgccgctatgaatattggaagctcttcaactacaga
-ctctattcttaattgccgtcgaaaatgggccgaatcggctattattaatactcggttttt
-ccgaggggattgttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatt
-taaatacaaccttgcagacaatgaataagggatccaatctctcatactccttttacaatt
-gctcatgcccctatgcaaaccttatgccgccacacctccgcaactctctcttctgaactg
-taagtagcttcattactggtttgagactatactgaagctgatgacattctaaaatggcta
-ttttcgaatgtgattcataatgtttatcgtttgggatggcagaatcacgttatttttgat
-atagcccgggtattctattgtatagaacgtatgctacaagtcattccccgaagaagacta
-gaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctttatttcccgata
-acctatcttccataaatagcggacagcaggatactgacgctcaacatcagtggttatggt
-ctaatttttaacttttaataaggtaacttcagcaggcatacacagtaactctttaattta
-taatcaaattagaagtctgacacttcttatatttttctatcatccaacgcgatcgcccat
-tagcttattgtgttactaataacgtatctaaaccaatccttttcaagctactgcctatat
-tgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtac
-gctttacaatacccggaaatcacaaactttgtagacaacgagtgaaatttatacactacg
-aagggccagcgtacaagacccatgaattaggcgatatgtttattctgacatattggttta
-tccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaaga
-ttcacgactgaaatataaatacgtttggctatatttatgttggagggaggcaatagcctt
-tactgttaaccgaagatttagccagtgagtgtgacactaaaacactggaataaatgcagg
-cgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatatagctctggatat
-aattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaagccggcctctca
-tattgaaggtccgaagtattccatgtacattaagatcactctctcattcatgcatcttgg
-cttaacaaatctggttgtccaagctttccaggcacgtatggtacaaattcggatcgaata
-cttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaa
-ccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagg
-gattagttatgttacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgca
-tcttttatcaagagactaacattattttcaacgacgtacatgctttacaatagggtactt
-atcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccgatatccattgga
-ccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtattgccataatgtaa
-tacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgc
-gcaacgtcaatacctttaggggtaacggccgctgatttcatatagatatacgataagttg
-gtatagctctactaggtggcatccacaatcgttgcatttactatagctggttacaatcat
-aatctataccgttccttacatactaccatagcgggatagcgtttttttgccgttgattgg
-gtttaagaggatgtcagtctcattatatccgattcggtgggagagccgttgttttcaaat
-cgcacactttgtgacataatgtacaagataacaaaactgatataagatataaactgtcaa
-tatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatttgactaattggg
-tgcagatttctcaattaataaaaaaatggcaccggatgggcttacaagccccttatcatt
-cacttgtatcatgatttccaagaacaatagaatttgctagcaagtatgaacagagattcg
-aattgcatccacagtacgccggagcgtttattttaatgtggatatgacgatgtactgttg
-gcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggag
-aaatatggtggtacaatctcagagaaagattacagtttggtttaaataggacttatcggg
-tcggaagtggaacttaataagcagtacacaattgggcaacagacgtcttgcctattacaa
-taggattacaatgcgttagatttcagacacgttcgtgtttggctattcgtcaattcccta
-aatagttagacgatcaactattatcaaagtgattctttgttcatcctccattcatgtaac
-agatggcacactacgcataacgccgaggaattttaacgagatttaagagagcagttcggg
-cacaacccacttgactttataacagctcggcagcataaacggtaatatgtgacaaatttc
-caaacgttataagaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgt
-gacgcagcaagcctaacttatctattggttttgctataaaagaacaaagttacacagaat
-cctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccgg
-cacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactccgggtatgataa
-tggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggttaggataaggatg
-agaccgaacttatttccggccataactttagattttctacctagtacacaacatcagggc
-ggacacgaaaccgccatcacatcatataccaggtttaatttgcttaatgggggaagtgtc
-aacgaaccttcgaactttagcaggcatatggccattatatatggccccagagcagaatgc
-tacagcagacaaaatttggatttatgtagtttaatacctatcaaacttggtgtgaccata
-cttgtctaacgacagtgcacaaagtgtaagttacaattattactactcagcagcttctgc
-aatgataaaatcttatcatacacgtcacatatgataatatctacttagggggaacgggct
-ccacaacctacatagtactcaatacttacactattcgacaggcacaccaaacctgtacag
-tcccaaaagattgagtcaactttgcagtactgcagatcacagtaatagcttagttagcga
-gtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgatgtgttggctaca
-aatagcaacgtatgaatttgtttgaagccacgtaaactgtacaaccttagagataagtct
-caggctactaaaaacacgttgtggcactaacaggatcatggttgattcttacttattcgg
-ctgaccggcccaataagtaaccttcaactagaacagaataatcgggagtagtttaattca
-gtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgtttt
-cttagcggattccctacttatggatttgagctcgtccacaatattcgatacaagaagttt
-gtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaaggaattaataga
-aggttgatggtaggctccgaacgctccatgattataatcaagtggactgtgcagtaaacg
-aggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagat
-aaaccatgaacagcacagtgtgaacccatggttgattttaggctaccttatttttaattt
-ccgttacacagaaacgaattccacaactaacatgccattaatttttcgatatcttataaa
-agatggtcgaaattcattcatttattttttttcggttctcgaaagtcaactaagctgtcg
-cgttttgtttctctttagaggtaaaagtggctttgatctcctacgtttggatactagtca
-accattactccatttgatccgtgagtatcacctgtctaacatccagcattatgactcctc
-ggcgaagaaaagacacacttcttagagtcgatgtgtattagctagggacacagttgttta
-atacgatagtgagcccagggagggcagtgcgtcccccagtagatttattcagctagtgta
-agtataagatatctcacccacgaggttcaagtgatatgcagtcttagaataatacttatc
-ctgaatttcgatattatgggtacttcaataatccgctagcgctactttatgtctcgttgg
-acagcaggacacatggcagtcttaaacactaaagacatcacctgaatgaatgtaatggga
-ttacaagaatcaatgaggtattatatacgacgtaggaaactctggatatatacagtaatc
-tagttacgccatcgcacttcattcctctggaaacttagaagacatcagctgtacgtggag
-gaaccagacccccgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaat
-gacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaaacccagcattta
-gcaataggagctacgtatgcaactcccacgtggtaataccttcaagctatcaatatatag
-gtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccagtataataattac
-agaggctctatgaaacccaactttccagctaaaagtcccaattaaatggttatttcgtac
-ttttaaagtcgcccgttctgttattacgcgaattgattctactccaaaattaaacacaaa
-ttatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataaggctctactaaat
-tataattaagacacttattaccagatttctctagttaagtttgaaccagctcgactaccg
-cgaaagatacattcccttctctatttttcagttcatctatgggtcagagaagcattgaat
-ttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaat
-atcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctg
-gaaggagtaagaagtatacagctgatccggtgtatccttcagtcatctgccctatactaa
-ttacacgacgcaaggaaaaataggtttattttctaggcaaacccttcataggtgactccg
-atgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggataataacgatctcc
-aatgaaccaaatgtagaatgtctattgattacccttttactattcgacttagagatagga
-gatagaacctcagtgtacttttttagccgaatgggaatctttgggaggtgaatggccata
-aggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgttcgtggaatcgat
-aacagatttgttgacccatagtaaatgtatactagtttatgttgtaagtgtagattgttt
-tccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaag
-tgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggttta
-gataaagccgtatgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcc
-cttataatagtagtttaactataaaagtatatactggtctgtcgccctttcacgatttgt
-tttaccggtttatgaagcgttacgtcattagagcggctccaatttaaggttaacggcttc
-catgtgtagttgtatacaaggataacttaaagtatctgttcagcgagctagttaagttat
-cctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttgctaatttattct
-caaggcaaattgggaattatcgatacctgtataccataaggtcgctcgatgtgatgctta
-tgtcttctggtgatcctaccttagttagtgctgattaacggaacattaatgtttatcgtt
-ttgagatttagccaattctctgattctaactcaagatgccttatctgacgtgctatgcag
-cccctaagtattttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgtt
-gtggttctctactggttaactatataatttacagctttgttgagctagttcctctttggt
-ttaagtcctcaatattagttggttcgagcgataagttggctagttaccttagtcactata
-ttagatccgaatgttatgcttcatctgaagaccgccaccctccaaaatttcttttaagac
-tcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacg
-agtttccatattttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtc
-gctctacaaggggacgcaattaagaaacagacatgctagtcaaaaataaacatagcgagg
-caccactaattcggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagt
-agttagttcggacatacatttacttcagatgatcaattagttttctacaaatgcttactc
-taccccgaaaaaagtcaccagactcttacgtctctttagtatccttccgtcttatataag
-gtcagtcccccgtttcggtaccctggaatttactaagaataatgaaacagcccccaagga
-cgtacgtttacaaatgatagaccagatcgcctagcttattccgacgcatgttgcatagaa
-ttgaaccaacggaatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgc
-agaatacgcctgatagttcggccacgaaatcatatgtcctttgagtattaagtatttgta
-atgatcaatcgagctcaagcaagcttacacttcctcggatattcagggaacttagtgcct
-ttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaatgcctacctcat
-agtgctgaattaacacagcactgcggacctaacttttcgaggtttcaagttcacgtctca
-aaacctaataggctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgta
-gtactgaccaagtgaatattctttttttctaaaagcagatctgctgccgggcactacgaa
-ggagatctctgtgtatcattattgcttcttgacatgatgactcttaaatcactgtgggtg
-tgcaaaacgatagcacaacccaattcgatagtacatattgttgatacttcgcactaaacc
-gttcatatttaaaggttgtgctccttccttcgttaaatactggtgacttggtcctatcta
-ctattagctagacctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtca
-tacatcttagacatcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaac
-aaatatgattattcttatactaatattagcaaagatgcataatgatttgtattaaatgta
-taattgaattgataagggtcttttagtcagtgatagagtagtataaggtagacattagaa
-ctcttaaccggacgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggta
-agagcggttactagtagtacctataatgcactgaatcttcggtcgaagtatagttctaat
-gctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgta
-agtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggg
-gaattaaccagattgaaggccaatcctcacatgtaatgagataatagacgataaatgaaa
-ttcttgtaatagttgaactgctacgtgatgggtattatatatgattgagatcctccaatt
-gccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgt
-cgtccgtatcataaacgacgcgacatgtacagcactccgaagtataagcaataataatgc
-gggtaatccagactagatcttttcggactcaatgcggtttcacggtaaacatgattaata
-ccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgtt
-gcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgac
-gaggcgcgggaacttcaagaactatcgtatattcaagtccattaccttttagtttcagac
-tggtggagctgactaaagttatatcatcattttgtacactggtttagttaacgataattt
-cagatttaacatgaccagacgataatcgctgtatatccagttggaatgtggtttgccaga
-aaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcg
-ctatacctcagtgtatttggagctgtagttataccgtgtgctaagatcagtagacatgac
-gagagcaatattatctaccttacaagcatcaacggacgtctagtcggaacaaaagactct
-aaaactcgaacttcaggttaatatactatagttctgtattcagcagttattcttatattc
-gatattatcttgcctattggatgtctgactttagtatattaatcatagtatctgccatgt
-aaaggtgccagtactaaatctgtttcacagtgcgaattataaacggttacaaccattaaa
-gacaacaagaccctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgat
-acatcccaattagtctatagggtcgggacgattctacggcatttctggttataatgacaa
-catggattgtggcccgagaatcgctctttcattaattaagcaatcattacagtcttataa
-gcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgagccgaatagctta
-aaaaacaggccaccgaacattgatagagaataccgaccacagcgcaacctttgattactt
-tcattaaattgtacggctcactcgacatcaagcttaagattgcgataatgtgaactcaaa
-tggatcagtactgaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgc
-tgttacaatatacagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttgg
-ttagaaatgatagccattcatgatagaaataagctgaatgataccagtatctttaactat
-gtagtcagggggaagataacgatggtccatgtatgtttctgatatgtgacagtattggcc
-gcgtaatttgctaacgaagctacttaatgcctttgagcttcatatagatttctttaatca
-aaatcggcaaaaagatagtatgagctataatatatgctagtagagaactctggaccatca
-tctatatgaatactgattcgagcgtgcaattactttagcctgcgtactactgactctaca
-aaacactctgagataagtttgtagtcagtaagtcgctctctataaaccttttggatgacc
-attgtacagccacttatagatcccaataaatagcacaggagacagagtttttcaatgctc
-gatcatttgccgatagtattttcgtctaacctcagggcacctattatttgatacctaacc
-taacggccctttcacaatggagaaatatatgacatcgggacaaacacaaatggtgggtgg
-ccaggagatatgacatggtggcgtctctaagaaacacggactccctctaggcaaactcac
-gtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggt
-acattgactggtcaggaatacatcactgtagttgccgtagtgtcctgttggtgttccatc
-aagacacatcgtataacgcaatttacgacggacatcagatcaagttatacagattattta
-agtatcacgtgtgcattgggacataagggatctcacacatgccttggaacatttttgctt
-tgtgccgctttttcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaa
-cagaatgagaaaggttagggctctaagttatcgtcgattgggatagacgagacatttgcg
-agcgccctccacggatacgaatctcccatatcaatgtgaactggatgctatgcagtttag
-ttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacc
-taatacacaaaaccgtcaaacattttctaattctaggtatgggccgatcataggagctaa
-ggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgcatatactgagta
-gctggcgtgcattctctcaattgtatcctttttaactgaactagtcggtcccatttcgtg
-actgagatctattaaccgataagattaataacactcgcattcgtatcagctcagagtgaa
-gtttttcaataatttgactgatatattaacttctaaaataaccctttaagcctcggatcc
-gtttcccaatcacatcaaaaattcttattccaactatctacggattaacaacgtgcatgg
-ggatcgtagtaagaacttgttccgatcactttgagtatatcaagttgacggcccggttat
-tattgaatagaaacattcacctgctaaattaaataccgcacatcggatacccgatttcag
-agggccgtcttactaagggcaggctttgttcggtttaactgagatgttcattattttaca
-gtatgcttcaactaatatgtaacgaaggacagtggatctgtctccatagtagatcttcag
-tcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtg
-aaagcaacccctagtattctagacgaaaattttttctagttcatctgataatttgccaat
-tcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcgaacctagagcca
-ttatttgtcggtaacccatgagttccttcttttcagaagttaatacactgtggtcctata
-cagaggaaaaacagcggttatatacgatcgtggcataacaacattggatcaagatagcaa
-tttggctacctattctaattctcactagattcggtattccactacaatatcggcagatta
-ggattggatgaataatcggtgtttaagtccggttgcgtctccaatctcctaatttttatt
-aatattgatcttggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaa
-agatagaagactcatttgaaaatggatcatccacagatccaaacattagcaagacactaa
-tccccaactagctattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgtt
-catgatctaattctttttgggctttgttcgatggtgattcagaatctttatccggtcgct
-tccctgtagctactttgtggggatattgcccggggattatagggttgagatcgtttccta
-aaagtatttaaaccaagtagacttcaactaaactacatcagaacatcgtgaagacaccat
-acgcggtacctttatttaccgataacatttcttcaagaaataccggtaagcagcataatg
-accctaaacagctcggggtatcgtcgtagttttaaattttatttaggttactgctcaagg
-aataaaaactaactatttaatttataataatattacaaggctcacactgattagatttgt
-ctataagacttcgcgatcccccattaccggattgtcttaagaataaactagataaaccat
-gcattttctagataaggcctttagtctaattagatacaaaaaacacgatagttgcatcct
-taatttattgtgtcaaacctggaaccttttaattacccgcaaatcactttatgtcgagac
-tacctctgaaatttattatctacctaccgcatgaggacttgaaccatcttgtaggagtta
-tgtttattagctaagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaa
-gcactcagaattgtttttagttgagtcaagactgatatataaataagtttccctagtttt
-ttcgtggtgggacgatattgaattgaatcttaaccgaagagtttcccactctgtcgcaca
-ataatacacgccaatatttccagccctgcttatgccttaatcggttactcaatctcccat
-tgaagttcattttgatctgcatagaagtttcgggcccagccttttttctgccaccttcct
-ccaagctctgtagacgcactctaagattgatgctcacatgtattaattctacattaacat
-aaatatataagtcatgcatcttcgagtaaaatatctggttctccaacatgtcctggcacg
-tatcgttataatgcccatacatgtagtattaaaatgattgggttaactggatattaagat
-catcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctc
-ggaagggctattacgcttacttccgttttggtatcttaatatgactttcaaaaattaagt
-tgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaac
-tacttgctttacaataccggtcgtatatatcgccgtgaatccagaagattgtcttctttg
-gattatcaaccgagatcctgtggaccgatgttttgggaccttcacagaggactccaggta
-gagctcgcttttgcattaatctaagaattgtacctctctaaaagatctaaaacagtgaat
-gtgtatttcatggaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgag
-ttattatacatatacgagatggtggtatacatcgaattcggggcatacactatagttgca
-ttgtatttagctgctttaaataatatgatattaccttccttacataagacattaccggca
-taccctggttttcaacttgtggggctttttgacgatcgcactctcatttgatccgagtag
-ggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaatagattactttt
-cgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacga
-gaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaagga
-tgcgcggaatagaaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgc
-cgacataggatgaaatcagattccaatgcaatacacagtaacccccacccttgattgtaa
-tgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtg
-cgatcaactatgaatctcggcgagttagatggtcgtacaatctcacacatagaggtcact
-tgcctgtaatgacgaattttcggctaggtactcgaactttattagaagtaaaaatgtggg
-caaaagaaggattccattttacaagacgattacaatgagttacatgtctctcaacgtagt
-ctttccctagtagtctttgaactatttaggtactccagaaaattttagcaaagggtttct
-gtgtgaatccgccattcatgtttatgatggaacaataagaataacgccctcgtatgttat
-cgacagtgaagtcagcagttcggccaaaaacatattcaatttagtacagatccccagaag
-ttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtctaattactatact
-aacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagtgtcgttttgcta
-tatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttaggacttcggattc
-tcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcc
-tgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaacta
-ttgatagtcgggagcataaccaggtgaacgtactttgttcacgacatttattgacatgtt
-ctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggttt
-aagggccgtaatgccggtagtgtcaaacttcatgagaactttagctggcttttggccagt
-atttagggaccaagagcactagccttaagctgaatattttgccatttatctactgttata
-actttaaaacttggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaa
-ggtttactaagaacaagcgtaggaattgagtttatattatatttaaactaaaagatgata
-ttagcttctgagggcgatagggctccaaatcataaagaggaatatattattacacgatta
-gaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttggcagtactccaca
-tctcagtaatacagttgggagagtctcaaatgttgttttattactcaatgaaccaccctc
-ataatttcactgctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaa
-atcgacaaaattacagataagtagatgcataataaaaaaaactgctcgctataacacgat
-catcgtgcattcttacttaggagcatcacccgcacaataacgtaccttaaactacaacac
-tattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctct
-ctcgtaaaatgtgataatagtttgcggagaggattcaattattttccattgcacctactc
-cactagattcgataaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcgga
-accataagcaaagcatgtaagtgaaccgtcatccttccctaagaaacataaaggttttta
-ataatgtcgactgtgaactataactgcatcctttcctgacctactccggttccttgttgt
-tatttctgaacgagaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcat
-gtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaa
-attaattttgccttttattttttttcaggctcgaaattaatgatttgttttttttgacct
-tctagttacgctaatatgcggtcgcctgtggtttctattgagtcctataacgggatggga
-tctaatacgtttggttactagtaaacaaggtataaatttgataccggagtatcaactgta
-taacatcaagctttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcg
-agtacagagccactaaggggtgtattacgatagtgacaccaccgagcgcactcactcccc
-aagtagatttatgatcctacgctaagtattagatatataaccaaagaggttctagtcagt
-gcaactcttagaataataattagccggttttgcctttttaggcctaatgcaatattcagc
-tagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaa
-atataatctatgaatgttatgccagtacttgaataaatcaggttttttataagtccttgc
-atactctcgttatatactgttagagtcttaccccatagaaattctttcatctgcaaactt
-agaagaattctcagctacggggagcataaagtccccaggatgttgacaaatacaacaaat
-gtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagttttagccgaacct
-tgtacggataaatccctccattttccaatagcagatacctatcctactacctcgtggtat
-taaattaaagcttgaaatatagagctgcatagcttatccaattcccaagcacgagtctac
-cgtcgtaaccacgatttgatttacagacgctagagcaaacccatctttaaacatataagt
-aaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgt
-ttataagccataattaaaaacatatgttcaacaggttcattgatatttgtaattgcacag
-gtttttaataaggatctacgtaagtataatgaacaaactttttaccagagttatattctg
-tactttgaaaatgctcctctaccgccttagagactttcaattagattttttgcagttaat
-ctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgt
-ctgtctcataactgtaggtctaatataattttcagttttcgaacacataaccctttgaaa
-atctgctatttaatgtctcacctgcatgcactatcttctatactgctcagaacggctata
-cgtcactatgctccaagtgacgatttaaacgaagcaaggaataataggtttattttagtg
-caaaacaattaagtgcggactacgtgctctttacaataagccttgtgattgggctatagg
-ttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctttgcattacccgg
-ttactagtcgaattacagatagctgttagatactcactctaattttggacaacaatccca
-atcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaaacgattacatat
-tatagacttgttcggggtagagatatcacagttgtgcaaacattgtaaatcgatactagt
-ttatgttggtagtctagttgcttttaccattccccgaaaaacttgatctactatttcgac
-aacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgt
-ccactatatgtaagtgtagctttacataatccactatgactgagatcattacggcctagg
-aaagcagcgtagaaaaaaagggcccggatattacgactgtaactataaaactagttactg
-gtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaacgaatttcagccg
-cgaaaattgatccgttaaccagtccatctcgacttctataaaacgataaagtaaagttga
-tgttcagcctccttcttatggttgcatcgagagtacactactcagtgggaaatagatcgg
-ggttcctacttcagattgtattatctaggcaattgccgattgtgccatacctggataaaa
-taagctacctacatgtgatgcttatctattatcgtcatactaccttagggtgtcctgttg
-aacgctacattaatctttagccgtttgagatgttccaatggataggagtctaacgcatga
-tgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagac
-gttataaatagaaaaaaggtccttctggttctattctgctgaactattgaatggaaagat
-tggttgacctacgtactatttgcttgaagtcatcaatttgacggggtgagagacatatgg
-tgcatactttacggactctatattttagatcagaagcttagcagtcttctctacaccccc
-tcacgacataattgcttttaagaatctatgtttgattcctctacgggaattcggatccgt
-tcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagcatacgaacactt
-tgctaactagacgtatgtatagtagctataaatcccgacgatatttacaaaaagaaatga
-gactcaaatatatacatagcgaccctacacttattcgcaccctgatctaggcgatcctag
-cacccacacccgaaagtgagcactagtgtcttccgtattaaatttactgcagttgagatt
-ttagttgtctactaaggattactctaacccgtaataaggatcaagactcggtactagctt
-tactatcattccctatgtgttttcctaactcacaagggtacgtaccagcctatgtaatta
-caataatgataaagacacaaaggaagtaactttacaaatgagtctccagttacactagct
-tagtccctcccatcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaa
-gaacactcataacgttggagtccaagaattagactcatagggcccccaacatttaatatg
-tactgtgagtttgaaggtgttctattgttaattcctgctcttgatacatgacacgtactc
-cgtgtttaaggcttcggactgactttctttcataagttgagcaacgaaaatttcagaatc
-gataagttggattcactaactaatacggctgattgaaaactccactccggacctatatgg
-tcgacctttatacgtaaccgatataaaacttataggctggtatatcgagccttcctagcg
-caatttcggatggggtttcttctactactcaacaacggaatagtctttgtttagtaaacc
-agagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtcattatggactgg
-agcactcttaaatcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaat
-tttcttgatacgtcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaa
-atacggctgtcgtgctcagatatactattagcgactcatctcgcctaacacgcacacgta
-taaactcggaatgactgccgctcttacatattagaaatacagactacaccacggaagcat
-tgggtcattctcaaccgctgtataaaagatgattagtcttataataagattaccaaagag
-gcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtg
-aggacgagatggtactcaggacaaatattaaccggacgaagtggtttacgtcgtactttc
-actattagtagtaaatacaaggtaacaccggggaatagtactaaatataatgatatctat
-cttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgact
-tatagcatgatacaaccgattgttacttttgtctattcaaaagattgaatagttttttat
-acaaaagccgcatacttatgacggctagtatacagtttcatcccctagcatcaatgctat
-ggacagtattgaacttataggaaattcttctaatagggcaaatccgtcgtgatgcctatt
-ttttttcagtcacatcctcaaatggcactagtattgtcgggatcccattaacaggctcaa
-ccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaact
-cccatggataaccaattataaggcccgtaatcctctagacatcgtttaccaataaatccg
-ctttctccgtaatcatgttgaataccccagagtagtccagatgataaccgatgaaacaca
-agtctttctcaatgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgc
-gacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaa
-cgccttgtaattttactttaagacgcctggtgatgtagattcttagataatcagtttgtt
-atcggctgtactttaccataatttcacaggtttcaggtcaagaagattatagctgtatat
-acagttccatgctcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtc
-tttaggcgtatccaatacatgccccgataccgcagtgtatttcgacatgtaggtataccg
-tcgcatttgagctcgagtcaggacgtcagctagattagattccttaatagaatataccga
-cctctagtccgaactaaactatagataacgccaacttcaggttaattgtctagtcgtctg
-tttgcagatgggattcttagatgagtgagtatcggccatattggttcgagcactttagtt
-tttgatgcataggatatgcaatgtatagctgaaagtactttatctgtttcaaactcacat
-tgattaaaccggtaaacctttaaagactacaagaaaatattcagtgagggcaattttgtc
-aatcacaatcttccagctagagatacttcacaatttgtcttgaggctacgcaacattaga
-cggattttcgcgttttattgaaataatcgaggggcccaagagtatccatagttcattttg
-taagatttctttacaggcttattacagcttcttcagactcctacatgcttacgagttata
-tgctagcatgtgaacaatagattaatatacaggaaaacgtacattgagagagatgaccct
-acacagcgcaaccgttgagtactttcattaaagggtaacgctctcgagacagcatcctta
-agatggccttattgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaag
-aatccctacaaacacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcg
-gagtatcaatttcgccaatcttggtgagaaagcataccctttcttcagagaaagaagatc
-aatcataacactatctttaacgaggtacgcacgcgcatcattacctgcctccatggatct
-ttaggatagcggaaagtattggcagcgtattgtgatttcgttcctactttatcaatttca
-cattcatatacatgtcttttatcaaaatcgccaataagataggatgagctatattagatg
-ctagtagagttcgcgccaacatcatcgataggaatactcaggacagcgtgataggacttt
-tcaatccctaatactctctataattataactctctcttaagtttggaggcagtaacgcgc
-tctatataatcagtttgctgcaccattcttcagcctctgatacatacaaataaattccac
-agcagtaagagggtttaattgagacatcttgggaacttaggattttactctaacatcacc
-gaaacgattattggataccgtacctaaacgaactttctcaaggcagtaatataggacatc
-cgcaataacacaaatgctgcctccccaggagttatgtcttcctggaggctatatcttaca
-cccactcactataggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataa
-gagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaa
-gttctgtcctgttcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatc
-tcagcaagttataaacatgttggaagtttctagtcggaattcccaaagaacggatctatc
-taatgcattcctacatttttcctgtctgccgatggtgccatcctattcaaagaatttctt
-aaaagtagattaaatgggacttttaacaatgagtaaccttacgcctctaagggttcctcg
-agtgccatacaccagtcaggtccgagccacatacacggagaacattctaacatagcattc
-tcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaaatcatacttgca
-atcccatagcacggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttg
-gtatgggaacatcattgcagctatggtctaacgcattaatgtttgggtacatcttccatc
-atataaacaggaagagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaa
-tcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaata
-gaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatatatgatctgcttt
-aataaaactttatccataggatacgtttccaaatcaattcaataattattagtcaaaata
-gataaggatgaacaacctgaaggccgatcggacgtagaaagtggtcccatcactttgagt
-tgatattgttgaaccacacgttattatggttttcaaacagtctcaggatattgtatatac
-agataatccgataccagttgtctgacgcccctcttacgtaccccaccctttgtgacgttt
-aaagcagttgttcagtattttaaactaggcggcaactaatttggaaagaagcacagtgga
-tatgtctaaattcttgttattcaggcctgaatttaatacaccgcatagttaacttcgcgg
-tagagttgttcatcatgcctcctctaagctaccacttctatgatacaccaatagttgttc
-tacggaatctgataattggccaagtcataaacttccgctgcgttcaacccccttgctcga
-atatccaactcgaaaagacagccttttggtgtccggaacaaatcagttacttcttttctg
-atgttaattctctgtggtcagatacagaccaaaaactccgcggatttaccatcctccaag
-aacaaatttgcatcaacatagcattttggctacatattctaagtctcaatagtttaggtt
-ttcaactacattatcccaacattaggattggaggaataatagctgggtaagtccccttgc
-gtctacaatcgactattttttatgaatatgcttctgccgcacctatggttattaaaaaag
-tcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaag
-agcatataattagcaacactctaagaacattatagatatgatgatagcgatcgtcatgat
-gttatccggtcacaatagtagcttcatcagctaattcgttttgccagtggtgacttgcgc
-tggaagaatcgttatacggtcccttccctcttgatacggtgggggcttattcaaccgcgt
-ggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagtcaactatactaa
-atcacaaaatagtgatcaatacatacccgcttcatggttttaaccatttaattgattaaa
-gatattccgctaagaaccattatctacctaaactgatcgccgtatcctagtagtttgaaa
-tttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgtagaataataggtc
-ttggagctaaatgatgtgattggtagtgaagacttacccttacaactttaccggtttctc
-ggaagaatatactagagaatcaatgcatgggctacataagcactttagtctaatgagata
-aaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaacctggtaattta
-aaccatatatctttatgtcgtcaataactctcatatgttttatataacttcccaatcacg
-acttgtaactgcttgttcgactgagctgtttgagctatgaggccgggatccggttgagct
-acatctatttgctacaagaaaaatgaaagcacatttgttgggagttctggctacactcat
-agagaaataagtggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaacc
-aagtggttccaacgctcgcgctaaagaattaaagcctttatttcctccacggagtagccc
-gtaatccggttcgaaagagaccattgaagttaattttcatatccagtgaagtttaggcac
-aagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaa
-cttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcgagttaattttcg
-ccttctccaacatggcatccctacgttcgttataaggaccatacatgtaggttttaaagg
-tttgcggttaatcgatatttacatcatagaaattctatagtcaaatttacaagactctag
-atactcactcgttgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcg
-taatatgaatttcatatagtaagttcaaggcactcatacctccgtgaagagggtagatag
-actattaaagttgtttaatagtacgtattgatggaaatgacccgtaggagatttaccact
-caatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgg
-gtccttcaaacacgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccga
-gataaatgagctataacactgtatgtcttttgattgctataaaacacagaaacggatatt
-aatttaggccgtaaccaacatctgttatttgacatagaacagatggtcctttacagcgta
-ttccggccttaatattgaggtccagtgtattgtcctcctttaaagaagttgattgtaact
-gacttaaataagacatgtcacccattcactgggttgcaactgctggccctttttgtccat
-cgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcg
-ctatgaaggttattcattaattttagctgttttcttagaaaaggtaaatttaaaattgaa
-aaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgaga
-ttgtaagaaataaagccataaccagccccggaatagaaaatgttaaggaaaggcgatctt
-ctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaa
-tctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcag
-aggataacggaatgtggttccgtcccataaacgatcattctcgcccacttagtggcgcgg
-taaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggctaccttctccaa
-ctttagtacaacgaataatgtccgattaacaaggagtcaatttgtcatgaccagttcatt
-caggtacttgtatctatacggacgcgttccagagtagtatttgaaattttgaggttctac
-tgataagtttagctatcgctgtatgtctgaataagaattt
diff --git a/bench/src/data/sherlock.txt b/bench/src/data/sherlock.txt
deleted file mode 100644
index c4c3130503..0000000000
--- a/bench/src/data/sherlock.txt
+++ /dev/null
@@ -1,13052 +0,0 @@
-Project Gutenberg's The Adventures of Sherlock Holmes, by Arthur Conan Doyle
-
-This eBook is for the use of anyone anywhere at no cost and with
-almost no restrictions whatsoever.  You may copy it, give it away or
-re-use it under the terms of the Project Gutenberg License included
-with this eBook or online at www.gutenberg.net
-
-
-Title: The Adventures of Sherlock Holmes
-
-Author: Arthur Conan Doyle
-
-Posting Date: April 18, 2011 [EBook #1661]
-First Posted: November 29, 2002
-
-Language: English
-
-
-*** START OF THIS PROJECT GUTENBERG EBOOK THE ADVENTURES OF SHERLOCK HOLMES ***
-
-
-
-
-Produced by an anonymous Project Gutenberg volunteer and Jose Menendez
-
-
-
-
-
-
-
-
-
-THE ADVENTURES OF SHERLOCK HOLMES
-
-by
-
-SIR ARTHUR CONAN DOYLE
-
-
-
-   I. A Scandal in Bohemia
-  II. The Red-headed League
- III. A Case of Identity
-  IV. The Boscombe Valley Mystery
-   V. The Five Orange Pips
-  VI. The Man with the Twisted Lip
- VII. The Adventure of the Blue Carbuncle
-VIII. The Adventure of the Speckled Band
-  IX. The Adventure of the Engineer's Thumb
-   X. The Adventure of the Noble Bachelor
-  XI. The Adventure of the Beryl Coronet
- XII. The Adventure of the Copper Beeches
-
-
-
-
-ADVENTURE I. A SCANDAL IN BOHEMIA
-
-I.
-
-To Sherlock Holmes she is always THE woman. I have seldom heard
-him mention her under any other name. In his eyes she eclipses
-and predominates the whole of her sex. It was not that he felt
-any emotion akin to love for Irene Adler. All emotions, and that
-one particularly, were abhorrent to his cold, precise but
-admirably balanced mind. He was, I take it, the most perfect
-reasoning and observing machine that the world has seen, but as a
-lover he would have placed himself in a false position. He never
-spoke of the softer passions, save with a gibe and a sneer. They
-were admirable things for the observer--excellent for drawing the
-veil from men's motives and actions. But for the trained reasoner
-to admit such intrusions into his own delicate and finely
-adjusted temperament was to introduce a distracting factor which
-might throw a doubt upon all his mental results. Grit in a
-sensitive instrument, or a crack in one of his own high-power
-lenses, would not be more disturbing than a strong emotion in a
-nature such as his. And yet there was but one woman to him, and
-that woman was the late Irene Adler, of dubious and questionable
-memory.
-
-I had seen little of Holmes lately. My marriage had drifted us
-away from each other. My own complete happiness, and the
-home-centred interests which rise up around the man who first
-finds himself master of his own establishment, were sufficient to
-absorb all my attention, while Holmes, who loathed every form of
-society with his whole Bohemian soul, remained in our lodgings in
-Baker Street, buried among his old books, and alternating from
-week to week between cocaine and ambition, the drowsiness of the
-drug, and the fierce energy of his own keen nature. He was still,
-as ever, deeply attracted by the study of crime, and occupied his
-immense faculties and extraordinary powers of observation in
-following out those clues, and clearing up those mysteries which
-had been abandoned as hopeless by the official police. From time
-to time I heard some vague account of his doings: of his summons
-to Odessa in the case of the Trepoff murder, of his clearing up
-of the singular tragedy of the Atkinson brothers at Trincomalee,
-and finally of the mission which he had accomplished so
-delicately and successfully for the reigning family of Holland.
-Beyond these signs of his activity, however, which I merely
-shared with all the readers of the daily press, I knew little of
-my former friend and companion.
-
-One night--it was on the twentieth of March, 1888--I was
-returning from a journey to a patient (for I had now returned to
-civil practice), when my way led me through Baker Street. As I
-passed the well-remembered door, which must always be associated
-in my mind with my wooing, and with the dark incidents of the
-Study in Scarlet, I was seized with a keen desire to see Holmes
-again, and to know how he was employing his extraordinary powers.
-His rooms were brilliantly lit, and, even as I looked up, I saw
-his tall, spare figure pass twice in a dark silhouette against
-the blind. He was pacing the room swiftly, eagerly, with his head
-sunk upon his chest and his hands clasped behind him. To me, who
-knew his every mood and habit, his attitude and manner told their
-own story. He was at work again. He had risen out of his
-drug-created dreams and was hot upon the scent of some new
-problem. I rang the bell and was shown up to the chamber which
-had formerly been in part my own.
-
-His manner was not effusive. It seldom was; but he was glad, I
-think, to see me. With hardly a word spoken, but with a kindly
-eye, he waved me to an armchair, threw across his case of cigars,
-and indicated a spirit case and a gasogene in the corner. Then he
-stood before the fire and looked me over in his singular
-introspective fashion.
-
-"Wedlock suits you," he remarked. "I think, Watson, that you have
-put on seven and a half pounds since I saw you."
-
-"Seven!" I answered.
-
-"Indeed, I should have thought a little more. Just a trifle more,
-I fancy, Watson. And in practice again, I observe. You did not
-tell me that you intended to go into harness."
-
-"Then, how do you know?"
-
-"I see it, I deduce it. How do I know that you have been getting
-yourself very wet lately, and that you have a most clumsy and
-careless servant girl?"
-
-"My dear Holmes," said I, "this is too much. You would certainly
-have been burned, had you lived a few centuries ago. It is true
-that I had a country walk on Thursday and came home in a dreadful
-mess, but as I have changed my clothes I can't imagine how you
-deduce it. As to Mary Jane, she is incorrigible, and my wife has
-given her notice, but there, again, I fail to see how you work it
-out."
-
-He chuckled to himself and rubbed his long, nervous hands
-together.
-
-"It is simplicity itself," said he; "my eyes tell me that on the
-inside of your left shoe, just where the firelight strikes it,
-the leather is scored by six almost parallel cuts. Obviously they
-have been caused by someone who has very carelessly scraped round
-the edges of the sole in order to remove crusted mud from it.
-Hence, you see, my double deduction that you had been out in vile
-weather, and that you had a particularly malignant boot-slitting
-specimen of the London slavey. As to your practice, if a
-gentleman walks into my rooms smelling of iodoform, with a black
-mark of nitrate of silver upon his right forefinger, and a bulge
-on the right side of his top-hat to show where he has secreted
-his stethoscope, I must be dull, indeed, if I do not pronounce
-him to be an active member of the medical profession."
-
-I could not help laughing at the ease with which he explained his
-process of deduction. "When I hear you give your reasons," I
-remarked, "the thing always appears to me to be so ridiculously
-simple that I could easily do it myself, though at each
-successive instance of your reasoning I am baffled until you
-explain your process. And yet I believe that my eyes are as good
-as yours."
-
-"Quite so," he answered, lighting a cigarette, and throwing
-himself down into an armchair. "You see, but you do not observe.
-The distinction is clear. For example, you have frequently seen
-the steps which lead up from the hall to this room."
-
-"Frequently."
-
-"How often?"
-
-"Well, some hundreds of times."
-
-"Then how many are there?"
-
-"How many? I don't know."
-
-"Quite so! You have not observed. And yet you have seen. That is
-just my point. Now, I know that there are seventeen steps,
-because I have both seen and observed. By-the-way, since you are
-interested in these little problems, and since you are good
-enough to chronicle one or two of my trifling experiences, you
-may be interested in this." He threw over a sheet of thick,
-pink-tinted note-paper which had been lying open upon the table.
-"It came by the last post," said he. "Read it aloud."
-
-The note was undated, and without either signature or address.
-
-"There will call upon you to-night, at a quarter to eight
-o'clock," it said, "a gentleman who desires to consult you upon a
-matter of the very deepest moment. Your recent services to one of
-the royal houses of Europe have shown that you are one who may
-safely be trusted with matters which are of an importance which
-can hardly be exaggerated. This account of you we have from all
-quarters received. Be in your chamber then at that hour, and do
-not take it amiss if your visitor wear a mask."
-
-"This is indeed a mystery," I remarked. "What do you imagine that
-it means?"
-
-"I have no data yet. It is a capital mistake to theorize before
-one has data. Insensibly one begins to twist facts to suit
-theories, instead of theories to suit facts. But the note itself.
-What do you deduce from it?"
-
-I carefully examined the writing, and the paper upon which it was
-written.
-
-"The man who wrote it was presumably well to do," I remarked,
-endeavouring to imitate my companion's processes. "Such paper
-could not be bought under half a crown a packet. It is peculiarly
-strong and stiff."
-
-"Peculiar--that is the very word," said Holmes. "It is not an
-English paper at all. Hold it up to the light."
-
-I did so, and saw a large "E" with a small "g," a "P," and a
-large "G" with a small "t" woven into the texture of the paper.
-
-"What do you make of that?" asked Holmes.
-
-"The name of the maker, no doubt; or his monogram, rather."
-
-"Not at all. The 'G' with the small 't' stands for
-'Gesellschaft,' which is the German for 'Company.' It is a
-customary contraction like our 'Co.' 'P,' of course, stands for
-'Papier.' Now for the 'Eg.' Let us glance at our Continental
-Gazetteer." He took down a heavy brown volume from his shelves.
-"Eglow, Eglonitz--here we are, Egria. It is in a German-speaking
-country--in Bohemia, not far from Carlsbad. 'Remarkable as being
-the scene of the death of Wallenstein, and for its numerous
-glass-factories and paper-mills.' Ha, ha, my boy, what do you
-make of that?" His eyes sparkled, and he sent up a great blue
-triumphant cloud from his cigarette.
-
-"The paper was made in Bohemia," I said.
-
-"Precisely. And the man who wrote the note is a German. Do you
-note the peculiar construction of the sentence--'This account of
-you we have from all quarters received.' A Frenchman or Russian
-could not have written that. It is the German who is so
-uncourteous to his verbs. It only remains, therefore, to discover
-what is wanted by this German who writes upon Bohemian paper and
-prefers wearing a mask to showing his face. And here he comes, if
-I am not mistaken, to resolve all our doubts."
-
-As he spoke there was the sharp sound of horses' hoofs and
-grating wheels against the curb, followed by a sharp pull at the
-bell. Holmes whistled.
-
-"A pair, by the sound," said he. "Yes," he continued, glancing
-out of the window. "A nice little brougham and a pair of
-beauties. A hundred and fifty guineas apiece. There's money in
-this case, Watson, if there is nothing else."
-
-"I think that I had better go, Holmes."
-
-"Not a bit, Doctor. Stay where you are. I am lost without my
-Boswell. And this promises to be interesting. It would be a pity
-to miss it."
-
-"But your client--"
-
-"Never mind him. I may want your help, and so may he. Here he
-comes. Sit down in that armchair, Doctor, and give us your best
-attention."
-
-A slow and heavy step, which had been heard upon the stairs and
-in the passage, paused immediately outside the door. Then there
-was a loud and authoritative tap.
-
-"Come in!" said Holmes.
-
-A man entered who could hardly have been less than six feet six
-inches in height, with the chest and limbs of a Hercules. His
-dress was rich with a richness which would, in England, be looked
-upon as akin to bad taste. Heavy bands of astrakhan were slashed
-across the sleeves and fronts of his double-breasted coat, while
-the deep blue cloak which was thrown over his shoulders was lined
-with flame-coloured silk and secured at the neck with a brooch
-which consisted of a single flaming beryl. Boots which extended
-halfway up his calves, and which were trimmed at the tops with
-rich brown fur, completed the impression of barbaric opulence
-which was suggested by his whole appearance. He carried a
-broad-brimmed hat in his hand, while he wore across the upper
-part of his face, extending down past the cheekbones, a black
-vizard mask, which he had apparently adjusted that very moment,
-for his hand was still raised to it as he entered. From the lower
-part of the face he appeared to be a man of strong character,
-with a thick, hanging lip, and a long, straight chin suggestive
-of resolution pushed to the length of obstinacy.
-
-"You had my note?" he asked with a deep harsh voice and a
-strongly marked German accent. "I told you that I would call." He
-looked from one to the other of us, as if uncertain which to
-address.
-
-"Pray take a seat," said Holmes. "This is my friend and
-colleague, Dr. Watson, who is occasionally good enough to help me
-in my cases. Whom have I the honour to address?"
-
-"You may address me as the Count Von Kramm, a Bohemian nobleman.
-I understand that this gentleman, your friend, is a man of honour
-and discretion, whom I may trust with a matter of the most
-extreme importance. If not, I should much prefer to communicate
-with you alone."
-
-I rose to go, but Holmes caught me by the wrist and pushed me
-back into my chair. "It is both, or none," said he. "You may say
-before this gentleman anything which you may say to me."
-
-The Count shrugged his broad shoulders. "Then I must begin," said
-he, "by binding you both to absolute secrecy for two years; at
-the end of that time the matter will be of no importance. At
-present it is not too much to say that it is of such weight it
-may have an influence upon European history."
-
-"I promise," said Holmes.
-
-"And I."
-
-"You will excuse this mask," continued our strange visitor. "The
-august person who employs me wishes his agent to be unknown to
-you, and I may confess at once that the title by which I have
-just called myself is not exactly my own."
-
-"I was aware of it," said Holmes dryly.
-
-"The circumstances are of great delicacy, and every precaution
-has to be taken to quench what might grow to be an immense
-scandal and seriously compromise one of the reigning families of
-Europe. To speak plainly, the matter implicates the great House
-of Ormstein, hereditary kings of Bohemia."
-
-"I was also aware of that," murmured Holmes, settling himself
-down in his armchair and closing his eyes.
-
-Our visitor glanced with some apparent surprise at the languid,
-lounging figure of the man who had been no doubt depicted to him
-as the most incisive reasoner and most energetic agent in Europe.
-Holmes slowly reopened his eyes and looked impatiently at his
-gigantic client.
-
-"If your Majesty would condescend to state your case," he
-remarked, "I should be better able to advise you."
-
-The man sprang from his chair and paced up and down the room in
-uncontrollable agitation. Then, with a gesture of desperation, he
-tore the mask from his face and hurled it upon the ground. "You
-are right," he cried; "I am the King. Why should I attempt to
-conceal it?"
-
-"Why, indeed?" murmured Holmes. "Your Majesty had not spoken
-before I was aware that I was addressing Wilhelm Gottsreich
-Sigismond von Ormstein, Grand Duke of Cassel-Felstein, and
-hereditary King of Bohemia."
-
-"But you can understand," said our strange visitor, sitting down
-once more and passing his hand over his high white forehead, "you
-can understand that I am not accustomed to doing such business in
-my own person. Yet the matter was so delicate that I could not
-confide it to an agent without putting myself in his power. I
-have come incognito from Prague for the purpose of consulting
-you."
-
-"Then, pray consult," said Holmes, shutting his eyes once more.
-
-"The facts are briefly these: Some five years ago, during a
-lengthy visit to Warsaw, I made the acquaintance of the well-known
-adventuress, Irene Adler. The name is no doubt familiar to you."
-
-"Kindly look her up in my index, Doctor," murmured Holmes without
-opening his eyes. For many years he had adopted a system of
-docketing all paragraphs concerning men and things, so that it
-was difficult to name a subject or a person on which he could not
-at once furnish information. In this case I found her biography
-sandwiched in between that of a Hebrew rabbi and that of a
-staff-commander who had written a monograph upon the deep-sea
-fishes.
-
-"Let me see!" said Holmes. "Hum! Born in New Jersey in the year
-1858. Contralto--hum! La Scala, hum! Prima donna Imperial Opera
-of Warsaw--yes! Retired from operatic stage--ha! Living in
-London--quite so! Your Majesty, as I understand, became entangled
-with this young person, wrote her some compromising letters, and
-is now desirous of getting those letters back."
-
-"Precisely so. But how--"
-
-"Was there a secret marriage?"
-
-"None."
-
-"No legal papers or certificates?"
-
-"None."
-
-"Then I fail to follow your Majesty. If this young person should
-produce her letters for blackmailing or other purposes, how is
-she to prove their authenticity?"
-
-"There is the writing."
-
-"Pooh, pooh! Forgery."
-
-"My private note-paper."
-
-"Stolen."
-
-"My own seal."
-
-"Imitated."
-
-"My photograph."
-
-"Bought."
-
-"We were both in the photograph."
-
-"Oh, dear! That is very bad! Your Majesty has indeed committed an
-indiscretion."
-
-"I was mad--insane."
-
-"You have compromised yourself seriously."
-
-"I was only Crown Prince then. I was young. I am but thirty now."
-
-"It must be recovered."
-
-"We have tried and failed."
-
-"Your Majesty must pay. It must be bought."
-
-"She will not sell."
-
-"Stolen, then."
-
-"Five attempts have been made. Twice burglars in my pay ransacked
-her house. Once we diverted her luggage when she travelled. Twice
-she has been waylaid. There has been no result."
-
-"No sign of it?"
-
-"Absolutely none."
-
-Holmes laughed. "It is quite a pretty little problem," said he.
-
-"But a very serious one to me," returned the King reproachfully.
-
-"Very, indeed. And what does she propose to do with the
-photograph?"
-
-"To ruin me."
-
-"But how?"
-
-"I am about to be married."
-
-"So I have heard."
-
-"To Clotilde Lothman von Saxe-Meningen, second daughter of the
-King of Scandinavia. You may know the strict principles of her
-family. She is herself the very soul of delicacy. A shadow of a
-doubt as to my conduct would bring the matter to an end."
-
-"And Irene Adler?"
-
-"Threatens to send them the photograph. And she will do it. I
-know that she will do it. You do not know her, but she has a soul
-of steel. She has the face of the most beautiful of women, and
-the mind of the most resolute of men. Rather than I should marry
-another woman, there are no lengths to which she would not
-go--none."
-
-"You are sure that she has not sent it yet?"
-
-"I am sure."
-
-"And why?"
-
-"Because she has said that she would send it on the day when the
-betrothal was publicly proclaimed. That will be next Monday."
-
-"Oh, then we have three days yet," said Holmes with a yawn. "That
-is very fortunate, as I have one or two matters of importance to
-look into just at present. Your Majesty will, of course, stay in
-London for the present?"
-
-"Certainly. You will find me at the Langham under the name of the
-Count Von Kramm."
-
-"Then I shall drop you a line to let you know how we progress."
-
-"Pray do so. I shall be all anxiety."
-
-"Then, as to money?"
-
-"You have carte blanche."
-
-"Absolutely?"
-
-"I tell you that I would give one of the provinces of my kingdom
-to have that photograph."
-
-"And for present expenses?"
-
-The King took a heavy chamois leather bag from under his cloak
-and laid it on the table.
-
-"There are three hundred pounds in gold and seven hundred in
-notes," he said.
-
-Holmes scribbled a receipt upon a sheet of his note-book and
-handed it to him.
-
-"And Mademoiselle's address?" he asked.
-
-"Is Briony Lodge, Serpentine Avenue, St. John's Wood."
-
-Holmes took a note of it. "One other question," said he. "Was the
-photograph a cabinet?"
-
-"It was."
-
-"Then, good-night, your Majesty, and I trust that we shall soon
-have some good news for you. And good-night, Watson," he added,
-as the wheels of the royal brougham rolled down the street. "If
-you will be good enough to call to-morrow afternoon at three
-o'clock I should like to chat this little matter over with you."
-
-
-II.
-
-At three o'clock precisely I was at Baker Street, but Holmes had
-not yet returned. The landlady informed me that he had left the
-house shortly after eight o'clock in the morning. I sat down
-beside the fire, however, with the intention of awaiting him,
-however long he might be. I was already deeply interested in his
-inquiry, for, though it was surrounded by none of the grim and
-strange features which were associated with the two crimes which
-I have already recorded, still, the nature of the case and the
-exalted station of his client gave it a character of its own.
-Indeed, apart from the nature of the investigation which my
-friend had on hand, there was something in his masterly grasp of
-a situation, and his keen, incisive reasoning, which made it a
-pleasure to me to study his system of work, and to follow the
-quick, subtle methods by which he disentangled the most
-inextricable mysteries. So accustomed was I to his invariable
-success that the very possibility of his failing had ceased to
-enter into my head.
-
-It was close upon four before the door opened, and a
-drunken-looking groom, ill-kempt and side-whiskered, with an
-inflamed face and disreputable clothes, walked into the room.
-Accustomed as I was to my friend's amazing powers in the use of
-disguises, I had to look three times before I was certain that it
-was indeed he. With a nod he vanished into the bedroom, whence he
-emerged in five minutes tweed-suited and respectable, as of old.
-Putting his hands into his pockets, he stretched out his legs in
-front of the fire and laughed heartily for some minutes.
-
-"Well, really!" he cried, and then he choked and laughed again
-until he was obliged to lie back, limp and helpless, in the
-chair.
-
-"What is it?"
-
-"It's quite too funny. I am sure you could never guess how I
-employed my morning, or what I ended by doing."
-
-"I can't imagine. I suppose that you have been watching the
-habits, and perhaps the house, of Miss Irene Adler."
-
-"Quite so; but the sequel was rather unusual. I will tell you,
-however. I left the house a little after eight o'clock this
-morning in the character of a groom out of work. There is a
-wonderful sympathy and freemasonry among horsey men. Be one of
-them, and you will know all that there is to know. I soon found
-Briony Lodge. It is a bijou villa, with a garden at the back, but
-built out in front right up to the road, two stories. Chubb lock
-to the door. Large sitting-room on the right side, well
-furnished, with long windows almost to the floor, and those
-preposterous English window fasteners which a child could open.
-Behind there was nothing remarkable, save that the passage window
-could be reached from the top of the coach-house. I walked round
-it and examined it closely from every point of view, but without
-noting anything else of interest.
-
-"I then lounged down the street and found, as I expected, that
-there was a mews in a lane which runs down by one wall of the
-garden. I lent the ostlers a hand in rubbing down their horses,
-and received in exchange twopence, a glass of half and half, two
-fills of shag tobacco, and as much information as I could desire
-about Miss Adler, to say nothing of half a dozen other people in
-the neighbourhood in whom I was not in the least interested, but
-whose biographies I was compelled to listen to."
-
-"And what of Irene Adler?" I asked.
-
-"Oh, she has turned all the men's heads down in that part. She is
-the daintiest thing under a bonnet on this planet. So say the
-Serpentine-mews, to a man. She lives quietly, sings at concerts,
-drives out at five every day, and returns at seven sharp for
-dinner. Seldom goes out at other times, except when she sings.
-Has only one male visitor, but a good deal of him. He is dark,
-handsome, and dashing, never calls less than once a day, and
-often twice. He is a Mr. Godfrey Norton, of the Inner Temple. See
-the advantages of a cabman as a confidant. They had driven him
-home a dozen times from Serpentine-mews, and knew all about him.
-When I had listened to all they had to tell, I began to walk up
-and down near Briony Lodge once more, and to think over my plan
-of campaign.
-
-"This Godfrey Norton was evidently an important factor in the
-matter. He was a lawyer. That sounded ominous. What was the
-relation between them, and what the object of his repeated
-visits? Was she his client, his friend, or his mistress? If the
-former, she had probably transferred the photograph to his
-keeping. If the latter, it was less likely. On the issue of this
-question depended whether I should continue my work at Briony
-Lodge, or turn my attention to the gentleman's chambers in the
-Temple. It was a delicate point, and it widened the field of my
-inquiry. I fear that I bore you with these details, but I have to
-let you see my little difficulties, if you are to understand the
-situation."
-
-"I am following you closely," I answered.
-
-"I was still balancing the matter in my mind when a hansom cab
-drove up to Briony Lodge, and a gentleman sprang out. He was a
-remarkably handsome man, dark, aquiline, and moustached--evidently
-the man of whom I had heard. He appeared to be in a
-great hurry, shouted to the cabman to wait, and brushed past the
-maid who opened the door with the air of a man who was thoroughly
-at home.
-
-"He was in the house about half an hour, and I could catch
-glimpses of him in the windows of the sitting-room, pacing up and
-down, talking excitedly, and waving his arms. Of her I could see
-nothing. Presently he emerged, looking even more flurried than
-before. As he stepped up to the cab, he pulled a gold watch from
-his pocket and looked at it earnestly, 'Drive like the devil,' he
-shouted, 'first to Gross & Hankey's in Regent Street, and then to
-the Church of St. Monica in the Edgeware Road. Half a guinea if
-you do it in twenty minutes!'
-
-"Away they went, and I was just wondering whether I should not do
-well to follow them when up the lane came a neat little landau,
-the coachman with his coat only half-buttoned, and his tie under
-his ear, while all the tags of his harness were sticking out of
-the buckles. It hadn't pulled up before she shot out of the hall
-door and into it. I only caught a glimpse of her at the moment,
-but she was a lovely woman, with a face that a man might die for.
-
-"'The Church of St. Monica, John,' she cried, 'and half a
-sovereign if you reach it in twenty minutes.'
-
-"This was quite too good to lose, Watson. I was just balancing
-whether I should run for it, or whether I should perch behind her
-landau when a cab came through the street. The driver looked
-twice at such a shabby fare, but I jumped in before he could
-object. 'The Church of St. Monica,' said I, 'and half a sovereign
-if you reach it in twenty minutes.' It was twenty-five minutes to
-twelve, and of course it was clear enough what was in the wind.
-
-"My cabby drove fast. I don't think I ever drove faster, but the
-others were there before us. The cab and the landau with their
-steaming horses were in front of the door when I arrived. I paid
-the man and hurried into the church. There was not a soul there
-save the two whom I had followed and a surpliced clergyman, who
-seemed to be expostulating with them. They were all three
-standing in a knot in front of the altar. I lounged up the side
-aisle like any other idler who has dropped into a church.
-Suddenly, to my surprise, the three at the altar faced round to
-me, and Godfrey Norton came running as hard as he could towards
-me.
-
-"'Thank God,' he cried. 'You'll do. Come! Come!'
-
-"'What then?' I asked.
-
-"'Come, man, come, only three minutes, or it won't be legal.'
-
-"I was half-dragged up to the altar, and before I knew where I was
-I found myself mumbling responses which were whispered in my ear,
-and vouching for things of which I knew nothing, and generally
-assisting in the secure tying up of Irene Adler, spinster, to
-Godfrey Norton, bachelor. It was all done in an instant, and
-there was the gentleman thanking me on the one side and the lady
-on the other, while the clergyman beamed on me in front. It was
-the most preposterous position in which I ever found myself in my
-life, and it was the thought of it that started me laughing just
-now. It seems that there had been some informality about their
-license, that the clergyman absolutely refused to marry them
-without a witness of some sort, and that my lucky appearance
-saved the bridegroom from having to sally out into the streets in
-search of a best man. The bride gave me a sovereign, and I mean
-to wear it on my watch-chain in memory of the occasion."
-
-"This is a very unexpected turn of affairs," said I; "and what
-then?"
-
-"Well, I found my plans very seriously menaced. It looked as if
-the pair might take an immediate departure, and so necessitate
-very prompt and energetic measures on my part. At the church
-door, however, they separated, he driving back to the Temple, and
-she to her own house. 'I shall drive out in the park at five as
-usual,' she said as she left him. I heard no more. They drove
-away in different directions, and I went off to make my own
-arrangements."
-
-"Which are?"
-
-"Some cold beef and a glass of beer," he answered, ringing the
-bell. "I have been too busy to think of food, and I am likely to
-be busier still this evening. By the way, Doctor, I shall want
-your co-operation."
-
-"I shall be delighted."
-
-"You don't mind breaking the law?"
-
-"Not in the least."
-
-"Nor running a chance of arrest?"
-
-"Not in a good cause."
-
-"Oh, the cause is excellent!"
-
-"Then I am your man."
-
-"I was sure that I might rely on you."
-
-"But what is it you wish?"
-
-"When Mrs. Turner has brought in the tray I will make it clear to
-you. Now," he said as he turned hungrily on the simple fare that
-our landlady had provided, "I must discuss it while I eat, for I
-have not much time. It is nearly five now. In two hours we must
-be on the scene of action. Miss Irene, or Madame, rather, returns
-from her drive at seven. We must be at Briony Lodge to meet her."
-
-"And what then?"
-
-"You must leave that to me. I have already arranged what is to
-occur. There is only one point on which I must insist. You must
-not interfere, come what may. You understand?"
-
-"I am to be neutral?"
-
-"To do nothing whatever. There will probably be some small
-unpleasantness. Do not join in it. It will end in my being
-conveyed into the house. Four or five minutes afterwards the
-sitting-room window will open. You are to station yourself close
-to that open window."
-
-"Yes."
-
-"You are to watch me, for I will be visible to you."
-
-"Yes."
-
-"And when I raise my hand--so--you will throw into the room what
-I give you to throw, and will, at the same time, raise the cry of
-fire. You quite follow me?"
-
-"Entirely."
-
-"It is nothing very formidable," he said, taking a long cigar-shaped
-roll from his pocket. "It is an ordinary plumber's smoke-rocket,
-fitted with a cap at either end to make it self-lighting.
-Your task is confined to that. When you raise your cry of fire,
-it will be taken up by quite a number of people. You may then
-walk to the end of the street, and I will rejoin you in ten
-minutes. I hope that I have made myself clear?"
-
-"I am to remain neutral, to get near the window, to watch you,
-and at the signal to throw in this object, then to raise the cry
-of fire, and to wait you at the corner of the street."
-
-"Precisely."
-
-"Then you may entirely rely on me."
-
-"That is excellent. I think, perhaps, it is almost time that I
-prepare for the new role I have to play."
-
-He disappeared into his bedroom and returned in a few minutes in
-the character of an amiable and simple-minded Nonconformist
-clergyman. His broad black hat, his baggy trousers, his white
-tie, his sympathetic smile, and general look of peering and
-benevolent curiosity were such as Mr. John Hare alone could have
-equalled. It was not merely that Holmes changed his costume. His
-expression, his manner, his very soul seemed to vary with every
-fresh part that he assumed. The stage lost a fine actor, even as
-science lost an acute reasoner, when he became a specialist in
-crime.
-
-It was a quarter past six when we left Baker Street, and it still
-wanted ten minutes to the hour when we found ourselves in
-Serpentine Avenue. It was already dusk, and the lamps were just
-being lighted as we paced up and down in front of Briony Lodge,
-waiting for the coming of its occupant. The house was just such
-as I had pictured it from Sherlock Holmes' succinct description,
-but the locality appeared to be less private than I expected. On
-the contrary, for a small street in a quiet neighbourhood, it was
-remarkably animated. There was a group of shabbily dressed men
-smoking and laughing in a corner, a scissors-grinder with his
-wheel, two guardsmen who were flirting with a nurse-girl, and
-several well-dressed young men who were lounging up and down with
-cigars in their mouths.
-
-"You see," remarked Holmes, as we paced to and fro in front of
-the house, "this marriage rather simplifies matters. The
-photograph becomes a double-edged weapon now. The chances are
-that she would be as averse to its being seen by Mr. Godfrey
-Norton, as our client is to its coming to the eyes of his
-princess. Now the question is, Where are we to find the
-photograph?"
-
-"Where, indeed?"
-
-"It is most unlikely that she carries it about with her. It is
-cabinet size. Too large for easy concealment about a woman's
-dress. She knows that the King is capable of having her waylaid
-and searched. Two attempts of the sort have already been made. We
-may take it, then, that she does not carry it about with her."
-
-"Where, then?"
-
-"Her banker or her lawyer. There is that double possibility. But
-I am inclined to think neither. Women are naturally secretive,
-and they like to do their own secreting. Why should she hand it
-over to anyone else? She could trust her own guardianship, but
-she could not tell what indirect or political influence might be
-brought to bear upon a business man. Besides, remember that she
-had resolved to use it within a few days. It must be where she
-can lay her hands upon it. It must be in her own house."
-
-"But it has twice been burgled."
-
-"Pshaw! They did not know how to look."
-
-"But how will you look?"
-
-"I will not look."
-
-"What then?"
-
-"I will get her to show me."
-
-"But she will refuse."
-
-"She will not be able to. But I hear the rumble of wheels. It is
-her carriage. Now carry out my orders to the letter."
-
-As he spoke the gleam of the side-lights of a carriage came round
-the curve of the avenue. It was a smart little landau which
-rattled up to the door of Briony Lodge. As it pulled up, one of
-the loafing men at the corner dashed forward to open the door in
-the hope of earning a copper, but was elbowed away by another
-loafer, who had rushed up with the same intention. A fierce
-quarrel broke out, which was increased by the two guardsmen, who
-took sides with one of the loungers, and by the scissors-grinder,
-who was equally hot upon the other side. A blow was struck, and
-in an instant the lady, who had stepped from her carriage, was
-the centre of a little knot of flushed and struggling men, who
-struck savagely at each other with their fists and sticks. Holmes
-dashed into the crowd to protect the lady; but just as he reached
-her he gave a cry and dropped to the ground, with the blood
-running freely down his face. At his fall the guardsmen took to
-their heels in one direction and the loungers in the other, while
-a number of better-dressed people, who had watched the scuffle
-without taking part in it, crowded in to help the lady and to
-attend to the injured man. Irene Adler, as I will still call her,
-had hurried up the steps; but she stood at the top with her
-superb figure outlined against the lights of the hall, looking
-back into the street.
-
-"Is the poor gentleman much hurt?" she asked.
-
-"He is dead," cried several voices.
-
-"No, no, there's life in him!" shouted another. "But he'll be
-gone before you can get him to hospital."
-
-"He's a brave fellow," said a woman. "They would have had the
-lady's purse and watch if it hadn't been for him. They were a
-gang, and a rough one, too. Ah, he's breathing now."
-
-"He can't lie in the street. May we bring him in, marm?"
-
-"Surely. Bring him into the sitting-room. There is a comfortable
-sofa. This way, please!"
-
-Slowly and solemnly he was borne into Briony Lodge and laid out
-in the principal room, while I still observed the proceedings
-from my post by the window. The lamps had been lit, but the
-blinds had not been drawn, so that I could see Holmes as he lay
-upon the couch. I do not know whether he was seized with
-compunction at that moment for the part he was playing, but I
-know that I never felt more heartily ashamed of myself in my life
-than when I saw the beautiful creature against whom I was
-conspiring, or the grace and kindliness with which she waited
-upon the injured man. And yet it would be the blackest treachery
-to Holmes to draw back now from the part which he had intrusted
-to me. I hardened my heart, and took the smoke-rocket from under
-my ulster. After all, I thought, we are not injuring her. We are
-but preventing her from injuring another.
-
-Holmes had sat up upon the couch, and I saw him motion like a man
-who is in need of air. A maid rushed across and threw open the
-window. At the same instant I saw him raise his hand and at the
-signal I tossed my rocket into the room with a cry of "Fire!" The
-word was no sooner out of my mouth than the whole crowd of
-spectators, well dressed and ill--gentlemen, ostlers, and
-servant-maids--joined in a general shriek of "Fire!" Thick clouds
-of smoke curled through the room and out at the open window. I
-caught a glimpse of rushing figures, and a moment later the voice
-of Holmes from within assuring them that it was a false alarm.
-Slipping through the shouting crowd I made my way to the corner
-of the street, and in ten minutes was rejoiced to find my
-friend's arm in mine, and to get away from the scene of uproar.
-He walked swiftly and in silence for some few minutes until we
-had turned down one of the quiet streets which lead towards the
-Edgeware Road.
-
-"You did it very nicely, Doctor," he remarked. "Nothing could
-have been better. It is all right."
-
-"You have the photograph?"
-
-"I know where it is."
-
-"And how did you find out?"
-
-"She showed me, as I told you she would."
-
-"I am still in the dark."
-
-"I do not wish to make a mystery," said he, laughing. "The matter
-was perfectly simple. You, of course, saw that everyone in the
-street was an accomplice. They were all engaged for the evening."
-
-"I guessed as much."
-
-"Then, when the row broke out, I had a little moist red paint in
-the palm of my hand. I rushed forward, fell down, clapped my hand
-to my face, and became a piteous spectacle. It is an old trick."
-
-"That also I could fathom."
-
-"Then they carried me in. She was bound to have me in. What else
-could she do? And into her sitting-room, which was the very room
-which I suspected. It lay between that and her bedroom, and I was
-determined to see which. They laid me on a couch, I motioned for
-air, they were compelled to open the window, and you had your
-chance."
-
-"How did that help you?"
-
-"It was all-important. When a woman thinks that her house is on
-fire, her instinct is at once to rush to the thing which she
-values most. It is a perfectly overpowering impulse, and I have
-more than once taken advantage of it. In the case of the
-Darlington substitution scandal it was of use to me, and also in
-the Arnsworth Castle business. A married woman grabs at her baby;
-an unmarried one reaches for her jewel-box. Now it was clear to
-me that our lady of to-day had nothing in the house more precious
-to her than what we are in quest of. She would rush to secure it.
-The alarm of fire was admirably done. The smoke and shouting were
-enough to shake nerves of steel. She responded beautifully. The
-photograph is in a recess behind a sliding panel just above the
-right bell-pull. She was there in an instant, and I caught a
-glimpse of it as she half-drew it out. When I cried out that it
-was a false alarm, she replaced it, glanced at the rocket, rushed
-from the room, and I have not seen her since. I rose, and, making
-my excuses, escaped from the house. I hesitated whether to
-attempt to secure the photograph at once; but the coachman had
-come in, and as he was watching me narrowly it seemed safer to
-wait. A little over-precipitance may ruin all."
-
-"And now?" I asked.
-
-"Our quest is practically finished. I shall call with the King
-to-morrow, and with you, if you care to come with us. We will be
-shown into the sitting-room to wait for the lady, but it is
-probable that when she comes she may find neither us nor the
-photograph. It might be a satisfaction to his Majesty to regain
-it with his own hands."
-
-"And when will you call?"
-
-"At eight in the morning. She will not be up, so that we shall
-have a clear field. Besides, we must be prompt, for this marriage
-may mean a complete change in her life and habits. I must wire to
-the King without delay."
-
-We had reached Baker Street and had stopped at the door. He was
-searching his pockets for the key when someone passing said:
-
-"Good-night, Mister Sherlock Holmes."
-
-There were several people on the pavement at the time, but the
-greeting appeared to come from a slim youth in an ulster who had
-hurried by.
-
-"I've heard that voice before," said Holmes, staring down the
-dimly lit street. "Now, I wonder who the deuce that could have
-been."
-
-
-III.
-
-I slept at Baker Street that night, and we were engaged upon our
-toast and coffee in the morning when the King of Bohemia rushed
-into the room.
-
-"You have really got it!" he cried, grasping Sherlock Holmes by
-either shoulder and looking eagerly into his face.
-
-"Not yet."
-
-"But you have hopes?"
-
-"I have hopes."
-
-"Then, come. I am all impatience to be gone."
-
-"We must have a cab."
-
-"No, my brougham is waiting."
-
-"Then that will simplify matters." We descended and started off
-once more for Briony Lodge.
-
-"Irene Adler is married," remarked Holmes.
-
-"Married! When?"
-
-"Yesterday."
-
-"But to whom?"
-
-"To an English lawyer named Norton."
-
-"But she could not love him."
-
-"I am in hopes that she does."
-
-"And why in hopes?"
-
-"Because it would spare your Majesty all fear of future
-annoyance. If the lady loves her husband, she does not love your
-Majesty. If she does not love your Majesty, there is no reason
-why she should interfere with your Majesty's plan."
-
-"It is true. And yet--Well! I wish she had been of my own
-station! What a queen she would have made!" He relapsed into a
-moody silence, which was not broken until we drew up in
-Serpentine Avenue.
-
-The door of Briony Lodge was open, and an elderly woman stood
-upon the steps. She watched us with a sardonic eye as we stepped
-from the brougham.
-
-"Mr. Sherlock Holmes, I believe?" said she.
-
-"I am Mr. Holmes," answered my companion, looking at her with a
-questioning and rather startled gaze.
-
-"Indeed! My mistress told me that you were likely to call. She
-left this morning with her husband by the 5:15 train from Charing
-Cross for the Continent."
-
-"What!" Sherlock Holmes staggered back, white with chagrin and
-surprise. "Do you mean that she has left England?"
-
-"Never to return."
-
-"And the papers?" asked the King hoarsely. "All is lost."
-
-"We shall see." He pushed past the servant and rushed into the
-drawing-room, followed by the King and myself. The furniture was
-scattered about in every direction, with dismantled shelves and
-open drawers, as if the lady had hurriedly ransacked them before
-her flight. Holmes rushed at the bell-pull, tore back a small
-sliding shutter, and, plunging in his hand, pulled out a
-photograph and a letter. The photograph was of Irene Adler
-herself in evening dress, the letter was superscribed to
-"Sherlock Holmes, Esq. To be left till called for." My friend
-tore it open and we all three read it together. It was dated at
-midnight of the preceding night and ran in this way:
-
-"MY DEAR MR. SHERLOCK HOLMES,--You really did it very well. You
-took me in completely. Until after the alarm of fire, I had not a
-suspicion. But then, when I found how I had betrayed myself, I
-began to think. I had been warned against you months ago. I had
-been told that if the King employed an agent it would certainly
-be you. And your address had been given me. Yet, with all this,
-you made me reveal what you wanted to know. Even after I became
-suspicious, I found it hard to think evil of such a dear, kind
-old clergyman. But, you know, I have been trained as an actress
-myself. Male costume is nothing new to me. I often take advantage
-of the freedom which it gives. I sent John, the coachman, to
-watch you, ran up stairs, got into my walking-clothes, as I call
-them, and came down just as you departed.
-
-"Well, I followed you to your door, and so made sure that I was
-really an object of interest to the celebrated Mr. Sherlock
-Holmes. Then I, rather imprudently, wished you good-night, and
-started for the Temple to see my husband.
-
-"We both thought the best resource was flight, when pursued by
-so formidable an antagonist; so you will find the nest empty when
-you call to-morrow. As to the photograph, your client may rest in
-peace. I love and am loved by a better man than he. The King may
-do what he will without hindrance from one whom he has cruelly
-wronged. I keep it only to safeguard myself, and to preserve a
-weapon which will always secure me from any steps which he might
-take in the future. I leave a photograph which he might care to
-possess; and I remain, dear Mr. Sherlock Holmes,
-
-                                      "Very truly yours,
-                                   "IRENE NORTON, née ADLER."
-
-"What a woman--oh, what a woman!" cried the King of Bohemia, when
-we had all three read this epistle. "Did I not tell you how quick
-and resolute she was? Would she not have made an admirable queen?
-Is it not a pity that she was not on my level?"
-
-"From what I have seen of the lady she seems indeed to be on a
-very different level to your Majesty," said Holmes coldly. "I am
-sorry that I have not been able to bring your Majesty's business
-to a more successful conclusion."
-
-"On the contrary, my dear sir," cried the King; "nothing could be
-more successful. I know that her word is inviolate. The
-photograph is now as safe as if it were in the fire."
-
-"I am glad to hear your Majesty say so."
-
-"I am immensely indebted to you. Pray tell me in what way I can
-reward you. This ring--" He slipped an emerald snake ring from
-his finger and held it out upon the palm of his hand.
-
-"Your Majesty has something which I should value even more
-highly," said Holmes.
-
-"You have but to name it."
-
-"This photograph!"
-
-The King stared at him in amazement.
-
-"Irene's photograph!" he cried. "Certainly, if you wish it."
-
-"I thank your Majesty. Then there is no more to be done in the
-matter. I have the honour to wish you a very good-morning." He
-bowed, and, turning away without observing the hand which the
-King had stretched out to him, he set off in my company for his
-chambers.
-
-And that was how a great scandal threatened to affect the kingdom
-of Bohemia, and how the best plans of Mr. Sherlock Holmes were
-beaten by a woman's wit. He used to make merry over the
-cleverness of women, but I have not heard him do it of late. And
-when he speaks of Irene Adler, or when he refers to her
-photograph, it is always under the honourable title of the woman.
-
-
-
-ADVENTURE II. THE RED-HEADED LEAGUE
-
-I had called upon my friend, Mr. Sherlock Holmes, one day in the
-autumn of last year and found him in deep conversation with a
-very stout, florid-faced, elderly gentleman with fiery red hair.
-With an apology for my intrusion, I was about to withdraw when
-Holmes pulled me abruptly into the room and closed the door
-behind me.
-
-"You could not possibly have come at a better time, my dear
-Watson," he said cordially.
-
-"I was afraid that you were engaged."
-
-"So I am. Very much so."
-
-"Then I can wait in the next room."
-
-"Not at all. This gentleman, Mr. Wilson, has been my partner and
-helper in many of my most successful cases, and I have no
-doubt that he will be of the utmost use to me in yours also."
-
-The stout gentleman half rose from his chair and gave a bob of
-greeting, with a quick little questioning glance from his small
-fat-encircled eyes.
-
-"Try the settee," said Holmes, relapsing into his armchair and
-putting his fingertips together, as was his custom when in
-judicial moods. "I know, my dear Watson, that you share my love
-of all that is bizarre and outside the conventions and humdrum
-routine of everyday life. You have shown your relish for it by
-the enthusiasm which has prompted you to chronicle, and, if you
-will excuse my saying so, somewhat to embellish so many of my own
-little adventures."
-
-"Your cases have indeed been of the greatest interest to me," I
-observed.
-
-"You will remember that I remarked the other day, just before we
-went into the very simple problem presented by Miss Mary
-Sutherland, that for strange effects and extraordinary
-combinations we must go to life itself, which is always far more
-daring than any effort of the imagination."
-
-"A proposition which I took the liberty of doubting."
-
-"You did, Doctor, but none the less you must come round to my
-view, for otherwise I shall keep on piling fact upon fact on you
-until your reason breaks down under them and acknowledges me to
-be right. Now, Mr. Jabez Wilson here has been good enough to call
-upon me this morning, and to begin a narrative which promises to
-be one of the most singular which I have listened to for some
-time. You have heard me remark that the strangest and most unique
-things are very often connected not with the larger but with the
-smaller crimes, and occasionally, indeed, where there is room for
-doubt whether any positive crime has been committed. As far as I
-have heard it is impossible for me to say whether the present
-case is an instance of crime or not, but the course of events is
-certainly among the most singular that I have ever listened to.
-Perhaps, Mr. Wilson, you would have the great kindness to
-recommence your narrative. I ask you not merely because my friend
-Dr. Watson has not heard the opening part but also because the
-peculiar nature of the story makes me anxious to have every
-possible detail from your lips. As a rule, when I have heard some
-slight indication of the course of events, I am able to guide
-myself by the thousands of other similar cases which occur to my
-memory. In the present instance I am forced to admit that the
-facts are, to the best of my belief, unique."
-
-The portly client puffed out his chest with an appearance of some
-little pride and pulled a dirty and wrinkled newspaper from the
-inside pocket of his greatcoat. As he glanced down the
-advertisement column, with his head thrust forward and the paper
-flattened out upon his knee, I took a good look at the man and
-endeavoured, after the fashion of my companion, to read the
-indications which might be presented by his dress or appearance.
-
-I did not gain very much, however, by my inspection. Our visitor
-bore every mark of being an average commonplace British
-tradesman, obese, pompous, and slow. He wore rather baggy grey
-shepherd's check trousers, a not over-clean black frock-coat,
-unbuttoned in the front, and a drab waistcoat with a heavy brassy
-Albert chain, and a square pierced bit of metal dangling down as
-an ornament. A frayed top-hat and a faded brown overcoat with a
-wrinkled velvet collar lay upon a chair beside him. Altogether,
-look as I would, there was nothing remarkable about the man save
-his blazing red head, and the expression of extreme chagrin and
-discontent upon his features.
-
-Sherlock Holmes' quick eye took in my occupation, and he shook
-his head with a smile as he noticed my questioning glances.
-"Beyond the obvious facts that he has at some time done manual
-labour, that he takes snuff, that he is a Freemason, that he has
-been in China, and that he has done a considerable amount of
-writing lately, I can deduce nothing else."
-
-Mr. Jabez Wilson started up in his chair, with his forefinger
-upon the paper, but his eyes upon my companion.
-
-"How, in the name of good-fortune, did you know all that, Mr.
-Holmes?" he asked. "How did you know, for example, that I did
-manual labour. It's as true as gospel, for I began as a ship's
-carpenter."
-
-"Your hands, my dear sir. Your right hand is quite a size larger
-than your left. You have worked with it, and the muscles are more
-developed."
-
-"Well, the snuff, then, and the Freemasonry?"
-
-"I won't insult your intelligence by telling you how I read that,
-especially as, rather against the strict rules of your order, you
-use an arc-and-compass breastpin."
-
-"Ah, of course, I forgot that. But the writing?"
-
-"What else can be indicated by that right cuff so very shiny for
-five inches, and the left one with the smooth patch near the
-elbow where you rest it upon the desk?"
-
-"Well, but China?"
-
-"The fish that you have tattooed immediately above your right
-wrist could only have been done in China. I have made a small
-study of tattoo marks and have even contributed to the literature
-of the subject. That trick of staining the fishes' scales of a
-delicate pink is quite peculiar to China. When, in addition, I
-see a Chinese coin hanging from your watch-chain, the matter
-becomes even more simple."
-
-Mr. Jabez Wilson laughed heavily. "Well, I never!" said he. "I
-thought at first that you had done something clever, but I see
-that there was nothing in it, after all."
-
-"I begin to think, Watson," said Holmes, "that I make a mistake
-in explaining. 'Omne ignotum pro magnifico,' you know, and my
-poor little reputation, such as it is, will suffer shipwreck if I
-am so candid. Can you not find the advertisement, Mr. Wilson?"
-
-"Yes, I have got it now," he answered with his thick red finger
-planted halfway down the column. "Here it is. This is what began
-it all. You just read it for yourself, sir."
-
-I took the paper from him and read as follows:
-
-"TO THE RED-HEADED LEAGUE: On account of the bequest of the late
-Ezekiah Hopkins, of Lebanon, Pennsylvania, U. S. A., there is now
-another vacancy open which entitles a member of the League to a
-salary of 4 pounds a week for purely nominal services. All
-red-headed men who are sound in body and mind and above the age
-of twenty-one years, are eligible. Apply in person on Monday, at
-eleven o'clock, to Duncan Ross, at the offices of the League, 7
-Pope's Court, Fleet Street."
-
-"What on earth does this mean?" I ejaculated after I had twice
-read over the extraordinary announcement.
-
-Holmes chuckled and wriggled in his chair, as was his habit when
-in high spirits. "It is a little off the beaten track, isn't it?"
-said he. "And now, Mr. Wilson, off you go at scratch and tell us
-all about yourself, your household, and the effect which this
-advertisement had upon your fortunes. You will first make a note,
-Doctor, of the paper and the date."
-
-"It is The Morning Chronicle of April 27, 1890. Just two months
-ago."
-
-"Very good. Now, Mr. Wilson?"
-
-"Well, it is just as I have been telling you, Mr. Sherlock
-Holmes," said Jabez Wilson, mopping his forehead; "I have a small
-pawnbroker's business at Coburg Square, near the City. It's not a
-very large affair, and of late years it has not done more than
-just give me a living. I used to be able to keep two assistants,
-but now I only keep one; and I would have a job to pay him but
-that he is willing to come for half wages so as to learn the
-business."
-
-"What is the name of this obliging youth?" asked Sherlock Holmes.
-
-"His name is Vincent Spaulding, and he's not such a youth,
-either. It's hard to say his age. I should not wish a smarter
-assistant, Mr. Holmes; and I know very well that he could better
-himself and earn twice what I am able to give him. But, after
-all, if he is satisfied, why should I put ideas in his head?"
-
-"Why, indeed? You seem most fortunate in having an employé who
-comes under the full market price. It is not a common experience
-among employers in this age. I don't know that your assistant is
-not as remarkable as your advertisement."
-
-"Oh, he has his faults, too," said Mr. Wilson. "Never was such a
-fellow for photography. Snapping away with a camera when he ought
-to be improving his mind, and then diving down into the cellar
-like a rabbit into its hole to develop his pictures. That is his
-main fault, but on the whole he's a good worker. There's no vice
-in him."
-
-"He is still with you, I presume?"
-
-"Yes, sir. He and a girl of fourteen, who does a bit of simple
-cooking and keeps the place clean--that's all I have in the
-house, for I am a widower and never had any family. We live very
-quietly, sir, the three of us; and we keep a roof over our heads
-and pay our debts, if we do nothing more.
-
-"The first thing that put us out was that advertisement.
-Spaulding, he came down into the office just this day eight
-weeks, with this very paper in his hand, and he says:
-
-"'I wish to the Lord, Mr. Wilson, that I was a red-headed man.'
-
-"'Why that?' I asks.
-
-"'Why,' says he, 'here's another vacancy on the League of the
-Red-headed Men. It's worth quite a little fortune to any man who
-gets it, and I understand that there are more vacancies than
-there are men, so that the trustees are at their wits' end what
-to do with the money. If my hair would only change colour, here's
-a nice little crib all ready for me to step into.'
-
-"'Why, what is it, then?' I asked. You see, Mr. Holmes, I am a
-very stay-at-home man, and as my business came to me instead of
-my having to go to it, I was often weeks on end without putting
-my foot over the door-mat. In that way I didn't know much of what
-was going on outside, and I was always glad of a bit of news.
-
-"'Have you never heard of the League of the Red-headed Men?' he
-asked with his eyes open.
-
-"'Never.'
-
-"'Why, I wonder at that, for you are eligible yourself for one
-of the vacancies.'
-
-"'And what are they worth?' I asked.
-
-"'Oh, merely a couple of hundred a year, but the work is slight,
-and it need not interfere very much with one's other
-occupations.'
-
-"Well, you can easily think that that made me prick up my ears,
-for the business has not been over-good for some years, and an
-extra couple of hundred would have been very handy.
-
-"'Tell me all about it,' said I.
-
-"'Well,' said he, showing me the advertisement, 'you can see for
-yourself that the League has a vacancy, and there is the address
-where you should apply for particulars. As far as I can make out,
-the League was founded by an American millionaire, Ezekiah
-Hopkins, who was very peculiar in his ways. He was himself
-red-headed, and he had a great sympathy for all red-headed men;
-so when he died it was found that he had left his enormous
-fortune in the hands of trustees, with instructions to apply the
-interest to the providing of easy berths to men whose hair is of
-that colour. From all I hear it is splendid pay and very little to
-do.'
-
-"'But,' said I, 'there would be millions of red-headed men who
-would apply.'
-
-"'Not so many as you might think,' he answered. 'You see it is
-really confined to Londoners, and to grown men. This American had
-started from London when he was young, and he wanted to do the
-old town a good turn. Then, again, I have heard it is no use your
-applying if your hair is light red, or dark red, or anything but
-real bright, blazing, fiery red. Now, if you cared to apply, Mr.
-Wilson, you would just walk in; but perhaps it would hardly be
-worth your while to put yourself out of the way for the sake of a
-few hundred pounds.'
-
-"Now, it is a fact, gentlemen, as you may see for yourselves,
-that my hair is of a very full and rich tint, so that it seemed
-to me that if there was to be any competition in the matter I
-stood as good a chance as any man that I had ever met. Vincent
-Spaulding seemed to know so much about it that I thought he might
-prove useful, so I just ordered him to put up the shutters for
-the day and to come right away with me. He was very willing to
-have a holiday, so we shut the business up and started off for
-the address that was given us in the advertisement.
-
-"I never hope to see such a sight as that again, Mr. Holmes. From
-north, south, east, and west every man who had a shade of red in
-his hair had tramped into the city to answer the advertisement.
-Fleet Street was choked with red-headed folk, and Pope's Court
-looked like a coster's orange barrow. I should not have thought
-there were so many in the whole country as were brought together
-by that single advertisement. Every shade of colour they
-were--straw, lemon, orange, brick, Irish-setter, liver, clay;
-but, as Spaulding said, there were not many who had the real
-vivid flame-coloured tint. When I saw how many were waiting, I
-would have given it up in despair; but Spaulding would not hear
-of it. How he did it I could not imagine, but he pushed and
-pulled and butted until he got me through the crowd, and right up
-to the steps which led to the office. There was a double stream
-upon the stair, some going up in hope, and some coming back
-dejected; but we wedged in as well as we could and soon found
-ourselves in the office."
-
-"Your experience has been a most entertaining one," remarked
-Holmes as his client paused and refreshed his memory with a huge
-pinch of snuff. "Pray continue your very interesting statement."
-
-"There was nothing in the office but a couple of wooden chairs
-and a deal table, behind which sat a small man with a head that
-was even redder than mine. He said a few words to each candidate
-as he came up, and then he always managed to find some fault in
-them which would disqualify them. Getting a vacancy did not seem
-to be such a very easy matter, after all. However, when our turn
-came the little man was much more favourable to me than to any of
-the others, and he closed the door as we entered, so that he
-might have a private word with us.
-
-"'This is Mr. Jabez Wilson,' said my assistant, 'and he is
-willing to fill a vacancy in the League.'
-
-"'And he is admirably suited for it,' the other answered. 'He has
-every requirement. I cannot recall when I have seen anything so
-fine.' He took a step backward, cocked his head on one side, and
-gazed at my hair until I felt quite bashful. Then suddenly he
-plunged forward, wrung my hand, and congratulated me warmly on my
-success.
-
-"'It would be injustice to hesitate,' said he. 'You will,
-however, I am sure, excuse me for taking an obvious precaution.'
-With that he seized my hair in both his hands, and tugged until I
-yelled with the pain. 'There is water in your eyes,' said he as
-he released me. 'I perceive that all is as it should be. But we
-have to be careful, for we have twice been deceived by wigs and
-once by paint. I could tell you tales of cobbler's wax which
-would disgust you with human nature.' He stepped over to the
-window and shouted through it at the top of his voice that the
-vacancy was filled. A groan of disappointment came up from below,
-and the folk all trooped away in different directions until there
-was not a red-head to be seen except my own and that of the
-manager.
-
-"'My name,' said he, 'is Mr. Duncan Ross, and I am myself one of
-the pensioners upon the fund left by our noble benefactor. Are
-you a married man, Mr. Wilson? Have you a family?'
-
-"I answered that I had not.
-
-"His face fell immediately.
-
-"'Dear me!' he said gravely, 'that is very serious indeed! I am
-sorry to hear you say that. The fund was, of course, for the
-propagation and spread of the red-heads as well as for their
-maintenance. It is exceedingly unfortunate that you should be a
-bachelor.'
-
-"My face lengthened at this, Mr. Holmes, for I thought that I was
-not to have the vacancy after all; but after thinking it over for
-a few minutes he said that it would be all right.
-
-"'In the case of another,' said he, 'the objection might be
-fatal, but we must stretch a point in favour of a man with such a
-head of hair as yours. When shall you be able to enter upon your
-new duties?'
-
-"'Well, it is a little awkward, for I have a business already,'
-said I.
-
-"'Oh, never mind about that, Mr. Wilson!' said Vincent Spaulding.
-'I should be able to look after that for you.'
-
-"'What would be the hours?' I asked.
-
-"'Ten to two.'
-
-"Now a pawnbroker's business is mostly done of an evening, Mr.
-Holmes, especially Thursday and Friday evening, which is just
-before pay-day; so it would suit me very well to earn a little in
-the mornings. Besides, I knew that my assistant was a good man,
-and that he would see to anything that turned up.
-
-"'That would suit me very well,' said I. 'And the pay?'
-
-"'Is 4 pounds a week.'
-
-"'And the work?'
-
-"'Is purely nominal.'
-
-"'What do you call purely nominal?'
-
-"'Well, you have to be in the office, or at least in the
-building, the whole time. If you leave, you forfeit your whole
-position forever. The will is very clear upon that point. You
-don't comply with the conditions if you budge from the office
-during that time.'
-
-"'It's only four hours a day, and I should not think of leaving,'
-said I.
-
-"'No excuse will avail,' said Mr. Duncan Ross; 'neither sickness
-nor business nor anything else. There you must stay, or you lose
-your billet.'
-
-"'And the work?'
-
-"'Is to copy out the "Encyclopaedia Britannica." There is the first
-volume of it in that press. You must find your own ink, pens, and
-blotting-paper, but we provide this table and chair. Will you be
-ready to-morrow?'
-
-"'Certainly,' I answered.
-
-"'Then, good-bye, Mr. Jabez Wilson, and let me congratulate you
-once more on the important position which you have been fortunate
-enough to gain.' He bowed me out of the room and I went home with
-my assistant, hardly knowing what to say or do, I was so pleased
-at my own good fortune.
-
-"Well, I thought over the matter all day, and by evening I was in
-low spirits again; for I had quite persuaded myself that the
-whole affair must be some great hoax or fraud, though what its
-object might be I could not imagine. It seemed altogether past
-belief that anyone could make such a will, or that they would pay
-such a sum for doing anything so simple as copying out the
-'Encyclopaedia Britannica.' Vincent Spaulding did what he could to
-cheer me up, but by bedtime I had reasoned myself out of the
-whole thing. However, in the morning I determined to have a look
-at it anyhow, so I bought a penny bottle of ink, and with a
-quill-pen, and seven sheets of foolscap paper, I started off for
-Pope's Court.
-
-"Well, to my surprise and delight, everything was as right as
-possible. The table was set out ready for me, and Mr. Duncan Ross
-was there to see that I got fairly to work. He started me off
-upon the letter A, and then he left me; but he would drop in from
-time to time to see that all was right with me. At two o'clock he
-bade me good-day, complimented me upon the amount that I had
-written, and locked the door of the office after me.
-
-"This went on day after day, Mr. Holmes, and on Saturday the
-manager came in and planked down four golden sovereigns for my
-week's work. It was the same next week, and the same the week
-after. Every morning I was there at ten, and every afternoon I
-left at two. By degrees Mr. Duncan Ross took to coming in only
-once of a morning, and then, after a time, he did not come in at
-all. Still, of course, I never dared to leave the room for an
-instant, for I was not sure when he might come, and the billet
-was such a good one, and suited me so well, that I would not risk
-the loss of it.
-
-"Eight weeks passed away like this, and I had written about
-Abbots and Archery and Armour and Architecture and Attica, and
-hoped with diligence that I might get on to the B's before very
-long. It cost me something in foolscap, and I had pretty nearly
-filled a shelf with my writings. And then suddenly the whole
-business came to an end."
-
-"To an end?"
-
-"Yes, sir. And no later than this morning. I went to my work as
-usual at ten o'clock, but the door was shut and locked, with a
-little square of cardboard hammered on to the middle of the
-panel with a tack. Here it is, and you can read for yourself."
-
-He held up a piece of white cardboard about the size of a sheet
-of note-paper. It read in this fashion:
-
-                  THE RED-HEADED LEAGUE
-
-                           IS
-
-                        DISSOLVED.
-
-                     October 9, 1890.
-
-Sherlock Holmes and I surveyed this curt announcement and the
-rueful face behind it, until the comical side of the affair so
-completely overtopped every other consideration that we both
-burst out into a roar of laughter.
-
-"I cannot see that there is anything very funny," cried our
-client, flushing up to the roots of his flaming head. "If you can
-do nothing better than laugh at me, I can go elsewhere."
-
-"No, no," cried Holmes, shoving him back into the chair from
-which he had half risen. "I really wouldn't miss your case for
-the world. It is most refreshingly unusual. But there is, if you
-will excuse my saying so, something just a little funny about it.
-Pray what steps did you take when you found the card upon the
-door?"
-
-"I was staggered, sir. I did not know what to do. Then I called
-at the offices round, but none of them seemed to know anything
-about it. Finally, I went to the landlord, who is an accountant
-living on the ground-floor, and I asked him if he could tell me
-what had become of the Red-headed League. He said that he had
-never heard of any such body. Then I asked him who Mr. Duncan
-Ross was. He answered that the name was new to him.
-
-"'Well,' said I, 'the gentleman at No. 4.'
-
-"'What, the red-headed man?'
-
-"'Yes.'
-
-"'Oh,' said he, 'his name was William Morris. He was a solicitor
-and was using my room as a temporary convenience until his new
-premises were ready. He moved out yesterday.'
-
-"'Where could I find him?'
-
-"'Oh, at his new offices. He did tell me the address. Yes, 17
-King Edward Street, near St. Paul's.'
-
-"I started off, Mr. Holmes, but when I got to that address it was
-a manufactory of artificial knee-caps, and no one in it had ever
-heard of either Mr. William Morris or Mr. Duncan Ross."
-
-"And what did you do then?" asked Holmes.
-
-"I went home to Saxe-Coburg Square, and I took the advice of my
-assistant. But he could not help me in any way. He could only say
-that if I waited I should hear by post. But that was not quite
-good enough, Mr. Holmes. I did not wish to lose such a place
-without a struggle, so, as I had heard that you were good enough
-to give advice to poor folk who were in need of it, I came right
-away to you."
-
-"And you did very wisely," said Holmes. "Your case is an
-exceedingly remarkable one, and I shall be happy to look into it.
-From what you have told me I think that it is possible that
-graver issues hang from it than might at first sight appear."
-
-"Grave enough!" said Mr. Jabez Wilson. "Why, I have lost four
-pound a week."
-
-"As far as you are personally concerned," remarked Holmes, "I do
-not see that you have any grievance against this extraordinary
-league. On the contrary, you are, as I understand, richer by some
-30 pounds, to say nothing of the minute knowledge which you have
-gained on every subject which comes under the letter A. You have
-lost nothing by them."
-
-"No, sir. But I want to find out about them, and who they are,
-and what their object was in playing this prank--if it was a
-prank--upon me. It was a pretty expensive joke for them, for it
-cost them two and thirty pounds."
-
-"We shall endeavour to clear up these points for you. And, first,
-one or two questions, Mr. Wilson. This assistant of yours who
-first called your attention to the advertisement--how long had he
-been with you?"
-
-"About a month then."
-
-"How did he come?"
-
-"In answer to an advertisement."
-
-"Was he the only applicant?"
-
-"No, I had a dozen."
-
-"Why did you pick him?"
-
-"Because he was handy and would come cheap."
-
-"At half-wages, in fact."
-
-"Yes."
-
-"What is he like, this Vincent Spaulding?"
-
-"Small, stout-built, very quick in his ways, no hair on his face,
-though he's not short of thirty. Has a white splash of acid upon
-his forehead."
-
-Holmes sat up in his chair in considerable excitement. "I thought
-as much," said he. "Have you ever observed that his ears are
-pierced for earrings?"
-
-"Yes, sir. He told me that a gipsy had done it for him when he
-was a lad."
-
-"Hum!" said Holmes, sinking back in deep thought. "He is still
-with you?"
-
-"Oh, yes, sir; I have only just left him."
-
-"And has your business been attended to in your absence?"
-
-"Nothing to complain of, sir. There's never very much to do of a
-morning."
-
-"That will do, Mr. Wilson. I shall be happy to give you an
-opinion upon the subject in the course of a day or two. To-day is
-Saturday, and I hope that by Monday we may come to a conclusion."
-
-"Well, Watson," said Holmes when our visitor had left us, "what
-do you make of it all?"
-
-"I make nothing of it," I answered frankly. "It is a most
-mysterious business."
-
-"As a rule," said Holmes, "the more bizarre a thing is the less
-mysterious it proves to be. It is your commonplace, featureless
-crimes which are really puzzling, just as a commonplace face is
-the most difficult to identify. But I must be prompt over this
-matter."
-
-"What are you going to do, then?" I asked.
-
-"To smoke," he answered. "It is quite a three pipe problem, and I
-beg that you won't speak to me for fifty minutes." He curled
-himself up in his chair, with his thin knees drawn up to his
-hawk-like nose, and there he sat with his eyes closed and his
-black clay pipe thrusting out like the bill of some strange bird.
-I had come to the conclusion that he had dropped asleep, and
-indeed was nodding myself, when he suddenly sprang out of his
-chair with the gesture of a man who has made up his mind and put
-his pipe down upon the mantelpiece.
-
-"Sarasate plays at the St. James's Hall this afternoon," he
-remarked. "What do you think, Watson? Could your patients spare
-you for a few hours?"
-
-"I have nothing to do to-day. My practice is never very
-absorbing."
-
-"Then put on your hat and come. I am going through the City
-first, and we can have some lunch on the way. I observe that
-there is a good deal of German music on the programme, which is
-rather more to my taste than Italian or French. It is
-introspective, and I want to introspect. Come along!"
-
-We travelled by the Underground as far as Aldersgate; and a short
-walk took us to Saxe-Coburg Square, the scene of the singular
-story which we had listened to in the morning. It was a poky,
-little, shabby-genteel place, where four lines of dingy
-two-storied brick houses looked out into a small railed-in
-enclosure, where a lawn of weedy grass and a few clumps of faded
-laurel-bushes made a hard fight against a smoke-laden and
-uncongenial atmosphere. Three gilt balls and a brown board with
-"JABEZ WILSON" in white letters, upon a corner house, announced
-the place where our red-headed client carried on his business.
-Sherlock Holmes stopped in front of it with his head on one side
-and looked it all over, with his eyes shining brightly between
-puckered lids. Then he walked slowly up the street, and then down
-again to the corner, still looking keenly at the houses. Finally
-he returned to the pawnbroker's, and, having thumped vigorously
-upon the pavement with his stick two or three times, he went up
-to the door and knocked. It was instantly opened by a
-bright-looking, clean-shaven young fellow, who asked him to step
-in.
-
-"Thank you," said Holmes, "I only wished to ask you how you would
-go from here to the Strand."
-
-"Third right, fourth left," answered the assistant promptly,
-closing the door.
-
-"Smart fellow, that," observed Holmes as we walked away. "He is,
-in my judgment, the fourth smartest man in London, and for daring
-I am not sure that he has not a claim to be third. I have known
-something of him before."
-
-"Evidently," said I, "Mr. Wilson's assistant counts for a good
-deal in this mystery of the Red-headed League. I am sure that you
-inquired your way merely in order that you might see him."
-
-"Not him."
-
-"What then?"
-
-"The knees of his trousers."
-
-"And what did you see?"
-
-"What I expected to see."
-
-"Why did you beat the pavement?"
-
-"My dear doctor, this is a time for observation, not for talk. We
-are spies in an enemy's country. We know something of Saxe-Coburg
-Square. Let us now explore the parts which lie behind it."
-
-The road in which we found ourselves as we turned round the
-corner from the retired Saxe-Coburg Square presented as great a
-contrast to it as the front of a picture does to the back. It was
-one of the main arteries which conveyed the traffic of the City
-to the north and west. The roadway was blocked with the immense
-stream of commerce flowing in a double tide inward and outward,
-while the footpaths were black with the hurrying swarm of
-pedestrians. It was difficult to realise as we looked at the line
-of fine shops and stately business premises that they really
-abutted on the other side upon the faded and stagnant square
-which we had just quitted.
-
-"Let me see," said Holmes, standing at the corner and glancing
-along the line, "I should like just to remember the order of the
-houses here. It is a hobby of mine to have an exact knowledge of
-London. There is Mortimer's, the tobacconist, the little
-newspaper shop, the Coburg branch of the City and Suburban Bank,
-the Vegetarian Restaurant, and McFarlane's carriage-building
-depot. That carries us right on to the other block. And now,
-Doctor, we've done our work, so it's time we had some play. A
-sandwich and a cup of coffee, and then off to violin-land, where
-all is sweetness and delicacy and harmony, and there are no
-red-headed clients to vex us with their conundrums."
-
-My friend was an enthusiastic musician, being himself not only a
-very capable performer but a composer of no ordinary merit. All
-the afternoon he sat in the stalls wrapped in the most perfect
-happiness, gently waving his long, thin fingers in time to the
-music, while his gently smiling face and his languid, dreamy eyes
-were as unlike those of Holmes the sleuth-hound, Holmes the
-relentless, keen-witted, ready-handed criminal agent, as it was
-possible to conceive. In his singular character the dual nature
-alternately asserted itself, and his extreme exactness and
-astuteness represented, as I have often thought, the reaction
-against the poetic and contemplative mood which occasionally
-predominated in him. The swing of his nature took him from
-extreme languor to devouring energy; and, as I knew well, he was
-never so truly formidable as when, for days on end, he had been
-lounging in his armchair amid his improvisations and his
-black-letter editions. Then it was that the lust of the chase
-would suddenly come upon him, and that his brilliant reasoning
-power would rise to the level of intuition, until those who were
-unacquainted with his methods would look askance at him as on a
-man whose knowledge was not that of other mortals. When I saw him
-that afternoon so enwrapped in the music at St. James's Hall I
-felt that an evil time might be coming upon those whom he had set
-himself to hunt down.
-
-"You want to go home, no doubt, Doctor," he remarked as we
-emerged.
-
-"Yes, it would be as well."
-
-"And I have some business to do which will take some hours. This
-business at Coburg Square is serious."
-
-"Why serious?"
-
-"A considerable crime is in contemplation. I have every reason to
-believe that we shall be in time to stop it. But to-day being
-Saturday rather complicates matters. I shall want your help
-to-night."
-
-"At what time?"
-
-"Ten will be early enough."
-
-"I shall be at Baker Street at ten."
-
-"Very well. And, I say, Doctor, there may be some little danger,
-so kindly put your army revolver in your pocket." He waved his
-hand, turned on his heel, and disappeared in an instant among the
-crowd.
-
-I trust that I am not more dense than my neighbours, but I was
-always oppressed with a sense of my own stupidity in my dealings
-with Sherlock Holmes. Here I had heard what he had heard, I had
-seen what he had seen, and yet from his words it was evident that
-he saw clearly not only what had happened but what was about to
-happen, while to me the whole business was still confused and
-grotesque. As I drove home to my house in Kensington I thought
-over it all, from the extraordinary story of the red-headed
-copier of the "Encyclopaedia" down to the visit to Saxe-Coburg
-Square, and the ominous words with which he had parted from me.
-What was this nocturnal expedition, and why should I go armed?
-Where were we going, and what were we to do? I had the hint from
-Holmes that this smooth-faced pawnbroker's assistant was a
-formidable man--a man who might play a deep game. I tried to
-puzzle it out, but gave it up in despair and set the matter aside
-until night should bring an explanation.
-
-It was a quarter-past nine when I started from home and made my
-way across the Park, and so through Oxford Street to Baker
-Street. Two hansoms were standing at the door, and as I entered
-the passage I heard the sound of voices from above. On entering
-his room I found Holmes in animated conversation with two men,
-one of whom I recognised as Peter Jones, the official police
-agent, while the other was a long, thin, sad-faced man, with a
-very shiny hat and oppressively respectable frock-coat.
-
-"Ha! Our party is complete," said Holmes, buttoning up his
-pea-jacket and taking his heavy hunting crop from the rack.
-"Watson, I think you know Mr. Jones, of Scotland Yard? Let me
-introduce you to Mr. Merryweather, who is to be our companion in
-to-night's adventure."
-
-"We're hunting in couples again, Doctor, you see," said Jones in
-his consequential way. "Our friend here is a wonderful man for
-starting a chase. All he wants is an old dog to help him to do
-the running down."
-
-"I hope a wild goose may not prove to be the end of our chase,"
-observed Mr. Merryweather gloomily.
-
-"You may place considerable confidence in Mr. Holmes, sir," said
-the police agent loftily. "He has his own little methods, which
-are, if he won't mind my saying so, just a little too theoretical
-and fantastic, but he has the makings of a detective in him. It
-is not too much to say that once or twice, as in that business of
-the Sholto murder and the Agra treasure, he has been more nearly
-correct than the official force."
-
-"Oh, if you say so, Mr. Jones, it is all right," said the
-stranger with deference. "Still, I confess that I miss my rubber.
-It is the first Saturday night for seven-and-twenty years that I
-have not had my rubber."
-
-"I think you will find," said Sherlock Holmes, "that you will
-play for a higher stake to-night than you have ever done yet, and
-that the play will be more exciting. For you, Mr. Merryweather,
-the stake will be some 30,000 pounds; and for you, Jones, it will
-be the man upon whom you wish to lay your hands."
-
-"John Clay, the murderer, thief, smasher, and forger. He's a
-young man, Mr. Merryweather, but he is at the head of his
-profession, and I would rather have my bracelets on him than on
-any criminal in London. He's a remarkable man, is young John
-Clay. His grandfather was a royal duke, and he himself has been
-to Eton and Oxford. His brain is as cunning as his fingers, and
-though we meet signs of him at every turn, we never know where to
-find the man himself. He'll crack a crib in Scotland one week,
-and be raising money to build an orphanage in Cornwall the next.
-I've been on his track for years and have never set eyes on him
-yet."
-
-"I hope that I may have the pleasure of introducing you to-night.
-I've had one or two little turns also with Mr. John Clay, and I
-agree with you that he is at the head of his profession. It is
-past ten, however, and quite time that we started. If you two
-will take the first hansom, Watson and I will follow in the
-second."
-
-Sherlock Holmes was not very communicative during the long drive
-and lay back in the cab humming the tunes which he had heard in
-the afternoon. We rattled through an endless labyrinth of gas-lit
-streets until we emerged into Farrington Street.
-
-"We are close there now," my friend remarked. "This fellow
-Merryweather is a bank director, and personally interested in the
-matter. I thought it as well to have Jones with us also. He is
-not a bad fellow, though an absolute imbecile in his profession.
-He has one positive virtue. He is as brave as a bulldog and as
-tenacious as a lobster if he gets his claws upon anyone. Here we
-are, and they are waiting for us."
-
-We had reached the same crowded thoroughfare in which we had
-found ourselves in the morning. Our cabs were dismissed, and,
-following the guidance of Mr. Merryweather, we passed down a
-narrow passage and through a side door, which he opened for us.
-Within there was a small corridor, which ended in a very massive
-iron gate. This also was opened, and led down a flight of winding
-stone steps, which terminated at another formidable gate. Mr.
-Merryweather stopped to light a lantern, and then conducted us
-down a dark, earth-smelling passage, and so, after opening a
-third door, into a huge vault or cellar, which was piled all
-round with crates and massive boxes.
-
-"You are not very vulnerable from above," Holmes remarked as he
-held up the lantern and gazed about him.
-
-"Nor from below," said Mr. Merryweather, striking his stick upon
-the flags which lined the floor. "Why, dear me, it sounds quite
-hollow!" he remarked, looking up in surprise.
-
-"I must really ask you to be a little more quiet!" said Holmes
-severely. "You have already imperilled the whole success of our
-expedition. Might I beg that you would have the goodness to sit
-down upon one of those boxes, and not to interfere?"
-
-The solemn Mr. Merryweather perched himself upon a crate, with a
-very injured expression upon his face, while Holmes fell upon his
-knees upon the floor and, with the lantern and a magnifying lens,
-began to examine minutely the cracks between the stones. A few
-seconds sufficed to satisfy him, for he sprang to his feet again
-and put his glass in his pocket.
-
-"We have at least an hour before us," he remarked, "for they can
-hardly take any steps until the good pawnbroker is safely in bed.
-Then they will not lose a minute, for the sooner they do their
-work the longer time they will have for their escape. We are at
-present, Doctor--as no doubt you have divined--in the cellar of
-the City branch of one of the principal London banks. Mr.
-Merryweather is the chairman of directors, and he will explain to
-you that there are reasons why the more daring criminals of
-London should take a considerable interest in this cellar at
-present."
-
-"It is our French gold," whispered the director. "We have had
-several warnings that an attempt might be made upon it."
-
-"Your French gold?"
-
-"Yes. We had occasion some months ago to strengthen our resources
-and borrowed for that purpose 30,000 napoleons from the Bank of
-France. It has become known that we have never had occasion to
-unpack the money, and that it is still lying in our cellar. The
-crate upon which I sit contains 2,000 napoleons packed between
-layers of lead foil. Our reserve of bullion is much larger at
-present than is usually kept in a single branch office, and the
-directors have had misgivings upon the subject."
-
-"Which were very well justified," observed Holmes. "And now it is
-time that we arranged our little plans. I expect that within an
-hour matters will come to a head. In the meantime Mr.
-Merryweather, we must put the screen over that dark lantern."
-
-"And sit in the dark?"
-
-"I am afraid so. I had brought a pack of cards in my pocket, and
-I thought that, as we were a partie carrée, you might have your
-rubber after all. But I see that the enemy's preparations have
-gone so far that we cannot risk the presence of a light. And,
-first of all, we must choose our positions. These are daring men,
-and though we shall take them at a disadvantage, they may do us
-some harm unless we are careful. I shall stand behind this crate,
-and do you conceal yourselves behind those. Then, when I flash a
-light upon them, close in swiftly. If they fire, Watson, have no
-compunction about shooting them down."
-
-I placed my revolver, cocked, upon the top of the wooden case
-behind which I crouched. Holmes shot the slide across the front
-of his lantern and left us in pitch darkness--such an absolute
-darkness as I have never before experienced. The smell of hot
-metal remained to assure us that the light was still there, ready
-to flash out at a moment's notice. To me, with my nerves worked
-up to a pitch of expectancy, there was something depressing and
-subduing in the sudden gloom, and in the cold dank air of the
-vault.
-
-"They have but one retreat," whispered Holmes. "That is back
-through the house into Saxe-Coburg Square. I hope that you have
-done what I asked you, Jones?"
-
-"I have an inspector and two officers waiting at the front door."
-
-"Then we have stopped all the holes. And now we must be silent
-and wait."
-
-What a time it seemed! From comparing notes afterwards it was but
-an hour and a quarter, yet it appeared to me that the night must
-have almost gone and the dawn be breaking above us. My limbs
-were weary and stiff, for I feared to change my position; yet my
-nerves were worked up to the highest pitch of tension, and my
-hearing was so acute that I could not only hear the gentle
-breathing of my companions, but I could distinguish the deeper,
-heavier in-breath of the bulky Jones from the thin, sighing note
-of the bank director. From my position I could look over the case
-in the direction of the floor. Suddenly my eyes caught the glint
-of a light.
-
-At first it was but a lurid spark upon the stone pavement. Then
-it lengthened out until it became a yellow line, and then,
-without any warning or sound, a gash seemed to open and a hand
-appeared, a white, almost womanly hand, which felt about in the
-centre of the little area of light. For a minute or more the
-hand, with its writhing fingers, protruded out of the floor. Then
-it was withdrawn as suddenly as it appeared, and all was dark
-again save the single lurid spark which marked a chink between
-the stones.
-
-Its disappearance, however, was but momentary. With a rending,
-tearing sound, one of the broad, white stones turned over upon
-its side and left a square, gaping hole, through which streamed
-the light of a lantern. Over the edge there peeped a clean-cut,
-boyish face, which looked keenly about it, and then, with a hand
-on either side of the aperture, drew itself shoulder-high and
-waist-high, until one knee rested upon the edge. In another
-instant he stood at the side of the hole and was hauling after
-him a companion, lithe and small like himself, with a pale face
-and a shock of very red hair.
-
-"It's all clear," he whispered. "Have you the chisel and the
-bags? Great Scott! Jump, Archie, jump, and I'll swing for it!"
-
-Sherlock Holmes had sprung out and seized the intruder by the
-collar. The other dived down the hole, and I heard the sound of
-rending cloth as Jones clutched at his skirts. The light flashed
-upon the barrel of a revolver, but Holmes' hunting crop came
-down on the man's wrist, and the pistol clinked upon the stone
-floor.
-
-"It's no use, John Clay," said Holmes blandly. "You have no
-chance at all."
-
-"So I see," the other answered with the utmost coolness. "I fancy
-that my pal is all right, though I see you have got his
-coat-tails."
-
-"There are three men waiting for him at the door," said Holmes.
-
-"Oh, indeed! You seem to have done the thing very completely. I
-must compliment you."
-
-"And I you," Holmes answered. "Your red-headed idea was very new
-and effective."
-
-"You'll see your pal again presently," said Jones. "He's quicker
-at climbing down holes than I am. Just hold out while I fix the
-derbies."
-
-"I beg that you will not touch me with your filthy hands,"
-remarked our prisoner as the handcuffs clattered upon his wrists.
-"You may not be aware that I have royal blood in my veins. Have
-the goodness, also, when you address me always to say 'sir' and
-'please.'"
-
-"All right," said Jones with a stare and a snigger. "Well, would
-you please, sir, march upstairs, where we can get a cab to carry
-your Highness to the police-station?"
-
-"That is better," said John Clay serenely. He made a sweeping bow
-to the three of us and walked quietly off in the custody of the
-detective.
-
-"Really, Mr. Holmes," said Mr. Merryweather as we followed them
-from the cellar, "I do not know how the bank can thank you or
-repay you. There is no doubt that you have detected and defeated
-in the most complete manner one of the most determined attempts
-at bank robbery that have ever come within my experience."
-
-"I have had one or two little scores of my own to settle with Mr.
-John Clay," said Holmes. "I have been at some small expense over
-this matter, which I shall expect the bank to refund, but beyond
-that I am amply repaid by having had an experience which is in
-many ways unique, and by hearing the very remarkable narrative of
-the Red-headed League."
-
-
-"You see, Watson," he explained in the early hours of the morning
-as we sat over a glass of whisky and soda in Baker Street, "it
-was perfectly obvious from the first that the only possible
-object of this rather fantastic business of the advertisement of
-the League, and the copying of the 'Encyclopaedia,' must be to get
-this not over-bright pawnbroker out of the way for a number of
-hours every day. It was a curious way of managing it, but,
-really, it would be difficult to suggest a better. The method was
-no doubt suggested to Clay's ingenious mind by the colour of his
-accomplice's hair. The 4 pounds a week was a lure which must draw
-him, and what was it to them, who were playing for thousands?
-They put in the advertisement, one rogue has the temporary
-office, the other rogue incites the man to apply for it, and
-together they manage to secure his absence every morning in the
-week. From the time that I heard of the assistant having come for
-half wages, it was obvious to me that he had some strong motive
-for securing the situation."
-
-"But how could you guess what the motive was?"
-
-"Had there been women in the house, I should have suspected a
-mere vulgar intrigue. That, however, was out of the question. The
-man's business was a small one, and there was nothing in his
-house which could account for such elaborate preparations, and
-such an expenditure as they were at. It must, then, be something
-out of the house. What could it be? I thought of the assistant's
-fondness for photography, and his trick of vanishing into the
-cellar. The cellar! There was the end of this tangled clue. Then
-I made inquiries as to this mysterious assistant and found that I
-had to deal with one of the coolest and most daring criminals in
-London. He was doing something in the cellar--something which
-took many hours a day for months on end. What could it be, once
-more? I could think of nothing save that he was running a tunnel
-to some other building.
-
-"So far I had got when we went to visit the scene of action. I
-surprised you by beating upon the pavement with my stick. I was
-ascertaining whether the cellar stretched out in front or behind.
-It was not in front. Then I rang the bell, and, as I hoped, the
-assistant answered it. We have had some skirmishes, but we had
-never set eyes upon each other before. I hardly looked at his
-face. His knees were what I wished to see. You must yourself have
-remarked how worn, wrinkled, and stained they were. They spoke of
-those hours of burrowing. The only remaining point was what they
-were burrowing for. I walked round the corner, saw the City and
-Suburban Bank abutted on our friend's premises, and felt that I
-had solved my problem. When you drove home after the concert I
-called upon Scotland Yard and upon the chairman of the bank
-directors, with the result that you have seen."
-
-"And how could you tell that they would make their attempt
-to-night?" I asked.
-
-"Well, when they closed their League offices that was a sign that
-they cared no longer about Mr. Jabez Wilson's presence--in other
-words, that they had completed their tunnel. But it was essential
-that they should use it soon, as it might be discovered, or the
-bullion might be removed. Saturday would suit them better than
-any other day, as it would give them two days for their escape.
-For all these reasons I expected them to come to-night."
-
-"You reasoned it out beautifully," I exclaimed in unfeigned
-admiration. "It is so long a chain, and yet every link rings
-true."
-
-"It saved me from ennui," he answered, yawning. "Alas! I already
-feel it closing in upon me. My life is spent in one long effort
-to escape from the commonplaces of existence. These little
-problems help me to do so."
-
-"And you are a benefactor of the race," said I.
-
-He shrugged his shoulders. "Well, perhaps, after all, it is of
-some little use," he remarked. "'L'homme c'est rien--l'oeuvre
-c'est tout,' as Gustave Flaubert wrote to George Sand."
-
-
-
-ADVENTURE III. A CASE OF IDENTITY
-
-"My dear fellow," said Sherlock Holmes as we sat on either side
-of the fire in his lodgings at Baker Street, "life is infinitely
-stranger than anything which the mind of man could invent. We
-would not dare to conceive the things which are really mere
-commonplaces of existence. If we could fly out of that window
-hand in hand, hover over this great city, gently remove the
-roofs, and peep in at the queer things which are going on, the
-strange coincidences, the plannings, the cross-purposes, the
-wonderful chains of events, working through generations, and
-leading to the most outré results, it would make all fiction with
-its conventionalities and foreseen conclusions most stale and
-unprofitable."
-
-"And yet I am not convinced of it," I answered. "The cases which
-come to light in the papers are, as a rule, bald enough, and
-vulgar enough. We have in our police reports realism pushed to
-its extreme limits, and yet the result is, it must be confessed,
-neither fascinating nor artistic."
-
-"A certain selection and discretion must be used in producing a
-realistic effect," remarked Holmes. "This is wanting in the
-police report, where more stress is laid, perhaps, upon the
-platitudes of the magistrate than upon the details, which to an
-observer contain the vital essence of the whole matter. Depend
-upon it, there is nothing so unnatural as the commonplace."
-
-I smiled and shook my head. "I can quite understand your thinking
-so," I said. "Of course, in your position of unofficial adviser
-and helper to everybody who is absolutely puzzled, throughout
-three continents, you are brought in contact with all that is
-strange and bizarre. But here"--I picked up the morning paper
-from the ground--"let us put it to a practical test. Here is the
-first heading upon which I come. 'A husband's cruelty to his
-wife.' There is half a column of print, but I know without
-reading it that it is all perfectly familiar to me. There is, of
-course, the other woman, the drink, the push, the blow, the
-bruise, the sympathetic sister or landlady. The crudest of
-writers could invent nothing more crude."
-
-"Indeed, your example is an unfortunate one for your argument,"
-said Holmes, taking the paper and glancing his eye down it. "This
-is the Dundas separation case, and, as it happens, I was engaged
-in clearing up some small points in connection with it. The
-husband was a teetotaler, there was no other woman, and the
-conduct complained of was that he had drifted into the habit of
-winding up every meal by taking out his false teeth and hurling
-them at his wife, which, you will allow, is not an action likely
-to occur to the imagination of the average story-teller. Take a
-pinch of snuff, Doctor, and acknowledge that I have scored over
-you in your example."
-
-He held out his snuffbox of old gold, with a great amethyst in
-the centre of the lid. Its splendour was in such contrast to his
-homely ways and simple life that I could not help commenting upon
-it.
-
-"Ah," said he, "I forgot that I had not seen you for some weeks.
-It is a little souvenir from the King of Bohemia in return for my
-assistance in the case of the Irene Adler papers."
-
-"And the ring?" I asked, glancing at a remarkable brilliant which
-sparkled upon his finger.
-
-"It was from the reigning family of Holland, though the matter in
-which I served them was of such delicacy that I cannot confide it
-even to you, who have been good enough to chronicle one or two of
-my little problems."
-
-"And have you any on hand just now?" I asked with interest.
-
-"Some ten or twelve, but none which present any feature of
-interest. They are important, you understand, without being
-interesting. Indeed, I have found that it is usually in
-unimportant matters that there is a field for the observation,
-and for the quick analysis of cause and effect which gives the
-charm to an investigation. The larger crimes are apt to be the
-simpler, for the bigger the crime the more obvious, as a rule, is
-the motive. In these cases, save for one rather intricate matter
-which has been referred to me from Marseilles, there is nothing
-which presents any features of interest. It is possible, however,
-that I may have something better before very many minutes are
-over, for this is one of my clients, or I am much mistaken."
-
-He had risen from his chair and was standing between the parted
-blinds gazing down into the dull neutral-tinted London street.
-Looking over his shoulder, I saw that on the pavement opposite
-there stood a large woman with a heavy fur boa round her neck,
-and a large curling red feather in a broad-brimmed hat which was
-tilted in a coquettish Duchess of Devonshire fashion over her
-ear. From under this great panoply she peeped up in a nervous,
-hesitating fashion at our windows, while her body oscillated
-backward and forward, and her fingers fidgeted with her glove
-buttons. Suddenly, with a plunge, as of the swimmer who leaves
-the bank, she hurried across the road, and we heard the sharp
-clang of the bell.
-
-"I have seen those symptoms before," said Holmes, throwing his
-cigarette into the fire. "Oscillation upon the pavement always
-means an affaire de coeur. She would like advice, but is not sure
-that the matter is not too delicate for communication. And yet
-even here we may discriminate. When a woman has been seriously
-wronged by a man she no longer oscillates, and the usual symptom
-is a broken bell wire. Here we may take it that there is a love
-matter, but that the maiden is not so much angry as perplexed, or
-grieved. But here she comes in person to resolve our doubts."
-
-As he spoke there was a tap at the door, and the boy in buttons
-entered to announce Miss Mary Sutherland, while the lady herself
-loomed behind his small black figure like a full-sailed
-merchant-man behind a tiny pilot boat. Sherlock Holmes welcomed
-her with the easy courtesy for which he was remarkable, and,
-having closed the door and bowed her into an armchair, he looked
-her over in the minute and yet abstracted fashion which was
-peculiar to him.
-
-"Do you not find," he said, "that with your short sight it is a
-little trying to do so much typewriting?"
-
-"I did at first," she answered, "but now I know where the letters
-are without looking." Then, suddenly realising the full purport
-of his words, she gave a violent start and looked up, with fear
-and astonishment upon her broad, good-humoured face. "You've
-heard about me, Mr. Holmes," she cried, "else how could you know
-all that?"
-
-"Never mind," said Holmes, laughing; "it is my business to know
-things. Perhaps I have trained myself to see what others
-overlook. If not, why should you come to consult me?"
-
-"I came to you, sir, because I heard of you from Mrs. Etherege,
-whose husband you found so easy when the police and everyone had
-given him up for dead. Oh, Mr. Holmes, I wish you would do as
-much for me. I'm not rich, but still I have a hundred a year in
-my own right, besides the little that I make by the machine, and
-I would give it all to know what has become of Mr. Hosmer Angel."
-
-"Why did you come away to consult me in such a hurry?" asked
-Sherlock Holmes, with his finger-tips together and his eyes to
-the ceiling.
-
-Again a startled look came over the somewhat vacuous face of Miss
-Mary Sutherland. "Yes, I did bang out of the house," she said,
-"for it made me angry to see the easy way in which Mr.
-Windibank--that is, my father--took it all. He would not go to
-the police, and he would not go to you, and so at last, as he
-would do nothing and kept on saying that there was no harm done,
-it made me mad, and I just on with my things and came right away
-to you."
-
-"Your father," said Holmes, "your stepfather, surely, since the
-name is different."
-
-"Yes, my stepfather. I call him father, though it sounds funny,
-too, for he is only five years and two months older than myself."
-
-"And your mother is alive?"
-
-"Oh, yes, mother is alive and well. I wasn't best pleased, Mr.
-Holmes, when she married again so soon after father's death, and
-a man who was nearly fifteen years younger than herself. Father
-was a plumber in the Tottenham Court Road, and he left a tidy
-business behind him, which mother carried on with Mr. Hardy, the
-foreman; but when Mr. Windibank came he made her sell the
-business, for he was very superior, being a traveller in wines.
-They got 4700 pounds for the goodwill and interest, which wasn't
-near as much as father could have got if he had been alive."
-
-I had expected to see Sherlock Holmes impatient under this
-rambling and inconsequential narrative, but, on the contrary, he
-had listened with the greatest concentration of attention.
-
-"Your own little income," he asked, "does it come out of the
-business?"
-
-"Oh, no, sir. It is quite separate and was left me by my uncle
-Ned in Auckland. It is in New Zealand stock, paying 4 1/2 per
-cent. Two thousand five hundred pounds was the amount, but I can
-only touch the interest."
-
-"You interest me extremely," said Holmes. "And since you draw so
-large a sum as a hundred a year, with what you earn into the
-bargain, you no doubt travel a little and indulge yourself in
-every way. I believe that a single lady can get on very nicely
-upon an income of about 60 pounds."
-
-"I could do with much less than that, Mr. Holmes, but you
-understand that as long as I live at home I don't wish to be a
-burden to them, and so they have the use of the money just while
-I am staying with them. Of course, that is only just for the
-time. Mr. Windibank draws my interest every quarter and pays it
-over to mother, and I find that I can do pretty well with what I
-earn at typewriting. It brings me twopence a sheet, and I can
-often do from fifteen to twenty sheets in a day."
-
-"You have made your position very clear to me," said Holmes.
-"This is my friend, Dr. Watson, before whom you can speak as
-freely as before myself. Kindly tell us now all about your
-connection with Mr. Hosmer Angel."
-
-A flush stole over Miss Sutherland's face, and she picked
-nervously at the fringe of her jacket. "I met him first at the
-gasfitters' ball," she said. "They used to send father tickets
-when he was alive, and then afterwards they remembered us, and
-sent them to mother. Mr. Windibank did not wish us to go. He
-never did wish us to go anywhere. He would get quite mad if I
-wanted so much as to join a Sunday-school treat. But this time I
-was set on going, and I would go; for what right had he to
-prevent? He said the folk were not fit for us to know, when all
-father's friends were to be there. And he said that I had nothing
-fit to wear, when I had my purple plush that I had never so much
-as taken out of the drawer. At last, when nothing else would do,
-he went off to France upon the business of the firm, but we went,
-mother and I, with Mr. Hardy, who used to be our foreman, and it
-was there I met Mr. Hosmer Angel."
-
-"I suppose," said Holmes, "that when Mr. Windibank came back from
-France he was very annoyed at your having gone to the ball."
-
-"Oh, well, he was very good about it. He laughed, I remember, and
-shrugged his shoulders, and said there was no use denying
-anything to a woman, for she would have her way."
-
-"I see. Then at the gasfitters' ball you met, as I understand, a
-gentleman called Mr. Hosmer Angel."
-
-"Yes, sir. I met him that night, and he called next day to ask if
-we had got home all safe, and after that we met him--that is to
-say, Mr. Holmes, I met him twice for walks, but after that father
-came back again, and Mr. Hosmer Angel could not come to the house
-any more."
-
-"No?"
-
-"Well, you know father didn't like anything of the sort. He
-wouldn't have any visitors if he could help it, and he used to
-say that a woman should be happy in her own family circle. But
-then, as I used to say to mother, a woman wants her own circle to
-begin with, and I had not got mine yet."
-
-"But how about Mr. Hosmer Angel? Did he make no attempt to see
-you?"
-
-"Well, father was going off to France again in a week, and Hosmer
-wrote and said that it would be safer and better not to see each
-other until he had gone. We could write in the meantime, and he
-used to write every day. I took the letters in in the morning, so
-there was no need for father to know."
-
-"Were you engaged to the gentleman at this time?"
-
-"Oh, yes, Mr. Holmes. We were engaged after the first walk that
-we took. Hosmer--Mr. Angel--was a cashier in an office in
-Leadenhall Street--and--"
-
-"What office?"
-
-"That's the worst of it, Mr. Holmes, I don't know."
-
-"Where did he live, then?"
-
-"He slept on the premises."
-
-"And you don't know his address?"
-
-"No--except that it was Leadenhall Street."
-
-"Where did you address your letters, then?"
-
-"To the Leadenhall Street Post Office, to be left till called
-for. He said that if they were sent to the office he would be
-chaffed by all the other clerks about having letters from a lady,
-so I offered to typewrite them, like he did his, but he wouldn't
-have that, for he said that when I wrote them they seemed to come
-from me, but when they were typewritten he always felt that the
-machine had come between us. That will just show you how fond he
-was of me, Mr. Holmes, and the little things that he would think
-of."
-
-"It was most suggestive," said Holmes. "It has long been an axiom
-of mine that the little things are infinitely the most important.
-Can you remember any other little things about Mr. Hosmer Angel?"
-
-"He was a very shy man, Mr. Holmes. He would rather walk with me
-in the evening than in the daylight, for he said that he hated to
-be conspicuous. Very retiring and gentlemanly he was. Even his
-voice was gentle. He'd had the quinsy and swollen glands when he
-was young, he told me, and it had left him with a weak throat,
-and a hesitating, whispering fashion of speech. He was always
-well dressed, very neat and plain, but his eyes were weak, just
-as mine are, and he wore tinted glasses against the glare."
-
-"Well, and what happened when Mr. Windibank, your stepfather,
-returned to France?"
-
-"Mr. Hosmer Angel came to the house again and proposed that we
-should marry before father came back. He was in dreadful earnest
-and made me swear, with my hands on the Testament, that whatever
-happened I would always be true to him. Mother said he was quite
-right to make me swear, and that it was a sign of his passion.
-Mother was all in his favour from the first and was even fonder
-of him than I was. Then, when they talked of marrying within the
-week, I began to ask about father; but they both said never to
-mind about father, but just to tell him afterwards, and mother
-said she would make it all right with him. I didn't quite like
-that, Mr. Holmes. It seemed funny that I should ask his leave, as
-he was only a few years older than me; but I didn't want to do
-anything on the sly, so I wrote to father at Bordeaux, where the
-company has its French offices, but the letter came back to me on
-the very morning of the wedding."
-
-"It missed him, then?"
-
-"Yes, sir; for he had started to England just before it arrived."
-
-"Ha! that was unfortunate. Your wedding was arranged, then, for
-the Friday. Was it to be in church?"
-
-"Yes, sir, but very quietly. It was to be at St. Saviour's, near
-King's Cross, and we were to have breakfast afterwards at the St.
-Pancras Hotel. Hosmer came for us in a hansom, but as there were
-two of us he put us both into it and stepped himself into a
-four-wheeler, which happened to be the only other cab in the
-street. We got to the church first, and when the four-wheeler
-drove up we waited for him to step out, but he never did, and
-when the cabman got down from the box and looked there was no one
-there! The cabman said that he could not imagine what had become
-of him, for he had seen him get in with his own eyes. That was
-last Friday, Mr. Holmes, and I have never seen or heard anything
-since then to throw any light upon what became of him."
-
-"It seems to me that you have been very shamefully treated," said
-Holmes.
-
-"Oh, no, sir! He was too good and kind to leave me so. Why, all
-the morning he was saying to me that, whatever happened, I was to
-be true; and that even if something quite unforeseen occurred to
-separate us, I was always to remember that I was pledged to him,
-and that he would claim his pledge sooner or later. It seemed
-strange talk for a wedding-morning, but what has happened since
-gives a meaning to it."
-
-"Most certainly it does. Your own opinion is, then, that some
-unforeseen catastrophe has occurred to him?"
-
-"Yes, sir. I believe that he foresaw some danger, or else he
-would not have talked so. And then I think that what he foresaw
-happened."
-
-"But you have no notion as to what it could have been?"
-
-"None."
-
-"One more question. How did your mother take the matter?"
-
-"She was angry, and said that I was never to speak of the matter
-again."
-
-"And your father? Did you tell him?"
-
-"Yes; and he seemed to think, with me, that something had
-happened, and that I should hear of Hosmer again. As he said,
-what interest could anyone have in bringing me to the doors of
-the church, and then leaving me? Now, if he had borrowed my
-money, or if he had married me and got my money settled on him,
-there might be some reason, but Hosmer was very independent about
-money and never would look at a shilling of mine. And yet, what
-could have happened? And why could he not write? Oh, it drives me
-half-mad to think of it, and I can't sleep a wink at night." She
-pulled a little handkerchief out of her muff and began to sob
-heavily into it.
-
-"I shall glance into the case for you," said Holmes, rising, "and
-I have no doubt that we shall reach some definite result. Let the
-weight of the matter rest upon me now, and do not let your mind
-dwell upon it further. Above all, try to let Mr. Hosmer Angel
-vanish from your memory, as he has done from your life."
-
-"Then you don't think I'll see him again?"
-
-"I fear not."
-
-"Then what has happened to him?"
-
-"You will leave that question in my hands. I should like an
-accurate description of him and any letters of his which you can
-spare."
-
-"I advertised for him in last Saturday's Chronicle," said she.
-"Here is the slip and here are four letters from him."
-
-"Thank you. And your address?"
-
-"No. 31 Lyon Place, Camberwell."
-
-"Mr. Angel's address you never had, I understand. Where is your
-father's place of business?"
-
-"He travels for Westhouse & Marbank, the great claret importers
-of Fenchurch Street."
-
-"Thank you. You have made your statement very clearly. You will
-leave the papers here, and remember the advice which I have given
-you. Let the whole incident be a sealed book, and do not allow it
-to affect your life."
-
-"You are very kind, Mr. Holmes, but I cannot do that. I shall be
-true to Hosmer. He shall find me ready when he comes back."
-
-For all the preposterous hat and the vacuous face, there was
-something noble in the simple faith of our visitor which
-compelled our respect. She laid her little bundle of papers upon
-the table and went her way, with a promise to come again whenever
-she might be summoned.
-
-Sherlock Holmes sat silent for a few minutes with his fingertips
-still pressed together, his legs stretched out in front of him,
-and his gaze directed upward to the ceiling. Then he took down
-from the rack the old and oily clay pipe, which was to him as a
-counsellor, and, having lit it, he leaned back in his chair, with
-the thick blue cloud-wreaths spinning up from him, and a look of
-infinite languor in his face.
-
-"Quite an interesting study, that maiden," he observed. "I found
-her more interesting than her little problem, which, by the way,
-is rather a trite one. You will find parallel cases, if you
-consult my index, in Andover in '77, and there was something of
-the sort at The Hague last year. Old as is the idea, however,
-there were one or two details which were new to me. But the
-maiden herself was most instructive."
-
-"You appeared to read a good deal upon her which was quite
-invisible to me," I remarked.
-
-"Not invisible but unnoticed, Watson. You did not know where to
-look, and so you missed all that was important. I can never bring
-you to realise the importance of sleeves, the suggestiveness of
-thumb-nails, or the great issues that may hang from a boot-lace.
-Now, what did you gather from that woman's appearance? Describe
-it."
-
-"Well, she had a slate-coloured, broad-brimmed straw hat, with a
-feather of a brickish red. Her jacket was black, with black beads
-sewn upon it, and a fringe of little black jet ornaments. Her
-dress was brown, rather darker than coffee colour, with a little
-purple plush at the neck and sleeves. Her gloves were greyish and
-were worn through at the right forefinger. Her boots I didn't
-observe. She had small round, hanging gold earrings, and a
-general air of being fairly well-to-do in a vulgar, comfortable,
-easy-going way."
-
-Sherlock Holmes clapped his hands softly together and chuckled.
-
-"'Pon my word, Watson, you are coming along wonderfully. You have
-really done very well indeed. It is true that you have missed
-everything of importance, but you have hit upon the method, and
-you have a quick eye for colour. Never trust to general
-impressions, my boy, but concentrate yourself upon details. My
-first glance is always at a woman's sleeve. In a man it is
-perhaps better first to take the knee of the trouser. As you
-observe, this woman had plush upon her sleeves, which is a most
-useful material for showing traces. The double line a little
-above the wrist, where the typewritist presses against the table,
-was beautifully defined. The sewing-machine, of the hand type,
-leaves a similar mark, but only on the left arm, and on the side
-of it farthest from the thumb, instead of being right across the
-broadest part, as this was. I then glanced at her face, and,
-observing the dint of a pince-nez at either side of her nose, I
-ventured a remark upon short sight and typewriting, which seemed
-to surprise her."
-
-"It surprised me."
-
-"But, surely, it was obvious. I was then much surprised and
-interested on glancing down to observe that, though the boots
-which she was wearing were not unlike each other, they were
-really odd ones; the one having a slightly decorated toe-cap, and
-the other a plain one. One was buttoned only in the two lower
-buttons out of five, and the other at the first, third, and
-fifth. Now, when you see that a young lady, otherwise neatly
-dressed, has come away from home with odd boots, half-buttoned,
-it is no great deduction to say that she came away in a hurry."
-
-"And what else?" I asked, keenly interested, as I always was, by
-my friend's incisive reasoning.
-
-"I noted, in passing, that she had written a note before leaving
-home but after being fully dressed. You observed that her right
-glove was torn at the forefinger, but you did not apparently see
-that both glove and finger were stained with violet ink. She had
-written in a hurry and dipped her pen too deep. It must have been
-this morning, or the mark would not remain clear upon the finger.
-All this is amusing, though rather elementary, but I must go back
-to business, Watson. Would you mind reading me the advertised
-description of Mr. Hosmer Angel?"
-
-I held the little printed slip to the light.
-
-"Missing," it said, "on the morning of the fourteenth, a gentleman
-named Hosmer Angel. About five ft. seven in. in height;
-strongly built, sallow complexion, black hair, a little bald in
-the centre, bushy, black side-whiskers and moustache; tinted
-glasses, slight infirmity of speech. Was dressed, when last seen,
-in black frock-coat faced with silk, black waistcoat, gold Albert
-chain, and grey Harris tweed trousers, with brown gaiters over
-elastic-sided boots. Known to have been employed in an office in
-Leadenhall Street. Anybody bringing--"
-
-"That will do," said Holmes. "As to the letters," he continued,
-glancing over them, "they are very commonplace. Absolutely no
-clue in them to Mr. Angel, save that he quotes Balzac once. There
-is one remarkable point, however, which will no doubt strike
-you."
-
-"They are typewritten," I remarked.
-
-"Not only that, but the signature is typewritten. Look at the
-neat little 'Hosmer Angel' at the bottom. There is a date, you
-see, but no superscription except Leadenhall Street, which is
-rather vague. The point about the signature is very suggestive--in
-fact, we may call it conclusive."
-
-"Of what?"
-
-"My dear fellow, is it possible you do not see how strongly it
-bears upon the case?"
-
-"I cannot say that I do unless it were that he wished to be able
-to deny his signature if an action for breach of promise were
-instituted."
-
-"No, that was not the point. However, I shall write two letters,
-which should settle the matter. One is to a firm in the City, the
-other is to the young lady's stepfather, Mr. Windibank, asking
-him whether he could meet us here at six o'clock tomorrow
-evening. It is just as well that we should do business with the
-male relatives. And now, Doctor, we can do nothing until the
-answers to those letters come, so we may put our little problem
-upon the shelf for the interim."
-
-I had had so many reasons to believe in my friend's subtle powers
-of reasoning and extraordinary energy in action that I felt that
-he must have some solid grounds for the assured and easy
-demeanour with which he treated the singular mystery which he had
-been called upon to fathom. Once only had I known him to fail, in
-the case of the King of Bohemia and of the Irene Adler
-photograph; but when I looked back to the weird business of the
-Sign of Four, and the extraordinary circumstances connected with
-the Study in Scarlet, I felt that it would be a strange tangle
-indeed which he could not unravel.
-
-I left him then, still puffing at his black clay pipe, with the
-conviction that when I came again on the next evening I would
-find that he held in his hands all the clues which would lead up
-to the identity of the disappearing bridegroom of Miss Mary
-Sutherland.
-
-A professional case of great gravity was engaging my own
-attention at the time, and the whole of next day I was busy at
-the bedside of the sufferer. It was not until close upon six
-o'clock that I found myself free and was able to spring into a
-hansom and drive to Baker Street, half afraid that I might be too
-late to assist at the dénouement of the little mystery. I found
-Sherlock Holmes alone, however, half asleep, with his long, thin
-form curled up in the recesses of his armchair. A formidable
-array of bottles and test-tubes, with the pungent cleanly smell
-of hydrochloric acid, told me that he had spent his day in the
-chemical work which was so dear to him.
-
-"Well, have you solved it?" I asked as I entered.
-
-"Yes. It was the bisulphate of baryta."
-
-"No, no, the mystery!" I cried.
-
-"Oh, that! I thought of the salt that I have been working upon.
-There was never any mystery in the matter, though, as I said
-yesterday, some of the details are of interest. The only drawback
-is that there is no law, I fear, that can touch the scoundrel."
-
-"Who was he, then, and what was his object in deserting Miss
-Sutherland?"
-
-The question was hardly out of my mouth, and Holmes had not yet
-opened his lips to reply, when we heard a heavy footfall in the
-passage and a tap at the door.
-
-"This is the girl's stepfather, Mr. James Windibank," said
-Holmes. "He has written to me to say that he would be here at
-six. Come in!"
-
-The man who entered was a sturdy, middle-sized fellow, some
-thirty years of age, clean-shaven, and sallow-skinned, with a
-bland, insinuating manner, and a pair of wonderfully sharp and
-penetrating grey eyes. He shot a questioning glance at each of
-us, placed his shiny top-hat upon the sideboard, and with a
-slight bow sidled down into the nearest chair.
-
-"Good-evening, Mr. James Windibank," said Holmes. "I think that
-this typewritten letter is from you, in which you made an
-appointment with me for six o'clock?"
-
-"Yes, sir. I am afraid that I am a little late, but I am not
-quite my own master, you know. I am sorry that Miss Sutherland
-has troubled you about this little matter, for I think it is far
-better not to wash linen of the sort in public. It was quite
-against my wishes that she came, but she is a very excitable,
-impulsive girl, as you may have noticed, and she is not easily
-controlled when she has made up her mind on a point. Of course, I
-did not mind you so much, as you are not connected with the
-official police, but it is not pleasant to have a family
-misfortune like this noised abroad. Besides, it is a useless
-expense, for how could you possibly find this Hosmer Angel?"
-
-"On the contrary," said Holmes quietly; "I have every reason to
-believe that I will succeed in discovering Mr. Hosmer Angel."
-
-Mr. Windibank gave a violent start and dropped his gloves. "I am
-delighted to hear it," he said.
-
-"It is a curious thing," remarked Holmes, "that a typewriter has
-really quite as much individuality as a man's handwriting. Unless
-they are quite new, no two of them write exactly alike. Some
-letters get more worn than others, and some wear only on one
-side. Now, you remark in this note of yours, Mr. Windibank, that
-in every case there is some little slurring over of the 'e,' and
-a slight defect in the tail of the 'r.' There are fourteen other
-characteristics, but those are the more obvious."
-
-"We do all our correspondence with this machine at the office,
-and no doubt it is a little worn," our visitor answered, glancing
-keenly at Holmes with his bright little eyes.
-
-"And now I will show you what is really a very interesting study,
-Mr. Windibank," Holmes continued. "I think of writing another
-little monograph some of these days on the typewriter and its
-relation to crime. It is a subject to which I have devoted some
-little attention. I have here four letters which purport to come
-from the missing man. They are all typewritten. In each case, not
-only are the 'e's' slurred and the 'r's' tailless, but you will
-observe, if you care to use my magnifying lens, that the fourteen
-other characteristics to which I have alluded are there as well."
-
-Mr. Windibank sprang out of his chair and picked up his hat. "I
-cannot waste time over this sort of fantastic talk, Mr. Holmes,"
-he said. "If you can catch the man, catch him, and let me know
-when you have done it."
-
-"Certainly," said Holmes, stepping over and turning the key in
-the door. "I let you know, then, that I have caught him!"
-
-"What! where?" shouted Mr. Windibank, turning white to his lips
-and glancing about him like a rat in a trap.
-
-"Oh, it won't do--really it won't," said Holmes suavely. "There
-is no possible getting out of it, Mr. Windibank. It is quite too
-transparent, and it was a very bad compliment when you said that
-it was impossible for me to solve so simple a question. That's
-right! Sit down and let us talk it over."
-
-Our visitor collapsed into a chair, with a ghastly face and a
-glitter of moisture on his brow. "It--it's not actionable," he
-stammered.
-
-"I am very much afraid that it is not. But between ourselves,
-Windibank, it was as cruel and selfish and heartless a trick in a
-petty way as ever came before me. Now, let me just run over the
-course of events, and you will contradict me if I go wrong."
-
-The man sat huddled up in his chair, with his head sunk upon his
-breast, like one who is utterly crushed. Holmes stuck his feet up
-on the corner of the mantelpiece and, leaning back with his hands
-in his pockets, began talking, rather to himself, as it seemed,
-than to us.
-
-"The man married a woman very much older than himself for her
-money," said he, "and he enjoyed the use of the money of the
-daughter as long as she lived with them. It was a considerable
-sum, for people in their position, and the loss of it would have
-made a serious difference. It was worth an effort to preserve it.
-The daughter was of a good, amiable disposition, but affectionate
-and warm-hearted in her ways, so that it was evident that with
-her fair personal advantages, and her little income, she would
-not be allowed to remain single long. Now her marriage would
-mean, of course, the loss of a hundred a year, so what does her
-stepfather do to prevent it? He takes the obvious course of
-keeping her at home and forbidding her to seek the company of
-people of her own age. But soon he found that that would not
-answer forever. She became restive, insisted upon her rights, and
-finally announced her positive intention of going to a certain
-ball. What does her clever stepfather do then? He conceives an
-idea more creditable to his head than to his heart. With the
-connivance and assistance of his wife he disguised himself,
-covered those keen eyes with tinted glasses, masked the face with
-a moustache and a pair of bushy whiskers, sunk that clear voice
-into an insinuating whisper, and doubly secure on account of the
-girl's short sight, he appears as Mr. Hosmer Angel, and keeps off
-other lovers by making love himself."
-
-"It was only a joke at first," groaned our visitor. "We never
-thought that she would have been so carried away."
-
-"Very likely not. However that may be, the young lady was very
-decidedly carried away, and, having quite made up her mind that
-her stepfather was in France, the suspicion of treachery never
-for an instant entered her mind. She was flattered by the
-gentleman's attentions, and the effect was increased by the
-loudly expressed admiration of her mother. Then Mr. Angel began
-to call, for it was obvious that the matter should be pushed as
-far as it would go if a real effect were to be produced. There
-were meetings, and an engagement, which would finally secure the
-girl's affections from turning towards anyone else. But the
-deception could not be kept up forever. These pretended journeys
-to France were rather cumbrous. The thing to do was clearly to
-bring the business to an end in such a dramatic manner that it
-would leave a permanent impression upon the young lady's mind and
-prevent her from looking upon any other suitor for some time to
-come. Hence those vows of fidelity exacted upon a Testament, and
-hence also the allusions to a possibility of something happening
-on the very morning of the wedding. James Windibank wished Miss
-Sutherland to be so bound to Hosmer Angel, and so uncertain as to
-his fate, that for ten years to come, at any rate, she would not
-listen to another man. As far as the church door he brought her,
-and then, as he could go no farther, he conveniently vanished
-away by the old trick of stepping in at one door of a
-four-wheeler and out at the other. I think that was the chain of
-events, Mr. Windibank!"
-
-Our visitor had recovered something of his assurance while Holmes
-had been talking, and he rose from his chair now with a cold
-sneer upon his pale face.
-
-"It may be so, or it may not, Mr. Holmes," said he, "but if you
-are so very sharp you ought to be sharp enough to know that it is
-you who are breaking the law now, and not me. I have done nothing
-actionable from the first, but as long as you keep that door
-locked you lay yourself open to an action for assault and illegal
-constraint."
-
-"The law cannot, as you say, touch you," said Holmes, unlocking
-and throwing open the door, "yet there never was a man who
-deserved punishment more. If the young lady has a brother or a
-friend, he ought to lay a whip across your shoulders. By Jove!"
-he continued, flushing up at the sight of the bitter sneer upon
-the man's face, "it is not part of my duties to my client, but
-here's a hunting crop handy, and I think I shall just treat
-myself to--" He took two swift steps to the whip, but before he
-could grasp it there was a wild clatter of steps upon the stairs,
-the heavy hall door banged, and from the window we could see Mr.
-James Windibank running at the top of his speed down the road.
-
-"There's a cold-blooded scoundrel!" said Holmes, laughing, as he
-threw himself down into his chair once more. "That fellow will
-rise from crime to crime until he does something very bad, and
-ends on a gallows. The case has, in some respects, been not
-entirely devoid of interest."
-
-"I cannot now entirely see all the steps of your reasoning," I
-remarked.
-
-"Well, of course it was obvious from the first that this Mr.
-Hosmer Angel must have some strong object for his curious
-conduct, and it was equally clear that the only man who really
-profited by the incident, as far as we could see, was the
-stepfather. Then the fact that the two men were never together,
-but that the one always appeared when the other was away, was
-suggestive. So were the tinted spectacles and the curious voice,
-which both hinted at a disguise, as did the bushy whiskers. My
-suspicions were all confirmed by his peculiar action in
-typewriting his signature, which, of course, inferred that his
-handwriting was so familiar to her that she would recognise even
-the smallest sample of it. You see all these isolated facts,
-together with many minor ones, all pointed in the same
-direction."
-
-"And how did you verify them?"
-
-"Having once spotted my man, it was easy to get corroboration. I
-knew the firm for which this man worked. Having taken the printed
-description. I eliminated everything from it which could be the
-result of a disguise--the whiskers, the glasses, the voice, and I
-sent it to the firm, with a request that they would inform me
-whether it answered to the description of any of their
-travellers. I had already noticed the peculiarities of the
-typewriter, and I wrote to the man himself at his business
-address asking him if he would come here. As I expected, his
-reply was typewritten and revealed the same trivial but
-characteristic defects. The same post brought me a letter from
-Westhouse & Marbank, of Fenchurch Street, to say that the
-description tallied in every respect with that of their employé,
-James Windibank. Voilà tout!"
-
-"And Miss Sutherland?"
-
-"If I tell her she will not believe me. You may remember the old
-Persian saying, 'There is danger for him who taketh the tiger
-cub, and danger also for whoso snatches a delusion from a woman.'
-There is as much sense in Hafiz as in Horace, and as much
-knowledge of the world."
-
-
-
-ADVENTURE IV. THE BOSCOMBE VALLEY MYSTERY
-
-We were seated at breakfast one morning, my wife and I, when the
-maid brought in a telegram. It was from Sherlock Holmes and ran
-in this way:
-
-"Have you a couple of days to spare? Have just been wired for from
-the west of England in connection with Boscombe Valley tragedy.
-Shall be glad if you will come with me. Air and scenery perfect.
-Leave Paddington by the 11:15."
-
-"What do you say, dear?" said my wife, looking across at me.
-"Will you go?"
-
-"I really don't know what to say. I have a fairly long list at
-present."
-
-"Oh, Anstruther would do your work for you. You have been looking
-a little pale lately. I think that the change would do you good,
-and you are always so interested in Mr. Sherlock Holmes' cases."
-
-"I should be ungrateful if I were not, seeing what I gained
-through one of them," I answered. "But if I am to go, I must pack
-at once, for I have only half an hour."
-
-My experience of camp life in Afghanistan had at least had the
-effect of making me a prompt and ready traveller. My wants were
-few and simple, so that in less than the time stated I was in a
-cab with my valise, rattling away to Paddington Station. Sherlock
-Holmes was pacing up and down the platform, his tall, gaunt
-figure made even gaunter and taller by his long grey
-travelling-cloak and close-fitting cloth cap.
-
-"It is really very good of you to come, Watson," said he. "It
-makes a considerable difference to me, having someone with me on
-whom I can thoroughly rely. Local aid is always either worthless
-or else biassed. If you will keep the two corner seats I shall
-get the tickets."
-
-We had the carriage to ourselves save for an immense litter of
-papers which Holmes had brought with him. Among these he rummaged
-and read, with intervals of note-taking and of meditation, until
-we were past Reading. Then he suddenly rolled them all into a
-gigantic ball and tossed them up onto the rack.
-
-"Have you heard anything of the case?" he asked.
-
-"Not a word. I have not seen a paper for some days."
-
-"The London press has not had very full accounts. I have just
-been looking through all the recent papers in order to master the
-particulars. It seems, from what I gather, to be one of those
-simple cases which are so extremely difficult."
-
-"That sounds a little paradoxical."
-
-"But it is profoundly true. Singularity is almost invariably a
-clue. The more featureless and commonplace a crime is, the more
-difficult it is to bring it home. In this case, however, they
-have established a very serious case against the son of the
-murdered man."
-
-"It is a murder, then?"
-
-"Well, it is conjectured to be so. I shall take nothing for
-granted until I have the opportunity of looking personally into
-it. I will explain the state of things to you, as far as I have
-been able to understand it, in a very few words.
-
-"Boscombe Valley is a country district not very far from Ross, in
-Herefordshire. The largest landed proprietor in that part is a
-Mr. John Turner, who made his money in Australia and returned
-some years ago to the old country. One of the farms which he
-held, that of Hatherley, was let to Mr. Charles McCarthy, who was
-also an ex-Australian. The men had known each other in the
-colonies, so that it was not unnatural that when they came to
-settle down they should do so as near each other as possible.
-Turner was apparently the richer man, so McCarthy became his
-tenant but still remained, it seems, upon terms of perfect
-equality, as they were frequently together. McCarthy had one son,
-a lad of eighteen, and Turner had an only daughter of the same
-age, but neither of them had wives living. They appear to have
-avoided the society of the neighbouring English families and to
-have led retired lives, though both the McCarthys were fond of
-sport and were frequently seen at the race-meetings of the
-neighbourhood. McCarthy kept two servants--a man and a girl.
-Turner had a considerable household, some half-dozen at the
-least. That is as much as I have been able to gather about the
-families. Now for the facts.
-
-"On June 3rd, that is, on Monday last, McCarthy left his house at
-Hatherley about three in the afternoon and walked down to the
-Boscombe Pool, which is a small lake formed by the spreading out
-of the stream which runs down the Boscombe Valley. He had been
-out with his serving-man in the morning at Ross, and he had told
-the man that he must hurry, as he had an appointment of
-importance to keep at three. From that appointment he never came
-back alive.
-
-"From Hatherley Farm-house to the Boscombe Pool is a quarter of a
-mile, and two people saw him as he passed over this ground. One
-was an old woman, whose name is not mentioned, and the other was
-William Crowder, a game-keeper in the employ of Mr. Turner. Both
-these witnesses depose that Mr. McCarthy was walking alone. The
-game-keeper adds that within a few minutes of his seeing Mr.
-McCarthy pass he had seen his son, Mr. James McCarthy, going the
-same way with a gun under his arm. To the best of his belief, the
-father was actually in sight at the time, and the son was
-following him. He thought no more of the matter until he heard in
-the evening of the tragedy that had occurred.
-
-"The two McCarthys were seen after the time when William Crowder,
-the game-keeper, lost sight of them. The Boscombe Pool is thickly
-wooded round, with just a fringe of grass and of reeds round the
-edge. A girl of fourteen, Patience Moran, who is the daughter of
-the lodge-keeper of the Boscombe Valley estate, was in one of the
-woods picking flowers. She states that while she was there she
-saw, at the border of the wood and close by the lake, Mr.
-McCarthy and his son, and that they appeared to be having a
-violent quarrel. She heard Mr. McCarthy the elder using very
-strong language to his son, and she saw the latter raise up his
-hand as if to strike his father. She was so frightened by their
-violence that she ran away and told her mother when she reached
-home that she had left the two McCarthys quarrelling near
-Boscombe Pool, and that she was afraid that they were going to
-fight. She had hardly said the words when young Mr. McCarthy came
-running up to the lodge to say that he had found his father dead
-in the wood, and to ask for the help of the lodge-keeper. He was
-much excited, without either his gun or his hat, and his right
-hand and sleeve were observed to be stained with fresh blood. On
-following him they found the dead body stretched out upon the
-grass beside the pool. The head had been beaten in by repeated
-blows of some heavy and blunt weapon. The injuries were such as
-might very well have been inflicted by the butt-end of his son's
-gun, which was found lying on the grass within a few paces of the
-body. Under these circumstances the young man was instantly
-arrested, and a verdict of 'wilful murder' having been returned
-at the inquest on Tuesday, he was on Wednesday brought before the
-magistrates at Ross, who have referred the case to the next
-Assizes. Those are the main facts of the case as they came out
-before the coroner and the police-court."
-
-"I could hardly imagine a more damning case," I remarked. "If
-ever circumstantial evidence pointed to a criminal it does so
-here."
-
-"Circumstantial evidence is a very tricky thing," answered Holmes
-thoughtfully. "It may seem to point very straight to one thing,
-but if you shift your own point of view a little, you may find it
-pointing in an equally uncompromising manner to something
-entirely different. It must be confessed, however, that the case
-looks exceedingly grave against the young man, and it is very
-possible that he is indeed the culprit. There are several people
-in the neighbourhood, however, and among them Miss Turner, the
-daughter of the neighbouring landowner, who believe in his
-innocence, and who have retained Lestrade, whom you may recollect
-in connection with the Study in Scarlet, to work out the case in
-his interest. Lestrade, being rather puzzled, has referred the
-case to me, and hence it is that two middle-aged gentlemen are
-flying westward at fifty miles an hour instead of quietly
-digesting their breakfasts at home."
-
-"I am afraid," said I, "that the facts are so obvious that you
-will find little credit to be gained out of this case."
-
-"There is nothing more deceptive than an obvious fact," he
-answered, laughing. "Besides, we may chance to hit upon some
-other obvious facts which may have been by no means obvious to
-Mr. Lestrade. You know me too well to think that I am boasting
-when I say that I shall either confirm or destroy his theory by
-means which he is quite incapable of employing, or even of
-understanding. To take the first example to hand, I very clearly
-perceive that in your bedroom the window is upon the right-hand
-side, and yet I question whether Mr. Lestrade would have noted
-even so self-evident a thing as that."
-
-"How on earth--"
-
-"My dear fellow, I know you well. I know the military neatness
-which characterises you. You shave every morning, and in this
-season you shave by the sunlight; but since your shaving is less
-and less complete as we get farther back on the left side, until
-it becomes positively slovenly as we get round the angle of the
-jaw, it is surely very clear that that side is less illuminated
-than the other. I could not imagine a man of your habits looking
-at himself in an equal light and being satisfied with such a
-result. I only quote this as a trivial example of observation and
-inference. Therein lies my métier, and it is just possible that
-it may be of some service in the investigation which lies before
-us. There are one or two minor points which were brought out in
-the inquest, and which are worth considering."
-
-"What are they?"
-
-"It appears that his arrest did not take place at once, but after
-the return to Hatherley Farm. On the inspector of constabulary
-informing him that he was a prisoner, he remarked that he was not
-surprised to hear it, and that it was no more than his deserts.
-This observation of his had the natural effect of removing any
-traces of doubt which might have remained in the minds of the
-coroner's jury."
-
-"It was a confession," I ejaculated.
-
-"No, for it was followed by a protestation of innocence."
-
-"Coming on the top of such a damning series of events, it was at
-least a most suspicious remark."
-
-"On the contrary," said Holmes, "it is the brightest rift which I
-can at present see in the clouds. However innocent he might be,
-he could not be such an absolute imbecile as not to see that the
-circumstances were very black against him. Had he appeared
-surprised at his own arrest, or feigned indignation at it, I
-should have looked upon it as highly suspicious, because such
-surprise or anger would not be natural under the circumstances,
-and yet might appear to be the best policy to a scheming man. His
-frank acceptance of the situation marks him as either an innocent
-man, or else as a man of considerable self-restraint and
-firmness. As to his remark about his deserts, it was also not
-unnatural if you consider that he stood beside the dead body of
-his father, and that there is no doubt that he had that very day
-so far forgotten his filial duty as to bandy words with him, and
-even, according to the little girl whose evidence is so
-important, to raise his hand as if to strike him. The
-self-reproach and contrition which are displayed in his remark
-appear to me to be the signs of a healthy mind rather than of a
-guilty one."
-
-I shook my head. "Many men have been hanged on far slighter
-evidence," I remarked.
-
-"So they have. And many men have been wrongfully hanged."
-
-"What is the young man's own account of the matter?"
-
-"It is, I am afraid, not very encouraging to his supporters,
-though there are one or two points in it which are suggestive.
-You will find it here, and may read it for yourself."
-
-He picked out from his bundle a copy of the local Herefordshire
-paper, and having turned down the sheet he pointed out the
-paragraph in which the unfortunate young man had given his own
-statement of what had occurred. I settled myself down in the
-corner of the carriage and read it very carefully. It ran in this
-way:
-
-"Mr. James McCarthy, the only son of the deceased, was then called
-and gave evidence as follows: 'I had been away from home for
-three days at Bristol, and had only just returned upon the
-morning of last Monday, the 3rd. My father was absent from home at
-the time of my arrival, and I was informed by the maid that he
-had driven over to Ross with John Cobb, the groom. Shortly after
-my return I heard the wheels of his trap in the yard, and,
-looking out of my window, I saw him get out and walk rapidly out
-of the yard, though I was not aware in which direction he was
-going. I then took my gun and strolled out in the direction of
-the Boscombe Pool, with the intention of visiting the rabbit
-warren which is upon the other side. On my way I saw William
-Crowder, the game-keeper, as he had stated in his evidence; but
-he is mistaken in thinking that I was following my father. I had
-no idea that he was in front of me. When about a hundred yards
-from the pool I heard a cry of "Cooee!" which was a usual signal
-between my father and myself. I then hurried forward, and found
-him standing by the pool. He appeared to be much surprised at
-seeing me and asked me rather roughly what I was doing there. A
-conversation ensued which led to high words and almost to blows,
-for my father was a man of a very violent temper. Seeing that his
-passion was becoming ungovernable, I left him and returned
-towards Hatherley Farm. I had not gone more than 150 yards,
-however, when I heard a hideous outcry behind me, which caused me
-to run back again. I found my father expiring upon the ground,
-with his head terribly injured. I dropped my gun and held him in
-my arms, but he almost instantly expired. I knelt beside him for
-some minutes, and then made my way to Mr. Turner's lodge-keeper,
-his house being the nearest, to ask for assistance. I saw no one
-near my father when I returned, and I have no idea how he came by
-his injuries. He was not a popular man, being somewhat cold and
-forbidding in his manners, but he had, as far as I know, no
-active enemies. I know nothing further of the matter.'
-
-"The Coroner: Did your father make any statement to you before
-he died?
-
-"Witness: He mumbled a few words, but I could only catch some
-allusion to a rat.
-
-"The Coroner: What did you understand by that?
-
-"Witness: It conveyed no meaning to me. I thought that he was
-delirious.
-
-"The Coroner: What was the point upon which you and your father
-had this final quarrel?
-
-"Witness: I should prefer not to answer.
-
-"The Coroner: I am afraid that I must press it.
-
-"Witness: It is really impossible for me to tell you. I can
-assure you that it has nothing to do with the sad tragedy which
-followed.
-
-"The Coroner: That is for the court to decide. I need not point
-out to you that your refusal to answer will prejudice your case
-considerably in any future proceedings which may arise.
-
-"Witness: I must still refuse.
-
-"The Coroner: I understand that the cry of 'Cooee' was a common
-signal between you and your father?
-
-"Witness: It was.
-
-"The Coroner: How was it, then, that he uttered it before he saw
-you, and before he even knew that you had returned from Bristol?
-
-"Witness (with considerable confusion): I do not know.
-
-"A Juryman: Did you see nothing which aroused your suspicions
-when you returned on hearing the cry and found your father
-fatally injured?
-
-"Witness: Nothing definite.
-
-"The Coroner: What do you mean?
-
-"Witness: I was so disturbed and excited as I rushed out into
-the open, that I could think of nothing except of my father. Yet
-I have a vague impression that as I ran forward something lay
-upon the ground to the left of me. It seemed to me to be
-something grey in colour, a coat of some sort, or a plaid perhaps.
-When I rose from my father I looked round for it, but it was
-gone.
-
-"'Do you mean that it disappeared before you went for help?'
-
-"'Yes, it was gone.'
-
-"'You cannot say what it was?'
-
-"'No, I had a feeling something was there.'
-
-"'How far from the body?'
-
-"'A dozen yards or so.'
-
-"'And how far from the edge of the wood?'
-
-"'About the same.'
-
-"'Then if it was removed it was while you were within a dozen
-yards of it?'
-
-"'Yes, but with my back towards it.'
-
-"This concluded the examination of the witness."
-
-"I see," said I as I glanced down the column, "that the coroner
-in his concluding remarks was rather severe upon young McCarthy.
-He calls attention, and with reason, to the discrepancy about his
-father having signalled to him before seeing him, also to his
-refusal to give details of his conversation with his father, and
-his singular account of his father's dying words. They are all,
-as he remarks, very much against the son."
-
-Holmes laughed softly to himself and stretched himself out upon
-the cushioned seat. "Both you and the coroner have been at some
-pains," said he, "to single out the very strongest points in the
-young man's favour. Don't you see that you alternately give him
-credit for having too much imagination and too little? Too
-little, if he could not invent a cause of quarrel which would
-give him the sympathy of the jury; too much, if he evolved from
-his own inner consciousness anything so outré as a dying
-reference to a rat, and the incident of the vanishing cloth. No,
-sir, I shall approach this case from the point of view that what
-this young man says is true, and we shall see whither that
-hypothesis will lead us. And now here is my pocket Petrarch, and
-not another word shall I say of this case until we are on the
-scene of action. We lunch at Swindon, and I see that we shall be
-there in twenty minutes."
-
-It was nearly four o'clock when we at last, after passing through
-the beautiful Stroud Valley, and over the broad gleaming Severn,
-found ourselves at the pretty little country-town of Ross. A
-lean, ferret-like man, furtive and sly-looking, was waiting for
-us upon the platform. In spite of the light brown dustcoat and
-leather-leggings which he wore in deference to his rustic
-surroundings, I had no difficulty in recognising Lestrade, of
-Scotland Yard. With him we drove to the Hereford Arms where a
-room had already been engaged for us.
-
-"I have ordered a carriage," said Lestrade as we sat over a cup
-of tea. "I knew your energetic nature, and that you would not be
-happy until you had been on the scene of the crime."
-
-"It was very nice and complimentary of you," Holmes answered. "It
-is entirely a question of barometric pressure."
-
-Lestrade looked startled. "I do not quite follow," he said.
-
-"How is the glass? Twenty-nine, I see. No wind, and not a cloud
-in the sky. I have a caseful of cigarettes here which need
-smoking, and the sofa is very much superior to the usual country
-hotel abomination. I do not think that it is probable that I
-shall use the carriage to-night."
-
-Lestrade laughed indulgently. "You have, no doubt, already formed
-your conclusions from the newspapers," he said. "The case is as
-plain as a pikestaff, and the more one goes into it the plainer
-it becomes. Still, of course, one can't refuse a lady, and such a
-very positive one, too. She has heard of you, and would have your
-opinion, though I repeatedly told her that there was nothing
-which you could do which I had not already done. Why, bless my
-soul! here is her carriage at the door."
-
-He had hardly spoken before there rushed into the room one of the
-most lovely young women that I have ever seen in my life. Her
-violet eyes shining, her lips parted, a pink flush upon her
-cheeks, all thought of her natural reserve lost in her
-overpowering excitement and concern.
-
-"Oh, Mr. Sherlock Holmes!" she cried, glancing from one to the
-other of us, and finally, with a woman's quick intuition,
-fastening upon my companion, "I am so glad that you have come. I
-have driven down to tell you so. I know that James didn't do it.
-I know it, and I want you to start upon your work knowing it,
-too. Never let yourself doubt upon that point. We have known each
-other since we were little children, and I know his faults as no
-one else does; but he is too tender-hearted to hurt a fly. Such a
-charge is absurd to anyone who really knows him."
-
-"I hope we may clear him, Miss Turner," said Sherlock Holmes.
-"You may rely upon my doing all that I can."
-
-"But you have read the evidence. You have formed some conclusion?
-Do you not see some loophole, some flaw? Do you not yourself
-think that he is innocent?"
-
-"I think that it is very probable."
-
-"There, now!" she cried, throwing back her head and looking
-defiantly at Lestrade. "You hear! He gives me hopes."
-
-Lestrade shrugged his shoulders. "I am afraid that my colleague
-has been a little quick in forming his conclusions," he said.
-
-"But he is right. Oh! I know that he is right. James never did
-it. And about his quarrel with his father, I am sure that the
-reason why he would not speak about it to the coroner was because
-I was concerned in it."
-
-"In what way?" asked Holmes.
-
-"It is no time for me to hide anything. James and his father had
-many disagreements about me. Mr. McCarthy was very anxious that
-there should be a marriage between us. James and I have always
-loved each other as brother and sister; but of course he is young
-and has seen very little of life yet, and--and--well, he
-naturally did not wish to do anything like that yet. So there
-were quarrels, and this, I am sure, was one of them."
-
-"And your father?" asked Holmes. "Was he in favour of such a
-union?"
-
-"No, he was averse to it also. No one but Mr. McCarthy was in
-favour of it." A quick blush passed over her fresh young face as
-Holmes shot one of his keen, questioning glances at her.
-
-"Thank you for this information," said he. "May I see your father
-if I call to-morrow?"
-
-"I am afraid the doctor won't allow it."
-
-"The doctor?"
-
-"Yes, have you not heard? Poor father has never been strong for
-years back, but this has broken him down completely. He has taken
-to his bed, and Dr. Willows says that he is a wreck and that his
-nervous system is shattered. Mr. McCarthy was the only man alive
-who had known dad in the old days in Victoria."
-
-"Ha! In Victoria! That is important."
-
-"Yes, at the mines."
-
-"Quite so; at the gold-mines, where, as I understand, Mr. Turner
-made his money."
-
-"Yes, certainly."
-
-"Thank you, Miss Turner. You have been of material assistance to
-me."
-
-"You will tell me if you have any news to-morrow. No doubt you
-will go to the prison to see James. Oh, if you do, Mr. Holmes, do
-tell him that I know him to be innocent."
-
-"I will, Miss Turner."
-
-"I must go home now, for dad is very ill, and he misses me so if
-I leave him. Good-bye, and God help you in your undertaking." She
-hurried from the room as impulsively as she had entered, and we
-heard the wheels of her carriage rattle off down the street.
-
-"I am ashamed of you, Holmes," said Lestrade with dignity after a
-few minutes' silence. "Why should you raise up hopes which you
-are bound to disappoint? I am not over-tender of heart, but I
-call it cruel."
-
-"I think that I see my way to clearing James McCarthy," said
-Holmes. "Have you an order to see him in prison?"
-
-"Yes, but only for you and me."
-
-"Then I shall reconsider my resolution about going out. We have
-still time to take a train to Hereford and see him to-night?"
-
-"Ample."
-
-"Then let us do so. Watson, I fear that you will find it very
-slow, but I shall only be away a couple of hours."
-
-I walked down to the station with them, and then wandered through
-the streets of the little town, finally returning to the hotel,
-where I lay upon the sofa and tried to interest myself in a
-yellow-backed novel. The puny plot of the story was so thin,
-however, when compared to the deep mystery through which we were
-groping, and I found my attention wander so continually from the
-action to the fact, that I at last flung it across the room and
-gave myself up entirely to a consideration of the events of the
-day. Supposing that this unhappy young man's story were
-absolutely true, then what hellish thing, what absolutely
-unforeseen and extraordinary calamity could have occurred between
-the time when he parted from his father, and the moment when,
-drawn back by his screams, he rushed into the glade? It was
-something terrible and deadly. What could it be? Might not the
-nature of the injuries reveal something to my medical instincts?
-I rang the bell and called for the weekly county paper, which
-contained a verbatim account of the inquest. In the surgeon's
-deposition it was stated that the posterior third of the left
-parietal bone and the left half of the occipital bone had been
-shattered by a heavy blow from a blunt weapon. I marked the spot
-upon my own head. Clearly such a blow must have been struck from
-behind. That was to some extent in favour of the accused, as when
-seen quarrelling he was face to face with his father. Still, it
-did not go for very much, for the older man might have turned his
-back before the blow fell. Still, it might be worth while to call
-Holmes' attention to it. Then there was the peculiar dying
-reference to a rat. What could that mean? It could not be
-delirium. A man dying from a sudden blow does not commonly become
-delirious. No, it was more likely to be an attempt to explain how
-he met his fate. But what could it indicate? I cudgelled my
-brains to find some possible explanation. And then the incident
-of the grey cloth seen by young McCarthy. If that were true the
-murderer must have dropped some part of his dress, presumably his
-overcoat, in his flight, and must have had the hardihood to
-return and to carry it away at the instant when the son was
-kneeling with his back turned not a dozen paces off. What a
-tissue of mysteries and improbabilities the whole thing was! I
-did not wonder at Lestrade's opinion, and yet I had so much faith
-in Sherlock Holmes' insight that I could not lose hope as long
-as every fresh fact seemed to strengthen his conviction of young
-McCarthy's innocence.
-
-It was late before Sherlock Holmes returned. He came back alone,
-for Lestrade was staying in lodgings in the town.
-
-"The glass still keeps very high," he remarked as he sat down.
-"It is of importance that it should not rain before we are able
-to go over the ground. On the other hand, a man should be at his
-very best and keenest for such nice work as that, and I did not
-wish to do it when fagged by a long journey. I have seen young
-McCarthy."
-
-"And what did you learn from him?"
-
-"Nothing."
-
-"Could he throw no light?"
-
-"None at all. I was inclined to think at one time that he knew
-who had done it and was screening him or her, but I am convinced
-now that he is as puzzled as everyone else. He is not a very
-quick-witted youth, though comely to look at and, I should think,
-sound at heart."
-
-"I cannot admire his taste," I remarked, "if it is indeed a fact
-that he was averse to a marriage with so charming a young lady as
-this Miss Turner."
-
-"Ah, thereby hangs a rather painful tale. This fellow is madly,
-insanely, in love with her, but some two years ago, when he was
-only a lad, and before he really knew her, for she had been away
-five years at a boarding-school, what does the idiot do but get
-into the clutches of a barmaid in Bristol and marry her at a
-registry office? No one knows a word of the matter, but you can
-imagine how maddening it must be to him to be upbraided for not
-doing what he would give his very eyes to do, but what he knows
-to be absolutely impossible. It was sheer frenzy of this sort
-which made him throw his hands up into the air when his father,
-at their last interview, was goading him on to propose to Miss
-Turner. On the other hand, he had no means of supporting himself,
-and his father, who was by all accounts a very hard man, would
-have thrown him over utterly had he known the truth. It was with
-his barmaid wife that he had spent the last three days in
-Bristol, and his father did not know where he was. Mark that
-point. It is of importance. Good has come out of evil, however,
-for the barmaid, finding from the papers that he is in serious
-trouble and likely to be hanged, has thrown him over utterly and
-has written to him to say that she has a husband already in the
-Bermuda Dockyard, so that there is really no tie between them. I
-think that that bit of news has consoled young McCarthy for all
-that he has suffered."
-
-"But if he is innocent, who has done it?"
-
-"Ah! who? I would call your attention very particularly to two
-points. One is that the murdered man had an appointment with
-someone at the pool, and that the someone could not have been his
-son, for his son was away, and he did not know when he would
-return. The second is that the murdered man was heard to cry
-'Cooee!' before he knew that his son had returned. Those are the
-crucial points upon which the case depends. And now let us talk
-about George Meredith, if you please, and we shall leave all
-minor matters until to-morrow."
-
-There was no rain, as Holmes had foretold, and the morning broke
-bright and cloudless. At nine o'clock Lestrade called for us with
-the carriage, and we set off for Hatherley Farm and the Boscombe
-Pool.
-
-"There is serious news this morning," Lestrade observed. "It is
-said that Mr. Turner, of the Hall, is so ill that his life is
-despaired of."
-
-"An elderly man, I presume?" said Holmes.
-
-"About sixty; but his constitution has been shattered by his life
-abroad, and he has been in failing health for some time. This
-business has had a very bad effect upon him. He was an old friend
-of McCarthy's, and, I may add, a great benefactor to him, for I
-have learned that he gave him Hatherley Farm rent free."
-
-"Indeed! That is interesting," said Holmes.
-
-"Oh, yes! In a hundred other ways he has helped him. Everybody
-about here speaks of his kindness to him."
-
-"Really! Does it not strike you as a little singular that this
-McCarthy, who appears to have had little of his own, and to have
-been under such obligations to Turner, should still talk of
-marrying his son to Turner's daughter, who is, presumably,
-heiress to the estate, and that in such a very cocksure manner,
-as if it were merely a case of a proposal and all else would
-follow? It is the more strange, since we know that Turner himself
-was averse to the idea. The daughter told us as much. Do you not
-deduce something from that?"
-
-"We have got to the deductions and the inferences," said
-Lestrade, winking at me. "I find it hard enough to tackle facts,
-Holmes, without flying away after theories and fancies."
-
-"You are right," said Holmes demurely; "you do find it very hard
-to tackle the facts."
-
-"Anyhow, I have grasped one fact which you seem to find it
-difficult to get hold of," replied Lestrade with some warmth.
-
-"And that is--"
-
-"That McCarthy senior met his death from McCarthy junior and that
-all theories to the contrary are the merest moonshine."
-
-"Well, moonshine is a brighter thing than fog," said Holmes,
-laughing. "But I am very much mistaken if this is not Hatherley
-Farm upon the left."
-
-"Yes, that is it." It was a widespread, comfortable-looking
-building, two-storied, slate-roofed, with great yellow blotches
-of lichen upon the grey walls. The drawn blinds and the smokeless
-chimneys, however, gave it a stricken look, as though the weight
-of this horror still lay heavy upon it. We called at the door,
-when the maid, at Holmes' request, showed us the boots which her
-master wore at the time of his death, and also a pair of the
-son's, though not the pair which he had then had. Having measured
-these very carefully from seven or eight different points, Holmes
-desired to be led to the court-yard, from which we all followed
-the winding track which led to Boscombe Pool.
-
-Sherlock Holmes was transformed when he was hot upon such a scent
-as this. Men who had only known the quiet thinker and logician of
-Baker Street would have failed to recognise him. His face flushed
-and darkened. His brows were drawn into two hard black lines,
-while his eyes shone out from beneath them with a steely glitter.
-His face was bent downward, his shoulders bowed, his lips
-compressed, and the veins stood out like whipcord in his long,
-sinewy neck. His nostrils seemed to dilate with a purely animal
-lust for the chase, and his mind was so absolutely concentrated
-upon the matter before him that a question or remark fell
-unheeded upon his ears, or, at the most, only provoked a quick,
-impatient snarl in reply. Swiftly and silently he made his way
-along the track which ran through the meadows, and so by way of
-the woods to the Boscombe Pool. It was damp, marshy ground, as is
-all that district, and there were marks of many feet, both upon
-the path and amid the short grass which bounded it on either
-side. Sometimes Holmes would hurry on, sometimes stop dead, and
-once he made quite a little detour into the meadow. Lestrade and
-I walked behind him, the detective indifferent and contemptuous,
-while I watched my friend with the interest which sprang from the
-conviction that every one of his actions was directed towards a
-definite end.
-
-The Boscombe Pool, which is a little reed-girt sheet of water
-some fifty yards across, is situated at the boundary between the
-Hatherley Farm and the private park of the wealthy Mr. Turner.
-Above the woods which lined it upon the farther side we could see
-the red, jutting pinnacles which marked the site of the rich
-landowner's dwelling. On the Hatherley side of the pool the woods
-grew very thick, and there was a narrow belt of sodden grass
-twenty paces across between the edge of the trees and the reeds
-which lined the lake. Lestrade showed us the exact spot at which
-the body had been found, and, indeed, so moist was the ground,
-that I could plainly see the traces which had been left by the
-fall of the stricken man. To Holmes, as I could see by his eager
-face and peering eyes, very many other things were to be read
-upon the trampled grass. He ran round, like a dog who is picking
-up a scent, and then turned upon my companion.
-
-"What did you go into the pool for?" he asked.
-
-"I fished about with a rake. I thought there might be some weapon
-or other trace. But how on earth--"
-
-"Oh, tut, tut! I have no time! That left foot of yours with its
-inward twist is all over the place. A mole could trace it, and
-there it vanishes among the reeds. Oh, how simple it would all
-have been had I been here before they came like a herd of buffalo
-and wallowed all over it. Here is where the party with the
-lodge-keeper came, and they have covered all tracks for six or
-eight feet round the body. But here are three separate tracks of
-the same feet." He drew out a lens and lay down upon his
-waterproof to have a better view, talking all the time rather to
-himself than to us. "These are young McCarthy's feet. Twice he
-was walking, and once he ran swiftly, so that the soles are
-deeply marked and the heels hardly visible. That bears out his
-story. He ran when he saw his father on the ground. Then here are
-the father's feet as he paced up and down. What is this, then? It
-is the butt-end of the gun as the son stood listening. And this?
-Ha, ha! What have we here? Tiptoes! tiptoes! Square, too, quite
-unusual boots! They come, they go, they come again--of course
-that was for the cloak. Now where did they come from?" He ran up
-and down, sometimes losing, sometimes finding the track until we
-were well within the edge of the wood and under the shadow of a
-great beech, the largest tree in the neighbourhood. Holmes traced
-his way to the farther side of this and lay down once more upon
-his face with a little cry of satisfaction. For a long time he
-remained there, turning over the leaves and dried sticks,
-gathering up what seemed to me to be dust into an envelope and
-examining with his lens not only the ground but even the bark of
-the tree as far as he could reach. A jagged stone was lying among
-the moss, and this also he carefully examined and retained. Then
-he followed a pathway through the wood until he came to the
-highroad, where all traces were lost.
-
-"It has been a case of considerable interest," he remarked,
-returning to his natural manner. "I fancy that this grey house on
-the right must be the lodge. I think that I will go in and have a
-word with Moran, and perhaps write a little note. Having done
-that, we may drive back to our luncheon. You may walk to the cab,
-and I shall be with you presently."
-
-It was about ten minutes before we regained our cab and drove
-back into Ross, Holmes still carrying with him the stone which he
-had picked up in the wood.
-
-"This may interest you, Lestrade," he remarked, holding it out.
-"The murder was done with it."
-
-"I see no marks."
-
-"There are none."
-
-"How do you know, then?"
-
-"The grass was growing under it. It had only lain there a few
-days. There was no sign of a place whence it had been taken. It
-corresponds with the injuries. There is no sign of any other
-weapon."
-
-"And the murderer?"
-
-"Is a tall man, left-handed, limps with the right leg, wears
-thick-soled shooting-boots and a grey cloak, smokes Indian
-cigars, uses a cigar-holder, and carries a blunt pen-knife in his
-pocket. There are several other indications, but these may be
-enough to aid us in our search."
-
-Lestrade laughed. "I am afraid that I am still a sceptic," he
-said. "Theories are all very well, but we have to deal with a
-hard-headed British jury."
-
-"Nous verrons," answered Holmes calmly. "You work your own
-method, and I shall work mine. I shall be busy this afternoon,
-and shall probably return to London by the evening train."
-
-"And leave your case unfinished?"
-
-"No, finished."
-
-"But the mystery?"
-
-"It is solved."
-
-"Who was the criminal, then?"
-
-"The gentleman I describe."
-
-"But who is he?"
-
-"Surely it would not be difficult to find out. This is not such a
-populous neighbourhood."
-
-Lestrade shrugged his shoulders. "I am a practical man," he said,
-"and I really cannot undertake to go about the country looking
-for a left-handed gentleman with a game leg. I should become the
-laughing-stock of Scotland Yard."
-
-"All right," said Holmes quietly. "I have given you the chance.
-Here are your lodgings. Good-bye. I shall drop you a line before
-I leave."
-
-Having left Lestrade at his rooms, we drove to our hotel, where
-we found lunch upon the table. Holmes was silent and buried in
-thought with a pained expression upon his face, as one who finds
-himself in a perplexing position.
-
-"Look here, Watson," he said when the cloth was cleared "just sit
-down in this chair and let me preach to you for a little. I don't
-know quite what to do, and I should value your advice. Light a
-cigar and let me expound."
-
- "Pray do so."
-
-"Well, now, in considering this case there are two points about
-young McCarthy's narrative which struck us both instantly,
-although they impressed me in his favour and you against him. One
-was the fact that his father should, according to his account,
-cry 'Cooee!' before seeing him. The other was his singular dying
-reference to a rat. He mumbled several words, you understand, but
-that was all that caught the son's ear. Now from this double
-point our research must commence, and we will begin it by
-presuming that what the lad says is absolutely true."
-
-"What of this 'Cooee!' then?"
-
-"Well, obviously it could not have been meant for the son. The
-son, as far as he knew, was in Bristol. It was mere chance that
-he was within earshot. The 'Cooee!' was meant to attract the
-attention of whoever it was that he had the appointment with. But
-'Cooee' is a distinctly Australian cry, and one which is used
-between Australians. There is a strong presumption that the
-person whom McCarthy expected to meet him at Boscombe Pool was
-someone who had been in Australia."
-
-"What of the rat, then?"
-
-Sherlock Holmes took a folded paper from his pocket and flattened
-it out on the table. "This is a map of the Colony of Victoria,"
-he said. "I wired to Bristol for it last night." He put his hand
-over part of the map. "What do you read?"
-
-"ARAT," I read.
-
-"And now?" He raised his hand.
-
-"BALLARAT."
-
-"Quite so. That was the word the man uttered, and of which his
-son only caught the last two syllables. He was trying to utter
-the name of his murderer. So and so, of Ballarat."
-
-"It is wonderful!" I exclaimed.
-
-"It is obvious. And now, you see, I had narrowed the field down
-considerably. The possession of a grey garment was a third point
-which, granting the son's statement to be correct, was a
-certainty. We have come now out of mere vagueness to the definite
-conception of an Australian from Ballarat with a grey cloak."
-
-"Certainly."
-
-"And one who was at home in the district, for the pool can only
-be approached by the farm or by the estate, where strangers could
-hardly wander."
-
-"Quite so."
-
-"Then comes our expedition of to-day. By an examination of the
-ground I gained the trifling details which I gave to that
-imbecile Lestrade, as to the personality of the criminal."
-
-"But how did you gain them?"
-
-"You know my method. It is founded upon the observation of
-trifles."
-
-"His height I know that you might roughly judge from the length
-of his stride. His boots, too, might be told from their traces."
-
-"Yes, they were peculiar boots."
-
-"But his lameness?"
-
-"The impression of his right foot was always less distinct than
-his left. He put less weight upon it. Why? Because he limped--he
-was lame."
-
-"But his left-handedness."
-
-"You were yourself struck by the nature of the injury as recorded
-by the surgeon at the inquest. The blow was struck from
-immediately behind, and yet was upon the left side. Now, how can
-that be unless it were by a left-handed man? He had stood behind
-that tree during the interview between the father and son. He had
-even smoked there. I found the ash of a cigar, which my special
-knowledge of tobacco ashes enables me to pronounce as an Indian
-cigar. I have, as you know, devoted some attention to this, and
-written a little monograph on the ashes of 140 different
-varieties of pipe, cigar, and cigarette tobacco. Having found the
-ash, I then looked round and discovered the stump among the moss
-where he had tossed it. It was an Indian cigar, of the variety
-which are rolled in Rotterdam."
-
-"And the cigar-holder?"
-
-"I could see that the end had not been in his mouth. Therefore he
-used a holder. The tip had been cut off, not bitten off, but the
-cut was not a clean one, so I deduced a blunt pen-knife."
-
-"Holmes," I said, "you have drawn a net round this man from which
-he cannot escape, and you have saved an innocent human life as
-truly as if you had cut the cord which was hanging him. I see the
-direction in which all this points. The culprit is--"
-
-"Mr. John Turner," cried the hotel waiter, opening the door of
-our sitting-room, and ushering in a visitor.
-
-The man who entered was a strange and impressive figure. His
-slow, limping step and bowed shoulders gave the appearance of
-decrepitude, and yet his hard, deep-lined, craggy features, and
-his enormous limbs showed that he was possessed of unusual
-strength of body and of character. His tangled beard, grizzled
-hair, and outstanding, drooping eyebrows combined to give an air
-of dignity and power to his appearance, but his face was of an
-ashen white, while his lips and the corners of his nostrils were
-tinged with a shade of blue. It was clear to me at a glance that
-he was in the grip of some deadly and chronic disease.
-
-"Pray sit down on the sofa," said Holmes gently. "You had my
-note?"
-
-"Yes, the lodge-keeper brought it up. You said that you wished to
-see me here to avoid scandal."
-
-"I thought people would talk if I went to the Hall."
-
-"And why did you wish to see me?" He looked across at my
-companion with despair in his weary eyes, as though his question
-was already answered.
-
-"Yes," said Holmes, answering the look rather than the words. "It
-is so. I know all about McCarthy."
-
-The old man sank his face in his hands. "God help me!" he cried.
-"But I would not have let the young man come to harm. I give you
-my word that I would have spoken out if it went against him at
-the Assizes."
-
-"I am glad to hear you say so," said Holmes gravely.
-
-"I would have spoken now had it not been for my dear girl. It
-would break her heart--it will break her heart when she hears
-that I am arrested."
-
-"It may not come to that," said Holmes.
-
-"What?"
-
-"I am no official agent. I understand that it was your daughter
-who required my presence here, and I am acting in her interests.
-Young McCarthy must be got off, however."
-
-"I am a dying man," said old Turner. "I have had diabetes for
-years. My doctor says it is a question whether I shall live a
-month. Yet I would rather die under my own roof than in a gaol."
-
-Holmes rose and sat down at the table with his pen in his hand
-and a bundle of paper before him. "Just tell us the truth," he
-said. "I shall jot down the facts. You will sign it, and Watson
-here can witness it. Then I could produce your confession at the
-last extremity to save young McCarthy. I promise you that I shall
-not use it unless it is absolutely needed."
-
-"It's as well," said the old man; "it's a question whether I
-shall live to the Assizes, so it matters little to me, but I
-should wish to spare Alice the shock. And now I will make the
-thing clear to you; it has been a long time in the acting, but
-will not take me long to tell.
-
-"You didn't know this dead man, McCarthy. He was a devil
-incarnate. I tell you that. God keep you out of the clutches of
-such a man as he. His grip has been upon me these twenty years,
-and he has blasted my life. I'll tell you first how I came to be
-in his power.
-
-"It was in the early '60's at the diggings. I was a young chap
-then, hot-blooded and reckless, ready to turn my hand at
-anything; I got among bad companions, took to drink, had no luck
-with my claim, took to the bush, and in a word became what you
-would call over here a highway robber. There were six of us, and
-we had a wild, free life of it, sticking up a station from time
-to time, or stopping the wagons on the road to the diggings.
-Black Jack of Ballarat was the name I went under, and our party
-is still remembered in the colony as the Ballarat Gang.
-
-"One day a gold convoy came down from Ballarat to Melbourne, and
-we lay in wait for it and attacked it. There were six troopers
-and six of us, so it was a close thing, but we emptied four of
-their saddles at the first volley. Three of our boys were killed,
-however, before we got the swag. I put my pistol to the head of
-the wagon-driver, who was this very man McCarthy. I wish to the
-Lord that I had shot him then, but I spared him, though I saw his
-wicked little eyes fixed on my face, as though to remember every
-feature. We got away with the gold, became wealthy men, and made
-our way over to England without being suspected. There I parted
-from my old pals and determined to settle down to a quiet and
-respectable life. I bought this estate, which chanced to be in
-the market, and I set myself to do a little good with my money,
-to make up for the way in which I had earned it. I married, too,
-and though my wife died young she left me my dear little Alice.
-Even when she was just a baby her wee hand seemed to lead me down
-the right path as nothing else had ever done. In a word, I turned
-over a new leaf and did my best to make up for the past. All was
-going well when McCarthy laid his grip upon me.
-
-"I had gone up to town about an investment, and I met him in
-Regent Street with hardly a coat to his back or a boot to his
-foot.
-
-"'Here we are, Jack,' says he, touching me on the arm; 'we'll be
-as good as a family to you. There's two of us, me and my son, and
-you can have the keeping of us. If you don't--it's a fine,
-law-abiding country is England, and there's always a policeman
-within hail.'
-
-"Well, down they came to the west country, there was no shaking
-them off, and there they have lived rent free on my best land
-ever since. There was no rest for me, no peace, no forgetfulness;
-turn where I would, there was his cunning, grinning face at my
-elbow. It grew worse as Alice grew up, for he soon saw I was more
-afraid of her knowing my past than of the police. Whatever he
-wanted he must have, and whatever it was I gave him without
-question, land, money, houses, until at last he asked a thing
-which I could not give. He asked for Alice.
-
-"His son, you see, had grown up, and so had my girl, and as I was
-known to be in weak health, it seemed a fine stroke to him that
-his lad should step into the whole property. But there I was
-firm. I would not have his cursed stock mixed with mine; not that
-I had any dislike to the lad, but his blood was in him, and that
-was enough. I stood firm. McCarthy threatened. I braved him to do
-his worst. We were to meet at the pool midway between our houses
-to talk it over.
-
-"When I went down there I found him talking with his son, so I
-smoked a cigar and waited behind a tree until he should be alone.
-But as I listened to his talk all that was black and bitter in
-me seemed to come uppermost. He was urging his son to marry my
-daughter with as little regard for what she might think as if she
-were a slut from off the streets. It drove me mad to think that I
-and all that I held most dear should be in the power of such a
-man as this. Could I not snap the bond? I was already a dying and
-a desperate man. Though clear of mind and fairly strong of limb,
-I knew that my own fate was sealed. But my memory and my girl!
-Both could be saved if I could but silence that foul tongue. I
-did it, Mr. Holmes. I would do it again. Deeply as I have sinned,
-I have led a life of martyrdom to atone for it. But that my girl
-should be entangled in the same meshes which held me was more
-than I could suffer. I struck him down with no more compunction
-than if he had been some foul and venomous beast. His cry brought
-back his son; but I had gained the cover of the wood, though I
-was forced to go back to fetch the cloak which I had dropped in
-my flight. That is the true story, gentlemen, of all that
-occurred."
-
-"Well, it is not for me to judge you," said Holmes as the old man
-signed the statement which had been drawn out. "I pray that we
-may never be exposed to such a temptation."
-
-"I pray not, sir. And what do you intend to do?"
-
-"In view of your health, nothing. You are yourself aware that you
-will soon have to answer for your deed at a higher court than the
-Assizes. I will keep your confession, and if McCarthy is
-condemned I shall be forced to use it. If not, it shall never be
-seen by mortal eye; and your secret, whether you be alive or
-dead, shall be safe with us."
-
-"Farewell, then," said the old man solemnly. "Your own deathbeds,
-when they come, will be the easier for the thought of the peace
-which you have given to mine." Tottering and shaking in all his
-giant frame, he stumbled slowly from the room.
-
-"God help us!" said Holmes after a long silence. "Why does fate
-play such tricks with poor, helpless worms? I never hear of such
-a case as this that I do not think of Baxter's words, and say,
-'There, but for the grace of God, goes Sherlock Holmes.'"
-
-James McCarthy was acquitted at the Assizes on the strength of a
-number of objections which had been drawn out by Holmes and
-submitted to the defending counsel. Old Turner lived for seven
-months after our interview, but he is now dead; and there is
-every prospect that the son and daughter may come to live happily
-together in ignorance of the black cloud which rests upon their
-past.
-
-
-
-ADVENTURE V. THE FIVE ORANGE PIPS
-
-When I glance over my notes and records of the Sherlock Holmes
-cases between the years '82 and '90, I am faced by so many which
-present strange and interesting features that it is no easy
-matter to know which to choose and which to leave. Some, however,
-have already gained publicity through the papers, and others have
-not offered a field for those peculiar qualities which my friend
-possessed in so high a degree, and which it is the object of
-these papers to illustrate. Some, too, have baffled his
-analytical skill, and would be, as narratives, beginnings without
-an ending, while others have been but partially cleared up, and
-have their explanations founded rather upon conjecture and
-surmise than on that absolute logical proof which was so dear to
-him. There is, however, one of these last which was so remarkable
-in its details and so startling in its results that I am tempted
-to give some account of it in spite of the fact that there are
-points in connection with it which never have been, and probably
-never will be, entirely cleared up.
-
-The year '87 furnished us with a long series of cases of greater
-or less interest, of which I retain the records. Among my
-headings under this one twelve months I find an account of the
-adventure of the Paradol Chamber, of the Amateur Mendicant
-Society, who held a luxurious club in the lower vault of a
-furniture warehouse, of the facts connected with the loss of the
-British barque "Sophy Anderson", of the singular adventures of the
-Grice Patersons in the island of Uffa, and finally of the
-Camberwell poisoning case. In the latter, as may be remembered,
-Sherlock Holmes was able, by winding up the dead man's watch, to
-prove that it had been wound up two hours before, and that
-therefore the deceased had gone to bed within that time--a
-deduction which was of the greatest importance in clearing up the
-case. All these I may sketch out at some future date, but none of
-them present such singular features as the strange train of
-circumstances which I have now taken up my pen to describe.
-
-It was in the latter days of September, and the equinoctial gales
-had set in with exceptional violence. All day the wind had
-screamed and the rain had beaten against the windows, so that
-even here in the heart of great, hand-made London we were forced
-to raise our minds for the instant from the routine of life and
-to recognise the presence of those great elemental forces which
-shriek at mankind through the bars of his civilisation, like
-untamed beasts in a cage. As evening drew in, the storm grew
-higher and louder, and the wind cried and sobbed like a child in
-the chimney. Sherlock Holmes sat moodily at one side of the
-fireplace cross-indexing his records of crime, while I at the
-other was deep in one of Clark Russell's fine sea-stories until
-the howl of the gale from without seemed to blend with the text,
-and the splash of the rain to lengthen out into the long swash of
-the sea waves. My wife was on a visit to her mother's, and for a
-few days I was a dweller once more in my old quarters at Baker
-Street.
-
-"Why," said I, glancing up at my companion, "that was surely the
-bell. Who could come to-night? Some friend of yours, perhaps?"
-
-"Except yourself I have none," he answered. "I do not encourage
-visitors."
-
-"A client, then?"
-
-"If so, it is a serious case. Nothing less would bring a man out
-on such a day and at such an hour. But I take it that it is more
-likely to be some crony of the landlady's."
-
-Sherlock Holmes was wrong in his conjecture, however, for there
-came a step in the passage and a tapping at the door. He
-stretched out his long arm to turn the lamp away from himself and
-towards the vacant chair upon which a newcomer must sit.
-
-"Come in!" said he.
-
-The man who entered was young, some two-and-twenty at the
-outside, well-groomed and trimly clad, with something of
-refinement and delicacy in his bearing. The streaming umbrella
-which he held in his hand, and his long shining waterproof told
-of the fierce weather through which he had come. He looked about
-him anxiously in the glare of the lamp, and I could see that his
-face was pale and his eyes heavy, like those of a man who is
-weighed down with some great anxiety.
-
-"I owe you an apology," he said, raising his golden pince-nez to
-his eyes. "I trust that I am not intruding. I fear that I have
-brought some traces of the storm and rain into your snug
-chamber."
-
-"Give me your coat and umbrella," said Holmes. "They may rest
-here on the hook and will be dry presently. You have come up from
-the south-west, I see."
-
-"Yes, from Horsham."
-
-"That clay and chalk mixture which I see upon your toe caps is
-quite distinctive."
-
-"I have come for advice."
-
-"That is easily got."
-
-"And help."
-
-"That is not always so easy."
-
-"I have heard of you, Mr. Holmes. I heard from Major Prendergast
-how you saved him in the Tankerville Club scandal."
-
-"Ah, of course. He was wrongfully accused of cheating at cards."
-
-"He said that you could solve anything."
-
-"He said too much."
-
-"That you are never beaten."
-
-"I have been beaten four times--three times by men, and once by a
-woman."
-
-"But what is that compared with the number of your successes?"
-
-"It is true that I have been generally successful."
-
-"Then you may be so with me."
-
-"I beg that you will draw your chair up to the fire and favour me
-with some details as to your case."
-
-"It is no ordinary one."
-
-"None of those which come to me are. I am the last court of
-appeal."
-
-"And yet I question, sir, whether, in all your experience, you
-have ever listened to a more mysterious and inexplicable chain of
-events than those which have happened in my own family."
-
-"You fill me with interest," said Holmes. "Pray give us the
-essential facts from the commencement, and I can afterwards
-question you as to those details which seem to me to be most
-important."
-
-The young man pulled his chair up and pushed his wet feet out
-towards the blaze.
-
-"My name," said he, "is John Openshaw, but my own affairs have,
-as far as I can understand, little to do with this awful
-business. It is a hereditary matter; so in order to give you an
-idea of the facts, I must go back to the commencement of the
-affair.
-
-"You must know that my grandfather had two sons--my uncle Elias
-and my father Joseph. My father had a small factory at Coventry,
-which he enlarged at the time of the invention of bicycling. He
-was a patentee of the Openshaw unbreakable tire, and his business
-met with such success that he was able to sell it and to retire
-upon a handsome competence.
-
-"My uncle Elias emigrated to America when he was a young man and
-became a planter in Florida, where he was reported to have done
-very well. At the time of the war he fought in Jackson's army,
-and afterwards under Hood, where he rose to be a colonel. When
-Lee laid down his arms my uncle returned to his plantation, where
-he remained for three or four years. About 1869 or 1870 he came
-back to Europe and took a small estate in Sussex, near Horsham.
-He had made a very considerable fortune in the States, and his
-reason for leaving them was his aversion to the negroes, and his
-dislike of the Republican policy in extending the franchise to
-them. He was a singular man, fierce and quick-tempered, very
-foul-mouthed when he was angry, and of a most retiring
-disposition. During all the years that he lived at Horsham, I
-doubt if ever he set foot in the town. He had a garden and two or
-three fields round his house, and there he would take his
-exercise, though very often for weeks on end he would never leave
-his room. He drank a great deal of brandy and smoked very
-heavily, but he would see no society and did not want any
-friends, not even his own brother.
-
-"He didn't mind me; in fact, he took a fancy to me, for at the
-time when he saw me first I was a youngster of twelve or so. This
-would be in the year 1878, after he had been eight or nine years
-in England. He begged my father to let me live with him and he
-was very kind to me in his way. When he was sober he used to be
-fond of playing backgammon and draughts with me, and he would
-make me his representative both with the servants and with the
-tradespeople, so that by the time that I was sixteen I was quite
-master of the house. I kept all the keys and could go where I
-liked and do what I liked, so long as I did not disturb him in
-his privacy. There was one singular exception, however, for he
-had a single room, a lumber-room up among the attics, which was
-invariably locked, and which he would never permit either me or
-anyone else to enter. With a boy's curiosity I have peeped
-through the keyhole, but I was never able to see more than such a
-collection of old trunks and bundles as would be expected in such
-a room.
-
-"One day--it was in March, 1883--a letter with a foreign stamp
-lay upon the table in front of the colonel's plate. It was not a
-common thing for him to receive letters, for his bills were all
-paid in ready money, and he had no friends of any sort. 'From
-India!' said he as he took it up, 'Pondicherry postmark! What can
-this be?' Opening it hurriedly, out there jumped five little
-dried orange pips, which pattered down upon his plate. I began to
-laugh at this, but the laugh was struck from my lips at the sight
-of his face. His lip had fallen, his eyes were protruding, his
-skin the colour of putty, and he glared at the envelope which he
-still held in his trembling hand, 'K. K. K.!' he shrieked, and
-then, 'My God, my God, my sins have overtaken me!'
-
-"'What is it, uncle?' I cried.
-
-"'Death,' said he, and rising from the table he retired to his
-room, leaving me palpitating with horror. I took up the envelope
-and saw scrawled in red ink upon the inner flap, just above the
-gum, the letter K three times repeated. There was nothing else
-save the five dried pips. What could be the reason of his
-overpowering terror? I left the breakfast-table, and as I
-ascended the stair I met him coming down with an old rusty key,
-which must have belonged to the attic, in one hand, and a small
-brass box, like a cashbox, in the other.
-
-"'They may do what they like, but I'll checkmate them still,'
-said he with an oath. 'Tell Mary that I shall want a fire in my
-room to-day, and send down to Fordham, the Horsham lawyer.'
-
-"I did as he ordered, and when the lawyer arrived I was asked to
-step up to the room. The fire was burning brightly, and in the
-grate there was a mass of black, fluffy ashes, as of burned
-paper, while the brass box stood open and empty beside it. As I
-glanced at the box I noticed, with a start, that upon the lid was
-printed the treble K which I had read in the morning upon the
-envelope.
-
-"'I wish you, John,' said my uncle, 'to witness my will. I leave
-my estate, with all its advantages and all its disadvantages, to
-my brother, your father, whence it will, no doubt, descend to
-you. If you can enjoy it in peace, well and good! If you find you
-cannot, take my advice, my boy, and leave it to your deadliest
-enemy. I am sorry to give you such a two-edged thing, but I can't
-say what turn things are going to take. Kindly sign the paper
-where Mr. Fordham shows you.'
-
-"I signed the paper as directed, and the lawyer took it away with
-him. The singular incident made, as you may think, the deepest
-impression upon me, and I pondered over it and turned it every
-way in my mind without being able to make anything of it. Yet I
-could not shake off the vague feeling of dread which it left
-behind, though the sensation grew less keen as the weeks passed
-and nothing happened to disturb the usual routine of our lives. I
-could see a change in my uncle, however. He drank more than ever,
-and he was less inclined for any sort of society. Most of his
-time he would spend in his room, with the door locked upon the
-inside, but sometimes he would emerge in a sort of drunken frenzy
-and would burst out of the house and tear about the garden with a
-revolver in his hand, screaming out that he was afraid of no man,
-and that he was not to be cooped up, like a sheep in a pen, by
-man or devil. When these hot fits were over, however, he would
-rush tumultuously in at the door and lock and bar it behind him,
-like a man who can brazen it out no longer against the terror
-which lies at the roots of his soul. At such times I have seen
-his face, even on a cold day, glisten with moisture, as though it
-were new raised from a basin.
-
-"Well, to come to an end of the matter, Mr. Holmes, and not to
-abuse your patience, there came a night when he made one of those
-drunken sallies from which he never came back. We found him, when
-we went to search for him, face downward in a little
-green-scummed pool, which lay at the foot of the garden. There
-was no sign of any violence, and the water was but two feet deep,
-so that the jury, having regard to his known eccentricity,
-brought in a verdict of 'suicide.' But I, who knew how he winced
-from the very thought of death, had much ado to persuade myself
-that he had gone out of his way to meet it. The matter passed,
-however, and my father entered into possession of the estate, and
-of some 14,000 pounds, which lay to his credit at the bank."
-
-"One moment," Holmes interposed, "your statement is, I foresee,
-one of the most remarkable to which I have ever listened. Let me
-have the date of the reception by your uncle of the letter, and
-the date of his supposed suicide."
-
-"The letter arrived on March 10, 1883. His death was seven weeks
-later, upon the night of May 2nd."
-
-"Thank you. Pray proceed."
-
-"When my father took over the Horsham property, he, at my
-request, made a careful examination of the attic, which had been
-always locked up. We found the brass box there, although its
-contents had been destroyed. On the inside of the cover was a
-paper label, with the initials of K. K. K. repeated upon it, and
-'Letters, memoranda, receipts, and a register' written beneath.
-These, we presume, indicated the nature of the papers which had
-been destroyed by Colonel Openshaw. For the rest, there was
-nothing of much importance in the attic save a great many
-scattered papers and note-books bearing upon my uncle's life in
-America. Some of them were of the war time and showed that he had
-done his duty well and had borne the repute of a brave soldier.
-Others were of a date during the reconstruction of the Southern
-states, and were mostly concerned with politics, for he had
-evidently taken a strong part in opposing the carpet-bag
-politicians who had been sent down from the North.
-
-"Well, it was the beginning of '84 when my father came to live at
-Horsham, and all went as well as possible with us until the
-January of '85. On the fourth day after the new year I heard my
-father give a sharp cry of surprise as we sat together at the
-breakfast-table. There he was, sitting with a newly opened
-envelope in one hand and five dried orange pips in the
-outstretched palm of the other one. He had always laughed at what
-he called my cock-and-bull story about the colonel, but he looked
-very scared and puzzled now that the same thing had come upon
-himself.
-
-"'Why, what on earth does this mean, John?' he stammered.
-
-"My heart had turned to lead. 'It is K. K. K.,' said I.
-
-"He looked inside the envelope. 'So it is,' he cried. 'Here are
-the very letters. But what is this written above them?'
-
-"'Put the papers on the sundial,' I read, peeping over his
-shoulder.
-
-"'What papers? What sundial?' he asked.
-
-"'The sundial in the garden. There is no other,' said I; 'but the
-papers must be those that are destroyed.'
-
-"'Pooh!' said he, gripping hard at his courage. 'We are in a
-civilised land here, and we can't have tomfoolery of this kind.
-Where does the thing come from?'
-
-"'From Dundee,' I answered, glancing at the postmark.
-
-"'Some preposterous practical joke,' said he. 'What have I to do
-with sundials and papers? I shall take no notice of such
-nonsense.'
-
-"'I should certainly speak to the police,' I said.
-
-"'And be laughed at for my pains. Nothing of the sort.'
-
-"'Then let me do so?'
-
-"'No, I forbid you. I won't have a fuss made about such
-nonsense.'
-
-"It was in vain to argue with him, for he was a very obstinate
-man. I went about, however, with a heart which was full of
-forebodings.
-
-"On the third day after the coming of the letter my father went
-from home to visit an old friend of his, Major Freebody, who is
-in command of one of the forts upon Portsdown Hill. I was glad
-that he should go, for it seemed to me that he was farther from
-danger when he was away from home. In that, however, I was in
-error. Upon the second day of his absence I received a telegram
-from the major, imploring me to come at once. My father had
-fallen over one of the deep chalk-pits which abound in the
-neighbourhood, and was lying senseless, with a shattered skull. I
-hurried to him, but he passed away without having ever recovered
-his consciousness. He had, as it appears, been returning from
-Fareham in the twilight, and as the country was unknown to him,
-and the chalk-pit unfenced, the jury had no hesitation in
-bringing in a verdict of 'death from accidental causes.'
-Carefully as I examined every fact connected with his death, I
-was unable to find anything which could suggest the idea of
-murder. There were no signs of violence, no footmarks, no
-robbery, no record of strangers having been seen upon the roads.
-And yet I need not tell you that my mind was far from at ease,
-and that I was well-nigh certain that some foul plot had been
-woven round him.
-
-"In this sinister way I came into my inheritance. You will ask me
-why I did not dispose of it? I answer, because I was well
-convinced that our troubles were in some way dependent upon an
-incident in my uncle's life, and that the danger would be as
-pressing in one house as in another.
-
-"It was in January, '85, that my poor father met his end, and two
-years and eight months have elapsed since then. During that time
-I have lived happily at Horsham, and I had begun to hope that
-this curse had passed away from the family, and that it had ended
-with the last generation. I had begun to take comfort too soon,
-however; yesterday morning the blow fell in the very shape in
-which it had come upon my father."
-
-The young man took from his waistcoat a crumpled envelope, and
-turning to the table he shook out upon it five little dried
-orange pips.
-
-"This is the envelope," he continued. "The postmark is
-London--eastern division. Within are the very words which were
-upon my father's last message: 'K. K. K.'; and then 'Put the
-papers on the sundial.'"
-
-"What have you done?" asked Holmes.
-
-"Nothing."
-
-"Nothing?"
-
-"To tell the truth"--he sank his face into his thin, white
-hands--"I have felt helpless. I have felt like one of those poor
-rabbits when the snake is writhing towards it. I seem to be in
-the grasp of some resistless, inexorable evil, which no foresight
-and no precautions can guard against."
-
-"Tut! tut!" cried Sherlock Holmes. "You must act, man, or you are
-lost. Nothing but energy can save you. This is no time for
-despair."
-
-"I have seen the police."
-
-"Ah!"
-
-"But they listened to my story with a smile. I am convinced that
-the inspector has formed the opinion that the letters are all
-practical jokes, and that the deaths of my relations were really
-accidents, as the jury stated, and were not to be connected with
-the warnings."
-
-Holmes shook his clenched hands in the air. "Incredible
-imbecility!" he cried.
-
-"They have, however, allowed me a policeman, who may remain in
-the house with me."
-
-"Has he come with you to-night?"
-
-"No. His orders were to stay in the house."
-
-Again Holmes raved in the air.
-
-"Why did you come to me," he cried, "and, above all, why did you
-not come at once?"
-
-"I did not know. It was only to-day that I spoke to Major
-Prendergast about my troubles and was advised by him to come to
-you."
-
-"It is really two days since you had the letter. We should have
-acted before this. You have no further evidence, I suppose, than
-that which you have placed before us--no suggestive detail which
-might help us?"
-
-"There is one thing," said John Openshaw. He rummaged in his coat
-pocket, and, drawing out a piece of discoloured, blue-tinted
-paper, he laid it out upon the table. "I have some remembrance,"
-said he, "that on the day when my uncle burned the papers I
-observed that the small, unburned margins which lay amid the
-ashes were of this particular colour. I found this single sheet
-upon the floor of his room, and I am inclined to think that it
-may be one of the papers which has, perhaps, fluttered out from
-among the others, and in that way has escaped destruction. Beyond
-the mention of pips, I do not see that it helps us much. I think
-myself that it is a page from some private diary. The writing is
-undoubtedly my uncle's."
-
-Holmes moved the lamp, and we both bent over the sheet of paper,
-which showed by its ragged edge that it had indeed been torn from
-a book. It was headed, "March, 1869," and beneath were the
-following enigmatical notices:
-
-"4th. Hudson came. Same old platform.
-
-"7th. Set the pips on McCauley, Paramore, and
-      John Swain, of St. Augustine.
-
-"9th. McCauley cleared.
-
-"10th. John Swain cleared.
-
-"12th. Visited Paramore. All well."
-
-"Thank you!" said Holmes, folding up the paper and returning it
-to our visitor. "And now you must on no account lose another
-instant. We cannot spare time even to discuss what you have told
-me. You must get home instantly and act."
-
-"What shall I do?"
-
-"There is but one thing to do. It must be done at once. You must
-put this piece of paper which you have shown us into the brass
-box which you have described. You must also put in a note to say
-that all the other papers were burned by your uncle, and that
-this is the only one which remains. You must assert that in such
-words as will carry conviction with them. Having done this, you
-must at once put the box out upon the sundial, as directed. Do
-you understand?"
-
-"Entirely."
-
-"Do not think of revenge, or anything of the sort, at present. I
-think that we may gain that by means of the law; but we have our
-web to weave, while theirs is already woven. The first
-consideration is to remove the pressing danger which threatens
-you. The second is to clear up the mystery and to punish the
-guilty parties."
-
-"I thank you," said the young man, rising and pulling on his
-overcoat. "You have given me fresh life and hope. I shall
-certainly do as you advise."
-
-"Do not lose an instant. And, above all, take care of yourself in
-the meanwhile, for I do not think that there can be a doubt that
-you are threatened by a very real and imminent danger. How do you
-go back?"
-
-"By train from Waterloo."
-
-"It is not yet nine. The streets will be crowded, so I trust that
-you may be in safety. And yet you cannot guard yourself too
-closely."
-
-"I am armed."
-
-"That is well. To-morrow I shall set to work upon your case."
-
-"I shall see you at Horsham, then?"
-
-"No, your secret lies in London. It is there that I shall seek
-it."
-
-"Then I shall call upon you in a day, or in two days, with news
-as to the box and the papers. I shall take your advice in every
-particular." He shook hands with us and took his leave. Outside
-the wind still screamed and the rain splashed and pattered
-against the windows. This strange, wild story seemed to have come
-to us from amid the mad elements--blown in upon us like a sheet
-of sea-weed in a gale--and now to have been reabsorbed by them
-once more.
-
-Sherlock Holmes sat for some time in silence, with his head sunk
-forward and his eyes bent upon the red glow of the fire. Then he
-lit his pipe, and leaning back in his chair he watched the blue
-smoke-rings as they chased each other up to the ceiling.
-
-"I think, Watson," he remarked at last, "that of all our cases we
-have had none more fantastic than this."
-
-"Save, perhaps, the Sign of Four."
-
-"Well, yes. Save, perhaps, that. And yet this John Openshaw seems
-to me to be walking amid even greater perils than did the
-Sholtos."
-
-"But have you," I asked, "formed any definite conception as to
-what these perils are?"
-
-"There can be no question as to their nature," he answered.
-
-"Then what are they? Who is this K. K. K., and why does he pursue
-this unhappy family?"
-
-Sherlock Holmes closed his eyes and placed his elbows upon the
-arms of his chair, with his finger-tips together. "The ideal
-reasoner," he remarked, "would, when he had once been shown a
-single fact in all its bearings, deduce from it not only all the
-chain of events which led up to it but also all the results which
-would follow from it. As Cuvier could correctly describe a whole
-animal by the contemplation of a single bone, so the observer who
-has thoroughly understood one link in a series of incidents
-should be able to accurately state all the other ones, both
-before and after. We have not yet grasped the results which the
-reason alone can attain to. Problems may be solved in the study
-which have baffled all those who have sought a solution by the
-aid of their senses. To carry the art, however, to its highest
-pitch, it is necessary that the reasoner should be able to
-utilise all the facts which have come to his knowledge; and this
-in itself implies, as you will readily see, a possession of all
-knowledge, which, even in these days of free education and
-encyclopaedias, is a somewhat rare accomplishment. It is not so
-impossible, however, that a man should possess all knowledge
-which is likely to be useful to him in his work, and this I have
-endeavoured in my case to do. If I remember rightly, you on one
-occasion, in the early days of our friendship, defined my limits
-in a very precise fashion."
-
-"Yes," I answered, laughing. "It was a singular document.
-Philosophy, astronomy, and politics were marked at zero, I
-remember. Botany variable, geology profound as regards the
-mud-stains from any region within fifty miles of town, chemistry
-eccentric, anatomy unsystematic, sensational literature and crime
-records unique, violin-player, boxer, swordsman, lawyer, and
-self-poisoner by cocaine and tobacco. Those, I think, were the
-main points of my analysis."
-
-Holmes grinned at the last item. "Well," he said, "I say now, as
-I said then, that a man should keep his little brain-attic
-stocked with all the furniture that he is likely to use, and the
-rest he can put away in the lumber-room of his library, where he
-can get it if he wants it. Now, for such a case as the one which
-has been submitted to us to-night, we need certainly to muster
-all our resources. Kindly hand me down the letter K of the
-'American Encyclopaedia' which stands upon the shelf beside you.
-Thank you. Now let us consider the situation and see what may be
-deduced from it. In the first place, we may start with a strong
-presumption that Colonel Openshaw had some very strong reason for
-leaving America. Men at his time of life do not change all their
-habits and exchange willingly the charming climate of Florida for
-the lonely life of an English provincial town. His extreme love
-of solitude in England suggests the idea that he was in fear of
-someone or something, so we may assume as a working hypothesis
-that it was fear of someone or something which drove him from
-America. As to what it was he feared, we can only deduce that by
-considering the formidable letters which were received by himself
-and his successors. Did you remark the postmarks of those
-letters?"
-
-"The first was from Pondicherry, the second from Dundee, and the
-third from London."
-
-"From East London. What do you deduce from that?"
-
-"They are all seaports. That the writer was on board of a ship."
-
-"Excellent. We have already a clue. There can be no doubt that
-the probability--the strong probability--is that the writer was
-on board of a ship. And now let us consider another point. In the
-case of Pondicherry, seven weeks elapsed between the threat and
-its fulfilment, in Dundee it was only some three or four days.
-Does that suggest anything?"
-
-"A greater distance to travel."
-
-"But the letter had also a greater distance to come."
-
-"Then I do not see the point."
-
-"There is at least a presumption that the vessel in which the man
-or men are is a sailing-ship. It looks as if they always send
-their singular warning or token before them when starting upon
-their mission. You see how quickly the deed followed the sign
-when it came from Dundee. If they had come from Pondicherry in a
-steamer they would have arrived almost as soon as their letter.
-But, as a matter of fact, seven weeks elapsed. I think that those
-seven weeks represented the difference between the mail-boat which
-brought the letter and the sailing vessel which brought the
-writer."
-
-"It is possible."
-
-"More than that. It is probable. And now you see the deadly
-urgency of this new case, and why I urged young Openshaw to
-caution. The blow has always fallen at the end of the time which
-it would take the senders to travel the distance. But this one
-comes from London, and therefore we cannot count upon delay."
-
-"Good God!" I cried. "What can it mean, this relentless
-persecution?"
-
-"The papers which Openshaw carried are obviously of vital
-importance to the person or persons in the sailing-ship. I think
-that it is quite clear that there must be more than one of them.
-A single man could not have carried out two deaths in such a way
-as to deceive a coroner's jury. There must have been several in
-it, and they must have been men of resource and determination.
-Their papers they mean to have, be the holder of them who it may.
-In this way you see K. K. K. ceases to be the initials of an
-individual and becomes the badge of a society."
-
-"But of what society?"
-
-"Have you never--" said Sherlock Holmes, bending forward and
-sinking his voice--"have you never heard of the Ku Klux Klan?"
-
-"I never have."
-
-Holmes turned over the leaves of the book upon his knee. "Here it
-is," said he presently:
-
-"'Ku Klux Klan. A name derived from the fanciful resemblance to
-the sound produced by cocking a rifle. This terrible secret
-society was formed by some ex-Confederate soldiers in the
-Southern states after the Civil War, and it rapidly formed local
-branches in different parts of the country, notably in Tennessee,
-Louisiana, the Carolinas, Georgia, and Florida. Its power was
-used for political purposes, principally for the terrorising of
-the negro voters and the murdering and driving from the country
-of those who were opposed to its views. Its outrages were usually
-preceded by a warning sent to the marked man in some fantastic
-but generally recognised shape--a sprig of oak-leaves in some
-parts, melon seeds or orange pips in others. On receiving this
-the victim might either openly abjure his former ways, or might
-fly from the country. If he braved the matter out, death would
-unfailingly come upon him, and usually in some strange and
-unforeseen manner. So perfect was the organisation of the
-society, and so systematic its methods, that there is hardly a
-case upon record where any man succeeded in braving it with
-impunity, or in which any of its outrages were traced home to the
-perpetrators. For some years the organisation flourished in spite
-of the efforts of the United States government and of the better
-classes of the community in the South. Eventually, in the year
-1869, the movement rather suddenly collapsed, although there have
-been sporadic outbreaks of the same sort since that date.'
-
-"You will observe," said Holmes, laying down the volume, "that
-the sudden breaking up of the society was coincident with the
-disappearance of Openshaw from America with their papers. It may
-well have been cause and effect. It is no wonder that he and his
-family have some of the more implacable spirits upon their track.
-You can understand that this register and diary may implicate
-some of the first men in the South, and that there may be many
-who will not sleep easy at night until it is recovered."
-
-"Then the page we have seen--"
-
-"Is such as we might expect. It ran, if I remember right, 'sent
-the pips to A, B, and C'--that is, sent the society's warning to
-them. Then there are successive entries that A and B cleared, or
-left the country, and finally that C was visited, with, I fear, a
-sinister result for C. Well, I think, Doctor, that we may let
-some light into this dark place, and I believe that the only
-chance young Openshaw has in the meantime is to do what I have
-told him. There is nothing more to be said or to be done
-to-night, so hand me over my violin and let us try to forget for
-half an hour the miserable weather and the still more miserable
-ways of our fellow-men."
-
-
-It had cleared in the morning, and the sun was shining with a
-subdued brightness through the dim veil which hangs over the
-great city. Sherlock Holmes was already at breakfast when I came
-down.
-
-"You will excuse me for not waiting for you," said he; "I have, I
-foresee, a very busy day before me in looking into this case of
-young Openshaw's."
-
-"What steps will you take?" I asked.
-
-"It will very much depend upon the results of my first inquiries.
-I may have to go down to Horsham, after all."
-
-"You will not go there first?"
-
-"No, I shall commence with the City. Just ring the bell and the
-maid will bring up your coffee."
-
-As I waited, I lifted the unopened newspaper from the table and
-glanced my eye over it. It rested upon a heading which sent a
-chill to my heart.
-
-"Holmes," I cried, "you are too late."
-
-"Ah!" said he, laying down his cup, "I feared as much. How was it
-done?" He spoke calmly, but I could see that he was deeply moved.
-
-"My eye caught the name of Openshaw, and the heading 'Tragedy
-Near Waterloo Bridge.' Here is the account:
-
-"Between nine and ten last night Police-Constable Cook, of the H
-Division, on duty near Waterloo Bridge, heard a cry for help and
-a splash in the water. The night, however, was extremely dark and
-stormy, so that, in spite of the help of several passers-by, it
-was quite impossible to effect a rescue. The alarm, however, was
-given, and, by the aid of the water-police, the body was
-eventually recovered. It proved to be that of a young gentleman
-whose name, as it appears from an envelope which was found in his
-pocket, was John Openshaw, and whose residence is near Horsham.
-It is conjectured that he may have been hurrying down to catch
-the last train from Waterloo Station, and that in his haste and
-the extreme darkness he missed his path and walked over the edge
-of one of the small landing-places for river steamboats. The body
-exhibited no traces of violence, and there can be no doubt that
-the deceased had been the victim of an unfortunate accident,
-which should have the effect of calling the attention of the
-authorities to the condition of the riverside landing-stages."
-
-We sat in silence for some minutes, Holmes more depressed and
-shaken than I had ever seen him.
-
-"That hurts my pride, Watson," he said at last. "It is a petty
-feeling, no doubt, but it hurts my pride. It becomes a personal
-matter with me now, and, if God sends me health, I shall set my
-hand upon this gang. That he should come to me for help, and that
-I should send him away to his death--!" He sprang from his chair
-and paced about the room in uncontrollable agitation, with a
-flush upon his sallow cheeks and a nervous clasping and
-unclasping of his long thin hands.
-
-"They must be cunning devils," he exclaimed at last. "How could
-they have decoyed him down there? The Embankment is not on the
-direct line to the station. The bridge, no doubt, was too
-crowded, even on such a night, for their purpose. Well, Watson,
-we shall see who will win in the long run. I am going out now!"
-
-"To the police?"
-
-"No; I shall be my own police. When I have spun the web they may
-take the flies, but not before."
-
-All day I was engaged in my professional work, and it was late in
-the evening before I returned to Baker Street. Sherlock Holmes
-had not come back yet. It was nearly ten o'clock before he
-entered, looking pale and worn. He walked up to the sideboard,
-and tearing a piece from the loaf he devoured it voraciously,
-washing it down with a long draught of water.
-
-"You are hungry," I remarked.
-
-"Starving. It had escaped my memory. I have had nothing since
-breakfast."
-
-"Nothing?"
-
-"Not a bite. I had no time to think of it."
-
-"And how have you succeeded?"
-
-"Well."
-
-"You have a clue?"
-
-"I have them in the hollow of my hand. Young Openshaw shall not
-long remain unavenged. Why, Watson, let us put their own devilish
-trade-mark upon them. It is well thought of!"
-
-"What do you mean?"
-
-He took an orange from the cupboard, and tearing it to pieces he
-squeezed out the pips upon the table. Of these he took five and
-thrust them into an envelope. On the inside of the flap he wrote
-"S. H. for J. O." Then he sealed it and addressed it to "Captain
-James Calhoun, Barque 'Lone Star,' Savannah, Georgia."
-
-"That will await him when he enters port," said he, chuckling.
-"It may give him a sleepless night. He will find it as sure a
-precursor of his fate as Openshaw did before him."
-
-"And who is this Captain Calhoun?"
-
-"The leader of the gang. I shall have the others, but he first."
-
-"How did you trace it, then?"
-
-He took a large sheet of paper from his pocket, all covered with
-dates and names.
-
-"I have spent the whole day," said he, "over Lloyd's registers
-and files of the old papers, following the future career of every
-vessel which touched at Pondicherry in January and February in
-'83. There were thirty-six ships of fair tonnage which were
-reported there during those months. Of these, one, the 'Lone Star,'
-instantly attracted my attention, since, although it was reported
-as having cleared from London, the name is that which is given to
-one of the states of the Union."
-
-"Texas, I think."
-
-"I was not and am not sure which; but I knew that the ship must
-have an American origin."
-
-"What then?"
-
-"I searched the Dundee records, and when I found that the barque
-'Lone Star' was there in January, '85, my suspicion became a
-certainty. I then inquired as to the vessels which lay at present
-in the port of London."
-
-"Yes?"
-
-"The 'Lone Star' had arrived here last week. I went down to the
-Albert Dock and found that she had been taken down the river by
-the early tide this morning, homeward bound to Savannah. I wired
-to Gravesend and learned that she had passed some time ago, and
-as the wind is easterly I have no doubt that she is now past the
-Goodwins and not very far from the Isle of Wight."
-
-"What will you do, then?"
-
-"Oh, I have my hand upon him. He and the two mates, are as I
-learn, the only native-born Americans in the ship. The others are
-Finns and Germans. I know, also, that they were all three away
-from the ship last night. I had it from the stevedore who has
-been loading their cargo. By the time that their sailing-ship
-reaches Savannah the mail-boat will have carried this letter, and
-the cable will have informed the police of Savannah that these
-three gentlemen are badly wanted here upon a charge of murder."
-
-There is ever a flaw, however, in the best laid of human plans,
-and the murderers of John Openshaw were never to receive the
-orange pips which would show them that another, as cunning and as
-resolute as themselves, was upon their track. Very long and very
-severe were the equinoctial gales that year. We waited long for
-news of the "Lone Star" of Savannah, but none ever reached us. We
-did at last hear that somewhere far out in the Atlantic a
-shattered stern-post of a boat was seen swinging in the trough
-of a wave, with the letters "L. S." carved upon it, and that is
-all which we shall ever know of the fate of the "Lone Star."
-
-
-
-ADVENTURE VI. THE MAN WITH THE TWISTED LIP
-
-Isa Whitney, brother of the late Elias Whitney, D.D., Principal
-of the Theological College of St. George's, was much addicted to
-opium. The habit grew upon him, as I understand, from some
-foolish freak when he was at college; for having read De
-Quincey's description of his dreams and sensations, he had
-drenched his tobacco with laudanum in an attempt to produce the
-same effects. He found, as so many more have done, that the
-practice is easier to attain than to get rid of, and for many
-years he continued to be a slave to the drug, an object of
-mingled horror and pity to his friends and relatives. I can see
-him now, with yellow, pasty face, drooping lids, and pin-point
-pupils, all huddled in a chair, the wreck and ruin of a noble
-man.
-
-One night--it was in June, '89--there came a ring to my bell,
-about the hour when a man gives his first yawn and glances at the
-clock. I sat up in my chair, and my wife laid her needle-work
-down in her lap and made a little face of disappointment.
-
-"A patient!" said she. "You'll have to go out."
-
-I groaned, for I was newly come back from a weary day.
-
-We heard the door open, a few hurried words, and then quick steps
-upon the linoleum. Our own door flew open, and a lady, clad in
-some dark-coloured stuff, with a black veil, entered the room.
-
-"You will excuse my calling so late," she began, and then,
-suddenly losing her self-control, she ran forward, threw her arms
-about my wife's neck, and sobbed upon her shoulder. "Oh, I'm in
-such trouble!" she cried; "I do so want a little help."
-
-"Why," said my wife, pulling up her veil, "it is Kate Whitney.
-How you startled me, Kate! I had not an idea who you were when
-you came in."
-
-"I didn't know what to do, so I came straight to you." That was
-always the way. Folk who were in grief came to my wife like birds
-to a light-house.
-
-"It was very sweet of you to come. Now, you must have some wine
-and water, and sit here comfortably and tell us all about it. Or
-should you rather that I sent James off to bed?"
-
-"Oh, no, no! I want the doctor's advice and help, too. It's about
-Isa. He has not been home for two days. I am so frightened about
-him!"
-
-It was not the first time that she had spoken to us of her
-husband's trouble, to me as a doctor, to my wife as an old friend
-and school companion. We soothed and comforted her by such words
-as we could find. Did she know where her husband was? Was it
-possible that we could bring him back to her?
-
-It seems that it was. She had the surest information that of late
-he had, when the fit was on him, made use of an opium den in the
-farthest east of the City. Hitherto his orgies had always been
-confined to one day, and he had come back, twitching and
-shattered, in the evening. But now the spell had been upon him
-eight-and-forty hours, and he lay there, doubtless among the
-dregs of the docks, breathing in the poison or sleeping off the
-effects. There he was to be found, she was sure of it, at the Bar
-of Gold, in Upper Swandam Lane. But what was she to do? How could
-she, a young and timid woman, make her way into such a place and
-pluck her husband out from among the ruffians who surrounded him?
-
-There was the case, and of course there was but one way out of
-it. Might I not escort her to this place? And then, as a second
-thought, why should she come at all? I was Isa Whitney's medical
-adviser, and as such I had influence over him. I could manage it
-better if I were alone. I promised her on my word that I would
-send him home in a cab within two hours if he were indeed at the
-address which she had given me. And so in ten minutes I had left
-my armchair and cheery sitting-room behind me, and was speeding
-eastward in a hansom on a strange errand, as it seemed to me at
-the time, though the future only could show how strange it was to
-be.
-
-But there was no great difficulty in the first stage of my
-adventure. Upper Swandam Lane is a vile alley lurking behind the
-high wharves which line the north side of the river to the east
-of London Bridge. Between a slop-shop and a gin-shop, approached
-by a steep flight of steps leading down to a black gap like the
-mouth of a cave, I found the den of which I was in search.
-Ordering my cab to wait, I passed down the steps, worn hollow in
-the centre by the ceaseless tread of drunken feet; and by the
-light of a flickering oil-lamp above the door I found the latch
-and made my way into a long, low room, thick and heavy with the
-brown opium smoke, and terraced with wooden berths, like the
-forecastle of an emigrant ship.
-
-Through the gloom one could dimly catch a glimpse of bodies lying
-in strange fantastic poses, bowed shoulders, bent knees, heads
-thrown back, and chins pointing upward, with here and there a
-dark, lack-lustre eye turned upon the newcomer. Out of the black
-shadows there glimmered little red circles of light, now bright,
-now faint, as the burning poison waxed or waned in the bowls of
-the metal pipes. The most lay silent, but some muttered to
-themselves, and others talked together in a strange, low,
-monotonous voice, their conversation coming in gushes, and then
-suddenly tailing off into silence, each mumbling out his own
-thoughts and paying little heed to the words of his neighbour. At
-the farther end was a small brazier of burning charcoal, beside
-which on a three-legged wooden stool there sat a tall, thin old
-man, with his jaw resting upon his two fists, and his elbows upon
-his knees, staring into the fire.
-
-As I entered, a sallow Malay attendant had hurried up with a pipe
-for me and a supply of the drug, beckoning me to an empty berth.
-
-"Thank you. I have not come to stay," said I. "There is a friend
-of mine here, Mr. Isa Whitney, and I wish to speak with him."
-
-There was a movement and an exclamation from my right, and
-peering through the gloom, I saw Whitney, pale, haggard, and
-unkempt, staring out at me.
-
-"My God! It's Watson," said he. He was in a pitiable state of
-reaction, with every nerve in a twitter. "I say, Watson, what
-o'clock is it?"
-
-"Nearly eleven."
-
-"Of what day?"
-
-"Of Friday, June 19th."
-
-"Good heavens! I thought it was Wednesday. It is Wednesday. What
-d'you want to frighten a chap for?" He sank his face onto his
-arms and began to sob in a high treble key.
-
-"I tell you that it is Friday, man. Your wife has been waiting
-this two days for you. You should be ashamed of yourself!"
-
-"So I am. But you've got mixed, Watson, for I have only been here
-a few hours, three pipes, four pipes--I forget how many. But I'll
-go home with you. I wouldn't frighten Kate--poor little Kate.
-Give me your hand! Have you a cab?"
-
-"Yes, I have one waiting."
-
-"Then I shall go in it. But I must owe something. Find what I
-owe, Watson. I am all off colour. I can do nothing for myself."
-
-I walked down the narrow passage between the double row of
-sleepers, holding my breath to keep out the vile, stupefying
-fumes of the drug, and looking about for the manager. As I passed
-the tall man who sat by the brazier I felt a sudden pluck at my
-skirt, and a low voice whispered, "Walk past me, and then look
-back at me." The words fell quite distinctly upon my ear. I
-glanced down. They could only have come from the old man at my
-side, and yet he sat now as absorbed as ever, very thin, very
-wrinkled, bent with age, an opium pipe dangling down from between
-his knees, as though it had dropped in sheer lassitude from his
-fingers. I took two steps forward and looked back. It took all my
-self-control to prevent me from breaking out into a cry of
-astonishment. He had turned his back so that none could see him
-but I. His form had filled out, his wrinkles were gone, the dull
-eyes had regained their fire, and there, sitting by the fire and
-grinning at my surprise, was none other than Sherlock Holmes. He
-made a slight motion to me to approach him, and instantly, as he
-turned his face half round to the company once more, subsided
-into a doddering, loose-lipped senility.
-
-"Holmes!" I whispered, "what on earth are you doing in this den?"
-
-"As low as you can," he answered; "I have excellent ears. If you
-would have the great kindness to get rid of that sottish friend
-of yours I should be exceedingly glad to have a little talk with
-you."
-
-"I have a cab outside."
-
-"Then pray send him home in it. You may safely trust him, for he
-appears to be too limp to get into any mischief. I should
-recommend you also to send a note by the cabman to your wife to
-say that you have thrown in your lot with me. If you will wait
-outside, I shall be with you in five minutes."
-
-It was difficult to refuse any of Sherlock Holmes' requests, for
-they were always so exceedingly definite, and put forward with
-such a quiet air of mastery. I felt, however, that when Whitney
-was once confined in the cab my mission was practically
-accomplished; and for the rest, I could not wish anything better
-than to be associated with my friend in one of those singular
-adventures which were the normal condition of his existence. In a
-few minutes I had written my note, paid Whitney's bill, led him
-out to the cab, and seen him driven through the darkness. In a
-very short time a decrepit figure had emerged from the opium den,
-and I was walking down the street with Sherlock Holmes. For two
-streets he shuffled along with a bent back and an uncertain foot.
-Then, glancing quickly round, he straightened himself out and
-burst into a hearty fit of laughter.
-
-"I suppose, Watson," said he, "that you imagine that I have added
-opium-smoking to cocaine injections, and all the other little
-weaknesses on which you have favoured me with your medical
-views."
-
-"I was certainly surprised to find you there."
-
-"But not more so than I to find you."
-
-"I came to find a friend."
-
-"And I to find an enemy."
-
-"An enemy?"
-
-"Yes; one of my natural enemies, or, shall I say, my natural
-prey. Briefly, Watson, I am in the midst of a very remarkable
-inquiry, and I have hoped to find a clue in the incoherent
-ramblings of these sots, as I have done before now. Had I been
-recognised in that den my life would not have been worth an
-hour's purchase; for I have used it before now for my own
-purposes, and the rascally Lascar who runs it has sworn to have
-vengeance upon me. There is a trap-door at the back of that
-building, near the corner of Paul's Wharf, which could tell some
-strange tales of what has passed through it upon the moonless
-nights."
-
-"What! You do not mean bodies?"
-
-"Ay, bodies, Watson. We should be rich men if we had 1000 pounds
-for every poor devil who has been done to death in that den. It
-is the vilest murder-trap on the whole riverside, and I fear that
-Neville St. Clair has entered it never to leave it more. But our
-trap should be here." He put his two forefingers between his
-teeth and whistled shrilly--a signal which was answered by a
-similar whistle from the distance, followed shortly by the rattle
-of wheels and the clink of horses' hoofs.
-
-"Now, Watson," said Holmes, as a tall dog-cart dashed up through
-the gloom, throwing out two golden tunnels of yellow light from
-its side lanterns. "You'll come with me, won't you?"
-
-"If I can be of use."
-
-"Oh, a trusty comrade is always of use; and a chronicler still
-more so. My room at The Cedars is a double-bedded one."
-
-"The Cedars?"
-
-"Yes; that is Mr. St. Clair's house. I am staying there while I
-conduct the inquiry."
-
-"Where is it, then?"
-
-"Near Lee, in Kent. We have a seven-mile drive before us."
-
-"But I am all in the dark."
-
-"Of course you are. You'll know all about it presently. Jump up
-here. All right, John; we shall not need you. Here's half a
-crown. Look out for me to-morrow, about eleven. Give her her
-head. So long, then!"
-
-He flicked the horse with his whip, and we dashed away through
-the endless succession of sombre and deserted streets, which
-widened gradually, until we were flying across a broad
-balustraded bridge, with the murky river flowing sluggishly
-beneath us. Beyond lay another dull wilderness of bricks and
-mortar, its silence broken only by the heavy, regular footfall of
-the policeman, or the songs and shouts of some belated party of
-revellers. A dull wrack was drifting slowly across the sky, and a
-star or two twinkled dimly here and there through the rifts of
-the clouds. Holmes drove in silence, with his head sunk upon his
-breast, and the air of a man who is lost in thought, while I sat
-beside him, curious to learn what this new quest might be which
-seemed to tax his powers so sorely, and yet afraid to break in
-upon the current of his thoughts. We had driven several miles,
-and were beginning to get to the fringe of the belt of suburban
-villas, when he shook himself, shrugged his shoulders, and lit up
-his pipe with the air of a man who has satisfied himself that he
-is acting for the best.
-
-"You have a grand gift of silence, Watson," said he. "It makes
-you quite invaluable as a companion. 'Pon my word, it is a great
-thing for me to have someone to talk to, for my own thoughts are
-not over-pleasant. I was wondering what I should say to this dear
-little woman to-night when she meets me at the door."
-
-"You forget that I know nothing about it."
-
-"I shall just have time to tell you the facts of the case before
-we get to Lee. It seems absurdly simple, and yet, somehow I can
-get nothing to go upon. There's plenty of thread, no doubt, but I
-can't get the end of it into my hand. Now, I'll state the case
-clearly and concisely to you, Watson, and maybe you can see a
-spark where all is dark to me."
-
-"Proceed, then."
-
-"Some years ago--to be definite, in May, 1884--there came to Lee
-a gentleman, Neville St. Clair by name, who appeared to have
-plenty of money. He took a large villa, laid out the grounds very
-nicely, and lived generally in good style. By degrees he made
-friends in the neighbourhood, and in 1887 he married the daughter
-of a local brewer, by whom he now has two children. He had no
-occupation, but was interested in several companies and went into
-town as a rule in the morning, returning by the 5:14 from Cannon
-Street every night. Mr. St. Clair is now thirty-seven years of
-age, is a man of temperate habits, a good husband, a very
-affectionate father, and a man who is popular with all who know
-him. I may add that his whole debts at the present moment, as far
-as we have been able to ascertain, amount to 88 pounds 10s., while
-he has 220 pounds standing to his credit in the Capital and
-Counties Bank. There is no reason, therefore, to think that money
-troubles have been weighing upon his mind.
-
-"Last Monday Mr. Neville St. Clair went into town rather earlier
-than usual, remarking before he started that he had two important
-commissions to perform, and that he would bring his little boy
-home a box of bricks. Now, by the merest chance, his wife
-received a telegram upon this same Monday, very shortly after his
-departure, to the effect that a small parcel of considerable
-value which she had been expecting was waiting for her at the
-offices of the Aberdeen Shipping Company. Now, if you are well up
-in your London, you will know that the office of the company is
-in Fresno Street, which branches out of Upper Swandam Lane, where
-you found me to-night. Mrs. St. Clair had her lunch, started for
-the City, did some shopping, proceeded to the company's office,
-got her packet, and found herself at exactly 4:35 walking through
-Swandam Lane on her way back to the station. Have you followed me
-so far?"
-
-"It is very clear."
-
-"If you remember, Monday was an exceedingly hot day, and Mrs. St.
-Clair walked slowly, glancing about in the hope of seeing a cab,
-as she did not like the neighbourhood in which she found herself.
-While she was walking in this way down Swandam Lane, she suddenly
-heard an ejaculation or cry, and was struck cold to see her
-husband looking down at her and, as it seemed to her, beckoning
-to her from a second-floor window. The window was open, and she
-distinctly saw his face, which she describes as being terribly
-agitated. He waved his hands frantically to her, and then
-vanished from the window so suddenly that it seemed to her that
-he had been plucked back by some irresistible force from behind.
-One singular point which struck her quick feminine eye was that
-although he wore some dark coat, such as he had started to town
-in, he had on neither collar nor necktie.
-
-"Convinced that something was amiss with him, she rushed down the
-steps--for the house was none other than the opium den in which
-you found me to-night--and running through the front room she
-attempted to ascend the stairs which led to the first floor. At
-the foot of the stairs, however, she met this Lascar scoundrel of
-whom I have spoken, who thrust her back and, aided by a Dane, who
-acts as assistant there, pushed her out into the street. Filled
-with the most maddening doubts and fears, she rushed down the
-lane and, by rare good-fortune, met in Fresno Street a number of
-constables with an inspector, all on their way to their beat. The
-inspector and two men accompanied her back, and in spite of the
-continued resistance of the proprietor, they made their way to
-the room in which Mr. St. Clair had last been seen. There was no
-sign of him there. In fact, in the whole of that floor there was
-no one to be found save a crippled wretch of hideous aspect, who,
-it seems, made his home there. Both he and the Lascar stoutly
-swore that no one else had been in the front room during the
-afternoon. So determined was their denial that the inspector was
-staggered, and had almost come to believe that Mrs. St. Clair had
-been deluded when, with a cry, she sprang at a small deal box
-which lay upon the table and tore the lid from it. Out there fell
-a cascade of children's bricks. It was the toy which he had
-promised to bring home.
-
-"This discovery, and the evident confusion which the cripple
-showed, made the inspector realise that the matter was serious.
-The rooms were carefully examined, and results all pointed to an
-abominable crime. The front room was plainly furnished as a
-sitting-room and led into a small bedroom, which looked out upon
-the back of one of the wharves. Between the wharf and the bedroom
-window is a narrow strip, which is dry at low tide but is covered
-at high tide with at least four and a half feet of water. The
-bedroom window was a broad one and opened from below. On
-examination traces of blood were to be seen upon the windowsill,
-and several scattered drops were visible upon the wooden floor of
-the bedroom. Thrust away behind a curtain in the front room were
-all the clothes of Mr. Neville St. Clair, with the exception of
-his coat. His boots, his socks, his hat, and his watch--all were
-there. There were no signs of violence upon any of these
-garments, and there were no other traces of Mr. Neville St.
-Clair. Out of the window he must apparently have gone for no
-other exit could be discovered, and the ominous bloodstains upon
-the sill gave little promise that he could save himself by
-swimming, for the tide was at its very highest at the moment of
-the tragedy.
-
-"And now as to the villains who seemed to be immediately
-implicated in the matter. The Lascar was known to be a man of the
-vilest antecedents, but as, by Mrs. St. Clair's story, he was
-known to have been at the foot of the stair within a very few
-seconds of her husband's appearance at the window, he could
-hardly have been more than an accessory to the crime. His defence
-was one of absolute ignorance, and he protested that he had no
-knowledge as to the doings of Hugh Boone, his lodger, and that he
-could not account in any way for the presence of the missing
-gentleman's clothes.
-
-"So much for the Lascar manager. Now for the sinister cripple who
-lives upon the second floor of the opium den, and who was
-certainly the last human being whose eyes rested upon Neville St.
-Clair. His name is Hugh Boone, and his hideous face is one which
-is familiar to every man who goes much to the City. He is a
-professional beggar, though in order to avoid the police
-regulations he pretends to a small trade in wax vestas. Some
-little distance down Threadneedle Street, upon the left-hand
-side, there is, as you may have remarked, a small angle in the
-wall. Here it is that this creature takes his daily seat,
-cross-legged with his tiny stock of matches on his lap, and as he
-is a piteous spectacle a small rain of charity descends into the
-greasy leather cap which lies upon the pavement beside him. I
-have watched the fellow more than once before ever I thought of
-making his professional acquaintance, and I have been surprised
-at the harvest which he has reaped in a short time. His
-appearance, you see, is so remarkable that no one can pass him
-without observing him. A shock of orange hair, a pale face
-disfigured by a horrible scar, which, by its contraction, has
-turned up the outer edge of his upper lip, a bulldog chin, and a
-pair of very penetrating dark eyes, which present a singular
-contrast to the colour of his hair, all mark him out from amid
-the common crowd of mendicants and so, too, does his wit, for he
-is ever ready with a reply to any piece of chaff which may be
-thrown at him by the passers-by. This is the man whom we now
-learn to have been the lodger at the opium den, and to have been
-the last man to see the gentleman of whom we are in quest."
-
-"But a cripple!" said I. "What could he have done single-handed
-against a man in the prime of life?"
-
-"He is a cripple in the sense that he walks with a limp; but in
-other respects he appears to be a powerful and well-nurtured man.
-Surely your medical experience would tell you, Watson, that
-weakness in one limb is often compensated for by exceptional
-strength in the others."
-
-"Pray continue your narrative."
-
-"Mrs. St. Clair had fainted at the sight of the blood upon the
-window, and she was escorted home in a cab by the police, as her
-presence could be of no help to them in their investigations.
-Inspector Barton, who had charge of the case, made a very careful
-examination of the premises, but without finding anything which
-threw any light upon the matter. One mistake had been made in not
-arresting Boone instantly, as he was allowed some few minutes
-during which he might have communicated with his friend the
-Lascar, but this fault was soon remedied, and he was seized and
-searched, without anything being found which could incriminate
-him. There were, it is true, some blood-stains upon his right
-shirt-sleeve, but he pointed to his ring-finger, which had been
-cut near the nail, and explained that the bleeding came from
-there, adding that he had been to the window not long before, and
-that the stains which had been observed there came doubtless from
-the same source. He denied strenuously having ever seen Mr.
-Neville St. Clair and swore that the presence of the clothes in
-his room was as much a mystery to him as to the police. As to
-Mrs. St. Clair's assertion that she had actually seen her husband
-at the window, he declared that she must have been either mad or
-dreaming. He was removed, loudly protesting, to the
-police-station, while the inspector remained upon the premises in
-the hope that the ebbing tide might afford some fresh clue.
-
-"And it did, though they hardly found upon the mud-bank what they
-had feared to find. It was Neville St. Clair's coat, and not
-Neville St. Clair, which lay uncovered as the tide receded. And
-what do you think they found in the pockets?"
-
-"I cannot imagine."
-
-"No, I don't think you would guess. Every pocket stuffed with
-pennies and half-pennies--421 pennies and 270 half-pennies. It
-was no wonder that it had not been swept away by the tide. But a
-human body is a different matter. There is a fierce eddy between
-the wharf and the house. It seemed likely enough that the
-weighted coat had remained when the stripped body had been sucked
-away into the river."
-
-"But I understand that all the other clothes were found in the
-room. Would the body be dressed in a coat alone?"
-
-"No, sir, but the facts might be met speciously enough. Suppose
-that this man Boone had thrust Neville St. Clair through the
-window, there is no human eye which could have seen the deed.
-What would he do then? It would of course instantly strike him
-that he must get rid of the tell-tale garments. He would seize
-the coat, then, and be in the act of throwing it out, when it
-would occur to him that it would swim and not sink. He has little
-time, for he has heard the scuffle downstairs when the wife tried
-to force her way up, and perhaps he has already heard from his
-Lascar confederate that the police are hurrying up the street.
-There is not an instant to be lost. He rushes to some secret
-hoard, where he has accumulated the fruits of his beggary, and he
-stuffs all the coins upon which he can lay his hands into the
-pockets to make sure of the coat's sinking. He throws it out, and
-would have done the same with the other garments had not he heard
-the rush of steps below, and only just had time to close the
-window when the police appeared."
-
-"It certainly sounds feasible."
-
-"Well, we will take it as a working hypothesis for want of a
-better. Boone, as I have told you, was arrested and taken to the
-station, but it could not be shown that there had ever before
-been anything against him. He had for years been known as a
-professional beggar, but his life appeared to have been a very
-quiet and innocent one. There the matter stands at present, and
-the questions which have to be solved--what Neville St. Clair was
-doing in the opium den, what happened to him when there, where is
-he now, and what Hugh Boone had to do with his disappearance--are
-all as far from a solution as ever. I confess that I cannot
-recall any case within my experience which looked at the first
-glance so simple and yet which presented such difficulties."
-
-While Sherlock Holmes had been detailing this singular series of
-events, we had been whirling through the outskirts of the great
-town until the last straggling houses had been left behind, and
-we rattled along with a country hedge upon either side of us.
-Just as he finished, however, we drove through two scattered
-villages, where a few lights still glimmered in the windows.
-
-"We are on the outskirts of Lee," said my companion. "We have
-touched on three English counties in our short drive, starting in
-Middlesex, passing over an angle of Surrey, and ending in Kent.
-See that light among the trees? That is The Cedars, and beside
-that lamp sits a woman whose anxious ears have already, I have
-little doubt, caught the clink of our horse's feet."
-
-"But why are you not conducting the case from Baker Street?" I
-asked.
-
-"Because there are many inquiries which must be made out here.
-Mrs. St. Clair has most kindly put two rooms at my disposal, and
-you may rest assured that she will have nothing but a welcome for
-my friend and colleague. I hate to meet her, Watson, when I have
-no news of her husband. Here we are. Whoa, there, whoa!"
-
-We had pulled up in front of a large villa which stood within its
-own grounds. A stable-boy had run out to the horse's head, and
-springing down, I followed Holmes up the small, winding
-gravel-drive which led to the house. As we approached, the door
-flew open, and a little blonde woman stood in the opening, clad
-in some sort of light mousseline de soie, with a touch of fluffy
-pink chiffon at her neck and wrists. She stood with her figure
-outlined against the flood of light, one hand upon the door, one
-half-raised in her eagerness, her body slightly bent, her head
-and face protruded, with eager eyes and parted lips, a standing
-question.
-
-"Well?" she cried, "well?" And then, seeing that there were two
-of us, she gave a cry of hope which sank into a groan as she saw
-that my companion shook his head and shrugged his shoulders.
-
-"No good news?"
-
-"None."
-
-"No bad?"
-
-"No."
-
-"Thank God for that. But come in. You must be weary, for you have
-had a long day."
-
-"This is my friend, Dr. Watson. He has been of most vital use to
-me in several of my cases, and a lucky chance has made it
-possible for me to bring him out and associate him with this
-investigation."
-
-"I am delighted to see you," said she, pressing my hand warmly.
-"You will, I am sure, forgive anything that may be wanting in our
-arrangements, when you consider the blow which has come so
-suddenly upon us."
-
-"My dear madam," said I, "I am an old campaigner, and if I were
-not I can very well see that no apology is needed. If I can be of
-any assistance, either to you or to my friend here, I shall be
-indeed happy."
-
-"Now, Mr. Sherlock Holmes," said the lady as we entered a
-well-lit dining-room, upon the table of which a cold supper had
-been laid out, "I should very much like to ask you one or two
-plain questions, to which I beg that you will give a plain
-answer."
-
-"Certainly, madam."
-
-"Do not trouble about my feelings. I am not hysterical, nor given
-to fainting. I simply wish to hear your real, real opinion."
-
-"Upon what point?"
-
-"In your heart of hearts, do you think that Neville is alive?"
-
-Sherlock Holmes seemed to be embarrassed by the question.
-"Frankly, now!" she repeated, standing upon the rug and looking
-keenly down at him as he leaned back in a basket-chair.
-
-"Frankly, then, madam, I do not."
-
-"You think that he is dead?"
-
-"I do."
-
-"Murdered?"
-
-"I don't say that. Perhaps."
-
-"And on what day did he meet his death?"
-
-"On Monday."
-
-"Then perhaps, Mr. Holmes, you will be good enough to explain how
-it is that I have received a letter from him to-day."
-
-Sherlock Holmes sprang out of his chair as if he had been
-galvanised.
-
-"What!" he roared.
-
-"Yes, to-day." She stood smiling, holding up a little slip of
-paper in the air.
-
-"May I see it?"
-
-"Certainly."
-
-He snatched it from her in his eagerness, and smoothing it out
-upon the table he drew over the lamp and examined it intently. I
-had left my chair and was gazing at it over his shoulder. The
-envelope was a very coarse one and was stamped with the Gravesend
-postmark and with the date of that very day, or rather of the day
-before, for it was considerably after midnight.
-
-"Coarse writing," murmured Holmes. "Surely this is not your
-husband's writing, madam."
-
-"No, but the enclosure is."
-
-"I perceive also that whoever addressed the envelope had to go
-and inquire as to the address."
-
-"How can you tell that?"
-
-"The name, you see, is in perfectly black ink, which has dried
-itself. The rest is of the greyish colour, which shows that
-blotting-paper has been used. If it had been written straight
-off, and then blotted, none would be of a deep black shade. This
-man has written the name, and there has then been a pause before
-he wrote the address, which can only mean that he was not
-familiar with it. It is, of course, a trifle, but there is
-nothing so important as trifles. Let us now see the letter. Ha!
-there has been an enclosure here!"
-
-"Yes, there was a ring. His signet-ring."
-
-"And you are sure that this is your husband's hand?"
-
-"One of his hands."
-
-"One?"
-
-"His hand when he wrote hurriedly. It is very unlike his usual
-writing, and yet I know it well."
-
-"'Dearest do not be frightened. All will come well. There is a
-huge error which it may take some little time to rectify.
-Wait in patience.--NEVILLE.' Written in pencil upon the fly-leaf
-of a book, octavo size, no water-mark. Hum! Posted to-day in
-Gravesend by a man with a dirty thumb. Ha! And the flap has been
-gummed, if I am not very much in error, by a person who had been
-chewing tobacco. And you have no doubt that it is your husband's
-hand, madam?"
-
-"None. Neville wrote those words."
-
-"And they were posted to-day at Gravesend. Well, Mrs. St. Clair,
-the clouds lighten, though I should not venture to say that the
-danger is over."
-
-"But he must be alive, Mr. Holmes."
-
-"Unless this is a clever forgery to put us on the wrong scent.
-The ring, after all, proves nothing. It may have been taken from
-him."
-
-"No, no; it is, it is his very own writing!"
-
-"Very well. It may, however, have been written on Monday and only
-posted to-day."
-
-"That is possible."
-
-"If so, much may have happened between."
-
-"Oh, you must not discourage me, Mr. Holmes. I know that all is
-well with him. There is so keen a sympathy between us that I
-should know if evil came upon him. On the very day that I saw him
-last he cut himself in the bedroom, and yet I in the dining-room
-rushed upstairs instantly with the utmost certainty that
-something had happened. Do you think that I would respond to such
-a trifle and yet be ignorant of his death?"
-
-"I have seen too much not to know that the impression of a woman
-may be more valuable than the conclusion of an analytical
-reasoner. And in this letter you certainly have a very strong
-piece of evidence to corroborate your view. But if your husband
-is alive and able to write letters, why should he remain away
-from you?"
-
-"I cannot imagine. It is unthinkable."
-
-"And on Monday he made no remarks before leaving you?"
-
-"No."
-
-"And you were surprised to see him in Swandam Lane?"
-
-"Very much so."
-
-"Was the window open?"
-
-"Yes."
-
-"Then he might have called to you?"
-
-"He might."
-
-"He only, as I understand, gave an inarticulate cry?"
-
-"Yes."
-
-"A call for help, you thought?"
-
-"Yes. He waved his hands."
-
-"But it might have been a cry of surprise. Astonishment at the
-unexpected sight of you might cause him to throw up his hands?"
-
-"It is possible."
-
-"And you thought he was pulled back?"
-
-"He disappeared so suddenly."
-
-"He might have leaped back. You did not see anyone else in the
-room?"
-
-"No, but this horrible man confessed to having been there, and
-the Lascar was at the foot of the stairs."
-
-"Quite so. Your husband, as far as you could see, had his
-ordinary clothes on?"
-
-"But without his collar or tie. I distinctly saw his bare
-throat."
-
-"Had he ever spoken of Swandam Lane?"
-
-"Never."
-
-"Had he ever showed any signs of having taken opium?"
-
-"Never."
-
-"Thank you, Mrs. St. Clair. Those are the principal points about
-which I wished to be absolutely clear. We shall now have a little
-supper and then retire, for we may have a very busy day
-to-morrow."
-
-A large and comfortable double-bedded room had been placed at our
-disposal, and I was quickly between the sheets, for I was weary
-after my night of adventure. Sherlock Holmes was a man, however,
-who, when he had an unsolved problem upon his mind, would go for
-days, and even for a week, without rest, turning it over,
-rearranging his facts, looking at it from every point of view
-until he had either fathomed it or convinced himself that his
-data were insufficient. It was soon evident to me that he was now
-preparing for an all-night sitting. He took off his coat and
-waistcoat, put on a large blue dressing-gown, and then wandered
-about the room collecting pillows from his bed and cushions from
-the sofa and armchairs. With these he constructed a sort of
-Eastern divan, upon which he perched himself cross-legged, with
-an ounce of shag tobacco and a box of matches laid out in front
-of him. In the dim light of the lamp I saw him sitting there, an
-old briar pipe between his lips, his eyes fixed vacantly upon the
-corner of the ceiling, the blue smoke curling up from him,
-silent, motionless, with the light shining upon his strong-set
-aquiline features. So he sat as I dropped off to sleep, and so he
-sat when a sudden ejaculation caused me to wake up, and I found
-the summer sun shining into the apartment. The pipe was still
-between his lips, the smoke still curled upward, and the room was
-full of a dense tobacco haze, but nothing remained of the heap of
-shag which I had seen upon the previous night.
-
-"Awake, Watson?" he asked.
-
-"Yes."
-
-"Game for a morning drive?"
-
-"Certainly."
-
-"Then dress. No one is stirring yet, but I know where the
-stable-boy sleeps, and we shall soon have the trap out." He
-chuckled to himself as he spoke, his eyes twinkled, and he seemed
-a different man to the sombre thinker of the previous night.
-
-As I dressed I glanced at my watch. It was no wonder that no one
-was stirring. It was twenty-five minutes past four. I had hardly
-finished when Holmes returned with the news that the boy was
-putting in the horse.
-
-"I want to test a little theory of mine," said he, pulling on his
-boots. "I think, Watson, that you are now standing in the
-presence of one of the most absolute fools in Europe. I deserve
-to be kicked from here to Charing Cross. But I think I have the
-key of the affair now."
-
-"And where is it?" I asked, smiling.
-
-"In the bathroom," he answered. "Oh, yes, I am not joking," he
-continued, seeing my look of incredulity. "I have just been
-there, and I have taken it out, and I have got it in this
-Gladstone bag. Come on, my boy, and we shall see whether it will
-not fit the lock."
-
-We made our way downstairs as quietly as possible, and out into
-the bright morning sunshine. In the road stood our horse and
-trap, with the half-clad stable-boy waiting at the head. We both
-sprang in, and away we dashed down the London Road. A few country
-carts were stirring, bearing in vegetables to the metropolis, but
-the lines of villas on either side were as silent and lifeless as
-some city in a dream.
-
-"It has been in some points a singular case," said Holmes,
-flicking the horse on into a gallop. "I confess that I have been
-as blind as a mole, but it is better to learn wisdom late than
-never to learn it at all."
-
-In town the earliest risers were just beginning to look sleepily
-from their windows as we drove through the streets of the Surrey
-side. Passing down the Waterloo Bridge Road we crossed over the
-river, and dashing up Wellington Street wheeled sharply to the
-right and found ourselves in Bow Street. Sherlock Holmes was well
-known to the force, and the two constables at the door saluted
-him. One of them held the horse's head while the other led us in.
-
-"Who is on duty?" asked Holmes.
-
-"Inspector Bradstreet, sir."
-
-"Ah, Bradstreet, how are you?" A tall, stout official had come
-down the stone-flagged passage, in a peaked cap and frogged
-jacket. "I wish to have a quiet word with you, Bradstreet."
-"Certainly, Mr. Holmes. Step into my room here." It was a small,
-office-like room, with a huge ledger upon the table, and a
-telephone projecting from the wall. The inspector sat down at his
-desk.
-
-"What can I do for you, Mr. Holmes?"
-
-"I called about that beggarman, Boone--the one who was charged
-with being concerned in the disappearance of Mr. Neville St.
-Clair, of Lee."
-
-"Yes. He was brought up and remanded for further inquiries."
-
-"So I heard. You have him here?"
-
-"In the cells."
-
-"Is he quiet?"
-
-"Oh, he gives no trouble. But he is a dirty scoundrel."
-
-"Dirty?"
-
-"Yes, it is all we can do to make him wash his hands, and his
-face is as black as a tinker's. Well, when once his case has been
-settled, he will have a regular prison bath; and I think, if you
-saw him, you would agree with me that he needed it."
-
-"I should like to see him very much."
-
-"Would you? That is easily done. Come this way. You can leave
-your bag."
-
-"No, I think that I'll take it."
-
-"Very good. Come this way, if you please." He led us down a
-passage, opened a barred door, passed down a winding stair, and
-brought us to a whitewashed corridor with a line of doors on each
-side.
-
-"The third on the right is his," said the inspector. "Here it
-is!" He quietly shot back a panel in the upper part of the door
-and glanced through.
-
-"He is asleep," said he. "You can see him very well."
-
-We both put our eyes to the grating. The prisoner lay with his
-face towards us, in a very deep sleep, breathing slowly and
-heavily. He was a middle-sized man, coarsely clad as became his
-calling, with a coloured shirt protruding through the rent in his
-tattered coat. He was, as the inspector had said, extremely
-dirty, but the grime which covered his face could not conceal its
-repulsive ugliness. A broad wheal from an old scar ran right
-across it from eye to chin, and by its contraction had turned up
-one side of the upper lip, so that three teeth were exposed in a
-perpetual snarl. A shock of very bright red hair grew low over
-his eyes and forehead.
-
-"He's a beauty, isn't he?" said the inspector.
-
-"He certainly needs a wash," remarked Holmes. "I had an idea that
-he might, and I took the liberty of bringing the tools with me."
-He opened the Gladstone bag as he spoke, and took out, to my
-astonishment, a very large bath-sponge.
-
-"He! he! You are a funny one," chuckled the inspector.
-
-"Now, if you will have the great goodness to open that door very
-quietly, we will soon make him cut a much more respectable
-figure."
-
-"Well, I don't know why not," said the inspector. "He doesn't
-look a credit to the Bow Street cells, does he?" He slipped his
-key into the lock, and we all very quietly entered the cell. The
-sleeper half turned, and then settled down once more into a deep
-slumber. Holmes stooped to the water-jug, moistened his sponge,
-and then rubbed it twice vigorously across and down the
-prisoner's face.
-
-"Let me introduce you," he shouted, "to Mr. Neville St. Clair, of
-Lee, in the county of Kent."
-
-Never in my life have I seen such a sight. The man's face peeled
-off under the sponge like the bark from a tree. Gone was the
-coarse brown tint! Gone, too, was the horrid scar which had
-seamed it across, and the twisted lip which had given the
-repulsive sneer to the face! A twitch brought away the tangled
-red hair, and there, sitting up in his bed, was a pale,
-sad-faced, refined-looking man, black-haired and smooth-skinned,
-rubbing his eyes and staring about him with sleepy bewilderment.
-Then suddenly realising the exposure, he broke into a scream and
-threw himself down with his face to the pillow.
-
-"Great heavens!" cried the inspector, "it is, indeed, the missing
-man. I know him from the photograph."
-
-The prisoner turned with the reckless air of a man who abandons
-himself to his destiny. "Be it so," said he. "And pray what am I
-charged with?"
-
-"With making away with Mr. Neville St.-- Oh, come, you can't be
-charged with that unless they make a case of attempted suicide of
-it," said the inspector with a grin. "Well, I have been
-twenty-seven years in the force, but this really takes the cake."
-
-"If I am Mr. Neville St. Clair, then it is obvious that no crime
-has been committed, and that, therefore, I am illegally
-detained."
-
-"No crime, but a very great error has been committed," said
-Holmes. "You would have done better to have trusted your wife."
-
-"It was not the wife; it was the children," groaned the prisoner.
-"God help me, I would not have them ashamed of their father. My
-God! What an exposure! What can I do?"
-
-Sherlock Holmes sat down beside him on the couch and patted him
-kindly on the shoulder.
-
-"If you leave it to a court of law to clear the matter up," said
-he, "of course you can hardly avoid publicity. On the other hand,
-if you convince the police authorities that there is no possible
-case against you, I do not know that there is any reason that the
-details should find their way into the papers. Inspector
-Bradstreet would, I am sure, make notes upon anything which you
-might tell us and submit it to the proper authorities. The case
-would then never go into court at all."
-
-"God bless you!" cried the prisoner passionately. "I would have
-endured imprisonment, ay, even execution, rather than have left
-my miserable secret as a family blot to my children.
-
-"You are the first who have ever heard my story. My father was a
-schoolmaster in Chesterfield, where I received an excellent
-education. I travelled in my youth, took to the stage, and
-finally became a reporter on an evening paper in London. One day
-my editor wished to have a series of articles upon begging in the
-metropolis, and I volunteered to supply them. There was the point
-from which all my adventures started. It was only by trying
-begging as an amateur that I could get the facts upon which to
-base my articles. When an actor I had, of course, learned all the
-secrets of making up, and had been famous in the green-room for
-my skill. I took advantage now of my attainments. I painted my
-face, and to make myself as pitiable as possible I made a good
-scar and fixed one side of my lip in a twist by the aid of a
-small slip of flesh-coloured plaster. Then with a red head of
-hair, and an appropriate dress, I took my station in the business
-part of the city, ostensibly as a match-seller but really as a
-beggar. For seven hours I plied my trade, and when I returned
-home in the evening I found to my surprise that I had received no
-less than 26s. 4d.
-
-"I wrote my articles and thought little more of the matter until,
-some time later, I backed a bill for a friend and had a writ
-served upon me for 25 pounds. I was at my wit's end where to get
-the money, but a sudden idea came to me. I begged a fortnight's
-grace from the creditor, asked for a holiday from my employers,
-and spent the time in begging in the City under my disguise. In
-ten days I had the money and had paid the debt.
-
-"Well, you can imagine how hard it was to settle down to arduous
-work at 2 pounds a week when I knew that I could earn as much in
-a day by smearing my face with a little paint, laying my cap on
-the ground, and sitting still. It was a long fight between my
-pride and the money, but the dollars won at last, and I threw up
-reporting and sat day after day in the corner which I had first
-chosen, inspiring pity by my ghastly face and filling my pockets
-with coppers. Only one man knew my secret. He was the keeper of a
-low den in which I used to lodge in Swandam Lane, where I could
-every morning emerge as a squalid beggar and in the evenings
-transform myself into a well-dressed man about town. This fellow,
-a Lascar, was well paid by me for his rooms, so that I knew that
-my secret was safe in his possession.
-
-"Well, very soon I found that I was saving considerable sums of
-money. I do not mean that any beggar in the streets of London
-could earn 700 pounds a year--which is less than my average
-takings--but I had exceptional advantages in my power of making
-up, and also in a facility of repartee, which improved by
-practice and made me quite a recognised character in the City.
-All day a stream of pennies, varied by silver, poured in upon me,
-and it was a very bad day in which I failed to take 2 pounds.
-
-"As I grew richer I grew more ambitious, took a house in the
-country, and eventually married, without anyone having a
-suspicion as to my real occupation. My dear wife knew that I had
-business in the City. She little knew what.
-
-"Last Monday I had finished for the day and was dressing in my
-room above the opium den when I looked out of my window and saw,
-to my horror and astonishment, that my wife was standing in the
-street, with her eyes fixed full upon me. I gave a cry of
-surprise, threw up my arms to cover my face, and, rushing to my
-confidant, the Lascar, entreated him to prevent anyone from
-coming up to me. I heard her voice downstairs, but I knew that
-she could not ascend. Swiftly I threw off my clothes, pulled on
-those of a beggar, and put on my pigments and wig. Even a wife's
-eyes could not pierce so complete a disguise. But then it
-occurred to me that there might be a search in the room, and that
-the clothes might betray me. I threw open the window, reopening
-by my violence a small cut which I had inflicted upon myself in
-the bedroom that morning. Then I seized my coat, which was
-weighted by the coppers which I had just transferred to it from
-the leather bag in which I carried my takings. I hurled it out of
-the window, and it disappeared into the Thames. The other clothes
-would have followed, but at that moment there was a rush of
-constables up the stair, and a few minutes after I found, rather,
-I confess, to my relief, that instead of being identified as Mr.
-Neville St. Clair, I was arrested as his murderer.
-
-"I do not know that there is anything else for me to explain. I
-was determined to preserve my disguise as long as possible, and
-hence my preference for a dirty face. Knowing that my wife would
-be terribly anxious, I slipped off my ring and confided it to the
-Lascar at a moment when no constable was watching me, together
-with a hurried scrawl, telling her that she had no cause to
-fear."
-
-"That note only reached her yesterday," said Holmes.
-
-"Good God! What a week she must have spent!"
-
-"The police have watched this Lascar," said Inspector Bradstreet,
-"and I can quite understand that he might find it difficult to
-post a letter unobserved. Probably he handed it to some sailor
-customer of his, who forgot all about it for some days."
-
-"That was it," said Holmes, nodding approvingly; "I have no doubt
-of it. But have you never been prosecuted for begging?"
-
-"Many times; but what was a fine to me?"
-
-"It must stop here, however," said Bradstreet. "If the police are
-to hush this thing up, there must be no more of Hugh Boone."
-
-"I have sworn it by the most solemn oaths which a man can take."
-
-"In that case I think that it is probable that no further steps
-may be taken. But if you are found again, then all must come out.
-I am sure, Mr. Holmes, that we are very much indebted to you for
-having cleared the matter up. I wish I knew how you reach your
-results."
-
-"I reached this one," said my friend, "by sitting upon five
-pillows and consuming an ounce of shag. I think, Watson, that if
-we drive to Baker Street we shall just be in time for breakfast."
-
-
-
-VII. THE ADVENTURE OF THE BLUE CARBUNCLE
-
-I had called upon my friend Sherlock Holmes upon the second
-morning after Christmas, with the intention of wishing him the
-compliments of the season. He was lounging upon the sofa in a
-purple dressing-gown, a pipe-rack within his reach upon the
-right, and a pile of crumpled morning papers, evidently newly
-studied, near at hand. Beside the couch was a wooden chair, and
-on the angle of the back hung a very seedy and disreputable
-hard-felt hat, much the worse for wear, and cracked in several
-places. A lens and a forceps lying upon the seat of the chair
-suggested that the hat had been suspended in this manner for the
-purpose of examination.
-
-"You are engaged," said I; "perhaps I interrupt you."
-
-"Not at all. I am glad to have a friend with whom I can discuss
-my results. The matter is a perfectly trivial one"--he jerked his
-thumb in the direction of the old hat--"but there are points in
-connection with it which are not entirely devoid of interest and
-even of instruction."
-
-I seated myself in his armchair and warmed my hands before his
-crackling fire, for a sharp frost had set in, and the windows
-were thick with the ice crystals. "I suppose," I remarked, "that,
-homely as it looks, this thing has some deadly story linked on to
-it--that it is the clue which will guide you in the solution of
-some mystery and the punishment of some crime."
-
-"No, no. No crime," said Sherlock Holmes, laughing. "Only one of
-those whimsical little incidents which will happen when you have
-four million human beings all jostling each other within the
-space of a few square miles. Amid the action and reaction of so
-dense a swarm of humanity, every possible combination of events
-may be expected to take place, and many a little problem will be
-presented which may be striking and bizarre without being
-criminal. We have already had experience of such."
-
-"So much so," I remarked, "that of the last six cases which I
-have added to my notes, three have been entirely free of any
-legal crime."
-
-"Precisely. You allude to my attempt to recover the Irene Adler
-papers, to the singular case of Miss Mary Sutherland, and to the
-adventure of the man with the twisted lip. Well, I have no doubt
-that this small matter will fall into the same innocent category.
-You know Peterson, the commissionaire?"
-
-"Yes."
-
-"It is to him that this trophy belongs."
-
-"It is his hat."
-
-"No, no, he found it. Its owner is unknown. I beg that you will
-look upon it not as a battered billycock but as an intellectual
-problem. And, first, as to how it came here. It arrived upon
-Christmas morning, in company with a good fat goose, which is, I
-have no doubt, roasting at this moment in front of Peterson's
-fire. The facts are these: about four o'clock on Christmas
-morning, Peterson, who, as you know, is a very honest fellow, was
-returning from some small jollification and was making his way
-homeward down Tottenham Court Road. In front of him he saw, in
-the gaslight, a tallish man, walking with a slight stagger, and
-carrying a white goose slung over his shoulder. As he reached the
-corner of Goodge Street, a row broke out between this stranger
-and a little knot of roughs. One of the latter knocked off the
-man's hat, on which he raised his stick to defend himself and,
-swinging it over his head, smashed the shop window behind him.
-Peterson had rushed forward to protect the stranger from his
-assailants; but the man, shocked at having broken the window, and
-seeing an official-looking person in uniform rushing towards him,
-dropped his goose, took to his heels, and vanished amid the
-labyrinth of small streets which lie at the back of Tottenham
-Court Road. The roughs had also fled at the appearance of
-Peterson, so that he was left in possession of the field of
-battle, and also of the spoils of victory in the shape of this
-battered hat and a most unimpeachable Christmas goose."
-
-"Which surely he restored to their owner?"
-
-"My dear fellow, there lies the problem. It is true that 'For
-Mrs. Henry Baker' was printed upon a small card which was tied to
-the bird's left leg, and it is also true that the initials 'H.
-B.' are legible upon the lining of this hat, but as there are
-some thousands of Bakers, and some hundreds of Henry Bakers in
-this city of ours, it is not easy to restore lost property to any
-one of them."
-
-"What, then, did Peterson do?"
-
-"He brought round both hat and goose to me on Christmas morning,
-knowing that even the smallest problems are of interest to me.
-The goose we retained until this morning, when there were signs
-that, in spite of the slight frost, it would be well that it
-should be eaten without unnecessary delay. Its finder has carried
-it off, therefore, to fulfil the ultimate destiny of a goose,
-while I continue to retain the hat of the unknown gentleman who
-lost his Christmas dinner."
-
-"Did he not advertise?"
-
-"No."
-
-"Then, what clue could you have as to his identity?"
-
-"Only as much as we can deduce."
-
-"From his hat?"
-
-"Precisely."
-
-"But you are joking. What can you gather from this old battered
-felt?"
-
-"Here is my lens. You know my methods. What can you gather
-yourself as to the individuality of the man who has worn this
-article?"
-
-I took the tattered object in my hands and turned it over rather
-ruefully. It was a very ordinary black hat of the usual round
-shape, hard and much the worse for wear. The lining had been of
-red silk, but was a good deal discoloured. There was no maker's
-name; but, as Holmes had remarked, the initials "H. B." were
-scrawled upon one side. It was pierced in the brim for a
-hat-securer, but the elastic was missing. For the rest, it was
-cracked, exceedingly dusty, and spotted in several places,
-although there seemed to have been some attempt to hide the
-discoloured patches by smearing them with ink.
-
-"I can see nothing," said I, handing it back to my friend.
-
-"On the contrary, Watson, you can see everything. You fail,
-however, to reason from what you see. You are too timid in
-drawing your inferences."
-
-"Then, pray tell me what it is that you can infer from this hat?"
-
-He picked it up and gazed at it in the peculiar introspective
-fashion which was characteristic of him. "It is perhaps less
-suggestive than it might have been," he remarked, "and yet there
-are a few inferences which are very distinct, and a few others
-which represent at least a strong balance of probability. That
-the man was highly intellectual is of course obvious upon the
-face of it, and also that he was fairly well-to-do within the
-last three years, although he has now fallen upon evil days. He
-had foresight, but has less now than formerly, pointing to a
-moral retrogression, which, when taken with the decline of his
-fortunes, seems to indicate some evil influence, probably drink,
-at work upon him. This may account also for the obvious fact that
-his wife has ceased to love him."
-
-"My dear Holmes!"
-
-"He has, however, retained some degree of self-respect," he
-continued, disregarding my remonstrance. "He is a man who leads a
-sedentary life, goes out little, is out of training entirely, is
-middle-aged, has grizzled hair which he has had cut within the
-last few days, and which he anoints with lime-cream. These are
-the more patent facts which are to be deduced from his hat. Also,
-by the way, that it is extremely improbable that he has gas laid
-on in his house."
-
-"You are certainly joking, Holmes."
-
-"Not in the least. Is it possible that even now, when I give you
-these results, you are unable to see how they are attained?"
-
-"I have no doubt that I am very stupid, but I must confess that I
-am unable to follow you. For example, how did you deduce that
-this man was intellectual?"
-
-For answer Holmes clapped the hat upon his head. It came right
-over the forehead and settled upon the bridge of his nose. "It is
-a question of cubic capacity," said he; "a man with so large a
-brain must have something in it."
-
-"The decline of his fortunes, then?"
-
-"This hat is three years old. These flat brims curled at the edge
-came in then. It is a hat of the very best quality. Look at the
-band of ribbed silk and the excellent lining. If this man could
-afford to buy so expensive a hat three years ago, and has had no
-hat since, then he has assuredly gone down in the world."
-
-"Well, that is clear enough, certainly. But how about the
-foresight and the moral retrogression?"
-
-Sherlock Holmes laughed. "Here is the foresight," said he putting
-his finger upon the little disc and loop of the hat-securer.
-"They are never sold upon hats. If this man ordered one, it is a
-sign of a certain amount of foresight, since he went out of his
-way to take this precaution against the wind. But since we see
-that he has broken the elastic and has not troubled to replace
-it, it is obvious that he has less foresight now than formerly,
-which is a distinct proof of a weakening nature. On the other
-hand, he has endeavoured to conceal some of these stains upon the
-felt by daubing them with ink, which is a sign that he has not
-entirely lost his self-respect."
-
-"Your reasoning is certainly plausible."
-
-"The further points, that he is middle-aged, that his hair is
-grizzled, that it has been recently cut, and that he uses
-lime-cream, are all to be gathered from a close examination of the
-lower part of the lining. The lens discloses a large number of
-hair-ends, clean cut by the scissors of the barber. They all
-appear to be adhesive, and there is a distinct odour of
-lime-cream. This dust, you will observe, is not the gritty, grey
-dust of the street but the fluffy brown dust of the house,
-showing that it has been hung up indoors most of the time, while
-the marks of moisture upon the inside are proof positive that the
-wearer perspired very freely, and could therefore, hardly be in
-the best of training."
-
-"But his wife--you said that she had ceased to love him."
-
-"This hat has not been brushed for weeks. When I see you, my dear
-Watson, with a week's accumulation of dust upon your hat, and
-when your wife allows you to go out in such a state, I shall fear
-that you also have been unfortunate enough to lose your wife's
-affection."
-
-"But he might be a bachelor."
-
-"Nay, he was bringing home the goose as a peace-offering to his
-wife. Remember the card upon the bird's leg."
-
-"You have an answer to everything. But how on earth do you deduce
-that the gas is not laid on in his house?"
-
-"One tallow stain, or even two, might come by chance; but when I
-see no less than five, I think that there can be little doubt
-that the individual must be brought into frequent contact with
-burning tallow--walks upstairs at night probably with his hat in
-one hand and a guttering candle in the other. Anyhow, he never
-got tallow-stains from a gas-jet. Are you satisfied?"
-
-"Well, it is very ingenious," said I, laughing; "but since, as
-you said just now, there has been no crime committed, and no harm
-done save the loss of a goose, all this seems to be rather a
-waste of energy."
-
-Sherlock Holmes had opened his mouth to reply, when the door flew
-open, and Peterson, the commissionaire, rushed into the apartment
-with flushed cheeks and the face of a man who is dazed with
-astonishment.
-
-"The goose, Mr. Holmes! The goose, sir!" he gasped.
-
-"Eh? What of it, then? Has it returned to life and flapped off
-through the kitchen window?" Holmes twisted himself round upon
-the sofa to get a fairer view of the man's excited face.
-
-"See here, sir! See what my wife found in its crop!" He held out
-his hand and displayed upon the centre of the palm a brilliantly
-scintillating blue stone, rather smaller than a bean in size, but
-of such purity and radiance that it twinkled like an electric
-point in the dark hollow of his hand.
-
-Sherlock Holmes sat up with a whistle. "By Jove, Peterson!" said
-he, "this is treasure trove indeed. I suppose you know what you
-have got?"
-
-"A diamond, sir? A precious stone. It cuts into glass as though
-it were putty."
-
-"It's more than a precious stone. It is the precious stone."
-
-"Not the Countess of Morcar's blue carbuncle!" I ejaculated.
-
-"Precisely so. I ought to know its size and shape, seeing that I
-have read the advertisement about it in The Times every day
-lately. It is absolutely unique, and its value can only be
-conjectured, but the reward offered of 1000 pounds is certainly
-not within a twentieth part of the market price."
-
-"A thousand pounds! Great Lord of mercy!" The commissionaire
-plumped down into a chair and stared from one to the other of us.
-
-"That is the reward, and I have reason to know that there are
-sentimental considerations in the background which would induce
-the Countess to part with half her fortune if she could but
-recover the gem."
-
-"It was lost, if I remember aright, at the Hotel Cosmopolitan," I
-remarked.
-
-"Precisely so, on December 22nd, just five days ago. John Horner,
-a plumber, was accused of having abstracted it from the lady's
-jewel-case. The evidence against him was so strong that the case
-has been referred to the Assizes. I have some account of the
-matter here, I believe." He rummaged amid his newspapers,
-glancing over the dates, until at last he smoothed one out,
-doubled it over, and read the following paragraph:
-
-"Hotel Cosmopolitan Jewel Robbery. John Horner, 26, plumber, was
-brought up upon the charge of having upon the 22nd inst.,
-abstracted from the jewel-case of the Countess of Morcar the
-valuable gem known as the blue carbuncle. James Ryder,
-upper-attendant at the hotel, gave his evidence to the effect
-that he had shown Horner up to the dressing-room of the Countess
-of Morcar upon the day of the robbery in order that he might
-solder the second bar of the grate, which was loose. He had
-remained with Horner some little time, but had finally been
-called away. On returning, he found that Horner had disappeared,
-that the bureau had been forced open, and that the small morocco
-casket in which, as it afterwards transpired, the Countess was
-accustomed to keep her jewel, was lying empty upon the
-dressing-table. Ryder instantly gave the alarm, and Horner was
-arrested the same evening; but the stone could not be found
-either upon his person or in his rooms. Catherine Cusack, maid to
-the Countess, deposed to having heard Ryder's cry of dismay on
-discovering the robbery, and to having rushed into the room,
-where she found matters as described by the last witness.
-Inspector Bradstreet, B division, gave evidence as to the arrest
-of Horner, who struggled frantically, and protested his innocence
-in the strongest terms. Evidence of a previous conviction for
-robbery having been given against the prisoner, the magistrate
-refused to deal summarily with the offence, but referred it to
-the Assizes. Horner, who had shown signs of intense emotion
-during the proceedings, fainted away at the conclusion and was
-carried out of court."
-
-"Hum! So much for the police-court," said Holmes thoughtfully,
-tossing aside the paper. "The question for us now to solve is the
-sequence of events leading from a rifled jewel-case at one end to
-the crop of a goose in Tottenham Court Road at the other. You
-see, Watson, our little deductions have suddenly assumed a much
-more important and less innocent aspect. Here is the stone; the
-stone came from the goose, and the goose came from Mr. Henry
-Baker, the gentleman with the bad hat and all the other
-characteristics with which I have bored you. So now we must set
-ourselves very seriously to finding this gentleman and
-ascertaining what part he has played in this little mystery. To
-do this, we must try the simplest means first, and these lie
-undoubtedly in an advertisement in all the evening papers. If
-this fail, I shall have recourse to other methods."
-
-"What will you say?"
-
-"Give me a pencil and that slip of paper. Now, then: 'Found at
-the corner of Goodge Street, a goose and a black felt hat. Mr.
-Henry Baker can have the same by applying at 6:30 this evening at
-221B, Baker Street.' That is clear and concise."
-
-"Very. But will he see it?"
-
-"Well, he is sure to keep an eye on the papers, since, to a poor
-man, the loss was a heavy one. He was clearly so scared by his
-mischance in breaking the window and by the approach of Peterson
-that he thought of nothing but flight, but since then he must
-have bitterly regretted the impulse which caused him to drop his
-bird. Then, again, the introduction of his name will cause him to
-see it, for everyone who knows him will direct his attention to
-it. Here you are, Peterson, run down to the advertising agency
-and have this put in the evening papers."
-
-"In which, sir?"
-
-"Oh, in the Globe, Star, Pall Mall, St. James's, Evening News,
-Standard, Echo, and any others that occur to you."
-
-"Very well, sir. And this stone?"
-
-"Ah, yes, I shall keep the stone. Thank you. And, I say,
-Peterson, just buy a goose on your way back and leave it here
-with me, for we must have one to give to this gentleman in place
-of the one which your family is now devouring."
-
-When the commissionaire had gone, Holmes took up the stone and
-held it against the light. "It's a bonny thing," said he. "Just
-see how it glints and sparkles. Of course it is a nucleus and
-focus of crime. Every good stone is. They are the devil's pet
-baits. In the larger and older jewels every facet may stand for a
-bloody deed. This stone is not yet twenty years old. It was found
-in the banks of the Amoy River in southern China and is remarkable
-in having every characteristic of the carbuncle, save that it is
-blue in shade instead of ruby red. In spite of its youth, it has
-already a sinister history. There have been two murders, a
-vitriol-throwing, a suicide, and several robberies brought about
-for the sake of this forty-grain weight of crystallised charcoal.
-Who would think that so pretty a toy would be a purveyor to the
-gallows and the prison? I'll lock it up in my strong box now and
-drop a line to the Countess to say that we have it."
-
-"Do you think that this man Horner is innocent?"
-
-"I cannot tell."
-
-"Well, then, do you imagine that this other one, Henry Baker, had
-anything to do with the matter?"
-
-"It is, I think, much more likely that Henry Baker is an
-absolutely innocent man, who had no idea that the bird which he
-was carrying was of considerably more value than if it were made
-of solid gold. That, however, I shall determine by a very simple
-test if we have an answer to our advertisement."
-
-"And you can do nothing until then?"
-
-"Nothing."
-
-"In that case I shall continue my professional round. But I shall
-come back in the evening at the hour you have mentioned, for I
-should like to see the solution of so tangled a business."
-
-"Very glad to see you. I dine at seven. There is a woodcock, I
-believe. By the way, in view of recent occurrences, perhaps I
-ought to ask Mrs. Hudson to examine its crop."
-
-I had been delayed at a case, and it was a little after half-past
-six when I found myself in Baker Street once more. As I
-approached the house I saw a tall man in a Scotch bonnet with a
-coat which was buttoned up to his chin waiting outside in the
-bright semicircle which was thrown from the fanlight. Just as I
-arrived the door was opened, and we were shown up together to
-Holmes' room.
-
-"Mr. Henry Baker, I believe," said he, rising from his armchair
-and greeting his visitor with the easy air of geniality which he
-could so readily assume. "Pray take this chair by the fire, Mr.
-Baker. It is a cold night, and I observe that your circulation is
-more adapted for summer than for winter. Ah, Watson, you have
-just come at the right time. Is that your hat, Mr. Baker?"
-
-"Yes, sir, that is undoubtedly my hat."
-
-He was a large man with rounded shoulders, a massive head, and a
-broad, intelligent face, sloping down to a pointed beard of
-grizzled brown. A touch of red in nose and cheeks, with a slight
-tremor of his extended hand, recalled Holmes' surmise as to his
-habits. His rusty black frock-coat was buttoned right up in
-front, with the collar turned up, and his lank wrists protruded
-from his sleeves without a sign of cuff or shirt. He spoke in a
-slow staccato fashion, choosing his words with care, and gave the
-impression generally of a man of learning and letters who had had
-ill-usage at the hands of fortune.
-
-"We have retained these things for some days," said Holmes,
-"because we expected to see an advertisement from you giving your
-address. I am at a loss to know now why you did not advertise."
-
-Our visitor gave a rather shamefaced laugh. "Shillings have not
-been so plentiful with me as they once were," he remarked. "I had
-no doubt that the gang of roughs who assaulted me had carried off
-both my hat and the bird. I did not care to spend more money in a
-hopeless attempt at recovering them."
-
-"Very naturally. By the way, about the bird, we were compelled to
-eat it."
-
-"To eat it!" Our visitor half rose from his chair in his
-excitement.
-
-"Yes, it would have been of no use to anyone had we not done so.
-But I presume that this other goose upon the sideboard, which is
-about the same weight and perfectly fresh, will answer your
-purpose equally well?"
-
-"Oh, certainly, certainly," answered Mr. Baker with a sigh of
-relief.
-
-"Of course, we still have the feathers, legs, crop, and so on of
-your own bird, so if you wish--"
-
-The man burst into a hearty laugh. "They might be useful to me as
-relics of my adventure," said he, "but beyond that I can hardly
-see what use the disjecta membra of my late acquaintance are
-going to be to me. No, sir, I think that, with your permission, I
-will confine my attentions to the excellent bird which I perceive
-upon the sideboard."
-
-Sherlock Holmes glanced sharply across at me with a slight shrug
-of his shoulders.
-
-"There is your hat, then, and there your bird," said he. "By the
-way, would it bore you to tell me where you got the other one
-from? I am somewhat of a fowl fancier, and I have seldom seen a
-better grown goose."
-
-"Certainly, sir," said Baker, who had risen and tucked his newly
-gained property under his arm. "There are a few of us who
-frequent the Alpha Inn, near the Museum--we are to be found in
-the Museum itself during the day, you understand. This year our
-good host, Windigate by name, instituted a goose club, by which,
-on consideration of some few pence every week, we were each to
-receive a bird at Christmas. My pence were duly paid, and the
-rest is familiar to you. I am much indebted to you, sir, for a
-Scotch bonnet is fitted neither to my years nor my gravity." With
-a comical pomposity of manner he bowed solemnly to both of us and
-strode off upon his way.
-
-"So much for Mr. Henry Baker," said Holmes when he had closed the
-door behind him. "It is quite certain that he knows nothing
-whatever about the matter. Are you hungry, Watson?"
-
-"Not particularly."
-
-"Then I suggest that we turn our dinner into a supper and follow
-up this clue while it is still hot."
-
-"By all means."
-
-It was a bitter night, so we drew on our ulsters and wrapped
-cravats about our throats. Outside, the stars were shining coldly
-in a cloudless sky, and the breath of the passers-by blew out
-into smoke like so many pistol shots. Our footfalls rang out
-crisply and loudly as we swung through the doctors' quarter,
-Wimpole Street, Harley Street, and so through Wigmore Street into
-Oxford Street. In a quarter of an hour we were in Bloomsbury at
-the Alpha Inn, which is a small public-house at the corner of one
-of the streets which runs down into Holborn. Holmes pushed open
-the door of the private bar and ordered two glasses of beer from
-the ruddy-faced, white-aproned landlord.
-
-"Your beer should be excellent if it is as good as your geese,"
-said he.
-
-"My geese!" The man seemed surprised.
-
-"Yes. I was speaking only half an hour ago to Mr. Henry Baker,
-who was a member of your goose club."
-
-"Ah! yes, I see. But you see, sir, them's not our geese."
-
-"Indeed! Whose, then?"
-
-"Well, I got the two dozen from a salesman in Covent Garden."
-
-"Indeed? I know some of them. Which was it?"
-
-"Breckinridge is his name."
-
-"Ah! I don't know him. Well, here's your good health landlord,
-and prosperity to your house. Good-night."
-
-"Now for Mr. Breckinridge," he continued, buttoning up his coat
-as we came out into the frosty air. "Remember, Watson that though
-we have so homely a thing as a goose at one end of this chain, we
-have at the other a man who will certainly get seven years' penal
-servitude unless we can establish his innocence. It is possible
-that our inquiry may but confirm his guilt; but, in any case, we
-have a line of investigation which has been missed by the police,
-and which a singular chance has placed in our hands. Let us
-follow it out to the bitter end. Faces to the south, then, and
-quick march!"
-
-We passed across Holborn, down Endell Street, and so through a
-zigzag of slums to Covent Garden Market. One of the largest
-stalls bore the name of Breckinridge upon it, and the proprietor
-a horsey-looking man, with a sharp face and trim side-whiskers was
-helping a boy to put up the shutters.
-
-"Good-evening. It's a cold night," said Holmes.
-
-The salesman nodded and shot a questioning glance at my
-companion.
-
-"Sold out of geese, I see," continued Holmes, pointing at the
-bare slabs of marble.
-
-"Let you have five hundred to-morrow morning."
-
-"That's no good."
-
-"Well, there are some on the stall with the gas-flare."
-
-"Ah, but I was recommended to you."
-
-"Who by?"
-
-"The landlord of the Alpha."
-
-"Oh, yes; I sent him a couple of dozen."
-
-"Fine birds they were, too. Now where did you get them from?"
-
-To my surprise the question provoked a burst of anger from the
-salesman.
-
-"Now, then, mister," said he, with his head cocked and his arms
-akimbo, "what are you driving at? Let's have it straight, now."
-
-"It is straight enough. I should like to know who sold you the
-geese which you supplied to the Alpha."
-
-"Well then, I shan't tell you. So now!"
-
-"Oh, it is a matter of no importance; but I don't know why you
-should be so warm over such a trifle."
-
-"Warm! You'd be as warm, maybe, if you were as pestered as I am.
-When I pay good money for a good article there should be an end
-of the business; but it's 'Where are the geese?' and 'Who did you
-sell the geese to?' and 'What will you take for the geese?' One
-would think they were the only geese in the world, to hear the
-fuss that is made over them."
-
-"Well, I have no connection with any other people who have been
-making inquiries," said Holmes carelessly. "If you won't tell us
-the bet is off, that is all. But I'm always ready to back my
-opinion on a matter of fowls, and I have a fiver on it that the
-bird I ate is country bred."
-
-"Well, then, you've lost your fiver, for it's town bred," snapped
-the salesman.
-
-"It's nothing of the kind."
-
-"I say it is."
-
-"I don't believe it."
-
-"D'you think you know more about fowls than I, who have handled
-them ever since I was a nipper? I tell you, all those birds that
-went to the Alpha were town bred."
-
-"You'll never persuade me to believe that."
-
-"Will you bet, then?"
-
-"It's merely taking your money, for I know that I am right. But
-I'll have a sovereign on with you, just to teach you not to be
-obstinate."
-
-The salesman chuckled grimly. "Bring me the books, Bill," said
-he.
-
-The small boy brought round a small thin volume and a great
-greasy-backed one, laying them out together beneath the hanging
-lamp.
-
-"Now then, Mr. Cocksure," said the salesman, "I thought that I
-was out of geese, but before I finish you'll find that there is
-still one left in my shop. You see this little book?"
-
-"Well?"
-
-"That's the list of the folk from whom I buy. D'you see? Well,
-then, here on this page are the country folk, and the numbers
-after their names are where their accounts are in the big ledger.
-Now, then! You see this other page in red ink? Well, that is a
-list of my town suppliers. Now, look at that third name. Just
-read it out to me."
-
-"Mrs. Oakshott, 117, Brixton Road--249," read Holmes.
-
-"Quite so. Now turn that up in the ledger."
-
-Holmes turned to the page indicated. "Here you are, 'Mrs.
-Oakshott, 117, Brixton Road, egg and poultry supplier.'"
-
-"Now, then, what's the last entry?"
-
-"'December 22nd. Twenty-four geese at 7s. 6d.'"
-
-"Quite so. There you are. And underneath?"
-
-"'Sold to Mr. Windigate of the Alpha, at 12s.'"
-
-"What have you to say now?"
-
-Sherlock Holmes looked deeply chagrined. He drew a sovereign from
-his pocket and threw it down upon the slab, turning away with the
-air of a man whose disgust is too deep for words. A few yards off
-he stopped under a lamp-post and laughed in the hearty, noiseless
-fashion which was peculiar to him.
-
-"When you see a man with whiskers of that cut and the 'Pink 'un'
-protruding out of his pocket, you can always draw him by a bet,"
-said he. "I daresay that if I had put 100 pounds down in front of
-him, that man would not have given me such complete information
-as was drawn from him by the idea that he was doing me on a
-wager. Well, Watson, we are, I fancy, nearing the end of our
-quest, and the only point which remains to be determined is
-whether we should go on to this Mrs. Oakshott to-night, or
-whether we should reserve it for to-morrow. It is clear from what
-that surly fellow said that there are others besides ourselves
-who are anxious about the matter, and I should--"
-
-His remarks were suddenly cut short by a loud hubbub which broke
-out from the stall which we had just left. Turning round we saw a
-little rat-faced fellow standing in the centre of the circle of
-yellow light which was thrown by the swinging lamp, while
-Breckinridge, the salesman, framed in the door of his stall, was
-shaking his fists fiercely at the cringing figure.
-
-"I've had enough of you and your geese," he shouted. "I wish you
-were all at the devil together. If you come pestering me any more
-with your silly talk I'll set the dog at you. You bring Mrs.
-Oakshott here and I'll answer her, but what have you to do with
-it? Did I buy the geese off you?"
-
-"No; but one of them was mine all the same," whined the little
-man.
-
-"Well, then, ask Mrs. Oakshott for it."
-
-"She told me to ask you."
-
-"Well, you can ask the King of Proosia, for all I care. I've had
-enough of it. Get out of this!" He rushed fiercely forward, and
-the inquirer flitted away into the darkness.
-
-"Ha! this may save us a visit to Brixton Road," whispered Holmes.
-"Come with me, and we will see what is to be made of this
-fellow." Striding through the scattered knots of people who
-lounged round the flaring stalls, my companion speedily overtook
-the little man and touched him upon the shoulder. He sprang
-round, and I could see in the gas-light that every vestige of
-colour had been driven from his face.
-
-"Who are you, then? What do you want?" he asked in a quavering
-voice.
-
-"You will excuse me," said Holmes blandly, "but I could not help
-overhearing the questions which you put to the salesman just now.
-I think that I could be of assistance to you."
-
-"You? Who are you? How could you know anything of the matter?"
-
-"My name is Sherlock Holmes. It is my business to know what other
-people don't know."
-
-"But you can know nothing of this?"
-
-"Excuse me, I know everything of it. You are endeavouring to
-trace some geese which were sold by Mrs. Oakshott, of Brixton
-Road, to a salesman named Breckinridge, by him in turn to Mr.
-Windigate, of the Alpha, and by him to his club, of which Mr.
-Henry Baker is a member."
-
-"Oh, sir, you are the very man whom I have longed to meet," cried
-the little fellow with outstretched hands and quivering fingers.
-"I can hardly explain to you how interested I am in this matter."
-
-Sherlock Holmes hailed a four-wheeler which was passing. "In that
-case we had better discuss it in a cosy room rather than in this
-wind-swept market-place," said he. "But pray tell me, before we
-go farther, who it is that I have the pleasure of assisting."
-
-The man hesitated for an instant. "My name is John Robinson," he
-answered with a sidelong glance.
-
-"No, no; the real name," said Holmes sweetly. "It is always
-awkward doing business with an alias."
-
-A flush sprang to the white cheeks of the stranger. "Well then,"
-said he, "my real name is James Ryder."
-
-"Precisely so. Head attendant at the Hotel Cosmopolitan. Pray
-step into the cab, and I shall soon be able to tell you
-everything which you would wish to know."
-
-The little man stood glancing from one to the other of us with
-half-frightened, half-hopeful eyes, as one who is not sure
-whether he is on the verge of a windfall or of a catastrophe.
-Then he stepped into the cab, and in half an hour we were back in
-the sitting-room at Baker Street. Nothing had been said during
-our drive, but the high, thin breathing of our new companion, and
-the claspings and unclaspings of his hands, spoke of the nervous
-tension within him.
-
-"Here we are!" said Holmes cheerily as we filed into the room.
-"The fire looks very seasonable in this weather. You look cold,
-Mr. Ryder. Pray take the basket-chair. I will just put on my
-slippers before we settle this little matter of yours. Now, then!
-You want to know what became of those geese?"
-
-"Yes, sir."
-
-"Or rather, I fancy, of that goose. It was one bird, I imagine in
-which you were interested--white, with a black bar across the
-tail."
-
-Ryder quivered with emotion. "Oh, sir," he cried, "can you tell
-me where it went to?"
-
-"It came here."
-
-"Here?"
-
-"Yes, and a most remarkable bird it proved. I don't wonder that
-you should take an interest in it. It laid an egg after it was
-dead--the bonniest, brightest little blue egg that ever was seen.
-I have it here in my museum."
-
-Our visitor staggered to his feet and clutched the mantelpiece
-with his right hand. Holmes unlocked his strong-box and held up
-the blue carbuncle, which shone out like a star, with a cold,
-brilliant, many-pointed radiance. Ryder stood glaring with a
-drawn face, uncertain whether to claim or to disown it.
-
-"The game's up, Ryder," said Holmes quietly. "Hold up, man, or
-you'll be into the fire! Give him an arm back into his chair,
-Watson. He's not got blood enough to go in for felony with
-impunity. Give him a dash of brandy. So! Now he looks a little
-more human. What a shrimp it is, to be sure!"
-
-For a moment he had staggered and nearly fallen, but the brandy
-brought a tinge of colour into his cheeks, and he sat staring
-with frightened eyes at his accuser.
-
-"I have almost every link in my hands, and all the proofs which I
-could possibly need, so there is little which you need tell me.
-Still, that little may as well be cleared up to make the case
-complete. You had heard, Ryder, of this blue stone of the
-Countess of Morcar's?"
-
-"It was Catherine Cusack who told me of it," said he in a
-crackling voice.
-
-"I see--her ladyship's waiting-maid. Well, the temptation of
-sudden wealth so easily acquired was too much for you, as it has
-been for better men before you; but you were not very scrupulous
-in the means you used. It seems to me, Ryder, that there is the
-making of a very pretty villain in you. You knew that this man
-Horner, the plumber, had been concerned in some such matter
-before, and that suspicion would rest the more readily upon him.
-What did you do, then? You made some small job in my lady's
-room--you and your confederate Cusack--and you managed that he
-should be the man sent for. Then, when he had left, you rifled
-the jewel-case, raised the alarm, and had this unfortunate man
-arrested. You then--"
-
-Ryder threw himself down suddenly upon the rug and clutched at my
-companion's knees. "For God's sake, have mercy!" he shrieked.
-"Think of my father! Of my mother! It would break their hearts. I
-never went wrong before! I never will again. I swear it. I'll
-swear it on a Bible. Oh, don't bring it into court! For Christ's
-sake, don't!"
-
-"Get back into your chair!" said Holmes sternly. "It is very well
-to cringe and crawl now, but you thought little enough of this
-poor Horner in the dock for a crime of which he knew nothing."
-
-"I will fly, Mr. Holmes. I will leave the country, sir. Then the
-charge against him will break down."
-
-"Hum! We will talk about that. And now let us hear a true account
-of the next act. How came the stone into the goose, and how came
-the goose into the open market? Tell us the truth, for there lies
-your only hope of safety."
-
-Ryder passed his tongue over his parched lips. "I will tell you
-it just as it happened, sir," said he. "When Horner had been
-arrested, it seemed to me that it would be best for me to get
-away with the stone at once, for I did not know at what moment
-the police might not take it into their heads to search me and my
-room. There was no place about the hotel where it would be safe.
-I went out, as if on some commission, and I made for my sister's
-house. She had married a man named Oakshott, and lived in Brixton
-Road, where she fattened fowls for the market. All the way there
-every man I met seemed to me to be a policeman or a detective;
-and, for all that it was a cold night, the sweat was pouring down
-my face before I came to the Brixton Road. My sister asked me
-what was the matter, and why I was so pale; but I told her that I
-had been upset by the jewel robbery at the hotel. Then I went
-into the back yard and smoked a pipe and wondered what it would
-be best to do.
-
-"I had a friend once called Maudsley, who went to the bad, and
-has just been serving his time in Pentonville. One day he had met
-me, and fell into talk about the ways of thieves, and how they
-could get rid of what they stole. I knew that he would be true to
-me, for I knew one or two things about him; so I made up my mind
-to go right on to Kilburn, where he lived, and take him into my
-confidence. He would show me how to turn the stone into money.
-But how to get to him in safety? I thought of the agonies I had
-gone through in coming from the hotel. I might at any moment be
-seized and searched, and there would be the stone in my waistcoat
-pocket. I was leaning against the wall at the time and looking at
-the geese which were waddling about round my feet, and suddenly
-an idea came into my head which showed me how I could beat the
-best detective that ever lived.
-
-"My sister had told me some weeks before that I might have the
-pick of her geese for a Christmas present, and I knew that she
-was always as good as her word. I would take my goose now, and in
-it I would carry my stone to Kilburn. There was a little shed in
-the yard, and behind this I drove one of the birds--a fine big
-one, white, with a barred tail. I caught it, and prying its bill
-open, I thrust the stone down its throat as far as my finger
-could reach. The bird gave a gulp, and I felt the stone pass
-along its gullet and down into its crop. But the creature flapped
-and struggled, and out came my sister to know what was the
-matter. As I turned to speak to her the brute broke loose and
-fluttered off among the others.
-
-"'Whatever were you doing with that bird, Jem?' says she.
-
-"'Well,' said I, 'you said you'd give me one for Christmas, and I
-was feeling which was the fattest.'
-
-"'Oh,' says she, 'we've set yours aside for you--Jem's bird, we
-call it. It's the big white one over yonder. There's twenty-six
-of them, which makes one for you, and one for us, and two dozen
-for the market.'
-
-"'Thank you, Maggie,' says I; 'but if it is all the same to you,
-I'd rather have that one I was handling just now.'
-
-"'The other is a good three pound heavier,' said she, 'and we
-fattened it expressly for you.'
-
-"'Never mind. I'll have the other, and I'll take it now,' said I.
-
-"'Oh, just as you like,' said she, a little huffed. 'Which is it
-you want, then?'
-
-"'That white one with the barred tail, right in the middle of the
-flock.'
-
-"'Oh, very well. Kill it and take it with you.'
-
-"Well, I did what she said, Mr. Holmes, and I carried the bird
-all the way to Kilburn. I told my pal what I had done, for he was
-a man that it was easy to tell a thing like that to. He laughed
-until he choked, and we got a knife and opened the goose. My
-heart turned to water, for there was no sign of the stone, and I
-knew that some terrible mistake had occurred. I left the bird,
-rushed back to my sister's, and hurried into the back yard. There
-was not a bird to be seen there.
-
-"'Where are they all, Maggie?' I cried.
-
-"'Gone to the dealer's, Jem.'
-
-"'Which dealer's?'
-
-"'Breckinridge, of Covent Garden.'
-
-"'But was there another with a barred tail?' I asked, 'the same
-as the one I chose?'
-
-"'Yes, Jem; there were two barred-tailed ones, and I could never
-tell them apart.'
-
-"Well, then, of course I saw it all, and I ran off as hard as my
-feet would carry me to this man Breckinridge; but he had sold the
-lot at once, and not one word would he tell me as to where they
-had gone. You heard him yourselves to-night. Well, he has always
-answered me like that. My sister thinks that I am going mad.
-Sometimes I think that I am myself. And now--and now I am myself
-a branded thief, without ever having touched the wealth for which
-I sold my character. God help me! God help me!" He burst into
-convulsive sobbing, with his face buried in his hands.
-
-There was a long silence, broken only by his heavy breathing and
-by the measured tapping of Sherlock Holmes' finger-tips upon the
-edge of the table. Then my friend rose and threw open the door.
-
-"Get out!" said he.
-
-"What, sir! Oh, Heaven bless you!"
-
-"No more words. Get out!"
-
-And no more words were needed. There was a rush, a clatter upon
-the stairs, the bang of a door, and the crisp rattle of running
-footfalls from the street.
-
-"After all, Watson," said Holmes, reaching up his hand for his
-clay pipe, "I am not retained by the police to supply their
-deficiencies. If Horner were in danger it would be another thing;
-but this fellow will not appear against him, and the case must
-collapse. I suppose that I am commuting a felony, but it is just
-possible that I am saving a soul. This fellow will not go wrong
-again; he is too terribly frightened. Send him to gaol now, and
-you make him a gaol-bird for life. Besides, it is the season of
-forgiveness. Chance has put in our way a most singular and
-whimsical problem, and its solution is its own reward. If you
-will have the goodness to touch the bell, Doctor, we will begin
-another investigation, in which, also a bird will be the chief
-feature."
-
-
-
-VIII. THE ADVENTURE OF THE SPECKLED BAND
-
-On glancing over my notes of the seventy odd cases in which I
-have during the last eight years studied the methods of my friend
-Sherlock Holmes, I find many tragic, some comic, a large number
-merely strange, but none commonplace; for, working as he did
-rather for the love of his art than for the acquirement of
-wealth, he refused to associate himself with any investigation
-which did not tend towards the unusual, and even the fantastic.
-Of all these varied cases, however, I cannot recall any which
-presented more singular features than that which was associated
-with the well-known Surrey family of the Roylotts of Stoke Moran.
-The events in question occurred in the early days of my
-association with Holmes, when we were sharing rooms as bachelors
-in Baker Street. It is possible that I might have placed them
-upon record before, but a promise of secrecy was made at the
-time, from which I have only been freed during the last month by
-the untimely death of the lady to whom the pledge was given. It
-is perhaps as well that the facts should now come to light, for I
-have reasons to know that there are widespread rumours as to the
-death of Dr. Grimesby Roylott which tend to make the matter even
-more terrible than the truth.
-
-It was early in April in the year '83 that I woke one morning to
-find Sherlock Holmes standing, fully dressed, by the side of my
-bed. He was a late riser, as a rule, and as the clock on the
-mantelpiece showed me that it was only a quarter-past seven, I
-blinked up at him in some surprise, and perhaps just a little
-resentment, for I was myself regular in my habits.
-
-"Very sorry to knock you up, Watson," said he, "but it's the
-common lot this morning. Mrs. Hudson has been knocked up, she
-retorted upon me, and I on you."
-
-"What is it, then--a fire?"
-
-"No; a client. It seems that a young lady has arrived in a
-considerable state of excitement, who insists upon seeing me. She
-is waiting now in the sitting-room. Now, when young ladies wander
-about the metropolis at this hour of the morning, and knock
-sleepy people up out of their beds, I presume that it is
-something very pressing which they have to communicate. Should it
-prove to be an interesting case, you would, I am sure, wish to
-follow it from the outset. I thought, at any rate, that I should
-call you and give you the chance."
-
-"My dear fellow, I would not miss it for anything."
-
-I had no keener pleasure than in following Holmes in his
-professional investigations, and in admiring the rapid
-deductions, as swift as intuitions, and yet always founded on a
-logical basis with which he unravelled the problems which were
-submitted to him. I rapidly threw on my clothes and was ready in
-a few minutes to accompany my friend down to the sitting-room. A
-lady dressed in black and heavily veiled, who had been sitting in
-the window, rose as we entered.
-
-"Good-morning, madam," said Holmes cheerily. "My name is Sherlock
-Holmes. This is my intimate friend and associate, Dr. Watson,
-before whom you can speak as freely as before myself. Ha! I am
-glad to see that Mrs. Hudson has had the good sense to light the
-fire. Pray draw up to it, and I shall order you a cup of hot
-coffee, for I observe that you are shivering."
-
-"It is not cold which makes me shiver," said the woman in a low
-voice, changing her seat as requested.
-
-"What, then?"
-
-"It is fear, Mr. Holmes. It is terror." She raised her veil as
-she spoke, and we could see that she was indeed in a pitiable
-state of agitation, her face all drawn and grey, with restless
-frightened eyes, like those of some hunted animal. Her features
-and figure were those of a woman of thirty, but her hair was shot
-with premature grey, and her expression was weary and haggard.
-Sherlock Holmes ran her over with one of his quick,
-all-comprehensive glances.
-
-"You must not fear," said he soothingly, bending forward and
-patting her forearm. "We shall soon set matters right, I have no
-doubt. You have come in by train this morning, I see."
-
-"You know me, then?"
-
-"No, but I observe the second half of a return ticket in the palm
-of your left glove. You must have started early, and yet you had
-a good drive in a dog-cart, along heavy roads, before you reached
-the station."
-
-The lady gave a violent start and stared in bewilderment at my
-companion.
-
-"There is no mystery, my dear madam," said he, smiling. "The left
-arm of your jacket is spattered with mud in no less than seven
-places. The marks are perfectly fresh. There is no vehicle save a
-dog-cart which throws up mud in that way, and then only when you
-sit on the left-hand side of the driver."
-
-"Whatever your reasons may be, you are perfectly correct," said
-she. "I started from home before six, reached Leatherhead at
-twenty past, and came in by the first train to Waterloo. Sir, I
-can stand this strain no longer; I shall go mad if it continues.
-I have no one to turn to--none, save only one, who cares for me,
-and he, poor fellow, can be of little aid. I have heard of you,
-Mr. Holmes; I have heard of you from Mrs. Farintosh, whom you
-helped in the hour of her sore need. It was from her that I had
-your address. Oh, sir, do you not think that you could help me,
-too, and at least throw a little light through the dense darkness
-which surrounds me? At present it is out of my power to reward
-you for your services, but in a month or six weeks I shall be
-married, with the control of my own income, and then at least you
-shall not find me ungrateful."
-
-Holmes turned to his desk and, unlocking it, drew out a small
-case-book, which he consulted.
-
-"Farintosh," said he. "Ah yes, I recall the case; it was
-concerned with an opal tiara. I think it was before your time,
-Watson. I can only say, madam, that I shall be happy to devote
-the same care to your case as I did to that of your friend. As to
-reward, my profession is its own reward; but you are at liberty
-to defray whatever expenses I may be put to, at the time which
-suits you best. And now I beg that you will lay before us
-everything that may help us in forming an opinion upon the
-matter."
-
-"Alas!" replied our visitor, "the very horror of my situation
-lies in the fact that my fears are so vague, and my suspicions
-depend so entirely upon small points, which might seem trivial to
-another, that even he to whom of all others I have a right to
-look for help and advice looks upon all that I tell him about it
-as the fancies of a nervous woman. He does not say so, but I can
-read it from his soothing answers and averted eyes. But I have
-heard, Mr. Holmes, that you can see deeply into the manifold
-wickedness of the human heart. You may advise me how to walk amid
-the dangers which encompass me."
-
-"I am all attention, madam."
-
-"My name is Helen Stoner, and I am living with my stepfather, who
-is the last survivor of one of the oldest Saxon families in
-England, the Roylotts of Stoke Moran, on the western border of
-Surrey."
-
-Holmes nodded his head. "The name is familiar to me," said he.
-
-"The family was at one time among the richest in England, and the
-estates extended over the borders into Berkshire in the north,
-and Hampshire in the west. In the last century, however, four
-successive heirs were of a dissolute and wasteful disposition,
-and the family ruin was eventually completed by a gambler in the
-days of the Regency. Nothing was left save a few acres of ground,
-and the two-hundred-year-old house, which is itself crushed under
-a heavy mortgage. The last squire dragged out his existence
-there, living the horrible life of an aristocratic pauper; but
-his only son, my stepfather, seeing that he must adapt himself to
-the new conditions, obtained an advance from a relative, which
-enabled him to take a medical degree and went out to Calcutta,
-where, by his professional skill and his force of character, he
-established a large practice. In a fit of anger, however, caused
-by some robberies which had been perpetrated in the house, he
-beat his native butler to death and narrowly escaped a capital
-sentence. As it was, he suffered a long term of imprisonment and
-afterwards returned to England a morose and disappointed man.
-
-"When Dr. Roylott was in India he married my mother, Mrs. Stoner,
-the young widow of Major-General Stoner, of the Bengal Artillery.
-My sister Julia and I were twins, and we were only two years old
-at the time of my mother's re-marriage. She had a considerable
-sum of money--not less than 1000 pounds a year--and this she
-bequeathed to Dr. Roylott entirely while we resided with him,
-with a provision that a certain annual sum should be allowed to
-each of us in the event of our marriage. Shortly after our return
-to England my mother died--she was killed eight years ago in a
-railway accident near Crewe. Dr. Roylott then abandoned his
-attempts to establish himself in practice in London and took us
-to live with him in the old ancestral house at Stoke Moran. The
-money which my mother had left was enough for all our wants, and
-there seemed to be no obstacle to our happiness.
-
-"But a terrible change came over our stepfather about this time.
-Instead of making friends and exchanging visits with our
-neighbours, who had at first been overjoyed to see a Roylott of
-Stoke Moran back in the old family seat, he shut himself up in
-his house and seldom came out save to indulge in ferocious
-quarrels with whoever might cross his path. Violence of temper
-approaching to mania has been hereditary in the men of the
-family, and in my stepfather's case it had, I believe, been
-intensified by his long residence in the tropics. A series of
-disgraceful brawls took place, two of which ended in the
-police-court, until at last he became the terror of the village,
-and the folks would fly at his approach, for he is a man of
-immense strength, and absolutely uncontrollable in his anger.
-
-"Last week he hurled the local blacksmith over a parapet into a
-stream, and it was only by paying over all the money which I
-could gather together that I was able to avert another public
-exposure. He had no friends at all save the wandering gipsies,
-and he would give these vagabonds leave to encamp upon the few
-acres of bramble-covered land which represent the family estate,
-and would accept in return the hospitality of their tents,
-wandering away with them sometimes for weeks on end. He has a
-passion also for Indian animals, which are sent over to him by a
-correspondent, and he has at this moment a cheetah and a baboon,
-which wander freely over his grounds and are feared by the
-villagers almost as much as their master.
-
-"You can imagine from what I say that my poor sister Julia and I
-had no great pleasure in our lives. No servant would stay with
-us, and for a long time we did all the work of the house. She was
-but thirty at the time of her death, and yet her hair had already
-begun to whiten, even as mine has."
-
-"Your sister is dead, then?"
-
-"She died just two years ago, and it is of her death that I wish
-to speak to you. You can understand that, living the life which I
-have described, we were little likely to see anyone of our own
-age and position. We had, however, an aunt, my mother's maiden
-sister, Miss Honoria Westphail, who lives near Harrow, and we
-were occasionally allowed to pay short visits at this lady's
-house. Julia went there at Christmas two years ago, and met there
-a half-pay major of marines, to whom she became engaged. My
-stepfather learned of the engagement when my sister returned and
-offered no objection to the marriage; but within a fortnight of
-the day which had been fixed for the wedding, the terrible event
-occurred which has deprived me of my only companion."
-
-Sherlock Holmes had been leaning back in his chair with his eyes
-closed and his head sunk in a cushion, but he half opened his
-lids now and glanced across at his visitor.
-
-"Pray be precise as to details," said he.
-
-"It is easy for me to be so, for every event of that dreadful
-time is seared into my memory. The manor-house is, as I have
-already said, very old, and only one wing is now inhabited. The
-bedrooms in this wing are on the ground floor, the sitting-rooms
-being in the central block of the buildings. Of these bedrooms
-the first is Dr. Roylott's, the second my sister's, and the third
-my own. There is no communication between them, but they all open
-out into the same corridor. Do I make myself plain?"
-
-"Perfectly so."
-
-"The windows of the three rooms open out upon the lawn. That
-fatal night Dr. Roylott had gone to his room early, though we
-knew that he had not retired to rest, for my sister was troubled
-by the smell of the strong Indian cigars which it was his custom
-to smoke. She left her room, therefore, and came into mine, where
-she sat for some time, chatting about her approaching wedding. At
-eleven o'clock she rose to leave me, but she paused at the door
-and looked back.
-
-"'Tell me, Helen,' said she, 'have you ever heard anyone whistle
-in the dead of the night?'
-
-"'Never,' said I.
-
-"'I suppose that you could not possibly whistle, yourself, in
-your sleep?'
-
-"'Certainly not. But why?'
-
-"'Because during the last few nights I have always, about three
-in the morning, heard a low, clear whistle. I am a light sleeper,
-and it has awakened me. I cannot tell where it came from--perhaps
-from the next room, perhaps from the lawn. I thought that I would
-just ask you whether you had heard it.'
-
-"'No, I have not. It must be those wretched gipsies in the
-plantation.'
-
-"'Very likely. And yet if it were on the lawn, I wonder that you
-did not hear it also.'
-
-"'Ah, but I sleep more heavily than you.'
-
-"'Well, it is of no great consequence, at any rate.' She smiled
-back at me, closed my door, and a few moments later I heard her
-key turn in the lock."
-
-"Indeed," said Holmes. "Was it your custom always to lock
-yourselves in at night?"
-
-"Always."
-
-"And why?"
-
-"I think that I mentioned to you that the doctor kept a cheetah
-and a baboon. We had no feeling of security unless our doors were
-locked."
-
-"Quite so. Pray proceed with your statement."
-
-"I could not sleep that night. A vague feeling of impending
-misfortune impressed me. My sister and I, you will recollect,
-were twins, and you know how subtle are the links which bind two
-souls which are so closely allied. It was a wild night. The wind
-was howling outside, and the rain was beating and splashing
-against the windows. Suddenly, amid all the hubbub of the gale,
-there burst forth the wild scream of a terrified woman. I knew
-that it was my sister's voice. I sprang from my bed, wrapped a
-shawl round me, and rushed into the corridor. As I opened my door
-I seemed to hear a low whistle, such as my sister described, and
-a few moments later a clanging sound, as if a mass of metal had
-fallen. As I ran down the passage, my sister's door was unlocked,
-and revolved slowly upon its hinges. I stared at it
-horror-stricken, not knowing what was about to issue from it. By
-the light of the corridor-lamp I saw my sister appear at the
-opening, her face blanched with terror, her hands groping for
-help, her whole figure swaying to and fro like that of a
-drunkard. I ran to her and threw my arms round her, but at that
-moment her knees seemed to give way and she fell to the ground.
-She writhed as one who is in terrible pain, and her limbs were
-dreadfully convulsed. At first I thought that she had not
-recognised me, but as I bent over her she suddenly shrieked out
-in a voice which I shall never forget, 'Oh, my God! Helen! It was
-the band! The speckled band!' There was something else which she
-would fain have said, and she stabbed with her finger into the
-air in the direction of the doctor's room, but a fresh convulsion
-seized her and choked her words. I rushed out, calling loudly for
-my stepfather, and I met him hastening from his room in his
-dressing-gown. When he reached my sister's side she was
-unconscious, and though he poured brandy down her throat and sent
-for medical aid from the village, all efforts were in vain, for
-she slowly sank and died without having recovered her
-consciousness. Such was the dreadful end of my beloved sister."
-
-"One moment," said Holmes, "are you sure about this whistle and
-metallic sound? Could you swear to it?"
-
-"That was what the county coroner asked me at the inquiry. It is
-my strong impression that I heard it, and yet, among the crash of
-the gale and the creaking of an old house, I may possibly have
-been deceived."
-
-"Was your sister dressed?"
-
-"No, she was in her night-dress. In her right hand was found the
-charred stump of a match, and in her left a match-box."
-
-"Showing that she had struck a light and looked about her when
-the alarm took place. That is important. And what conclusions did
-the coroner come to?"
-
-"He investigated the case with great care, for Dr. Roylott's
-conduct had long been notorious in the county, but he was unable
-to find any satisfactory cause of death. My evidence showed that
-the door had been fastened upon the inner side, and the windows
-were blocked by old-fashioned shutters with broad iron bars,
-which were secured every night. The walls were carefully sounded,
-and were shown to be quite solid all round, and the flooring was
-also thoroughly examined, with the same result. The chimney is
-wide, but is barred up by four large staples. It is certain,
-therefore, that my sister was quite alone when she met her end.
-Besides, there were no marks of any violence upon her."
-
-"How about poison?"
-
-"The doctors examined her for it, but without success."
-
-"What do you think that this unfortunate lady died of, then?"
-
-"It is my belief that she died of pure fear and nervous shock,
-though what it was that frightened her I cannot imagine."
-
-"Were there gipsies in the plantation at the time?"
-
-"Yes, there are nearly always some there."
-
-"Ah, and what did you gather from this allusion to a band--a
-speckled band?"
-
-"Sometimes I have thought that it was merely the wild talk of
-delirium, sometimes that it may have referred to some band of
-people, perhaps to these very gipsies in the plantation. I do not
-know whether the spotted handkerchiefs which so many of them wear
-over their heads might have suggested the strange adjective which
-she used."
-
-Holmes shook his head like a man who is far from being satisfied.
-
-"These are very deep waters," said he; "pray go on with your
-narrative."
-
-"Two years have passed since then, and my life has been until
-lately lonelier than ever. A month ago, however, a dear friend,
-whom I have known for many years, has done me the honour to ask
-my hand in marriage. His name is Armitage--Percy Armitage--the
-second son of Mr. Armitage, of Crane Water, near Reading. My
-stepfather has offered no opposition to the match, and we are to
-be married in the course of the spring. Two days ago some repairs
-were started in the west wing of the building, and my bedroom
-wall has been pierced, so that I have had to move into the
-chamber in which my sister died, and to sleep in the very bed in
-which she slept. Imagine, then, my thrill of terror when last
-night, as I lay awake, thinking over her terrible fate, I
-suddenly heard in the silence of the night the low whistle which
-had been the herald of her own death. I sprang up and lit the
-lamp, but nothing was to be seen in the room. I was too shaken to
-go to bed again, however, so I dressed, and as soon as it was
-daylight I slipped down, got a dog-cart at the Crown Inn, which
-is opposite, and drove to Leatherhead, from whence I have come on
-this morning with the one object of seeing you and asking your
-advice."
-
-"You have done wisely," said my friend. "But have you told me
-all?"
-
-"Yes, all."
-
-"Miss Roylott, you have not. You are screening your stepfather."
-
-"Why, what do you mean?"
-
-For answer Holmes pushed back the frill of black lace which
-fringed the hand that lay upon our visitor's knee. Five little
-livid spots, the marks of four fingers and a thumb, were printed
-upon the white wrist.
-
-"You have been cruelly used," said Holmes.
-
-The lady coloured deeply and covered over her injured wrist. "He
-is a hard man," she said, "and perhaps he hardly knows his own
-strength."
-
-There was a long silence, during which Holmes leaned his chin
-upon his hands and stared into the crackling fire.
-
-"This is a very deep business," he said at last. "There are a
-thousand details which I should desire to know before I decide
-upon our course of action. Yet we have not a moment to lose. If
-we were to come to Stoke Moran to-day, would it be possible for
-us to see over these rooms without the knowledge of your
-stepfather?"
-
-"As it happens, he spoke of coming into town to-day upon some
-most important business. It is probable that he will be away all
-day, and that there would be nothing to disturb you. We have a
-housekeeper now, but she is old and foolish, and I could easily
-get her out of the way."
-
-"Excellent. You are not averse to this trip, Watson?"
-
-"By no means."
-
-"Then we shall both come. What are you going to do yourself?"
-
-"I have one or two things which I would wish to do now that I am
-in town. But I shall return by the twelve o'clock train, so as to
-be there in time for your coming."
-
-"And you may expect us early in the afternoon. I have myself some
-small business matters to attend to. Will you not wait and
-breakfast?"
-
-"No, I must go. My heart is lightened already since I have
-confided my trouble to you. I shall look forward to seeing you
-again this afternoon." She dropped her thick black veil over her
-face and glided from the room.
-
-"And what do you think of it all, Watson?" asked Sherlock Holmes,
-leaning back in his chair.
-
-"It seems to me to be a most dark and sinister business."
-
-"Dark enough and sinister enough."
-
-"Yet if the lady is correct in saying that the flooring and walls
-are sound, and that the door, window, and chimney are impassable,
-then her sister must have been undoubtedly alone when she met her
-mysterious end."
-
-"What becomes, then, of these nocturnal whistles, and what of the
-very peculiar words of the dying woman?"
-
-"I cannot think."
-
-"When you combine the ideas of whistles at night, the presence of
-a band of gipsies who are on intimate terms with this old doctor,
-the fact that we have every reason to believe that the doctor has
-an interest in preventing his stepdaughter's marriage, the dying
-allusion to a band, and, finally, the fact that Miss Helen Stoner
-heard a metallic clang, which might have been caused by one of
-those metal bars that secured the shutters falling back into its
-place, I think that there is good ground to think that the
-mystery may be cleared along those lines."
-
-"But what, then, did the gipsies do?"
-
-"I cannot imagine."
-
-"I see many objections to any such theory."
-
-"And so do I. It is precisely for that reason that we are going
-to Stoke Moran this day. I want to see whether the objections are
-fatal, or if they may be explained away. But what in the name of
-the devil!"
-
-The ejaculation had been drawn from my companion by the fact that
-our door had been suddenly dashed open, and that a huge man had
-framed himself in the aperture. His costume was a peculiar
-mixture of the professional and of the agricultural, having a
-black top-hat, a long frock-coat, and a pair of high gaiters,
-with a hunting-crop swinging in his hand. So tall was he that his
-hat actually brushed the cross bar of the doorway, and his
-breadth seemed to span it across from side to side. A large face,
-seared with a thousand wrinkles, burned yellow with the sun, and
-marked with every evil passion, was turned from one to the other
-of us, while his deep-set, bile-shot eyes, and his high, thin,
-fleshless nose, gave him somewhat the resemblance to a fierce old
-bird of prey.
-
-"Which of you is Holmes?" asked this apparition.
-
-"My name, sir; but you have the advantage of me," said my
-companion quietly.
-
-"I am Dr. Grimesby Roylott, of Stoke Moran."
-
-"Indeed, Doctor," said Holmes blandly. "Pray take a seat."
-
-"I will do nothing of the kind. My stepdaughter has been here. I
-have traced her. What has she been saying to you?"
-
-"It is a little cold for the time of the year," said Holmes.
-
-"What has she been saying to you?" screamed the old man
-furiously.
-
-"But I have heard that the crocuses promise well," continued my
-companion imperturbably.
-
-"Ha! You put me off, do you?" said our new visitor, taking a step
-forward and shaking his hunting-crop. "I know you, you scoundrel!
-I have heard of you before. You are Holmes, the meddler."
-
-My friend smiled.
-
-"Holmes, the busybody!"
-
-His smile broadened.
-
-"Holmes, the Scotland Yard Jack-in-office!"
-
-Holmes chuckled heartily. "Your conversation is most
-entertaining," said he. "When you go out close the door, for
-there is a decided draught."
-
-"I will go when I have said my say. Don't you dare to meddle with
-my affairs. I know that Miss Stoner has been here. I traced her!
-I am a dangerous man to fall foul of! See here." He stepped
-swiftly forward, seized the poker, and bent it into a curve with
-his huge brown hands.
-
-"See that you keep yourself out of my grip," he snarled, and
-hurling the twisted poker into the fireplace he strode out of the
-room.
-
-"He seems a very amiable person," said Holmes, laughing. "I am
-not quite so bulky, but if he had remained I might have shown him
-that my grip was not much more feeble than his own." As he spoke
-he picked up the steel poker and, with a sudden effort,
-straightened it out again.
-
-"Fancy his having the insolence to confound me with the official
-detective force! This incident gives zest to our investigation,
-however, and I only trust that our little friend will not suffer
-from her imprudence in allowing this brute to trace her. And now,
-Watson, we shall order breakfast, and afterwards I shall walk
-down to Doctors' Commons, where I hope to get some data which may
-help us in this matter."
-
-
-It was nearly one o'clock when Sherlock Holmes returned from his
-excursion. He held in his hand a sheet of blue paper, scrawled
-over with notes and figures.
-
-"I have seen the will of the deceased wife," said he. "To
-determine its exact meaning I have been obliged to work out the
-present prices of the investments with which it is concerned. The
-total income, which at the time of the wife's death was little
-short of 1100 pounds, is now, through the fall in agricultural
-prices, not more than 750 pounds. Each daughter can claim an
-income of 250 pounds, in case of marriage. It is evident,
-therefore, that if both girls had married, this beauty would have
-had a mere pittance, while even one of them would cripple him to
-a very serious extent. My morning's work has not been wasted,
-since it has proved that he has the very strongest motives for
-standing in the way of anything of the sort. And now, Watson,
-this is too serious for dawdling, especially as the old man is
-aware that we are interesting ourselves in his affairs; so if you
-are ready, we shall call a cab and drive to Waterloo. I should be
-very much obliged if you would slip your revolver into your
-pocket. An Eley's No. 2 is an excellent argument with gentlemen
-who can twist steel pokers into knots. That and a tooth-brush
-are, I think, all that we need."
-
-At Waterloo we were fortunate in catching a train for
-Leatherhead, where we hired a trap at the station inn and drove
-for four or five miles through the lovely Surrey lanes. It was a
-perfect day, with a bright sun and a few fleecy clouds in the
-heavens. The trees and wayside hedges were just throwing out
-their first green shoots, and the air was full of the pleasant
-smell of the moist earth. To me at least there was a strange
-contrast between the sweet promise of the spring and this
-sinister quest upon which we were engaged. My companion sat in
-the front of the trap, his arms folded, his hat pulled down over
-his eyes, and his chin sunk upon his breast, buried in the
-deepest thought. Suddenly, however, he started, tapped me on the
-shoulder, and pointed over the meadows.
-
-"Look there!" said he.
-
-A heavily timbered park stretched up in a gentle slope,
-thickening into a grove at the highest point. From amid the
-branches there jutted out the grey gables and high roof-tree of a
-very old mansion.
-
-"Stoke Moran?" said he.
-
-"Yes, sir, that be the house of Dr. Grimesby Roylott," remarked
-the driver.
-
-"There is some building going on there," said Holmes; "that is
-where we are going."
-
-"There's the village," said the driver, pointing to a cluster of
-roofs some distance to the left; "but if you want to get to the
-house, you'll find it shorter to get over this stile, and so by
-the foot-path over the fields. There it is, where the lady is
-walking."
-
-"And the lady, I fancy, is Miss Stoner," observed Holmes, shading
-his eyes. "Yes, I think we had better do as you suggest."
-
-We got off, paid our fare, and the trap rattled back on its way
-to Leatherhead.
-
-"I thought it as well," said Holmes as we climbed the stile,
-"that this fellow should think we had come here as architects, or
-on some definite business. It may stop his gossip.
-Good-afternoon, Miss Stoner. You see that we have been as good as
-our word."
-
-Our client of the morning had hurried forward to meet us with a
-face which spoke her joy. "I have been waiting so eagerly for
-you," she cried, shaking hands with us warmly. "All has turned
-out splendidly. Dr. Roylott has gone to town, and it is unlikely
-that he will be back before evening."
-
-"We have had the pleasure of making the doctor's acquaintance,"
-said Holmes, and in a few words he sketched out what had
-occurred. Miss Stoner turned white to the lips as she listened.
-
-"Good heavens!" she cried, "he has followed me, then."
-
-"So it appears."
-
-"He is so cunning that I never know when I am safe from him. What
-will he say when he returns?"
-
-"He must guard himself, for he may find that there is someone
-more cunning than himself upon his track. You must lock yourself
-up from him to-night. If he is violent, we shall take you away to
-your aunt's at Harrow. Now, we must make the best use of our
-time, so kindly take us at once to the rooms which we are to
-examine."
-
-The building was of grey, lichen-blotched stone, with a high
-central portion and two curving wings, like the claws of a crab,
-thrown out on each side. In one of these wings the windows were
-broken and blocked with wooden boards, while the roof was partly
-caved in, a picture of ruin. The central portion was in little
-better repair, but the right-hand block was comparatively modern,
-and the blinds in the windows, with the blue smoke curling up
-from the chimneys, showed that this was where the family resided.
-Some scaffolding had been erected against the end wall, and the
-stone-work had been broken into, but there were no signs of any
-workmen at the moment of our visit. Holmes walked slowly up and
-down the ill-trimmed lawn and examined with deep attention the
-outsides of the windows.
-
-"This, I take it, belongs to the room in which you used to sleep,
-the centre one to your sister's, and the one next to the main
-building to Dr. Roylott's chamber?"
-
-"Exactly so. But I am now sleeping in the middle one."
-
-"Pending the alterations, as I understand. By the way, there does
-not seem to be any very pressing need for repairs at that end
-wall."
-
-"There were none. I believe that it was an excuse to move me from
-my room."
-
-"Ah! that is suggestive. Now, on the other side of this narrow
-wing runs the corridor from which these three rooms open. There
-are windows in it, of course?"
-
-"Yes, but very small ones. Too narrow for anyone to pass
-through."
-
-"As you both locked your doors at night, your rooms were
-unapproachable from that side. Now, would you have the kindness
-to go into your room and bar your shutters?"
-
-Miss Stoner did so, and Holmes, after a careful examination
-through the open window, endeavoured in every way to force the
-shutter open, but without success. There was no slit through
-which a knife could be passed to raise the bar. Then with his
-lens he tested the hinges, but they were of solid iron, built
-firmly into the massive masonry. "Hum!" said he, scratching his
-chin in some perplexity, "my theory certainly presents some
-difficulties. No one could pass these shutters if they were
-bolted. Well, we shall see if the inside throws any light upon
-the matter."
-
-A small side door led into the whitewashed corridor from which
-the three bedrooms opened. Holmes refused to examine the third
-chamber, so we passed at once to the second, that in which Miss
-Stoner was now sleeping, and in which her sister had met with her
-fate. It was a homely little room, with a low ceiling and a
-gaping fireplace, after the fashion of old country-houses. A
-brown chest of drawers stood in one corner, a narrow
-white-counterpaned bed in another, and a dressing-table on the
-left-hand side of the window. These articles, with two small
-wicker-work chairs, made up all the furniture in the room save
-for a square of Wilton carpet in the centre. The boards round and
-the panelling of the walls were of brown, worm-eaten oak, so old
-and discoloured that it may have dated from the original building
-of the house. Holmes drew one of the chairs into a corner and sat
-silent, while his eyes travelled round and round and up and down,
-taking in every detail of the apartment.
-
-"Where does that bell communicate with?" he asked at last
-pointing to a thick bell-rope which hung down beside the bed, the
-tassel actually lying upon the pillow.
-
-"It goes to the housekeeper's room."
-
-"It looks newer than the other things?"
-
-"Yes, it was only put there a couple of years ago."
-
-"Your sister asked for it, I suppose?"
-
-"No, I never heard of her using it. We used always to get what we
-wanted for ourselves."
-
-"Indeed, it seemed unnecessary to put so nice a bell-pull there.
-You will excuse me for a few minutes while I satisfy myself as to
-this floor." He threw himself down upon his face with his lens in
-his hand and crawled swiftly backward and forward, examining
-minutely the cracks between the boards. Then he did the same with
-the wood-work with which the chamber was panelled. Finally he
-walked over to the bed and spent some time in staring at it and
-in running his eye up and down the wall. Finally he took the
-bell-rope in his hand and gave it a brisk tug.
-
-"Why, it's a dummy," said he.
-
-"Won't it ring?"
-
-"No, it is not even attached to a wire. This is very interesting.
-You can see now that it is fastened to a hook just above where
-the little opening for the ventilator is."
-
-"How very absurd! I never noticed that before."
-
-"Very strange!" muttered Holmes, pulling at the rope. "There are
-one or two very singular points about this room. For example,
-what a fool a builder must be to open a ventilator into another
-room, when, with the same trouble, he might have communicated
-with the outside air!"
-
-"That is also quite modern," said the lady.
-
-"Done about the same time as the bell-rope?" remarked Holmes.
-
-"Yes, there were several little changes carried out about that
-time."
-
-"They seem to have been of a most interesting character--dummy
-bell-ropes, and ventilators which do not ventilate. With your
-permission, Miss Stoner, we shall now carry our researches into
-the inner apartment."
-
-Dr. Grimesby Roylott's chamber was larger than that of his
-step-daughter, but was as plainly furnished. A camp-bed, a small
-wooden shelf full of books, mostly of a technical character, an
-armchair beside the bed, a plain wooden chair against the wall, a
-round table, and a large iron safe were the principal things
-which met the eye. Holmes walked slowly round and examined each
-and all of them with the keenest interest.
-
-"What's in here?" he asked, tapping the safe.
-
-"My stepfather's business papers."
-
-"Oh! you have seen inside, then?"
-
-"Only once, some years ago. I remember that it was full of
-papers."
-
-"There isn't a cat in it, for example?"
-
-"No. What a strange idea!"
-
-"Well, look at this!" He took up a small saucer of milk which
-stood on the top of it.
-
-"No; we don't keep a cat. But there is a cheetah and a baboon."
-
-"Ah, yes, of course! Well, a cheetah is just a big cat, and yet a
-saucer of milk does not go very far in satisfying its wants, I
-daresay. There is one point which I should wish to determine." He
-squatted down in front of the wooden chair and examined the seat
-of it with the greatest attention.
-
-"Thank you. That is quite settled," said he, rising and putting
-his lens in his pocket. "Hullo! Here is something interesting!"
-
-The object which had caught his eye was a small dog lash hung on
-one corner of the bed. The lash, however, was curled upon itself
-and tied so as to make a loop of whipcord.
-
-"What do you make of that, Watson?"
-
-"It's a common enough lash. But I don't know why it should be
-tied."
-
-"That is not quite so common, is it? Ah, me! it's a wicked world,
-and when a clever man turns his brains to crime it is the worst
-of all. I think that I have seen enough now, Miss Stoner, and
-with your permission we shall walk out upon the lawn."
-
-I had never seen my friend's face so grim or his brow so dark as
-it was when we turned from the scene of this investigation. We
-had walked several times up and down the lawn, neither Miss
-Stoner nor myself liking to break in upon his thoughts before he
-roused himself from his reverie.
-
-"It is very essential, Miss Stoner," said he, "that you should
-absolutely follow my advice in every respect."
-
-"I shall most certainly do so."
-
-"The matter is too serious for any hesitation. Your life may
-depend upon your compliance."
-
-"I assure you that I am in your hands."
-
-"In the first place, both my friend and I must spend the night in
-your room."
-
-Both Miss Stoner and I gazed at him in astonishment.
-
-"Yes, it must be so. Let me explain. I believe that that is the
-village inn over there?"
-
-"Yes, that is the Crown."
-
-"Very good. Your windows would be visible from there?"
-
-"Certainly."
-
-"You must confine yourself to your room, on pretence of a
-headache, when your stepfather comes back. Then when you hear him
-retire for the night, you must open the shutters of your window,
-undo the hasp, put your lamp there as a signal to us, and then
-withdraw quietly with everything which you are likely to want
-into the room which you used to occupy. I have no doubt that, in
-spite of the repairs, you could manage there for one night."
-
-"Oh, yes, easily."
-
-"The rest you will leave in our hands."
-
-"But what will you do?"
-
-"We shall spend the night in your room, and we shall investigate
-the cause of this noise which has disturbed you."
-
-"I believe, Mr. Holmes, that you have already made up your mind,"
-said Miss Stoner, laying her hand upon my companion's sleeve.
-
-"Perhaps I have."
-
-"Then, for pity's sake, tell me what was the cause of my sister's
-death."
-
-"I should prefer to have clearer proofs before I speak."
-
-"You can at least tell me whether my own thought is correct, and
-if she died from some sudden fright."
-
-"No, I do not think so. I think that there was probably some more
-tangible cause. And now, Miss Stoner, we must leave you for if
-Dr. Roylott returned and saw us our journey would be in vain.
-Good-bye, and be brave, for if you will do what I have told you,
-you may rest assured that we shall soon drive away the dangers
-that threaten you."
-
-Sherlock Holmes and I had no difficulty in engaging a bedroom and
-sitting-room at the Crown Inn. They were on the upper floor, and
-from our window we could command a view of the avenue gate, and
-of the inhabited wing of Stoke Moran Manor House. At dusk we saw
-Dr. Grimesby Roylott drive past, his huge form looming up beside
-the little figure of the lad who drove him. The boy had some
-slight difficulty in undoing the heavy iron gates, and we heard
-the hoarse roar of the doctor's voice and saw the fury with which
-he shook his clinched fists at him. The trap drove on, and a few
-minutes later we saw a sudden light spring up among the trees as
-the lamp was lit in one of the sitting-rooms.
-
-"Do you know, Watson," said Holmes as we sat together in the
-gathering darkness, "I have really some scruples as to taking you
-to-night. There is a distinct element of danger."
-
-"Can I be of assistance?"
-
-"Your presence might be invaluable."
-
-"Then I shall certainly come."
-
-"It is very kind of you."
-
-"You speak of danger. You have evidently seen more in these rooms
-than was visible to me."
-
-"No, but I fancy that I may have deduced a little more. I imagine
-that you saw all that I did."
-
-"I saw nothing remarkable save the bell-rope, and what purpose
-that could answer I confess is more than I can imagine."
-
-"You saw the ventilator, too?"
-
-"Yes, but I do not think that it is such a very unusual thing to
-have a small opening between two rooms. It was so small that a
-rat could hardly pass through."
-
-"I knew that we should find a ventilator before ever we came to
-Stoke Moran."
-
-"My dear Holmes!"
-
-"Oh, yes, I did. You remember in her statement she said that her
-sister could smell Dr. Roylott's cigar. Now, of course that
-suggested at once that there must be a communication between the
-two rooms. It could only be a small one, or it would have been
-remarked upon at the coroner's inquiry. I deduced a ventilator."
-
-"But what harm can there be in that?"
-
-"Well, there is at least a curious coincidence of dates. A
-ventilator is made, a cord is hung, and a lady who sleeps in the
-bed dies. Does not that strike you?"
-
-"I cannot as yet see any connection."
-
-"Did you observe anything very peculiar about that bed?"
-
-"No."
-
-"It was clamped to the floor. Did you ever see a bed fastened
-like that before?"
-
-"I cannot say that I have."
-
-"The lady could not move her bed. It must always be in the same
-relative position to the ventilator and to the rope--or so we may
-call it, since it was clearly never meant for a bell-pull."
-
-"Holmes," I cried, "I seem to see dimly what you are hinting at.
-We are only just in time to prevent some subtle and horrible
-crime."
-
-"Subtle enough and horrible enough. When a doctor does go wrong
-he is the first of criminals. He has nerve and he has knowledge.
-Palmer and Pritchard were among the heads of their profession.
-This man strikes even deeper, but I think, Watson, that we shall
-be able to strike deeper still. But we shall have horrors enough
-before the night is over; for goodness' sake let us have a quiet
-pipe and turn our minds for a few hours to something more
-cheerful."
-
-
-About nine o'clock the light among the trees was extinguished,
-and all was dark in the direction of the Manor House. Two hours
-passed slowly away, and then, suddenly, just at the stroke of
-eleven, a single bright light shone out right in front of us.
-
-"That is our signal," said Holmes, springing to his feet; "it
-comes from the middle window."
-
-As we passed out he exchanged a few words with the landlord,
-explaining that we were going on a late visit to an acquaintance,
-and that it was possible that we might spend the night there. A
-moment later we were out on the dark road, a chill wind blowing
-in our faces, and one yellow light twinkling in front of us
-through the gloom to guide us on our sombre errand.
-
-There was little difficulty in entering the grounds, for
-unrepaired breaches gaped in the old park wall. Making our way
-among the trees, we reached the lawn, crossed it, and were about
-to enter through the window when out from a clump of laurel
-bushes there darted what seemed to be a hideous and distorted
-child, who threw itself upon the grass with writhing limbs and
-then ran swiftly across the lawn into the darkness.
-
-"My God!" I whispered; "did you see it?"
-
-Holmes was for the moment as startled as I. His hand closed like
-a vice upon my wrist in his agitation. Then he broke into a low
-laugh and put his lips to my ear.
-
-"It is a nice household," he murmured. "That is the baboon."
-
-I had forgotten the strange pets which the doctor affected. There
-was a cheetah, too; perhaps we might find it upon our shoulders
-at any moment. I confess that I felt easier in my mind when,
-after following Holmes' example and slipping off my shoes, I
-found myself inside the bedroom. My companion noiselessly closed
-the shutters, moved the lamp onto the table, and cast his eyes
-round the room. All was as we had seen it in the daytime. Then
-creeping up to me and making a trumpet of his hand, he whispered
-into my ear again so gently that it was all that I could do to
-distinguish the words:
-
-"The least sound would be fatal to our plans."
-
-I nodded to show that I had heard.
-
-"We must sit without light. He would see it through the
-ventilator."
-
-I nodded again.
-
-"Do not go asleep; your very life may depend upon it. Have your
-pistol ready in case we should need it. I will sit on the side of
-the bed, and you in that chair."
-
-I took out my revolver and laid it on the corner of the table.
-
-Holmes had brought up a long thin cane, and this he placed upon
-the bed beside him. By it he laid the box of matches and the
-stump of a candle. Then he turned down the lamp, and we were left
-in darkness.
-
-How shall I ever forget that dreadful vigil? I could not hear a
-sound, not even the drawing of a breath, and yet I knew that my
-companion sat open-eyed, within a few feet of me, in the same
-state of nervous tension in which I was myself. The shutters cut
-off the least ray of light, and we waited in absolute darkness.
-
-From outside came the occasional cry of a night-bird, and once at
-our very window a long drawn catlike whine, which told us that
-the cheetah was indeed at liberty. Far away we could hear the
-deep tones of the parish clock, which boomed out every quarter of
-an hour. How long they seemed, those quarters! Twelve struck, and
-one and two and three, and still we sat waiting silently for
-whatever might befall.
-
-Suddenly there was the momentary gleam of a light up in the
-direction of the ventilator, which vanished immediately, but was
-succeeded by a strong smell of burning oil and heated metal.
-Someone in the next room had lit a dark-lantern. I heard a gentle
-sound of movement, and then all was silent once more, though the
-smell grew stronger. For half an hour I sat with straining ears.
-Then suddenly another sound became audible--a very gentle,
-soothing sound, like that of a small jet of steam escaping
-continually from a kettle. The instant that we heard it, Holmes
-sprang from the bed, struck a match, and lashed furiously with
-his cane at the bell-pull.
-
-"You see it, Watson?" he yelled. "You see it?"
-
-But I saw nothing. At the moment when Holmes struck the light I
-heard a low, clear whistle, but the sudden glare flashing into my
-weary eyes made it impossible for me to tell what it was at which
-my friend lashed so savagely. I could, however, see that his face
-was deadly pale and filled with horror and loathing. He had
-ceased to strike and was gazing up at the ventilator when
-suddenly there broke from the silence of the night the most
-horrible cry to which I have ever listened. It swelled up louder
-and louder, a hoarse yell of pain and fear and anger all mingled
-in the one dreadful shriek. They say that away down in the
-village, and even in the distant parsonage, that cry raised the
-sleepers from their beds. It struck cold to our hearts, and I
-stood gazing at Holmes, and he at me, until the last echoes of it
-had died away into the silence from which it rose.
-
-"What can it mean?" I gasped.
-
-"It means that it is all over," Holmes answered. "And perhaps,
-after all, it is for the best. Take your pistol, and we will
-enter Dr. Roylott's room."
-
-With a grave face he lit the lamp and led the way down the
-corridor. Twice he struck at the chamber door without any reply
-from within. Then he turned the handle and entered, I at his
-heels, with the cocked pistol in my hand.
-
-It was a singular sight which met our eyes. On the table stood a
-dark-lantern with the shutter half open, throwing a brilliant
-beam of light upon the iron safe, the door of which was ajar.
-Beside this table, on the wooden chair, sat Dr. Grimesby Roylott
-clad in a long grey dressing-gown, his bare ankles protruding
-beneath, and his feet thrust into red heelless Turkish slippers.
-Across his lap lay the short stock with the long lash which we
-had noticed during the day. His chin was cocked upward and his
-eyes were fixed in a dreadful, rigid stare at the corner of the
-ceiling. Round his brow he had a peculiar yellow band, with
-brownish speckles, which seemed to be bound tightly round his
-head. As we entered he made neither sound nor motion.
-
-"The band! the speckled band!" whispered Holmes.
-
-I took a step forward. In an instant his strange headgear began
-to move, and there reared itself from among his hair the squat
-diamond-shaped head and puffed neck of a loathsome serpent.
-
-"It is a swamp adder!" cried Holmes; "the deadliest snake in
-India. He has died within ten seconds of being bitten. Violence
-does, in truth, recoil upon the violent, and the schemer falls
-into the pit which he digs for another. Let us thrust this
-creature back into its den, and we can then remove Miss Stoner to
-some place of shelter and let the county police know what has
-happened."
-
-As he spoke he drew the dog-whip swiftly from the dead man's lap,
-and throwing the noose round the reptile's neck he drew it from
-its horrid perch and, carrying it at arm's length, threw it into
-the iron safe, which he closed upon it.
-
-Such are the true facts of the death of Dr. Grimesby Roylott, of
-Stoke Moran. It is not necessary that I should prolong a
-narrative which has already run to too great a length by telling
-how we broke the sad news to the terrified girl, how we conveyed
-her by the morning train to the care of her good aunt at Harrow,
-of how the slow process of official inquiry came to the
-conclusion that the doctor met his fate while indiscreetly
-playing with a dangerous pet. The little which I had yet to learn
-of the case was told me by Sherlock Holmes as we travelled back
-next day.
-
-"I had," said he, "come to an entirely erroneous conclusion which
-shows, my dear Watson, how dangerous it always is to reason from
-insufficient data. The presence of the gipsies, and the use of
-the word 'band,' which was used by the poor girl, no doubt, to
-explain the appearance which she had caught a hurried glimpse of
-by the light of her match, were sufficient to put me upon an
-entirely wrong scent. I can only claim the merit that I instantly
-reconsidered my position when, however, it became clear to me
-that whatever danger threatened an occupant of the room could not
-come either from the window or the door. My attention was
-speedily drawn, as I have already remarked to you, to this
-ventilator, and to the bell-rope which hung down to the bed. The
-discovery that this was a dummy, and that the bed was clamped to
-the floor, instantly gave rise to the suspicion that the rope was
-there as a bridge for something passing through the hole and
-coming to the bed. The idea of a snake instantly occurred to me,
-and when I coupled it with my knowledge that the doctor was
-furnished with a supply of creatures from India, I felt that I
-was probably on the right track. The idea of using a form of
-poison which could not possibly be discovered by any chemical
-test was just such a one as would occur to a clever and ruthless
-man who had had an Eastern training. The rapidity with which such
-a poison would take effect would also, from his point of view, be
-an advantage. It would be a sharp-eyed coroner, indeed, who could
-distinguish the two little dark punctures which would show where
-the poison fangs had done their work. Then I thought of the
-whistle. Of course he must recall the snake before the morning
-light revealed it to the victim. He had trained it, probably by
-the use of the milk which we saw, to return to him when summoned.
-He would put it through this ventilator at the hour that he
-thought best, with the certainty that it would crawl down the
-rope and land on the bed. It might or might not bite the
-occupant, perhaps she might escape every night for a week, but
-sooner or later she must fall a victim.
-
-"I had come to these conclusions before ever I had entered his
-room. An inspection of his chair showed me that he had been in
-the habit of standing on it, which of course would be necessary
-in order that he should reach the ventilator. The sight of the
-safe, the saucer of milk, and the loop of whipcord were enough to
-finally dispel any doubts which may have remained. The metallic
-clang heard by Miss Stoner was obviously caused by her stepfather
-hastily closing the door of his safe upon its terrible occupant.
-Having once made up my mind, you know the steps which I took in
-order to put the matter to the proof. I heard the creature hiss
-as I have no doubt that you did also, and I instantly lit the
-light and attacked it."
-
-"With the result of driving it through the ventilator."
-
-"And also with the result of causing it to turn upon its master
-at the other side. Some of the blows of my cane came home and
-roused its snakish temper, so that it flew upon the first person
-it saw. In this way I am no doubt indirectly responsible for Dr.
-Grimesby Roylott's death, and I cannot say that it is likely to
-weigh very heavily upon my conscience."
-
-
-
-IX. THE ADVENTURE OF THE ENGINEER'S THUMB
-
-Of all the problems which have been submitted to my friend, Mr.
-Sherlock Holmes, for solution during the years of our intimacy,
-there were only two which I was the means of introducing to his
-notice--that of Mr. Hatherley's thumb, and that of Colonel
-Warburton's madness. Of these the latter may have afforded a
-finer field for an acute and original observer, but the other was
-so strange in its inception and so dramatic in its details that
-it may be the more worthy of being placed upon record, even if it
-gave my friend fewer openings for those deductive methods of
-reasoning by which he achieved such remarkable results. The story
-has, I believe, been told more than once in the newspapers, but,
-like all such narratives, its effect is much less striking when
-set forth en bloc in a single half-column of print than when the
-facts slowly evolve before your own eyes, and the mystery clears
-gradually away as each new discovery furnishes a step which leads
-on to the complete truth. At the time the circumstances made a
-deep impression upon me, and the lapse of two years has hardly
-served to weaken the effect.
-
-It was in the summer of '89, not long after my marriage, that the
-events occurred which I am now about to summarise. I had returned
-to civil practice and had finally abandoned Holmes in his Baker
-Street rooms, although I continually visited him and occasionally
-even persuaded him to forgo his Bohemian habits so far as to come
-and visit us. My practice had steadily increased, and as I
-happened to live at no very great distance from Paddington
-Station, I got a few patients from among the officials. One of
-these, whom I had cured of a painful and lingering disease, was
-never weary of advertising my virtues and of endeavouring to send
-me on every sufferer over whom he might have any influence.
-
-One morning, at a little before seven o'clock, I was awakened by
-the maid tapping at the door to announce that two men had come
-from Paddington and were waiting in the consulting-room. I
-dressed hurriedly, for I knew by experience that railway cases
-were seldom trivial, and hastened downstairs. As I descended, my
-old ally, the guard, came out of the room and closed the door
-tightly behind him.
-
-"I've got him here," he whispered, jerking his thumb over his
-shoulder; "he's all right."
-
-"What is it, then?" I asked, for his manner suggested that it was
-some strange creature which he had caged up in my room.
-
-"It's a new patient," he whispered. "I thought I'd bring him
-round myself; then he couldn't slip away. There he is, all safe
-and sound. I must go now, Doctor; I have my dooties, just the
-same as you." And off he went, this trusty tout, without even
-giving me time to thank him.
-
-I entered my consulting-room and found a gentleman seated by the
-table. He was quietly dressed in a suit of heather tweed with a
-soft cloth cap which he had laid down upon my books. Round one of
-his hands he had a handkerchief wrapped, which was mottled all
-over with bloodstains. He was young, not more than
-five-and-twenty, I should say, with a strong, masculine face; but
-he was exceedingly pale and gave me the impression of a man who
-was suffering from some strong agitation, which it took all his
-strength of mind to control.
-
-"I am sorry to knock you up so early, Doctor," said he, "but I
-have had a very serious accident during the night. I came in by
-train this morning, and on inquiring at Paddington as to where I
-might find a doctor, a worthy fellow very kindly escorted me
-here. I gave the maid a card, but I see that she has left it upon
-the side-table."
-
-I took it up and glanced at it. "Mr. Victor Hatherley, hydraulic
-engineer, 16A, Victoria Street (3rd floor)." That was the name,
-style, and abode of my morning visitor. "I regret that I have
-kept you waiting," said I, sitting down in my library-chair. "You
-are fresh from a night journey, I understand, which is in itself
-a monotonous occupation."
-
-"Oh, my night could not be called monotonous," said he, and
-laughed. He laughed very heartily, with a high, ringing note,
-leaning back in his chair and shaking his sides. All my medical
-instincts rose up against that laugh.
-
-"Stop it!" I cried; "pull yourself together!" and I poured out
-some water from a caraffe.
-
-It was useless, however. He was off in one of those hysterical
-outbursts which come upon a strong nature when some great crisis
-is over and gone. Presently he came to himself once more, very
-weary and pale-looking.
-
-"I have been making a fool of myself," he gasped.
-
-"Not at all. Drink this." I dashed some brandy into the water,
-and the colour began to come back to his bloodless cheeks.
-
-"That's better!" said he. "And now, Doctor, perhaps you would
-kindly attend to my thumb, or rather to the place where my thumb
-used to be."
-
-He unwound the handkerchief and held out his hand. It gave even
-my hardened nerves a shudder to look at it. There were four
-protruding fingers and a horrid red, spongy surface where the
-thumb should have been. It had been hacked or torn right out from
-the roots.
-
-"Good heavens!" I cried, "this is a terrible injury. It must have
-bled considerably."
-
-"Yes, it did. I fainted when it was done, and I think that I must
-have been senseless for a long time. When I came to I found that
-it was still bleeding, so I tied one end of my handkerchief very
-tightly round the wrist and braced it up with a twig."
-
-"Excellent! You should have been a surgeon."
-
-"It is a question of hydraulics, you see, and came within my own
-province."
-
-"This has been done," said I, examining the wound, "by a very
-heavy and sharp instrument."
-
-"A thing like a cleaver," said he.
-
-"An accident, I presume?"
-
-"By no means."
-
-"What! a murderous attack?"
-
-"Very murderous indeed."
-
-"You horrify me."
-
-I sponged the wound, cleaned it, dressed it, and finally covered
-it over with cotton wadding and carbolised bandages. He lay back
-without wincing, though he bit his lip from time to time.
-
-"How is that?" I asked when I had finished.
-
-"Capital! Between your brandy and your bandage, I feel a new man.
-I was very weak, but I have had a good deal to go through."
-
-"Perhaps you had better not speak of the matter. It is evidently
-trying to your nerves."
-
-"Oh, no, not now. I shall have to tell my tale to the police;
-but, between ourselves, if it were not for the convincing
-evidence of this wound of mine, I should be surprised if they
-believed my statement, for it is a very extraordinary one, and I
-have not much in the way of proof with which to back it up; and,
-even if they believe me, the clues which I can give them are so
-vague that it is a question whether justice will be done."
-
-"Ha!" cried I, "if it is anything in the nature of a problem
-which you desire to see solved, I should strongly recommend you
-to come to my friend, Mr. Sherlock Holmes, before you go to the
-official police."
-
-"Oh, I have heard of that fellow," answered my visitor, "and I
-should be very glad if he would take the matter up, though of
-course I must use the official police as well. Would you give me
-an introduction to him?"
-
-"I'll do better. I'll take you round to him myself."
-
-"I should be immensely obliged to you."
-
-"We'll call a cab and go together. We shall just be in time to
-have a little breakfast with him. Do you feel equal to it?"
-
-"Yes; I shall not feel easy until I have told my story."
-
-"Then my servant will call a cab, and I shall be with you in an
-instant." I rushed upstairs, explained the matter shortly to my
-wife, and in five minutes was inside a hansom, driving with my
-new acquaintance to Baker Street.
-
-Sherlock Holmes was, as I expected, lounging about his
-sitting-room in his dressing-gown, reading the agony column of The
-Times and smoking his before-breakfast pipe, which was composed
-of all the plugs and dottles left from his smokes of the day
-before, all carefully dried and collected on the corner of the
-mantelpiece. He received us in his quietly genial fashion,
-ordered fresh rashers and eggs, and joined us in a hearty meal.
-When it was concluded he settled our new acquaintance upon the
-sofa, placed a pillow beneath his head, and laid a glass of
-brandy and water within his reach.
-
-"It is easy to see that your experience has been no common one,
-Mr. Hatherley," said he. "Pray, lie down there and make yourself
-absolutely at home. Tell us what you can, but stop when you are
-tired and keep up your strength with a little stimulant."
-
-"Thank you," said my patient, "but I have felt another man since
-the doctor bandaged me, and I think that your breakfast has
-completed the cure. I shall take up as little of your valuable
-time as possible, so I shall start at once upon my peculiar
-experiences."
-
-Holmes sat in his big armchair with the weary, heavy-lidded
-expression which veiled his keen and eager nature, while I sat
-opposite to him, and we listened in silence to the strange story
-which our visitor detailed to us.
-
-"You must know," said he, "that I am an orphan and a bachelor,
-residing alone in lodgings in London. By profession I am a
-hydraulic engineer, and I have had considerable experience of my
-work during the seven years that I was apprenticed to Venner &
-Matheson, the well-known firm, of Greenwich. Two years ago,
-having served my time, and having also come into a fair sum of
-money through my poor father's death, I determined to start in
-business for myself and took professional chambers in Victoria
-Street.
-
-"I suppose that everyone finds his first independent start in
-business a dreary experience. To me it has been exceptionally so.
-During two years I have had three consultations and one small
-job, and that is absolutely all that my profession has brought
-me. My gross takings amount to 27 pounds 10s. Every day, from
-nine in the morning until four in the afternoon, I waited in my
-little den, until at last my heart began to sink, and I came to
-believe that I should never have any practice at all.
-
-"Yesterday, however, just as I was thinking of leaving the
-office, my clerk entered to say there was a gentleman waiting who
-wished to see me upon business. He brought up a card, too, with
-the name of 'Colonel Lysander Stark' engraved upon it. Close at
-his heels came the colonel himself, a man rather over the middle
-size, but of an exceeding thinness. I do not think that I have
-ever seen so thin a man. His whole face sharpened away into nose
-and chin, and the skin of his cheeks was drawn quite tense over
-his outstanding bones. Yet this emaciation seemed to be his
-natural habit, and due to no disease, for his eye was bright, his
-step brisk, and his bearing assured. He was plainly but neatly
-dressed, and his age, I should judge, would be nearer forty than
-thirty.
-
-"'Mr. Hatherley?' said he, with something of a German accent.
-'You have been recommended to me, Mr. Hatherley, as being a man
-who is not only proficient in his profession but is also discreet
-and capable of preserving a secret.'
-
-"I bowed, feeling as flattered as any young man would at such an
-address. 'May I ask who it was who gave me so good a character?'
-
-"'Well, perhaps it is better that I should not tell you that just
-at this moment. I have it from the same source that you are both
-an orphan and a bachelor and are residing alone in London.'
-
-"'That is quite correct,' I answered; 'but you will excuse me if
-I say that I cannot see how all this bears upon my professional
-qualifications. I understand that it was on a professional matter
-that you wished to speak to me?'
-
-"'Undoubtedly so. But you will find that all I say is really to
-the point. I have a professional commission for you, but absolute
-secrecy is quite essential--absolute secrecy, you understand, and
-of course we may expect that more from a man who is alone than
-from one who lives in the bosom of his family.'
-
-"'If I promise to keep a secret,' said I, 'you may absolutely
-depend upon my doing so.'
-
-"He looked very hard at me as I spoke, and it seemed to me that I
-had never seen so suspicious and questioning an eye.
-
-"'Do you promise, then?' said he at last.
-
-"'Yes, I promise.'
-
-"'Absolute and complete silence before, during, and after? No
-reference to the matter at all, either in word or writing?'
-
-"'I have already given you my word.'
-
-"'Very good.' He suddenly sprang up, and darting like lightning
-across the room he flung open the door. The passage outside was
-empty.
-
-"'That's all right,' said he, coming back. 'I know that clerks are
-sometimes curious as to their master's affairs. Now we can talk
-in safety.' He drew up his chair very close to mine and began to
-stare at me again with the same questioning and thoughtful look.
-
-"A feeling of repulsion, and of something akin to fear had begun
-to rise within me at the strange antics of this fleshless man.
-Even my dread of losing a client could not restrain me from
-showing my impatience.
-
-"'I beg that you will state your business, sir,' said I; 'my time
-is of value.' Heaven forgive me for that last sentence, but the
-words came to my lips.
-
-"'How would fifty guineas for a night's work suit you?' he asked.
-
-"'Most admirably.'
-
-"'I say a night's work, but an hour's would be nearer the mark. I
-simply want your opinion about a hydraulic stamping machine which
-has got out of gear. If you show us what is wrong we shall soon
-set it right ourselves. What do you think of such a commission as
-that?'
-
-"'The work appears to be light and the pay munificent.'
-
-"'Precisely so. We shall want you to come to-night by the last
-train.'
-
-"'Where to?'
-
-"'To Eyford, in Berkshire. It is a little place near the borders
-of Oxfordshire, and within seven miles of Reading. There is a
-train from Paddington which would bring you there at about
-11:15.'
-
-"'Very good.'
-
-"'I shall come down in a carriage to meet you.'
-
-"'There is a drive, then?'
-
-"'Yes, our little place is quite out in the country. It is a good
-seven miles from Eyford Station.'
-
-"'Then we can hardly get there before midnight. I suppose there
-would be no chance of a train back. I should be compelled to stop
-the night.'
-
-"'Yes, we could easily give you a shake-down.'
-
-"'That is very awkward. Could I not come at some more convenient
-hour?'
-
-"'We have judged it best that you should come late. It is to
-recompense you for any inconvenience that we are paying to you, a
-young and unknown man, a fee which would buy an opinion from the
-very heads of your profession. Still, of course, if you would
-like to draw out of the business, there is plenty of time to do
-so.'
-
-"I thought of the fifty guineas, and of how very useful they
-would be to me. 'Not at all,' said I, 'I shall be very happy to
-accommodate myself to your wishes. I should like, however, to
-understand a little more clearly what it is that you wish me to
-do.'
-
-"'Quite so. It is very natural that the pledge of secrecy which
-we have exacted from you should have aroused your curiosity. I
-have no wish to commit you to anything without your having it all
-laid before you. I suppose that we are absolutely safe from
-eavesdroppers?'
-
-"'Entirely.'
-
-"'Then the matter stands thus. You are probably aware that
-fuller's-earth is a valuable product, and that it is only found
-in one or two places in England?'
-
-"'I have heard so.'
-
-"'Some little time ago I bought a small place--a very small
-place--within ten miles of Reading. I was fortunate enough to
-discover that there was a deposit of fuller's-earth in one of my
-fields. On examining it, however, I found that this deposit was a
-comparatively small one, and that it formed a link between two
-very much larger ones upon the right and left--both of them,
-however, in the grounds of my neighbours. These good people were
-absolutely ignorant that their land contained that which was
-quite as valuable as a gold-mine. Naturally, it was to my
-interest to buy their land before they discovered its true value,
-but unfortunately I had no capital by which I could do this. I
-took a few of my friends into the secret, however, and they
-suggested that we should quietly and secretly work our own little
-deposit and that in this way we should earn the money which would
-enable us to buy the neighbouring fields. This we have now been
-doing for some time, and in order to help us in our operations we
-erected a hydraulic press. This press, as I have already
-explained, has got out of order, and we wish your advice upon the
-subject. We guard our secret very jealously, however, and if it
-once became known that we had hydraulic engineers coming to our
-little house, it would soon rouse inquiry, and then, if the facts
-came out, it would be good-bye to any chance of getting these
-fields and carrying out our plans. That is why I have made you
-promise me that you will not tell a human being that you are
-going to Eyford to-night. I hope that I make it all plain?'
-
-"'I quite follow you,' said I. 'The only point which I could not
-quite understand was what use you could make of a hydraulic press
-in excavating fuller's-earth, which, as I understand, is dug out
-like gravel from a pit.'
-
-"'Ah!' said he carelessly, 'we have our own process. We compress
-the earth into bricks, so as to remove them without revealing
-what they are. But that is a mere detail. I have taken you fully
-into my confidence now, Mr. Hatherley, and I have shown you how I
-trust you.' He rose as he spoke. 'I shall expect you, then, at
-Eyford at 11:15.'
-
-"'I shall certainly be there.'
-
-"'And not a word to a soul.' He looked at me with a last long,
-questioning gaze, and then, pressing my hand in a cold, dank
-grasp, he hurried from the room.
-
-"Well, when I came to think it all over in cool blood I was very
-much astonished, as you may both think, at this sudden commission
-which had been intrusted to me. On the one hand, of course, I was
-glad, for the fee was at least tenfold what I should have asked
-had I set a price upon my own services, and it was possible that
-this order might lead to other ones. On the other hand, the face
-and manner of my patron had made an unpleasant impression upon
-me, and I could not think that his explanation of the
-fuller's-earth was sufficient to explain the necessity for my
-coming at midnight, and his extreme anxiety lest I should tell
-anyone of my errand. However, I threw all fears to the winds, ate
-a hearty supper, drove to Paddington, and started off, having
-obeyed to the letter the injunction as to holding my tongue.
-
-"At Reading I had to change not only my carriage but my station.
-However, I was in time for the last train to Eyford, and I
-reached the little dim-lit station after eleven o'clock. I was the
-only passenger who got out there, and there was no one upon the
-platform save a single sleepy porter with a lantern. As I passed
-out through the wicket gate, however, I found my acquaintance of
-the morning waiting in the shadow upon the other side. Without a
-word he grasped my arm and hurried me into a carriage, the door
-of which was standing open. He drew up the windows on either
-side, tapped on the wood-work, and away we went as fast as the
-horse could go."
-
-"One horse?" interjected Holmes.
-
-"Yes, only one."
-
-"Did you observe the colour?"
-
-"Yes, I saw it by the side-lights when I was stepping into the
-carriage. It was a chestnut."
-
-"Tired-looking or fresh?"
-
-"Oh, fresh and glossy."
-
-"Thank you. I am sorry to have interrupted you. Pray continue
-your most interesting statement."
-
-"Away we went then, and we drove for at least an hour. Colonel
-Lysander Stark had said that it was only seven miles, but I
-should think, from the rate that we seemed to go, and from the
-time that we took, that it must have been nearer twelve. He sat
-at my side in silence all the time, and I was aware, more than
-once when I glanced in his direction, that he was looking at me
-with great intensity. The country roads seem to be not very good
-in that part of the world, for we lurched and jolted terribly. I
-tried to look out of the windows to see something of where we
-were, but they were made of frosted glass, and I could make out
-nothing save the occasional bright blur of a passing light. Now
-and then I hazarded some remark to break the monotony of the
-journey, but the colonel answered only in monosyllables, and the
-conversation soon flagged. At last, however, the bumping of the
-road was exchanged for the crisp smoothness of a gravel-drive,
-and the carriage came to a stand. Colonel Lysander Stark sprang
-out, and, as I followed after him, pulled me swiftly into a porch
-which gaped in front of us. We stepped, as it were, right out of
-the carriage and into the hall, so that I failed to catch the
-most fleeting glance of the front of the house. The instant that
-I had crossed the threshold the door slammed heavily behind us,
-and I heard faintly the rattle of the wheels as the carriage
-drove away.
-
-"It was pitch dark inside the house, and the colonel fumbled
-about looking for matches and muttering under his breath.
-Suddenly a door opened at the other end of the passage, and a
-long, golden bar of light shot out in our direction. It grew
-broader, and a woman appeared with a lamp in her hand, which she
-held above her head, pushing her face forward and peering at us.
-I could see that she was pretty, and from the gloss with which
-the light shone upon her dark dress I knew that it was a rich
-material. She spoke a few words in a foreign tongue in a tone as
-though asking a question, and when my companion answered in a
-gruff monosyllable she gave such a start that the lamp nearly
-fell from her hand. Colonel Stark went up to her, whispered
-something in her ear, and then, pushing her back into the room
-from whence she had come, he walked towards me again with the
-lamp in his hand.
-
-"'Perhaps you will have the kindness to wait in this room for a
-few minutes,' said he, throwing open another door. It was a
-quiet, little, plainly furnished room, with a round table in the
-centre, on which several German books were scattered. Colonel
-Stark laid down the lamp on the top of a harmonium beside the
-door. 'I shall not keep you waiting an instant,' said he, and
-vanished into the darkness.
-
-"I glanced at the books upon the table, and in spite of my
-ignorance of German I could see that two of them were treatises
-on science, the others being volumes of poetry. Then I walked
-across to the window, hoping that I might catch some glimpse of
-the country-side, but an oak shutter, heavily barred, was folded
-across it. It was a wonderfully silent house. There was an old
-clock ticking loudly somewhere in the passage, but otherwise
-everything was deadly still. A vague feeling of uneasiness began
-to steal over me. Who were these German people, and what were
-they doing living in this strange, out-of-the-way place? And
-where was the place? I was ten miles or so from Eyford, that was
-all I knew, but whether north, south, east, or west I had no
-idea. For that matter, Reading, and possibly other large towns,
-were within that radius, so the place might not be so secluded,
-after all. Yet it was quite certain, from the absolute stillness,
-that we were in the country. I paced up and down the room,
-humming a tune under my breath to keep up my spirits and feeling
-that I was thoroughly earning my fifty-guinea fee.
-
-"Suddenly, without any preliminary sound in the midst of the
-utter stillness, the door of my room swung slowly open. The woman
-was standing in the aperture, the darkness of the hall behind
-her, the yellow light from my lamp beating upon her eager and
-beautiful face. I could see at a glance that she was sick with
-fear, and the sight sent a chill to my own heart. She held up one
-shaking finger to warn me to be silent, and she shot a few
-whispered words of broken English at me, her eyes glancing back,
-like those of a frightened horse, into the gloom behind her.
-
-"'I would go,' said she, trying hard, as it seemed to me, to
-speak calmly; 'I would go. I should not stay here. There is no
-good for you to do.'
-
-"'But, madam,' said I, 'I have not yet done what I came for. I
-cannot possibly leave until I have seen the machine.'
-
-"'It is not worth your while to wait,' she went on. 'You can pass
-through the door; no one hinders.' And then, seeing that I smiled
-and shook my head, she suddenly threw aside her constraint and
-made a step forward, with her hands wrung together. 'For the love
-of Heaven!' she whispered, 'get away from here before it is too
-late!'
-
-"But I am somewhat headstrong by nature, and the more ready to
-engage in an affair when there is some obstacle in the way. I
-thought of my fifty-guinea fee, of my wearisome journey, and of
-the unpleasant night which seemed to be before me. Was it all to
-go for nothing? Why should I slink away without having carried
-out my commission, and without the payment which was my due? This
-woman might, for all I knew, be a monomaniac. With a stout
-bearing, therefore, though her manner had shaken me more than I
-cared to confess, I still shook my head and declared my intention
-of remaining where I was. She was about to renew her entreaties
-when a door slammed overhead, and the sound of several footsteps
-was heard upon the stairs. She listened for an instant, threw up
-her hands with a despairing gesture, and vanished as suddenly and
-as noiselessly as she had come.
-
-"The newcomers were Colonel Lysander Stark and a short thick man
-with a chinchilla beard growing out of the creases of his double
-chin, who was introduced to me as Mr. Ferguson.
-
-"'This is my secretary and manager,' said the colonel. 'By the
-way, I was under the impression that I left this door shut just
-now. I fear that you have felt the draught.'
-
-"'On the contrary,' said I, 'I opened the door myself because I
-felt the room to be a little close.'
-
-"He shot one of his suspicious looks at me. 'Perhaps we had
-better proceed to business, then,' said he. 'Mr. Ferguson and I
-will take you up to see the machine.'
-
-"'I had better put my hat on, I suppose.'
-
-"'Oh, no, it is in the house.'
-
-"'What, you dig fuller's-earth in the house?'
-
-"'No, no. This is only where we compress it. But never mind that.
-All we wish you to do is to examine the machine and to let us
-know what is wrong with it.'
-
-"We went upstairs together, the colonel first with the lamp, the
-fat manager and I behind him. It was a labyrinth of an old house,
-with corridors, passages, narrow winding staircases, and little
-low doors, the thresholds of which were hollowed out by the
-generations who had crossed them. There were no carpets and no
-signs of any furniture above the ground floor, while the plaster
-was peeling off the walls, and the damp was breaking through in
-green, unhealthy blotches. I tried to put on as unconcerned an
-air as possible, but I had not forgotten the warnings of the
-lady, even though I disregarded them, and I kept a keen eye upon
-my two companions. Ferguson appeared to be a morose and silent
-man, but I could see from the little that he said that he was at
-least a fellow-countryman.
-
-"Colonel Lysander Stark stopped at last before a low door, which
-he unlocked. Within was a small, square room, in which the three
-of us could hardly get at one time. Ferguson remained outside,
-and the colonel ushered me in.
-
-"'We are now,' said he, 'actually within the hydraulic press, and
-it would be a particularly unpleasant thing for us if anyone were
-to turn it on. The ceiling of this small chamber is really the
-end of the descending piston, and it comes down with the force of
-many tons upon this metal floor. There are small lateral columns
-of water outside which receive the force, and which transmit and
-multiply it in the manner which is familiar to you. The machine
-goes readily enough, but there is some stiffness in the working
-of it, and it has lost a little of its force. Perhaps you will
-have the goodness to look it over and to show us how we can set
-it right.'
-
-"I took the lamp from him, and I examined the machine very
-thoroughly. It was indeed a gigantic one, and capable of
-exercising enormous pressure. When I passed outside, however, and
-pressed down the levers which controlled it, I knew at once by
-the whishing sound that there was a slight leakage, which allowed
-a regurgitation of water through one of the side cylinders. An
-examination showed that one of the india-rubber bands which was
-round the head of a driving-rod had shrunk so as not quite to
-fill the socket along which it worked. This was clearly the cause
-of the loss of power, and I pointed it out to my companions, who
-followed my remarks very carefully and asked several practical
-questions as to how they should proceed to set it right. When I
-had made it clear to them, I returned to the main chamber of the
-machine and took a good look at it to satisfy my own curiosity.
-It was obvious at a glance that the story of the fuller's-earth
-was the merest fabrication, for it would be absurd to suppose
-that so powerful an engine could be designed for so inadequate a
-purpose. The walls were of wood, but the floor consisted of a
-large iron trough, and when I came to examine it I could see a
-crust of metallic deposit all over it. I had stooped and was
-scraping at this to see exactly what it was when I heard a
-muttered exclamation in German and saw the cadaverous face of the
-colonel looking down at me.
-
-"'What are you doing there?' he asked.
-
-"I felt angry at having been tricked by so elaborate a story as
-that which he had told me. 'I was admiring your fuller's-earth,'
-said I; 'I think that I should be better able to advise you as to
-your machine if I knew what the exact purpose was for which it
-was used.'
-
-"The instant that I uttered the words I regretted the rashness of
-my speech. His face set hard, and a baleful light sprang up in
-his grey eyes.
-
-"'Very well,' said he, 'you shall know all about the machine.' He
-took a step backward, slammed the little door, and turned the key
-in the lock. I rushed towards it and pulled at the handle, but it
-was quite secure, and did not give in the least to my kicks and
-shoves. 'Hullo!' I yelled. 'Hullo! Colonel! Let me out!'
-
-"And then suddenly in the silence I heard a sound which sent my
-heart into my mouth. It was the clank of the levers and the swish
-of the leaking cylinder. He had set the engine at work. The lamp
-still stood upon the floor where I had placed it when examining
-the trough. By its light I saw that the black ceiling was coming
-down upon me, slowly, jerkily, but, as none knew better than
-myself, with a force which must within a minute grind me to a
-shapeless pulp. I threw myself, screaming, against the door, and
-dragged with my nails at the lock. I implored the colonel to let
-me out, but the remorseless clanking of the levers drowned my
-cries. The ceiling was only a foot or two above my head, and with
-my hand upraised I could feel its hard, rough surface. Then it
-flashed through my mind that the pain of my death would depend
-very much upon the position in which I met it. If I lay on my
-face the weight would come upon my spine, and I shuddered to
-think of that dreadful snap. Easier the other way, perhaps; and
-yet, had I the nerve to lie and look up at that deadly black
-shadow wavering down upon me? Already I was unable to stand
-erect, when my eye caught something which brought a gush of hope
-back to my heart.
-
-"I have said that though the floor and ceiling were of iron, the
-walls were of wood. As I gave a last hurried glance around, I saw
-a thin line of yellow light between two of the boards, which
-broadened and broadened as a small panel was pushed backward. For
-an instant I could hardly believe that here was indeed a door
-which led away from death. The next instant I threw myself
-through, and lay half-fainting upon the other side. The panel had
-closed again behind me, but the crash of the lamp, and a few
-moments afterwards the clang of the two slabs of metal, told me
-how narrow had been my escape.
-
-"I was recalled to myself by a frantic plucking at my wrist, and
-I found myself lying upon the stone floor of a narrow corridor,
-while a woman bent over me and tugged at me with her left hand,
-while she held a candle in her right. It was the same good friend
-whose warning I had so foolishly rejected.
-
-"'Come! come!' she cried breathlessly. 'They will be here in a
-moment. They will see that you are not there. Oh, do not waste
-the so-precious time, but come!'
-
-"This time, at least, I did not scorn her advice. I staggered to
-my feet and ran with her along the corridor and down a winding
-stair. The latter led to another broad passage, and just as we
-reached it we heard the sound of running feet and the shouting of
-two voices, one answering the other from the floor on which  we
-were and from the one beneath. My guide stopped and looked about
-her like one  who is at her wit's end. Then she threw open a door
-which led into a bedroom, through the window of which the moon
-was shining brightly.
-
-"'It is your only chance,' said she. 'It is high, but it may be
-that you can jump it.'
-
-"As she spoke a light sprang into view at the further end of the
-passage, and I saw the lean figure of Colonel Lysander Stark
-rushing forward with a lantern in one hand and a weapon like a
-butcher's cleaver in the other. I rushed across the bedroom,
-flung open the window, and looked out. How quiet and sweet and
-wholesome the garden looked in the moonlight, and it could not be
-more than thirty feet down. I clambered out upon the sill, but I
-hesitated to jump until I should have heard what passed between
-my saviour and the ruffian who pursued me. If she were ill-used,
-then at any risks I was determined to go back to her assistance.
-The thought had hardly flashed through my mind before he was at
-the door, pushing his way past her; but she threw her arms round
-him and tried to hold him back.
-
-"'Fritz! Fritz!' she cried in English, 'remember your promise
-after the last time. You said it should not be again. He will be
-silent! Oh, he will be silent!'
-
-"'You are mad, Elise!' he shouted, struggling to break away from
-her. 'You will be the ruin of us. He has seen too much. Let me
-pass, I say!' He dashed her to one side, and, rushing to the
-window, cut at me with his heavy weapon. I had let myself go, and
-was hanging by the hands to the sill, when his blow fell. I was
-conscious of a dull pain, my grip loosened, and I fell into the
-garden below.
-
-"I was shaken but not hurt by the fall; so I picked myself up and
-rushed off among the bushes as hard as I could run, for I
-understood that I was far from being out of danger yet. Suddenly,
-however, as I ran, a deadly dizziness and sickness came over me.
-I glanced down at my hand, which was throbbing painfully, and
-then, for the first time, saw that my thumb had been cut off and
-that the blood was pouring from my wound. I endeavoured to tie my
-handkerchief round it, but there came a sudden buzzing in my
-ears, and next moment I fell in a dead faint among the
-rose-bushes.
-
-"How long I remained unconscious I cannot tell. It must have been
-a very long time, for the moon had sunk, and a bright morning was
-breaking when I came to myself. My clothes were all sodden with
-dew, and my coat-sleeve was drenched with blood from my wounded
-thumb. The smarting of it recalled in an instant all the
-particulars of my night's adventure, and I sprang to my feet with
-the feeling that I might hardly yet be safe from my pursuers. But
-to my astonishment, when I came to look round me, neither house
-nor garden were to be seen. I had been lying in an angle of the
-hedge close by the highroad, and just a little lower down was a
-long building, which proved, upon my approaching it, to be the
-very station at which I had arrived upon the previous night. Were
-it not for the ugly wound upon my hand, all that had passed
-during those dreadful hours might have been an evil dream.
-
-"Half dazed, I went into the station and asked about the morning
-train. There would be one to Reading in less than an hour. The
-same porter was on duty, I found, as had been there when I
-arrived. I inquired of him whether he had ever heard of Colonel
-Lysander Stark. The name was strange to him. Had he observed a
-carriage the night before waiting for me? No, he had not. Was
-there a police-station anywhere near? There was one about three
-miles off.
-
-"It was too far for me to go, weak and ill as I was. I determined
-to wait until I got back to town before telling my story to the
-police. It was a little past six when I arrived, so I went first
-to have my wound dressed, and then the doctor was kind enough to
-bring me along here. I put the case into your hands and shall do
-exactly what you advise."
-
-We both sat in silence for some little time after listening to
-this extraordinary narrative. Then Sherlock Holmes pulled down
-from the shelf one of the ponderous commonplace books in which he
-placed his cuttings.
-
-"Here is an advertisement which will interest you," said he. "It
-appeared in all the papers about a year ago. Listen to this:
-'Lost, on the 9th inst., Mr. Jeremiah Hayling, aged
-twenty-six, a hydraulic engineer. Left his lodgings at ten
-o'clock at night, and has not been heard of since. Was
-dressed in,' etc., etc. Ha! That represents the last time that
-the colonel needed to have his machine overhauled, I fancy."
-
-"Good heavens!" cried my patient. "Then that explains what the
-girl said."
-
-"Undoubtedly. It is quite clear that the colonel was a cool and
-desperate man, who was absolutely determined that nothing should
-stand in the way of his little game, like those out-and-out
-pirates who will leave no survivor from a captured ship. Well,
-every moment now is precious, so if you feel equal to it we shall
-go down to Scotland Yard at once as a preliminary to starting for
-Eyford."
-
-Some three hours or so afterwards we were all in the train
-together, bound from Reading to the little Berkshire village.
-There were Sherlock Holmes, the hydraulic engineer, Inspector
-Bradstreet, of Scotland Yard, a plain-clothes man, and myself.
-Bradstreet had spread an ordnance map of the county out upon the
-seat and was busy with his compasses drawing a circle with Eyford
-for its centre.
-
-"There you are," said he. "That circle is drawn at a radius of
-ten miles from the village. The place we want must be somewhere
-near that line. You said ten miles, I think, sir."
-
-"It was an hour's good drive."
-
-"And you think that they brought you back all that way when you
-were unconscious?"
-
-"They must have done so. I have a confused memory, too, of having
-been lifted and conveyed somewhere."
-
-"What I cannot understand," said I, "is why they should have
-spared you when they found you lying fainting in the garden.
-Perhaps the villain was softened by the woman's entreaties."
-
-"I hardly think that likely. I never saw a more inexorable face
-in my life."
-
-"Oh, we shall soon clear up all that," said Bradstreet. "Well, I
-have drawn my circle, and I only wish I knew at what point upon
-it the folk that we are in search of are to be found."
-
-"I think I could lay my finger on it," said Holmes quietly.
-
-"Really, now!" cried the inspector, "you have formed your
-opinion! Come, now, we shall see who agrees with you. I say it is
-south, for the country is more deserted there."
-
-"And I say east," said my patient.
-
-"I am for west," remarked the plain-clothes man. "There are
-several quiet little villages up there."
-
-"And I am for north," said I, "because there are no hills there,
-and our friend says that he did not notice the carriage go up
-any."
-
-"Come," cried the inspector, laughing; "it's a very pretty
-diversity of opinion. We have boxed the compass among us. Who do
-you give your casting vote to?"
-
-"You are all wrong."
-
-"But we can't all be."
-
-"Oh, yes, you can. This is my point." He placed his finger in the
-centre of the circle. "This is where we shall find them."
-
-"But the twelve-mile drive?" gasped Hatherley.
-
-"Six out and six back. Nothing simpler. You say yourself that the
-horse was fresh and glossy when you got in. How could it be that
-if it had gone twelve miles over heavy roads?"
-
-"Indeed, it is a likely ruse enough," observed Bradstreet
-thoughtfully. "Of course there can be no doubt as to the nature
-of this gang."
-
-"None at all," said Holmes. "They are coiners on a large scale,
-and have used the machine to form the amalgam which has taken the
-place of silver."
-
-"We have known for some time that a clever gang was at work,"
-said the inspector. "They have been turning out half-crowns by
-the thousand. We even traced them as far as Reading, but could
-get no farther, for they had covered their traces in a way that
-showed that they were very old hands. But now, thanks to this
-lucky chance, I think that we have got them right enough."
-
-But the inspector was mistaken, for those criminals were not
-destined to fall into the hands of justice. As we rolled into
-Eyford Station we saw a gigantic column of smoke which streamed
-up from behind a small clump of trees in the neighbourhood and
-hung like an immense ostrich feather over the landscape.
-
-"A house on fire?" asked Bradstreet as the train steamed off
-again on its way.
-
-"Yes, sir!" said the station-master.
-
-"When did it break out?"
-
-"I hear that it was during the night, sir, but it has got worse,
-and the whole place is in a blaze."
-
-"Whose house is it?"
-
-"Dr. Becher's."
-
-"Tell me," broke in the engineer, "is Dr. Becher a German, very
-thin, with a long, sharp nose?"
-
-The station-master laughed heartily. "No, sir, Dr. Becher is an
-Englishman, and there isn't a man in the parish who has a
-better-lined waistcoat. But he has a gentleman staying with him,
-a patient, as I understand, who is a foreigner, and he looks as
-if a little good Berkshire beef would do him no harm."
-
-The station-master had not finished his speech before we were all
-hastening in the direction of the fire. The road topped a low
-hill, and there was a great widespread whitewashed building in
-front of us, spouting fire at every chink and window, while in
-the garden in front three fire-engines were vainly striving to
-keep the flames under.
-
-"That's it!" cried Hatherley, in intense excitement. "There is
-the gravel-drive, and there are the rose-bushes where I lay. That
-second window is the one that I jumped from."
-
-"Well, at least," said Holmes, "you have had your revenge upon
-them. There can be no question that it was your oil-lamp which,
-when it was crushed in the press, set fire to the wooden walls,
-though no doubt they were too excited in the chase after you to
-observe it at the time. Now keep your eyes open in this crowd for
-your friends of last night, though I very much fear that they are
-a good hundred miles off by now."
-
-And Holmes' fears came to be realised, for from that day to this
-no word has ever been heard either of the beautiful woman, the
-sinister German, or the morose Englishman. Early that morning a
-peasant had met a cart containing several people and some very
-bulky boxes driving rapidly in the direction of Reading, but
-there all traces of the fugitives disappeared, and even Holmes'
-ingenuity failed ever to discover the least clue as to their
-whereabouts.
-
-The firemen had been much perturbed at the strange arrangements
-which they had found within, and still more so by discovering a
-newly severed human thumb upon a window-sill of the second floor.
-About sunset, however, their efforts were at last successful, and
-they subdued the flames, but not before the roof had fallen in,
-and the whole place been reduced to such absolute ruin that, save
-some twisted cylinders and iron piping, not a trace remained of
-the machinery which had cost our unfortunate acquaintance so
-dearly. Large masses of nickel and of tin were discovered stored
-in an out-house, but no coins were to be found, which may have
-explained the presence of those bulky boxes which have been
-already referred to.
-
-How our hydraulic engineer had been conveyed from the garden to
-the spot where he recovered his senses might have remained
-forever a mystery were it not for the soft mould, which told us a
-very plain tale. He had evidently been carried down by two
-persons, one of whom had remarkably small feet and the other
-unusually large ones. On the whole, it was most probable that the
-silent Englishman, being less bold or less murderous than his
-companion, had assisted the woman to bear the unconscious man out
-of the way of danger.
-
-"Well," said our engineer ruefully as we took our seats to return
-once more to London, "it has been a pretty business for me! I
-have lost my thumb and I have lost a fifty-guinea fee, and what
-have I gained?"
-
-"Experience," said Holmes, laughing. "Indirectly it may be of
-value, you know; you have only to put it into words to gain the
-reputation of being excellent company for the remainder of your
-existence."
-
-
-
-X. THE ADVENTURE OF THE NOBLE BACHELOR
-
-The Lord St. Simon marriage, and its curious termination, have
-long ceased to be a subject of interest in those exalted circles
-in which the unfortunate bridegroom moves. Fresh scandals have
-eclipsed it, and their more piquant details have drawn the
-gossips away from this four-year-old drama. As I have reason to
-believe, however, that the full facts have never been revealed to
-the general public, and as my friend Sherlock Holmes had a
-considerable share in clearing the matter up, I feel that no
-memoir of him would be complete without some little sketch of
-this remarkable episode.
-
-It was a few weeks before my own marriage, during the days when I
-was still sharing rooms with Holmes in Baker Street, that he came
-home from an afternoon stroll to find a letter on the table
-waiting for him. I had remained indoors all day, for the weather
-had taken a sudden turn to rain, with high autumnal winds, and
-the Jezail bullet which I had brought back in one of my limbs as
-a relic of my Afghan campaign throbbed with dull persistence.
-With my body in one easy-chair and my legs upon another, I had
-surrounded myself with a cloud of newspapers until at last,
-saturated with the news of the day, I tossed them all aside and
-lay listless, watching the huge crest and monogram upon the
-envelope upon the table and wondering lazily who my friend's
-noble correspondent could be.
-
-"Here is a very fashionable epistle," I remarked as he entered.
-"Your morning letters, if I remember right, were from a
-fish-monger and a tide-waiter."
-
-"Yes, my correspondence has certainly the charm of variety," he
-answered, smiling, "and the humbler are usually the more
-interesting. This looks like one of those unwelcome social
-summonses which call upon a man either to be bored or to lie."
-
-He broke the seal and glanced over the contents.
-
-"Oh, come, it may prove to be something of interest, after all."
-
-"Not social, then?"
-
-"No, distinctly professional."
-
-"And from a noble client?"
-
-"One of the highest in England."
-
-"My dear fellow, I congratulate you."
-
-"I assure you, Watson, without affectation, that the status of my
-client is a matter of less moment to me than the interest of his
-case. It is just possible, however, that that also may not be
-wanting in this new investigation. You have been reading the
-papers diligently of late, have you not?"
-
-"It looks like it," said I ruefully, pointing to a huge bundle in
-the corner. "I have had nothing else to do."
-
-"It is fortunate, for you will perhaps be able to post me up. I
-read nothing except the criminal news and the agony column. The
-latter is always instructive. But if you have followed recent
-events so closely you must have read about Lord St. Simon and his
-wedding?"
-
-"Oh, yes, with the deepest interest."
-
-"That is well. The letter which I hold in my hand is from Lord
-St. Simon. I will read it to you, and in return you must turn
-over these papers and let me have whatever bears upon the matter.
-This is what he says:
-
-"'MY DEAR MR. SHERLOCK HOLMES:--Lord Backwater tells me that I
-may place implicit reliance upon your judgment and discretion. I
-have determined, therefore, to call upon you and to consult you
-in reference to the very painful event which has occurred in
-connection with my wedding. Mr. Lestrade, of Scotland Yard, is
-acting already in the matter, but he assures me that he sees no
-objection to your co-operation, and that he even thinks that
-it might be of some assistance. I will call at four o'clock in
-the afternoon, and, should you have any other engagement at that
-time, I hope that you will postpone it, as this matter is of
-paramount importance. Yours faithfully, ST. SIMON.'
-
-"It is dated from Grosvenor Mansions, written with a quill pen,
-and the noble lord has had the misfortune to get a smear of ink
-upon the outer side of his right little finger," remarked Holmes
-as he folded up the epistle.
-
-"He says four o'clock. It is three now. He will be here in an
-hour."
-
-"Then I have just time, with your assistance, to get clear upon
-the subject. Turn over those papers and arrange the extracts in
-their order of time, while I take a glance as to who our client
-is." He picked a red-covered volume from a line of books of
-reference beside the mantelpiece. "Here he is," said he, sitting
-down and flattening it out upon his knee. "'Lord Robert Walsingham
-de Vere St. Simon, second son of the Duke of Balmoral.' Hum! 'Arms:
-Azure, three caltrops in chief over a fess sable. Born in 1846.'
-He's forty-one years of age, which is mature for marriage. Was
-Under-Secretary for the colonies in a late administration. The
-Duke, his father, was at one time Secretary for Foreign Affairs.
-They inherit Plantagenet blood by direct descent, and Tudor on
-the distaff side. Ha! Well, there is nothing very instructive in
-all this. I think that I must turn to you Watson, for something
-more solid."
-
-"I have very little difficulty in finding what I want," said I,
-"for the facts are quite recent, and the matter struck me as
-remarkable. I feared to refer them to you, however, as I knew
-that you had an inquiry on hand and that you disliked the
-intrusion of other matters."
-
-"Oh, you mean the little problem of the Grosvenor Square
-furniture van. That is quite cleared up now--though, indeed, it
-was obvious from the first. Pray give me the results of your
-newspaper selections."
-
-"Here is the first notice which I can find. It is in the personal
-column of the Morning Post, and dates, as you see, some weeks
-back: 'A marriage has been arranged,' it says, 'and will, if
-rumour is correct, very shortly take place, between Lord Robert
-St. Simon, second son of the Duke of Balmoral, and Miss Hatty
-Doran, the only daughter of Aloysius Doran. Esq., of San
-Francisco, Cal., U.S.A.' That is all."
-
-"Terse and to the point," remarked Holmes, stretching his long,
-thin legs towards the fire.
-
-"There was a paragraph amplifying this in one of the society
-papers of the same week. Ah, here it is: 'There will soon be a
-call for protection in the marriage market, for the present
-free-trade principle appears to tell heavily against our home
-product. One by one the management of the noble houses of Great
-Britain is passing into the hands of our fair cousins from across
-the Atlantic. An important addition has been made during the last
-week to the list of the prizes which have been borne away by
-these charming invaders. Lord St. Simon, who has shown himself
-for over twenty years proof against the little god's arrows, has
-now definitely announced his approaching marriage with Miss Hatty
-Doran, the fascinating daughter of a California millionaire. Miss
-Doran, whose graceful figure and striking face attracted much
-attention at the Westbury House festivities, is an only child,
-and it is currently reported that her dowry will run to
-considerably over the six figures, with expectancies for the
-future. As it is an open secret that the Duke of Balmoral has
-been compelled to sell his pictures within the last few years,
-and as Lord St. Simon has no property of his own save the small
-estate of Birchmoor, it is obvious that the Californian heiress
-is not the only gainer by an alliance which will enable her to
-make the easy and common transition from a Republican lady to a
-British peeress.'"
-
-"Anything else?" asked Holmes, yawning.
-
-"Oh, yes; plenty. Then there is another note in the Morning Post
-to say that the marriage would be an absolutely quiet one, that it
-would be at St. George's, Hanover Square, that only half a dozen
-intimate friends would be invited, and that the party would
-return to the furnished house at Lancaster Gate which has been
-taken by Mr. Aloysius Doran. Two days later--that is, on
-Wednesday last--there is a curt announcement that the wedding had
-taken place, and that the honeymoon would be passed at Lord
-Backwater's place, near Petersfield. Those are all the notices
-which appeared before the disappearance of the bride."
-
-"Before the what?" asked Holmes with a start.
-
-"The vanishing of the lady."
-
-"When did she vanish, then?"
-
-"At the wedding breakfast."
-
-"Indeed. This is more interesting than it promised to be; quite
-dramatic, in fact."
-
-"Yes; it struck me as being a little out of the common."
-
-"They often vanish before the ceremony, and occasionally during
-the honeymoon; but I cannot call to mind anything quite so prompt
-as this. Pray let me have the details."
-
-"I warn you that they are very incomplete."
-
-"Perhaps we may make them less so."
-
-"Such as they are, they are set forth in a single article of a
-morning paper of yesterday, which I will read to you. It is
-headed, 'Singular Occurrence at a Fashionable Wedding':
-
-"'The family of Lord Robert St. Simon has been thrown into the
-greatest consternation by the strange and painful episodes which
-have taken place in connection with his wedding. The ceremony, as
-shortly announced in the papers of yesterday, occurred on the
-previous morning; but it is only now that it has been possible to
-confirm the strange rumours which have been so persistently
-floating about. In spite of the attempts of the friends to hush
-the matter up, so much public attention has now been drawn to it
-that no good purpose can be served by affecting to disregard what
-is a common subject for conversation.
-
-"'The ceremony, which was performed at St. George's, Hanover
-Square, was a very quiet one, no one being present save the
-father of the bride, Mr. Aloysius Doran, the Duchess of Balmoral,
-Lord Backwater, Lord Eustace and Lady Clara St. Simon (the
-younger brother and sister of the bridegroom), and Lady Alicia
-Whittington. The whole party proceeded afterwards to the house of
-Mr. Aloysius Doran, at Lancaster Gate, where breakfast had been
-prepared. It appears that some little trouble was caused by a
-woman, whose name has not been ascertained, who endeavoured to
-force her way into the house after the bridal party, alleging
-that she had some claim upon Lord St. Simon. It was only after a
-painful and prolonged scene that she was ejected by the butler
-and the footman. The bride, who had fortunately entered the house
-before this unpleasant interruption, had sat down to breakfast
-with the rest, when she complained of a sudden indisposition and
-retired to her room. Her prolonged absence having caused some
-comment, her father followed her, but learned from her maid that
-she had only come up to her chamber for an instant, caught up an
-ulster and bonnet, and hurried down to the passage. One of the
-footmen declared that he had seen a lady leave the house thus
-apparelled, but had refused to credit that it was his mistress,
-believing her to be with the company. On ascertaining that his
-daughter had disappeared, Mr. Aloysius Doran, in conjunction with
-the bridegroom, instantly put themselves in communication with
-the police, and very energetic inquiries are being made, which
-will probably result in a speedy clearing up of this very
-singular business. Up to a late hour last night, however, nothing
-had transpired as to the whereabouts of the missing lady. There
-are rumours of foul play in the matter, and it is said that the
-police have caused the arrest of the woman who had caused the
-original disturbance, in the belief that, from jealousy or some
-other motive, she may have been concerned in the strange
-disappearance of the bride.'"
-
-"And is that all?"
-
-"Only one little item in another of the morning papers, but it is
-a suggestive one."
-
-"And it is--"
-
-"That Miss Flora Millar, the lady who had caused the disturbance,
-has actually been arrested. It appears that she was formerly a
-danseuse at the Allegro, and that she has known the bridegroom
-for some years. There are no further particulars, and the whole
-case is in your hands now--so far as it has been set forth in the
-public press."
-
-"And an exceedingly interesting case it appears to be. I would
-not have missed it for worlds. But there is a ring at the bell,
-Watson, and as the clock makes it a few minutes after four, I
-have no doubt that this will prove to be our noble client. Do not
-dream of going, Watson, for I very much prefer having a witness,
-if only as a check to my own memory."
-
-"Lord Robert St. Simon," announced our page-boy, throwing open
-the door. A gentleman entered, with a pleasant, cultured face,
-high-nosed and pale, with something perhaps of petulance about
-the mouth, and with the steady, well-opened eye of a man whose
-pleasant lot it had ever been to command and to be obeyed. His
-manner was brisk, and yet his general appearance gave an undue
-impression of age, for he had a slight forward stoop and a little
-bend of the knees as he walked. His hair, too, as he swept off
-his very curly-brimmed hat, was grizzled round the edges and thin
-upon the top. As to his dress, it was careful to the verge of
-foppishness, with high collar, black frock-coat, white waistcoat,
-yellow gloves, patent-leather shoes, and light-coloured gaiters.
-He advanced slowly into the room, turning his head from left to
-right, and swinging in his right hand the cord which held his
-golden eyeglasses.
-
-"Good-day, Lord St. Simon," said Holmes, rising and bowing. "Pray
-take the basket-chair. This is my friend and colleague, Dr.
-Watson. Draw up a little to the fire, and we will talk this
-matter over."
-
-"A most painful matter to me, as you can most readily imagine,
-Mr. Holmes. I have been cut to the quick. I understand that you
-have already managed several delicate cases of this sort, sir,
-though I presume that they were hardly from the same class of
-society."
-
-"No, I am descending."
-
-"I beg pardon."
-
-"My last client of the sort was a king."
-
-"Oh, really! I had no idea. And which king?"
-
-"The King of Scandinavia."
-
-"What! Had he lost his wife?"
-
-"You can understand," said Holmes suavely, "that I extend to the
-affairs of my other clients the same secrecy which I promise to
-you in yours."
-
-"Of course! Very right! very right! I'm sure I beg pardon. As to
-my own case, I am ready to give you any information which may
-assist you in forming an opinion."
-
-"Thank you. I have already learned all that is in the public
-prints, nothing more. I presume that I may take it as correct--this
-article, for example, as to the disappearance of the bride."
-
-Lord St. Simon glanced over it. "Yes, it is correct, as far as it
-goes."
-
-"But it needs a great deal of supplementing before anyone could
-offer an opinion. I think that I may arrive at my facts most
-directly by questioning you."
-
-"Pray do so."
-
-"When did you first meet Miss Hatty Doran?"
-
-"In San Francisco, a year ago."
-
-"You were travelling in the States?"
-
-"Yes."
-
-"Did you become engaged then?"
-
-"No."
-
-"But you were on a friendly footing?"
-
-"I was amused by her society, and she could see that I was
-amused."
-
-"Her father is very rich?"
-
-"He is said to be the richest man on the Pacific slope."
-
-"And how did he make his money?"
-
-"In mining. He had nothing a few years ago. Then he struck gold,
-invested it, and came up by leaps and bounds."
-
-"Now, what is your own impression as to the young lady's--your
-wife's character?"
-
-The nobleman swung his glasses a little faster and stared down
-into the fire. "You see, Mr. Holmes," said he, "my wife was
-twenty before her father became a rich man. During that time she
-ran free in a mining camp and wandered through woods or
-mountains, so that her education has come from Nature rather than
-from the schoolmaster. She is what we call in England a tomboy,
-with a strong nature, wild and free, unfettered by any sort of
-traditions. She is impetuous--volcanic, I was about to say. She
-is swift in making up her mind and fearless in carrying out her
-resolutions. On the other hand, I would not have given her the
-name which I have the honour to bear"--he gave a little stately
-cough--"had not I thought her to be at bottom a noble woman. I
-believe that she is capable of heroic self-sacrifice and that
-anything dishonourable would be repugnant to her."
-
-"Have you her photograph?"
-
-"I brought this with me." He opened a locket and showed us the
-full face of a very lovely woman. It was not a photograph but an
-ivory miniature, and the artist had brought out the full effect
-of the lustrous black hair, the large dark eyes, and the
-exquisite mouth. Holmes gazed long and earnestly at it. Then he
-closed the locket and handed it back to Lord St. Simon.
-
-"The young lady came to London, then, and you renewed your
-acquaintance?"
-
-"Yes, her father brought her over for this last London season. I
-met her several times, became engaged to her, and have now
-married her."
-
-"She brought, I understand, a considerable dowry?"
-
-"A fair dowry. Not more than is usual in my family."
-
-"And this, of course, remains to you, since the marriage is a
-fait accompli?"
-
-"I really have made no inquiries on the subject."
-
-"Very naturally not. Did you see Miss Doran on the day before the
-wedding?"
-
-"Yes."
-
-"Was she in good spirits?"
-
-"Never better. She kept talking of what we should do in our
-future lives."
-
-"Indeed! That is very interesting. And on the morning of the
-wedding?"
-
-"She was as bright as possible--at least until after the
-ceremony."
-
-"And did you observe any change in her then?"
-
-"Well, to tell the truth, I saw then the first signs that I had
-ever seen that her temper was just a little sharp. The incident
-however, was too trivial to relate and can have no possible
-bearing upon the case."
-
-"Pray let us have it, for all that."
-
-"Oh, it is childish. She dropped her bouquet as we went towards
-the vestry. She was passing the front pew at the time, and it
-fell over into the pew. There was a moment's delay, but the
-gentleman in the pew handed it up to her again, and it did not
-appear to be the worse for the fall. Yet when I spoke to her of
-the matter, she answered me abruptly; and in the carriage, on our
-way home, she seemed absurdly agitated over this trifling cause."
-
-"Indeed! You say that there was a gentleman in the pew. Some of
-the general public were present, then?"
-
-"Oh, yes. It is impossible to exclude them when the church is
-open."
-
-"This gentleman was not one of your wife's friends?"
-
-"No, no; I call him a gentleman by courtesy, but he was quite a
-common-looking person. I hardly noticed his appearance. But
-really I think that we are wandering rather far from the point."
-
-"Lady St. Simon, then, returned from the wedding in a less
-cheerful frame of mind than she had gone to it. What did she do
-on re-entering her father's house?"
-
-"I saw her in conversation with her maid."
-
-"And who is her maid?"
-
-"Alice is her name. She is an American and came from California
-with her."
-
-"A confidential servant?"
-
-"A little too much so. It seemed to me that her mistress allowed
-her to take great liberties. Still, of course, in America they
-look upon these things in a different way."
-
-"How long did she speak to this Alice?"
-
-"Oh, a few minutes. I had something else to think of."
-
-"You did not overhear what they said?"
-
-"Lady St. Simon said something about 'jumping a claim.' She was
-accustomed to use slang of the kind. I have no idea what she
-meant."
-
-"American slang is very expressive sometimes. And what did your
-wife do when she finished speaking to her maid?"
-
-"She walked into the breakfast-room."
-
-"On your arm?"
-
-"No, alone. She was very independent in little matters like that.
-Then, after we had sat down for ten minutes or so, she rose
-hurriedly, muttered some words of apology, and left the room. She
-never came back."
-
-"But this maid, Alice, as I understand, deposes that she went to
-her room, covered her bride's dress with a long ulster, put on a
-bonnet, and went out."
-
-"Quite so. And she was afterwards seen walking into Hyde Park in
-company with Flora Millar, a woman who is now in custody, and who
-had already made a disturbance at Mr. Doran's house that
-morning."
-
-"Ah, yes. I should like a few particulars as to this young lady,
-and your relations to her."
-
-Lord St. Simon shrugged his shoulders and raised his eyebrows.
-"We have been on a friendly footing for some years--I may say on
-a very friendly footing. She used to be at the Allegro. I have
-not treated her ungenerously, and she had no just cause of
-complaint against me, but you know what women are, Mr. Holmes.
-Flora was a dear little thing, but exceedingly hot-headed and
-devotedly attached to me. She wrote me dreadful letters when she
-heard that I was about to be married, and, to tell the truth, the
-reason why I had the marriage celebrated so quietly was that I
-feared lest there might be a scandal in the church. She came to
-Mr. Doran's door just after we returned, and she endeavoured to
-push her way in, uttering very abusive expressions towards my
-wife, and even threatening her, but I had foreseen the
-possibility of something of the sort, and I had two police
-fellows there in private clothes, who soon pushed her out again.
-She was quiet when she saw that there was no good in making a
-row."
-
-"Did your wife hear all this?"
-
-"No, thank goodness, she did not."
-
-"And she was seen walking with this very woman afterwards?"
-
-"Yes. That is what Mr. Lestrade, of Scotland Yard, looks upon as
-so serious. It is thought that Flora decoyed my wife out and laid
-some terrible trap for her."
-
-"Well, it is a possible supposition."
-
-"You think so, too?"
-
-"I did not say a probable one. But you do not yourself look upon
-this as likely?"
-
-"I do not think Flora would hurt a fly."
-
-"Still, jealousy is a strange transformer of characters. Pray
-what is your own theory as to what took place?"
-
-"Well, really, I came to seek a theory, not to propound one. I
-have given you all the facts. Since you ask me, however, I may
-say that it has occurred to me as possible that the excitement of
-this affair, the consciousness that she had made so immense a
-social stride, had the effect of causing some little nervous
-disturbance in my wife."
-
-"In short, that she had become suddenly deranged?"
-
-"Well, really, when I consider that she has turned her back--I
-will not say upon me, but upon so much that many have aspired to
-without success--I can hardly explain it in any other fashion."
-
-"Well, certainly that is also a conceivable hypothesis," said
-Holmes, smiling. "And now, Lord St. Simon, I think that I have
-nearly all my data. May I ask whether you were seated at the
-breakfast-table so that you could see out of the window?"
-
-"We could see the other side of the road and the Park."
-
-"Quite so. Then I do not think that I need to detain you longer.
-I shall communicate with you."
-
-"Should you be fortunate enough to solve this problem," said our
-client, rising.
-
-"I have solved it."
-
-"Eh? What was that?"
-
-"I say that I have solved it."
-
-"Where, then, is my wife?"
-
-"That is a detail which I shall speedily supply."
-
-Lord St. Simon shook his head. "I am afraid that it will take
-wiser heads than yours or mine," he remarked, and bowing in a
-stately, old-fashioned manner he departed.
-
-"It is very good of Lord St. Simon to honour my head by putting
-it on a level with his own," said Sherlock Holmes, laughing. "I
-think that I shall have a whisky and soda and a cigar after all
-this cross-questioning. I had formed my conclusions as to the
-case before our client came into the room."
-
-"My dear Holmes!"
-
-"I have notes of several similar cases, though none, as I
-remarked before, which were quite as prompt. My whole examination
-served to turn my conjecture into a certainty. Circumstantial
-evidence is occasionally very convincing, as when you find a
-trout in the milk, to quote Thoreau's example."
-
-"But I have heard all that you have heard."
-
-"Without, however, the knowledge of pre-existing cases which
-serves me so well. There was a parallel instance in Aberdeen some
-years back, and something on very much the same lines at Munich
-the year after the Franco-Prussian War. It is one of these
-cases--but, hullo, here is Lestrade! Good-afternoon, Lestrade!
-You will find an extra tumbler upon the sideboard, and there are
-cigars in the box."
-
-The official detective was attired in a pea-jacket and cravat,
-which gave him a decidedly nautical appearance, and he carried a
-black canvas bag in his hand. With a short greeting he seated
-himself and lit the cigar which had been offered to him.
-
-"What's up, then?" asked Holmes with a twinkle in his eye. "You
-look dissatisfied."
-
-"And I feel dissatisfied. It is this infernal St. Simon marriage
-case. I can make neither head nor tail of the business."
-
-"Really! You surprise me."
-
-"Who ever heard of such a mixed affair? Every clue seems to slip
-through my fingers. I have been at work upon it all day."
-
-"And very wet it seems to have made you," said Holmes laying his
-hand upon the arm of the pea-jacket.
-
-"Yes, I have been dragging the Serpentine."
-
-"In heaven's name, what for?"
-
-"In search of the body of Lady St. Simon."
-
-Sherlock Holmes leaned back in his chair and laughed heartily.
-
-"Have you dragged the basin of Trafalgar Square fountain?" he
-asked.
-
-"Why? What do you mean?"
-
-"Because you have just as good a chance of finding this lady in
-the one as in the other."
-
-Lestrade shot an angry glance at my companion. "I suppose you
-know all about it," he snarled.
-
-"Well, I have only just heard the facts, but my mind is made up."
-
-"Oh, indeed! Then you think that the Serpentine plays no part in
-the matter?"
-
-"I think it very unlikely."
-
-"Then perhaps you will kindly explain how it is that we found
-this in it?" He opened his bag as he spoke, and tumbled onto the
-floor a wedding-dress of watered silk, a pair of white satin
-shoes and a bride's wreath and veil, all discoloured and soaked
-in water. "There," said he, putting a new wedding-ring upon the
-top of the pile. "There is a little nut for you to crack, Master
-Holmes."
-
-"Oh, indeed!" said my friend, blowing blue rings into the air.
-"You dragged them from the Serpentine?"
-
-"No. They were found floating near the margin by a park-keeper.
-They have been identified as her clothes, and it seemed to me
-that if the clothes were there the body would not be far off."
-
-"By the same brilliant reasoning, every man's body is to be found
-in the neighbourhood of his wardrobe. And pray what did you hope
-to arrive at through this?"
-
-"At some evidence implicating Flora Millar in the disappearance."
-
-"I am afraid that you will find it difficult."
-
-"Are you, indeed, now?" cried Lestrade with some bitterness. "I
-am afraid, Holmes, that you are not very practical with your
-deductions and your inferences. You have made two blunders in as
-many minutes. This dress does implicate Miss Flora Millar."
-
-"And how?"
-
-"In the dress is a pocket. In the pocket is a card-case. In the
-card-case is a note. And here is the very note." He slapped it
-down upon the table in front of him. "Listen to this: 'You will
-see me when all is ready. Come at once. F.H.M.' Now my theory all
-along has been that Lady St. Simon was decoyed away by Flora
-Millar, and that she, with confederates, no doubt, was
-responsible for her disappearance. Here, signed with her
-initials, is the very note which was no doubt quietly slipped
-into her hand at the door and which lured her within their
-reach."
-
-"Very good, Lestrade," said Holmes, laughing. "You really are
-very fine indeed. Let me see it." He took up the paper in a
-listless way, but his attention instantly became riveted, and he
-gave a little cry of satisfaction. "This is indeed important,"
-said he.
-
-"Ha! you find it so?"
-
-"Extremely so. I congratulate you warmly."
-
-Lestrade rose in his triumph and bent his head to look. "Why," he
-shrieked, "you're looking at the wrong side!"
-
-"On the contrary, this is the right side."
-
-"The right side? You're mad! Here is the note written in pencil
-over here."
-
-"And over here is what appears to be the fragment of a hotel
-bill, which interests me deeply."
-
-"There's nothing in it. I looked at it before," said Lestrade.
-"'Oct. 4th, rooms 8s., breakfast 2s. 6d., cocktail 1s., lunch 2s.
-6d., glass sherry, 8d.' I see nothing in that."
-
-"Very likely not. It is most important, all the same. As to the
-note, it is important also, or at least the initials are, so I
-congratulate you again."
-
-"I've wasted time enough," said Lestrade, rising. "I believe in
-hard work and not in sitting by the fire spinning fine theories.
-Good-day, Mr. Holmes, and we shall see which gets to the bottom
-of the matter first." He gathered up the garments, thrust them
-into the bag, and made for the door.
-
-"Just one hint to you, Lestrade," drawled Holmes before his rival
-vanished; "I will tell you the true solution of the matter. Lady
-St. Simon is a myth. There is not, and there never has been, any
-such person."
-
-Lestrade looked sadly at my companion. Then he turned to me,
-tapped his forehead three times, shook his head solemnly, and
-hurried away.
-
-He had hardly shut the door behind him when Holmes rose to put on
-his overcoat. "There is something in what the fellow says about
-outdoor work," he remarked, "so I think, Watson, that I must
-leave you to your papers for a little."
-
-It was after five o'clock when Sherlock Holmes left me, but I had
-no time to be lonely, for within an hour there arrived a
-confectioner's man with a very large flat box. This he unpacked
-with the help of a youth whom he had brought with him, and
-presently, to my very great astonishment, a quite epicurean
-little cold supper began to be laid out upon our humble
-lodging-house mahogany. There were a couple of brace of cold
-woodcock, a pheasant, a pâté de foie gras pie with a group of
-ancient and cobwebby bottles. Having laid out all these luxuries,
-my two visitors vanished away, like the genii of the Arabian
-Nights, with no explanation save that the things had been paid
-for and were ordered to this address.
-
-Just before nine o'clock Sherlock Holmes stepped briskly into the
-room. His features were gravely set, but there was a light in his
-eye which made me think that he had not been disappointed in his
-conclusions.
-
-"They have laid the supper, then," he said, rubbing his hands.
-
-"You seem to expect company. They have laid for five."
-
-"Yes, I fancy we may have some company dropping in," said he. "I
-am surprised that Lord St. Simon has not already arrived. Ha! I
-fancy that I hear his step now upon the stairs."
-
-It was indeed our visitor of the afternoon who came bustling in,
-dangling his glasses more vigorously than ever, and with a very
-perturbed expression upon his aristocratic features.
-
-"My messenger reached you, then?" asked Holmes.
-
-"Yes, and I confess that the contents startled me beyond measure.
-Have you good authority for what you say?"
-
-"The best possible."
-
-Lord St. Simon sank into a chair and passed his hand over his
-forehead.
-
-"What will the Duke say," he murmured, "when he hears that one of
-the family has been subjected to such humiliation?"
-
-"It is the purest accident. I cannot allow that there is any
-humiliation."
-
-"Ah, you look on these things from another standpoint."
-
-"I fail to see that anyone is to blame. I can hardly see how the
-lady could have acted otherwise, though her abrupt method of
-doing it was undoubtedly to be regretted. Having no mother, she
-had no one to advise her at such a crisis."
-
-"It was a slight, sir, a public slight," said Lord St. Simon,
-tapping his fingers upon the table.
-
-"You must make allowance for this poor girl, placed in so
-unprecedented a position."
-
-"I will make no allowance. I am very angry indeed, and I have
-been shamefully used."
-
-"I think that I heard a ring," said Holmes. "Yes, there are steps
-on the landing. If I cannot persuade you to take a lenient view
-of the matter, Lord St. Simon, I have brought an advocate here
-who may be more successful." He opened the door and ushered in a
-lady and gentleman. "Lord St. Simon," said he "allow me to
-introduce you to Mr. and Mrs. Francis Hay Moulton. The lady, I
-think, you have already met."
-
-At the sight of these newcomers our client had sprung from his
-seat and stood very erect, with his eyes cast down and his hand
-thrust into the breast of his frock-coat, a picture of offended
-dignity. The lady had taken a quick step forward and had held out
-her hand to him, but he still refused to raise his eyes. It was
-as well for his resolution, perhaps, for her pleading face was
-one which it was hard to resist.
-
-"You're angry, Robert," said she. "Well, I guess you have every
-cause to be."
-
-"Pray make no apology to me," said Lord St. Simon bitterly.
-
-"Oh, yes, I know that I have treated you real bad and that I
-should have spoken to you before I went; but I was kind of
-rattled, and from the time when I saw Frank here again I just
-didn't know what I was doing or saying. I only wonder I didn't
-fall down and do a faint right there before the altar."
-
-"Perhaps, Mrs. Moulton, you would like my friend and me to leave
-the room while you explain this matter?"
-
-"If I may give an opinion," remarked the strange gentleman,
-"we've had just a little too much secrecy over this business
-already. For my part, I should like all Europe and America to
-hear the rights of it." He was a small, wiry, sunburnt man,
-clean-shaven, with a sharp face and alert manner.
-
-"Then I'll tell our story right away," said the lady. "Frank here
-and I met in '84, in McQuire's camp, near the Rockies, where pa
-was working a claim. We were engaged to each other, Frank and I;
-but then one day father struck a rich pocket and made a pile,
-while poor Frank here had a claim that petered out and came to
-nothing. The richer pa grew the poorer was Frank; so at last pa
-wouldn't hear of our engagement lasting any longer, and he took
-me away to 'Frisco. Frank wouldn't throw up his hand, though; so
-he followed me there, and he saw me without pa knowing anything
-about it. It would only have made him mad to know, so we just
-fixed it all up for ourselves. Frank said that he would go and
-make his pile, too, and never come back to claim me until he had
-as much as pa. So then I promised to wait for him to the end of
-time and pledged myself not to marry anyone else while he lived.
-'Why shouldn't we be married right away, then,' said he, 'and
-then I will feel sure of you; and I won't claim to be your
-husband until I come back?' Well, we talked it over, and he had
-fixed it all up so nicely, with a clergyman all ready in waiting,
-that we just did it right there; and then Frank went off to seek
-his fortune, and I went back to pa.
-
-"The next I heard of Frank was that he was in Montana, and then
-he went prospecting in Arizona, and then I heard of him from New
-Mexico. After that came a long newspaper story about how a
-miners' camp had been attacked by Apache Indians, and there was
-my Frank's name among the killed. I fainted dead away, and I was
-very sick for months after. Pa thought I had a decline and took
-me to half the doctors in 'Frisco. Not a word of news came for a
-year and more, so that I never doubted that Frank was really
-dead. Then Lord St. Simon came to 'Frisco, and we came to London,
-and a marriage was arranged, and pa was very pleased, but I felt
-all the time that no man on this earth would ever take the place
-in my heart that had been given to my poor Frank.
-
-"Still, if I had married Lord St. Simon, of course I'd have done
-my duty by him. We can't command our love, but we can our
-actions. I went to the altar with him with the intention to make
-him just as good a wife as it was in me to be. But you may
-imagine what I felt when, just as I came to the altar rails, I
-glanced back and saw Frank standing and looking at me out of the
-first pew. I thought it was his ghost at first; but when I looked
-again there he was still, with a kind of question in his eyes, as
-if to ask me whether I were glad or sorry to see him. I wonder I
-didn't drop. I know that everything was turning round, and the
-words of the clergyman were just like the buzz of a bee in my
-ear. I didn't know what to do. Should I stop the service and make
-a scene in the church? I glanced at him again, and he seemed to
-know what I was thinking, for he raised his finger to his lips to
-tell me to be still. Then I saw him scribble on a piece of paper,
-and I knew that he was writing me a note. As I passed his pew on
-the way out I dropped my bouquet over to him, and he slipped the
-note into my hand when he returned me the flowers. It was only a
-line asking me to join him when he made the sign to me to do so.
-Of course I never doubted for a moment that my first duty was now
-to him, and I determined to do just whatever he might direct.
-
-"When I got back I told my maid, who had known him in California,
-and had always been his friend. I ordered her to say nothing, but
-to get a few things packed and my ulster ready. I know I ought to
-have spoken to Lord St. Simon, but it was dreadful hard before
-his mother and all those great people. I just made up my mind to
-run away and explain afterwards. I hadn't been at the table ten
-minutes before I saw Frank out of the window at the other side of
-the road. He beckoned to me and then began walking into the Park.
-I slipped out, put on my things, and followed him. Some woman
-came talking something or other about Lord St. Simon to
-me--seemed to me from the little I heard as if he had a little
-secret of his own before marriage also--but I managed to get away
-from her and soon overtook Frank. We got into a cab together, and
-away we drove to some lodgings he had taken in Gordon Square, and
-that was my true wedding after all those years of waiting. Frank
-had been a prisoner among the Apaches, had escaped, came on to
-'Frisco, found that I had given him up for dead and had gone to
-England, followed me there, and had come upon me at last on the
-very morning of my second wedding."
-
-"I saw it in a paper," explained the American. "It gave the name
-and the church but not where the lady lived."
-
-"Then we had a talk as to what we should do, and Frank was all
-for openness, but I was so ashamed of it all that I felt as if I
-should like to vanish away and never see any of them again--just
-sending a line to pa, perhaps, to show him that I was alive. It
-was awful to me to think of all those lords and ladies sitting
-round that breakfast-table and waiting for me to come back. So
-Frank took my wedding-clothes and things and made a bundle of
-them, so that I should not be traced, and dropped them away
-somewhere where no one could find them. It is likely that we
-should have gone on to Paris to-morrow, only that this good
-gentleman, Mr. Holmes, came round to us this evening, though how
-he found us is more than I can think, and he showed us very
-clearly and kindly that I was wrong and that Frank was right, and
-that we should be putting ourselves in the wrong if we were so
-secret. Then he offered to give us a chance of talking to Lord
-St. Simon alone, and so we came right away round to his rooms at
-once. Now, Robert, you have heard it all, and I am very sorry if
-I have given you pain, and I hope that you do not think very
-meanly of me."
-
-Lord St. Simon had by no means relaxed his rigid attitude, but
-had listened with a frowning brow and a compressed lip to this
-long narrative.
-
-"Excuse me," he said, "but it is not my custom to discuss my most
-intimate personal affairs in this public manner."
-
-"Then you won't forgive me? You won't shake hands before I go?"
-
-"Oh, certainly, if it would give you any pleasure." He put out
-his hand and coldly grasped that which she extended to him.
-
-"I had hoped," suggested Holmes, "that you would have joined us
-in a friendly supper."
-
-"I think that there you ask a little too much," responded his
-Lordship. "I may be forced to acquiesce in these recent
-developments, but I can hardly be expected to make merry over
-them. I think that with your permission I will now wish you all a
-very good-night." He included us all in a sweeping bow and
-stalked out of the room.
-
-"Then I trust that you at least will honour me with your
-company," said Sherlock Holmes. "It is always a joy to meet an
-American, Mr. Moulton, for I am one of those who believe that the
-folly of a monarch and the blundering of a minister in far-gone
-years will not prevent our children from being some day citizens
-of the same world-wide country under a flag which shall be a
-quartering of the Union Jack with the Stars and Stripes."
-
-"The case has been an interesting one," remarked Holmes when our
-visitors had left us, "because it serves to show very clearly how
-simple the explanation may be of an affair which at first sight
-seems to be almost inexplicable. Nothing could be more natural
-than the sequence of events as narrated by this lady, and nothing
-stranger than the result when viewed, for instance, by Mr.
-Lestrade of Scotland Yard."
-
-"You were not yourself at fault at all, then?"
-
-"From the first, two facts were very obvious to me, the one that
-the lady had been quite willing to undergo the wedding ceremony,
-the other that she had repented of it within a few minutes of
-returning home. Obviously something had occurred during the
-morning, then, to cause her to change her mind. What could that
-something be? She could not have spoken to anyone when she was
-out, for she had been in the company of the bridegroom. Had she
-seen someone, then? If she had, it must be someone from America
-because she had spent so short a time in this country that she
-could hardly have allowed anyone to acquire so deep an influence
-over her that the mere sight of him would induce her to change
-her plans so completely. You see we have already arrived, by a
-process of exclusion, at the idea that she might have seen an
-American. Then who could this American be, and why should he
-possess so much influence over her? It might be a lover; it might
-be a husband. Her young womanhood had, I knew, been spent in
-rough scenes and under strange conditions. So far I had got
-before I ever heard Lord St. Simon's narrative. When he told us
-of a man in a pew, of the change in the bride's manner, of so
-transparent a device for obtaining a note as the dropping of a
-bouquet, of her resort to her confidential maid, and of her very
-significant allusion to claim-jumping--which in miners' parlance
-means taking possession of that which another person has a prior
-claim to--the whole situation became absolutely clear. She had
-gone off with a man, and the man was either a lover or was a
-previous husband--the chances being in favour of the latter."
-
-"And how in the world did you find them?"
-
-"It might have been difficult, but friend Lestrade held
-information in his hands the value of which he did not himself
-know. The initials were, of course, of the highest importance,
-but more valuable still was it to know that within a week he had
-settled his bill at one of the most select London hotels."
-
-"How did you deduce the select?"
-
-"By the select prices. Eight shillings for a bed and eightpence
-for a glass of sherry pointed to one of the most expensive
-hotels. There are not many in London which charge at that rate.
-In the second one which I visited in Northumberland Avenue, I
-learned by an inspection of the book that Francis H. Moulton, an
-American gentleman, had left only the day before, and on looking
-over the entries against him, I came upon the very items which I
-had seen in the duplicate bill. His letters were to be forwarded
-to 226 Gordon Square; so thither I travelled, and being fortunate
-enough to find the loving couple at home, I ventured to give them
-some paternal advice and to point out to them that it would be
-better in every way that they should make their position a little
-clearer both to the general public and to Lord St. Simon in
-particular. I invited them to meet him here, and, as you see, I
-made him keep the appointment."
-
-"But with no very good result," I remarked. "His conduct was
-certainly not very gracious."
-
-"Ah, Watson," said Holmes, smiling, "perhaps you would not be
-very gracious either, if, after all the trouble of wooing and
-wedding, you found yourself deprived in an instant of wife and of
-fortune. I think that we may judge Lord St. Simon very mercifully
-and thank our stars that we are never likely to find ourselves in
-the same position. Draw your chair up and hand me my violin, for
-the only problem we have still to solve is how to while away
-these bleak autumnal evenings."
-
-
-
-XI. THE ADVENTURE OF THE BERYL CORONET
-
-"Holmes," said I as I stood one morning in our bow-window looking
-down the street, "here is a madman coming along. It seems rather
-sad that his relatives should allow him to come out alone."
-
-My friend rose lazily from his armchair and stood with his hands
-in the pockets of his dressing-gown, looking over my shoulder. It
-was a bright, crisp February morning, and the snow of the day
-before still lay deep upon the ground, shimmering brightly in the
-wintry sun. Down the centre of Baker Street it had been ploughed
-into a brown crumbly band by the traffic, but at either side and
-on the heaped-up edges of the foot-paths it still lay as white as
-when it fell. The grey pavement had been cleaned and scraped, but
-was still dangerously slippery, so that there were fewer
-passengers than usual. Indeed, from the direction of the
-Metropolitan Station no one was coming save the single gentleman
-whose eccentric conduct had drawn my attention.
-
-He was a man of about fifty, tall, portly, and imposing, with a
-massive, strongly marked face and a commanding figure. He was
-dressed in a sombre yet rich style, in black frock-coat, shining
-hat, neat brown gaiters, and well-cut pearl-grey trousers. Yet
-his actions were in absurd contrast to the dignity of his dress
-and features, for he was running hard, with occasional little
-springs, such as a weary man gives who is little accustomed to
-set any tax upon his legs. As he ran he jerked his hands up and
-down, waggled his head, and writhed his face into the most
-extraordinary contortions.
-
-"What on earth can be the matter with him?" I asked. "He is
-looking up at the numbers of the houses."
-
-"I believe that he is coming here," said Holmes, rubbing his
-hands.
-
-"Here?"
-
-"Yes; I rather think he is coming to consult me professionally. I
-think that I recognise the symptoms. Ha! did I not tell you?" As
-he spoke, the man, puffing and blowing, rushed at our door and
-pulled at our bell until the whole house resounded with the
-clanging.
-
-A few moments later he was in our room, still puffing, still
-gesticulating, but with so fixed a look of grief and despair in
-his eyes that our smiles were turned in an instant to horror and
-pity. For a while he could not get his words out, but swayed his
-body and plucked at his hair like one who has been driven to the
-extreme limits of his reason. Then, suddenly springing to his
-feet, he beat his head against the wall with such force that we
-both rushed upon him and tore him away to the centre of the room.
-Sherlock Holmes pushed him down into the easy-chair and, sitting
-beside him, patted his hand and chatted with him in the easy,
-soothing tones which he knew so well how to employ.
-
-"You have come to me to tell your story, have you not?" said he.
-"You are fatigued with your haste. Pray wait until you have
-recovered yourself, and then I shall be most happy to look into
-any little problem which you may submit to me."
-
-The man sat for a minute or more with a heaving chest, fighting
-against his emotion. Then he passed his handkerchief over his
-brow, set his lips tight, and turned his face towards us.
-
-"No doubt you think me mad?" said he.
-
-"I see that you have had some great trouble," responded Holmes.
-
-"God knows I have!--a trouble which is enough to unseat my
-reason, so sudden and so terrible is it. Public disgrace I might
-have faced, although I am a man whose character has never yet
-borne a stain. Private affliction also is the lot of every man;
-but the two coming together, and in so frightful a form, have
-been enough to shake my very soul. Besides, it is not I alone.
-The very noblest in the land may suffer unless some way be found
-out of this horrible affair."
-
-"Pray compose yourself, sir," said Holmes, "and let me have a
-clear account of who you are and what it is that has befallen
-you."
-
-"My name," answered our visitor, "is probably familiar to your
-ears. I am Alexander Holder, of the banking firm of Holder &
-Stevenson, of Threadneedle Street."
-
-The name was indeed well known to us as belonging to the senior
-partner in the second largest private banking concern in the City
-of London. What could have happened, then, to bring one of the
-foremost citizens of London to this most pitiable pass? We
-waited, all curiosity, until with another effort he braced
-himself to tell his story.
-
-"I feel that time is of value," said he; "that is why I hastened
-here when the police inspector suggested that I should secure
-your co-operation. I came to Baker Street by the Underground and
-hurried from there on foot, for the cabs go slowly through this
-snow. That is why I was so out of breath, for I am a man who
-takes very little exercise. I feel better now, and I will put the
-facts before you as shortly and yet as clearly as I can.
-
-"It is, of course, well known to you that in a successful banking
-business as much depends upon our being able to find remunerative
-investments for our funds as upon our increasing our connection
-and the number of our depositors. One of our most lucrative means
-of laying out money is in the shape of loans, where the security
-is unimpeachable. We have done a good deal in this direction
-during the last few years, and there are many noble families to
-whom we have advanced large sums upon the security of their
-pictures, libraries, or plate.
-
-"Yesterday morning I was seated in my office at the bank when a
-card was brought in to me by one of the clerks. I started when I
-saw the name, for it was that of none other than--well, perhaps
-even to you I had better say no more than that it was a name
-which is a household word all over the earth--one of the highest,
-noblest, most exalted names in England. I was overwhelmed by the
-honour and attempted, when he entered, to say so, but he plunged
-at once into business with the air of a man who wishes to hurry
-quickly through a disagreeable task.
-
-"'Mr. Holder,' said he, 'I have been informed that you are in the
-habit of advancing money.'
-
-"'The firm does so when the security is good.' I answered.
-
-"'It is absolutely essential to me,' said he, 'that I should have
-50,000 pounds at once. I could, of course, borrow so trifling a
-sum ten times over from my friends, but I much prefer to make it
-a matter of business and to carry out that business myself. In my
-position you can readily understand that it is unwise to place
-one's self under obligations.'
-
-"'For how long, may I ask, do you want this sum?' I asked.
-
-"'Next Monday I have a large sum due to me, and I shall then most
-certainly repay what you advance, with whatever interest you
-think it right to charge. But it is very essential to me that the
-money should be paid at once.'
-
-"'I should be happy to advance it without further parley from my
-own private purse,' said I, 'were it not that the strain would be
-rather more than it could bear. If, on the other hand, I am to do
-it in the name of the firm, then in justice to my partner I must
-insist that, even in your case, every businesslike precaution
-should be taken.'
-
-"'I should much prefer to have it so,' said he, raising up a
-square, black morocco case which he had laid beside his chair.
-'You have doubtless heard of the Beryl Coronet?'
-
-"'One of the most precious public possessions of the empire,'
-said I.
-
-"'Precisely.' He opened the case, and there, imbedded in soft,
-flesh-coloured velvet, lay the magnificent piece of jewellery
-which he had named. 'There are thirty-nine enormous beryls,' said
-he, 'and the price of the gold chasing is incalculable. The
-lowest estimate would put the worth of the coronet at double the
-sum which I have asked. I am prepared to leave it with you as my
-security.'
-
-"I took the precious case into my hands and looked in some
-perplexity from it to my illustrious client.
-
-"'You doubt its value?' he asked.
-
-"'Not at all. I only doubt--'
-
-"'The propriety of my leaving it. You may set your mind at rest
-about that. I should not dream of doing so were it not absolutely
-certain that I should be able in four days to reclaim it. It is a
-pure matter of form. Is the security sufficient?'
-
-"'Ample.'
-
-"'You understand, Mr. Holder, that I am giving you a strong proof
-of the confidence which I have in you, founded upon all that I
-have heard of you. I rely upon you not only to be discreet and to
-refrain from all gossip upon the matter but, above all, to
-preserve this coronet with every possible precaution because I
-need not say that a great public scandal would be caused if any
-harm were to befall it. Any injury to it would be almost as
-serious as its complete loss, for there are no beryls in the
-world to match these, and it would be impossible to replace them.
-I leave it with you, however, with every confidence, and I shall
-call for it in person on Monday morning.'
-
-"Seeing that my client was anxious to leave, I said no more but,
-calling for my cashier, I ordered him to pay over fifty 1000
-pound notes. When I was alone once more, however, with the
-precious case lying upon the table in front of me, I could not
-but think with some misgivings of the immense responsibility
-which it entailed upon me. There could be no doubt that, as it
-was a national possession, a horrible scandal would ensue if any
-misfortune should occur to it. I already regretted having ever
-consented to take charge of it. However, it was too late to alter
-the matter now, so I locked it up in my private safe and turned
-once more to my work.
-
-"When evening came I felt that it would be an imprudence to leave
-so precious a thing in the office behind me. Bankers' safes had
-been forced before now, and why should not mine be? If so, how
-terrible would be the position in which I should find myself! I
-determined, therefore, that for the next few days I would always
-carry the case backward and forward with me, so that it might
-never be really out of my reach. With this intention, I called a
-cab and drove out to my house at Streatham, carrying the jewel
-with me. I did not breathe freely until I had taken it upstairs
-and locked it in the bureau of my dressing-room.
-
-"And now a word as to my household, Mr. Holmes, for I wish you to
-thoroughly understand the situation. My groom and my page sleep
-out of the house, and may be set aside altogether. I have three
-maid-servants who have been with me a number of years and whose
-absolute reliability is quite above suspicion. Another, Lucy
-Parr, the second waiting-maid, has only been in my service a few
-months. She came with an excellent character, however, and has
-always given me satisfaction. She is a very pretty girl and has
-attracted admirers who have occasionally hung about the place.
-That is the only drawback which we have found to her, but we
-believe her to be a thoroughly good girl in every way.
-
-"So much for the servants. My family itself is so small that it
-will not take me long to describe it. I am a widower and have an
-only son, Arthur. He has been a disappointment to me, Mr.
-Holmes--a grievous disappointment. I have no doubt that I am
-myself to blame. People tell me that I have spoiled him. Very
-likely I have. When my dear wife died I felt that he was all I
-had to love. I could not bear to see the smile fade even for a
-moment from his face. I have never denied him a wish. Perhaps it
-would have been better for both of us had I been sterner, but I
-meant it for the best.
-
-"It was naturally my intention that he should succeed me in my
-business, but he was not of a business turn. He was wild,
-wayward, and, to speak the truth, I could not trust him in the
-handling of large sums of money. When he was young he became a
-member of an aristocratic club, and there, having charming
-manners, he was soon the intimate of a number of men with long
-purses and expensive habits. He learned to play heavily at cards
-and to squander money on the turf, until he had again and again
-to come to me and implore me to give him an advance upon his
-allowance, that he might settle his debts of honour. He tried
-more than once to break away from the dangerous company which he
-was keeping, but each time the influence of his friend, Sir
-George Burnwell, was enough to draw him back again.
-
-"And, indeed, I could not wonder that such a man as Sir George
-Burnwell should gain an influence over him, for he has frequently
-brought him to my house, and I have found myself that I could
-hardly resist the fascination of his manner. He is older than
-Arthur, a man of the world to his finger-tips, one who had been
-everywhere, seen everything, a brilliant talker, and a man of
-great personal beauty. Yet when I think of him in cold blood, far
-away from the glamour of his presence, I am convinced from his
-cynical speech and the look which I have caught in his eyes that
-he is one who should be deeply distrusted. So I think, and so,
-too, thinks my little Mary, who has a woman's quick insight into
-character.
-
-"And now there is only she to be described. She is my niece; but
-when my brother died five years ago and left her alone in the
-world I adopted her, and have looked upon her ever since as my
-daughter. She is a sunbeam in my house--sweet, loving, beautiful,
-a wonderful manager and housekeeper, yet as tender and quiet and
-gentle as a woman could be. She is my right hand. I do not know
-what I could do without her. In only one matter has she ever gone
-against my wishes. Twice my boy has asked her to marry him, for
-he loves her devotedly, but each time she has refused him. I
-think that if anyone could have drawn him into the right path it
-would have been she, and that his marriage might have changed his
-whole life; but now, alas! it is too late--forever too late!
-
-"Now, Mr. Holmes, you know the people who live under my roof, and
-I shall continue with my miserable story.
-
-"When we were taking coffee in the drawing-room that night after
-dinner, I told Arthur and Mary my experience, and of the precious
-treasure which we had under our roof, suppressing only the name
-of my client. Lucy Parr, who had brought in the coffee, had, I am
-sure, left the room; but I cannot swear that the door was closed.
-Mary and Arthur were much interested and wished to see the famous
-coronet, but I thought it better not to disturb it.
-
-"'Where have you put it?' asked Arthur.
-
-"'In my own bureau.'
-
-"'Well, I hope to goodness the house won't be burgled during the
-night.' said he.
-
-"'It is locked up,' I answered.
-
-"'Oh, any old key will fit that bureau. When I was a youngster I
-have opened it myself with the key of the box-room cupboard.'
-
-"He often had a wild way of talking, so that I thought little of
-what he said. He followed me to my room, however, that night with
-a very grave face.
-
-"'Look here, dad,' said he with his eyes cast down, 'can you let
-me have 200 pounds?'
-
-"'No, I cannot!' I answered sharply. 'I have been far too
-generous with you in money matters.'
-
-"'You have been very kind,' said he, 'but I must have this money,
-or else I can never show my face inside the club again.'
-
-"'And a very good thing, too!' I cried.
-
-"'Yes, but you would not have me leave it a dishonoured man,'
-said he. 'I could not bear the disgrace. I must raise the money
-in some way, and if you will not let me have it, then I must try
-other means.'
-
-"I was very angry, for this was the third demand during the
-month. 'You shall not have a farthing from me,' I cried, on which
-he bowed and left the room without another word.
-
-"When he was gone I unlocked my bureau, made sure that my
-treasure was safe, and locked it again. Then I started to go
-round the house to see that all was secure--a duty which I
-usually leave to Mary but which I thought it well to perform
-myself that night. As I came down the stairs I saw Mary herself
-at the side window of the hall, which she closed and fastened as
-I approached.
-
-"'Tell me, dad,' said she, looking, I thought, a little
-disturbed, 'did you give Lucy, the maid, leave to go out
-to-night?'
-
-"'Certainly not.'
-
-"'She came in just now by the back door. I have no doubt that she
-has only been to the side gate to see someone, but I think that
-it is hardly safe and should be stopped.'
-
-"'You must speak to her in the morning, or I will if you prefer
-it. Are you sure that everything is fastened?'
-
-"'Quite sure, dad.'
-
-"'Then, good-night.' I kissed her and went up to my bedroom
-again, where I was soon asleep.
-
-"I am endeavouring to tell you everything, Mr. Holmes, which may
-have any bearing upon the case, but I beg that you will question
-me upon any point which I do not make clear."
-
-"On the contrary, your statement is singularly lucid."
-
-"I come to a part of my story now in which I should wish to be
-particularly so. I am not a very heavy sleeper, and the anxiety
-in my mind tended, no doubt, to make me even less so than usual.
-About two in the morning, then, I was awakened by some sound in
-the house. It had ceased ere I was wide awake, but it had left an
-impression behind it as though a window had gently closed
-somewhere. I lay listening with all my ears. Suddenly, to my
-horror, there was a distinct sound of footsteps moving softly in
-the next room. I slipped out of bed, all palpitating with fear,
-and peeped round the corner of my dressing-room door.
-
-"'Arthur!' I screamed, 'you villain! you thief! How dare you
-touch that coronet?'
-
-"The gas was half up, as I had left it, and my unhappy boy,
-dressed only in his shirt and trousers, was standing beside the
-light, holding the coronet in his hands. He appeared to be
-wrenching at it, or bending it with all his strength. At my cry
-he dropped it from his grasp and turned as pale as death. I
-snatched it up and examined it. One of the gold corners, with
-three of the beryls in it, was missing.
-
-"'You blackguard!' I shouted, beside myself with rage. 'You have
-destroyed it! You have dishonoured me forever! Where are the
-jewels which you have stolen?'
-
-"'Stolen!' he cried.
-
-"'Yes, thief!' I roared, shaking him by the shoulder.
-
-"'There are none missing. There cannot be any missing,' said he.
-
-"'There are three missing. And you know where they are. Must I
-call you a liar as well as a thief? Did I not see you trying to
-tear off another piece?'
-
-"'You have called me names enough,' said he, 'I will not stand it
-any longer. I shall not say another word about this business,
-since you have chosen to insult me. I will leave your house in
-the morning and make my own way in the world.'
-
-"'You shall leave it in the hands of the police!' I cried
-half-mad with grief and rage. 'I shall have this matter probed to
-the bottom.'
-
-"'You shall learn nothing from me,' said he with a passion such
-as I should not have thought was in his nature. 'If you choose to
-call the police, let the police find what they can.'
-
-"By this time the whole house was astir, for I had raised my
-voice in my anger. Mary was the first to rush into my room, and,
-at the sight of the coronet and of Arthur's face, she read the
-whole story and, with a scream, fell down senseless on the
-ground. I sent the house-maid for the police and put the
-investigation into their hands at once. When the inspector and a
-constable entered the house, Arthur, who had stood sullenly with
-his arms folded, asked me whether it was my intention to charge
-him with theft. I answered that it had ceased to be a private
-matter, but had become a public one, since the ruined coronet was
-national property. I was determined that the law should have its
-way in everything.
-
-"'At least,' said he, 'you will not have me arrested at once. It
-would be to your advantage as well as mine if I might leave the
-house for five minutes.'
-
-"'That you may get away, or perhaps that you may conceal what you
-have stolen,' said I. And then, realising the dreadful position
-in which I was placed, I implored him to remember that not only
-my honour but that of one who was far greater than I was at
-stake; and that he threatened to raise a scandal which would
-convulse the nation. He might avert it all if he would but tell
-me what he had done with the three missing stones.
-
-"'You may as well face the matter,' said I; 'you have been caught
-in the act, and no confession could make your guilt more heinous.
-If you but make such reparation as is in your power, by telling
-us where the beryls are, all shall be forgiven and forgotten.'
-
-"'Keep your forgiveness for those who ask for it,' he answered,
-turning away from me with a sneer. I saw that he was too hardened
-for any words of mine to influence him. There was but one way for
-it. I called in the inspector and gave him into custody. A search
-was made at once not only of his person but of his room and of
-every portion of the house where he could possibly have concealed
-the gems; but no trace of them could be found, nor would the
-wretched boy open his mouth for all our persuasions and our
-threats. This morning he was removed to a cell, and I, after
-going through all the police formalities, have hurried round to
-you to implore you to use your skill in unravelling the matter.
-The police have openly confessed that they can at present make
-nothing of it. You may go to any expense which you think
-necessary. I have already offered a reward of 1000 pounds. My
-God, what shall I do! I have lost my honour, my gems, and my son
-in one night. Oh, what shall I do!"
-
-He put a hand on either side of his head and rocked himself to
-and fro, droning to himself like a child whose grief has got
-beyond words.
-
-Sherlock Holmes sat silent for some few minutes, with his brows
-knitted and his eyes fixed upon the fire.
-
-"Do you receive much company?" he asked.
-
-"None save my partner with his family and an occasional friend of
-Arthur's. Sir George Burnwell has been several times lately. No
-one else, I think."
-
-"Do you go out much in society?"
-
-"Arthur does. Mary and I stay at home. We neither of us care for
-it."
-
-"That is unusual in a young girl."
-
-"She is of a quiet nature. Besides, she is not so very young. She
-is four-and-twenty."
-
-"This matter, from what you say, seems to have been a shock to
-her also."
-
-"Terrible! She is even more affected than I."
-
-"You have neither of you any doubt as to your son's guilt?"
-
-"How can we have when I saw him with my own eyes with the coronet
-in his hands."
-
-"I hardly consider that a conclusive proof. Was the remainder of
-the coronet at all injured?"
-
-"Yes, it was twisted."
-
-"Do you not think, then, that he might have been trying to
-straighten it?"
-
-"God bless you! You are doing what you can for him and for me.
-But it is too heavy a task. What was he doing there at all? If
-his purpose were innocent, why did he not say so?"
-
-"Precisely. And if it were guilty, why did he not invent a lie?
-His silence appears to me to cut both ways. There are several
-singular points about the case. What did the police think of the
-noise which awoke you from your sleep?"
-
-"They considered that it might be caused by Arthur's closing his
-bedroom door."
-
-"A likely story! As if a man bent on felony would slam his door
-so as to wake a household. What did they say, then, of the
-disappearance of these gems?"
-
-"They are still sounding the planking and probing the furniture
-in the hope of finding them."
-
-"Have they thought of looking outside the house?"
-
-"Yes, they have shown extraordinary energy. The whole garden has
-already been minutely examined."
-
-"Now, my dear sir," said Holmes, "is it not obvious to you now
-that this matter really strikes very much deeper than either you
-or the police were at first inclined to think? It appeared to you
-to be a simple case; to me it seems exceedingly complex. Consider
-what is involved by your theory. You suppose that your son came
-down from his bed, went, at great risk, to your dressing-room,
-opened your bureau, took out your coronet, broke off by main
-force a small portion of it, went off to some other place,
-concealed three gems out of the thirty-nine, with such skill that
-nobody can find them, and then returned with the other thirty-six
-into the room in which he exposed himself to the greatest danger
-of being discovered. I ask you now, is such a theory tenable?"
-
-"But what other is there?" cried the banker with a gesture of
-despair. "If his motives were innocent, why does he not explain
-them?"
-
-"It is our task to find that out," replied Holmes; "so now, if
-you please, Mr. Holder, we will set off for Streatham together,
-and devote an hour to glancing a little more closely into
-details."
-
-My friend insisted upon my accompanying them in their expedition,
-which I was eager enough to do, for my curiosity and sympathy
-were deeply stirred by the story to which we had listened. I
-confess that the guilt of the banker's son appeared to me to be
-as obvious as it did to his unhappy father, but still I had such
-faith in Holmes' judgment that I felt that there must be some
-grounds for hope as long as he was dissatisfied with the accepted
-explanation. He hardly spoke a word the whole way out to the
-southern suburb, but sat with his chin upon his breast and his
-hat drawn over his eyes, sunk in the deepest thought. Our client
-appeared to have taken fresh heart at the little glimpse of hope
-which had been presented to him, and he even broke into a
-desultory chat with me over his business affairs. A short railway
-journey and a shorter walk brought us to Fairbank, the modest
-residence of the great financier.
-
-Fairbank was a good-sized square house of white stone, standing
-back a little from the road. A double carriage-sweep, with a
-snow-clad lawn, stretched down in front to two large iron gates
-which closed the entrance. On the right side was a small wooden
-thicket, which led into a narrow path between two neat hedges
-stretching from the road to the kitchen door, and forming the
-tradesmen's entrance. On the left ran a lane which led to the
-stables, and was not itself within the grounds at all, being a
-public, though little used, thoroughfare. Holmes left us standing
-at the door and walked slowly all round the house, across the
-front, down the tradesmen's path, and so round by the garden
-behind into the stable lane. So long was he that Mr. Holder and I
-went into the dining-room and waited by the fire until he should
-return. We were sitting there in silence when the door opened and
-a young lady came in. She was rather above the middle height,
-slim, with dark hair and eyes, which seemed the darker against
-the absolute pallor of her skin. I do not think that I have ever
-seen such deadly paleness in a woman's face. Her lips, too, were
-bloodless, but her eyes were flushed with crying. As she swept
-silently into the room she impressed me with a greater sense of
-grief than the banker had done in the morning, and it was the
-more striking in her as she was evidently a woman of strong
-character, with immense capacity for self-restraint. Disregarding
-my presence, she went straight to her uncle and passed her hand
-over his head with a sweet womanly caress.
-
-"You have given orders that Arthur should be liberated, have you
-not, dad?" she asked.
-
-"No, no, my girl, the matter must be probed to the bottom."
-
-"But I am so sure that he is innocent. You know what woman's
-instincts are. I know that he has done no harm and that you will
-be sorry for having acted so harshly."
-
-"Why is he silent, then, if he is innocent?"
-
-"Who knows? Perhaps because he was so angry that you should
-suspect him."
-
-"How could I help suspecting him, when I actually saw him with
-the coronet in his hand?"
-
-"Oh, but he had only picked it up to look at it. Oh, do, do take
-my word for it that he is innocent. Let the matter drop and say
-no more. It is so dreadful to think of our dear Arthur in
-prison!"
-
-"I shall never let it drop until the gems are found--never, Mary!
-Your affection for Arthur blinds you as to the awful consequences
-to me. Far from hushing the thing up, I have brought a gentleman
-down from London to inquire more deeply into it."
-
-"This gentleman?" she asked, facing round to me.
-
-"No, his friend. He wished us to leave him alone. He is round in
-the stable lane now."
-
-"The stable lane?" She raised her dark eyebrows. "What can he
-hope to find there? Ah! this, I suppose, is he. I trust, sir,
-that you will succeed in proving, what I feel sure is the truth,
-that my cousin Arthur is innocent of this crime."
-
-"I fully share your opinion, and I trust, with you, that we may
-prove it," returned Holmes, going back to the mat to knock the
-snow from his shoes. "I believe I have the honour of addressing
-Miss Mary Holder. Might I ask you a question or two?"
-
-"Pray do, sir, if it may help to clear this horrible affair up."
-
-"You heard nothing yourself last night?"
-
-"Nothing, until my uncle here began to speak loudly. I heard
-that, and I came down."
-
-"You shut up the windows and doors the night before. Did you
-fasten all the windows?"
-
-"Yes."
-
-"Were they all fastened this morning?"
-
-"Yes."
-
-"You have a maid who has a sweetheart? I think that you remarked
-to your uncle last night that she had been out to see him?"
-
-"Yes, and she was the girl who waited in the drawing-room, and
-who may have heard uncle's remarks about the coronet."
-
-"I see. You infer that she may have gone out to tell her
-sweetheart, and that the two may have planned the robbery."
-
-"But what is the good of all these vague theories," cried the
-banker impatiently, "when I have told you that I saw Arthur with
-the coronet in his hands?"
-
-"Wait a little, Mr. Holder. We must come back to that. About this
-girl, Miss Holder. You saw her return by the kitchen door, I
-presume?"
-
-"Yes; when I went to see if the door was fastened for the night I
-met her slipping in. I saw the man, too, in the gloom."
-
-"Do you know him?"
-
-"Oh, yes! he is the green-grocer who brings our vegetables round.
-His name is Francis Prosper."
-
-"He stood," said Holmes, "to the left of the door--that is to
-say, farther up the path than is necessary to reach the door?"
-
-"Yes, he did."
-
-"And he is a man with a wooden leg?"
-
-Something like fear sprang up in the young lady's expressive
-black eyes. "Why, you are like a magician," said she. "How do you
-know that?" She smiled, but there was no answering smile in
-Holmes' thin, eager face.
-
-"I should be very glad now to go upstairs," said he. "I shall
-probably wish to go over the outside of the house again. Perhaps
-I had better take a look at the lower windows before I go up."
-
-He walked swiftly round from one to the other, pausing only at
-the large one which looked from the hall onto the stable lane.
-This he opened and made a very careful examination of the sill
-with his powerful magnifying lens. "Now we shall go upstairs,"
-said he at last.
-
-The banker's dressing-room was a plainly furnished little
-chamber, with a grey carpet, a large bureau, and a long mirror.
-Holmes went to the bureau first and looked hard at the lock.
-
-"Which key was used to open it?" he asked.
-
-"That which my son himself indicated--that of the cupboard of the
-lumber-room."
-
-"Have you it here?"
-
-"That is it on the dressing-table."
-
-Sherlock Holmes took it up and opened the bureau.
-
-"It is a noiseless lock," said he. "It is no wonder that it did
-not wake you. This case, I presume, contains the coronet. We must
-have a look at it." He opened the case, and taking out the diadem
-he laid it upon the table. It was a magnificent specimen of the
-jeweller's art, and the thirty-six stones were the finest that I
-have ever seen. At one side of the coronet was a cracked edge,
-where a corner holding three gems had been torn away.
-
-"Now, Mr. Holder," said Holmes, "here is the corner which
-corresponds to that which has been so unfortunately lost. Might I
-beg that you will break it off."
-
-The banker recoiled in horror. "I should not dream of trying,"
-said he.
-
-"Then I will." Holmes suddenly bent his strength upon it, but
-without result. "I feel it give a little," said he; "but, though
-I am exceptionally strong in the fingers, it would take me all my
-time to break it. An ordinary man could not do it. Now, what do
-you think would happen if I did break it, Mr. Holder? There would
-be a noise like a pistol shot. Do you tell me that all this
-happened within a few yards of your bed and that you heard
-nothing of it?"
-
-"I do not know what to think. It is all dark to me."
-
-"But perhaps it may grow lighter as we go. What do you think,
-Miss Holder?"
-
-"I confess that I still share my uncle's perplexity."
-
-"Your son had no shoes or slippers on when you saw him?"
-
-"He had nothing on save only his trousers and shirt."
-
-"Thank you. We have certainly been favoured with extraordinary
-luck during this inquiry, and it will be entirely our own fault
-if we do not succeed in clearing the matter up. With your
-permission, Mr. Holder, I shall now continue my investigations
-outside."
-
-He went alone, at his own request, for he explained that any
-unnecessary footmarks might make his task more difficult. For an
-hour or more he was at work, returning at last with his feet
-heavy with snow and his features as inscrutable as ever.
-
-"I think that I have seen now all that there is to see, Mr.
-Holder," said he; "I can serve you best by returning to my
-rooms."
-
-"But the gems, Mr. Holmes. Where are they?"
-
-"I cannot tell."
-
-The banker wrung his hands. "I shall never see them again!" he
-cried. "And my son? You give me hopes?"
-
-"My opinion is in no way altered."
-
-"Then, for God's sake, what was this dark business which was
-acted in my house last night?"
-
-"If you can call upon me at my Baker Street rooms to-morrow
-morning between nine and ten I shall be happy to do what I can to
-make it clearer. I understand that you give me carte blanche to
-act for you, provided only that I get back the gems, and that you
-place no limit on the sum I may draw."
-
-"I would give my fortune to have them back."
-
-"Very good. I shall look into the matter between this and then.
-Good-bye; it is just possible that I may have to come over here
-again before evening."
-
-It was obvious to me that my companion's mind was now made up
-about the case, although what his conclusions were was more than
-I could even dimly imagine. Several times during our homeward
-journey I endeavoured to sound him upon the point, but he always
-glided away to some other topic, until at last I gave it over in
-despair. It was not yet three when we found ourselves in our
-rooms once more. He hurried to his chamber and was down again in
-a few minutes dressed as a common loafer. With his collar turned
-up, his shiny, seedy coat, his red cravat, and his worn boots, he
-was a perfect sample of the class.
-
-"I think that this should do," said he, glancing into the glass
-above the fireplace. "I only wish that you could come with me,
-Watson, but I fear that it won't do. I may be on the trail in
-this matter, or I may be following a will-o'-the-wisp, but I
-shall soon know which it is. I hope that I may be back in a few
-hours." He cut a slice of beef from the joint upon the sideboard,
-sandwiched it between two rounds of bread, and thrusting this
-rude meal into his pocket he started off upon his expedition.
-
-I had just finished my tea when he returned, evidently in
-excellent spirits, swinging an old elastic-sided boot in his
-hand. He chucked it down into a corner and helped himself to a
-cup of tea.
-
-"I only looked in as I passed," said he. "I am going right on."
-
-"Where to?"
-
-"Oh, to the other side of the West End. It may be some time
-before I get back. Don't wait up for me in case I should be
-late."
-
-"How are you getting on?"
-
-"Oh, so so. Nothing to complain of. I have been out to Streatham
-since I saw you last, but I did not call at the house. It is a
-very sweet little problem, and I would not have missed it for a
-good deal. However, I must not sit gossiping here, but must get
-these disreputable clothes off and return to my highly
-respectable self."
-
-I could see by his manner that he had stronger reasons for
-satisfaction than his words alone would imply. His eyes twinkled,
-and there was even a touch of colour upon his sallow cheeks. He
-hastened upstairs, and a few minutes later I heard the slam of
-the hall door, which told me that he was off once more upon his
-congenial hunt.
-
-I waited until midnight, but there was no sign of his return, so
-I retired to my room. It was no uncommon thing for him to be away
-for days and nights on end when he was hot upon a scent, so that
-his lateness caused me no surprise. I do not know at what hour he
-came in, but when I came down to breakfast in the morning there
-he was with a cup of coffee in one hand and the paper in the
-other, as fresh and trim as possible.
-
-"You will excuse my beginning without you, Watson," said he, "but
-you remember that our client has rather an early appointment this
-morning."
-
-"Why, it is after nine now," I answered. "I should not be
-surprised if that were he. I thought I heard a ring."
-
-It was, indeed, our friend the financier. I was shocked by the
-change which had come over him, for his face which was naturally
-of a broad and massive mould, was now pinched and fallen in,
-while his hair seemed to me at least a shade whiter. He entered
-with a weariness and lethargy which was even more painful than
-his violence of the morning before, and he dropped heavily into
-the armchair which I pushed forward for him.
-
-"I do not know what I have done to be so severely tried," said
-he. "Only two days ago I was a happy and prosperous man, without
-a care in the world. Now I am left to a lonely and dishonoured
-age. One sorrow comes close upon the heels of another. My niece,
-Mary, has deserted me."
-
-"Deserted you?"
-
-"Yes. Her bed this morning had not been slept in, her room was
-empty, and a note for me lay upon the hall table. I had said to
-her last night, in sorrow and not in anger, that if she had
-married my boy all might have been well with him. Perhaps it was
-thoughtless of me to say so. It is to that remark that she refers
-in this note:
-
-"'MY DEAREST UNCLE:--I feel that I have brought trouble upon you,
-and that if I had acted differently this terrible misfortune
-might never have occurred. I cannot, with this thought in my
-mind, ever again be happy under your roof, and I feel that I must
-leave you forever. Do not worry about my future, for that is
-provided for; and, above all, do not search for me, for it will
-be fruitless labour and an ill-service to me. In life or in
-death, I am ever your loving,--MARY.'
-
-"What could she mean by that note, Mr. Holmes? Do you think it
-points to suicide?"
-
-"No, no, nothing of the kind. It is perhaps the best possible
-solution. I trust, Mr. Holder, that you are nearing the end of
-your troubles."
-
-"Ha! You say so! You have heard something, Mr. Holmes; you have
-learned something! Where are the gems?"
-
-"You would not think 1000 pounds apiece an excessive sum for
-them?"
-
-"I would pay ten."
-
-"That would be unnecessary. Three thousand will cover the matter.
-And there is a little reward, I fancy. Have you your check-book?
-Here is a pen. Better make it out for 4000 pounds."
-
-With a dazed face the banker made out the required check. Holmes
-walked over to his desk, took out a little triangular piece of
-gold with three gems in it, and threw it down upon the table.
-
-With a shriek of joy our client clutched it up.
-
-"You have it!" he gasped. "I am saved! I am saved!"
-
-The reaction of joy was as passionate as his grief had been, and
-he hugged his recovered gems to his bosom.
-
-"There is one other thing you owe, Mr. Holder," said Sherlock
-Holmes rather sternly.
-
-"Owe!" He caught up a pen. "Name the sum, and I will pay it."
-
-"No, the debt is not to me. You owe a very humble apology to that
-noble lad, your son, who has carried himself in this matter as I
-should be proud to see my own son do, should I ever chance to
-have one."
-
-"Then it was not Arthur who took them?"
-
-"I told you yesterday, and I repeat to-day, that it was not."
-
-"You are sure of it! Then let us hurry to him at once to let him
-know that the truth is known."
-
-"He knows it already. When I had cleared it all up I had an
-interview with him, and finding that he would not tell me the
-story, I told it to him, on which he had to confess that I was
-right and to add the very few details which were not yet quite
-clear to me. Your news of this morning, however, may open his
-lips."
-
-"For heaven's sake, tell me, then, what is this extraordinary
-mystery!"
-
-"I will do so, and I will show you the steps by which I reached
-it. And let me say to you, first, that which it is hardest for me
-to say and for you to hear: there has been an understanding
-between Sir George Burnwell and your niece Mary. They have now
-fled together."
-
-"My Mary? Impossible!"
-
-"It is unfortunately more than possible; it is certain. Neither
-you nor your son knew the true character of this man when you
-admitted him into your family circle. He is one of the most
-dangerous men in England--a ruined gambler, an absolutely
-desperate villain, a man without heart or conscience. Your niece
-knew nothing of such men. When he breathed his vows to her, as he
-had done to a hundred before her, she flattered herself that she
-alone had touched his heart. The devil knows best what he said,
-but at least she became his tool and was in the habit of seeing
-him nearly every evening."
-
-"I cannot, and I will not, believe it!" cried the banker with an
-ashen face.
-
-"I will tell you, then, what occurred in your house last night.
-Your niece, when you had, as she thought, gone to your room,
-slipped down and talked to her lover through the window which
-leads into the stable lane. His footmarks had pressed right
-through the snow, so long had he stood there. She told him of the
-coronet. His wicked lust for gold kindled at the news, and he
-bent her to his will. I have no doubt that she loved you, but
-there are women in whom the love of a lover extinguishes all
-other loves, and I think that she must have been one. She had
-hardly listened to his instructions when she saw you coming
-downstairs, on which she closed the window rapidly and told you
-about one of the servants' escapade with her wooden-legged lover,
-which was all perfectly true.
-
-"Your boy, Arthur, went to bed after his interview with you but
-he slept badly on account of his uneasiness about his club debts.
-In the middle of the night he heard a soft tread pass his door,
-so he rose and, looking out, was surprised to see his cousin
-walking very stealthily along the passage until she disappeared
-into your dressing-room. Petrified with astonishment, the lad
-slipped on some clothes and waited there in the dark to see what
-would come of this strange affair. Presently she emerged from the
-room again, and in the light of the passage-lamp your son saw
-that she carried the precious coronet in her hands. She passed
-down the stairs, and he, thrilling with horror, ran along and
-slipped behind the curtain near your door, whence he could see
-what passed in the hall beneath. He saw her stealthily open the
-window, hand out the coronet to someone in the gloom, and then
-closing it once more hurry back to her room, passing quite close
-to where he stood hid behind the curtain.
-
-"As long as she was on the scene he could not take any action
-without a horrible exposure of the woman whom he loved. But the
-instant that she was gone he realised how crushing a misfortune
-this would be for you, and how all-important it was to set it
-right. He rushed down, just as he was, in his bare feet, opened
-the window, sprang out into the snow, and ran down the lane,
-where he could see a dark figure in the moonlight. Sir George
-Burnwell tried to get away, but Arthur caught him, and there was
-a struggle between them, your lad tugging at one side of the
-coronet, and his opponent at the other. In the scuffle, your son
-struck Sir George and cut him over the eye. Then something
-suddenly snapped, and your son, finding that he had the coronet
-in his hands, rushed back, closed the window, ascended to your
-room, and had just observed that the coronet had been twisted in
-the struggle and was endeavouring to straighten it when you
-appeared upon the scene."
-
-"Is it possible?" gasped the banker.
-
-"You then roused his anger by calling him names at a moment when
-he felt that he had deserved your warmest thanks. He could not
-explain the true state of affairs without betraying one who
-certainly deserved little enough consideration at his hands. He
-took the more chivalrous view, however, and preserved her
-secret."
-
-"And that was why she shrieked and fainted when she saw the
-coronet," cried Mr. Holder. "Oh, my God! what a blind fool I have
-been! And his asking to be allowed to go out for five minutes!
-The dear fellow wanted to see if the missing piece were at the
-scene of the struggle. How cruelly I have misjudged him!"
-
-"When I arrived at the house," continued Holmes, "I at once went
-very carefully round it to observe if there were any traces in
-the snow which might help me. I knew that none had fallen since
-the evening before, and also that there had been a strong frost
-to preserve impressions. I passed along the tradesmen's path, but
-found it all trampled down and indistinguishable. Just beyond it,
-however, at the far side of the kitchen door, a woman had stood
-and talked with a man, whose round impressions on one side showed
-that he had a wooden leg. I could even tell that they had been
-disturbed, for the woman had run back swiftly to the door, as was
-shown by the deep toe and light heel marks, while Wooden-leg had
-waited a little, and then had gone away. I thought at the time
-that this might be the maid and her sweetheart, of whom you had
-already spoken to me, and inquiry showed it was so. I passed
-round the garden without seeing anything more than random tracks,
-which I took to be the police; but when I got into the stable
-lane a very long and complex story was written in the snow in
-front of me.
-
-"There was a double line of tracks of a booted man, and a second
-double line which I saw with delight belonged to a man with naked
-feet. I was at once convinced from what you had told me that the
-latter was your son. The first had walked both ways, but the
-other had run swiftly, and as his tread was marked in places over
-the depression of the boot, it was obvious that he had passed
-after the other. I followed them up and found they led to the
-hall window, where Boots had worn all the snow away while
-waiting. Then I walked to the other end, which was a hundred
-yards or more down the lane. I saw where Boots had faced round,
-where the snow was cut up as though there had been a struggle,
-and, finally, where a few drops of blood had fallen, to show me
-that I was not mistaken. Boots had then run down the lane, and
-another little smudge of blood showed that it was he who had been
-hurt. When he came to the highroad at the other end, I found that
-the pavement had been cleared, so there was an end to that clue.
-
-"On entering the house, however, I examined, as you remember, the
-sill and framework of the hall window with my lens, and I could
-at once see that someone had passed out. I could distinguish the
-outline of an instep where the wet foot had been placed in coming
-in. I was then beginning to be able to form an opinion as to what
-had occurred. A man had waited outside the window; someone had
-brought the gems; the deed had been overseen by your son; he had
-pursued the thief; had struggled with him; they had each tugged
-at the coronet, their united strength causing injuries which
-neither alone could have effected. He had returned with the
-prize, but had left a fragment in the grasp of his opponent. So
-far I was clear. The question now was, who was the man and who
-was it brought him the coronet?
-
-"It is an old maxim of mine that when you have excluded the
-impossible, whatever remains, however improbable, must be the
-truth. Now, I knew that it was not you who had brought it down,
-so there only remained your niece and the maids. But if it were
-the maids, why should your son allow himself to be accused in
-their place? There could be no possible reason. As he loved his
-cousin, however, there was an excellent explanation why he should
-retain her secret--the more so as the secret was a disgraceful
-one. When I remembered that you had seen her at that window, and
-how she had fainted on seeing the coronet again, my conjecture
-became a certainty.
-
-"And who could it be who was her confederate? A lover evidently,
-for who else could outweigh the love and gratitude which she must
-feel to you? I knew that you went out little, and that your
-circle of friends was a very limited one. But among them was Sir
-George Burnwell. I had heard of him before as being a man of evil
-reputation among women. It must have been he who wore those boots
-and retained the missing gems. Even though he knew that Arthur
-had discovered him, he might still flatter himself that he was
-safe, for the lad could not say a word without compromising his
-own family.
-
-"Well, your own good sense will suggest what measures I took
-next. I went in the shape of a loafer to Sir George's house,
-managed to pick up an acquaintance with his valet, learned that
-his master had cut his head the night before, and, finally, at
-the expense of six shillings, made all sure by buying a pair of
-his cast-off shoes. With these I journeyed down to Streatham and
-saw that they exactly fitted the tracks."
-
-"I saw an ill-dressed vagabond in the lane yesterday evening,"
-said Mr. Holder.
-
-"Precisely. It was I. I found that I had my man, so I came home
-and changed my clothes. It was a delicate part which I had to
-play then, for I saw that a prosecution must be avoided to avert
-scandal, and I knew that so astute a villain would see that our
-hands were tied in the matter. I went and saw him. At first, of
-course, he denied everything. But when I gave him every
-particular that had occurred, he tried to bluster and took down a
-life-preserver from the wall. I knew my man, however, and I
-clapped a pistol to his head before he could strike. Then he
-became a little more reasonable. I told him that we would give
-him a price for the stones he held--1000 pounds apiece. That
-brought out the first signs of grief that he had shown. 'Why,
-dash it all!' said he, 'I've let them go at six hundred for the
-three!' I soon managed to get the address of the receiver who had
-them, on promising him that there would be no prosecution. Off I
-set to him, and after much chaffering I got our stones at 1000
-pounds apiece. Then I looked in upon your son, told him that all
-was right, and eventually got to my bed about two o'clock, after
-what I may call a really hard day's work."
-
-"A day which has saved England from a great public scandal," said
-the banker, rising. "Sir, I cannot find words to thank you, but
-you shall not find me ungrateful for what you have done. Your
-skill has indeed exceeded all that I have heard of it. And now I
-must fly to my dear boy to apologise to him for the wrong which I
-have done him. As to what you tell me of poor Mary, it goes to my
-very heart. Not even your skill can inform me where she is now."
-
-"I think that we may safely say," returned Holmes, "that she is
-wherever Sir George Burnwell is. It is equally certain, too, that
-whatever her sins are, they will soon receive a more than
-sufficient punishment."
-
-
-
-XII. THE ADVENTURE OF THE COPPER BEECHES
-
-"To the man who loves art for its own sake," remarked Sherlock
-Holmes, tossing aside the advertisement sheet of the Daily
-Telegraph, "it is frequently in its least important and lowliest
-manifestations that the keenest pleasure is to be derived. It is
-pleasant to me to observe, Watson, that you have so far grasped
-this truth that in these little records of our cases which you
-have been good enough to draw up, and, I am bound to say,
-occasionally to embellish, you have given prominence not so much
-to the many causes célèbres and sensational trials in which I
-have figured but rather to those incidents which may have been
-trivial in themselves, but which have given room for those
-faculties of deduction and of logical synthesis which I have made
-my special province."
-
-"And yet," said I, smiling, "I cannot quite hold myself absolved
-from the charge of sensationalism which has been urged against my
-records."
-
-"You have erred, perhaps," he observed, taking up a glowing
-cinder with the tongs and lighting with it the long cherry-wood
-pipe which was wont to replace his clay when he was in a
-disputatious rather than a meditative mood--"you have erred
-perhaps in attempting to put colour and life into each of your
-statements instead of confining yourself to the task of placing
-upon record that severe reasoning from cause to effect which is
-really the only notable feature about the thing."
-
-"It seems to me that I have done you full justice in the matter,"
-I remarked with some coldness, for I was repelled by the egotism
-which I had more than once observed to be a strong factor in my
-friend's singular character.
-
-"No, it is not selfishness or conceit," said he, answering, as
-was his wont, my thoughts rather than my words. "If I claim full
-justice for my art, it is because it is an impersonal thing--a
-thing beyond myself. Crime is common. Logic is rare. Therefore it
-is upon the logic rather than upon the crime that you should
-dwell. You have degraded what should have been a course of
-lectures into a series of tales."
-
-It was a cold morning of the early spring, and we sat after
-breakfast on either side of a cheery fire in the old room at
-Baker Street. A thick fog rolled down between the lines of
-dun-coloured houses, and the opposing windows loomed like dark,
-shapeless blurs through the heavy yellow wreaths. Our gas was lit
-and shone on the white cloth and glimmer of china and metal, for
-the table had not been cleared yet. Sherlock Holmes had been
-silent all the morning, dipping continuously into the
-advertisement columns of a succession of papers until at last,
-having apparently given up his search, he had emerged in no very
-sweet temper to lecture me upon my literary shortcomings.
-
-"At the same time," he remarked after a pause, during which he
-had sat puffing at his long pipe and gazing down into the fire,
-"you can hardly be open to a charge of sensationalism, for out of
-these cases which you have been so kind as to interest yourself
-in, a fair proportion do not treat of crime, in its legal sense,
-at all. The small matter in which I endeavoured to help the King
-of Bohemia, the singular experience of Miss Mary Sutherland, the
-problem connected with the man with the twisted lip, and the
-incident of the noble bachelor, were all matters which are
-outside the pale of the law. But in avoiding the sensational, I
-fear that you may have bordered on the trivial."
-
-"The end may have been so," I answered, "but the methods I hold
-to have been novel and of interest."
-
-"Pshaw, my dear fellow, what do the public, the great unobservant
-public, who could hardly tell a weaver by his tooth or a
-compositor by his left thumb, care about the finer shades of
-analysis and deduction! But, indeed, if you are trivial, I cannot
-blame you, for the days of the great cases are past. Man, or at
-least criminal man, has lost all enterprise and originality. As
-to my own little practice, it seems to be degenerating into an
-agency for recovering lost lead pencils and giving advice to
-young ladies from boarding-schools. I think that I have touched
-bottom at last, however. This note I had this morning marks my
-zero-point, I fancy. Read it!" He tossed a crumpled letter across
-to me.
-
-It was dated from Montague Place upon the preceding evening, and
-ran thus:
-
-"DEAR MR. HOLMES:--I am very anxious to consult you as to whether
-I should or should not accept a situation which has been offered
-to me as governess. I shall call at half-past ten to-morrow if I
-do not inconvenience you. Yours faithfully,
-                                               "VIOLET HUNTER."
-
-"Do you know the young lady?" I asked.
-
-"Not I."
-
-"It is half-past ten now."
-
-"Yes, and I have no doubt that is her ring."
-
-"It may turn out to be of more interest than you think. You
-remember that the affair of the blue carbuncle, which appeared to
-be a mere whim at first, developed into a serious investigation.
-It may be so in this case, also."
-
-"Well, let us hope so. But our doubts will very soon be solved,
-for here, unless I am much mistaken, is the person in question."
-
-As he spoke the door opened and a young lady entered the room.
-She was plainly but neatly dressed, with a bright, quick face,
-freckled like a plover's egg, and with the brisk manner of a
-woman who has had her own way to make in the world.
-
-"You will excuse my troubling you, I am sure," said she, as my
-companion rose to greet her, "but I have had a very strange
-experience, and as I have no parents or relations of any sort
-from whom I could ask advice, I thought that perhaps you would be
-kind enough to tell me what I should do."
-
-"Pray take a seat, Miss Hunter. I shall be happy to do anything
-that I can to serve you."
-
-I could see that Holmes was favourably impressed by the manner
-and speech of his new client. He looked her over in his searching
-fashion, and then composed himself, with his lids drooping and
-his finger-tips together, to listen to her story.
-
-"I have been a governess for five years," said she, "in the
-family of Colonel Spence Munro, but two months ago the colonel
-received an appointment at Halifax, in Nova Scotia, and took his
-children over to America with him, so that I found myself without
-a situation. I advertised, and I answered advertisements, but
-without success. At last the little money which I had saved began
-to run short, and I was at my wit's end as to what I should do.
-
-"There is a well-known agency for governesses in the West End
-called Westaway's, and there I used to call about once a week in
-order to see whether anything had turned up which might suit me.
-Westaway was the name of the founder of the business, but it is
-really managed by Miss Stoper. She sits in her own little office,
-and the ladies who are seeking employment wait in an anteroom,
-and are then shown in one by one, when she consults her ledgers
-and sees whether she has anything which would suit them.
-
-"Well, when I called last week I was shown into the little office
-as usual, but I found that Miss Stoper was not alone. A
-prodigiously stout man with a very smiling face and a great heavy
-chin which rolled down in fold upon fold over his throat sat at
-her elbow with a pair of glasses on his nose, looking very
-earnestly at the ladies who entered. As I came in he gave quite a
-jump in his chair and turned quickly to Miss Stoper.
-
-"'That will do,' said he; 'I could not ask for anything better.
-Capital! capital!' He seemed quite enthusiastic and rubbed his
-hands together in the most genial fashion. He was such a
-comfortable-looking man that it was quite a pleasure to look at
-him.
-
-"'You are looking for a situation, miss?' he asked.
-
-"'Yes, sir.'
-
-"'As governess?'
-
-"'Yes, sir.'
-
-"'And what salary do you ask?'
-
-"'I had 4 pounds a month in my last place with Colonel Spence
-Munro.'
-
-"'Oh, tut, tut! sweating--rank sweating!' he cried, throwing his
-fat hands out into the air like a man who is in a boiling
-passion. 'How could anyone offer so pitiful a sum to a lady with
-such attractions and accomplishments?'
-
-"'My accomplishments, sir, may be less than you imagine,' said I.
-'A little French, a little German, music, and drawing--'
-
-"'Tut, tut!' he cried. 'This is all quite beside the question.
-The point is, have you or have you not the bearing and deportment
-of a lady? There it is in a nutshell. If you have not, you are
-not fitted for the rearing of a child who may some day play a
-considerable part in the history of the country. But if you have
-why, then, how could any gentleman ask you to condescend to
-accept anything under the three figures? Your salary with me,
-madam, would commence at 100 pounds a year.'
-
-"You may imagine, Mr. Holmes, that to me, destitute as I was,
-such an offer seemed almost too good to be true. The gentleman,
-however, seeing perhaps the look of incredulity upon my face,
-opened a pocket-book and took out a note.
-
-"'It is also my custom,' said he, smiling in the most pleasant
-fashion until his eyes were just two little shining slits amid
-the white creases of his face, 'to advance to my young ladies
-half their salary beforehand, so that they may meet any little
-expenses of their journey and their wardrobe.'
-
-"It seemed to me that I had never met so fascinating and so
-thoughtful a man. As I was already in debt to my tradesmen, the
-advance was a great convenience, and yet there was something
-unnatural about the whole transaction which made me wish to know
-a little more before I quite committed myself.
-
-"'May I ask where you live, sir?' said I.
-
-"'Hampshire. Charming rural place. The Copper Beeches, five miles
-on the far side of Winchester. It is the most lovely country, my
-dear young lady, and the dearest old country-house.'
-
-"'And my duties, sir? I should be glad to know what they would
-be.'
-
-"'One child--one dear little romper just six years old. Oh, if
-you could see him killing cockroaches with a slipper! Smack!
-smack! smack! Three gone before you could wink!' He leaned back
-in his chair and laughed his eyes into his head again.
-
-"I was a little startled at the nature of the child's amusement,
-but the father's laughter made me think that perhaps he was
-joking.
-
-"'My sole duties, then,' I asked, 'are to take charge of a single
-child?'
-
-"'No, no, not the sole, not the sole, my dear young lady,' he
-cried. 'Your duty would be, as I am sure your good sense would
-suggest, to obey any little commands my wife might give, provided
-always that they were such commands as a lady might with
-propriety obey. You see no difficulty, heh?'
-
-"'I should be happy to make myself useful.'
-
-"'Quite so. In dress now, for example. We are faddy people, you
-know--faddy but kind-hearted. If you were asked to wear any dress
-which we might give you, you would not object to our little whim.
-Heh?'
-
-"'No,' said I, considerably astonished at his words.
-
-"'Or to sit here, or sit there, that would not be offensive to
-you?'
-
-"'Oh, no.'
-
-"'Or to cut your hair quite short before you come to us?'
-
-"I could hardly believe my ears. As you may observe, Mr. Holmes,
-my hair is somewhat luxuriant, and of a rather peculiar tint of
-chestnut. It has been considered artistic. I could not dream of
-sacrificing it in this offhand fashion.
-
-"'I am afraid that that is quite impossible,' said I. He had been
-watching me eagerly out of his small eyes, and I could see a
-shadow pass over his face as I spoke.
-
-"'I am afraid that it is quite essential,' said he. 'It is a
-little fancy of my wife's, and ladies' fancies, you know, madam,
-ladies' fancies must be consulted. And so you won't cut your
-hair?'
-
-"'No, sir, I really could not,' I answered firmly.
-
-"'Ah, very well; then that quite settles the matter. It is a
-pity, because in other respects you would really have done very
-nicely. In that case, Miss Stoper, I had best inspect a few more
-of your young ladies.'
-
-"The manageress had sat all this while busy with her papers
-without a word to either of us, but she glanced at me now with so
-much annoyance upon her face that I could not help suspecting
-that she had lost a handsome commission through my refusal.
-
-"'Do you desire your name to be kept upon the books?' she asked.
-
-"'If you please, Miss Stoper.'
-
-"'Well, really, it seems rather useless, since you refuse the
-most excellent offers in this fashion,' said she sharply. 'You
-can hardly expect us to exert ourselves to find another such
-opening for you. Good-day to you, Miss Hunter.' She struck a gong
-upon the table, and I was shown out by the page.
-
-"Well, Mr. Holmes, when I got back to my lodgings and found
-little enough in the cupboard, and two or three bills upon the
-table, I began to ask myself whether I had not done a very
-foolish thing. After all, if these people had strange fads and
-expected obedience on the most extraordinary matters, they were
-at least ready to pay for their eccentricity. Very few
-governesses in England are getting 100 pounds a year. Besides,
-what use was my hair to me? Many people are improved by wearing
-it short and perhaps I should be among the number. Next day I was
-inclined to think that I had made a mistake, and by the day after
-I was sure of it. I had almost overcome my pride so far as to go
-back to the agency and inquire whether the place was still open
-when I received this letter from the gentleman himself. I have it
-here and I will read it to you:
-
-                       "'The Copper Beeches, near Winchester.
-"'DEAR MISS HUNTER:--Miss Stoper has very kindly given me your
-address, and I write from here to ask you whether you have
-reconsidered your decision. My wife is very anxious that you
-should come, for she has been much attracted by my description of
-you. We are willing to give 30 pounds a quarter, or 120 pounds a
-year, so as to recompense you for any little inconvenience which
-our fads may cause you. They are not very exacting, after all. My
-wife is fond of a particular shade of electric blue and would
-like you to wear such a dress indoors in the morning. You need
-not, however, go to the expense of purchasing one, as we have one
-belonging to my dear daughter Alice (now in Philadelphia), which
-would, I should think, fit you very well. Then, as to sitting
-here or there, or amusing yourself in any manner indicated, that
-need cause you no inconvenience. As regards your hair, it is no
-doubt a pity, especially as I could not help remarking its beauty
-during our short interview, but I am afraid that I must remain
-firm upon this point, and I only hope that the increased salary
-may recompense you for the loss. Your duties, as far as the child
-is concerned, are very light. Now do try to come, and I shall
-meet you with the dog-cart at Winchester. Let me know your train.
-Yours faithfully, JEPHRO RUCASTLE.'
-
-"That is the letter which I have just received, Mr. Holmes, and
-my mind is made up that I will accept it. I thought, however,
-that before taking the final step I should like to submit the
-whole matter to your consideration."
-
-"Well, Miss Hunter, if your mind is made up, that settles the
-question," said Holmes, smiling.
-
-"But you would not advise me to refuse?"
-
-"I confess that it is not the situation which I should like to
-see a sister of mine apply for."
-
-"What is the meaning of it all, Mr. Holmes?"
-
-"Ah, I have no data. I cannot tell. Perhaps you have yourself
-formed some opinion?"
-
-"Well, there seems to me to be only one possible solution. Mr.
-Rucastle seemed to be a very kind, good-natured man. Is it not
-possible that his wife is a lunatic, that he desires to keep the
-matter quiet for fear she should be taken to an asylum, and that
-he humours her fancies in every way in order to prevent an
-outbreak?"
-
-"That is a possible solution--in fact, as matters stand, it is
-the most probable one. But in any case it does not seem to be a
-nice household for a young lady."
-
-"But the money, Mr. Holmes, the money!"
-
-"Well, yes, of course the pay is good--too good. That is what
-makes me uneasy. Why should they give you 120 pounds a year, when
-they could have their pick for 40 pounds? There must be some
-strong reason behind."
-
-"I thought that if I told you the circumstances you would
-understand afterwards if I wanted your help. I should feel so
-much stronger if I felt that you were at the back of me."
-
-"Oh, you may carry that feeling away with you. I assure you that
-your little problem promises to be the most interesting which has
-come my way for some months. There is something distinctly novel
-about some of the features. If you should find yourself in doubt
-or in danger--"
-
-"Danger! What danger do you foresee?"
-
-Holmes shook his head gravely. "It would cease to be a danger if
-we could define it," said he. "But at any time, day or night, a
-telegram would bring me down to your help."
-
-"That is enough." She rose briskly from her chair with the
-anxiety all swept from her face. "I shall go down to Hampshire
-quite easy in my mind now. I shall write to Mr. Rucastle at once,
-sacrifice my poor hair to-night, and start for Winchester
-to-morrow." With a few grateful words to Holmes she bade us both
-good-night and bustled off upon her way.
-
-"At least," said I as we heard her quick, firm steps descending
-the stairs, "she seems to be a young lady who is very well able
-to take care of herself."
-
-"And she would need to be," said Holmes gravely. "I am much
-mistaken if we do not hear from her before many days are past."
-
-It was not very long before my friend's prediction was fulfilled.
-A fortnight went by, during which I frequently found my thoughts
-turning in her direction and wondering what strange side-alley of
-human experience this lonely woman had strayed into. The unusual
-salary, the curious conditions, the light duties, all pointed to
-something abnormal, though whether a fad or a plot, or whether
-the man were a philanthropist or a villain, it was quite beyond
-my powers to determine. As to Holmes, I observed that he sat
-frequently for half an hour on end, with knitted brows and an
-abstracted air, but he swept the matter away with a wave of his
-hand when I mentioned it. "Data! data! data!" he cried
-impatiently. "I can't make bricks without clay." And yet he would
-always wind up by muttering that no sister of his should ever
-have accepted such a situation.
-
-The telegram which we eventually received came late one night
-just as I was thinking of turning in and Holmes was settling down
-to one of those all-night chemical researches which he frequently
-indulged in, when I would leave him stooping over a retort and a
-test-tube at night and find him in the same position when I came
-down to breakfast in the morning. He opened the yellow envelope,
-and then, glancing at the message, threw it across to me.
-
-"Just look up the trains in Bradshaw," said he, and turned back
-to his chemical studies.
-
-The summons was a brief and urgent one.
-
-"Please be at the Black Swan Hotel at Winchester at midday
-to-morrow," it said. "Do come! I am at my wit's end.  HUNTER."
-
-"Will you come with me?" asked Holmes, glancing up.
-
-"I should wish to."
-
-"Just look it up, then."
-
-"There is a train at half-past nine," said I, glancing over my
-Bradshaw. "It is due at Winchester at 11:30."
-
-"That will do very nicely. Then perhaps I had better postpone my
-analysis of the acetones, as we may need to be at our best in the
-morning."
-
-By eleven o'clock the next day we were well upon our way to the
-old English capital. Holmes had been buried in the morning papers
-all the way down, but after we had passed the Hampshire border he
-threw them down and began to admire the scenery. It was an ideal
-spring day, a light blue sky, flecked with little fleecy white
-clouds drifting across from west to east. The sun was shining
-very brightly, and yet there was an exhilarating nip in the air,
-which set an edge to a man's energy. All over the countryside,
-away to the rolling hills around Aldershot, the little red and
-grey roofs of the farm-steadings peeped out from amid the light
-green of the new foliage.
-
-"Are they not fresh and beautiful?" I cried with all the
-enthusiasm of a man fresh from the fogs of Baker Street.
-
-But Holmes shook his head gravely.
-
-"Do you know, Watson," said he, "that it is one of the curses of
-a mind with a turn like mine that I must look at everything with
-reference to my own special subject. You look at these scattered
-houses, and you are impressed by their beauty. I look at them,
-and the only thought which comes to me is a feeling of their
-isolation and of the impunity with which crime may be committed
-there."
-
-"Good heavens!" I cried. "Who would associate crime with these
-dear old homesteads?"
-
-"They always fill me with a certain horror. It is my belief,
-Watson, founded upon my experience, that the lowest and vilest
-alleys in London do not present a more dreadful record of sin
-than does the smiling and beautiful countryside."
-
-"You horrify me!"
-
-"But the reason is very obvious. The pressure of public opinion
-can do in the town what the law cannot accomplish. There is no
-lane so vile that the scream of a tortured child, or the thud of
-a drunkard's blow, does not beget sympathy and indignation among
-the neighbours, and then the whole machinery of justice is ever
-so close that a word of complaint can set it going, and there is
-but a step between the crime and the dock. But look at these
-lonely houses, each in its own fields, filled for the most part
-with poor ignorant folk who know little of the law. Think of the
-deeds of hellish cruelty, the hidden wickedness which may go on,
-year in, year out, in such places, and none the wiser. Had this
-lady who appeals to us for help gone to live in Winchester, I
-should never have had a fear for her. It is the five miles of
-country which makes the danger. Still, it is clear that she is
-not personally threatened."
-
-"No. If she can come to Winchester to meet us she can get away."
-
-"Quite so. She has her freedom."
-
-"What CAN be the matter, then? Can you suggest no explanation?"
-
-"I have devised seven separate explanations, each of which would
-cover the facts as far as we know them. But which of these is
-correct can only be determined by the fresh information which we
-shall no doubt find waiting for us. Well, there is the tower of
-the cathedral, and we shall soon learn all that Miss Hunter has
-to tell."
-
-The Black Swan is an inn of repute in the High Street, at no
-distance from the station, and there we found the young lady
-waiting for us. She had engaged a sitting-room, and our lunch
-awaited us upon the table.
-
-"I am so delighted that you have come," she said earnestly. "It
-is so very kind of you both; but indeed I do not know what I
-should do. Your advice will be altogether invaluable to me."
-
-"Pray tell us what has happened to you."
-
-"I will do so, and I must be quick, for I have promised Mr.
-Rucastle to be back before three. I got his leave to come into
-town this morning, though he little knew for what purpose."
-
-"Let us have everything in its due order." Holmes thrust his long
-thin legs out towards the fire and composed himself to listen.
-
-"In the first place, I may say that I have met, on the whole,
-with no actual ill-treatment from Mr. and Mrs. Rucastle. It is
-only fair to them to say that. But I cannot understand them, and
-I am not easy in my mind about them."
-
-"What can you not understand?"
-
-"Their reasons for their conduct. But you shall have it all just
-as it occurred. When I came down, Mr. Rucastle met me here and
-drove me in his dog-cart to the Copper Beeches. It is, as he
-said, beautifully situated, but it is not beautiful in itself,
-for it is a large square block of a house, whitewashed, but all
-stained and streaked with damp and bad weather. There are grounds
-round it, woods on three sides, and on the fourth a field which
-slopes down to the Southampton highroad, which curves past about
-a hundred yards from the front door. This ground in front belongs
-to the house, but the woods all round are part of Lord
-Southerton's preserves. A clump of copper beeches immediately in
-front of the hall door has given its name to the place.
-
-"I was driven over by my employer, who was as amiable as ever,
-and was introduced by him that evening to his wife and the child.
-There was no truth, Mr. Holmes, in the conjecture which seemed to
-us to be probable in your rooms at Baker Street. Mrs. Rucastle is
-not mad. I found her to be a silent, pale-faced woman, much
-younger than her husband, not more than thirty, I should think,
-while he can hardly be less than forty-five. From their
-conversation I have gathered that they have been married about
-seven years, that he was a widower, and that his only child by
-the first wife was the daughter who has gone to Philadelphia. Mr.
-Rucastle told me in private that the reason why she had left them
-was that she had an unreasoning aversion to her stepmother. As
-the daughter could not have been less than twenty, I can quite
-imagine that her position must have been uncomfortable with her
-father's young wife.
-
-"Mrs. Rucastle seemed to me to be colourless in mind as well as
-in feature. She impressed me neither favourably nor the reverse.
-She was a nonentity. It was easy to see that she was passionately
-devoted both to her husband and to her little son. Her light grey
-eyes wandered continually from one to the other, noting every
-little want and forestalling it if possible. He was kind to her
-also in his bluff, boisterous fashion, and on the whole they
-seemed to be a happy couple. And yet she had some secret sorrow,
-this woman. She would often be lost in deep thought, with the
-saddest look upon her face. More than once I have surprised her
-in tears. I have thought sometimes that it was the disposition of
-her child which weighed upon her mind, for I have never met so
-utterly spoiled and so ill-natured a little creature. He is small
-for his age, with a head which is quite disproportionately large.
-His whole life appears to be spent in an alternation between
-savage fits of passion and gloomy intervals of sulking. Giving
-pain to any creature weaker than himself seems to be his one idea
-of amusement, and he shows quite remarkable talent in planning
-the capture of mice, little birds, and insects. But I would
-rather not talk about the creature, Mr. Holmes, and, indeed, he
-has little to do with my story."
-
-"I am glad of all details," remarked my friend, "whether they
-seem to you to be relevant or not."
-
-"I shall try not to miss anything of importance. The one
-unpleasant thing about the house, which struck me at once, was
-the appearance and conduct of the servants. There are only two, a
-man and his wife. Toller, for that is his name, is a rough,
-uncouth man, with grizzled hair and whiskers, and a perpetual
-smell of drink. Twice since I have been with them he has been
-quite drunk, and yet Mr. Rucastle seemed to take no notice of it.
-His wife is a very tall and strong woman with a sour face, as
-silent as Mrs. Rucastle and much less amiable. They are a most
-unpleasant couple, but fortunately I spend most of my time in the
-nursery and my own room, which are next to each other in one
-corner of the building.
-
-"For two days after my arrival at the Copper Beeches my life was
-very quiet; on the third, Mrs. Rucastle came down just after
-breakfast and whispered something to her husband.
-
-"'Oh, yes,' said he, turning to me, 'we are very much obliged to
-you, Miss Hunter, for falling in with our whims so far as to cut
-your hair. I assure you that it has not detracted in the tiniest
-iota from your appearance. We shall now see how the electric-blue
-dress will become you. You will find it laid out upon the bed in
-your room, and if you would be so good as to put it on we should
-both be extremely obliged.'
-
-"The dress which I found waiting for me was of a peculiar shade
-of blue. It was of excellent material, a sort of beige, but it
-bore unmistakable signs of having been worn before. It could not
-have been a better fit if I had been measured for it. Both Mr.
-and Mrs. Rucastle expressed a delight at the look of it, which
-seemed quite exaggerated in its vehemence. They were waiting for
-me in the drawing-room, which is a very large room, stretching
-along the entire front of the house, with three long windows
-reaching down to the floor. A chair had been placed close to the
-central window, with its back turned towards it. In this I was
-asked to sit, and then Mr. Rucastle, walking up and down on the
-other side of the room, began to tell me a series of the funniest
-stories that I have ever listened to. You cannot imagine how
-comical he was, and I laughed until I was quite weary. Mrs.
-Rucastle, however, who has evidently no sense of humour, never so
-much as smiled, but sat with her hands in her lap, and a sad,
-anxious look upon her face. After an hour or so, Mr. Rucastle
-suddenly remarked that it was time to commence the duties of the
-day, and that I might change my dress and go to little Edward in
-the nursery.
-
-"Two days later this same performance was gone through under
-exactly similar circumstances. Again I changed my dress, again I
-sat in the window, and again I laughed very heartily at the funny
-stories of which my employer had an immense répertoire, and which
-he told inimitably. Then he handed me a yellow-backed novel, and
-moving my chair a little sideways, that my own shadow might not
-fall upon the page, he begged me to read aloud to him. I read for
-about ten minutes, beginning in the heart of a chapter, and then
-suddenly, in the middle of a sentence, he ordered me to cease and
-to change my dress.
-
-"You can easily imagine, Mr. Holmes, how curious I became as to
-what the meaning of this extraordinary performance could possibly
-be. They were always very careful, I observed, to turn my face
-away from the window, so that I became consumed with the desire
-to see what was going on behind my back. At first it seemed to be
-impossible, but I soon devised a means. My hand-mirror had been
-broken, so a happy thought seized me, and I concealed a piece of
-the glass in my handkerchief. On the next occasion, in the midst
-of my laughter, I put my handkerchief up to my eyes, and was able
-with a little management to see all that there was behind me. I
-confess that I was disappointed. There was nothing. At least that
-was my first impression. At the second glance, however, I
-perceived that there was a man standing in the Southampton Road,
-a small bearded man in a grey suit, who seemed to be looking in
-my direction. The road is an important highway, and there are
-usually people there. This man, however, was leaning against the
-railings which bordered our field and was looking earnestly up. I
-lowered my handkerchief and glanced at Mrs. Rucastle to find her
-eyes fixed upon me with a most searching gaze. She said nothing,
-but I am convinced that she had divined that I had a mirror in my
-hand and had seen what was behind me. She rose at once.
-
-"'Jephro,' said she, 'there is an impertinent fellow upon the
-road there who stares up at Miss Hunter.'
-
-"'No friend of yours, Miss Hunter?' he asked.
-
-"'No, I know no one in these parts.'
-
-"'Dear me! How very impertinent! Kindly turn round and motion to
-him to go away.'
-
-"'Surely it would be better to take no notice.'
-
-"'No, no, we should have him loitering here always. Kindly turn
-round and wave him away like that.'
-
-"I did as I was told, and at the same instant Mrs. Rucastle drew
-down the blind. That was a week ago, and from that time I have
-not sat again in the window, nor have I worn the blue dress, nor
-seen the man in the road."
-
-"Pray continue," said Holmes. "Your narrative promises to be a
-most interesting one."
-
-"You will find it rather disconnected, I fear, and there may
-prove to be little relation between the different incidents of
-which I speak. On the very first day that I was at the Copper
-Beeches, Mr. Rucastle took me to a small outhouse which stands
-near the kitchen door. As we approached it I heard the sharp
-rattling of a chain, and the sound as of a large animal moving
-about.
-
-"'Look in here!' said Mr. Rucastle, showing me a slit between two
-planks. 'Is he not a beauty?'
-
-"I looked through and was conscious of two glowing eyes, and of a
-vague figure huddled up in the darkness.
-
-"'Don't be frightened,' said my employer, laughing at the start
-which I had given. 'It's only Carlo, my mastiff. I call him mine,
-but really old Toller, my groom, is the only man who can do
-anything with him. We feed him once a day, and not too much then,
-so that he is always as keen as mustard. Toller lets him loose
-every night, and God help the trespasser whom he lays his fangs
-upon. For goodness' sake don't you ever on any pretext set your
-foot over the threshold at night, for it's as much as your life
-is worth.'
-
-"The warning was no idle one, for two nights later I happened to
-look out of my bedroom window about two o'clock in the morning.
-It was a beautiful moonlight night, and the lawn in front of the
-house was silvered over and almost as bright as day. I was
-standing, rapt in the peaceful beauty of the scene, when I was
-aware that something was moving under the shadow of the copper
-beeches. As it emerged into the moonshine I saw what it was. It
-was a giant dog, as large as a calf, tawny tinted, with hanging
-jowl, black muzzle, and huge projecting bones. It walked slowly
-across the lawn and vanished into the shadow upon the other side.
-That dreadful sentinel sent a chill to my heart which I do not
-think that any burglar could have done.
-
-"And now I have a very strange experience to tell you. I had, as
-you know, cut off my hair in London, and I had placed it in a
-great coil at the bottom of my trunk. One evening, after the
-child was in bed, I began to amuse myself by examining the
-furniture of my room and by rearranging my own little things.
-There was an old chest of drawers in the room, the two upper ones
-empty and open, the lower one locked. I had filled the first two
-with my linen, and as I had still much to pack away I was
-naturally annoyed at not having the use of the third drawer. It
-struck me that it might have been fastened by a mere oversight,
-so I took out my bunch of keys and tried to open it. The very
-first key fitted to perfection, and I drew the drawer open. There
-was only one thing in it, but I am sure that you would never
-guess what it was. It was my coil of hair.
-
-"I took it up and examined it. It was of the same peculiar tint,
-and the same thickness. But then the impossibility of the thing
-obtruded itself upon me. How could my hair have been locked in
-the drawer? With trembling hands I undid my trunk, turned out the
-contents, and drew from the bottom my own hair. I laid the two
-tresses together, and I assure you that they were identical. Was
-it not extraordinary? Puzzle as I would, I could make nothing at
-all of what it meant. I returned the strange hair to the drawer,
-and I said nothing of the matter to the Rucastles as I felt that
-I had put myself in the wrong by opening a drawer which they had
-locked.
-
-"I am naturally observant, as you may have remarked, Mr. Holmes,
-and I soon had a pretty good plan of the whole house in my head.
-There was one wing, however, which appeared not to be inhabited
-at all. A door which faced that which led into the quarters of
-the Tollers opened into this suite, but it was invariably locked.
-One day, however, as I ascended the stair, I met Mr. Rucastle
-coming out through this door, his keys in his hand, and a look on
-his face which made him a very different person to the round,
-jovial man to whom I was accustomed. His cheeks were red, his
-brow was all crinkled with anger, and the veins stood out at his
-temples with passion. He locked the door and hurried past me
-without a word or a look.
-
-"This aroused my curiosity, so when I went out for a walk in the
-grounds with my charge, I strolled round to the side from which I
-could see the windows of this part of the house. There were four
-of them in a row, three of which were simply dirty, while the
-fourth was shuttered up. They were evidently all deserted. As I
-strolled up and down, glancing at them occasionally, Mr. Rucastle
-came out to me, looking as merry and jovial as ever.
-
-"'Ah!' said he, 'you must not think me rude if I passed you
-without a word, my dear young lady. I was preoccupied with
-business matters.'
-
-"I assured him that I was not offended. 'By the way,' said I,
-'you seem to have quite a suite of spare rooms up there, and one
-of them has the shutters up.'
-
-"He looked surprised and, as it seemed to me, a little startled
-at my remark.
-
-"'Photography is one of my hobbies,' said he. 'I have made my
-dark room up there. But, dear me! what an observant young lady we
-have come upon. Who would have believed it? Who would have ever
-believed it?' He spoke in a jesting tone, but there was no jest
-in his eyes as he looked at me. I read suspicion there and
-annoyance, but no jest.
-
-"Well, Mr. Holmes, from the moment that I understood that there
-was something about that suite of rooms which I was not to know,
-I was all on fire to go over them. It was not mere curiosity,
-though I have my share of that. It was more a feeling of duty--a
-feeling that some good might come from my penetrating to this
-place. They talk of woman's instinct; perhaps it was woman's
-instinct which gave me that feeling. At any rate, it was there,
-and I was keenly on the lookout for any chance to pass the
-forbidden door.
-
-"It was only yesterday that the chance came. I may tell you that,
-besides Mr. Rucastle, both Toller and his wife find something to
-do in these deserted rooms, and I once saw him carrying a large
-black linen bag with him through the door. Recently he has been
-drinking hard, and yesterday evening he was very drunk; and when
-I came upstairs there was the key in the door. I have no doubt at
-all that he had left it there. Mr. and Mrs. Rucastle were both
-downstairs, and the child was with them, so that I had an
-admirable opportunity. I turned the key gently in the lock,
-opened the door, and slipped through.
-
-"There was a little passage in front of me, unpapered and
-uncarpeted, which turned at a right angle at the farther end.
-Round this corner were three doors in a line, the first and third
-of which were open. They each led into an empty room, dusty and
-cheerless, with two windows in the one and one in the other, so
-thick with dirt that the evening light glimmered dimly through
-them. The centre door was closed, and across the outside of it
-had been fastened one of the broad bars of an iron bed, padlocked
-at one end to a ring in the wall, and fastened at the other with
-stout cord. The door itself was locked as well, and the key was
-not there. This barricaded door corresponded clearly with the
-shuttered window outside, and yet I could see by the glimmer from
-beneath it that the room was not in darkness. Evidently there was
-a skylight which let in light from above. As I stood in the
-passage gazing at the sinister door and wondering what secret it
-might veil, I suddenly heard the sound of steps within the room
-and saw a shadow pass backward and forward against the little
-slit of dim light which shone out from under the door. A mad,
-unreasoning terror rose up in me at the sight, Mr. Holmes. My
-overstrung nerves failed me suddenly, and I turned and ran--ran
-as though some dreadful hand were behind me clutching at the
-skirt of my dress. I rushed down the passage, through the door,
-and straight into the arms of Mr. Rucastle, who was waiting
-outside.
-
-"'So,' said he, smiling, 'it was you, then. I thought that it
-must be when I saw the door open.'
-
-"'Oh, I am so frightened!' I panted.
-
-"'My dear young lady! my dear young lady!'--you cannot think how
-caressing and soothing his manner was--'and what has frightened
-you, my dear young lady?'
-
-"But his voice was just a little too coaxing. He overdid it. I
-was keenly on my guard against him.
-
-"'I was foolish enough to go into the empty wing,' I answered.
-'But it is so lonely and eerie in this dim light that I was
-frightened and ran out again. Oh, it is so dreadfully still in
-there!'
-
-"'Only that?' said he, looking at me keenly.
-
-"'Why, what did you think?' I asked.
-
-"'Why do you think that I lock this door?'
-
-"'I am sure that I do not know.'
-
-"'It is to keep people out who have no business there. Do you
-see?' He was still smiling in the most amiable manner.
-
-"'I am sure if I had known--'
-
-"'Well, then, you know now. And if you ever put your foot over
-that threshold again'--here in an instant the smile hardened into
-a grin of rage, and he glared down at me with the face of a
-demon--'I'll throw you to the mastiff.'
-
-"I was so terrified that I do not know what I did. I suppose that
-I must have rushed past him into my room. I remember nothing
-until I found myself lying on my bed trembling all over. Then I
-thought of you, Mr. Holmes. I could not live there longer without
-some advice. I was frightened of the house, of the man, of the
-woman, of the servants, even of the child. They were all horrible
-to me. If I could only bring you down all would be well. Of
-course I might have fled from the house, but my curiosity was
-almost as strong as my fears. My mind was soon made up. I would
-send you a wire. I put on my hat and cloak, went down to the
-office, which is about half a mile from the house, and then
-returned, feeling very much easier. A horrible doubt came into my
-mind as I approached the door lest the dog might be loose, but I
-remembered that Toller had drunk himself into a state of
-insensibility that evening, and I knew that he was the only one
-in the household who had any influence with the savage creature,
-or who would venture to set him free. I slipped in in safety and
-lay awake half the night in my joy at the thought of seeing you.
-I had no difficulty in getting leave to come into Winchester this
-morning, but I must be back before three o'clock, for Mr. and
-Mrs. Rucastle are going on a visit, and will be away all the
-evening, so that I must look after the child. Now I have told you
-all my adventures, Mr. Holmes, and I should be very glad if you
-could tell me what it all means, and, above all, what I should
-do."
-
-Holmes and I had listened spellbound to this extraordinary story.
-My friend rose now and paced up and down the room, his hands in
-his pockets, and an expression of the most profound gravity upon
-his face.
-
-"Is Toller still drunk?" he asked.
-
-"Yes. I heard his wife tell Mrs. Rucastle that she could do
-nothing with him."
-
-"That is well. And the Rucastles go out to-night?"
-
-"Yes."
-
-"Is there a cellar with a good strong lock?"
-
-"Yes, the wine-cellar."
-
-"You seem to me to have acted all through this matter like a very
-brave and sensible girl, Miss Hunter. Do you think that you could
-perform one more feat? I should not ask it of you if I did not
-think you a quite exceptional woman."
-
-"I will try. What is it?"
-
-"We shall be at the Copper Beeches by seven o'clock, my friend
-and I. The Rucastles will be gone by that time, and Toller will,
-we hope, be incapable. There only remains Mrs. Toller, who might
-give the alarm. If you could send her into the cellar on some
-errand, and then turn the key upon her, you would facilitate
-matters immensely."
-
-"I will do it."
-
-"Excellent! We shall then look thoroughly into the affair. Of
-course there is only one feasible explanation. You have been
-brought there to personate someone, and the real person is
-imprisoned in this chamber. That is obvious. As to who this
-prisoner is, I have no doubt that it is the daughter, Miss Alice
-Rucastle, if I remember right, who was said to have gone to
-America. You were chosen, doubtless, as resembling her in height,
-figure, and the colour of your hair. Hers had been cut off, very
-possibly in some illness through which she has passed, and so, of
-course, yours had to be sacrificed also. By a curious chance you
-came upon her tresses. The man in the road was undoubtedly some
-friend of hers--possibly her fiancé--and no doubt, as you wore
-the girl's dress and were so like her, he was convinced from your
-laughter, whenever he saw you, and afterwards from your gesture,
-that Miss Rucastle was perfectly happy, and that she no longer
-desired his attentions. The dog is let loose at night to prevent
-him from endeavouring to communicate with her. So much is fairly
-clear. The most serious point in the case is the disposition of
-the child."
-
-"What on earth has that to do with it?" I ejaculated.
-
-"My dear Watson, you as a medical man are continually gaining
-light as to the tendencies of a child by the study of the
-parents. Don't you see that the converse is equally valid. I have
-frequently gained my first real insight into the character of
-parents by studying their children. This child's disposition is
-abnormally cruel, merely for cruelty's sake, and whether he
-derives this from his smiling father, as I should suspect, or
-from his mother, it bodes evil for the poor girl who is in their
-power."
-
-"I am sure that you are right, Mr. Holmes," cried our client. "A
-thousand things come back to me which make me certain that you
-have hit it. Oh, let us lose not an instant in bringing help to
-this poor creature."
-
-"We must be circumspect, for we are dealing with a very cunning
-man. We can do nothing until seven o'clock. At that hour we shall
-be with you, and it will not be long before we solve the
-mystery."
-
-We were as good as our word, for it was just seven when we
-reached the Copper Beeches, having put up our trap at a wayside
-public-house. The group of trees, with their dark leaves shining
-like burnished metal in the light of the setting sun, were
-sufficient to mark the house even had Miss Hunter not been
-standing smiling on the door-step.
-
-"Have you managed it?" asked Holmes.
-
-A loud thudding noise came from somewhere downstairs. "That is
-Mrs. Toller in the cellar," said she. "Her husband lies snoring
-on the kitchen rug. Here are his keys, which are the duplicates
-of Mr. Rucastle's."
-
-"You have done well indeed!" cried Holmes with enthusiasm. "Now
-lead the way, and we shall soon see the end of this black
-business."
-
-We passed up the stair, unlocked the door, followed on down a
-passage, and found ourselves in front of the barricade which Miss
-Hunter had described. Holmes cut the cord and removed the
-transverse bar. Then he tried the various keys in the lock, but
-without success. No sound came from within, and at the silence
-Holmes' face clouded over.
-
-"I trust that we are not too late," said he. "I think, Miss
-Hunter, that we had better go in without you. Now, Watson, put
-your shoulder to it, and we shall see whether we cannot make our
-way in."
-
-It was an old rickety door and gave at once before our united
-strength. Together we rushed into the room. It was empty. There
-was no furniture save a little pallet bed, a small table, and a
-basketful of linen. The skylight above was open, and the prisoner
-gone.
-
-"There has been some villainy here," said Holmes; "this beauty
-has guessed Miss Hunter's intentions and has carried his victim
-off."
-
-"But how?"
-
-"Through the skylight. We shall soon see how he managed it." He
-swung himself up onto the roof. "Ah, yes," he cried, "here's the
-end of a long light ladder against the eaves. That is how he did
-it."
-
-"But it is impossible," said Miss Hunter; "the ladder was not
-there when the Rucastles went away."
-
-"He has come back and done it. I tell you that he is a clever and
-dangerous man. I should not be very much surprised if this were
-he whose step I hear now upon the stair. I think, Watson, that it
-would be as well for you to have your pistol ready."
-
-The words were hardly out of his mouth before a man appeared at
-the door of the room, a very fat and burly man, with a heavy
-stick in his hand. Miss Hunter screamed and shrunk against the
-wall at the sight of him, but Sherlock Holmes sprang forward and
-confronted him.
-
-"You villain!" said he, "where's your daughter?"
-
-The fat man cast his eyes round, and then up at the open
-skylight.
-
-"It is for me to ask you that," he shrieked, "you thieves! Spies
-and thieves! I have caught you, have I? You are in my power. I'll
-serve you!" He turned and clattered down the stairs as hard as he
-could go.
-
-"He's gone for the dog!" cried Miss Hunter.
-
-"I have my revolver," said I.
-
-"Better close the front door," cried Holmes, and we all rushed
-down the stairs together. We had hardly reached the hall when we
-heard the baying of a hound, and then a scream of agony, with a
-horrible worrying sound which it was dreadful to listen to. An
-elderly man with a red face and shaking limbs came staggering out
-at a side door.
-
-"My God!" he cried. "Someone has loosed the dog. It's not been
-fed for two days. Quick, quick, or it'll be too late!"
-
-Holmes and I rushed out and round the angle of the house, with
-Toller hurrying behind us. There was the huge famished brute, its
-black muzzle buried in Rucastle's throat, while he writhed and
-screamed upon the ground. Running up, I blew its brains out, and
-it fell over with its keen white teeth still meeting in the great
-creases of his neck. With much labour we separated them and
-carried him, living but horribly mangled, into the house. We laid
-him upon the drawing-room sofa, and having dispatched the sobered
-Toller to bear the news to his wife, I did what I could to
-relieve his pain. We were all assembled round him when the door
-opened, and a tall, gaunt woman entered the room.
-
-"Mrs. Toller!" cried Miss Hunter.
-
-"Yes, miss. Mr. Rucastle let me out when he came back before he
-went up to you. Ah, miss, it is a pity you didn't let me know
-what you were planning, for I would have told you that your pains
-were wasted."
-
-"Ha!" said Holmes, looking keenly at her. "It is clear that Mrs.
-Toller knows more about this matter than anyone else."
-
-"Yes, sir, I do, and I am ready enough to tell what I know."
-
-"Then, pray, sit down, and let us hear it for there are several
-points on which I must confess that I am still in the dark."
-
-"I will soon make it clear to you," said she; "and I'd have done
-so before now if I could ha' got out from the cellar. If there's
-police-court business over this, you'll remember that I was the
-one that stood your friend, and that I was Miss Alice's friend
-too.
-
-"She was never happy at home, Miss Alice wasn't, from the time
-that her father married again. She was slighted like and had no
-say in anything, but it never really became bad for her until
-after she met Mr. Fowler at a friend's house. As well as I could
-learn, Miss Alice had rights of her own by will, but she was so
-quiet and patient, she was, that she never said a word about them
-but just left everything in Mr. Rucastle's hands. He knew he was
-safe with her; but when there was a chance of a husband coming
-forward, who would ask for all that the law would give him, then
-her father thought it time to put a stop on it. He wanted her to
-sign a paper, so that whether she married or not, he could use
-her money. When she wouldn't do it, he kept on worrying her until
-she got brain-fever, and for six weeks was at death's door. Then
-she got better at last, all worn to a shadow, and with her
-beautiful hair cut off; but that didn't make no change in her
-young man, and he stuck to her as true as man could be."
-
-"Ah," said Holmes, "I think that what you have been good enough
-to tell us makes the matter fairly clear, and that I can deduce
-all that remains. Mr. Rucastle then, I presume, took to this
-system of imprisonment?"
-
-"Yes, sir."
-
-"And brought Miss Hunter down from London in order to get rid of
-the disagreeable persistence of Mr. Fowler."
-
-"That was it, sir."
-
-"But Mr. Fowler being a persevering man, as a good seaman should
-be, blockaded the house, and having met you succeeded by certain
-arguments, metallic or otherwise, in convincing you that your
-interests were the same as his."
-
-"Mr. Fowler was a very kind-spoken, free-handed gentleman," said
-Mrs. Toller serenely.
-
-"And in this way he managed that your good man should have no
-want of drink, and that a ladder should be ready at the moment
-when your master had gone out."
-
-"You have it, sir, just as it happened."
-
-"I am sure we owe you an apology, Mrs. Toller," said Holmes, "for
-you have certainly cleared up everything which puzzled us. And
-here comes the country surgeon and Mrs. Rucastle, so I think,
-Watson, that we had best escort Miss Hunter back to Winchester,
-as it seems to me that our locus standi now is rather a
-questionable one."
-
-And thus was solved the mystery of the sinister house with the
-copper beeches in front of the door. Mr. Rucastle survived, but
-was always a broken man, kept alive solely through the care of
-his devoted wife. They still live with their old servants, who
-probably know so much of Rucastle's past life that he finds it
-difficult to part from them. Mr. Fowler and Miss Rucastle were
-married, by special license, in Southampton the day after their
-flight, and he is now the holder of a government appointment in
-the island of Mauritius. As to Miss Violet Hunter, my friend
-Holmes, rather to my disappointment, manifested no further
-interest in her when once she had ceased to be the centre of one
-of his problems, and she is now the head of a private school at
-Walsall, where I believe that she has met with considerable success.
-
-
-
-
-
-
-
-
-
-End of the Project Gutenberg EBook of The Adventures of Sherlock Holmes, by 
-Arthur Conan Doyle
-
-*** END OF THIS PROJECT GUTENBERG EBOOK THE ADVENTURES OF SHERLOCK HOLMES ***
-
-***** This file should be named 1661-8.txt or 1661-8.zip *****
-This and all associated files of various formats will be found in:
-        http://www.gutenberg.org/1/6/6/1661/
-
-Produced by an anonymous Project Gutenberg volunteer and Jose Menendez
-
-Updated editions will replace the previous one--the old editions
-will be renamed.
-
-Creating the works from public domain print editions means that no
-one owns a United States copyright in these works, so the Foundation
-(and you!) can copy and distribute it in the United States without
-permission and without paying copyright royalties.  Special rules,
-set forth in the General Terms of Use part of this license, apply to
-copying and distributing Project Gutenberg-tm electronic works to
-protect the PROJECT GUTENBERG-tm concept and trademark.  Project
-Gutenberg is a registered trademark, and may not be used if you
-charge for the eBooks, unless you receive specific permission.  If you
-do not charge anything for copies of this eBook, complying with the
-rules is very easy.  You may use this eBook for nearly any purpose
-such as creation of derivative works, reports, performances and
-research.  They may be modified and printed and given away--you may do
-practically ANYTHING with public domain eBooks.  Redistribution is
-subject to the trademark license, especially commercial
-redistribution.
-
-
-
-*** START: FULL LICENSE ***
-
-THE FULL PROJECT GUTENBERG LICENSE
-PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK
-
-To protect the Project Gutenberg-tm mission of promoting the free
-distribution of electronic works, by using or distributing this work
-(or any other work associated in any way with the phrase "Project
-Gutenberg"), you agree to comply with all the terms of the Full Project
-Gutenberg-tm License (available with this file or online at
-http://gutenberg.net/license).
-
-
-Section 1.  General Terms of Use and Redistributing Project Gutenberg-tm
-electronic works
-
-1.A.  By reading or using any part of this Project Gutenberg-tm
-electronic work, you indicate that you have read, understand, agree to
-and accept all the terms of this license and intellectual property
-(trademark/copyright) agreement.  If you do not agree to abide by all
-the terms of this agreement, you must cease using and return or destroy
-all copies of Project Gutenberg-tm electronic works in your possession.
-If you paid a fee for obtaining a copy of or access to a Project
-Gutenberg-tm electronic work and you do not agree to be bound by the
-terms of this agreement, you may obtain a refund from the person or
-entity to whom you paid the fee as set forth in paragraph 1.E.8.
-
-1.B.  "Project Gutenberg" is a registered trademark.  It may only be
-used on or associated in any way with an electronic work by people who
-agree to be bound by the terms of this agreement.  There are a few
-things that you can do with most Project Gutenberg-tm electronic works
-even without complying with the full terms of this agreement.  See
-paragraph 1.C below.  There are a lot of things you can do with Project
-Gutenberg-tm electronic works if you follow the terms of this agreement
-and help preserve free future access to Project Gutenberg-tm electronic
-works.  See paragraph 1.E below.
-
-1.C.  The Project Gutenberg Literary Archive Foundation ("the Foundation"
-or PGLAF), owns a compilation copyright in the collection of Project
-Gutenberg-tm electronic works.  Nearly all the individual works in the
-collection are in the public domain in the United States.  If an
-individual work is in the public domain in the United States and you are
-located in the United States, we do not claim a right to prevent you from
-copying, distributing, performing, displaying or creating derivative
-works based on the work as long as all references to Project Gutenberg
-are removed.  Of course, we hope that you will support the Project
-Gutenberg-tm mission of promoting free access to electronic works by
-freely sharing Project Gutenberg-tm works in compliance with the terms of
-this agreement for keeping the Project Gutenberg-tm name associated with
-the work.  You can easily comply with the terms of this agreement by
-keeping this work in the same format with its attached full Project
-Gutenberg-tm License when you share it without charge with others.
-
-1.D.  The copyright laws of the place where you are located also govern
-what you can do with this work.  Copyright laws in most countries are in
-a constant state of change.  If you are outside the United States, check
-the laws of your country in addition to the terms of this agreement
-before downloading, copying, displaying, performing, distributing or
-creating derivative works based on this work or any other Project
-Gutenberg-tm work.  The Foundation makes no representations concerning
-the copyright status of any work in any country outside the United
-States.
-
-1.E.  Unless you have removed all references to Project Gutenberg:
-
-1.E.1.  The following sentence, with active links to, or other immediate
-access to, the full Project Gutenberg-tm License must appear prominently
-whenever any copy of a Project Gutenberg-tm work (any work on which the
-phrase "Project Gutenberg" appears, or with which the phrase "Project
-Gutenberg" is associated) is accessed, displayed, performed, viewed,
-copied or distributed:
-
-This eBook is for the use of anyone anywhere at no cost and with
-almost no restrictions whatsoever.  You may copy it, give it away or
-re-use it under the terms of the Project Gutenberg License included
-with this eBook or online at www.gutenberg.net
-
-1.E.2.  If an individual Project Gutenberg-tm electronic work is derived
-from the public domain (does not contain a notice indicating that it is
-posted with permission of the copyright holder), the work can be copied
-and distributed to anyone in the United States without paying any fees
-or charges.  If you are redistributing or providing access to a work
-with the phrase "Project Gutenberg" associated with or appearing on the
-work, you must comply either with the requirements of paragraphs 1.E.1
-through 1.E.7 or obtain permission for the use of the work and the
-Project Gutenberg-tm trademark as set forth in paragraphs 1.E.8 or
-1.E.9.
-
-1.E.3.  If an individual Project Gutenberg-tm electronic work is posted
-with the permission of the copyright holder, your use and distribution
-must comply with both paragraphs 1.E.1 through 1.E.7 and any additional
-terms imposed by the copyright holder.  Additional terms will be linked
-to the Project Gutenberg-tm License for all works posted with the
-permission of the copyright holder found at the beginning of this work.
-
-1.E.4.  Do not unlink or detach or remove the full Project Gutenberg-tm
-License terms from this work, or any files containing a part of this
-work or any other work associated with Project Gutenberg-tm.
-
-1.E.5.  Do not copy, display, perform, distribute or redistribute this
-electronic work, or any part of this electronic work, without
-prominently displaying the sentence set forth in paragraph 1.E.1 with
-active links or immediate access to the full terms of the Project
-Gutenberg-tm License.
-
-1.E.6.  You may convert to and distribute this work in any binary,
-compressed, marked up, nonproprietary or proprietary form, including any
-word processing or hypertext form.  However, if you provide access to or
-distribute copies of a Project Gutenberg-tm work in a format other than
-"Plain Vanilla ASCII" or other format used in the official version
-posted on the official Project Gutenberg-tm web site (www.gutenberg.net),
-you must, at no additional cost, fee or expense to the user, provide a
-copy, a means of exporting a copy, or a means of obtaining a copy upon
-request, of the work in its original "Plain Vanilla ASCII" or other
-form.  Any alternate format must include the full Project Gutenberg-tm
-License as specified in paragraph 1.E.1.
-
-1.E.7.  Do not charge a fee for access to, viewing, displaying,
-performing, copying or distributing any Project Gutenberg-tm works
-unless you comply with paragraph 1.E.8 or 1.E.9.
-
-1.E.8.  You may charge a reasonable fee for copies of or providing
-access to or distributing Project Gutenberg-tm electronic works provided
-that
-
-- You pay a royalty fee of 20% of the gross profits you derive from
-     the use of Project Gutenberg-tm works calculated using the method
-     you already use to calculate your applicable taxes.  The fee is
-     owed to the owner of the Project Gutenberg-tm trademark, but he
-     has agreed to donate royalties under this paragraph to the
-     Project Gutenberg Literary Archive Foundation.  Royalty payments
-     must be paid within 60 days following each date on which you
-     prepare (or are legally required to prepare) your periodic tax
-     returns.  Royalty payments should be clearly marked as such and
-     sent to the Project Gutenberg Literary Archive Foundation at the
-     address specified in Section 4, "Information about donations to
-     the Project Gutenberg Literary Archive Foundation."
-
-- You provide a full refund of any money paid by a user who notifies
-     you in writing (or by e-mail) within 30 days of receipt that s/he
-     does not agree to the terms of the full Project Gutenberg-tm
-     License.  You must require such a user to return or
-     destroy all copies of the works possessed in a physical medium
-     and discontinue all use of and all access to other copies of
-     Project Gutenberg-tm works.
-
-- You provide, in accordance with paragraph 1.F.3, a full refund of any
-     money paid for a work or a replacement copy, if a defect in the
-     electronic work is discovered and reported to you within 90 days
-     of receipt of the work.
-
-- You comply with all other terms of this agreement for free
-     distribution of Project Gutenberg-tm works.
-
-1.E.9.  If you wish to charge a fee or distribute a Project Gutenberg-tm
-electronic work or group of works on different terms than are set
-forth in this agreement, you must obtain permission in writing from
-both the Project Gutenberg Literary Archive Foundation and Michael
-Hart, the owner of the Project Gutenberg-tm trademark.  Contact the
-Foundation as set forth in Section 3 below.
-
-1.F.
-
-1.F.1.  Project Gutenberg volunteers and employees expend considerable
-effort to identify, do copyright research on, transcribe and proofread
-public domain works in creating the Project Gutenberg-tm
-collection.  Despite these efforts, Project Gutenberg-tm electronic
-works, and the medium on which they may be stored, may contain
-"Defects," such as, but not limited to, incomplete, inaccurate or
-corrupt data, transcription errors, a copyright or other intellectual
-property infringement, a defective or damaged disk or other medium, a
-computer virus, or computer codes that damage or cannot be read by
-your equipment.
-
-1.F.2.  LIMITED WARRANTY, DISCLAIMER OF DAMAGES - Except for the "Right
-of Replacement or Refund" described in paragraph 1.F.3, the Project
-Gutenberg Literary Archive Foundation, the owner of the Project
-Gutenberg-tm trademark, and any other party distributing a Project
-Gutenberg-tm electronic work under this agreement, disclaim all
-liability to you for damages, costs and expenses, including legal
-fees.  YOU AGREE THAT YOU HAVE NO REMEDIES FOR NEGLIGENCE, STRICT
-LIABILITY, BREACH OF WARRANTY OR BREACH OF CONTRACT EXCEPT THOSE
-PROVIDED IN PARAGRAPH 1.F.3.  YOU AGREE THAT THE FOUNDATION, THE
-TRADEMARK OWNER, AND ANY DISTRIBUTOR UNDER THIS AGREEMENT WILL NOT BE
-LIABLE TO YOU FOR ACTUAL, DIRECT, INDIRECT, CONSEQUENTIAL, PUNITIVE OR
-INCIDENTAL DAMAGES EVEN IF YOU GIVE NOTICE OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-1.F.3.  LIMITED RIGHT OF REPLACEMENT OR REFUND - If you discover a
-defect in this electronic work within 90 days of receiving it, you can
-receive a refund of the money (if any) you paid for it by sending a
-written explanation to the person you received the work from.  If you
-received the work on a physical medium, you must return the medium with
-your written explanation.  The person or entity that provided you with
-the defective work may elect to provide a replacement copy in lieu of a
-refund.  If you received the work electronically, the person or entity
-providing it to you may choose to give you a second opportunity to
-receive the work electronically in lieu of a refund.  If the second copy
-is also defective, you may demand a refund in writing without further
-opportunities to fix the problem.
-
-1.F.4.  Except for the limited right of replacement or refund set forth
-in paragraph 1.F.3, this work is provided to you 'AS-IS' WITH NO OTHER
-WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-WARRANTIES OF MERCHANTIBILITY OR FITNESS FOR ANY PURPOSE.
-
-1.F.5.  Some states do not allow disclaimers of certain implied
-warranties or the exclusion or limitation of certain types of damages.
-If any disclaimer or limitation set forth in this agreement violates the
-law of the state applicable to this agreement, the agreement shall be
-interpreted to make the maximum disclaimer or limitation permitted by
-the applicable state law.  The invalidity or unenforceability of any
-provision of this agreement shall not void the remaining provisions.
-
-1.F.6.  INDEMNITY - You agree to indemnify and hold the Foundation, the
-trademark owner, any agent or employee of the Foundation, anyone
-providing copies of Project Gutenberg-tm electronic works in accordance
-with this agreement, and any volunteers associated with the production,
-promotion and distribution of Project Gutenberg-tm electronic works,
-harmless from all liability, costs and expenses, including legal fees,
-that arise directly or indirectly from any of the following which you do
-or cause to occur: (a) distribution of this or any Project Gutenberg-tm
-work, (b) alteration, modification, or additions or deletions to any
-Project Gutenberg-tm work, and (c) any Defect you cause.
-
-
-Section  2.  Information about the Mission of Project Gutenberg-tm
-
-Project Gutenberg-tm is synonymous with the free distribution of
-electronic works in formats readable by the widest variety of computers
-including obsolete, old, middle-aged and new computers.  It exists
-because of the efforts of hundreds of volunteers and donations from
-people in all walks of life.
-
-Volunteers and financial support to provide volunteers with the
-assistance they need are critical to reaching Project Gutenberg-tm's
-goals and ensuring that the Project Gutenberg-tm collection will
-remain freely available for generations to come.  In 2001, the Project
-Gutenberg Literary Archive Foundation was created to provide a secure
-and permanent future for Project Gutenberg-tm and future generations.
-To learn more about the Project Gutenberg Literary Archive Foundation
-and how your efforts and donations can help, see Sections 3 and 4
-and the Foundation web page at http://www.pglaf.org.
-
-
-Section 3.  Information about the Project Gutenberg Literary Archive
-Foundation
-
-The Project Gutenberg Literary Archive Foundation is a non profit
-501(c)(3) educational corporation organized under the laws of the
-state of Mississippi and granted tax exempt status by the Internal
-Revenue Service.  The Foundation's EIN or federal tax identification
-number is 64-6221541.  Its 501(c)(3) letter is posted at
-http://pglaf.org/fundraising.  Contributions to the Project Gutenberg
-Literary Archive Foundation are tax deductible to the full extent
-permitted by U.S. federal laws and your state's laws.
-
-The Foundation's principal office is located at 4557 Melan Dr. S.
-Fairbanks, AK, 99712., but its volunteers and employees are scattered
-throughout numerous locations.  Its business office is located at
-809 North 1500 West, Salt Lake City, UT 84116, (801) 596-1887, email
-business@pglaf.org.  Email contact links and up to date contact
-information can be found at the Foundation's web site and official
-page at http://pglaf.org
-
-For additional contact information:
-     Dr. Gregory B. Newby
-     Chief Executive and Director
-     gbnewby@pglaf.org
-
-
-Section 4.  Information about Donations to the Project Gutenberg
-Literary Archive Foundation
-
-Project Gutenberg-tm depends upon and cannot survive without wide
-spread public support and donations to carry out its mission of
-increasing the number of public domain and licensed works that can be
-freely distributed in machine readable form accessible by the widest
-array of equipment including outdated equipment.  Many small donations
-($1 to $5,000) are particularly important to maintaining tax exempt
-status with the IRS.
-
-The Foundation is committed to complying with the laws regulating
-charities and charitable donations in all 50 states of the United
-States.  Compliance requirements are not uniform and it takes a
-considerable effort, much paperwork and many fees to meet and keep up
-with these requirements.  We do not solicit donations in locations
-where we have not received written confirmation of compliance.  To
-SEND DONATIONS or determine the status of compliance for any
-particular state visit http://pglaf.org
-
-While we cannot and do not solicit contributions from states where we
-have not met the solicitation requirements, we know of no prohibition
-against accepting unsolicited donations from donors in such states who
-approach us with offers to donate.
-
-International donations are gratefully accepted, but we cannot make
-any statements concerning tax treatment of donations received from
-outside the United States.  U.S. laws alone swamp our small staff.
-
-Please check the Project Gutenberg Web pages for current donation
-methods and addresses.  Donations are accepted in a number of other
-ways including including checks, online payments and credit card
-donations.  To donate, please visit: http://pglaf.org/donate
-
-
-Section 5.  General Information About Project Gutenberg-tm electronic
-works.
-
-Professor Michael S. Hart is the originator of the Project Gutenberg-tm
-concept of a library of electronic works that could be freely shared
-with anyone.  For thirty years, he produced and distributed Project
-Gutenberg-tm eBooks with only a loose network of volunteer support.
-
-
-Project Gutenberg-tm eBooks are often created from several printed
-editions, all of which are confirmed as Public Domain in the U.S.
-unless a copyright notice is included.  Thus, we do not necessarily
-keep eBooks in compliance with any particular paper edition.
-
-
-Most people start at our Web site which has the main PG search facility:
-
-     http://www.gutenberg.net
-
-This Web site includes information about Project Gutenberg-tm,
-including how to make donations to the Project Gutenberg Literary
-Archive Foundation, how to help produce our new eBooks, and how to
-subscribe to our email newsletter to hear about new eBooks.
diff --git a/bench/src/ffi/mod.rs b/bench/src/ffi/mod.rs
deleted file mode 100644
index 347a0e1154..0000000000
--- a/bench/src/ffi/mod.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// We don't always use all of the method available to each regex engine because
-// of conditional compilation and such.
-#![allow(dead_code)]
-
-#[cfg(feature = "re-onig")]
-pub mod onig;
-#[cfg(feature = "re-pcre1")]
-pub mod pcre1;
-#[cfg(feature = "re-pcre2")]
-pub mod pcre2;
-#[cfg(feature = "re-re2")]
-pub mod re2;
-#[cfg(feature = "re-tcl")]
-pub mod tcl;
diff --git a/bench/src/ffi/onig.rs b/bench/src/ffi/onig.rs
deleted file mode 100644
index 24a18105d5..0000000000
--- a/bench/src/ffi/onig.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use onig;
-
-pub struct Regex(onig::Regex);
-
-unsafe impl Send for Regex {}
-
-impl Regex {
-    pub fn new(pattern: &str) -> Result<Self, onig::Error> {
-        onig::Regex::new(pattern).map(Regex)
-    }
-
-    pub fn is_match(&self, text: &str) -> bool {
-        // Gah. onig's is_match function is anchored, but find is not.
-        self.0
-            .search_with_options(
-                text,
-                0,
-                text.len(),
-                onig::SearchOptions::SEARCH_OPTION_NONE,
-                None,
-            )
-            .is_some()
-    }
-
-    pub fn find_iter<'r, 't>(
-        &'r self,
-        text: &'t str,
-    ) -> onig::FindMatches<'r, 't> {
-        self.0.find_iter(text)
-    }
-}
diff --git a/bench/src/ffi/pcre1.rs b/bench/src/ffi/pcre1.rs
deleted file mode 100644
index b65ab4bc37..0000000000
--- a/bench/src/ffi/pcre1.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-#![allow(non_snake_case)]
-
-use std::ffi::{CStr, CString};
-use std::fmt;
-use std::ptr;
-
-use libc::{c_char, c_int, c_void};
-use libpcre_sys::{
-    pcre, pcre_compile, pcre_exec, pcre_extra, pcre_free, pcre_free_study,
-    pcre_study, PCRE_ERROR_NOMATCH, PCRE_NO_UTF8_CHECK, PCRE_UTF8,
-};
-
-const PCRE_UCP: c_int = 0x20000000;
-const PCRE_STUDY_JIT_COMPLETE: c_int = 0x0001;
-
-// We use libpcre-sys directly because the pcre crate has unavoidable
-// performance problems in its core matching routines. (e.g., It always
-// allocates an ovector.)
-pub struct Regex {
-    code: *mut pcre,
-    extra: *mut pcre_extra,
-}
-
-unsafe impl Send for Regex {}
-
-impl Drop for Regex {
-    fn drop(&mut self) {
-        unsafe {
-            pcre_free_study(self.extra);
-            pcre_free(self.code as *mut c_void);
-        }
-    }
-}
-
-pub struct Error {
-    msg: String,
-    offset: c_int,
-}
-
-impl Regex {
-    pub fn new(pattern: &str) -> Result<Regex, Error> {
-        let pattern = CString::new(pattern.to_owned()).unwrap();
-        let mut errptr: *const c_char = ptr::null();
-        let mut erroffset: c_int = 0;
-        let code = unsafe {
-            pcre_compile(
-                pattern.as_ptr(),
-                PCRE_UCP | PCRE_UTF8,
-                &mut errptr,
-                &mut erroffset,
-                ptr::null(),
-            )
-        };
-        if code.is_null() {
-            let msg =
-                unsafe { CStr::from_ptr(errptr).to_str().unwrap().to_owned() };
-            return Err(Error { msg: msg, offset: erroffset });
-        }
-
-        let extra =
-            unsafe { pcre_study(code, PCRE_STUDY_JIT_COMPLETE, &mut errptr) };
-        if extra.is_null() {
-            if errptr.is_null() {
-                panic!("unexpected error. Maybe JIT support isn't enabled?");
-            }
-            let msg =
-                unsafe { CStr::from_ptr(errptr).to_str().unwrap().to_owned() };
-            return Err(Error { msg: msg, offset: 0 });
-        }
-        Ok(Regex { code: code, extra: extra })
-    }
-
-    pub fn is_match(&self, text: &str) -> bool {
-        self.find_at(text, 0).is_some()
-    }
-
-    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> {
-        FindMatches { re: self, text: text, last_match_end: 0 }
-    }
-
-    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
-        const OVEC_SIZE: usize = 15 * 3; // hopefully enough for benchmarks?
-        let mut ovec: [c_int; OVEC_SIZE] = [0; OVEC_SIZE];
-        let err = unsafe {
-            pcre_exec(
-                self.code,
-                self.extra,
-                text.as_ptr() as *const i8,
-                text.len() as c_int,
-                start as c_int,
-                PCRE_NO_UTF8_CHECK,
-                ovec.as_mut_ptr(),
-                OVEC_SIZE as c_int,
-            )
-        };
-        if err == PCRE_ERROR_NOMATCH {
-            None
-        } else if err < 0 {
-            panic!("unknown error code: {:?}", err)
-        } else {
-            Some((ovec[0] as usize, ovec[1] as usize))
-        }
-    }
-}
-
-pub struct FindMatches<'r, 't> {
-    re: &'r Regex,
-    text: &'t str,
-    last_match_end: usize,
-}
-
-impl<'r, 't> Iterator for FindMatches<'r, 't> {
-    type Item = (usize, usize);
-
-    fn next(&mut self) -> Option<(usize, usize)> {
-        match self.re.find_at(self.text, self.last_match_end) {
-            None => None,
-            Some((s, e)) => {
-                self.last_match_end = e;
-                Some((s, e))
-            }
-        }
-    }
-}
-
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "PCRE error at {:?}: {}", self.offset, self.msg)
-    }
-}
diff --git a/bench/src/ffi/pcre2.rs b/bench/src/ffi/pcre2.rs
deleted file mode 100644
index 6fc5f6de0b..0000000000
--- a/bench/src/ffi/pcre2.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-#![allow(non_camel_case_types)]
-
-use std::fmt;
-use std::ptr;
-use std::str;
-
-use libc::{c_int, c_void, size_t};
-
-pub struct Regex {
-    code: *mut code,
-    match_data: *mut match_data,
-    ovector: *mut size_t,
-}
-
-unsafe impl Send for Regex {}
-
-impl Drop for Regex {
-    fn drop(&mut self) {
-        unsafe {
-            pcre2_match_data_free_8(self.match_data);
-            pcre2_code_free_8(self.code);
-        }
-    }
-}
-
-pub struct Error {
-    code: c_int,
-    offset: size_t,
-}
-
-impl Regex {
-    pub fn new(pattern: &str) -> Result<Regex, Error> {
-        let mut error_code: c_int = 0;
-        let mut error_offset: size_t = 0;
-        let code = unsafe {
-            pcre2_compile_8(
-                pattern.as_ptr(),
-                pattern.len(),
-                // PCRE2 can get significantly faster in some cases depending
-                // on the permutation of these options (in particular, dropping
-                // UCP). We should endeavor to have a separate "ASCII compatible"
-                // benchmark.
-                PCRE2_UCP | PCRE2_UTF,
-                &mut error_code,
-                &mut error_offset,
-                ptr::null_mut(),
-            )
-        };
-        if code.is_null() {
-            return Err(Error { code: error_code, offset: error_offset });
-        }
-        let err = unsafe { pcre2_jit_compile_8(code, PCRE2_JIT_COMPLETE) };
-        if err < 0 {
-            panic!("pcre2_jit_compile_8 failed with error: {:?}", err);
-        }
-        let match_data = unsafe {
-            pcre2_match_data_create_from_pattern_8(code, ptr::null_mut())
-        };
-        if match_data.is_null() {
-            panic!("could not allocate match_data");
-        }
-        let ovector = unsafe { pcre2_get_ovector_pointer_8(match_data) };
-        if ovector.is_null() {
-            panic!("could not get ovector");
-        }
-        Ok(Regex { code: code, match_data: match_data, ovector: ovector })
-    }
-
-    pub fn is_match(&self, text: &str) -> bool {
-        self.find_at(text, 0).is_some()
-    }
-
-    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> {
-        FindMatches { re: self, text: text, last_match_end: 0 }
-    }
-
-    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
-        // The man pages for PCRE2 say that pcre2_jit_match is the fastest
-        // way to execute a JIT match because it skips sanity checks. We also
-        // explicitly disable the UTF-8 validity check, but it's probably not
-        // necessary.
-        let err = unsafe {
-            pcre2_jit_match_8(
-                self.code,
-                text.as_ptr(),
-                text.len(),
-                start,
-                PCRE2_NO_UTF_CHECK,
-                self.match_data,
-                ptr::null_mut(),
-            )
-        };
-        if err == PCRE2_ERROR_NOMATCH {
-            None
-        } else if err < 0 {
-            panic!("unknown error code: {:?}", err)
-        } else {
-            Some(unsafe { (*self.ovector, *self.ovector.offset(1)) })
-        }
-    }
-}
-
-pub struct FindMatches<'r, 't> {
-    re: &'r Regex,
-    text: &'t str,
-    last_match_end: usize,
-}
-
-impl<'r, 't> Iterator for FindMatches<'r, 't> {
-    type Item = (usize, usize);
-
-    fn next(&mut self) -> Option<(usize, usize)> {
-        match self.re.find_at(self.text, self.last_match_end) {
-            None => None,
-            Some((s, e)) => {
-                self.last_match_end = e;
-                Some((s, e))
-            }
-        }
-    }
-}
-
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const BUF_LEN: size_t = 256;
-        let mut buf = [0; BUF_LEN];
-        let len = unsafe {
-            pcre2_get_error_message_8(self.code, buf.as_mut_ptr(), BUF_LEN)
-        };
-        if len < 0 {
-            write!(
-                f,
-                "Unknown PCRE error. (code: {:?}, offset: {:?})",
-                self.code, self.offset
-            )
-        } else {
-            let msg = str::from_utf8(&buf[..len as usize]).unwrap();
-            write!(f, "error at {:?}: {}", self.offset, msg)
-        }
-    }
-}
-
-// PCRE2 FFI. We only wrap the bits we need.
-
-const PCRE2_UCP: u32 = 0x00020000;
-const PCRE2_UTF: u32 = 0x00080000;
-const PCRE2_NO_UTF_CHECK: u32 = 0x40000000;
-const PCRE2_JIT_COMPLETE: u32 = 0x00000001;
-const PCRE2_ERROR_NOMATCH: c_int = -1;
-
-type code = c_void;
-
-type match_data = c_void;
-
-type compile_context = c_void; // unused
-
-type general_context = c_void; // unused
-
-type match_context = c_void; // unused
-
-extern "C" {
-    fn pcre2_compile_8(
-        pattern: *const u8,
-        len: size_t,
-        options: u32,
-        error_code: *mut c_int,
-        error_offset: *mut size_t,
-        context: *mut compile_context,
-    ) -> *mut code;
-
-    fn pcre2_code_free_8(code: *mut code);
-
-    fn pcre2_match_data_create_from_pattern_8(
-        code: *const code,
-        context: *mut general_context,
-    ) -> *mut match_data;
-
-    fn pcre2_match_data_free_8(match_data: *mut match_data);
-
-    fn pcre2_get_ovector_pointer_8(match_data: *mut match_data)
-        -> *mut size_t;
-
-    fn pcre2_jit_compile_8(code: *const code, options: u32) -> c_int;
-
-    fn pcre2_jit_match_8(
-        code: *const code,
-        subject: *const u8,
-        length: size_t,
-        startoffset: size_t,
-        options: u32,
-        match_data: *mut match_data,
-        match_context: *mut match_context,
-    ) -> c_int;
-
-    fn pcre2_get_error_message_8(
-        error_code: c_int,
-        buf: *mut u8,
-        buflen: size_t,
-    ) -> c_int;
-}
diff --git a/bench/src/ffi/re2.cpp b/bench/src/ffi/re2.cpp
deleted file mode 100644
index 2d7109d1a9..0000000000
--- a/bench/src/ffi/re2.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <iostream>
-#include <stdio.h>
-
-#include "re2/re2.h"
-
-using namespace re2;
-
-extern "C" {
-    typedef void re2_regexp;
-
-    typedef struct re2_string {
-        const char *text;
-        int len;
-    } re2_string;
-
-    re2_regexp* re2_regexp_new(re2_string pat) {
-        re2::StringPiece re2_pat(pat.text, pat.len);
-        return reinterpret_cast<re2_regexp*>(new RE2(re2_pat));
-    }
-
-    void re2_regexp_free(re2_regexp *re) {
-        delete reinterpret_cast<RE2*>(re);
-    }
-
-    bool re2_regexp_match(re2_regexp *re, re2_string text,
-                          int startpos, int endpos) {
-        RE2 *cpp_re = reinterpret_cast<RE2*>(re);
-        re2::StringPiece cpp_text(text.text, text.len);
-
-        return cpp_re->Match(cpp_text, startpos, endpos, RE2::UNANCHORED,
-                             NULL, 0);
-    }
-
-    bool re2_regexp_find(re2_regexp *re, re2_string text,
-                         int startpos, int endpos,
-                         int *match_start, int *match_end) {
-        RE2 *cpp_re = reinterpret_cast<RE2*>(re);
-        re2::StringPiece cpp_text(text.text, text.len);
-        re2::StringPiece result;
-        bool matched;
-
-        matched = cpp_re->Match(cpp_text, startpos, endpos, RE2::UNANCHORED,
-                                &result, 1);
-        if (matched) {
-            *match_start = result.data() - cpp_text.data();
-            *match_end = *match_start + result.length();
-        }
-        return matched;
-    }
-}
diff --git a/bench/src/ffi/re2.rs b/bench/src/ffi/re2.rs
deleted file mode 100644
index 6886656346..0000000000
--- a/bench/src/ffi/re2.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-#![allow(non_camel_case_types)]
-
-use libc::{c_int, c_uchar, c_void};
-
-/// Regex wraps an RE2 regular expression.
-///
-/// It cannot be used safely from multiple threads simultaneously.
-pub struct Regex {
-    re: *mut re2_regexp,
-}
-
-unsafe impl Send for Regex {}
-
-impl Drop for Regex {
-    fn drop(&mut self) {
-        unsafe {
-            re2_regexp_free(self.re);
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Error(());
-
-impl Regex {
-    pub fn new(pattern: &str) -> Result<Regex, Error> {
-        unsafe { Ok(Regex { re: re2_regexp_new(pattern.into()) }) }
-    }
-
-    pub fn is_match(&self, text: &str) -> bool {
-        unsafe {
-            re2_regexp_match(self.re, text.into(), 0, text.len() as c_int)
-        }
-    }
-
-    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> {
-        FindMatches { re: self, text: text, last_end: 0, last_match: None }
-    }
-
-    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
-        let (mut s, mut e): (c_int, c_int) = (0, 0);
-        let matched = unsafe {
-            re2_regexp_find(
-                self.re,
-                text.into(),
-                start as c_int,
-                text.len() as c_int,
-                &mut s,
-                &mut e,
-            )
-        };
-        if matched {
-            Some((s as usize, e as usize))
-        } else {
-            None
-        }
-    }
-}
-
-pub struct FindMatches<'r, 't> {
-    re: &'r Regex,
-    text: &'t str,
-    last_end: usize,
-    last_match: Option<usize>,
-}
-
-// This implementation is identical to the one Rust uses, since both Rust's
-// regex engine and RE2 handle empty matches in the same way.
-impl<'r, 't> Iterator for FindMatches<'r, 't> {
-    type Item = (usize, usize);
-
-    fn next(&mut self) -> Option<(usize, usize)> {
-        fn next_after_empty(text: &str, i: usize) -> usize {
-            let b = match text.as_bytes().get(i) {
-                None => return text.len() + 1,
-                Some(&b) => b,
-            };
-            let inc = if b <= 0x7F {
-                1
-            } else if b <= 0b110_11111 {
-                2
-            } else if b <= 0b1110_1111 {
-                3
-            } else {
-                4
-            };
-            i + inc
-        }
-
-        if self.last_end > self.text.len() {
-            return None;
-        }
-        let (s, e) = match self.re.find_at(self.text, self.last_end) {
-            None => return None,
-            Some((s, e)) => (s, e),
-        };
-        assert!(s >= self.last_end);
-        if s == e {
-            // This is an empty match. To ensure we make progress, start
-            // the next search at the smallest possible starting position
-            // of the next match following this one.
-            self.last_end = next_after_empty(&self.text, e);
-            // Don't accept empty matches immediately following a match.
-            // Just move on to the next match.
-            if Some(e) == self.last_match {
-                return self.next();
-            }
-        } else {
-            self.last_end = e;
-        }
-        self.last_match = Some(self.last_end);
-        Some((s, e))
-    }
-}
-
-// RE2 FFI is below. Note that this uses a hand-rolled C API that is defined
-// in re2.cpp.
-
-type re2_regexp = c_void;
-
-#[repr(C)]
-struct re2_string {
-    text: *const c_uchar,
-    len: c_int,
-}
-
-impl<'a> From<&'a str> for re2_string {
-    fn from(s: &'a str) -> re2_string {
-        re2_string { text: s.as_ptr(), len: s.len() as c_int }
-    }
-}
-
-extern "C" {
-    fn re2_regexp_new(pat: re2_string) -> *mut re2_regexp;
-    fn re2_regexp_free(re: *mut re2_regexp);
-    fn re2_regexp_match(
-        re: *mut re2_regexp,
-        text: re2_string,
-        startpos: c_int,
-        endpos: c_int,
-    ) -> bool;
-    fn re2_regexp_find(
-        re: *mut re2_regexp,
-        text: re2_string,
-        startpos: c_int,
-        endpos: c_int,
-        match_start: *mut c_int,
-        match_end: *mut c_int,
-    ) -> bool;
-}
diff --git a/bench/src/ffi/tcl.rs b/bench/src/ffi/tcl.rs
deleted file mode 100644
index 0c5c52e190..0000000000
--- a/bench/src/ffi/tcl.rs
+++ /dev/null
@@ -1,213 +0,0 @@
-#![allow(non_camel_case_types)]
-
-use std::mem;
-use std::ptr;
-use std::sync::Once;
-
-use libc::{c_char, c_int, c_long, c_void};
-
-// Used to initialize the TCL interpreter exactly once.
-static ONCE: Once = Once::new();
-
-/// Text is a TCL string object backed by a Rust string.
-///
-/// This is a special type that is created once per benchmark and is not
-/// included in timings. In particular, all regex searches execute on values
-/// of this type, so we're careful to avoid the overhead of creating such
-/// objects on every search.
-pub struct Text {
-    s: String,
-    obj: *mut tcl_obj,
-}
-
-// TCL's objects are ref-counted in a thread-unsafe manner, which would
-// normally disqualify a Send bound. However, we don't permit Text to be used
-// in a way that can lead to unsafety. In particular, the ref count is always
-// 1, until it is dropped, in which the ref count is decreased to zero and
-// the underlying memory is freed.
-unsafe impl Send for Text {}
-
-impl Drop for Text {
-    fn drop(&mut self) {
-        unsafe {
-            assert_eq!((*self.obj).ref_count, 1);
-            // This will drop the ref count to 0 and cause it to be freed.
-            (*self.obj).decr_ref_count();
-        }
-    }
-}
-
-impl Text {
-    pub fn new(text: String) -> Text {
-        let ptr = text.as_ptr() as *const c_char;
-        let len = text.len() as c_int;
-        let obj = unsafe { Tcl_NewStringObj(ptr, len) };
-        unsafe {
-            (*obj).incr_ref_count();
-        }
-        Text { s: text, obj: obj }
-    }
-
-    pub fn len(&self) -> usize {
-        self.s.len()
-    }
-}
-
-/// Regex wraps a TCL regex. It owns a TCL string object and a pointer to a
-/// regexp object. The two share storage.
-///
-/// There's no Drop impl for Regex because the memory for the regex will be
-/// freed when `pat` is dropped.
-pub struct Regex {
-    pat: Text,
-    re: *mut tcl_regexp,
-}
-
-unsafe impl Send for Regex {}
-
-#[derive(Debug)]
-pub struct Error(());
-
-impl Regex {
-    pub fn new(pattern: &str) -> Result<Regex, Error> {
-        ONCE.call_once(|| unsafe {
-            Tcl_CreateInterp();
-        });
-
-        let pat = Text::new(pattern.to_owned());
-        let re = unsafe {
-            Tcl_GetRegExpFromObj(ptr::null_mut(), pat.obj, TCL_REG_ADVANCED)
-        };
-        if re.is_null() {
-            return Err(Error(()));
-        }
-        Ok(Regex { pat: pat, re: re })
-    }
-
-    pub fn is_match(&self, text: &Text) -> bool {
-        let result = unsafe {
-            Tcl_RegExpExecObj(ptr::null_mut(), self.re, text.obj, 0, 1, 0)
-        };
-        if result == -1 {
-            panic!("Tcl_RegExpExecObj failed");
-        }
-        result > 0
-    }
-
-    pub fn find_iter<'r, 't>(&'r self, text: &'t Text) -> FindMatches<'r, 't> {
-        FindMatches { re: self, text: text, last_match: 0 }
-    }
-
-    fn find_at(&self, text: &Text, start: usize) -> Option<(usize, usize)> {
-        let result = unsafe {
-            Tcl_RegExpExecObj(
-                ptr::null_mut(),
-                self.re,
-                text.obj,
-                start as c_int,
-                1,
-                0,
-            )
-        };
-        if result == -1 {
-            panic!("Tcl_RegExpExecObj failed");
-        } else if result == 0 {
-            return None;
-        }
-        let mut info: tcl_regexp_info = unsafe { mem::zeroed() };
-        unsafe {
-            Tcl_RegExpGetInfo(self.re, &mut info);
-            let s = start as c_long + (*info.matches).start;
-            let e = start as c_long + (*info.matches).end;
-            Some((s as usize, e as usize))
-        }
-    }
-}
-
-pub struct FindMatches<'r, 't> {
-    re: &'r Regex,
-    text: &'t Text,
-    last_match: usize,
-}
-
-impl<'r, 't> Iterator for FindMatches<'r, 't> {
-    type Item = (usize, usize);
-
-    fn next(&mut self) -> Option<(usize, usize)> {
-        match self.re.find_at(self.text, self.last_match) {
-            None => None,
-            Some((s, e)) => {
-                self.last_match = e;
-                Some((s, e))
-            }
-        }
-    }
-}
-
-// TCL's FFI. We only wrap the bits we need.
-
-const TCL_REG_ADVANCED: c_int = 3;
-
-type tcl_interp = c_void;
-type tcl_regexp = c_void;
-
-#[repr(C)]
-struct tcl_obj {
-    ref_count: c_int,
-    // There are more fields, but we don't care about them.
-    // We're careful to only access ref_count so we can increment/decrement it.
-    // This is necessary because Tcl_IncRefCount and Tcl_DecrRefCount are
-    // macros.
-}
-
-impl tcl_obj {
-    unsafe fn incr_ref_count(&mut self) {
-        self.ref_count += 1;
-    }
-
-    unsafe fn decr_ref_count(&mut self) {
-        self.ref_count -= 1;
-        if self.ref_count <= 0 {
-            TclFreeObj(self);
-        }
-    }
-}
-
-#[repr(C)]
-struct tcl_regexp_info {
-    nsubs: c_int,
-    matches: *mut tcl_regexp_indices,
-    extend_start: c_long,
-    reserved: c_long,
-}
-
-#[repr(C)]
-struct tcl_regexp_indices {
-    start: c_long,
-    end: c_long,
-}
-
-extern "C" {
-    fn Tcl_CreateInterp() -> *mut tcl_interp;
-
-    fn Tcl_NewStringObj(pat: *const c_char, len: c_int) -> *mut tcl_obj;
-
-    fn TclFreeObj(obj: *mut tcl_obj);
-
-    fn Tcl_GetRegExpFromObj(
-        int: *mut tcl_interp,
-        pat: *mut tcl_obj,
-        flags: c_int,
-    ) -> *mut tcl_regexp;
-
-    fn Tcl_RegExpExecObj(
-        int: *mut tcl_interp,
-        re: *mut tcl_regexp,
-        text: *mut tcl_obj,
-        offset: c_int,
-        nmatches: c_int,
-        flags: c_int,
-    ) -> c_int;
-
-    fn Tcl_RegExpGetInfo(re: *mut tcl_regexp, info: *mut tcl_regexp_info);
-}
diff --git a/bench/src/main.rs b/bench/src/main.rs
deleted file mode 100644
index 0b52d85f75..0000000000
--- a/bench/src/main.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-use std::fs::File;
-use std::str;
-
-use docopt::Docopt;
-use memmap::Mmap;
-
-mod ffi;
-
-const USAGE: &'static str = "
-Count the number of matches of <pattern> in <file>.
-
-This compiles the pattern once and counts all successive non-overlapping
-matches in <file>. <file> is memory mapped. Matching is done as if <file> were
-a single string (it is not line oriented).
-
-Since this tool includes compilation of the <pattern>, sufficiently large
-haystacks should be used to amortize the cost of compilation. (e.g., >1MB.)
-
-Usage:
-    regex-run-one [options] [onig | pcre1 | pcre2 | re2 | rust | rust-bytes | tcl] <file> <pattern>
-    regex-run-one [options] (-h | --help)
-
-Options:
-    -h, --help   Show this usage message.
-";
-
-#[derive(Debug, serde::Deserialize)]
-struct Args {
-    arg_pattern: String,
-    arg_file: String,
-    cmd_onig: bool,
-    cmd_pcre1: bool,
-    cmd_pcre2: bool,
-    cmd_re2: bool,
-    cmd_rust: bool,
-    cmd_rust_bytes: bool,
-    cmd_tcl: bool,
-}
-
-fn main() {
-    let args: Args = Docopt::new(USAGE)
-        .and_then(|d| d.deserialize())
-        .unwrap_or_else(|e| e.exit());
-
-    let mmap =
-        unsafe { Mmap::map(&File::open(&args.arg_file).unwrap()).unwrap() };
-    let haystack = unsafe { str::from_utf8_unchecked(&mmap) };
-
-    println!("{}", args.count(&haystack));
-}
-
-impl Args {
-    fn count(&self, haystack: &str) -> usize {
-        let pat = &self.arg_pattern;
-        if self.cmd_onig {
-            count_onig(pat, haystack)
-        } else if self.cmd_pcre1 {
-            count_pcre1(pat, haystack)
-        } else if self.cmd_pcre2 {
-            count_pcre2(pat, haystack)
-        } else if self.cmd_re2 {
-            count_re2(pat, haystack)
-        } else if self.cmd_rust {
-            count_rust(pat, haystack)
-        } else if self.cmd_rust_bytes {
-            count_rust_bytes(pat, haystack)
-        } else if self.cmd_tcl {
-            count_tcl(pat, haystack)
-        } else {
-            panic!("unreachable")
-        }
-    }
-}
-
-macro_rules! nada {
-    ($feature:expr, $name:ident) => {
-        #[cfg(not(feature = $feature))]
-        fn $name(_pat: &str, _haystack: &str) -> usize {
-            panic!(
-                "Support not enabled. Re-compile with '--features {}' \
-                 to enable.",
-                $feature
-            )
-        }
-    };
-}
-
-nada!("re-onig", count_onig);
-#[cfg(feature = "re-onig")]
-fn count_onig(pat: &str, haystack: &str) -> usize {
-    use ffi::onig::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack).count()
-}
-
-nada!("re-pcre1", count_pcre1);
-#[cfg(feature = "re-pcre1")]
-fn count_pcre1(pat: &str, haystack: &str) -> usize {
-    use ffi::pcre1::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack).count()
-}
-
-nada!("re-pcre2", count_pcre2);
-#[cfg(feature = "re-pcre2")]
-fn count_pcre2(pat: &str, haystack: &str) -> usize {
-    use ffi::pcre2::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack).count()
-}
-
-nada!("re-re2", count_re2);
-#[cfg(feature = "re-re2")]
-fn count_re2(pat: &str, haystack: &str) -> usize {
-    use ffi::re2::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack).count()
-}
-
-nada!("re-rust", count_rust);
-#[cfg(feature = "re-rust")]
-fn count_rust(pat: &str, haystack: &str) -> usize {
-    use regex::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack).count()
-}
-
-nada!("re-rust-bytes", count_rust_bytes);
-#[cfg(feature = "re-rust-bytes")]
-fn count_rust_bytes(pat: &str, haystack: &str) -> usize {
-    use regex::bytes::Regex;
-    Regex::new(pat).unwrap().find_iter(haystack.as_bytes()).count()
-}
-
-nada!("re-tcl", count_tcl);
-#[cfg(feature = "re-tcl")]
-fn count_tcl(pat: &str, haystack: &str) -> usize {
-    use ffi::tcl::{Regex, Text};
-    Regex::new(pat).unwrap().find_iter(&Text::new(haystack.to_owned())).count()
-}
diff --git a/bench/src/misc.rs b/bench/src/misc.rs
deleted file mode 100644
index b389a2755f..0000000000
--- a/bench/src/misc.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-#![allow(non_snake_case)]
-
-use std::iter::repeat;
-
-use test::Bencher;
-
-#[cfg(any(feature = "re-rust", feature = "re-rust-bytes"))]
-use crate::RegexSet;
-use crate::{Regex, Text};
-
-#[cfg(not(feature = "re-onig"))]
-#[cfg(not(feature = "re-pcre1"))]
-#[cfg(not(feature = "re-pcre2"))]
-bench_match!(
-    no_exponential,
-    {
-        format!(
-            "{}{}",
-            repeat("a?").take(100).collect::<String>(),
-            repeat("a").take(100).collect::<String>()
-        )
-    },
-    repeat("a").take(100).collect()
-);
-
-bench_match!(literal, r"y", {
-    format!("{}y", repeat("x").take(50).collect::<String>())
-});
-
-bench_match!(not_literal, r".y", {
-    format!("{}y", repeat("x").take(50).collect::<String>())
-});
-
-bench_match!(match_class, "[abcdw]", {
-    format!("{}w", repeat("xxxx").take(20).collect::<String>())
-});
-
-bench_match!(match_class_in_range, "[ac]", {
-    format!("{}c", repeat("bbbb").take(20).collect::<String>())
-});
-
-#[cfg(not(feature = "re-rust-bytes"))]
-#[cfg(not(feature = "re-tcl"))]
-bench_match!(match_class_unicode, r"\p{L}", {
-    format!("{}a", repeat("☃5☃5").take(20).collect::<String>())
-});
-
-bench_not_match!(anchored_literal_short_non_match, r"^zbc(d|e)", {
-    "abcdefghijklmnopqrstuvwxyz".to_owned()
-});
-
-bench_not_match!(anchored_literal_long_non_match, r"^zbc(d|e)", {
-    repeat("abcdefghijklmnopqrstuvwxyz").take(15).collect::<String>()
-});
-
-bench_match!(anchored_literal_short_match, r"^.bc(d|e)", {
-    "abcdefghijklmnopqrstuvwxyz".to_owned()
-});
-
-bench_match!(anchored_literal_long_match, r"^.bc(d|e)", {
-    repeat("abcdefghijklmnopqrstuvwxyz").take(15).collect::<String>()
-});
-
-bench_match!(one_pass_short, r"^.bc(d|e)*$", {
-    "abcddddddeeeededd".to_owned()
-});
-
-bench_match!(one_pass_short_not, r".bc(d|e)*$", {
-    "abcddddddeeeededd".to_owned()
-});
-
-bench_match!(one_pass_long_prefix, r"^abcdefghijklmnopqrstuvwxyz.*$", {
-    "abcdefghijklmnopqrstuvwxyz".to_owned()
-});
-
-bench_match!(one_pass_long_prefix_not, r"^.bcdefghijklmnopqrstuvwxyz.*$", {
-    "abcdefghijklmnopqrstuvwxyz".to_owned()
-});
-
-bench_match!(long_needle1, r"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", {
-    repeat("a").take(100_000).collect::<String>() + "b"
-});
-
-bench_match!(long_needle2, r"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbba", {
-    repeat("b").take(100_000).collect::<String>() + "a"
-});
-
-// This benchmark specifically targets the "reverse suffix literal"
-// optimization. In particular, it is easy for a naive implementation to
-// take quadratic worst case time. This benchmark provides a case for such
-// a scenario.
-bench_not_match!(reverse_suffix_no_quadratic, r"[r-z].*bcdefghijklmnopq", {
-    repeat("bcdefghijklmnopq").take(500).collect::<String>()
-});
-
-#[cfg(feature = "re-rust")]
-#[bench]
-fn replace_all(b: &mut Bencher) {
-    let re = regex!("[cjrw]");
-    let text = "abcdefghijklmnopqrstuvwxyz";
-    b.iter(|| re.replace_all(text, ""));
-}
-
-const TXT_32: &'static str = include_str!("data/32.txt");
-const TXT_1K: &'static str = include_str!("data/1K.txt");
-const TXT_32K: &'static str = include_str!("data/32K.txt");
-const TXT_1MB: &'static str = include_str!("data/1MB.txt");
-
-fn get_text(corpus: &str, suffix: String) -> String {
-    let mut corpus = corpus.to_string();
-    corpus.push_str(&suffix);
-    corpus
-}
-
-fn easy0_suffix() -> String {
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ".to_string()
-}
-
-macro_rules! easy0 {
-    () => {
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
-    };
-}
-
-bench_match!(easy0_32, easy0!(), get_text(TXT_32, easy0_suffix()));
-bench_match!(easy0_1K, easy0!(), get_text(TXT_1K, easy0_suffix()));
-bench_match!(easy0_32K, easy0!(), get_text(TXT_32K, easy0_suffix()));
-bench_match!(easy0_1MB, easy0!(), get_text(TXT_1MB, easy0_suffix()));
-
-fn easy1_suffix() -> String {
-    "AABCCCDEEEFGGHHHIJJ".to_string()
-}
-
-macro_rules! easy1 {
-    () => {
-        r"A[AB]B[BC]C[CD]D[DE]E[EF]F[FG]G[GH]H[HI]I[IJ]J$"
-    };
-}
-
-bench_match!(easy1_32, easy1!(), get_text(TXT_32, easy1_suffix()));
-bench_match!(easy1_1K, easy1!(), get_text(TXT_1K, easy1_suffix()));
-bench_match!(easy1_32K, easy1!(), get_text(TXT_32K, easy1_suffix()));
-bench_match!(easy1_1MB, easy1!(), get_text(TXT_1MB, easy1_suffix()));
-
-fn medium_suffix() -> String {
-    "XABCDEFGHIJKLMNOPQRSTUVWXYZ".to_string()
-}
-
-macro_rules! medium {
-    () => {
-        r"[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
-    };
-}
-
-bench_match!(medium_32, medium!(), get_text(TXT_32, medium_suffix()));
-bench_match!(medium_1K, medium!(), get_text(TXT_1K, medium_suffix()));
-bench_match!(medium_32K, medium!(), get_text(TXT_32K, medium_suffix()));
-bench_match!(medium_1MB, medium!(), get_text(TXT_1MB, medium_suffix()));
-
-fn hard_suffix() -> String {
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ".to_string()
-}
-
-macro_rules! hard {
-    () => {
-        r"[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
-    };
-}
-
-bench_match!(hard_32, hard!(), get_text(TXT_32, hard_suffix()));
-bench_match!(hard_1K, hard!(), get_text(TXT_1K, hard_suffix()));
-bench_match!(hard_32K, hard!(), get_text(TXT_32K, hard_suffix()));
-bench_match!(hard_1MB, hard!(), get_text(TXT_1MB, hard_suffix()));
-
-fn reallyhard_suffix() -> String {
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ".to_string()
-}
-
-macro_rules! reallyhard {
-    () => {
-        // The point of this being "really" hard is that it should completely
-        // thwart any prefix or suffix literal optimizations.
-        r"[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ.*"
-    };
-}
-
-bench_match!(
-    reallyhard_32,
-    reallyhard!(),
-    get_text(TXT_32, reallyhard_suffix())
-);
-bench_match!(
-    reallyhard_1K,
-    reallyhard!(),
-    get_text(TXT_1K, reallyhard_suffix())
-);
-bench_match!(
-    reallyhard_32K,
-    reallyhard!(),
-    get_text(TXT_32K, reallyhard_suffix())
-);
-bench_match!(
-    reallyhard_1MB,
-    reallyhard!(),
-    get_text(TXT_1MB, reallyhard_suffix())
-);
-
-fn reallyhard2_suffix() -> String {
-    "Sherlock Holmes".to_string()
-}
-
-macro_rules! reallyhard2 {
-    () => {
-        r"\w+\s+Holmes"
-    };
-}
-
-bench_match!(
-    reallyhard2_1K,
-    reallyhard2!(),
-    get_text(TXT_1K, reallyhard2_suffix())
-);
-
-//
-// Benchmarks to justify the short-haystack NFA fallthrough optimization
-// implemented by `read_captures_at` in regex/src/exec.rs. See github issue
-// #348.
-//
-// The procedure used to try to determine the right hardcoded cutoff
-// for the short-haystack optimization in issue #348 is as follows.
-//
-// ```
-// > cd bench
-// > cargo bench --features re-rust short_hay | tee dfa-nfa.res
-// > # modify the `MatchType::Dfa` branch in exec.rs:read_captures_at
-// > # to just execute the nfa
-// > cargo bench --features re-rust short_hay | tee nfa-only.res
-// > cargo benchcmp dfa-nfa.res nfa-only.res
-// ```
-//
-// The expected result is that short inputs will go faster under
-// the nfa-only mode, but at some turnover point the dfa-nfa mode
-// will start to win again. Unfortunately, that is not what happened.
-// Instead there was no noticeable change in the bench results, so
-// I've opted to just do the more conservative anchor optimization.
-//
-bench_captures!(
-    short_haystack_1x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    String::from("aaaabbbbccccbbbdddd")
-);
-bench_captures!(
-    short_haystack_2x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(2).collect::<String>(),
-        repeat("dddd").take(2).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_3x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(3).collect::<String>(),
-        repeat("dddd").take(3).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_4x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(4).collect::<String>(),
-        repeat("dddd").take(4).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_10x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(10).collect::<String>(),
-        repeat("dddd").take(10).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_100x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(100).collect::<String>(),
-        repeat("dddd").take(100).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_1000x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(1000).collect::<String>(),
-        repeat("dddd").take(1000).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_10000x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(10000).collect::<String>(),
-        repeat("dddd").take(10000).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_100000x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(100000).collect::<String>(),
-        repeat("dddd").take(100000).collect::<String>(),
-    )
-);
-bench_captures!(
-    short_haystack_1000000x,
-    Regex::new(r"(bbbb)cccc(bbb)").unwrap(),
-    2,
-    format!(
-        "{}bbbbccccbbb{}",
-        repeat("aaaa").take(1000000).collect::<String>(),
-        repeat("dddd").take(1000000).collect::<String>(),
-    )
-);
-
-#[cfg(any(feature = "re-rust", feature = "re-rust-bytes"))]
-bench_is_match_set!(
-    is_match_set,
-    true,
-    RegexSet::new(vec![
-        "aaaaaaaaaaaaaaaaaaa",
-        "abc579",
-        "def.+",
-        "e24fg",
-        "a.*2c",
-        "23.",
-    ])
-    .unwrap(),
-    format!(
-        "{}a482c{}",
-        repeat('a').take(10).collect::<String>(),
-        repeat('b').take(10).collect::<String>()
-    )
-);
-
-#[cfg(any(feature = "re-rust", feature = "re-rust-bytes"))]
-bench_matches_set!(
-    matches_set,
-    true,
-    RegexSet::new(vec![
-        "aaaaaaaaaaaaaaaaaaa",
-        "abc579",
-        "def.+",
-        "e24fg",
-        "a.*2c",
-        "23.",
-    ])
-    .unwrap(),
-    format!(
-        "{}a482c{}",
-        repeat('a').take(10).collect::<String>(),
-        repeat('b').take(10).collect::<String>()
-    )
-);
diff --git a/bench/src/regexdna.rs b/bench/src/regexdna.rs
deleted file mode 100644
index 7a35aa4563..0000000000
--- a/bench/src/regexdna.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use test::Bencher;
-
-use crate::{Regex, Text};
-
-// USAGE: dna!(name, pattern, count)
-//
-// This is same as bench_find, except it always uses the regexdna haystack.
-macro_rules! dna {
-    ($name:ident, $pattern:expr, $count:expr) => {
-        bench_find!(
-            $name,
-            $pattern,
-            $count,
-            include_str!("data/regexdna.txt").to_owned()
-        );
-    };
-}
-
-dna!(find_new_lines, r">[^\n]*\n|\n", 83337);
-dna!(variant1, r"agggtaaa|tttaccct", 32);
-dna!(variant2, r"[cgt]gggtaaa|tttaccc[acg]", 115);
-dna!(variant3, r"a[act]ggtaaa|tttacc[agt]t", 368);
-dna!(variant4, r"ag[act]gtaaa|tttac[agt]ct", 254);
-dna!(variant5, r"agg[act]taaa|ttta[agt]cct", 466);
-dna!(variant6, r"aggg[acg]aaa|ttt[cgt]ccct", 135);
-dna!(variant7, r"agggt[cgt]aa|tt[acg]accct", 137);
-dna!(variant8, r"agggta[cgt]a|t[acg]taccct", 139);
-dna!(variant9, r"agggtaa[cgt]|[acg]ttaccct", 197);
-dna!(subst1, r"B", 29963);
-dna!(subst2, r"D", 29987);
-dna!(subst3, r"H", 30004);
-dna!(subst4, r"K", 29974);
-dna!(subst5, r"M", 29979);
-dna!(subst6, r"N", 29959);
-dna!(subst7, r"R", 30012);
-dna!(subst8, r"S", 29994);
-dna!(subst9, r"V", 29996);
-dna!(subst10, r"W", 29984);
-dna!(subst11, r"Y", 29947);
diff --git a/bench/src/rust_compile.rs b/bench/src/rust_compile.rs
deleted file mode 100644
index f88e9b181e..0000000000
--- a/bench/src/rust_compile.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use regex_syntax::Parser;
-use test::Bencher;
-
-use regex::internal::Compiler;
-
-#[bench]
-fn compile_simple(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"^bc(d|e)*$").unwrap();
-        Compiler::new().compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_simple_bytes(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"^bc(d|e)*$").unwrap();
-        Compiler::new().bytes(true).compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_simple_full(b: &mut Bencher) {
-    b.iter(|| regex!(r"^bc(d|e)*$"));
-}
-
-#[bench]
-fn compile_small(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"\p{L}|\p{N}|\s|.|\d").unwrap();
-        Compiler::new().compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_small_bytes(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"\p{L}|\p{N}|\s|.|\d").unwrap();
-        Compiler::new().bytes(true).compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_small_full(b: &mut Bencher) {
-    b.iter(|| regex!(r"\p{L}|\p{N}|\s|.|\d"));
-}
-
-#[bench]
-fn compile_huge(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"\p{L}{50}").unwrap();
-        Compiler::new().size_limit(1 << 30).compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_huge_bytes(b: &mut Bencher) {
-    b.iter(|| {
-        let re = Parser::new().parse(r"\p{L}{50}").unwrap();
-        Compiler::new().size_limit(1 << 30).bytes(true).compile(&[re]).unwrap()
-    });
-}
-
-#[bench]
-fn compile_huge_full(b: &mut Bencher) {
-    b.iter(|| regex!(r"\p{L}{50}"));
-}
diff --git a/bench/src/rust_parse.rs b/bench/src/rust_parse.rs
deleted file mode 100644
index 6dea1c10f8..0000000000
--- a/bench/src/rust_parse.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use regex_syntax::Expr;
-use test::Bencher;
-
-#[bench]
-fn parse_simple(b: &mut Bencher) {
-    b.iter(|| {
-        let re = r"^bc(d|e)*$";
-        Expr::parse(re).unwrap()
-    });
-}
-
-#[bench]
-fn parse_simple2(b: &mut Bencher) {
-    b.iter(|| {
-        let re = r"'[a-zA-Z_][a-zA-Z0-9_]*(')\b";
-        Expr::parse(re).unwrap()
-    });
-}
-
-#[bench]
-fn parse_small(b: &mut Bencher) {
-    b.iter(|| {
-        let re = r"\p{L}|\p{N}|\s|.|\d";
-        Expr::parse(re).unwrap()
-    });
-}
-
-#[bench]
-fn parse_huge(b: &mut Bencher) {
-    b.iter(|| {
-        let re = r"\p{L}{100}";
-        Expr::parse(re).unwrap()
-    });
-}
diff --git a/bench/src/sherlock.rs b/bench/src/sherlock.rs
deleted file mode 100644
index 593eff3c56..0000000000
--- a/bench/src/sherlock.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-use test::Bencher;
-
-use crate::{Regex, Text};
-
-// USAGE: sherlock!(name, pattern, count)
-//
-// This is same as bench_find, except it always uses the Sherlock haystack.
-macro_rules! sherlock {
-    ($name:ident, $pattern:expr, $count:expr) => {
-        bench_find!(
-            $name,
-            $pattern,
-            $count,
-            include_str!("data/sherlock.txt").to_owned()
-        );
-    };
-}
-
-// These patterns are all single string literals that compile down to a variant
-// of Boyer-Moore w/ memchr. This also demonstrates the impact that the
-// frequency of a match has on performance.
-sherlock!(name_sherlock, r"Sherlock", 97);
-sherlock!(name_holmes, r"Holmes", 461);
-sherlock!(name_sherlock_holmes, r"Sherlock Holmes", 91);
-
-// Like the above, except case insensitively. The prefix detector will extract
-// multiple *cut* prefix literals for each of the following before hitting its
-// limit. All of these should be able to use either memchr2 or memchr3.
-// std C++ does not support inline modifier syntax
-sherlock!(name_sherlock_nocase, r"(?i)Sherlock", 102);
-sherlock!(name_holmes_nocase, r"(?i)Holmes", 467);
-sherlock!(name_sherlock_holmes_nocase, r"(?i)Sherlock Holmes", 96);
-
-// Will quickly find instances of 'Sherlock', but then needs to fall back to
-// the lazy DFA to process the Unicode aware `\s`.
-sherlock!(name_whitespace, r"Sherlock\s+Holmes", 97);
-
-// Now try more variations on name matching.
-// This one has two alternates that both start with 'S'. This should compile
-// to an Aho-Corasick automaton that uses memchr. Never enters lazy DFA.
-sherlock!(name_alt1, r"Sherlock|Street", 158);
-// This one doesn't have a common byte, but should still use Aho-Corasick and
-// memchr2.
-// Never enters lazy DFA.
-sherlock!(name_alt2, r"Sherlock|Holmes", 558);
-// Still using Aho-Corasick, but more patterns. Never enters lazy DFA but
-// also can't use any memchr variant.
-sherlock!(name_alt3, r"Sherlock|Holmes|Watson|Irene|Adler|John|Baker", 740);
-// Still using Aho-Corasick, but needs the lazy DFA.
-sherlock!(
-    name_alt3_nocase,
-    r"(?i)Sherlock|Holmes|Watson|Irene|Adler|John|Baker",
-    753
-);
-// Should still use Aho-Corasick for the prefixes in each alternate, but
-// we need to use the lazy DFA to complete it.
-sherlock!(name_alt4, r"Sher[a-z]+|Hol[a-z]+", 582);
-sherlock!(name_alt4_nocase, r"(?i)Sher[a-z]+|Hol[a-z]+", 697);
-// Uses Aho-Corasick, but can use memchr3 (unlike name_alt3).
-sherlock!(name_alt5, r"Sherlock|Holmes|Watson", 639);
-sherlock!(name_alt5_nocase, r"(?i)Sherlock|Holmes|Watson", 650);
-
-// How long does it take to discover that there's no match? In the first two
-// cases, we detect the rarest byte in the literal to run memchr on. In the
-// first, it's 'z' and in the second it's 'j'. The third case only has common
-// letters, and is therefore slower.
-sherlock!(no_match_uncommon, r"zqj", 0);
-sherlock!(no_match_common, r"aqj", 0);
-sherlock!(no_match_really_common, r"aei", 0);
-
-// Various twiddling on very common words. This tends to stress the constant
-// overhead of actually reporting a match. (None of these actually enter any
-// matching engines.)
-sherlock!(the_lower, r"the", 7218);
-sherlock!(the_upper, r"The", 741);
-sherlock!(the_nocase, r"(?i)the", 7987);
-
-// Process whitespace after a very common word.
-// Uses Boyer-Moore to find `the` and the lazy DFA for the rest.
-sherlock!(the_whitespace, r"the\s+\w+", 5410);
-
-// How fast can we match everything? This essentially defeats any clever prefix
-// tricks and just executes the DFA across the entire input.
-#[cfg(not(feature = "re-pcre1"))]
-#[cfg(not(feature = "re-pcre2"))]
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(everything_greedy, r".*", 13053);
-#[cfg(not(feature = "re-onig"))]
-#[cfg(not(feature = "re-pcre1"))]
-#[cfg(not(feature = "re-pcre2"))]
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(everything_greedy_nl, r"(?s).*", 1);
-
-// How fast can we match every letter? This also defeats any clever prefix
-// tricks.
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(letters, r"\p{L}", 447160);
-
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(letters_upper, r"\p{Lu}", 14180);
-
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(letters_lower, r"\p{Ll}", 432980);
-
-// Similarly, for words.
-#[cfg(not(feature = "re-re2"))]
-sherlock!(words, r"\w+", 109214);
-#[cfg(feature = "re-re2")]
-sherlock!(words, r"\w+", 109222); // hmm, why does RE2 diverge here?
-
-// Find complete words before Holmes. The `\w` defeats any prefix
-// optimizations.
-sherlock!(before_holmes, r"\w+\s+Holmes", 319);
-
-// Find complete words before Holmes. Both of the `\w`s defeat any prefix
-// and suffix optimizations.
-sherlock!(before_after_holmes, r"\w+\s+Holmes\s+\w+", 137);
-
-// Find Holmes co-occurring with Watson in a particular window of characters.
-// This uses Aho-Corasick for the Holmes|Watson prefix, but the lazy DFA for
-// the rest.
-sherlock!(holmes_cochar_watson, r"Holmes.{0,25}Watson|Watson.{0,25}Holmes", 7);
-
-// Find Holmes co-occurring with Watson in a particular window of words.
-// This uses Aho-Corasick for the Holmes|Watson prefix, but the lazy DFA for
-// the rest.
-#[cfg(not(feature = "re-onig"))]
-#[cfg(not(feature = "re-pcre1"))]
-#[cfg(not(feature = "re-pcre2"))]
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(
-    holmes_coword_watson,
-    r"Holmes(?:\s*.+\s*){0,10}Watson|Watson(?:\s*.+\s*){0,10}Holmes",
-    51
-);
-
-// Find some subset of quotes in the text.
-// This does detect the `"` or `'` prefix literal and does a quick scan for
-// either byte before starting the lazy DFA.
-sherlock!(quotes, r#"["'][^"']{0,30}[?!.]["']"#, 767);
-
-// Finds all occurrences of Sherlock Holmes at the beginning or end of a line.
-// The empty assertions defeat any detection of prefix literals, so it's the
-// lazy DFA the entire way.
-sherlock!(
-    line_boundary_sherlock_holmes,
-    r"(?m)^Sherlock Holmes|Sherlock Holmes$",
-    34
-);
-
-// All words ending in `n`. This uses Unicode word boundaries, which the DFA
-// can speculatively handle. Since this benchmark is on mostly ASCII text, it
-// performs well here. A different benchmark with non-Western text would be
-// more revealing since the search would be forced to fall back to an NFA
-// simulation.
-#[cfg(not(feature = "re-tcl"))]
-sherlock!(word_ending_n, r"\b\w+n\b", 8366);
-
-// This is a real bad one for Rust's engine. This particular expression
-// fills the state cache quite frequently, which results in a lot of churn.
-// This can be made to go roughly the speed of PCRE by increasing the DFA cache
-// size.
-//
-// Its only salvation is that the DFA realizes it's executing slowly, gives up
-// quickly and falls back to the NFA algorithm.
-//
-// RE2 seems to do a worse job at this than Rust. So much so that it's slow
-// enough to be annoying, so we disable it.
-#[cfg(not(feature = "re-re2"))]
-sherlock!(repeated_class_negation, r"[a-q][^u-z]{13}x", 142);
-
-// This defeats any prefix optimizations but triggers the reverse suffix
-// optimization.
-sherlock!(ing_suffix, r"[a-zA-Z]+ing", 2824);
-
-// Similar to ing_suffix, but a little more complex by limiting the length
-// of the word and making sure it's surrounded by whitespace. The trailing
-// `\s` defeats the reverse suffix optimization.
-//
-// Onig does surprisingly well on this benchmark and yet does quite poorly on
-// the ing_suffix benchmark. That one has me stumped.
-sherlock!(ing_suffix_limited_space, r"\s[a-zA-Z]{0,12}ing\s", 2081);
diff --git a/examples/regexdna-input.txt b/examples/regexdna-input.txt
deleted file mode 100644
index fb23263397..0000000000
--- a/examples/regexdna-input.txt
+++ /dev/null
@@ -1,1671 +0,0 @@
->ONE Homo sapiens alu
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
-GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
-GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
-TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
-AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
-GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
-CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
-TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
-ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
-GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
-ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
-CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
-CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
-ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
-CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
-AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
-CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
-AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
-CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
-CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
-CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
-CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
-ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
-AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
-TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
-ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
-CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
-AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
-AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
-TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
-CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
-TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
-CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
-GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
-GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
-CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
-GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
-GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
-AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
-GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
-CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
-GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
-TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
-CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
-ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
-CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
-AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
-CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
-CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
-ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
-GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
-GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
-GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
-TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
-CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
-GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
-CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
-GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
-CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
-CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
-CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
-ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
-CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
-GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
-AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
-ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
-TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
-GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
-GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
-TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
-AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
-ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
-GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
-AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
-TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
-CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
-GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
-CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
-GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
-TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
-ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
-TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
-GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
-TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
-GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
-GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
-ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
-GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
-GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
-CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
-ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
-AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
-TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
-CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
-TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
-CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
-GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
-GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
-CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
-TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
-CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
-AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
-AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
-AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
-GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
-TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
-AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
-AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
-CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
-TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
-GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
-CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
-CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
-GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
-AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
-GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
-TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
-CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
-GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
-CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
-AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
-ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
-ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
-AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
-GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
-GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
-CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
-GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
-CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
-GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
-GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
-GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
-CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
-AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
-CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
-CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
-GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
-GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
-TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
-ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
-CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
-ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
-GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
-TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
-GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
-GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
-GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
-GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
-TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
-TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
-TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
-GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
-CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
-TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
-GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
-GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
-GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
-ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
-GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
-CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
-CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
-CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
-GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
-TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
-GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
-AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
-GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
-CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
-GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
-ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
-GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
-AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
-CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
-TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
-AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
-GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
-CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
-AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
-CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
-GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
-CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
-AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
-AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
-CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
-GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
-CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
-TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
-CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
-AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
-TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
-CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
-CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
-GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
-GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
-GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
-CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
-TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
-CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
-CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
-CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
-AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
-GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
-CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
-TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
-GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
-GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
-CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
-TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
-CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
-CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
-GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
-GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
-GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
-GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
-TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
-ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
-CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
-AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
-GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
-CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
-GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
-TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
-GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
-GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
-AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
-AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
-CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
-CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
-AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
-GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
-GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
-GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
-CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
-CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
-CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
-GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
-TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
-CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
-CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
-AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
-AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
-GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
-TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
-AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
-GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
-CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
-GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
-GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
-TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
-AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
-GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
-AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
-AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
-GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
-CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
-AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
-TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
-TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
-GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
-TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
-CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
-CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
-TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
-CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
-AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
-GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
-TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
-TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
-GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
-GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
-ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
-TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
-CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
-CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
-GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
-CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
-GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
-GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
-GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
-GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
-GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
-AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
-CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
-GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
-AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
-GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
-ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
-GAGGCTGAGGCAGGAGAATC
->TWO IUB ambiguity codes
-cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
-tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
-NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
-cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
-gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
-HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
-tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
-tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
-acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
-tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
-gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
-accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
-RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
-tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
-cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
-ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
-actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
-YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
-KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
-aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
-aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
-gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
-tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
-tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
-ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
-ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
-BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
-aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
-tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
-cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
-aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
-tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
-aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
-gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
-ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
-taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
-ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
-gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
-gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
-tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
-tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
-taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
-cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
-aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
-cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
-ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
-attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
-ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
-attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
-tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
-aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
-cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
-gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
-attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
-BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
-DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
-tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
-tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
-tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
-taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
-aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
-DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
-VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
-agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
-gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
-tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
-catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
-tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
-aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
-aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
-acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
-tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
-aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
-acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
-RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
-RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
-tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
-gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
-YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
-ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
-ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
-gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
-KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
-aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
-gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
-taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
-VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
-NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
-MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
-cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
-ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
-tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
-aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
-actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
-tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
-gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
-BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
-aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
-aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
-YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
-aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
-cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
-tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
-tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
-MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
-taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
-tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
-RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
-agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
-NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
-gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
-aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
-ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
-cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
-tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
-RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
-tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
-gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
-tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
-ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
-tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
-ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
-BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
-gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
-acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
-gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
-taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
-acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
-tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
-catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
-tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
-atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
-ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
-ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
-cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
-SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
-VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
-BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
-NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
-tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
-ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
-cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
-VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
-atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
-aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
-tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
-RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
-gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
-tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
-attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
-atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
-cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
-NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
-ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
-cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
-aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
-agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
-tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
-ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
-ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
-tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
-taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
-tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
-YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
-ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
-tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
-ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
-attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
-atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
-YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
-gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
-MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
-tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
-ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
-aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
-BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
-tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
-StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
-cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
-atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
-atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
-ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
-gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
-tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
-BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
-agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
-HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
-tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
-aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
-catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
-aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
-tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
-cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
-DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
-gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
-tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
-atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
-KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
-tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
-tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
-taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
-NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
-HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
-ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
-tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
-cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
-ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
-HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
-gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
-BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
-gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
-KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
-cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
-tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
-taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
-gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
-aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
-acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
-RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
-attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
-KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
-KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
-gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
-aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
-aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
-ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
-tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
-aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
-tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
-MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
-cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
-caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
-ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
-acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
-tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
-gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
-atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
-aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
-NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
-taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
-aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
-ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
-DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
-tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
-aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
-ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
-ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
-RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
-aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
-aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
-aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
-tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
-atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
-BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
-gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
-cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
-RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
-taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
-aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
-gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
-gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
-aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
-gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
-ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
-MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
-SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
-aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
-VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
-HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
-agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
-gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
-agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
-tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
-gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
-VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
-tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
-MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
-actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
-WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
-tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
-KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
-BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
-attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
-VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
-aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
-tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
-tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
-tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
-VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
-tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
-ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
-tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
-WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
-tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
-tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
-MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
-tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
-atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
-aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
-aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
-aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
-YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
-WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
-ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
-aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
-ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
-gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
-NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
-atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
-tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
-aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
-gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
-gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
-tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
-aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
-ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
-tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
-catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
-cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
-aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
-NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
-ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
-RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
-SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
-RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
-agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
-gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
-MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
-aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
-cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
-ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
-accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
-tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
-acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
-SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
-tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
-gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
-attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
-DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
-aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
-tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
-ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
-ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
-tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
-tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
-attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
-aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
-cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
-aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
-VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
-catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
-taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
-cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
-DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
-tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
-acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
-tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
-YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
-cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
-actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
-KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
-WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
-ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
-aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
-aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
-agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
-NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
-taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
-RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
-aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
-tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
-aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
-tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
-aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
-tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
-DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
-YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
-tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
-ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
-cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
-atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
-cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
-aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
-acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
-tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
-ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
-gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
-ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
-aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
-cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
-MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
-atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
-taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
-taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
-ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
-cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
-BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
-tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
-gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
-gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
-ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
-aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
-taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
-atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
-atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
-aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
-cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
-tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
-aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
-acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
-gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
-gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
-gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
-MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
-cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
-agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
-taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
-ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
-aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
-VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
-ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
-tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
-tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
-gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
-tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
-DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
-acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
-aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
-gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
-agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
-aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
-gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
-ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
-gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
-SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
-tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
-aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
-MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
-aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
-ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
-aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
-YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
-aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
-aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
-ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
-atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
-cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
-attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
-BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
-aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
-agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
-BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
-agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
-KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
-attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
-BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
-StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
-atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
-HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
-gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
-gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
-caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
-gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
-aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
-aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
-HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
-gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
-ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
-taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
-atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
-gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
-YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
-aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
-tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
-tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
-HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
-gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
-SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
-HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
-tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
-tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
-caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
-atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
-ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
-aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
-acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
-aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
-ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
-tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
-actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
-cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
-ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
-tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
-tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
-YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
-ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
-aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
-DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
-tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
-ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
->THREE Homo sapiens frequency
-agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
-cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
-tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
-tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
-gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
-tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
-tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
-atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
-cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
-ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
-ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
-atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
-gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
-tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
-gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
-atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
-tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
-ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
-tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
-aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
-gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
-ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
-agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
-agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
-acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
-cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
-cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
-cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
-aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
-tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
-atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
-cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
-tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
-catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
-tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
-caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
-tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
-aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
-aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
-ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
-gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
-ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
-cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
-gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
-ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
-cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
-taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
-gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
-taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
-ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
-aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
-gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
-acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
-ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
-tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
-tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
-tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
-ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
-aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
-tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
-gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
-gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
-cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
-actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
-tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
-ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
-ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
-agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
-gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
-tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
-atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
-cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
-tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
-gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
-gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
-aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
-gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
-cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
-taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
-tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
-ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
-aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
-gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
-aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
-tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
-tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
-aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
-ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
-ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
-caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
-gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
-cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
-ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
-tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
-atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
-ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
-acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
-taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
-ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
-aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
-cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
-tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
-gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
-aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
-cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
-cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
-gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
-cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
-gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
-agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
-aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
-aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
-cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
-agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
-cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
-agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
-gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
-aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
-agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
-cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
-agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
-ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
-tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
-gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
-gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
-ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
-gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
-atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
-tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
-ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
-tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
-cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
-ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
-aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
-gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
-ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
-atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
-aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
-gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
-atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
-aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
-tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
-ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
-gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
-cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
-ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
-ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
-ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
-cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
-tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
-tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
-cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
-gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
-ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
-ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
-tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
-agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
-ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
-cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
-agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
-tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
-gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
-ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
-ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
-agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
-attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
-ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
-agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
-aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
-gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
-gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
-ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
-gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
-ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
-taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
-aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
-tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
-ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
-agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
-ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
-agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
-gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
-tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
-gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
-cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
-ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
-cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
-gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
-gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
-tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
-cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
-aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
-ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
-gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
-aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
-gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
-aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
-gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
-agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
-caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
-gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
-aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
-tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
-tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
-ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
-ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
-gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
-ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
-aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
-tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
-acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
-atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
-gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
-tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
-cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
-gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
-acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
-acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
-attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
-tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
-cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
-aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
-ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
-tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
-gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
-gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
-acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
-gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
-gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
-ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
-taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
-agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
-gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
-ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
-accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
-tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
-taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
-catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
-tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
-ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
-aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
-atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
-tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
-ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
-tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
-aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
-agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
-acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
-aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
-ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
-gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
-taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
-taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
-tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
-gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
-ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
-atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
-tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
-cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
-aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
-taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
-caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
-ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
-tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
-tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
-gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
-gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
-gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
-ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
-tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
-taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
-gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
-ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
-gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
-tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
-ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
-tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
-cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
-ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
-caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
-cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
-gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
-cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
-taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
-tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
-taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
-tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
-tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
-tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
-ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
-aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
-atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
-actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
-gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
-ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
-gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
-tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
-aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
-atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
-catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
-taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
-ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
-cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
-agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
-atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
-tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
-gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
-attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
-tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
-tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
-gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
-attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
-aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
-ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
-taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
-atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
-aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
-agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
-gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
-tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
-taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
-cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
-aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
-ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
-gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
-tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
-ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
-cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
-aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
-cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
-ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
-tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
-ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
-atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
-tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
-ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
-acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
-ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
-aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
-gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
-ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
-tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
-gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
-taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
-aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
-tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
-gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
-ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
-tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
-tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
-tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
-ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
-gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
-ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
-gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
-tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
-caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
-tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
-gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
-tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
-cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
-gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
-tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
-caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
-agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
-atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
-ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
-atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
-tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
-tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
-ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
-agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
-acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
-cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
-taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
-acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
-ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
-ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
-cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
-ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
-cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
-attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
-gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
-ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
-aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
-acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
-tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
-tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
-agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
-ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
-tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
-ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
-aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
-cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
-tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
-tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
-accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
-agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
-aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
-gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
-aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
-ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
-cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
-ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
-tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
-tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
-aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
-gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
-cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
-aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
-gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
-gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
-tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
-tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
-accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
-atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
-tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
-atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
-gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
-ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
-tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
-gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
-tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
-gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
-ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
-agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
-aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
-tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
-tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
-tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
-aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
-aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
-aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
-ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
-gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
-tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
-atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
-gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
-tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
-gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
-atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
-gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
-ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
-tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
-gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
-aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
-acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
-acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
-accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
-atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
-aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
-gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
-aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
-caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
-cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
-ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
-aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
-tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
-agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
-caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
-gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
-gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
-acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
-ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
-gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
-cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
-ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
-actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
-tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
-catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
-tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
-tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
-tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
-cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
-cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
-tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
-aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
-cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
-caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
-ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
-tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
-attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
-tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
-gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
-cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
-aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
-ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
-aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
-gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
-gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
-cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
-gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
-tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
-aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
-atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
-ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
-aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
-aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
-cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
-gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
-ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
-tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
-gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
-atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
-ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
-acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
-cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
-atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
-tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
-atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
-ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
-agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
-agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
-atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
-tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
-tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
-taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
-aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
-tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
-acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
-tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
-acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
-ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
-tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
-aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
-taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
-cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
-ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
-attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
-caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
-aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
-atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
-tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
-cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
-ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
-gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
-actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
-cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
-ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
-aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
-ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
-gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
-ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
-cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
-tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
-ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
-cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
-ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
-attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
-agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
-ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
-aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
-aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
-atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
-cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
-gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
-aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
-atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
-ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
-cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
-caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
-tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
-catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
-atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
-tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
-gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
-agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
-actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
-ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
-tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
-ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
-gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
-tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
-taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
-agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
-acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
-cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
-attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
-agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
-gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
-taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
-ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
-tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
-tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
-aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
-tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
-atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
-ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
-aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
-actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
-acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
-aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
-caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
-aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
-cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
-atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
-ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
-agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
-atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
-ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
-attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
-ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
-atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
-taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
-tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
-aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
-ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
-gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
-gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
-ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
-cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
-ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
-aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
-taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
-gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
-gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
-tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
-attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
-caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
-acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
-cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
-taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
-taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
-tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
-ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
-taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
-tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
-gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
-gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
-cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
-aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
-gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
-agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
-agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
-acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
-gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
-tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
-atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
-ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
-gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
-gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
-gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
-atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
-ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
-acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
-tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
-tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
-cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
-aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
-gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
-ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
-taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
-gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
-tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
-tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
-caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
-ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
-gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
-ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
-aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
-ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
-tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
-gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
-aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
-ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
-cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
-attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
-ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
-gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
-ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
-atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
-atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
-atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
-cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
-cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
-gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
-accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
-tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
-aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
-cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
-tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
-cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
-acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
-cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
-ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
-agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
-cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
-acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
-gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
-gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
-cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
-gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
-ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
-ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
-agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
-gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
-tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
-tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
-ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
-ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
-ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
-catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
-ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
-tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
-aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
-gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
-agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
-atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
-taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
-tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
-cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
-cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
-tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
-catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
-catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
-ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
-tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
-ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
-ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
-ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
-tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
-ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
-tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
-aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
-gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
-ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
-agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
-taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
-ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
-agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
-gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
-agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
-ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
-ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
-acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
-aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
-ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
-ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
-tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
-gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
-ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
-tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
-aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
-ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
-atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
-acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
-gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
-acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
-ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
-ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
-gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
-agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
-ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
-ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
-gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
-gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
-gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
-cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
-aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
-cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
-gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
-ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
-gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
-atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
-gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
-acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
-aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
-cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
-atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
-tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
-tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
-ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
-tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
-gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
-gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
-aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
-tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
-tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
-attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
-catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
-taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
-ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
-gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
-aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
-aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
-agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
-tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
-aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
-agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
-ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
-taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
-ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
-cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
-tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
-cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
-gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
-cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
-tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
-acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
-ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
-gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
-taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
-tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
-tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
-cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
-tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
-ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
-aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
-agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
-gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
-catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
-tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
-aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
-acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
-tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
-aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
-agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
-gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
-gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
-taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
-gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
-gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
-tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
-agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
-tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
-caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
-aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
-gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
-catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
-ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
-tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
-gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
-cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
-gagatacctttgcaattttt
diff --git a/examples/regexdna-output.txt b/examples/regexdna-output.txt
deleted file mode 100644
index d36baa5be8..0000000000
--- a/examples/regexdna-output.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-agggtaaa|tttaccct 0
-[cgt]gggtaaa|tttaccc[acg] 3
-a[act]ggtaaa|tttacc[agt]t 9
-ag[act]gtaaa|tttac[agt]ct 8
-agg[act]taaa|ttta[agt]cct 10
-aggg[acg]aaa|ttt[cgt]ccct 3
-agggt[cgt]aa|tt[acg]accct 4
-agggta[cgt]a|t[acg]taccct 3
-agggtaa[cgt]|[acg]ttaccct 5
-
-101745
-100000
-133640
diff --git a/examples/shootout-regex-dna-bytes.rs b/examples/shootout-regex-dna-bytes.rs
deleted file mode 100644
index 773fd9ba8d..0000000000
--- a/examples/shootout-regex-dna-bytes.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-// The Computer Language Benchmarks Game
-// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
-//
-// contributed by the Rust Project Developers
-// contributed by TeXitoi
-// contributed by BurntSushi
-
-use std::io::{self, Read};
-use std::sync::Arc;
-use std::thread;
-
-macro_rules! regex {
-    ($re:expr) => {
-        ::regex::bytes::Regex::new($re).unwrap()
-    };
-}
-
-fn main() {
-    let mut seq = Vec::with_capacity(51 * (1 << 20));
-    io::stdin().read_to_end(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, &b""[..]).into_owned();
-    let clen = seq.len();
-    let seq_arc = Arc::new(seq.clone());
-
-    let variants = vec![
-        regex!("agggtaaa|tttaccct"),
-        regex!("[cgt]gggtaaa|tttaccc[acg]"),
-        regex!("a[act]ggtaaa|tttacc[agt]t"),
-        regex!("ag[act]gtaaa|tttac[agt]ct"),
-        regex!("agg[act]taaa|ttta[agt]cct"),
-        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
-        regex!("agggt[cgt]aa|tt[acg]accct"),
-        regex!("agggta[cgt]a|t[acg]taccct"),
-        regex!("agggtaa[cgt]|[acg]ttaccct"),
-    ];
-    let mut counts = vec![];
-    for variant in variants {
-        let seq = seq_arc.clone();
-        let restr = variant.to_string();
-        let future = thread::spawn(move || variant.find_iter(&seq).count());
-        counts.push((restr, future));
-    }
-
-    let substs = vec![
-        (regex!("B"), &b"(c|g|t)"[..]),
-        (regex!("D"), &b"(a|g|t)"[..]),
-        (regex!("H"), &b"(a|c|t)"[..]),
-        (regex!("K"), &b"(g|t)"[..]),
-        (regex!("M"), &b"(a|c)"[..]),
-        (regex!("N"), &b"(a|c|g|t)"[..]),
-        (regex!("R"), &b"(a|g)"[..]),
-        (regex!("S"), &b"(c|g)"[..]),
-        (regex!("V"), &b"(a|c|g)"[..]),
-        (regex!("W"), &b"(a|t)"[..]),
-        (regex!("Y"), &b"(c|t)"[..]),
-    ];
-    let mut seq = seq;
-    for (re, replacement) in substs {
-        seq = re.replace_all(&seq, replacement).into_owned();
-    }
-
-    for (variant, count) in counts {
-        println!("{} {}", variant, count.join().unwrap());
-    }
-    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
-}
diff --git a/examples/shootout-regex-dna-cheat.rs b/examples/shootout-regex-dna-cheat.rs
deleted file mode 100644
index 1bde7ab1ff..0000000000
--- a/examples/shootout-regex-dna-cheat.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-// The Computer Language Benchmarks Game
-// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
-//
-// contributed by the Rust Project Developers
-// contributed by TeXitoi
-// contributed by BurntSushi
-
-// This technically solves the problem posed in the `regex-dna` benchmark, but
-// it cheats by combining all of the replacements into a single regex and
-// replacing them with a single linear scan. i.e., it re-implements
-// `replace_all`. As a result, this is around 25% faster. ---AG
-
-use std::io::{self, Read};
-use std::sync::Arc;
-use std::thread;
-
-macro_rules! regex {
-    ($re:expr) => {
-        ::regex::Regex::new($re).unwrap()
-    };
-}
-
-fn main() {
-    let mut seq = String::with_capacity(50 * (1 << 20));
-    io::stdin().read_to_string(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
-    let clen = seq.len();
-    let seq_arc = Arc::new(seq.clone());
-
-    let variants = vec![
-        regex!("agggtaaa|tttaccct"),
-        regex!("[cgt]gggtaaa|tttaccc[acg]"),
-        regex!("a[act]ggtaaa|tttacc[agt]t"),
-        regex!("ag[act]gtaaa|tttac[agt]ct"),
-        regex!("agg[act]taaa|ttta[agt]cct"),
-        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
-        regex!("agggt[cgt]aa|tt[acg]accct"),
-        regex!("agggta[cgt]a|t[acg]taccct"),
-        regex!("agggtaa[cgt]|[acg]ttaccct"),
-    ];
-    let mut counts = vec![];
-    for variant in variants {
-        let seq = seq_arc.clone();
-        let restr = variant.to_string();
-        let future = thread::spawn(move || variant.find_iter(&seq).count());
-        counts.push((restr, future));
-    }
-
-    let substs = vec![
-        (b'B', "(c|g|t)"),
-        (b'D', "(a|g|t)"),
-        (b'H', "(a|c|t)"),
-        (b'K', "(g|t)"),
-        (b'M', "(a|c)"),
-        (b'N', "(a|c|g|t)"),
-        (b'R', "(a|g)"),
-        (b'S', "(c|g)"),
-        (b'V', "(a|c|g)"),
-        (b'W', "(a|t)"),
-        (b'Y', "(c|t)"),
-    ]; // combined into one regex in `replace_all`
-    let seq = replace_all(&seq, substs);
-
-    for (variant, count) in counts {
-        println!("{} {}", variant, count.join().unwrap());
-    }
-    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
-}
-
-fn replace_all(text: &str, substs: Vec<(u8, &str)>) -> String {
-    let mut replacements = vec![""; 256];
-    let mut alternates = vec![];
-    for (re, replacement) in substs {
-        replacements[re as usize] = replacement;
-        alternates.push((re as char).to_string());
-    }
-
-    let re = regex!(&alternates.join("|"));
-    let mut new = String::with_capacity(text.len());
-    let mut last_match = 0;
-    for m in re.find_iter(text) {
-        new.push_str(&text[last_match..m.start()]);
-        new.push_str(replacements[text.as_bytes()[m.start()] as usize]);
-        last_match = m.end();
-    }
-    new.push_str(&text[last_match..]);
-    new
-}
diff --git a/examples/shootout-regex-dna-replace.rs b/examples/shootout-regex-dna-replace.rs
deleted file mode 100644
index 20694e06f3..0000000000
--- a/examples/shootout-regex-dna-replace.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use std::io::{self, Read};
-
-macro_rules! regex {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re).build().unwrap().into_regex()
-    }};
-}
-
-fn main() {
-    let mut seq = String::with_capacity(50 * (1 << 20));
-    io::stdin().read_to_string(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
-    println!("original: {}, replaced: {}", ilen, seq.len());
-}
diff --git a/examples/shootout-regex-dna-single-cheat.rs b/examples/shootout-regex-dna-single-cheat.rs
deleted file mode 100644
index 70a979c6d4..0000000000
--- a/examples/shootout-regex-dna-single-cheat.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-// The Computer Language Benchmarks Game
-// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
-//
-// contributed by the Rust Project Developers
-// contributed by TeXitoi
-// contributed by BurntSushi
-
-use std::io::{self, Read};
-
-macro_rules! regex {
-    ($re:expr) => {
-        ::regex::Regex::new($re).unwrap()
-    };
-}
-
-fn main() {
-    let mut seq = String::with_capacity(50 * (1 << 20));
-    io::stdin().read_to_string(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
-    let clen = seq.len();
-
-    let variants = vec![
-        regex!("agggtaaa|tttaccct"),
-        regex!("[cgt]gggtaaa|tttaccc[acg]"),
-        regex!("a[act]ggtaaa|tttacc[agt]t"),
-        regex!("ag[act]gtaaa|tttac[agt]ct"),
-        regex!("agg[act]taaa|ttta[agt]cct"),
-        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
-        regex!("agggt[cgt]aa|tt[acg]accct"),
-        regex!("agggta[cgt]a|t[acg]taccct"),
-        regex!("agggtaa[cgt]|[acg]ttaccct"),
-    ];
-    for re in variants {
-        println!("{} {}", re.to_string(), re.find_iter(&seq).count());
-    }
-
-    let substs = vec![
-        (b'B', "(c|g|t)"),
-        (b'D', "(a|g|t)"),
-        (b'H', "(a|c|t)"),
-        (b'K', "(g|t)"),
-        (b'M', "(a|c)"),
-        (b'N', "(a|c|g|t)"),
-        (b'R', "(a|g)"),
-        (b'S', "(c|g)"),
-        (b'V', "(a|c|g)"),
-        (b'W', "(a|t)"),
-        (b'Y', "(c|t)"),
-    ]; // combined into one regex in `replace_all`
-    let seq = replace_all(&seq, substs);
-
-    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
-}
-
-fn replace_all(text: &str, substs: Vec<(u8, &str)>) -> String {
-    let mut replacements = vec![""; 256];
-    let mut alternates = vec![];
-    for (re, replacement) in substs {
-        replacements[re as usize] = replacement;
-        alternates.push((re as char).to_string());
-    }
-
-    let re = regex!(&alternates.join("|"));
-    let mut new = String::with_capacity(text.len());
-    let mut last_match = 0;
-    for m in re.find_iter(text) {
-        new.push_str(&text[last_match..m.start()]);
-        new.push_str(replacements[text.as_bytes()[m.start()] as usize]);
-        last_match = m.end();
-    }
-    new.push_str(&text[last_match..]);
-    new
-}
diff --git a/examples/shootout-regex-dna-single.rs b/examples/shootout-regex-dna-single.rs
deleted file mode 100644
index b474059600..0000000000
--- a/examples/shootout-regex-dna-single.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// The Computer Language Benchmarks Game
-// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
-//
-// contributed by the Rust Project Developers
-// contributed by TeXitoi
-// contributed by BurntSushi
-
-use std::io::{self, Read};
-
-macro_rules! regex {
-    ($re:expr) => {
-        ::regex::Regex::new($re).unwrap()
-    };
-}
-
-fn main() {
-    let mut seq = String::with_capacity(50 * (1 << 20));
-    io::stdin().read_to_string(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
-    let clen = seq.len();
-
-    let variants = vec![
-        regex!("agggtaaa|tttaccct"),
-        regex!("[cgt]gggtaaa|tttaccc[acg]"),
-        regex!("a[act]ggtaaa|tttacc[agt]t"),
-        regex!("ag[act]gtaaa|tttac[agt]ct"),
-        regex!("agg[act]taaa|ttta[agt]cct"),
-        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
-        regex!("agggt[cgt]aa|tt[acg]accct"),
-        regex!("agggta[cgt]a|t[acg]taccct"),
-        regex!("agggtaa[cgt]|[acg]ttaccct"),
-    ];
-    for re in variants {
-        println!("{} {}", re.to_string(), re.find_iter(&seq).count());
-    }
-
-    let substs = vec![
-        (regex!("B"), "(c|g|t)"),
-        (regex!("D"), "(a|g|t)"),
-        (regex!("H"), "(a|c|t)"),
-        (regex!("K"), "(g|t)"),
-        (regex!("M"), "(a|c)"),
-        (regex!("N"), "(a|c|g|t)"),
-        (regex!("R"), "(a|g)"),
-        (regex!("S"), "(c|g)"),
-        (regex!("V"), "(a|c|g)"),
-        (regex!("W"), "(a|t)"),
-        (regex!("Y"), "(c|t)"),
-    ];
-    let mut seq = seq;
-    for (re, replacement) in substs {
-        seq = re.replace_all(&seq, replacement).into_owned();
-    }
-    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
-}
diff --git a/examples/shootout-regex-dna.rs b/examples/shootout-regex-dna.rs
deleted file mode 100644
index b96518e4c4..0000000000
--- a/examples/shootout-regex-dna.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-// The Computer Language Benchmarks Game
-// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
-//
-// contributed by the Rust Project Developers
-// contributed by TeXitoi
-// contributed by BurntSushi
-
-use std::io::{self, Read};
-use std::sync::Arc;
-use std::thread;
-
-macro_rules! regex {
-    ($re:expr) => {
-        ::regex::Regex::new($re).unwrap()
-    };
-}
-
-fn main() {
-    let mut seq = String::with_capacity(51 * (1 << 20));
-    io::stdin().read_to_string(&mut seq).unwrap();
-    let ilen = seq.len();
-
-    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
-    let clen = seq.len();
-    let seq_arc = Arc::new(seq.clone());
-
-    let variants = vec![
-        regex!("agggtaaa|tttaccct"),
-        regex!("[cgt]gggtaaa|tttaccc[acg]"),
-        regex!("a[act]ggtaaa|tttacc[agt]t"),
-        regex!("ag[act]gtaaa|tttac[agt]ct"),
-        regex!("agg[act]taaa|ttta[agt]cct"),
-        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
-        regex!("agggt[cgt]aa|tt[acg]accct"),
-        regex!("agggta[cgt]a|t[acg]taccct"),
-        regex!("agggtaa[cgt]|[acg]ttaccct"),
-    ];
-    let mut counts = vec![];
-    for variant in variants {
-        let seq = seq_arc.clone();
-        let restr = variant.to_string();
-        let future = thread::spawn(move || variant.find_iter(&seq).count());
-        counts.push((restr, future));
-    }
-
-    let substs = vec![
-        (regex!("B"), "(c|g|t)"),
-        (regex!("D"), "(a|g|t)"),
-        (regex!("H"), "(a|c|t)"),
-        (regex!("K"), "(g|t)"),
-        (regex!("M"), "(a|c)"),
-        (regex!("N"), "(a|c|g|t)"),
-        (regex!("R"), "(a|g)"),
-        (regex!("S"), "(c|g)"),
-        (regex!("V"), "(a|c|g)"),
-        (regex!("W"), "(a|t)"),
-        (regex!("Y"), "(c|t)"),
-    ];
-    let mut seq = seq;
-    for (re, replacement) in substs {
-        seq = re.replace_all(&seq, replacement).into_owned();
-    }
-
-    for (variant, count) in counts {
-        println!("{} {}", variant, count.join().unwrap());
-    }
-    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
-}
diff --git a/fuzz/.gitignore b/fuzz/.gitignore
index a0925114d6..1a45eee776 100644
--- a/fuzz/.gitignore
+++ b/fuzz/.gitignore
@@ -1,3 +1,4 @@
 target
 corpus
 artifacts
+coverage
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index c1e2776348..8688e73e03 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,18 +1,32 @@
 [package]
 name = "regex-fuzz"
 version = "0.0.0"
-authors = ["David Korczynski <david@adalogics.com>"]
+authors = [
+  "The Rust Project Developers",
+  "David Korczynski <david@adalogics.com>",
+  "Addison Crump <me@addisoncrump.info>",
+  "Andrew Gallant <jamslam@gmail.com>",
+]
 publish = false
-edition = "2018"
+edition = "2021"
 
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
-libfuzzer-sys = "0.4.1"
+arbitrary = { version = "1.3.0", features = ["derive"] }
+libfuzzer-sys = { version = "0.4.1", features = ["arbitrary-derive"] }
+regex = { path = "..", features = ["logging"] }
+regex-automata = { path = "../regex-automata", features = ["logging"] }
+regex-lite = { path = "../regex-lite" }
+regex-syntax = { path = "../regex-syntax", features = ["arbitrary"] }
 
-[dependencies.regex]
-path = ".."
+[dependencies.env_logger]
+# Note that this is currently using an older version because of the dependency
+# tree explosion that happened in 0.10.
+version = "0.9.3"
+default-features = false
+features = ["atty", "humantime", "termcolor"]
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -22,6 +36,34 @@ members = ["."]
 name = "fuzz_regex_match"
 path = "fuzz_targets/fuzz_regex_match.rs"
 
+[[bin]]
+name = "fuzz_regex_lite_match"
+path = "fuzz_targets/fuzz_regex_lite_match.rs"
+
+[[bin]]
+name = "fuzz_regex_automata_deserialize_dense_dfa"
+path = "fuzz_targets/fuzz_regex_automata_deserialize_dense_dfa.rs"
+
+[[bin]]
+name = "fuzz_regex_automata_deserialize_sparse_dfa"
+path = "fuzz_targets/fuzz_regex_automata_deserialize_sparse_dfa.rs"
+
+[[bin]]
+name = "ast_roundtrip"
+path = "fuzz_targets/ast_roundtrip.rs"
+
+[[bin]]
+name = "ast_fuzz_match"
+path = "fuzz_targets/ast_fuzz_match.rs"
+
+[[bin]]
+name = "ast_fuzz_regex"
+path = "fuzz_targets/ast_fuzz_regex.rs"
+
+[[bin]]
+name = "ast_fuzz_match_bytes"
+path = "fuzz_targets/ast_fuzz_match_bytes.rs"
+
 [profile.release]
 opt-level = 3
 debug = true
diff --git a/fuzz/fuzz_targets/ast_fuzz_match.rs b/fuzz/fuzz_targets/ast_fuzz_match.rs
new file mode 100644
index 0000000000..58a8ebbf80
--- /dev/null
+++ b/fuzz/fuzz_targets/ast_fuzz_match.rs
@@ -0,0 +1,35 @@
+#![no_main]
+
+use {
+    libfuzzer_sys::{fuzz_target, Corpus},
+    regex::RegexBuilder,
+    regex_syntax::ast::Ast,
+};
+
+#[derive(Eq, PartialEq, arbitrary::Arbitrary)]
+struct FuzzData {
+    ast: Ast,
+    haystack: String,
+}
+
+impl std::fmt::Debug for FuzzData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("FuzzData");
+        builder.field("ast", &format!("{}", self.ast));
+        builder.field("haystack", &self.haystack);
+        builder.finish()
+    }
+}
+
+fuzz_target!(|data: FuzzData| -> Corpus {
+    let _ = env_logger::try_init();
+
+    let pattern = format!("{}", data.ast);
+    let Ok(re) = RegexBuilder::new(&pattern).size_limit(1<<20).build() else {
+        return Corpus::Reject;
+    };
+    re.is_match(&data.haystack);
+    re.find(&data.haystack);
+    re.captures(&data.haystack).map_or(0, |c| c.len());
+    Corpus::Keep
+});
diff --git a/fuzz/fuzz_targets/ast_fuzz_match_bytes.rs b/fuzz/fuzz_targets/ast_fuzz_match_bytes.rs
new file mode 100644
index 0000000000..a4fa0bd737
--- /dev/null
+++ b/fuzz/fuzz_targets/ast_fuzz_match_bytes.rs
@@ -0,0 +1,35 @@
+#![no_main]
+
+use {
+    libfuzzer_sys::{fuzz_target, Corpus},
+    regex::bytes::RegexBuilder,
+    regex_syntax::ast::Ast,
+};
+
+#[derive(arbitrary::Arbitrary, Eq, PartialEq)]
+struct FuzzData {
+    ast: Ast,
+    haystack: Vec<u8>,
+}
+
+impl std::fmt::Debug for FuzzData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("FuzzData");
+        builder.field("ast", &format!("{}", self.ast));
+        builder.field("haystack", &self.haystack);
+        builder.finish()
+    }
+}
+
+fuzz_target!(|data: FuzzData| -> Corpus {
+    let _ = env_logger::try_init();
+
+    let pattern = format!("{}", data.ast);
+    let Ok(re) = RegexBuilder::new(&pattern).size_limit(1<<20).build() else {
+        return Corpus::Reject;
+    };
+    re.is_match(&data.haystack);
+    re.find(&data.haystack);
+    re.captures(&data.haystack).map_or(0, |c| c.len());
+    Corpus::Keep
+});
diff --git a/fuzz/fuzz_targets/ast_fuzz_regex.rs b/fuzz/fuzz_targets/ast_fuzz_regex.rs
new file mode 100644
index 0000000000..1257235a92
--- /dev/null
+++ b/fuzz/fuzz_targets/ast_fuzz_regex.rs
@@ -0,0 +1,25 @@
+#![no_main]
+
+use {
+    libfuzzer_sys::fuzz_target, regex::RegexBuilder, regex_syntax::ast::Ast,
+};
+
+#[derive(Eq, PartialEq, arbitrary::Arbitrary)]
+struct FuzzData {
+    ast: Ast,
+}
+
+impl std::fmt::Debug for FuzzData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("FuzzData");
+        builder.field("ast", &format!("{}", self.ast));
+        builder.finish()
+    }
+}
+
+fuzz_target!(|data: FuzzData| {
+    let _ = env_logger::try_init();
+
+    let pattern = format!("{}", data.ast);
+    RegexBuilder::new(&pattern).size_limit(1 << 20).build().ok();
+});
diff --git a/fuzz/fuzz_targets/ast_roundtrip.rs b/fuzz/fuzz_targets/ast_roundtrip.rs
new file mode 100644
index 0000000000..040b59d631
--- /dev/null
+++ b/fuzz/fuzz_targets/ast_roundtrip.rs
@@ -0,0 +1,73 @@
+#![no_main]
+
+use {
+    libfuzzer_sys::{fuzz_target, Corpus},
+    regex_syntax::ast::{
+        parse::Parser, visit, Ast, Flag, Group, GroupKind, SetFlags, Visitor,
+    },
+};
+
+#[derive(Eq, PartialEq, arbitrary::Arbitrary)]
+struct FuzzData {
+    ast: Ast,
+}
+
+impl std::fmt::Debug for FuzzData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("FuzzData");
+        builder.field("ast", &self.ast);
+        builder.field("stringified", &format!("{}", self.ast));
+        builder.finish()
+    }
+}
+
+struct VerboseVisitor;
+
+impl Visitor for VerboseVisitor {
+    type Output = ();
+    type Err = ();
+
+    fn finish(self) -> Result<Self::Output, Self::Err> {
+        Ok(())
+    }
+
+    fn visit_pre(&mut self, ast: &Ast) -> Result<Self::Output, Self::Err> {
+        match ast {
+            Ast::Flags(SetFlags { flags, .. })
+            | Ast::Group(Group {
+                kind: GroupKind::NonCapturing(flags), ..
+            }) if flags
+                .flag_state(Flag::IgnoreWhitespace)
+                .unwrap_or(false) =>
+            {
+                Err(())
+            }
+            _ => Ok(()),
+        }
+    }
+}
+
+fuzz_target!(|data: FuzzData| -> Corpus {
+    let _ = env_logger::try_init();
+
+    let pattern = format!("{}", data.ast);
+    let Ok(ast) = Parser::new().parse(&pattern) else {
+        return Corpus::Keep;
+    };
+    if visit(&ast, VerboseVisitor).is_err() {
+        return Corpus::Reject;
+    }
+    let ast2 = Parser::new().parse(&ast.to_string()).unwrap();
+    assert_eq!(
+        ast,
+        ast2,
+        "Found difference:\
+         \nleft:  {:?}\
+         \nright: {:?}\
+         \nIf these two match, then there was a parsing difference; \
+           maybe non-determinism?",
+        ast.to_string(),
+        ast2.to_string()
+    );
+    Corpus::Keep
+});
diff --git a/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_dense_dfa.rs b/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_dense_dfa.rs
new file mode 100644
index 0000000000..07c2847313
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_dense_dfa.rs
@@ -0,0 +1,39 @@
+#![no_main]
+
+use libfuzzer_sys::{fuzz_target, Corpus};
+
+fuzz_target!(|data: &[u8]| -> Corpus {
+    run(data).map_or(Corpus::Reject, |_| Corpus::Keep)
+});
+
+fn run(given_data: &[u8]) -> Option<()> {
+    use regex_automata::dfa::Automaton;
+
+    let _ = env_logger::try_init();
+
+    if given_data.len() < 2 {
+        return None;
+    }
+    let haystack_len = usize::from(given_data[0]);
+    let haystack = given_data.get(1..1 + haystack_len)?;
+    let given_dfa_bytes = given_data.get(1 + haystack_len..)?;
+
+    // We help the fuzzer along by adding a preamble to the bytes that should
+    // at least make these first parts valid. The preamble expects a very
+    // specific sequence of bytes, so it makes sense to just force this.
+    let label = "rust-regex-automata-dfa-dense\x00\x00\x00";
+    assert_eq!(0, label.len() % 4);
+    let endianness_check = 0xFEFFu32.to_ne_bytes().to_vec();
+    let version_check = 2u32.to_ne_bytes().to_vec();
+    let mut dfa_bytes: Vec<u8> = vec![];
+    dfa_bytes.extend(label.as_bytes());
+    dfa_bytes.extend(&endianness_check);
+    dfa_bytes.extend(&version_check);
+    dfa_bytes.extend(given_dfa_bytes);
+    // This is the real test: checking that any input we give to
+    // DFA::from_bytes will never result in a panic.
+    let (dfa, _) =
+        regex_automata::dfa::dense::DFA::from_bytes(&dfa_bytes).ok()?;
+    let _ = dfa.try_search_fwd(&regex_automata::Input::new(haystack));
+    Some(())
+}
diff --git a/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_sparse_dfa.rs b/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_sparse_dfa.rs
new file mode 100644
index 0000000000..0bd15f74d9
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_regex_automata_deserialize_sparse_dfa.rs
@@ -0,0 +1,39 @@
+#![no_main]
+
+use libfuzzer_sys::{fuzz_target, Corpus};
+
+fuzz_target!(|data: &[u8]| -> Corpus {
+    run(data).map_or(Corpus::Reject, |_| Corpus::Keep)
+});
+
+fn run(given_data: &[u8]) -> Option<()> {
+    use regex_automata::dfa::Automaton;
+
+    let _ = env_logger::try_init();
+
+    if given_data.len() < 2 {
+        return None;
+    }
+    let haystack_len = usize::from(given_data[0]);
+    let haystack = given_data.get(1..1 + haystack_len)?;
+    let given_dfa_bytes = given_data.get(1 + haystack_len..)?;
+
+    // We help the fuzzer along by adding a preamble to the bytes that should
+    // at least make these first parts valid. The preamble expects a very
+    // specific sequence of bytes, so it makes sense to just force this.
+    let label = "rust-regex-automata-dfa-sparse\x00\x00";
+    assert_eq!(0, label.len() % 4);
+    let endianness_check = 0xFEFFu32.to_ne_bytes().to_vec();
+    let version_check = 2u32.to_ne_bytes().to_vec();
+    let mut dfa_bytes: Vec<u8> = vec![];
+    dfa_bytes.extend(label.as_bytes());
+    dfa_bytes.extend(&endianness_check);
+    dfa_bytes.extend(&version_check);
+    dfa_bytes.extend(given_dfa_bytes);
+    // This is the real test: checking that any input we give to
+    // DFA::from_bytes will never result in a panic.
+    let (dfa, _) =
+        regex_automata::dfa::sparse::DFA::from_bytes(&dfa_bytes).ok()?;
+    let _ = dfa.try_search_fwd(&regex_automata::Input::new(haystack));
+    Some(())
+}
diff --git a/fuzz/fuzz_targets/fuzz_regex_lite_match.rs b/fuzz/fuzz_targets/fuzz_regex_lite_match.rs
new file mode 100644
index 0000000000..579078c71e
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_regex_lite_match.rs
@@ -0,0 +1,64 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
+
+#[derive(arbitrary::Arbitrary)]
+struct FuzzCase<'a> {
+    pattern: &'a str,
+    haystack: &'a str,
+    case_insensitive: bool,
+    multi_line: bool,
+    crlf: bool,
+    dot_matches_new_line: bool,
+    swap_greed: bool,
+    ignore_whitespace: bool,
+}
+
+impl std::fmt::Debug for FuzzCase<'_> {
+    fn fmt(
+        &self,
+        fmt: &mut std::fmt::Formatter,
+    ) -> Result<(), std::fmt::Error> {
+        let FuzzCase {
+            pattern,
+            case_insensitive,
+            multi_line,
+            crlf,
+            dot_matches_new_line,
+            swap_greed,
+            ignore_whitespace,
+            haystack,
+        } = self;
+
+        write!(
+            fmt,
+            r#"
+let Ok(re) = regex_lite::RegexBuilder::new({pattern:?})
+    .case_insensitive({case_insensitive:?})
+    .multi_line({multi_line:?})
+    .crlf({crlf:?})
+    .dot_matches_new_line({dot_matches_new_line:?})
+    .swap_greed({swap_greed:?})
+    .ignore_whitespace({ignore_whitespace:?})
+    .build() else {{ return }};
+re.is_match({haystack:?});
+        "#
+        )
+    }
+}
+
+fuzz_target!(|case: FuzzCase| -> Corpus {
+    let _ = env_logger::try_init();
+
+    let Ok(re) = regex_lite::RegexBuilder::new(case.pattern)
+        .case_insensitive(case.case_insensitive)
+        .multi_line(case.multi_line)
+        .crlf(case.crlf)
+        .dot_matches_new_line(case.dot_matches_new_line)
+        .swap_greed(case.swap_greed)
+        .ignore_whitespace(case.ignore_whitespace)
+        .size_limit(1<<20)
+        .build() else { return Corpus::Reject };
+    re.is_match(case.haystack);
+    Corpus::Keep
+});
diff --git a/fuzz/fuzz_targets/fuzz_regex_match.rs b/fuzz/fuzz_targets/fuzz_regex_match.rs
index 8b3453934e..ae4d8a2d44 100644
--- a/fuzz/fuzz_targets/fuzz_regex_match.rs
+++ b/fuzz/fuzz_targets/fuzz_regex_match.rs
@@ -1,33 +1,69 @@
 #![no_main]
-use libfuzzer_sys::fuzz_target;
 
-fuzz_target!(|data: &[u8]| {
-    if data.len() < 2 {
-        return;
-    }
-    let split_point = data[0] as usize;
-    if let Ok(data) = std::str::from_utf8(&data[1..]) {
-        use std::cmp::max;
-        // split data into regular expression and actual input to search through
-        let len = data.chars().count();
-        let split_off_point = max(split_point, 1) % len as usize;
-        let char_index = data.char_indices().nth(split_off_point);
-        if let Some((char_index, _)) = char_index {
-            let (pattern, input) = data.split_at(char_index);
-            // If the haystack is big, don't use it. The issue is that
-            // the fuzzer is compiled with sanitizer options and it makes
-            // everything pretty slow. This was put in here as a result of
-            // getting timeout errors from OSS-fuzz. There's really nothing to
-            // be done about them. Unicode word boundaries in the PikeVM are
-            // slow. It is what it is.
-            if input.len() >= 8 * (1 << 10) {
-                return;
-            }
-            let result =
-                regex::RegexBuilder::new(pattern).size_limit(1 << 18).build();
-            if let Ok(re) = result {
-                re.is_match(input);
-            }
-        }
+use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
+
+#[derive(arbitrary::Arbitrary)]
+struct FuzzCase<'a> {
+    pattern: &'a str,
+    haystack: &'a str,
+    case_insensitive: bool,
+    multi_line: bool,
+    dot_matches_new_line: bool,
+    swap_greed: bool,
+    ignore_whitespace: bool,
+    unicode: bool,
+    octal: bool,
+}
+
+impl std::fmt::Debug for FuzzCase<'_> {
+    fn fmt(
+        &self,
+        fmt: &mut std::fmt::Formatter,
+    ) -> Result<(), std::fmt::Error> {
+        let FuzzCase {
+            pattern,
+            case_insensitive,
+            multi_line,
+            dot_matches_new_line,
+            swap_greed,
+            ignore_whitespace,
+            unicode,
+            octal,
+            haystack,
+        } = self;
+
+        write!(
+            fmt,
+            r#"
+let Ok(re) = regex::RegexBuilder::new({pattern:?})
+    .case_insensitive({case_insensitive:?})
+    .multi_line({multi_line:?})
+    .dot_matches_new_line({dot_matches_new_line:?})
+    .swap_greed({swap_greed:?})
+    .ignore_whitespace({ignore_whitespace:?})
+    .unicode({unicode:?})
+    .octal({octal:?})
+    .size_limit(1<<20)
+    .build() else {{ return }};
+re.is_match({haystack:?});
+        "#
+        )
     }
+}
+
+fuzz_target!(|case: FuzzCase| -> Corpus {
+    let _ = env_logger::try_init();
+
+    let Ok(re) = regex::RegexBuilder::new(case.pattern)
+        .case_insensitive(case.case_insensitive)
+        .multi_line(case.multi_line)
+        .dot_matches_new_line(case.dot_matches_new_line)
+        .swap_greed(case.swap_greed)
+        .ignore_whitespace(case.ignore_whitespace)
+        .unicode(case.unicode)
+        .octal(case.octal)
+        .size_limit(1<<20)
+        .build() else { return Corpus::Reject };
+    re.is_match(case.haystack);
+    Corpus::Keep
 });
diff --git a/bench/log/.gitignore b/record/old-bench-log/.gitignore
similarity index 100%
rename from bench/log/.gitignore
rename to record/old-bench-log/.gitignore
diff --git a/bench/log/01-lazy-dfa/dynamic b/record/old-bench-log/01-lazy-dfa/dynamic
similarity index 100%
rename from bench/log/01-lazy-dfa/dynamic
rename to record/old-bench-log/01-lazy-dfa/dynamic
diff --git a/bench/log/01-lazy-dfa/dynamic-no-lazy-dfa b/record/old-bench-log/01-lazy-dfa/dynamic-no-lazy-dfa
similarity index 100%
rename from bench/log/01-lazy-dfa/dynamic-no-lazy-dfa
rename to record/old-bench-log/01-lazy-dfa/dynamic-no-lazy-dfa
diff --git a/bench/log/01-lazy-dfa/native b/record/old-bench-log/01-lazy-dfa/native
similarity index 100%
rename from bench/log/01-lazy-dfa/native
rename to record/old-bench-log/01-lazy-dfa/native
diff --git a/bench/log/01-lazy-dfa/nfa b/record/old-bench-log/01-lazy-dfa/nfa
similarity index 100%
rename from bench/log/01-lazy-dfa/nfa
rename to record/old-bench-log/01-lazy-dfa/nfa
diff --git a/bench/log/01-lazy-dfa/pcre b/record/old-bench-log/01-lazy-dfa/pcre
similarity index 100%
rename from bench/log/01-lazy-dfa/pcre
rename to record/old-bench-log/01-lazy-dfa/pcre
diff --git a/bench/log/02-set/dynamic b/record/old-bench-log/02-set/dynamic
similarity index 100%
rename from bench/log/02-set/dynamic
rename to record/old-bench-log/02-set/dynamic
diff --git a/bench/log/03-bytes/onig b/record/old-bench-log/03-bytes/onig
similarity index 100%
rename from bench/log/03-bytes/onig
rename to record/old-bench-log/03-bytes/onig
diff --git a/bench/log/03-bytes/pcre b/record/old-bench-log/03-bytes/pcre
similarity index 100%
rename from bench/log/03-bytes/pcre
rename to record/old-bench-log/03-bytes/pcre
diff --git a/bench/log/03-bytes/rust b/record/old-bench-log/03-bytes/rust
similarity index 100%
rename from bench/log/03-bytes/rust
rename to record/old-bench-log/03-bytes/rust
diff --git a/bench/log/03-bytes/rust-bytes b/record/old-bench-log/03-bytes/rust-bytes
similarity index 100%
rename from bench/log/03-bytes/rust-bytes
rename to record/old-bench-log/03-bytes/rust-bytes
diff --git a/bench/log/04/onig b/record/old-bench-log/04/onig
similarity index 100%
rename from bench/log/04/onig
rename to record/old-bench-log/04/onig
diff --git a/bench/log/04/pcre1-jit b/record/old-bench-log/04/pcre1-jit
similarity index 100%
rename from bench/log/04/pcre1-jit
rename to record/old-bench-log/04/pcre1-jit
diff --git a/bench/log/04/pcre2-jit b/record/old-bench-log/04/pcre2-jit
similarity index 100%
rename from bench/log/04/pcre2-jit
rename to record/old-bench-log/04/pcre2-jit
diff --git a/bench/log/04/re2 b/record/old-bench-log/04/re2
similarity index 100%
rename from bench/log/04/re2
rename to record/old-bench-log/04/re2
diff --git a/bench/log/04/rust b/record/old-bench-log/04/rust
similarity index 100%
rename from bench/log/04/rust
rename to record/old-bench-log/04/rust
diff --git a/bench/log/04/tcl b/record/old-bench-log/04/tcl
similarity index 100%
rename from bench/log/04/tcl
rename to record/old-bench-log/04/tcl
diff --git a/bench/log/05/onig b/record/old-bench-log/05/onig
similarity index 100%
rename from bench/log/05/onig
rename to record/old-bench-log/05/onig
diff --git a/bench/log/05/onig-vs-rust b/record/old-bench-log/05/onig-vs-rust
similarity index 100%
rename from bench/log/05/onig-vs-rust
rename to record/old-bench-log/05/onig-vs-rust
diff --git a/bench/log/05/pcre1 b/record/old-bench-log/05/pcre1
similarity index 100%
rename from bench/log/05/pcre1
rename to record/old-bench-log/05/pcre1
diff --git a/bench/log/05/pcre1-vs-rust b/record/old-bench-log/05/pcre1-vs-rust
similarity index 100%
rename from bench/log/05/pcre1-vs-rust
rename to record/old-bench-log/05/pcre1-vs-rust
diff --git a/bench/log/05/pcre2 b/record/old-bench-log/05/pcre2
similarity index 100%
rename from bench/log/05/pcre2
rename to record/old-bench-log/05/pcre2
diff --git a/bench/log/05/pcre2-vs-rust b/record/old-bench-log/05/pcre2-vs-rust
similarity index 100%
rename from bench/log/05/pcre2-vs-rust
rename to record/old-bench-log/05/pcre2-vs-rust
diff --git a/bench/log/05/re2 b/record/old-bench-log/05/re2
similarity index 100%
rename from bench/log/05/re2
rename to record/old-bench-log/05/re2
diff --git a/bench/log/05/re2-vs-rust b/record/old-bench-log/05/re2-vs-rust
similarity index 100%
rename from bench/log/05/re2-vs-rust
rename to record/old-bench-log/05/re2-vs-rust
diff --git a/bench/log/05/rust b/record/old-bench-log/05/rust
similarity index 100%
rename from bench/log/05/rust
rename to record/old-bench-log/05/rust
diff --git a/bench/log/05/tcl b/record/old-bench-log/05/tcl
similarity index 100%
rename from bench/log/05/tcl
rename to record/old-bench-log/05/tcl
diff --git a/bench/log/05/tcl-vs-rust b/record/old-bench-log/05/tcl-vs-rust
similarity index 100%
rename from bench/log/05/tcl-vs-rust
rename to record/old-bench-log/05/tcl-vs-rust
diff --git a/bench/log/06/dphobos-dmd b/record/old-bench-log/06/dphobos-dmd
similarity index 100%
rename from bench/log/06/dphobos-dmd
rename to record/old-bench-log/06/dphobos-dmd
diff --git a/bench/log/06/dphobos-dmd-ct b/record/old-bench-log/06/dphobos-dmd-ct
similarity index 100%
rename from bench/log/06/dphobos-dmd-ct
rename to record/old-bench-log/06/dphobos-dmd-ct
diff --git a/bench/log/06/dphobos-ldc b/record/old-bench-log/06/dphobos-ldc
similarity index 100%
rename from bench/log/06/dphobos-ldc
rename to record/old-bench-log/06/dphobos-ldc
diff --git a/bench/log/06/dphobos-ldc-ct b/record/old-bench-log/06/dphobos-ldc-ct
similarity index 100%
rename from bench/log/06/dphobos-ldc-ct
rename to record/old-bench-log/06/dphobos-ldc-ct
diff --git a/bench/log/06/pcre1 b/record/old-bench-log/06/pcre1
similarity index 100%
rename from bench/log/06/pcre1
rename to record/old-bench-log/06/pcre1
diff --git a/bench/log/06/pcre2 b/record/old-bench-log/06/pcre2
similarity index 100%
rename from bench/log/06/pcre2
rename to record/old-bench-log/06/pcre2
diff --git a/bench/log/06/re2 b/record/old-bench-log/06/re2
similarity index 100%
rename from bench/log/06/re2
rename to record/old-bench-log/06/re2
diff --git a/bench/log/06/rust b/record/old-bench-log/06/rust
similarity index 100%
rename from bench/log/06/rust
rename to record/old-bench-log/06/rust
diff --git a/bench/log/07/boost b/record/old-bench-log/07/boost
similarity index 100%
rename from bench/log/07/boost
rename to record/old-bench-log/07/boost
diff --git a/bench/log/07/dphobos-dmd b/record/old-bench-log/07/dphobos-dmd
similarity index 100%
rename from bench/log/07/dphobos-dmd
rename to record/old-bench-log/07/dphobos-dmd
diff --git a/bench/log/07/dphobos-dmd-ct b/record/old-bench-log/07/dphobos-dmd-ct
similarity index 100%
rename from bench/log/07/dphobos-dmd-ct
rename to record/old-bench-log/07/dphobos-dmd-ct
diff --git a/bench/log/07/oniguruma b/record/old-bench-log/07/oniguruma
similarity index 100%
rename from bench/log/07/oniguruma
rename to record/old-bench-log/07/oniguruma
diff --git a/bench/log/07/pcre1 b/record/old-bench-log/07/pcre1
similarity index 100%
rename from bench/log/07/pcre1
rename to record/old-bench-log/07/pcre1
diff --git a/bench/log/07/pcre2 b/record/old-bench-log/07/pcre2
similarity index 100%
rename from bench/log/07/pcre2
rename to record/old-bench-log/07/pcre2
diff --git a/bench/log/07/re2 b/record/old-bench-log/07/re2
similarity index 100%
rename from bench/log/07/re2
rename to record/old-bench-log/07/re2
diff --git a/bench/log/07/rust b/record/old-bench-log/07/rust
similarity index 100%
rename from bench/log/07/rust
rename to record/old-bench-log/07/rust
diff --git a/bench/log/07/rust-bytes b/record/old-bench-log/07/rust-bytes
similarity index 100%
rename from bench/log/07/rust-bytes
rename to record/old-bench-log/07/rust-bytes
diff --git a/bench/log/07/stdcpp b/record/old-bench-log/07/stdcpp
similarity index 100%
rename from bench/log/07/stdcpp
rename to record/old-bench-log/07/stdcpp
diff --git a/bench/log/07/stdcpp-libcxx b/record/old-bench-log/07/stdcpp-libcxx
similarity index 100%
rename from bench/log/07/stdcpp-libcxx
rename to record/old-bench-log/07/stdcpp-libcxx
diff --git a/bench/log/07/tcl b/record/old-bench-log/07/tcl
similarity index 100%
rename from bench/log/07/tcl
rename to record/old-bench-log/07/tcl
diff --git a/bench/log/08-new-memmem/rust-after-01 b/record/old-bench-log/08-new-memmem/rust-after-01
similarity index 100%
rename from bench/log/08-new-memmem/rust-after-01
rename to record/old-bench-log/08-new-memmem/rust-after-01
diff --git a/bench/log/08-new-memmem/rust-after-02 b/record/old-bench-log/08-new-memmem/rust-after-02
similarity index 100%
rename from bench/log/08-new-memmem/rust-after-02
rename to record/old-bench-log/08-new-memmem/rust-after-02
diff --git a/bench/log/08-new-memmem/rust-before-01 b/record/old-bench-log/08-new-memmem/rust-before-01
similarity index 100%
rename from bench/log/08-new-memmem/rust-before-01
rename to record/old-bench-log/08-new-memmem/rust-before-01
diff --git a/bench/log/08-new-memmem/rust-before-02 b/record/old-bench-log/08-new-memmem/rust-before-02
similarity index 100%
rename from bench/log/08-new-memmem/rust-before-02
rename to record/old-bench-log/08-new-memmem/rust-before-02
diff --git a/bench/log/09-new-baseline/pcre2 b/record/old-bench-log/09-new-baseline/pcre2
similarity index 100%
rename from bench/log/09-new-baseline/pcre2
rename to record/old-bench-log/09-new-baseline/pcre2
diff --git a/bench/log/09-new-baseline/re2 b/record/old-bench-log/09-new-baseline/re2
similarity index 100%
rename from bench/log/09-new-baseline/re2
rename to record/old-bench-log/09-new-baseline/re2
diff --git a/bench/log/09-new-baseline/rust b/record/old-bench-log/09-new-baseline/rust
similarity index 100%
rename from bench/log/09-new-baseline/rust
rename to record/old-bench-log/09-new-baseline/rust
diff --git a/bench/log/09-new-baseline/rust-bytes b/record/old-bench-log/09-new-baseline/rust-bytes
similarity index 100%
rename from bench/log/09-new-baseline/rust-bytes
rename to record/old-bench-log/09-new-baseline/rust-bytes
diff --git a/bench/log/10-last-frontier/rust-after-literal.log b/record/old-bench-log/10-last-frontier/rust-after-literal.log
similarity index 100%
rename from bench/log/10-last-frontier/rust-after-literal.log
rename to record/old-bench-log/10-last-frontier/rust-after-literal.log
diff --git a/bench/log/10-last-frontier/rust-before-literal.log b/record/old-bench-log/10-last-frontier/rust-before-literal.log
similarity index 100%
rename from bench/log/10-last-frontier/rust-before-literal.log
rename to record/old-bench-log/10-last-frontier/rust-before-literal.log
diff --git a/bench/log/10-last-frontier/rust-bytes-after-literal.log b/record/old-bench-log/10-last-frontier/rust-bytes-after-literal.log
similarity index 100%
rename from bench/log/10-last-frontier/rust-bytes-after-literal.log
rename to record/old-bench-log/10-last-frontier/rust-bytes-after-literal.log
diff --git a/bench/log/10-last-frontier/rust-bytes-before-literal.log b/record/old-bench-log/10-last-frontier/rust-bytes-before-literal.log
similarity index 100%
rename from bench/log/10-last-frontier/rust-bytes-before-literal.log
rename to record/old-bench-log/10-last-frontier/rust-bytes-before-literal.log
diff --git a/record/old-bench-log/11-regex-1.7.3/rust b/record/old-bench-log/11-regex-1.7.3/rust
new file mode 100644
index 0000000000..aed99af927
--- /dev/null
+++ b/record/old-bench-log/11-regex-1.7.3/rust
@@ -0,0 +1,124 @@
+
+running 119 tests
+test misc::anchored_literal_long_match       ... bench:           7 ns/iter (+/- 0) = 55714 MB/s
+test misc::anchored_literal_long_non_match   ... bench:          10 ns/iter (+/- 0) = 39000 MB/s
+test misc::anchored_literal_short_match      ... bench:           7 ns/iter (+/- 0) = 3714 MB/s
+test misc::anchored_literal_short_non_match  ... bench:          10 ns/iter (+/- 0) = 2600 MB/s
+test misc::easy0_1K                          ... bench:           7 ns/iter (+/- 0) = 150142 MB/s
+test misc::easy0_1MB                         ... bench:          11 ns/iter (+/- 1) = 95327545 MB/s
+test misc::easy0_32                          ... bench:           7 ns/iter (+/- 0) = 8428 MB/s
+test misc::easy0_32K                         ... bench:           7 ns/iter (+/- 0) = 4685000 MB/s
+test misc::easy1_1K                          ... bench:          17 ns/iter (+/- 1) = 61411 MB/s
+test misc::easy1_1MB                         ... bench:          20 ns/iter (+/- 0) = 52429800 MB/s
+test misc::easy1_32                          ... bench:          18 ns/iter (+/- 1) = 2888 MB/s
+test misc::easy1_32K                         ... bench:          18 ns/iter (+/- 0) = 1821555 MB/s
+test misc::hard_1K                           ... bench:          24 ns/iter (+/- 0) = 43791 MB/s
+test misc::hard_1MB                          ... bench:          28 ns/iter (+/- 0) = 37450107 MB/s
+test misc::hard_32                           ... bench:          24 ns/iter (+/- 0) = 2458 MB/s
+test misc::hard_32K                          ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::is_match_set                      ... bench:          37 ns/iter (+/- 0) = 675 MB/s
+test misc::literal                           ... bench:           8 ns/iter (+/- 1) = 6375 MB/s
+test misc::long_needle1                      ... bench:       1,785 ns/iter (+/- 1) = 56022 MB/s
+test misc::long_needle2                      ... bench:     193,595 ns/iter (+/- 1,486) = 516 MB/s
+test misc::match_class                       ... bench:          37 ns/iter (+/- 1) = 2189 MB/s
+test misc::match_class_in_range              ... bench:           8 ns/iter (+/- 0) = 10125 MB/s
+test misc::match_class_unicode               ... bench:         181 ns/iter (+/- 1) = 889 MB/s
+test misc::matches_set                       ... bench:         216 ns/iter (+/- 9) = 115 MB/s
+test misc::medium_1K                         ... bench:           7 ns/iter (+/- 0) = 150285 MB/s
+test misc::medium_1MB                        ... bench:          12 ns/iter (+/- 1) = 87383666 MB/s
+test misc::medium_32                         ... bench:           7 ns/iter (+/- 0) = 8571 MB/s
+test misc::medium_32K                        ... bench:           7 ns/iter (+/- 0) = 4685142 MB/s
+test misc::no_exponential                    ... bench:         283 ns/iter (+/- 7) = 353 MB/s
+test misc::not_literal                       ... bench:          53 ns/iter (+/- 1) = 962 MB/s
+test misc::one_pass_long_prefix              ... bench:          24 ns/iter (+/- 2) = 1083 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          24 ns/iter (+/- 2) = 1083 MB/s
+test misc::one_pass_short                    ... bench:          16 ns/iter (+/- 0) = 1062 MB/s
+test misc::one_pass_short_not                ... bench:          19 ns/iter (+/- 0) = 894 MB/s
+test misc::reallyhard2_1K                    ... bench:          41 ns/iter (+/- 0) = 25365 MB/s
+test misc::reallyhard_1K                     ... bench:       1,208 ns/iter (+/- 2) = 870 MB/s
+test misc::reallyhard_1MB                    ... bench:   1,213,959 ns/iter (+/- 7,198) = 863 MB/s
+test misc::reallyhard_32                     ... bench:          62 ns/iter (+/- 0) = 951 MB/s
+test misc::reallyhard_32K                    ... bench:      38,231 ns/iter (+/- 354) = 857 MB/s
+test misc::replace_all                       ... bench:          86 ns/iter (+/- 3)
+test misc::reverse_suffix_no_quadratic       ... bench:       2,351 ns/iter (+/- 31) = 3402 MB/s
+test misc::short_haystack_1000000x           ... bench:      91,018 ns/iter (+/- 203) = 87894 MB/s
+test misc::short_haystack_100000x            ... bench:       9,277 ns/iter (+/- 40) = 86235 MB/s
+test misc::short_haystack_10000x             ... bench:       2,863 ns/iter (+/- 4) = 27946 MB/s
+test misc::short_haystack_1000x              ... bench:         201 ns/iter (+/- 3) = 39855 MB/s
+test misc::short_haystack_100x               ... bench:         100 ns/iter (+/- 2) = 8110 MB/s
+test misc::short_haystack_10x                ... bench:          88 ns/iter (+/- 0) = 1034 MB/s
+test misc::short_haystack_1x                 ... bench:          86 ns/iter (+/- 1) = 220 MB/s
+test misc::short_haystack_2x                 ... bench:          87 ns/iter (+/- 0) = 310 MB/s
+test misc::short_haystack_3x                 ... bench:          88 ns/iter (+/- 1) = 397 MB/s
+test misc::short_haystack_4x                 ... bench:          88 ns/iter (+/- 1) = 488 MB/s
+test regexdna::find_new_lines                ... bench:   7,348,651 ns/iter (+/- 40,559) = 691 MB/s
+test regexdna::subst1                        ... bench:     493,624 ns/iter (+/- 10,315) = 10298 MB/s
+test regexdna::subst10                       ... bench:     489,573 ns/iter (+/- 18,151) = 10383 MB/s
+test regexdna::subst11                       ... bench:     492,501 ns/iter (+/- 11,650) = 10321 MB/s
+test regexdna::subst2                        ... bench:     492,283 ns/iter (+/- 12,363) = 10326 MB/s
+test regexdna::subst3                        ... bench:     496,795 ns/iter (+/- 20,704) = 10232 MB/s
+test regexdna::subst4                        ... bench:     489,245 ns/iter (+/- 10,289) = 10390 MB/s
+test regexdna::subst5                        ... bench:     499,701 ns/iter (+/- 11,359) = 10172 MB/s
+test regexdna::subst6                        ... bench:     490,460 ns/iter (+/- 8,758) = 10364 MB/s
+test regexdna::subst7                        ... bench:     496,398 ns/iter (+/- 18,774) = 10240 MB/s
+test regexdna::subst8                        ... bench:     497,077 ns/iter (+/- 24,767) = 10226 MB/s
+test regexdna::subst9                        ... bench:     496,763 ns/iter (+/- 12,477) = 10233 MB/s
+test regexdna::variant1                      ... bench:   1,454,747 ns/iter (+/- 48,995) = 3494 MB/s
+test regexdna::variant2                      ... bench:   2,311,001 ns/iter (+/- 63,347) = 2199 MB/s
+test regexdna::variant3                      ... bench:   2,832,483 ns/iter (+/- 33,976) = 1794 MB/s
+test regexdna::variant4                      ... bench:   2,796,710 ns/iter (+/- 56,279) = 1817 MB/s
+test regexdna::variant5                      ... bench:   1,708,634 ns/iter (+/- 25,749) = 2975 MB/s
+test regexdna::variant6                      ... bench:   1,706,259 ns/iter (+/- 22,151) = 2979 MB/s
+test regexdna::variant7                      ... bench:   2,400,436 ns/iter (+/- 24,655) = 2117 MB/s
+test regexdna::variant8                      ... bench:   2,413,765 ns/iter (+/- 50,326) = 2106 MB/s
+test regexdna::variant9                      ... bench:   2,402,528 ns/iter (+/- 26,150) = 2115 MB/s
+test rust_compile::compile_huge              ... bench:      51,936 ns/iter (+/- 834)
+test rust_compile::compile_huge_bytes        ... bench:   3,294,633 ns/iter (+/- 40,585)
+test rust_compile::compile_huge_full         ... bench:   6,323,294 ns/iter (+/- 66,684)
+test rust_compile::compile_simple            ... bench:       1,992 ns/iter (+/- 25)
+test rust_compile::compile_simple_bytes      ... bench:       2,004 ns/iter (+/- 20)
+test rust_compile::compile_simple_full       ... bench:       9,697 ns/iter (+/- 68)
+test rust_compile::compile_small             ... bench:       4,261 ns/iter (+/- 72)
+test rust_compile::compile_small_bytes       ... bench:      83,908 ns/iter (+/- 1,405)
+test rust_compile::compile_small_full        ... bench:     166,152 ns/iter (+/- 3,508)
+test sherlock::before_after_holmes           ... bench:     699,767 ns/iter (+/- 6,201) = 850 MB/s
+test sherlock::before_holmes                 ... bench:      29,284 ns/iter (+/- 573) = 20315 MB/s
+test sherlock::everything_greedy             ... bench:   1,070,812 ns/iter (+/- 18,795) = 555 MB/s
+test sherlock::everything_greedy_nl          ... bench:     445,517 ns/iter (+/- 7,760) = 1335 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      43,459 ns/iter (+/- 901) = 13689 MB/s
+test sherlock::holmes_coword_watson          ... bench:     335,772 ns/iter (+/- 6,348) = 1771 MB/s
+test sherlock::ing_suffix                    ... bench:     153,546 ns/iter (+/- 3,075) = 3874 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     777,388 ns/iter (+/- 8,447) = 765 MB/s
+test sherlock::letters                       ... bench:  10,123,374 ns/iter (+/- 90,059) = 58 MB/s
+test sherlock::letters_lower                 ... bench:   9,957,916 ns/iter (+/- 63,766) = 59 MB/s
+test sherlock::letters_upper                 ... bench:   1,123,119 ns/iter (+/- 17,972) = 529 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:     694,714 ns/iter (+/- 7,006) = 856 MB/s
+test sherlock::name_alt1                     ... bench:      13,427 ns/iter (+/- 331) = 44308 MB/s
+test sherlock::name_alt2                     ... bench:      33,171 ns/iter (+/- 1,029) = 17935 MB/s
+test sherlock::name_alt3                     ... bench:      36,816 ns/iter (+/- 1,138) = 16159 MB/s
+test sherlock::name_alt3_nocase              ... bench:     221,185 ns/iter (+/- 3,268) = 2689 MB/s
+test sherlock::name_alt4                     ... bench:      49,883 ns/iter (+/- 1,150) = 11926 MB/s
+test sherlock::name_alt4_nocase              ... bench:      74,967 ns/iter (+/- 1,807) = 7935 MB/s
+test sherlock::name_alt5                     ... bench:      34,675 ns/iter (+/- 1,335) = 17157 MB/s
+test sherlock::name_alt5_nocase              ... bench:     192,109 ns/iter (+/- 6,194) = 3096 MB/s
+test sherlock::name_holmes                   ... bench:      18,355 ns/iter (+/- 389) = 32412 MB/s
+test sherlock::name_holmes_nocase            ... bench:      58,179 ns/iter (+/- 917) = 10225 MB/s
+test sherlock::name_sherlock                 ... bench:      14,307 ns/iter (+/- 74) = 41583 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,332 ns/iter (+/- 144) = 41510 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      41,336 ns/iter (+/- 736) = 14392 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      40,029 ns/iter (+/- 1,393) = 14862 MB/s
+test sherlock::name_whitespace               ... bench:      17,807 ns/iter (+/- 105) = 33410 MB/s
+test sherlock::no_match_common               ... bench:      13,625 ns/iter (+/- 15) = 43664 MB/s
+test sherlock::no_match_really_common        ... bench:      13,818 ns/iter (+/- 282) = 43054 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,628 ns/iter (+/- 27) = 43655 MB/s
+test sherlock::quotes                        ... bench:     232,910 ns/iter (+/- 1,883) = 2554 MB/s
+test sherlock::repeated_class_negation       ... bench:  36,892,964 ns/iter (+/- 629,538) = 16 MB/s
+test sherlock::the_lower                     ... bench:     203,077 ns/iter (+/- 2,574) = 2929 MB/s
+test sherlock::the_nocase                    ... bench:     290,781 ns/iter (+/- 6,597) = 2045 MB/s
+test sherlock::the_upper                     ... bench:      22,731 ns/iter (+/- 439) = 26172 MB/s
+test sherlock::the_whitespace                ... bench:     423,983 ns/iter (+/- 10,849) = 1403 MB/s
+test sherlock::word_ending_n                 ... bench:   1,109,013 ns/iter (+/- 12,645) = 536 MB/s
+test sherlock::words                         ... bench:   4,529,451 ns/iter (+/- 44,285) = 131 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 119 measured; 0 filtered out; finished in 164.08s
+
diff --git a/record/old-bench-log/11-regex-1.7.3/rust-bytes b/record/old-bench-log/11-regex-1.7.3/rust-bytes
new file mode 100644
index 0000000000..e9f750ebdf
--- /dev/null
+++ b/record/old-bench-log/11-regex-1.7.3/rust-bytes
@@ -0,0 +1,112 @@
+
+running 107 tests
+test misc::anchored_literal_long_match       ... bench:           8 ns/iter (+/- 0) = 48750 MB/s
+test misc::anchored_literal_long_non_match   ... bench:          10 ns/iter (+/- 0) = 39000 MB/s
+test misc::anchored_literal_short_match      ... bench:           7 ns/iter (+/- 0) = 3714 MB/s
+test misc::anchored_literal_short_non_match  ... bench:          10 ns/iter (+/- 0) = 2600 MB/s
+test misc::easy0_1K                          ... bench:           7 ns/iter (+/- 0) = 150142 MB/s
+test misc::easy0_1MB                         ... bench:          11 ns/iter (+/- 0) = 95327545 MB/s
+test misc::easy0_32                          ... bench:           7 ns/iter (+/- 0) = 8428 MB/s
+test misc::easy0_32K                         ... bench:           7 ns/iter (+/- 0) = 4685000 MB/s
+test misc::easy1_1K                          ... bench:          17 ns/iter (+/- 0) = 61411 MB/s
+test misc::easy1_1MB                         ... bench:          20 ns/iter (+/- 0) = 52429800 MB/s
+test misc::easy1_32                          ... bench:          18 ns/iter (+/- 0) = 2888 MB/s
+test misc::easy1_32K                         ... bench:          18 ns/iter (+/- 0) = 1821555 MB/s
+test misc::hard_1K                           ... bench:          24 ns/iter (+/- 0) = 43791 MB/s
+test misc::hard_1MB                          ... bench:          28 ns/iter (+/- 0) = 37450107 MB/s
+test misc::hard_32                           ... bench:          24 ns/iter (+/- 0) = 2458 MB/s
+test misc::hard_32K                          ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::is_match_set                      ... bench:          37 ns/iter (+/- 0) = 675 MB/s
+test misc::literal                           ... bench:           7 ns/iter (+/- 0) = 7285 MB/s
+test misc::long_needle1                      ... bench:       2,186 ns/iter (+/- 19) = 45746 MB/s
+test misc::long_needle2                      ... bench:     210,378 ns/iter (+/- 61,574) = 475 MB/s
+test misc::match_class                       ... bench:          39 ns/iter (+/- 1) = 2076 MB/s
+test misc::match_class_in_range              ... bench:           7 ns/iter (+/- 0) = 11571 MB/s
+test misc::matches_set                       ... bench:         176 ns/iter (+/- 12) = 142 MB/s
+test misc::medium_1K                         ... bench:           8 ns/iter (+/- 0) = 131500 MB/s
+test misc::medium_1MB                        ... bench:          12 ns/iter (+/- 0) = 87383666 MB/s
+test misc::medium_32                         ... bench:           8 ns/iter (+/- 0) = 7500 MB/s
+test misc::medium_32K                        ... bench:           8 ns/iter (+/- 0) = 4099500 MB/s
+test misc::no_exponential                    ... bench:         274 ns/iter (+/- 7) = 364 MB/s
+test misc::not_literal                       ... bench:          53 ns/iter (+/- 0) = 962 MB/s
+test misc::one_pass_long_prefix              ... bench:          24 ns/iter (+/- 2) = 1083 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          24 ns/iter (+/- 1) = 1083 MB/s
+test misc::one_pass_short                    ... bench:          16 ns/iter (+/- 1) = 1062 MB/s
+test misc::one_pass_short_not                ... bench:          19 ns/iter (+/- 0) = 894 MB/s
+test misc::reallyhard2_1K                    ... bench:          38 ns/iter (+/- 5) = 27368 MB/s
+test misc::reallyhard_1K                     ... bench:       1,220 ns/iter (+/- 15) = 861 MB/s
+test misc::reallyhard_1MB                    ... bench:   1,215,297 ns/iter (+/- 5,229) = 862 MB/s
+test misc::reallyhard_32                     ... bench:          63 ns/iter (+/- 1) = 936 MB/s
+test misc::reallyhard_32K                    ... bench:      38,164 ns/iter (+/- 232) = 859 MB/s
+test misc::reverse_suffix_no_quadratic       ... bench:       2,353 ns/iter (+/- 8) = 3399 MB/s
+test regexdna::find_new_lines                ... bench:   7,346,276 ns/iter (+/- 46,149) = 691 MB/s
+test regexdna::subst1                        ... bench:     486,203 ns/iter (+/- 21,159) = 10455 MB/s
+test regexdna::subst10                       ... bench:     494,356 ns/iter (+/- 6,423) = 10282 MB/s
+test regexdna::subst11                       ... bench:     481,930 ns/iter (+/- 19,639) = 10548 MB/s
+test regexdna::subst2                        ... bench:     486,672 ns/iter (+/- 22,184) = 10445 MB/s
+test regexdna::subst3                        ... bench:     487,152 ns/iter (+/- 19,776) = 10434 MB/s
+test regexdna::subst4                        ... bench:     486,534 ns/iter (+/- 23,897) = 10448 MB/s
+test regexdna::subst5                        ... bench:     481,412 ns/iter (+/- 26,310) = 10559 MB/s
+test regexdna::subst6                        ... bench:     479,498 ns/iter (+/- 20,310) = 10601 MB/s
+test regexdna::subst7                        ... bench:     481,960 ns/iter (+/- 18,492) = 10547 MB/s
+test regexdna::subst8                        ... bench:     482,282 ns/iter (+/- 22,522) = 10540 MB/s
+test regexdna::subst9                        ... bench:     489,224 ns/iter (+/- 25,264) = 10390 MB/s
+test regexdna::variant1                      ... bench:   1,470,068 ns/iter (+/- 65,563) = 3457 MB/s
+test regexdna::variant2                      ... bench:   2,298,112 ns/iter (+/- 27,688) = 2211 MB/s
+test regexdna::variant3                      ... bench:   2,818,539 ns/iter (+/- 31,432) = 1803 MB/s
+test regexdna::variant4                      ... bench:   2,786,226 ns/iter (+/- 30,699) = 1824 MB/s
+test regexdna::variant5                      ... bench:   1,716,429 ns/iter (+/- 20,264) = 2961 MB/s
+test regexdna::variant6                      ... bench:   1,719,420 ns/iter (+/- 23,944) = 2956 MB/s
+test regexdna::variant7                      ... bench:   2,391,022 ns/iter (+/- 23,192) = 2126 MB/s
+test regexdna::variant8                      ... bench:   2,418,744 ns/iter (+/- 44,152) = 2101 MB/s
+test regexdna::variant9                      ... bench:   2,400,918 ns/iter (+/- 24,041) = 2117 MB/s
+test rust_compile::compile_huge              ... bench:      57,745 ns/iter (+/- 816)
+test rust_compile::compile_huge_bytes        ... bench:   3,346,952 ns/iter (+/- 39,488)
+test rust_compile::compile_huge_full         ... bench:   6,344,293 ns/iter (+/- 53,114)
+test rust_compile::compile_simple            ... bench:       2,040 ns/iter (+/- 32)
+test rust_compile::compile_simple_bytes      ... bench:       2,010 ns/iter (+/- 34)
+test rust_compile::compile_simple_full       ... bench:       9,632 ns/iter (+/- 464)
+test rust_compile::compile_small             ... bench:       4,445 ns/iter (+/- 77)
+test rust_compile::compile_small_bytes       ... bench:      83,791 ns/iter (+/- 1,929)
+test rust_compile::compile_small_full        ... bench:     164,948 ns/iter (+/- 2,595)
+test sherlock::before_after_holmes           ... bench:     699,996 ns/iter (+/- 6,647) = 849 MB/s
+test sherlock::before_holmes                 ... bench:      28,208 ns/iter (+/- 233) = 21090 MB/s
+test sherlock::everything_greedy             ... bench:   1,033,048 ns/iter (+/- 9,790) = 575 MB/s
+test sherlock::everything_greedy_nl          ... bench:     424,081 ns/iter (+/- 22,574) = 1402 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      43,131 ns/iter (+/- 827) = 13793 MB/s
+test sherlock::holmes_coword_watson          ... bench:     336,678 ns/iter (+/- 6,985) = 1767 MB/s
+test sherlock::ing_suffix                    ... bench:     153,589 ns/iter (+/- 3,193) = 3873 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     776,911 ns/iter (+/- 8,815) = 765 MB/s
+test sherlock::letters                       ... bench:  10,056,702 ns/iter (+/- 49,688) = 59 MB/s
+test sherlock::letters_lower                 ... bench:   9,900,568 ns/iter (+/- 76,118) = 60 MB/s
+test sherlock::letters_upper                 ... bench:   1,120,456 ns/iter (+/- 13,538) = 530 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:     693,727 ns/iter (+/- 6,840) = 857 MB/s
+test sherlock::name_alt1                     ... bench:      11,101 ns/iter (+/- 65) = 53592 MB/s
+test sherlock::name_alt2                     ... bench:      34,003 ns/iter (+/- 966) = 17496 MB/s
+test sherlock::name_alt3                     ... bench:      37,975 ns/iter (+/- 1,313) = 15666 MB/s
+test sherlock::name_alt3_nocase              ... bench:     214,299 ns/iter (+/- 3,026) = 2776 MB/s
+test sherlock::name_alt4                     ... bench:      50,551 ns/iter (+/- 1,377) = 11768 MB/s
+test sherlock::name_alt4_nocase              ... bench:      74,713 ns/iter (+/- 1,359) = 7962 MB/s
+test sherlock::name_alt5                     ... bench:      35,426 ns/iter (+/- 625) = 16793 MB/s
+test sherlock::name_alt5_nocase              ... bench:     190,521 ns/iter (+/- 4,903) = 3122 MB/s
+test sherlock::name_holmes                   ... bench:      18,070 ns/iter (+/- 763) = 32923 MB/s
+test sherlock::name_holmes_nocase            ... bench:      58,454 ns/iter (+/- 1,228) = 10177 MB/s
+test sherlock::name_sherlock                 ... bench:      14,380 ns/iter (+/- 227) = 41372 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,491 ns/iter (+/- 116) = 41055 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      40,722 ns/iter (+/- 231) = 14609 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      39,937 ns/iter (+/- 623) = 14896 MB/s
+test sherlock::name_whitespace               ... bench:      17,979 ns/iter (+/- 140) = 33090 MB/s
+test sherlock::no_match_common               ... bench:      13,650 ns/iter (+/- 112) = 43584 MB/s
+test sherlock::no_match_really_common        ... bench:      13,623 ns/iter (+/- 295) = 43671 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,641 ns/iter (+/- 55) = 43613 MB/s
+test sherlock::quotes                        ... bench:     232,451 ns/iter (+/- 6,555) = 2559 MB/s
+test sherlock::repeated_class_negation       ... bench:  36,984,199 ns/iter (+/- 623,153) = 16 MB/s
+test sherlock::the_lower                     ... bench:     189,502 ns/iter (+/- 4,870) = 3139 MB/s
+test sherlock::the_nocase                    ... bench:     294,945 ns/iter (+/- 9,381) = 2017 MB/s
+test sherlock::the_upper                     ... bench:      21,591 ns/iter (+/- 680) = 27554 MB/s
+test sherlock::the_whitespace                ... bench:     424,862 ns/iter (+/- 7,197) = 1400 MB/s
+test sherlock::word_ending_n                 ... bench:   1,126,768 ns/iter (+/- 13,900) = 527 MB/s
+test sherlock::words                         ... bench:   4,517,167 ns/iter (+/- 55,809) = 131 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 107 measured; 0 filtered out; finished in 150.58s
+
diff --git a/record/old-bench-log/12-regex-1.8.1/rust b/record/old-bench-log/12-regex-1.8.1/rust
new file mode 100644
index 0000000000..282893e55e
--- /dev/null
+++ b/record/old-bench-log/12-regex-1.8.1/rust
@@ -0,0 +1,124 @@
+
+running 119 tests
+test misc::anchored_literal_long_match       ... bench:           8 ns/iter (+/- 0) = 48750 MB/s
+test misc::anchored_literal_long_non_match   ... bench:           9 ns/iter (+/- 0) = 43333 MB/s
+test misc::anchored_literal_short_match      ... bench:           7 ns/iter (+/- 0) = 3714 MB/s
+test misc::anchored_literal_short_non_match  ... bench:           9 ns/iter (+/- 0) = 2888 MB/s
+test misc::easy0_1K                          ... bench:          24 ns/iter (+/- 1) = 43791 MB/s
+test misc::easy0_1MB                         ... bench:          28 ns/iter (+/- 0) = 37450107 MB/s
+test misc::easy0_32                          ... bench:          25 ns/iter (+/- 0) = 2360 MB/s
+test misc::easy0_32K                         ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::easy1_1K                          ... bench:          18 ns/iter (+/- 1) = 58000 MB/s
+test misc::easy1_1MB                         ... bench:          21 ns/iter (+/- 0) = 49933142 MB/s
+test misc::easy1_32                          ... bench:          18 ns/iter (+/- 0) = 2888 MB/s
+test misc::easy1_32K                         ... bench:          18 ns/iter (+/- 0) = 1821555 MB/s
+test misc::hard_1K                           ... bench:          24 ns/iter (+/- 0) = 43791 MB/s
+test misc::hard_1MB                          ... bench:          29 ns/iter (+/- 0) = 36158724 MB/s
+test misc::hard_32                           ... bench:          24 ns/iter (+/- 0) = 2458 MB/s
+test misc::hard_32K                          ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::is_match_set                      ... bench:          37 ns/iter (+/- 0) = 675 MB/s
+test misc::literal                           ... bench:           7 ns/iter (+/- 0) = 7285 MB/s
+test misc::long_needle1                      ... bench:       1,802 ns/iter (+/- 6) = 55494 MB/s
+test misc::long_needle2                      ... bench:     207,353 ns/iter (+/- 165) = 482 MB/s
+test misc::match_class                       ... bench:          41 ns/iter (+/- 2) = 1975 MB/s
+test misc::match_class_in_range              ... bench:           7 ns/iter (+/- 0) = 11571 MB/s
+test misc::match_class_unicode               ... bench:         168 ns/iter (+/- 3) = 958 MB/s
+test misc::matches_set                       ... bench:         210 ns/iter (+/- 5) = 119 MB/s
+test misc::medium_1K                         ... bench:          25 ns/iter (+/- 0) = 42080 MB/s
+test misc::medium_1MB                        ... bench:          29 ns/iter (+/- 0) = 36158758 MB/s
+test misc::medium_32                         ... bench:          25 ns/iter (+/- 0) = 2400 MB/s
+test misc::medium_32K                        ... bench:          25 ns/iter (+/- 0) = 1311840 MB/s
+test misc::no_exponential                    ... bench:         268 ns/iter (+/- 7) = 373 MB/s
+test misc::not_literal                       ... bench:          44 ns/iter (+/- 4) = 1159 MB/s
+test misc::one_pass_long_prefix              ... bench:          24 ns/iter (+/- 2) = 1083 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          23 ns/iter (+/- 2) = 1130 MB/s
+test misc::one_pass_short                    ... bench:          16 ns/iter (+/- 0) = 1062 MB/s
+test misc::one_pass_short_not                ... bench:          19 ns/iter (+/- 0) = 894 MB/s
+test misc::reallyhard2_1K                    ... bench:          38 ns/iter (+/- 1) = 27368 MB/s
+test misc::reallyhard_1K                     ... bench:       1,215 ns/iter (+/- 12) = 865 MB/s
+test misc::reallyhard_1MB                    ... bench:   1,215,907 ns/iter (+/- 6,442) = 862 MB/s
+test misc::reallyhard_32                     ... bench:          53 ns/iter (+/- 2) = 1113 MB/s
+test misc::reallyhard_32K                    ... bench:      38,162 ns/iter (+/- 464) = 859 MB/s
+test misc::replace_all                       ... bench:          86 ns/iter (+/- 5)
+test misc::reverse_suffix_no_quadratic       ... bench:       2,355 ns/iter (+/- 470) = 3397 MB/s
+test misc::short_haystack_1000000x           ... bench:      91,039 ns/iter (+/- 157) = 87874 MB/s
+test misc::short_haystack_100000x            ... bench:       7,595 ns/iter (+/- 33) = 105333 MB/s
+test misc::short_haystack_10000x             ... bench:       2,865 ns/iter (+/- 9) = 27927 MB/s
+test misc::short_haystack_1000x              ... bench:         211 ns/iter (+/- 2) = 37966 MB/s
+test misc::short_haystack_100x               ... bench:          98 ns/iter (+/- 3) = 8275 MB/s
+test misc::short_haystack_10x                ... bench:          92 ns/iter (+/- 4) = 989 MB/s
+test misc::short_haystack_1x                 ... bench:          90 ns/iter (+/- 2) = 211 MB/s
+test misc::short_haystack_2x                 ... bench:          88 ns/iter (+/- 3) = 306 MB/s
+test misc::short_haystack_3x                 ... bench:          91 ns/iter (+/- 3) = 384 MB/s
+test misc::short_haystack_4x                 ... bench:          90 ns/iter (+/- 3) = 477 MB/s
+test regexdna::find_new_lines                ... bench:   7,323,399 ns/iter (+/- 24,661) = 694 MB/s
+test regexdna::subst1                        ... bench:     473,671 ns/iter (+/- 16,963) = 10731 MB/s
+test regexdna::subst10                       ... bench:     463,672 ns/iter (+/- 13,433) = 10963 MB/s
+test regexdna::subst11                       ... bench:     470,891 ns/iter (+/- 28,305) = 10795 MB/s
+test regexdna::subst2                        ... bench:     469,218 ns/iter (+/- 26,181) = 10833 MB/s
+test regexdna::subst3                        ... bench:     467,417 ns/iter (+/- 30,700) = 10875 MB/s
+test regexdna::subst4                        ... bench:     469,373 ns/iter (+/- 17,254) = 10830 MB/s
+test regexdna::subst5                        ... bench:     467,035 ns/iter (+/- 30,365) = 10884 MB/s
+test regexdna::subst6                        ... bench:     466,540 ns/iter (+/- 18,283) = 10895 MB/s
+test regexdna::subst7                        ... bench:     470,291 ns/iter (+/- 23,930) = 10809 MB/s
+test regexdna::subst8                        ... bench:     466,425 ns/iter (+/- 27,080) = 10898 MB/s
+test regexdna::subst9                        ... bench:     468,192 ns/iter (+/- 17,296) = 10857 MB/s
+test regexdna::variant1                      ... bench:     653,471 ns/iter (+/- 8,898) = 7779 MB/s
+test regexdna::variant2                      ... bench:     902,852 ns/iter (+/- 12,549) = 5630 MB/s
+test regexdna::variant3                      ... bench:   1,158,000 ns/iter (+/- 14,075) = 4389 MB/s
+test regexdna::variant4                      ... bench:   1,149,520 ns/iter (+/- 13,482) = 4422 MB/s
+test regexdna::variant5                      ... bench:   1,132,121 ns/iter (+/- 7,624) = 4490 MB/s
+test regexdna::variant6                      ... bench:   1,069,227 ns/iter (+/- 13,436) = 4754 MB/s
+test regexdna::variant7                      ... bench:   1,150,436 ns/iter (+/- 28,302) = 4418 MB/s
+test regexdna::variant8                      ... bench:   1,148,923 ns/iter (+/- 49,063) = 4424 MB/s
+test regexdna::variant9                      ... bench:   1,190,858 ns/iter (+/- 15,044) = 4268 MB/s
+test rust_compile::compile_huge              ... bench:      52,168 ns/iter (+/- 827)
+test rust_compile::compile_huge_bytes        ... bench:   3,330,456 ns/iter (+/- 57,242)
+test rust_compile::compile_huge_full         ... bench:   6,378,126 ns/iter (+/- 85,019)
+test rust_compile::compile_simple            ... bench:       2,291 ns/iter (+/- 39)
+test rust_compile::compile_simple_bytes      ... bench:       2,355 ns/iter (+/- 37)
+test rust_compile::compile_simple_full       ... bench:      14,581 ns/iter (+/- 103)
+test rust_compile::compile_small             ... bench:      10,443 ns/iter (+/- 114)
+test rust_compile::compile_small_bytes       ... bench:      11,269 ns/iter (+/- 150)
+test rust_compile::compile_small_full        ... bench:      14,746 ns/iter (+/- 212)
+test sherlock::before_after_holmes           ... bench:     699,736 ns/iter (+/- 6,402) = 850 MB/s
+test sherlock::before_holmes                 ... bench:      28,001 ns/iter (+/- 198) = 21246 MB/s
+test sherlock::everything_greedy             ... bench:   1,029,174 ns/iter (+/- 33,321) = 578 MB/s
+test sherlock::everything_greedy_nl          ... bench:     460,103 ns/iter (+/- 23,290) = 1293 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      57,666 ns/iter (+/- 907) = 10316 MB/s
+test sherlock::holmes_coword_watson          ... bench:     345,016 ns/iter (+/- 4,672) = 1724 MB/s
+test sherlock::ing_suffix                    ... bench:     150,499 ns/iter (+/- 4,855) = 3953 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     777,723 ns/iter (+/- 8,076) = 764 MB/s
+test sherlock::letters                       ... bench:  10,022,203 ns/iter (+/- 77,897) = 59 MB/s
+test sherlock::letters_lower                 ... bench:   9,861,816 ns/iter (+/- 76,172) = 60 MB/s
+test sherlock::letters_upper                 ... bench:   1,134,201 ns/iter (+/- 11,926) = 524 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:     693,533 ns/iter (+/- 6,686) = 857 MB/s
+test sherlock::name_alt1                     ... bench:      11,974 ns/iter (+/- 292) = 49685 MB/s
+test sherlock::name_alt2                     ... bench:      44,708 ns/iter (+/- 573) = 13307 MB/s
+test sherlock::name_alt3                     ... bench:      49,873 ns/iter (+/- 785) = 11928 MB/s
+test sherlock::name_alt3_nocase              ... bench:     190,194 ns/iter (+/- 2,944) = 3128 MB/s
+test sherlock::name_alt4                     ... bench:      52,028 ns/iter (+/- 1,102) = 11434 MB/s
+test sherlock::name_alt4_nocase              ... bench:     119,891 ns/iter (+/- 921) = 4962 MB/s
+test sherlock::name_alt5                     ... bench:      47,139 ns/iter (+/- 1,617) = 12620 MB/s
+test sherlock::name_alt5_nocase              ... bench:     200,159 ns/iter (+/- 3,992) = 2972 MB/s
+test sherlock::name_holmes                   ... bench:      17,902 ns/iter (+/- 577) = 33232 MB/s
+test sherlock::name_holmes_nocase            ... bench:      58,219 ns/iter (+/- 1,215) = 10218 MB/s
+test sherlock::name_sherlock                 ... bench:      14,314 ns/iter (+/- 45) = 41563 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,399 ns/iter (+/- 45) = 41317 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      41,418 ns/iter (+/- 591) = 14364 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      39,877 ns/iter (+/- 545) = 14919 MB/s
+test sherlock::name_whitespace               ... bench:      17,883 ns/iter (+/- 151) = 33268 MB/s
+test sherlock::no_match_common               ... bench:      13,696 ns/iter (+/- 123) = 43438 MB/s
+test sherlock::no_match_really_common        ... bench:      10,157 ns/iter (+/- 222) = 58573 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,663 ns/iter (+/- 53) = 43543 MB/s
+test sherlock::quotes                        ... bench:     234,890 ns/iter (+/- 4,574) = 2532 MB/s
+test sherlock::repeated_class_negation       ... bench:  36,406,680 ns/iter (+/- 397,378) = 16 MB/s
+test sherlock::the_lower                     ... bench:     192,028 ns/iter (+/- 5,315) = 3098 MB/s
+test sherlock::the_nocase                    ... bench:     311,087 ns/iter (+/- 6,723) = 1912 MB/s
+test sherlock::the_upper                     ... bench:      21,710 ns/iter (+/- 1,269) = 27403 MB/s
+test sherlock::the_whitespace                ... bench:     425,246 ns/iter (+/- 7,741) = 1399 MB/s
+test sherlock::word_ending_n                 ... bench:   1,116,412 ns/iter (+/- 11,753) = 532 MB/s
+test sherlock::words                         ... bench:   4,452,805 ns/iter (+/- 84,309) = 133 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 119 measured; 0 filtered out; finished in 142.33s
+
diff --git a/record/old-bench-log/12-regex-1.8.1/rust-bytes b/record/old-bench-log/12-regex-1.8.1/rust-bytes
new file mode 100644
index 0000000000..f5380a765d
--- /dev/null
+++ b/record/old-bench-log/12-regex-1.8.1/rust-bytes
@@ -0,0 +1,112 @@
+
+running 107 tests
+test misc::anchored_literal_long_match       ... bench:           7 ns/iter (+/- 0) = 55714 MB/s
+test misc::anchored_literal_long_non_match   ... bench:           8 ns/iter (+/- 0) = 48750 MB/s
+test misc::anchored_literal_short_match      ... bench:           7 ns/iter (+/- 0) = 3714 MB/s
+test misc::anchored_literal_short_non_match  ... bench:           8 ns/iter (+/- 0) = 3250 MB/s
+test misc::easy0_1K                          ... bench:          24 ns/iter (+/- 0) = 43791 MB/s
+test misc::easy0_1MB                         ... bench:          28 ns/iter (+/- 0) = 37450107 MB/s
+test misc::easy0_32                          ... bench:          24 ns/iter (+/- 0) = 2458 MB/s
+test misc::easy0_32K                         ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::easy1_1K                          ... bench:          18 ns/iter (+/- 0) = 58000 MB/s
+test misc::easy1_1MB                         ... bench:          21 ns/iter (+/- 0) = 49933142 MB/s
+test misc::easy1_32                          ... bench:          18 ns/iter (+/- 2) = 2888 MB/s
+test misc::easy1_32K                         ... bench:          18 ns/iter (+/- 0) = 1821555 MB/s
+test misc::hard_1K                           ... bench:          24 ns/iter (+/- 0) = 43791 MB/s
+test misc::hard_1MB                          ... bench:          28 ns/iter (+/- 0) = 37450107 MB/s
+test misc::hard_32                           ... bench:          24 ns/iter (+/- 0) = 2458 MB/s
+test misc::hard_32K                          ... bench:          24 ns/iter (+/- 0) = 1366458 MB/s
+test misc::is_match_set                      ... bench:          37 ns/iter (+/- 0) = 675 MB/s
+test misc::literal                           ... bench:           7 ns/iter (+/- 0) = 7285 MB/s
+test misc::long_needle1                      ... bench:       1,801 ns/iter (+/- 2) = 55525 MB/s
+test misc::long_needle2                      ... bench:     212,892 ns/iter (+/- 206) = 469 MB/s
+test misc::match_class                       ... bench:          40 ns/iter (+/- 0) = 2025 MB/s
+test misc::match_class_in_range              ... bench:           7 ns/iter (+/- 0) = 11571 MB/s
+test misc::matches_set                       ... bench:         174 ns/iter (+/- 2) = 143 MB/s
+test misc::medium_1K                         ... bench:          25 ns/iter (+/- 0) = 42080 MB/s
+test misc::medium_1MB                        ... bench:          29 ns/iter (+/- 0) = 36158758 MB/s
+test misc::medium_32                         ... bench:          25 ns/iter (+/- 0) = 2400 MB/s
+test misc::medium_32K                        ... bench:          25 ns/iter (+/- 0) = 1311840 MB/s
+test misc::no_exponential                    ... bench:         270 ns/iter (+/- 8) = 370 MB/s
+test misc::not_literal                       ... bench:          44 ns/iter (+/- 1) = 1159 MB/s
+test misc::one_pass_long_prefix              ... bench:          23 ns/iter (+/- 0) = 1130 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          23 ns/iter (+/- 0) = 1130 MB/s
+test misc::one_pass_short                    ... bench:          16 ns/iter (+/- 1) = 1062 MB/s
+test misc::one_pass_short_not                ... bench:          19 ns/iter (+/- 0) = 894 MB/s
+test misc::reallyhard2_1K                    ... bench:          38 ns/iter (+/- 2) = 27368 MB/s
+test misc::reallyhard_1K                     ... bench:       1,215 ns/iter (+/- 15) = 865 MB/s
+test misc::reallyhard_1MB                    ... bench:   1,217,631 ns/iter (+/- 11,216) = 861 MB/s
+test misc::reallyhard_32                     ... bench:          53 ns/iter (+/- 4) = 1113 MB/s
+test misc::reallyhard_32K                    ... bench:      38,251 ns/iter (+/- 364) = 857 MB/s
+test misc::reverse_suffix_no_quadratic       ... bench:       2,353 ns/iter (+/- 4) = 3399 MB/s
+test regexdna::find_new_lines                ... bench:   7,322,463 ns/iter (+/- 37,966) = 694 MB/s
+test regexdna::subst1                        ... bench:     466,849 ns/iter (+/- 12,252) = 10888 MB/s
+test regexdna::subst10                       ... bench:     465,011 ns/iter (+/- 19,693) = 10931 MB/s
+test regexdna::subst11                       ... bench:     457,806 ns/iter (+/- 13,453) = 11103 MB/s
+test regexdna::subst2                        ... bench:     456,878 ns/iter (+/- 32,828) = 11126 MB/s
+test regexdna::subst3                        ... bench:     465,531 ns/iter (+/- 21,786) = 10919 MB/s
+test regexdna::subst4                        ... bench:     454,553 ns/iter (+/- 12,698) = 11183 MB/s
+test regexdna::subst5                        ... bench:     456,977 ns/iter (+/- 13,155) = 11123 MB/s
+test regexdna::subst6                        ... bench:     466,105 ns/iter (+/- 15,667) = 10906 MB/s
+test regexdna::subst7                        ... bench:     462,655 ns/iter (+/- 18,871) = 10987 MB/s
+test regexdna::subst8                        ... bench:     456,642 ns/iter (+/- 19,218) = 11132 MB/s
+test regexdna::subst9                        ... bench:     456,307 ns/iter (+/- 15,369) = 11140 MB/s
+test regexdna::variant1                      ... bench:     655,033 ns/iter (+/- 7,901) = 7760 MB/s
+test regexdna::variant2                      ... bench:     902,675 ns/iter (+/- 15,165) = 5631 MB/s
+test regexdna::variant3                      ... bench:   1,159,521 ns/iter (+/- 14,489) = 4384 MB/s
+test regexdna::variant4                      ... bench:   1,147,781 ns/iter (+/- 16,536) = 4428 MB/s
+test regexdna::variant5                      ... bench:   1,133,068 ns/iter (+/- 13,938) = 4486 MB/s
+test regexdna::variant6                      ... bench:   1,061,174 ns/iter (+/- 14,478) = 4790 MB/s
+test regexdna::variant7                      ... bench:   1,151,637 ns/iter (+/- 35,753) = 4414 MB/s
+test regexdna::variant8                      ... bench:   1,137,068 ns/iter (+/- 37,678) = 4470 MB/s
+test regexdna::variant9                      ... bench:   1,185,082 ns/iter (+/- 14,355) = 4289 MB/s
+test rust_compile::compile_huge              ... bench:      66,894 ns/iter (+/- 2,425)
+test rust_compile::compile_huge_bytes        ... bench:   3,331,663 ns/iter (+/- 47,261)
+test rust_compile::compile_huge_full         ... bench:   6,446,254 ns/iter (+/- 65,334)
+test rust_compile::compile_simple            ... bench:       2,351 ns/iter (+/- 71)
+test rust_compile::compile_simple_bytes      ... bench:       2,350 ns/iter (+/- 49)
+test rust_compile::compile_simple_full       ... bench:      14,460 ns/iter (+/- 144)
+test rust_compile::compile_small             ... bench:      10,350 ns/iter (+/- 120)
+test rust_compile::compile_small_bytes       ... bench:      10,993 ns/iter (+/- 89)
+test rust_compile::compile_small_full        ... bench:      14,201 ns/iter (+/- 139)
+test sherlock::before_after_holmes           ... bench:     698,092 ns/iter (+/- 6,907) = 852 MB/s
+test sherlock::before_holmes                 ... bench:      29,127 ns/iter (+/- 1,001) = 20425 MB/s
+test sherlock::everything_greedy             ... bench:   1,026,902 ns/iter (+/- 86,299) = 579 MB/s
+test sherlock::everything_greedy_nl          ... bench:     433,157 ns/iter (+/- 10,129) = 1373 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      57,103 ns/iter (+/- 509) = 10418 MB/s
+test sherlock::holmes_coword_watson          ... bench:     344,973 ns/iter (+/- 3,288) = 1724 MB/s
+test sherlock::ing_suffix                    ... bench:     158,337 ns/iter (+/- 2,492) = 3757 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     776,703 ns/iter (+/- 8,000) = 765 MB/s
+test sherlock::letters                       ... bench:  10,179,909 ns/iter (+/- 55,188) = 58 MB/s
+test sherlock::letters_lower                 ... bench:  10,007,465 ns/iter (+/- 75,168) = 59 MB/s
+test sherlock::letters_upper                 ... bench:   1,116,201 ns/iter (+/- 11,571) = 532 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:     693,124 ns/iter (+/- 6,540) = 858 MB/s
+test sherlock::name_alt1                     ... bench:      12,079 ns/iter (+/- 192) = 49253 MB/s
+test sherlock::name_alt2                     ... bench:      44,336 ns/iter (+/- 1,424) = 13418 MB/s
+test sherlock::name_alt3                     ... bench:      49,569 ns/iter (+/- 721) = 12002 MB/s
+test sherlock::name_alt3_nocase              ... bench:     189,812 ns/iter (+/- 2,952) = 3134 MB/s
+test sherlock::name_alt4                     ... bench:      52,132 ns/iter (+/- 1,182) = 11412 MB/s
+test sherlock::name_alt4_nocase              ... bench:     120,591 ns/iter (+/- 2,521) = 4933 MB/s
+test sherlock::name_alt5                     ... bench:      46,956 ns/iter (+/- 545) = 12670 MB/s
+test sherlock::name_alt5_nocase              ... bench:     199,252 ns/iter (+/- 2,212) = 2985 MB/s
+test sherlock::name_holmes                   ... bench:      17,983 ns/iter (+/- 591) = 33083 MB/s
+test sherlock::name_holmes_nocase            ... bench:      58,139 ns/iter (+/- 919) = 10232 MB/s
+test sherlock::name_sherlock                 ... bench:      14,283 ns/iter (+/- 113) = 41653 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,587 ns/iter (+/- 82) = 40785 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      40,947 ns/iter (+/- 385) = 14529 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      39,607 ns/iter (+/- 567) = 15020 MB/s
+test sherlock::name_whitespace               ... bench:      18,803 ns/iter (+/- 232) = 31640 MB/s
+test sherlock::no_match_common               ... bench:      13,704 ns/iter (+/- 73) = 43413 MB/s
+test sherlock::no_match_really_common        ... bench:      14,166 ns/iter (+/- 191) = 41997 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,702 ns/iter (+/- 36) = 43419 MB/s
+test sherlock::quotes                        ... bench:     232,609 ns/iter (+/- 3,217) = 2557 MB/s
+test sherlock::repeated_class_negation       ... bench:  36,167,769 ns/iter (+/- 592,579) = 16 MB/s
+test sherlock::the_lower                     ... bench:     188,281 ns/iter (+/- 2,966) = 3159 MB/s
+test sherlock::the_nocase                    ... bench:     312,853 ns/iter (+/- 23,145) = 1901 MB/s
+test sherlock::the_upper                     ... bench:      20,987 ns/iter (+/- 909) = 28347 MB/s
+test sherlock::the_whitespace                ... bench:     427,154 ns/iter (+/- 6,396) = 1392 MB/s
+test sherlock::word_ending_n                 ... bench:   1,112,964 ns/iter (+/- 15,393) = 534 MB/s
+test sherlock::words                         ... bench:   4,513,468 ns/iter (+/- 35,410) = 131 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 107 measured; 0 filtered out; finished in 143.96s
+
diff --git a/record/old-bench-log/13-regex-1.9.0/rust b/record/old-bench-log/13-regex-1.9.0/rust
new file mode 100644
index 0000000000..b46bdf9152
--- /dev/null
+++ b/record/old-bench-log/13-regex-1.9.0/rust
@@ -0,0 +1,115 @@
+
+running 110 tests
+test misc::anchored_literal_long_match       ... bench:          15 ns/iter (+/- 0) = 26000 MB/s
+test misc::anchored_literal_long_non_match   ... bench:          12 ns/iter (+/- 1) = 32500 MB/s
+test misc::anchored_literal_short_match      ... bench:          15 ns/iter (+/- 0) = 1733 MB/s
+test misc::anchored_literal_short_non_match  ... bench:          12 ns/iter (+/- 1) = 2166 MB/s
+test misc::easy0_1K                          ... bench:          42 ns/iter (+/- 0) = 25023 MB/s
+test misc::easy0_1MB                         ... bench:          42 ns/iter (+/- 0) = 24966738 MB/s
+test misc::easy0_32                          ... bench:          42 ns/iter (+/- 0) = 1404 MB/s
+test misc::easy0_32K                         ... bench:          43 ns/iter (+/- 0) = 762674 MB/s
+test misc::easy1_1K                          ... bench:          35 ns/iter (+/- 0) = 29828 MB/s
+test misc::easy1_1MB                         ... bench:          35 ns/iter (+/- 0) = 29959885 MB/s
+test misc::easy1_32                          ... bench:          35 ns/iter (+/- 0) = 1485 MB/s
+test misc::easy1_32K                         ... bench:          35 ns/iter (+/- 0) = 936800 MB/s
+test misc::hard_1K                           ... bench:          43 ns/iter (+/- 0) = 24441 MB/s
+test misc::hard_1MB                          ... bench:          42 ns/iter (+/- 0) = 24966738 MB/s
+test misc::hard_32                           ... bench:          42 ns/iter (+/- 0) = 1404 MB/s
+test misc::hard_32K                          ... bench:          42 ns/iter (+/- 0) = 780833 MB/s
+test misc::is_match_set                      ... bench:          46 ns/iter (+/- 1) = 543 MB/s
+test misc::literal                           ... bench:           9 ns/iter (+/- 0) = 5666 MB/s
+test misc::long_needle1                      ... bench:       1,801 ns/iter (+/- 24) = 55525 MB/s
+test misc::long_needle2                      ... bench:     194,124 ns/iter (+/- 289) = 515 MB/s
+test misc::match_class                       ... bench:          22 ns/iter (+/- 1) = 3681 MB/s
+test misc::match_class_in_range              ... bench:          10 ns/iter (+/- 0) = 8100 MB/s
+test misc::match_class_unicode               ... bench:         196 ns/iter (+/- 0) = 821 MB/s
+test misc::matches_set                       ... bench:          55 ns/iter (+/- 3) = 454 MB/s
+test misc::medium_1K                         ... bench:          43 ns/iter (+/- 0) = 24465 MB/s
+test misc::medium_1MB                        ... bench:          43 ns/iter (+/- 0) = 24386139 MB/s
+test misc::medium_32                         ... bench:          43 ns/iter (+/- 0) = 1395 MB/s
+test misc::medium_32K                        ... bench:          43 ns/iter (+/- 0) = 762697 MB/s
+test misc::no_exponential                    ... bench:         167 ns/iter (+/- 0) = 598 MB/s
+test misc::not_literal                       ... bench:          26 ns/iter (+/- 1) = 1961 MB/s
+test misc::one_pass_long_prefix              ... bench:          40 ns/iter (+/- 0) = 650 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          40 ns/iter (+/- 0) = 650 MB/s
+test misc::one_pass_short                    ... bench:          30 ns/iter (+/- 0) = 566 MB/s
+test misc::one_pass_short_not                ... bench:          31 ns/iter (+/- 0) = 548 MB/s
+test misc::reallyhard2_1K                    ... bench:          67 ns/iter (+/- 1) = 15522 MB/s
+test misc::reallyhard_1K                     ... bench:          78 ns/iter (+/- 1) = 13474 MB/s
+test misc::reallyhard_1MB                    ... bench:      19,310 ns/iter (+/- 80) = 54303 MB/s
+test misc::reallyhard_32                     ... bench:          62 ns/iter (+/- 2) = 951 MB/s
+test misc::reallyhard_32K                    ... bench:         543 ns/iter (+/- 4) = 60395 MB/s
+test misc::replace_all                       ... bench:         151 ns/iter (+/- 13)
+test misc::reverse_suffix_no_quadratic       ... bench:       9,302 ns/iter (+/- 25) = 860 MB/s
+test misc::short_haystack_1000000x           ... bench:      90,868 ns/iter (+/- 354) = 88039 MB/s
+test misc::short_haystack_100000x            ... bench:       7,215 ns/iter (+/- 18) = 110881 MB/s
+test misc::short_haystack_10000x             ... bench:         605 ns/iter (+/- 2) = 132249 MB/s
+test misc::short_haystack_1000x              ... bench:         148 ns/iter (+/- 2) = 54128 MB/s
+test misc::short_haystack_100x               ... bench:          83 ns/iter (+/- 3) = 9771 MB/s
+test misc::short_haystack_10x                ... bench:          89 ns/iter (+/- 1) = 1022 MB/s
+test misc::short_haystack_1x                 ... bench:          79 ns/iter (+/- 1) = 240 MB/s
+test misc::short_haystack_2x                 ... bench:          79 ns/iter (+/- 1) = 341 MB/s
+test misc::short_haystack_3x                 ... bench:          80 ns/iter (+/- 2) = 437 MB/s
+test misc::short_haystack_4x                 ... bench:          79 ns/iter (+/- 1) = 544 MB/s
+test regexdna::find_new_lines                ... bench:   1,748,215 ns/iter (+/- 25,793) = 2907 MB/s
+test regexdna::subst1                        ... bench:     486,169 ns/iter (+/- 11,425) = 10456 MB/s
+test regexdna::subst10                       ... bench:     479,019 ns/iter (+/- 7,468) = 10612 MB/s
+test regexdna::subst11                       ... bench:     481,118 ns/iter (+/- 10,305) = 10565 MB/s
+test regexdna::subst2                        ... bench:     484,508 ns/iter (+/- 11,753) = 10491 MB/s
+test regexdna::subst3                        ... bench:     481,861 ns/iter (+/- 7,991) = 10549 MB/s
+test regexdna::subst4                        ... bench:     477,043 ns/iter (+/- 12,101) = 10656 MB/s
+test regexdna::subst5                        ... bench:     483,954 ns/iter (+/- 7,728) = 10503 MB/s
+test regexdna::subst6                        ... bench:     479,564 ns/iter (+/- 13,514) = 10600 MB/s
+test regexdna::subst7                        ... bench:     481,345 ns/iter (+/- 11,205) = 10560 MB/s
+test regexdna::subst8                        ... bench:     479,772 ns/iter (+/- 13,266) = 10595 MB/s
+test regexdna::subst9                        ... bench:     480,299 ns/iter (+/- 9,997) = 10583 MB/s
+test regexdna::variant1                      ... bench:     693,230 ns/iter (+/- 21,808) = 7332 MB/s
+test regexdna::variant2                      ... bench:     936,552 ns/iter (+/- 9,916) = 5427 MB/s
+test regexdna::variant3                      ... bench:   1,192,921 ns/iter (+/- 11,038) = 4261 MB/s
+test regexdna::variant4                      ... bench:   1,170,341 ns/iter (+/- 27,745) = 4343 MB/s
+test regexdna::variant5                      ... bench:   1,166,877 ns/iter (+/- 8,369) = 4356 MB/s
+test regexdna::variant6                      ... bench:   1,085,919 ns/iter (+/- 9,594) = 4681 MB/s
+test regexdna::variant7                      ... bench:   1,248,718 ns/iter (+/- 13,480) = 4070 MB/s
+test regexdna::variant8                      ... bench:   1,216,643 ns/iter (+/- 15,505) = 4178 MB/s
+test regexdna::variant9                      ... bench:   1,219,951 ns/iter (+/- 14,109) = 4166 MB/s
+test sherlock::before_after_holmes           ... bench:      27,363 ns/iter (+/- 604) = 21742 MB/s
+test sherlock::before_holmes                 ... bench:      31,147 ns/iter (+/- 876) = 19100 MB/s
+test sherlock::everything_greedy             ... bench:   1,326,354 ns/iter (+/- 22,628) = 448 MB/s
+test sherlock::everything_greedy_nl          ... bench:     801,343 ns/iter (+/- 895) = 742 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      56,328 ns/iter (+/- 1,009) = 10561 MB/s
+test sherlock::holmes_coword_watson          ... bench:     301,186 ns/iter (+/- 3,615) = 1975 MB/s
+test sherlock::ing_suffix                    ... bench:     176,428 ns/iter (+/- 2,182) = 3372 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     173,948 ns/iter (+/- 5,073) = 3420 MB/s
+test sherlock::letters                       ... bench:   7,226,608 ns/iter (+/- 261,849) = 82 MB/s
+test sherlock::letters_lower                 ... bench:   7,024,589 ns/iter (+/- 145,281) = 84 MB/s
+test sherlock::letters_upper                 ... bench:   1,004,841 ns/iter (+/- 6,857) = 592 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:      15,978 ns/iter (+/- 90) = 37234 MB/s
+test sherlock::name_alt1                     ... bench:      11,151 ns/iter (+/- 289) = 53352 MB/s
+test sherlock::name_alt2                     ... bench:      45,441 ns/iter (+/- 960) = 13092 MB/s
+test sherlock::name_alt3                     ... bench:      51,934 ns/iter (+/- 806) = 11455 MB/s
+test sherlock::name_alt3_nocase              ... bench:     171,844 ns/iter (+/- 4,176) = 3462 MB/s
+test sherlock::name_alt4                     ... bench:      46,611 ns/iter (+/- 1,072) = 12763 MB/s
+test sherlock::name_alt4_nocase              ... bench:      74,956 ns/iter (+/- 2,098) = 7937 MB/s
+test sherlock::name_alt5                     ... bench:      47,595 ns/iter (+/- 595) = 12499 MB/s
+test sherlock::name_alt5_nocase              ... bench:     100,636 ns/iter (+/- 814) = 5911 MB/s
+test sherlock::name_holmes                   ... bench:      19,293 ns/iter (+/- 687) = 30836 MB/s
+test sherlock::name_holmes_nocase            ... bench:      52,310 ns/iter (+/- 1,024) = 11373 MB/s
+test sherlock::name_sherlock                 ... bench:      16,080 ns/iter (+/- 327) = 36998 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,605 ns/iter (+/- 120) = 40734 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      38,662 ns/iter (+/- 360) = 15388 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      37,650 ns/iter (+/- 316) = 15801 MB/s
+test sherlock::name_whitespace               ... bench:      16,234 ns/iter (+/- 125) = 36647 MB/s
+test sherlock::no_match_common               ... bench:      13,709 ns/iter (+/- 72) = 43397 MB/s
+test sherlock::no_match_really_common        ... bench:       9,870 ns/iter (+/- 133) = 60276 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,735 ns/iter (+/- 57) = 43315 MB/s
+test sherlock::quotes                        ... bench:     189,377 ns/iter (+/- 2,105) = 3141 MB/s
+test sherlock::repeated_class_negation       ... bench:      29,934 ns/iter (+/- 1,249) = 19874 MB/s
+test sherlock::the_lower                     ... bench:     213,236 ns/iter (+/- 3,823) = 2790 MB/s
+test sherlock::the_nocase                    ... bench:     322,922 ns/iter (+/- 5,946) = 1842 MB/s
+test sherlock::the_upper                     ... bench:      23,494 ns/iter (+/- 718) = 25322 MB/s
+test sherlock::the_whitespace                ... bench:     392,113 ns/iter (+/- 6,046) = 1517 MB/s
+test sherlock::word_ending_n                 ... bench:     673,618 ns/iter (+/- 12,865) = 883 MB/s
+test sherlock::words                         ... bench:   3,632,096 ns/iter (+/- 56,944) = 163 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 110 measured; 0 filtered out; finished in 117.87s
+
diff --git a/record/old-bench-log/13-regex-1.9.0/rust-bytes b/record/old-bench-log/13-regex-1.9.0/rust-bytes
new file mode 100644
index 0000000000..8ac6c046c8
--- /dev/null
+++ b/record/old-bench-log/13-regex-1.9.0/rust-bytes
@@ -0,0 +1,103 @@
+
+running 98 tests
+test misc::anchored_literal_long_match       ... bench:          15 ns/iter (+/- 0) = 26000 MB/s
+test misc::anchored_literal_long_non_match   ... bench:          12 ns/iter (+/- 0) = 32500 MB/s
+test misc::anchored_literal_short_match      ... bench:          15 ns/iter (+/- 0) = 1733 MB/s
+test misc::anchored_literal_short_non_match  ... bench:          12 ns/iter (+/- 0) = 2166 MB/s
+test misc::easy0_1K                          ... bench:          42 ns/iter (+/- 0) = 25023 MB/s
+test misc::easy0_1MB                         ... bench:          42 ns/iter (+/- 0) = 24966738 MB/s
+test misc::easy0_32                          ... bench:          42 ns/iter (+/- 0) = 1404 MB/s
+test misc::easy0_32K                         ... bench:          42 ns/iter (+/- 0) = 780833 MB/s
+test misc::easy1_1K                          ... bench:          34 ns/iter (+/- 1) = 30705 MB/s
+test misc::easy1_1MB                         ... bench:          34 ns/iter (+/- 0) = 30841058 MB/s
+test misc::easy1_32                          ... bench:          34 ns/iter (+/- 0) = 1529 MB/s
+test misc::easy1_32K                         ... bench:          34 ns/iter (+/- 0) = 964352 MB/s
+test misc::hard_1K                           ... bench:          42 ns/iter (+/- 0) = 25023 MB/s
+test misc::hard_1MB                          ... bench:          42 ns/iter (+/- 0) = 24966738 MB/s
+test misc::hard_32                           ... bench:          42 ns/iter (+/- 0) = 1404 MB/s
+test misc::hard_32K                          ... bench:          42 ns/iter (+/- 0) = 780833 MB/s
+test misc::is_match_set                      ... bench:          47 ns/iter (+/- 1) = 531 MB/s
+test misc::literal                           ... bench:          10 ns/iter (+/- 0) = 5100 MB/s
+test misc::long_needle1                      ... bench:       1,808 ns/iter (+/- 7) = 55310 MB/s
+test misc::long_needle2                      ... bench:     213,106 ns/iter (+/- 416) = 469 MB/s
+test misc::match_class                       ... bench:          23 ns/iter (+/- 1) = 3521 MB/s
+test misc::match_class_in_range              ... bench:          11 ns/iter (+/- 0) = 7363 MB/s
+test misc::matches_set                       ... bench:          56 ns/iter (+/- 3) = 446 MB/s
+test misc::medium_1K                         ... bench:          43 ns/iter (+/- 0) = 24465 MB/s
+test misc::medium_1MB                        ... bench:          43 ns/iter (+/- 0) = 24386139 MB/s
+test misc::medium_32                         ... bench:          43 ns/iter (+/- 0) = 1395 MB/s
+test misc::medium_32K                        ... bench:          43 ns/iter (+/- 0) = 762697 MB/s
+test misc::no_exponential                    ... bench:         162 ns/iter (+/- 4) = 617 MB/s
+test misc::not_literal                       ... bench:          27 ns/iter (+/- 1) = 1888 MB/s
+test misc::one_pass_long_prefix              ... bench:          41 ns/iter (+/- 0) = 634 MB/s
+test misc::one_pass_long_prefix_not          ... bench:          41 ns/iter (+/- 0) = 634 MB/s
+test misc::one_pass_short                    ... bench:          30 ns/iter (+/- 0) = 566 MB/s
+test misc::one_pass_short_not                ... bench:          31 ns/iter (+/- 0) = 548 MB/s
+test misc::reallyhard2_1K                    ... bench:          70 ns/iter (+/- 1) = 14857 MB/s
+test misc::reallyhard_1K                     ... bench:          78 ns/iter (+/- 3) = 13474 MB/s
+test misc::reallyhard_1MB                    ... bench:      19,850 ns/iter (+/- 345) = 52826 MB/s
+test misc::reallyhard_32                     ... bench:          61 ns/iter (+/- 2) = 967 MB/s
+test misc::reallyhard_32K                    ... bench:         546 ns/iter (+/- 8) = 60064 MB/s
+test misc::reverse_suffix_no_quadratic       ... bench:       9,304 ns/iter (+/- 29) = 859 MB/s
+test regexdna::find_new_lines                ... bench:   1,733,767 ns/iter (+/- 66,699) = 2932 MB/s
+test regexdna::subst1                        ... bench:     486,442 ns/iter (+/- 11,929) = 10450 MB/s
+test regexdna::subst10                       ... bench:     486,073 ns/iter (+/- 12,157) = 10458 MB/s
+test regexdna::subst11                       ... bench:     483,485 ns/iter (+/- 11,703) = 10514 MB/s
+test regexdna::subst2                        ... bench:     487,298 ns/iter (+/- 9,184) = 10431 MB/s
+test regexdna::subst3                        ... bench:     491,219 ns/iter (+/- 9,614) = 10348 MB/s
+test regexdna::subst4                        ... bench:     482,668 ns/iter (+/- 9,576) = 10531 MB/s
+test regexdna::subst5                        ... bench:     489,673 ns/iter (+/- 8,331) = 10381 MB/s
+test regexdna::subst6                        ... bench:     484,707 ns/iter (+/- 5,276) = 10487 MB/s
+test regexdna::subst7                        ... bench:     485,109 ns/iter (+/- 9,360) = 10478 MB/s
+test regexdna::subst8                        ... bench:     485,790 ns/iter (+/- 9,298) = 10464 MB/s
+test regexdna::subst9                        ... bench:     483,255 ns/iter (+/- 12,434) = 10519 MB/s
+test regexdna::variant1                      ... bench:     654,757 ns/iter (+/- 8,719) = 7763 MB/s
+test regexdna::variant2                      ... bench:     905,052 ns/iter (+/- 9,599) = 5616 MB/s
+test regexdna::variant3                      ... bench:   1,161,187 ns/iter (+/- 13,798) = 4377 MB/s
+test regexdna::variant4                      ... bench:   1,144,656 ns/iter (+/- 15,198) = 4440 MB/s
+test regexdna::variant5                      ... bench:   1,136,222 ns/iter (+/- 9,112) = 4473 MB/s
+test regexdna::variant6                      ... bench:   1,062,124 ns/iter (+/- 12,336) = 4786 MB/s
+test regexdna::variant7                      ... bench:   1,144,371 ns/iter (+/- 44,700) = 4442 MB/s
+test regexdna::variant8                      ... bench:   1,143,064 ns/iter (+/- 53,456) = 4447 MB/s
+test regexdna::variant9                      ... bench:   1,187,063 ns/iter (+/- 14,341) = 4282 MB/s
+test sherlock::before_after_holmes           ... bench:      27,804 ns/iter (+/- 598) = 21397 MB/s
+test sherlock::before_holmes                 ... bench:      31,197 ns/iter (+/- 933) = 19070 MB/s
+test sherlock::everything_greedy             ... bench:   1,272,335 ns/iter (+/- 12,466) = 467 MB/s
+test sherlock::everything_greedy_nl          ... bench:     801,469 ns/iter (+/- 955) = 742 MB/s
+test sherlock::holmes_cochar_watson          ... bench:      56,790 ns/iter (+/- 1,606) = 10476 MB/s
+test sherlock::holmes_coword_watson          ... bench:     300,554 ns/iter (+/- 3,460) = 1979 MB/s
+test sherlock::ing_suffix                    ... bench:     179,355 ns/iter (+/- 5,486) = 3317 MB/s
+test sherlock::ing_suffix_limited_space      ... bench:     175,703 ns/iter (+/- 2,380) = 3386 MB/s
+test sherlock::letters                       ... bench:   7,197,094 ns/iter (+/- 181,502) = 82 MB/s
+test sherlock::letters_lower                 ... bench:   7,100,979 ns/iter (+/- 155,898) = 83 MB/s
+test sherlock::letters_upper                 ... bench:   1,018,217 ns/iter (+/- 21,695) = 584 MB/s
+test sherlock::line_boundary_sherlock_holmes ... bench:      15,931 ns/iter (+/- 140) = 37344 MB/s
+test sherlock::name_alt1                     ... bench:      10,932 ns/iter (+/- 96) = 54421 MB/s
+test sherlock::name_alt2                     ... bench:      45,580 ns/iter (+/- 829) = 13052 MB/s
+test sherlock::name_alt3                     ... bench:      51,942 ns/iter (+/- 1,418) = 11453 MB/s
+test sherlock::name_alt3_nocase              ... bench:     171,749 ns/iter (+/- 1,451) = 3463 MB/s
+test sherlock::name_alt4                     ... bench:      45,705 ns/iter (+/- 1,536) = 13016 MB/s
+test sherlock::name_alt4_nocase              ... bench:      73,782 ns/iter (+/- 1,679) = 8063 MB/s
+test sherlock::name_alt5                     ... bench:      48,045 ns/iter (+/- 1,261) = 12382 MB/s
+test sherlock::name_alt5_nocase              ... bench:     100,307 ns/iter (+/- 553) = 5931 MB/s
+test sherlock::name_holmes                   ... bench:      18,916 ns/iter (+/- 662) = 31451 MB/s
+test sherlock::name_holmes_nocase            ... bench:      52,714 ns/iter (+/- 774) = 11286 MB/s
+test sherlock::name_sherlock                 ... bench:      14,575 ns/iter (+/- 163) = 40818 MB/s
+test sherlock::name_sherlock_holmes          ... bench:      14,625 ns/iter (+/- 166) = 40679 MB/s
+test sherlock::name_sherlock_holmes_nocase   ... bench:      39,024 ns/iter (+/- 361) = 15245 MB/s
+test sherlock::name_sherlock_nocase          ... bench:      38,025 ns/iter (+/- 418) = 15645 MB/s
+test sherlock::name_whitespace               ... bench:      16,247 ns/iter (+/- 88) = 36618 MB/s
+test sherlock::no_match_common               ... bench:      13,724 ns/iter (+/- 28) = 43349 MB/s
+test sherlock::no_match_really_common        ... bench:      13,798 ns/iter (+/- 93) = 43117 MB/s
+test sherlock::no_match_uncommon             ... bench:      13,671 ns/iter (+/- 80) = 43517 MB/s
+test sherlock::quotes                        ... bench:     189,359 ns/iter (+/- 2,334) = 3141 MB/s
+test sherlock::repeated_class_negation       ... bench:      29,083 ns/iter (+/- 708) = 20456 MB/s
+test sherlock::the_lower                     ... bench:     204,122 ns/iter (+/- 4,256) = 2914 MB/s
+test sherlock::the_nocase                    ... bench:     319,388 ns/iter (+/- 6,790) = 1862 MB/s
+test sherlock::the_upper                     ... bench:      22,706 ns/iter (+/- 961) = 26201 MB/s
+test sherlock::the_whitespace                ... bench:     386,276 ns/iter (+/- 4,950) = 1540 MB/s
+test sherlock::word_ending_n                 ... bench:     690,010 ns/iter (+/- 8,516) = 862 MB/s
+test sherlock::words                         ... bench:   3,659,990 ns/iter (+/- 104,505) = 162 MB/s
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 98 measured; 0 filtered out; finished in 105.65s
+
diff --git a/record/old-bench-log/README.md b/record/old-bench-log/README.md
new file mode 100644
index 0000000000..aab290e8e3
--- /dev/null
+++ b/record/old-bench-log/README.md
@@ -0,0 +1,11 @@
+These represent an old log of benchmarks from regex 1.7.3 and older. New
+and much more comprehensive benchmarks are now maintained as part of the
+[rebar] project.
+
+We keep these old benchmark recordings for posterity, but they may be removed
+in the future.
+
+Measurements can be compared using the [`cargo-benchcmp`][cargo-benchcmp] tool.
+
+[rebar]: https://github.com/BurntSushi/rebar
+[cargo-benchcmp]: https://github.com/BurntSushi/cargo-benchcmp
diff --git a/bench/log/old/01-before b/record/old-bench-log/old/01-before
similarity index 100%
rename from bench/log/old/01-before
rename to record/old-bench-log/old/01-before
diff --git a/bench/log/old/02-new-syntax-crate b/record/old-bench-log/old/02-new-syntax-crate
similarity index 100%
rename from bench/log/old/02-new-syntax-crate
rename to record/old-bench-log/old/02-new-syntax-crate
diff --git a/bench/log/old/03-new-syntax-crate b/record/old-bench-log/old/03-new-syntax-crate
similarity index 100%
rename from bench/log/old/03-new-syntax-crate
rename to record/old-bench-log/old/03-new-syntax-crate
diff --git a/bench/log/old/04-fixed-benchmark b/record/old-bench-log/old/04-fixed-benchmark
similarity index 100%
rename from bench/log/old/04-fixed-benchmark
rename to record/old-bench-log/old/04-fixed-benchmark
diff --git a/bench/log/old/05-thread-caching b/record/old-bench-log/old/05-thread-caching
similarity index 100%
rename from bench/log/old/05-thread-caching
rename to record/old-bench-log/old/05-thread-caching
diff --git a/bench/log/old/06-major-dynamic b/record/old-bench-log/old/06-major-dynamic
similarity index 100%
rename from bench/log/old/06-major-dynamic
rename to record/old-bench-log/old/06-major-dynamic
diff --git a/bench/log/old/06-major-macro b/record/old-bench-log/old/06-major-macro
similarity index 100%
rename from bench/log/old/06-major-macro
rename to record/old-bench-log/old/06-major-macro
diff --git a/bench/log/old/07-prefix-improvements b/record/old-bench-log/old/07-prefix-improvements
similarity index 100%
rename from bench/log/old/07-prefix-improvements
rename to record/old-bench-log/old/07-prefix-improvements
diff --git a/bench/log/old/08-case-fixes b/record/old-bench-log/old/08-case-fixes
similarity index 100%
rename from bench/log/old/08-case-fixes
rename to record/old-bench-log/old/08-case-fixes
diff --git a/bench/log/old/09-before-compiler-rewrite b/record/old-bench-log/old/09-before-compiler-rewrite
similarity index 100%
rename from bench/log/old/09-before-compiler-rewrite
rename to record/old-bench-log/old/09-before-compiler-rewrite
diff --git a/bench/log/old/10-compiler-rewrite b/record/old-bench-log/old/10-compiler-rewrite
similarity index 100%
rename from bench/log/old/10-compiler-rewrite
rename to record/old-bench-log/old/10-compiler-rewrite
diff --git a/bench/log/old/11-compiler-rewrite b/record/old-bench-log/old/11-compiler-rewrite
similarity index 100%
rename from bench/log/old/11-compiler-rewrite
rename to record/old-bench-log/old/11-compiler-rewrite
diff --git a/bench/log/old/12-executor b/record/old-bench-log/old/12-executor
similarity index 100%
rename from bench/log/old/12-executor
rename to record/old-bench-log/old/12-executor
diff --git a/bench/log/old/12-executor-bytes b/record/old-bench-log/old/12-executor-bytes
similarity index 100%
rename from bench/log/old/12-executor-bytes
rename to record/old-bench-log/old/12-executor-bytes
diff --git a/bench/log/old/13-cache-byte-range-suffixes b/record/old-bench-log/old/13-cache-byte-range-suffixes
similarity index 100%
rename from bench/log/old/13-cache-byte-range-suffixes
rename to record/old-bench-log/old/13-cache-byte-range-suffixes
diff --git a/regex-automata/Cargo.toml b/regex-automata/Cargo.toml
new file mode 100644
index 0000000000..8c1931c668
--- /dev/null
+++ b/regex-automata/Cargo.toml
@@ -0,0 +1,109 @@
+[package]
+name = "regex-automata"
+version = "0.3.0"  #:version
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
+description = "Automata construction and matching using regular expressions."
+documentation = "https://docs.rs/regex-automata"
+repository = "https://github.com/rust-lang/regex/tree/master/regex-automata"
+readme = "README.md"
+keywords = ["regex", "dfa", "automata", "automaton", "nfa"]
+license = "MIT OR Apache-2.0"
+categories = ["text-processing"]
+edition = "2021"
+autoexamples = false
+
+[lib]
+bench = false
+
+# This crate has many many many features. See the crate docs for a description
+# of each and when you might want to use them.
+[features]
+default = ["std", "syntax", "perf", "unicode", "meta", "nfa", "dfa", "hybrid"]
+std = ["regex-syntax?/std", "memchr?/std", "aho-corasick?/std", "alloc"]
+alloc = []
+logging = ["dep:log", "aho-corasick?/logging"]
+
+syntax = ["dep:regex-syntax", "alloc"]
+
+meta = ["syntax", "nfa-pikevm"]
+
+nfa = ["nfa-thompson", "nfa-pikevm", "nfa-backtrack"]
+nfa-thompson = ["alloc"]
+nfa-pikevm = ["nfa-thompson"]
+nfa-backtrack = ["nfa-thompson"]
+
+dfa = ["dfa-build", "dfa-search", "dfa-onepass"]
+dfa-build = ["nfa-thompson", "dfa-search"]
+dfa-search = []
+dfa-onepass = ["nfa-thompson"]
+
+hybrid = ["alloc", "nfa-thompson"]
+
+perf = ["perf-inline", "perf-literal"]
+perf-inline = []
+perf-literal = ["perf-literal-substring", "perf-literal-multisubstring"]
+perf-literal-substring = ["aho-corasick?/perf-literal", "dep:memchr"]
+perf-literal-multisubstring = ["std", "dep:aho-corasick"]
+
+# Enables all Unicode features. This expands if new Unicode features are added.
+unicode = [
+  "unicode-age",
+  "unicode-bool",
+  "unicode-case",
+  "unicode-gencat",
+  "unicode-perl",
+  "unicode-script",
+  "unicode-segment",
+  "unicode-word-boundary",
+  "regex-syntax?/unicode",
+]
+# Enables use of the `Age` property, e.g., `\p{Age:3.0}`.
+unicode-age = ["regex-syntax?/unicode-age"]
+# Enables use of a smattering of boolean properties, e.g., `\p{Emoji}`.
+unicode-bool = ["regex-syntax?/unicode-bool"]
+# Enables Unicode-aware case insensitive matching, e.g., `(?i)β`.
+unicode-case = ["regex-syntax?/unicode-case"]
+# Enables Unicode general categories, e.g., `\p{Letter}` or `\pL`.
+unicode-gencat = ["regex-syntax?/unicode-gencat"]
+# Enables Unicode-aware Perl classes corresponding to `\w`, `\s` and `\d`.
+unicode-perl = ["regex-syntax?/unicode-perl"]
+# Enables Unicode scripts and script extensions, e.g., `\p{Greek}`.
+unicode-script = ["regex-syntax?/unicode-script"]
+# Enables Unicode segmentation properties, e.g., `\p{gcb=Extend}`.
+unicode-segment = ["regex-syntax?/unicode-segment"]
+# Enables Unicode word boundary support. If this is enabled with unicode-perl,
+# then data tables from regex-syntax are used. Otherwise, a new data table
+# inside regex-automata will be included.
+unicode-word-boundary = []
+
+# These are strictly internal features that may be removed or changed in
+# non-compatible ways.
+internal-instrument = ["internal-instrument-pikevm"]
+internal-instrument-pikevm = ["logging", "std"]
+
+[dependencies]
+aho-corasick = { version = "1.0.0", optional = true, default-features = false }
+log = { version = "0.4.14", optional = true }
+memchr = { version = "2.5.0", optional = true, default-features = false }
+regex-syntax = { path = "../regex-syntax", version = "0.7.0", optional = true, default-features = false }
+
+[dev-dependencies]
+anyhow = "1.0.69"
+bstr = { version = "1.3.0", default-features = false, features = ["std"] }
+doc-comment = "0.3.3"
+quickcheck = { version = "1.0.3", default-features = false }
+regex-test = { path = "../regex-test", version = "0.1.0" }
+
+[dev-dependencies.env_logger]
+version = "0.9.3"
+default-features = false
+features = ["atty", "humantime", "termcolor"]
+
+# We put these tests here because they are written primarily against the
+# regex-automata API, and in particular use regex-automata features for
+# conditional compilation. If we moved these up as tests on 'regex' proper,
+# then we'd need to duplicate regex-automata's complex features on 'regex' too,
+# which I really do not want to do.
+[[test]]
+path = "tests/lib.rs"
+name = "integration"
diff --git a/regex-automata/LICENSE-APACHE b/regex-automata/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/regex-automata/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/regex-automata/LICENSE-MIT b/regex-automata/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/regex-automata/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/regex-automata/README.md b/regex-automata/README.md
new file mode 100644
index 0000000000..c12b07012f
--- /dev/null
+++ b/regex-automata/README.md
@@ -0,0 +1,117 @@
+regex-automata
+==============
+This crate exposes a variety of regex engines used by the `regex` crate.
+It provides a vast, sprawling and "expert" level API to each regex engine.
+The regex engines provided by this crate focus heavily on finite automata
+implementations and specifically guarantee worst case `O(m * n)` time
+complexity for all searches. (Where `m ~ len(regex)` and `n ~ len(haystack)`.)
+
+[![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
+[![Crates.io](https://img.shields.io/crates/v/regex-automata.svg)](https://crates.io/crates/regex-automata)
+
+
+### Documentation
+
+https://docs.rs/regex-automata
+
+
+### Example
+
+This example shows how to search for matches of multiple regexes, where each
+regex uses the same capture group names to parse different key-value formats.
+
+```rust
+use regex_automata::{meta::Regex, PatternID};
+
+let re = Regex::new_many(&[
+    r#"(?m)^(?<key>[[:word:]]+)=(?<val>[[:word:]]+)$"#,
+    r#"(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$"#,
+    r#"(?m)^(?<key>[[:word:]]+)='(?<val>[^']+)'$"#,
+    r#"(?m)^(?<key>[[:word:]]+):\s*(?<val>[[:word:]]+)$"#,
+]).unwrap();
+let hay = r#"
+best_album="Blow Your Face Out"
+best_quote='"then as it was, then again it will be"'
+best_year=1973
+best_simpsons_episode: HOMR
+"#;
+let mut kvs = vec![];
+for caps in re.captures_iter(hay) {
+    // N.B. One could use capture indices '1' and '2' here
+    // as well. Capture indices are local to each pattern.
+    // (Just like names are.)
+    let key = &hay[caps.get_group_by_name("key").unwrap()];
+    let val = &hay[caps.get_group_by_name("val").unwrap()];
+    kvs.push((key, val));
+}
+assert_eq!(kvs, vec![
+    ("best_album", "Blow Your Face Out"),
+    ("best_quote", "\"then as it was, then again it will be\""),
+    ("best_year", "1973"),
+    ("best_simpsons_episode", "HOMR"),
+]);
+```
+
+
+### Safety
+
+**I welcome audits of `unsafe` code.**
+
+This crate tries to be extremely conservative in its use of `unsafe`, but does
+use it in a few spots. In general, I am very open to removing uses of `unsafe`
+if it doesn't result in measurable performance regressions and doesn't result
+in significantly more complex code.
+
+Below is an outline of how `unsafe` is used in this crate.
+
+* `util::pool::Pool` makes use of `unsafe` to implement a fast path for
+accessing an element of the pool. The fast path applies to the first thread
+that uses the pool. In effect, the fast path is fast because it avoid a mutex
+lock. `unsafe` is also used in the no-std version of `Pool` to implement a spin
+lock for synchronization.
+* `util::lazy::Lazy` uses `unsafe` to implement a variant of
+`once_cell::sync::Lazy` that works in no-std environments. A no-std no-alloc
+implementation is also provided that requires use of `unsafe`.
+* The `dfa` module makes extensive use of `unsafe` to support zero-copy
+deserialization of DFAs. The high level problem is that you need to get from
+`&[u8]` to the internal representation of a DFA without doing any copies.
+This is required for support in no-std no-alloc environments. It also makes
+deserialization extremely cheap.
+* The `dfa` and `hybrid` modules use `unsafe` to explicitly elide bounds checks
+in the core search loops. This makes the codegen tighter and typically leads to
+consistent 5-10% performance improvements on some workloads.
+
+In general, the above reflect the only uses of `unsafe` throughout the entire
+`regex` crate. At present, there are no plans to meaningfully expand the use
+of `unsafe`. With that said, one thing folks have been asking for is cheap
+deserialization of a `regex::Regex`. My sense is that this feature will require
+a lot more `unsafe` in places to support zero-copy deserialization. It is
+unclear at this point whether this will be pursued.
+
+
+### Motivation
+
+I started out building this crate because I wanted to re-work the `regex`
+crate internals to make it more amenable to optimizations. It turns out that
+there are a lot of different ways to build regex engines and even more ways to
+compose them. Moreover, heuristic literal optimizations are often tricky to
+get correct, but the fruit they bear is attractive. All of these things were
+difficult to expand upon without risking the introduction of more bugs. So I
+decided to tear things down and start fresh.
+
+In the course of doing so, I ended up designing strong boundaries between each
+component so that each component could be reasoned and tested independently.
+This also made it somewhat natural to expose the components as a library unto
+itself. Namely, folks have been asking for more capabilities in the regex
+crate for a long time, but these capabilities usually come with additional API
+complexity that I didn't want to introduce in the `regex` crate proper. But
+exposing them in an "expert" level crate like `regex-automata` seemed quite
+fine.
+
+In the end, I do still somewhat consider this crate an experiment. It is
+unclear whether the strong boundaries between components will be an impediment
+to ongoing development or not. De-coupling tends to lead to slower development
+in my experience, and when you mix in the added cost of not introducing
+breaking changes all of the time, things can get quite complicated. But, I
+don't think anyone has ever release the internals of a regex engine as a
+library before. So it will be interesting to see how it plays out!
diff --git a/regex-automata/src/dfa/accel.rs b/regex-automata/src/dfa/accel.rs
new file mode 100644
index 0000000000..5ea2423dd0
--- /dev/null
+++ b/regex-automata/src/dfa/accel.rs
@@ -0,0 +1,516 @@
+// This module defines some core types for dealing with accelerated DFA states.
+// Briefly, a DFA state can be "accelerated" if all of its transitions except
+// for a few loop back to itself. This directly implies that the only way out
+// of such a state is if a byte corresponding to one of those non-loopback
+// transitions is found. Such states are often found in simple repetitions in
+// non-Unicode regexes. For example, consider '(?-u)[^a]+a'. We can look at its
+// DFA with regex-cli:
+//
+//     $ regex-cli debug dfa dense '(?-u)[^a]+a' -BbC
+//     dense::DFA(
+//     D 000000:
+//     Q 000001:
+//      *000002:
+//     A 000003: \x00-` => 3, a => 5, b-\xFF => 3
+//      >000004: \x00-` => 3, a => 4, b-\xFF => 3
+//       000005: \x00-\xFF => 2, EOI => 2
+//     )
+//
+// In particular, state 3 is accelerated (shown via the 'A' indicator) since
+// the only way to leave that state once entered is to see an 'a' byte. If
+// there is a long run of non-'a' bytes, then using something like 'memchr'
+// to find the next 'a' byte can be significantly faster than just using the
+// standard byte-at-a-time state machine.
+//
+// Unfortunately, this optimization rarely applies when Unicode is enabled.
+// For example, patterns like '[^a]' don't actually match any byte that isn't
+// 'a', but rather, any UTF-8 encoding of a Unicode scalar value that isn't
+// 'a'. This makes the state machine much more complex---far beyond a single
+// state---and removes the ability to easily accelerate it. (Because if the
+// machine sees a non-UTF-8 sequence, then the machine won't match through it.)
+//
+// In practice, we only consider accelerating states that have 3 or fewer
+// non-loop transitions. At a certain point, you get diminishing returns, but
+// also because that's what the memchr crate supports. The structures below
+// hard-code this assumption and provide (de)serialization APIs for use inside
+// a DFA.
+//
+// And finally, note that there is some trickery involved in making it very
+// fast to not only check whether a state is accelerated at search time, but
+// also to access the bytes to search for to implement the acceleration itself.
+// dfa/special.rs provides more detail, but the short story is that all
+// accelerated states appear contiguously in a DFA. This means we can represent
+// the ID space of all accelerated DFA states with a single range. So given
+// a state ID, we can determine whether it's accelerated via
+//
+//     min_accel_id <= id <= max_accel_id
+//
+// And find its corresponding accelerator with:
+//
+//     accels.get((id - min_accel_id) / dfa_stride)
+
+#[cfg(feature = "dfa-build")]
+use alloc::{vec, vec::Vec};
+
+use crate::util::{
+    int::Pointer,
+    memchr,
+    wire::{self, DeserializeError, Endian, SerializeError},
+};
+
+/// The base type used to represent a collection of accelerators.
+///
+/// While an `Accel` is represented as a fixed size array of bytes, a
+/// *collection* of `Accel`s (called `Accels`) is represented internally as a
+/// slice of u32. While it's a bit unnatural to do this and costs us a bit of
+/// fairly low-risk not-safe code, it lets us remove the need for a second type
+/// parameter in the definition of dense::DFA. (Which really wants everything
+/// to be a slice of u32.)
+type AccelTy = u32;
+
+/// The size of the unit of representation for accelerators.
+///
+/// ACCEL_CAP *must* be a multiple of this size.
+const ACCEL_TY_SIZE: usize = core::mem::size_of::<AccelTy>();
+
+/// The maximum length in bytes that a single Accel can be. This is distinct
+/// from the capacity of an accelerator in that the length represents only the
+/// bytes that should be read.
+const ACCEL_LEN: usize = 4;
+
+/// The capacity of each accelerator, in bytes. We set this to 8 since it's a
+/// multiple of 4 (our ID size) and because it gives us a little wiggle room
+/// if we want to support more accel bytes in the future without a breaking
+/// change.
+///
+/// This MUST be a multiple of ACCEL_TY_SIZE.
+const ACCEL_CAP: usize = 8;
+
+/// Search for between 1 and 3 needle bytes in the given haystack, starting the
+/// search at the given position. If `needles` has a length other than 1-3,
+/// then this panics.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn find_fwd(
+    needles: &[u8],
+    haystack: &[u8],
+    at: usize,
+) -> Option<usize> {
+    let bs = needles;
+    let i = match needles.len() {
+        1 => memchr::memchr(bs[0], &haystack[at..])?,
+        2 => memchr::memchr2(bs[0], bs[1], &haystack[at..])?,
+        3 => memchr::memchr3(bs[0], bs[1], bs[2], &haystack[at..])?,
+        0 => panic!("cannot find with empty needles"),
+        n => panic!("invalid needles length: {}", n),
+    };
+    Some(at + i)
+}
+
+/// Search for between 1 and 3 needle bytes in the given haystack in reverse,
+/// starting the search at the given position. If `needles` has a length other
+/// than 1-3, then this panics.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn find_rev(
+    needles: &[u8],
+    haystack: &[u8],
+    at: usize,
+) -> Option<usize> {
+    let bs = needles;
+    match needles.len() {
+        1 => memchr::memrchr(bs[0], &haystack[..at]),
+        2 => memchr::memrchr2(bs[0], bs[1], &haystack[..at]),
+        3 => memchr::memrchr3(bs[0], bs[1], bs[2], &haystack[..at]),
+        0 => panic!("cannot find with empty needles"),
+        n => panic!("invalid needles length: {}", n),
+    }
+}
+
+/// Represents the accelerators for all accelerated states in a dense DFA.
+///
+/// The `A` type parameter represents the type of the underlying bytes.
+/// Generally, this is either `&[AccelTy]` or `Vec<AccelTy>`.
+#[derive(Clone)]
+pub(crate) struct Accels<A> {
+    /// A length prefixed slice of contiguous accelerators. See the top comment
+    /// in this module for more details on how we can jump from a DFA's state
+    /// ID to an accelerator in this list.
+    ///
+    /// The first 4 bytes always correspond to the number of accelerators
+    /// that follow.
+    accels: A,
+}
+
+#[cfg(feature = "dfa-build")]
+impl Accels<Vec<AccelTy>> {
+    /// Create an empty sequence of accelerators for a DFA.
+    pub fn empty() -> Accels<Vec<AccelTy>> {
+        Accels { accels: vec![0] }
+    }
+
+    /// Add an accelerator to this sequence.
+    ///
+    /// This adds to the accelerator to the end of the sequence and therefore
+    /// should be done in correspondence with its state in the DFA.
+    ///
+    /// This panics if this results in more accelerators than AccelTy::MAX.
+    pub fn add(&mut self, accel: Accel) {
+        self.accels.extend_from_slice(&accel.as_accel_tys());
+        let len = self.len();
+        self.set_len(len + 1);
+    }
+
+    /// Set the number of accelerators in this sequence, which is encoded in
+    /// the first 4 bytes of the underlying bytes.
+    fn set_len(&mut self, new_len: usize) {
+        // The only way an accelerator gets added is if a state exists for
+        // it, and if a state exists, then its index is guaranteed to be
+        // representable by a AccelTy by virtue of the guarantees provided by
+        // StateID.
+        let new_len = AccelTy::try_from(new_len).unwrap();
+        self.accels[0] = new_len;
+    }
+}
+
+impl<'a> Accels<&'a [AccelTy]> {
+    /// Deserialize a sequence of accelerators from the given bytes. If there
+    /// was a problem deserializing, then an error is returned.
+    ///
+    /// This is guaranteed to run in constant time. This does not guarantee
+    /// that every accelerator in the returned collection is valid. Thus,
+    /// accessing one may panic, or not-safe code that relies on accelerators
+    /// being correct my result in UB.
+    ///
+    /// Callers may check the validity of every accelerator with the `validate`
+    /// method.
+    pub fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(Accels<&'a [AccelTy]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        let (accel_len, _) =
+            wire::try_read_u32_as_usize(slice, "accelerators length")?;
+        // The accelerator length is part of the accel_tys slice that
+        // we deserialize. This is perhaps a bit idiosyncratic. It would
+        // probably be better to split out the length into a real field.
+
+        let accel_tys_len = wire::add(
+            wire::mul(accel_len, 2, "total number of accelerator accel_tys")?,
+            1,
+            "total number of accel_tys",
+        )?;
+        let accel_tys_bytes_len = wire::mul(
+            ACCEL_TY_SIZE,
+            accel_tys_len,
+            "total number of bytes in accelerators",
+        )?;
+        wire::check_slice_len(slice, accel_tys_bytes_len, "accelerators")?;
+        wire::check_alignment::<AccelTy>(slice)?;
+        let accel_tys = &slice[..accel_tys_bytes_len];
+        slice = &slice[accel_tys_bytes_len..];
+        // SAFETY: We've checked the length and alignment above, and since
+        // slice is just bytes and AccelTy is just a u32, we can safely cast to
+        // a slice of &[AccelTy].
+        let accels = unsafe {
+            core::slice::from_raw_parts(
+                accel_tys.as_ptr().cast::<AccelTy>(),
+                accel_tys_len,
+            )
+        };
+        Ok((Accels { accels }, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+impl<A: AsRef<[AccelTy]>> Accels<A> {
+    /// Return an owned version of the accelerators.
+    #[cfg(feature = "alloc")]
+    pub fn to_owned(&self) -> Accels<alloc::vec::Vec<AccelTy>> {
+        Accels { accels: self.accels.as_ref().to_vec() }
+    }
+
+    /// Return a borrowed version of the accelerators.
+    pub fn as_ref(&self) -> Accels<&[AccelTy]> {
+        Accels { accels: self.accels.as_ref() }
+    }
+
+    /// Return the bytes representing the serialization of the accelerators.
+    pub fn as_bytes(&self) -> &[u8] {
+        let accels = self.accels.as_ref();
+        // SAFETY: This is safe because accels is a just a slice of AccelTy,
+        // and u8 always has a smaller alignment.
+        unsafe {
+            core::slice::from_raw_parts(
+                accels.as_ptr().cast::<u8>(),
+                accels.len() * ACCEL_TY_SIZE,
+            )
+        }
+    }
+
+    /// Returns the memory usage, in bytes, of these accelerators.
+    ///
+    /// The memory usage is computed based on the number of bytes used to
+    /// represent all of the accelerators.
+    ///
+    /// This does **not** include the stack size used by this value.
+    pub fn memory_usage(&self) -> usize {
+        self.as_bytes().len()
+    }
+
+    /// Return the bytes to search for corresponding to the accelerator in this
+    /// sequence at index `i`. If no such accelerator exists, then this panics.
+    ///
+    /// The significance of the index is that it should be in correspondence
+    /// with the index of the corresponding DFA. That is, accelerated DFA
+    /// states are stored contiguously in the DFA and have an ordering implied
+    /// by their respective state IDs. The state's index in that sequence
+    /// corresponds to the index of its corresponding accelerator.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn needles(&self, i: usize) -> &[u8] {
+        if i >= self.len() {
+            panic!("invalid accelerator index {}", i);
+        }
+        let bytes = self.as_bytes();
+        let offset = ACCEL_TY_SIZE + i * ACCEL_CAP;
+        let len = usize::from(bytes[offset]);
+        &bytes[offset + 1..offset + 1 + len]
+    }
+
+    /// Return the total number of accelerators in this sequence.
+    pub fn len(&self) -> usize {
+        // This should never panic since deserialization checks that the
+        // length can fit into a usize.
+        usize::try_from(self.accels.as_ref()[0]).unwrap()
+    }
+
+    /// Return the accelerator in this sequence at index `i`. If no such
+    /// accelerator exists, then this returns None.
+    ///
+    /// See the docs for `needles` on the significance of the index.
+    fn get(&self, i: usize) -> Option<Accel> {
+        if i >= self.len() {
+            return None;
+        }
+        let offset = ACCEL_TY_SIZE + i * ACCEL_CAP;
+        let accel = Accel::from_slice(&self.as_bytes()[offset..])
+            .expect("Accels must contain valid accelerators");
+        Some(accel)
+    }
+
+    /// Returns an iterator of accelerators in this sequence.
+    fn iter(&self) -> IterAccels<'_, A> {
+        IterAccels { accels: self, i: 0 }
+    }
+
+    /// Writes these accelerators to the given byte buffer using the indicated
+    /// endianness. If the given buffer is too small, then an error is
+    /// returned. Upon success, the total number of bytes written is returned.
+    /// The number of bytes written is guaranteed to be a multiple of 8.
+    pub fn write_to<E: Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        assert_eq!(
+            nwrite % ACCEL_TY_SIZE,
+            0,
+            "expected accelerator bytes written to be a multiple of {}",
+            ACCEL_TY_SIZE,
+        );
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("accelerators"));
+        }
+
+        // The number of accelerators can never exceed AccelTy::MAX.
+        E::write_u32(AccelTy::try_from(self.len()).unwrap(), dst);
+        // The actual accelerators are just raw bytes and thus their endianness
+        // is irrelevant. So we can copy them as bytes.
+        dst[ACCEL_TY_SIZE..nwrite]
+            .copy_from_slice(&self.as_bytes()[ACCEL_TY_SIZE..nwrite]);
+        Ok(nwrite)
+    }
+
+    /// Validates that every accelerator in this collection can be successfully
+    /// deserialized as a valid accelerator.
+    pub fn validate(&self) -> Result<(), DeserializeError> {
+        for chunk in self.as_bytes()[ACCEL_TY_SIZE..].chunks(ACCEL_CAP) {
+            let _ = Accel::from_slice(chunk)?;
+        }
+        Ok(())
+    }
+
+    /// Returns the total number of bytes written by `write_to`.
+    pub fn write_to_len(&self) -> usize {
+        self.as_bytes().len()
+    }
+}
+
+impl<A: AsRef<[AccelTy]>> core::fmt::Debug for Accels<A> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "Accels(")?;
+        let mut list = f.debug_list();
+        for a in self.iter() {
+            list.entry(&a);
+        }
+        list.finish()?;
+        write!(f, ")")
+    }
+}
+
+#[derive(Debug)]
+struct IterAccels<'a, A: AsRef<[AccelTy]>> {
+    accels: &'a Accels<A>,
+    i: usize,
+}
+
+impl<'a, A: AsRef<[AccelTy]>> Iterator for IterAccels<'a, A> {
+    type Item = Accel;
+
+    fn next(&mut self) -> Option<Accel> {
+        let accel = self.accels.get(self.i)?;
+        self.i += 1;
+        Some(accel)
+    }
+}
+
+/// Accel represents a structure for determining how to "accelerate" a DFA
+/// state.
+///
+/// Namely, it contains zero or more bytes that must be seen in order for the
+/// DFA to leave the state it is associated with. In practice, the actual range
+/// is 1 to 3 bytes.
+///
+/// The purpose of acceleration is to identify states whose vast majority
+/// of transitions are just loops back to the same state. For example,
+/// in the regex `(?-u)^[^a]+b`, the corresponding DFA will have a state
+/// (corresponding to `[^a]+`) where all transitions *except* for `a` and
+/// `b` loop back to itself. Thus, this state can be "accelerated" by simply
+/// looking for the next occurrence of either `a` or `b` instead of explicitly
+/// following transitions. (In this case, `b` transitions to the next state
+/// where as `a` would transition to the dead state.)
+#[derive(Clone)]
+pub(crate) struct Accel {
+    /// The first byte is the length. Subsequent bytes are the accelerated
+    /// bytes.
+    ///
+    /// Note that we make every accelerator 8 bytes as a slightly wasteful
+    /// way of making sure alignment is always correct for state ID sizes of
+    /// 1, 2, 4 and 8. This should be okay since accelerated states aren't
+    /// particularly common, especially when Unicode is enabled.
+    bytes: [u8; ACCEL_CAP],
+}
+
+impl Accel {
+    /// Returns an empty accel, where no bytes are accelerated.
+    #[cfg(feature = "dfa-build")]
+    pub fn new() -> Accel {
+        Accel { bytes: [0; ACCEL_CAP] }
+    }
+
+    /// Returns a verified accelerator derived from the beginning of the given
+    /// slice.
+    ///
+    /// If the slice is not long enough or contains invalid bytes for an
+    /// accelerator, then this returns an error.
+    pub fn from_slice(mut slice: &[u8]) -> Result<Accel, DeserializeError> {
+        slice = &slice[..core::cmp::min(ACCEL_LEN, slice.len())];
+        let bytes = slice
+            .try_into()
+            .map_err(|_| DeserializeError::buffer_too_small("accelerator"))?;
+        Accel::from_bytes(bytes)
+    }
+
+    /// Returns a verified accelerator derived from raw bytes.
+    ///
+    /// If the given bytes are invalid, then this returns an error.
+    fn from_bytes(bytes: [u8; 4]) -> Result<Accel, DeserializeError> {
+        if usize::from(bytes[0]) >= ACCEL_LEN {
+            return Err(DeserializeError::generic(
+                "accelerator bytes cannot have length more than 3",
+            ));
+        }
+        Ok(Accel::from_bytes_unchecked(bytes))
+    }
+
+    /// Returns an accelerator derived from raw bytes.
+    ///
+    /// This does not check whether the given bytes are valid. Invalid bytes
+    /// cannot sacrifice memory safety, but may result in panics or silent
+    /// logic bugs.
+    fn from_bytes_unchecked(bytes: [u8; 4]) -> Accel {
+        Accel { bytes: [bytes[0], bytes[1], bytes[2], bytes[3], 0, 0, 0, 0] }
+    }
+
+    /// Attempts to add the given byte to this accelerator. If the accelerator
+    /// is already full or thinks the byte is a poor accelerator, then this
+    /// returns false. Otherwise, returns true.
+    ///
+    /// If the given byte is already in this accelerator, then it panics.
+    #[cfg(feature = "dfa-build")]
+    pub fn add(&mut self, byte: u8) -> bool {
+        if self.len() >= 3 {
+            return false;
+        }
+        // As a special case, we totally reject trying to accelerate a state
+        // with an ASCII space. In most cases, it occurs very frequently, and
+        // tends to result in worse overall performance.
+        if byte == b' ' {
+            return false;
+        }
+        assert!(
+            !self.contains(byte),
+            "accelerator already contains {:?}",
+            crate::util::escape::DebugByte(byte)
+        );
+        self.bytes[self.len() + 1] = byte;
+        self.bytes[0] += 1;
+        true
+    }
+
+    /// Return the number of bytes in this accelerator.
+    pub fn len(&self) -> usize {
+        usize::from(self.bytes[0])
+    }
+
+    /// Returns true if and only if there are no bytes in this accelerator.
+    #[cfg(feature = "dfa-build")]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the slice of bytes to accelerate.
+    ///
+    /// If this accelerator is empty, then this returns an empty slice.
+    fn needles(&self) -> &[u8] {
+        &self.bytes[1..1 + self.len()]
+    }
+
+    /// Returns true if and only if this accelerator will accelerate the given
+    /// byte.
+    #[cfg(feature = "dfa-build")]
+    fn contains(&self, byte: u8) -> bool {
+        self.needles().iter().position(|&b| b == byte).is_some()
+    }
+
+    /// Returns the accelerator bytes as an array of AccelTys.
+    #[cfg(feature = "dfa-build")]
+    fn as_accel_tys(&self) -> [AccelTy; 2] {
+        assert_eq!(ACCEL_CAP, 8);
+        // These unwraps are OK since ACCEL_CAP is set to 8.
+        let first =
+            AccelTy::from_ne_bytes(self.bytes[0..4].try_into().unwrap());
+        let second =
+            AccelTy::from_ne_bytes(self.bytes[4..8].try_into().unwrap());
+        [first, second]
+    }
+}
+
+impl core::fmt::Debug for Accel {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "Accel(")?;
+        let mut set = f.debug_set();
+        for &b in self.needles() {
+            set.entry(&crate::util::escape::DebugByte(b));
+        }
+        set.finish()?;
+        write!(f, ")")
+    }
+}
diff --git a/regex-automata/src/dfa/automaton.rs b/regex-automata/src/dfa/automaton.rs
new file mode 100644
index 0000000000..2be080425d
--- /dev/null
+++ b/regex-automata/src/dfa/automaton.rs
@@ -0,0 +1,2120 @@
+#[cfg(feature = "alloc")]
+use crate::util::search::PatternSet;
+use crate::{
+    dfa::search,
+    util::{
+        empty,
+        prefilter::Prefilter,
+        primitives::{PatternID, StateID},
+        search::{Anchored, HalfMatch, Input, MatchError},
+    },
+};
+
+/// A trait describing the interface of a deterministic finite automaton (DFA).
+///
+/// The complexity of this trait probably means that it's unlikely for others
+/// to implement it. The primary purpose of the trait is to provide for a way
+/// of abstracting over different types of DFAs. In this crate, that means
+/// dense DFAs and sparse DFAs. (Dense DFAs are fast but memory hungry, where
+/// as sparse DFAs are slower but come with a smaller memory footprint. But
+/// they otherwise provide exactly equivalent expressive power.) For example, a
+/// [`dfa::regex::Regex`](crate::dfa::regex::Regex) is generic over this trait.
+///
+/// Normally, a DFA's execution model is very simple. You might have a single
+/// start state, zero or more final or "match" states and a function that
+/// transitions from one state to the next given the next byte of input.
+/// Unfortunately, the interface described by this trait is significantly
+/// more complicated than this. The complexity has a number of different
+/// reasons, mostly motivated by performance, functionality or space savings:
+///
+/// * A DFA can search for multiple patterns simultaneously. This
+/// means extra information is returned when a match occurs. Namely,
+/// a match is not just an offset, but an offset plus a pattern ID.
+/// [`Automaton::pattern_len`] returns the number of patterns compiled into
+/// the DFA, [`Automaton::match_len`] returns the total number of patterns
+/// that match in a particular state and [`Automaton::match_pattern`] permits
+/// iterating over the patterns that match in a particular state.
+/// * A DFA can have multiple start states, and the choice of which start
+/// state to use depends on the content of the string being searched and
+/// position of the search, as well as whether the search is an anchored
+/// search for a specific pattern in the DFA. Moreover, computing the start
+/// state also depends on whether you're doing a forward or a reverse search.
+/// [`Automaton::start_state_forward`] and [`Automaton::start_state_reverse`]
+/// are used to compute the start state for forward and reverse searches,
+/// respectively.
+/// * All matches are delayed by one byte to support things like `$` and `\b`
+/// at the end of a pattern. Therefore, every use of a DFA is required to use
+/// [`Automaton::next_eoi_state`]
+/// at the end of the search to compute the final transition.
+/// * For optimization reasons, some states are treated specially. Every
+/// state is either special or not, which can be determined via the
+/// [`Automaton::is_special_state`] method. If it's special, then the state
+/// must be at least one of a few possible types of states. (Note that some
+/// types can overlap, for example, a match state can also be an accel state.
+/// But some types can't. If a state is a dead state, then it can never be any
+/// other type of state.) Those types are:
+///     * A dead state. A dead state means the DFA will never enter a match
+///     state. This can be queried via the [`Automaton::is_dead_state`] method.
+///     * A quit state. A quit state occurs if the DFA had to stop the search
+///     prematurely for some reason. This can be queried via the
+///     [`Automaton::is_quit_state`] method.
+///     * A match state. A match state occurs when a match is found. When a DFA
+///     enters a match state, the search may stop immediately (when looking
+///     for the earliest match), or it may continue to find the leftmost-first
+///     match. This can be queried via the [`Automaton::is_match_state`]
+///     method.
+///     * A start state. A start state is where a search begins. For every
+///     search, there is exactly one start state that is used, however, a
+///     DFA may contain many start states. When the search is in a start
+///     state, it may use a prefilter to quickly skip to candidate matches
+///     without executing the DFA on every byte. This can be queried via the
+///     [`Automaton::is_start_state`] method.
+///     * An accel state. An accel state is a state that is accelerated.
+///     That is, it is a state where _most_ of its transitions loop back to
+///     itself and only a small number of transitions lead to other states.
+///     This kind of state is said to be accelerated because a search routine
+///     can quickly look for the bytes leading out of the state instead of
+///     continuing to execute the DFA on each byte. This can be queried via the
+///     [`Automaton::is_accel_state`] method. And the bytes that lead out of
+///     the state can be queried via the [`Automaton::accelerator`] method.
+///
+/// There are a number of provided methods on this trait that implement
+/// efficient searching (for forwards and backwards) with a DFA using
+/// all of the above features of this trait. In particular, given the
+/// complexity of all these features, implementing a search routine in
+/// this trait can be a little subtle. With that said, it is possible to
+/// somewhat simplify the search routine. For example, handling accelerated
+/// states is strictly optional, since it is always correct to assume that
+/// `Automaton::is_accel_state` returns false. However, one complex part of
+/// writing a search routine using this trait is handling the 1-byte delay of a
+/// match. That is not optional.
+///
+/// # Safety
+///
+/// This trait is not safe to implement so that code may rely on the
+/// correctness of implementations of this trait to avoid undefined behavior.
+/// The primary correctness guarantees are:
+///
+/// * `Automaton::start_state` always returns a valid state ID or an error or
+/// panics.
+/// * `Automaton::next_state`, when given a valid state ID, always returns
+/// a valid state ID for all values of `anchored` and `byte`, or otherwise
+/// panics.
+///
+/// In general, the rest of the methods on `Automaton` need to uphold their
+/// contracts as well. For example, `Automaton::is_dead` should only returns
+/// true if the given state ID is actually a dead state.
+pub unsafe trait Automaton {
+    /// Transitions from the current state to the next state, given the next
+    /// byte of input.
+    ///
+    /// Implementations must guarantee that the returned ID is always a valid
+    /// ID when `current` refers to a valid ID. Moreover, the transition
+    /// function must be defined for all possible values of `input`.
+    ///
+    /// # Panics
+    ///
+    /// If the given ID does not refer to a valid state, then this routine
+    /// may panic but it also may not panic and instead return an invalid ID.
+    /// However, if the caller provides an invalid ID then this must never
+    /// sacrifice memory safety.
+    ///
+    /// # Example
+    ///
+    /// This shows a simplistic example for walking a DFA for a given haystack
+    /// by using the `next_state` method.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, Input};
+    ///
+    /// let dfa = dense::DFA::new(r"[a-z]+r")?;
+    /// let haystack = "bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     state = dfa.next_state(state, b);
+    /// }
+    /// // Matches are always delayed by 1 byte, so we must explicitly walk the
+    /// // special "EOI" transition at the end of the search.
+    /// state = dfa.next_eoi_state(state);
+    /// assert!(dfa.is_match_state(state));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn next_state(&self, current: StateID, input: u8) -> StateID;
+
+    /// Transitions from the current state to the next state, given the next
+    /// byte of input.
+    ///
+    /// Unlike [`Automaton::next_state`], implementations may implement this
+    /// more efficiently by assuming that the `current` state ID is valid.
+    /// Typically, this manifests by eliding bounds checks.
+    ///
+    /// # Safety
+    ///
+    /// Callers of this method must guarantee that `current` refers to a valid
+    /// state ID. If `current` is not a valid state ID for this automaton, then
+    /// calling this routine may result in undefined behavior.
+    ///
+    /// If `current` is valid, then implementations must guarantee that the ID
+    /// returned is valid for all possible values of `input`.
+    unsafe fn next_state_unchecked(
+        &self,
+        current: StateID,
+        input: u8,
+    ) -> StateID;
+
+    /// Transitions from the current state to the next state for the special
+    /// EOI symbol.
+    ///
+    /// Implementations must guarantee that the returned ID is always a valid
+    /// ID when `current` refers to a valid ID.
+    ///
+    /// This routine must be called at the end of every search in a correct
+    /// implementation of search. Namely, DFAs in this crate delay matches
+    /// by one byte in order to support look-around operators. Thus, after
+    /// reaching the end of a haystack, a search implementation must follow one
+    /// last EOI transition.
+    ///
+    /// It is best to think of EOI as an additional symbol in the alphabet of
+    /// a DFA that is distinct from every other symbol. That is, the alphabet
+    /// of DFAs in this crate has a logical size of 257 instead of 256, where
+    /// 256 corresponds to every possible inhabitant of `u8`. (In practice, the
+    /// physical alphabet size may be smaller because of alphabet compression
+    /// via equivalence classes, but EOI is always represented somehow in the
+    /// alphabet.)
+    ///
+    /// # Panics
+    ///
+    /// If the given ID does not refer to a valid state, then this routine
+    /// may panic but it also may not panic and instead return an invalid ID.
+    /// However, if the caller provides an invalid ID then this must never
+    /// sacrifice memory safety.
+    ///
+    /// # Example
+    ///
+    /// This shows a simplistic example for walking a DFA for a given haystack,
+    /// and then finishing the search with the final EOI transition.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, Input};
+    ///
+    /// let dfa = dense::DFA::new(r"[a-z]+r")?;
+    /// let haystack = "bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// //
+    /// // The unwrap is OK because we aren't requesting a start state for a
+    /// // specific pattern.
+    /// let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     state = dfa.next_state(state, b);
+    /// }
+    /// // Matches are always delayed by 1 byte, so we must explicitly walk
+    /// // the special "EOI" transition at the end of the search. Without this
+    /// // final transition, the assert below will fail since the DFA will not
+    /// // have entered a match state yet!
+    /// state = dfa.next_eoi_state(state);
+    /// assert!(dfa.is_match_state(state));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn next_eoi_state(&self, current: StateID) -> StateID;
+
+    /// Return the ID of the start state for this lazy DFA when executing a
+    /// forward search.
+    ///
+    /// Unlike typical DFA implementations, the start state for DFAs in this
+    /// crate is dependent on a few different factors:
+    ///
+    /// * The [`Anchored`] mode of the search. Unanchored, anchored and
+    /// anchored searches for a specific [`PatternID`] all use different start
+    /// states.
+    /// * The position at which the search begins, via [`Input::start`]. This
+    /// and the byte immediately preceding the start of the search (if one
+    /// exists) influence which look-behind assertions are true at the start
+    /// of the search. This in turn influences which start state is selected.
+    /// * Whether the search is a forward or reverse search. This routine can
+    /// only be used for forward searches.
+    ///
+    /// # Errors
+    ///
+    /// This may return a [`MatchError`] if the search needs to give up
+    /// when determining the start state (for example, if it sees a "quit"
+    /// byte). This can also return an error if the given `Input` contains an
+    /// unsupported [`Anchored`] configuration.
+    fn start_state_forward(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError>;
+
+    /// Return the ID of the start state for this lazy DFA when executing a
+    /// reverse search.
+    ///
+    /// Unlike typical DFA implementations, the start state for DFAs in this
+    /// crate is dependent on a few different factors:
+    ///
+    /// * The [`Anchored`] mode of the search. Unanchored, anchored and
+    /// anchored searches for a specific [`PatternID`] all use different start
+    /// states.
+    /// * The position at which the search begins, via [`Input::start`]. This
+    /// and the byte immediately preceding the start of the search (if one
+    /// exists) influence which look-behind assertions are true at the start
+    /// of the search. This in turn influences which start state is selected.
+    /// * Whether the search is a forward or reverse search. This routine can
+    /// only be used for reverse searches.
+    ///
+    /// # Errors
+    ///
+    /// This may return a [`MatchError`] if the search needs to give up
+    /// when determining the start state (for example, if it sees a "quit"
+    /// byte). This can also return an error if the given `Input` contains an
+    /// unsupported [`Anchored`] configuration.
+    fn start_state_reverse(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError>;
+
+    /// If this DFA has a universal starting state for the given anchor mode
+    /// and the DFA supports universal starting states, then this returns that
+    /// state's identifier.
+    ///
+    /// A DFA is said to have a universal starting state when the starting
+    /// state is invariant with respect to the haystack. Usually, the starting
+    /// state is chosen depending on the bytes immediately surrounding the
+    /// starting position of a search. However, the starting state only differs
+    /// when one or more of the patterns in the DFA have look-around assertions
+    /// in its prefix.
+    ///
+    /// Stated differently, if none of the patterns in a DFA have look-around
+    /// assertions in their prefix, then the DFA has a universal starting state
+    /// and _may_ be returned by this method.
+    ///
+    /// It is always correct for implementations to return `None`, and indeed,
+    /// this is what the default implementation does. When this returns `None`,
+    /// callers must use either `start_state_forward` or `start_state_reverse`
+    /// to get the starting state.
+    ///
+    /// # Use case
+    ///
+    /// There are a few reasons why one might want to use this:
+    ///
+    /// * If you know your regex patterns have no look-around assertions in
+    /// their prefix, then calling this routine is likely cheaper and perhaps
+    /// more semantically meaningful.
+    /// * When implementing prefilter support in a DFA regex implementation,
+    /// it is necessary to re-compute the start state after a candidate
+    /// is returned from the prefilter. However, this is only needed when
+    /// there isn't a universal start state. When one exists, one can avoid
+    /// re-computing the start state.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense::DFA},
+    ///     Anchored,
+    /// };
+    ///
+    /// // There are no look-around assertions in the prefixes of any of the
+    /// // patterns, so we get a universal start state.
+    /// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+$", "[A-Z]+"])?;
+    /// assert!(dfa.universal_start_state(Anchored::No).is_some());
+    /// assert!(dfa.universal_start_state(Anchored::Yes).is_some());
+    ///
+    /// // One of the patterns has a look-around assertion in its prefix,
+    /// // so this means there is no longer a universal start state.
+    /// let dfa = DFA::new_many(&["[0-9]+", "^[a-z]+$", "[A-Z]+"])?;
+    /// assert!(!dfa.universal_start_state(Anchored::No).is_some());
+    /// assert!(!dfa.universal_start_state(Anchored::Yes).is_some());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn universal_start_state(&self, _mode: Anchored) -> Option<StateID> {
+        None
+    }
+
+    /// Returns true if and only if the given identifier corresponds to a
+    /// "special" state. A special state is one or more of the following:
+    /// a dead state, a quit state, a match state, a start state or an
+    /// accelerated state.
+    ///
+    /// A correct implementation _may_ always return false for states that
+    /// are either start states or accelerated states, since that information
+    /// is only intended to be used for optimization purposes. Correct
+    /// implementations must return true if the state is a dead, quit or match
+    /// state. This is because search routines using this trait must be able
+    /// to rely on `is_special_state` as an indicator that a state may need
+    /// special treatment. (For example, when a search routine sees a dead
+    /// state, it must terminate.)
+    ///
+    /// This routine permits search implementations to use a single branch to
+    /// check whether a state needs special attention before executing the next
+    /// transition. The example below shows how to do this.
+    ///
+    /// # Example
+    ///
+    /// This example shows how `is_special_state` can be used to implement a
+    /// correct search routine with minimal branching. In particular, this
+    /// search routine implements "leftmost" matching, which means that it
+    /// doesn't immediately stop once a match is found. Instead, it continues
+    /// until it reaches a dead state.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     HalfMatch, MatchError, Input,
+    /// };
+    ///
+    /// fn find<A: Automaton>(
+    ///     dfa: &A,
+    ///     haystack: &[u8],
+    /// ) -> Result<Option<HalfMatch>, MatchError> {
+    ///     // The start state is determined by inspecting the position and the
+    ///     // initial bytes of the haystack. Note that start states can never
+    ///     // be match states (since DFAs in this crate delay matches by 1
+    ///     // byte), so we don't need to check if the start state is a match.
+    ///     let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+    ///     let mut last_match = None;
+    ///     // Walk all the bytes in the haystack. We can quit early if we see
+    ///     // a dead or a quit state. The former means the automaton will
+    ///     // never transition to any other state. The latter means that the
+    ///     // automaton entered a condition in which its search failed.
+    ///     for (i, &b) in haystack.iter().enumerate() {
+    ///         state = dfa.next_state(state, b);
+    ///         if dfa.is_special_state(state) {
+    ///             if dfa.is_match_state(state) {
+    ///                 last_match = Some(HalfMatch::new(
+    ///                     dfa.match_pattern(state, 0),
+    ///                     i,
+    ///                 ));
+    ///             } else if dfa.is_dead_state(state) {
+    ///                 return Ok(last_match);
+    ///             } else if dfa.is_quit_state(state) {
+    ///                 // It is possible to enter into a quit state after
+    ///                 // observing a match has occurred. In that case, we
+    ///                 // should return the match instead of an error.
+    ///                 if last_match.is_some() {
+    ///                     return Ok(last_match);
+    ///                 }
+    ///                 return Err(MatchError::quit(b, i));
+    ///             }
+    ///             // Implementors may also want to check for start or accel
+    ///             // states and handle them differently for performance
+    ///             // reasons. But it is not necessary for correctness.
+    ///         }
+    ///     }
+    ///     // Matches are always delayed by 1 byte, so we must explicitly walk
+    ///     // the special "EOI" transition at the end of the search.
+    ///     state = dfa.next_eoi_state(state);
+    ///     if dfa.is_match_state(state) {
+    ///         last_match = Some(HalfMatch::new(
+    ///             dfa.match_pattern(state, 0),
+    ///             haystack.len(),
+    ///         ));
+    ///     }
+    ///     Ok(last_match)
+    /// }
+    ///
+    /// // We use a greedy '+' operator to show how the search doesn't just
+    /// // stop once a match is detected. It continues extending the match.
+    /// // Using '[a-z]+?' would also work as expected and stop the search
+    /// // early. Greediness is built into the automaton.
+    /// let dfa = dense::DFA::new(r"[a-z]+")?;
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let mat = find(&dfa, haystack)?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 0);
+    /// assert_eq!(mat.offset(), 10);
+    ///
+    /// // Here's another example that tests our handling of the special EOI
+    /// // transition. This will fail to find a match if we don't call
+    /// // 'next_eoi_state' at the end of the search since the match isn't
+    /// // found until the final byte in the haystack.
+    /// let dfa = dense::DFA::new(r"[0-9]{4}")?;
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let mat = find(&dfa, haystack)?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 0);
+    /// assert_eq!(mat.offset(), 15);
+    ///
+    /// // And note that our search implementation above automatically works
+    /// // with multi-DFAs. Namely, `dfa.match_pattern(match_state, 0)` selects
+    /// // the appropriate pattern ID for us.
+    /// let dfa = dense::DFA::new_many(&[r"[a-z]+", r"[0-9]+"])?;
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let mat = find(&dfa, haystack)?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 1);
+    /// assert_eq!(mat.offset(), 3);
+    /// let mat = find(&dfa, &haystack[3..])?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 0);
+    /// assert_eq!(mat.offset(), 7);
+    /// let mat = find(&dfa, &haystack[10..])?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 1);
+    /// assert_eq!(mat.offset(), 5);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn is_special_state(&self, id: StateID) -> bool;
+
+    /// Returns true if and only if the given identifier corresponds to a dead
+    /// state. When a DFA enters a dead state, it is impossible to leave. That
+    /// is, every transition on a dead state by definition leads back to the
+    /// same dead state.
+    ///
+    /// In practice, the dead state always corresponds to the identifier `0`.
+    /// Moreover, in practice, there is only one dead state.
+    ///
+    /// The existence of a dead state is not strictly required in the classical
+    /// model of finite state machines, where one generally only cares about
+    /// the question of whether an input sequence matches or not. Dead states
+    /// are not needed to answer that question, since one can immediately quit
+    /// as soon as one enters a final or "match" state. However, we don't just
+    /// care about matches but also care about the location of matches, and
+    /// more specifically, care about semantics like "greedy" matching.
+    ///
+    /// For example, given the pattern `a+` and the input `aaaz`, the dead
+    /// state won't be entered until the state machine reaches `z` in the
+    /// input, at which point, the search routine can quit. But without the
+    /// dead state, the search routine wouldn't know when to quit. In a
+    /// classical representation, the search routine would stop after seeing
+    /// the first `a` (which is when the search would enter a match state). But
+    /// this wouldn't implement "greedy" matching where `a+` matches as many
+    /// `a`'s as possible.
+    ///
+    /// # Example
+    ///
+    /// See the example for [`Automaton::is_special_state`] for how to use this
+    /// method correctly.
+    fn is_dead_state(&self, id: StateID) -> bool;
+
+    /// Returns true if and only if the given identifier corresponds to a quit
+    /// state. A quit state is like a dead state (it has no transitions other
+    /// than to itself), except it indicates that the DFA failed to complete
+    /// the search. When this occurs, callers can neither accept or reject that
+    /// a match occurred.
+    ///
+    /// In practice, the quit state always corresponds to the state immediately
+    /// following the dead state. (Which is not usually represented by `1`,
+    /// since state identifiers are pre-multiplied by the state machine's
+    /// alphabet stride, and the alphabet stride varies between DFAs.)
+    ///
+    /// The typical way in which a quit state can occur is when heuristic
+    /// support for Unicode word boundaries is enabled via the
+    /// [`dense::Config::unicode_word_boundary`](crate::dfa::dense::Config::unicode_word_boundary)
+    /// option. But other options, like the lower level
+    /// [`dense::Config::quit`](crate::dfa::dense::Config::quit)
+    /// configuration, can also result in a quit state being entered. The
+    /// purpose of the quit state is to provide a way to execute a fast DFA
+    /// in common cases while delegating to slower routines when the DFA quits.
+    ///
+    /// The default search implementations provided by this crate will return a
+    /// [`MatchError::quit`] error when a quit state is entered.
+    ///
+    /// # Example
+    ///
+    /// See the example for [`Automaton::is_special_state`] for how to use this
+    /// method correctly.
+    fn is_quit_state(&self, id: StateID) -> bool;
+
+    /// Returns true if and only if the given identifier corresponds to a
+    /// match state. A match state is also referred to as a "final" state and
+    /// indicates that a match has been found.
+    ///
+    /// If all you care about is whether a particular pattern matches in the
+    /// input sequence, then a search routine can quit early as soon as the
+    /// machine enters a match state. However, if you're looking for the
+    /// standard "leftmost-first" match location, then search _must_ continue
+    /// until either the end of the input or until the machine enters a dead
+    /// state. (Since either condition implies that no other useful work can
+    /// be done.) Namely, when looking for the location of a match, then
+    /// search implementations should record the most recent location in
+    /// which a match state was entered, but otherwise continue executing the
+    /// search as normal. (The search may even leave the match state.) Once
+    /// the termination condition is reached, the most recently recorded match
+    /// location should be returned.
+    ///
+    /// Finally, one additional power given to match states in this crate
+    /// is that they are always associated with a specific pattern in order
+    /// to support multi-DFAs. See [`Automaton::match_pattern`] for more
+    /// details and an example for how to query the pattern associated with a
+    /// particular match state.
+    ///
+    /// # Example
+    ///
+    /// See the example for [`Automaton::is_special_state`] for how to use this
+    /// method correctly.
+    fn is_match_state(&self, id: StateID) -> bool;
+
+    /// Returns true only if the given identifier corresponds to a start
+    /// state
+    ///
+    /// A start state is a state in which a DFA begins a search.
+    /// All searches begin in a start state. Moreover, since all matches are
+    /// delayed by one byte, a start state can never be a match state.
+    ///
+    /// The main role of a start state is, as mentioned, to be a starting
+    /// point for a DFA. This starting point is determined via one of
+    /// [`Automaton::start_state_forward`] or
+    /// [`Automaton::start_state_reverse`], depending on whether one is doing
+    /// a forward or a reverse search, respectively.
+    ///
+    /// A secondary use of start states is for prefix acceleration. Namely,
+    /// while executing a search, if one detects that you're in a start state,
+    /// then it may be faster to look for the next match of a prefix of the
+    /// pattern, if one exists. If a prefix exists and since all matches must
+    /// begin with that prefix, then skipping ahead to occurrences of that
+    /// prefix may be much faster than executing the DFA.
+    ///
+    /// As mentioned in the documentation for
+    /// [`is_special_state`](Automaton::is_special_state) implementations
+    /// _may_ always return false, even if the given identifier is a start
+    /// state. This is because knowing whether a state is a start state or not
+    /// is not necessary for correctness and is only treated as a potential
+    /// performance optimization. (For example, the implementations of this
+    /// trait in this crate will only return true when the given identifier
+    /// corresponds to a start state and when [specialization of start
+    /// states](crate::dfa::dense::Config::specialize_start_states) was enabled
+    /// during DFA construction. If start state specialization is disabled
+    /// (which is the default), then this method will always return false.)
+    ///
+    /// # Example
+    ///
+    /// This example shows how to implement your own search routine that does
+    /// a prefix search whenever the search enters a start state.
+    ///
+    /// Note that you do not need to implement your own search routine
+    /// to make use of prefilters like this. The search routines
+    /// provided by this crate already implement prefilter support via
+    /// the [`Prefilter`](crate::util::prefilter::Prefilter) trait.
+    /// A prefilter can be added to your search configuration with
+    /// [`dense::Config::prefilter`](crate::dfa::dense::Config::prefilter) for
+    /// dense and sparse DFAs in this crate.
+    ///
+    /// This example is meant to show how you might deal with prefilters in a
+    /// simplified case if you are implementing your own search routine.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     HalfMatch, MatchError, Input,
+    /// };
+    ///
+    /// fn find_byte(slice: &[u8], at: usize, byte: u8) -> Option<usize> {
+    ///     // Would be faster to use the memchr crate, but this is still
+    ///     // faster than running through the DFA.
+    ///     slice[at..].iter().position(|&b| b == byte).map(|i| at + i)
+    /// }
+    ///
+    /// fn find<A: Automaton>(
+    ///     dfa: &A,
+    ///     haystack: &[u8],
+    ///     prefix_byte: Option<u8>,
+    /// ) -> Result<Option<HalfMatch>, MatchError> {
+    ///     // See the Automaton::is_special_state example for similar code
+    ///     // with more comments.
+    ///
+    ///     let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+    ///     let mut last_match = None;
+    ///     let mut pos = 0;
+    ///     while pos < haystack.len() {
+    ///         let b = haystack[pos];
+    ///         state = dfa.next_state(state, b);
+    ///         pos += 1;
+    ///         if dfa.is_special_state(state) {
+    ///             if dfa.is_match_state(state) {
+    ///                 last_match = Some(HalfMatch::new(
+    ///                     dfa.match_pattern(state, 0),
+    ///                     pos - 1,
+    ///                 ));
+    ///             } else if dfa.is_dead_state(state) {
+    ///                 return Ok(last_match);
+    ///             } else if dfa.is_quit_state(state) {
+    ///                 // It is possible to enter into a quit state after
+    ///                 // observing a match has occurred. In that case, we
+    ///                 // should return the match instead of an error.
+    ///                 if last_match.is_some() {
+    ///                     return Ok(last_match);
+    ///                 }
+    ///                 return Err(MatchError::quit(b, pos - 1));
+    ///             } else if dfa.is_start_state(state) {
+    ///                 // If we're in a start state and know all matches begin
+    ///                 // with a particular byte, then we can quickly skip to
+    ///                 // candidate matches without running the DFA through
+    ///                 // every byte inbetween.
+    ///                 if let Some(prefix_byte) = prefix_byte {
+    ///                     pos = match find_byte(haystack, pos, prefix_byte) {
+    ///                         Some(pos) => pos,
+    ///                         None => break,
+    ///                     };
+    ///                 }
+    ///             }
+    ///         }
+    ///     }
+    ///     // Matches are always delayed by 1 byte, so we must explicitly walk
+    ///     // the special "EOI" transition at the end of the search.
+    ///     state = dfa.next_eoi_state(state);
+    ///     if dfa.is_match_state(state) {
+    ///         last_match = Some(HalfMatch::new(
+    ///             dfa.match_pattern(state, 0),
+    ///             haystack.len(),
+    ///         ));
+    ///     }
+    ///     Ok(last_match)
+    /// }
+    ///
+    /// // In this example, it's obvious that all occurrences of our pattern
+    /// // begin with 'Z', so we pass in 'Z'. Note also that we need to
+    /// // enable start state specialization, or else it won't be possible to
+    /// // detect start states during a search. ('is_start_state' would always
+    /// // return false.)
+    /// let dfa = dense::DFA::builder()
+    ///     .configure(dense::DFA::config().specialize_start_states(true))
+    ///     .build(r"Z[a-z]+")?;
+    /// let haystack = "123 foobar Zbaz quux".as_bytes();
+    /// let mat = find(&dfa, haystack, Some(b'Z'))?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 0);
+    /// assert_eq!(mat.offset(), 15);
+    ///
+    /// // But note that we don't need to pass in a prefix byte. If we don't,
+    /// // then the search routine does no acceleration.
+    /// let mat = find(&dfa, haystack, None)?.unwrap();
+    /// assert_eq!(mat.pattern().as_usize(), 0);
+    /// assert_eq!(mat.offset(), 15);
+    ///
+    /// // However, if we pass an incorrect byte, then the prefix search will
+    /// // result in incorrect results.
+    /// assert_eq!(find(&dfa, haystack, Some(b'X'))?, None);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn is_start_state(&self, id: StateID) -> bool;
+
+    /// Returns true if and only if the given identifier corresponds to an
+    /// accelerated state.
+    ///
+    /// An accelerated state is a special optimization
+    /// trick implemented by this crate. Namely, if
+    /// [`dense::Config::accelerate`](crate::dfa::dense::Config::accelerate) is
+    /// enabled (and it is by default), then DFAs generated by this crate will
+    /// tag states meeting certain characteristics as accelerated. States meet
+    /// this criteria whenever most of their transitions are self-transitions.
+    /// That is, transitions that loop back to the same state. When a small
+    /// number of transitions aren't self-transitions, then it follows that
+    /// there are only a small number of bytes that can cause the DFA to leave
+    /// that state. Thus, there is an opportunity to look for those bytes
+    /// using more optimized routines rather than continuing to run through
+    /// the DFA. This trick is similar to the prefilter idea described in
+    /// the documentation of [`Automaton::is_start_state`] with two main
+    /// differences:
+    ///
+    /// 1. It is more limited since acceleration only applies to single bytes.
+    /// This means states are rarely accelerated when Unicode mode is enabled
+    /// (which is enabled by default).
+    /// 2. It can occur anywhere in the DFA, which increases optimization
+    /// opportunities.
+    ///
+    /// Like the prefilter idea, the main downside (and a possible reason to
+    /// disable it) is that it can lead to worse performance in some cases.
+    /// Namely, if a state is accelerated for very common bytes, then the
+    /// overhead of checking for acceleration and using the more optimized
+    /// routines to look for those bytes can cause overall performance to be
+    /// worse than if acceleration wasn't enabled at all.
+    ///
+    /// A simple example of a regex that has an accelerated state is
+    /// `(?-u)[^a]+a`. Namely, the `[^a]+` sub-expression gets compiled down
+    /// into a single state where all transitions except for `a` loop back to
+    /// itself, and where `a` is the only transition (other than the special
+    /// EOI transition) that goes to some other state. Thus, this state can
+    /// be accelerated and implemented more efficiently by calling an
+    /// optimized routine like `memchr` with `a` as the needle. Notice that
+    /// the `(?-u)` to disable Unicode is necessary here, as without it,
+    /// `[^a]` will match any UTF-8 encoding of any Unicode scalar value other
+    /// than `a`. This more complicated expression compiles down to many DFA
+    /// states and the simple acceleration optimization is no longer available.
+    ///
+    /// Typically, this routine is used to guard calls to
+    /// [`Automaton::accelerator`], which returns the accelerated bytes for
+    /// the specified state.
+    fn is_accel_state(&self, id: StateID) -> bool;
+
+    /// Returns the total number of patterns compiled into this DFA.
+    ///
+    /// In the case of a DFA that contains no patterns, this must return `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the pattern length for a DFA that never matches:
+    ///
+    /// ```
+    /// use regex_automata::dfa::{Automaton, dense::DFA};
+    ///
+    /// let dfa: DFA<Vec<u32>> = DFA::never_match()?;
+    /// assert_eq!(dfa.pattern_len(), 0);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And another example for a DFA that matches at every position:
+    ///
+    /// ```
+    /// use regex_automata::dfa::{Automaton, dense::DFA};
+    ///
+    /// let dfa: DFA<Vec<u32>> = DFA::always_match()?;
+    /// assert_eq!(dfa.pattern_len(), 1);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And finally, a DFA that was constructed from multiple patterns:
+    ///
+    /// ```
+    /// use regex_automata::dfa::{Automaton, dense::DFA};
+    ///
+    /// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(dfa.pattern_len(), 3);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn pattern_len(&self) -> usize;
+
+    /// Returns the total number of patterns that match in this state.
+    ///
+    /// If the given state is not a match state, then implementations may
+    /// panic.
+    ///
+    /// If the DFA was compiled with one pattern, then this must necessarily
+    /// always return `1` for all match states.
+    ///
+    /// Implementations must guarantee that [`Automaton::match_pattern`] can be
+    /// called with indices up to (but not including) the length returned by
+    /// this routine without panicking.
+    ///
+    /// # Panics
+    ///
+    /// Implementations are permitted to panic if the provided state ID does
+    /// not correspond to a match state.
+    ///
+    /// # Example
+    ///
+    /// This example shows a simple instance of implementing overlapping
+    /// matches. In particular, it shows not only how to determine how many
+    /// patterns have matched in a particular state, but also how to access
+    /// which specific patterns have matched.
+    ///
+    /// Notice that we must use
+    /// [`MatchKind::All`](crate::MatchKind::All)
+    /// when building the DFA. If we used
+    /// [`MatchKind::LeftmostFirst`](crate::MatchKind::LeftmostFirst)
+    /// instead, then the DFA would not be constructed in a way that
+    /// supports overlapping matches. (It would only report a single pattern
+    /// that matches at any particular point in time.)
+    ///
+    /// Another thing to take note of is the patterns used and the order in
+    /// which the pattern IDs are reported. In the example below, pattern `3`
+    /// is yielded first. Why? Because it corresponds to the match that
+    /// appears first. Namely, the `@` symbol is part of `\S+` but not part
+    /// of any of the other patterns. Since the `\S+` pattern has a match that
+    /// starts to the left of any other pattern, its ID is returned before any
+    /// other.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{Automaton, dense}, Input, MatchKind};
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().match_kind(MatchKind::All))
+    ///     .build_many(&[
+    ///         r"[[:word:]]+", r"[a-z]+", r"[A-Z]+", r"[[:^space:]]+",
+    ///     ])?;
+    /// let haystack = "@bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     state = dfa.next_state(state, b);
+    /// }
+    /// state = dfa.next_eoi_state(state);
+    ///
+    /// assert!(dfa.is_match_state(state));
+    /// assert_eq!(dfa.match_len(state), 3);
+    /// // The following calls are guaranteed to not panic since `match_len`
+    /// // returned `3` above.
+    /// assert_eq!(dfa.match_pattern(state, 0).as_usize(), 3);
+    /// assert_eq!(dfa.match_pattern(state, 1).as_usize(), 0);
+    /// assert_eq!(dfa.match_pattern(state, 2).as_usize(), 1);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn match_len(&self, id: StateID) -> usize;
+
+    /// Returns the pattern ID corresponding to the given match index in the
+    /// given state.
+    ///
+    /// See [`Automaton::match_len`] for an example of how to use this
+    /// method correctly. Note that if you know your DFA is compiled with a
+    /// single pattern, then this routine is never necessary since it will
+    /// always return a pattern ID of `0` for an index of `0` when `id`
+    /// corresponds to a match state.
+    ///
+    /// Typically, this routine is used when implementing an overlapping
+    /// search, as the example for `Automaton::match_len` does.
+    ///
+    /// # Panics
+    ///
+    /// If the state ID is not a match state or if the match index is out
+    /// of bounds for the given state, then this routine may either panic
+    /// or produce an incorrect result. If the state ID is correct and the
+    /// match index is correct, then this routine must always produce a valid
+    /// `PatternID`.
+    fn match_pattern(&self, id: StateID, index: usize) -> PatternID;
+
+    /// Returns true if and only if this automaton can match the empty string.
+    /// When it returns false, all possible matches are guaranteed to have a
+    /// non-zero length.
+    ///
+    /// This is useful as cheap way to know whether code needs to handle the
+    /// case of a zero length match. This is particularly important when UTF-8
+    /// modes are enabled, as when UTF-8 mode is enabled, empty matches that
+    /// split a codepoint must never be reported. This extra handling can
+    /// sometimes be costly, and since regexes matching an empty string are
+    /// somewhat rare, it can be beneficial to treat such regexes specially.
+    ///
+    /// # Example
+    ///
+    /// This example shows a few different DFAs and whether they match the
+    /// empty string or not. Notice the empty string isn't merely a matter
+    /// of a string of length literally `0`, but rather, whether a match can
+    /// occur between specific pairs of bytes.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{dense::DFA, Automaton}, util::syntax};
+    ///
+    /// // The empty regex matches the empty string.
+    /// let dfa = DFA::new("")?;
+    /// assert!(dfa.has_empty(), "empty matches empty");
+    /// // The '+' repetition operator requires at least one match, and so
+    /// // does not match the empty string.
+    /// let dfa = DFA::new("a+")?;
+    /// assert!(!dfa.has_empty(), "+ does not match empty");
+    /// // But the '*' repetition operator does.
+    /// let dfa = DFA::new("a*")?;
+    /// assert!(dfa.has_empty(), "* does match empty");
+    /// // And wrapping '+' in an operator that can match an empty string also
+    /// // causes it to match the empty string too.
+    /// let dfa = DFA::new("(a+)*")?;
+    /// assert!(dfa.has_empty(), "+ inside of * matches empty");
+    ///
+    /// // If a regex is just made of a look-around assertion, even if the
+    /// // assertion requires some kind of non-empty string around it (such as
+    /// // \b), then it is still treated as if it matches the empty string.
+    /// // Namely, if a match occurs of just a look-around assertion, then the
+    /// // match returned is empty.
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().unicode_word_boundary(true))
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .build(r"^$\A\z\b\B(?-u:\b\B)")?;
+    /// assert!(dfa.has_empty(), "assertions match empty");
+    /// // Even when an assertion is wrapped in a '+', it still matches the
+    /// // empty string.
+    /// let dfa = DFA::new(r"^+")?;
+    /// assert!(dfa.has_empty(), "+ of an assertion matches empty");
+    ///
+    /// // An alternation with even one branch that can match the empty string
+    /// // is also said to match the empty string overall.
+    /// let dfa = DFA::new("foo|(bar)?|quux")?;
+    /// assert!(dfa.has_empty(), "alternations can match empty");
+    ///
+    /// // An NFA that matches nothing does not match the empty string.
+    /// let dfa = DFA::new("[a&&b]")?;
+    /// assert!(!dfa.has_empty(), "never matching means not matching empty");
+    /// // But if it's wrapped in something that doesn't require a match at
+    /// // all, then it can match the empty string!
+    /// let dfa = DFA::new("[a&&b]*")?;
+    /// assert!(dfa.has_empty(), "* on never-match still matches empty");
+    /// // Since a '+' requires a match, using it on something that can never
+    /// // match will itself produce a regex that can never match anything,
+    /// // and thus does not match the empty string.
+    /// let dfa = DFA::new("[a&&b]+")?;
+    /// assert!(!dfa.has_empty(), "+ on never-match still matches nothing");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn has_empty(&self) -> bool;
+
+    /// Whether UTF-8 mode is enabled for this DFA or not.
+    ///
+    /// When UTF-8 mode is enabled, all matches reported by a DFA are
+    /// guaranteed to correspond to spans of valid UTF-8. This includes
+    /// zero-width matches. For example, the DFA must guarantee that the empty
+    /// regex will not match at the positions between code units in the UTF-8
+    /// encoding of a single codepoint.
+    ///
+    /// See [`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) for
+    /// more information.
+    ///
+    /// # Example
+    ///
+    /// This example shows how UTF-8 mode can impact the match spans that may
+    /// be reported in certain cases.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// // UTF-8 mode is enabled by default.
+    /// let re = DFA::new("")?;
+    /// assert!(re.is_utf8());
+    /// let mut input = Input::new("☃");
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(Some(HalfMatch::must(0, 0)), got);
+    ///
+    /// // Even though an empty regex matches at 1..1, our next match is
+    /// // 3..3 because 1..1 and 2..2 split the snowman codepoint (which is
+    /// // three bytes long).
+    /// input.set_start(1);
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(Some(HalfMatch::must(0, 3)), got);
+    ///
+    /// // But if we disable UTF-8, then we'll get matches at 1..1 and 2..2:
+    /// let re = DFA::builder()
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build("")?;
+    /// assert!(!re.is_utf8());
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(Some(HalfMatch::must(0, 1)), got);
+    ///
+    /// input.set_start(2);
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(Some(HalfMatch::must(0, 2)), got);
+    ///
+    /// input.set_start(3);
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(Some(HalfMatch::must(0, 3)), got);
+    ///
+    /// input.set_start(4);
+    /// let got = re.try_search_fwd(&input)?;
+    /// assert_eq!(None, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn is_utf8(&self) -> bool;
+
+    /// Returns true if and only if this DFA is limited to returning matches
+    /// whose start position is `0`.
+    ///
+    /// Note that if you're using DFAs provided by
+    /// this crate, then this is _orthogonal_ to
+    /// [`Config::start_kind`](crate::dfa::dense::Config::start_kind).
+    ///
+    /// This is useful in some cases because if a DFA is limited to producing
+    /// matches that start at offset `0`, then a reverse search is never
+    /// required for finding the start of a match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::dfa::{dense::DFA, Automaton};
+    ///
+    /// // The empty regex matches anywhere
+    /// let dfa = DFA::new("")?;
+    /// assert!(!dfa.is_always_start_anchored(), "empty matches anywhere");
+    /// // 'a' matches anywhere.
+    /// let dfa = DFA::new("a")?;
+    /// assert!(!dfa.is_always_start_anchored(), "'a' matches anywhere");
+    /// // '^' only matches at offset 0!
+    /// let dfa = DFA::new("^a")?;
+    /// assert!(dfa.is_always_start_anchored(), "'^a' matches only at 0");
+    /// // But '(?m:^)' matches at 0 but at other offsets too.
+    /// let dfa = DFA::new("(?m:^)a")?;
+    /// assert!(!dfa.is_always_start_anchored(), "'(?m:^)a' matches anywhere");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    fn is_always_start_anchored(&self) -> bool;
+
+    /// Return a slice of bytes to accelerate for the given state, if possible.
+    ///
+    /// If the given state has no accelerator, then an empty slice must be
+    /// returned. If `Automaton::is_accel_state` returns true for the given ID,
+    /// then this routine _must_ return a non-empty slice. But note that it is
+    /// not required for an implementation of this trait to ever return `true`
+    /// for `is_accel_state`, even if the state _could_ be accelerated. That
+    /// is, acceleration is an optional optimization. But the return values of
+    /// `is_accel_state` and `accelerator` must be in sync.
+    ///
+    /// If the given ID is not a valid state ID for this automaton, then
+    /// implementations may panic or produce incorrect results.
+    ///
+    /// See [`Automaton::is_accel_state`] for more details on state
+    /// acceleration.
+    ///
+    /// By default, this method will always return an empty slice.
+    ///
+    /// # Example
+    ///
+    /// This example shows a contrived case in which we build a regex that we
+    /// know is accelerated and extract the accelerator from a state.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     util::{primitives::StateID, syntax},
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     // We disable Unicode everywhere and permit the regex to match
+    ///     // invalid UTF-8. e.g., [^abc] matches \xFF, which is not valid
+    ///     // UTF-8. If we left Unicode enabled, [^abc] would match any UTF-8
+    ///     // encoding of any Unicode scalar value except for 'a', 'b' or 'c'.
+    ///     // That translates to a much more complicated DFA, and also
+    ///     // inhibits the 'accelerator' optimization that we are trying to
+    ///     // demostrate in this example.
+    ///     .syntax(syntax::Config::new().unicode(false).utf8(false))
+    ///     .build("[^abc]+a")?;
+    ///
+    /// // Here we just pluck out the state that we know is accelerated.
+    /// // While the stride calculations are something that can be relied
+    /// // on by callers, the specific position of the accelerated state is
+    /// // implementation defined.
+    /// //
+    /// // N.B. We get '3' by inspecting the state machine using 'regex-cli'.
+    /// // e.g., try `regex-cli debug dfa dense '[^abc]+a' -BbUC`.
+    /// let id = StateID::new(3 * dfa.stride()).unwrap();
+    /// let accelerator = dfa.accelerator(id);
+    /// // The `[^abc]+` sub-expression permits [a, b, c] to be accelerated.
+    /// assert_eq!(accelerator, &[b'a', b'b', b'c']);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn accelerator(&self, _id: StateID) -> &[u8] {
+        &[]
+    }
+
+    /// Returns the prefilter associated with a DFA, if one exists.
+    ///
+    /// The default implementation of this trait always returns `None`. And
+    /// indeed, it is always correct to return `None`.
+    ///
+    /// For DFAs in this crate, a prefilter can be attached to a DFA via
+    /// [`dense::Config::prefilter`](crate::dfa::dense::Config::prefilter).
+    ///
+    /// Do note that prefilters are not serialized by DFAs in this crate.
+    /// So if you deserialize a DFA that had a prefilter attached to it
+    /// at serialization time, then it will not have a prefilter after
+    /// deserialization.
+    #[inline]
+    fn get_prefilter(&self) -> Option<&Prefilter> {
+        None
+    }
+
+    /// Executes a forward search and returns the end position of the leftmost
+    /// match that is found. If no match exists, then `None` is returned.
+    ///
+    /// In particular, this method continues searching even after it enters
+    /// a match state. The search only terminates once it has reached the
+    /// end of the input or when it has entered a dead or quit state. Upon
+    /// termination, the position of the last byte seen while still in a match
+    /// state is returned.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Notes for implementors
+    ///
+    /// Implementors of this trait are not required to implement any particular
+    /// match semantics (such as leftmost-first), which are instead manifest in
+    /// the DFA's transitions. But this search routine should behave as a
+    /// general "leftmost" search.
+    ///
+    /// In particular, this method must continue searching even after it enters
+    /// a match state. The search should only terminate once it has reached
+    /// the end of the input or when it has entered a dead or quit state. Upon
+    /// termination, the position of the last byte seen while still in a match
+    /// state is returned.
+    ///
+    /// Since this trait provides an implementation for this method by default,
+    /// it's unlikely that one will need to implement this.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use this method with a
+    /// [`dense::DFA`](crate::dfa::dense::DFA).
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// let dfa = dense::DFA::new("foo[0-9]+")?;
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new(b"foo12345"))?);
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over latter parts.
+    /// let dfa = dense::DFA::new("abc|a")?;
+    /// let expected = Some(HalfMatch::must(0, 3));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new(b"abc"))?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi-DFA that permits searching for
+    /// specific patterns.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     Anchored, HalfMatch, PatternID, Input,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().starts_for_each_pattern(true))
+    ///     .build_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;
+    /// let haystack = "foo123".as_bytes();
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(HalfMatch::must(0, 6));
+    /// let got = dfa.try_search_fwd(&Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// let expected = Some(HalfMatch::must(1, 6));
+    /// let got = dfa.try_search_fwd(&input)?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// // N.B. We disable Unicode here so that we use a simple ASCII word
+    /// // boundary. Alternatively, we could enable heuristic support for
+    /// // Unicode word boundaries.
+    /// let dfa = dense::DFA::new(r"(?-u)\b[0-9]{3}\b")?;
+    /// let haystack = "foo123bar".as_bytes();
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about the
+    /// // larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `3` instead of `6`.
+    /// let input = Input::new(&haystack[3..6]);
+    /// let expected = Some(HalfMatch::must(0, 3));
+    /// let got = dfa.try_search_fwd(&input)?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let input = Input::new(haystack).range(3..6);
+    /// let expected = None;
+    /// let got = dfa.try_search_fwd(&input)?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn try_search_fwd(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        let utf8empty = self.has_empty() && self.is_utf8();
+        let hm = match search::find_fwd(&self, input)? {
+            None => return Ok(None),
+            Some(hm) if !utf8empty => return Ok(Some(hm)),
+            Some(hm) => hm,
+        };
+        // We get to this point when we know our DFA can match the empty string
+        // AND when UTF-8 mode is enabled. In this case, we skip any matches
+        // whose offset splits a codepoint. Such a match is necessarily a
+        // zero-width match, because UTF-8 mode requires the underlying NFA
+        // to be built such that all non-empty matches span valid UTF-8.
+        // Therefore, any match that ends in the middle of a codepoint cannot
+        // be part of a span of valid UTF-8 and thus must be an empty match.
+        // In such cases, we skip it, so as not to report matches that split a
+        // codepoint.
+        //
+        // Note that this is not a checked assumption. Callers *can* provide an
+        // NFA with UTF-8 mode enabled but produces non-empty matches that span
+        // invalid UTF-8. But doing so is documented to result in unspecified
+        // behavior.
+        empty::skip_splits_fwd(input, hm, hm.offset(), |input| {
+            let got = search::find_fwd(&self, input)?;
+            Ok(got.map(|hm| (hm, hm.offset())))
+        })
+    }
+
+    /// Executes a reverse search and returns the start of the position of the
+    /// leftmost match that is found. If no match exists, then `None` is
+    /// returned.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use this method with a
+    /// [`dense::DFA`](crate::dfa::dense::DFA). In particular, this
+    /// routine is principally useful when used in conjunction with the
+    /// [`nfa::thompson::Config::reverse`](crate::nfa::thompson::Config::reverse)
+    /// configuration. In general, it's unlikely to be correct to use
+    /// both `try_search_fwd` and `try_search_rev` with the same DFA since
+    /// any particular DFA will only support searching in one direction with
+    /// respect to the pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson,
+    ///     dfa::{Automaton, dense},
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build("foo[0-9]+")?;
+    /// let expected = Some(HalfMatch::must(0, 0));
+    /// assert_eq!(expected, dfa.try_search_rev(&Input::new(b"foo12345"))?);
+    ///
+    /// // Even though a match is found after reading the last byte (`c`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over latter parts.
+    /// let dfa = dense::Builder::new()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build("abc|c")?;
+    /// let expected = Some(HalfMatch::must(0, 0));
+    /// assert_eq!(expected, dfa.try_search_rev(&Input::new(b"abc"))?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: UTF-8 mode
+    ///
+    /// This examples demonstrates that UTF-8 mode applies to reverse
+    /// DFAs. When UTF-8 mode is enabled in the underlying NFA, then all
+    /// matches reported must correspond to valid UTF-8 spans. This includes
+    /// prohibiting zero-width matches that split a codepoint.
+    ///
+    /// UTF-8 mode is enabled by default. Notice below how the only zero-width
+    /// matches reported are those at UTF-8 boundaries:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build(r"")?;
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let mut input = Input::new("☃");
+    /// let mut matches = vec![];
+    /// loop {
+    ///     match dfa.try_search_rev(&input)? {
+    ///         None => break,
+    ///         Some(hm) => {
+    ///             matches.push(hm);
+    ///             if hm.offset() == 0 || input.end() == 0 {
+    ///                 break;
+    ///             } else if hm.offset() < input.end() {
+    ///                 input.set_end(hm.offset());
+    ///             } else {
+    ///                 // This is only necessary to handle zero-width
+    ///                 // matches, which of course occur in this example.
+    ///                 // Without this, the search would never advance
+    ///                 // backwards beyond the initial match.
+    ///                 input.set_end(input.end() - 1);
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Now let's look at the same example, but with UTF-8 mode on the
+    /// original NFA disabled (which results in disabling UTF-8 mode on the
+    /// DFA):
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true).utf8(false))
+    ///     .build(r"")?;
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let mut input = Input::new("☃");
+    /// let mut matches = vec![];
+    /// loop {
+    ///     match dfa.try_search_rev(&input)? {
+    ///         None => break,
+    ///         Some(hm) => {
+    ///             matches.push(hm);
+    ///             if hm.offset() == 0 || input.end() == 0 {
+    ///                 break;
+    ///             } else if hm.offset() < input.end() {
+    ///                 input.set_end(hm.offset());
+    ///             } else {
+    ///                 // This is only necessary to handle zero-width
+    ///                 // matches, which of course occur in this example.
+    ///                 // Without this, the search would never advance
+    ///                 // backwards beyond the initial match.
+    ///                 input.set_end(input.end() - 1);
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 2),
+    ///     HalfMatch::must(0, 1),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn try_search_rev(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        let utf8empty = self.has_empty() && self.is_utf8();
+        let hm = match search::find_rev(self, input)? {
+            None => return Ok(None),
+            Some(hm) if !utf8empty => return Ok(Some(hm)),
+            Some(hm) => hm,
+        };
+        empty::skip_splits_rev(input, hm, hm.offset(), |input| {
+            let got = search::find_rev(self, input)?;
+            Ok(got.map(|hm| (hm, hm.offset())))
+        })
+    }
+
+    /// Executes an overlapping forward search. Matches, if one exists, can be
+    /// obtained via the [`OverlappingState::get_match`] method.
+    ///
+    /// This routine is principally only useful when searching for multiple
+    /// patterns on inputs where multiple patterns may match the same regions
+    /// of text. In particular, callers must preserve the automaton's search
+    /// state from prior calls so that the implementation knows where the last
+    /// match occurred.
+    ///
+    /// When using this routine to implement an iterator of overlapping
+    /// matches, the `start` of the search should always be set to the end
+    /// of the last match. If more patterns match at the previous location,
+    /// then they will be immediately returned. (This is tracked by the given
+    /// overlapping state.) Otherwise, the search continues at the starting
+    /// position given.
+    ///
+    /// If for some reason you want the search to forget about its previous
+    /// state and restart the search at a particular position, then setting the
+    /// state to [`OverlappingState::start`] will accomplish that.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to run a basic overlapping search with a
+    /// [`dense::DFA`](crate::dfa::dense::DFA). Notice that we build the
+    /// automaton with a `MatchKind::All` configuration. Overlapping searches
+    /// are unlikely to work as one would expect when using the default
+    /// `MatchKind::LeftmostFirst` match semantics, since leftmost-first
+    /// matching is fundamentally incompatible with overlapping searches.
+    /// Namely, overlapping searches need to report matches as they are seen,
+    /// where as leftmost-first searches will continue searching even after a
+    /// match has been observed in order to find the conventional end position
+    /// of the match. More concretely, leftmost-first searches use dead states
+    /// to terminate a search after a specific match can no longer be extended.
+    /// Overlapping searches instead do the opposite by continuing the search
+    /// to find totally new matches (potentially of other patterns).
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::{Automaton, OverlappingState, dense},
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().match_kind(MatchKind::All))
+    ///     .build_many(&[r"[[:word:]]+$", r"[[:^space:]]+$"])?;
+    /// let haystack = "@foo";
+    /// let mut state = OverlappingState::start();
+    ///
+    /// let expected = Some(HalfMatch::must(1, 4));
+    /// dfa.try_search_overlapping_fwd(&Input::new(haystack), &mut state)?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// // The first pattern also matches at the same position, so re-running
+    /// // the search will yield another match. Notice also that the first
+    /// // pattern is returned after the second. This is because the second
+    /// // pattern begins its match before the first, is therefore an earlier
+    /// // match and is thus reported first.
+    /// let expected = Some(HalfMatch::must(0, 4));
+    /// dfa.try_search_overlapping_fwd(&Input::new(haystack), &mut state)?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn try_search_overlapping_fwd(
+        &self,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        let utf8empty = self.has_empty() && self.is_utf8();
+        search::find_overlapping_fwd(self, input, state)?;
+        match state.get_match() {
+            None => Ok(()),
+            Some(_) if !utf8empty => Ok(()),
+            Some(_) => skip_empty_utf8_splits_overlapping(
+                input,
+                state,
+                |input, state| {
+                    search::find_overlapping_fwd(self, input, state)
+                },
+            ),
+        }
+    }
+
+    /// Executes a reverse overlapping forward search. Matches, if one exists,
+    /// can be obtained via the [`OverlappingState::get_match`] method.
+    ///
+    /// When using this routine to implement an iterator of overlapping
+    /// matches, the `start` of the search should remain invariant throughout
+    /// iteration. The `OverlappingState` given to the search will keep track
+    /// of the current position of the search. (This is because multiple
+    /// matches may be reported at the same position, so only the search
+    /// implementation itself knows when to advance the position.)
+    ///
+    /// If for some reason you want the search to forget about its previous
+    /// state and restart the search at a particular position, then setting the
+    /// state to [`OverlappingState::start`] will accomplish that.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example: UTF-8 mode
+    ///
+    /// This examples demonstrates that UTF-8 mode applies to reverse
+    /// DFAs. When UTF-8 mode is enabled in the underlying NFA, then all
+    /// matches reported must correspond to valid UTF-8 spans. This includes
+    /// prohibiting zero-width matches that split a codepoint.
+    ///
+    /// UTF-8 mode is enabled by default. Notice below how the only zero-width
+    /// matches reported are those at UTF-8 boundaries:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton, OverlappingState},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build_many(&[r"", r"☃"])?;
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let input = Input::new("☃");
+    /// let mut state = OverlappingState::start();
+    /// let mut matches = vec![];
+    /// loop {
+    ///     dfa.try_search_overlapping_rev(&input, &mut state)?;
+    ///     match state.get_match() {
+    ///         None => break,
+    ///         Some(hm) => matches.push(hm),
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(1, 0),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Now let's look at the same example, but with UTF-8 mode on the
+    /// original NFA disabled (which results in disabling UTF-8 mode on the
+    /// DFA):
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton, OverlappingState},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .thompson(thompson::Config::new().reverse(true).utf8(false))
+    ///     .build_many(&[r"", r"☃"])?;
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let input = Input::new("☃");
+    /// let mut state = OverlappingState::start();
+    /// let mut matches = vec![];
+    /// loop {
+    ///     dfa.try_search_overlapping_rev(&input, &mut state)?;
+    ///     match state.get_match() {
+    ///         None => break,
+    ///         Some(hm) => matches.push(hm),
+    ///     }
+    /// }
+    ///
+    /// // Now *all* positions match, even within a codepoint,
+    /// // because we lifted the requirement that matches
+    /// // correspond to valid UTF-8 spans.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 2),
+    ///     HalfMatch::must(0, 1),
+    ///     HalfMatch::must(1, 0),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    fn try_search_overlapping_rev(
+        &self,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        let utf8empty = self.has_empty() && self.is_utf8();
+        search::find_overlapping_rev(self, input, state)?;
+        match state.get_match() {
+            None => Ok(()),
+            Some(_) if !utf8empty => Ok(()),
+            Some(_) => skip_empty_utf8_splits_overlapping(
+                input,
+                state,
+                |input, state| {
+                    search::find_overlapping_rev(self, input, state)
+                },
+            ),
+        }
+    }
+
+    /// Writes the set of patterns that match anywhere in the given search
+    /// configuration to `patset`. If multiple patterns match at the same
+    /// position and the underlying DFA supports overlapping matches, then all
+    /// matching patterns are written to the given set.
+    ///
+    /// Unless all of the patterns in this DFA are anchored, then generally
+    /// speaking, this will visit every byte in the haystack.
+    ///
+    /// This search routine *does not* clear the pattern set. This gives some
+    /// flexibility to the caller (e.g., running multiple searches with the
+    /// same pattern set), but does make the API bug-prone if you're reusing
+    /// the same pattern set for multiple searches but intended them to be
+    /// independent.
+    ///
+    /// If a pattern ID matched but the given `PatternSet` does not have
+    /// sufficient capacity to store it, then it is not inserted and silently
+    /// dropped.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find all matching patterns in a haystack,
+    /// even when some patterns match at the same position as other patterns.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense::DFA},
+    ///     Input, MatchKind, PatternSet,
+    /// };
+    ///
+    /// let patterns = &[
+    ///     r"[[:word:]]+",
+    ///     r"[0-9]+",
+    ///     r"[[:alpha:]]+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ];
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build_many(patterns)?;
+    ///
+    /// let input = Input::new("foobar");
+    /// let mut patset = PatternSet::new(dfa.pattern_len());
+    /// dfa.try_which_overlapping_matches(&input, &mut patset)?;
+    /// let expected = vec![0, 2, 3, 4, 6];
+    /// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "alloc")]
+    #[inline]
+    fn try_which_overlapping_matches(
+        &self,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) -> Result<(), MatchError> {
+        let mut state = OverlappingState::start();
+        while let Some(m) = {
+            self.try_search_overlapping_fwd(input, &mut state)?;
+            state.get_match()
+        } {
+            let _ = patset.insert(m.pattern());
+            // There's nothing left to find, so we can stop. Or the caller
+            // asked us to.
+            if patset.is_full() || input.get_earliest() {
+                break;
+            }
+        }
+        Ok(())
+    }
+}
+
+unsafe impl<'a, A: Automaton + ?Sized> Automaton for &'a A {
+    #[inline]
+    fn next_state(&self, current: StateID, input: u8) -> StateID {
+        (**self).next_state(current, input)
+    }
+
+    #[inline]
+    unsafe fn next_state_unchecked(
+        &self,
+        current: StateID,
+        input: u8,
+    ) -> StateID {
+        (**self).next_state_unchecked(current, input)
+    }
+
+    #[inline]
+    fn next_eoi_state(&self, current: StateID) -> StateID {
+        (**self).next_eoi_state(current)
+    }
+
+    #[inline]
+    fn start_state_forward(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        (**self).start_state_forward(input)
+    }
+
+    #[inline]
+    fn start_state_reverse(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        (**self).start_state_reverse(input)
+    }
+
+    #[inline]
+    fn universal_start_state(&self, mode: Anchored) -> Option<StateID> {
+        (**self).universal_start_state(mode)
+    }
+
+    #[inline]
+    fn is_special_state(&self, id: StateID) -> bool {
+        (**self).is_special_state(id)
+    }
+
+    #[inline]
+    fn is_dead_state(&self, id: StateID) -> bool {
+        (**self).is_dead_state(id)
+    }
+
+    #[inline]
+    fn is_quit_state(&self, id: StateID) -> bool {
+        (**self).is_quit_state(id)
+    }
+
+    #[inline]
+    fn is_match_state(&self, id: StateID) -> bool {
+        (**self).is_match_state(id)
+    }
+
+    #[inline]
+    fn is_start_state(&self, id: StateID) -> bool {
+        (**self).is_start_state(id)
+    }
+
+    #[inline]
+    fn is_accel_state(&self, id: StateID) -> bool {
+        (**self).is_accel_state(id)
+    }
+
+    #[inline]
+    fn pattern_len(&self) -> usize {
+        (**self).pattern_len()
+    }
+
+    #[inline]
+    fn match_len(&self, id: StateID) -> usize {
+        (**self).match_len(id)
+    }
+
+    #[inline]
+    fn match_pattern(&self, id: StateID, index: usize) -> PatternID {
+        (**self).match_pattern(id, index)
+    }
+
+    #[inline]
+    fn has_empty(&self) -> bool {
+        (**self).has_empty()
+    }
+
+    #[inline]
+    fn is_utf8(&self) -> bool {
+        (**self).is_utf8()
+    }
+
+    #[inline]
+    fn is_always_start_anchored(&self) -> bool {
+        (**self).is_always_start_anchored()
+    }
+
+    #[inline]
+    fn accelerator(&self, id: StateID) -> &[u8] {
+        (**self).accelerator(id)
+    }
+
+    #[inline]
+    fn get_prefilter(&self) -> Option<&Prefilter> {
+        (**self).get_prefilter()
+    }
+
+    #[inline]
+    fn try_search_fwd(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        (**self).try_search_fwd(input)
+    }
+
+    #[inline]
+    fn try_search_rev(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        (**self).try_search_rev(input)
+    }
+
+    #[inline]
+    fn try_search_overlapping_fwd(
+        &self,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        (**self).try_search_overlapping_fwd(input, state)
+    }
+
+    #[inline]
+    fn try_search_overlapping_rev(
+        &self,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        (**self).try_search_overlapping_rev(input, state)
+    }
+
+    #[cfg(feature = "alloc")]
+    #[inline]
+    fn try_which_overlapping_matches(
+        &self,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) -> Result<(), MatchError> {
+        (**self).try_which_overlapping_matches(input, patset)
+    }
+}
+
+/// Represents the current state of an overlapping search.
+///
+/// This is used for overlapping searches since they need to know something
+/// about the previous search. For example, when multiple patterns match at the
+/// same position, this state tracks the last reported pattern so that the next
+/// search knows whether to report another matching pattern or continue with
+/// the search at the next position. Additionally, it also tracks which state
+/// the last search call terminated in.
+///
+/// This type provides little introspection capabilities. The only thing a
+/// caller can do is construct it and pass it around to permit search routines
+/// to use it to track state, and also ask whether a match has been found.
+///
+/// Callers should always provide a fresh state constructed via
+/// [`OverlappingState::start`] when starting a new search. Reusing state from
+/// a previous search may result in incorrect results.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct OverlappingState {
+    /// The match reported by the most recent overlapping search to use this
+    /// state.
+    ///
+    /// If a search does not find any matches, then it is expected to clear
+    /// this value.
+    pub(crate) mat: Option<HalfMatch>,
+    /// The state ID of the state at which the search was in when the call
+    /// terminated. When this is a match state, `last_match` must be set to a
+    /// non-None value.
+    ///
+    /// A `None` value indicates the start state of the corresponding
+    /// automaton. We cannot use the actual ID, since any one automaton may
+    /// have many start states, and which one is in use depends on several
+    /// search-time factors.
+    pub(crate) id: Option<StateID>,
+    /// The position of the search.
+    ///
+    /// When `id` is None (i.e., we are starting a search), this is set to
+    /// the beginning of the search as given by the caller regardless of its
+    /// current value. Subsequent calls to an overlapping search pick up at
+    /// this offset.
+    pub(crate) at: usize,
+    /// The index into the matching patterns of the next match to report if the
+    /// current state is a match state. Note that this may be 1 greater than
+    /// the total number of matches to report for the current match state. (In
+    /// which case, no more matches should be reported at the current position
+    /// and the search should advance to the next position.)
+    pub(crate) next_match_index: Option<usize>,
+    /// This is set to true when a reverse overlapping search has entered its
+    /// EOI transitions.
+    ///
+    /// This isn't used in a forward search because it knows to stop once the
+    /// position exceeds the end of the search range. In a reverse search,
+    /// since we use unsigned offsets, we don't "know" once we've gone past
+    /// `0`. So the only way to detect it is with this extra flag. The reverse
+    /// overlapping search knows to terminate specifically after it has
+    /// reported all matches after following the EOI transition.
+    pub(crate) rev_eoi: bool,
+}
+
+impl OverlappingState {
+    /// Create a new overlapping state that begins at the start state of any
+    /// automaton.
+    pub fn start() -> OverlappingState {
+        OverlappingState {
+            mat: None,
+            id: None,
+            at: 0,
+            next_match_index: None,
+            rev_eoi: false,
+        }
+    }
+
+    /// Return the match result of the most recent search to execute with this
+    /// state.
+    ///
+    /// A searches will clear this result automatically, such that if no
+    /// match is found, this will correctly report `None`.
+    pub fn get_match(&self) -> Option<HalfMatch> {
+        self.mat
+    }
+}
+
+/// Runs the given overlapping `search` function (forwards or backwards) until
+/// a match is found whose offset does not split a codepoint.
+///
+/// This is *not* always correct to call. It should only be called when the DFA
+/// has UTF-8 mode enabled *and* it can produce zero-width matches. Calling
+/// this when both of those things aren't true might result in legitimate
+/// matches getting skipped.
+#[cold]
+#[inline(never)]
+fn skip_empty_utf8_splits_overlapping<F>(
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+    mut search: F,
+) -> Result<(), MatchError>
+where
+    F: FnMut(&Input<'_>, &mut OverlappingState) -> Result<(), MatchError>,
+{
+    // Note that this routine works for forwards and reverse searches
+    // even though there's no code here to handle those cases. That's
+    // because overlapping searches drive themselves to completion via
+    // `OverlappingState`. So all we have to do is push it until no matches are
+    // found.
+
+    let mut hm = match state.get_match() {
+        None => return Ok(()),
+        Some(hm) => hm,
+    };
+    if input.get_anchored().is_anchored() {
+        if !input.is_char_boundary(hm.offset()) {
+            state.mat = None;
+        }
+        return Ok(());
+    }
+    while !input.is_char_boundary(hm.offset()) {
+        search(input, state)?;
+        hm = match state.get_match() {
+            None => return Ok(()),
+            Some(hm) => hm,
+        };
+    }
+    Ok(())
+}
+
+/// Write a prefix "state" indicator for fmt::Debug impls.
+///
+/// Specifically, this tries to succinctly distinguish the different types of
+/// states: dead states, quit states, accelerated states, start states and
+/// match states. It even accounts for the possible overlappings of different
+/// state types.
+pub(crate) fn fmt_state_indicator<A: Automaton>(
+    f: &mut core::fmt::Formatter<'_>,
+    dfa: A,
+    id: StateID,
+) -> core::fmt::Result {
+    if dfa.is_dead_state(id) {
+        write!(f, "D")?;
+        if dfa.is_start_state(id) {
+            write!(f, ">")?;
+        } else {
+            write!(f, " ")?;
+        }
+    } else if dfa.is_quit_state(id) {
+        write!(f, "Q ")?;
+    } else if dfa.is_start_state(id) {
+        if dfa.is_accel_state(id) {
+            write!(f, "A>")?;
+        } else {
+            write!(f, " >")?;
+        }
+    } else if dfa.is_match_state(id) {
+        if dfa.is_accel_state(id) {
+            write!(f, "A*")?;
+        } else {
+            write!(f, " *")?;
+        }
+    } else if dfa.is_accel_state(id) {
+        write!(f, "A ")?;
+    } else {
+        write!(f, "  ")?;
+    }
+    Ok(())
+}
+
+#[cfg(all(test, feature = "syntax", feature = "dfa-build"))]
+mod tests {
+    // A basic test ensuring that our Automaton trait is object safe. (This is
+    // the main reason why we don't define the search routines as generic over
+    // Into<Input>.)
+    #[test]
+    fn object_safe() {
+        use crate::{
+            dfa::{dense, Automaton},
+            HalfMatch, Input,
+        };
+
+        let dfa = dense::DFA::new("abc").unwrap();
+        let dfa: &dyn Automaton = &dfa;
+        assert_eq!(
+            Ok(Some(HalfMatch::must(0, 6))),
+            dfa.try_search_fwd(&Input::new(b"xyzabcxyz")),
+        );
+    }
+}
diff --git a/regex-automata/src/dfa/dense.rs b/regex-automata/src/dfa/dense.rs
new file mode 100644
index 0000000000..00086cc947
--- /dev/null
+++ b/regex-automata/src/dfa/dense.rs
@@ -0,0 +1,5127 @@
+/*!
+Types and routines specific to dense DFAs.
+
+This module is the home of [`dense::DFA`](DFA).
+
+This module also contains a [`dense::Builder`](Builder) and a
+[`dense::Config`](Config) for building and configuring a dense DFA.
+*/
+
+#[cfg(feature = "dfa-build")]
+use core::cmp;
+use core::{convert::TryFrom, fmt, iter, mem::size_of, slice};
+
+#[cfg(feature = "dfa-build")]
+use alloc::{
+    collections::{BTreeMap, BTreeSet},
+    vec,
+    vec::Vec,
+};
+
+#[cfg(feature = "dfa-build")]
+use crate::{
+    dfa::{
+        accel::Accel, determinize, minimize::Minimizer, remapper::Remapper,
+        sparse,
+    },
+    nfa::thompson,
+    util::{look::LookMatcher, search::MatchKind},
+};
+use crate::{
+    dfa::{
+        accel::Accels,
+        automaton::{fmt_state_indicator, Automaton},
+        special::Special,
+        start::StartKind,
+        DEAD,
+    },
+    util::{
+        alphabet::{self, ByteClasses, ByteSet},
+        int::{Pointer, Usize},
+        prefilter::Prefilter,
+        primitives::{PatternID, StateID},
+        search::{Anchored, Input, MatchError},
+        start::{Start, StartByteMap},
+        wire::{self, DeserializeError, Endian, SerializeError},
+    },
+};
+
+/// The label that is pre-pended to a serialized DFA.
+const LABEL: &str = "rust-regex-automata-dfa-dense";
+
+/// The format version of dense regexes. This version gets incremented when a
+/// change occurs. A change may not necessarily be a breaking change, but the
+/// version does permit good error messages in the case where a breaking change
+/// is made.
+const VERSION: u32 = 2;
+
+/// The configuration used for compiling a dense DFA.
+///
+/// As a convenience, [`DFA::config`] is an alias for [`Config::new`]. The
+/// advantage of the former is that it often lets you avoid importing the
+/// `Config` type directly.
+///
+/// A dense DFA configuration is a simple data object that is typically used
+/// with [`dense::Builder::configure`](self::Builder::configure).
+///
+/// The default configuration guarantees that a search will never return
+/// a "quit" error, although it is possible for a search to fail if
+/// [`Config::starts_for_each_pattern`] wasn't enabled (which it is not by
+/// default) and an [`Anchored::Pattern`] mode is requested via [`Input`].
+#[cfg(feature = "dfa-build")]
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    // As with other configuration types in this crate, we put all our knobs
+    // in options so that we can distinguish between "default" and "not set."
+    // This makes it possible to easily combine multiple configurations
+    // without default values overwriting explicitly specified values. See the
+    // 'overwrite' method.
+    //
+    // For docs on the fields below, see the corresponding method setters.
+    accelerate: Option<bool>,
+    pre: Option<Option<Prefilter>>,
+    minimize: Option<bool>,
+    match_kind: Option<MatchKind>,
+    start_kind: Option<StartKind>,
+    starts_for_each_pattern: Option<bool>,
+    byte_classes: Option<bool>,
+    unicode_word_boundary: Option<bool>,
+    quitset: Option<ByteSet>,
+    specialize_start_states: Option<bool>,
+    dfa_size_limit: Option<Option<usize>>,
+    determinize_size_limit: Option<Option<usize>>,
+}
+
+#[cfg(feature = "dfa-build")]
+impl Config {
+    /// Return a new default dense DFA compiler configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Enable state acceleration.
+    ///
+    /// When enabled, DFA construction will analyze each state to determine
+    /// whether it is eligible for simple acceleration. Acceleration typically
+    /// occurs when most of a state's transitions loop back to itself, leaving
+    /// only a select few bytes that will exit the state. When this occurs,
+    /// other routines like `memchr` can be used to look for those bytes which
+    /// may be much faster than traversing the DFA.
+    ///
+    /// Callers may elect to disable this if consistent performance is more
+    /// desirable than variable performance. Namely, acceleration can sometimes
+    /// make searching slower than it otherwise would be if the transitions
+    /// that leave accelerated states are traversed frequently.
+    ///
+    /// See [`Automaton::accelerator`](crate::dfa::Automaton::accelerator) for
+    /// an example.
+    ///
+    /// This is enabled by default.
+    pub fn accelerate(mut self, yes: bool) -> Config {
+        self.accelerate = Some(yes);
+        self
+    }
+
+    /// Set a prefilter to be used whenever a start state is entered.
+    ///
+    /// A [`Prefilter`] in this context is meant to accelerate searches by
+    /// looking for literal prefixes that every match for the corresponding
+    /// pattern (or patterns) must start with. Once a prefilter produces a
+    /// match, the underlying search routine continues on to try and confirm
+    /// the match.
+    ///
+    /// Be warned that setting a prefilter does not guarantee that the search
+    /// will be faster. While it's usually a good bet, if the prefilter
+    /// produces a lot of false positive candidates (i.e., positions matched
+    /// by the prefilter but not by the regex), then the overall result can
+    /// be slower than if you had just executed the regex engine without any
+    /// prefilters.
+    ///
+    /// Note that unless [`Config::specialize_start_states`] has been
+    /// explicitly set, then setting this will also enable (when `pre` is
+    /// `Some`) or disable (when `pre` is `None`) start state specialization.
+    /// This occurs because without start state specialization, a prefilter
+    /// is likely to be less effective. And without a prefilter, start state
+    /// specialization is usually pointless.
+    ///
+    /// **WARNING:** Note that prefilters are not preserved as part of
+    /// serialization. Serializing a DFA will drop its prefilter.
+    ///
+    /// By default no prefilter is set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton},
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "bar"]);
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 11)),
+    ///     re.try_search_fwd(&input)?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Be warned though that an incorrect prefilter can lead to incorrect
+    /// results!
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton},
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "car"]);
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(
+    ///     // No match reported even though there clearly is one!
+    ///     None,
+    ///     re.try_search_fwd(&input)?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn prefilter(mut self, pre: Option<Prefilter>) -> Config {
+        self.pre = Some(pre);
+        if self.specialize_start_states.is_none() {
+            self.specialize_start_states =
+                Some(self.get_prefilter().is_some());
+        }
+        self
+    }
+
+    /// Minimize the DFA.
+    ///
+    /// When enabled, the DFA built will be minimized such that it is as small
+    /// as possible.
+    ///
+    /// Whether one enables minimization or not depends on the types of costs
+    /// you're willing to pay and how much you care about its benefits. In
+    /// particular, minimization has worst case `O(n*k*logn)` time and `O(k*n)`
+    /// space, where `n` is the number of DFA states and `k` is the alphabet
+    /// size. In practice, minimization can be quite costly in terms of both
+    /// space and time, so it should only be done if you're willing to wait
+    /// longer to produce a DFA. In general, you might want a minimal DFA in
+    /// the following circumstances:
+    ///
+    /// 1. You would like to optimize for the size of the automaton. This can
+    ///    manifest in one of two ways. Firstly, if you're converting the
+    ///    DFA into Rust code (or a table embedded in the code), then a minimal
+    ///    DFA will translate into a corresponding reduction in code  size, and
+    ///    thus, also the final compiled binary size. Secondly, if you are
+    ///    building many DFAs and putting them on the heap, you'll be able to
+    ///    fit more if they are smaller. Note though that building a minimal
+    ///    DFA itself requires additional space; you only realize the space
+    ///    savings once the minimal DFA is constructed (at which point, the
+    ///    space used for minimization is freed).
+    /// 2. You've observed that a smaller DFA results in faster match
+    ///    performance. Naively, this isn't guaranteed since there is no
+    ///    inherent difference between matching with a bigger-than-minimal
+    ///    DFA and a minimal DFA. However, a smaller DFA may make use of your
+    ///    CPU's cache more efficiently.
+    /// 3. You are trying to establish an equivalence between regular
+    ///    languages. The standard method for this is to build a minimal DFA
+    ///    for each language and then compare them. If the DFAs are equivalent
+    ///    (up to state renaming), then the languages are equivalent.
+    ///
+    /// Typically, minimization only makes sense as an offline process. That
+    /// is, one might minimize a DFA before serializing it to persistent
+    /// storage. In practical terms, minimization can take around an order of
+    /// magnitude more time than compiling the initial DFA via determinization.
+    ///
+    /// This option is disabled by default.
+    pub fn minimize(mut self, yes: bool) -> Config {
+        self.minimize = Some(yes);
+        self
+    }
+
+    /// Set the desired match semantics.
+    ///
+    /// The default is [`MatchKind::LeftmostFirst`], which corresponds to the
+    /// match semantics of Perl-like regex engines. That is, when multiple
+    /// patterns would match at the same leftmost position, the pattern that
+    /// appears first in the concrete syntax is chosen.
+    ///
+    /// Currently, the only other kind of match semantics supported is
+    /// [`MatchKind::All`]. This corresponds to classical DFA construction
+    /// where all possible matches are added to the DFA.
+    ///
+    /// Typically, `All` is used when one wants to execute an overlapping
+    /// search and `LeftmostFirst` otherwise. In particular, it rarely makes
+    /// sense to use `All` with the various "leftmost" find routines, since the
+    /// leftmost routines depend on the `LeftmostFirst` automata construction
+    /// strategy. Specifically, `LeftmostFirst` adds dead states to the DFA
+    /// as a way to terminate the search and report a match. `LeftmostFirst`
+    /// also supports non-greedy matches using this strategy where as `All`
+    /// does not.
+    ///
+    /// # Example: overlapping search
+    ///
+    /// This example shows the typical use of `MatchKind::All`, which is to
+    /// report overlapping matches.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::{Automaton, OverlappingState, dense},
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().match_kind(MatchKind::All))
+    ///     .build_many(&[r"\w+$", r"\S+$"])?;
+    /// let input = Input::new("@foo");
+    /// let mut state = OverlappingState::start();
+    ///
+    /// let expected = Some(HalfMatch::must(1, 4));
+    /// dfa.try_search_overlapping_fwd(&input, &mut state)?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// // The first pattern also matches at the same position, so re-running
+    /// // the search will yield another match. Notice also that the first
+    /// // pattern is returned after the second. This is because the second
+    /// // pattern begins its match before the first, is therefore an earlier
+    /// // match and is thus reported first.
+    /// let expected = Some(HalfMatch::must(0, 4));
+    /// dfa.try_search_overlapping_fwd(&input, &mut state)?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: reverse automaton to find start of match
+    ///
+    /// Another example for using `MatchKind::All` is for constructing a
+    /// reverse automaton to find the start of a match. `All` semantics are
+    /// used for this in order to find the longest possible match, which
+    /// corresponds to the leftmost starting position.
+    ///
+    /// Note that if you need the starting position then
+    /// [`dfa::regex::Regex`](crate::dfa::regex::Regex) will handle this for
+    /// you, so it's usually not necessary to do this yourself.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense, Automaton, StartKind},
+    ///     nfa::thompson::NFA,
+    ///     Anchored, HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let haystack = "123foobar456".as_bytes();
+    /// let pattern = r"[a-z]+r";
+    ///
+    /// let dfa_fwd = dense::DFA::new(pattern)?;
+    /// let dfa_rev = dense::Builder::new()
+    ///     .thompson(NFA::config().reverse(true))
+    ///     .configure(dense::Config::new()
+    ///         // This isn't strictly necessary since both anchored and
+    ///         // unanchored searches are supported by default. But since
+    ///         // finding the start-of-match only requires anchored searches,
+    ///         // we can get rid of the unanchored configuration and possibly
+    ///         // slim down our DFA considerably.
+    ///         .start_kind(StartKind::Anchored)
+    ///         .match_kind(MatchKind::All)
+    ///     )
+    ///     .build(pattern)?;
+    /// let expected_fwd = HalfMatch::must(0, 9);
+    /// let expected_rev = HalfMatch::must(0, 3);
+    /// let got_fwd = dfa_fwd.try_search_fwd(&Input::new(haystack))?.unwrap();
+    /// // Here we don't specify the pattern to search for since there's only
+    /// // one pattern and we're doing a leftmost search. But if this were an
+    /// // overlapping search, you'd need to specify the pattern that matched
+    /// // in the forward direction. (Otherwise, you might wind up finding the
+    /// // starting position of a match of some other pattern.) That in turn
+    /// // requires building the reverse automaton with starts_for_each_pattern
+    /// // enabled. Indeed, this is what Regex does internally.
+    /// let input = Input::new(haystack)
+    ///     .range(..got_fwd.offset())
+    ///     .anchored(Anchored::Yes);
+    /// let got_rev = dfa_rev.try_search_rev(&input)?.unwrap();
+    /// assert_eq!(expected_fwd, got_fwd);
+    /// assert_eq!(expected_rev, got_rev);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn match_kind(mut self, kind: MatchKind) -> Config {
+        self.match_kind = Some(kind);
+        self
+    }
+
+    /// The type of starting state configuration to use for a DFA.
+    ///
+    /// By default, the starting state configuration is [`StartKind::Both`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense::DFA, Automaton, StartKind},
+    ///     Anchored, HalfMatch, Input,
+    /// };
+    ///
+    /// let haystack = "quux foo123";
+    /// let expected = HalfMatch::must(0, 11);
+    ///
+    /// // By default, DFAs support both anchored and unanchored searches.
+    /// let dfa = DFA::new(r"[0-9]+")?;
+    /// let input = Input::new(haystack);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&input)?);
+    ///
+    /// // But if we only need anchored searches, then we can build a DFA
+    /// // that only supports anchored searches. This leads to a smaller DFA
+    /// // (potentially significantly smaller in some cases), but a DFA that
+    /// // will panic if you try to use it with an unanchored search.
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().start_kind(StartKind::Anchored))
+    ///     .build(r"[0-9]+")?;
+    /// let input = Input::new(haystack)
+    ///     .range(8..)
+    ///     .anchored(Anchored::Yes);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&input)?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn start_kind(mut self, kind: StartKind) -> Config {
+        self.start_kind = Some(kind);
+        self
+    }
+
+    /// Whether to compile a separate start state for each pattern in the
+    /// automaton.
+    ///
+    /// When enabled, a separate **anchored** start state is added for each
+    /// pattern in the DFA. When this start state is used, then the DFA will
+    /// only search for matches for the pattern specified, even if there are
+    /// other patterns in the DFA.
+    ///
+    /// The main downside of this option is that it can potentially increase
+    /// the size of the DFA and/or increase the time it takes to build the DFA.
+    ///
+    /// There are a few reasons one might want to enable this (it's disabled
+    /// by default):
+    ///
+    /// 1. When looking for the start of an overlapping match (using a
+    /// reverse DFA), doing it correctly requires starting the reverse search
+    /// using the starting state of the pattern that matched in the forward
+    /// direction. Indeed, when building a [`Regex`](crate::dfa::regex::Regex),
+    /// it will automatically enable this option when building the reverse DFA
+    /// internally.
+    /// 2. When you want to use a DFA with multiple patterns to both search
+    /// for matches of any pattern or to search for anchored matches of one
+    /// particular pattern while using the same DFA. (Otherwise, you would need
+    /// to compile a new DFA for each pattern.)
+    /// 3. Since the start states added for each pattern are anchored, if you
+    /// compile an unanchored DFA with one pattern while also enabling this
+    /// option, then you can use the same DFA to perform anchored or unanchored
+    /// searches. The latter you get with the standard search APIs. The former
+    /// you get from the various `_at` search methods that allow you specify a
+    /// pattern ID to search for.
+    ///
+    /// By default this is disabled.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use this option to permit the same DFA to
+    /// run both anchored and unanchored searches for a single pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{dense, Automaton},
+    ///     Anchored, HalfMatch, PatternID, Input,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().starts_for_each_pattern(true))
+    ///     .build(r"foo[0-9]+")?;
+    /// let haystack = "quux foo123";
+    ///
+    /// // Here's a normal unanchored search. Notice that we use 'None' for the
+    /// // pattern ID. Since the DFA was built as an unanchored machine, it
+    /// // use its default unanchored starting state.
+    /// let expected = HalfMatch::must(0, 11);
+    /// let input = Input::new(haystack);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&input)?);
+    /// // But now if we explicitly specify the pattern to search ('0' being
+    /// // the only pattern in the DFA), then it will use the starting state
+    /// // for that specific pattern which is always anchored. Since the
+    /// // pattern doesn't have a match at the beginning of the haystack, we
+    /// // find nothing.
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(0)));
+    /// assert_eq!(None, dfa.try_search_fwd(&input)?);
+    /// // And finally, an anchored search is not the same as putting a '^' at
+    /// // beginning of the pattern. An anchored search can only match at the
+    /// // beginning of the *search*, which we can change:
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(0)))
+    ///     .range(5..);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&input)?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn starts_for_each_pattern(mut self, yes: bool) -> Config {
+        self.starts_for_each_pattern = Some(yes);
+        self
+    }
+
+    /// Whether to attempt to shrink the size of the DFA's alphabet or not.
+    ///
+    /// This option is enabled by default and should never be disabled unless
+    /// one is debugging a generated DFA.
+    ///
+    /// When enabled, the DFA will use a map from all possible bytes to their
+    /// corresponding equivalence class. Each equivalence class represents a
+    /// set of bytes that does not discriminate between a match and a non-match
+    /// in the DFA. For example, the pattern `[ab]+` has at least two
+    /// equivalence classes: a set containing `a` and `b` and a set containing
+    /// every byte except for `a` and `b`. `a` and `b` are in the same
+    /// equivalence class because they never discriminate between a match and a
+    /// non-match.
+    ///
+    /// The advantage of this map is that the size of the transition table
+    /// can be reduced drastically from `#states * 256 * sizeof(StateID)` to
+    /// `#states * k * sizeof(StateID)` where `k` is the number of equivalence
+    /// classes (rounded up to the nearest power of 2). As a result, total
+    /// space usage can decrease substantially. Moreover, since a smaller
+    /// alphabet is used, DFA compilation becomes faster as well.
+    ///
+    /// **WARNING:** This is only useful for debugging DFAs. Disabling this
+    /// does not yield any speed advantages. Namely, even when this is
+    /// disabled, a byte class map is still used while searching. The only
+    /// difference is that every byte will be forced into its own distinct
+    /// equivalence class. This is useful for debugging the actual generated
+    /// transitions because it lets one see the transitions defined on actual
+    /// bytes instead of the equivalence classes.
+    pub fn byte_classes(mut self, yes: bool) -> Config {
+        self.byte_classes = Some(yes);
+        self
+    }
+
+    /// Heuristically enable Unicode word boundaries.
+    ///
+    /// When set, this will attempt to implement Unicode word boundaries as if
+    /// they were ASCII word boundaries. This only works when the search input
+    /// is ASCII only. If a non-ASCII byte is observed while searching, then a
+    /// [`MatchError::quit`](crate::MatchError::quit) error is returned.
+    ///
+    /// A possible alternative to enabling this option is to simply use an
+    /// ASCII word boundary, e.g., via `(?-u:\b)`. The main reason to use this
+    /// option is if you absolutely need Unicode support. This option lets one
+    /// use a fast search implementation (a DFA) for some potentially very
+    /// common cases, while providing the option to fall back to some other
+    /// regex engine to handle the general case when an error is returned.
+    ///
+    /// If the pattern provided has no Unicode word boundary in it, then this
+    /// option has no effect. (That is, quitting on a non-ASCII byte only
+    /// occurs when this option is enabled _and_ a Unicode word boundary is
+    /// present in the pattern.)
+    ///
+    /// This is almost equivalent to setting all non-ASCII bytes to be quit
+    /// bytes. The only difference is that this will cause non-ASCII bytes to
+    /// be quit bytes _only_ when a Unicode word boundary is present in the
+    /// pattern.
+    ///
+    /// When enabling this option, callers _must_ be prepared to handle
+    /// a [`MatchError`](crate::MatchError) error during search.
+    /// When using a [`Regex`](crate::dfa::regex::Regex), this corresponds
+    /// to using the `try_` suite of methods. Alternatively, if
+    /// callers can guarantee that their input is ASCII only, then a
+    /// [`MatchError::quit`](crate::MatchError::quit) error will never be
+    /// returned while searching.
+    ///
+    /// This is disabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to heuristically enable Unicode word boundaries
+    /// in a pattern. It also shows what happens when a search comes across a
+    /// non-ASCII byte.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     HalfMatch, Input, MatchError,
+    /// };
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().unicode_word_boundary(true))
+    ///     .build(r"\b[0-9]+\b")?;
+    ///
+    /// // The match occurs before the search ever observes the snowman
+    /// // character, so no error occurs.
+    /// let haystack = "foo 123  ☃".as_bytes();
+    /// let expected = Some(HalfMatch::must(0, 7));
+    /// let got = dfa.try_search_fwd(&Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // Notice that this search fails, even though the snowman character
+    /// // occurs after the ending match offset. This is because search
+    /// // routines read one byte past the end of the search to account for
+    /// // look-around, and indeed, this is required here to determine whether
+    /// // the trailing \b matches.
+    /// let haystack = "foo 123 ☃".as_bytes();
+    /// let expected = MatchError::quit(0xE2, 8);
+    /// let got = dfa.try_search_fwd(&Input::new(haystack));
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// // Another example is executing a search where the span of the haystack
+    /// // we specify is all ASCII, but there is non-ASCII just before it. This
+    /// // correctly also reports an error.
+    /// let input = Input::new("β123").range(2..);
+    /// let expected = MatchError::quit(0xB2, 1);
+    /// let got = dfa.try_search_fwd(&input);
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// // And similarly for the trailing word boundary.
+    /// let input = Input::new("123β").range(..3);
+    /// let expected = MatchError::quit(0xCE, 3);
+    /// let got = dfa.try_search_fwd(&input);
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn unicode_word_boundary(mut self, yes: bool) -> Config {
+        // We have a separate option for this instead of just setting the
+        // appropriate quit bytes here because we don't want to set quit bytes
+        // for every regex. We only want to set them when the regex contains a
+        // Unicode word boundary.
+        self.unicode_word_boundary = Some(yes);
+        self
+    }
+
+    /// Add a "quit" byte to the DFA.
+    ///
+    /// When a quit byte is seen during search time, then search will return
+    /// a [`MatchError::quit`](crate::MatchError::quit) error indicating the
+    /// offset at which the search stopped.
+    ///
+    /// A quit byte will always overrule any other aspects of a regex. For
+    /// example, if the `x` byte is added as a quit byte and the regex `\w` is
+    /// used, then observing `x` will cause the search to quit immediately
+    /// despite the fact that `x` is in the `\w` class.
+    ///
+    /// This mechanism is primarily useful for heuristically enabling certain
+    /// features like Unicode word boundaries in a DFA. Namely, if the input
+    /// to search is ASCII, then a Unicode word boundary can be implemented
+    /// via an ASCII word boundary with no change in semantics. Thus, a DFA
+    /// can attempt to match a Unicode word boundary but give up as soon as it
+    /// observes a non-ASCII byte. Indeed, if callers set all non-ASCII bytes
+    /// to be quit bytes, then Unicode word boundaries will be permitted when
+    /// building DFAs. Of course, callers should enable
+    /// [`Config::unicode_word_boundary`] if they want this behavior instead.
+    /// (The advantage being that non-ASCII quit bytes will only be added if a
+    /// Unicode word boundary is in the pattern.)
+    ///
+    /// When enabling this option, callers _must_ be prepared to handle a
+    /// [`MatchError`](crate::MatchError) error during search. When using a
+    /// [`Regex`](crate::dfa::regex::Regex), this corresponds to using the
+    /// `try_` suite of methods.
+    ///
+    /// By default, there are no quit bytes set.
+    ///
+    /// # Panics
+    ///
+    /// This panics if heuristic Unicode word boundaries are enabled and any
+    /// non-ASCII byte is removed from the set of quit bytes. Namely, enabling
+    /// Unicode word boundaries requires setting every non-ASCII byte to a quit
+    /// byte. So if the caller attempts to undo any of that, then this will
+    /// panic.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to cause a search to terminate if it sees a
+    /// `\n` byte. This could be useful if, for example, you wanted to prevent
+    /// a user supplied pattern from matching across a line boundary.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{Automaton, dense}, Input, MatchError};
+    ///
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().quit(b'\n', true))
+    ///     .build(r"foo\p{any}+bar")?;
+    ///
+    /// let haystack = "foo\nbar".as_bytes();
+    /// // Normally this would produce a match, since \p{any} contains '\n'.
+    /// // But since we instructed the automaton to enter a quit state if a
+    /// // '\n' is observed, this produces a match error instead.
+    /// let expected = MatchError::quit(b'\n', 3);
+    /// let got = dfa.try_search_fwd(&Input::new(haystack)).unwrap_err();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn quit(mut self, byte: u8, yes: bool) -> Config {
+        if self.get_unicode_word_boundary() && !byte.is_ascii() && !yes {
+            panic!(
+                "cannot set non-ASCII byte to be non-quit when \
+                 Unicode word boundaries are enabled"
+            );
+        }
+        if self.quitset.is_none() {
+            self.quitset = Some(ByteSet::empty());
+        }
+        if yes {
+            self.quitset.as_mut().unwrap().add(byte);
+        } else {
+            self.quitset.as_mut().unwrap().remove(byte);
+        }
+        self
+    }
+
+    /// Enable specializing start states in the DFA.
+    ///
+    /// When start states are specialized, an implementor of a search routine
+    /// using a lazy DFA can tell when the search has entered a starting state.
+    /// When start states aren't specialized, then it is impossible to know
+    /// whether the search has entered a start state.
+    ///
+    /// Ideally, this option wouldn't need to exist and we could always
+    /// specialize start states. The problem is that start states can be quite
+    /// active. This in turn means that an efficient search routine is likely
+    /// to ping-pong between a heavily optimized hot loop that handles most
+    /// states and to a less optimized specialized handling of start states.
+    /// This causes branches to get heavily mispredicted and overall can
+    /// materially decrease throughput. Therefore, specializing start states
+    /// should only be enabled when it is needed.
+    ///
+    /// Knowing whether a search is in a start state is typically useful when a
+    /// prefilter is active for the search. A prefilter is typically only run
+    /// when in a start state and a prefilter can greatly accelerate a search.
+    /// Therefore, the possible cost of specializing start states is worth it
+    /// in this case. Otherwise, if you have no prefilter, there is likely no
+    /// reason to specialize start states.
+    ///
+    /// This is disabled by default, but note that it is automatically
+    /// enabled (or disabled) if [`Config::prefilter`] is set. Namely, unless
+    /// `specialize_start_states` has already been set, [`Config::prefilter`]
+    /// will automatically enable or disable it based on whether a prefilter
+    /// is present or not, respectively. This is done because a prefilter's
+    /// effectiveness is rooted in being executed whenever the DFA is in a
+    /// start state, and that's only possible to do when they are specialized.
+    ///
+    /// Note that it is plausibly reasonable to _disable_ this option
+    /// explicitly while _enabling_ a prefilter. In that case, a prefilter
+    /// will still be run at the beginning of a search, but never again. This
+    /// in theory could strike a good balance if you're in a situation where a
+    /// prefilter is likely to produce many false positive candidates.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to enable start state specialization and then
+    /// shows how to check whether a state is a start state or not.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, Input};
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().specialize_start_states(true))
+    ///     .build(r"[a-z]+")?;
+    ///
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let sid = dfa.start_state_forward(&Input::new(haystack))?;
+    /// // The ID returned by 'start_state_forward' will always be tagged as
+    /// // a start state when start state specialization is enabled.
+    /// assert!(dfa.is_special_state(sid));
+    /// assert!(dfa.is_start_state(sid));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Compare the above with the default DFA configuration where start states
+    /// are _not_ specialized. In this case, the start state is not tagged at
+    /// all:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, Input};
+    ///
+    /// let dfa = DFA::new(r"[a-z]+")?;
+    ///
+    /// let haystack = "123 foobar 4567";
+    /// let sid = dfa.start_state_forward(&Input::new(haystack))?;
+    /// // Start states are not special in the default configuration!
+    /// assert!(!dfa.is_special_state(sid));
+    /// assert!(!dfa.is_start_state(sid));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn specialize_start_states(mut self, yes: bool) -> Config {
+        self.specialize_start_states = Some(yes);
+        self
+    }
+
+    /// Set a size limit on the total heap used by a DFA.
+    ///
+    /// This size limit is expressed in bytes and is applied during
+    /// determinization of an NFA into a DFA. If the DFA's heap usage, and only
+    /// the DFA, exceeds this configured limit, then determinization is stopped
+    /// and an error is returned.
+    ///
+    /// This limit does not apply to auxiliary storage used during
+    /// determinization that isn't part of the generated DFA.
+    ///
+    /// This limit is only applied during determinization. Currently, there is
+    /// no way to post-pone this check to after minimization if minimization
+    /// was enabled.
+    ///
+    /// The total limit on heap used during determinization is the sum of the
+    /// DFA and determinization size limits.
+    ///
+    /// The default is no limit.
+    ///
+    /// # Example
+    ///
+    /// This example shows a DFA that fails to build because of a configured
+    /// size limit. This particular example also serves as a cautionary tale
+    /// demonstrating just how big DFAs with large Unicode character classes
+    /// can get.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{dense, Automaton}, Input};
+    ///
+    /// // 6MB isn't enough!
+    /// dense::Builder::new()
+    ///     .configure(dense::Config::new().dfa_size_limit(Some(6_000_000)))
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 7MB probably is!
+    /// // (Note that DFA sizes aren't necessarily stable between releases.)
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new().dfa_size_limit(Some(7_000_000)))
+    ///     .build(r"\w{20}")?;
+    /// let haystack = "A".repeat(20).into_bytes();
+    /// assert!(dfa.try_search_fwd(&Input::new(&haystack))?.is_some());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// While one needs a little more than 6MB to represent `\w{20}`, it
+    /// turns out that you only need a little more than 6KB to represent
+    /// `(?-u:\w{20})`. So only use Unicode if you need it!
+    ///
+    /// As with [`Config::determinize_size_limit`], the size of a DFA is
+    /// influenced by other factors, such as what start state configurations
+    /// to support. For example, if you only need unanchored searches and not
+    /// anchored searches, then configuring the DFA to only support unanchored
+    /// searches can reduce its size. By default, DFAs support both unanchored
+    /// and anchored searches.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{dense, Automaton, StartKind}, Input};
+    ///
+    /// // 3MB isn't enough!
+    /// dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .dfa_size_limit(Some(3_000_000))
+    ///         .start_kind(StartKind::Unanchored)
+    ///     )
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 4MB probably is!
+    /// // (Note that DFA sizes aren't necessarily stable between releases.)
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .dfa_size_limit(Some(4_000_000))
+    ///         .start_kind(StartKind::Unanchored)
+    ///     )
+    ///     .build(r"\w{20}")?;
+    /// let haystack = "A".repeat(20).into_bytes();
+    /// assert!(dfa.try_search_fwd(&Input::new(&haystack))?.is_some());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn dfa_size_limit(mut self, bytes: Option<usize>) -> Config {
+        self.dfa_size_limit = Some(bytes);
+        self
+    }
+
+    /// Set a size limit on the total heap used by determinization.
+    ///
+    /// This size limit is expressed in bytes and is applied during
+    /// determinization of an NFA into a DFA. If the heap used for auxiliary
+    /// storage during determinization (memory that is not in the DFA but
+    /// necessary for building the DFA) exceeds this configured limit, then
+    /// determinization is stopped and an error is returned.
+    ///
+    /// This limit does not apply to heap used by the DFA itself.
+    ///
+    /// The total limit on heap used during determinization is the sum of the
+    /// DFA and determinization size limits.
+    ///
+    /// The default is no limit.
+    ///
+    /// # Example
+    ///
+    /// This example shows a DFA that fails to build because of a
+    /// configured size limit on the amount of heap space used by
+    /// determinization. This particular example complements the example for
+    /// [`Config::dfa_size_limit`] by demonstrating that not only does Unicode
+    /// potentially make DFAs themselves big, but it also results in more
+    /// auxiliary storage during determinization. (Although, auxiliary storage
+    /// is still not as much as the DFA itself.)
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{dense, Automaton}, Input};
+    ///
+    /// // 600KB isn't enough!
+    /// dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .determinize_size_limit(Some(600_000))
+    ///     )
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 700KB probably is!
+    /// // (Note that auxiliary storage sizes aren't necessarily stable between
+    /// // releases.)
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .determinize_size_limit(Some(700_000))
+    ///     )
+    ///     .build(r"\w{20}")?;
+    /// let haystack = "A".repeat(20).into_bytes();
+    /// assert!(dfa.try_search_fwd(&Input::new(&haystack))?.is_some());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Note that some parts of the configuration on a DFA can have a
+    /// big impact on how big the DFA is, and thus, how much memory is
+    /// used. For example, the default setting for [`Config::start_kind`] is
+    /// [`StartKind::Both`]. But if you only need an anchored search, for
+    /// example, then it can be much cheaper to build a DFA that only supports
+    /// anchored searches. (Running an unanchored search with it would panic.)
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::{dense, Automaton, StartKind},
+    ///     Anchored, Input,
+    /// };
+    ///
+    /// // 200KB isn't enough!
+    /// dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .determinize_size_limit(Some(200_000))
+    ///         .start_kind(StartKind::Anchored)
+    ///     )
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 300KB probably is!
+    /// // (Note that auxiliary storage sizes aren't necessarily stable between
+    /// // releases.)
+    /// let dfa = dense::Builder::new()
+    ///     .configure(dense::Config::new()
+    ///         .determinize_size_limit(Some(300_000))
+    ///         .start_kind(StartKind::Anchored)
+    ///     )
+    ///     .build(r"\w{20}")?;
+    /// let haystack = "A".repeat(20).into_bytes();
+    /// let input = Input::new(&haystack).anchored(Anchored::Yes);
+    /// assert!(dfa.try_search_fwd(&input)?.is_some());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn determinize_size_limit(mut self, bytes: Option<usize>) -> Config {
+        self.determinize_size_limit = Some(bytes);
+        self
+    }
+
+    /// Returns whether this configuration has enabled simple state
+    /// acceleration.
+    pub fn get_accelerate(&self) -> bool {
+        self.accelerate.unwrap_or(true)
+    }
+
+    /// Returns the prefilter attached to this configuration, if any.
+    pub fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref().unwrap_or(&None).as_ref()
+    }
+
+    /// Returns whether this configuration has enabled the expensive process
+    /// of minimizing a DFA.
+    pub fn get_minimize(&self) -> bool {
+        self.minimize.unwrap_or(false)
+    }
+
+    /// Returns the match semantics set in this configuration.
+    pub fn get_match_kind(&self) -> MatchKind {
+        self.match_kind.unwrap_or(MatchKind::LeftmostFirst)
+    }
+
+    /// Returns the starting state configuration for a DFA.
+    pub fn get_starts(&self) -> StartKind {
+        self.start_kind.unwrap_or(StartKind::Both)
+    }
+
+    /// Returns whether this configuration has enabled anchored starting states
+    /// for every pattern in the DFA.
+    pub fn get_starts_for_each_pattern(&self) -> bool {
+        self.starts_for_each_pattern.unwrap_or(false)
+    }
+
+    /// Returns whether this configuration has enabled byte classes or not.
+    /// This is typically a debugging oriented option, as disabling it confers
+    /// no speed benefit.
+    pub fn get_byte_classes(&self) -> bool {
+        self.byte_classes.unwrap_or(true)
+    }
+
+    /// Returns whether this configuration has enabled heuristic Unicode word
+    /// boundary support. When enabled, it is possible for a search to return
+    /// an error.
+    pub fn get_unicode_word_boundary(&self) -> bool {
+        self.unicode_word_boundary.unwrap_or(false)
+    }
+
+    /// Returns whether this configuration will instruct the DFA to enter a
+    /// quit state whenever the given byte is seen during a search. When at
+    /// least one byte has this enabled, it is possible for a search to return
+    /// an error.
+    pub fn get_quit(&self, byte: u8) -> bool {
+        self.quitset.map_or(false, |q| q.contains(byte))
+    }
+
+    /// Returns whether this configuration will instruct the DFA to
+    /// "specialize" start states. When enabled, the DFA will mark start states
+    /// as "special" so that search routines using the DFA can detect when
+    /// it's in a start state and do some kind of optimization (like run a
+    /// prefilter).
+    pub fn get_specialize_start_states(&self) -> bool {
+        self.specialize_start_states.unwrap_or(false)
+    }
+
+    /// Returns the DFA size limit of this configuration if one was set.
+    /// The size limit is total number of bytes on the heap that a DFA is
+    /// permitted to use. If the DFA exceeds this limit during construction,
+    /// then construction is stopped and an error is returned.
+    pub fn get_dfa_size_limit(&self) -> Option<usize> {
+        self.dfa_size_limit.unwrap_or(None)
+    }
+
+    /// Returns the determinization size limit of this configuration if one
+    /// was set. The size limit is total number of bytes on the heap that
+    /// determinization is permitted to use. If determinization exceeds this
+    /// limit during construction, then construction is stopped and an error is
+    /// returned.
+    ///
+    /// This is different from the DFA size limit in that this only applies to
+    /// the auxiliary storage used during determinization. Once determinization
+    /// is complete, this memory is freed.
+    ///
+    /// The limit on the total heap memory used is the sum of the DFA and
+    /// determinization size limits.
+    pub fn get_determinize_size_limit(&self) -> Option<usize> {
+        self.determinize_size_limit.unwrap_or(None)
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            accelerate: o.accelerate.or(self.accelerate),
+            pre: o.pre.or_else(|| self.pre.clone()),
+            minimize: o.minimize.or(self.minimize),
+            match_kind: o.match_kind.or(self.match_kind),
+            start_kind: o.start_kind.or(self.start_kind),
+            starts_for_each_pattern: o
+                .starts_for_each_pattern
+                .or(self.starts_for_each_pattern),
+            byte_classes: o.byte_classes.or(self.byte_classes),
+            unicode_word_boundary: o
+                .unicode_word_boundary
+                .or(self.unicode_word_boundary),
+            quitset: o.quitset.or(self.quitset),
+            specialize_start_states: o
+                .specialize_start_states
+                .or(self.specialize_start_states),
+            dfa_size_limit: o.dfa_size_limit.or(self.dfa_size_limit),
+            determinize_size_limit: o
+                .determinize_size_limit
+                .or(self.determinize_size_limit),
+        }
+    }
+}
+
+/// A builder for constructing a deterministic finite automaton from regular
+/// expressions.
+///
+/// This builder provides two main things:
+///
+/// 1. It provides a few different `build` routines for actually constructing
+/// a DFA from different kinds of inputs. The most convenient is
+/// [`Builder::build`], which builds a DFA directly from a pattern string. The
+/// most flexible is [`Builder::build_from_nfa`], which builds a DFA straight
+/// from an NFA.
+/// 2. The builder permits configuring a number of things.
+/// [`Builder::configure`] is used with [`Config`] to configure aspects of
+/// the DFA and the construction process itself. [`Builder::syntax`] and
+/// [`Builder::thompson`] permit configuring the regex parser and Thompson NFA
+/// construction, respectively. The syntax and thompson configurations only
+/// apply when building from a pattern string.
+///
+/// This builder always constructs a *single* DFA. As such, this builder
+/// can only be used to construct regexes that either detect the presence
+/// of a match or find the end location of a match. A single DFA cannot
+/// produce both the start and end of a match. For that information, use a
+/// [`Regex`](crate::dfa::regex::Regex), which can be similarly configured
+/// using [`regex::Builder`](crate::dfa::regex::Builder). The main reason to
+/// use a DFA directly is if the end location of a match is enough for your use
+/// case. Namely, a `Regex` will construct two DFAs instead of one, since a
+/// second reverse DFA is needed to find the start of a match.
+///
+/// Note that if one wants to build a sparse DFA, you must first build a dense
+/// DFA and convert that to a sparse DFA. There is no way to build a sparse
+/// DFA without first building a dense DFA.
+///
+/// # Example
+///
+/// This example shows how to build a minimized DFA that completely disables
+/// Unicode. That is:
+///
+/// * Things such as `\w`, `.` and `\b` are no longer Unicode-aware. `\w`
+///   and `\b` are ASCII-only while `.` matches any byte except for `\n`
+///   (instead of any UTF-8 encoding of a Unicode scalar value except for
+///   `\n`). Things that are Unicode only, such as `\pL`, are not allowed.
+/// * The pattern itself is permitted to match invalid UTF-8. For example,
+///   things like `[^a]` that match any byte except for `a` are permitted.
+///
+/// ```
+/// use regex_automata::{
+///     dfa::{Automaton, dense},
+///     util::syntax,
+///     HalfMatch, Input,
+/// };
+///
+/// let dfa = dense::Builder::new()
+///     .configure(dense::Config::new().minimize(false))
+///     .syntax(syntax::Config::new().unicode(false).utf8(false))
+///     .build(r"foo[^b]ar.*")?;
+///
+/// let haystack = b"\xFEfoo\xFFar\xE2\x98\xFF\n";
+/// let expected = Some(HalfMatch::must(0, 10));
+/// let got = dfa.try_search_fwd(&Input::new(haystack))?;
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[cfg(feature = "dfa-build")]
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    #[cfg(feature = "syntax")]
+    thompson: thompson::Compiler,
+}
+
+#[cfg(feature = "dfa-build")]
+impl Builder {
+    /// Create a new dense DFA builder with the default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            #[cfg(feature = "syntax")]
+            thompson: thompson::Compiler::new(),
+        }
+    }
+
+    /// Build a DFA from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(&self, pattern: &str) -> Result<OwnedDFA, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a DFA from the given patterns.
+    ///
+    /// When matches are returned, the pattern ID corresponds to the index of
+    /// the pattern in the slice given.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<OwnedDFA, BuildError> {
+        let nfa = self
+            .thompson
+            .clone()
+            // We can always forcefully disable captures because DFAs do not
+            // support them.
+            .configure(thompson::Config::new().captures(false))
+            .build_many(patterns)
+            .map_err(BuildError::nfa)?;
+        self.build_from_nfa(&nfa)
+    }
+
+    /// Build a DFA from the given NFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a DFA if you already have an NFA in
+    /// hand.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense},
+    ///     nfa::thompson::NFA,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let haystack = "foo123bar".as_bytes();
+    ///
+    /// // This shows how to set non-default options for building an NFA.
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().shrink(true))
+    ///     .build(r"[0-9]+")?;
+    /// let dfa = dense::Builder::new().build_from_nfa(&nfa)?;
+    /// let expected = Some(HalfMatch::must(0, 6));
+    /// let got = dfa.try_search_fwd(&Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_nfa(
+        &self,
+        nfa: &thompson::NFA,
+    ) -> Result<OwnedDFA, BuildError> {
+        let mut quitset = self.config.quitset.unwrap_or(ByteSet::empty());
+        if self.config.get_unicode_word_boundary()
+            && nfa.look_set_any().contains_word_unicode()
+        {
+            for b in 0x80..=0xFF {
+                quitset.add(b);
+            }
+        }
+        let classes = if !self.config.get_byte_classes() {
+            // DFAs will always use the equivalence class map, but enabling
+            // this option is useful for debugging. Namely, this will cause all
+            // transitions to be defined over their actual bytes instead of an
+            // opaque equivalence class identifier. The former is much easier
+            // to grok as a human.
+            ByteClasses::singletons()
+        } else {
+            let mut set = nfa.byte_class_set().clone();
+            // It is important to distinguish any "quit" bytes from all other
+            // bytes. Otherwise, a non-quit byte may end up in the same class
+            // as a quit byte, and thus cause the DFA stop when it shouldn't.
+            //
+            // Test case:
+            //
+            //   regex-cli find hybrid regex -w @conn.json.1000x.log \
+            //     '^#' '\b10\.55\.182\.100\b'
+            if !quitset.is_empty() {
+                set.add_set(&quitset);
+            }
+            set.byte_classes()
+        };
+
+        let mut dfa = DFA::initial(
+            classes,
+            nfa.pattern_len(),
+            self.config.get_starts(),
+            nfa.look_matcher(),
+            self.config.get_starts_for_each_pattern(),
+            self.config.get_prefilter().map(|p| p.clone()),
+            quitset,
+            Flags::from_nfa(&nfa),
+        )?;
+        determinize::Config::new()
+            .match_kind(self.config.get_match_kind())
+            .quit(quitset)
+            .dfa_size_limit(self.config.get_dfa_size_limit())
+            .determinize_size_limit(self.config.get_determinize_size_limit())
+            .run(nfa, &mut dfa)?;
+        if self.config.get_minimize() {
+            dfa.minimize();
+        }
+        if self.config.get_accelerate() {
+            dfa.accelerate();
+        }
+        // The state shuffling done before this point always assumes that start
+        // states should be marked as "special," even though it isn't the
+        // default configuration. State shuffling is complex enough as it is,
+        // so it's simpler to just "fix" our special state ID ranges to not
+        // include starting states after-the-fact.
+        if !self.config.get_specialize_start_states() {
+            dfa.special.set_no_special_start_states();
+        }
+        // Look for and set the universal starting states.
+        dfa.set_universal_starts();
+        Ok(dfa)
+    }
+
+    /// Apply the given dense DFA configuration options to this builder.
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// These settings only apply when constructing a DFA directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.thompson.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like whether the DFA should match the regex
+    /// in reverse or if additional time should be spent shrinking the size of
+    /// the NFA.
+    ///
+    /// These settings only apply when constructing a DFA directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.thompson.configure(config);
+        self
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl Default for Builder {
+    fn default() -> Builder {
+        Builder::new()
+    }
+}
+
+/// A convenience alias for an owned DFA. We use this particular instantiation
+/// a lot in this crate, so it's worth giving it a name. This instantiation
+/// is commonly used for mutable APIs on the DFA while building it. The main
+/// reason for making DFAs generic is no_std support, and more generally,
+/// making it possible to load a DFA from an arbitrary slice of bytes.
+#[cfg(feature = "alloc")]
+pub(crate) type OwnedDFA = DFA<alloc::vec::Vec<u32>>;
+
+/// A dense table-based deterministic finite automaton (DFA).
+///
+/// All dense DFAs have one or more start states, zero or more match states
+/// and a transition table that maps the current state and the current byte
+/// of input to the next state. A DFA can use this information to implement
+/// fast searching. In particular, the use of a dense DFA generally makes the
+/// trade off that match speed is the most valuable characteristic, even if
+/// building the DFA may take significant time *and* space. (More concretely,
+/// building a DFA takes time and space that is exponential in the size of the
+/// pattern in the worst case.) As such, the processing of every byte of input
+/// is done with a small constant number of operations that does not vary with
+/// the pattern, its size or the size of the alphabet. If your needs don't line
+/// up with this trade off, then a dense DFA may not be an adequate solution to
+/// your problem.
+///
+/// In contrast, a [`sparse::DFA`] makes the opposite
+/// trade off: it uses less space but will execute a variable number of
+/// instructions per byte at match time, which makes it slower for matching.
+/// (Note that space usage is still exponential in the size of the pattern in
+/// the worst case.)
+///
+/// A DFA can be built using the default configuration via the
+/// [`DFA::new`] constructor. Otherwise, one can
+/// configure various aspects via [`dense::Builder`](Builder).
+///
+/// A single DFA fundamentally supports the following operations:
+///
+/// 1. Detection of a match.
+/// 2. Location of the end of a match.
+/// 3. In the case of a DFA with multiple patterns, which pattern matched is
+///    reported as well.
+///
+/// A notable absence from the above list of capabilities is the location of
+/// the *start* of a match. In order to provide both the start and end of
+/// a match, *two* DFAs are required. This functionality is provided by a
+/// [`Regex`](crate::dfa::regex::Regex).
+///
+/// # Type parameters
+///
+/// A `DFA` has one type parameter, `T`, which is used to represent state IDs,
+/// pattern IDs and accelerators. `T` is typically a `Vec<u32>` or a `&[u32]`.
+///
+/// # The `Automaton` trait
+///
+/// This type implements the [`Automaton`] trait, which means it can be used
+/// for searching. For example:
+///
+/// ```
+/// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+///
+/// let dfa = DFA::new("foo[0-9]+")?;
+/// let expected = HalfMatch::must(0, 8);
+/// assert_eq!(Some(expected), dfa.try_search_fwd(&Input::new("foo12345"))?);
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone)]
+pub struct DFA<T> {
+    /// The transition table for this DFA. This includes the transitions
+    /// themselves, along with the stride, number of states and the equivalence
+    /// class mapping.
+    tt: TransitionTable<T>,
+    /// The set of starting state identifiers for this DFA. The starting state
+    /// IDs act as pointers into the transition table. The specific starting
+    /// state chosen for each search is dependent on the context at which the
+    /// search begins.
+    st: StartTable<T>,
+    /// The set of match states and the patterns that match for each
+    /// corresponding match state.
+    ///
+    /// This structure is technically only needed because of support for
+    /// multi-regexes. Namely, multi-regexes require answering not just whether
+    /// a match exists, but _which_ patterns match. So we need to store the
+    /// matching pattern IDs for each match state. We do this even when there
+    /// is only one pattern for the sake of simplicity. In practice, this uses
+    /// up very little space for the case of one pattern.
+    ms: MatchStates<T>,
+    /// Information about which states are "special." Special states are states
+    /// that are dead, quit, matching, starting or accelerated. For more info,
+    /// see the docs for `Special`.
+    special: Special,
+    /// The accelerators for this DFA.
+    ///
+    /// If a state is accelerated, then there exist only a small number of
+    /// bytes that can cause the DFA to leave the state. This permits searching
+    /// to use optimized routines to find those specific bytes instead of using
+    /// the transition table.
+    ///
+    /// All accelerated states exist in a contiguous range in the DFA's
+    /// transition table. See dfa/special.rs for more details on how states are
+    /// arranged.
+    accels: Accels<T>,
+    /// Any prefilter attached to this DFA.
+    ///
+    /// Note that currently prefilters are not serialized. When deserializing
+    /// a DFA from bytes, this is always set to `None`.
+    pre: Option<Prefilter>,
+    /// The set of "quit" bytes for this DFA.
+    ///
+    /// This is only used when computing the start state for a particular
+    /// position in a haystack. Namely, in the case where there is a quit
+    /// byte immediately before the start of the search, this set needs to be
+    /// explicitly consulted. In all other cases, quit bytes are detected by
+    /// the DFA itself, by transitioning all quit bytes to a special "quit
+    /// state."
+    quitset: ByteSet,
+    /// Various flags describing the behavior of this DFA.
+    flags: Flags,
+}
+
+#[cfg(feature = "dfa-build")]
+impl OwnedDFA {
+    /// Parse the given regular expression using a default configuration and
+    /// return the corresponding DFA.
+    ///
+    /// If you want a non-default configuration, then use the
+    /// [`dense::Builder`](Builder) to set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// let dfa = dense::DFA::new("foo[0-9]+bar")?;
+    /// let expected = Some(HalfMatch::must(0, 11));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345bar"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<OwnedDFA, BuildError> {
+        Builder::new().build(pattern)
+    }
+
+    /// Parse the given regular expressions using a default configuration and
+    /// return the corresponding multi-DFA.
+    ///
+    /// If you want a non-default configuration, then use the
+    /// [`dense::Builder`](Builder) to set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// let dfa = dense::DFA::new_many(&["[0-9]+", "[a-z]+"])?;
+    /// let expected = Some(HalfMatch::must(1, 3));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345bar"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<OwnedDFA, BuildError> {
+        Builder::new().build_many(patterns)
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl OwnedDFA {
+    /// Create a new DFA that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// let dfa = dense::DFA::always_match()?;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 0));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new(""))?);
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<OwnedDFA, BuildError> {
+        let nfa = thompson::NFA::always_match();
+        Builder::new().build_from_nfa(&nfa)
+    }
+
+    /// Create a new DFA that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, Input};
+    ///
+    /// let dfa = dense::DFA::never_match()?;
+    /// assert_eq!(None, dfa.try_search_fwd(&Input::new(""))?);
+    /// assert_eq!(None, dfa.try_search_fwd(&Input::new("foo"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<OwnedDFA, BuildError> {
+        let nfa = thompson::NFA::never_match();
+        Builder::new().build_from_nfa(&nfa)
+    }
+
+    /// Create an initial DFA with the given equivalence classes, pattern
+    /// length and whether anchored starting states are enabled for each
+    /// pattern. An initial DFA can be further mutated via determinization.
+    fn initial(
+        classes: ByteClasses,
+        pattern_len: usize,
+        starts: StartKind,
+        lookm: &LookMatcher,
+        starts_for_each_pattern: bool,
+        pre: Option<Prefilter>,
+        quitset: ByteSet,
+        flags: Flags,
+    ) -> Result<OwnedDFA, BuildError> {
+        let start_pattern_len =
+            if starts_for_each_pattern { Some(pattern_len) } else { None };
+        Ok(DFA {
+            tt: TransitionTable::minimal(classes),
+            st: StartTable::dead(starts, lookm, start_pattern_len)?,
+            ms: MatchStates::empty(pattern_len),
+            special: Special::new(),
+            accels: Accels::empty(),
+            pre,
+            quitset,
+            flags,
+        })
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl DFA<&[u32]> {
+    /// Return a new default dense DFA compiler configuration.
+    ///
+    /// This is a convenience routine to avoid needing to import the [`Config`]
+    /// type when customizing the construction of a dense DFA.
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Create a new dense DFA builder with the default configuration.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+}
+
+impl<T: AsRef<[u32]>> DFA<T> {
+    /// Cheaply return a borrowed version of this dense DFA. Specifically,
+    /// the DFA returned always uses `&[u32]` for its transition table.
+    pub fn as_ref(&self) -> DFA<&'_ [u32]> {
+        DFA {
+            tt: self.tt.as_ref(),
+            st: self.st.as_ref(),
+            ms: self.ms.as_ref(),
+            special: self.special,
+            accels: self.accels(),
+            pre: self.pre.clone(),
+            quitset: self.quitset,
+            flags: self.flags,
+        }
+    }
+
+    /// Return an owned version of this sparse DFA. Specifically, the DFA
+    /// returned always uses `Vec<u32>` for its transition table.
+    ///
+    /// Effectively, this returns a dense DFA whose transition table lives on
+    /// the heap.
+    #[cfg(feature = "alloc")]
+    pub fn to_owned(&self) -> OwnedDFA {
+        DFA {
+            tt: self.tt.to_owned(),
+            st: self.st.to_owned(),
+            ms: self.ms.to_owned(),
+            special: self.special,
+            accels: self.accels().to_owned(),
+            pre: self.pre.clone(),
+            quitset: self.quitset,
+            flags: self.flags,
+        }
+    }
+
+    /// Returns the starting state configuration for this DFA.
+    ///
+    /// The default is [`StartKind::Both`], which means the DFA supports both
+    /// unanchored and anchored searches. However, this can generally lead to
+    /// bigger DFAs. Therefore, a DFA might be compiled with support for just
+    /// unanchored or anchored searches. In that case, running a search with
+    /// an unsupported configuration will panic.
+    pub fn start_kind(&self) -> StartKind {
+        self.st.kind
+    }
+
+    /// Returns the start byte map used for computing the `Start` configuration
+    /// at the beginning of a search.
+    pub(crate) fn start_map(&self) -> &StartByteMap {
+        &self.st.start_map
+    }
+
+    /// Returns true only if this DFA has starting states for each pattern.
+    ///
+    /// When a DFA has starting states for each pattern, then a search with the
+    /// DFA can be configured to only look for anchored matches of a specific
+    /// pattern. Specifically, APIs like [`Automaton::try_search_fwd`] can
+    /// accept a non-None `pattern_id` if and only if this method returns true.
+    /// Otherwise, calling `try_search_fwd` will panic.
+    ///
+    /// Note that if the DFA has no patterns, this always returns false.
+    pub fn starts_for_each_pattern(&self) -> bool {
+        self.st.pattern_len.is_some()
+    }
+
+    /// Returns the equivalence classes that make up the alphabet for this DFA.
+    ///
+    /// Unless [`Config::byte_classes`] was disabled, it is possible that
+    /// multiple distinct bytes are grouped into the same equivalence class
+    /// if it is impossible for them to discriminate between a match and a
+    /// non-match. This has the effect of reducing the overall alphabet size
+    /// and in turn potentially substantially reducing the size of the DFA's
+    /// transition table.
+    ///
+    /// The downside of using equivalence classes like this is that every state
+    /// transition will automatically use this map to convert an arbitrary
+    /// byte to its corresponding equivalence class. In practice this has a
+    /// negligible impact on performance.
+    pub fn byte_classes(&self) -> &ByteClasses {
+        &self.tt.classes
+    }
+
+    /// Returns the total number of elements in the alphabet for this DFA.
+    ///
+    /// That is, this returns the total number of transitions that each state
+    /// in this DFA must have. Typically, a normal byte oriented DFA would
+    /// always have an alphabet size of 256, corresponding to the number of
+    /// unique values in a single byte. However, this implementation has two
+    /// peculiarities that impact the alphabet length:
+    ///
+    /// * Every state has a special "EOI" transition that is only followed
+    /// after the end of some haystack is reached. This EOI transition is
+    /// necessary to account for one byte of look-ahead when implementing
+    /// things like `\b` and `$`.
+    /// * Bytes are grouped into equivalence classes such that no two bytes in
+    /// the same class can distinguish a match from a non-match. For example,
+    /// in the regex `^[a-z]+$`, the ASCII bytes `a-z` could all be in the
+    /// same equivalence class. This leads to a massive space savings.
+    ///
+    /// Note though that the alphabet length does _not_ necessarily equal the
+    /// total stride space taken up by a single DFA state in the transition
+    /// table. Namely, for performance reasons, the stride is always the
+    /// smallest power of two that is greater than or equal to the alphabet
+    /// length. For this reason, [`DFA::stride`] or [`DFA::stride2`] are
+    /// often more useful. The alphabet length is typically useful only for
+    /// informational purposes.
+    pub fn alphabet_len(&self) -> usize {
+        self.tt.alphabet_len()
+    }
+
+    /// Returns the total stride for every state in this DFA, expressed as the
+    /// exponent of a power of 2. The stride is the amount of space each state
+    /// takes up in the transition table, expressed as a number of transitions.
+    /// (Unused transitions map to dead states.)
+    ///
+    /// The stride of a DFA is always equivalent to the smallest power of 2
+    /// that is greater than or equal to the DFA's alphabet length. This
+    /// definition uses extra space, but permits faster translation between
+    /// premultiplied state identifiers and contiguous indices (by using shifts
+    /// instead of relying on integer division).
+    ///
+    /// For example, if the DFA's stride is 16 transitions, then its `stride2`
+    /// is `4` since `2^4 = 16`.
+    ///
+    /// The minimum `stride2` value is `1` (corresponding to a stride of `2`)
+    /// while the maximum `stride2` value is `9` (corresponding to a stride of
+    /// `512`). The maximum is not `8` since the maximum alphabet size is `257`
+    /// when accounting for the special EOI transition. However, an alphabet
+    /// length of that size is exceptionally rare since the alphabet is shrunk
+    /// into equivalence classes.
+    pub fn stride2(&self) -> usize {
+        self.tt.stride2
+    }
+
+    /// Returns the total stride for every state in this DFA. This corresponds
+    /// to the total number of transitions used by each state in this DFA's
+    /// transition table.
+    ///
+    /// Please see [`DFA::stride2`] for more information. In particular, this
+    /// returns the stride as the number of transitions, where as `stride2`
+    /// returns it as the exponent of a power of 2.
+    pub fn stride(&self) -> usize {
+        self.tt.stride()
+    }
+
+    /// Returns the memory usage, in bytes, of this DFA.
+    ///
+    /// The memory usage is computed based on the number of bytes used to
+    /// represent this DFA.
+    ///
+    /// This does **not** include the stack size used up by this DFA. To
+    /// compute that, use `std::mem::size_of::<dense::DFA>()`.
+    pub fn memory_usage(&self) -> usize {
+        self.tt.memory_usage()
+            + self.st.memory_usage()
+            + self.ms.memory_usage()
+            + self.accels.memory_usage()
+    }
+}
+
+/// Routines for converting a dense DFA to other representations, such as
+/// sparse DFAs or raw bytes suitable for persistent storage.
+impl<T: AsRef<[u32]>> DFA<T> {
+    /// Convert this dense DFA to a sparse DFA.
+    ///
+    /// If a `StateID` is too small to represent all states in the sparse
+    /// DFA, then this returns an error. In most cases, if a dense DFA is
+    /// constructable with `StateID` then a sparse DFA will be as well.
+    /// However, it is not guaranteed.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense}, HalfMatch, Input};
+    ///
+    /// let dense = dense::DFA::new("foo[0-9]+")?;
+    /// let sparse = dense.to_sparse()?;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, sparse.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_sparse(&self) -> Result<sparse::DFA<Vec<u8>>, BuildError> {
+        sparse::DFA::from_dense(self)
+    }
+
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in little endian
+    /// format. Upon success, the `Vec<u8>` and the initial padding length are
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// The padding returned is non-zero if the returned `Vec<u8>` starts at
+    /// an address that does not have the same alignment as `u32`. The padding
+    /// corresponds to the number of leading bytes written to the returned
+    /// `Vec<u8>`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using to_bytes_little_endian would work on a little endian target.
+    /// let (buf, _) = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_little_endian(&self) -> (Vec<u8>, usize) {
+        self.to_bytes::<wire::LE>()
+    }
+
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in big endian
+    /// format. Upon success, the `Vec<u8>` and the initial padding length are
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// The padding returned is non-zero if the returned `Vec<u8>` starts at
+    /// an address that does not have the same alignment as `u32`. The padding
+    /// corresponds to the number of leading bytes written to the returned
+    /// `Vec<u8>`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using to_bytes_big_endian would work on a big endian target.
+    /// let (buf, _) = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_big_endian(&self) -> (Vec<u8>, usize) {
+        self.to_bytes::<wire::BE>()
+    }
+
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in native endian
+    /// format. Upon success, the `Vec<u8>` and the initial padding length are
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// The padding returned is non-zero if the returned `Vec<u8>` starts at
+    /// an address that does not have the same alignment as `u32`. The padding
+    /// corresponds to the number of leading bytes written to the returned
+    /// `Vec<u8>`.
+    ///
+    /// Generally speaking, native endian format should only be used when
+    /// you know that the target you're compiling the DFA for matches the
+    /// endianness of the target on which you're compiling DFA. For example,
+    /// if serialization and deserialization happen in the same process or on
+    /// the same machine. Otherwise, when serializing a DFA for use in a
+    /// portable environment, you'll almost certainly want to serialize _both_
+    /// a little endian and a big endian version and then load the correct one
+    /// based on the target's configuration.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// let (buf, _) = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_native_endian(&self) -> (Vec<u8>, usize) {
+        self.to_bytes::<wire::NE>()
+    }
+
+    /// The implementation of the public `to_bytes` serialization methods,
+    /// which is generic over endianness.
+    #[cfg(feature = "dfa-build")]
+    fn to_bytes<E: Endian>(&self) -> (Vec<u8>, usize) {
+        let len = self.write_to_len();
+        let (mut buf, padding) = wire::alloc_aligned_buffer::<u32>(len);
+        // This should always succeed since the only possible serialization
+        // error is providing a buffer that's too small, but we've ensured that
+        // `buf` is big enough here.
+        self.as_ref().write_to::<E>(&mut buf[padding..]).unwrap();
+        (buf, padding)
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in little endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Note that unlike the various `to_byte_*` routines, this does not write
+    /// any padding. Callers are responsible for handling alignment correctly.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA. We
+    /// // need to use a special type to force the alignment of our [u8; N]
+    /// // array to be aligned to a 4 byte boundary. Otherwise, deserializing
+    /// // the DFA may fail because of an alignment mismatch.
+    /// #[repr(C)]
+    /// struct Aligned<B: ?Sized> {
+    ///     _align: [u32; 0],
+    ///     bytes: B,
+    /// }
+    /// let mut buf = Aligned { _align: [], bytes: [0u8; 4 * (1<<10)] };
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using write_to_little_endian would work on a little endian target.
+    /// let written = original_dfa.write_to_native_endian(&mut buf.bytes)?;
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf.bytes[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_little_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.as_ref().write_to::<wire::LE>(dst)
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in big endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Note that unlike the various `to_byte_*` routines, this does not write
+    /// any padding. Callers are responsible for handling alignment correctly.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA. We
+    /// // need to use a special type to force the alignment of our [u8; N]
+    /// // array to be aligned to a 4 byte boundary. Otherwise, deserializing
+    /// // the DFA may fail because of an alignment mismatch.
+    /// #[repr(C)]
+    /// struct Aligned<B: ?Sized> {
+    ///     _align: [u32; 0],
+    ///     bytes: B,
+    /// }
+    /// let mut buf = Aligned { _align: [], bytes: [0u8; 4 * (1<<10)] };
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using write_to_big_endian would work on a big endian target.
+    /// let written = original_dfa.write_to_native_endian(&mut buf.bytes)?;
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf.bytes[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_big_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.as_ref().write_to::<wire::BE>(dst)
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in native endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Generally speaking, native endian format should only be used when
+    /// you know that the target you're compiling the DFA for matches the
+    /// endianness of the target on which you're compiling DFA. For example,
+    /// if serialization and deserialization happen in the same process or on
+    /// the same machine. Otherwise, when serializing a DFA for use in a
+    /// portable environment, you'll almost certainly want to serialize _both_
+    /// a little endian and a big endian version and then load the correct one
+    /// based on the target's configuration.
+    ///
+    /// Note that unlike the various `to_byte_*` routines, this does not write
+    /// any padding. Callers are responsible for handling alignment correctly.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA. We
+    /// // need to use a special type to force the alignment of our [u8; N]
+    /// // array to be aligned to a 4 byte boundary. Otherwise, deserializing
+    /// // the DFA may fail because of an alignment mismatch.
+    /// #[repr(C)]
+    /// struct Aligned<B: ?Sized> {
+    ///     _align: [u32; 0],
+    ///     bytes: B,
+    /// }
+    /// let mut buf = Aligned { _align: [], bytes: [0u8; 4 * (1<<10)] };
+    /// let written = original_dfa.write_to_native_endian(&mut buf.bytes)?;
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&buf.bytes[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_native_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.as_ref().write_to::<wire::NE>(dst)
+    }
+
+    /// Return the total number of bytes required to serialize this DFA.
+    ///
+    /// This is useful for determining the size of the buffer required to pass
+    /// to one of the serialization routines:
+    ///
+    /// * [`DFA::write_to_little_endian`]
+    /// * [`DFA::write_to_big_endian`]
+    /// * [`DFA::write_to_native_endian`]
+    ///
+    /// Passing a buffer smaller than the size returned by this method will
+    /// result in a serialization error. Serialization routines are guaranteed
+    /// to succeed when the buffer is big enough.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to dynamically allocate enough room to serialize
+    /// a DFA.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// let mut buf = vec![0; original_dfa.write_to_len()];
+    /// // This is guaranteed to succeed, because the only serialization error
+    /// // that can occur is when the provided buffer is too small. But
+    /// // write_to_len guarantees a correct sie.
+    /// let written = original_dfa.write_to_native_endian(&mut buf).unwrap();
+    /// // But this is not guaranteed to succeed! In particular,
+    /// // deserialization requires proper alignment for &[u32], but our buffer
+    /// // was allocated as a &[u8] whose required alignment is smaller than
+    /// // &[u32]. However, it's likely to work in practice because of how most
+    /// // allocators work. So if you write code like this, make sure to either
+    /// // handle the error correctly and/or run it under Miri since Miri will
+    /// // likely provoke the error by returning Vec<u8> buffers with alignment
+    /// // less than &[u32].
+    /// let dfa: DFA<&[u32]> = match DFA::from_bytes(&buf[..written]) {
+    ///     // As mentioned above, it is legal for an error to be returned
+    ///     // here. It is quite difficult to get a Vec<u8> with a guaranteed
+    ///     // alignment equivalent to Vec<u32>.
+    ///     Err(_) => return Ok(()),
+    ///     Ok((dfa, _)) => dfa,
+    /// };
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Note that this example isn't actually guaranteed to work! In
+    /// particular, if `buf` is not aligned to a 4-byte boundary, then the
+    /// `DFA::from_bytes` call will fail. If you need this to work, then you
+    /// either need to deal with adding some initial padding yourself, or use
+    /// one of the `to_bytes` methods, which will do it for you.
+    pub fn write_to_len(&self) -> usize {
+        wire::write_label_len(LABEL)
+        + wire::write_endianness_check_len()
+        + wire::write_version_len()
+        + size_of::<u32>() // unused, intended for future flexibility
+        + self.flags.write_to_len()
+        + self.tt.write_to_len()
+        + self.st.write_to_len()
+        + self.ms.write_to_len()
+        + self.special.write_to_len()
+        + self.accels.write_to_len()
+        + self.quitset.write_to_len()
+    }
+}
+
+impl<'a> DFA<&'a [u32]> {
+    /// Safely deserialize a DFA with a specific state identifier
+    /// representation. Upon success, this returns both the deserialized DFA
+    /// and the number of bytes read from the given slice. Namely, the contents
+    /// of the slice beyond the DFA are not read.
+    ///
+    /// Deserializing a DFA using this routine will never allocate heap memory.
+    /// For safety purposes, the DFA's transition table will be verified such
+    /// that every transition points to a valid state. If this verification is
+    /// too costly, then a [`DFA::from_bytes_unchecked`] API is provided, which
+    /// will always execute in constant time.
+    ///
+    /// The bytes given must be generated by one of the serialization APIs
+    /// of a `DFA` using a semver compatible release of this crate. Those
+    /// include:
+    ///
+    /// * [`DFA::to_bytes_little_endian`]
+    /// * [`DFA::to_bytes_big_endian`]
+    /// * [`DFA::to_bytes_native_endian`]
+    /// * [`DFA::write_to_little_endian`]
+    /// * [`DFA::write_to_big_endian`]
+    /// * [`DFA::write_to_native_endian`]
+    ///
+    /// The `to_bytes` methods allocate and return a `Vec<u8>` for you, along
+    /// with handling alignment correctly. The `write_to` methods do not
+    /// allocate and write to an existing slice (which may be on the stack).
+    /// Since deserialization always uses the native endianness of the target
+    /// platform, the serialization API you use should match the endianness of
+    /// the target platform. (It's often a good idea to generate serialized
+    /// DFAs for both forms of endianness and then load the correct one based
+    /// on endianness.)
+    ///
+    /// # Errors
+    ///
+    /// Generally speaking, it's easier to state the conditions in which an
+    /// error is _not_ returned. All of the following must be true:
+    ///
+    /// * The bytes given must be produced by one of the serialization APIs
+    ///   on this DFA, as mentioned above.
+    /// * The endianness of the target platform matches the endianness used to
+    ///   serialized the provided DFA.
+    /// * The slice given must have the same alignment as `u32`.
+    ///
+    /// If any of the above are not true, then an error will be returned.
+    ///
+    /// # Panics
+    ///
+    /// This routine will never panic for any input.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize a DFA to raw bytes, deserialize it
+    /// and then use it for searching.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// let initial = DFA::new("foo[0-9]+")?;
+    /// let (bytes, _) = initial.to_bytes_native_endian();
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&bytes)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: dealing with alignment and padding
+    ///
+    /// In the above example, we used the `to_bytes_native_endian` method to
+    /// serialize a DFA, but we ignored part of its return value corresponding
+    /// to padding added to the beginning of the serialized DFA. This is OK
+    /// because deserialization will skip this initial padding. What matters
+    /// is that the address immediately following the padding has an alignment
+    /// that matches `u32`. That is, the following is an equivalent but
+    /// alternative way to write the above example:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// let initial = DFA::new("foo[0-9]+")?;
+    /// // Serialization returns the number of leading padding bytes added to
+    /// // the returned Vec<u8>.
+    /// let (bytes, pad) = initial.to_bytes_native_endian();
+    /// let dfa: DFA<&[u32]> = DFA::from_bytes(&bytes[pad..])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This padding is necessary because Rust's standard library does
+    /// not expose any safe and robust way of creating a `Vec<u8>` with a
+    /// guaranteed alignment other than 1. Now, in practice, the underlying
+    /// allocator is likely to provide a `Vec<u8>` that meets our alignment
+    /// requirements, which means `pad` is zero in practice most of the time.
+    ///
+    /// The purpose of exposing the padding like this is flexibility for the
+    /// caller. For example, if one wants to embed a serialized DFA into a
+    /// compiled program, then it's important to guarantee that it starts at a
+    /// `u32`-aligned address. The simplest way to do this is to discard the
+    /// padding bytes and set it up so that the serialized DFA itself begins at
+    /// a properly aligned address. We can show this in two parts. The first
+    /// part is serializing the DFA to a file:
+    ///
+    /// ```no_run
+    /// use regex_automata::dfa::dense::DFA;
+    ///
+    /// let dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// let (bytes, pad) = dfa.to_bytes_big_endian();
+    /// // Write the contents of the DFA *without* the initial padding.
+    /// std::fs::write("foo.bigendian.dfa", &bytes[pad..])?;
+    ///
+    /// // Do it again, but this time for little endian.
+    /// let (bytes, pad) = dfa.to_bytes_little_endian();
+    /// std::fs::write("foo.littleendian.dfa", &bytes[pad..])?;
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And now the second part is embedding the DFA into the compiled program
+    /// and deserializing it at runtime on first use. We use conditional
+    /// compilation to choose the correct endianness.
+    ///
+    /// ```no_run
+    /// use regex_automata::{
+    ///     dfa::{Automaton, dense::DFA},
+    ///     util::{lazy::Lazy, wire::AlignAs},
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// // This crate provides its own "lazy" type, kind of like
+    /// // lazy_static! or once_cell::sync::Lazy. But it works in no-alloc
+    /// // no-std environments and let's us write this using completely
+    /// // safe code.
+    /// static RE: Lazy<DFA<&'static [u32]>> = Lazy::new(|| {
+    ///     # const _: &str = stringify! {
+    ///     // This assignment is made possible (implicitly) via the
+    ///     // CoerceUnsized trait. This is what guarantees that our
+    ///     // bytes are stored in memory on a 4 byte boundary. You
+    ///     // *must* do this or something equivalent for correct
+    ///     // deserialization.
+    ///     static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {
+    ///         _align: [],
+    ///         #[cfg(target_endian = "big")]
+    ///         bytes: *include_bytes!("foo.bigendian.dfa"),
+    ///         #[cfg(target_endian = "little")]
+    ///         bytes: *include_bytes!("foo.littleendian.dfa"),
+    ///     };
+    ///     # };
+    ///     # static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {
+    ///     #     _align: [],
+    ///     #     bytes: [],
+    ///     # };
+    ///
+    ///     let (dfa, _) = DFA::from_bytes(&ALIGNED.bytes)
+    ///         .expect("serialized DFA should be valid");
+    ///     dfa
+    /// });
+    ///
+    /// let expected = Ok(Some(HalfMatch::must(0, 8)));
+    /// assert_eq!(expected, RE.try_search_fwd(&Input::new("foo12345")));
+    /// ```
+    ///
+    /// An alternative to [`util::lazy::Lazy`](crate::util::lazy::Lazy)
+    /// is [`lazy_static`](https://crates.io/crates/lazy_static) or
+    /// [`once_cell`](https://crates.io/crates/once_cell), which provide
+    /// stronger guarantees (like the initialization function only being
+    /// executed once). And `once_cell` in particular provides a more
+    /// expressive API. But a `Lazy` value from this crate is likely just fine
+    /// in most circumstances.
+    ///
+    /// Note that regardless of which initialization method you use, you
+    /// will still need to use the [`AlignAs`](crate::util::wire::AlignAs)
+    /// trick above to force correct alignment, but this is safe to do and
+    /// `from_bytes` will return an error if you get it wrong.
+    pub fn from_bytes(
+        slice: &'a [u8],
+    ) -> Result<(DFA<&'a [u32]>, usize), DeserializeError> {
+        // SAFETY: This is safe because we validate the transition table, start
+        // table, match states and accelerators below. If any validation fails,
+        // then we return an error.
+        let (dfa, nread) = unsafe { DFA::from_bytes_unchecked(slice)? };
+        dfa.tt.validate(&dfa.special)?;
+        dfa.st.validate(&dfa.tt)?;
+        dfa.ms.validate(&dfa)?;
+        dfa.accels.validate()?;
+        // N.B. dfa.special doesn't have a way to do unchecked deserialization,
+        // so it has already been validated.
+        Ok((dfa, nread))
+    }
+
+    /// Deserialize a DFA with a specific state identifier representation in
+    /// constant time by omitting the verification of the validity of the
+    /// transition table and other data inside the DFA.
+    ///
+    /// This is just like [`DFA::from_bytes`], except it can potentially return
+    /// a DFA that exhibits undefined behavior if its transition table contains
+    /// invalid state identifiers.
+    ///
+    /// This routine is useful if you need to deserialize a DFA cheaply
+    /// and cannot afford the transition table validation performed by
+    /// `from_bytes`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, dense::DFA}, HalfMatch, Input};
+    ///
+    /// let initial = DFA::new("foo[0-9]+")?;
+    /// let (bytes, _) = initial.to_bytes_native_endian();
+    /// // SAFETY: This is guaranteed to be safe since the bytes given come
+    /// // directly from a compatible serialization routine.
+    /// let dfa: DFA<&[u32]> = unsafe { DFA::from_bytes_unchecked(&bytes)?.0 };
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub unsafe fn from_bytes_unchecked(
+        slice: &'a [u8],
+    ) -> Result<(DFA<&'a [u32]>, usize), DeserializeError> {
+        let mut nr = 0;
+
+        nr += wire::skip_initial_padding(slice);
+        wire::check_alignment::<StateID>(&slice[nr..])?;
+        nr += wire::read_label(&slice[nr..], LABEL)?;
+        nr += wire::read_endianness_check(&slice[nr..])?;
+        nr += wire::read_version(&slice[nr..], VERSION)?;
+
+        let _unused = wire::try_read_u32(&slice[nr..], "unused space")?;
+        nr += size_of::<u32>();
+
+        let (flags, nread) = Flags::from_bytes(&slice[nr..])?;
+        nr += nread;
+
+        let (tt, nread) = TransitionTable::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (st, nread) = StartTable::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (ms, nread) = MatchStates::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (special, nread) = Special::from_bytes(&slice[nr..])?;
+        nr += nread;
+        special.validate_state_len(tt.len(), tt.stride2)?;
+
+        let (accels, nread) = Accels::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (quitset, nread) = ByteSet::from_bytes(&slice[nr..])?;
+        nr += nread;
+
+        // Prefilters don't support serialization, so they're always absent.
+        let pre = None;
+        Ok((DFA { tt, st, ms, special, accels, pre, quitset, flags }, nr))
+    }
+
+    /// The implementation of the public `write_to` serialization methods,
+    /// which is generic over endianness.
+    ///
+    /// This is defined only for &[u32] to reduce binary size/compilation time.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("dense DFA"));
+        }
+        dst = &mut dst[..nwrite];
+
+        let mut nw = 0;
+        nw += wire::write_label(LABEL, &mut dst[nw..])?;
+        nw += wire::write_endianness_check::<E>(&mut dst[nw..])?;
+        nw += wire::write_version::<E>(VERSION, &mut dst[nw..])?;
+        nw += {
+            // Currently unused, intended for future flexibility
+            E::write_u32(0, &mut dst[nw..]);
+            size_of::<u32>()
+        };
+        nw += self.flags.write_to::<E>(&mut dst[nw..])?;
+        nw += self.tt.write_to::<E>(&mut dst[nw..])?;
+        nw += self.st.write_to::<E>(&mut dst[nw..])?;
+        nw += self.ms.write_to::<E>(&mut dst[nw..])?;
+        nw += self.special.write_to::<E>(&mut dst[nw..])?;
+        nw += self.accels.write_to::<E>(&mut dst[nw..])?;
+        nw += self.quitset.write_to::<E>(&mut dst[nw..])?;
+        Ok(nw)
+    }
+}
+
+// The following methods implement mutable routines on the internal
+// representation of a DFA. As such, we must fix the first type parameter to a
+// `Vec<u32>` since a generic `T: AsRef<[u32]>` does not permit mutation. We
+// can get away with this because these methods are internal to the crate and
+// are exclusively used during construction of the DFA.
+#[cfg(feature = "dfa-build")]
+impl OwnedDFA {
+    /// Add a start state of this DFA.
+    pub(crate) fn set_start_state(
+        &mut self,
+        anchored: Anchored,
+        start: Start,
+        id: StateID,
+    ) {
+        assert!(self.tt.is_valid(id), "invalid start state");
+        self.st.set_start(anchored, start, id);
+    }
+
+    /// Set the given transition to this DFA. Both the `from` and `to` states
+    /// must already exist.
+    pub(crate) fn set_transition(
+        &mut self,
+        from: StateID,
+        byte: alphabet::Unit,
+        to: StateID,
+    ) {
+        self.tt.set(from, byte, to);
+    }
+
+    /// An an empty state (a state where all transitions lead to a dead state)
+    /// and return its identifier. The identifier returned is guaranteed to
+    /// not point to any other existing state.
+    ///
+    /// If adding a state would exceed `StateID::LIMIT`, then this returns an
+    /// error.
+    pub(crate) fn add_empty_state(&mut self) -> Result<StateID, BuildError> {
+        self.tt.add_empty_state()
+    }
+
+    /// Swap the two states given in the transition table.
+    ///
+    /// This routine does not do anything to check the correctness of this
+    /// swap. Callers must ensure that other states pointing to id1 and id2 are
+    /// updated appropriately.
+    pub(crate) fn swap_states(&mut self, id1: StateID, id2: StateID) {
+        self.tt.swap(id1, id2);
+    }
+
+    /// Remap all of the state identifiers in this DFA according to the map
+    /// function given. This includes all transitions and all starting state
+    /// identifiers.
+    pub(crate) fn remap(&mut self, map: impl Fn(StateID) -> StateID) {
+        // We could loop over each state ID and call 'remap_state' here, but
+        // this is more direct: just map every transition directly. This
+        // technically might do a little extra work since the alphabet length
+        // is likely less than the stride, but if that is indeed an issue we
+        // should benchmark it and fix it.
+        for sid in self.tt.table_mut().iter_mut() {
+            *sid = map(*sid);
+        }
+        for sid in self.st.table_mut().iter_mut() {
+            *sid = map(*sid);
+        }
+    }
+
+    /// Remap the transitions for the state given according to the function
+    /// given. This applies the given map function to every transition in the
+    /// given state and changes the transition in place to the result of the
+    /// map function for that transition.
+    pub(crate) fn remap_state(
+        &mut self,
+        id: StateID,
+        map: impl Fn(StateID) -> StateID,
+    ) {
+        self.tt.remap(id, map);
+    }
+
+    /// Truncate the states in this DFA to the given length.
+    ///
+    /// This routine does not do anything to check the correctness of this
+    /// truncation. Callers must ensure that other states pointing to truncated
+    /// states are updated appropriately.
+    pub(crate) fn truncate_states(&mut self, len: usize) {
+        self.tt.truncate(len);
+    }
+
+    /// Minimize this DFA in place using Hopcroft's algorithm.
+    pub(crate) fn minimize(&mut self) {
+        Minimizer::new(self).run();
+    }
+
+    /// Updates the match state pattern ID map to use the one provided.
+    ///
+    /// This is useful when it's convenient to manipulate matching states
+    /// (and their corresponding pattern IDs) as a map. In particular, the
+    /// representation used by a DFA for this map is not amenable to mutation,
+    /// so if things need to be changed (like when shuffling states), it's
+    /// often easier to work with the map form.
+    pub(crate) fn set_pattern_map(
+        &mut self,
+        map: &BTreeMap<StateID, Vec<PatternID>>,
+    ) -> Result<(), BuildError> {
+        self.ms = self.ms.new_with_map(map)?;
+        Ok(())
+    }
+
+    /// Find states that have a small number of non-loop transitions and mark
+    /// them as candidates for acceleration during search.
+    pub(crate) fn accelerate(&mut self) {
+        // dead and quit states can never be accelerated.
+        if self.state_len() <= 2 {
+            return;
+        }
+
+        // Go through every state and record their accelerator, if possible.
+        let mut accels = BTreeMap::new();
+        // Count the number of accelerated match, start and non-match/start
+        // states.
+        let (mut cmatch, mut cstart, mut cnormal) = (0, 0, 0);
+        for state in self.states() {
+            if let Some(accel) = state.accelerate(self.byte_classes()) {
+                debug!(
+                    "accelerating full DFA state {}: {:?}",
+                    state.id().as_usize(),
+                    accel,
+                );
+                accels.insert(state.id(), accel);
+                if self.is_match_state(state.id()) {
+                    cmatch += 1;
+                } else if self.is_start_state(state.id()) {
+                    cstart += 1;
+                } else {
+                    assert!(!self.is_dead_state(state.id()));
+                    assert!(!self.is_quit_state(state.id()));
+                    cnormal += 1;
+                }
+            }
+        }
+        // If no states were able to be accelerated, then we're done.
+        if accels.is_empty() {
+            return;
+        }
+        let original_accels_len = accels.len();
+
+        // A remapper keeps track of state ID changes. Once we're done
+        // shuffling, the remapper is used to rewrite all transitions in the
+        // DFA based on the new positions of states.
+        let mut remapper = Remapper::new(self);
+
+        // As we swap states, if they are match states, we need to swap their
+        // pattern ID lists too (for multi-regexes). We do this by converting
+        // the lists to an easily swappable map, and then convert back to
+        // MatchStates once we're done.
+        let mut new_matches = self.ms.to_map(self);
+
+        // There is at least one state that gets accelerated, so these are
+        // guaranteed to get set to sensible values below.
+        self.special.min_accel = StateID::MAX;
+        self.special.max_accel = StateID::ZERO;
+        let update_special_accel =
+            |special: &mut Special, accel_id: StateID| {
+                special.min_accel = cmp::min(special.min_accel, accel_id);
+                special.max_accel = cmp::max(special.max_accel, accel_id);
+            };
+
+        // Start by shuffling match states. Any match states that are
+        // accelerated get moved to the end of the match state range.
+        if cmatch > 0 && self.special.matches() {
+            // N.B. special.{min,max}_match do not need updating, since the
+            // range/number of match states does not change. Only the ordering
+            // of match states may change.
+            let mut next_id = self.special.max_match;
+            let mut cur_id = next_id;
+            while cur_id >= self.special.min_match {
+                if let Some(accel) = accels.remove(&cur_id) {
+                    accels.insert(next_id, accel);
+                    update_special_accel(&mut self.special, next_id);
+
+                    // No need to do any actual swapping for equivalent IDs.
+                    if cur_id != next_id {
+                        remapper.swap(self, cur_id, next_id);
+
+                        // Swap pattern IDs for match states.
+                        let cur_pids = new_matches.remove(&cur_id).unwrap();
+                        let next_pids = new_matches.remove(&next_id).unwrap();
+                        new_matches.insert(cur_id, next_pids);
+                        new_matches.insert(next_id, cur_pids);
+                    }
+                    next_id = self.tt.prev_state_id(next_id);
+                }
+                cur_id = self.tt.prev_state_id(cur_id);
+            }
+        }
+
+        // This is where it gets tricky. Without acceleration, start states
+        // normally come right after match states. But we want accelerated
+        // states to be a single contiguous range (to make it very fast
+        // to determine whether a state *is* accelerated), while also keeping
+        // match and starting states as contiguous ranges for the same reason.
+        // So what we do here is shuffle states such that it looks like this:
+        //
+        //     DQMMMMAAAAASSSSSSNNNNNNN
+        //         |         |
+        //         |---------|
+        //      accelerated states
+        //
+        // Where:
+        //   D - dead state
+        //   Q - quit state
+        //   M - match state (may be accelerated)
+        //   A - normal state that is accelerated
+        //   S - start state (may be accelerated)
+        //   N - normal state that is NOT accelerated
+        //
+        // We implement this by shuffling states, which is done by a sequence
+        // of pairwise swaps. We start by looking at all normal states to be
+        // accelerated. When we find one, we swap it with the earliest starting
+        // state, and then swap that with the earliest normal state. This
+        // preserves the contiguous property.
+        //
+        // Once we're done looking for accelerated normal states, now we look
+        // for accelerated starting states by moving them to the beginning
+        // of the starting state range (just like we moved accelerated match
+        // states to the end of the matching state range).
+        //
+        // For a more detailed/different perspective on this, see the docs
+        // in dfa/special.rs.
+        if cnormal > 0 {
+            // our next available starting and normal states for swapping.
+            let mut next_start_id = self.special.min_start;
+            let mut cur_id = self.to_state_id(self.state_len() - 1);
+            // This is guaranteed to exist since cnormal > 0.
+            let mut next_norm_id =
+                self.tt.next_state_id(self.special.max_start);
+            while cur_id >= next_norm_id {
+                if let Some(accel) = accels.remove(&cur_id) {
+                    remapper.swap(self, next_start_id, cur_id);
+                    remapper.swap(self, next_norm_id, cur_id);
+                    // Keep our accelerator map updated with new IDs if the
+                    // states we swapped were also accelerated.
+                    if let Some(accel2) = accels.remove(&next_norm_id) {
+                        accels.insert(cur_id, accel2);
+                    }
+                    if let Some(accel2) = accels.remove(&next_start_id) {
+                        accels.insert(next_norm_id, accel2);
+                    }
+                    accels.insert(next_start_id, accel);
+                    update_special_accel(&mut self.special, next_start_id);
+                    // Our start range shifts one to the right now.
+                    self.special.min_start =
+                        self.tt.next_state_id(self.special.min_start);
+                    self.special.max_start =
+                        self.tt.next_state_id(self.special.max_start);
+                    next_start_id = self.tt.next_state_id(next_start_id);
+                    next_norm_id = self.tt.next_state_id(next_norm_id);
+                }
+                // This is pretty tricky, but if our 'next_norm_id' state also
+                // happened to be accelerated, then the result is that it is
+                // now in the position of cur_id, so we need to consider it
+                // again. This loop is still guaranteed to terminate though,
+                // because when accels contains cur_id, we're guaranteed to
+                // increment next_norm_id even if cur_id remains unchanged.
+                if !accels.contains_key(&cur_id) {
+                    cur_id = self.tt.prev_state_id(cur_id);
+                }
+            }
+        }
+        // Just like we did for match states, but we want to move accelerated
+        // start states to the beginning of the range instead of the end.
+        if cstart > 0 {
+            // N.B. special.{min,max}_start do not need updating, since the
+            // range/number of start states does not change at this point. Only
+            // the ordering of start states may change.
+            let mut next_id = self.special.min_start;
+            let mut cur_id = next_id;
+            while cur_id <= self.special.max_start {
+                if let Some(accel) = accels.remove(&cur_id) {
+                    remapper.swap(self, cur_id, next_id);
+                    accels.insert(next_id, accel);
+                    update_special_accel(&mut self.special, next_id);
+                    next_id = self.tt.next_state_id(next_id);
+                }
+                cur_id = self.tt.next_state_id(cur_id);
+            }
+        }
+
+        // Remap all transitions in our DFA and assert some things.
+        remapper.remap(self);
+        // This unwrap is OK because acceleration never changes the number of
+        // match states or patterns in those match states. Since acceleration
+        // runs after the pattern map has been set at least once, we know that
+        // our match states cannot error.
+        self.set_pattern_map(&new_matches).unwrap();
+        self.special.set_max();
+        self.special.validate().expect("special state ranges should validate");
+        self.special
+            .validate_state_len(self.state_len(), self.stride2())
+            .expect(
+                "special state ranges should be consistent with state length",
+            );
+        assert_eq!(
+            self.special.accel_len(self.stride()),
+            // We record the number of accelerated states initially detected
+            // since the accels map is itself mutated in the process above.
+            // If mutated incorrectly, its size may change, and thus can't be
+            // trusted as a source of truth of how many accelerated states we
+            // expected there to be.
+            original_accels_len,
+            "mismatch with expected number of accelerated states",
+        );
+
+        // And finally record our accelerators. We kept our accels map updated
+        // as we shuffled states above, so the accelerators should now
+        // correspond to a contiguous range in the state ID space. (Which we
+        // assert.)
+        let mut prev: Option<StateID> = None;
+        for (id, accel) in accels {
+            assert!(prev.map_or(true, |p| self.tt.next_state_id(p) == id));
+            prev = Some(id);
+            self.accels.add(accel);
+        }
+    }
+
+    /// Shuffle the states in this DFA so that starting states, match
+    /// states and accelerated states are all contiguous.
+    ///
+    /// See dfa/special.rs for more details.
+    pub(crate) fn shuffle(
+        &mut self,
+        mut matches: BTreeMap<StateID, Vec<PatternID>>,
+    ) -> Result<(), BuildError> {
+        // The determinizer always adds a quit state and it is always second.
+        self.special.quit_id = self.to_state_id(1);
+        // If all we have are the dead and quit states, then we're done and
+        // the DFA will never produce a match.
+        if self.state_len() <= 2 {
+            self.special.set_max();
+            return Ok(());
+        }
+
+        // Collect all our non-DEAD start states into a convenient set and
+        // confirm there is no overlap with match states. In the classicl DFA
+        // construction, start states can be match states. But because of
+        // look-around, we delay all matches by a byte, which prevents start
+        // states from being match states.
+        let mut is_start: BTreeSet<StateID> = BTreeSet::new();
+        for (start_id, _, _) in self.starts() {
+            // If a starting configuration points to a DEAD state, then we
+            // don't want to shuffle it. The DEAD state is always the first
+            // state with ID=0. So we can just leave it be.
+            if start_id == DEAD {
+                continue;
+            }
+            assert!(
+                !matches.contains_key(&start_id),
+                "{:?} is both a start and a match state, which is not allowed",
+                start_id,
+            );
+            is_start.insert(start_id);
+        }
+
+        // We implement shuffling by a sequence of pairwise swaps of states.
+        // Since we have a number of things referencing states via their
+        // IDs and swapping them changes their IDs, we need to record every
+        // swap we make so that we can remap IDs. The remapper handles this
+        // book-keeping for us.
+        let mut remapper = Remapper::new(self);
+
+        // Shuffle matching states.
+        if matches.is_empty() {
+            self.special.min_match = DEAD;
+            self.special.max_match = DEAD;
+        } else {
+            // The determinizer guarantees that the first two states are the
+            // dead and quit states, respectively. We want our match states to
+            // come right after quit.
+            let mut next_id = self.to_state_id(2);
+            let mut new_matches = BTreeMap::new();
+            self.special.min_match = next_id;
+            for (id, pids) in matches {
+                remapper.swap(self, next_id, id);
+                new_matches.insert(next_id, pids);
+                // If we swapped a start state, then update our set.
+                if is_start.contains(&next_id) {
+                    is_start.remove(&next_id);
+                    is_start.insert(id);
+                }
+                next_id = self.tt.next_state_id(next_id);
+            }
+            matches = new_matches;
+            self.special.max_match = cmp::max(
+                self.special.min_match,
+                self.tt.prev_state_id(next_id),
+            );
+        }
+
+        // Shuffle starting states.
+        {
+            let mut next_id = self.to_state_id(2);
+            if self.special.matches() {
+                next_id = self.tt.next_state_id(self.special.max_match);
+            }
+            self.special.min_start = next_id;
+            for id in is_start {
+                remapper.swap(self, next_id, id);
+                next_id = self.tt.next_state_id(next_id);
+            }
+            self.special.max_start = cmp::max(
+                self.special.min_start,
+                self.tt.prev_state_id(next_id),
+            );
+        }
+
+        // Finally remap all transitions in our DFA.
+        remapper.remap(self);
+        self.set_pattern_map(&matches)?;
+        self.special.set_max();
+        self.special.validate().expect("special state ranges should validate");
+        self.special
+            .validate_state_len(self.state_len(), self.stride2())
+            .expect(
+                "special state ranges should be consistent with state length",
+            );
+        Ok(())
+    }
+
+    /// Checks whether there are universal start states (both anchored and
+    /// unanchored), and if so, sets the relevant fields to the start state
+    /// IDs.
+    ///
+    /// Universal start states occur precisely when the all patterns in the
+    /// DFA have no look-around assertions in their prefix.
+    fn set_universal_starts(&mut self) {
+        assert_eq!(6, Start::len(), "expected 6 start configurations");
+
+        let start_id = |dfa: &mut OwnedDFA, inp: &Input<'_>, start: Start| {
+            // This OK because we only call 'start' under conditions
+            // in which we know it will succeed.
+            dfa.st.start(inp, start).expect("valid Input configuration")
+        };
+        if self.start_kind().has_unanchored() {
+            let inp = Input::new("").anchored(Anchored::No);
+            let sid = start_id(self, &inp, Start::NonWordByte);
+            if sid == start_id(self, &inp, Start::WordByte)
+                && sid == start_id(self, &inp, Start::Text)
+                && sid == start_id(self, &inp, Start::LineLF)
+                && sid == start_id(self, &inp, Start::LineCR)
+                && sid == start_id(self, &inp, Start::CustomLineTerminator)
+            {
+                self.st.universal_start_unanchored = Some(sid);
+            }
+        }
+        if self.start_kind().has_anchored() {
+            let inp = Input::new("").anchored(Anchored::Yes);
+            let sid = start_id(self, &inp, Start::NonWordByte);
+            if sid == start_id(self, &inp, Start::WordByte)
+                && sid == start_id(self, &inp, Start::Text)
+                && sid == start_id(self, &inp, Start::LineLF)
+                && sid == start_id(self, &inp, Start::LineCR)
+                && sid == start_id(self, &inp, Start::CustomLineTerminator)
+            {
+                self.st.universal_start_anchored = Some(sid);
+            }
+        }
+    }
+}
+
+// A variety of generic internal methods for accessing DFA internals.
+impl<T: AsRef<[u32]>> DFA<T> {
+    /// Return the info about special states.
+    pub(crate) fn special(&self) -> &Special {
+        &self.special
+    }
+
+    /// Return the info about special states as a mutable borrow.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn special_mut(&mut self) -> &mut Special {
+        &mut self.special
+    }
+
+    /// Returns the quit set (may be empty) used by this DFA.
+    pub(crate) fn quitset(&self) -> &ByteSet {
+        &self.quitset
+    }
+
+    /// Returns the flags for this DFA.
+    pub(crate) fn flags(&self) -> &Flags {
+        &self.flags
+    }
+
+    /// Returns an iterator over all states in this DFA.
+    ///
+    /// This iterator yields a tuple for each state. The first element of the
+    /// tuple corresponds to a state's identifier, and the second element
+    /// corresponds to the state itself (comprised of its transitions).
+    pub(crate) fn states(&self) -> StateIter<'_, T> {
+        self.tt.states()
+    }
+
+    /// Return the total number of states in this DFA. Every DFA has at least
+    /// 1 state, even the empty DFA.
+    pub(crate) fn state_len(&self) -> usize {
+        self.tt.len()
+    }
+
+    /// Return an iterator over all pattern IDs for the given match state.
+    ///
+    /// If the given state is not a match state, then this panics.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn pattern_id_slice(&self, id: StateID) -> &[PatternID] {
+        assert!(self.is_match_state(id));
+        self.ms.pattern_id_slice(self.match_state_index(id))
+    }
+
+    /// Return the total number of pattern IDs for the given match state.
+    ///
+    /// If the given state is not a match state, then this panics.
+    pub(crate) fn match_pattern_len(&self, id: StateID) -> usize {
+        assert!(self.is_match_state(id));
+        self.ms.pattern_len(self.match_state_index(id))
+    }
+
+    /// Returns the total number of patterns matched by this DFA.
+    pub(crate) fn pattern_len(&self) -> usize {
+        self.ms.pattern_len
+    }
+
+    /// Returns a map from match state ID to a list of pattern IDs that match
+    /// in that state.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn pattern_map(&self) -> BTreeMap<StateID, Vec<PatternID>> {
+        self.ms.to_map(self)
+    }
+
+    /// Returns the ID of the quit state for this DFA.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn quit_id(&self) -> StateID {
+        self.to_state_id(1)
+    }
+
+    /// Convert the given state identifier to the state's index. The state's
+    /// index corresponds to the position in which it appears in the transition
+    /// table. When a DFA is NOT premultiplied, then a state's identifier is
+    /// also its index. When a DFA is premultiplied, then a state's identifier
+    /// is equal to `index * alphabet_len`. This routine reverses that.
+    pub(crate) fn to_index(&self, id: StateID) -> usize {
+        self.tt.to_index(id)
+    }
+
+    /// Convert an index to a state (in the range 0..self.state_len()) to an
+    /// actual state identifier.
+    ///
+    /// This is useful when using a `Vec<T>` as an efficient map keyed by state
+    /// to some other information (such as a remapped state ID).
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn to_state_id(&self, index: usize) -> StateID {
+        self.tt.to_state_id(index)
+    }
+
+    /// Return the table of state IDs for this DFA's start states.
+    pub(crate) fn starts(&self) -> StartStateIter<'_> {
+        self.st.iter()
+    }
+
+    /// Returns the index of the match state for the given ID. If the
+    /// given ID does not correspond to a match state, then this may
+    /// panic or produce an incorrect result.
+    fn match_state_index(&self, id: StateID) -> usize {
+        debug_assert!(self.is_match_state(id));
+        // This is one of the places where we rely on the fact that match
+        // states are contiguous in the transition table. Namely, that the
+        // first match state ID always corresponds to dfa.special.min_match.
+        // From there, since we know the stride, we can compute the overall
+        // index of any match state given the match state's ID.
+        let min = self.special().min_match.as_usize();
+        // CORRECTNESS: We're allowed to produce an incorrect result or panic,
+        // so both the subtraction and the unchecked StateID construction is
+        // OK.
+        self.to_index(StateID::new_unchecked(id.as_usize() - min))
+    }
+
+    /// Returns the index of the accelerator state for the given ID. If the
+    /// given ID does not correspond to an accelerator state, then this may
+    /// panic or produce an incorrect result.
+    fn accelerator_index(&self, id: StateID) -> usize {
+        let min = self.special().min_accel.as_usize();
+        // CORRECTNESS: We're allowed to produce an incorrect result or panic,
+        // so both the subtraction and the unchecked StateID construction is
+        // OK.
+        self.to_index(StateID::new_unchecked(id.as_usize() - min))
+    }
+
+    /// Return the accelerators for this DFA.
+    fn accels(&self) -> Accels<&[u32]> {
+        self.accels.as_ref()
+    }
+
+    /// Return this DFA's transition table as a slice.
+    fn trans(&self) -> &[StateID] {
+        self.tt.table()
+    }
+}
+
+impl<T: AsRef<[u32]>> fmt::Debug for DFA<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "dense::DFA(")?;
+        for state in self.states() {
+            fmt_state_indicator(f, self, state.id())?;
+            let id = if f.alternate() {
+                state.id().as_usize()
+            } else {
+                self.to_index(state.id())
+            };
+            write!(f, "{:06?}: ", id)?;
+            state.fmt(f)?;
+            write!(f, "\n")?;
+        }
+        writeln!(f, "")?;
+        for (i, (start_id, anchored, sty)) in self.starts().enumerate() {
+            let id = if f.alternate() {
+                start_id.as_usize()
+            } else {
+                self.to_index(start_id)
+            };
+            if i % self.st.stride == 0 {
+                match anchored {
+                    Anchored::No => writeln!(f, "START-GROUP(unanchored)")?,
+                    Anchored::Yes => writeln!(f, "START-GROUP(anchored)")?,
+                    Anchored::Pattern(pid) => {
+                        writeln!(f, "START_GROUP(pattern: {:?})", pid)?
+                    }
+                }
+            }
+            writeln!(f, "  {:?} => {:06?}", sty, id)?;
+        }
+        if self.pattern_len() > 1 {
+            writeln!(f, "")?;
+            for i in 0..self.ms.len() {
+                let id = self.ms.match_state_id(self, i);
+                let id = if f.alternate() {
+                    id.as_usize()
+                } else {
+                    self.to_index(id)
+                };
+                write!(f, "MATCH({:06?}): ", id)?;
+                for (i, &pid) in self.ms.pattern_id_slice(i).iter().enumerate()
+                {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{:?}", pid)?;
+                }
+                writeln!(f, "")?;
+            }
+        }
+        writeln!(f, "state length: {:?}", self.state_len())?;
+        writeln!(f, "pattern length: {:?}", self.pattern_len())?;
+        writeln!(f, "flags: {:?}", self.flags)?;
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+// SAFETY: We assert that our implementation of each method is correct.
+unsafe impl<T: AsRef<[u32]>> Automaton for DFA<T> {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_special_state(&self, id: StateID) -> bool {
+        self.special.is_special_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_dead_state(&self, id: StateID) -> bool {
+        self.special.is_dead_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_quit_state(&self, id: StateID) -> bool {
+        self.special.is_quit_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_match_state(&self, id: StateID) -> bool {
+        self.special.is_match_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_start_state(&self, id: StateID) -> bool {
+        self.special.is_start_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_accel_state(&self, id: StateID) -> bool {
+        self.special.is_accel_state(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next_state(&self, current: StateID, input: u8) -> StateID {
+        let input = self.byte_classes().get(input);
+        let o = current.as_usize() + usize::from(input);
+        self.trans()[o]
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    unsafe fn next_state_unchecked(
+        &self,
+        current: StateID,
+        byte: u8,
+    ) -> StateID {
+        // We don't (or shouldn't) need an unchecked variant for the byte
+        // class mapping, since bound checks should be omitted automatically
+        // by virtue of its representation. If this ends up not being true as
+        // confirmed by codegen, please file an issue. ---AG
+        let class = self.byte_classes().get(byte);
+        let o = current.as_usize() + usize::from(class);
+        let next = *self.trans().get_unchecked(o);
+        next
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next_eoi_state(&self, current: StateID) -> StateID {
+        let eoi = self.byte_classes().eoi().as_usize();
+        let o = current.as_usize() + eoi;
+        self.trans()[o]
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn pattern_len(&self) -> usize {
+        self.ms.pattern_len
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn match_len(&self, id: StateID) -> usize {
+        self.match_pattern_len(id)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn match_pattern(&self, id: StateID, match_index: usize) -> PatternID {
+        // This is an optimization for the very common case of a DFA with a
+        // single pattern. This conditional avoids a somewhat more costly path
+        // that finds the pattern ID from the state machine, which requires
+        // a bit of slicing/pointer-chasing. This optimization tends to only
+        // matter when matches are frequent.
+        if self.ms.pattern_len == 1 {
+            return PatternID::ZERO;
+        }
+        let state_index = self.match_state_index(id);
+        self.ms.pattern_id(state_index, match_index)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn has_empty(&self) -> bool {
+        self.flags.has_empty
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_utf8(&self) -> bool {
+        self.flags.is_utf8
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_always_start_anchored(&self) -> bool {
+        self.flags.is_always_start_anchored
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn start_state_forward(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        if !self.quitset.is_empty() && input.start() > 0 {
+            let offset = input.start() - 1;
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start = self.st.start_map.fwd(&input);
+        self.st.start(input, start)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn start_state_reverse(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        if !self.quitset.is_empty() && input.end() < input.haystack().len() {
+            let offset = input.end();
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start = self.st.start_map.rev(&input);
+        self.st.start(input, start)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn universal_start_state(&self, mode: Anchored) -> Option<StateID> {
+        match mode {
+            Anchored::No => self.st.universal_start_unanchored,
+            Anchored::Yes => self.st.universal_start_anchored,
+            Anchored::Pattern(_) => None,
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn accelerator(&self, id: StateID) -> &[u8] {
+        if !self.is_accel_state(id) {
+            return &[];
+        }
+        self.accels.needles(self.accelerator_index(id))
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref()
+    }
+}
+
+/// The transition table portion of a dense DFA.
+///
+/// The transition table is the core part of the DFA in that it describes how
+/// to move from one state to another based on the input sequence observed.
+#[derive(Clone)]
+pub(crate) struct TransitionTable<T> {
+    /// A contiguous region of memory representing the transition table in
+    /// row-major order. The representation is dense. That is, every state
+    /// has precisely the same number of transitions. The maximum number of
+    /// transitions per state is 257 (256 for each possible byte value, plus 1
+    /// for the special EOI transition). If a DFA has been instructed to use
+    /// byte classes (the default), then the number of transitions is usually
+    /// substantially fewer.
+    ///
+    /// In practice, T is either `Vec<u32>` or `&[u32]`.
+    table: T,
+    /// A set of equivalence classes, where a single equivalence class
+    /// represents a set of bytes that never discriminate between a match
+    /// and a non-match in the DFA. Each equivalence class corresponds to a
+    /// single character in this DFA's alphabet, where the maximum number of
+    /// characters is 257 (each possible value of a byte plus the special
+    /// EOI transition). Consequently, the number of equivalence classes
+    /// corresponds to the number of transitions for each DFA state. Note
+    /// though that the *space* used by each DFA state in the transition table
+    /// may be larger. The total space used by each DFA state is known as the
+    /// stride.
+    ///
+    /// The only time the number of equivalence classes is fewer than 257 is if
+    /// the DFA's kind uses byte classes (which is the default). Equivalence
+    /// classes should generally only be disabled when debugging, so that
+    /// the transitions themselves aren't obscured. Disabling them has no
+    /// other benefit, since the equivalence class map is always used while
+    /// searching. In the vast majority of cases, the number of equivalence
+    /// classes is substantially smaller than 257, particularly when large
+    /// Unicode classes aren't used.
+    classes: ByteClasses,
+    /// The stride of each DFA state, expressed as a power-of-two exponent.
+    ///
+    /// The stride of a DFA corresponds to the total amount of space used by
+    /// each DFA state in the transition table. This may be bigger than the
+    /// size of a DFA's alphabet, since the stride is always the smallest
+    /// power of two greater than or equal to the alphabet size.
+    ///
+    /// While this wastes space, this avoids the need for integer division
+    /// to convert between premultiplied state IDs and their corresponding
+    /// indices. Instead, we can use simple bit-shifts.
+    ///
+    /// See the docs for the `stride2` method for more details.
+    ///
+    /// The minimum `stride2` value is `1` (corresponding to a stride of `2`)
+    /// while the maximum `stride2` value is `9` (corresponding to a stride of
+    /// `512`). The maximum is not `8` since the maximum alphabet size is `257`
+    /// when accounting for the special EOI transition. However, an alphabet
+    /// length of that size is exceptionally rare since the alphabet is shrunk
+    /// into equivalence classes.
+    stride2: usize,
+}
+
+impl<'a> TransitionTable<&'a [u32]> {
+    /// Deserialize a transition table starting at the beginning of `slice`.
+    /// Upon success, return the total number of bytes read along with the
+    /// transition table.
+    ///
+    /// If there was a problem deserializing any part of the transition table,
+    /// then this returns an error. Notably, if the given slice does not have
+    /// the same alignment as `StateID`, then this will return an error (among
+    /// other possible errors).
+    ///
+    /// This is guaranteed to execute in constant time.
+    ///
+    /// # Safety
+    ///
+    /// This routine is not safe because it does not check the valdity of the
+    /// transition table itself. In particular, the transition table can be
+    /// quite large, so checking its validity can be somewhat expensive. An
+    /// invalid transition table is not safe because other code may rely on the
+    /// transition table being correct (such as explicit bounds check elision).
+    /// Therefore, an invalid transition table can lead to undefined behavior.
+    ///
+    /// Callers that use this function must either pass on the safety invariant
+    /// or guarantee that the bytes given contain a valid transition table.
+    /// This guarantee is upheld by the bytes written by `write_to`.
+    unsafe fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(TransitionTable<&'a [u32]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        let (state_len, nr) =
+            wire::try_read_u32_as_usize(slice, "state length")?;
+        slice = &slice[nr..];
+
+        let (stride2, nr) = wire::try_read_u32_as_usize(slice, "stride2")?;
+        slice = &slice[nr..];
+
+        let (classes, nr) = ByteClasses::from_bytes(slice)?;
+        slice = &slice[nr..];
+
+        // The alphabet length (determined by the byte class map) cannot be
+        // bigger than the stride (total space used by each DFA state).
+        if stride2 > 9 {
+            return Err(DeserializeError::generic(
+                "dense DFA has invalid stride2 (too big)",
+            ));
+        }
+        // It also cannot be zero, since even a DFA that never matches anything
+        // has a non-zero number of states with at least two equivalence
+        // classes: one for all 256 byte values and another for the EOI
+        // sentinel.
+        if stride2 < 1 {
+            return Err(DeserializeError::generic(
+                "dense DFA has invalid stride2 (too small)",
+            ));
+        }
+        // This is OK since 1 <= stride2 <= 9.
+        let stride =
+            1usize.checked_shl(u32::try_from(stride2).unwrap()).unwrap();
+        if classes.alphabet_len() > stride {
+            return Err(DeserializeError::generic(
+                "alphabet size cannot be bigger than transition table stride",
+            ));
+        }
+
+        let trans_len =
+            wire::shl(state_len, stride2, "dense table transition length")?;
+        let table_bytes_len = wire::mul(
+            trans_len,
+            StateID::SIZE,
+            "dense table state byte length",
+        )?;
+        wire::check_slice_len(slice, table_bytes_len, "transition table")?;
+        wire::check_alignment::<StateID>(slice)?;
+        let table_bytes = &slice[..table_bytes_len];
+        slice = &slice[table_bytes_len..];
+        // SAFETY: Since StateID is always representable as a u32, all we need
+        // to do is ensure that we have the proper length and alignment. We've
+        // checked both above, so the cast below is safe.
+        //
+        // N.B. This is the only not-safe code in this function.
+        let table = core::slice::from_raw_parts(
+            table_bytes.as_ptr().cast::<u32>(),
+            trans_len,
+        );
+        let tt = TransitionTable { table, classes, stride2 };
+        Ok((tt, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl TransitionTable<Vec<u32>> {
+    /// Create a minimal transition table with just two states: a dead state
+    /// and a quit state. The alphabet length and stride of the transition
+    /// table is determined by the given set of equivalence classes.
+    fn minimal(classes: ByteClasses) -> TransitionTable<Vec<u32>> {
+        let mut tt = TransitionTable {
+            table: vec![],
+            classes,
+            stride2: classes.stride2(),
+        };
+        // Two states, regardless of alphabet size, can always fit into u32.
+        tt.add_empty_state().unwrap(); // dead state
+        tt.add_empty_state().unwrap(); // quit state
+        tt
+    }
+
+    /// Set a transition in this table. Both the `from` and `to` states must
+    /// already exist, otherwise this panics. `unit` should correspond to the
+    /// transition out of `from` to set to `to`.
+    fn set(&mut self, from: StateID, unit: alphabet::Unit, to: StateID) {
+        assert!(self.is_valid(from), "invalid 'from' state");
+        assert!(self.is_valid(to), "invalid 'to' state");
+        self.table[from.as_usize() + self.classes.get_by_unit(unit)] =
+            to.as_u32();
+    }
+
+    /// Add an empty state (a state where all transitions lead to a dead state)
+    /// and return its identifier. The identifier returned is guaranteed to
+    /// not point to any other existing state.
+    ///
+    /// If adding a state would exhaust the state identifier space, then this
+    /// returns an error.
+    fn add_empty_state(&mut self) -> Result<StateID, BuildError> {
+        // Normally, to get a fresh state identifier, we would just
+        // take the index of the next state added to the transition
+        // table. However, we actually perform an optimization here
+        // that premultiplies state IDs by the stride, such that they
+        // point immediately at the beginning of their transitions in
+        // the transition table. This avoids an extra multiplication
+        // instruction for state lookup at search time.
+        //
+        // Premultiplied identifiers means that instead of your matching
+        // loop looking something like this:
+        //
+        //   state = dfa.start
+        //   for byte in haystack:
+        //       next = dfa.transitions[state * stride + byte]
+        //       if dfa.is_match(next):
+        //           return true
+        //   return false
+        //
+        // it can instead look like this:
+        //
+        //   state = dfa.start
+        //   for byte in haystack:
+        //       next = dfa.transitions[state + byte]
+        //       if dfa.is_match(next):
+        //           return true
+        //   return false
+        //
+        // In other words, we save a multiplication instruction in the
+        // critical path. This turns out to be a decent performance win.
+        // The cost of using premultiplied state ids is that they can
+        // require a bigger state id representation. (And they also make
+        // the code a bit more complex, especially during minimization and
+        // when reshuffling states, as one needs to convert back and forth
+        // between state IDs and state indices.)
+        //
+        // To do this, we simply take the index of the state into the
+        // entire transition table, rather than the index of the state
+        // itself. e.g., If the stride is 64, then the ID of the 3rd state
+        // is 192, not 2.
+        let next = self.table.len();
+        let id =
+            StateID::new(next).map_err(|_| BuildError::too_many_states())?;
+        self.table.extend(iter::repeat(0).take(self.stride()));
+        Ok(id)
+    }
+
+    /// Swap the two states given in this transition table.
+    ///
+    /// This routine does not do anything to check the correctness of this
+    /// swap. Callers must ensure that other states pointing to id1 and id2 are
+    /// updated appropriately.
+    ///
+    /// Both id1 and id2 must point to valid states, otherwise this panics.
+    fn swap(&mut self, id1: StateID, id2: StateID) {
+        assert!(self.is_valid(id1), "invalid 'id1' state: {:?}", id1);
+        assert!(self.is_valid(id2), "invalid 'id2' state: {:?}", id2);
+        // We only need to swap the parts of the state that are used. So if the
+        // stride is 64, but the alphabet length is only 33, then we save a lot
+        // of work.
+        for b in 0..self.classes.alphabet_len() {
+            self.table.swap(id1.as_usize() + b, id2.as_usize() + b);
+        }
+    }
+
+    /// Remap the transitions for the state given according to the function
+    /// given. This applies the given map function to every transition in the
+    /// given state and changes the transition in place to the result of the
+    /// map function for that transition.
+    fn remap(&mut self, id: StateID, map: impl Fn(StateID) -> StateID) {
+        for byte in 0..self.alphabet_len() {
+            let i = id.as_usize() + byte;
+            let next = self.table()[i];
+            self.table_mut()[id.as_usize() + byte] = map(next);
+        }
+    }
+
+    /// Truncate the states in this transition table to the given length.
+    ///
+    /// This routine does not do anything to check the correctness of this
+    /// truncation. Callers must ensure that other states pointing to truncated
+    /// states are updated appropriately.
+    fn truncate(&mut self, len: usize) {
+        self.table.truncate(len << self.stride2);
+    }
+}
+
+impl<T: AsRef<[u32]>> TransitionTable<T> {
+    /// Writes a serialized form of this transition table to the buffer given.
+    /// If the buffer is too small, then an error is returned. To determine
+    /// how big the buffer must be, use `write_to_len`.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("transition table"));
+        }
+        dst = &mut dst[..nwrite];
+
+        // write state length
+        // Unwrap is OK since number of states is guaranteed to fit in a u32.
+        E::write_u32(u32::try_from(self.len()).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write state stride (as power of 2)
+        // Unwrap is OK since stride2 is guaranteed to be <= 9.
+        E::write_u32(u32::try_from(self.stride2).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write byte class map
+        let n = self.classes.write_to(dst)?;
+        dst = &mut dst[n..];
+
+        // write actual transitions
+        for &sid in self.table() {
+            let n = wire::write_state_id::<E>(sid, &mut dst);
+            dst = &mut dst[n..];
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of this transition
+    /// table will use.
+    fn write_to_len(&self) -> usize {
+        size_of::<u32>()   // state length
+        + size_of::<u32>() // stride2
+        + self.classes.write_to_len()
+        + (self.table().len() * StateID::SIZE)
+    }
+
+    /// Validates that every state ID in this transition table is valid.
+    ///
+    /// That is, every state ID can be used to correctly index a state in this
+    /// table.
+    fn validate(&self, sp: &Special) -> Result<(), DeserializeError> {
+        for state in self.states() {
+            // We check that the ID itself is well formed. That is, if it's
+            // a special state then it must actually be a quit, dead, accel,
+            // match or start state.
+            if sp.is_special_state(state.id()) {
+                let is_actually_special = sp.is_dead_state(state.id())
+                    || sp.is_quit_state(state.id())
+                    || sp.is_match_state(state.id())
+                    || sp.is_start_state(state.id())
+                    || sp.is_accel_state(state.id());
+                if !is_actually_special {
+                    // This is kind of a cryptic error message...
+                    return Err(DeserializeError::generic(
+                        "found dense state tagged as special but \
+                         wasn't actually special",
+                    ));
+                }
+            }
+            for (_, to) in state.transitions() {
+                if !self.is_valid(to) {
+                    return Err(DeserializeError::generic(
+                        "found invalid state ID in transition table",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Converts this transition table to a borrowed value.
+    fn as_ref(&self) -> TransitionTable<&'_ [u32]> {
+        TransitionTable {
+            table: self.table.as_ref(),
+            classes: self.classes.clone(),
+            stride2: self.stride2,
+        }
+    }
+
+    /// Converts this transition table to an owned value.
+    #[cfg(feature = "alloc")]
+    fn to_owned(&self) -> TransitionTable<alloc::vec::Vec<u32>> {
+        TransitionTable {
+            table: self.table.as_ref().to_vec(),
+            classes: self.classes.clone(),
+            stride2: self.stride2,
+        }
+    }
+
+    /// Return the state for the given ID. If the given ID is not valid, then
+    /// this panics.
+    fn state(&self, id: StateID) -> State<'_> {
+        assert!(self.is_valid(id));
+
+        let i = id.as_usize();
+        State {
+            id,
+            stride2: self.stride2,
+            transitions: &self.table()[i..i + self.alphabet_len()],
+        }
+    }
+
+    /// Returns an iterator over all states in this transition table.
+    ///
+    /// This iterator yields a tuple for each state. The first element of the
+    /// tuple corresponds to a state's identifier, and the second element
+    /// corresponds to the state itself (comprised of its transitions).
+    fn states(&self) -> StateIter<'_, T> {
+        StateIter {
+            tt: self,
+            it: self.table().chunks(self.stride()).enumerate(),
+        }
+    }
+
+    /// Convert a state identifier to an index to a state (in the range
+    /// 0..self.len()).
+    ///
+    /// This is useful when using a `Vec<T>` as an efficient map keyed by state
+    /// to some other information (such as a remapped state ID).
+    ///
+    /// If the given ID is not valid, then this may panic or produce an
+    /// incorrect index.
+    fn to_index(&self, id: StateID) -> usize {
+        id.as_usize() >> self.stride2
+    }
+
+    /// Convert an index to a state (in the range 0..self.len()) to an actual
+    /// state identifier.
+    ///
+    /// This is useful when using a `Vec<T>` as an efficient map keyed by state
+    /// to some other information (such as a remapped state ID).
+    ///
+    /// If the given index is not in the specified range, then this may panic
+    /// or produce an incorrect state ID.
+    fn to_state_id(&self, index: usize) -> StateID {
+        // CORRECTNESS: If the given index is not valid, then it is not
+        // required for this to panic or return a valid state ID.
+        StateID::new_unchecked(index << self.stride2)
+    }
+
+    /// Returns the state ID for the state immediately following the one given.
+    ///
+    /// This does not check whether the state ID returned is invalid. In fact,
+    /// if the state ID given is the last state in this DFA, then the state ID
+    /// returned is guaranteed to be invalid.
+    #[cfg(feature = "dfa-build")]
+    fn next_state_id(&self, id: StateID) -> StateID {
+        self.to_state_id(self.to_index(id).checked_add(1).unwrap())
+    }
+
+    /// Returns the state ID for the state immediately preceding the one given.
+    ///
+    /// If the dead ID given (which is zero), then this panics.
+    #[cfg(feature = "dfa-build")]
+    fn prev_state_id(&self, id: StateID) -> StateID {
+        self.to_state_id(self.to_index(id).checked_sub(1).unwrap())
+    }
+
+    /// Returns the table as a slice of state IDs.
+    fn table(&self) -> &[StateID] {
+        wire::u32s_to_state_ids(self.table.as_ref())
+    }
+
+    /// Returns the total number of states in this transition table.
+    ///
+    /// Note that a DFA always has at least two states: the dead and quit
+    /// states. In particular, the dead state always has ID 0 and is
+    /// correspondingly always the first state. The dead state is never a match
+    /// state.
+    fn len(&self) -> usize {
+        self.table().len() >> self.stride2
+    }
+
+    /// Returns the total stride for every state in this DFA. This corresponds
+    /// to the total number of transitions used by each state in this DFA's
+    /// transition table.
+    fn stride(&self) -> usize {
+        1 << self.stride2
+    }
+
+    /// Returns the total number of elements in the alphabet for this
+    /// transition table. This is always less than or equal to `self.stride()`.
+    /// It is only equal when the alphabet length is a power of 2. Otherwise,
+    /// it is always strictly less.
+    fn alphabet_len(&self) -> usize {
+        self.classes.alphabet_len()
+    }
+
+    /// Returns true if and only if the given state ID is valid for this
+    /// transition table. Validity in this context means that the given ID can
+    /// be used as a valid offset with `self.stride()` to index this transition
+    /// table.
+    fn is_valid(&self, id: StateID) -> bool {
+        let id = id.as_usize();
+        id < self.table().len() && id % self.stride() == 0
+    }
+
+    /// Return the memory usage, in bytes, of this transition table.
+    ///
+    /// This does not include the size of a `TransitionTable` value itself.
+    fn memory_usage(&self) -> usize {
+        self.table().len() * StateID::SIZE
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl<T: AsMut<[u32]>> TransitionTable<T> {
+    /// Returns the table as a slice of state IDs.
+    fn table_mut(&mut self) -> &mut [StateID] {
+        wire::u32s_to_state_ids_mut(self.table.as_mut())
+    }
+}
+
+/// The set of all possible starting states in a DFA.
+///
+/// The set of starting states corresponds to the possible choices one can make
+/// in terms of starting a DFA. That is, before following the first transition,
+/// you first need to select the state that you start in.
+///
+/// Normally, a DFA converted from an NFA that has a single starting state
+/// would itself just have one starting state. However, our support for look
+/// around generally requires more starting states. The correct starting state
+/// is chosen based on certain properties of the position at which we begin
+/// our search.
+///
+/// Before listing those properties, we first must define two terms:
+///
+/// * `haystack` - The bytes to execute the search. The search always starts
+///   at the beginning of `haystack` and ends before or at the end of
+///   `haystack`.
+/// * `context` - The (possibly empty) bytes surrounding `haystack`. `haystack`
+///   must be contained within `context` such that `context` is at least as big
+///   as `haystack`.
+///
+/// This split is crucial for dealing with look-around. For example, consider
+/// the context `foobarbaz`, the haystack `bar` and the regex `^bar$`. This
+/// regex should _not_ match the haystack since `bar` does not appear at the
+/// beginning of the input. Similarly, the regex `\Bbar\B` should match the
+/// haystack because `bar` is not surrounded by word boundaries. But a search
+/// that does not take context into account would not permit `\B` to match
+/// since the beginning of any string matches a word boundary. Similarly, a
+/// search that does not take context into account when searching `^bar$` in
+/// the haystack `bar` would produce a match when it shouldn't.
+///
+/// Thus, it follows that the starting state is chosen based on the following
+/// criteria, derived from the position at which the search starts in the
+/// `context` (corresponding to the start of `haystack`):
+///
+/// 1. If the search starts at the beginning of `context`, then the `Text`
+///    start state is used. (Since `^` corresponds to
+///    `hir::Anchor::Start`.)
+/// 2. If the search starts at a position immediately following a line
+///    terminator, then the `Line` start state is used. (Since `(?m:^)`
+///    corresponds to `hir::Anchor::StartLF`.)
+/// 3. If the search starts at a position immediately following a byte
+///    classified as a "word" character (`[_0-9a-zA-Z]`), then the `WordByte`
+///    start state is used. (Since `(?-u:\b)` corresponds to a word boundary.)
+/// 4. Otherwise, if the search starts at a position immediately following
+///    a byte that is not classified as a "word" character (`[^_0-9a-zA-Z]`),
+///    then the `NonWordByte` start state is used. (Since `(?-u:\B)`
+///    corresponds to a not-word-boundary.)
+///
+/// (N.B. Unicode word boundaries are not supported by the DFA because they
+/// require multi-byte look-around and this is difficult to support in a DFA.)
+///
+/// To further complicate things, we also support constructing individual
+/// anchored start states for each pattern in the DFA. (Which is required to
+/// implement overlapping regexes correctly, but is also generally useful.)
+/// Thus, when individual start states for each pattern are enabled, then the
+/// total number of start states represented is `4 + (4 * #patterns)`, where
+/// the 4 comes from each of the 4 possibilities above. The first 4 represents
+/// the starting states for the entire DFA, which support searching for
+/// multiple patterns simultaneously (possibly unanchored).
+///
+/// If individual start states are disabled, then this will only store 4
+/// start states. Typically, individual start states are only enabled when
+/// constructing the reverse DFA for regex matching. But they are also useful
+/// for building DFAs that can search for a specific pattern or even to support
+/// both anchored and unanchored searches with the same DFA.
+///
+/// Note though that while the start table always has either `4` or
+/// `4 + (4 * #patterns)` starting state *ids*, the total number of states
+/// might be considerably smaller. That is, many of the IDs may be duplicative.
+/// (For example, if a regex doesn't have a `\b` sub-pattern, then there's no
+/// reason to generate a unique starting state for handling word boundaries.
+/// Similarly for start/end anchors.)
+#[derive(Clone)]
+pub(crate) struct StartTable<T> {
+    /// The initial start state IDs.
+    ///
+    /// In practice, T is either `Vec<u32>` or `&[u32]`.
+    ///
+    /// The first `2 * stride` (currently always 8) entries always correspond
+    /// to the starts states for the entire DFA, with the first 4 entries being
+    /// for unanchored searches and the second 4 entries being for anchored
+    /// searches. To keep things simple, we always use 8 entries even if the
+    /// `StartKind` is not both.
+    ///
+    /// After that, there are `stride * patterns` state IDs, where `patterns`
+    /// may be zero in the case of a DFA with no patterns or in the case where
+    /// the DFA was built without enabling starting states for each pattern.
+    table: T,
+    /// The starting state configuration supported. When 'both', both
+    /// unanchored and anchored searches work. When 'unanchored', anchored
+    /// searches panic. When 'anchored', unanchored searches panic.
+    kind: StartKind,
+    /// The start state configuration for every possible byte.
+    start_map: StartByteMap,
+    /// The number of starting state IDs per pattern.
+    stride: usize,
+    /// The total number of patterns for which starting states are encoded.
+    /// This is `None` for DFAs that were built without start states for each
+    /// pattern. Thus, one cannot use this field to say how many patterns
+    /// are in the DFA in all cases. It is specific to how many patterns are
+    /// represented in this start table.
+    pattern_len: Option<usize>,
+    /// The universal starting state for unanchored searches. This is only
+    /// present when the DFA supports unanchored searches and when all starting
+    /// state IDs for an unanchored search are equivalent.
+    universal_start_unanchored: Option<StateID>,
+    /// The universal starting state for anchored searches. This is only
+    /// present when the DFA supports anchored searches and when all starting
+    /// state IDs for an anchored search are equivalent.
+    universal_start_anchored: Option<StateID>,
+}
+
+#[cfg(feature = "dfa-build")]
+impl StartTable<Vec<u32>> {
+    /// Create a valid set of start states all pointing to the dead state.
+    ///
+    /// When the corresponding DFA is constructed with start states for each
+    /// pattern, then `patterns` should be the number of patterns. Otherwise,
+    /// it should be zero.
+    ///
+    /// If the total table size could exceed the allocatable limit, then this
+    /// returns an error. In practice, this is unlikely to be able to occur,
+    /// since it's likely that allocation would have failed long before it got
+    /// to this point.
+    fn dead(
+        kind: StartKind,
+        lookm: &LookMatcher,
+        pattern_len: Option<usize>,
+    ) -> Result<StartTable<Vec<u32>>, BuildError> {
+        if let Some(len) = pattern_len {
+            assert!(len <= PatternID::LIMIT);
+        }
+        let stride = Start::len();
+        // OK because 2*4 is never going to overflow anything.
+        let starts_len = stride.checked_mul(2).unwrap();
+        let pattern_starts_len =
+            match stride.checked_mul(pattern_len.unwrap_or(0)) {
+                Some(x) => x,
+                None => return Err(BuildError::too_many_start_states()),
+            };
+        let table_len = match starts_len.checked_add(pattern_starts_len) {
+            Some(x) => x,
+            None => return Err(BuildError::too_many_start_states()),
+        };
+        if let Err(_) = isize::try_from(table_len) {
+            return Err(BuildError::too_many_start_states());
+        }
+        let table = vec![DEAD.as_u32(); table_len];
+        let start_map = StartByteMap::new(lookm);
+        Ok(StartTable {
+            table,
+            kind,
+            start_map,
+            stride,
+            pattern_len,
+            universal_start_unanchored: None,
+            universal_start_anchored: None,
+        })
+    }
+}
+
+impl<'a> StartTable<&'a [u32]> {
+    /// Deserialize a table of start state IDs starting at the beginning of
+    /// `slice`. Upon success, return the total number of bytes read along with
+    /// the table of starting state IDs.
+    ///
+    /// If there was a problem deserializing any part of the starting IDs,
+    /// then this returns an error. Notably, if the given slice does not have
+    /// the same alignment as `StateID`, then this will return an error (among
+    /// other possible errors).
+    ///
+    /// This is guaranteed to execute in constant time.
+    ///
+    /// # Safety
+    ///
+    /// This routine is not safe because it does not check the valdity of the
+    /// starting state IDs themselves. In particular, the number of starting
+    /// IDs can be of variable length, so it's possible that checking their
+    /// validity cannot be done in constant time. An invalid starting state
+    /// ID is not safe because other code may rely on the starting IDs being
+    /// correct (such as explicit bounds check elision). Therefore, an invalid
+    /// start ID can lead to undefined behavior.
+    ///
+    /// Callers that use this function must either pass on the safety invariant
+    /// or guarantee that the bytes given contain valid starting state IDs.
+    /// This guarantee is upheld by the bytes written by `write_to`.
+    unsafe fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(StartTable<&'a [u32]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        let (kind, nr) = StartKind::from_bytes(slice)?;
+        slice = &slice[nr..];
+
+        let (start_map, nr) = StartByteMap::from_bytes(slice)?;
+        slice = &slice[nr..];
+
+        let (stride, nr) =
+            wire::try_read_u32_as_usize(slice, "start table stride")?;
+        slice = &slice[nr..];
+        if stride != Start::len() {
+            return Err(DeserializeError::generic(
+                "invalid starting table stride",
+            ));
+        }
+
+        let (maybe_pattern_len, nr) =
+            wire::try_read_u32_as_usize(slice, "start table patterns")?;
+        slice = &slice[nr..];
+        let pattern_len = if maybe_pattern_len.as_u32() == u32::MAX {
+            None
+        } else {
+            Some(maybe_pattern_len)
+        };
+        if pattern_len.map_or(false, |len| len > PatternID::LIMIT) {
+            return Err(DeserializeError::generic(
+                "invalid number of patterns",
+            ));
+        }
+
+        let (universal_unanchored, nr) =
+            wire::try_read_u32(slice, "universal unanchored start")?;
+        slice = &slice[nr..];
+        let universal_start_unanchored = if universal_unanchored == u32::MAX {
+            None
+        } else {
+            Some(StateID::try_from(universal_unanchored).map_err(|e| {
+                DeserializeError::state_id_error(
+                    e,
+                    "universal unanchored start",
+                )
+            })?)
+        };
+
+        let (universal_anchored, nr) =
+            wire::try_read_u32(slice, "universal anchored start")?;
+        slice = &slice[nr..];
+        let universal_start_anchored = if universal_anchored == u32::MAX {
+            None
+        } else {
+            Some(StateID::try_from(universal_anchored).map_err(|e| {
+                DeserializeError::state_id_error(e, "universal anchored start")
+            })?)
+        };
+
+        let pattern_table_size = wire::mul(
+            stride,
+            pattern_len.unwrap_or(0),
+            "invalid pattern length",
+        )?;
+        // Our start states always start with a two stride of start states for
+        // the entire automaton. The first stride is for unanchored starting
+        // states and the second stride is for anchored starting states. What
+        // follows it are an optional set of start states for each pattern.
+        let start_state_len = wire::add(
+            wire::mul(2, stride, "start state stride too big")?,
+            pattern_table_size,
+            "invalid 'any' pattern starts size",
+        )?;
+        let table_bytes_len = wire::mul(
+            start_state_len,
+            StateID::SIZE,
+            "pattern table bytes length",
+        )?;
+        wire::check_slice_len(slice, table_bytes_len, "start ID table")?;
+        wire::check_alignment::<StateID>(slice)?;
+        let table_bytes = &slice[..table_bytes_len];
+        slice = &slice[table_bytes_len..];
+        // SAFETY: Since StateID is always representable as a u32, all we need
+        // to do is ensure that we have the proper length and alignment. We've
+        // checked both above, so the cast below is safe.
+        //
+        // N.B. This is the only not-safe code in this function.
+        let table = core::slice::from_raw_parts(
+            table_bytes.as_ptr().cast::<u32>(),
+            start_state_len,
+        );
+        let st = StartTable {
+            table,
+            kind,
+            start_map,
+            stride,
+            pattern_len,
+            universal_start_unanchored,
+            universal_start_anchored,
+        };
+        Ok((st, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+impl<T: AsRef<[u32]>> StartTable<T> {
+    /// Writes a serialized form of this start table to the buffer given. If
+    /// the buffer is too small, then an error is returned. To determine how
+    /// big the buffer must be, use `write_to_len`.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small(
+                "starting table ids",
+            ));
+        }
+        dst = &mut dst[..nwrite];
+
+        // write start kind
+        let nw = self.kind.write_to::<E>(dst)?;
+        dst = &mut dst[nw..];
+        // write start byte map
+        let nw = self.start_map.write_to(dst)?;
+        dst = &mut dst[nw..];
+        // write stride
+        // Unwrap is OK since the stride is always 4 (currently).
+        E::write_u32(u32::try_from(self.stride).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+        // write pattern length
+        // Unwrap is OK since number of patterns is guaranteed to fit in a u32.
+        E::write_u32(
+            u32::try_from(self.pattern_len.unwrap_or(0xFFFF_FFFF)).unwrap(),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write universal start unanchored state id, u32::MAX if absent
+        E::write_u32(
+            self.universal_start_unanchored
+                .map_or(u32::MAX, |sid| sid.as_u32()),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write universal start anchored state id, u32::MAX if absent
+        E::write_u32(
+            self.universal_start_anchored.map_or(u32::MAX, |sid| sid.as_u32()),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write start IDs
+        for &sid in self.table() {
+            let n = wire::write_state_id::<E>(sid, &mut dst);
+            dst = &mut dst[n..];
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of this start ID table
+    /// will use.
+    fn write_to_len(&self) -> usize {
+        self.kind.write_to_len()
+        + self.start_map.write_to_len()
+        + size_of::<u32>() // stride
+        + size_of::<u32>() // # patterns
+        + size_of::<u32>() // universal unanchored start
+        + size_of::<u32>() // universal anchored start
+        + (self.table().len() * StateID::SIZE)
+    }
+
+    /// Validates that every state ID in this start table is valid by checking
+    /// it against the given transition table (which must be for the same DFA).
+    ///
+    /// That is, every state ID can be used to correctly index a state.
+    fn validate(
+        &self,
+        tt: &TransitionTable<T>,
+    ) -> Result<(), DeserializeError> {
+        if !self.universal_start_unanchored.map_or(true, |s| tt.is_valid(s)) {
+            return Err(DeserializeError::generic(
+                "found invalid universal unanchored starting state ID",
+            ));
+        }
+        if !self.universal_start_anchored.map_or(true, |s| tt.is_valid(s)) {
+            return Err(DeserializeError::generic(
+                "found invalid universal anchored starting state ID",
+            ));
+        }
+        for &id in self.table() {
+            if !tt.is_valid(id) {
+                return Err(DeserializeError::generic(
+                    "found invalid starting state ID",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    /// Converts this start list to a borrowed value.
+    fn as_ref(&self) -> StartTable<&'_ [u32]> {
+        StartTable {
+            table: self.table.as_ref(),
+            kind: self.kind,
+            start_map: self.start_map.clone(),
+            stride: self.stride,
+            pattern_len: self.pattern_len,
+            universal_start_unanchored: self.universal_start_unanchored,
+            universal_start_anchored: self.universal_start_anchored,
+        }
+    }
+
+    /// Converts this start list to an owned value.
+    #[cfg(feature = "alloc")]
+    fn to_owned(&self) -> StartTable<alloc::vec::Vec<u32>> {
+        StartTable {
+            table: self.table.as_ref().to_vec(),
+            kind: self.kind,
+            start_map: self.start_map.clone(),
+            stride: self.stride,
+            pattern_len: self.pattern_len,
+            universal_start_unanchored: self.universal_start_unanchored,
+            universal_start_anchored: self.universal_start_anchored,
+        }
+    }
+
+    /// Return the start state for the given input and starting configuration.
+    /// This returns an error if the input configuration is not supported by
+    /// this DFA. For example, requesting an unanchored search when the DFA was
+    /// not built with unanchored starting states. Or asking for an anchored
+    /// pattern search with an invalid pattern ID or on a DFA that was not
+    /// built with start states for each pattern.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn start(
+        &self,
+        input: &Input<'_>,
+        start: Start,
+    ) -> Result<StateID, MatchError> {
+        let start_index = start.as_usize();
+        let mode = input.get_anchored();
+        let index = match mode {
+            Anchored::No => {
+                if !self.kind.has_unanchored() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                start_index
+            }
+            Anchored::Yes => {
+                if !self.kind.has_anchored() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                self.stride + start_index
+            }
+            Anchored::Pattern(pid) => {
+                let len = match self.pattern_len {
+                    None => {
+                        return Err(MatchError::unsupported_anchored(mode))
+                    }
+                    Some(len) => len,
+                };
+                if pid.as_usize() >= len {
+                    return Ok(DEAD);
+                }
+                (2 * self.stride)
+                    + (self.stride * pid.as_usize())
+                    + start_index
+            }
+        };
+        Ok(self.table()[index])
+    }
+
+    /// Returns an iterator over all start state IDs in this table.
+    ///
+    /// Each item is a triple of: start state ID, the start state type and the
+    /// pattern ID (if any).
+    fn iter(&self) -> StartStateIter<'_> {
+        StartStateIter { st: self.as_ref(), i: 0 }
+    }
+
+    /// Returns the table as a slice of state IDs.
+    fn table(&self) -> &[StateID] {
+        wire::u32s_to_state_ids(self.table.as_ref())
+    }
+
+    /// Return the memory usage, in bytes, of this start list.
+    ///
+    /// This does not include the size of a `StartList` value itself.
+    fn memory_usage(&self) -> usize {
+        self.table().len() * StateID::SIZE
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl<T: AsMut<[u32]>> StartTable<T> {
+    /// Set the start state for the given index and pattern.
+    ///
+    /// If the pattern ID or state ID are not valid, then this will panic.
+    fn set_start(&mut self, anchored: Anchored, start: Start, id: StateID) {
+        let start_index = start.as_usize();
+        let index = match anchored {
+            Anchored::No => start_index,
+            Anchored::Yes => self.stride + start_index,
+            Anchored::Pattern(pid) => {
+                let pid = pid.as_usize();
+                let len = self
+                    .pattern_len
+                    .expect("start states for each pattern enabled");
+                assert!(pid < len, "invalid pattern ID {:?}", pid);
+                self.stride
+                    .checked_mul(pid)
+                    .unwrap()
+                    .checked_add(self.stride.checked_mul(2).unwrap())
+                    .unwrap()
+                    .checked_add(start_index)
+                    .unwrap()
+            }
+        };
+        self.table_mut()[index] = id;
+    }
+
+    /// Returns the table as a mutable slice of state IDs.
+    fn table_mut(&mut self) -> &mut [StateID] {
+        wire::u32s_to_state_ids_mut(self.table.as_mut())
+    }
+}
+
+/// An iterator over start state IDs.
+///
+/// This iterator yields a triple of start state ID, the anchored mode and the
+/// start state type. If a pattern ID is relevant, then the anchored mode will
+/// contain it. Start states with an anchored mode containing a pattern ID will
+/// only occur when the DFA was compiled with start states for each pattern
+/// (which is disabled by default).
+pub(crate) struct StartStateIter<'a> {
+    st: StartTable<&'a [u32]>,
+    i: usize,
+}
+
+impl<'a> Iterator for StartStateIter<'a> {
+    type Item = (StateID, Anchored, Start);
+
+    fn next(&mut self) -> Option<(StateID, Anchored, Start)> {
+        let i = self.i;
+        let table = self.st.table();
+        if i >= table.len() {
+            return None;
+        }
+        self.i += 1;
+
+        // This unwrap is okay since the stride of the starting state table
+        // must always match the number of start state types.
+        let start_type = Start::from_usize(i % self.st.stride).unwrap();
+        let anchored = if i < self.st.stride {
+            Anchored::No
+        } else if i < (2 * self.st.stride) {
+            Anchored::Yes
+        } else {
+            let pid = (i - (2 * self.st.stride)) / self.st.stride;
+            Anchored::Pattern(PatternID::new(pid).unwrap())
+        };
+        Some((table[i], anchored, start_type))
+    }
+}
+
+/// This type represents that patterns that should be reported whenever a DFA
+/// enters a match state. This structure exists to support DFAs that search for
+/// matches for multiple regexes.
+///
+/// This structure relies on the fact that all match states in a DFA occur
+/// contiguously in the DFA's transition table. (See dfa/special.rs for a more
+/// detailed breakdown of the representation.) Namely, when a match occurs, we
+/// know its state ID. Since we know the start and end of the contiguous region
+/// of match states, we can use that to compute the position at which the match
+/// state occurs. That in turn is used as an offset into this structure.
+#[derive(Clone, Debug)]
+struct MatchStates<T> {
+    /// Slices is a flattened sequence of pairs, where each pair points to a
+    /// sub-slice of pattern_ids. The first element of the pair is an offset
+    /// into pattern_ids and the second element of the pair is the number
+    /// of 32-bit pattern IDs starting at that position. That is, each pair
+    /// corresponds to a single DFA match state and its corresponding match
+    /// IDs. The number of pairs always corresponds to the number of distinct
+    /// DFA match states.
+    ///
+    /// In practice, T is either Vec<u32> or &[u32].
+    slices: T,
+    /// A flattened sequence of pattern IDs for each DFA match state. The only
+    /// way to correctly read this sequence is indirectly via `slices`.
+    ///
+    /// In practice, T is either Vec<u32> or &[u32].
+    pattern_ids: T,
+    /// The total number of unique patterns represented by these match states.
+    pattern_len: usize,
+}
+
+impl<'a> MatchStates<&'a [u32]> {
+    unsafe fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(MatchStates<&'a [u32]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        // Read the total number of match states.
+        let (state_len, nr) =
+            wire::try_read_u32_as_usize(slice, "match state length")?;
+        slice = &slice[nr..];
+
+        // Read the slice start/length pairs.
+        let pair_len = wire::mul(2, state_len, "match state offset pairs")?;
+        let slices_bytes_len = wire::mul(
+            pair_len,
+            PatternID::SIZE,
+            "match state slice offset byte length",
+        )?;
+        wire::check_slice_len(slice, slices_bytes_len, "match state slices")?;
+        wire::check_alignment::<PatternID>(slice)?;
+        let slices_bytes = &slice[..slices_bytes_len];
+        slice = &slice[slices_bytes_len..];
+        // SAFETY: Since PatternID is always representable as a u32, all we
+        // need to do is ensure that we have the proper length and alignment.
+        // We've checked both above, so the cast below is safe.
+        //
+        // N.B. This is one of the few not-safe snippets in this function,
+        // so we mark it explicitly to call it out.
+        let slices = core::slice::from_raw_parts(
+            slices_bytes.as_ptr().cast::<u32>(),
+            pair_len,
+        );
+
+        // Read the total number of unique pattern IDs (which is always 1 more
+        // than the maximum pattern ID in this automaton, since pattern IDs are
+        // handed out contiguously starting at 0).
+        let (pattern_len, nr) =
+            wire::try_read_u32_as_usize(slice, "pattern length")?;
+        slice = &slice[nr..];
+
+        // Now read the pattern ID length. We don't need to store this
+        // explicitly, but we need it to know how many pattern IDs to read.
+        let (idlen, nr) =
+            wire::try_read_u32_as_usize(slice, "pattern ID length")?;
+        slice = &slice[nr..];
+
+        // Read the actual pattern IDs.
+        let pattern_ids_len =
+            wire::mul(idlen, PatternID::SIZE, "pattern ID byte length")?;
+        wire::check_slice_len(slice, pattern_ids_len, "match pattern IDs")?;
+        wire::check_alignment::<PatternID>(slice)?;
+        let pattern_ids_bytes = &slice[..pattern_ids_len];
+        slice = &slice[pattern_ids_len..];
+        // SAFETY: Since PatternID is always representable as a u32, all we
+        // need to do is ensure that we have the proper length and alignment.
+        // We've checked both above, so the cast below is safe.
+        //
+        // N.B. This is one of the few not-safe snippets in this function,
+        // so we mark it explicitly to call it out.
+        let pattern_ids = core::slice::from_raw_parts(
+            pattern_ids_bytes.as_ptr().cast::<u32>(),
+            idlen,
+        );
+
+        let ms = MatchStates { slices, pattern_ids, pattern_len };
+        Ok((ms, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl MatchStates<Vec<u32>> {
+    fn empty(pattern_len: usize) -> MatchStates<Vec<u32>> {
+        assert!(pattern_len <= PatternID::LIMIT);
+        MatchStates { slices: vec![], pattern_ids: vec![], pattern_len }
+    }
+
+    fn new(
+        matches: &BTreeMap<StateID, Vec<PatternID>>,
+        pattern_len: usize,
+    ) -> Result<MatchStates<Vec<u32>>, BuildError> {
+        let mut m = MatchStates::empty(pattern_len);
+        for (_, pids) in matches.iter() {
+            let start = PatternID::new(m.pattern_ids.len())
+                .map_err(|_| BuildError::too_many_match_pattern_ids())?;
+            m.slices.push(start.as_u32());
+            // This is always correct since the number of patterns in a single
+            // match state can never exceed maximum number of allowable
+            // patterns. Why? Because a pattern can only appear once in a
+            // particular match state, by construction. (And since our pattern
+            // ID limit is one less than u32::MAX, we're guaranteed that the
+            // length fits in a u32.)
+            m.slices.push(u32::try_from(pids.len()).unwrap());
+            for &pid in pids {
+                m.pattern_ids.push(pid.as_u32());
+            }
+        }
+        m.pattern_len = pattern_len;
+        Ok(m)
+    }
+
+    fn new_with_map(
+        &self,
+        matches: &BTreeMap<StateID, Vec<PatternID>>,
+    ) -> Result<MatchStates<Vec<u32>>, BuildError> {
+        MatchStates::new(matches, self.pattern_len)
+    }
+}
+
+impl<T: AsRef<[u32]>> MatchStates<T> {
+    /// Writes a serialized form of these match states to the buffer given. If
+    /// the buffer is too small, then an error is returned. To determine how
+    /// big the buffer must be, use `write_to_len`.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("match states"));
+        }
+        dst = &mut dst[..nwrite];
+
+        // write state ID length
+        // Unwrap is OK since number of states is guaranteed to fit in a u32.
+        E::write_u32(u32::try_from(self.len()).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write slice offset pairs
+        for &pid in self.slices() {
+            let n = wire::write_pattern_id::<E>(pid, &mut dst);
+            dst = &mut dst[n..];
+        }
+
+        // write unique pattern ID length
+        // Unwrap is OK since number of patterns is guaranteed to fit in a u32.
+        E::write_u32(u32::try_from(self.pattern_len).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write pattern ID length
+        // Unwrap is OK since we check at construction (and deserialization)
+        // that the number of patterns is representable as a u32.
+        E::write_u32(u32::try_from(self.pattern_ids().len()).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write pattern IDs
+        for &pid in self.pattern_ids() {
+            let n = wire::write_pattern_id::<E>(pid, &mut dst);
+            dst = &mut dst[n..];
+        }
+
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of these match states
+    /// will use.
+    fn write_to_len(&self) -> usize {
+        size_of::<u32>()   // match state length
+        + (self.slices().len() * PatternID::SIZE)
+        + size_of::<u32>() // unique pattern ID length
+        + size_of::<u32>() // pattern ID length
+        + (self.pattern_ids().len() * PatternID::SIZE)
+    }
+
+    /// Valides that the match state info is itself internally consistent and
+    /// consistent with the recorded match state region in the given DFA.
+    fn validate(&self, dfa: &DFA<T>) -> Result<(), DeserializeError> {
+        if self.len() != dfa.special.match_len(dfa.stride()) {
+            return Err(DeserializeError::generic(
+                "match state length mismatch",
+            ));
+        }
+        for si in 0..self.len() {
+            let start = self.slices()[si * 2].as_usize();
+            let len = self.slices()[si * 2 + 1].as_usize();
+            if start >= self.pattern_ids().len() {
+                return Err(DeserializeError::generic(
+                    "invalid pattern ID start offset",
+                ));
+            }
+            if start + len > self.pattern_ids().len() {
+                return Err(DeserializeError::generic(
+                    "invalid pattern ID length",
+                ));
+            }
+            for mi in 0..len {
+                let pid = self.pattern_id(si, mi);
+                if pid.as_usize() >= self.pattern_len {
+                    return Err(DeserializeError::generic(
+                        "invalid pattern ID",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Converts these match states back into their map form. This is useful
+    /// when shuffling states, as the normal MatchStates representation is not
+    /// amenable to easy state swapping. But with this map, to swap id1 and
+    /// id2, all you need to do is:
+    ///
+    /// if let Some(pids) = map.remove(&id1) {
+    ///     map.insert(id2, pids);
+    /// }
+    ///
+    /// Once shuffling is done, use MatchStates::new to convert back.
+    #[cfg(feature = "dfa-build")]
+    fn to_map(&self, dfa: &DFA<T>) -> BTreeMap<StateID, Vec<PatternID>> {
+        let mut map = BTreeMap::new();
+        for i in 0..self.len() {
+            let mut pids = vec![];
+            for j in 0..self.pattern_len(i) {
+                pids.push(self.pattern_id(i, j));
+            }
+            map.insert(self.match_state_id(dfa, i), pids);
+        }
+        map
+    }
+
+    /// Converts these match states to a borrowed value.
+    fn as_ref(&self) -> MatchStates<&'_ [u32]> {
+        MatchStates {
+            slices: self.slices.as_ref(),
+            pattern_ids: self.pattern_ids.as_ref(),
+            pattern_len: self.pattern_len,
+        }
+    }
+
+    /// Converts these match states to an owned value.
+    #[cfg(feature = "alloc")]
+    fn to_owned(&self) -> MatchStates<alloc::vec::Vec<u32>> {
+        MatchStates {
+            slices: self.slices.as_ref().to_vec(),
+            pattern_ids: self.pattern_ids.as_ref().to_vec(),
+            pattern_len: self.pattern_len,
+        }
+    }
+
+    /// Returns the match state ID given the match state index. (Where the
+    /// first match state corresponds to index 0.)
+    ///
+    /// This panics if there is no match state at the given index.
+    fn match_state_id(&self, dfa: &DFA<T>, index: usize) -> StateID {
+        assert!(dfa.special.matches(), "no match states to index");
+        // This is one of the places where we rely on the fact that match
+        // states are contiguous in the transition table. Namely, that the
+        // first match state ID always corresponds to dfa.special.min_start.
+        // From there, since we know the stride, we can compute the ID of any
+        // match state given its index.
+        let stride2 = u32::try_from(dfa.stride2()).unwrap();
+        let offset = index.checked_shl(stride2).unwrap();
+        let id = dfa.special.min_match.as_usize().checked_add(offset).unwrap();
+        let sid = StateID::new(id).unwrap();
+        assert!(dfa.is_match_state(sid));
+        sid
+    }
+
+    /// Returns the pattern ID at the given match index for the given match
+    /// state.
+    ///
+    /// The match state index is the state index minus the state index of the
+    /// first match state in the DFA.
+    ///
+    /// The match index is the index of the pattern ID for the given state.
+    /// The index must be less than `self.pattern_len(state_index)`.
+    fn pattern_id(&self, state_index: usize, match_index: usize) -> PatternID {
+        self.pattern_id_slice(state_index)[match_index]
+    }
+
+    /// Returns the number of patterns in the given match state.
+    ///
+    /// The match state index is the state index minus the state index of the
+    /// first match state in the DFA.
+    fn pattern_len(&self, state_index: usize) -> usize {
+        self.slices()[state_index * 2 + 1].as_usize()
+    }
+
+    /// Returns all of the pattern IDs for the given match state index.
+    ///
+    /// The match state index is the state index minus the state index of the
+    /// first match state in the DFA.
+    fn pattern_id_slice(&self, state_index: usize) -> &[PatternID] {
+        let start = self.slices()[state_index * 2].as_usize();
+        let len = self.pattern_len(state_index);
+        &self.pattern_ids()[start..start + len]
+    }
+
+    /// Returns the pattern ID offset slice of u32 as a slice of PatternID.
+    fn slices(&self) -> &[PatternID] {
+        wire::u32s_to_pattern_ids(self.slices.as_ref())
+    }
+
+    /// Returns the total number of match states.
+    fn len(&self) -> usize {
+        assert_eq!(0, self.slices().len() % 2);
+        self.slices().len() / 2
+    }
+
+    /// Returns the pattern ID slice of u32 as a slice of PatternID.
+    fn pattern_ids(&self) -> &[PatternID] {
+        wire::u32s_to_pattern_ids(self.pattern_ids.as_ref())
+    }
+
+    /// Return the memory usage, in bytes, of these match pairs.
+    fn memory_usage(&self) -> usize {
+        (self.slices().len() + self.pattern_ids().len()) * PatternID::SIZE
+    }
+}
+
+/// A common set of flags for both dense and sparse DFAs. This primarily
+/// centralizes the serialization format of these flags at a bitset.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Flags {
+    /// Whether the DFA can match the empty string. When this is false, all
+    /// matches returned by this DFA are guaranteed to have non-zero length.
+    pub(crate) has_empty: bool,
+    /// Whether the DFA should only produce matches with spans that correspond
+    /// to valid UTF-8. This also includes omitting any zero-width matches that
+    /// split the UTF-8 encoding of a codepoint.
+    pub(crate) is_utf8: bool,
+    /// Whether the DFA is always anchored or not, regardless of `Input`
+    /// configuration. This is useful for avoiding a reverse scan even when
+    /// executing unanchored searches.
+    pub(crate) is_always_start_anchored: bool,
+}
+
+impl Flags {
+    /// Creates a set of flags for a DFA from an NFA.
+    ///
+    /// N.B. This constructor was defined at the time of writing because all
+    /// of the flags are derived directly from the NFA. If this changes in the
+    /// future, we might be more thoughtful about how the `Flags` value is
+    /// itself built.
+    #[cfg(feature = "dfa-build")]
+    fn from_nfa(nfa: &thompson::NFA) -> Flags {
+        Flags {
+            has_empty: nfa.has_empty(),
+            is_utf8: nfa.is_utf8(),
+            is_always_start_anchored: nfa.is_always_start_anchored(),
+        }
+    }
+
+    /// Deserializes the flags from the given slice. On success, this also
+    /// returns the number of bytes read from the slice.
+    pub(crate) fn from_bytes(
+        slice: &[u8],
+    ) -> Result<(Flags, usize), DeserializeError> {
+        let (bits, nread) = wire::try_read_u32(slice, "flag bitset")?;
+        let flags = Flags {
+            has_empty: bits & (1 << 0) != 0,
+            is_utf8: bits & (1 << 1) != 0,
+            is_always_start_anchored: bits & (1 << 2) != 0,
+        };
+        Ok((flags, nread))
+    }
+
+    /// Writes these flags to the given byte slice. If the buffer is too small,
+    /// then an error is returned. To determine how big the buffer must be,
+    /// use `write_to_len`.
+    pub(crate) fn write_to<E: Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        fn bool_to_int(b: bool) -> u32 {
+            if b {
+                1
+            } else {
+                0
+            }
+        }
+
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("flag bitset"));
+        }
+        let bits = (bool_to_int(self.has_empty) << 0)
+            | (bool_to_int(self.is_utf8) << 1)
+            | (bool_to_int(self.is_always_start_anchored) << 2);
+        E::write_u32(bits, dst);
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of these flags
+    /// will use.
+    pub(crate) fn write_to_len(&self) -> usize {
+        size_of::<u32>()
+    }
+}
+
+/// An iterator over all states in a DFA.
+///
+/// This iterator yields a tuple for each state. The first element of the
+/// tuple corresponds to a state's identifier, and the second element
+/// corresponds to the state itself (comprised of its transitions).
+///
+/// `'a` corresponding to the lifetime of original DFA, `T` corresponds to
+/// the type of the transition table itself.
+pub(crate) struct StateIter<'a, T> {
+    tt: &'a TransitionTable<T>,
+    it: iter::Enumerate<slice::Chunks<'a, StateID>>,
+}
+
+impl<'a, T: AsRef<[u32]>> Iterator for StateIter<'a, T> {
+    type Item = State<'a>;
+
+    fn next(&mut self) -> Option<State<'a>> {
+        self.it.next().map(|(index, _)| {
+            let id = self.tt.to_state_id(index);
+            self.tt.state(id)
+        })
+    }
+}
+
+/// An immutable representation of a single DFA state.
+///
+/// `'a` correspondings to the lifetime of a DFA's transition table.
+pub(crate) struct State<'a> {
+    id: StateID,
+    stride2: usize,
+    transitions: &'a [StateID],
+}
+
+impl<'a> State<'a> {
+    /// Return an iterator over all transitions in this state. This yields
+    /// a number of transitions equivalent to the alphabet length of the
+    /// corresponding DFA.
+    ///
+    /// Each transition is represented by a tuple. The first element is
+    /// the input byte for that transition and the second element is the
+    /// transitions itself.
+    pub(crate) fn transitions(&self) -> StateTransitionIter<'_> {
+        StateTransitionIter {
+            len: self.transitions.len(),
+            it: self.transitions.iter().enumerate(),
+        }
+    }
+
+    /// Return an iterator over a sparse representation of the transitions in
+    /// this state. Only non-dead transitions are returned.
+    ///
+    /// The "sparse" representation in this case corresponds to a sequence of
+    /// triples. The first two elements of the triple comprise an inclusive
+    /// byte range while the last element corresponds to the transition taken
+    /// for all bytes in the range.
+    ///
+    /// This is somewhat more condensed than the classical sparse
+    /// representation (where you have an element for every non-dead
+    /// transition), but in practice, checking if a byte is in a range is very
+    /// cheap and using ranges tends to conserve quite a bit more space.
+    pub(crate) fn sparse_transitions(&self) -> StateSparseTransitionIter<'_> {
+        StateSparseTransitionIter { dense: self.transitions(), cur: None }
+    }
+
+    /// Returns the identifier for this state.
+    pub(crate) fn id(&self) -> StateID {
+        self.id
+    }
+
+    /// Analyzes this state to determine whether it can be accelerated. If so,
+    /// it returns an accelerator that contains at least one byte.
+    #[cfg(feature = "dfa-build")]
+    fn accelerate(&self, classes: &ByteClasses) -> Option<Accel> {
+        // We just try to add bytes to our accelerator. Once adding fails
+        // (because we've added too many bytes), then give up.
+        let mut accel = Accel::new();
+        for (class, id) in self.transitions() {
+            if id == self.id() {
+                continue;
+            }
+            for unit in classes.elements(class) {
+                if let Some(byte) = unit.as_u8() {
+                    if !accel.add(byte) {
+                        return None;
+                    }
+                }
+            }
+        }
+        if accel.is_empty() {
+            None
+        } else {
+            Some(accel)
+        }
+    }
+}
+
+impl<'a> fmt::Debug for State<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for (i, (start, end, sid)) in self.sparse_transitions().enumerate() {
+            let id = if f.alternate() {
+                sid.as_usize()
+            } else {
+                sid.as_usize() >> self.stride2
+            };
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            if start == end {
+                write!(f, "{:?} => {:?}", start, id)?;
+            } else {
+                write!(f, "{:?}-{:?} => {:?}", start, end, id)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over all transitions in a single DFA state. This yields
+/// a number of transitions equivalent to the alphabet length of the
+/// corresponding DFA.
+///
+/// Each transition is represented by a tuple. The first element is the input
+/// byte for that transition and the second element is the transition itself.
+#[derive(Debug)]
+pub(crate) struct StateTransitionIter<'a> {
+    len: usize,
+    it: iter::Enumerate<slice::Iter<'a, StateID>>,
+}
+
+impl<'a> Iterator for StateTransitionIter<'a> {
+    type Item = (alphabet::Unit, StateID);
+
+    fn next(&mut self) -> Option<(alphabet::Unit, StateID)> {
+        self.it.next().map(|(i, &id)| {
+            let unit = if i + 1 == self.len {
+                alphabet::Unit::eoi(i)
+            } else {
+                let b = u8::try_from(i)
+                    .expect("raw byte alphabet is never exceeded");
+                alphabet::Unit::u8(b)
+            };
+            (unit, id)
+        })
+    }
+}
+
+/// An iterator over all non-DEAD transitions in a single DFA state using a
+/// sparse representation.
+///
+/// Each transition is represented by a triple. The first two elements of the
+/// triple comprise an inclusive byte range while the last element corresponds
+/// to the transition taken for all bytes in the range.
+///
+/// As a convenience, this always returns `alphabet::Unit` values of the same
+/// type. That is, you'll never get a (byte, EOI) or a (EOI, byte). Only (byte,
+/// byte) and (EOI, EOI) values are yielded.
+#[derive(Debug)]
+pub(crate) struct StateSparseTransitionIter<'a> {
+    dense: StateTransitionIter<'a>,
+    cur: Option<(alphabet::Unit, alphabet::Unit, StateID)>,
+}
+
+impl<'a> Iterator for StateSparseTransitionIter<'a> {
+    type Item = (alphabet::Unit, alphabet::Unit, StateID);
+
+    fn next(&mut self) -> Option<(alphabet::Unit, alphabet::Unit, StateID)> {
+        while let Some((unit, next)) = self.dense.next() {
+            let (prev_start, prev_end, prev_next) = match self.cur {
+                Some(t) => t,
+                None => {
+                    self.cur = Some((unit, unit, next));
+                    continue;
+                }
+            };
+            if prev_next == next && !unit.is_eoi() {
+                self.cur = Some((prev_start, unit, prev_next));
+            } else {
+                self.cur = Some((unit, unit, next));
+                if prev_next != DEAD {
+                    return Some((prev_start, prev_end, prev_next));
+                }
+            }
+        }
+        if let Some((start, end, next)) = self.cur.take() {
+            if next != DEAD {
+                return Some((start, end, next));
+            }
+        }
+        None
+    }
+}
+
+/// An error that occurred during the construction of a DFA.
+///
+/// This error does not provide many introspection capabilities. There are
+/// generally only two things you can do with it:
+///
+/// * Obtain a human readable message via its `std::fmt::Display` impl.
+/// * Access an underlying [`nfa::thompson::BuildError`](thompson::BuildError)
+/// type from its `source` method via the `std::error::Error` trait. This error
+/// only occurs when using convenience routines for building a DFA directly
+/// from a pattern string.
+///
+/// When the `std` feature is enabled, this implements the `std::error::Error`
+/// trait.
+#[cfg(feature = "dfa-build")]
+#[derive(Clone, Debug)]
+pub struct BuildError {
+    kind: BuildErrorKind,
+}
+
+/// The kind of error that occurred during the construction of a DFA.
+///
+/// Note that this error is non-exhaustive. Adding new variants is not
+/// considered a breaking change.
+#[cfg(feature = "dfa-build")]
+#[derive(Clone, Debug)]
+enum BuildErrorKind {
+    /// An error that occurred while constructing an NFA as a precursor step
+    /// before a DFA is compiled.
+    NFA(thompson::BuildError),
+    /// An error that occurred because an unsupported regex feature was used.
+    /// The message string describes which unsupported feature was used.
+    ///
+    /// The primary regex feature that is unsupported by DFAs is the Unicode
+    /// word boundary look-around assertion (`\b`). This can be worked around
+    /// by either using an ASCII word boundary (`(?-u:\b)`) or by enabling
+    /// Unicode word boundaries when building a DFA.
+    Unsupported(&'static str),
+    /// An error that occurs if too many states are produced while building a
+    /// DFA.
+    TooManyStates,
+    /// An error that occurs if too many start states are needed while building
+    /// a DFA.
+    ///
+    /// This is a kind of oddball error that occurs when building a DFA with
+    /// start states enabled for each pattern and enough patterns to cause
+    /// the table of start states to overflow `usize`.
+    TooManyStartStates,
+    /// This is another oddball error that can occur if there are too many
+    /// patterns spread out across too many match states.
+    TooManyMatchPatternIDs,
+    /// An error that occurs if the DFA got too big during determinization.
+    DFAExceededSizeLimit { limit: usize },
+    /// An error that occurs if auxiliary storage (not the DFA) used during
+    /// determinization got too big.
+    DeterminizeExceededSizeLimit { limit: usize },
+}
+
+#[cfg(feature = "dfa-build")]
+impl BuildError {
+    /// Return the kind of this error.
+    fn kind(&self) -> &BuildErrorKind {
+        &self.kind
+    }
+
+    pub(crate) fn nfa(err: thompson::BuildError) -> BuildError {
+        BuildError { kind: BuildErrorKind::NFA(err) }
+    }
+
+    pub(crate) fn unsupported_dfa_word_boundary_unicode() -> BuildError {
+        let msg = "cannot build DFAs for regexes with Unicode word \
+                   boundaries; switch to ASCII word boundaries, or \
+                   heuristically enable Unicode word boundaries or use a \
+                   different regex engine";
+        BuildError { kind: BuildErrorKind::Unsupported(msg) }
+    }
+
+    pub(crate) fn too_many_states() -> BuildError {
+        BuildError { kind: BuildErrorKind::TooManyStates }
+    }
+
+    pub(crate) fn too_many_start_states() -> BuildError {
+        BuildError { kind: BuildErrorKind::TooManyStartStates }
+    }
+
+    pub(crate) fn too_many_match_pattern_ids() -> BuildError {
+        BuildError { kind: BuildErrorKind::TooManyMatchPatternIDs }
+    }
+
+    pub(crate) fn dfa_exceeded_size_limit(limit: usize) -> BuildError {
+        BuildError { kind: BuildErrorKind::DFAExceededSizeLimit { limit } }
+    }
+
+    pub(crate) fn determinize_exceeded_size_limit(limit: usize) -> BuildError {
+        BuildError {
+            kind: BuildErrorKind::DeterminizeExceededSizeLimit { limit },
+        }
+    }
+}
+
+#[cfg(all(feature = "std", feature = "dfa-build"))]
+impl std::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind() {
+            BuildErrorKind::NFA(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl core::fmt::Display for BuildError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self.kind() {
+            BuildErrorKind::NFA(_) => write!(f, "error building NFA"),
+            BuildErrorKind::Unsupported(ref msg) => {
+                write!(f, "unsupported regex feature for DFAs: {}", msg)
+            }
+            BuildErrorKind::TooManyStates => write!(
+                f,
+                "number of DFA states exceeds limit of {}",
+                StateID::LIMIT,
+            ),
+            BuildErrorKind::TooManyStartStates => {
+                let stride = Start::len();
+                // The start table has `stride` entries for starting states for
+                // the entire DFA, and then `stride` entries for each pattern
+                // if start states for each pattern are enabled (which is the
+                // only way this error can occur). Thus, the total number of
+                // patterns that can fit in the table is `stride` less than
+                // what we can allocate.
+                let max = usize::try_from(core::isize::MAX).unwrap();
+                let limit = (max - stride) / stride;
+                write!(
+                    f,
+                    "compiling DFA with start states exceeds pattern \
+                     pattern limit of {}",
+                    limit,
+                )
+            }
+            BuildErrorKind::TooManyMatchPatternIDs => write!(
+                f,
+                "compiling DFA with total patterns in all match states \
+                 exceeds limit of {}",
+                PatternID::LIMIT,
+            ),
+            BuildErrorKind::DFAExceededSizeLimit { limit } => write!(
+                f,
+                "DFA exceeded size limit of {:?} during determinization",
+                limit,
+            ),
+            BuildErrorKind::DeterminizeExceededSizeLimit { limit } => {
+                write!(f, "determinization exceeded size limit of {:?}", limit)
+            }
+        }
+    }
+}
+
+#[cfg(all(test, feature = "syntax", feature = "dfa-build"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn errors_with_unicode_word_boundary() {
+        let pattern = r"\b";
+        assert!(Builder::new().build(pattern).is_err());
+    }
+
+    #[test]
+    fn roundtrip_never_match() {
+        let dfa = DFA::never_match().unwrap();
+        let (buf, _) = dfa.to_bytes_native_endian();
+        let dfa: DFA<&[u32]> = DFA::from_bytes(&buf).unwrap().0;
+
+        assert_eq!(None, dfa.try_search_fwd(&Input::new("foo12345")).unwrap());
+    }
+
+    #[test]
+    fn roundtrip_always_match() {
+        use crate::HalfMatch;
+
+        let dfa = DFA::always_match().unwrap();
+        let (buf, _) = dfa.to_bytes_native_endian();
+        let dfa: DFA<&[u32]> = DFA::from_bytes(&buf).unwrap().0;
+
+        assert_eq!(
+            Some(HalfMatch::must(0, 0)),
+            dfa.try_search_fwd(&Input::new("foo12345")).unwrap()
+        );
+    }
+
+    // See the analogous test in src/hybrid/dfa.rs.
+    #[test]
+    fn heuristic_unicode_reverse() {
+        let dfa = DFA::builder()
+            .configure(DFA::config().unicode_word_boundary(true))
+            .thompson(thompson::Config::new().reverse(true))
+            .build(r"\b[0-9]+\b")
+            .unwrap();
+
+        let input = Input::new("β123").range(2..);
+        let expected = MatchError::quit(0xB2, 1);
+        let got = dfa.try_search_rev(&input);
+        assert_eq!(Err(expected), got);
+
+        let input = Input::new("123β").range(..3);
+        let expected = MatchError::quit(0xCE, 3);
+        let got = dfa.try_search_rev(&input);
+        assert_eq!(Err(expected), got);
+    }
+}
diff --git a/regex-automata/src/dfa/determinize.rs b/regex-automata/src/dfa/determinize.rs
new file mode 100644
index 0000000000..0a645bc948
--- /dev/null
+++ b/regex-automata/src/dfa/determinize.rs
@@ -0,0 +1,599 @@
+use alloc::{collections::BTreeMap, vec::Vec};
+
+use crate::{
+    dfa::{
+        dense::{self, BuildError},
+        DEAD,
+    },
+    nfa::thompson,
+    util::{
+        self,
+        alphabet::{self, ByteSet},
+        determinize::{State, StateBuilderEmpty, StateBuilderNFA},
+        primitives::{PatternID, StateID},
+        search::{Anchored, MatchKind},
+        sparse_set::SparseSets,
+        start::Start,
+    },
+};
+
+/// A builder for configuring and running a DFA determinizer.
+#[derive(Clone, Debug)]
+pub(crate) struct Config {
+    match_kind: MatchKind,
+    quit: ByteSet,
+    dfa_size_limit: Option<usize>,
+    determinize_size_limit: Option<usize>,
+}
+
+impl Config {
+    /// Create a new default config for a determinizer. The determinizer may be
+    /// configured before calling `run`.
+    pub fn new() -> Config {
+        Config {
+            match_kind: MatchKind::LeftmostFirst,
+            quit: ByteSet::empty(),
+            dfa_size_limit: None,
+            determinize_size_limit: None,
+        }
+    }
+
+    /// Run determinization on the given NFA and write the resulting DFA into
+    /// the one given. The DFA given should be initialized but otherwise empty.
+    /// "Initialized" means that it is setup to handle the NFA's byte classes,
+    /// number of patterns and whether to build start states for each pattern.
+    pub fn run(
+        &self,
+        nfa: &thompson::NFA,
+        dfa: &mut dense::OwnedDFA,
+    ) -> Result<(), BuildError> {
+        let dead = State::dead();
+        let quit = State::dead();
+        let mut cache = StateMap::default();
+        // We only insert the dead state here since its representation is
+        // identical to the quit state. And we never want anything pointing
+        // to the quit state other than specific transitions derived from the
+        // determinizer's configured "quit" bytes.
+        //
+        // We do put the quit state into 'builder_states' below. This ensures
+        // that a proper DFA state ID is allocated for it, and that no other
+        // DFA state uses the "location after the DEAD state." That is, it
+        // is assumed that the quit state is always the state immediately
+        // following the DEAD state.
+        cache.insert(dead.clone(), DEAD);
+
+        let runner = Runner {
+            config: self.clone(),
+            nfa,
+            dfa,
+            builder_states: alloc::vec![dead, quit],
+            cache,
+            memory_usage_state: 0,
+            sparses: SparseSets::new(nfa.states().len()),
+            stack: alloc::vec![],
+            scratch_state_builder: StateBuilderEmpty::new(),
+        };
+        runner.run()
+    }
+
+    /// The match semantics to use for determinization.
+    ///
+    /// MatchKind::All corresponds to the standard textbook construction.
+    /// All possible match states are represented in the DFA.
+    /// MatchKind::LeftmostFirst permits greediness and otherwise tries to
+    /// simulate the match semantics of backtracking regex engines. Namely,
+    /// only a subset of match states are built, and dead states are used to
+    /// stop searches with an unanchored prefix.
+    ///
+    /// The default is MatchKind::LeftmostFirst.
+    pub fn match_kind(&mut self, kind: MatchKind) -> &mut Config {
+        self.match_kind = kind;
+        self
+    }
+
+    /// The set of bytes to use that will cause the DFA to enter a quit state,
+    /// stop searching and return an error. By default, this is empty.
+    pub fn quit(&mut self, set: ByteSet) -> &mut Config {
+        self.quit = set;
+        self
+    }
+
+    /// The limit, in bytes of the heap, that the DFA is permitted to use. This
+    /// does not include the auxiliary heap storage used by determinization.
+    pub fn dfa_size_limit(&mut self, bytes: Option<usize>) -> &mut Config {
+        self.dfa_size_limit = bytes;
+        self
+    }
+
+    /// The limit, in bytes of the heap, that determinization itself is allowed
+    /// to use. This does not include the size of the DFA being built.
+    pub fn determinize_size_limit(
+        &mut self,
+        bytes: Option<usize>,
+    ) -> &mut Config {
+        self.determinize_size_limit = bytes;
+        self
+    }
+}
+
+/// The actual implementation of determinization that converts an NFA to a DFA
+/// through powerset construction.
+///
+/// This determinizer roughly follows the typical powerset construction, where
+/// each DFA state is comprised of one or more NFA states. In the worst case,
+/// there is one DFA state for every possible combination of NFA states. In
+/// practice, this only happens in certain conditions, typically when there are
+/// bounded repetitions.
+///
+/// The main differences between this implementation and typical deteminization
+/// are that this implementation delays matches by one state and hackily makes
+/// look-around work. Comments below attempt to explain this.
+///
+/// The lifetime variable `'a` refers to the lifetime of the NFA or DFA,
+/// whichever is shorter.
+#[derive(Debug)]
+struct Runner<'a> {
+    /// The configuration used to initialize determinization.
+    config: Config,
+    /// The NFA we're converting into a DFA.
+    nfa: &'a thompson::NFA,
+    /// The DFA we're building.
+    dfa: &'a mut dense::OwnedDFA,
+    /// Each DFA state being built is defined as an *ordered* set of NFA
+    /// states, along with some meta facts about the ordered set of NFA states.
+    ///
+    /// This is never empty. The first state is always a dummy state such that
+    /// a state id == 0 corresponds to a dead state. The second state is always
+    /// the quit state.
+    ///
+    /// Why do we have states in both a `Vec` and in a cache map below?
+    /// Well, they serve two different roles based on access patterns.
+    /// `builder_states` is the canonical home of each state, and provides
+    /// constant random access by a DFA state's ID. The cache map below, on
+    /// the other hand, provides a quick way of searching for identical DFA
+    /// states by using the DFA state as a key in the map. Of course, we use
+    /// reference counting to avoid actually duplicating the state's data
+    /// itself. (Although this has never been benchmarked.) Note that the cache
+    /// map does not give us full minimization; it just lets us avoid some very
+    /// obvious redundant states.
+    ///
+    /// Note that the index into this Vec isn't quite the DFA's state ID.
+    /// Rather, it's just an index. To get the state ID, you have to multiply
+    /// it by the DFA's stride. That's done by self.dfa.from_index. And the
+    /// inverse is self.dfa.to_index.
+    ///
+    /// Moreover, DFA states don't usually retain the IDs assigned to them
+    /// by their position in this Vec. After determinization completes,
+    /// states are shuffled around to support other optimizations. See the
+    /// sibling 'special' module for more details on that. (The reason for
+    /// mentioning this is that if you print out the DFA for debugging during
+    /// determinization, and then print out the final DFA after it is fully
+    /// built, then the state IDs likely won't match up.)
+    builder_states: Vec<State>,
+    /// A cache of DFA states that already exist and can be easily looked up
+    /// via ordered sets of NFA states.
+    ///
+    /// See `builder_states` docs for why we store states in two different
+    /// ways.
+    cache: StateMap,
+    /// The memory usage, in bytes, used by builder_states and cache. We track
+    /// this as new states are added since states use a variable amount of
+    /// heap. Tracking this as we add states makes it possible to compute the
+    /// total amount of memory used by the determinizer in constant time.
+    memory_usage_state: usize,
+    /// A pair of sparse sets for tracking ordered sets of NFA state IDs.
+    /// These are reused throughout determinization. A bounded sparse set
+    /// gives us constant time insertion, membership testing and clearing.
+    sparses: SparseSets,
+    /// Scratch space for a stack of NFA states to visit, for depth first
+    /// visiting without recursion.
+    stack: Vec<StateID>,
+    /// Scratch space for storing an ordered sequence of NFA states, for
+    /// amortizing allocation. This is principally useful for when we avoid
+    /// adding a new DFA state since it already exists. In order to detect this
+    /// case though, we still need an ordered set of NFA state IDs. So we use
+    /// this space to stage that ordered set before we know whether we need to
+    /// create a new DFA state or not.
+    scratch_state_builder: StateBuilderEmpty,
+}
+
+/// A map from states to state identifiers. When using std, we use a standard
+/// hashmap, since it's a bit faster for this use case. (Other maps, like
+/// one's based on FNV, have not yet been benchmarked.)
+///
+/// The main purpose of this map is to reuse states where possible. This won't
+/// fully minimize the DFA, but it works well in a lot of cases.
+#[cfg(feature = "std")]
+type StateMap = std::collections::HashMap<State, StateID>;
+#[cfg(not(feature = "std"))]
+type StateMap = BTreeMap<State, StateID>;
+
+impl<'a> Runner<'a> {
+    /// Build the DFA. If there was a problem constructing the DFA (e.g., if
+    /// the chosen state identifier representation is too small), then an error
+    /// is returned.
+    fn run(mut self) -> Result<(), BuildError> {
+        if self.nfa.look_set_any().contains_word_unicode()
+            && !self.config.quit.contains_range(0x80, 0xFF)
+        {
+            return Err(BuildError::unsupported_dfa_word_boundary_unicode());
+        }
+
+        // A sequence of "representative" bytes drawn from each equivalence
+        // class. These representative bytes are fed to the NFA to compute
+        // state transitions. This allows us to avoid re-computing state
+        // transitions for bytes that are guaranteed to produce identical
+        // results. Since computing the representatives needs to do a little
+        // work, we do it once here because we'll be iterating over them a lot.
+        let representatives: Vec<alphabet::Unit> =
+            self.dfa.byte_classes().representatives(..).collect();
+        // The set of all DFA state IDs that still need to have their
+        // transitions set. We start by seeding this with all starting states.
+        let mut uncompiled = alloc::vec![];
+        self.add_all_starts(&mut uncompiled)?;
+        while let Some(dfa_id) = uncompiled.pop() {
+            for &unit in &representatives {
+                if unit.as_u8().map_or(false, |b| self.config.quit.contains(b))
+                {
+                    continue;
+                }
+                // In many cases, the state we transition to has already been
+                // computed. 'cached_state' will do the minimal amount of work
+                // to check this, and if it exists, immediately return an
+                // already existing state ID.
+                let (next_dfa_id, is_new) = self.cached_state(dfa_id, unit)?;
+                self.dfa.set_transition(dfa_id, unit, next_dfa_id);
+                // If the state ID we got back is newly created, then we need
+                // to compile it, so add it to our uncompiled frontier.
+                if is_new {
+                    uncompiled.push(next_dfa_id);
+                }
+            }
+        }
+        debug!(
+            "determinization complete, memory usage: {}, \
+             dense DFA size: {}, \
+             is reverse? {}",
+            self.memory_usage(),
+            self.dfa.memory_usage(),
+            self.nfa.is_reverse(),
+        );
+
+        // A map from DFA state ID to one or more NFA match IDs. Each NFA match
+        // ID corresponds to a distinct regex pattern that matches in the state
+        // corresponding to the key.
+        let mut matches: BTreeMap<StateID, Vec<PatternID>> = BTreeMap::new();
+        self.cache.clear();
+        #[cfg(feature = "logging")]
+        let mut total_pat_len = 0;
+        for (i, state) in self.builder_states.into_iter().enumerate() {
+            if let Some(pat_ids) = state.match_pattern_ids() {
+                let id = self.dfa.to_state_id(i);
+                log! {
+                    total_pat_len += pat_ids.len();
+                }
+                matches.insert(id, pat_ids);
+            }
+        }
+        log! {
+            use core::mem::size_of;
+            let per_elem = size_of::<StateID>() + size_of::<Vec<PatternID>>();
+            let pats = total_pat_len * size_of::<PatternID>();
+            let mem = (matches.len() * per_elem) + pats;
+            log::debug!("matches map built, memory usage: {}", mem);
+        }
+        // At this point, we shuffle the "special" states in the final DFA.
+        // This permits a DFA's match loop to detect a match condition (among
+        // other things) by merely inspecting the current state's identifier,
+        // and avoids the need for any additional auxiliary storage.
+        self.dfa.shuffle(matches)?;
+        Ok(())
+    }
+
+    /// Return the identifier for the next DFA state given an existing DFA
+    /// state and an input byte. If the next DFA state already exists, then
+    /// return its identifier from the cache. Otherwise, build the state, cache
+    /// it and return its identifier.
+    ///
+    /// This routine returns a boolean indicating whether a new state was
+    /// built. If a new state is built, then the caller needs to add it to its
+    /// frontier of uncompiled DFA states to compute transitions for.
+    fn cached_state(
+        &mut self,
+        dfa_id: StateID,
+        unit: alphabet::Unit,
+    ) -> Result<(StateID, bool), BuildError> {
+        // Compute the set of all reachable NFA states, including epsilons.
+        let empty_builder = self.get_state_builder();
+        let builder = util::determinize::next(
+            self.nfa,
+            self.config.match_kind,
+            &mut self.sparses,
+            &mut self.stack,
+            &self.builder_states[self.dfa.to_index(dfa_id)],
+            unit,
+            empty_builder,
+        );
+        self.maybe_add_state(builder)
+    }
+
+    /// Compute the set of DFA start states and add their identifiers in
+    /// 'dfa_state_ids' (no duplicates are added).
+    fn add_all_starts(
+        &mut self,
+        dfa_state_ids: &mut Vec<StateID>,
+    ) -> Result<(), BuildError> {
+        // These should be the first states added.
+        assert!(dfa_state_ids.is_empty());
+        // We only want to add (un)anchored starting states that is consistent
+        // with our DFA's configuration. Unconditionally adding both (although
+        // it is the default) can make DFAs quite a bit bigger.
+        if self.dfa.start_kind().has_unanchored() {
+            self.add_start_group(Anchored::No, dfa_state_ids)?;
+        }
+        if self.dfa.start_kind().has_anchored() {
+            self.add_start_group(Anchored::Yes, dfa_state_ids)?;
+        }
+        // I previously has an 'assert' here checking that either
+        // 'dfa_state_ids' was non-empty, or the NFA had zero patterns. But it
+        // turns out this isn't always true. For example, the NFA might have
+        // one or more patterns but where all such patterns are just 'fail'
+        // states. These will ultimately just compile down to DFA dead states,
+        // and since the dead state was added earlier, no new DFA states are
+        // added. And thus, it is valid and okay for 'dfa_state_ids' to be
+        // empty even if there are a non-zero number of patterns in the NFA.
+
+        // We only need to compute anchored start states for each pattern if it
+        // was requested to do so.
+        if self.dfa.starts_for_each_pattern() {
+            for pid in self.nfa.patterns() {
+                self.add_start_group(Anchored::Pattern(pid), dfa_state_ids)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Add a group of start states for the given match pattern ID. Any new
+    /// DFA states added are pushed on to 'dfa_state_ids'. (No duplicates are
+    /// pushed.)
+    ///
+    /// When pattern_id is None, then this will compile a group of unanchored
+    /// start states (if the DFA is unanchored). When the pattern_id is
+    /// present, then this will compile a group of anchored start states that
+    /// only match the given pattern.
+    ///
+    /// This panics if `anchored` corresponds to an invalid pattern ID.
+    fn add_start_group(
+        &mut self,
+        anchored: Anchored,
+        dfa_state_ids: &mut Vec<StateID>,
+    ) -> Result<(), BuildError> {
+        let nfa_start = match anchored {
+            Anchored::No => self.nfa.start_unanchored(),
+            Anchored::Yes => self.nfa.start_anchored(),
+            Anchored::Pattern(pid) => {
+                self.nfa.start_pattern(pid).expect("valid pattern ID")
+            }
+        };
+
+        // When compiling start states, we're careful not to build additional
+        // states that aren't necessary. For example, if the NFA has no word
+        // boundary assertion, then there's no reason to have distinct start
+        // states for 'NonWordByte' and 'WordByte' starting configurations.
+        // Instead, the 'WordByte' starting configuration can just point
+        // directly to the start state for the 'NonWordByte' config.
+        //
+        // Note though that we only need to care about assertions in the prefix
+        // of an NFA since this only concerns the starting states. (Actually,
+        // the most precisely thing we could do it is look at the prefix
+        // assertions of each pattern when 'anchored == Anchored::Pattern',
+        // and then only compile extra states if the prefix is non-empty.) But
+        // we settle for simplicity here instead of absolute minimalism. It is
+        // somewhat rare, after all, for multiple patterns in the same regex to
+        // have different prefix look-arounds.
+
+        let (id, is_new) =
+            self.add_one_start(nfa_start, Start::NonWordByte)?;
+        self.dfa.set_start_state(anchored, Start::NonWordByte, id);
+        if is_new {
+            dfa_state_ids.push(id);
+        }
+
+        if !self.nfa.look_set_prefix_any().contains_word() {
+            self.dfa.set_start_state(anchored, Start::WordByte, id);
+        } else {
+            let (id, is_new) =
+                self.add_one_start(nfa_start, Start::WordByte)?;
+            self.dfa.set_start_state(anchored, Start::WordByte, id);
+            if is_new {
+                dfa_state_ids.push(id);
+            }
+        }
+        if !self.nfa.look_set_prefix_any().contains_anchor() {
+            self.dfa.set_start_state(anchored, Start::Text, id);
+            self.dfa.set_start_state(anchored, Start::LineLF, id);
+            self.dfa.set_start_state(anchored, Start::LineCR, id);
+            self.dfa.set_start_state(
+                anchored,
+                Start::CustomLineTerminator,
+                id,
+            );
+        } else {
+            let (id, is_new) = self.add_one_start(nfa_start, Start::Text)?;
+            self.dfa.set_start_state(anchored, Start::Text, id);
+            if is_new {
+                dfa_state_ids.push(id);
+            }
+
+            let (id, is_new) = self.add_one_start(nfa_start, Start::LineLF)?;
+            self.dfa.set_start_state(anchored, Start::LineLF, id);
+            if is_new {
+                dfa_state_ids.push(id);
+            }
+
+            let (id, is_new) = self.add_one_start(nfa_start, Start::LineCR)?;
+            self.dfa.set_start_state(anchored, Start::LineCR, id);
+            if is_new {
+                dfa_state_ids.push(id);
+            }
+
+            let (id, is_new) =
+                self.add_one_start(nfa_start, Start::CustomLineTerminator)?;
+            self.dfa.set_start_state(
+                anchored,
+                Start::CustomLineTerminator,
+                id,
+            );
+            if is_new {
+                dfa_state_ids.push(id);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Add a new DFA start state corresponding to the given starting NFA
+    /// state, and the starting search configuration. (The starting search
+    /// configuration essentially tells us which look-behind assertions are
+    /// true for this particular state.)
+    ///
+    /// The boolean returned indicates whether the state ID returned is a newly
+    /// created state, or a previously cached state.
+    fn add_one_start(
+        &mut self,
+        nfa_start: StateID,
+        start: Start,
+    ) -> Result<(StateID, bool), BuildError> {
+        // Compute the look-behind assertions that are true in this starting
+        // configuration, and the determine the epsilon closure. While
+        // computing the epsilon closure, we only follow condiional epsilon
+        // transitions that satisfy the look-behind assertions in 'look_have'.
+        let mut builder_matches = self.get_state_builder().into_matches();
+        util::determinize::set_lookbehind_from_start(
+            self.nfa,
+            &start,
+            &mut builder_matches,
+        );
+        self.sparses.set1.clear();
+        util::determinize::epsilon_closure(
+            self.nfa,
+            nfa_start,
+            builder_matches.look_have(),
+            &mut self.stack,
+            &mut self.sparses.set1,
+        );
+        let mut builder = builder_matches.into_nfa();
+        util::determinize::add_nfa_states(
+            &self.nfa,
+            &self.sparses.set1,
+            &mut builder,
+        );
+        self.maybe_add_state(builder)
+    }
+
+    /// Adds the given state to the DFA being built depending on whether it
+    /// already exists in this determinizer's cache.
+    ///
+    /// If it does exist, then the memory used by 'state' is put back into the
+    /// determinizer and the previously created state's ID is returned. (Along
+    /// with 'false', indicating that no new state was added.)
+    ///
+    /// If it does not exist, then the state is added to the DFA being built
+    /// and a fresh ID is allocated (if ID allocation fails, then an error is
+    /// returned) and returned. (Along with 'true', indicating that a new state
+    /// was added.)
+    fn maybe_add_state(
+        &mut self,
+        builder: StateBuilderNFA,
+    ) -> Result<(StateID, bool), BuildError> {
+        if let Some(&cached_id) = self.cache.get(builder.as_bytes()) {
+            // Since we have a cached state, put the constructed state's
+            // memory back into our scratch space, so that it can be reused.
+            self.put_state_builder(builder);
+            return Ok((cached_id, false));
+        }
+        self.add_state(builder).map(|sid| (sid, true))
+    }
+
+    /// Add the given state to the DFA and make it available in the cache.
+    ///
+    /// The state initially has no transitions. That is, it transitions to the
+    /// dead state for all possible inputs, and transitions to the quit state
+    /// for all quit bytes.
+    ///
+    /// If adding the state would exceed the maximum value for StateID, then an
+    /// error is returned.
+    fn add_state(
+        &mut self,
+        builder: StateBuilderNFA,
+    ) -> Result<StateID, BuildError> {
+        let id = self.dfa.add_empty_state()?;
+        if !self.config.quit.is_empty() {
+            for b in self.config.quit.iter() {
+                self.dfa.set_transition(
+                    id,
+                    alphabet::Unit::u8(b),
+                    self.dfa.quit_id(),
+                );
+            }
+        }
+        let state = builder.to_state();
+        // States use reference counting internally, so we only need to count
+        // their memroy usage once.
+        self.memory_usage_state += state.memory_usage();
+        self.builder_states.push(state.clone());
+        self.cache.insert(state, id);
+        self.put_state_builder(builder);
+        if let Some(limit) = self.config.dfa_size_limit {
+            if self.dfa.memory_usage() > limit {
+                return Err(BuildError::dfa_exceeded_size_limit(limit));
+            }
+        }
+        if let Some(limit) = self.config.determinize_size_limit {
+            if self.memory_usage() > limit {
+                return Err(BuildError::determinize_exceeded_size_limit(
+                    limit,
+                ));
+            }
+        }
+        Ok(id)
+    }
+
+    /// Returns a state builder from this determinizer that might have existing
+    /// capacity. This helps avoid allocs in cases where a state is built that
+    /// turns out to already be cached.
+    ///
+    /// Callers must put the state builder back with 'put_state_builder',
+    /// otherwise the allocation reuse won't work.
+    fn get_state_builder(&mut self) -> StateBuilderEmpty {
+        core::mem::replace(
+            &mut self.scratch_state_builder,
+            StateBuilderEmpty::new(),
+        )
+    }
+
+    /// Puts the given state builder back into this determinizer for reuse.
+    ///
+    /// Note that building a 'State' from a builder always creates a new
+    /// alloc, so callers should always put the builder back.
+    fn put_state_builder(&mut self, builder: StateBuilderNFA) {
+        let _ = core::mem::replace(
+            &mut self.scratch_state_builder,
+            builder.clear(),
+        );
+    }
+
+    /// Return the memory usage, in bytes, of this determinizer at the current
+    /// point in time. This does not include memory used by the NFA or the
+    /// dense DFA itself.
+    fn memory_usage(&self) -> usize {
+        use core::mem::size_of;
+
+        self.builder_states.len() * size_of::<State>()
+        // Maps likely use more memory than this, but it's probably close.
+        + self.cache.len() * (size_of::<State>() + size_of::<StateID>())
+        + self.memory_usage_state
+        + self.stack.capacity() * size_of::<StateID>()
+        + self.scratch_state_builder.capacity()
+    }
+}
diff --git a/regex-automata/src/dfa/minimize.rs b/regex-automata/src/dfa/minimize.rs
new file mode 100644
index 0000000000..ccb16a923e
--- /dev/null
+++ b/regex-automata/src/dfa/minimize.rs
@@ -0,0 +1,463 @@
+use core::{cell::RefCell, fmt, mem};
+
+use alloc::{collections::BTreeMap, rc::Rc, vec, vec::Vec};
+
+use crate::{
+    dfa::{automaton::Automaton, dense, DEAD},
+    util::{
+        alphabet,
+        primitives::{PatternID, StateID},
+    },
+};
+
+/// An implementation of Hopcroft's algorithm for minimizing DFAs.
+///
+/// The algorithm implemented here is mostly taken from Wikipedia:
+/// https://en.wikipedia.org/wiki/DFA_minimization#Hopcroft's_algorithm
+///
+/// This code has had some light optimization attention paid to it,
+/// particularly in the form of reducing allocation as much as possible.
+/// However, it is still generally slow. Future optimization work should
+/// probably focus on the bigger picture rather than micro-optimizations. For
+/// example:
+///
+/// 1. Figure out how to more intelligently create initial partitions. That is,
+///    Hopcroft's algorithm starts by creating two partitions of DFA states
+///    that are known to NOT be equivalent: match states and non-match states.
+///    The algorithm proceeds by progressively refining these partitions into
+///    smaller partitions. If we could start with more partitions, then we
+///    could reduce the amount of work that Hopcroft's algorithm needs to do.
+/// 2. For every partition that we visit, we find all incoming transitions to
+///    every state in the partition for *every* element in the alphabet. (This
+///    is why using byte classes can significantly decrease minimization times,
+///    since byte classes shrink the alphabet.) This is quite costly and there
+///    is perhaps some redundant work being performed depending on the specific
+///    states in the set. For example, we might be able to only visit some
+///    elements of the alphabet based on the transitions.
+/// 3. Move parts of minimization into determinization. If minimization has
+///    fewer states to deal with, then it should run faster. A prime example
+///    of this might be large Unicode classes, which are generated in way that
+///    can create a lot of redundant states. (Some work has been done on this
+///    point during NFA compilation via the algorithm described in the
+///    "Incremental Construction of MinimalAcyclic Finite-State Automata"
+///    paper.)
+pub(crate) struct Minimizer<'a> {
+    dfa: &'a mut dense::OwnedDFA,
+    in_transitions: Vec<Vec<Vec<StateID>>>,
+    partitions: Vec<StateSet>,
+    waiting: Vec<StateSet>,
+}
+
+impl<'a> fmt::Debug for Minimizer<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Minimizer")
+            .field("dfa", &self.dfa)
+            .field("in_transitions", &self.in_transitions)
+            .field("partitions", &self.partitions)
+            .field("waiting", &self.waiting)
+            .finish()
+    }
+}
+
+/// A set of states. A state set makes up a single partition in Hopcroft's
+/// algorithm.
+///
+/// It is represented by an ordered set of state identifiers. We use shared
+/// ownership so that a single state set can be in both the set of partitions
+/// and in the set of waiting sets simultaneously without an additional
+/// allocation. Generally, once a state set is built, it becomes immutable.
+///
+/// We use this representation because it avoids the overhead of more
+/// traditional set data structures (HashSet/BTreeSet), and also because
+/// computing intersection/subtraction on this representation is especially
+/// fast.
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+struct StateSet {
+    ids: Rc<RefCell<Vec<StateID>>>,
+}
+
+impl<'a> Minimizer<'a> {
+    pub fn new(dfa: &'a mut dense::OwnedDFA) -> Minimizer<'a> {
+        let in_transitions = Minimizer::incoming_transitions(dfa);
+        let partitions = Minimizer::initial_partitions(dfa);
+        let waiting = partitions.clone();
+        Minimizer { dfa, in_transitions, partitions, waiting }
+    }
+
+    pub fn run(mut self) {
+        let stride2 = self.dfa.stride2();
+        let as_state_id = |index: usize| -> StateID {
+            StateID::new(index << stride2).unwrap()
+        };
+        let as_index = |id: StateID| -> usize { id.as_usize() >> stride2 };
+
+        let mut incoming = StateSet::empty();
+        let mut scratch1 = StateSet::empty();
+        let mut scratch2 = StateSet::empty();
+        let mut newparts = vec![];
+
+        // This loop is basically Hopcroft's algorithm. Everything else is just
+        // shuffling data around to fit our representation.
+        while let Some(set) = self.waiting.pop() {
+            for b in self.dfa.byte_classes().iter() {
+                self.find_incoming_to(b, &set, &mut incoming);
+                // If incoming is empty, then the intersection with any other
+                // set must also be empty. So 'newparts' just ends up being
+                // 'self.partitions'. So there's no need to go through the loop
+                // below.
+                //
+                // This actually turns out to be rather large optimization. On
+                // the order of making minimization 4-5x faster. It's likely
+                // that the vast majority of all states have very few incoming
+                // transitions.
+                if incoming.is_empty() {
+                    continue;
+                }
+
+                for p in 0..self.partitions.len() {
+                    self.partitions[p].intersection(&incoming, &mut scratch1);
+                    if scratch1.is_empty() {
+                        newparts.push(self.partitions[p].clone());
+                        continue;
+                    }
+
+                    self.partitions[p].subtract(&incoming, &mut scratch2);
+                    if scratch2.is_empty() {
+                        newparts.push(self.partitions[p].clone());
+                        continue;
+                    }
+
+                    let (x, y) =
+                        (scratch1.deep_clone(), scratch2.deep_clone());
+                    newparts.push(x.clone());
+                    newparts.push(y.clone());
+                    match self.find_waiting(&self.partitions[p]) {
+                        Some(i) => {
+                            self.waiting[i] = x;
+                            self.waiting.push(y);
+                        }
+                        None => {
+                            if x.len() <= y.len() {
+                                self.waiting.push(x);
+                            } else {
+                                self.waiting.push(y);
+                            }
+                        }
+                    }
+                }
+                newparts = mem::replace(&mut self.partitions, newparts);
+                newparts.clear();
+            }
+        }
+
+        // At this point, we now have a minimal partitioning of states, where
+        // each partition is an equivalence class of DFA states. Now we need to
+        // use this partioning to update the DFA to only contain one state for
+        // each partition.
+
+        // Create a map from DFA state ID to the representative ID of the
+        // equivalence class to which it belongs. The representative ID of an
+        // equivalence class of states is the minimum ID in that class.
+        let mut state_to_part = vec![DEAD; self.dfa.state_len()];
+        for p in &self.partitions {
+            p.iter(|id| state_to_part[as_index(id)] = p.min());
+        }
+
+        // Generate a new contiguous sequence of IDs for minimal states, and
+        // create a map from equivalence IDs to the new IDs. Thus, the new
+        // minimal ID of *any* state in the unminimized DFA can be obtained
+        // with minimals_ids[state_to_part[old_id]].
+        let mut minimal_ids = vec![DEAD; self.dfa.state_len()];
+        let mut new_index = 0;
+        for state in self.dfa.states() {
+            if state_to_part[as_index(state.id())] == state.id() {
+                minimal_ids[as_index(state.id())] = as_state_id(new_index);
+                new_index += 1;
+            }
+        }
+        // The total number of states in the minimal DFA.
+        let minimal_count = new_index;
+        // Convenience function for remapping state IDs. This takes an old ID,
+        // looks up its Hopcroft partition and then maps that to the new ID
+        // range.
+        let remap = |old| minimal_ids[as_index(state_to_part[as_index(old)])];
+
+        // Re-map this DFA in place such that the only states remaining
+        // correspond to the representative states of every equivalence class.
+        for id in (0..self.dfa.state_len()).map(as_state_id) {
+            // If this state isn't a representative for an equivalence class,
+            // then we skip it since it won't appear in the minimal DFA.
+            if state_to_part[as_index(id)] != id {
+                continue;
+            }
+            self.dfa.remap_state(id, remap);
+            self.dfa.swap_states(id, minimal_ids[as_index(id)]);
+        }
+        // Trim off all unused states from the pre-minimized DFA. This
+        // represents all states that were merged into a non-singleton
+        // equivalence class of states, and appeared after the first state
+        // in each such class. (Because the state with the smallest ID in each
+        // equivalence class is its representative ID.)
+        self.dfa.truncate_states(minimal_count);
+
+        // Update the new start states, which is now just the minimal ID of
+        // whatever state the old start state was collapsed into. Also, we
+        // collect everything before-hand to work around the borrow checker.
+        // We're already allocating so much that this is probably fine. If this
+        // turns out to be costly, then I guess add a `starts_mut` iterator.
+        let starts: Vec<_> = self.dfa.starts().collect();
+        for (old_start_id, anchored, start_type) in starts {
+            self.dfa.set_start_state(
+                anchored,
+                start_type,
+                remap(old_start_id),
+            );
+        }
+
+        // Update the match state pattern ID list for multi-regexes. All we
+        // need to do is remap the match state IDs. The pattern ID lists are
+        // always the same as they were since match states with distinct
+        // pattern ID lists are always considered distinct states.
+        let mut pmap = BTreeMap::new();
+        for (match_id, pattern_ids) in self.dfa.pattern_map() {
+            let new_id = remap(match_id);
+            pmap.insert(new_id, pattern_ids);
+        }
+        // This unwrap is OK because minimization never increases the number of
+        // match states or patterns in those match states. Since minimization
+        // runs after the pattern map has already been set at least once, we
+        // know that our match states cannot error.
+        self.dfa.set_pattern_map(&pmap).unwrap();
+
+        // In order to update the ID of the maximum match state, we need to
+        // find the maximum ID among all of the match states in the minimized
+        // DFA. This is not necessarily the new ID of the unminimized maximum
+        // match state, since that could have been collapsed with a much
+        // earlier match state. Therefore, to find the new max match state,
+        // we iterate over all previous match states, find their corresponding
+        // new minimal ID, and take the maximum of those.
+        let old = self.dfa.special().clone();
+        let new = self.dfa.special_mut();
+        // ... but only remap if we had match states.
+        if old.matches() {
+            new.min_match = StateID::MAX;
+            new.max_match = StateID::ZERO;
+            for i in as_index(old.min_match)..=as_index(old.max_match) {
+                let new_id = remap(as_state_id(i));
+                if new_id < new.min_match {
+                    new.min_match = new_id;
+                }
+                if new_id > new.max_match {
+                    new.max_match = new_id;
+                }
+            }
+        }
+        // ... same, but for start states.
+        if old.starts() {
+            new.min_start = StateID::MAX;
+            new.max_start = StateID::ZERO;
+            for i in as_index(old.min_start)..=as_index(old.max_start) {
+                let new_id = remap(as_state_id(i));
+                if new_id == DEAD {
+                    continue;
+                }
+                if new_id < new.min_start {
+                    new.min_start = new_id;
+                }
+                if new_id > new.max_start {
+                    new.max_start = new_id;
+                }
+            }
+            if new.max_start == DEAD {
+                new.min_start = DEAD;
+            }
+        }
+        new.quit_id = remap(new.quit_id);
+        new.set_max();
+    }
+
+    fn find_waiting(&self, set: &StateSet) -> Option<usize> {
+        self.waiting.iter().position(|s| s == set)
+    }
+
+    fn find_incoming_to(
+        &self,
+        b: alphabet::Unit,
+        set: &StateSet,
+        incoming: &mut StateSet,
+    ) {
+        incoming.clear();
+        set.iter(|id| {
+            for &inid in
+                &self.in_transitions[self.dfa.to_index(id)][b.as_usize()]
+            {
+                incoming.add(inid);
+            }
+        });
+        incoming.canonicalize();
+    }
+
+    fn initial_partitions(dfa: &dense::OwnedDFA) -> Vec<StateSet> {
+        // For match states, we know that two match states with different
+        // pattern ID lists will *always* be distinct, so we can partition them
+        // initially based on that.
+        let mut matching: BTreeMap<Vec<PatternID>, StateSet> = BTreeMap::new();
+        let mut is_quit = StateSet::empty();
+        let mut no_match = StateSet::empty();
+        for state in dfa.states() {
+            if dfa.is_match_state(state.id()) {
+                let mut pids = vec![];
+                for i in 0..dfa.match_len(state.id()) {
+                    pids.push(dfa.match_pattern(state.id(), i));
+                }
+                matching
+                    .entry(pids)
+                    .or_insert(StateSet::empty())
+                    .add(state.id());
+            } else if dfa.is_quit_state(state.id()) {
+                is_quit.add(state.id());
+            } else {
+                no_match.add(state.id());
+            }
+        }
+
+        let mut sets: Vec<StateSet> =
+            matching.into_iter().map(|(_, set)| set).collect();
+        sets.push(no_match);
+        sets.push(is_quit);
+        sets
+    }
+
+    fn incoming_transitions(dfa: &dense::OwnedDFA) -> Vec<Vec<Vec<StateID>>> {
+        let mut incoming = vec![];
+        for _ in dfa.states() {
+            incoming.push(vec![vec![]; dfa.alphabet_len()]);
+        }
+        for state in dfa.states() {
+            for (b, next) in state.transitions() {
+                incoming[dfa.to_index(next)][b.as_usize()].push(state.id());
+            }
+        }
+        incoming
+    }
+}
+
+impl StateSet {
+    fn empty() -> StateSet {
+        StateSet { ids: Rc::new(RefCell::new(vec![])) }
+    }
+
+    fn add(&mut self, id: StateID) {
+        self.ids.borrow_mut().push(id);
+    }
+
+    fn min(&self) -> StateID {
+        self.ids.borrow()[0]
+    }
+
+    fn canonicalize(&mut self) {
+        self.ids.borrow_mut().sort();
+        self.ids.borrow_mut().dedup();
+    }
+
+    fn clear(&mut self) {
+        self.ids.borrow_mut().clear();
+    }
+
+    fn len(&self) -> usize {
+        self.ids.borrow().len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    fn deep_clone(&self) -> StateSet {
+        let ids = self.ids.borrow().iter().cloned().collect();
+        StateSet { ids: Rc::new(RefCell::new(ids)) }
+    }
+
+    fn iter<F: FnMut(StateID)>(&self, mut f: F) {
+        for &id in self.ids.borrow().iter() {
+            f(id);
+        }
+    }
+
+    fn intersection(&self, other: &StateSet, dest: &mut StateSet) {
+        dest.clear();
+        if self.is_empty() || other.is_empty() {
+            return;
+        }
+
+        let (seta, setb) = (self.ids.borrow(), other.ids.borrow());
+        let (mut ita, mut itb) = (seta.iter().cloned(), setb.iter().cloned());
+        let (mut a, mut b) = (ita.next().unwrap(), itb.next().unwrap());
+        loop {
+            if a == b {
+                dest.add(a);
+                a = match ita.next() {
+                    None => break,
+                    Some(a) => a,
+                };
+                b = match itb.next() {
+                    None => break,
+                    Some(b) => b,
+                };
+            } else if a < b {
+                a = match ita.next() {
+                    None => break,
+                    Some(a) => a,
+                };
+            } else {
+                b = match itb.next() {
+                    None => break,
+                    Some(b) => b,
+                };
+            }
+        }
+    }
+
+    fn subtract(&self, other: &StateSet, dest: &mut StateSet) {
+        dest.clear();
+        if self.is_empty() || other.is_empty() {
+            self.iter(|s| dest.add(s));
+            return;
+        }
+
+        let (seta, setb) = (self.ids.borrow(), other.ids.borrow());
+        let (mut ita, mut itb) = (seta.iter().cloned(), setb.iter().cloned());
+        let (mut a, mut b) = (ita.next().unwrap(), itb.next().unwrap());
+        loop {
+            if a == b {
+                a = match ita.next() {
+                    None => break,
+                    Some(a) => a,
+                };
+                b = match itb.next() {
+                    None => {
+                        dest.add(a);
+                        break;
+                    }
+                    Some(b) => b,
+                };
+            } else if a < b {
+                dest.add(a);
+                a = match ita.next() {
+                    None => break,
+                    Some(a) => a,
+                };
+            } else {
+                b = match itb.next() {
+                    None => {
+                        dest.add(a);
+                        break;
+                    }
+                    Some(b) => b,
+                };
+            }
+        }
+        for a in ita {
+            dest.add(a);
+        }
+    }
+}
diff --git a/regex-automata/src/dfa/mod.rs b/regex-automata/src/dfa/mod.rs
new file mode 100644
index 0000000000..c289567d05
--- /dev/null
+++ b/regex-automata/src/dfa/mod.rs
@@ -0,0 +1,360 @@
+/*!
+A module for building and searching with determinstic finite automata (DFAs).
+
+Like other modules in this crate, DFAs support a rich regex syntax with Unicode
+features. DFAs also have extensive options for configuring the best space vs
+time trade off for your use case and provides support for cheap deserialization
+of automata for use in `no_std` environments.
+
+If you're looking for lazy DFAs that build themselves incrementally during
+search, then please see the top-level [`hybrid` module](crate::hybrid).
+
+# Overview
+
+This section gives a brief overview of the primary types in this module:
+
+* A [`regex::Regex`] provides a way to search for matches of a regular
+expression using DFAs. This includes iterating over matches with both the start
+and end positions of each match.
+* A [`dense::DFA`] provides low level access to a DFA that uses a dense
+representation (uses lots of space, but fast searching).
+* A [`sparse::DFA`] provides the same API as a `dense::DFA`, but uses a sparse
+representation (uses less space, but slower searching).
+* An [`Automaton`] trait that defines an interface that both dense and sparse
+DFAs implement. (A `regex::Regex` is generic over this trait.)
+* Both dense DFAs and sparse DFAs support serialization to raw bytes (e.g.,
+[`dense::DFA::to_bytes_little_endian`]) and cheap deserialization (e.g.,
+[`dense::DFA::from_bytes`]).
+
+There is also a [`onepass`] module that provides a [one-pass
+DFA](onepass::DFA). The unique advantage of this DFA is that, for the class
+of regexes it can be built with, it supports reporting the spans of matching
+capturing groups. It is the only DFA in this crate capable of such a thing.
+
+# Example: basic regex searching
+
+This example shows how to compile a regex using the default configuration
+and then use it to find matches in a byte string:
+
+```
+use regex_automata::{Match, dfa::regex::Regex};
+
+let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+let text = b"2018-12-24 2016-10-08";
+let matches: Vec<Match> = re.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Example: searching with regex sets
+
+The DFAs in this module all fully support searching with multiple regexes
+simultaneously. You can use this support with standard leftmost-first style
+searching to find non-overlapping matches:
+
+```
+# if cfg!(miri) { return Ok(()); } // miri takes too long
+use regex_automata::{Match, dfa::regex::Regex};
+
+let re = Regex::new_many(&[r"\w+", r"\S+"])?;
+let text = b"@foo bar";
+let matches: Vec<Match> = re.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(1, 0..4),
+    Match::must(0, 5..8),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Example: use sparse DFAs
+
+By default, compiling a regex will use dense DFAs internally. This uses more
+memory, but executes searches more quickly. If you can abide slower searches
+(somewhere around 3-5x), then sparse DFAs might make more sense since they can
+use significantly less space.
+
+Using sparse DFAs is as easy as using `Regex::new_sparse` instead of
+`Regex::new`:
+
+```
+use regex_automata::{Match, dfa::regex::Regex};
+
+let re = Regex::new_sparse(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
+let text = b"2018-12-24 2016-10-08";
+let matches: Vec<Match> = re.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+If you already have dense DFAs for some reason, they can be converted to sparse
+DFAs and used to build a new `Regex`. For example:
+
+```
+use regex_automata::{Match, dfa::regex::Regex};
+
+let dense_re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
+let sparse_re = Regex::builder().build_from_dfas(
+    dense_re.forward().to_sparse()?,
+    dense_re.reverse().to_sparse()?,
+);
+let text = b"2018-12-24 2016-10-08";
+let matches: Vec<Match> = sparse_re.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Example: deserialize a DFA
+
+This shows how to first serialize a DFA into raw bytes, and then deserialize
+those raw bytes back into a DFA. While this particular example is a
+bit contrived, this same technique can be used in your program to
+deserialize a DFA at start up time or by memory mapping a file.
+
+```
+use regex_automata::{Match, dfa::{dense, regex::Regex}};
+
+let re1 = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
+// serialize both the forward and reverse DFAs, see note below
+let (fwd_bytes, fwd_pad) = re1.forward().to_bytes_native_endian();
+let (rev_bytes, rev_pad) = re1.reverse().to_bytes_native_endian();
+// now deserialize both---we need to specify the correct type!
+let fwd: dense::DFA<&[u32]> = dense::DFA::from_bytes(&fwd_bytes[fwd_pad..])?.0;
+let rev: dense::DFA<&[u32]> = dense::DFA::from_bytes(&rev_bytes[rev_pad..])?.0;
+// finally, reconstruct our regex
+let re2 = Regex::builder().build_from_dfas(fwd, rev);
+
+// we can use it like normal
+let text = b"2018-12-24 2016-10-08";
+let matches: Vec<Match> = re2.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+There are a few points worth noting here:
+
+* We need to extract the raw DFAs used by the regex and serialize those. You
+can build the DFAs manually yourself using [`dense::Builder`], but using
+the DFAs from a `Regex` guarantees that the DFAs are built correctly. (In
+particular, a `Regex` constructs a reverse DFA for finding the starting
+location of matches.)
+* To convert the DFA to raw bytes, we use the `to_bytes_native_endian` method.
+In practice, you'll want to use either [`dense::DFA::to_bytes_little_endian`]
+or [`dense::DFA::to_bytes_big_endian`], depending on which platform you're
+deserializing your DFA from. If you intend to deserialize on either platform,
+then you'll need to serialize both and deserialize the right one depending on
+your target's endianness.
+* Safely deserializing a DFA requires verifying the raw bytes, particularly if
+they are untrusted, since an invalid DFA could cause logical errors, panics
+or even undefined behavior. This verification step requires visiting all of
+the transitions in the DFA, which can be costly. If cheaper verification is
+desired, then [`dense::DFA::from_bytes_unchecked`] is available that only does
+verification that can be performed in constant time. However, one can only use
+this routine if the caller can guarantee that the bytes provided encoded a
+valid DFA.
+
+The same process can be achieved with sparse DFAs as well:
+
+```
+use regex_automata::{Match, dfa::{sparse, regex::Regex}};
+
+let re1 = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
+// serialize both
+let fwd_bytes = re1.forward().to_sparse()?.to_bytes_native_endian();
+let rev_bytes = re1.reverse().to_sparse()?.to_bytes_native_endian();
+// now deserialize both---we need to specify the correct type!
+let fwd: sparse::DFA<&[u8]> = sparse::DFA::from_bytes(&fwd_bytes)?.0;
+let rev: sparse::DFA<&[u8]> = sparse::DFA::from_bytes(&rev_bytes)?.0;
+// finally, reconstruct our regex
+let re2 = Regex::builder().build_from_dfas(fwd, rev);
+
+// we can use it like normal
+let text = b"2018-12-24 2016-10-08";
+let matches: Vec<Match> = re2.find_iter(text).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+Note that unlike dense DFAs, sparse DFAs have no alignment requirements.
+Conversely, dense DFAs must be be aligned to the same alignment as a
+[`StateID`](crate::util::primitives::StateID).
+
+# Support for `no_std` and `alloc`-only
+
+This crate comes with `alloc` and `std` features that are enabled by default.
+When the `alloc` or `std` features are enabled, the API of this module will
+include the facilities necessary for compiling, serializing, deserializing
+and searching with DFAs. When only the `alloc` feature is enabled, then
+implementations of the `std::error::Error` trait are dropped, but everything
+else generally remains the same. When both the `alloc` and `std` features are
+disabled, the API of this module will shrink such that it only includes the
+facilities necessary for deserializing and searching with DFAs.
+
+The intended workflow for `no_std` environments is thus as follows:
+
+* Write a program with the `alloc` or `std` features that compiles and
+serializes a regular expression. You may need to serialize both little and big
+endian versions of each DFA. (So that's 4 DFAs in total for each regex.)
+* In your `no_std` environment, follow the examples above for deserializing
+your previously serialized DFAs into regexes. You can then search with them as
+you would any regex.
+
+Deserialization can happen anywhere. For example, with bytes embedded into a
+binary or with a file memory mapped at runtime.
+
+The `regex-cli` command (found in the same repository as this crate) can be
+used to serialize DFAs to files and generate Rust code to read them.
+
+# Syntax
+
+This module supports the same syntax as the `regex` crate, since they share the
+same parser. You can find an exhaustive list of supported syntax in the
+[documentation for the `regex` crate](https://docs.rs/regex/1/regex/#syntax).
+
+There are two things that are not supported by the DFAs in this module:
+
+* Capturing groups. The DFAs (and [`Regex`](regex::Regex)es built on top
+of them) can only find the offsets of an entire match, but cannot resolve
+the offsets of each capturing group. This is because DFAs do not have the
+expressive power necessary.
+* Unicode word boundaries. These present particularly difficult challenges for
+DFA construction and would result in an explosion in the number of states.
+One can enable [`dense::Config::unicode_word_boundary`] though, which provides
+heuristic support for Unicode word boundaries that only works on ASCII text.
+Otherwise, one can use `(?-u:\b)` for an ASCII word boundary, which will work
+on any input.
+
+There are no plans to lift either of these limitations.
+
+Note that these restrictions are identical to the restrictions on lazy DFAs.
+
+# Differences with general purpose regexes
+
+The main goal of the [`regex`](https://docs.rs/regex) crate is to serve as a
+general purpose regular expression engine. It aims to automatically balance low
+compile times, fast search times and low memory usage, while also providing
+a convenient API for users. In contrast, this module provides a lower level
+regular expression interface based exclusively on DFAs that is a bit less
+convenient while providing more explicit control over memory usage and search
+times.
+
+Here are some specific negative differences:
+
+* **Compilation can take an exponential amount of time and space** in the size
+of the regex pattern. While most patterns do not exhibit worst case exponential
+time, such patterns do exist. For example, `[01]*1[01]{N}` will build a DFA
+with approximately `2^(N+2)` states. For this reason, untrusted patterns should
+not be compiled with this module. (In the future, the API may expose an option
+to return an error if the DFA gets too big.)
+* This module does not support sub-match extraction via capturing groups, which
+can be achieved with the regex crate's "captures" API.
+* While the regex crate doesn't necessarily sport fast compilation times,
+the regexes in this module are almost universally slow to compile, especially
+when they contain large Unicode character classes. For example, on my system,
+compiling `\w{50}` takes about 1 second and almost 15MB of memory! (Compiling
+a sparse regex takes about the same time but only uses about 1.2MB of
+memory.) Conversly, compiling the same regex without Unicode support, e.g.,
+`(?-u)\w{50}`, takes under 1 millisecond and about 15KB of memory. For this
+reason, you should only use Unicode character classes if you absolutely need
+them! (They are enabled by default though.)
+* This module does not support Unicode word boundaries. ASCII word bondaries
+may be used though by disabling Unicode or selectively doing so in the syntax,
+e.g., `(?-u:\b)`. There is also an option to
+[heuristically enable Unicode word boundaries](crate::dfa::dense::Config::unicode_word_boundary),
+where the corresponding DFA will give up if any non-ASCII byte is seen.
+* As a lower level API, this module does not do literal optimizations
+automatically. Although it does provide hooks in its API to make use of the
+[`Prefilter`](crate::util::prefilter::Prefilter) trait. Missing literal
+optimizations means that searches may run much slower than what you're
+accustomed to, although, it does provide more predictable and consistent
+performance.
+* There is no `&str` API like in the regex crate. In this module, all APIs
+operate on `&[u8]`. By default, match indices are
+guaranteed to fall on UTF-8 boundaries, unless either of
+[`syntax::Config::utf8`](crate::util::syntax::Config::utf8) or
+[`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) are disabled.
+
+With some of the downsides out of the way, here are some positive differences:
+
+* Both dense and sparse DFAs can be serialized to raw bytes, and then cheaply
+deserialized. Deserialization can be done in constant time with the unchecked
+APIs, since searching can be performed directly on the raw serialized bytes of
+a DFA.
+* This module was specifically designed so that the searching phase of a
+DFA has minimal runtime requirements, and can therefore be used in `no_std`
+environments. While `no_std` environments cannot compile regexes, they can
+deserialize pre-compiled regexes.
+* Since this module builds DFAs ahead of time, it will generally out-perform
+the `regex` crate on equivalent tasks. The performance difference is likely
+not large. However, because of a complex set of optimizations in the regex
+crate (like literal optimizations), an accurate performance comparison may be
+difficult to do.
+* Sparse DFAs provide a way to build a DFA ahead of time that sacrifices search
+performance a small amount, but uses much less storage space. Potentially even
+less than what the regex crate uses.
+* This module exposes DFAs directly, such as [`dense::DFA`] and
+[`sparse::DFA`], which enables one to do less work in some cases. For example,
+if you only need the end of a match and not the start of a match, then you can
+use a DFA directly without building a `Regex`, which always requires a second
+DFA to find the start of a match.
+* This module provides more control over memory usage. Aside from choosing
+between dense and sparse DFAs, one can also choose a smaller state identifier
+representation to use less space. Also, one can enable DFA minimization
+via [`dense::Config::minimize`], but it can increase compilation times
+dramatically.
+*/
+
+#[cfg(feature = "dfa-search")]
+pub use crate::dfa::{
+    automaton::{Automaton, OverlappingState},
+    start::StartKind,
+};
+
+/// This is an alias for a state ID of zero. It has special significance
+/// because it always corresponds to the first state in a DFA, and the first
+/// state in a DFA is always "dead." That is, the dead state always has all
+/// of its transitions set to itself. Moreover, the dead state is used as a
+/// sentinel for various things. e.g., In search, reaching a dead state means
+/// that the search must stop.
+const DEAD: crate::util::primitives::StateID =
+    crate::util::primitives::StateID::ZERO;
+
+#[cfg(feature = "dfa-search")]
+pub mod dense;
+#[cfg(feature = "dfa-onepass")]
+pub mod onepass;
+#[cfg(feature = "dfa-search")]
+pub mod regex;
+#[cfg(feature = "dfa-search")]
+pub mod sparse;
+
+#[cfg(feature = "dfa-search")]
+pub(crate) mod accel;
+#[cfg(feature = "dfa-search")]
+mod automaton;
+#[cfg(feature = "dfa-build")]
+mod determinize;
+#[cfg(feature = "dfa-build")]
+mod minimize;
+#[cfg(any(feature = "dfa-build", feature = "dfa-onepass"))]
+mod remapper;
+#[cfg(feature = "dfa-search")]
+mod search;
+#[cfg(feature = "dfa-search")]
+mod special;
+#[cfg(feature = "dfa-search")]
+mod start;
diff --git a/regex-automata/src/dfa/onepass.rs b/regex-automata/src/dfa/onepass.rs
new file mode 100644
index 0000000000..44691d0c8a
--- /dev/null
+++ b/regex-automata/src/dfa/onepass.rs
@@ -0,0 +1,3188 @@
+/*!
+A DFA that can return spans for matching capturing groups.
+
+This module is the home of a [one-pass DFA](DFA).
+
+This module also contains a [`Builder`] and a [`Config`] for building and
+configuring a one-pass DFA.
+*/
+
+// A note on naming and credit:
+//
+// As far as I know, Russ Cox came up with the practical vision and
+// implementation of a "one-pass regex engine." He mentions and describes it
+// briefly in the third article of his regexp article series:
+// https://swtch.com/~rsc/regexp/regexp3.html
+//
+// Cox's implementation is in RE2, and the implementation below is most
+// heavily inspired by RE2's. The key thing they have in common is that
+// their transitions are defined over an alphabet of bytes. In contrast,
+// Go's regex engine also has a one-pass engine, but its transitions are
+// more firmly rooted on Unicode codepoints. The ideas are the same, but the
+// implementations are different.
+//
+// RE2 tends to call this a "one-pass NFA." Here, we call it a "one-pass DFA."
+// They're both true in their own ways:
+//
+// * The "one-pass" criterion is generally a property of the NFA itself. In
+// particular, it is said that an NFA is one-pass if, after each byte of input
+// during a search, there is at most one "VM thread" remaining to take for the
+// next byte of input. That is, there is never any ambiguity as to the path to
+// take through the NFA during a search.
+//
+// * On the other hand, once a one-pass NFA has its representation converted
+// to something where a constant number of instructions is used for each byte
+// of input, the implementation looks a lot more like a DFA. It's technically
+// more powerful than a DFA since it has side effects (storing offsets inside
+// of slots activated by a transition), but it is far closer to a DFA than an
+// NFA simulation.
+//
+// Thus, in this crate, we call it a one-pass DFA.
+
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    dfa::{remapper::Remapper, DEAD},
+    nfa::thompson::{self, NFA},
+    util::{
+        alphabet::ByteClasses,
+        captures::Captures,
+        escape::DebugByte,
+        int::{Usize, U32, U64, U8},
+        look::{Look, LookSet, UnicodeWordBoundaryError},
+        primitives::{NonMaxUsize, PatternID, StateID},
+        search::{Anchored, Input, Match, MatchError, MatchKind, Span},
+        sparse_set::SparseSet,
+    },
+};
+
+/// The configuration used for building a [one-pass DFA](DFA).
+///
+/// A one-pass DFA configuration is a simple data object that is typically used
+/// with [`Builder::configure`]. It can be cheaply cloned.
+///
+/// A default configuration can be created either with `Config::new`, or
+/// perhaps more conveniently, with [`DFA::config`].
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    match_kind: Option<MatchKind>,
+    starts_for_each_pattern: Option<bool>,
+    byte_classes: Option<bool>,
+    size_limit: Option<Option<usize>>,
+}
+
+impl Config {
+    /// Return a new default one-pass DFA configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Set the desired match semantics.
+    ///
+    /// The default is [`MatchKind::LeftmostFirst`], which corresponds to the
+    /// match semantics of Perl-like regex engines. That is, when multiple
+    /// patterns would match at the same leftmost position, the pattern that
+    /// appears first in the concrete syntax is chosen.
+    ///
+    /// Currently, the only other kind of match semantics supported is
+    /// [`MatchKind::All`]. This corresponds to "classical DFA" construction
+    /// where all possible matches are visited.
+    ///
+    /// When it comes to the one-pass DFA, it is rarer for preference order and
+    /// "longest match" to actually disagree. Since if they did disagree, then
+    /// the regex typically isn't one-pass. For example, searching `Samwise`
+    /// for `Sam|Samwise` will report `Sam` for leftmost-first matching and
+    /// `Samwise` for "longest match" or "all" matching. However, this regex is
+    /// not one-pass if taken literally. The equivalent regex, `Sam(?:|wise)`
+    /// is one-pass and `Sam|Samwise` may be optimized to it.
+    ///
+    /// The other main difference is that "all" match semantics don't support
+    /// non-greedy matches. "All" match semantics always try to match as much
+    /// as possible.
+    pub fn match_kind(mut self, kind: MatchKind) -> Config {
+        self.match_kind = Some(kind);
+        self
+    }
+
+    /// Whether to compile a separate start state for each pattern in the
+    /// one-pass DFA.
+    ///
+    /// When enabled, a separate **anchored** start state is added for each
+    /// pattern in the DFA. When this start state is used, then the DFA will
+    /// only search for matches for the pattern specified, even if there are
+    /// other patterns in the DFA.
+    ///
+    /// The main downside of this option is that it can potentially increase
+    /// the size of the DFA and/or increase the time it takes to build the DFA.
+    ///
+    /// You might want to enable this option when you want to both search for
+    /// anchored matches of any pattern or to search for anchored matches of
+    /// one particular pattern while using the same DFA. (Otherwise, you would
+    /// need to compile a new DFA for each pattern.)
+    ///
+    /// By default this is disabled.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a multi-regex and then search for
+    /// matches for a any of the patterns or matches for a specific pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::onepass::DFA, Anchored, Input, Match, PatternID,
+    /// };
+    ///
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().starts_for_each_pattern(true))
+    ///     .build_many(&["[a-z]+", "[0-9]+"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "123abc";
+    /// let input = Input::new(haystack).anchored(Anchored::Yes);
+    ///
+    /// // A normal multi-pattern search will show pattern 1 matches.
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(Some(Match::must(1, 0..3)), caps.get_match());
+    ///
+    /// // If we only want to report pattern 0 matches, then we'll get no
+    /// // match here.
+    /// let input = input.anchored(Anchored::Pattern(PatternID::must(0)));
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn starts_for_each_pattern(mut self, yes: bool) -> Config {
+        self.starts_for_each_pattern = Some(yes);
+        self
+    }
+
+    /// Whether to attempt to shrink the size of the DFA's alphabet or not.
+    ///
+    /// This option is enabled by default and should never be disabled unless
+    /// one is debugging a one-pass DFA.
+    ///
+    /// When enabled, the DFA will use a map from all possible bytes to their
+    /// corresponding equivalence class. Each equivalence class represents a
+    /// set of bytes that does not discriminate between a match and a non-match
+    /// in the DFA. For example, the pattern `[ab]+` has at least two
+    /// equivalence classes: a set containing `a` and `b` and a set containing
+    /// every byte except for `a` and `b`. `a` and `b` are in the same
+    /// equivalence class because they never discriminate between a match and a
+    /// non-match.
+    ///
+    /// The advantage of this map is that the size of the transition table
+    /// can be reduced drastically from (approximately) `#states * 256 *
+    /// sizeof(StateID)` to `#states * k * sizeof(StateID)` where `k` is the
+    /// number of equivalence classes (rounded up to the nearest power of 2).
+    /// As a result, total space usage can decrease substantially. Moreover,
+    /// since a smaller alphabet is used, DFA compilation becomes faster as
+    /// well.
+    ///
+    /// **WARNING:** This is only useful for debugging DFAs. Disabling this
+    /// does not yield any speed advantages. Namely, even when this is
+    /// disabled, a byte class map is still used while searching. The only
+    /// difference is that every byte will be forced into its own distinct
+    /// equivalence class. This is useful for debugging the actual generated
+    /// transitions because it lets one see the transitions defined on actual
+    /// bytes instead of the equivalence classes.
+    pub fn byte_classes(mut self, yes: bool) -> Config {
+        self.byte_classes = Some(yes);
+        self
+    }
+
+    /// Set a size limit on the total heap used by a one-pass DFA.
+    ///
+    /// This size limit is expressed in bytes and is applied during
+    /// construction of a one-pass DFA. If the DFA's heap usage exceeds
+    /// this configured limit, then construction is stopped and an error is
+    /// returned.
+    ///
+    /// The default is no limit.
+    ///
+    /// # Example
+    ///
+    /// This example shows a one-pass DFA that fails to build because of
+    /// a configured size limit. This particular example also serves as a
+    /// cautionary tale demonstrating just how big DFAs with large Unicode
+    /// character classes can get.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// // 6MB isn't enough!
+    /// DFA::builder()
+    ///     .configure(DFA::config().size_limit(Some(6_000_000)))
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 7MB probably is!
+    /// // (Note that DFA sizes aren't necessarily stable between releases.)
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().size_limit(Some(7_000_000)))
+    ///     .build(r"\w{20}")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "A".repeat(20);
+    /// re.captures(&mut cache, &haystack, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..20)), caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// While one needs a little more than 3MB to represent `\w{20}`, it
+    /// turns out that you only need a little more than 4KB to represent
+    /// `(?-u:\w{20})`. So only use Unicode if you need it!
+    pub fn size_limit(mut self, limit: Option<usize>) -> Config {
+        self.size_limit = Some(limit);
+        self
+    }
+
+    /// Returns the match semantics set in this configuration.
+    pub fn get_match_kind(&self) -> MatchKind {
+        self.match_kind.unwrap_or(MatchKind::LeftmostFirst)
+    }
+
+    /// Returns whether this configuration has enabled anchored starting states
+    /// for every pattern in the DFA.
+    pub fn get_starts_for_each_pattern(&self) -> bool {
+        self.starts_for_each_pattern.unwrap_or(false)
+    }
+
+    /// Returns whether this configuration has enabled byte classes or not.
+    /// This is typically a debugging oriented option, as disabling it confers
+    /// no speed benefit.
+    pub fn get_byte_classes(&self) -> bool {
+        self.byte_classes.unwrap_or(true)
+    }
+
+    /// Returns the DFA size limit of this configuration if one was set.
+    /// The size limit is total number of bytes on the heap that a DFA is
+    /// permitted to use. If the DFA exceeds this limit during construction,
+    /// then construction is stopped and an error is returned.
+    pub fn get_size_limit(&self) -> Option<usize> {
+        self.size_limit.unwrap_or(None)
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            match_kind: o.match_kind.or(self.match_kind),
+            starts_for_each_pattern: o
+                .starts_for_each_pattern
+                .or(self.starts_for_each_pattern),
+            byte_classes: o.byte_classes.or(self.byte_classes),
+            size_limit: o.size_limit.or(self.size_limit),
+        }
+    }
+}
+
+/// A builder for a [one-pass DFA](DFA).
+///
+/// This builder permits configuring options for the syntax of a pattern, the
+/// NFA construction and the DFA construction. This builder is different from a
+/// general purpose regex builder in that it permits fine grain configuration
+/// of the construction process. The trade off for this is complexity, and
+/// the possibility of setting a configuration that might not make sense. For
+/// example, there are two different UTF-8 modes:
+///
+/// * [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) controls
+/// whether the pattern itself can contain sub-expressions that match invalid
+/// UTF-8.
+/// * [`thompson::Config::utf8`] controls whether empty matches that split a
+/// Unicode codepoint are reported or not.
+///
+/// Generally speaking, callers will want to either enable all of these or
+/// disable all of these.
+///
+/// # Example
+///
+/// This example shows how to disable UTF-8 mode in the syntax and the NFA.
+/// This is generally what you want for matching on arbitrary bytes.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     dfa::onepass::DFA,
+///     nfa::thompson,
+///     util::syntax,
+///     Match,
+/// };
+///
+/// let re = DFA::builder()
+///     .syntax(syntax::Config::new().utf8(false))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .build(r"foo(?-u:[^b])ar.*")?;
+/// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+///
+/// let haystack = b"foo\xFFarzz\xE2\x98\xFF\n";
+/// re.captures(&mut cache, haystack, &mut caps);
+/// // Notice that `(?-u:[^b])` matches invalid UTF-8,
+/// // but the subsequent `.*` does not! Disabling UTF-8
+/// // on the syntax permits this.
+/// //
+/// // N.B. This example does not show the impact of
+/// // disabling UTF-8 mode on a one-pass DFA Config,
+/// //  since that only impacts regexes that can
+/// // produce matches of length 0.
+/// assert_eq!(Some(Match::must(0, 0..8)), caps.get_match());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    #[cfg(feature = "syntax")]
+    thompson: thompson::Compiler,
+}
+
+impl Builder {
+    /// Create a new one-pass DFA builder with the default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            #[cfg(feature = "syntax")]
+            thompson: thompson::Compiler::new(),
+        }
+    }
+
+    /// Build a one-pass DFA from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(&self, pattern: &str) -> Result<DFA, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a one-pass DFA from the given patterns.
+    ///
+    /// When matches are returned, the pattern ID corresponds to the index of
+    /// the pattern in the slice given.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<DFA, BuildError> {
+        let nfa =
+            self.thompson.build_many(patterns).map_err(BuildError::nfa)?;
+        self.build_from_nfa(nfa)
+    }
+
+    /// Build a DFA from the given NFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a DFA if you already have an NFA in
+    /// hand.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, nfa::thompson::NFA, Match};
+    ///
+    /// // This shows how to set non-default options for building an NFA.
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().shrink(true))
+    ///     .build(r"[a-z0-9]+")?;
+    /// let re = DFA::builder().build_from_nfa(nfa)?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// re.captures(&mut cache, "foo123bar", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..9)), caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_nfa(&self, nfa: NFA) -> Result<DFA, BuildError> {
+        // Why take ownership if we're just going to pass a reference to the
+        // NFA to our internal builder? Well, the first thing to note is that
+        // an NFA uses reference counting internally, so either choice is going
+        // to be cheap. So there isn't much cost either way.
+        //
+        // The real reason is that a one-pass DFA, semantically, shares
+        // ownership of an NFA. This is unlike other DFAs that don't share
+        // ownership of an NFA at all, primarily because they want to be
+        // self-contained in order to support cheap (de)serialization.
+        //
+        // But then why pass a '&nfa' below if we want to share ownership?
+        // Well, it turns out that using a '&NFA' in our internal builder
+        // separates its lifetime from the DFA we're building, and this turns
+        // out to make code a bit more composable. e.g., We can iterate over
+        // things inside the NFA while borrowing the builder as mutable because
+        // we know the NFA cannot be mutated. So TL;DR --- this weirdness is
+        // "because borrow checker."
+        InternalBuilder::new(self.config.clone(), &nfa).build()
+    }
+
+    /// Apply the given one-pass DFA configuration options to this builder.
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// These settings only apply when constructing a one-pass DFA directly
+    /// from a pattern.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.thompson.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like whether additional time should be
+    /// spent shrinking the size of the NFA.
+    ///
+    /// These settings only apply when constructing a DFA directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.thompson.configure(config);
+        self
+    }
+}
+
+/// An internal builder for encapsulating the state necessary to build a
+/// one-pass DFA. Typical use is just `InternalBuilder::new(..).build()`.
+///
+/// There is no separate pass for determining whether the NFA is one-pass or
+/// not. We just try to build the DFA. If during construction we discover that
+/// it is not one-pass, we bail out. This is likely to lead to some undesirable
+/// expense in some cases, so it might make sense to try an identify common
+/// patterns in the NFA that make it definitively not one-pass. That way, we
+/// can avoid ever trying to build a one-pass DFA in the first place. For
+/// example, '\w*\s' is not one-pass, and since '\w' is Unicode-aware by
+/// default, it's probably not a trivial cost to try and build a one-pass DFA
+/// for it and then fail.
+///
+/// Note that some (immutable) fields are duplicated here. For example, the
+/// 'nfa' and 'classes' fields are both in the 'DFA'. They are the same thing,
+/// but we duplicate them because it makes composition easier below. Otherwise,
+/// since the borrow checker can't see through method calls, the mutable borrow
+/// we use to mutate the DFA winds up preventing borrowing from any other part
+/// of the DFA, even though we aren't mutating those parts. We only do this
+/// because the duplication is cheap.
+#[derive(Debug)]
+struct InternalBuilder<'a> {
+    /// The DFA we're building.
+    dfa: DFA,
+    /// An unordered collection of NFA state IDs that we haven't yet tried to
+    /// build into a DFA state yet.
+    ///
+    /// This collection does not ultimately wind up including every NFA state
+    /// ID. Instead, each ID represents a "start" state for a sub-graph of the
+    /// NFA. The set of NFA states we then use to build a DFA state consists
+    /// of that "start" state and all states reachable from it via epsilon
+    /// transitions.
+    uncompiled_nfa_ids: Vec<StateID>,
+    /// A map from NFA state ID to DFA state ID. This is useful for easily
+    /// determining whether an NFA state has been used as a "starting" point
+    /// to build a DFA state yet. If it hasn't, then it is mapped to DEAD,
+    /// and since DEAD is specially added and never corresponds to any NFA
+    /// state, it follows that a mapping to DEAD implies the NFA state has
+    /// no corresponding DFA state yet.
+    nfa_to_dfa_id: Vec<StateID>,
+    /// A stack used to traverse the NFA states that make up a single DFA
+    /// state. Traversal occurs until the stack is empty, and we only push to
+    /// the stack when the state ID isn't in 'seen'. Actually, even more than
+    /// that, if we try to push something on to this stack that is already in
+    /// 'seen', then we bail out on construction completely, since it implies
+    /// that the NFA is not one-pass.
+    stack: Vec<(StateID, Epsilons)>,
+    /// The set of NFA states that we've visited via 'stack'.
+    seen: SparseSet,
+    /// Whether a match NFA state has been observed while constructing a
+    /// one-pass DFA state. Once a match state is seen, assuming we are using
+    /// leftmost-first match semantics, then we don't add any more transitions
+    /// to the DFA state we're building.
+    matched: bool,
+    /// The config passed to the builder.
+    ///
+    /// This is duplicated in dfa.config.
+    config: Config,
+    /// The NFA we're building a one-pass DFA from.
+    ///
+    /// This is duplicated in dfa.nfa.
+    nfa: &'a NFA,
+    /// The equivalence classes that make up the alphabet for this DFA>
+    ///
+    /// This is duplicated in dfa.classes.
+    classes: ByteClasses,
+}
+
+impl<'a> InternalBuilder<'a> {
+    /// Create a new builder with an initial empty DFA.
+    fn new(config: Config, nfa: &'a NFA) -> InternalBuilder {
+        let classes = if !config.get_byte_classes() {
+            // A one-pass DFA will always use the equivalence class map, but
+            // enabling this option is useful for debugging. Namely, this will
+            // cause all transitions to be defined over their actual bytes
+            // instead of an opaque equivalence class identifier. The former is
+            // much easier to grok as a human.
+            ByteClasses::singletons()
+        } else {
+            nfa.byte_classes().clone()
+        };
+        // Normally a DFA alphabet includes the EOI symbol, but we don't need
+        // that in the one-pass DFA since we handle look-around explicitly
+        // without encoding it into the DFA. Thus, we don't need to delay
+        // matches by 1 byte. However, we reuse the space that *would* be used
+        // by the EOI transition by putting match information there (like which
+        // pattern matches and which look-around assertions need to hold). So
+        // this means our real alphabet length is 1 fewer than what the byte
+        // classes report, since we don't use EOI.
+        let alphabet_len = classes.alphabet_len().checked_sub(1).unwrap();
+        let stride2 = classes.stride2();
+        let dfa = DFA {
+            config: config.clone(),
+            nfa: nfa.clone(),
+            table: vec![],
+            starts: vec![],
+            // Since one-pass DFAs have a smaller state ID max than
+            // StateID::MAX, it follows that StateID::MAX is a valid initial
+            // value for min_match_id since no state ID can ever be greater
+            // than it. In the case of a one-pass DFA with no match states, the
+            // min_match_id will keep this sentinel value.
+            min_match_id: StateID::MAX,
+            classes: classes.clone(),
+            alphabet_len,
+            stride2,
+            pateps_offset: alphabet_len,
+            // OK because PatternID::MAX*2 is guaranteed not to overflow.
+            explicit_slot_start: nfa.pattern_len().checked_mul(2).unwrap(),
+        };
+        InternalBuilder {
+            dfa,
+            uncompiled_nfa_ids: vec![],
+            nfa_to_dfa_id: vec![DEAD; nfa.states().len()],
+            stack: vec![],
+            seen: SparseSet::new(nfa.states().len()),
+            matched: false,
+            config,
+            nfa,
+            classes,
+        }
+    }
+
+    /// Build the DFA from the NFA given to this builder. If the NFA is not
+    /// one-pass, then return an error. An error may also be returned if a
+    /// particular limit is exceeded. (Some limits, like the total heap memory
+    /// used, are configurable. Others, like the total patterns or slots, are
+    /// hard-coded based on representational limitations.)
+    fn build(mut self) -> Result<DFA, BuildError> {
+        self.nfa.look_set_any().available().map_err(BuildError::word)?;
+        for look in self.nfa.look_set_any().iter() {
+            // This is a future incompatibility check where if we add any
+            // more look-around assertions, then the one-pass DFA either
+            // needs to reject them (what we do here) or it needs to have its
+            // Transition representation modified to be capable of storing the
+            // new assertions.
+            if look.as_repr() > Look::WordUnicodeNegate.as_repr() {
+                return Err(BuildError::unsupported_look(look));
+            }
+        }
+        if self.nfa.pattern_len().as_u64() > PatternEpsilons::PATTERN_ID_LIMIT
+        {
+            return Err(BuildError::too_many_patterns(
+                PatternEpsilons::PATTERN_ID_LIMIT,
+            ));
+        }
+        if self.nfa.group_info().explicit_slot_len() > Slots::LIMIT {
+            return Err(BuildError::not_one_pass(
+                "too many explicit capturing groups (max is 16)",
+            ));
+        }
+        assert_eq!(DEAD, self.add_empty_state()?);
+
+        // This is where the explicit slots start. We care about this because
+        // we only need to track explicit slots. The implicit slots---two for
+        // each pattern---are tracked as part of the search routine itself.
+        let explicit_slot_start = self.nfa.pattern_len() * 2;
+        self.add_start_state(None, self.nfa.start_anchored())?;
+        if self.config.get_starts_for_each_pattern() {
+            for pid in self.nfa.patterns() {
+                self.add_start_state(
+                    Some(pid),
+                    self.nfa.start_pattern(pid).unwrap(),
+                )?;
+            }
+        }
+        // NOTE: One wonders what the effects of treating 'uncompiled_nfa_ids'
+        // as a stack are. It is really an unordered *set* of NFA state IDs.
+        // If it, for example, in practice led to discovering whether a regex
+        // was or wasn't one-pass later than if we processed NFA state IDs in
+        // ascending order, then that would make this routine more costly in
+        // the somewhat common case of a regex that isn't one-pass.
+        while let Some(nfa_id) = self.uncompiled_nfa_ids.pop() {
+            let dfa_id = self.nfa_to_dfa_id[nfa_id];
+            // Once we see a match, we keep going, but don't add any new
+            // transitions. Normally we'd just stop, but we have to keep
+            // going in order to verify that our regex is actually one-pass.
+            self.matched = false;
+            // The NFA states we've already explored for this DFA state.
+            self.seen.clear();
+            // The NFA states to explore via epsilon transitions. If we ever
+            // try to push an NFA state that we've already seen, then the NFA
+            // is not one-pass because it implies there are multiple epsilon
+            // transition paths that lead to the same NFA state. In other
+            // words, there is ambiguity.
+            self.stack_push(nfa_id, Epsilons::empty())?;
+            while let Some((id, epsilons)) = self.stack.pop() {
+                match *self.nfa.state(id) {
+                    thompson::State::ByteRange { ref trans } => {
+                        self.compile_transition(dfa_id, trans, epsilons)?;
+                    }
+                    thompson::State::Sparse(ref sparse) => {
+                        for trans in sparse.transitions.iter() {
+                            self.compile_transition(dfa_id, trans, epsilons)?;
+                        }
+                    }
+                    thompson::State::Dense(ref dense) => {
+                        for trans in dense.iter() {
+                            self.compile_transition(dfa_id, &trans, epsilons)?;
+                        }
+                    }
+                    thompson::State::Look { look, next } => {
+                        let looks = epsilons.looks().insert(look);
+                        self.stack_push(next, epsilons.set_looks(looks))?;
+                    }
+                    thompson::State::Union { ref alternates } => {
+                        for &sid in alternates.iter().rev() {
+                            self.stack_push(sid, epsilons)?;
+                        }
+                    }
+                    thompson::State::BinaryUnion { alt1, alt2 } => {
+                        self.stack_push(alt2, epsilons)?;
+                        self.stack_push(alt1, epsilons)?;
+                    }
+                    thompson::State::Capture { next, slot, .. } => {
+                        let slot = slot.as_usize();
+                        let epsilons = if slot < explicit_slot_start {
+                            // If this is an implicit slot, we don't care
+                            // about it, since we handle implicit slots in
+                            // the search routine. We can get away with that
+                            // because there are 2 implicit slots for every
+                            // pattern.
+                            epsilons
+                        } else {
+                            // Offset our explicit slots so that they start
+                            // at index 0.
+                            let offset = slot - explicit_slot_start;
+                            epsilons.set_slots(epsilons.slots().insert(offset))
+                        };
+                        self.stack_push(next, epsilons)?;
+                    }
+                    thompson::State::Fail => {
+                        continue;
+                    }
+                    thompson::State::Match { pattern_id } => {
+                        // If we found two different paths to a match state
+                        // for the same DFA state, then we have ambiguity.
+                        // Thus, it's not one-pass.
+                        if self.matched {
+                            return Err(BuildError::not_one_pass(
+                                "multiple epsilon transitions to match state",
+                            ));
+                        }
+                        self.matched = true;
+                        // Shove the matching pattern ID and the 'epsilons'
+                        // into the current DFA state's pattern epsilons. The
+                        // 'epsilons' includes the slots we need to capture
+                        // before reporting the match and also the conditional
+                        // epsilon transitions we need to check before we can
+                        // report a match.
+                        self.dfa.set_pattern_epsilons(
+                            dfa_id,
+                            PatternEpsilons::empty()
+                                .set_pattern_id(pattern_id)
+                                .set_epsilons(epsilons),
+                        );
+                        // N.B. It is tempting to just bail out here when
+                        // compiling a leftmost-first DFA, since we will never
+                        // compile any more transitions in that case. But we
+                        // actually need to keep going in order to verify that
+                        // we actually have a one-pass regex. e.g., We might
+                        // see more Match states (e.g., for other patterns)
+                        // that imply that we don't have a one-pass regex.
+                        // So instead, we mark that we've found a match and
+                        // continue on. When we go to compile a new DFA state,
+                        // we just skip that part. But otherwise check that the
+                        // one-pass property is upheld.
+                    }
+                }
+            }
+        }
+        self.shuffle_states();
+        Ok(self.dfa)
+    }
+
+    /// Shuffle all match states to the end of the transition table and set
+    /// 'min_match_id' to the ID of the first such match state.
+    ///
+    /// The point of this is to make it extremely cheap to determine whether
+    /// a state is a match state or not. We need to check on this on every
+    /// transition during a search, so it being cheap is important. This
+    /// permits us to check it by simply comparing two state identifiers, as
+    /// opposed to looking for the pattern ID in the state's `PatternEpsilons`.
+    /// (Which requires a memory load and some light arithmetic.)
+    fn shuffle_states(&mut self) {
+        let mut remapper = Remapper::new(&self.dfa);
+        let mut next_dest = self.dfa.last_state_id();
+        for i in (0..self.dfa.state_len()).rev() {
+            let id = StateID::must(i);
+            let is_match =
+                self.dfa.pattern_epsilons(id).pattern_id().is_some();
+            if !is_match {
+                continue;
+            }
+            remapper.swap(&mut self.dfa, next_dest, id);
+            self.dfa.min_match_id = next_dest;
+            next_dest = self.dfa.prev_state_id(next_dest).expect(
+                "match states should be a proper subset of all states",
+            );
+        }
+        remapper.remap(&mut self.dfa);
+    }
+
+    /// Compile the given NFA transition into the DFA state given.
+    ///
+    /// 'Epsilons' corresponds to any conditional epsilon transitions that need
+    /// to be satisfied to follow this transition, and any slots that need to
+    /// be saved if the transition is followed.
+    ///
+    /// If this transition indicates that the NFA is not one-pass, then
+    /// this returns an error. (This occurs, for example, if the DFA state
+    /// already has a transition defined for the same input symbols as the
+    /// given transition, *and* the result of the old and new transitions is
+    /// different.)
+    fn compile_transition(
+        &mut self,
+        dfa_id: StateID,
+        trans: &thompson::Transition,
+        epsilons: Epsilons,
+    ) -> Result<(), BuildError> {
+        let next_dfa_id = self.add_dfa_state_for_nfa_state(trans.next)?;
+        for byte in self
+            .classes
+            .representatives(trans.start..=trans.end)
+            .filter_map(|r| r.as_u8())
+        {
+            let oldtrans = self.dfa.transition(dfa_id, byte);
+            let newtrans =
+                Transition::new(self.matched, next_dfa_id, epsilons);
+            // If the old transition points to the DEAD state, then we know
+            // 'byte' has not been mapped to any transition for this DFA state
+            // yet. So set it unconditionally. Otherwise, we require that the
+            // old and new transitions are equivalent. Otherwise, there is
+            // ambiguity and thus the regex is not one-pass.
+            if oldtrans.state_id() == DEAD {
+                self.dfa.set_transition(dfa_id, byte, newtrans);
+            } else if oldtrans != newtrans {
+                return Err(BuildError::not_one_pass(
+                    "conflicting transition",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    /// Add a start state to the DFA corresponding to the given NFA starting
+    /// state ID.
+    ///
+    /// If adding a state would blow any limits (configured or hard-coded),
+    /// then an error is returned.
+    ///
+    /// If the starting state is an anchored state for a particular pattern,
+    /// then callers must provide the pattern ID for that starting state.
+    /// Callers must also ensure that the first starting state added is the
+    /// start state for all patterns, and then each anchored starting state for
+    /// each pattern (if necessary) added in order. Otherwise, this panics.
+    fn add_start_state(
+        &mut self,
+        pid: Option<PatternID>,
+        nfa_id: StateID,
+    ) -> Result<StateID, BuildError> {
+        match pid {
+            // With no pid, this should be the start state for all patterns
+            // and thus be the first one.
+            None => assert!(self.dfa.starts.is_empty()),
+            // With a pid, we want it to be at self.dfa.starts[pid+1].
+            Some(pid) => assert!(self.dfa.starts.len() == pid.one_more()),
+        }
+        let dfa_id = self.add_dfa_state_for_nfa_state(nfa_id)?;
+        self.dfa.starts.push(dfa_id);
+        Ok(dfa_id)
+    }
+
+    /// Add a new DFA state corresponding to the given NFA state. If adding a
+    /// state would blow any limits (configured or hard-coded), then an error
+    /// is returned. If a DFA state already exists for the given NFA state,
+    /// then that DFA state's ID is returned and no new states are added.
+    ///
+    /// It is not expected that this routine is called for every NFA state.
+    /// Instead, an NFA state ID will usually correspond to the "start" state
+    /// for a sub-graph of the NFA, where all states in the sub-graph are
+    /// reachable via epsilon transitions (conditional or unconditional). That
+    /// sub-graph of NFA states is ultimately what produces a single DFA state.
+    fn add_dfa_state_for_nfa_state(
+        &mut self,
+        nfa_id: StateID,
+    ) -> Result<StateID, BuildError> {
+        // If we've already built a DFA state for the given NFA state, then
+        // just return that. We definitely do not want to have more than one
+        // DFA state in existence for the same NFA state, since all but one of
+        // them will likely become unreachable. And at least some of them are
+        // likely to wind up being incomplete.
+        let existing_dfa_id = self.nfa_to_dfa_id[nfa_id];
+        if existing_dfa_id != DEAD {
+            return Ok(existing_dfa_id);
+        }
+        // If we don't have any DFA state yet, add it and then add the given
+        // NFA state to the list of states to explore.
+        let dfa_id = self.add_empty_state()?;
+        self.nfa_to_dfa_id[nfa_id] = dfa_id;
+        self.uncompiled_nfa_ids.push(nfa_id);
+        Ok(dfa_id)
+    }
+
+    /// Unconditionally add a new empty DFA state. If adding it would exceed
+    /// any limits (configured or hard-coded), then an error is returned. The
+    /// ID of the new state is returned on success.
+    ///
+    /// The added state is *not* a match state.
+    fn add_empty_state(&mut self) -> Result<StateID, BuildError> {
+        let state_limit = Transition::STATE_ID_LIMIT;
+        // Note that unlike dense and lazy DFAs, we specifically do NOT
+        // premultiply our state IDs here. The reason is that we want to pack
+        // our state IDs into 64-bit transitions with other info, so the fewer
+        // the bits we use for state IDs the better. If we premultiply, then
+        // our state ID space shrinks. We justify this by the assumption that
+        // a one-pass DFA is just already doing a fair bit more work than a
+        // normal DFA anyway, so an extra multiplication to compute a state
+        // transition doesn't seem like a huge deal.
+        let next_id = self.dfa.table.len() >> self.dfa.stride2();
+        let id = StateID::new(next_id)
+            .map_err(|_| BuildError::too_many_states(state_limit))?;
+        if id.as_u64() > Transition::STATE_ID_LIMIT {
+            return Err(BuildError::too_many_states(state_limit));
+        }
+        self.dfa
+            .table
+            .extend(core::iter::repeat(Transition(0)).take(self.dfa.stride()));
+        // The default empty value for 'PatternEpsilons' is sadly not all
+        // zeroes. Instead, a special sentinel is used to indicate that there
+        // is no pattern. So we need to explicitly set the pattern epsilons to
+        // the correct "empty" PatternEpsilons.
+        self.dfa.set_pattern_epsilons(id, PatternEpsilons::empty());
+        if let Some(size_limit) = self.config.get_size_limit() {
+            if self.dfa.memory_usage() > size_limit {
+                return Err(BuildError::exceeded_size_limit(size_limit));
+            }
+        }
+        Ok(id)
+    }
+
+    /// Push the given NFA state ID and its corresponding epsilons (slots and
+    /// conditional epsilon transitions) on to a stack for use in a depth first
+    /// traversal of a sub-graph of the NFA.
+    ///
+    /// If the given NFA state ID has already been pushed on to the stack, then
+    /// it indicates the regex is not one-pass and this correspondingly returns
+    /// an error.
+    fn stack_push(
+        &mut self,
+        nfa_id: StateID,
+        epsilons: Epsilons,
+    ) -> Result<(), BuildError> {
+        // If we already have seen a match and we are compiling a leftmost
+        // first DFA, then we shouldn't add any more states to look at. This is
+        // effectively how preference order and non-greediness is implemented.
+        // if !self.config.get_match_kind().continue_past_first_match()
+        // && self.matched
+        // {
+        // return Ok(());
+        // }
+        if !self.seen.insert(nfa_id) {
+            return Err(BuildError::not_one_pass(
+                "multiple epsilon transitions to same state",
+            ));
+        }
+        self.stack.push((nfa_id, epsilons));
+        Ok(())
+    }
+}
+
+/// A one-pass DFA for executing a subset of anchored regex searches while
+/// resolving capturing groups.
+///
+/// A one-pass DFA can be built from an NFA that is one-pass. An NFA is
+/// one-pass when there is never any ambiguity about how to continue a search.
+/// For example, `a*a` is not one-pass becuase during a search, it's not
+/// possible to know whether to continue matching the `a*` or to move on to
+/// the single `a`. However, `a*b` is one-pass, because for every byte in the
+/// input, it's always clear when to move on from `a*` to `b`.
+///
+/// # Only anchored searches are supported
+///
+/// In this crate, especially for DFAs, unanchored searches are implemented by
+/// treating the pattern as if it had a `(?s-u:.)*?` prefix. While the prefix
+/// is one-pass on its own, adding anything after it, e.g., `(?s-u:.)*?a` will
+/// make the overall pattern not one-pass. Why? Because the `(?s-u:.)` matches
+/// any byte, and there is therefore ambiguity as to when the prefix should
+/// stop matching and something else should start matching.
+///
+/// Therefore, one-pass DFAs do not support unanchored searches. In addition
+/// to many regexes simply not being one-pass, it implies that one-pass DFAs
+/// have limited utility. With that said, when a one-pass DFA can be used, it
+/// can potentially provide a dramatic speed up over alternatives like the
+/// [`BoundedBacktracker`](crate::nfa::thompson::backtrack::BoundedBacktracker)
+/// and the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM). In particular,
+/// a one-pass DFA is the only DFA capable of reporting the spans of matching
+/// capturing groups.
+///
+/// To clarify, when we say that unanchored searches are not supported, what
+/// that actually means is:
+///
+/// * The high level routines, [`DFA::is_match`] and [`DFA::captures`], always
+/// do anchored searches.
+/// * Since iterators are most useful in the context of unanchored searches,
+/// there is no `DFA::captures_iter` method.
+/// * For lower level routines like [`DFA::try_search`], an error will be
+/// returned if the given [`Input`] is configured to do an unanchored search or
+/// search for an invalid pattern ID. (Note that an [`Input`] is configured to
+/// do an unanchored search by default, so just giving a `Input::new` is
+/// guaranteed to return an error.)
+///
+/// # Other limitations
+///
+/// In addition to the [configurable heap limit](Config::size_limit) and
+/// the requirement that a regex pattern be one-pass, there are some other
+/// limitations:
+///
+/// * There is an internal limit on the total number of explicit capturing
+/// groups that appear across all patterns. It is somewhat small and there is
+/// no way to configure it. If your pattern(s) exceed this limit, then building
+/// a one-pass DFA will fail.
+/// * If the number of patterns exceeds an internal unconfigurable limit, then
+/// building a one-pass DFA will fail. This limit is quite large and you're
+/// unlikely to hit it.
+/// * If the total number of states exceeds an internal unconfigurable limit,
+/// then building a one-pass DFA will fail. This limit is quite large and
+/// you're unlikely to hit it.
+///
+/// # Other examples of regexes that aren't one-pass
+///
+/// One particularly unfortunate example is that enabling Unicode can cause
+/// regexes that were one-pass to no longer be one-pass. Consider the regex
+/// `(?-u)\w*\s` for example. It is one-pass because there is exactly no
+/// overlap between the ASCII definitions of `\w` and `\s`. But `\w*\s`
+/// (i.e., with Unicode enabled) is *not* one-pass because `\w` and `\s` get
+/// translated to UTF-8 automatons. And while the *codepoints* in `\w` and `\s`
+/// do not overlap, the underlying UTF-8 encodings do. Indeed, because of the
+/// overlap between UTF-8 automata, the use of Unicode character classes will
+/// tend to vastly increase the likelihood of a regex not being one-pass.
+///
+/// # How does one know if a regex is one-pass or not?
+///
+/// At the time of writing, the only way to know is to try and build a one-pass
+/// DFA. The one-pass property is checked while constructing the DFA.
+///
+/// This does mean that you might potentially waste some CPU cycles and memory
+/// by optimistically trying to build a one-pass DFA. But this is currently the
+/// only way. In the future, building a one-pass DFA might be able to use some
+/// heuristics to detect common violations of the one-pass property and bail
+/// more quickly.
+///
+/// # Resource usage
+///
+/// Unlike a general DFA, a one-pass DFA has stricter bounds on its resource
+/// usage. Namely, construction of a one-pass DFA has a time and space
+/// complexity of `O(n)`, where `n ~ nfa.states().len()`. (A general DFA's time
+/// and space complexity is `O(2^n)`.) This smaller time bound is achieved
+/// because there is at most one DFA state created for each NFA state. If
+/// additional DFA states would be required, then the pattern is not one-pass
+/// and construction will fail.
+///
+/// Note though that currently, this DFA uses a fully dense representation.
+/// This means that while its space complexity is no worse than an NFA, it may
+/// in practice use more memory because of higher constant factors. The reason
+/// for this trade off is two-fold. Firstly, a dense representation makes the
+/// search faster. Secondly, the bigger an NFA, the more unlikely it is to be
+/// one-pass. Therefore, most one-pass DFAs are usually pretty small.
+///
+/// # Example
+///
+/// This example shows that the one-pass DFA implements Unicode word boundaries
+/// correctly while simultaneously reporting spans for capturing groups that
+/// participate in a match. (This is the only DFA that implements full support
+/// for Unicode word boundaries.)
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{dfa::onepass::DFA, Match, Span};
+///
+/// let re = DFA::new(r"\b(?P<first>\w+)[[:space:]]+(?P<last>\w+)\b")?;
+/// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+///
+/// re.captures(&mut cache, "Шерлок Холмс", &mut caps);
+/// assert_eq!(Some(Match::must(0, 0..23)), caps.get_match());
+/// assert_eq!(Some(Span::from(0..12)), caps.get_group_by_name("first"));
+/// assert_eq!(Some(Span::from(13..23)), caps.get_group_by_name("last"));
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: iteration
+///
+/// Unlike other regex engines in this crate, this one does not provide
+/// iterator search functions. This is because a one-pass DFA only supports
+/// anchored searches, and so iterator functions are generally not applicable.
+///
+/// However, if you know that all of your matches are
+/// directly adjacent, then an iterator can be used. The
+/// [`util::iter::Searcher`](crate::util::iter::Searcher) type can be used for
+/// this purpose:
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     dfa::onepass::DFA,
+///     util::iter::Searcher,
+///     Anchored, Input, Span,
+/// };
+///
+/// let re = DFA::new(r"\w(\d)\w")?;
+/// let (mut cache, caps) = (re.create_cache(), re.create_captures());
+/// let input = Input::new("a1zb2yc3x").anchored(Anchored::Yes);
+///
+/// let mut it = Searcher::new(input).into_captures_iter(caps, |input, caps| {
+///     Ok(re.try_search(&mut cache, input, caps)?)
+/// }).infallible();
+/// let caps0 = it.next().unwrap();
+/// assert_eq!(Some(Span::from(1..2)), caps0.get_group(1));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone)]
+pub struct DFA {
+    /// The configuration provided by the caller.
+    config: Config,
+    /// The NFA used to build this DFA.
+    ///
+    /// NOTE: We probably don't need to store the NFA here, but we use enough
+    /// bits from it that it's convenient to do so. And there really isn't much
+    /// cost to doing so either, since an NFA is reference counted internally.
+    nfa: NFA,
+    /// The transition table. Given a state ID 's' and a byte of haystack 'b',
+    /// the next state is `table[sid + classes[byte]]`.
+    ///
+    /// The stride of this table (i.e., the number of columns) is always
+    /// a power of 2, even if the alphabet length is smaller. This makes
+    /// converting between state IDs and state indices very cheap.
+    ///
+    /// Note that the stride always includes room for one extra "transition"
+    /// that isn't actually a transition. It is a 'PatternEpsilons' that is
+    /// used for match states only. Because of this, the maximum number of
+    /// active columns in the transition table is 257, which means the maximum
+    /// stride is 512 (the next power of 2 greater than or equal to 257).
+    table: Vec<Transition>,
+    /// The DFA state IDs of the starting states.
+    ///
+    /// `starts[0]` is always present and corresponds to the starting state
+    /// when searching for matches of any pattern in the DFA.
+    ///
+    /// `starts[i]` where i>0 corresponds to the starting state for the pattern
+    /// ID 'i-1'. These starting states are optional.
+    starts: Vec<StateID>,
+    /// Every state ID >= this value corresponds to a match state.
+    ///
+    /// This is what a search uses to detect whether a state is a match state
+    /// or not. It requires only a simple comparison instead of bit-unpacking
+    /// the PatternEpsilons from every state.
+    min_match_id: StateID,
+    /// The alphabet of this DFA, split into equivalence classes. Bytes in the
+    /// same equivalence class can never discriminate between a match and a
+    /// non-match.
+    classes: ByteClasses,
+    /// The number of elements in each state in the transition table. This may
+    /// be less than the stride, since the stride is always a power of 2 and
+    /// the alphabet length can be anything up to and including 256.
+    alphabet_len: usize,
+    /// The number of columns in the transition table, expressed as a power of
+    /// 2.
+    stride2: usize,
+    /// The offset at which the PatternEpsilons for a match state is stored in
+    /// the transition table.
+    ///
+    /// PERF: One wonders whether it would be better to put this in a separate
+    /// allocation, since only match states have a non-empty PatternEpsilons
+    /// and the number of match states tends be dwarfed by the number of
+    /// non-match states. So this would save '8*len(non_match_states)' for each
+    /// DFA. The question is whether moving this to a different allocation will
+    /// lead to a perf hit during searches. You might think dealing with match
+    /// states is rare, but some regexes spend a lot of time in match states
+    /// gobbling up input. But... match state handling is already somewhat
+    /// expensive, so maybe this wouldn't do much? Either way, it's worth
+    /// experimenting.
+    pateps_offset: usize,
+    /// The first explicit slot index. This refers to the first slot appearing
+    /// immediately after the last implicit slot. It is always 'patterns.len()
+    /// * 2'.
+    ///
+    /// We record this because we only store the explicit slots in our DFA
+    /// transition table that need to be saved. Implicit slots are handled
+    /// automatically as part of the search.
+    explicit_slot_start: usize,
+}
+
+impl DFA {
+    /// Parse the given regular expression using the default configuration and
+    /// return the corresponding one-pass DFA.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let re = DFA::new("foo[0-9]+bar")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "foo12345barzzz", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..11)), caps.get_match());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    #[inline]
+    pub fn new(pattern: &str) -> Result<DFA, BuildError> {
+        DFA::builder().build(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "multi regex."
+    /// This similarly uses the default regex configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let re = DFA::new_many(&["[a-z]+", "[0-9]+"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "abc123", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..3)), caps.get_match());
+    ///
+    /// re.captures(&mut cache, "123abc", &mut caps);
+    /// assert_eq!(Some(Match::must(1, 0..3)), caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    #[inline]
+    pub fn new_many<P: AsRef<str>>(patterns: &[P]) -> Result<DFA, BuildError> {
+        DFA::builder().build_many(patterns)
+    }
+
+    /// Like `new`, but builds a one-pass DFA directly from an NFA. This is
+    /// useful if you already have an NFA, or even if you hand-assembled the
+    /// NFA.
+    ///
+    /// # Example
+    ///
+    /// This shows how to hand assemble a regular expression via its HIR,
+    /// compile an NFA from it and build a one-pass DFA from the NFA.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::onepass::DFA,
+    ///     nfa::thompson::NFA,
+    ///     Match,
+    /// };
+    /// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+    ///
+    /// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///     ClassBytesRange::new(b'0', b'9'),
+    ///     ClassBytesRange::new(b'A', b'Z'),
+    ///     ClassBytesRange::new(b'_', b'_'),
+    ///     ClassBytesRange::new(b'a', b'z'),
+    /// ])));
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;
+    ///
+    /// let re = DFA::new_from_nfa(nfa)?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let expected = Some(Match::must(0, 0..1));
+    /// re.captures(&mut cache, "A", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_from_nfa(nfa: NFA) -> Result<DFA, BuildError> {
+        DFA::builder().build_from_nfa(nfa)
+    }
+
+    /// Create a new one-pass DFA that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let dfa = DFA::always_match()?;
+    /// let mut cache = dfa.create_cache();
+    /// let mut caps = dfa.create_captures();
+    ///
+    /// let expected = Match::must(0, 0..0);
+    /// dfa.captures(&mut cache, "", &mut caps);
+    /// assert_eq!(Some(expected), caps.get_match());
+    /// dfa.captures(&mut cache, "foo", &mut caps);
+    /// assert_eq!(Some(expected), caps.get_match());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<DFA, BuildError> {
+        let nfa = thompson::NFA::always_match();
+        Builder::new().build_from_nfa(nfa)
+    }
+
+    /// Create a new one-pass DFA that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::dfa::onepass::DFA;
+    ///
+    /// let dfa = DFA::never_match()?;
+    /// let mut cache = dfa.create_cache();
+    /// let mut caps = dfa.create_captures();
+    ///
+    /// dfa.captures(&mut cache, "", &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    /// dfa.captures(&mut cache, "foo", &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<DFA, BuildError> {
+        let nfa = thompson::NFA::never_match();
+        Builder::new().build_from_nfa(nfa)
+    }
+
+    /// Return a default configuration for a DFA.
+    ///
+    /// This is a convenience routine to avoid needing to import the `Config`
+    /// type when customizing the construction of a DFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to change the match semantics of this DFA from
+    /// its default "leftmost first" to "all." When using "all," non-greediness
+    /// doesn't apply and neither does preference order matching. Instead, the
+    /// longest match possible is always returned. (Although, by construction,
+    /// it's impossible for a one-pass DFA to have a different answer for
+    /// "preference order" vs "longest match.")
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match, MatchKind};
+    ///
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build(r"(abc)+?")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// re.captures(&mut cache, "abcabc", &mut caps);
+    /// // Normally, the non-greedy repetition would give us a 0..3 match.
+    /// assert_eq!(Some(Match::must(0, 0..6)), caps.get_match());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a builder for configuring the construction of a DFA.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::onepass::DFA,
+    ///     nfa::thompson,
+    ///     util::syntax,
+    ///     Match,
+    /// };
+    ///
+    /// let re = DFA::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let haystack = b"foo\xFFarzz\xE2\x98\xFF\n";
+    /// let expected = Some(Match::must(0, 0..8));
+    /// re.captures(&mut cache, haystack, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    /// Create a new empty set of capturing groups that is guaranteed to be
+    /// valid for the search APIs on this DFA.
+    ///
+    /// A `Captures` value created for a specific DFA cannot be used with any
+    /// other DFA.
+    ///
+    /// This is a convenience function for [`Captures::all`]. See the
+    /// [`Captures`] documentation for an explanation of its alternative
+    /// constructors that permit the DFA to do less work during a search, and
+    /// thus might make it faster.
+    #[inline]
+    pub fn create_captures(&self) -> Captures {
+        Captures::all(self.nfa.group_info().clone())
+    }
+
+    /// Create a new cache for this DFA.
+    ///
+    /// The cache returned should only be used for searches for this
+    /// DFA. If you want to reuse the cache for another DFA, then you
+    /// must call [`Cache::reset`] with that DFA (or, equivalently,
+    /// [`DFA::reset_cache`]).
+    #[inline]
+    pub fn create_cache(&self) -> Cache {
+        Cache::new(self)
+    }
+
+    /// Reset the given cache such that it can be used for searching with the
+    /// this DFA (and only this DFA).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different DFA.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different DFA.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let re1 = DFA::new(r"\w")?;
+    /// let re2 = DFA::new(r"\W")?;
+    /// let mut caps1 = re1.create_captures();
+    /// let mut caps2 = re2.create_captures();
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     { re1.captures(&mut cache, "Δ", &mut caps1); caps1.get_match() },
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the one-pass DFA we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// re2.reset_cache(&mut cache);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     { re2.captures(&mut cache, "☃", &mut caps2); caps2.get_match() },
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn reset_cache(&self, cache: &mut Cache) {
+        cache.reset(self);
+    }
+
+    /// Return the config for this one-pass DFA.
+    #[inline]
+    pub fn get_config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Returns a reference to the underlying NFA.
+    #[inline]
+    pub fn get_nfa(&self) -> &NFA {
+        &self.nfa
+    }
+
+    /// Returns the total number of patterns compiled into this DFA.
+    ///
+    /// In the case of a DFA that contains no patterns, this returns `0`.
+    #[inline]
+    pub fn pattern_len(&self) -> usize {
+        self.get_nfa().pattern_len()
+    }
+
+    /// Returns the total number of states in this one-pass DFA.
+    ///
+    /// Note that unlike dense or sparse DFAs, a one-pass DFA does not expose
+    /// a low level DFA API. Therefore, this routine has little use other than
+    /// being informational.
+    #[inline]
+    pub fn state_len(&self) -> usize {
+        self.table.len() >> self.stride2()
+    }
+
+    /// Returns the total number of elements in the alphabet for this DFA.
+    ///
+    /// That is, this returns the total number of transitions that each
+    /// state in this DFA must have. The maximum alphabet size is 256, which
+    /// corresponds to each possible byte value.
+    ///
+    /// The alphabet size may be less than 256 though, and unless
+    /// [`Config::byte_classes`] is disabled, it is typically must less than
+    /// 256. Namely, bytes are grouped into equivalence classes such that no
+    /// two bytes in the same class can distinguish a match from a non-match.
+    /// For example, in the regex `^[a-z]+$`, the ASCII bytes `a-z` could
+    /// all be in the same equivalence class. This leads to a massive space
+    /// savings.
+    ///
+    /// Note though that the alphabet length does _not_ necessarily equal the
+    /// total stride space taken up by a single DFA state in the transition
+    /// table. Namely, for performance reasons, the stride is always the
+    /// smallest power of two that is greater than or equal to the alphabet
+    /// length. For this reason, [`DFA::stride`] or [`DFA::stride2`] are
+    /// often more useful. The alphabet length is typically useful only for
+    /// informational purposes.
+    ///
+    /// Note also that unlike dense or sparse DFAs, a one-pass DFA does
+    /// not have a special end-of-input (EOI) transition. This is because
+    /// a one-pass DFA handles look-around assertions explicitly (like the
+    /// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM)) and does not build
+    /// them into the transitions of the DFA.
+    #[inline]
+    pub fn alphabet_len(&self) -> usize {
+        self.alphabet_len
+    }
+
+    /// Returns the total stride for every state in this DFA, expressed as the
+    /// exponent of a power of 2. The stride is the amount of space each state
+    /// takes up in the transition table, expressed as a number of transitions.
+    /// (Unused transitions map to dead states.)
+    ///
+    /// The stride of a DFA is always equivalent to the smallest power of
+    /// 2 that is greater than or equal to the DFA's alphabet length. This
+    /// definition uses extra space, but possibly permits faster translation
+    /// between state identifiers and their corresponding offsets in this DFA's
+    /// transition table.
+    ///
+    /// For example, if the DFA's stride is 16 transitions, then its `stride2`
+    /// is `4` since `2^4 = 16`.
+    ///
+    /// The minimum `stride2` value is `1` (corresponding to a stride of `2`)
+    /// while the maximum `stride2` value is `9` (corresponding to a stride
+    /// of `512`). The maximum in theory should be `8`, but because of some
+    /// implementation quirks that may be relaxed in the future, it is one more
+    /// than `8`. (Do note that a maximal stride is incredibly rare, as it
+    /// would imply that there is almost no redundant in the regex pattern.)
+    ///
+    /// Note that unlike dense or sparse DFAs, a one-pass DFA does not expose
+    /// a low level DFA API. Therefore, this routine has little use other than
+    /// being informational.
+    #[inline]
+    pub fn stride2(&self) -> usize {
+        self.stride2
+    }
+
+    /// Returns the total stride for every state in this DFA. This corresponds
+    /// to the total number of transitions used by each state in this DFA's
+    /// transition table.
+    ///
+    /// Please see [`DFA::stride2`] for more information. In particular, this
+    /// returns the stride as the number of transitions, where as `stride2`
+    /// returns it as the exponent of a power of 2.
+    ///
+    /// Note that unlike dense or sparse DFAs, a one-pass DFA does not expose
+    /// a low level DFA API. Therefore, this routine has little use other than
+    /// being informational.
+    #[inline]
+    pub fn stride(&self) -> usize {
+        1 << self.stride2()
+    }
+
+    /// Returns the memory usage, in bytes, of this DFA.
+    ///
+    /// The memory usage is computed based on the number of bytes used to
+    /// represent this DFA.
+    ///
+    /// This does **not** include the stack size used up by this DFA. To
+    /// compute that, use `std::mem::size_of::<onepass::DFA>()`.
+    #[inline]
+    pub fn memory_usage(&self) -> usize {
+        use core::mem::size_of;
+
+        self.table.len() * size_of::<Transition>()
+            + self.starts.len() * size_of::<StateID>()
+    }
+}
+
+impl DFA {
+    /// Executes an anchored leftmost forward search, and returns true if and
+    /// only if this one-pass DFA matches the given haystack.
+    ///
+    /// This routine may short circuit if it knows that scanning future
+    /// input will never lead to a different result. In particular, if the
+    /// underlying DFA enters a match state, then this routine will return
+    /// `true` immediately without inspecting any future input. (Consider how
+    /// this might make a difference given the regex `a+` on the haystack
+    /// `aaaaaaaaaaaaaaa`. This routine can stop after it sees the first `a`,
+    /// but routines like `find` need to continue searching because `+` is
+    /// greedy by default.)
+    ///
+    /// The given `Input` is forcefully set to use [`Anchored::Yes`] if the
+    /// given configuration was [`Anchored::No`] (which is the default).
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode. Concretely,
+    /// this occurs when using [`Anchored::Pattern`] without enabling
+    /// [`Config::starts_for_each_pattern`].
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`DFA::try_search`] if you want to handle these panics as error
+    /// values instead.
+    ///
+    /// # Example
+    ///
+    /// This shows basic usage:
+    ///
+    /// ```
+    /// use regex_automata::dfa::onepass::DFA;
+    ///
+    /// let re = DFA::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.is_match(&mut cache, "foo12345bar"));
+    /// assert!(!re.is_match(&mut cache, "foobar"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: consistency with search APIs
+    ///
+    /// `is_match` is guaranteed to return `true` whenever `captures` returns
+    /// a match. This includes searches that are executed entirely within a
+    /// codepoint:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Input};
+    ///
+    /// let re = DFA::new("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(!re.is_match(&mut cache, Input::new("☃").span(1..2)));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Notice that when UTF-8 mode is disabled, then the above reports a
+    /// match because the restriction against zero-width matches that split a
+    /// codepoint has been lifted:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, nfa::thompson::NFA, Input};
+    ///
+    /// let re = DFA::builder()
+    ///     .thompson(NFA::config().utf8(false))
+    ///     .build("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.is_match(&mut cache, Input::new("☃").span(1..2)));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> bool {
+        let mut input = input.into().earliest(true);
+        if matches!(input.get_anchored(), Anchored::No) {
+            input.set_anchored(Anchored::Yes);
+        }
+        self.try_search_slots(cache, &input, &mut []).unwrap().is_some()
+    }
+
+    /// Executes an anchored leftmost forward search, and returns a `Match` if
+    /// and only if this one-pass DFA matches the given haystack.
+    ///
+    /// This routine only includes the overall match span. To get access to the
+    /// individual spans of each capturing group, use [`DFA::captures`].
+    ///
+    /// The given `Input` is forcefully set to use [`Anchored::Yes`] if the
+    /// given configuration was [`Anchored::No`] (which is the default).
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode. Concretely,
+    /// this occurs when using [`Anchored::Pattern`] without enabling
+    /// [`Config::starts_for_each_pattern`].
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`DFA::try_search`] if you want to handle these panics as error
+    /// values instead.
+    ///
+    /// # Example
+    ///
+    /// Leftmost first match semantics corresponds to the match with the
+    /// smallest starting offset, but where the end offset is determined by
+    /// preferring earlier branches in the original regular expression. For
+    /// example, `Sam|Samwise` will match `Sam` in `Samwise`, but `Samwise|Sam`
+    /// will match `Samwise` in `Samwise`.
+    ///
+    /// Generally speaking, the "leftmost first" match is how most backtracking
+    /// regular expressions tend to work. This is in contrast to POSIX-style
+    /// regular expressions that yield "leftmost longest" matches. Namely,
+    /// both `Sam|Samwise` and `Samwise|Sam` match `Samwise` when using
+    /// leftmost longest semantics. (This crate does not currently support
+    /// leftmost longest semantics.)
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let re = DFA::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    /// let expected = Match::must(0, 0..8);
+    /// assert_eq!(Some(expected), re.find(&mut cache, "foo12345"));
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over later parts.
+    /// let re = DFA::new("abc|a")?;
+    /// let mut cache = re.create_cache();
+    /// let expected = Match::must(0, 0..3);
+    /// assert_eq!(Some(expected), re.find(&mut cache, "abc"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Option<Match> {
+        let mut input = input.into();
+        if matches!(input.get_anchored(), Anchored::No) {
+            input.set_anchored(Anchored::Yes);
+        }
+        if self.get_nfa().pattern_len() == 1 {
+            let mut slots = [None, None];
+            let pid =
+                self.try_search_slots(cache, &input, &mut slots).unwrap()?;
+            let start = slots[0].unwrap().get();
+            let end = slots[1].unwrap().get();
+            return Some(Match::new(pid, Span { start, end }));
+        }
+        let ginfo = self.get_nfa().group_info();
+        let slots_len = ginfo.implicit_slot_len();
+        let mut slots = vec![None; slots_len];
+        let pid = self.try_search_slots(cache, &input, &mut slots).unwrap()?;
+        let start = slots[pid.as_usize() * 2].unwrap().get();
+        let end = slots[pid.as_usize() * 2 + 1].unwrap().get();
+        Some(Match::new(pid, Span { start, end }))
+    }
+
+    /// Executes an anchored leftmost forward search and writes the spans
+    /// of capturing groups that participated in a match into the provided
+    /// [`Captures`] value. If no match was found, then [`Captures::is_match`]
+    /// is guaranteed to return `false`.
+    ///
+    /// The given `Input` is forcefully set to use [`Anchored::Yes`] if the
+    /// given configuration was [`Anchored::No`] (which is the default).
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode. Concretely,
+    /// this occurs when using [`Anchored::Pattern`] without enabling
+    /// [`Config::starts_for_each_pattern`].
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`DFA::try_search`] if you want to handle these panics as error
+    /// values instead.
+    ///
+    /// # Example
+    ///
+    /// This shows a simple example of a one-pass regex that extracts
+    /// capturing group spans.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Match, Span};
+    ///
+    /// let re = DFA::new(
+    ///     // Notice that we use ASCII here. The corresponding Unicode regex
+    ///     // is sadly not one-pass.
+    ///     "(?P<first>[[:alpha:]]+)[[:space:]]+(?P<last>[[:alpha:]]+)",
+    /// )?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Bruce Springsteen", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..17)), caps.get_match());
+    /// assert_eq!(Some(Span::from(0..5)), caps.get_group(1));
+    /// assert_eq!(Some(Span::from(6..17)), caps.get_group_by_name("last"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn captures<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+        caps: &mut Captures,
+    ) {
+        let mut input = input.into();
+        if matches!(input.get_anchored(), Anchored::No) {
+            input.set_anchored(Anchored::Yes);
+        }
+        self.try_search(cache, &input, caps).unwrap();
+    }
+
+    /// Executes an anchored leftmost forward search and writes the spans
+    /// of capturing groups that participated in a match into the provided
+    /// [`Captures`] value. If no match was found, then [`Captures::is_match`]
+    /// is guaranteed to return `false`.
+    ///
+    /// The differences with [`DFA::captures`] are:
+    ///
+    /// 1. This returns an error instead of panicking if the search fails.
+    /// 2. Accepts an `&Input` instead of a `Into<Input>`. This permits reusing
+    /// the same input for multiple searches, which _may_ be important for
+    /// latency.
+    /// 3. This does not automatically change the [`Anchored`] mode from `No`
+    /// to `Yes`. Instead, if [`Input::anchored`] is `Anchored::No`, then an
+    /// error is returned.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode. Concretely,
+    /// this occurs when using [`Anchored::Pattern`] without enabling
+    /// [`Config::starts_for_each_pattern`].
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi-regex that permits searching
+    /// for specific patterns. Note that this is somewhat less useful than
+    /// in other regex engines, since a one-pass DFA by definition has no
+    /// ambiguity about which pattern can match at a position. That is, if it
+    /// were possible for two different patterns to match at the same starting
+    /// position, then the multi-regex would not be one-pass and construction
+    /// would have failed.
+    ///
+    /// Nevertheless, this can still be useful if you only care about matches
+    /// for a specific pattern, and want the DFA to report "no match" even if
+    /// some other pattern would have matched.
+    ///
+    /// Note that in order to make use of this functionality,
+    /// [`Config::starts_for_each_pattern`] must be enabled. It is disabled
+    /// by default since it may result in higher memory usage.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::onepass::DFA, Anchored, Input, Match, PatternID,
+    /// };
+    ///
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().starts_for_each_pattern(true))
+    ///     .build_many(&["[a-z]+", "[0-9]+"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "123abc";
+    /// let input = Input::new(haystack).anchored(Anchored::Yes);
+    ///
+    /// // A normal multi-pattern search will show pattern 1 matches.
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(Some(Match::must(1, 0..3)), caps.get_match());
+    ///
+    /// // If we only want to report pattern 0 matches, then we'll get no
+    /// // match here.
+    /// let input = input.anchored(Anchored::Pattern(PatternID::must(0)));
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::onepass::DFA, Anchored, Input, Match};
+    ///
+    /// // one-pass DFAs fully support Unicode word boundaries!
+    /// // A sad joke is that a Unicode aware regex like \w+\s is not one-pass.
+    /// // :-(
+    /// let re = DFA::new(r"\b[0-9]{3}\b")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about
+    /// // the larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `0..3` instead of
+    /// // `3..6`.
+    /// let expected = Some(Match::must(0, 0..3));
+    /// let input = Input::new(&haystack[3..6]).anchored(Anchored::Yes);
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// let input = Input::new(haystack).range(3..6).anchored(Anchored::Yes);
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        caps: &mut Captures,
+    ) -> Result<(), MatchError> {
+        let pid = self.try_search_slots(cache, input, caps.slots_mut())?;
+        caps.set_pattern(pid);
+        Ok(())
+    }
+
+    /// Executes an anchored leftmost forward search and writes the spans
+    /// of capturing groups that participated in a match into the provided
+    /// `slots`, and returns the matching pattern ID. The contents of the
+    /// slots for patterns other than the matching pattern are unspecified. If
+    /// no match was found, then `None` is returned and the contents of all
+    /// `slots` is unspecified.
+    ///
+    /// This is like [`DFA::try_search`], but it accepts a raw slots slice
+    /// instead of a `Captures` value. This is useful in contexts where you
+    /// don't want or need to allocate a `Captures`.
+    ///
+    /// It is legal to pass _any_ number of slots to this routine. If the regex
+    /// engine would otherwise write a slot offset that doesn't fit in the
+    /// provided slice, then it is simply skipped. In general though, there are
+    /// usually three slice lengths you might want to use:
+    ///
+    /// * An empty slice, if you only care about which pattern matched.
+    /// * A slice with
+    /// [`pattern_len() * 2`](crate::dfa::onepass::DFA::pattern_len)
+    /// slots, if you only care about the overall match spans for each matching
+    /// pattern.
+    /// * A slice with
+    /// [`slot_len()`](crate::util::captures::GroupInfo::slot_len) slots, which
+    /// permits recording match offsets for every capturing group in every
+    /// pattern.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode. Concretely,
+    /// this occurs when using [`Anchored::Pattern`] without enabling
+    /// [`Config::starts_for_each_pattern`].
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the overall match offsets in a
+    /// multi-pattern search without allocating a `Captures` value. Indeed, we
+    /// can put our slots right on the stack.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::onepass::DFA, Anchored, Input, PatternID};
+    ///
+    /// let re = DFA::new_many(&[
+    ///     r"[a-zA-Z]+",
+    ///     r"[0-9]+",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("123").anchored(Anchored::Yes);
+    ///
+    /// // We only care about the overall match offsets here, so we just
+    /// // allocate two slots for each pattern. Each slot records the start
+    /// // and end of the match.
+    /// let mut slots = [None; 4];
+    /// let pid = re.try_search_slots(&mut cache, &input, &mut slots)?;
+    /// assert_eq!(Some(PatternID::must(1)), pid);
+    ///
+    /// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'.
+    /// // See 'GroupInfo' for more details on the mapping between groups and
+    /// // slot indices.
+    /// let slot_start = pid.unwrap().as_usize() * 2;
+    /// let slot_end = slot_start + 1;
+    /// assert_eq!(Some(0), slots[slot_start].map(|s| s.get()));
+    /// assert_eq!(Some(3), slots[slot_end].map(|s| s.get()));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        if !utf8empty {
+            return self.try_search_slots_imp(cache, input, slots);
+        }
+        // See PikeVM::try_search_slots for why we do this.
+        let min = self.get_nfa().group_info().implicit_slot_len();
+        if slots.len() >= min {
+            return self.try_search_slots_imp(cache, input, slots);
+        }
+        if self.get_nfa().pattern_len() == 1 {
+            let mut enough = [None, None];
+            let got = self.try_search_slots_imp(cache, input, &mut enough)?;
+            // This is OK because we know `enough_slots` is strictly bigger
+            // than `slots`, otherwise this special case isn't reached.
+            slots.copy_from_slice(&enough[..slots.len()]);
+            return Ok(got);
+        }
+        let mut enough = vec![None; min];
+        let got = self.try_search_slots_imp(cache, input, &mut enough)?;
+        // This is OK because we know `enough_slots` is strictly bigger than
+        // `slots`, otherwise this special case isn't reached.
+        slots.copy_from_slice(&enough[..slots.len()]);
+        Ok(got)
+    }
+
+    #[inline(never)]
+    fn try_search_slots_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        match self.search_imp(cache, input, slots)? {
+            None => return Ok(None),
+            Some(pid) if !utf8empty => return Ok(Some(pid)),
+            Some(pid) => {
+                // These slot indices are always correct because we know our
+                // 'pid' is valid and thus we know that the slot indices for it
+                // are valid.
+                let slot_start = pid.as_usize().wrapping_mul(2);
+                let slot_end = slot_start.wrapping_add(1);
+                // OK because we know we have a match and we know our caller
+                // provided slots are big enough (which we make true above if
+                // the caller didn't). Namely, we're only here when 'utf8empty'
+                // is true, and when that's true, we require slots for every
+                // pattern.
+                let start = slots[slot_start].unwrap().get();
+                let end = slots[slot_end].unwrap().get();
+                // If our match splits a codepoint, then we cannot report is
+                // as a match. And since one-pass DFAs only support anchored
+                // searches, we don't try to skip ahead to find the next match.
+                // We can just quit with nothing.
+                if start == end && !input.is_char_boundary(start) {
+                    return Ok(None);
+                }
+                Ok(Some(pid))
+            }
+        }
+    }
+}
+
+impl DFA {
+    fn search_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        // PERF: Some ideas. I ran out of steam after my initial impl to try
+        // many of these.
+        //
+        // 1) Try doing more state shuffling. Right now, all we do is push
+        // match states to the end of the transition table so that we can do
+        // 'if sid >= self.min_match_id' to know whether we're in a match
+        // state or not. But what about doing something like dense DFAs and
+        // pushing dead, match and states with captures/looks all toward the
+        // beginning of the transition table. Then we could do 'if sid <=
+        // self.max_special_id', in which case, we need to do some special
+        // handling of some sort. Otherwise, we get the happy path, just
+        // like in a DFA search. The main argument against this is that the
+        // one-pass DFA is likely to be used most often with capturing groups
+        // and if capturing groups are common, then this might wind up being a
+        // pessimization.
+        //
+        // 2) Consider moving 'PatternEpsilons' out of the transition table.
+        // It is only needed for match states and usually a small minority of
+        // states are match states. Therefore, we're using an extra 'u64' for
+        // most states.
+        //
+        // 3) I played around with the match state handling and it seems like
+        // there is probably a lot left on the table for improvement. The
+        // key tension is that the 'find_match' routine is a giant mess, but
+        // splitting it out into a non-inlineable function is a non-starter
+        // because the match state might consume input, so 'find_match' COULD
+        // be called quite a lot, and a function call at that point would trash
+        // perf. In theory, we could detect whether a match state consumes
+        // input and then specialize our search routine based on that. In that
+        // case, maybe an extra function call is OK, but even then, it might be
+        // too much of a latency hit. Another idea is to just try and figure
+        // out how to reduce the code size of 'find_match'. RE2 has a trick
+        // here where the match handling isn't done if we know the next byte of
+        // input yields a match too. Maybe we adopt that?
+        //
+        // This just might be a tricky DFA to optimize.
+
+        if input.is_done() {
+            return Ok(None);
+        }
+        // We unfortunately have a bit of book-keeping to do to set things
+        // up. We do have to setup our cache and clear all of our slots. In
+        // particular, clearing the slots is necessary for the case where we
+        // report a match, but one of the capturing groups didn't participate
+        // in the match but had a span set from a previous search. That would
+        // be bad. In theory, we could avoid all this slot clearing if we knew
+        // that every slot was always activated for every match. Then we would
+        // know they would always be overwritten when a match is found.
+        let explicit_slots_len = core::cmp::min(
+            Slots::LIMIT,
+            slots.len().saturating_sub(self.explicit_slot_start),
+        );
+        cache.setup_search(explicit_slots_len);
+        for slot in cache.explicit_slots() {
+            *slot = None;
+        }
+        for slot in slots.iter_mut() {
+            *slot = None;
+        }
+        // We set the starting slots for every pattern up front. This does
+        // increase our latency somewhat, but it avoids having to do it every
+        // time we see a match state (which could be many times in a single
+        // search if the match state consumes input).
+        for pid in self.nfa.patterns() {
+            let i = pid.as_usize() * 2;
+            if i >= slots.len() {
+                break;
+            }
+            slots[i] = NonMaxUsize::new(input.start());
+        }
+        let mut pid = None;
+        let mut next_sid = match input.get_anchored() {
+            Anchored::Yes => self.start(),
+            Anchored::Pattern(pid) => self.start_pattern(pid)?,
+            Anchored::No => {
+                // If the regex is itself always anchored, then we're fine,
+                // even if the search is configured to be unanchored.
+                if !self.nfa.is_always_start_anchored() {
+                    return Err(MatchError::unsupported_anchored(
+                        Anchored::No,
+                    ));
+                }
+                self.start()
+            }
+        };
+        let leftmost_first =
+            matches!(self.config.get_match_kind(), MatchKind::LeftmostFirst);
+        for at in input.start()..input.end() {
+            let sid = next_sid;
+            let trans = self.transition(sid, input.haystack()[at]);
+            next_sid = trans.state_id();
+            let epsilons = trans.epsilons();
+            if sid >= self.min_match_id {
+                if self.find_match(cache, input, at, sid, slots, &mut pid) {
+                    if input.get_earliest()
+                        || (leftmost_first && trans.match_wins())
+                    {
+                        return Ok(pid);
+                    }
+                }
+            }
+            if sid == DEAD
+                || (!epsilons.looks().is_empty()
+                    && !self.nfa.look_matcher().matches_set_inline(
+                        epsilons.looks(),
+                        input.haystack(),
+                        at,
+                    ))
+            {
+                return Ok(pid);
+            }
+            epsilons.slots().apply(at, cache.explicit_slots());
+        }
+        if next_sid >= self.min_match_id {
+            self.find_match(
+                cache,
+                input,
+                input.end(),
+                next_sid,
+                slots,
+                &mut pid,
+            );
+        }
+        Ok(pid)
+    }
+
+    /// Assumes 'sid' is a match state and looks for whether a match can
+    /// be reported. If so, appropriate offsets are written to 'slots' and
+    /// 'matched_pid' is set to the matching pattern ID.
+    ///
+    /// Even when 'sid' is a match state, it's possible that a match won't
+    /// be reported. For example, when the conditional epsilon transitions
+    /// leading to the match state aren't satisfied at the given position in
+    /// the haystack.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        at: usize,
+        sid: StateID,
+        slots: &mut [Option<NonMaxUsize>],
+        matched_pid: &mut Option<PatternID>,
+    ) -> bool {
+        debug_assert!(sid >= self.min_match_id);
+        let pateps = self.pattern_epsilons(sid);
+        let epsilons = pateps.epsilons();
+        if !epsilons.looks().is_empty()
+            && !self.nfa.look_matcher().matches_set_inline(
+                epsilons.looks(),
+                input.haystack(),
+                at,
+            )
+        {
+            return false;
+        }
+        let pid = pateps.pattern_id_unchecked();
+        // This calculation is always correct because we know our 'pid' is
+        // valid and thus we know that the slot indices for it are valid.
+        let slot_end = pid.as_usize().wrapping_mul(2).wrapping_add(1);
+        // Set the implicit 'end' slot for the matching pattern. (The 'start'
+        // slot was set at the beginning of the search.)
+        if slot_end < slots.len() {
+            slots[slot_end] = NonMaxUsize::new(at);
+        }
+        // If the caller provided enough room, copy the previously recorded
+        // explicit slots from our scratch space to the caller provided slots.
+        // We *also* need to set any explicit slots that are active as part of
+        // the path to the match state.
+        if self.explicit_slot_start < slots.len() {
+            // NOTE: The 'cache.explicit_slots()' slice is setup at the
+            // beginning of every search such that it is guaranteed to return a
+            // slice of length equivalent to 'slots[explicit_slot_start..]'.
+            slots[self.explicit_slot_start..]
+                .copy_from_slice(cache.explicit_slots());
+            epsilons.slots().apply(at, &mut slots[self.explicit_slot_start..]);
+        }
+        *matched_pid = Some(pid);
+        true
+    }
+}
+
+impl DFA {
+    /// Returns the anchored start state for matching any pattern in this DFA.
+    fn start(&self) -> StateID {
+        self.starts[0]
+    }
+
+    /// Returns the anchored start state for matching the given pattern. If
+    /// 'starts_for_each_pattern'
+    /// was not enabled, then this returns an error. If the given pattern is
+    /// not in this DFA, then `Ok(None)` is returned.
+    fn start_pattern(&self, pid: PatternID) -> Result<StateID, MatchError> {
+        if !self.config.get_starts_for_each_pattern() {
+            return Err(MatchError::unsupported_anchored(Anchored::Pattern(
+                pid,
+            )));
+        }
+        // 'starts' always has non-zero length. The first entry is always the
+        // anchored starting state for all patterns, and the following entries
+        // are optional and correspond to the anchored starting states for
+        // patterns at pid+1. Thus, starts.len()-1 corresponds to the total
+        // number of patterns that one can explicitly search for. (And it may
+        // be zero.)
+        Ok(self.starts.get(pid.one_more()).copied().unwrap_or(DEAD))
+    }
+
+    /// Returns the transition from the given state ID and byte of input. The
+    /// transition includes the next state ID, the slots that should be saved
+    /// and any conditional epsilon transitions that must be satisfied in order
+    /// to take this transition.
+    fn transition(&self, sid: StateID, byte: u8) -> Transition {
+        let offset = sid.as_usize() << self.stride2();
+        let class = self.classes.get(byte).as_usize();
+        self.table[offset + class]
+    }
+
+    /// Set the transition from the given state ID and byte of input to the
+    /// transition given.
+    fn set_transition(&mut self, sid: StateID, byte: u8, to: Transition) {
+        let offset = sid.as_usize() << self.stride2();
+        let class = self.classes.get(byte).as_usize();
+        self.table[offset + class] = to;
+    }
+
+    /// Return an iterator of "sparse" transitions for the given state ID.
+    /// "sparse" in this context means that consecutive transitions that are
+    /// equivalent are returned as one group, and transitions to the DEAD state
+    /// are ignored.
+    ///
+    /// This winds up being useful for debug printing, since it's much terser
+    /// to display runs of equivalent transitions than the transition for every
+    /// possible byte value. Indeed, in practice, it's very common for runs
+    /// of equivalent transitions to appear.
+    fn sparse_transitions(&self, sid: StateID) -> SparseTransitionIter<'_> {
+        let start = sid.as_usize() << self.stride2();
+        let end = start + self.alphabet_len();
+        SparseTransitionIter {
+            it: self.table[start..end].iter().enumerate(),
+            cur: None,
+        }
+    }
+
+    /// Return the pattern epsilons for the given state ID.
+    ///
+    /// If the given state ID does not correspond to a match state ID, then the
+    /// pattern epsilons returned is empty.
+    fn pattern_epsilons(&self, sid: StateID) -> PatternEpsilons {
+        let offset = sid.as_usize() << self.stride2();
+        PatternEpsilons(self.table[offset + self.pateps_offset].0)
+    }
+
+    /// Set the pattern epsilons for the given state ID.
+    fn set_pattern_epsilons(&mut self, sid: StateID, pateps: PatternEpsilons) {
+        let offset = sid.as_usize() << self.stride2();
+        self.table[offset + self.pateps_offset] = Transition(pateps.0);
+    }
+
+    /// Returns the state ID prior to the one given. This returns None if the
+    /// given ID is the first DFA state.
+    fn prev_state_id(&self, id: StateID) -> Option<StateID> {
+        if id == DEAD {
+            None
+        } else {
+            // CORRECTNESS: Since 'id' is not the first state, subtracting 1
+            // is always valid.
+            Some(StateID::new_unchecked(id.as_usize().checked_sub(1).unwrap()))
+        }
+    }
+
+    /// Returns the state ID of the last state in this DFA's transition table.
+    /// "last" in this context means the last state to appear in memory, i.e.,
+    /// the one with the greatest ID.
+    fn last_state_id(&self) -> StateID {
+        // CORRECTNESS: A DFA table is always non-empty since it always at
+        // least contains a DEAD state. Since every state has the same stride,
+        // we can just compute what the "next" state ID would have been and
+        // then subtract 1 from it.
+        StateID::new_unchecked(
+            (self.table.len() >> self.stride2()).checked_sub(1).unwrap(),
+        )
+    }
+
+    /// Move the transitions from 'id1' to 'id2' and vice versa.
+    ///
+    /// WARNING: This does not update the rest of the transition table to have
+    /// transitions to 'id1' changed to 'id2' and vice versa. This merely moves
+    /// the states in memory.
+    pub(super) fn swap_states(&mut self, id1: StateID, id2: StateID) {
+        let o1 = id1.as_usize() << self.stride2();
+        let o2 = id2.as_usize() << self.stride2();
+        for b in 0..self.stride() {
+            self.table.swap(o1 + b, o2 + b);
+        }
+    }
+
+    /// Map all state IDs in this DFA (transition table + start states)
+    /// according to the closure given.
+    pub(super) fn remap(&mut self, map: impl Fn(StateID) -> StateID) {
+        for i in 0..self.state_len() {
+            let offset = i << self.stride2();
+            for b in 0..self.alphabet_len() {
+                let next = self.table[offset + b].state_id();
+                self.table[offset + b].set_state_id(map(next));
+            }
+        }
+        for i in 0..self.starts.len() {
+            self.starts[i] = map(self.starts[i]);
+        }
+    }
+}
+
+impl core::fmt::Debug for DFA {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        fn debug_state_transitions(
+            f: &mut core::fmt::Formatter,
+            dfa: &DFA,
+            sid: StateID,
+        ) -> core::fmt::Result {
+            for (i, (start, end, trans)) in
+                dfa.sparse_transitions(sid).enumerate()
+            {
+                let next = trans.state_id();
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                if start == end {
+                    write!(
+                        f,
+                        "{:?} => {:?}",
+                        DebugByte(start),
+                        next.as_usize(),
+                    )?;
+                } else {
+                    write!(
+                        f,
+                        "{:?}-{:?} => {:?}",
+                        DebugByte(start),
+                        DebugByte(end),
+                        next.as_usize(),
+                    )?;
+                }
+                if trans.match_wins() {
+                    write!(f, " (MW)")?;
+                }
+                if !trans.epsilons().is_empty() {
+                    write!(f, " ({:?})", trans.epsilons())?;
+                }
+            }
+            Ok(())
+        }
+
+        writeln!(f, "onepass::DFA(")?;
+        for index in 0..self.state_len() {
+            let sid = StateID::must(index);
+            let pateps = self.pattern_epsilons(sid);
+            if sid == DEAD {
+                write!(f, "D ")?;
+            } else if pateps.pattern_id().is_some() {
+                write!(f, "* ")?;
+            } else {
+                write!(f, "  ")?;
+            }
+            write!(f, "{:06?}", sid.as_usize())?;
+            if !pateps.is_empty() {
+                write!(f, " ({:?})", pateps)?;
+            }
+            write!(f, ": ")?;
+            debug_state_transitions(f, self, sid)?;
+            write!(f, "\n")?;
+        }
+        writeln!(f, "")?;
+        for (i, &sid) in self.starts.iter().enumerate() {
+            if i == 0 {
+                writeln!(f, "START(ALL): {:?}", sid.as_usize())?;
+            } else {
+                writeln!(
+                    f,
+                    "START(pattern: {:?}): {:?}",
+                    i - 1,
+                    sid.as_usize(),
+                )?;
+            }
+        }
+        writeln!(f, "state length: {:?}", self.state_len())?;
+        writeln!(f, "pattern length: {:?}", self.pattern_len())?;
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+/// An iterator over groups of consecutive equivalent transitions in a single
+/// state.
+#[derive(Debug)]
+struct SparseTransitionIter<'a> {
+    it: core::iter::Enumerate<core::slice::Iter<'a, Transition>>,
+    cur: Option<(u8, u8, Transition)>,
+}
+
+impl<'a> Iterator for SparseTransitionIter<'a> {
+    type Item = (u8, u8, Transition);
+
+    fn next(&mut self) -> Option<(u8, u8, Transition)> {
+        while let Some((b, &trans)) = self.it.next() {
+            // Fine because we'll never have more than u8::MAX transitions in
+            // one state.
+            let b = b.as_u8();
+            let (prev_start, prev_end, prev_trans) = match self.cur {
+                Some(t) => t,
+                None => {
+                    self.cur = Some((b, b, trans));
+                    continue;
+                }
+            };
+            if prev_trans == trans {
+                self.cur = Some((prev_start, b, prev_trans));
+            } else {
+                self.cur = Some((b, b, trans));
+                if prev_trans.state_id() != DEAD {
+                    return Some((prev_start, prev_end, prev_trans));
+                }
+            }
+        }
+        if let Some((start, end, trans)) = self.cur.take() {
+            if trans.state_id() != DEAD {
+                return Some((start, end, trans));
+            }
+        }
+        None
+    }
+}
+
+/// A cache represents mutable state that a one-pass [`DFA`] requires during a
+/// search.
+///
+/// For a given one-pass DFA, its corresponding cache may be created either via
+/// [`DFA::create_cache`], or via [`Cache::new`]. They are equivalent in every
+/// way, except the former does not require explicitly importing `Cache`.
+///
+/// A particular `Cache` is coupled with the one-pass DFA from which it was
+/// created. It may only be used with that one-pass DFA. A cache and its
+/// allocations may be re-purposed via [`Cache::reset`], in which case, it can
+/// only be used with the new one-pass DFA (and not the old one).
+#[derive(Clone, Debug)]
+pub struct Cache {
+    /// Scratch space used to store slots during a search. Basically, we use
+    /// the caller provided slots to store slots known when a match occurs.
+    /// But after a match occurs, we might continue a search but ultimately
+    /// fail to extend the match. When continuing the search, we need some
+    /// place to store candidate capture offsets without overwriting the slot
+    /// offsets recorded for the most recently seen match.
+    explicit_slots: Vec<Option<NonMaxUsize>>,
+    /// The number of slots in the caller-provided 'Captures' value for the
+    /// current search. This is always at most 'explicit_slots.len()', but
+    /// might be less than it, if the caller provided fewer slots to fill.
+    explicit_slot_len: usize,
+}
+
+impl Cache {
+    /// Create a new [`onepass::DFA`](DFA) cache.
+    ///
+    /// A potentially more convenient routine to create a cache is
+    /// [`DFA::create_cache`], as it does not require also importing the
+    /// `Cache` type.
+    ///
+    /// If you want to reuse the returned `Cache` with some other one-pass DFA,
+    /// then you must call [`Cache::reset`] with the desired one-pass DFA.
+    pub fn new(re: &DFA) -> Cache {
+        let mut cache = Cache { explicit_slots: vec![], explicit_slot_len: 0 };
+        cache.reset(re);
+        cache
+    }
+
+    /// Reset this cache such that it can be used for searching with a
+    /// different [`onepass::DFA`](DFA).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different one-pass DFA.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different one-pass
+    /// DFA.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::onepass::DFA, Match};
+    ///
+    /// let re1 = DFA::new(r"\w")?;
+    /// let re2 = DFA::new(r"\W")?;
+    /// let mut caps1 = re1.create_captures();
+    /// let mut caps2 = re2.create_captures();
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     { re1.captures(&mut cache, "Δ", &mut caps1); caps1.get_match() },
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the one-pass DFA we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// re2.reset_cache(&mut cache);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     { re2.captures(&mut cache, "☃", &mut caps2); caps2.get_match() },
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, re: &DFA) {
+        let explicit_slot_len = re.get_nfa().group_info().explicit_slot_len();
+        self.explicit_slots.resize(explicit_slot_len, None);
+        self.explicit_slot_len = explicit_slot_len;
+    }
+
+    /// Returns the heap memory usage, in bytes, of this cache.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        self.explicit_slots.len() * core::mem::size_of::<Option<NonMaxUsize>>()
+    }
+
+    fn explicit_slots(&mut self) -> &mut [Option<NonMaxUsize>] {
+        &mut self.explicit_slots[..self.explicit_slot_len]
+    }
+
+    fn setup_search(&mut self, explicit_slot_len: usize) {
+        self.explicit_slot_len = explicit_slot_len;
+    }
+}
+
+/// Represents a single transition in a one-pass DFA.
+///
+/// The high 24 bits corresponds to the state ID. The low 48 bits corresponds
+/// to the transition epsilons, which contains the slots that should be saved
+/// when this transition is followed and the conditional epsilon transitions
+/// that must be satisfied in order to follow this transition.
+#[derive(Clone, Copy, Eq, PartialEq)]
+struct Transition(u64);
+
+impl Transition {
+    const STATE_ID_BITS: u64 = 21;
+    const STATE_ID_SHIFT: u64 = 64 - Transition::STATE_ID_BITS;
+    const STATE_ID_LIMIT: u64 = 1 << Transition::STATE_ID_BITS;
+    const MATCH_WINS_SHIFT: u64 = 64 - (Transition::STATE_ID_BITS + 1);
+    const INFO_MASK: u64 = 0x000003FF_FFFFFFFF;
+
+    /// Return a new transition to the given state ID with the given epsilons.
+    fn new(match_wins: bool, sid: StateID, epsilons: Epsilons) -> Transition {
+        let match_wins =
+            if match_wins { 1 << Transition::MATCH_WINS_SHIFT } else { 0 };
+        let sid = sid.as_u64() << Transition::STATE_ID_SHIFT;
+        Transition(sid | match_wins | epsilons.0)
+    }
+
+    /// Returns true if and only if this transition points to the DEAD state.
+    fn is_dead(self) -> bool {
+        self.state_id() == DEAD
+    }
+
+    /// Return whether this transition has a "match wins" property.
+    ///
+    /// When a transition has this property, it means that if a match has been
+    /// found and the search uses leftmost-first semantics, then that match
+    /// should be returned immediately instead of continuing on.
+    ///
+    /// The "match wins" name comes from RE2, which uses a pretty much
+    /// identical mechanism for implementing leftmost-first semantics.
+    fn match_wins(&self) -> bool {
+        (self.0 >> Transition::MATCH_WINS_SHIFT & 1) == 1
+    }
+
+    /// Return the "next" state ID that this transition points to.
+    fn state_id(&self) -> StateID {
+        // OK because a Transition has a valid StateID in its upper bits by
+        // construction. The cast to usize is also correct, even on 16-bit
+        // targets because, again, we know the upper bits is a valid StateID,
+        // which can never overflow usize on any supported target.
+        StateID::new_unchecked(
+            (self.0 >> Transition::STATE_ID_SHIFT).as_usize(),
+        )
+    }
+
+    /// Set the "next" state ID in this transition.
+    fn set_state_id(&mut self, sid: StateID) {
+        *self = Transition::new(self.match_wins(), sid, self.epsilons());
+    }
+
+    /// Return the epsilons embedded in this transition.
+    fn epsilons(&self) -> Epsilons {
+        Epsilons(self.0 & Transition::INFO_MASK)
+    }
+}
+
+impl core::fmt::Debug for Transition {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.is_dead() {
+            return write!(f, "0");
+        }
+        write!(f, "{}", self.state_id().as_usize())?;
+        if self.match_wins() {
+            write!(f, "-MW")?;
+        }
+        if !self.epsilons().is_empty() {
+            write!(f, "-{:?}", self.epsilons())?;
+        }
+        Ok(())
+    }
+}
+
+/// A representation of a match state's pattern ID along with the epsilons for
+/// when a match occurs.
+///
+/// A match state in a one-pass DFA, unlike in a more general DFA, has exactly
+/// one pattern ID. If it had more, then the original NFA would not have been
+/// one-pass.
+///
+/// The "epsilons" part of this corresponds to what was found in the epsilon
+/// transitions between the transition taken in the last byte of input and the
+/// ultimate match state. This might include saving slots and/or conditional
+/// epsilon transitions that must be satisfied before one can report the match.
+///
+/// Technically, every state has room for a 'PatternEpsilons', but it is only
+/// ever non-empty for match states.
+#[derive(Clone, Copy)]
+struct PatternEpsilons(u64);
+
+impl PatternEpsilons {
+    const PATTERN_ID_BITS: u64 = 22;
+    const PATTERN_ID_SHIFT: u64 = 64 - PatternEpsilons::PATTERN_ID_BITS;
+    // A sentinel value indicating that this is not a match state. We don't
+    // use 0 since 0 is a valid pattern ID.
+    const PATTERN_ID_NONE: u64 = 0x00000000_003FFFFF;
+    const PATTERN_ID_LIMIT: u64 = PatternEpsilons::PATTERN_ID_NONE;
+    const PATTERN_ID_MASK: u64 = 0xFFFFFC00_00000000;
+    const EPSILONS_MASK: u64 = 0x000003FF_FFFFFFFF;
+
+    /// Return a new empty pattern epsilons that has no pattern ID and has no
+    /// epsilons. This is suitable for non-match states.
+    fn empty() -> PatternEpsilons {
+        PatternEpsilons(
+            PatternEpsilons::PATTERN_ID_NONE
+                << PatternEpsilons::PATTERN_ID_SHIFT,
+        )
+    }
+
+    /// Whether this pattern epsilons is empty or not. It's empty when it has
+    /// no pattern ID and an empty epsilons.
+    fn is_empty(self) -> bool {
+        self.pattern_id().is_none() && self.epsilons().is_empty()
+    }
+
+    /// Return the pattern ID in this pattern epsilons if one exists.
+    fn pattern_id(self) -> Option<PatternID> {
+        let pid = self.0 >> PatternEpsilons::PATTERN_ID_SHIFT;
+        if pid == PatternEpsilons::PATTERN_ID_LIMIT {
+            None
+        } else {
+            Some(PatternID::new_unchecked(pid.as_usize()))
+        }
+    }
+
+    /// Returns the pattern ID without checking whether it's valid. If this is
+    /// called and there is no pattern ID in this `PatternEpsilons`, then this
+    /// will likely produce an incorrect result or possibly even a panic or
+    /// an overflow. But safety will not be violated.
+    ///
+    /// This is useful when you know a particular state is a match state. If
+    /// it's a match state, then it must have a pattern ID.
+    fn pattern_id_unchecked(self) -> PatternID {
+        let pid = self.0 >> PatternEpsilons::PATTERN_ID_SHIFT;
+        PatternID::new_unchecked(pid.as_usize())
+    }
+
+    /// Return a new pattern epsilons with the given pattern ID, but the same
+    /// epsilons.
+    fn set_pattern_id(self, pid: PatternID) -> PatternEpsilons {
+        PatternEpsilons(
+            (pid.as_u64() << PatternEpsilons::PATTERN_ID_SHIFT)
+                | (self.0 & PatternEpsilons::EPSILONS_MASK),
+        )
+    }
+
+    /// Return the epsilons part of this pattern epsilons.
+    fn epsilons(self) -> Epsilons {
+        Epsilons(self.0 & PatternEpsilons::EPSILONS_MASK)
+    }
+
+    /// Return a new pattern epsilons with the given epsilons, but the same
+    /// pattern ID.
+    fn set_epsilons(self, epsilons: Epsilons) -> PatternEpsilons {
+        PatternEpsilons(
+            (self.0 & PatternEpsilons::PATTERN_ID_MASK)
+                | u64::from(epsilons.0),
+        )
+    }
+}
+
+impl core::fmt::Debug for PatternEpsilons {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.is_empty() {
+            return write!(f, "N/A");
+        }
+        if let Some(pid) = self.pattern_id() {
+            write!(f, "{}", pid.as_usize())?;
+        }
+        if !self.epsilons().is_empty() {
+            if self.pattern_id().is_some() {
+                write!(f, "/")?;
+            }
+            write!(f, "{:?}", self.epsilons())?;
+        }
+        Ok(())
+    }
+}
+
+/// Epsilons represents all of the NFA epsilons transitions that went into a
+/// single transition in a single DFA state. In this case, it only represents
+/// the epsilon transitions that have some kind of non-consuming side effect:
+/// either the transition requires storing the current position of the search
+/// into a slot, or the transition is conditional and requires the current
+/// position in the input to satisfy an assertion before the transition may be
+/// taken.
+///
+/// This folds the cumulative effect of a group of NFA states (all connected
+/// by epsilon transitions) down into a single set of bits. While these bits
+/// can represent all possible conditional epsilon transitions, it only permits
+/// storing up to a somewhat small number of slots.
+///
+/// Epsilons is represented as a 42-bit integer. For example, it is packed into
+/// the lower 42 bits of a `Transition`. (Where the high 22 bits contains a
+/// `StateID` and a special "match wins" property.)
+#[derive(Clone, Copy)]
+struct Epsilons(u64);
+
+impl Epsilons {
+    const SLOT_MASK: u64 = 0x000003FF_FFFFFC00;
+    const SLOT_SHIFT: u64 = 10;
+    const LOOK_MASK: u64 = 0x00000000_000003FF;
+
+    /// Create a new empty epsilons. It has no slots and no assertions that
+    /// need to be satisfied.
+    fn empty() -> Epsilons {
+        Epsilons(0)
+    }
+
+    /// Returns true if this epsilons contains no slots and no assertions.
+    fn is_empty(self) -> bool {
+        self.0 == 0
+    }
+
+    /// Returns the slot epsilon transitions.
+    fn slots(self) -> Slots {
+        Slots((self.0 >> Epsilons::SLOT_SHIFT).low_u32())
+    }
+
+    /// Set the slot epsilon transitions.
+    fn set_slots(self, slots: Slots) -> Epsilons {
+        Epsilons(
+            (u64::from(slots.0) << Epsilons::SLOT_SHIFT)
+                | (self.0 & Epsilons::LOOK_MASK),
+        )
+    }
+
+    /// Return the set of look-around assertions in these epsilon transitions.
+    fn looks(self) -> LookSet {
+        LookSet { bits: (self.0 & Epsilons::LOOK_MASK).low_u16() }
+    }
+
+    /// Set the look-around assertions on these epsilon transitions.
+    fn set_looks(self, look_set: LookSet) -> Epsilons {
+        Epsilons((self.0 & Epsilons::SLOT_MASK) | u64::from(look_set.bits))
+    }
+}
+
+impl core::fmt::Debug for Epsilons {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut wrote = false;
+        if !self.slots().is_empty() {
+            write!(f, "{:?}", self.slots())?;
+            wrote = true;
+        }
+        if !self.looks().is_empty() {
+            if wrote {
+                write!(f, "/")?;
+            }
+            write!(f, "{:?}", self.looks())?;
+            wrote = true;
+        }
+        if !wrote {
+            write!(f, "N/A")?;
+        }
+        Ok(())
+    }
+}
+
+/// The set of epsilon transitions indicating that the current position in a
+/// search should be saved to a slot.
+///
+/// This *only* represents explicit slots. So for example, the pattern
+/// `[a-z]+([0-9]+)([a-z]+)` has:
+///
+/// * 3 capturing groups, thus 6 slots.
+/// * 1 implicit capturing group, thus 2 implicit slots.
+/// * 2 explicit capturing groups, thus 4 explicit slots.
+///
+/// While implicit slots are represented by epsilon transitions in an NFA, we
+/// do not explicitly represent them here. Instead, implicit slots are assumed
+/// to be present and handled automatically in the search code. Therefore,
+/// that means we only need to represent explicit slots in our epsilon
+/// transitions.
+///
+/// Its representation is a bit set. The bit 'i' is set if and only if there
+/// exists an explicit slot at index 'c', where 'c = (#patterns * 2) + i'. That
+/// is, the bit 'i' corresponds to the first explicit slot and the first
+/// explicit slot appears immediately following the last implicit slot. (If
+/// this is confusing, see `GroupInfo` for more details on how slots works.)
+///
+/// A single `Slots` represents all the active slots in a sub-graph of an NFA,
+/// where all the states are connected by epsilon transitions. In effect, when
+/// traversing the one-pass DFA during a search, all slots set in a particular
+/// transition must be captured by recording the current search position.
+///
+/// The API of `Slots` requires the caller to handle the explicit slot offset.
+/// That is, a `Slots` doesn't know where the explicit slots start for a
+/// particular NFA. Thus, if the callers see's the bit 'i' is set, then they
+/// need to do the arithmetic above to find 'c', which is the real actual slot
+/// index in the corresponding NFA.
+#[derive(Clone, Copy)]
+struct Slots(u32);
+
+impl Slots {
+    const LIMIT: usize = 32;
+
+    /// Insert the slot at the given bit index.
+    fn insert(self, slot: usize) -> Slots {
+        debug_assert!(slot < Slots::LIMIT);
+        Slots(self.0 | (1 << slot.as_u32()))
+    }
+
+    /// Remove the slot at the given bit index.
+    fn remove(self, slot: usize) -> Slots {
+        debug_assert!(slot < Slots::LIMIT);
+        Slots(self.0 & !(1 << slot.as_u32()))
+    }
+
+    /// Returns true if and only if this set contains no slots.
+    fn is_empty(self) -> bool {
+        self.0 == 0
+    }
+
+    /// Returns an iterator over all of the set bits in this set.
+    fn iter(self) -> SlotsIter {
+        SlotsIter { slots: self }
+    }
+
+    /// For the position `at` in the current haystack, copy it to
+    /// `caller_explicit_slots` for all slots that are in this set.
+    ///
+    /// Callers may pass a slice of any length. Slots in this set bigger than
+    /// the length of the given explicit slots are simply skipped.
+    ///
+    /// The slice *must* correspond only to the explicit slots and the first
+    /// element of the slice must always correspond to the first explicit slot
+    /// in the corresponding NFA.
+    fn apply(
+        self,
+        at: usize,
+        caller_explicit_slots: &mut [Option<NonMaxUsize>],
+    ) {
+        if self.is_empty() {
+            return;
+        }
+        let at = NonMaxUsize::new(at);
+        for slot in self.iter() {
+            if slot >= caller_explicit_slots.len() {
+                break;
+            }
+            caller_explicit_slots[slot] = at;
+        }
+    }
+}
+
+impl core::fmt::Debug for Slots {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "S")?;
+        for slot in self.iter() {
+            write!(f, "-{:?}", slot)?;
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over all of the bits set in a slot set.
+///
+/// This returns the bit index that is set, so callers may need to offset it
+/// to get the actual NFA slot index.
+#[derive(Debug)]
+struct SlotsIter {
+    slots: Slots,
+}
+
+impl Iterator for SlotsIter {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        // Number of zeroes here is always <= u8::MAX, and so fits in a usize.
+        let slot = self.slots.0.trailing_zeros().as_usize();
+        if slot >= Slots::LIMIT {
+            return None;
+        }
+        self.slots = self.slots.remove(slot);
+        Some(slot)
+    }
+}
+
+/// An error that occurred during the construction of a one-pass DFA.
+///
+/// This error does not provide many introspection capabilities. There are
+/// generally only two things you can do with it:
+///
+/// * Obtain a human readable message via its `std::fmt::Display` impl.
+/// * Access an underlying [`thompson::BuildError`] type from its `source`
+/// method via the `std::error::Error` trait. This error only occurs when using
+/// convenience routines for building a one-pass DFA directly from a pattern
+/// string.
+///
+/// When the `std` feature is enabled, this implements the `std::error::Error`
+/// trait.
+#[derive(Clone, Debug)]
+pub struct BuildError {
+    kind: BuildErrorKind,
+}
+
+/// The kind of error that occurred during the construction of a one-pass DFA.
+#[derive(Clone, Debug)]
+enum BuildErrorKind {
+    NFA(crate::nfa::thompson::BuildError),
+    Word(UnicodeWordBoundaryError),
+    TooManyStates { limit: u64 },
+    TooManyPatterns { limit: u64 },
+    UnsupportedLook { look: Look },
+    ExceededSizeLimit { limit: usize },
+    NotOnePass { msg: &'static str },
+}
+
+impl BuildError {
+    fn nfa(err: crate::nfa::thompson::BuildError) -> BuildError {
+        BuildError { kind: BuildErrorKind::NFA(err) }
+    }
+
+    fn word(err: UnicodeWordBoundaryError) -> BuildError {
+        BuildError { kind: BuildErrorKind::Word(err) }
+    }
+
+    fn too_many_states(limit: u64) -> BuildError {
+        BuildError { kind: BuildErrorKind::TooManyStates { limit } }
+    }
+
+    fn too_many_patterns(limit: u64) -> BuildError {
+        BuildError { kind: BuildErrorKind::TooManyPatterns { limit } }
+    }
+
+    fn unsupported_look(look: Look) -> BuildError {
+        BuildError { kind: BuildErrorKind::UnsupportedLook { look } }
+    }
+
+    fn exceeded_size_limit(limit: usize) -> BuildError {
+        BuildError { kind: BuildErrorKind::ExceededSizeLimit { limit } }
+    }
+
+    fn not_one_pass(msg: &'static str) -> BuildError {
+        BuildError { kind: BuildErrorKind::NotOnePass { msg } }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use self::BuildErrorKind::*;
+
+        match self.kind {
+            NFA(ref err) => Some(err),
+            Word(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl core::fmt::Display for BuildError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use self::BuildErrorKind::*;
+
+        match self.kind {
+            NFA(_) => write!(f, "error building NFA"),
+            Word(_) => write!(f, "NFA contains Unicode word boundary"),
+            TooManyStates { limit } => write!(
+                f,
+                "one-pass DFA exceeded a limit of {:?} for number of states",
+                limit,
+            ),
+            TooManyPatterns { limit } => write!(
+                f,
+                "one-pass DFA exceeded a limit of {:?} for number of patterns",
+                limit,
+            ),
+            UnsupportedLook { look } => write!(
+                f,
+                "one-pass DFA does not support the {:?} assertion",
+                look,
+            ),
+            ExceededSizeLimit { limit } => write!(
+                f,
+                "one-pass DFA exceeded size limit of {:?} during building",
+                limit,
+            ),
+            NotOnePass { msg } => write!(
+                f,
+                "one-pass DFA could not be built because \
+                 pattern is not one-pass: {}",
+                msg,
+            ),
+        }
+    }
+}
+
+#[cfg(all(test, feature = "syntax"))]
+mod tests {
+    use alloc::string::ToString;
+
+    use super::*;
+
+    #[test]
+    fn fail_conflicting_transition() {
+        let predicate = |err: &str| err.contains("conflicting transition");
+
+        let err = DFA::new(r"a*[ab]").unwrap_err().to_string();
+        assert!(predicate(&err), "{}", err);
+    }
+
+    #[test]
+    fn fail_multiple_epsilon() {
+        let predicate = |err: &str| {
+            err.contains("multiple epsilon transitions to same state")
+        };
+
+        let err = DFA::new(r"(^|$)a").unwrap_err().to_string();
+        assert!(predicate(&err), "{}", err);
+    }
+
+    #[test]
+    fn fail_multiple_match() {
+        let predicate = |err: &str| {
+            err.contains("multiple epsilon transitions to match state")
+        };
+
+        let err = DFA::new_many(&[r"^", r"$"]).unwrap_err().to_string();
+        assert!(predicate(&err), "{}", err);
+    }
+
+    // This test is meant to build a one-pass regex with the maximum number of
+    // possible slots.
+    //
+    // NOTE: Remember that the slot limit only applies to explicit capturing
+    // groups. Any number of implicit capturing groups is supported (up to the
+    // maximum number of supported patterns), since implicit groups are handled
+    // by the search loop itself.
+    #[test]
+    fn max_slots() {
+        // One too many...
+        let pat = r"(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)";
+        assert!(DFA::new(pat).is_err());
+        // Just right.
+        let pat = r"(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)";
+        assert!(DFA::new(pat).is_ok());
+    }
+
+    // This test ensures that the one-pass DFA works with all look-around
+    // assertions that we expect it to work with.
+    //
+    // The utility of this test is that each one-pass transition has a small
+    // amount of space to store look-around assertions. Currently, there is
+    // logic in the one-pass constructor to ensure there aren't more than ten
+    // possible assertions. And indeed, there are only ten possible assertions
+    // (at time of writing), so this is okay. But conceivably, more assertions
+    // could be added. So we check that things at least work with what we
+    // expect them to work with.
+    #[test]
+    fn assertions() {
+        // haystack anchors
+        assert!(DFA::new(r"^").is_ok());
+        assert!(DFA::new(r"$").is_ok());
+
+        // line anchors
+        assert!(DFA::new(r"(?m)^").is_ok());
+        assert!(DFA::new(r"(?m)$").is_ok());
+        assert!(DFA::new(r"(?Rm)^").is_ok());
+        assert!(DFA::new(r"(?Rm)$").is_ok());
+
+        // word boundaries
+        if cfg!(feature = "unicode-word-boundary") {
+            assert!(DFA::new(r"\b").is_ok());
+            assert!(DFA::new(r"\B").is_ok());
+        }
+        assert!(DFA::new(r"(?-u)\b").is_ok());
+        assert!(DFA::new(r"(?-u)\B").is_ok());
+    }
+
+    #[cfg(not(miri))] // takes too long on miri
+    #[test]
+    fn is_one_pass() {
+        use crate::util::syntax;
+
+        assert!(DFA::new(r"a*b").is_ok());
+        if cfg!(feature = "unicode-perl") {
+            assert!(DFA::new(r"\w").is_ok());
+        }
+        assert!(DFA::new(r"(?-u)\w*\s").is_ok());
+        assert!(DFA::new(r"(?s:.)*?").is_ok());
+        assert!(DFA::builder()
+            .syntax(syntax::Config::new().utf8(false))
+            .build(r"(?s-u:.)*?")
+            .is_ok());
+    }
+
+    #[test]
+    fn is_not_one_pass() {
+        assert!(DFA::new(r"a*a").is_err());
+        assert!(DFA::new(r"(?s-u:.)*?").is_err());
+        assert!(DFA::new(r"(?s:.)*?a").is_err());
+    }
+
+    #[cfg(not(miri))]
+    #[test]
+    fn is_not_one_pass_bigger() {
+        assert!(DFA::new(r"\w*\s").is_err());
+    }
+}
diff --git a/regex-automata/src/dfa/regex.rs b/regex-automata/src/dfa/regex.rs
new file mode 100644
index 0000000000..2c3f4c21a2
--- /dev/null
+++ b/regex-automata/src/dfa/regex.rs
@@ -0,0 +1,871 @@
+/*!
+A DFA-backed `Regex`.
+
+This module provides [`Regex`], which is defined generically over the
+[`Automaton`] trait. A `Regex` implements convenience routines you might have
+come to expect, such as finding the start/end of a match and iterating over
+all non-overlapping matches. This `Regex` type is limited in its capabilities
+to what a DFA can provide. Therefore, APIs involving capturing groups, for
+example, are not provided.
+
+Internally, a `Regex` is composed of two DFAs. One is a "forward" DFA that
+finds the end offset of a match, where as the other is a "reverse" DFA that
+find the start offset of a match.
+
+See the [parent module](crate::dfa) for examples.
+*/
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+#[cfg(feature = "dfa-build")]
+use crate::dfa::dense::BuildError;
+use crate::{
+    dfa::{automaton::Automaton, dense},
+    util::{iter, search::Input},
+    Anchored, Match, MatchError,
+};
+#[cfg(feature = "alloc")]
+use crate::{
+    dfa::{sparse, StartKind},
+    util::search::MatchKind,
+};
+
+// When the alloc feature is enabled, the regex type sets its A type parameter
+// to default to an owned dense DFA. But without alloc, we set no default. This
+// makes things a lot more convenient in the common case, since writing out the
+// DFA types is pretty annoying.
+//
+// Since we have two different definitions but only want to write one doc
+// string, we use a macro to capture the doc and other attributes once and then
+// repeat them for each definition.
+macro_rules! define_regex_type {
+    ($(#[$doc:meta])*) => {
+        #[cfg(feature = "alloc")]
+        $(#[$doc])*
+        pub struct Regex<A = dense::OwnedDFA> {
+            forward: A,
+            reverse: A,
+        }
+
+        #[cfg(not(feature = "alloc"))]
+        $(#[$doc])*
+        pub struct Regex<A> {
+            forward: A,
+            reverse: A,
+        }
+    };
+}
+
+define_regex_type!(
+    /// A regular expression that uses deterministic finite automata for fast
+    /// searching.
+    ///
+    /// A regular expression is comprised of two DFAs, a "forward" DFA and a
+    /// "reverse" DFA. The forward DFA is responsible for detecting the end of
+    /// a match while the reverse DFA is responsible for detecting the start
+    /// of a match. Thus, in order to find the bounds of any given match, a
+    /// forward search must first be run followed by a reverse search. A match
+    /// found by the forward DFA guarantees that the reverse DFA will also find
+    /// a match.
+    ///
+    /// The type of the DFA used by a `Regex` corresponds to the `A` type
+    /// parameter, which must satisfy the [`Automaton`] trait. Typically,
+    /// `A` is either a [`dense::DFA`](crate::dfa::dense::DFA) or a
+    /// [`sparse::DFA`](crate::dfa::sparse::DFA), where dense DFAs use more
+    /// memory but search faster, while sparse DFAs use less memory but search
+    /// more slowly.
+    ///
+    /// # Crate features
+    ///
+    /// Note that despite what the documentation auto-generates, the _only_
+    /// crate feature needed to use this type is `dfa-search`. You do _not_
+    /// need to enable the `alloc` feature.
+    ///
+    /// By default, a regex's automaton type parameter is set to
+    /// `dense::DFA<Vec<u32>>` when the `alloc` feature is enabled. For most
+    /// in-memory work loads, this is the most convenient type that gives the
+    /// best search performance. When the `alloc` feature is disabled, no
+    /// default type is used.
+    ///
+    /// # When should I use this?
+    ///
+    /// Generally speaking, if you can afford the overhead of building a full
+    /// DFA for your regex, and you don't need things like capturing groups,
+    /// then this is a good choice if you're looking to optimize for matching
+    /// speed. Note however that its speed may be worse than a general purpose
+    /// regex engine if you don't provide a [`dense::Config::prefilter`] to the
+    /// underlying DFA.
+    ///
+    /// # Sparse DFAs
+    ///
+    /// Since a `Regex` is generic over the [`Automaton`] trait, it can be
+    /// used with any kind of DFA. While this crate constructs dense DFAs by
+    /// default, it is easy enough to build corresponding sparse DFAs, and then
+    /// build a regex from them:
+    ///
+    /// ```
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// // First, build a regex that uses dense DFAs.
+    /// let dense_re = Regex::new("foo[0-9]+")?;
+    ///
+    /// // Second, build sparse DFAs from the forward and reverse dense DFAs.
+    /// let fwd = dense_re.forward().to_sparse()?;
+    /// let rev = dense_re.reverse().to_sparse()?;
+    ///
+    /// // Third, build a new regex from the constituent sparse DFAs.
+    /// let sparse_re = Regex::builder().build_from_dfas(fwd, rev);
+    ///
+    /// // A regex that uses sparse DFAs can be used just like with dense DFAs.
+    /// assert_eq!(true, sparse_re.is_match(b"foo123"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Alternatively, one can use a [`Builder`] to construct a sparse DFA
+    /// more succinctly. (Note though that dense DFAs are still constructed
+    /// first internally, and then converted to sparse DFAs, as in the example
+    /// above.)
+    ///
+    /// ```
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// let sparse_re = Regex::builder().build_sparse(r"foo[0-9]+")?;
+    /// // A regex that uses sparse DFAs can be used just like with dense DFAs.
+    /// assert!(sparse_re.is_match(b"foo123"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Fallibility
+    ///
+    /// Most of the search routines defined on this type will _panic_ when the
+    /// underlying search fails. This might be because the DFA gave up because
+    /// it saw a quit byte, whether configured explicitly or via heuristic
+    /// Unicode word boundary support, although neither are enabled by default.
+    /// Or it might fail because an invalid `Input` configuration is given,
+    /// for example, with an unsupported [`Anchored`] mode.
+    ///
+    /// If you need to handle these error cases instead of allowing them to
+    /// trigger a panic, then the lower level [`Regex::try_search`] provides
+    /// a fallible API that never panics.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to cause a search to terminate if it sees a
+    /// `\n` byte, and handle the error returned. This could be useful if, for
+    /// example, you wanted to prevent a user supplied pattern from matching
+    /// across a line boundary.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{dfa::{self, regex::Regex}, Input, MatchError};
+    ///
+    /// let re = Regex::builder()
+    ///     .dense(dfa::dense::Config::new().quit(b'\n', true))
+    ///     .build(r"foo\p{any}+bar")?;
+    ///
+    /// let input = Input::new("foo\nbar");
+    /// // Normally this would produce a match, since \p{any} contains '\n'.
+    /// // But since we instructed the automaton to enter a quit state if a
+    /// // '\n' is observed, this produces a match error instead.
+    /// let expected = MatchError::quit(b'\n', 3);
+    /// let got = re.try_search(&input).unwrap_err();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[derive(Clone, Debug)]
+);
+
+#[cfg(all(feature = "syntax", feature = "dfa-build"))]
+impl Regex {
+    /// Parse the given regular expression using the default configuration and
+    /// return the corresponding regex.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// let re = Regex::new("foo[0-9]+bar")?;
+    /// assert_eq!(
+    ///     Some(Match::must(0, 3..14)),
+    ///     re.find(b"zzzfoo12345barzzz"),
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new(pattern: &str) -> Result<Regex, BuildError> {
+        Builder::new().build(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "regex set."
+    /// This similarly uses the default regex configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// let re = Regex::new_many(&["[a-z]+", "[0-9]+"])?;
+    ///
+    /// let mut it = re.find_iter(b"abc 1 foo 4567 0 quux");
+    /// assert_eq!(Some(Match::must(0, 0..3)), it.next());
+    /// assert_eq!(Some(Match::must(1, 4..5)), it.next());
+    /// assert_eq!(Some(Match::must(0, 6..9)), it.next());
+    /// assert_eq!(Some(Match::must(1, 10..14)), it.next());
+    /// assert_eq!(Some(Match::must(1, 15..16)), it.next());
+    /// assert_eq!(Some(Match::must(0, 17..21)), it.next());
+    /// assert_eq!(None, it.next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        Builder::new().build_many(patterns)
+    }
+}
+
+#[cfg(all(feature = "syntax", feature = "dfa-build"))]
+impl Regex<sparse::DFA<Vec<u8>>> {
+    /// Parse the given regular expression using the default configuration,
+    /// except using sparse DFAs, and return the corresponding regex.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// let re = Regex::new_sparse("foo[0-9]+bar")?;
+    /// assert_eq!(
+    ///     Some(Match::must(0, 3..14)),
+    ///     re.find(b"zzzfoo12345barzzz"),
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_sparse(
+        pattern: &str,
+    ) -> Result<Regex<sparse::DFA<Vec<u8>>>, BuildError> {
+        Builder::new().build_sparse(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "regex set"
+    /// using sparse DFAs. This otherwise similarly uses the default regex
+    /// configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// let re = Regex::new_many_sparse(&["[a-z]+", "[0-9]+"])?;
+    ///
+    /// let mut it = re.find_iter(b"abc 1 foo 4567 0 quux");
+    /// assert_eq!(Some(Match::must(0, 0..3)), it.next());
+    /// assert_eq!(Some(Match::must(1, 4..5)), it.next());
+    /// assert_eq!(Some(Match::must(0, 6..9)), it.next());
+    /// assert_eq!(Some(Match::must(1, 10..14)), it.next());
+    /// assert_eq!(Some(Match::must(1, 15..16)), it.next());
+    /// assert_eq!(Some(Match::must(0, 17..21)), it.next());
+    /// assert_eq!(None, it.next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_many_sparse<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<Regex<sparse::DFA<Vec<u8>>>, BuildError> {
+        Builder::new().build_many_sparse(patterns)
+    }
+}
+
+/// Convenience routines for regex construction.
+impl Regex<dense::DFA<&'static [u32]>> {
+    /// Return a builder for configuring the construction of a `Regex`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode
+    /// everywhere.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     dfa::regex::Regex, nfa::thompson, util::syntax, Match,
+    /// };
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+    /// let expected = Some(Match::must(0, 1..9));
+    /// let got = re.find(haystack);
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+}
+
+/// Standard search routines for finding and iterating over matches.
+impl<A: Automaton> Regex<A> {
+    /// Returns true if and only if this regex matches the given haystack.
+    ///
+    /// This routine may short circuit if it knows that scanning future input
+    /// will never lead to a different result. In particular, if the underlying
+    /// DFA enters a match state or a dead state, then this routine will return
+    /// `true` or `false`, respectively, without inspecting any future input.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`Regex::try_search`] if you want to handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// let re = Regex::new("foo[0-9]+bar")?;
+    /// assert_eq!(true, re.is_match("foo12345bar"));
+    /// assert_eq!(false, re.is_match("foobar"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match<'h, I: Into<Input<'h>>>(&self, input: I) -> bool {
+        // Not only can we do an "earliest" search, but we can avoid doing a
+        // reverse scan too.
+        let input = input.into().earliest(true);
+        self.forward().try_search_fwd(&input).map(|x| x.is_some()).unwrap()
+    }
+
+    /// Returns the start and end offset of the leftmost match. If no match
+    /// exists, then `None` is returned.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`Regex::try_search`] if you want to handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// // Greediness is applied appropriately.
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// assert_eq!(Some(Match::must(0, 3..11)), re.find("zzzfoo12345zzz"));
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the default leftmost-first match semantics demand that we find the
+    /// // earliest match that prefers earlier parts of the pattern over latter
+    /// // parts.
+    /// let re = Regex::new("abc|a")?;
+    /// assert_eq!(Some(Match::must(0, 0..3)), re.find("abc"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find<'h, I: Into<Input<'h>>>(&self, input: I) -> Option<Match> {
+        self.try_search(&input.into()).unwrap()
+    }
+
+    /// Returns an iterator over all non-overlapping leftmost matches in the
+    /// given bytes. If no match exists, then the iterator yields no elements.
+    ///
+    /// This corresponds to the "standard" regex search iterator.
+    ///
+    /// # Panics
+    ///
+    /// If the search returns an error during iteration, then iteration
+    /// panics. See [`Regex::find`] for the panic conditions.
+    ///
+    /// Use [`Regex::try_search`] with
+    /// [`util::iter::Searcher`](crate::util::iter::Searcher) if you want to
+    /// handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, dfa::regex::Regex};
+    ///
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// let text = "foo1 foo12 foo123";
+    /// let matches: Vec<Match> = re.find_iter(text).collect();
+    /// assert_eq!(matches, vec![
+    ///     Match::must(0, 0..4),
+    ///     Match::must(0, 5..10),
+    ///     Match::must(0, 11..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        input: I,
+    ) -> FindMatches<'r, 'h, A> {
+        let it = iter::Searcher::new(input.into());
+        FindMatches { re: self, it }
+    }
+}
+
+/// Lower level fallible search routines that permit controlling where the
+/// search starts and ends in a particular sequence.
+impl<A: Automaton> Regex<A> {
+    /// Returns the start and end offset of the leftmost match. If no match
+    /// exists, then `None` is returned.
+    ///
+    /// This is like [`Regex::find`] but with two differences:
+    ///
+    /// 1. It is not generic over `Into<Input>` and instead accepts a
+    /// `&Input`. This permits reusing the same `Input` for multiple searches
+    /// without needing to create a new one. This _may_ help with latency.
+    /// 2. It returns an error if the search could not complete where as
+    /// [`Regex::find`] will panic.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in the following circumstances:
+    ///
+    /// * The configuration of the DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the DFA quitting.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    #[inline]
+    pub fn try_search(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<Match>, MatchError> {
+        let (fwd, rev) = (self.forward(), self.reverse());
+        let end = match fwd.try_search_fwd(input)? {
+            None => return Ok(None),
+            Some(end) => end,
+        };
+        // This special cases an empty match at the beginning of the search. If
+        // our end matches our start, then since a reverse DFA can't match past
+        // the start, it must follow that our starting position is also our end
+        // position. So short circuit and skip the reverse search.
+        if input.start() == end.offset() {
+            return Ok(Some(Match::new(
+                end.pattern(),
+                end.offset()..end.offset(),
+            )));
+        }
+        // We can also skip the reverse search if we know our search was
+        // anchored. This occurs either when the input config is anchored or
+        // when we know the regex itself is anchored. In this case, we know the
+        // start of the match, if one is found, must be the start of the
+        // search.
+        if self.is_anchored(input) {
+            return Ok(Some(Match::new(
+                end.pattern(),
+                input.start()..end.offset(),
+            )));
+        }
+        // N.B. I have tentatively convinced myself that it isn't necessary
+        // to specify the specific pattern for the reverse search since the
+        // reverse search will always find the same pattern to match as the
+        // forward search. But I lack a rigorous proof. Why not just provide
+        // the pattern anyway? Well, if it is needed, then leaving it out
+        // gives us a chance to find a witness. (Also, if we don't need to
+        // specify the pattern, then we don't need to build the reverse DFA
+        // with 'starts_for_each_pattern' enabled.)
+        //
+        // We also need to be careful to disable 'earliest' for the reverse
+        // search, since it could be enabled for the forward search. In the
+        // reverse case, to satisfy "leftmost" criteria, we need to match
+        // as much as we can. We also need to be careful to make the search
+        // anchored. We don't want the reverse search to report any matches
+        // other than the one beginning at the end of our forward search.
+        let revsearch = input
+            .clone()
+            .span(input.start()..end.offset())
+            .anchored(Anchored::Yes)
+            .earliest(false);
+        let start = rev
+            .try_search_rev(&revsearch)?
+            .expect("reverse search must match if forward search does");
+        assert_eq!(
+            start.pattern(),
+            end.pattern(),
+            "forward and reverse search must match same pattern",
+        );
+        assert!(start.offset() <= end.offset());
+        Ok(Some(Match::new(end.pattern(), start.offset()..end.offset())))
+    }
+
+    /// Returns true if either the given input specifies an anchored search
+    /// or if the underlying DFA is always anchored.
+    fn is_anchored(&self, input: &Input<'_>) -> bool {
+        match input.get_anchored() {
+            Anchored::No => self.forward().is_always_start_anchored(),
+            Anchored::Yes | Anchored::Pattern(_) => true,
+        }
+    }
+}
+
+/// Non-search APIs for querying information about the regex and setting a
+/// prefilter.
+impl<A: Automaton> Regex<A> {
+    /// Return the underlying DFA responsible for forward matching.
+    ///
+    /// This is useful for accessing the underlying DFA and converting it to
+    /// some other format or size. See the [`Builder::build_from_dfas`] docs
+    /// for an example of where this might be useful.
+    pub fn forward(&self) -> &A {
+        &self.forward
+    }
+
+    /// Return the underlying DFA responsible for reverse matching.
+    ///
+    /// This is useful for accessing the underlying DFA and converting it to
+    /// some other format or size. See the [`Builder::build_from_dfas`] docs
+    /// for an example of where this might be useful.
+    pub fn reverse(&self) -> &A {
+        &self.reverse
+    }
+
+    /// Returns the total number of patterns matched by this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// let re = Regex::new_many(&[r"[a-z]+", r"[0-9]+", r"\w+"])?;
+    /// assert_eq!(3, re.pattern_len());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        assert_eq!(self.forward().pattern_len(), self.reverse().pattern_len());
+        self.forward().pattern_len()
+    }
+}
+
+/// An iterator over all non-overlapping matches for an infallible search.
+///
+/// The iterator yields a [`Match`] value until no more matches could be found.
+/// If the underlying regex engine returns an error, then a panic occurs.
+///
+/// The type parameters are as follows:
+///
+/// * `A` represents the type of the underyling DFA that implements the
+/// [`Automaton`] trait.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'h` represents the lifetime of the haystack being searched.
+/// * `'r` represents the lifetime of the regex object itself.
+///
+/// This iterator can be created with the [`Regex::find_iter`] method.
+#[derive(Debug)]
+pub struct FindMatches<'r, 'h, A> {
+    re: &'r Regex<A>,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'h, A: Automaton> Iterator for FindMatches<'r, 'h, A> {
+    type Item = Match;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match> {
+        let FindMatches { re, ref mut it } = *self;
+        it.advance(|input| re.try_search(input))
+    }
+}
+
+/// A builder for a regex based on deterministic finite automatons.
+///
+/// This builder permits configuring options for the syntax of a pattern, the
+/// NFA construction, the DFA construction and finally the regex searching
+/// itself. This builder is different from a general purpose regex builder in
+/// that it permits fine grain configuration of the construction process. The
+/// trade off for this is complexity, and the possibility of setting a
+/// configuration that might not make sense. For example, there are two
+/// different UTF-8 modes:
+///
+/// * [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) controls
+/// whether the pattern itself can contain sub-expressions that match invalid
+/// UTF-8.
+/// * [`thompson::Config::utf8`](crate::nfa::thompson::Config::utf8) controls
+/// how the regex iterators themselves advance the starting position of the
+/// next search when a match with zero length is found.
+///
+/// Generally speaking, callers will want to either enable all of these or
+/// disable all of these.
+///
+/// Internally, building a regex requires building two DFAs, where one is
+/// responsible for finding the end of a match and the other is responsible
+/// for finding the start of a match. If you only need to detect whether
+/// something matched, or only the end of a match, then you should use a
+/// [`dense::Builder`] to construct a single DFA, which is cheaper than
+/// building two DFAs.
+///
+/// # Build methods
+///
+/// This builder has a few "build" methods. In general, it's the result of
+/// combining the following parameters:
+///
+/// * Building one or many regexes.
+/// * Building a regex with dense or sparse DFAs.
+///
+/// The simplest "build" method is [`Builder::build`]. It accepts a single
+/// pattern and builds a dense DFA using `usize` for the state identifier
+/// representation.
+///
+/// The most general "build" method is [`Builder::build_many`], which permits
+/// building a regex that searches for multiple patterns simultaneously while
+/// using a specific state identifier representation.
+///
+/// The most flexible "build" method, but hardest to use, is
+/// [`Builder::build_from_dfas`]. This exposes the fact that a [`Regex`] is
+/// just a pair of DFAs, and this method allows you to specify those DFAs
+/// exactly.
+///
+/// # Example
+///
+/// This example shows how to disable UTF-8 mode in the syntax and the regex
+/// itself. This is generally what you want for matching on arbitrary bytes.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     dfa::regex::Regex, nfa::thompson, util::syntax, Match,
+/// };
+///
+/// let re = Regex::builder()
+///     .syntax(syntax::Config::new().utf8(false))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .build(r"foo(?-u:[^b])ar.*")?;
+/// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+/// let expected = Some(Match::must(0, 1..9));
+/// let got = re.find(haystack);
+/// assert_eq!(expected, got);
+/// // Notice that `(?-u:[^b])` matches invalid UTF-8,
+/// // but the subsequent `.*` does not! Disabling UTF-8
+/// // on the syntax permits this.
+/// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap().range()]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    #[cfg(feature = "dfa-build")]
+    dfa: dense::Builder,
+}
+
+impl Builder {
+    /// Create a new regex builder with the default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            #[cfg(feature = "dfa-build")]
+            dfa: dense::Builder::new(),
+        }
+    }
+
+    /// Build a regex from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn build(&self, pattern: &str) -> Result<Regex, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a regex from the given pattern using sparse DFAs.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn build_sparse(
+        &self,
+        pattern: &str,
+    ) -> Result<Regex<sparse::DFA<Vec<u8>>>, BuildError> {
+        self.build_many_sparse(&[pattern])
+    }
+
+    /// Build a regex from the given patterns.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        let forward = self.dfa.build_many(patterns)?;
+        let reverse = self
+            .dfa
+            .clone()
+            .configure(
+                dense::Config::new()
+                    .prefilter(None)
+                    .specialize_start_states(false)
+                    .start_kind(StartKind::Anchored)
+                    .match_kind(MatchKind::All),
+            )
+            .thompson(crate::nfa::thompson::Config::new().reverse(true))
+            .build_many(patterns)?;
+        Ok(self.build_from_dfas(forward, reverse))
+    }
+
+    /// Build a sparse regex from the given patterns.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn build_many_sparse<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<Regex<sparse::DFA<Vec<u8>>>, BuildError> {
+        let re = self.build_many(patterns)?;
+        let forward = re.forward().to_sparse()?;
+        let reverse = re.reverse().to_sparse()?;
+        Ok(self.build_from_dfas(forward, reverse))
+    }
+
+    /// Build a regex from its component forward and reverse DFAs.
+    ///
+    /// This is useful when deserializing a regex from some arbitrary
+    /// memory region. This is also useful for building regexes from other
+    /// types of DFAs.
+    ///
+    /// If you're building the DFAs from scratch instead of building new DFAs
+    /// from other DFAs, then you'll need to make sure that the reverse DFA is
+    /// configured correctly to match the intended semantics. Namely:
+    ///
+    /// * It should be anchored.
+    /// * It should use [`MatchKind::All`] semantics.
+    /// * It should match in reverse.
+    /// * Otherwise, its configuration should match the forward DFA.
+    ///
+    /// If these conditions aren't satisfied, then the behavior of searches is
+    /// unspecified.
+    ///
+    /// Note that when using this constructor, no configuration is applied.
+    /// Since this routine provides the DFAs to the builder, there is no
+    /// opportunity to apply other configuration options.
+    ///
+    /// # Example
+    ///
+    /// This example is a bit a contrived. The usual use of these methods
+    /// would involve serializing `initial_re` somewhere and then deserializing
+    /// it later to build a regex. But in this case, we do everything in
+    /// memory.
+    ///
+    /// ```
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// let initial_re = Regex::new("foo[0-9]+")?;
+    /// assert_eq!(true, initial_re.is_match(b"foo123"));
+    ///
+    /// let (fwd, rev) = (initial_re.forward(), initial_re.reverse());
+    /// let re = Regex::builder().build_from_dfas(fwd, rev);
+    /// assert_eq!(true, re.is_match(b"foo123"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This example shows how to build a `Regex` that uses sparse DFAs instead
+    /// of dense DFAs without using one of the convenience `build_sparse`
+    /// routines:
+    ///
+    /// ```
+    /// use regex_automata::dfa::regex::Regex;
+    ///
+    /// let initial_re = Regex::new("foo[0-9]+")?;
+    /// assert_eq!(true, initial_re.is_match(b"foo123"));
+    ///
+    /// let fwd = initial_re.forward().to_sparse()?;
+    /// let rev = initial_re.reverse().to_sparse()?;
+    /// let re = Regex::builder().build_from_dfas(fwd, rev);
+    /// assert_eq!(true, re.is_match(b"foo123"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_dfas<A: Automaton>(
+        &self,
+        forward: A,
+        reverse: A,
+    ) -> Regex<A> {
+        Regex { forward, reverse }
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.dfa.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like whether additional time should be
+    /// spent shrinking the size of the NFA.
+    #[cfg(all(feature = "syntax", feature = "dfa-build"))]
+    pub fn thompson(
+        &mut self,
+        config: crate::nfa::thompson::Config,
+    ) -> &mut Builder {
+        self.dfa.thompson(config);
+        self
+    }
+
+    /// Set the dense DFA compilation configuration for this builder using
+    /// [`dense::Config`](dense::Config).
+    ///
+    /// This permits setting things like whether the underlying DFAs should
+    /// be minimized.
+    #[cfg(feature = "dfa-build")]
+    pub fn dense(&mut self, config: dense::Config) -> &mut Builder {
+        self.dfa.configure(config);
+        self
+    }
+}
+
+impl Default for Builder {
+    fn default() -> Builder {
+        Builder::new()
+    }
+}
diff --git a/regex-automata/src/dfa/remapper.rs b/regex-automata/src/dfa/remapper.rs
new file mode 100644
index 0000000000..6e49646721
--- /dev/null
+++ b/regex-automata/src/dfa/remapper.rs
@@ -0,0 +1,242 @@
+use alloc::vec::Vec;
+
+use crate::util::primitives::StateID;
+
+/// Remappable is a tightly coupled abstraction that facilitates remapping
+/// state identifiers in DFAs.
+///
+/// The main idea behind remapping state IDs is that DFAs often need to check
+/// if a certain state is a "special" state of some kind (like a match state)
+/// during a search. Since this is extremely perf critical code, we want this
+/// check to be as fast as possible. Partitioning state IDs into, for example,
+/// into "non-match" and "match" states means one can tell if a state is a
+/// match state via a simple comparison of the state ID.
+///
+/// The issue is that during the DFA construction process, it's not
+/// particularly easy to partition the states. Instead, the simplest thing is
+/// to often just do a pass over all of the states and shuffle them into their
+/// desired partitionings. To do that, we need a mechanism for swapping states.
+/// Hence, this abstraction.
+///
+/// Normally, for such little code, I would just duplicate it. But this is a
+/// key optimization and the implementation is a bit subtle. So the abstraction
+/// is basically a ham-fisted attempt at DRY. The only place we use this is in
+/// the dense and one-pass DFAs.
+///
+/// See also src/dfa/special.rs for a more detailed explanation of how dense
+/// DFAs are partitioned.
+pub(super) trait Remappable: core::fmt::Debug {
+    /// Return the total number of states.
+    fn state_len(&self) -> usize;
+    /// Return the power-of-2 exponent that yields the stride. The pertinent
+    /// laws here are, where N=stride2: 2^N=stride and len(alphabet) <= stride.
+    fn stride2(&self) -> usize;
+    /// Swap the states pointed to by the given IDs. The underlying finite
+    /// state machine should be mutated such that all of the transitions in
+    /// `id1` are now in the memory region where the transitions for `id2`
+    /// were, and all of the transitions in `id2` are now in the memory region
+    /// where the transitions for `id1` were.
+    ///
+    /// Essentially, this "moves" `id1` to `id2` and `id2` to `id1`.
+    ///
+    /// It is expected that, after calling this, the underlying value will be
+    /// left in an inconsistent state, since any other transitions pointing to,
+    /// e.g., `id1` need to be updated to point to `id2`, since that's where
+    /// `id1` moved to.
+    ///
+    /// In order to "fix" the underlying inconsistent state, a `Remapper`
+    /// should be used to guarantee that `remap` is called at the appropriate
+    /// time.
+    fn swap_states(&mut self, id1: StateID, id2: StateID);
+    /// This must remap every single state ID in the underlying value according
+    /// to the function given. For example, in a DFA, this should remap every
+    /// transition and every starting state ID.
+    fn remap(&mut self, map: impl Fn(StateID) -> StateID);
+}
+
+/// Remapper is an abstraction the manages the remapping of state IDs in a
+/// finite state machine. This is useful when one wants to shuffle states into
+/// different positions in the machine.
+///
+/// One of the key complexities this manages is the ability to correctly move
+/// one state multiple times.
+///
+/// Once shuffling is complete, `remap` must be called, which will rewrite
+/// all pertinent transitions to updated state IDs. Neglecting to call `remap`
+/// will almost certainly result in a corrupt machine.
+#[derive(Debug)]
+pub(super) struct Remapper {
+    /// A map from the index of a state to its pre-multiplied identifier.
+    ///
+    /// When a state is swapped with another, then their corresponding
+    /// locations in this map are also swapped. Thus, its new position will
+    /// still point to its old pre-multiplied StateID.
+    ///
+    /// While there is a bit more to it, this then allows us to rewrite the
+    /// state IDs in a DFA's transition table in a single pass. This is done
+    /// by iterating over every ID in this map, then iterating over each
+    /// transition for the state at that ID and re-mapping the transition from
+    /// `old_id` to `map[dfa.to_index(old_id)]`. That is, we find the position
+    /// in this map where `old_id` *started*, and set it to where it ended up
+    /// after all swaps have been completed.
+    map: Vec<StateID>,
+    /// A mapper from state index to state ID (and back).
+    idxmap: IndexMapper,
+}
+
+impl Remapper {
+    /// Create a new remapper from the given remappable implementation. The
+    /// remapper can then be used to swap states. The remappable value given
+    /// here must the same one given to `swap` and `remap`.
+    pub(super) fn new(r: &impl Remappable) -> Remapper {
+        let idxmap = IndexMapper { stride2: r.stride2() };
+        let map = (0..r.state_len()).map(|i| idxmap.to_state_id(i)).collect();
+        Remapper { map, idxmap }
+    }
+
+    /// Swap two states. Once this is called, callers must follow through to
+    /// call `remap`, or else it's possible for the underlying remappable
+    /// value to be in a corrupt state.
+    pub(super) fn swap(
+        &mut self,
+        r: &mut impl Remappable,
+        id1: StateID,
+        id2: StateID,
+    ) {
+        if id1 == id2 {
+            return;
+        }
+        r.swap_states(id1, id2);
+        self.map.swap(self.idxmap.to_index(id1), self.idxmap.to_index(id2));
+    }
+
+    /// Complete the remapping process by rewriting all state IDs in the
+    /// remappable value according to the swaps performed.
+    pub(super) fn remap(mut self, r: &mut impl Remappable) {
+        // Update the map to account for states that have been swapped
+        // multiple times. For example, if (A, C) and (C, G) are swapped, then
+        // transitions previously pointing to A should now point to G. But if
+        // we don't update our map, they will erroneously be set to C. All we
+        // do is follow the swaps in our map until we see our original state
+        // ID.
+        //
+        // The intuition here is to think about how changes are made to the
+        // map: only through pairwise swaps. That means that starting at any
+        // given state, it is always possible to find the loop back to that
+        // state by following the swaps represented in the map (which might be
+        // 0 swaps).
+        //
+        // We are also careful to clone the map before starting in order to
+        // freeze it. We use the frozen map to find our loops, since we need to
+        // update our map as well. Without freezing it, our updates could break
+        // the loops referenced above and produce incorrect results.
+        let oldmap = self.map.clone();
+        for i in 0..r.state_len() {
+            let cur_id = self.idxmap.to_state_id(i);
+            let mut new_id = oldmap[i];
+            if cur_id == new_id {
+                continue;
+            }
+            loop {
+                let id = oldmap[self.idxmap.to_index(new_id)];
+                if cur_id == id {
+                    self.map[i] = new_id;
+                    break;
+                }
+                new_id = id;
+            }
+        }
+        r.remap(|next| self.map[self.idxmap.to_index(next)]);
+    }
+}
+
+/// A simple type for mapping between state indices and state IDs.
+///
+/// The reason why this exists is because state IDs are "premultiplied." That
+/// is, in order to get to the transitions for a particular state, one need
+/// only use the state ID as-is, instead of having to multiple it by transition
+/// table's stride.
+///
+/// The downside of this is that it's inconvenient to map between state IDs
+/// using a dense map, e.g., Vec<StateID>. That's because state IDs look like
+/// `0`, `0+stride`, `0+2*stride`, `0+3*stride`, etc., instead of `0`, `1`,
+/// `2`, `3`, etc.
+///
+/// Since our state IDs are premultiplied, we can convert back-and-forth
+/// between IDs and indices by simply unmultiplying the IDs and multiplying the
+/// indices.
+#[derive(Debug)]
+struct IndexMapper {
+    /// The power of 2 corresponding to the stride of the corresponding
+    /// transition table. 'id >> stride2' de-multiplies an ID while 'index <<
+    /// stride2' pre-multiplies an index to an ID.
+    stride2: usize,
+}
+
+impl IndexMapper {
+    /// Convert a state ID to a state index.
+    fn to_index(&self, id: StateID) -> usize {
+        id.as_usize() >> self.stride2
+    }
+
+    /// Convert a state index to a state ID.
+    fn to_state_id(&self, index: usize) -> StateID {
+        // CORRECTNESS: If the given index is not valid, then it is not
+        // required for this to panic or return a valid state ID. We'll "just"
+        // wind up with panics or silent logic errors at some other point.
+        StateID::new_unchecked(index << self.stride2)
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+mod dense {
+    use crate::{dfa::dense::OwnedDFA, util::primitives::StateID};
+
+    use super::Remappable;
+
+    impl Remappable for OwnedDFA {
+        fn state_len(&self) -> usize {
+            OwnedDFA::state_len(self)
+        }
+
+        fn stride2(&self) -> usize {
+            OwnedDFA::stride2(self)
+        }
+
+        fn swap_states(&mut self, id1: StateID, id2: StateID) {
+            OwnedDFA::swap_states(self, id1, id2)
+        }
+
+        fn remap(&mut self, map: impl Fn(StateID) -> StateID) {
+            OwnedDFA::remap(self, map)
+        }
+    }
+}
+
+#[cfg(feature = "dfa-onepass")]
+mod onepass {
+    use crate::{dfa::onepass::DFA, util::primitives::StateID};
+
+    use super::Remappable;
+
+    impl Remappable for DFA {
+        fn state_len(&self) -> usize {
+            DFA::state_len(self)
+        }
+
+        fn stride2(&self) -> usize {
+            // We don't do pre-multiplication for the one-pass DFA, so
+            // returning 0 has the effect of making state IDs and state indices
+            // equivalent.
+            0
+        }
+
+        fn swap_states(&mut self, id1: StateID, id2: StateID) {
+            DFA::swap_states(self, id1, id2)
+        }
+
+        fn remap(&mut self, map: impl Fn(StateID) -> StateID) {
+            DFA::remap(self, map)
+        }
+    }
+}
diff --git a/regex-automata/src/dfa/search.rs b/regex-automata/src/dfa/search.rs
new file mode 100644
index 0000000000..8c012a5944
--- /dev/null
+++ b/regex-automata/src/dfa/search.rs
@@ -0,0 +1,654 @@
+use crate::{
+    dfa::{
+        accel,
+        automaton::{Automaton, OverlappingState},
+    },
+    util::{
+        prefilter::Prefilter,
+        primitives::StateID,
+        search::{Anchored, HalfMatch, Input, Span},
+    },
+    MatchError,
+};
+
+#[inline(never)]
+pub fn find_fwd<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+) -> Result<Option<HalfMatch>, MatchError> {
+    if input.is_done() {
+        return Ok(None);
+    }
+    let pre = if input.get_anchored().is_anchored() {
+        None
+    } else {
+        dfa.get_prefilter()
+    };
+    // Searching with a pattern ID is always anchored, so we should never use
+    // a prefilter.
+    if pre.is_some() {
+        if input.get_earliest() {
+            find_fwd_imp(dfa, input, pre, true)
+        } else {
+            find_fwd_imp(dfa, input, pre, false)
+        }
+    } else {
+        if input.get_earliest() {
+            find_fwd_imp(dfa, input, None, true)
+        } else {
+            find_fwd_imp(dfa, input, None, false)
+        }
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_fwd_imp<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    pre: Option<&'_ Prefilter>,
+    earliest: bool,
+) -> Result<Option<HalfMatch>, MatchError> {
+    // See 'prefilter_restart' docs for explanation.
+    let universal_start = dfa.universal_start_state(Anchored::No).is_some();
+    let mut mat = None;
+    let mut sid = init_fwd(dfa, input)?;
+    let mut at = input.start();
+    // This could just be a closure, but then I think it would be unsound
+    // because it would need to be safe to invoke. This way, the lack of safety
+    // is clearer in the code below.
+    macro_rules! next_unchecked {
+        ($sid:expr, $at:expr) => {{
+            let byte = *input.haystack().get_unchecked($at);
+            dfa.next_state_unchecked($sid, byte)
+        }};
+    }
+
+    if let Some(ref pre) = pre {
+        let span = Span::from(at..input.end());
+        // If a prefilter doesn't report false positives, then we don't need to
+        // touch the DFA at all. However, since all matches include the pattern
+        // ID, and the prefilter infrastructure doesn't report pattern IDs, we
+        // limit this optimization to cases where there is exactly one pattern.
+        // In that case, any match must be the 0th pattern.
+        match pre.find(input.haystack(), span) {
+            None => return Ok(mat),
+            Some(ref span) => {
+                at = span.start;
+                if !universal_start {
+                    sid = prefilter_restart(dfa, &input, at)?;
+                }
+            }
+        }
+    }
+    while at < input.end() {
+        // SAFETY: There are two safety invariants we need to uphold here in
+        // the loops below: that 'sid' and 'prev_sid' are valid state IDs
+        // for this DFA, and that 'at' is a valid index into 'haystack'.
+        // For the former, we rely on the invariant that next_state* and
+        // start_state_forward always returns a valid state ID (given a valid
+        // state ID in the former case). For the latter safety invariant, we
+        // always guard unchecked access with a check that 'at' is less than
+        // 'end', where 'end <= haystack.len()'. In the unrolled loop below, we
+        // ensure that 'at' is always in bounds.
+        //
+        // PERF: See a similar comment in src/hybrid/search.rs that justifies
+        // this extra work to make the search loop fast. The same reasoning and
+        // benchmarks apply here.
+        let mut prev_sid;
+        while at < input.end() {
+            prev_sid = unsafe { next_unchecked!(sid, at) };
+            if dfa.is_special_state(prev_sid) || at + 3 >= input.end() {
+                core::mem::swap(&mut prev_sid, &mut sid);
+                break;
+            }
+            at += 1;
+
+            sid = unsafe { next_unchecked!(prev_sid, at) };
+            if dfa.is_special_state(sid) {
+                break;
+            }
+            at += 1;
+
+            prev_sid = unsafe { next_unchecked!(sid, at) };
+            if dfa.is_special_state(prev_sid) {
+                core::mem::swap(&mut prev_sid, &mut sid);
+                break;
+            }
+            at += 1;
+
+            sid = unsafe { next_unchecked!(prev_sid, at) };
+            if dfa.is_special_state(sid) {
+                break;
+            }
+            at += 1;
+        }
+        if dfa.is_special_state(sid) {
+            if dfa.is_start_state(sid) {
+                if let Some(ref pre) = pre {
+                    let span = Span::from(at..input.end());
+                    match pre.find(input.haystack(), span) {
+                        None => return Ok(mat),
+                        Some(ref span) => {
+                            // We want to skip any update to 'at' below
+                            // at the end of this iteration and just
+                            // jump immediately back to the next state
+                            // transition at the leading position of the
+                            // candidate match.
+                            //
+                            // ... but only if we actually made progress
+                            // with our prefilter, otherwise if the start
+                            // state has a self-loop, we can get stuck.
+                            if span.start > at {
+                                at = span.start;
+                                if !universal_start {
+                                    sid = prefilter_restart(dfa, &input, at)?;
+                                }
+                                continue;
+                            }
+                        }
+                    }
+                } else if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    at = accel::find_fwd(needles, input.haystack(), at + 1)
+                        .unwrap_or(input.end());
+                    continue;
+                }
+            } else if dfa.is_match_state(sid) {
+                let pattern = dfa.match_pattern(sid, 0);
+                mat = Some(HalfMatch::new(pattern, at));
+                if earliest {
+                    return Ok(mat);
+                }
+                if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    at = accel::find_fwd(needles, input.haystack(), at + 1)
+                        .unwrap_or(input.end());
+                    continue;
+                }
+            } else if dfa.is_accel_state(sid) {
+                let needs = dfa.accelerator(sid);
+                at = accel::find_fwd(needs, input.haystack(), at + 1)
+                    .unwrap_or(input.end());
+                continue;
+            } else if dfa.is_dead_state(sid) {
+                return Ok(mat);
+            } else {
+                // It's important that this is a debug_assert, since this can
+                // actually be tripped even if DFA::from_bytes succeeds and
+                // returns a supposedly valid DFA.
+                debug_assert!(dfa.is_quit_state(sid));
+                return Err(MatchError::quit(input.haystack()[at], at));
+            }
+        }
+        at += 1;
+    }
+    eoi_fwd(dfa, input, &mut sid, &mut mat)?;
+    Ok(mat)
+}
+
+#[inline(never)]
+pub fn find_rev<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+) -> Result<Option<HalfMatch>, MatchError> {
+    if input.is_done() {
+        return Ok(None);
+    }
+    if input.get_earliest() {
+        find_rev_imp(dfa, input, true)
+    } else {
+        find_rev_imp(dfa, input, false)
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_rev_imp<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    earliest: bool,
+) -> Result<Option<HalfMatch>, MatchError> {
+    let mut mat = None;
+    let mut sid = init_rev(dfa, input)?;
+    // In reverse search, the loop below can't handle the case of searching an
+    // empty slice. Ideally we could write something congruent to the forward
+    // search, i.e., 'while at >= start', but 'start' might be 0. Since we use
+    // an unsigned offset, 'at >= 0' is trivially always true. We could avoid
+    // this extra case handling by using a signed offset, but Rust makes it
+    // annoying to do. So... We just handle the empty case separately.
+    if input.start() == input.end() {
+        eoi_rev(dfa, input, &mut sid, &mut mat)?;
+        return Ok(mat);
+    }
+
+    let mut at = input.end() - 1;
+    macro_rules! next_unchecked {
+        ($sid:expr, $at:expr) => {{
+            let byte = *input.haystack().get_unchecked($at);
+            dfa.next_state_unchecked($sid, byte)
+        }};
+    }
+    loop {
+        // SAFETY: See comments in 'find_fwd' for a safety argument.
+        let mut prev_sid;
+        while at >= input.start() {
+            prev_sid = unsafe { next_unchecked!(sid, at) };
+            if dfa.is_special_state(prev_sid)
+                || at <= input.start().saturating_add(3)
+            {
+                core::mem::swap(&mut prev_sid, &mut sid);
+                break;
+            }
+            at -= 1;
+
+            sid = unsafe { next_unchecked!(prev_sid, at) };
+            if dfa.is_special_state(sid) {
+                break;
+            }
+            at -= 1;
+
+            prev_sid = unsafe { next_unchecked!(sid, at) };
+            if dfa.is_special_state(prev_sid) {
+                core::mem::swap(&mut prev_sid, &mut sid);
+                break;
+            }
+            at -= 1;
+
+            sid = unsafe { next_unchecked!(prev_sid, at) };
+            if dfa.is_special_state(sid) {
+                break;
+            }
+            at -= 1;
+        }
+        if dfa.is_special_state(sid) {
+            if dfa.is_start_state(sid) {
+                if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    at = accel::find_rev(needles, input.haystack(), at)
+                        .map(|i| i + 1)
+                        .unwrap_or(input.start());
+                }
+            } else if dfa.is_match_state(sid) {
+                let pattern = dfa.match_pattern(sid, 0);
+                // Since reverse searches report the beginning of a match
+                // and the beginning is inclusive (not exclusive like the
+                // end of a match), we add 1 to make it inclusive.
+                mat = Some(HalfMatch::new(pattern, at + 1));
+                if earliest {
+                    return Ok(mat);
+                }
+                if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    at = accel::find_rev(needles, input.haystack(), at)
+                        .map(|i| i + 1)
+                        .unwrap_or(input.start());
+                }
+            } else if dfa.is_accel_state(sid) {
+                let needles = dfa.accelerator(sid);
+                // If the accelerator returns nothing, why don't we quit the
+                // search? Well, if the accelerator doesn't find anything, that
+                // doesn't mean we don't have a match. It just means that we
+                // can't leave the current state given one of the 255 possible
+                // byte values. However, there might be an EOI transition. So
+                // we set 'at' to the end of the haystack, which will cause
+                // this loop to stop and fall down into the EOI transition.
+                at = accel::find_rev(needles, input.haystack(), at)
+                    .map(|i| i + 1)
+                    .unwrap_or(input.start());
+            } else if dfa.is_dead_state(sid) {
+                return Ok(mat);
+            } else {
+                debug_assert!(dfa.is_quit_state(sid));
+                return Err(MatchError::quit(input.haystack()[at], at));
+            }
+        }
+        if at == input.start() {
+            break;
+        }
+        at -= 1;
+    }
+    eoi_rev(dfa, input, &mut sid, &mut mat)?;
+    Ok(mat)
+}
+
+#[inline(never)]
+pub fn find_overlapping_fwd<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    state.mat = None;
+    if input.is_done() {
+        return Ok(());
+    }
+    let pre = if input.get_anchored().is_anchored() {
+        None
+    } else {
+        dfa.get_prefilter()
+    };
+    if pre.is_some() {
+        find_overlapping_fwd_imp(dfa, input, pre, state)
+    } else {
+        find_overlapping_fwd_imp(dfa, input, None, state)
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_overlapping_fwd_imp<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    pre: Option<&'_ Prefilter>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    // See 'prefilter_restart' docs for explanation.
+    let universal_start = dfa.universal_start_state(Anchored::No).is_some();
+    let mut sid = match state.id {
+        None => {
+            state.at = input.start();
+            init_fwd(dfa, input)?
+        }
+        Some(sid) => {
+            if let Some(match_index) = state.next_match_index {
+                let match_len = dfa.match_len(sid);
+                if match_index < match_len {
+                    state.next_match_index = Some(match_index + 1);
+                    let pattern = dfa.match_pattern(sid, match_index);
+                    state.mat = Some(HalfMatch::new(pattern, state.at));
+                    return Ok(());
+                }
+            }
+            // Once we've reported all matches at a given position, we need to
+            // advance the search to the next position.
+            state.at += 1;
+            if state.at > input.end() {
+                return Ok(());
+            }
+            sid
+        }
+    };
+
+    // NOTE: We don't optimize the crap out of this routine primarily because
+    // it seems like most find_overlapping searches will have higher match
+    // counts, and thus, throughput is perhaps not as important. But if you
+    // have a use case for something faster, feel free to file an issue.
+    while state.at < input.end() {
+        sid = dfa.next_state(sid, input.haystack()[state.at]);
+        if dfa.is_special_state(sid) {
+            state.id = Some(sid);
+            if dfa.is_start_state(sid) {
+                if let Some(ref pre) = pre {
+                    let span = Span::from(state.at..input.end());
+                    match pre.find(input.haystack(), span) {
+                        None => return Ok(()),
+                        Some(ref span) => {
+                            if span.start > state.at {
+                                state.at = span.start;
+                                if !universal_start {
+                                    sid = prefilter_restart(
+                                        dfa, &input, state.at,
+                                    )?;
+                                }
+                                continue;
+                            }
+                        }
+                    }
+                } else if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    state.at = accel::find_fwd(
+                        needles,
+                        input.haystack(),
+                        state.at + 1,
+                    )
+                    .unwrap_or(input.end());
+                    continue;
+                }
+            } else if dfa.is_match_state(sid) {
+                state.next_match_index = Some(1);
+                let pattern = dfa.match_pattern(sid, 0);
+                state.mat = Some(HalfMatch::new(pattern, state.at));
+                return Ok(());
+            } else if dfa.is_accel_state(sid) {
+                let needs = dfa.accelerator(sid);
+                // If the accelerator returns nothing, why don't we quit the
+                // search? Well, if the accelerator doesn't find anything, that
+                // doesn't mean we don't have a match. It just means that we
+                // can't leave the current state given one of the 255 possible
+                // byte values. However, there might be an EOI transition. So
+                // we set 'at' to the end of the haystack, which will cause
+                // this loop to stop and fall down into the EOI transition.
+                state.at =
+                    accel::find_fwd(needs, input.haystack(), state.at + 1)
+                        .unwrap_or(input.end());
+                continue;
+            } else if dfa.is_dead_state(sid) {
+                return Ok(());
+            } else {
+                debug_assert!(dfa.is_quit_state(sid));
+                return Err(MatchError::quit(
+                    input.haystack()[state.at],
+                    state.at,
+                ));
+            }
+        }
+        state.at += 1;
+    }
+
+    let result = eoi_fwd(dfa, input, &mut sid, &mut state.mat);
+    state.id = Some(sid);
+    if state.mat.is_some() {
+        // '1' is always correct here since if we get to this point, this
+        // always corresponds to the first (index '0') match discovered at
+        // this position. So the next match to report at this position (if
+        // it exists) is at index '1'.
+        state.next_match_index = Some(1);
+    }
+    result
+}
+
+#[inline(never)]
+pub(crate) fn find_overlapping_rev<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    state.mat = None;
+    if input.is_done() {
+        return Ok(());
+    }
+    let mut sid = match state.id {
+        None => {
+            let sid = init_rev(dfa, input)?;
+            state.id = Some(sid);
+            if input.start() == input.end() {
+                state.rev_eoi = true;
+            } else {
+                state.at = input.end() - 1;
+            }
+            sid
+        }
+        Some(sid) => {
+            if let Some(match_index) = state.next_match_index {
+                let match_len = dfa.match_len(sid);
+                if match_index < match_len {
+                    state.next_match_index = Some(match_index + 1);
+                    let pattern = dfa.match_pattern(sid, match_index);
+                    state.mat = Some(HalfMatch::new(pattern, state.at));
+                    return Ok(());
+                }
+            }
+            // Once we've reported all matches at a given position, we need
+            // to advance the search to the next position. However, if we've
+            // already followed the EOI transition, then we know we're done
+            // with the search and there cannot be any more matches to report.
+            if state.rev_eoi {
+                return Ok(());
+            } else if state.at == input.start() {
+                // At this point, we should follow the EOI transition. This
+                // will cause us the skip the main loop below and fall through
+                // to the final 'eoi_rev' transition.
+                state.rev_eoi = true;
+            } else {
+                // We haven't hit the end of the search yet, so move on.
+                state.at -= 1;
+            }
+            sid
+        }
+    };
+    while !state.rev_eoi {
+        sid = dfa.next_state(sid, input.haystack()[state.at]);
+        if dfa.is_special_state(sid) {
+            state.id = Some(sid);
+            if dfa.is_start_state(sid) {
+                if dfa.is_accel_state(sid) {
+                    let needles = dfa.accelerator(sid);
+                    state.at =
+                        accel::find_rev(needles, input.haystack(), state.at)
+                            .map(|i| i + 1)
+                            .unwrap_or(input.start());
+                }
+            } else if dfa.is_match_state(sid) {
+                state.next_match_index = Some(1);
+                let pattern = dfa.match_pattern(sid, 0);
+                state.mat = Some(HalfMatch::new(pattern, state.at + 1));
+                return Ok(());
+            } else if dfa.is_accel_state(sid) {
+                let needles = dfa.accelerator(sid);
+                // If the accelerator returns nothing, why don't we quit the
+                // search? Well, if the accelerator doesn't find anything, that
+                // doesn't mean we don't have a match. It just means that we
+                // can't leave the current state given one of the 255 possible
+                // byte values. However, there might be an EOI transition. So
+                // we set 'at' to the end of the haystack, which will cause
+                // this loop to stop and fall down into the EOI transition.
+                state.at =
+                    accel::find_rev(needles, input.haystack(), state.at)
+                        .map(|i| i + 1)
+                        .unwrap_or(input.start());
+            } else if dfa.is_dead_state(sid) {
+                return Ok(());
+            } else {
+                debug_assert!(dfa.is_quit_state(sid));
+                return Err(MatchError::quit(
+                    input.haystack()[state.at],
+                    state.at,
+                ));
+            }
+        }
+        if state.at == input.start() {
+            break;
+        }
+        state.at -= 1;
+    }
+
+    let result = eoi_rev(dfa, input, &mut sid, &mut state.mat);
+    state.rev_eoi = true;
+    state.id = Some(sid);
+    if state.mat.is_some() {
+        // '1' is always correct here since if we get to this point, this
+        // always corresponds to the first (index '0') match discovered at
+        // this position. So the next match to report at this position (if
+        // it exists) is at index '1'.
+        state.next_match_index = Some(1);
+    }
+    result
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn init_fwd<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+) -> Result<StateID, MatchError> {
+    let sid = dfa.start_state_forward(input)?;
+    // Start states can never be match states, since all matches are delayed
+    // by 1 byte.
+    debug_assert!(!dfa.is_match_state(sid));
+    Ok(sid)
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn init_rev<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+) -> Result<StateID, MatchError> {
+    let sid = dfa.start_state_reverse(input)?;
+    // Start states can never be match states, since all matches are delayed
+    // by 1 byte.
+    debug_assert!(!dfa.is_match_state(sid));
+    Ok(sid)
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn eoi_fwd<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    sid: &mut StateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    match input.haystack().get(sp.end) {
+        Some(&b) => {
+            *sid = dfa.next_state(*sid, b);
+            if dfa.is_match_state(*sid) {
+                let pattern = dfa.match_pattern(*sid, 0);
+                *mat = Some(HalfMatch::new(pattern, sp.end));
+            } else if dfa.is_quit_state(*sid) {
+                return Err(MatchError::quit(b, sp.end));
+            }
+        }
+        None => {
+            *sid = dfa.next_eoi_state(*sid);
+            if dfa.is_match_state(*sid) {
+                let pattern = dfa.match_pattern(*sid, 0);
+                *mat = Some(HalfMatch::new(pattern, input.haystack().len()));
+            }
+            // N.B. We don't have to check 'is_quit' here because the EOI
+            // transition can never lead to a quit state.
+            debug_assert!(!dfa.is_quit_state(*sid));
+        }
+    }
+    Ok(())
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn eoi_rev<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    sid: &mut StateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    if sp.start > 0 {
+        let byte = input.haystack()[sp.start - 1];
+        *sid = dfa.next_state(*sid, byte);
+        if dfa.is_match_state(*sid) {
+            let pattern = dfa.match_pattern(*sid, 0);
+            *mat = Some(HalfMatch::new(pattern, sp.start));
+        } else if dfa.is_quit_state(*sid) {
+            return Err(MatchError::quit(byte, sp.start - 1));
+        }
+    } else {
+        *sid = dfa.next_eoi_state(*sid);
+        if dfa.is_match_state(*sid) {
+            let pattern = dfa.match_pattern(*sid, 0);
+            *mat = Some(HalfMatch::new(pattern, 0));
+        }
+        // N.B. We don't have to check 'is_quit' here because the EOI
+        // transition can never lead to a quit state.
+        debug_assert!(!dfa.is_quit_state(*sid));
+    }
+    Ok(())
+}
+
+/// Re-compute the starting state that a DFA should be in after finding a
+/// prefilter candidate match at the position `at`.
+///
+/// The function with the same name has a bit more docs in hybrid/search.rs.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn prefilter_restart<A: Automaton + ?Sized>(
+    dfa: &A,
+    input: &Input<'_>,
+    at: usize,
+) -> Result<StateID, MatchError> {
+    let mut input = input.clone();
+    input.set_start(at);
+    init_fwd(dfa, &input)
+}
diff --git a/regex-automata/src/dfa/sparse.rs b/regex-automata/src/dfa/sparse.rs
new file mode 100644
index 0000000000..5d8ec23408
--- /dev/null
+++ b/regex-automata/src/dfa/sparse.rs
@@ -0,0 +1,2656 @@
+/*!
+Types and routines specific to sparse DFAs.
+
+This module is the home of [`sparse::DFA`](DFA).
+
+Unlike the [`dense`](super::dense) module, this module does not contain a
+builder or configuration specific for sparse DFAs. Instead, the intended
+way to build a sparse DFA is either by using a default configuration with
+its constructor [`sparse::DFA::new`](DFA::new), or by first configuring the
+construction of a dense DFA with [`dense::Builder`](super::dense::Builder)
+and then calling [`dense::DFA::to_sparse`](super::dense::DFA::to_sparse). For
+example, this configures a sparse DFA to do an overlapping search:
+
+```
+use regex_automata::{
+    dfa::{Automaton, OverlappingState, dense},
+    HalfMatch, Input, MatchKind,
+};
+
+let dense_re = dense::Builder::new()
+    .configure(dense::Config::new().match_kind(MatchKind::All))
+    .build(r"Samwise|Sam")?;
+let sparse_re = dense_re.to_sparse()?;
+
+// Setup our haystack and initial start state.
+let input = Input::new("Samwise");
+let mut state = OverlappingState::start();
+
+// First, 'Sam' will match.
+sparse_re.try_search_overlapping_fwd(&input, &mut state)?;
+assert_eq!(Some(HalfMatch::must(0, 3)), state.get_match());
+
+// And now 'Samwise' will match.
+sparse_re.try_search_overlapping_fwd(&input, &mut state)?;
+assert_eq!(Some(HalfMatch::must(0, 7)), state.get_match());
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+*/
+
+#[cfg(feature = "dfa-build")]
+use core::iter;
+use core::{
+    convert::{TryFrom, TryInto},
+    fmt,
+    mem::size_of,
+};
+
+#[cfg(feature = "dfa-build")]
+use alloc::{vec, vec::Vec};
+
+#[cfg(feature = "dfa-build")]
+use crate::dfa::dense::{self, BuildError};
+use crate::{
+    dfa::{
+        automaton::{fmt_state_indicator, Automaton},
+        dense::Flags,
+        special::Special,
+        StartKind, DEAD,
+    },
+    util::{
+        alphabet::{ByteClasses, ByteSet},
+        escape::DebugByte,
+        int::{Pointer, Usize, U16, U32},
+        prefilter::Prefilter,
+        primitives::{PatternID, StateID},
+        search::{Anchored, Input, MatchError},
+        start::{Start, StartByteMap},
+        wire::{self, DeserializeError, Endian, SerializeError},
+    },
+};
+
+const LABEL: &str = "rust-regex-automata-dfa-sparse";
+const VERSION: u32 = 2;
+
+/// A sparse deterministic finite automaton (DFA) with variable sized states.
+///
+/// In contrast to a [dense::DFA](crate::dfa::dense::DFA), a sparse DFA uses
+/// a more space efficient representation for its transitions. Consequently,
+/// sparse DFAs may use much less memory than dense DFAs, but this comes at a
+/// price. In particular, reading the more space efficient transitions takes
+/// more work, and consequently, searching using a sparse DFA is typically
+/// slower than a dense DFA.
+///
+/// A sparse DFA can be built using the default configuration via the
+/// [`DFA::new`] constructor. Otherwise, one can configure various aspects
+/// of a dense DFA via [`dense::Builder`](crate::dfa::dense::Builder),
+/// and then convert a dense DFA to a sparse DFA using
+/// [`dense::DFA::to_sparse`](crate::dfa::dense::DFA::to_sparse).
+///
+/// In general, a sparse DFA supports all the same search operations as a dense
+/// DFA.
+///
+/// Making the choice between a dense and sparse DFA depends on your specific
+/// work load. If you can sacrifice a bit of search time performance, then a
+/// sparse DFA might be the best choice. In particular, while sparse DFAs are
+/// probably always slower than dense DFAs, you may find that they are easily
+/// fast enough for your purposes!
+///
+/// # Type parameters
+///
+/// A `DFA` has one type parameter, `T`, which is used to represent the parts
+/// of a sparse DFA. `T` is typically a `Vec<u8>` or a `&[u8]`.
+///
+/// # The `Automaton` trait
+///
+/// This type implements the [`Automaton`] trait, which means it can be used
+/// for searching. For example:
+///
+/// ```
+/// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+///
+/// let dfa = DFA::new("foo[0-9]+")?;
+/// let expected = Some(HalfMatch::must(0, 8));
+/// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone)]
+pub struct DFA<T> {
+    // When compared to a dense DFA, a sparse DFA *looks* a lot simpler
+    // representation-wise. In reality, it is perhaps more complicated. Namely,
+    // in a dense DFA, all information needs to be very cheaply accessible
+    // using only state IDs. In a sparse DFA however, each state uses a
+    // variable amount of space because each state encodes more information
+    // than just its transitions. Each state also includes an accelerator if
+    // one exists, along with the matching pattern IDs if the state is a match
+    // state.
+    //
+    // That is, a lot of the complexity is pushed down into how each state
+    // itself is represented.
+    tt: Transitions<T>,
+    st: StartTable<T>,
+    special: Special,
+    pre: Option<Prefilter>,
+    quitset: ByteSet,
+    flags: Flags,
+}
+
+#[cfg(feature = "dfa-build")]
+impl DFA<Vec<u8>> {
+    /// Parse the given regular expression using a default configuration and
+    /// return the corresponding sparse DFA.
+    ///
+    /// If you want a non-default configuration, then use
+    /// the [`dense::Builder`](crate::dfa::dense::Builder)
+    /// to set your own configuration, and then call
+    /// [`dense::DFA::to_sparse`](crate::dfa::dense::DFA::to_sparse) to create
+    /// a sparse DFA.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse}, HalfMatch, Input};
+    ///
+    /// let dfa = sparse::DFA::new("foo[0-9]+bar")?;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 11));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345bar"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<DFA<Vec<u8>>, BuildError> {
+        dense::Builder::new()
+            .build(pattern)
+            .and_then(|dense| dense.to_sparse())
+    }
+
+    /// Parse the given regular expressions using a default configuration and
+    /// return the corresponding multi-DFA.
+    ///
+    /// If you want a non-default configuration, then use
+    /// the [`dense::Builder`](crate::dfa::dense::Builder)
+    /// to set your own configuration, and then call
+    /// [`dense::DFA::to_sparse`](crate::dfa::dense::DFA::to_sparse) to create
+    /// a sparse DFA.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse}, HalfMatch, Input};
+    ///
+    /// let dfa = sparse::DFA::new_many(&["[0-9]+", "[a-z]+"])?;
+    /// let expected = Some(HalfMatch::must(1, 3));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345bar"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<DFA<Vec<u8>>, BuildError> {
+        dense::Builder::new()
+            .build_many(patterns)
+            .and_then(|dense| dense.to_sparse())
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl DFA<Vec<u8>> {
+    /// Create a new DFA that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{Automaton, sparse},
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let dfa = sparse::DFA::always_match()?;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 0));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new(""))?);
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<DFA<Vec<u8>>, BuildError> {
+        dense::DFA::always_match()?.to_sparse()
+    }
+
+    /// Create a new sparse DFA that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse}, Input};
+    ///
+    /// let dfa = sparse::DFA::never_match()?;
+    /// assert_eq!(None, dfa.try_search_fwd(&Input::new(""))?);
+    /// assert_eq!(None, dfa.try_search_fwd(&Input::new("foo"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<DFA<Vec<u8>>, BuildError> {
+        dense::DFA::never_match()?.to_sparse()
+    }
+
+    /// The implementation for constructing a sparse DFA from a dense DFA.
+    pub(crate) fn from_dense<T: AsRef<[u32]>>(
+        dfa: &dense::DFA<T>,
+    ) -> Result<DFA<Vec<u8>>, BuildError> {
+        // In order to build the transition table, we need to be able to write
+        // state identifiers for each of the "next" transitions in each state.
+        // Our state identifiers correspond to the byte offset in the
+        // transition table at which the state is encoded. Therefore, we do not
+        // actually know what the state identifiers are until we've allocated
+        // exactly as much space as we need for each state. Thus, construction
+        // of the transition table happens in two passes.
+        //
+        // In the first pass, we fill out the shell of each state, which
+        // includes the transition length, the input byte ranges and
+        // zero-filled space for the transitions and accelerators, if present.
+        // In this first pass, we also build up a map from the state identifier
+        // index of the dense DFA to the state identifier in this sparse DFA.
+        //
+        // In the second pass, we fill in the transitions based on the map
+        // built in the first pass.
+
+        // The capacity given here reflects a minimum. (Well, the true minimum
+        // is likely even bigger, but hopefully this saves a few reallocs.)
+        let mut sparse = Vec::with_capacity(StateID::SIZE * dfa.state_len());
+        // This maps state indices from the dense DFA to StateIDs in the sparse
+        // DFA. We build out this map on the first pass, and then use it in the
+        // second pass to back-fill our transitions.
+        let mut remap: Vec<StateID> = vec![DEAD; dfa.state_len()];
+        for state in dfa.states() {
+            let pos = sparse.len();
+
+            remap[dfa.to_index(state.id())] = StateID::new(pos)
+                .map_err(|_| BuildError::too_many_states())?;
+            // zero-filled space for the transition length
+            sparse.push(0);
+            sparse.push(0);
+
+            let mut transition_len = 0;
+            for (unit1, unit2, _) in state.sparse_transitions() {
+                match (unit1.as_u8(), unit2.as_u8()) {
+                    (Some(b1), Some(b2)) => {
+                        transition_len += 1;
+                        sparse.push(b1);
+                        sparse.push(b2);
+                    }
+                    (None, None) => {}
+                    (Some(_), None) | (None, Some(_)) => {
+                        // can never occur because sparse_transitions never
+                        // groups EOI with any other transition.
+                        unreachable!()
+                    }
+                }
+            }
+            // Add dummy EOI transition. This is never actually read while
+            // searching, but having space equivalent to the total number
+            // of transitions is convenient. Otherwise, we'd need to track
+            // a different number of transitions for the byte ranges as for
+            // the 'next' states.
+            //
+            // N.B. The loop above is not guaranteed to yield the EOI
+            // transition, since it may point to a DEAD state. By putting
+            // it here, we always write the EOI transition, and thus
+            // guarantee that our transition length is >0. Why do we always
+            // need the EOI transition? Because in order to implement
+            // Automaton::next_eoi_state, this lets us just ask for the last
+            // transition. There are probably other/better ways to do this.
+            transition_len += 1;
+            sparse.push(0);
+            sparse.push(0);
+
+            // Check some assumptions about transition length.
+            assert_ne!(
+                transition_len, 0,
+                "transition length should be non-zero",
+            );
+            assert!(
+                transition_len <= 257,
+                "expected transition length {} to be <= 257",
+                transition_len,
+            );
+
+            // Fill in the transition length.
+            // Since transition length is always <= 257, we use the most
+            // significant bit to indicate whether this is a match state or
+            // not.
+            let ntrans = if dfa.is_match_state(state.id()) {
+                transition_len | (1 << 15)
+            } else {
+                transition_len
+            };
+            wire::NE::write_u16(ntrans, &mut sparse[pos..]);
+
+            // zero-fill the actual transitions.
+            // Unwraps are OK since transition_length <= 257 and our minimum
+            // support usize size is 16-bits.
+            let zeros = usize::try_from(transition_len)
+                .unwrap()
+                .checked_mul(StateID::SIZE)
+                .unwrap();
+            sparse.extend(iter::repeat(0).take(zeros));
+
+            // If this is a match state, write the pattern IDs matched by this
+            // state.
+            if dfa.is_match_state(state.id()) {
+                let plen = dfa.match_pattern_len(state.id());
+                // Write the actual pattern IDs with a u32 length prefix.
+                // First, zero-fill space.
+                let mut pos = sparse.len();
+                // Unwraps are OK since it's guaranteed that plen <=
+                // PatternID::LIMIT, which is in turn guaranteed to fit into a
+                // u32.
+                let zeros = size_of::<u32>()
+                    .checked_mul(plen)
+                    .unwrap()
+                    .checked_add(size_of::<u32>())
+                    .unwrap();
+                sparse.extend(iter::repeat(0).take(zeros));
+
+                // Now write the length prefix.
+                wire::NE::write_u32(
+                    // Will never fail since u32::MAX is invalid pattern ID.
+                    // Thus, the number of pattern IDs is representable by a
+                    // u32.
+                    plen.try_into().expect("pattern ID length fits in u32"),
+                    &mut sparse[pos..],
+                );
+                pos += size_of::<u32>();
+
+                // Now write the pattern IDs.
+                for &pid in dfa.pattern_id_slice(state.id()) {
+                    pos += wire::write_pattern_id::<wire::NE>(
+                        pid,
+                        &mut sparse[pos..],
+                    );
+                }
+            }
+
+            // And now add the accelerator, if one exists. An accelerator is
+            // at most 4 bytes and at least 1 byte. The first byte is the
+            // length, N. N bytes follow the length. The set of bytes that
+            // follow correspond (exhaustively) to the bytes that must be seen
+            // to leave this state.
+            let accel = dfa.accelerator(state.id());
+            sparse.push(accel.len().try_into().unwrap());
+            sparse.extend_from_slice(accel);
+        }
+
+        let mut new = DFA {
+            tt: Transitions {
+                sparse,
+                classes: dfa.byte_classes().clone(),
+                state_len: dfa.state_len(),
+                pattern_len: dfa.pattern_len(),
+            },
+            st: StartTable::from_dense_dfa(dfa, &remap)?,
+            special: dfa.special().remap(|id| remap[dfa.to_index(id)]),
+            pre: dfa.get_prefilter().map(|p| p.clone()),
+            quitset: dfa.quitset().clone(),
+            flags: dfa.flags().clone(),
+        };
+        // And here's our second pass. Iterate over all of the dense states
+        // again, and update the transitions in each of the states in the
+        // sparse DFA.
+        for old_state in dfa.states() {
+            let new_id = remap[dfa.to_index(old_state.id())];
+            let mut new_state = new.tt.state_mut(new_id);
+            let sparse = old_state.sparse_transitions();
+            for (i, (_, _, next)) in sparse.enumerate() {
+                let next = remap[dfa.to_index(next)];
+                new_state.set_next_at(i, next);
+            }
+        }
+        debug!(
+            "created sparse DFA, memory usage: {} (dense memory usage: {})",
+            new.memory_usage(),
+            dfa.memory_usage(),
+        );
+        Ok(new)
+    }
+}
+
+impl<T: AsRef<[u8]>> DFA<T> {
+    /// Cheaply return a borrowed version of this sparse DFA. Specifically, the
+    /// DFA returned always uses `&[u8]` for its transitions.
+    pub fn as_ref<'a>(&'a self) -> DFA<&'a [u8]> {
+        DFA {
+            tt: self.tt.as_ref(),
+            st: self.st.as_ref(),
+            special: self.special,
+            pre: self.pre.clone(),
+            quitset: self.quitset,
+            flags: self.flags,
+        }
+    }
+
+    /// Return an owned version of this sparse DFA. Specifically, the DFA
+    /// returned always uses `Vec<u8>` for its transitions.
+    ///
+    /// Effectively, this returns a sparse DFA whose transitions live on the
+    /// heap.
+    #[cfg(feature = "alloc")]
+    pub fn to_owned(&self) -> DFA<alloc::vec::Vec<u8>> {
+        DFA {
+            tt: self.tt.to_owned(),
+            st: self.st.to_owned(),
+            special: self.special,
+            pre: self.pre.clone(),
+            quitset: self.quitset,
+            flags: self.flags,
+        }
+    }
+
+    /// Returns the starting state configuration for this DFA.
+    ///
+    /// The default is [`StartKind::Both`], which means the DFA supports both
+    /// unanchored and anchored searches. However, this can generally lead to
+    /// bigger DFAs. Therefore, a DFA might be compiled with support for just
+    /// unanchored or anchored searches. In that case, running a search with
+    /// an unsupported configuration will panic.
+    pub fn start_kind(&self) -> StartKind {
+        self.st.kind
+    }
+
+    /// Returns true only if this DFA has starting states for each pattern.
+    ///
+    /// When a DFA has starting states for each pattern, then a search with the
+    /// DFA can be configured to only look for anchored matches of a specific
+    /// pattern. Specifically, APIs like [`Automaton::try_search_fwd`] can
+    /// accept a [`Anchored::Pattern`] if and only if this method returns true.
+    /// Otherwise, an error will be returned.
+    ///
+    /// Note that if the DFA is empty, this always returns false.
+    pub fn starts_for_each_pattern(&self) -> bool {
+        self.st.pattern_len.is_some()
+    }
+
+    /// Returns the equivalence classes that make up the alphabet for this DFA.
+    ///
+    /// Unless [`dense::Config::byte_classes`] was disabled, it is possible
+    /// that multiple distinct bytes are grouped into the same equivalence
+    /// class if it is impossible for them to discriminate between a match and
+    /// a non-match. This has the effect of reducing the overall alphabet size
+    /// and in turn potentially substantially reducing the size of the DFA's
+    /// transition table.
+    ///
+    /// The downside of using equivalence classes like this is that every state
+    /// transition will automatically use this map to convert an arbitrary
+    /// byte to its corresponding equivalence class. In practice this has a
+    /// negligible impact on performance.
+    pub fn byte_classes(&self) -> &ByteClasses {
+        &self.tt.classes
+    }
+
+    /// Returns the memory usage, in bytes, of this DFA.
+    ///
+    /// The memory usage is computed based on the number of bytes used to
+    /// represent this DFA.
+    ///
+    /// This does **not** include the stack size used up by this DFA. To
+    /// compute that, use `std::mem::size_of::<sparse::DFA>()`.
+    pub fn memory_usage(&self) -> usize {
+        self.tt.memory_usage() + self.st.memory_usage()
+    }
+}
+
+/// Routines for converting a sparse DFA to other representations, such as raw
+/// bytes suitable for persistent storage.
+impl<T: AsRef<[u8]>> DFA<T> {
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in little endian
+    /// format.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Note that unlike a [`dense::DFA`](crate::dfa::dense::DFA)'s
+    /// serialization methods, this does not add any initial padding to the
+    /// returned bytes. Padding isn't required for sparse DFAs since they have
+    /// no alignment requirements.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using to_bytes_little_endian would work on a little endian target.
+    /// let buf = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_little_endian(&self) -> Vec<u8> {
+        self.to_bytes::<wire::LE>()
+    }
+
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in big endian
+    /// format.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Note that unlike a [`dense::DFA`](crate::dfa::dense::DFA)'s
+    /// serialization methods, this does not add any initial padding to the
+    /// returned bytes. Padding isn't required for sparse DFAs since they have
+    /// no alignment requirements.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using to_bytes_big_endian would work on a big endian target.
+    /// let buf = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_big_endian(&self) -> Vec<u8> {
+        self.to_bytes::<wire::BE>()
+    }
+
+    /// Serialize this DFA as raw bytes to a `Vec<u8>` in native endian
+    /// format.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Note that unlike a [`dense::DFA`](crate::dfa::dense::DFA)'s
+    /// serialization methods, this does not add any initial padding to the
+    /// returned bytes. Padding isn't required for sparse DFAs since they have
+    /// no alignment requirements.
+    ///
+    /// Generally speaking, native endian format should only be used when
+    /// you know that the target you're compiling the DFA for matches the
+    /// endianness of the target on which you're compiling DFA. For example,
+    /// if serialization and deserialization happen in the same process or on
+    /// the same machine. Otherwise, when serializing a DFA for use in a
+    /// portable environment, you'll almost certainly want to serialize _both_
+    /// a little endian and a big endian version and then load the correct one
+    /// based on the target's configuration.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA:
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// let buf = original_dfa.to_bytes_native_endian();
+    /// // Even if buf has initial padding, DFA::from_bytes will automatically
+    /// // ignore it.
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "dfa-build")]
+    pub fn to_bytes_native_endian(&self) -> Vec<u8> {
+        self.to_bytes::<wire::NE>()
+    }
+
+    /// The implementation of the public `to_bytes` serialization methods,
+    /// which is generic over endianness.
+    #[cfg(feature = "dfa-build")]
+    fn to_bytes<E: Endian>(&self) -> Vec<u8> {
+        let mut buf = vec![0; self.write_to_len()];
+        // This should always succeed since the only possible serialization
+        // error is providing a buffer that's too small, but we've ensured that
+        // `buf` is big enough here.
+        self.write_to::<E>(&mut buf).unwrap();
+        buf
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in little endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA.
+    /// let mut buf = [0u8; 4 * (1<<10)];
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using write_to_little_endian would work on a little endian target.
+    /// let written = original_dfa.write_to_native_endian(&mut buf)?;
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_little_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.write_to::<wire::LE>(dst)
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in big endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA.
+    /// let mut buf = [0u8; 4 * (1<<10)];
+    /// // N.B. We use native endianness here to make the example work, but
+    /// // using write_to_big_endian would work on a big endian target.
+    /// let written = original_dfa.write_to_native_endian(&mut buf)?;
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_big_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.write_to::<wire::BE>(dst)
+    }
+
+    /// Serialize this DFA as raw bytes to the given slice, in native endian
+    /// format. Upon success, the total number of bytes written to `dst` is
+    /// returned.
+    ///
+    /// The written bytes are guaranteed to be deserialized correctly and
+    /// without errors in a semver compatible release of this crate by a
+    /// `DFA`'s deserialization APIs (assuming all other criteria for the
+    /// deserialization APIs has been satisfied):
+    ///
+    /// * [`DFA::from_bytes`]
+    /// * [`DFA::from_bytes_unchecked`]
+    ///
+    /// Generally speaking, native endian format should only be used when
+    /// you know that the target you're compiling the DFA for matches the
+    /// endianness of the target on which you're compiling DFA. For example,
+    /// if serialization and deserialization happen in the same process or on
+    /// the same machine. Otherwise, when serializing a DFA for use in a
+    /// portable environment, you'll almost certainly want to serialize _both_
+    /// a little endian and a big endian version and then load the correct one
+    /// based on the target's configuration.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the given destination slice is not big enough
+    /// to contain the full serialized DFA. If an error occurs, then nothing
+    /// is written to `dst`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize and deserialize a DFA without
+    /// dynamic memory allocation.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Create a 4KB buffer on the stack to store our serialized DFA.
+    /// let mut buf = [0u8; 4 * (1<<10)];
+    /// let written = original_dfa.write_to_native_endian(&mut buf)?;
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_native_endian(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        self.write_to::<wire::NE>(dst)
+    }
+
+    /// The implementation of the public `write_to` serialization methods,
+    /// which is generic over endianness.
+    fn write_to<E: Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let mut nw = 0;
+        nw += wire::write_label(LABEL, &mut dst[nw..])?;
+        nw += wire::write_endianness_check::<E>(&mut dst[nw..])?;
+        nw += wire::write_version::<E>(VERSION, &mut dst[nw..])?;
+        nw += {
+            // Currently unused, intended for future flexibility
+            E::write_u32(0, &mut dst[nw..]);
+            size_of::<u32>()
+        };
+        nw += self.flags.write_to::<E>(&mut dst[nw..])?;
+        nw += self.tt.write_to::<E>(&mut dst[nw..])?;
+        nw += self.st.write_to::<E>(&mut dst[nw..])?;
+        nw += self.special.write_to::<E>(&mut dst[nw..])?;
+        nw += self.quitset.write_to::<E>(&mut dst[nw..])?;
+        Ok(nw)
+    }
+
+    /// Return the total number of bytes required to serialize this DFA.
+    ///
+    /// This is useful for determining the size of the buffer required to pass
+    /// to one of the serialization routines:
+    ///
+    /// * [`DFA::write_to_little_endian`]
+    /// * [`DFA::write_to_big_endian`]
+    /// * [`DFA::write_to_native_endian`]
+    ///
+    /// Passing a buffer smaller than the size returned by this method will
+    /// result in a serialization error.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to dynamically allocate enough room to serialize
+    /// a sparse DFA.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// // Compile our original DFA.
+    /// let original_dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// let mut buf = vec![0; original_dfa.write_to_len()];
+    /// let written = original_dfa.write_to_native_endian(&mut buf)?;
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&buf[..written])?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn write_to_len(&self) -> usize {
+        wire::write_label_len(LABEL)
+        + wire::write_endianness_check_len()
+        + wire::write_version_len()
+        + size_of::<u32>() // unused, intended for future flexibility
+        + self.flags.write_to_len()
+        + self.tt.write_to_len()
+        + self.st.write_to_len()
+        + self.special.write_to_len()
+        + self.quitset.write_to_len()
+    }
+}
+
+impl<'a> DFA<&'a [u8]> {
+    /// Safely deserialize a sparse DFA with a specific state identifier
+    /// representation. Upon success, this returns both the deserialized DFA
+    /// and the number of bytes read from the given slice. Namely, the contents
+    /// of the slice beyond the DFA are not read.
+    ///
+    /// Deserializing a DFA using this routine will never allocate heap memory.
+    /// For safety purposes, the DFA's transitions will be verified such that
+    /// every transition points to a valid state. If this verification is too
+    /// costly, then a [`DFA::from_bytes_unchecked`] API is provided, which
+    /// will always execute in constant time.
+    ///
+    /// The bytes given must be generated by one of the serialization APIs
+    /// of a `DFA` using a semver compatible release of this crate. Those
+    /// include:
+    ///
+    /// * [`DFA::to_bytes_little_endian`]
+    /// * [`DFA::to_bytes_big_endian`]
+    /// * [`DFA::to_bytes_native_endian`]
+    /// * [`DFA::write_to_little_endian`]
+    /// * [`DFA::write_to_big_endian`]
+    /// * [`DFA::write_to_native_endian`]
+    ///
+    /// The `to_bytes` methods allocate and return a `Vec<u8>` for you. The
+    /// `write_to` methods do not allocate and write to an existing slice
+    /// (which may be on the stack). Since deserialization always uses the
+    /// native endianness of the target platform, the serialization API you use
+    /// should match the endianness of the target platform. (It's often a good
+    /// idea to generate serialized DFAs for both forms of endianness and then
+    /// load the correct one based on endianness.)
+    ///
+    /// # Errors
+    ///
+    /// Generally speaking, it's easier to state the conditions in which an
+    /// error is _not_ returned. All of the following must be true:
+    ///
+    /// * The bytes given must be produced by one of the serialization APIs
+    ///   on this DFA, as mentioned above.
+    /// * The endianness of the target platform matches the endianness used to
+    ///   serialized the provided DFA.
+    ///
+    /// If any of the above are not true, then an error will be returned.
+    ///
+    /// Note that unlike deserializing a
+    /// [`dense::DFA`](crate::dfa::dense::DFA), deserializing a sparse DFA has
+    /// no alignment requirements. That is, an alignment of `1` is valid.
+    ///
+    /// # Panics
+    ///
+    /// This routine will never panic for any input.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to serialize a DFA to raw bytes, deserialize it
+    /// and then use it for searching.
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// let initial = DFA::new("foo[0-9]+")?;
+    /// let bytes = initial.to_bytes_native_endian();
+    /// let dfa: DFA<&[u8]> = DFA::from_bytes(&bytes)?.0;
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: loading a DFA from static memory
+    ///
+    /// One use case this library supports is the ability to serialize a
+    /// DFA to disk and then use `include_bytes!` to store it in a compiled
+    /// Rust program. Those bytes can then be cheaply deserialized into a
+    /// `DFA` structure at runtime and used for searching without having to
+    /// re-compile the DFA (which can be quite costly).
+    ///
+    /// We can show this in two parts. The first part is serializing the DFA to
+    /// a file:
+    ///
+    /// ```no_run
+    /// use regex_automata::dfa::sparse::DFA;
+    ///
+    /// let dfa = DFA::new("foo[0-9]+")?;
+    ///
+    /// // Write a big endian serialized version of this DFA to a file.
+    /// let bytes = dfa.to_bytes_big_endian();
+    /// std::fs::write("foo.bigendian.dfa", &bytes)?;
+    ///
+    /// // Do it again, but this time for little endian.
+    /// let bytes = dfa.to_bytes_little_endian();
+    /// std::fs::write("foo.littleendian.dfa", &bytes)?;
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And now the second part is embedding the DFA into the compiled program
+    /// and deserializing it at runtime on first use. We use conditional
+    /// compilation to choose the correct endianness. We do not need to employ
+    /// any special tricks to ensure a proper alignment, since a sparse DFA has
+    /// no alignment requirements.
+    ///
+    /// ```no_run
+    /// use regex_automata::{
+    ///     dfa::{Automaton, sparse::DFA},
+    ///     util::lazy::Lazy,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// // This crate provides its own "lazy" type, kind of like
+    /// // lazy_static! or once_cell::sync::Lazy. But it works in no-alloc
+    /// // no-std environments and let's us write this using completely
+    /// // safe code.
+    /// static RE: Lazy<DFA<&'static [u8]>> = Lazy::new(|| {
+    ///     # const _: &str = stringify! {
+    ///     #[cfg(target_endian = "big")]
+    ///     static BYTES: &[u8] = include_bytes!("foo.bigendian.dfa");
+    ///     #[cfg(target_endian = "little")]
+    ///     static BYTES: &[u8] = include_bytes!("foo.littleendian.dfa");
+    ///     # };
+    ///     # static BYTES: &[u8] = b"";
+    ///
+    ///     let (dfa, _) = DFA::from_bytes(BYTES)
+    ///         .expect("serialized DFA should be valid");
+    ///     dfa
+    /// });
+    ///
+    /// let expected = Ok(Some(HalfMatch::must(0, 8)));
+    /// assert_eq!(expected, RE.try_search_fwd(&Input::new("foo12345")));
+    /// ```
+    ///
+    /// Alternatively, consider using
+    /// [`lazy_static`](https://crates.io/crates/lazy_static)
+    /// or
+    /// [`once_cell`](https://crates.io/crates/once_cell),
+    /// which will guarantee safety for you.
+    pub fn from_bytes(
+        slice: &'a [u8],
+    ) -> Result<(DFA<&'a [u8]>, usize), DeserializeError> {
+        // SAFETY: This is safe because we validate both the sparse transitions
+        // (by trying to decode every state) and start state ID list below. If
+        // either validation fails, then we return an error.
+        let (dfa, nread) = unsafe { DFA::from_bytes_unchecked(slice)? };
+        dfa.tt.validate(&dfa.special)?;
+        dfa.st.validate(&dfa.special, &dfa.tt)?;
+        // N.B. dfa.special doesn't have a way to do unchecked deserialization,
+        // so it has already been validated.
+        Ok((dfa, nread))
+    }
+
+    /// Deserialize a DFA with a specific state identifier representation in
+    /// constant time by omitting the verification of the validity of the
+    /// sparse transitions.
+    ///
+    /// This is just like [`DFA::from_bytes`], except it can potentially return
+    /// a DFA that exhibits undefined behavior if its transitions contains
+    /// invalid state identifiers.
+    ///
+    /// This routine is useful if you need to deserialize a DFA cheaply and
+    /// cannot afford the transition validation performed by `from_bytes`.
+    ///
+    /// # Safety
+    ///
+    /// This routine is not safe because it permits callers to provide
+    /// arbitrary transitions with possibly incorrect state identifiers. While
+    /// the various serialization routines will never return an incorrect
+    /// DFA, there is no guarantee that the bytes provided here are correct.
+    /// While `from_bytes_unchecked` will still do several forms of basic
+    /// validation, this routine does not check that the transitions themselves
+    /// are correct. Given an incorrect transition table, it is possible for
+    /// the search routines to access out-of-bounds memory because of explicit
+    /// bounds check elision.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{dfa::{Automaton, sparse::DFA}, HalfMatch, Input};
+    ///
+    /// let initial = DFA::new("foo[0-9]+")?;
+    /// let bytes = initial.to_bytes_native_endian();
+    /// // SAFETY: This is guaranteed to be safe since the bytes given come
+    /// // directly from a compatible serialization routine.
+    /// let dfa: DFA<&[u8]> = unsafe { DFA::from_bytes_unchecked(&bytes)?.0 };
+    ///
+    /// let expected = Some(HalfMatch::must(0, 8));
+    /// assert_eq!(expected, dfa.try_search_fwd(&Input::new("foo12345"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub unsafe fn from_bytes_unchecked(
+        slice: &'a [u8],
+    ) -> Result<(DFA<&'a [u8]>, usize), DeserializeError> {
+        let mut nr = 0;
+
+        nr += wire::read_label(&slice[nr..], LABEL)?;
+        nr += wire::read_endianness_check(&slice[nr..])?;
+        nr += wire::read_version(&slice[nr..], VERSION)?;
+
+        let _unused = wire::try_read_u32(&slice[nr..], "unused space")?;
+        nr += size_of::<u32>();
+
+        let (flags, nread) = Flags::from_bytes(&slice[nr..])?;
+        nr += nread;
+
+        let (tt, nread) = Transitions::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (st, nread) = StartTable::from_bytes_unchecked(&slice[nr..])?;
+        nr += nread;
+
+        let (special, nread) = Special::from_bytes(&slice[nr..])?;
+        nr += nread;
+        if special.max.as_usize() >= tt.sparse().len() {
+            return Err(DeserializeError::generic(
+                "max should not be greater than or equal to sparse bytes",
+            ));
+        }
+
+        let (quitset, nread) = ByteSet::from_bytes(&slice[nr..])?;
+        nr += nread;
+
+        // Prefilters don't support serialization, so they're always absent.
+        let pre = None;
+        Ok((DFA { tt, st, special, pre, quitset, flags }, nr))
+    }
+}
+
+impl<T: AsRef<[u8]>> fmt::Debug for DFA<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "sparse::DFA(")?;
+        for state in self.tt.states() {
+            fmt_state_indicator(f, self, state.id())?;
+            writeln!(f, "{:06?}: {:?}", state.id().as_usize(), state)?;
+        }
+        writeln!(f, "")?;
+        for (i, (start_id, anchored, sty)) in self.st.iter().enumerate() {
+            if i % self.st.stride == 0 {
+                match anchored {
+                    Anchored::No => writeln!(f, "START-GROUP(unanchored)")?,
+                    Anchored::Yes => writeln!(f, "START-GROUP(anchored)")?,
+                    Anchored::Pattern(pid) => writeln!(
+                        f,
+                        "START_GROUP(pattern: {:?})",
+                        pid.as_usize()
+                    )?,
+                }
+            }
+            writeln!(f, "  {:?} => {:06?}", sty, start_id.as_usize())?;
+        }
+        writeln!(f, "state length: {:?}", self.tt.state_len)?;
+        writeln!(f, "pattern length: {:?}", self.pattern_len())?;
+        writeln!(f, "flags: {:?}", self.flags)?;
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+// SAFETY: We assert that our implementation of each method is correct.
+unsafe impl<T: AsRef<[u8]>> Automaton for DFA<T> {
+    #[inline]
+    fn is_special_state(&self, id: StateID) -> bool {
+        self.special.is_special_state(id)
+    }
+
+    #[inline]
+    fn is_dead_state(&self, id: StateID) -> bool {
+        self.special.is_dead_state(id)
+    }
+
+    #[inline]
+    fn is_quit_state(&self, id: StateID) -> bool {
+        self.special.is_quit_state(id)
+    }
+
+    #[inline]
+    fn is_match_state(&self, id: StateID) -> bool {
+        self.special.is_match_state(id)
+    }
+
+    #[inline]
+    fn is_start_state(&self, id: StateID) -> bool {
+        self.special.is_start_state(id)
+    }
+
+    #[inline]
+    fn is_accel_state(&self, id: StateID) -> bool {
+        self.special.is_accel_state(id)
+    }
+
+    // This is marked as inline to help dramatically boost sparse searching,
+    // which decodes each state it enters to follow the next transition.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next_state(&self, current: StateID, input: u8) -> StateID {
+        let input = self.tt.classes.get(input);
+        self.tt.state(current).next(input)
+    }
+
+    #[inline]
+    unsafe fn next_state_unchecked(
+        &self,
+        current: StateID,
+        input: u8,
+    ) -> StateID {
+        self.next_state(current, input)
+    }
+
+    #[inline]
+    fn next_eoi_state(&self, current: StateID) -> StateID {
+        self.tt.state(current).next_eoi()
+    }
+
+    #[inline]
+    fn pattern_len(&self) -> usize {
+        self.tt.pattern_len
+    }
+
+    #[inline]
+    fn match_len(&self, id: StateID) -> usize {
+        self.tt.state(id).pattern_len()
+    }
+
+    #[inline]
+    fn match_pattern(&self, id: StateID, match_index: usize) -> PatternID {
+        // This is an optimization for the very common case of a DFA with a
+        // single pattern. This conditional avoids a somewhat more costly path
+        // that finds the pattern ID from the state machine, which requires
+        // a bit of slicing/pointer-chasing. This optimization tends to only
+        // matter when matches are frequent.
+        if self.tt.pattern_len == 1 {
+            return PatternID::ZERO;
+        }
+        self.tt.state(id).pattern_id(match_index)
+    }
+
+    #[inline]
+    fn has_empty(&self) -> bool {
+        self.flags.has_empty
+    }
+
+    #[inline]
+    fn is_utf8(&self) -> bool {
+        self.flags.is_utf8
+    }
+
+    #[inline]
+    fn is_always_start_anchored(&self) -> bool {
+        self.flags.is_always_start_anchored
+    }
+
+    #[inline]
+    fn start_state_forward(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        if !self.quitset.is_empty() && input.start() > 0 {
+            let offset = input.start() - 1;
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start = self.st.start_map.fwd(&input);
+        self.st.start(input, start)
+    }
+
+    #[inline]
+    fn start_state_reverse(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<StateID, MatchError> {
+        if !self.quitset.is_empty() && input.end() < input.haystack().len() {
+            let offset = input.end();
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start = self.st.start_map.rev(&input);
+        self.st.start(input, start)
+    }
+
+    #[inline]
+    fn universal_start_state(&self, mode: Anchored) -> Option<StateID> {
+        match mode {
+            Anchored::No => self.st.universal_start_unanchored,
+            Anchored::Yes => self.st.universal_start_anchored,
+            Anchored::Pattern(_) => None,
+        }
+    }
+
+    #[inline]
+    fn accelerator(&self, id: StateID) -> &[u8] {
+        self.tt.state(id).accelerator()
+    }
+
+    #[inline]
+    fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref()
+    }
+}
+
+/// The transition table portion of a sparse DFA.
+///
+/// The transition table is the core part of the DFA in that it describes how
+/// to move from one state to another based on the input sequence observed.
+///
+/// Unlike a typical dense table based DFA, states in a sparse transition
+/// table have variable size. That is, states with more transitions use more
+/// space than states with fewer transitions. This means that finding the next
+/// transition takes more work than with a dense DFA, but also typically uses
+/// much less space.
+#[derive(Clone)]
+struct Transitions<T> {
+    /// The raw encoding of each state in this DFA.
+    ///
+    /// Each state has the following information:
+    ///
+    /// * A set of transitions to subsequent states. Transitions to the dead
+    ///   state are omitted.
+    /// * If the state can be accelerated, then any additional accelerator
+    ///   information.
+    /// * If the state is a match state, then the state contains all pattern
+    ///   IDs that match when in that state.
+    ///
+    /// To decode a state, use Transitions::state.
+    ///
+    /// In practice, T is either Vec<u8> or &[u8].
+    sparse: T,
+    /// A set of equivalence classes, where a single equivalence class
+    /// represents a set of bytes that never discriminate between a match
+    /// and a non-match in the DFA. Each equivalence class corresponds to a
+    /// single character in this DFA's alphabet, where the maximum number of
+    /// characters is 257 (each possible value of a byte plus the special
+    /// EOI transition). Consequently, the number of equivalence classes
+    /// corresponds to the number of transitions for each DFA state. Note
+    /// though that the *space* used by each DFA state in the transition table
+    /// may be larger. The total space used by each DFA state is known as the
+    /// stride and is documented above.
+    ///
+    /// The only time the number of equivalence classes is fewer than 257 is
+    /// if the DFA's kind uses byte classes which is the default. Equivalence
+    /// classes should generally only be disabled when debugging, so that
+    /// the transitions themselves aren't obscured. Disabling them has no
+    /// other benefit, since the equivalence class map is always used while
+    /// searching. In the vast majority of cases, the number of equivalence
+    /// classes is substantially smaller than 257, particularly when large
+    /// Unicode classes aren't used.
+    ///
+    /// N.B. Equivalence classes aren't particularly useful in a sparse DFA
+    /// in the current implementation, since equivalence classes generally tend
+    /// to correspond to continuous ranges of bytes that map to the same
+    /// transition. So in a sparse DFA, equivalence classes don't really lead
+    /// to a space savings. In the future, it would be good to try and remove
+    /// them from sparse DFAs entirely, but requires a bit of work since sparse
+    /// DFAs are built from dense DFAs, which are in turn built on top of
+    /// equivalence classes.
+    classes: ByteClasses,
+    /// The total number of states in this DFA. Note that a DFA always has at
+    /// least one state---the dead state---even the empty DFA. In particular,
+    /// the dead state always has ID 0 and is correspondingly always the first
+    /// state. The dead state is never a match state.
+    state_len: usize,
+    /// The total number of unique patterns represented by these match states.
+    pattern_len: usize,
+}
+
+impl<'a> Transitions<&'a [u8]> {
+    unsafe fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(Transitions<&'a [u8]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        let (state_len, nr) =
+            wire::try_read_u32_as_usize(&slice, "state length")?;
+        slice = &slice[nr..];
+
+        let (pattern_len, nr) =
+            wire::try_read_u32_as_usize(&slice, "pattern length")?;
+        slice = &slice[nr..];
+
+        let (classes, nr) = ByteClasses::from_bytes(&slice)?;
+        slice = &slice[nr..];
+
+        let (len, nr) =
+            wire::try_read_u32_as_usize(&slice, "sparse transitions length")?;
+        slice = &slice[nr..];
+
+        wire::check_slice_len(slice, len, "sparse states byte length")?;
+        let sparse = &slice[..len];
+        slice = &slice[len..];
+
+        let trans = Transitions { sparse, classes, state_len, pattern_len };
+        Ok((trans, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+impl<T: AsRef<[u8]>> Transitions<T> {
+    /// Writes a serialized form of this transition table to the buffer given.
+    /// If the buffer is too small, then an error is returned. To determine
+    /// how big the buffer must be, use `write_to_len`.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small(
+                "sparse transition table",
+            ));
+        }
+        dst = &mut dst[..nwrite];
+
+        // write state length
+        E::write_u32(u32::try_from(self.state_len).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write pattern length
+        E::write_u32(u32::try_from(self.pattern_len).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write byte class map
+        let n = self.classes.write_to(dst)?;
+        dst = &mut dst[n..];
+
+        // write number of bytes in sparse transitions
+        E::write_u32(u32::try_from(self.sparse().len()).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+
+        // write actual transitions
+        let mut id = DEAD;
+        while id.as_usize() < self.sparse().len() {
+            let state = self.state(id);
+            let n = state.write_to::<E>(&mut dst)?;
+            dst = &mut dst[n..];
+            // The next ID is the offset immediately following `state`.
+            id = StateID::new(id.as_usize() + state.write_to_len()).unwrap();
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of this transition
+    /// table will use.
+    fn write_to_len(&self) -> usize {
+        size_of::<u32>()   // state length
+        + size_of::<u32>() // pattern length
+        + self.classes.write_to_len()
+        + size_of::<u32>() // sparse transitions length
+        + self.sparse().len()
+    }
+
+    /// Validates that every state ID in this transition table is valid.
+    ///
+    /// That is, every state ID can be used to correctly index a state in this
+    /// table.
+    fn validate(&self, sp: &Special) -> Result<(), DeserializeError> {
+        // In order to validate everything, we not only need to make sure we
+        // can decode every state, but that every transition in every state
+        // points to a valid state. There are many duplicative transitions, so
+        // we record state IDs that we've verified so that we don't redo the
+        // decoding work.
+        //
+        // Except, when in no_std mode, we don't have dynamic memory allocation
+        // available to us, so we skip this optimization. It's not clear
+        // whether doing something more clever is worth it just yet. If you're
+        // profiling this code and need it to run faster, please file an issue.
+        //
+        // OK, so we also use this to record the set of valid state IDs. Since
+        // it is possible for a transition to point to an invalid state ID that
+        // still (somehow) deserializes to a valid state. So we need to make
+        // sure our transitions are limited to actually correct state IDs.
+        // The problem is, I'm not sure how to do this verification step in
+        // no-std no-alloc mode. I think we'd *have* to store the set of valid
+        // state IDs in the DFA itself. For now, we don't do this verification
+        // in no-std no-alloc mode. The worst thing that can happen is an
+        // incorrect result. But no panics or memory safety problems should
+        // result. Because we still do validate that the state itself is
+        // "valid" in the sense that everything it points to actually exists.
+        //
+        // ---AG
+        struct Seen {
+            #[cfg(feature = "alloc")]
+            set: alloc::collections::BTreeSet<StateID>,
+            #[cfg(not(feature = "alloc"))]
+            set: core::marker::PhantomData<StateID>,
+        }
+
+        #[cfg(feature = "alloc")]
+        impl Seen {
+            fn new() -> Seen {
+                Seen { set: alloc::collections::BTreeSet::new() }
+            }
+            fn insert(&mut self, id: StateID) {
+                self.set.insert(id);
+            }
+            fn contains(&self, id: &StateID) -> bool {
+                self.set.contains(id)
+            }
+        }
+
+        #[cfg(not(feature = "alloc"))]
+        impl Seen {
+            fn new() -> Seen {
+                Seen { set: core::marker::PhantomData }
+            }
+            fn insert(&mut self, _id: StateID) {}
+            fn contains(&self, _id: &StateID) -> bool {
+                false
+            }
+        }
+
+        let mut verified: Seen = Seen::new();
+        // We need to make sure that we decode the correct number of states.
+        // Otherwise, an empty set of transitions would validate even if the
+        // recorded state length is non-empty.
+        let mut len = 0;
+        // We can't use the self.states() iterator because it assumes the state
+        // encodings are valid. It could panic if they aren't.
+        let mut id = DEAD;
+        while id.as_usize() < self.sparse().len() {
+            // Before we even decode the state, we check that the ID itself
+            // is well formed. That is, if it's a special state then it must
+            // actually be a quit, dead, accel, match or start state.
+            if sp.is_special_state(id) {
+                let is_actually_special = sp.is_dead_state(id)
+                    || sp.is_quit_state(id)
+                    || sp.is_match_state(id)
+                    || sp.is_start_state(id)
+                    || sp.is_accel_state(id);
+                if !is_actually_special {
+                    // This is kind of a cryptic error message...
+                    return Err(DeserializeError::generic(
+                        "found sparse state tagged as special but \
+                         wasn't actually special",
+                    ));
+                }
+            }
+            let state = self.try_state(sp, id)?;
+            verified.insert(id);
+            // The next ID should be the offset immediately following `state`.
+            id = StateID::new(wire::add(
+                id.as_usize(),
+                state.write_to_len(),
+                "next state ID offset",
+            )?)
+            .map_err(|err| {
+                DeserializeError::state_id_error(err, "next state ID offset")
+            })?;
+            len += 1;
+        }
+        // Now that we've checked that all top-level states are correct and
+        // importantly, collected a set of valid state IDs, we have all the
+        // information we need to check that all transitions are correct too.
+        //
+        // Note that we can't use `valid_ids` to iterate because it will
+        // be empty in no-std no-alloc contexts. (And yes, that means our
+        // verification isn't quite as good.) We can use `self.states()`
+        // though at least, since we know that all states can at least be
+        // decoded and traversed correctly.
+        for state in self.states() {
+            // Check that all transitions in this state are correct.
+            for i in 0..state.ntrans {
+                let to = state.next_at(i);
+                // For no-alloc, we just check that the state can decode. It is
+                // technically possible that the state ID could still point to
+                // a non-existent state even if it decodes (fuzzing proved this
+                // to be true), but it shouldn't result in any memory unsafety
+                // or panics in non-debug mode.
+                #[cfg(not(feature = "alloc"))]
+                {
+                    let _ = self.try_state(sp, to)?;
+                }
+                #[cfg(feature = "alloc")]
+                {
+                    if !verified.contains(&to) {
+                        return Err(DeserializeError::generic(
+                            "found transition that points to a \
+                             non-existent state",
+                        ));
+                    }
+                }
+            }
+        }
+        if len != self.state_len {
+            return Err(DeserializeError::generic(
+                "mismatching sparse state length",
+            ));
+        }
+        Ok(())
+    }
+
+    /// Converts these transitions to a borrowed value.
+    fn as_ref(&self) -> Transitions<&'_ [u8]> {
+        Transitions {
+            sparse: self.sparse(),
+            classes: self.classes.clone(),
+            state_len: self.state_len,
+            pattern_len: self.pattern_len,
+        }
+    }
+
+    /// Converts these transitions to an owned value.
+    #[cfg(feature = "alloc")]
+    fn to_owned(&self) -> Transitions<alloc::vec::Vec<u8>> {
+        Transitions {
+            sparse: self.sparse().to_vec(),
+            classes: self.classes.clone(),
+            state_len: self.state_len,
+            pattern_len: self.pattern_len,
+        }
+    }
+
+    /// Return a convenient representation of the given state.
+    ///
+    /// This panics if the state is invalid.
+    ///
+    /// This is marked as inline to help dramatically boost sparse searching,
+    /// which decodes each state it enters to follow the next transition. Other
+    /// functions involved are also inlined, which should hopefully eliminate
+    /// a lot of the extraneous decoding that is never needed just to follow
+    /// the next transition.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn state(&self, id: StateID) -> State<'_> {
+        let mut state = &self.sparse()[id.as_usize()..];
+        let mut ntrans = wire::read_u16(&state).as_usize();
+        let is_match = (1 << 15) & ntrans != 0;
+        ntrans &= !(1 << 15);
+        state = &state[2..];
+
+        let (input_ranges, state) = state.split_at(ntrans * 2);
+        let (next, state) = state.split_at(ntrans * StateID::SIZE);
+        let (pattern_ids, state) = if is_match {
+            let npats = wire::read_u32(&state).as_usize();
+            state[4..].split_at(npats * 4)
+        } else {
+            (&[][..], state)
+        };
+
+        let accel_len = usize::from(state[0]);
+        let accel = &state[1..accel_len + 1];
+        State { id, is_match, ntrans, input_ranges, next, pattern_ids, accel }
+    }
+
+    /// Like `state`, but will return an error if the state encoding is
+    /// invalid. This is useful for verifying states after deserialization,
+    /// which is required for a safe deserialization API.
+    ///
+    /// Note that this only verifies that this state is decodable and that
+    /// all of its data is consistent. It does not verify that its state ID
+    /// transitions point to valid states themselves, nor does it verify that
+    /// every pattern ID is valid.
+    fn try_state(
+        &self,
+        sp: &Special,
+        id: StateID,
+    ) -> Result<State<'_>, DeserializeError> {
+        if id.as_usize() > self.sparse().len() {
+            return Err(DeserializeError::generic(
+                "invalid caller provided sparse state ID",
+            ));
+        }
+        let mut state = &self.sparse()[id.as_usize()..];
+        // Encoding format starts with a u16 that stores the total number of
+        // transitions in this state.
+        let (mut ntrans, _) =
+            wire::try_read_u16_as_usize(state, "state transition length")?;
+        let is_match = ((1 << 15) & ntrans) != 0;
+        ntrans &= !(1 << 15);
+        state = &state[2..];
+        if ntrans > 257 || ntrans == 0 {
+            return Err(DeserializeError::generic(
+                "invalid transition length",
+            ));
+        }
+        if is_match && !sp.is_match_state(id) {
+            return Err(DeserializeError::generic(
+                "state marked as match but not in match ID range",
+            ));
+        } else if !is_match && sp.is_match_state(id) {
+            return Err(DeserializeError::generic(
+                "state in match ID range but not marked as match state",
+            ));
+        }
+
+        // Each transition has two pieces: an inclusive range of bytes on which
+        // it is defined, and the state ID that those bytes transition to. The
+        // pairs come first, followed by a corresponding sequence of state IDs.
+        let input_ranges_len = ntrans.checked_mul(2).unwrap();
+        wire::check_slice_len(state, input_ranges_len, "sparse byte pairs")?;
+        let (input_ranges, state) = state.split_at(input_ranges_len);
+        // Every range should be of the form A-B, where A<=B.
+        for pair in input_ranges.chunks(2) {
+            let (start, end) = (pair[0], pair[1]);
+            if start > end {
+                return Err(DeserializeError::generic("invalid input range"));
+            }
+        }
+
+        // And now extract the corresponding sequence of state IDs. We leave
+        // this sequence as a &[u8] instead of a &[S] because sparse DFAs do
+        // not have any alignment requirements.
+        let next_len = ntrans
+            .checked_mul(self.id_len())
+            .expect("state size * #trans should always fit in a usize");
+        wire::check_slice_len(state, next_len, "sparse trans state IDs")?;
+        let (next, state) = state.split_at(next_len);
+        // We can at least verify that every state ID is in bounds.
+        for idbytes in next.chunks(self.id_len()) {
+            let (id, _) =
+                wire::read_state_id(idbytes, "sparse state ID in try_state")?;
+            wire::check_slice_len(
+                self.sparse(),
+                id.as_usize(),
+                "invalid sparse state ID",
+            )?;
+        }
+
+        // If this is a match state, then read the pattern IDs for this state.
+        // Pattern IDs is a u32-length prefixed sequence of native endian
+        // encoded 32-bit integers.
+        let (pattern_ids, state) = if is_match {
+            let (npats, nr) =
+                wire::try_read_u32_as_usize(state, "pattern ID length")?;
+            let state = &state[nr..];
+            if npats == 0 {
+                return Err(DeserializeError::generic(
+                    "state marked as a match, but has no pattern IDs",
+                ));
+            }
+
+            let pattern_ids_len =
+                wire::mul(npats, 4, "sparse pattern ID byte length")?;
+            wire::check_slice_len(
+                state,
+                pattern_ids_len,
+                "sparse pattern IDs",
+            )?;
+            let (pattern_ids, state) = state.split_at(pattern_ids_len);
+            for patbytes in pattern_ids.chunks(PatternID::SIZE) {
+                wire::read_pattern_id(
+                    patbytes,
+                    "sparse pattern ID in try_state",
+                )?;
+            }
+            (pattern_ids, state)
+        } else {
+            (&[][..], state)
+        };
+
+        // Now read this state's accelerator info. The first byte is the length
+        // of the accelerator, which is typically 0 (for no acceleration) but
+        // is no bigger than 3. The length indicates the number of bytes that
+        // follow, where each byte corresponds to a transition out of this
+        // state.
+        if state.is_empty() {
+            return Err(DeserializeError::generic("no accelerator length"));
+        }
+        let (accel_len, state) = (usize::from(state[0]), &state[1..]);
+
+        if accel_len > 3 {
+            return Err(DeserializeError::generic(
+                "sparse invalid accelerator length",
+            ));
+        } else if accel_len == 0 && sp.is_accel_state(id) {
+            return Err(DeserializeError::generic(
+                "got no accelerators in state, but in accelerator ID range",
+            ));
+        } else if accel_len > 0 && !sp.is_accel_state(id) {
+            return Err(DeserializeError::generic(
+                "state in accelerator ID range, but has no accelerators",
+            ));
+        }
+
+        wire::check_slice_len(
+            state,
+            accel_len,
+            "sparse corrupt accelerator length",
+        )?;
+        let (accel, _) = (&state[..accel_len], &state[accel_len..]);
+
+        let state = State {
+            id,
+            is_match,
+            ntrans,
+            input_ranges,
+            next,
+            pattern_ids,
+            accel,
+        };
+        if sp.is_quit_state(state.next_at(state.ntrans - 1)) {
+            return Err(DeserializeError::generic(
+                "state with EOI transition to quit state is illegal",
+            ));
+        }
+        Ok(state)
+    }
+
+    /// Return an iterator over all of the states in this DFA.
+    ///
+    /// The iterator returned yields tuples, where the first element is the
+    /// state ID and the second element is the state itself.
+    fn states(&self) -> StateIter<'_, T> {
+        StateIter { trans: self, id: DEAD.as_usize() }
+    }
+
+    /// Returns the sparse transitions as raw bytes.
+    fn sparse(&self) -> &[u8] {
+        self.sparse.as_ref()
+    }
+
+    /// Returns the number of bytes represented by a single state ID.
+    fn id_len(&self) -> usize {
+        StateID::SIZE
+    }
+
+    /// Return the memory usage, in bytes, of these transitions.
+    ///
+    /// This does not include the size of a `Transitions` value itself.
+    fn memory_usage(&self) -> usize {
+        self.sparse().len()
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl<T: AsMut<[u8]>> Transitions<T> {
+    /// Return a convenient mutable representation of the given state.
+    /// This panics if the state is invalid.
+    fn state_mut(&mut self, id: StateID) -> StateMut<'_> {
+        let mut state = &mut self.sparse_mut()[id.as_usize()..];
+        let mut ntrans = wire::read_u16(&state).as_usize();
+        let is_match = (1 << 15) & ntrans != 0;
+        ntrans &= !(1 << 15);
+        state = &mut state[2..];
+
+        let (input_ranges, state) = state.split_at_mut(ntrans * 2);
+        let (next, state) = state.split_at_mut(ntrans * StateID::SIZE);
+        let (pattern_ids, state) = if is_match {
+            let npats = wire::read_u32(&state).as_usize();
+            state[4..].split_at_mut(npats * 4)
+        } else {
+            (&mut [][..], state)
+        };
+
+        let accel_len = usize::from(state[0]);
+        let accel = &mut state[1..accel_len + 1];
+        StateMut {
+            id,
+            is_match,
+            ntrans,
+            input_ranges,
+            next,
+            pattern_ids,
+            accel,
+        }
+    }
+
+    /// Returns the sparse transitions as raw mutable bytes.
+    fn sparse_mut(&mut self) -> &mut [u8] {
+        self.sparse.as_mut()
+    }
+}
+
+/// The set of all possible starting states in a DFA.
+///
+/// See the eponymous type in the `dense` module for more details. This type
+/// is very similar to `dense::StartTable`, except that its underlying
+/// representation is `&[u8]` instead of `&[S]`. (The latter would require
+/// sparse DFAs to be aligned, which is explicitly something we do not require
+/// because we don't really need it.)
+#[derive(Clone)]
+struct StartTable<T> {
+    /// The initial start state IDs as a contiguous table of native endian
+    /// encoded integers, represented by `S`.
+    ///
+    /// In practice, T is either Vec<u8> or &[u8] and has no alignment
+    /// requirements.
+    ///
+    /// The first `2 * stride` (currently always 8) entries always correspond
+    /// to the starts states for the entire DFA, with the first 4 entries being
+    /// for unanchored searches and the second 4 entries being for anchored
+    /// searches. To keep things simple, we always use 8 entries even if the
+    /// `StartKind` is not both.
+    ///
+    /// After that, there are `stride * patterns` state IDs, where `patterns`
+    /// may be zero in the case of a DFA with no patterns or in the case where
+    /// the DFA was built without enabling starting states for each pattern.
+    table: T,
+    /// The starting state configuration supported. When 'both', both
+    /// unanchored and anchored searches work. When 'unanchored', anchored
+    /// searches panic. When 'anchored', unanchored searches panic.
+    kind: StartKind,
+    /// The start state configuration for every possible byte.
+    start_map: StartByteMap,
+    /// The number of starting state IDs per pattern.
+    stride: usize,
+    /// The total number of patterns for which starting states are encoded.
+    /// This is `None` for DFAs that were built without start states for each
+    /// pattern. Thus, one cannot use this field to say how many patterns
+    /// are in the DFA in all cases. It is specific to how many patterns are
+    /// represented in this start table.
+    pattern_len: Option<usize>,
+    /// The universal starting state for unanchored searches. This is only
+    /// present when the DFA supports unanchored searches and when all starting
+    /// state IDs for an unanchored search are equivalent.
+    universal_start_unanchored: Option<StateID>,
+    /// The universal starting state for anchored searches. This is only
+    /// present when the DFA supports anchored searches and when all starting
+    /// state IDs for an anchored search are equivalent.
+    universal_start_anchored: Option<StateID>,
+}
+
+#[cfg(feature = "dfa-build")]
+impl StartTable<Vec<u8>> {
+    fn new<T: AsRef<[u32]>>(
+        dfa: &dense::DFA<T>,
+        pattern_len: Option<usize>,
+    ) -> StartTable<Vec<u8>> {
+        let stride = Start::len();
+        // This is OK since the only way we're here is if a dense DFA could be
+        // constructed successfully, which uses the same space.
+        let len = stride
+            .checked_mul(pattern_len.unwrap_or(0))
+            .unwrap()
+            .checked_add(stride.checked_mul(2).unwrap())
+            .unwrap()
+            .checked_mul(StateID::SIZE)
+            .unwrap();
+        StartTable {
+            table: vec![0; len],
+            kind: dfa.start_kind(),
+            start_map: dfa.start_map().clone(),
+            stride,
+            pattern_len,
+            universal_start_unanchored: dfa
+                .universal_start_state(Anchored::No),
+            universal_start_anchored: dfa.universal_start_state(Anchored::Yes),
+        }
+    }
+
+    fn from_dense_dfa<T: AsRef<[u32]>>(
+        dfa: &dense::DFA<T>,
+        remap: &[StateID],
+    ) -> Result<StartTable<Vec<u8>>, BuildError> {
+        // Unless the DFA has start states compiled for each pattern, then
+        // as far as the starting state table is concerned, there are zero
+        // patterns to account for. It will instead only store starting states
+        // for the entire DFA.
+        let start_pattern_len = if dfa.starts_for_each_pattern() {
+            Some(dfa.pattern_len())
+        } else {
+            None
+        };
+        let mut sl = StartTable::new(dfa, start_pattern_len);
+        for (old_start_id, anchored, sty) in dfa.starts() {
+            let new_start_id = remap[dfa.to_index(old_start_id)];
+            sl.set_start(anchored, sty, new_start_id);
+        }
+        Ok(sl)
+    }
+}
+
+impl<'a> StartTable<&'a [u8]> {
+    unsafe fn from_bytes_unchecked(
+        mut slice: &'a [u8],
+    ) -> Result<(StartTable<&'a [u8]>, usize), DeserializeError> {
+        let slice_start = slice.as_ptr().as_usize();
+
+        let (kind, nr) = StartKind::from_bytes(slice)?;
+        slice = &slice[nr..];
+
+        let (start_map, nr) = StartByteMap::from_bytes(slice)?;
+        slice = &slice[nr..];
+
+        let (stride, nr) =
+            wire::try_read_u32_as_usize(slice, "sparse start table stride")?;
+        slice = &slice[nr..];
+        if stride != Start::len() {
+            return Err(DeserializeError::generic(
+                "invalid sparse starting table stride",
+            ));
+        }
+
+        let (maybe_pattern_len, nr) =
+            wire::try_read_u32_as_usize(slice, "sparse start table patterns")?;
+        slice = &slice[nr..];
+        let pattern_len = if maybe_pattern_len.as_u32() == u32::MAX {
+            None
+        } else {
+            Some(maybe_pattern_len)
+        };
+        if pattern_len.map_or(false, |len| len > PatternID::LIMIT) {
+            return Err(DeserializeError::generic(
+                "sparse invalid number of patterns",
+            ));
+        }
+
+        let (universal_unanchored, nr) =
+            wire::try_read_u32(slice, "universal unanchored start")?;
+        slice = &slice[nr..];
+        let universal_start_unanchored = if universal_unanchored == u32::MAX {
+            None
+        } else {
+            Some(StateID::try_from(universal_unanchored).map_err(|e| {
+                DeserializeError::state_id_error(
+                    e,
+                    "universal unanchored start",
+                )
+            })?)
+        };
+
+        let (universal_anchored, nr) =
+            wire::try_read_u32(slice, "universal anchored start")?;
+        slice = &slice[nr..];
+        let universal_start_anchored = if universal_anchored == u32::MAX {
+            None
+        } else {
+            Some(StateID::try_from(universal_anchored).map_err(|e| {
+                DeserializeError::state_id_error(e, "universal anchored start")
+            })?)
+        };
+
+        let pattern_table_size = wire::mul(
+            stride,
+            pattern_len.unwrap_or(0),
+            "sparse invalid pattern length",
+        )?;
+        // Our start states always start with a single stride of start states
+        // for the entire automaton which permit it to match any pattern. What
+        // follows it are an optional set of start states for each pattern.
+        let start_state_len = wire::add(
+            wire::mul(2, stride, "start state stride too big")?,
+            pattern_table_size,
+            "sparse invalid 'any' pattern starts size",
+        )?;
+        let table_bytes_len = wire::mul(
+            start_state_len,
+            StateID::SIZE,
+            "sparse pattern table bytes length",
+        )?;
+        wire::check_slice_len(
+            slice,
+            table_bytes_len,
+            "sparse start ID table",
+        )?;
+        let table = &slice[..table_bytes_len];
+        slice = &slice[table_bytes_len..];
+
+        let sl = StartTable {
+            table,
+            kind,
+            start_map,
+            stride,
+            pattern_len,
+            universal_start_unanchored,
+            universal_start_anchored,
+        };
+        Ok((sl, slice.as_ptr().as_usize() - slice_start))
+    }
+}
+
+impl<T: AsRef<[u8]>> StartTable<T> {
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small(
+                "sparse starting table ids",
+            ));
+        }
+        dst = &mut dst[..nwrite];
+
+        // write start kind
+        let nw = self.kind.write_to::<E>(dst)?;
+        dst = &mut dst[nw..];
+        // write start byte map
+        let nw = self.start_map.write_to(dst)?;
+        dst = &mut dst[nw..];
+        // write stride
+        E::write_u32(u32::try_from(self.stride).unwrap(), dst);
+        dst = &mut dst[size_of::<u32>()..];
+        // write pattern length
+        E::write_u32(
+            u32::try_from(self.pattern_len.unwrap_or(0xFFFF_FFFF)).unwrap(),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write universal start unanchored state id, u32::MAX if absent
+        E::write_u32(
+            self.universal_start_unanchored
+                .map_or(u32::MAX, |sid| sid.as_u32()),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write universal start anchored state id, u32::MAX if absent
+        E::write_u32(
+            self.universal_start_anchored.map_or(u32::MAX, |sid| sid.as_u32()),
+            dst,
+        );
+        dst = &mut dst[size_of::<u32>()..];
+        // write start IDs
+        for (sid, _, _) in self.iter() {
+            E::write_u32(sid.as_u32(), dst);
+            dst = &mut dst[StateID::SIZE..];
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the number of bytes the serialized form of this transition
+    /// table will use.
+    fn write_to_len(&self) -> usize {
+        self.kind.write_to_len()
+        + self.start_map.write_to_len()
+        + size_of::<u32>() // stride
+        + size_of::<u32>() // # patterns
+        + size_of::<u32>() // universal unanchored start
+        + size_of::<u32>() // universal anchored start
+        + self.table().len()
+    }
+
+    /// Validates that every starting state ID in this table is valid.
+    ///
+    /// That is, every starting state ID can be used to correctly decode a
+    /// state in the DFA's sparse transitions.
+    fn validate(
+        &self,
+        sp: &Special,
+        trans: &Transitions<T>,
+    ) -> Result<(), DeserializeError> {
+        for (id, _, _) in self.iter() {
+            if sp.is_match_state(id) {
+                return Err(DeserializeError::generic(
+                    "start states cannot be match states",
+                ));
+            }
+            // Confirm that the start state points to a valid state.
+            let state = trans.try_state(sp, id)?;
+            // And like for the transition table, confirm that the transitions
+            // on all start states themselves point to a valid state.
+            //
+            // It'd probably be better to integrate this validation with the
+            // transition table, or otherwise store a sorted sequence of all
+            // valid state IDs in the sparse DFA itself. That way, we could
+            // check that every pointer to a state corresponds precisely to a
+            // correct and valid state.
+            for i in 0..state.ntrans {
+                let to = state.next_at(i);
+                let _ = trans.try_state(sp, to)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Converts this start list to a borrowed value.
+    fn as_ref(&self) -> StartTable<&'_ [u8]> {
+        StartTable {
+            table: self.table(),
+            kind: self.kind,
+            start_map: self.start_map.clone(),
+            stride: self.stride,
+            pattern_len: self.pattern_len,
+            universal_start_unanchored: self.universal_start_unanchored,
+            universal_start_anchored: self.universal_start_anchored,
+        }
+    }
+
+    /// Converts this start list to an owned value.
+    #[cfg(feature = "alloc")]
+    fn to_owned(&self) -> StartTable<alloc::vec::Vec<u8>> {
+        StartTable {
+            table: self.table().to_vec(),
+            kind: self.kind,
+            start_map: self.start_map.clone(),
+            stride: self.stride,
+            pattern_len: self.pattern_len,
+            universal_start_unanchored: self.universal_start_unanchored,
+            universal_start_anchored: self.universal_start_anchored,
+        }
+    }
+
+    /// Return the start state for the given index and pattern ID. If the
+    /// pattern ID is None, then the corresponding start state for the entire
+    /// DFA is returned. If the pattern ID is not None, then the corresponding
+    /// starting state for the given pattern is returned. If this start table
+    /// does not have individual starting states for each pattern, then this
+    /// panics.
+    fn start(
+        &self,
+        input: &Input<'_>,
+        start: Start,
+    ) -> Result<StateID, MatchError> {
+        let start_index = start.as_usize();
+        let mode = input.get_anchored();
+        let index = match mode {
+            Anchored::No => {
+                if !self.kind.has_unanchored() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                start_index
+            }
+            Anchored::Yes => {
+                if !self.kind.has_anchored() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                self.stride + start_index
+            }
+            Anchored::Pattern(pid) => {
+                let len = match self.pattern_len {
+                    None => {
+                        return Err(MatchError::unsupported_anchored(mode))
+                    }
+                    Some(len) => len,
+                };
+                if pid.as_usize() >= len {
+                    return Ok(DEAD);
+                }
+                (2 * self.stride)
+                    + (self.stride * pid.as_usize())
+                    + start_index
+            }
+        };
+        let start = index * StateID::SIZE;
+        // This OK since we're allowed to assume that the start table contains
+        // valid StateIDs.
+        Ok(wire::read_state_id_unchecked(&self.table()[start..]).0)
+    }
+
+    /// Return an iterator over all start IDs in this table.
+    fn iter(&self) -> StartStateIter<'_, T> {
+        StartStateIter { st: self, i: 0 }
+    }
+
+    /// Returns the total number of start state IDs in this table.
+    fn len(&self) -> usize {
+        self.table().len() / StateID::SIZE
+    }
+
+    /// Returns the table as a raw slice of bytes.
+    fn table(&self) -> &[u8] {
+        self.table.as_ref()
+    }
+
+    /// Return the memory usage, in bytes, of this start list.
+    ///
+    /// This does not include the size of a `StartTable` value itself.
+    fn memory_usage(&self) -> usize {
+        self.table().len()
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl<T: AsMut<[u8]>> StartTable<T> {
+    /// Set the start state for the given index and pattern.
+    ///
+    /// If the pattern ID or state ID are not valid, then this will panic.
+    fn set_start(&mut self, anchored: Anchored, start: Start, id: StateID) {
+        let start_index = start.as_usize();
+        let index = match anchored {
+            Anchored::No => start_index,
+            Anchored::Yes => self.stride + start_index,
+            Anchored::Pattern(pid) => {
+                let pid = pid.as_usize();
+                let len = self
+                    .pattern_len
+                    .expect("start states for each pattern enabled");
+                assert!(pid < len, "invalid pattern ID {:?}", pid);
+                self.stride
+                    .checked_mul(pid)
+                    .unwrap()
+                    .checked_add(self.stride.checked_mul(2).unwrap())
+                    .unwrap()
+                    .checked_add(start_index)
+                    .unwrap()
+            }
+        };
+        let start = index * StateID::SIZE;
+        let end = start + StateID::SIZE;
+        wire::write_state_id::<wire::NE>(
+            id,
+            &mut self.table.as_mut()[start..end],
+        );
+    }
+}
+
+/// An iterator over all state state IDs in a sparse DFA.
+struct StartStateIter<'a, T> {
+    st: &'a StartTable<T>,
+    i: usize,
+}
+
+impl<'a, T: AsRef<[u8]>> Iterator for StartStateIter<'a, T> {
+    type Item = (StateID, Anchored, Start);
+
+    fn next(&mut self) -> Option<(StateID, Anchored, Start)> {
+        let i = self.i;
+        if i >= self.st.len() {
+            return None;
+        }
+        self.i += 1;
+
+        // This unwrap is okay since the stride of any DFA must always match
+        // the number of start state types.
+        let start_type = Start::from_usize(i % self.st.stride).unwrap();
+        let anchored = if i < self.st.stride {
+            Anchored::No
+        } else if i < (2 * self.st.stride) {
+            Anchored::Yes
+        } else {
+            let pid = (i - (2 * self.st.stride)) / self.st.stride;
+            Anchored::Pattern(PatternID::new(pid).unwrap())
+        };
+        let start = i * StateID::SIZE;
+        let end = start + StateID::SIZE;
+        let bytes = self.st.table()[start..end].try_into().unwrap();
+        // This is OK since we're allowed to assume that any IDs in this start
+        // table are correct and valid for this DFA.
+        let id = StateID::from_ne_bytes_unchecked(bytes);
+        Some((id, anchored, start_type))
+    }
+}
+
+impl<'a, T> fmt::Debug for StartStateIter<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("StartStateIter").field("i", &self.i).finish()
+    }
+}
+
+/// An iterator over all states in a sparse DFA.
+///
+/// This iterator yields tuples, where the first element is the state ID and
+/// the second element is the state itself.
+struct StateIter<'a, T> {
+    trans: &'a Transitions<T>,
+    id: usize,
+}
+
+impl<'a, T: AsRef<[u8]>> Iterator for StateIter<'a, T> {
+    type Item = State<'a>;
+
+    fn next(&mut self) -> Option<State<'a>> {
+        if self.id >= self.trans.sparse().len() {
+            return None;
+        }
+        let state = self.trans.state(StateID::new_unchecked(self.id));
+        self.id = self.id + state.write_to_len();
+        Some(state)
+    }
+}
+
+impl<'a, T> fmt::Debug for StateIter<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("StateIter").field("id", &self.id).finish()
+    }
+}
+
+/// A representation of a sparse DFA state that can be cheaply materialized
+/// from a state identifier.
+#[derive(Clone)]
+struct State<'a> {
+    /// The identifier of this state.
+    id: StateID,
+    /// Whether this is a match state or not.
+    is_match: bool,
+    /// The number of transitions in this state.
+    ntrans: usize,
+    /// Pairs of input ranges, where there is one pair for each transition.
+    /// Each pair specifies an inclusive start and end byte range for the
+    /// corresponding transition.
+    input_ranges: &'a [u8],
+    /// Transitions to the next state. This slice contains native endian
+    /// encoded state identifiers, with `S` as the representation. Thus, there
+    /// are `ntrans * size_of::<S>()` bytes in this slice.
+    next: &'a [u8],
+    /// If this is a match state, then this contains the pattern IDs that match
+    /// when the DFA is in this state.
+    ///
+    /// This is a contiguous sequence of 32-bit native endian encoded integers.
+    pattern_ids: &'a [u8],
+    /// An accelerator for this state, if present. If this state has no
+    /// accelerator, then this is an empty slice. When non-empty, this slice
+    /// has length at most 3 and corresponds to the exhaustive set of bytes
+    /// that must be seen in order to transition out of this state.
+    accel: &'a [u8],
+}
+
+impl<'a> State<'a> {
+    /// Searches for the next transition given an input byte. If no such
+    /// transition could be found, then a dead state is returned.
+    ///
+    /// This is marked as inline to help dramatically boost sparse searching,
+    /// which decodes each state it enters to follow the next transition.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next(&self, input: u8) -> StateID {
+        // This straight linear search was observed to be much better than
+        // binary search on ASCII haystacks, likely because a binary search
+        // visits the ASCII case last but a linear search sees it first. A
+        // binary search does do a little better on non-ASCII haystacks, but
+        // not by much. There might be a better trade off lurking here.
+        for i in 0..(self.ntrans - 1) {
+            let (start, end) = self.range(i);
+            if start <= input && input <= end {
+                return self.next_at(i);
+            }
+            // We could bail early with an extra branch: if input < b1, then
+            // we know we'll never find a matching transition. Interestingly,
+            // this extra branch seems to not help performance, or will even
+            // hurt it. It's likely very dependent on the DFA itself and what
+            // is being searched.
+        }
+        DEAD
+    }
+
+    /// Returns the next state ID for the special EOI transition.
+    fn next_eoi(&self) -> StateID {
+        self.next_at(self.ntrans - 1)
+    }
+
+    /// Returns the identifier for this state.
+    fn id(&self) -> StateID {
+        self.id
+    }
+
+    /// Returns the inclusive input byte range for the ith transition in this
+    /// state.
+    fn range(&self, i: usize) -> (u8, u8) {
+        (self.input_ranges[i * 2], self.input_ranges[i * 2 + 1])
+    }
+
+    /// Returns the next state for the ith transition in this state.
+    fn next_at(&self, i: usize) -> StateID {
+        let start = i * StateID::SIZE;
+        let end = start + StateID::SIZE;
+        let bytes = self.next[start..end].try_into().unwrap();
+        StateID::from_ne_bytes_unchecked(bytes)
+    }
+
+    /// Returns the pattern ID for the given match index. If the match index
+    /// is invalid, then this panics.
+    fn pattern_id(&self, match_index: usize) -> PatternID {
+        let start = match_index * PatternID::SIZE;
+        wire::read_pattern_id_unchecked(&self.pattern_ids[start..]).0
+    }
+
+    /// Returns the total number of pattern IDs for this state. This is always
+    /// zero when `is_match` is false.
+    fn pattern_len(&self) -> usize {
+        assert_eq!(0, self.pattern_ids.len() % 4);
+        self.pattern_ids.len() / 4
+    }
+
+    /// Return an accelerator for this state.
+    fn accelerator(&self) -> &'a [u8] {
+        self.accel
+    }
+
+    /// Write the raw representation of this state to the given buffer using
+    /// the given endianness.
+    fn write_to<E: Endian>(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small(
+                "sparse state transitions",
+            ));
+        }
+
+        let ntrans =
+            if self.is_match { self.ntrans | (1 << 15) } else { self.ntrans };
+        E::write_u16(u16::try_from(ntrans).unwrap(), dst);
+        dst = &mut dst[size_of::<u16>()..];
+
+        dst[..self.input_ranges.len()].copy_from_slice(self.input_ranges);
+        dst = &mut dst[self.input_ranges.len()..];
+
+        for i in 0..self.ntrans {
+            E::write_u32(self.next_at(i).as_u32(), dst);
+            dst = &mut dst[StateID::SIZE..];
+        }
+
+        if self.is_match {
+            E::write_u32(u32::try_from(self.pattern_len()).unwrap(), dst);
+            dst = &mut dst[size_of::<u32>()..];
+            for i in 0..self.pattern_len() {
+                let pid = self.pattern_id(i);
+                E::write_u32(pid.as_u32(), dst);
+                dst = &mut dst[PatternID::SIZE..];
+            }
+        }
+
+        dst[0] = u8::try_from(self.accel.len()).unwrap();
+        dst[1..][..self.accel.len()].copy_from_slice(self.accel);
+
+        Ok(nwrite)
+    }
+
+    /// Return the total number of bytes that this state consumes in its
+    /// encoded form.
+    fn write_to_len(&self) -> usize {
+        let mut len = 2
+            + (self.ntrans * 2)
+            + (self.ntrans * StateID::SIZE)
+            + (1 + self.accel.len());
+        if self.is_match {
+            len += size_of::<u32>() + self.pattern_ids.len();
+        }
+        len
+    }
+}
+
+impl<'a> fmt::Debug for State<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut printed = false;
+        for i in 0..(self.ntrans - 1) {
+            let next = self.next_at(i);
+            if next == DEAD {
+                continue;
+            }
+
+            if printed {
+                write!(f, ", ")?;
+            }
+            let (start, end) = self.range(i);
+            if start == end {
+                write!(f, "{:?} => {:?}", DebugByte(start), next.as_usize())?;
+            } else {
+                write!(
+                    f,
+                    "{:?}-{:?} => {:?}",
+                    DebugByte(start),
+                    DebugByte(end),
+                    next.as_usize(),
+                )?;
+            }
+            printed = true;
+        }
+        let eoi = self.next_at(self.ntrans - 1);
+        if eoi != DEAD {
+            if printed {
+                write!(f, ", ")?;
+            }
+            write!(f, "EOI => {:?}", eoi.as_usize())?;
+        }
+        Ok(())
+    }
+}
+
+/// A representation of a mutable sparse DFA state that can be cheaply
+/// materialized from a state identifier.
+#[cfg(feature = "dfa-build")]
+struct StateMut<'a> {
+    /// The identifier of this state.
+    id: StateID,
+    /// Whether this is a match state or not.
+    is_match: bool,
+    /// The number of transitions in this state.
+    ntrans: usize,
+    /// Pairs of input ranges, where there is one pair for each transition.
+    /// Each pair specifies an inclusive start and end byte range for the
+    /// corresponding transition.
+    input_ranges: &'a mut [u8],
+    /// Transitions to the next state. This slice contains native endian
+    /// encoded state identifiers, with `S` as the representation. Thus, there
+    /// are `ntrans * size_of::<S>()` bytes in this slice.
+    next: &'a mut [u8],
+    /// If this is a match state, then this contains the pattern IDs that match
+    /// when the DFA is in this state.
+    ///
+    /// This is a contiguous sequence of 32-bit native endian encoded integers.
+    pattern_ids: &'a [u8],
+    /// An accelerator for this state, if present. If this state has no
+    /// accelerator, then this is an empty slice. When non-empty, this slice
+    /// has length at most 3 and corresponds to the exhaustive set of bytes
+    /// that must be seen in order to transition out of this state.
+    accel: &'a mut [u8],
+}
+
+#[cfg(feature = "dfa-build")]
+impl<'a> StateMut<'a> {
+    /// Sets the ith transition to the given state.
+    fn set_next_at(&mut self, i: usize, next: StateID) {
+        let start = i * StateID::SIZE;
+        let end = start + StateID::SIZE;
+        wire::write_state_id::<wire::NE>(next, &mut self.next[start..end]);
+    }
+}
+
+#[cfg(feature = "dfa-build")]
+impl<'a> fmt::Debug for StateMut<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = State {
+            id: self.id,
+            is_match: self.is_match,
+            ntrans: self.ntrans,
+            input_ranges: self.input_ranges,
+            next: self.next,
+            pattern_ids: self.pattern_ids,
+            accel: self.accel,
+        };
+        fmt::Debug::fmt(&state, f)
+    }
+}
+
+/*
+/// A binary search routine specialized specifically to a sparse DFA state's
+/// transitions. Specifically, the transitions are defined as a set of pairs
+/// of input bytes that delineate an inclusive range of bytes. If the input
+/// byte is in the range, then the corresponding transition is a match.
+///
+/// This binary search accepts a slice of these pairs and returns the position
+/// of the matching pair (the ith transition), or None if no matching pair
+/// could be found.
+///
+/// Note that this routine is not currently used since it was observed to
+/// either decrease performance when searching ASCII, or did not provide enough
+/// of a boost on non-ASCII haystacks to be worth it. However, we leave it here
+/// for posterity in case we can find a way to use it.
+///
+/// In theory, we could use the standard library's search routine if we could
+/// cast a `&[u8]` to a `&[(u8, u8)]`, but I don't believe this is currently
+/// guaranteed to be safe and is thus UB (since I don't think the in-memory
+/// representation of `(u8, u8)` has been nailed down). One could define a
+/// repr(C) type, but the casting doesn't seem justified.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn binary_search_ranges(ranges: &[u8], needle: u8) -> Option<usize> {
+    debug_assert!(ranges.len() % 2 == 0, "ranges must have even length");
+    debug_assert!(ranges.len() <= 512, "ranges should be short");
+
+    let (mut left, mut right) = (0, ranges.len() / 2);
+    while left < right {
+        let mid = (left + right) / 2;
+        let (b1, b2) = (ranges[mid * 2], ranges[mid * 2 + 1]);
+        if needle < b1 {
+            right = mid;
+        } else if needle > b2 {
+            left = mid + 1;
+        } else {
+            return Some(mid);
+        }
+    }
+    None
+}
+*/
+
+#[cfg(all(test, feature = "syntax", feature = "dfa-build"))]
+mod tests {
+    use crate::{
+        dfa::{dense::DFA, Automaton},
+        nfa::thompson,
+        Input, MatchError,
+    };
+
+    // See the analogous test in src/hybrid/dfa.rs and src/dfa/dense.rs.
+    #[test]
+    fn heuristic_unicode_forward() {
+        let dfa = DFA::builder()
+            .configure(DFA::config().unicode_word_boundary(true))
+            .thompson(thompson::Config::new().reverse(true))
+            .build(r"\b[0-9]+\b")
+            .unwrap()
+            .to_sparse()
+            .unwrap();
+
+        let input = Input::new("β123").range(2..);
+        let expected = MatchError::quit(0xB2, 1);
+        let got = dfa.try_search_fwd(&input);
+        assert_eq!(Err(expected), got);
+
+        let input = Input::new("123β").range(..3);
+        let expected = MatchError::quit(0xCE, 3);
+        let got = dfa.try_search_fwd(&input);
+        assert_eq!(Err(expected), got);
+    }
+
+    // See the analogous test in src/hybrid/dfa.rs and src/dfa/dense.rs.
+    #[test]
+    fn heuristic_unicode_reverse() {
+        let dfa = DFA::builder()
+            .configure(DFA::config().unicode_word_boundary(true))
+            .thompson(thompson::Config::new().reverse(true))
+            .build(r"\b[0-9]+\b")
+            .unwrap()
+            .to_sparse()
+            .unwrap();
+
+        let input = Input::new("β123").range(2..);
+        let expected = MatchError::quit(0xB2, 1);
+        let got = dfa.try_search_rev(&input);
+        assert_eq!(Err(expected), got);
+
+        let input = Input::new("123β").range(..3);
+        let expected = MatchError::quit(0xCE, 3);
+        let got = dfa.try_search_rev(&input);
+        assert_eq!(Err(expected), got);
+    }
+}
diff --git a/regex-automata/src/dfa/special.rs b/regex-automata/src/dfa/special.rs
new file mode 100644
index 0000000000..a831df5c55
--- /dev/null
+++ b/regex-automata/src/dfa/special.rs
@@ -0,0 +1,494 @@
+use crate::{
+    dfa::DEAD,
+    util::{
+        primitives::StateID,
+        wire::{self, DeserializeError, Endian, SerializeError},
+    },
+};
+
+macro_rules! err {
+    ($msg:expr) => {
+        return Err(DeserializeError::generic($msg));
+    };
+}
+
+// Special represents the identifiers in a DFA that correspond to "special"
+// states. If a state is one or more of the following, then it is considered
+// special:
+//
+// * dead - A non-matching state where all outgoing transitions lead back to
+//   itself. There is only one of these, regardless of whether minimization
+//   has run. The dead state always has an ID of 0. i.e., It is always the
+//   first state in a DFA.
+// * quit - A state that is entered whenever a byte is seen that should cause
+//   a DFA to give up and stop searching. This results in a MatchError::quit
+//   error being returned at search time. The default configuration for a DFA
+//   has no quit bytes, which means this state is unreachable by default,
+//   although it is always present for reasons of implementation simplicity.
+//   This state is only reachable when the caller configures the DFA to quit
+//   on certain bytes. There is always exactly one of these states and it
+//   is always the second state. (Its actual ID depends on the size of the
+//   alphabet in dense DFAs, since state IDs are premultiplied in order to
+//   allow them to be used directly as indices into the transition table.)
+// * match - An accepting state, i.e., indicative of a match. There may be
+//   zero or more of these states.
+// * accelerated - A state where all of its outgoing transitions, except a
+//   few, loop back to itself. These states are candidates for acceleration
+//   via memchr during search. There may be zero or more of these states.
+// * start - A non-matching state that indicates where the automaton should
+//   start during a search. There is always at least one starting state and
+//   all are guaranteed to be non-match states. (A start state cannot be a
+//   match state because the DFAs in this crate delay all matches by one byte.
+//   So every search that finds a match must move through one transition to
+//   some other match state, even when searching an empty string.)
+//
+// These are not mutually exclusive categories. Namely, the following
+// overlappings can occur:
+//
+// * {dead, start} - If a DFA can never lead to a match and it is minimized,
+//   then it will typically compile to something where all starting IDs point
+//   to the DFA's dead state.
+// * {match, accelerated} - It is possible for a match state to have the
+//   majority of its transitions loop back to itself, which means it's
+//   possible for a match state to be accelerated.
+// * {start, accelerated} - Similarly, it is possible for a start state to be
+//   accelerated. Note that it is possible for an accelerated state to be
+//   neither a match or a start state. Also note that just because both match
+//   and start states overlap with accelerated states does not mean that
+//   match and start states overlap with each other. In fact, they are
+//   guaranteed not to overlap.
+//
+// As a special mention, every DFA always has a dead and a quit state, even
+// though from the perspective of the DFA, they are equivalent. (Indeed,
+// minimization special cases them to ensure they don't get merged.) The
+// purpose of keeping them distinct is to use the quit state as a sentinel to
+// distguish between whether a search finished successfully without finding
+// anything or whether it gave up before finishing.
+//
+// So the main problem we want to solve here is the *fast* detection of whether
+// a state is special or not. And we also want to do this while storing as
+// little extra data as possible. AND we want to be able to quickly determine
+// which categories a state falls into above if it is special.
+//
+// We achieve this by essentially shuffling all special states to the beginning
+// of a DFA. That is, all special states appear before every other non-special
+// state. By representing special states this way, we can determine whether a
+// state is special or not by a single comparison, where special.max is the
+// identifier of the last special state in the DFA:
+//
+//     if current_state <= special.max:
+//         ... do something with special state
+//
+// The only thing left to do is to determine what kind of special state
+// it is. Because what we do next depends on that. Since special states
+// are typically rare, we can afford to do a bit more extra work, but we'd
+// still like this to be as fast as possible. The trick we employ here is to
+// continue shuffling states even within the special state range. Such that
+// one contiguous region corresponds to match states, another for start states
+// and then an overlapping range for accelerated states. At a high level, our
+// special state detection might look like this (for leftmost searching, where
+// we continue searching even after seeing a match):
+//
+//     byte = input[offset]
+//     current_state = next_state(current_state, byte)
+//     offset += 1
+//     if current_state <= special.max:
+//         if current_state == 0:
+//             # We can never leave a dead state, so this always marks the
+//             # end of our search.
+//             return last_match
+//         if current_state == special.quit_id:
+//             # A quit state means we give up. If he DFA has no quit state,
+//             # then special.quit_id == 0 == dead, which is handled by the
+//             # conditional above.
+//             return Err(MatchError::quit { byte, offset: offset - 1 })
+//         if special.min_match <= current_state <= special.max_match:
+//             last_match = Some(offset)
+//             if special.min_accel <= current_state <= special.max_accel:
+//                 offset = accelerate(input, offset)
+//                 last_match = Some(offset)
+//         elif special.min_start <= current_state <= special.max_start:
+//             offset = prefilter.find(input, offset)
+//             if special.min_accel <= current_state <= special.max_accel:
+//                 offset = accelerate(input, offset)
+//         elif special.min_accel <= current_state <= special.max_accel:
+//             offset = accelerate(input, offset)
+//
+// There are some small details left out of the logic above. For example,
+// in order to accelerate a state, we need to know which bytes to search for.
+// This in turn implies some extra data we need to store in the DFA. To keep
+// things compact, we would ideally only store
+//
+//     N = special.max_accel - special.min_accel + 1
+//
+// items. But state IDs are premultiplied, which means they are not contiguous.
+// So in order to take a state ID and index an array of accelerated structures,
+// we need to do:
+//
+//     i = (state_id - special.min_accel) / stride
+//
+// (N.B. 'stride' is always a power of 2, so the above can be implemented via
+// '(state_id - special.min_accel) >> stride2', where 'stride2' is x in
+// 2^x=stride.)
+//
+// Moreover, some of these specialty categories may be empty. For example,
+// DFAs are not required to have any match states or any accelerated states.
+// In that case, the lower and upper bounds are both set to 0 (the dead state
+// ID) and the first `current_state == 0` check subsumes cases where the
+// ranges are empty.
+//
+// Loop unrolling, if applicable, has also been left out of the logic above.
+//
+// Graphically, the ranges look like this, where asterisks indicate ranges
+// that can be empty. Each 'x' is a state.
+//
+//      quit
+//  dead|
+//     ||
+//     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+//     | |             |    | start |                       |
+//     | |-------------|    |-------|                       |
+//     |   match*   |          |    |                       |
+//     |            |          |    |                       |
+//     |            |----------|    |                       |
+//     |                accel*      |                       |
+//     |                            |                       |
+//     |                            |                       |
+//     |----------------------------|------------------------
+//              special                   non-special*
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Special {
+    /// The identifier of the last special state in a DFA. A state is special
+    /// if and only if its identifier is less than or equal to `max`.
+    pub(crate) max: StateID,
+    /// The identifier of the quit state in a DFA. (There is no analogous field
+    /// for the dead state since the dead state's ID is always zero, regardless
+    /// of state ID size.)
+    pub(crate) quit_id: StateID,
+    /// The identifier of the first match state.
+    pub(crate) min_match: StateID,
+    /// The identifier of the last match state.
+    pub(crate) max_match: StateID,
+    /// The identifier of the first accelerated state.
+    pub(crate) min_accel: StateID,
+    /// The identifier of the last accelerated state.
+    pub(crate) max_accel: StateID,
+    /// The identifier of the first start state.
+    pub(crate) min_start: StateID,
+    /// The identifier of the last start state.
+    pub(crate) max_start: StateID,
+}
+
+impl Special {
+    /// Creates a new set of special ranges for a DFA. All ranges are initially
+    /// set to only contain the dead state. This is interpreted as an empty
+    /// range.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn new() -> Special {
+        Special {
+            max: DEAD,
+            quit_id: DEAD,
+            min_match: DEAD,
+            max_match: DEAD,
+            min_accel: DEAD,
+            max_accel: DEAD,
+            min_start: DEAD,
+            max_start: DEAD,
+        }
+    }
+
+    /// Remaps all of the special state identifiers using the function given.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn remap(&self, map: impl Fn(StateID) -> StateID) -> Special {
+        Special {
+            max: map(self.max),
+            quit_id: map(self.quit_id),
+            min_match: map(self.min_match),
+            max_match: map(self.max_match),
+            min_accel: map(self.min_accel),
+            max_accel: map(self.max_accel),
+            min_start: map(self.min_start),
+            max_start: map(self.max_start),
+        }
+    }
+
+    /// Deserialize the given bytes into special state ranges. If the slice
+    /// given is not big enough, then this returns an error. Similarly, if
+    /// any of the expected invariants around special state ranges aren't
+    /// upheld, an error is returned. Note that this does not guarantee that
+    /// the information returned is correct.
+    ///
+    /// Upon success, this returns the number of bytes read in addition to the
+    /// special state IDs themselves.
+    pub(crate) fn from_bytes(
+        mut slice: &[u8],
+    ) -> Result<(Special, usize), DeserializeError> {
+        wire::check_slice_len(slice, 8 * StateID::SIZE, "special states")?;
+
+        let mut nread = 0;
+        let mut read_id = |what| -> Result<StateID, DeserializeError> {
+            let (id, nr) = wire::try_read_state_id(slice, what)?;
+            nread += nr;
+            slice = &slice[StateID::SIZE..];
+            Ok(id)
+        };
+
+        let max = read_id("special max id")?;
+        let quit_id = read_id("special quit id")?;
+        let min_match = read_id("special min match id")?;
+        let max_match = read_id("special max match id")?;
+        let min_accel = read_id("special min accel id")?;
+        let max_accel = read_id("special max accel id")?;
+        let min_start = read_id("special min start id")?;
+        let max_start = read_id("special max start id")?;
+
+        let special = Special {
+            max,
+            quit_id,
+            min_match,
+            max_match,
+            min_accel,
+            max_accel,
+            min_start,
+            max_start,
+        };
+        special.validate()?;
+        assert_eq!(nread, special.write_to_len());
+        Ok((special, nread))
+    }
+
+    /// Validate that the information describing special states satisfies
+    /// all known invariants.
+    pub(crate) fn validate(&self) -> Result<(), DeserializeError> {
+        // Check that both ends of the range are DEAD or neither are.
+        if self.min_match == DEAD && self.max_match != DEAD {
+            err!("min_match is DEAD, but max_match is not");
+        }
+        if self.min_match != DEAD && self.max_match == DEAD {
+            err!("max_match is DEAD, but min_match is not");
+        }
+        if self.min_accel == DEAD && self.max_accel != DEAD {
+            err!("min_accel is DEAD, but max_accel is not");
+        }
+        if self.min_accel != DEAD && self.max_accel == DEAD {
+            err!("max_accel is DEAD, but min_accel is not");
+        }
+        if self.min_start == DEAD && self.max_start != DEAD {
+            err!("min_start is DEAD, but max_start is not");
+        }
+        if self.min_start != DEAD && self.max_start == DEAD {
+            err!("max_start is DEAD, but min_start is not");
+        }
+
+        // Check that ranges are well formed.
+        if self.min_match > self.max_match {
+            err!("min_match should not be greater than max_match");
+        }
+        if self.min_accel > self.max_accel {
+            err!("min_accel should not be greater than max_accel");
+        }
+        if self.min_start > self.max_start {
+            err!("min_start should not be greater than max_start");
+        }
+
+        // Check that ranges are ordered with respect to one another.
+        if self.matches() && self.quit_id >= self.min_match {
+            err!("quit_id should not be greater than min_match");
+        }
+        if self.accels() && self.quit_id >= self.min_accel {
+            err!("quit_id should not be greater than min_accel");
+        }
+        if self.starts() && self.quit_id >= self.min_start {
+            err!("quit_id should not be greater than min_start");
+        }
+        if self.matches() && self.accels() && self.min_accel < self.min_match {
+            err!("min_match should not be greater than min_accel");
+        }
+        if self.matches() && self.starts() && self.min_start < self.min_match {
+            err!("min_match should not be greater than min_start");
+        }
+        if self.accels() && self.starts() && self.min_start < self.min_accel {
+            err!("min_accel should not be greater than min_start");
+        }
+
+        // Check that max is at least as big as everything else.
+        if self.max < self.quit_id {
+            err!("quit_id should not be greater than max");
+        }
+        if self.max < self.max_match {
+            err!("max_match should not be greater than max");
+        }
+        if self.max < self.max_accel {
+            err!("max_accel should not be greater than max");
+        }
+        if self.max < self.max_start {
+            err!("max_start should not be greater than max");
+        }
+
+        Ok(())
+    }
+
+    /// Validate that the special state information is compatible with the
+    /// given state len.
+    pub(crate) fn validate_state_len(
+        &self,
+        len: usize,
+        stride2: usize,
+    ) -> Result<(), DeserializeError> {
+        // We assume that 'validate' has already passed, so we know that 'max'
+        // is truly the max. So all we need to check is that the max state ID
+        // is less than the state ID len. The max legal value here is len-1,
+        // which occurs when there are no non-special states.
+        if (self.max.as_usize() >> stride2) >= len {
+            err!("max should not be greater than or equal to state length");
+        }
+        Ok(())
+    }
+
+    /// Write the IDs and ranges for special states to the given byte buffer.
+    /// The buffer given must have enough room to store all data, otherwise
+    /// this will return an error. The number of bytes written is returned
+    /// on success. The number of bytes written is guaranteed to be a multiple
+    /// of 8.
+    pub(crate) fn write_to<E: Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        use crate::util::wire::write_state_id as write;
+
+        if dst.len() < self.write_to_len() {
+            return Err(SerializeError::buffer_too_small("special state ids"));
+        }
+
+        let mut nwrite = 0;
+        nwrite += write::<E>(self.max, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.quit_id, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.min_match, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.max_match, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.min_accel, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.max_accel, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.min_start, &mut dst[nwrite..]);
+        nwrite += write::<E>(self.max_start, &mut dst[nwrite..]);
+
+        assert_eq!(
+            self.write_to_len(),
+            nwrite,
+            "expected to write certain number of bytes",
+        );
+        assert_eq!(
+            nwrite % 8,
+            0,
+            "expected to write multiple of 8 bytes for special states",
+        );
+        Ok(nwrite)
+    }
+
+    /// Returns the total number of bytes written by `write_to`.
+    pub(crate) fn write_to_len(&self) -> usize {
+        8 * StateID::SIZE
+    }
+
+    /// Sets the maximum special state ID based on the current values. This
+    /// should be used once all possible state IDs are set.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn set_max(&mut self) {
+        use core::cmp::max;
+        self.max = max(
+            self.quit_id,
+            max(self.max_match, max(self.max_accel, self.max_start)),
+        );
+    }
+
+    /// Sets the maximum special state ID such that starting states are not
+    /// considered "special." This also marks the min/max starting states as
+    /// DEAD such that 'is_start_state' always returns false, even if the state
+    /// is actually a starting state.
+    ///
+    /// This is useful when there is no prefilter set. It will avoid
+    /// ping-ponging between the hot path in the DFA search code and the start
+    /// state handling code, which is typically only useful for executing a
+    /// prefilter.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn set_no_special_start_states(&mut self) {
+        use core::cmp::max;
+        self.max = max(self.quit_id, max(self.max_match, self.max_accel));
+        self.min_start = DEAD;
+        self.max_start = DEAD;
+    }
+
+    /// Returns true if and only if the given state ID is a special state.
+    #[inline]
+    pub(crate) fn is_special_state(&self, id: StateID) -> bool {
+        id <= self.max
+    }
+
+    /// Returns true if and only if the given state ID is a dead state.
+    #[inline]
+    pub(crate) fn is_dead_state(&self, id: StateID) -> bool {
+        id == DEAD
+    }
+
+    /// Returns true if and only if the given state ID is a quit state.
+    #[inline]
+    pub(crate) fn is_quit_state(&self, id: StateID) -> bool {
+        !self.is_dead_state(id) && self.quit_id == id
+    }
+
+    /// Returns true if and only if the given state ID is a match state.
+    #[inline]
+    pub(crate) fn is_match_state(&self, id: StateID) -> bool {
+        !self.is_dead_state(id) && self.min_match <= id && id <= self.max_match
+    }
+
+    /// Returns true if and only if the given state ID is an accel state.
+    #[inline]
+    pub(crate) fn is_accel_state(&self, id: StateID) -> bool {
+        !self.is_dead_state(id) && self.min_accel <= id && id <= self.max_accel
+    }
+
+    /// Returns true if and only if the given state ID is a start state.
+    #[inline]
+    pub(crate) fn is_start_state(&self, id: StateID) -> bool {
+        !self.is_dead_state(id) && self.min_start <= id && id <= self.max_start
+    }
+
+    /// Returns the total number of match states for a dense table based DFA.
+    #[inline]
+    pub(crate) fn match_len(&self, stride: usize) -> usize {
+        if self.matches() {
+            (self.max_match.as_usize() - self.min_match.as_usize() + stride)
+                / stride
+        } else {
+            0
+        }
+    }
+
+    /// Returns true if and only if there is at least one match state.
+    #[inline]
+    pub(crate) fn matches(&self) -> bool {
+        self.min_match != DEAD
+    }
+
+    /// Returns the total number of accel states.
+    #[cfg(feature = "dfa-build")]
+    pub(crate) fn accel_len(&self, stride: usize) -> usize {
+        if self.accels() {
+            (self.max_accel.as_usize() - self.min_accel.as_usize() + stride)
+                / stride
+        } else {
+            0
+        }
+    }
+
+    /// Returns true if and only if there is at least one accel state.
+    #[inline]
+    pub(crate) fn accels(&self) -> bool {
+        self.min_accel != DEAD
+    }
+
+    /// Returns true if and only if there is at least one start state.
+    #[inline]
+    pub(crate) fn starts(&self) -> bool {
+        self.min_start != DEAD
+    }
+}
diff --git a/regex-automata/src/dfa/start.rs b/regex-automata/src/dfa/start.rs
new file mode 100644
index 0000000000..2bd9f91935
--- /dev/null
+++ b/regex-automata/src/dfa/start.rs
@@ -0,0 +1,72 @@
+use core::mem::size_of;
+
+use crate::util::wire::{self, DeserializeError, Endian, SerializeError};
+
+/// The kind of anchored starting configurations to support in a DFA.
+///
+/// Fully compiled DFAs need to be explicitly configured as to which anchored
+/// starting configurations to support. The reason for not just supporting
+/// everything unconditionally is that it can use more resources (such as
+/// memory and build time). The downside of this is that if you try to execute
+/// a search using an [`Anchored`](crate::Anchored) mode that is not supported
+/// by the DFA, then the search will return an error.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum StartKind {
+    /// Support both anchored and unanchored searches.
+    Both,
+    /// Support only unanchored searches. Requesting an anchored search will
+    /// panic.
+    ///
+    /// Note that even if an unanchored search is requested, the pattern itself
+    /// may still be anchored. For example, `^abc` will only match `abc` at the
+    /// start of a haystack. This will remain true, even if the regex engine
+    /// only supported unanchored searches.
+    Unanchored,
+    /// Support only anchored searches. Requesting an unanchored search will
+    /// panic.
+    Anchored,
+}
+
+impl StartKind {
+    pub(crate) fn from_bytes(
+        slice: &[u8],
+    ) -> Result<(StartKind, usize), DeserializeError> {
+        wire::check_slice_len(slice, size_of::<u32>(), "start kind bytes")?;
+        let (n, nr) = wire::try_read_u32(slice, "start kind integer")?;
+        match n {
+            0 => Ok((StartKind::Both, nr)),
+            1 => Ok((StartKind::Unanchored, nr)),
+            2 => Ok((StartKind::Anchored, nr)),
+            _ => Err(DeserializeError::generic("unrecognized start kind")),
+        }
+    }
+
+    pub(crate) fn write_to<E: Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("start kind"));
+        }
+        let n = match *self {
+            StartKind::Both => 0,
+            StartKind::Unanchored => 1,
+            StartKind::Anchored => 2,
+        };
+        E::write_u32(n, dst);
+        Ok(nwrite)
+    }
+
+    pub(crate) fn write_to_len(&self) -> usize {
+        size_of::<u32>()
+    }
+
+    pub(crate) fn has_unanchored(&self) -> bool {
+        matches!(*self, StartKind::Both | StartKind::Unanchored)
+    }
+
+    pub(crate) fn has_anchored(&self) -> bool {
+        matches!(*self, StartKind::Both | StartKind::Anchored)
+    }
+}
diff --git a/regex-automata/src/hybrid/dfa.rs b/regex-automata/src/hybrid/dfa.rs
new file mode 100644
index 0000000000..874b511e23
--- /dev/null
+++ b/regex-automata/src/hybrid/dfa.rs
@@ -0,0 +1,4378 @@
+/*!
+Types and routines specific to lazy DFAs.
+
+This module is the home of [`hybrid::dfa::DFA`](DFA).
+
+This module also contains a [`hybrid::dfa::Builder`](Builder) and a
+[`hybrid::dfa::Config`](Config) for configuring and building a lazy DFA.
+*/
+
+use core::{iter, mem::size_of};
+
+use alloc::vec::Vec;
+
+use crate::{
+    hybrid::{
+        error::{BuildError, CacheError},
+        id::{LazyStateID, LazyStateIDError},
+        search,
+    },
+    nfa::thompson,
+    util::{
+        alphabet::{self, ByteClasses, ByteSet},
+        determinize::{self, State, StateBuilderEmpty, StateBuilderNFA},
+        empty,
+        prefilter::Prefilter,
+        primitives::{PatternID, StateID as NFAStateID},
+        search::{
+            Anchored, HalfMatch, Input, MatchError, MatchKind, PatternSet,
+        },
+        sparse_set::SparseSets,
+        start::{Start, StartByteMap},
+    },
+};
+
+/// The mininum number of states that a lazy DFA's cache size must support.
+///
+/// This is checked at time of construction to ensure that at least some small
+/// number of states can fit in the given capacity allotment. If we can't fit
+/// at least this number of states, then the thinking is that it's pretty
+/// senseless to use the lazy DFA. More to the point, parts of the code do
+/// assume that the cache can fit at least some small number of states.
+const MIN_STATES: usize = SENTINEL_STATES + 2;
+
+/// The number of "sentinel" states that get added to every lazy DFA.
+///
+/// These are special states indicating status conditions of a search: unknown,
+/// dead and quit. These states in particular also use zero NFA states, so
+/// their memory usage is quite small. This is relevant for computing the
+/// minimum memory needed for a lazy DFA cache.
+const SENTINEL_STATES: usize = 3;
+
+/// A hybrid NFA/DFA (also called a "lazy DFA") for regex searching.
+///
+/// A lazy DFA is a DFA that builds itself at search time. It otherwise has
+/// very similar characteristics as a [`dense::DFA`](crate::dfa::dense::DFA).
+/// Indeed, both support precisely the same regex features with precisely the
+/// same semantics.
+///
+/// Where as a `dense::DFA` must be completely built to handle any input before
+/// it may be used for search, a lazy DFA starts off effectively empty. During
+/// a search, a lazy DFA will build itself depending on whether it has already
+/// computed the next transition or not. If it has, then it looks a lot like
+/// a `dense::DFA` internally: it does a very fast table based access to find
+/// the next transition. Otherwise, if the state hasn't been computed, then it
+/// does determinization _for that specific transition_ to compute the next DFA
+/// state.
+///
+/// The main selling point of a lazy DFA is that, in practice, it has
+/// the performance profile of a `dense::DFA` without the weakness of it
+/// taking worst case exponential time to build. Indeed, for each byte of
+/// input, the lazy DFA will construct as most one new DFA state. Thus, a
+/// lazy DFA achieves worst case `O(mn)` time for regex search (where `m ~
+/// pattern.len()` and `n ~ haystack.len()`).
+///
+/// The main downsides of a lazy DFA are:
+///
+/// 1. It requires mutable "cache" space during search. This is where the
+/// transition table, among other things, is stored.
+/// 2. In pathological cases (e.g., if the cache is too small), it will run
+/// out of room and either require a bigger cache capacity or will repeatedly
+/// clear the cache and thus repeatedly regenerate DFA states. Overall, this
+/// will tend to be slower than a typical NFA simulation.
+///
+/// # Capabilities
+///
+/// Like a `dense::DFA`, a single lazy DFA fundamentally supports the following
+/// operations:
+///
+/// 1. Detection of a match.
+/// 2. Location of the end of a match.
+/// 3. In the case of a lazy DFA with multiple patterns, which pattern matched
+/// is reported as well.
+///
+/// A notable absence from the above list of capabilities is the location of
+/// the *start* of a match. In order to provide both the start and end of
+/// a match, *two* lazy DFAs are required. This functionality is provided by a
+/// [`Regex`](crate::hybrid::regex::Regex).
+///
+/// # Example
+///
+/// This shows how to build a lazy DFA with the default configuration and
+/// execute a search. Notice how, in contrast to a `dense::DFA`, we must create
+/// a cache and pass it to our search routine.
+///
+/// ```
+/// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+///
+/// let dfa = DFA::new("foo[0-9]+")?;
+/// let mut cache = dfa.create_cache();
+///
+/// let expected = Some(HalfMatch::must(0, 8));
+/// assert_eq!(expected, dfa.try_search_fwd(
+///     &mut cache, &Input::new("foo12345"))?,
+/// );
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct DFA {
+    config: Config,
+    nfa: thompson::NFA,
+    stride2: usize,
+    start_map: StartByteMap,
+    classes: ByteClasses,
+    quitset: ByteSet,
+    cache_capacity: usize,
+}
+
+impl DFA {
+    /// Parse the given regular expression using a default configuration and
+    /// return the corresponding lazy DFA.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa = DFA::new("foo[0-9]+bar")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let expected = HalfMatch::must(0, 11);
+    /// assert_eq!(
+    ///     Some(expected),
+    ///     dfa.try_search_fwd(&mut cache, &Input::new("foo12345bar"))?,
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<DFA, BuildError> {
+        DFA::builder().build(pattern)
+    }
+
+    /// Parse the given regular expressions using a default configuration and
+    /// return the corresponding lazy multi-DFA.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+"])?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let expected = HalfMatch::must(1, 3);
+    /// assert_eq!(
+    ///     Some(expected),
+    ///     dfa.try_search_fwd(&mut cache, &Input::new("foo12345bar"))?,
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(patterns: &[P]) -> Result<DFA, BuildError> {
+        DFA::builder().build_many(patterns)
+    }
+
+    /// Create a new lazy DFA that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa = DFA::always_match()?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let expected = HalfMatch::must(0, 0);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(
+    ///     &mut cache, &Input::new(""))?,
+    /// );
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(
+    ///     &mut cache, &Input::new("foo"))?,
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<DFA, BuildError> {
+        let nfa = thompson::NFA::always_match();
+        Builder::new().build_from_nfa(nfa)
+    }
+
+    /// Create a new lazy DFA that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, Input};
+    ///
+    /// let dfa = DFA::never_match()?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// assert_eq!(None, dfa.try_search_fwd(&mut cache, &Input::new(""))?);
+    /// assert_eq!(None, dfa.try_search_fwd(&mut cache, &Input::new("foo"))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<DFA, BuildError> {
+        let nfa = thompson::NFA::never_match();
+        Builder::new().build_from_nfa(nfa)
+    }
+
+    /// Return a default configuration for a `DFA`.
+    ///
+    /// This is a convenience routine to avoid needing to import the [`Config`]
+    /// type when customizing the construction of a lazy DFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a lazy DFA that heuristically supports
+    /// Unicode word boundaries.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, MatchError, Input};
+    ///
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().unicode_word_boundary(true))
+    ///     .build(r"\b\w+\b")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// // Since our haystack is all ASCII, the DFA search sees then and knows
+    /// // it is legal to interpret Unicode word boundaries as ASCII word
+    /// // boundaries.
+    /// let input = Input::new("!!foo!!");
+    /// let expected = HalfMatch::must(0, 5);
+    /// assert_eq!(Some(expected), re.try_search_fwd(&mut cache, &input)?);
+    ///
+    /// // But if our haystack contains non-ASCII, then the search will fail
+    /// // with an error.
+    /// let input = Input::new("!!βββ!!");
+    /// let expected = MatchError::quit(b'\xCE', 2);
+    /// assert_eq!(Err(expected), re.try_search_fwd(&mut cache, &input));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a builder for configuring the construction of a `Regex`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode
+    /// everywhere for lazy DFAs.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, util::syntax, HalfMatch, Input};
+    ///
+    /// let re = DFA::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new(b"\xFEfoo\xFFarzz\xE2\x98\xFF\n");
+    /// let expected = Some(HalfMatch::must(0, 9));
+    /// let got = re.try_search_fwd(&mut cache, &input)?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    /// Create a new cache for this lazy DFA.
+    ///
+    /// The cache returned should only be used for searches for this
+    /// lazy DFA. If you want to reuse the cache for another DFA, then
+    /// you must call [`Cache::reset`] with that DFA (or, equivalently,
+    /// [`DFA::reset_cache`]).
+    pub fn create_cache(&self) -> Cache {
+        Cache::new(self)
+    }
+
+    /// Reset the given cache such that it can be used for searching with the
+    /// this lazy DFA (and only this DFA).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different lazy DFA.
+    ///
+    /// Resetting a cache sets its "clear count" to 0. This is relevant if the
+    /// lazy DFA has been configured to "give up" after it has cleared the
+    /// cache a certain number of times.
+    ///
+    /// Any lazy state ID generated by the cache prior to resetting it is
+    /// invalid after the reset.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different DFA.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa1 = DFA::new(r"\w")?;
+    /// let dfa2 = DFA::new(r"\W")?;
+    ///
+    /// let mut cache = dfa1.create_cache();
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 2)),
+    ///     dfa1.try_search_fwd(&mut cache, &Input::new("Δ"))?,
+    /// );
+    ///
+    /// // Using 'cache' with dfa2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the DFA we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 'dfa1' is also not
+    /// // allowed.
+    /// dfa2.reset_cache(&mut cache);
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 3)),
+    ///     dfa2.try_search_fwd(&mut cache, &Input::new("☃"))?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset_cache(&self, cache: &mut Cache) {
+        Lazy::new(self, cache).reset_cache()
+    }
+
+    /// Returns the total number of patterns compiled into this lazy DFA.
+    ///
+    /// In the case of a DFA that contains no patterns, this returns `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the pattern length for a DFA that never matches:
+    ///
+    /// ```
+    /// use regex_automata::hybrid::dfa::DFA;
+    ///
+    /// let dfa = DFA::never_match()?;
+    /// assert_eq!(dfa.pattern_len(), 0);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And another example for a DFA that matches at every position:
+    ///
+    /// ```
+    /// use regex_automata::hybrid::dfa::DFA;
+    ///
+    /// let dfa = DFA::always_match()?;
+    /// assert_eq!(dfa.pattern_len(), 1);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And finally, a DFA that was constructed from multiple patterns:
+    ///
+    /// ```
+    /// use regex_automata::hybrid::dfa::DFA;
+    ///
+    /// let dfa = DFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(dfa.pattern_len(), 3);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        self.nfa.pattern_len()
+    }
+
+    /// Returns the equivalence classes that make up the alphabet for this DFA.
+    ///
+    /// Unless [`Config::byte_classes`] was disabled, it is possible that
+    /// multiple distinct bytes are grouped into the same equivalence class
+    /// if it is impossible for them to discriminate between a match and a
+    /// non-match. This has the effect of reducing the overall alphabet size
+    /// and in turn potentially substantially reducing the size of the DFA's
+    /// transition table.
+    ///
+    /// The downside of using equivalence classes like this is that every state
+    /// transition will automatically use this map to convert an arbitrary
+    /// byte to its corresponding equivalence class. In practice this has a
+    /// negligible impact on performance.
+    pub fn byte_classes(&self) -> &ByteClasses {
+        &self.classes
+    }
+
+    /// Returns this lazy DFA's configuration.
+    pub fn get_config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Returns a reference to the underlying NFA.
+    pub fn get_nfa(&self) -> &thompson::NFA {
+        &self.nfa
+    }
+
+    /// Returns the stride, as a base-2 exponent, required for these
+    /// equivalence classes.
+    ///
+    /// The stride is always the smallest power of 2 that is greater than or
+    /// equal to the alphabet length. This is done so that converting between
+    /// state IDs and indices can be done with shifts alone, which is much
+    /// faster than integer division.
+    fn stride2(&self) -> usize {
+        self.stride2
+    }
+
+    /// Returns the total stride for every state in this lazy DFA. This
+    /// corresponds to the total number of transitions used by each state in
+    /// this DFA's transition table.
+    fn stride(&self) -> usize {
+        1 << self.stride2()
+    }
+
+    /// Returns the memory usage, in bytes, of this lazy DFA.
+    ///
+    /// This does **not** include the stack size used up by this lazy DFA. To
+    /// compute that, use `std::mem::size_of::<DFA>()`. This also does not
+    /// include the size of the `Cache` used.
+    ///
+    /// This also does not include any heap memory used by the NFA inside of
+    /// this hybrid NFA/DFA. This is because the NFA's ownership is shared, and
+    /// thus not owned by this hybrid NFA/DFA. More practically, several regex
+    /// engines in this crate embed an NFA, and reporting the NFA's memory
+    /// usage in all of them would likely result in reporting higher heap
+    /// memory than is actually used.
+    pub fn memory_usage(&self) -> usize {
+        // The only thing that uses heap memory in a DFA is the NFA. But the
+        // NFA has shared ownership, so reporting its memory as part of the
+        // hybrid DFA is likely to lead to double-counting the NFA memory
+        // somehow. In particular, this DFA does not really own an NFA, so
+        // including it in the DFA's memory usage doesn't seem semantically
+        // correct.
+        0
+    }
+}
+
+impl DFA {
+    /// Executes a forward search and returns the end position of the leftmost
+    /// match that is found. If no match exists, then `None` is returned.
+    ///
+    /// In particular, this method continues searching even after it enters
+    /// a match state. The search only terminates once it has reached the
+    /// end of the input or when it has entered a dead or quit state. Upon
+    /// termination, the position of the last byte seen while still in a match
+    /// state is returned.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to run a basic search.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa = DFA::new("foo[0-9]+")?;
+    /// let mut cache = dfa.create_cache();
+    /// let expected = HalfMatch::must(0, 8);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(
+    ///     &mut cache, &Input::new("foo12345"))?,
+    /// );
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over later parts.
+    /// let dfa = DFA::new("abc|a")?;
+    /// let mut cache = dfa.create_cache();
+    /// let expected = HalfMatch::must(0, 3);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(
+    ///     &mut cache, &Input::new("abc"))?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a lazy multi-DFA that permits searching
+    /// for specific patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     Anchored, HalfMatch, PatternID, Input,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().starts_for_each_pattern(true))
+    ///     .build_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "foo123";
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(HalfMatch::must(0, 6));
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let expected = Some(HalfMatch::must(1, 6));
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// let got = dfa.try_search_fwd(&mut cache, &input)?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// // N.B. We disable Unicode here so that we use a simple ASCII word
+    /// // boundary. Alternatively, we could enable heuristic support for
+    /// // Unicode word boundaries since our haystack is pure ASCII.
+    /// let dfa = DFA::new(r"(?-u)\b[0-9]{3}\b")?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about the
+    /// // larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `3` instead of `6`.
+    /// let expected = Some(HalfMatch::must(0, 3));
+    /// let got = dfa.try_search_fwd(
+    ///     &mut cache,
+    ///     &Input::new(&haystack[3..6]),
+    /// )?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// let got = dfa.try_search_fwd(
+    ///     &mut cache,
+    ///     &Input::new(haystack).range(3..6),
+    /// )?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_fwd(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        let hm = match search::find_fwd(self, cache, input)? {
+            None => return Ok(None),
+            Some(hm) if !utf8empty => return Ok(Some(hm)),
+            Some(hm) => hm,
+        };
+        // We get to this point when we know our DFA can match the empty string
+        // AND when UTF-8 mode is enabled. In this case, we skip any matches
+        // whose offset splits a codepoint. Such a match is necessarily a
+        // zero-width match, because UTF-8 mode requires the underlying NFA
+        // to be built such that all non-empty matches span valid UTF-8.
+        // Therefore, any match that ends in the middle of a codepoint cannot
+        // be part of a span of valid UTF-8 and thus must be an empty match.
+        // In such cases, we skip it, so as not to report matches that split a
+        // codepoint.
+        //
+        // Note that this is not a checked assumption. Callers *can* provide an
+        // NFA with UTF-8 mode enabled but produces non-empty matches that span
+        // invalid UTF-8. But doing so is documented to result in unspecified
+        // behavior.
+        empty::skip_splits_fwd(input, hm, hm.offset(), |input| {
+            let got = search::find_fwd(self, cache, input)?;
+            Ok(got.map(|hm| (hm, hm.offset())))
+        })
+    }
+
+    /// Executes a reverse search and returns the start of the position of the
+    /// leftmost match that is found. If no match exists, then `None` is
+    /// returned.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This routine is principally useful when used in
+    /// conjunction with the
+    /// [`nfa::thompson::Config::reverse`](crate::nfa::thompson::Config::reverse)
+    /// configuration. In general, it's unlikely to be correct to use both
+    /// `try_search_fwd` and `try_search_rev` with the same DFA since any
+    /// particular DFA will only support searching in one direction with
+    /// respect to the pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson,
+    ///     hybrid::dfa::DFA,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build("foo[0-9]+")?;
+    /// let mut cache = dfa.create_cache();
+    /// let expected = HalfMatch::must(0, 0);
+    /// assert_eq!(
+    ///     Some(expected),
+    ///     dfa.try_search_rev(&mut cache, &Input::new("foo12345"))?,
+    /// );
+    ///
+    /// // Even though a match is found after reading the last byte (`c`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over latter parts.
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build("abc|c")?;
+    /// let mut cache = dfa.create_cache();
+    /// let expected = HalfMatch::must(0, 0);
+    /// assert_eq!(Some(expected), dfa.try_search_rev(
+    ///     &mut cache, &Input::new("abc"))?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: UTF-8 mode
+    ///
+    /// This examples demonstrates that UTF-8 mode applies to reverse
+    /// DFAs. When UTF-8 mode is enabled in the underlying NFA, then all
+    /// matches reported must correspond to valid UTF-8 spans. This includes
+    /// prohibiting zero-width matches that split a codepoint.
+    ///
+    /// UTF-8 mode is enabled by default. Notice below how the only zero-width
+    /// matches reported are those at UTF-8 boundaries:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build(r"")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let mut input = Input::new("☃");
+    /// let mut matches = vec![];
+    /// loop {
+    ///     match dfa.try_search_rev(&mut cache, &input)? {
+    ///         None => break,
+    ///         Some(hm) => {
+    ///             matches.push(hm);
+    ///             if hm.offset() == 0 || input.end() == 0 {
+    ///                 break;
+    ///             } else if hm.offset() < input.end() {
+    ///                 input.set_end(hm.offset());
+    ///             } else {
+    ///                 // This is only necessary to handle zero-width
+    ///                 // matches, which of course occur in this example.
+    ///                 // Without this, the search would never advance
+    ///                 // backwards beyond the initial match.
+    ///                 input.set_end(input.end() - 1);
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Now let's look at the same example, but with UTF-8 mode on the
+    /// underlying NFA disabled:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .thompson(thompson::Config::new().reverse(true).utf8(false))
+    ///     .build(r"")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let mut input = Input::new("☃");
+    /// let mut matches = vec![];
+    /// loop {
+    ///     match dfa.try_search_rev(&mut cache, &input)? {
+    ///         None => break,
+    ///         Some(hm) => {
+    ///             matches.push(hm);
+    ///             if hm.offset() == 0 || input.end() == 0 {
+    ///                 break;
+    ///             } else if hm.offset() < input.end() {
+    ///                 input.set_end(hm.offset());
+    ///             } else {
+    ///                 // This is only necessary to handle zero-width
+    ///                 // matches, which of course occur in this example.
+    ///                 // Without this, the search would never advance
+    ///                 // backwards beyond the initial match.
+    ///                 input.set_end(input.end() - 1);
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 2),
+    ///     HalfMatch::must(0, 1),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_rev(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        let hm = match search::find_rev(self, cache, input)? {
+            None => return Ok(None),
+            Some(hm) if !utf8empty => return Ok(Some(hm)),
+            Some(hm) => hm,
+        };
+        empty::skip_splits_rev(input, hm, hm.offset(), |input| {
+            let got = search::find_rev(self, cache, input)?;
+            Ok(got.map(|hm| (hm, hm.offset())))
+        })
+    }
+
+    /// Executes an overlapping forward search and returns the end position of
+    /// matches as they are found. If no match exists, then `None` is returned.
+    ///
+    /// This routine is principally only useful when searching for multiple
+    /// patterns on inputs where multiple patterns may match the same regions
+    /// of text. In particular, callers must preserve the automaton's search
+    /// state from prior calls so that the implementation knows where the last
+    /// match occurred.
+    ///
+    /// When using this routine to implement an iterator of overlapping
+    /// matches, the `start` of the search should remain invariant throughout
+    /// iteration. The `OverlappingState` given to the search will keep track
+    /// of the current position of the search. (This is because multiple
+    /// matches may be reported at the same position, so only the search
+    /// implementation itself knows when to advance the position.)
+    ///
+    /// If for some reason you want the search to forget about its previous
+    /// state and restart the search at a particular position, then setting the
+    /// state to [`OverlappingState::start`] will accomplish that.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to run a basic overlapping search. Notice
+    /// that we build the automaton with a `MatchKind::All` configuration.
+    /// Overlapping searches are unlikely to work as one would expect when
+    /// using the default `MatchKind::LeftmostFirst` match semantics, since
+    /// leftmost-first matching is fundamentally incompatible with overlapping
+    /// searches. Namely, overlapping searches need to report matches as they
+    /// are seen, where as leftmost-first searches will continue searching even
+    /// after a match has been observed in order to find the conventional end
+    /// position of the match. More concretely, leftmost-first searches use
+    /// dead states to terminate a search after a specific match can no longer
+    /// be extended. Overlapping searches instead do the opposite by continuing
+    /// the search to find totally new matches (potentially of other patterns).
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     hybrid::dfa::{DFA, OverlappingState},
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build_many(&[r"\w+$", r"\S+$"])?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "@foo";
+    /// let mut state = OverlappingState::start();
+    ///
+    /// let expected = Some(HalfMatch::must(1, 4));
+    /// dfa.try_search_overlapping_fwd(
+    ///     &mut cache, &Input::new(haystack), &mut state,
+    /// )?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// // The first pattern also matches at the same position, so re-running
+    /// // the search will yield another match. Notice also that the first
+    /// // pattern is returned after the second. This is because the second
+    /// // pattern begins its match before the first, is therefore an earlier
+    /// // match and is thus reported first.
+    /// let expected = Some(HalfMatch::must(0, 4));
+    /// dfa.try_search_overlapping_fwd(
+    ///     &mut cache, &Input::new(haystack), &mut state,
+    /// )?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_overlapping_fwd(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        search::find_overlapping_fwd(self, cache, input, state)?;
+        match state.get_match() {
+            None => Ok(()),
+            Some(_) if !utf8empty => Ok(()),
+            Some(_) => skip_empty_utf8_splits_overlapping(
+                input,
+                state,
+                |input, state| {
+                    search::find_overlapping_fwd(self, cache, input, state)
+                },
+            ),
+        }
+    }
+
+    /// Executes a reverse overlapping search and returns the start of the
+    /// position of the leftmost match that is found. If no match exists, then
+    /// `None` is returned.
+    ///
+    /// When using this routine to implement an iterator of overlapping
+    /// matches, the `start` of the search should remain invariant throughout
+    /// iteration. The `OverlappingState` given to the search will keep track
+    /// of the current position of the search. (This is because multiple
+    /// matches may be reported at the same position, so only the search
+    /// implementation itself knows when to advance the position.)
+    ///
+    /// If for some reason you want the search to forget about its previous
+    /// state and restart the search at a particular position, then setting the
+    /// state to [`OverlappingState::start`] will accomplish that.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example: UTF-8 mode
+    ///
+    /// This examples demonstrates that UTF-8 mode applies to reverse
+    /// DFAs. When UTF-8 mode is enabled in the underlying NFA, then all
+    /// matches reported must correspond to valid UTF-8 spans. This includes
+    /// prohibiting zero-width matches that split a codepoint.
+    ///
+    /// UTF-8 mode is enabled by default. Notice below how the only zero-width
+    /// matches reported are those at UTF-8 boundaries:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::{DFA, OverlappingState},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build_many(&[r"", r"☃"])?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let input = Input::new("☃");
+    /// let mut state = OverlappingState::start();
+    /// let mut matches = vec![];
+    /// loop {
+    ///     dfa.try_search_overlapping_rev(&mut cache, &input, &mut state)?;
+    ///     match state.get_match() {
+    ///         None => break,
+    ///         Some(hm) => matches.push(hm),
+    ///     }
+    /// }
+    ///
+    /// // No matches split a codepoint.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(1, 0),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Now let's look at the same example, but with UTF-8 mode on the
+    /// underlying NFA disabled:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::{DFA, OverlappingState},
+    ///     nfa::thompson,
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .thompson(thompson::Config::new().reverse(true).utf8(false))
+    ///     .build_many(&[r"", r"☃"])?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // Run the reverse DFA to collect all matches.
+    /// let input = Input::new("☃");
+    /// let mut state = OverlappingState::start();
+    /// let mut matches = vec![];
+    /// loop {
+    ///     dfa.try_search_overlapping_rev(&mut cache, &input, &mut state)?;
+    ///     match state.get_match() {
+    ///         None => break,
+    ///         Some(hm) => matches.push(hm),
+    ///     }
+    /// }
+    ///
+    /// // Now *all* positions match, even within a codepoint,
+    /// // because we lifted the requirement that matches
+    /// // correspond to valid UTF-8 spans.
+    /// let expected = vec![
+    ///     HalfMatch::must(0, 3),
+    ///     HalfMatch::must(0, 2),
+    ///     HalfMatch::must(0, 1),
+    ///     HalfMatch::must(1, 0),
+    ///     HalfMatch::must(0, 0),
+    /// ];
+    /// assert_eq!(expected, matches);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_overlapping_rev(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        state: &mut OverlappingState,
+    ) -> Result<(), MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        search::find_overlapping_rev(self, cache, input, state)?;
+        match state.get_match() {
+            None => Ok(()),
+            Some(_) if !utf8empty => Ok(()),
+            Some(_) => skip_empty_utf8_splits_overlapping(
+                input,
+                state,
+                |input, state| {
+                    search::find_overlapping_rev(self, cache, input, state)
+                },
+            ),
+        }
+    }
+
+    /// Writes the set of patterns that match anywhere in the given search
+    /// configuration to `patset`. If multiple patterns match at the same
+    /// position and the underlying DFA supports overlapping matches, then all
+    /// matching patterns are written to the given set.
+    ///
+    /// Unless all of the patterns in this DFA are anchored, then generally
+    /// speaking, this will visit every byte in the haystack.
+    ///
+    /// This search routine *does not* clear the pattern set. This gives some
+    /// flexibility to the caller (e.g., running multiple searches with the
+    /// same pattern set), but does make the API bug-prone if you're reusing
+    /// the same pattern set for multiple searches but intended them to be
+    /// independent.
+    ///
+    /// If a pattern ID matched but the given `PatternSet` does not have
+    /// sufficient capacity to store it, then it is not inserted and silently
+    /// dropped.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find all matching patterns in a haystack,
+    /// even when some patterns match at the same position as other patterns.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     Input, MatchKind, PatternSet,
+    /// };
+    ///
+    /// let patterns = &[
+    ///     r"\w+", r"\d+", r"\pL+", r"foo", r"bar", r"barfoo", r"foobar",
+    /// ];
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build_many(patterns)?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let input = Input::new("foobar");
+    /// let mut patset = PatternSet::new(dfa.pattern_len());
+    /// dfa.try_which_overlapping_matches(&mut cache, &input, &mut patset)?;
+    /// let expected = vec![0, 2, 3, 4, 6];
+    /// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) -> Result<(), MatchError> {
+        let mut state = OverlappingState::start();
+        while let Some(m) = {
+            self.try_search_overlapping_fwd(cache, input, &mut state)?;
+            state.get_match()
+        } {
+            let _ = patset.try_insert(m.pattern());
+            // There's nothing left to find, so we can stop. Or the caller
+            // asked us to.
+            if patset.is_full() || input.get_earliest() {
+                break;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl DFA {
+    /// Transitions from the current state to the next state, given the next
+    /// byte of input.
+    ///
+    /// The given cache is used to either reuse pre-computed state
+    /// transitions, or to store this newly computed transition for future
+    /// reuse. Thus, this routine guarantees that it will never return a state
+    /// ID that has an "unknown" tag.
+    ///
+    /// # State identifier validity
+    ///
+    /// The only valid value for `current` is the lazy state ID returned
+    /// by the most recent call to `next_state`, `next_state_untagged`,
+    /// `next_state_untagged_unchecked`, `start_state_forward` or
+    /// `state_state_reverse` for the given `cache`. Any state ID returned from
+    /// prior calls to these routines (with the same `cache`) is considered
+    /// invalid (even if it gives an appearance of working). State IDs returned
+    /// from _any_ prior call for different `cache` values are also always
+    /// invalid.
+    ///
+    /// The returned ID is always a valid ID when `current` refers to a valid
+    /// ID. Moreover, this routine is defined for all possible values of
+    /// `input`.
+    ///
+    /// These validity rules are not checked, even in debug mode. Callers are
+    /// required to uphold these rules themselves.
+    ///
+    /// Violating these state ID validity rules will not sacrifice memory
+    /// safety, but _may_ produce an incorrect result or a panic.
+    ///
+    /// # Panics
+    ///
+    /// If the given ID does not refer to a valid state, then this routine
+    /// may panic but it also may not panic and instead return an invalid or
+    /// incorrect ID.
+    ///
+    /// # Example
+    ///
+    /// This shows a simplistic example for walking a lazy DFA for a given
+    /// haystack by using the `next_state` method.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, Input};
+    ///
+    /// let dfa = DFA::new(r"[a-z]+r")?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut sid = dfa.start_state_forward(
+    ///     &mut cache, &Input::new(haystack),
+    /// )?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     sid = dfa.next_state(&mut cache, sid, b)?;
+    /// }
+    /// // Matches are always delayed by 1 byte, so we must explicitly walk the
+    /// // special "EOI" transition at the end of the search.
+    /// sid = dfa.next_eoi_state(&mut cache, sid)?;
+    /// assert!(sid.is_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn next_state(
+        &self,
+        cache: &mut Cache,
+        current: LazyStateID,
+        input: u8,
+    ) -> Result<LazyStateID, CacheError> {
+        let class = usize::from(self.classes.get(input));
+        let offset = current.as_usize_untagged() + class;
+        let sid = cache.trans[offset];
+        if !sid.is_unknown() {
+            return Ok(sid);
+        }
+        let unit = alphabet::Unit::u8(input);
+        Lazy::new(self, cache).cache_next_state(current, unit)
+    }
+
+    /// Transitions from the current state to the next state, given the next
+    /// byte of input and a state ID that is not tagged.
+    ///
+    /// The only reason to use this routine is performance. In particular, the
+    /// `next_state` method needs to do some additional checks, among them is
+    /// to account for identifiers to states that are not yet computed. In
+    /// such a case, the transition is computed on the fly. However, if it is
+    /// known that the `current` state ID is untagged, then these checks can be
+    /// omitted.
+    ///
+    /// Since this routine does not compute states on the fly, it does not
+    /// modify the cache and thus cannot return an error. Consequently, `cache`
+    /// does not need to be mutable and it is possible for this routine to
+    /// return a state ID corresponding to the special "unknown" state. In
+    /// this case, it is the caller's responsibility to use the prior state
+    /// ID and `input` with `next_state` in order to force the computation of
+    /// the unknown transition. Otherwise, trying to use the "unknown" state
+    /// ID will just result in transitioning back to itself, and thus never
+    /// terminating. (This is technically a special exemption to the state ID
+    /// validity rules, but is permissible since this routine is guarateed to
+    /// never mutate the given `cache`, and thus the identifier is guaranteed
+    /// to remain valid.)
+    ///
+    /// See [`LazyStateID`] for more details on what it means for a state ID
+    /// to be tagged. Also, see
+    /// [`next_state_untagged_unchecked`](DFA::next_state_untagged_unchecked)
+    /// for this same idea, but with bounds checks forcefully elided.
+    ///
+    /// # State identifier validity
+    ///
+    /// The only valid value for `current` is an **untagged** lazy
+    /// state ID returned by the most recent call to `next_state`,
+    /// `next_state_untagged`, `next_state_untagged_unchecked`,
+    /// `start_state_forward` or `state_state_reverse` for the given `cache`.
+    /// Any state ID returned from prior calls to these routines (with the
+    /// same `cache`) is considered invalid (even if it gives an appearance
+    /// of working). State IDs returned from _any_ prior call for different
+    /// `cache` values are also always invalid.
+    ///
+    /// The returned ID is always a valid ID when `current` refers to a valid
+    /// ID, although it may be tagged. Moreover, this routine is defined for
+    /// all possible values of `input`.
+    ///
+    /// Not all validity rules are checked, even in debug mode. Callers are
+    /// required to uphold these rules themselves.
+    ///
+    /// Violating these state ID validity rules will not sacrifice memory
+    /// safety, but _may_ produce an incorrect result or a panic.
+    ///
+    /// # Panics
+    ///
+    /// If the given ID does not refer to a valid state, then this routine
+    /// may panic but it also may not panic and instead return an invalid or
+    /// incorrect ID.
+    ///
+    /// # Example
+    ///
+    /// This shows a simplistic example for walking a lazy DFA for a given
+    /// haystack by using the `next_state_untagged` method where possible.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, Input};
+    ///
+    /// let dfa = DFA::new(r"[a-z]+r")?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut sid = dfa.start_state_forward(
+    ///     &mut cache, &Input::new(haystack),
+    /// )?;
+    /// // Walk all the bytes in the haystack.
+    /// let mut at = 0;
+    /// while at < haystack.len() {
+    ///     if sid.is_tagged() {
+    ///         sid = dfa.next_state(&mut cache, sid, haystack[at])?;
+    ///     } else {
+    ///         let mut prev_sid = sid;
+    ///         // We attempt to chew through as much as we can while moving
+    ///         // through untagged state IDs. Thus, the transition function
+    ///         // does less work on average per byte. (Unrolling this loop
+    ///         // may help even more.)
+    ///         while at < haystack.len() {
+    ///             prev_sid = sid;
+    ///             sid = dfa.next_state_untagged(
+    ///                 &mut cache, sid, haystack[at],
+    ///             );
+    ///             at += 1;
+    ///             if sid.is_tagged() {
+    ///                 break;
+    ///             }
+    ///         }
+    ///         // We must ensure that we never proceed to the next iteration
+    ///         // with an unknown state ID. If we don't account for this
+    ///         // case, then search isn't guaranteed to terminate since all
+    ///         // transitions on unknown states loop back to itself.
+    ///         if sid.is_unknown() {
+    ///             sid = dfa.next_state(
+    ///                 &mut cache, prev_sid, haystack[at - 1],
+    ///             )?;
+    ///         }
+    ///     }
+    /// }
+    /// // Matches are always delayed by 1 byte, so we must explicitly walk the
+    /// // special "EOI" transition at the end of the search.
+    /// sid = dfa.next_eoi_state(&mut cache, sid)?;
+    /// assert!(sid.is_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn next_state_untagged(
+        &self,
+        cache: &Cache,
+        current: LazyStateID,
+        input: u8,
+    ) -> LazyStateID {
+        debug_assert!(!current.is_tagged());
+        let class = usize::from(self.classes.get(input));
+        let offset = current.as_usize_unchecked() + class;
+        cache.trans[offset]
+    }
+
+    /// Transitions from the current state to the next state, eliding bounds
+    /// checks, given the next byte of input and a state ID that is not tagged.
+    ///
+    /// The only reason to use this routine is performance. In particular, the
+    /// `next_state` method needs to do some additional checks, among them is
+    /// to account for identifiers to states that are not yet computed. In
+    /// such a case, the transition is computed on the fly. However, if it is
+    /// known that the `current` state ID is untagged, then these checks can be
+    /// omitted.
+    ///
+    /// Since this routine does not compute states on the fly, it does not
+    /// modify the cache and thus cannot return an error. Consequently, `cache`
+    /// does not need to be mutable and it is possible for this routine to
+    /// return a state ID corresponding to the special "unknown" state. In
+    /// this case, it is the caller's responsibility to use the prior state
+    /// ID and `input` with `next_state` in order to force the computation of
+    /// the unknown transition. Otherwise, trying to use the "unknown" state
+    /// ID will just result in transitioning back to itself, and thus never
+    /// terminating. (This is technically a special exemption to the state ID
+    /// validity rules, but is permissible since this routine is guarateed to
+    /// never mutate the given `cache`, and thus the identifier is guaranteed
+    /// to remain valid.)
+    ///
+    /// See [`LazyStateID`] for more details on what it means for a state ID
+    /// to be tagged. Also, see
+    /// [`next_state_untagged`](DFA::next_state_untagged)
+    /// for this same idea, but with memory safety guaranteed by retaining
+    /// bounds checks.
+    ///
+    /// # State identifier validity
+    ///
+    /// The only valid value for `current` is an **untagged** lazy
+    /// state ID returned by the most recent call to `next_state`,
+    /// `next_state_untagged`, `next_state_untagged_unchecked`,
+    /// `start_state_forward` or `state_state_reverse` for the given `cache`.
+    /// Any state ID returned from prior calls to these routines (with the
+    /// same `cache`) is considered invalid (even if it gives an appearance
+    /// of working). State IDs returned from _any_ prior call for different
+    /// `cache` values are also always invalid.
+    ///
+    /// The returned ID is always a valid ID when `current` refers to a valid
+    /// ID, although it may be tagged. Moreover, this routine is defined for
+    /// all possible values of `input`.
+    ///
+    /// Not all validity rules are checked, even in debug mode. Callers are
+    /// required to uphold these rules themselves.
+    ///
+    /// Violating these state ID validity rules will not sacrifice memory
+    /// safety, but _may_ produce an incorrect result or a panic.
+    ///
+    /// # Safety
+    ///
+    /// Callers of this method must guarantee that `current` refers to a valid
+    /// state ID according to the rules described above. If `current` is not a
+    /// valid state ID for this automaton, then calling this routine may result
+    /// in undefined behavior.
+    ///
+    /// If `current` is valid, then the ID returned is valid for all possible
+    /// values of `input`.
+    #[inline]
+    pub unsafe fn next_state_untagged_unchecked(
+        &self,
+        cache: &Cache,
+        current: LazyStateID,
+        input: u8,
+    ) -> LazyStateID {
+        debug_assert!(!current.is_tagged());
+        let class = usize::from(self.classes.get(input));
+        let offset = current.as_usize_unchecked() + class;
+        *cache.trans.get_unchecked(offset)
+    }
+
+    /// Transitions from the current state to the next state for the special
+    /// EOI symbol.
+    ///
+    /// The given cache is used to either reuse pre-computed state
+    /// transitions, or to store this newly computed transition for future
+    /// reuse. Thus, this routine guarantees that it will never return a state
+    /// ID that has an "unknown" tag.
+    ///
+    /// This routine must be called at the end of every search in a correct
+    /// implementation of search. Namely, lazy DFAs in this crate delay matches
+    /// by one byte in order to support look-around operators. Thus, after
+    /// reaching the end of a haystack, a search implementation must follow one
+    /// last EOI transition.
+    ///
+    /// It is best to think of EOI as an additional symbol in the alphabet of a
+    /// DFA that is distinct from every other symbol. That is, the alphabet of
+    /// lazy DFAs in this crate has a logical size of 257 instead of 256, where
+    /// 256 corresponds to every possible inhabitant of `u8`. (In practice, the
+    /// physical alphabet size may be smaller because of alphabet compression
+    /// via equivalence classes, but EOI is always represented somehow in the
+    /// alphabet.)
+    ///
+    /// # State identifier validity
+    ///
+    /// The only valid value for `current` is the lazy state ID returned
+    /// by the most recent call to `next_state`, `next_state_untagged`,
+    /// `next_state_untagged_unchecked`, `start_state_forward` or
+    /// `state_state_reverse` for the given `cache`. Any state ID returned from
+    /// prior calls to these routines (with the same `cache`) is considered
+    /// invalid (even if it gives an appearance of working). State IDs returned
+    /// from _any_ prior call for different `cache` values are also always
+    /// invalid.
+    ///
+    /// The returned ID is always a valid ID when `current` refers to a valid
+    /// ID.
+    ///
+    /// These validity rules are not checked, even in debug mode. Callers are
+    /// required to uphold these rules themselves.
+    ///
+    /// Violating these state ID validity rules will not sacrifice memory
+    /// safety, but _may_ produce an incorrect result or a panic.
+    ///
+    /// # Panics
+    ///
+    /// If the given ID does not refer to a valid state, then this routine
+    /// may panic but it also may not panic and instead return an invalid or
+    /// incorrect ID.
+    ///
+    /// # Example
+    ///
+    /// This shows a simplistic example for walking a DFA for a given haystack,
+    /// and then finishing the search with the final EOI transition.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, Input};
+    ///
+    /// let dfa = DFA::new(r"[a-z]+r")?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut sid = dfa.start_state_forward(
+    ///     &mut cache, &Input::new(haystack),
+    /// )?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     sid = dfa.next_state(&mut cache, sid, b)?;
+    /// }
+    /// // Matches are always delayed by 1 byte, so we must explicitly walk
+    /// // the special "EOI" transition at the end of the search. Without this
+    /// // final transition, the assert below will fail since the DFA will not
+    /// // have entered a match state yet!
+    /// sid = dfa.next_eoi_state(&mut cache, sid)?;
+    /// assert!(sid.is_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn next_eoi_state(
+        &self,
+        cache: &mut Cache,
+        current: LazyStateID,
+    ) -> Result<LazyStateID, CacheError> {
+        let eoi = self.classes.eoi().as_usize();
+        let offset = current.as_usize_untagged() + eoi;
+        let sid = cache.trans[offset];
+        if !sid.is_unknown() {
+            return Ok(sid);
+        }
+        let unit = self.classes.eoi();
+        Lazy::new(self, cache).cache_next_state(current, unit)
+    }
+
+    /// Return the ID of the start state for this lazy DFA when executing a
+    /// forward search.
+    ///
+    /// Unlike typical DFA implementations, the start state for DFAs in this
+    /// crate is dependent on a few different factors:
+    ///
+    /// * The [`Anchored`] mode of the search. Unanchored, anchored and
+    /// anchored searches for a specific [`PatternID`] all use different start
+    /// states.
+    /// * The position at which the search begins, via [`Input::start`]. This
+    /// and the byte immediately preceding the start of the search (if one
+    /// exists) influence which look-behind assertions are true at the start
+    /// of the search. This in turn influences which start state is selected.
+    /// * Whether the search is a forward or reverse search. This routine can
+    /// only be used for forward searches.
+    ///
+    /// # Errors
+    ///
+    /// This may return a [`MatchError`] (not a [`CacheError`]!) if the search
+    /// needs to give up when determining the start state (for example, if
+    /// it sees a "quit" byte or if the cache has been cleared too many
+    /// times). This can also return an error if the given `Input` contains an
+    /// unsupported [`Anchored`] configuration.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn start_state_forward(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<LazyStateID, MatchError> {
+        if !self.quitset.is_empty() && input.start() > 0 {
+            let offset = input.start() - 1;
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start_type = self.start_map.fwd(input);
+        let start = LazyRef::new(self, cache)
+            .get_cached_start_id(input, start_type)?;
+        if !start.is_unknown() {
+            return Ok(start);
+        }
+        Lazy::new(self, cache).cache_start_group(input, start_type)
+    }
+
+    /// Return the ID of the start state for this lazy DFA when executing a
+    /// reverse search.
+    ///
+    /// Unlike typical DFA implementations, the start state for DFAs in this
+    /// crate is dependent on a few different factors:
+    ///
+    /// * The [`Anchored`] mode of the search. Unanchored, anchored and
+    /// anchored searches for a specific [`PatternID`] all use different start
+    /// states.
+    /// * The position at which the search begins, via [`Input::start`]. This
+    /// and the byte immediately preceding the start of the search (if one
+    /// exists) influence which look-behind assertions are true at the start
+    /// of the search. This in turn influences which start state is selected.
+    /// * Whether the search is a forward or reverse search. This routine can
+    /// only be used for reverse searches.
+    ///
+    /// # Errors
+    ///
+    /// This may return a [`MatchError`] (not a [`CacheError`]!) if the search
+    /// needs to give up when determining the start state (for example, if
+    /// it sees a "quit" byte or if the cache has been cleared too many
+    /// times). This can also return an error if the given `Input` contains an
+    /// unsupported [`Anchored`] configuration.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn start_state_reverse(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<LazyStateID, MatchError> {
+        if !self.quitset.is_empty() && input.end() < input.haystack().len() {
+            let offset = input.end();
+            let byte = input.haystack()[offset];
+            if self.quitset.contains(byte) {
+                return Err(MatchError::quit(byte, offset));
+            }
+        }
+        let start_type = self.start_map.rev(input);
+        let start = LazyRef::new(self, cache)
+            .get_cached_start_id(input, start_type)?;
+        if !start.is_unknown() {
+            return Ok(start);
+        }
+        Lazy::new(self, cache).cache_start_group(input, start_type)
+    }
+
+    /// Returns the total number of patterns that match in this state.
+    ///
+    /// If the lazy DFA was compiled with one pattern, then this must
+    /// necessarily always return `1` for all match states.
+    ///
+    /// A lazy DFA guarantees that [`DFA::match_pattern`] can be called with
+    /// indices up to (but not including) the length returned by this routine
+    /// without panicking.
+    ///
+    /// # Panics
+    ///
+    /// If the given state is not a match state, then this may either panic
+    /// or return an incorrect result.
+    ///
+    /// # Example
+    ///
+    /// This example shows a simple instance of implementing overlapping
+    /// matches. In particular, it shows not only how to determine how many
+    /// patterns have matched in a particular state, but also how to access
+    /// which specific patterns have matched.
+    ///
+    /// Notice that we must use [`MatchKind::All`] when building the DFA. If we
+    /// used [`MatchKind::LeftmostFirst`] instead, then the DFA would not be
+    /// constructed in a way that supports overlapping matches. (It would only
+    /// report a single pattern that matches at any particular point in time.)
+    ///
+    /// Another thing to take note of is the patterns used and the order in
+    /// which the pattern IDs are reported. In the example below, pattern `3`
+    /// is yielded first. Why? Because it corresponds to the match that
+    /// appears first. Namely, the `@` symbol is part of `\S+` but not part
+    /// of any of the other patterns. Since the `\S+` pattern has a match that
+    /// starts to the left of any other pattern, its ID is returned before any
+    /// other.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, Input, MatchKind};
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build_many(&[
+    ///         r"\w+", r"[a-z]+", r"[A-Z]+", r"\S+",
+    ///     ])?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "@bar".as_bytes();
+    ///
+    /// // The start state is determined by inspecting the position and the
+    /// // initial bytes of the haystack.
+    /// let mut sid = dfa.start_state_forward(
+    ///     &mut cache, &Input::new(haystack),
+    /// )?;
+    /// // Walk all the bytes in the haystack.
+    /// for &b in haystack {
+    ///     sid = dfa.next_state(&mut cache, sid, b)?;
+    /// }
+    /// sid = dfa.next_eoi_state(&mut cache, sid)?;
+    ///
+    /// assert!(sid.is_match());
+    /// assert_eq!(dfa.match_len(&mut cache, sid), 3);
+    /// // The following calls are guaranteed to not panic since `match_len`
+    /// // returned `3` above.
+    /// assert_eq!(dfa.match_pattern(&mut cache, sid, 0).as_usize(), 3);
+    /// assert_eq!(dfa.match_pattern(&mut cache, sid, 1).as_usize(), 0);
+    /// assert_eq!(dfa.match_pattern(&mut cache, sid, 2).as_usize(), 1);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn match_len(&self, cache: &Cache, id: LazyStateID) -> usize {
+        assert!(id.is_match());
+        LazyRef::new(self, cache).get_cached_state(id).match_len()
+    }
+
+    /// Returns the pattern ID corresponding to the given match index in the
+    /// given state.
+    ///
+    /// See [`DFA::match_len`] for an example of how to use this method
+    /// correctly. Note that if you know your lazy DFA is configured with a
+    /// single pattern, then this routine is never necessary since it will
+    /// always return a pattern ID of `0` for an index of `0` when `id`
+    /// corresponds to a match state.
+    ///
+    /// Typically, this routine is used when implementing an overlapping
+    /// search, as the example for `DFA::match_len` does.
+    ///
+    /// # Panics
+    ///
+    /// If the state ID is not a match state or if the match index is out
+    /// of bounds for the given state, then this routine may either panic
+    /// or produce an incorrect result. If the state ID is correct and the
+    /// match index is correct, then this routine always produces a valid
+    /// `PatternID`.
+    #[inline]
+    pub fn match_pattern(
+        &self,
+        cache: &Cache,
+        id: LazyStateID,
+        match_index: usize,
+    ) -> PatternID {
+        // This is an optimization for the very common case of a DFA with a
+        // single pattern. This conditional avoids a somewhat more costly path
+        // that finds the pattern ID from the corresponding `State`, which
+        // requires a bit of slicing/pointer-chasing. This optimization tends
+        // to only matter when matches are frequent.
+        if self.pattern_len() == 1 {
+            return PatternID::ZERO;
+        }
+        LazyRef::new(self, cache)
+            .get_cached_state(id)
+            .match_pattern(match_index)
+    }
+}
+
+/// A cache represents a partially computed DFA.
+///
+/// A cache is the key component that differentiates a classical DFA and a
+/// hybrid NFA/DFA (also called a "lazy DFA"). Where a classical DFA builds a
+/// complete transition table that can handle all possible inputs, a hybrid
+/// NFA/DFA starts with an empty transition table and builds only the parts
+/// required during search. The parts that are built are stored in a cache. For
+/// this reason, a cache is a required parameter for nearly every operation on
+/// a [`DFA`].
+///
+/// Caches can be created from their corresponding DFA via
+/// [`DFA::create_cache`]. A cache can only be used with either the DFA that
+/// created it, or the DFA that was most recently used to reset it with
+/// [`Cache::reset`]. Using a cache with any other DFA may result in panics
+/// or incorrect results.
+#[derive(Clone, Debug)]
+pub struct Cache {
+    // N.B. If you're looking to understand how determinization works, it
+    // is probably simpler to first grok src/dfa/determinize.rs, since that
+    // doesn't have the "laziness" component.
+    /// The transition table.
+    ///
+    /// Given a `current` LazyStateID and an `input` byte, the next state can
+    /// be computed via `trans[untagged(current) + equiv_class(input)]`. Notice
+    /// that no multiplication is used. That's because state identifiers are
+    /// "premultiplied."
+    ///
+    /// Note that the next state may be the "unknown" state. In this case, the
+    /// next state is not known and determinization for `current` on `input`
+    /// must be performed.
+    trans: Vec<LazyStateID>,
+    /// The starting states for this DFA.
+    ///
+    /// These are computed lazily. Initially, these are all set to "unknown"
+    /// lazy state IDs.
+    ///
+    /// When 'starts_for_each_pattern' is disabled (the default), then the size
+    /// of this is constrained to the possible starting configurations based
+    /// on the search parameters. (At time of writing, that's 4.) However,
+    /// when starting states for each pattern is enabled, then there are N
+    /// additional groups of starting states, where each group reflects the
+    /// different possible configurations and N is the number of patterns.
+    starts: Vec<LazyStateID>,
+    /// A sequence of NFA/DFA powerset states that have been computed for this
+    /// lazy DFA. This sequence is indexable by untagged LazyStateIDs. (Every
+    /// tagged LazyStateID can be used to index this sequence by converting it
+    /// to its untagged form.)
+    states: Vec<State>,
+    /// A map from states to their corresponding IDs. This map may be accessed
+    /// via the raw byte representation of a state, which means that a `State`
+    /// does not need to be allocated to determine whether it already exists
+    /// in this map. Indeed, the existence of such a state is what determines
+    /// whether we allocate a new `State` or not.
+    ///
+    /// The higher level idea here is that we do just enough determinization
+    /// for a state to check whether we've already computed it. If we have,
+    /// then we can save a little (albeit not much) work. The real savings is
+    /// in memory usage. If we never checked for trivially duplicate states,
+    /// then our memory usage would explode to unreasonable levels.
+    states_to_id: StateMap,
+    /// Sparse sets used to track which NFA states have been visited during
+    /// various traversals.
+    sparses: SparseSets,
+    /// Scratch space for traversing the NFA graph. (We use space on the heap
+    /// instead of the call stack.)
+    stack: Vec<NFAStateID>,
+    /// Scratch space for building a NFA/DFA powerset state. This is used to
+    /// help amortize allocation since not every powerset state generated is
+    /// added to the cache. In particular, if it already exists in the cache,
+    /// then there is no need to allocate a new `State` for it.
+    scratch_state_builder: StateBuilderEmpty,
+    /// A simple abstraction for handling the saving of at most a single state
+    /// across a cache clearing. This is required for correctness. Namely, if
+    /// adding a new state after clearing the cache fails, then the caller
+    /// must retain the ability to continue using the state ID given. The
+    /// state corresponding to the state ID is what we preserve across cache
+    /// clearings.
+    state_saver: StateSaver,
+    /// The memory usage, in bytes, used by 'states' and 'states_to_id'. We
+    /// track this as new states are added since states use a variable amount
+    /// of heap. Tracking this as we add states makes it possible to compute
+    /// the total amount of memory used by the determinizer in constant time.
+    memory_usage_state: usize,
+    /// The number of times the cache has been cleared. When a minimum cache
+    /// clear count is set, then the cache will return an error instead of
+    /// clearing the cache if the count has been exceeded.
+    clear_count: usize,
+    /// The total number of bytes searched since the last time this cache was
+    /// cleared, not including the current search.
+    ///
+    /// This can be added to the length of the current search to get the true
+    /// total number of bytes searched.
+    ///
+    /// This is generally only non-zero when the
+    /// `Cache::search_{start,update,finish}` APIs are used to track search
+    /// progress.
+    bytes_searched: usize,
+    /// The progress of the current search.
+    ///
+    /// This is only non-`None` when callers utlize the `Cache::search_start`,
+    /// `Cache::search_update` and `Cache::search_finish` APIs.
+    ///
+    /// The purpose of recording search progress is to be able to make a
+    /// determination about the efficiency of the cache. Namely, by keeping
+    /// track of the
+    progress: Option<SearchProgress>,
+}
+
+impl Cache {
+    /// Create a new cache for the given lazy DFA.
+    ///
+    /// The cache returned should only be used for searches for the given DFA.
+    /// If you want to reuse the cache for another DFA, then you must call
+    /// [`Cache::reset`] with that DFA.
+    pub fn new(dfa: &DFA) -> Cache {
+        let mut cache = Cache {
+            trans: alloc::vec![],
+            starts: alloc::vec![],
+            states: alloc::vec![],
+            states_to_id: StateMap::new(),
+            sparses: SparseSets::new(dfa.get_nfa().states().len()),
+            stack: alloc::vec![],
+            scratch_state_builder: StateBuilderEmpty::new(),
+            state_saver: StateSaver::none(),
+            memory_usage_state: 0,
+            clear_count: 0,
+            bytes_searched: 0,
+            progress: None,
+        };
+        debug!("pre-init lazy DFA cache size: {}", cache.memory_usage());
+        Lazy { dfa, cache: &mut cache }.init_cache();
+        debug!("post-init lazy DFA cache size: {}", cache.memory_usage());
+        cache
+    }
+
+    /// Reset this cache such that it can be used for searching with the given
+    /// lazy DFA (and only that DFA).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different lazy DFA.
+    ///
+    /// Resetting a cache sets its "clear count" to 0. This is relevant if the
+    /// lazy DFA has been configured to "give up" after it has cleared the
+    /// cache a certain number of times.
+    ///
+    /// Any lazy state ID generated by the cache prior to resetting it is
+    /// invalid after the reset.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different DFA.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let dfa1 = DFA::new(r"\w")?;
+    /// let dfa2 = DFA::new(r"\W")?;
+    ///
+    /// let mut cache = dfa1.create_cache();
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 2)),
+    ///     dfa1.try_search_fwd(&mut cache, &Input::new("Δ"))?,
+    /// );
+    ///
+    /// // Using 'cache' with dfa2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the DFA we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 'dfa1' is also not
+    /// // allowed.
+    /// cache.reset(&dfa2);
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 3)),
+    ///     dfa2.try_search_fwd(&mut cache, &Input::new("☃"))?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, dfa: &DFA) {
+        Lazy::new(dfa, self).reset_cache()
+    }
+
+    /// Initializes a new search starting at the given position.
+    ///
+    /// If a previous search was unfinished, then it is finished automatically
+    /// and a new search is begun.
+    ///
+    /// Note that keeping track of search progress is _not necessary_
+    /// for correct implementations of search using a lazy DFA. Keeping
+    /// track of search progress is only necessary if you want the
+    /// [`Config::minimum_bytes_per_state`] configuration knob to work.
+    #[inline]
+    pub fn search_start(&mut self, at: usize) {
+        // If a previous search wasn't marked as finished, then finish it
+        // now automatically.
+        if let Some(p) = self.progress.take() {
+            self.bytes_searched += p.len();
+        }
+        self.progress = Some(SearchProgress { start: at, at });
+    }
+
+    /// Updates the current search to indicate that it has search to the
+    /// current position.
+    ///
+    /// No special care needs to be taken for reverse searches. Namely, the
+    /// position given may be _less than_ the starting position of the search.
+    ///
+    /// # Panics
+    ///
+    /// This panics if no search has been started by [`Cache::search_start`].
+    #[inline]
+    pub fn search_update(&mut self, at: usize) {
+        let p =
+            self.progress.as_mut().expect("no in-progress search to update");
+        p.at = at;
+    }
+
+    /// Indicates that a search has finished at the given position.
+    ///
+    /// # Panics
+    ///
+    /// This panics if no search has been started by [`Cache::search_start`].
+    #[inline]
+    pub fn search_finish(&mut self, at: usize) {
+        let mut p =
+            self.progress.take().expect("no in-progress search to finish");
+        p.at = at;
+        self.bytes_searched += p.len();
+    }
+
+    /// Returns the total number of bytes that have been searched since this
+    /// cache was last cleared.
+    ///
+    /// This is useful for determining the efficiency of the cache. For
+    /// example, the lazy DFA uses this value in conjunction with the
+    /// [`Config::minimum_bytes_per_state`] knob to help determine whether it
+    /// should quit searching.
+    ///
+    /// This always returns `0` if search progress isn't being tracked. Note
+    /// that the lazy DFA search routines in this crate always track search
+    /// progress.
+    pub fn search_total_len(&self) -> usize {
+        self.bytes_searched + self.progress.as_ref().map_or(0, |p| p.len())
+    }
+
+    /// Returns the total number of times this cache has been cleared since it
+    /// was either created or last reset.
+    ///
+    /// This is useful for informational purposes or if you want to change
+    /// search strategies based on the number of times the cache has been
+    /// cleared.
+    pub fn clear_count(&self) -> usize {
+        self.clear_count
+    }
+
+    /// Returns the heap memory usage, in bytes, of this cache.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        const ID_SIZE: usize = size_of::<LazyStateID>();
+        const STATE_SIZE: usize = size_of::<State>();
+
+        // NOTE: If you make changes to the below, then
+        // 'minimum_cache_capacity' should be updated correspondingly.
+
+        self.trans.len() * ID_SIZE
+        + self.starts.len() * ID_SIZE
+        + self.states.len() * STATE_SIZE
+        // Maps likely use more memory than this, but it's probably close.
+        + self.states_to_id.len() * (STATE_SIZE + ID_SIZE)
+        + self.sparses.memory_usage()
+        + self.stack.capacity() * ID_SIZE
+        + self.scratch_state_builder.capacity()
+        // Heap memory used by 'State' in both 'states' and 'states_to_id'.
+        + self.memory_usage_state
+    }
+}
+
+/// Keeps track of the progress of the current search.
+///
+/// This is updated via the `Cache::search_{start,update,finish}` APIs to
+/// record how many bytes have been searched. This permits computing a
+/// heuristic that represents the efficiency of a cache, and thus helps inform
+/// whether the lazy DFA should give up or not.
+#[derive(Clone, Debug)]
+struct SearchProgress {
+    start: usize,
+    at: usize,
+}
+
+impl SearchProgress {
+    /// Returns the length, in bytes, of this search so far.
+    ///
+    /// This automatically handles the case of a reverse search, where `at`
+    /// is likely to be less than `start`.
+    fn len(&self) -> usize {
+        if self.start <= self.at {
+            self.at - self.start
+        } else {
+            self.start - self.at
+        }
+    }
+}
+
+/// A map from states to state identifiers. When using std, we use a standard
+/// hashmap, since it's a bit faster for this use case. (Other maps, like
+/// one's based on FNV, have not yet been benchmarked.)
+///
+/// The main purpose of this map is to reuse states where possible. This won't
+/// fully minimize the DFA, but it works well in a lot of cases.
+#[cfg(feature = "std")]
+type StateMap = std::collections::HashMap<State, LazyStateID>;
+#[cfg(not(feature = "std"))]
+type StateMap = alloc::collections::BTreeMap<State, LazyStateID>;
+
+/// A type that groups methods that require the base NFA/DFA and writable
+/// access to the cache.
+#[derive(Debug)]
+struct Lazy<'i, 'c> {
+    dfa: &'i DFA,
+    cache: &'c mut Cache,
+}
+
+impl<'i, 'c> Lazy<'i, 'c> {
+    /// Creates a new 'Lazy' wrapper for a DFA and its corresponding cache.
+    fn new(dfa: &'i DFA, cache: &'c mut Cache) -> Lazy<'i, 'c> {
+        Lazy { dfa, cache }
+    }
+
+    /// Return an immutable view by downgrading a writable cache to a read-only
+    /// cache.
+    fn as_ref<'a>(&'a self) -> LazyRef<'i, 'a> {
+        LazyRef::new(self.dfa, self.cache)
+    }
+
+    /// This is marked as 'inline(never)' to avoid bloating methods on 'DFA'
+    /// like 'next_state' and 'next_eoi_state' that are called in critical
+    /// areas. The idea is to let the optimizer focus on the other areas of
+    /// those methods as the hot path.
+    ///
+    /// Here's an example that justifies 'inline(never)'
+    ///
+    /// ```ignore
+    /// regex-cli find hybrid dfa \
+    ///   @all-codepoints-utf8-100x '\pL{100}' --cache-capacity 10000000
+    /// ```
+    ///
+    /// Where 'all-codepoints-utf8-100x' is the UTF-8 encoding of every
+    /// codepoint, in sequence, repeated 100 times.
+    ///
+    /// With 'inline(never)' hyperfine reports 1.1s per run. With
+    /// 'inline(always)', hyperfine reports 1.23s. So that's a 10% improvement.
+    #[cold]
+    #[inline(never)]
+    fn cache_next_state(
+        &mut self,
+        mut current: LazyStateID,
+        unit: alphabet::Unit,
+    ) -> Result<LazyStateID, CacheError> {
+        let stride2 = self.dfa.stride2();
+        let empty_builder = self.get_state_builder();
+        let builder = determinize::next(
+            self.dfa.get_nfa(),
+            self.dfa.get_config().get_match_kind(),
+            &mut self.cache.sparses,
+            &mut self.cache.stack,
+            &self.cache.states[current.as_usize_untagged() >> stride2],
+            unit,
+            empty_builder,
+        );
+        let save_state = !self.as_ref().state_builder_fits_in_cache(&builder);
+        if save_state {
+            self.save_state(current);
+        }
+        let next = self.add_builder_state(builder, |sid| sid)?;
+        if save_state {
+            current = self.saved_state_id();
+        }
+        // This is the payoff. The next time 'next_state' is called with this
+        // state and alphabet unit, it will find this transition and avoid
+        // having to re-determinize this transition.
+        self.set_transition(current, unit, next);
+        Ok(next)
+    }
+
+    /// Compute and cache the starting state for the given pattern ID (if
+    /// present) and the starting configuration.
+    ///
+    /// This panics if a pattern ID is given and the DFA isn't configured to
+    /// build anchored start states for each pattern.
+    ///
+    /// This will never return an unknown lazy state ID.
+    ///
+    /// If caching this state would otherwise result in a cache that has been
+    /// cleared too many times, then an error is returned.
+    #[cold]
+    #[inline(never)]
+    fn cache_start_group(
+        &mut self,
+        input: &Input<'_>,
+        start: Start,
+    ) -> Result<LazyStateID, MatchError> {
+        let mode = input.get_anchored();
+        let nfa_start_id = match mode {
+            Anchored::No => self.dfa.get_nfa().start_unanchored(),
+            Anchored::Yes => self.dfa.get_nfa().start_anchored(),
+            Anchored::Pattern(pid) => {
+                if !self.dfa.get_config().get_starts_for_each_pattern() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                match self.dfa.get_nfa().start_pattern(pid) {
+                    None => return Ok(self.as_ref().dead_id()),
+                    Some(sid) => sid,
+                }
+            }
+        };
+
+        let id = self
+            .cache_start_one(nfa_start_id, start)
+            .map_err(|_| MatchError::gave_up(input.start()))?;
+        self.set_start_state(input, start, id);
+        Ok(id)
+    }
+
+    /// Compute and cache the starting state for the given NFA state ID and the
+    /// starting configuration. The NFA state ID might be one of the following:
+    ///
+    /// 1) An unanchored start state to match any pattern.
+    /// 2) An anchored start state to match any pattern.
+    /// 3) An anchored start state for a particular pattern.
+    ///
+    /// This will never return an unknown lazy state ID.
+    ///
+    /// If caching this state would otherwise result in a cache that has been
+    /// cleared too many times, then an error is returned.
+    fn cache_start_one(
+        &mut self,
+        nfa_start_id: NFAStateID,
+        start: Start,
+    ) -> Result<LazyStateID, CacheError> {
+        let mut builder_matches = self.get_state_builder().into_matches();
+        determinize::set_lookbehind_from_start(
+            self.dfa.get_nfa(),
+            &start,
+            &mut builder_matches,
+        );
+        self.cache.sparses.set1.clear();
+        determinize::epsilon_closure(
+            self.dfa.get_nfa(),
+            nfa_start_id,
+            builder_matches.look_have(),
+            &mut self.cache.stack,
+            &mut self.cache.sparses.set1,
+        );
+        let mut builder = builder_matches.into_nfa();
+        determinize::add_nfa_states(
+            &self.dfa.get_nfa(),
+            &self.cache.sparses.set1,
+            &mut builder,
+        );
+        let tag_starts = self.dfa.get_config().get_specialize_start_states();
+        self.add_builder_state(builder, |id| {
+            if tag_starts {
+                id.to_start()
+            } else {
+                id
+            }
+        })
+    }
+
+    /// Either add the given builder state to this cache, or return an ID to an
+    /// equivalent state already in this cache.
+    ///
+    /// In the case where no equivalent state exists, the idmap function given
+    /// may be used to transform the identifier allocated. This is useful if
+    /// the caller needs to tag the ID with additional information.
+    ///
+    /// This will never return an unknown lazy state ID.
+    ///
+    /// If caching this state would otherwise result in a cache that has been
+    /// cleared too many times, then an error is returned.
+    fn add_builder_state(
+        &mut self,
+        builder: StateBuilderNFA,
+        idmap: impl Fn(LazyStateID) -> LazyStateID,
+    ) -> Result<LazyStateID, CacheError> {
+        if let Some(&cached_id) =
+            self.cache.states_to_id.get(builder.as_bytes())
+        {
+            // Since we have a cached state, put the constructed state's
+            // memory back into our scratch space, so that it can be reused.
+            self.put_state_builder(builder);
+            return Ok(cached_id);
+        }
+        let result = self.add_state(builder.to_state(), idmap);
+        self.put_state_builder(builder);
+        result
+    }
+
+    /// Allocate a new state ID and add the given state to this cache.
+    ///
+    /// The idmap function given may be used to transform the identifier
+    /// allocated. This is useful if the caller needs to tag the ID with
+    /// additional information.
+    ///
+    /// This will never return an unknown lazy state ID.
+    ///
+    /// If caching this state would otherwise result in a cache that has been
+    /// cleared too many times, then an error is returned.
+    fn add_state(
+        &mut self,
+        state: State,
+        idmap: impl Fn(LazyStateID) -> LazyStateID,
+    ) -> Result<LazyStateID, CacheError> {
+        if !self.as_ref().state_fits_in_cache(&state) {
+            self.try_clear_cache()?;
+        }
+        // It's important for this to come second, since the above may clear
+        // the cache. If we clear the cache after ID generation, then the ID
+        // is likely bunk since it would have been generated based on a larger
+        // transition table.
+        let mut id = idmap(self.next_state_id()?);
+        if state.is_match() {
+            id = id.to_match();
+        }
+        // Add room in the transition table. Since this is a fresh state, all
+        // of its transitions are unknown.
+        self.cache.trans.extend(
+            iter::repeat(self.as_ref().unknown_id()).take(self.dfa.stride()),
+        );
+        // When we add a sentinel state, we never want to set any quit
+        // transitions. Technically, this is harmless, since sentinel states
+        // have all of their transitions set to loop back to themselves. But
+        // when creating sentinel states before the quit sentinel state,
+        // this will try to call 'set_transition' on a state ID that doesn't
+        // actually exist yet, which isn't allowed. So we just skip doing so
+        // entirely.
+        if !self.dfa.quitset.is_empty() && !self.as_ref().is_sentinel(id) {
+            let quit_id = self.as_ref().quit_id();
+            for b in self.dfa.quitset.iter() {
+                self.set_transition(id, alphabet::Unit::u8(b), quit_id);
+            }
+        }
+        self.cache.memory_usage_state += state.memory_usage();
+        self.cache.states.push(state.clone());
+        self.cache.states_to_id.insert(state, id);
+        Ok(id)
+    }
+
+    /// Allocate a new state ID.
+    ///
+    /// This will never return an unknown lazy state ID.
+    ///
+    /// If caching this state would otherwise result in a cache that has been
+    /// cleared too many times, then an error is returned.
+    fn next_state_id(&mut self) -> Result<LazyStateID, CacheError> {
+        let sid = match LazyStateID::new(self.cache.trans.len()) {
+            Ok(sid) => sid,
+            Err(_) => {
+                self.try_clear_cache()?;
+                // This has to pass since we check that ID capacity at
+                // construction time can fit at least MIN_STATES states.
+                LazyStateID::new(self.cache.trans.len()).unwrap()
+            }
+        };
+        Ok(sid)
+    }
+
+    /// Attempt to clear the cache used by this lazy DFA.
+    ///
+    /// If clearing the cache exceeds the minimum number of required cache
+    /// clearings, then this will return a cache error. In this case,
+    /// callers should bubble this up as the cache can't be used until it is
+    /// reset. Implementations of search should convert this error into a
+    /// [`MatchError::gave_up`].
+    ///
+    /// If 'self.state_saver' is set to save a state, then this state is
+    /// persisted through cache clearing. Otherwise, the cache is returned to
+    /// its state after initialization with two exceptions: its clear count
+    /// is incremented and some of its memory likely has additional capacity.
+    /// That is, clearing a cache does _not_ release memory.
+    ///
+    /// Otherwise, any lazy state ID generated by the cache prior to resetting
+    /// it is invalid after the reset.
+    fn try_clear_cache(&mut self) -> Result<(), CacheError> {
+        let c = self.dfa.get_config();
+        if let Some(min_count) = c.get_minimum_cache_clear_count() {
+            if self.cache.clear_count >= min_count {
+                if let Some(min_bytes_per) = c.get_minimum_bytes_per_state() {
+                    let len = self.cache.search_total_len();
+                    let min_bytes =
+                        min_bytes_per.saturating_mul(self.cache.states.len());
+                    // If we've searched 0 bytes then probably something has
+                    // gone wrong and the lazy DFA search implementation isn't
+                    // correctly updating the search progress state.
+                    if len == 0 {
+                        trace!(
+                            "number of bytes searched is 0, but \
+                             a minimum bytes per state searched ({}) is \
+                             enabled, maybe Cache::search_update \
+                             is not being used?",
+                            min_bytes_per,
+                        );
+                    }
+                    if len < min_bytes {
+                        trace!(
+                            "lazy DFA cache has been cleared {} times, \
+                             which exceeds the limit of {}, \
+                             AND its bytes searched per state is less \
+                             than the configured mininum of {}, \
+                             therefore lazy DFA is giving up \
+                             (bytes searched since cache clear = {}, \
+                              number of states = {})",
+                            self.cache.clear_count,
+                            min_count,
+                            min_bytes_per,
+                            len,
+                            self.cache.states.len(),
+                        );
+                        return Err(CacheError::bad_efficiency());
+                    } else {
+                        trace!(
+                            "lazy DFA cache has been cleared {} times, \
+                             which exceeds the limit of {}, \
+                             AND its bytes searched per state is greater \
+                             than the configured mininum of {}, \
+                             therefore lazy DFA is continuing! \
+                             (bytes searched since cache clear = {}, \
+                              number of states = {})",
+                            self.cache.clear_count,
+                            min_count,
+                            min_bytes_per,
+                            len,
+                            self.cache.states.len(),
+                        );
+                    }
+                } else {
+                    trace!(
+                        "lazy DFA cache has been cleared {} times, \
+                         which exceeds the limit of {}, \
+                         since there is no configured bytes per state \
+                         minimum, lazy DFA is giving up",
+                        self.cache.clear_count,
+                        min_count,
+                    );
+                    return Err(CacheError::too_many_cache_clears());
+                }
+            }
+        }
+        self.clear_cache();
+        Ok(())
+    }
+
+    /// Clears _and_ resets the cache. Resetting the cache means that no
+    /// states are persisted and the clear count is reset to 0. No heap memory
+    /// is released.
+    ///
+    /// Note that the caller may reset a cache with a different DFA than what
+    /// it was created from. In which case, the cache can now be used with the
+    /// new DFA (and not the old DFA).
+    fn reset_cache(&mut self) {
+        self.cache.state_saver = StateSaver::none();
+        self.clear_cache();
+        // If a new DFA is used, it might have a different number of NFA
+        // states, so we need to make sure our sparse sets have the appropriate
+        // size.
+        self.cache.sparses.resize(self.dfa.get_nfa().states().len());
+        self.cache.clear_count = 0;
+        self.cache.progress = None;
+    }
+
+    /// Clear the cache used by this lazy DFA.
+    ///
+    /// If 'self.state_saver' is set to save a state, then this state is
+    /// persisted through cache clearing. Otherwise, the cache is returned to
+    /// its state after initialization with two exceptions: its clear count
+    /// is incremented and some of its memory likely has additional capacity.
+    /// That is, clearing a cache does _not_ release memory.
+    ///
+    /// Otherwise, any lazy state ID generated by the cache prior to resetting
+    /// it is invalid after the reset.
+    fn clear_cache(&mut self) {
+        self.cache.trans.clear();
+        self.cache.starts.clear();
+        self.cache.states.clear();
+        self.cache.states_to_id.clear();
+        self.cache.memory_usage_state = 0;
+        self.cache.clear_count += 1;
+        self.cache.bytes_searched = 0;
+        if let Some(ref mut progress) = self.cache.progress {
+            progress.start = progress.at;
+        }
+        trace!(
+            "lazy DFA cache has been cleared (count: {})",
+            self.cache.clear_count
+        );
+        self.init_cache();
+        // If the state we want to save is one of the sentinel
+        // (unknown/dead/quit) states, then 'init_cache' adds those back, and
+        // their identifier values remains invariant. So there's no need to add
+        // it again. (And indeed, doing so would be incorrect!)
+        if let Some((old_id, state)) = self.cache.state_saver.take_to_save() {
+            // If the state is one of the special sentinel states, then it is
+            // automatically added by cache initialization and its ID always
+            // remains the same. With that said, this should never occur since
+            // the sentinel states are all loop states back to themselves. So
+            // we should never be in a position where we're attempting to save
+            // a sentinel state since we never compute transitions out of a
+            // sentinel state.
+            assert!(
+                !self.as_ref().is_sentinel(old_id),
+                "cannot save sentinel state"
+            );
+            let new_id = self
+                .add_state(state, |id| {
+                    if old_id.is_start() {
+                        // We don't need to consult the
+                        // 'specialize_start_states' config knob here, because
+                        // if it's disabled, old_id.is_start() will never
+                        // return true.
+                        id.to_start()
+                    } else {
+                        id
+                    }
+                })
+                // The unwrap here is OK because lazy DFA creation ensures that
+                // we have room in the cache to add MIN_STATES states. Since
+                // 'init_cache' above adds 3, this adds a 4th.
+                .expect("adding one state after cache clear must work");
+            self.cache.state_saver = StateSaver::Saved(new_id);
+        }
+    }
+
+    /// Initialize this cache from emptiness to a place where it can be used
+    /// for search.
+    ///
+    /// This is called both at cache creation time and after the cache has been
+    /// cleared.
+    ///
+    /// Primarily, this adds the three sentinel states and allocates some
+    /// initial memory.
+    fn init_cache(&mut self) {
+        // Why multiply by 2 here? Because we make room for both the unanchored
+        // and anchored start states. Unanchored is first and then anchored.
+        let mut starts_len = Start::len().checked_mul(2).unwrap();
+        // ... but if we also want start states for every pattern, we make room
+        // for that too.
+        if self.dfa.get_config().get_starts_for_each_pattern() {
+            starts_len += Start::len() * self.dfa.pattern_len();
+        }
+        self.cache
+            .starts
+            .extend(iter::repeat(self.as_ref().unknown_id()).take(starts_len));
+        // This is the set of NFA states that corresponds to each of our three
+        // sentinel states: the empty set.
+        let dead = State::dead();
+        // This sets up some states that we use as sentinels that are present
+        // in every DFA. While it would be technically possible to implement
+        // this DFA without explicitly putting these states in the transition
+        // table, this is convenient to do to make `next_state` correct for all
+        // valid state IDs without needing explicit conditionals to special
+        // case these sentinel states.
+        //
+        // All three of these states are "dead" states. That is, all of
+        // them transition only to themselves. So once you enter one of
+        // these states, it's impossible to leave them. Thus, any correct
+        // search routine must explicitly check for these state types. (Sans
+        // `unknown`, since that is only used internally to represent missing
+        // states.)
+        let unk_id =
+            self.add_state(dead.clone(), |id| id.to_unknown()).unwrap();
+        let dead_id = self.add_state(dead.clone(), |id| id.to_dead()).unwrap();
+        let quit_id = self.add_state(dead.clone(), |id| id.to_quit()).unwrap();
+        assert_eq!(unk_id, self.as_ref().unknown_id());
+        assert_eq!(dead_id, self.as_ref().dead_id());
+        assert_eq!(quit_id, self.as_ref().quit_id());
+        // The idea here is that if you start in an unknown/dead/quit state and
+        // try to transition on them, then you should end up where you started.
+        self.set_all_transitions(unk_id, unk_id);
+        self.set_all_transitions(dead_id, dead_id);
+        self.set_all_transitions(quit_id, quit_id);
+        // All of these states are technically equivalent from the FSM
+        // perspective, so putting all three of them in the cache isn't
+        // possible. (They are distinct merely because we use their
+        // identifiers as sentinels to mean something, as indicated by the
+        // names.) Moreover, we wouldn't want to do that. Unknown and quit
+        // states are special in that they are artificial constructions
+        // this implementation. But dead states are a natural part of
+        // determinization. When you reach a point in the NFA where you cannot
+        // go anywhere else, a dead state will naturally arise and we MUST
+        // reuse the canonical dead state that we've created here. Why? Because
+        // it is the state ID that tells the search routine whether a state is
+        // dead or not, and thus, whether to stop the search. Having a bunch of
+        // distinct dead states would be quite wasteful!
+        self.cache.states_to_id.insert(dead, dead_id);
+    }
+
+    /// Save the state corresponding to the ID given such that the state
+    /// persists through a cache clearing.
+    ///
+    /// While the state may persist, the ID may not. In order to discover the
+    /// new state ID, one must call 'saved_state_id' after a cache clearing.
+    fn save_state(&mut self, id: LazyStateID) {
+        let state = self.as_ref().get_cached_state(id).clone();
+        self.cache.state_saver = StateSaver::ToSave { id, state };
+    }
+
+    /// Returns the updated lazy state ID for a state that was persisted
+    /// through a cache clearing.
+    ///
+    /// It is only correct to call this routine when both a state has been
+    /// saved and the cache has just been cleared. Otherwise, this panics.
+    fn saved_state_id(&mut self) -> LazyStateID {
+        self.cache
+            .state_saver
+            .take_saved()
+            .expect("state saver does not have saved state ID")
+    }
+
+    /// Set all transitions on the state 'from' to 'to'.
+    fn set_all_transitions(&mut self, from: LazyStateID, to: LazyStateID) {
+        for unit in self.dfa.classes.representatives(..) {
+            self.set_transition(from, unit, to);
+        }
+    }
+
+    /// Set the transition on 'from' for 'unit' to 'to'.
+    ///
+    /// This panics if either 'from' or 'to' is invalid.
+    ///
+    /// All unit values are OK.
+    fn set_transition(
+        &mut self,
+        from: LazyStateID,
+        unit: alphabet::Unit,
+        to: LazyStateID,
+    ) {
+        assert!(self.as_ref().is_valid(from), "invalid 'from' id: {:?}", from);
+        assert!(self.as_ref().is_valid(to), "invalid 'to' id: {:?}", to);
+        let offset =
+            from.as_usize_untagged() + self.dfa.classes.get_by_unit(unit);
+        self.cache.trans[offset] = to;
+    }
+
+    /// Set the start ID for the given pattern ID (if given) and starting
+    /// configuration to the ID given.
+    ///
+    /// This panics if 'id' is not valid or if a pattern ID is given and
+    /// 'starts_for_each_pattern' is not enabled.
+    fn set_start_state(
+        &mut self,
+        input: &Input<'_>,
+        start: Start,
+        id: LazyStateID,
+    ) {
+        assert!(self.as_ref().is_valid(id));
+        let start_index = start.as_usize();
+        let index = match input.get_anchored() {
+            Anchored::No => start_index,
+            Anchored::Yes => Start::len() + start_index,
+            Anchored::Pattern(pid) => {
+                assert!(
+                    self.dfa.get_config().get_starts_for_each_pattern(),
+                    "attempted to search for a specific pattern \
+                     without enabling starts_for_each_pattern",
+                );
+                let pid = pid.as_usize();
+                (2 * Start::len()) + (Start::len() * pid) + start_index
+            }
+        };
+        self.cache.starts[index] = id;
+    }
+
+    /// Returns a state builder from this DFA that might have existing
+    /// capacity. This helps avoid allocs in cases where a state is built that
+    /// turns out to already be cached.
+    ///
+    /// Callers must put the state builder back with 'put_state_builder',
+    /// otherwise the allocation reuse won't work.
+    fn get_state_builder(&mut self) -> StateBuilderEmpty {
+        core::mem::replace(
+            &mut self.cache.scratch_state_builder,
+            StateBuilderEmpty::new(),
+        )
+    }
+
+    /// Puts the given state builder back into this DFA for reuse.
+    ///
+    /// Note that building a 'State' from a builder always creates a new alloc,
+    /// so callers should always put the builder back.
+    fn put_state_builder(&mut self, builder: StateBuilderNFA) {
+        let _ = core::mem::replace(
+            &mut self.cache.scratch_state_builder,
+            builder.clear(),
+        );
+    }
+}
+
+/// A type that groups methods that require the base NFA/DFA and read-only
+/// access to the cache.
+#[derive(Debug)]
+struct LazyRef<'i, 'c> {
+    dfa: &'i DFA,
+    cache: &'c Cache,
+}
+
+impl<'i, 'c> LazyRef<'i, 'c> {
+    /// Creates a new 'Lazy' wrapper for a DFA and its corresponding cache.
+    fn new(dfa: &'i DFA, cache: &'c Cache) -> LazyRef<'i, 'c> {
+        LazyRef { dfa, cache }
+    }
+
+    /// Return the ID of the start state for the given configuration.
+    ///
+    /// If the start state has not yet been computed, then this returns an
+    /// unknown lazy state ID.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn get_cached_start_id(
+        &self,
+        input: &Input<'_>,
+        start: Start,
+    ) -> Result<LazyStateID, MatchError> {
+        let start_index = start.as_usize();
+        let mode = input.get_anchored();
+        let index = match mode {
+            Anchored::No => start_index,
+            Anchored::Yes => Start::len() + start_index,
+            Anchored::Pattern(pid) => {
+                if !self.dfa.get_config().get_starts_for_each_pattern() {
+                    return Err(MatchError::unsupported_anchored(mode));
+                }
+                if pid.as_usize() >= self.dfa.pattern_len() {
+                    return Ok(self.dead_id());
+                }
+                (2 * Start::len())
+                    + (Start::len() * pid.as_usize())
+                    + start_index
+            }
+        };
+        Ok(self.cache.starts[index])
+    }
+
+    /// Return the cached NFA/DFA powerset state for the given ID.
+    ///
+    /// This panics if the given ID does not address a valid state.
+    fn get_cached_state(&self, sid: LazyStateID) -> &State {
+        let index = sid.as_usize_untagged() >> self.dfa.stride2();
+        &self.cache.states[index]
+    }
+
+    /// Returns true if and only if the given ID corresponds to a "sentinel"
+    /// state.
+    ///
+    /// A sentinel state is a state that signifies a special condition of
+    /// search, and where every transition maps back to itself. See LazyStateID
+    /// for more details. Note that start and match states are _not_ sentinels
+    /// since they may otherwise be real states with non-trivial transitions.
+    /// The purposes of sentinel states is purely to indicate something. Their
+    /// transitions are not meant to be followed.
+    fn is_sentinel(&self, id: LazyStateID) -> bool {
+        id == self.unknown_id() || id == self.dead_id() || id == self.quit_id()
+    }
+
+    /// Returns the ID of the unknown state for this lazy DFA.
+    fn unknown_id(&self) -> LazyStateID {
+        // This unwrap is OK since 0 is always a valid state ID.
+        LazyStateID::new(0).unwrap().to_unknown()
+    }
+
+    /// Returns the ID of the dead state for this lazy DFA.
+    fn dead_id(&self) -> LazyStateID {
+        // This unwrap is OK since the maximum value here is 1 * 512 = 512,
+        // which is <= 2047 (the maximum state ID on 16-bit systems). Where
+        // 512 is the worst case for our equivalence classes (every byte is a
+        // distinct class).
+        LazyStateID::new(1 << self.dfa.stride2()).unwrap().to_dead()
+    }
+
+    /// Returns the ID of the quit state for this lazy DFA.
+    fn quit_id(&self) -> LazyStateID {
+        // This unwrap is OK since the maximum value here is 2 * 512 = 1024,
+        // which is <= 2047 (the maximum state ID on 16-bit systems). Where
+        // 512 is the worst case for our equivalence classes (every byte is a
+        // distinct class).
+        LazyStateID::new(2 << self.dfa.stride2()).unwrap().to_quit()
+    }
+
+    /// Returns true if and only if the given ID is valid.
+    ///
+    /// An ID is valid if it is both a valid index into the transition table
+    /// and is a multiple of the DFA's stride.
+    fn is_valid(&self, id: LazyStateID) -> bool {
+        let id = id.as_usize_untagged();
+        id < self.cache.trans.len() && id % self.dfa.stride() == 0
+    }
+
+    /// Returns true if adding the state given would fit in this cache.
+    fn state_fits_in_cache(&self, state: &State) -> bool {
+        let needed = self.cache.memory_usage()
+            + self.memory_usage_for_one_more_state(state.memory_usage());
+        trace!(
+            "lazy DFA cache capacity check: {:?} ?<=? {:?}",
+            needed,
+            self.dfa.cache_capacity
+        );
+        needed <= self.dfa.cache_capacity
+    }
+
+    /// Returns true if adding the state to be built by the given builder would
+    /// fit in this cache.
+    fn state_builder_fits_in_cache(&self, state: &StateBuilderNFA) -> bool {
+        let needed = self.cache.memory_usage()
+            + self.memory_usage_for_one_more_state(state.as_bytes().len());
+        needed <= self.dfa.cache_capacity
+    }
+
+    /// Returns the additional memory usage, in bytes, required to add one more
+    /// state to this cache. The given size should be the heap size, in bytes,
+    /// that would be used by the new state being added.
+    fn memory_usage_for_one_more_state(
+        &self,
+        state_heap_size: usize,
+    ) -> usize {
+        const ID_SIZE: usize = size_of::<LazyStateID>();
+        const STATE_SIZE: usize = size_of::<State>();
+
+        self.dfa.stride() * ID_SIZE // additional space needed in trans table
+        + STATE_SIZE // space in cache.states
+        + (STATE_SIZE + ID_SIZE) // space in cache.states_to_id
+        + state_heap_size // heap memory used by state itself
+    }
+}
+
+/// A simple type that encapsulates the saving of a state ID through a cache
+/// clearing.
+///
+/// A state ID can be marked for saving with ToSave, while a state ID can be
+/// saved itself with Saved.
+#[derive(Clone, Debug)]
+enum StateSaver {
+    /// An empty state saver. In this case, no states (other than the special
+    /// sentinel states) are preserved after clearing the cache.
+    None,
+    /// An ID of a state (and the state itself) that should be preserved after
+    /// the lazy DFA's cache has been cleared. After clearing, the updated ID
+    /// is stored in 'Saved' since it may have changed.
+    ToSave { id: LazyStateID, state: State },
+    /// An ID that of a state that has been persisted through a lazy DFA
+    /// cache clearing. The ID recorded here corresonds to an ID that was
+    /// once marked as ToSave. The IDs are likely not equivalent even though
+    /// the states they point to are.
+    Saved(LazyStateID),
+}
+
+impl StateSaver {
+    /// Create an empty state saver.
+    fn none() -> StateSaver {
+        StateSaver::None
+    }
+
+    /// Replace this state saver with an empty saver, and if this saver is a
+    /// request to save a state, return that request.
+    fn take_to_save(&mut self) -> Option<(LazyStateID, State)> {
+        match core::mem::replace(self, StateSaver::None) {
+            StateSaver::None | StateSaver::Saved(_) => None,
+            StateSaver::ToSave { id, state } => Some((id, state)),
+        }
+    }
+
+    /// Replace this state saver with an empty saver, and if this saver is a
+    /// saved state (or a request to save a state), return that state's ID.
+    ///
+    /// The idea here is that a request to save a state isn't necessarily
+    /// honored because it might not be needed. e.g., Some higher level code
+    /// might request a state to be saved on the off chance that the cache gets
+    /// cleared when a new state is added at a lower level. But if that new
+    /// state is never added, then the cache is never cleared and the state and
+    /// its ID remain unchanged.
+    fn take_saved(&mut self) -> Option<LazyStateID> {
+        match core::mem::replace(self, StateSaver::None) {
+            StateSaver::None => None,
+            StateSaver::Saved(id) | StateSaver::ToSave { id, .. } => Some(id),
+        }
+    }
+}
+
+/// The configuration used for building a lazy DFA.
+///
+/// As a convenience, [`DFA::config`] is an alias for [`Config::new`]. The
+/// advantage of the former is that it often lets you avoid importing the
+/// `Config` type directly.
+///
+/// A lazy DFA configuration is a simple data object that is typically used
+/// with [`Builder::configure`].
+///
+/// The default configuration guarantees that a search will never return a
+/// "gave up" or "quit" error, although it is possible for a search to fail
+/// if [`Config::starts_for_each_pattern`] wasn't enabled (which it is not by
+/// default) and an [`Anchored::Pattern`] mode is requested via [`Input`].
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    // As with other configuration types in this crate, we put all our knobs
+    // in options so that we can distinguish between "default" and "not set."
+    // This makes it possible to easily combine multiple configurations
+    // without default values overwriting explicitly specified values. See the
+    // 'overwrite' method.
+    //
+    // For docs on the fields below, see the corresponding method setters.
+    match_kind: Option<MatchKind>,
+    pre: Option<Option<Prefilter>>,
+    starts_for_each_pattern: Option<bool>,
+    byte_classes: Option<bool>,
+    unicode_word_boundary: Option<bool>,
+    quitset: Option<ByteSet>,
+    specialize_start_states: Option<bool>,
+    cache_capacity: Option<usize>,
+    skip_cache_capacity_check: Option<bool>,
+    minimum_cache_clear_count: Option<Option<usize>>,
+    minimum_bytes_per_state: Option<Option<usize>>,
+}
+
+impl Config {
+    /// Return a new default lazy DFA builder configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Set the desired match semantics.
+    ///
+    /// The default is [`MatchKind::LeftmostFirst`], which corresponds to the
+    /// match semantics of Perl-like regex engines. That is, when multiple
+    /// patterns would match at the same leftmost position, the pattern that
+    /// appears first in the concrete syntax is chosen.
+    ///
+    /// Currently, the only other kind of match semantics supported is
+    /// [`MatchKind::All`]. This corresponds to classical DFA construction
+    /// where all possible matches are added to the lazy DFA.
+    ///
+    /// Typically, `All` is used when one wants to execute an overlapping
+    /// search and `LeftmostFirst` otherwise. In particular, it rarely makes
+    /// sense to use `All` with the various "leftmost" find routines, since the
+    /// leftmost routines depend on the `LeftmostFirst` automata construction
+    /// strategy. Specifically, `LeftmostFirst` adds dead states to the
+    /// lazy DFA as a way to terminate the search and report a match.
+    /// `LeftmostFirst` also supports non-greedy matches using this strategy
+    /// where as `All` does not.
+    ///
+    /// # Example: overlapping search
+    ///
+    /// This example shows the typical use of `MatchKind::All`, which is to
+    /// report overlapping matches.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     hybrid::dfa::{DFA, OverlappingState},
+    ///     HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build_many(&[r"\w+$", r"\S+$"])?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "@foo";
+    /// let mut state = OverlappingState::start();
+    ///
+    /// let expected = Some(HalfMatch::must(1, 4));
+    /// dfa.try_search_overlapping_fwd(
+    ///     &mut cache, &Input::new(haystack), &mut state,
+    /// )?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// // The first pattern also matches at the same position, so re-running
+    /// // the search will yield another match. Notice also that the first
+    /// // pattern is returned after the second. This is because the second
+    /// // pattern begins its match before the first, is therefore an earlier
+    /// // match and is thus reported first.
+    /// let expected = Some(HalfMatch::must(0, 4));
+    /// dfa.try_search_overlapping_fwd(
+    ///     &mut cache, &Input::new(haystack), &mut state,
+    /// )?;
+    /// assert_eq!(expected, state.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: reverse automaton to find start of match
+    ///
+    /// Another example for using `MatchKind::All` is for constructing a
+    /// reverse automaton to find the start of a match. `All` semantics are
+    /// used for this in order to find the longest possible match, which
+    /// corresponds to the leftmost starting position.
+    ///
+    /// Note that if you need the starting position then
+    /// [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) will handle this
+    /// for you, so it's usually not necessary to do this yourself.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     nfa::thompson::NFA,
+    ///     Anchored, HalfMatch, Input, MatchKind,
+    /// };
+    ///
+    /// let input = Input::new("123foobar456");
+    /// let pattern = r"[a-z]+r";
+    ///
+    /// let dfa_fwd = DFA::new(pattern)?;
+    /// let dfa_rev = DFA::builder()
+    ///     .thompson(NFA::config().reverse(true))
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .build(pattern)?;
+    /// let mut cache_fwd = dfa_fwd.create_cache();
+    /// let mut cache_rev = dfa_rev.create_cache();
+    ///
+    /// let expected_fwd = HalfMatch::must(0, 9);
+    /// let expected_rev = HalfMatch::must(0, 3);
+    /// let got_fwd = dfa_fwd.try_search_fwd(&mut cache_fwd, &input)?.unwrap();
+    /// // Here we don't specify the pattern to search for since there's only
+    /// // one pattern and we're doing a leftmost search. But if this were an
+    /// // overlapping search, you'd need to specify the pattern that matched
+    /// // in the forward direction. (Otherwise, you might wind up finding the
+    /// // starting position of a match of some other pattern.) That in turn
+    /// // requires building the reverse automaton with starts_for_each_pattern
+    /// // enabled.
+    /// let input = input
+    ///     .clone()
+    ///     .range(..got_fwd.offset())
+    ///     .anchored(Anchored::Yes);
+    /// let got_rev = dfa_rev.try_search_rev(&mut cache_rev, &input)?.unwrap();
+    /// assert_eq!(expected_fwd, got_fwd);
+    /// assert_eq!(expected_rev, got_rev);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn match_kind(mut self, kind: MatchKind) -> Config {
+        self.match_kind = Some(kind);
+        self
+    }
+
+    /// Set a prefilter to be used whenever a start state is entered.
+    ///
+    /// A [`Prefilter`] in this context is meant to accelerate searches by
+    /// looking for literal prefixes that every match for the corresponding
+    /// pattern (or patterns) must start with. Once a prefilter produces a
+    /// match, the underlying search routine continues on to try and confirm
+    /// the match.
+    ///
+    /// Be warned that setting a prefilter does not guarantee that the search
+    /// will be faster. While it's usually a good bet, if the prefilter
+    /// produces a lot of false positive candidates (i.e., positions matched
+    /// by the prefilter but not by the regex), then the overall result can
+    /// be slower than if you had just executed the regex engine without any
+    /// prefilters.
+    ///
+    /// Note that unless [`Config::specialize_start_states`] has been
+    /// explicitly set, then setting this will also enable (when `pre` is
+    /// `Some`) or disable (when `pre` is `None`) start state specialization.
+    /// This occurs because without start state specialization, a prefilter
+    /// is likely to be less effective. And without a prefilter, start state
+    /// specialization is usually pointless.
+    ///
+    /// By default no prefilter is set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "bar"]);
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 11)),
+    ///     re.try_search_fwd(&mut cache, &input)?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Be warned though that an incorrect prefilter can lead to incorrect
+    /// results!
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "car"]);
+    /// let re = DFA::builder()
+    ///     .configure(DFA::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(
+    ///     // No match reported even though there clearly is one!
+    ///     None,
+    ///     re.try_search_fwd(&mut cache, &input)?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn prefilter(mut self, pre: Option<Prefilter>) -> Config {
+        self.pre = Some(pre);
+        if self.specialize_start_states.is_none() {
+            self.specialize_start_states =
+                Some(self.get_prefilter().is_some());
+        }
+        self
+    }
+
+    /// Whether to compile a separate start state for each pattern in the
+    /// lazy DFA.
+    ///
+    /// When enabled, a separate **anchored** start state is added for each
+    /// pattern in the lazy DFA. When this start state is used, then the DFA
+    /// will only search for matches for the pattern specified, even if there
+    /// are other patterns in the DFA.
+    ///
+    /// The main downside of this option is that it can potentially increase
+    /// the size of the DFA and/or increase the time it takes to build the
+    /// DFA at search time. However, since this is configuration for a lazy
+    /// DFA, these states aren't actually built unless they're used. Enabling
+    /// this isn't necessarily free, however, as it may result in higher cache
+    /// usage.
+    ///
+    /// There are a few reasons one might want to enable this (it's disabled
+    /// by default):
+    ///
+    /// 1. When looking for the start of an overlapping match (using a reverse
+    /// DFA), doing it correctly requires starting the reverse search using the
+    /// starting state of the pattern that matched in the forward direction.
+    /// Indeed, when building a [`Regex`](crate::hybrid::regex::Regex), it
+    /// will automatically enable this option when building the reverse DFA
+    /// internally.
+    /// 2. When you want to use a DFA with multiple patterns to both search
+    /// for matches of any pattern or to search for anchored matches of one
+    /// particular pattern while using the same DFA. (Otherwise, you would need
+    /// to compile a new DFA for each pattern.)
+    ///
+    /// By default this is disabled.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use this option to permit the same lazy DFA
+    /// to run both general searches for any pattern and anchored searches for
+    /// a specific pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     Anchored, HalfMatch, Input, PatternID,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().starts_for_each_pattern(true))
+    ///     .build_many(&[r"[a-z0-9]{6}", r"[a-z][a-z0-9]{5}"])?;
+    /// let mut cache = dfa.create_cache();
+    /// let haystack = "bar foo123";
+    ///
+    /// // Here's a normal unanchored search that looks for any pattern.
+    /// let expected = HalfMatch::must(0, 10);
+    /// let input = Input::new(haystack);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&mut cache, &input)?);
+    /// // We can also do a normal anchored search for any pattern. Since it's
+    /// // an anchored search, we position the start of the search where we
+    /// // know the match will begin.
+    /// let expected = HalfMatch::must(0, 10);
+    /// let input = Input::new(haystack).range(4..);
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&mut cache, &input)?);
+    /// // Since we compiled anchored start states for each pattern, we can
+    /// // also look for matches of other patterns explicitly, even if a
+    /// // different pattern would have normally matched.
+    /// let expected = HalfMatch::must(1, 10);
+    /// let input = Input::new(haystack)
+    ///     .range(4..)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// assert_eq!(Some(expected), dfa.try_search_fwd(&mut cache, &input)?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn starts_for_each_pattern(mut self, yes: bool) -> Config {
+        self.starts_for_each_pattern = Some(yes);
+        self
+    }
+
+    /// Whether to attempt to shrink the size of the lazy DFA's alphabet or
+    /// not.
+    ///
+    /// This option is enabled by default and should never be disabled unless
+    /// one is debugging the lazy DFA.
+    ///
+    /// When enabled, the lazy DFA will use a map from all possible bytes
+    /// to their corresponding equivalence class. Each equivalence class
+    /// represents a set of bytes that does not discriminate between a match
+    /// and a non-match in the DFA. For example, the pattern `[ab]+` has at
+    /// least two equivalence classes: a set containing `a` and `b` and a set
+    /// containing every byte except for `a` and `b`. `a` and `b` are in the
+    /// same equivalence classes because they never discriminate between a
+    /// match and a non-match.
+    ///
+    /// The advantage of this map is that the size of the transition table
+    /// can be reduced drastically from `#states * 256 * sizeof(LazyStateID)`
+    /// to `#states * k * sizeof(LazyStateID)` where `k` is the number of
+    /// equivalence classes (rounded up to the nearest power of 2). As a
+    /// result, total space usage can decrease substantially. Moreover, since a
+    /// smaller alphabet is used, DFA compilation during search becomes faster
+    /// as well since it will potentially be able to reuse a single transition
+    /// for multiple bytes.
+    ///
+    /// **WARNING:** This is only useful for debugging lazy DFAs. Disabling
+    /// this does not yield any speed advantages. Namely, even when this is
+    /// disabled, a byte class map is still used while searching. The only
+    /// difference is that every byte will be forced into its own distinct
+    /// equivalence class. This is useful for debugging the actual generated
+    /// transitions because it lets one see the transitions defined on actual
+    /// bytes instead of the equivalence classes.
+    pub fn byte_classes(mut self, yes: bool) -> Config {
+        self.byte_classes = Some(yes);
+        self
+    }
+
+    /// Heuristically enable Unicode word boundaries.
+    ///
+    /// When set, this will attempt to implement Unicode word boundaries as if
+    /// they were ASCII word boundaries. This only works when the search input
+    /// is ASCII only. If a non-ASCII byte is observed while searching, then a
+    /// [`MatchError::quit`] error is returned.
+    ///
+    /// A possible alternative to enabling this option is to simply use an
+    /// ASCII word boundary, e.g., via `(?-u:\b)`. The main reason to use this
+    /// option is if you absolutely need Unicode support. This option lets one
+    /// use a fast search implementation (a DFA) for some potentially very
+    /// common cases, while providing the option to fall back to some other
+    /// regex engine to handle the general case when an error is returned.
+    ///
+    /// If the pattern provided has no Unicode word boundary in it, then this
+    /// option has no effect. (That is, quitting on a non-ASCII byte only
+    /// occurs when this option is enabled _and_ a Unicode word boundary is
+    /// present in the pattern.)
+    ///
+    /// This is almost equivalent to setting all non-ASCII bytes to be quit
+    /// bytes. The only difference is that this will cause non-ASCII bytes to
+    /// be quit bytes _only_ when a Unicode word boundary is present in the
+    /// pattern.
+    ///
+    /// When enabling this option, callers _must_ be prepared to handle
+    /// a [`MatchError`](crate::MatchError) error during search.
+    /// When using a [`Regex`](crate::hybrid::regex::Regex), this
+    /// corresponds to using the `try_` suite of methods. Alternatively,
+    /// if callers can guarantee that their input is ASCII only, then a
+    /// [`MatchError::quit`] error will never be returned while searching.
+    ///
+    /// This is disabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to heuristically enable Unicode word boundaries
+    /// in a pattern. It also shows what happens when a search comes across a
+    /// non-ASCII byte.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     HalfMatch, Input, MatchError,
+    /// };
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().unicode_word_boundary(true))
+    ///     .build(r"\b[0-9]+\b")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // The match occurs before the search ever observes the snowman
+    /// // character, so no error occurs.
+    /// let haystack = "foo 123  ☃";
+    /// let expected = Some(HalfMatch::must(0, 7));
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// // Notice that this search fails, even though the snowman character
+    /// // occurs after the ending match offset. This is because search
+    /// // routines read one byte past the end of the search to account for
+    /// // look-around, and indeed, this is required here to determine whether
+    /// // the trailing \b matches.
+    /// let haystack = "foo 123 ☃";
+    /// let expected = MatchError::quit(0xE2, 8);
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack));
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// // Another example is executing a search where the span of the haystack
+    /// // we specify is all ASCII, but there is non-ASCII just before it. This
+    /// // correctly also reports an error.
+    /// let input = Input::new("β123").range(2..);
+    /// let expected = MatchError::quit(0xB2, 1);
+    /// let got = dfa.try_search_fwd(&mut cache, &input);
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// // And similarly for the trailing word boundary.
+    /// let input = Input::new("123β").range(..3);
+    /// let expected = MatchError::quit(0xCE, 3);
+    /// let got = dfa.try_search_fwd(&mut cache, &input);
+    /// assert_eq!(Err(expected), got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn unicode_word_boundary(mut self, yes: bool) -> Config {
+        // We have a separate option for this instead of just setting the
+        // appropriate quit bytes here because we don't want to set quit bytes
+        // for every regex. We only want to set them when the regex contains a
+        // Unicode word boundary.
+        self.unicode_word_boundary = Some(yes);
+        self
+    }
+
+    /// Add a "quit" byte to the lazy DFA.
+    ///
+    /// When a quit byte is seen during search time, then search will return a
+    /// [`MatchError::quit`] error indicating the offset at which the search
+    /// stopped.
+    ///
+    /// A quit byte will always overrule any other aspects of a regex. For
+    /// example, if the `x` byte is added as a quit byte and the regex `\w` is
+    /// used, then observing `x` will cause the search to quit immediately
+    /// despite the fact that `x` is in the `\w` class.
+    ///
+    /// This mechanism is primarily useful for heuristically enabling certain
+    /// features like Unicode word boundaries in a DFA. Namely, if the input
+    /// to search is ASCII, then a Unicode word boundary can be implemented
+    /// via an ASCII word boundary with no change in semantics. Thus, a DFA
+    /// can attempt to match a Unicode word boundary but give up as soon as it
+    /// observes a non-ASCII byte. Indeed, if callers set all non-ASCII bytes
+    /// to be quit bytes, then Unicode word boundaries will be permitted when
+    /// building lazy DFAs. Of course, callers should enable
+    /// [`Config::unicode_word_boundary`] if they want this behavior instead.
+    /// (The advantage being that non-ASCII quit bytes will only be added if a
+    /// Unicode word boundary is in the pattern.)
+    ///
+    /// When enabling this option, callers _must_ be prepared to handle a
+    /// [`MatchError`](crate::MatchError) error during search. When using a
+    /// [`Regex`](crate::hybrid::regex::Regex), this corresponds to using the
+    /// `try_` suite of methods.
+    ///
+    /// By default, there are no quit bytes set.
+    ///
+    /// # Panics
+    ///
+    /// This panics if heuristic Unicode word boundaries are enabled and any
+    /// non-ASCII byte is removed from the set of quit bytes. Namely, enabling
+    /// Unicode word boundaries requires setting every non-ASCII byte to a quit
+    /// byte. So if the caller attempts to undo any of that, then this will
+    /// panic.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to cause a search to terminate if it sees a
+    /// `\n` byte. This could be useful if, for example, you wanted to prevent
+    /// a user supplied pattern from matching across a line boundary.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, MatchError, Input};
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().quit(b'\n', true))
+    ///     .build(r"foo\p{any}+bar")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "foo\nbar";
+    /// // Normally this would produce a match, since \p{any} contains '\n'.
+    /// // But since we instructed the automaton to enter a quit state if a
+    /// // '\n' is observed, this produces a match error instead.
+    /// let expected = MatchError::quit(b'\n', 3);
+    /// let got = dfa.try_search_fwd(
+    ///     &mut cache,
+    ///     &Input::new(haystack),
+    /// ).unwrap_err();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn quit(mut self, byte: u8, yes: bool) -> Config {
+        if self.get_unicode_word_boundary() && !byte.is_ascii() && !yes {
+            panic!(
+                "cannot set non-ASCII byte to be non-quit when \
+                 Unicode word boundaries are enabled"
+            );
+        }
+        if self.quitset.is_none() {
+            self.quitset = Some(ByteSet::empty());
+        }
+        if yes {
+            self.quitset.as_mut().unwrap().add(byte);
+        } else {
+            self.quitset.as_mut().unwrap().remove(byte);
+        }
+        self
+    }
+
+    /// Enable specializing start states in the lazy DFA.
+    ///
+    /// When start states are specialized, an implementor of a search routine
+    /// using a lazy DFA can tell when the search has entered a starting state.
+    /// When start states aren't specialized, then it is impossible to know
+    /// whether the search has entered a start state.
+    ///
+    /// Ideally, this option wouldn't need to exist and we could always
+    /// specialize start states. The problem is that start states can be quite
+    /// active. This in turn means that an efficient search routine is likely
+    /// to ping-pong between a heavily optimized hot loop that handles most
+    /// states and to a less optimized specialized handling of start states.
+    /// This causes branches to get heavily mispredicted and overall can
+    /// materially decrease throughput. Therefore, specializing start states
+    /// should only be enabled when it is needed.
+    ///
+    /// Knowing whether a search is in a start state is typically useful when a
+    /// prefilter is active for the search. A prefilter is typically only run
+    /// when in a start state and a prefilter can greatly accelerate a search.
+    /// Therefore, the possible cost of specializing start states is worth it
+    /// in this case. Otherwise, if you have no prefilter, there is likely no
+    /// reason to specialize start states.
+    ///
+    /// This is disabled by default, but note that it is automatically
+    /// enabled (or disabled) if [`Config::prefilter`] is set. Namely, unless
+    /// `specialize_start_states` has already been set, [`Config::prefilter`]
+    /// will automatically enable or disable it based on whether a prefilter
+    /// is present or not, respectively. This is done because a prefilter's
+    /// effectiveness is rooted in being executed whenever the DFA is in a
+    /// start state, and that's only possible to do when they are specialized.
+    ///
+    /// Note that it is plausibly reasonable to _disable_ this option
+    /// explicitly while _enabling_ a prefilter. In that case, a prefilter
+    /// will still be run at the beginning of a search, but never again. This
+    /// in theory could strike a good balance if you're in a situation where a
+    /// prefilter is likely to produce many false positive candidates.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to enable start state specialization and then
+    /// shows how to check whether a state is a start state or not.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, MatchError, Input};
+    ///
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().specialize_start_states(true))
+    ///     .build(r"[a-z]+")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let sid = dfa.start_state_forward(&mut cache, &Input::new(haystack))?;
+    /// // The ID returned by 'start_state_forward' will always be tagged as
+    /// // a start state when start state specialization is enabled.
+    /// assert!(sid.is_tagged());
+    /// assert!(sid.is_start());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Compare the above with the default lazy DFA configuration where
+    /// start states are _not_ specialized. In this case, the start state
+    /// is not tagged and `sid.is_start()` returns false.
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::dfa::DFA, MatchError, Input};
+    ///
+    /// let dfa = DFA::new(r"[a-z]+")?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "123 foobar 4567".as_bytes();
+    /// let sid = dfa.start_state_forward(&mut cache, &Input::new(haystack))?;
+    /// // Start states are not tagged in the default configuration!
+    /// assert!(!sid.is_tagged());
+    /// assert!(!sid.is_start());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn specialize_start_states(mut self, yes: bool) -> Config {
+        self.specialize_start_states = Some(yes);
+        self
+    }
+
+    /// Sets the maximum amount of heap memory, in bytes, to allocate to the
+    /// cache for use during a lazy DFA search. If the lazy DFA would otherwise
+    /// use more heap memory, then, depending on other configuration knobs,
+    /// either stop the search and return an error or clear the cache and
+    /// continue the search.
+    ///
+    /// The default cache capacity is some "reasonable" number that will
+    /// accommodate most regular expressions. You may find that if you need
+    /// to build a large DFA then it may be necessary to increase the cache
+    /// capacity.
+    ///
+    /// Note that while building a lazy DFA will do a "minimum" check to ensure
+    /// the capacity is big enough, this is more or less about correctness.
+    /// If the cache is bigger than the minimum but still "too small," then the
+    /// lazy DFA could wind up spending a lot of time clearing the cache and
+    /// recomputing transitions, thus negating the performance benefits of a
+    /// lazy DFA. Thus, setting the cache capacity is mostly an experimental
+    /// endeavor. For most common patterns, however, the default should be
+    /// sufficient.
+    ///
+    /// For more details on how the lazy DFA's cache is used, see the
+    /// documentation for [`Cache`].
+    ///
+    /// # Example
+    ///
+    /// This example shows what happens if the configured cache capacity is
+    /// too small. In such cases, one can override the cache capacity to make
+    /// it bigger. Alternatively, one might want to use less memory by setting
+    /// a smaller cache capacity.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let pattern = r"\p{L}{1000}";
+    ///
+    /// // The default cache capacity is likely too small to deal with regexes
+    /// // that are very large. Large repetitions of large Unicode character
+    /// // classes are a common way to make very large regexes.
+    /// let _ = DFA::new(pattern).unwrap_err();
+    /// // Bump up the capacity to something bigger.
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().cache_capacity(100 * (1<<20))) // 100 MB
+    ///     .build(pattern)?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "ͰͲͶͿΆΈΉΊΌΎΏΑΒΓΔΕΖΗΘΙ".repeat(50);
+    /// let expected = Some(HalfMatch::must(0, 2000));
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(&haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn cache_capacity(mut self, bytes: usize) -> Config {
+        self.cache_capacity = Some(bytes);
+        self
+    }
+
+    /// Configures construction of a lazy DFA to use the minimum cache capacity
+    /// if the configured capacity is otherwise too small for the provided NFA.
+    ///
+    /// This is useful if you never want lazy DFA construction to fail because
+    /// of a capacity that is too small.
+    ///
+    /// In general, this option is typically not a good idea. In particular,
+    /// while a minimum cache capacity does permit the lazy DFA to function
+    /// where it otherwise couldn't, it's plausible that it may not function
+    /// well if it's constantly running out of room. In that case, the speed
+    /// advantages of the lazy DFA may be negated. On the other hand, the
+    /// "minimum" cache capacity computed may not be completely accurate and
+    /// could actually be bigger than what is really necessary. Therefore, it
+    /// is plausible that using the minimum cache capacity could still result
+    /// in very good performance.
+    ///
+    /// This is disabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows what happens if the configured cache capacity is
+    /// too small. In such cases, one could override the capacity explicitly.
+    /// An alternative, demonstrated here, let's us force construction to use
+    /// the minimum cache capacity if the configured capacity is otherwise
+    /// too small.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, HalfMatch, Input};
+    ///
+    /// let pattern = r"\p{L}{1000}";
+    ///
+    /// // The default cache capacity is likely too small to deal with regexes
+    /// // that are very large. Large repetitions of large Unicode character
+    /// // classes are a common way to make very large regexes.
+    /// let _ = DFA::new(pattern).unwrap_err();
+    /// // Configure construction such it automatically selects the minimum
+    /// // cache capacity if it would otherwise be too small.
+    /// let dfa = DFA::builder()
+    ///     .configure(DFA::config().skip_cache_capacity_check(true))
+    ///     .build(pattern)?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// let haystack = "ͰͲͶͿΆΈΉΊΌΎΏΑΒΓΔΕΖΗΘΙ".repeat(50);
+    /// let expected = Some(HalfMatch::must(0, 2000));
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(&haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn skip_cache_capacity_check(mut self, yes: bool) -> Config {
+        self.skip_cache_capacity_check = Some(yes);
+        self
+    }
+
+    /// Configure a lazy DFA search to quit after a certain number of cache
+    /// clearings.
+    ///
+    /// When a minimum is set, then a lazy DFA search will *possibly* "give
+    /// up" after the minimum number of cache clearings has occurred. This is
+    /// typically useful in scenarios where callers want to detect whether the
+    /// lazy DFA search is "efficient" or not. If the cache is cleared too many
+    /// times, this is a good indicator that it is not efficient, and thus, the
+    /// caller may wish to use some other regex engine.
+    ///
+    /// Note that the number of times a cache is cleared is a property of
+    /// the cache itself. Thus, if a cache is used in a subsequent search
+    /// with a similarly configured lazy DFA, then it could cause the
+    /// search to "give up" if the cache needed to be cleared, depending
+    /// on its internal count and configured minimum. The cache clear
+    /// count can only be reset to `0` via [`DFA::reset_cache`] (or
+    /// [`Regex::reset_cache`](crate::hybrid::regex::Regex::reset_cache) if
+    /// you're using the `Regex` API).
+    ///
+    /// By default, no minimum is configured. Thus, a lazy DFA search will
+    /// never give up due to cache clearings. If you do set this option, you
+    /// might consider also setting [`Config::minimum_bytes_per_state`] in
+    /// order for the lazy DFA to take efficiency into account before giving
+    /// up.
+    ///
+    /// # Example
+    ///
+    /// This example uses a somewhat pathological configuration to demonstrate
+    /// the _possible_ behavior of cache clearing and how it might result
+    /// in a search that returns an error.
+    ///
+    /// It is important to note that the precise mechanics of how and when
+    /// a cache gets cleared is an implementation detail.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::dfa::DFA, Input, MatchError, MatchErrorKind};
+    ///
+    /// // This is a carefully chosen regex. The idea is to pick one
+    /// // that requires some decent number of states (hence the bounded
+    /// // repetition). But we specifically choose to create a class with an
+    /// // ASCII letter and a non-ASCII letter so that we can check that no new
+    /// // states are created once the cache is full. Namely, if we fill up the
+    /// // cache on a haystack of 'a's, then in order to match one 'β', a new
+    /// // state will need to be created since a 'β' is encoded with multiple
+    /// // bytes. Since there's no room for this state, the search should quit
+    /// // at the very first position.
+    /// let pattern = r"[aβ]{100}";
+    /// let dfa = DFA::builder()
+    ///     .configure(
+    ///         // Configure it so that we have the minimum cache capacity
+    ///         // possible. And that if any clearings occur, the search quits.
+    ///         DFA::config()
+    ///             .skip_cache_capacity_check(true)
+    ///             .cache_capacity(0)
+    ///             .minimum_cache_clear_count(Some(0)),
+    ///     )
+    ///     .build(pattern)?;
+    /// let mut cache = dfa.create_cache();
+    ///
+    /// // Our search will give up before reaching the end!
+    /// let haystack = "a".repeat(101).into_bytes();
+    /// let result = dfa.try_search_fwd(&mut cache, &Input::new(&haystack));
+    /// assert!(matches!(
+    ///     *result.unwrap_err().kind(),
+    ///     MatchErrorKind::GaveUp { .. },
+    /// ));
+    ///
+    /// // Now that we know the cache is full, if we search a haystack that we
+    /// // know will require creating at least one new state, it should not
+    /// // be able to make much progress.
+    /// let haystack = "β".repeat(101).into_bytes();
+    /// let result = dfa.try_search_fwd(&mut cache, &Input::new(&haystack));
+    /// assert!(matches!(
+    ///     *result.unwrap_err().kind(),
+    ///     MatchErrorKind::GaveUp { .. },
+    /// ));
+    ///
+    /// // If we reset the cache, then we should be able to create more states
+    /// // and make more progress with searching for betas.
+    /// cache.reset(&dfa);
+    /// let haystack = "β".repeat(101).into_bytes();
+    /// let result = dfa.try_search_fwd(&mut cache, &Input::new(&haystack));
+    /// assert!(matches!(
+    ///     *result.unwrap_err().kind(),
+    ///     MatchErrorKind::GaveUp { .. },
+    /// ));
+    ///
+    /// // ... switching back to ASCII still makes progress since it just needs
+    /// // to set transitions on existing states!
+    /// let haystack = "a".repeat(101).into_bytes();
+    /// let result = dfa.try_search_fwd(&mut cache, &Input::new(&haystack));
+    /// assert!(matches!(
+    ///     *result.unwrap_err().kind(),
+    ///     MatchErrorKind::GaveUp { .. },
+    /// ));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn minimum_cache_clear_count(mut self, min: Option<usize>) -> Config {
+        self.minimum_cache_clear_count = Some(min);
+        self
+    }
+
+    /// Configure a lazy DFA search to quit only when its efficiency drops
+    /// below the given minimum.
+    ///
+    /// The efficiency of the cache is determined by the number of DFA states
+    /// compiled per byte of haystack searched. For example, if the efficiency
+    /// is 2, then it means the lazy DFA is creating a new DFA state after
+    /// searching approximately 2 bytes in a haystack. Generally speaking, 2
+    /// is quite bad and it's likely that even a slower regex engine like the
+    /// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) would be faster.
+    ///
+    /// This has no effect if [`Config::minimum_cache_clear_count`] is not set.
+    /// Namely, this option only kicks in when the cache has been cleared more
+    /// than the minimum number. If no minimum is set, then the cache is simply
+    /// cleared whenever it fills up and it is impossible for the lazy DFA to
+    /// quit due to ineffective use of the cache.
+    ///
+    /// In general, if one is setting [`Config::minimum_cache_clear_count`],
+    /// then one should probably also set this knob as well. The reason is
+    /// that the absolute number of times the cache is cleared is generally
+    /// not a great predictor of efficiency. For example, if a new DFA state
+    /// is created for every 1,000 bytes searched, then it wouldn't be hard
+    /// for the cache to get cleared more than `N` times and then cause the
+    /// lazy DFA to quit. But a new DFA state every 1,000 bytes is likely quite
+    /// good from a performance perspective, and it's likely that the lazy
+    /// DFA should continue searching, even if it requires clearing the cache
+    /// occasionally.
+    ///
+    /// Finally, note that if you're implementing your own lazy DFA search
+    /// routine and also want this efficiency check to work correctly, then
+    /// you'll need to use the following routines to record search progress:
+    ///
+    /// * Call [`Cache::search_start`] at the beginning of every search.
+    /// * Call [`Cache::search_update`] whenever [`DFA::next_state`] is
+    /// called.
+    /// * Call [`Cache::search_finish`] before completing a search. (It is
+    /// not strictly necessary to call this when an error is returned, as
+    /// `Cache::search_start` will automatically finish the previous search
+    /// for you. But calling it where possible before returning helps improve
+    /// the accuracy of how many bytes have actually been searched.)
+    pub fn minimum_bytes_per_state(mut self, min: Option<usize>) -> Config {
+        self.minimum_bytes_per_state = Some(min);
+        self
+    }
+
+    /// Returns the match semantics set in this configuration.
+    pub fn get_match_kind(&self) -> MatchKind {
+        self.match_kind.unwrap_or(MatchKind::LeftmostFirst)
+    }
+
+    /// Returns the prefilter set in this configuration, if one at all.
+    pub fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref().unwrap_or(&None).as_ref()
+    }
+
+    /// Returns whether this configuration has enabled anchored starting states
+    /// for every pattern in the DFA.
+    pub fn get_starts_for_each_pattern(&self) -> bool {
+        self.starts_for_each_pattern.unwrap_or(false)
+    }
+
+    /// Returns whether this configuration has enabled byte classes or not.
+    /// This is typically a debugging oriented option, as disabling it confers
+    /// no speed benefit.
+    pub fn get_byte_classes(&self) -> bool {
+        self.byte_classes.unwrap_or(true)
+    }
+
+    /// Returns whether this configuration has enabled heuristic Unicode word
+    /// boundary support. When enabled, it is possible for a search to return
+    /// an error.
+    pub fn get_unicode_word_boundary(&self) -> bool {
+        self.unicode_word_boundary.unwrap_or(false)
+    }
+
+    /// Returns whether this configuration will instruct the lazy DFA to enter
+    /// a quit state whenever the given byte is seen during a search. When at
+    /// least one byte has this enabled, it is possible for a search to return
+    /// an error.
+    pub fn get_quit(&self, byte: u8) -> bool {
+        self.quitset.map_or(false, |q| q.contains(byte))
+    }
+
+    /// Returns whether this configuration will instruct the lazy DFA to
+    /// "specialize" start states. When enabled, the lazy DFA will tag start
+    /// states so that search routines using the lazy DFA can detect when
+    /// it's in a start state and do some kind of optimization (like run a
+    /// prefilter).
+    pub fn get_specialize_start_states(&self) -> bool {
+        self.specialize_start_states.unwrap_or(false)
+    }
+
+    /// Returns the cache capacity set on this configuration.
+    pub fn get_cache_capacity(&self) -> usize {
+        self.cache_capacity.unwrap_or(2 * (1 << 20))
+    }
+
+    /// Returns whether the cache capacity check should be skipped.
+    pub fn get_skip_cache_capacity_check(&self) -> bool {
+        self.skip_cache_capacity_check.unwrap_or(false)
+    }
+
+    /// Returns, if set, the minimum number of times the cache must be cleared
+    /// before a lazy DFA search can give up. When no minimum is set, then a
+    /// search will never quit and will always clear the cache whenever it
+    /// fills up.
+    pub fn get_minimum_cache_clear_count(&self) -> Option<usize> {
+        self.minimum_cache_clear_count.unwrap_or(None)
+    }
+
+    /// Returns, if set, the minimum number of bytes per state that need to be
+    /// processed in order for the lazy DFA to keep going. If the minimum falls
+    /// below this number (and the cache has been cleared a minimum number of
+    /// times), then the lazy DFA will return a "gave up" error.
+    pub fn get_minimum_bytes_per_state(&self) -> Option<usize> {
+        self.minimum_bytes_per_state.unwrap_or(None)
+    }
+
+    /// Returns the minimum lazy DFA cache capacity required for the given NFA.
+    ///
+    /// The cache capacity required for a particular NFA may change without
+    /// notice. Callers should not rely on it being stable.
+    ///
+    /// This is useful for informational purposes, but can also be useful for
+    /// other reasons. For example, if one wants to check the minimum cache
+    /// capacity themselves or if one wants to set the capacity based on the
+    /// minimum.
+    ///
+    /// This may return an error if this configuration does not support all of
+    /// the instructions used in the given NFA. For example, if the NFA has a
+    /// Unicode word boundary but this configuration does not enable heuristic
+    /// support for Unicode word boundaries.
+    pub fn get_minimum_cache_capacity(
+        &self,
+        nfa: &thompson::NFA,
+    ) -> Result<usize, BuildError> {
+        let quitset = self.quit_set_from_nfa(nfa)?;
+        let classes = self.byte_classes_from_nfa(nfa, &quitset);
+        let starts = self.get_starts_for_each_pattern();
+        Ok(minimum_cache_capacity(nfa, &classes, starts))
+    }
+
+    /// Returns the byte class map used during search from the given NFA.
+    ///
+    /// If byte classes are disabled on this configuration, then a map is
+    /// returned that puts each byte in its own equivalent class.
+    fn byte_classes_from_nfa(
+        &self,
+        nfa: &thompson::NFA,
+        quit: &ByteSet,
+    ) -> ByteClasses {
+        if !self.get_byte_classes() {
+            // The lazy DFA will always use the equivalence class map, but
+            // enabling this option is useful for debugging. Namely, this will
+            // cause all transitions to be defined over their actual bytes
+            // instead of an opaque equivalence class identifier. The former is
+            // much easier to grok as a human.
+            ByteClasses::singletons()
+        } else {
+            let mut set = nfa.byte_class_set().clone();
+            // It is important to distinguish any "quit" bytes from all other
+            // bytes. Otherwise, a non-quit byte may end up in the same class
+            // as a quit byte, and thus cause the DFA stop when it shouldn't.
+            //
+            // Test case:
+            //
+            //   regex-cli find hybrid regex -w @conn.json.1000x.log \
+            //     '^#' '\b10\.55\.182\.100\b'
+            if !quit.is_empty() {
+                set.add_set(&quit);
+            }
+            set.byte_classes()
+        }
+    }
+
+    /// Return the quit set for this configuration and the given NFA.
+    ///
+    /// This may return an error if the NFA is incompatible with this
+    /// configuration's quit set. For example, if the NFA has a Unicode word
+    /// boundary and the quit set doesn't include non-ASCII bytes.
+    fn quit_set_from_nfa(
+        &self,
+        nfa: &thompson::NFA,
+    ) -> Result<ByteSet, BuildError> {
+        let mut quit = self.quitset.unwrap_or(ByteSet::empty());
+        if nfa.look_set_any().contains_word_unicode() {
+            if self.get_unicode_word_boundary() {
+                for b in 0x80..=0xFF {
+                    quit.add(b);
+                }
+            } else {
+                // If heuristic support for Unicode word boundaries wasn't
+                // enabled, then we can still check if our quit set is correct.
+                // If the caller set their quit bytes in a way that causes the
+                // DFA to quit on at least all non-ASCII bytes, then that's all
+                // we need for heuristic support to work.
+                if !quit.contains_range(0x80, 0xFF) {
+                    return Err(
+                        BuildError::unsupported_dfa_word_boundary_unicode(),
+                    );
+                }
+            }
+        }
+        Ok(quit)
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    fn overwrite(&self, o: Config) -> Config {
+        Config {
+            match_kind: o.match_kind.or(self.match_kind),
+            pre: o.pre.or_else(|| self.pre.clone()),
+            starts_for_each_pattern: o
+                .starts_for_each_pattern
+                .or(self.starts_for_each_pattern),
+            byte_classes: o.byte_classes.or(self.byte_classes),
+            unicode_word_boundary: o
+                .unicode_word_boundary
+                .or(self.unicode_word_boundary),
+            quitset: o.quitset.or(self.quitset),
+            specialize_start_states: o
+                .specialize_start_states
+                .or(self.specialize_start_states),
+            cache_capacity: o.cache_capacity.or(self.cache_capacity),
+            skip_cache_capacity_check: o
+                .skip_cache_capacity_check
+                .or(self.skip_cache_capacity_check),
+            minimum_cache_clear_count: o
+                .minimum_cache_clear_count
+                .or(self.minimum_cache_clear_count),
+            minimum_bytes_per_state: o
+                .minimum_bytes_per_state
+                .or(self.minimum_bytes_per_state),
+        }
+    }
+}
+
+/// A builder for constructing a lazy deterministic finite automaton from
+/// regular expressions.
+///
+/// As a convenience, [`DFA::builder`] is an alias for [`Builder::new`]. The
+/// advantage of the former is that it often lets you avoid importing the
+/// `Builder` type directly.
+///
+/// This builder provides two main things:
+///
+/// 1. It provides a few different `build` routines for actually constructing
+/// a DFA from different kinds of inputs. The most convenient is
+/// [`Builder::build`], which builds a DFA directly from a pattern string. The
+/// most flexible is [`Builder::build_from_nfa`], which builds a DFA straight
+/// from an NFA.
+/// 2. The builder permits configuring a number of things.
+/// [`Builder::configure`] is used with [`Config`] to configure aspects of
+/// the DFA and the construction process itself. [`Builder::syntax`] and
+/// [`Builder::thompson`] permit configuring the regex parser and Thompson NFA
+/// construction, respectively. The syntax and thompson configurations only
+/// apply when building from a pattern string.
+///
+/// This builder always constructs a *single* lazy DFA. As such, this builder
+/// can only be used to construct regexes that either detect the presence
+/// of a match or find the end location of a match. A single DFA cannot
+/// produce both the start and end of a match. For that information, use a
+/// [`Regex`](crate::hybrid::regex::Regex), which can be similarly configured
+/// using [`regex::Builder`](crate::hybrid::regex::Builder). The main reason
+/// to use a DFA directly is if the end location of a match is enough for your
+/// use case. Namely, a `Regex` will construct two lazy DFAs instead of one,
+/// since a second reverse DFA is needed to find the start of a match.
+///
+/// # Example
+///
+/// This example shows how to build a lazy DFA that uses a tiny cache capacity
+/// and completely disables Unicode. That is:
+///
+/// * Things such as `\w`, `.` and `\b` are no longer Unicode-aware. `\w`
+///   and `\b` are ASCII-only while `.` matches any byte except for `\n`
+///   (instead of any UTF-8 encoding of a Unicode scalar value except for
+///   `\n`). Things that are Unicode only, such as `\pL`, are not allowed.
+/// * The pattern itself is permitted to match invalid UTF-8. For example,
+///   things like `[^a]` that match any byte except for `a` are permitted.
+///
+/// ```
+/// use regex_automata::{
+///     hybrid::dfa::DFA,
+///     nfa::thompson,
+///     util::syntax,
+///     HalfMatch, Input,
+/// };
+///
+/// let dfa = DFA::builder()
+///     .configure(DFA::config().cache_capacity(5_000))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .syntax(syntax::Config::new().unicode(false).utf8(false))
+///     .build(r"foo[^b]ar.*")?;
+/// let mut cache = dfa.create_cache();
+///
+/// let haystack = b"\xFEfoo\xFFar\xE2\x98\xFF\n";
+/// let expected = Some(HalfMatch::must(0, 10));
+/// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack))?;
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    #[cfg(feature = "syntax")]
+    thompson: thompson::Compiler,
+}
+
+impl Builder {
+    /// Create a new lazy DFA builder with the default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            #[cfg(feature = "syntax")]
+            thompson: thompson::Compiler::new(),
+        }
+    }
+
+    /// Build a lazy DFA from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(&self, pattern: &str) -> Result<DFA, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a lazy DFA from the given patterns.
+    ///
+    /// When matches are returned, the pattern ID corresponds to the index of
+    /// the pattern in the slice given.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<DFA, BuildError> {
+        let nfa = self
+            .thompson
+            .clone()
+            // We can always forcefully disable captures because DFAs do not
+            // support them.
+            .configure(thompson::Config::new().captures(false))
+            .build_many(patterns)
+            .map_err(BuildError::nfa)?;
+        self.build_from_nfa(nfa)
+    }
+
+    /// Build a DFA from the given NFA.
+    ///
+    /// Note that this requires owning a `thompson::NFA`. While this may force
+    /// you to clone the NFA, such a clone is not a deep clone. Namely, NFAs
+    /// are defined internally to support shared ownership such that cloning is
+    /// very cheap.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a lazy DFA if you already have an NFA
+    /// in hand.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     nfa::thompson,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let haystack = "foo123bar";
+    ///
+    /// // This shows how to set non-default options for building an NFA.
+    /// let nfa = thompson::Compiler::new()
+    ///     .configure(thompson::Config::new().shrink(true))
+    ///     .build(r"[0-9]+")?;
+    /// let dfa = DFA::builder().build_from_nfa(nfa)?;
+    /// let mut cache = dfa.create_cache();
+    /// let expected = Some(HalfMatch::must(0, 6));
+    /// let got = dfa.try_search_fwd(&mut cache, &Input::new(haystack))?;
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_nfa(
+        &self,
+        nfa: thompson::NFA,
+    ) -> Result<DFA, BuildError> {
+        let quitset = self.config.quit_set_from_nfa(&nfa)?;
+        let classes = self.config.byte_classes_from_nfa(&nfa, &quitset);
+        // Check that we can fit at least a few states into our cache,
+        // otherwise it's pretty senseless to use the lazy DFA. This does have
+        // a possible failure mode though. This assumes the maximum size of a
+        // state in powerset space (so, the total number of NFA states), which
+        // may never actually materialize, and could be quite a bit larger
+        // than the actual biggest state. If this turns out to be a problem,
+        // we could expose a knob that disables this check. But if so, we have
+        // to be careful not to panic in other areas of the code (the cache
+        // clearing and init code) that tend to assume some minimum useful
+        // cache capacity.
+        let min_cache = minimum_cache_capacity(
+            &nfa,
+            &classes,
+            self.config.get_starts_for_each_pattern(),
+        );
+        let mut cache_capacity = self.config.get_cache_capacity();
+        if cache_capacity < min_cache {
+            // When the caller has asked us to skip the cache capacity check,
+            // then we simply force the cache capacity to its minimum amount
+            // and mush on.
+            if self.config.get_skip_cache_capacity_check() {
+                debug!(
+                    "given capacity ({}) is too small, \
+                     since skip_cache_capacity_check is enabled, \
+                     setting cache capacity to minimum ({})",
+                    cache_capacity, min_cache,
+                );
+                cache_capacity = min_cache;
+            } else {
+                return Err(BuildError::insufficient_cache_capacity(
+                    min_cache,
+                    cache_capacity,
+                ));
+            }
+        }
+        // We also need to check that we can fit at least some small number
+        // of states in our state ID space. This is unlikely to trigger in
+        // >=32-bit systems, but 16-bit systems have a pretty small state ID
+        // space since a number of bits are used up as sentinels.
+        if let Err(err) = minimum_lazy_state_id(&classes) {
+            return Err(BuildError::insufficient_state_id_capacity(err));
+        }
+        let stride2 = classes.stride2();
+        let start_map = StartByteMap::new(nfa.look_matcher());
+        Ok(DFA {
+            config: self.config.clone(),
+            nfa,
+            stride2,
+            start_map,
+            classes,
+            quitset,
+            cache_capacity,
+        })
+    }
+
+    /// Apply the given lazy DFA configuration options to this builder.
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// These settings only apply when constructing a lazy DFA directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.thompson.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like whether the DFA should match the regex
+    /// in reverse or if additional time should be spent shrinking the size of
+    /// the NFA.
+    ///
+    /// These settings only apply when constructing a DFA directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.thompson.configure(config);
+        self
+    }
+}
+
+/// Represents the current state of an overlapping search.
+///
+/// This is used for overlapping searches since they need to know something
+/// about the previous search. For example, when multiple patterns match at the
+/// same position, this state tracks the last reported pattern so that the next
+/// search knows whether to report another matching pattern or continue with
+/// the search at the next position. Additionally, it also tracks which state
+/// the last search call terminated in.
+///
+/// This type provides little introspection capabilities. The only thing a
+/// caller can do is construct it and pass it around to permit search routines
+/// to use it to track state, and also ask whether a match has been found.
+///
+/// Callers should always provide a fresh state constructed via
+/// [`OverlappingState::start`] when starting a new search. Reusing state from
+/// a previous search may result in incorrect results.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct OverlappingState {
+    /// The match reported by the most recent overlapping search to use this
+    /// state.
+    ///
+    /// If a search does not find any matches, then it is expected to clear
+    /// this value.
+    pub(crate) mat: Option<HalfMatch>,
+    /// The state ID of the state at which the search was in when the call
+    /// terminated. When this is a match state, `last_match` must be set to a
+    /// non-None value.
+    ///
+    /// A `None` value indicates the start state of the corresponding
+    /// automaton. We cannot use the actual ID, since any one automaton may
+    /// have many start states, and which one is in use depends on several
+    /// search-time factors.
+    pub(crate) id: Option<LazyStateID>,
+    /// The position of the search.
+    ///
+    /// When `id` is None (i.e., we are starting a search), this is set to
+    /// the beginning of the search as given by the caller regardless of its
+    /// current value. Subsequent calls to an overlapping search pick up at
+    /// this offset.
+    pub(crate) at: usize,
+    /// The index into the matching patterns of the next match to report if the
+    /// current state is a match state. Note that this may be 1 greater than
+    /// the total number of matches to report for the current match state. (In
+    /// which case, no more matches should be reported at the current position
+    /// and the search should advance to the next position.)
+    pub(crate) next_match_index: Option<usize>,
+    /// This is set to true when a reverse overlapping search has entered its
+    /// EOI transitions.
+    ///
+    /// This isn't used in a forward search because it knows to stop once the
+    /// position exceeds the end of the search range. In a reverse search,
+    /// since we use unsigned offsets, we don't "know" once we've gone past
+    /// `0`. So the only way to detect it is with this extra flag. The reverse
+    /// overlapping search knows to terminate specifically after it has
+    /// reported all matches after following the EOI transition.
+    pub(crate) rev_eoi: bool,
+}
+
+impl OverlappingState {
+    /// Create a new overlapping state that begins at the start state of any
+    /// automaton.
+    pub fn start() -> OverlappingState {
+        OverlappingState {
+            mat: None,
+            id: None,
+            at: 0,
+            next_match_index: None,
+            rev_eoi: false,
+        }
+    }
+
+    /// Return the match result of the most recent search to execute with this
+    /// state.
+    ///
+    /// A searches will clear this result automatically, such that if no
+    /// match is found, this will correctly report `None`.
+    pub fn get_match(&self) -> Option<HalfMatch> {
+        self.mat
+    }
+}
+
+/// Runs the given overlapping `search` function (forwards or backwards) until
+/// a match is found whose offset does not split a codepoint.
+///
+/// This is *not* always correct to call. It should only be called when the
+/// underlying NFA has UTF-8 mode enabled *and* it can produce zero-width
+/// matches. Calling this when both of those things aren't true might result
+/// in legitimate matches getting skipped.
+#[cold]
+#[inline(never)]
+fn skip_empty_utf8_splits_overlapping<F>(
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+    mut search: F,
+) -> Result<(), MatchError>
+where
+    F: FnMut(&Input<'_>, &mut OverlappingState) -> Result<(), MatchError>,
+{
+    // Note that this routine works for forwards and reverse searches
+    // even though there's no code here to handle those cases. That's
+    // because overlapping searches drive themselves to completion via
+    // `OverlappingState`. So all we have to do is push it until no matches are
+    // found.
+
+    let mut hm = match state.get_match() {
+        None => return Ok(()),
+        Some(hm) => hm,
+    };
+    if input.get_anchored().is_anchored() {
+        if !input.is_char_boundary(hm.offset()) {
+            state.mat = None;
+        }
+        return Ok(());
+    }
+    while !input.is_char_boundary(hm.offset()) {
+        search(input, state)?;
+        hm = match state.get_match() {
+            None => return Ok(()),
+            Some(hm) => hm,
+        };
+    }
+    Ok(())
+}
+
+/// Based on the minimum number of states required for a useful lazy DFA cache,
+/// this returns the minimum lazy state ID that must be representable.
+///
+/// It's not likely for this to have any impact 32-bit systems (or higher), but
+/// on 16-bit systems, the lazy state ID space is quite constrained and thus
+/// may be insufficient if our MIN_STATES value is (for some reason) too high.
+fn minimum_lazy_state_id(
+    classes: &ByteClasses,
+) -> Result<LazyStateID, LazyStateIDError> {
+    let stride = 1 << classes.stride2();
+    let min_state_index = MIN_STATES.checked_sub(1).unwrap();
+    LazyStateID::new(min_state_index * stride)
+}
+
+/// Based on the minimum number of states required for a useful lazy DFA cache,
+/// this returns a heuristic minimum number of bytes of heap space required.
+///
+/// This is a "heuristic" because the minimum it returns is likely bigger than
+/// the true minimum. Namely, it assumes that each powerset NFA/DFA state uses
+/// the maximum number of NFA states (all of them). This is likely bigger
+/// than what is required in practice. Computing the true minimum effectively
+/// requires determinization, which is probably too much work to do for a
+/// simple check like this.
+///
+/// One of the issues with this approach IMO is that it requires that this
+/// be in sync with the calculation above for computing how much heap memory
+/// the DFA cache uses. If we get it wrong, it's possible for example for the
+/// minimum to be smaller than the computed heap memory, and thus, it may be
+/// the case that we can't add the required minimum number of states. That in
+/// turn will make lazy DFA panic because we assume that we can add at least a
+/// minimum number of states.
+///
+/// Another approach would be to always allow the minimum number of states to
+/// be added to the lazy DFA cache, even if it exceeds the configured cache
+/// limit. This does mean that the limit isn't really a limit in all cases,
+/// which is unfortunate. But it does at least guarantee that the lazy DFA can
+/// always make progress, even if it is slow. (This approach is very similar to
+/// enabling the 'skip_cache_capacity_check' config knob, except it wouldn't
+/// rely on cache size calculation. Instead, it would just always permit a
+/// minimum number of states to be added.)
+fn minimum_cache_capacity(
+    nfa: &thompson::NFA,
+    classes: &ByteClasses,
+    starts_for_each_pattern: bool,
+) -> usize {
+    const ID_SIZE: usize = size_of::<LazyStateID>();
+    const STATE_SIZE: usize = size_of::<State>();
+
+    let stride = 1 << classes.stride2();
+    let states_len = nfa.states().len();
+    let sparses = 2 * states_len * NFAStateID::SIZE;
+    let trans = MIN_STATES * stride * ID_SIZE;
+
+    let mut starts = Start::len() * ID_SIZE;
+    if starts_for_each_pattern {
+        starts += (Start::len() * nfa.pattern_len()) * ID_SIZE;
+    }
+
+    // The min number of states HAS to be at least 4: we have 3 sentinel states
+    // and then we need space for one more when we save a state after clearing
+    // the cache. We also need space for one more, otherwise we get stuck in a
+    // loop where we try to add a 5th state, which gets rejected, which clears
+    // the cache, which adds back a saved state (4th total state) which then
+    // tries to add the 5th state again.
+    assert!(MIN_STATES >= 5, "minimum number of states has to be at least 5");
+    // The minimum number of non-sentinel states. We consider this separately
+    // because sentinel states are much smaller in that they contain no NFA
+    // states. Given our aggressive calculation here, it's worth being more
+    // precise with the number of states we need.
+    let non_sentinel = MIN_STATES.checked_sub(SENTINEL_STATES).unwrap();
+
+    // Every `State` has 5 bytes for flags, 4 bytes (max) for the number of
+    // patterns, followed by 32-bit encodings of patterns and then delta
+    // varint encodings of NFA state IDs. We use the worst case (which isn't
+    // technically possible) of 5 bytes for each NFA state ID.
+    //
+    // HOWEVER, three of the states needed by a lazy DFA are just the sentinel
+    // unknown, dead and quit states. Those states have a known size and it is
+    // small.
+    let dead_state_size = State::dead().memory_usage();
+    let max_state_size = 5 + 4 + (nfa.pattern_len() * 4) + (states_len * 5);
+    let states = (SENTINEL_STATES * (STATE_SIZE + dead_state_size))
+        + (non_sentinel * (STATE_SIZE + max_state_size));
+    // NOTE: We don't double count heap memory used by State for this map since
+    // we use reference counting to avoid doubling memory usage. (This tends to
+    // be where most memory is allocated in the cache.)
+    let states_to_sid = (MIN_STATES * STATE_SIZE) + (MIN_STATES * ID_SIZE);
+    let stack = states_len * NFAStateID::SIZE;
+    let scratch_state_builder = max_state_size;
+
+    trans
+        + starts
+        + states
+        + states_to_sid
+        + sparses
+        + stack
+        + scratch_state_builder
+}
+
+#[cfg(all(test, feature = "syntax"))]
+mod tests {
+    use super::*;
+
+    // Tests that we handle heuristic Unicode word boundary support in reverse
+    // DFAs in the specific case of contextual searches.
+    //
+    // I wrote this test when I discovered a bug in how heuristic word
+    // boundaries were handled. Namely, that the starting state selection
+    // didn't consider the DFA's quit byte set when looking at the byte
+    // immediately before the start of the search (or immediately after the
+    // end of the search in the case of a reverse search). As a result, it was
+    // possible for '\bfoo\b' to match 'β123' because the trailing \xB2 byte
+    // in the 'β' codepoint would be treated as a non-word character. But of
+    // course, this search should trigger the DFA to quit, since there is a
+    // non-ASCII byte in consideration.
+    //
+    // Thus, I fixed 'start_state_{forward,reverse}' to check the quit byte set
+    // if it wasn't empty. The forward case is tested in the doc test for the
+    // Config::unicode_word_boundary API. We test the reverse case here, which
+    // is sufficiently niche that it doesn't really belong in a doc test.
+    #[test]
+    fn heuristic_unicode_reverse() {
+        let dfa = DFA::builder()
+            .configure(DFA::config().unicode_word_boundary(true))
+            .thompson(thompson::Config::new().reverse(true))
+            .build(r"\b[0-9]+\b")
+            .unwrap();
+        let mut cache = dfa.create_cache();
+
+        let input = Input::new("β123").range(2..);
+        let expected = MatchError::quit(0xB2, 1);
+        let got = dfa.try_search_rev(&mut cache, &input);
+        assert_eq!(Err(expected), got);
+
+        let input = Input::new("123β").range(..3);
+        let expected = MatchError::quit(0xCE, 3);
+        let got = dfa.try_search_rev(&mut cache, &input);
+        assert_eq!(Err(expected), got);
+    }
+}
diff --git a/regex-automata/src/hybrid/error.rs b/regex-automata/src/hybrid/error.rs
new file mode 100644
index 0000000000..604daf3c38
--- /dev/null
+++ b/regex-automata/src/hybrid/error.rs
@@ -0,0 +1,139 @@
+use crate::{hybrid::id::LazyStateIDError, nfa};
+
+/// An error that occurs when initial construction of a lazy DFA fails.
+///
+/// A build error can occur when insufficient cache capacity is configured or
+/// if something about the NFA is unsupported. (For example, if one attempts
+/// to build a lazy DFA without heuristic Unicode support but with an NFA that
+/// contains a Unicode word boundary.)
+///
+/// This error does not provide many introspection capabilities. There are
+/// generally only two things you can do with it:
+///
+/// * Obtain a human readable message via its `std::fmt::Display` impl.
+/// * Access an underlying
+/// [`nfa::thompson::BuildError`](crate::nfa::thompson::BuildError)
+/// type from its `source` method via the `std::error::Error` trait. This error
+/// only occurs when using convenience routines for building a lazy DFA
+/// directly from a pattern string.
+///
+/// When the `std` feature is enabled, this implements the `std::error::Error`
+/// trait.
+#[derive(Clone, Debug)]
+pub struct BuildError {
+    kind: BuildErrorKind,
+}
+
+#[derive(Clone, Debug)]
+enum BuildErrorKind {
+    NFA(nfa::thompson::BuildError),
+    InsufficientCacheCapacity { minimum: usize, given: usize },
+    InsufficientStateIDCapacity { err: LazyStateIDError },
+    Unsupported(&'static str),
+}
+
+impl BuildError {
+    pub(crate) fn nfa(err: nfa::thompson::BuildError) -> BuildError {
+        BuildError { kind: BuildErrorKind::NFA(err) }
+    }
+
+    pub(crate) fn insufficient_cache_capacity(
+        minimum: usize,
+        given: usize,
+    ) -> BuildError {
+        BuildError {
+            kind: BuildErrorKind::InsufficientCacheCapacity { minimum, given },
+        }
+    }
+
+    pub(crate) fn insufficient_state_id_capacity(
+        err: LazyStateIDError,
+    ) -> BuildError {
+        BuildError {
+            kind: BuildErrorKind::InsufficientStateIDCapacity { err },
+        }
+    }
+
+    pub(crate) fn unsupported_dfa_word_boundary_unicode() -> BuildError {
+        let msg = "cannot build lazy DFAs for regexes with Unicode word \
+                   boundaries; switch to ASCII word boundaries, or \
+                   heuristically enable Unicode word boundaries or use a \
+                   different regex engine";
+        BuildError { kind: BuildErrorKind::Unsupported(msg) }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind {
+            BuildErrorKind::NFA(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl core::fmt::Display for BuildError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self.kind {
+            BuildErrorKind::NFA(_) => write!(f, "error building NFA"),
+            BuildErrorKind::InsufficientCacheCapacity { minimum, given } => {
+                write!(
+                    f,
+                    "given cache capacity ({}) is smaller than \
+                     minimum required ({})",
+                    given, minimum,
+                )
+            }
+            BuildErrorKind::InsufficientStateIDCapacity { ref err } => {
+                err.fmt(f)
+            }
+            BuildErrorKind::Unsupported(ref msg) => {
+                write!(f, "unsupported regex feature for DFAs: {}", msg)
+            }
+        }
+    }
+}
+
+/// An error that occurs when cache usage has become inefficient.
+///
+/// One of the weaknesses of a lazy DFA is that it may need to clear its
+/// cache repeatedly if it's not big enough. If this happens too much, then it
+/// can slow searching down significantly. A mitigation to this is to use
+/// heuristics to detect whether the cache is being used efficiently or not.
+/// If not, then a lazy DFA can return a `CacheError`.
+///
+/// The default configuration of a lazy DFA in this crate is
+/// set such that a `CacheError` will never occur. Instead,
+/// callers must opt into this behavior with settings like
+/// [`dfa::Config::minimum_cache_clear_count`](crate::hybrid::dfa::Config::minimum_cache_clear_count)
+/// and
+/// [`dfa::Config::minimum_bytes_per_state`](crate::hybrid::dfa::Config::minimum_bytes_per_state).
+///
+/// When the `std` feature is enabled, this implements the `std::error::Error`
+/// trait.
+#[derive(Clone, Debug)]
+pub struct CacheError(());
+
+impl CacheError {
+    pub(crate) fn too_many_cache_clears() -> CacheError {
+        CacheError(())
+    }
+
+    pub(crate) fn bad_efficiency() -> CacheError {
+        CacheError(())
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CacheError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
+}
+
+impl core::fmt::Display for CacheError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "lazy DFA cache has been cleared too many times")
+    }
+}
diff --git a/regex-automata/src/hybrid/id.rs b/regex-automata/src/hybrid/id.rs
new file mode 100644
index 0000000000..662e3c98f0
--- /dev/null
+++ b/regex-automata/src/hybrid/id.rs
@@ -0,0 +1,354 @@
+/// A state identifier specifically tailored for lazy DFAs.
+///
+/// A lazy state ID logically represents a pointer to a DFA state. In practice,
+/// by limiting the number of DFA states it can address, it reserves some
+/// bits of its representation to encode some additional information. That
+/// additional information is called a "tag." That tag is used to record
+/// whether the state it points to is an unknown, dead, quit, start or match
+/// state.
+///
+/// When implementing a low level search routine with a lazy DFA, it is
+/// necessary to query the type of the current state to know what to do:
+///
+/// * **Unknown** - The state has not yet been computed. The
+/// parameters used to get this state ID must be re-passed to
+/// [`DFA::next_state`](crate::hybrid::dfa::DFA::next_state), which will never
+/// return an unknown state ID.
+/// * **Dead** - A dead state only has transitions to itself. It indicates that
+/// the search cannot do anything else and should stop with whatever result it
+/// has.
+/// * **Quit** - A quit state indicates that the automaton could not answer
+/// whether a match exists or not. Correct search implementations must return a
+/// [`MatchError::quit`](crate::MatchError::quit) when a DFA enters a quit
+/// state.
+/// * **Start** - A start state is a state in which a search can begin.
+/// Lazy DFAs usually have more than one start state. Branching on
+/// this isn't required for correctness, but a common optimization is
+/// to run a prefilter when a search enters a start state. Note that
+/// start states are *not* tagged automatically, and one must enable the
+/// [`Config::specialize_start_states`](crate::hybrid::dfa::Config::specialize_start_states)
+/// setting for start states to be tagged. The reason for this is
+/// that a DFA search loop is usually written to execute a prefilter once it
+/// enters a start state. But if there is no prefilter, this handling can be
+/// quite diastrous as the DFA may ping-pong between the special handling code
+/// and a possible optimized hot path for handling untagged states. When start
+/// states aren't specialized, then they are untagged and remain in the hot
+/// path.
+/// * **Match** - A match state indicates that a match has been found.
+/// Depending on the semantics of your search implementation, it may either
+/// continue until the end of the haystack or a dead state, or it might quit
+/// and return the match immediately.
+///
+/// As an optimization, the [`is_tagged`](LazyStateID::is_tagged) predicate
+/// can be used to determine if a tag exists at all. This is useful to avoid
+/// branching on all of the above types for every byte searched.
+///
+/// # Example
+///
+/// This example shows how `LazyStateID` can be used to implement a correct
+/// search routine with minimal branching. In particular, this search routine
+/// implements "leftmost" matching, which means that it doesn't immediately
+/// stop once a match is found. Instead, it continues until it reaches a dead
+/// state.
+///
+/// Notice also how a correct search implementation deals with
+/// [`CacheError`](crate::hybrid::CacheError)s returned by some of
+/// the lazy DFA routines. When a `CacheError` occurs, it returns
+/// [`MatchError::gave_up`](crate::MatchError::gave_up).
+///
+/// ```
+/// use regex_automata::{
+///     hybrid::dfa::{Cache, DFA},
+///     HalfMatch, MatchError, Input,
+/// };
+///
+/// fn find_leftmost_first(
+///     dfa: &DFA,
+///     cache: &mut Cache,
+///     haystack: &[u8],
+/// ) -> Result<Option<HalfMatch>, MatchError> {
+///     // The start state is determined by inspecting the position and the
+///     // initial bytes of the haystack. Note that start states can never
+///     // be match states (since DFAs in this crate delay matches by 1
+///     // byte), so we don't need to check if the start state is a match.
+///     let mut sid = dfa.start_state_forward(
+///         cache,
+///         &Input::new(haystack),
+///     )?;
+///     let mut last_match = None;
+///     // Walk all the bytes in the haystack. We can quit early if we see
+///     // a dead or a quit state. The former means the automaton will
+///     // never transition to any other state. The latter means that the
+///     // automaton entered a condition in which its search failed.
+///     for (i, &b) in haystack.iter().enumerate() {
+///         sid = dfa
+///             .next_state(cache, sid, b)
+///             .map_err(|_| MatchError::gave_up(i))?;
+///         if sid.is_tagged() {
+///             if sid.is_match() {
+///                 last_match = Some(HalfMatch::new(
+///                     dfa.match_pattern(cache, sid, 0),
+///                     i,
+///                 ));
+///             } else if sid.is_dead() {
+///                 return Ok(last_match);
+///             } else if sid.is_quit() {
+///                 // It is possible to enter into a quit state after
+///                 // observing a match has occurred. In that case, we
+///                 // should return the match instead of an error.
+///                 if last_match.is_some() {
+///                     return Ok(last_match);
+///                 }
+///                 return Err(MatchError::quit(b, i));
+///             }
+///             // Implementors may also want to check for start states and
+///             // handle them differently for performance reasons. But it is
+///             // not necessary for correctness. Note that in order to check
+///             // for start states, you'll need to enable the
+///             // 'specialize_start_states' config knob, otherwise start
+///             // states will not be tagged.
+///         }
+///     }
+///     // Matches are always delayed by 1 byte, so we must explicitly walk
+///     // the special "EOI" transition at the end of the search.
+///     sid = dfa
+///         .next_eoi_state(cache, sid)
+///         .map_err(|_| MatchError::gave_up(haystack.len()))?;
+///     if sid.is_match() {
+///         last_match = Some(HalfMatch::new(
+///             dfa.match_pattern(cache, sid, 0),
+///             haystack.len(),
+///         ));
+///     }
+///     Ok(last_match)
+/// }
+///
+/// // We use a greedy '+' operator to show how the search doesn't just stop
+/// // once a match is detected. It continues extending the match. Using
+/// // '[a-z]+?' would also work as expected and stop the search early.
+/// // Greediness is built into the automaton.
+/// let dfa = DFA::new(r"[a-z]+")?;
+/// let mut cache = dfa.create_cache();
+/// let haystack = "123 foobar 4567".as_bytes();
+/// let mat = find_leftmost_first(&dfa, &mut cache, haystack)?.unwrap();
+/// assert_eq!(mat.pattern().as_usize(), 0);
+/// assert_eq!(mat.offset(), 10);
+///
+/// // Here's another example that tests our handling of the special
+/// // EOI transition. This will fail to find a match if we don't call
+/// // 'next_eoi_state' at the end of the search since the match isn't found
+/// // until the final byte in the haystack.
+/// let dfa = DFA::new(r"[0-9]{4}")?;
+/// let mut cache = dfa.create_cache();
+/// let haystack = "123 foobar 4567".as_bytes();
+/// let mat = find_leftmost_first(&dfa, &mut cache, haystack)?.unwrap();
+/// assert_eq!(mat.pattern().as_usize(), 0);
+/// assert_eq!(mat.offset(), 15);
+///
+/// // And note that our search implementation above automatically works
+/// // with multi-DFAs. Namely, `dfa.match_pattern(match_state, 0)` selects
+/// // the appropriate pattern ID for us.
+/// let dfa = DFA::new_many(&[r"[a-z]+", r"[0-9]+"])?;
+/// let mut cache = dfa.create_cache();
+/// let haystack = "123 foobar 4567".as_bytes();
+/// let mat = find_leftmost_first(&dfa, &mut cache, haystack)?.unwrap();
+/// assert_eq!(mat.pattern().as_usize(), 1);
+/// assert_eq!(mat.offset(), 3);
+/// let mat = find_leftmost_first(&dfa, &mut cache, &haystack[3..])?.unwrap();
+/// assert_eq!(mat.pattern().as_usize(), 0);
+/// assert_eq!(mat.offset(), 7);
+/// let mat = find_leftmost_first(&dfa, &mut cache, &haystack[10..])?.unwrap();
+/// assert_eq!(mat.pattern().as_usize(), 1);
+/// assert_eq!(mat.offset(), 5);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(
+    Clone, Copy, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord,
+)]
+pub struct LazyStateID(u32);
+
+impl LazyStateID {
+    #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
+    const MAX_BIT: usize = 31;
+
+    #[cfg(target_pointer_width = "16")]
+    const MAX_BIT: usize = 15;
+
+    const MASK_UNKNOWN: usize = 1 << (LazyStateID::MAX_BIT);
+    const MASK_DEAD: usize = 1 << (LazyStateID::MAX_BIT - 1);
+    const MASK_QUIT: usize = 1 << (LazyStateID::MAX_BIT - 2);
+    const MASK_START: usize = 1 << (LazyStateID::MAX_BIT - 3);
+    const MASK_MATCH: usize = 1 << (LazyStateID::MAX_BIT - 4);
+    const MAX: usize = LazyStateID::MASK_MATCH - 1;
+
+    /// Create a new lazy state ID.
+    ///
+    /// If the given identifier exceeds [`LazyStateID::MAX`], then this returns
+    /// an error.
+    #[inline]
+    pub(crate) fn new(id: usize) -> Result<LazyStateID, LazyStateIDError> {
+        if id > LazyStateID::MAX {
+            let attempted = u64::try_from(id).unwrap();
+            return Err(LazyStateIDError { attempted });
+        }
+        Ok(LazyStateID::new_unchecked(id))
+    }
+
+    /// Create a new lazy state ID without checking whether the given value
+    /// exceeds [`LazyStateID::MAX`].
+    ///
+    /// While this is unchecked, providing an incorrect value must never
+    /// sacrifice memory safety.
+    #[inline]
+    const fn new_unchecked(id: usize) -> LazyStateID {
+        // FIXME: Use as_u32() once const functions in traits are stable.
+        LazyStateID(id as u32)
+    }
+
+    /// Return this lazy state ID as an untagged `usize`.
+    ///
+    /// If this lazy state ID is tagged, then the usize returned is the state
+    /// ID without the tag. If the ID was not tagged, then the usize returned
+    /// is equivalent to the state ID.
+    #[inline]
+    pub(crate) fn as_usize_untagged(&self) -> usize {
+        self.as_usize_unchecked() & LazyStateID::MAX
+    }
+
+    /// Return this lazy state ID as its raw internal `usize` value, which may
+    /// be tagged (and thus greater than LazyStateID::MAX).
+    #[inline]
+    pub(crate) const fn as_usize_unchecked(&self) -> usize {
+        // FIXME: Use as_usize() once const functions in traits are stable.
+        self.0 as usize
+    }
+
+    #[inline]
+    pub(crate) const fn to_unknown(&self) -> LazyStateID {
+        LazyStateID::new_unchecked(
+            self.as_usize_unchecked() | LazyStateID::MASK_UNKNOWN,
+        )
+    }
+
+    #[inline]
+    pub(crate) const fn to_dead(&self) -> LazyStateID {
+        LazyStateID::new_unchecked(
+            self.as_usize_unchecked() | LazyStateID::MASK_DEAD,
+        )
+    }
+
+    #[inline]
+    pub(crate) const fn to_quit(&self) -> LazyStateID {
+        LazyStateID::new_unchecked(
+            self.as_usize_unchecked() | LazyStateID::MASK_QUIT,
+        )
+    }
+
+    /// Return this lazy state ID as a state ID that is tagged as a start
+    /// state.
+    #[inline]
+    pub(crate) const fn to_start(&self) -> LazyStateID {
+        LazyStateID::new_unchecked(
+            self.as_usize_unchecked() | LazyStateID::MASK_START,
+        )
+    }
+
+    /// Return this lazy state ID as a lazy state ID that is tagged as a match
+    /// state.
+    #[inline]
+    pub(crate) const fn to_match(&self) -> LazyStateID {
+        LazyStateID::new_unchecked(
+            self.as_usize_unchecked() | LazyStateID::MASK_MATCH,
+        )
+    }
+
+    /// Return true if and only if this lazy state ID is tagged.
+    ///
+    /// When a lazy state ID is tagged, then one can conclude that it is one
+    /// of a match, start, dead, quit or unknown state.
+    #[inline]
+    pub const fn is_tagged(&self) -> bool {
+        self.as_usize_unchecked() > LazyStateID::MAX
+    }
+
+    /// Return true if and only if this represents a lazy state ID that is
+    /// "unknown." That is, the state has not yet been created. When a caller
+    /// sees this state ID, it generally means that a state has to be computed
+    /// in order to proceed.
+    #[inline]
+    pub const fn is_unknown(&self) -> bool {
+        self.as_usize_unchecked() & LazyStateID::MASK_UNKNOWN > 0
+    }
+
+    /// Return true if and only if this represents a dead state. A dead state
+    /// is a state that can never transition to any other state except the
+    /// dead state. When a dead state is seen, it generally indicates that a
+    /// search should stop.
+    #[inline]
+    pub const fn is_dead(&self) -> bool {
+        self.as_usize_unchecked() & LazyStateID::MASK_DEAD > 0
+    }
+
+    /// Return true if and only if this represents a quit state. A quit state
+    /// is a state that is representationally equivalent to a dead state,
+    /// except it indicates the automaton has reached a point at which it can
+    /// no longer determine whether a match exists or not. In general, this
+    /// indicates an error during search and the caller must either pass this
+    /// error up or use a different search technique.
+    #[inline]
+    pub const fn is_quit(&self) -> bool {
+        self.as_usize_unchecked() & LazyStateID::MASK_QUIT > 0
+    }
+
+    /// Return true if and only if this lazy state ID has been tagged as a
+    /// start state.
+    ///
+    /// Note that if
+    /// [`Config::specialize_start_states`](crate::hybrid::dfa::Config) is
+    /// disabled (which is the default), then this will always return false
+    /// since start states won't be tagged.
+    #[inline]
+    pub const fn is_start(&self) -> bool {
+        self.as_usize_unchecked() & LazyStateID::MASK_START > 0
+    }
+
+    /// Return true if and only if this lazy state ID has been tagged as a
+    /// match state.
+    #[inline]
+    pub const fn is_match(&self) -> bool {
+        self.as_usize_unchecked() & LazyStateID::MASK_MATCH > 0
+    }
+}
+
+/// This error occurs when a lazy state ID could not be constructed.
+///
+/// This occurs when given an integer exceeding the maximum lazy state ID
+/// value.
+///
+/// When the `std` feature is enabled, this implements the `Error` trait.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct LazyStateIDError {
+    attempted: u64,
+}
+
+impl LazyStateIDError {
+    /// Returns the value that failed to constructed a lazy state ID.
+    pub(crate) fn attempted(&self) -> u64 {
+        self.attempted
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for LazyStateIDError {}
+
+impl core::fmt::Display for LazyStateIDError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(
+            f,
+            "failed to create LazyStateID from {:?}, which exceeds {:?}",
+            self.attempted(),
+            LazyStateID::MAX,
+        )
+    }
+}
diff --git a/regex-automata/src/hybrid/mod.rs b/regex-automata/src/hybrid/mod.rs
new file mode 100644
index 0000000000..d6ed0e9f84
--- /dev/null
+++ b/regex-automata/src/hybrid/mod.rs
@@ -0,0 +1,144 @@
+/*!
+A module for building and searching with lazy determinstic finite automata
+(DFAs).
+
+Like other modules in this crate, lazy DFAs support a rich regex syntax with
+Unicode features. The key feature of a lazy DFA is that it builds itself
+incrementally during search, and never uses more than a configured capacity of
+memory. Thus, when searching with a lazy DFA, one must supply a mutable "cache"
+in which the actual DFA's transition table is stored.
+
+If you're looking for fully compiled DFAs, then please see the top-level
+[`dfa` module](crate::dfa).
+
+# Overview
+
+This section gives a brief overview of the primary types in this module:
+
+* A [`regex::Regex`] provides a way to search for matches of a regular
+expression using lazy DFAs. This includes iterating over matches with both the
+start and end positions of each match.
+* A [`dfa::DFA`] provides direct low level access to a lazy DFA.
+
+# Example: basic regex searching
+
+This example shows how to compile a regex using the default configuration
+and then use it to find matches in a byte string:
+
+```
+use regex_automata::{hybrid::regex::Regex, Match};
+
+let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+let mut cache = re.create_cache();
+
+let haystack = "2018-12-24 2016-10-08";
+let matches: Vec<Match> = re.find_iter(&mut cache, haystack).collect();
+assert_eq!(matches, vec![
+    Match::must(0, 0..10),
+    Match::must(0, 11..21),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Example: searching with multiple regexes
+
+The lazy DFAs in this module all fully support searching with multiple regexes
+simultaneously. You can use this support with standard leftmost-first style
+searching to find non-overlapping matches:
+
+```
+# if cfg!(miri) { return Ok(()); } // miri takes too long
+use regex_automata::{hybrid::regex::Regex, Match};
+
+let re = Regex::new_many(&[r"\w+", r"\S+"])?;
+let mut cache = re.create_cache();
+
+let haystack = "@foo bar";
+let matches: Vec<Match> = re.find_iter(&mut cache, haystack).collect();
+assert_eq!(matches, vec![
+    Match::must(1, 0..4),
+    Match::must(0, 5..8),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# When should I use this?
+
+Generally speaking, if you can abide the use of mutable state during search,
+and you don't need things like capturing groups or Unicode word boundary
+support in non-ASCII text, then a lazy DFA is likely a robust choice with
+respect to both search speed and memory usage. Note however that its speed
+may be worse than a general purpose regex engine if you don't select a good
+[prefilter](crate::util::prefilter).
+
+If you know ahead of time that your pattern would result in a very large DFA
+if it was fully compiled, it may be better to use an NFA simulation instead
+of a lazy DFA. Either that, or increase the cache capacity of your lazy DFA
+to something that is big enough to hold the state machine (likely through
+experimentation). The issue here is that if the cache is too small, then it
+could wind up being reset too frequently and this might decrease searching
+speed significantly.
+
+# Differences with fully compiled DFAs
+
+A [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) and a
+[`dfa::regex::Regex`](crate::dfa::regex::Regex) both have the same capabilities
+(and similarly for their underlying DFAs), but they achieve them through
+different means. The main difference is that a hybrid or "lazy" regex builds
+its DFA lazily during search, where as a fully compiled regex will build its
+DFA at construction time. While building a DFA at search time might sound like
+it's slow, it tends to work out where most bytes seen during a search will
+reuse pre-built parts of the DFA and thus can be almost as fast as a fully
+compiled DFA. The main downside is that searching requires mutable space to
+store the DFA, and, in the worst case, a search can result in a new state being
+created for each byte seen, which would make searching quite a bit slower.
+
+A fully compiled DFA never has to worry about searches being slower once
+it's built. (Aside from, say, the transition table being so large that it
+is subject to harsh CPU cache effects.) However, of course, building a full
+DFA can be quite time consuming and memory hungry. Particularly when large
+Unicode character classes are used, which tend to translate into very large
+DFAs.
+
+A lazy DFA strikes a nice balance _in practice_, particularly in the
+presence of Unicode mode, by only building what is needed. It avoids the
+worst case exponential time complexity of DFA compilation by guaranteeing that
+it will only build at most one state per byte searched. While the worst
+case here can lead to a very high constant, it will never be exponential.
+
+# Syntax
+
+This module supports the same syntax as the `regex` crate, since they share the
+same parser. You can find an exhaustive list of supported syntax in the
+[documentation for the `regex` crate](https://docs.rs/regex/1/regex/#syntax).
+
+There are two things that are not supported by the lazy DFAs in this module:
+
+* Capturing groups. The DFAs (and [`Regex`](regex::Regex)es built on top
+of them) can only find the offsets of an entire match, but cannot resolve
+the offsets of each capturing group. This is because DFAs do not have the
+expressive power necessary. Note that it is okay to build a lazy DFA from an
+NFA that contains capture groups. The capture groups will simply be ignored.
+* Unicode word boundaries. These present particularly difficult challenges for
+DFA construction and would result in an explosion in the number of states.
+One can enable [`dfa::Config::unicode_word_boundary`] though, which provides
+heuristic support for Unicode word boundaries that only works on ASCII text.
+Otherwise, one can use `(?-u:\b)` for an ASCII word boundary, which will work
+on any input.
+
+There are no plans to lift either of these limitations.
+
+Note that these restrictions are identical to the restrictions on fully
+compiled DFAs.
+*/
+
+pub use self::{
+    error::{BuildError, CacheError},
+    id::LazyStateID,
+};
+
+pub mod dfa;
+mod error;
+mod id;
+pub mod regex;
+mod search;
diff --git a/regex-automata/src/hybrid/regex.rs b/regex-automata/src/hybrid/regex.rs
new file mode 100644
index 0000000000..75667daf91
--- /dev/null
+++ b/regex-automata/src/hybrid/regex.rs
@@ -0,0 +1,895 @@
+/*!
+A lazy DFA backed `Regex`.
+
+This module provides a [`Regex`] backed by a lazy DFA. A `Regex` implements
+convenience routines you might have come to expect, such as finding a match
+and iterating over all non-overlapping matches. This `Regex` type is limited
+in its capabilities to what a lazy DFA can provide. Therefore, APIs involving
+capturing groups, for example, are not provided.
+
+Internally, a `Regex` is composed of two DFAs. One is a "forward" DFA that
+finds the end offset of a match, where as the other is a "reverse" DFA that
+find the start offset of a match.
+
+See the [parent module](crate::hybrid) for examples.
+*/
+
+use crate::{
+    hybrid::{
+        dfa::{self, DFA},
+        error::BuildError,
+    },
+    nfa::thompson,
+    util::{
+        iter,
+        search::{Anchored, Input, Match, MatchError, MatchKind},
+    },
+};
+
+/// A regular expression that uses hybrid NFA/DFAs (also called "lazy DFAs")
+/// for searching.
+///
+/// A regular expression is comprised of two lazy DFAs, a "forward" DFA and a
+/// "reverse" DFA. The forward DFA is responsible for detecting the end of
+/// a match while the reverse DFA is responsible for detecting the start
+/// of a match. Thus, in order to find the bounds of any given match, a
+/// forward search must first be run followed by a reverse search. A match
+/// found by the forward DFA guarantees that the reverse DFA will also find
+/// a match.
+///
+/// # Fallibility
+///
+/// Most of the search routines defined on this type will _panic_ when the
+/// underlying search fails. This might be because the DFA gave up because it
+/// saw a quit byte, whether configured explicitly or via heuristic Unicode
+/// word boundary support, although neither are enabled by default. It might
+/// also fail if the underlying DFA determines it isn't making effective use of
+/// the cache (which also never happens by default). Or it might fail because
+/// an invalid `Input` configuration is given, for example, with an unsupported
+/// [`Anchored`] mode.
+///
+/// If you need to handle these error cases instead of allowing them to trigger
+/// a panic, then the lower level [`Regex::try_search`] provides a fallible API
+/// that never panics.
+///
+/// # Example
+///
+/// This example shows how to cause a search to terminate if it sees a
+/// `\n` byte, and handle the error returned. This could be useful if, for
+/// example, you wanted to prevent a user supplied pattern from matching
+/// across a line boundary.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{hybrid::{dfa, regex::Regex}, Input, MatchError};
+///
+/// let re = Regex::builder()
+///     .dfa(dfa::Config::new().quit(b'\n', true))
+///     .build(r"foo\p{any}+bar")?;
+/// let mut cache = re.create_cache();
+///
+/// let input = Input::new("foo\nbar");
+/// // Normally this would produce a match, since \p{any} contains '\n'.
+/// // But since we instructed the automaton to enter a quit state if a
+/// // '\n' is observed, this produces a match error instead.
+/// let expected = MatchError::quit(b'\n', 3);
+/// let got = re.try_search(&mut cache, &input).unwrap_err();
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Debug)]
+pub struct Regex {
+    /// The forward lazy DFA. This can only find the end of a match.
+    forward: DFA,
+    /// The reverse lazy DFA. This can only find the start of a match.
+    ///
+    /// This is built with 'all' match semantics (instead of leftmost-first)
+    /// so that it always finds the longest possible match (which corresponds
+    /// to the leftmost starting position). It is also compiled as an anchored
+    /// matcher and has 'starts_for_each_pattern' enabled. Including starting
+    /// states for each pattern is necessary to ensure that we only look for
+    /// matches of a pattern that matched in the forward direction. Otherwise,
+    /// we might wind up finding the "leftmost" starting position of a totally
+    /// different pattern!
+    reverse: DFA,
+}
+
+/// Convenience routines for regex and cache construction.
+impl Regex {
+    /// Parse the given regular expression using the default configuration and
+    /// return the corresponding regex.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::regex::Regex, Match};
+    ///
+    /// let re = Regex::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 3..14)),
+    ///     re.find(&mut cache, "zzzfoo12345barzzz"),
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<Regex, BuildError> {
+        Regex::builder().build(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "multi regex."
+    /// This similarly uses the default regex configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::regex::Regex, Match};
+    ///
+    /// let re = Regex::new_many(&["[a-z]+", "[0-9]+"])?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let mut it = re.find_iter(&mut cache, "abc 1 foo 4567 0 quux");
+    /// assert_eq!(Some(Match::must(0, 0..3)), it.next());
+    /// assert_eq!(Some(Match::must(1, 4..5)), it.next());
+    /// assert_eq!(Some(Match::must(0, 6..9)), it.next());
+    /// assert_eq!(Some(Match::must(1, 10..14)), it.next());
+    /// assert_eq!(Some(Match::must(1, 15..16)), it.next());
+    /// assert_eq!(Some(Match::must(0, 17..21)), it.next());
+    /// assert_eq!(None, it.next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        Regex::builder().build_many(patterns)
+    }
+
+    /// Return a builder for configuring the construction of a `Regex`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode
+    /// everywhere.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     hybrid::regex::Regex, nfa::thompson, util::syntax, Match,
+    /// };
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+    /// let expected = Some(Match::must(0, 1..9));
+    /// let got = re.find(&mut cache, haystack);
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    /// Create a new cache for this `Regex`.
+    ///
+    /// The cache returned should only be used for searches for this
+    /// `Regex`. If you want to reuse the cache for another `Regex`, then
+    /// you must call [`Cache::reset`] with that `Regex` (or, equivalently,
+    /// [`Regex::reset_cache`]).
+    pub fn create_cache(&self) -> Cache {
+        Cache::new(self)
+    }
+
+    /// Reset the given cache such that it can be used for searching with the
+    /// this `Regex` (and only this `Regex`).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `Regex`.
+    ///
+    /// Resetting a cache sets its "clear count" to 0. This is relevant if the
+    /// `Regex` has been configured to "give up" after it has cleared the cache
+    /// a certain number of times.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different `Regex`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::regex::Regex, Match};
+    ///
+    /// let re1 = Regex::new(r"\w")?;
+    /// let re2 = Regex::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     re1.find(&mut cache, "Δ"),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the Regex we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// re2.reset_cache(&mut cache);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     re2.find(&mut cache, "☃"),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset_cache(&self, cache: &mut Cache) {
+        self.forward().reset_cache(&mut cache.forward);
+        self.reverse().reset_cache(&mut cache.reverse);
+    }
+}
+
+/// Standard infallible search routines for finding and iterating over matches.
+impl Regex {
+    /// Returns true if and only if this regex matches the given haystack.
+    ///
+    /// This routine may short circuit if it knows that scanning future input
+    /// will never lead to a different result. In particular, if the underlying
+    /// DFA enters a match state or a dead state, then this routine will return
+    /// `true` or `false`, respectively, without inspecting any future input.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`Regex::try_search`] if you want to handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::hybrid::regex::Regex;
+    ///
+    /// let re = Regex::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.is_match(&mut cache, "foo12345bar"));
+    /// assert!(!re.is_match(&mut cache, "foobar"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> bool {
+        // Not only can we do an "earliest" search, but we can avoid doing a
+        // reverse scan too.
+        self.forward()
+            .try_search_fwd(&mut cache.forward, &input.into().earliest(true))
+            .unwrap()
+            .is_some()
+    }
+
+    /// Returns the start and end offset of the leftmost match. If no match
+    /// exists, then `None` is returned.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// Use [`Regex::try_search`] if you want to handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Match, hybrid::regex::Regex};
+    ///
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 3..11)),
+    ///     re.find(&mut cache, "zzzfoo12345zzz"),
+    /// );
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the default leftmost-first match semantics demand that we find the
+    /// // earliest match that prefers earlier parts of the pattern over latter
+    /// // parts.
+    /// let re = Regex::new("abc|a")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(Some(Match::must(0, 0..3)), re.find(&mut cache, "abc"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Option<Match> {
+        self.try_search(cache, &input.into()).unwrap()
+    }
+
+    /// Returns an iterator over all non-overlapping leftmost matches in the
+    /// given bytes. If no match exists, then the iterator yields no elements.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search panics, callers cannot know whether a match exists or
+    /// not.
+    ///
+    /// The above conditions also apply to the iterator returned as well. For
+    /// example, if the lazy DFA gives up or quits during a search using this
+    /// method, then a panic will occur during iteration.
+    ///
+    /// Use [`Regex::try_search`] with [`util::iter::Searcher`](iter::Searcher)
+    /// if you want to handle these error conditions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{hybrid::regex::Regex, Match};
+    ///
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let text = "foo1 foo12 foo123";
+    /// let matches: Vec<Match> = re.find_iter(&mut cache, text).collect();
+    /// assert_eq!(matches, vec![
+    ///     Match::must(0, 0..4),
+    ///     Match::must(0, 5..10),
+    ///     Match::must(0, 11..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'c, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        cache: &'c mut Cache,
+        input: I,
+    ) -> FindMatches<'r, 'c, 'h> {
+        let it = iter::Searcher::new(input.into());
+        FindMatches { re: self, cache, it }
+    }
+}
+
+/// Lower level "search" primitives that accept a `&Input` for cheap reuse
+/// and return an error if one occurs instead of panicking.
+impl Regex {
+    /// Returns the start and end offset of the leftmost match. If no match
+    /// exists, then `None` is returned.
+    ///
+    /// This is like [`Regex::find`] but with two differences:
+    ///
+    /// 1. It is not generic over `Into<Input>` and instead accepts a
+    /// `&Input`. This permits reusing the same `Input` for multiple searches
+    /// without needing to create a new one. This _may_ help with latency.
+    /// 2. It returns an error if the search could not complete where as
+    /// [`Regex::find`] will panic.
+    ///
+    /// # Errors
+    ///
+    /// This routine errors if the search could not complete. This can occur
+    /// in a number of circumstances:
+    ///
+    /// * The configuration of the lazy DFA may permit it to "quit" the search.
+    /// For example, setting quit bytes or enabling heuristic support for
+    /// Unicode word boundaries. The default configuration does not enable any
+    /// option that could result in the lazy DFA quitting.
+    /// * The configuration of the lazy DFA may also permit it to "give up"
+    /// on a search if it makes ineffective use of its transition table
+    /// cache. The default configuration does not enable this by default,
+    /// although it is typically a good idea to.
+    /// * When the provided `Input` configuration is not supported. For
+    /// example, by providing an unsupported anchor mode.
+    ///
+    /// When a search returns an error, callers cannot know whether a match
+    /// exists or not.
+    #[inline]
+    pub fn try_search(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<Match>, MatchError> {
+        let (fcache, rcache) = (&mut cache.forward, &mut cache.reverse);
+        let end = match self.forward().try_search_fwd(fcache, input)? {
+            None => return Ok(None),
+            Some(end) => end,
+        };
+        // This special cases an empty match at the beginning of the search. If
+        // our end matches our start, then since a reverse DFA can't match past
+        // the start, it must follow that our starting position is also our end
+        // position. So short circuit and skip the reverse search.
+        if input.start() == end.offset() {
+            return Ok(Some(Match::new(
+                end.pattern(),
+                end.offset()..end.offset(),
+            )));
+        }
+        // We can also skip the reverse search if we know our search was
+        // anchored. This occurs either when the input config is anchored or
+        // when we know the regex itself is anchored. In this case, we know the
+        // start of the match, if one is found, must be the start of the
+        // search.
+        if self.is_anchored(input) {
+            return Ok(Some(Match::new(
+                end.pattern(),
+                input.start()..end.offset(),
+            )));
+        }
+        // N.B. I have tentatively convinced myself that it isn't necessary
+        // to specify the specific pattern for the reverse search since the
+        // reverse search will always find the same pattern to match as the
+        // forward search. But I lack a rigorous proof. Why not just provide
+        // the pattern anyway? Well, if it is needed, then leaving it out
+        // gives us a chance to find a witness. (Also, if we don't need to
+        // specify the pattern, then we don't need to build the reverse DFA
+        // with 'starts_for_each_pattern' enabled. It doesn't matter too much
+        // for the lazy DFA, but does make the overall DFA bigger.)
+        //
+        // We also need to be careful to disable 'earliest' for the reverse
+        // search, since it could be enabled for the forward search. In the
+        // reverse case, to satisfy "leftmost" criteria, we need to match as
+        // much as we can. We also need to be careful to make the search
+        // anchored. We don't want the reverse search to report any matches
+        // other than the one beginning at the end of our forward search.
+        let revsearch = input
+            .clone()
+            .span(input.start()..end.offset())
+            .anchored(Anchored::Yes)
+            .earliest(false);
+        let start = self
+            .reverse()
+            .try_search_rev(rcache, &revsearch)?
+            .expect("reverse search must match if forward search does");
+        debug_assert_eq!(
+            start.pattern(),
+            end.pattern(),
+            "forward and reverse search must match same pattern",
+        );
+        debug_assert!(start.offset() <= end.offset());
+        Ok(Some(Match::new(end.pattern(), start.offset()..end.offset())))
+    }
+
+    /// Returns true if either the given input specifies an anchored search
+    /// or if the underlying NFA is always anchored.
+    fn is_anchored(&self, input: &Input<'_>) -> bool {
+        match input.get_anchored() {
+            Anchored::No => {
+                self.forward().get_nfa().is_always_start_anchored()
+            }
+            Anchored::Yes | Anchored::Pattern(_) => true,
+        }
+    }
+}
+
+/// Non-search APIs for querying information about the regex and setting a
+/// prefilter.
+impl Regex {
+    /// Return the underlying lazy DFA responsible for forward matching.
+    ///
+    /// This is useful for accessing the underlying lazy DFA and using it
+    /// directly if the situation calls for it.
+    pub fn forward(&self) -> &DFA {
+        &self.forward
+    }
+
+    /// Return the underlying lazy DFA responsible for reverse matching.
+    ///
+    /// This is useful for accessing the underlying lazy DFA and using it
+    /// directly if the situation calls for it.
+    pub fn reverse(&self) -> &DFA {
+        &self.reverse
+    }
+
+    /// Returns the total number of patterns matched by this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::hybrid::regex::Regex;
+    ///
+    /// let re = Regex::new_many(&[r"[a-z]+", r"[0-9]+", r"\w+"])?;
+    /// assert_eq!(3, re.pattern_len());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        assert_eq!(self.forward().pattern_len(), self.reverse().pattern_len());
+        self.forward().pattern_len()
+    }
+}
+
+/// An iterator over all non-overlapping matches for an infallible search.
+///
+/// The iterator yields a [`Match`] value until no more matches could be found.
+/// If the underlying regex engine returns an error, then a panic occurs.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the regex object.
+/// * `'h` represents the lifetime of the haystack being searched.
+/// * `'c` represents the lifetime of the regex cache.
+///
+/// This iterator can be created with the [`Regex::find_iter`] method.
+#[derive(Debug)]
+pub struct FindMatches<'r, 'c, 'h> {
+    re: &'r Regex,
+    cache: &'c mut Cache,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'c, 'h> Iterator for FindMatches<'r, 'c, 'h> {
+    type Item = Match;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match> {
+        let FindMatches { re, ref mut cache, ref mut it } = *self;
+        it.advance(|input| re.try_search(cache, input))
+    }
+}
+
+/// A cache represents a partially computed forward and reverse DFA.
+///
+/// A cache is the key component that differentiates a classical DFA and a
+/// hybrid NFA/DFA (also called a "lazy DFA"). Where a classical DFA builds a
+/// complete transition table that can handle all possible inputs, a hybrid
+/// NFA/DFA starts with an empty transition table and builds only the parts
+/// required during search. The parts that are built are stored in a cache. For
+/// this reason, a cache is a required parameter for nearly every operation on
+/// a [`Regex`].
+///
+/// Caches can be created from their corresponding `Regex` via
+/// [`Regex::create_cache`]. A cache can only be used with either the `Regex`
+/// that created it, or the `Regex` that was most recently used to reset it
+/// with [`Cache::reset`]. Using a cache with any other `Regex` may result in
+/// panics or incorrect results.
+#[derive(Debug, Clone)]
+pub struct Cache {
+    forward: dfa::Cache,
+    reverse: dfa::Cache,
+}
+
+impl Cache {
+    /// Create a new cache for the given `Regex`.
+    ///
+    /// The cache returned should only be used for searches for the given
+    /// `Regex`. If you want to reuse the cache for another `Regex`, then you
+    /// must call [`Cache::reset`] with that `Regex`.
+    pub fn new(re: &Regex) -> Cache {
+        let forward = dfa::Cache::new(re.forward());
+        let reverse = dfa::Cache::new(re.reverse());
+        Cache { forward, reverse }
+    }
+
+    /// Reset this cache such that it can be used for searching with the given
+    /// `Regex` (and only that `Regex`).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `Regex`.
+    ///
+    /// Resetting a cache sets its "clear count" to 0. This is relevant if the
+    /// `Regex` has been configured to "give up" after it has cleared the cache
+    /// a certain number of times.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different `Regex`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{hybrid::regex::Regex, Match};
+    ///
+    /// let re1 = Regex::new(r"\w")?;
+    /// let re2 = Regex::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     re1.find(&mut cache, "Δ"),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the Regex we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// cache.reset(&re2);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     re2.find(&mut cache, "☃"),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, re: &Regex) {
+        self.forward.reset(re.forward());
+        self.reverse.reset(re.reverse());
+    }
+
+    /// Return a reference to the forward cache.
+    pub fn forward(&mut self) -> &dfa::Cache {
+        &self.forward
+    }
+
+    /// Return a reference to the reverse cache.
+    pub fn reverse(&mut self) -> &dfa::Cache {
+        &self.reverse
+    }
+
+    /// Return a mutable reference to the forward cache.
+    ///
+    /// If you need mutable references to both the forward and reverse caches,
+    /// then use [`Cache::as_parts_mut`].
+    pub fn forward_mut(&mut self) -> &mut dfa::Cache {
+        &mut self.forward
+    }
+
+    /// Return a mutable reference to the reverse cache.
+    ///
+    /// If you need mutable references to both the forward and reverse caches,
+    /// then use [`Cache::as_parts_mut`].
+    pub fn reverse_mut(&mut self) -> &mut dfa::Cache {
+        &mut self.reverse
+    }
+
+    /// Return references to the forward and reverse caches, respectively.
+    pub fn as_parts(&self) -> (&dfa::Cache, &dfa::Cache) {
+        (&self.forward, &self.reverse)
+    }
+
+    /// Return mutable references to the forward and reverse caches,
+    /// respectively.
+    pub fn as_parts_mut(&mut self) -> (&mut dfa::Cache, &mut dfa::Cache) {
+        (&mut self.forward, &mut self.reverse)
+    }
+
+    /// Returns the heap memory usage, in bytes, as a sum of the forward and
+    /// reverse lazy DFA caches.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        self.forward.memory_usage() + self.reverse.memory_usage()
+    }
+}
+
+/// A builder for a regex based on a hybrid NFA/DFA.
+///
+/// This builder permits configuring options for the syntax of a pattern, the
+/// NFA construction, the lazy DFA construction and finally the regex searching
+/// itself. This builder is different from a general purpose regex builder
+/// in that it permits fine grain configuration of the construction process.
+/// The trade off for this is complexity, and the possibility of setting a
+/// configuration that might not make sense. For example, there are two
+/// different UTF-8 modes:
+///
+/// * [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) controls
+/// whether the pattern itself can contain sub-expressions that match invalid
+/// UTF-8.
+/// * [`thompson::Config::utf8`] controls how the regex iterators themselves
+/// advance the starting position of the next search when a match with zero
+/// length is found.
+///
+/// Generally speaking, callers will want to either enable all of these or
+/// disable all of these.
+///
+/// Internally, building a regex requires building two hybrid NFA/DFAs,
+/// where one is responsible for finding the end of a match and the other is
+/// responsible for finding the start of a match. If you only need to detect
+/// whether something matched, or only the end of a match, then you should use
+/// a [`dfa::Builder`] to construct a single hybrid NFA/DFA, which is cheaper
+/// than building two of them.
+///
+/// # Example
+///
+/// This example shows how to disable UTF-8 mode in the syntax and the regex
+/// itself. This is generally what you want for matching on arbitrary bytes.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     hybrid::regex::Regex, nfa::thompson, util::syntax, Match,
+/// };
+///
+/// let re = Regex::builder()
+///     .syntax(syntax::Config::new().utf8(false))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .build(r"foo(?-u:[^b])ar.*")?;
+/// let mut cache = re.create_cache();
+///
+/// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+/// let expected = Some(Match::must(0, 1..9));
+/// let got = re.find(&mut cache, haystack);
+/// assert_eq!(expected, got);
+/// // Notice that `(?-u:[^b])` matches invalid UTF-8,
+/// // but the subsequent `.*` does not! Disabling UTF-8
+/// // on the syntax permits this.
+/// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap().range()]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    dfa: dfa::Builder,
+}
+
+impl Builder {
+    /// Create a new regex builder with the default configuration.
+    pub fn new() -> Builder {
+        Builder { dfa: DFA::builder() }
+    }
+
+    /// Build a regex from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(&self, pattern: &str) -> Result<Regex, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a regex from the given patterns.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        let forward = self.dfa.build_many(patterns)?;
+        let reverse = self
+            .dfa
+            .clone()
+            .configure(
+                DFA::config()
+                    .prefilter(None)
+                    .specialize_start_states(false)
+                    .match_kind(MatchKind::All),
+            )
+            .thompson(thompson::Config::new().reverse(true))
+            .build_many(patterns)?;
+        Ok(self.build_from_dfas(forward, reverse))
+    }
+
+    /// Build a regex from its component forward and reverse hybrid NFA/DFAs.
+    ///
+    /// This is useful when you've built a forward and reverse lazy DFA
+    /// separately, and want to combine them into a single regex. Once build,
+    /// the individual DFAs given can still be accessed via [`Regex::forward`]
+    /// and [`Regex::reverse`].
+    ///
+    /// It is important that the reverse lazy DFA be compiled under the
+    /// following conditions:
+    ///
+    /// * It should use [`MatchKind::All`] semantics.
+    /// * It should match in reverse.
+    /// * Otherwise, its configuration should match the forward DFA.
+    ///
+    /// If these conditions aren't satisfied, then the behavior of searches is
+    /// unspecified.
+    ///
+    /// Note that when using this constructor, no configuration is applied.
+    /// Since this routine provides the DFAs to the builder, there is no
+    /// opportunity to apply other configuration options.
+    ///
+    /// # Example
+    ///
+    /// This shows how to build individual lazy forward and reverse DFAs, and
+    /// then combine them into a single `Regex`.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::{dfa::DFA, regex::Regex},
+    ///     nfa::thompson,
+    ///     MatchKind,
+    /// };
+    ///
+    /// let fwd = DFA::new(r"foo[0-9]+")?;
+    /// let rev = DFA::builder()
+    ///     .configure(DFA::config().match_kind(MatchKind::All))
+    ///     .thompson(thompson::Config::new().reverse(true))
+    ///     .build(r"foo[0-9]+")?;
+    ///
+    /// let re = Regex::builder().build_from_dfas(fwd, rev);
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(true, re.is_match(&mut cache, "foo123"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_dfas(&self, forward: DFA, reverse: DFA) -> Regex {
+        Regex { forward, reverse }
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.dfa.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](thompson::Config).
+    ///
+    /// This permits setting things like whether additional time should be
+    /// spent shrinking the size of the NFA.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.dfa.thompson(config);
+        self
+    }
+
+    /// Set the lazy DFA compilation configuration for this builder using
+    /// [`dfa::Config`](dfa::Config).
+    ///
+    /// This permits setting things like whether Unicode word boundaries should
+    /// be heuristically supported or settings how the behavior of the cache.
+    pub fn dfa(&mut self, config: dfa::Config) -> &mut Builder {
+        self.dfa.configure(config);
+        self
+    }
+}
+
+impl Default for Builder {
+    fn default() -> Builder {
+        Builder::new()
+    }
+}
diff --git a/regex-automata/src/hybrid/search.rs b/regex-automata/src/hybrid/search.rs
new file mode 100644
index 0000000000..0d0bb8af5b
--- /dev/null
+++ b/regex-automata/src/hybrid/search.rs
@@ -0,0 +1,802 @@
+use crate::{
+    hybrid::{
+        dfa::{Cache, OverlappingState, DFA},
+        id::LazyStateID,
+    },
+    util::{
+        prefilter::Prefilter,
+        search::{HalfMatch, Input, MatchError, Span},
+    },
+};
+
+#[inline(never)]
+pub(crate) fn find_fwd(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+) -> Result<Option<HalfMatch>, MatchError> {
+    if input.is_done() {
+        return Ok(None);
+    }
+    let pre = if input.get_anchored().is_anchored() {
+        None
+    } else {
+        dfa.get_config().get_prefilter()
+    };
+    // So what we do here is specialize four different versions of 'find_fwd':
+    // one for each of the combinations for 'has prefilter' and 'is earliest
+    // search'. The reason for doing this is that both of these things require
+    // branches and special handling in some code that can be very hot,
+    // and shaving off as much as we can when we don't need it tends to be
+    // beneficial in ad hoc benchmarks. To see these differences, you often
+    // need a query with a high match count. In other words, specializing these
+    // four routines *tends* to help latency more than throughput.
+    if pre.is_some() {
+        if input.get_earliest() {
+            find_fwd_imp(dfa, cache, input, pre, true)
+        } else {
+            find_fwd_imp(dfa, cache, input, pre, false)
+        }
+    } else {
+        if input.get_earliest() {
+            find_fwd_imp(dfa, cache, input, None, true)
+        } else {
+            find_fwd_imp(dfa, cache, input, None, false)
+        }
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_fwd_imp(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    pre: Option<&'_ Prefilter>,
+    earliest: bool,
+) -> Result<Option<HalfMatch>, MatchError> {
+    // See 'prefilter_restart' docs for explanation.
+    let universal_start = dfa.get_nfa().look_set_prefix_any().is_empty();
+    let mut mat = None;
+    let mut sid = init_fwd(dfa, cache, input)?;
+    let mut at = input.start();
+    // This could just be a closure, but then I think it would be unsound
+    // because it would need to be safe to invoke. This way, the lack of safety
+    // is clearer in the code below.
+    macro_rules! next_unchecked {
+        ($sid:expr, $at:expr) => {{
+            let byte = *input.haystack().get_unchecked($at);
+            dfa.next_state_untagged_unchecked(cache, $sid, byte)
+        }};
+    }
+
+    if let Some(ref pre) = pre {
+        let span = Span::from(at..input.end());
+        match pre.find(input.haystack(), span) {
+            None => return Ok(mat),
+            Some(ref span) => {
+                at = span.start;
+                if !universal_start {
+                    sid = prefilter_restart(dfa, cache, &input, at)?;
+                }
+            }
+        }
+    }
+    cache.search_start(at);
+    while at < input.end() {
+        if sid.is_tagged() {
+            cache.search_update(at);
+            sid = dfa
+                .next_state(cache, sid, input.haystack()[at])
+                .map_err(|_| gave_up(at))?;
+        } else {
+            // SAFETY: There are two safety invariants we need to uphold
+            // here in the loops below: that 'sid' and 'prev_sid' are valid
+            // state IDs for this DFA, and that 'at' is a valid index into
+            // 'haystack'. For the former, we rely on the invariant that
+            // next_state* and start_state_forward always returns a valid state
+            // ID (given a valid state ID in the former case), and that we are
+            // only at this place in the code if 'sid' is untagged. Moreover,
+            // every call to next_state_untagged_unchecked below is guarded by
+            // a check that sid is untagged. For the latter safety invariant,
+            // we always guard unchecked access with a check that 'at' is less
+            // than 'end', where 'end <= haystack.len()'. In the unrolled loop
+            // below, we ensure that 'at' is always in bounds.
+            //
+            // PERF: For justification of omitting bounds checks, it gives us a
+            // ~10% bump in search time. This was used for a benchmark:
+            //
+            //     regex-cli find hybrid dfa @bigfile '(?m)^.+$' -UBb
+            //
+            // PERF: For justification for the loop unrolling, we use a few
+            // different tests:
+            //
+            //     regex-cli find hybrid dfa @$bigfile '\w{50}' -UBb
+            //     regex-cli find hybrid dfa @$bigfile '(?m)^.+$' -UBb
+            //     regex-cli find hybrid dfa @$bigfile 'ZQZQZQZQ' -UBb
+            //
+            // And there are three different configurations:
+            //
+            //     nounroll: this entire 'else' block vanishes and we just
+            //               always use 'dfa.next_state(..)'.
+            //      unroll1: just the outer loop below
+            //      unroll2: just the inner loop below
+            //      unroll3: both the outer and inner loops below
+            //
+            // This results in a matrix of timings for each of the above
+            // regexes with each of the above unrolling configurations:
+            //
+            //              '\w{50}'   '(?m)^.+$'   'ZQZQZQZQ'
+            //   nounroll   1.51s      2.34s        1.51s
+            //    unroll1   1.53s      2.32s        1.56s
+            //    unroll2   2.22s      1.50s        0.61s
+            //    unroll3   1.67s      1.45s        0.61s
+            //
+            // Ideally we'd be able to find a configuration that yields the
+            // best time for all regexes, but alas we settle for unroll3 that
+            // gives us *almost* the best for '\w{50}' and the best for the
+            // other two regexes.
+            //
+            // So what exactly is going on here? The first unrolling (grouping
+            // together runs of untagged transitions) specifically targets
+            // our choice of representation. The second unrolling (grouping
+            // together runs of self-transitions) specifically targets a common
+            // DFA topology. Let's dig in a little bit by looking at our
+            // regexes:
+            //
+            // '\w{50}': This regex spends a lot of time outside of the DFA's
+            // start state matching some part of the '\w' repetition. This
+            // means that it's a bit of a worst case for loop unrolling that
+            // targets self-transitions since the self-transitions in '\w{50}'
+            // are not particularly active for this haystack. However, the
+            // first unrolling (grouping together untagged transitions)
+            // does apply quite well here since very few transitions hit
+            // match/dead/quit/unknown states. It is however worth mentioning
+            // that if start states are configured to be tagged (which you
+            // typically want to do if you have a prefilter), then this regex
+            // actually slows way down because it is constantly ping-ponging
+            // out of the unrolled loop and into the handling of a tagged start
+            // state below. But when start states aren't tagged, the unrolled
+            // loop stays hot. (This is why it's imperative that start state
+            // tagging be disabled when there isn't a prefilter!)
+            //
+            // '(?m)^.+$': There are two important aspects of this regex: 1)
+            // on this haystack, its match count is very high, much higher
+            // than the other two regex and 2) it spends the vast majority
+            // of its time matching '.+'. Since Unicode mode is disabled,
+            // this corresponds to repeatedly following self transitions for
+            // the vast majority of the input. This does benefit from the
+            // untagged unrolling since most of the transitions will be to
+            // untagged states, but the untagged unrolling does more work than
+            // what is actually required. Namely, it has to keep track of the
+            // previous and next state IDs, which I guess requires a bit more
+            // shuffling. This is supported by the fact that nounroll+unroll1
+            // are both slower than unroll2+unroll3, where the latter has a
+            // loop unrolling that specifically targets self-transitions.
+            //
+            // 'ZQZQZQZQ': This one is very similar to '(?m)^.+$' because it
+            // spends the vast majority of its time in self-transitions for
+            // the (implicit) unanchored prefix. The main difference with
+            // '(?m)^.+$' is that it has a much lower match count. So there
+            // isn't much time spent in the overhead of reporting matches. This
+            // is the primary explainer in the perf difference here. We include
+            // this regex and the former to make sure we have comparison points
+            // with high and low match counts.
+            //
+            // NOTE: I used 'OpenSubtitles2018.raw.sample.en' for 'bigfile'.
+            //
+            // NOTE: In a follow-up, it turns out that the "inner" loop
+            // mentioned above was a pretty big pessimization in some other
+            // cases. Namely, it resulted in too much ping-ponging into and out
+            // of the loop, which resulted in nearly ~2x regressions in search
+            // time when compared to the originaly lazy DFA in the regex crate.
+            // So I've removed the second loop unrolling that targets the
+            // self-transition case.
+            let mut prev_sid = sid;
+            while at < input.end() {
+                prev_sid = unsafe { next_unchecked!(sid, at) };
+                if prev_sid.is_tagged() || at + 3 >= input.end() {
+                    core::mem::swap(&mut prev_sid, &mut sid);
+                    break;
+                }
+                at += 1;
+
+                sid = unsafe { next_unchecked!(prev_sid, at) };
+                if sid.is_tagged() {
+                    break;
+                }
+                at += 1;
+
+                prev_sid = unsafe { next_unchecked!(sid, at) };
+                if prev_sid.is_tagged() {
+                    core::mem::swap(&mut prev_sid, &mut sid);
+                    break;
+                }
+                at += 1;
+
+                sid = unsafe { next_unchecked!(prev_sid, at) };
+                if sid.is_tagged() {
+                    break;
+                }
+                at += 1;
+            }
+            // If we quit out of the code above with an unknown state ID at
+            // any point, then we need to re-compute that transition using
+            // 'next_state', which will do NFA powerset construction for us.
+            if sid.is_unknown() {
+                cache.search_update(at);
+                sid = dfa
+                    .next_state(cache, prev_sid, input.haystack()[at])
+                    .map_err(|_| gave_up(at))?;
+            }
+        }
+        if sid.is_tagged() {
+            if sid.is_start() {
+                if let Some(ref pre) = pre {
+                    let span = Span::from(at..input.end());
+                    match pre.find(input.haystack(), span) {
+                        None => {
+                            cache.search_finish(span.end);
+                            return Ok(mat);
+                        }
+                        Some(ref span) => {
+                            // We want to skip any update to 'at' below
+                            // at the end of this iteration and just
+                            // jump immediately back to the next state
+                            // transition at the leading position of the
+                            // candidate match.
+                            //
+                            // ... but only if we actually made progress
+                            // with our prefilter, otherwise if the start
+                            // state has a self-loop, we can get stuck.
+                            if span.start > at {
+                                at = span.start;
+                                if !universal_start {
+                                    sid = prefilter_restart(
+                                        dfa, cache, &input, at,
+                                    )?;
+                                }
+                                continue;
+                            }
+                        }
+                    }
+                }
+            } else if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                // Since slice ranges are inclusive at the beginning and
+                // exclusive at the end, and since forward searches report
+                // the end, we can return 'at' as-is. This only works because
+                // matches are delayed by 1 byte. So by the time we observe a
+                // match, 'at' has already been set to 1 byte past the actual
+                // match location, which is precisely the exclusive ending
+                // bound of the match.
+                mat = Some(HalfMatch::new(pattern, at));
+                if earliest {
+                    cache.search_finish(at);
+                    return Ok(mat);
+                }
+            } else if sid.is_dead() {
+                cache.search_finish(at);
+                return Ok(mat);
+            } else if sid.is_quit() {
+                cache.search_finish(at);
+                return Err(MatchError::quit(input.haystack()[at], at));
+            } else {
+                debug_assert!(sid.is_unknown());
+                unreachable!("sid being unknown is a bug");
+            }
+        }
+        at += 1;
+    }
+    eoi_fwd(dfa, cache, input, &mut sid, &mut mat)?;
+    cache.search_finish(input.end());
+    Ok(mat)
+}
+
+#[inline(never)]
+pub(crate) fn find_rev(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+) -> Result<Option<HalfMatch>, MatchError> {
+    if input.is_done() {
+        return Ok(None);
+    }
+    if input.get_earliest() {
+        find_rev_imp(dfa, cache, input, true)
+    } else {
+        find_rev_imp(dfa, cache, input, false)
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_rev_imp(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    earliest: bool,
+) -> Result<Option<HalfMatch>, MatchError> {
+    let mut mat = None;
+    let mut sid = init_rev(dfa, cache, input)?;
+    // In reverse search, the loop below can't handle the case of searching an
+    // empty slice. Ideally we could write something congruent to the forward
+    // search, i.e., 'while at >= start', but 'start' might be 0. Since we use
+    // an unsigned offset, 'at >= 0' is trivially always true. We could avoid
+    // this extra case handling by using a signed offset, but Rust makes it
+    // annoying to do. So... We just handle the empty case separately.
+    if input.start() == input.end() {
+        eoi_rev(dfa, cache, input, &mut sid, &mut mat)?;
+        return Ok(mat);
+    }
+
+    let mut at = input.end() - 1;
+    macro_rules! next_unchecked {
+        ($sid:expr, $at:expr) => {{
+            let byte = *input.haystack().get_unchecked($at);
+            dfa.next_state_untagged_unchecked(cache, $sid, byte)
+        }};
+    }
+    cache.search_start(at);
+    loop {
+        if sid.is_tagged() {
+            cache.search_update(at);
+            sid = dfa
+                .next_state(cache, sid, input.haystack()[at])
+                .map_err(|_| gave_up(at))?;
+        } else {
+            // SAFETY: See comments in 'find_fwd' for a safety argument.
+            //
+            // PERF: The comments in 'find_fwd' also provide a justification
+            // from a performance perspective as to 1) why we elide bounds
+            // checks and 2) why we do a specialized version of unrolling
+            // below. The reverse search does have a slightly different
+            // consideration in that most reverse searches tend to be
+            // anchored and on shorter haystacks. However, this still makes a
+            // difference. Take this command for example:
+            //
+            //     regex-cli find hybrid regex @$bigfile '(?m)^.+$' -UBb
+            //
+            // (Notice that we use 'find hybrid regex', not 'find hybrid dfa'
+            // like in the justification for the forward direction. The 'regex'
+            // sub-command will find start-of-match and thus run the reverse
+            // direction.)
+            //
+            // Without unrolling below, the above command takes around 3.76s.
+            // But with the unrolling below, we get down to 2.55s. If we keep
+            // the unrolling but add in bounds checks, then we get 2.86s.
+            //
+            // NOTE: I used 'OpenSubtitles2018.raw.sample.en' for 'bigfile'.
+            let mut prev_sid = sid;
+            while at >= input.start() {
+                prev_sid = unsafe { next_unchecked!(sid, at) };
+                if prev_sid.is_tagged()
+                    || at <= input.start().saturating_add(3)
+                {
+                    core::mem::swap(&mut prev_sid, &mut sid);
+                    break;
+                }
+                at -= 1;
+
+                sid = unsafe { next_unchecked!(prev_sid, at) };
+                if sid.is_tagged() {
+                    break;
+                }
+                at -= 1;
+
+                prev_sid = unsafe { next_unchecked!(sid, at) };
+                if prev_sid.is_tagged() {
+                    core::mem::swap(&mut prev_sid, &mut sid);
+                    break;
+                }
+                at -= 1;
+
+                sid = unsafe { next_unchecked!(prev_sid, at) };
+                if sid.is_tagged() {
+                    break;
+                }
+                at -= 1;
+            }
+            // If we quit out of the code above with an unknown state ID at
+            // any point, then we need to re-compute that transition using
+            // 'next_state', which will do NFA powerset construction for us.
+            if sid.is_unknown() {
+                cache.search_update(at);
+                sid = dfa
+                    .next_state(cache, prev_sid, input.haystack()[at])
+                    .map_err(|_| gave_up(at))?;
+            }
+        }
+        if sid.is_tagged() {
+            if sid.is_start() {
+                // do nothing
+            } else if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                // Since reverse searches report the beginning of a match
+                // and the beginning is inclusive (not exclusive like the
+                // end of a match), we add 1 to make it inclusive.
+                mat = Some(HalfMatch::new(pattern, at + 1));
+                if earliest {
+                    cache.search_finish(at);
+                    return Ok(mat);
+                }
+            } else if sid.is_dead() {
+                cache.search_finish(at);
+                return Ok(mat);
+            } else if sid.is_quit() {
+                cache.search_finish(at);
+                return Err(MatchError::quit(input.haystack()[at], at));
+            } else {
+                debug_assert!(sid.is_unknown());
+                unreachable!("sid being unknown is a bug");
+            }
+        }
+        if at == input.start() {
+            break;
+        }
+        at -= 1;
+    }
+    cache.search_finish(input.start());
+    eoi_rev(dfa, cache, input, &mut sid, &mut mat)?;
+    Ok(mat)
+}
+
+#[inline(never)]
+pub(crate) fn find_overlapping_fwd(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    state.mat = None;
+    if input.is_done() {
+        return Ok(());
+    }
+    let pre = if input.get_anchored().is_anchored() {
+        None
+    } else {
+        dfa.get_config().get_prefilter()
+    };
+    if pre.is_some() {
+        find_overlapping_fwd_imp(dfa, cache, input, pre, state)
+    } else {
+        find_overlapping_fwd_imp(dfa, cache, input, None, state)
+    }
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn find_overlapping_fwd_imp(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    pre: Option<&'_ Prefilter>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    // See 'prefilter_restart' docs for explanation.
+    let universal_start = dfa.get_nfa().look_set_prefix_any().is_empty();
+    let mut sid = match state.id {
+        None => {
+            state.at = input.start();
+            init_fwd(dfa, cache, input)?
+        }
+        Some(sid) => {
+            if let Some(match_index) = state.next_match_index {
+                let match_len = dfa.match_len(cache, sid);
+                if match_index < match_len {
+                    state.next_match_index = Some(match_index + 1);
+                    let pattern = dfa.match_pattern(cache, sid, match_index);
+                    state.mat = Some(HalfMatch::new(pattern, state.at));
+                    return Ok(());
+                }
+            }
+            // Once we've reported all matches at a given position, we need to
+            // advance the search to the next position.
+            state.at += 1;
+            if state.at > input.end() {
+                return Ok(());
+            }
+            sid
+        }
+    };
+
+    // NOTE: We don't optimize the crap out of this routine primarily because
+    // it seems like most overlapping searches will have higher match counts,
+    // and thus, throughput is perhaps not as important. But if you have a use
+    // case for something faster, feel free to file an issue.
+    cache.search_start(state.at);
+    while state.at < input.end() {
+        sid = dfa
+            .next_state(cache, sid, input.haystack()[state.at])
+            .map_err(|_| gave_up(state.at))?;
+        if sid.is_tagged() {
+            state.id = Some(sid);
+            if sid.is_start() {
+                if let Some(ref pre) = pre {
+                    let span = Span::from(state.at..input.end());
+                    match pre.find(input.haystack(), span) {
+                        None => return Ok(()),
+                        Some(ref span) => {
+                            if span.start > state.at {
+                                state.at = span.start;
+                                if !universal_start {
+                                    sid = prefilter_restart(
+                                        dfa, cache, &input, state.at,
+                                    )?;
+                                }
+                                continue;
+                            }
+                        }
+                    }
+                }
+            } else if sid.is_match() {
+                state.next_match_index = Some(1);
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                state.mat = Some(HalfMatch::new(pattern, state.at));
+                cache.search_finish(state.at);
+                return Ok(());
+            } else if sid.is_dead() {
+                cache.search_finish(state.at);
+                return Ok(());
+            } else if sid.is_quit() {
+                cache.search_finish(state.at);
+                return Err(MatchError::quit(
+                    input.haystack()[state.at],
+                    state.at,
+                ));
+            } else {
+                debug_assert!(sid.is_unknown());
+                unreachable!("sid being unknown is a bug");
+            }
+        }
+        state.at += 1;
+        cache.search_update(state.at);
+    }
+
+    let result = eoi_fwd(dfa, cache, input, &mut sid, &mut state.mat);
+    state.id = Some(sid);
+    if state.mat.is_some() {
+        // '1' is always correct here since if we get to this point, this
+        // always corresponds to the first (index '0') match discovered at
+        // this position. So the next match to report at this position (if
+        // it exists) is at index '1'.
+        state.next_match_index = Some(1);
+    }
+    cache.search_finish(input.end());
+    result
+}
+
+#[inline(never)]
+pub(crate) fn find_overlapping_rev(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    state: &mut OverlappingState,
+) -> Result<(), MatchError> {
+    state.mat = None;
+    if input.is_done() {
+        return Ok(());
+    }
+    let mut sid = match state.id {
+        None => {
+            let sid = init_rev(dfa, cache, input)?;
+            state.id = Some(sid);
+            if input.start() == input.end() {
+                state.rev_eoi = true;
+            } else {
+                state.at = input.end() - 1;
+            }
+            sid
+        }
+        Some(sid) => {
+            if let Some(match_index) = state.next_match_index {
+                let match_len = dfa.match_len(cache, sid);
+                if match_index < match_len {
+                    state.next_match_index = Some(match_index + 1);
+                    let pattern = dfa.match_pattern(cache, sid, match_index);
+                    state.mat = Some(HalfMatch::new(pattern, state.at));
+                    return Ok(());
+                }
+            }
+            // Once we've reported all matches at a given position, we need
+            // to advance the search to the next position. However, if we've
+            // already followed the EOI transition, then we know we're done
+            // with the search and there cannot be any more matches to report.
+            if state.rev_eoi {
+                return Ok(());
+            } else if state.at == input.start() {
+                // At this point, we should follow the EOI transition. This
+                // will cause us the skip the main loop below and fall through
+                // to the final 'eoi_rev' transition.
+                state.rev_eoi = true;
+            } else {
+                // We haven't hit the end of the search yet, so move on.
+                state.at -= 1;
+            }
+            sid
+        }
+    };
+    cache.search_start(state.at);
+    while !state.rev_eoi {
+        sid = dfa
+            .next_state(cache, sid, input.haystack()[state.at])
+            .map_err(|_| gave_up(state.at))?;
+        if sid.is_tagged() {
+            state.id = Some(sid);
+            if sid.is_start() {
+                // do nothing
+            } else if sid.is_match() {
+                state.next_match_index = Some(1);
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                state.mat = Some(HalfMatch::new(pattern, state.at + 1));
+                cache.search_finish(state.at);
+                return Ok(());
+            } else if sid.is_dead() {
+                cache.search_finish(state.at);
+                return Ok(());
+            } else if sid.is_quit() {
+                cache.search_finish(state.at);
+                return Err(MatchError::quit(
+                    input.haystack()[state.at],
+                    state.at,
+                ));
+            } else {
+                debug_assert!(sid.is_unknown());
+                unreachable!("sid being unknown is a bug");
+            }
+        }
+        if state.at == input.start() {
+            break;
+        }
+        state.at -= 1;
+        cache.search_update(state.at);
+    }
+
+    let result = eoi_rev(dfa, cache, input, &mut sid, &mut state.mat);
+    state.rev_eoi = true;
+    state.id = Some(sid);
+    if state.mat.is_some() {
+        // '1' is always correct here since if we get to this point, this
+        // always corresponds to the first (index '0') match discovered at
+        // this position. So the next match to report at this position (if
+        // it exists) is at index '1'.
+        state.next_match_index = Some(1);
+    }
+    cache.search_finish(input.start());
+    result
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn init_fwd(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+) -> Result<LazyStateID, MatchError> {
+    let sid = dfa.start_state_forward(cache, input)?;
+    // Start states can never be match states, since all matches are delayed
+    // by 1 byte.
+    debug_assert!(!sid.is_match());
+    Ok(sid)
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn init_rev(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+) -> Result<LazyStateID, MatchError> {
+    let sid = dfa.start_state_reverse(cache, input)?;
+    // Start states can never be match states, since all matches are delayed
+    // by 1 byte.
+    debug_assert!(!sid.is_match());
+    Ok(sid)
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn eoi_fwd(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    sid: &mut LazyStateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    match input.haystack().get(sp.end) {
+        Some(&b) => {
+            *sid =
+                dfa.next_state(cache, *sid, b).map_err(|_| gave_up(sp.end))?;
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, *sid, 0);
+                *mat = Some(HalfMatch::new(pattern, sp.end));
+            } else if sid.is_quit() {
+                return Err(MatchError::quit(b, sp.end));
+            }
+        }
+        None => {
+            *sid = dfa
+                .next_eoi_state(cache, *sid)
+                .map_err(|_| gave_up(input.haystack().len()))?;
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, *sid, 0);
+                *mat = Some(HalfMatch::new(pattern, input.haystack().len()));
+            }
+            // N.B. We don't have to check 'is_quit' here because the EOI
+            // transition can never lead to a quit state.
+            debug_assert!(!sid.is_quit());
+        }
+    }
+    Ok(())
+}
+
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn eoi_rev(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    sid: &mut LazyStateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    if sp.start > 0 {
+        let byte = input.haystack()[sp.start - 1];
+        *sid = dfa
+            .next_state(cache, *sid, byte)
+            .map_err(|_| gave_up(sp.start))?;
+        if sid.is_match() {
+            let pattern = dfa.match_pattern(cache, *sid, 0);
+            *mat = Some(HalfMatch::new(pattern, sp.start));
+        } else if sid.is_quit() {
+            return Err(MatchError::quit(byte, sp.start - 1));
+        }
+    } else {
+        *sid =
+            dfa.next_eoi_state(cache, *sid).map_err(|_| gave_up(sp.start))?;
+        if sid.is_match() {
+            let pattern = dfa.match_pattern(cache, *sid, 0);
+            *mat = Some(HalfMatch::new(pattern, 0));
+        }
+        // N.B. We don't have to check 'is_quit' here because the EOI
+        // transition can never lead to a quit state.
+        debug_assert!(!sid.is_quit());
+    }
+    Ok(())
+}
+
+/// Re-compute the starting state that a DFA should be in after finding a
+/// prefilter candidate match at the position `at`.
+///
+/// It is always correct to call this, but not always necessary. Namely,
+/// whenever the DFA has a universal start state, the DFA can remain in the
+/// start state that it was in when it ran the prefilter. Why? Because in that
+/// case, there is only one start state.
+///
+/// When does a DFA have a universal start state? In precisely cases where
+/// it has no look-around assertions in its prefix. So for example, `\bfoo`
+/// does not have a universal start state because the start state depends on
+/// whether the byte immediately before the start position is a word byte or
+/// not. However, `foo\b` does have a universal start state because the word
+/// boundary does not appear in the pattern's prefix.
+///
+/// So... most cases don't need this, but when a pattern doesn't have a
+/// universal start state, then after a prefilter candidate has been found, the
+/// current state *must* be re-litigated as if computing the start state at the
+/// beginning of the search because it might change. That is, not all start
+/// states are created equal.
+///
+/// Why avoid it? Because while it's not super expensive, it isn't a trivial
+/// operation to compute the start state. It is much better to avoid it and
+/// just state in the current state if you know it to be correct.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn prefilter_restart(
+    dfa: &DFA,
+    cache: &mut Cache,
+    input: &Input<'_>,
+    at: usize,
+) -> Result<LazyStateID, MatchError> {
+    let mut input = input.clone();
+    input.set_start(at);
+    init_fwd(dfa, cache, &input)
+}
+
+/// A convenience routine for constructing a "gave up" match error.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn gave_up(offset: usize) -> MatchError {
+    MatchError::gave_up(offset)
+}
diff --git a/regex-automata/src/lib.rs b/regex-automata/src/lib.rs
new file mode 100644
index 0000000000..85fa27d736
--- /dev/null
+++ b/regex-automata/src/lib.rs
@@ -0,0 +1,648 @@
+/*!
+This crate exposes a variety of regex engines used by the `regex` crate.
+It provides a vast, sprawling and "expert" level API to each regex engine.
+The regex engines provided by this crate focus heavily on finite automata
+implementations and specifically guarantee worst case `O(m * n)` time
+complexity for all searches. (Where `m ~ len(regex)` and `n ~ len(haystack)`.)
+
+The primary goal of this crate is to serve as an implementation detail for the
+`regex` crate. A secondary goal is to make its internals available for use by
+others.
+
+# Table of contents
+
+* [Should I be using this crate?](#should-i-be-using-this-crate) gives some
+reasons for and against using this crate.
+* [Examples](#examples) provides a small selection of things you can do with
+this crate.
+* [Available regex engines](#available-regex-engines) provides a hyperlinked
+list of all regex engines in this crate.
+* [API themes](#api-themes) discusses common elements used throughout this
+crate.
+* [Crate features](#crate-features) documents the extensive list of Cargo
+features available.
+
+# Should I be using this crate?
+
+If you find yourself here because you just want to use regexes, then you should
+first check out whether the [`regex` crate](https://docs.rs/regex) meets
+your needs. It provides a streamlined and difficult-to-misuse API for regex
+searching.
+
+If you're here because there is something specific you want to do that can't
+be easily done with `regex` crate, then you are perhaps in the right place.
+It's most likely that the first stop you'll want to make is to explore the
+[`meta` regex APIs](meta). Namely, the `regex` crate is just a light wrapper
+over a [`meta::Regex`], so its API will probably be the easiest to transition
+to. In contrast to the `regex` crate, the `meta::Regex` API supports more
+search parameters and does multi-pattern searches. However, it isn't quite as
+ergonomic.
+
+Otherwise, the following is an inexhaustive list of reasons to use this crate:
+
+* You want to analyze or use a [Thompson `NFA`](nfa::thompson::NFA) directly.
+* You want more powerful multi-pattern search than what is provided by
+`RegexSet` in the `regex` crate. All regex engines in this crate support
+multi-pattern searches.
+* You want to use one of the `regex` crate's internal engines directly because
+of some interesting configuration that isn't possible via the `regex` crate.
+For example, a [lazy DFA's configuration](hybrid::dfa::Config) exposes a
+dizzying number of options for controlling its execution.
+* You want to use the lower level search APIs. For example, both the [lazy
+DFA](hybrid::dfa) and [fully compiled DFAs](dfa) support searching by exploring
+the automaton one state at a time. This might be useful, for example, for
+stream searches or searches of strings stored in non-contiguous in memory.
+* You want to build a fully compiled DFA and then [use zero-copy
+deserialization](dfa::dense::DFA::from_bytes) to load it into memory and use
+it for searching. This use case is supported in core-only no-std/no-alloc
+environments.
+* You want to run [anchored searches](Input::anchored) without using the `^`
+anchor in your regex pattern.
+* You need to work-around contention issues with
+sharing a regex across multiple threads. The
+[`meta::Regex::search_with`](meta::Regex::search_with) API permits bypassing
+any kind of synchronization at all by requiring the caller to provide the
+mutable scratch spaced needed during a search.
+* You want to build your own regex engine on top of the `regex` crate's
+infrastructure.
+
+# Examples
+
+This section tries to identify a few interesting things you can do with this
+crate and demonstrates them.
+
+### Multi-pattern searches with capture groups
+
+One of the more frustrating limitations of `RegexSet` in the `regex` crate
+(at the time of writing) is that it doesn't report match positions. With this
+crate, multi-pattern support was intentionally designed in from the beginning,
+which means it works in all regex engines and even for capture groups as well.
+
+This example shows how to search for matches of multiple regexes, where each
+regex uses the same capture group names to parse different key-value formats.
+
+```
+use regex_automata::{meta::Regex, PatternID};
+
+let re = Regex::new_many(&[
+    r#"(?m)^(?<key>[[:word:]]+)=(?<val>[[:word:]]+)$"#,
+    r#"(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$"#,
+    r#"(?m)^(?<key>[[:word:]]+)='(?<val>[^']+)'$"#,
+    r#"(?m)^(?<key>[[:word:]]+):\s*(?<val>[[:word:]]+)$"#,
+])?;
+let hay = r#"
+best_album="Blow Your Face Out"
+best_quote='"then as it was, then again it will be"'
+best_year=1973
+best_simpsons_episode: HOMR
+"#;
+let mut kvs = vec![];
+for caps in re.captures_iter(hay) {
+    // N.B. One could use capture indices '1' and '2' here
+    // as well. Capture indices are local to each pattern.
+    // (Just like names are.)
+    let key = &hay[caps.get_group_by_name("key").unwrap()];
+    let val = &hay[caps.get_group_by_name("val").unwrap()];
+    kvs.push((key, val));
+}
+assert_eq!(kvs, vec![
+    ("best_album", "Blow Your Face Out"),
+    ("best_quote", "\"then as it was, then again it will be\""),
+    ("best_year", "1973"),
+    ("best_simpsons_episode", "HOMR"),
+]);
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+### Build a full DFA and walk it manually
+
+One of the regex engines in this crate is a fully compiled DFA. It takes worst
+case exponential time to build, but once built, it can be easily explored and
+used for searches. Here's a simple example that uses its lower level APIs to
+implement a simple anchored search by hand.
+
+```
+use regex_automata::{dfa::{Automaton, dense}, Input};
+
+let dfa = dense::DFA::new(r"(?-u)\b[A-Z]\w+z\b")?;
+let haystack = "Quartz";
+
+// The start state is determined by inspecting the position and the
+// initial bytes of the haystack.
+let mut state = dfa.start_state_forward(&Input::new(haystack))?;
+// Walk all the bytes in the haystack.
+for &b in haystack.as_bytes().iter() {
+    state = dfa.next_state(state, b);
+}
+// DFAs in this crate require an explicit
+// end-of-input transition if a search reaches
+// the end of a haystack.
+state = dfa.next_eoi_state(state);
+assert!(dfa.is_match_state(state));
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+Or do the same with a lazy DFA that avoids exponential worst case compile time,
+but requires mutable scratch space to lazily build the DFA during the search.
+
+```
+use regex_automata::{hybrid::dfa::DFA, Input};
+
+let dfa = DFA::new(r"(?-u)\b[A-Z]\w+z\b")?;
+let mut cache = dfa.create_cache();
+let hay = "Quartz";
+
+// The start state is determined by inspecting the position and the
+// initial bytes of the haystack.
+let mut state = dfa.start_state_forward(&mut cache, &Input::new(hay))?;
+// Walk all the bytes in the haystack.
+for &b in hay.as_bytes().iter() {
+    state = dfa.next_state(&mut cache, state, b)?;
+}
+// DFAs in this crate require an explicit
+// end-of-input transition if a search reaches
+// the end of a haystack.
+state = dfa.next_eoi_state(&mut cache, state)?;
+assert!(state.is_match());
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+### Find all overlapping matches
+
+This example shows how to build a DFA and use it to find all possible matches,
+including overlapping matches. A similar example will work with a lazy DFA as
+well. This also works with multiple patterns and will report all matches at the
+same position where multiple patterns match.
+
+```
+use regex_automata::{
+    dfa::{dense, Automaton, OverlappingState},
+    Input, MatchKind,
+};
+
+let dfa = dense::DFA::builder()
+    .configure(dense::DFA::config().match_kind(MatchKind::All))
+    .build(r"(?-u)\w{3,}")?;
+let input = Input::new("homer marge bart lisa maggie");
+let mut state = OverlappingState::start();
+
+let mut matches = vec![];
+while let Some(hm) = {
+    dfa.try_search_overlapping_fwd(&input, &mut state)?;
+    state.get_match()
+} {
+    matches.push(hm.offset());
+}
+assert_eq!(matches, vec![
+    3, 4, 5,        // hom, home, homer
+    9, 10, 11,      // mar, marg, marge
+    15, 16,         // bar, bart
+    20, 21,         // lis, lisa
+    25, 26, 27, 28, // mag, magg, maggi, maggie
+]);
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Available regex engines
+
+The following is a complete list of all regex engines provided by this crate,
+along with a very brief description of it and why you might want to use it.
+
+* [`dfa::regex::Regex`] is a regex engine that works on top of either
+[dense](dfa::dense) or [sparse](dfa::sparse) fully compiled DFAs. You might
+use a DFA if you need the fastest possible regex engine in this crate and can
+afford the exorbitant memory usage usually required by DFAs. Low level APIs on
+fully compiled DFAs are provided by the [`Automaton` trait](dfa::Automaton).
+Fully compiled dense DFAs can handle all regexes except for searching a regex
+with a Unicode word boundary on non-ASCII haystacks. A fully compiled DFA based
+regex can only report the start and end of each match.
+* [`hybrid::regex::Regex`] is a regex engine that works on top of a lazily
+built DFA. Its performance profile is very similar to that of fully compiled
+DFAs, but can be slower in some pathological cases. Fully compiled DFAs are
+also amenable to more optimizations, such as state acceleration, that aren't
+available in a lazy DFA. You might use this lazy DFA if you can't abide the
+worst case exponential compile time of a full DFA, but still want the DFA
+search performance in the vast majority of cases. A lazy DFA based regex can
+only report the start and end of each match.
+* [`dfa::onepass::DFA`] is a regex engine that is implemented as a DFA, but
+can report the matches of each capture group in addition to the start and end
+of each match. The catch is that it only works on a somewhat small subset of
+regexes known as "one-pass." You'll want to use this for cases when you need
+capture group matches and the regex is one-pass since it is likely to be faster
+than any alternative. A one-pass DFA can handle all types of regexes, but does
+have some reasonable limits on the number of capture groups it can handle.
+* [`nfa::thompson::backtrack::BoundedBacktracker`] is a regex engine that uses
+backtracking, but keeps track of the work it has done to avoid catastrophic
+backtracking. Like the one-pass DFA, it provides the matches of each capture
+group. It retains the `O(m * n)` worst case time bound. This tends to be slower
+than the one-pass DFA regex engine, but faster than the PikeVM. It can handle
+all types of regexes, but usually only works well with small haystacks and
+small regexes due to the memory required to avoid redoing work.
+* [`nfa::thompson::pikevm::PikeVM`] is a regex engine that can handle all
+regexes, of all sizes and provides capture group matches. It tends to be a tool
+of last resort because it is also usually the slowest regex engine.
+* [`meta::Regex`] is the meta regex engine that combines *all* of the above
+engines into one. The reason for this is that each of the engines above have
+their own caveats such as, "only handles a subset of regexes" or "is generally
+slow." The meta regex engine accounts for all of these caveats and composes
+the engines in a way that attempts to mitigate each engine's weaknesses while
+emphasizing its strengths. For example, it will attempt to run a lazy DFA even
+if it might fail. In which case, it will restart the search with a likely
+slower but more capable regex engine. The meta regex engine is what you should
+default to. Use one of the above engines directly only if you have a specific
+reason to.
+
+# API themes
+
+While each regex engine has its own APIs and configuration options, there are
+some general themes followed by all of them.
+
+### The `Input` abstraction
+
+Most search routines in this crate accept anything that implements
+`Into<Input>`. Both `&str` and `&[u8]` haystacks satisfy this constraint, which
+means that things like `engine.search("foo")` will work as you would expect.
+
+By virtue of accepting an `Into<Input>` though, callers can provide more than
+just a haystack. Indeed, the [`Input`] type has more details, but briefly,
+callers can use it to configure various aspects of the search:
+
+* The span of the haystack to search via [`Input::span`] or [`Input::range`],
+which might be a substring of the haystack.
+* Whether to run an anchored search or not via [`Input::anchored`]. This
+permits one to require matches to start at the same offset that the search
+started.
+* Whether to ask the regex engine to stop as soon as a match is seen via
+[`Input::earliest`]. This can be used to find the offset of a match as soon
+as it is known without waiting for the full leftmost-first match to be found.
+This can also be used to avoid the worst case `O(m * n^2)` time complexity
+of iteration.
+
+Some lower level search routines accept an `&Input` for performance reasons.
+In which case, `&Input::new("haystack")` can be used for a simple search.
+
+### Error reporting
+
+Most, but not all, regex engines in this crate can fail to execute a search.
+When a search fails, callers cannot determine whether or not a match exists.
+That is, the result is indeterminate.
+
+Search failure, in all cases in this crate, is represented by a [`MatchError`].
+Routines that can fail start with the `try_` prefix in their name. For example,
+[`hybrid::regex::Regex::try_search`] can fail for a number of reasons.
+Conversely, routines that either can't fail or can panic on failure lack the
+`try_` prefix. For example, [`hybrid::regex::Regex::find`] will panic in
+cases where [`hybrid::regex::Regex::try_search`] would return an error, and
+[`meta::Regex::find`] will never panic. Therefore, callers need to pay close
+attention to the panicking conditions in the documentation.
+
+In most cases, the reasons that a search fails are either predictable or
+configurable, albeit at some additional cost.
+
+An example of predictable failure is
+[`BoundedBacktracker::try_search`](nfa::thompson::backtrack::BoundedBacktracker::try_search).
+Namely, it fails whenever the multiplication of the haystack, the regex and some
+constant exceeds the
+[configured visited capacity](nfa::thompson::backtrack::Config::visited_capacity).
+Callers can predict the failure in terms of haystack length via the
+[`BoundedBacktracker::max_haystack_len`](nfa::thompson::backtrack::BoundedBacktracker::max_haystack_len)
+method. While this form of failure is technically avoidable by increasing the
+visited capacity, it isn't practical to do so for all inputs because the
+memory usage required for larger haystacks becomes impractically large. So in
+practice, if one is using the bounded backtracker, you really do have to deal
+with the failure.
+
+An example of configurable failure happens when one enables heuristic support
+for Unicode word boundaries in a DFA. Namely, since the DFAs in this crate
+(except for the one-pass DFA) do not support Unicode word boundaries on
+non-ASCII haystacks, building a DFA from an NFA that contains a Unicode word
+boundary will itself fail. However, one can configure DFAs to still be built in
+this case by
+[configuring heuristic support for Unicode word boundaries](hybrid::dfa::Config::unicode_word_boundary).
+If the NFA the DFA is built from contains a Unicode word boundary, then the
+DFA will still be built, but special transitions will be added to every state
+that cause the DFA to fail if any non-ASCII byte is seen. This failure happens
+at search time and it requires the caller to opt into this.
+
+There are other ways for regex engines to fail in this crate, but the above
+two should represent the general theme of failures one can find. Dealing
+with these failures is, in part, one the reaponsibilities of the [meta regex
+engine](meta). Notice, for example, that the meta regex engine exposes an API
+that never returns an error nor panics. It carefully manages all of the ways
+in which the regex engines can fail and either avoids the predictable ones
+entirely (e.g., the bounded backtracker) or reacts to configured failures by
+falling back to a different engine (e.g., the lazy DFA quitting because it saw
+a non-ASCII byte).
+
+### Configuration and Builders
+
+Most of the regex engines in this crate come with two types to facilitate
+building the regex engine: a `Config` and a `Builder`. A `Config` is usually
+specific to that particular regex engine, but other objects such as parsing and
+NFA compilation have `Config` types too. A `Builder` is the thing responsible
+for taking inputs (either pattern strings or already-parsed patterns or even
+NFAs directly) and turning them into an actual regex engine that can be used
+for searching.
+
+The main reason why building a regex engine is a bit complicated is because
+of the desire to permit composition with de-coupled components. For example,
+you might want to [manually construct a Thompson NFA](nfa::thompson::Builder)
+and then build a regex engine from it without ever using a regex parser
+at all. On the other hand, you might also want to build a regex engine directly
+from the concrete syntax. This demonstrates why regex engine construction is
+so flexible: it needs to support not just convenient construction, but also
+construction from parts built elsewhere.
+
+This is also in turn why there are many different `Config` structs in this
+crate. Let's look more closely at an example: [`hybrid::regex::Builder`]. It
+accepts three different `Config` types for configuring construction of a lazy
+DFA regex:
+
+* [`hybrid::regex::Builder::syntax`] accepts a
+[`util::syntax::Config`] for configuring the options found in the
+[`regex-syntax`](regex_syntax) crate. For example, whether to match
+case insensitively.
+* [`hybrid::regex::Builder::thompson`] accepts a [`nfa::thompson::Config`] for
+configuring construction of a [Thompson NFA](nfa::thompson::NFA). For example,
+whether to build an NFA that matches the reverse language described by the
+regex.
+* [`hybrid::regex::Builder::dfa`] accept a [`hybrid::dfa::Config`] for
+configuring construction of the pair of underlying lazy DFAs that make up the
+lazy DFA regex engine. For example, changing the capacity of the cache used to
+store the transition table.
+
+The lazy DFA regex engine uses all three of those configuration objects for
+methods like [`hybrid::regex::Builder::build`], which accepts a pattern
+string containing the concrete syntax of your regex. It uses the syntax
+configuration to parse it into an AST and translate it into an HIR. Then the
+NFA configuration when compiling the HIR into an NFA. And then finally the DFA
+configuration when lazily determinizing the NFA into a DFA.
+
+Notice though that the builder also has a
+[`hybrid::regex::Builder::build_from_dfas`] constructor. This permits callers
+to build the underlying pair of lazy DFAs themselves (one for the forward
+searching to find the end of a match and one for the reverse searching to find
+the start of a match), and then build the regex engine from them. The lazy
+DFAs, in turn, have their own builder that permits [construction directly from
+a Thompson NFA](hybrid::dfa::Builder::build_from_nfa). Continuing down the
+rabbit hole, a Thompson NFA has its own compiler that permits [construction
+directly from an HIR](nfa::thompson::Compiler::build_from_hir). The lazy DFA
+regex engine builder lets you follow this rabbit hole all the way down, but
+also provides convenience routines that do it for you when you don't need
+precise control over every component.
+
+The [meta regex engine](meta) is a good example of something that utilizes the
+full flexibility of these builders. It often needs not only precise control
+over each component, but also shares them across multiple regex engines.
+(Most sharing is done by internal reference accounting. For example, an
+[`NFA`](nfa::thompson::NFA) is reference counted internally which makes cloning
+cheap.)
+
+### Size limits
+
+Unlike the `regex` crate, the `regex-automata` crate specifically does not
+enable any size limits by default. That means users of this crate need to
+be quite careful when using untrusted patterns. Namely, because bounded
+repetitions can grow exponentially by stacking them, it is possible to build a
+very large internal regex object from just a small pattern string. For example,
+the NFA built from the pattern `a{10}{10}{10}{10}{10}{10}{10}` is over 240MB.
+
+There are multiple size limit options in this crate. If one or more size limits
+are relevant for the object you're building, they will be configurable via
+methods on a corresponding `Config` type.
+
+# Crate features
+
+This crate has a dizzying number of features. The main idea is to be able to
+control how much stuff you pull in for your specific use case, since the full
+crate is quite large and can dramatically increase compile times and binary
+size.
+
+The most barebones but useful configuration is to disable all default features
+and enable only `dfa-search`. This will bring in just the DFA deserialization
+and search routines without any dependency on `std` or `alloc`. This does
+require generating and serializing a DFA, and then storing it somewhere, but
+it permits regex searches in freestanding or embedded environments.
+
+Because there are so many features, they are split into a few groups.
+
+The default set of features is: `std`, `syntax`, `perf`, `unicode`, `meta`,
+`nfa`, `dfa` and `hybrid`. Basically, the default is to enable everything
+except for development related features like `logging`.
+
+### Ecosystem features
+
+* **std** - Enables use of the standard library. In terms of APIs, this usually
+just means that error types implement the `std::error::Error` trait. Otherwise,
+`std` sometimes enables the code to be faster, for example, using a `HashMap`
+instead of a `BTreeMap`. (The `std` feature matters more for dependencies like
+`aho-corasick` and `memchr`, where `std` is required to enable certain classes
+of SIMD optimizations.) Enabling `std` automatically enables `alloc`.
+* **alloc** - Enables use of the `alloc` library. This is required for most
+APIs in this crate. The main exception is deserializing and searching with
+fully compiled DFAs.
+* **logging** - Adds a dependency on the `log` crate and makes this crate emit
+log messages of varying degrees of utility. The log messages are especially
+useful in trying to understand what the meta regex engine is doing.
+
+### Performance features
+
+* **perf** - Enables all of the below features.
+* **perf-inline** - When enabled, `inline(always)` is used in (many) strategic
+locations to help performance at the expense of longer compile times and
+increased binary size.
+* **perf-literal** - Enables all literal related optimizations.
+    * **perf-literal-substring** - Enables all single substring literal
+    optimizations. This includes adding a dependency on the `memchr` crate.
+    * **perf-literal-multisubstring** - Enables all multiple substring literal
+    optimizations. This includes adding a dependency on the `aho-corasick`
+    crate.
+
+### Unicode features
+
+* **unicode** -
+  Enables all Unicode features. This feature is enabled by default, and will
+  always cover all Unicode features, even if more are added in the future.
+* **unicode-age** -
+  Provide the data for the
+  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
+  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
+  codepoints first introduced in Unicode 6.0
+* **unicode-bool** -
+  Provide the data for numerous Unicode boolean properties. The full list
+  is not included here, but contains properties like `Alphabetic`, `Emoji`,
+  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
+* **unicode-case** -
+  Provide the data for case insensitive matching using
+  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
+* **unicode-gencat** -
+  Provide the data for
+  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
+  This includes, but is not limited to, `Decimal_Number`, `Letter`,
+  `Math_Symbol`, `Number` and `Punctuation`.
+* **unicode-perl** -
+  Provide the data for supporting the Unicode-aware Perl character classes,
+  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
+  Unicode-aware word boundary assertions. Note that if this feature is
+  disabled, the `\s` and `\d` character classes are still available if the
+  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
+* **unicode-script** -
+  Provide the data for
+  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
+  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
+  `Latin` and `Thai`.
+* **unicode-segment** -
+  Provide the data necessary to provide the properties used to implement the
+  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
+  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
+  `\p{sb=ATerm}`.
+* **unicode-word-boundary** -
+  Enables support for Unicode word boundaries, i.e., `\b`, in regexes. When
+  this and `unicode-perl` are enabled, then data tables from `regex-syntax` are
+  used to implement Unicode word boundaries. However, if `regex-syntax` isn't
+  enabled as a dependency then one can still enable this feature. It will
+  cause `regex-automata` to bundle its own data table that would otherwise be
+  redundant with `regex-syntax`'s table.
+
+### Regex engine features
+
+* **syntax** - Enables a dependency on `regex-syntax`. This makes APIs
+for building regex engines from pattern strings available. Without the
+`regex-syntax` dependency, the only way to build a regex engine is generally
+to deserialize a previously built DFA or to hand assemble an NFA using its
+[builder API](nfa::thompson::Builder). Once you have an NFA, you can build any
+of the regex engines in this crate. The `syntax` feature also enables `alloc`.
+* **meta** - Enables the meta regex engine. This also enables the `syntax` and
+`nfa-pikevm` features, as both are the minimal requirements needed. The meta
+regex engine benefits from enabling any of the other regex engines and will
+use them automatically when appropriate.
+* **nfa** - Enables all NFA related features below.
+    * **nfa-thompson** - Enables the Thompson NFA APIs. This enables `alloc`.
+    * **nfa-pikevm** - Enables the PikeVM regex engine. This enables
+    `nfa-thompson`.
+    * **nfa-backtrack** - Enables the bounded backtracker regex engine. This
+    enables `nfa-thompson`.
+* **dfa** - Enables all DFA related features below.
+    * **dfa-build** - Enables APIs for determinizing DFAs from NFAs. This
+    enables `nfa-thompson` and `dfa-search`.
+    * **dfa-search** - Enables APIs for searching with DFAs.
+    * **dfa-onepass** - Enables the one-pass DFA API. This enables
+    `nfa-thompson`.
+* **hybrid** - Enables the hybrid NFA/DFA or "lazy DFA" regex engine. This
+enables `alloc` and `nfa-thompson`.
+
+*/
+
+// We are no_std.
+#![no_std]
+// All APIs need docs!
+#![deny(missing_docs)]
+// Some intra-doc links are broken when certain features are disabled, so we
+// only bleat about it when most (all?) features are enabled. But when we do,
+// we block the build. Links need to work.
+#![cfg_attr(
+    all(
+        feature = "std",
+        feature = "nfa",
+        feature = "dfa",
+        feature = "hybrid"
+    ),
+    deny(rustdoc::broken_intra_doc_links)
+)]
+// Broken rustdoc links are very easy to come by when you start disabling
+// features. Namely, features tend to change imports, and imports change what's
+// available to link to.
+//
+// Basically, we just don't support rustdoc for anything other than the maximal
+// feature configuration. Other configurations will work, they just won't be
+// perfect.
+//
+// So here, we specifically allow them so we don't even get warned about them.
+#![cfg_attr(
+    not(all(
+        feature = "std",
+        feature = "nfa",
+        feature = "dfa",
+        feature = "hybrid"
+    )),
+    allow(rustdoc::broken_intra_doc_links)
+)]
+// Kinda similar, but eliminating all of the dead code and unused import
+// warnings for every feature combo is a fool's errand. Instead, we just
+// suppress those, but still let them through in a common configuration when we
+// build most of everything.
+//
+// This does actually suggest that when features are disabled, we are actually
+// compiling more code than we need to be. And this is perhaps not so great
+// because disabling features is usually done in order to reduce compile times
+// by reducing the amount of code one compiles... However, usually, most of the
+// time this dead code is a relatively small amount from the 'util' module.
+// But... I confess... There isn't a ton of visibility on this.
+//
+// I'm happy to try to address this in a different way, but "let's annotate
+// every function in 'util' with some non-local combination of features" just
+// cannot be the way forward.
+#![cfg_attr(
+    not(all(
+        feature = "std",
+        feature = "nfa",
+        feature = "dfa",
+        feature = "hybrid",
+        feature = "perf-literal-substring",
+        feature = "perf-literal-multisubstring",
+    )),
+    allow(dead_code, unused_imports, unused_variables)
+)]
+// We generally want all types to impl Debug.
+#![warn(missing_debug_implementations)]
+// No clue why this thing is still unstable because it's pretty amazing. This
+// adds Cargo feature annotations to items in the rustdoc output. Which is
+// sadly hugely beneficial for this crate due to the number of features.
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+
+// I have literally never tested this crate on 16-bit, so it is quite
+// suspicious to advertise support for it. But... the regex crate, at time
+// of writing, at least claims to support it by not doing any conditional
+// compilation based on the target pointer width. So I guess I remain
+// consistent with that here.
+//
+// If you are here because you're on a 16-bit system and you were somehow using
+// the regex crate previously, please file an issue. Please be prepared to
+// provide some kind of reproduction or carve out some path to getting 16-bit
+// working in CI. (Via qemu?)
+#[cfg(not(any(
+    target_pointer_width = "16",
+    target_pointer_width = "32",
+    target_pointer_width = "64"
+)))]
+compile_error!("not supported on non-{16,32,64}, please file an issue");
+
+#[cfg(any(test, feature = "std"))]
+extern crate std;
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(doctest)]
+doc_comment::doctest!("../README.md");
+
+#[doc(inline)]
+pub use crate::util::primitives::PatternID;
+pub use crate::util::search::*;
+
+#[macro_use]
+mod macros;
+
+#[cfg(any(feature = "dfa-search", feature = "dfa-onepass"))]
+pub mod dfa;
+#[cfg(feature = "hybrid")]
+pub mod hybrid;
+#[cfg(feature = "meta")]
+pub mod meta;
+#[cfg(feature = "nfa-thompson")]
+pub mod nfa;
+pub mod util;
diff --git a/regex-automata/src/macros.rs b/regex-automata/src/macros.rs
new file mode 100644
index 0000000000..31b4ca3816
--- /dev/null
+++ b/regex-automata/src/macros.rs
@@ -0,0 +1,20 @@
+// Some feature combinations result in some of these macros never being used.
+// Which is fine. Just squash the warnings.
+#![allow(unused_macros)]
+
+macro_rules! log {
+    ($($tt:tt)*) => {
+        #[cfg(feature = "logging")]
+        {
+            $($tt)*
+        }
+    }
+}
+
+macro_rules! debug {
+    ($($tt:tt)*) => { log!(log::debug!($($tt)*)) }
+}
+
+macro_rules! trace {
+    ($($tt:tt)*) => { log!(log::trace!($($tt)*)) }
+}
diff --git a/regex-automata/src/meta/error.rs b/regex-automata/src/meta/error.rs
new file mode 100644
index 0000000000..f5911aebbf
--- /dev/null
+++ b/regex-automata/src/meta/error.rs
@@ -0,0 +1,241 @@
+use regex_syntax::{ast, hir};
+
+use crate::{nfa, util::search::MatchError, PatternID};
+
+/// An error that occurs when construction of a `Regex` fails.
+///
+/// A build error is generally a result of one of two possible failure
+/// modes. First is a parse or syntax error in the concrete syntax of a
+/// pattern. Second is that the construction of the underlying regex matcher
+/// fails, usually because it gets too big with respect to limits like
+/// [`Config::nfa_size_limit`](crate::meta::Config::nfa_size_limit).
+///
+/// This error provides very little introspection capabilities. You can:
+///
+/// * Ask for the [`PatternID`] of the pattern that caused an error, if one
+/// is available. This is available for things like syntax errors, but not for
+/// cases where build limits are exceeded.
+/// * Ask for the underlying syntax error, but only if the error is a syntax
+/// error.
+/// * Ask for a human readable message corresponding to the underlying error.
+/// * The `BuildError::source` method (from the `std::error::Error`
+/// trait implementation) may be used to query for an underlying error if one
+/// exists. There are no API guarantees about which error is returned.
+///
+/// When the `std` feature is enabled, this implements `std::error::Error`.
+#[derive(Clone, Debug)]
+pub struct BuildError {
+    kind: BuildErrorKind,
+}
+
+#[derive(Clone, Debug)]
+enum BuildErrorKind {
+    Syntax { pid: PatternID, err: regex_syntax::Error },
+    NFA(nfa::thompson::BuildError),
+}
+
+impl BuildError {
+    /// If it is known which pattern ID caused this build error to occur, then
+    /// this method returns it.
+    ///
+    /// Some errors are not associated with a particular pattern. However, any
+    /// errors that occur as part of parsing a pattern are guaranteed to be
+    /// associated with a pattern ID.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, PatternID};
+    ///
+    /// let err = Regex::new_many(&["a", "b", r"\p{Foo}", "c"]).unwrap_err();
+    /// assert_eq!(Some(PatternID::must(2)), err.pattern());
+    /// ```
+    pub fn pattern(&self) -> Option<PatternID> {
+        match self.kind {
+            BuildErrorKind::Syntax { pid, .. } => Some(pid),
+            _ => None,
+        }
+    }
+
+    /// If this error occurred because the regex exceeded the configured size
+    /// limit before being built, then this returns the configured size limit.
+    ///
+    /// The limit returned is what was configured, and corresponds to the
+    /// maximum amount of heap usage in bytes.
+    pub fn size_limit(&self) -> Option<usize> {
+        match self.kind {
+            BuildErrorKind::NFA(ref err) => err.size_limit(),
+            _ => None,
+        }
+    }
+
+    /// If this error corresponds to a syntax error, then a reference to it is
+    /// returned by this method.
+    pub fn syntax_error(&self) -> Option<&regex_syntax::Error> {
+        match self.kind {
+            BuildErrorKind::Syntax { ref err, .. } => Some(err),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn ast(pid: PatternID, err: ast::Error) -> BuildError {
+        let err = regex_syntax::Error::from(err);
+        BuildError { kind: BuildErrorKind::Syntax { pid, err } }
+    }
+
+    pub(crate) fn hir(pid: PatternID, err: hir::Error) -> BuildError {
+        let err = regex_syntax::Error::from(err);
+        BuildError { kind: BuildErrorKind::Syntax { pid, err } }
+    }
+
+    pub(crate) fn nfa(err: nfa::thompson::BuildError) -> BuildError {
+        BuildError { kind: BuildErrorKind::NFA(err) }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind {
+            BuildErrorKind::Syntax { ref err, .. } => Some(err),
+            BuildErrorKind::NFA(ref err) => Some(err),
+        }
+    }
+}
+
+impl core::fmt::Display for BuildError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self.kind {
+            BuildErrorKind::Syntax { pid, .. } => {
+                write!(f, "error parsing pattern {}", pid.as_usize())
+            }
+            BuildErrorKind::NFA(_) => write!(f, "error building NFA"),
+        }
+    }
+}
+
+/// An error that occurs when a search should be retried.
+///
+/// This retry error distinguishes between two different failure modes.
+///
+/// The first is one where potential quadratic behavior has been detected.
+/// In this case, whatever optimization that led to this behavior should be
+/// stopped, and the next best strategy shouldbe used.
+///
+/// The second indicates that the underlying regex engine has failed for some
+/// reason. This usually occurs because either a lazy DFA's cache has become
+/// ineffective or because a non-ASCII byte has been seen *and* a Unicode word
+/// boundary was used in one of the patterns. In this failure case, a different
+/// regex engine that won't fail in these ways (PikeVM, backtracker or the
+/// one-pass DFA) should be used.
+///
+/// This is an internal error only and should never bleed into the public
+/// API.
+#[derive(Debug)]
+pub(crate) enum RetryError {
+    Quadratic(RetryQuadraticError),
+    Fail(RetryFailError),
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RetryError {}
+
+impl core::fmt::Display for RetryError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            RetryError::Quadratic(ref err) => err.fmt(f),
+            RetryError::Fail(ref err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<MatchError> for RetryError {
+    fn from(merr: MatchError) -> RetryError {
+        RetryError::Fail(RetryFailError::from(merr))
+    }
+}
+
+/// An error that occurs when potential quadratic behavior has been detected
+/// when applying either the "reverse suffix" or "reverse inner" optimizations.
+///
+/// When this error occurs, callers should abandon the "reverse" optimization
+/// and use a normal forward search.
+#[derive(Debug)]
+pub(crate) struct RetryQuadraticError(());
+
+impl RetryQuadraticError {
+    pub(crate) fn new() -> RetryQuadraticError {
+        RetryQuadraticError(())
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RetryQuadraticError {}
+
+impl core::fmt::Display for RetryQuadraticError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "regex engine gave up to avoid quadratic behavior")
+    }
+}
+
+impl From<RetryQuadraticError> for RetryError {
+    fn from(err: RetryQuadraticError) -> RetryError {
+        RetryError::Quadratic(err)
+    }
+}
+
+/// An error that occurs when a regex engine "gives up" for some reason before
+/// finishing a search. Usually this occurs because of heuristic Unicode word
+/// boundary support or because of ineffective cache usage in the lazy DFA.
+///
+/// When this error occurs, callers should retry the regex search with a
+/// different regex engine.
+///
+/// Note that this has convenient `From` impls that will automatically
+/// convert a `MatchError` into this error. This works because the meta
+/// regex engine internals guarantee that errors like `HaystackTooLong` and
+/// `UnsupportAnchored` will never occur. The only errors left are `Quit` and
+/// `GaveUp`, which both correspond to this "failure" error.
+#[derive(Debug)]
+pub(crate) struct RetryFailError {
+    offset: usize,
+}
+
+impl RetryFailError {
+    pub(crate) fn from_offset(offset: usize) -> RetryFailError {
+        RetryFailError { offset }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RetryFailError {}
+
+impl core::fmt::Display for RetryFailError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "regex engine failed at offset {:?}", self.offset)
+    }
+}
+
+impl From<RetryFailError> for RetryError {
+    fn from(err: RetryFailError) -> RetryError {
+        RetryError::Fail(err)
+    }
+}
+
+impl From<MatchError> for RetryFailError {
+    fn from(merr: MatchError) -> RetryFailError {
+        use crate::util::search::MatchErrorKind::*;
+
+        match *merr.kind() {
+            Quit { offset, .. } => RetryFailError::from_offset(offset),
+            GaveUp { offset } => RetryFailError::from_offset(offset),
+            // These can never occur because we avoid them by construction
+            // or with higher level control flow logic. For example, the
+            // backtracker's wrapper will never hand out a backtracker engine
+            // when the haystack would be too long.
+            HaystackTooLong { .. } | UnsupportedAnchored { .. } => {
+                unreachable!("found impossible error in meta engine: {}", merr)
+            }
+        }
+    }
+}
diff --git a/regex-automata/src/meta/limited.rs b/regex-automata/src/meta/limited.rs
new file mode 100644
index 0000000000..005878acdb
--- /dev/null
+++ b/regex-automata/src/meta/limited.rs
@@ -0,0 +1,220 @@
+/*!
+This module defines two bespoke reverse DFA searching routines. (One for the
+lazy DFA and one for the fully compiled DFA.) These routines differ from the
+usual ones by permitting the caller to specify a minimum starting position.
+That is, the search will begin at `input.end()` and will usually stop at
+`input.start()`, unless `min_start > input.start()`, in which case, the search
+will stop at `min_start`.
+
+In other words, this lets you say, "no, the search must not extend past this
+point, even if it's within the bounds of the given `Input`." And if the search
+*does* want to go past that point, it stops and returns a "may be quadratic"
+error, which indicates that the caller should retry using some other technique.
+
+These routines specifically exist to protect against quadratic behavior when
+employing the "reverse suffix" and "reverse inner" optimizations. Without the
+backstop these routines provide, it is possible for parts of the haystack to
+get re-scanned over and over again. The backstop not only prevents this, but
+*tells you when it is happening* so that you can change the strategy.
+
+Why can't we just use the normal search routines? We could use the normal
+search routines and just set the start bound on the provided `Input` to our
+`min_start` position. The problem here is that it's impossible to distinguish
+between "no match because we reached the end of input" and "determined there
+was no match well before the end of input." The former case is what we care
+about with respect to quadratic behavior. The latter case is totally fine.
+
+Why don't we modify the normal search routines to report the position at which
+the search stops? I considered this, and I still wonder if it is indeed the
+right thing to do. However, I think the straight-forward thing to do there
+would be to complicate the return type signature of almost every search routine
+in this crate, which I really do not want to do. It therefore might make more
+sense to provide a richer way for search routines to report meta data, but that
+was beyond my bandwidth to work on at the time of writing.
+
+See the 'opt/reverse-inner' and 'opt/reverse-suffix' benchmarks in rebar for a
+real demonstration of how quadratic behavior is mitigated.
+*/
+
+use crate::{
+    meta::error::{RetryError, RetryQuadraticError},
+    HalfMatch, Input, MatchError,
+};
+
+#[cfg(feature = "dfa-build")]
+pub(crate) fn dfa_try_search_half_rev(
+    dfa: &crate::dfa::dense::DFA<alloc::vec::Vec<u32>>,
+    input: &Input<'_>,
+    min_start: usize,
+) -> Result<Option<HalfMatch>, RetryError> {
+    use crate::dfa::Automaton;
+
+    let mut mat = None;
+    let mut sid = dfa.start_state_reverse(input)?;
+    if input.start() == input.end() {
+        dfa_eoi_rev(dfa, input, &mut sid, &mut mat)?;
+        return Ok(mat);
+    }
+    let mut at = input.end() - 1;
+    loop {
+        sid = dfa.next_state(sid, input.haystack()[at]);
+        if dfa.is_special_state(sid) {
+            if dfa.is_match_state(sid) {
+                let pattern = dfa.match_pattern(sid, 0);
+                // Since reverse searches report the beginning of a
+                // match and the beginning is inclusive (not exclusive
+                // like the end of a match), we add 1 to make it
+                // inclusive.
+                mat = Some(HalfMatch::new(pattern, at + 1));
+            } else if dfa.is_dead_state(sid) {
+                return Ok(mat);
+            } else if dfa.is_quit_state(sid) {
+                if mat.is_some() {
+                    return Ok(mat);
+                }
+                return Err(MatchError::quit(input.haystack()[at], at).into());
+            }
+        }
+        if at == input.start() {
+            break;
+        }
+        at -= 1;
+        if at < min_start {
+            trace!(
+                "reached position {} which is before the previous literal \
+				 match, quitting to avoid quadratic behavior",
+                at,
+            );
+            return Err(RetryError::Quadratic(RetryQuadraticError::new()));
+        }
+    }
+    dfa_eoi_rev(dfa, input, &mut sid, &mut mat)?;
+    Ok(mat)
+}
+
+#[cfg(feature = "hybrid")]
+pub(crate) fn hybrid_try_search_half_rev(
+    dfa: &crate::hybrid::dfa::DFA,
+    cache: &mut crate::hybrid::dfa::Cache,
+    input: &Input<'_>,
+    min_start: usize,
+) -> Result<Option<HalfMatch>, RetryError> {
+    let mut mat = None;
+    let mut sid = dfa.start_state_reverse(cache, input)?;
+    if input.start() == input.end() {
+        hybrid_eoi_rev(dfa, cache, input, &mut sid, &mut mat)?;
+        return Ok(mat);
+    }
+    let mut at = input.end() - 1;
+    loop {
+        sid = dfa
+            .next_state(cache, sid, input.haystack()[at])
+            .map_err(|_| MatchError::gave_up(at))?;
+        if sid.is_tagged() {
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                // Since reverse searches report the beginning of a
+                // match and the beginning is inclusive (not exclusive
+                // like the end of a match), we add 1 to make it
+                // inclusive.
+                mat = Some(HalfMatch::new(pattern, at + 1));
+            } else if sid.is_dead() {
+                return Ok(mat);
+            } else if sid.is_quit() {
+                if mat.is_some() {
+                    return Ok(mat);
+                }
+                return Err(MatchError::quit(input.haystack()[at], at).into());
+            }
+        }
+        if at == input.start() {
+            break;
+        }
+        at -= 1;
+        if at < min_start {
+            trace!(
+                "reached position {} which is before the previous literal \
+				 match, quitting to avoid quadratic behavior",
+                at,
+            );
+            return Err(RetryError::Quadratic(RetryQuadraticError::new()));
+        }
+    }
+    hybrid_eoi_rev(dfa, cache, input, &mut sid, &mut mat)?;
+    Ok(mat)
+}
+
+#[cfg(feature = "dfa-build")]
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn dfa_eoi_rev(
+    dfa: &crate::dfa::dense::DFA<alloc::vec::Vec<u32>>,
+    input: &Input<'_>,
+    sid: &mut crate::util::primitives::StateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    use crate::dfa::Automaton;
+
+    let sp = input.get_span();
+    if sp.start > 0 {
+        let byte = input.haystack()[sp.start - 1];
+        *sid = dfa.next_state(*sid, byte);
+        if dfa.is_match_state(*sid) {
+            let pattern = dfa.match_pattern(*sid, 0);
+            *mat = Some(HalfMatch::new(pattern, sp.start));
+        } else if dfa.is_quit_state(*sid) {
+            if mat.is_some() {
+                return Ok(());
+            }
+            return Err(MatchError::quit(byte, sp.start - 1));
+        }
+    } else {
+        *sid = dfa.next_eoi_state(*sid);
+        if dfa.is_match_state(*sid) {
+            let pattern = dfa.match_pattern(*sid, 0);
+            *mat = Some(HalfMatch::new(pattern, 0));
+        }
+        // N.B. We don't have to check 'is_quit' here because the EOI
+        // transition can never lead to a quit state.
+        debug_assert!(!dfa.is_quit_state(*sid));
+    }
+    Ok(())
+}
+
+#[cfg(feature = "hybrid")]
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn hybrid_eoi_rev(
+    dfa: &crate::hybrid::dfa::DFA,
+    cache: &mut crate::hybrid::dfa::Cache,
+    input: &Input<'_>,
+    sid: &mut crate::hybrid::LazyStateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    if sp.start > 0 {
+        let byte = input.haystack()[sp.start - 1];
+        *sid = dfa
+            .next_state(cache, *sid, byte)
+            .map_err(|_| MatchError::gave_up(sp.start))?;
+        if sid.is_match() {
+            let pattern = dfa.match_pattern(cache, *sid, 0);
+            *mat = Some(HalfMatch::new(pattern, sp.start));
+        } else if sid.is_quit() {
+            if mat.is_some() {
+                return Ok(());
+            }
+            return Err(MatchError::quit(byte, sp.start - 1));
+        }
+    } else {
+        *sid = dfa
+            .next_eoi_state(cache, *sid)
+            .map_err(|_| MatchError::gave_up(sp.start))?;
+        if sid.is_match() {
+            let pattern = dfa.match_pattern(cache, *sid, 0);
+            *mat = Some(HalfMatch::new(pattern, 0));
+        }
+        // N.B. We don't have to check 'is_quit' here because the EOI
+        // transition can never lead to a quit state.
+        debug_assert!(!sid.is_quit());
+    }
+    Ok(())
+}
diff --git a/regex-automata/src/meta/literal.rs b/regex-automata/src/meta/literal.rs
new file mode 100644
index 0000000000..a68b93b7a6
--- /dev/null
+++ b/regex-automata/src/meta/literal.rs
@@ -0,0 +1,81 @@
+use alloc::{vec, vec::Vec};
+
+use regex_syntax::hir::Hir;
+
+use crate::{meta::regex::RegexInfo, util::search::MatchKind};
+
+/// Pull out an alternation of literals from the given sequence of HIR
+/// expressions.
+///
+/// There are numerous ways for this to fail. Generally, this only applies
+/// to regexes of the form 'foo|bar|baz|...|quux'. It can also fail if there
+/// are "too few" alternates, in which case, the regex engine is likely faster.
+///
+/// And currently, this only returns something when 'hirs.len() == 1'.
+pub(crate) fn alternation_literals(
+    info: &RegexInfo,
+    hirs: &[&Hir],
+) -> Option<Vec<Vec<u8>>> {
+    use regex_syntax::hir::{HirKind, Literal};
+
+    // Might as well skip the work below if we know we can't build an
+    // Aho-Corasick searcher.
+    if !cfg!(feature = "perf-literal-multisubstring") {
+        return None;
+    }
+    // This is pretty hacky, but basically, if `is_alternation_literal` is
+    // true, then we can make several assumptions about the structure of our
+    // HIR. This is what justifies the `unreachable!` statements below.
+    if hirs.len() != 1
+        || !info.props()[0].look_set().is_empty()
+        || info.props()[0].explicit_captures_len() > 0
+        || !info.props()[0].is_alternation_literal()
+        || info.config().get_match_kind() != MatchKind::LeftmostFirst
+    {
+        return None;
+    }
+    let hir = &hirs[0];
+    let alts = match *hir.kind() {
+        HirKind::Alternation(ref alts) => alts,
+        _ => return None, // one literal isn't worth it
+    };
+
+    let mut lits = vec![];
+    for alt in alts {
+        let mut lit = vec![];
+        match *alt.kind() {
+            HirKind::Literal(Literal(ref bytes)) => {
+                lit.extend_from_slice(bytes)
+            }
+            HirKind::Concat(ref exprs) => {
+                for e in exprs {
+                    match *e.kind() {
+                        HirKind::Literal(Literal(ref bytes)) => {
+                            lit.extend_from_slice(bytes);
+                        }
+                        _ => unreachable!("expected literal, got {:?}", e),
+                    }
+                }
+            }
+            _ => unreachable!("expected literal or concat, got {:?}", alt),
+        }
+        lits.push(lit);
+    }
+    // Why do this? Well, when the number of literals is small, it's likely
+    // that we'll use the lazy DFA which is in turn likely to be faster than
+    // Aho-Corasick in such cases. Primarily because Aho-Corasick doesn't have
+    // a "lazy DFA" but either a contiguous NFA or a full DFA. We rarely use
+    // the latter because it is so hungry (in time and space), and the former
+    // is decently fast, but not as fast as a well oiled lazy DFA.
+    //
+    // However, once the number starts getting large, the lazy DFA is likely
+    // to start thrashing because of the modest default cache size. When
+    // exactly does this happen? Dunno. But at whatever point that is (we make
+    // a guess below based on ad hoc benchmarking), we'll want to cut over to
+    // Aho-Corasick, where even the contiguous NFA is likely to do much better.
+    if lits.len() < 3000 {
+        debug!("skipping Aho-Corasick because there are too few literals");
+        return None;
+    }
+    Some(lits)
+}
diff --git a/regex-automata/src/meta/mod.rs b/regex-automata/src/meta/mod.rs
new file mode 100644
index 0000000000..01f430fcb7
--- /dev/null
+++ b/regex-automata/src/meta/mod.rs
@@ -0,0 +1,62 @@
+/*!
+Provides a regex matcher that composes several other regex matchers
+automatically.
+
+This module is home to a meta [`Regex`], which provides a convenient high
+level API for executing regular expressions in linear time.
+
+# Comparison with the `regex` crate
+
+A meta `Regex` is the implementation used directly by the `regex` crate.
+Indeed, the `regex` crate API is essentially just a light wrapper over a meta
+`Regex`. This means that if you need the full flexibility offered by this
+API, then you should be able to switch to using this API directly without
+any changes in match semantics or syntax. However, there are some API level
+differences:
+
+* The `regex` crate API returns match objects that include references to the
+haystack itself, which in turn makes it easy to access the matching strings
+without having to slice the haystack yourself. In contrast, a meta `Regex`
+returns match objects that only have offsets in them.
+* At time of writing, a meta `Regex` doesn't have some of the convenience
+routines that the `regex` crate has, such as replacements. Note though that
+[`Captures::interpolate_string`](crate::util::captures::Captures::interpolate_string)
+will handle the replacement string interpolation for you.
+* A meta `Regex` supports the [`Input`](crate::Input) abstraction, which
+provides a way to configure a search in more ways than is supported by the
+`regex` crate. For example, [`Input::anchored`](crate::Input::anchored) can
+be used to run an anchored search, regardless of whether the pattern is itself
+anchored with a `^`.
+* A meta `Regex` supports multi-pattern searching everywhere.
+Indeed, every [`Match`](crate::Match) returned by the search APIs
+include a [`PatternID`](crate::PatternID) indicating which pattern
+matched. In the single pattern case, all matches correspond to
+[`PatternID::ZERO`](crate::PatternID::ZERO). In contrast, the `regex` crate
+has distinct `Regex` and a `RegexSet` APIs. The former only supports a single
+pattern, while the latter supports multiple patterns but cannot report the
+offsets of a match.
+* A meta `Regex` provides the explicit capability of bypassing its internal
+memory pool for automatically acquiring mutable scratch space required by its
+internal regex engines. Namely, a [`Cache`] can be explicitly provided to lower
+level routines such as [`Regex::search_with`].
+
+*/
+
+pub use self::{
+    error::BuildError,
+    regex::{
+        Builder, Cache, CapturesMatches, Config, FindMatches, Regex, Split,
+        SplitN,
+    },
+};
+
+mod error;
+#[cfg(any(feature = "dfa-build", feature = "hybrid"))]
+mod limited;
+mod literal;
+mod regex;
+mod reverse_inner;
+#[cfg(any(feature = "dfa-build", feature = "hybrid"))]
+mod stopat;
+mod strategy;
+mod wrappers;
diff --git a/regex-automata/src/meta/regex.rs b/regex-automata/src/meta/regex.rs
new file mode 100644
index 0000000000..cc6ac78cb8
--- /dev/null
+++ b/regex-automata/src/meta/regex.rs
@@ -0,0 +1,3560 @@
+use core::{
+    borrow::Borrow,
+    panic::{RefUnwindSafe, UnwindSafe},
+};
+
+use alloc::{boxed::Box, sync::Arc, vec, vec::Vec};
+
+use regex_syntax::{
+    ast,
+    hir::{self, Hir},
+};
+
+use crate::{
+    meta::{
+        error::BuildError,
+        strategy::{self, Strategy},
+        wrappers,
+    },
+    util::{
+        captures::{Captures, GroupInfo},
+        iter,
+        pool::{Pool, PoolGuard},
+        prefilter::Prefilter,
+        primitives::{NonMaxUsize, PatternID},
+        search::{HalfMatch, Input, Match, MatchKind, PatternSet, Span},
+    },
+};
+
+/// A type alias for our pool of meta::Cache that fixes the type parameters to
+/// what we use for the meta regex below.
+type CachePool = Pool<Cache, CachePoolFn>;
+
+/// Same as above, but for the guard returned by a pool.
+type CachePoolGuard<'a> = PoolGuard<'a, Cache, CachePoolFn>;
+
+/// The type of the closure we use to create new caches. We need to spell out
+/// all of the marker traits or else we risk leaking !MARKER impls.
+type CachePoolFn =
+    Box<dyn Fn() -> Cache + Send + Sync + UnwindSafe + RefUnwindSafe>;
+
+/// A regex matcher that works by composing several other regex matchers
+/// automatically.
+///
+/// In effect, a meta regex papers over a lot of the quirks or performance
+/// problems in each of the regex engines in this crate. Its goal is to provide
+/// an infallible and simple API that "just does the right thing" in the common
+/// case.
+///
+/// A meta regex is the implementation of a `Regex` in the `regex` crate.
+/// Indeed, the `regex` crate API is essentially just a light wrapper over
+/// this type. This includes the `regex` crate's `RegexSet` API!
+///
+/// # Composition
+///
+/// This is called a "meta" matcher precisely because it uses other regex
+/// matchers to provide a convenient high level regex API. Here are some
+/// examples of how other regex matchers are composed:
+///
+/// * When calling [`Regex::captures`], instead of immediately
+/// running a slower but more capable regex engine like the
+/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM), the meta regex engine
+/// will usually first look for the bounds of a match with a higher throughput
+/// regex engine like a [lazy DFA](crate::hybrid). Only when a match is found
+/// is a slower engine like `PikeVM` used to find the matching span for each
+/// capture group.
+/// * While higher throughout engines like the lazy DFA cannot handle
+/// Unicode word boundaries in general, they can still be used on pure ASCII
+/// haystacks by pretending that Unicode word boundaries are just plain ASCII
+/// word boundaries. However, if a haystack is not ASCII, the meta regex engine
+/// will automatically switch to a (possibly slower) regex engine that supports
+/// Unicode word boundaries in general.
+/// * In some cases where a regex pattern is just a simple literal or a small
+/// set of literals, an actual regex engine won't be used at all. Instead,
+/// substring or multi-substring search algorithms will be employed.
+///
+/// There are many other forms of composition happening too, but the above
+/// should give a general idea. In particular, it may perhaps be surprising
+/// that *multiple* regex engines might get executed for a single search. That
+/// is, the decision of what regex engine to use is not _just_ based on the
+/// pattern, but also based on the dynamic execution of the search itself.
+///
+/// The primary reason for this composition is performance. The fundamental
+/// tension is that the faster engines tend to be less capable, and the more
+/// capable engines tend to be slower.
+///
+/// Note that the forms of composition that are allowed are determined by
+/// compile time crate features and configuration. For example, if the `hybrid`
+/// feature isn't enabled, or if [`Config::hybrid`] has been disabled, then the
+/// meta regex engine will never use a lazy DFA.
+///
+/// # Synchronization and cloning
+///
+/// Most of the regex engines in this crate require some kind of mutable
+/// "scratch" space to read and write from while performing a search. Since
+/// a meta regex composes these regex engines, a meta regex also requires
+/// mutable scratch space. This scratch space is called a [`Cache`].
+///
+/// Most regex engines _also_ usually have a read-only component, typically
+/// a [Thompson `NFA`](crate::nfa::thompson::NFA).
+///
+/// In order to make the `Regex` API convenient, most of the routines hide
+/// the fact that a `Cache` is needed at all. To achieve this, a [memory
+/// pool](crate::util::pool::Pool) is used internally to retrieve `Cache`
+/// values in a thread safe way that also permits reuse. This in turn implies
+/// that every such search call requires some form of synchronization. Usually
+/// this synchronization is fast enough to not notice, but in some cases, it
+/// can be a bottleneck. This typically occurs when all of the following are
+/// true:
+///
+/// * The same `Regex` is shared across multiple threads simultaneously,
+/// usually via a [`util::lazy::Lazy`](crate::util::lazy::Lazy) or something
+/// similar from the `once_cell` or `lazy_static` crates.
+/// * The primary unit of work in each thread is a regex search.
+/// * Searches are run on very short haystacks.
+///
+/// This particular case can lead to high contention on the pool used by a
+/// `Regex` internally, which can in turn increase latency to a noticeable
+/// effect. This cost can be mitigated in one of the following ways:
+///
+/// * Use a distinct copy of a `Regex` in each thread, usually by cloning it.
+/// Cloning a `Regex` _does not_ do a deep copy of its read-only component.
+/// But it does lead to each `Regex` having its own memory pool, which in
+/// turn eliminates the problem of contention. In general, this technique should
+/// not result in any additional memory usage when compared to sharing the same
+/// `Regex` across multiple threads simultaneously.
+/// * Use lower level APIs, like [`Regex::search_with`], which permit passing
+/// a `Cache` explicitly. In this case, it is up to you to determine how best
+/// to provide a `Cache`. For example, you might put a `Cache` in thread-local
+/// storage if your use case allows for it.
+///
+/// Overall, this is an issue that happens rarely in practice, but it can
+/// happen.
+///
+/// # Warning: spin-locks may be used in alloc-only mode
+///
+/// When this crate is built without the `std` feature and the high level APIs
+/// on a `Regex` are used, then a spin-lock will be used to synchronize access
+/// to an internal pool of `Cache` values. This may be undesirable because
+/// a spin-lock is [effectively impossible to implement correctly in user
+/// space][spinlocks-are-bad]. That is, more concretely, the spin-lock could
+/// result in a deadlock.
+///
+/// [spinlocks-are-bad]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html
+///
+/// If one wants to avoid the use of spin-locks when the `std` feature is
+/// disabled, then you must use APIs that accept a `Cache` value explicitly.
+/// For example, [`Regex::search_with`].
+///
+/// # Example
+///
+/// ```
+/// use regex_automata::meta::Regex;
+///
+/// let re = Regex::new(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$")?;
+/// assert!(re.is_match("2010-03-14"));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: anchored search
+///
+/// This example shows how to use [`Input::anchored`] to run an anchored
+/// search, even when the regex pattern itself isn't anchored. An anchored
+/// search guarantees that if a match is found, then the start offset of the
+/// match corresponds to the offset at which the search was started.
+///
+/// ```
+/// use regex_automata::{meta::Regex, Anchored, Input, Match};
+///
+/// let re = Regex::new(r"\bfoo\b")?;
+/// let input = Input::new("xx foo xx").range(3..).anchored(Anchored::Yes);
+/// // The offsets are in terms of the original haystack.
+/// assert_eq!(Some(Match::must(0, 3..6)), re.find(input));
+///
+/// // Notice that no match occurs here, because \b still takes the
+/// // surrounding context into account, even if it means looking back
+/// // before the start of your search.
+/// let hay = "xxfoo xx";
+/// let input = Input::new(hay).range(2..).anchored(Anchored::Yes);
+/// assert_eq!(None, re.find(input));
+/// // Indeed, you cannot achieve the above by simply slicing the
+/// // haystack itself, since the regex engine can't see the
+/// // surrounding context. This is why 'Input' permits setting
+/// // the bounds of a search!
+/// let input = Input::new(&hay[2..]).anchored(Anchored::Yes);
+/// // WRONG!
+/// assert_eq!(Some(Match::must(0, 0..3)), re.find(input));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: earliest search
+///
+/// This example shows how to use [`Input::earliest`] to run a search that
+/// might stop before finding the typical leftmost match.
+///
+/// ```
+/// use regex_automata::{meta::Regex, Anchored, Input, Match};
+///
+/// let re = Regex::new(r"[a-z]{3}|b")?;
+/// let input = Input::new("abc").earliest(true);
+/// assert_eq!(Some(Match::must(0, 1..2)), re.find(input));
+///
+/// // Note that "earliest" isn't really a match semantic unto itself.
+/// // Instead, it is merely an instruction to whatever regex engine
+/// // gets used internally to quit as soon as it can. For example,
+/// // this regex uses a different search technique, and winds up
+/// // producing a different (but valid) match!
+/// let re = Regex::new(r"abc|b")?;
+/// let input = Input::new("abc").earliest(true);
+/// assert_eq!(Some(Match::must(0, 0..3)), re.find(input));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: change the line terminator
+///
+/// This example shows how to enable multi-line mode by default and change
+/// the line terminator to the NUL byte:
+///
+/// ```
+/// use regex_automata::{meta::Regex, util::syntax, Match};
+///
+/// let re = Regex::builder()
+///     .syntax(syntax::Config::new().multi_line(true))
+///     .configure(Regex::config().line_terminator(b'\x00'))
+///     .build(r"^foo$")?;
+/// let hay = "\x00foo\x00";
+/// assert_eq!(Some(Match::must(0, 1..4)), re.find(hay));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Debug)]
+pub struct Regex {
+    /// The actual regex implementation.
+    imp: Arc<RegexI>,
+    /// A thread safe pool of caches.
+    ///
+    /// For the higher level search APIs, a `Cache` is automatically plucked
+    /// from this pool before running a search. The lower level `with` methods
+    /// permit the caller to provide their own cache, thereby bypassing
+    /// accesses to this pool.
+    ///
+    /// Note that we put this outside the `Arc` so that cloning a `Regex`
+    /// results in creating a fresh `CachePool`. This in turn permits callers
+    /// to clone regexes into separate threads where each such regex gets
+    /// the pool's "thread owner" optimization. Otherwise, if one shares the
+    /// `Regex` directly, then the pool will go through a slower mutex path for
+    /// all threads except for the "owner."
+    pool: CachePool,
+}
+
+/// The internal implementation of `Regex`, split out so that it can be wrapped
+/// in an `Arc`.
+#[derive(Debug)]
+struct RegexI {
+    /// The core matching engine.
+    ///
+    /// Why is this reference counted when RegexI is already wrapped in an Arc?
+    /// Well, we need to capture this in a closure to our `Pool` below in order
+    /// to create new `Cache` values when needed. So since it needs to be in
+    /// two places, we make it reference counted.
+    ///
+    /// We make `RegexI` itself reference counted too so that `Regex` itself
+    /// stays extremely small and very cheap to clone.
+    strat: Arc<dyn Strategy>,
+    /// Metadata about the regexes driving the strategy. The metadata is also
+    /// usually stored inside the strategy too, but we put it here as well
+    /// so that we can get quick access to it (without virtual calls) before
+    /// executing the regex engine. For example, we use this metadata to
+    /// detect a subset of cases where we know a match is impossible, and can
+    /// thus avoid calling into the strategy at all.
+    ///
+    /// Since `RegexInfo` is stored in multiple places, it is also reference
+    /// counted.
+    info: RegexInfo,
+}
+
+/// Convenience constructors for a `Regex` using the default configuration.
+impl Regex {
+    /// Builds a `Regex` from a single pattern string using the default
+    /// configuration.
+    ///
+    /// If there was a problem parsing the pattern or a problem turning it into
+    /// a regex matcher, then an error is returned.
+    ///
+    /// If you want to change the configuration of a `Regex`, use a [`Builder`]
+    /// with a [`Config`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new(r"(?Rm)^foo$")?;
+    /// let hay = "\r\nfoo\r\n";
+    /// assert_eq!(Some(Match::must(0, 2..5)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new(pattern: &str) -> Result<Regex, BuildError> {
+        Regex::builder().build(pattern)
+    }
+
+    /// Builds a `Regex` from many pattern strings using the default
+    /// configuration.
+    ///
+    /// If there was a problem parsing any of the patterns or a problem turning
+    /// them into a regex matcher, then an error is returned.
+    ///
+    /// If you want to change the configuration of a `Regex`, use a [`Builder`]
+    /// with a [`Config`].
+    ///
+    /// # Example: simple lexer
+    ///
+    /// This simplistic example leverages the multi-pattern support to build a
+    /// simple little lexer. The pattern ID in the match tells you which regex
+    /// matched, which in turn might be used to map back to the "type" of the
+    /// token returned by the lexer.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new_many(&[
+    ///     r"[[:space:]]",
+    ///     r"[A-Za-z0-9][A-Za-z0-9_]+",
+    ///     r"->",
+    ///     r".",
+    /// ])?;
+    /// let haystack = "fn is_boss(bruce: i32, springsteen: String) -> bool;";
+    /// let matches: Vec<Match> = re.find_iter(haystack).collect();
+    /// assert_eq!(matches, vec![
+    ///     Match::must(1, 0..2),   // 'fn'
+    ///     Match::must(0, 2..3),   // ' '
+    ///     Match::must(1, 3..10),  // 'is_boss'
+    ///     Match::must(3, 10..11), // '('
+    ///     Match::must(1, 11..16), // 'bruce'
+    ///     Match::must(3, 16..17), // ':'
+    ///     Match::must(0, 17..18), // ' '
+    ///     Match::must(1, 18..21), // 'i32'
+    ///     Match::must(3, 21..22), // ','
+    ///     Match::must(0, 22..23), // ' '
+    ///     Match::must(1, 23..34), // 'springsteen'
+    ///     Match::must(3, 34..35), // ':'
+    ///     Match::must(0, 35..36), // ' '
+    ///     Match::must(1, 36..42), // 'String'
+    ///     Match::must(3, 42..43), // ')'
+    ///     Match::must(0, 43..44), // ' '
+    ///     Match::must(2, 44..46), // '->'
+    ///     Match::must(0, 46..47), // ' '
+    ///     Match::must(1, 47..51), // 'bool'
+    ///     Match::must(3, 51..52), // ';'
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// One can write a lexer like the above using a regex like
+    /// `(?P<space>[[:space:]])|(?P<ident>[A-Za-z0-9][A-Za-z0-9_]+)|...`,
+    /// but then you need to ask whether capture group matched to determine
+    /// which branch in the regex matched, and thus, which token the match
+    /// corresponds to. In contrast, the above example includes the pattern ID
+    /// in the match. There's no need to use capture groups at all.
+    ///
+    /// # Example: finding the pattern that caused an error
+    ///
+    /// When a syntax error occurs, it is possible to ask which pattern
+    /// caused the syntax error.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, PatternID};
+    ///
+    /// let err = Regex::new_many(&["a", "b", r"\p{Foo}", "c"]).unwrap_err();
+    /// assert_eq!(Some(PatternID::must(2)), err.pattern());
+    /// ```
+    ///
+    /// # Example: zero patterns is valid
+    ///
+    /// Building a regex with zero patterns results in a regex that never
+    /// matches anything. Because this routine is generic, passing an empty
+    /// slice usually requires a turbo-fish (or something else to help type
+    /// inference).
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::new_many::<&str>(&[])?;
+    /// assert_eq!(None, re.find(""));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        Regex::builder().build_many(patterns)
+    }
+
+    /// Return a default configuration for a `Regex`.
+    ///
+    /// This is a convenience routine to avoid needing to import the [`Config`]
+    /// type when customizing the construction of a `Regex`.
+    ///
+    /// # Example: lower the NFA size limit
+    ///
+    /// In some cases, the default size limit might be too big. The size limit
+    /// can be lowered, which will prevent large regex patterns from compiling.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config().nfa_size_limit(Some(20 * (1<<10))))
+    ///     // Not even 20KB is enough to build a single large Unicode class!
+    ///     .build(r"\pL");
+    /// assert!(result.is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a builder for configuring the construction of a `Regex`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example: change the line terminator
+    ///
+    /// This example shows how to enable multi-line mode by default and change
+    /// the line terminator to the NUL byte:
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().multi_line(true))
+    ///     .configure(Regex::config().line_terminator(b'\x00'))
+    ///     .build(r"^foo$")?;
+    /// let hay = "\x00foo\x00";
+    /// assert_eq!(Some(Match::must(0, 1..4)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+}
+
+/// High level convenience routines for using a regex to search a haystack.
+impl Regex {
+    /// Returns true if and only if this regex matches the given haystack.
+    ///
+    /// This routine may short circuit if it knows that scanning future input
+    /// will never lead to a different result. (Consider how this might make
+    /// a difference given the regex `a+` on the haystack `aaaaaaaaaaaaaaa`.
+    /// This routine _may_ stop after it sees the first `a`, but routines like
+    /// `find` need to continue searching because `+` is greedy by default.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new("foo[0-9]+bar")?;
+    ///
+    /// assert!(re.is_match("foo12345bar"));
+    /// assert!(!re.is_match("foobar"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: consistency with search APIs
+    ///
+    /// `is_match` is guaranteed to return `true` whenever `find` returns a
+    /// match. This includes searches that are executed entirely within a
+    /// codepoint:
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input};
+    ///
+    /// let re = Regex::new("a*")?;
+    ///
+    /// // This doesn't match because the default configuration bans empty
+    /// // matches from splitting a codepoint.
+    /// assert!(!re.is_match(Input::new("☃").span(1..2)));
+    /// assert_eq!(None, re.find(Input::new("☃").span(1..2)));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Notice that when UTF-8 mode is disabled, then the above reports a
+    /// match because the restriction against zero-width matches that split a
+    /// codepoint has been lifted:
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().utf8_empty(false))
+    ///     .build("a*")?;
+    ///
+    /// assert!(re.is_match(Input::new("☃").span(1..2)));
+    /// assert_eq!(
+    ///     Some(Match::must(0, 1..1)),
+    ///     re.find(Input::new("☃").span(1..2)),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// A similar idea applies when using line anchors with CRLF mode enabled,
+    /// which prevents them from matching between a `\r` and a `\n`.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, Match};
+    ///
+    /// let re = Regex::new(r"(?Rm:$)")?;
+    /// assert!(!re.is_match(Input::new("\r\n").span(1..1)));
+    /// // A regular line anchor, which only considers \n as a
+    /// // line terminator, will match.
+    /// let re = Regex::new(r"(?m:$)")?;
+    /// assert!(re.is_match(Input::new("\r\n").span(1..1)));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match<'h, I: Into<Input<'h>>>(&self, input: I) -> bool {
+        let input = input.into().earliest(true);
+        self.search_half(&input).is_some()
+    }
+
+    /// Executes a leftmost search and returns the first match that is found,
+    /// if one exists.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// assert_eq!(Some(Match::must(0, 0..8)), re.find("foo12345"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find<'h, I: Into<Input<'h>>>(&self, input: I) -> Option<Match> {
+        self.search(&input.into())
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Span};
+    ///
+    /// let re = Regex::new(r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$")?;
+    /// let mut caps = re.create_captures();
+    ///
+    /// re.captures("2010-03-14", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(Span::from(0..4)), caps.get_group(1));
+    /// assert_eq!(Some(Span::from(5..7)), caps.get_group(2));
+    /// assert_eq!(Some(Span::from(8..10)), caps.get_group(3));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn captures<'h, I: Into<Input<'h>>>(
+        &self,
+        input: I,
+        caps: &mut Captures,
+    ) {
+        self.search_captures(&input.into(), caps)
+    }
+
+    /// Returns an iterator over all non-overlapping leftmost matches in
+    /// the given haystack. If no match exists, then the iterator yields no
+    /// elements.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new("foo[0-9]+")?;
+    /// let haystack = "foo1 foo12 foo123";
+    /// let matches: Vec<Match> = re.find_iter(haystack).collect();
+    /// assert_eq!(matches, vec![
+    ///     Match::must(0, 0..4),
+    ///     Match::must(0, 5..10),
+    ///     Match::must(0, 11..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        input: I,
+    ) -> FindMatches<'r, 'h> {
+        let cache = self.pool.get();
+        let it = iter::Searcher::new(input.into());
+        FindMatches { re: self, cache, it }
+    }
+
+    /// Returns an iterator over all non-overlapping `Captures` values. If no
+    /// match exists, then the iterator yields no elements.
+    ///
+    /// This yields the same matches as [`Regex::find_iter`], but it includes
+    /// the spans of all capturing groups that participate in each match.
+    ///
+    /// **Tip:** See [`util::iter::Searcher`](crate::util::iter::Searcher) for
+    /// how to correctly iterate over all matches in a haystack while avoiding
+    /// the creation of a new `Captures` value for every match. (Which you are
+    /// forced to do with an `Iterator`.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Span};
+    ///
+    /// let re = Regex::new("foo(?P<numbers>[0-9]+)")?;
+    ///
+    /// let haystack = "foo1 foo12 foo123";
+    /// let matches: Vec<Span> = re
+    ///     .captures_iter(haystack)
+    ///     // The unwrap is OK since 'numbers' matches if the pattern matches.
+    ///     .map(|caps| caps.get_group_by_name("numbers").unwrap())
+    ///     .collect();
+    /// assert_eq!(matches, vec![
+    ///     Span::from(3..4),
+    ///     Span::from(8..10),
+    ///     Span::from(14..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn captures_iter<'r, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        input: I,
+    ) -> CapturesMatches<'r, 'h> {
+        let cache = self.pool.get();
+        let caps = self.create_captures();
+        let it = iter::Searcher::new(input.into());
+        CapturesMatches { re: self, cache, caps, it }
+    }
+
+    /// Returns an iterator of spans of the haystack given, delimited by a
+    /// match of the regex. Namely, each element of the iterator corresponds to
+    /// a part of the haystack that *isn't* matched by the regular expression.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"[ \t]+")?;
+    /// let hay = "a b \t  c\td    e";
+    /// let fields: Vec<&str> = re.split(hay).map(|span| &hay[span]).collect();
+    /// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: more cases
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r" ")?;
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a", "little", "lamb"]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["lion", "", "tiger", "leopard"]);
+    ///
+    /// let re = Regex::new(r"::")?;
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["lion", "tiger", "leopard"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// If a haystack contains multiple contiguous matches, you will end up
+    /// with empty spans yielded by the iterator:
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "XXXXaXXbXc";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    ///
+    /// let re = Regex::new(r"/")?;
+    /// let hay = "(///)";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["(", "", "", ")"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Separators at the start or end of a haystack are neighbored by empty
+    /// spans.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"0")?;
+    /// let hay = "010";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["", "1", ""]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// When the empty string is used as a regex, it splits at every valid
+    /// UTF-8 boundary by default (which includes the beginning and end of the
+    /// haystack):
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"")?;
+    /// let hay = "rust";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["", "r", "u", "s", "t", ""]);
+    ///
+    /// // Splitting by an empty string is UTF-8 aware by default!
+    /// let re = Regex::new(r"")?;
+    /// let hay = "☃";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["", "☃", ""]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// But note that UTF-8 mode for empty strings can be disabled, which will
+    /// then result in a match at every byte offset in the haystack,
+    /// including between every UTF-8 code unit.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().utf8_empty(false))
+    ///     .build(r"")?;
+    /// let hay = "☃".as_bytes();
+    /// let got: Vec<&[u8]> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec![
+    ///     // Writing byte string slices is just brutal. The problem is that
+    ///     // b"foo" has type &[u8; 3] instead of &[u8].
+    ///     &[][..], &[b'\xE2'][..], &[b'\x98'][..], &[b'\x83'][..], &[][..],
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Contiguous separators (commonly shows up with whitespace), can lead to
+    /// possibly surprising behavior. For example, this code is correct:
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r" ")?;
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// It does *not* give you `["a", "b", "c"]`. For that behavior, you'd want
+    /// to match contiguous space characters:
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r" +")?;
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).map(|sp| &hay[sp]).collect();
+    /// // N.B. This does still include a leading empty span because ' +'
+    /// // matches at the beginning of the haystack.
+    /// assert_eq!(got, vec!["", "a", "b", "c"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn split<'r, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        input: I,
+    ) -> Split<'r, 'h> {
+        Split { finder: self.find_iter(input), last: 0 }
+    }
+
+    /// Returns an iterator of at most `limit` spans of the haystack given,
+    /// delimited by a match of the regex. (A `limit` of `0` will return no
+    /// spans.) Namely, each element of the iterator corresponds to a part
+    /// of the haystack that *isn't* matched by the regular expression. The
+    /// remainder of the haystack that is not split will be the last element in
+    /// the iterator.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some haystack:
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let hay = "Hey! How are you?";
+    /// let fields: Vec<&str> =
+    ///     re.splitn(hay, 3).map(|span| &hay[span]).collect();
+    /// assert_eq!(fields, vec!["Hey", "How", "are you?"]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Examples: more cases
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r" ")?;
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.splitn(hay, 3).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a little lamb"]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "";
+    /// let got: Vec<&str> = re.splitn(hay, 3).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.splitn(hay, 3).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["lion", "", "tigerXleopard"]);
+    ///
+    /// let re = Regex::new(r"::")?;
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.splitn(hay, 2).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["lion", "tiger::leopard"]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 1).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["abcXdef"]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "abcdef";
+    /// let got: Vec<&str> = re.splitn(hay, 2).map(|sp| &hay[sp]).collect();
+    /// assert_eq!(got, vec!["abcdef"]);
+    ///
+    /// let re = Regex::new(r"X")?;
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 0).map(|sp| &hay[sp]).collect();
+    /// assert!(got.is_empty());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn splitn<'r, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        input: I,
+        limit: usize,
+    ) -> SplitN<'r, 'h> {
+        SplitN { splits: self.split(input), limit }
+    }
+}
+
+/// Lower level search routines that give more control.
+impl Regex {
+    /// Returns the start and end offset of the leftmost match. If no match
+    /// exists, then `None` is returned.
+    ///
+    /// This is like [`Regex::find`] but, but it accepts a concrete `&Input`
+    /// instead of an `Into<Input>`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, Match};
+    ///
+    /// let re = Regex::new(r"Samwise|Sam")?;
+    /// let input = Input::new(
+    ///     "one of the chief characters, Samwise the Brave",
+    /// );
+    /// assert_eq!(Some(Match::must(0, 29..36)), re.search(&input));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search(&self, input: &Input<'_>) -> Option<Match> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        let mut guard = self.pool.get();
+        let result = self.imp.strat.search(&mut guard, input);
+        // We do this dance with the guard and explicitly put it back in the
+        // pool because it seems to result in better codegen. If we let the
+        // guard's Drop impl put it back in the pool, then functions like
+        // ptr::drop_in_place get called and they *don't* get inlined. This
+        // isn't usually a big deal, but in latency sensitive benchmarks the
+        // extra function call can matter.
+        //
+        // I used `rebar measure -f '^grep/every-line$' -e meta` to measure
+        // the effects here.
+        //
+        // Note that this doesn't eliminate the latency effects of using the
+        // pool. There is still some (minor) cost for the "thread owner" of the
+        // pool. (i.e., The thread that first calls a regex search routine.)
+        // However, for other threads using the regex, the pool access can be
+        // quite expensive as it goes through a mutex. Callers can avoid this
+        // by either cloning the Regex (which creates a distinct copy of the
+        // pool), or callers can use the lower level APIs that accept a 'Cache'
+        // directly and do their own handling.
+        PoolGuard::put(guard);
+        result
+    }
+
+    /// Returns the end offset of the leftmost match. If no match exists, then
+    /// `None` is returned.
+    ///
+    /// This is distinct from [`Regex::search`] in that it only returns the end
+    /// of a match and not the start of the match. Depending on a variety of
+    /// implementation details, this _may_ permit the regex engine to do less
+    /// overall work. For example, if a DFA is being used to execute a search,
+    /// then the start of a match usually requires running a separate DFA in
+    /// reverse to the find the start of a match. If one only needs the end of
+    /// a match, then the separate reverse scan to find the start of a match
+    /// can be skipped. (Note that the reverse scan is avoided even when using
+    /// `Regex::search` when possible, for example, in the case of an anchored
+    /// search.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, HalfMatch};
+    ///
+    /// let re = Regex::new(r"Samwise|Sam")?;
+    /// let input = Input::new(
+    ///     "one of the chief characters, Samwise the Brave",
+    /// );
+    /// assert_eq!(Some(HalfMatch::must(0, 36)), re.search_half(&input));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_half(&self, input: &Input<'_>) -> Option<HalfMatch> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        let mut guard = self.pool.get();
+        let result = self.imp.strat.search_half(&mut guard, input);
+        // See 'Regex::search' for why we put the guard back explicitly.
+        PoolGuard::put(guard);
+        result
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// This is like [`Regex::captures`], but it accepts a concrete `&Input`
+    /// instead of an `Into<Input>`.
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi-pattern `Regex` that permits
+    /// searching for specific patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     Anchored, Match, PatternID, Input,
+    /// };
+    ///
+    /// let re = Regex::new_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;
+    /// let mut caps = re.create_captures();
+    /// let haystack = "foo123";
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(Match::must(0, 0..6));
+    /// re.search_captures(&Input::new(haystack), &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let expected = Some(Match::must(1, 0..6));
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// re.search_captures(&input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Match, Input};
+    ///
+    /// let re = Regex::new(r"\b[0-9]{3}\b")?;
+    /// let mut caps = re.create_captures();
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about
+    /// // the larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `0..3` instead of
+    /// // `3..6`.
+    /// let expected = Some(Match::must(0, 0..3));
+    /// let input = Input::new(&haystack[3..6]);
+    /// re.search_captures(&input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// let input = Input::new(haystack).range(3..6);
+    /// re.search_captures(&input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_captures(&self, input: &Input<'_>, caps: &mut Captures) {
+        caps.set_pattern(None);
+        let pid = self.search_slots(input, caps.slots_mut());
+        caps.set_pattern(pid);
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided `slots`, and
+    /// returns the matching pattern ID. The contents of the slots for patterns
+    /// other than the matching pattern are unspecified. If no match was found,
+    /// then `None` is returned and the contents of `slots` is unspecified.
+    ///
+    /// This is like [`Regex::search`], but it accepts a raw slots slice
+    /// instead of a `Captures` value. This is useful in contexts where you
+    /// don't want or need to allocate a `Captures`.
+    ///
+    /// It is legal to pass _any_ number of slots to this routine. If the regex
+    /// engine would otherwise write a slot offset that doesn't fit in the
+    /// provided slice, then it is simply skipped. In general though, there are
+    /// usually three slice lengths you might want to use:
+    ///
+    /// * An empty slice, if you only care about which pattern matched.
+    /// * A slice with [`pattern_len() * 2`](Regex::pattern_len) slots, if you
+    /// only care about the overall match spans for each matching pattern.
+    /// * A slice with
+    /// [`slot_len()`](crate::util::captures::GroupInfo::slot_len) slots, which
+    /// permits recording match offsets for every capturing group in every
+    /// pattern.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the overall match offsets in a
+    /// multi-pattern search without allocating a `Captures` value. Indeed, we
+    /// can put our slots right on the stack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, PatternID, Input};
+    ///
+    /// let re = Regex::new_many(&[
+    ///     r"\pL+",
+    ///     r"\d+",
+    /// ])?;
+    /// let input = Input::new("!@#123");
+    ///
+    /// // We only care about the overall match offsets here, so we just
+    /// // allocate two slots for each pattern. Each slot records the start
+    /// // and end of the match.
+    /// let mut slots = [None; 4];
+    /// let pid = re.search_slots(&input, &mut slots);
+    /// assert_eq!(Some(PatternID::must(1)), pid);
+    ///
+    /// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'.
+    /// // See 'GroupInfo' for more details on the mapping between groups and
+    /// // slot indices.
+    /// let slot_start = pid.unwrap().as_usize() * 2;
+    /// let slot_end = slot_start + 1;
+    /// assert_eq!(Some(3), slots[slot_start].map(|s| s.get()));
+    /// assert_eq!(Some(6), slots[slot_end].map(|s| s.get()));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_slots(
+        &self,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        let mut guard = self.pool.get();
+        let result = self.imp.strat.search_slots(&mut guard, input, slots);
+        // See 'Regex::search' for why we put the guard back explicitly.
+        PoolGuard::put(guard);
+        result
+    }
+
+    /// Writes the set of patterns that match anywhere in the given search
+    /// configuration to `patset`. If multiple patterns match at the same
+    /// position and this `Regex` was configured with [`MatchKind::All`]
+    /// semantics, then all matching patterns are written to the given set.
+    ///
+    /// Unless all of the patterns in this `Regex` are anchored, then generally
+    /// speaking, this will scan the entire haystack.
+    ///
+    /// This search routine *does not* clear the pattern set. This gives some
+    /// flexibility to the caller (e.g., running multiple searches with the
+    /// same pattern set), but does make the API bug-prone if you're reusing
+    /// the same pattern set for multiple searches but intended them to be
+    /// independent.
+    ///
+    /// If a pattern ID matched but the given `PatternSet` does not have
+    /// sufficient capacity to store it, then it is not inserted and silently
+    /// dropped.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find all matching patterns in a haystack,
+    /// even when some patterns match at the same position as other patterns.
+    /// It is important that we configure the `Regex` with [`MatchKind::All`]
+    /// semantics here, or else overlapping matches will not be reported.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Input, MatchKind, PatternSet};
+    ///
+    /// let patterns = &[
+    ///     r"\w+", r"\d+", r"\pL+", r"foo", r"bar", r"barfoo", r"foobar",
+    /// ];
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().match_kind(MatchKind::All))
+    ///     .build_many(patterns)?;
+    ///
+    /// let input = Input::new("foobar");
+    /// let mut patset = PatternSet::new(re.pattern_len());
+    /// re.which_overlapping_matches(&input, &mut patset);
+    /// let expected = vec![0, 2, 3, 4, 6];
+    /// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn which_overlapping_matches(
+        &self,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        if self.imp.info.is_impossible(input) {
+            return;
+        }
+        let mut guard = self.pool.get();
+        let result = self
+            .imp
+            .strat
+            .which_overlapping_matches(&mut guard, input, patset);
+        // See 'Regex::search' for why we put the guard back explicitly.
+        PoolGuard::put(guard);
+        result
+    }
+}
+
+/// Lower level search routines that give more control, and require the caller
+/// to provide an explicit [`Cache`] parameter.
+impl Regex {
+    /// This is like [`Regex::search`], but requires the caller to
+    /// explicitly pass a [`Cache`].
+    ///
+    /// # Why pass a `Cache` explicitly?
+    ///
+    /// Passing a `Cache` explicitly will bypass the use of an internal memory
+    /// pool used by `Regex` to get a `Cache` for a search. The use of this
+    /// pool can be slower in some cases when a `Regex` is used from multiple
+    /// threads simultaneously. Typically, performance only becomes an issue
+    /// when there is heavy contention, which in turn usually only occurs
+    /// when each thread's primary unit of work is a regex search on a small
+    /// haystack.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, Match};
+    ///
+    /// let re = Regex::new(r"Samwise|Sam")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new(
+    ///     "one of the chief characters, Samwise the Brave",
+    /// );
+    /// assert_eq!(
+    ///     Some(Match::must(0, 29..36)),
+    ///     re.search_with(&mut cache, &input),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_with(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<Match> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        self.imp.strat.search(cache, input)
+    }
+
+    /// This is like [`Regex::search_half`], but requires the caller to
+    /// explicitly pass a [`Cache`].
+    ///
+    /// # Why pass a `Cache` explicitly?
+    ///
+    /// Passing a `Cache` explicitly will bypass the use of an internal memory
+    /// pool used by `Regex` to get a `Cache` for a search. The use of this
+    /// pool can be slower in some cases when a `Regex` is used from multiple
+    /// threads simultaneously. Typically, performance only becomes an issue
+    /// when there is heavy contention, which in turn usually only occurs
+    /// when each thread's primary unit of work is a regex search on a small
+    /// haystack.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, HalfMatch};
+    ///
+    /// let re = Regex::new(r"Samwise|Sam")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new(
+    ///     "one of the chief characters, Samwise the Brave",
+    /// );
+    /// assert_eq!(
+    ///     Some(HalfMatch::must(0, 36)),
+    ///     re.search_half_with(&mut cache, &input),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_half_with(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        self.imp.strat.search_half(cache, input)
+    }
+
+    /// This is like [`Regex::search_captures`], but requires the caller to
+    /// explicitly pass a [`Cache`].
+    ///
+    /// # Why pass a `Cache` explicitly?
+    ///
+    /// Passing a `Cache` explicitly will bypass the use of an internal memory
+    /// pool used by `Regex` to get a `Cache` for a search. The use of this
+    /// pool can be slower in some cases when a `Regex` is used from multiple
+    /// threads simultaneously. Typically, performance only becomes an issue
+    /// when there is heavy contention, which in turn usually only occurs
+    /// when each thread's primary unit of work is a regex search on a small
+    /// haystack.
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi-pattern `Regex` that permits
+    /// searching for specific patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     Anchored, Match, PatternID, Input,
+    /// };
+    ///
+    /// let re = Regex::new_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123";
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(Match::must(0, 0..6));
+    /// re.search_captures_with(&mut cache, &Input::new(haystack), &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let expected = Some(Match::must(1, 0..6));
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// re.search_captures_with(&mut cache, &input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Match, Input};
+    ///
+    /// let re = Regex::new(r"\b[0-9]{3}\b")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about
+    /// // the larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `0..3` instead of
+    /// // `3..6`.
+    /// let expected = Some(Match::must(0, 0..3));
+    /// let input = Input::new(&haystack[3..6]);
+    /// re.search_captures_with(&mut cache, &input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// let input = Input::new(haystack).range(3..6);
+    /// re.search_captures_with(&mut cache, &input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_captures_with(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        caps: &mut Captures,
+    ) {
+        caps.set_pattern(None);
+        let pid = self.search_slots_with(cache, input, caps.slots_mut());
+        caps.set_pattern(pid);
+    }
+
+    /// This is like [`Regex::search_slots`], but requires the caller to
+    /// explicitly pass a [`Cache`].
+    ///
+    /// # Why pass a `Cache` explicitly?
+    ///
+    /// Passing a `Cache` explicitly will bypass the use of an internal memory
+    /// pool used by `Regex` to get a `Cache` for a search. The use of this
+    /// pool can be slower in some cases when a `Regex` is used from multiple
+    /// threads simultaneously. Typically, performance only becomes an issue
+    /// when there is heavy contention, which in turn usually only occurs
+    /// when each thread's primary unit of work is a regex search on a small
+    /// haystack.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the overall match offsets in a
+    /// multi-pattern search without allocating a `Captures` value. Indeed, we
+    /// can put our slots right on the stack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, PatternID, Input};
+    ///
+    /// let re = Regex::new_many(&[
+    ///     r"\pL+",
+    ///     r"\d+",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("!@#123");
+    ///
+    /// // We only care about the overall match offsets here, so we just
+    /// // allocate two slots for each pattern. Each slot records the start
+    /// // and end of the match.
+    /// let mut slots = [None; 4];
+    /// let pid = re.search_slots_with(&mut cache, &input, &mut slots);
+    /// assert_eq!(Some(PatternID::must(1)), pid);
+    ///
+    /// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'.
+    /// // See 'GroupInfo' for more details on the mapping between groups and
+    /// // slot indices.
+    /// let slot_start = pid.unwrap().as_usize() * 2;
+    /// let slot_end = slot_start + 1;
+    /// assert_eq!(Some(3), slots[slot_start].map(|s| s.get()));
+    /// assert_eq!(Some(6), slots[slot_end].map(|s| s.get()));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_slots_with(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        if self.imp.info.is_impossible(input) {
+            return None;
+        }
+        self.imp.strat.search_slots(cache, input, slots)
+    }
+
+    /// This is like [`Regex::which_overlapping_matches`], but requires the
+    /// caller to explicitly pass a [`Cache`].
+    ///
+    /// Passing a `Cache` explicitly will bypass the use of an internal memory
+    /// pool used by `Regex` to get a `Cache` for a search. The use of this
+    /// pool can be slower in some cases when a `Regex` is used from multiple
+    /// threads simultaneously. Typically, performance only becomes an issue
+    /// when there is heavy contention, which in turn usually only occurs
+    /// when each thread's primary unit of work is a regex search on a small
+    /// haystack.
+    ///
+    /// # Why pass a `Cache` explicitly?
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Input, MatchKind, PatternSet};
+    ///
+    /// let patterns = &[
+    ///     r"\w+", r"\d+", r"\pL+", r"foo", r"bar", r"barfoo", r"foobar",
+    /// ];
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().match_kind(MatchKind::All))
+    ///     .build_many(patterns)?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("foobar");
+    /// let mut patset = PatternSet::new(re.pattern_len());
+    /// re.which_overlapping_matches_with(&mut cache, &input, &mut patset);
+    /// let expected = vec![0, 2, 3, 4, 6];
+    /// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn which_overlapping_matches_with(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        if self.imp.info.is_impossible(input) {
+            return;
+        }
+        self.imp.strat.which_overlapping_matches(cache, input, patset)
+    }
+}
+
+/// Various non-search routines for querying properties of a `Regex` and
+/// convenience routines for creating [`Captures`] and [`Cache`] values.
+impl Regex {
+    /// Creates a new object for recording capture group offsets. This is used
+    /// in search APIs like [`Regex::captures`] and [`Regex::search_captures`].
+    ///
+    /// This is a convenience routine for
+    /// `Captures::all(re.group_info().clone())`. Callers may build other types
+    /// of `Captures` values that record less information (and thus require
+    /// less work from the regex engine) using [`Captures::matches`] and
+    /// [`Captures::empty`].
+    ///
+    /// # Example
+    ///
+    /// This shows some alternatives to [`Regex::create_captures`]:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     util::captures::Captures,
+    ///     Match, PatternID, Span,
+    /// };
+    ///
+    /// let re = Regex::new(r"(?<first>[A-Z][a-z]+) (?<last>[A-Z][a-z]+)")?;
+    ///
+    /// // This is equivalent to Regex::create_captures. It stores matching
+    /// // offsets for all groups in the regex.
+    /// let mut all = Captures::all(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut all);
+    /// assert_eq!(Some(Match::must(0, 0..17)), all.get_match());
+    /// assert_eq!(Some(Span::from(0..5)), all.get_group_by_name("first"));
+    /// assert_eq!(Some(Span::from(6..17)), all.get_group_by_name("last"));
+    ///
+    /// // In this version, we only care about the implicit groups, which
+    /// // means offsets for the explicit groups will be unavailable. It can
+    /// // sometimes be faster to ask for fewer groups, since the underlying
+    /// // regex engine needs to do less work to keep track of them.
+    /// let mut matches = Captures::matches(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut matches);
+    /// // We still get the overall match info.
+    /// assert_eq!(Some(Match::must(0, 0..17)), matches.get_match());
+    /// // But now the explicit groups are unavailable.
+    /// assert_eq!(None, matches.get_group_by_name("first"));
+    /// assert_eq!(None, matches.get_group_by_name("last"));
+    ///
+    /// // Finally, in this version, we don't ask to keep track of offsets for
+    /// // *any* groups. All we get back is whether a match occurred, and if
+    /// // so, the ID of the pattern that matched.
+    /// let mut empty = Captures::empty(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut empty);
+    /// // it's a match!
+    /// assert!(empty.is_match());
+    /// // for pattern ID 0
+    /// assert_eq!(Some(PatternID::ZERO), empty.pattern());
+    /// // Match offsets are unavailable.
+    /// assert_eq!(None, empty.get_match());
+    /// // And of course, explicit groups are unavailable too.
+    /// assert_eq!(None, empty.get_group_by_name("first"));
+    /// assert_eq!(None, empty.get_group_by_name("last"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn create_captures(&self) -> Captures {
+        Captures::all(self.group_info().clone())
+    }
+
+    /// Creates a new cache for use with lower level search APIs like
+    /// [`Regex::search_with`].
+    ///
+    /// The cache returned should only be used for searches for this `Regex`.
+    /// If you want to reuse the cache for another `Regex`, then you must call
+    /// [`Cache::reset`] with that `Regex`.
+    ///
+    /// This is a convenience routine for [`Cache::new`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Input, Match};
+    ///
+    /// let re = Regex::new(r"(?-u)m\w+\s+m\w+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("crazy janey and her mission man");
+    /// assert_eq!(
+    ///     Some(Match::must(0, 20..31)),
+    ///     re.search_with(&mut cache, &input),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn create_cache(&self) -> Cache {
+        self.imp.strat.create_cache()
+    }
+
+    /// Returns the total number of patterns in this regex.
+    ///
+    /// The standard [`Regex::new`] constructor always results in a `Regex`
+    /// with a single pattern, but [`Regex::new_many`] permits building a
+    /// multi-pattern regex.
+    ///
+    /// A `Regex` guarantees that the maximum possible `PatternID` returned in
+    /// any match is `Regex::pattern_len() - 1`. In the case where the number
+    /// of patterns is `0`, a match is impossible.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^[a-z]$")?;
+    /// assert_eq!(1, re.pattern_len());
+    ///
+    /// let re = Regex::new_many::<&str>(&[])?;
+    /// assert_eq!(0, re.pattern_len());
+    ///
+    /// let re = Regex::new_many(&["a", "b", "c"])?;
+    /// assert_eq!(3, re.pattern_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        self.imp.info.pattern_len()
+    }
+
+    /// Returns the total number of capturing groups.
+    ///
+    /// This includes the implicit capturing group corresponding to the
+    /// entire match. Therefore, the minimum value returned is `1`.
+    ///
+    /// # Example
+    ///
+    /// This shows a few patterns and how many capture groups they have.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let len = |pattern| {
+    ///     Regex::new(pattern).map(|re| re.captures_len())
+    /// };
+    ///
+    /// assert_eq!(1, len("a")?);
+    /// assert_eq!(2, len("(a)")?);
+    /// assert_eq!(3, len("(a)|(b)")?);
+    /// assert_eq!(5, len("(a)(b)|(c)(d)")?);
+    /// assert_eq!(2, len("(a)|b")?);
+    /// assert_eq!(2, len("a|(b)")?);
+    /// assert_eq!(2, len("(b)*")?);
+    /// assert_eq!(2, len("(b)+")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: multiple patterns
+    ///
+    /// This routine also works for multiple patterns. The total number is
+    /// the sum of the capture groups of each pattern.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let len = |patterns| {
+    ///     Regex::new_many(patterns).map(|re| re.captures_len())
+    /// };
+    ///
+    /// assert_eq!(2, len(&["a", "b"])?);
+    /// assert_eq!(4, len(&["(a)", "(b)"])?);
+    /// assert_eq!(6, len(&["(a)|(b)", "(c)|(d)"])?);
+    /// assert_eq!(8, len(&["(a)(b)|(c)(d)", "(x)(y)"])?);
+    /// assert_eq!(3, len(&["(a)", "b"])?);
+    /// assert_eq!(3, len(&["a", "(b)"])?);
+    /// assert_eq!(4, len(&["(a)", "(b)*"])?);
+    /// assert_eq!(4, len(&["(a)+", "(b)+"])?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn captures_len(&self) -> usize {
+        self.imp
+            .info
+            .props_union()
+            .explicit_captures_len()
+            .saturating_add(self.pattern_len())
+    }
+
+    /// Returns the total number of capturing groups that appear in every
+    /// possible match.
+    ///
+    /// If the number of capture groups can vary depending on the match, then
+    /// this returns `None`. That is, a value is only returned when the number
+    /// of matching groups is invariant or "static."
+    ///
+    /// Note that like [`Regex::captures_len`], this **does** include the
+    /// implicit capturing group corresponding to the entire match. Therefore,
+    /// when a non-None value is returned, it is guaranteed to be at least `1`.
+    /// Stated differently, a return value of `Some(0)` is impossible.
+    ///
+    /// # Example
+    ///
+    /// This shows a few cases where a static number of capture groups is
+    /// available and a few cases where it is not.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let len = |pattern| {
+    ///     Regex::new(pattern).map(|re| re.static_captures_len())
+    /// };
+    ///
+    /// assert_eq!(Some(1), len("a")?);
+    /// assert_eq!(Some(2), len("(a)")?);
+    /// assert_eq!(Some(2), len("(a)|(b)")?);
+    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
+    /// assert_eq!(None, len("(a)|b")?);
+    /// assert_eq!(None, len("a|(b)")?);
+    /// assert_eq!(None, len("(b)*")?);
+    /// assert_eq!(Some(2), len("(b)+")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: multiple patterns
+    ///
+    /// This property extends to regexes with multiple patterns as well. In
+    /// order for their to be a static number of capture groups in this case,
+    /// every pattern must have the same static number.
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let len = |patterns| {
+    ///     Regex::new_many(patterns).map(|re| re.static_captures_len())
+    /// };
+    ///
+    /// assert_eq!(Some(1), len(&["a", "b"])?);
+    /// assert_eq!(Some(2), len(&["(a)", "(b)"])?);
+    /// assert_eq!(Some(2), len(&["(a)|(b)", "(c)|(d)"])?);
+    /// assert_eq!(Some(3), len(&["(a)(b)|(c)(d)", "(x)(y)"])?);
+    /// assert_eq!(None, len(&["(a)", "b"])?);
+    /// assert_eq!(None, len(&["a", "(b)"])?);
+    /// assert_eq!(None, len(&["(a)", "(b)*"])?);
+    /// assert_eq!(Some(2), len(&["(a)+", "(b)+"])?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn static_captures_len(&self) -> Option<usize> {
+        self.imp
+            .info
+            .props_union()
+            .static_explicit_captures_len()
+            .map(|len| len.saturating_add(1))
+    }
+
+    /// Return information about the capture groups in this `Regex`.
+    ///
+    /// A `GroupInfo` is an immutable object that can be cheaply cloned. It
+    /// is responsible for maintaining a mapping between the capture groups
+    /// in the concrete syntax of zero or more regex patterns and their
+    /// internal representation used by some of the regex matchers. It is also
+    /// responsible for maintaining a mapping between the name of each group
+    /// (if one exists) and its corresponding group index.
+    ///
+    /// A `GroupInfo` is ultimately what is used to build a [`Captures`] value,
+    /// which is some mutable space where group offsets are stored as a result
+    /// of a search.
+    ///
+    /// # Example
+    ///
+    /// This shows some alternatives to [`Regex::create_captures`]:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     util::captures::Captures,
+    ///     Match, PatternID, Span,
+    /// };
+    ///
+    /// let re = Regex::new(r"(?<first>[A-Z][a-z]+) (?<last>[A-Z][a-z]+)")?;
+    ///
+    /// // This is equivalent to Regex::create_captures. It stores matching
+    /// // offsets for all groups in the regex.
+    /// let mut all = Captures::all(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut all);
+    /// assert_eq!(Some(Match::must(0, 0..17)), all.get_match());
+    /// assert_eq!(Some(Span::from(0..5)), all.get_group_by_name("first"));
+    /// assert_eq!(Some(Span::from(6..17)), all.get_group_by_name("last"));
+    ///
+    /// // In this version, we only care about the implicit groups, which
+    /// // means offsets for the explicit groups will be unavailable. It can
+    /// // sometimes be faster to ask for fewer groups, since the underlying
+    /// // regex engine needs to do less work to keep track of them.
+    /// let mut matches = Captures::matches(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut matches);
+    /// // We still get the overall match info.
+    /// assert_eq!(Some(Match::must(0, 0..17)), matches.get_match());
+    /// // But now the explicit groups are unavailable.
+    /// assert_eq!(None, matches.get_group_by_name("first"));
+    /// assert_eq!(None, matches.get_group_by_name("last"));
+    ///
+    /// // Finally, in this version, we don't ask to keep track of offsets for
+    /// // *any* groups. All we get back is whether a match occurred, and if
+    /// // so, the ID of the pattern that matched.
+    /// let mut empty = Captures::empty(re.group_info().clone());
+    /// re.captures("Bruce Springsteen", &mut empty);
+    /// // it's a match!
+    /// assert!(empty.is_match());
+    /// // for pattern ID 0
+    /// assert_eq!(Some(PatternID::ZERO), empty.pattern());
+    /// // Match offsets are unavailable.
+    /// assert_eq!(None, empty.get_match());
+    /// // And of course, explicit groups are unavailable too.
+    /// assert_eq!(None, empty.get_group_by_name("first"));
+    /// assert_eq!(None, empty.get_group_by_name("last"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn group_info(&self) -> &GroupInfo {
+        self.imp.strat.group_info()
+    }
+
+    /// Returns the configuration object used to build this `Regex`.
+    ///
+    /// If no configuration object was explicitly passed, then the
+    /// configuration returned represents the default.
+    #[inline]
+    pub fn get_config(&self) -> &Config {
+        self.imp.info.config()
+    }
+
+    /// Returns true if this regex has a high chance of being "accelerated."
+    ///
+    /// The precise meaning of "accelerated" is specifically left unspecified,
+    /// but the general meaning is that the search is a high likelihood of
+    /// running faster than than a character-at-a-time loop inside a standard
+    /// regex engine.
+    ///
+    /// When a regex is accelerated, it is only a *probabilistic* claim. That
+    /// is, just because the regex is believed to be accelerated, that doesn't
+    /// mean it will definitely execute searches very fast. Similarly, if a
+    /// regex is *not* accelerated, that is also a probabilistic claim. That
+    /// is, a regex for which `is_accelerated` returns `false` could still run
+    /// searches more quickly than a regex for which `is_accelerated` returns
+    /// `true`.
+    ///
+    /// Whether a regex is marked as accelerated or not is dependent on
+    /// implementations details that may change in a semver compatible release.
+    /// That is, a regex that is accelerated in a `x.y.1` release might not be
+    /// accelerated in a `x.y.2` release.
+    ///
+    /// Basically, the value of acceleration boils down to a hedge: a hodge
+    /// podge of internal heuristics combine to make a probabilistic guess
+    /// that this regex search may run "fast." The value in knowing this from
+    /// a caller's perspective is that it may act as a signal that no further
+    /// work should be done to accelerate a search. For example, a grep-like
+    /// tool might try to do some extra work extracting literals from a regex
+    /// to create its own heuristic acceleration strategies. But it might
+    /// choose to defer to this crate's acceleration strategy if one exists.
+    /// This routine permits querying whether such a strategy is active for a
+    /// particular regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// // A simple literal is very likely to be accelerated.
+    /// let re = Regex::new(r"foo")?;
+    /// assert!(re.is_accelerated());
+    ///
+    /// // A regex with no literals is likely to not be accelerated.
+    /// let re = Regex::new(r"\w")?;
+    /// assert!(!re.is_accelerated());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_accelerated(&self) -> bool {
+        self.imp.strat.is_accelerated()
+    }
+
+    /// Return the total approximate heap memory, in bytes, used by this `Regex`.
+    ///
+    /// Note that currently, there is no high level configuration for setting
+    /// a limit on the specific value returned by this routine. Instead, the
+    /// following routines can be used to control heap memory at a bit of a
+    /// lower level:
+    ///
+    /// * [`Config::nfa_size_limit`] controls how big _any_ of the NFAs are
+    /// allowed to be.
+    /// * [`Config::onepass_size_limit`] controls how big the one-pass DFA is
+    /// allowed to be.
+    /// * [`Config::hybrid_cache_capacity`] controls how much memory the lazy
+    /// DFA is permitted to allocate to store its transition table.
+    /// * [`Config::dfa_size_limit`] controls how big a fully compiled DFA is
+    /// allowed to be.
+    /// * [`Config::dfa_state_limit`] controls the conditions under which the
+    /// meta regex engine will even attempt to build a fully compiled DFA.
+    #[inline]
+    pub fn memory_usage(&self) -> usize {
+        self.imp.strat.memory_usage()
+    }
+}
+
+impl Clone for Regex {
+    fn clone(&self) -> Regex {
+        let imp = Arc::clone(&self.imp);
+        let pool = {
+            let strat = Arc::clone(&imp.strat);
+            let create: CachePoolFn = Box::new(move || strat.create_cache());
+            Pool::new(create)
+        };
+        Regex { imp, pool }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct RegexInfo(Arc<RegexInfoI>);
+
+#[derive(Clone, Debug)]
+struct RegexInfoI {
+    config: Config,
+    props: Vec<hir::Properties>,
+    props_union: hir::Properties,
+}
+
+impl RegexInfo {
+    fn new(config: Config, hirs: &[&Hir]) -> RegexInfo {
+        // Collect all of the properties from each of the HIRs, and also
+        // union them into one big set of properties representing all HIRs
+        // as if they were in one big alternation.
+        let mut props = vec![];
+        for hir in hirs.iter() {
+            props.push(hir.properties().clone());
+        }
+        let props_union = hir::Properties::union(&props);
+
+        RegexInfo(Arc::new(RegexInfoI { config, props, props_union }))
+    }
+
+    pub(crate) fn config(&self) -> &Config {
+        &self.0.config
+    }
+
+    pub(crate) fn props(&self) -> &[hir::Properties] {
+        &self.0.props
+    }
+
+    pub(crate) fn props_union(&self) -> &hir::Properties {
+        &self.0.props_union
+    }
+
+    pub(crate) fn pattern_len(&self) -> usize {
+        self.props().len()
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.props().iter().map(|p| p.memory_usage()).sum::<usize>()
+            + self.props_union().memory_usage()
+    }
+
+    /// Returns true when the search is guaranteed to be anchored. That is,
+    /// when a match is reported, its offset is guaranteed to correspond to
+    /// the start of the search.
+    ///
+    /// This includes returning true when `input` _isn't_ anchored but the
+    /// underlying regex is.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn is_anchored_start(&self, input: &Input<'_>) -> bool {
+        input.get_anchored().is_anchored() || self.is_always_anchored_start()
+    }
+
+    /// Returns true when this regex is always anchored to the start of a
+    /// search. And in particular, that regardless of an `Input` configuration,
+    /// if any match is reported it must start at `0`.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn is_always_anchored_start(&self) -> bool {
+        use regex_syntax::hir::Look;
+        self.props_union().look_set_prefix().contains(Look::Start)
+    }
+
+    /// Returns true when this regex is always anchored to the end of a
+    /// search. And in particular, that regardless of an `Input` configuration,
+    /// if any match is reported it must end at the end of the haystack.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn is_always_anchored_end(&self) -> bool {
+        use regex_syntax::hir::Look;
+        self.props_union().look_set_suffix().contains(Look::End)
+    }
+
+    /// Returns true if and only if it is known that a match is impossible
+    /// for the given input. This is useful for short-circuiting and avoiding
+    /// running the regex engine if it's known no match can be reported.
+    ///
+    /// Note that this doesn't necessarily detect every possible case. For
+    /// example, when `pattern_len() == 0`, a match is impossible, but that
+    /// case is so rare that it's fine to be handled by the regex engine
+    /// itself. That is, it's not worth the cost of adding it here in order to
+    /// make it a little faster. The reason is that this is called for every
+    /// search. so there is some cost to adding checks here. Arguably, some of
+    /// the checks that are here already probably shouldn't be here...
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_impossible(&self, input: &Input<'_>) -> bool {
+        // The underlying regex is anchored, so if we don't start the search
+        // at position 0, a match is impossible, because the anchor can only
+        // match at position 0.
+        if input.start() > 0 && self.is_always_anchored_start() {
+            return true;
+        }
+        // Same idea, but for the end anchor.
+        if input.end() < input.haystack().len()
+            && self.is_always_anchored_end()
+        {
+            return true;
+        }
+        // If the haystack is smaller than the minimum length required, then
+        // we know there can be no match.
+        let minlen = match self.props_union().minimum_len() {
+            None => return false,
+            Some(minlen) => minlen,
+        };
+        if input.get_span().len() < minlen {
+            return true;
+        }
+        // Same idea as minimum, but for maximum. This is trickier. We can
+        // only apply the maximum when we know the entire span that we're
+        // searching *has* to match according to the regex (and possibly the
+        // input configuration). If we know there is too much for the regex
+        // to match, we can bail early.
+        //
+        // I don't think we can apply the maximum otherwise unfortunately.
+        if self.is_anchored_start(input) && self.is_always_anchored_end() {
+            let maxlen = match self.props_union().maximum_len() {
+                None => return false,
+                Some(maxlen) => maxlen,
+            };
+            if input.get_span().len() > maxlen {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+/// An iterator over all non-overlapping matches.
+///
+/// The iterator yields a [`Match`] value until no more matches could be found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the `Regex` that produced this iterator.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`Regex::find_iter`] method.
+#[derive(Debug)]
+pub struct FindMatches<'r, 'h> {
+    re: &'r Regex,
+    cache: CachePoolGuard<'r>,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'h> FindMatches<'r, 'h> {
+    /// Returns the `Regex` value that created this iterator.
+    #[inline]
+    pub fn regex(&self) -> &'r Regex {
+        self.re
+    }
+
+    /// Returns the current `Input` associated with this iterator.
+    ///
+    /// The `start` position on the given `Input` may change during iteration,
+    /// but all other values are guaranteed to remain invariant.
+    #[inline]
+    pub fn input<'s>(&'s self) -> &'s Input<'h> {
+        self.it.input()
+    }
+}
+
+impl<'r, 'h> Iterator for FindMatches<'r, 'h> {
+    type Item = Match;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match> {
+        let FindMatches { re, ref mut cache, ref mut it } = *self;
+        it.advance(|input| Ok(re.search_with(cache, input)))
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        // If all we care about is a count of matches, then we only need to
+        // find the end position of each match. This can give us a 2x perf
+        // boost in some cases, because it avoids needing to do a reverse scan
+        // to find the start of a match.
+        let FindMatches { re, mut cache, it } = self;
+        // This does the deref for PoolGuard once instead of every iter.
+        let cache = &mut *cache;
+        it.into_half_matches_iter(
+            |input| Ok(re.search_half_with(cache, input)),
+        )
+        .count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for FindMatches<'r, 'h> {}
+
+/// An iterator over all non-overlapping leftmost matches with their capturing
+/// groups.
+///
+/// The iterator yields a [`Captures`] value until no more matches could be
+/// found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the `Regex` that produced this iterator.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`Regex::captures_iter`] method.
+#[derive(Debug)]
+pub struct CapturesMatches<'r, 'h> {
+    re: &'r Regex,
+    cache: CachePoolGuard<'r>,
+    caps: Captures,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'h> CapturesMatches<'r, 'h> {
+    /// Returns the `Regex` value that created this iterator.
+    #[inline]
+    pub fn regex(&self) -> &'r Regex {
+        self.re
+    }
+
+    /// Returns the current `Input` associated with this iterator.
+    ///
+    /// The `start` position on the given `Input` may change during iteration,
+    /// but all other values are guaranteed to remain invariant.
+    #[inline]
+    pub fn input<'s>(&'s self) -> &'s Input<'h> {
+        self.it.input()
+    }
+}
+
+impl<'r, 'h> Iterator for CapturesMatches<'r, 'h> {
+    type Item = Captures;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures> {
+        // Splitting 'self' apart seems necessary to appease borrowck.
+        let CapturesMatches { re, ref mut cache, ref mut caps, ref mut it } =
+            *self;
+        let _ = it.advance(|input| {
+            re.search_captures_with(cache, input, caps);
+            Ok(caps.get_match())
+        });
+        if caps.is_match() {
+            Some(caps.clone())
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        let CapturesMatches { re, mut cache, it, .. } = self;
+        // This does the deref for PoolGuard once instead of every iter.
+        let cache = &mut *cache;
+        it.into_half_matches_iter(
+            |input| Ok(re.search_half_with(cache, input)),
+        )
+        .count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for CapturesMatches<'r, 'h> {}
+
+/// Yields all substrings delimited by a regular expression match.
+///
+/// The spans correspond to the offsets between matches.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the `Regex` that produced this iterator.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`Regex::split`] method.
+#[derive(Debug)]
+pub struct Split<'r, 'h> {
+    finder: FindMatches<'r, 'h>,
+    last: usize,
+}
+
+impl<'r, 'h> Split<'r, 'h> {
+    /// Returns the current `Input` associated with this iterator.
+    ///
+    /// The `start` position on the given `Input` may change during iteration,
+    /// but all other values are guaranteed to remain invariant.
+    #[inline]
+    pub fn input<'s>(&'s self) -> &'s Input<'h> {
+        self.finder.input()
+    }
+}
+
+impl<'r, 'h> Iterator for Split<'r, 'h> {
+    type Item = Span;
+
+    fn next(&mut self) -> Option<Span> {
+        match self.finder.next() {
+            None => {
+                let len = self.finder.it.input().haystack().len();
+                if self.last > len {
+                    None
+                } else {
+                    let span = Span::from(self.last..len);
+                    self.last = len + 1; // Next call will return None
+                    Some(span)
+                }
+            }
+            Some(m) => {
+                let span = Span::from(self.last..m.start());
+                self.last = m.end();
+                Some(span)
+            }
+        }
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Split<'r, 'h> {}
+
+/// Yields at most `N` spans delimited by a regular expression match.
+///
+/// The spans correspond to the offsets between matches. The last span will be
+/// whatever remains after splitting.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the `Regex` that produced this iterator.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`Regex::splitn`] method.
+#[derive(Debug)]
+pub struct SplitN<'r, 'h> {
+    splits: Split<'r, 'h>,
+    limit: usize,
+}
+
+impl<'r, 'h> SplitN<'r, 'h> {
+    /// Returns the current `Input` associated with this iterator.
+    ///
+    /// The `start` position on the given `Input` may change during iteration,
+    /// but all other values are guaranteed to remain invariant.
+    #[inline]
+    pub fn input<'s>(&'s self) -> &'s Input<'h> {
+        self.splits.input()
+    }
+}
+
+impl<'r, 'h> Iterator for SplitN<'r, 'h> {
+    type Item = Span;
+
+    fn next(&mut self) -> Option<Span> {
+        if self.limit == 0 {
+            return None;
+        }
+
+        self.limit -= 1;
+        if self.limit > 0 {
+            return self.splits.next();
+        }
+
+        let len = self.splits.finder.it.input().haystack().len();
+        if self.splits.last > len {
+            // We've already returned all substrings.
+            None
+        } else {
+            // self.n == 0, so future calls will return None immediately
+            Some(Span::from(self.splits.last..len))
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, Some(self.limit))
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for SplitN<'r, 'h> {}
+
+/// Represents mutable scratch space used by regex engines during a search.
+///
+/// Most of the regex engines in this crate require some kind of
+/// mutable state in order to execute a search. This mutable state is
+/// explicitly separated from the the core regex object (such as a
+/// [`thompson::NFA`](crate::nfa::thompson::NFA)) so that the read-only regex
+/// object can be shared across multiple threads simultaneously without any
+/// synchronization. Conversly, a `Cache` must either be duplicated if using
+/// the same `Regex` from multiple threads, or else there must be some kind of
+/// synchronization that guarantees exclusive access while it's in use by one
+/// thread.
+///
+/// A `Regex` attempts to do this synchronization for you by using a thread
+/// pool internally. Its size scales roughly with the number of simultaneous
+/// regex searches.
+///
+/// For cases where one does not want to rely on a `Regex`'s internal thread
+/// pool, lower level routines such as [`Regex::search_with`] are provided
+/// that permit callers to pass a `Cache` into the search routine explicitly.
+///
+/// General advice is that the thread pool is often more than good enough.
+/// However, it may be possible to observe the effects of its latency,
+/// especially when searching many small haystacks from many threads
+/// simultaneously.
+///
+/// Caches can be created from their corresponding `Regex` via
+/// [`Regex::create_cache`]. A cache can only be used with either the `Regex`
+/// that created it, or the `Regex` that was most recently used to reset it
+/// with [`Cache::reset`]. Using a cache with any other `Regex` may result in
+/// panics or incorrect results.
+///
+/// # Example
+///
+/// ```
+/// use regex_automata::{meta::Regex, Input, Match};
+///
+/// let re = Regex::new(r"(?-u)m\w+\s+m\w+")?;
+/// let mut cache = re.create_cache();
+/// let input = Input::new("crazy janey and her mission man");
+/// assert_eq!(
+///     Some(Match::must(0, 20..31)),
+///     re.search_with(&mut cache, &input),
+/// );
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Debug, Clone)]
+pub struct Cache {
+    pub(crate) capmatches: Captures,
+    pub(crate) pikevm: wrappers::PikeVMCache,
+    pub(crate) backtrack: wrappers::BoundedBacktrackerCache,
+    pub(crate) onepass: wrappers::OnePassCache,
+    pub(crate) hybrid: wrappers::HybridCache,
+    pub(crate) revhybrid: wrappers::ReverseHybridCache,
+}
+
+impl Cache {
+    /// Creates a new `Cache` for use with this regex.
+    ///
+    /// The cache returned should only be used for searches for the given
+    /// `Regex`. If you want to reuse the cache for another `Regex`, then you
+    /// must call [`Cache::reset`] with that `Regex`.
+    pub fn new(re: &Regex) -> Cache {
+        re.create_cache()
+    }
+
+    /// Reset this cache such that it can be used for searching with the given
+    /// `Regex` (and only that `Regex`).
+    ///
+    /// A cache reset permits potentially reusing memory already allocated in
+    /// this cache with a different `Regex`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different `Regex`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Match, Input};
+    ///
+    /// let re1 = Regex::new(r"\w")?;
+    /// let re2 = Regex::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     re1.search_with(&mut cache, &Input::new("Δ")),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the Regex we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// cache.reset(&re2);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     re2.search_with(&mut cache, &Input::new("☃")),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, re: &Regex) {
+        re.imp.strat.reset_cache(self)
+    }
+
+    /// Returns the heap memory usage, in bytes, of this cache.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        let mut bytes = 0;
+        bytes += self.pikevm.memory_usage();
+        bytes += self.backtrack.memory_usage();
+        bytes += self.onepass.memory_usage();
+        bytes += self.hybrid.memory_usage();
+        bytes += self.revhybrid.memory_usage();
+        bytes
+    }
+}
+
+/// An object describing the configuration of a `Regex`.
+///
+/// This configuration only includes options for the
+/// non-syntax behavior of a `Regex`, and can be applied via the
+/// [`Builder::configure`] method. For configuring the syntax options, see
+/// [`util::syntax::Config`](crate::util::syntax::Config).
+///
+/// # Example: lower the NFA size limit
+///
+/// In some cases, the default size limit might be too big. The size limit can
+/// be lowered, which will prevent large regex patterns from compiling.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::meta::Regex;
+///
+/// let result = Regex::builder()
+///     .configure(Regex::config().nfa_size_limit(Some(20 * (1<<10))))
+///     // Not even 20KB is enough to build a single large Unicode class!
+///     .build(r"\pL");
+/// assert!(result.is_err());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    // As with other configuration types in this crate, we put all our knobs
+    // in options so that we can distinguish between "default" and "not set."
+    // This makes it possible to easily combine multiple configurations
+    // without default values overwriting explicitly specified values. See the
+    // 'overwrite' method.
+    //
+    // For docs on the fields below, see the corresponding method setters.
+    match_kind: Option<MatchKind>,
+    utf8_empty: Option<bool>,
+    autopre: Option<bool>,
+    pre: Option<Option<Prefilter>>,
+    nfa_size_limit: Option<Option<usize>>,
+    onepass_size_limit: Option<Option<usize>>,
+    hybrid_cache_capacity: Option<usize>,
+    hybrid: Option<bool>,
+    dfa: Option<bool>,
+    dfa_size_limit: Option<Option<usize>>,
+    dfa_state_limit: Option<Option<usize>>,
+    onepass: Option<bool>,
+    backtrack: Option<bool>,
+    byte_classes: Option<bool>,
+    line_terminator: Option<u8>,
+}
+
+impl Config {
+    /// Create a new configuration object for a `Regex`.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Set the match semantics for a `Regex`.
+    ///
+    /// The default value is [`MatchKind::LeftmostFirst`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match, MatchKind};
+    ///
+    /// // By default, leftmost-first semantics are used, which
+    /// // disambiguates matches at the same position by selecting
+    /// // the one that corresponds earlier in the pattern.
+    /// let re = Regex::new("sam|samwise")?;
+    /// assert_eq!(Some(Match::must(0, 0..3)), re.find("samwise"));
+    ///
+    /// // But with 'all' semantics, match priority is ignored
+    /// // and all match states are included. When coupled with
+    /// // a leftmost search, the search will report the last
+    /// // possible match.
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().match_kind(MatchKind::All))
+    ///     .build("sam|samwise")?;
+    /// assert_eq!(Some(Match::must(0, 0..7)), re.find("samwise"));
+    /// // Beware that this can lead to skipping matches!
+    /// // Usually 'all' is used for anchored reverse searches
+    /// // only, or for overlapping searches.
+    /// assert_eq!(Some(Match::must(0, 4..11)), re.find("sam samwise"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn match_kind(self, kind: MatchKind) -> Config {
+        Config { match_kind: Some(kind), ..self }
+    }
+
+    /// Toggles whether empty matches are permitted to occur between the code
+    /// units of a UTF-8 encoded codepoint.
+    ///
+    /// This should generally be enabled when search a `&str` or anything that
+    /// you otherwise know is valid UTF-8. It should be disabled in all other
+    /// cases. Namely, if the haystack is not valid UTF-8 and this is enabled,
+    /// then behavior is unspecified.
+    ///
+    /// By default, this is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new("")?;
+    /// let got: Vec<Match> = re.find_iter("☃").collect();
+    /// // Matches only occur at the beginning and end of the snowman.
+    /// assert_eq!(got, vec![
+    ///     Match::must(0, 0..0),
+    ///     Match::must(0, 3..3),
+    /// ]);
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().utf8_empty(false))
+    ///     .build("")?;
+    /// let got: Vec<Match> = re.find_iter("☃").collect();
+    /// // Matches now occur at every position!
+    /// assert_eq!(got, vec![
+    ///     Match::must(0, 0..0),
+    ///     Match::must(0, 1..1),
+    ///     Match::must(0, 2..2),
+    ///     Match::must(0, 3..3),
+    /// ]);
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn utf8_empty(self, yes: bool) -> Config {
+        Config { utf8_empty: Some(yes), ..self }
+    }
+
+    /// Toggles whether automatic prefilter support is enabled.
+    ///
+    /// If this is disabled and [`Config::prefilter`] is not set, then the
+    /// meta regex engine will not use any prefilters. This can sometimes
+    /// be beneficial in cases where you know (or have measured) that the
+    /// prefilter leads to overall worse search performance.
+    ///
+    /// By default, this is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().auto_prefilter(false))
+    ///     .build(r"Bruce \w+")?;
+    /// let hay = "Hello Bruce Springsteen!";
+    /// assert_eq!(Some(Match::must(0, 6..23)), re.find(hay));
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn auto_prefilter(self, yes: bool) -> Config {
+        Config { autopre: Some(yes), ..self }
+    }
+
+    /// Overrides and sets the prefilter to use inside a `Regex`.
+    ///
+    /// This permits one to forcefully set a prefilter in cases where the
+    /// caller knows better than whatever the automatic prefilter logic is
+    /// capable of.
+    ///
+    /// By default, this is set to `None` and an automatic prefilter will be
+    /// used if one could be built. (Assuming [`Config::auto_prefilter`] is
+    /// enabled, which it is by default.)
+    ///
+    /// # Example
+    ///
+    /// This example shows how to set your own prefilter. In the case of a
+    /// pattern like `Bruce \w+`, the automatic prefilter is likely to be
+    /// constructed in a way that it will look for occurrences of `Bruce `.
+    /// In most cases, this is the best choice. But in some cases, it may be
+    /// the case that running `memchr` on `B` is the best choice. One can
+    /// achieve that behavior by overriding the automatic prefilter logic
+    /// and providing a prefilter that just matches `B`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     util::prefilter::Prefilter,
+    ///     Match, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["B"])
+    ///     .expect("a prefilter");
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().prefilter(Some(pre)))
+    ///     .build(r"Bruce \w+")?;
+    /// let hay = "Hello Bruce Springsteen!";
+    /// assert_eq!(Some(Match::must(0, 6..23)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: incorrect prefilters can lead to incorrect results!
+    ///
+    /// Be warned that setting an incorrect prefilter can lead to missed
+    /// matches. So if you use this option, ensure your prefilter can _never_
+    /// report false negatives. (A false positive is, on the other hand, quite
+    /// okay and generally unavoidable.)
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     meta::Regex,
+    ///     util::prefilter::Prefilter,
+    ///     Match, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Z"])
+    ///     .expect("a prefilter");
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().prefilter(Some(pre)))
+    ///     .build(r"Bruce \w+")?;
+    /// let hay = "Hello Bruce Springsteen!";
+    /// // Oops! No match found, but there should be one!
+    /// assert_eq!(None, re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn prefilter(self, pre: Option<Prefilter>) -> Config {
+        Config { pre: Some(pre), ..self }
+    }
+
+    /// Sets the size limit, in bytes, to enforce on the construction of every
+    /// NFA build by the meta regex engine.
+    ///
+    /// Setting it to `None` disables the limit. This is not recommended if
+    /// you're compiling untrusted patterns.
+    ///
+    /// Note that this limit is applied to _each_ NFA built, and if any of
+    /// them excceed the limit, then construction will fail. This limit does
+    /// _not_ correspond to the total memory used by all NFAs in the meta regex
+    /// engine.
+    ///
+    /// This defaults to some reasonable number that permits most reasonable
+    /// patterns.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config().nfa_size_limit(Some(20 * (1<<10))))
+    ///     // Not even 20KB is enough to build a single large Unicode class!
+    ///     .build(r"\pL");
+    /// assert!(result.is_err());
+    ///
+    /// // But notice that building such a regex with the exact same limit
+    /// // can succeed depending on other aspects of the configuration. For
+    /// // example, a single *forward* NFA will (at time of writing) fit into
+    /// // the 20KB limit, but a *reverse* NFA of the same pattern will not.
+    /// // So if one configures a meta regex such that a reverse NFA is never
+    /// // needed and thus never built, then the 20KB limit will be enough for
+    /// // a pattern like \pL!
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config()
+    ///         .nfa_size_limit(Some(20 * (1<<10)))
+    ///         // The DFAs are the only thing that (currently) need a reverse
+    ///         // NFA. So if both are disabled, the meta regex engine will
+    ///         // skip building the reverse NFA. Note that this isn't an API
+    ///         // guarantee. A future semver compatible version may introduce
+    ///         // new use cases for a reverse NFA.
+    ///         .hybrid(false)
+    ///         .dfa(false)
+    ///     )
+    ///     // Not even 20KB is enough to build a single large Unicode class!
+    ///     .build(r"\pL");
+    /// assert!(result.is_ok());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn nfa_size_limit(self, limit: Option<usize>) -> Config {
+        Config { nfa_size_limit: Some(limit), ..self }
+    }
+
+    /// Sets the size limit, in bytes, for the one-pass DFA.
+    ///
+    /// Setting it to `None` disables the limit. Disabling the limit is
+    /// strongly discouraged when compiling untrusted patterns. Even if the
+    /// patterns are trusted, it still may not be a good idea, since a one-pass
+    /// DFA can use a lot of memory. With that said, as the size of a regex
+    /// increases, the likelihood of it being one-pass likely decreases.
+    ///
+    /// This defaults to some reasonable number that permits most reasonable
+    /// one-pass patterns.
+    ///
+    /// # Example
+    ///
+    /// This shows how to set the one-pass DFA size limit. Note that since
+    /// a one-pass DFA is an optional component of the meta regex engine,
+    /// this size limit only impacts what is built internally and will never
+    /// determine whether a `Regex` itself fails to build.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config().onepass_size_limit(Some(2 * (1<<20))))
+    ///     .build(r"\pL{5}");
+    /// assert!(result.is_ok());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn onepass_size_limit(self, limit: Option<usize>) -> Config {
+        Config { onepass_size_limit: Some(limit), ..self }
+    }
+
+    /// Set the cache capacity, in bytes, for the lazy DFA.
+    ///
+    /// The cache capacity of the lazy DFA determines approximately how much
+    /// heap memory it is allowed to use to store its state transitions. The
+    /// state transitions are computed at search time, and if the cache fills
+    /// up it, it is cleared. At this point, any previously generated state
+    /// transitions are lost and are re-generated if they're needed again.
+    ///
+    /// This sort of cache filling and clearing works quite well _so long as
+    /// cache clearing happens infrequently_. If it happens too often, then the
+    /// meta regex engine will stop using the lazy DFA and switch over to a
+    /// different regex engine.
+    ///
+    /// In cases where the cache is cleared too often, it may be possible to
+    /// give the cache more space and reduce (or eliminate) how often it is
+    /// cleared. Similarly, sometimes a regex is so big that the lazy DFA isn't
+    /// used at all if its cache capacity isn't big enough.
+    ///
+    /// The capacity set here is a _limit_ on how much memory is used. The
+    /// actual memory used is only allocated as it's needed.
+    ///
+    /// Determining the right value for this is a little tricky and will likely
+    /// required some profiling. Enabling the `logging` feature and setting the
+    /// log level to `trace` will also tell you how often the cache is being
+    /// cleared.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config().hybrid_cache_capacity(20 * (1<<20)))
+    ///     .build(r"\pL{5}");
+    /// assert!(result.is_ok());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn hybrid_cache_capacity(self, limit: usize) -> Config {
+        Config { hybrid_cache_capacity: Some(limit), ..self }
+    }
+
+    /// Sets the size limit, in bytes, for heap memory used for a fully
+    /// compiled DFA.
+    ///
+    /// **NOTE:** If you increase this, you'll likely also need to increase
+    /// [`Config::dfa_state_limit`].
+    ///
+    /// In contrast to the lazy DFA, building a full DFA requires computing
+    /// all of its state transitions up front. This can be a very expensive
+    /// process, and runs in worst case `2^n` time and space (where `n` is
+    /// proportional to the size of the regex). However, a full DFA unlocks
+    /// some additional optimization opportunities.
+    ///
+    /// Because full DFAs can be so expensive, the default limits for them are
+    /// incredibly small. Generally speaking, if your regex is moderately big
+    /// or if you're using Unicode features (`\w` is Unicode-aware by default
+    /// for example), then you can expect that the meta regex engine won't even
+    /// attempt to build a DFA for it.
+    ///
+    /// If this and [`Config::dfa_state_limit`] are set to `None`, then the
+    /// meta regex will not use any sort of limits when deciding whether to
+    /// build a DFA. This in turn makes construction of a `Regex` take
+    /// worst case exponential time and space. Even short patterns can result
+    /// in huge space blow ups. So it is strongly recommended to keep some kind
+    /// of limit set!
+    ///
+    /// The default is set to a small number that permits some simple regexes
+    /// to get compiled into DFAs in reasonable time.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     // 100MB is much bigger than the default.
+    ///     .configure(Regex::config()
+    ///         .dfa_size_limit(Some(100 * (1<<20)))
+    ///         // We don't care about size too much here, so just
+    ///         // remove the NFA state limit altogether.
+    ///         .dfa_state_limit(None))
+    ///     .build(r"\pL{5}");
+    /// assert!(result.is_ok());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn dfa_size_limit(self, limit: Option<usize>) -> Config {
+        Config { dfa_size_limit: Some(limit), ..self }
+    }
+
+    /// Sets a limit on the total number of NFA states, beyond which, a full
+    /// DFA is not attempted to be compiled.
+    ///
+    /// This limit works in concert with [`Config::dfa_size_limit`]. Namely,
+    /// where as `Config::dfa_size_limit` is applied by attempting to construct
+    /// a DFA, this limit is used to avoid the attempt in the first place. This
+    /// is useful to avoid hefty initialization costs associated with building
+    /// a DFA for cases where it is obvious the DFA will ultimately be too big.
+    ///
+    /// By default, this is set to a very small number.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let result = Regex::builder()
+    ///     .configure(Regex::config()
+    ///         // Sometimes the default state limit rejects DFAs even
+    ///         // if they would fit in the size limit. Here, we disable
+    ///         // the check on the number of NFA states and just rely on
+    ///         // the size limit.
+    ///         .dfa_state_limit(None))
+    ///     .build(r"(?-u)\w{30}");
+    /// assert!(result.is_ok());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn dfa_state_limit(self, limit: Option<usize>) -> Config {
+        Config { dfa_state_limit: Some(limit), ..self }
+    }
+
+    /// Whether to attempt to shrink the size of the alphabet for the regex
+    /// pattern or not. When enabled, the alphabet is shrunk into a set of
+    /// equivalence classes, where every byte in the same equivalence class
+    /// cannot discriminate between a match or non-match.
+    ///
+    /// **WARNING:** This is only useful for debugging DFAs. Disabling this
+    /// does not yield any speed advantages. Indeed, disabling it can result
+    /// in much higher memory usage. Disabling byte classes is useful for
+    /// debugging the actual generated transitions because it lets one see the
+    /// transitions defined on actual bytes instead of the equivalence classes.
+    ///
+    /// This option is enabled by default and should never be disabled unless
+    /// one is debugging the meta regex engine's internals.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().byte_classes(false))
+    ///     .build(r"[a-z]+")?;
+    /// let hay = "!!quux!!";
+    /// assert_eq!(Some(Match::must(0, 2..6)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn byte_classes(self, yes: bool) -> Config {
+        Config { byte_classes: Some(yes), ..self }
+    }
+
+    /// Set the line terminator to be used by the `^` and `$` anchors in
+    /// multi-line mode.
+    ///
+    /// This option has no effect when CRLF mode is enabled. That is,
+    /// regardless of this setting, `(?Rm:^)` and `(?Rm:$)` will always treat
+    /// `\r` and `\n` as line terminators (and will never match between a `\r`
+    /// and a `\n`).
+    ///
+    /// By default, `\n` is the line terminator.
+    ///
+    /// **Warning**: This does not change the behavior of `.`. To do that,
+    /// you'll need to configure the syntax option
+    /// [`syntax::Config::line_terminator`](crate::util::syntax::Config::line_terminator)
+    /// in addition to this. Otherwise, `.` will continue to match any
+    /// character other than `\n`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().multi_line(true))
+    ///     .configure(Regex::config().line_terminator(b'\x00'))
+    ///     .build(r"^foo$")?;
+    /// let hay = "\x00foo\x00";
+    /// assert_eq!(Some(Match::must(0, 1..4)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn line_terminator(self, byte: u8) -> Config {
+        Config { line_terminator: Some(byte), ..self }
+    }
+
+    /// Toggle whether the hybrid NFA/DFA (also known as the "lazy DFA") should
+    /// be available for use by the meta regex engine.
+    ///
+    /// Enabling this does not necessarily mean that the lazy DFA will
+    /// definitely be used. It just means that it will be _available_ for use
+    /// if the meta regex engine thinks it will be useful.
+    ///
+    /// When the `hybrid` crate feature is enabled, then this is enabled by
+    /// default. Otherwise, if the crate feature is disabled, then this is
+    /// always disabled, regardless of its setting by the caller.
+    pub fn hybrid(self, yes: bool) -> Config {
+        Config { hybrid: Some(yes), ..self }
+    }
+
+    /// Toggle whether a fully compiled DFA should be available for use by the
+    /// meta regex engine.
+    ///
+    /// Enabling this does not necessarily mean that a DFA will definitely be
+    /// used. It just means that it will be _available_ for use if the meta
+    /// regex engine thinks it will be useful.
+    ///
+    /// When the `dfa-build` crate feature is enabled, then this is enabled by
+    /// default. Otherwise, if the crate feature is disabled, then this is
+    /// always disabled, regardless of its setting by the caller.
+    pub fn dfa(self, yes: bool) -> Config {
+        Config { dfa: Some(yes), ..self }
+    }
+
+    /// Toggle whether a one-pass DFA should be available for use by the meta
+    /// regex engine.
+    ///
+    /// Enabling this does not necessarily mean that a one-pass DFA will
+    /// definitely be used. It just means that it will be _available_ for
+    /// use if the meta regex engine thinks it will be useful. (Indeed, a
+    /// one-pass DFA can only be used when the regex is one-pass. See the
+    /// [`dfa::onepass`](crate::dfa::onepass) module for more details.)
+    ///
+    /// When the `dfa-onepass` crate feature is enabled, then this is enabled
+    /// by default. Otherwise, if the crate feature is disabled, then this is
+    /// always disabled, regardless of its setting by the caller.
+    pub fn onepass(self, yes: bool) -> Config {
+        Config { onepass: Some(yes), ..self }
+    }
+
+    /// Toggle whether a bounded backtracking regex engine should be available
+    /// for use by the meta regex engine.
+    ///
+    /// Enabling this does not necessarily mean that a bounded backtracker will
+    /// definitely be used. It just means that it will be _available_ for use
+    /// if the meta regex engine thinks it will be useful.
+    ///
+    /// When the `nfa-backtrack` crate feature is enabled, then this is enabled
+    /// by default. Otherwise, if the crate feature is disabled, then this is
+    /// always disabled, regardless of its setting by the caller.
+    pub fn backtrack(self, yes: bool) -> Config {
+        Config { backtrack: Some(yes), ..self }
+    }
+
+    /// Returns the match kind on this configuration, as set by
+    /// [`Config::match_kind`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_match_kind(&self) -> MatchKind {
+        self.match_kind.unwrap_or(MatchKind::LeftmostFirst)
+    }
+
+    /// Returns whether empty matches must fall on valid UTF-8 boundaries, as
+    /// set by [`Config::utf8_empty`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_utf8_empty(&self) -> bool {
+        self.utf8_empty.unwrap_or(true)
+    }
+
+    /// Returns whether automatic prefilters are enabled, as set by
+    /// [`Config::auto_prefilter`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_auto_prefilter(&self) -> bool {
+        self.autopre.unwrap_or(true)
+    }
+
+    /// Returns a manually set prefilter, if one was set by
+    /// [`Config::prefilter`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref().unwrap_or(&None).as_ref()
+    }
+
+    /// Returns NFA size limit, as set by [`Config::nfa_size_limit`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_nfa_size_limit(&self) -> Option<usize> {
+        self.nfa_size_limit.unwrap_or(Some(10 * (1 << 20)))
+    }
+
+    /// Returns one-pass DFA size limit, as set by
+    /// [`Config::onepass_size_limit`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_onepass_size_limit(&self) -> Option<usize> {
+        self.onepass_size_limit.unwrap_or(Some(1 * (1 << 20)))
+    }
+
+    /// Returns hybrid NFA/DFA cache capacity, as set by
+    /// [`Config::hybrid_cache_capacity`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_hybrid_cache_capacity(&self) -> usize {
+        self.hybrid_cache_capacity.unwrap_or(2 * (1 << 20))
+    }
+
+    /// Returns DFA size limit, as set by [`Config::dfa_size_limit`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_dfa_size_limit(&self) -> Option<usize> {
+        // The default for this is VERY small because building a full DFA is
+        // ridiculously costly. But for regexes that are very small, it can be
+        // beneficial to use a full DFA. In particular, a full DFA can enable
+        // additional optimizations via something called "accelerated" states.
+        // Namely, when there's a state with only a few outgoing transitions,
+        // we can temporary suspend walking the transition table and use memchr
+        // for just those outgoing transitions to skip ahead very quickly.
+        //
+        // Generally speaking, if Unicode is enabled in your regex and you're
+        // using some kind of Unicode feature, then it's going to blow this
+        // size limit. Moreover, Unicode tends to defeat the "accelerated"
+        // state optimization too, so it's a double whammy.
+        //
+        // We also use a limit on the number of NFA states to avoid even
+        // starting the DFA construction process. Namely, DFA construction
+        // itself could make lots of initial allocs proportional to the size
+        // of the NFA, and if the NFA is large, it doesn't make sense to pay
+        // that cost if we know it's likely to be blown by a large margin.
+        self.dfa_size_limit.unwrap_or(Some(40 * (1 << 10)))
+    }
+
+    /// Returns DFA size limit in terms of the number of states in the NFA, as
+    /// set by [`Config::dfa_state_limit`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_dfa_state_limit(&self) -> Option<usize> {
+        // Again, as with the size limit, we keep this very small.
+        self.dfa_state_limit.unwrap_or(Some(30))
+    }
+
+    /// Returns whether byte classes are enabled, as set by
+    /// [`Config::byte_classes`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_byte_classes(&self) -> bool {
+        self.byte_classes.unwrap_or(true)
+    }
+
+    /// Returns the line terminator for this configuration, as set by
+    /// [`Config::line_terminator`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_line_terminator(&self) -> u8 {
+        self.line_terminator.unwrap_or(b'\n')
+    }
+
+    /// Returns whether the hybrid NFA/DFA regex engine may be used, as set by
+    /// [`Config::hybrid`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_hybrid(&self) -> bool {
+        #[cfg(feature = "hybrid")]
+        {
+            self.hybrid.unwrap_or(true)
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            false
+        }
+    }
+
+    /// Returns whether the DFA regex engine may be used, as set by
+    /// [`Config::dfa`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_dfa(&self) -> bool {
+        #[cfg(feature = "dfa-build")]
+        {
+            self.dfa.unwrap_or(true)
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            false
+        }
+    }
+
+    /// Returns whether the one-pass DFA regex engine may be used, as set by
+    /// [`Config::onepass`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_onepass(&self) -> bool {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            self.onepass.unwrap_or(true)
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            false
+        }
+    }
+
+    /// Returns whether the bounded backtracking regex engine may be used, as
+    /// set by [`Config::backtrack`].
+    ///
+    /// If it was not explicitly set, then a default value is returned.
+    pub fn get_backtrack(&self) -> bool {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            self.backtrack.unwrap_or(true)
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            false
+        }
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            match_kind: o.match_kind.or(self.match_kind),
+            utf8_empty: o.utf8_empty.or(self.utf8_empty),
+            autopre: o.autopre.or(self.autopre),
+            pre: o.pre.or_else(|| self.pre.clone()),
+            nfa_size_limit: o.nfa_size_limit.or(self.nfa_size_limit),
+            onepass_size_limit: o
+                .onepass_size_limit
+                .or(self.onepass_size_limit),
+            hybrid_cache_capacity: o
+                .hybrid_cache_capacity
+                .or(self.hybrid_cache_capacity),
+            hybrid: o.hybrid.or(self.hybrid),
+            dfa: o.dfa.or(self.dfa),
+            dfa_size_limit: o.dfa_size_limit.or(self.dfa_size_limit),
+            dfa_state_limit: o.dfa_state_limit.or(self.dfa_state_limit),
+            onepass: o.onepass.or(self.onepass),
+            backtrack: o.backtrack.or(self.backtrack),
+            byte_classes: o.byte_classes.or(self.byte_classes),
+            line_terminator: o.line_terminator.or(self.line_terminator),
+        }
+    }
+}
+
+/// A builder for configuring and constructing a `Regex`.
+///
+/// The builder permits configuring two different aspects of a `Regex`:
+///
+/// * [`Builder::configure`] will set high-level configuration options as
+/// described by a [`Config`].
+/// * [`Builder::syntax`] will set the syntax level configuration options
+/// as described by a [`util::syntax::Config`](crate::util::syntax::Config).
+/// This only applies when building a `Regex` from pattern strings.
+///
+/// Once configured, the builder can then be used to construct a `Regex` from
+/// one of 4 different inputs:
+///
+/// * [`Builder::build`] creates a regex from a single pattern string.
+/// * [`Builder::build_many`] creates a regex from many pattern strings.
+/// * [`Builder::build_from_hir`] creates a regex from a
+/// [`regex-syntax::Hir`](Hir) expression.
+/// * [`Builder::build_many_from_hir`] creates a regex from many
+/// [`regex-syntax::Hir`](Hir) expressions.
+///
+/// The latter two methods in particular provide a way to construct a fully
+/// feature regular expression matcher directly from an `Hir` expression
+/// without having to first convert it to a string. (This is in contrast to the
+/// top-level `regex` crate which intentionally provides no such API in order
+/// to avoid making `regex-syntax` a public dependency.)
+///
+/// As a convenience, this builder may be created via [`Regex::builder`], which
+/// may help avoid an extra import.
+///
+/// # Example: change the line terminator
+///
+/// This example shows how to enable multi-line mode by default and change the
+/// line terminator to the NUL byte:
+///
+/// ```
+/// use regex_automata::{meta::Regex, util::syntax, Match};
+///
+/// let re = Regex::builder()
+///     .syntax(syntax::Config::new().multi_line(true))
+///     .configure(Regex::config().line_terminator(b'\x00'))
+///     .build(r"^foo$")?;
+/// let hay = "\x00foo\x00";
+/// assert_eq!(Some(Match::must(0, 1..4)), re.find(hay));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: disable UTF-8 requirement
+///
+/// By default, regex patterns are required to match UTF-8. This includes
+/// regex patterns that can produce matches of length zero. In the case of an
+/// empty match, by default, matches will not appear between the code units of
+/// a UTF-8 encoded codepoint.
+///
+/// However, it can be useful to disable this requirement, particularly if
+/// you're searching things like `&[u8]` that are not known to be valid UTF-8.
+///
+/// ```
+/// use regex_automata::{meta::Regex, util::syntax, Match};
+///
+/// let mut builder = Regex::builder();
+/// // Disables the requirement that non-empty matches match UTF-8.
+/// builder.syntax(syntax::Config::new().utf8(false));
+/// // Disables the requirement that empty matches match UTF-8 boundaries.
+/// builder.configure(Regex::config().utf8_empty(false));
+///
+/// // We can match raw bytes via \xZZ syntax, but we need to disable
+/// // Unicode mode to do that. We could disable it everywhere, or just
+/// // selectively, as shown here.
+/// let re = builder.build(r"(?-u:\xFF)foo(?-u:\xFF)")?;
+/// let hay = b"\xFFfoo\xFF";
+/// assert_eq!(Some(Match::must(0, 0..5)), re.find(hay));
+///
+/// // We can also match between code units.
+/// let re = builder.build(r"")?;
+/// let hay = "☃";
+/// assert_eq!(re.find_iter(hay).collect::<Vec<Match>>(), vec![
+///     Match::must(0, 0..0),
+///     Match::must(0, 1..1),
+///     Match::must(0, 2..2),
+///     Match::must(0, 3..3),
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    ast: ast::parse::ParserBuilder,
+    hir: hir::translate::TranslatorBuilder,
+}
+
+impl Builder {
+    /// Creates a new builder for configuring and constructing a [`Regex`].
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            ast: ast::parse::ParserBuilder::new(),
+            hir: hir::translate::TranslatorBuilder::new(),
+        }
+    }
+
+    /// Builds a `Regex` from a single pattern string.
+    ///
+    /// If there was a problem parsing the pattern or a problem turning it into
+    /// a regex matcher, then an error is returned.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to configure syntax options.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().crlf(true).multi_line(true))
+    ///     .build(r"^foo$")?;
+    /// let hay = "\r\nfoo\r\n";
+    /// assert_eq!(Some(Match::must(0, 2..5)), re.find(hay));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build(&self, pattern: &str) -> Result<Regex, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Builds a `Regex` from many pattern strings.
+    ///
+    /// If there was a problem parsing any of the patterns or a problem turning
+    /// them into a regex matcher, then an error is returned.
+    ///
+    /// # Example: finding the pattern that caused an error
+    ///
+    /// When a syntax error occurs, it is possible to ask which pattern
+    /// caused the syntax error.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, PatternID};
+    ///
+    /// let err = Regex::builder()
+    ///     .build_many(&["a", "b", r"\p{Foo}", "c"])
+    ///     .unwrap_err();
+    /// assert_eq!(Some(PatternID::must(2)), err.pattern());
+    /// ```
+    ///
+    /// # Example: zero patterns is valid
+    ///
+    /// Building a regex with zero patterns results in a regex that never
+    /// matches anything. Because this routine is generic, passing an empty
+    /// slice usually requires a turbo-fish (or something else to help type
+    /// inference).
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .build_many::<&str>(&[])?;
+    /// assert_eq!(None, re.find(""));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<Regex, BuildError> {
+        use crate::util::primitives::IteratorIndexExt;
+        log! {
+            debug!("building meta regex with {} patterns:", patterns.len());
+            for (pid, p) in patterns.iter().with_pattern_ids() {
+                let p = p.as_ref();
+                // We might split a grapheme with this truncation logic, but
+                // that's fine. We at least avoid splitting a codepoint.
+                let maxoff = p
+                    .char_indices()
+                    .map(|(i, ch)| i + ch.len_utf8())
+                    .take(1000)
+                    .last()
+                    .unwrap_or(0);
+                if maxoff < p.len() {
+                    debug!("{:?}: {}[... snip ...]", pid, &p[..maxoff]);
+                } else {
+                    debug!("{:?}: {}", pid, p);
+                }
+            }
+        }
+        let (mut asts, mut hirs) = (vec![], vec![]);
+        for (pid, p) in patterns.iter().with_pattern_ids() {
+            let ast = self
+                .ast
+                .build()
+                .parse(p.as_ref())
+                .map_err(|err| BuildError::ast(pid, err))?;
+            asts.push(ast);
+        }
+        for ((pid, p), ast) in
+            patterns.iter().with_pattern_ids().zip(asts.iter())
+        {
+            let hir = self
+                .hir
+                .build()
+                .translate(p.as_ref(), ast)
+                .map_err(|err| BuildError::hir(pid, err))?;
+            hirs.push(hir);
+        }
+        self.build_many_from_hir(&hirs)
+    }
+
+    /// Builds a `Regex` directly from an `Hir` expression.
+    ///
+    /// This is useful if you needed to parse a pattern string into an `Hir`
+    /// for other reasons (such as analysis or transformations). This routine
+    /// permits building a `Regex` directly from the `Hir` expression instead
+    /// of first converting the `Hir` back to a pattern string.
+    ///
+    /// When using this method, any options set via [`Builder::syntax`] are
+    /// ignored. Namely, the syntax options only apply when parsing a pattern
+    /// string, which isn't relevant here.
+    ///
+    /// If there was a problem building the underlying regex matcher for the
+    /// given `Hir`, then an error is returned.
+    ///
+    /// # Example
+    ///
+    /// This example shows how one can hand-construct an `Hir` expression and
+    /// build a regex from it without doing any parsing at all.
+    ///
+    /// ```
+    /// use {
+    ///     regex_automata::{meta::Regex, Match},
+    ///     regex_syntax::hir::{Hir, Look},
+    /// };
+    ///
+    /// // (?Rm)^foo$
+    /// let hir = Hir::concat(vec![
+    ///     Hir::look(Look::StartCRLF),
+    ///     Hir::literal("foo".as_bytes()),
+    ///     Hir::look(Look::EndCRLF),
+    /// ]);
+    /// let re = Regex::builder()
+    ///     .build_from_hir(&hir)?;
+    /// let hay = "\r\nfoo\r\n";
+    /// assert_eq!(Some(Match::must(0, 2..5)), re.find(hay));
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_hir(&self, hir: &Hir) -> Result<Regex, BuildError> {
+        self.build_many_from_hir(&[hir])
+    }
+
+    /// Builds a `Regex` directly from many `Hir` expressions.
+    ///
+    /// This is useful if you needed to parse pattern strings into `Hir`
+    /// expressions for other reasons (such as analysis or transformations).
+    /// This routine permits building a `Regex` directly from the `Hir`
+    /// expressions instead of first converting the `Hir` expressions back to
+    /// pattern strings.
+    ///
+    /// When using this method, any options set via [`Builder::syntax`] are
+    /// ignored. Namely, the syntax options only apply when parsing a pattern
+    /// string, which isn't relevant here.
+    ///
+    /// If there was a problem building the underlying regex matcher for the
+    /// given `Hir` expressions, then an error is returned.
+    ///
+    /// Note that unlike [`Builder::build_many`], this can only fail as a
+    /// result of building the underlying matcher. In that case, there is
+    /// no single `Hir` expression that can be isolated as a reason for the
+    /// failure. So if this routine fails, it's not possible to determine which
+    /// `Hir` expression caused the failure.
+    ///
+    /// # Example
+    ///
+    /// This example shows how one can hand-construct multiple `Hir`
+    /// expressions and build a single regex from them without doing any
+    /// parsing at all.
+    ///
+    /// ```
+    /// use {
+    ///     regex_automata::{meta::Regex, Match},
+    ///     regex_syntax::hir::{Hir, Look},
+    /// };
+    ///
+    /// // (?Rm)^foo$
+    /// let hir1 = Hir::concat(vec![
+    ///     Hir::look(Look::StartCRLF),
+    ///     Hir::literal("foo".as_bytes()),
+    ///     Hir::look(Look::EndCRLF),
+    /// ]);
+    /// // (?Rm)^bar$
+    /// let hir2 = Hir::concat(vec![
+    ///     Hir::look(Look::StartCRLF),
+    ///     Hir::literal("bar".as_bytes()),
+    ///     Hir::look(Look::EndCRLF),
+    /// ]);
+    /// let re = Regex::builder()
+    ///     .build_many_from_hir(&[&hir1, &hir2])?;
+    /// let hay = "\r\nfoo\r\nbar";
+    /// let got: Vec<Match> = re.find_iter(hay).collect();
+    /// let expected = vec![
+    ///     Match::must(0, 2..5),
+    ///     Match::must(1, 7..10),
+    /// ];
+    /// assert_eq!(expected, got);
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_many_from_hir<H: Borrow<Hir>>(
+        &self,
+        hirs: &[H],
+    ) -> Result<Regex, BuildError> {
+        let config = self.config.clone();
+        // We collect the HIRs into a vec so we can write internal routines
+        // with '&[&Hir]'. i.e., Don't use generics everywhere to keep code
+        // bloat down..
+        let hirs: Vec<&Hir> = hirs.iter().map(|hir| hir.borrow()).collect();
+        let info = RegexInfo::new(config, &hirs);
+        let strat = strategy::new(&info, &hirs)?;
+        let pool = {
+            let strat = Arc::clone(&strat);
+            let create: CachePoolFn = Box::new(move || strat.create_cache());
+            Pool::new(create)
+        };
+        Ok(Regex { imp: Arc::new(RegexI { strat, info }), pool })
+    }
+
+    /// Configure the behavior of a `Regex`.
+    ///
+    /// This configuration controls non-syntax options related to the behavior
+    /// of a `Regex`. This includes things like whether empty matches can split
+    /// a codepoint, prefilters, line terminators and a long list of options
+    /// for configuring which regex engines the meta regex engine will be able
+    /// to use internally.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to disable UTF-8 empty mode. This will permit
+    /// empty matches to occur between the UTF-8 encoding of a codepoint.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, Match};
+    ///
+    /// let re = Regex::new("")?;
+    /// let got: Vec<Match> = re.find_iter("☃").collect();
+    /// // Matches only occur at the beginning and end of the snowman.
+    /// assert_eq!(got, vec![
+    ///     Match::must(0, 0..0),
+    ///     Match::must(0, 3..3),
+    /// ]);
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().utf8_empty(false))
+    ///     .build("")?;
+    /// let got: Vec<Match> = re.find_iter("☃").collect();
+    /// // Matches now occur at every position!
+    /// assert_eq!(got, vec![
+    ///     Match::must(0, 0..0),
+    ///     Match::must(0, 1..1),
+    ///     Match::must(0, 2..2),
+    ///     Match::must(0, 3..3),
+    /// ]);
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Configure the syntax options when parsing a pattern string while
+    /// building a `Regex`.
+    ///
+    /// These options _only_ apply when [`Builder::build`] or [`Builder::build_many`]
+    /// are used. The other build methods accept `Hir` values, which have
+    /// already been parsed.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to enable case insensitive mode.
+    ///
+    /// ```
+    /// use regex_automata::{meta::Regex, util::syntax, Match};
+    ///
+    /// let re = Regex::builder()
+    ///     .syntax(syntax::Config::new().case_insensitive(true))
+    ///     .build(r"δ")?;
+    /// assert_eq!(Some(Match::must(0, 0..2)), re.find(r"Δ"));
+    ///
+    /// Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        config.apply_ast(&mut self.ast);
+        config.apply_hir(&mut self.hir);
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // I found this in the course of building out the benchmark suite for
+    // rebar.
+    #[test]
+    fn regression() {
+        env_logger::init();
+
+        let re = Regex::new(r"[a-zA-Z]+ing").unwrap();
+        assert_eq!(1, re.find_iter("tingling").count());
+    }
+}
diff --git a/regex-automata/src/meta/reverse_inner.rs b/regex-automata/src/meta/reverse_inner.rs
new file mode 100644
index 0000000000..3d78779f6f
--- /dev/null
+++ b/regex-automata/src/meta/reverse_inner.rs
@@ -0,0 +1,220 @@
+/*!
+A module dedicated to plucking inner literals out of a regex pattern, and
+then constructing a prefilter for them. We also include a regex pattern
+"prefix" that corresponds to the bits of the regex that need to match before
+the literals do. The reverse inner optimization then proceeds by looking for
+matches of the inner literal(s), and then doing a reverse search of the prefix
+from the start of the literal match to find the overall start position of the
+match.
+
+The essential invariant we want to uphold here is that the literals we return
+reflect a set where *at least* one of them must match in order for the overall
+regex to match. We also need to maintain the invariant that the regex prefix
+returned corresponds to the entirety of the regex up until the literals we
+return.
+
+This somewhat limits what we can do. That is, if we a regex like
+`\w+(@!|%%)\w+`, then we can pluck the `{@!, %%}` out and build a prefilter
+from it. Then we just need to compile `\w+` in reverse. No fuss no muss. But if
+we have a regex like \d+@!|\w+%%`, then we get kind of stymied. Technically,
+we could still extract `{@!, %%}`, and it is true that at least of them must
+match. But then, what is our regex prefix? Again, in theory, that could be
+`\d+|\w+`, but that's not quite right, because the `\d+` only matches when `@!`
+matches, and `\w+` only matches when `%%` matches.
+
+All of that is technically possible to do, but it seemingly requires a lot of
+sophistication and machinery. Probably the way to tackle that is with some kind
+of formalism and approach this problem more generally.
+
+For now, the code below basically just looks for a top-level concatenation.
+And if it can find one, it looks for literals in each of the direct child
+sub-expressions of that concatenation. If some good ones are found, we return
+those and a concatenation of the Hir expressions seen up to that point.
+*/
+
+use alloc::vec::Vec;
+
+use regex_syntax::hir::{self, literal, Hir, HirKind};
+
+use crate::{util::prefilter::Prefilter, MatchKind};
+
+/// Attempts to extract an "inner" prefilter from the given HIR expressions. If
+/// one was found, then a concatenation of the HIR expressions that precede it
+/// is returned.
+///
+/// The idea here is that the prefilter returned can be used to find candidate
+/// matches. And then the HIR returned can be used to build a reverse regex
+/// matcher, which will find the start of the candidate match. Finally, the
+/// match still has to be confirmed with a normal anchored forward scan to find
+/// the end position of the match.
+///
+/// Note that this assumes leftmost-first match semantics, so callers must
+/// not call this otherwise.
+pub(crate) fn extract(hirs: &[&Hir]) -> Option<(Hir, Prefilter)> {
+    if hirs.len() != 1 {
+        debug!(
+            "skipping reverse inner optimization since it only \
+		 	 supports 1 pattern, {} were given",
+            hirs.len(),
+        );
+        return None;
+    }
+    let mut concat = match top_concat(hirs[0]) {
+        Some(concat) => concat,
+        None => {
+            debug!(
+                "skipping reverse inner optimization because a top-level \
+		 	     concatenation could not found",
+            );
+            return None;
+        }
+    };
+    // We skip the first HIR because if it did have a prefix prefilter in it,
+    // we probably wouldn't be here looking for an inner prefilter.
+    for i in 1..concat.len() {
+        let hir = &concat[i];
+        let pre = match prefilter(hir) {
+            None => continue,
+            Some(pre) => pre,
+        };
+        // Even if we got a prefilter, if it isn't consider "fast," then we
+        // probably don't want to bother with it. Namely, since the reverse
+        // inner optimization requires some overhead, it likely only makes
+        // sense if the prefilter scan itself is (believed) to be much faster
+        // than the regex engine.
+        if !pre.is_fast() {
+            debug!(
+                "skipping extracted inner prefilter because \
+				 it probably isn't fast"
+            );
+            continue;
+        }
+        let concat_suffix = Hir::concat(concat.split_off(i));
+        let concat_prefix = Hir::concat(concat);
+        // Look for a prefilter again. Why? Because above we only looked for
+        // a prefilter on the individual 'hir', but we might be able to find
+        // something better and more discriminatory by looking at the entire
+        // suffix. We don't do this above to avoid making this loop worst case
+        // quadratic in the length of 'concat'.
+        let pre2 = match prefilter(&concat_suffix) {
+            None => pre,
+            Some(pre2) => {
+                if pre2.is_fast() {
+                    pre2
+                } else {
+                    pre
+                }
+            }
+        };
+        return Some((concat_prefix, pre2));
+    }
+    debug!(
+        "skipping reverse inner optimization because a top-level \
+	     sub-expression with a fast prefilter could not be found"
+    );
+    None
+}
+
+/// Attempt to extract a prefilter from an HIR expression.
+///
+/// We do a little massaging here to do our best that the prefilter we get out
+/// of this is *probably* fast. Basically, the false positive rate has a much
+/// higher impact for things like the reverse inner optimization because more
+/// work needs to potentially be done for each candidate match.
+///
+/// Note that this assumes leftmost-first match semantics, so callers must
+/// not call this otherwise.
+fn prefilter(hir: &Hir) -> Option<Prefilter> {
+    let mut extractor = literal::Extractor::new();
+    extractor.kind(literal::ExtractKind::Prefix);
+    let mut prefixes = extractor.extract(hir);
+    debug!(
+        "inner prefixes (len={:?}) extracted before optimization: {:?}",
+        prefixes.len(),
+        prefixes
+    );
+    // Since these are inner literals, we know they cannot be exact. But the
+    // extractor doesn't know this. We mark them as inexact because this might
+    // impact literal optimization. Namely, optimization weights "all literals
+    // are exact" as very high, because it presumes that any match results in
+    // an overall match. But of course, that is not the case here.
+    //
+    // In practice, this avoids plucking out a ASCII-only \s as an alternation
+    // of single-byte whitespace characters.
+    prefixes.make_inexact();
+    prefixes.optimize_for_prefix_by_preference();
+    debug!(
+        "inner prefixes (len={:?}) extracted after optimization: {:?}",
+        prefixes.len(),
+        prefixes
+    );
+    prefixes
+        .literals()
+        .and_then(|lits| Prefilter::new(MatchKind::LeftmostFirst, lits))
+}
+
+/// Looks for a "top level" HirKind::Concat item in the given HIR. This will
+/// try to return one even if it's embedded in a capturing group, but is
+/// otherwise pretty conservative in what is returned.
+///
+/// The HIR returned is a complete copy of the concat with all capturing
+/// groups removed. In effect, the concat returned is "flattened" with respect
+/// to capturing groups. This makes the detection logic above for prefixes
+/// a bit simpler, and it works because 1) capturing groups never influence
+/// whether a match occurs or not and 2) capturing groups are not used when
+/// doing the reverse inner search to find the start of the match.
+fn top_concat(mut hir: &Hir) -> Option<Vec<Hir>> {
+    loop {
+        hir = match hir.kind() {
+            HirKind::Empty
+            | HirKind::Literal(_)
+            | HirKind::Class(_)
+            | HirKind::Look(_)
+            | HirKind::Repetition(_)
+            | HirKind::Alternation(_) => return None,
+            HirKind::Capture(hir::Capture { ref sub, .. }) => sub,
+            HirKind::Concat(ref subs) => {
+                // We are careful to only do the flattening/copy when we know
+                // we have a "top level" concat we can inspect. This avoids
+                // doing extra work in cases where we definitely won't use it.
+                // (This might still be wasted work if we can't go on to find
+                // some literals to extract.)
+                let concat =
+                    Hir::concat(subs.iter().map(|h| flatten(h)).collect());
+                return match concat.into_kind() {
+                    HirKind::Concat(xs) => Some(xs),
+                    // It is actually possible for this case to occur, because
+                    // 'Hir::concat' might simplify the expression to the point
+                    // that concatenations are actually removed. One wonders
+                    // whether this leads to other cases where we should be
+                    // extracting literals, but in theory, I believe if we do
+                    // get here, then it means that a "real" prefilter failed
+                    // to be extracted and we should probably leave well enough
+                    // alone. (A "real" prefilter is unbothered by "top-level
+                    // concats" and "capturing groups.")
+                    _ => return None,
+                };
+            }
+        };
+    }
+}
+
+/// Returns a copy of the given HIR but with all capturing groups removed.
+fn flatten(hir: &Hir) -> Hir {
+    match hir.kind() {
+        HirKind::Empty => Hir::empty(),
+        HirKind::Literal(hir::Literal(ref x)) => Hir::literal(x.clone()),
+        HirKind::Class(ref x) => Hir::class(x.clone()),
+        HirKind::Look(ref x) => Hir::look(x.clone()),
+        HirKind::Repetition(ref x) => Hir::repetition(x.with(flatten(&x.sub))),
+        // This is the interesting case. We just drop the group information
+        // entirely and use the child HIR itself.
+        HirKind::Capture(hir::Capture { ref sub, .. }) => flatten(sub),
+        HirKind::Alternation(ref xs) => {
+            Hir::alternation(xs.iter().map(|x| flatten(x)).collect())
+        }
+        HirKind::Concat(ref xs) => {
+            Hir::concat(xs.iter().map(|x| flatten(x)).collect())
+        }
+    }
+}
diff --git a/regex-automata/src/meta/stopat.rs b/regex-automata/src/meta/stopat.rs
new file mode 100644
index 0000000000..e8d716689c
--- /dev/null
+++ b/regex-automata/src/meta/stopat.rs
@@ -0,0 +1,224 @@
+/*!
+This module defines two bespoke forward DFA search routines. One for the lazy
+DFA and one for the fully compiled DFA. These routines differ from the normal
+ones by reporting the position at which the search terminates when a match
+*isn't* found.
+
+This position at which a search terminates is useful in contexts where the meta
+regex engine runs optimizations that could go quadratic if we aren't careful.
+Namely, a regex search *could* scan to the end of the haystack only to report a
+non-match. If the caller doesn't know that the search scanned to the end of the
+haystack, it might restart the search at the next literal candidate it finds
+and repeat the process.
+
+Providing the caller with the position at which the search stopped provides a
+way for the caller to determine the point at which subsequent scans should not
+pass. This is principally used in the "reverse inner" optimization, which works
+like this:
+
+1. Look for a match of an inner literal. Say, 'Z' in '\w+Z\d+'.
+2. At the spot where 'Z' matches, do a reverse anchored search from there for
+'\w+'.
+3. If the reverse search matches, it corresponds to the start position of a
+(possible) match. At this point, do a forward anchored search to find the end
+position. If an end position is found, then we have a match and we know its
+bounds.
+
+If the forward anchored search in (3) searches the entire rest of the haystack
+but reports a non-match, then a naive implementation of the above will continue
+back at step 1 looking for more candidates. There might still be a match to be
+found! It's possible. But we already scanned the whole haystack. So if we keep
+repeating the process, then we might wind up taking quadratic time in the size
+of the haystack, which is not great.
+
+So if the forward anchored search in (3) reports the position at which it
+stops, then we can detect whether quadratic behavior might be occurring in
+steps (1) and (2). For (1), it occurs if the literal candidate found occurs
+*before* the end of the previous search in (3), since that means we're now
+going to look for another match in a place where the forward search has already
+scanned. It is *correct* to do so, but our technique has become inefficient.
+For (2), quadratic behavior occurs similarly when its reverse search extends
+past the point where the previous forward search in (3) terminated. Indeed, to
+implement (2), we use the sibling 'limited' module for ensuring our reverse
+scan doesn't go further than we want.
+
+See the 'opt/reverse-inner' benchmarks in rebar for a real demonstration of
+how quadratic behavior is mitigated.
+*/
+
+use crate::{meta::error::RetryFailError, HalfMatch, Input, MatchError};
+
+#[cfg(feature = "dfa-build")]
+pub(crate) fn dfa_try_search_half_fwd(
+    dfa: &crate::dfa::dense::DFA<alloc::vec::Vec<u32>>,
+    input: &Input<'_>,
+) -> Result<Result<HalfMatch, usize>, RetryFailError> {
+    use crate::dfa::{accel, Automaton};
+
+    let mut mat = None;
+    let mut sid = dfa.start_state_forward(input)?;
+    let mut at = input.start();
+    while at < input.end() {
+        sid = dfa.next_state(sid, input.haystack()[at]);
+        if dfa.is_special_state(sid) {
+            if dfa.is_match_state(sid) {
+                let pattern = dfa.match_pattern(sid, 0);
+                mat = Some(HalfMatch::new(pattern, at));
+                if input.get_earliest() {
+                    return Ok(mat.ok_or(at));
+                }
+                if dfa.is_accel_state(sid) {
+                    let needs = dfa.accelerator(sid);
+                    at = accel::find_fwd(needs, input.haystack(), at)
+                        .unwrap_or(input.end());
+                    continue;
+                }
+            } else if dfa.is_accel_state(sid) {
+                let needs = dfa.accelerator(sid);
+                at = accel::find_fwd(needs, input.haystack(), at)
+                    .unwrap_or(input.end());
+                continue;
+            } else if dfa.is_dead_state(sid) {
+                return Ok(mat.ok_or(at));
+            } else if dfa.is_quit_state(sid) {
+                if mat.is_some() {
+                    return Ok(mat.ok_or(at));
+                }
+                return Err(MatchError::quit(input.haystack()[at], at).into());
+            } else {
+                // Ideally we wouldn't use a DFA that specialized start states
+                // and thus 'is_start_state()' could never be true here, but in
+                // practice we reuse the DFA created for the full regex which
+                // will specialize start states whenever there is a prefilter.
+                debug_assert!(dfa.is_start_state(sid));
+            }
+        }
+        at += 1;
+    }
+    dfa_eoi_fwd(dfa, input, &mut sid, &mut mat)?;
+    Ok(mat.ok_or(at))
+}
+
+#[cfg(feature = "hybrid")]
+pub(crate) fn hybrid_try_search_half_fwd(
+    dfa: &crate::hybrid::dfa::DFA,
+    cache: &mut crate::hybrid::dfa::Cache,
+    input: &Input<'_>,
+) -> Result<Result<HalfMatch, usize>, RetryFailError> {
+    let mut mat = None;
+    let mut sid = dfa.start_state_forward(cache, input)?;
+    let mut at = input.start();
+    while at < input.end() {
+        sid = dfa
+            .next_state(cache, sid, input.haystack()[at])
+            .map_err(|_| MatchError::gave_up(at))?;
+        if sid.is_tagged() {
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, sid, 0);
+                mat = Some(HalfMatch::new(pattern, at));
+                if input.get_earliest() {
+                    return Ok(mat.ok_or(at));
+                }
+            } else if sid.is_dead() {
+                return Ok(mat.ok_or(at));
+            } else if sid.is_quit() {
+                if mat.is_some() {
+                    return Ok(mat.ok_or(at));
+                }
+                return Err(MatchError::quit(input.haystack()[at], at).into());
+            } else {
+                // We should NEVER get an unknown state ID back from
+                // dfa.next_state().
+                debug_assert!(!sid.is_unknown());
+                // Ideally we wouldn't use a lazy DFA that specialized start
+                // states and thus 'sid.is_start()' could never be true here,
+                // but in practice we reuse the lazy DFA created for the full
+                // regex which will specialize start states whenever there is
+                // a prefilter.
+                debug_assert!(sid.is_start());
+            }
+        }
+        at += 1;
+    }
+    hybrid_eoi_fwd(dfa, cache, input, &mut sid, &mut mat)?;
+    Ok(mat.ok_or(at))
+}
+
+#[cfg(feature = "dfa-build")]
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn dfa_eoi_fwd(
+    dfa: &crate::dfa::dense::DFA<alloc::vec::Vec<u32>>,
+    input: &Input<'_>,
+    sid: &mut crate::util::primitives::StateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    use crate::dfa::Automaton;
+
+    let sp = input.get_span();
+    match input.haystack().get(sp.end) {
+        Some(&b) => {
+            *sid = dfa.next_state(*sid, b);
+            if dfa.is_match_state(*sid) {
+                let pattern = dfa.match_pattern(*sid, 0);
+                *mat = Some(HalfMatch::new(pattern, sp.end));
+            } else if dfa.is_quit_state(*sid) {
+                if mat.is_some() {
+                    return Ok(());
+                }
+                return Err(MatchError::quit(b, sp.end));
+            }
+        }
+        None => {
+            *sid = dfa.next_eoi_state(*sid);
+            if dfa.is_match_state(*sid) {
+                let pattern = dfa.match_pattern(*sid, 0);
+                *mat = Some(HalfMatch::new(pattern, input.haystack().len()));
+            }
+            // N.B. We don't have to check 'is_quit' here because the EOI
+            // transition can never lead to a quit state.
+            debug_assert!(!dfa.is_quit_state(*sid));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(feature = "hybrid")]
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn hybrid_eoi_fwd(
+    dfa: &crate::hybrid::dfa::DFA,
+    cache: &mut crate::hybrid::dfa::Cache,
+    input: &Input<'_>,
+    sid: &mut crate::hybrid::LazyStateID,
+    mat: &mut Option<HalfMatch>,
+) -> Result<(), MatchError> {
+    let sp = input.get_span();
+    match input.haystack().get(sp.end) {
+        Some(&b) => {
+            *sid = dfa
+                .next_state(cache, *sid, b)
+                .map_err(|_| MatchError::gave_up(sp.end))?;
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, *sid, 0);
+                *mat = Some(HalfMatch::new(pattern, sp.end));
+            } else if sid.is_quit() {
+                if mat.is_some() {
+                    return Ok(());
+                }
+                return Err(MatchError::quit(b, sp.end));
+            }
+        }
+        None => {
+            *sid = dfa
+                .next_eoi_state(cache, *sid)
+                .map_err(|_| MatchError::gave_up(input.haystack().len()))?;
+            if sid.is_match() {
+                let pattern = dfa.match_pattern(cache, *sid, 0);
+                *mat = Some(HalfMatch::new(pattern, input.haystack().len()));
+            }
+            // N.B. We don't have to check 'is_quit' here because the EOI
+            // transition can never lead to a quit state.
+            debug_assert!(!sid.is_quit());
+        }
+    }
+    Ok(())
+}
diff --git a/regex-automata/src/meta/strategy.rs b/regex-automata/src/meta/strategy.rs
new file mode 100644
index 0000000000..2de2c385ec
--- /dev/null
+++ b/regex-automata/src/meta/strategy.rs
@@ -0,0 +1,1740 @@
+use core::{
+    fmt::Debug,
+    panic::{RefUnwindSafe, UnwindSafe},
+};
+
+use alloc::sync::Arc;
+
+use regex_syntax::hir::{literal, Hir};
+
+use crate::{
+    meta::{
+        error::{BuildError, RetryError, RetryFailError, RetryQuadraticError},
+        regex::{Cache, RegexInfo},
+        reverse_inner, wrappers,
+    },
+    nfa::thompson::{self, NFA},
+    util::{
+        captures::{Captures, GroupInfo},
+        look::LookMatcher,
+        prefilter::{self, Prefilter, PrefilterI},
+        primitives::{NonMaxUsize, PatternID},
+        search::{Anchored, HalfMatch, Input, Match, MatchKind, PatternSet},
+    },
+};
+
+/// A trait that represents a single meta strategy. Its main utility is in
+/// providing a way to do dynamic dispatch over a few choices.
+///
+/// Why dynamic dispatch? I actually don't have a super compelling reason, and
+/// importantly, I have not benchmarked it with the main alternative: an enum.
+/// I went with dynamic dispatch initially because the regex engine search code
+/// really can't be inlined into caller code in most cases because it's just
+/// too big. In other words, it is already expected that every regex search
+/// will entail at least the cost of a function call.
+///
+/// I do wonder whether using enums would result in better codegen overall
+/// though. It's a worthwhile experiment to try. Probably the most interesting
+/// benchmark to run in such a case would be one with a high match count. That
+/// is, a benchmark to test the overall latency of a search call.
+pub(super) trait Strategy:
+    Debug + Send + Sync + RefUnwindSafe + UnwindSafe + 'static
+{
+    fn group_info(&self) -> &GroupInfo;
+
+    fn create_cache(&self) -> Cache;
+
+    fn reset_cache(&self, cache: &mut Cache);
+
+    fn is_accelerated(&self) -> bool;
+
+    fn memory_usage(&self) -> usize;
+
+    fn search(&self, cache: &mut Cache, input: &Input<'_>) -> Option<Match>;
+
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch>;
+
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID>;
+
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    );
+}
+
+pub(super) fn new(
+    info: &RegexInfo,
+    hirs: &[&Hir],
+) -> Result<Arc<dyn Strategy>, BuildError> {
+    // At this point, we're committed to a regex engine of some kind. So pull
+    // out a prefilter if we can, which will feed to each of the constituent
+    // regex engines.
+    let pre = if info.is_always_anchored_start() {
+        // PERF: I'm not sure we necessarily want to do this... We may want to
+        // run a prefilter for quickly rejecting in some cases. The problem
+        // is that anchored searches overlap quite a bit with the use case
+        // of "run a regex on every line to extract data." In that case, the
+        // regex always matches, so running a prefilter doesn't really help us
+        // there. The main place where a prefilter helps in an anchored search
+        // is if the anchored search is not expected to match frequently. That
+        // is, the prefilter gives us a way to possibly reject a haystack very
+        // quickly.
+        //
+        // Maybe we should do use a prefilter, but only for longer haystacks?
+        // Or maybe we should only use a prefilter when we think it's "fast"?
+        //
+        // Interestingly, I think we currently lack the infrastructure for
+        // disabling a prefilter based on haystack length. That would probably
+        // need to be a new 'Input' option. (Interestingly, an 'Input' used to
+        // carry a 'Prefilter' with it, but I moved away from that.)
+        debug!("skipping literal extraction since regex is anchored");
+        None
+    } else if let Some(pre) = info.config().get_prefilter() {
+        debug!(
+            "skipping literal extraction since the caller provided a prefilter"
+        );
+        Some(pre.clone())
+    } else if info.config().get_auto_prefilter() {
+        let kind = info.config().get_match_kind();
+        let prefixes = crate::util::prefilter::prefixes(kind, hirs);
+        // If we can build a full `Strategy` from just the extracted prefixes,
+        // then we can short-circuit and avoid building a regex engine at all.
+        if let Some(pre) = Pre::from_prefixes(info, &prefixes) {
+            debug!(
+                "found that the regex can be broken down to a literal \
+                 search, avoiding the regex engine entirely",
+            );
+            return Ok(pre);
+        }
+        // This now attempts another short-circuit of the regex engine: if we
+        // have a huge alternation of just plain literals, then we can just use
+        // Aho-Corasick for that and avoid the regex engine entirely.
+        //
+        // You might think this case would just be handled by
+        // `Pre::from_prefixes`, but that technique relies on heuristic literal
+        // extraction from the corresponding `Hir`. That works, but part of
+        // heuristics limit the size and number of literals returned. This case
+        // will specifically handle patterns with very large alternations.
+        //
+        // One wonders if we should just roll this our heuristic literal
+        // extraction, and then I think this case could disappear entirely.
+        if let Some(pre) = Pre::from_alternation_literals(info, hirs) {
+            debug!(
+                "found plain alternation of literals, \
+                 avoiding regex engine entirely and using Aho-Corasick"
+            );
+            return Ok(pre);
+        }
+        prefixes.literals().and_then(|strings| {
+            debug!(
+                "creating prefilter from {} literals: {:?}",
+                strings.len(),
+                strings,
+            );
+            Prefilter::new(kind, strings)
+        })
+    } else {
+        debug!("skipping literal extraction since prefilters were disabled");
+        None
+    };
+    let mut core = Core::new(info.clone(), pre.clone(), hirs)?;
+    // Now that we have our core regex engines built, there are a few cases
+    // where we can do a little bit better than just a normal "search forward
+    // and maybe use a prefilter when in a start state." However, these cases
+    // may not always work or otherwise build on top of the Core searcher.
+    // For example, the reverse anchored optimization seems like it might
+    // always work, but only the DFAs support reverse searching and the DFAs
+    // might give up or quit for reasons. If we had, e.g., a PikeVM that
+    // supported reverse searching, then we could avoid building a full Core
+    // engine for this case.
+    core = match ReverseAnchored::new(core) {
+        Err(core) => core,
+        Ok(ra) => {
+            debug!("using reverse anchored strategy");
+            return Ok(Arc::new(ra));
+        }
+    };
+    core = match ReverseSuffix::new(core, hirs) {
+        Err(core) => core,
+        Ok(rs) => {
+            debug!("using reverse suffix strategy");
+            return Ok(Arc::new(rs));
+        }
+    };
+    core = match ReverseInner::new(core, hirs) {
+        Err(core) => core,
+        Ok(ri) => {
+            debug!("using reverse inner strategy");
+            return Ok(Arc::new(ri));
+        }
+    };
+    debug!("using core strategy");
+    Ok(Arc::new(core))
+}
+
+#[derive(Clone, Debug)]
+struct Pre<P> {
+    pre: P,
+    group_info: GroupInfo,
+}
+
+impl<P: PrefilterI> Pre<P> {
+    fn new(pre: P) -> Arc<dyn Strategy> {
+        // The only thing we support when we use prefilters directly as a
+        // strategy is the start and end of the overall match for a single
+        // pattern. In other words, exactly one implicit capturing group. Which
+        // is exactly what we use here for a GroupInfo.
+        let group_info = GroupInfo::new([[None::<&str>]]).unwrap();
+        Arc::new(Pre { pre, group_info })
+    }
+}
+
+// This is a little weird, but we don't actually care about the type parameter
+// here because we're selecting which underlying prefilter to use. So we just
+// define it on an arbitrary type.
+impl Pre<()> {
+    /// Given a sequence of prefixes, attempt to return a full `Strategy` using
+    /// just the prefixes.
+    ///
+    /// Basically, this occurs when the prefixes given not just prefixes,
+    /// but an enumeration of the entire language matched by the regular
+    /// expression.
+    ///
+    /// A number of other conditions need to be true too. For example, there
+    /// can be only one pattern, the number of explicit capture groups is 0, no
+    /// look-around assertions and so on.
+    ///
+    /// Note that this ignores `Config::get_auto_prefilter` because if this
+    /// returns something, then it isn't a prefilter but a matcher itself.
+    /// Therefore, it shouldn't suffer from the problems typical to prefilters
+    /// (such as a high false positive rate).
+    fn from_prefixes(
+        info: &RegexInfo,
+        prefixes: &literal::Seq,
+    ) -> Option<Arc<dyn Strategy>> {
+        let kind = info.config().get_match_kind();
+        // Check to see if our prefixes are exact, which means we might be
+        // able to bypass the regex engine entirely and just rely on literal
+        // searches.
+        if !prefixes.is_exact() {
+            return None;
+        }
+        // We also require that we have a single regex pattern. Namely,
+        // we reuse the prefilter infrastructure to implement search and
+        // prefilters only report spans. Prefilters don't know about pattern
+        // IDs. The multi-regex case isn't a lost cause, we might still use
+        // Aho-Corasick and we might still just use a regular prefilter, but
+        // that's done below.
+        if info.pattern_len() != 1 {
+            return None;
+        }
+        // We can't have any capture groups either. The literal engines don't
+        // know how to deal with things like '(foo)(bar)'. In that case, a
+        // prefilter will just be used and then the regex engine will resolve
+        // the capture groups.
+        if info.props()[0].explicit_captures_len() != 0 {
+            return None;
+        }
+        // We also require that it has zero look-around assertions. Namely,
+        // literal extraction treats look-around assertions as if they match
+        // *every* empty string. But of course, that isn't true. So for
+        // example, 'foo\bquux' never matches anything, but 'fooquux' is
+        // extracted from that as an exact literal. Such cases should just run
+        // the regex engine. 'fooquux' will be used as a normal prefilter, and
+        // then the regex engine will try to look for an actual match.
+        if !info.props()[0].look_set().is_empty() {
+            return None;
+        }
+        // Finally, currently, our prefilters are all oriented around
+        // leftmost-first match semantics, so don't try to use them if the
+        // caller asked for anything else.
+        if kind != MatchKind::LeftmostFirst {
+            return None;
+        }
+        // The above seems like a lot of requirements to meet, but it applies
+        // to a lot of cases. 'foo', '[abc][123]' and 'foo|bar|quux' all meet
+        // the above criteria, for example.
+        //
+        // Note that this is effectively a latency optimization. If we didn't
+        // do this, then the extracted literals would still get bundled into
+        // a prefilter, and every regex engine capable of running unanchored
+        // searches supports prefilters. So this optimization merely sidesteps
+        // having to run the regex engine at all to confirm the match. Thus, it
+        // decreases the latency of a match.
+
+        // OK because we know the set is exact and thus finite.
+        let prefixes = prefixes.literals().unwrap();
+        debug!(
+            "trying to bypass regex engine by creating \
+             prefilter from {} literals: {:?}",
+            prefixes.len(),
+            prefixes,
+        );
+        let choice = match prefilter::Choice::new(kind, prefixes) {
+            Some(choice) => choice,
+            None => {
+                debug!(
+                    "regex bypass failed because no prefilter could be built"
+                );
+                return None;
+            }
+        };
+        let strat: Arc<dyn Strategy> = match choice {
+            prefilter::Choice::Memchr(pre) => Pre::new(pre),
+            prefilter::Choice::Memchr2(pre) => Pre::new(pre),
+            prefilter::Choice::Memchr3(pre) => Pre::new(pre),
+            prefilter::Choice::Memmem(pre) => Pre::new(pre),
+            prefilter::Choice::Teddy(pre) => Pre::new(pre),
+            prefilter::Choice::ByteSet(pre) => Pre::new(pre),
+            prefilter::Choice::AhoCorasick(pre) => Pre::new(pre),
+        };
+        Some(strat)
+    }
+
+    /// Attempts to extract an alternation of literals, and if it's deemed
+    /// worth doing, returns an Aho-Corasick prefilter as a strategy.
+    ///
+    /// And currently, this only returns something when 'hirs.len() == 1'. This
+    /// could in theory do something if there are multiple HIRs where all of
+    /// them are alternation of literals, but I haven't had the time to go down
+    /// that path yet.
+    fn from_alternation_literals(
+        info: &RegexInfo,
+        hirs: &[&Hir],
+    ) -> Option<Arc<dyn Strategy>> {
+        use crate::util::prefilter::AhoCorasick;
+
+        let lits = crate::meta::literal::alternation_literals(info, hirs)?;
+        let ac = AhoCorasick::new(MatchKind::LeftmostFirst, &lits)?;
+        Some(Pre::new(ac))
+    }
+}
+
+// This implements Strategy for anything that implements PrefilterI.
+//
+// Note that this must only be used for regexes of length 1. Multi-regexes
+// don't work here. The prefilter interface only provides the span of a match
+// and not the pattern ID. (I did consider making it more expressive, but I
+// couldn't figure out how to tie everything together elegantly.) Thus, so long
+// as the regex only contains one pattern, we can simply assume that a match
+// corresponds to PatternID::ZERO. And indeed, that's what we do here.
+//
+// In practice, since this impl is used to report matches directly and thus
+// completely bypasses the regex engine, we only wind up using this under the
+// following restrictions:
+//
+// * There must be only one pattern. As explained above.
+// * The literal sequence must be finite and only contain exact literals.
+// * There must not be any look-around assertions. If there are, the literals
+// extracted might be exact, but a match doesn't necessarily imply an overall
+// match. As a trivial example, 'foo\bbar' does not match 'foobar'.
+// * The pattern must not have any explicit capturing groups. If it does, the
+// caller might expect them to be resolved. e.g., 'foo(bar)'.
+//
+// So when all of those things are true, we use a prefilter directly as a
+// strategy.
+//
+// In the case where the number of patterns is more than 1, we don't use this
+// but do use a special Aho-Corasick strategy if all of the regexes are just
+// simple literals or alternations of literals. (We also use the Aho-Corasick
+// strategy when len(patterns)==1 if the number of literals is large. In that
+// case, literal extraction gives up and will return an infinite set.)
+impl<P: PrefilterI> Strategy for Pre<P> {
+    fn group_info(&self) -> &GroupInfo {
+        &self.group_info
+    }
+
+    fn create_cache(&self) -> Cache {
+        Cache {
+            capmatches: Captures::all(self.group_info().clone()),
+            pikevm: wrappers::PikeVMCache::none(),
+            backtrack: wrappers::BoundedBacktrackerCache::none(),
+            onepass: wrappers::OnePassCache::none(),
+            hybrid: wrappers::HybridCache::none(),
+            revhybrid: wrappers::ReverseHybridCache::none(),
+        }
+    }
+
+    fn reset_cache(&self, _cache: &mut Cache) {}
+
+    fn is_accelerated(&self) -> bool {
+        self.pre.is_fast()
+    }
+
+    fn memory_usage(&self) -> usize {
+        self.pre.memory_usage()
+    }
+
+    fn search(&self, _cache: &mut Cache, input: &Input<'_>) -> Option<Match> {
+        if input.is_done() {
+            return None;
+        }
+        if input.get_anchored().is_anchored() {
+            return self
+                .pre
+                .prefix(input.haystack(), input.get_span())
+                .map(|sp| Match::new(PatternID::ZERO, sp));
+        }
+        self.pre
+            .find(input.haystack(), input.get_span())
+            .map(|sp| Match::new(PatternID::ZERO, sp))
+    }
+
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        self.search(cache, input).map(|m| HalfMatch::new(m.pattern(), m.end()))
+    }
+
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        let m = self.search(cache, input)?;
+        if let Some(slot) = slots.get_mut(0) {
+            *slot = NonMaxUsize::new(m.start());
+        }
+        if let Some(slot) = slots.get_mut(1) {
+            *slot = NonMaxUsize::new(m.end());
+        }
+        Some(m.pattern())
+    }
+
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        if self.search(cache, input).is_some() {
+            patset.insert(PatternID::ZERO);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Core {
+    info: RegexInfo,
+    pre: Option<Prefilter>,
+    nfa: NFA,
+    nfarev: Option<NFA>,
+    pikevm: wrappers::PikeVM,
+    backtrack: wrappers::BoundedBacktracker,
+    onepass: wrappers::OnePass,
+    hybrid: wrappers::Hybrid,
+    dfa: wrappers::DFA,
+}
+
+impl Core {
+    fn new(
+        info: RegexInfo,
+        pre: Option<Prefilter>,
+        hirs: &[&Hir],
+    ) -> Result<Core, BuildError> {
+        let mut lookm = LookMatcher::new();
+        lookm.set_line_terminator(info.config().get_line_terminator());
+        let thompson_config = thompson::Config::new()
+            .utf8(info.config().get_utf8_empty())
+            .nfa_size_limit(info.config().get_nfa_size_limit())
+            .shrink(false)
+            .captures(true)
+            .look_matcher(lookm);
+        let nfa = thompson::Compiler::new()
+            .configure(thompson_config.clone())
+            .build_many_from_hir(hirs)
+            .map_err(BuildError::nfa)?;
+        // It's possible for the PikeVM or the BB to fail to build, even though
+        // at this point, we already have a full NFA in hand. They can fail
+        // when a Unicode word boundary is used but where Unicode word boundary
+        // support is disabled at compile time, thus making it impossible to
+        // match. (Construction can also fail if the NFA was compiled without
+        // captures, but we always enable that above.)
+        let pikevm = wrappers::PikeVM::new(&info, pre.clone(), &nfa)?;
+        let backtrack =
+            wrappers::BoundedBacktracker::new(&info, pre.clone(), &nfa)?;
+        // The onepass engine can of course fail to build, but we expect it to
+        // fail in many cases because it is an optimization that doesn't apply
+        // to all regexes. The 'OnePass' wrapper encapsulates this failure (and
+        // logs a message if it occurs).
+        let onepass = wrappers::OnePass::new(&info, &nfa);
+        // We try to encapsulate whether a particular regex engine should be
+        // used within each respective wrapper, but the DFAs need a reverse NFA
+        // to build itself, and we really do not want to build a reverse NFA if
+        // we know we aren't going to use the lazy DFA. So we do a config check
+        // up front, which is in practice the only way we won't try to use the
+        // DFA.
+        let (nfarev, hybrid, dfa) =
+            if !info.config().get_hybrid() && !info.config().get_dfa() {
+                (None, wrappers::Hybrid::none(), wrappers::DFA::none())
+            } else {
+                // FIXME: Technically, we don't quite yet KNOW that we need
+                // a reverse NFA. It's possible for the DFAs below to both
+                // fail to build just based on the forward NFA. In which case,
+                // building the reverse NFA was totally wasted work. But...
+                // fixing this requires breaking DFA construction apart into
+                // two pieces: one for the forward part and another for the
+                // reverse part. Quite annoying. Making it worse, when building
+                // both DFAs fails, it's quite likely that the NFA is large and
+                // that it will take quite some time to build the reverse NFA
+                // too. So... it's really probably worth it to do this!
+                let nfarev = thompson::Compiler::new()
+                    // Currently, reverse NFAs don't support capturing groups,
+                    // so we MUST disable them. But even if we didn't have to,
+                    // we would, because nothing in this crate does anything
+                    // useful with capturing groups in reverse. And of course,
+                    // the lazy DFA ignores capturing groups in all cases.
+                    .configure(
+                        thompson_config.clone().captures(false).reverse(true),
+                    )
+                    .build_many_from_hir(hirs)
+                    .map_err(BuildError::nfa)?;
+                let dfa = if !info.config().get_dfa() {
+                    wrappers::DFA::none()
+                } else {
+                    wrappers::DFA::new(&info, pre.clone(), &nfa, &nfarev)
+                };
+                let hybrid = if !info.config().get_hybrid() {
+                    wrappers::Hybrid::none()
+                } else if dfa.is_some() {
+                    debug!("skipping lazy DFA because we have a full DFA");
+                    wrappers::Hybrid::none()
+                } else {
+                    wrappers::Hybrid::new(&info, pre.clone(), &nfa, &nfarev)
+                };
+                (Some(nfarev), hybrid, dfa)
+            };
+        Ok(Core {
+            info,
+            pre,
+            nfa,
+            nfarev,
+            pikevm,
+            backtrack,
+            onepass,
+            hybrid,
+            dfa,
+        })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_mayfail(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<Result<Option<Match>, RetryFailError>> {
+        if let Some(e) = self.dfa.get(input) {
+            trace!("using full DFA for search at {:?}", input.get_span());
+            Some(e.try_search(input))
+        } else if let Some(e) = self.hybrid.get(input) {
+            trace!("using lazy DFA for search at {:?}", input.get_span());
+            Some(e.try_search(&mut cache.hybrid, input))
+        } else {
+            None
+        }
+    }
+
+    fn search_nofail(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<Match> {
+        let caps = &mut cache.capmatches;
+        caps.set_pattern(None);
+        // We manually inline 'try_search_slots_nofail' here because we need to
+        // borrow from 'cache.capmatches' in this method, but if we do, then
+        // we can't pass 'cache' wholesale to to 'try_slots_no_hybrid'. It's a
+        // classic example of how the borrow checker inhibits decomposition.
+        // There are of course work-arounds (more types and/or interior
+        // mutability), but that's more annoying than this IMO.
+        let pid = if let Some(ref e) = self.onepass.get(input) {
+            trace!("using OnePass for search at {:?}", input.get_span());
+            e.search_slots(&mut cache.onepass, input, caps.slots_mut())
+        } else if let Some(ref e) = self.backtrack.get(input) {
+            trace!(
+                "using BoundedBacktracker for search at {:?}",
+                input.get_span()
+            );
+            e.search_slots(&mut cache.backtrack, input, caps.slots_mut())
+        } else {
+            trace!("using PikeVM for search at {:?}", input.get_span());
+            let e = self.pikevm.get();
+            e.search_slots(&mut cache.pikevm, input, caps.slots_mut())
+        };
+        caps.set_pattern(pid);
+        caps.get_match()
+    }
+
+    fn search_half_nofail(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        // Only the lazy/full DFA returns half-matches, since the DFA requires
+        // a reverse scan to find the start position. These fallback regex
+        // engines can find the start and end in a single pass, so we just do
+        // that and throw away the start offset to conform to the API.
+        let m = self.search_nofail(cache, input)?;
+        Some(HalfMatch::new(m.pattern(), m.end()))
+    }
+
+    fn search_slots_nofail(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        if let Some(ref e) = self.onepass.get(input) {
+            trace!(
+                "using OnePass for capture search at {:?}",
+                input.get_span()
+            );
+            e.search_slots(&mut cache.onepass, input, slots)
+        } else if let Some(ref e) = self.backtrack.get(input) {
+            trace!(
+                "using BoundedBacktracker for capture search at {:?}",
+                input.get_span()
+            );
+            e.search_slots(&mut cache.backtrack, input, slots)
+        } else {
+            trace!(
+                "using PikeVM for capture search at {:?}",
+                input.get_span()
+            );
+            let e = self.pikevm.get();
+            e.search_slots(&mut cache.pikevm, input, slots)
+        }
+    }
+
+    fn is_capture_search_needed(&self, slots_len: usize) -> bool {
+        slots_len > self.nfa.group_info().implicit_slot_len()
+    }
+}
+
+impl Strategy for Core {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn group_info(&self) -> &GroupInfo {
+        self.nfa.group_info()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn create_cache(&self) -> Cache {
+        Cache {
+            capmatches: Captures::all(self.group_info().clone()),
+            pikevm: self.pikevm.create_cache(),
+            backtrack: self.backtrack.create_cache(),
+            onepass: self.onepass.create_cache(),
+            hybrid: self.hybrid.create_cache(),
+            revhybrid: wrappers::ReverseHybridCache::none(),
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn reset_cache(&self, cache: &mut Cache) {
+        cache.pikevm.reset(&self.pikevm);
+        cache.backtrack.reset(&self.backtrack);
+        cache.onepass.reset(&self.onepass);
+        cache.hybrid.reset(&self.hybrid);
+    }
+
+    fn is_accelerated(&self) -> bool {
+        self.pre.as_ref().map_or(false, |pre| pre.is_fast())
+    }
+
+    fn memory_usage(&self) -> usize {
+        self.info.memory_usage()
+            + self.pre.as_ref().map_or(0, |pre| pre.memory_usage())
+            + self.nfa.memory_usage()
+            + self.nfarev.as_ref().map_or(0, |nfa| nfa.memory_usage())
+            + self.onepass.memory_usage()
+            + self.dfa.memory_usage()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search(&self, cache: &mut Cache, input: &Input<'_>) -> Option<Match> {
+        // We manually inline try_search_mayfail here because letting the
+        // compiler do it seems to produce pretty crappy codegen.
+        return if let Some(e) = self.dfa.get(input) {
+            trace!("using full DFA for full search at {:?}", input.get_span());
+            match e.try_search(input) {
+                Ok(x) => x,
+                Err(_err) => {
+                    trace!("full DFA search failed: {}", _err);
+                    self.search_nofail(cache, input)
+                }
+            }
+        } else if let Some(e) = self.hybrid.get(input) {
+            trace!("using lazy DFA for full search at {:?}", input.get_span());
+            match e.try_search(&mut cache.hybrid, input) {
+                Ok(x) => x,
+                Err(_err) => {
+                    trace!("lazy DFA search failed: {}", _err);
+                    self.search_nofail(cache, input)
+                }
+            }
+        } else {
+            self.search_nofail(cache, input)
+        };
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        // The main difference with 'search' is that if we're using a DFA, we
+        // can use a single forward scan without needing to run the reverse
+        // DFA.
+        return if let Some(e) = self.dfa.get(input) {
+            trace!("using full DFA for half search at {:?}", input.get_span());
+            match e.try_search_half_fwd(input) {
+                Ok(x) => x,
+                Err(_err) => {
+                    trace!("full DFA half search failed: {}", _err);
+                    self.search_half_nofail(cache, input)
+                }
+            }
+        } else if let Some(e) = self.hybrid.get(input) {
+            trace!("using lazy DFA for half search at {:?}", input.get_span());
+            match e.try_search_half_fwd(&mut cache.hybrid, input) {
+                Ok(x) => x,
+                Err(_err) => {
+                    trace!("lazy DFA half search failed: {}", _err);
+                    self.search_half_nofail(cache, input)
+                }
+            }
+        } else {
+            self.search_half_nofail(cache, input)
+        };
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        // Even if the regex has explicit capture groups, if the caller didn't
+        // provide any explicit slots, then it doesn't make sense to try and do
+        // extra work to get offsets for those slots. Ideally the caller should
+        // realize this and not call this routine in the first place, but alas,
+        // we try to save the caller from themselves if they do.
+        if !self.is_capture_search_needed(slots.len()) {
+            trace!("asked for slots unnecessarily, trying fast path");
+            let m = self.search(cache, input)?;
+            copy_match_to_slots(m, slots);
+            return Some(m.pattern());
+        }
+        // If the onepass DFA is available for this search (which only happens
+        // when it's anchored), then skip running a fallible DFA. The onepass
+        // DFA isn't as fast as a full or lazy DFA, but it is typically quite
+        // a bit faster than the backtracker or the PikeVM. So it isn't as
+        // advantageous to try and do a full/lazy DFA scan first.
+        //
+        // We still theorize that it's better to do a full/lazy DFA scan, even
+        // when it's anchored, because it's usually much faster and permits us
+        // to say "no match" much more quickly. This does hurt the case of,
+        // say, parsing each line in a log file into capture groups, because
+        // in that case, the line always matches. So the lazy DFA scan is
+        // usually just wasted work. But, the lazy DFA is usually quite fast
+        // and doesn't cost too much here.
+        if self.onepass.get(&input).is_some() {
+            return self.search_slots_nofail(cache, &input, slots);
+        }
+        let m = match self.try_search_mayfail(cache, input) {
+            Some(Ok(Some(m))) => m,
+            Some(Ok(None)) => return None,
+            Some(Err(_err)) => {
+                trace!("fast capture search failed: {}", _err);
+                return self.search_slots_nofail(cache, input, slots);
+            }
+            None => {
+                return self.search_slots_nofail(cache, input, slots);
+            }
+        };
+        // At this point, now that we've found the bounds of the
+        // match, we need to re-run something that can resolve
+        // capturing groups. But we only need to run on it on the
+        // match bounds and not the entire haystack.
+        trace!(
+            "match found at {}..{} in capture search, \
+		  	 using another engine to find captures",
+            m.start(),
+            m.end(),
+        );
+        let input = input
+            .clone()
+            .span(m.start()..m.end())
+            .anchored(Anchored::Pattern(m.pattern()));
+        Some(
+            self.search_slots_nofail(cache, &input, slots)
+                .expect("should find a match"),
+        )
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        if let Some(e) = self.dfa.get(input) {
+            trace!(
+                "using full DFA for overlapping search at {:?}",
+                input.get_span()
+            );
+            let _err = match e.try_which_overlapping_matches(input, patset) {
+                Ok(()) => return,
+                Err(err) => err,
+            };
+            trace!("fast overlapping search failed: {}", _err);
+        } else if let Some(e) = self.hybrid.get(input) {
+            trace!(
+                "using lazy DFA for overlapping search at {:?}",
+                input.get_span()
+            );
+            let _err = match e.try_which_overlapping_matches(
+                &mut cache.hybrid,
+                input,
+                patset,
+            ) {
+                Ok(()) => {
+                    return;
+                }
+                Err(err) => err,
+            };
+            trace!("fast overlapping search failed: {}", _err);
+        }
+        trace!(
+            "using PikeVM for overlapping search at {:?}",
+            input.get_span()
+        );
+        let e = self.pikevm.get();
+        e.which_overlapping_matches(&mut cache.pikevm, input, patset)
+    }
+}
+
+#[derive(Debug)]
+struct ReverseAnchored {
+    core: Core,
+}
+
+impl ReverseAnchored {
+    fn new(core: Core) -> Result<ReverseAnchored, Core> {
+        if !core.info.is_always_anchored_end() {
+            debug!(
+                "skipping reverse anchored optimization because \
+				 the regex is not always anchored at the end"
+            );
+            return Err(core);
+        }
+        if core.info.is_always_anchored_start() {
+            debug!(
+                "skipping reverse anchored optimization because \
+				 the regex is also anchored at the start"
+            );
+            return Err(core);
+        }
+        // Only DFAs can do reverse searches (currently), so we need one of
+        // them in order to do this optimization. It's possible (although
+        // pretty unlikely) that we have neither and need to give up.
+        if !core.hybrid.is_some() && !core.dfa.is_some() {
+            debug!(
+                "skipping reverse anchored optimization because \
+				 we don't have a lazy DFA or a full DFA"
+            );
+            return Err(core);
+        }
+        Ok(ReverseAnchored { core })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_anchored_rev(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        // We of course always want an anchored search. In theory, the
+        // underlying regex engines should automatically enable anchored
+        // searches since the regex is itself anchored, but this more clearly
+        // expresses intent and is always correct.
+        let input = input.clone().anchored(Anchored::Yes);
+        if let Some(e) = self.core.dfa.get(&input) {
+            trace!(
+                "using full DFA for reverse anchored search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_rev(&input)
+        } else if let Some(e) = self.core.hybrid.get(&input) {
+            trace!(
+                "using lazy DFA for reverse anchored search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_rev(&mut cache.hybrid, &input)
+        } else {
+            unreachable!("ReverseAnchored always has a DFA")
+        }
+    }
+}
+
+// Note that in this impl, we don't check that 'input.end() ==
+// input.haystack().len()'. In particular, when that condition is false, a
+// match is always impossible because we know that the regex is always anchored
+// at the end (or else 'ReverseAnchored' won't be built). We don't check that
+// here because the 'Regex' wrapper actually does that for us in all cases.
+// Thus, in this impl, we can actually assume that the end position in 'input'
+// is equivalent to the length of the haystack.
+impl Strategy for ReverseAnchored {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn group_info(&self) -> &GroupInfo {
+        self.core.group_info()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn create_cache(&self) -> Cache {
+        self.core.create_cache()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn reset_cache(&self, cache: &mut Cache) {
+        self.core.reset_cache(cache);
+    }
+
+    fn is_accelerated(&self) -> bool {
+        // Since this is anchored at the end, a reverse anchored search is
+        // almost certainly guaranteed to result in a much faster search than
+        // a standard forward search.
+        true
+    }
+
+    fn memory_usage(&self) -> usize {
+        self.core.memory_usage()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search(&self, cache: &mut Cache, input: &Input<'_>) -> Option<Match> {
+        match self.try_search_half_anchored_rev(cache, input) {
+            Err(_err) => {
+                trace!("fast reverse anchored search failed: {}", _err);
+                self.core.search_nofail(cache, input)
+            }
+            Ok(None) => None,
+            Ok(Some(hm)) => {
+                Some(Match::new(hm.pattern(), hm.offset()..input.end()))
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        match self.try_search_half_anchored_rev(cache, input) {
+            Err(_err) => {
+                trace!("fast reverse anchored search failed: {}", _err);
+                self.core.search_half_nofail(cache, input)
+            }
+            Ok(None) => None,
+            Ok(Some(hm)) => {
+                // Careful here! 'try_search_half' is a *forward* search that
+                // only cares about the *end* position of a match. But
+                // 'hm.offset()' is actually the start of the match. So we
+                // actually just throw that away here and, since we know we
+                // have a match, return the only possible position at which a
+                // match can occur: input.end().
+                Some(HalfMatch::new(hm.pattern(), input.end()))
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        match self.try_search_half_anchored_rev(cache, input) {
+            Err(_err) => {
+                trace!("fast reverse anchored search failed: {}", _err);
+                self.core.search_slots_nofail(cache, input, slots)
+            }
+            Ok(None) => None,
+            Ok(Some(hm)) => {
+                if !self.core.is_capture_search_needed(slots.len()) {
+                    trace!("asked for slots unnecessarily, skipping captures");
+                    let m = Match::new(hm.pattern(), hm.offset()..input.end());
+                    copy_match_to_slots(m, slots);
+                    return Some(m.pattern());
+                }
+                let start = hm.offset();
+                let input = input
+                    .clone()
+                    .span(start..input.end())
+                    .anchored(Anchored::Pattern(hm.pattern()));
+                self.core.search_slots_nofail(cache, &input, slots)
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        // It seems like this could probably benefit from a reverse anchored
+        // optimization, perhaps by doing an overlapping reverse search (which
+        // the DFAs do support). I haven't given it much thought though, and
+        // I'm currently focus more on the single pattern case.
+        self.core.which_overlapping_matches(cache, input, patset)
+    }
+}
+
+#[derive(Debug)]
+struct ReverseSuffix {
+    core: Core,
+    pre: Prefilter,
+}
+
+impl ReverseSuffix {
+    fn new(core: Core, hirs: &[&Hir]) -> Result<ReverseSuffix, Core> {
+        if !core.info.config().get_auto_prefilter() {
+            debug!(
+                "skipping reverse suffix optimization because \
+                 automatic prefilters are disabled"
+            );
+            return Err(core);
+        }
+        // Like the reverse inner optimization, we don't do this for regexes
+        // that are always anchored. It could lead to scanning too much, but
+        // could say "no match" much more quickly than running the regex
+        // engine if the initial literal scan doesn't match. With that said,
+        // the reverse suffix optimization has lower overhead, since it only
+        // requires a reverse scan after a literal match to confirm or reject
+        // the match. (Although, in the case of confirmation, it then needs to
+        // do another forward scan to find the end position.)
+        if core.info.is_always_anchored_start() {
+            debug!(
+                "skipping reverse suffix optimization because \
+				 the regex is always anchored at the start",
+            );
+            return Err(core);
+        }
+        // Only DFAs can do reverse searches (currently), so we need one of
+        // them in order to do this optimization. It's possible (although
+        // pretty unlikely) that we have neither and need to give up.
+        if !core.hybrid.is_some() && !core.dfa.is_some() {
+            debug!(
+                "skipping reverse suffix optimization because \
+				 we don't have a lazy DFA or a full DFA"
+            );
+            return Err(core);
+        }
+        if core.pre.as_ref().map_or(false, |p| p.is_fast()) {
+            debug!(
+                "skipping reverse suffix optimization because \
+				 we already have a prefilter that we think is fast"
+            );
+            return Err(core);
+        }
+        let kind = core.info.config().get_match_kind();
+        let suffixes = crate::util::prefilter::suffixes(kind, hirs);
+        let lcs = match suffixes.longest_common_suffix() {
+            None => {
+                debug!(
+                    "skipping reverse suffix optimization because \
+                     a longest common suffix could not be found",
+                );
+                return Err(core);
+            }
+            Some(lcs) if lcs.is_empty() => {
+                debug!(
+                    "skipping reverse suffix optimization because \
+                     the longest common suffix is the empty string",
+                );
+                return Err(core);
+            }
+            Some(lcs) => lcs,
+        };
+        let pre = match Prefilter::new(kind, &[lcs]) {
+            Some(pre) => pre,
+            None => {
+                debug!(
+                    "skipping reverse suffix optimization because \
+                     a prefilter could not be constructed from the \
+                     longest common suffix",
+                );
+                return Err(core);
+            }
+        };
+        if !pre.is_fast() {
+            debug!(
+                "skipping reverse suffix optimization because \
+				 while we have a suffix prefilter, it is not \
+				 believed to be 'fast'"
+            );
+            return Err(core);
+        }
+        Ok(ReverseSuffix { core, pre })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_start(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        let mut span = input.get_span();
+        let mut min_start = 0;
+        loop {
+            let litmatch = match self.pre.find(input.haystack(), span) {
+                None => return Ok(None),
+                Some(span) => span,
+            };
+            trace!("reverse suffix scan found suffix match at {:?}", litmatch);
+            let revinput = input
+                .clone()
+                .anchored(Anchored::Yes)
+                .span(input.start()..litmatch.end);
+            match self
+                .try_search_half_rev_limited(cache, &revinput, min_start)?
+            {
+                None => {
+                    if span.start >= span.end {
+                        break;
+                    }
+                    span.start = litmatch.start.checked_add(1).unwrap();
+                }
+                Some(hm) => return Ok(Some(hm)),
+            }
+            min_start = litmatch.end;
+        }
+        Ok(None)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_fwd(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        if let Some(e) = self.core.dfa.get(&input) {
+            trace!(
+                "using full DFA for forward reverse suffix search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_fwd(&input)
+        } else if let Some(e) = self.core.hybrid.get(&input) {
+            trace!(
+                "using lazy DFA for forward reverse suffix search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_fwd(&mut cache.hybrid, &input)
+        } else {
+            unreachable!("ReverseSuffix always has a DFA")
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_rev_limited(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        if let Some(e) = self.core.dfa.get(&input) {
+            trace!(
+                "using full DFA for reverse suffix search at {:?}, \
+                 but will be stopped at {} to avoid quadratic behavior",
+                input.get_span(),
+                min_start,
+            );
+            e.try_search_half_rev_limited(&input, min_start)
+        } else if let Some(e) = self.core.hybrid.get(&input) {
+            trace!(
+                "using lazy DFA for reverse inner search at {:?}, \
+                 but will be stopped at {} to avoid quadratic behavior",
+                input.get_span(),
+                min_start,
+            );
+            e.try_search_half_rev_limited(&mut cache.hybrid, &input, min_start)
+        } else {
+            unreachable!("ReverseSuffix always has a DFA")
+        }
+    }
+}
+
+impl Strategy for ReverseSuffix {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn group_info(&self) -> &GroupInfo {
+        self.core.group_info()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn create_cache(&self) -> Cache {
+        self.core.create_cache()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn reset_cache(&self, cache: &mut Cache) {
+        self.core.reset_cache(cache);
+    }
+
+    fn is_accelerated(&self) -> bool {
+        self.pre.is_fast()
+    }
+
+    fn memory_usage(&self) -> usize {
+        self.core.memory_usage() + self.pre.memory_usage()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search(&self, cache: &mut Cache, input: &Input<'_>) -> Option<Match> {
+        match self.try_search_half_start(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!("reverse suffix optimization failed: {}", _err);
+                self.core.search(cache, input)
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!("reverse suffix reverse fast search failed: {}", _err);
+                self.core.search_nofail(cache, input)
+            }
+            Ok(None) => None,
+            Ok(Some(hm_start)) => {
+                let fwdinput = input
+                    .clone()
+                    .anchored(Anchored::Pattern(hm_start.pattern()))
+                    .span(hm_start.offset()..input.end());
+                match self.try_search_half_fwd(cache, &fwdinput) {
+                    Err(_err) => {
+                        trace!(
+                            "reverse suffix forward fast search failed: {}",
+                            _err
+                        );
+                        self.core.search_nofail(cache, input)
+                    }
+                    Ok(None) => {
+                        unreachable!(
+                            "suffix match plus reverse match implies \
+						     there must be a match",
+                        )
+                    }
+                    Ok(Some(hm_end)) => Some(Match::new(
+                        hm_start.pattern(),
+                        hm_start.offset()..hm_end.offset(),
+                    )),
+                }
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        match self.try_search_half_start(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!("reverse suffix half optimization failed: {}", _err);
+                self.core.search_half(cache, input)
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!(
+                    "reverse suffix reverse fast half search failed: {}",
+                    _err
+                );
+                self.core.search_half_nofail(cache, input)
+            }
+            Ok(None) => None,
+            Ok(Some(hm_start)) => {
+                // This is a bit subtle. It is tempting to just stop searching
+                // at this point and return a half-match with an offset
+                // corresponding to where the suffix was found. But the suffix
+                // match does not necessarily correspond to the end of the
+                // proper leftmost-first match. Consider /[a-z]+ing/ against
+                // 'tingling'. The first suffix match is the first 'ing', and
+                // the /[a-z]+/ matches the 't'. So if we stopped here, then
+                // we'd report 'ting' as the match. But 'tingling' is the
+                // correct match because of greediness.
+                let fwdinput = input
+                    .clone()
+                    .anchored(Anchored::Pattern(hm_start.pattern()))
+                    .span(hm_start.offset()..input.end());
+                match self.try_search_half_fwd(cache, &fwdinput) {
+                    Err(_err) => {
+                        trace!(
+                            "reverse suffix forward fast search failed: {}",
+                            _err
+                        );
+                        self.core.search_half_nofail(cache, input)
+                    }
+                    Ok(None) => {
+                        unreachable!(
+                            "suffix match plus reverse match implies \
+						     there must be a match",
+                        )
+                    }
+                    Ok(Some(hm_end)) => Some(hm_end),
+                }
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        if !self.core.is_capture_search_needed(slots.len()) {
+            trace!("asked for slots unnecessarily, trying fast path");
+            let m = self.search(cache, input)?;
+            copy_match_to_slots(m, slots);
+            return Some(m.pattern());
+        }
+        let hm_start = match self.try_search_half_start(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!(
+                    "reverse suffix captures optimization failed: {}",
+                    _err
+                );
+                return self.core.search_slots(cache, input, slots);
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!(
+                    "reverse suffix reverse fast captures search failed: {}",
+                    _err
+                );
+                return self.core.search_slots_nofail(cache, input, slots);
+            }
+            Ok(None) => return None,
+            Ok(Some(hm_start)) => hm_start,
+        };
+        trace!(
+            "match found at {}..{} in capture search, \
+		  	 using another engine to find captures",
+            hm_start.offset(),
+            input.end(),
+        );
+        let start = hm_start.offset();
+        let input = input
+            .clone()
+            .span(start..input.end())
+            .anchored(Anchored::Pattern(hm_start.pattern()));
+        self.core.search_slots_nofail(cache, &input, slots)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        self.core.which_overlapping_matches(cache, input, patset)
+    }
+}
+
+#[derive(Debug)]
+struct ReverseInner {
+    core: Core,
+    preinner: Prefilter,
+    nfarev: NFA,
+    hybrid: wrappers::ReverseHybrid,
+    dfa: wrappers::ReverseDFA,
+}
+
+impl ReverseInner {
+    fn new(core: Core, hirs: &[&Hir]) -> Result<ReverseInner, Core> {
+        if !core.info.config().get_auto_prefilter() {
+            debug!(
+                "skipping reverse inner optimization because \
+                 automatic prefilters are disabled"
+            );
+            return Err(core);
+        }
+        // Currently we hard-code the assumption of leftmost-first match
+        // semantics. This isn't a huge deal because 'all' semantics tend to
+        // only be used for forward overlapping searches with multiple regexes,
+        // and this optimization only supports a single pattern at the moment.
+        if core.info.config().get_match_kind() != MatchKind::LeftmostFirst {
+            debug!(
+                "skipping reverse inner optimization because \
+				 match kind is {:?} but this only supports leftmost-first",
+                core.info.config().get_match_kind(),
+            );
+            return Err(core);
+        }
+        // It's likely that a reverse inner scan has too much overhead for it
+        // to be worth it when the regex is anchored at the start. It is
+        // possible for it to be quite a bit faster if the initial literal
+        // scan fails to detect a match, in which case, we can say "no match"
+        // very quickly. But this could be undesirable, e.g., scanning too far
+        // or when the literal scan matches. If it matches, then confirming the
+        // match requires a reverse scan followed by a forward scan to confirm
+        // or reject, which is a fair bit of work.
+        if core.info.is_always_anchored_start() {
+            debug!(
+                "skipping reverse inner optimization because \
+				 the regex is always anchored at the start",
+            );
+            return Err(core);
+        }
+        // Only DFAs can do reverse searches (currently), so we need one of
+        // them in order to do this optimization. It's possible (although
+        // pretty unlikely) that we have neither and need to give up.
+        if !core.hybrid.is_some() && !core.dfa.is_some() {
+            debug!(
+                "skipping reverse inner optimization because \
+				 we don't have a lazy DFA or a full DFA"
+            );
+            return Err(core);
+        }
+        if core.pre.as_ref().map_or(false, |p| p.is_fast()) {
+            debug!(
+                "skipping reverse inner optimization because \
+				 we already have a prefilter that we think is fast"
+            );
+            return Err(core);
+        } else if core.pre.is_some() {
+            debug!(
+                "core engine has a prefix prefilter, but it is \
+                 probably not fast, so continuing with attempt to \
+                 use reverse inner prefilter"
+            );
+        }
+        let (concat_prefix, preinner) = match reverse_inner::extract(hirs) {
+            Some(x) => x,
+            // N.B. the 'extract' function emits debug messages explaining
+            // why we bailed out here.
+            None => return Err(core),
+        };
+        debug!("building reverse NFA for prefix before inner literal");
+        let mut lookm = LookMatcher::new();
+        lookm.set_line_terminator(core.info.config().get_line_terminator());
+        let thompson_config = thompson::Config::new()
+            .reverse(true)
+            .utf8(core.info.config().get_utf8_empty())
+            .nfa_size_limit(core.info.config().get_nfa_size_limit())
+            .shrink(false)
+            .captures(false)
+            .look_matcher(lookm);
+        let result = thompson::Compiler::new()
+            .configure(thompson_config)
+            .build_from_hir(&concat_prefix);
+        let nfarev = match result {
+            Ok(nfarev) => nfarev,
+            Err(_err) => {
+                debug!(
+                    "skipping reverse inner optimization because the \
+					 reverse NFA failed to build: {}",
+                    _err,
+                );
+                return Err(core);
+            }
+        };
+        debug!("building reverse DFA for prefix before inner literal");
+        let dfa = if !core.info.config().get_dfa() {
+            wrappers::ReverseDFA::none()
+        } else {
+            wrappers::ReverseDFA::new(&core.info, &nfarev)
+        };
+        let hybrid = if !core.info.config().get_hybrid() {
+            wrappers::ReverseHybrid::none()
+        } else if dfa.is_some() {
+            debug!(
+                "skipping lazy DFA for reverse inner optimization \
+				 because we have a full DFA"
+            );
+            wrappers::ReverseHybrid::none()
+        } else {
+            wrappers::ReverseHybrid::new(&core.info, &nfarev)
+        };
+        Ok(ReverseInner { core, preinner, nfarev, hybrid, dfa })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_full(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Option<Match>, RetryError> {
+        let mut span = input.get_span();
+        let mut min_match_start = 0;
+        let mut min_pre_start = 0;
+        loop {
+            let litmatch = match self.preinner.find(input.haystack(), span) {
+                None => return Ok(None),
+                Some(span) => span,
+            };
+            if litmatch.start < min_pre_start {
+                trace!(
+                    "found inner prefilter match at {:?}, which starts \
+					 before the end of the last forward scan at {}, \
+					 quitting to avoid quadratic behavior",
+                    litmatch,
+                    min_pre_start,
+                );
+                return Err(RetryError::Quadratic(RetryQuadraticError::new()));
+            }
+            trace!("reverse inner scan found inner match at {:?}", litmatch);
+            let revinput = input
+                .clone()
+                .anchored(Anchored::Yes)
+                .span(input.start()..litmatch.start);
+            // Note that in addition to the literal search above scanning past
+            // our minimum start point, this routine can also return an error
+            // as a result of detecting possible quadratic behavior if the
+            // reverse scan goes past the minimum start point. That is, the
+            // literal search might not, but the reverse regex search for the
+            // prefix might!
+            match self.try_search_half_rev_limited(
+                cache,
+                &revinput,
+                min_match_start,
+            )? {
+                None => {
+                    if span.start >= span.end {
+                        break;
+                    }
+                    span.start = litmatch.start.checked_add(1).unwrap();
+                }
+                Some(hm_start) => {
+                    let fwdinput = input
+                        .clone()
+                        .anchored(Anchored::Pattern(hm_start.pattern()))
+                        .span(hm_start.offset()..input.end());
+                    match self.try_search_half_fwd_stopat(cache, &fwdinput)? {
+                        Err(stopat) => {
+                            min_pre_start = stopat;
+                            span.start =
+                                litmatch.start.checked_add(1).unwrap();
+                        }
+                        Ok(hm_end) => {
+                            return Ok(Some(Match::new(
+                                hm_start.pattern(),
+                                hm_start.offset()..hm_end.offset(),
+                            )))
+                        }
+                    }
+                }
+            }
+            min_match_start = litmatch.end;
+        }
+        Ok(None)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_fwd_stopat(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<Result<HalfMatch, usize>, RetryFailError> {
+        if let Some(e) = self.core.dfa.get(&input) {
+            trace!(
+                "using full DFA for forward reverse inner search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_fwd_stopat(&input)
+        } else if let Some(e) = self.core.hybrid.get(&input) {
+            trace!(
+                "using lazy DFA for forward reverse inner search at {:?}",
+                input.get_span()
+            );
+            e.try_search_half_fwd_stopat(&mut cache.hybrid, &input)
+        } else {
+            unreachable!("ReverseInner always has a DFA")
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn try_search_half_rev_limited(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        if let Some(e) = self.dfa.get(&input) {
+            trace!(
+                "using full DFA for reverse inner search at {:?}, \
+                 but will be stopped at {} to avoid quadratic behavior",
+                input.get_span(),
+                min_start,
+            );
+            e.try_search_half_rev_limited(&input, min_start)
+        } else if let Some(e) = self.hybrid.get(&input) {
+            trace!(
+                "using lazy DFA for reverse inner search at {:?}, \
+                 but will be stopped at {} to avoid quadratic behavior",
+                input.get_span(),
+                min_start,
+            );
+            e.try_search_half_rev_limited(
+                &mut cache.revhybrid,
+                &input,
+                min_start,
+            )
+        } else {
+            unreachable!("ReverseInner always has a DFA")
+        }
+    }
+}
+
+impl Strategy for ReverseInner {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn group_info(&self) -> &GroupInfo {
+        self.core.group_info()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn create_cache(&self) -> Cache {
+        let mut cache = self.core.create_cache();
+        cache.revhybrid = self.hybrid.create_cache();
+        cache
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn reset_cache(&self, cache: &mut Cache) {
+        self.core.reset_cache(cache);
+        cache.revhybrid.reset(&self.hybrid);
+    }
+
+    fn is_accelerated(&self) -> bool {
+        self.preinner.is_fast()
+    }
+
+    fn memory_usage(&self) -> usize {
+        self.core.memory_usage()
+            + self.preinner.memory_usage()
+            + self.nfarev.memory_usage()
+            + self.dfa.memory_usage()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search(&self, cache: &mut Cache, input: &Input<'_>) -> Option<Match> {
+        match self.try_search_full(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!("reverse inner optimization failed: {}", _err);
+                self.core.search(cache, input)
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!("reverse inner fast search failed: {}", _err);
+                self.core.search_nofail(cache, input)
+            }
+            Ok(matornot) => matornot,
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_half(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Option<HalfMatch> {
+        match self.try_search_full(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!("reverse inner half optimization failed: {}", _err);
+                self.core.search_half(cache, input)
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!("reverse inner fast half search failed: {}", _err);
+                self.core.search_half_nofail(cache, input)
+            }
+            Ok(None) => None,
+            Ok(Some(m)) => Some(HalfMatch::new(m.pattern(), m.end())),
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        if !self.core.is_capture_search_needed(slots.len()) {
+            trace!("asked for slots unnecessarily, trying fast path");
+            let m = self.search(cache, input)?;
+            copy_match_to_slots(m, slots);
+            return Some(m.pattern());
+        }
+        let m = match self.try_search_full(cache, input) {
+            Err(RetryError::Quadratic(_err)) => {
+                trace!("reverse inner captures optimization failed: {}", _err);
+                return self.core.search_slots(cache, input, slots);
+            }
+            Err(RetryError::Fail(_err)) => {
+                trace!("reverse inner fast captures search failed: {}", _err);
+                return self.core.search_slots_nofail(cache, input, slots);
+            }
+            Ok(None) => return None,
+            Ok(Some(m)) => m,
+        };
+        trace!(
+            "match found at {}..{} in capture search, \
+		  	 using another engine to find captures",
+            m.start(),
+            m.end(),
+        );
+        let input = input
+            .clone()
+            .span(m.start()..m.end())
+            .anchored(Anchored::Pattern(m.pattern()));
+        self.core.search_slots_nofail(cache, &input, slots)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        self.core.which_overlapping_matches(cache, input, patset)
+    }
+}
+
+/// Copies the offsets in the given match to the corresponding positions in
+/// `slots`.
+///
+/// In effect, this sets the slots corresponding to the implicit group for the
+/// pattern in the given match. If the indices for the corresponding slots do
+/// not exist, then no slots are set.
+///
+/// This is useful when the caller provides slots (or captures), but you use a
+/// regex engine that doesn't operate on slots (like a lazy DFA). This function
+/// lets you map the match you get back to the slots provided by the caller.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn copy_match_to_slots(m: Match, slots: &mut [Option<NonMaxUsize>]) {
+    let slot_start = m.pattern().as_usize() * 2;
+    let slot_end = slot_start + 1;
+    if let Some(slot) = slots.get_mut(slot_start) {
+        *slot = NonMaxUsize::new(m.start());
+    }
+    if let Some(slot) = slots.get_mut(slot_end) {
+        *slot = NonMaxUsize::new(m.end());
+    }
+}
diff --git a/regex-automata/src/meta/wrappers.rs b/regex-automata/src/meta/wrappers.rs
new file mode 100644
index 0000000000..8f58363a17
--- /dev/null
+++ b/regex-automata/src/meta/wrappers.rs
@@ -0,0 +1,1316 @@
+/*!
+This module contains a boat load of wrappers around each of our internal regex
+engines. They encapsulate a few things:
+
+1. The wrappers manage the conditional existence of the regex engine. Namely,
+the PikeVM is the only required regex engine. The rest are optional. These
+wrappers present a uniform API regardless of which engines are available. And
+availability might be determined by compile time features or by dynamic
+configuration via `meta::Config`. Encapsulating the conditional compilation
+features is in particular a huge simplification for the higher level code that
+composes these engines.
+2. The wrappers manage construction of each engine, including skipping it if
+the engine is unavailable or configured to not be used.
+3. The wrappers manage whether an engine *can* be used for a particular
+search configuration. For example, `BoundedBacktracker::get` only returns a
+backtracking engine when the haystack is bigger than the maximum supported
+length. The wrappers also sometimes take a position on when an engine *ought*
+to be used, but only in cases where the logic is extremely local to the engine
+itself. Otherwise, things like "choose between the backtracker and the one-pass
+DFA" are managed by the higher level meta strategy code.
+
+There are also corresponding wrappers for the various `Cache` types for each
+regex engine that needs them. If an engine is unavailable or not used, then a
+cache for it will *not* actually be allocated.
+*/
+
+use alloc::vec::Vec;
+
+use crate::{
+    meta::{
+        error::{BuildError, RetryError, RetryFailError},
+        regex::RegexInfo,
+    },
+    nfa::thompson::{pikevm, NFA},
+    util::{prefilter::Prefilter, primitives::NonMaxUsize},
+    HalfMatch, Input, Match, MatchKind, PatternID, PatternSet,
+};
+
+#[cfg(feature = "dfa-build")]
+use crate::dfa;
+#[cfg(feature = "dfa-onepass")]
+use crate::dfa::onepass;
+#[cfg(feature = "hybrid")]
+use crate::hybrid;
+#[cfg(feature = "nfa-backtrack")]
+use crate::nfa::thompson::backtrack;
+
+#[derive(Debug)]
+pub(crate) struct PikeVM(PikeVMEngine);
+
+impl PikeVM {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+    ) -> Result<PikeVM, BuildError> {
+        PikeVMEngine::new(info, pre, nfa).map(PikeVM)
+    }
+
+    pub(crate) fn create_cache(&self) -> PikeVMCache {
+        PikeVMCache::new(self)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(&self) -> &PikeVMEngine {
+        &self.0
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct PikeVMEngine(pikevm::PikeVM);
+
+impl PikeVMEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+    ) -> Result<PikeVMEngine, BuildError> {
+        let pikevm_config = pikevm::Config::new()
+            .match_kind(info.config().get_match_kind())
+            .prefilter(pre);
+        let engine = pikevm::Builder::new()
+            .configure(pikevm_config)
+            .build_from_nfa(nfa.clone())
+            .map_err(BuildError::nfa)?;
+        debug!("PikeVM built");
+        Ok(PikeVMEngine(engine))
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn search_slots(
+        &self,
+        cache: &mut PikeVMCache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        self.0.search_slots(cache.0.as_mut().unwrap(), input, slots)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn which_overlapping_matches(
+        &self,
+        cache: &mut PikeVMCache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        self.0.which_overlapping_matches(
+            cache.0.as_mut().unwrap(),
+            input,
+            patset,
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct PikeVMCache(Option<pikevm::Cache>);
+
+impl PikeVMCache {
+    pub(crate) fn none() -> PikeVMCache {
+        PikeVMCache(None)
+    }
+
+    pub(crate) fn new(builder: &PikeVM) -> PikeVMCache {
+        PikeVMCache(Some(builder.get().0.create_cache()))
+    }
+
+    pub(crate) fn reset(&mut self, builder: &PikeVM) {
+        self.0.as_mut().unwrap().reset(&builder.get().0);
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.0.as_ref().map_or(0, |c| c.memory_usage())
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct BoundedBacktracker(Option<BoundedBacktrackerEngine>);
+
+impl BoundedBacktracker {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+    ) -> Result<BoundedBacktracker, BuildError> {
+        BoundedBacktrackerEngine::new(info, pre, nfa).map(BoundedBacktracker)
+    }
+
+    pub(crate) fn create_cache(&self) -> BoundedBacktrackerCache {
+        BoundedBacktrackerCache::new(self)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(
+        &self,
+        input: &Input<'_>,
+    ) -> Option<&BoundedBacktrackerEngine> {
+        let engine = self.0.as_ref()?;
+        // It is difficult to make the backtracker give up early if it is
+        // guaranteed to eventually wind up in a match state. This is because
+        // of the greedy nature of a backtracker: it just blindly mushes
+        // forward. Every other regex engine is able to give up more quickly,
+        // so even if the backtracker might be able to zip through faster than
+        // (say) the PikeVM, we prefer the theoretical benefit that some other
+        // engine might be able to scan much less of the haystack than the
+        // backtracker.
+        //
+        // Now, if the haystack is really short already, then we allow the
+        // backtracker to run. (This hasn't been litigated quantitatively with
+        // benchmarks. Just a hunch.)
+        if input.get_earliest() && input.haystack().len() > 128 {
+            return None;
+        }
+        // If the backtracker is just going to return an error because the
+        // haystack is too long, then obviously do not use it.
+        if input.get_span().len() > engine.max_haystack_len() {
+            return None;
+        }
+        Some(engine)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct BoundedBacktrackerEngine(
+    #[cfg(feature = "nfa-backtrack")] backtrack::BoundedBacktracker,
+    #[cfg(not(feature = "nfa-backtrack"))] (),
+);
+
+impl BoundedBacktrackerEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+    ) -> Result<Option<BoundedBacktrackerEngine>, BuildError> {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            if !info.config().get_backtrack()
+                || info.config().get_match_kind() != MatchKind::LeftmostFirst
+            {
+                return Ok(None);
+            }
+            let backtrack_config = backtrack::Config::new().prefilter(pre);
+            let engine = backtrack::Builder::new()
+                .configure(backtrack_config)
+                .build_from_nfa(nfa.clone())
+                .map_err(BuildError::nfa)?;
+            debug!("BoundedBacktracker built");
+            Ok(Some(BoundedBacktrackerEngine(engine)))
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            Ok(None)
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn search_slots(
+        &self,
+        cache: &mut BoundedBacktrackerCache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            // OK because we only permit access to this engine when we know
+            // the haystack is short enough for the backtracker to run without
+            // reporting an error.
+            self.0
+                .try_search_slots(cache.0.as_mut().unwrap(), input, slots)
+                .unwrap()
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn max_haystack_len(&self) -> usize {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            self.0.max_haystack_len()
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct BoundedBacktrackerCache(
+    #[cfg(feature = "nfa-backtrack")] Option<backtrack::Cache>,
+    #[cfg(not(feature = "nfa-backtrack"))] (),
+);
+
+impl BoundedBacktrackerCache {
+    pub(crate) fn none() -> BoundedBacktrackerCache {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            BoundedBacktrackerCache(None)
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            BoundedBacktrackerCache(())
+        }
+    }
+
+    pub(crate) fn new(
+        builder: &BoundedBacktracker,
+    ) -> BoundedBacktrackerCache {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            BoundedBacktrackerCache(
+                builder.0.as_ref().map(|e| e.0.create_cache()),
+            )
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            BoundedBacktrackerCache(())
+        }
+    }
+
+    pub(crate) fn reset(&mut self, builder: &BoundedBacktracker) {
+        #[cfg(feature = "nfa-backtrack")]
+        if let Some(ref e) = builder.0 {
+            self.0.as_mut().unwrap().reset(&e.0);
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "nfa-backtrack")]
+        {
+            self.0.as_ref().map_or(0, |c| c.memory_usage())
+        }
+        #[cfg(not(feature = "nfa-backtrack"))]
+        {
+            0
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct OnePass(Option<OnePassEngine>);
+
+impl OnePass {
+    pub(crate) fn new(info: &RegexInfo, nfa: &NFA) -> OnePass {
+        OnePass(OnePassEngine::new(info, nfa))
+    }
+
+    pub(crate) fn create_cache(&self) -> OnePassCache {
+        OnePassCache::new(self)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(&self, input: &Input<'_>) -> Option<&OnePassEngine> {
+        let engine = self.0.as_ref()?;
+        if !input.get_anchored().is_anchored()
+            && !engine.get_nfa().is_always_start_anchored()
+        {
+            return None;
+        }
+        Some(engine)
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.0.as_ref().map_or(0, |e| e.memory_usage())
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct OnePassEngine(
+    #[cfg(feature = "dfa-onepass")] onepass::DFA,
+    #[cfg(not(feature = "dfa-onepass"))] (),
+);
+
+impl OnePassEngine {
+    pub(crate) fn new(info: &RegexInfo, nfa: &NFA) -> Option<OnePassEngine> {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            if !info.config().get_onepass() {
+                return None;
+            }
+            // In order to even attempt building a one-pass DFA, we require
+            // that we either have at least one explicit capturing group or
+            // there's a Unicode word boundary somewhere. If we don't have
+            // either of these things, then the lazy DFA will almost certainly
+            // be useable and be much faster. The only case where it might
+            // not is if the lazy DFA isn't utilizing its cache effectively,
+            // but in those cases, the underlying regex is almost certainly
+            // not one-pass or is too big to fit within the current one-pass
+            // implementation limits.
+            if info.props_union().explicit_captures_len() == 0
+                && !info.props_union().look_set().contains_word_unicode()
+            {
+                debug!("not building OnePass because it isn't worth it");
+                return None;
+            }
+            let onepass_config = onepass::Config::new()
+                .match_kind(info.config().get_match_kind())
+                // Like for the lazy DFA, we unconditionally enable this
+                // because it doesn't cost much and makes the API more
+                // flexible.
+                .starts_for_each_pattern(true)
+                .byte_classes(info.config().get_byte_classes())
+                .size_limit(info.config().get_onepass_size_limit());
+            let result = onepass::Builder::new()
+                .configure(onepass_config)
+                .build_from_nfa(nfa.clone());
+            let engine = match result {
+                Ok(engine) => engine,
+                Err(_err) => {
+                    debug!("OnePass failed to build: {}", _err);
+                    return None;
+                }
+            };
+            debug!("OnePass built, {} bytes", engine.memory_usage());
+            Some(OnePassEngine(engine))
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            None
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn search_slots(
+        &self,
+        cache: &mut OnePassCache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            // OK because we only permit getting a OnePassEngine when we know
+            // the search is anchored and thus an error cannot occur.
+            self.0
+                .try_search_slots(cache.0.as_mut().unwrap(), input, slots)
+                .unwrap()
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            self.0.memory_usage()
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn get_nfa(&self) -> &NFA {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            self.0.get_nfa()
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct OnePassCache(
+    #[cfg(feature = "dfa-onepass")] Option<onepass::Cache>,
+    #[cfg(not(feature = "dfa-onepass"))] (),
+);
+
+impl OnePassCache {
+    pub(crate) fn none() -> OnePassCache {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            OnePassCache(None)
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            OnePassCache(())
+        }
+    }
+
+    pub(crate) fn new(builder: &OnePass) -> OnePassCache {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            OnePassCache(builder.0.as_ref().map(|e| e.0.create_cache()))
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            OnePassCache(())
+        }
+    }
+
+    pub(crate) fn reset(&mut self, builder: &OnePass) {
+        #[cfg(feature = "dfa-onepass")]
+        if let Some(ref e) = builder.0 {
+            self.0.as_mut().unwrap().reset(&e.0);
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "dfa-onepass")]
+        {
+            self.0.as_ref().map_or(0, |c| c.memory_usage())
+        }
+        #[cfg(not(feature = "dfa-onepass"))]
+        {
+            0
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Hybrid(Option<HybridEngine>);
+
+impl Hybrid {
+    pub(crate) fn none() -> Hybrid {
+        Hybrid(None)
+    }
+
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+        nfarev: &NFA,
+    ) -> Hybrid {
+        Hybrid(HybridEngine::new(info, pre, nfa, nfarev))
+    }
+
+    pub(crate) fn create_cache(&self) -> HybridCache {
+        HybridCache::new(self)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(&self, _input: &Input<'_>) -> Option<&HybridEngine> {
+        let engine = self.0.as_ref()?;
+        Some(engine)
+    }
+
+    pub(crate) fn is_some(&self) -> bool {
+        self.0.is_some()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct HybridEngine(
+    #[cfg(feature = "hybrid")] hybrid::regex::Regex,
+    #[cfg(not(feature = "hybrid"))] (),
+);
+
+impl HybridEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+        nfarev: &NFA,
+    ) -> Option<HybridEngine> {
+        #[cfg(feature = "hybrid")]
+        {
+            if !info.config().get_hybrid() {
+                return None;
+            }
+            let dfa_config = hybrid::dfa::Config::new()
+                .match_kind(info.config().get_match_kind())
+                .prefilter(pre.clone())
+                // Enabling this is necessary for ensuring we can service any
+                // kind of 'Input' search without error. For the lazy DFA,
+                // this is not particularly costly, since the start states are
+                // generated lazily.
+                .starts_for_each_pattern(true)
+                .byte_classes(info.config().get_byte_classes())
+                .unicode_word_boundary(true)
+                .specialize_start_states(pre.is_some())
+                .cache_capacity(info.config().get_hybrid_cache_capacity())
+                // This makes it possible for building a lazy DFA to
+                // fail even though the NFA has already been built. Namely,
+                // if the cache capacity is too small to fit some minimum
+                // number of states (which is small, like 4 or 5), then the
+                // DFA will refuse to build.
+                //
+                // We shouldn't enable this to make building always work, since
+                // this could cause the allocation of a cache bigger than the
+                // provided capacity amount.
+                //
+                // This is effectively the only reason why building a lazy DFA
+                // could fail. If it does, then we simply suppress the error
+                // and return None.
+                .skip_cache_capacity_check(false)
+                // This and enabling heuristic Unicode word boundary support
+                // above make it so the lazy DFA can quit at match time.
+                .minimum_cache_clear_count(Some(3))
+                .minimum_bytes_per_state(Some(10));
+            let result = hybrid::dfa::Builder::new()
+                .configure(dfa_config.clone())
+                .build_from_nfa(nfa.clone());
+            let fwd = match result {
+                Ok(fwd) => fwd,
+                Err(_err) => {
+                    debug!("forward lazy DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            let result = hybrid::dfa::Builder::new()
+                .configure(
+                    dfa_config
+                        .clone()
+                        .match_kind(MatchKind::All)
+                        .prefilter(None)
+                        .specialize_start_states(false),
+                )
+                .build_from_nfa(nfarev.clone());
+            let rev = match result {
+                Ok(rev) => rev,
+                Err(_err) => {
+                    debug!("reverse lazy DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            let engine =
+                hybrid::regex::Builder::new().build_from_dfas(fwd, rev);
+            debug!("lazy DFA built");
+            Some(HybridEngine(engine))
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            None
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+    ) -> Result<Option<Match>, RetryFailError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let cache = cache.0.as_mut().unwrap();
+            self.0.try_search(cache, input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_fwd(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let fwd = self.0.forward();
+            let mut fwdcache = cache.0.as_mut().unwrap().as_parts_mut().0;
+            fwd.try_search_fwd(&mut fwdcache, input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_fwd_stopat(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+    ) -> Result<Result<HalfMatch, usize>, RetryFailError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let dfa = self.0.forward();
+            let mut cache = cache.0.as_mut().unwrap().as_parts_mut().0;
+            crate::meta::stopat::hybrid_try_search_half_fwd(
+                dfa, &mut cache, input,
+            )
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let rev = self.0.reverse();
+            let mut revcache = cache.0.as_mut().unwrap().as_parts_mut().1;
+            rev.try_search_rev(&mut revcache, input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev_limited(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let dfa = self.0.reverse();
+            let mut cache = cache.0.as_mut().unwrap().as_parts_mut().1;
+            crate::meta::limited::hybrid_try_search_half_rev(
+                dfa, &mut cache, input, min_start,
+            )
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[inline]
+    pub(crate) fn try_which_overlapping_matches(
+        &self,
+        cache: &mut HybridCache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) -> Result<(), RetryFailError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let fwd = self.0.forward();
+            let mut fwdcache = cache.0.as_mut().unwrap().as_parts_mut().0;
+            fwd.try_which_overlapping_matches(&mut fwdcache, input, patset)
+                .map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct HybridCache(
+    #[cfg(feature = "hybrid")] Option<hybrid::regex::Cache>,
+    #[cfg(not(feature = "hybrid"))] (),
+);
+
+impl HybridCache {
+    pub(crate) fn none() -> HybridCache {
+        #[cfg(feature = "hybrid")]
+        {
+            HybridCache(None)
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            HybridCache(())
+        }
+    }
+
+    pub(crate) fn new(builder: &Hybrid) -> HybridCache {
+        #[cfg(feature = "hybrid")]
+        {
+            HybridCache(builder.0.as_ref().map(|e| e.0.create_cache()))
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            HybridCache(())
+        }
+    }
+
+    pub(crate) fn reset(&mut self, builder: &Hybrid) {
+        #[cfg(feature = "hybrid")]
+        if let Some(ref e) = builder.0 {
+            self.0.as_mut().unwrap().reset(&e.0);
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "hybrid")]
+        {
+            self.0.as_ref().map_or(0, |c| c.memory_usage())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            0
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct DFA(Option<DFAEngine>);
+
+impl DFA {
+    pub(crate) fn none() -> DFA {
+        DFA(None)
+    }
+
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+        nfarev: &NFA,
+    ) -> DFA {
+        DFA(DFAEngine::new(info, pre, nfa, nfarev))
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(&self, _input: &Input<'_>) -> Option<&DFAEngine> {
+        let engine = self.0.as_ref()?;
+        Some(engine)
+    }
+
+    pub(crate) fn is_some(&self) -> bool {
+        self.0.is_some()
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.0.as_ref().map_or(0, |e| e.memory_usage())
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct DFAEngine(
+    #[cfg(feature = "dfa-build")] dfa::regex::Regex,
+    #[cfg(not(feature = "dfa-build"))] (),
+);
+
+impl DFAEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        pre: Option<Prefilter>,
+        nfa: &NFA,
+        nfarev: &NFA,
+    ) -> Option<DFAEngine> {
+        #[cfg(feature = "dfa-build")]
+        {
+            if !info.config().get_dfa() {
+                return None;
+            }
+            // If our NFA is anything but small, don't even bother with a DFA.
+            if let Some(state_limit) = info.config().get_dfa_state_limit() {
+                if nfa.states().len() > state_limit {
+                    debug!(
+                        "skipping full DFA because NFA has {} states, \
+                         which exceeds the heuristic limit of {}",
+                        nfa.states().len(),
+                        state_limit,
+                    );
+                    return None;
+                }
+            }
+            // We cut the size limit in four because the total heap used by
+            // DFA construction is determinization aux memory and the DFA
+            // itself, and those things are configured independently in the
+            // lower level DFA builder API. And then split that in two because
+            // of forward and reverse DFAs.
+            let size_limit = info.config().get_dfa_size_limit().map(|n| n / 4);
+            let dfa_config = dfa::dense::Config::new()
+                .match_kind(info.config().get_match_kind())
+                .prefilter(pre.clone())
+                // Enabling this is necessary for ensuring we can service any
+                // kind of 'Input' search without error. For the full DFA, this
+                // can be quite costly. But since we have such a small bound
+                // on the size of the DFA, in practice, any multl-regexes are
+                // probably going to blow the limit anyway.
+                .starts_for_each_pattern(true)
+                .byte_classes(info.config().get_byte_classes())
+                .unicode_word_boundary(true)
+                .specialize_start_states(pre.is_some())
+                .determinize_size_limit(size_limit)
+                .dfa_size_limit(size_limit);
+            let result = dfa::dense::Builder::new()
+                .configure(dfa_config.clone())
+                .build_from_nfa(&nfa);
+            let fwd = match result {
+                Ok(fwd) => fwd,
+                Err(_err) => {
+                    debug!("forward full DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            let result = dfa::dense::Builder::new()
+                .configure(
+                    dfa_config
+                        .clone()
+                        // We never need unanchored reverse searches, so
+                        // there's no point in building it into the DFA, which
+                        // WILL take more space. (This isn't done for the lazy
+                        // DFA because the DFA is, well, lazy. It doesn't pay
+                        // the cost for supporting unanchored searches unless
+                        // you actually do an unanchored search, which we
+                        // don't.)
+                        .start_kind(dfa::StartKind::Anchored)
+                        .match_kind(MatchKind::All)
+                        .prefilter(None)
+                        .specialize_start_states(false),
+                )
+                .build_from_nfa(&nfarev);
+            let rev = match result {
+                Ok(rev) => rev,
+                Err(_err) => {
+                    debug!("reverse full DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            let engine = dfa::regex::Builder::new().build_from_dfas(fwd, rev);
+            debug!(
+                "fully compiled forward and reverse DFAs built, {} bytes",
+                engine.forward().memory_usage()
+                    + engine.reverse().memory_usage(),
+            );
+            Some(DFAEngine(engine))
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            None
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<Match>, RetryFailError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            self.0.try_search(input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_fwd(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            use crate::dfa::Automaton;
+            self.0.forward().try_search_fwd(input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_fwd_stopat(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Result<HalfMatch, usize>, RetryFailError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            let dfa = self.0.forward();
+            crate::meta::stopat::dfa_try_search_half_fwd(dfa, input)
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev(
+        &self,
+        input: &Input<'_>,
+    ) -> Result<Option<HalfMatch>, RetryFailError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            use crate::dfa::Automaton;
+            self.0.reverse().try_search_rev(&input).map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev_limited(
+        &self,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            let dfa = self.0.reverse();
+            crate::meta::limited::dfa_try_search_half_rev(
+                dfa, input, min_start,
+            )
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    #[inline]
+    pub(crate) fn try_which_overlapping_matches(
+        &self,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) -> Result<(), RetryFailError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            use crate::dfa::Automaton;
+            self.0
+                .forward()
+                .try_which_overlapping_matches(input, patset)
+                .map_err(|e| e.into())
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "dfa-build")]
+        {
+            self.0.forward().memory_usage() + self.0.reverse().memory_usage()
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ReverseHybrid(Option<ReverseHybridEngine>);
+
+impl ReverseHybrid {
+    pub(crate) fn none() -> ReverseHybrid {
+        ReverseHybrid(None)
+    }
+
+    pub(crate) fn new(info: &RegexInfo, nfarev: &NFA) -> ReverseHybrid {
+        ReverseHybrid(ReverseHybridEngine::new(info, nfarev))
+    }
+
+    pub(crate) fn create_cache(&self) -> ReverseHybridCache {
+        ReverseHybridCache::new(self)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(
+        &self,
+        _input: &Input<'_>,
+    ) -> Option<&ReverseHybridEngine> {
+        let engine = self.0.as_ref()?;
+        Some(engine)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ReverseHybridEngine(
+    #[cfg(feature = "hybrid")] hybrid::dfa::DFA,
+    #[cfg(not(feature = "hybrid"))] (),
+);
+
+impl ReverseHybridEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        nfarev: &NFA,
+    ) -> Option<ReverseHybridEngine> {
+        #[cfg(feature = "hybrid")]
+        {
+            if !info.config().get_hybrid() {
+                return None;
+            }
+            // Since we only use this for reverse searches, we can hard-code
+            // a number of things like match semantics, prefilters, starts
+            // for each pattern and so on.
+            let dfa_config = hybrid::dfa::Config::new()
+                .match_kind(MatchKind::All)
+                .prefilter(None)
+                .starts_for_each_pattern(false)
+                .byte_classes(info.config().get_byte_classes())
+                .unicode_word_boundary(true)
+                .specialize_start_states(false)
+                .cache_capacity(info.config().get_hybrid_cache_capacity())
+                .skip_cache_capacity_check(false)
+                .minimum_cache_clear_count(Some(3))
+                .minimum_bytes_per_state(Some(10));
+            let result = hybrid::dfa::Builder::new()
+                .configure(dfa_config)
+                .build_from_nfa(nfarev.clone());
+            let rev = match result {
+                Ok(rev) => rev,
+                Err(_err) => {
+                    debug!("lazy reverse DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            debug!("lazy reverse DFA built");
+            Some(ReverseHybridEngine(rev))
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            None
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev_limited(
+        &self,
+        cache: &mut ReverseHybridCache,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        #[cfg(feature = "hybrid")]
+        {
+            let dfa = &self.0;
+            let mut cache = cache.0.as_mut().unwrap();
+            crate::meta::limited::hybrid_try_search_half_rev(
+                dfa, &mut cache, input, min_start,
+            )
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct ReverseHybridCache(
+    #[cfg(feature = "hybrid")] Option<hybrid::dfa::Cache>,
+    #[cfg(not(feature = "hybrid"))] (),
+);
+
+impl ReverseHybridCache {
+    pub(crate) fn none() -> ReverseHybridCache {
+        #[cfg(feature = "hybrid")]
+        {
+            ReverseHybridCache(None)
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            ReverseHybridCache(())
+        }
+    }
+
+    pub(crate) fn new(builder: &ReverseHybrid) -> ReverseHybridCache {
+        #[cfg(feature = "hybrid")]
+        {
+            ReverseHybridCache(builder.0.as_ref().map(|e| e.0.create_cache()))
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            ReverseHybridCache(())
+        }
+    }
+
+    pub(crate) fn reset(&mut self, builder: &ReverseHybrid) {
+        #[cfg(feature = "hybrid")]
+        if let Some(ref e) = builder.0 {
+            self.0.as_mut().unwrap().reset(&e.0);
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "hybrid")]
+        {
+            self.0.as_ref().map_or(0, |c| c.memory_usage())
+        }
+        #[cfg(not(feature = "hybrid"))]
+        {
+            0
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ReverseDFA(Option<ReverseDFAEngine>);
+
+impl ReverseDFA {
+    pub(crate) fn none() -> ReverseDFA {
+        ReverseDFA(None)
+    }
+
+    pub(crate) fn new(info: &RegexInfo, nfarev: &NFA) -> ReverseDFA {
+        ReverseDFA(ReverseDFAEngine::new(info, nfarev))
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn get(&self, _input: &Input<'_>) -> Option<&ReverseDFAEngine> {
+        let engine = self.0.as_ref()?;
+        Some(engine)
+    }
+
+    pub(crate) fn is_some(&self) -> bool {
+        self.0.is_some()
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.0.as_ref().map_or(0, |e| e.memory_usage())
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ReverseDFAEngine(
+    #[cfg(feature = "dfa-build")] dfa::dense::DFA<Vec<u32>>,
+    #[cfg(not(feature = "dfa-build"))] (),
+);
+
+impl ReverseDFAEngine {
+    pub(crate) fn new(
+        info: &RegexInfo,
+        nfarev: &NFA,
+    ) -> Option<ReverseDFAEngine> {
+        #[cfg(feature = "dfa-build")]
+        {
+            if !info.config().get_dfa() {
+                return None;
+            }
+            // If our NFA is anything but small, don't even bother with a DFA.
+            if let Some(state_limit) = info.config().get_dfa_state_limit() {
+                if nfarev.states().len() > state_limit {
+                    debug!(
+                        "skipping full reverse DFA because NFA has {} states, \
+                         which exceeds the heuristic limit of {}",
+                        nfarev.states().len(),
+                        state_limit,
+					);
+                    return None;
+                }
+            }
+            // We cut the size limit in two because the total heap used by DFA
+            // construction is determinization aux memory and the DFA itself,
+            // and those things are configured independently in the lower level
+            // DFA builder API.
+            let size_limit = info.config().get_dfa_size_limit().map(|n| n / 2);
+            // Since we only use this for reverse searches, we can hard-code
+            // a number of things like match semantics, prefilters, starts
+            // for each pattern and so on. We also disable acceleration since
+            // it's incompatible with limited searches (which is the only
+            // operation we support for this kind of engine at the moment).
+            let dfa_config = dfa::dense::Config::new()
+                .match_kind(MatchKind::All)
+                .prefilter(None)
+                .accelerate(false)
+                .start_kind(dfa::StartKind::Anchored)
+                .starts_for_each_pattern(false)
+                .byte_classes(info.config().get_byte_classes())
+                .unicode_word_boundary(true)
+                .specialize_start_states(false)
+                .determinize_size_limit(size_limit)
+                .dfa_size_limit(size_limit);
+            let result = dfa::dense::Builder::new()
+                .configure(dfa_config)
+                .build_from_nfa(&nfarev);
+            let rev = match result {
+                Ok(rev) => rev,
+                Err(_err) => {
+                    debug!("full reverse DFA failed to build: {}", _err);
+                    return None;
+                }
+            };
+            debug!(
+                "fully compiled reverse DFA built, {} bytes",
+                rev.memory_usage()
+            );
+            Some(ReverseDFAEngine(rev))
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            None
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn try_search_half_rev_limited(
+        &self,
+        input: &Input<'_>,
+        min_start: usize,
+    ) -> Result<Option<HalfMatch>, RetryError> {
+        #[cfg(feature = "dfa-build")]
+        {
+            let dfa = &self.0;
+            crate::meta::limited::dfa_try_search_half_rev(
+                dfa, input, min_start,
+            )
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        #[cfg(feature = "dfa-build")]
+        {
+            self.0.memory_usage()
+        }
+        #[cfg(not(feature = "dfa-build"))]
+        {
+            // Impossible to reach because this engine is never constructed
+            // if the requisite features aren't enabled.
+            unreachable!()
+        }
+    }
+}
diff --git a/regex-automata/src/nfa/mod.rs b/regex-automata/src/nfa/mod.rs
new file mode 100644
index 0000000000..0c36f598af
--- /dev/null
+++ b/regex-automata/src/nfa/mod.rs
@@ -0,0 +1,55 @@
+/*!
+Provides non-deterministic finite automata (NFA) and regex engines that use
+them.
+
+While NFAs and DFAs (deterministic finite automata) have equivalent *theoretical*
+power, their usage in practice tends to result in different engineering trade
+offs. While this isn't meant to be a comprehensive treatment of the topic, here
+are a few key trade offs that are, at minimum, true for this crate:
+
+* NFAs tend to be represented sparsely where as DFAs are represented densely.
+Sparse representations use less memory, but are slower to traverse. Conversely,
+dense representations use more memory, but are faster to traverse. (Sometimes
+these lines are blurred. For example, an `NFA` might choose to represent a
+particular state in a dense fashion, and a DFA can be built using a sparse
+representation via [`sparse::DFA`](crate::dfa::sparse::DFA).
+* NFAs have espilon transitions and DFAs don't. In practice, this means that
+handling a single byte in a haystack with an NFA at search time may require
+visiting multiple NFA states. In a DFA, each byte only requires visiting
+a single state. Stated differently, NFAs require a variable number of CPU
+instructions to process one byte in a haystack where as a DFA uses a constant
+number of CPU instructions to process one byte.
+* NFAs are generally easier to amend with secondary storage. For example, the
+[`thompson::pikevm::PikeVM`] uses an NFA to match, but also uses additional
+memory beyond the model of a finite state machine to track offsets for matching
+capturing groups. Conversely, the most a DFA can do is report the offset (and
+pattern ID) at which a match occurred. This is generally why we also compile
+DFAs in reverse, so that we can run them after finding the end of a match to
+also find the start of a match.
+* NFAs take worst case linear time to build, but DFAs take worst case
+exponential time to build. The [hybrid NFA/DFA](crate::hybrid) mitigates this
+challenge for DFAs in many practical cases.
+
+There are likely other differences, but the bottom line is that NFAs tend to be
+more memory efficient and give easier opportunities for increasing expressive
+power, where as DFAs are faster to search with.
+
+# Why only a Thompson NFA?
+
+Currently, the only kind of NFA we support in this crate is a [Thompson
+NFA](https://en.wikipedia.org/wiki/Thompson%27s_construction). This refers
+to a specific construction algorithm that takes the syntax of a regex
+pattern and converts it to an NFA. Specifically, it makes gratuitous use of
+epsilon transitions in order to keep its structure simple. In exchange, its
+construction time is linear in the size of the regex. A Thompson NFA also makes
+the guarantee that given any state and a character in a haystack, there is at
+most one transition defined for it. (Although there may be many epsilon
+transitions.)
+
+It possible that other types of NFAs will be added in the future, such as a
+[Glushkov NFA](https://en.wikipedia.org/wiki/Glushkov%27s_construction_algorithm).
+But currently, this crate only provides a Thompson NFA.
+*/
+
+#[cfg(feature = "nfa-thompson")]
+pub mod thompson;
diff --git a/regex-automata/src/nfa/thompson/backtrack.rs b/regex-automata/src/nfa/thompson/backtrack.rs
new file mode 100644
index 0000000000..4358652b89
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/backtrack.rs
@@ -0,0 +1,1904 @@
+/*!
+An NFA backed bounded backtracker for executing regex searches with capturing
+groups.
+
+This module provides a [`BoundedBacktracker`] that works by simulating an NFA
+using the classical backtracking algorithm with a twist: it avoids redoing
+work that it has done before and thereby avoids worst case exponential time.
+In exchange, it can only be used on "short" haystacks. Its advantage is that
+is can be faster than the [`PikeVM`](thompson::pikevm::PikeVM) in many cases
+because it does less book-keeping.
+*/
+
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    nfa::thompson::{self, BuildError, State, NFA},
+    util::{
+        captures::Captures,
+        empty, iter,
+        prefilter::Prefilter,
+        primitives::{NonMaxUsize, PatternID, SmallIndex, StateID},
+        search::{Anchored, Input, Match, MatchError, Span},
+    },
+};
+
+/// Returns the minimum visited capacity for the given haystack.
+///
+/// This function can be used as the argument to [`Config::visited_capacity`]
+/// in order to guarantee that a backtracking search for the given `input`
+/// won't return an error when using a [`BoundedBacktracker`] built from the
+/// given `NFA`.
+///
+/// This routine exists primarily as a way to test that the bounded backtracker
+/// works correctly when its capacity is set to the smallest possible amount.
+/// Still, it may be useful in cases where you know you want to use the bounded
+/// backtracker for a specific input, and just need to know what visited
+/// capacity to provide to make it work.
+///
+/// Be warned that this number could be quite large as it is multiplicative in
+/// the size the given NFA and haystack.
+pub fn min_visited_capacity(nfa: &NFA, input: &Input<'_>) -> usize {
+    div_ceil(nfa.states().len() * (input.get_span().len() + 1), 8)
+}
+
+/// The configuration used for building a bounded backtracker.
+///
+/// A bounded backtracker configuration is a simple data object that is
+/// typically used with [`Builder::configure`].
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    pre: Option<Option<Prefilter>>,
+    visited_capacity: Option<usize>,
+}
+
+impl Config {
+    /// Return a new default regex configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Set a prefilter to be used whenever a start state is entered.
+    ///
+    /// A [`Prefilter`] in this context is meant to accelerate searches by
+    /// looking for literal prefixes that every match for the corresponding
+    /// pattern (or patterns) must start with. Once a prefilter produces a
+    /// match, the underlying search routine continues on to try and confirm
+    /// the match.
+    ///
+    /// Be warned that setting a prefilter does not guarantee that the search
+    /// will be faster. While it's usually a good bet, if the prefilter
+    /// produces a lot of false positive candidates (i.e., positions matched
+    /// by the prefilter but not by the regex), then the overall result can
+    /// be slower than if you had just executed the regex engine without any
+    /// prefilters.
+    ///
+    /// By default no prefilter is set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     util::prefilter::Prefilter,
+    ///     Input, Match, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "bar"]);
+    /// let re = BoundedBacktracker::builder()
+    ///     .configure(BoundedBacktracker::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(
+    ///     Some(Match::must(0, 5..11)),
+    ///     re.try_find(&mut cache, input)?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Be warned though that an incorrect prefilter can lead to incorrect
+    /// results!
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "car"]);
+    /// let re = BoundedBacktracker::builder()
+    ///     .configure(BoundedBacktracker::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// // No match reported even though there clearly is one!
+    /// assert_eq!(None, re.try_find(&mut cache, input)?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn prefilter(mut self, pre: Option<Prefilter>) -> Config {
+        self.pre = Some(pre);
+        self
+    }
+
+    /// Set the visited capacity used to bound backtracking.
+    ///
+    /// The visited capacity represents the amount of heap memory (in bytes) to
+    /// allocate toward tracking which parts of the backtracking search have
+    /// been done before. The heap memory needed for any particular search is
+    /// proportional to `haystack.len() * nfa.states().len()`, which an be
+    /// quite large. Therefore, the bounded backtracker is typically only able
+    /// to run on shorter haystacks.
+    ///
+    /// For a given regex, increasing the visited capacity means that the
+    /// maximum haystack length that can be searched is increased. The
+    /// [`BoundedBacktracker::max_haystack_len`] method returns that maximum.
+    ///
+    /// The default capacity is a reasonable but empirically chosen size.
+    ///
+    /// # Example
+    ///
+    /// As with other regex engines, Unicode is what tends to make the bounded
+    /// backtracker less useful by making the maximum haystack length quite
+    /// small. If necessary, increasing the visited capacity using this routine
+    /// will increase the maximum haystack length at the cost of using more
+    /// memory.
+    ///
+    /// Note though that the specific maximum values here are not an API
+    /// guarantee. The default visited capacity is subject to change and not
+    /// covered by semver.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// // Unicode inflates the size of the underlying NFA quite a bit, and
+    /// // thus means that the backtracker can only handle smaller haystacks,
+    /// // assuming that the visited capacity remains unchanged.
+    /// let re = BoundedBacktracker::new(r"\w+")?;
+    /// assert!(re.max_haystack_len() <= 7_000);
+    /// // But we can increase the visited capacity to handle bigger haystacks!
+    /// let re = BoundedBacktracker::builder()
+    ///     .configure(BoundedBacktracker::config().visited_capacity(1<<20))
+    ///     .build(r"\w+")?;
+    /// assert!(re.max_haystack_len() >= 25_000);
+    /// assert!(re.max_haystack_len() <= 28_000);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn visited_capacity(mut self, capacity: usize) -> Config {
+        self.visited_capacity = Some(capacity);
+        self
+    }
+
+    /// Returns the prefilter set in this configuration, if one at all.
+    pub fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref().unwrap_or(&None).as_ref()
+    }
+
+    /// Returns the configured visited capacity.
+    ///
+    /// Note that the actual capacity used may be slightly bigger than the
+    /// configured capacity.
+    pub fn get_visited_capacity(&self) -> usize {
+        const DEFAULT: usize = 256 * (1 << 10); // 256 KB
+        self.visited_capacity.unwrap_or(DEFAULT)
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            pre: o.pre.or_else(|| self.pre.clone()),
+            visited_capacity: o.visited_capacity.or(self.visited_capacity),
+        }
+    }
+}
+
+/// A builder for a bounded backtracker.
+///
+/// This builder permits configuring options for the syntax of a pattern, the
+/// NFA construction and the `BoundedBacktracker` construction. This builder
+/// is different from a general purpose regex builder in that it permits fine
+/// grain configuration of the construction process. The trade off for this is
+/// complexity, and the possibility of setting a configuration that might not
+/// make sense. For example, there are two different UTF-8 modes:
+///
+/// * [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) controls
+/// whether the pattern itself can contain sub-expressions that match invalid
+/// UTF-8.
+/// * [`thompson::Config::utf8`] controls how the regex iterators themselves
+/// advance the starting position of the next search when a match with zero
+/// length is found.
+///
+/// Generally speaking, callers will want to either enable all of these or
+/// disable all of these.
+///
+/// # Example
+///
+/// This example shows how to disable UTF-8 mode in the syntax and the regex
+/// itself. This is generally what you want for matching on arbitrary bytes.
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::{self, backtrack::BoundedBacktracker},
+///     util::syntax,
+///     Match,
+/// };
+///
+/// let re = BoundedBacktracker::builder()
+///     .syntax(syntax::Config::new().utf8(false))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .build(r"foo(?-u:[^b])ar.*")?;
+/// let mut cache = re.create_cache();
+///
+/// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+/// let expected = Some(Ok(Match::must(0, 1..9)));
+/// let got = re.try_find_iter(&mut cache, haystack).next();
+/// assert_eq!(expected, got);
+/// // Notice that `(?-u:[^b])` matches invalid UTF-8,
+/// // but the subsequent `.*` does not! Disabling UTF-8
+/// // on the syntax permits this.
+/// //
+/// // N.B. This example does not show the impact of
+/// // disabling UTF-8 mode on a BoundedBacktracker Config, since that
+/// // only impacts regexes that can produce matches of
+/// // length 0.
+/// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap()?.range()]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    #[cfg(feature = "syntax")]
+    thompson: thompson::Compiler,
+}
+
+impl Builder {
+    /// Create a new BoundedBacktracker builder with its default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            #[cfg(feature = "syntax")]
+            thompson: thompson::Compiler::new(),
+        }
+    }
+
+    /// Build a `BoundedBacktracker` from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(
+        &self,
+        pattern: &str,
+    ) -> Result<BoundedBacktracker, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a `BoundedBacktracker` from the given patterns.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<BoundedBacktracker, BuildError> {
+        let nfa = self.thompson.build_many(patterns)?;
+        self.build_from_nfa(nfa)
+    }
+
+    /// Build a `BoundedBacktracker` directly from its NFA.
+    ///
+    /// Note that when using this method, any configuration that applies to the
+    /// construction of the NFA itself will of course be ignored, since the NFA
+    /// given here is already built.
+    pub fn build_from_nfa(
+        &self,
+        nfa: NFA,
+    ) -> Result<BoundedBacktracker, BuildError> {
+        // If the NFA has no captures, then the backtracker doesn't work since
+        // it relies on them in order to report match locations. However, in
+        // the special case of an NFA with no patterns, it is allowed, since
+        // no matches can ever be produced. And importantly, an NFA with no
+        // patterns has no capturing groups anyway, so this is necessary to
+        // permit the backtracker to work with regexes with zero patterns.
+        if !nfa.has_capture() && nfa.pattern_len() > 0 {
+            return Err(BuildError::missing_captures());
+        }
+        nfa.look_set_any().available().map_err(BuildError::word)?;
+        Ok(BoundedBacktracker { config: self.config.clone(), nfa })
+    }
+
+    /// Apply the given `BoundedBacktracker` configuration options to this
+    /// builder.
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// These settings only apply when constructing a `BoundedBacktracker`
+    /// directly from a pattern.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.thompson.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like if additional time should be spent
+    /// shrinking the size of the NFA.
+    ///
+    /// These settings only apply when constructing a `BoundedBacktracker`
+    /// directly from a pattern.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.thompson.configure(config);
+        self
+    }
+}
+
+/// A backtracking regex engine that bounds its execution to avoid exponential
+/// blow-up.
+///
+/// This regex engine only implements leftmost-first match semantics and
+/// only supports leftmost searches. It effectively does the same thing as a
+/// [`PikeVM`](thompson::pikevm::PikeVM), but typically does it faster because
+/// it doesn't have to worry about copying capturing group spans for most NFA
+/// states. Instead, the backtracker can maintain one set of captures (provided
+/// by the caller) and never needs to copy them. In exchange, the backtracker
+/// bounds itself to ensure it doesn't exhibit worst case exponential time.
+/// This results in the backtracker only being able to handle short haystacks
+/// given reasonable memory usage.
+///
+/// # Searches may return an error!
+///
+/// By design, this backtracking regex engine is bounded. This bound is
+/// implemented by not visiting any combination of NFA state ID and position
+/// in a haystack more than once. Thus, the total memory required to bound
+/// backtracking is proportional to `haystack.len() * nfa.states().len()`.
+/// This can obviously get quite large, since large haystacks aren't terribly
+/// uncommon. To avoid using exorbitant memory, the capacity is bounded by
+/// a fixed limit set via [`Config::visited_capacity`]. Thus, if the total
+/// capacity required for a particular regex and a haystack exceeds this
+/// capacity, then the search routine will return an error.
+///
+/// Unlike other regex engines that may return an error at search time (like
+/// the DFA or the hybrid NFA/DFA), there is no way to guarantee that a bounded
+/// backtracker will work for every haystack. Therefore, this regex engine
+/// _only_ exposes fallible search routines to avoid the footgun of panicking
+/// when running a search on a haystack that is too big.
+///
+/// If one wants to use the fallible search APIs without handling the
+/// error, the only way to guarantee an error won't occur from the
+/// haystack length is to ensure the haystack length does not exceed
+/// [`BoundedBacktracker::max_haystack_len`].
+///
+/// # Example: Unicode word boundaries
+///
+/// This example shows that the bounded backtracker implements Unicode word
+/// boundaries correctly by default.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{nfa::thompson::backtrack::BoundedBacktracker, Match};
+///
+/// let re = BoundedBacktracker::new(r"\b\w+\b")?;
+/// let mut cache = re.create_cache();
+///
+/// let mut it = re.try_find_iter(&mut cache, "Шерлок Холмс");
+/// assert_eq!(Some(Ok(Match::must(0, 0..12))), it.next());
+/// assert_eq!(Some(Ok(Match::must(0, 13..23))), it.next());
+/// assert_eq!(None, it.next());
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: multiple regex patterns
+///
+/// The bounded backtracker supports searching for multiple patterns
+/// simultaneously, just like other regex engines. Note though that because it
+/// uses a backtracking strategy, this regex engine is unlikely to scale well
+/// as more patterns are added. But then again, as more patterns are added, the
+/// maximum haystack length allowed will also shorten (assuming the visited
+/// capacity remains invariant).
+///
+/// ```
+/// use regex_automata::{nfa::thompson::backtrack::BoundedBacktracker, Match};
+///
+/// let re = BoundedBacktracker::new_many(&["[a-z]+", "[0-9]+"])?;
+/// let mut cache = re.create_cache();
+///
+/// let mut it = re.try_find_iter(&mut cache, "abc 1 foo 4567 0 quux");
+/// assert_eq!(Some(Ok(Match::must(0, 0..3))), it.next());
+/// assert_eq!(Some(Ok(Match::must(1, 4..5))), it.next());
+/// assert_eq!(Some(Ok(Match::must(0, 6..9))), it.next());
+/// assert_eq!(Some(Ok(Match::must(1, 10..14))), it.next());
+/// assert_eq!(Some(Ok(Match::must(1, 15..16))), it.next());
+/// assert_eq!(Some(Ok(Match::must(0, 17..21))), it.next());
+/// assert_eq!(None, it.next());
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct BoundedBacktracker {
+    config: Config,
+    nfa: NFA,
+}
+
+impl BoundedBacktracker {
+    /// Parse the given regular expression using the default configuration and
+    /// return the corresponding `BoundedBacktracker`.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(
+    ///     Some(Ok(Match::must(0, 3..14))),
+    ///     re.try_find_iter(&mut cache, "zzzfoo12345barzzz").next(),
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<BoundedBacktracker, BuildError> {
+        BoundedBacktracker::builder().build(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "multi regex."
+    /// This similarly uses the default regex configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new_many(&["[a-z]+", "[0-9]+"])?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let mut it = re.try_find_iter(&mut cache, "abc 1 foo 4567 0 quux");
+    /// assert_eq!(Some(Ok(Match::must(0, 0..3))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(1, 4..5))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 6..9))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(1, 10..14))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(1, 15..16))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 17..21))), it.next());
+    /// assert_eq!(None, it.next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<BoundedBacktracker, BuildError> {
+        BoundedBacktracker::builder().build_many(patterns)
+    }
+
+    /// # Example
+    ///
+    /// This shows how to hand assemble a regular expression via its HIR,
+    /// compile an NFA from it and build a BoundedBacktracker from the NFA.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{NFA, backtrack::BoundedBacktracker},
+    ///     Match,
+    /// };
+    /// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+    ///
+    /// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///     ClassBytesRange::new(b'0', b'9'),
+    ///     ClassBytesRange::new(b'A', b'Z'),
+    ///     ClassBytesRange::new(b'_', b'_'),
+    ///     ClassBytesRange::new(b'a', b'z'),
+    /// ])));
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;
+    ///
+    /// let re = BoundedBacktracker::new_from_nfa(nfa)?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let expected = Some(Match::must(0, 3..4));
+    /// re.try_captures(&mut cache, "!@#A#@!", &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_from_nfa(nfa: NFA) -> Result<BoundedBacktracker, BuildError> {
+        BoundedBacktracker::builder().build_from_nfa(nfa)
+    }
+
+    /// Create a new `BoundedBacktracker` that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::always_match()?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let expected = Some(Ok(Match::must(0, 0..0)));
+    /// assert_eq!(expected, re.try_find_iter(&mut cache, "").next());
+    /// assert_eq!(expected, re.try_find_iter(&mut cache, "foo").next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<BoundedBacktracker, BuildError> {
+        let nfa = thompson::NFA::always_match();
+        BoundedBacktracker::new_from_nfa(nfa)
+    }
+
+    /// Create a new `BoundedBacktracker` that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// let re = BoundedBacktracker::never_match()?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert_eq!(None, re.try_find_iter(&mut cache, "").next());
+    /// assert_eq!(None, re.try_find_iter(&mut cache, "foo").next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<BoundedBacktracker, BuildError> {
+        let nfa = thompson::NFA::never_match();
+        BoundedBacktracker::new_from_nfa(nfa)
+    }
+
+    /// Return a default configuration for a `BoundedBacktracker`.
+    ///
+    /// This is a convenience routine to avoid needing to import the `Config`
+    /// type when customizing the construction of a `BoundedBacktracker`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to disable UTF-8 mode. When UTF-8 mode is
+    /// disabled, zero-width matches that split a codepoint are allowed.
+    /// Otherwise they are never reported.
+    ///
+    /// In the code below, notice that `""` is permitted to match positions
+    /// that split the encoding of a codepoint.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, backtrack::BoundedBacktracker},
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::builder()
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let haystack = "a☃z";
+    /// let mut it = re.try_find_iter(&mut cache, haystack);
+    /// assert_eq!(Some(Ok(Match::must(0, 0..0))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 1..1))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 2..2))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 3..3))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 4..4))), it.next());
+    /// assert_eq!(Some(Ok(Match::must(0, 5..5))), it.next());
+    /// assert_eq!(None, it.next());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a builder for configuring the construction of a
+    /// `BoundedBacktracker`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode
+    /// everywhere.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, backtrack::BoundedBacktracker},
+    ///     util::syntax,
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+    /// let expected = Some(Match::must(0, 1..9));
+    /// re.try_captures(&mut cache, haystack, &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    /// Create a new cache for this regex.
+    ///
+    /// The cache returned should only be used for searches for this
+    /// regex. If you want to reuse the cache for another regex, then you
+    /// must call [`Cache::reset`] with that regex (or, equivalently,
+    /// [`BoundedBacktracker::reset_cache`]).
+    pub fn create_cache(&self) -> Cache {
+        Cache::new(self)
+    }
+
+    /// Create a new empty set of capturing groups that is guaranteed to be
+    /// valid for the search APIs on this `BoundedBacktracker`.
+    ///
+    /// A `Captures` value created for a specific `BoundedBacktracker` cannot
+    /// be used with any other `BoundedBacktracker`.
+    ///
+    /// This is a convenience function for [`Captures::all`]. See the
+    /// [`Captures`] documentation for an explanation of its alternative
+    /// constructors that permit the `BoundedBacktracker` to do less work
+    /// during a search, and thus might make it faster.
+    pub fn create_captures(&self) -> Captures {
+        Captures::all(self.get_nfa().group_info().clone())
+    }
+
+    /// Reset the given cache such that it can be used for searching with the
+    /// this `BoundedBacktracker` (and only this `BoundedBacktracker`).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `BoundedBacktracker`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different
+    /// `BoundedBacktracker`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re1 = BoundedBacktracker::new(r"\w")?;
+    /// let re2 = BoundedBacktracker::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Ok(Match::must(0, 0..2))),
+    ///     re1.try_find_iter(&mut cache, "Δ").next(),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the BoundedBacktracker we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// cache.reset(&re2);
+    /// assert_eq!(
+    ///     Some(Ok(Match::must(0, 0..3))),
+    ///     re2.try_find_iter(&mut cache, "☃").next(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset_cache(&self, cache: &mut Cache) {
+        cache.reset(self);
+    }
+
+    /// Returns the total number of patterns compiled into this
+    /// `BoundedBacktracker`.
+    ///
+    /// In the case of a `BoundedBacktracker` that contains no patterns, this
+    /// returns `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the pattern length for a `BoundedBacktracker` that
+    /// never matches:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// let re = BoundedBacktracker::never_match()?;
+    /// assert_eq!(re.pattern_len(), 0);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And another example for a `BoundedBacktracker` that matches at every
+    /// position:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// let re = BoundedBacktracker::always_match()?;
+    /// assert_eq!(re.pattern_len(), 1);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And finally, a `BoundedBacktracker` that was constructed from multiple
+    /// patterns:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// let re = BoundedBacktracker::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(re.pattern_len(), 3);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        self.nfa.pattern_len()
+    }
+
+    /// Return the config for this `BoundedBacktracker`.
+    #[inline]
+    pub fn get_config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Returns a reference to the underlying NFA.
+    #[inline]
+    pub fn get_nfa(&self) -> &NFA {
+        &self.nfa
+    }
+
+    /// Returns the maximum haystack length supported by this backtracker.
+    ///
+    /// This routine is a function of both [`Config::visited_capacity`] and the
+    /// internal size of the backtracker's NFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how the maximum haystack length can vary depending
+    /// on the size of the regex itself. Note though that the specific maximum
+    /// values here are not an API guarantee. The default visited capacity is
+    /// subject to change and not covered by semver.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match, MatchError,
+    /// };
+    ///
+    /// // If you're only using ASCII, you get a big budget.
+    /// let re = BoundedBacktracker::new(r"(?-u)\w+")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(re.max_haystack_len(), 299_592);
+    /// // Things work up to the max.
+    /// let mut haystack = "a".repeat(299_592);
+    /// let expected = Some(Ok(Match::must(0, 0..299_592)));
+    /// assert_eq!(expected, re.try_find_iter(&mut cache, &haystack).next());
+    /// // But you'll get an error if you provide a haystack that's too big.
+    /// // Notice that we use the 'try_find_iter' routine instead, which
+    /// // yields Result<Match, MatchError> instead of Match.
+    /// haystack.push('a');
+    /// let expected = Some(Err(MatchError::haystack_too_long(299_593)));
+    /// assert_eq!(expected, re.try_find_iter(&mut cache, &haystack).next());
+    ///
+    /// // Unicode inflates the size of the underlying NFA quite a bit, and
+    /// // thus means that the backtracker can only handle smaller haystacks,
+    /// // assuming that the visited capacity remains unchanged.
+    /// let re = BoundedBacktracker::new(r"\w+")?;
+    /// assert!(re.max_haystack_len() <= 7_000);
+    /// // But we can increase the visited capacity to handle bigger haystacks!
+    /// let re = BoundedBacktracker::builder()
+    ///     .configure(BoundedBacktracker::config().visited_capacity(1<<20))
+    ///     .build(r"\w+")?;
+    /// assert!(re.max_haystack_len() >= 25_000);
+    /// assert!(re.max_haystack_len() <= 28_000);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn max_haystack_len(&self) -> usize {
+        // The capacity given in the config is "bytes of heap memory," but the
+        // capacity we use here is "number of bits." So conver the capacity in
+        // bytes to the capacity in bits.
+        let capacity = 8 * self.get_config().get_visited_capacity();
+        let blocks = div_ceil(capacity, Visited::BLOCK_SIZE);
+        let real_capacity = blocks * Visited::BLOCK_SIZE;
+        (real_capacity / self.nfa.states().len()) - 1
+    }
+}
+
+impl BoundedBacktracker {
+    /// Returns true if and only if this regex matches the given haystack.
+    ///
+    /// In the case of a backtracking regex engine, and unlike most other
+    /// regex engines in this crate, short circuiting isn't practical. However,
+    /// this routine may still be faster because it instructs backtracking to
+    /// not keep track of any capturing groups.
+    ///
+    /// # Errors
+    ///
+    /// This routine only errors if the search could not complete. For this
+    /// backtracking regex engine, this only occurs when the haystack length
+    /// exceeds [`BoundedBacktracker::max_haystack_len`].
+    ///
+    /// When a search cannot complete, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+    ///
+    /// let re = BoundedBacktracker::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.try_is_match(&mut cache, "foo12345bar")?);
+    /// assert!(!re.try_is_match(&mut cache, "foobar")?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: consistency with search APIs
+    ///
+    /// `is_match` is guaranteed to return `true` whenever `find` returns a
+    /// match. This includes searches that are executed entirely within a
+    /// codepoint:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Input,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(!re.try_is_match(&mut cache, Input::new("☃").span(1..2))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Notice that when UTF-8 mode is disabled, then the above reports a
+    /// match because the restriction against zero-width matches that split a
+    /// codepoint has been lifted:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{backtrack::BoundedBacktracker, NFA},
+    ///     Input,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::builder()
+    ///     .thompson(NFA::config().utf8(false))
+    ///     .build("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.try_is_match(&mut cache, Input::new("☃").span(1..2))?);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_is_match<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Result<bool, MatchError> {
+        let input = input.into().earliest(true);
+        self.try_search_slots(cache, &input, &mut []).map(|pid| pid.is_some())
+    }
+
+    /// Executes a leftmost forward search and returns a `Match` if one exists.
+    ///
+    /// This routine only includes the overall match span. To get
+    /// access to the individual spans of each capturing group, use
+    /// [`BoundedBacktracker::try_captures`].
+    ///
+    /// # Errors
+    ///
+    /// This routine only errors if the search could not complete. For this
+    /// backtracking regex engine, this only occurs when the haystack length
+    /// exceeds [`BoundedBacktracker::max_haystack_len`].
+    ///
+    /// When a search cannot complete, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    /// let expected = Match::must(0, 0..8);
+    /// assert_eq!(Some(expected), re.try_find(&mut cache, "foo12345")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_find<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Result<Option<Match>, MatchError> {
+        let input = input.into();
+        if self.get_nfa().pattern_len() == 1 {
+            let mut slots = [None, None];
+            let pid = match self.try_search_slots(cache, &input, &mut slots)? {
+                None => return Ok(None),
+                Some(pid) => pid,
+            };
+            let start = slots[0].unwrap().get();
+            let end = slots[1].unwrap().get();
+            return Ok(Some(Match::new(pid, Span { start, end })));
+        }
+        let ginfo = self.get_nfa().group_info();
+        let slots_len = ginfo.implicit_slot_len();
+        let mut slots = vec![None; slots_len];
+        let pid = match self.try_search_slots(cache, &input, &mut slots)? {
+            None => return Ok(None),
+            Some(pid) => pid,
+        };
+        let start = slots[pid.as_usize() * 2].unwrap().get();
+        let end = slots[pid.as_usize() * 2 + 1].unwrap().get();
+        Ok(Some(Match::new(pid, Span { start, end })))
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// # Errors
+    ///
+    /// This routine only errors if the search could not complete. For this
+    /// backtracking regex engine, this only occurs when the haystack length
+    /// exceeds [`BoundedBacktracker::max_haystack_len`].
+    ///
+    /// When a search cannot complete, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Span,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new(
+    ///     r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$",
+    /// )?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.try_captures(&mut cache, "2010-03-14", &mut caps)?;
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(Span::from(0..4)), caps.get_group(1));
+    /// assert_eq!(Some(Span::from(5..7)), caps.get_group(2));
+    /// assert_eq!(Some(Span::from(8..10)), caps.get_group(3));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_captures<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+        caps: &mut Captures,
+    ) -> Result<(), MatchError> {
+        self.try_search(cache, &input.into(), caps)
+    }
+
+    /// Returns an iterator over all non-overlapping leftmost matches in the
+    /// given bytes. If no match exists, then the iterator yields no elements.
+    ///
+    /// If the regex engine returns an error at any point, then the iterator
+    /// will yield that error.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match, MatchError,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let text = "foo1 foo12 foo123";
+    /// let result: Result<Vec<Match>, MatchError> = re
+    ///     .try_find_iter(&mut cache, text)
+    ///     .collect();
+    /// let matches = result?;
+    /// assert_eq!(matches, vec![
+    ///     Match::must(0, 0..4),
+    ///     Match::must(0, 5..10),
+    ///     Match::must(0, 11..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_find_iter<'r, 'c, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        cache: &'c mut Cache,
+        input: I,
+    ) -> TryFindMatches<'r, 'c, 'h> {
+        let caps = Captures::matches(self.get_nfa().group_info().clone());
+        let it = iter::Searcher::new(input.into());
+        TryFindMatches { re: self, cache, caps, it }
+    }
+
+    /// Returns an iterator over all non-overlapping `Captures` values. If no
+    /// match exists, then the iterator yields no elements.
+    ///
+    /// This yields the same matches as [`BoundedBacktracker::try_find_iter`],
+    /// but it includes the spans of all capturing groups that participate in
+    /// each match.
+    ///
+    /// If the regex engine returns an error at any point, then the iterator
+    /// will yield that error.
+    ///
+    /// **Tip:** See [`util::iter::Searcher`](crate::util::iter::Searcher) for
+    /// how to correctly iterate over all matches in a haystack while avoiding
+    /// the creation of a new `Captures` value for every match. (Which you are
+    /// forced to do with an `Iterator`.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Span,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new("foo(?P<numbers>[0-9]+)")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let text = "foo1 foo12 foo123";
+    /// let mut spans = vec![];
+    /// for result in re.try_captures_iter(&mut cache, text) {
+    ///     let caps = result?;
+    ///     // The unwrap is OK since 'numbers' matches if the pattern matches.
+    ///     spans.push(caps.get_group_by_name("numbers").unwrap());
+    /// }
+    /// assert_eq!(spans, vec![
+    ///     Span::from(3..4),
+    ///     Span::from(8..10),
+    ///     Span::from(14..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_captures_iter<'r, 'c, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        cache: &'c mut Cache,
+        input: I,
+    ) -> TryCapturesMatches<'r, 'c, 'h> {
+        let caps = self.create_captures();
+        let it = iter::Searcher::new(input.into());
+        TryCapturesMatches { re: self, cache, caps, it }
+    }
+}
+
+impl BoundedBacktracker {
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// This is like [`BoundedBacktracker::try_captures`], but it accepts a
+    /// concrete `&Input` instead of an `Into<Input>`.
+    ///
+    /// # Errors
+    ///
+    /// This routine only errors if the search could not complete. For this
+    /// backtracking regex engine, this only occurs when the haystack length
+    /// exceeds [`BoundedBacktracker::max_haystack_len`].
+    ///
+    /// When a search cannot complete, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi bounded backtracker that
+    /// permits searching for specific patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Anchored, Input, Match, PatternID,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new_many(&[
+    ///     "[a-z0-9]{6}",
+    ///     "[a-z][a-z0-9]{5}",
+    /// ])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123";
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(Match::must(0, 0..6));
+    /// re.try_search(&mut cache, &Input::new(haystack), &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let expected = Some(Match::must(1, 0..6));
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// re.try_search(&mut cache, &input, &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new(r"\b[0-9]{3}\b")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about
+    /// // the larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `0..3` instead of
+    /// // `3..6`.
+    /// let expected = Some(Match::must(0, 0..3));
+    /// re.try_search(&mut cache, &Input::new(&haystack[3..6]), &mut caps)?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// re.try_search(
+    ///     &mut cache, &Input::new(haystack).range(3..6), &mut caps,
+    /// )?;
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        caps: &mut Captures,
+    ) -> Result<(), MatchError> {
+        caps.set_pattern(None);
+        let pid = self.try_search_slots(cache, input, caps.slots_mut())?;
+        caps.set_pattern(pid);
+        Ok(())
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided `slots`, and
+    /// returns the matching pattern ID. The contents of the slots for patterns
+    /// other than the matching pattern are unspecified. If no match was found,
+    /// then `None` is returned and the contents of all `slots` is unspecified.
+    ///
+    /// This is like [`BoundedBacktracker::try_search`], but it accepts a raw
+    /// slots slice instead of a `Captures` value. This is useful in contexts
+    /// where you don't want or need to allocate a `Captures`.
+    ///
+    /// It is legal to pass _any_ number of slots to this routine. If the regex
+    /// engine would otherwise write a slot offset that doesn't fit in the
+    /// provided slice, then it is simply skipped. In general though, there are
+    /// usually three slice lengths you might want to use:
+    ///
+    /// * An empty slice, if you only care about which pattern matched.
+    /// * A slice with
+    /// [`pattern_len() * 2`](crate::nfa::thompson::NFA::pattern_len)
+    /// slots, if you only care about the overall match spans for each matching
+    /// pattern.
+    /// * A slice with
+    /// [`slot_len()`](crate::util::captures::GroupInfo::slot_len) slots, which
+    /// permits recording match offsets for every capturing group in every
+    /// pattern.
+    ///
+    /// # Errors
+    ///
+    /// This routine only errors if the search could not complete. For this
+    /// backtracking regex engine, this only occurs when the haystack length
+    /// exceeds [`BoundedBacktracker::max_haystack_len`].
+    ///
+    /// When a search cannot complete, callers cannot know whether a match
+    /// exists or not.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the overall match offsets in a
+    /// multi-pattern search without allocating a `Captures` value. Indeed, we
+    /// can put our slots right on the stack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     PatternID, Input,
+    /// };
+    ///
+    /// let re = BoundedBacktracker::new_many(&[
+    ///     r"\pL+",
+    ///     r"\d+",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("!@#123");
+    ///
+    /// // We only care about the overall match offsets here, so we just
+    /// // allocate two slots for each pattern. Each slot records the start
+    /// // and end of the match.
+    /// let mut slots = [None; 4];
+    /// let pid = re.try_search_slots(&mut cache, &input, &mut slots)?;
+    /// assert_eq!(Some(PatternID::must(1)), pid);
+    ///
+    /// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'.
+    /// // See 'GroupInfo' for more details on the mapping between groups and
+    /// // slot indices.
+    /// let slot_start = pid.unwrap().as_usize() * 2;
+    /// let slot_end = slot_start + 1;
+    /// assert_eq!(Some(3), slots[slot_start].map(|s| s.get()));
+    /// assert_eq!(Some(6), slots[slot_end].map(|s| s.get()));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        if !utf8empty {
+            return self.try_search_slots_imp(cache, input, slots);
+        }
+        // See PikeVM::try_search_slots for why we do this.
+        let min = self.get_nfa().group_info().implicit_slot_len();
+        if slots.len() >= min {
+            return self.try_search_slots_imp(cache, input, slots);
+        }
+        if self.get_nfa().pattern_len() == 1 {
+            let mut enough = [None, None];
+            let got = self.try_search_slots_imp(cache, input, &mut enough)?;
+            // This is OK because we know `enough_slots` is strictly bigger
+            // than `slots`, otherwise this special case isn't reached.
+            slots.copy_from_slice(&enough[..slots.len()]);
+            return Ok(got);
+        }
+        let mut enough = vec![None; min];
+        let got = self.try_search_slots_imp(cache, input, &mut enough)?;
+        // This is OK because we know `enough_slots` is strictly bigger than
+        // `slots`, otherwise this special case isn't reached.
+        slots.copy_from_slice(&enough[..slots.len()]);
+        Ok(got)
+    }
+
+    /// This is the actual implementation of `try_search_slots_imp` that
+    /// doesn't account for the special case when 1) the NFA has UTF-8 mode
+    /// enabled, 2) the NFA can match the empty string and 3) the caller has
+    /// provided an insufficient number of slots to record match offsets.
+    #[inline(never)]
+    fn try_search_slots_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        let (pid, end) = match self.search_imp(cache, input, slots)? {
+            None => return Ok(None),
+            Some(pid) if !utf8empty => return Ok(Some(pid)),
+            Some(pid) => {
+                let slot_start = pid.as_usize() * 2;
+                let slot_end = slot_start + 1;
+                // OK because we know we have a match and we know our caller
+                // provided slots are big enough (which we make true above if
+                // the caller didn't). Namely, we're only here when 'utf8empty'
+                // is true, and when that's true, we require slots for every
+                // pattern.
+                (pid, slots[slot_end].unwrap().get())
+            }
+        };
+        empty::skip_splits_fwd(input, pid, end, |input| {
+            let pid = match self.search_imp(cache, input, slots)? {
+                None => return Ok(None),
+                Some(pid) => pid,
+            };
+            let slot_start = pid.as_usize() * 2;
+            let slot_end = slot_start + 1;
+            Ok(Some((pid, slots[slot_end].unwrap().get())))
+        })
+    }
+
+    /// The implementation of standard leftmost backtracking search.
+    ///
+    /// Capturing group spans are written to 'caps', but only if requested.
+    /// 'caps' can be one of three things: 1) totally empty, in which case, we
+    /// only report the pattern that matched or 2) only has slots for recording
+    /// the overall match offsets for any pattern or 3) has all slots available
+    /// for recording the spans of any groups participating in a match.
+    fn search_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Result<Option<PatternID>, MatchError> {
+        // Unlike in the PikeVM, we write our capturing group spans directly
+        // into the caller's captures groups. So we have to make sure we're
+        // starting with a blank slate first. In the PikeVM, we avoid this
+        // by construction: the spans that are copied to every slot in the
+        // 'Captures' value already account for presence/absence. In this
+        // backtracker, we write directly into the caller provided slots, where
+        // as in the PikeVM, we write into scratch space first and only copy
+        // them to the caller provided slots when a match is found.
+        for slot in slots.iter_mut() {
+            *slot = None;
+        }
+        cache.setup_search(&self.nfa, input)?;
+        if input.is_done() {
+            return Ok(None);
+        }
+        let (anchored, start_id) = match input.get_anchored() {
+            // Only way we're unanchored is if both the caller asked for an
+            // unanchored search *and* the pattern is itself not anchored.
+            Anchored::No => (
+                self.nfa.is_always_start_anchored(),
+                // We always use the anchored starting state here, even if
+                // doing an unanchored search. The "unanchored" part of it is
+                // implemented in the loop below, by simply trying the next
+                // byte offset if the previous backtracking exploration failed.
+                self.nfa.start_anchored(),
+            ),
+            Anchored::Yes => (true, self.nfa.start_anchored()),
+            Anchored::Pattern(pid) => match self.nfa.start_pattern(pid) {
+                None => return Ok(None),
+                Some(sid) => (true, sid),
+            },
+        };
+        if anchored {
+            let at = input.start();
+            return Ok(self.backtrack(cache, input, at, start_id, slots));
+        }
+        let pre = self.get_config().get_prefilter();
+        let mut at = input.start();
+        while at <= input.end() {
+            if let Some(ref pre) = pre {
+                let span = Span::from(at..input.end());
+                match pre.find(input.haystack(), span) {
+                    None => break,
+                    Some(ref span) => at = span.start,
+                }
+            }
+            if let Some(pid) =
+                self.backtrack(cache, input, at, start_id, slots)
+            {
+                return Ok(Some(pid));
+            }
+            at += 1;
+        }
+        Ok(None)
+    }
+
+    /// Look for a match starting at `at` in `input` and write the matching
+    /// pattern ID and group spans to `caps`. The search uses `start_id` as its
+    /// starting state in the underlying NFA.
+    ///
+    /// If no match was found, then the caller should increment `at` and try
+    /// at the next position.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn backtrack(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        at: usize,
+        start_id: StateID,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        cache.stack.push(Frame::Step { sid: start_id, at });
+        while let Some(frame) = cache.stack.pop() {
+            match frame {
+                Frame::Step { sid, at } => {
+                    if let Some(pid) = self.step(cache, input, sid, at, slots)
+                    {
+                        return Some(pid);
+                    }
+                }
+                Frame::RestoreCapture { slot, offset } => {
+                    slots[slot] = offset;
+                }
+            }
+        }
+        None
+    }
+
+    // LAMENTATION: The actual backtracking search is implemented in about
+    // 75 lines below. Yet this file is over 2,000 lines long. What have I
+    // done?
+
+    /// Execute a "step" in the backtracing algorithm.
+    ///
+    /// A "step" is somewhat of a misnomer, because this routine keeps going
+    /// until it either runs out of things to try or fins a match. In the
+    /// former case, it may have pushed some things on to the backtracking
+    /// stack, in which case, those will be tried next as part of the
+    /// 'backtrack' routine above.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn step(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        mut sid: StateID,
+        mut at: usize,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        loop {
+            if !cache.visited.insert(sid, at - input.start()) {
+                return None;
+            }
+            match *self.nfa.state(sid) {
+                State::ByteRange { ref trans } => {
+                    // Why do we need this? Unlike other regex engines in this
+                    // crate, the backtracker can steam roll ahead in the
+                    // haystack outside of the main loop over the bytes in the
+                    // haystack. While 'trans.matches()' below handles the case
+                    // of 'at' being out of bounds of 'input.haystack()', we
+                    // also need to handle the case of 'at' going out of bounds
+                    // of the span the caller asked to search.
+                    //
+                    // We should perhaps make the 'trans.matches()' API accept
+                    // an '&Input' instead of a '&[u8]'. Or at least, add a new
+                    // API that does it.
+                    if at >= input.end() {
+                        return None;
+                    }
+                    if !trans.matches(input.haystack(), at) {
+                        return None;
+                    }
+                    sid = trans.next;
+                    at += 1;
+                }
+                State::Sparse(ref sparse) => {
+                    if at >= input.end() {
+                        return None;
+                    }
+                    sid = sparse.matches(input.haystack(), at)?;
+                    at += 1;
+                }
+                State::Dense(ref dense) => {
+                    if at >= input.end() {
+                        return None;
+                    }
+                    sid = dense.matches(input.haystack(), at)?;
+                    at += 1;
+                }
+                State::Look { look, next } => {
+                    // OK because we don't permit building a searcher with a
+                    // Unicode word boundary if the requisite Unicode data is
+                    // unavailable.
+                    if !self.nfa.look_matcher().matches_inline(
+                        look,
+                        input.haystack(),
+                        at,
+                    ) {
+                        return None;
+                    }
+                    sid = next;
+                }
+                State::Union { ref alternates } => {
+                    sid = match alternates.get(0) {
+                        None => return None,
+                        Some(&sid) => sid,
+                    };
+                    cache.stack.extend(
+                        alternates[1..]
+                            .iter()
+                            .copied()
+                            .rev()
+                            .map(|sid| Frame::Step { sid, at }),
+                    );
+                }
+                State::BinaryUnion { alt1, alt2 } => {
+                    sid = alt1;
+                    cache.stack.push(Frame::Step { sid: alt2, at });
+                }
+                State::Capture { next, slot, .. } => {
+                    if slot.as_usize() < slots.len() {
+                        cache.stack.push(Frame::RestoreCapture {
+                            slot,
+                            offset: slots[slot],
+                        });
+                        slots[slot] = NonMaxUsize::new(at);
+                    }
+                    sid = next;
+                }
+                State::Fail => return None,
+                State::Match { pattern_id } => {
+                    return Some(pattern_id);
+                }
+            }
+        }
+    }
+}
+
+/// An iterator over all non-overlapping matches for a fallible search.
+///
+/// The iterator yields a `Result<Match, MatchError` value until no more
+/// matches could be found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the BoundedBacktracker.
+/// * `'c` represents the lifetime of the BoundedBacktracker's cache.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`BoundedBacktracker::try_find_iter`]
+/// method.
+#[derive(Debug)]
+pub struct TryFindMatches<'r, 'c, 'h> {
+    re: &'r BoundedBacktracker,
+    cache: &'c mut Cache,
+    caps: Captures,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'c, 'h> Iterator for TryFindMatches<'r, 'c, 'h> {
+    type Item = Result<Match, MatchError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<Match, MatchError>> {
+        // Splitting 'self' apart seems necessary to appease borrowck.
+        let TryFindMatches { re, ref mut cache, ref mut caps, ref mut it } =
+            *self;
+        it.try_advance(|input| {
+            re.try_search(cache, input, caps)?;
+            Ok(caps.get_match())
+        })
+        .transpose()
+    }
+}
+
+/// An iterator over all non-overlapping leftmost matches, with their capturing
+/// groups, for a fallible search.
+///
+/// The iterator yields a `Result<Captures, MatchError>` value until no more
+/// matches could be found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the BoundedBacktracker.
+/// * `'c` represents the lifetime of the BoundedBacktracker's cache.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the
+/// [`BoundedBacktracker::try_captures_iter`] method.
+#[derive(Debug)]
+pub struct TryCapturesMatches<'r, 'c, 'h> {
+    re: &'r BoundedBacktracker,
+    cache: &'c mut Cache,
+    caps: Captures,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'c, 'h> Iterator for TryCapturesMatches<'r, 'c, 'h> {
+    type Item = Result<Captures, MatchError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<Captures, MatchError>> {
+        // Splitting 'self' apart seems necessary to appease borrowck.
+        let TryCapturesMatches { re, ref mut cache, ref mut caps, ref mut it } =
+            *self;
+        let _ = it
+            .try_advance(|input| {
+                re.try_search(cache, input, caps)?;
+                Ok(caps.get_match())
+            })
+            .transpose()?;
+        if caps.is_match() {
+            Some(Ok(caps.clone()))
+        } else {
+            None
+        }
+    }
+}
+
+/// A cache represents mutable state that a [`BoundedBacktracker`] requires
+/// during a search.
+///
+/// For a given [`BoundedBacktracker`], its corresponding cache may be created
+/// either via [`BoundedBacktracker::create_cache`], or via [`Cache::new`].
+/// They are equivalent in every way, except the former does not require
+/// explicitly importing `Cache`.
+///
+/// A particular `Cache` is coupled with the [`BoundedBacktracker`] from which
+/// it was created. It may only be used with that `BoundedBacktracker`. A cache
+/// and its allocations may be re-purposed via [`Cache::reset`], in which case,
+/// it can only be used with the new `BoundedBacktracker` (and not the old
+/// one).
+#[derive(Clone, Debug)]
+pub struct Cache {
+    /// Stack used on the heap for doing backtracking instead of the
+    /// traditional recursive approach. We don't want recursion because then
+    /// we're likely to hit a stack overflow for bigger regexes.
+    stack: Vec<Frame>,
+    /// The set of (StateID, HaystackOffset) pairs that have been visited
+    /// by the backtracker within a single search. If such a pair has been
+    /// visited, then we avoid doing the work for that pair again. This is
+    /// what "bounds" the backtracking and prevents it from having worst case
+    /// exponential time.
+    visited: Visited,
+}
+
+impl Cache {
+    /// Create a new [`BoundedBacktracker`] cache.
+    ///
+    /// A potentially more convenient routine to create a cache is
+    /// [`BoundedBacktracker::create_cache`], as it does not require also
+    /// importing the `Cache` type.
+    ///
+    /// If you want to reuse the returned `Cache` with some other
+    /// `BoundedBacktracker`, then you must call [`Cache::reset`] with the
+    /// desired `BoundedBacktracker`.
+    pub fn new(re: &BoundedBacktracker) -> Cache {
+        Cache { stack: vec![], visited: Visited::new(re) }
+    }
+
+    /// Reset this cache such that it can be used for searching with different
+    /// [`BoundedBacktracker`].
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `BoundedBacktracker`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different
+    /// `BoundedBacktracker`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::backtrack::BoundedBacktracker,
+    ///     Match,
+    /// };
+    ///
+    /// let re1 = BoundedBacktracker::new(r"\w")?;
+    /// let re2 = BoundedBacktracker::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Ok(Match::must(0, 0..2))),
+    ///     re1.try_find_iter(&mut cache, "Δ").next(),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the BoundedBacktracker we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// cache.reset(&re2);
+    /// assert_eq!(
+    ///     Some(Ok(Match::must(0, 0..3))),
+    ///     re2.try_find_iter(&mut cache, "☃").next(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, re: &BoundedBacktracker) {
+        self.visited.reset(re);
+    }
+
+    /// Returns the heap memory usage, in bytes, of this cache.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        self.stack.len() * core::mem::size_of::<Frame>()
+            + self.visited.memory_usage()
+    }
+
+    /// Clears this cache. This should be called at the start of every search
+    /// to ensure we start with a clean slate.
+    ///
+    /// This also sets the length of the capturing groups used in the current
+    /// search. This permits an optimization where by 'SlotTable::for_state'
+    /// only returns the number of slots equivalent to the number of slots
+    /// given in the 'Captures' value. This may be less than the total number
+    /// of possible slots, e.g., when one only wants to track overall match
+    /// offsets. This in turn permits less copying of capturing group spans
+    /// in the BoundedBacktracker.
+    fn setup_search(
+        &mut self,
+        nfa: &NFA,
+        input: &Input<'_>,
+    ) -> Result<(), MatchError> {
+        self.stack.clear();
+        self.visited.setup_search(nfa, input)?;
+        Ok(())
+    }
+}
+
+/// Represents a stack frame on the heap while doing backtracking.
+///
+/// Instead of using explicit recursion for backtracking, we use a stack on
+/// the heap to keep track of things that we want to explore if the current
+/// backtracking branch turns out to not lead to a match.
+#[derive(Clone, Debug)]
+enum Frame {
+    /// Look for a match starting at `sid` and the given position in the
+    /// haystack.
+    Step { sid: StateID, at: usize },
+    /// Reset the given `slot` to the given `offset` (which might be `None`).
+    /// This effectively gives a "scope" to capturing groups, such that an
+    /// offset for a particular group only gets returned if the match goes
+    /// through that capturing group. If backtracking ends up going down a
+    /// different branch that results in a different offset (or perhaps none at
+    /// all), then this "restore capture" frame will cause the offset to get
+    /// reset.
+    RestoreCapture { slot: SmallIndex, offset: Option<NonMaxUsize> },
+}
+
+/// A bitset that keeps track of whether a particular (StateID, offset) has
+/// been considered during backtracking. If it has already been visited, then
+/// backtracking skips it. This is what gives backtracking its "bound."
+#[derive(Clone, Debug)]
+struct Visited {
+    /// The actual underlying bitset. Each element in the bitset corresponds
+    /// to a particular (StateID, offset) pair. States correspond to the rows
+    /// and the offsets correspond to the columns.
+    ///
+    /// If our underlying NFA has N states and the haystack we're searching
+    /// has M bytes, then we have N*(M+1) entries in our bitset table. The
+    /// M+1 occurs because our matches are delayed by one byte (to support
+    /// look-around), and so we need to handle the end position itself rather
+    /// than stopping just before the end. (If there is no end position, then
+    /// it's treated as "end-of-input," which is matched by things like '$'.)
+    ///
+    /// Given BITS=N*(M+1), we wind up with div_ceil(BITS, sizeof(usize))
+    /// blocks.
+    ///
+    /// We use 'usize' to represent our blocks because it makes some of the
+    /// arithmetic in 'insert' a bit nicer. For example, if we used 'u32' for
+    /// our block, we'd either need to cast u32s to usizes or usizes to u32s.
+    bitset: Vec<usize>,
+    /// The stride represents one plus length of the haystack we're searching
+    /// (as described above). The stride must be initialized for each search.
+    stride: usize,
+}
+
+impl Visited {
+    /// The size of each block, in bits.
+    const BLOCK_SIZE: usize = 8 * core::mem::size_of::<usize>();
+
+    /// Create a new visited set for the given backtracker.
+    ///
+    /// The set is ready to use, but must be setup at the beginning of each
+    /// search by calling `setup_search`.
+    fn new(re: &BoundedBacktracker) -> Visited {
+        let mut visited = Visited { bitset: vec![], stride: 0 };
+        visited.reset(re);
+        visited
+    }
+
+    /// Insert the given (StateID, offset) pair into this set. If it already
+    /// exists, then this is a no-op and it returns false. Otherwise this
+    /// returns true.
+    fn insert(&mut self, sid: StateID, at: usize) -> bool {
+        let table_index = sid.as_usize() * self.stride + at;
+        let block_index = table_index / Visited::BLOCK_SIZE;
+        let bit = table_index % Visited::BLOCK_SIZE;
+        let block_with_bit = 1 << bit;
+        if self.bitset[block_index] & block_with_bit != 0 {
+            return false;
+        }
+        self.bitset[block_index] |= block_with_bit;
+        true
+    }
+
+    /// Returns the capacity of this visited set in terms of the number of bits
+    /// it has to track (StateID, offset) pairs.
+    fn capacity(&self) -> usize {
+        self.bitset.len() * Visited::BLOCK_SIZE
+    }
+
+    /// Reset this visited set to work with the given bounded backtracker.
+    fn reset(&mut self, re: &BoundedBacktracker) {
+        // The capacity given in the config is "bytes of heap memory," but the
+        // capacity we use here is "number of bits." So conver the capacity in
+        // bytes to the capacity in bits.
+        let capacity = 8 * re.get_config().get_visited_capacity();
+        let blocks = div_ceil(capacity, Visited::BLOCK_SIZE);
+        self.bitset.resize(blocks, 0);
+        // N.B. 'stride' is set in 'setup_search', since it isn't known until
+        // we know the length of the haystack. (That is also when we return an
+        // error if the haystack is too big.)
+    }
+
+    /// Setup this visited set to work for a search using the given NFA
+    /// and input configuration. The NFA must be the same NFA used by the
+    /// BoundedBacktracker given to Visited::reset. Failing to call this might
+    /// result in panics or silently incorrect search behavior.
+    fn setup_search(
+        &mut self,
+        nfa: &NFA,
+        input: &Input<'_>,
+    ) -> Result<(), MatchError> {
+        // Our haystack length is only the length of the span of the entire
+        // haystack that we'll be searching.
+        let haylen = input.get_span().len();
+        let err = || MatchError::haystack_too_long(haylen);
+        // Our stride is one more than the length of the input because our main
+        // search loop includes the position at input.end(). (And it does this
+        // because matches are delayed by one byte to account for look-around.)
+        self.stride = haylen + 1;
+        let capacity = match nfa.states().len().checked_mul(self.stride) {
+            None => return Err(err()),
+            Some(capacity) => capacity,
+        };
+        if capacity > self.capacity() {
+            return Err(err());
+        }
+        // We only need to zero out our desired capacity, not our total
+        // capacity in this set.
+        let blocks = div_ceil(capacity, Visited::BLOCK_SIZE);
+        for block in self.bitset.iter_mut().take(blocks) {
+            *block = 0;
+        }
+        Ok(())
+    }
+
+    /// Return the heap memory usage, in bytes, of this visited set.
+    fn memory_usage(&self) -> usize {
+        self.bitset.len() * core::mem::size_of::<usize>()
+    }
+}
+
+/// Integer division, but rounds up instead of down.
+fn div_ceil(lhs: usize, rhs: usize) -> usize {
+    if lhs % rhs == 0 {
+        lhs / rhs
+    } else {
+        (lhs / rhs) + 1
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/builder.rs b/regex-automata/src/nfa/thompson/builder.rs
new file mode 100644
index 0000000000..b57e5bc0f3
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/builder.rs
@@ -0,0 +1,1337 @@
+use core::mem;
+
+use alloc::{sync::Arc, vec, vec::Vec};
+
+use crate::{
+    nfa::thompson::{
+        error::BuildError,
+        nfa::{self, SparseTransitions, Transition, NFA},
+    },
+    util::{
+        look::{Look, LookMatcher},
+        primitives::{IteratorIndexExt, PatternID, SmallIndex, StateID},
+    },
+};
+
+/// An intermediate NFA state used during construction.
+///
+/// During construction of an NFA, it is often convenient to work with states
+/// that are amenable to mutation and other carry more information than we
+/// otherwise need once an NFA has been built. This type represents those
+/// needs.
+///
+/// Once construction is finished, the builder will convert these states to a
+/// [`nfa::thompson::State`](crate::nfa::thompson::State). This conversion not
+/// only results in a simpler representation, but in some cases, entire classes
+/// of states are completely removed (such as [`State::Empty`]).
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum State {
+    /// An empty state whose only purpose is to forward the automaton to
+    /// another state via an unconditional epsilon transition.
+    ///
+    /// Unconditional epsilon transitions are quite useful during the
+    /// construction of an NFA, as they permit the insertion of no-op
+    /// placeholders that make it easier to compose NFA sub-graphs. When
+    /// the Thompson NFA builder produces a final NFA, all unconditional
+    /// epsilon transitions are removed, and state identifiers are remapped
+    /// accordingly.
+    Empty {
+        /// The next state that this state should transition to.
+        next: StateID,
+    },
+    /// A state that only transitions to another state if the current input
+    /// byte is in a particular range of bytes.
+    ByteRange { trans: Transition },
+    /// A state with possibly many transitions, represented in a sparse
+    /// fashion. Transitions must be ordered lexicographically by input range
+    /// and be non-overlapping. As such, this may only be used when every
+    /// transition has equal priority. (In practice, this is only used for
+    /// encoding large UTF-8 automata.) In contrast, a `Union` state has each
+    /// alternate in order of priority. Priority is used to implement greedy
+    /// matching and also alternations themselves, e.g., `abc|a` where `abc`
+    /// has priority over `a`.
+    ///
+    /// To clarify, it is possible to remove `Sparse` and represent all things
+    /// that `Sparse` is used for via `Union`. But this creates a more bloated
+    /// NFA with more epsilon transitions than is necessary in the special case
+    /// of character classes.
+    Sparse { transitions: Vec<Transition> },
+    /// A conditional epsilon transition satisfied via some sort of
+    /// look-around.
+    Look { look: Look, next: StateID },
+    /// An empty state that records the start of a capture location. This is an
+    /// unconditional epsilon transition like `Empty`, except it can be used to
+    /// record position information for a captue group when using the NFA for
+    /// search.
+    CaptureStart {
+        /// The ID of the pattern that this capture was defined.
+        pattern_id: PatternID,
+        /// The capture group index that this capture state corresponds to.
+        /// The capture group index is always relative to its corresponding
+        /// pattern. Therefore, in the presence of multiple patterns, both the
+        /// pattern ID and the capture group index are required to uniquely
+        /// identify a capturing group.
+        group_index: SmallIndex,
+        /// The next state that this state should transition to.
+        next: StateID,
+    },
+    /// An empty state that records the end of a capture location. This is an
+    /// unconditional epsilon transition like `Empty`, except it can be used to
+    /// record position information for a captue group when using the NFA for
+    /// search.
+    CaptureEnd {
+        /// The ID of the pattern that this capture was defined.
+        pattern_id: PatternID,
+        /// The capture group index that this capture state corresponds to.
+        /// The capture group index is always relative to its corresponding
+        /// pattern. Therefore, in the presence of multiple patterns, both the
+        /// pattern ID and the capture group index are required to uniquely
+        /// identify a capturing group.
+        group_index: SmallIndex,
+        /// The next state that this state should transition to.
+        next: StateID,
+    },
+    /// An alternation such that there exists an epsilon transition to all
+    /// states in `alternates`, where matches found via earlier transitions
+    /// are preferred over later transitions.
+    Union { alternates: Vec<StateID> },
+    /// An alternation such that there exists an epsilon transition to all
+    /// states in `alternates`, where matches found via later transitions are
+    /// preferred over earlier transitions.
+    ///
+    /// This "reverse" state exists for convenience during compilation that
+    /// permits easy construction of non-greedy combinations of NFA states. At
+    /// the end of compilation, Union and UnionReverse states are merged into
+    /// one Union type of state, where the latter has its epsilon transitions
+    /// reversed to reflect the priority inversion.
+    ///
+    /// The "convenience" here arises from the fact that as new states are
+    /// added to the list of `alternates`, we would like that add operation
+    /// to be amortized constant time. But if we used a `Union`, we'd need to
+    /// prepend the state, which takes O(n) time. There are other approaches we
+    /// could use to solve this, but this seems simple enough.
+    UnionReverse { alternates: Vec<StateID> },
+    /// A state that cannot be transitioned out of. This is useful for cases
+    /// where you want to prevent matching from occurring. For example, if your
+    /// regex parser permits empty character classes, then one could choose a
+    /// `Fail` state to represent it.
+    Fail,
+    /// A match state. There is at most one such occurrence of this state in
+    /// an NFA for each pattern compiled into the NFA. At time of writing, a
+    /// match state is always produced for every pattern given, but in theory,
+    /// if a pattern can never lead to a match, then the match state could be
+    /// omitted.
+    ///
+    /// `pattern_id` refers to the ID of the pattern itself, which corresponds
+    /// to the pattern's index (starting at 0).
+    Match { pattern_id: PatternID },
+}
+
+impl State {
+    /// If this state is an unconditional espilon transition, then this returns
+    /// the target of the transition.
+    fn goto(&self) -> Option<StateID> {
+        match *self {
+            State::Empty { next } => Some(next),
+            State::Union { ref alternates } if alternates.len() == 1 => {
+                Some(alternates[0])
+            }
+            State::UnionReverse { ref alternates }
+                if alternates.len() == 1 =>
+            {
+                Some(alternates[0])
+            }
+            _ => None,
+        }
+    }
+
+    /// Returns the heap memory usage, in bytes, of this state.
+    fn memory_usage(&self) -> usize {
+        match *self {
+            State::Empty { .. }
+            | State::ByteRange { .. }
+            | State::Look { .. }
+            | State::CaptureStart { .. }
+            | State::CaptureEnd { .. }
+            | State::Fail
+            | State::Match { .. } => 0,
+            State::Sparse { ref transitions } => {
+                transitions.len() * mem::size_of::<Transition>()
+            }
+            State::Union { ref alternates } => {
+                alternates.len() * mem::size_of::<StateID>()
+            }
+            State::UnionReverse { ref alternates } => {
+                alternates.len() * mem::size_of::<StateID>()
+            }
+        }
+    }
+}
+
+/// An abstraction for building Thompson NFAs by hand.
+///
+/// A builder is what a [`thompson::Compiler`](crate::nfa::thompson::Compiler)
+/// uses internally to translate a regex's high-level intermediate
+/// representation into an [`NFA`].
+///
+/// The primary function of this builder is to abstract away the internal
+/// representation of an NFA and make it difficult to produce NFAs are that
+/// internally invalid or inconsistent. This builder also provides a way to
+/// add "empty" states (which can be thought of as unconditional epsilon
+/// transitions), despite the fact that [`thompson::State`](nfa::State) does
+/// not have any "empty" representation. The advantage of "empty" states is
+/// that they make the code for constructing a Thompson NFA logically simpler.
+///
+/// Many of the routines on this builder may panic or return errors. Generally
+/// speaking, panics occur when an invalid sequence of method calls were made,
+/// where as an error occurs if things get too big. (Where "too big" might mean
+/// exhausting identifier space or using up too much heap memory in accordance
+/// with the configured [`size_limit`](Builder::set_size_limit).)
+///
+/// # Overview
+///
+/// ## Adding multiple patterns
+///
+/// Each pattern you add to an NFA should correspond to a pair of
+/// [`Builder::start_pattern`] and [`Builder::finish_pattern`] calls, with
+/// calls inbetween that add NFA states for that pattern. NFA states may be
+/// added without first calling `start_pattern`, with the exception of adding
+/// capturing states.
+///
+/// ## Adding NFA states
+///
+/// Here is a very brief overview of each of the methods that add NFA states.
+/// Every method adds a single state.
+///
+/// * [`add_empty`](Builder::add_empty): Add a state with a single
+/// unconditional epsilon transition to another state.
+/// * [`add_union`](Builder::add_union): Adds a state with unconditional
+/// epsilon transitions to two or more states, with earlier transitions
+/// preferred over later ones.
+/// * [`add_union_reverse`](Builder::add_union_reverse): Adds a state with
+/// unconditional epsilon transitions to two or more states, with later
+/// transitions preferred over earlier ones.
+/// * [`add_range`](Builder::add_range): Adds a state with a single transition
+/// to another state that can only be followed if the current input byte is
+/// within the range given.
+/// * [`add_sparse`](Builder::add_sparse): Adds a state with two or more
+/// range transitions to other states, where a transition is only followed
+/// if the current input byte is within one of the ranges. All transitions
+/// in this state have equal priority, and the corresponding ranges must be
+/// non-overlapping.
+/// * [`add_look`](Builder::add_look): Adds a state with a single *conditional*
+/// epsilon transition to another state, where the condition depends on a
+/// limited look-around property.
+/// * [`add_capture_start`](Builder::add_capture_start): Adds a state with
+/// a single unconditional epsilon transition that also instructs an NFA
+/// simulation to record the current input position to a specific location in
+/// memory. This is intended to represent the starting location of a capturing
+/// group.
+/// * [`add_capture_end`](Builder::add_capture_end): Adds a state with
+/// a single unconditional epsilon transition that also instructs an NFA
+/// simulation to record the current input position to a specific location in
+/// memory. This is intended to represent the ending location of a capturing
+/// group.
+/// * [`add_fail`](Builder::add_fail): Adds a state that never transitions to
+/// another state.
+/// * [`add_match`](Builder::add_match): Add a state that indicates a match has
+/// been found for a particular pattern. A match state is a final state with
+/// no outgoing transitions.
+///
+/// ## Setting transitions between NFA states
+///
+/// The [`Builder::patch`] method creates a transition from one state to the
+/// next. If the `from` state corresponds to a state that supports multiple
+/// outgoing transitions (such as "union"), then this adds the corresponding
+/// transition. Otherwise, it sets the single transition. (This routine panics
+/// if `from` corresponds to a state added by `add_sparse`, since sparse states
+/// need more specialized handling.)
+///
+/// # Example
+///
+/// This annotated example shows how to hand construct the regex `[a-z]+`
+/// (without an unanchored prefix).
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::{pikevm::PikeVM, Builder, Transition},
+///     util::primitives::StateID,
+///     Match,
+/// };
+///
+/// let mut builder = Builder::new();
+/// // Before adding NFA states for our pattern, we need to tell the builder
+/// // that we are starting the pattern.
+/// builder.start_pattern()?;
+/// // Since we use the Pike VM below for searching, we need to add capturing
+/// // states. If you're just going to build a DFA from the NFA, then capturing
+/// // states do not need to be added.
+/// let start = builder.add_capture_start(StateID::ZERO, 0, None)?;
+/// let range = builder.add_range(Transition {
+///     // We don't know the state ID of the 'next' state yet, so we just fill
+///     // in a dummy 'ZERO' value.
+///     start: b'a', end: b'z', next: StateID::ZERO,
+/// })?;
+/// // This state will point back to 'range', but also enable us to move ahead.
+/// // That is, this implements the '+' repetition operator. We add 'range' and
+/// // then 'end' below to this alternation.
+/// let alt = builder.add_union(vec![])?;
+/// // The final state before the match state, which serves to capture the
+/// // end location of the match.
+/// let end = builder.add_capture_end(StateID::ZERO, 0)?;
+/// // The match state for our pattern.
+/// let mat = builder.add_match()?;
+/// // Now we fill in the transitions between states.
+/// builder.patch(start, range)?;
+/// builder.patch(range, alt)?;
+/// // If we added 'end' before 'range', then we'd implement non-greedy
+/// // matching, i.e., '+?'.
+/// builder.patch(alt, range)?;
+/// builder.patch(alt, end)?;
+/// builder.patch(end, mat)?;
+/// // We must explicitly finish pattern and provide the starting state ID for
+/// // this particular pattern.
+/// builder.finish_pattern(start)?;
+/// // Finally, when we build the NFA, we provide the anchored and unanchored
+/// // starting state IDs. Since we didn't bother with an unanchored prefix
+/// // here, we only support anchored searching. Thus, both starting states are
+/// // the same.
+/// let nfa = builder.build(start, start)?;
+///
+/// // Now build a Pike VM from our NFA, and use it for searching. This shows
+/// // how we can use a regex engine without ever worrying about syntax!
+/// let re = PikeVM::new_from_nfa(nfa)?;
+/// let mut cache = re.create_cache();
+/// let mut caps = re.create_captures();
+/// let expected = Some(Match::must(0, 0..3));
+/// re.captures(&mut cache, "foo0", &mut caps);
+/// assert_eq!(expected, caps.get_match());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct Builder {
+    /// The ID of the pattern that we're currently building.
+    ///
+    /// Callers are required to set (and unset) this by calling
+    /// {start,finish}_pattern. Otherwise, most methods will panic.
+    pattern_id: Option<PatternID>,
+    /// A sequence of intermediate NFA states. Once a state is added to this
+    /// sequence, it is assigned a state ID equivalent to its index. Once a
+    /// state is added, it is still expected to be mutated, e.g., to set its
+    /// transition to a state that didn't exist at the time it was added.
+    states: Vec<State>,
+    /// The starting states for each individual pattern. Starting at any
+    /// of these states will result in only an anchored search for the
+    /// corresponding pattern. The vec is indexed by pattern ID. When the NFA
+    /// contains a single regex, then `start_pattern[0]` and `start_anchored`
+    /// are always equivalent.
+    start_pattern: Vec<StateID>,
+    /// A map from pattern ID to capture group index to name. (If no name
+    /// exists, then a None entry is present. Thus, all capturing groups are
+    /// present in this mapping.)
+    ///
+    /// The outer vec is indexed by pattern ID, while the inner vec is indexed
+    /// by capture index offset for the corresponding pattern.
+    ///
+    /// The first capture group for each pattern is always unnamed and is thus
+    /// always None.
+    captures: Vec<Vec<Option<Arc<str>>>>,
+    /// The combined memory used by each of the 'State's in 'states'. This
+    /// only includes heap usage by each state, and not the size of the state
+    /// itself. In other words, this tracks heap memory used that isn't
+    /// captured via `size_of::<State>() * states.len()`.
+    memory_states: usize,
+    /// Whether this NFA only matches UTF-8 and whether regex engines using
+    /// this NFA for searching should report empty matches that split a
+    /// codepoint.
+    utf8: bool,
+    /// Whether this NFA should be matched in reverse or not.
+    reverse: bool,
+    /// The matcher to use for look-around assertions.
+    look_matcher: LookMatcher,
+    /// A size limit to respect when building an NFA. If the total heap memory
+    /// of the intermediate NFA states exceeds (or would exceed) this amount,
+    /// then an error is returned.
+    size_limit: Option<usize>,
+}
+
+impl Builder {
+    /// Create a new builder for hand-assembling NFAs.
+    pub fn new() -> Builder {
+        Builder::default()
+    }
+
+    /// Clear this builder.
+    ///
+    /// Clearing removes all state associated with building an NFA, but does
+    /// not reset configuration (such as size limits and whether the NFA
+    /// should only match UTF-8). After clearing, the builder can be reused to
+    /// assemble an entirely new NFA.
+    pub fn clear(&mut self) {
+        self.pattern_id = None;
+        self.states.clear();
+        self.start_pattern.clear();
+        self.captures.clear();
+        self.memory_states = 0;
+    }
+
+    /// Assemble a [`NFA`] from the states added so far.
+    ///
+    /// After building an NFA, more states may be added and `build` may be
+    /// called again. To reuse a builder to produce an entirely new NFA from
+    /// scratch, call the [`clear`](Builder::clear) method first.
+    ///
+    /// `start_anchored` refers to the ID of the starting state that anchored
+    /// searches should use. That is, searches who matches are limited to the
+    /// starting position of the search.
+    ///
+    /// `start_unanchored` refers to the ID of the starting state that
+    /// unanchored searches should use. This permits searches to report matches
+    /// that start after the beginning of the search. In cases where unanchored
+    /// searches are not supported, the unanchored starting state ID must be
+    /// the same as the anchored starting state ID.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if there was a problem producing the final NFA.
+    /// In particular, this might include an error if the capturing groups
+    /// added to this builder violate any of the invariants documented on
+    /// [`GroupInfo`](crate::util::captures::GroupInfo).
+    ///
+    /// # Panics
+    ///
+    /// If `start_pattern` was called, then `finish_pattern` must be called
+    /// before `build`, otherwise this panics.
+    ///
+    /// This may panic for other invalid uses of a builder. For example, if
+    /// a "start capture" state was added without a corresponding "end capture"
+    /// state.
+    pub fn build(
+        &self,
+        start_anchored: StateID,
+        start_unanchored: StateID,
+    ) -> Result<NFA, BuildError> {
+        assert!(self.pattern_id.is_none(), "must call 'finish_pattern' first");
+        debug!(
+            "intermediate NFA compilation via builder is complete, \
+             intermediate NFA size: {} states, {} bytes on heap",
+            self.states.len(),
+            self.memory_usage(),
+        );
+
+        let mut nfa = nfa::Inner::default();
+        nfa.set_utf8(self.utf8);
+        nfa.set_reverse(self.reverse);
+        nfa.set_look_matcher(self.look_matcher.clone());
+        // A set of compiler internal state IDs that correspond to states
+        // that are exclusively epsilon transitions, i.e., goto instructions,
+        // combined with the state that they point to. This is used to
+        // record said states while transforming the compiler's internal NFA
+        // representation to the external form.
+        let mut empties = vec![];
+        // A map used to re-map state IDs when translating this builder's
+        // internal NFA state representation to the final NFA representation.
+        let mut remap = vec![];
+        remap.resize(self.states.len(), StateID::ZERO);
+
+        nfa.set_starts(start_anchored, start_unanchored, &self.start_pattern);
+        nfa.set_captures(&self.captures).map_err(BuildError::captures)?;
+        // The idea here is to convert our intermediate states to their final
+        // form. The only real complexity here is the process of converting
+        // transitions, which are expressed in terms of state IDs. The new
+        // set of states will be smaller because of partial epsilon removal,
+        // so the state IDs will not be the same.
+        for (sid, state) in self.states.iter().with_state_ids() {
+            match *state {
+                State::Empty { next } => {
+                    // Since we're removing empty states, we need to handle
+                    // them later since we don't yet know which new state this
+                    // empty state will be mapped to.
+                    empties.push((sid, next));
+                }
+                State::ByteRange { trans } => {
+                    remap[sid] = nfa.add(nfa::State::ByteRange { trans });
+                }
+                State::Sparse { ref transitions } => {
+                    remap[sid] = match transitions.len() {
+                        0 => nfa.add(nfa::State::Fail),
+                        1 => nfa.add(nfa::State::ByteRange {
+                            trans: transitions[0],
+                        }),
+                        _ => {
+                            let transitions =
+                                transitions.to_vec().into_boxed_slice();
+                            let sparse = SparseTransitions { transitions };
+                            nfa.add(nfa::State::Sparse(sparse))
+                        }
+                    }
+                }
+                State::Look { look, next } => {
+                    remap[sid] = nfa.add(nfa::State::Look { look, next });
+                }
+                State::CaptureStart { pattern_id, group_index, next } => {
+                    // We can't remove this empty state because of the side
+                    // effect of capturing an offset for this capture slot.
+                    let slot = nfa
+                        .group_info()
+                        .slot(pattern_id, group_index.as_usize())
+                        .expect("invalid capture index");
+                    let slot =
+                        SmallIndex::new(slot).expect("a small enough slot");
+                    remap[sid] = nfa.add(nfa::State::Capture {
+                        next,
+                        pattern_id,
+                        group_index,
+                        slot,
+                    });
+                }
+                State::CaptureEnd { pattern_id, group_index, next } => {
+                    // We can't remove this empty state because of the side
+                    // effect of capturing an offset for this capture slot.
+                    // Also, this always succeeds because we check that all
+                    // slot indices are valid for all capture indices when they
+                    // are initially added.
+                    let slot = nfa
+                        .group_info()
+                        .slot(pattern_id, group_index.as_usize())
+                        .expect("invalid capture index")
+                        .checked_add(1)
+                        .unwrap();
+                    let slot =
+                        SmallIndex::new(slot).expect("a small enough slot");
+                    remap[sid] = nfa.add(nfa::State::Capture {
+                        next,
+                        pattern_id,
+                        group_index,
+                        slot,
+                    });
+                }
+                State::Union { ref alternates } => {
+                    if alternates.is_empty() {
+                        remap[sid] = nfa.add(nfa::State::Fail);
+                    } else if alternates.len() == 1 {
+                        empties.push((sid, alternates[0]));
+                        remap[sid] = alternates[0];
+                    } else if alternates.len() == 2 {
+                        remap[sid] = nfa.add(nfa::State::BinaryUnion {
+                            alt1: alternates[0],
+                            alt2: alternates[1],
+                        });
+                    } else {
+                        let alternates =
+                            alternates.to_vec().into_boxed_slice();
+                        remap[sid] = nfa.add(nfa::State::Union { alternates });
+                    }
+                }
+                State::UnionReverse { ref alternates } => {
+                    if alternates.is_empty() {
+                        remap[sid] = nfa.add(nfa::State::Fail);
+                    } else if alternates.len() == 1 {
+                        empties.push((sid, alternates[0]));
+                        remap[sid] = alternates[0];
+                    } else if alternates.len() == 2 {
+                        remap[sid] = nfa.add(nfa::State::BinaryUnion {
+                            alt1: alternates[1],
+                            alt2: alternates[0],
+                        });
+                    } else {
+                        let mut alternates =
+                            alternates.to_vec().into_boxed_slice();
+                        alternates.reverse();
+                        remap[sid] = nfa.add(nfa::State::Union { alternates });
+                    }
+                }
+                State::Fail => {
+                    remap[sid] = nfa.add(nfa::State::Fail);
+                }
+                State::Match { pattern_id } => {
+                    remap[sid] = nfa.add(nfa::State::Match { pattern_id });
+                }
+            }
+        }
+        // Some of the new states still point to empty state IDs, so we need to
+        // follow each of them and remap the empty state IDs to their non-empty
+        // state IDs.
+        //
+        // We also keep track of which states we've already mapped. This helps
+        // avoid quadratic behavior in a long chain of empty states. For
+        // example, in 'a{0}{50000}'.
+        let mut remapped = vec![false; self.states.len()];
+        for &(empty_id, empty_next) in empties.iter() {
+            if remapped[empty_id] {
+                continue;
+            }
+            // empty states can point to other empty states, forming a chain.
+            // So we must follow the chain until the end, which must end at
+            // a non-empty state, and therefore, a state that is correctly
+            // remapped. We are guaranteed to terminate because our compiler
+            // never builds a loop among only empty states.
+            let mut new_next = empty_next;
+            while let Some(next) = self.states[new_next].goto() {
+                new_next = next;
+            }
+            remap[empty_id] = remap[new_next];
+            remapped[empty_id] = true;
+
+            // Now that we've remapped the main 'empty_id' above, we re-follow
+            // the chain from above and remap every empty state we found along
+            // the way to our ultimate non-empty target. We are careful to set
+            // 'remapped' to true for each such state. We thus will not need
+            // to re-compute this chain for any subsequent empty states in
+            // 'empties' that are part of this chain.
+            let mut next2 = empty_next;
+            while let Some(next) = self.states[next2].goto() {
+                remap[next2] = remap[new_next];
+                remapped[next2] = true;
+                next2 = next;
+            }
+        }
+        // Finally remap all of the state IDs.
+        nfa.remap(&remap);
+        let final_nfa = nfa.into_nfa();
+        debug!(
+            "NFA compilation via builder complete, \
+             final NFA size: {} states, {} bytes on heap, \
+             has empty? {:?}, utf8? {:?}",
+            final_nfa.states().len(),
+            final_nfa.memory_usage(),
+            final_nfa.has_empty(),
+            final_nfa.is_utf8(),
+        );
+        Ok(final_nfa)
+    }
+
+    /// Start the assembly of a pattern in this NFA.
+    ///
+    /// Upon success, this returns the identifier for the new pattern.
+    /// Identifiers start at `0` and are incremented by 1 for each new pattern.
+    ///
+    /// It is necessary to call this routine before adding capturing states.
+    /// Otherwise, any other NFA state may be added before starting a pattern.
+    ///
+    /// # Errors
+    ///
+    /// If the pattern identifier space is exhausted, then this returns an
+    /// error.
+    ///
+    /// # Panics
+    ///
+    /// If this is called while assembling another pattern (i.e., before
+    /// `finish_pattern` is called), then this panics.
+    pub fn start_pattern(&mut self) -> Result<PatternID, BuildError> {
+        assert!(self.pattern_id.is_none(), "must call 'finish_pattern' first");
+
+        let proposed = self.start_pattern.len();
+        let pid = PatternID::new(proposed)
+            .map_err(|_| BuildError::too_many_patterns(proposed))?;
+        self.pattern_id = Some(pid);
+        // This gets filled in when 'finish_pattern' is called.
+        self.start_pattern.push(StateID::ZERO);
+        Ok(pid)
+    }
+
+    /// Finish the assembly of a pattern in this NFA.
+    ///
+    /// Upon success, this returns the identifier for the new pattern.
+    /// Identifiers start at `0` and are incremented by 1 for each new
+    /// pattern. This is the same identifier returned by the corresponding
+    /// `start_pattern` call.
+    ///
+    /// Note that `start_pattern` and `finish_pattern` pairs cannot be
+    /// interleaved or nested. A correct `finish_pattern` call _always_
+    /// corresponds to the most recently called `start_pattern` routine.
+    ///
+    /// # Errors
+    ///
+    /// This currently never returns an error, but this is subject to change.
+    ///
+    /// # Panics
+    ///
+    /// If this is called without a corresponding `start_pattern` call, then
+    /// this panics.
+    pub fn finish_pattern(
+        &mut self,
+        start_id: StateID,
+    ) -> Result<PatternID, BuildError> {
+        let pid = self.current_pattern_id();
+        self.start_pattern[pid] = start_id;
+        self.pattern_id = None;
+        Ok(pid)
+    }
+
+    /// Returns the pattern identifier of the current pattern.
+    ///
+    /// # Panics
+    ///
+    /// If this doesn't occur after a `start_pattern` call and before the
+    /// corresponding `finish_pattern` call, then this panics.
+    pub fn current_pattern_id(&self) -> PatternID {
+        self.pattern_id.expect("must call 'start_pattern' first")
+    }
+
+    /// Returns the number of patterns added to this builder so far.
+    ///
+    /// This only includes patterns that have had `finish_pattern` called
+    /// for them.
+    pub fn pattern_len(&self) -> usize {
+        self.start_pattern.len()
+    }
+
+    /// Add an "empty" NFA state.
+    ///
+    /// An "empty" NFA state is a state with a single unconditional epsilon
+    /// transition to another NFA state. Such empty states are removed before
+    /// building the final [`NFA`] (which has no such "empty" states), but they
+    /// can be quite useful in the construction process of an NFA.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_empty(&mut self) -> Result<StateID, BuildError> {
+        self.add(State::Empty { next: StateID::ZERO })
+    }
+
+    /// Add a "union" NFA state.
+    ///
+    /// A "union" NFA state that contains zero or more unconditional epsilon
+    /// transitions to other NFA states. The order of these transitions
+    /// reflects a priority order where earlier transitions are preferred over
+    /// later transitions.
+    ///
+    /// Callers may provide an empty set of alternates to this method call, and
+    /// then later add transitions via `patch`. At final build time, a "union"
+    /// state with no alternates is converted to a "fail" state, and a "union"
+    /// state with exactly one alternate is treated as if it were an "empty"
+    /// state.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_union(
+        &mut self,
+        alternates: Vec<StateID>,
+    ) -> Result<StateID, BuildError> {
+        self.add(State::Union { alternates })
+    }
+
+    /// Add a "reverse union" NFA state.
+    ///
+    /// A "reverse union" NFA state contains zero or more unconditional epsilon
+    /// transitions to other NFA states. The order of these transitions
+    /// reflects a priority order where later transitions are preferred
+    /// over earlier transitions. This is an inverted priority order when
+    /// compared to `add_union`. This is useful, for example, for implementing
+    /// non-greedy repetition operators.
+    ///
+    /// Callers may provide an empty set of alternates to this method call, and
+    /// then later add transitions via `patch`. At final build time, a "reverse
+    /// union" state with no alternates is converted to a "fail" state, and a
+    /// "reverse union" state with exactly one alternate is treated as if it
+    /// were an "empty" state.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_union_reverse(
+        &mut self,
+        alternates: Vec<StateID>,
+    ) -> Result<StateID, BuildError> {
+        self.add(State::UnionReverse { alternates })
+    }
+
+    /// Add a "range" NFA state.
+    ///
+    /// A "range" NFA state is a state with one outgoing transition to another
+    /// state, where that transition may only be followed if the current input
+    /// byte falls between a range of bytes given.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_range(
+        &mut self,
+        trans: Transition,
+    ) -> Result<StateID, BuildError> {
+        self.add(State::ByteRange { trans })
+    }
+
+    /// Add a "sparse" NFA state.
+    ///
+    /// A "sparse" NFA state contains zero or more outgoing transitions, where
+    /// the transition to be followed (if any) is chosen based on whether the
+    /// current input byte falls in the range of one such transition. The
+    /// transitions given *must* be non-overlapping and in ascending order. (A
+    /// "sparse" state with no transitions is equivalent to a "fail" state.)
+    ///
+    /// A "sparse" state is like adding a "union" state and pointing it at a
+    /// bunch of "range" states, except that the different alternates have
+    /// equal priority.
+    ///
+    /// Note that a "sparse" state is the only state that cannot be patched.
+    /// This is because a "sparse" state has many transitions, each of which
+    /// may point to a different NFA state. Moreover, adding more such
+    /// transitions requires more than just an NFA state ID to point to. It
+    /// also requires a byte range. The `patch` routine does not support the
+    /// additional information required. Therefore, callers must ensure that
+    /// all outgoing transitions for this state are included when `add_sparse`
+    /// is called. There is no way to add more later.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    ///
+    /// # Panics
+    ///
+    /// This routine _may_ panic if the transitions given overlap or are not
+    /// in ascending order.
+    pub fn add_sparse(
+        &mut self,
+        transitions: Vec<Transition>,
+    ) -> Result<StateID, BuildError> {
+        self.add(State::Sparse { transitions })
+    }
+
+    /// Add a "look" NFA state.
+    ///
+    /// A "look" NFA state corresponds to a state with exactly one
+    /// *conditional* epsilon transition to another NFA state. Namely, it
+    /// represents one of a small set of simplistic look-around operators.
+    ///
+    /// Callers may provide a "dummy" state ID (typically [`StateID::ZERO`]),
+    /// and then change it later with [`patch`](Builder::patch).
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_look(
+        &mut self,
+        next: StateID,
+        look: Look,
+    ) -> Result<StateID, BuildError> {
+        self.add(State::Look { look, next })
+    }
+
+    /// Add a "start capture" NFA state.
+    ///
+    /// A "start capture" NFA state corresponds to a state with exactly one
+    /// outgoing unconditional epsilon transition to another state. Unlike
+    /// "empty" states, a "start capture" state also carries with it an
+    /// instruction for saving the current position of input to a particular
+    /// location in memory. NFA simulations, like the Pike VM, may use this
+    /// information to report the match locations of capturing groups in a
+    /// regex pattern.
+    ///
+    /// If the corresponding capturing group has a name, then callers should
+    /// include it here.
+    ///
+    /// Callers may provide a "dummy" state ID (typically [`StateID::ZERO`]),
+    /// and then change it later with [`patch`](Builder::patch).
+    ///
+    /// Note that unlike `start_pattern`/`finish_pattern`, capturing start and
+    /// end states may be interleaved. Indeed, it is typical for many "start
+    /// capture" NFA states to appear before the first "end capture" state.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded or if the given
+    /// capture index overflows `usize`.
+    ///
+    /// While the above are the only conditions in which this routine can
+    /// currently return an error, it is possible to call this method with an
+    /// inputs that results in the final `build()` step failing to produce an
+    /// NFA. For example, if one adds two distinct capturing groups with the
+    /// same name, then that will result in `build()` failing with an error.
+    ///
+    /// See the [`GroupInfo`](crate::util::captures::GroupInfo) type for
+    /// more information on what qualifies as valid capturing groups.
+    ///
+    /// # Example
+    ///
+    /// This example shows that an error occurs when one tries to add multiple
+    /// capturing groups with the same name to the same pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::Builder,
+    ///     util::primitives::StateID,
+    /// };
+    ///
+    /// let name = Some(std::sync::Arc::from("foo"));
+    /// let mut builder = Builder::new();
+    /// builder.start_pattern()?;
+    /// // 0th capture group should always be unnamed.
+    /// let start = builder.add_capture_start(StateID::ZERO, 0, None)?;
+    /// // OK
+    /// builder.add_capture_start(StateID::ZERO, 1, name.clone())?;
+    /// // This is not OK, but 'add_capture_start' still succeeds. We don't
+    /// // get an error until we call 'build' below. Without this call, the
+    /// // call to 'build' below would succeed.
+    /// builder.add_capture_start(StateID::ZERO, 2, name.clone())?;
+    /// // Finish our pattern so we can try to build the NFA.
+    /// builder.finish_pattern(start)?;
+    /// let result = builder.build(start, start);
+    /// assert!(result.is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// However, adding multiple capturing groups with the same name to
+    /// distinct patterns is okay:
+    ///
+    /// ```
+    /// use std::sync::Arc;
+    ///
+    /// use regex_automata::{
+    ///     nfa::thompson::{pikevm::PikeVM, Builder, Transition},
+    ///     util::{
+    ///         captures::Captures,
+    ///         primitives::{PatternID, StateID},
+    ///     },
+    ///     Span,
+    /// };
+    ///
+    /// // Hand-compile the patterns '(?P<foo>[a-z])' and '(?P<foo>[A-Z])'.
+    /// let mut builder = Builder::new();
+    /// // We compile them to support an unanchored search, which requires
+    /// // adding an implicit '(?s-u:.)*?' prefix before adding either pattern.
+    /// let unanchored_prefix = builder.add_union_reverse(vec![])?;
+    /// let any = builder.add_range(Transition {
+    ///     start: b'\x00', end: b'\xFF', next: StateID::ZERO,
+    /// })?;
+    /// builder.patch(unanchored_prefix, any)?;
+    /// builder.patch(any, unanchored_prefix)?;
+    ///
+    /// // Compile an alternation that permits matching multiple patterns.
+    /// let alt = builder.add_union(vec![])?;
+    /// builder.patch(unanchored_prefix, alt)?;
+    ///
+    /// // Compile '(?P<foo>[a-z]+)'.
+    /// builder.start_pattern()?;
+    /// let start0 = builder.add_capture_start(StateID::ZERO, 0, None)?;
+    /// // N.B. 0th capture group must always be unnamed.
+    /// let foo_start0 = builder.add_capture_start(
+    ///     StateID::ZERO, 1, Some(Arc::from("foo")),
+    /// )?;
+    /// let lowercase = builder.add_range(Transition {
+    ///     start: b'a', end: b'z', next: StateID::ZERO,
+    /// })?;
+    /// let foo_end0 = builder.add_capture_end(StateID::ZERO, 1)?;
+    /// let end0 = builder.add_capture_end(StateID::ZERO, 0)?;
+    /// let match0 = builder.add_match()?;
+    /// builder.patch(start0, foo_start0)?;
+    /// builder.patch(foo_start0, lowercase)?;
+    /// builder.patch(lowercase, foo_end0)?;
+    /// builder.patch(foo_end0, end0)?;
+    /// builder.patch(end0, match0)?;
+    /// builder.finish_pattern(start0)?;
+    ///
+    /// // Compile '(?P<foo>[A-Z]+)'.
+    /// builder.start_pattern()?;
+    /// let start1 = builder.add_capture_start(StateID::ZERO, 0, None)?;
+    /// // N.B. 0th capture group must always be unnamed.
+    /// let foo_start1 = builder.add_capture_start(
+    ///     StateID::ZERO, 1, Some(Arc::from("foo")),
+    /// )?;
+    /// let uppercase = builder.add_range(Transition {
+    ///     start: b'A', end: b'Z', next: StateID::ZERO,
+    /// })?;
+    /// let foo_end1 = builder.add_capture_end(StateID::ZERO, 1)?;
+    /// let end1 = builder.add_capture_end(StateID::ZERO, 0)?;
+    /// let match1 = builder.add_match()?;
+    /// builder.patch(start1, foo_start1)?;
+    /// builder.patch(foo_start1, uppercase)?;
+    /// builder.patch(uppercase, foo_end1)?;
+    /// builder.patch(foo_end1, end1)?;
+    /// builder.patch(end1, match1)?;
+    /// builder.finish_pattern(start1)?;
+    ///
+    /// // Now add the patterns to our alternation that we started above.
+    /// builder.patch(alt, start0)?;
+    /// builder.patch(alt, start1)?;
+    ///
+    /// // Finally build the NFA. The first argument is the anchored starting
+    /// // state (the pattern alternation) where as the second is the
+    /// // unanchored starting state (the unanchored prefix).
+    /// let nfa = builder.build(alt, unanchored_prefix)?;
+    ///
+    /// // Now build a Pike VM from our NFA and access the 'foo' capture
+    /// // group regardless of which pattern matched, since it is defined
+    /// // for both patterns.
+    /// let vm = PikeVM::new_from_nfa(nfa)?;
+    /// let mut cache = vm.create_cache();
+    /// let caps: Vec<Captures> =
+    ///     vm.captures_iter(&mut cache, "0123aAaAA").collect();
+    /// assert_eq!(5, caps.len());
+    ///
+    /// assert_eq!(Some(PatternID::must(0)), caps[0].pattern());
+    /// assert_eq!(Some(Span::from(4..5)), caps[0].get_group_by_name("foo"));
+    ///
+    /// assert_eq!(Some(PatternID::must(1)), caps[1].pattern());
+    /// assert_eq!(Some(Span::from(5..6)), caps[1].get_group_by_name("foo"));
+    ///
+    /// assert_eq!(Some(PatternID::must(0)), caps[2].pattern());
+    /// assert_eq!(Some(Span::from(6..7)), caps[2].get_group_by_name("foo"));
+    ///
+    /// assert_eq!(Some(PatternID::must(1)), caps[3].pattern());
+    /// assert_eq!(Some(Span::from(7..8)), caps[3].get_group_by_name("foo"));
+    ///
+    /// assert_eq!(Some(PatternID::must(1)), caps[4].pattern());
+    /// assert_eq!(Some(Span::from(8..9)), caps[4].get_group_by_name("foo"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn add_capture_start(
+        &mut self,
+        next: StateID,
+        group_index: u32,
+        name: Option<Arc<str>>,
+    ) -> Result<StateID, BuildError> {
+        let pid = self.current_pattern_id();
+        let group_index = match SmallIndex::try_from(group_index) {
+            Err(_) => {
+                return Err(BuildError::invalid_capture_index(group_index))
+            }
+            Ok(group_index) => group_index,
+        };
+        // Make sure we have space to insert our (pid,index)|-->name mapping.
+        if pid.as_usize() >= self.captures.len() {
+            for _ in 0..=(pid.as_usize() - self.captures.len()) {
+                self.captures.push(vec![]);
+            }
+        }
+        // In the case where 'group_index < self.captures[pid].len()', it means
+        // that we are adding a duplicate capture group. This is somewhat
+        // weird, but permissible because the capture group itself can be
+        // repeated in the syntax. For example, '([a-z]){4}' will produce 4
+        // capture groups. In practice, only the last will be set at search
+        // time when a match occurs. For duplicates, we don't need to push
+        // anything other than a CaptureStart NFA state.
+        if group_index.as_usize() >= self.captures[pid].len() {
+            // For discontiguous indices, push placeholders for earlier capture
+            // groups that weren't explicitly added.
+            for _ in 0..(group_index.as_usize() - self.captures[pid].len()) {
+                self.captures[pid].push(None);
+            }
+            self.captures[pid].push(name);
+        }
+        self.add(State::CaptureStart { pattern_id: pid, group_index, next })
+    }
+
+    /// Add a "end capture" NFA state.
+    ///
+    /// A "end capture" NFA state corresponds to a state with exactly one
+    /// outgoing unconditional epsilon transition to another state. Unlike
+    /// "empty" states, a "end capture" state also carries with it an
+    /// instruction for saving the current position of input to a particular
+    /// location in memory. NFA simulations, like the Pike VM, may use this
+    /// information to report the match locations of capturing groups in a
+    ///
+    /// Callers may provide a "dummy" state ID (typically [`StateID::ZERO`]),
+    /// and then change it later with [`patch`](Builder::patch).
+    ///
+    /// Note that unlike `start_pattern`/`finish_pattern`, capturing start and
+    /// end states may be interleaved. Indeed, it is typical for many "start
+    /// capture" NFA states to appear before the first "end capture" state.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded or if the given
+    /// capture index overflows `usize`.
+    ///
+    /// While the above are the only conditions in which this routine can
+    /// currently return an error, it is possible to call this method with an
+    /// inputs that results in the final `build()` step failing to produce an
+    /// NFA. For example, if one adds two distinct capturing groups with the
+    /// same name, then that will result in `build()` failing with an error.
+    ///
+    /// See the [`GroupInfo`](crate::util::captures::GroupInfo) type for
+    /// more information on what qualifies as valid capturing groups.
+    pub fn add_capture_end(
+        &mut self,
+        next: StateID,
+        group_index: u32,
+    ) -> Result<StateID, BuildError> {
+        let pid = self.current_pattern_id();
+        let group_index = match SmallIndex::try_from(group_index) {
+            Err(_) => {
+                return Err(BuildError::invalid_capture_index(group_index))
+            }
+            Ok(group_index) => group_index,
+        };
+        self.add(State::CaptureEnd { pattern_id: pid, group_index, next })
+    }
+
+    /// Adds a "fail" NFA state.
+    ///
+    /// A "fail" state is simply a state that has no outgoing transitions. It
+    /// acts as a way to cause a search to stop without reporting a match.
+    /// For example, one way to represent an NFA with zero patterns is with a
+    /// single "fail" state.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    pub fn add_fail(&mut self) -> Result<StateID, BuildError> {
+        self.add(State::Fail)
+    }
+
+    /// Adds a "match" NFA state.
+    ///
+    /// A "match" state has no outgoing transitions (just like a "fail"
+    /// state), but it has special significance in that if a search enters
+    /// this state, then a match has been found. The match state that is added
+    /// automatically has the current pattern ID associated with it. This is
+    /// used to report the matching pattern ID at search time.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the state identifier space is exhausted, or if
+    /// the configured heap size limit has been exceeded.
+    ///
+    /// # Panics
+    ///
+    /// This must be called after a `start_pattern` call but before the
+    /// corresponding `finish_pattern` call. Otherwise, it panics.
+    pub fn add_match(&mut self) -> Result<StateID, BuildError> {
+        let pattern_id = self.current_pattern_id();
+        let sid = self.add(State::Match { pattern_id })?;
+        Ok(sid)
+    }
+
+    /// The common implementation of "add a state." It handles the common
+    /// error cases of state ID exhausting (by owning state ID allocation) and
+    /// whether the size limit has been exceeded.
+    fn add(&mut self, state: State) -> Result<StateID, BuildError> {
+        let id = StateID::new(self.states.len())
+            .map_err(|_| BuildError::too_many_states(self.states.len()))?;
+        self.memory_states += state.memory_usage();
+        self.states.push(state);
+        self.check_size_limit()?;
+        Ok(id)
+    }
+
+    /// Add a transition from one state to another.
+    ///
+    /// This routine is called "patch" since it is very common to add the
+    /// states you want, typically with "dummy" state ID transitions, and then
+    /// "patch" in the real state IDs later. This is because you don't always
+    /// know all of the necessary state IDs to add because they might not
+    /// exist yet.
+    ///
+    /// # Errors
+    ///
+    /// This may error if patching leads to an increase in heap usage beyond
+    /// the configured size limit. Heap usage only grows when patching adds a
+    /// new transition (as in the case of a "union" state).
+    ///
+    /// # Panics
+    ///
+    /// This panics if `from` corresponds to a "sparse" state. When "sparse"
+    /// states are added, there is no way to patch them after-the-fact. (If you
+    /// have a use case where this would be helpful, please file an issue. It
+    /// will likely require a new API.)
+    pub fn patch(
+        &mut self,
+        from: StateID,
+        to: StateID,
+    ) -> Result<(), BuildError> {
+        let old_memory_states = self.memory_states;
+        match self.states[from] {
+            State::Empty { ref mut next } => {
+                *next = to;
+            }
+            State::ByteRange { ref mut trans } => {
+                trans.next = to;
+            }
+            State::Sparse { .. } => {
+                panic!("cannot patch from a sparse NFA state")
+            }
+            State::Look { ref mut next, .. } => {
+                *next = to;
+            }
+            State::Union { ref mut alternates } => {
+                alternates.push(to);
+                self.memory_states += mem::size_of::<StateID>();
+            }
+            State::UnionReverse { ref mut alternates } => {
+                alternates.push(to);
+                self.memory_states += mem::size_of::<StateID>();
+            }
+            State::CaptureStart { ref mut next, .. } => {
+                *next = to;
+            }
+            State::CaptureEnd { ref mut next, .. } => {
+                *next = to;
+            }
+            State::Fail => {}
+            State::Match { .. } => {}
+        }
+        if old_memory_states != self.memory_states {
+            self.check_size_limit()?;
+        }
+        Ok(())
+    }
+
+    /// Set whether the NFA produced by this builder should only match UTF-8.
+    ///
+    /// This should be set when both of the following are true:
+    ///
+    /// 1. The caller guarantees that the NFA created by this build will only
+    /// report non-empty matches with spans that are valid UTF-8.
+    /// 2. The caller desires regex engines using this NFA to avoid reporting
+    /// empty matches with a span that splits a valid UTF-8 encoded codepoint.
+    ///
+    /// Property (1) is not checked. Instead, this requires the caller to
+    /// promise that it is true. Property (2) corresponds to the behavior of
+    /// regex engines using the NFA created by this builder. Namely, there
+    /// is no way in the NFA's graph itself to say that empty matches found
+    /// by, for example, the regex `a*` will fall on valid UTF-8 boundaries.
+    /// Instead, this option is used to communicate the UTF-8 semantic to regex
+    /// engines that will typically implement it as a post-processing step by
+    /// filtering out empty matches that don't fall on UTF-8 boundaries.
+    ///
+    /// If you're building an NFA from an HIR (and not using a
+    /// [`thompson::Compiler`](crate::nfa::thompson::Compiler)), then you can
+    /// use the [`syntax::Config::utf8`](crate::util::syntax::Config::utf8)
+    /// option to guarantee that if the HIR detects a non-empty match, then it
+    /// is guaranteed to be valid UTF-8.
+    ///
+    /// Note that property (2) does *not* specify the behavior of executing
+    /// a search on a haystack that is not valid UTF-8. Therefore, if you're
+    /// *not* running this NFA on strings that are guaranteed to be valid
+    /// UTF-8, you almost certainly do not want to enable this option.
+    /// Similarly, if you are running the NFA on strings that *are* guaranteed
+    /// to be valid UTF-8, then you almost certainly want to enable this option
+    /// unless you can guarantee that your NFA will never produce a zero-width
+    /// match.
+    ///
+    /// It is disabled by default.
+    pub fn set_utf8(&mut self, yes: bool) {
+        self.utf8 = yes;
+    }
+
+    /// Returns whether UTF-8 mode is enabled for this builder.
+    ///
+    /// See [`Builder::set_utf8`] for more details about what "UTF-8 mode" is.
+    pub fn get_utf8(&self) -> bool {
+        self.utf8
+    }
+
+    /// Sets whether the NFA produced by this builder should be matched in
+    /// reverse or not. Generally speaking, when enabled, the NFA produced
+    /// should be matched by moving backwards through a haystack, from a higher
+    /// memory address to a lower memory address.
+    ///
+    /// See also [`NFA::is_reverse`] for more details.
+    ///
+    /// This is disabled by default, which means NFAs are by default matched
+    /// in the forward direction.
+    pub fn set_reverse(&mut self, yes: bool) {
+        self.reverse = yes;
+    }
+
+    /// Returns whether reverse mode is enabled for this builder.
+    ///
+    /// See [`Builder::set_reverse`] for more details about what "reverse mode"
+    /// is.
+    pub fn get_reverse(&self) -> bool {
+        self.reverse
+    }
+
+    /// Sets the look-around matcher that should be used for the resulting NFA.
+    ///
+    /// A look-around matcher can be used to configure how look-around
+    /// assertions are matched. For example, a matcher might carry
+    /// configuration that changes the line terminator used for `(?m:^)` and
+    /// `(?m:$)` assertions.
+    pub fn set_look_matcher(&mut self, m: LookMatcher) {
+        self.look_matcher = m;
+    }
+
+    /// Returns the look-around matcher used for this builder.
+    ///
+    /// If a matcher was not explicitly set, then `LookMatcher::default()` is
+    /// returned.
+    pub fn get_look_matcher(&self) -> &LookMatcher {
+        &self.look_matcher
+    }
+
+    /// Set the size limit on this builder.
+    ///
+    /// Setting the size limit will also check whether the NFA built so far
+    /// fits within the given size limit. If it doesn't, then an error is
+    /// returned.
+    ///
+    /// By default, there is no configured size limit.
+    pub fn set_size_limit(
+        &mut self,
+        limit: Option<usize>,
+    ) -> Result<(), BuildError> {
+        self.size_limit = limit;
+        self.check_size_limit()
+    }
+
+    /// Return the currently configured size limit.
+    ///
+    /// By default, this returns `None`, which corresponds to no configured
+    /// size limit.
+    pub fn get_size_limit(&self) -> Option<usize> {
+        self.size_limit
+    }
+
+    /// Returns the heap memory usage, in bytes, used by the NFA states added
+    /// so far.
+    ///
+    /// Note that this is an approximation of how big the final NFA will be.
+    /// In practice, the final NFA will likely be a bit smaller because of
+    /// its simpler state representation. (For example, using things like
+    /// `Box<[StateID]>` instead of `Vec<StateID>`.)
+    pub fn memory_usage(&self) -> usize {
+        self.states.len() * mem::size_of::<State>() + self.memory_states
+    }
+
+    fn check_size_limit(&self) -> Result<(), BuildError> {
+        if let Some(limit) = self.size_limit {
+            if self.memory_usage() > limit {
+                return Err(BuildError::exceeded_size_limit(limit));
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // This asserts that a builder state doesn't have its size changed. It is
+    // *really* easy to accidentally increase the size, and thus potentially
+    // dramatically increase the memory usage of NFA builder.
+    //
+    // This assert doesn't mean we absolutely cannot increase the size of a
+    // builder state. We can. It's just here to make sure we do it knowingly
+    // and intentionally.
+    //
+    // A builder state is unfortunately a little bigger than an NFA state,
+    // since we really want to support adding things to a pre-existing state.
+    // i.e., We use Vec<thing> instead of Box<[thing]>. So we end up using an
+    // extra 8 bytes per state. Sad, but at least it gets freed once the NFA
+    // is built.
+    #[test]
+    fn state_has_small_size() {
+        #[cfg(target_pointer_width = "64")]
+        assert_eq!(32, core::mem::size_of::<State>());
+        #[cfg(target_pointer_width = "32")]
+        assert_eq!(16, core::mem::size_of::<State>());
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/compiler.rs b/regex-automata/src/nfa/thompson/compiler.rs
new file mode 100644
index 0000000000..f29e1e33d9
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/compiler.rs
@@ -0,0 +1,2013 @@
+use core::{borrow::Borrow, cell::RefCell};
+
+use alloc::{sync::Arc, vec, vec::Vec};
+
+use regex_syntax::{
+    hir::{self, Hir},
+    utf8::{Utf8Range, Utf8Sequences},
+    ParserBuilder,
+};
+
+use crate::{
+    nfa::thompson::{
+        builder::Builder,
+        error::BuildError,
+        literal_trie::LiteralTrie,
+        map::{Utf8BoundedMap, Utf8SuffixKey, Utf8SuffixMap},
+        nfa::{Transition, NFA},
+        range_trie::RangeTrie,
+    },
+    util::{
+        look::{Look, LookMatcher},
+        primitives::{PatternID, StateID},
+    },
+};
+
+/// The configuration used for a Thompson NFA compiler.
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    utf8: Option<bool>,
+    reverse: Option<bool>,
+    nfa_size_limit: Option<Option<usize>>,
+    shrink: Option<bool>,
+    captures: Option<bool>,
+    look_matcher: Option<LookMatcher>,
+    #[cfg(test)]
+    unanchored_prefix: Option<bool>,
+}
+
+impl Config {
+    /// Return a new default Thompson NFA compiler configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Whether to enable UTF-8 mode during search or not.
+    ///
+    /// A regex engine is said to be in UTF-8 mode when it guarantees that
+    /// all matches returned by it have spans consisting of only valid UTF-8.
+    /// That is, it is impossible for a match span to be returned that
+    /// contains any invalid UTF-8.
+    ///
+    /// UTF-8 mode generally consists of two things:
+    ///
+    /// 1. Whether the NFA's states are constructed such that all paths to a
+    /// match state that consume at least one byte always correspond to valid
+    /// UTF-8.
+    /// 2. Whether all paths to a match state that do _not_ consume any bytes
+    /// should always correspond to valid UTF-8 boundaries.
+    ///
+    /// (1) is a guarantee made by whoever constructs the NFA.
+    /// If you're parsing a regex from its concrete syntax, then
+    /// [`syntax::Config::utf8`](crate::util::syntax::Config::utf8) can make
+    /// this guarantee for you. It does it by returning an error if the regex
+    /// pattern could every report a non-empty match span that contains invalid
+    /// UTF-8. So long as `syntax::Config::utf8` mode is enabled and your regex
+    /// successfully parses, then you're guaranteed that the corresponding NFA
+    /// will only ever report non-empty match spans containing valid UTF-8.
+    ///
+    /// (2) is a trickier guarantee because it cannot be enforced by the NFA
+    /// state graph itself. Consider, for example, the regex `a*`. It matches
+    /// the empty strings in `☃` at positions `0`, `1`, `2` and `3`, where
+    /// positions `1` and `2` occur within the UTF-8 encoding of a codepoint,
+    /// and thus correspond to invalid UTF-8 boundaries. Therefore, this
+    /// guarantee must be made at a higher level than the NFA state graph
+    /// itself. This crate deals with this case in each regex engine. Namely,
+    /// when a zero-width match that splits a codepoint is found and UTF-8
+    /// mode enabled, then it is ignored and the engine moves on looking for
+    /// the next match.
+    ///
+    /// Thus, UTF-8 mode is both a promise that the NFA built only reports
+    /// non-empty matches that are valid UTF-8, and an *instruction* to regex
+    /// engines that empty matches that split codepoints should be banned.
+    ///
+    /// Because UTF-8 mode is fundamentally about avoiding invalid UTF-8 spans,
+    /// it only makes sense to enable this option when you *know* your haystack
+    /// is valid UTF-8. (For example, a `&str`.) Enabling UTF-8 mode and
+    /// searching a haystack that contains invalid UTF-8 leads to **unspecified
+    /// behavior**.
+    ///
+    /// Therefore, it may make sense to enable `syntax::Config::utf8` while
+    /// simultaneously *disabling* this option. That would ensure all non-empty
+    /// match spans are valid UTF-8, but that empty match spans may still split
+    /// a codepoint or match at other places that aren't valid UTF-8.
+    ///
+    /// In general, this mode is only relevant if your regex can match the
+    /// empty string. Most regexes don't.
+    ///
+    /// This is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows how UTF-8 mode can impact the match spans that may
+    /// be reported in certain cases.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, pikevm::PikeVM},
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = PikeVM::new("")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// // UTF-8 mode is enabled by default.
+    /// let mut input = Input::new("☃");
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..0)), caps.get_match());
+    ///
+    /// // Even though an empty regex matches at 1..1, our next match is
+    /// // 3..3 because 1..1 and 2..2 split the snowman codepoint (which is
+    /// // three bytes long).
+    /// input.set_start(1);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 3..3)), caps.get_match());
+    ///
+    /// // But if we disable UTF-8, then we'll get matches at 1..1 and 2..2:
+    /// let re = PikeVM::builder()
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build("")?;
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 1..1)), caps.get_match());
+    ///
+    /// input.set_start(2);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 2..2)), caps.get_match());
+    ///
+    /// input.set_start(3);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 3..3)), caps.get_match());
+    ///
+    /// input.set_start(4);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn utf8(mut self, yes: bool) -> Config {
+        self.utf8 = Some(yes);
+        self
+    }
+
+    /// Reverse the NFA.
+    ///
+    /// A NFA reversal is performed by reversing all of the concatenated
+    /// sub-expressions in the original pattern, recursively. (Look around
+    /// operators are also inverted.) The resulting NFA can be used to match
+    /// the pattern starting from the end of a string instead of the beginning
+    /// of a string.
+    ///
+    /// Reversing the NFA is useful for building a reverse DFA, which is most
+    /// useful for finding the start of a match after its ending position has
+    /// been found. NFA execution engines typically do not work on reverse
+    /// NFAs. For example, currently, the Pike VM reports the starting location
+    /// of matches without a reverse NFA.
+    ///
+    /// Currently, enabling this setting requires disabling the
+    /// [`captures`](Config::captures) setting. If both are enabled, then the
+    /// compiler will return an error. It is expected that this limitation will
+    /// be lifted in the future.
+    ///
+    /// This is disabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a DFA from a reverse NFA, and then use
+    /// the DFA to search backwards.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     dfa::{self, Automaton},
+    ///     nfa::thompson::NFA,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let dfa = dfa::dense::Builder::new()
+    ///     .thompson(NFA::config().captures(false).reverse(true))
+    ///     .build("baz[0-9]+")?;
+    /// let expected = Some(HalfMatch::must(0, 3));
+    /// assert_eq!(
+    ///     expected,
+    ///     dfa.try_search_rev(&Input::new("foobaz12345bar"))?,
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reverse(mut self, yes: bool) -> Config {
+        self.reverse = Some(yes);
+        self
+    }
+
+    /// Sets an approximate size limit on the total heap used by the NFA being
+    /// compiled.
+    ///
+    /// This permits imposing constraints on the size of a compiled NFA. This
+    /// may be useful in contexts where the regex pattern is untrusted and one
+    /// wants to avoid using too much memory.
+    ///
+    /// This size limit does not apply to auxiliary heap used during
+    /// compilation that is not part of the built NFA.
+    ///
+    /// Note that this size limit is applied during compilation in order for
+    /// the limit to prevent too much heap from being used. However, the
+    /// implementation may use an intermediate NFA representation that is
+    /// otherwise slightly bigger than the final public form. Since the size
+    /// limit may be applied to an intermediate representation, there is not
+    /// necessarily a precise correspondence between the configured size limit
+    /// and the heap usage of the final NFA.
+    ///
+    /// There is no size limit by default.
+    ///
+    /// # Example
+    ///
+    /// This example demonstrates how Unicode mode can greatly increase the
+    /// size of the NFA.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// // 300KB isn't enough!
+    /// NFA::compiler()
+    ///     .configure(NFA::config().nfa_size_limit(Some(300_000)))
+    ///     .build(r"\w{20}")
+    ///     .unwrap_err();
+    ///
+    /// // ... but 400KB probably is.
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().nfa_size_limit(Some(400_000)))
+    ///     .build(r"\w{20}")?;
+    ///
+    /// assert_eq!(nfa.pattern_len(), 1);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn nfa_size_limit(mut self, bytes: Option<usize>) -> Config {
+        self.nfa_size_limit = Some(bytes);
+        self
+    }
+
+    /// Apply best effort heuristics to shrink the NFA at the expense of more
+    /// time/memory.
+    ///
+    /// Generally speaking, if one is using an NFA to compile a DFA, then the
+    /// extra time used to shrink the NFA will be more than made up for during
+    /// DFA construction (potentially by a lot). In other words, enabling this
+    /// can substantially decrease the overall amount of time it takes to build
+    /// a DFA.
+    ///
+    /// A reason to keep this disabled is if you want to compile an NFA and
+    /// start using it as quickly as possible without needing to build a DFA,
+    /// and you don't mind using a bit of extra memory for the NFA. e.g., for
+    /// an NFA simulation or for a lazy DFA.
+    ///
+    /// NFA shrinking is currently most useful when compiling a reverse
+    /// NFA with large Unicode character classes. In particular, it trades
+    /// additional CPU time during NFA compilation in favor of generating fewer
+    /// NFA states.
+    ///
+    /// This is disabled by default because it can increase compile times
+    /// quite a bit if you aren't building a full DFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows that NFA shrinking can lead to substantial space
+    /// savings in some cases. Notice that, as noted above, we build a reverse
+    /// DFA and use a pattern with a large Unicode character class.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// // Currently we have to disable captures when enabling reverse NFA.
+    /// let config = NFA::config().captures(false).reverse(true);
+    /// let not_shrunk = NFA::compiler()
+    ///     .configure(config.clone().shrink(false))
+    ///     .build(r"\w")?;
+    /// let shrunk = NFA::compiler()
+    ///     .configure(config.clone().shrink(true))
+    ///     .build(r"\w")?;
+    ///
+    /// // While a specific shrink factor is not guaranteed, the savings can be
+    /// // considerable in some cases.
+    /// assert!(shrunk.states().len() * 2 < not_shrunk.states().len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn shrink(mut self, yes: bool) -> Config {
+        self.shrink = Some(yes);
+        self
+    }
+
+    /// Whether to include 'Capture' states in the NFA.
+    ///
+    /// Currently, enabling this setting requires disabling the
+    /// [`reverse`](Config::reverse) setting. If both are enabled, then the
+    /// compiler will return an error. It is expected that this limitation will
+    /// be lifted in the future.
+    ///
+    /// This is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example demonstrates that some regex engines, like the Pike VM,
+    /// require capturing groups to be present in the NFA. Building a Pike VM
+    /// with an NFA without capturing groups will result in an error.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::{pikevm::PikeVM, NFA};
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build(r"[a-z]+")?;
+    /// assert!(PikeVM::new_from_nfa(nfa).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn captures(mut self, yes: bool) -> Config {
+        self.captures = Some(yes);
+        self
+    }
+
+    /// Sets the look-around matcher that should be used with this NFA.
+    ///
+    /// A look-around matcher determines how to match look-around assertions.
+    /// In particular, some assertions are configurable. For example, the
+    /// `(?m:^)` and `(?m:$)` assertions can have their line terminator changed
+    /// from the default of `\n` to any other byte.
+    ///
+    /// # Example
+    ///
+    /// This shows how to change the line terminator for multi-line assertions.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, pikevm::PikeVM},
+    ///     util::look::LookMatcher,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let mut lookm = LookMatcher::new();
+    /// lookm.set_line_terminator(b'\x00');
+    ///
+    /// let re = PikeVM::builder()
+    ///     .thompson(thompson::Config::new().look_matcher(lookm))
+    ///     .build(r"(?m)^[a-z]+$")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// // Multi-line assertions now use NUL as a terminator.
+    /// assert_eq!(
+    ///     Some(Match::must(0, 1..4)),
+    ///     re.find(&mut cache, b"\x00abc\x00"),
+    /// );
+    /// // ... and \n is no longer recognized as a terminator.
+    /// assert_eq!(
+    ///     None,
+    ///     re.find(&mut cache, b"\nabc\n"),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn look_matcher(mut self, m: LookMatcher) -> Config {
+        self.look_matcher = Some(m);
+        self
+    }
+
+    /// Whether to compile an unanchored prefix into this NFA.
+    ///
+    /// This is enabled by default. It is made available for tests only to make
+    /// it easier to unit test the output of the compiler.
+    #[cfg(test)]
+    fn unanchored_prefix(mut self, yes: bool) -> Config {
+        self.unanchored_prefix = Some(yes);
+        self
+    }
+
+    /// Returns whether this configuration has enabled UTF-8 mode.
+    pub fn get_utf8(&self) -> bool {
+        self.utf8.unwrap_or(true)
+    }
+
+    /// Returns whether this configuration has enabled reverse NFA compilation.
+    pub fn get_reverse(&self) -> bool {
+        self.reverse.unwrap_or(false)
+    }
+
+    /// Return the configured NFA size limit, if it exists, in the number of
+    /// bytes of heap used.
+    pub fn get_nfa_size_limit(&self) -> Option<usize> {
+        self.nfa_size_limit.unwrap_or(None)
+    }
+
+    /// Return whether NFA shrinking is enabled.
+    pub fn get_shrink(&self) -> bool {
+        self.shrink.unwrap_or(false)
+    }
+
+    /// Return whether NFA compilation is configured to produce capture states.
+    pub fn get_captures(&self) -> bool {
+        self.captures.unwrap_or(true)
+    }
+
+    /// Return the look-around matcher for this NFA.
+    pub fn get_look_matcher(&self) -> LookMatcher {
+        self.look_matcher.clone().unwrap_or(LookMatcher::default())
+    }
+
+    /// Return whether NFA compilation is configured to include an unanchored
+    /// prefix.
+    ///
+    /// This is always false when not in test mode.
+    fn get_unanchored_prefix(&self) -> bool {
+        #[cfg(test)]
+        {
+            self.unanchored_prefix.unwrap_or(true)
+        }
+        #[cfg(not(test))]
+        {
+            true
+        }
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            utf8: o.utf8.or(self.utf8),
+            reverse: o.reverse.or(self.reverse),
+            nfa_size_limit: o.nfa_size_limit.or(self.nfa_size_limit),
+            shrink: o.shrink.or(self.shrink),
+            captures: o.captures.or(self.captures),
+            look_matcher: o.look_matcher.or_else(|| self.look_matcher.clone()),
+            #[cfg(test)]
+            unanchored_prefix: o.unanchored_prefix.or(self.unanchored_prefix),
+        }
+    }
+}
+
+/*
+This compiler below uses Thompson's construction algorithm. The compiler takes
+a regex-syntax::Hir as input and emits an NFA graph as output. The NFA graph
+is structured in a way that permits it to be executed by a virtual machine and
+also used to efficiently build a DFA.
+
+The compiler deals with a slightly expanded set of NFA states than what is
+in a final NFA (as exhibited by builder::State and nfa::State). Notably a
+compiler state includes an empty node that has exactly one unconditional
+epsilon transition to the next state. In other words, it's a "goto" instruction
+if one views Thompson's NFA as a set of bytecode instructions. These goto
+instructions are removed in a subsequent phase before returning the NFA to the
+caller. The purpose of these empty nodes is that they make the construction
+algorithm substantially simpler to implement. We remove them before returning
+to the caller because they can represent substantial overhead when traversing
+the NFA graph (either while searching using the NFA directly or while building
+a DFA).
+
+In the future, it would be nice to provide a Glushkov compiler as well, as it
+would work well as a bit-parallel NFA for smaller regexes. But the Thompson
+construction is one I'm more familiar with and seems more straight-forward to
+deal with when it comes to large Unicode character classes.
+
+Internally, the compiler uses interior mutability to improve composition in the
+face of the borrow checker. In particular, we'd really like to be able to write
+things like this:
+
+    self.c_concat(exprs.iter().map(|e| self.c(e)))
+
+Which elegantly uses iterators to build up a sequence of compiled regex
+sub-expressions and then hands it off to the concatenating compiler routine.
+Without interior mutability, the borrow checker won't let us borrow `self`
+mutably both inside and outside the closure at the same time.
+*/
+
+/// A builder for compiling an NFA from a regex's high-level intermediate
+/// representation (HIR).
+///
+/// This compiler provides a way to translate a parsed regex pattern into an
+/// NFA state graph. The NFA state graph can either be used directly to execute
+/// a search (e.g., with a Pike VM), or it can be further used to build a DFA.
+///
+/// This compiler provides APIs both for compiling regex patterns directly from
+/// their concrete syntax, or via a [`regex_syntax::hir::Hir`].
+///
+/// This compiler has various options that may be configured via
+/// [`thompson::Config`](Config).
+///
+/// Note that a compiler is not the same as a [`thompson::Builder`](Builder).
+/// A `Builder` provides a lower level API that is uncoupled from a regex
+/// pattern's concrete syntax or even its HIR. Instead, it permits stitching
+/// together an NFA by hand. See its docs for examples.
+///
+/// # Example: compilation from concrete syntax
+///
+/// This shows how to compile an NFA from a pattern string while setting a size
+/// limit on how big the NFA is allowed to be (in terms of bytes of heap used).
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::{NFA, pikevm::PikeVM},
+///     Match,
+/// };
+///
+/// let config = NFA::config().nfa_size_limit(Some(1_000));
+/// let nfa = NFA::compiler().configure(config).build(r"(?-u)\w")?;
+///
+/// let re = PikeVM::new_from_nfa(nfa)?;
+/// let mut cache = re.create_cache();
+/// let mut caps = re.create_captures();
+/// let expected = Some(Match::must(0, 3..4));
+/// re.captures(&mut cache, "!@#A#@!", &mut caps);
+/// assert_eq!(expected, caps.get_match());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: compilation from HIR
+///
+/// This shows how to hand assemble a regular expression via its HIR, and then
+/// compile an NFA directly from it.
+///
+/// ```
+/// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+/// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+///
+/// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![
+///     ClassBytesRange::new(b'0', b'9'),
+///     ClassBytesRange::new(b'A', b'Z'),
+///     ClassBytesRange::new(b'_', b'_'),
+///     ClassBytesRange::new(b'a', b'z'),
+/// ])));
+///
+/// let config = NFA::config().nfa_size_limit(Some(1_000));
+/// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;
+///
+/// let re = PikeVM::new_from_nfa(nfa)?;
+/// let mut cache = re.create_cache();
+/// let mut caps = re.create_captures();
+/// let expected = Some(Match::must(0, 3..4));
+/// re.captures(&mut cache, "!@#A#@!", &mut caps);
+/// assert_eq!(expected, caps.get_match());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Compiler {
+    /// A regex parser, used when compiling an NFA directly from a pattern
+    /// string.
+    parser: ParserBuilder,
+    /// The compiler configuration.
+    config: Config,
+    /// The builder for actually constructing an NFA. This provides a
+    /// convenient abstraction for writing a compiler.
+    builder: RefCell<Builder>,
+    /// State used for compiling character classes to UTF-8 byte automata.
+    /// State is not retained between character class compilations. This just
+    /// serves to amortize allocation to the extent possible.
+    utf8_state: RefCell<Utf8State>,
+    /// State used for arranging character classes in reverse into a trie.
+    trie_state: RefCell<RangeTrie>,
+    /// State used for caching common suffixes when compiling reverse UTF-8
+    /// automata (for Unicode character classes).
+    utf8_suffix: RefCell<Utf8SuffixMap>,
+}
+
+impl Compiler {
+    /// Create a new NFA builder with its default configuration.
+    pub fn new() -> Compiler {
+        Compiler {
+            parser: ParserBuilder::new(),
+            config: Config::default(),
+            builder: RefCell::new(Builder::new()),
+            utf8_state: RefCell::new(Utf8State::new()),
+            trie_state: RefCell::new(RangeTrie::new()),
+            utf8_suffix: RefCell::new(Utf8SuffixMap::new(1000)),
+        }
+    }
+
+    /// Compile the given regular expression pattern into an NFA.
+    ///
+    /// If there was a problem parsing the regex, then that error is returned.
+    ///
+    /// Otherwise, if there was a problem building the NFA, then an error is
+    /// returned. The only error that can occur is if the compiled regex would
+    /// exceed the size limits configured on this builder, or if any part of
+    /// the NFA would exceed the integer representations used. (For example,
+    /// too many states might plausibly occur on a 16-bit target.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build(r"(?-u)\w")?;
+    ///
+    /// let re = PikeVM::new_from_nfa(nfa)?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    /// let expected = Some(Match::must(0, 3..4));
+    /// re.captures(&mut cache, "!@#A#@!", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build(&self, pattern: &str) -> Result<NFA, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Compile the given regular expression patterns into a single NFA.
+    ///
+    /// When matches are returned, the pattern ID corresponds to the index of
+    /// the pattern in the slice given.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_many(&[
+    ///     r"(?-u)\s",
+    ///     r"(?-u)\w",
+    /// ])?;
+    ///
+    /// let re = PikeVM::new_from_nfa(nfa)?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    /// let expected = Some(Match::must(1, 1..2));
+    /// re.captures(&mut cache, "!A! !A!", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<NFA, BuildError> {
+        let mut hirs = vec![];
+        for p in patterns {
+            hirs.push(
+                self.parser
+                    .build()
+                    .parse(p.as_ref())
+                    .map_err(BuildError::syntax)?,
+            );
+            debug!("parsed: {:?}", p.as_ref());
+        }
+        self.build_many_from_hir(&hirs)
+    }
+
+    /// Compile the given high level intermediate representation of a regular
+    /// expression into an NFA.
+    ///
+    /// If there was a problem building the NFA, then an error is returned. The
+    /// only error that can occur is if the compiled regex would exceed the
+    /// size limits configured on this builder, or if any part of the NFA would
+    /// exceed the integer representations used. (For example, too many states
+    /// might plausibly occur on a 16-bit target.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    /// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+    ///
+    /// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///     ClassBytesRange::new(b'0', b'9'),
+    ///     ClassBytesRange::new(b'A', b'Z'),
+    ///     ClassBytesRange::new(b'_', b'_'),
+    ///     ClassBytesRange::new(b'a', b'z'),
+    /// ])));
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;
+    ///
+    /// let re = PikeVM::new_from_nfa(nfa)?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    /// let expected = Some(Match::must(0, 3..4));
+    /// re.captures(&mut cache, "!@#A#@!", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_from_hir(&self, expr: &Hir) -> Result<NFA, BuildError> {
+        self.build_many_from_hir(&[expr])
+    }
+
+    /// Compile the given high level intermediate representations of regular
+    /// expressions into a single NFA.
+    ///
+    /// When matches are returned, the pattern ID corresponds to the index of
+    /// the pattern in the slice given.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    /// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+    ///
+    /// let hirs = &[
+    ///     Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///         ClassBytesRange::new(b'\t', b'\r'),
+    ///         ClassBytesRange::new(b' ', b' '),
+    ///     ]))),
+    ///     Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///         ClassBytesRange::new(b'0', b'9'),
+    ///         ClassBytesRange::new(b'A', b'Z'),
+    ///         ClassBytesRange::new(b'_', b'_'),
+    ///         ClassBytesRange::new(b'a', b'z'),
+    ///     ]))),
+    /// ];
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_many_from_hir(hirs)?;
+    ///
+    /// let re = PikeVM::new_from_nfa(nfa)?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    /// let expected = Some(Match::must(1, 1..2));
+    /// re.captures(&mut cache, "!A! !A!", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn build_many_from_hir<H: Borrow<Hir>>(
+        &self,
+        exprs: &[H],
+    ) -> Result<NFA, BuildError> {
+        self.compile(exprs)
+    }
+
+    /// Apply the given NFA configuration options to this builder.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build(r"(?-u)\w")?;
+    /// assert_eq!(nfa.pattern_len(), 1);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn configure(&mut self, config: Config) -> &mut Compiler {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// This syntax configuration only applies when an NFA is built directly
+    /// from a pattern string. If an NFA is built from an HIR, then all syntax
+    /// settings are ignored.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::syntax};
+    ///
+    /// let syntax_config = syntax::Config::new().unicode(false);
+    /// let nfa = NFA::compiler().syntax(syntax_config).build(r"\w")?;
+    /// // If Unicode were enabled, the number of states would be much bigger.
+    /// assert!(nfa.states().len() < 15);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Compiler {
+        config.apply(&mut self.parser);
+        self
+    }
+}
+
+impl Compiler {
+    /// Compile the sequence of HIR expressions given. Pattern IDs are
+    /// allocated starting from 0, in correspondence with the slice given.
+    ///
+    /// It is legal to provide an empty slice. In that case, the NFA returned
+    /// has no patterns and will never match anything.
+    fn compile<H: Borrow<Hir>>(&self, exprs: &[H]) -> Result<NFA, BuildError> {
+        if exprs.len() > PatternID::LIMIT {
+            return Err(BuildError::too_many_patterns(exprs.len()));
+        }
+        if self.config.get_reverse() && self.config.get_captures() {
+            return Err(BuildError::unsupported_captures());
+        }
+
+        self.builder.borrow_mut().clear();
+        self.builder.borrow_mut().set_utf8(self.config.get_utf8());
+        self.builder.borrow_mut().set_reverse(self.config.get_reverse());
+        self.builder
+            .borrow_mut()
+            .set_look_matcher(self.config.get_look_matcher());
+        self.builder
+            .borrow_mut()
+            .set_size_limit(self.config.get_nfa_size_limit())?;
+
+        // We always add an unanchored prefix unless we were specifically told
+        // not to (for tests only), or if we know that the regex is anchored
+        // for all matches. When an unanchored prefix is not added, then the
+        // NFA's anchored and unanchored start states are equivalent.
+        let all_anchored = exprs.iter().all(|e| {
+            e.borrow()
+                .properties()
+                .look_set_prefix()
+                .contains(hir::Look::Start)
+        });
+        let anchored = !self.config.get_unanchored_prefix() || all_anchored;
+        let unanchored_prefix = if anchored {
+            self.c_empty()?
+        } else {
+            self.c_at_least(&Hir::dot(hir::Dot::AnyByte), false, 0)?
+        };
+
+        let compiled = self.c_alt_iter(exprs.iter().map(|e| {
+            let _ = self.start_pattern()?;
+            let one = self.c_cap(0, None, e.borrow())?;
+            let match_state_id = self.add_match()?;
+            self.patch(one.end, match_state_id)?;
+            let _ = self.finish_pattern(one.start)?;
+            Ok(ThompsonRef { start: one.start, end: match_state_id })
+        }))?;
+        self.patch(unanchored_prefix.end, compiled.start)?;
+        let nfa = self
+            .builder
+            .borrow_mut()
+            .build(compiled.start, unanchored_prefix.start)?;
+
+        debug!("HIR-to-NFA compilation complete, config: {:?}", self.config);
+        Ok(nfa)
+    }
+
+    /// Compile an arbitrary HIR expression.
+    fn c(&self, expr: &Hir) -> Result<ThompsonRef, BuildError> {
+        use regex_syntax::hir::{Class, HirKind::*};
+
+        match *expr.kind() {
+            Empty => self.c_empty(),
+            Literal(hir::Literal(ref bytes)) => self.c_literal(bytes),
+            Class(Class::Bytes(ref c)) => self.c_byte_class(c),
+            Class(Class::Unicode(ref c)) => self.c_unicode_class(c),
+            Look(ref look) => self.c_look(look),
+            Repetition(ref rep) => self.c_repetition(rep),
+            Capture(ref c) => self.c_cap(c.index, c.name.as_deref(), &c.sub),
+            Concat(ref es) => self.c_concat(es.iter().map(|e| self.c(e))),
+            Alternation(ref es) => self.c_alt_slice(es),
+        }
+    }
+
+    /// Compile a concatenation of the sub-expressions yielded by the given
+    /// iterator. If the iterator yields no elements, then this compiles down
+    /// to an "empty" state that always matches.
+    ///
+    /// If the compiler is in reverse mode, then the expressions given are
+    /// automatically compiled in reverse.
+    fn c_concat<I>(&self, mut it: I) -> Result<ThompsonRef, BuildError>
+    where
+        I: DoubleEndedIterator<Item = Result<ThompsonRef, BuildError>>,
+    {
+        let first = if self.is_reverse() { it.next_back() } else { it.next() };
+        let ThompsonRef { start, mut end } = match first {
+            Some(result) => result?,
+            None => return self.c_empty(),
+        };
+        loop {
+            let next =
+                if self.is_reverse() { it.next_back() } else { it.next() };
+            let compiled = match next {
+                Some(result) => result?,
+                None => break,
+            };
+            self.patch(end, compiled.start)?;
+            end = compiled.end;
+        }
+        Ok(ThompsonRef { start, end })
+    }
+
+    /// Compile an alternation of the given HIR values.
+    ///
+    /// This is like 'c_alt_iter', but it accepts a slice of HIR values instead
+    /// of an iterator of compiled NFA subgraphs. The point of accepting a
+    /// slice here is that it opens up some optimization opportunities. For
+    /// example, if all of the HIR values are literals, then this routine might
+    /// re-shuffle them to make NFA epsilon closures substantially faster.
+    fn c_alt_slice(&self, exprs: &[Hir]) -> Result<ThompsonRef, BuildError> {
+        // self.c_alt_iter(exprs.iter().map(|e| self.c(e)))
+        let literal_count = exprs
+            .iter()
+            .filter(|e| {
+                matches!(*e.kind(), hir::HirKind::Literal(hir::Literal(_)))
+            })
+            .count();
+        if literal_count <= 1 || literal_count < exprs.len() {
+            return self.c_alt_iter(exprs.iter().map(|e| self.c(e)));
+        }
+
+        let mut trie = if self.is_reverse() {
+            LiteralTrie::reverse()
+        } else {
+            LiteralTrie::forward()
+        };
+        for expr in exprs.iter() {
+            let literal = match *expr.kind() {
+                hir::HirKind::Literal(hir::Literal(ref bytes)) => bytes,
+                _ => unreachable!(),
+            };
+            trie.add(literal)?;
+        }
+        trie.compile(&mut self.builder.borrow_mut())
+    }
+
+    /// Compile an alternation, where each element yielded by the given
+    /// iterator represents an item in the alternation. If the iterator yields
+    /// no elements, then this compiles down to a "fail" state.
+    ///
+    /// In an alternation, expressions appearing earlier are "preferred" at
+    /// match time over expressions appearing later. At least, this is true
+    /// when using "leftmost first" match semantics. (If "leftmost longest" are
+    /// ever added in the future, then this preference order of priority would
+    /// not apply in that mode.)
+    fn c_alt_iter<I>(&self, mut it: I) -> Result<ThompsonRef, BuildError>
+    where
+        I: Iterator<Item = Result<ThompsonRef, BuildError>>,
+    {
+        let first = match it.next() {
+            None => return self.c_fail(),
+            Some(result) => result?,
+        };
+        let second = match it.next() {
+            None => return Ok(first),
+            Some(result) => result?,
+        };
+
+        let union = self.add_union()?;
+        let end = self.add_empty()?;
+        self.patch(union, first.start)?;
+        self.patch(first.end, end)?;
+        self.patch(union, second.start)?;
+        self.patch(second.end, end)?;
+        for result in it {
+            let compiled = result?;
+            self.patch(union, compiled.start)?;
+            self.patch(compiled.end, end)?;
+        }
+        Ok(ThompsonRef { start: union, end })
+    }
+
+    /// Compile the given capture sub-expression. `expr` should be the
+    /// sub-expression contained inside the capture. If "capture" states are
+    /// enabled, then they are added as appropriate.
+    ///
+    /// This accepts the pieces of a capture instead of a `hir::Capture` so
+    /// that it's easy to manufacture a "fake" group when necessary, e.g., for
+    /// adding the entire pattern as if it were a group in order to create
+    /// appropriate "capture" states in the NFA.
+    fn c_cap(
+        &self,
+        index: u32,
+        name: Option<&str>,
+        expr: &Hir,
+    ) -> Result<ThompsonRef, BuildError> {
+        if !self.config.get_captures() {
+            return self.c(expr);
+        }
+
+        let start = self.add_capture_start(index, name)?;
+        let inner = self.c(expr)?;
+        let end = self.add_capture_end(index)?;
+        self.patch(start, inner.start)?;
+        self.patch(inner.end, end)?;
+        Ok(ThompsonRef { start, end })
+    }
+
+    /// Compile the given repetition expression. This handles all types of
+    /// repetitions and greediness.
+    fn c_repetition(
+        &self,
+        rep: &hir::Repetition,
+    ) -> Result<ThompsonRef, BuildError> {
+        match (rep.min, rep.max) {
+            (0, Some(1)) => self.c_zero_or_one(&rep.sub, rep.greedy),
+            (min, None) => self.c_at_least(&rep.sub, rep.greedy, min),
+            (min, Some(max)) if min == max => self.c_exactly(&rep.sub, min),
+            (min, Some(max)) => self.c_bounded(&rep.sub, rep.greedy, min, max),
+        }
+    }
+
+    /// Compile the given expression such that it matches at least `min` times,
+    /// but no more than `max` times.
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_bounded(
+        &self,
+        expr: &Hir,
+        greedy: bool,
+        min: u32,
+        max: u32,
+    ) -> Result<ThompsonRef, BuildError> {
+        let prefix = self.c_exactly(expr, min)?;
+        if min == max {
+            return Ok(prefix);
+        }
+
+        // It is tempting here to compile the rest here as a concatenation
+        // of zero-or-one matches. i.e., for `a{2,5}`, compile it as if it
+        // were `aaa?a?a?`. The problem here is that it leads to this program:
+        //
+        //     >000000: 61 => 01
+        //      000001: 61 => 02
+        //      000002: union(03, 04)
+        //      000003: 61 => 04
+        //      000004: union(05, 06)
+        //      000005: 61 => 06
+        //      000006: union(07, 08)
+        //      000007: 61 => 08
+        //      000008: MATCH
+        //
+        // And effectively, once you hit state 2, the epsilon closure will
+        // include states 3, 5, 6, 7 and 8, which is quite a bit. It is better
+        // to instead compile it like so:
+        //
+        //     >000000: 61 => 01
+        //      000001: 61 => 02
+        //      000002: union(03, 08)
+        //      000003: 61 => 04
+        //      000004: union(05, 08)
+        //      000005: 61 => 06
+        //      000006: union(07, 08)
+        //      000007: 61 => 08
+        //      000008: MATCH
+        //
+        // So that the epsilon closure of state 2 is now just 3 and 8.
+        let empty = self.add_empty()?;
+        let mut prev_end = prefix.end;
+        for _ in min..max {
+            let union = if greedy {
+                self.add_union()
+            } else {
+                self.add_union_reverse()
+            }?;
+            let compiled = self.c(expr)?;
+            self.patch(prev_end, union)?;
+            self.patch(union, compiled.start)?;
+            self.patch(union, empty)?;
+            prev_end = compiled.end;
+        }
+        self.patch(prev_end, empty)?;
+        Ok(ThompsonRef { start: prefix.start, end: empty })
+    }
+
+    /// Compile the given expression such that it may be matched `n` or more
+    /// times, where `n` can be any integer. (Although a particularly large
+    /// integer is likely to run afoul of any configured size limits.)
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_at_least(
+        &self,
+        expr: &Hir,
+        greedy: bool,
+        n: u32,
+    ) -> Result<ThompsonRef, BuildError> {
+        if n == 0 {
+            // When the expression cannot match the empty string, then we
+            // can get away with something much simpler: just one 'alt'
+            // instruction that optionally repeats itself. But if the expr
+            // can match the empty string... see below.
+            if expr.properties().minimum_len().map_or(false, |len| len > 0) {
+                let union = if greedy {
+                    self.add_union()
+                } else {
+                    self.add_union_reverse()
+                }?;
+                let compiled = self.c(expr)?;
+                self.patch(union, compiled.start)?;
+                self.patch(compiled.end, union)?;
+                return Ok(ThompsonRef { start: union, end: union });
+            }
+
+            // What's going on here? Shouldn't x* be simpler than this? It
+            // turns out that when implementing leftmost-first (Perl-like)
+            // match semantics, x* results in an incorrect preference order
+            // when computing the transitive closure of states if and only if
+            // 'x' can match the empty string. So instead, we compile x* as
+            // (x+)?, which preserves the correct preference order.
+            //
+            // See: https://github.com/rust-lang/regex/issues/779
+            let compiled = self.c(expr)?;
+            let plus = if greedy {
+                self.add_union()
+            } else {
+                self.add_union_reverse()
+            }?;
+            self.patch(compiled.end, plus)?;
+            self.patch(plus, compiled.start)?;
+
+            let question = if greedy {
+                self.add_union()
+            } else {
+                self.add_union_reverse()
+            }?;
+            let empty = self.add_empty()?;
+            self.patch(question, compiled.start)?;
+            self.patch(question, empty)?;
+            self.patch(plus, empty)?;
+            Ok(ThompsonRef { start: question, end: empty })
+        } else if n == 1 {
+            let compiled = self.c(expr)?;
+            let union = if greedy {
+                self.add_union()
+            } else {
+                self.add_union_reverse()
+            }?;
+            self.patch(compiled.end, union)?;
+            self.patch(union, compiled.start)?;
+            Ok(ThompsonRef { start: compiled.start, end: union })
+        } else {
+            let prefix = self.c_exactly(expr, n - 1)?;
+            let last = self.c(expr)?;
+            let union = if greedy {
+                self.add_union()
+            } else {
+                self.add_union_reverse()
+            }?;
+            self.patch(prefix.end, last.start)?;
+            self.patch(last.end, union)?;
+            self.patch(union, last.start)?;
+            Ok(ThompsonRef { start: prefix.start, end: union })
+        }
+    }
+
+    /// Compile the given expression such that it may be matched zero or one
+    /// times.
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_zero_or_one(
+        &self,
+        expr: &Hir,
+        greedy: bool,
+    ) -> Result<ThompsonRef, BuildError> {
+        let union =
+            if greedy { self.add_union() } else { self.add_union_reverse() }?;
+        let compiled = self.c(expr)?;
+        let empty = self.add_empty()?;
+        self.patch(union, compiled.start)?;
+        self.patch(union, empty)?;
+        self.patch(compiled.end, empty)?;
+        Ok(ThompsonRef { start: union, end: empty })
+    }
+
+    /// Compile the given HIR expression exactly `n` times.
+    fn c_exactly(
+        &self,
+        expr: &Hir,
+        n: u32,
+    ) -> Result<ThompsonRef, BuildError> {
+        let it = (0..n).map(|_| self.c(expr));
+        self.c_concat(it)
+    }
+
+    /// Compile the given byte oriented character class.
+    ///
+    /// This uses "sparse" states to represent an alternation between ranges in
+    /// this character class. We can use "sparse" states instead of stitching
+    /// together a "union" state because all ranges in a character class have
+    /// equal priority *and* are non-overlapping (thus, only one can match, so
+    /// there's never a question of priority in the first place). This saves a
+    /// fair bit of overhead when traversing an NFA.
+    ///
+    /// This routine compiles an empty character class into a "fail" state.
+    fn c_byte_class(
+        &self,
+        cls: &hir::ClassBytes,
+    ) -> Result<ThompsonRef, BuildError> {
+        let end = self.add_empty()?;
+        let mut trans = Vec::with_capacity(cls.ranges().len());
+        for r in cls.iter() {
+            trans.push(Transition {
+                start: r.start(),
+                end: r.end(),
+                next: end,
+            });
+        }
+        Ok(ThompsonRef { start: self.add_sparse(trans)?, end })
+    }
+
+    /// Compile the given Unicode character class.
+    ///
+    /// This routine specifically tries to use various types of compression,
+    /// since UTF-8 automata of large classes can get quite large. The specific
+    /// type of compression used depends on forward vs reverse compilation, and
+    /// whether NFA shrinking is enabled or not.
+    ///
+    /// Aside from repetitions causing lots of repeat group, this is like the
+    /// single most expensive part of regex compilation. Therefore, a large part
+    /// of the expense of compilation may be reduce by disabling Unicode in the
+    /// pattern.
+    ///
+    /// This routine compiles an empty character class into a "fail" state.
+    fn c_unicode_class(
+        &self,
+        cls: &hir::ClassUnicode,
+    ) -> Result<ThompsonRef, BuildError> {
+        // If all we have are ASCII ranges wrapped in a Unicode package, then
+        // there is zero reason to bring out the big guns. We can fit all ASCII
+        // ranges within a single sparse state.
+        if cls.is_ascii() {
+            let end = self.add_empty()?;
+            let mut trans = Vec::with_capacity(cls.ranges().len());
+            for r in cls.iter() {
+                // The unwraps below are OK because we've verified that this
+                // class only contains ASCII codepoints.
+                trans.push(Transition {
+                    // FIXME(1.59): use the 'TryFrom<char> for u8' impl.
+                    start: u8::try_from(u32::from(r.start())).unwrap(),
+                    end: u8::try_from(u32::from(r.end())).unwrap(),
+                    next: end,
+                });
+            }
+            Ok(ThompsonRef { start: self.add_sparse(trans)?, end })
+        } else if self.is_reverse() {
+            if !self.config.get_shrink() {
+                // When we don't want to spend the extra time shrinking, we
+                // compile the UTF-8 automaton in reverse using something like
+                // the "naive" approach, but will attempt to re-use common
+                // suffixes.
+                self.c_unicode_class_reverse_with_suffix(cls)
+            } else {
+                // When we want to shrink our NFA for reverse UTF-8 automata,
+                // we cannot feed UTF-8 sequences directly to the UTF-8
+                // compiler, since the UTF-8 compiler requires all sequences
+                // to be lexicographically sorted. Instead, we organize our
+                // sequences into a range trie, which can then output our
+                // sequences in the correct order. Unfortunately, building the
+                // range trie is fairly expensive (but not nearly as expensive
+                // as building a DFA). Hence the reason why the 'shrink' option
+                // exists, so that this path can be toggled off. For example,
+                // we might want to turn this off if we know we won't be
+                // compiling a DFA.
+                let mut trie = self.trie_state.borrow_mut();
+                trie.clear();
+
+                for rng in cls.iter() {
+                    for mut seq in Utf8Sequences::new(rng.start(), rng.end()) {
+                        seq.reverse();
+                        trie.insert(seq.as_slice());
+                    }
+                }
+                let mut builder = self.builder.borrow_mut();
+                let mut utf8_state = self.utf8_state.borrow_mut();
+                let mut utf8c =
+                    Utf8Compiler::new(&mut *builder, &mut *utf8_state)?;
+                trie.iter(|seq| {
+                    utf8c.add(&seq)?;
+                    Ok(())
+                })?;
+                utf8c.finish()
+            }
+        } else {
+            // In the forward direction, we always shrink our UTF-8 automata
+            // because we can stream it right into the UTF-8 compiler. There
+            // is almost no downside (in either memory or time) to using this
+            // approach.
+            let mut builder = self.builder.borrow_mut();
+            let mut utf8_state = self.utf8_state.borrow_mut();
+            let mut utf8c =
+                Utf8Compiler::new(&mut *builder, &mut *utf8_state)?;
+            for rng in cls.iter() {
+                for seq in Utf8Sequences::new(rng.start(), rng.end()) {
+                    utf8c.add(seq.as_slice())?;
+                }
+            }
+            utf8c.finish()
+        }
+
+        // For reference, the code below is the "naive" version of compiling a
+        // UTF-8 automaton. It is deliciously simple (and works for both the
+        // forward and reverse cases), but will unfortunately produce very
+        // large NFAs. When compiling a forward automaton, the size difference
+        // can sometimes be an order of magnitude. For example, the '\w' regex
+        // will generate about ~3000 NFA states using the naive approach below,
+        // but only 283 states when using the approach above. This is because
+        // the approach above actually compiles a *minimal* (or near minimal,
+        // because of the bounded hashmap for reusing equivalent states) UTF-8
+        // automaton.
+        //
+        // The code below is kept as a reference point in order to make it
+        // easier to understand the higher level goal here. Although, it will
+        // almost certainly bit-rot, so keep that in mind. Also, if you try to
+        // use it, some of the tests in this module will fail because they look
+        // for terser byte code produce by the more optimized handling above.
+        // But the integration test suite should still pass.
+        //
+        // One good example of the substantial difference this can make is to
+        // compare and contrast performance of the Pike VM when the code below
+        // is active vs the code above. Here's an example to try:
+        //
+        //   regex-cli find nfa thompson pikevm -b @$smallishru '(?m)^\w{20}'
+        //
+        // With Unicode classes generated below, this search takes about 45s on
+        // my machine. But with the compressed version above, the search takes
+        // only around 1.4s. The NFA is also 20% smaller. This is in part due
+        // to the compression, but also because of the utilization of 'sparse'
+        // NFA states. They lead to much less state shuffling during the NFA
+        // search.
+        /*
+        let it = cls
+            .iter()
+            .flat_map(|rng| Utf8Sequences::new(rng.start(), rng.end()))
+            .map(|seq| {
+                let it = seq
+                    .as_slice()
+                    .iter()
+                    .map(|rng| self.c_range(rng.start, rng.end));
+                self.c_concat(it)
+            });
+        self.c_alt(it)
+        */
+    }
+
+    /// Compile the given Unicode character class in reverse with suffix
+    /// caching.
+    ///
+    /// This is a "quick" way to compile large Unicode classes into reverse
+    /// UTF-8 automata while doing a small amount of compression on that
+    /// automata by reusing common suffixes.
+    ///
+    /// A more comprehensive compression scheme can be accomplished by using
+    /// a range trie to efficiently sort a reverse sequence of UTF-8 byte
+    /// rqanges, and then use Daciuk's algorithm via `Utf8Compiler`.
+    ///
+    /// This is the technique used when "NFA shrinking" is disabled.
+    ///
+    /// (This also tries to use "sparse" states where possible, just like
+    /// `c_byte_class` does.)
+    fn c_unicode_class_reverse_with_suffix(
+        &self,
+        cls: &hir::ClassUnicode,
+    ) -> Result<ThompsonRef, BuildError> {
+        // N.B. It would likely be better to cache common *prefixes* in the
+        // reverse direction, but it's not quite clear how to do that. The
+        // advantage of caching suffixes is that it does give us a win, and
+        // has a very small additional overhead.
+        let mut cache = self.utf8_suffix.borrow_mut();
+        cache.clear();
+
+        let union = self.add_union()?;
+        let alt_end = self.add_empty()?;
+        for urng in cls.iter() {
+            for seq in Utf8Sequences::new(urng.start(), urng.end()) {
+                let mut end = alt_end;
+                for brng in seq.as_slice() {
+                    let key = Utf8SuffixKey {
+                        from: end,
+                        start: brng.start,
+                        end: brng.end,
+                    };
+                    let hash = cache.hash(&key);
+                    if let Some(id) = cache.get(&key, hash) {
+                        end = id;
+                        continue;
+                    }
+
+                    let compiled = self.c_range(brng.start, brng.end)?;
+                    self.patch(compiled.end, end)?;
+                    end = compiled.start;
+                    cache.set(key, hash, end);
+                }
+                self.patch(union, end)?;
+            }
+        }
+        Ok(ThompsonRef { start: union, end: alt_end })
+    }
+
+    /// Compile the given HIR look-around assertion to an NFA look-around
+    /// assertion.
+    fn c_look(&self, anchor: &hir::Look) -> Result<ThompsonRef, BuildError> {
+        let look = match *anchor {
+            hir::Look::Start => Look::Start,
+            hir::Look::End => Look::End,
+            hir::Look::StartLF => Look::StartLF,
+            hir::Look::EndLF => Look::EndLF,
+            hir::Look::StartCRLF => Look::StartCRLF,
+            hir::Look::EndCRLF => Look::EndCRLF,
+            hir::Look::WordAscii => Look::WordAscii,
+            hir::Look::WordAsciiNegate => Look::WordAsciiNegate,
+            hir::Look::WordUnicode => Look::WordUnicode,
+            hir::Look::WordUnicodeNegate => Look::WordUnicodeNegate,
+        };
+        let id = self.add_look(look)?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile the given byte string to a concatenation of bytes.
+    fn c_literal(&self, bytes: &[u8]) -> Result<ThompsonRef, BuildError> {
+        self.c_concat(bytes.iter().copied().map(|b| self.c_range(b, b)))
+    }
+
+    /// Compile a "range" state with one transition that may only be followed
+    /// if the input byte is in the (inclusive) range given.
+    ///
+    /// Both the `start` and `end` locations point to the state created.
+    /// Callers will likely want to keep the `start`, but patch the `end` to
+    /// point to some other state.
+    fn c_range(&self, start: u8, end: u8) -> Result<ThompsonRef, BuildError> {
+        let id = self.add_range(start, end)?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile an "empty" state with one unconditional epsilon transition.
+    ///
+    /// Both the `start` and `end` locations point to the state created.
+    /// Callers will likely want to keep the `start`, but patch the `end` to
+    /// point to some other state.
+    fn c_empty(&self) -> Result<ThompsonRef, BuildError> {
+        let id = self.add_empty()?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile a "fail" state that can never have any outgoing transitions.
+    fn c_fail(&self) -> Result<ThompsonRef, BuildError> {
+        let id = self.add_fail()?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    // The below helpers are meant to be simple wrappers around the
+    // corresponding Builder methods. For the most part, they let us write
+    // 'self.add_foo()' instead of 'self.builder.borrow_mut().add_foo()', where
+    // the latter is a mouthful. Some of the methods do inject a little bit
+    // of extra logic. e.g., Flipping look-around operators when compiling in
+    // reverse mode.
+
+    fn patch(&self, from: StateID, to: StateID) -> Result<(), BuildError> {
+        self.builder.borrow_mut().patch(from, to)
+    }
+
+    fn start_pattern(&self) -> Result<PatternID, BuildError> {
+        self.builder.borrow_mut().start_pattern()
+    }
+
+    fn finish_pattern(
+        &self,
+        start_id: StateID,
+    ) -> Result<PatternID, BuildError> {
+        self.builder.borrow_mut().finish_pattern(start_id)
+    }
+
+    fn add_empty(&self) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_empty()
+    }
+
+    fn add_range(&self, start: u8, end: u8) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_range(Transition {
+            start,
+            end,
+            next: StateID::ZERO,
+        })
+    }
+
+    fn add_sparse(
+        &self,
+        ranges: Vec<Transition>,
+    ) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_sparse(ranges)
+    }
+
+    fn add_look(&self, mut look: Look) -> Result<StateID, BuildError> {
+        if self.is_reverse() {
+            look = look.reversed();
+        }
+        self.builder.borrow_mut().add_look(StateID::ZERO, look)
+    }
+
+    fn add_union(&self) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_union(vec![])
+    }
+
+    fn add_union_reverse(&self) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_union_reverse(vec![])
+    }
+
+    fn add_capture_start(
+        &self,
+        capture_index: u32,
+        name: Option<&str>,
+    ) -> Result<StateID, BuildError> {
+        let name = name.map(|n| Arc::from(n));
+        self.builder.borrow_mut().add_capture_start(
+            StateID::ZERO,
+            capture_index,
+            name,
+        )
+    }
+
+    fn add_capture_end(
+        &self,
+        capture_index: u32,
+    ) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_capture_end(StateID::ZERO, capture_index)
+    }
+
+    fn add_fail(&self) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_fail()
+    }
+
+    fn add_match(&self) -> Result<StateID, BuildError> {
+        self.builder.borrow_mut().add_match()
+    }
+
+    fn is_reverse(&self) -> bool {
+        self.config.get_reverse()
+    }
+}
+
+/// A value that represents the result of compiling a sub-expression of a
+/// regex's HIR. Specifically, this represents a sub-graph of the NFA that
+/// has an initial state at `start` and a final state at `end`.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ThompsonRef {
+    pub(crate) start: StateID,
+    pub(crate) end: StateID,
+}
+
+/// A UTF-8 compiler based on Daciuk's algorithm for compilining minimal DFAs
+/// from a lexicographically sorted sequence of strings in linear time.
+///
+/// The trick here is that any Unicode codepoint range can be converted to
+/// a sequence of byte ranges that form a UTF-8 automaton. Connecting them
+/// together via an alternation is trivial, and indeed, it works. However,
+/// there is a lot of redundant structure in many UTF-8 automatons. Since our
+/// UTF-8 ranges are in lexicographic order, we can use Daciuk's algorithm
+/// to build nearly minimal DFAs in linear time. (They are guaranteed to be
+/// minimal because we use a bounded cache of previously build DFA states.)
+///
+/// The drawback is that this sadly doesn't work for reverse automata, since
+/// the ranges are no longer in lexicographic order. For that, we invented the
+/// range trie (which gets its own module). Once a range trie is built, we then
+/// use this same Utf8Compiler to build a reverse UTF-8 automaton.
+///
+/// The high level idea is described here:
+/// https://blog.burntsushi.net/transducers/#finite-state-machines-as-data-structures
+///
+/// There is also another implementation of this in the `fst` crate.
+#[derive(Debug)]
+struct Utf8Compiler<'a> {
+    builder: &'a mut Builder,
+    state: &'a mut Utf8State,
+    target: StateID,
+}
+
+#[derive(Clone, Debug)]
+struct Utf8State {
+    compiled: Utf8BoundedMap,
+    uncompiled: Vec<Utf8Node>,
+}
+
+#[derive(Clone, Debug)]
+struct Utf8Node {
+    trans: Vec<Transition>,
+    last: Option<Utf8LastTransition>,
+}
+
+#[derive(Clone, Debug)]
+struct Utf8LastTransition {
+    start: u8,
+    end: u8,
+}
+
+impl Utf8State {
+    fn new() -> Utf8State {
+        Utf8State { compiled: Utf8BoundedMap::new(10_000), uncompiled: vec![] }
+    }
+
+    fn clear(&mut self) {
+        self.compiled.clear();
+        self.uncompiled.clear();
+    }
+}
+
+impl<'a> Utf8Compiler<'a> {
+    fn new(
+        builder: &'a mut Builder,
+        state: &'a mut Utf8State,
+    ) -> Result<Utf8Compiler<'a>, BuildError> {
+        let target = builder.add_empty()?;
+        state.clear();
+        let mut utf8c = Utf8Compiler { builder, state, target };
+        utf8c.add_empty();
+        Ok(utf8c)
+    }
+
+    fn finish(&mut self) -> Result<ThompsonRef, BuildError> {
+        self.compile_from(0)?;
+        let node = self.pop_root();
+        let start = self.compile(node)?;
+        Ok(ThompsonRef { start, end: self.target })
+    }
+
+    fn add(&mut self, ranges: &[Utf8Range]) -> Result<(), BuildError> {
+        let prefix_len = ranges
+            .iter()
+            .zip(&self.state.uncompiled)
+            .take_while(|&(range, node)| {
+                node.last.as_ref().map_or(false, |t| {
+                    (t.start, t.end) == (range.start, range.end)
+                })
+            })
+            .count();
+        assert!(prefix_len < ranges.len());
+        self.compile_from(prefix_len)?;
+        self.add_suffix(&ranges[prefix_len..]);
+        Ok(())
+    }
+
+    fn compile_from(&mut self, from: usize) -> Result<(), BuildError> {
+        let mut next = self.target;
+        while from + 1 < self.state.uncompiled.len() {
+            let node = self.pop_freeze(next);
+            next = self.compile(node)?;
+        }
+        self.top_last_freeze(next);
+        Ok(())
+    }
+
+    fn compile(
+        &mut self,
+        node: Vec<Transition>,
+    ) -> Result<StateID, BuildError> {
+        let hash = self.state.compiled.hash(&node);
+        if let Some(id) = self.state.compiled.get(&node, hash) {
+            return Ok(id);
+        }
+        let id = self.builder.add_sparse(node.clone())?;
+        self.state.compiled.set(node, hash, id);
+        Ok(id)
+    }
+
+    fn add_suffix(&mut self, ranges: &[Utf8Range]) {
+        assert!(!ranges.is_empty());
+        let last = self
+            .state
+            .uncompiled
+            .len()
+            .checked_sub(1)
+            .expect("non-empty nodes");
+        assert!(self.state.uncompiled[last].last.is_none());
+        self.state.uncompiled[last].last = Some(Utf8LastTransition {
+            start: ranges[0].start,
+            end: ranges[0].end,
+        });
+        for r in &ranges[1..] {
+            self.state.uncompiled.push(Utf8Node {
+                trans: vec![],
+                last: Some(Utf8LastTransition { start: r.start, end: r.end }),
+            });
+        }
+    }
+
+    fn add_empty(&mut self) {
+        self.state.uncompiled.push(Utf8Node { trans: vec![], last: None });
+    }
+
+    fn pop_freeze(&mut self, next: StateID) -> Vec<Transition> {
+        let mut uncompiled = self.state.uncompiled.pop().unwrap();
+        uncompiled.set_last_transition(next);
+        uncompiled.trans
+    }
+
+    fn pop_root(&mut self) -> Vec<Transition> {
+        assert_eq!(self.state.uncompiled.len(), 1);
+        assert!(self.state.uncompiled[0].last.is_none());
+        self.state.uncompiled.pop().expect("non-empty nodes").trans
+    }
+
+    fn top_last_freeze(&mut self, next: StateID) {
+        let last = self
+            .state
+            .uncompiled
+            .len()
+            .checked_sub(1)
+            .expect("non-empty nodes");
+        self.state.uncompiled[last].set_last_transition(next);
+    }
+}
+
+impl Utf8Node {
+    fn set_last_transition(&mut self, next: StateID) {
+        if let Some(last) = self.last.take() {
+            self.trans.push(Transition {
+                start: last.start,
+                end: last.end,
+                next,
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::{vec, vec::Vec};
+
+    use crate::{
+        nfa::thompson::{SparseTransitions, State, Transition, NFA},
+        util::primitives::{PatternID, StateID},
+    };
+
+    fn build(pattern: &str) -> NFA {
+        NFA::compiler()
+            .configure(NFA::config().captures(false).unanchored_prefix(false))
+            .build(pattern)
+            .unwrap()
+    }
+
+    fn pid(id: usize) -> PatternID {
+        PatternID::new(id).unwrap()
+    }
+
+    fn sid(id: usize) -> StateID {
+        StateID::new(id).unwrap()
+    }
+
+    fn s_byte(byte: u8, next: usize) -> State {
+        let next = sid(next);
+        let trans = Transition { start: byte, end: byte, next };
+        State::ByteRange { trans }
+    }
+
+    fn s_range(start: u8, end: u8, next: usize) -> State {
+        let next = sid(next);
+        let trans = Transition { start, end, next };
+        State::ByteRange { trans }
+    }
+
+    fn s_sparse(transitions: &[(u8, u8, usize)]) -> State {
+        let transitions = transitions
+            .iter()
+            .map(|&(start, end, next)| Transition {
+                start,
+                end,
+                next: sid(next),
+            })
+            .collect();
+        State::Sparse(SparseTransitions { transitions })
+    }
+
+    fn s_bin_union(alt1: usize, alt2: usize) -> State {
+        State::BinaryUnion { alt1: sid(alt1), alt2: sid(alt2) }
+    }
+
+    fn s_union(alts: &[usize]) -> State {
+        State::Union {
+            alternates: alts
+                .iter()
+                .map(|&id| sid(id))
+                .collect::<Vec<StateID>>()
+                .into_boxed_slice(),
+        }
+    }
+
+    fn s_fail() -> State {
+        State::Fail
+    }
+
+    fn s_match(id: usize) -> State {
+        State::Match { pattern_id: pid(id) }
+    }
+
+    // Test that building an unanchored NFA has an appropriate `(?s:.)*?`
+    // prefix.
+    #[test]
+    fn compile_unanchored_prefix() {
+        let nfa = NFA::compiler()
+            .configure(NFA::config().captures(false))
+            .build(r"a")
+            .unwrap();
+        assert_eq!(
+            nfa.states(),
+            &[
+                s_bin_union(2, 1),
+                s_range(0, 255, 0),
+                s_byte(b'a', 3),
+                s_match(0),
+            ]
+        );
+    }
+
+    #[test]
+    fn compile_empty() {
+        assert_eq!(build("").states(), &[s_match(0),]);
+    }
+
+    #[test]
+    fn compile_literal() {
+        assert_eq!(build("a").states(), &[s_byte(b'a', 1), s_match(0),]);
+        assert_eq!(
+            build("ab").states(),
+            &[s_byte(b'a', 1), s_byte(b'b', 2), s_match(0),]
+        );
+        assert_eq!(
+            build("☃").states(),
+            &[s_byte(0xE2, 1), s_byte(0x98, 2), s_byte(0x83, 3), s_match(0)]
+        );
+
+        // Check that non-UTF-8 literals work.
+        let nfa = NFA::compiler()
+            .configure(NFA::config().captures(false).unanchored_prefix(false))
+            .syntax(crate::util::syntax::Config::new().utf8(false))
+            .build(r"(?-u)\xFF")
+            .unwrap();
+        assert_eq!(nfa.states(), &[s_byte(b'\xFF', 1), s_match(0),]);
+    }
+
+    #[test]
+    fn compile_class_ascii() {
+        assert_eq!(
+            build(r"[a-z]").states(),
+            &[s_range(b'a', b'z', 1), s_match(0),]
+        );
+        assert_eq!(
+            build(r"[x-za-c]").states(),
+            &[s_sparse(&[(b'a', b'c', 1), (b'x', b'z', 1)]), s_match(0)]
+        );
+    }
+
+    #[test]
+    #[cfg(not(miri))]
+    fn compile_class_unicode() {
+        assert_eq!(
+            build(r"[\u03B1-\u03B4]").states(),
+            &[s_range(0xB1, 0xB4, 2), s_byte(0xCE, 0), s_match(0)]
+        );
+        assert_eq!(
+            build(r"[\u03B1-\u03B4\u{1F919}-\u{1F91E}]").states(),
+            &[
+                s_range(0xB1, 0xB4, 5),
+                s_range(0x99, 0x9E, 5),
+                s_byte(0xA4, 1),
+                s_byte(0x9F, 2),
+                s_sparse(&[(0xCE, 0xCE, 0), (0xF0, 0xF0, 3)]),
+                s_match(0),
+            ]
+        );
+        assert_eq!(
+            build(r"[a-z☃]").states(),
+            &[
+                s_byte(0x83, 3),
+                s_byte(0x98, 0),
+                s_sparse(&[(b'a', b'z', 3), (0xE2, 0xE2, 1)]),
+                s_match(0),
+            ]
+        );
+    }
+
+    #[test]
+    fn compile_repetition() {
+        assert_eq!(
+            build(r"a?").states(),
+            &[s_bin_union(1, 2), s_byte(b'a', 2), s_match(0),]
+        );
+        assert_eq!(
+            build(r"a??").states(),
+            &[s_bin_union(2, 1), s_byte(b'a', 2), s_match(0),]
+        );
+    }
+
+    #[test]
+    fn compile_group() {
+        assert_eq!(
+            build(r"ab+").states(),
+            &[s_byte(b'a', 1), s_byte(b'b', 2), s_bin_union(1, 3), s_match(0)]
+        );
+        assert_eq!(
+            build(r"(ab)").states(),
+            &[s_byte(b'a', 1), s_byte(b'b', 2), s_match(0)]
+        );
+        assert_eq!(
+            build(r"(ab)+").states(),
+            &[s_byte(b'a', 1), s_byte(b'b', 2), s_bin_union(0, 3), s_match(0)]
+        );
+    }
+
+    #[test]
+    fn compile_alternation() {
+        assert_eq!(
+            build(r"a|b").states(),
+            &[s_range(b'a', b'b', 1), s_match(0)]
+        );
+        assert_eq!(
+            build(r"ab|cd").states(),
+            &[
+                s_byte(b'b', 3),
+                s_byte(b'd', 3),
+                s_sparse(&[(b'a', b'a', 0), (b'c', b'c', 1)]),
+                s_match(0)
+            ],
+        );
+        assert_eq!(
+            build(r"|b").states(),
+            &[s_byte(b'b', 2), s_bin_union(2, 0), s_match(0)]
+        );
+        assert_eq!(
+            build(r"a|").states(),
+            &[s_byte(b'a', 2), s_bin_union(0, 2), s_match(0)]
+        );
+    }
+
+    // This tests the use of a non-binary union, i.e., a state with more than
+    // 2 unconditional epsilon transitions. The only place they tend to appear
+    // is in reverse NFAs when shrinking is disabled. Otherwise, 'binary-union'
+    // and 'sparse' tend to cover all other cases of alternation.
+    #[test]
+    fn compile_non_binary_union() {
+        let nfa = NFA::compiler()
+            .configure(
+                NFA::config()
+                    .captures(false)
+                    .reverse(true)
+                    .shrink(false)
+                    .unanchored_prefix(false),
+            )
+            .build(r"[\u1000\u2000\u3000]")
+            .unwrap();
+        assert_eq!(
+            nfa.states(),
+            &[
+                s_union(&[3, 6, 9]),
+                s_byte(0xE1, 10),
+                s_byte(0x80, 1),
+                s_byte(0x80, 2),
+                s_byte(0xE2, 10),
+                s_byte(0x80, 4),
+                s_byte(0x80, 5),
+                s_byte(0xE3, 10),
+                s_byte(0x80, 7),
+                s_byte(0x80, 8),
+                s_match(0),
+            ]
+        );
+    }
+
+    #[test]
+    fn compile_many_start_pattern() {
+        let nfa = NFA::compiler()
+            .configure(NFA::config().captures(false).unanchored_prefix(false))
+            .build_many(&["a", "b"])
+            .unwrap();
+        assert_eq!(
+            nfa.states(),
+            &[
+                s_byte(b'a', 1),
+                s_match(0),
+                s_byte(b'b', 3),
+                s_match(1),
+                s_bin_union(0, 2),
+            ]
+        );
+        assert_eq!(nfa.start_anchored().as_usize(), 4);
+        assert_eq!(nfa.start_unanchored().as_usize(), 4);
+        // Test that the start states for each individual pattern are correct.
+        assert_eq!(nfa.start_pattern(pid(0)).unwrap(), sid(0));
+        assert_eq!(nfa.start_pattern(pid(1)).unwrap(), sid(2));
+    }
+
+    // This tests that our compiler can handle an empty character class. At the
+    // time of writing, the regex parser forbids it, so the only way to test it
+    // is to provide a hand written HIR.
+    #[test]
+    fn empty_class_bytes() {
+        use regex_syntax::hir::{Class, ClassBytes, Hir};
+
+        let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![])));
+        let config = NFA::config().captures(false).unanchored_prefix(false);
+        let nfa =
+            NFA::compiler().configure(config).build_from_hir(&hir).unwrap();
+        assert_eq!(nfa.states(), &[s_fail(), s_match(0)]);
+    }
+
+    // Like empty_class_bytes, but for a Unicode class.
+    #[test]
+    fn empty_class_unicode() {
+        use regex_syntax::hir::{Class, ClassUnicode, Hir};
+
+        let hir = Hir::class(Class::Unicode(ClassUnicode::new(vec![])));
+        let config = NFA::config().captures(false).unanchored_prefix(false);
+        let nfa =
+            NFA::compiler().configure(config).build_from_hir(&hir).unwrap();
+        assert_eq!(nfa.states(), &[s_fail(), s_match(0)]);
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/error.rs b/regex-automata/src/nfa/thompson/error.rs
new file mode 100644
index 0000000000..645bb065a0
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/error.rs
@@ -0,0 +1,197 @@
+use crate::util::{
+    captures, look,
+    primitives::{PatternID, StateID},
+};
+
+/// An error that can occured during the construction of a thompson NFA.
+///
+/// This error does not provide many introspection capabilities. There are
+/// generally only two things you can do with it:
+///
+/// * Obtain a human readable message via its `std::fmt::Display` impl.
+/// * Access an underlying [`regex_syntax::Error`] type from its `source`
+/// method via the `std::error::Error` trait. This error only occurs when using
+/// convenience routines for building an NFA directly from a pattern string.
+///
+/// Otherwise, errors typically occur when a limit has been breeched. For
+/// example, if the total heap usage of the compiled NFA exceeds the limit
+/// set by [`Config::nfa_size_limit`](crate::nfa::thompson::Config), then
+/// building the NFA will fail.
+#[derive(Clone, Debug)]
+pub struct BuildError {
+    kind: BuildErrorKind,
+}
+
+/// The kind of error that occurred during the construction of a thompson NFA.
+#[derive(Clone, Debug)]
+enum BuildErrorKind {
+    /// An error that occurred while parsing a regular expression. Note that
+    /// this error may be printed over multiple lines, and is generally
+    /// intended to be end user readable on its own.
+    #[cfg(feature = "syntax")]
+    Syntax(regex_syntax::Error),
+    /// An error that occurs if the capturing groups provided to an NFA builder
+    /// do not satisfy the documented invariants. For example, things like
+    /// too many groups, missing groups, having the first (zeroth) group be
+    /// named or duplicate group names within the same pattern.
+    Captures(captures::GroupInfoError),
+    /// An error that occurs when an NFA contains a Unicode word boundary, but
+    /// where the crate was compiled without the necessary data for dealing
+    /// with Unicode word boundaries.
+    Word(look::UnicodeWordBoundaryError),
+    /// An error that occurs if too many patterns were given to the NFA
+    /// compiler.
+    TooManyPatterns {
+        /// The number of patterns given, which exceeds the limit.
+        given: usize,
+        /// The limit on the number of patterns.
+        limit: usize,
+    },
+    /// An error that occurs if too states are produced while building an NFA.
+    TooManyStates {
+        /// The minimum number of states that are desired, which exceeds the
+        /// limit.
+        given: usize,
+        /// The limit on the number of states.
+        limit: usize,
+    },
+    /// An error that occurs when NFA compilation exceeds a configured heap
+    /// limit.
+    ExceededSizeLimit {
+        /// The configured limit, in bytes.
+        limit: usize,
+    },
+    /// An error that occurs when an invalid capture group index is added to
+    /// the NFA. An "invalid" index can be one that would otherwise overflow
+    /// a `usize` on the current target.
+    InvalidCaptureIndex {
+        /// The invalid index that was given.
+        index: u32,
+    },
+    /// An error that occurs when one tries to build an NFA simulation (such as
+    /// the PikeVM) without any capturing groups.
+    MissingCaptures,
+    /// An error that occurs when one tries to build a reverse NFA with
+    /// captures enabled. Currently, this isn't supported, but we probably
+    /// should support it at some point.
+    #[cfg(feature = "syntax")]
+    UnsupportedCaptures,
+}
+
+impl BuildError {
+    /// If this error occurred because the NFA exceeded the configured size
+    /// limit before being built, then this returns the configured size limit.
+    ///
+    /// The limit returned is what was configured, and corresponds to the
+    /// maximum amount of heap usage in bytes.
+    pub fn size_limit(&self) -> Option<usize> {
+        match self.kind {
+            BuildErrorKind::ExceededSizeLimit { limit } => Some(limit),
+            _ => None,
+        }
+    }
+
+    fn kind(&self) -> &BuildErrorKind {
+        &self.kind
+    }
+
+    #[cfg(feature = "syntax")]
+    pub(crate) fn syntax(err: regex_syntax::Error) -> BuildError {
+        BuildError { kind: BuildErrorKind::Syntax(err) }
+    }
+
+    pub(crate) fn captures(err: captures::GroupInfoError) -> BuildError {
+        BuildError { kind: BuildErrorKind::Captures(err) }
+    }
+
+    pub(crate) fn word(err: look::UnicodeWordBoundaryError) -> BuildError {
+        BuildError { kind: BuildErrorKind::Word(err) }
+    }
+
+    pub(crate) fn too_many_patterns(given: usize) -> BuildError {
+        let limit = PatternID::LIMIT;
+        BuildError { kind: BuildErrorKind::TooManyPatterns { given, limit } }
+    }
+
+    pub(crate) fn too_many_states(given: usize) -> BuildError {
+        let limit = StateID::LIMIT;
+        BuildError { kind: BuildErrorKind::TooManyStates { given, limit } }
+    }
+
+    pub(crate) fn exceeded_size_limit(limit: usize) -> BuildError {
+        BuildError { kind: BuildErrorKind::ExceededSizeLimit { limit } }
+    }
+
+    pub(crate) fn invalid_capture_index(index: u32) -> BuildError {
+        BuildError { kind: BuildErrorKind::InvalidCaptureIndex { index } }
+    }
+
+    pub(crate) fn missing_captures() -> BuildError {
+        BuildError { kind: BuildErrorKind::MissingCaptures }
+    }
+
+    #[cfg(feature = "syntax")]
+    pub(crate) fn unsupported_captures() -> BuildError {
+        BuildError { kind: BuildErrorKind::UnsupportedCaptures }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind() {
+            #[cfg(feature = "syntax")]
+            BuildErrorKind::Syntax(ref err) => Some(err),
+            BuildErrorKind::Captures(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl core::fmt::Display for BuildError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self.kind() {
+            #[cfg(feature = "syntax")]
+            BuildErrorKind::Syntax(_) => write!(f, "error parsing regex"),
+            BuildErrorKind::Captures(_) => {
+                write!(f, "error with capture groups")
+            }
+            BuildErrorKind::Word(_) => {
+                write!(f, "NFA contains Unicode word boundary")
+            }
+            BuildErrorKind::TooManyPatterns { given, limit } => write!(
+                f,
+                "attemped to compile {} patterns, \
+                 which exceeds the limit of {}",
+                given, limit,
+            ),
+            BuildErrorKind::TooManyStates { given, limit } => write!(
+                f,
+                "attemped to compile {} NFA states, \
+                 which exceeds the limit of {}",
+                given, limit,
+            ),
+            BuildErrorKind::ExceededSizeLimit { limit } => write!(
+                f,
+                "heap usage during NFA compilation exceeded limit of {}",
+                limit,
+            ),
+            BuildErrorKind::InvalidCaptureIndex { index } => write!(
+                f,
+                "capture group index {} is invalid (too big or discontinuous)",
+                index,
+            ),
+            BuildErrorKind::MissingCaptures => write!(
+                f,
+                "operation requires the NFA to have capturing groups, \
+                 but the NFA given contains none",
+            ),
+            #[cfg(feature = "syntax")]
+            BuildErrorKind::UnsupportedCaptures => write!(
+                f,
+                "currently captures must be disabled when compiling \
+                 a reverse NFA",
+            ),
+        }
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/literal_trie.rs b/regex-automata/src/nfa/thompson/literal_trie.rs
new file mode 100644
index 0000000000..7ed129afd1
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/literal_trie.rs
@@ -0,0 +1,528 @@
+use core::mem;
+
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    nfa::thompson::{self, compiler::ThompsonRef, BuildError, Builder},
+    util::primitives::{IteratorIndexExt, StateID},
+};
+
+/// A trie that preserves leftmost-first match semantics.
+///
+/// This is a purpose-built data structure for optimizing 'lit1|lit2|..|litN'
+/// patterns. It can *only* handle alternations of literals, which makes it
+/// somewhat restricted in its scope, but literal alternations are fairly
+/// common.
+///
+/// At a 5,000 foot level, the main idea of this trie is make an alternation of
+/// literals look more like a DFA than an NFA via epsilon removal.
+///
+/// More precisely, the main issue is in how alternations are compiled into
+/// a Thompson NFA. Namely, each alternation gets a single NFA "union" state
+/// with an epsilon transition for every branch of the alternation pointing to
+/// an NFA state corresponding to the start of that branch. The main problem
+/// with this representation is the cost of computing an epsilon closure. Once
+/// you hit the alternation's start state, it acts as a sort of "clog" that
+/// requires you to traverse all of the epsilon transitions to compute the full
+/// closure.
+///
+/// While fixing such clogs in the general case is pretty tricky without going
+/// to a DFA (or perhaps a Glushkov NFA, but that comes with other problems).
+/// But at least in the case of an alternation of literals, we can convert
+/// that to a prefix trie without too much cost. In theory, that's all you
+/// really need to do: build the trie and then compile it to a Thompson NFA.
+/// For example, if you have the pattern 'bar|baz|foo', then using a trie, it
+/// is transformed to something like 'b(a(r|z))|f'. This reduces the clog by
+/// reducing the number of epsilon transitions out of the alternation's start
+/// state from 3 to 2 (it actually gets down to 1 when you use a sparse state,
+/// which we do below). It's a small effect here, but when your alternation is
+/// huge, the savings is also huge.
+///
+/// And that is... essentially what a LiteralTrie does. But there is one
+/// hiccup. Consider a regex like 'sam|samwise'. How does a prefix trie compile
+/// that when leftmost-first semantics are used? If 'sam|samwise' was the
+/// entire regex, then you could just drop the 'samwise' branch entirely since
+/// it is impossible to match ('sam' will always take priority, and since it
+/// is a prefix of 'samwise', 'samwise' will never match). But what about the
+/// regex '\b(sam|samwise)\b'? In that case, you can't remove 'samwise' because
+/// it might match when 'sam' doesn't fall on a word boundary.
+///
+/// The main idea is that 'sam|samwise' can be translated to 'sam(?:|wise)',
+/// which is a precisely equivalent regex that also gets rid of the clog.
+///
+/// Another example is 'zapper|z|zap'. That gets translated to
+/// 'z(?:apper||ap)'.
+///
+/// We accomplish this by giving each state in the trie multiple "chunks" of
+/// transitions. Each chunk barrier represents a match. The idea is that once
+/// you know a match occurs, none of the transitions after the match can be
+/// re-ordered and mixed in with the transitions before the match. Otherwise,
+/// the match semantics could be changed.
+///
+/// See the 'State' data type for a bit more detail.
+///
+/// Future work:
+///
+/// * In theory, it would be nice to generalize the idea of removing clogs and
+/// apply it to the NFA graph itself. Then this could in theory work for
+/// case insensitive alternations of literals, or even just alternations where
+/// each branch starts with a non-epsilon transition.
+/// * Could we instead use the Aho-Corasick algorithm here? The aho-corasick
+/// crate deals with leftmost-first matches correctly, but I think this implies
+/// encoding failure transitions into a Thompson NFA somehow. Which seems fine,
+/// because failure transitions are just unconditional epsilon transitions?
+/// * Or perhaps even better, could we use an aho_corasick::AhoCorasick
+/// directly? At time of writing, 0.7 is the current version of the
+/// aho-corasick crate, and that definitely cannot be used as-is. But if we
+/// expose the underlying finite state machine API, then could we use it? That
+/// would be super. If we could figure that out, it might also lend itself to
+/// more general composition of finite state machines.
+#[derive(Clone)]
+pub(crate) struct LiteralTrie {
+    /// The set of trie states. Each state contains one or more chunks, where
+    /// each chunk is a sparse set of transitions to other states. A leaf state
+    /// is always a match state that contains only empty chunks (i.e., no
+    /// transitions).
+    states: Vec<State>,
+    /// Whether to add literals in reverse to the trie. Useful when building
+    /// a reverse NFA automaton.
+    rev: bool,
+}
+
+impl LiteralTrie {
+    /// Create a new literal trie that adds literals in the forward direction.
+    pub(crate) fn forward() -> LiteralTrie {
+        let root = State::default();
+        LiteralTrie { states: vec![root], rev: false }
+    }
+
+    /// Create a new literal trie that adds literals in reverse.
+    pub(crate) fn reverse() -> LiteralTrie {
+        let root = State::default();
+        LiteralTrie { states: vec![root], rev: true }
+    }
+
+    /// Add the given literal to this trie.
+    ///
+    /// If the literal could not be added because the `StateID` space was
+    /// exhausted, then an error is returned. If an error returns, the trie
+    /// is in an unspecified state.
+    pub(crate) fn add(&mut self, bytes: &[u8]) -> Result<(), BuildError> {
+        let mut prev = StateID::ZERO;
+        let mut it = bytes.iter().copied();
+        while let Some(b) = if self.rev { it.next_back() } else { it.next() } {
+            prev = self.get_or_add_state(prev, b)?;
+        }
+        self.states[prev].add_match();
+        Ok(())
+    }
+
+    /// If the given transition is defined, then return the next state ID.
+    /// Otherwise, add the transition to `from` and point it to a new state.
+    ///
+    /// If a new state ID could not be allocated, then an error is returned.
+    fn get_or_add_state(
+        &mut self,
+        from: StateID,
+        byte: u8,
+    ) -> Result<StateID, BuildError> {
+        let active = self.states[from].active_chunk();
+        match active.binary_search_by_key(&byte, |t| t.byte) {
+            Ok(i) => Ok(active[i].next),
+            Err(i) => {
+                // Add a new state and get its ID.
+                let next = StateID::new(self.states.len()).map_err(|_| {
+                    BuildError::too_many_states(self.states.len())
+                })?;
+                self.states.push(State::default());
+                // Offset our position to account for all transitions and not
+                // just the ones in the active chunk.
+                let i = self.states[from].active_chunk_start() + i;
+                let t = Transition { byte, next };
+                self.states[from].transitions.insert(i, t);
+                Ok(next)
+            }
+        }
+    }
+
+    /// Compile this literal trie to the NFA builder given.
+    ///
+    /// This forwards any errors that may occur while using the given builder.
+    pub(crate) fn compile(
+        &self,
+        builder: &mut Builder,
+    ) -> Result<ThompsonRef, BuildError> {
+        // Compilation proceeds via depth-first traversal of the trie.
+        //
+        // This is overall pretty brutal. The recursive version of this is
+        // deliciously simple. (See 'compile_to_hir' below for what it might
+        // look like.) But recursion on a trie means your call stack grows
+        // in accordance with the longest literal, which just does not seem
+        // appropriate. So we push the call stack to the heap. But as a result,
+        // the trie traversal becomes pretty brutal because we essentially
+        // have to encode the state of a double for-loop into an explicit call
+        // frame. If someone can simplify this without using recursion, that'd
+        // be great.
+
+        // 'end' is our match state for this trie, but represented in the the
+        // NFA. Any time we see a match in the trie, we insert a transition
+        // from the current state we're in to 'end'.
+        let end = builder.add_empty()?;
+        let mut stack = vec![];
+        let mut f = Frame::new(&self.states[StateID::ZERO]);
+        loop {
+            if let Some(t) = f.transitions.next() {
+                if self.states[t.next].is_leaf() {
+                    f.sparse.push(thompson::Transition {
+                        start: t.byte,
+                        end: t.byte,
+                        next: end,
+                    });
+                } else {
+                    f.sparse.push(thompson::Transition {
+                        start: t.byte,
+                        end: t.byte,
+                        // This is a little funny, but when the frame we create
+                        // below completes, it will pop this parent frame off
+                        // and modify this transition to point to the correct
+                        // state.
+                        next: StateID::ZERO,
+                    });
+                    stack.push(f);
+                    f = Frame::new(&self.states[t.next]);
+                }
+                continue;
+            }
+            // At this point, we have visited all transitions in f.chunk, so
+            // add it as a sparse NFA state. Unless the chunk was empty, in
+            // which case, we don't do anything.
+            if !f.sparse.is_empty() {
+                let chunk_id = if f.sparse.len() == 1 {
+                    builder.add_range(f.sparse.pop().unwrap())?
+                } else {
+                    let sparse = mem::replace(&mut f.sparse, vec![]);
+                    builder.add_sparse(sparse)?
+                };
+                f.union.push(chunk_id);
+            }
+            // Now we need to look to see if there are other chunks to visit.
+            if let Some(chunk) = f.chunks.next() {
+                // If we're here, it means we're on the second (or greater)
+                // chunk, which implies there is a match at this point. So
+                // connect this state to the final end state.
+                f.union.push(end);
+                // Advance to the next chunk.
+                f.transitions = chunk.iter();
+                continue;
+            }
+            // Now that we are out of chunks, we have completely visited
+            // this state. So turn our union of chunks into an NFA union
+            // state, and add that union state to the parent state's current
+            // sparse state. (If there is no parent, we're done.)
+            let start = builder.add_union(f.union)?;
+            match stack.pop() {
+                None => {
+                    return Ok(ThompsonRef { start, end });
+                }
+                Some(mut parent) => {
+                    // OK because the only way a frame gets pushed on to the
+                    // stack (aside from the root) is when a transition has
+                    // been added to 'sparse'.
+                    parent.sparse.last_mut().unwrap().next = start;
+                    f = parent;
+                }
+            }
+        }
+    }
+
+    /// Converts this trie to an equivalent HIR expression.
+    ///
+    /// We don't actually use this, but it's useful for tests. In particular,
+    /// it provides a (somewhat) human readable representation of the trie
+    /// itself.
+    #[cfg(test)]
+    fn compile_to_hir(&self) -> regex_syntax::hir::Hir {
+        self.compile_state_to_hir(StateID::ZERO)
+    }
+
+    /// The recursive implementation of 'to_hir'.
+    ///
+    /// Notice how simple this is compared to 'compile' above. 'compile' could
+    /// be similarly simple, but we opt to not use recursion in order to avoid
+    /// overflowing the stack in the case of a longer literal.
+    #[cfg(test)]
+    fn compile_state_to_hir(&self, sid: StateID) -> regex_syntax::hir::Hir {
+        use regex_syntax::hir::Hir;
+
+        let mut alt = vec![];
+        for (i, chunk) in self.states[sid].chunks().enumerate() {
+            if i > 0 {
+                alt.push(Hir::empty());
+            }
+            if chunk.is_empty() {
+                continue;
+            }
+            let mut chunk_alt = vec![];
+            for t in chunk.iter() {
+                chunk_alt.push(Hir::concat(vec![
+                    Hir::literal(vec![t.byte]),
+                    self.compile_state_to_hir(t.next),
+                ]));
+            }
+            alt.push(Hir::alternation(chunk_alt));
+        }
+        Hir::alternation(alt)
+    }
+}
+
+impl core::fmt::Debug for LiteralTrie {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        writeln!(f, "LiteralTrie(")?;
+        for (sid, state) in self.states.iter().with_state_ids() {
+            writeln!(f, "{:06?}: {:?}", sid.as_usize(), state)?;
+        }
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+/// An explicit stack frame used for traversing the trie without using
+/// recursion.
+///
+/// Each frame is tied to the traversal of a single trie state. The frame is
+/// dropped once the entire state (and all of its children) have been visited.
+/// The "output" of compiling a state is the 'union' vector, which is turn
+/// converted to a NFA union state. Each branch of the union corresponds to a
+/// chunk in the trie state.
+///
+/// 'sparse' corresponds to the set of transitions for a particular chunk in a
+/// trie state. It is ultimately converted to an NFA sparse state. The 'sparse'
+/// field, after being converted to a sparse NFA state, is reused for any
+/// subsequent chunks in the trie state, if any exist.
+#[derive(Debug)]
+struct Frame<'a> {
+    /// The remaining chunks to visit for a trie state.
+    chunks: StateChunksIter<'a>,
+    /// The transitions of the current chunk that we're iterating over. Since
+    /// every trie state has at least one chunk, every frame is initialized
+    /// with the first chunk's transitions ready to be consumed.
+    transitions: core::slice::Iter<'a, Transition>,
+    /// The NFA state IDs pointing to the start of each chunk compiled by
+    /// this trie state. This ultimately gets converted to an NFA union once
+    /// the entire trie state (and all of its children) have been compiled.
+    /// The order of these matters for leftmost-first match semantics, since
+    /// earlier matches in the union are preferred over later ones.
+    union: Vec<StateID>,
+    /// The actual NFA transitions for a single chunk in a trie state. This
+    /// gets converted to an NFA sparse state, and its corresponding NFA state
+    /// ID should get added to 'union'.
+    sparse: Vec<thompson::Transition>,
+}
+
+impl<'a> Frame<'a> {
+    /// Create a new stack frame for trie traversal. This initializes the
+    /// 'transitions' iterator to the transitions for the first chunk, with the
+    /// 'chunks' iterator being every chunk after the first one.
+    fn new(state: &'a State) -> Frame<'a> {
+        let mut chunks = state.chunks();
+        // every state has at least 1 chunk
+        let chunk = chunks.next().unwrap();
+        let transitions = chunk.iter();
+        Frame { chunks, transitions, union: vec![], sparse: vec![] }
+    }
+}
+
+/// A state in a trie.
+///
+/// This uses a sparse representation. Since we don't use literal tries
+/// for searching, and ultimately (and compilation requires visiting every
+/// transition anyway), we use a sparse representation for transitions. This
+/// means we save on memory, at the expense of 'LiteralTrie::add' being perhaps
+/// a bit slower.
+///
+/// While 'transitions' is pretty standard as far as tries goes, the 'chunks'
+/// piece here is more unusual. In effect, 'chunks' defines a partitioning
+/// of 'transitions', where each chunk corresponds to a distinct set of
+/// transitions. The key invariant is that a transition in one chunk cannot
+/// be moved to another chunk. This is the secret sauce that preserve
+/// leftmost-first match semantics.
+///
+/// A new chunk is added whenever we mark a state as a match state. Once a
+/// new chunk is added, the old active chunk is frozen and is never mutated
+/// again. The new chunk becomes the active chunk, which is defined as
+/// '&transitions[chunks.last().map_or(0, |c| c.1)..]'. Thus, a state where
+/// 'chunks' is empty actually contains one chunk. Thus, every state contains
+/// at least one (possibly empty) chunk.
+///
+/// A "leaf" state is a state that has no outgoing transitions (so
+/// 'transitions' is empty). Note that there is no way for a leaf state to be a
+/// non-matching state. (Although while building the trie, within 'add', a leaf
+/// state may exist while not containing any matches. But this invariant is
+/// only broken within 'add'. Once 'add' returns, the invariant is upheld.)
+#[derive(Clone, Default)]
+struct State {
+    transitions: Vec<Transition>,
+    chunks: Vec<(usize, usize)>,
+}
+
+impl State {
+    /// Mark this state as a match state and freeze the active chunk such that
+    /// it can not be further mutated.
+    fn add_match(&mut self) {
+        // This is not strictly necessary, but there's no point in recording
+        // another match by adding another chunk if the state has no
+        // transitions. Note though that we only skip this if we already know
+        // this is a match state, which is only true if 'chunks' is not empty.
+        // Basically, if we didn't do this, nothing semantically would change,
+        // but we'd end up pushing another chunk and potentially triggering an
+        // alloc.
+        if self.transitions.is_empty() && !self.chunks.is_empty() {
+            return;
+        }
+        let chunk_start = self.active_chunk_start();
+        let chunk_end = self.transitions.len();
+        self.chunks.push((chunk_start, chunk_end));
+    }
+
+    /// Returns true if and only if this state is a leaf state. That is, a
+    /// state that has no outgoing transitions.
+    fn is_leaf(&self) -> bool {
+        self.transitions.is_empty()
+    }
+
+    /// Returns an iterator over all of the chunks (including the currently
+    /// active chunk) in this state. Since the active chunk is included, the
+    /// iterator is guaranteed to always yield at least one chunk (although the
+    /// chunk may be empty).
+    fn chunks(&self) -> StateChunksIter<'_> {
+        StateChunksIter {
+            transitions: &*self.transitions,
+            chunks: self.chunks.iter(),
+            active: Some(self.active_chunk()),
+        }
+    }
+
+    /// Returns the active chunk as a slice of transitions.
+    fn active_chunk(&self) -> &[Transition] {
+        let start = self.active_chunk_start();
+        &self.transitions[start..]
+    }
+
+    /// Returns the index into 'transitions' where the active chunk starts.
+    fn active_chunk_start(&self) -> usize {
+        self.chunks.last().map_or(0, |&(_, end)| end)
+    }
+}
+
+impl core::fmt::Debug for State {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut spacing = " ";
+        for (i, chunk) in self.chunks().enumerate() {
+            if i > 0 {
+                write!(f, "{}MATCH", spacing)?;
+            }
+            spacing = "";
+            for (j, t) in chunk.iter().enumerate() {
+                spacing = " ";
+                if j == 0 && i > 0 {
+                    write!(f, " ")?;
+                } else if j > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{:?}", t)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over all of the chunks in a state, including the active chunk.
+///
+/// This iterator is created by `State::chunks`. We name this iterator so that
+/// we can include it in the `Frame` type for non-recursive trie traversal.
+#[derive(Debug)]
+struct StateChunksIter<'a> {
+    transitions: &'a [Transition],
+    chunks: core::slice::Iter<'a, (usize, usize)>,
+    active: Option<&'a [Transition]>,
+}
+
+impl<'a> Iterator for StateChunksIter<'a> {
+    type Item = &'a [Transition];
+
+    fn next(&mut self) -> Option<&'a [Transition]> {
+        if let Some(&(start, end)) = self.chunks.next() {
+            return Some(&self.transitions[start..end]);
+        }
+        if let Some(chunk) = self.active.take() {
+            return Some(chunk);
+        }
+        None
+    }
+}
+
+/// A single transition in a trie to another state.
+#[derive(Clone, Copy)]
+struct Transition {
+    byte: u8,
+    next: StateID,
+}
+
+impl core::fmt::Debug for Transition {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(
+            f,
+            "{:?} => {}",
+            crate::util::escape::DebugByte(self.byte),
+            self.next.as_usize()
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use bstr::B;
+    use regex_syntax::hir::Hir;
+
+    use super::*;
+
+    #[test]
+    fn zap() {
+        let mut trie = LiteralTrie::forward();
+        trie.add(b"zapper").unwrap();
+        trie.add(b"z").unwrap();
+        trie.add(b"zap").unwrap();
+
+        let got = trie.compile_to_hir();
+        let expected = Hir::concat(vec![
+            Hir::literal(B("z")),
+            Hir::alternation(vec![
+                Hir::literal(B("apper")),
+                Hir::empty(),
+                Hir::literal(B("ap")),
+            ]),
+        ]);
+        assert_eq!(expected, got);
+    }
+
+    #[test]
+    fn maker() {
+        let mut trie = LiteralTrie::forward();
+        trie.add(b"make").unwrap();
+        trie.add(b"maple").unwrap();
+        trie.add(b"maker").unwrap();
+
+        let got = trie.compile_to_hir();
+        let expected = Hir::concat(vec![
+            Hir::literal(B("ma")),
+            Hir::alternation(vec![
+                Hir::concat(vec![
+                    Hir::literal(B("ke")),
+                    Hir::alternation(vec![Hir::empty(), Hir::literal(B("r"))]),
+                ]),
+                Hir::literal(B("ple")),
+            ]),
+        ]);
+        assert_eq!(expected, got);
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/map.rs b/regex-automata/src/nfa/thompson/map.rs
new file mode 100644
index 0000000000..c36ce53866
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/map.rs
@@ -0,0 +1,296 @@
+// This module contains a couple simple and purpose built hash maps. The key
+// trade off they make is that they serve as caches rather than true maps. That
+// is, inserting a new entry may cause eviction of another entry. This gives
+// us two things. First, there's less overhead associated with inserts and
+// lookups. Secondly, it lets us control our memory usage.
+//
+// These maps are used in some fairly hot code when generating NFA states for
+// large Unicode character classes.
+//
+// Instead of exposing a rich hashmap entry API, we just permit the caller to
+// produce a hash of the key directly. The hash can then be reused for both
+// lookups and insertions at the cost of leaking abstraction a bit. But these
+// are for internal use only, so it's fine.
+//
+// The Utf8BoundedMap is used for Daciuk's algorithm for constructing a
+// (almost) minimal DFA for large Unicode character classes in linear time.
+// (Daciuk's algorithm is always used when compiling forward NFAs. For reverse
+// NFAs, it's only used when the compiler is configured to 'shrink' the NFA,
+// since there's a bit more expense in the reverse direction.)
+//
+// The Utf8SuffixMap is used when compiling large Unicode character classes for
+// reverse NFAs when 'shrink' is disabled. Specifically, it augments the naive
+// construction of UTF-8 automata by caching common suffixes. This doesn't
+// get the same space savings as Daciuk's algorithm, but it's basically as
+// fast as the naive approach and typically winds up using less memory (since
+// it generates smaller NFAs) despite the presence of the cache.
+//
+// These maps effectively represent caching mechanisms for sparse and
+// byte-range NFA states, respectively. The former represents a single NFA
+// state with many transitions of equivalent priority while the latter
+// represents a single NFA state with a single transition. (Neither state ever
+// has or is an epsilon transition.) Thus, they have different key types. It's
+// likely we could make one generic map, but the machinery didn't seem worth
+// it. They are simple enough.
+
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    nfa::thompson::Transition,
+    util::{
+        int::{Usize, U64},
+        primitives::StateID,
+    },
+};
+
+// Basic FNV-1a hash constants as described in:
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+const PRIME: u64 = 1099511628211;
+const INIT: u64 = 14695981039346656037;
+
+/// A bounded hash map where the key is a sequence of NFA transitions and the
+/// value is a pre-existing NFA state ID.
+///
+/// std's hashmap can be used for this, however, this map has two important
+/// advantages. Firstly, it has lower overhead. Secondly, it permits us to
+/// control our memory usage by limited the number of slots. In general, the
+/// cost here is that this map acts as a cache. That is, inserting a new entry
+/// may remove an old entry. We are okay with this, since it does not impact
+/// correctness in the cases where it is used. The only effect that dropping
+/// states from the cache has is that the resulting NFA generated may be bigger
+/// than it otherwise would be.
+///
+/// This improves benchmarks that compile large Unicode character classes,
+/// since it makes the generation of (almost) minimal UTF-8 automaton faster.
+/// Specifically, one could observe the difference with std's hashmap via
+/// something like the following benchmark:
+///
+///   hyperfine "regex-cli debug nfa thompson --quiet --reverse '\w{90} ecurB'"
+///
+/// But to observe that difference, you'd have to modify the code to use
+/// std's hashmap.
+///
+/// It is quite possible that there is a better way to approach this problem.
+/// For example, if there happens to be a very common state that collides with
+/// a lot of less frequent states, then we could wind up with very poor caching
+/// behavior. Alas, the effectiveness of this cache has not been measured.
+/// Instead, ad hoc experiments suggest that it is "good enough." Additional
+/// smarts (such as an LRU eviction policy) have to be weighed against the
+/// amount of extra time they cost.
+#[derive(Clone, Debug)]
+pub struct Utf8BoundedMap {
+    /// The current version of this map. Only entries with matching versions
+    /// are considered during lookups. If an entry is found with a mismatched
+    /// version, then the map behaves as if the entry does not exist.
+    ///
+    /// This makes it possible to clear the map by simply incrementing the
+    /// version number instead of actually deallocating any storage.
+    version: u16,
+    /// The total number of entries this map can store.
+    capacity: usize,
+    /// The actual entries, keyed by hash. Collisions between different states
+    /// result in the old state being dropped.
+    map: Vec<Utf8BoundedEntry>,
+}
+
+/// An entry in this map.
+#[derive(Clone, Debug, Default)]
+struct Utf8BoundedEntry {
+    /// The version of the map used to produce this entry. If this entry's
+    /// version does not match the current version of the map, then the map
+    /// should behave as if this entry does not exist.
+    version: u16,
+    /// The key, which is a sorted sequence of non-overlapping NFA transitions.
+    key: Vec<Transition>,
+    /// The state ID corresponding to the state containing the transitions in
+    /// this entry.
+    val: StateID,
+}
+
+impl Utf8BoundedMap {
+    /// Create a new bounded map with the given capacity. The map will never
+    /// grow beyond the given size.
+    ///
+    /// Note that this does not allocate. Instead, callers must call `clear`
+    /// before using this map. `clear` will allocate space if necessary.
+    ///
+    /// This avoids the need to pay for the allocation of this map when
+    /// compiling regexes that lack large Unicode character classes.
+    pub fn new(capacity: usize) -> Utf8BoundedMap {
+        assert!(capacity > 0);
+        Utf8BoundedMap { version: 0, capacity, map: vec![] }
+    }
+
+    /// Clear this map of all entries, but permit the reuse of allocation
+    /// if possible.
+    ///
+    /// This must be called before the map can be used.
+    pub fn clear(&mut self) {
+        if self.map.is_empty() {
+            self.map = vec![Utf8BoundedEntry::default(); self.capacity];
+        } else {
+            self.version = self.version.wrapping_add(1);
+            // If we loop back to version 0, then we forcefully clear the
+            // entire map. Otherwise, it might be possible to incorrectly
+            // match entries used to generate other NFAs.
+            if self.version == 0 {
+                self.map = vec![Utf8BoundedEntry::default(); self.capacity];
+            }
+        }
+    }
+
+    /// Return a hash of the given transitions.
+    pub fn hash(&self, key: &[Transition]) -> usize {
+        let mut h = INIT;
+        for t in key {
+            h = (h ^ u64::from(t.start)).wrapping_mul(PRIME);
+            h = (h ^ u64::from(t.end)).wrapping_mul(PRIME);
+            h = (h ^ t.next.as_u64()).wrapping_mul(PRIME);
+        }
+        (h % self.map.len().as_u64()).as_usize()
+    }
+
+    /// Retrieve the cached state ID corresponding to the given key. The hash
+    /// given must have been computed with `hash` using the same key value.
+    ///
+    /// If there is no cached state with the given transitions, then None is
+    /// returned.
+    pub fn get(&mut self, key: &[Transition], hash: usize) -> Option<StateID> {
+        let entry = &self.map[hash];
+        if entry.version != self.version {
+            return None;
+        }
+        // There may be a hash collision, so we need to confirm real equality.
+        if entry.key != key {
+            return None;
+        }
+        Some(entry.val)
+    }
+
+    /// Add a cached state to this map with the given key. Callers should
+    /// ensure that `state_id` points to a state that contains precisely the
+    /// NFA transitions given.
+    ///
+    /// `hash` must have been computed using the `hash` method with the same
+    /// key.
+    pub fn set(
+        &mut self,
+        key: Vec<Transition>,
+        hash: usize,
+        state_id: StateID,
+    ) {
+        self.map[hash] =
+            Utf8BoundedEntry { version: self.version, key, val: state_id };
+    }
+}
+
+/// A cache of suffixes used to modestly compress UTF-8 automata for large
+/// Unicode character classes.
+#[derive(Clone, Debug)]
+pub struct Utf8SuffixMap {
+    /// The current version of this map. Only entries with matching versions
+    /// are considered during lookups. If an entry is found with a mismatched
+    /// version, then the map behaves as if the entry does not exist.
+    version: u16,
+    /// The total number of entries this map can store.
+    capacity: usize,
+    /// The actual entries, keyed by hash. Collisions between different states
+    /// result in the old state being dropped.
+    map: Vec<Utf8SuffixEntry>,
+}
+
+/// A key that uniquely identifies an NFA state. It is a triple that represents
+/// a transition from one state for a particular byte range.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct Utf8SuffixKey {
+    pub from: StateID,
+    pub start: u8,
+    pub end: u8,
+}
+
+/// An entry in this map.
+#[derive(Clone, Debug, Default)]
+struct Utf8SuffixEntry {
+    /// The version of the map used to produce this entry. If this entry's
+    /// version does not match the current version of the map, then the map
+    /// should behave as if this entry does not exist.
+    version: u16,
+    /// The key, which consists of a transition in a particular state.
+    key: Utf8SuffixKey,
+    /// The identifier that the transition in the key maps to.
+    val: StateID,
+}
+
+impl Utf8SuffixMap {
+    /// Create a new bounded map with the given capacity. The map will never
+    /// grow beyond the given size.
+    ///
+    /// Note that this does not allocate. Instead, callers must call `clear`
+    /// before using this map. `clear` will allocate space if necessary.
+    ///
+    /// This avoids the need to pay for the allocation of this map when
+    /// compiling regexes that lack large Unicode character classes.
+    pub fn new(capacity: usize) -> Utf8SuffixMap {
+        assert!(capacity > 0);
+        Utf8SuffixMap { version: 0, capacity, map: vec![] }
+    }
+
+    /// Clear this map of all entries, but permit the reuse of allocation
+    /// if possible.
+    ///
+    /// This must be called before the map can be used.
+    pub fn clear(&mut self) {
+        if self.map.is_empty() {
+            self.map = vec![Utf8SuffixEntry::default(); self.capacity];
+        } else {
+            self.version = self.version.wrapping_add(1);
+            if self.version == 0 {
+                self.map = vec![Utf8SuffixEntry::default(); self.capacity];
+            }
+        }
+    }
+
+    /// Return a hash of the given transition.
+    pub fn hash(&self, key: &Utf8SuffixKey) -> usize {
+        // Basic FNV-1a hash as described:
+        // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+        const PRIME: u64 = 1099511628211;
+        const INIT: u64 = 14695981039346656037;
+
+        let mut h = INIT;
+        h = (h ^ key.from.as_u64()).wrapping_mul(PRIME);
+        h = (h ^ u64::from(key.start)).wrapping_mul(PRIME);
+        h = (h ^ u64::from(key.end)).wrapping_mul(PRIME);
+        (h % self.map.len().as_u64()).as_usize()
+    }
+
+    /// Retrieve the cached state ID corresponding to the given key. The hash
+    /// given must have been computed with `hash` using the same key value.
+    ///
+    /// If there is no cached state with the given key, then None is returned.
+    pub fn get(
+        &mut self,
+        key: &Utf8SuffixKey,
+        hash: usize,
+    ) -> Option<StateID> {
+        let entry = &self.map[hash];
+        if entry.version != self.version {
+            return None;
+        }
+        if key != &entry.key {
+            return None;
+        }
+        Some(entry.val)
+    }
+
+    /// Add a cached state to this map with the given key. Callers should
+    /// ensure that `state_id` points to a state that contains precisely the
+    /// NFA transition given.
+    ///
+    /// `hash` must have been computed using the `hash` method with the same
+    /// key.
+    pub fn set(&mut self, key: Utf8SuffixKey, hash: usize, state_id: StateID) {
+        self.map[hash] =
+            Utf8SuffixEntry { version: self.version, key, val: state_id };
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/mod.rs b/regex-automata/src/nfa/thompson/mod.rs
new file mode 100644
index 0000000000..3581d738c2
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/mod.rs
@@ -0,0 +1,81 @@
+/*!
+Defines a Thompson NFA and provides the [`PikeVM`](pikevm::PikeVM) and
+[`BoundedBacktracker`](backtrack::BoundedBacktracker) regex engines.
+
+A Thompson NFA (non-deterministic finite automaton) is arguably _the_ central
+data type in this library. It is the result of what is commonly referred to as
+"regex compilation." That is, turning a regex pattern from its concrete syntax
+string into something that can run a search looks roughly like this:
+
+* A `&str` is parsed into a [`regex-syntax::ast::Ast`](regex_syntax::ast::Ast).
+* An `Ast` is translated into a [`regex-syntax::hir::Hir`](regex_syntax::hir::Hir).
+* An `Hir` is compiled into a [`NFA`].
+* The `NFA` is then used to build one of a few different regex engines:
+  * An `NFA` is used directly in the `PikeVM` and `BoundedBacktracker` engines.
+  * An `NFA` is used by a [hybrid NFA/DFA](crate::hybrid) to build out a DFA's
+  transition table at search time.
+  * An `NFA`, assuming it is one-pass, is used to build a full
+  [one-pass DFA](crate::dfa::onepass) ahead of time.
+  * An `NFA` is used to build a [full DFA](crate::dfa) ahead of time.
+
+The [`meta`](crate::meta) regex engine makes all of these choices for you based
+on various criteria. However, if you have a lower level use case, _you_ can
+build any of the above regex engines and use them directly. But you must start
+here by building an `NFA`.
+
+# Details
+
+It is perhaps worth expanding a bit more on what it means to go through the
+`&str`->`Ast`->`Hir`->`NFA` process.
+
+* Parsing a string into an `Ast` gives it a structured representation.
+Crucially, the size and amount of work done in this step is proportional to the
+size of the original string. No optimization or Unicode handling is done at
+this point. This means that parsing into an `Ast` has very predictable costs.
+Moreover, an `Ast` can be roundtripped back to its original pattern string as
+written.
+* Translating an `Ast` into an `Hir` is a process by which the structured
+representation is simplified down to its most fundamental components.
+Translation deals with flags such as case insensitivity by converting things
+like `(?i:a)` to `[Aa]`. Translation is also where Unicode tables are consulted
+to resolve things like `\p{Emoji}` and `\p{Greek}`. It also flattens each
+character class, regardless of how deeply nested it is, into a single sequence
+of non-overlapping ranges. All the various literal forms are thrown out in
+favor of one common representation. Overall, the `Hir` is small enough to fit
+into your head and makes analysis and other tasks much simpler.
+* Compiling an `Hir` into an `NFA` formulates the regex into a finite state
+machine whose transitions are defined over bytes. For example, an `Hir` might
+have a Unicode character class corresponding to a sequence of ranges defined
+in terms of `char`. Compilation is then responsible for turning those ranges
+into a UTF-8 automaton. That is, an automaton that matches the UTF-8 encoding
+of just the codepoints specified by those ranges. Otherwise, the main job of
+an `NFA` is to serve as a byte-code of sorts for a virtual machine. It can be
+seen as a sequence of instructions for how to match a regex.
+*/
+
+#[cfg(feature = "nfa-backtrack")]
+pub mod backtrack;
+mod builder;
+#[cfg(feature = "syntax")]
+mod compiler;
+mod error;
+#[cfg(feature = "syntax")]
+mod literal_trie;
+#[cfg(feature = "syntax")]
+mod map;
+mod nfa;
+#[cfg(feature = "nfa-pikevm")]
+pub mod pikevm;
+#[cfg(feature = "syntax")]
+mod range_trie;
+
+pub use self::{
+    builder::Builder,
+    error::BuildError,
+    nfa::{
+        DenseTransitions, PatternIter, SparseTransitions, State, Transition,
+        NFA,
+    },
+};
+#[cfg(feature = "syntax")]
+pub use compiler::{Compiler, Config};
diff --git a/regex-automata/src/nfa/thompson/nfa.rs b/regex-automata/src/nfa/thompson/nfa.rs
new file mode 100644
index 0000000000..6e46b04df9
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/nfa.rs
@@ -0,0 +1,2101 @@
+use core::{fmt, mem};
+
+use alloc::{boxed::Box, format, string::String, sync::Arc, vec, vec::Vec};
+
+#[cfg(feature = "syntax")]
+use crate::nfa::thompson::{
+    compiler::{Compiler, Config},
+    error::BuildError,
+};
+use crate::{
+    nfa::thompson::builder::Builder,
+    util::{
+        alphabet::{self, ByteClassSet, ByteClasses},
+        captures::{GroupInfo, GroupInfoError},
+        look::{Look, LookMatcher, LookSet},
+        primitives::{
+            IteratorIndexExt, PatternID, PatternIDIter, SmallIndex, StateID,
+        },
+        sparse_set::SparseSet,
+    },
+};
+
+/// A byte oriented Thompson non-deterministic finite automaton (NFA).
+///
+/// A Thompson NFA is a finite state machine that permits unconditional epsilon
+/// transitions, but guarantees that there exists at most one non-epsilon
+/// transition for each element in the alphabet for each state.
+///
+/// An NFA may be used directly for searching, for analysis or to build
+/// a deterministic finite automaton (DFA).
+///
+/// # Cheap clones
+///
+/// Since an NFA is a core data type in this crate that many other regex
+/// engines are based on top of, it is convenient to give ownership of an NFA
+/// to said regex engines. Because of this, an NFA uses reference counting
+/// internally. Therefore, it is cheap to clone and it is encouraged to do so.
+///
+/// # Capabilities
+///
+/// Using an NFA for searching via the
+/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) provides the most amount
+/// of "power" of any regex engine in this crate. Namely, it supports the
+/// following in all cases:
+///
+/// 1. Detection of a match.
+/// 2. Location of a match, including both the start and end offset, in a
+/// single pass of the haystack.
+/// 3. Location of matching capturing groups.
+/// 4. Handles multiple patterns, including (1)-(3) when multiple patterns are
+/// present.
+///
+/// # Capturing Groups
+///
+/// Groups refer to parenthesized expressions inside a regex pattern. They look
+/// like this, where `exp` is an arbitrary regex:
+///
+/// * `(exp)` - An unnamed capturing group.
+/// * `(?P<name>exp)` or `(?<name>exp)` - A named capturing group.
+/// * `(?:exp)` - A non-capturing group.
+/// * `(?i:exp)` - A non-capturing group that sets flags.
+///
+/// Only the first two forms are said to be _capturing_. Capturing
+/// means that the last position at which they match is reportable. The
+/// [`Captures`](crate::util::captures::Captures) type provides convenient
+/// access to the match positions of capturing groups, which includes looking
+/// up capturing groups by their name.
+///
+/// # Byte oriented
+///
+/// This NFA is byte oriented, which means that all of its transitions are
+/// defined on bytes. In other words, the alphabet of an NFA consists of the
+/// 256 different byte values.
+///
+/// While DFAs nearly demand that they be byte oriented for performance
+/// reasons, an NFA could conceivably be *Unicode codepoint* oriented. Indeed,
+/// a previous version of this NFA supported both byte and codepoint oriented
+/// modes. A codepoint oriented mode can work because an NFA fundamentally uses
+/// a sparse representation of transitions, which works well with the large
+/// sparse space of Unicode codepoints.
+///
+/// Nevertheless, this NFA is only byte oriented. This choice is primarily
+/// driven by implementation simplicity, and also in part memory usage. In
+/// practice, performance between the two is roughly comparable. However,
+/// building a DFA (including a hybrid DFA) really wants a byte oriented NFA.
+/// So if we do have a codepoint oriented NFA, then we also need to generate
+/// byte oriented NFA in order to build an hybrid NFA/DFA. Thus, by only
+/// generating byte oriented NFAs, we can produce one less NFA. In other words,
+/// if we made our NFA codepoint oriented, we'd need to *also* make it support
+/// a byte oriented mode, which is more complicated. But a byte oriented mode
+/// can support everything.
+///
+/// # Differences with DFAs
+///
+/// At the theoretical level, the precise difference between an NFA and a DFA
+/// is that, in a DFA, for every state, an input symbol unambiguously refers
+/// to a single transition _and_ that an input symbol is required for each
+/// transition. At a practical level, this permits DFA implementations to be
+/// implemented at their core with a small constant number of CPU instructions
+/// for each byte of input searched. In practice, this makes them quite a bit
+/// faster than NFAs _in general_. Namely, in order to execute a search for any
+/// Thompson NFA, one needs to keep track of a _set_ of states, and execute
+/// the possible transitions on all of those states for each input symbol.
+/// Overall, this results in much more overhead. To a first approximation, one
+/// can expect DFA searches to be about an order of magnitude faster.
+///
+/// So why use an NFA at all? The main advantage of an NFA is that it takes
+/// linear time (in the size of the pattern string after repetitions have been
+/// expanded) to build and linear memory usage. A DFA, on the other hand, may
+/// take exponential time and/or space to build. Even in non-pathological
+/// cases, DFAs often take quite a bit more memory than their NFA counterparts,
+/// _especially_ if large Unicode character classes are involved. Of course,
+/// an NFA also provides additional capabilities. For example, it can match
+/// Unicode word boundaries on non-ASCII text and resolve the positions of
+/// capturing groups.
+///
+/// Note that a [`hybrid::regex::Regex`](crate::hybrid::regex::Regex) strikes a
+/// good balance between an NFA and a DFA. It avoids the exponential build time
+/// of a DFA while maintaining its fast search time. The downside of a hybrid
+/// NFA/DFA is that in some cases it can be slower at search time than the NFA.
+/// (It also has less functionality than a pure NFA. It cannot handle Unicode
+/// word boundaries on non-ASCII text and cannot resolve capturing groups.)
+///
+/// # Example
+///
+/// This shows how to build an NFA with the default configuration and execute a
+/// search using the Pike VM.
+///
+/// ```
+/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+///
+/// let re = PikeVM::new(r"foo[0-9]+")?;
+/// let mut cache = re.create_cache();
+/// let mut caps = re.create_captures();
+///
+/// let expected = Some(Match::must(0, 0..8));
+/// re.captures(&mut cache, b"foo12345", &mut caps);
+/// assert_eq!(expected, caps.get_match());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: resolving capturing groups
+///
+/// This example shows how to parse some simple dates and extract the
+/// components of each date via capturing groups.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     util::captures::Captures,
+/// };
+///
+/// let vm = PikeVM::new(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})")?;
+/// let mut cache = vm.create_cache();
+///
+/// let haystack = "2012-03-14, 2013-01-01 and 2014-07-05";
+/// let all: Vec<Captures> = vm.captures_iter(
+///     &mut cache, haystack.as_bytes()
+/// ).collect();
+/// // There should be a total of 3 matches.
+/// assert_eq!(3, all.len());
+/// // The year from the second match is '2013'.
+/// let span = all[1].get_group_by_name("y").unwrap();
+/// assert_eq!("2013", &haystack[span]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// This example shows that only the last match of a capturing group is
+/// reported, even if it had to match multiple times for an overall match
+/// to occur.
+///
+/// ```
+/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+///
+/// let re = PikeVM::new(r"([a-z]){4}")?;
+/// let mut cache = re.create_cache();
+/// let mut caps = re.create_captures();
+///
+/// let haystack = b"quux";
+/// re.captures(&mut cache, haystack, &mut caps);
+/// assert!(caps.is_match());
+/// assert_eq!(Some(Span::from(3..4)), caps.get_group(1));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone)]
+pub struct NFA(
+    // We make NFAs reference counted primarily for two reasons. First is that
+    // the NFA type itself is quite large (at least 0.5KB), and so it makes
+    // sense to put it on the heap by default anyway. Second is that, for Arc
+    // specifically, this enables cheap clones. This tends to be useful because
+    // several structures (the backtracker, the Pike VM, the hybrid NFA/DFA)
+    // all want to hang on to an NFA for use during search time. We could
+    // provide the NFA at search time via a function argument, but this makes
+    // for an unnecessarily annoying API. Instead, we just let each structure
+    // share ownership of the NFA. Using a deep clone would not be smart, since
+    // the NFA can use quite a bit of heap space.
+    Arc<Inner>,
+);
+
+impl NFA {
+    /// Parse the given regular expression using a default configuration and
+    /// build an NFA from it.
+    ///
+    /// If you want a non-default configuration, then use the NFA
+    /// [`Compiler`] with a [`Config`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new(r"foo[0-9]+")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let expected = Some(Match::must(0, 0..8));
+    /// re.captures(&mut cache, b"foo12345", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<NFA, BuildError> {
+        NFA::compiler().build(pattern)
+    }
+
+    /// Parse the given regular expressions using a default configuration and
+    /// build a multi-NFA from them.
+    ///
+    /// If you want a non-default configuration, then use the NFA
+    /// [`Compiler`] with a [`Config`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new_many(&["[0-9]+", "[a-z]+"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let expected = Some(Match::must(1, 0..3));
+    /// re.captures(&mut cache, b"foo12345bar", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(patterns: &[P]) -> Result<NFA, BuildError> {
+        NFA::compiler().build_many(patterns)
+    }
+
+    /// Returns an NFA with a single regex pattern that always matches at every
+    /// position.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    ///
+    /// let re = PikeVM::new_from_nfa(NFA::always_match())?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let expected = Some(Match::must(0, 0..0));
+    /// re.captures(&mut cache, b"", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    /// re.captures(&mut cache, b"foo", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> NFA {
+        // We could use NFA::new("") here and we'd get the same semantics, but
+        // hand-assembling the NFA (as below) does the same thing with a fewer
+        // number of states. It also avoids needing the 'syntax' feature
+        // enabled.
+        //
+        // Technically all we need is the "match" state, but we add the
+        // "capture" states so that the PikeVM can use this NFA.
+        //
+        // The unwraps below are OK because we add so few states that they will
+        // never exhaust any default limits in any environment.
+        let mut builder = Builder::new();
+        let pid = builder.start_pattern().unwrap();
+        assert_eq!(pid.as_usize(), 0);
+        let start_id =
+            builder.add_capture_start(StateID::ZERO, 0, None).unwrap();
+        let end_id = builder.add_capture_end(StateID::ZERO, 0).unwrap();
+        let match_id = builder.add_match().unwrap();
+        builder.patch(start_id, end_id).unwrap();
+        builder.patch(end_id, match_id).unwrap();
+        let pid = builder.finish_pattern(start_id).unwrap();
+        assert_eq!(pid.as_usize(), 0);
+        builder.build(start_id, start_id).unwrap()
+    }
+
+    /// Returns an NFA that never matches at any position.
+    ///
+    /// This is a convenience routine for creating an NFA with zero patterns.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::{NFA, pikevm::PikeVM};
+    ///
+    /// let re = PikeVM::new_from_nfa(NFA::never_match())?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, b"", &mut caps);
+    /// assert!(!caps.is_match());
+    /// re.captures(&mut cache, b"foo", &mut caps);
+    /// assert!(!caps.is_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> NFA {
+        // This always succeeds because it only requires one NFA state, which
+        // will never exhaust any (default) limits.
+        let mut builder = Builder::new();
+        let sid = builder.add_fail().unwrap();
+        builder.build(sid, sid).unwrap()
+    }
+
+    /// Return a default configuration for an `NFA`.
+    ///
+    /// This is a convenience routine to avoid needing to import the `Config`
+    /// type when customizing the construction of an NFA.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build an NFA with a small size limit that
+    /// results in a compilation error for any regex that tries to use more
+    /// heap memory than the configured limit.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::{NFA, pikevm::PikeVM};
+    ///
+    /// let result = PikeVM::builder()
+    ///     .thompson(NFA::config().nfa_size_limit(Some(1_000)))
+    ///     // Remember, \w is Unicode-aware by default and thus huge.
+    ///     .build(r"\w+");
+    /// assert!(result.is_err());
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a compiler for configuring the construction of an `NFA`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Compiler`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build an NFA that is permitted match invalid
+    /// UTF-8. Without the additional syntax configuration here, compilation of
+    /// `(?-u:.)` would fail because it is permitted to match invalid UTF-8.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::syntax,
+    ///     Match,
+    /// };
+    ///
+    /// let re = PikeVM::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .build(r"[a-z]+(?-u:.)")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let expected = Some(Match::must(0, 1..5));
+    /// re.captures(&mut cache, b"\xFFabc\xFF", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn compiler() -> Compiler {
+        Compiler::new()
+    }
+
+    /// Returns an iterator over all pattern identifiers in this NFA.
+    ///
+    /// Pattern IDs are allocated in sequential order starting from zero,
+    /// where the order corresponds to the order of patterns provided to the
+    /// [`NFA::new_many`] constructor.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// let pids: Vec<PatternID> = nfa.patterns().collect();
+    /// assert_eq!(pids, vec![
+    ///     PatternID::must(0),
+    ///     PatternID::must(1),
+    ///     PatternID::must(2),
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn patterns(&self) -> PatternIter<'_> {
+        PatternIter {
+            it: PatternID::iter(self.pattern_len()),
+            _marker: core::marker::PhantomData,
+        }
+    }
+
+    /// Returns the total number of regex patterns in this NFA.
+    ///
+    /// This may return zero if the NFA was constructed with no patterns. In
+    /// this case, the NFA can never produce a match for any input.
+    ///
+    /// This is guaranteed to be no bigger than [`PatternID::LIMIT`] because
+    /// NFA construction will fail if too many patterns are added.
+    ///
+    /// It is always true that `nfa.patterns().count() == nfa.pattern_len()`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa = NFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(3, nfa.pattern_len());
+    ///
+    /// let nfa = NFA::never_match();
+    /// assert_eq!(0, nfa.pattern_len());
+    ///
+    /// let nfa = NFA::always_match();
+    /// assert_eq!(1, nfa.pattern_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn pattern_len(&self) -> usize {
+        self.0.start_pattern.len()
+    }
+
+    /// Return the state identifier of the initial anchored state of this NFA.
+    ///
+    /// The returned identifier is guaranteed to be a valid index into the
+    /// slice returned by [`NFA::states`], and is also a valid argument to
+    /// [`NFA::state`].
+    ///
+    /// # Example
+    ///
+    /// This example shows a somewhat contrived example where we can easily
+    /// predict the anchored starting state.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::{NFA, State};
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build("a")?;
+    /// let state = nfa.state(nfa.start_anchored());
+    /// match *state {
+    ///     State::ByteRange { trans } => {
+    ///         assert_eq!(b'a', trans.start);
+    ///         assert_eq!(b'a', trans.end);
+    ///     }
+    ///     _ => unreachable!("unexpected state"),
+    /// }
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn start_anchored(&self) -> StateID {
+        self.0.start_anchored
+    }
+
+    /// Return the state identifier of the initial unanchored state of this
+    /// NFA.
+    ///
+    /// This is equivalent to the identifier returned by
+    /// [`NFA::start_anchored`] when the NFA has no unanchored starting state.
+    ///
+    /// The returned identifier is guaranteed to be a valid index into the
+    /// slice returned by [`NFA::states`], and is also a valid argument to
+    /// [`NFA::state`].
+    ///
+    /// # Example
+    ///
+    /// This example shows that the anchored and unanchored starting states
+    /// are equivalent when an anchored NFA is built.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa = NFA::new("^a")?;
+    /// assert_eq!(nfa.start_anchored(), nfa.start_unanchored());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn start_unanchored(&self) -> StateID {
+        self.0.start_unanchored
+    }
+
+    /// Return the state identifier of the initial anchored state for the given
+    /// pattern, or `None` if there is no pattern corresponding to the given
+    /// identifier.
+    ///
+    /// If one uses the starting state for a particular pattern, then the only
+    /// match that can be returned is for the corresponding pattern.
+    ///
+    /// The returned identifier is guaranteed to be a valid index into the
+    /// slice returned by [`NFA::states`], and is also a valid argument to
+    /// [`NFA::state`].
+    ///
+    /// # Errors
+    ///
+    /// If the pattern doesn't exist in this NFA, then this returns an error.
+    /// This occurs when `pid.as_usize() >= nfa.pattern_len()`.
+    ///
+    /// # Example
+    ///
+    /// This example shows that the anchored and unanchored starting states
+    /// are equivalent when an anchored NFA is built.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new_many(&["^a", "^b"])?;
+    /// // The anchored and unanchored states for the entire NFA are the same,
+    /// // since all of the patterns are anchored.
+    /// assert_eq!(nfa.start_anchored(), nfa.start_unanchored());
+    /// // But the anchored starting states for each pattern are distinct,
+    /// // because these starting states can only lead to matches for the
+    /// // corresponding pattern.
+    /// let anchored = Some(nfa.start_anchored());
+    /// assert_ne!(anchored, nfa.start_pattern(PatternID::must(0)));
+    /// assert_ne!(anchored, nfa.start_pattern(PatternID::must(1)));
+    /// // Requesting a pattern not in the NFA will result in None:
+    /// assert_eq!(None, nfa.start_pattern(PatternID::must(2)));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn start_pattern(&self, pid: PatternID) -> Option<StateID> {
+        self.0.start_pattern.get(pid.as_usize()).copied()
+    }
+
+    /// Get the byte class set for this NFA.
+    ///
+    /// A byte class set is a partitioning of this NFA's alphabet into
+    /// equivalence classes. Any two bytes in the same equivalence class are
+    /// guaranteed to never discriminate between a match or a non-match. (The
+    /// partitioning may not be minimal.)
+    ///
+    /// Byte classes are used internally by this crate when building DFAs.
+    /// Namely, among other optimizations, they enable a space optimization
+    /// where the DFA's internal alphabet is defined over the equivalence
+    /// classes of bytes instead of all possible byte values. The former is
+    /// often quite a bit smaller than the latter, which permits the DFA to use
+    /// less space for its transition table.
+    #[inline]
+    pub(crate) fn byte_class_set(&self) -> &ByteClassSet {
+        &self.0.byte_class_set
+    }
+
+    /// Get the byte classes for this NFA.
+    ///
+    /// Byte classes represent a partitioning of this NFA's alphabet into
+    /// equivalence classes. Any two bytes in the same equivalence class are
+    /// guaranteed to never discriminate between a match or a non-match. (The
+    /// partitioning may not be minimal.)
+    ///
+    /// Byte classes are used internally by this crate when building DFAs.
+    /// Namely, among other optimizations, they enable a space optimization
+    /// where the DFA's internal alphabet is defined over the equivalence
+    /// classes of bytes instead of all possible byte values. The former is
+    /// often quite a bit smaller than the latter, which permits the DFA to use
+    /// less space for its transition table.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to query the class of various bytes.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa = NFA::new("[a-z]+")?;
+    /// let classes = nfa.byte_classes();
+    /// // 'a' and 'z' are in the same class for this regex.
+    /// assert_eq!(classes.get(b'a'), classes.get(b'z'));
+    /// // But 'a' and 'A' are not.
+    /// assert_ne!(classes.get(b'a'), classes.get(b'A'));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn byte_classes(&self) -> &ByteClasses {
+        &self.0.byte_classes
+    }
+
+    /// Return a reference to the NFA state corresponding to the given ID.
+    ///
+    /// This is a convenience routine for `nfa.states()[id]`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when the given identifier does not reference a valid state.
+    /// That is, when `id.as_usize() >= nfa.states().len()`.
+    ///
+    /// # Example
+    ///
+    /// The anchored state for a pattern will typically correspond to a
+    /// capturing state for that pattern. (Although, this is not an API
+    /// guarantee!)
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, State}, PatternID};
+    ///
+    /// let nfa = NFA::new("a")?;
+    /// let state = nfa.state(nfa.start_pattern(PatternID::ZERO).unwrap());
+    /// match *state {
+    ///     State::Capture { slot, .. } => {
+    ///         assert_eq!(0, slot.as_usize());
+    ///     }
+    ///     _ => unreachable!("unexpected state"),
+    /// }
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn state(&self, id: StateID) -> &State {
+        &self.states()[id]
+    }
+
+    /// Returns a slice of all states in this NFA.
+    ///
+    /// The slice returned is indexed by `StateID`. This provides a convenient
+    /// way to access states while following transitions among those states.
+    ///
+    /// # Example
+    ///
+    /// This demonstrates that disabling UTF-8 mode can shrink the size of the
+    /// NFA considerably in some cases, especially when using Unicode character
+    /// classes.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa_unicode = NFA::new(r"\w")?;
+    /// let nfa_ascii = NFA::new(r"(?-u)\w")?;
+    /// // Yes, a factor of 45 difference. No lie.
+    /// assert!(40 * nfa_ascii.states().len() < nfa_unicode.states().len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn states(&self) -> &[State] {
+        &self.0.states
+    }
+
+    /// Returns the capturing group info for this NFA.
+    ///
+    /// The [`GroupInfo`] provides a way to map to and from capture index
+    /// and capture name for each pattern. It also provides a mapping from
+    /// each of the capturing groups in every pattern to their corresponding
+    /// slot offsets encoded in [`State::Capture`] states.
+    ///
+    /// Note that `GroupInfo` uses reference counting internally, such that
+    /// cloning a `GroupInfo` is very cheap.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get a list of all capture group names for
+    /// a particular pattern.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new(r"(a)(?P<foo>b)(c)(d)(?P<bar>e)")?;
+    /// // The first is the implicit group that is always unnammed. The next
+    /// // 5 groups are the explicit groups found in the concrete syntax above.
+    /// let expected = vec![None, None, Some("foo"), None, None, Some("bar")];
+    /// let got: Vec<Option<&str>> =
+    ///     nfa.group_info().pattern_names(PatternID::ZERO).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// // Using an invalid pattern ID will result in nothing yielded.
+    /// let got = nfa.group_info().pattern_names(PatternID::must(999)).count();
+    /// assert_eq!(0, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn group_info(&self) -> &GroupInfo {
+        &self.0.group_info()
+    }
+
+    /// Returns true if and only if this NFA has at least one
+    /// [`Capture`](State::Capture) in its sequence of states.
+    ///
+    /// This is useful as a way to perform a quick test before attempting
+    /// something that does or does not require capture states. For example,
+    /// some regex engines (like the PikeVM) require capture states in order to
+    /// work at all.
+    ///
+    /// # Example
+    ///
+    /// This example shows a few different NFAs and whether they have captures
+    /// or not.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// // Obviously has capture states.
+    /// let nfa = NFA::new("(a)")?;
+    /// assert!(nfa.has_capture());
+    ///
+    /// // Less obviously has capture states, because every pattern has at
+    /// // least one anonymous capture group corresponding to the match for the
+    /// // entire pattern.
+    /// let nfa = NFA::new("a")?;
+    /// assert!(nfa.has_capture());
+    ///
+    /// // Other than hand building your own NFA, this is the only way to build
+    /// // an NFA without capturing groups. In general, you should only do this
+    /// // if you don't intend to use any of the NFA-oriented regex engines.
+    /// // Overall, capturing groups don't have many downsides. Although they
+    /// // can add a bit of noise to simple NFAs, so it can be nice to disable
+    /// // them for debugging purposes.
+    /// //
+    /// // Notice that 'has_capture' is false here even when we have an
+    /// // explicit capture group in the pattern.
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build("(a)")?;
+    /// assert!(!nfa.has_capture());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn has_capture(&self) -> bool {
+        self.0.has_capture
+    }
+
+    /// Returns true if and only if this NFA can match the empty string.
+    /// When it returns false, all possible matches are guaranteed to have a
+    /// non-zero length.
+    ///
+    /// This is useful as cheap way to know whether code needs to handle the
+    /// case of a zero length match. This is particularly important when UTF-8
+    /// modes are enabled, as when UTF-8 mode is enabled, empty matches that
+    /// split a codepoint must never be reported. This extra handling can
+    /// sometimes be costly, and since regexes matching an empty string are
+    /// somewhat rare, it can be beneficial to treat such regexes specially.
+    ///
+    /// # Example
+    ///
+    /// This example shows a few different NFAs and whether they match the
+    /// empty string or not. Notice the empty string isn't merely a matter
+    /// of a string of length literally `0`, but rather, whether a match can
+    /// occur between specific pairs of bytes.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::syntax};
+    ///
+    /// // The empty regex matches the empty string.
+    /// let nfa = NFA::new("")?;
+    /// assert!(nfa.has_empty(), "empty matches empty");
+    /// // The '+' repetition operator requires at least one match, and so
+    /// // does not match the empty string.
+    /// let nfa = NFA::new("a+")?;
+    /// assert!(!nfa.has_empty(), "+ does not match empty");
+    /// // But the '*' repetition operator does.
+    /// let nfa = NFA::new("a*")?;
+    /// assert!(nfa.has_empty(), "* does match empty");
+    /// // And wrapping '+' in an operator that can match an empty string also
+    /// // causes it to match the empty string too.
+    /// let nfa = NFA::new("(a+)*")?;
+    /// assert!(nfa.has_empty(), "+ inside of * matches empty");
+    ///
+    /// // If a regex is just made of a look-around assertion, even if the
+    /// // assertion requires some kind of non-empty string around it (such as
+    /// // \b), then it is still treated as if it matches the empty string.
+    /// // Namely, if a match occurs of just a look-around assertion, then the
+    /// // match returned is empty.
+    /// let nfa = NFA::compiler()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .build(r"^$\A\z\b\B(?-u:\b\B)")?;
+    /// assert!(nfa.has_empty(), "assertions match empty");
+    /// // Even when an assertion is wrapped in a '+', it still matches the
+    /// // empty string.
+    /// let nfa = NFA::new(r"\b+")?;
+    /// assert!(nfa.has_empty(), "+ of an assertion matches empty");
+    ///
+    /// // An alternation with even one branch that can match the empty string
+    /// // is also said to match the empty string overall.
+    /// let nfa = NFA::new("foo|(bar)?|quux")?;
+    /// assert!(nfa.has_empty(), "alternations can match empty");
+    ///
+    /// // An NFA that matches nothing does not match the empty string.
+    /// let nfa = NFA::new("[a&&b]")?;
+    /// assert!(!nfa.has_empty(), "never matching means not matching empty");
+    /// // But if it's wrapped in something that doesn't require a match at
+    /// // all, then it can match the empty string!
+    /// let nfa = NFA::new("[a&&b]*")?;
+    /// assert!(nfa.has_empty(), "* on never-match still matches empty");
+    /// // Since a '+' requires a match, using it on something that can never
+    /// // match will itself produce a regex that can never match anything,
+    /// // and thus does not match the empty string.
+    /// let nfa = NFA::new("[a&&b]+")?;
+    /// assert!(!nfa.has_empty(), "+ on never-match still matches nothing");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn has_empty(&self) -> bool {
+        self.0.has_empty
+    }
+
+    /// Whether UTF-8 mode is enabled for this NFA or not.
+    ///
+    /// When UTF-8 mode is enabled, all matches reported by a regex engine
+    /// derived from this NFA are guaranteed to correspond to spans of valid
+    /// UTF-8. This includes zero-width matches. For example, the regex engine
+    /// must guarantee that the empty regex will not match at the positions
+    /// between code units in the UTF-8 encoding of a single codepoint.
+    ///
+    /// See [`Config::utf8`] for more information.
+    ///
+    /// This is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows how UTF-8 mode can impact the match spans that may
+    /// be reported in certain cases.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, pikevm::PikeVM},
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = PikeVM::new("")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// // UTF-8 mode is enabled by default.
+    /// let mut input = Input::new("☃");
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..0)), caps.get_match());
+    ///
+    /// // Even though an empty regex matches at 1..1, our next match is
+    /// // 3..3 because 1..1 and 2..2 split the snowman codepoint (which is
+    /// // three bytes long).
+    /// input.set_start(1);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 3..3)), caps.get_match());
+    ///
+    /// // But if we disable UTF-8, then we'll get matches at 1..1 and 2..2:
+    /// let re = PikeVM::builder()
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build("")?;
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 1..1)), caps.get_match());
+    ///
+    /// input.set_start(2);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 2..2)), caps.get_match());
+    ///
+    /// input.set_start(3);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 3..3)), caps.get_match());
+    ///
+    /// input.set_start(4);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_utf8(&self) -> bool {
+        self.0.utf8
+    }
+
+    /// Returns true when this NFA is meant to be matched in reverse.
+    ///
+    /// Generally speaking, when this is true, it means the NFA is supposed to
+    /// be used in conjunction with moving backwards through the haystack. That
+    /// is, from a higher memory address to a lower memory address.
+    ///
+    /// It is often the case that lower level routines dealing with an NFA
+    /// don't need to care about whether it is "meant" to be matched in reverse
+    /// or not. However, there are some specific cases where it matters. For
+    /// example, the implementation of CRLF-aware `^` and `$` line anchors
+    /// needs to know whether the search is in the forward or reverse
+    /// direction. In the forward direction, neither `^` nor `$` should match
+    /// when a `\r` has been seen previously and a `\n` is next. However, in
+    /// the reverse direction, neither `^` nor `$` should match when a `\n`
+    /// has been seen previously and a `\r` is next. This fundamentally changes
+    /// how the state machine is constructed, and thus needs to be altered
+    /// based on the direction of the search.
+    ///
+    /// This is automatically set when using a [`Compiler`] with a configuration
+    /// where [`Config::reverse`] is enabled. If you're building your own NFA
+    /// by hand via a [`Builder`]
+    #[inline]
+    pub fn is_reverse(&self) -> bool {
+        self.0.reverse
+    }
+
+    /// Returns true if and only if all starting states for this NFA correspond
+    /// to the beginning of an anchored search.
+    ///
+    /// Typically, an NFA will have both an anchored and an unanchored starting
+    /// state. Namely, because it tends to be useful to have both and the cost
+    /// of having an unanchored starting state is almost zero (for an NFA).
+    /// However, if all patterns in the NFA are themselves anchored, then even
+    /// the unanchored starting state will correspond to an anchored search
+    /// since the pattern doesn't permit anything else.
+    ///
+    /// # Example
+    ///
+    /// This example shows a few different scenarios where this method's
+    /// return value varies.
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// // The unanchored starting state permits matching this pattern anywhere
+    /// // in a haystack, instead of just at the beginning.
+    /// let nfa = NFA::new("a")?;
+    /// assert!(!nfa.is_always_start_anchored());
+    ///
+    /// // In this case, the pattern is itself anchored, so there is no way
+    /// // to run an unanchored search.
+    /// let nfa = NFA::new("^a")?;
+    /// assert!(nfa.is_always_start_anchored());
+    ///
+    /// // When multiline mode is enabled, '^' can match at the start of a line
+    /// // in addition to the start of a haystack, so an unanchored search is
+    /// // actually possible.
+    /// let nfa = NFA::new("(?m)^a")?;
+    /// assert!(!nfa.is_always_start_anchored());
+    ///
+    /// // Weird cases also work. A pattern is only considered anchored if all
+    /// // matches may only occur at the start of a haystack.
+    /// let nfa = NFA::new("(^a)|a")?;
+    /// assert!(!nfa.is_always_start_anchored());
+    ///
+    /// // When multiple patterns are present, if they are all anchored, then
+    /// // the NFA is always anchored too.
+    /// let nfa = NFA::new_many(&["^a", "^b", "^c"])?;
+    /// assert!(nfa.is_always_start_anchored());
+    ///
+    /// // But if one pattern is unanchored, then the NFA must permit an
+    /// // unanchored search.
+    /// let nfa = NFA::new_many(&["^a", "b", "^c"])?;
+    /// assert!(!nfa.is_always_start_anchored());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_always_start_anchored(&self) -> bool {
+        self.start_anchored() == self.start_unanchored()
+    }
+
+    /// Returns the look-around matcher associated with this NFA.
+    ///
+    /// A look-around matcher determines how to match look-around assertions.
+    /// In particular, some assertions are configurable. For example, the
+    /// `(?m:^)` and `(?m:$)` assertions can have their line terminator changed
+    /// from the default of `\n` to any other byte.
+    ///
+    /// If the NFA was built using a [`Compiler`], then this matcher
+    /// can be set via the [`Config::look_matcher`] configuration
+    /// knob. Otherwise, if you've built an NFA by hand, it is set via
+    /// [`Builder::set_look_matcher`].
+    ///
+    /// # Example
+    ///
+    /// This shows how to change the line terminator for multi-line assertions.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, pikevm::PikeVM},
+    ///     util::look::LookMatcher,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let mut lookm = LookMatcher::new();
+    /// lookm.set_line_terminator(b'\x00');
+    ///
+    /// let re = PikeVM::builder()
+    ///     .thompson(thompson::Config::new().look_matcher(lookm))
+    ///     .build(r"(?m)^[a-z]+$")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// // Multi-line assertions now use NUL as a terminator.
+    /// assert_eq!(
+    ///     Some(Match::must(0, 1..4)),
+    ///     re.find(&mut cache, b"\x00abc\x00"),
+    /// );
+    /// // ... and \n is no longer recognized as a terminator.
+    /// assert_eq!(
+    ///     None,
+    ///     re.find(&mut cache, b"\nabc\n"),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn look_matcher(&self) -> &LookMatcher {
+        &self.0.look_matcher
+    }
+
+    /// Returns the union of all look-around assertions used throughout this
+    /// NFA. When the returned set is empty, it implies that the NFA has no
+    /// look-around assertions and thus zero conditional epsilon transitions.
+    ///
+    /// This is useful in some cases enabling optimizations. It is not
+    /// unusual, for example, for optimizations to be of the form, "for any
+    /// regex with zero conditional epsilon transitions, do ..." where "..."
+    /// is some kind of optimization.
+    ///
+    /// This isn't only helpful for optimizations either. Sometimes look-around
+    /// assertions are difficult to support. For example, many of the DFAs in
+    /// this crate don't support Unicode word boundaries or handle them using
+    /// heuristics. Handling that correctly typically requires some kind of
+    /// cheap check of whether the NFA has a Unicode word boundary in the first
+    /// place.
+    ///
+    /// # Example
+    ///
+    /// This example shows how this routine varies based on the regex pattern:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::look::Look};
+    ///
+    /// // No look-around at all.
+    /// let nfa = NFA::new("a")?;
+    /// assert!(nfa.look_set_any().is_empty());
+    ///
+    /// // When multiple patterns are present, since this returns the union,
+    /// // it will include look-around assertions that only appear in one
+    /// // pattern.
+    /// let nfa = NFA::new_many(&["a", "b", "a^b", "c"])?;
+    /// assert!(nfa.look_set_any().contains(Look::Start));
+    ///
+    /// // Some groups of assertions have various shortcuts. For example:
+    /// let nfa = NFA::new(r"(?-u:\b)")?;
+    /// assert!(nfa.look_set_any().contains_word());
+    /// assert!(!nfa.look_set_any().contains_word_unicode());
+    /// assert!(nfa.look_set_any().contains_word_ascii());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn look_set_any(&self) -> LookSet {
+        self.0.look_set_any
+    }
+
+    /// Returns the union of all prefix look-around assertions for every
+    /// pattern in this NFA. When the returned set is empty, it implies none of
+    /// the patterns require moving through a conditional epsilon transition
+    /// before inspecting the first byte in the haystack.
+    ///
+    /// This can be useful for determining what kinds of assertions need to be
+    /// satisfied at the beginning of a search. For example, typically DFAs
+    /// in this crate will build a distinct starting state for each possible
+    /// starting configuration that might result in look-around assertions
+    /// being satisfied differently. However, if the set returned here is
+    /// empty, then you know that the start state is invariant because there
+    /// are no conditional epsilon transitions to consider.
+    ///
+    /// # Example
+    ///
+    /// This example shows how this routine varies based on the regex pattern:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::look::Look};
+    ///
+    /// // No look-around at all.
+    /// let nfa = NFA::new("a")?;
+    /// assert!(nfa.look_set_prefix_any().is_empty());
+    ///
+    /// // When multiple patterns are present, since this returns the union,
+    /// // it will include look-around assertions that only appear in one
+    /// // pattern. But it will only include assertions that are in the prefix
+    /// // of a pattern. For example, this includes '^' but not '$' even though
+    /// // '$' does appear.
+    /// let nfa = NFA::new_many(&["a", "b", "^ab$", "c"])?;
+    /// assert!(nfa.look_set_prefix_any().contains(Look::Start));
+    /// assert!(!nfa.look_set_prefix_any().contains(Look::End));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn look_set_prefix_any(&self) -> LookSet {
+        self.0.look_set_prefix_any
+    }
+
+    // FIXME: The `look_set_prefix_all` computation was not correct, and it
+    // seemed a little tricky to fix it. Since I wasn't actually using it for
+    // anything, I just decided to remove it in the run up to the regex 1.9
+    // release. If you need this, please file an issue.
+    /*
+    /// Returns the intersection of all prefix look-around assertions for every
+    /// pattern in this NFA. When the returned set is empty, it implies at
+    /// least one of the patterns does not require moving through a conditional
+    /// epsilon transition before inspecting the first byte in the haystack.
+    /// Conversely, when the set contains an assertion, it implies that every
+    /// pattern in the NFA also contains that assertion in its prefix.
+    ///
+    /// This can be useful for determining what kinds of assertions need to be
+    /// satisfied at the beginning of a search. For example, if you know that
+    /// [`Look::Start`] is in the prefix intersection set returned here, then
+    /// you know that all searches, regardless of input configuration, will be
+    /// anchored.
+    ///
+    /// # Example
+    ///
+    /// This example shows how this routine varies based on the regex pattern:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::look::Look};
+    ///
+    /// // No look-around at all.
+    /// let nfa = NFA::new("a")?;
+    /// assert!(nfa.look_set_prefix_all().is_empty());
+    ///
+    /// // When multiple patterns are present, since this returns the
+    /// // intersection, it will only include assertions present in every
+    /// // prefix, and only the prefix.
+    /// let nfa = NFA::new_many(&["^a$", "^b$", "$^ab$", "^c$"])?;
+    /// assert!(nfa.look_set_prefix_all().contains(Look::Start));
+    /// assert!(!nfa.look_set_prefix_all().contains(Look::End));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn look_set_prefix_all(&self) -> LookSet {
+        self.0.look_set_prefix_all
+    }
+    */
+
+    /// Returns the memory usage, in bytes, of this NFA.
+    ///
+    /// This does **not** include the stack size used up by this NFA. To
+    /// compute that, use `std::mem::size_of::<NFA>()`.
+    ///
+    /// # Example
+    ///
+    /// This example shows that large Unicode character classes can use quite
+    /// a bit of memory.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa_unicode = NFA::new(r"\w")?;
+    /// let nfa_ascii = NFA::new(r"(?-u:\w)")?;
+    ///
+    /// assert!(10 * nfa_ascii.memory_usage() < nfa_unicode.memory_usage());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn memory_usage(&self) -> usize {
+        use core::mem::size_of;
+
+        size_of::<Inner>() // allocated on the heap via Arc
+            + self.0.states.len() * size_of::<State>()
+            + self.0.start_pattern.len() * size_of::<StateID>()
+            + self.0.group_info.memory_usage()
+            + self.0.memory_extra
+    }
+}
+
+impl fmt::Debug for NFA {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+/// The "inner" part of the NFA. We split this part out so that we can easily
+/// wrap it in an `Arc` above in the definition of `NFA`.
+///
+/// See builder.rs for the code that actually builds this type. This module
+/// does provide (internal) mutable methods for adding things to this
+/// NFA before finalizing it, but the high level construction process is
+/// controlled by the builder abstraction. (Which is complicated enough to
+/// get its own module.)
+#[derive(Default)]
+pub(super) struct Inner {
+    /// The state sequence. This sequence is guaranteed to be indexable by all
+    /// starting state IDs, and it is also guaranteed to contain at most one
+    /// `Match` state for each pattern compiled into this NFA. (A pattern may
+    /// not have a corresponding `Match` state if a `Match` state is impossible
+    /// to reach.)
+    states: Vec<State>,
+    /// The anchored starting state of this NFA.
+    start_anchored: StateID,
+    /// The unanchored starting state of this NFA.
+    start_unanchored: StateID,
+    /// The starting states for each individual pattern. Starting at any
+    /// of these states will result in only an anchored search for the
+    /// corresponding pattern. The vec is indexed by pattern ID. When the NFA
+    /// contains a single regex, then `start_pattern[0]` and `start_anchored`
+    /// are always equivalent.
+    start_pattern: Vec<StateID>,
+    /// Info about the capturing groups in this NFA. This is responsible for
+    /// mapping groups to slots, mapping groups to names and names to groups.
+    group_info: GroupInfo,
+    /// A representation of equivalence classes over the transitions in this
+    /// NFA. Two bytes in the same equivalence class must not discriminate
+    /// between a match or a non-match. This map can be used to shrink the
+    /// total size of a DFA's transition table with a small match-time cost.
+    ///
+    /// Note that the NFA's transitions are *not* defined in terms of these
+    /// equivalence classes. The NFA's transitions are defined on the original
+    /// byte values. For the most part, this is because they wouldn't really
+    /// help the NFA much since the NFA already uses a sparse representation
+    /// to represent transitions. Byte classes are most effective in a dense
+    /// representation.
+    byte_class_set: ByteClassSet,
+    /// This is generated from `byte_class_set`, and essentially represents the
+    /// same thing but supports different access patterns. Namely, this permits
+    /// looking up the equivalence class of a byte very cheaply.
+    ///
+    /// Ideally we would just store this, but because of annoying code
+    /// structure reasons, we keep both this and `byte_class_set` around for
+    /// now. I think I would prefer that `byte_class_set` were computed in the
+    /// `Builder`, but right now, we compute it as states are added to the
+    /// `NFA`.
+    byte_classes: ByteClasses,
+    /// Whether this NFA has a `Capture` state anywhere.
+    has_capture: bool,
+    /// When the empty string is in the language matched by this NFA.
+    has_empty: bool,
+    /// Whether UTF-8 mode is enabled for this NFA. Briefly, this means that
+    /// all non-empty matches produced by this NFA correspond to spans of valid
+    /// UTF-8, and any empty matches produced by this NFA that split a UTF-8
+    /// encoded codepoint should be filtered out by the corresponding regex
+    /// engine.
+    utf8: bool,
+    /// Whether this NFA is meant to be matched in reverse or not.
+    reverse: bool,
+    /// The matcher to be used for look-around assertions.
+    look_matcher: LookMatcher,
+    /// The union of all look-around assertions that occur anywhere within
+    /// this NFA. If this set is empty, then it means there are precisely zero
+    /// conditional epsilon transitions in the NFA.
+    look_set_any: LookSet,
+    /// The union of all look-around assertions that occur as a zero-length
+    /// prefix for any of the patterns in this NFA.
+    look_set_prefix_any: LookSet,
+    /*
+    /// The intersection of all look-around assertions that occur as a
+    /// zero-length prefix for any of the patterns in this NFA.
+    look_set_prefix_all: LookSet,
+    */
+    /// Heap memory used indirectly by NFA states and other things (like the
+    /// various capturing group representations above). Since each state
+    /// might use a different amount of heap, we need to keep track of this
+    /// incrementally.
+    memory_extra: usize,
+}
+
+impl Inner {
+    /// Runs any last finalization bits and turns this into a full NFA.
+    pub(super) fn into_nfa(mut self) -> NFA {
+        self.byte_classes = self.byte_class_set.byte_classes();
+        // Do epsilon closure from the start state of every pattern in order
+        // to compute various properties such as look-around assertions and
+        // whether the empty string can be matched.
+        let mut stack = vec![];
+        let mut seen = SparseSet::new(self.states.len());
+        for &start_id in self.start_pattern.iter() {
+            stack.push(start_id);
+            seen.clear();
+            // let mut prefix_all = LookSet::full();
+            let mut prefix_any = LookSet::empty();
+            while let Some(sid) = stack.pop() {
+                if !seen.insert(sid) {
+                    continue;
+                }
+                match self.states[sid] {
+                    State::ByteRange { .. }
+                    | State::Dense { .. }
+                    | State::Fail => continue,
+                    State::Sparse(_) => {
+                        // This snippet below will rewrite this sparse state
+                        // as a dense state. By doing it here, we apply this
+                        // optimization to all hot "sparse" states since these
+                        // are the states that are reachable from the start
+                        // state via an epsilon closure.
+                        //
+                        // Unfortunately, this optimization did not seem to
+                        // help much in some very limited ad hoc benchmarking.
+                        //
+                        // I left the 'Dense' state type in place in case we
+                        // want to revisit this, but I suspect the real way
+                        // to make forward progress is a more fundamental
+                        // rearchitecting of how data in the NFA is laid out.
+                        // I think we should consider a single contiguous
+                        // allocation instead of all this indirection and
+                        // potential heap allocations for every state. But this
+                        // is a large re-design and will require API breaking
+                        // changes.
+                        // self.memory_extra -= self.states[sid].memory_usage();
+                        // let trans = DenseTransitions::from_sparse(sparse);
+                        // self.states[sid] = State::Dense(trans);
+                        // self.memory_extra += self.states[sid].memory_usage();
+                        continue;
+                    }
+                    State::Match { .. } => self.has_empty = true,
+                    State::Look { look, next } => {
+                        prefix_any = prefix_any.insert(look);
+                        stack.push(next);
+                    }
+                    State::Union { ref alternates } => {
+                        // Order doesn't matter here, since we're just dealing
+                        // with look-around sets. But if we do richer analysis
+                        // here that needs to care about preference order, then
+                        // this should be done in reverse.
+                        stack.extend(alternates.iter());
+                    }
+                    State::BinaryUnion { alt1, alt2 } => {
+                        stack.push(alt2);
+                        stack.push(alt1);
+                    }
+                    State::Capture { next, .. } => {
+                        stack.push(next);
+                    }
+                }
+            }
+            self.look_set_prefix_any =
+                self.look_set_prefix_any.union(prefix_any);
+        }
+        NFA(Arc::new(self))
+    }
+
+    /// Returns the capturing group info for this NFA.
+    pub(super) fn group_info(&self) -> &GroupInfo {
+        &self.group_info
+    }
+
+    /// Add the given state to this NFA after allocating a fresh identifier for
+    /// it.
+    ///
+    /// This panics if too many states are added such that a fresh identifier
+    /// could not be created. (Currently, the only caller of this routine is
+    /// a `Builder`, and it upholds this invariant.)
+    pub(super) fn add(&mut self, state: State) -> StateID {
+        match state {
+            State::ByteRange { ref trans } => {
+                self.byte_class_set.set_range(trans.start, trans.end);
+            }
+            State::Sparse(ref sparse) => {
+                for trans in sparse.transitions.iter() {
+                    self.byte_class_set.set_range(trans.start, trans.end);
+                }
+            }
+            State::Dense { .. } => unreachable!(),
+            State::Look { look, .. } => {
+                self.look_matcher
+                    .add_to_byteset(look, &mut self.byte_class_set);
+                self.look_set_any = self.look_set_any.insert(look);
+            }
+            State::Capture { .. } => {
+                self.has_capture = true;
+            }
+            State::Union { .. }
+            | State::BinaryUnion { .. }
+            | State::Fail
+            | State::Match { .. } => {}
+        }
+
+        let id = StateID::new(self.states.len()).unwrap();
+        self.memory_extra += state.memory_usage();
+        self.states.push(state);
+        id
+    }
+
+    /// Set the starting state identifiers for this NFA.
+    ///
+    /// `start_anchored` and `start_unanchored` may be equivalent. When they
+    /// are, then the NFA can only execute anchored searches. This might
+    /// occur, for example, for patterns that are unconditionally anchored.
+    /// e.g., `^foo`.
+    pub(super) fn set_starts(
+        &mut self,
+        start_anchored: StateID,
+        start_unanchored: StateID,
+        start_pattern: &[StateID],
+    ) {
+        self.start_anchored = start_anchored;
+        self.start_unanchored = start_unanchored;
+        self.start_pattern = start_pattern.to_vec();
+    }
+
+    /// Sets the UTF-8 mode of this NFA.
+    pub(super) fn set_utf8(&mut self, yes: bool) {
+        self.utf8 = yes;
+    }
+
+    /// Sets the reverse mode of this NFA.
+    pub(super) fn set_reverse(&mut self, yes: bool) {
+        self.reverse = yes;
+    }
+
+    /// Sets the look-around assertion matcher for this NFA.
+    pub(super) fn set_look_matcher(&mut self, m: LookMatcher) {
+        self.look_matcher = m;
+    }
+
+    /// Set the capturing groups for this NFA.
+    ///
+    /// The given slice should contain the capturing groups for each pattern,
+    /// The capturing groups in turn should correspond to the total number of
+    /// capturing groups in the pattern, including the anonymous first capture
+    /// group for each pattern. If a capturing group does have a name, then it
+    /// should be provided as a Arc<str>.
+    ///
+    /// This returns an error if a corresponding `GroupInfo` could not be
+    /// built.
+    pub(super) fn set_captures(
+        &mut self,
+        captures: &[Vec<Option<Arc<str>>>],
+    ) -> Result<(), GroupInfoError> {
+        self.group_info = GroupInfo::new(
+            captures.iter().map(|x| x.iter().map(|y| y.as_ref())),
+        )?;
+        Ok(())
+    }
+
+    /// Remap the transitions in every state of this NFA using the given map.
+    /// The given map should be indexed according to state ID namespace used by
+    /// the transitions of the states currently in this NFA.
+    ///
+    /// This is particularly useful to the NFA builder, since it is convenient
+    /// to add NFA states in order to produce their final IDs. Then, after all
+    /// of the intermediate "empty" states (unconditional epsilon transitions)
+    /// have been removed from the builder's representation, we can re-map all
+    /// of the transitions in the states already added to their final IDs.
+    pub(super) fn remap(&mut self, old_to_new: &[StateID]) {
+        for state in &mut self.states {
+            state.remap(old_to_new);
+        }
+        self.start_anchored = old_to_new[self.start_anchored];
+        self.start_unanchored = old_to_new[self.start_unanchored];
+        for id in self.start_pattern.iter_mut() {
+            *id = old_to_new[*id];
+        }
+    }
+}
+
+impl fmt::Debug for Inner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "thompson::NFA(")?;
+        for (sid, state) in self.states.iter().with_state_ids() {
+            let status = if sid == self.start_anchored {
+                '^'
+            } else if sid == self.start_unanchored {
+                '>'
+            } else {
+                ' '
+            };
+            writeln!(f, "{}{:06?}: {:?}", status, sid.as_usize(), state)?;
+        }
+        let pattern_len = self.start_pattern.len();
+        if pattern_len > 1 {
+            writeln!(f, "")?;
+            for pid in 0..pattern_len {
+                let sid = self.start_pattern[pid];
+                writeln!(f, "START({:06?}): {:?}", pid, sid.as_usize())?;
+            }
+        }
+        writeln!(f, "")?;
+        writeln!(
+            f,
+            "transition equivalence classes: {:?}",
+            self.byte_classes,
+        )?;
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+/// A state in an NFA.
+///
+/// In theory, it can help to conceptualize an `NFA` as a graph consisting of
+/// `State`s. Each `State` contains its complete set of outgoing transitions.
+///
+/// In practice, it can help to conceptualize an `NFA` as a sequence of
+/// instructions for a virtual machine. Each `State` says what to do and where
+/// to go next.
+///
+/// Strictly speaking, the practical interpretation is the most correct one,
+/// because of the [`Capture`](State::Capture) state. Namely, a `Capture`
+/// state always forwards execution to another state unconditionally. Its only
+/// purpose is to cause a side effect: the recording of the current input
+/// position at a particular location in memory. In this sense, an `NFA`
+/// has more power than a theoretical non-deterministic finite automaton.
+///
+/// For most uses of this crate, it is likely that one may never even need to
+/// be aware of this type at all. The main use cases for looking at `State`s
+/// directly are if you need to write your own search implementation or if you
+/// need to do some kind of analysis on the NFA.
+#[derive(Clone, Eq, PartialEq)]
+pub enum State {
+    /// A state with a single transition that can only be taken if the current
+    /// input symbol is in a particular range of bytes.
+    ByteRange {
+        /// The transition from this state to the next.
+        trans: Transition,
+    },
+    /// A state with possibly many transitions represented in a sparse fashion.
+    /// Transitions are non-overlapping and ordered lexicographically by input
+    /// range.
+    ///
+    /// In practice, this is used for encoding UTF-8 automata. Its presence is
+    /// primarily an optimization that avoids many additional unconditional
+    /// epsilon transitions (via [`Union`](State::Union) states), and thus
+    /// decreases the overhead of traversing the NFA. This can improve both
+    /// matching time and DFA construction time.
+    Sparse(SparseTransitions),
+    /// A dense representation of a state with multiple transitions.
+    Dense(DenseTransitions),
+    /// A conditional epsilon transition satisfied via some sort of
+    /// look-around. Look-around is limited to anchor and word boundary
+    /// assertions.
+    ///
+    /// Look-around states are meant to be evaluated while performing epsilon
+    /// closure (computing the set of states reachable from a particular state
+    /// via only epsilon transitions). If the current position in the haystack
+    /// satisfies the look-around assertion, then you're permitted to follow
+    /// that epsilon transition.
+    Look {
+        /// The look-around assertion that must be satisfied before moving
+        /// to `next`.
+        look: Look,
+        /// The state to transition to if the look-around assertion is
+        /// satisfied.
+        next: StateID,
+    },
+    /// An alternation such that there exists an epsilon transition to all
+    /// states in `alternates`, where matches found via earlier transitions
+    /// are preferred over later transitions.
+    Union {
+        /// An ordered sequence of unconditional epsilon transitions to other
+        /// states. Transitions earlier in the sequence are preferred over
+        /// transitions later in the sequence.
+        alternates: Box<[StateID]>,
+    },
+    /// An alternation such that there exists precisely two unconditional
+    /// epsilon transitions, where matches found via `alt1` are preferred over
+    /// matches found via `alt2`.
+    ///
+    /// This state exists as a common special case of Union where there are
+    /// only two alternates. In this case, we don't need any allocations to
+    /// represent the state. This saves a bit of memory and also saves an
+    /// additional memory access when traversing the NFA.
+    BinaryUnion {
+        /// An unconditional epsilon transition to another NFA state. This
+        /// is preferred over `alt2`.
+        alt1: StateID,
+        /// An unconditional epsilon transition to another NFA state. Matches
+        /// reported via this transition should only be reported if no matches
+        /// were found by following `alt1`.
+        alt2: StateID,
+    },
+    /// An empty state that records a capture location.
+    ///
+    /// From the perspective of finite automata, this is precisely equivalent
+    /// to an unconditional epsilon transition, but serves the purpose of
+    /// instructing NFA simulations to record additional state when the finite
+    /// state machine passes through this epsilon transition.
+    ///
+    /// `slot` in this context refers to the specific capture group slot
+    /// offset that is being recorded. Each capturing group has two slots
+    /// corresponding to the start and end of the matching portion of that
+    /// group.
+    ///
+    /// The pattern ID and capture group index are also included in this state
+    /// in case they are useful. But mostly, all you'll need is `next` and
+    /// `slot`.
+    Capture {
+        /// The state to transtition to, unconditionally.
+        next: StateID,
+        /// The pattern ID that this capture belongs to.
+        pattern_id: PatternID,
+        /// The capture group index that this capture belongs to. Capture group
+        /// indices are local to each pattern. For example, when capturing
+        /// groups are enabled, every pattern has a capture group at index
+        /// `0`.
+        group_index: SmallIndex,
+        /// The slot index for this capture. Every capturing group has two
+        /// slots: one for the start haystack offset and one for the end
+        /// haystack offset. Unlike capture group indices, slot indices are
+        /// global across all patterns in this NFA. That is, each slot belongs
+        /// to a single pattern, but there is only one slot at index `i`.
+        slot: SmallIndex,
+    },
+    /// A state that cannot be transitioned out of. This is useful for cases
+    /// where you want to prevent matching from occurring. For example, if your
+    /// regex parser permits empty character classes, then one could choose
+    /// a `Fail` state to represent them. (An empty character class can be
+    /// thought of as an empty set. Since nothing is in an empty set, they can
+    /// never match anything.)
+    Fail,
+    /// A match state. There is at least one such occurrence of this state for
+    /// each regex that can match that is in this NFA.
+    Match {
+        /// The matching pattern ID.
+        pattern_id: PatternID,
+    },
+}
+
+impl State {
+    /// Returns true if and only if this state contains one or more epsilon
+    /// transitions.
+    ///
+    /// In practice, a state has no outgoing transitions (like `Match`), has
+    /// only non-epsilon transitions (like `ByteRange`) or has only epsilon
+    /// transitions (like `Union`).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{State, Transition},
+    ///     util::primitives::{PatternID, StateID, SmallIndex},
+    /// };
+    ///
+    /// // Capture states are epsilon transitions.
+    /// let state = State::Capture {
+    ///     next: StateID::ZERO,
+    ///     pattern_id: PatternID::ZERO,
+    ///     group_index: SmallIndex::ZERO,
+    ///     slot: SmallIndex::ZERO,
+    /// };
+    /// assert!(state.is_epsilon());
+    ///
+    /// // ByteRange states are not.
+    /// let state = State::ByteRange {
+    ///     trans: Transition { start: b'a', end: b'z', next: StateID::ZERO },
+    /// };
+    /// assert!(!state.is_epsilon());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_epsilon(&self) -> bool {
+        match *self {
+            State::ByteRange { .. }
+            | State::Sparse { .. }
+            | State::Dense { .. }
+            | State::Fail
+            | State::Match { .. } => false,
+            State::Look { .. }
+            | State::Union { .. }
+            | State::BinaryUnion { .. }
+            | State::Capture { .. } => true,
+        }
+    }
+
+    /// Returns the heap memory usage of this NFA state in bytes.
+    fn memory_usage(&self) -> usize {
+        match *self {
+            State::ByteRange { .. }
+            | State::Look { .. }
+            | State::BinaryUnion { .. }
+            | State::Capture { .. }
+            | State::Match { .. }
+            | State::Fail => 0,
+            State::Sparse(SparseTransitions { ref transitions }) => {
+                transitions.len() * mem::size_of::<Transition>()
+            }
+            State::Dense { .. } => 256 * mem::size_of::<StateID>(),
+            State::Union { ref alternates } => {
+                alternates.len() * mem::size_of::<StateID>()
+            }
+        }
+    }
+
+    /// Remap the transitions in this state using the given map. Namely, the
+    /// given map should be indexed according to the transitions currently
+    /// in this state.
+    ///
+    /// This is used during the final phase of the NFA compiler, which turns
+    /// its intermediate NFA into the final NFA.
+    fn remap(&mut self, remap: &[StateID]) {
+        match *self {
+            State::ByteRange { ref mut trans } => {
+                trans.next = remap[trans.next]
+            }
+            State::Sparse(SparseTransitions { ref mut transitions }) => {
+                for t in transitions.iter_mut() {
+                    t.next = remap[t.next];
+                }
+            }
+            State::Dense(DenseTransitions { ref mut transitions }) => {
+                for sid in transitions.iter_mut() {
+                    *sid = remap[*sid];
+                }
+            }
+            State::Look { ref mut next, .. } => *next = remap[*next],
+            State::Union { ref mut alternates } => {
+                for alt in alternates.iter_mut() {
+                    *alt = remap[*alt];
+                }
+            }
+            State::BinaryUnion { ref mut alt1, ref mut alt2 } => {
+                *alt1 = remap[*alt1];
+                *alt2 = remap[*alt2];
+            }
+            State::Capture { ref mut next, .. } => *next = remap[*next],
+            State::Fail => {}
+            State::Match { .. } => {}
+        }
+    }
+}
+
+impl fmt::Debug for State {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            State::ByteRange { ref trans } => trans.fmt(f),
+            State::Sparse(SparseTransitions { ref transitions }) => {
+                let rs = transitions
+                    .iter()
+                    .map(|t| format!("{:?}", t))
+                    .collect::<Vec<String>>()
+                    .join(", ");
+                write!(f, "sparse({})", rs)
+            }
+            State::Dense(ref dense) => {
+                write!(f, "dense(")?;
+                for (i, t) in dense.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{:?}", t)?;
+                }
+                write!(f, ")")
+            }
+            State::Look { ref look, next } => {
+                write!(f, "{:?} => {:?}", look, next.as_usize())
+            }
+            State::Union { ref alternates } => {
+                let alts = alternates
+                    .iter()
+                    .map(|id| format!("{:?}", id.as_usize()))
+                    .collect::<Vec<String>>()
+                    .join(", ");
+                write!(f, "union({})", alts)
+            }
+            State::BinaryUnion { alt1, alt2 } => {
+                write!(
+                    f,
+                    "binary-union({}, {})",
+                    alt1.as_usize(),
+                    alt2.as_usize()
+                )
+            }
+            State::Capture { next, pattern_id, group_index, slot } => {
+                write!(
+                    f,
+                    "capture(pid={:?}, group={:?}, slot={:?}) => {:?}",
+                    pattern_id.as_usize(),
+                    group_index.as_usize(),
+                    slot.as_usize(),
+                    next.as_usize(),
+                )
+            }
+            State::Fail => write!(f, "FAIL"),
+            State::Match { pattern_id } => {
+                write!(f, "MATCH({:?})", pattern_id.as_usize())
+            }
+        }
+    }
+}
+
+/// A sequence of transitions used to represent a sparse state.
+///
+/// This is the primary representation of a [`Sparse`](State::Sparse) state.
+/// It corresponds to a sorted sequence of transitions with non-overlapping
+/// byte ranges. If the byte at the current position in the haystack matches
+/// one of the byte ranges, then the finite state machine should take the
+/// corresponding transition.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SparseTransitions {
+    /// The sorted sequence of non-overlapping transitions.
+    pub transitions: Box<[Transition]>,
+}
+
+impl SparseTransitions {
+    /// This follows the matching transition for a particular byte.
+    ///
+    /// The matching transition is found by looking for a matching byte
+    /// range (there is at most one) corresponding to the position `at` in
+    /// `haystack`.
+    ///
+    /// If `at >= haystack.len()`, then this returns `None`.
+    #[inline]
+    pub fn matches(&self, haystack: &[u8], at: usize) -> Option<StateID> {
+        haystack.get(at).and_then(|&b| self.matches_byte(b))
+    }
+
+    /// This follows the matching transition for any member of the alphabet.
+    ///
+    /// The matching transition is found by looking for a matching byte
+    /// range (there is at most one) corresponding to the position `at` in
+    /// `haystack`. If the given alphabet unit is [`EOI`](alphabet::Unit::eoi),
+    /// then this always returns `None`.
+    #[inline]
+    pub(crate) fn matches_unit(
+        &self,
+        unit: alphabet::Unit,
+    ) -> Option<StateID> {
+        unit.as_u8().map_or(None, |byte| self.matches_byte(byte))
+    }
+
+    /// This follows the matching transition for a particular byte.
+    ///
+    /// The matching transition is found by looking for a matching byte range
+    /// (there is at most one) corresponding to the byte given.
+    #[inline]
+    pub fn matches_byte(&self, byte: u8) -> Option<StateID> {
+        for t in self.transitions.iter() {
+            if t.start > byte {
+                break;
+            } else if t.matches_byte(byte) {
+                return Some(t.next);
+            }
+        }
+        None
+
+        /*
+        // This is an alternative implementation that uses binary search. In
+        // some ad hoc experiments, like
+        //
+        //   smallishru=OpenSubtitles2018.raw.sample.smallish.ru
+        //   regex-cli find nfa thompson pikevm -b "@$smallishru" '\b\w+\b'
+        //
+        // I could not observe any improvement, and in fact, things seemed to
+        // be a bit slower. I can see an improvement in at least one benchmark:
+        //
+        //   allcpssmall=all-codepoints-utf8-10x
+        //   regex-cli find nfa thompson pikevm @$allcpssmall '\pL{100}'
+        //
+        // Where total search time goes from 3.2s to 2.4s when using binary
+        // search.
+        self.transitions
+            .binary_search_by(|t| {
+                if t.end < byte {
+                    core::cmp::Ordering::Less
+                } else if t.start > byte {
+                    core::cmp::Ordering::Greater
+                } else {
+                    core::cmp::Ordering::Equal
+                }
+            })
+            .ok()
+            .map(|i| self.transitions[i].next)
+        */
+    }
+}
+
+/// A sequence of transitions used to represent a dense state.
+///
+/// This is the primary representation of a [`Dense`](State::Dense) state. It
+/// provides constant time matching. That is, given a byte in a haystack and
+/// a `DenseTransitions`, one can determine if the state matches in constant
+/// time.
+///
+/// This is in contrast to `SparseTransitions`, whose time complexity is
+/// necessarily bigger than constant time. Also in contrast, `DenseTransitions`
+/// usually requires (much) more heap memory.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DenseTransitions {
+    /// A dense representation of this state's transitions on the heap. This
+    /// always has length 256.
+    pub transitions: Box<[StateID]>,
+}
+
+impl DenseTransitions {
+    /// This follows the matching transition for a particular byte.
+    ///
+    /// The matching transition is found by looking for a transition that
+    /// doesn't correspond to `StateID::ZERO` for the byte `at` the given
+    /// position in `haystack`.
+    ///
+    /// If `at >= haystack.len()`, then this returns `None`.
+    #[inline]
+    pub fn matches(&self, haystack: &[u8], at: usize) -> Option<StateID> {
+        haystack.get(at).and_then(|&b| self.matches_byte(b))
+    }
+
+    /// This follows the matching transition for any member of the alphabet.
+    ///
+    /// The matching transition is found by looking for a transition that
+    /// doesn't correspond to `StateID::ZERO` for the byte `at` the given
+    /// position in `haystack`.
+    ///
+    /// If `at >= haystack.len()` or if the given alphabet unit is
+    /// [`EOI`](alphabet::Unit::eoi), then this returns `None`.
+    #[inline]
+    pub(crate) fn matches_unit(
+        &self,
+        unit: alphabet::Unit,
+    ) -> Option<StateID> {
+        unit.as_u8().map_or(None, |byte| self.matches_byte(byte))
+    }
+
+    /// This follows the matching transition for a particular byte.
+    ///
+    /// The matching transition is found by looking for a transition that
+    /// doesn't correspond to `StateID::ZERO` for the given `byte`.
+    ///
+    /// If `at >= haystack.len()`, then this returns `None`.
+    #[inline]
+    pub fn matches_byte(&self, byte: u8) -> Option<StateID> {
+        let next = self.transitions[usize::from(byte)];
+        if next == StateID::ZERO {
+            None
+        } else {
+            Some(next)
+        }
+    }
+
+    /*
+    /// The dense state optimization isn't currently enabled, so permit a
+    /// little bit of dead code.
+    pub(crate) fn from_sparse(sparse: &SparseTransitions) -> DenseTransitions {
+        let mut dense = vec![StateID::ZERO; 256];
+        for t in sparse.transitions.iter() {
+            for b in t.start..=t.end {
+                dense[usize::from(b)] = t.next;
+            }
+        }
+        DenseTransitions { transitions: dense.into_boxed_slice() }
+    }
+    */
+
+    /// Returns an iterator over all transitions that don't point to
+    /// `StateID::ZERO`.
+    pub(crate) fn iter(&self) -> impl Iterator<Item = Transition> + '_ {
+        use crate::util::int::Usize;
+        self.transitions
+            .iter()
+            .enumerate()
+            .filter(|&(_, &sid)| sid != StateID::ZERO)
+            .map(|(byte, &next)| Transition {
+                start: byte.as_u8(),
+                end: byte.as_u8(),
+                next,
+            })
+    }
+}
+
+/// A single transition to another state.
+///
+/// This transition may only be followed if the current byte in the haystack
+/// falls in the inclusive range of bytes specified.
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct Transition {
+    /// The inclusive start of the byte range.
+    pub start: u8,
+    /// The inclusive end of the byte range.
+    pub end: u8,
+    /// The identifier of the state to transition to.
+    pub next: StateID,
+}
+
+impl Transition {
+    /// Returns true if the position `at` in `haystack` falls in this
+    /// transition's range of bytes.
+    ///
+    /// If `at >= haystack.len()`, then this returns `false`.
+    pub fn matches(&self, haystack: &[u8], at: usize) -> bool {
+        haystack.get(at).map_or(false, |&b| self.matches_byte(b))
+    }
+
+    /// Returns true if the given alphabet unit falls in this transition's
+    /// range of bytes. If the given unit is [`EOI`](alphabet::Unit::eoi), then
+    /// this returns `false`.
+    pub fn matches_unit(&self, unit: alphabet::Unit) -> bool {
+        unit.as_u8().map_or(false, |byte| self.matches_byte(byte))
+    }
+
+    /// Returns true if the given byte falls in this transition's range of
+    /// bytes.
+    pub fn matches_byte(&self, byte: u8) -> bool {
+        self.start <= byte && byte <= self.end
+    }
+}
+
+impl fmt::Debug for Transition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use crate::util::escape::DebugByte;
+
+        let Transition { start, end, next } = *self;
+        if self.start == self.end {
+            write!(f, "{:?} => {:?}", DebugByte(start), next.as_usize())
+        } else {
+            write!(
+                f,
+                "{:?}-{:?} => {:?}",
+                DebugByte(start),
+                DebugByte(end),
+                next.as_usize(),
+            )
+        }
+    }
+}
+
+/// An iterator over all pattern IDs in an NFA.
+///
+/// This iterator is created by [`NFA::patterns`].
+///
+/// The lifetime parameter `'a` refers to the lifetime of the NFA from which
+/// this pattern iterator was created.
+#[derive(Debug)]
+pub struct PatternIter<'a> {
+    it: PatternIDIter,
+    /// We explicitly associate a lifetime with this iterator even though we
+    /// don't actually borrow anything from the NFA. We do this for backward
+    /// compatibility purposes. If we ever do need to borrow something from
+    /// the NFA, then we can and just get rid of this marker without breaking
+    /// the public API.
+    _marker: core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> Iterator for PatternIter<'a> {
+    type Item = PatternID;
+
+    fn next(&mut self) -> Option<PatternID> {
+        self.it.next()
+    }
+}
+
+#[cfg(all(test, feature = "nfa-pikevm"))]
+mod tests {
+    use super::*;
+    use crate::{nfa::thompson::pikevm::PikeVM, Input};
+
+    // This asserts that an NFA state doesn't have its size changed. It is
+    // *really* easy to accidentally increase the size, and thus potentially
+    // dramatically increase the memory usage of every NFA.
+    //
+    // This assert doesn't mean we absolutely cannot increase the size of an
+    // NFA state. We can. It's just here to make sure we do it knowingly and
+    // intentionally.
+    #[test]
+    fn state_has_small_size() {
+        #[cfg(target_pointer_width = "64")]
+        assert_eq!(24, core::mem::size_of::<State>());
+        #[cfg(target_pointer_width = "32")]
+        assert_eq!(20, core::mem::size_of::<State>());
+    }
+
+    #[test]
+    fn always_match() {
+        let re = PikeVM::new_from_nfa(NFA::always_match()).unwrap();
+        let mut cache = re.create_cache();
+        let mut caps = re.create_captures();
+        let mut find = |haystack, start, end| {
+            let input = Input::new(haystack).range(start..end);
+            re.search(&mut cache, &input, &mut caps);
+            caps.get_match().map(|m| m.end())
+        };
+
+        assert_eq!(Some(0), find("", 0, 0));
+        assert_eq!(Some(0), find("a", 0, 1));
+        assert_eq!(Some(1), find("a", 1, 1));
+        assert_eq!(Some(0), find("ab", 0, 2));
+        assert_eq!(Some(1), find("ab", 1, 2));
+        assert_eq!(Some(2), find("ab", 2, 2));
+    }
+
+    #[test]
+    fn never_match() {
+        let re = PikeVM::new_from_nfa(NFA::never_match()).unwrap();
+        let mut cache = re.create_cache();
+        let mut caps = re.create_captures();
+        let mut find = |haystack, start, end| {
+            let input = Input::new(haystack).range(start..end);
+            re.search(&mut cache, &input, &mut caps);
+            caps.get_match().map(|m| m.end())
+        };
+
+        assert_eq!(None, find("", 0, 0));
+        assert_eq!(None, find("a", 0, 1));
+        assert_eq!(None, find("a", 1, 1));
+        assert_eq!(None, find("ab", 0, 2));
+        assert_eq!(None, find("ab", 1, 2));
+        assert_eq!(None, find("ab", 2, 2));
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/pikevm.rs b/regex-automata/src/nfa/thompson/pikevm.rs
new file mode 100644
index 0000000000..d11590bece
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/pikevm.rs
@@ -0,0 +1,2367 @@
+/*!
+An NFA backed Pike VM for executing regex searches with capturing groups.
+
+This module provides a [`PikeVM`] that works by simulating an NFA and
+resolving all spans of capturing groups that participate in a match.
+*/
+
+#[cfg(feature = "internal-instrument-pikevm")]
+use core::cell::RefCell;
+
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    nfa::thompson::{self, BuildError, State, NFA},
+    util::{
+        captures::Captures,
+        empty, iter,
+        prefilter::Prefilter,
+        primitives::{NonMaxUsize, PatternID, SmallIndex, StateID},
+        search::{Anchored, Input, Match, MatchKind, PatternSet, Span},
+        sparse_set::SparseSet,
+    },
+};
+
+/// A simple macro for conditionally executing instrumentation logic when
+/// the 'trace' log level is enabled. This is a compile-time no-op when the
+/// 'internal-instrument-pikevm' feature isn't enabled. The intent here is that
+/// this makes it easier to avoid doing extra work when instrumentation isn't
+/// enabled.
+///
+/// This macro accepts a closure of type `|&mut Counters|`. The closure can
+/// then increment counters (or whatever) in accordance with what one wants
+/// to track.
+macro_rules! instrument {
+    ($fun:expr) => {
+        #[cfg(feature = "internal-instrument-pikevm")]
+        {
+            let fun: &mut dyn FnMut(&mut Counters) = &mut $fun;
+            COUNTERS.with(|c: &RefCell<Counters>| fun(&mut *c.borrow_mut()));
+        }
+    };
+}
+
+#[cfg(feature = "internal-instrument-pikevm")]
+std::thread_local! {
+    /// Effectively global state used to keep track of instrumentation
+    /// counters. The "proper" way to do this is to thread it through the
+    /// PikeVM, but it makes the code quite icky. Since this is just a
+    /// debugging feature, we're content to relegate it to thread local
+    /// state. When instrumentation is enabled, the counters are reset at the
+    /// beginning of every search and printed (with the 'trace' log level) at
+    /// the end of every search.
+    static COUNTERS: RefCell<Counters> = RefCell::new(Counters::empty());
+}
+
+/// The configuration used for building a [`PikeVM`].
+///
+/// A PikeVM configuration is a simple data object that is typically used with
+/// [`Builder::configure`]. It can be cheaply cloned.
+///
+/// A default configuration can be created either with `Config::new`, or
+/// perhaps more conveniently, with [`PikeVM::config`].
+#[derive(Clone, Debug, Default)]
+pub struct Config {
+    match_kind: Option<MatchKind>,
+    pre: Option<Option<Prefilter>>,
+}
+
+impl Config {
+    /// Return a new default PikeVM configuration.
+    pub fn new() -> Config {
+        Config::default()
+    }
+
+    /// Set the desired match semantics.
+    ///
+    /// The default is [`MatchKind::LeftmostFirst`], which corresponds to the
+    /// match semantics of Perl-like regex engines. That is, when multiple
+    /// patterns would match at the same leftmost position, the pattern that
+    /// appears first in the concrete syntax is chosen.
+    ///
+    /// Currently, the only other kind of match semantics supported is
+    /// [`MatchKind::All`]. This corresponds to "classical DFA" construction
+    /// where all possible matches are visited in the NFA by the `PikeVM`.
+    ///
+    /// Typically, `All` is used when one wants to execute an overlapping
+    /// search and `LeftmostFirst` otherwise. In particular, it rarely makes
+    /// sense to use `All` with the various "leftmost" find routines, since the
+    /// leftmost routines depend on the `LeftmostFirst` automata construction
+    /// strategy. Specifically, `LeftmostFirst` results in the `PikeVM`
+    /// simulating dead states as a way to terminate the search and report a
+    /// match. `LeftmostFirst` also supports non-greedy matches using this
+    /// strategy where as `All` does not.
+    pub fn match_kind(mut self, kind: MatchKind) -> Config {
+        self.match_kind = Some(kind);
+        self
+    }
+
+    /// Set a prefilter to be used whenever a start state is entered.
+    ///
+    /// A [`Prefilter`] in this context is meant to accelerate searches by
+    /// looking for literal prefixes that every match for the corresponding
+    /// pattern (or patterns) must start with. Once a prefilter produces a
+    /// match, the underlying search routine continues on to try and confirm
+    /// the match.
+    ///
+    /// Be warned that setting a prefilter does not guarantee that the search
+    /// will be faster. While it's usually a good bet, if the prefilter
+    /// produces a lot of false positive candidates (i.e., positions matched
+    /// by the prefilter but not by the regex), then the overall result can
+    /// be slower than if you had just executed the regex engine without any
+    /// prefilters.
+    ///
+    /// By default no prefilter is set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::prefilter::Prefilter,
+    ///     Input, Match, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "bar"]);
+    /// let re = PikeVM::builder()
+    ///     .configure(PikeVM::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// assert_eq!(Some(Match::must(0, 5..11)), re.find(&mut cache, input));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Be warned though that an incorrect prefilter can lead to incorrect
+    /// results!
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::prefilter::Prefilter,
+    ///     Input, HalfMatch, MatchKind,
+    /// };
+    ///
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["foo", "car"]);
+    /// let re = PikeVM::builder()
+    ///     .configure(PikeVM::config().prefilter(pre))
+    ///     .build(r"(foo|bar)[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("foo1 barfox bar");
+    /// // No match reported even though there clearly is one!
+    /// assert_eq!(None, re.find(&mut cache, input));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn prefilter(mut self, pre: Option<Prefilter>) -> Config {
+        self.pre = Some(pre);
+        self
+    }
+
+    /// Returns the match semantics set in this configuration.
+    pub fn get_match_kind(&self) -> MatchKind {
+        self.match_kind.unwrap_or(MatchKind::LeftmostFirst)
+    }
+
+    /// Returns the prefilter set in this configuration, if one at all.
+    pub fn get_prefilter(&self) -> Option<&Prefilter> {
+        self.pre.as_ref().unwrap_or(&None).as_ref()
+    }
+
+    /// Overwrite the default configuration such that the options in `o` are
+    /// always used. If an option in `o` is not set, then the corresponding
+    /// option in `self` is used. If it's not set in `self` either, then it
+    /// remains not set.
+    pub(crate) fn overwrite(&self, o: Config) -> Config {
+        Config {
+            match_kind: o.match_kind.or(self.match_kind),
+            pre: o.pre.or_else(|| self.pre.clone()),
+        }
+    }
+}
+
+/// A builder for a `PikeVM`.
+///
+/// This builder permits configuring options for the syntax of a pattern,
+/// the NFA construction and the `PikeVM` construction. This builder is
+/// different from a general purpose regex builder in that it permits fine
+/// grain configuration of the construction process. The trade off for this is
+/// complexity, and the possibility of setting a configuration that might not
+/// make sense. For example, there are two different UTF-8 modes:
+///
+/// * [`util::syntax::Config::utf8`](crate::util::syntax::Config::utf8)
+/// controls whether the pattern itself can contain sub-expressions that match
+/// invalid UTF-8.
+/// * [`thompson::Config::utf8`] controls whether empty matches that split a
+/// Unicode codepoint are reported or not.
+///
+/// Generally speaking, callers will want to either enable all of these or
+/// disable all of these.
+///
+/// # Example
+///
+/// This example shows how to disable UTF-8 mode in the syntax and the regex
+/// itself. This is generally what you want for matching on arbitrary bytes.
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::{self, pikevm::PikeVM},
+///     util::syntax,
+///     Match,
+/// };
+///
+/// let re = PikeVM::builder()
+///     .syntax(syntax::Config::new().utf8(false))
+///     .thompson(thompson::Config::new().utf8(false))
+///     .build(r"foo(?-u:[^b])ar.*")?;
+/// let mut cache = re.create_cache();
+///
+/// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+/// let expected = Some(Match::must(0, 1..9));
+/// let got = re.find_iter(&mut cache, haystack).next();
+/// assert_eq!(expected, got);
+/// // Notice that `(?-u:[^b])` matches invalid UTF-8,
+/// // but the subsequent `.*` does not! Disabling UTF-8
+/// // on the syntax permits this.
+/// //
+/// // N.B. This example does not show the impact of
+/// // disabling UTF-8 mode on a PikeVM Config, since that
+/// // only impacts regexes that can produce matches of
+/// // length 0.
+/// assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap().range()]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Builder {
+    config: Config,
+    #[cfg(feature = "syntax")]
+    thompson: thompson::Compiler,
+}
+
+impl Builder {
+    /// Create a new PikeVM builder with its default configuration.
+    pub fn new() -> Builder {
+        Builder {
+            config: Config::default(),
+            #[cfg(feature = "syntax")]
+            thompson: thompson::Compiler::new(),
+        }
+    }
+
+    /// Build a `PikeVM` from the given pattern.
+    ///
+    /// If there was a problem parsing or compiling the pattern, then an error
+    /// is returned.
+    #[cfg(feature = "syntax")]
+    pub fn build(&self, pattern: &str) -> Result<PikeVM, BuildError> {
+        self.build_many(&[pattern])
+    }
+
+    /// Build a `PikeVM` from the given patterns.
+    #[cfg(feature = "syntax")]
+    pub fn build_many<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> Result<PikeVM, BuildError> {
+        let nfa = self.thompson.build_many(patterns)?;
+        self.build_from_nfa(nfa)
+    }
+
+    /// Build a `PikeVM` directly from its NFA.
+    ///
+    /// Note that when using this method, any configuration that applies to the
+    /// construction of the NFA itself will of course be ignored, since the NFA
+    /// given here is already built.
+    pub fn build_from_nfa(&self, nfa: NFA) -> Result<PikeVM, BuildError> {
+        // If the NFA has no captures, then the PikeVM doesn't work since it
+        // relies on them in order to report match locations. However, in
+        // the special case of an NFA with no patterns, it is allowed, since
+        // no matches can ever be produced. And importantly, an NFA with no
+        // patterns has no capturing groups anyway, so this is necessary to
+        // permit the PikeVM to work with regexes with zero patterns.
+        if !nfa.has_capture() && nfa.pattern_len() > 0 {
+            return Err(BuildError::missing_captures());
+        }
+        nfa.look_set_any().available().map_err(BuildError::word)?;
+        Ok(PikeVM { config: self.config.clone(), nfa })
+    }
+
+    /// Apply the given `PikeVM` configuration options to this builder.
+    pub fn configure(&mut self, config: Config) -> &mut Builder {
+        self.config = self.config.overwrite(config);
+        self
+    }
+
+    /// Set the syntax configuration for this builder using
+    /// [`syntax::Config`](crate::util::syntax::Config).
+    ///
+    /// This permits setting things like case insensitivity, Unicode and multi
+    /// line mode.
+    ///
+    /// These settings only apply when constructing a PikeVM directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn syntax(
+        &mut self,
+        config: crate::util::syntax::Config,
+    ) -> &mut Builder {
+        self.thompson.syntax(config);
+        self
+    }
+
+    /// Set the Thompson NFA configuration for this builder using
+    /// [`nfa::thompson::Config`](crate::nfa::thompson::Config).
+    ///
+    /// This permits setting things like if additional time should be spent
+    /// shrinking the size of the NFA.
+    ///
+    /// These settings only apply when constructing a PikeVM directly from a
+    /// pattern.
+    #[cfg(feature = "syntax")]
+    pub fn thompson(&mut self, config: thompson::Config) -> &mut Builder {
+        self.thompson.configure(config);
+        self
+    }
+}
+
+/// A virtual machine for executing regex searches with capturing groups.
+///
+/// # Infallible APIs
+///
+/// Unlike most other regex engines in this crate, a `PikeVM` never returns an
+/// error at search time. It supports all [`Anchored`] configurations, never
+/// quits and works on haystacks of arbitrary length.
+///
+/// There are two caveats to mention though:
+///
+/// * If an invalid pattern ID is given to a search via [`Anchored::Pattern`],
+/// then the PikeVM will report "no match." This is consistent with all other
+/// regex engines in this crate.
+/// * When using [`PikeVM::which_overlapping_matches`] with a [`PatternSet`]
+/// that has insufficient capacity to store all valid pattern IDs, then if a
+/// match occurs for a `PatternID` that cannot be inserted, it is silently
+/// dropped as if it did not match.
+///
+/// # Advice
+///
+/// The `PikeVM` is generally the most "powerful" regex engine in this crate.
+/// "Powerful" in this context means that it can handle any regular expression
+/// that is parseable by `regex-syntax` and any size haystack. Regretably,
+/// the `PikeVM` is also simultaneously often the _slowest_ regex engine in
+/// practice. This results in an annoying situation where one generally tries
+/// to pick any other regex engine (or perhaps none at all) before being
+/// forced to fall back to a `PikeVM`.
+///
+/// For example, a common strategy for dealing with capturing groups is to
+/// actually look for the overall match of the regex using a faster regex
+/// engine, like a [lazy DFA](crate::hybrid::regex::Regex). Once the overall
+/// match is found, one can then run the `PikeVM` on just the match span to
+/// find the spans of the capturing groups. In this way, the faster regex
+/// engine does the majority of the work, while the `PikeVM` only lends its
+/// power in a more limited role.
+///
+/// Unfortunately, this isn't always possible because the faster regex engines
+/// don't support all of the regex features in `regex-syntax`. This notably
+/// includes (and is currently limited to) Unicode word boundaries. So if
+/// your pattern has Unicode word boundaries, you typically can't use a
+/// DFA-based regex engine at all (unless you [enable heuristic support for
+/// it](crate::hybrid::dfa::Config::unicode_word_boundary)). (The [one-pass
+/// DFA](crate::dfa::onepass::DFA) can handle Unicode word boundaries for
+/// anchored searches only, but in a cruel sort of joke, many Unicode features
+/// tend to result in making the regex _not_ one-pass.)
+///
+/// # Example
+///
+/// This example shows that the `PikeVM` implements Unicode word boundaries
+/// correctly by default.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+///
+/// let re = PikeVM::new(r"\b\w+\b")?;
+/// let mut cache = re.create_cache();
+///
+/// let mut it = re.find_iter(&mut cache, "Шерлок Холмс");
+/// assert_eq!(Some(Match::must(0, 0..12)), it.next());
+/// assert_eq!(Some(Match::must(0, 13..23)), it.next());
+/// assert_eq!(None, it.next());
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct PikeVM {
+    config: Config,
+    nfa: NFA,
+}
+
+impl PikeVM {
+    /// Parse the given regular expression using the default configuration and
+    /// return the corresponding `PikeVM`.
+    ///
+    /// If you want a non-default configuration, then use the [`Builder`] to
+    /// set your own configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 3..14)),
+    ///     re.find_iter(&mut cache, "zzzfoo12345barzzz").next(),
+    /// );
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new(pattern: &str) -> Result<PikeVM, BuildError> {
+        PikeVM::builder().build(pattern)
+    }
+
+    /// Like `new`, but parses multiple patterns into a single "multi regex."
+    /// This similarly uses the default regex configuration.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new_many(&["[a-z]+", "[0-9]+"])?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let mut it = re.find_iter(&mut cache, "abc 1 foo 4567 0 quux");
+    /// assert_eq!(Some(Match::must(0, 0..3)), it.next());
+    /// assert_eq!(Some(Match::must(1, 4..5)), it.next());
+    /// assert_eq!(Some(Match::must(0, 6..9)), it.next());
+    /// assert_eq!(Some(Match::must(1, 10..14)), it.next());
+    /// assert_eq!(Some(Match::must(1, 15..16)), it.next());
+    /// assert_eq!(Some(Match::must(0, 17..21)), it.next());
+    /// assert_eq!(None, it.next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn new_many<P: AsRef<str>>(
+        patterns: &[P],
+    ) -> Result<PikeVM, BuildError> {
+        PikeVM::builder().build_many(patterns)
+    }
+
+    /// Like `new`, but builds a PikeVM directly from an NFA. This is useful
+    /// if you already have an NFA, or even if you hand-assembled the NFA.
+    ///
+    /// # Example
+    ///
+    /// This shows how to hand assemble a regular expression via its HIR,
+    /// compile an NFA from it and build a PikeVM from the NFA.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{NFA, pikevm::PikeVM}, Match};
+    /// use regex_syntax::hir::{Hir, Class, ClassBytes, ClassBytesRange};
+    ///
+    /// let hir = Hir::class(Class::Bytes(ClassBytes::new(vec![
+    ///     ClassBytesRange::new(b'0', b'9'),
+    ///     ClassBytesRange::new(b'A', b'Z'),
+    ///     ClassBytesRange::new(b'_', b'_'),
+    ///     ClassBytesRange::new(b'a', b'z'),
+    /// ])));
+    ///
+    /// let config = NFA::config().nfa_size_limit(Some(1_000));
+    /// let nfa = NFA::compiler().configure(config).build_from_hir(&hir)?;
+    ///
+    /// let re = PikeVM::new_from_nfa(nfa)?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let expected = Some(Match::must(0, 3..4));
+    /// re.captures(&mut cache, "!@#A#@!", &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new_from_nfa(nfa: NFA) -> Result<PikeVM, BuildError> {
+        PikeVM::builder().build_from_nfa(nfa)
+    }
+
+    /// Create a new `PikeVM` that matches every input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::always_match()?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let expected = Match::must(0, 0..0);
+    /// assert_eq!(Some(expected), re.find_iter(&mut cache, "").next());
+    /// assert_eq!(Some(expected), re.find_iter(&mut cache, "foo").next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn always_match() -> Result<PikeVM, BuildError> {
+        let nfa = thompson::NFA::always_match();
+        PikeVM::new_from_nfa(nfa)
+    }
+
+    /// Create a new `PikeVM` that never matches any input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::never_match()?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert_eq!(None, re.find_iter(&mut cache, "").next());
+    /// assert_eq!(None, re.find_iter(&mut cache, "foo").next());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn never_match() -> Result<PikeVM, BuildError> {
+        let nfa = thompson::NFA::never_match();
+        PikeVM::new_from_nfa(nfa)
+    }
+
+    /// Return a default configuration for a `PikeVM`.
+    ///
+    /// This is a convenience routine to avoid needing to import the `Config`
+    /// type when customizing the construction of a `PikeVM`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to disable UTF-8 mode. When UTF-8 mode is
+    /// disabled, zero-width matches that split a codepoint are allowed.
+    /// Otherwise they are never reported.
+    ///
+    /// In the code below, notice that `""` is permitted to match positions
+    /// that split the encoding of a codepoint.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{self, pikevm::PikeVM}, Match};
+    ///
+    /// let re = PikeVM::builder()
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let haystack = "a☃z";
+    /// let mut it = re.find_iter(&mut cache, haystack);
+    /// assert_eq!(Some(Match::must(0, 0..0)), it.next());
+    /// assert_eq!(Some(Match::must(0, 1..1)), it.next());
+    /// assert_eq!(Some(Match::must(0, 2..2)), it.next());
+    /// assert_eq!(Some(Match::must(0, 3..3)), it.next());
+    /// assert_eq!(Some(Match::must(0, 4..4)), it.next());
+    /// assert_eq!(Some(Match::must(0, 5..5)), it.next());
+    /// assert_eq!(None, it.next());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn config() -> Config {
+        Config::new()
+    }
+
+    /// Return a builder for configuring the construction of a `PikeVM`.
+    ///
+    /// This is a convenience routine to avoid needing to import the
+    /// [`Builder`] type in common cases.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use the builder to disable UTF-8 mode
+    /// everywhere.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::{self, pikevm::PikeVM},
+    ///     util::syntax,
+    ///     Match,
+    /// };
+    ///
+    /// let re = PikeVM::builder()
+    ///     .syntax(syntax::Config::new().utf8(false))
+    ///     .thompson(thompson::Config::new().utf8(false))
+    ///     .build(r"foo(?-u:[^b])ar.*")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
+    /// let expected = Some(Match::must(0, 1..9));
+    /// re.captures(&mut cache, haystack, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    /// Create a new empty set of capturing groups that is guaranteed to be
+    /// valid for the search APIs on this `PikeVM`.
+    ///
+    /// A `Captures` value created for a specific `PikeVM` cannot be used with
+    /// any other `PikeVM`.
+    ///
+    /// This is a convenience function for [`Captures::all`]. See the
+    /// [`Captures`] documentation for an explanation of its alternative
+    /// constructors that permit the `PikeVM` to do less work during a search,
+    /// and thus might make it faster.
+    pub fn create_captures(&self) -> Captures {
+        Captures::all(self.get_nfa().group_info().clone())
+    }
+
+    /// Create a new cache for this `PikeVM`.
+    ///
+    /// The cache returned should only be used for searches for this
+    /// `PikeVM`. If you want to reuse the cache for another `PikeVM`, then
+    /// you must call [`Cache::reset`] with that `PikeVM` (or, equivalently,
+    /// [`PikeVM::reset_cache`]).
+    pub fn create_cache(&self) -> Cache {
+        Cache::new(self)
+    }
+
+    /// Reset the given cache such that it can be used for searching with the
+    /// this `PikeVM` (and only this `PikeVM`).
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `PikeVM`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different `PikeVM`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re1 = PikeVM::new(r"\w")?;
+    /// let re2 = PikeVM::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     re1.find_iter(&mut cache, "Δ").next(),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the PikeVM we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// re2.reset_cache(&mut cache);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     re2.find_iter(&mut cache, "☃").next(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset_cache(&self, cache: &mut Cache) {
+        cache.reset(self);
+    }
+
+    /// Returns the total number of patterns compiled into this `PikeVM`.
+    ///
+    /// In the case of a `PikeVM` that contains no patterns, this returns `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the pattern length for a `PikeVM` that never
+    /// matches:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::never_match()?;
+    /// assert_eq!(re.pattern_len(), 0);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And another example for a `PikeVM` that matches at every position:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::always_match()?;
+    /// assert_eq!(re.pattern_len(), 1);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// And finally, a `PikeVM` that was constructed from multiple patterns:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(re.pattern_len(), 3);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn pattern_len(&self) -> usize {
+        self.nfa.pattern_len()
+    }
+
+    /// Return the config for this `PikeVM`.
+    #[inline]
+    pub fn get_config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Returns a reference to the underlying NFA.
+    #[inline]
+    pub fn get_nfa(&self) -> &NFA {
+        &self.nfa
+    }
+}
+
+impl PikeVM {
+    /// Returns true if and only if this `PikeVM` matches the given haystack.
+    ///
+    /// This routine may short circuit if it knows that scanning future
+    /// input will never lead to a different result. In particular, if the
+    /// underlying NFA enters a match state, then this routine will return
+    /// `true` immediately without inspecting any future input. (Consider how
+    /// this might make a difference given the regex `a+` on the haystack
+    /// `aaaaaaaaaaaaaaa`. This routine can stop after it sees the first `a`,
+    /// but routines like `find` need to continue searching because `+` is
+    /// greedy by default.)
+    ///
+    /// # Example
+    ///
+    /// This shows basic usage:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new("foo[0-9]+bar")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.is_match(&mut cache, "foo12345bar"));
+    /// assert!(!re.is_match(&mut cache, "foobar"));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: consistency with search APIs
+    ///
+    /// `is_match` is guaranteed to return `true` whenever `find` returns a
+    /// match. This includes searches that are executed entirely within a
+    /// codepoint:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Input};
+    ///
+    /// let re = PikeVM::new("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(!re.is_match(&mut cache, Input::new("☃").span(1..2)));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Notice that when UTF-8 mode is disabled, then the above reports a
+    /// match because the restriction against zero-width matches that split a
+    /// codepoint has been lifted:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::{pikevm::PikeVM, NFA}, Input};
+    ///
+    /// let re = PikeVM::builder()
+    ///     .thompson(NFA::config().utf8(false))
+    ///     .build("a*")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert!(re.is_match(&mut cache, Input::new("☃").span(1..2)));
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> bool {
+        let input = input.into().earliest(true);
+        self.search_slots(cache, &input, &mut []).is_some()
+    }
+
+    /// Executes a leftmost forward search and returns a `Match` if one exists.
+    ///
+    /// This routine only includes the overall match span. To get access to the
+    /// individual spans of each capturing group, use [`PikeVM::captures`].
+    ///
+    /// # Example
+    ///
+    /// Leftmost first match semantics corresponds to the match with the
+    /// smallest starting offset, but where the end offset is determined by
+    /// preferring earlier branches in the original regular expression. For
+    /// example, `Sam|Samwise` will match `Sam` in `Samwise`, but `Samwise|Sam`
+    /// will match `Samwise` in `Samwise`.
+    ///
+    /// Generally speaking, the "leftmost first" match is how most backtracking
+    /// regular expressions tend to work. This is in contrast to POSIX-style
+    /// regular expressions that yield "leftmost longest" matches. Namely,
+    /// both `Sam|Samwise` and `Samwise|Sam` match `Samwise` when using
+    /// leftmost longest semantics. (This crate does not currently support
+    /// leftmost longest semantics.)
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    /// let expected = Match::must(0, 0..8);
+    /// assert_eq!(Some(expected), re.find(&mut cache, "foo12345"));
+    ///
+    /// // Even though a match is found after reading the first byte (`a`),
+    /// // the leftmost first match semantics demand that we find the earliest
+    /// // match that prefers earlier parts of the pattern over later parts.
+    /// let re = PikeVM::new("abc|a")?;
+    /// let mut cache = re.create_cache();
+    /// let expected = Match::must(0, 0..3);
+    /// assert_eq!(Some(expected), re.find(&mut cache, "abc"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Option<Match> {
+        let input = input.into();
+        if self.get_nfa().pattern_len() == 1 {
+            let mut slots = [None, None];
+            let pid = self.search_slots(cache, &input, &mut slots)?;
+            let start = slots[0].unwrap().get();
+            let end = slots[1].unwrap().get();
+            return Some(Match::new(pid, Span { start, end }));
+        }
+        let ginfo = self.get_nfa().group_info();
+        let slots_len = ginfo.implicit_slot_len();
+        let mut slots = vec![None; slots_len];
+        let pid = self.search_slots(cache, &input, &mut slots)?;
+        let start = slots[pid.as_usize() * 2].unwrap().get();
+        let end = slots[pid.as_usize() * 2 + 1].unwrap().get();
+        Some(Match::new(pid, Span { start, end }))
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+    ///
+    /// let re = PikeVM::new(r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "2010-03-14", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(Span::from(0..4)), caps.get_group(1));
+    /// assert_eq!(Some(Span::from(5..7)), caps.get_group(2));
+    /// assert_eq!(Some(Span::from(8..10)), caps.get_group(3));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn captures<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+        caps: &mut Captures,
+    ) {
+        self.search(cache, &input.into(), caps)
+    }
+
+    /// Returns an iterator over all non-overlapping leftmost matches in the
+    /// given bytes. If no match exists, then the iterator yields no elements.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new("foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let text = "foo1 foo12 foo123";
+    /// let matches: Vec<Match> = re.find_iter(&mut cache, text).collect();
+    /// assert_eq!(matches, vec![
+    ///     Match::must(0, 0..4),
+    ///     Match::must(0, 5..10),
+    ///     Match::must(0, 11..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'c, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        cache: &'c mut Cache,
+        input: I,
+    ) -> FindMatches<'r, 'c, 'h> {
+        let caps = Captures::matches(self.get_nfa().group_info().clone());
+        let it = iter::Searcher::new(input.into());
+        FindMatches { re: self, cache, caps, it }
+    }
+
+    /// Returns an iterator over all non-overlapping `Captures` values. If no
+    /// match exists, then the iterator yields no elements.
+    ///
+    /// This yields the same matches as [`PikeVM::find_iter`], but it includes
+    /// the spans of all capturing groups that participate in each match.
+    ///
+    /// **Tip:** See [`util::iter::Searcher`](crate::util::iter::Searcher) for
+    /// how to correctly iterate over all matches in a haystack while avoiding
+    /// the creation of a new `Captures` value for every match. (Which you are
+    /// forced to do with an `Iterator`.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+    ///
+    /// let re = PikeVM::new("foo(?P<numbers>[0-9]+)")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let text = "foo1 foo12 foo123";
+    /// let matches: Vec<Span> = re
+    ///     .captures_iter(&mut cache, text)
+    ///     // The unwrap is OK since 'numbers' matches if the pattern matches.
+    ///     .map(|caps| caps.get_group_by_name("numbers").unwrap())
+    ///     .collect();
+    /// assert_eq!(matches, vec![
+    ///     Span::from(3..4),
+    ///     Span::from(8..10),
+    ///     Span::from(14..17),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn captures_iter<'r, 'c, 'h, I: Into<Input<'h>>>(
+        &'r self,
+        cache: &'c mut Cache,
+        input: I,
+    ) -> CapturesMatches<'r, 'c, 'h> {
+        let caps = self.create_captures();
+        let it = iter::Searcher::new(input.into());
+        CapturesMatches { re: self, cache, caps, it }
+    }
+}
+
+impl PikeVM {
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided [`Captures`]
+    /// value. If no match was found, then [`Captures::is_match`] is guaranteed
+    /// to return `false`.
+    ///
+    /// This is like [`PikeVM::captures`], but it accepts a concrete `&Input`
+    /// instead of an `Into<Input>`.
+    ///
+    /// # Example: specific pattern search
+    ///
+    /// This example shows how to build a multi-PikeVM that permits searching
+    /// for specific patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     Anchored, Match, PatternID, Input,
+    /// };
+    ///
+    /// let re = PikeVM::new_many(&["[a-z0-9]{6}", "[a-z][a-z0-9]{5}"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123";
+    ///
+    /// // Since we are using the default leftmost-first match and both
+    /// // patterns match at the same starting position, only the first pattern
+    /// // will be returned in this case when doing a search for any of the
+    /// // patterns.
+    /// let expected = Some(Match::must(0, 0..6));
+    /// re.search(&mut cache, &Input::new(haystack), &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we want to check whether some other pattern matches, then we
+    /// // can provide its pattern ID.
+    /// let expected = Some(Match::must(1, 0..6));
+    /// let input = Input::new(haystack)
+    ///     .anchored(Anchored::Pattern(PatternID::must(1)));
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: specifying the bounds of a search
+    ///
+    /// This example shows how providing the bounds of a search can produce
+    /// different results than simply sub-slicing the haystack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match, Input};
+    ///
+    /// let re = PikeVM::new(r"\b[0-9]{3}\b")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let haystack = "foo123bar";
+    ///
+    /// // Since we sub-slice the haystack, the search doesn't know about
+    /// // the larger context and assumes that `123` is surrounded by word
+    /// // boundaries. And of course, the match position is reported relative
+    /// // to the sub-slice as well, which means we get `0..3` instead of
+    /// // `3..6`.
+    /// let expected = Some(Match::must(0, 0..3));
+    /// re.search(&mut cache, &Input::new(&haystack[3..6]), &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// // But if we provide the bounds of the search within the context of the
+    /// // entire haystack, then the search can take the surrounding context
+    /// // into account. (And if we did find a match, it would be reported
+    /// // as a valid offset into `haystack` instead of its sub-slice.)
+    /// let expected = None;
+    /// let input = Input::new(haystack).range(3..6);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        caps: &mut Captures,
+    ) {
+        caps.set_pattern(None);
+        let pid = self.search_slots(cache, input, caps.slots_mut());
+        caps.set_pattern(pid);
+    }
+
+    /// Executes a leftmost forward search and writes the spans of capturing
+    /// groups that participated in a match into the provided `slots`, and
+    /// returns the matching pattern ID. The contents of the slots for patterns
+    /// other than the matching pattern are unspecified. If no match was found,
+    /// then `None` is returned and the contents of `slots` is unspecified.
+    ///
+    /// This is like [`PikeVM::search`], but it accepts a raw slots slice
+    /// instead of a `Captures` value. This is useful in contexts where you
+    /// don't want or need to allocate a `Captures`.
+    ///
+    /// It is legal to pass _any_ number of slots to this routine. If the regex
+    /// engine would otherwise write a slot offset that doesn't fit in the
+    /// provided slice, then it is simply skipped. In general though, there are
+    /// usually three slice lengths you might want to use:
+    ///
+    /// * An empty slice, if you only care about which pattern matched.
+    /// * A slice with
+    /// [`pattern_len() * 2`](crate::nfa::thompson::NFA::pattern_len)
+    /// slots, if you only care about the overall match spans for each matching
+    /// pattern.
+    /// * A slice with
+    /// [`slot_len()`](crate::util::captures::GroupInfo::slot_len) slots, which
+    /// permits recording match offsets for every capturing group in every
+    /// pattern.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the overall match offsets in a
+    /// multi-pattern search without allocating a `Captures` value. Indeed, we
+    /// can put our slots right on the stack.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID, Input};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"\pL+",
+    ///     r"\d+",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let input = Input::new("!@#123");
+    ///
+    /// // We only care about the overall match offsets here, so we just
+    /// // allocate two slots for each pattern. Each slot records the start
+    /// // and end of the match.
+    /// let mut slots = [None; 4];
+    /// let pid = re.search_slots(&mut cache, &input, &mut slots);
+    /// assert_eq!(Some(PatternID::must(1)), pid);
+    ///
+    /// // The overall match offsets are always at 'pid * 2' and 'pid * 2 + 1'.
+    /// // See 'GroupInfo' for more details on the mapping between groups and
+    /// // slot indices.
+    /// let slot_start = pid.unwrap().as_usize() * 2;
+    /// let slot_end = slot_start + 1;
+    /// assert_eq!(Some(3), slots[slot_start].map(|s| s.get()));
+    /// assert_eq!(Some(6), slots[slot_end].map(|s| s.get()));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn search_slots(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        if !utf8empty {
+            return self.search_slots_imp(cache, input, slots);
+        }
+        // There is an unfortunate special case where if the regex can
+        // match the empty string and UTF-8 mode is enabled, the search
+        // implementation requires that the slots have at least as much space
+        // to report the bounds of any match. This is so zero-width matches
+        // that split a codepoint can be filtered out.
+        //
+        // Note that if utf8empty is true, we specialize the case for when
+        // the number of patterns is 1. In that case, we can just use a stack
+        // allocation. Otherwise we resort to a heap allocation, which we
+        // convince ourselves we're fine with due to the pathological nature of
+        // this case.
+        let min = self.get_nfa().group_info().implicit_slot_len();
+        if slots.len() >= min {
+            return self.search_slots_imp(cache, input, slots);
+        }
+        if self.get_nfa().pattern_len() == 1 {
+            let mut enough = [None, None];
+            let got = self.search_slots_imp(cache, input, &mut enough);
+            // This is OK because we know `enough_slots` is strictly bigger
+            // than `slots`, otherwise this special case isn't reached.
+            slots.copy_from_slice(&enough[..slots.len()]);
+            return got;
+        }
+        let mut enough = vec![None; min];
+        let got = self.search_slots_imp(cache, input, &mut enough);
+        // This is OK because we know `enough_slots` is strictly bigger than
+        // `slots`, otherwise this special case isn't reached.
+        slots.copy_from_slice(&enough[..slots.len()]);
+        got
+    }
+
+    /// This is the actual implementation of `search_slots_imp` that
+    /// doesn't account for the special case when 1) the NFA has UTF-8 mode
+    /// enabled, 2) the NFA can match the empty string and 3) the caller has
+    /// provided an insufficient number of slots to record match offsets.
+    #[inline(never)]
+    fn search_slots_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        let (pid, end) = match self.search_imp(cache, input, slots) {
+            None => return None,
+            Some(pid) if !utf8empty => return Some(pid),
+            Some(pid) => {
+                let slot_start = pid.as_usize() * 2;
+                let slot_end = slot_start + 1;
+                // OK because we know we have a match and we know our caller
+                // provided slots are big enough (which we make true above if
+                // the caller didn't). Namely, we're only here when 'utf8empty'
+                // is true, and when that's true, we require slots for every
+                // pattern.
+                (pid, slots[slot_end].unwrap().get())
+            }
+        };
+        empty::skip_splits_fwd(input, pid, end, |input| {
+            let pid = match self.search_imp(cache, input, slots) {
+                None => return Ok(None),
+                Some(pid) => pid,
+            };
+            let slot_start = pid.as_usize() * 2;
+            let slot_end = slot_start + 1;
+            Ok(Some((pid, slots[slot_end].unwrap().get())))
+        })
+        // OK because the PikeVM never errors.
+        .unwrap()
+    }
+
+    /// Writes the set of patterns that match anywhere in the given search
+    /// configuration to `patset`. If multiple patterns match at the same
+    /// position and this `PikeVM` was configured with [`MatchKind::All`]
+    /// semantics, then all matching patterns are written to the given set.
+    ///
+    /// Unless all of the patterns in this `PikeVM` are anchored, then
+    /// generally speaking, this will visit every byte in the haystack.
+    ///
+    /// This search routine *does not* clear the pattern set. This gives some
+    /// flexibility to the caller (e.g., running multiple searches with the
+    /// same pattern set), but does make the API bug-prone if you're reusing
+    /// the same pattern set for multiple searches but intended them to be
+    /// independent.
+    ///
+    /// If a pattern ID matched but the given `PatternSet` does not have
+    /// sufficient capacity to store it, then it is not inserted and silently
+    /// dropped.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find all matching patterns in a haystack,
+    /// even when some patterns match at the same position as other patterns.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     Input, MatchKind, PatternSet,
+    /// };
+    ///
+    /// let patterns = &[
+    ///     r"\w+", r"\d+", r"\pL+", r"foo", r"bar", r"barfoo", r"foobar",
+    /// ];
+    /// let re = PikeVM::builder()
+    ///     .configure(PikeVM::config().match_kind(MatchKind::All))
+    ///     .build_many(patterns)?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("foobar");
+    /// let mut patset = PatternSet::new(re.pattern_len());
+    /// re.which_overlapping_matches(&mut cache, &input, &mut patset);
+    /// let expected = vec![0, 2, 3, 4, 6];
+    /// let got: Vec<usize> = patset.iter().map(|p| p.as_usize()).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn which_overlapping_matches(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        self.which_overlapping_imp(cache, input, patset)
+    }
+}
+
+impl PikeVM {
+    /// The implementation of standard leftmost search.
+    ///
+    /// Capturing group spans are written to `slots`, but only if requested.
+    /// `slots` can be any length. Any slot in the NFA that is activated but
+    /// which is out of bounds for the given `slots` is ignored.
+    fn search_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        cache.setup_search(slots.len());
+        if input.is_done() {
+            return None;
+        }
+        // Why do we even care about this? Well, in our 'Captures'
+        // representation, we use usize::MAX as a sentinel to indicate "no
+        // match." This isn't problematic so long as our haystack doesn't have
+        // a maximal length. Byte slices are guaranteed by Rust to have a
+        // length that fits into isize, and so this assert should always pass.
+        // But we put it here to make our assumption explicit.
+        assert!(
+            input.haystack().len() < core::usize::MAX,
+            "byte slice lengths must be less than usize MAX",
+        );
+        instrument!(|c| c.reset(&self.nfa));
+
+        // Whether we want to visit all match states instead of emulating the
+        // 'leftmost' semantics of typical backtracking regex engines.
+        let allmatches =
+            self.config.get_match_kind().continue_past_first_match();
+        let (anchored, start_id) = match self.start_config(input) {
+            None => return None,
+            Some(config) => config,
+        };
+
+        let pre =
+            if anchored { None } else { self.get_config().get_prefilter() };
+        let Cache { ref mut stack, ref mut curr, ref mut next } = cache;
+        let mut pid = None;
+        // Yes, our search doesn't end at input.end(), but includes it. This
+        // is necessary because matches are delayed by one byte, just like
+        // how the DFA engines work. The delay is used to handle look-behind
+        // assertions. In the case of the PikeVM, the delay is implemented
+        // by not considering a match to exist until it is visited in
+        // 'steps'. Technically, we know a match exists in the previous
+        // iteration via 'epsilon_closure'. (It's the same thing in NFA-to-DFA
+        // determinization. We don't mark a DFA state as a match state if it
+        // contains an NFA match state, but rather, whether the DFA state was
+        // generated by a transition from a DFA state that contains an NFA
+        // match state.)
+        let mut at = input.start();
+        while at <= input.end() {
+            // If we have no states left to visit, then there are some cases
+            // where we know we can quit early or even skip ahead.
+            if curr.set.is_empty() {
+                // We have a match and we haven't been instructed to continue
+                // on even after finding a match, so we can quit.
+                if pid.is_some() && !allmatches {
+                    break;
+                }
+                // If we're running an anchored search and we've advanced
+                // beyond the start position with no other states to try, then
+                // we will never observe a match and thus can stop.
+                if anchored && at > input.start() {
+                    break;
+                }
+                // If there no states left to explore at this position and we
+                // know we can't terminate early, then we are effectively at
+                // the starting state of the NFA. If we fell through here,
+                // we'd end up adding our '(?s-u:.)*?' prefix and it would be
+                // the only thing in 'curr'. So we might as well just skip
+                // ahead until we find something that we know might advance us
+                // forward.
+                if let Some(ref pre) = pre {
+                    let span = Span::from(at..input.end());
+                    match pre.find(input.haystack(), span) {
+                        None => break,
+                        Some(ref span) => at = span.start,
+                    }
+                }
+            }
+            // Instead of using the NFA's unanchored start state, we actually
+            // always use its anchored starting state. As a result, when doing
+            // an unanchored search, we need to simulate our own '(?s-u:.)*?'
+            // prefix, to permit a match to appear anywhere.
+            //
+            // Now, we don't *have* to do things this way. We could use the
+            // NFA's unanchored starting state and do one 'epsilon_closure'
+            // call from that starting state before the main loop here. And
+            // that is just as correct. However, it turns out to be slower
+            // than our approach here because it slightly increases the cost
+            // of processing each byte by requiring us to visit more NFA
+            // states to deal with the additional NFA states in the unanchored
+            // prefix. By simulating it explicitly here, we lower those costs
+            // substantially. The cost is itself small, but it adds up for
+            // large haystacks.
+            //
+            // In order to simulate the '(?s-u:.)*?' prefix---which is not
+            // greedy---we are careful not to perform an epsilon closure on
+            // the start state if we already have a match. Namely, if we
+            // did otherwise, we would never reach a terminating condition
+            // because there would always be additional states to process.
+            // In effect, the exclusion of running 'epsilon_closure' when
+            // we have a match corresponds to the "dead" states we have in
+            // our DFA regex engines. Namely, in a DFA, match states merely
+            // instruct the search execution to record the current offset as
+            // the most recently seen match. It is the dead state that actually
+            // indicates when to stop the search (other than EOF or quit
+            // states).
+            //
+            // However, when 'allmatches' is true, the caller has asked us to
+            // leave in every possible match state. This tends not to make a
+            // whole lot of sense in unanchored searches, because it means the
+            // search really cannot terminate until EOF. And often, in that
+            // case, you wind up skipping over a bunch of matches and are left
+            // with the "last" match. Arguably, it just doesn't make a lot of
+            // sense to run a 'leftmost' search (which is what this routine is)
+            // with 'allmatches' set to true. But the DFAs support it and this
+            // matches their behavior. (Generally, 'allmatches' is useful for
+            // overlapping searches or leftmost anchored searches to find the
+            // longest possible match by ignoring match priority.)
+            if !pid.is_some() || allmatches {
+                // Since we are adding to the 'curr' active states and since
+                // this is for the start ID, we use a slots slice that is
+                // guaranteed to have the right length but where every element
+                // is absent. This is exactly what we want, because this
+                // epsilon closure is responsible for simulating an unanchored
+                // '(?s:.)*?' prefix. It is specifically outside of any
+                // capturing groups, and thus, using slots that are always
+                // absent is correct.
+                //
+                // Note though that we can't just use '&mut []' here, since
+                // this epsilon closure may traverse through 'Captures' epsilon
+                // transitions, and thus must be able to write offsets to the
+                // slots given which are later copied to slot values in 'curr'.
+                let slots = next.slot_table.all_absent();
+                self.epsilon_closure(stack, slots, curr, input, at, start_id);
+            }
+            if let Some(x) = self.nexts(stack, curr, next, input, at, slots) {
+                pid = Some(x);
+            }
+            // Unless the caller asked us to return early, we need to mush on
+            // to see if we can extend our match. (But note that 'nexts' will
+            // quit right after seeing a match when match_kind==LeftmostFirst,
+            // as is consistent with leftmost-first match priority.)
+            if input.get_earliest() && pid.is_some() {
+                break;
+            }
+            core::mem::swap(curr, next);
+            next.set.clear();
+            at += 1;
+        }
+        instrument!(|c| c.eprint(&self.nfa));
+        pid
+    }
+
+    /// The implementation for the 'which_overlapping_matches' API. Basically,
+    /// we do a single scan through the entire haystack (unless our regex
+    /// or search is anchored) and record every pattern that matched. In
+    /// particular, when MatchKind::All is used, this supports overlapping
+    /// matches. So if we have the regexes 'sam' and 'samwise', they will
+    /// *both* be reported in the pattern set when searching the haystack
+    /// 'samwise'.
+    fn which_overlapping_imp(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+        patset: &mut PatternSet,
+    ) {
+        // NOTE: This is effectively a copy of 'search_imp' above, but with no
+        // captures support and instead writes patterns that matched directly
+        // to 'patset'. See that routine for better commentary about what's
+        // going on in this routine. We probably could unify the routines using
+        // generics or more helper routines, but I'm not sure it's worth it.
+        //
+        // NOTE: We somewhat go out of our way here to support things like
+        // 'input.get_earliest()' and 'leftmost-first' match semantics. Neither
+        // of those seem particularly relevant to this routine, but they are
+        // both supported by the DFA analogs of this routine by construction
+        // and composition, so it seems like good sense to have the PikeVM
+        // match that behavior.
+
+        cache.setup_search(0);
+        if input.is_done() {
+            return;
+        }
+        assert!(
+            input.haystack().len() < core::usize::MAX,
+            "byte slice lengths must be less than usize MAX",
+        );
+        instrument!(|c| c.reset(&self.nfa));
+
+        let allmatches =
+            self.config.get_match_kind().continue_past_first_match();
+        let (anchored, start_id) = match self.start_config(input) {
+            None => return,
+            Some(config) => config,
+        };
+
+        let Cache { ref mut stack, ref mut curr, ref mut next } = cache;
+        for at in input.start()..=input.end() {
+            let any_matches = !patset.is_empty();
+            if curr.set.is_empty() {
+                if any_matches && !allmatches {
+                    break;
+                }
+                if anchored && at > input.start() {
+                    break;
+                }
+            }
+            if !any_matches || allmatches {
+                let slots = &mut [];
+                self.epsilon_closure(stack, slots, curr, input, at, start_id);
+            }
+            self.nexts_overlapping(stack, curr, next, input, at, patset);
+            // If we found a match and filled our set, then there is no more
+            // additional info that we can provide. Thus, we can quit. We also
+            // quit if the caller asked us to stop at the earliest point that
+            // we know a match exists.
+            if patset.is_full() || input.get_earliest() {
+                break;
+            }
+            core::mem::swap(curr, next);
+            next.set.clear();
+        }
+        instrument!(|c| c.eprint(&self.nfa));
+    }
+
+    /// Process the active states in 'curr' to find the states (written to
+    /// 'next') we should process for the next byte in the haystack.
+    ///
+    /// 'stack' is used to perform a depth first traversal of the NFA when
+    /// computing an epsilon closure.
+    ///
+    /// When a match is found, the slots for that match state (in 'curr') are
+    /// copied to 'caps'. Moreover, once a match is seen, processing for 'curr'
+    /// stops (unless the PikeVM was configured with MatchKind::All semantics).
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn nexts(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr: &mut ActiveStates,
+        next: &mut ActiveStates,
+        input: &Input<'_>,
+        at: usize,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> Option<PatternID> {
+        instrument!(|c| c.record_state_set(&curr.set));
+        let mut pid = None;
+        let ActiveStates { ref set, ref mut slot_table } = *curr;
+        for sid in set.iter() {
+            pid = match self.next(stack, slot_table, next, input, at, sid) {
+                None => continue,
+                Some(pid) => Some(pid),
+            };
+            slots.copy_from_slice(slot_table.for_state(sid));
+            if !self.config.get_match_kind().continue_past_first_match() {
+                break;
+            }
+        }
+        pid
+    }
+
+    /// Like 'nexts', but for the overlapping case. This doesn't write any
+    /// slots, and instead just writes which pattern matched in 'patset'.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn nexts_overlapping(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr: &mut ActiveStates,
+        next: &mut ActiveStates,
+        input: &Input<'_>,
+        at: usize,
+        patset: &mut PatternSet,
+    ) {
+        instrument!(|c| c.record_state_set(&curr.set));
+        let utf8empty = self.get_nfa().has_empty() && self.get_nfa().is_utf8();
+        let ActiveStates { ref set, ref mut slot_table } = *curr;
+        for sid in set.iter() {
+            let pid = match self.next(stack, slot_table, next, input, at, sid)
+            {
+                None => continue,
+                Some(pid) => pid,
+            };
+            // This handles the case of finding a zero-width match that splits
+            // a codepoint. Namely, if we're in UTF-8 mode AND we know we can
+            // match the empty string, then the only valid way of getting to
+            // this point with an offset that splits a codepoint is when we
+            // have an empty match. Such matches, in UTF-8 mode, must not be
+            // reported. So we just skip them here and pretend as if we did
+            // not see a match.
+            if utf8empty && !input.is_char_boundary(at) {
+                continue;
+            }
+            let _ = patset.try_insert(pid);
+            if !self.config.get_match_kind().continue_past_first_match() {
+                break;
+            }
+        }
+    }
+
+    /// Starting from 'sid', if the position 'at' in the 'input' haystack has a
+    /// transition defined out of 'sid', then add the state transitioned to and
+    /// its epsilon closure to the 'next' set of states to explore.
+    ///
+    /// 'stack' is used by the epsilon closure computation to perform a depth
+    /// first traversal of the NFA.
+    ///
+    /// 'curr_slot_table' should be the table of slots for the current set of
+    /// states being explored. If there is a transition out of 'sid', then
+    /// sid's row in the slot table is used to perform the epsilon closure.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slot_table: &mut SlotTable,
+        next: &mut ActiveStates,
+        input: &Input<'_>,
+        at: usize,
+        sid: StateID,
+    ) -> Option<PatternID> {
+        instrument!(|c| c.record_step(sid));
+        match *self.nfa.state(sid) {
+            State::Fail
+            | State::Look { .. }
+            | State::Union { .. }
+            | State::BinaryUnion { .. }
+            | State::Capture { .. } => None,
+            State::ByteRange { ref trans } => {
+                if trans.matches(input.haystack(), at) {
+                    let slots = curr_slot_table.for_state(sid);
+                    // OK because 'at <= haystack.len() < usize::MAX', so
+                    // adding 1 will never wrap.
+                    let at = at.wrapping_add(1);
+                    self.epsilon_closure(
+                        stack, slots, next, input, at, trans.next,
+                    );
+                }
+                None
+            }
+            State::Sparse(ref sparse) => {
+                if let Some(next_sid) = sparse.matches(input.haystack(), at) {
+                    let slots = curr_slot_table.for_state(sid);
+                    // OK because 'at <= haystack.len() < usize::MAX', so
+                    // adding 1 will never wrap.
+                    let at = at.wrapping_add(1);
+                    self.epsilon_closure(
+                        stack, slots, next, input, at, next_sid,
+                    );
+                }
+                None
+            }
+            State::Dense(ref dense) => {
+                if let Some(next_sid) = dense.matches(input.haystack(), at) {
+                    let slots = curr_slot_table.for_state(sid);
+                    // OK because 'at <= haystack.len() < usize::MAX', so
+                    // adding 1 will never wrap.
+                    let at = at.wrapping_add(1);
+                    self.epsilon_closure(
+                        stack, slots, next, input, at, next_sid,
+                    );
+                }
+                None
+            }
+            State::Match { pattern_id } => Some(pattern_id),
+        }
+    }
+
+    /// Compute the epsilon closure of 'sid', writing the closure into 'next'
+    /// while copying slot values from 'curr_slots' into corresponding states
+    /// in 'next'. 'curr_slots' should be the slot values corresponding to
+    /// 'sid'.
+    ///
+    /// The given 'stack' is used to perform a depth first traversal of the
+    /// NFA by recursively following all epsilon transitions out of 'sid'.
+    /// Conditional epsilon transitions are followed if and only if they are
+    /// satisfied for the position 'at' in the 'input' haystack.
+    ///
+    /// While this routine may write to 'curr_slots', once it returns, any
+    /// writes are undone and the original values (even if absent) are
+    /// restored.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn epsilon_closure(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slots: &mut [Option<NonMaxUsize>],
+        next: &mut ActiveStates,
+        input: &Input<'_>,
+        at: usize,
+        sid: StateID,
+    ) {
+        instrument!(|c| {
+            c.record_closure(sid);
+            c.record_stack_push(sid);
+        });
+        stack.push(FollowEpsilon::Explore(sid));
+        while let Some(frame) = stack.pop() {
+            match frame {
+                FollowEpsilon::RestoreCapture { slot, offset: pos } => {
+                    curr_slots[slot] = pos;
+                }
+                FollowEpsilon::Explore(sid) => {
+                    self.epsilon_closure_explore(
+                        stack, curr_slots, next, input, at, sid,
+                    );
+                }
+            }
+        }
+    }
+
+    /// Explore all of the epsilon transitions out of 'sid'. This is mostly
+    /// split out from 'epsilon_closure' in order to clearly delineate
+    /// the actual work of computing an epsilon closure from the stack
+    /// book-keeping.
+    ///
+    /// This will push any additional explorations needed on to 'stack'.
+    ///
+    /// 'curr_slots' should refer to the slots for the currently active NFA
+    /// state. That is, the current state we are stepping through. These
+    /// slots are mutated in place as new 'Captures' states are traversed
+    /// during epsilon closure, but the slots are restored to their original
+    /// values once the full epsilon closure is completed. The ultimate use of
+    /// 'curr_slots' is to copy them to the corresponding 'next_slots', so that
+    /// the capturing group spans are forwarded from the currently active state
+    /// to the next.
+    ///
+    /// 'next' refers to the next set of active states. Computing an epsilon
+    /// closure may increase the next set of active states.
+    ///
+    /// 'input' refers to the caller's input configuration and 'at' refers to
+    /// the current position in the haystack. These are used to check whether
+    /// conditional epsilon transitions (like look-around) are satisfied at
+    /// the current position. If they aren't, then the epsilon closure won't
+    /// include them.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn epsilon_closure_explore(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slots: &mut [Option<NonMaxUsize>],
+        next: &mut ActiveStates,
+        input: &Input<'_>,
+        at: usize,
+        mut sid: StateID,
+    ) {
+        // We can avoid pushing some state IDs on to our stack in precisely
+        // the cases where a 'push(x)' would be immediately followed by a 'x
+        // = pop()'. This is achieved by this outer-loop. We simply set 'sid'
+        // to be the next state ID we want to explore once we're done with
+        // our initial exploration. In practice, this avoids a lot of stack
+        // thrashing.
+        loop {
+            instrument!(|c| c.record_set_insert(sid));
+            // Record this state as part of our next set of active states. If
+            // we've already explored it, then no need to do it again.
+            if !next.set.insert(sid) {
+                return;
+            }
+            match *self.nfa.state(sid) {
+                State::Fail
+                | State::Match { .. }
+                | State::ByteRange { .. }
+                | State::Sparse { .. }
+                | State::Dense { .. } => {
+                    next.slot_table.for_state(sid).copy_from_slice(curr_slots);
+                    return;
+                }
+                State::Look { look, next } => {
+                    // OK because we don't permit building a searcher with a
+                    // Unicode word boundary if the requisite Unicode data is
+                    // unavailable.
+                    if !self.nfa.look_matcher().matches_inline(
+                        look,
+                        input.haystack(),
+                        at,
+                    ) {
+                        return;
+                    }
+                    sid = next;
+                }
+                State::Union { ref alternates } => {
+                    sid = match alternates.get(0) {
+                        None => return,
+                        Some(&sid) => sid,
+                    };
+                    instrument!(|c| {
+                        for &alt in &alternates[1..] {
+                            c.record_stack_push(alt);
+                        }
+                    });
+                    stack.extend(
+                        alternates[1..]
+                            .iter()
+                            .copied()
+                            .rev()
+                            .map(FollowEpsilon::Explore),
+                    );
+                }
+                State::BinaryUnion { alt1, alt2 } => {
+                    sid = alt1;
+                    instrument!(|c| c.record_stack_push(sid));
+                    stack.push(FollowEpsilon::Explore(alt2));
+                }
+                State::Capture { next, slot, .. } => {
+                    // There's no need to do anything with slots that
+                    // ultimately won't be copied into the caller-provided
+                    // 'Captures' value. So we just skip dealing with them at
+                    // all.
+                    if slot.as_usize() < curr_slots.len() {
+                        instrument!(|c| c.record_stack_push(sid));
+                        stack.push(FollowEpsilon::RestoreCapture {
+                            slot,
+                            offset: curr_slots[slot],
+                        });
+                        // OK because length of a slice must fit into an isize.
+                        curr_slots[slot] = Some(NonMaxUsize::new(at).unwrap());
+                    }
+                    sid = next;
+                }
+            }
+        }
+    }
+
+    /// Return the starting configuration of a PikeVM search.
+    ///
+    /// The "start config" is basically whether the search should be anchored
+    /// or not and the NFA state ID at which to begin the search. The state ID
+    /// returned always corresponds to an anchored starting state even when the
+    /// search is unanchored. This is because the PikeVM search loop deals with
+    /// unanchored searches with an explicit epsilon closure out of the start
+    /// state.
+    ///
+    /// This routine accounts for both the caller's `Input` configuration
+    /// and the pattern itself. For example, even if the caller asks for an
+    /// unanchored search, if the pattern itself is anchored, then this will
+    /// always return 'true' because implementing an unanchored search in that
+    /// case would be incorrect.
+    ///
+    /// Similarly, if the caller requests an anchored search for a particular
+    /// pattern, then the starting state ID returned will reflect that.
+    ///
+    /// If a pattern ID is given in the input configuration that is not in
+    /// this regex, then `None` is returned.
+    fn start_config(&self, input: &Input<'_>) -> Option<(bool, StateID)> {
+        match input.get_anchored() {
+            // Only way we're unanchored is if both the caller asked for an
+            // unanchored search *and* the pattern is itself not anchored.
+            Anchored::No => Some((
+                self.nfa.is_always_start_anchored(),
+                self.nfa.start_anchored(),
+            )),
+            Anchored::Yes => Some((true, self.nfa.start_anchored())),
+            Anchored::Pattern(pid) => {
+                Some((true, self.nfa.start_pattern(pid)?))
+            }
+        }
+    }
+}
+
+/// An iterator over all non-overlapping matches for a particular search.
+///
+/// The iterator yields a [`Match`] value until no more matches could be found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the PikeVM.
+/// * `'c` represents the lifetime of the PikeVM's cache.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`PikeVM::find_iter`] method.
+#[derive(Debug)]
+pub struct FindMatches<'r, 'c, 'h> {
+    re: &'r PikeVM,
+    cache: &'c mut Cache,
+    caps: Captures,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'c, 'h> Iterator for FindMatches<'r, 'c, 'h> {
+    type Item = Match;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match> {
+        // Splitting 'self' apart seems necessary to appease borrowck.
+        let FindMatches { re, ref mut cache, ref mut caps, ref mut it } =
+            *self;
+        // 'advance' converts errors into panics, which is OK here because
+        // the PikeVM can never return an error.
+        it.advance(|input| {
+            re.search(cache, input, caps);
+            Ok(caps.get_match())
+        })
+    }
+}
+
+/// An iterator over all non-overlapping leftmost matches, with their capturing
+/// groups, for a particular search.
+///
+/// The iterator yields a [`Captures`] value until no more matches could be
+/// found.
+///
+/// The lifetime parameters are as follows:
+///
+/// * `'r` represents the lifetime of the PikeVM.
+/// * `'c` represents the lifetime of the PikeVM's cache.
+/// * `'h` represents the lifetime of the haystack being searched.
+///
+/// This iterator can be created with the [`PikeVM::captures_iter`] method.
+#[derive(Debug)]
+pub struct CapturesMatches<'r, 'c, 'h> {
+    re: &'r PikeVM,
+    cache: &'c mut Cache,
+    caps: Captures,
+    it: iter::Searcher<'h>,
+}
+
+impl<'r, 'c, 'h> Iterator for CapturesMatches<'r, 'c, 'h> {
+    type Item = Captures;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures> {
+        // Splitting 'self' apart seems necessary to appease borrowck.
+        let CapturesMatches { re, ref mut cache, ref mut caps, ref mut it } =
+            *self;
+        // 'advance' converts errors into panics, which is OK here because
+        // the PikeVM can never return an error.
+        it.advance(|input| {
+            re.search(cache, input, caps);
+            Ok(caps.get_match())
+        });
+        if caps.is_match() {
+            Some(caps.clone())
+        } else {
+            None
+        }
+    }
+}
+
+/// A cache represents mutable state that a [`PikeVM`] requires during a
+/// search.
+///
+/// For a given [`PikeVM`], its corresponding cache may be created either via
+/// [`PikeVM::create_cache`], or via [`Cache::new`]. They are equivalent in
+/// every way, except the former does not require explicitly importing `Cache`.
+///
+/// A particular `Cache` is coupled with the [`PikeVM`] from which it
+/// was created. It may only be used with that `PikeVM`. A cache and its
+/// allocations may be re-purposed via [`Cache::reset`], in which case, it can
+/// only be used with the new `PikeVM` (and not the old one).
+#[derive(Clone, Debug)]
+pub struct Cache {
+    /// Stack used while computing epsilon closure. This effectively lets us
+    /// move what is more naturally expressed through recursion to a stack
+    /// on the heap.
+    stack: Vec<FollowEpsilon>,
+    /// The current active states being explored for the current byte in the
+    /// haystack.
+    curr: ActiveStates,
+    /// The next set of states we're building that will be explored for the
+    /// next byte in the haystack.
+    next: ActiveStates,
+}
+
+impl Cache {
+    /// Create a new [`PikeVM`] cache.
+    ///
+    /// A potentially more convenient routine to create a cache is
+    /// [`PikeVM::create_cache`], as it does not require also importing the
+    /// `Cache` type.
+    ///
+    /// If you want to reuse the returned `Cache` with some other `PikeVM`,
+    /// then you must call [`Cache::reset`] with the desired `PikeVM`.
+    pub fn new(re: &PikeVM) -> Cache {
+        Cache {
+            stack: vec![],
+            curr: ActiveStates::new(re),
+            next: ActiveStates::new(re),
+        }
+    }
+
+    /// Reset this cache such that it can be used for searching with a
+    /// different [`PikeVM`].
+    ///
+    /// A cache reset permits reusing memory already allocated in this cache
+    /// with a different `PikeVM`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to re-purpose a cache for use with a different `PikeVM`.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re1 = PikeVM::new(r"\w")?;
+    /// let re2 = PikeVM::new(r"\W")?;
+    ///
+    /// let mut cache = re1.create_cache();
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..2)),
+    ///     re1.find_iter(&mut cache, "Δ").next(),
+    /// );
+    ///
+    /// // Using 'cache' with re2 is not allowed. It may result in panics or
+    /// // incorrect results. In order to re-purpose the cache, we must reset
+    /// // it with the PikeVM we'd like to use it with.
+    /// //
+    /// // Similarly, after this reset, using the cache with 're1' is also not
+    /// // allowed.
+    /// cache.reset(&re2);
+    /// assert_eq!(
+    ///     Some(Match::must(0, 0..3)),
+    ///     re2.find_iter(&mut cache, "☃").next(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn reset(&mut self, re: &PikeVM) {
+        self.curr.reset(re);
+        self.next.reset(re);
+    }
+
+    /// Returns the heap memory usage, in bytes, of this cache.
+    ///
+    /// This does **not** include the stack size used up by this cache. To
+    /// compute that, use `std::mem::size_of::<Cache>()`.
+    pub fn memory_usage(&self) -> usize {
+        use core::mem::size_of;
+        (self.stack.len() * size_of::<FollowEpsilon>())
+            + self.curr.memory_usage()
+            + self.next.memory_usage()
+    }
+
+    /// Clears this cache. This should be called at the start of every search
+    /// to ensure we start with a clean slate.
+    ///
+    /// This also sets the length of the capturing groups used in the current
+    /// search. This permits an optimization where by 'SlotTable::for_state'
+    /// only returns the number of slots equivalent to the number of slots
+    /// given in the 'Captures' value. This may be less than the total number
+    /// of possible slots, e.g., when one only wants to track overall match
+    /// offsets. This in turn permits less copying of capturing group spans
+    /// in the PikeVM.
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.stack.clear();
+        self.curr.setup_search(captures_slot_len);
+        self.next.setup_search(captures_slot_len);
+    }
+}
+
+/// A set of active states used to "simulate" the execution of an NFA via the
+/// PikeVM.
+///
+/// There are two sets of these used during NFA simulation. One set corresponds
+/// to the "current" set of states being traversed for the current position
+/// in a haystack. The other set corresponds to the "next" set of states being
+/// built, which will become the new "current" set for the next position in the
+/// haystack. These two sets correspond to CLIST and NLIST in Thompson's
+/// original paper regexes: https://dl.acm.org/doi/pdf/10.1145/363347.363387
+///
+/// In addition to representing a set of NFA states, this also maintains slot
+/// values for each state. These slot values are what turn the NFA simulation
+/// into the "Pike VM." Namely, they track capturing group values for each
+/// state. During the computation of epsilon closure, we copy slot values from
+/// states in the "current" set to the "next" set. Eventually, once a match
+/// is found, the slot values for that match state are what we write to the
+/// caller provided 'Captures' value.
+#[derive(Clone, Debug)]
+struct ActiveStates {
+    /// The set of active NFA states. This set preserves insertion order, which
+    /// is critical for simulating the match semantics of backtracking regex
+    /// engines.
+    set: SparseSet,
+    /// The slots for every NFA state, where each slot stores a (possibly
+    /// absent) offset. Every capturing group has two slots. One for a start
+    /// offset and one for an end offset.
+    slot_table: SlotTable,
+}
+
+impl ActiveStates {
+    /// Create a new set of active states for the given PikeVM. The active
+    /// states returned may only be used with the given PikeVM. (Use 'reset'
+    /// to re-purpose the allocation for a different PikeVM.)
+    fn new(re: &PikeVM) -> ActiveStates {
+        let mut active = ActiveStates {
+            set: SparseSet::new(0),
+            slot_table: SlotTable::new(),
+        };
+        active.reset(re);
+        active
+    }
+
+    /// Reset this set of active states such that it can be used with the given
+    /// PikeVM (and only that PikeVM).
+    fn reset(&mut self, re: &PikeVM) {
+        self.set.resize(re.get_nfa().states().len());
+        self.slot_table.reset(re);
+    }
+
+    /// Return the heap memory usage, in bytes, used by this set of active
+    /// states.
+    ///
+    /// This does not include the stack size of this value.
+    fn memory_usage(&self) -> usize {
+        self.set.memory_usage() + self.slot_table.memory_usage()
+    }
+
+    /// Setup this set of active states for a new search. The given slot
+    /// length should be the number of slots in a caller provided 'Captures'
+    /// (and may be zero).
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.set.clear();
+        self.slot_table.setup_search(captures_slot_len);
+    }
+}
+
+/// A table of slots, where each row represent a state in an NFA. Thus, the
+/// table has room for storing slots for every single state in an NFA.
+///
+/// This table is represented with a single contiguous allocation. In general,
+/// the notion of "capturing group" doesn't really exist at this level of
+/// abstraction, hence the name "slot" instead. (Indeed, every capturing group
+/// maps to a pair of slots, one for the start offset and one for the end
+/// offset.) Slots are indexed by the 'Captures' NFA state.
+///
+/// N.B. Not every state actually needs a row of slots. Namely, states that
+/// only have epsilon transitions currently never have anything written to
+/// their rows in this table. Thus, the table is somewhat wasteful in its heap
+/// usage. However, it is important to maintain fast random access by state
+/// ID, which means one giant table tends to work well. RE2 takes a different
+/// approach here and allocates each row as its own reference counted thing.
+/// I explored such a strategy at one point here, but couldn't get it to work
+/// well using entirely safe code. (To the ambitious reader: I encourage you to
+/// re-litigate that experiment.) I very much wanted to stick to safe code, but
+/// could be convinced otherwise if there was a solid argument and the safety
+/// was encapsulated well.
+#[derive(Clone, Debug)]
+struct SlotTable {
+    /// The actual table of offsets.
+    table: Vec<Option<NonMaxUsize>>,
+    /// The number of slots per state, i.e., the table's stride or the length
+    /// of each row.
+    slots_per_state: usize,
+    /// The number of slots in the caller-provided 'Captures' value for the
+    /// current search. Setting this to 'slots_per_state' is always correct,
+    /// but may be wasteful.
+    slots_for_captures: usize,
+}
+
+impl SlotTable {
+    /// Create a new slot table.
+    ///
+    /// One should call 'reset' with the corresponding PikeVM before use.
+    fn new() -> SlotTable {
+        SlotTable { table: vec![], slots_for_captures: 0, slots_per_state: 0 }
+    }
+
+    /// Reset this slot table such that it can be used with the given PikeVM
+    /// (and only that PikeVM).
+    fn reset(&mut self, re: &PikeVM) {
+        let nfa = re.get_nfa();
+        self.slots_per_state = nfa.group_info().slot_len();
+        // This is always correct, but may be reduced for a particular search
+        // if a 'Captures' has fewer slots, e.g., none at all or only slots
+        // for tracking the overall match instead of all slots for every
+        // group.
+        self.slots_for_captures = nfa.group_info().slot_len();
+        let len = nfa
+            .states()
+            .len()
+            // We add 1 so that our last row is always empty. We use it as
+            // "scratch" space for computing the epsilon closure off of the
+            // starting state.
+            .checked_add(1)
+            .and_then(|x| x.checked_mul(self.slots_per_state))
+            // It seems like this could actually panic on legitimate inputs on
+            // 32-bit targets, and very likely to panic on 16-bit. Should we
+            // somehow convert this to an error? What about something similar
+            // for the lazy DFA cache? If you're tripping this assert, please
+            // file a bug.
+            .expect("slot table length doesn't overflow");
+        // This happens about as often as a regex is compiled, so it probably
+        // should be at debug level, but I found it quite distracting and not
+        // particularly useful.
+        trace!(
+            "resizing PikeVM active states table to {} entries \
+             (slots_per_state={})",
+            len,
+            self.slots_per_state,
+        );
+        self.table.resize(len, None);
+    }
+
+    /// Return the heap memory usage, in bytes, used by this slot table.
+    ///
+    /// This does not include the stack size of this value.
+    fn memory_usage(&self) -> usize {
+        self.table.len() * core::mem::size_of::<Option<NonMaxUsize>>()
+    }
+
+    /// Perform any per-search setup for this slot table.
+    ///
+    /// In particular, this sets the length of the number of slots used in the
+    /// 'Captures' given by the caller (if any at all). This number may be
+    /// smaller than the total number of slots available, e.g., when the caller
+    /// is only interested in tracking the overall match and not the spans of
+    /// every matching capturing group. Only tracking the overall match can
+    /// save a substantial amount of time copying capturing spans during a
+    /// search.
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.slots_for_captures = captures_slot_len;
+    }
+
+    /// Return a mutable slice of the slots for the given state.
+    ///
+    /// Note that the length of the slice returned may be less than the total
+    /// number of slots available for this state. In particular, the length
+    /// always matches the number of slots indicated via 'setup_search'.
+    fn for_state(&mut self, sid: StateID) -> &mut [Option<NonMaxUsize>] {
+        let i = sid.as_usize() * self.slots_per_state;
+        &mut self.table[i..i + self.slots_for_captures]
+    }
+
+    /// Return a slice of slots of appropriate length where every slot offset
+    /// is guaranteed to be absent. This is useful in cases where you need to
+    /// compute an epsilon closure outside of the user supplied regex, and thus
+    /// never want it to have any capturing slots set.
+    fn all_absent(&mut self) -> &mut [Option<NonMaxUsize>] {
+        let i = self.table.len() - self.slots_per_state;
+        &mut self.table[i..i + self.slots_for_captures]
+    }
+}
+
+/// Represents a stack frame for use while computing an epsilon closure.
+///
+/// (An "epsilon closure" refers to the set of reachable NFA states from a
+/// single state without consuming any input. That is, the set of all epsilon
+/// transitions not only from that single state, but from every other state
+/// reachable by an epsilon transition as well. This is why it's called a
+/// "closure." Computing an epsilon closure is also done during DFA
+/// determinization! Compare and contrast the epsilon closure here in this
+/// PikeVM and the one used for determinization in crate::util::determinize.)
+///
+/// Computing the epsilon closure in a Thompson NFA proceeds via a depth
+/// first traversal over all epsilon transitions from a particular state.
+/// (A depth first traversal is important because it emulates the same priority
+/// of matches that is typically found in backtracking regex engines.) This
+/// depth first traversal is naturally expressed using recursion, but to avoid
+/// a call stack size proportional to the size of a regex, we put our stack on
+/// the heap instead.
+///
+/// This stack thus consists of call frames. The typical call frame is
+/// `Explore`, which instructs epsilon closure to explore the epsilon
+/// transitions from that state. (Subsequent epsilon transitions are then
+/// pushed on to the stack as more `Explore` frames.) If the state ID being
+/// explored has no epsilon transitions, then the capturing group slots are
+/// copied from the original state that sparked the epsilon closure (from the
+/// 'step' routine) to the state ID being explored. This way, capturing group
+/// slots are forwarded from the previous state to the next.
+///
+/// The other stack frame, `RestoreCaptures`, instructs the epsilon closure to
+/// set the position for a particular slot back to some particular offset. This
+/// frame is pushed when `Explore` sees a `Capture` transition. `Explore` will
+/// set the offset of the slot indicated in `Capture` to the current offset,
+/// and then push the old offset on to the stack as a `RestoreCapture` frame.
+/// Thus, the new offset is only used until the epsilon closure reverts back to
+/// the `RestoreCapture` frame. In effect, this gives the `Capture` epsilon
+/// transition its "scope" to only states that come "after" it during depth
+/// first traversal.
+#[derive(Clone, Debug)]
+enum FollowEpsilon {
+    /// Explore the epsilon transitions from a state ID.
+    Explore(StateID),
+    /// Reset the given `slot` to the given `offset` (which might be `None`).
+    RestoreCapture { slot: SmallIndex, offset: Option<NonMaxUsize> },
+}
+
+/// A set of counters that "instruments" a PikeVM search. To enable this, you
+/// must enable the 'internal-instrument-pikevm' feature. Then run your Rust
+/// program with RUST_LOG=regex_automata::nfa::thompson::pikevm=trace set in
+/// the environment. The metrics collected will be dumped automatically for
+/// every search executed by the PikeVM.
+///
+/// NOTE: When 'internal-instrument-pikevm' is enabled, it will likely cause an
+/// absolute decrease in wall-clock performance, even if the 'trace' log level
+/// isn't enabled. (Although, we do try to avoid extra costs when 'trace' isn't
+/// enabled.) The main point of instrumentation is to get counts of various
+/// events that occur during the PikeVM's execution.
+///
+/// This is a somewhat hacked together collection of metrics that are useful
+/// to gather from a PikeVM search. In particular, it lets us scrutinize the
+/// performance profile of a search beyond what general purpose profiling tools
+/// give us. Namely, we orient the profiling data around the specific states of
+/// the NFA.
+///
+/// In other words, this lets us see which parts of the NFA graph are most
+/// frequently activated. This then provides direction for optimization
+/// opportunities.
+///
+/// The really sad part about this is that it absolutely clutters up the PikeVM
+/// implementation. :'( Another approach would be to just manually add this
+/// code in whenever I want this kind of profiling data, but it's complicated
+/// and tedious enough that I went with this approach... for now.
+///
+/// When instrumentation is enabled (which also turns on 'logging'), then a
+/// `Counters` is initialized for every search and `trace`'d just before the
+/// search returns to the caller.
+///
+/// Tip: When debugging performance problems with the PikeVM, it's best to try
+/// to work with an NFA that is as small as possible. Otherwise the state graph
+/// is likely to be too big to digest.
+#[cfg(feature = "internal-instrument-pikevm")]
+#[derive(Clone, Debug)]
+struct Counters {
+    /// The number of times the NFA is in a particular permutation of states.
+    state_sets: alloc::collections::BTreeMap<Vec<StateID>, u64>,
+    /// The number of times 'step' is called for a particular state ID (which
+    /// indexes this array).
+    steps: Vec<u64>,
+    /// The number of times an epsilon closure was computed for a state.
+    closures: Vec<u64>,
+    /// The number of times a particular state ID is pushed on to a stack while
+    /// computing an epsilon closure.
+    stack_pushes: Vec<u64>,
+    /// The number of times a particular state ID is inserted into a sparse set
+    /// while computing an epsilon closure.
+    set_inserts: Vec<u64>,
+}
+
+#[cfg(feature = "internal-instrument-pikevm")]
+impl Counters {
+    fn empty() -> Counters {
+        Counters {
+            state_sets: alloc::collections::BTreeMap::new(),
+            steps: vec![],
+            closures: vec![],
+            stack_pushes: vec![],
+            set_inserts: vec![],
+        }
+    }
+
+    fn reset(&mut self, nfa: &NFA) {
+        let len = nfa.states().len();
+
+        self.state_sets.clear();
+
+        self.steps.clear();
+        self.steps.resize(len, 0);
+
+        self.closures.clear();
+        self.closures.resize(len, 0);
+
+        self.stack_pushes.clear();
+        self.stack_pushes.resize(len, 0);
+
+        self.set_inserts.clear();
+        self.set_inserts.resize(len, 0);
+    }
+
+    fn eprint(&self, nfa: &NFA) {
+        trace!("===== START PikeVM Instrumentation Output =====");
+        // We take the top-K most occurring state sets. Otherwise the output
+        // is likely to be overwhelming. And we probably only care about the
+        // most frequently occuring ones anyway.
+        const LIMIT: usize = 20;
+        let mut set_counts =
+            self.state_sets.iter().collect::<Vec<(&Vec<StateID>, &u64)>>();
+        set_counts.sort_by_key(|(_, &count)| core::cmp::Reverse(count));
+        trace!("## PikeVM frequency of state sets (top {})", LIMIT);
+        for (set, count) in set_counts.iter().take(LIMIT) {
+            trace!("{:?}: {}", set, count);
+        }
+        if set_counts.len() > LIMIT {
+            trace!(
+                "... {} sets omitted (out of {} total)",
+                set_counts.len() - LIMIT,
+                set_counts.len(),
+            );
+        }
+
+        trace!("");
+        trace!("## PikeVM total frequency of events");
+        trace!(
+            "steps: {}, closures: {}, stack-pushes: {}, set-inserts: {}",
+            self.steps.iter().copied().sum::<u64>(),
+            self.closures.iter().copied().sum::<u64>(),
+            self.stack_pushes.iter().copied().sum::<u64>(),
+            self.set_inserts.iter().copied().sum::<u64>(),
+        );
+
+        trace!("");
+        trace!("## PikeVM frequency of events broken down by state");
+        for sid in 0..self.steps.len() {
+            trace!(
+                "{:06}: steps: {}, closures: {}, \
+                 stack-pushes: {}, set-inserts: {}",
+                sid,
+                self.steps[sid],
+                self.closures[sid],
+                self.stack_pushes[sid],
+                self.set_inserts[sid],
+            );
+        }
+
+        trace!("");
+        trace!("## NFA debug display");
+        trace!("{:?}", nfa);
+        trace!("===== END PikeVM Instrumentation Output =====");
+    }
+
+    fn record_state_set(&mut self, set: &SparseSet) {
+        let set = set.iter().collect::<Vec<StateID>>();
+        *self.state_sets.entry(set).or_insert(0) += 1;
+    }
+
+    fn record_step(&mut self, sid: StateID) {
+        self.steps[sid] += 1;
+    }
+
+    fn record_closure(&mut self, sid: StateID) {
+        self.closures[sid] += 1;
+    }
+
+    fn record_stack_push(&mut self, sid: StateID) {
+        self.stack_pushes[sid] += 1;
+    }
+
+    fn record_set_insert(&mut self, sid: StateID) {
+        self.set_inserts[sid] += 1;
+    }
+}
diff --git a/regex-automata/src/nfa/thompson/range_trie.rs b/regex-automata/src/nfa/thompson/range_trie.rs
new file mode 100644
index 0000000000..2522e7fe01
--- /dev/null
+++ b/regex-automata/src/nfa/thompson/range_trie.rs
@@ -0,0 +1,1055 @@
+/*
+I've called the primary data structure in this module a "range trie." As far
+as I can tell, there is no prior art on a data structure like this, however,
+it's likely someone somewhere has built something like it. Searching for
+"range trie" turns up the paper "Range Tries for Scalable Address Lookup,"
+but it does not appear relevant.
+
+The range trie is just like a trie in that it is a special case of a
+deterministic finite state machine. It has states and each state has a set
+of transitions to other states. It is acyclic, and, like a normal trie,
+it makes no attempt to reuse common suffixes among its elements. The key
+difference between a normal trie and a range trie below is that a range trie
+operates on *contiguous sequences* of bytes instead of singleton bytes.
+One could say say that our alphabet is ranges of bytes instead of bytes
+themselves, except a key part of range trie construction is splitting ranges
+apart to ensure there is at most one transition that can be taken for any
+byte in a given state.
+
+I've tried to explain the details of how the range trie works below, so
+for now, we are left with trying to understand what problem we're trying to
+solve. Which is itself fairly involved!
+
+At the highest level, here's what we want to do. We want to convert a
+sequence of Unicode codepoints into a finite state machine whose transitions
+are over *bytes* and *not* Unicode codepoints. We want this because it makes
+said finite state machines much smaller and much faster to execute. As a
+simple example, consider a byte oriented automaton for all Unicode scalar
+values (0x00 through 0x10FFFF, not including surrogate codepoints):
+
+    [00-7F]
+    [C2-DF][80-BF]
+    [E0-E0][A0-BF][80-BF]
+    [E1-EC][80-BF][80-BF]
+    [ED-ED][80-9F][80-BF]
+    [EE-EF][80-BF][80-BF]
+    [F0-F0][90-BF][80-BF][80-BF]
+    [F1-F3][80-BF][80-BF][80-BF]
+    [F4-F4][80-8F][80-BF][80-BF]
+
+(These byte ranges are generated via the regex-syntax::utf8 module, which
+was based on Russ Cox's code in RE2, which was in turn based on Ken
+Thompson's implementation of the same idea in his Plan9 implementation of
+grep.)
+
+It should be fairly straight-forward to see how one could compile this into
+a DFA. The sequences are sorted and non-overlapping. Essentially, you could
+build a trie from this fairly easy. The problem comes when your initial
+range (in this case, 0x00-0x10FFFF) isn't so nice. For example, the class
+represented by '\w' contains only a tenth of the codepoints that
+0x00-0x10FFFF contains, but if we were to write out the byte based ranges
+as we did above, the list would stretch to 892 entries! This turns into
+quite a large NFA with a few thousand states. Turning this beast into a DFA
+takes quite a bit of time. We are thus left with trying to trim down the
+number of states we produce as early as possible.
+
+One approach (used by RE2 and still by the regex crate, at time of writing)
+is to try to find common suffixes while building NFA states for the above
+and reuse them. This is very cheap to do and one can control precisely how
+much extra memory you want to use for the cache.
+
+Another approach, however, is to reuse an algorithm for constructing a
+*minimal* DFA from a sorted sequence of inputs. I don't want to go into
+the full details here, but I explain it in more depth in my blog post on
+FSTs[1]. Note that the algorithm was not invented by me, but was published
+in paper by Daciuk et al. in 2000 called "Incremental Construction of
+MinimalAcyclic Finite-State Automata." Like the suffix cache approach above,
+it is also possible to control the amount of extra memory one uses, although
+this usually comes with the cost of sacrificing true minimality. (But it's
+typically close enough with a reasonably sized cache of states.)
+
+The catch is that Daciuk's algorithm only works if you add your keys in
+lexicographic ascending order. In our case, since we're dealing with ranges,
+we also need the additional requirement that ranges are either equivalent
+or do not overlap at all. For example, if one were given the following byte
+ranges:
+
+    [BC-BF][80-BF]
+    [BC-BF][90-BF]
+
+Then Daciuk's algorithm would not work, since there is nothing to handle the
+fact that the ranges overlap. They would need to be split apart. Thankfully,
+Thompson's algorithm for producing byte ranges for Unicode codepoint ranges
+meets both of our requirements. (A proof for this eludes me, but it appears
+true.)
+
+... however, we would also like to be able to compile UTF-8 automata in
+reverse. We want this because in order to find the starting location of a
+match using a DFA, we need to run a second DFA---a reversed version of the
+forward DFA---backwards to discover the match location. Unfortunately, if
+we reverse our byte sequences for 0x00-0x10FFFF, we get sequences that are
+can overlap, even if they are sorted:
+
+    [00-7F]
+    [80-BF][80-9F][ED-ED]
+    [80-BF][80-BF][80-8F][F4-F4]
+    [80-BF][80-BF][80-BF][F1-F3]
+    [80-BF][80-BF][90-BF][F0-F0]
+    [80-BF][80-BF][E1-EC]
+    [80-BF][80-BF][EE-EF]
+    [80-BF][A0-BF][E0-E0]
+    [80-BF][C2-DF]
+
+For example, '[80-BF][80-BF][EE-EF]' and '[80-BF][A0-BF][E0-E0]' have
+overlapping ranges between '[80-BF]' and '[A0-BF]'. Thus, there is no
+simple way to apply Daciuk's algorithm.
+
+And thus, the range trie was born. The range trie's only purpose is to take
+sequences of byte ranges like the ones above, collect them into a trie and then
+spit them out in a sorted fashion with no overlapping ranges. For example,
+0x00-0x10FFFF gets translated to:
+
+    [0-7F]
+    [80-BF][80-9F][80-8F][F1-F3]
+    [80-BF][80-9F][80-8F][F4]
+    [80-BF][80-9F][90-BF][F0]
+    [80-BF][80-9F][90-BF][F1-F3]
+    [80-BF][80-9F][E1-EC]
+    [80-BF][80-9F][ED]
+    [80-BF][80-9F][EE-EF]
+    [80-BF][A0-BF][80-8F][F1-F3]
+    [80-BF][A0-BF][80-8F][F4]
+    [80-BF][A0-BF][90-BF][F0]
+    [80-BF][A0-BF][90-BF][F1-F3]
+    [80-BF][A0-BF][E0]
+    [80-BF][A0-BF][E1-EC]
+    [80-BF][A0-BF][EE-EF]
+    [80-BF][C2-DF]
+
+We've thus satisfied our requirements for running Daciuk's algorithm. All
+sequences of ranges are sorted, and any corresponding ranges are either
+exactly equivalent or non-overlapping.
+
+In effect, a range trie is building a DFA from a sequence of arbitrary byte
+ranges. But it uses an algoritm custom tailored to its input, so it is not as
+costly as traditional DFA construction. While it is still quite a bit more
+costly than the forward case (which only needs Daciuk's algorithm), it winds
+up saving a substantial amount of time if one is doing a full DFA powerset
+construction later by virtue of producing a much much smaller NFA.
+
+[1] - https://blog.burntsushi.net/transducers/
+[2] - https://www.mitpressjournals.org/doi/pdfplus/10.1162/089120100561601
+*/
+
+use core::{cell::RefCell, convert::TryFrom, fmt, mem, ops::RangeInclusive};
+
+use alloc::{format, string::String, vec, vec::Vec};
+
+use regex_syntax::utf8::Utf8Range;
+
+use crate::util::primitives::StateID;
+
+/// There is only one final state in this trie. Every sequence of byte ranges
+/// added shares the same final state.
+const FINAL: StateID = StateID::ZERO;
+
+/// The root state of the trie.
+const ROOT: StateID = StateID::new_unchecked(1);
+
+/// A range trie represents an ordered set of sequences of bytes.
+///
+/// A range trie accepts as input a sequence of byte ranges and merges
+/// them into the existing set such that the trie can produce a sorted
+/// non-overlapping sequence of byte ranges. The sequence emitted corresponds
+/// precisely to the sequence of bytes matched by the given keys, although the
+/// byte ranges themselves may be split at different boundaries.
+///
+/// The order complexity of this data structure seems difficult to analyze.
+/// If the size of a byte is held as a constant, then insertion is clearly
+/// O(n) where n is the number of byte ranges in the input key. However, if
+/// k=256 is our alphabet size, then insertion could be O(k^2 * n). In
+/// particular it seems possible for pathological inputs to cause insertion
+/// to do a lot of work. However, for what we use this data structure for,
+/// there should be no pathological inputs since the ultimate source is always
+/// a sorted set of Unicode scalar value ranges.
+///
+/// Internally, this trie is setup like a finite state machine. Note though
+/// that it is acyclic.
+#[derive(Clone)]
+pub struct RangeTrie {
+    /// The states in this trie. The first is always the shared final state.
+    /// The second is always the root state. Otherwise, there is no
+    /// particular order.
+    states: Vec<State>,
+    /// A free-list of states. When a range trie is cleared, all of its states
+    /// are added to this list. Creating a new state reuses states from this
+    /// list before allocating a new one.
+    free: Vec<State>,
+    /// A stack for traversing this trie to yield sequences of byte ranges in
+    /// lexicographic order.
+    iter_stack: RefCell<Vec<NextIter>>,
+    /// A bufer that stores the current sequence during iteration.
+    iter_ranges: RefCell<Vec<Utf8Range>>,
+    /// A stack used for traversing the trie in order to (deeply) duplicate
+    /// a state. States are recursively duplicated when ranges are split.
+    dupe_stack: Vec<NextDupe>,
+    /// A stack used for traversing the trie during insertion of a new
+    /// sequence of byte ranges.
+    insert_stack: Vec<NextInsert>,
+}
+
+/// A single state in this trie.
+#[derive(Clone)]
+struct State {
+    /// A sorted sequence of non-overlapping transitions to other states. Each
+    /// transition corresponds to a single range of bytes.
+    transitions: Vec<Transition>,
+}
+
+/// A transition is a single range of bytes. If a particular byte is in this
+/// range, then the corresponding machine may transition to the state pointed
+/// to by `next_id`.
+#[derive(Clone)]
+struct Transition {
+    /// The byte range.
+    range: Utf8Range,
+    /// The next state to transition to.
+    next_id: StateID,
+}
+
+impl RangeTrie {
+    /// Create a new empty range trie.
+    pub fn new() -> RangeTrie {
+        let mut trie = RangeTrie {
+            states: vec![],
+            free: vec![],
+            iter_stack: RefCell::new(vec![]),
+            iter_ranges: RefCell::new(vec![]),
+            dupe_stack: vec![],
+            insert_stack: vec![],
+        };
+        trie.clear();
+        trie
+    }
+
+    /// Clear this range trie such that it is empty. Clearing a range trie
+    /// and reusing it can beneficial because this may reuse allocations.
+    pub fn clear(&mut self) {
+        self.free.extend(self.states.drain(..));
+        self.add_empty(); // final
+        self.add_empty(); // root
+    }
+
+    /// Iterate over all of the sequences of byte ranges in this trie, and
+    /// call the provided function for each sequence. Iteration occurs in
+    /// lexicographic order.
+    pub fn iter<E, F: FnMut(&[Utf8Range]) -> Result<(), E>>(
+        &self,
+        mut f: F,
+    ) -> Result<(), E> {
+        let mut stack = self.iter_stack.borrow_mut();
+        stack.clear();
+        let mut ranges = self.iter_ranges.borrow_mut();
+        ranges.clear();
+
+        // We do iteration in a way that permits us to use a single buffer
+        // for our keys. We iterate in a depth first fashion, while being
+        // careful to expand our frontier as we move deeper in the trie.
+        stack.push(NextIter { state_id: ROOT, tidx: 0 });
+        while let Some(NextIter { mut state_id, mut tidx }) = stack.pop() {
+            // This could be implemented more simply without an inner loop
+            // here, but at the cost of more stack pushes.
+            loop {
+                let state = self.state(state_id);
+                // If we've visited all transitions in this state, then pop
+                // back to the parent state.
+                if tidx >= state.transitions.len() {
+                    ranges.pop();
+                    break;
+                }
+
+                let t = &state.transitions[tidx];
+                ranges.push(t.range);
+                if t.next_id == FINAL {
+                    f(&ranges)?;
+                    ranges.pop();
+                    tidx += 1;
+                } else {
+                    // Expand our frontier. Once we come back to this state
+                    // via the stack, start in on the next transition.
+                    stack.push(NextIter { state_id, tidx: tidx + 1 });
+                    // Otherwise, move to the first transition of the next
+                    // state.
+                    state_id = t.next_id;
+                    tidx = 0;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Inserts a new sequence of ranges into this trie.
+    ///
+    /// The sequence given must be non-empty and must not have a length
+    /// exceeding 4.
+    pub fn insert(&mut self, ranges: &[Utf8Range]) {
+        assert!(!ranges.is_empty());
+        assert!(ranges.len() <= 4);
+
+        let mut stack = mem::replace(&mut self.insert_stack, vec![]);
+        stack.clear();
+
+        stack.push(NextInsert::new(ROOT, ranges));
+        while let Some(next) = stack.pop() {
+            let (state_id, ranges) = (next.state_id(), next.ranges());
+            assert!(!ranges.is_empty());
+
+            let (mut new, rest) = (ranges[0], &ranges[1..]);
+
+            // i corresponds to the position of the existing transition on
+            // which we are operating. Typically, the result is to remove the
+            // transition and replace it with two or more new transitions
+            // corresponding to the partitions generated by splitting the
+            // 'new' with the ith transition's range.
+            let mut i = self.state(state_id).find(new);
+
+            // In this case, there is no overlap *and* the new range is greater
+            // than all existing ranges. So we can just add it to the end.
+            if i == self.state(state_id).transitions.len() {
+                let next_id = NextInsert::push(self, &mut stack, rest);
+                self.add_transition(state_id, new, next_id);
+                continue;
+            }
+
+            // The need for this loop is a bit subtle, buf basically, after
+            // we've handled the partitions from our initial split, it's
+            // possible that there will be a partition leftover that overlaps
+            // with a subsequent transition. If so, then we have to repeat
+            // the split process again with the leftovers and that subsequent
+            // transition.
+            'OUTER: loop {
+                let old = self.state(state_id).transitions[i].clone();
+                let split = match Split::new(old.range, new) {
+                    Some(split) => split,
+                    None => {
+                        let next_id = NextInsert::push(self, &mut stack, rest);
+                        self.add_transition_at(i, state_id, new, next_id);
+                        continue;
+                    }
+                };
+                let splits = split.as_slice();
+                // If we only have one partition, then the ranges must be
+                // equivalent. There's nothing to do here for this state, so
+                // just move on to the next one.
+                if splits.len() == 1 {
+                    // ... but only if we have anything left to do.
+                    if !rest.is_empty() {
+                        stack.push(NextInsert::new(old.next_id, rest));
+                    }
+                    break;
+                }
+                // At this point, we know that 'split' is non-empty and there
+                // must be some overlap AND that the two ranges are not
+                // equivalent. Therefore, the existing range MUST be removed
+                // and split up somehow. Instead of actually doing the removal
+                // and then a subsequent insertion---with all the memory
+                // shuffling that entails---we simply overwrite the transition
+                // at position `i` for the first new transition we want to
+                // insert. After that, we're forced to do expensive inserts.
+                let mut first = true;
+                let mut add_trans =
+                    |trie: &mut RangeTrie, pos, from, range, to| {
+                        if first {
+                            trie.set_transition_at(pos, from, range, to);
+                            first = false;
+                        } else {
+                            trie.add_transition_at(pos, from, range, to);
+                        }
+                    };
+                for (j, &srange) in splits.iter().enumerate() {
+                    match srange {
+                        SplitRange::Old(r) => {
+                            // Deep clone the state pointed to by the ith
+                            // transition. This is always necessary since 'old'
+                            // is always coupled with at least a 'both'
+                            // partition. We don't want any new changes made
+                            // via the 'both' partition to impact the part of
+                            // the transition that doesn't overlap with the
+                            // new range.
+                            let dup_id = self.duplicate(old.next_id);
+                            add_trans(self, i, state_id, r, dup_id);
+                        }
+                        SplitRange::New(r) => {
+                            // This is a bit subtle, but if this happens to be
+                            // the last partition in our split, it is possible
+                            // that this overlaps with a subsequent transition.
+                            // If it does, then we must repeat the whole
+                            // splitting process over again with `r` and the
+                            // subsequent transition.
+                            {
+                                let trans = &self.state(state_id).transitions;
+                                if j + 1 == splits.len()
+                                    && i < trans.len()
+                                    && intersects(r, trans[i].range)
+                                {
+                                    new = r;
+                                    continue 'OUTER;
+                                }
+                            }
+
+                            // ... otherwise, setup exploration for a new
+                            // empty state and add a brand new transition for
+                            // this new range.
+                            let next_id =
+                                NextInsert::push(self, &mut stack, rest);
+                            add_trans(self, i, state_id, r, next_id);
+                        }
+                        SplitRange::Both(r) => {
+                            // Continue adding the remaining ranges on this
+                            // path and update the transition with the new
+                            // range.
+                            if !rest.is_empty() {
+                                stack.push(NextInsert::new(old.next_id, rest));
+                            }
+                            add_trans(self, i, state_id, r, old.next_id);
+                        }
+                    }
+                    i += 1;
+                }
+                // If we've reached this point, then we know that there are
+                // no subsequent transitions with any overlap. Therefore, we
+                // can stop processing this range and move on to the next one.
+                break;
+            }
+        }
+        self.insert_stack = stack;
+    }
+
+    pub fn add_empty(&mut self) -> StateID {
+        let id = match StateID::try_from(self.states.len()) {
+            Ok(id) => id,
+            Err(_) => {
+                // This generally should not happen since a range trie is
+                // only ever used to compile a single sequence of Unicode
+                // scalar values. If we ever got to this point, we would, at
+                // *minimum*, be using 96GB in just the range trie alone.
+                panic!("too many sequences added to range trie");
+            }
+        };
+        // If we have some free states available, then use them to avoid
+        // more allocations.
+        if let Some(mut state) = self.free.pop() {
+            state.clear();
+            self.states.push(state);
+        } else {
+            self.states.push(State { transitions: vec![] });
+        }
+        id
+    }
+
+    /// Performs a deep clone of the given state and returns the duplicate's
+    /// state ID.
+    ///
+    /// A "deep clone" in this context means that the state given along with
+    /// recursively all states that it points to are copied. Once complete,
+    /// the given state ID and the returned state ID share nothing.
+    ///
+    /// This is useful during range trie insertion when a new range overlaps
+    /// with an existing range that is bigger than the new one. The part
+    /// of the existing range that does *not* overlap with the new one is
+    /// duplicated so that adding the new range to the overlap doesn't disturb
+    /// the non-overlapping portion.
+    ///
+    /// There's one exception: if old_id is the final state, then it is not
+    /// duplicated and the same final state is returned. This is because all
+    /// final states in this trie are equivalent.
+    fn duplicate(&mut self, old_id: StateID) -> StateID {
+        if old_id == FINAL {
+            return FINAL;
+        }
+
+        let mut stack = mem::replace(&mut self.dupe_stack, vec![]);
+        stack.clear();
+
+        let new_id = self.add_empty();
+        // old_id is the state we're cloning and new_id is the ID of the
+        // duplicated state for old_id.
+        stack.push(NextDupe { old_id, new_id });
+        while let Some(NextDupe { old_id, new_id }) = stack.pop() {
+            for i in 0..self.state(old_id).transitions.len() {
+                let t = self.state(old_id).transitions[i].clone();
+                if t.next_id == FINAL {
+                    // All final states are the same, so there's no need to
+                    // duplicate it.
+                    self.add_transition(new_id, t.range, FINAL);
+                    continue;
+                }
+
+                let new_child_id = self.add_empty();
+                self.add_transition(new_id, t.range, new_child_id);
+                stack.push(NextDupe {
+                    old_id: t.next_id,
+                    new_id: new_child_id,
+                });
+            }
+        }
+        self.dupe_stack = stack;
+        new_id
+    }
+
+    /// Adds the given transition to the given state.
+    ///
+    /// Callers must ensure that all previous transitions in this state
+    /// are lexicographically smaller than the given range.
+    fn add_transition(
+        &mut self,
+        from_id: StateID,
+        range: Utf8Range,
+        next_id: StateID,
+    ) {
+        self.state_mut(from_id)
+            .transitions
+            .push(Transition { range, next_id });
+    }
+
+    /// Like `add_transition`, except this inserts the transition just before
+    /// the ith transition.
+    fn add_transition_at(
+        &mut self,
+        i: usize,
+        from_id: StateID,
+        range: Utf8Range,
+        next_id: StateID,
+    ) {
+        self.state_mut(from_id)
+            .transitions
+            .insert(i, Transition { range, next_id });
+    }
+
+    /// Overwrites the transition at position i with the given transition.
+    fn set_transition_at(
+        &mut self,
+        i: usize,
+        from_id: StateID,
+        range: Utf8Range,
+        next_id: StateID,
+    ) {
+        self.state_mut(from_id).transitions[i] = Transition { range, next_id };
+    }
+
+    /// Return an immutable borrow for the state with the given ID.
+    fn state(&self, id: StateID) -> &State {
+        &self.states[id]
+    }
+
+    /// Return a mutable borrow for the state with the given ID.
+    fn state_mut(&mut self, id: StateID) -> &mut State {
+        &mut self.states[id]
+    }
+}
+
+impl State {
+    /// Find the position at which the given range should be inserted in this
+    /// state.
+    ///
+    /// The position returned is always in the inclusive range
+    /// [0, transitions.len()]. If 'transitions.len()' is returned, then the
+    /// given range overlaps with no other range in this state *and* is greater
+    /// than all of them.
+    ///
+    /// For all other possible positions, the given range either overlaps
+    /// with the transition at that position or is otherwise less than it
+    /// with no overlap (and is greater than the previous transition). In the
+    /// former case, careful attention must be paid to inserting this range
+    /// as a new transition. In the latter case, the range can be inserted as
+    /// a new transition at the given position without disrupting any other
+    /// transitions.
+    fn find(&self, range: Utf8Range) -> usize {
+        /// Returns the position `i` at which `pred(xs[i])` first returns true
+        /// such that for all `j >= i`, `pred(xs[j]) == true`. If `pred` never
+        /// returns true, then `xs.len()` is returned.
+        ///
+        /// We roll our own binary search because it doesn't seem like the
+        /// standard library's binary search can be used here. Namely, if
+        /// there is an overlapping range, then we want to find the first such
+        /// occurrence, but there may be many. Or at least, it's not quite
+        /// clear to me how to do it.
+        fn binary_search<T, F>(xs: &[T], mut pred: F) -> usize
+        where
+            F: FnMut(&T) -> bool,
+        {
+            let (mut left, mut right) = (0, xs.len());
+            while left < right {
+                // Overflow is impossible because xs.len() <= 256.
+                let mid = (left + right) / 2;
+                if pred(&xs[mid]) {
+                    right = mid;
+                } else {
+                    left = mid + 1;
+                }
+            }
+            left
+        }
+
+        // Benchmarks suggest that binary search is just a bit faster than
+        // straight linear search. Specifically when using the debug tool:
+        //
+        //   hyperfine "regex-cli debug nfa thompson --quiet --reverse '\w{90} ecurB'"
+        binary_search(&self.transitions, |t| range.start <= t.range.end)
+    }
+
+    /// Clear this state such that it has zero transitions.
+    fn clear(&mut self) {
+        self.transitions.clear();
+    }
+}
+
+/// The next state to process during duplication.
+#[derive(Clone, Debug)]
+struct NextDupe {
+    /// The state we want to duplicate.
+    old_id: StateID,
+    /// The ID of the new state that is a duplicate of old_id.
+    new_id: StateID,
+}
+
+/// The next state (and its corresponding transition) that we want to visit
+/// during iteration in lexicographic order.
+#[derive(Clone, Debug)]
+struct NextIter {
+    state_id: StateID,
+    tidx: usize,
+}
+
+/// The next state to process during insertion and any remaining ranges that we
+/// want to add for a partcular sequence of ranges. The first such instance
+/// is always the root state along with all ranges given.
+#[derive(Clone, Debug)]
+struct NextInsert {
+    /// The next state to begin inserting ranges. This state should be the
+    /// state at which `ranges[0]` should be inserted.
+    state_id: StateID,
+    /// The ranges to insert. We used a fixed-size array here to avoid an
+    /// allocation.
+    ranges: [Utf8Range; 4],
+    /// The number of valid ranges in the above array.
+    len: u8,
+}
+
+impl NextInsert {
+    /// Create the next item to visit. The given state ID should correspond
+    /// to the state at which the first range in the given slice should be
+    /// inserted. The slice given must not be empty and it must be no longer
+    /// than 4.
+    fn new(state_id: StateID, ranges: &[Utf8Range]) -> NextInsert {
+        let len = ranges.len();
+        assert!(len > 0);
+        assert!(len <= 4);
+
+        let mut tmp = [Utf8Range { start: 0, end: 0 }; 4];
+        tmp[..len].copy_from_slice(ranges);
+        NextInsert { state_id, ranges: tmp, len: u8::try_from(len).unwrap() }
+    }
+
+    /// Push a new empty state to visit along with any remaining ranges that
+    /// still need to be inserted. The ID of the new empty state is returned.
+    ///
+    /// If ranges is empty, then no new state is created and FINAL is returned.
+    fn push(
+        trie: &mut RangeTrie,
+        stack: &mut Vec<NextInsert>,
+        ranges: &[Utf8Range],
+    ) -> StateID {
+        if ranges.is_empty() {
+            FINAL
+        } else {
+            let next_id = trie.add_empty();
+            stack.push(NextInsert::new(next_id, ranges));
+            next_id
+        }
+    }
+
+    /// Return the ID of the state to visit.
+    fn state_id(&self) -> StateID {
+        self.state_id
+    }
+
+    /// Return the remaining ranges to insert.
+    fn ranges(&self) -> &[Utf8Range] {
+        &self.ranges[..usize::try_from(self.len).unwrap()]
+    }
+}
+
+/// Split represents a partitioning of two ranges into one or more ranges. This
+/// is the secret sauce that makes a range trie work, as it's what tells us
+/// how to deal with two overlapping but unequal ranges during insertion.
+///
+/// Essentially, either two ranges overlap or they don't. If they don't, then
+/// handling insertion is easy: just insert the new range into its
+/// lexicographically correct position. Since it does not overlap with anything
+/// else, no other transitions are impacted by the new range.
+///
+/// If they do overlap though, there are generally three possible cases to
+/// handle:
+///
+/// 1. The part where the two ranges actually overlap. i.e., The intersection.
+/// 2. The part of the existing range that is not in the the new range.
+/// 3. The part of the new range that is not in the old range.
+///
+/// (1) is guaranteed to always occur since all overlapping ranges have a
+/// non-empty intersection. If the two ranges are not equivalent, then at
+/// least one of (2) or (3) is guaranteed to occur as well. In some cases,
+/// e.g., `[0-4]` and `[4-9]`, all three cases will occur.
+///
+/// This `Split` type is responsible for providing (1), (2) and (3) for any
+/// possible pair of byte ranges.
+///
+/// As for insertion, for the overlap in (1), the remaining ranges to insert
+/// should be added by following the corresponding transition. However, this
+/// should only be done for the overlapping parts of the range. If there was
+/// a part of the existing range that was not in the new range, then that
+/// existing part must be split off from the transition and duplicated. The
+/// remaining parts of the overlap can then be added to using the new ranges
+/// without disturbing the existing range.
+///
+/// Handling the case for the part of a new range that is not in an existing
+/// range is seemingly easy. Just treat it as if it were a non-overlapping
+/// range. The problem here is that if this new non-overlapping range occurs
+/// after both (1) and (2), then it's possible that it can overlap with the
+/// next transition in the current state. If it does, then the whole process
+/// must be repeated!
+///
+/// # Details of the 3 cases
+///
+/// The following details the various cases that are implemented in code
+/// below. It's plausible that the number of cases is not actually minimal,
+/// but it's important for this code to remain at least somewhat readable.
+///
+/// Given [a,b] and [x,y], where a <= b, x <= y, b < 256 and y < 256, we define
+/// the follow distinct relationships where at least one must apply. The order
+/// of these matters, since multiple can match. The first to match applies.
+///
+///   1. b < x <=> [a,b] < [x,y]
+///   2. y < a <=> [x,y] < [a,b]
+///
+/// In the case of (1) and (2), these are the only cases where there is no
+/// overlap. Or otherwise, the intersection of [a,b] and [x,y] is empty. In
+/// order to compute the intersection, one can do [max(a,x), min(b,y)]. The
+/// intersection in all of the following cases is non-empty.
+///
+///    3. a = x && b = y <=> [a,b] == [x,y]
+///    4. a = x && b < y <=> [x,y] right-extends [a,b]
+///    5. b = y && a > x <=> [x,y] left-extends [a,b]
+///    6. x = a && y < b <=> [a,b] right-extends [x,y]
+///    7. y = b && x > a <=> [a,b] left-extends [x,y]
+///    8. a > x && b < y <=> [x,y] covers [a,b]
+///    9. x > a && y < b <=> [a,b] covers [x,y]
+///   10. b = x && a < y <=> [a,b] is left-adjacent to [x,y]
+///   11. y = a && x < b <=> [x,y] is left-adjacent to [a,b]
+///   12. b > x && b < y <=> [a,b] left-overlaps [x,y]
+///   13. y > a && y < b <=> [x,y] left-overlaps [a,b]
+///
+/// In cases 3-13, we can form rules that partition the ranges into a
+/// non-overlapping ordered sequence of ranges:
+///
+///    3. [a,b]
+///    4. [a,b], [b+1,y]
+///    5. [x,a-1], [a,b]
+///    6. [x,y], [y+1,b]
+///    7. [a,x-1], [x,y]
+///    8. [x,a-1], [a,b], [b+1,y]
+///    9. [a,x-1], [x,y], [y+1,b]
+///   10. [a,b-1], [b,b], [b+1,y]
+///   11. [x,y-1], [y,y], [y+1,b]
+///   12. [a,x-1], [x,b], [b+1,y]
+///   13. [x,a-1], [a,y], [y+1,b]
+///
+/// In the code below, we go a step further and identify each of the above
+/// outputs as belonging either to the overlap of the two ranges or to one
+/// of [a,b] or [x,y] exclusively.
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct Split {
+    partitions: [SplitRange; 3],
+    len: usize,
+}
+
+/// A tagged range indicating how it was derived from a pair of ranges.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum SplitRange {
+    Old(Utf8Range),
+    New(Utf8Range),
+    Both(Utf8Range),
+}
+
+impl Split {
+    /// Create a partitioning of the given ranges.
+    ///
+    /// If the given ranges have an empty intersection, then None is returned.
+    fn new(o: Utf8Range, n: Utf8Range) -> Option<Split> {
+        let range = |r: RangeInclusive<u8>| Utf8Range {
+            start: *r.start(),
+            end: *r.end(),
+        };
+        let old = |r| SplitRange::Old(range(r));
+        let new = |r| SplitRange::New(range(r));
+        let both = |r| SplitRange::Both(range(r));
+
+        // Use same names as the comment above to make it easier to compare.
+        let (a, b, x, y) = (o.start, o.end, n.start, n.end);
+
+        if b < x || y < a {
+            // case 1, case 2
+            None
+        } else if a == x && b == y {
+            // case 3
+            Some(Split::parts1(both(a..=b)))
+        } else if a == x && b < y {
+            // case 4
+            Some(Split::parts2(both(a..=b), new(b + 1..=y)))
+        } else if b == y && a > x {
+            // case 5
+            Some(Split::parts2(new(x..=a - 1), both(a..=b)))
+        } else if x == a && y < b {
+            // case 6
+            Some(Split::parts2(both(x..=y), old(y + 1..=b)))
+        } else if y == b && x > a {
+            // case 7
+            Some(Split::parts2(old(a..=x - 1), both(x..=y)))
+        } else if a > x && b < y {
+            // case 8
+            Some(Split::parts3(new(x..=a - 1), both(a..=b), new(b + 1..=y)))
+        } else if x > a && y < b {
+            // case 9
+            Some(Split::parts3(old(a..=x - 1), both(x..=y), old(y + 1..=b)))
+        } else if b == x && a < y {
+            // case 10
+            Some(Split::parts3(old(a..=b - 1), both(b..=b), new(b + 1..=y)))
+        } else if y == a && x < b {
+            // case 11
+            Some(Split::parts3(new(x..=y - 1), both(y..=y), old(y + 1..=b)))
+        } else if b > x && b < y {
+            // case 12
+            Some(Split::parts3(old(a..=x - 1), both(x..=b), new(b + 1..=y)))
+        } else if y > a && y < b {
+            // case 13
+            Some(Split::parts3(new(x..=a - 1), both(a..=y), old(y + 1..=b)))
+        } else {
+            unreachable!()
+        }
+    }
+
+    /// Create a new split with a single partition. This only occurs when two
+    /// ranges are equivalent.
+    fn parts1(r1: SplitRange) -> Split {
+        // This value doesn't matter since it is never accessed.
+        let nada = SplitRange::Old(Utf8Range { start: 0, end: 0 });
+        Split { partitions: [r1, nada, nada], len: 1 }
+    }
+
+    /// Create a new split with two partitions.
+    fn parts2(r1: SplitRange, r2: SplitRange) -> Split {
+        // This value doesn't matter since it is never accessed.
+        let nada = SplitRange::Old(Utf8Range { start: 0, end: 0 });
+        Split { partitions: [r1, r2, nada], len: 2 }
+    }
+
+    /// Create a new split with three partitions.
+    fn parts3(r1: SplitRange, r2: SplitRange, r3: SplitRange) -> Split {
+        Split { partitions: [r1, r2, r3], len: 3 }
+    }
+
+    /// Return the partitions in this split as a slice.
+    fn as_slice(&self) -> &[SplitRange] {
+        &self.partitions[..self.len]
+    }
+}
+
+impl fmt::Debug for RangeTrie {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "")?;
+        for (i, state) in self.states.iter().enumerate() {
+            let status = if i == FINAL.as_usize() { '*' } else { ' ' };
+            writeln!(f, "{}{:06}: {:?}", status, i, state)?;
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Debug for State {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let rs = self
+            .transitions
+            .iter()
+            .map(|t| format!("{:?}", t))
+            .collect::<Vec<String>>()
+            .join(", ");
+        write!(f, "{}", rs)
+    }
+}
+
+impl fmt::Debug for Transition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.range.start == self.range.end {
+            write!(
+                f,
+                "{:02X} => {:02X}",
+                self.range.start,
+                self.next_id.as_usize(),
+            )
+        } else {
+            write!(
+                f,
+                "{:02X}-{:02X} => {:02X}",
+                self.range.start,
+                self.range.end,
+                self.next_id.as_usize(),
+            )
+        }
+    }
+}
+
+/// Returns true if and only if the given ranges intersect.
+fn intersects(r1: Utf8Range, r2: Utf8Range) -> bool {
+    !(r1.end < r2.start || r2.end < r1.start)
+}
+
+#[cfg(test)]
+mod tests {
+    use core::ops::RangeInclusive;
+
+    use regex_syntax::utf8::Utf8Range;
+
+    use super::*;
+
+    fn r(range: RangeInclusive<u8>) -> Utf8Range {
+        Utf8Range { start: *range.start(), end: *range.end() }
+    }
+
+    fn split_maybe(
+        old: RangeInclusive<u8>,
+        new: RangeInclusive<u8>,
+    ) -> Option<Split> {
+        Split::new(r(old), r(new))
+    }
+
+    fn split(
+        old: RangeInclusive<u8>,
+        new: RangeInclusive<u8>,
+    ) -> Vec<SplitRange> {
+        split_maybe(old, new).unwrap().as_slice().to_vec()
+    }
+
+    #[test]
+    fn no_splits() {
+        // case 1
+        assert_eq!(None, split_maybe(0..=1, 2..=3));
+        // case 2
+        assert_eq!(None, split_maybe(2..=3, 0..=1));
+    }
+
+    #[test]
+    fn splits() {
+        let range = |r: RangeInclusive<u8>| Utf8Range {
+            start: *r.start(),
+            end: *r.end(),
+        };
+        let old = |r| SplitRange::Old(range(r));
+        let new = |r| SplitRange::New(range(r));
+        let both = |r| SplitRange::Both(range(r));
+
+        // case 3
+        assert_eq!(split(0..=0, 0..=0), vec![both(0..=0)]);
+        assert_eq!(split(9..=9, 9..=9), vec![both(9..=9)]);
+
+        // case 4
+        assert_eq!(split(0..=5, 0..=6), vec![both(0..=5), new(6..=6)]);
+        assert_eq!(split(0..=5, 0..=8), vec![both(0..=5), new(6..=8)]);
+        assert_eq!(split(5..=5, 5..=8), vec![both(5..=5), new(6..=8)]);
+
+        // case 5
+        assert_eq!(split(1..=5, 0..=5), vec![new(0..=0), both(1..=5)]);
+        assert_eq!(split(3..=5, 0..=5), vec![new(0..=2), both(3..=5)]);
+        assert_eq!(split(5..=5, 0..=5), vec![new(0..=4), both(5..=5)]);
+
+        // case 6
+        assert_eq!(split(0..=6, 0..=5), vec![both(0..=5), old(6..=6)]);
+        assert_eq!(split(0..=8, 0..=5), vec![both(0..=5), old(6..=8)]);
+        assert_eq!(split(5..=8, 5..=5), vec![both(5..=5), old(6..=8)]);
+
+        // case 7
+        assert_eq!(split(0..=5, 1..=5), vec![old(0..=0), both(1..=5)]);
+        assert_eq!(split(0..=5, 3..=5), vec![old(0..=2), both(3..=5)]);
+        assert_eq!(split(0..=5, 5..=5), vec![old(0..=4), both(5..=5)]);
+
+        // case 8
+        assert_eq!(
+            split(3..=6, 2..=7),
+            vec![new(2..=2), both(3..=6), new(7..=7)],
+        );
+        assert_eq!(
+            split(3..=6, 1..=8),
+            vec![new(1..=2), both(3..=6), new(7..=8)],
+        );
+
+        // case 9
+        assert_eq!(
+            split(2..=7, 3..=6),
+            vec![old(2..=2), both(3..=6), old(7..=7)],
+        );
+        assert_eq!(
+            split(1..=8, 3..=6),
+            vec![old(1..=2), both(3..=6), old(7..=8)],
+        );
+
+        // case 10
+        assert_eq!(
+            split(3..=6, 6..=7),
+            vec![old(3..=5), both(6..=6), new(7..=7)],
+        );
+        assert_eq!(
+            split(3..=6, 6..=8),
+            vec![old(3..=5), both(6..=6), new(7..=8)],
+        );
+        assert_eq!(
+            split(5..=6, 6..=7),
+            vec![old(5..=5), both(6..=6), new(7..=7)],
+        );
+
+        // case 11
+        assert_eq!(
+            split(6..=7, 3..=6),
+            vec![new(3..=5), both(6..=6), old(7..=7)],
+        );
+        assert_eq!(
+            split(6..=8, 3..=6),
+            vec![new(3..=5), both(6..=6), old(7..=8)],
+        );
+        assert_eq!(
+            split(6..=7, 5..=6),
+            vec![new(5..=5), both(6..=6), old(7..=7)],
+        );
+
+        // case 12
+        assert_eq!(
+            split(3..=7, 5..=9),
+            vec![old(3..=4), both(5..=7), new(8..=9)],
+        );
+        assert_eq!(
+            split(3..=5, 4..=6),
+            vec![old(3..=3), both(4..=5), new(6..=6)],
+        );
+
+        // case 13
+        assert_eq!(
+            split(5..=9, 3..=7),
+            vec![new(3..=4), both(5..=7), old(8..=9)],
+        );
+        assert_eq!(
+            split(4..=6, 3..=5),
+            vec![new(3..=3), both(4..=5), old(6..=6)],
+        );
+    }
+
+    // Arguably there should be more tests here, but in practice, this data
+    // structure is well covered by the huge number of regex tests.
+}
diff --git a/regex-automata/src/util/alphabet.rs b/regex-automata/src/util/alphabet.rs
new file mode 100644
index 0000000000..76eca39363
--- /dev/null
+++ b/regex-automata/src/util/alphabet.rs
@@ -0,0 +1,1138 @@
+/*!
+This module provides APIs for dealing with the alphabets of finite state
+machines.
+
+There are two principal types in this module, [`ByteClasses`] and [`Unit`].
+The former defines the alphabet of a finite state machine while the latter
+represents an element of that alphabet.
+
+To a first approximation, the alphabet of all automata in this crate is just
+a `u8`. Namely, every distinct byte value. All 256 of them. In practice, this
+can be quite wasteful when building a transition table for a DFA, since it
+requires storing a state identifier for each element in the alphabet. Instead,
+we collapse the alphabet of an automaton down into equivalence classes, where
+every byte in the same equivalence class never discriminates between a match or
+a non-match from any other byte in the same class. For example, in the regex
+`[a-z]+`, then you could consider it having an alphabet consisting of two
+equivalence classes: `a-z` and everything else. In terms of the transitions on
+an automaton, it doesn't actually require representing every distinct byte.
+Just the equivalence classes.
+
+The downside of equivalence classes is that, of course, searching a haystack
+deals with individual byte values. Those byte values need to be mapped to
+their corresponding equivalence class. This is what `ByteClasses` does. In
+practice, doing this for every state transition has negligible impact on modern
+CPUs. Moreover, it helps make more efficient use of the CPU cache by (possibly
+considerably) shrinking the size of the transition table.
+
+One last hiccup concerns `Unit`. Namely, because of look-around and how the
+DFAs in this crate work, we need to add a sentinel value to our alphabet
+of equivalence classes that represents the "end" of a search. We call that
+sentinel [`Unit::eoi`] or "end of input." Thus, a `Unit` is either an
+equivalence class corresponding to a set of bytes, or it is a special "end of
+input" sentinel.
+
+In general, you should not expect to need either of these types unless you're
+doing lower level shenanigans with DFAs, or even building your own DFAs.
+(Although, you don't have to use these types to build your own DFAs of course.)
+For example, if you're walking a DFA's state graph, it's probably useful to
+make use of [`ByteClasses`] to visit each element in the DFA's alphabet instead
+of just visiting every distinct `u8` value. The latter isn't necessarily wrong,
+but it could be potentially very wasteful.
+*/
+use crate::util::{
+    escape::DebugByte,
+    wire::{self, DeserializeError, SerializeError},
+};
+
+/// Unit represents a single unit of haystack for DFA based regex engines.
+///
+/// It is not expected for consumers of this crate to need to use this type
+/// unless they are implementing their own DFA. And even then, it's not
+/// required: implementors may use other techniques to handle haystack units.
+///
+/// Typically, a single unit of haystack for a DFA would be a single byte.
+/// However, for the DFAs in this crate, matches are delayed by a single byte
+/// in order to handle look-ahead assertions (`\b`, `$` and `\z`). Thus, once
+/// we have consumed the haystack, we must run the DFA through one additional
+/// transition using a unit that indicates the haystack has ended.
+///
+/// There is no way to represent a sentinel with a `u8` since all possible
+/// values *may* be valid haystack units to a DFA, therefore this type
+/// explicitly adds room for a sentinel value.
+///
+/// The sentinel EOI value is always its own equivalence class and is
+/// ultimately represented by adding 1 to the maximum equivalence class value.
+/// So for example, the regex `^[a-z]+$` might be split into the following
+/// equivalence classes:
+///
+/// ```text
+/// 0 => [\x00-`]
+/// 1 => [a-z]
+/// 2 => [{-\xFF]
+/// 3 => [EOI]
+/// ```
+///
+/// Where EOI is the special sentinel value that is always in its own
+/// singleton equivalence class.
+#[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+pub struct Unit(UnitKind);
+
+#[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+enum UnitKind {
+    /// Represents a byte value, or more typically, an equivalence class
+    /// represented as a byte value.
+    U8(u8),
+    /// Represents the "end of input" sentinel. We regretably use a `u16`
+    /// here since the maximum sentinel value is `256`. Thankfully, we don't
+    /// actually store a `Unit` anywhere, so this extra space shouldn't be too
+    /// bad.
+    EOI(u16),
+}
+
+impl Unit {
+    /// Create a new haystack unit from a byte value.
+    ///
+    /// All possible byte values are legal. However, when creating a haystack
+    /// unit for a specific DFA, one should be careful to only construct units
+    /// that are in that DFA's alphabet. Namely, one way to compact a DFA's
+    /// in-memory representation is to collapse its transitions to a set of
+    /// equivalence classes into a set of all possible byte values. If a DFA
+    /// uses equivalence classes instead of byte values, then the byte given
+    /// here should be the equivalence class.
+    pub fn u8(byte: u8) -> Unit {
+        Unit(UnitKind::U8(byte))
+    }
+
+    /// Create a new "end of input" haystack unit.
+    ///
+    /// The value given is the sentinel value used by this unit to represent
+    /// the "end of input." The value should be the total number of equivalence
+    /// classes in the corresponding alphabet. Its maximum value is `256`,
+    /// which occurs when every byte is its own equivalence class.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `num_byte_equiv_classes` is greater than `256`.
+    pub fn eoi(num_byte_equiv_classes: usize) -> Unit {
+        assert!(
+            num_byte_equiv_classes <= 256,
+            "max number of byte-based equivalent classes is 256, but got {}",
+            num_byte_equiv_classes,
+        );
+        Unit(UnitKind::EOI(u16::try_from(num_byte_equiv_classes).unwrap()))
+    }
+
+    /// If this unit is not an "end of input" sentinel, then returns its
+    /// underlying byte value. Otherwise return `None`.
+    pub fn as_u8(self) -> Option<u8> {
+        match self.0 {
+            UnitKind::U8(b) => Some(b),
+            UnitKind::EOI(_) => None,
+        }
+    }
+
+    /// If this unit is an "end of input" sentinel, then return the underyling
+    /// sentinel value that was given to [`Unit::eoi`]. Otherwise return
+    /// `None`.
+    pub fn as_eoi(self) -> Option<u16> {
+        match self.0 {
+            UnitKind::U8(_) => None,
+            UnitKind::EOI(sentinel) => Some(sentinel),
+        }
+    }
+
+    /// Return this unit as a `usize`, regardless of whether it is a byte value
+    /// or an "end of input" sentinel. In the latter case, the underlying
+    /// sentinel value given to [`Unit::eoi`] is returned.
+    pub fn as_usize(self) -> usize {
+        match self.0 {
+            UnitKind::U8(b) => usize::from(b),
+            UnitKind::EOI(eoi) => usize::from(eoi),
+        }
+    }
+
+    /// Returns true if and only of this unit is a byte value equivalent to the
+    /// byte given. This always returns false when this is an "end of input"
+    /// sentinel.
+    pub fn is_byte(self, byte: u8) -> bool {
+        self.as_u8().map_or(false, |b| b == byte)
+    }
+
+    /// Returns true when this unit represents an "end of input" sentinel.
+    pub fn is_eoi(self) -> bool {
+        self.as_eoi().is_some()
+    }
+
+    /// Returns true when this unit corresponds to an ASCII word byte.
+    ///
+    /// This always returns false when this unit represents an "end of input"
+    /// sentinel.
+    pub fn is_word_byte(self) -> bool {
+        self.as_u8().map_or(false, crate::util::utf8::is_word_byte)
+    }
+}
+
+impl core::fmt::Debug for Unit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        match self.0 {
+            UnitKind::U8(b) => write!(f, "{:?}", DebugByte(b)),
+            UnitKind::EOI(_) => write!(f, "EOI"),
+        }
+    }
+}
+
+/// A representation of byte oriented equivalence classes.
+///
+/// This is used in a DFA to reduce the size of the transition table. This can
+/// have a particularly large impact not only on the total size of a dense DFA,
+/// but also on compile times.
+///
+/// The essential idea here is that the alphabet of a DFA is shrunk from the
+/// usual 256 distinct byte values down to a set of equivalence classes. The
+/// guarantee you get is that any byte belonging to the same equivalence class
+/// can be treated as if it were any other byte in the same class, and the
+/// result of a search wouldn't change.
+///
+/// # Example
+///
+/// This example shows how to get byte classes from an
+/// [`NFA`](crate::nfa::thompson::NFA) and ask for the class of various bytes.
+///
+/// ```
+/// use regex_automata::nfa::thompson::NFA;
+///
+/// let nfa = NFA::new("[a-z]+")?;
+/// let classes = nfa.byte_classes();
+/// // 'a' and 'z' are in the same class for this regex.
+/// assert_eq!(classes.get(b'a'), classes.get(b'z'));
+/// // But 'a' and 'A' are not.
+/// assert_ne!(classes.get(b'a'), classes.get(b'A'));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Copy)]
+pub struct ByteClasses([u8; 256]);
+
+impl ByteClasses {
+    /// Creates a new set of equivalence classes where all bytes are mapped to
+    /// the same class.
+    #[inline]
+    pub fn empty() -> ByteClasses {
+        ByteClasses([0; 256])
+    }
+
+    /// Creates a new set of equivalence classes where each byte belongs to
+    /// its own equivalence class.
+    #[inline]
+    pub fn singletons() -> ByteClasses {
+        let mut classes = ByteClasses::empty();
+        for b in 0..=255 {
+            classes.set(b, b);
+        }
+        classes
+    }
+
+    /// Deserializes a byte class map from the given slice. If the slice is of
+    /// insufficient length or otherwise contains an impossible mapping, then
+    /// an error is returned. Upon success, the number of bytes read along with
+    /// the map are returned. The number of bytes read is always a multiple of
+    /// 8.
+    pub(crate) fn from_bytes(
+        slice: &[u8],
+    ) -> Result<(ByteClasses, usize), DeserializeError> {
+        wire::check_slice_len(slice, 256, "byte class map")?;
+        let mut classes = ByteClasses::empty();
+        for (b, &class) in slice[..256].iter().enumerate() {
+            classes.set(u8::try_from(b).unwrap(), class);
+        }
+        // We specifically don't use 'classes.iter()' here because that
+        // iterator depends on 'classes.alphabet_len()' being correct. But that
+        // is precisely the thing we're trying to verify below!
+        for &b in classes.0.iter() {
+            if usize::from(b) >= classes.alphabet_len() {
+                return Err(DeserializeError::generic(
+                    "found equivalence class greater than alphabet len",
+                ));
+            }
+        }
+        Ok((classes, 256))
+    }
+
+    /// Writes this byte class map to the given byte buffer. if the given
+    /// buffer is too small, then an error is returned. Upon success, the total
+    /// number of bytes written is returned. The number of bytes written is
+    /// guaranteed to be a multiple of 8.
+    pub(crate) fn write_to(
+        &self,
+        mut dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("byte class map"));
+        }
+        for b in 0..=255 {
+            dst[0] = self.get(b);
+            dst = &mut dst[1..];
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the total number of bytes written by `write_to`.
+    pub(crate) fn write_to_len(&self) -> usize {
+        256
+    }
+
+    /// Set the equivalence class for the given byte.
+    #[inline]
+    pub fn set(&mut self, byte: u8, class: u8) {
+        self.0[usize::from(byte)] = class;
+    }
+
+    /// Get the equivalence class for the given byte.
+    #[inline]
+    pub fn get(&self, byte: u8) -> u8 {
+        self.0[usize::from(byte)]
+    }
+
+    /// Get the equivalence class for the given haystack unit and return the
+    /// class as a `usize`.
+    #[inline]
+    pub fn get_by_unit(&self, unit: Unit) -> usize {
+        match unit.0 {
+            UnitKind::U8(b) => usize::from(self.get(b)),
+            UnitKind::EOI(b) => usize::from(b),
+        }
+    }
+
+    /// Create a unit that represents the "end of input" sentinel based on the
+    /// number of equivalence classes.
+    #[inline]
+    pub fn eoi(&self) -> Unit {
+        // The alphabet length already includes the EOI sentinel, hence why
+        // we subtract 1.
+        Unit::eoi(self.alphabet_len().checked_sub(1).unwrap())
+    }
+
+    /// Return the total number of elements in the alphabet represented by
+    /// these equivalence classes. Equivalently, this returns the total number
+    /// of equivalence classes.
+    #[inline]
+    pub fn alphabet_len(&self) -> usize {
+        // Add one since the number of equivalence classes is one bigger than
+        // the last one. But add another to account for the final EOI class
+        // that isn't explicitly represented.
+        usize::from(self.0[255]) + 1 + 1
+    }
+
+    /// Returns the stride, as a base-2 exponent, required for these
+    /// equivalence classes.
+    ///
+    /// The stride is always the smallest power of 2 that is greater than or
+    /// equal to the alphabet length, and the `stride2` returned here is the
+    /// exponent applied to `2` to get the smallest power. This is done so that
+    /// converting between premultiplied state IDs and indices can be done with
+    /// shifts alone, which is much faster than integer division.
+    #[inline]
+    pub fn stride2(&self) -> usize {
+        let zeros = self.alphabet_len().next_power_of_two().trailing_zeros();
+        usize::try_from(zeros).unwrap()
+    }
+
+    /// Returns true if and only if every byte in this class maps to its own
+    /// equivalence class. Equivalently, there are 257 equivalence classes
+    /// and each class contains either exactly one byte or corresponds to the
+    /// singleton class containing the "end of input" sentinel.
+    #[inline]
+    pub fn is_singleton(&self) -> bool {
+        self.alphabet_len() == 257
+    }
+
+    /// Returns an iterator over all equivalence classes in this set.
+    #[inline]
+    pub fn iter(&self) -> ByteClassIter<'_> {
+        ByteClassIter { classes: self, i: 0 }
+    }
+
+    /// Returns an iterator over a sequence of representative bytes from each
+    /// equivalence class within the range of bytes given.
+    ///
+    /// When the given range is unbounded on both sides, the iterator yields
+    /// exactly N items, where N is equivalent to the number of equivalence
+    /// classes. Each item is an arbitrary byte drawn from each equivalence
+    /// class.
+    ///
+    /// This is useful when one is determinizing an NFA and the NFA's alphabet
+    /// hasn't been converted to equivalence classes. Picking an arbitrary byte
+    /// from each equivalence class then permits a full exploration of the NFA
+    /// instead of using every possible byte value and thus potentially saves
+    /// quite a lot of redundant work.
+    ///
+    /// # Example
+    ///
+    /// This shows an example of what a complete sequence of representatives
+    /// might look like from a real example.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::alphabet::Unit};
+    ///
+    /// let nfa = NFA::new("[a-z]+")?;
+    /// let classes = nfa.byte_classes();
+    /// let reps: Vec<Unit> = classes.representatives(..).collect();
+    /// // Note that the specific byte values yielded are not guaranteed!
+    /// let expected = vec![
+    ///     Unit::u8(b'\x00'),
+    ///     Unit::u8(b'a'),
+    ///     Unit::u8(b'{'),
+    ///     Unit::eoi(3),
+    /// ];
+    /// assert_eq!(expected, reps);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Note though, that you can ask for an arbitrary range of bytes, and only
+    /// representatives for that range will be returned:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::alphabet::Unit};
+    ///
+    /// let nfa = NFA::new("[a-z]+")?;
+    /// let classes = nfa.byte_classes();
+    /// let reps: Vec<Unit> = classes.representatives(b'A'..=b'z').collect();
+    /// // Note that the specific byte values yielded are not guaranteed!
+    /// let expected = vec![
+    ///     Unit::u8(b'A'),
+    ///     Unit::u8(b'a'),
+    /// ];
+    /// assert_eq!(expected, reps);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn representatives<R: core::ops::RangeBounds<u8>>(
+        &self,
+        range: R,
+    ) -> ByteClassRepresentatives<'_> {
+        use core::ops::Bound;
+
+        let cur_byte = match range.start_bound() {
+            Bound::Included(&i) => usize::from(i),
+            Bound::Excluded(&i) => usize::from(i).checked_add(1).unwrap(),
+            Bound::Unbounded => 0,
+        };
+        let end_byte = match range.end_bound() {
+            Bound::Included(&i) => {
+                Some(usize::from(i).checked_add(1).unwrap())
+            }
+            Bound::Excluded(&i) => Some(usize::from(i)),
+            Bound::Unbounded => None,
+        };
+        assert_ne!(
+            cur_byte,
+            usize::MAX,
+            "start range must be less than usize::MAX",
+        );
+        ByteClassRepresentatives {
+            classes: self,
+            cur_byte,
+            end_byte,
+            last_class: None,
+        }
+    }
+
+    /// Returns an iterator of the bytes in the given equivalence class.
+    ///
+    /// This is useful when one needs to know the actual bytes that belong to
+    /// an equivalence class. For example, conceptually speaking, accelerating
+    /// a DFA state occurs when a state only has a few outgoing transitions.
+    /// But in reality, what is required is that there are only a small
+    /// number of distinct bytes that can lead to an outgoing transition. The
+    /// difference is that any one transition can correspond to an equivalence
+    /// class which may contains many bytes. Therefore, DFA state acceleration
+    /// considers the actual elements in each equivalence class of each
+    /// outgoing transition.
+    ///
+    /// # Example
+    ///
+    /// This shows an example of how to get all of the elements in an
+    /// equivalence class.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, util::alphabet::Unit};
+    ///
+    /// let nfa = NFA::new("[a-z]+")?;
+    /// let classes = nfa.byte_classes();
+    /// let elements: Vec<Unit> = classes.elements(Unit::u8(1)).collect();
+    /// let expected: Vec<Unit> = (b'a'..=b'z').map(Unit::u8).collect();
+    /// assert_eq!(expected, elements);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn elements(&self, class: Unit) -> ByteClassElements {
+        ByteClassElements { classes: self, class, byte: 0 }
+    }
+
+    /// Returns an iterator of byte ranges in the given equivalence class.
+    ///
+    /// That is, a sequence of contiguous ranges are returned. Typically, every
+    /// class maps to a single contiguous range.
+    fn element_ranges(&self, class: Unit) -> ByteClassElementRanges {
+        ByteClassElementRanges { elements: self.elements(class), range: None }
+    }
+}
+
+impl Default for ByteClasses {
+    fn default() -> ByteClasses {
+        ByteClasses::singletons()
+    }
+}
+
+impl core::fmt::Debug for ByteClasses {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if self.is_singleton() {
+            write!(f, "ByteClasses({{singletons}})")
+        } else {
+            write!(f, "ByteClasses(")?;
+            for (i, class) in self.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{:?} => [", class.as_usize())?;
+                for (start, end) in self.element_ranges(class) {
+                    if start == end {
+                        write!(f, "{:?}", start)?;
+                    } else {
+                        write!(f, "{:?}-{:?}", start, end)?;
+                    }
+                }
+                write!(f, "]")?;
+            }
+            write!(f, ")")
+        }
+    }
+}
+
+/// An iterator over each equivalence class.
+///
+/// The last element in this iterator always corresponds to [`Unit::eoi`].
+///
+/// This is created by the [`ByteClasses::iter`] method.
+///
+/// The lifetime `'a` refers to the lifetime of the byte classes that this
+/// iterator was created from.
+#[derive(Debug)]
+pub struct ByteClassIter<'a> {
+    classes: &'a ByteClasses,
+    i: usize,
+}
+
+impl<'a> Iterator for ByteClassIter<'a> {
+    type Item = Unit;
+
+    fn next(&mut self) -> Option<Unit> {
+        if self.i + 1 == self.classes.alphabet_len() {
+            self.i += 1;
+            Some(self.classes.eoi())
+        } else if self.i < self.classes.alphabet_len() {
+            let class = u8::try_from(self.i).unwrap();
+            self.i += 1;
+            Some(Unit::u8(class))
+        } else {
+            None
+        }
+    }
+}
+
+/// An iterator over representative bytes from each equivalence class.
+///
+/// This is created by the [`ByteClasses::representatives`] method.
+///
+/// The lifetime `'a` refers to the lifetime of the byte classes that this
+/// iterator was created from.
+#[derive(Debug)]
+pub struct ByteClassRepresentatives<'a> {
+    classes: &'a ByteClasses,
+    cur_byte: usize,
+    end_byte: Option<usize>,
+    last_class: Option<u8>,
+}
+
+impl<'a> Iterator for ByteClassRepresentatives<'a> {
+    type Item = Unit;
+
+    fn next(&mut self) -> Option<Unit> {
+        while self.cur_byte < self.end_byte.unwrap_or(256) {
+            let byte = u8::try_from(self.cur_byte).unwrap();
+            let class = self.classes.get(byte);
+            self.cur_byte += 1;
+
+            if self.last_class != Some(class) {
+                self.last_class = Some(class);
+                return Some(Unit::u8(byte));
+            }
+        }
+        if self.cur_byte != usize::MAX && self.end_byte.is_none() {
+            // Using usize::MAX as a sentinel is OK because we ban usize::MAX
+            // from appearing as a start bound in iterator construction. But
+            // why do it this way? Well, we want to return the EOI class
+            // whenever the end of the given range is unbounded because EOI
+            // isn't really a "byte" per se, so the only way it should be
+            // excluded is if there is a bounded end to the range. Therefore,
+            // when the end is unbounded, we just need to know whether we've
+            // reported EOI or not. When we do, we set cur_byte to a value it
+            // can never otherwise be.
+            self.cur_byte = usize::MAX;
+            return Some(self.classes.eoi());
+        }
+        None
+    }
+}
+
+/// An iterator over all elements in an equivalence class.
+///
+/// This is created by the [`ByteClasses::elements`] method.
+///
+/// The lifetime `'a` refers to the lifetime of the byte classes that this
+/// iterator was created from.
+#[derive(Debug)]
+pub struct ByteClassElements<'a> {
+    classes: &'a ByteClasses,
+    class: Unit,
+    byte: usize,
+}
+
+impl<'a> Iterator for ByteClassElements<'a> {
+    type Item = Unit;
+
+    fn next(&mut self) -> Option<Unit> {
+        while self.byte < 256 {
+            let byte = u8::try_from(self.byte).unwrap();
+            self.byte += 1;
+            if self.class.is_byte(self.classes.get(byte)) {
+                return Some(Unit::u8(byte));
+            }
+        }
+        if self.byte < 257 {
+            self.byte += 1;
+            if self.class.is_eoi() {
+                return Some(Unit::eoi(256));
+            }
+        }
+        None
+    }
+}
+
+/// An iterator over all elements in an equivalence class expressed as a
+/// sequence of contiguous ranges.
+#[derive(Debug)]
+struct ByteClassElementRanges<'a> {
+    elements: ByteClassElements<'a>,
+    range: Option<(Unit, Unit)>,
+}
+
+impl<'a> Iterator for ByteClassElementRanges<'a> {
+    type Item = (Unit, Unit);
+
+    fn next(&mut self) -> Option<(Unit, Unit)> {
+        loop {
+            let element = match self.elements.next() {
+                None => return self.range.take(),
+                Some(element) => element,
+            };
+            match self.range.take() {
+                None => {
+                    self.range = Some((element, element));
+                }
+                Some((start, end)) => {
+                    if end.as_usize() + 1 != element.as_usize()
+                        || element.is_eoi()
+                    {
+                        self.range = Some((element, element));
+                        return Some((start, end));
+                    }
+                    self.range = Some((start, element));
+                }
+            }
+        }
+    }
+}
+
+/// A partitioning of bytes into equivalence classes.
+///
+/// A byte class set keeps track of an *approximation* of equivalence classes
+/// of bytes during NFA construction. That is, every byte in an equivalence
+/// class cannot discriminate between a match and a non-match.
+///
+/// For example, in the regex `[ab]+`, the bytes `a` and `b` would be in the
+/// same equivalence class because it never matters whether an `a` or a `b` is
+/// seen, and no combination of `a`s and `b`s in the text can discriminate a
+/// match.
+///
+/// Note though that this does not compute the minimal set of equivalence
+/// classes. For example, in the regex `[ac]+`, both `a` and `c` are in the
+/// same equivalence class for the same reason that `a` and `b` are in the
+/// same equivalence class in the aforementioned regex. However, in this
+/// implementation, `a` and `c` are put into distinct equivalence classes. The
+/// reason for this is implementation complexity. In the future, we should
+/// endeavor to compute the minimal equivalence classes since they can have a
+/// rather large impact on the size of the DFA. (Doing this will likely require
+/// rethinking how equivalence classes are computed, including changing the
+/// representation here, which is only able to group contiguous bytes into the
+/// same equivalence class.)
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug)]
+pub(crate) struct ByteClassSet(ByteSet);
+
+#[cfg(feature = "alloc")]
+impl Default for ByteClassSet {
+    fn default() -> ByteClassSet {
+        ByteClassSet::empty()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ByteClassSet {
+    /// Create a new set of byte classes where all bytes are part of the same
+    /// equivalence class.
+    pub(crate) fn empty() -> Self {
+        ByteClassSet(ByteSet::empty())
+    }
+
+    /// Indicate the the range of byte given (inclusive) can discriminate a
+    /// match between it and all other bytes outside of the range.
+    pub(crate) fn set_range(&mut self, start: u8, end: u8) {
+        debug_assert!(start <= end);
+        if start > 0 {
+            self.0.add(start - 1);
+        }
+        self.0.add(end);
+    }
+
+    /// Add the contiguous ranges in the set given to this byte class set.
+    pub(crate) fn add_set(&mut self, set: &ByteSet) {
+        for (start, end) in set.iter_ranges() {
+            self.set_range(start, end);
+        }
+    }
+
+    /// Convert this boolean set to a map that maps all byte values to their
+    /// corresponding equivalence class. The last mapping indicates the largest
+    /// equivalence class identifier (which is never bigger than 255).
+    pub(crate) fn byte_classes(&self) -> ByteClasses {
+        let mut classes = ByteClasses::empty();
+        let mut class = 0u8;
+        let mut b = 0u8;
+        loop {
+            classes.set(b, class);
+            if b == 255 {
+                break;
+            }
+            if self.0.contains(b) {
+                class = class.checked_add(1).unwrap();
+            }
+            b = b.checked_add(1).unwrap();
+        }
+        classes
+    }
+}
+
+/// A simple set of bytes that is reasonably cheap to copy and allocation free.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct ByteSet {
+    bits: BitSet,
+}
+
+/// The representation of a byte set. Split out so that we can define a
+/// convenient Debug impl for it while keeping "ByteSet" in the output.
+#[derive(Clone, Copy, Default, Eq, PartialEq)]
+struct BitSet([u128; 2]);
+
+impl ByteSet {
+    /// Create an empty set of bytes.
+    pub(crate) fn empty() -> ByteSet {
+        ByteSet { bits: BitSet([0; 2]) }
+    }
+
+    /// Add a byte to this set.
+    ///
+    /// If the given byte already belongs to this set, then this is a no-op.
+    pub(crate) fn add(&mut self, byte: u8) {
+        let bucket = byte / 128;
+        let bit = byte % 128;
+        self.bits.0[usize::from(bucket)] |= 1 << bit;
+    }
+
+    /// Remove a byte from this set.
+    ///
+    /// If the given byte is not in this set, then this is a no-op.
+    pub(crate) fn remove(&mut self, byte: u8) {
+        let bucket = byte / 128;
+        let bit = byte % 128;
+        self.bits.0[usize::from(bucket)] &= !(1 << bit);
+    }
+
+    /// Return true if and only if the given byte is in this set.
+    pub(crate) fn contains(&self, byte: u8) -> bool {
+        let bucket = byte / 128;
+        let bit = byte % 128;
+        self.bits.0[usize::from(bucket)] & (1 << bit) > 0
+    }
+
+    /// Return true if and only if the given inclusive range of bytes is in
+    /// this set.
+    pub(crate) fn contains_range(&self, start: u8, end: u8) -> bool {
+        (start..=end).all(|b| self.contains(b))
+    }
+
+    /// Returns an iterator over all bytes in this set.
+    pub(crate) fn iter(&self) -> ByteSetIter {
+        ByteSetIter { set: self, b: 0 }
+    }
+
+    /// Returns an iterator over all contiguous ranges of bytes in this set.
+    pub(crate) fn iter_ranges(&self) -> ByteSetRangeIter {
+        ByteSetRangeIter { set: self, b: 0 }
+    }
+
+    /// Return true if and only if this set is empty.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.bits.0 == [0, 0]
+    }
+
+    /// Deserializes a byte set from the given slice. If the slice is of
+    /// incorrect length or is otherwise malformed, then an error is returned.
+    /// Upon success, the number of bytes read along with the set are returned.
+    /// The number of bytes read is always a multiple of 8.
+    pub(crate) fn from_bytes(
+        slice: &[u8],
+    ) -> Result<(ByteSet, usize), DeserializeError> {
+        use core::mem::size_of;
+
+        wire::check_slice_len(slice, 2 * size_of::<u128>(), "byte set")?;
+        let mut nread = 0;
+        let (low, nr) = wire::try_read_u128(slice, "byte set low bucket")?;
+        nread += nr;
+        let (high, nr) = wire::try_read_u128(slice, "byte set high bucket")?;
+        nread += nr;
+        Ok((ByteSet { bits: BitSet([low, high]) }, nread))
+    }
+
+    /// Writes this byte set to the given byte buffer. If the given buffer is
+    /// too small, then an error is returned. Upon success, the total number of
+    /// bytes written is returned. The number of bytes written is guaranteed to
+    /// be a multiple of 8.
+    pub(crate) fn write_to<E: crate::util::wire::Endian>(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        use core::mem::size_of;
+
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("byte set"));
+        }
+        let mut nw = 0;
+        E::write_u128(self.bits.0[0], &mut dst[nw..]);
+        nw += size_of::<u128>();
+        E::write_u128(self.bits.0[1], &mut dst[nw..]);
+        nw += size_of::<u128>();
+        assert_eq!(nwrite, nw, "expected to write certain number of bytes",);
+        assert_eq!(
+            nw % 8,
+            0,
+            "expected to write multiple of 8 bytes for byte set",
+        );
+        Ok(nw)
+    }
+
+    /// Returns the total number of bytes written by `write_to`.
+    pub(crate) fn write_to_len(&self) -> usize {
+        2 * core::mem::size_of::<u128>()
+    }
+}
+
+impl core::fmt::Debug for BitSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut fmtd = f.debug_set();
+        for b in 0u8..=255 {
+            if (ByteSet { bits: *self }).contains(b) {
+                fmtd.entry(&b);
+            }
+        }
+        fmtd.finish()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ByteSetIter<'a> {
+    set: &'a ByteSet,
+    b: usize,
+}
+
+impl<'a> Iterator for ByteSetIter<'a> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<u8> {
+        while self.b <= 255 {
+            let b = u8::try_from(self.b).unwrap();
+            self.b += 1;
+            if self.set.contains(b) {
+                return Some(b);
+            }
+        }
+        None
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ByteSetRangeIter<'a> {
+    set: &'a ByteSet,
+    b: usize,
+}
+
+impl<'a> Iterator for ByteSetRangeIter<'a> {
+    type Item = (u8, u8);
+
+    fn next(&mut self) -> Option<(u8, u8)> {
+        let asu8 = |n: usize| u8::try_from(n).unwrap();
+        while self.b <= 255 {
+            let start = asu8(self.b);
+            self.b += 1;
+            if !self.set.contains(start) {
+                continue;
+            }
+
+            let mut end = start;
+            while self.b <= 255 && self.set.contains(asu8(self.b)) {
+                end = asu8(self.b);
+                self.b += 1;
+            }
+            return Some((start, end));
+        }
+        None
+    }
+}
+
+#[cfg(all(test, feature = "alloc"))]
+mod tests {
+    use alloc::{vec, vec::Vec};
+
+    use super::*;
+
+    #[test]
+    fn byte_classes() {
+        let mut set = ByteClassSet::empty();
+        set.set_range(b'a', b'z');
+
+        let classes = set.byte_classes();
+        assert_eq!(classes.get(0), 0);
+        assert_eq!(classes.get(1), 0);
+        assert_eq!(classes.get(2), 0);
+        assert_eq!(classes.get(b'a' - 1), 0);
+        assert_eq!(classes.get(b'a'), 1);
+        assert_eq!(classes.get(b'm'), 1);
+        assert_eq!(classes.get(b'z'), 1);
+        assert_eq!(classes.get(b'z' + 1), 2);
+        assert_eq!(classes.get(254), 2);
+        assert_eq!(classes.get(255), 2);
+
+        let mut set = ByteClassSet::empty();
+        set.set_range(0, 2);
+        set.set_range(4, 6);
+        let classes = set.byte_classes();
+        assert_eq!(classes.get(0), 0);
+        assert_eq!(classes.get(1), 0);
+        assert_eq!(classes.get(2), 0);
+        assert_eq!(classes.get(3), 1);
+        assert_eq!(classes.get(4), 2);
+        assert_eq!(classes.get(5), 2);
+        assert_eq!(classes.get(6), 2);
+        assert_eq!(classes.get(7), 3);
+        assert_eq!(classes.get(255), 3);
+    }
+
+    #[test]
+    fn full_byte_classes() {
+        let mut set = ByteClassSet::empty();
+        for b in 0u8..=255 {
+            set.set_range(b, b);
+        }
+        assert_eq!(set.byte_classes().alphabet_len(), 257);
+    }
+
+    #[test]
+    fn elements_typical() {
+        let mut set = ByteClassSet::empty();
+        set.set_range(b'b', b'd');
+        set.set_range(b'g', b'm');
+        set.set_range(b'z', b'z');
+        let classes = set.byte_classes();
+        // class 0: \x00-a
+        // class 1: b-d
+        // class 2: e-f
+        // class 3: g-m
+        // class 4: n-y
+        // class 5: z-z
+        // class 6: \x7B-\xFF
+        // class 7: EOI
+        assert_eq!(classes.alphabet_len(), 8);
+
+        let elements = classes.elements(Unit::u8(0)).collect::<Vec<_>>();
+        assert_eq!(elements.len(), 98);
+        assert_eq!(elements[0], Unit::u8(b'\x00'));
+        assert_eq!(elements[97], Unit::u8(b'a'));
+
+        let elements = classes.elements(Unit::u8(1)).collect::<Vec<_>>();
+        assert_eq!(
+            elements,
+            vec![Unit::u8(b'b'), Unit::u8(b'c'), Unit::u8(b'd')],
+        );
+
+        let elements = classes.elements(Unit::u8(2)).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::u8(b'e'), Unit::u8(b'f')],);
+
+        let elements = classes.elements(Unit::u8(3)).collect::<Vec<_>>();
+        assert_eq!(
+            elements,
+            vec![
+                Unit::u8(b'g'),
+                Unit::u8(b'h'),
+                Unit::u8(b'i'),
+                Unit::u8(b'j'),
+                Unit::u8(b'k'),
+                Unit::u8(b'l'),
+                Unit::u8(b'm'),
+            ],
+        );
+
+        let elements = classes.elements(Unit::u8(4)).collect::<Vec<_>>();
+        assert_eq!(elements.len(), 12);
+        assert_eq!(elements[0], Unit::u8(b'n'));
+        assert_eq!(elements[11], Unit::u8(b'y'));
+
+        let elements = classes.elements(Unit::u8(5)).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::u8(b'z')]);
+
+        let elements = classes.elements(Unit::u8(6)).collect::<Vec<_>>();
+        assert_eq!(elements.len(), 133);
+        assert_eq!(elements[0], Unit::u8(b'\x7B'));
+        assert_eq!(elements[132], Unit::u8(b'\xFF'));
+
+        let elements = classes.elements(Unit::eoi(7)).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::eoi(256)]);
+    }
+
+    #[test]
+    fn elements_singletons() {
+        let classes = ByteClasses::singletons();
+        assert_eq!(classes.alphabet_len(), 257);
+
+        let elements = classes.elements(Unit::u8(b'a')).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::u8(b'a')]);
+
+        let elements = classes.elements(Unit::eoi(5)).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::eoi(256)]);
+    }
+
+    #[test]
+    fn elements_empty() {
+        let classes = ByteClasses::empty();
+        assert_eq!(classes.alphabet_len(), 2);
+
+        let elements = classes.elements(Unit::u8(0)).collect::<Vec<_>>();
+        assert_eq!(elements.len(), 256);
+        assert_eq!(elements[0], Unit::u8(b'\x00'));
+        assert_eq!(elements[255], Unit::u8(b'\xFF'));
+
+        let elements = classes.elements(Unit::eoi(1)).collect::<Vec<_>>();
+        assert_eq!(elements, vec![Unit::eoi(256)]);
+    }
+
+    #[test]
+    fn representatives() {
+        let mut set = ByteClassSet::empty();
+        set.set_range(b'b', b'd');
+        set.set_range(b'g', b'm');
+        set.set_range(b'z', b'z');
+        let classes = set.byte_classes();
+
+        let got: Vec<Unit> = classes.representatives(..).collect();
+        let expected = vec![
+            Unit::u8(b'\x00'),
+            Unit::u8(b'b'),
+            Unit::u8(b'e'),
+            Unit::u8(b'g'),
+            Unit::u8(b'n'),
+            Unit::u8(b'z'),
+            Unit::u8(b'\x7B'),
+            Unit::eoi(7),
+        ];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(..0).collect();
+        assert!(got.is_empty());
+        let got: Vec<Unit> = classes.representatives(1..1).collect();
+        assert!(got.is_empty());
+        let got: Vec<Unit> = classes.representatives(255..255).collect();
+        assert!(got.is_empty());
+
+        // A weird case that is the only guaranteed to way to get an iterator
+        // of just the EOI class by excluding all possible byte values.
+        let got: Vec<Unit> = classes
+            .representatives((
+                core::ops::Bound::Excluded(255),
+                core::ops::Bound::Unbounded,
+            ))
+            .collect();
+        let expected = vec![Unit::eoi(7)];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(..=255).collect();
+        let expected = vec![
+            Unit::u8(b'\x00'),
+            Unit::u8(b'b'),
+            Unit::u8(b'e'),
+            Unit::u8(b'g'),
+            Unit::u8(b'n'),
+            Unit::u8(b'z'),
+            Unit::u8(b'\x7B'),
+        ];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'b'..=b'd').collect();
+        let expected = vec![Unit::u8(b'b')];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'a'..=b'd').collect();
+        let expected = vec![Unit::u8(b'a'), Unit::u8(b'b')];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'b'..=b'e').collect();
+        let expected = vec![Unit::u8(b'b'), Unit::u8(b'e')];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'A'..=b'Z').collect();
+        let expected = vec![Unit::u8(b'A')];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'A'..=b'z').collect();
+        let expected = vec![
+            Unit::u8(b'A'),
+            Unit::u8(b'b'),
+            Unit::u8(b'e'),
+            Unit::u8(b'g'),
+            Unit::u8(b'n'),
+            Unit::u8(b'z'),
+        ];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'z'..).collect();
+        let expected = vec![Unit::u8(b'z'), Unit::u8(b'\x7B'), Unit::eoi(7)];
+        assert_eq!(expected, got);
+
+        let got: Vec<Unit> = classes.representatives(b'z'..=0xFF).collect();
+        let expected = vec![Unit::u8(b'z'), Unit::u8(b'\x7B')];
+        assert_eq!(expected, got);
+    }
+}
diff --git a/regex-automata/src/util/captures.rs b/regex-automata/src/util/captures.rs
new file mode 100644
index 0000000000..30bcced498
--- /dev/null
+++ b/regex-automata/src/util/captures.rs
@@ -0,0 +1,2546 @@
+/*!
+Provides types for dealing with capturing groups.
+
+Capturing groups refer to sub-patterns of regexes that some regex engines can
+report matching offsets for. For example, matching `[a-z]([0-9]+)` against
+`a789` would give `a789` as the overall match (for the implicit capturing group
+at index `0`) and `789` as the match for the capturing group `([0-9]+)` (an
+explicit capturing group at index `1`).
+
+Not all regex engines can report match offsets for capturing groups. Indeed,
+to a first approximation, regex engines that can report capturing group offsets
+tend to be quite a bit slower than regex engines that can't. This is because
+tracking capturing groups at search time usually requires more "power" that
+in turn adds overhead.
+
+Other regex implementations might call capturing groups "submatches."
+
+# Overview
+
+The main types in this module are:
+
+* [`Captures`] records the capturing group offsets found during a search. It
+provides convenience routines for looking up capturing group offsets by either
+index or name.
+* [`GroupInfo`] records the mapping between capturing groups and "slots,"
+where the latter are how capturing groups are recorded during a regex search.
+This also keeps a mapping from capturing group name to index, and capture
+group index to name. A `GroupInfo` is used by `Captures` internally to
+provide a convenient API. It is unlikely that you'll use a `GroupInfo`
+directly, but for example, if you've compiled an Thompson NFA, then you can use
+[`thompson::NFA::group_info`](crate::nfa::thompson::NFA::group_info) to get its
+underlying `GroupInfo`.
+*/
+
+use alloc::{string::String, sync::Arc, vec, vec::Vec};
+
+use crate::util::{
+    interpolate,
+    primitives::{
+        NonMaxUsize, PatternID, PatternIDError, PatternIDIter, SmallIndex,
+    },
+    search::{Match, Span},
+};
+
+/// The span offsets of capturing groups after a match has been found.
+///
+/// This type represents the output of regex engines that can report the
+/// offsets at which capturing groups matches or "submatches" occur. For
+/// example, the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM). When a match
+/// occurs, it will at minimum contain the [`PatternID`] of the pattern that
+/// matched. Depending upon how it was constructed, it may also contain the
+/// start/end offsets of the entire match of the pattern and the start/end
+/// offsets of each capturing group that participated in the match.
+///
+/// Values of this type are always created for a specific [`GroupInfo`]. It is
+/// unspecified behavior to use a `Captures` value in a search with any regex
+/// engine that has a different `GroupInfo` than the one the `Captures` were
+/// created with.
+///
+/// # Constructors
+///
+/// There are three constructors for this type that control what kind of
+/// information is available upon a match:
+///
+/// * [`Captures::all`]: Will store overall pattern match offsets in addition
+/// to the offsets of capturing groups that participated in the match.
+/// * [`Captures::matches`]: Will store only the overall pattern
+/// match offsets. The offsets of capturing groups (even ones that participated
+/// in the match) are not available.
+/// * [`Captures::empty`]: Will only store the pattern ID that matched. No
+/// match offsets are available at all.
+///
+/// If you aren't sure which to choose, then pick the first one. The first one
+/// is what convenience routines like,
+/// [`PikeVM::create_captures`](crate::nfa::thompson::pikevm::PikeVM::create_captures),
+/// will use automatically.
+///
+/// The main difference between these choices is performance. Namely, if you
+/// ask for _less_ information, then the execution of regex search may be able
+/// to run more quickly.
+///
+/// # Notes
+///
+/// It is worth pointing out that this type is not coupled to any one specific
+/// regex engine. Instead, its coupling is with [`GroupInfo`], which is the
+/// thing that is responsible for mapping capturing groups to "slot" offsets.
+/// Slot offsets are indices into a single sequence of memory at which matching
+/// haystack offsets for the corresponding group are written by regex engines.
+///
+/// # Example
+///
+/// This example shows how to parse a simple date and extract the components of
+/// the date via capturing groups:
+///
+/// ```
+/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+///
+/// let re = PikeVM::new(r"^([0-9]{4})-([0-9]{2})-([0-9]{2})$")?;
+/// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+///
+/// re.captures(&mut cache, "2010-03-14", &mut caps);
+/// assert!(caps.is_match());
+/// assert_eq!(Some(Span::from(0..4)), caps.get_group(1));
+/// assert_eq!(Some(Span::from(5..7)), caps.get_group(2));
+/// assert_eq!(Some(Span::from(8..10)), caps.get_group(3));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: named capturing groups
+///
+/// This example is like the one above, but leverages the ability to name
+/// capturing groups in order to make the code a bit clearer:
+///
+/// ```
+/// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+///
+/// let re = PikeVM::new(r"^(?P<y>[0-9]{4})-(?P<m>[0-9]{2})-(?P<d>[0-9]{2})$")?;
+/// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+///
+/// re.captures(&mut cache, "2010-03-14", &mut caps);
+/// assert!(caps.is_match());
+/// assert_eq!(Some(Span::from(0..4)), caps.get_group_by_name("y"));
+/// assert_eq!(Some(Span::from(5..7)), caps.get_group_by_name("m"));
+/// assert_eq!(Some(Span::from(8..10)), caps.get_group_by_name("d"));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone)]
+pub struct Captures {
+    /// The group info that these capture groups are coupled to. This is what
+    /// gives the "convenience" of the `Captures` API. Namely, it provides the
+    /// slot mapping and the name|-->index mapping for capture lookups by name.
+    group_info: GroupInfo,
+    /// The ID of the pattern that matched. Regex engines must set this to
+    /// None when no match occurs.
+    pid: Option<PatternID>,
+    /// The slot values, i.e., submatch offsets.
+    ///
+    /// In theory, the smallest sequence of slots would be something like
+    /// `max(groups(pattern) for pattern in regex) * 2`, but instead, we use
+    /// `sum(groups(pattern) for pattern in regex) * 2`. Why?
+    ///
+    /// Well, the former could be used in theory, because we don't generally
+    /// have any overlapping APIs that involve capturing groups. Therefore,
+    /// there's technically never any need to have slots set for multiple
+    /// patterns. However, this might change some day, in which case, we would
+    /// need to have slots available.
+    ///
+    /// The other reason is that during the execution of some regex engines,
+    /// there exists a point in time where multiple slots for different
+    /// patterns may be written to before knowing which pattern has matched.
+    /// Therefore, the regex engines themselves, in order to support multiple
+    /// patterns correctly, must have all slots available. If `Captures`
+    /// doesn't have all slots available, then regex engines can't write
+    /// directly into the caller provided `Captures` and must instead write
+    /// into some other storage and then copy the slots involved in the match
+    /// at the end of the search.
+    ///
+    /// So overall, at least as of the time of writing, it seems like the path
+    /// of least resistance is to just require allocating all possible slots
+    /// instead of the conceptual minimum. Another way to justify this is that
+    /// the most common case is a single pattern, in which case, there is no
+    /// inefficiency here since the 'max' and 'sum' calculations above are
+    /// equivalent in that case.
+    ///
+    /// N.B. The mapping from group index to slot is maintained by `GroupInfo`
+    /// and is considered an API guarantee. See `GroupInfo` for more details on
+    /// that mapping.
+    ///
+    /// N.B. `Option<NonMaxUsize>` has the same size as a `usize`.
+    slots: Vec<Option<NonMaxUsize>>,
+}
+
+impl Captures {
+    /// Create new storage for the offsets of all matching capturing groups.
+    ///
+    /// This routine provides the most information for matches---namely, the
+    /// spans of matching capturing groups---but also requires the regex search
+    /// routines to do the most work.
+    ///
+    /// It is unspecified behavior to use the returned `Captures` value in a
+    /// search with a `GroupInfo` other than the one that is provided to this
+    /// constructor.
+    ///
+    /// # Example
+    ///
+    /// This example shows that all capturing groups---but only ones that
+    /// participated in a match---are available to query after a match has
+    /// been found:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::captures::Captures,
+    ///     Span, Match,
+    /// };
+    ///
+    /// let re = PikeVM::new(
+    ///     r"^(?:(?P<lower>[a-z]+)|(?P<upper>[A-Z]+))(?P<digits>[0-9]+)$",
+    /// )?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = Captures::all(re.get_nfa().group_info().clone());
+    ///
+    /// re.captures(&mut cache, "ABC123", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(Match::must(0, 0..6)), caps.get_match());
+    /// // The 'lower' group didn't match, so it won't have any offsets.
+    /// assert_eq!(None, caps.get_group_by_name("lower"));
+    /// assert_eq!(Some(Span::from(0..3)), caps.get_group_by_name("upper"));
+    /// assert_eq!(Some(Span::from(3..6)), caps.get_group_by_name("digits"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn all(group_info: GroupInfo) -> Captures {
+        let slots = group_info.slot_len();
+        Captures { group_info, pid: None, slots: vec![None; slots] }
+    }
+
+    /// Create new storage for only the full match spans of a pattern. This
+    /// does not include any capturing group offsets.
+    ///
+    /// It is unspecified behavior to use the returned `Captures` value in a
+    /// search with a `GroupInfo` other than the one that is provided to this
+    /// constructor.
+    ///
+    /// # Example
+    ///
+    /// This example shows that only overall match offsets are reported when
+    /// this constructor is used. Accessing any capturing groups other than
+    /// the 0th will always return `None`.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::captures::Captures,
+    ///     Match,
+    /// };
+    ///
+    /// let re = PikeVM::new(
+    ///     r"^(?:(?P<lower>[a-z]+)|(?P<upper>[A-Z]+))(?P<digits>[0-9]+)$",
+    /// )?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = Captures::matches(re.get_nfa().group_info().clone());
+    ///
+    /// re.captures(&mut cache, "ABC123", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(Match::must(0, 0..6)), caps.get_match());
+    /// // We didn't ask for capturing group offsets, so they aren't available.
+    /// assert_eq!(None, caps.get_group_by_name("lower"));
+    /// assert_eq!(None, caps.get_group_by_name("upper"));
+    /// assert_eq!(None, caps.get_group_by_name("digits"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn matches(group_info: GroupInfo) -> Captures {
+        // This is OK because we know there are at least this many slots,
+        // and GroupInfo construction guarantees that the number of slots fits
+        // into a usize.
+        let slots = group_info.pattern_len().checked_mul(2).unwrap();
+        Captures { group_info, pid: None, slots: vec![None; slots] }
+    }
+
+    /// Create new storage for only tracking which pattern matched. No offsets
+    /// are stored at all.
+    ///
+    /// It is unspecified behavior to use the returned `Captures` value in a
+    /// search with a `GroupInfo` other than the one that is provided to this
+    /// constructor.
+    ///
+    /// # Example
+    ///
+    /// This example shows that only the pattern that matched can be accessed
+    /// from a `Captures` value created via this constructor.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::captures::Captures,
+    ///     PatternID,
+    /// };
+    ///
+    /// let re = PikeVM::new_many(&[r"[a-z]+", r"[A-Z]+"])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = Captures::empty(re.get_nfa().group_info().clone());
+    ///
+    /// re.captures(&mut cache, "aABCz", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(PatternID::must(0)), caps.pattern());
+    /// // We didn't ask for any offsets, so they aren't available.
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// re.captures(&mut cache, &"aABCz"[1..], &mut caps);
+    /// assert!(caps.is_match());
+    /// assert_eq!(Some(PatternID::must(1)), caps.pattern());
+    /// // We didn't ask for any offsets, so they aren't available.
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn empty(group_info: GroupInfo) -> Captures {
+        Captures { group_info, pid: None, slots: vec![] }
+    }
+
+    /// Returns true if and only if this capturing group represents a match.
+    ///
+    /// This is a convenience routine for `caps.pattern().is_some()`.
+    ///
+    /// # Example
+    ///
+    /// When using the PikeVM (for example), the lightest weight way of
+    /// detecting whether a match exists is to create capturing groups that
+    /// only track the ID of the pattern that match (if any):
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::captures::Captures,
+    /// };
+    ///
+    /// let re = PikeVM::new(r"[a-z]+")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = Captures::empty(re.get_nfa().group_info().clone());
+    ///
+    /// re.captures(&mut cache, "aABCz", &mut caps);
+    /// assert!(caps.is_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_match(&self) -> bool {
+        self.pid.is_some()
+    }
+
+    /// Returns the identifier of the pattern that matched when this
+    /// capturing group represents a match. If no match was found, then this
+    /// always returns `None`.
+    ///
+    /// This returns a pattern ID in precisely the cases in which `is_match`
+    /// returns `true`. Similarly, the pattern ID returned is always the
+    /// same pattern ID found in the `Match` returned by `get_match`.
+    ///
+    /// # Example
+    ///
+    /// When using the PikeVM (for example), the lightest weight way of
+    /// detecting which pattern matched is to create capturing groups that only
+    /// track the ID of the pattern that match (if any):
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::captures::Captures,
+    ///     PatternID,
+    /// };
+    ///
+    /// let re = PikeVM::new_many(&[r"[a-z]+", r"[A-Z]+"])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = Captures::empty(re.get_nfa().group_info().clone());
+    ///
+    /// re.captures(&mut cache, "ABC", &mut caps);
+    /// assert_eq!(Some(PatternID::must(1)), caps.pattern());
+    /// // Recall that offsets are only available when using a non-empty
+    /// // Captures value. So even though a match occurred, this returns None!
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn pattern(&self) -> Option<PatternID> {
+        self.pid
+    }
+
+    /// Returns the pattern ID and the span of the match, if one occurred.
+    ///
+    /// This always returns `None` when `Captures` was created with
+    /// [`Captures::empty`], even if a match was found.
+    ///
+    /// If this routine returns a non-`None` value, then `is_match` is
+    /// guaranteed to return `true` and `pattern` is also guaranteed to return
+    /// a non-`None` value.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get the full match from a search:
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match};
+    ///
+    /// let re = PikeVM::new_many(&[r"[a-z]+", r"[A-Z]+"])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "ABC", &mut caps);
+    /// assert_eq!(Some(Match::must(1, 0..3)), caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn get_match(&self) -> Option<Match> {
+        Some(Match::new(self.pattern()?, self.get_group(0)?))
+    }
+
+    /// Returns the span of a capturing group match corresponding to the group
+    /// index given, only if both the overall pattern matched and the capturing
+    /// group participated in that match.
+    ///
+    /// This returns `None` if `index` is invalid. `index` is valid if and only
+    /// if it's less than [`Captures::group_len`] for the matching pattern.
+    ///
+    /// This always returns `None` when `Captures` was created with
+    /// [`Captures::empty`], even if a match was found. This also always
+    /// returns `None` for any `index > 0` when `Captures` was created with
+    /// [`Captures::matches`].
+    ///
+    /// If this routine returns a non-`None` value, then `is_match` is
+    /// guaranteed to return `true`, `pattern` is guaranteed to return a
+    /// non-`None` value and `get_match` is guaranteed to return a non-`None`
+    /// value.
+    ///
+    /// By convention, the 0th capture group will always return the same
+    /// span as the span returned by `get_match`. This is because the 0th
+    /// capture group always corresponds to the entirety of the pattern's
+    /// match. (It is similarly always unnamed because it is implicit.) This
+    /// isn't necessarily true of all regex engines. For example, one can
+    /// hand-compile a [`thompson::NFA`](crate::nfa::thompson::NFA) via a
+    /// [`thompson::Builder`](crate::nfa::thompson::Builder), which isn't
+    /// technically forced to make the 0th capturing group always correspond to
+    /// the entire match.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get the capturing groups, by index, from a
+    /// match:
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span, Match};
+    ///
+    /// let re = PikeVM::new(r"^(?P<first>\pL+)\s+(?P<last>\pL+)$")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Bruce Springsteen", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..17)), caps.get_match());
+    /// assert_eq!(Some(Span::from(0..5)), caps.get_group(1));
+    /// assert_eq!(Some(Span::from(6..17)), caps.get_group(2));
+    /// // Looking for a non-existent capturing group will return None:
+    /// assert_eq!(None, caps.get_group(3));
+    /// assert_eq!(None, caps.get_group(9944060567225171988));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn get_group(&self, index: usize) -> Option<Span> {
+        let pid = self.pattern()?;
+        // There's a little bit of work needed to map captures to slots in the
+        // fully general case. But in the overwhelming common case of a single
+        // pattern, we can just do some simple arithmetic.
+        let (slot_start, slot_end) = if self.group_info().pattern_len() == 1 {
+            (index.checked_mul(2)?, index.checked_mul(2)?.checked_add(1)?)
+        } else {
+            self.group_info().slots(pid, index)?
+        };
+        let start = self.slots.get(slot_start).copied()??;
+        let end = self.slots.get(slot_end).copied()??;
+        Some(Span { start: start.get(), end: end.get() })
+    }
+
+    /// Returns the span of a capturing group match corresponding to the group
+    /// name given, only if both the overall pattern matched and the capturing
+    /// group participated in that match.
+    ///
+    /// This returns `None` if `name` does not correspond to a valid capturing
+    /// group for the pattern that matched.
+    ///
+    /// This always returns `None` when `Captures` was created with
+    /// [`Captures::empty`], even if a match was found. This also always
+    /// returns `None` for any `index > 0` when `Captures` was created with
+    /// [`Captures::matches`].
+    ///
+    /// If this routine returns a non-`None` value, then `is_match` is
+    /// guaranteed to return `true`, `pattern` is guaranteed to return a
+    /// non-`None` value and `get_match` is guaranteed to return a non-`None`
+    /// value.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get the capturing groups, by name, from a
+    /// match:
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span, Match};
+    ///
+    /// let re = PikeVM::new(r"^(?P<first>\pL+)\s+(?P<last>\pL+)$")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Bruce Springsteen", &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..17)), caps.get_match());
+    /// assert_eq!(Some(Span::from(0..5)), caps.get_group_by_name("first"));
+    /// assert_eq!(Some(Span::from(6..17)), caps.get_group_by_name("last"));
+    /// // Looking for a non-existent capturing group will return None:
+    /// assert_eq!(None, caps.get_group_by_name("middle"));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn get_group_by_name(&self, name: &str) -> Option<Span> {
+        let index = self.group_info().to_index(self.pattern()?, name)?;
+        self.get_group(index)
+    }
+
+    /// Returns an iterator of possible spans for every capturing group in the
+    /// matching pattern.
+    ///
+    /// If this `Captures` value does not correspond to a match, then the
+    /// iterator returned yields no elements.
+    ///
+    /// Note that the iterator returned yields elements of type `Option<Span>`.
+    /// A span is present if and only if it corresponds to a capturing group
+    /// that participated in a match.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to collect all capturing groups:
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+    ///
+    /// let re = PikeVM::new(
+    ///     // Matches first/last names, with an optional middle name.
+    ///     r"^(?P<first>\pL+)\s+(?:(?P<middle>\pL+)\s+)?(?P<last>\pL+)$",
+    /// )?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Harry James Potter", &mut caps);
+    /// assert!(caps.is_match());
+    /// let groups: Vec<Option<Span>> = caps.iter().collect();
+    /// assert_eq!(groups, vec![
+    ///     Some(Span::from(0..18)),
+    ///     Some(Span::from(0..5)),
+    ///     Some(Span::from(6..11)),
+    ///     Some(Span::from(12..18)),
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This example uses the same regex as the previous example, but with a
+    /// haystack that omits the middle name. This results in a capturing group
+    /// that is present in the elements yielded by the iterator but without a
+    /// match:
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Span};
+    ///
+    /// let re = PikeVM::new(
+    ///     // Matches first/last names, with an optional middle name.
+    ///     r"^(?P<first>\pL+)\s+(?:(?P<middle>\pL+)\s+)?(?P<last>\pL+)$",
+    /// )?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Harry Potter", &mut caps);
+    /// assert!(caps.is_match());
+    /// let groups: Vec<Option<Span>> = caps.iter().collect();
+    /// assert_eq!(groups, vec![
+    ///     Some(Span::from(0..12)),
+    ///     Some(Span::from(0..5)),
+    ///     None,
+    ///     Some(Span::from(6..12)),
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn iter(&self) -> CapturesPatternIter<'_> {
+        let names = self
+            .pattern()
+            .map_or(GroupInfoPatternNames::empty().enumerate(), |pid| {
+                self.group_info().pattern_names(pid).enumerate()
+            });
+        CapturesPatternIter { caps: self, names }
+    }
+
+    /// Return the total number of capturing groups for the matching pattern.
+    ///
+    /// If this `Captures` value does not correspond to a match, then this
+    /// always returns `0`.
+    ///
+    /// This always returns the same number of elements yielded by
+    /// [`Captures::iter`]. That is, the number includes capturing groups even
+    /// if they don't participate in the match.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to count the total number of capturing groups
+    /// associated with a pattern. Notice that it includes groups that did not
+    /// participate in a match (just like `Captures::iter` does).
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new(
+    ///     // Matches first/last names, with an optional middle name.
+    ///     r"^(?P<first>\pL+)\s+(?:(?P<middle>\pL+)\s+)?(?P<last>\pL+)$",
+    /// )?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Harry Potter", &mut caps);
+    /// assert_eq!(4, caps.group_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn group_len(&self) -> usize {
+        let pid = match self.pattern() {
+            None => return 0,
+            Some(pid) => pid,
+        };
+        self.group_info().group_len(pid)
+    }
+
+    /// Returns a reference to the underlying group info on which these
+    /// captures are based.
+    ///
+    /// The difference between `GroupInfo` and `Captures` is that the former
+    /// defines the structure of capturing groups where as the latter is what
+    /// stores the actual match information. So where as `Captures` only gives
+    /// you access to the current match, `GroupInfo` lets you query any
+    /// information about all capturing groups, even ones for patterns that
+    /// weren't involved in a match.
+    ///
+    /// Note that a `GroupInfo` uses reference counting internally, so it may
+    /// be cloned cheaply.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get all capturing group names from the
+    /// underlying `GroupInfo`. Notice that we don't even need to run a
+    /// search.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"(?P<foo>a)",
+    ///     r"(a)(b)",
+    ///     r"ab",
+    ///     r"(?P<bar>a)(?P<quux>a)",
+    ///     r"(?P<foo>z)",
+    /// ])?;
+    /// let caps = re.create_captures();
+    ///
+    /// let expected = vec![
+    ///     (PatternID::must(0), 0, None),
+    ///     (PatternID::must(0), 1, Some("foo")),
+    ///     (PatternID::must(1), 0, None),
+    ///     (PatternID::must(1), 1, None),
+    ///     (PatternID::must(1), 2, None),
+    ///     (PatternID::must(2), 0, None),
+    ///     (PatternID::must(3), 0, None),
+    ///     (PatternID::must(3), 1, Some("bar")),
+    ///     (PatternID::must(3), 2, Some("quux")),
+    ///     (PatternID::must(4), 0, None),
+    ///     (PatternID::must(4), 1, Some("foo")),
+    /// ];
+    /// // We could also just use 're.get_nfa().group_info()'.
+    /// let got: Vec<(PatternID, usize, Option<&str>)> =
+    ///     caps.group_info().all_names().collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn group_info(&self) -> &GroupInfo {
+        &self.group_info
+    }
+
+    /// Interpolates the capture references in `replacement` with the
+    /// corresponding substrings in `haystack` matched by each reference. The
+    /// interpolated string is returned.
+    ///
+    /// See the [`interpolate` module](interpolate) for documentation on the
+    /// format of the replacement string.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use interpolation, and also shows how it
+    /// can work with multi-pattern regexes.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    ///     r"(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let replacement = "year=$year, month=$month, day=$day";
+    ///
+    /// // This matches the first pattern.
+    /// let hay = "On 14-03-2010, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let result = caps.interpolate_string(hay, replacement);
+    /// assert_eq!("year=2010, month=03, day=14", result);
+    ///
+    /// // And this matches the second pattern.
+    /// let hay = "On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let result = caps.interpolate_string(hay, replacement);
+    /// assert_eq!("year=2010, month=03, day=14", result);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn interpolate_string(
+        &self,
+        haystack: &str,
+        replacement: &str,
+    ) -> String {
+        let mut dst = String::new();
+        self.interpolate_string_into(haystack, replacement, &mut dst);
+        dst
+    }
+
+    /// Interpolates the capture references in `replacement` with the
+    /// corresponding substrings in `haystack` matched by each reference. The
+    /// interpolated string is written to `dst`.
+    ///
+    /// See the [`interpolate` module](interpolate) for documentation on the
+    /// format of the replacement string.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use interpolation, and also shows how it
+    /// can work with multi-pattern regexes.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    ///     r"(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let replacement = "year=$year, month=$month, day=$day";
+    ///
+    /// // This matches the first pattern.
+    /// let hay = "On 14-03-2010, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let mut dst = String::new();
+    /// caps.interpolate_string_into(hay, replacement, &mut dst);
+    /// assert_eq!("year=2010, month=03, day=14", dst);
+    ///
+    /// // And this matches the second pattern.
+    /// let hay = "On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let mut dst = String::new();
+    /// caps.interpolate_string_into(hay, replacement, &mut dst);
+    /// assert_eq!("year=2010, month=03, day=14", dst);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn interpolate_string_into(
+        &self,
+        haystack: &str,
+        replacement: &str,
+        dst: &mut String,
+    ) {
+        interpolate::string(
+            replacement,
+            |index, dst| {
+                let span = match self.get_group(index) {
+                    None => return,
+                    Some(span) => span,
+                };
+                dst.push_str(&haystack[span]);
+            },
+            |name| self.group_info().to_index(self.pattern()?, name),
+            dst,
+        );
+    }
+
+    /// Interpolates the capture references in `replacement` with the
+    /// corresponding substrings in `haystack` matched by each reference. The
+    /// interpolated byte string is returned.
+    ///
+    /// See the [`interpolate` module](interpolate) for documentation on the
+    /// format of the replacement string.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use interpolation, and also shows how it
+    /// can work with multi-pattern regexes.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    ///     r"(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let replacement = b"year=$year, month=$month, day=$day";
+    ///
+    /// // This matches the first pattern.
+    /// let hay = b"On 14-03-2010, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let result = caps.interpolate_bytes(hay, replacement);
+    /// assert_eq!(&b"year=2010, month=03, day=14"[..], result);
+    ///
+    /// // And this matches the second pattern.
+    /// let hay = b"On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let result = caps.interpolate_bytes(hay, replacement);
+    /// assert_eq!(&b"year=2010, month=03, day=14"[..], result);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn interpolate_bytes(
+        &self,
+        haystack: &[u8],
+        replacement: &[u8],
+    ) -> Vec<u8> {
+        let mut dst = vec![];
+        self.interpolate_bytes_into(haystack, replacement, &mut dst);
+        dst
+    }
+
+    /// Interpolates the capture references in `replacement` with the
+    /// corresponding substrings in `haystack` matched by each reference. The
+    /// interpolated byte string is written to `dst`.
+    ///
+    /// See the [`interpolate` module](interpolate) for documentation on the
+    /// format of the replacement string.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use interpolation, and also shows how it
+    /// can work with multi-pattern regexes.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, PatternID};
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    ///     r"(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})",
+    /// ])?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let replacement = b"year=$year, month=$month, day=$day";
+    ///
+    /// // This matches the first pattern.
+    /// let hay = b"On 14-03-2010, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let mut dst = vec![];
+    /// caps.interpolate_bytes_into(hay, replacement, &mut dst);
+    /// assert_eq!(&b"year=2010, month=03, day=14"[..], dst);
+    ///
+    /// // And this matches the second pattern.
+    /// let hay = b"On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// let mut dst = vec![];
+    /// caps.interpolate_bytes_into(hay, replacement, &mut dst);
+    /// assert_eq!(&b"year=2010, month=03, day=14"[..], dst);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn interpolate_bytes_into(
+        &self,
+        haystack: &[u8],
+        replacement: &[u8],
+        dst: &mut Vec<u8>,
+    ) {
+        interpolate::bytes(
+            replacement,
+            |index, dst| {
+                let span = match self.get_group(index) {
+                    None => return,
+                    Some(span) => span,
+                };
+                dst.extend_from_slice(&haystack[span]);
+            },
+            |name| self.group_info().to_index(self.pattern()?, name),
+            dst,
+        );
+    }
+
+    /// This is a convenience routine for extracting the substrings
+    /// corresponding to matching capture groups in the given `haystack`. The
+    /// `haystack` should be the same substring used to find the match spans in
+    /// this `Captures` value.
+    ///
+    /// This is identical to [`Captures::extract_bytes`], except it works with
+    /// `&str` instead of `&[u8]`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the number of explicit matching groups in this
+    /// `Captures` value is less than `N`. This also panics if this `Captures`
+    /// value does not correspond to a match.
+    ///
+    /// Note that this does *not* panic if the number of explicit matching
+    /// groups is bigger than `N`. In that case, only the first `N` matching
+    /// groups are extracted.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let hay = "On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// assert!(caps.is_match());
+    /// let (full, [year, month, day]) = caps.extract(hay);
+    /// assert_eq!("2010-03-14", full);
+    /// assert_eq!("2010", year);
+    /// assert_eq!("03", month);
+    /// assert_eq!("14", day);
+    ///
+    /// // We can also ask for fewer than all capture groups.
+    /// let (full, [year]) = caps.extract(hay);
+    /// assert_eq!("2010-03-14", full);
+    /// assert_eq!("2010", year);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn extract<'h, const N: usize>(
+        &self,
+        haystack: &'h str,
+    ) -> (&'h str, [&'h str; N]) {
+        let mut matched = self.iter().flatten();
+        let whole_match = &haystack[matched.next().expect("a match")];
+        let group_matches = [0; N].map(|_| {
+            let sp = matched.next().expect("too few matching groups");
+            &haystack[sp]
+        });
+        (whole_match, group_matches)
+    }
+
+    /// This is a convenience routine for extracting the substrings
+    /// corresponding to matching capture groups in the given `haystack`. The
+    /// `haystack` should be the same substring used to find the match spans in
+    /// this `Captures` value.
+    ///
+    /// This is identical to [`Captures::extract`], except it works with
+    /// `&[u8]` instead of `&str`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the number of explicit matching groups in this
+    /// `Captures` value is less than `N`. This also panics if this `Captures`
+    /// value does not correspond to a match.
+    ///
+    /// Note that this does *not* panic if the number of explicit matching
+    /// groups is bigger than `N`. In that case, only the first `N` matching
+    /// groups are extracted.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// let hay = b"On 2010-03-14, I became a Tenneessee lamb.";
+    /// re.captures(&mut cache, hay, &mut caps);
+    /// assert!(caps.is_match());
+    /// let (full, [year, month, day]) = caps.extract_bytes(hay);
+    /// assert_eq!(b"2010-03-14", full);
+    /// assert_eq!(b"2010", year);
+    /// assert_eq!(b"03", month);
+    /// assert_eq!(b"14", day);
+    ///
+    /// // We can also ask for fewer than all capture groups.
+    /// let (full, [year]) = caps.extract_bytes(hay);
+    /// assert_eq!(b"2010-03-14", full);
+    /// assert_eq!(b"2010", year);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn extract_bytes<'h, const N: usize>(
+        &self,
+        haystack: &'h [u8],
+    ) -> (&'h [u8], [&'h [u8]; N]) {
+        let mut matched = self.iter().flatten();
+        let whole_match = &haystack[matched.next().expect("a match")];
+        let group_matches = [0; N].map(|_| {
+            let sp = matched.next().expect("too few matching groups");
+            &haystack[sp]
+        });
+        (whole_match, group_matches)
+    }
+}
+
+/// Lower level "slot" oriented APIs. One does not typically need to use these
+/// when executing a search. They are instead mostly intended for folks that
+/// are writing their own regex engine while reusing this `Captures` type.
+impl Captures {
+    /// Clear this `Captures` value.
+    ///
+    /// After clearing, all slots inside this `Captures` value will be set to
+    /// `None`. Similarly, any pattern ID that it was previously associated
+    /// with (for a match) is erased.
+    ///
+    /// It is not usually necessary to call this routine. Namely, a `Captures`
+    /// value only provides high level access to the capturing groups of the
+    /// pattern that matched, and only low level access to individual slots.
+    /// Thus, even if slots corresponding to groups that aren't associated
+    /// with the matching pattern are set, then it won't impact the higher
+    /// level APIs. Namely, higher level APIs like [`Captures::get_group`] will
+    /// return `None` if no pattern ID is present, even if there are spans set
+    /// in the underlying slots.
+    ///
+    /// Thus, to "clear" a `Captures` value of a match, it is usually only
+    /// necessary to call [`Captures::set_pattern`] with `None`.
+    ///
+    /// # Example
+    ///
+    /// This example shows what happens when a `Captures` value is cleared.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new(r"^(?P<first>\pL+)\s+(?P<last>\pL+)$")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Bruce Springsteen", &mut caps);
+    /// assert!(caps.is_match());
+    /// let slots: Vec<Option<usize>> =
+    ///     caps.slots().iter().map(|s| s.map(|x| x.get())).collect();
+    /// // Note that the following ordering is considered an API guarantee.
+    /// assert_eq!(slots, vec![
+    ///     Some(0),
+    ///     Some(17),
+    ///     Some(0),
+    ///     Some(5),
+    ///     Some(6),
+    ///     Some(17),
+    /// ]);
+    ///
+    /// // Now clear the slots. Everything is gone and it is no longer a match.
+    /// caps.clear();
+    /// assert!(!caps.is_match());
+    /// let slots: Vec<Option<usize>> =
+    ///     caps.slots().iter().map(|s| s.map(|x| x.get())).collect();
+    /// assert_eq!(slots, vec![
+    ///     None,
+    ///     None,
+    ///     None,
+    ///     None,
+    ///     None,
+    ///     None,
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn clear(&mut self) {
+        self.pid = None;
+        for slot in self.slots.iter_mut() {
+            *slot = None;
+        }
+    }
+
+    /// Set the pattern on this `Captures` value.
+    ///
+    /// When the pattern ID is `None`, then this `Captures` value does not
+    /// correspond to a match (`is_match` will return `false`). Otherwise, it
+    /// corresponds to a match.
+    ///
+    /// This is useful in search implementations where you might want to
+    /// initially call `set_pattern(None)` in order to avoid the cost of
+    /// calling `clear()` if it turns out to not be necessary.
+    ///
+    /// # Example
+    ///
+    /// This example shows that `set_pattern` merely overwrites the pattern ID.
+    /// It does not actually change the underlying slot values.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::nfa::thompson::pikevm::PikeVM;
+    ///
+    /// let re = PikeVM::new(r"^(?P<first>\pL+)\s+(?P<last>\pL+)$")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "Bruce Springsteen", &mut caps);
+    /// assert!(caps.is_match());
+    /// assert!(caps.pattern().is_some());
+    /// let slots: Vec<Option<usize>> =
+    ///     caps.slots().iter().map(|s| s.map(|x| x.get())).collect();
+    /// // Note that the following ordering is considered an API guarantee.
+    /// assert_eq!(slots, vec![
+    ///     Some(0),
+    ///     Some(17),
+    ///     Some(0),
+    ///     Some(5),
+    ///     Some(6),
+    ///     Some(17),
+    /// ]);
+    ///
+    /// // Now set the pattern to None. Note that the slot values remain.
+    /// caps.set_pattern(None);
+    /// assert!(!caps.is_match());
+    /// assert!(!caps.pattern().is_some());
+    /// let slots: Vec<Option<usize>> =
+    ///     caps.slots().iter().map(|s| s.map(|x| x.get())).collect();
+    /// // Note that the following ordering is considered an API guarantee.
+    /// assert_eq!(slots, vec![
+    ///     Some(0),
+    ///     Some(17),
+    ///     Some(0),
+    ///     Some(5),
+    ///     Some(6),
+    ///     Some(17),
+    /// ]);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn set_pattern(&mut self, pid: Option<PatternID>) {
+        self.pid = pid;
+    }
+
+    /// Returns the underlying slots, where each slot stores a single offset.
+    ///
+    /// Every matching capturing group generally corresponds to two slots: one
+    /// slot for the starting position and another for the ending position.
+    /// Typically, either both are present or neither are. (The weasel word
+    /// "typically" is used here because it really depends on the regex engine
+    /// implementation. Every sensible regex engine likely adheres to this
+    /// invariant, and every regex engine in this crate is sensible.)
+    ///
+    /// Generally speaking, callers should prefer to use higher level routines
+    /// like [`Captures::get_match`] or [`Captures::get_group`].
+    ///
+    /// An important note here is that a regex engine may not reset all of the
+    /// slots to `None` values when no match occurs, or even when a match of
+    /// a different pattern occurs. But this depends on how the regex engine
+    /// implementation deals with slots.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get the underlying slots from a regex match.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::primitives::{PatternID, NonMaxUsize},
+    /// };
+    ///
+    /// let re = PikeVM::new_many(&[
+    ///     r"[a-z]+",
+    ///     r"[0-9]+",
+    /// ])?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// re.captures(&mut cache, "123", &mut caps);
+    /// assert_eq!(Some(PatternID::must(1)), caps.pattern());
+    /// // Note that the only guarantee we have here is that slots 2 and 3
+    /// // are set to correct values. The contents of the first two slots are
+    /// // unspecified since the 0th pattern did not match.
+    /// let expected = &[
+    ///     None,
+    ///     None,
+    ///     NonMaxUsize::new(0),
+    ///     NonMaxUsize::new(3),
+    /// ];
+    /// assert_eq!(expected, caps.slots());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn slots(&self) -> &[Option<NonMaxUsize>] {
+        &self.slots
+    }
+
+    /// Returns the underlying slots as a mutable slice, where each slot stores
+    /// a single offset.
+    ///
+    /// This tends to be most useful for regex engine implementations for
+    /// writing offsets for matching capturing groups to slots.
+    ///
+    /// See [`Captures::slots`] for more information about slots.
+    #[inline]
+    pub fn slots_mut(&mut self) -> &mut [Option<NonMaxUsize>] {
+        &mut self.slots
+    }
+}
+
+impl core::fmt::Debug for Captures {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut dstruct = f.debug_struct("Captures");
+        dstruct.field("pid", &self.pid);
+        if let Some(pid) = self.pid {
+            dstruct.field("spans", &CapturesDebugMap { pid, caps: self });
+        }
+        dstruct.finish()
+    }
+}
+
+/// A little helper type to provide a nice map-like debug representation for
+/// our capturing group spans.
+struct CapturesDebugMap<'a> {
+    pid: PatternID,
+    caps: &'a Captures,
+}
+
+impl<'a> core::fmt::Debug for CapturesDebugMap<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        struct Key<'a>(usize, Option<&'a str>);
+
+        impl<'a> core::fmt::Debug for Key<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "{}", self.0)?;
+                if let Some(name) = self.1 {
+                    write!(f, "/{:?}", name)?;
+                }
+                Ok(())
+            }
+        }
+
+        let mut map = f.debug_map();
+        let names = self.caps.group_info().pattern_names(self.pid);
+        for (group_index, maybe_name) in names.enumerate() {
+            let key = Key(group_index, maybe_name);
+            match self.caps.get_group(group_index) {
+                None => map.entry(&key, &None::<()>),
+                Some(span) => map.entry(&key, &span),
+            };
+        }
+        map.finish()
+    }
+}
+
+/// An iterator over all capturing groups in a `Captures` value.
+///
+/// This iterator includes capturing groups that did not participate in a
+/// match. See the [`Captures::iter`] method documentation for more details
+/// and examples.
+///
+/// The lifetime parameter `'a` refers to the lifetime of the underlying
+/// `Captures` value.
+#[derive(Clone, Debug)]
+pub struct CapturesPatternIter<'a> {
+    caps: &'a Captures,
+    names: core::iter::Enumerate<GroupInfoPatternNames<'a>>,
+}
+
+impl<'a> Iterator for CapturesPatternIter<'a> {
+    type Item = Option<Span>;
+
+    fn next(&mut self) -> Option<Option<Span>> {
+        let (group_index, _) = self.names.next()?;
+        Some(self.caps.get_group(group_index))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.names.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.names.count()
+    }
+}
+
+impl<'a> ExactSizeIterator for CapturesPatternIter<'a> {}
+impl<'a> core::iter::FusedIterator for CapturesPatternIter<'a> {}
+
+/// Represents information about capturing groups in a compiled regex.
+///
+/// The information encapsulated by this type consists of the following. For
+/// each pattern:
+///
+/// * A map from every capture group name to its corresponding capture group
+/// index.
+/// * A map from every capture group index to its corresponding capture group
+/// name.
+/// * A map from capture group index to its corresponding slot index. A slot
+/// refers to one half of a capturing group. That is, a capture slot is either
+/// the start or end of a capturing group. A slot is usually the mechanism
+/// by which a regex engine records offsets for each capturing group during a
+/// search.
+///
+/// A `GroupInfo` uses reference counting internally and is thus cheap to
+/// clone.
+///
+/// # Mapping from capture groups to slots
+///
+/// One of the main responsibilities of a `GroupInfo` is to build a mapping
+/// from `(PatternID, u32)` (where the `u32` is a capture index) to something
+/// called a "slot." As mentioned above, a slot refers to one half of a
+/// capturing group. Both combined provide the start and end offsets of
+/// a capturing group that participated in a match.
+///
+/// **The mapping between group indices and slots is an API guarantee.** That
+/// is, the mapping won't change within a semver compatible release.
+///
+/// Slots exist primarily because this is a convenient mechanism by which
+/// regex engines report group offsets at search time. For example, the
+/// [`nfa::thompson::State::Capture`](crate::nfa::thompson::State::Capture)
+/// NFA state includes the slot index. When a regex engine transitions through
+/// this state, it will likely use the slot index to write the current haystack
+/// offset to some region of memory. When a match is found, those slots are
+/// then reported to the caller, typically via a convenient abstraction like a
+/// [`Captures`] value.
+///
+/// Because this crate provides first class support for multi-pattern regexes,
+/// and because of some performance related reasons, the mapping between
+/// capturing groups and slots is a little complex. However, in the case of a
+/// single pattern, the mapping can be described very simply: for all capture
+/// group indices `i`, its corresponding slots are at `i * 2` and `i * 2 + 1`.
+/// Notice that the pattern ID isn't involved at all here, because it only
+/// applies to a single-pattern regex, it is therefore always `0`.
+///
+/// In the multi-pattern case, the mapping is a bit more complicated. To talk
+/// about it, we must define what we mean by "implicit" vs "explicit"
+/// capturing groups:
+///
+/// * An **implicit** capturing group refers to the capturing group that is
+/// present for every pattern automatically, and corresponds to the overall
+/// match of a pattern. Every pattern has precisely one implicit capturing
+/// group. It is always unnamed and it always corresponds to the capture group
+/// index `0`.
+/// * An **explicit** capturing group refers to any capturing group that
+/// appears in the concrete syntax of the pattern. (Or, if an NFA was hand
+/// built without any concrete syntax, it refers to any capturing group with an
+/// index greater than `0`.)
+///
+/// Some examples:
+///
+/// * `\w+` has one implicit capturing group and zero explicit capturing
+/// groups.
+/// * `(\w+)` has one implicit group and one explicit group.
+/// * `foo(\d+)(?:\pL+)(\d+)` has one implicit group and two explicit groups.
+///
+/// Turning back to the slot mapping, we can now state it as follows:
+///
+/// * Given a pattern ID `pid`, the slots for its implicit group are always
+/// at `pid * 2` and `pid * 2 + 1`.
+/// * Given a pattern ID `0`, the slots for its explicit groups start
+/// at `group_info.pattern_len() * 2`.
+/// * Given a pattern ID `pid > 0`, the slots for its explicit groups start
+/// immediately following where the slots for the explicit groups of `pid - 1`
+/// end.
+///
+/// In particular, while there is a concrete formula one can use to determine
+/// where the slots for the implicit group of any pattern are, there is no
+/// general formula for determining where the slots for explicit capturing
+/// groups are. This is because each pattern can contain a different number
+/// of groups.
+///
+/// The intended way of getting the slots for a particular capturing group
+/// (whether implicit or explicit) is via the [`GroupInfo::slot`] or
+/// [`GroupInfo::slots`] method.
+///
+/// See below for a concrete example of how capturing groups get mapped to
+/// slots.
+///
+/// # Example
+///
+/// This example shows how to build a new `GroupInfo` and query it for
+/// information.
+///
+/// ```
+/// use regex_automata::util::{captures::GroupInfo, primitives::PatternID};
+///
+/// let info = GroupInfo::new(vec![
+///     vec![None, Some("foo")],
+///     vec![None],
+///     vec![None, None, None, Some("bar"), None],
+///     vec![None, None, Some("foo")],
+/// ])?;
+/// // The number of patterns being tracked.
+/// assert_eq!(4, info.pattern_len());
+/// // We can query the number of groups for any pattern.
+/// assert_eq!(2, info.group_len(PatternID::must(0)));
+/// assert_eq!(1, info.group_len(PatternID::must(1)));
+/// assert_eq!(5, info.group_len(PatternID::must(2)));
+/// assert_eq!(3, info.group_len(PatternID::must(3)));
+/// // An invalid pattern always has zero groups.
+/// assert_eq!(0, info.group_len(PatternID::must(999)));
+/// // 2 slots per group
+/// assert_eq!(22, info.slot_len());
+///
+/// // We can map a group index for a particular pattern to its name, if
+/// // one exists.
+/// assert_eq!(Some("foo"), info.to_name(PatternID::must(3), 2));
+/// assert_eq!(None, info.to_name(PatternID::must(2), 4));
+/// // Or map a name to its group index.
+/// assert_eq!(Some(1), info.to_index(PatternID::must(0), "foo"));
+/// assert_eq!(Some(2), info.to_index(PatternID::must(3), "foo"));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: mapping from capture groups to slots
+///
+/// This example shows the specific mapping from capture group indices for
+/// each pattern to their corresponding slots. The slot values shown in this
+/// example are considered an API guarantee.
+///
+/// ```
+/// use regex_automata::util::{captures::GroupInfo, primitives::PatternID};
+///
+/// let info = GroupInfo::new(vec![
+///     vec![None, Some("foo")],
+///     vec![None],
+///     vec![None, None, None, Some("bar"), None],
+///     vec![None, None, Some("foo")],
+/// ])?;
+///
+/// // We first show the slots for each pattern's implicit group.
+/// assert_eq!(Some((0, 1)), info.slots(PatternID::must(0), 0));
+/// assert_eq!(Some((2, 3)), info.slots(PatternID::must(1), 0));
+/// assert_eq!(Some((4, 5)), info.slots(PatternID::must(2), 0));
+/// assert_eq!(Some((6, 7)), info.slots(PatternID::must(3), 0));
+///
+/// // And now we show the slots for each pattern's explicit group.
+/// assert_eq!(Some((8, 9)), info.slots(PatternID::must(0), 1));
+/// assert_eq!(Some((10, 11)), info.slots(PatternID::must(2), 1));
+/// assert_eq!(Some((12, 13)), info.slots(PatternID::must(2), 2));
+/// assert_eq!(Some((14, 15)), info.slots(PatternID::must(2), 3));
+/// assert_eq!(Some((16, 17)), info.slots(PatternID::must(2), 4));
+/// assert_eq!(Some((18, 19)), info.slots(PatternID::must(3), 1));
+/// assert_eq!(Some((20, 21)), info.slots(PatternID::must(3), 2));
+///
+/// // Asking for the slots for an invalid pattern ID or even for an invalid
+/// // group index for a specific pattern will return None. So for example,
+/// // you're guaranteed to not get the slots for a different pattern than the
+/// // one requested.
+/// assert_eq!(None, info.slots(PatternID::must(5), 0));
+/// assert_eq!(None, info.slots(PatternID::must(1), 1));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct GroupInfo(Arc<GroupInfoInner>);
+
+impl GroupInfo {
+    /// Creates a new group info from a sequence of patterns, where each
+    /// sequence of patterns yields a sequence of possible group names. The
+    /// index of each pattern in the sequence corresponds to its `PatternID`,
+    /// and the index of each group in each pattern's sequence corresponds to
+    /// its coresponding group index.
+    ///
+    /// While this constructor is very generic and therefore perhaps hard to
+    /// chew on, an example of a valid concrete type that can be passed to
+    /// this constructor is `Vec<Vec<Option<String>>>`. The outer `Vec`
+    /// corresponds to the patterns, i.e., one `Vec<Option<String>>` per
+    /// pattern. The inner `Vec` corresponds to the capturing groups for
+    /// each pattern. The `Option<String>` corresponds to the name of the
+    /// capturing group, if present.
+    ///
+    /// It is legal to pass an empty iterator to this constructor. It will
+    /// return an empty group info with zero slots. An empty group info is
+    /// useful for cases where you have no patterns or for cases where slots
+    /// aren't being used at all (e.g., for most DFAs in this crate).
+    ///
+    /// # Errors
+    ///
+    /// This constructor returns an error if the given capturing groups are
+    /// invalid in some way. Those reasons include, but are not necessarily
+    /// limited to:
+    ///
+    /// * Too many patterns (i.e., `PatternID` would overflow).
+    /// * Too many capturing groups (e.g., `u32` would overflow).
+    /// * A pattern is given that has no capturing groups. (All patterns must
+    /// have at least an implicit capturing group at index `0`.)
+    /// * The capturing group at index `0` has a name. It must be unnamed.
+    /// * There are duplicate capturing group names within the same pattern.
+    /// (Multiple capturing groups with the same name may exist, but they
+    /// must be in different patterns.)
+    ///
+    /// An example below shows how to trigger some of the above error
+    /// conditions.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a new `GroupInfo` and query it for
+    /// information.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// let info = GroupInfo::new(vec![
+    ///     vec![None, Some("foo")],
+    ///     vec![None],
+    ///     vec![None, None, None, Some("bar"), None],
+    ///     vec![None, None, Some("foo")],
+    /// ])?;
+    /// // The number of patterns being tracked.
+    /// assert_eq!(4, info.pattern_len());
+    /// // 2 slots per group
+    /// assert_eq!(22, info.slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: empty `GroupInfo`
+    ///
+    /// This example shows how to build a new `GroupInfo` and query it for
+    /// information.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// let info = GroupInfo::empty();
+    /// // Everything is zero.
+    /// assert_eq!(0, info.pattern_len());
+    /// assert_eq!(0, info.slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: error conditions
+    ///
+    /// This example shows how to provoke some of the ways in which building
+    /// a `GroupInfo` can fail.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// // Either the group info is empty, or all patterns must have at least
+    /// // one capturing group.
+    /// assert!(GroupInfo::new(vec![
+    ///     vec![None, Some("a")], // ok
+    ///     vec![None], // ok
+    ///     vec![], // not ok
+    /// ]).is_err());
+    /// // Note that building an empty group info is OK.
+    /// assert!(GroupInfo::new(Vec::<Vec<Option<String>>>::new()).is_ok());
+    ///
+    /// // The first group in each pattern must correspond to an implicit
+    /// // anonymous group. i.e., One that is not named. By convention, this
+    /// // group corresponds to the overall match of a regex. Every other group
+    /// // in a pattern is explicit and optional.
+    /// assert!(GroupInfo::new(vec![vec![Some("foo")]]).is_err());
+    ///
+    /// // There must not be duplicate group names within the same pattern.
+    /// assert!(GroupInfo::new(vec![
+    ///     vec![None, Some("foo"), Some("foo")],
+    /// ]).is_err());
+    /// // But duplicate names across distinct patterns is OK.
+    /// assert!(GroupInfo::new(vec![
+    ///     vec![None, Some("foo")],
+    ///     vec![None, Some("foo")],
+    /// ]).is_ok());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// There are other ways for building a `GroupInfo` to fail but are
+    /// difficult to show. For example, if the number of patterns given would
+    /// overflow `PatternID`.
+    pub fn new<P, G, N>(pattern_groups: P) -> Result<GroupInfo, GroupInfoError>
+    where
+        P: IntoIterator<Item = G>,
+        G: IntoIterator<Item = Option<N>>,
+        N: AsRef<str>,
+    {
+        let mut group_info = GroupInfoInner {
+            slot_ranges: vec![],
+            name_to_index: vec![],
+            index_to_name: vec![],
+            memory_extra: 0,
+        };
+        for (pattern_index, groups) in pattern_groups.into_iter().enumerate() {
+            // If we can't convert the pattern index to an ID, then the caller
+            // tried to build capture info for too many patterns.
+            let pid = PatternID::new(pattern_index)
+                .map_err(GroupInfoError::too_many_patterns)?;
+
+            let mut groups_iter = groups.into_iter().enumerate();
+            match groups_iter.next() {
+                None => return Err(GroupInfoError::missing_groups(pid)),
+                Some((_, Some(_))) => {
+                    return Err(GroupInfoError::first_must_be_unnamed(pid))
+                }
+                Some((_, None)) => {}
+            }
+            group_info.add_first_group(pid);
+            // Now iterate over the rest, which correspond to all of the
+            // (conventionally) explicit capture groups in a regex pattern.
+            for (group_index, maybe_name) in groups_iter {
+                // Just like for patterns, if the group index can't be
+                // converted to a "small" index, then the caller has given too
+                // many groups for a particular pattern.
+                let group = SmallIndex::new(group_index).map_err(|_| {
+                    GroupInfoError::too_many_groups(pid, group_index)
+                })?;
+                group_info.add_explicit_group(pid, group, maybe_name)?;
+            }
+        }
+        group_info.fixup_slot_ranges()?;
+        Ok(GroupInfo(Arc::new(group_info)))
+    }
+
+    /// This creates an empty `GroupInfo`.
+    ///
+    /// This is a convenience routine for calling `GroupInfo::new` with an
+    /// iterator that yields no elements.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a new empty `GroupInfo` and query it
+    /// for information.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// let info = GroupInfo::empty();
+    /// // Everything is zero.
+    /// assert_eq!(0, info.pattern_len());
+    /// assert_eq!(0, info.all_group_len());
+    /// assert_eq!(0, info.slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn empty() -> GroupInfo {
+        GroupInfo::new(core::iter::empty::<[Option<&str>; 0]>())
+            .expect("empty group info is always valid")
+    }
+
+    /// Return the capture group index corresponding to the given name in the
+    /// given pattern. If no such capture group name exists in the given
+    /// pattern, then this returns `None`.
+    ///
+    /// If the given pattern ID is invalid, then this returns `None`.
+    ///
+    /// This also returns `None` for all inputs if these captures are empty
+    /// (e.g., built from an empty [`GroupInfo`]). To check whether captures
+    /// are are present for a specific pattern, use [`GroupInfo::group_len`].
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the capture index for the given pattern
+    /// and group name.
+    ///
+    /// Remember that capture indices are relative to the pattern, such that
+    /// the same capture index value may refer to different capturing groups
+    /// for distinct patterns.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let (pid0, pid1) = (PatternID::must(0), PatternID::must(1));
+    ///
+    /// let nfa = NFA::new_many(&[
+    ///     r"a(?P<quux>\w+)z(?P<foo>\s+)",
+    ///     r"a(?P<foo>\d+)z",
+    /// ])?;
+    /// let groups = nfa.group_info();
+    /// assert_eq!(Some(2), groups.to_index(pid0, "foo"));
+    /// // Recall that capture index 0 is always unnamed and refers to the
+    /// // entire pattern. So the first capturing group present in the pattern
+    /// // itself always starts at index 1.
+    /// assert_eq!(Some(1), groups.to_index(pid1, "foo"));
+    ///
+    /// // And if a name does not exist for a particular pattern, None is
+    /// // returned.
+    /// assert!(groups.to_index(pid0, "quux").is_some());
+    /// assert!(groups.to_index(pid1, "quux").is_none());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_index(&self, pid: PatternID, name: &str) -> Option<usize> {
+        let indices = self.0.name_to_index.get(pid.as_usize())?;
+        indices.get(name).cloned().map(|i| i.as_usize())
+    }
+
+    /// Return the capture name for the given index and given pattern. If the
+    /// corresponding group does not have a name, then this returns `None`.
+    ///
+    /// If the pattern ID is invalid, then this returns `None`.
+    ///
+    /// If the group index is invalid for the given pattern, then this returns
+    /// `None`. A group `index` is valid for a pattern `pid` in an `nfa` if and
+    /// only if `index < nfa.pattern_capture_len(pid)`.
+    ///
+    /// This also returns `None` for all inputs if these captures are empty
+    /// (e.g., built from an empty [`GroupInfo`]). To check whether captures
+    /// are are present for a specific pattern, use [`GroupInfo::group_len`].
+    ///
+    /// # Example
+    ///
+    /// This example shows how to find the capture group name for the given
+    /// pattern and group index.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let (pid0, pid1) = (PatternID::must(0), PatternID::must(1));
+    ///
+    /// let nfa = NFA::new_many(&[
+    ///     r"a(?P<foo>\w+)z(\s+)x(\d+)",
+    ///     r"a(\d+)z(?P<foo>\s+)",
+    /// ])?;
+    /// let groups = nfa.group_info();
+    /// assert_eq!(None, groups.to_name(pid0, 0));
+    /// assert_eq!(Some("foo"), groups.to_name(pid0, 1));
+    /// assert_eq!(None, groups.to_name(pid0, 2));
+    /// assert_eq!(None, groups.to_name(pid0, 3));
+    ///
+    /// assert_eq!(None, groups.to_name(pid1, 0));
+    /// assert_eq!(None, groups.to_name(pid1, 1));
+    /// assert_eq!(Some("foo"), groups.to_name(pid1, 2));
+    /// // '3' is not a valid capture index for the second pattern.
+    /// assert_eq!(None, groups.to_name(pid1, 3));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_name(&self, pid: PatternID, group_index: usize) -> Option<&str> {
+        let pattern_names = self.0.index_to_name.get(pid.as_usize())?;
+        pattern_names.get(group_index)?.as_deref()
+    }
+
+    /// Return an iterator of all capture groups and their names (if present)
+    /// for a particular pattern.
+    ///
+    /// If the given pattern ID is invalid or if this `GroupInfo` is empty,
+    /// then the iterator yields no elements.
+    ///
+    /// The number of elements yielded by this iterator is always equal to
+    /// the result of calling [`GroupInfo::group_len`] with the same
+    /// `PatternID`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get a list of all capture group names for
+    /// a particular pattern.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new(r"(a)(?P<foo>b)(c)(d)(?P<bar>e)")?;
+    /// // The first is the implicit group that is always unnammed. The next
+    /// // 5 groups are the explicit groups found in the concrete syntax above.
+    /// let expected = vec![None, None, Some("foo"), None, None, Some("bar")];
+    /// let got: Vec<Option<&str>> =
+    ///     nfa.group_info().pattern_names(PatternID::ZERO).collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// // Using an invalid pattern ID will result in nothing yielded.
+    /// let got = nfa.group_info().pattern_names(PatternID::must(999)).count();
+    /// assert_eq!(0, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn pattern_names(&self, pid: PatternID) -> GroupInfoPatternNames<'_> {
+        GroupInfoPatternNames {
+            it: self
+                .0
+                .index_to_name
+                .get(pid.as_usize())
+                .map(|indices| indices.iter())
+                .unwrap_or([].iter()),
+        }
+    }
+
+    /// Return an iterator of all capture groups for all patterns supported by
+    /// this `GroupInfo`. Each item yielded is a triple of the group's pattern
+    /// ID, index in the pattern and the group's name, if present.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to get a list of all capture groups found in
+    /// one NFA, potentially spanning multiple patterns.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new_many(&[
+    ///     r"(?P<foo>a)",
+    ///     r"a",
+    ///     r"(a)",
+    /// ])?;
+    /// let expected = vec![
+    ///     (PatternID::must(0), 0, None),
+    ///     (PatternID::must(0), 1, Some("foo")),
+    ///     (PatternID::must(1), 0, None),
+    ///     (PatternID::must(2), 0, None),
+    ///     (PatternID::must(2), 1, None),
+    /// ];
+    /// let got: Vec<(PatternID, usize, Option<&str>)> =
+    ///     nfa.group_info().all_names().collect();
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Unlike other capturing group related routines, this routine doesn't
+    /// panic even if captures aren't enabled on this NFA:
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build_many(&[
+    ///         r"(?P<foo>a)",
+    ///         r"a",
+    ///         r"(a)",
+    ///     ])?;
+    /// // When captures aren't enabled, there's nothing to return.
+    /// assert_eq!(0, nfa.group_info().all_names().count());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn all_names(&self) -> GroupInfoAllNames<'_> {
+        GroupInfoAllNames {
+            group_info: self,
+            pids: PatternID::iter(self.pattern_len()),
+            current_pid: None,
+            names: None,
+        }
+    }
+
+    /// Returns the starting and ending slot corresponding to the given
+    /// capturing group for the given pattern. The ending slot is always one
+    /// more than the starting slot returned.
+    ///
+    /// Note that this is like [`GroupInfo::slot`], except that it also returns
+    /// the ending slot value for convenience.
+    ///
+    /// If either the pattern ID or the capture index is invalid, then this
+    /// returns None.
+    ///
+    /// # Example
+    ///
+    /// This example shows that the starting slots for the first capturing
+    /// group of each pattern are distinct.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new_many(&["a", "b"])?;
+    /// assert_ne!(
+    ///     nfa.group_info().slots(PatternID::must(0), 0),
+    ///     nfa.group_info().slots(PatternID::must(1), 0),
+    /// );
+    ///
+    /// // Also, the start and end slot values are never equivalent.
+    /// let (start, end) = nfa.group_info().slots(PatternID::ZERO, 0).unwrap();
+    /// assert_ne!(start, end);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn slots(
+        &self,
+        pid: PatternID,
+        group_index: usize,
+    ) -> Option<(usize, usize)> {
+        // Since 'slot' only even returns valid starting slots, we know that
+        // there must also be an end slot and that end slot is always one more
+        // than the start slot.
+        self.slot(pid, group_index).map(|start| (start, start + 1))
+    }
+
+    /// Returns the starting slot corresponding to the given capturing group
+    /// for the given pattern. The ending slot is always one more than the
+    /// value returned.
+    ///
+    /// If either the pattern ID or the capture index is invalid, then this
+    /// returns None.
+    ///
+    /// # Example
+    ///
+    /// This example shows that the starting slots for the first capturing
+    /// group of each pattern are distinct.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new_many(&["a", "b"])?;
+    /// assert_ne!(
+    ///     nfa.group_info().slot(PatternID::must(0), 0),
+    ///     nfa.group_info().slot(PatternID::must(1), 0),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn slot(&self, pid: PatternID, group_index: usize) -> Option<usize> {
+        if group_index >= self.group_len(pid) {
+            return None;
+        }
+        // At this point, we know that 'pid' refers to a real pattern and that
+        // 'group_index' refers to a real group. We therefore also know that
+        // the pattern and group can be combined to return a correct slot.
+        // That's why we don't need to use checked arithmetic below.
+        if group_index == 0 {
+            Some(pid.as_usize() * 2)
+        } else {
+            // As above, we don't need to check that our slot is less than the
+            // end of our range since we already know the group index is a
+            // valid index for the given pattern.
+            let (start, _) = self.0.slot_ranges[pid];
+            Some(start.as_usize() + ((group_index - 1) * 2))
+        }
+    }
+
+    /// Returns the total number of patterns in this `GroupInfo`.
+    ///
+    /// This may return zero if the `GroupInfo` was constructed with no
+    /// patterns.
+    ///
+    /// This is guaranteed to be no bigger than [`PatternID::LIMIT`] because
+    /// `GroupInfo` construction will fail if too many patterns are added.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::nfa::thompson::NFA;
+    ///
+    /// let nfa = NFA::new_many(&["[0-9]+", "[a-z]+", "[A-Z]+"])?;
+    /// assert_eq!(3, nfa.group_info().pattern_len());
+    ///
+    /// let nfa = NFA::never_match();
+    /// assert_eq!(0, nfa.group_info().pattern_len());
+    ///
+    /// let nfa = NFA::always_match();
+    /// assert_eq!(1, nfa.group_info().pattern_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn pattern_len(&self) -> usize {
+        self.0.pattern_len()
+    }
+
+    /// Return the number of capture groups in a pattern.
+    ///
+    /// If the pattern ID is invalid, then this returns `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows how the values returned by this routine may vary
+    /// for different patterns and NFA configurations.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new(r"(a)(b)(c)")?;
+    /// // There are 3 explicit groups in the pattern's concrete syntax and
+    /// // 1 unnamed and implicit group spanning the entire pattern.
+    /// assert_eq!(4, nfa.group_info().group_len(PatternID::ZERO));
+    ///
+    /// let nfa = NFA::new(r"abc")?;
+    /// // There is just the unnamed implicit group.
+    /// assert_eq!(1, nfa.group_info().group_len(PatternID::ZERO));
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build(r"abc")?;
+    /// // We disabled capturing groups, so there are none.
+    /// assert_eq!(0, nfa.group_info().group_len(PatternID::ZERO));
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build(r"(a)(b)(c)")?;
+    /// // We disabled capturing groups, so there are none, even if there are
+    /// // explicit groups in the concrete syntax.
+    /// assert_eq!(0, nfa.group_info().group_len(PatternID::ZERO));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn group_len(&self, pid: PatternID) -> usize {
+        self.0.group_len(pid)
+    }
+
+    /// Return the total number of capture groups across all patterns.
+    ///
+    /// This includes implicit groups that represent the entire match of a
+    /// pattern.
+    ///
+    /// # Example
+    ///
+    /// This example shows how the values returned by this routine may vary
+    /// for different patterns and NFA configurations.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::NFA, PatternID};
+    ///
+    /// let nfa = NFA::new(r"(a)(b)(c)")?;
+    /// // There are 3 explicit groups in the pattern's concrete syntax and
+    /// // 1 unnamed and implicit group spanning the entire pattern.
+    /// assert_eq!(4, nfa.group_info().all_group_len());
+    ///
+    /// let nfa = NFA::new(r"abc")?;
+    /// // There is just the unnamed implicit group.
+    /// assert_eq!(1, nfa.group_info().all_group_len());
+    ///
+    /// let nfa = NFA::new_many(&["(a)", "b", "(c)"])?;
+    /// // Each pattern has one implicit groups, and two
+    /// // patterns have one explicit group each.
+    /// assert_eq!(5, nfa.group_info().all_group_len());
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build(r"abc")?;
+    /// // We disabled capturing groups, so there are none.
+    /// assert_eq!(0, nfa.group_info().all_group_len());
+    ///
+    /// let nfa = NFA::compiler()
+    ///     .configure(NFA::config().captures(false))
+    ///     .build(r"(a)(b)(c)")?;
+    /// // We disabled capturing groups, so there are none, even if there are
+    /// // explicit groups in the concrete syntax.
+    /// assert_eq!(0, nfa.group_info().group_len(PatternID::ZERO));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn all_group_len(&self) -> usize {
+        self.slot_len() / 2
+    }
+
+    /// Returns the total number of slots in this `GroupInfo` across all
+    /// patterns.
+    ///
+    /// The total number of slots is always twice the total number of capturing
+    /// groups, including both implicit and explicit groups.
+    ///
+    /// # Example
+    ///
+    /// This example shows the relationship between the number of capturing
+    /// groups and slots.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// // There are 11 total groups here.
+    /// let info = GroupInfo::new(vec![
+    ///     vec![None, Some("foo")],
+    ///     vec![None],
+    ///     vec![None, None, None, Some("bar"), None],
+    ///     vec![None, None, Some("foo")],
+    /// ])?;
+    /// // 2 slots per group gives us 11*2=22 slots.
+    /// assert_eq!(22, info.slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn slot_len(&self) -> usize {
+        self.0.small_slot_len().as_usize()
+    }
+
+    /// Returns the total number of slots for implicit capturing groups.
+    ///
+    /// This is like [`GroupInfo::slot_len`], except it doesn't include the
+    /// explicit slots for each pattern. Since there are always exactly 2
+    /// implicit slots for each pattern, the number of implicit slots is always
+    /// equal to twice the number of patterns.
+    ///
+    /// # Example
+    ///
+    /// This example shows the relationship between the number of capturing
+    /// groups, implicit slots and explicit slots.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// // There are 11 total groups here.
+    /// let info = GroupInfo::new(vec![vec![None, Some("foo"), Some("bar")]])?;
+    /// // 2 slots per group gives us 11*2=22 slots.
+    /// assert_eq!(6, info.slot_len());
+    /// // 2 implicit slots per pattern gives us 2 implicit slots since there
+    /// // is 1 pattern.
+    /// assert_eq!(2, info.implicit_slot_len());
+    /// // 2 explicit capturing groups gives us 2*2=4 explicit slots.
+    /// assert_eq!(4, info.explicit_slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn implicit_slot_len(&self) -> usize {
+        self.pattern_len() * 2
+    }
+
+    /// Returns the total number of slots for explicit capturing groups.
+    ///
+    /// This is like [`GroupInfo::slot_len`], except it doesn't include the
+    /// implicit slots for each pattern. (There are always 2 implicit slots for
+    /// each pattern.)
+    ///
+    /// For a non-empty `GroupInfo`, it is always the case that `slot_len` is
+    /// strictly greater than `explicit_slot_len`. For an empty `GroupInfo`,
+    /// both the total number of slots and the number of explicit slots is
+    /// `0`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the relationship between the number of capturing
+    /// groups, implicit slots and explicit slots.
+    ///
+    /// ```
+    /// use regex_automata::util::captures::GroupInfo;
+    ///
+    /// // There are 11 total groups here.
+    /// let info = GroupInfo::new(vec![vec![None, Some("foo"), Some("bar")]])?;
+    /// // 2 slots per group gives us 11*2=22 slots.
+    /// assert_eq!(6, info.slot_len());
+    /// // 2 implicit slots per pattern gives us 2 implicit slots since there
+    /// // is 1 pattern.
+    /// assert_eq!(2, info.implicit_slot_len());
+    /// // 2 explicit capturing groups gives us 2*2=4 explicit slots.
+    /// assert_eq!(4, info.explicit_slot_len());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn explicit_slot_len(&self) -> usize {
+        self.slot_len().saturating_sub(self.implicit_slot_len())
+    }
+
+    /// Returns the memory usage, in bytes, of this `GroupInfo`.
+    ///
+    /// This does **not** include the stack size used up by this `GroupInfo`.
+    /// To compute that, use `std::mem::size_of::<GroupInfo>()`.
+    #[inline]
+    pub fn memory_usage(&self) -> usize {
+        use core::mem::size_of as s;
+
+        s::<GroupInfoInner>()
+            + self.0.slot_ranges.len() * s::<(SmallIndex, SmallIndex)>()
+            + self.0.name_to_index.len() * s::<CaptureNameMap>()
+            + self.0.index_to_name.len() * s::<Vec<Option<Arc<str>>>>()
+            + self.0.memory_extra
+    }
+}
+
+/// A map from capture group name to its corresponding capture group index.
+///
+/// This type is actually wrapped inside a Vec indexed by pattern ID on a
+/// `GroupInfo`, since multiple patterns may have the same capture group name.
+/// That is, each pattern gets its own namespace of capture group names.
+///
+/// Perhaps a more memory efficient representation would be
+/// HashMap<(PatternID, Arc<str>), usize>, but this makes it difficult to look
+/// up a capture index by name without producing a `Arc<str>`, which requires
+/// an allocation. To fix this, I think we'd need to define our own unsized
+/// type or something? Anyway, I didn't give this much thought since it
+/// probably doesn't matter much in the grand scheme of things. But it did
+/// stand out to me as mildly wasteful.
+#[cfg(feature = "std")]
+type CaptureNameMap = std::collections::HashMap<Arc<str>, SmallIndex>;
+#[cfg(not(feature = "std"))]
+type CaptureNameMap = alloc::collections::BTreeMap<Arc<str>, SmallIndex>;
+
+/// The inner guts of `GroupInfo`. This type only exists so that it can
+/// be wrapped in an `Arc` to make `GroupInfo` reference counted.
+#[derive(Debug, Default)]
+struct GroupInfoInner {
+    slot_ranges: Vec<(SmallIndex, SmallIndex)>,
+    name_to_index: Vec<CaptureNameMap>,
+    index_to_name: Vec<Vec<Option<Arc<str>>>>,
+    memory_extra: usize,
+}
+
+impl GroupInfoInner {
+    /// This adds the first unnamed group for the given pattern ID. The given
+    /// pattern ID must be zero if this is the first time this method is
+    /// called, or must be exactly one more than the pattern ID supplied to the
+    /// previous call to this method. (This method panics if this rule is
+    /// violated.)
+    ///
+    /// This can be thought of as initializing the GroupInfo state for the
+    /// given pattern and closing off the state for any previous pattern.
+    fn add_first_group(&mut self, pid: PatternID) {
+        assert_eq!(pid.as_usize(), self.slot_ranges.len());
+        assert_eq!(pid.as_usize(), self.name_to_index.len());
+        assert_eq!(pid.as_usize(), self.index_to_name.len());
+        // This is the start of our slots for the explicit capturing groups.
+        // Note that since the slots for the 0th group for every pattern appear
+        // before any slots for the nth group (where n > 0) in any pattern, we
+        // will have to fix up the slot ranges once we know how many patterns
+        // we've added capture groups for.
+        let slot_start = self.small_slot_len();
+        self.slot_ranges.push((slot_start, slot_start));
+        self.name_to_index.push(CaptureNameMap::new());
+        self.index_to_name.push(vec![None]);
+        self.memory_extra += core::mem::size_of::<Option<Arc<str>>>();
+    }
+
+    /// Add an explicit capturing group for the given pattern with the given
+    /// index. If the group has a name, then that must be given as well.
+    ///
+    /// Note that every capturing group except for the first or zeroth group is
+    /// explicit.
+    ///
+    /// This returns an error if adding this group would result in overflowing
+    /// slot indices or if a capturing group with the same name for this
+    /// pattern has already been added.
+    fn add_explicit_group<N: AsRef<str>>(
+        &mut self,
+        pid: PatternID,
+        group: SmallIndex,
+        maybe_name: Option<N>,
+    ) -> Result<(), GroupInfoError> {
+        // We also need to check that the slot index generated for
+        // this group is also valid. Although, this is a little weird
+        // because we offset these indices below, at which point, we'll
+        // have to recheck them. Gosh this is annoying. Note that
+        // the '+2' below is OK because 'end' is guaranteed to be less
+        // than isize::MAX.
+        let end = &mut self.slot_ranges[pid].1;
+        *end = SmallIndex::new(end.as_usize() + 2).map_err(|_| {
+            GroupInfoError::too_many_groups(pid, group.as_usize())
+        })?;
+        if let Some(name) = maybe_name {
+            let name = Arc::<str>::from(name.as_ref());
+            if self.name_to_index[pid].contains_key(&*name) {
+                return Err(GroupInfoError::duplicate(pid, &name));
+            }
+            let len = name.len();
+            self.name_to_index[pid].insert(Arc::clone(&name), group);
+            self.index_to_name[pid].push(Some(name));
+            // Adds the memory used by the Arc<str> in both maps.
+            self.memory_extra +=
+                2 * (len + core::mem::size_of::<Option<Arc<str>>>());
+            // And also the value entry for the 'name_to_index' map.
+            // This is probably an underestimate for 'name_to_index' since
+            // hashmaps/btrees likely have some non-zero overhead, but we
+            // assume here that they have zero overhead.
+            self.memory_extra += core::mem::size_of::<SmallIndex>();
+        } else {
+            self.index_to_name[pid].push(None);
+            self.memory_extra += core::mem::size_of::<Option<Arc<str>>>();
+        }
+        // This is a sanity assert that checks that our group index
+        // is in line with the number of groups added so far for this
+        // pattern.
+        assert_eq!(group.one_more(), self.group_len(pid));
+        // And is also in line with the 'index_to_name' map.
+        assert_eq!(group.one_more(), self.index_to_name[pid].len());
+        Ok(())
+    }
+
+    /// This corrects the slot ranges to account for the slots corresponding
+    /// to the zeroth group of each pattern. That is, every slot range is
+    /// offset by 'pattern_len() * 2', since each pattern uses two slots to
+    /// represent the zeroth group.
+    fn fixup_slot_ranges(&mut self) -> Result<(), GroupInfoError> {
+        use crate::util::primitives::IteratorIndexExt;
+        // Since we know number of patterns fits in PatternID and
+        // PatternID::MAX < isize::MAX, it follows that multiplying by 2 will
+        // never overflow usize.
+        let offset = self.pattern_len().checked_mul(2).unwrap();
+        for (pid, &mut (ref mut start, ref mut end)) in
+            self.slot_ranges.iter_mut().with_pattern_ids()
+        {
+            let group_len = 1 + ((end.as_usize() - start.as_usize()) / 2);
+            let new_end = match end.as_usize().checked_add(offset) {
+                Some(new_end) => new_end,
+                None => {
+                    return Err(GroupInfoError::too_many_groups(
+                        pid, group_len,
+                    ))
+                }
+            };
+            *end = SmallIndex::new(new_end).map_err(|_| {
+                GroupInfoError::too_many_groups(pid, group_len)
+            })?;
+            // Since start <= end, if end is valid then start must be too.
+            *start = SmallIndex::new(start.as_usize() + offset).unwrap();
+        }
+        Ok(())
+    }
+
+    /// Return the total number of patterns represented by this capture slot
+    /// info.
+    fn pattern_len(&self) -> usize {
+        self.slot_ranges.len()
+    }
+
+    /// Return the total number of capturing groups for the given pattern. If
+    /// the given pattern isn't valid for this capture slot info, then 0 is
+    /// returned.
+    fn group_len(&self, pid: PatternID) -> usize {
+        let (start, end) = match self.slot_ranges.get(pid.as_usize()) {
+            None => return 0,
+            Some(range) => range,
+        };
+        // The difference between any two SmallIndex values always fits in a
+        // usize since we know that SmallIndex::MAX <= isize::MAX-1. We also
+        // know that start<=end by construction and that the number of groups
+        // never exceeds SmallIndex and thus never overflows usize.
+        1 + ((end.as_usize() - start.as_usize()) / 2)
+    }
+
+    /// Return the total number of slots in this capture slot info as a
+    /// "small index."
+    fn small_slot_len(&self) -> SmallIndex {
+        // Since slots are allocated in order of pattern (starting at 0) and
+        // then in order of capture group, it follows that the number of slots
+        // is the end of the range of slots for the last pattern. This is
+        // true even when the last pattern has no capturing groups, since
+        // 'slot_ranges' will still represent it explicitly with an empty
+        // range.
+        self.slot_ranges.last().map_or(SmallIndex::ZERO, |&(_, end)| end)
+    }
+}
+
+/// An error that may occur when building a `GroupInfo`.
+///
+/// Building a `GroupInfo` does a variety of checks to make sure the
+/// capturing groups satisfy a number of invariants. This includes, but is not
+/// limited to, ensuring that the first capturing group is unnamed and that
+/// there are no duplicate capture groups for a specific pattern.
+#[derive(Clone, Debug)]
+pub struct GroupInfoError {
+    kind: GroupInfoErrorKind,
+}
+
+/// The kind of error that occurs when building a `GroupInfo` fails.
+///
+/// We keep this un-exported because it's not clear how useful it is to
+/// export it.
+#[derive(Clone, Debug)]
+enum GroupInfoErrorKind {
+    /// This occurs when too many patterns have been added. i.e., It would
+    /// otherwise overflow a `PatternID`.
+    TooManyPatterns { err: PatternIDError },
+    /// This occurs when too many capturing groups have been added for a
+    /// particular pattern.
+    TooManyGroups {
+        /// The ID of the pattern that had too many groups.
+        pattern: PatternID,
+        /// The minimum number of groups that the caller has tried to add for
+        /// a pattern.
+        minimum: usize,
+    },
+    /// An error that occurs when a pattern has no capture groups. Either the
+    /// group info must be empty, or all patterns must have at least one group
+    /// (corresponding to the unnamed group for the entire pattern).
+    MissingGroups {
+        /// The ID of the pattern that had no capturing groups.
+        pattern: PatternID,
+    },
+    /// An error that occurs when one tries to provide a name for the capture
+    /// group at index 0. This capturing group must currently always be
+    /// unnamed.
+    FirstMustBeUnnamed {
+        /// The ID of the pattern that was found to have a named first
+        /// capturing group.
+        pattern: PatternID,
+    },
+    /// An error that occurs when duplicate capture group names for the same
+    /// pattern are added.
+    ///
+    /// NOTE: At time of writing, this error can never occur if you're using
+    /// regex-syntax, since the parser itself will reject patterns with
+    /// duplicate capture group names. This error can only occur when the
+    /// builder is used to hand construct NFAs.
+    Duplicate {
+        /// The pattern in which the duplicate capture group name was found.
+        pattern: PatternID,
+        /// The duplicate name.
+        name: String,
+    },
+}
+
+impl GroupInfoError {
+    fn too_many_patterns(err: PatternIDError) -> GroupInfoError {
+        GroupInfoError { kind: GroupInfoErrorKind::TooManyPatterns { err } }
+    }
+
+    fn too_many_groups(pattern: PatternID, minimum: usize) -> GroupInfoError {
+        GroupInfoError {
+            kind: GroupInfoErrorKind::TooManyGroups { pattern, minimum },
+        }
+    }
+
+    fn missing_groups(pattern: PatternID) -> GroupInfoError {
+        GroupInfoError { kind: GroupInfoErrorKind::MissingGroups { pattern } }
+    }
+
+    fn first_must_be_unnamed(pattern: PatternID) -> GroupInfoError {
+        GroupInfoError {
+            kind: GroupInfoErrorKind::FirstMustBeUnnamed { pattern },
+        }
+    }
+
+    fn duplicate(pattern: PatternID, name: &str) -> GroupInfoError {
+        GroupInfoError {
+            kind: GroupInfoErrorKind::Duplicate {
+                pattern,
+                name: String::from(name),
+            },
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for GroupInfoError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind {
+            GroupInfoErrorKind::TooManyPatterns { .. }
+            | GroupInfoErrorKind::TooManyGroups { .. }
+            | GroupInfoErrorKind::MissingGroups { .. }
+            | GroupInfoErrorKind::FirstMustBeUnnamed { .. }
+            | GroupInfoErrorKind::Duplicate { .. } => None,
+        }
+    }
+}
+
+impl core::fmt::Display for GroupInfoError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use self::GroupInfoErrorKind::*;
+
+        match self.kind {
+            TooManyPatterns { ref err } => {
+                write!(f, "too many patterns to build capture info: {}", err)
+            }
+            TooManyGroups { pattern, minimum } => {
+                write!(
+                    f,
+                    "too many capture groups (at least {}) were \
+                     found for pattern {}",
+                    minimum,
+                    pattern.as_usize()
+                )
+            }
+            MissingGroups { pattern } => write!(
+                f,
+                "no capturing groups found for pattern {} \
+                 (either all patterns have zero groups or all patterns have \
+                  at least one group)",
+                pattern.as_usize(),
+            ),
+            FirstMustBeUnnamed { pattern } => write!(
+                f,
+                "first capture group (at index 0) for pattern {} has a name \
+                 (it must be unnamed)",
+                pattern.as_usize(),
+            ),
+            Duplicate { pattern, ref name } => write!(
+                f,
+                "duplicate capture group name '{}' found for pattern {}",
+                name,
+                pattern.as_usize(),
+            ),
+        }
+    }
+}
+
+/// An iterator over capturing groups and their names for a specific pattern.
+///
+/// This iterator is created by [`GroupInfo::pattern_names`].
+///
+/// The lifetime parameter `'a` refers to the lifetime of the `GroupInfo`
+/// from which this iterator was created.
+#[derive(Clone, Debug)]
+pub struct GroupInfoPatternNames<'a> {
+    it: core::slice::Iter<'a, Option<Arc<str>>>,
+}
+
+impl GroupInfoPatternNames<'static> {
+    fn empty() -> GroupInfoPatternNames<'static> {
+        GroupInfoPatternNames { it: [].iter() }
+    }
+}
+
+impl<'a> Iterator for GroupInfoPatternNames<'a> {
+    type Item = Option<&'a str>;
+
+    fn next(&mut self) -> Option<Option<&'a str>> {
+        self.it.next().map(|x| x.as_deref())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupInfoPatternNames<'a> {}
+impl<'a> core::iter::FusedIterator for GroupInfoPatternNames<'a> {}
+
+/// An iterator over capturing groups and their names for a `GroupInfo`.
+///
+/// This iterator is created by [`GroupInfo::all_names`].
+///
+/// The lifetime parameter `'a` refers to the lifetime of the `GroupInfo`
+/// from which this iterator was created.
+#[derive(Debug)]
+pub struct GroupInfoAllNames<'a> {
+    group_info: &'a GroupInfo,
+    pids: PatternIDIter,
+    current_pid: Option<PatternID>,
+    names: Option<core::iter::Enumerate<GroupInfoPatternNames<'a>>>,
+}
+
+impl<'a> Iterator for GroupInfoAllNames<'a> {
+    type Item = (PatternID, usize, Option<&'a str>);
+
+    fn next(&mut self) -> Option<(PatternID, usize, Option<&'a str>)> {
+        // If the group info has no captures, then we never have anything
+        // to yield. We need to consider this case explicitly (at time of
+        // writing) because 'pattern_capture_names' will panic if captures
+        // aren't enabled.
+        if self.group_info.0.index_to_name.is_empty() {
+            return None;
+        }
+        if self.current_pid.is_none() {
+            self.current_pid = Some(self.pids.next()?);
+        }
+        let pid = self.current_pid.unwrap();
+        if self.names.is_none() {
+            self.names = Some(self.group_info.pattern_names(pid).enumerate());
+        }
+        let (group_index, name) = match self.names.as_mut().unwrap().next() {
+            Some((group_index, name)) => (group_index, name),
+            None => {
+                self.current_pid = None;
+                self.names = None;
+                return self.next();
+            }
+        };
+        Some((pid, group_index, name))
+    }
+}
diff --git a/regex-automata/src/util/determinize/mod.rs b/regex-automata/src/util/determinize/mod.rs
new file mode 100644
index 0000000000..14aa9a8c3a
--- /dev/null
+++ b/regex-automata/src/util/determinize/mod.rs
@@ -0,0 +1,610 @@
+/*!
+This module contains types and routines for implementing determinization.
+
+In this crate, there are at least two places where we implement
+determinization: fully ahead-of-time compiled DFAs in the `dfa` module and
+lazily compiled DFAs in the `hybrid` module. The stuff in this module
+corresponds to the things that are in common between these implementations.
+
+There are three broad things that our implementations of determinization have
+in common, as defined by this module:
+
+* The classification of start states. That is, whether we're dealing with
+word boundaries, line boundaries, etc., is all the same. This also includes
+the look-behind assertions that are satisfied by each starting state
+classification.
+* The representation of DFA states as sets of NFA states, including
+convenience types for building these DFA states that are amenable to reusing
+allocations.
+* Routines for the "classical" parts of determinization: computing the
+epsilon closure, tracking match states (with corresponding pattern IDs, since
+we support multi-pattern finite automata) and, of course, computing the
+transition function between states for units of input.
+
+I did consider a couple of alternatives to this particular form of code reuse:
+
+1. Don't do any code reuse. The problem here is that we *really* want both
+forms of determinization to do exactly identical things when it comes to
+their handling of NFA states. While our tests generally ensure this, the code
+is tricky and large enough where not reusing code is a pretty big bummer.
+
+2. Implement all of determinization once and make it generic over fully
+compiled DFAs and lazily compiled DFAs. While I didn't actually try this
+approach, my instinct is that it would be more complex than is needed here.
+And the interface required would be pretty hairy. Instead, I think splitting
+it into logical sub-components works better.
+*/
+
+use alloc::vec::Vec;
+
+pub(crate) use self::state::{
+    State, StateBuilderEmpty, StateBuilderMatches, StateBuilderNFA,
+};
+
+use crate::{
+    nfa::thompson,
+    util::{
+        alphabet,
+        look::{Look, LookSet},
+        primitives::StateID,
+        search::MatchKind,
+        sparse_set::{SparseSet, SparseSets},
+        start::Start,
+        utf8,
+    },
+};
+
+mod state;
+
+/// Compute the set of all reachable NFA states, including the full epsilon
+/// closure, from a DFA state for a single unit of input. The set of reachable
+/// states is returned as a `StateBuilderNFA`. The `StateBuilderNFA` returned
+/// also includes any look-behind assertions satisfied by `unit`, in addition
+/// to whether it is a match state. For multi-pattern DFAs, the builder will
+/// also include the pattern IDs that match (in the order seen).
+///
+/// `nfa` must be able to resolve any NFA state in `state` and any NFA state
+/// reachable via the epsilon closure of any NFA state in `state`. `sparses`
+/// must have capacity equivalent to `nfa.len()`.
+///
+/// `match_kind` should correspond to the match semantics implemented by the
+/// DFA being built. Generally speaking, for leftmost-first match semantics,
+/// states that appear after the first NFA match state will not be included in
+/// the `StateBuilderNFA` returned since they are impossible to visit.
+///
+/// `sparses` is used as scratch space for NFA traversal. Other than their
+/// capacity requirements (detailed above), there are no requirements on what's
+/// contained within them (if anything). Similarly, what's inside of them once
+/// this routine returns is unspecified.
+///
+/// `stack` must have length 0. It is used as scratch space for depth first
+/// traversal. After returning, it is guaranteed that `stack` will have length
+/// 0.
+///
+/// `state` corresponds to the current DFA state on which one wants to compute
+/// the transition for the input `unit`.
+///
+/// `empty_builder` corresponds to the builder allocation to use to produce a
+/// complete `StateBuilderNFA` state. If the state is not needed (or is already
+/// cached), then it can be cleared and reused without needing to create a new
+/// `State`. The `StateBuilderNFA` state returned is final and ready to be
+/// turned into a `State` if necessary.
+pub(crate) fn next(
+    nfa: &thompson::NFA,
+    match_kind: MatchKind,
+    sparses: &mut SparseSets,
+    stack: &mut Vec<StateID>,
+    state: &State,
+    unit: alphabet::Unit,
+    empty_builder: StateBuilderEmpty,
+) -> StateBuilderNFA {
+    sparses.clear();
+
+    // Whether the NFA is matched in reverse or not. We use this in some
+    // conditional logic for dealing with the exceptionally annoying CRLF-aware
+    // line anchors.
+    let rev = nfa.is_reverse();
+    // The look-around matcher that our NFA is configured with. We don't
+    // actually use it to match look-around assertions, but we do need its
+    // configuration for constructing states consistent with how it matches.
+    let lookm = nfa.look_matcher();
+
+    // Put the NFA state IDs into a sparse set in case we need to
+    // re-compute their epsilon closure.
+    //
+    // Doing this state shuffling is technically not necessary unless some
+    // kind of look-around is used in the DFA. Some ad hoc experiments
+    // suggested that avoiding this didn't lead to much of an improvement,
+    // but perhaps more rigorous experimentation should be done. And in
+    // particular, avoiding this check requires some light refactoring of
+    // the code below.
+    state.iter_nfa_state_ids(|nfa_id| {
+        sparses.set1.insert(nfa_id);
+    });
+
+    // Compute look-ahead assertions originating from the current state. Based
+    // on the input unit we're transitioning over, some additional set of
+    // assertions may be true. Thus, we re-compute this state's epsilon closure
+    // (but only if necessary). Notably, when we build a DFA state initially,
+    // we don't enable any look-ahead assertions because we don't know whether
+    // they're true or not at that point.
+    if !state.look_need().is_empty() {
+        // Add look-ahead assertions that are now true based on the current
+        // input unit.
+        let mut look_have = state.look_have().clone();
+        match unit.as_u8() {
+            Some(b'\r') => {
+                if !rev || !state.is_half_crlf() {
+                    look_have = look_have.insert(Look::EndCRLF);
+                }
+            }
+            Some(b'\n') => {
+                if rev || !state.is_half_crlf() {
+                    look_have = look_have.insert(Look::EndCRLF);
+                }
+            }
+            Some(_) => {}
+            None => {
+                look_have = look_have.insert(Look::End);
+                look_have = look_have.insert(Look::EndLF);
+                look_have = look_have.insert(Look::EndCRLF);
+            }
+        }
+        if unit.is_byte(lookm.get_line_terminator()) {
+            look_have = look_have.insert(Look::EndLF);
+        }
+        if state.is_half_crlf()
+            && ((rev && !unit.is_byte(b'\r'))
+                || (!rev && !unit.is_byte(b'\n')))
+        {
+            look_have = look_have.insert(Look::StartCRLF);
+        }
+        if state.is_from_word() == unit.is_word_byte() {
+            look_have = look_have.insert(Look::WordUnicodeNegate);
+            look_have = look_have.insert(Look::WordAsciiNegate);
+        } else {
+            look_have = look_have.insert(Look::WordUnicode);
+            look_have = look_have.insert(Look::WordAscii);
+        }
+        // If we have new assertions satisfied that are among the set of
+        // assertions that exist in this state (that is, just because we added
+        // an EndLF assertion above doesn't mean there is an EndLF conditional
+        // epsilon transition in this state), then we re-compute this state's
+        // epsilon closure using the updated set of assertions.
+        //
+        // Note that since our DFA states omit unconditional epsilon
+        // transitions, this check is necessary for correctness. If we re-did
+        // the epsilon closure below needlessly, it could change based on the
+        // fact that we omitted epsilon states originally.
+        if !look_have
+            .subtract(state.look_have())
+            .intersect(state.look_need())
+            .is_empty()
+        {
+            for nfa_id in sparses.set1.iter() {
+                epsilon_closure(
+                    nfa,
+                    nfa_id,
+                    look_have,
+                    stack,
+                    &mut sparses.set2,
+                );
+            }
+            sparses.swap();
+            sparses.set2.clear();
+        }
+    }
+
+    // Convert our empty builder into one that can record assertions and match
+    // pattern IDs.
+    let mut builder = empty_builder.into_matches();
+    // Set whether the StartLF look-behind assertion is true for this
+    // transition or not. The look-behind assertion for ASCII word boundaries
+    // is handled below.
+    if nfa.look_set_any().contains_anchor_line()
+        && unit.is_byte(lookm.get_line_terminator())
+    {
+        // Why only handle StartLF here and not Start? That's because Start
+        // can only impact the starting state, which is speical cased in
+        // start state handling.
+        builder.set_look_have(|have| have.insert(Look::StartLF));
+    }
+    // We also need to add StartCRLF to our assertions too, if we can. This
+    // is unfortunately a bit more complicated, because it depends on the
+    // direction of the search. In the forward direction, ^ matches after a
+    // \n, but in the reverse direction, ^ only matches after a \r. (This is
+    // further complicated by the fact that reverse a regex means changing a ^
+    // to a $ and vice versa.)
+    if nfa.look_set_any().contains_anchor_crlf()
+        && ((rev && unit.is_byte(b'\r')) || (!rev && unit.is_byte(b'\n')))
+    {
+        builder.set_look_have(|have| have.insert(Look::StartCRLF));
+    }
+    for nfa_id in sparses.set1.iter() {
+        match *nfa.state(nfa_id) {
+            thompson::State::Union { .. }
+            | thompson::State::BinaryUnion { .. }
+            | thompson::State::Fail
+            | thompson::State::Look { .. }
+            | thompson::State::Capture { .. } => {}
+            thompson::State::Match { pattern_id } => {
+                // Notice here that we are calling the NEW state a match
+                // state if the OLD state we are transitioning from
+                // contains an NFA match state. This is precisely how we
+                // delay all matches by one byte and also what therefore
+                // guarantees that starting states cannot be match states.
+                //
+                // If we didn't delay matches by one byte, then whether
+                // a DFA is a matching state or not would be determined
+                // by whether one of its own constituent NFA states
+                // was a match state. (And that would be done in
+                // 'add_nfa_states'.)
+                //
+                // Also, 'add_match_pattern_id' requires that callers never
+                // pass duplicative pattern IDs. We do in fact uphold that
+                // guarantee here, but it's subtle. In particular, a Thompson
+                // NFA guarantees that each pattern has exactly one match
+                // state. Moreover, since we're iterating over the NFA state
+                // IDs in a set, we are guarateed not to have any duplicative
+                // match states. Thus, it is impossible to add the same pattern
+                // ID more than once.
+                //
+                // N.B. We delay matches by 1 byte as a way to hack 1-byte
+                // look-around into DFA searches. This lets us support ^, $
+                // and ASCII-only \b. The delay is also why we need a special
+                // "end-of-input" (EOI) sentinel and why we need to follow the
+                // EOI sentinel at the end of every search. This final EOI
+                // transition is necessary to report matches found at the end
+                // of a haystack.
+                builder.add_match_pattern_id(pattern_id);
+                if !match_kind.continue_past_first_match() {
+                    break;
+                }
+            }
+            thompson::State::ByteRange { ref trans } => {
+                if trans.matches_unit(unit) {
+                    epsilon_closure(
+                        nfa,
+                        trans.next,
+                        builder.look_have(),
+                        stack,
+                        &mut sparses.set2,
+                    );
+                }
+            }
+            thompson::State::Sparse(ref sparse) => {
+                if let Some(next) = sparse.matches_unit(unit) {
+                    epsilon_closure(
+                        nfa,
+                        next,
+                        builder.look_have(),
+                        stack,
+                        &mut sparses.set2,
+                    );
+                }
+            }
+            thompson::State::Dense(ref dense) => {
+                if let Some(next) = dense.matches_unit(unit) {
+                    epsilon_closure(
+                        nfa,
+                        next,
+                        builder.look_have(),
+                        stack,
+                        &mut sparses.set2,
+                    );
+                }
+            }
+        }
+    }
+    // We only set the word byte if there's a word boundary look-around
+    // anywhere in this regex. Otherwise, there's no point in bloating the
+    // number of states if we don't have one.
+    //
+    // We also only set it when the state has a non-zero number of NFA states.
+    // Otherwise, we could wind up with states that *should* be DEAD states
+    // but are otherwise distinct from DEAD states because of this look-behind
+    // assertion being set. While this can't technically impact correctness *in
+    // theory*, it can create pathological DFAs that consume input until EOI or
+    // a quit byte is seen. Consuming until EOI isn't a correctness problem,
+    // but a (serious) perf problem. Hitting a quit byte, however, could be a
+    // correctness problem since it could cause search routines to report an
+    // error instead of a detected match once the quit state is entered. (The
+    // search routine could be made to be a bit smarter by reporting a match
+    // if one was detected once it enters a quit state (and indeed, the search
+    // routines in this crate do just that), but it seems better to prevent
+    // these things by construction if possible.)
+    if !sparses.set2.is_empty() {
+        if nfa.look_set_any().contains_word() && unit.is_word_byte() {
+            builder.set_is_from_word();
+        }
+        if nfa.look_set_any().contains_anchor_crlf()
+            && ((rev && unit.is_byte(b'\n')) || (!rev && unit.is_byte(b'\r')))
+        {
+            builder.set_is_half_crlf();
+        }
+    }
+    let mut builder_nfa = builder.into_nfa();
+    add_nfa_states(nfa, &sparses.set2, &mut builder_nfa);
+    builder_nfa
+}
+
+/// Compute the epsilon closure for the given NFA state. The epsilon closure
+/// consists of all NFA state IDs, including `start_nfa_id`, that can be
+/// reached from `start_nfa_id` without consuming any input. These state IDs
+/// are written to `set` in the order they are visited, but only if they are
+/// not already in `set`. `start_nfa_id` must be a valid state ID for the NFA
+/// given.
+///
+/// `look_have` consists of the satisfied assertions at the current
+/// position. For conditional look-around epsilon transitions, these are
+/// only followed if they are satisfied by `look_have`.
+///
+/// `stack` must have length 0. It is used as scratch space for depth first
+/// traversal. After returning, it is guaranteed that `stack` will have length
+/// 0.
+pub(crate) fn epsilon_closure(
+    nfa: &thompson::NFA,
+    start_nfa_id: StateID,
+    look_have: LookSet,
+    stack: &mut Vec<StateID>,
+    set: &mut SparseSet,
+) {
+    assert!(stack.is_empty());
+    // If this isn't an epsilon state, then the epsilon closure is always just
+    // itself, so there's no need to spin up the machinery below to handle it.
+    if !nfa.state(start_nfa_id).is_epsilon() {
+        set.insert(start_nfa_id);
+        return;
+    }
+
+    stack.push(start_nfa_id);
+    while let Some(mut id) = stack.pop() {
+        // In many cases, we can avoid stack operations when an NFA state only
+        // adds one new state to visit. In that case, we just set our ID to
+        // that state and mush on. We only use the stack when an NFA state
+        // introduces multiple new states to visit.
+        loop {
+            // Insert this NFA state, and if it's already in the set and thus
+            // already visited, then we can move on to the next one.
+            if !set.insert(id) {
+                break;
+            }
+            match *nfa.state(id) {
+                thompson::State::ByteRange { .. }
+                | thompson::State::Sparse { .. }
+                | thompson::State::Dense { .. }
+                | thompson::State::Fail
+                | thompson::State::Match { .. } => break,
+                thompson::State::Look { look, next } => {
+                    if !look_have.contains(look) {
+                        break;
+                    }
+                    id = next;
+                }
+                thompson::State::Union { ref alternates } => {
+                    id = match alternates.get(0) {
+                        None => break,
+                        Some(&id) => id,
+                    };
+                    // We need to process our alternates in order to preserve
+                    // match preferences, so put the earliest alternates closer
+                    // to the top of the stack.
+                    stack.extend(alternates[1..].iter().rev());
+                }
+                thompson::State::BinaryUnion { alt1, alt2 } => {
+                    id = alt1;
+                    stack.push(alt2);
+                }
+                thompson::State::Capture { next, .. } => {
+                    id = next;
+                }
+            }
+        }
+    }
+}
+
+/// Add the NFA state IDs in the given `set` to the given DFA builder state.
+/// The order in which states are added corresponds to the order in which they
+/// were added to `set`.
+///
+/// The DFA builder state given should already have its complete set of match
+/// pattern IDs added (if any) and any look-behind assertions (StartLF, Start
+/// and whether this state is being generated for a transition over a word byte
+/// when applicable) that are true immediately prior to transitioning into this
+/// state (via `builder.look_have()`). The match pattern IDs should correspond
+/// to matches that occured on the previous transition, since all matches are
+/// delayed by one byte. The things that should _not_ be set are look-ahead
+/// assertions (EndLF, End and whether the next byte is a word byte or not).
+/// The builder state should also not have anything in `look_need` set, as this
+/// routine will compute that for you.
+///
+/// The given NFA should be able to resolve all identifiers in `set` to a
+/// particular NFA state. Additionally, `set` must have capacity equivalent
+/// to `nfa.len()`.
+pub(crate) fn add_nfa_states(
+    nfa: &thompson::NFA,
+    set: &SparseSet,
+    builder: &mut StateBuilderNFA,
+) {
+    for nfa_id in set.iter() {
+        match *nfa.state(nfa_id) {
+            thompson::State::ByteRange { .. } => {
+                builder.add_nfa_state_id(nfa_id);
+            }
+            thompson::State::Sparse { .. } => {
+                builder.add_nfa_state_id(nfa_id);
+            }
+            thompson::State::Dense { .. } => {
+                builder.add_nfa_state_id(nfa_id);
+            }
+            thompson::State::Look { look, .. } => {
+                builder.add_nfa_state_id(nfa_id);
+                builder.set_look_need(|need| need.insert(look));
+            }
+            thompson::State::Union { .. }
+            | thompson::State::BinaryUnion { .. } => {
+                // Pure epsilon transitions don't need to be tracked as part
+                // of the DFA state. Tracking them is actually superfluous;
+                // they won't cause any harm other than making determinization
+                // slower.
+                //
+                // Why aren't these needed? Well, in an NFA, epsilon
+                // transitions are really just jumping points to other states.
+                // So once you hit an epsilon transition, the same set of
+                // resulting states always appears. Therefore, putting them in
+                // a DFA's set of ordered NFA states is strictly redundant.
+                //
+                // Look-around states are also epsilon transitions, but
+                // they are *conditional*. So their presence could be
+                // discriminatory, and thus, they are tracked above.
+                //
+                // But wait... why are epsilon states in our `set` in the first
+                // place? Why not just leave them out? They're in our `set`
+                // because it was generated by computing an epsilon closure,
+                // and we want to keep track of all states we visited to avoid
+                // re-visiting them. In exchange, we have to do this second
+                // iteration over our collected states to finalize our DFA
+                // state. In theory, we could avoid this second iteration if
+                // we maintained two sets during epsilon closure: the set of
+                // visited states (to avoid cycles) and the set of states that
+                // will actually be used to construct the next DFA state.
+                //
+                // Note that this optimization requires that we re-compute the
+                // epsilon closure to account for look-ahead in 'next' *only
+                // when necessary*. Namely, only when the set of look-around
+                // assertions changes and only when those changes are within
+                // the set of assertions that are needed in order to step
+                // through the closure correctly. Otherwise, if we re-do the
+                // epsilon closure needlessly, it could change based on the
+                // fact that we are omitting epsilon states here.
+                //
+                // -----
+                //
+                // Welp, scratch the above. It turns out that recording these
+                // is in fact necessary to seemingly handle one particularly
+                // annoying case: when a conditional epsilon transition is
+                // put inside of a repetition operator. One specific case I
+                // ran into was the regex `(?:\b|%)+` on the haystack `z%`.
+                // The correct leftmost first matches are: [0, 0] and [1, 1].
+                // But the DFA was reporting [0, 0] and [1, 2]. To understand
+                // why this happens, consider the NFA for the aforementioned
+                // regex:
+                //
+                //     >000000: binary-union(4, 1)
+                //      000001: \x00-\xFF => 0
+                //      000002: WordAscii => 5
+                //      000003: % => 5
+                //     ^000004: binary-union(2, 3)
+                //      000005: binary-union(4, 6)
+                //      000006: MATCH(0)
+                //
+                // The problem here is that one of the DFA start states is
+                // going to consist of the NFA states [2, 3] by computing the
+                // epsilon closure of state 4. State 4 isn't included because
+                // we previously were not keeping track of union states. But
+                // only a subset of transitions out of this state will be able
+                // to follow WordAscii, and in those cases, the epsilon closure
+                // is redone. The only problem is that computing the epsilon
+                // closure from [2, 3] is different than computing the epsilon
+                // closure from [4]. In the former case, assuming the WordAscii
+                // assertion is satisfied, you get: [2, 3, 6]. In the latter
+                // case, you get: [2, 6, 3]. Notice that '6' is the match state
+                // and appears AFTER '3' in the former case. This leads to a
+                // preferential but incorrect match of '%' before returning
+                // a match. In the latter case, the match is preferred over
+                // continuing to accept the '%'.
+                //
+                // It almost feels like we might be able to fix the NFA states
+                // to avoid this, or to at least only keep track of union
+                // states where this actually matters, since in the vast
+                // majority of cases, this doesn't matter.
+                //
+                // Another alternative would be to define a new HIR property
+                // called "assertion is repeated anywhere" and compute it
+                // inductively over the entire pattern. If it happens anywhere,
+                // which is probably pretty rare, then we record union states.
+                // Otherwise we don't.
+                builder.add_nfa_state_id(nfa_id);
+            }
+            // Capture states we definitely do not need to record, since they
+            // are unconditional epsilon transitions with no branching.
+            thompson::State::Capture { .. } => {}
+            // It's not totally clear whether we need to record fail states or
+            // not, but we do so out of an abundance of caution. Since they are
+            // quite rare in practice, there isn't much cost to recording them.
+            thompson::State::Fail => {
+                builder.add_nfa_state_id(nfa_id);
+            }
+            thompson::State::Match { .. } => {
+                // Normally, the NFA match state doesn't actually need to
+                // be inside the DFA state. But since we delay matches by
+                // one byte, the matching DFA state corresponds to states
+                // that transition from the one we're building here. And
+                // the way we detect those cases is by looking for an NFA
+                // match state. See 'next' for how this is handled.
+                builder.add_nfa_state_id(nfa_id);
+            }
+        }
+    }
+    // If we know this state contains no look-around assertions, then
+    // there's no reason to track which look-around assertions were
+    // satisfied when this state was created.
+    if builder.look_need().is_empty() {
+        builder.set_look_have(|_| LookSet::empty());
+    }
+}
+
+/// Sets the appropriate look-behind assertions on the given state based on
+/// this starting configuration.
+pub(crate) fn set_lookbehind_from_start(
+    nfa: &thompson::NFA,
+    start: &Start,
+    builder: &mut StateBuilderMatches,
+) {
+    let rev = nfa.is_reverse();
+    let lineterm = nfa.look_matcher().get_line_terminator();
+    match *start {
+        Start::NonWordByte => {}
+        Start::WordByte => {
+            builder.set_is_from_word();
+        }
+        Start::Text => {
+            builder.set_look_have(|have| {
+                have.insert(Look::Start)
+                    .insert(Look::StartLF)
+                    .insert(Look::StartCRLF)
+            });
+        }
+        Start::LineLF => {
+            if rev {
+                builder.set_is_half_crlf();
+                builder.set_look_have(|have| have.insert(Look::StartLF));
+            } else {
+                builder.set_look_have(|have| have.insert(Look::StartCRLF));
+            }
+            if lineterm == b'\n' {
+                builder.set_look_have(|have| have.insert(Look::StartLF));
+            }
+        }
+        Start::LineCR => {
+            if rev {
+                builder.set_look_have(|have| have.insert(Look::StartCRLF));
+            } else {
+                builder.set_is_half_crlf();
+            }
+            if lineterm == b'\r' {
+                builder.set_look_have(|have| have.insert(Look::StartLF));
+            }
+        }
+        Start::CustomLineTerminator => {
+            builder.set_look_have(|have| have.insert(Look::StartLF));
+            // This is a bit of a tricky case, but if the line terminator was
+            // set to a word byte, then we also need to behave as if the start
+            // configuration is Start::WordByte. That is, we need to mark our
+            // state as having come from a word byte.
+            if utf8::is_word_byte(lineterm) {
+                builder.set_is_from_word();
+            }
+        }
+    }
+}
diff --git a/regex-automata/src/util/determinize/state.rs b/regex-automata/src/util/determinize/state.rs
new file mode 100644
index 0000000000..68f81f93c9
--- /dev/null
+++ b/regex-automata/src/util/determinize/state.rs
@@ -0,0 +1,906 @@
+/*!
+This module defines a DFA state representation and builders for constructing
+DFA states.
+
+This representation is specifically for use in implementations of NFA-to-DFA
+conversion via powerset construction. (Also called "determinization" in this
+crate.)
+
+The term "DFA state" is somewhat overloaded in this crate. In some cases, it
+refers to the set of transitions over an alphabet for a particular state. In
+other cases, it refers to a set of NFA states. The former is really about the
+final representation of a state in a DFA's transition table, where as the
+latter---what this module is focused on---is closer to an intermediate form
+that is used to help eventually build the transition table.
+
+This module exports four types. All four types represent the same idea: an
+ordered set of NFA states. This ordered set represents the epsilon closure of a
+particular NFA state, where the "epsilon closure" is the set of NFA states that
+can be transitioned to without consuming any input. i.e., Follow all of the NFA
+state's epsilon transitions. In addition, this implementation of DFA states
+cares about two other things: the ordered set of pattern IDs corresponding
+to the patterns that match if the state is a match state, and the set of
+look-behind assertions that were true when the state was created.
+
+The first, `State`, is a frozen representation of a state that cannot be
+modified. It may be cheaply cloned without copying the state itself and can be
+accessed safely from multiple threads simultaneously. This type is useful for
+when one knows that the DFA state being constructed is distinct from any other
+previously constructed states. Namely, powerset construction, in practice,
+requires one to keep a cache of previously created DFA states. Otherwise,
+the number of DFA states created in memory balloons to an impractically
+large number. For this reason, equivalent states should endeavor to have an
+equivalent byte-level representation. (In general, "equivalency" here means,
+"equivalent assertions, pattern IDs and NFA state IDs." We do not require that
+full DFA minimization be implemented here. This form of equivalency is only
+surface deep and is more-or-less a practical necessity.)
+
+The other three types represent different phases in the construction of a
+DFA state. Internally, these three types (and `State`) all use the same
+byte-oriented representation. That means one can use any of the builder types
+to check whether the state it represents already exists or not. If it does,
+then there is no need to freeze it into a `State` (which requires an alloc and
+a copy). Here are the three types described succinctly:
+
+* `StateBuilderEmpty` represents a state with no pattern IDs, no assertions
+and no NFA states. Creating a `StateBuilderEmpty` performs no allocs. A
+`StateBuilderEmpty` can only be used to query its underlying memory capacity,
+or to convert into a builder for recording pattern IDs and/or assertions.
+
+* `StateBuilderMatches` represents a state with zero or more pattern IDs, zero
+or more satisfied assertions and zero NFA state IDs. A `StateBuilderMatches`
+can only be used for adding pattern IDs and recording assertions.
+
+* `StateBuilderNFA` represents a state with zero or more pattern IDs, zero or
+more satisfied assertions and zero or more NFA state IDs. A `StateBuilderNFA`
+can only be used for adding NFA state IDs and recording some assertions.
+
+The expected flow here is to use the above builders to construct a candidate
+DFA state to check if it already exists. If it does, then there's no need to
+freeze it into a `State`. It it doesn't exist, then `StateBuilderNFA::to_state`
+can be called to freeze the builder into an immutable `State`. In either
+case, `clear` should be called on the builder to turn it back into a
+`StateBuilderEmpty` that reuses the underyling memory.
+
+The main purpose for splitting the builder into these distinct types is to
+make it impossible to do things like adding a pattern ID after adding an NFA
+state ID. Namely, this makes it simpler to use a space-and-time efficient
+binary representation for the state. (The format is documented on the `Repr`
+type below.) If we just used one type for everything, it would be possible for
+callers to use an incorrect interleaving of calls and thus result in a corrupt
+representation. I chose to use more type machinery to make this impossible to
+do because 1) determinization is itself pretty complex and it wouldn't be too
+hard to foul this up and 2) there isn't too much machinery involved and it's
+well contained.
+
+As an optimization, sometimes states won't have certain things set. For
+example, if the underlying NFA has no word boundary assertions, then there is
+no reason to set a state's look-behind assertion as to whether it was generated
+from a word byte or not. Similarly, if a state has no NFA states corresponding
+to look-around assertions, then there is no reason to set `look_have` to a
+non-empty set. Finally, callers usually omit unconditional epsilon transitions
+when adding NFA state IDs since they aren't discriminatory.
+
+Finally, the binary representation used by these states is, thankfully, not
+serialized anywhere. So any kind of change can be made with reckless abandon,
+as long as everything in this module agrees.
+*/
+
+use core::{convert::TryFrom, mem};
+
+use alloc::{sync::Arc, vec::Vec};
+
+use crate::util::{
+    int::{I32, U32},
+    look::LookSet,
+    primitives::{PatternID, StateID},
+    wire::{self, Endian},
+};
+
+/// A DFA state that, at its core, is represented by an ordered set of NFA
+/// states.
+///
+/// This type is intended to be used only in NFA-to-DFA conversion via powerset
+/// construction.
+///
+/// It may be cheaply cloned and accessed safely from mulitple threads
+/// simultaneously.
+#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub(crate) struct State(Arc<[u8]>);
+
+/// This Borrow impl permits us to lookup any state in a map by its byte
+/// representation. This is particularly convenient when one has a StateBuilder
+/// and we want to see if a correspondingly equivalent state already exists. If
+/// one does exist, then we can reuse the allocation required by StateBuilder
+/// without having to convert it into a State first.
+impl core::borrow::Borrow<[u8]> for State {
+    fn borrow(&self) -> &[u8] {
+        &*self.0
+    }
+}
+
+impl core::fmt::Debug for State {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_tuple("State").field(&self.repr()).finish()
+    }
+}
+
+/// For docs on these routines, see the internal Repr and ReprVec types below.
+impl State {
+    pub(crate) fn dead() -> State {
+        StateBuilderEmpty::new().into_matches().into_nfa().to_state()
+    }
+
+    pub(crate) fn is_match(&self) -> bool {
+        self.repr().is_match()
+    }
+
+    pub(crate) fn is_from_word(&self) -> bool {
+        self.repr().is_from_word()
+    }
+
+    pub(crate) fn is_half_crlf(&self) -> bool {
+        self.repr().is_half_crlf()
+    }
+
+    pub(crate) fn look_have(&self) -> LookSet {
+        self.repr().look_have()
+    }
+
+    pub(crate) fn look_need(&self) -> LookSet {
+        self.repr().look_need()
+    }
+
+    pub(crate) fn match_len(&self) -> usize {
+        self.repr().match_len()
+    }
+
+    pub(crate) fn match_pattern(&self, index: usize) -> PatternID {
+        self.repr().match_pattern(index)
+    }
+
+    pub(crate) fn match_pattern_ids(&self) -> Option<Vec<PatternID>> {
+        self.repr().match_pattern_ids()
+    }
+
+    #[cfg(all(test, not(miri)))]
+    pub(crate) fn iter_match_pattern_ids<F: FnMut(PatternID)>(&self, f: F) {
+        self.repr().iter_match_pattern_ids(f)
+    }
+
+    pub(crate) fn iter_nfa_state_ids<F: FnMut(StateID)>(&self, f: F) {
+        self.repr().iter_nfa_state_ids(f)
+    }
+
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.0.len()
+    }
+
+    fn repr(&self) -> Repr<'_> {
+        Repr(&*self.0)
+    }
+}
+
+/// A state builder that represents an empty state.
+///
+/// This is a useful "initial condition" for state construction. It has no
+/// NFA state IDs, no assertions set and no pattern IDs. No allocations are
+/// made when new() is called. Its main use is for being converted into a
+/// builder that can capture assertions and pattern IDs.
+#[derive(Clone, Debug)]
+pub(crate) struct StateBuilderEmpty(Vec<u8>);
+
+/// For docs on these routines, see the internal Repr and ReprVec types below.
+impl StateBuilderEmpty {
+    pub(crate) fn new() -> StateBuilderEmpty {
+        StateBuilderEmpty(alloc::vec![])
+    }
+
+    pub(crate) fn into_matches(mut self) -> StateBuilderMatches {
+        self.0.extend_from_slice(&[0, 0, 0, 0, 0]);
+        StateBuilderMatches(self.0)
+    }
+
+    fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    pub(crate) fn capacity(&self) -> usize {
+        self.0.capacity()
+    }
+}
+
+/// A state builder that collects assertions and pattern IDs.
+///
+/// When collecting pattern IDs is finished, this can be converted into a
+/// builder that collects NFA state IDs.
+#[derive(Clone)]
+pub(crate) struct StateBuilderMatches(Vec<u8>);
+
+impl core::fmt::Debug for StateBuilderMatches {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_tuple("StateBuilderMatches").field(&self.repr()).finish()
+    }
+}
+
+/// For docs on these routines, see the internal Repr and ReprVec types below.
+impl StateBuilderMatches {
+    pub(crate) fn into_nfa(mut self) -> StateBuilderNFA {
+        self.repr_vec().close_match_pattern_ids();
+        StateBuilderNFA { repr: self.0, prev_nfa_state_id: StateID::ZERO }
+    }
+
+    pub(crate) fn set_is_from_word(&mut self) {
+        self.repr_vec().set_is_from_word()
+    }
+
+    pub(crate) fn set_is_half_crlf(&mut self) {
+        self.repr_vec().set_is_half_crlf()
+    }
+
+    pub(crate) fn look_have(&self) -> LookSet {
+        LookSet::read_repr(&self.0[1..])
+    }
+
+    pub(crate) fn set_look_have(
+        &mut self,
+        set: impl FnMut(LookSet) -> LookSet,
+    ) {
+        self.repr_vec().set_look_have(set)
+    }
+
+    pub(crate) fn add_match_pattern_id(&mut self, pid: PatternID) {
+        self.repr_vec().add_match_pattern_id(pid)
+    }
+
+    fn repr(&self) -> Repr<'_> {
+        Repr(&self.0)
+    }
+
+    fn repr_vec(&mut self) -> ReprVec<'_> {
+        ReprVec(&mut self.0)
+    }
+}
+
+/// A state builder that collects some assertions and NFA state IDs.
+///
+/// When collecting NFA state IDs is finished, this can be used to build a
+/// `State` if necessary.
+///
+/// When dont with building a state (regardless of whether it got kept or not),
+/// it's usually a good idea to call `clear` to get an empty builder back so
+/// that it can be reused to build the next state.
+#[derive(Clone)]
+pub(crate) struct StateBuilderNFA {
+    repr: Vec<u8>,
+    prev_nfa_state_id: StateID,
+}
+
+impl core::fmt::Debug for StateBuilderNFA {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_tuple("StateBuilderNFA").field(&self.repr()).finish()
+    }
+}
+
+/// For docs on these routines, see the internal Repr and ReprVec types below.
+impl StateBuilderNFA {
+    pub(crate) fn to_state(&self) -> State {
+        State(Arc::from(&*self.repr))
+    }
+
+    pub(crate) fn clear(self) -> StateBuilderEmpty {
+        let mut builder = StateBuilderEmpty(self.repr);
+        builder.clear();
+        builder
+    }
+
+    pub(crate) fn look_need(&self) -> LookSet {
+        self.repr().look_need()
+    }
+
+    pub(crate) fn set_look_have(
+        &mut self,
+        set: impl FnMut(LookSet) -> LookSet,
+    ) {
+        self.repr_vec().set_look_have(set)
+    }
+
+    pub(crate) fn set_look_need(
+        &mut self,
+        set: impl FnMut(LookSet) -> LookSet,
+    ) {
+        self.repr_vec().set_look_need(set)
+    }
+
+    pub(crate) fn add_nfa_state_id(&mut self, sid: StateID) {
+        ReprVec(&mut self.repr)
+            .add_nfa_state_id(&mut self.prev_nfa_state_id, sid)
+    }
+
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        &self.repr
+    }
+
+    fn repr(&self) -> Repr<'_> {
+        Repr(&self.repr)
+    }
+
+    fn repr_vec(&mut self) -> ReprVec<'_> {
+        ReprVec(&mut self.repr)
+    }
+}
+
+/// Repr is a read-only view into the representation of a DFA state.
+///
+/// Primarily, a Repr is how we achieve DRY: we implement decoding the format
+/// in one place, and then use a Repr to implement the various methods on the
+/// public state types.
+///
+/// The format is as follows:
+///
+/// The first three bytes correspond to bitsets.
+///
+/// Byte 0 is a bitset corresponding to miscellaneous flags associated with the
+/// state. Bit 0 is set to 1 if the state is a match state. Bit 1 is set to 1
+/// if the state has pattern IDs explicitly written to it. (This is a flag that
+/// is not meant to be set by determinization, but rather, is used as part of
+/// an internal space-saving optimization.) Bit 2 is set to 1 if the state was
+/// generated by a transition over a "word" byte. (Callers may not always set
+/// this. For example, if the NFA has no word boundary assertion, then needing
+/// to track whether a state came from a word byte or not is superfluous and
+/// wasteful.)
+///
+/// Byte 1 corresponds to the look-behind assertions that were satisfied by
+/// the transition that created this state. This generally only includes the
+/// StartLF and Start assertions. (Look-ahead assertions are not tracked as
+/// part of states. Instead, these are applied by re-computing the epsilon
+/// closure of a state when computing the transition function. See `next` in
+/// the parent module.)
+///
+/// Byte 2 corresponds to the set of look-around assertions (including both
+/// look-behind and look-ahead) that appear somewhere in this state's set of
+/// NFA state IDs. This is used to determine whether this state's epsilon
+/// closure should be re-computed when computing the transition function.
+/// Namely, look-around assertions are "just" conditional epsilon transitions,
+/// so if there are new assertions available when computing the transition
+/// function, we should only re-compute the epsilon closure if those new
+/// assertions are relevant to this particular state.
+///
+/// Bytes 3..7 correspond to a 32-bit native-endian encoded integer
+/// corresponding to the number of patterns encoded in this state. If the state
+/// is not a match state (byte 0 bit 0 is 0) or if it's only pattern ID is
+/// PatternID::ZERO, then no integer is encoded at this position. Instead, byte
+/// offset 3 is the position at which the first NFA state ID is encoded.
+///
+/// For a match state with at least one non-ZERO pattern ID, the next bytes
+/// correspond to a sequence of 32-bit native endian encoded integers that
+/// represent each pattern ID, in order, that this match state represents.
+///
+/// After the pattern IDs (if any), NFA state IDs are delta encoded as
+/// varints.[1] The first NFA state ID is encoded as itself, and each
+/// subsequent NFA state ID is encoded as the difference between itself and the
+/// previous NFA state ID.
+///
+/// [1] - https://developers.google.com/protocol-buffers/docs/encoding#varints
+struct Repr<'a>(&'a [u8]);
+
+impl<'a> Repr<'a> {
+    /// Returns true if and only if this is a match state.
+    ///
+    /// If callers have added pattern IDs to this state, then callers MUST set
+    /// this state as a match state explicitly. However, as a special case,
+    /// states that are marked as match states but with no pattern IDs, then
+    /// the state is treated as if it had a single pattern ID equivalent to
+    /// PatternID::ZERO.
+    fn is_match(&self) -> bool {
+        self.0[0] & (1 << 0) > 0
+    }
+
+    /// Returns true if and only if this state has had at least one pattern
+    /// ID added to it.
+    ///
+    /// This is an internal-only flag that permits the representation to save
+    /// space in the common case of an NFA with one pattern in it. In that
+    /// case, a match state can only ever have exactly one pattern ID:
+    /// PatternID::ZERO. So there's no need to represent it.
+    fn has_pattern_ids(&self) -> bool {
+        self.0[0] & (1 << 1) > 0
+    }
+
+    /// Returns true if and only if this state is marked as having been created
+    /// from a transition over a word byte. This is useful for checking whether
+    /// a word boundary assertion is true or not, which requires look-behind
+    /// (whether the current state came from a word byte or not) and look-ahead
+    /// (whether the transition byte is a word byte or not).
+    ///
+    /// Since states with this set are distinct from states that don't have
+    /// this set (even if they are otherwise equivalent), callers should not
+    /// set this assertion unless the underlying NFA has at least one word
+    /// boundary assertion somewhere. Otherwise, a superfluous number of states
+    /// may be created.
+    fn is_from_word(&self) -> bool {
+        self.0[0] & (1 << 2) > 0
+    }
+
+    /// Returns true if and only if this state is marked as being inside of a
+    /// CRLF terminator. In the forward direction, this means the state was
+    /// created after seeing a `\r`. In the reverse direction, this means the
+    /// state was created after seeing a `\n`.
+    fn is_half_crlf(&self) -> bool {
+        self.0[0] & (1 << 3) > 0
+    }
+
+    /// The set of look-behind assertions that were true in the transition that
+    /// created this state.
+    ///
+    /// Generally, this should be empty if 'look_need' is empty, since there is
+    /// no reason to track which look-behind assertions are true if the state
+    /// has no conditional epsilon transitions.
+    ///
+    /// Satisfied look-ahead assertions are not tracked in states. Instead,
+    /// these are re-computed on demand via epsilon closure when computing the
+    /// transition function.
+    fn look_have(&self) -> LookSet {
+        LookSet::read_repr(&self.0[1..])
+    }
+
+    /// The set of look-around (both behind and ahead) assertions that appear
+    /// at least once in this state's set of NFA states.
+    ///
+    /// This is used to determine whether the epsilon closure needs to be
+    /// re-computed when computing the transition function. Namely, if the
+    /// state has no conditional epsilon transitions, then there is no need
+    /// to re-compute the epsilon closure.
+    fn look_need(&self) -> LookSet {
+        LookSet::read_repr(&self.0[3..])
+    }
+
+    /// Returns the total number of match pattern IDs in this state.
+    ///
+    /// If this state is not a match state, then this always returns 0.
+    fn match_len(&self) -> usize {
+        if !self.is_match() {
+            return 0;
+        } else if !self.has_pattern_ids() {
+            1
+        } else {
+            self.encoded_pattern_len()
+        }
+    }
+
+    /// Returns the pattern ID for this match state at the given index.
+    ///
+    /// If the given index is greater than or equal to `match_len()` for this
+    /// state, then this could panic or return incorrect results.
+    fn match_pattern(&self, index: usize) -> PatternID {
+        if !self.has_pattern_ids() {
+            PatternID::ZERO
+        } else {
+            let offset = 9 + index * PatternID::SIZE;
+            // This is OK since we only ever serialize valid PatternIDs to
+            // states.
+            wire::read_pattern_id_unchecked(&self.0[offset..]).0
+        }
+    }
+
+    /// Returns a copy of all match pattern IDs in this state. If this state
+    /// is not a match state, then this returns None.
+    fn match_pattern_ids(&self) -> Option<Vec<PatternID>> {
+        if !self.is_match() {
+            return None;
+        }
+        let mut pids = alloc::vec![];
+        self.iter_match_pattern_ids(|pid| pids.push(pid));
+        Some(pids)
+    }
+
+    /// Calls the given function on every pattern ID in this state.
+    fn iter_match_pattern_ids<F: FnMut(PatternID)>(&self, mut f: F) {
+        if !self.is_match() {
+            return;
+        }
+        // As an optimization for a very common case, when this is a match
+        // state for an NFA with only one pattern, we don't actually write the
+        // pattern ID to the state representation. Instead, we know it must
+        // be there since it is the only possible choice.
+        if !self.has_pattern_ids() {
+            f(PatternID::ZERO);
+            return;
+        }
+        let mut pids = &self.0[9..self.pattern_offset_end()];
+        while !pids.is_empty() {
+            let pid = wire::read_u32(pids);
+            pids = &pids[PatternID::SIZE..];
+            // This is OK since we only ever serialize valid PatternIDs to
+            // states. And since pattern IDs can never exceed a usize, the
+            // unwrap is OK.
+            f(PatternID::new_unchecked(usize::try_from(pid).unwrap()));
+        }
+    }
+
+    /// Calls the given function on every NFA state ID in this state.
+    fn iter_nfa_state_ids<F: FnMut(StateID)>(&self, mut f: F) {
+        let mut sids = &self.0[self.pattern_offset_end()..];
+        let mut prev = 0i32;
+        while !sids.is_empty() {
+            let (delta, nr) = read_vari32(sids);
+            sids = &sids[nr..];
+            let sid = prev + delta;
+            prev = sid;
+            // This is OK since we only ever serialize valid StateIDs to
+            // states. And since state IDs can never exceed an isize, they must
+            // always be able to fit into a usize, and thus cast is OK.
+            f(StateID::new_unchecked(sid.as_usize()))
+        }
+    }
+
+    /// Returns the offset into this state's representation where the pattern
+    /// IDs end and the NFA state IDs begin.
+    fn pattern_offset_end(&self) -> usize {
+        let encoded = self.encoded_pattern_len();
+        if encoded == 0 {
+            return 5;
+        }
+        // This arithmetic is OK since we were able to address this many bytes
+        // when writing to the state, thus, it must fit into a usize.
+        encoded.checked_mul(4).unwrap().checked_add(9).unwrap()
+    }
+
+    /// Returns the total number of *encoded* pattern IDs in this state.
+    ///
+    /// This may return 0 even when this is a match state, since the pattern
+    /// ID `PatternID::ZERO` is not encoded when it's the only pattern ID in
+    /// the match state (the overwhelming common case).
+    fn encoded_pattern_len(&self) -> usize {
+        if !self.has_pattern_ids() {
+            return 0;
+        }
+        // This unwrap is OK since the total number of patterns is always
+        // guaranteed to fit into a usize.
+        usize::try_from(wire::read_u32(&self.0[5..9])).unwrap()
+    }
+}
+
+impl<'a> core::fmt::Debug for Repr<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut nfa_ids = alloc::vec![];
+        self.iter_nfa_state_ids(|sid| nfa_ids.push(sid));
+        f.debug_struct("Repr")
+            .field("is_match", &self.is_match())
+            .field("is_from_word", &self.is_from_word())
+            .field("is_half_crlf", &self.is_half_crlf())
+            .field("look_have", &self.look_have())
+            .field("look_need", &self.look_need())
+            .field("match_pattern_ids", &self.match_pattern_ids())
+            .field("nfa_state_ids", &nfa_ids)
+            .finish()
+    }
+}
+
+/// ReprVec is a write-only view into the representation of a DFA state.
+///
+/// See Repr for more details on the purpose of this type and also the format.
+///
+/// Note that not all possible combinations of methods may be called. This is
+/// precisely what the various StateBuilder types encapsulate: they only
+/// permit valid combinations via Rust's linear typing.
+struct ReprVec<'a>(&'a mut Vec<u8>);
+
+impl<'a> ReprVec<'a> {
+    /// Set this state as a match state.
+    ///
+    /// This should not be exposed explicitly outside of this module. It is
+    /// set automatically when a pattern ID is added.
+    fn set_is_match(&mut self) {
+        self.0[0] |= 1 << 0;
+    }
+
+    /// Set that this state has pattern IDs explicitly written to it.
+    ///
+    /// This should not be exposed explicitly outside of this module. This is
+    /// used internally as a space saving optimization. Namely, if the state
+    /// is a match state but does not have any pattern IDs written to it,
+    /// then it is automatically inferred to have a pattern ID of ZERO.
+    fn set_has_pattern_ids(&mut self) {
+        self.0[0] |= 1 << 1;
+    }
+
+    /// Set this state as being built from a transition over a word byte.
+    ///
+    /// Setting this is only necessary when one needs to deal with word
+    /// boundary assertions. Therefore, if the underlying NFA has no word
+    /// boundary assertions, callers should not set this.
+    fn set_is_from_word(&mut self) {
+        self.0[0] |= 1 << 2;
+    }
+
+    /// Set this state as having seen half of a CRLF terminator.
+    ///
+    /// In the forward direction, this should be set when a `\r` has been seen.
+    /// In the reverse direction, this should be set when a `\n` has been seen.
+    fn set_is_half_crlf(&mut self) {
+        self.0[0] |= 1 << 3;
+    }
+
+    /// The set of look-behind assertions that were true in the transition that
+    /// created this state.
+    fn look_have(&self) -> LookSet {
+        self.repr().look_have()
+    }
+
+    /// The set of look-around (both behind and ahead) assertions that appear
+    /// at least once in this state's set of NFA states.
+    fn look_need(&self) -> LookSet {
+        self.repr().look_need()
+    }
+
+    /// Mutate the set of look-behind assertions that were true in the
+    /// transition that created this state.
+    fn set_look_have(&mut self, mut set: impl FnMut(LookSet) -> LookSet) {
+        set(self.look_have()).write_repr(&mut self.0[1..]);
+    }
+
+    /// Mutate the set of look-around (both behind and ahead) assertions that
+    /// appear at least once in this state's set of NFA states.
+    fn set_look_need(&mut self, mut set: impl FnMut(LookSet) -> LookSet) {
+        set(self.look_need()).write_repr(&mut self.0[3..]);
+    }
+
+    /// Add a pattern ID to this state. All match states must have at least
+    /// one pattern ID associated with it.
+    ///
+    /// Callers must never add duplicative pattern IDs.
+    ///
+    /// The order in which patterns are added must correspond to the order
+    /// in which patterns are reported as matches.
+    fn add_match_pattern_id(&mut self, pid: PatternID) {
+        // As a (somewhat small) space saving optimization, in the case where
+        // a matching state has exactly one pattern ID, PatternID::ZERO, we do
+        // not write either the pattern ID or the number of patterns encoded.
+        // Instead, all we do is set the 'is_match' bit on this state. Overall,
+        // this saves 8 bytes per match state for the overwhelming majority of
+        // match states.
+        //
+        // In order to know whether pattern IDs need to be explicitly read or
+        // not, we use another internal-only bit, 'has_pattern_ids', to
+        // indicate whether they have been explicitly written or not.
+        if !self.repr().has_pattern_ids() {
+            if pid == PatternID::ZERO {
+                self.set_is_match();
+                return;
+            }
+            // Make room for 'close_match_pattern_ids' to write the total
+            // number of pattern IDs written.
+            self.0.extend(core::iter::repeat(0).take(PatternID::SIZE));
+            self.set_has_pattern_ids();
+            // If this was already a match state, then the only way that's
+            // possible when the state doesn't have pattern IDs is if
+            // PatternID::ZERO was added by the caller previously. In this
+            // case, we are now adding a non-ZERO pattern ID after it, in
+            // which case, we want to make sure to represent ZERO explicitly
+            // now.
+            if self.repr().is_match() {
+                write_u32(self.0, 0)
+            } else {
+                // Otherwise, just make sure the 'is_match' bit is set.
+                self.set_is_match();
+            }
+        }
+        write_u32(self.0, pid.as_u32());
+    }
+
+    /// Indicate that no more pattern IDs will be added to this state.
+    ///
+    /// Once this is called, callers must not call it or 'add_match_pattern_id'
+    /// again.
+    ///
+    /// This should not be exposed explicitly outside of this module. It
+    /// should be called only when converting a StateBuilderMatches into a
+    /// StateBuilderNFA.
+    fn close_match_pattern_ids(&mut self) {
+        // If we never wrote any pattern IDs, then there's nothing to do here.
+        if !self.repr().has_pattern_ids() {
+            return;
+        }
+        let patsize = PatternID::SIZE;
+        let pattern_bytes = self.0.len() - 9;
+        // Every pattern ID uses 4 bytes, so number of bytes should be
+        // divisible by 4.
+        assert_eq!(pattern_bytes % patsize, 0);
+        // This unwrap is OK since we are guaranteed that the maximum number
+        // of possible patterns fits into a u32.
+        let count32 = u32::try_from(pattern_bytes / patsize).unwrap();
+        wire::NE::write_u32(count32, &mut self.0[5..9]);
+    }
+
+    /// Add an NFA state ID to this state. The order in which NFA states are
+    /// added matters. It is the caller's responsibility to ensure that
+    /// duplicate NFA state IDs are not added.
+    fn add_nfa_state_id(&mut self, prev: &mut StateID, sid: StateID) {
+        let delta = sid.as_i32() - prev.as_i32();
+        write_vari32(self.0, delta);
+        *prev = sid;
+    }
+
+    /// Return a read-only view of this state's representation.
+    fn repr(&self) -> Repr<'_> {
+        Repr(self.0.as_slice())
+    }
+}
+
+/// Write a signed 32-bit integer using zig-zag encoding.
+///
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn write_vari32(data: &mut Vec<u8>, n: i32) {
+    let mut un = n.to_bits() << 1;
+    if n < 0 {
+        un = !un;
+    }
+    write_varu32(data, un)
+}
+
+/// Read a signed 32-bit integer using zig-zag encoding. Also, return the
+/// number of bytes read.
+///
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn read_vari32(data: &[u8]) -> (i32, usize) {
+    let (un, i) = read_varu32(data);
+    let mut n = i32::from_bits(un >> 1);
+    if un & 1 != 0 {
+        n = !n;
+    }
+    (n, i)
+}
+
+/// Write an unsigned 32-bit integer as a varint. In essence, `n` is written
+/// as a sequence of bytes where all bytes except for the last one have the
+/// most significant bit set. The least significant 7 bits correspond to the
+/// actual bits of `n`. So in the worst case, a varint uses 5 bytes, but in
+/// very common cases, it uses fewer than 4.
+///
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn write_varu32(data: &mut Vec<u8>, mut n: u32) {
+    while n >= 0b1000_0000 {
+        data.push(n.low_u8() | 0b1000_0000);
+        n >>= 7;
+    }
+    data.push(n.low_u8());
+}
+
+/// Read an unsigned 32-bit varint. Also, return the number of bytes read.
+///
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn read_varu32(data: &[u8]) -> (u32, usize) {
+    // N.B. We can assume correctness here since we know that all varuints are
+    // written with write_varu32. Hence, the 'as' uses and unchecked arithmetic
+    // is all okay.
+    let mut n: u32 = 0;
+    let mut shift: u32 = 0;
+    for (i, &b) in data.iter().enumerate() {
+        if b < 0b1000_0000 {
+            return (n | (u32::from(b) << shift), i + 1);
+        }
+        n |= (u32::from(b) & 0b0111_1111) << shift;
+        shift += 7;
+    }
+    (0, 0)
+}
+
+/// Push a native-endian encoded `n` on to `dst`.
+fn write_u32(dst: &mut Vec<u8>, n: u32) {
+    use crate::util::wire::NE;
+
+    let start = dst.len();
+    dst.extend(core::iter::repeat(0).take(mem::size_of::<u32>()));
+    NE::write_u32(n, &mut dst[start..]);
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::vec;
+
+    use quickcheck::quickcheck;
+
+    use super::*;
+
+    #[cfg(not(miri))]
+    quickcheck! {
+        fn prop_state_read_write_nfa_state_ids(sids: Vec<StateID>) -> bool {
+            // Builders states do not permit duplicate IDs.
+            let sids = dedup_state_ids(sids);
+
+            let mut b = StateBuilderEmpty::new().into_matches().into_nfa();
+            for &sid in &sids {
+                b.add_nfa_state_id(sid);
+            }
+            let s = b.to_state();
+            let mut got = vec![];
+            s.iter_nfa_state_ids(|sid| got.push(sid));
+            got == sids
+        }
+
+        fn prop_state_read_write_pattern_ids(pids: Vec<PatternID>) -> bool {
+            // Builders states do not permit duplicate IDs.
+            let pids = dedup_pattern_ids(pids);
+
+            let mut b = StateBuilderEmpty::new().into_matches();
+            for &pid in &pids {
+                b.add_match_pattern_id(pid);
+            }
+            let s = b.into_nfa().to_state();
+            let mut got = vec![];
+            s.iter_match_pattern_ids(|pid| got.push(pid));
+            got == pids
+        }
+
+        fn prop_state_read_write_nfa_state_and_pattern_ids(
+            sids: Vec<StateID>,
+            pids: Vec<PatternID>
+        ) -> bool {
+            // Builders states do not permit duplicate IDs.
+            let sids = dedup_state_ids(sids);
+            let pids = dedup_pattern_ids(pids);
+
+            let mut b = StateBuilderEmpty::new().into_matches();
+            for &pid in &pids {
+                b.add_match_pattern_id(pid);
+            }
+
+            let mut b = b.into_nfa();
+            for &sid in &sids {
+                b.add_nfa_state_id(sid);
+            }
+
+            let s = b.to_state();
+            let mut got_pids = vec![];
+            s.iter_match_pattern_ids(|pid| got_pids.push(pid));
+            let mut got_sids = vec![];
+            s.iter_nfa_state_ids(|sid| got_sids.push(sid));
+            got_pids == pids && got_sids == sids
+        }
+    }
+
+    quickcheck! {
+        fn prop_read_write_varu32(n: u32) -> bool {
+            let mut buf = vec![];
+            write_varu32(&mut buf, n);
+            let (got, nread) = read_varu32(&buf);
+            nread == buf.len() && got == n
+        }
+
+        fn prop_read_write_vari32(n: i32) -> bool {
+            let mut buf = vec![];
+            write_vari32(&mut buf, n);
+            let (got, nread) = read_vari32(&buf);
+            nread == buf.len() && got == n
+        }
+    }
+
+    #[cfg(not(miri))]
+    fn dedup_state_ids(sids: Vec<StateID>) -> Vec<StateID> {
+        let mut set = alloc::collections::BTreeSet::new();
+        let mut deduped = vec![];
+        for sid in sids {
+            if set.contains(&sid) {
+                continue;
+            }
+            set.insert(sid);
+            deduped.push(sid);
+        }
+        deduped
+    }
+
+    #[cfg(not(miri))]
+    fn dedup_pattern_ids(pids: Vec<PatternID>) -> Vec<PatternID> {
+        let mut set = alloc::collections::BTreeSet::new();
+        let mut deduped = vec![];
+        for pid in pids {
+            if set.contains(&pid) {
+                continue;
+            }
+            set.insert(pid);
+            deduped.push(pid);
+        }
+        deduped
+    }
+}
diff --git a/regex-automata/src/util/empty.rs b/regex-automata/src/util/empty.rs
new file mode 100644
index 0000000000..e16af3b6e5
--- /dev/null
+++ b/regex-automata/src/util/empty.rs
@@ -0,0 +1,265 @@
+/*!
+This module provides helper routines for dealing with zero-width matches.
+
+The main problem being solved here is this:
+
+1. The caller wants to search something that they know is valid UTF-8, such
+as a Rust `&str`.
+2. The regex used by the caller can match the empty string. For example, `a*`.
+3. The caller should never get match offsets returned that occur within the
+encoding of a UTF-8 codepoint. It is logically incorrect, and also means that,
+e.g., slicing the `&str` at those offsets will lead to a panic.
+
+So the question here is, how do we prevent the caller from getting match
+offsets that split a codepoint? For example, strictly speaking, the regex `a*`
+matches `☃` at the positions `[0, 0]`, `[1, 1]`, `[2, 2]` and `[3, 3]` since
+the UTF-8 encoding of `☃` is `\xE2\x98\x83`. In particular, the `NFA` that
+underlies all of the matching engines in this crate doesn't have anything in
+its state graph that prevents matching between UTF-8 code units. Indeed, any
+engine derived from the `NFA` will match at those positions by virtue of the
+fact that the `NFA` is byte oriented. That is, its transitions are defined over
+bytes and the matching engines work by proceeding one byte at a time.
+
+(An alternative architecture would be to define the transitions in an `NFA`
+over codepoints, or `char`. And then make the matching engines proceed by
+decoding one codepoint at a time. This is a viable strategy, but it doesn't
+work for DFA matching engines because designing a fast and memory efficient
+transition table for an alphabet as large as Unicode is quite difficult. More
+to the point, the top-level `regex` crate supports matching on arbitrary bytes
+when Unicode mode is disabled and one is searching a `&[u8]`. So in that case,
+you can't just limit yourself to decoding codepoints and matching those. You
+really do need to be able to follow byte oriented transitions on the `NFA`.)
+
+In an older version of the regex crate, we handled this case not in the regex
+engine, but in the iterators over matches. Namely, since this case only arises
+when the match is empty, we "just" incremented the next starting position
+of the search by `N`, where `N` is the length of the codepoint encoded at
+the current position. The alternative or more "natural" solution of just
+incrementing by `1` would result in executing a search of `a*` on `☃` like
+this:
+
+* Start search at `0`.
+* Found match at `[0, 0]`.
+* Next start position is `0`.
+* To avoid an infinite loop, since it's an empty match, increment by `1`.
+* Start search at `1`.
+* Found match at `[1, 1]`. Oops.
+
+But if we instead incremented by `3` (the length in bytes of `☃`), then we get
+the following:
+
+* Start search at `0`.
+* Found match at `[0, 0]`.
+* Next start position is `0`.
+* To avoid an infinite loop, since it's an empty match, increment by `3`.
+* Start search at `3`.
+* Found match at `[3, 3]`.
+
+And we get the correct result. But does this technique work in all cases?
+Crucially, it requires that a zero-width match that splits a codepoint never
+occurs beyond the starting position of the search. Because if it did, merely
+incrementing the start position by the number of bytes in the codepoint at
+the current position wouldn't be enough. A zero-width match could just occur
+anywhere. It turns out that it is _almost_ true. We can convince ourselves by
+looking at all possible patterns that can match the empty string:
+
+* Patterns like `a*`, `a{0}`, `(?:)`, `a|` and `|a` all unconditionally match
+the empty string. That is, assuming there isn't an `a` at the current position,
+they will all match the empty string at the start of a search. There is no way
+to move past it because any other match would not be "leftmost."
+* `^` only matches at the beginning of the haystack, where the start position
+is `0`. Since we know we're searching valid UTF-8 (if it isn't valid UTF-8,
+then this entire problem goes away because it implies your string type supports
+invalid UTF-8 and thus must deal with offsets that not only split a codepoint
+but occur in entirely invalid UTF-8 somehow), it follows that `^` never matches
+between the code units of a codepoint because the start of a valid UTF-8 string
+is never within the encoding of a codepoint.
+* `$` basically the same logic as `^`, but for the end of a string. A valid
+UTF-8 string can't have an incomplete codepoint at the end of it.
+* `(?m:^)` follows similarly to `^`, but it can match immediately following
+a `\n`. However, since a `\n` is always a codepoint itself and can never
+appear within a codepoint, it follows that the position immediately following
+a `\n` in a string that is valid UTF-8 is guaranteed to not be between the
+code units of another codepoint. (One caveat here is that the line terminator
+for multi-line anchors can now be changed to any arbitrary byte, including
+things like `\x98` which might occur within a codepoint. However, this wasn't
+supported by the old regex crate. If it was, it pose the same problems as
+`(?-u:\B)`, as we'll discuss below.)
+* `(?m:$)` a similar argument as for `(?m:^)`. The only difference is that a
+`(?m:$)` matches just before a `\n`. But the same argument applies.
+* `(?Rm:^)` and `(?Rm:$)` weren't supported by the old regex crate, but the
+CRLF aware line anchors follow a similar argument as for `(?m:^)` and `(?m:$)`.
+Namely, since they only ever match at a boundary where one side is either a
+`\r` or a `\n`, neither of which can occur within a codepoint.
+* `\b` only matches at positions where both sides are valid codepoints, so
+this cannot split a codepoint.
+* `\B`, like `\b`, also only matches at positions where both sides are valid
+codepoints. So this cannot split a codepoint either.
+* `(?-u:\b)` matches only at positions where at least one side of it is an ASCII
+word byte. Since ASCII bytes cannot appear as code units in non-ASCII codepoints
+(one of the many amazing qualities of UTF-8), it follows that this too cannot
+split a codepoint.
+* `(?-u:\B)` finally represents a problem. It can matches between *any* two
+bytes that are either both word bytes or non-word bytes. Since code units like
+`\xE2` and `\x98` (from the UTF-8 encoding of `☃`) are both non-word bytes,
+`(?-u:\B)` will match at the position between them.
+
+Thus, our approach of incrementing one codepoint at a time after seeing an
+empty match is flawed because `(?-u:\B)` can result in an empty match that
+splits a codepoint at a position past the starting point of a search. For
+example, searching `(?-u:\B)` on `a☃` would produce the following matches: `[2,
+2]`, `[3, 3]` and `[4, 4]`. The positions at `0` and `1` don't match because
+they correspond to word boundaries since `a` is an ASCII word byte.
+
+So what did the old regex crate do to avoid this? It banned `(?-u:\B)` from
+regexes that could match `&str`. That might sound extreme, but a lot of other
+things were banned too. For example, all of `(?-u:.)`, `(?-u:[^a])` and
+`(?-u:\W)` can match invalid UTF-8 too, including individual code units with a
+codepoint. The key difference is that those expressions could never produce an
+empty match. That ban happens when translating an `Ast` to an `Hir`, because
+that process that reason about whether an `Hir` can produce *non-empty* matches
+at invalid UTF-8 boundaries. Bottom line though is that we side-stepped the
+`(?-u:\B)` issue by banning it.
+
+If banning `(?-u:\B)` were the only issue with the old regex crate's approach,
+then I probably would have kept it. `\B` is rarely used, so it's not such a big
+deal to have to work-around it. However, the problem with the above approach
+is that it doesn't compose. The logic for avoiding splitting a codepoint only
+lived in the iterator, which means if anyone wants to implement their own
+iterator over regex matches, they have to deal with this extremely subtle edge
+case to get full correctness.
+
+Instead, in this crate, we take the approach of pushing this complexity down
+to the lowest layers of each regex engine. The approach is pretty simple:
+
+* If this corner case doesn't apply, don't do anything. (For example, if UTF-8
+mode isn't enabled or if the regex cannot match the empty string.)
+* If an empty match is reported, explicitly check if it splits a codepoint.
+* If it doesn't, we're done, return the match.
+* If it does, then ignore the match and re-run the search.
+* Repeat the above process until the end of the haystack is reached or a match
+is found that doesn't split a codepoint or isn't zero width.
+
+And that's pretty much what this module provides. Every regex engine uses these
+methods in their lowest level public APIs, but just above the layer where
+their internal engine is used. That way, all regex engines can be arbitrarily
+composed without worrying about handling this case, and iterators don't need to
+handle it explicitly.
+
+(It turns out that a new feature I added, support for changing the line
+terminator in a regex to any arbitrary byte, also provokes the above problem.
+Namely, the byte could be invalid UTF-8 or a UTF-8 continuation byte. So that
+support would need to be limited or banned when UTF-8 mode is enabled, just
+like we did for `(?-u:\B)`. But thankfully our more robust approach in this
+crate handles that case just fine too.)
+*/
+
+use crate::util::search::{Input, MatchError};
+
+#[cold]
+#[inline(never)]
+pub(crate) fn skip_splits_fwd<T, F>(
+    input: &Input<'_>,
+    init_value: T,
+    match_offset: usize,
+    find: F,
+) -> Result<Option<T>, MatchError>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<(T, usize)>, MatchError>,
+{
+    skip_splits(true, input, init_value, match_offset, find)
+}
+
+#[cold]
+#[inline(never)]
+pub(crate) fn skip_splits_rev<T, F>(
+    input: &Input<'_>,
+    init_value: T,
+    match_offset: usize,
+    find: F,
+) -> Result<Option<T>, MatchError>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<(T, usize)>, MatchError>,
+{
+    skip_splits(false, input, init_value, match_offset, find)
+}
+
+fn skip_splits<T, F>(
+    forward: bool,
+    input: &Input<'_>,
+    init_value: T,
+    mut match_offset: usize,
+    mut find: F,
+) -> Result<Option<T>, MatchError>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<(T, usize)>, MatchError>,
+{
+    // If our config says to do an anchored search, then we're definitely
+    // done. We just need to determine whether we have a valid match or
+    // not. If we don't, then we're not allowed to continue, so we report
+    // no match.
+    //
+    // This is actually quite a subtle correctness thing. The key here is
+    // that if we got an empty match that splits a codepoint after doing an
+    // anchored search in UTF-8 mode, then that implies that we must have
+    // *started* the search at a location that splits a codepoint. This
+    // follows from the fact that if a match is reported from an anchored
+    // search, then the start offset of the match *must* match the start
+    // offset of the search.
+    //
+    // It also follows that no other non-empty match is possible. For
+    // example, you might write a regex like '(?:)|SOMETHING' and start its
+    // search in the middle of a codepoint. The first branch is an empty
+    // regex that will bubble up a match at the first position, and then
+    // get rejected here and report no match. But what if 'SOMETHING' could
+    // have matched? We reason that such a thing is impossible, because
+    // if it does, it must report a match that starts in the middle of a
+    // codepoint. This in turn implies that a match is reported whose span
+    // does not correspond to valid UTF-8, and this breaks the promise
+    // made when UTF-8 mode is enabled. (That promise *can* be broken, for
+    // example, by enabling UTF-8 mode but building an by hand NFA that
+    // produces non-empty matches that span invalid UTF-8. This is an unchecked
+    // but documented precondition violation of UTF-8 mode, and is documented
+    // to have unspecified behavior.)
+    //
+    // I believe this actually means that if an anchored search is run, and
+    // UTF-8 mode is enabled and the start position splits a codepoint,
+    // then it is correct to immediately report no match without even
+    // executing the regex engine. But it doesn't really seem worth writing
+    // out that case in every regex engine to save a tiny bit of work in an
+    // extremely pathological case, so we just handle it here.
+    if input.get_anchored().is_anchored() {
+        return Ok(if input.is_char_boundary(match_offset) {
+            Some(init_value)
+        } else {
+            None
+        });
+    }
+    // Otherwise, we have an unanchored search, so just keep looking for
+    // matches until we have one that does not split a codepoint or we hit
+    // EOI.
+    let mut value = init_value;
+    let mut input = input.clone();
+    while !input.is_char_boundary(match_offset) {
+        if forward {
+            // The unwrap is OK here because overflowing usize while
+            // iterating over a slice is impossible, at it would require
+            // a slice of length greater than isize::MAX, which is itself
+            // impossible.
+            input.set_start(input.start().checked_add(1).unwrap());
+        } else {
+            input.set_end(match input.end().checked_sub(1) {
+                None => return Ok(None),
+                Some(end) => end,
+            });
+        }
+        match find(&input)? {
+            None => return Ok(None),
+            Some((new_value, new_match_end)) => {
+                value = new_value;
+                match_offset = new_match_end;
+            }
+        }
+    }
+    Ok(Some(value))
+}
diff --git a/regex-automata/src/util/escape.rs b/regex-automata/src/util/escape.rs
new file mode 100644
index 0000000000..7f6aa15f5d
--- /dev/null
+++ b/regex-automata/src/util/escape.rs
@@ -0,0 +1,84 @@
+/*!
+Provides convenience routines for escaping raw bytes.
+
+Since this crate tends to deal with `&[u8]` everywhere and the default
+`Debug` implementation just shows decimal integers, it makes debugging those
+representations quite difficult. This module provides types that show `&[u8]`
+as if it were a string, with invalid UTF-8 escaped into its byte-by-byte hex
+representation.
+*/
+
+use crate::util::utf8;
+
+/// Provides a convenient `Debug` implementation for a `u8`.
+///
+/// The `Debug` impl treats the byte as an ASCII, and emits a human readable
+/// representation of it. If the byte isn't ASCII, then it's emitted as a hex
+/// escape sequence.
+#[derive(Clone, Copy)]
+pub struct DebugByte(pub u8);
+
+impl core::fmt::Debug for DebugByte {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        // Special case ASCII space. It's too hard to read otherwise, so
+        // put quotes around it. I sometimes wonder whether just '\x20' would
+        // be better...
+        if self.0 == b' ' {
+            return write!(f, "' '");
+        }
+        // 10 bytes is enough to cover any output from ascii::escape_default.
+        let mut bytes = [0u8; 10];
+        let mut len = 0;
+        for (i, mut b) in core::ascii::escape_default(self.0).enumerate() {
+            // capitalize \xab to \xAB
+            if i >= 2 && b'a' <= b && b <= b'f' {
+                b -= 32;
+            }
+            bytes[len] = b;
+            len += 1;
+        }
+        write!(f, "{}", core::str::from_utf8(&bytes[..len]).unwrap())
+    }
+}
+
+/// Provides a convenient `Debug` implementation for `&[u8]`.
+///
+/// This generally works best when the bytes are presumed to be mostly UTF-8,
+/// but will work for anything. For any bytes that aren't UTF-8, they are
+/// emitted as hex escape sequences.
+pub struct DebugHaystack<'a>(pub &'a [u8]);
+
+impl<'a> core::fmt::Debug for DebugHaystack<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "\"")?;
+        // This is a sad re-implementation of a similar impl found in bstr.
+        let mut bytes = self.0;
+        while let Some(result) = utf8::decode(bytes) {
+            let ch = match result {
+                Ok(ch) => ch,
+                Err(byte) => {
+                    write!(f, r"\x{:02x}", byte)?;
+                    bytes = &bytes[1..];
+                    continue;
+                }
+            };
+            bytes = &bytes[ch.len_utf8()..];
+            match ch {
+                '\0' => write!(f, "\\0")?,
+                // ASCII control characters except \0, \n, \r, \t
+                '\x01'..='\x08'
+                | '\x0b'
+                | '\x0c'
+                | '\x0e'..='\x19'
+                | '\x7f' => {
+                    write!(f, "\\x{:02x}", u32::from(ch))?;
+                }
+                '\n' | '\r' | '\t' | _ => {
+                    write!(f, "{}", ch.escape_debug())?;
+                }
+            }
+        }
+        write!(f, "\"")?;
+        Ok(())
+    }
+}
diff --git a/regex-automata/src/util/int.rs b/regex-automata/src/util/int.rs
new file mode 100644
index 0000000000..e6b13bff96
--- /dev/null
+++ b/regex-automata/src/util/int.rs
@@ -0,0 +1,252 @@
+/*!
+This module provides several integer oriented traits for converting between
+both fixed size integers and integers whose size varies based on the target
+(like `usize`).
+
+The driving design principle of this module is to attempt to centralize as many
+`as` casts as possible here. And in particular, we separate casts into two
+buckets:
+
+* Casts that we use for their truncating behavior. In this case, we use more
+descriptive names, like `low_u32` and `high_u32`.
+* Casts that we use for converting back-and-forth between `usize`. These
+conversions are generally necessary because we often store indices in different
+formats to save on memory, which requires converting to and from `usize`. In
+this case, we very specifically do not want to overflow, and so the methods
+defined here will panic if the `as` cast would be lossy in debug mode. (A
+normal `as` cast will never panic!)
+
+For `as` casts between raw pointers, we use `cast`, so `as` isn't needed there.
+
+For regex engines, floating point is just never used, so we don't have to worry
+about `as` casts for those.
+
+Otherwise, this module pretty much covers all of our `as` needs except for one
+thing: const contexts. There are a select few places in this crate where we
+still need to use `as` because const functions on traits aren't stable yet.
+If we wind up significantly expanding our const footprint in this crate, it
+might be worth defining free functions to handle those cases. But at the time
+of writing, that just seemed like too much ceremony. Instead, I comment each
+such use of `as` in a const context with a "fixme" notice.
+
+NOTE: for simplicity, we don't take target pointer width into account here for
+`usize` conversions. Since we currently only panic in debug mode, skipping the
+check when it can be proven it isn't needed at compile time doesn't really
+matter. Now, if we wind up wanting to do as many checks as possible in release
+mode, then we would want to skip those when we know the conversions are always
+non-lossy.
+
+NOTE: this module isn't an exhaustive API. For example, we still use things
+like `u64::from` where possible, or even `usize::try_from()` for when we do
+explicitly want to panic or when we want to return an error for overflow.
+*/
+
+pub(crate) trait U8 {
+    fn as_usize(self) -> usize;
+}
+
+impl U8 for u8 {
+    fn as_usize(self) -> usize {
+        usize::from(self)
+    }
+}
+
+pub(crate) trait U16 {
+    fn as_usize(self) -> usize;
+    fn low_u8(self) -> u8;
+    fn high_u8(self) -> u8;
+}
+
+impl U16 for u16 {
+    fn as_usize(self) -> usize {
+        usize::from(self)
+    }
+
+    fn low_u8(self) -> u8 {
+        self as u8
+    }
+
+    fn high_u8(self) -> u8 {
+        (self >> 8) as u8
+    }
+}
+
+pub(crate) trait U32 {
+    fn as_usize(self) -> usize;
+    fn low_u8(self) -> u8;
+    fn low_u16(self) -> u16;
+    fn high_u16(self) -> u16;
+}
+
+impl U32 for u32 {
+    fn as_usize(self) -> usize {
+        #[cfg(debug_assertions)]
+        {
+            usize::try_from(self).expect("u32 overflowed usize")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as usize
+        }
+    }
+
+    fn low_u8(self) -> u8 {
+        self as u8
+    }
+
+    fn low_u16(self) -> u16 {
+        self as u16
+    }
+
+    fn high_u16(self) -> u16 {
+        (self >> 16) as u16
+    }
+}
+
+pub(crate) trait U64 {
+    fn as_usize(self) -> usize;
+    fn low_u8(self) -> u8;
+    fn low_u16(self) -> u16;
+    fn low_u32(self) -> u32;
+    fn high_u32(self) -> u32;
+}
+
+impl U64 for u64 {
+    fn as_usize(self) -> usize {
+        #[cfg(debug_assertions)]
+        {
+            usize::try_from(self).expect("u64 overflowed usize")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as usize
+        }
+    }
+
+    fn low_u8(self) -> u8 {
+        self as u8
+    }
+
+    fn low_u16(self) -> u16 {
+        self as u16
+    }
+
+    fn low_u32(self) -> u32 {
+        self as u32
+    }
+
+    fn high_u32(self) -> u32 {
+        (self >> 32) as u32
+    }
+}
+
+pub(crate) trait I32 {
+    fn as_usize(self) -> usize;
+    fn to_bits(self) -> u32;
+    fn from_bits(n: u32) -> i32;
+}
+
+impl I32 for i32 {
+    fn as_usize(self) -> usize {
+        #[cfg(debug_assertions)]
+        {
+            usize::try_from(self).expect("i32 overflowed usize")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as usize
+        }
+    }
+
+    fn to_bits(self) -> u32 {
+        self as u32
+    }
+
+    fn from_bits(n: u32) -> i32 {
+        n as i32
+    }
+}
+
+pub(crate) trait Usize {
+    fn as_u8(self) -> u8;
+    fn as_u16(self) -> u16;
+    fn as_u32(self) -> u32;
+    fn as_u64(self) -> u64;
+}
+
+impl Usize for usize {
+    fn as_u8(self) -> u8 {
+        #[cfg(debug_assertions)]
+        {
+            u8::try_from(self).expect("usize overflowed u8")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as u8
+        }
+    }
+
+    fn as_u16(self) -> u16 {
+        #[cfg(debug_assertions)]
+        {
+            u16::try_from(self).expect("usize overflowed u16")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as u16
+        }
+    }
+
+    fn as_u32(self) -> u32 {
+        #[cfg(debug_assertions)]
+        {
+            u32::try_from(self).expect("usize overflowed u32")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as u32
+        }
+    }
+
+    fn as_u64(self) -> u64 {
+        #[cfg(debug_assertions)]
+        {
+            u64::try_from(self).expect("usize overflowed u64")
+        }
+        #[cfg(not(debug_assertions))]
+        {
+            self as u64
+        }
+    }
+}
+
+// Pointers aren't integers, but we convert pointers to integers to perform
+// offset arithmetic in some places. (And no, we don't convert the integers
+// back to pointers.) So add 'as_usize' conversions here too for completeness.
+//
+// These 'as' casts are actually okay because they're always non-lossy. But the
+// idea here is to just try and remove as much 'as' as possible, particularly
+// in this crate where we are being really paranoid about offsets and making
+// sure we don't panic on inputs that might be untrusted. This way, the 'as'
+// casts become easier to audit if they're all in one place, even when some of
+// them are actually okay 100% of the time.
+
+pub(crate) trait Pointer {
+    fn as_usize(self) -> usize;
+}
+
+impl<T> Pointer for *const T {
+    fn as_usize(self) -> usize {
+        self as usize
+    }
+}
+
+pub(crate) trait PointerMut {
+    fn as_usize(self) -> usize;
+}
+
+impl<T> PointerMut for *mut T {
+    fn as_usize(self) -> usize {
+        self as usize
+    }
+}
diff --git a/regex-automata/src/util/interpolate.rs b/regex-automata/src/util/interpolate.rs
new file mode 100644
index 0000000000..f274629df4
--- /dev/null
+++ b/regex-automata/src/util/interpolate.rs
@@ -0,0 +1,579 @@
+/*!
+Provides routines for interpolating capture group references.
+
+That is, if a replacement string contains references like `$foo` or `${foo1}`,
+then they are replaced with the corresponding capture values for the groups
+named `foo` and `foo1`, respectively. Similarly, syntax like `$1` and `${1}`
+is supported as well, with `1` corresponding to a capture group index and not
+a name.
+
+This module provides the free functions [`string`] and [`bytes`], which
+interpolate Rust Unicode strings and byte strings, respectively.
+
+# Format
+
+These routines support two different kinds of capture references: unbraced and
+braced.
+
+For the unbraced format, the format supported is `$ref` where `name` can be
+any character in the class `[0-9A-Za-z_]`. `ref` is always the longest
+possible parse. So for example, `$1a` corresponds to the capture group named
+`1a` and not the capture group at index `1`. If `ref` matches `^[0-9]+$`, then
+it is treated as a capture group index itself and not a name.
+
+For the braced format, the format supported is `${ref}` where `ref` can be any
+sequence of bytes except for `}`. If no closing brace occurs, then it is not
+considered a capture reference. As with the unbraced format, if `ref` matches
+`^[0-9]+$`, then it is treated as a capture group index and not a name.
+
+The braced format is useful for exerting precise control over the name of the
+capture reference. For example, `${1}a` corresponds to the capture group
+reference `1` followed by the letter `a`, where as `$1a` (as mentioned above)
+corresponds to the capture group reference `1a`. The braced format is also
+useful for expressing capture group names that use characters not supported by
+the unbraced format. For example, `${foo[bar].baz}` refers to the capture group
+named `foo[bar].baz`.
+
+If a capture group reference is found and it does not refer to a valid capture
+group, then it will be replaced with the empty string.
+
+To write a literal `$`, use `$$`.
+
+To be clear, and as exhibited via the type signatures in the routines in this
+module, it is impossible for a replacement string to be invalid. A replacement
+string may not have the intended semantics, but the interpolation procedure
+itself can never fail.
+*/
+
+use alloc::{string::String, vec::Vec};
+
+use crate::util::memchr::memchr;
+
+/// Accepts a replacement string and interpolates capture references with their
+/// corresponding values.
+///
+/// `append` should be a function that appends the string value of a capture
+/// group at a particular index to the string given. If the capture group
+/// index is invalid, then nothing should be appended.
+///
+/// `name_to_index` should be a function that maps a capture group name to a
+/// capture group index. If the given name doesn't exist, then `None` should
+/// be returned.
+///
+/// Finally, `dst` is where the final interpolated contents should be written.
+/// If `replacement` contains no capture group references, then `dst` will be
+/// equivalent to `replacement`.
+///
+/// See the [module documentation](self) for details about the format
+/// supported.
+///
+/// # Example
+///
+/// ```
+/// use regex_automata::util::interpolate;
+///
+/// let mut dst = String::new();
+/// interpolate::string(
+///     "foo $bar baz",
+///     |index, dst| {
+///         if index == 0 {
+///             dst.push_str("BAR");
+///         }
+///     },
+///     |name| {
+///         if name == "bar" {
+///             Some(0)
+///         } else {
+///             None
+///         }
+///     },
+///     &mut dst,
+/// );
+/// assert_eq!("foo BAR baz", dst);
+/// ```
+pub fn string(
+    mut replacement: &str,
+    mut append: impl FnMut(usize, &mut String),
+    mut name_to_index: impl FnMut(&str) -> Option<usize>,
+    dst: &mut String,
+) {
+    while !replacement.is_empty() {
+        match memchr(b'$', replacement.as_bytes()) {
+            None => break,
+            Some(i) => {
+                dst.push_str(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        // Handle escaping of '$'.
+        if replacement.as_bytes().get(1).map_or(false, |&b| b == b'$') {
+            dst.push_str("$");
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement.as_bytes()) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push_str("$");
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => append(i, dst),
+            Ref::Named(name) => {
+                if let Some(i) = name_to_index(name) {
+                    append(i, dst);
+                }
+            }
+        }
+    }
+    dst.push_str(replacement);
+}
+
+/// Accepts a replacement byte string and interpolates capture references with
+/// their corresponding values.
+///
+/// `append` should be a function that appends the byte string value of a
+/// capture group at a particular index to the byte string given. If the
+/// capture group index is invalid, then nothing should be appended.
+///
+/// `name_to_index` should be a function that maps a capture group name to a
+/// capture group index. If the given name doesn't exist, then `None` should
+/// be returned.
+///
+/// Finally, `dst` is where the final interpolated contents should be written.
+/// If `replacement` contains no capture group references, then `dst` will be
+/// equivalent to `replacement`.
+///
+/// See the [module documentation](self) for details about the format
+/// supported.
+///
+/// # Example
+///
+/// ```
+/// use regex_automata::util::interpolate;
+///
+/// let mut dst = vec![];
+/// interpolate::bytes(
+///     b"foo $bar baz",
+///     |index, dst| {
+///         if index == 0 {
+///             dst.extend_from_slice(b"BAR");
+///         }
+///     },
+///     |name| {
+///         if name == "bar" {
+///             Some(0)
+///         } else {
+///             None
+///         }
+///     },
+///     &mut dst,
+/// );
+/// assert_eq!(&b"foo BAR baz"[..], dst);
+/// ```
+pub fn bytes(
+    mut replacement: &[u8],
+    mut append: impl FnMut(usize, &mut Vec<u8>),
+    mut name_to_index: impl FnMut(&str) -> Option<usize>,
+    dst: &mut Vec<u8>,
+) {
+    while !replacement.is_empty() {
+        match memchr(b'$', replacement) {
+            None => break,
+            Some(i) => {
+                dst.extend_from_slice(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        // Handle escaping of '$'.
+        if replacement.get(1).map_or(false, |&b| b == b'$') {
+            dst.push(b'$');
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push(b'$');
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => append(i, dst),
+            Ref::Named(name) => {
+                if let Some(i) = name_to_index(name) {
+                    append(i, dst);
+                }
+            }
+        }
+    }
+    dst.extend_from_slice(replacement);
+}
+
+/// `CaptureRef` represents a reference to a capture group inside some text.
+/// The reference is either a capture group name or a number.
+///
+/// It is also tagged with the position in the text following the
+/// capture reference.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct CaptureRef<'a> {
+    cap: Ref<'a>,
+    end: usize,
+}
+
+/// A reference to a capture group in some text.
+///
+/// e.g., `$2`, `$foo`, `${foo}`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Ref<'a> {
+    Named(&'a str),
+    Number(usize),
+}
+
+impl<'a> From<&'a str> for Ref<'a> {
+    fn from(x: &'a str) -> Ref<'a> {
+        Ref::Named(x)
+    }
+}
+
+impl From<usize> for Ref<'static> {
+    fn from(x: usize) -> Ref<'static> {
+        Ref::Number(x)
+    }
+}
+
+/// Parses a possible reference to a capture group name in the given text,
+/// starting at the beginning of `replacement`.
+///
+/// If no such valid reference could be found, None is returned.
+///
+/// Note that this returns a "possible" reference because this routine doesn't
+/// know whether the reference is to a valid group or not. If it winds up not
+/// being a valid reference, then it should be replaced with the empty string.
+fn find_cap_ref(replacement: &[u8]) -> Option<CaptureRef<'_>> {
+    let mut i = 0;
+    let rep: &[u8] = replacement;
+    if rep.len() <= 1 || rep[0] != b'$' {
+        return None;
+    }
+    i += 1;
+    if rep[i] == b'{' {
+        return find_cap_ref_braced(rep, i + 1);
+    }
+    let mut cap_end = i;
+    while rep.get(cap_end).copied().map_or(false, is_valid_cap_letter) {
+        cap_end += 1;
+    }
+    if cap_end == i {
+        return None;
+    }
+    // We just verified that the range 0..cap_end is valid ASCII, so it must
+    // therefore be valid UTF-8. If we really cared, we could avoid this UTF-8
+    // check via an unchecked conversion or by parsing the number straight from
+    // &[u8].
+    let cap = core::str::from_utf8(&rep[i..cap_end])
+        .expect("valid UTF-8 capture name");
+    Some(CaptureRef {
+        cap: match cap.parse::<usize>() {
+            Ok(i) => Ref::Number(i),
+            Err(_) => Ref::Named(cap),
+        },
+        end: cap_end,
+    })
+}
+
+/// Looks for a braced reference, e.g., `${foo1}`. This assumes that an opening
+/// brace has been found at `i-1` in `rep`. This then looks for a closing
+/// brace and returns the capture reference within the brace.
+fn find_cap_ref_braced(rep: &[u8], mut i: usize) -> Option<CaptureRef<'_>> {
+    assert_eq!(b'{', rep[i.checked_sub(1).unwrap()]);
+    let start = i;
+    while rep.get(i).map_or(false, |&b| b != b'}') {
+        i += 1;
+    }
+    if !rep.get(i).map_or(false, |&b| b == b'}') {
+        return None;
+    }
+    // When looking at braced names, we don't put any restrictions on the name,
+    // so it's possible it could be invalid UTF-8. But a capture group name
+    // can never be invalid UTF-8, so if we have invalid UTF-8, then we can
+    // safely return None.
+    let cap = match core::str::from_utf8(&rep[start..i]) {
+        Err(_) => return None,
+        Ok(cap) => cap,
+    };
+    Some(CaptureRef {
+        cap: match cap.parse::<usize>() {
+            Ok(i) => Ref::Number(i),
+            Err(_) => Ref::Named(cap),
+        },
+        end: i + 1,
+    })
+}
+
+/// Returns true if and only if the given byte is allowed in a capture name
+/// written in non-brace form.
+fn is_valid_cap_letter(b: u8) -> bool {
+    match b {
+        b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_' => true,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::{string::String, vec, vec::Vec};
+
+    use super::{find_cap_ref, CaptureRef};
+
+    macro_rules! find {
+        ($name:ident, $text:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(None, find_cap_ref($text.as_bytes()));
+            }
+        };
+        ($name:ident, $text:expr, $capref:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(Some($capref), find_cap_ref($text.as_bytes()));
+            }
+        };
+    }
+
+    macro_rules! c {
+        ($name_or_number:expr, $pos:expr) => {
+            CaptureRef { cap: $name_or_number.into(), end: $pos }
+        };
+    }
+
+    find!(find_cap_ref1, "$foo", c!("foo", 4));
+    find!(find_cap_ref2, "${foo}", c!("foo", 6));
+    find!(find_cap_ref3, "$0", c!(0, 2));
+    find!(find_cap_ref4, "$5", c!(5, 2));
+    find!(find_cap_ref5, "$10", c!(10, 3));
+    // See https://github.com/rust-lang/regex/pull/585
+    // for more on characters following numbers
+    find!(find_cap_ref6, "$42a", c!("42a", 4));
+    find!(find_cap_ref7, "${42}a", c!(42, 5));
+    find!(find_cap_ref8, "${42");
+    find!(find_cap_ref9, "${42 ");
+    find!(find_cap_ref10, " $0 ");
+    find!(find_cap_ref11, "$");
+    find!(find_cap_ref12, " ");
+    find!(find_cap_ref13, "");
+    find!(find_cap_ref14, "$1-$2", c!(1, 2));
+    find!(find_cap_ref15, "$1_$2", c!("1_", 3));
+    find!(find_cap_ref16, "$x-$y", c!("x", 2));
+    find!(find_cap_ref17, "$x_$y", c!("x_", 3));
+    find!(find_cap_ref18, "${#}", c!("#", 4));
+    find!(find_cap_ref19, "${Z[}", c!("Z[", 5));
+    find!(find_cap_ref20, "${¾}", c!("¾", 5));
+    find!(find_cap_ref21, "${¾a}", c!("¾a", 6));
+    find!(find_cap_ref22, "${a¾}", c!("a¾", 6));
+    find!(find_cap_ref23, "${☃}", c!("☃", 6));
+    find!(find_cap_ref24, "${a☃}", c!("a☃", 7));
+    find!(find_cap_ref25, "${☃a}", c!("☃a", 7));
+    find!(find_cap_ref26, "${名字}", c!("名字", 9));
+
+    fn interpolate_string(
+        mut name_to_index: Vec<(&'static str, usize)>,
+        caps: Vec<&'static str>,
+        replacement: &str,
+    ) -> String {
+        name_to_index.sort_by_key(|x| x.0);
+
+        let mut dst = String::new();
+        super::string(
+            replacement,
+            |i, dst| {
+                if let Some(&s) = caps.get(i) {
+                    dst.push_str(s);
+                }
+            },
+            |name| -> Option<usize> {
+                name_to_index
+                    .binary_search_by_key(&name, |x| x.0)
+                    .ok()
+                    .map(|i| name_to_index[i].1)
+            },
+            &mut dst,
+        );
+        dst
+    }
+
+    fn interpolate_bytes(
+        mut name_to_index: Vec<(&'static str, usize)>,
+        caps: Vec<&'static str>,
+        replacement: &str,
+    ) -> String {
+        name_to_index.sort_by_key(|x| x.0);
+
+        let mut dst = vec![];
+        super::bytes(
+            replacement.as_bytes(),
+            |i, dst| {
+                if let Some(&s) = caps.get(i) {
+                    dst.extend_from_slice(s.as_bytes());
+                }
+            },
+            |name| -> Option<usize> {
+                name_to_index
+                    .binary_search_by_key(&name, |x| x.0)
+                    .ok()
+                    .map(|i| name_to_index[i].1)
+            },
+            &mut dst,
+        );
+        String::from_utf8(dst).unwrap()
+    }
+
+    macro_rules! interp {
+        ($name:ident, $map:expr, $caps:expr, $hay:expr, $expected:expr $(,)*) => {
+            #[test]
+            fn $name() {
+                assert_eq!(
+                    $expected,
+                    interpolate_string($map, $caps, $hay),
+                    "interpolate::string failed",
+                );
+                assert_eq!(
+                    $expected,
+                    interpolate_bytes($map, $caps, $hay),
+                    "interpolate::bytes failed",
+                );
+            }
+        };
+    }
+
+    interp!(
+        interp1,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $foo test",
+        "test xxx test",
+    );
+
+    interp!(
+        interp2,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test$footest",
+        "test",
+    );
+
+    interp!(
+        interp3,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test${foo}test",
+        "testxxxtest",
+    );
+
+    interp!(
+        interp4,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test$2test",
+        "test",
+    );
+
+    interp!(
+        interp5,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test${2}test",
+        "testxxxtest",
+    );
+
+    interp!(
+        interp6,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $$foo test",
+        "test $foo test",
+    );
+
+    interp!(
+        interp7,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $foo",
+        "test xxx",
+    );
+
+    interp!(
+        interp8,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "$foo test",
+        "xxx test",
+    );
+
+    interp!(
+        interp9,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test $bar$foo",
+        "test yyyxxx",
+    );
+
+    interp!(
+        interp10,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test $ test",
+        "test $ test",
+    );
+
+    interp!(
+        interp11,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${} test",
+        "test  test",
+    );
+
+    interp!(
+        interp12,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${ } test",
+        "test  test",
+    );
+
+    interp!(
+        interp13,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${a b} test",
+        "test  test",
+    );
+
+    interp!(
+        interp14,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${a} test",
+        "test  test",
+    );
+
+    // This is a funny case where a braced reference is never closed, but
+    // within the unclosed braced reference, there is an unbraced reference.
+    // In this case, the braced reference is just treated literally and the
+    // unbraced reference is found.
+    interp!(
+        interp15,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${wat $bar ok",
+        "test ${wat yyy ok",
+    );
+}
diff --git a/regex-automata/src/util/iter.rs b/regex-automata/src/util/iter.rs
new file mode 100644
index 0000000000..4fda8dc4cb
--- /dev/null
+++ b/regex-automata/src/util/iter.rs
@@ -0,0 +1,1027 @@
+/*!
+Generic helpers for iteration of matches from a regex engine in a haystack.
+
+The principle type in this module is a [`Searcher`]. A `Searcher` provides
+its own lower level iterater-like API in addition to methods for constructing
+types that implement `Iterator`. The documentation for `Searcher` explains a
+bit more about why these different APIs exist.
+
+Currently, this module supports iteration over any regex engine that works
+with the [`HalfMatch`], [`Match`] or [`Captures`] types.
+*/
+
+#[cfg(feature = "alloc")]
+use crate::util::captures::Captures;
+use crate::util::search::{HalfMatch, Input, Match, MatchError};
+
+/// A searcher for creating iterators and performing lower level iteration.
+///
+/// This searcher encapsulates the logic required for finding all successive
+/// non-overlapping matches in a haystack. In theory, iteration would look
+/// something like this:
+///
+/// 1. Setting the start position to `0`.
+/// 2. Execute a regex search. If no match, end iteration.
+/// 3. Report the match and set the start position to the end of the match.
+/// 4. Go back to (2).
+///
+/// And if this were indeed the case, it's likely that `Searcher` wouldn't
+/// exist. Unfortunately, because a regex may match the empty string, the above
+/// logic won't work for all possible regexes. Namely, if an empty match is
+/// found, then step (3) would set the start position of the search to the
+/// position it was at. Thus, iteration would never end.
+///
+/// Instead, a `Searcher` knows how to detect these cases and forcefully
+/// advance iteration in the case of an empty match that overlaps with a
+/// previous match.
+///
+/// If you know that your regex cannot match any empty string, then the simple
+/// algorithm described above will work correctly.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// In particular, a `Searcher` is not itself an iterator. Instead, it provides
+/// `advance` routines that permit moving the search along explicitly. It also
+/// provides various routines, like [`Searcher::into_matches_iter`], that
+/// accept a closure (representing how a regex engine executes a search) and
+/// returns a conventional iterator.
+///
+/// The lifetime parameters come from the [`Input`] type passed to
+/// [`Searcher::new`]:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// # Searcher vs Iterator
+///
+/// Why does a search type with "advance" APIs exist at all when we also have
+/// iterators? Unfortunately, the reasoning behind this split is a complex
+/// combination of the following things:
+///
+/// 1. While many of the regex engines expose their own iterators, it is also
+/// nice to expose this lower level iteration helper because it permits callers
+/// to provide their own `Input` configuration. Moreover, a `Searcher` can work
+/// with _any_ regex engine instead of only the ones defined in this crate.
+/// This way, everyone benefits from a shared iteration implementation.
+/// 2. There are many different regex engines that, while they have the same
+/// match semantics, they have slightly different APIs. Iteration is just
+/// complex enough to want to share code, and so we need a way of abstracting
+/// over those different regex engines. While we could define a new trait that
+/// describes any regex engine search API, it would wind up looking very close
+/// to a closure. While there may still be reasons for the more generic trait
+/// to exist, for now and for the purposes of iteration, we use a closure.
+/// Closures also provide a lot of easy flexibility at the call site, in that
+/// they permit the caller to borrow any kind of state they want for use during
+/// each search call.
+/// 3. As a result of using closures, and because closures are anonymous types
+/// that cannot be named, it is difficult to encapsulate them without both
+/// costs to speed and added complexity to the public API. For example, in
+/// defining an iterator type like
+/// [`dfa::regex::FindMatches`](crate::dfa::regex::FindMatches),
+/// if we use a closure internally, it's not possible to name this type in the
+/// return type of the iterator constructor. Thus, the only way around it is
+/// to erase the type by boxing it and turning it into a `Box<dyn FnMut ...>`.
+/// This boxed closure is unlikely to be inlined _and_ it infects the public
+/// API in subtle ways. Namely, unless you declare the closure as implementing
+/// `Send` and `Sync`, then the resulting iterator type won't implement it
+/// either. But there are practical issues with requiring the closure to
+/// implement `Send` and `Sync` that result in other API complexities that
+/// are beyond the scope of this already long exposition.
+/// 4. Some regex engines expose more complex match information than just
+/// "which pattern matched" and "at what offsets." For example, the PikeVM
+/// exposes match spans for each capturing group that participated in the
+/// match. In such cases, it can be quite beneficial to reuse the capturing
+/// group allocation on subsequent searches. A proper iterator doesn't permit
+/// this API due to its interface, so it's useful to have something a bit lower
+/// level that permits callers to amortize allocations while also reusing a
+/// shared implementation of iteration. (See the documentation for
+/// [`Searcher::advance`] for an example of using the "advance" API with the
+/// PikeVM.)
+///
+/// What this boils down to is that there are "advance" APIs which require
+/// handing a closure to it for every call, and there are also APIs to create
+/// iterators from a closure. The former are useful for _implementing_
+/// iterators or when you need more flexibility, while the latter are useful
+/// for conveniently writing custom iterators on-the-fly.
+///
+/// # Example: iterating with captures
+///
+/// Several regex engines in this crate over convenient iterator APIs over
+/// [`Captures`] values. To do so, this requires allocating a new `Captures`
+/// value for each iteration step. This can perhaps be more costly than you
+/// might want. Instead of implementing your own iterator to avoid that
+/// cost (which can be a little subtle if you want to handle empty matches
+/// correctly), you can use this `Searcher` to do it for you:
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     util::iter::Searcher,
+///     Input, Span,
+/// };
+///
+/// let re = PikeVM::new("foo(?P<numbers>[0-9]+)")?;
+/// let haystack = "foo1 foo12 foo123";
+///
+/// let mut caps = re.create_captures();
+/// let mut cache = re.create_cache();
+/// let mut matches = vec![];
+/// let mut searcher = Searcher::new(Input::new(haystack));
+/// while let Some(_) = searcher.advance(|input| {
+///     re.search(&mut cache, input, &mut caps);
+///     Ok(caps.get_match())
+/// }) {
+///     // The unwrap is OK since 'numbers' matches if the pattern matches.
+///     matches.push(caps.get_group_by_name("numbers").unwrap());
+/// }
+/// assert_eq!(matches, vec![
+///     Span::from(3..4),
+///     Span::from(8..10),
+///     Span::from(14..17),
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Searcher<'h> {
+    /// The input parameters to give to each regex engine call.
+    ///
+    /// The start position of the search is mutated during iteration.
+    input: Input<'h>,
+    /// Records the end offset of the most recent match. This is necessary to
+    /// handle a corner case for preventing empty matches from overlapping with
+    /// the ending bounds of a prior match.
+    last_match_end: Option<usize>,
+}
+
+impl<'h> Searcher<'h> {
+    /// Create a new fallible non-overlapping matches iterator.
+    ///
+    /// The given `input` provides the parameters (including the haystack),
+    /// while the `finder` represents a closure that calls the underlying regex
+    /// engine. The closure may borrow any additional state that is needed,
+    /// such as a prefilter scanner.
+    pub fn new(input: Input<'h>) -> Searcher<'h> {
+        Searcher { input, last_match_end: None }
+    }
+
+    /// Returns the current `Input` used by this searcher.
+    ///
+    /// The `Input` returned is generally equivalent to the one given to
+    /// [`Searcher::new`], but its start position may be different to reflect
+    /// the start of the next search to be executed.
+    pub fn input<'s>(&'s self) -> &'s Input<'h> {
+        &self.input
+    }
+
+    /// Return the next half match for an infallible search if one exists, and
+    /// advance to the next position.
+    ///
+    /// This is like `try_advance_half`, except errors are converted into
+    /// panics.
+    ///
+    /// # Panics
+    ///
+    /// If the given closure returns an error, then this panics. This is useful
+    /// when you know your underlying regex engine has been configured to not
+    /// return an error.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use a `Searcher` to iterate over all matches
+    /// when using a DFA, which only provides "half" matches.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     util::iter::Searcher,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let re = DFA::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");
+    /// let mut it = Searcher::new(input);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 10));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 21));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 32));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = None;
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This correctly moves iteration forward even when an empty match occurs:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     util::iter::Searcher,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let re = DFA::new(r"a|")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("abba");
+    /// let mut it = Searcher::new(input);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 1));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 2));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(HalfMatch::must(0, 4));
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = None;
+    /// let got = it.advance_half(|input| re.try_search_fwd(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn advance_half<F>(&mut self, finder: F) -> Option<HalfMatch>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+    {
+        match self.try_advance_half(finder) {
+            Ok(m) => m,
+            Err(err) => panic!(
+                "unexpected regex half find error: {}\n\
+                 to handle find errors, use 'try' or 'search' methods",
+                err,
+            ),
+        }
+    }
+
+    /// Return the next match for an infallible search if one exists, and
+    /// advance to the next position.
+    ///
+    /// The search is advanced even in the presence of empty matches by
+    /// forbidding empty matches from overlapping with any other match.
+    ///
+    /// This is like `try_advance`, except errors are converted into panics.
+    ///
+    /// # Panics
+    ///
+    /// If the given closure returns an error, then this panics. This is useful
+    /// when you know your underlying regex engine has been configured to not
+    /// return an error.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use a `Searcher` to iterate over all matches
+    /// when using a regex based on lazy DFAs:
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::regex::Regex,
+    ///     util::iter::Searcher,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");
+    /// let mut it = Searcher::new(input);
+    ///
+    /// let expected = Some(Match::must(0, 0..10));
+    /// let got = it.advance(|input| re.try_search(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(Match::must(0, 11..21));
+    /// let got = it.advance(|input| re.try_search(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(Match::must(0, 22..32));
+    /// let got = it.advance(|input| re.try_search(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = None;
+    /// let got = it.advance(|input| re.try_search(&mut cache, input));
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This example shows the same as above, but with the PikeVM. This example
+    /// is useful because it shows how to use this API even when the regex
+    /// engine doesn't directly return a `Match`.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::iter::Searcher,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = PikeVM::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");
+    /// let mut it = Searcher::new(input);
+    ///
+    /// let expected = Some(Match::must(0, 0..10));
+    /// let got = it.advance(|input| {
+    ///     re.search(&mut cache, input, &mut caps);
+    ///     Ok(caps.get_match())
+    /// });
+    /// // Note that if we wanted to extract capturing group spans, we could
+    /// // do that here with 'caps'.
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(Match::must(0, 11..21));
+    /// let got = it.advance(|input| {
+    ///     re.search(&mut cache, input, &mut caps);
+    ///     Ok(caps.get_match())
+    /// });
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = Some(Match::must(0, 22..32));
+    /// let got = it.advance(|input| {
+    ///     re.search(&mut cache, input, &mut caps);
+    ///     Ok(caps.get_match())
+    /// });
+    /// assert_eq!(expected, got);
+    ///
+    /// let expected = None;
+    /// let got = it.advance(|input| {
+    ///     re.search(&mut cache, input, &mut caps);
+    ///     Ok(caps.get_match())
+    /// });
+    /// assert_eq!(expected, got);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn advance<F>(&mut self, finder: F) -> Option<Match>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+    {
+        match self.try_advance(finder) {
+            Ok(m) => m,
+            Err(err) => panic!(
+                "unexpected regex find error: {}\n\
+                 to handle find errors, use 'try' or 'search' methods",
+                err,
+            ),
+        }
+    }
+
+    /// Return the next half match for a fallible search if one exists, and
+    /// advance to the next position.
+    ///
+    /// This is like `advance_half`, except it permits callers to handle errors
+    /// during iteration.
+    #[inline]
+    pub fn try_advance_half<F>(
+        &mut self,
+        mut finder: F,
+    ) -> Result<Option<HalfMatch>, MatchError>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+    {
+        let mut m = match finder(&self.input)? {
+            None => return Ok(None),
+            Some(m) => m,
+        };
+        if Some(m.offset()) == self.last_match_end {
+            m = match self.handle_overlapping_empty_half_match(m, finder)? {
+                None => return Ok(None),
+                Some(m) => m,
+            };
+        }
+        self.input.set_start(m.offset());
+        self.last_match_end = Some(m.offset());
+        Ok(Some(m))
+    }
+
+    /// Return the next match for a fallible search if one exists, and advance
+    /// to the next position.
+    ///
+    /// This is like `advance`, except it permits callers to handle errors
+    /// during iteration.
+    #[inline]
+    pub fn try_advance<F>(
+        &mut self,
+        mut finder: F,
+    ) -> Result<Option<Match>, MatchError>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+    {
+        let mut m = match finder(&self.input)? {
+            None => return Ok(None),
+            Some(m) => m,
+        };
+        if m.is_empty() && Some(m.end()) == self.last_match_end {
+            m = match self.handle_overlapping_empty_match(m, finder)? {
+                None => return Ok(None),
+                Some(m) => m,
+            };
+        }
+        self.input.set_start(m.end());
+        self.last_match_end = Some(m.end());
+        Ok(Some(m))
+    }
+
+    /// Given a closure that executes a single search, return an iterator over
+    /// all successive non-overlapping half matches.
+    ///
+    /// The iterator returned yields result values. If the underlying regex
+    /// engine is configured to never return an error, consider calling
+    /// [`TryHalfMatchesIter::infallible`] to convert errors into panics.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use a `Searcher` to create a proper
+    /// iterator over half matches.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::dfa::DFA,
+    ///     util::iter::Searcher,
+    ///     HalfMatch, Input,
+    /// };
+    ///
+    /// let re = DFA::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");
+    /// let mut it = Searcher::new(input).into_half_matches_iter(|input| {
+    ///     re.try_search_fwd(&mut cache, input)
+    /// });
+    ///
+    /// let expected = Some(Ok(HalfMatch::must(0, 10)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = Some(Ok(HalfMatch::must(0, 21)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = Some(Ok(HalfMatch::must(0, 32)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = None;
+    /// assert_eq!(expected, it.next());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn into_half_matches_iter<F>(
+        self,
+        finder: F,
+    ) -> TryHalfMatchesIter<'h, F>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+    {
+        TryHalfMatchesIter { it: self, finder }
+    }
+
+    /// Given a closure that executes a single search, return an iterator over
+    /// all successive non-overlapping matches.
+    ///
+    /// The iterator returned yields result values. If the underlying regex
+    /// engine is configured to never return an error, consider calling
+    /// [`TryMatchesIter::infallible`] to convert errors into panics.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use a `Searcher` to create a proper
+    /// iterator over matches.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     hybrid::regex::Regex,
+    ///     util::iter::Searcher,
+    ///     Match, Input,
+    /// };
+    ///
+    /// let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// let input = Input::new("2010-03-14 2016-10-08 2020-10-22");
+    /// let mut it = Searcher::new(input).into_matches_iter(|input| {
+    ///     re.try_search(&mut cache, input)
+    /// });
+    ///
+    /// let expected = Some(Ok(Match::must(0, 0..10)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = Some(Ok(Match::must(0, 11..21)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = Some(Ok(Match::must(0, 22..32)));
+    /// assert_eq!(expected, it.next());
+    ///
+    /// let expected = None;
+    /// assert_eq!(expected, it.next());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn into_matches_iter<F>(self, finder: F) -> TryMatchesIter<'h, F>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+    {
+        TryMatchesIter { it: self, finder }
+    }
+
+    /// Given a closure that executes a single search, return an iterator over
+    /// all successive non-overlapping `Captures` values.
+    ///
+    /// The iterator returned yields result values. If the underlying regex
+    /// engine is configured to never return an error, consider calling
+    /// [`TryCapturesIter::infallible`] to convert errors into panics.
+    ///
+    /// Unlike the other iterator constructors, this accepts an initial
+    /// `Captures` value. This `Captures` value is reused for each search, and
+    /// the iterator implementation clones it before returning it. The caller
+    /// must provide this value because the iterator is purposely ignorant
+    /// of the underlying regex engine and thus doesn't know how to create
+    /// one itself. More to the point, a `Captures` value itself has a few
+    /// different constructors, which change which kind of information is
+    /// available to query in exchange for search performance.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to use a `Searcher` to create a proper iterator
+    /// over `Captures` values, which provides access to all capturing group
+    /// spans for each match.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     util::iter::Searcher,
+    ///     Input,
+    /// };
+    ///
+    /// let re = PikeVM::new(
+    ///     r"(?P<y>[0-9]{4})-(?P<m>[0-9]{2})-(?P<d>[0-9]{2})",
+    /// )?;
+    /// let (mut cache, caps) = (re.create_cache(), re.create_captures());
+    ///
+    /// let haystack = "2010-03-14 2016-10-08 2020-10-22";
+    /// let input = Input::new(haystack);
+    /// let mut it = Searcher::new(input)
+    ///     .into_captures_iter(caps, |input, caps| {
+    ///         re.search(&mut cache, input, caps);
+    ///         Ok(())
+    ///     });
+    ///
+    /// let got = it.next().expect("first date")?;
+    /// let year = got.get_group_by_name("y").expect("must match");
+    /// assert_eq!("2010", &haystack[year]);
+    ///
+    /// let got = it.next().expect("second date")?;
+    /// let month = got.get_group_by_name("m").expect("must match");
+    /// assert_eq!("10", &haystack[month]);
+    ///
+    /// let got = it.next().expect("third date")?;
+    /// let day = got.get_group_by_name("d").expect("must match");
+    /// assert_eq!("22", &haystack[day]);
+    ///
+    /// assert!(it.next().is_none());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "alloc")]
+    #[inline]
+    pub fn into_captures_iter<F>(
+        self,
+        caps: Captures,
+        finder: F,
+    ) -> TryCapturesIter<'h, F>
+    where
+        F: FnMut(&Input<'_>, &mut Captures) -> Result<(), MatchError>,
+    {
+        TryCapturesIter { it: self, caps, finder }
+    }
+
+    /// Handles the special case of a match that begins where the previous
+    /// match ended. Without this special handling, it'd be possible to get
+    /// stuck where an empty match never results in forward progress. This
+    /// also makes it more consistent with how presiding general purpose regex
+    /// engines work.
+    #[cold]
+    #[inline(never)]
+    fn handle_overlapping_empty_half_match<F>(
+        &mut self,
+        _: HalfMatch,
+        mut finder: F,
+    ) -> Result<Option<HalfMatch>, MatchError>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+    {
+        // Since we are only here when 'm.offset()' matches the offset of the
+        // last match, it follows that this must have been an empty match.
+        // Since we both need to make progress *and* prevent overlapping
+        // matches, we discard this match and advance the search by 1.
+        //
+        // Note that this may start a search in the middle of a codepoint. The
+        // regex engines themselves are expected to deal with that and not
+        // report any matches within a codepoint if they are configured in
+        // UTF-8 mode.
+        self.input.set_start(self.input.start().checked_add(1).unwrap());
+        finder(&self.input)
+    }
+
+    /// Handles the special case of an empty match by ensuring that 1) the
+    /// iterator always advances and 2) empty matches never overlap with other
+    /// matches.
+    ///
+    /// (1) is necessary because we principally make progress by setting the
+    /// starting location of the next search to the ending location of the last
+    /// match. But if a match is empty, then this results in a search that does
+    /// not advance and thus does not terminate.
+    ///
+    /// (2) is not strictly necessary, but makes intuitive sense and matches
+    /// the presiding behavior of most general purpose regex engines. The
+    /// "intuitive sense" here is that we want to report NON-overlapping
+    /// matches. So for example, given the regex 'a|(?:)' against the haystack
+    /// 'a', without the special handling, you'd get the matches [0, 1) and [1,
+    /// 1), where the latter overlaps with the end bounds of the former.
+    ///
+    /// Note that we mark this cold and forcefully prevent inlining because
+    /// handling empty matches like this is extremely rare and does require
+    /// quite a bit of code, comparatively. Keeping this code out of the main
+    /// iterator function keeps it smaller and more amenable to inlining
+    /// itself.
+    #[cold]
+    #[inline(never)]
+    fn handle_overlapping_empty_match<F>(
+        &mut self,
+        m: Match,
+        mut finder: F,
+    ) -> Result<Option<Match>, MatchError>
+    where
+        F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+    {
+        assert!(m.is_empty());
+        self.input.set_start(self.input.start().checked_add(1).unwrap());
+        finder(&self.input)
+    }
+}
+
+/// An iterator over all non-overlapping half matches for a fallible search.
+///
+/// The iterator yields a `Result<HalfMatch, MatchError>` value until no more
+/// matches could be found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_half_matches_iter`].
+pub struct TryHalfMatchesIter<'h, F> {
+    it: Searcher<'h>,
+    finder: F,
+}
+
+impl<'h, F> TryHalfMatchesIter<'h, F> {
+    /// Return an infallible version of this iterator.
+    ///
+    /// Any item yielded that corresponds to an error results in a panic. This
+    /// is useful if your underlying regex engine is configured in a way that
+    /// it is guaranteed to never return an error.
+    pub fn infallible(self) -> HalfMatchesIter<'h, F> {
+        HalfMatchesIter(self)
+    }
+
+    /// Returns the current `Input` used by this iterator.
+    ///
+    /// The `Input` returned is generally equivalent to the one used to
+    /// construct this iterator, but its start position may be different to
+    /// reflect the start of the next search to be executed.
+    pub fn input<'i>(&'i self) -> &'i Input<'h> {
+        self.it.input()
+    }
+}
+
+impl<'h, F> Iterator for TryHalfMatchesIter<'h, F>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+{
+    type Item = Result<HalfMatch, MatchError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<HalfMatch, MatchError>> {
+        self.it.try_advance_half(&mut self.finder).transpose()
+    }
+}
+
+impl<'h, F> core::fmt::Debug for TryHalfMatchesIter<'h, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("TryHalfMatchesIter")
+            .field("it", &self.it)
+            .field("finder", &"<closure>")
+            .finish()
+    }
+}
+
+/// An iterator over all non-overlapping half matches for an infallible search.
+///
+/// The iterator yields a [`HalfMatch`] value until no more matches could be
+/// found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_half_matches_iter`] and
+/// then calling [`TryHalfMatchesIter::infallible`].
+#[derive(Debug)]
+pub struct HalfMatchesIter<'h, F>(TryHalfMatchesIter<'h, F>);
+
+impl<'h, F> HalfMatchesIter<'h, F> {
+    /// Returns the current `Input` used by this iterator.
+    ///
+    /// The `Input` returned is generally equivalent to the one used to
+    /// construct this iterator, but its start position may be different to
+    /// reflect the start of the next search to be executed.
+    pub fn input<'i>(&'i self) -> &'i Input<'h> {
+        self.0.it.input()
+    }
+}
+
+impl<'h, F> Iterator for HalfMatchesIter<'h, F>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+{
+    type Item = HalfMatch;
+
+    #[inline]
+    fn next(&mut self) -> Option<HalfMatch> {
+        match self.0.next()? {
+            Ok(m) => Some(m),
+            Err(err) => panic!(
+                "unexpected regex half find error: {}\n\
+                 to handle find errors, use 'try' or 'search' methods",
+                err,
+            ),
+        }
+    }
+}
+
+/// An iterator over all non-overlapping matches for a fallible search.
+///
+/// The iterator yields a `Result<Match, MatchError>` value until no more
+/// matches could be found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_matches_iter`].
+pub struct TryMatchesIter<'h, F> {
+    it: Searcher<'h>,
+    finder: F,
+}
+
+impl<'h, F> TryMatchesIter<'h, F> {
+    /// Return an infallible version of this iterator.
+    ///
+    /// Any item yielded that corresponds to an error results in a panic. This
+    /// is useful if your underlying regex engine is configured in a way that
+    /// it is guaranteed to never return an error.
+    pub fn infallible(self) -> MatchesIter<'h, F> {
+        MatchesIter(self)
+    }
+
+    /// Returns the current `Input` used by this iterator.
+    ///
+    /// The `Input` returned is generally equivalent to the one used to
+    /// construct this iterator, but its start position may be different to
+    /// reflect the start of the next search to be executed.
+    pub fn input<'i>(&'i self) -> &'i Input<'h> {
+        self.it.input()
+    }
+}
+
+impl<'h, F> Iterator for TryMatchesIter<'h, F>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+{
+    type Item = Result<Match, MatchError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<Match, MatchError>> {
+        self.it.try_advance(&mut self.finder).transpose()
+    }
+}
+
+impl<'h, F> core::fmt::Debug for TryMatchesIter<'h, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("TryMatchesIter")
+            .field("it", &self.it)
+            .field("finder", &"<closure>")
+            .finish()
+    }
+}
+
+/// An iterator over all non-overlapping matches for an infallible search.
+///
+/// The iterator yields a [`Match`] value until no more matches could be found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_matches_iter`] and
+/// then calling [`TryMatchesIter::infallible`].
+#[derive(Debug)]
+pub struct MatchesIter<'h, F>(TryMatchesIter<'h, F>);
+
+impl<'h, F> MatchesIter<'h, F> {
+    /// Returns the current `Input` used by this iterator.
+    ///
+    /// The `Input` returned is generally equivalent to the one used to
+    /// construct this iterator, but its start position may be different to
+    /// reflect the start of the next search to be executed.
+    pub fn input<'i>(&'i self) -> &'i Input<'h> {
+        self.0.it.input()
+    }
+}
+
+impl<'h, F> Iterator for MatchesIter<'h, F>
+where
+    F: FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+{
+    type Item = Match;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match> {
+        match self.0.next()? {
+            Ok(m) => Some(m),
+            Err(err) => panic!(
+                "unexpected regex find error: {}\n\
+                 to handle find errors, use 'try' or 'search' methods",
+                err,
+            ),
+        }
+    }
+}
+
+/// An iterator over all non-overlapping captures for a fallible search.
+///
+/// The iterator yields a `Result<Captures, MatchError>` value until no more
+/// matches could be found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_captures_iter`].
+#[cfg(feature = "alloc")]
+pub struct TryCapturesIter<'h, F> {
+    it: Searcher<'h>,
+    caps: Captures,
+    finder: F,
+}
+
+#[cfg(feature = "alloc")]
+impl<'h, F> TryCapturesIter<'h, F> {
+    /// Return an infallible version of this iterator.
+    ///
+    /// Any item yielded that corresponds to an error results in a panic. This
+    /// is useful if your underlying regex engine is configured in a way that
+    /// it is guaranteed to never return an error.
+    pub fn infallible(self) -> CapturesIter<'h, F> {
+        CapturesIter(self)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'h, F> Iterator for TryCapturesIter<'h, F>
+where
+    F: FnMut(&Input<'_>, &mut Captures) -> Result<(), MatchError>,
+{
+    type Item = Result<Captures, MatchError>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<Captures, MatchError>> {
+        let TryCapturesIter { ref mut it, ref mut caps, ref mut finder } =
+            *self;
+        let result = it
+            .try_advance(|input| {
+                (finder)(input, caps)?;
+                Ok(caps.get_match())
+            })
+            .transpose()?;
+        match result {
+            Ok(_) => Some(Ok(caps.clone())),
+            Err(err) => Some(Err(err)),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'h, F> core::fmt::Debug for TryCapturesIter<'h, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("TryCapturesIter")
+            .field("it", &self.it)
+            .field("caps", &self.caps)
+            .field("finder", &"<closure>")
+            .finish()
+    }
+}
+
+/// An iterator over all non-overlapping captures for an infallible search.
+///
+/// The iterator yields a [`Captures`] value until no more matches could be
+/// found.
+///
+/// The type parameters are as follows:
+///
+/// * `F` represents the type of a closure that executes the search.
+///
+/// The lifetime parameters come from the [`Input`] type:
+///
+/// * `'h` is the lifetime of the underlying haystack.
+///
+/// When possible, prefer the iterators defined on the regex engine you're
+/// using. This tries to abstract over the regex engine and is thus a bit more
+/// unwieldy to use.
+///
+/// This iterator is created by [`Searcher::into_captures_iter`] and then
+/// calling [`TryCapturesIter::infallible`].
+#[cfg(feature = "alloc")]
+#[derive(Debug)]
+pub struct CapturesIter<'h, F>(TryCapturesIter<'h, F>);
+
+#[cfg(feature = "alloc")]
+impl<'h, F> Iterator for CapturesIter<'h, F>
+where
+    F: FnMut(&Input<'_>, &mut Captures) -> Result<(), MatchError>,
+{
+    type Item = Captures;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures> {
+        match self.0.next()? {
+            Ok(m) => Some(m),
+            Err(err) => panic!(
+                "unexpected regex captures error: {}\n\
+                 to handle find errors, use 'try' or 'search' methods",
+                err,
+            ),
+        }
+    }
+}
diff --git a/regex-automata/src/util/lazy.rs b/regex-automata/src/util/lazy.rs
new file mode 100644
index 0000000000..b9f013c88c
--- /dev/null
+++ b/regex-automata/src/util/lazy.rs
@@ -0,0 +1,465 @@
+/*!
+A lazily initialized value for safe sharing between threads.
+
+The principal type in this module is `Lazy`, which makes it easy to construct
+values that are shared safely across multiple threads simultaneously.
+*/
+
+use core::fmt;
+
+/// A lazily initialized value that implements `Deref` for `T`.
+///
+/// A `Lazy` takes an initialization function and permits callers from any
+/// thread to access the result of that initialization function in a safe
+/// manner. In effect, this permits one-time initialization of global resources
+/// in a (possibly) multi-threaded program.
+///
+/// This type and its functionality are available even when neither the `alloc`
+/// nor the `std` features are enabled. In exchange, a `Lazy` does **not**
+/// guarantee that the given `create` function is called at most once. It
+/// might be called multiple times. Moreover, a call to `Lazy::get` (either
+/// explicitly or implicitly via `Lazy`'s `Deref` impl) may block until a `T`
+/// is available.
+///
+/// This is very similar to `lazy_static` or `once_cell`, except it doesn't
+/// guarantee that the initialization function will be run once and it works
+/// in no-alloc no-std environments. With that said, if you need stronger
+/// guarantees or a more flexible API, then it is recommended to use either
+/// `lazy_static` or `once_cell`.
+///
+/// # Warning: may use a spin lock
+///
+/// When this crate is compiled _without_ the `alloc` feature, then this type
+/// may used a spin lock internally. This can have subtle effects that may
+/// be undesirable. See [Spinlocks Considered Harmful][spinharm] for a more
+/// thorough treatment of this topic.
+///
+/// [spinharm]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html
+///
+/// # Example
+///
+/// This type is useful for creating regexes once, and then using them from
+/// multiple threads simultaneously without worrying about synchronization.
+///
+/// ```
+/// use regex_automata::{dfa::regex::Regex, util::lazy::Lazy, Match};
+///
+/// static RE: Lazy<Regex> = Lazy::new(|| Regex::new("foo[0-9]+bar").unwrap());
+///
+/// let expected = Some(Match::must(0, 3..14));
+/// assert_eq!(expected, RE.find(b"zzzfoo12345barzzz"));
+/// ```
+pub struct Lazy<T, F = fn() -> T>(lazy::Lazy<T, F>);
+
+impl<T, F> Lazy<T, F> {
+    /// Create a new `Lazy` value that is initialized via the given function.
+    ///
+    /// The `T` type is automatically inferred from the return type of the
+    /// `create` function given.
+    pub const fn new(create: F) -> Lazy<T, F> {
+        Lazy(lazy::Lazy::new(create))
+    }
+}
+
+impl<T, F: Fn() -> T> Lazy<T, F> {
+    /// Return a reference to the lazily initialized value.
+    ///
+    /// This routine may block if another thread is initializing a `T`.
+    ///
+    /// Note that given a `x` which has type `Lazy`, this must be called via
+    /// `Lazy::get(x)` and not `x.get()`. This routine is defined this way
+    /// because `Lazy` impls `Deref` with a target of `T`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the `create` function inside this lazy value panics.
+    /// If the panic occurred in another thread, then this routine _may_ also
+    /// panic (but is not guaranteed to do so).
+    pub fn get(this: &Lazy<T, F>) -> &T {
+        this.0.get()
+    }
+}
+
+impl<T, F: Fn() -> T> core::ops::Deref for Lazy<T, F> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        Lazy::get(self)
+    }
+}
+
+impl<T: fmt::Debug, F: Fn() -> T> fmt::Debug for Lazy<T, F> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[cfg(feature = "alloc")]
+mod lazy {
+    use core::{
+        fmt,
+        marker::PhantomData,
+        sync::atomic::{AtomicPtr, Ordering},
+    };
+
+    use alloc::boxed::Box;
+
+    /// A non-std lazy initialized value.
+    ///
+    /// This might run the initialization function more than once, but will
+    /// never block.
+    ///
+    /// I wish I could get these semantics into the non-alloc non-std Lazy
+    /// type below, but I'm not sure how to do it. If you can do an alloc,
+    /// then the implementation becomes very simple if you don't care about
+    /// redundant work precisely because a pointer can be atomically swapped.
+    ///
+    /// Perhaps making this approach work in the non-alloc non-std case
+    /// requires asking the caller for a pointer? It would make the API less
+    /// convenient I think.
+    pub(super) struct Lazy<T, F> {
+        data: AtomicPtr<T>,
+        create: F,
+        // This indicates to the compiler that this type can drop T. It's not
+        // totally clear how the absence of this marker could lead to trouble,
+        // but putting here doesn't have any downsides so we hedge until somone
+        // can from the Unsafe Working Group can tell us definitively that we
+        // don't need it.
+        //
+        // See: https://github.com/BurntSushi/regex-automata/issues/30
+        owned: PhantomData<Box<T>>,
+    }
+
+    // SAFETY: So long as T and &T (and F and &F) can themselves be safely
+    // shared among threads, so to can a Lazy<T, _>. Namely, the Lazy API only
+    // permits accessing a &T and initialization is free of data races. So if T
+    // is thread safe, then so to is Lazy<T, _>.
+    //
+    // We specifically require that T: Send in order for Lazy<T> to be Sync.
+    // Without that requirement, it's possible to send a T from one thread to
+    // another via Lazy's destructor.
+    //
+    // It's not clear whether we need F: Send+Sync for Lazy to be Sync. But
+    // we're conservative for now and keep both.
+    unsafe impl<T: Send + Sync, F: Send + Sync> Sync for Lazy<T, F> {}
+
+    impl<T, F> Lazy<T, F> {
+        /// Create a new alloc but non-std lazy value that is racily
+        /// initialized. That is, the 'create' function may be called more than
+        /// once.
+        pub(super) const fn new(create: F) -> Lazy<T, F> {
+            Lazy {
+                data: AtomicPtr::new(core::ptr::null_mut()),
+                create,
+                owned: PhantomData,
+            }
+        }
+    }
+
+    impl<T, F: Fn() -> T> Lazy<T, F> {
+        /// Get the underlying lazy value. If it hasn't been initialized
+        /// yet, then always attempt to initialize it (even if some other
+        /// thread is initializing it) and atomicly attach it to this lazy
+        /// value before returning it.
+        pub(super) fn get(&self) -> &T {
+            if let Some(data) = self.poll() {
+                return data;
+            }
+            let data = (self.create)();
+            let mut ptr = Box::into_raw(Box::new(data));
+            // We attempt to stuff our initialized value into our atomic
+            // pointer. Upon success, we don't need to do anything. But if
+            // someone else beat us to the punch, then we need to make sure
+            // our newly created value is dropped.
+            let result = self.data.compare_exchange(
+                core::ptr::null_mut(),
+                ptr,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            );
+            if let Err(old) = result {
+                // SAFETY: We created 'ptr' via Box::into_raw above, so turning
+                // it back into a Box via from_raw is safe.
+                drop(unsafe { Box::from_raw(ptr) });
+                ptr = old;
+            }
+            // SAFETY: We just set the pointer above to a non-null value, even
+            // in the error case, and set it to a fully initialized value
+            // returned by 'create'.
+            unsafe { &*ptr }
+        }
+
+        /// If this lazy value has been initialized successfully, then return
+        /// that value. Otherwise return None immediately. This never attempts
+        /// to run initialization itself.
+        fn poll(&self) -> Option<&T> {
+            let ptr = self.data.load(Ordering::Acquire);
+            if ptr.is_null() {
+                return None;
+            }
+            // SAFETY: We just checked that the pointer is not null. Since it's
+            // not null, it must have been fully initialized by 'get' at some
+            // point.
+            Some(unsafe { &*ptr })
+        }
+    }
+
+    impl<T: fmt::Debug, F: Fn() -> T> fmt::Debug for Lazy<T, F> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.debug_struct("Lazy").field("data", &self.poll()).finish()
+        }
+    }
+
+    impl<T, F> Drop for Lazy<T, F> {
+        fn drop(&mut self) {
+            let ptr = *self.data.get_mut();
+            if !ptr.is_null() {
+                // SAFETY: We just checked that 'ptr' is not null. And since
+                // we have exclusive access, there are no races to worry about.
+                drop(unsafe { Box::from_raw(ptr) });
+            }
+        }
+    }
+}
+
+#[cfg(not(feature = "alloc"))]
+mod lazy {
+    use core::{
+        cell::Cell,
+        fmt,
+        mem::MaybeUninit,
+        panic::{RefUnwindSafe, UnwindSafe},
+        sync::atomic::{AtomicU8, Ordering},
+    };
+
+    /// Our 'Lazy' value can be in one of three states:
+    ///
+    /// * INIT is where it starts, and also ends up back here if the
+    /// 'create' routine panics.
+    /// * BUSY is where it sits while initialization is running in exactly
+    /// one thread.
+    /// * DONE is where it sits after 'create' has completed and 'data' has
+    /// been fully initialized.
+    const LAZY_STATE_INIT: u8 = 0;
+    const LAZY_STATE_BUSY: u8 = 1;
+    const LAZY_STATE_DONE: u8 = 2;
+
+    /// A non-alloc non-std lazy initialized value.
+    ///
+    /// This guarantees initialization only happens once, but uses a spinlock
+    /// to block in the case of simultaneous access. Blocking occurs so that
+    /// one thread waits while another thread initializes the value.
+    ///
+    /// I would much rather have the semantics of the 'alloc' Lazy type above.
+    /// Namely, that we might run the initialization function more than once,
+    /// but we never otherwise block. However, I don't know how to do that in
+    /// a non-alloc non-std context.
+    pub(super) struct Lazy<T, F> {
+        state: AtomicU8,
+        create: Cell<Option<F>>,
+        data: Cell<MaybeUninit<T>>,
+    }
+
+    // SAFETY: So long as T and &T (and F and &F) can themselves be safely
+    // shared among threads, so to can a Lazy<T, _>. Namely, the Lazy API only
+    // permits accessing a &T and initialization is free of data races. So if T
+    // is thread safe, then so to is Lazy<T, _>.
+    unsafe impl<T: Send + Sync, F: Send + Sync> Sync for Lazy<T, F> {}
+    // A reference to a Lazy is unwind safe because we specifically take
+    // precautions to poison all accesses to a Lazy if the caller-provided
+    // 'create' function panics.
+    impl<T: UnwindSafe, F: UnwindSafe + RefUnwindSafe> RefUnwindSafe
+        for Lazy<T, F>
+    {
+    }
+
+    impl<T, F> Lazy<T, F> {
+        /// Create a new non-alloc non-std lazy value that is initialized
+        /// exactly once on first use using the given function.
+        pub(super) const fn new(create: F) -> Lazy<T, F> {
+            Lazy {
+                state: AtomicU8::new(LAZY_STATE_INIT),
+                create: Cell::new(Some(create)),
+                data: Cell::new(MaybeUninit::uninit()),
+            }
+        }
+    }
+
+    impl<T, F: FnOnce() -> T> Lazy<T, F> {
+        /// Get the underlying lazy value. If it isn't been initialized
+        /// yet, then either initialize it or block until some other thread
+        /// initializes it. If the 'create' function given to Lazy::new panics
+        /// (even in another thread), then this panics too.
+        pub(super) fn get(&self) -> &T {
+            // This is effectively a spinlock. We loop until we enter a DONE
+            // state, and if possible, initialize it ourselves. The only way
+            // we exit the loop is if 'create' panics, we initialize 'data' or
+            // some other thread initializes 'data'.
+            //
+            // Yes, I have read spinlocks considered harmful[1]. And that
+            // article is why this spinlock is only active when 'alloc' isn't
+            // enabled. I did this because I don't think there is really
+            // another choice without 'alloc', other than not providing this at
+            // all. But I think that's a big bummer.
+            //
+            // [1]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html
+            while self.state.load(Ordering::Acquire) != LAZY_STATE_DONE {
+                // Check if we're the first ones to get here. If so, we'll be
+                // the ones who initialize.
+                let result = self.state.compare_exchange(
+                    LAZY_STATE_INIT,
+                    LAZY_STATE_BUSY,
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                );
+                // This means we saw the INIT state and nobody else can. So we
+                // must take responsibility for initializing. And by virtue of
+                // observing INIT, we have also told anyone else trying to
+                // get here that we are BUSY. If someone else sees BUSY, then
+                // they will spin until we finish initialization.
+                if let Ok(_) = result {
+                    // Since we are guaranteed to be the only ones here, we
+                    // know that 'create' is there... Unless someone else got
+                    // here before us and 'create' panicked. In which case,
+                    // 'self.create' is now 'None' and we forward the panic
+                    // to the caller. (i.e., We implement poisoning.)
+                    //
+                    // SAFETY: Our use of 'self.state' guarantees that we are
+                    // the only thread executing this line, and thus there are
+                    // no races.
+                    let create = unsafe {
+                        (*self.create.as_ptr()).take().expect(
+                            "Lazy's create function panicked, \
+                             preventing initialization,
+                             poisoning current thread",
+                        )
+                    };
+                    let guard = Guard { state: &self.state };
+                    // SAFETY: Our use of 'self.state' guarantees that we are
+                    // the only thread executing this line, and thus there are
+                    // no races.
+                    unsafe {
+                        (*self.data.as_ptr()).as_mut_ptr().write(create());
+                    }
+                    // All is well. 'self.create' ran successfully, so we
+                    // forget the guard.
+                    core::mem::forget(guard);
+                    // Everything is initialized, so we can declare success.
+                    self.state.store(LAZY_STATE_DONE, Ordering::Release);
+                    break;
+                }
+                core::hint::spin_loop();
+            }
+            // We only get here if data is fully initialized, and thus poll
+            // will always return something.
+            self.poll().unwrap()
+        }
+
+        /// If this lazy value has been initialized successfully, then return
+        /// that value. Otherwise return None immediately. This never blocks.
+        fn poll(&self) -> Option<&T> {
+            if self.state.load(Ordering::Acquire) == LAZY_STATE_DONE {
+                // SAFETY: The DONE state only occurs when data has been fully
+                // initialized.
+                Some(unsafe { &*(*self.data.as_ptr()).as_ptr() })
+            } else {
+                None
+            }
+        }
+    }
+
+    impl<T: fmt::Debug, F: FnMut() -> T> fmt::Debug for Lazy<T, F> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.debug_struct("Lazy")
+                .field("state", &self.state.load(Ordering::Acquire))
+                .field("create", &"<closure>")
+                .field("data", &self.poll())
+                .finish()
+        }
+    }
+
+    impl<T, F> Drop for Lazy<T, F> {
+        fn drop(&mut self) {
+            if *self.state.get_mut() == LAZY_STATE_DONE {
+                // SAFETY: state is DONE if and only if data has been fully
+                // initialized. At which point, it is safe to drop.
+                unsafe {
+                    // MSRV(1.60): Use assume_init_drop. The below is how
+                    // assume_init_drop is implemented.
+                    core::ptr::drop_in_place(
+                        (*self.data.as_ptr()).as_mut_ptr(),
+                    )
+                }
+            }
+        }
+    }
+
+    /// A guard that will reset a Lazy's state back to INIT when dropped. The
+    /// idea here is to 'forget' this guard on success. On failure (when a
+    /// panic occurs), the Drop impl runs and causes all in-progress and future
+    /// 'get' calls to panic. Without this guard, all in-progress and future
+    /// 'get' calls would spin forever. Crashing is much better than getting
+    /// stuck in an infinite loop.
+    struct Guard<'a> {
+        state: &'a AtomicU8,
+    }
+
+    impl<'a> Drop for Guard<'a> {
+        fn drop(&mut self) {
+            // We force ourselves back into an INIT state. This will in turn
+            // cause any future 'get' calls to attempt calling 'self.create'
+            // again which will in turn panic because 'self.create' will now
+            // be 'None'.
+            self.state.store(LAZY_STATE_INIT, Ordering::Release);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn assert_send<T: Send>() {}
+    fn assert_sync<T: Sync>() {}
+    fn assert_unwind<T: core::panic::UnwindSafe>() {}
+    fn assert_refunwind<T: core::panic::RefUnwindSafe>() {}
+
+    #[test]
+    fn oibits() {
+        assert_send::<Lazy<u64>>();
+        assert_sync::<Lazy<u64>>();
+        assert_unwind::<Lazy<u64>>();
+        assert_refunwind::<Lazy<u64>>();
+    }
+
+    // This is a regression test because we used to rely on the inferred Sync
+    // impl for the Lazy type defined above (for 'alloc' mode). In the
+    // inferred impl, it only requires that T: Sync for Lazy<T>: Sync. But
+    // if we have that, we can actually make use of the fact that Lazy<T> drops
+    // T to create a value on one thread and drop it on another. This *should*
+    // require T: Send, but our missing bounds before let it sneak by.
+    //
+    // Basically, this test should not compile, so we... comment it out. We
+    // don't have a great way of testing compile-fail tests right now.
+    //
+    // See: https://github.com/BurntSushi/regex-automata/issues/30
+    /*
+    #[test]
+    fn sync_not_send() {
+        #[allow(dead_code)]
+        fn inner<T: Sync + Default>() {
+            let lazy = Lazy::new(move || T::default());
+            std::thread::scope(|scope| {
+                scope.spawn(|| {
+                    Lazy::get(&lazy); // We create T in this thread
+                });
+            });
+            // And drop in this thread.
+            drop(lazy);
+            // So we have send a !Send type over threads. (with some more
+            // legwork, its possible to even sneak the value out of drop
+            // through thread local)
+        }
+    }
+    */
+}
diff --git a/regex-automata/src/util/look.rs b/regex-automata/src/util/look.rs
new file mode 100644
index 0000000000..389a864efb
--- /dev/null
+++ b/regex-automata/src/util/look.rs
@@ -0,0 +1,1748 @@
+/*!
+Types and routines for working with look-around assertions.
+
+This module principally defines two types:
+
+* [`Look`] enumerates all of the assertions supported by this crate.
+* [`LookSet`] provides a way to efficiently store a set of [`Look`] values.
+* [`LookMatcher`] provides routines for checking whether a `Look` or a
+`LookSet` matches at a particular position in a haystack.
+*/
+
+// LAMENTATION: Sadly, a lot of the API of `Look` and `LookSet` were basically
+// copied verbatim from the regex-syntax crate. I would have no problems using
+// the regex-syntax types and defining the matching routines (only found
+// in this crate) as free functions, except the `Look` and `LookSet` types
+// are used in lots of places. Including in places we expect to work when
+// regex-syntax is *not* enabled, such as in the definition of the NFA itself.
+//
+// Thankfully the code we copy is pretty simple and there isn't much of it.
+// Otherwise, the rest of this module deals with *matching* the assertions,
+// which is not something that regex-syntax handles.
+
+use crate::util::{escape::DebugByte, utf8};
+
+/// A look-around assertion.
+///
+/// An assertion matches at a position between characters in a haystack.
+/// Namely, it does not actually "consume" any input as most parts of a regular
+/// expression do. Assertions are a way of stating that some property must be
+/// true at a particular point during matching.
+///
+/// For example, `(?m)^[a-z]+$` is a pattern that:
+///
+/// * Scans the haystack for a position at which `(?m:^)` is satisfied. That
+/// occurs at either the beginning of the haystack, or immediately following
+/// a `\n` character.
+/// * Looks for one or more occurrences of `[a-z]`.
+/// * Once `[a-z]+` has matched as much as it can, an overall match is only
+/// reported when `[a-z]+` stops just before a `\n`.
+///
+/// So in this case, `abc` and `\nabc\n` match, but `\nabc1\n` does not.
+///
+/// Assertions are also called "look-around," "look-behind" and "look-ahead."
+/// Specifically, some assertions are look-behind (like `^`), other assertions
+/// are look-ahead (like `$`) and yet other assertions are both look-ahead and
+/// look-behind (like `\b`).
+///
+/// # Assertions in an NFA
+///
+/// An assertion in a [`thompson::NFA`](crate::nfa::thompson::NFA) can be
+/// thought of as a conditional epsilon transition. That is, a matching engine
+/// like the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) only permits
+/// moving through conditional epsilon transitions when their condition
+/// is satisfied at whatever position the `PikeVM` is currently at in the
+/// haystack.
+///
+/// How assertions are handled in a `DFA` is trickier, since a DFA does not
+/// have epsilon transitions at all. In this case, they are compiled into the
+/// automaton itself, at the expense of more states than what would be required
+/// without an assertion.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Look {
+    /// Match the beginning of text. Specifically, this matches at the starting
+    /// position of the input.
+    Start = 1 << 0,
+    /// Match the end of text. Specifically, this matches at the ending
+    /// position of the input.
+    End = 1 << 1,
+    /// Match the beginning of a line or the beginning of text. Specifically,
+    /// this matches at the starting position of the input, or at the position
+    /// immediately following a `\n` character.
+    StartLF = 1 << 2,
+    /// Match the end of a line or the end of text. Specifically, this matches
+    /// at the end position of the input, or at the position immediately
+    /// preceding a `\n` character.
+    EndLF = 1 << 3,
+    /// Match the beginning of a line or the beginning of text. Specifically,
+    /// this matches at the starting position of the input, or at the position
+    /// immediately following either a `\r` or `\n` character, but never after
+    /// a `\r` when a `\n` follows.
+    StartCRLF = 1 << 4,
+    /// Match the end of a line or the end of text. Specifically, this matches
+    /// at the end position of the input, or at the position immediately
+    /// preceding a `\r` or `\n` character, but never before a `\n` when a `\r`
+    /// precedes it.
+    EndCRLF = 1 << 5,
+    /// Match an ASCII-only word boundary. That is, this matches a position
+    /// where the left adjacent character and right adjacent character
+    /// correspond to a word and non-word or a non-word and word character.
+    WordAscii = 1 << 6,
+    /// Match an ASCII-only negation of a word boundary.
+    WordAsciiNegate = 1 << 7,
+    /// Match a Unicode-aware word boundary. That is, this matches a position
+    /// where the left adjacent character and right adjacent character
+    /// correspond to a word and non-word or a non-word and word character.
+    WordUnicode = 1 << 8,
+    /// Match a Unicode-aware negation of a word boundary.
+    WordUnicodeNegate = 1 << 9,
+}
+
+impl Look {
+    /// Flip the look-around assertion to its equivalent for reverse searches.
+    /// For example, `StartLF` gets translated to `EndLF`.
+    ///
+    /// Some assertions, such as `WordUnicode`, remain the same since they
+    /// match the same positions regardless of the direction of the search.
+    #[inline]
+    pub const fn reversed(self) -> Look {
+        match self {
+            Look::Start => Look::End,
+            Look::End => Look::Start,
+            Look::StartLF => Look::EndLF,
+            Look::EndLF => Look::StartLF,
+            Look::StartCRLF => Look::EndCRLF,
+            Look::EndCRLF => Look::StartCRLF,
+            Look::WordAscii => Look::WordAscii,
+            Look::WordAsciiNegate => Look::WordAsciiNegate,
+            Look::WordUnicode => Look::WordUnicode,
+            Look::WordUnicodeNegate => Look::WordUnicodeNegate,
+        }
+    }
+
+    /// Return the underlying representation of this look-around enumeration
+    /// as an integer. Giving the return value to the [`Look::from_repr`]
+    /// constructor is guaranteed to return the same look-around variant that
+    /// one started with within a semver compatible release of this crate.
+    #[inline]
+    pub const fn as_repr(self) -> u16 {
+        // AFAIK, 'as' is the only way to zero-cost convert an int enum to an
+        // actual int.
+        self as u16
+    }
+
+    /// Given the underlying representation of a `Look` value, return the
+    /// corresponding `Look` value if the representation is valid. Otherwise
+    /// `None` is returned.
+    #[inline]
+    pub const fn from_repr(repr: u16) -> Option<Look> {
+        match repr {
+            0b00_0000_0001 => Some(Look::Start),
+            0b00_0000_0010 => Some(Look::End),
+            0b00_0000_0100 => Some(Look::StartLF),
+            0b00_0000_1000 => Some(Look::EndLF),
+            0b00_0001_0000 => Some(Look::StartCRLF),
+            0b00_0010_0000 => Some(Look::EndCRLF),
+            0b00_0100_0000 => Some(Look::WordAscii),
+            0b00_1000_0000 => Some(Look::WordAsciiNegate),
+            0b01_0000_0000 => Some(Look::WordUnicode),
+            0b10_0000_0000 => Some(Look::WordUnicodeNegate),
+            _ => None,
+        }
+    }
+
+    /// Returns a convenient single codepoint representation of this
+    /// look-around assertion. Each assertion is guaranteed to be represented
+    /// by a distinct character.
+    ///
+    /// This is useful for succinctly representing a look-around assertion in
+    /// human friendly but succinct output intended for a programmer working on
+    /// regex internals.
+    #[inline]
+    pub const fn as_char(self) -> char {
+        match self {
+            Look::Start => 'A',
+            Look::End => 'z',
+            Look::StartLF => '^',
+            Look::EndLF => '$',
+            Look::StartCRLF => 'r',
+            Look::EndCRLF => 'R',
+            Look::WordAscii => 'b',
+            Look::WordAsciiNegate => 'B',
+            Look::WordUnicode => '𝛃',
+            Look::WordUnicodeNegate => '𝚩',
+        }
+    }
+}
+
+/// LookSet is a memory-efficient set of look-around assertions.
+///
+/// This is useful for efficiently tracking look-around assertions. For
+/// example, a [`thompson::NFA`](crate::nfa::thompson::NFA) provides properties
+/// that return `LookSet`s.
+#[derive(Clone, Copy, Default, Eq, PartialEq)]
+pub struct LookSet {
+    /// The underlying representation this set is exposed to make it possible
+    /// to store it somewhere efficiently. The representation is that
+    /// of a bitset, where each assertion occupies bit `i` where `i =
+    /// Look::as_repr()`.
+    ///
+    /// Note that users of this internal representation must permit the full
+    /// range of `u16` values to be represented. For example, even if the
+    /// current implementation only makes use of the 10 least significant bits,
+    /// it may use more bits in a future semver compatible release.
+    pub bits: u16,
+}
+
+impl LookSet {
+    /// Create an empty set of look-around assertions.
+    #[inline]
+    pub fn empty() -> LookSet {
+        LookSet { bits: 0 }
+    }
+
+    /// Create a full set of look-around assertions.
+    ///
+    /// This set contains all possible look-around assertions.
+    #[inline]
+    pub fn full() -> LookSet {
+        LookSet { bits: !0 }
+    }
+
+    /// Create a look-around set containing the look-around assertion given.
+    ///
+    /// This is a convenience routine for creating an empty set and inserting
+    /// one look-around assertions.
+    #[inline]
+    pub fn singleton(look: Look) -> LookSet {
+        LookSet::empty().insert(look)
+    }
+
+    /// Returns the total number of look-around assertions in this set.
+    #[inline]
+    pub fn len(self) -> usize {
+        // OK because max value always fits in a u8, which in turn always
+        // fits in a usize, regardless of target.
+        usize::try_from(self.bits.count_ones()).unwrap()
+    }
+
+    /// Returns true if and only if this set is empty.
+    #[inline]
+    pub fn is_empty(self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns true if and only if the given look-around assertion is in this
+    /// set.
+    #[inline]
+    pub fn contains(self, look: Look) -> bool {
+        self.bits & look.as_repr() != 0
+    }
+
+    /// Returns true if and only if this set contains any anchor assertions.
+    /// This includes both "start/end of haystack" and "start/end of line."
+    #[inline]
+    pub fn contains_anchor(&self) -> bool {
+        self.contains_anchor_haystack() || self.contains_anchor_line()
+    }
+
+    /// Returns true if and only if this set contains any "start/end of
+    /// haystack" anchors. This doesn't include "start/end of line" anchors.
+    #[inline]
+    pub fn contains_anchor_haystack(&self) -> bool {
+        self.contains(Look::Start) || self.contains(Look::End)
+    }
+
+    /// Returns true if and only if this set contains any "start/end of line"
+    /// anchors. This doesn't include "start/end of haystack" anchors. This
+    /// includes both `\n` line anchors and CRLF (`\r\n`) aware line anchors.
+    #[inline]
+    pub fn contains_anchor_line(&self) -> bool {
+        self.contains(Look::StartLF)
+            || self.contains(Look::EndLF)
+            || self.contains(Look::StartCRLF)
+            || self.contains(Look::EndCRLF)
+    }
+
+    /// Returns true if and only if this set contains any "start/end of line"
+    /// anchors that only treat `\n` as line terminators. This does not include
+    /// haystack anchors or CRLF aware line anchors.
+    #[inline]
+    pub fn contains_anchor_lf(&self) -> bool {
+        self.contains(Look::StartLF) || self.contains(Look::EndLF)
+    }
+
+    /// Returns true if and only if this set contains any "start/end of line"
+    /// anchors that are CRLF-aware. This doesn't include "start/end of
+    /// haystack" or "start/end of line-feed" anchors.
+    #[inline]
+    pub fn contains_anchor_crlf(&self) -> bool {
+        self.contains(Look::StartCRLF) || self.contains(Look::EndCRLF)
+    }
+
+    /// Returns true if and only if this set contains any word boundary or
+    /// negated word boundary assertions. This include both Unicode and ASCII
+    /// word boundaries.
+    #[inline]
+    pub fn contains_word(self) -> bool {
+        self.contains_word_unicode() || self.contains_word_ascii()
+    }
+
+    /// Returns true if and only if this set contains any Unicode word boundary
+    /// or negated Unicode word boundary assertions.
+    #[inline]
+    pub fn contains_word_unicode(self) -> bool {
+        self.contains(Look::WordUnicode)
+            || self.contains(Look::WordUnicodeNegate)
+    }
+
+    /// Returns true if and only if this set contains any ASCII word boundary
+    /// or negated ASCII word boundary assertions.
+    #[inline]
+    pub fn contains_word_ascii(self) -> bool {
+        self.contains(Look::WordAscii) || self.contains(Look::WordAsciiNegate)
+    }
+
+    /// Returns an iterator over all of the look-around assertions in this set.
+    #[inline]
+    pub fn iter(self) -> LookSetIter {
+        LookSetIter { set: self }
+    }
+
+    /// Return a new set that is equivalent to the original, but with the given
+    /// assertion added to it. If the assertion is already in the set, then the
+    /// returned set is equivalent to the original.
+    #[inline]
+    pub fn insert(self, look: Look) -> LookSet {
+        LookSet { bits: self.bits | look.as_repr() }
+    }
+
+    /// Updates this set in place with the result of inserting the given
+    /// assertion into this set.
+    #[inline]
+    pub fn set_insert(&mut self, look: Look) {
+        *self = self.insert(look);
+    }
+
+    /// Return a new set that is equivalent to the original, but with the given
+    /// assertion removed from it. If the assertion is not in the set, then the
+    /// returned set is equivalent to the original.
+    #[inline]
+    pub fn remove(self, look: Look) -> LookSet {
+        LookSet { bits: self.bits & !look.as_repr() }
+    }
+
+    /// Updates this set in place with the result of removing the given
+    /// assertion from this set.
+    #[inline]
+    pub fn set_remove(&mut self, look: Look) {
+        *self = self.remove(look);
+    }
+
+    /// Returns a new set that is the result of subtracting the given set from
+    /// this set.
+    #[inline]
+    pub fn subtract(self, other: LookSet) -> LookSet {
+        LookSet { bits: self.bits & !other.bits }
+    }
+
+    /// Updates this set in place with the result of subtracting the given set
+    /// from this set.
+    #[inline]
+    pub fn set_subtract(&mut self, other: LookSet) {
+        *self = self.subtract(other);
+    }
+
+    /// Returns a new set that is the union of this and the one given.
+    #[inline]
+    pub fn union(self, other: LookSet) -> LookSet {
+        LookSet { bits: self.bits | other.bits }
+    }
+
+    /// Updates this set in place with the result of unioning it with the one
+    /// given.
+    #[inline]
+    pub fn set_union(&mut self, other: LookSet) {
+        *self = self.union(other);
+    }
+
+    /// Returns a new set that is the intersection of this and the one given.
+    #[inline]
+    pub fn intersect(self, other: LookSet) -> LookSet {
+        LookSet { bits: self.bits & other.bits }
+    }
+
+    /// Updates this set in place with the result of intersecting it with the
+    /// one given.
+    #[inline]
+    pub fn set_intersect(&mut self, other: LookSet) {
+        *self = self.intersect(other);
+    }
+
+    /// Return a `LookSet` from the slice given as a native endian 16-bit
+    /// integer.
+    ///
+    /// # Panics
+    ///
+    /// This panics if `slice.len() < 2`.
+    #[inline]
+    pub fn read_repr(slice: &[u8]) -> LookSet {
+        let bits = u16::from_ne_bytes(slice[..2].try_into().unwrap());
+        LookSet { bits }
+    }
+
+    /// Write a `LookSet` as a native endian 16-bit integer to the beginning
+    /// of the slice given.
+    ///
+    /// # Panics
+    ///
+    /// This panics if `slice.len() < 2`.
+    #[inline]
+    pub fn write_repr(self, slice: &mut [u8]) {
+        let raw = self.bits.to_ne_bytes();
+        slice[0] = raw[0];
+        slice[1] = raw[1];
+    }
+
+    /// Checks that all assertions in this set can be matched.
+    ///
+    /// Some assertions, such as Unicode word boundaries, require optional (but
+    /// enabled by default) tables that may not be available. If there are
+    /// assertions in this set that require tables that are not available, then
+    /// this will return an error.
+    ///
+    /// Specifically, this returns an error when the the
+    /// `unicode-word-boundary` feature is _not_ enabled _and_ this set
+    /// contains a Unicode word boundary assertion.
+    ///
+    /// It can be useful to use this on the result of
+    /// [`NFA::look_set_any`](crate::nfa::thompson::NFA::look_set_any)
+    /// when building a matcher engine to ensure methods like
+    /// [`LookMatcher::matches_set`] do not panic at search time.
+    pub fn available(self) -> Result<(), UnicodeWordBoundaryError> {
+        if self.contains_word_unicode() {
+            UnicodeWordBoundaryError::check()?;
+        }
+        Ok(())
+    }
+}
+
+impl core::fmt::Debug for LookSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.is_empty() {
+            return write!(f, "∅");
+        }
+        for look in self.iter() {
+            write!(f, "{}", look.as_char())?;
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over all look-around assertions in a [`LookSet`].
+///
+/// This iterator is created by [`LookSet::iter`].
+#[derive(Clone, Debug)]
+pub struct LookSetIter {
+    set: LookSet,
+}
+
+impl Iterator for LookSetIter {
+    type Item = Look;
+
+    #[inline]
+    fn next(&mut self) -> Option<Look> {
+        if self.set.is_empty() {
+            return None;
+        }
+        // We'll never have more than u8::MAX distinct look-around assertions,
+        // so 'repr' will always fit into a u16.
+        let repr = u16::try_from(self.set.bits.trailing_zeros()).unwrap();
+        let look = Look::from_repr(1 << repr)?;
+        self.set = self.set.remove(look);
+        Some(look)
+    }
+}
+
+/// A matcher for look-around assertions.
+///
+/// This matcher permits configuring aspects of how look-around assertions are
+/// matched.
+///
+/// # Example
+///
+/// A `LookMatcher` can change the line terminator used for matching multi-line
+/// anchors such as `(?m:^)` and `(?m:$)`.
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::{self, pikevm::PikeVM},
+///     util::look::LookMatcher,
+///     Match, Input,
+/// };
+///
+/// let mut lookm = LookMatcher::new();
+/// lookm.set_line_terminator(b'\x00');
+///
+/// let re = PikeVM::builder()
+///     .thompson(thompson::Config::new().look_matcher(lookm))
+///     .build(r"(?m)^[a-z]+$")?;
+/// let mut cache = re.create_cache();
+///
+/// // Multi-line assertions now use NUL as a terminator.
+/// assert_eq!(
+///     Some(Match::must(0, 1..4)),
+///     re.find(&mut cache, b"\x00abc\x00"),
+/// );
+/// // ... and \n is no longer recognized as a terminator.
+/// assert_eq!(
+///     None,
+///     re.find(&mut cache, b"\nabc\n"),
+/// );
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct LookMatcher {
+    lineterm: DebugByte,
+}
+
+impl LookMatcher {
+    /// Creates a new default matcher for look-around assertions.
+    pub fn new() -> LookMatcher {
+        LookMatcher { lineterm: DebugByte(b'\n') }
+    }
+
+    /// Sets the line terminator for use with `(?m:^)` and `(?m:$)`.
+    ///
+    /// Namely, instead of `^` matching after `\n` and `$` matching immediately
+    /// before a `\n`, this will cause it to match after and before the byte
+    /// given.
+    ///
+    /// It can occasionally be useful to use this to configure the line
+    /// terminator to the NUL byte when searching binary data.
+    ///
+    /// Note that this does not apply to CRLF-aware line anchors such as
+    /// `(?Rm:^)` and `(?Rm:$)`. CRLF-aware line anchors are hard-coded to
+    /// use `\r` and `\n`.
+    pub fn set_line_terminator(&mut self, byte: u8) -> &mut LookMatcher {
+        self.lineterm.0 = byte;
+        self
+    }
+
+    /// Returns the line terminator that was configured for this matcher.
+    ///
+    /// If no line terminator was configured, then this returns `\n`.
+    ///
+    /// Note that the line terminator should only be used for matching `(?m:^)`
+    /// and `(?m:$)` assertions. It specifically should _not_ be used for
+    /// matching the CRLF aware assertions `(?Rm:^)` and `(?Rm:$)`.
+    pub fn get_line_terminator(&self) -> u8 {
+        self.lineterm.0
+    }
+
+    /// Returns true when the position `at` in `haystack` satisfies the given
+    /// look-around assertion.
+    ///
+    /// # Panics
+    ///
+    /// This panics when testing any Unicode word boundary assertion in this
+    /// set and when the Unicode word data is not available. Specifically, this
+    /// only occurs when the `unicode-word-boundary` feature is not enabled.
+    ///
+    /// Since it's generally expected that this routine is called inside of
+    /// a matching engine, callers should check the error condition when
+    /// building the matching engine. If there is a Unicode word boundary
+    /// in the matcher and the data isn't available, then the matcher should
+    /// fail to build.
+    ///
+    /// Callers can check the error condition with [`LookSet::available`].
+    ///
+    /// This also may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn matches(&self, look: Look, haystack: &[u8], at: usize) -> bool {
+        self.matches_inline(look, haystack, at)
+    }
+
+    /// Like `matches`, but forcefully inlined.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn matches_inline(
+        &self,
+        look: Look,
+        haystack: &[u8],
+        at: usize,
+    ) -> bool {
+        match look {
+            Look::Start => self.is_start(haystack, at),
+            Look::End => self.is_end(haystack, at),
+            Look::StartLF => self.is_start_lf(haystack, at),
+            Look::EndLF => self.is_end_lf(haystack, at),
+            Look::StartCRLF => self.is_start_crlf(haystack, at),
+            Look::EndCRLF => self.is_end_crlf(haystack, at),
+            Look::WordAscii => self.is_word_ascii(haystack, at),
+            Look::WordAsciiNegate => self.is_word_ascii_negate(haystack, at),
+            Look::WordUnicode => self.is_word_unicode(haystack, at).unwrap(),
+            Look::WordUnicodeNegate => {
+                self.is_word_unicode_negate(haystack, at).unwrap()
+            }
+        }
+    }
+
+    /// Returns true when _all_ of the assertions in the given set match at the
+    /// given position in the haystack.
+    ///
+    /// # Panics
+    ///
+    /// This panics when testing any Unicode word boundary assertion in this
+    /// set and when the Unicode word data is not available. Specifically, this
+    /// only occurs when the `unicode-word-boundary` feature is not enabled.
+    ///
+    /// Since it's generally expected that this routine is called inside of
+    /// a matching engine, callers should check the error condition when
+    /// building the matching engine. If there is a Unicode word boundary
+    /// in the matcher and the data isn't available, then the matcher should
+    /// fail to build.
+    ///
+    /// Callers can check the error condition with [`LookSet::available`].
+    ///
+    /// This also may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn matches_set(
+        &self,
+        set: LookSet,
+        haystack: &[u8],
+        at: usize,
+    ) -> bool {
+        self.matches_set_inline(set, haystack, at)
+    }
+
+    /// Like `LookSet::matches`, but forcefully inlined for perf.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn matches_set_inline(
+        &self,
+        set: LookSet,
+        haystack: &[u8],
+        at: usize,
+    ) -> bool {
+        // This used to luse LookSet::iter with Look::matches on each element,
+        // but that proved to be quite diastrous for perf. The manual "if
+        // the set has this assertion, check it" turns out to be quite a bit
+        // faster.
+        if set.contains(Look::Start) {
+            if !self.is_start(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::End) {
+            if !self.is_end(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::StartLF) {
+            if !self.is_start_lf(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::EndLF) {
+            if !self.is_end_lf(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::StartCRLF) {
+            if !self.is_start_crlf(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::EndCRLF) {
+            if !self.is_end_crlf(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::WordAscii) {
+            if !self.is_word_ascii(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::WordAsciiNegate) {
+            if !self.is_word_ascii_negate(haystack, at) {
+                return false;
+            }
+        }
+        if set.contains(Look::WordUnicode) {
+            if !self.is_word_unicode(haystack, at).unwrap() {
+                return false;
+            }
+        }
+        if set.contains(Look::WordUnicodeNegate) {
+            if !self.is_word_unicode_negate(haystack, at).unwrap() {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Split up the given byte classes into equivalence classes in a way that
+    /// is consistent with this look-around assertion.
+    #[cfg(feature = "alloc")]
+    pub(crate) fn add_to_byteset(
+        &self,
+        look: Look,
+        set: &mut crate::util::alphabet::ByteClassSet,
+    ) {
+        match look {
+            Look::Start | Look::End => {}
+            Look::StartLF | Look::EndLF => {
+                set.set_range(self.lineterm.0, self.lineterm.0);
+            }
+            Look::StartCRLF | Look::EndCRLF => {
+                set.set_range(b'\r', b'\r');
+                set.set_range(b'\n', b'\n');
+            }
+            Look::WordAscii
+            | Look::WordAsciiNegate
+            | Look::WordUnicode
+            | Look::WordUnicodeNegate => {
+                // We need to mark all ranges of bytes whose pairs result in
+                // evaluating \b differently. This isn't technically correct
+                // for Unicode word boundaries, but DFAs can't handle those
+                // anyway, and thus, the byte classes don't need to either
+                // since they are themselves only used in DFAs.
+                //
+                // FIXME: It seems like the calls to 'set_range' here are
+                // completely invariant, which means we could just hard-code
+                // them here without needing to write a loop. And we only need
+                // to do this dance at most once per regex.
+                //
+                // FIXME: Is this correct for \B?
+                let iswb = utf8::is_word_byte;
+                // This unwrap is OK because we guard every use of 'asu8' with
+                // a check that the input is <= 255.
+                let asu8 = |b: u16| u8::try_from(b).unwrap();
+                let mut b1: u16 = 0;
+                let mut b2: u16;
+                while b1 <= 255 {
+                    b2 = b1 + 1;
+                    while b2 <= 255 && iswb(asu8(b1)) == iswb(asu8(b2)) {
+                        b2 += 1;
+                    }
+                    // The guards above guarantee that b2 can never get any
+                    // bigger.
+                    assert!(b2 <= 256);
+                    // Subtracting 1 from b2 is always OK because it is always
+                    // at least 1 greater than b1, and the assert above
+                    // guarantees that the asu8 conversion will succeed.
+                    set.set_range(asu8(b1), asu8(b2.checked_sub(1).unwrap()));
+                    b1 = b2;
+                }
+            }
+        }
+    }
+
+    /// Returns true when [`Look::Start`] is satisfied `at` the given position
+    /// in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_start(&self, _haystack: &[u8], at: usize) -> bool {
+        at == 0
+    }
+
+    /// Returns true when [`Look::End`] is satisfied `at` the given position in
+    /// `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_end(&self, haystack: &[u8], at: usize) -> bool {
+        at == haystack.len()
+    }
+
+    /// Returns true when [`Look::StartLF`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_start_lf(&self, haystack: &[u8], at: usize) -> bool {
+        self.is_start(haystack, at) || haystack[at - 1] == self.lineterm.0
+    }
+
+    /// Returns true when [`Look::EndLF`] is satisfied `at` the given position
+    /// in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_end_lf(&self, haystack: &[u8], at: usize) -> bool {
+        self.is_end(haystack, at) || haystack[at] == self.lineterm.0
+    }
+
+    /// Returns true when [`Look::StartCRLF`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_start_crlf(&self, haystack: &[u8], at: usize) -> bool {
+        self.is_start(haystack, at)
+            || haystack[at - 1] == b'\n'
+            || (haystack[at - 1] == b'\r'
+                && (at >= haystack.len() || haystack[at] != b'\n'))
+    }
+
+    /// Returns true when [`Look::EndCRLF`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_end_crlf(&self, haystack: &[u8], at: usize) -> bool {
+        self.is_end(haystack, at)
+            || haystack[at] == b'\r'
+            || (haystack[at] == b'\n'
+                && (at == 0 || haystack[at - 1] != b'\r'))
+    }
+
+    /// Returns true when [`Look::WordAscii`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_word_ascii(&self, haystack: &[u8], at: usize) -> bool {
+        let word_before = at > 0 && utf8::is_word_byte(haystack[at - 1]);
+        let word_after =
+            at < haystack.len() && utf8::is_word_byte(haystack[at]);
+        word_before != word_after
+    }
+
+    /// Returns true when [`Look::WordAsciiNegate`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    #[inline]
+    pub fn is_word_ascii_negate(&self, haystack: &[u8], at: usize) -> bool {
+        !self.is_word_ascii(haystack, at)
+    }
+
+    /// Returns true when [`Look::WordUnicode`] is satisfied `at` the given
+    /// position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when Unicode word boundary tables
+    /// are not available. Specifically, this only occurs when the
+    /// `unicode-word-boundary` feature is not enabled.
+    #[inline]
+    pub fn is_word_unicode(
+        &self,
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, UnicodeWordBoundaryError> {
+        let word_before = is_word_char::rev(haystack, at)?;
+        let word_after = is_word_char::fwd(haystack, at)?;
+        Ok(word_before != word_after)
+    }
+
+    /// Returns true when [`Look::WordUnicodeNegate`] is satisfied `at` the
+    /// given position in `haystack`.
+    ///
+    /// # Panics
+    ///
+    /// This may panic when `at > haystack.len()`. Note that `at ==
+    /// haystack.len()` is legal and guaranteed not to panic.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when Unicode word boundary tables
+    /// are not available. Specifically, this only occurs when the
+    /// `unicode-word-boundary` feature is not enabled.
+    #[inline]
+    pub fn is_word_unicode_negate(
+        &self,
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, UnicodeWordBoundaryError> {
+        // This is pretty subtle. Why do we need to do UTF-8 decoding here?
+        // Well... at time of writing, the is_word_char_{fwd,rev} routines will
+        // only return true if there is a valid UTF-8 encoding of a "word"
+        // codepoint, and false in every other case (including invalid UTF-8).
+        // This means that in regions of invalid UTF-8 (which might be a
+        // subset of valid UTF-8!), it would result in \B matching. While this
+        // would be questionable in the context of truly invalid UTF-8, it is
+        // *certainly* wrong to report match boundaries that split the encoding
+        // of a codepoint. So to work around this, we ensure that we can decode
+        // a codepoint on either side of `at`. If either direction fails, then
+        // we don't permit \B to match at all.
+        //
+        // Now, this isn't exactly optimal from a perf perspective. We could
+        // try and detect this in is_word_char::{fwd,rev}, but it's not clear
+        // if it's worth it. \B is, after all, rarely used. Even worse,
+        // is_word_char::{fwd,rev} could do its own UTF-8 decoding, and so this
+        // will wind up doing UTF-8 decoding twice. Owch. We could fix this
+        // with more code complexity, but it just doesn't feel worth it for \B.
+        //
+        // And in particular, we do *not* have to do this with \b, because \b
+        // *requires* that at least one side of `at` be a "word" codepoint,
+        // which in turn implies one side of `at` must be valid UTF-8. This in
+        // turn implies that \b can never split a valid UTF-8 encoding of a
+        // codepoint. In the case where one side of `at` is truly invalid UTF-8
+        // and the other side IS a word codepoint, then we want \b to match
+        // since it represents a valid UTF-8 boundary. It also makes sense. For
+        // example, you'd want \b\w+\b to match 'abc' in '\xFFabc\xFF'.
+        //
+        // Note also that this is not just '!is_word_unicode(..)' like it is
+        // for the ASCII case. For example, neither \b nor \B is satisfied
+        // within invalid UTF-8 sequences.
+        let word_before = at > 0
+            && match utf8::decode_last(&haystack[..at]) {
+                None | Some(Err(_)) => return Ok(false),
+                Some(Ok(_)) => is_word_char::rev(haystack, at)?,
+            };
+        let word_after = at < haystack.len()
+            && match utf8::decode(&haystack[at..]) {
+                None | Some(Err(_)) => return Ok(false),
+                Some(Ok(_)) => is_word_char::fwd(haystack, at)?,
+            };
+        Ok(word_before == word_after)
+    }
+}
+
+impl Default for LookMatcher {
+    fn default() -> LookMatcher {
+        LookMatcher::new()
+    }
+}
+
+/// An error that occurs when the Unicode-aware `\w` class is unavailable.
+///
+/// This error can occur when the data tables necessary for the Unicode aware
+/// Perl character class `\w` are unavailable. The `\w` class is used to
+/// determine whether a codepoint is considered a word character or not when
+/// determining whether a Unicode aware `\b` (or `\B`) matches at a particular
+/// position.
+///
+/// This error can only occur when the `unicode-word-boundary` feature is
+/// disabled.
+#[derive(Clone, Debug)]
+pub struct UnicodeWordBoundaryError(());
+
+impl UnicodeWordBoundaryError {
+    #[cfg(not(feature = "unicode-word-boundary"))]
+    pub(crate) fn new() -> UnicodeWordBoundaryError {
+        UnicodeWordBoundaryError(())
+    }
+
+    /// Returns an error if and only if Unicode word boundary data is
+    /// unavailable.
+    pub fn check() -> Result<(), UnicodeWordBoundaryError> {
+        is_word_char::check()
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnicodeWordBoundaryError {}
+
+impl core::fmt::Display for UnicodeWordBoundaryError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "Unicode-aware \\b and \\B are unavailabe because the \
+             requiste data tables are missing, please enable the \
+             unicode-word-boundary feature"
+        )
+    }
+}
+
+// Below are FOUR different ways for checking whether whether a "word"
+// codepoint exists at a particular position in the haystack. The four
+// different approaches are, in order of preference:
+//
+// 1. Parse '\w', convert to an NFA, convert to a fully compiled DFA on the
+// first call, and then use that DFA for all subsequent calls.
+// 2. Do UTF-8 decoding and use regex_syntax::is_word_character if available.
+// 3. Do UTF-8 decoding and use our own 'perl_word' table.
+// 4. Return an error.
+//
+// The reason for all of these approaches is a combination of perf and
+// permitting one to build regex-automata without the Unicode data necessary
+// for handling Unicode-aware word boundaries. (In which case, '(?-u:\b)' would
+// still work.)
+//
+// The DFA approach is the fastest, but it requires the regex parser, the
+// NFA compiler, the DFA builder and the DFA search runtime. That's a lot to
+// bring in, but if it's available, it's (probably) the best we can do.
+//
+// Approaches (2) and (3) are effectively equivalent, but (2) reuses the
+// data in regex-syntax and avoids duplicating it in regex-automata.
+//
+// Finally, (4) unconditionally returns an error since the requisite data isn't
+// available anywhere.
+//
+// There are actually more approaches possible that we didn't implement. For
+// example, if the DFA builder is available but the syntax parser is not, we
+// could technically hand construct our own NFA from the 'perl_word' data
+// table. But to avoid some pretty hairy code duplication, we would in turn
+// need to pull the UTF-8 compiler out of the NFA compiler. Yikes.
+//
+// A possibly more sensible alternative is to use a lazy DFA when the full
+// DFA builder isn't available...
+//
+// Yet another choice would be to build the full DFA and then embed it into the
+// source. Then we'd only need to bring in the DFA search runtime, which is
+// considerably smaller than the DFA builder code. The problem here is that the
+// Debian people have spooked me[1] into avoiding cyclic dependencies. Namely,
+// we'd need to build regex-cli, which depends on regex-automata in order to
+// build some part of regex-automata. But to be honest, something like this has
+// to be allowed somehow? I just don't know what the right process is.
+//
+// There are perhaps other choices as well. Why did I stop at these 4? Because
+// I wanted to preserve my sanity. I suspect I'll wind up adding the lazy DFA
+// approach eventually, as the benefits of the DFA approach are somewhat
+// compelling. The 'boundary-words-holmes' benchmark tests this:
+//
+//   $ regex-cli bench measure -f boundary-words-holmes -e pikevm > dfa.csv
+//
+// Then I changed the code below so that the util/unicode_data/perl_word table
+// was used and re-ran the benchmark:
+//
+//   $ regex-cli bench measure -f boundary-words-holmes -e pikevm > table.csv
+//
+// And compared them:
+//
+//   $ regex-cli bench diff dfa.csv table.csv
+//   benchmark                             engine                 dfa        table
+//   ---------                             ------                 ---        -----
+//   internal/count/boundary-words-holmes  regex/automata/pikevm  18.6 MB/s  12.9 MB/s
+//
+// Which is a nice improvement.
+//
+// UPDATE: It turns out that it takes approximately 22ms to build the reverse
+// DFA for \w. (And about 3ms for the forward DFA.) It's probably not much in
+// the grand scheme things, but that is a significant latency cost. So I'm not
+// sure that's a good idea. I then tried using a lazy DFA instead, and that
+// eliminated the overhead, but since the lazy DFA requires mutable working
+// memory, that requires introducing a 'Cache' for every simultaneous call.
+//
+// I ended up deciding for now to just keep the "UTF-8 decode and check the
+// table." The DFA and lazy DFA approaches are still below, but commented out.
+//
+// [1]: https://github.com/BurntSushi/ucd-generate/issues/11
+
+/*
+/// A module that looks for word codepoints using lazy DFAs.
+#[cfg(all(
+    feature = "unicode-word-boundary",
+    feature = "syntax",
+    feature = "unicode-perl",
+    feature = "hybrid"
+))]
+mod is_word_char {
+    use alloc::vec::Vec;
+
+    use crate::{
+        hybrid::dfa::{Cache, DFA},
+        nfa::thompson::NFA,
+        util::{lazy::Lazy, pool::Pool, primitives::StateID},
+        Anchored, Input,
+    };
+
+    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn fwd(
+        haystack: &[u8],
+        mut at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        static WORD: Lazy<DFA> = Lazy::new(|| DFA::new(r"\w").unwrap());
+        static CACHE: Lazy<Pool<Cache>> =
+            Lazy::new(|| Pool::new(|| WORD.create_cache()));
+        let dfa = Lazy::get(&WORD);
+        let mut cache = Lazy::get(&CACHE).get();
+        let mut sid = dfa
+            .start_state_forward(
+                &mut cache,
+                &Input::new("").anchored(Anchored::Yes),
+            )
+            .unwrap();
+        while at < haystack.len() {
+            let byte = haystack[at];
+            sid = dfa.next_state(&mut cache, sid, byte).unwrap();
+            at += 1;
+            if sid.is_tagged() {
+                if sid.is_match() {
+                    return Ok(true);
+                } else if sid.is_dead() {
+                    return Ok(false);
+                }
+            }
+        }
+        Ok(dfa.next_eoi_state(&mut cache, sid).unwrap().is_match())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn rev(
+        haystack: &[u8],
+        mut at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        static WORD: Lazy<DFA> = Lazy::new(|| {
+            DFA::builder()
+                .thompson(NFA::config().reverse(true))
+                .build(r"\w")
+                .unwrap()
+        });
+        static CACHE: Lazy<Pool<Cache>> =
+            Lazy::new(|| Pool::new(|| WORD.create_cache()));
+        let dfa = Lazy::get(&WORD);
+        let mut cache = Lazy::get(&CACHE).get();
+        let mut sid = dfa
+            .start_state_reverse(
+                &mut cache,
+                &Input::new("").anchored(Anchored::Yes),
+            )
+            .unwrap();
+        while at > 0 {
+            at -= 1;
+            let byte = haystack[at];
+            sid = dfa.next_state(&mut cache, sid, byte).unwrap();
+            if sid.is_tagged() {
+                if sid.is_match() {
+                    return Ok(true);
+                } else if sid.is_dead() {
+                    return Ok(false);
+                }
+            }
+        }
+        Ok(dfa.next_eoi_state(&mut cache, sid).unwrap().is_match())
+    }
+}
+*/
+
+/*
+/// A module that looks for word codepoints using fully compiled DFAs.
+#[cfg(all(
+    feature = "unicode-word-boundary",
+    feature = "syntax",
+    feature = "unicode-perl",
+    feature = "dfa-build"
+))]
+mod is_word_char {
+    use alloc::vec::Vec;
+
+    use crate::{
+        dfa::{dense::DFA, Automaton, StartKind},
+        nfa::thompson::NFA,
+        util::{lazy::Lazy, primitives::StateID},
+        Anchored, Input,
+    };
+
+    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn fwd(
+        haystack: &[u8],
+        mut at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        static WORD: Lazy<(DFA<Vec<u32>>, StateID)> = Lazy::new(|| {
+            let dfa = DFA::builder()
+                .configure(DFA::config().start_kind(StartKind::Anchored))
+                .build(r"\w")
+                .unwrap();
+            // OK because our regex has no look-around.
+            let start_id = dfa.universal_start_state(Anchored::Yes).unwrap();
+            (dfa, start_id)
+        });
+        let &(ref dfa, mut sid) = Lazy::get(&WORD);
+        while at < haystack.len() {
+            let byte = haystack[at];
+            sid = dfa.next_state(sid, byte);
+            at += 1;
+            if dfa.is_special_state(sid) {
+                if dfa.is_match_state(sid) {
+                    return Ok(true);
+                } else if dfa.is_dead_state(sid) {
+                    return Ok(false);
+                }
+            }
+        }
+        Ok(dfa.is_match_state(dfa.next_eoi_state(sid)))
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn rev(
+        haystack: &[u8],
+        mut at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        static WORD: Lazy<(DFA<Vec<u32>>, StateID)> = Lazy::new(|| {
+            let dfa = DFA::builder()
+                .configure(DFA::config().start_kind(StartKind::Anchored))
+                // From ad hoc measurements, it looks like setting
+                // shrink==false is slightly faster than shrink==true. I kind
+                // of feel like this indicates that shrinking is probably a
+                // failure, although it can help in some cases. Sigh.
+                .thompson(NFA::config().reverse(true).shrink(false))
+                .build(r"\w")
+                .unwrap();
+            // OK because our regex has no look-around.
+            let start_id = dfa.universal_start_state(Anchored::Yes).unwrap();
+            (dfa, start_id)
+        });
+        let &(ref dfa, mut sid) = Lazy::get(&WORD);
+        while at > 0 {
+            at -= 1;
+            let byte = haystack[at];
+            sid = dfa.next_state(sid, byte);
+            if dfa.is_special_state(sid) {
+                if dfa.is_match_state(sid) {
+                    return Ok(true);
+                } else if dfa.is_dead_state(sid) {
+                    return Ok(false);
+                }
+            }
+        }
+        Ok(dfa.is_match_state(dfa.next_eoi_state(sid)))
+    }
+}
+*/
+
+/// A module that looks for word codepoints using regex-syntax's data tables.
+#[cfg(all(
+    feature = "unicode-word-boundary",
+    feature = "syntax",
+    feature = "unicode-perl",
+))]
+mod is_word_char {
+    use regex_syntax::try_is_word_character;
+
+    use crate::util::utf8;
+
+    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn fwd(
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Ok(match utf8::decode(&haystack[at..]) {
+            None | Some(Err(_)) => false,
+            Some(Ok(ch)) => try_is_word_character(ch).expect(
+                "since unicode-word-boundary, syntax and unicode-perl \
+                 are all enabled, it is expected that \
+                 try_is_word_character succeeds",
+            ),
+        })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn rev(
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Ok(match utf8::decode_last(&haystack[..at]) {
+            None | Some(Err(_)) => false,
+            Some(Ok(ch)) => try_is_word_character(ch).expect(
+                "since unicode-word-boundary, syntax and unicode-perl \
+                 are all enabled, it is expected that \
+                 try_is_word_character succeeds",
+            ),
+        })
+    }
+}
+
+/// A module that looks for word codepoints using regex-automata's data tables
+/// (which are only compiled when regex-syntax's tables aren't available).
+///
+/// Note that the cfg should match the one in src/util/unicode_data/mod.rs for
+/// perl_word.
+#[cfg(all(
+    feature = "unicode-word-boundary",
+    not(all(feature = "syntax", feature = "unicode-perl")),
+))]
+mod is_word_char {
+    use crate::util::utf8;
+
+    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn fwd(
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Ok(match utf8::decode(&haystack[at..]) {
+            None | Some(Err(_)) => false,
+            Some(Ok(ch)) => is_word_character(ch),
+        })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn rev(
+        haystack: &[u8],
+        at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Ok(match utf8::decode_last(&haystack[..at]) {
+            None | Some(Err(_)) => false,
+            Some(Ok(ch)) => is_word_character(ch),
+        })
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_word_character(c: char) -> bool {
+        use crate::util::{unicode_data::perl_word::PERL_WORD, utf8};
+
+        // MSRV(1.59): Use 'u8::try_from(c)' instead.
+        if u8::try_from(u32::from(c)).map_or(false, utf8::is_word_byte) {
+            return true;
+        }
+        PERL_WORD
+            .binary_search_by(|&(start, end)| {
+                use core::cmp::Ordering;
+
+                if start <= c && c <= end {
+                    Ordering::Equal
+                } else if start > c {
+                    Ordering::Greater
+                } else {
+                    Ordering::Less
+                }
+            })
+            .is_ok()
+    }
+}
+
+/// A module that always returns an error if Unicode word boundaries are
+/// disabled. When this feature is disabled, then regex-automata will not
+/// include its own data tables even if regex-syntax is disabled.
+#[cfg(not(feature = "unicode-word-boundary"))]
+mod is_word_char {
+    pub(super) fn check() -> Result<(), super::UnicodeWordBoundaryError> {
+        Err(super::UnicodeWordBoundaryError::new())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn fwd(
+        _bytes: &[u8],
+        _at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Err(super::UnicodeWordBoundaryError::new())
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(super) fn rev(
+        _bytes: &[u8],
+        _at: usize,
+    ) -> Result<bool, super::UnicodeWordBoundaryError> {
+        Err(super::UnicodeWordBoundaryError::new())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! testlook {
+        ($look:expr, $haystack:expr, $at:expr) => {
+            LookMatcher::default().matches($look, $haystack.as_bytes(), $at)
+        };
+    }
+
+    #[test]
+    fn look_matches_start_line() {
+        let look = Look::StartLF;
+
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "\n", 0));
+        assert!(testlook!(look, "\n", 1));
+        assert!(testlook!(look, "a", 0));
+        assert!(testlook!(look, "\na", 1));
+
+        assert!(!testlook!(look, "a", 1));
+        assert!(!testlook!(look, "a\na", 1));
+    }
+
+    #[test]
+    fn look_matches_end_line() {
+        let look = Look::EndLF;
+
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "\n", 1));
+        assert!(testlook!(look, "\na", 0));
+        assert!(testlook!(look, "\na", 2));
+        assert!(testlook!(look, "a\na", 1));
+
+        assert!(!testlook!(look, "a", 0));
+        assert!(!testlook!(look, "\na", 1));
+        assert!(!testlook!(look, "a\na", 0));
+        assert!(!testlook!(look, "a\na", 2));
+    }
+
+    #[test]
+    fn look_matches_start_text() {
+        let look = Look::Start;
+
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "\n", 0));
+        assert!(testlook!(look, "a", 0));
+
+        assert!(!testlook!(look, "\n", 1));
+        assert!(!testlook!(look, "\na", 1));
+        assert!(!testlook!(look, "a", 1));
+        assert!(!testlook!(look, "a\na", 1));
+    }
+
+    #[test]
+    fn look_matches_end_text() {
+        let look = Look::End;
+
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "\n", 1));
+        assert!(testlook!(look, "\na", 2));
+
+        assert!(!testlook!(look, "\na", 0));
+        assert!(!testlook!(look, "a\na", 1));
+        assert!(!testlook!(look, "a", 0));
+        assert!(!testlook!(look, "\na", 1));
+        assert!(!testlook!(look, "a\na", 0));
+        assert!(!testlook!(look, "a\na", 2));
+    }
+
+    #[test]
+    #[cfg(all(not(miri), feature = "unicode-word-boundary"))]
+    fn look_matches_word_unicode() {
+        let look = Look::WordUnicode;
+
+        // \xF0\x9D\x9B\x83 = 𝛃 (in \w)
+        // \xF0\x90\x86\x80 = 𐆀 (not in \w)
+
+        // Simple ASCII word boundaries.
+        assert!(testlook!(look, "a", 0));
+        assert!(testlook!(look, "a", 1));
+        assert!(testlook!(look, "a ", 1));
+        assert!(testlook!(look, " a ", 1));
+        assert!(testlook!(look, " a ", 2));
+
+        // Unicode word boundaries with a non-ASCII codepoint.
+        assert!(testlook!(look, "𝛃", 0));
+        assert!(testlook!(look, "𝛃", 4));
+        assert!(testlook!(look, "𝛃 ", 4));
+        assert!(testlook!(look, " 𝛃 ", 1));
+        assert!(testlook!(look, " 𝛃 ", 5));
+
+        // Unicode word boundaries between non-ASCII codepoints.
+        assert!(testlook!(look, "𝛃𐆀", 0));
+        assert!(testlook!(look, "𝛃𐆀", 4));
+
+        // Non word boundaries for ASCII.
+        assert!(!testlook!(look, "", 0));
+        assert!(!testlook!(look, "ab", 1));
+        assert!(!testlook!(look, "a ", 2));
+        assert!(!testlook!(look, " a ", 0));
+        assert!(!testlook!(look, " a ", 3));
+
+        // Non word boundaries with a non-ASCII codepoint.
+        assert!(!testlook!(look, "𝛃b", 4));
+        assert!(!testlook!(look, "𝛃 ", 5));
+        assert!(!testlook!(look, " 𝛃 ", 0));
+        assert!(!testlook!(look, " 𝛃 ", 6));
+        assert!(!testlook!(look, "𝛃", 1));
+        assert!(!testlook!(look, "𝛃", 2));
+        assert!(!testlook!(look, "𝛃", 3));
+
+        // Non word boundaries with non-ASCII codepoints.
+        assert!(!testlook!(look, "𝛃𐆀", 1));
+        assert!(!testlook!(look, "𝛃𐆀", 2));
+        assert!(!testlook!(look, "𝛃𐆀", 3));
+        assert!(!testlook!(look, "𝛃𐆀", 5));
+        assert!(!testlook!(look, "𝛃𐆀", 6));
+        assert!(!testlook!(look, "𝛃𐆀", 7));
+        assert!(!testlook!(look, "𝛃𐆀", 8));
+    }
+
+    #[test]
+    fn look_matches_word_ascii() {
+        let look = Look::WordAscii;
+
+        // \xF0\x9D\x9B\x83 = 𝛃 (in \w)
+        // \xF0\x90\x86\x80 = 𐆀 (not in \w)
+
+        // Simple ASCII word boundaries.
+        assert!(testlook!(look, "a", 0));
+        assert!(testlook!(look, "a", 1));
+        assert!(testlook!(look, "a ", 1));
+        assert!(testlook!(look, " a ", 1));
+        assert!(testlook!(look, " a ", 2));
+
+        // Unicode word boundaries with a non-ASCII codepoint. Since this is
+        // an ASCII word boundary, none of these match.
+        assert!(!testlook!(look, "𝛃", 0));
+        assert!(!testlook!(look, "𝛃", 4));
+        assert!(!testlook!(look, "𝛃 ", 4));
+        assert!(!testlook!(look, " 𝛃 ", 1));
+        assert!(!testlook!(look, " 𝛃 ", 5));
+
+        // Unicode word boundaries between non-ASCII codepoints. Again, since
+        // this is an ASCII word boundary, none of these match.
+        assert!(!testlook!(look, "𝛃𐆀", 0));
+        assert!(!testlook!(look, "𝛃𐆀", 4));
+
+        // Non word boundaries for ASCII.
+        assert!(!testlook!(look, "", 0));
+        assert!(!testlook!(look, "ab", 1));
+        assert!(!testlook!(look, "a ", 2));
+        assert!(!testlook!(look, " a ", 0));
+        assert!(!testlook!(look, " a ", 3));
+
+        // Non word boundaries with a non-ASCII codepoint.
+        assert!(testlook!(look, "𝛃b", 4));
+        assert!(!testlook!(look, "𝛃 ", 5));
+        assert!(!testlook!(look, " 𝛃 ", 0));
+        assert!(!testlook!(look, " 𝛃 ", 6));
+        assert!(!testlook!(look, "𝛃", 1));
+        assert!(!testlook!(look, "𝛃", 2));
+        assert!(!testlook!(look, "𝛃", 3));
+
+        // Non word boundaries with non-ASCII codepoints.
+        assert!(!testlook!(look, "𝛃𐆀", 1));
+        assert!(!testlook!(look, "𝛃𐆀", 2));
+        assert!(!testlook!(look, "𝛃𐆀", 3));
+        assert!(!testlook!(look, "𝛃𐆀", 5));
+        assert!(!testlook!(look, "𝛃𐆀", 6));
+        assert!(!testlook!(look, "𝛃𐆀", 7));
+        assert!(!testlook!(look, "𝛃𐆀", 8));
+    }
+
+    #[test]
+    #[cfg(all(not(miri), feature = "unicode-word-boundary"))]
+    fn look_matches_word_unicode_negate() {
+        let look = Look::WordUnicodeNegate;
+
+        // \xF0\x9D\x9B\x83 = 𝛃 (in \w)
+        // \xF0\x90\x86\x80 = 𐆀 (not in \w)
+
+        // Simple ASCII word boundaries.
+        assert!(!testlook!(look, "a", 0));
+        assert!(!testlook!(look, "a", 1));
+        assert!(!testlook!(look, "a ", 1));
+        assert!(!testlook!(look, " a ", 1));
+        assert!(!testlook!(look, " a ", 2));
+
+        // Unicode word boundaries with a non-ASCII codepoint.
+        assert!(!testlook!(look, "𝛃", 0));
+        assert!(!testlook!(look, "𝛃", 4));
+        assert!(!testlook!(look, "𝛃 ", 4));
+        assert!(!testlook!(look, " 𝛃 ", 1));
+        assert!(!testlook!(look, " 𝛃 ", 5));
+
+        // Unicode word boundaries between non-ASCII codepoints.
+        assert!(!testlook!(look, "𝛃𐆀", 0));
+        assert!(!testlook!(look, "𝛃𐆀", 4));
+
+        // Non word boundaries for ASCII.
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "ab", 1));
+        assert!(testlook!(look, "a ", 2));
+        assert!(testlook!(look, " a ", 0));
+        assert!(testlook!(look, " a ", 3));
+
+        // Non word boundaries with a non-ASCII codepoint.
+        assert!(testlook!(look, "𝛃b", 4));
+        assert!(testlook!(look, "𝛃 ", 5));
+        assert!(testlook!(look, " 𝛃 ", 0));
+        assert!(testlook!(look, " 𝛃 ", 6));
+        // These don't match because they could otherwise return an offset that
+        // splits the UTF-8 encoding of a codepoint.
+        assert!(!testlook!(look, "𝛃", 1));
+        assert!(!testlook!(look, "𝛃", 2));
+        assert!(!testlook!(look, "𝛃", 3));
+
+        // Non word boundaries with non-ASCII codepoints. These also don't
+        // match because they could otherwise return an offset that splits the
+        // UTF-8 encoding of a codepoint.
+        assert!(!testlook!(look, "𝛃𐆀", 1));
+        assert!(!testlook!(look, "𝛃𐆀", 2));
+        assert!(!testlook!(look, "𝛃𐆀", 3));
+        assert!(!testlook!(look, "𝛃𐆀", 5));
+        assert!(!testlook!(look, "𝛃𐆀", 6));
+        assert!(!testlook!(look, "𝛃𐆀", 7));
+        // But this one does, since 𐆀 isn't a word codepoint, and 8 is the end
+        // of the haystack. So the "end" of the haystack isn't a word and 𐆀
+        // isn't a word, thus, \B matches.
+        assert!(testlook!(look, "𝛃𐆀", 8));
+    }
+
+    #[test]
+    fn look_matches_word_ascii_negate() {
+        let look = Look::WordAsciiNegate;
+
+        // \xF0\x9D\x9B\x83 = 𝛃 (in \w)
+        // \xF0\x90\x86\x80 = 𐆀 (not in \w)
+
+        // Simple ASCII word boundaries.
+        assert!(!testlook!(look, "a", 0));
+        assert!(!testlook!(look, "a", 1));
+        assert!(!testlook!(look, "a ", 1));
+        assert!(!testlook!(look, " a ", 1));
+        assert!(!testlook!(look, " a ", 2));
+
+        // Unicode word boundaries with a non-ASCII codepoint. Since this is
+        // an ASCII word boundary, none of these match.
+        assert!(testlook!(look, "𝛃", 0));
+        assert!(testlook!(look, "𝛃", 4));
+        assert!(testlook!(look, "𝛃 ", 4));
+        assert!(testlook!(look, " 𝛃 ", 1));
+        assert!(testlook!(look, " 𝛃 ", 5));
+
+        // Unicode word boundaries between non-ASCII codepoints. Again, since
+        // this is an ASCII word boundary, none of these match.
+        assert!(testlook!(look, "𝛃𐆀", 0));
+        assert!(testlook!(look, "𝛃𐆀", 4));
+
+        // Non word boundaries for ASCII.
+        assert!(testlook!(look, "", 0));
+        assert!(testlook!(look, "ab", 1));
+        assert!(testlook!(look, "a ", 2));
+        assert!(testlook!(look, " a ", 0));
+        assert!(testlook!(look, " a ", 3));
+
+        // Non word boundaries with a non-ASCII codepoint.
+        assert!(!testlook!(look, "𝛃b", 4));
+        assert!(testlook!(look, "𝛃 ", 5));
+        assert!(testlook!(look, " 𝛃 ", 0));
+        assert!(testlook!(look, " 𝛃 ", 6));
+        assert!(testlook!(look, "𝛃", 1));
+        assert!(testlook!(look, "𝛃", 2));
+        assert!(testlook!(look, "𝛃", 3));
+
+        // Non word boundaries with non-ASCII codepoints.
+        assert!(testlook!(look, "𝛃𐆀", 1));
+        assert!(testlook!(look, "𝛃𐆀", 2));
+        assert!(testlook!(look, "𝛃𐆀", 3));
+        assert!(testlook!(look, "𝛃𐆀", 5));
+        assert!(testlook!(look, "𝛃𐆀", 6));
+        assert!(testlook!(look, "𝛃𐆀", 7));
+        assert!(testlook!(look, "𝛃𐆀", 8));
+    }
+
+    #[test]
+    fn look_set() {
+        let mut f = LookSet::default();
+        assert!(!f.contains(Look::Start));
+        assert!(!f.contains(Look::End));
+        assert!(!f.contains(Look::StartLF));
+        assert!(!f.contains(Look::EndLF));
+        assert!(!f.contains(Look::WordUnicode));
+        assert!(!f.contains(Look::WordUnicodeNegate));
+        assert!(!f.contains(Look::WordAscii));
+        assert!(!f.contains(Look::WordAsciiNegate));
+
+        f = f.insert(Look::Start);
+        assert!(f.contains(Look::Start));
+        f = f.remove(Look::Start);
+        assert!(!f.contains(Look::Start));
+
+        f = f.insert(Look::End);
+        assert!(f.contains(Look::End));
+        f = f.remove(Look::End);
+        assert!(!f.contains(Look::End));
+
+        f = f.insert(Look::StartLF);
+        assert!(f.contains(Look::StartLF));
+        f = f.remove(Look::StartLF);
+        assert!(!f.contains(Look::StartLF));
+
+        f = f.insert(Look::EndLF);
+        assert!(f.contains(Look::EndLF));
+        f = f.remove(Look::EndLF);
+        assert!(!f.contains(Look::EndLF));
+
+        f = f.insert(Look::StartCRLF);
+        assert!(f.contains(Look::StartCRLF));
+        f = f.remove(Look::StartCRLF);
+        assert!(!f.contains(Look::StartCRLF));
+
+        f = f.insert(Look::EndCRLF);
+        assert!(f.contains(Look::EndCRLF));
+        f = f.remove(Look::EndCRLF);
+        assert!(!f.contains(Look::EndCRLF));
+
+        f = f.insert(Look::WordUnicode);
+        assert!(f.contains(Look::WordUnicode));
+        f = f.remove(Look::WordUnicode);
+        assert!(!f.contains(Look::WordUnicode));
+
+        f = f.insert(Look::WordUnicodeNegate);
+        assert!(f.contains(Look::WordUnicodeNegate));
+        f = f.remove(Look::WordUnicodeNegate);
+        assert!(!f.contains(Look::WordUnicodeNegate));
+
+        f = f.insert(Look::WordAscii);
+        assert!(f.contains(Look::WordAscii));
+        f = f.remove(Look::WordAscii);
+        assert!(!f.contains(Look::WordAscii));
+
+        f = f.insert(Look::WordAsciiNegate);
+        assert!(f.contains(Look::WordAsciiNegate));
+        f = f.remove(Look::WordAsciiNegate);
+        assert!(!f.contains(Look::WordAsciiNegate));
+    }
+
+    #[test]
+    fn look_set_iter() {
+        let set = LookSet::empty();
+        assert_eq!(0, set.iter().count());
+
+        let set = LookSet::full();
+        assert_eq!(10, set.iter().count());
+
+        let set =
+            LookSet::empty().insert(Look::StartLF).insert(Look::WordUnicode);
+        assert_eq!(2, set.iter().count());
+
+        let set = LookSet::empty().insert(Look::StartLF);
+        assert_eq!(1, set.iter().count());
+
+        let set = LookSet::empty().insert(Look::WordAsciiNegate);
+        assert_eq!(1, set.iter().count());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn look_set_debug() {
+        let res = alloc::format!("{:?}", LookSet::empty());
+        assert_eq!("∅", res);
+        let res = alloc::format!("{:?}", LookSet::full());
+        assert_eq!("Az^$rRbB𝛃𝚩", res);
+    }
+}
diff --git a/regex-automata/src/util/memchr.rs b/regex-automata/src/util/memchr.rs
new file mode 100644
index 0000000000..a2cbb07321
--- /dev/null
+++ b/regex-automata/src/util/memchr.rs
@@ -0,0 +1,93 @@
+/*!
+This module defines simple wrapper routines for the memchr functions from the
+`memchr` crate. Basically, when the `memchr` crate is available, we use it,
+otherwise we use a naive implementation which is still pretty fast.
+*/
+
+pub(crate) use self::inner::*;
+
+#[cfg(feature = "perf-literal-substring")]
+pub(super) mod inner {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr(n1: u8, haystack: &[u8]) -> Option<usize> {
+        memchr::memchr(n1, haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr2(n1: u8, n2: u8, haystack: &[u8]) -> Option<usize> {
+        memchr::memchr2(n1, n2, haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr3(
+        n1: u8,
+        n2: u8,
+        n3: u8,
+        haystack: &[u8],
+    ) -> Option<usize> {
+        memchr::memchr3(n1, n2, n3, haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr(n1: u8, haystack: &[u8]) -> Option<usize> {
+        memchr::memrchr(n1, haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr2(n1: u8, n2: u8, haystack: &[u8]) -> Option<usize> {
+        memchr::memrchr2(n1, n2, haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr3(
+        n1: u8,
+        n2: u8,
+        n3: u8,
+        haystack: &[u8],
+    ) -> Option<usize> {
+        memchr::memrchr3(n1, n2, n3, haystack)
+    }
+}
+
+#[cfg(not(feature = "perf-literal-substring"))]
+pub(super) mod inner {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr(n1: u8, haystack: &[u8]) -> Option<usize> {
+        haystack.iter().position(|&b| b == n1)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr2(n1: u8, n2: u8, haystack: &[u8]) -> Option<usize> {
+        haystack.iter().position(|&b| b == n1 || b == n2)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memchr3(
+        n1: u8,
+        n2: u8,
+        n3: u8,
+        haystack: &[u8],
+    ) -> Option<usize> {
+        haystack.iter().position(|&b| b == n1 || b == n2 || b == n3)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr(n1: u8, haystack: &[u8]) -> Option<usize> {
+        haystack.iter().rposition(|&b| b == n1)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr2(n1: u8, n2: u8, haystack: &[u8]) -> Option<usize> {
+        haystack.iter().rposition(|&b| b == n1 || b == n2)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn memrchr3(
+        n1: u8,
+        n2: u8,
+        n3: u8,
+        haystack: &[u8],
+    ) -> Option<usize> {
+        haystack.iter().rposition(|&b| b == n1 || b == n2 || b == n3)
+    }
+}
diff --git a/regex-automata/src/util/mod.rs b/regex-automata/src/util/mod.rs
new file mode 100644
index 0000000000..bb739df1df
--- /dev/null
+++ b/regex-automata/src/util/mod.rs
@@ -0,0 +1,57 @@
+/*!
+A collection of modules that provide APIs that are useful across many regex
+engines.
+
+While one should explore the sub-modules directly to get a sense of what's
+there, here are some highlights that tie the sub-modules to higher level
+use cases:
+
+* `alphabet` contains APIs that are useful if you're doing low level things
+with the DFAs in this crate. For example, implementing determinization or
+walking its state graph directly.
+* `captures` contains APIs for dealing with capture group matches and their
+mapping to "slots" used inside an NFA graph. This is also where you can find
+iterators over capture group names.
+* `escape` contains types for pretty-printing raw byte slices as strings.
+* `iter` contains API helpers for writing regex iterators.
+* `lazy` contains a no-std and no-alloc variant of `lazy_static!` and
+`once_cell`.
+* `look` contains APIs for matching and configuring look-around assertions.
+* `pool` provides a way to reuse mutable memory allocated in a thread safe
+manner.
+* `prefilter` provides APIs for building prefilters and using them in searches.
+* `primitives` are what you might use if you're doing lower level work on
+automata, such as walking an NFA state graph.
+* `syntax` provides some higher level convenience functions for interacting
+with the `regex-syntax` crate.
+* `wire` is useful if you're working with DFA serialization.
+*/
+
+pub mod alphabet;
+#[cfg(feature = "alloc")]
+pub mod captures;
+pub mod escape;
+#[cfg(feature = "alloc")]
+pub mod interpolate;
+pub mod iter;
+pub mod lazy;
+pub mod look;
+#[cfg(feature = "alloc")]
+pub mod pool;
+pub mod prefilter;
+pub mod primitives;
+#[cfg(feature = "syntax")]
+pub mod syntax;
+pub mod wire;
+
+#[cfg(any(feature = "dfa-build", feature = "hybrid"))]
+pub(crate) mod determinize;
+pub(crate) mod empty;
+pub(crate) mod int;
+pub(crate) mod memchr;
+pub(crate) mod search;
+#[cfg(feature = "alloc")]
+pub(crate) mod sparse_set;
+pub(crate) mod start;
+pub(crate) mod unicode_data;
+pub(crate) mod utf8;
diff --git a/regex-automata/src/util/pool.rs b/regex-automata/src/util/pool.rs
new file mode 100644
index 0000000000..7f4a1c21e2
--- /dev/null
+++ b/regex-automata/src/util/pool.rs
@@ -0,0 +1,993 @@
+// This module provides a relatively simple thread-safe pool of reusable
+// objects. For the most part, it's implemented by a stack represented by a
+// Mutex<Vec<T>>. It has one small trick: because unlocking a mutex is somewhat
+// costly, in the case where a pool is accessed by the first thread that tried
+// to get a value, we bypass the mutex. Here are some benchmarks showing the
+// difference.
+//
+// 2022-10-15: These benchmarks are from the old regex crate and they aren't
+// easy to reproduce because some rely on older implementations of Pool that
+// are no longer around. I've left the results here for posterity, but any
+// enterprising individual should feel encouraged to re-litigate the way Pool
+// works. I am not at all certain it is the best approach.
+//
+// 1) misc::anchored_literal_long_non_match    21 (18571 MB/s)
+// 2) misc::anchored_literal_long_non_match   107 (3644 MB/s)
+// 3) misc::anchored_literal_long_non_match    45 (8666 MB/s)
+// 4) misc::anchored_literal_long_non_match    19 (20526 MB/s)
+//
+// (1) represents our baseline: the master branch at the time of writing when
+// using the 'thread_local' crate to implement the pool below.
+//
+// (2) represents a naive pool implemented completely via Mutex<Vec<T>>. There
+// is no special trick for bypassing the mutex.
+//
+// (3) is the same as (2), except it uses Mutex<Vec<Box<T>>>. It is twice as
+// fast because a Box<T> is much smaller than the T we use with a Pool in this
+// crate. So pushing and popping a Box<T> from a Vec is quite a bit faster
+// than for T.
+//
+// (4) is the same as (3), but with the trick for bypassing the mutex in the
+// case of the first-to-get thread.
+//
+// Why move off of thread_local? Even though (4) is a hair faster than (1)
+// above, this was not the main goal. The main goal was to move off of
+// thread_local and find a way to *simply* re-capture some of its speed for
+// regex's specific case. So again, why move off of it? The *primary* reason is
+// because of memory leaks. See https://github.com/rust-lang/regex/issues/362
+// for example. (Why do I want it to be simple? Well, I suppose what I mean is,
+// "use as much safe code as possible to minimize risk and be as sure as I can
+// be that it is correct.")
+//
+// My guess is that the thread_local design is probably not appropriate for
+// regex since its memory usage scales to the number of active threads that
+// have used a regex, where as the pool below scales to the number of threads
+// that simultaneously use a regex. While neither case permits contraction,
+// since we own the pool data structure below, we can add contraction if a
+// clear use case pops up in the wild. More pressingly though, it seems that
+// there are at least some use case patterns where one might have many threads
+// sitting around that might have used a regex at one point. While thread_local
+// does try to reuse space previously used by a thread that has since stopped,
+// its maximal memory usage still scales with the total number of active
+// threads. In contrast, the pool below scales with the total number of threads
+// *simultaneously* using the pool. The hope is that this uses less memory
+// overall. And if it doesn't, we can hopefully tune it somehow.
+//
+// It seems that these sort of conditions happen frequently
+// in FFI inside of other more "managed" languages. This was
+// mentioned in the issue linked above, and also mentioned here:
+// https://github.com/BurntSushi/rure-go/issues/3. And in particular, users
+// confirm that disabling the use of thread_local resolves the leak.
+//
+// There were other weaker reasons for moving off of thread_local as well.
+// Namely, at the time, I was looking to reduce dependencies. And for something
+// like regex, maintenance can be simpler when we own the full dependency tree.
+//
+// Note that I am not entirely happy with this pool. It has some subtle
+// implementation details and is overall still observable (even with the
+// thread owner optimization) in benchmarks. If someone wants to take a crack
+// at building something better, please file an issue. Even if it means a
+// different API. The API exposed by this pool is not the minimal thing that
+// something like a 'Regex' actually needs. It could adapt to, for example,
+// an API more like what is found in the 'thread_local' crate. However, we do
+// really need to support the no-std alloc-only context, or else the regex
+// crate wouldn't be able to support no-std alloc-only. However, I'm generally
+// okay with making the alloc-only context slower (as it is here), although I
+// do find it unfortunate.
+
+/*!
+A thread safe memory pool.
+
+The principal type in this module is a [`Pool`]. It main use case is for
+holding a thread safe collection of mutable scratch spaces (usually called
+`Cache` in this crate) that regex engines need to execute a search. This then
+permits sharing the same read-only regex object across multiple threads while
+having a quick way of reusing scratch space in a thread safe way. This avoids
+needing to re-create the scratch space for every search, which could wind up
+being quite expensive.
+*/
+
+/// A thread safe pool that works in an `alloc`-only context.
+///
+/// Getting a value out comes with a guard. When that guard is dropped, the
+/// value is automatically put back in the pool. The guard provides both a
+/// `Deref` and a `DerefMut` implementation for easy access to an underlying
+/// `T`.
+///
+/// A `Pool` impls `Sync` when `T` is `Send` (even if `T` is not `Sync`). This
+/// is possible because a pool is guaranteed to provide a value to exactly one
+/// thread at any time.
+///
+/// Currently, a pool never contracts in size. Its size is proportional to the
+/// maximum number of simultaneous uses. This may change in the future.
+///
+/// A `Pool` is a particularly useful data structure for this crate because
+/// many of the regex engines require a mutable "cache" in order to execute
+/// a search. Since regexes themselves tend to be global, the problem is then:
+/// how do you get a mutable cache to execute a search? You could:
+///
+/// 1. Use a `thread_local!`, which requires the standard library and requires
+/// that the regex pattern be statically known.
+/// 2. Use a `Pool`.
+/// 3. Make the cache an explicit dependency in your code and pass it around.
+/// 4. Put the cache state in a `Mutex`, but this means only one search can
+/// execute at a time.
+/// 5. Create a new cache for every search.
+///
+/// A `thread_local!` is perhaps the best choice if it works for your use case.
+/// Putting the cache in a mutex or creating a new cache for every search are
+/// perhaps the worst choices. Of the remaining two choices, whether you use
+/// this `Pool` or thread through a cache explicitly in your code is a matter
+/// of taste and depends on your code architecture.
+///
+/// # Warning: may use a spin lock
+///
+/// When this crate is compiled _without_ the `std` feature, then this type
+/// may used a spin lock internally. This can have subtle effects that may
+/// be undesirable. See [Spinlocks Considered Harmful][spinharm] for a more
+/// thorough treatment of this topic.
+///
+/// [spinharm]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html
+///
+/// # Example
+///
+/// This example shows how to share a single hybrid regex among multiple
+/// threads, while also safely getting exclusive access to a hybrid's
+/// [`Cache`](crate::hybrid::regex::Cache) without preventing other searches
+/// from running while your thread uses the `Cache`.
+///
+/// ```
+/// use regex_automata::{
+///     hybrid::regex::{Cache, Regex},
+///     util::{lazy::Lazy, pool::Pool},
+///     Match,
+/// };
+///
+/// static RE: Lazy<Regex> =
+///     Lazy::new(|| Regex::new("foo[0-9]+bar").unwrap());
+/// static CACHE: Lazy<Pool<Cache>> =
+///     Lazy::new(|| Pool::new(|| RE.create_cache()));
+///
+/// let expected = Some(Match::must(0, 3..14));
+/// assert_eq!(expected, RE.find(&mut CACHE.get(), b"zzzfoo12345barzzz"));
+/// ```
+pub struct Pool<T, F = fn() -> T>(alloc::boxed::Box<inner::Pool<T, F>>);
+
+impl<T, F> Pool<T, F> {
+    /// Create a new pool. The given closure is used to create values in
+    /// the pool when necessary.
+    pub fn new(create: F) -> Pool<T, F> {
+        Pool(alloc::boxed::Box::new(inner::Pool::new(create)))
+    }
+}
+
+impl<T: Send, F: Fn() -> T> Pool<T, F> {
+    /// Get a value from the pool. The caller is guaranteed to have
+    /// exclusive access to the given value. Namely, it is guaranteed that
+    /// this will never return a value that was returned by another call to
+    /// `get` but was not put back into the pool.
+    ///
+    /// When the guard goes out of scope and its destructor is called, then
+    /// it will automatically be put back into the pool. Alternatively,
+    /// [`PoolGuard::put`] may be used to explicitly put it back in the pool
+    /// without relying on its destructor.
+    ///
+    /// Note that there is no guarantee provided about which value in the
+    /// pool is returned. That is, calling get, dropping the guard (causing
+    /// the value to go back into the pool) and then calling get again is
+    /// *not* guaranteed to return the same value received in the first `get`
+    /// call.
+    pub fn get(&self) -> PoolGuard<'_, T, F> {
+        PoolGuard(self.0.get())
+    }
+}
+
+impl<T: core::fmt::Debug, F> core::fmt::Debug for Pool<T, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_tuple("Pool").field(&self.0).finish()
+    }
+}
+
+/// A guard that is returned when a caller requests a value from the pool.
+///
+/// The purpose of the guard is to use RAII to automatically put the value
+/// back in the pool once it's dropped.
+pub struct PoolGuard<'a, T: Send, F: Fn() -> T>(inner::PoolGuard<'a, T, F>);
+
+impl<'a, T: Send, F: Fn() -> T> PoolGuard<'a, T, F> {
+    /// Consumes this guard and puts it back into the pool.
+    ///
+    /// This circumvents the guard's `Drop` implementation. This can be useful
+    /// in circumstances where the automatic `Drop` results in poorer codegen,
+    /// such as calling non-inlined functions.
+    pub fn put(this: PoolGuard<'_, T, F>) {
+        inner::PoolGuard::put(this.0);
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::Deref for PoolGuard<'a, T, F> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.0.value()
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::DerefMut for PoolGuard<'a, T, F> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.0.value_mut()
+    }
+}
+
+impl<'a, T: Send + core::fmt::Debug, F: Fn() -> T> core::fmt::Debug
+    for PoolGuard<'a, T, F>
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_tuple("PoolGuard").field(&self.0).finish()
+    }
+}
+
+#[cfg(feature = "std")]
+mod inner {
+    use core::{
+        cell::UnsafeCell,
+        panic::{RefUnwindSafe, UnwindSafe},
+        sync::atomic::{AtomicUsize, Ordering},
+    };
+
+    use alloc::{boxed::Box, vec, vec::Vec};
+
+    use std::{sync::Mutex, thread_local};
+
+    /// An atomic counter used to allocate thread IDs.
+    ///
+    /// We specifically start our counter at 3 so that we can use the values
+    /// less than it as sentinels.
+    static COUNTER: AtomicUsize = AtomicUsize::new(3);
+
+    /// A thread ID indicating that there is no owner. This is the initial
+    /// state of a pool. Once a pool has an owner, there is no way to change
+    /// it.
+    static THREAD_ID_UNOWNED: usize = 0;
+
+    /// A thread ID indicating that the special owner value is in use and not
+    /// available. This state is useful for avoiding a case where the owner
+    /// of a pool calls `get` before putting the result of a previous `get`
+    /// call back into the pool.
+    static THREAD_ID_INUSE: usize = 1;
+
+    /// This sentinel is used to indicate that a guard has already been dropped
+    /// and should not be re-dropped. We use this because our drop code can be
+    /// called outside of Drop and thus there could be a bug in the internal
+    /// implementation that results in trying to put the same guard back into
+    /// the same pool multiple times, and *that* could result in UB if we
+    /// didn't mark the guard as already having been put back in the pool.
+    ///
+    /// So this isn't strictly necessary, but this let's us define some
+    /// routines as safe (like PoolGuard::put_imp) that we couldn't otherwise
+    /// do.
+    static THREAD_ID_DROPPED: usize = 2;
+
+    thread_local!(
+        /// A thread local used to assign an ID to a thread.
+        static THREAD_ID: usize = {
+            let next = COUNTER.fetch_add(1, Ordering::Relaxed);
+            // SAFETY: We cannot permit the reuse of thread IDs since reusing a
+            // thread ID might result in more than one thread "owning" a pool,
+            // and thus, permit accessing a mutable value from multiple threads
+            // simultaneously without synchronization. The intent of this panic
+            // is to be a sanity check. It is not expected that the thread ID
+            // space will actually be exhausted in practice. Even on a 32-bit
+            // system, it would require spawning 2^32 threads (although they
+            // wouldn't all need to run simultaneously, so it is in theory
+            // possible).
+            //
+            // This checks that the counter never wraps around, since atomic
+            // addition wraps around on overflow.
+            if next == 0 {
+                panic!("regex: thread ID allocation space exhausted");
+            }
+            next
+        };
+    );
+
+    /// A thread safe pool utilizing std-only features.
+    ///
+    /// The main difference between this and the simplistic alloc-only pool is
+    /// the use of std::sync::Mutex and an "owner thread" optimization that
+    /// makes accesses by the owner of a pool faster than all other threads.
+    /// This makes the common case of running a regex within a single thread
+    /// faster by avoiding mutex unlocking.
+    pub(super) struct Pool<T, F> {
+        /// A stack of T values to hand out. These are used when a Pool is
+        /// accessed by a thread that didn't create it.
+        stack: Mutex<Vec<Box<T>>>,
+        /// A function to create more T values when stack is empty and a caller
+        /// has requested a T.
+        create: F,
+        /// The ID of the thread that owns this pool. The owner is the thread
+        /// that makes the first call to 'get'. When the owner calls 'get', it
+        /// gets 'owner_val' directly instead of returning a T from 'stack'.
+        /// See comments elsewhere for details, but this is intended to be an
+        /// optimization for the common case that makes getting a T faster.
+        ///
+        /// It is initialized to a value of zero (an impossible thread ID) as a
+        /// sentinel to indicate that it is unowned.
+        owner: AtomicUsize,
+        /// A value to return when the caller is in the same thread that
+        /// first called `Pool::get`.
+        ///
+        /// This is set to None when a Pool is first created, and set to Some
+        /// once the first thread calls Pool::get.
+        owner_val: UnsafeCell<Option<T>>,
+    }
+
+    // SAFETY: Since we want to use a Pool from multiple threads simultaneously
+    // behind an Arc, we need for it to be Sync. In cases where T is sync,
+    // Pool<T> would be Sync. However, since we use a Pool to store mutable
+    // scratch space, we wind up using a T that has interior mutability and is
+    // thus itself not Sync. So what we *really* want is for our Pool<T> to by
+    // Sync even when T is not Sync (but is at least Send).
+    //
+    // The only non-sync aspect of a Pool is its 'owner_val' field, which is
+    // used to implement faster access to a pool value in the common case of
+    // a pool being accessed in the same thread in which it was created. The
+    // 'stack' field is also shared, but a Mutex<T> where T: Send is already
+    // Sync. So we only need to worry about 'owner_val'.
+    //
+    // The key is to guarantee that 'owner_val' can only ever be accessed from
+    // one thread. In our implementation below, we guarantee this by only
+    // returning the 'owner_val' when the ID of the current thread matches the
+    // ID of the thread that first called 'Pool::get'. Since this can only ever
+    // be one thread, it follows that only one thread can access 'owner_val' at
+    // any point in time. Thus, it is safe to declare that Pool<T> is Sync when
+    // T is Send.
+    //
+    // If there is a way to achieve our performance goals using safe code, then
+    // I would very much welcome a patch. As it stands, the implementation
+    // below tries to balance safety with performance. The case where a Regex
+    // is used from multiple threads simultaneously will suffer a bit since
+    // getting a value out of the pool will require unlocking a mutex.
+    //
+    // We require `F: Send + Sync` because we call `F` at any point on demand,
+    // potentially from multiple threads simultaneously.
+    unsafe impl<T: Send, F: Send + Sync> Sync for Pool<T, F> {}
+
+    // If T is UnwindSafe, then since we provide exclusive access to any
+    // particular value in the pool, it should therefore also be considered
+    // RefUnwindSafe. Also, since we use std::sync::Mutex, we get poisoning
+    // from it if another thread panics while the lock is held.
+    //
+    // We require `F: UnwindSafe + RefUnwindSafe` because we call `F` at any
+    // point on demand, so it needs to be unwind safe on both dimensions for
+    // the entire Pool to be unwind safe.
+    impl<T: UnwindSafe, F: UnwindSafe + RefUnwindSafe> RefUnwindSafe
+        for Pool<T, F>
+    {
+    }
+
+    impl<T, F> Pool<T, F> {
+        /// Create a new pool. The given closure is used to create values in
+        /// the pool when necessary.
+        pub(super) fn new(create: F) -> Pool<T, F> {
+            // MSRV(1.63): Mark this function as 'const'. I've arranged the
+            // code such that it should "just work." Then mark the public
+            // 'Pool::new' method as 'const' too. (The alloc-only Pool::new
+            // is already 'const', so that should "just work" too.) The only
+            // thing we're waiting for is Mutex::new to be const.
+            let owner = AtomicUsize::new(THREAD_ID_UNOWNED);
+            let owner_val = UnsafeCell::new(None); // init'd on first access
+            Pool { stack: Mutex::new(vec![]), create, owner, owner_val }
+        }
+    }
+
+    impl<T: Send, F: Fn() -> T> Pool<T, F> {
+        /// Get a value from the pool. This may block if another thread is also
+        /// attempting to retrieve a value from the pool.
+        pub(super) fn get(&self) -> PoolGuard<'_, T, F> {
+            // Our fast path checks if the caller is the thread that "owns"
+            // this pool. Or stated differently, whether it is the first thread
+            // that tried to extract a value from the pool. If it is, then we
+            // can return a T to the caller without going through a mutex.
+            //
+            // SAFETY: We must guarantee that only one thread gets access
+            // to this value. Since a thread is uniquely identified by the
+            // THREAD_ID thread local, it follows that if the caller's thread
+            // ID is equal to the owner, then only one thread may receive this
+            // value. This is also why we can get away with what looks like a
+            // racy load and a store. We know that if 'owner == caller', then
+            // only one thread can be here, so we don't need to worry about any
+            // other thread setting the owner to something else.
+            let caller = THREAD_ID.with(|id| *id);
+            let owner = self.owner.load(Ordering::Acquire);
+            if caller == owner {
+                self.owner.store(THREAD_ID_INUSE, Ordering::Release);
+                return self.guard_owned(caller);
+            }
+            self.get_slow(caller, owner)
+        }
+
+        /// This is the "slow" version that goes through a mutex to pop an
+        /// allocated value off a stack to return to the caller. (Or, if the
+        /// stack is empty, a new value is created.)
+        ///
+        /// If the pool has no owner, then this will set the owner.
+        #[cold]
+        fn get_slow(
+            &self,
+            caller: usize,
+            owner: usize,
+        ) -> PoolGuard<'_, T, F> {
+            if owner == THREAD_ID_UNOWNED {
+                // This sentinel means this pool is not yet owned. We try to
+                // atomically set the owner. If we do, then this thread becomes
+                // the owner and we can return a guard that represents the
+                // special T for the owner.
+                //
+                // Note that we set the owner to a different sentinel that
+                // indicates that the owned value is in use. The owner ID will
+                // get updated to the actual ID of this thread once the guard
+                // returned by this function is put back into the pool.
+                let res = self.owner.compare_exchange(
+                    THREAD_ID_UNOWNED,
+                    THREAD_ID_INUSE,
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                );
+                if res.is_ok() {
+                    // SAFETY: A successful CAS above implies this thread is
+                    // the owner and that this is the only such thread that
+                    // can reach here. Thus, there is no data race.
+                    unsafe {
+                        *self.owner_val.get() = Some((self.create)());
+                    }
+                    return self.guard_owned(caller);
+                }
+            }
+            let mut stack = self.stack.lock().unwrap();
+            let value = match stack.pop() {
+                None => Box::new((self.create)()),
+                Some(value) => value,
+            };
+            self.guard_stack(value)
+        }
+
+        /// Puts a value back into the pool. Callers don't need to call this.
+        /// Once the guard that's returned by 'get' is dropped, it is put back
+        /// into the pool automatically.
+        fn put_value(&self, value: Box<T>) {
+            let mut stack = self.stack.lock().unwrap();
+            stack.push(value);
+        }
+
+        /// Create a guard that represents the special owned T.
+        fn guard_owned(&self, caller: usize) -> PoolGuard<'_, T, F> {
+            PoolGuard { pool: self, value: Err(caller) }
+        }
+
+        /// Create a guard that contains a value from the pool's stack.
+        fn guard_stack(&self, value: Box<T>) -> PoolGuard<'_, T, F> {
+            PoolGuard { pool: self, value: Ok(value) }
+        }
+    }
+
+    impl<T: core::fmt::Debug, F> core::fmt::Debug for Pool<T, F> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.debug_struct("Pool")
+                .field("stack", &self.stack)
+                .field("owner", &self.owner)
+                .field("owner_val", &self.owner_val)
+                .finish()
+        }
+    }
+
+    /// A guard that is returned when a caller requests a value from the pool.
+    pub(super) struct PoolGuard<'a, T: Send, F: Fn() -> T> {
+        /// The pool that this guard is attached to.
+        pool: &'a Pool<T, F>,
+        /// This is Err when the guard represents the special "owned" value.
+        /// In which case, the value is retrieved from 'pool.owner_val'. And
+        /// in the special case of `Err(THREAD_ID_DROPPED)`, it means the
+        /// guard has been put back into the pool and should no longer be used.
+        value: Result<Box<T>, usize>,
+    }
+
+    impl<'a, T: Send, F: Fn() -> T> PoolGuard<'a, T, F> {
+        /// Return the underlying value.
+        pub(super) fn value(&self) -> &T {
+            match self.value {
+                Ok(ref v) => &**v,
+                // SAFETY: This is safe because the only way a PoolGuard gets
+                // created for self.value=Err is when the current thread
+                // corresponds to the owning thread, of which there can only
+                // be one. Thus, we are guaranteed to be providing exclusive
+                // access here which makes this safe.
+                //
+                // Also, since 'owner_val' is guaranteed to be initialized
+                // before an owned PoolGuard is created, the unchecked unwrap
+                // is safe.
+                Err(id) => unsafe {
+                    // This assert is *not* necessary for safety, since we
+                    // should never be here if the guard had been put back into
+                    // the pool. This is a sanity check to make sure we didn't
+                    // break an internal invariant.
+                    debug_assert_ne!(THREAD_ID_DROPPED, id);
+                    (*self.pool.owner_val.get()).as_ref().unwrap_unchecked()
+                },
+            }
+        }
+
+        /// Return the underlying value as a mutable borrow.
+        pub(super) fn value_mut(&mut self) -> &mut T {
+            match self.value {
+                Ok(ref mut v) => &mut **v,
+                // SAFETY: This is safe because the only way a PoolGuard gets
+                // created for self.value=None is when the current thread
+                // corresponds to the owning thread, of which there can only
+                // be one. Thus, we are guaranteed to be providing exclusive
+                // access here which makes this safe.
+                //
+                // Also, since 'owner_val' is guaranteed to be initialized
+                // before an owned PoolGuard is created, the unwrap_unchecked
+                // is safe.
+                Err(id) => unsafe {
+                    // This assert is *not* necessary for safety, since we
+                    // should never be here if the guard had been put back into
+                    // the pool. This is a sanity check to make sure we didn't
+                    // break an internal invariant.
+                    debug_assert_ne!(THREAD_ID_DROPPED, id);
+                    (*self.pool.owner_val.get()).as_mut().unwrap_unchecked()
+                },
+            }
+        }
+
+        /// Consumes this guard and puts it back into the pool.
+        pub(super) fn put(this: PoolGuard<'_, T, F>) {
+            // Since this is effectively consuming the guard and putting the
+            // value back into the pool, there's no reason to run its Drop
+            // impl after doing this. I don't believe there is a correctness
+            // problem with doing so, but there's definitely a perf problem
+            // by redoing this work. So we avoid it.
+            let mut this = core::mem::ManuallyDrop::new(this);
+            this.put_imp();
+        }
+
+        /// Puts this guard back into the pool by only borrowing the guard as
+        /// mutable. This should be called at most once.
+        #[inline(always)]
+        fn put_imp(&mut self) {
+            match core::mem::replace(&mut self.value, Err(THREAD_ID_DROPPED)) {
+                Ok(value) => self.pool.put_value(value),
+                // If this guard has a value "owned" by the thread, then
+                // the Pool guarantees that this is the ONLY such guard.
+                // Therefore, in order to place it back into the pool and make
+                // it available, we need to change the owner back to the owning
+                // thread's ID. But note that we use the ID that was stored in
+                // the guard, since a guard can be moved to another thread and
+                // dropped. (A previous iteration of this code read from the
+                // THREAD_ID thread local, which uses the ID of the current
+                // thread which may not be the ID of the owning thread! This
+                // also avoids the TLS access, which is likely a hair faster.)
+                Err(owner) => {
+                    // If we hit this point, it implies 'put_imp' has been
+                    // called multiple times for the same guard which in turn
+                    // corresponds to a bug in this implementation.
+                    assert_ne!(THREAD_ID_DROPPED, owner);
+                    self.pool.owner.store(owner, Ordering::Release);
+                }
+            }
+        }
+    }
+
+    impl<'a, T: Send, F: Fn() -> T> Drop for PoolGuard<'a, T, F> {
+        fn drop(&mut self) {
+            self.put_imp();
+        }
+    }
+
+    impl<'a, T: Send + core::fmt::Debug, F: Fn() -> T> core::fmt::Debug
+        for PoolGuard<'a, T, F>
+    {
+        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+            f.debug_struct("PoolGuard")
+                .field("pool", &self.pool)
+                .field("value", &self.value)
+                .finish()
+        }
+    }
+}
+
+// FUTURE: We should consider using Mara Bos's nearly-lock-free version of this
+// here: https://gist.github.com/m-ou-se/5fdcbdf7dcf4585199ce2de697f367a4.
+//
+// One reason why I did things with a "mutex" below is that it isolates the
+// safety concerns to just the Mutex, where as the safety of Mara's pool is a
+// bit more sprawling. I also expect this code to not be used that much, and
+// so is unlikely to get as much real world usage with which to test it. That
+// means the "obviously correct" lever is an important one.
+//
+// The specific reason to use Mara's pool is that it is likely faster and also
+// less likely to hit problems with spin-locks, although it is not completely
+// impervious to them.
+//
+// The best solution to this problem, probably, is a truly lock free pool. That
+// could be done with a lock free linked list. The issue is the ABA problem. It
+// is difficult to avoid, and doing so is complex. BUT, the upshot of that is
+// that if we had a truly lock free pool, then we could also use it above in
+// the 'std' pool instead of a Mutex because it should be completely free the
+// problems that come from spin-locks.
+#[cfg(not(feature = "std"))]
+mod inner {
+    use core::{
+        cell::UnsafeCell,
+        panic::{RefUnwindSafe, UnwindSafe},
+        sync::atomic::{AtomicBool, Ordering},
+    };
+
+    use alloc::{boxed::Box, vec, vec::Vec};
+
+    /// A thread safe pool utilizing alloc-only features.
+    ///
+    /// Unlike the std version, it doesn't seem possible(?) to implement the
+    /// "thread owner" optimization because alloc-only doesn't have any concept
+    /// of threads. So the best we can do is just a normal stack. This will
+    /// increase latency in alloc-only environments.
+    pub(super) struct Pool<T, F> {
+        /// A stack of T values to hand out. These are used when a Pool is
+        /// accessed by a thread that didn't create it.
+        stack: Mutex<Vec<Box<T>>>,
+        /// A function to create more T values when stack is empty and a caller
+        /// has requested a T.
+        create: F,
+    }
+
+    // If T is UnwindSafe, then since we provide exclusive access to any
+    // particular value in the pool, it should therefore also be considered
+    // RefUnwindSafe.
+    impl<T: UnwindSafe, F: UnwindSafe> RefUnwindSafe for Pool<T, F> {}
+
+    impl<T, F> Pool<T, F> {
+        /// Create a new pool. The given closure is used to create values in
+        /// the pool when necessary.
+        pub(super) const fn new(create: F) -> Pool<T, F> {
+            Pool { stack: Mutex::new(vec![]), create }
+        }
+    }
+
+    impl<T: Send, F: Fn() -> T> Pool<T, F> {
+        /// Get a value from the pool. This may block if another thread is also
+        /// attempting to retrieve a value from the pool.
+        pub(super) fn get(&self) -> PoolGuard<'_, T, F> {
+            let mut stack = self.stack.lock();
+            let value = match stack.pop() {
+                None => Box::new((self.create)()),
+                Some(value) => value,
+            };
+            PoolGuard { pool: self, value: Some(value) }
+        }
+
+        fn put(&self, guard: PoolGuard<'_, T, F>) {
+            let mut guard = core::mem::ManuallyDrop::new(guard);
+            if let Some(value) = guard.value.take() {
+                self.put_value(value);
+            }
+        }
+
+        /// Puts a value back into the pool. Callers don't need to call this.
+        /// Once the guard that's returned by 'get' is dropped, it is put back
+        /// into the pool automatically.
+        fn put_value(&self, value: Box<T>) {
+            let mut stack = self.stack.lock();
+            stack.push(value);
+        }
+    }
+
+    impl<T: core::fmt::Debug, F> core::fmt::Debug for Pool<T, F> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.debug_struct("Pool").field("stack", &self.stack).finish()
+        }
+    }
+
+    /// A guard that is returned when a caller requests a value from the pool.
+    pub(super) struct PoolGuard<'a, T: Send, F: Fn() -> T> {
+        /// The pool that this guard is attached to.
+        pool: &'a Pool<T, F>,
+        /// This is None after the guard has been put back into the pool.
+        value: Option<Box<T>>,
+    }
+
+    impl<'a, T: Send, F: Fn() -> T> PoolGuard<'a, T, F> {
+        /// Return the underlying value.
+        pub(super) fn value(&self) -> &T {
+            self.value.as_deref().unwrap()
+        }
+
+        /// Return the underlying value as a mutable borrow.
+        pub(super) fn value_mut(&mut self) -> &mut T {
+            self.value.as_deref_mut().unwrap()
+        }
+
+        /// Consumes this guard and puts it back into the pool.
+        pub(super) fn put(this: PoolGuard<'_, T, F>) {
+            // Since this is effectively consuming the guard and putting the
+            // value back into the pool, there's no reason to run its Drop
+            // impl after doing this. I don't believe there is a correctness
+            // problem with doing so, but there's definitely a perf problem
+            // by redoing this work. So we avoid it.
+            let mut this = core::mem::ManuallyDrop::new(this);
+            this.put_imp();
+        }
+
+        /// Puts this guard back into the pool by only borrowing the guard as
+        /// mutable. This should be called at most once.
+        #[inline(always)]
+        fn put_imp(&mut self) {
+            if let Some(value) = self.value.take() {
+                self.pool.put_value(value);
+            }
+        }
+    }
+
+    impl<'a, T: Send, F: Fn() -> T> Drop for PoolGuard<'a, T, F> {
+        fn drop(&mut self) {
+            self.put_imp();
+        }
+    }
+
+    impl<'a, T: Send + core::fmt::Debug, F: Fn() -> T> core::fmt::Debug
+        for PoolGuard<'a, T, F>
+    {
+        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+            f.debug_struct("PoolGuard")
+                .field("pool", &self.pool)
+                .field("value", &self.value)
+                .finish()
+        }
+    }
+
+    /// A spin-lock based mutex. Yes, I have read spinlocks cosnidered
+    /// harmful[1], and if there's a reasonable alternative choice, I'll
+    /// happily take it.
+    ///
+    /// I suspect the most likely alternative here is a Treiber stack, but
+    /// implementing one correctly in a way that avoids the ABA problem looks
+    /// subtle enough that I'm not sure I want to attempt that. But otherwise,
+    /// we only need a mutex in order to implement our pool, so if there's
+    /// something simpler we can use that works for our `Pool` use case, then
+    /// that would be great.
+    ///
+    /// Note that this mutex does not do poisoning.
+    ///
+    /// [1]: https://matklad.github.io/2020/01/02/spinlocks-considered-harmful.html
+    #[derive(Debug)]
+    struct Mutex<T> {
+        locked: AtomicBool,
+        data: UnsafeCell<T>,
+    }
+
+    // SAFETY: Since a Mutex guarantees exclusive access, as long as we can
+    // send it across threads, it must also be Sync.
+    unsafe impl<T: Send> Sync for Mutex<T> {}
+
+    impl<T> Mutex<T> {
+        /// Create a new mutex for protecting access to the given value across
+        /// multiple threads simultaneously.
+        const fn new(value: T) -> Mutex<T> {
+            Mutex {
+                locked: AtomicBool::new(false),
+                data: UnsafeCell::new(value),
+            }
+        }
+
+        /// Lock this mutex and return a guard providing exclusive access to
+        /// `T`. This blocks if some other thread has already locked this
+        /// mutex.
+        fn lock(&self) -> MutexGuard<'_, T> {
+            while self
+                .locked
+                .compare_exchange(
+                    false,
+                    true,
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                )
+                .is_err()
+            {
+                core::hint::spin_loop();
+            }
+            // SAFETY: The only way we're here is if we successfully set
+            // 'locked' to true, which implies we must be the only thread here
+            // and thus have exclusive access to 'data'.
+            let data = unsafe { &mut *self.data.get() };
+            MutexGuard { locked: &self.locked, data }
+        }
+    }
+
+    /// A guard that derefs to &T and &mut T. When it's dropped, the lock is
+    /// released.
+    #[derive(Debug)]
+    struct MutexGuard<'a, T> {
+        locked: &'a AtomicBool,
+        data: &'a mut T,
+    }
+
+    impl<'a, T> core::ops::Deref for MutexGuard<'a, T> {
+        type Target = T;
+
+        fn deref(&self) -> &T {
+            self.data
+        }
+    }
+
+    impl<'a, T> core::ops::DerefMut for MutexGuard<'a, T> {
+        fn deref_mut(&mut self) -> &mut T {
+            self.data
+        }
+    }
+
+    impl<'a, T> Drop for MutexGuard<'a, T> {
+        fn drop(&mut self) {
+            // Drop means 'data' is no longer accessible, so we can unlock
+            // the mutex.
+            self.locked.store(false, Ordering::Release);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::panic::{RefUnwindSafe, UnwindSafe};
+
+    use alloc::{boxed::Box, vec, vec::Vec};
+
+    use super::*;
+
+    #[test]
+    fn oibits() {
+        fn assert_oitbits<T: Send + Sync + UnwindSafe + RefUnwindSafe>() {}
+        assert_oitbits::<Pool<Vec<u32>>>();
+        assert_oitbits::<Pool<core::cell::RefCell<Vec<u32>>>>();
+        assert_oitbits::<
+            Pool<
+                Vec<u32>,
+                Box<
+                    dyn Fn() -> Vec<u32>
+                        + Send
+                        + Sync
+                        + UnwindSafe
+                        + RefUnwindSafe,
+                >,
+            >,
+        >();
+    }
+
+    // Tests that Pool implements the "single owner" optimization. That is, the
+    // thread that first accesses the pool gets its own copy, while all other
+    // threads get distinct copies.
+    #[cfg(feature = "std")]
+    #[test]
+    fn thread_owner_optimization() {
+        use std::{cell::RefCell, sync::Arc, vec};
+
+        let pool: Arc<Pool<RefCell<Vec<char>>>> =
+            Arc::new(Pool::new(|| RefCell::new(vec!['a'])));
+        pool.get().borrow_mut().push('x');
+
+        let pool1 = pool.clone();
+        let t1 = std::thread::spawn(move || {
+            let guard = pool1.get();
+            guard.borrow_mut().push('y');
+        });
+
+        let pool2 = pool.clone();
+        let t2 = std::thread::spawn(move || {
+            let guard = pool2.get();
+            guard.borrow_mut().push('z');
+        });
+
+        t1.join().unwrap();
+        t2.join().unwrap();
+
+        // If we didn't implement the single owner optimization, then one of
+        // the threads above is likely to have mutated the [a, x] vec that
+        // we stuffed in the pool before spawning the threads. But since
+        // neither thread was first to access the pool, and because of the
+        // optimization, we should be guaranteed that neither thread mutates
+        // the special owned pool value.
+        //
+        // (Technically this is an implementation detail and not a contract of
+        // Pool's API.)
+        assert_eq!(vec!['a', 'x'], *pool.get().borrow());
+    }
+
+    // This tests that if the "owner" of a pool asks for two values, then it
+    // gets two distinct values and not the same one. This test failed in the
+    // course of developing the pool, which in turn resulted in UB because it
+    // permitted getting aliasing &mut borrows to the same place in memory.
+    #[test]
+    fn thread_owner_distinct() {
+        let pool = Pool::new(|| vec!['a']);
+
+        {
+            let mut g1 = pool.get();
+            let v1 = &mut *g1;
+            let mut g2 = pool.get();
+            let v2 = &mut *g2;
+            v1.push('b');
+            v2.push('c');
+            assert_eq!(&mut vec!['a', 'b'], v1);
+            assert_eq!(&mut vec!['a', 'c'], v2);
+        }
+        // This isn't technically guaranteed, but we
+        // expect to now get the "owned" value (the first
+        // call to 'get()' above) now that it's back in
+        // the pool.
+        assert_eq!(&mut vec!['a', 'b'], &mut *pool.get());
+    }
+
+    // This tests that we can share a guard with another thread, mutate the
+    // underlying value and everything works. This failed in the course of
+    // developing a pool since the pool permitted 'get()' to return the same
+    // value to the owner thread, even before the previous value was put back
+    // into the pool. This in turn resulted in this test producing a data race.
+    #[cfg(feature = "std")]
+    #[test]
+    fn thread_owner_sync() {
+        let pool = Pool::new(|| vec!['a']);
+        {
+            let mut g1 = pool.get();
+            let mut g2 = pool.get();
+            std::thread::scope(|s| {
+                s.spawn(|| {
+                    g1.push('b');
+                });
+                s.spawn(|| {
+                    g2.push('c');
+                });
+            });
+
+            let v1 = &mut *g1;
+            let v2 = &mut *g2;
+            assert_eq!(&mut vec!['a', 'b'], v1);
+            assert_eq!(&mut vec!['a', 'c'], v2);
+        }
+
+        // This isn't technically guaranteed, but we
+        // expect to now get the "owned" value (the first
+        // call to 'get()' above) now that it's back in
+        // the pool.
+        assert_eq!(&mut vec!['a', 'b'], &mut *pool.get());
+    }
+
+    // This tests that if we move a PoolGuard that is owned by the current
+    // thread to another thread and drop it, then the thread owner doesn't
+    // change. During development of the pool, this test failed because the
+    // PoolGuard assumed it was dropped in the same thread from which it was
+    // created, and thus used the current thread's ID as the owner, which could
+    // be different than the actual owner of the pool.
+    #[cfg(feature = "std")]
+    #[test]
+    fn thread_owner_send_drop() {
+        let pool = Pool::new(|| vec!['a']);
+        // Establishes this thread as the owner.
+        {
+            pool.get().push('b');
+        }
+        std::thread::scope(|s| {
+            // Sanity check that we get the same value back.
+            // (Not technically guaranteed.)
+            let mut g = pool.get();
+            assert_eq!(&vec!['a', 'b'], &*g);
+            // Now push it to another thread and drop it.
+            s.spawn(move || {
+                g.push('c');
+            })
+            .join()
+            .unwrap();
+        });
+        // Now check that we're still the owner. This is not technically
+        // guaranteed by the API, but is true in practice given the thread
+        // owner optimization.
+        assert_eq!(&vec!['a', 'b', 'c'], &*pool.get());
+    }
+}
diff --git a/regex-automata/src/util/prefilter/aho_corasick.rs b/regex-automata/src/util/prefilter/aho_corasick.rs
new file mode 100644
index 0000000000..a7474d29ab
--- /dev/null
+++ b/regex-automata/src/util/prefilter/aho_corasick.rs
@@ -0,0 +1,140 @@
+use crate::util::{
+    prefilter::PrefilterI,
+    search::{MatchKind, Span},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct AhoCorasick {
+    #[cfg(not(feature = "perf-literal-multisubstring"))]
+    _unused: (),
+    #[cfg(feature = "perf-literal-multisubstring")]
+    ac: aho_corasick::AhoCorasick,
+}
+
+impl AhoCorasick {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        kind: MatchKind,
+        needles: &[B],
+    ) -> Option<AhoCorasick> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            let ac_match_kind = match kind {
+                MatchKind::LeftmostFirst => {
+                    aho_corasick::MatchKind::LeftmostFirst
+                }
+                MatchKind::All => aho_corasick::MatchKind::Standard,
+            };
+            // This is kind of just an arbitrary number, but basically, if we
+            // have a small enough set of literals, then we try to use the VERY
+            // memory hungry DFA. Otherwise, we whimp out and use an NFA. The
+            // upshot is that the NFA is quite lean and decently fast. Faster
+            // than a naive Aho-Corasick NFA anyway.
+            let ac_kind = if needles.len() <= 500 {
+                aho_corasick::AhoCorasickKind::DFA
+            } else {
+                aho_corasick::AhoCorasickKind::ContiguousNFA
+            };
+            let result = aho_corasick::AhoCorasick::builder()
+                .kind(Some(ac_kind))
+                .match_kind(ac_match_kind)
+                .start_kind(aho_corasick::StartKind::Both)
+                // We try to handle all of the prefilter cases in the super
+                // module, and only use Aho-Corasick for the actual automaton.
+                // The aho-corasick crate does have some extra prefilters,
+                // namely, looking for rare bytes to feed to memchr{,2,3}
+                // instead of just the first byte. If we end up wanting
+                // those---and they are somewhat tricky to implement---then
+                // we could port them to this crate.
+                //
+                // The main reason for doing things this way is so we have a
+                // complete and easy to understand picture of which prefilters
+                // are available and how they work. Otherwise it seems too
+                // easy to get into a situation where we have a prefilter
+                // layered on top of prefilter, and that might have unintended
+                // consequences.
+                .prefilter(false)
+                .build(needles);
+            let ac = match result {
+                Ok(ac) => ac,
+                Err(_err) => {
+                    debug!("aho-corasick prefilter failed to build: {}", _err);
+                    return None;
+                }
+            };
+            Some(AhoCorasick { ac })
+        }
+    }
+}
+
+impl PrefilterI for AhoCorasick {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            let input =
+                aho_corasick::Input::new(haystack).span(span.start..span.end);
+            self.ac
+                .find(input)
+                .map(|m| Span { start: m.start(), end: m.end() })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            let input = aho_corasick::Input::new(haystack)
+                .anchored(aho_corasick::Anchored::Yes)
+                .span(span.start..span.end);
+            self.ac
+                .find(input)
+                .map(|m| Span { start: m.start(), end: m.end() })
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            self.ac.memory_usage()
+        }
+    }
+
+    fn is_fast(&self) -> bool {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            // Aho-Corasick is never considered "fast" because it's never
+            // going to be even close to an order of magnitude faster than the
+            // regex engine itself (assuming a DFA is used). In fact, it is
+            // usually slower. The magic of Aho-Corasick is that it can search
+            // a *large* number of literals with a relatively small amount of
+            // memory. The regex engines are far more wasteful.
+            //
+            // Aho-Corasick may be "fast" when the regex engine corresponds
+            // to, say, the PikeVM. That happens when the lazy DFA couldn't be
+            // built or used for some reason. But in these cases, the regex
+            // itself is likely quite big and we're probably hosed no matter
+            // what we do. (In this case, the best bet is for the caller to
+            // increase some of the memory limits on the hybrid cache capacity
+            // and hope that's enough.)
+            false
+        }
+    }
+}
diff --git a/regex-automata/src/util/prefilter/byteset.rs b/regex-automata/src/util/prefilter/byteset.rs
new file mode 100644
index 0000000000..a669d6c9d7
--- /dev/null
+++ b/regex-automata/src/util/prefilter/byteset.rs
@@ -0,0 +1,58 @@
+use crate::util::{
+    prefilter::PrefilterI,
+    search::{MatchKind, Span},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct ByteSet([bool; 256]);
+
+impl ByteSet {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        _kind: MatchKind,
+        needles: &[B],
+    ) -> Option<ByteSet> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            let mut set = [false; 256];
+            for needle in needles.iter() {
+                let needle = needle.as_ref();
+                if needle.len() != 1 {
+                    return None;
+                }
+                set[usize::from(needle[0])] = true;
+            }
+            Some(ByteSet(set))
+        }
+    }
+}
+
+impl PrefilterI for ByteSet {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        haystack[span].iter().position(|&b| self.0[usize::from(b)]).map(|i| {
+            let start = span.start + i;
+            let end = start + 1;
+            Span { start, end }
+        })
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        let b = *haystack.get(span.start)?;
+        if self.0[usize::from(b)] {
+            Some(Span { start: span.start, end: span.start + 1 })
+        } else {
+            None
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        0
+    }
+
+    fn is_fast(&self) -> bool {
+        false
+    }
+}
diff --git a/regex-automata/src/util/prefilter/memchr.rs b/regex-automata/src/util/prefilter/memchr.rs
new file mode 100644
index 0000000000..3d44b83721
--- /dev/null
+++ b/regex-automata/src/util/prefilter/memchr.rs
@@ -0,0 +1,186 @@
+use crate::util::{
+    prefilter::PrefilterI,
+    search::{MatchKind, Span},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Memchr(u8);
+
+impl Memchr {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        _kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Memchr> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            if needles.len() != 1 {
+                return None;
+            }
+            if needles[0].as_ref().len() != 1 {
+                return None;
+            }
+            Some(Memchr(needles[0].as_ref()[0]))
+        }
+    }
+}
+
+impl PrefilterI for Memchr {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            memchr::memchr(self.0, &haystack[span]).map(|i| {
+                let start = span.start + i;
+                let end = start + 1;
+                Span { start, end }
+            })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        let b = *haystack.get(span.start)?;
+        if self.0 == b {
+            Some(Span { start: span.start, end: span.start + 1 })
+        } else {
+            None
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        0
+    }
+
+    fn is_fast(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Memchr2(u8, u8);
+
+impl Memchr2 {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        _kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Memchr2> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            if needles.len() != 2 {
+                return None;
+            }
+            if !needles.iter().all(|n| n.as_ref().len() == 1) {
+                return None;
+            }
+            let b1 = needles[0].as_ref()[0];
+            let b2 = needles[1].as_ref()[0];
+            Some(Memchr2(b1, b2))
+        }
+    }
+}
+
+impl PrefilterI for Memchr2 {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            memchr::memchr2(self.0, self.1, &haystack[span]).map(|i| {
+                let start = span.start + i;
+                let end = start + 1;
+                Span { start, end }
+            })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        let b = *haystack.get(span.start)?;
+        if self.0 == b || self.1 == b {
+            Some(Span { start: span.start, end: span.start + 1 })
+        } else {
+            None
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        0
+    }
+
+    fn is_fast(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Memchr3(u8, u8, u8);
+
+impl Memchr3 {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        _kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Memchr3> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            if needles.len() != 3 {
+                return None;
+            }
+            if !needles.iter().all(|n| n.as_ref().len() == 1) {
+                return None;
+            }
+            let b1 = needles[0].as_ref()[0];
+            let b2 = needles[1].as_ref()[0];
+            let b3 = needles[2].as_ref()[0];
+            Some(Memchr3(b1, b2, b3))
+        }
+    }
+}
+
+impl PrefilterI for Memchr3 {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-substring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-substring")]
+        {
+            memchr::memchr3(self.0, self.1, self.2, &haystack[span]).map(|i| {
+                let start = span.start + i;
+                let end = start + 1;
+                Span { start, end }
+            })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        let b = *haystack.get(span.start)?;
+        if self.0 == b || self.1 == b || self.2 == b {
+            Some(Span { start: span.start, end: span.start + 1 })
+        } else {
+            None
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        0
+    }
+
+    fn is_fast(&self) -> bool {
+        true
+    }
+}
diff --git a/regex-automata/src/util/prefilter/memmem.rs b/regex-automata/src/util/prefilter/memmem.rs
new file mode 100644
index 0000000000..deea17bd9d
--- /dev/null
+++ b/regex-automata/src/util/prefilter/memmem.rs
@@ -0,0 +1,88 @@
+use crate::util::{
+    prefilter::PrefilterI,
+    search::{MatchKind, Span},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Memmem {
+    #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+    _unused: (),
+    #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+    finder: memchr::memmem::Finder<'static>,
+}
+
+impl Memmem {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        _kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Memmem> {
+        #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+        {
+            None
+        }
+        #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+        {
+            if needles.len() != 1 {
+                return None;
+            }
+            let needle = needles[0].as_ref();
+            let finder = memchr::memmem::Finder::new(needle).into_owned();
+            Some(Memmem { finder })
+        }
+    }
+}
+
+impl PrefilterI for Memmem {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+        {
+            unreachable!()
+        }
+        #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+        {
+            self.finder.find(&haystack[span]).map(|i| {
+                let start = span.start + i;
+                let end = start + self.finder.needle().len();
+                Span { start, end }
+            })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+        {
+            unreachable!()
+        }
+        #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+        {
+            let needle = self.finder.needle();
+            if haystack[span].starts_with(needle) {
+                Some(Span { end: span.start + needle.len(), ..span })
+            } else {
+                None
+            }
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+        {
+            unreachable!()
+        }
+        #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+        {
+            self.finder.needle().len()
+        }
+    }
+
+    fn is_fast(&self) -> bool {
+        #[cfg(not(all(feature = "std", feature = "perf-literal-substring")))]
+        {
+            unreachable!()
+        }
+        #[cfg(all(feature = "std", feature = "perf-literal-substring"))]
+        {
+            true
+        }
+    }
+}
diff --git a/regex-automata/src/util/prefilter/mod.rs b/regex-automata/src/util/prefilter/mod.rs
new file mode 100644
index 0000000000..ea3eb73d8c
--- /dev/null
+++ b/regex-automata/src/util/prefilter/mod.rs
@@ -0,0 +1,705 @@
+/*!
+Defines a prefilter for accelerating regex searches.
+
+A prefilter can be created by building a [`Prefilter`] value.
+
+A prefilter represents one of the most important optimizations available for
+accelerating regex searches. The idea of a prefilter is to very quickly find
+candidate locations in a haystack where a regex _could_ match. Once a candidate
+is found, it is then intended for the regex engine to run at that position to
+determine whether the candidate is a match or a false positive.
+
+In the aforementioned description of the prefilter optimization also lay its
+demise. Namely, if a prefilter has a high false positive rate and it produces
+lots of candidates, then a prefilter can overall make a regex search slower.
+It can run more slowly because more time is spent ping-ponging between the
+prefilter search and the regex engine attempting to confirm each candidate as
+a match. This ping-ponging has overhead that adds up, and is exacerbated by
+a high false positive rate.
+
+Nevertheless, the optimization is still generally worth performing in most
+cases. Particularly given just how much throughput can be improved. (It is not
+uncommon for prefilter optimizations to improve throughput by one or two orders
+of magnitude.)
+
+Typically a prefilter is used to find occurrences of literal prefixes from a
+regex pattern, but this isn't required. A prefilter can be used to look for
+suffixes or even inner literals.
+
+Note that as of now, prefilters throw away information about which pattern
+each literal comes from. In other words, when a prefilter finds a match,
+there's no way to know which pattern (or patterns) it came from. Therefore,
+in order to confirm a match, you'll have to check all of the patterns by
+running the full regex engine.
+*/
+
+mod aho_corasick;
+mod byteset;
+mod memchr;
+mod memmem;
+mod teddy;
+
+use core::{
+    borrow::Borrow,
+    fmt::Debug,
+    panic::{RefUnwindSafe, UnwindSafe},
+};
+
+#[cfg(feature = "alloc")]
+use alloc::sync::Arc;
+
+#[cfg(feature = "syntax")]
+use regex_syntax::hir::{literal, Hir};
+
+use crate::util::search::{MatchKind, Span};
+
+pub(crate) use crate::util::prefilter::{
+    aho_corasick::AhoCorasick,
+    byteset::ByteSet,
+    memchr::{Memchr, Memchr2, Memchr3},
+    memmem::Memmem,
+    teddy::Teddy,
+};
+
+/// A prefilter for accelerating regex searches.
+///
+/// If you already have your literals that you want to search with,
+/// then the vanilla [`Prefilter::new`] constructor is for you. But
+/// if you have an [`Hir`] value from the `regex-syntax` crate, then
+/// [`Prefilter::from_hir_prefix`] might be more convenient. Namely, it uses
+/// the [`regex-syntax::hir::literal`](regex_syntax::hir::literal) module to
+/// extract literal prefixes for you, optimize them and then select and build a
+/// prefilter matcher.
+///
+/// A prefilter must have **zero false negatives**. However, by its very
+/// nature, it may produce false positives. That is, a prefilter will never
+/// skip over a position in the haystack that corresponds to a match of the
+/// original regex pattern, but it *may* produce a match for a position
+/// in the haystack that does *not* correspond to a match of the original
+/// regex pattern. If you use either the [`Prefilter::from_hir_prefix`] or
+/// [`Prefilter::from_hirs_prefix`] constructors, then this guarantee is
+/// upheld for you automatically. This guarantee is not preserved if you use
+/// [`Prefilter::new`] though, since it is up to the caller to provide correct
+/// literal strings with respect to the original regex pattern.
+///
+/// # Cloning
+///
+/// It is an API guarantee that cloning a prefilter is cheap. That is, cloning
+/// it will not duplicate whatever heap memory is used to represent the
+/// underlying matcher.
+///
+/// # Example
+///
+/// This example shows how to attach a `Prefilter` to the
+/// [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM) in order to accelerate
+/// searches.
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     util::prefilter::Prefilter,
+///     Match, MatchKind,
+/// };
+///
+/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Bruce "])
+///     .expect("a prefilter");
+/// let re = PikeVM::builder()
+///     .configure(PikeVM::config().prefilter(Some(pre)))
+///     .build(r"Bruce \w+")?;
+/// let mut cache = re.create_cache();
+/// assert_eq!(
+///     Some(Match::must(0, 6..23)),
+///     re.find(&mut cache, "Hello Bruce Springsteen!"),
+/// );
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// But note that if you get your prefilter incorrect, it could lead to an
+/// incorrect result!
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     util::prefilter::Prefilter,
+///     Match, MatchKind,
+/// };
+///
+/// // This prefilter is wrong!
+/// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["Patti "])
+///     .expect("a prefilter");
+/// let re = PikeVM::builder()
+///     .configure(PikeVM::config().prefilter(Some(pre)))
+///     .build(r"Bruce \w+")?;
+/// let mut cache = re.create_cache();
+/// // We find no match even though the regex does match.
+/// assert_eq!(
+///     None,
+///     re.find(&mut cache, "Hello Bruce Springsteen!"),
+/// );
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct Prefilter {
+    #[cfg(not(feature = "alloc"))]
+    _unused: (),
+    #[cfg(feature = "alloc")]
+    pre: Arc<dyn PrefilterI>,
+    #[cfg(feature = "alloc")]
+    is_fast: bool,
+}
+
+impl Prefilter {
+    /// Create a new prefilter from a sequence of needles and a corresponding
+    /// match semantics.
+    ///
+    /// This may return `None` for a variety of reasons, for example, if
+    /// a suitable prefilter could not be constructed. That might occur
+    /// if they are unavailable (e.g., the `perf-literal-substring` and
+    /// `perf-literal-multisubstring` features aren't enabled), or it might
+    /// occur because of heuristics or other artifacts of how the prefilter
+    /// works.
+    ///
+    /// Note that if you have an [`Hir`] expression, it may be more convenient
+    /// to use [`Prefilter::from_hir_prefix`]. It will automatically handle the
+    /// task of extracting prefix literals for you.
+    ///
+    /// # Example
+    ///
+    /// This example shows how match semantics can impact the matching
+    /// algorithm used by the prefilter. For this reason, it is important to
+    /// ensure that the match semantics given here are consistent with the
+    /// match semantics intended for the regular expression that the literals
+    /// were extracted from.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     util::{prefilter::Prefilter, syntax},
+    ///     MatchKind, Span,
+    /// };
+    ///
+    /// let hay = "Hello samwise";
+    ///
+    /// // With leftmost-first, we find 'samwise' here because it comes
+    /// // before 'sam' in the sequence we give it..
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["samwise", "sam"])
+    ///     .expect("a prefilter");
+    /// assert_eq!(
+    ///     Some(Span::from(6..13)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    /// // Still with leftmost-first but with the literals reverse, now 'sam'
+    /// // will match instead!
+    /// let pre = Prefilter::new(MatchKind::LeftmostFirst, &["sam", "samwise"])
+    ///     .expect("a prefilter");
+    /// assert_eq!(
+    ///     Some(Span::from(6..9)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    /// // Now we put 'samwise' back before 'sam', but change the match
+    /// // semantics to 'All'. In this case, there is no preference
+    /// // order semantics and the first match detected is returned.
+    /// let pre = Prefilter::new(MatchKind::All, &["samwise", "sam"])
+    ///     .expect("a prefilter");
+    /// assert_eq!(
+    ///     Some(Span::from(6..9)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn new<B: AsRef<[u8]>>(
+        kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Prefilter> {
+        Choice::new(kind, needles).and_then(Prefilter::from_choice)
+    }
+
+    /// This turns a prefilter selection into a `Prefilter`. That is, in turns
+    /// the enum given into a trait object.
+    fn from_choice(choice: Choice) -> Option<Prefilter> {
+        #[cfg(not(feature = "alloc"))]
+        {
+            None
+        }
+        #[cfg(feature = "alloc")]
+        {
+            let pre: Arc<dyn PrefilterI> = match choice {
+                Choice::Memchr(p) => Arc::new(p),
+                Choice::Memchr2(p) => Arc::new(p),
+                Choice::Memchr3(p) => Arc::new(p),
+                Choice::Memmem(p) => Arc::new(p),
+                Choice::Teddy(p) => Arc::new(p),
+                Choice::ByteSet(p) => Arc::new(p),
+                Choice::AhoCorasick(p) => Arc::new(p),
+            };
+            let is_fast = pre.is_fast();
+            Some(Prefilter { pre, is_fast })
+        }
+    }
+
+    /// This attempts to extract prefixes from the given `Hir` expression for
+    /// the given match semantics, and if possible, builds a prefilter for
+    /// them.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a prefilter directly from an [`Hir`]
+    /// expression, and use to find an occurrence of a prefix from the regex
+    /// pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     util::{prefilter::Prefilter, syntax},
+    ///     MatchKind, Span,
+    /// };
+    ///
+    /// let hir = syntax::parse(r"(Bruce|Patti) \w+")?;
+    /// let pre = Prefilter::from_hir_prefix(MatchKind::LeftmostFirst, &hir)
+    ///     .expect("a prefilter");
+    /// let hay = "Hello Patti Scialfa!";
+    /// assert_eq!(
+    ///     Some(Span::from(6..12)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn from_hir_prefix(kind: MatchKind, hir: &Hir) -> Option<Prefilter> {
+        Prefilter::from_hirs_prefix(kind, &[hir])
+    }
+
+    /// This attempts to extract prefixes from the given `Hir` expressions for
+    /// the given match semantics, and if possible, builds a prefilter for
+    /// them.
+    ///
+    /// Note that as of now, prefilters throw away information about which
+    /// pattern each literal comes from. In other words, when a prefilter finds
+    /// a match, there's no way to know which pattern (or patterns) it came
+    /// from. Therefore, in order to confirm a match, you'll have to check all
+    /// of the patterns by running the full regex engine.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a prefilter directly from multiple
+    /// `Hir` expressions expression, and use it to find an occurrence of a
+    /// prefix from the regex patterns.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     util::{prefilter::Prefilter, syntax},
+    ///     MatchKind, Span,
+    /// };
+    ///
+    /// let hirs = syntax::parse_many(&[
+    ///     r"(Bruce|Patti) \w+",
+    ///     r"Mrs?\. Doubtfire",
+    /// ])?;
+    /// let pre = Prefilter::from_hirs_prefix(MatchKind::LeftmostFirst, &hirs)
+    ///     .expect("a prefilter");
+    /// let hay = "Hello Mrs. Doubtfire";
+    /// assert_eq!(
+    ///     Some(Span::from(6..20)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "syntax")]
+    pub fn from_hirs_prefix<H: Borrow<Hir>>(
+        kind: MatchKind,
+        hirs: &[H],
+    ) -> Option<Prefilter> {
+        prefixes(kind, hirs)
+            .literals()
+            .and_then(|lits| Prefilter::new(kind, lits))
+    }
+
+    /// Run this prefilter on `haystack[span.start..end]` and return a matching
+    /// span if one exists.
+    ///
+    /// The span returned is guaranteed to have a start position greater than
+    /// or equal to the one given, and an end position less than or equal to
+    /// the one given.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a prefilter directly from an [`Hir`]
+    /// expression, and use it to find an occurrence of a prefix from the regex
+    /// pattern.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     util::{prefilter::Prefilter, syntax},
+    ///     MatchKind, Span,
+    /// };
+    ///
+    /// let hir = syntax::parse(r"Bruce \w+")?;
+    /// let pre = Prefilter::from_hir_prefix(MatchKind::LeftmostFirst, &hir)
+    ///     .expect("a prefilter");
+    /// let hay = "Hello Bruce Springsteen!";
+    /// assert_eq!(
+    ///     Some(Span::from(6..12)),
+    ///     pre.find(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "alloc"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "alloc")]
+        {
+            self.pre.find(haystack, span)
+        }
+    }
+
+    /// Returns the span of a prefix of `haystack[span.start..span.end]` if
+    /// the prefilter matches.
+    ///
+    /// The span returned is guaranteed to have a start position equivalent to
+    /// the one given, and an end position less than or equal to the one given.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to build a prefilter directly from an [`Hir`]
+    /// expression, and use it to find an occurrence of a prefix from the regex
+    /// pattern that begins at the start of a haystack only.
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     util::{prefilter::Prefilter, syntax},
+    ///     MatchKind, Span,
+    /// };
+    ///
+    /// let hir = syntax::parse(r"Bruce \w+")?;
+    /// let pre = Prefilter::from_hir_prefix(MatchKind::LeftmostFirst, &hir)
+    ///     .expect("a prefilter");
+    /// let hay = "Hello Bruce Springsteen!";
+    /// // Nothing is found here because 'Bruce' does
+    /// // not occur at the beginning of our search.
+    /// assert_eq!(
+    ///     None,
+    ///     pre.prefix(hay.as_bytes(), Span::from(0..hay.len())),
+    /// );
+    /// // But if we change where we start the search
+    /// // to begin where 'Bruce ' begins, then a
+    /// // match will be found.
+    /// assert_eq!(
+    ///     Some(Span::from(6..12)),
+    ///     pre.prefix(hay.as_bytes(), Span::from(6..hay.len())),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "alloc"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "alloc")]
+        {
+            self.pre.prefix(haystack, span)
+        }
+    }
+
+    /// Returns the heap memory, in bytes, used by the underlying prefilter.
+    #[inline]
+    pub fn memory_usage(&self) -> usize {
+        #[cfg(not(feature = "alloc"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "alloc")]
+        {
+            self.pre.memory_usage()
+        }
+    }
+
+    /// Implementations might return true here if they believe themselves to
+    /// be "fast." The concept of "fast" is deliberately left vague, but in
+    /// practice this usually corresponds to whether it's believed that SIMD
+    /// will be used.
+    ///
+    /// Why do we care about this? Well, some prefilter tricks tend to come
+    /// with their own bits of overhead, and so might only make sense if we
+    /// know that a scan will be *much* faster than the regex engine itself.
+    /// Otherwise, the trick may not be worth doing. Whether something is
+    /// "much" faster than the regex engine generally boils down to whether
+    /// SIMD is used. (But not always. Even a SIMD matcher with a high false
+    /// positive rate can become quite slow.)
+    ///
+    /// Even if this returns true, it is still possible for the prefilter to
+    /// be "slow." Remember, prefilters are just heuristics. We can't really
+    /// *know* a prefilter will be fast without actually trying the prefilter.
+    /// (Which of course we cannot afford to do.)
+    #[inline]
+    pub(crate) fn is_fast(&self) -> bool {
+        #[cfg(not(feature = "alloc"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "alloc")]
+        {
+            self.is_fast
+        }
+    }
+}
+
+/// A trait for abstracting over prefilters. Basically, a prefilter is
+/// something that do an unanchored *and* an anchored search in a haystack
+/// within a given span.
+///
+/// This exists pretty much only so that we can use prefilters as a trait
+/// object (which is what `Prefilter` is). If we ever move off of trait objects
+/// and to an enum, then it's likely this trait could be removed.
+pub(crate) trait PrefilterI:
+    Debug + Send + Sync + RefUnwindSafe + UnwindSafe + 'static
+{
+    /// Run this prefilter on `haystack[span.start..end]` and return a matching
+    /// span if one exists.
+    ///
+    /// The span returned is guaranteed to have a start position greater than
+    /// or equal to the one given, and an end position less than or equal to
+    /// the one given.
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span>;
+
+    /// Returns the span of a prefix of `haystack[span.start..span.end]` if
+    /// the prefilter matches.
+    ///
+    /// The span returned is guaranteed to have a start position equivalent to
+    /// the one given, and an end position less than or equal to the one given.
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span>;
+
+    /// Returns the heap memory, in bytes, used by the underlying prefilter.
+    fn memory_usage(&self) -> usize;
+
+    /// Implementations might return true here if they believe themselves to
+    /// be "fast." See [`Prefilter::is_fast`] for more details.
+    fn is_fast(&self) -> bool;
+}
+
+#[cfg(feature = "alloc")]
+impl<P: PrefilterI + ?Sized> PrefilterI for Arc<P> {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        (&**self).find(haystack, span)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        (&**self).prefix(haystack, span)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn memory_usage(&self) -> usize {
+        (&**self).memory_usage()
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_fast(&self) -> bool {
+        (&**self).is_fast()
+    }
+}
+
+/// A type that encapsulates the selection of a prefilter algorithm from a
+/// sequence of needles.
+///
+/// The existence of this type is a little tricky, because we don't (currently)
+/// use it for performing a search. Instead, we really only consume it by
+/// converting the underlying prefilter into a trait object, whether that be
+/// `dyn PrefilterI` or `dyn Strategy` (for the meta regex engine). In order
+/// to avoid re-copying the prefilter selection logic, we isolate it here, and
+/// then force anything downstream that wants to convert it to a trait object
+/// to do trivial case analysis on it.
+///
+/// One wonders whether we *should* use an enum instead of a trait object.
+/// At time of writing, I chose trait objects based on instinct because 1) I
+/// knew I wasn't going to inline anything and 2) there would potentially be
+/// many different choices. However, as of time of writing, I haven't actually
+/// compared the trait object approach to the enum approach. That probably
+/// should be litigated, but I ran out of steam.
+///
+/// Note that if the `alloc` feature is disabled, then values of this type
+/// are (and should) never be constructed. Also, in practice, for any of the
+/// prefilters to be selected, you'll need at least one of the `perf-literal-*`
+/// features enabled.
+#[derive(Clone, Debug)]
+pub(crate) enum Choice {
+    Memchr(Memchr),
+    Memchr2(Memchr2),
+    Memchr3(Memchr3),
+    Memmem(Memmem),
+    Teddy(Teddy),
+    ByteSet(ByteSet),
+    AhoCorasick(AhoCorasick),
+}
+
+impl Choice {
+    /// Select what is believed to be the best prefilter algorithm for the
+    /// match semantics and sequence of needles given.
+    ///
+    /// This selection algorithm uses the needles as given without any
+    /// modification. For example, if `[bar]` is given, then this doesn't
+    /// try to select `memchr` for `b`. Instead, it would select `memmem`
+    /// for `bar`. If callers would want `memchr` selected for `[bar]`, then
+    /// callers should massages the literals themselves. That is, callers are
+    /// responsible for heuristics surrounding which sequence of literals is
+    /// best.
+    ///
+    /// What this selection algorithm does is attempt to use the fastest
+    /// prefilter that works for the literals given. So if `[a, b]`, is given,
+    /// then `memchr2` is selected.
+    ///
+    /// Of course, which prefilter is selected is also subject to what
+    /// is available. For example, if `alloc` isn't enabled, then
+    /// that limits which prefilters can be selected. Similarly, if
+    /// `perf-literal-substring` isn't enabled, then nothing from the `memchr`
+    /// crate can be returned.
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Choice> {
+        // An empty set means the regex matches nothing, so no sense in
+        // building a prefilter.
+        if needles.len() == 0 {
+            debug!("prefilter building failed: found empty set of literals");
+            return None;
+        }
+        // If the regex can match the empty string, then the prefilter
+        // will by definition match at every position. This is obviously
+        // completely ineffective.
+        if needles.iter().any(|n| n.as_ref().is_empty()) {
+            debug!("prefilter building failed: literals match empty string");
+            return None;
+        }
+        // BREADCRUMBS: Perhaps the literal optimizer should special case
+        // sequences of length two or three if the leading bytes of each are
+        // "rare"? Or perhaps, if there are two or three total possible leading
+        // bytes, regardless of the number of literals, and all are rare...
+        // Then well, perhaps we should use memchr2 or memchr3 in those cases?
+        if let Some(pre) = Memchr::new(kind, needles) {
+            debug!("prefilter built: memchr");
+            return Some(Choice::Memchr(pre));
+        }
+        if let Some(pre) = Memchr2::new(kind, needles) {
+            debug!("prefilter built: memchr2");
+            return Some(Choice::Memchr2(pre));
+        }
+        if let Some(pre) = Memchr3::new(kind, needles) {
+            debug!("prefilter built: memchr3");
+            return Some(Choice::Memchr3(pre));
+        }
+        if let Some(pre) = Memmem::new(kind, needles) {
+            debug!("prefilter built: memmem");
+            return Some(Choice::Memmem(pre));
+        }
+        if let Some(pre) = Teddy::new(kind, needles) {
+            debug!("prefilter built: teddy");
+            return Some(Choice::Teddy(pre));
+        }
+        if let Some(pre) = ByteSet::new(kind, needles) {
+            debug!("prefilter built: byteset");
+            return Some(Choice::ByteSet(pre));
+        }
+        if let Some(pre) = AhoCorasick::new(kind, needles) {
+            debug!("prefilter built: aho-corasick");
+            return Some(Choice::AhoCorasick(pre));
+        }
+        debug!("prefilter building failed: no strategy could be found");
+        None
+    }
+}
+
+/// Extracts all of the prefix literals from the given HIR expressions into a
+/// single `Seq`. The literals in the sequence are ordered with respect to the
+/// order of the given HIR expressions and consistent with the match semantics
+/// given.
+///
+/// The sequence returned is "optimized." That is, they may be shrunk or even
+/// truncated according to heuristics with the intent of making them more
+/// useful as a prefilter. (Which translates to both using faster algorithms
+/// and minimizing the false positive rate.)
+///
+/// Note that this erases any connection between the literals and which pattern
+/// (or patterns) they came from.
+///
+/// The match kind given must correspond to the match semantics of the regex
+/// that is represented by the HIRs given. The match semantics may change the
+/// literal sequence returned.
+#[cfg(feature = "syntax")]
+pub(crate) fn prefixes<H>(kind: MatchKind, hirs: &[H]) -> literal::Seq
+where
+    H: core::borrow::Borrow<Hir>,
+{
+    let mut extractor = literal::Extractor::new();
+    extractor.kind(literal::ExtractKind::Prefix);
+
+    let mut prefixes = literal::Seq::empty();
+    for hir in hirs {
+        prefixes.union(&mut extractor.extract(hir.borrow()));
+    }
+    debug!(
+        "prefixes (len={:?}, exact={:?}) extracted before optimization: {:?}",
+        prefixes.len(),
+        prefixes.is_exact(),
+        prefixes
+    );
+    match kind {
+        MatchKind::All => {
+            prefixes.sort();
+            prefixes.dedup();
+        }
+        MatchKind::LeftmostFirst => {
+            prefixes.optimize_for_prefix_by_preference();
+        }
+    }
+    debug!(
+        "prefixes (len={:?}, exact={:?}) extracted after optimization: {:?}",
+        prefixes.len(),
+        prefixes.is_exact(),
+        prefixes
+    );
+    prefixes
+}
+
+/// Like `prefixes`, but for all suffixes of all matches for the given HIRs.
+#[cfg(feature = "syntax")]
+pub(crate) fn suffixes<H>(kind: MatchKind, hirs: &[H]) -> literal::Seq
+where
+    H: core::borrow::Borrow<Hir>,
+{
+    let mut extractor = literal::Extractor::new();
+    extractor.kind(literal::ExtractKind::Suffix);
+
+    let mut suffixes = literal::Seq::empty();
+    for hir in hirs {
+        suffixes.union(&mut extractor.extract(hir.borrow()));
+    }
+    debug!(
+        "suffixes (len={:?}, exact={:?}) extracted before optimization: {:?}",
+        suffixes.len(),
+        suffixes.is_exact(),
+        suffixes
+    );
+    match kind {
+        MatchKind::All => {
+            suffixes.sort();
+            suffixes.dedup();
+        }
+        MatchKind::LeftmostFirst => {
+            suffixes.optimize_for_suffix_by_preference();
+        }
+    }
+    debug!(
+        "suffixes (len={:?}, exact={:?}) extracted after optimization: {:?}",
+        suffixes.len(),
+        suffixes.is_exact(),
+        suffixes
+    );
+    suffixes
+}
diff --git a/regex-automata/src/util/prefilter/teddy.rs b/regex-automata/src/util/prefilter/teddy.rs
new file mode 100644
index 0000000000..e8383c0a61
--- /dev/null
+++ b/regex-automata/src/util/prefilter/teddy.rs
@@ -0,0 +1,155 @@
+use crate::util::{
+    prefilter::PrefilterI,
+    search::{MatchKind, Span},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Teddy {
+    #[cfg(not(feature = "perf-literal-multisubstring"))]
+    _unused: (),
+    /// The actual Teddy searcher.
+    ///
+    /// Technically, it's possible that Teddy doesn't actually get used, since
+    /// Teddy does require its haystack to at least be of a certain size
+    /// (usually around the size of whatever vector is being used, so ~16
+    /// or ~32 bytes). For haystacks shorter than that, the implementation
+    /// currently uses Rabin-Karp.
+    #[cfg(feature = "perf-literal-multisubstring")]
+    searcher: aho_corasick::packed::Searcher,
+    /// When running an anchored search, the packed searcher can't handle it so
+    /// we defer to Aho-Corasick itself. Kind of sad, but changing the packed
+    /// searchers to support anchored search would be difficult at worst and
+    /// annoying at best. Since packed searchers only apply to small numbers of
+    /// literals, we content ourselves that this is not much of an added cost.
+    /// (That packed searchers only work with a small number of literals is
+    /// also why we use a DFA here. Otherwise, the memory usage of a DFA would
+    /// likely be unacceptable.)
+    #[cfg(feature = "perf-literal-multisubstring")]
+    anchored_ac: aho_corasick::dfa::DFA,
+    /// The length of the smallest literal we look for.
+    ///
+    /// We use this as a hueristic to figure out whether this will be "fast" or
+    /// not. Generally, the longer the better, because longer needles are more
+    /// discriminating and thus reduce false positive rate.
+    #[cfg(feature = "perf-literal-multisubstring")]
+    minimum_len: usize,
+}
+
+impl Teddy {
+    pub(crate) fn new<B: AsRef<[u8]>>(
+        kind: MatchKind,
+        needles: &[B],
+    ) -> Option<Teddy> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            None
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            // We only really support leftmost-first semantics. In
+            // theory we could at least support leftmost-longest, as the
+            // aho-corasick crate does, but regex-automata doesn't know about
+            // leftmost-longest currently.
+            let (packed_match_kind, ac_match_kind) = match kind {
+                MatchKind::LeftmostFirst => (
+                    aho_corasick::packed::MatchKind::LeftmostFirst,
+                    aho_corasick::MatchKind::LeftmostFirst,
+                ),
+                _ => return None,
+            };
+            let minimum_len =
+                needles.iter().map(|n| n.as_ref().len()).min().unwrap_or(0);
+            let packed = aho_corasick::packed::Config::new()
+                .match_kind(packed_match_kind)
+                .builder()
+                .extend(needles)
+                .build()?;
+            let anchored_ac = aho_corasick::dfa::DFA::builder()
+                .match_kind(ac_match_kind)
+                .start_kind(aho_corasick::StartKind::Anchored)
+                .prefilter(false)
+                .build(needles)
+                .ok()?;
+            Some(Teddy { searcher: packed, anchored_ac, minimum_len })
+        }
+    }
+}
+
+impl PrefilterI for Teddy {
+    fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            let ac_span =
+                aho_corasick::Span { start: span.start, end: span.end };
+            self.searcher
+                .find_in(haystack, ac_span)
+                .map(|m| Span { start: m.start(), end: m.end() })
+        }
+    }
+
+    fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            use aho_corasick::automaton::Automaton;
+            let input = aho_corasick::Input::new(haystack)
+                .anchored(aho_corasick::Anchored::Yes)
+                .span(span.start..span.end);
+            self.anchored_ac
+                .try_find(&input)
+                // OK because we build the DFA with anchored support.
+                .expect("aho-corasick DFA should never fail")
+                .map(|m| Span { start: m.start(), end: m.end() })
+        }
+    }
+
+    fn memory_usage(&self) -> usize {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            use aho_corasick::automaton::Automaton;
+            self.searcher.memory_usage() + self.anchored_ac.memory_usage()
+        }
+    }
+
+    fn is_fast(&self) -> bool {
+        #[cfg(not(feature = "perf-literal-multisubstring"))]
+        {
+            unreachable!()
+        }
+        #[cfg(feature = "perf-literal-multisubstring")]
+        {
+            // Teddy is usually quite fast, but I have seen some cases where
+            // a large number of literals can overwhelm it and make it not so
+            // fast. We make an educated but conservative guess at a limit, at
+            // which point, we're not so comfortable thinking Teddy is "fast."
+            //
+            // Well... this used to incorporate a "limit" on the *number*
+            // of literals, but I have since changed it to a minimum on the
+            // *smallest* literal. Namely, when there is a very small literal
+            // (1 or 2 bytes), it is far more likely that it leads to a higher
+            // false positive rate. (Although, of course, not always. For
+            // example, 'zq' is likely to have a very low false positive rate.)
+            // But when we have 3 bytes, we have a really good chance of being
+            // quite discriminatory and thus fast.
+            //
+            // We may still want to add some kind of limit on the number of
+            // literals here, but keep in mind that Teddy already has its own
+            // somewhat small limit (64 at time of writing). The main issue
+            // here is that if 'is_fast' is false, it opens the door for the
+            // reverse inner optimization to kick in. We really only want to
+            // resort to the reverse inner optimization if we absolutely must.
+            self.minimum_len >= 3
+        }
+    }
+}
diff --git a/regex-automata/src/util/primitives.rs b/regex-automata/src/util/primitives.rs
new file mode 100644
index 0000000000..5c5d187b0e
--- /dev/null
+++ b/regex-automata/src/util/primitives.rs
@@ -0,0 +1,776 @@
+/*!
+Lower level primitive types that are useful in a variety of circumstances.
+
+# Overview
+
+This list represents the principle types in this module and briefly describes
+when you might want to use them.
+
+* [`PatternID`] - A type that represents the identifier of a regex pattern.
+This is probably the most widely used type in this module (which is why it's
+also re-exported in the crate root).
+* [`StateID`] - A type the represents the identifier of a finite automaton
+state. This is used for both NFAs and DFAs, with the notable exception of
+the hybrid NFA/DFA. (The hybrid NFA/DFA uses a special purpose "lazy" state
+identifier.)
+* [`SmallIndex`] - The internal representation of both a `PatternID` and a
+`StateID`. Its purpose is to serve as a type that can index memory without
+being as big as a `usize` on 64-bit targets. The main idea behind this type
+is that there are many things in regex engines that will, in practice, never
+overflow a 32-bit integer. (For example, like the number of patterns in a regex
+or the number of states in an NFA.) Thus, a `SmallIndex` can be used to index
+memory without peppering `as` casts everywhere. Moreover, it forces callers
+to handle errors in the case where, somehow, the value would otherwise overflow
+either a 32-bit integer or a `usize` (e.g., on 16-bit targets).
+* [`NonMaxUsize`] - Represents a `usize` that cannot be `usize::MAX`. As a
+result, `Option<NonMaxUsize>` has the same size in memory as a `usize`. This
+useful, for example, when representing the offsets of submatches since it
+reduces memory usage by a factor of 2. It is a legal optimization since Rust
+guarantees that slices never have a length that exceeds `isize::MAX`.
+*/
+
+use core::num::NonZeroUsize;
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+use crate::util::int::{Usize, U16, U32, U64};
+
+/// A `usize` that can never be `usize::MAX`.
+///
+/// This is similar to `core::num::NonZeroUsize`, but instead of not permitting
+/// a zero value, this does not permit a max value.
+///
+/// This is useful in certain contexts where one wants to optimize the memory
+/// usage of things that contain match offsets. Namely, since Rust slices
+/// are guaranteed to never have a length exceeding `isize::MAX`, we can use
+/// `usize::MAX` as a sentinel to indicate that no match was found. Indeed,
+/// types like `Option<NonMaxUsize>` have exactly the same size in memory as a
+/// `usize`.
+///
+/// This type is defined to be `repr(transparent)` for
+/// `core::num::NonZeroUsize`, which is in turn defined to be
+/// `repr(transparent)` for `usize`.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct NonMaxUsize(NonZeroUsize);
+
+impl NonMaxUsize {
+    /// Create a new `NonMaxUsize` from the given value.
+    ///
+    /// This returns `None` only when the given value is equal to `usize::MAX`.
+    #[inline]
+    pub fn new(value: usize) -> Option<NonMaxUsize> {
+        NonZeroUsize::new(value.wrapping_add(1)).map(NonMaxUsize)
+    }
+
+    /// Return the underlying `usize` value. The returned value is guaranteed
+    /// to not equal `usize::MAX`.
+    #[inline]
+    pub fn get(self) -> usize {
+        self.0.get().wrapping_sub(1)
+    }
+}
+
+// We provide our own Debug impl because seeing the internal repr can be quite
+// surprising if you aren't expecting it. e.g., 'NonMaxUsize(5)' vs just '5'.
+impl core::fmt::Debug for NonMaxUsize {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{:?}", self.get())
+    }
+}
+
+/// A type that represents a "small" index.
+///
+/// The main idea of this type is to provide something that can index memory,
+/// but uses less memory than `usize` on 64-bit systems. Specifically, its
+/// representation is always a `u32` and has `repr(transparent)` enabled. (So
+/// it is safe to transmute between a `u32` and a `SmallIndex`.)
+///
+/// A small index is typically useful in cases where there is no practical way
+/// that the index will overflow a 32-bit integer. A good example of this is
+/// an NFA state. If you could somehow build an NFA with `2^30` states, its
+/// memory usage would be exorbitant and its runtime execution would be so
+/// slow as to be completely worthless. Therefore, this crate generally deems
+/// it acceptable to return an error if it would otherwise build an NFA that
+/// requires a slice longer than what a 32-bit integer can index. In exchange,
+/// we can use 32-bit indices instead of 64-bit indices in various places.
+///
+/// This type ensures this by providing a constructor that will return an error
+/// if its argument cannot fit into the type. This makes it much easier to
+/// handle these sorts of boundary cases that are otherwise extremely subtle.
+///
+/// On all targets, this type guarantees that its value will fit in a `u32`,
+/// `i32`, `usize` and an `isize`. This means that on 16-bit targets, for
+/// example, this type's maximum value will never overflow an `isize`,
+/// which means it will never overflow a `i16` even though its internal
+/// representation is still a `u32`.
+///
+/// The purpose for making the type fit into even signed integer types like
+/// `isize` is to guarantee that the difference between any two small indices
+/// is itself also a small index. This is useful in certain contexts, e.g.,
+/// for delta encoding.
+///
+/// # Other types
+///
+/// The following types wrap `SmallIndex` to provide a more focused use case:
+///
+/// * [`PatternID`] is for representing the identifiers of patterns.
+/// * [`StateID`] is for representing the identifiers of states in finite
+/// automata. It is used for both NFAs and DFAs.
+///
+/// # Representation
+///
+/// This type is always represented internally by a `u32` and is marked as
+/// `repr(transparent)`. Thus, this type always has the same representation as
+/// a `u32`. It is thus safe to transmute between a `u32` and a `SmallIndex`.
+///
+/// # Indexing
+///
+/// For convenience, callers may use a `SmallIndex` to index slices.
+///
+/// # Safety
+///
+/// While a `SmallIndex` is meant to guarantee that its value fits into `usize`
+/// without using as much space as a `usize` on all targets, callers must
+/// not rely on this property for safety. Callers may choose to rely on this
+/// property for correctness however. For example, creating a `SmallIndex` with
+/// an invalid value can be done in entirely safe code. This may in turn result
+/// in panics or silent logical errors.
+#[derive(
+    Clone, Copy, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord,
+)]
+#[repr(transparent)]
+pub struct SmallIndex(u32);
+
+impl SmallIndex {
+    /// The maximum index value.
+    #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
+    pub const MAX: SmallIndex =
+        // FIXME: Use as_usize() once const functions in traits are stable.
+        SmallIndex::new_unchecked(core::i32::MAX as usize - 1);
+
+    /// The maximum index value.
+    #[cfg(target_pointer_width = "16")]
+    pub const MAX: SmallIndex =
+        SmallIndex::new_unchecked(core::isize::MAX - 1);
+
+    /// The total number of values that can be represented as a small index.
+    pub const LIMIT: usize = SmallIndex::MAX.as_usize() + 1;
+
+    /// The zero index value.
+    pub const ZERO: SmallIndex = SmallIndex::new_unchecked(0);
+
+    /// The number of bytes that a single small index uses in memory.
+    pub const SIZE: usize = core::mem::size_of::<SmallIndex>();
+
+    /// Create a new small index.
+    ///
+    /// If the given index exceeds [`SmallIndex::MAX`], then this returns
+    /// an error.
+    #[inline]
+    pub fn new(index: usize) -> Result<SmallIndex, SmallIndexError> {
+        SmallIndex::try_from(index)
+    }
+
+    /// Create a new small index without checking whether the given value
+    /// exceeds [`SmallIndex::MAX`].
+    ///
+    /// Using this routine with an invalid index value will result in
+    /// unspecified behavior, but *not* undefined behavior. In particular, an
+    /// invalid index value is likely to cause panics or possibly even silent
+    /// logical errors.
+    ///
+    /// Callers must never rely on a `SmallIndex` to be within a certain range
+    /// for memory safety.
+    #[inline]
+    pub const fn new_unchecked(index: usize) -> SmallIndex {
+        // FIXME: Use as_u32() once const functions in traits are stable.
+        SmallIndex(index as u32)
+    }
+
+    /// Like [`SmallIndex::new`], but panics if the given index is not valid.
+    #[inline]
+    pub fn must(index: usize) -> SmallIndex {
+        SmallIndex::new(index).expect("invalid small index")
+    }
+
+    /// Return this small index as a `usize`. This is guaranteed to never
+    /// overflow `usize`.
+    #[inline]
+    pub const fn as_usize(&self) -> usize {
+        // FIXME: Use as_usize() once const functions in traits are stable.
+        self.0 as usize
+    }
+
+    /// Return this small index as a `u64`. This is guaranteed to never
+    /// overflow.
+    #[inline]
+    pub const fn as_u64(&self) -> u64 {
+        // FIXME: Use u64::from() once const functions in traits are stable.
+        self.0 as u64
+    }
+
+    /// Return the internal `u32` of this small index. This is guaranteed to
+    /// never overflow `u32`.
+    #[inline]
+    pub const fn as_u32(&self) -> u32 {
+        self.0
+    }
+
+    /// Return the internal `u32` of this small index represented as an `i32`.
+    /// This is guaranteed to never overflow an `i32`.
+    #[inline]
+    pub const fn as_i32(&self) -> i32 {
+        // This is OK because we guarantee that our max value is <= i32::MAX.
+        self.0 as i32
+    }
+
+    /// Returns one more than this small index as a usize.
+    ///
+    /// Since a small index has constraints on its maximum value, adding `1` to
+    /// it will always fit in a `usize`, `u32` and a `i32`.
+    #[inline]
+    pub fn one_more(&self) -> usize {
+        self.as_usize() + 1
+    }
+
+    /// Decode this small index from the bytes given using the native endian
+    /// byte order for the current target.
+    ///
+    /// If the decoded integer is not representable as a small index for the
+    /// current target, then this returns an error.
+    #[inline]
+    pub fn from_ne_bytes(
+        bytes: [u8; 4],
+    ) -> Result<SmallIndex, SmallIndexError> {
+        let id = u32::from_ne_bytes(bytes);
+        if id > SmallIndex::MAX.as_u32() {
+            return Err(SmallIndexError { attempted: u64::from(id) });
+        }
+        Ok(SmallIndex::new_unchecked(id.as_usize()))
+    }
+
+    /// Decode this small index from the bytes given using the native endian
+    /// byte order for the current target.
+    ///
+    /// This is analogous to [`SmallIndex::new_unchecked`] in that is does not
+    /// check whether the decoded integer is representable as a small index.
+    #[inline]
+    pub fn from_ne_bytes_unchecked(bytes: [u8; 4]) -> SmallIndex {
+        SmallIndex::new_unchecked(u32::from_ne_bytes(bytes).as_usize())
+    }
+
+    /// Return the underlying small index integer as raw bytes in native endian
+    /// format.
+    #[inline]
+    pub fn to_ne_bytes(&self) -> [u8; 4] {
+        self.0.to_ne_bytes()
+    }
+}
+
+impl<T> core::ops::Index<SmallIndex> for [T] {
+    type Output = T;
+
+    #[inline]
+    fn index(&self, index: SmallIndex) -> &T {
+        &self[index.as_usize()]
+    }
+}
+
+impl<T> core::ops::IndexMut<SmallIndex> for [T] {
+    #[inline]
+    fn index_mut(&mut self, index: SmallIndex) -> &mut T {
+        &mut self[index.as_usize()]
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<T> core::ops::Index<SmallIndex> for Vec<T> {
+    type Output = T;
+
+    #[inline]
+    fn index(&self, index: SmallIndex) -> &T {
+        &self[index.as_usize()]
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<T> core::ops::IndexMut<SmallIndex> for Vec<T> {
+    #[inline]
+    fn index_mut(&mut self, index: SmallIndex) -> &mut T {
+        &mut self[index.as_usize()]
+    }
+}
+
+impl From<u8> for SmallIndex {
+    fn from(index: u8) -> SmallIndex {
+        SmallIndex::new_unchecked(usize::from(index))
+    }
+}
+
+impl TryFrom<u16> for SmallIndex {
+    type Error = SmallIndexError;
+
+    fn try_from(index: u16) -> Result<SmallIndex, SmallIndexError> {
+        if u32::from(index) > SmallIndex::MAX.as_u32() {
+            return Err(SmallIndexError { attempted: u64::from(index) });
+        }
+        Ok(SmallIndex::new_unchecked(index.as_usize()))
+    }
+}
+
+impl TryFrom<u32> for SmallIndex {
+    type Error = SmallIndexError;
+
+    fn try_from(index: u32) -> Result<SmallIndex, SmallIndexError> {
+        if index > SmallIndex::MAX.as_u32() {
+            return Err(SmallIndexError { attempted: u64::from(index) });
+        }
+        Ok(SmallIndex::new_unchecked(index.as_usize()))
+    }
+}
+
+impl TryFrom<u64> for SmallIndex {
+    type Error = SmallIndexError;
+
+    fn try_from(index: u64) -> Result<SmallIndex, SmallIndexError> {
+        if index > SmallIndex::MAX.as_u64() {
+            return Err(SmallIndexError { attempted: index });
+        }
+        Ok(SmallIndex::new_unchecked(index.as_usize()))
+    }
+}
+
+impl TryFrom<usize> for SmallIndex {
+    type Error = SmallIndexError;
+
+    fn try_from(index: usize) -> Result<SmallIndex, SmallIndexError> {
+        if index > SmallIndex::MAX.as_usize() {
+            return Err(SmallIndexError { attempted: index.as_u64() });
+        }
+        Ok(SmallIndex::new_unchecked(index))
+    }
+}
+
+#[cfg(test)]
+impl quickcheck::Arbitrary for SmallIndex {
+    fn arbitrary(gen: &mut quickcheck::Gen) -> SmallIndex {
+        use core::cmp::max;
+
+        let id = max(i32::MIN + 1, i32::arbitrary(gen)).abs();
+        if id > SmallIndex::MAX.as_i32() {
+            SmallIndex::MAX
+        } else {
+            SmallIndex::new(usize::try_from(id).unwrap()).unwrap()
+        }
+    }
+}
+
+/// This error occurs when a small index could not be constructed.
+///
+/// This occurs when given an integer exceeding the maximum small index value.
+///
+/// When the `std` feature is enabled, this implements the `Error` trait.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SmallIndexError {
+    attempted: u64,
+}
+
+impl SmallIndexError {
+    /// Returns the value that could not be converted to a small index.
+    pub fn attempted(&self) -> u64 {
+        self.attempted
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SmallIndexError {}
+
+impl core::fmt::Display for SmallIndexError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(
+            f,
+            "failed to create small index from {:?}, which exceeds {:?}",
+            self.attempted(),
+            SmallIndex::MAX,
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct SmallIndexIter {
+    rng: core::ops::Range<usize>,
+}
+
+impl Iterator for SmallIndexIter {
+    type Item = SmallIndex;
+
+    fn next(&mut self) -> Option<SmallIndex> {
+        if self.rng.start >= self.rng.end {
+            return None;
+        }
+        let next_id = self.rng.start + 1;
+        let id = core::mem::replace(&mut self.rng.start, next_id);
+        // new_unchecked is OK since we asserted that the number of
+        // elements in this iterator will fit in an ID at construction.
+        Some(SmallIndex::new_unchecked(id))
+    }
+}
+
+macro_rules! index_type_impls {
+    ($name:ident, $err:ident, $iter:ident, $withiter:ident) => {
+        impl $name {
+            /// The maximum value.
+            pub const MAX: $name = $name(SmallIndex::MAX);
+
+            /// The total number of values that can be represented.
+            pub const LIMIT: usize = SmallIndex::LIMIT;
+
+            /// The zero value.
+            pub const ZERO: $name = $name(SmallIndex::ZERO);
+
+            /// The number of bytes that a single value uses in memory.
+            pub const SIZE: usize = SmallIndex::SIZE;
+
+            /// Create a new value that is represented by a "small index."
+            ///
+            /// If the given index exceeds the maximum allowed value, then this
+            /// returns an error.
+            #[inline]
+            pub fn new(value: usize) -> Result<$name, $err> {
+                SmallIndex::new(value).map($name).map_err($err)
+            }
+
+            /// Create a new value without checking whether the given argument
+            /// exceeds the maximum.
+            ///
+            /// Using this routine with an invalid value will result in
+            /// unspecified behavior, but *not* undefined behavior. In
+            /// particular, an invalid ID value is likely to cause panics or
+            /// possibly even silent logical errors.
+            ///
+            /// Callers must never rely on this type to be within a certain
+            /// range for memory safety.
+            #[inline]
+            pub const fn new_unchecked(value: usize) -> $name {
+                $name(SmallIndex::new_unchecked(value))
+            }
+
+            /// Like `new`, but panics if the given value is not valid.
+            #[inline]
+            pub fn must(value: usize) -> $name {
+                $name::new(value).expect(concat!(
+                    "invalid ",
+                    stringify!($name),
+                    " value"
+                ))
+            }
+
+            /// Return the internal value as a `usize`. This is guaranteed to
+            /// never overflow `usize`.
+            #[inline]
+            pub const fn as_usize(&self) -> usize {
+                self.0.as_usize()
+            }
+
+            /// Return the internal value as a `u64`. This is guaranteed to
+            /// never overflow.
+            #[inline]
+            pub const fn as_u64(&self) -> u64 {
+                self.0.as_u64()
+            }
+
+            /// Return the internal value as a `u32`. This is guaranteed to
+            /// never overflow `u32`.
+            #[inline]
+            pub const fn as_u32(&self) -> u32 {
+                self.0.as_u32()
+            }
+
+            /// Return the internal value as a i32`. This is guaranteed to
+            /// never overflow an `i32`.
+            #[inline]
+            pub const fn as_i32(&self) -> i32 {
+                self.0.as_i32()
+            }
+
+            /// Returns one more than this value as a usize.
+            ///
+            /// Since values represented by a "small index" have constraints
+            /// on their maximum value, adding `1` to it will always fit in a
+            /// `usize`, `u32` and a `i32`.
+            #[inline]
+            pub fn one_more(&self) -> usize {
+                self.0.one_more()
+            }
+
+            /// Decode this value from the bytes given using the native endian
+            /// byte order for the current target.
+            ///
+            /// If the decoded integer is not representable as a small index
+            /// for the current target, then this returns an error.
+            #[inline]
+            pub fn from_ne_bytes(bytes: [u8; 4]) -> Result<$name, $err> {
+                SmallIndex::from_ne_bytes(bytes).map($name).map_err($err)
+            }
+
+            /// Decode this value from the bytes given using the native endian
+            /// byte order for the current target.
+            ///
+            /// This is analogous to `new_unchecked` in that is does not check
+            /// whether the decoded integer is representable as a small index.
+            #[inline]
+            pub fn from_ne_bytes_unchecked(bytes: [u8; 4]) -> $name {
+                $name(SmallIndex::from_ne_bytes_unchecked(bytes))
+            }
+
+            /// Return the underlying integer as raw bytes in native endian
+            /// format.
+            #[inline]
+            pub fn to_ne_bytes(&self) -> [u8; 4] {
+                self.0.to_ne_bytes()
+            }
+
+            /// Returns an iterator over all values from 0 up to and not
+            /// including the given length.
+            ///
+            /// If the given length exceeds this type's limit, then this
+            /// panics.
+            pub(crate) fn iter(len: usize) -> $iter {
+                $iter::new(len)
+            }
+        }
+
+        // We write our own Debug impl so that we get things like PatternID(5)
+        // instead of PatternID(SmallIndex(5)).
+        impl core::fmt::Debug for $name {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                f.debug_tuple(stringify!($name)).field(&self.as_u32()).finish()
+            }
+        }
+
+        impl<T> core::ops::Index<$name> for [T] {
+            type Output = T;
+
+            #[inline]
+            fn index(&self, index: $name) -> &T {
+                &self[index.as_usize()]
+            }
+        }
+
+        impl<T> core::ops::IndexMut<$name> for [T] {
+            #[inline]
+            fn index_mut(&mut self, index: $name) -> &mut T {
+                &mut self[index.as_usize()]
+            }
+        }
+
+        #[cfg(feature = "alloc")]
+        impl<T> core::ops::Index<$name> for Vec<T> {
+            type Output = T;
+
+            #[inline]
+            fn index(&self, index: $name) -> &T {
+                &self[index.as_usize()]
+            }
+        }
+
+        #[cfg(feature = "alloc")]
+        impl<T> core::ops::IndexMut<$name> for Vec<T> {
+            #[inline]
+            fn index_mut(&mut self, index: $name) -> &mut T {
+                &mut self[index.as_usize()]
+            }
+        }
+
+        impl From<u8> for $name {
+            fn from(value: u8) -> $name {
+                $name(SmallIndex::from(value))
+            }
+        }
+
+        impl TryFrom<u16> for $name {
+            type Error = $err;
+
+            fn try_from(value: u16) -> Result<$name, $err> {
+                SmallIndex::try_from(value).map($name).map_err($err)
+            }
+        }
+
+        impl TryFrom<u32> for $name {
+            type Error = $err;
+
+            fn try_from(value: u32) -> Result<$name, $err> {
+                SmallIndex::try_from(value).map($name).map_err($err)
+            }
+        }
+
+        impl TryFrom<u64> for $name {
+            type Error = $err;
+
+            fn try_from(value: u64) -> Result<$name, $err> {
+                SmallIndex::try_from(value).map($name).map_err($err)
+            }
+        }
+
+        impl TryFrom<usize> for $name {
+            type Error = $err;
+
+            fn try_from(value: usize) -> Result<$name, $err> {
+                SmallIndex::try_from(value).map($name).map_err($err)
+            }
+        }
+
+        #[cfg(test)]
+        impl quickcheck::Arbitrary for $name {
+            fn arbitrary(gen: &mut quickcheck::Gen) -> $name {
+                $name(SmallIndex::arbitrary(gen))
+            }
+        }
+
+        /// This error occurs when a value could not be constructed.
+        ///
+        /// This occurs when given an integer exceeding the maximum allowed
+        /// value.
+        ///
+        /// When the `std` feature is enabled, this implements the `Error`
+        /// trait.
+        #[derive(Clone, Debug, Eq, PartialEq)]
+        pub struct $err(SmallIndexError);
+
+        impl $err {
+            /// Returns the value that could not be converted to an ID.
+            pub fn attempted(&self) -> u64 {
+                self.0.attempted()
+            }
+        }
+
+        #[cfg(feature = "std")]
+        impl std::error::Error for $err {}
+
+        impl core::fmt::Display for $err {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(
+                    f,
+                    "failed to create {} from {:?}, which exceeds {:?}",
+                    stringify!($name),
+                    self.attempted(),
+                    $name::MAX,
+                )
+            }
+        }
+
+        #[derive(Clone, Debug)]
+        pub(crate) struct $iter(SmallIndexIter);
+
+        impl $iter {
+            fn new(len: usize) -> $iter {
+                assert!(
+                    len <= $name::LIMIT,
+                    "cannot create iterator for {} when number of \
+                     elements exceed {:?}",
+                    stringify!($name),
+                    $name::LIMIT,
+                );
+                $iter(SmallIndexIter { rng: 0..len })
+            }
+        }
+
+        impl Iterator for $iter {
+            type Item = $name;
+
+            fn next(&mut self) -> Option<$name> {
+                self.0.next().map($name)
+            }
+        }
+
+        /// An iterator adapter that is like std::iter::Enumerate, but attaches
+        /// small index values instead. It requires `ExactSizeIterator`. At
+        /// construction, it ensures that the index of each element in the
+        /// iterator is representable in the corresponding small index type.
+        #[derive(Clone, Debug)]
+        pub(crate) struct $withiter<I> {
+            it: I,
+            ids: $iter,
+        }
+
+        impl<I: Iterator + ExactSizeIterator> $withiter<I> {
+            fn new(it: I) -> $withiter<I> {
+                let ids = $name::iter(it.len());
+                $withiter { it, ids }
+            }
+        }
+
+        impl<I: Iterator + ExactSizeIterator> Iterator for $withiter<I> {
+            type Item = ($name, I::Item);
+
+            fn next(&mut self) -> Option<($name, I::Item)> {
+                let item = self.it.next()?;
+                // Number of elements in this iterator must match, according
+                // to contract of ExactSizeIterator.
+                let id = self.ids.next().unwrap();
+                Some((id, item))
+            }
+        }
+    };
+}
+
+/// The identifier of a regex pattern, represented by a [`SmallIndex`].
+///
+/// The identifier for a pattern corresponds to its relative position among
+/// other patterns in a single finite state machine. Namely, when building
+/// a multi-pattern regex engine, one must supply a sequence of patterns to
+/// match. The position (starting at 0) of each pattern in that sequence
+/// represents its identifier. This identifier is in turn used to identify and
+/// report matches of that pattern in various APIs.
+///
+/// See the [`SmallIndex`] type for more information about what it means for
+/// a pattern ID to be a "small index."
+///
+/// Note that this type is defined in the
+/// [`util::primitives`](crate::util::primitives) module, but it is also
+/// re-exported at the crate root due to how common it is.
+#[derive(Clone, Copy, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct PatternID(SmallIndex);
+
+/// The identifier of a finite automaton state, represented by a
+/// [`SmallIndex`].
+///
+/// Most regex engines in this crate are built on top of finite automata. Each
+/// state in a finite automaton defines transitions from its state to another.
+/// Those transitions point to other states via their identifiers, i.e., a
+/// `StateID`. Since finite automata tend to contain many transitions, it is
+/// much more memory efficient to define state IDs as small indices.
+///
+/// See the [`SmallIndex`] type for more information about what it means for
+/// a state ID to be a "small index."
+#[derive(Clone, Copy, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct StateID(SmallIndex);
+
+index_type_impls!(PatternID, PatternIDError, PatternIDIter, WithPatternIDIter);
+index_type_impls!(StateID, StateIDError, StateIDIter, WithStateIDIter);
+
+/// A utility trait that defines a couple of adapters for making it convenient
+/// to access indices as "small index" types. We require ExactSizeIterator so
+/// that iterator construction can do a single check to make sure the index of
+/// each element is representable by its small index type.
+pub(crate) trait IteratorIndexExt: Iterator {
+    fn with_pattern_ids(self) -> WithPatternIDIter<Self>
+    where
+        Self: Sized + ExactSizeIterator,
+    {
+        WithPatternIDIter::new(self)
+    }
+
+    fn with_state_ids(self) -> WithStateIDIter<Self>
+    where
+        Self: Sized + ExactSizeIterator,
+    {
+        WithStateIDIter::new(self)
+    }
+}
+
+impl<I: Iterator> IteratorIndexExt for I {}
diff --git a/regex-automata/src/util/search.rs b/regex-automata/src/util/search.rs
new file mode 100644
index 0000000000..70affcb7fe
--- /dev/null
+++ b/regex-automata/src/util/search.rs
@@ -0,0 +1,1967 @@
+/*!
+Types and routines that support the search APIs of most regex engines.
+
+This sub-module isn't exposed directly, but rather, its contents are exported
+at the crate root due to the universality of most of the types and routines in
+this module.
+*/
+
+use core::ops::{Range, RangeBounds};
+
+use crate::util::{escape::DebugByte, primitives::PatternID, utf8};
+
+/// The parameters for a regex search including the haystack to search.
+///
+/// It turns out that regex searches have a few parameters, and in most cases,
+/// those parameters have defaults that work in the vast majority of cases.
+/// This `Input` type exists to make that common case seamnless while also
+/// providing an avenue for changing the parameters of a search. In particular,
+/// this type enables doing so without a combinatorial explosion of different
+/// methods and/or superfluous parameters in the common cases.
+///
+/// An `Input` permits configuring the following things:
+///
+/// * Search only a substring of a haystack, while taking the broader context
+/// into account for resolving look-around assertions.
+/// * Indicating whether to search for all patterns in a regex, or to
+/// only search for one pattern in particular.
+/// * Whether to perform an anchored on unanchored search.
+/// * Whether to report a match as early as possible.
+///
+/// All of these parameters, except for the haystack, have sensible default
+/// values. This means that the minimal search configuration is simply a call
+/// to [`Input::new`] with your haystack. Setting any other parameter is
+/// optional.
+///
+/// Moreover, for any `H` that implements `AsRef<[u8]>`, there exists a
+/// `From<H> for Input` implementation. This is useful because many of the
+/// search APIs in this crate accept an `Into<Input>`. This means you can
+/// provide string or byte strings to these routines directly, and they'll
+/// automatically get converted into an `Input` for you.
+///
+/// The lifetime parameter `'h` refers to the lifetime of the haystack.
+///
+/// # Organization
+///
+/// The API of `Input` is split into a few different parts:
+///
+/// * A builder-like API that transforms a `Input` by value. Examples:
+/// [`Input::span`] and [`Input::anchored`].
+/// * A setter API that permits mutating parameters in place. Examples:
+/// [`Input::set_span`] and [`Input::set_anchored`].
+/// * A getter API that permits retrieving any of the search parameters.
+/// Examples: [`Input::get_span`] and [`Input::get_anchored`].
+/// * A few convenience getter routines that don't conform to the above naming
+/// pattern due to how common they are. Examples: [`Input::haystack`],
+/// [`Input::start`] and [`Input::end`].
+/// * Miscellaneous predicates and other helper routines that are useful
+/// in some contexts. Examples: [`Input::is_char_boundary`].
+///
+/// A `Input` exposes so much because it is meant to be used by both callers of
+/// regex engines _and_ implementors of regex engines. A constraining factor is
+/// that regex engines should accept a `&Input` as its lowest level API, which
+/// means that implementors should only use the "getter" APIs of a `Input`.
+///
+/// # Valid bounds and search termination
+///
+/// An `Input` permits setting the bounds of a search via either
+/// [`Input::span`] or [`Input::range`]. The bounds set must be valid, or
+/// else a panic will occur. Bounds are valid if and only if:
+///
+/// * The bounds represent a valid range into the input's haystack.
+/// * **or** the end bound is a valid ending bound for the haystack *and*
+/// the start bound is exactly one greater than the start bound.
+///
+/// In the latter case, [`Input::is_done`] will return true and indicates any
+/// search receiving such an input should immediately return with no match.
+///
+/// Note that while `Input` is used for reverse searches in this crate, the
+/// `Input::is_done` predicate assumes a forward search. Because unsigned
+/// offsets are used internally, there is no way to tell from only the offsets
+/// whether a reverse search is done or not.
+///
+/// # Regex engine support
+///
+/// Any regex engine accepting an `Input` must support at least the following
+/// things:
+///
+/// * Searching a `&[u8]` for matches.
+/// * Searching a substring of `&[u8]` for a match, such that any match
+/// reported must appear entirely within that substring.
+/// * For a forwards search, a match should never be reported when
+/// [`Input::is_done`] returns true. (For reverse searches, termination should
+/// be handled outside of `Input`.)
+///
+/// Supporting other aspects of an `Input` are optional, but regex engines
+/// should handle aspects they don't support gracefully. How this is done is
+/// generally up to the regex engine. This crate generally treats unsupported
+/// anchored modes as an error to report for example, but for simplicity, in
+/// the meta regex engine, trying to search with an invalid pattern ID just
+/// results in no match being reported.
+#[derive(Clone)]
+pub struct Input<'h> {
+    haystack: &'h [u8],
+    span: Span,
+    anchored: Anchored,
+    earliest: bool,
+}
+
+impl<'h> Input<'h> {
+    /// Create a new search configuration for the given haystack.
+    #[inline]
+    pub fn new<H: ?Sized + AsRef<[u8]>>(haystack: &'h H) -> Input<'h> {
+        Input {
+            haystack: haystack.as_ref(),
+            span: Span { start: 0, end: haystack.as_ref().len() },
+            anchored: Anchored::No,
+            earliest: false,
+        }
+    }
+
+    /// Set the span for this search.
+    ///
+    /// This routine does not panic if the span given is not a valid range for
+    /// this search's haystack. If this search is run with an invalid range,
+    /// then the most likely outcome is that the actual search execution will
+    /// panic.
+    ///
+    /// This routine is generic over how a span is provided. While
+    /// a [`Span`] may be given directly, one may also provide a
+    /// `std::ops::Range<usize>`. To provide anything supported by range
+    /// syntax, use the [`Input::range`] method.
+    ///
+    /// The default span is the entire haystack.
+    ///
+    /// Note that [`Input::range`] overrides this method and vice versa.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the given span does not correspond to valid bounds in
+    /// the haystack or the termination of a search.
+    ///
+    /// # Example
+    ///
+    /// This example shows how the span of the search can impact whether a
+    /// match is reported or not. This is particularly relevant for look-around
+    /// operators, which might take things outside of the span into account
+    /// when determining whether they match.
+    ///
+    /// ```
+    /// # if cfg!(miri) { return Ok(()); } // miri takes too long
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     Match, Input,
+    /// };
+    ///
+    /// // Look for 'at', but as a distinct word.
+    /// let re = PikeVM::new(r"\bat\b")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// // Our haystack contains 'at', but not as a distinct word.
+    /// let haystack = "batter";
+    ///
+    /// // A standard search finds nothing, as expected.
+    /// let input = Input::new(haystack);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// // But if we wanted to search starting at position '1', we might
+    /// // slice the haystack. If we do this, it's impossible for the \b
+    /// // anchors to take the surrounding context into account! And thus,
+    /// // a match is produced.
+    /// let input = Input::new(&haystack[1..3]);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..2)), caps.get_match());
+    ///
+    /// // But if we specify the span of the search instead of slicing the
+    /// // haystack, then the regex engine can "see" outside of the span
+    /// // and resolve the anchors correctly.
+    /// let input = Input::new(haystack).span(1..3);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This may seem a little ham-fisted, but this scenario tends to come up
+    /// if some other regex engine found the match span and now you need to
+    /// re-process that span to look for capturing groups. (e.g., Run a faster
+    /// DFA first, find a match, then run the PikeVM on just the match span to
+    /// resolve capturing groups.) In order to implement that sort of logic
+    /// correctly, you need to set the span on the search instead of slicing
+    /// the haystack directly.
+    ///
+    /// The other advantage of using this routine to specify the bounds of the
+    /// search is that the match offsets are still reported in terms of the
+    /// original haystack. For example, the second search in the example above
+    /// reported a match at position `0`, even though `at` starts at offset
+    /// `1` because we sliced the haystack.
+    #[inline]
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Input<'h> {
+        self.set_span(span);
+        self
+    }
+
+    /// Like `Input::span`, but accepts any range instead.
+    ///
+    /// This routine does not panic if the range given is not a valid range for
+    /// this search's haystack. If this search is run with an invalid range,
+    /// then the most likely outcome is that the actual search execution will
+    /// panic.
+    ///
+    /// The default range is the entire haystack.
+    ///
+    /// Note that [`Input::span`] overrides this method and vice versa.
+    ///
+    /// # Panics
+    ///
+    /// This routine will panic if the given range could not be converted
+    /// to a valid [`Range`]. For example, this would panic when given
+    /// `0..=usize::MAX` since it cannot be represented using a half-open
+    /// interval in terms of `usize`.
+    ///
+    /// This also panics if the given range does not correspond to valid bounds
+    /// in the haystack or the termination of a search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    ///
+    /// let input = Input::new("foobar").range(2..=4);
+    /// assert_eq!(2..5, input.get_range());
+    /// ```
+    #[inline]
+    pub fn range<R: RangeBounds<usize>>(mut self, range: R) -> Input<'h> {
+        self.set_range(range);
+        self
+    }
+
+    /// Sets the anchor mode of a search.
+    ///
+    /// When a search is anchored (so that's [`Anchored::Yes`] or
+    /// [`Anchored::Pattern`]), a match must begin at the start of a search.
+    /// When a search is not anchored (that's [`Anchored::No`]), regex engines
+    /// will behave as if the pattern started with a `(?:s-u.)*?`. This prefix
+    /// permits a match to appear anywhere.
+    ///
+    /// By default, the anchored mode is [`Anchored::No`].
+    ///
+    /// **WARNING:** this is subtly different than using a `^` at the start of
+    /// your regex. A `^` forces a regex to match exclusively at the start of
+    /// a haystack, regardless of where you begin your search. In contrast,
+    /// anchoring a search will allow your regex to match anywhere in your
+    /// haystack, but the match must start at the beginning of a search.
+    ///
+    /// For example, consider the haystack `aba` and the following searches:
+    ///
+    /// 1. The regex `^a` is compiled with `Anchored::No` and searches `aba`
+    ///    starting at position `2`. Since `^` requires the match to start at
+    ///    the beginning of the haystack and `2 > 0`, no match is found.
+    /// 2. The regex `a` is compiled with `Anchored::Yes` and searches `aba`
+    ///    starting at position `2`. This reports a match at `[2, 3]` since
+    ///    the match starts where the search started. Since there is no `^`,
+    ///    there is no requirement for the match to start at the beginning of
+    ///    the haystack.
+    /// 3. The regex `a` is compiled with `Anchored::Yes` and searches `aba`
+    ///    starting at position `1`. Since `b` corresponds to position `1` and
+    ///    since the search is anchored, it finds no match. While the regex
+    ///    matches at other positions, configuring the search to be anchored
+    ///    requires that it only report a match that begins at the same offset
+    ///    as the beginning of the search.
+    /// 4. The regex `a` is compiled with `Anchored::No` and searches `aba`
+    ///    startting at position `1`. Since the search is not anchored and
+    ///    the regex does not start with `^`, the search executes as if there
+    ///    is a `(?s:.)*?` prefix that permits it to match anywhere. Thus, it
+    ///    reports a match at `[2, 3]`.
+    ///
+    /// Note that the [`Anchored::Pattern`] mode is like `Anchored::Yes`,
+    /// except it only reports matches for a particular pattern.
+    ///
+    /// # Example
+    ///
+    /// This demonstrates the differences between an anchored search and
+    /// a pattern that begins with `^` (as described in the above warning
+    /// message).
+    ///
+    /// ```
+    /// use regex_automata::{
+    ///     nfa::thompson::pikevm::PikeVM,
+    ///     Anchored, Match, Input,
+    /// };
+    ///
+    /// let haystack = "aba";
+    ///
+    /// let re = PikeVM::new(r"^a")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let input = Input::new(haystack).span(2..3).anchored(Anchored::No);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// // No match is found because 2 is not the beginning of the haystack,
+    /// // which is what ^ requires.
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// let re = PikeVM::new(r"a")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let input = Input::new(haystack).span(2..3).anchored(Anchored::Yes);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// // An anchored search can still match anywhere in the haystack, it just
+    /// // must begin at the start of the search which is '2' in this case.
+    /// assert_eq!(Some(Match::must(0, 2..3)), caps.get_match());
+    ///
+    /// let re = PikeVM::new(r"a")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let input = Input::new(haystack).span(1..3).anchored(Anchored::Yes);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// // No match is found since we start searching at offset 1 which
+    /// // corresponds to 'b'. Since there is no '(?s:.)*?' prefix, no match
+    /// // is found.
+    /// assert_eq!(None, caps.get_match());
+    ///
+    /// let re = PikeVM::new(r"a")?;
+    /// let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
+    /// let input = Input::new(haystack).span(1..3).anchored(Anchored::No);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// // Since anchored=no, an implicit '(?s:.)*?' prefix was added to the
+    /// // pattern. Even though the search starts at 'b', the 'match anything'
+    /// // prefix allows the search to match 'a'.
+    /// let expected = Some(Match::must(0, 2..3));
+    /// assert_eq!(expected, caps.get_match());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn anchored(mut self, mode: Anchored) -> Input<'h> {
+        self.set_anchored(mode);
+        self
+    }
+
+    /// Whether to execute an "earliest" search or not.
+    ///
+    /// When running a non-overlapping search, an "earliest" search will return
+    /// the match location as early as possible. For example, given a pattern
+    /// of `foo[0-9]+` and a haystack of `foo12345`, a normal leftmost search
+    /// will return `foo12345` as a match. But an "earliest" search for regex
+    /// engines that support "earliest" semantics will return `foo1` as a
+    /// match, since as soon as the first digit following `foo` is seen, it is
+    /// known to have found a match.
+    ///
+    /// Note that "earliest" semantics generally depend on the regex engine.
+    /// Different regex engines may determine there is a match at different
+    /// points. So there is no guarantee that "earliest" matches will always
+    /// return the same offsets for all regex engines. The "earliest" notion
+    /// is really about when the particular regex engine determines there is
+    /// a match rather than a consistent semantic unto itself. This is often
+    /// useful for implementing "did a match occur or not" predicates, but
+    /// sometimes the offset is useful as well.
+    ///
+    /// This is disabled by default.
+    ///
+    /// # Example
+    ///
+    /// This example shows the difference between "earliest" searching and
+    /// normal searching.
+    ///
+    /// ```
+    /// use regex_automata::{nfa::thompson::pikevm::PikeVM, Match, Input};
+    ///
+    /// let re = PikeVM::new(r"foo[0-9]+")?;
+    /// let mut cache = re.create_cache();
+    /// let mut caps = re.create_captures();
+    ///
+    /// // A normal search implements greediness like you expect.
+    /// let input = Input::new("foo12345");
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..8)), caps.get_match());
+    ///
+    /// // When 'earliest' is enabled and the regex engine supports
+    /// // it, the search will bail once it knows a match has been
+    /// // found.
+    /// let input = Input::new("foo12345").earliest(true);
+    /// re.search(&mut cache, &input, &mut caps);
+    /// assert_eq!(Some(Match::must(0, 0..4)), caps.get_match());
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn earliest(mut self, yes: bool) -> Input<'h> {
+        self.set_earliest(yes);
+        self
+    }
+
+    /// Set the span for this search configuration.
+    ///
+    /// This is like the [`Input::span`] method, except this mutates the
+    /// span in place.
+    ///
+    /// This routine is generic over how a span is provided. While
+    /// a [`Span`] may be given directly, one may also provide a
+    /// `std::ops::Range<usize>`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the given span does not correspond to valid bounds in
+    /// the haystack or the termination of a search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    /// input.set_span(2..4);
+    /// assert_eq!(2..4, input.get_range());
+    /// ```
+    #[inline]
+    pub fn set_span<S: Into<Span>>(&mut self, span: S) {
+        let span = span.into();
+        assert!(
+            span.end <= self.haystack.len()
+                && span.start <= span.end.wrapping_add(1),
+            "invalid span {:?} for haystack of length {}",
+            span,
+            self.haystack.len(),
+        );
+        self.span = span;
+    }
+
+    /// Set the span for this search configuration given any range.
+    ///
+    /// This is like the [`Input::range`] method, except this mutates the
+    /// span in place.
+    ///
+    /// This routine does not panic if the range given is not a valid range for
+    /// this search's haystack. If this search is run with an invalid range,
+    /// then the most likely outcome is that the actual search execution will
+    /// panic.
+    ///
+    /// # Panics
+    ///
+    /// This routine will panic if the given range could not be converted
+    /// to a valid [`Range`]. For example, this would panic when given
+    /// `0..=usize::MAX` since it cannot be represented using a half-open
+    /// interval in terms of `usize`.
+    ///
+    /// This also panics if the given span does not correspond to valid bounds
+    /// in the haystack or the termination of a search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    /// input.set_range(2..=4);
+    /// assert_eq!(2..5, input.get_range());
+    /// ```
+    #[inline]
+    pub fn set_range<R: RangeBounds<usize>>(&mut self, range: R) {
+        use core::ops::Bound;
+
+        // It's a little weird to convert ranges into spans, and then spans
+        // back into ranges when we actually slice the haystack. Because
+        // of that process, we always represent everything as a half-open
+        // internal. Therefore, handling things like m..=n is a little awkward.
+        let start = match range.start_bound() {
+            Bound::Included(&i) => i,
+            // Can this case ever happen? Range syntax doesn't support it...
+            Bound::Excluded(&i) => i.checked_add(1).unwrap(),
+            Bound::Unbounded => 0,
+        };
+        let end = match range.end_bound() {
+            Bound::Included(&i) => i.checked_add(1).unwrap(),
+            Bound::Excluded(&i) => i,
+            Bound::Unbounded => self.haystack().len(),
+        };
+        self.set_span(Span { start, end });
+    }
+
+    /// Set the starting offset for the span for this search configuration.
+    ///
+    /// This is a convenience routine for only mutating the start of a span
+    /// without having to set the entire span.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the span resulting from the new start position does not
+    /// correspond to valid bounds in the haystack or the termination of a
+    /// search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    /// input.set_start(5);
+    /// assert_eq!(5..6, input.get_range());
+    /// ```
+    #[inline]
+    pub fn set_start(&mut self, start: usize) {
+        self.set_span(Span { start, ..self.get_span() });
+    }
+
+    /// Set the ending offset for the span for this search configuration.
+    ///
+    /// This is a convenience routine for only mutating the end of a span
+    /// without having to set the entire span.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the span resulting from the new end position does not
+    /// correspond to valid bounds in the haystack or the termination of a
+    /// search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    /// input.set_end(5);
+    /// assert_eq!(0..5, input.get_range());
+    /// ```
+    #[inline]
+    pub fn set_end(&mut self, end: usize) {
+        self.set_span(Span { end, ..self.get_span() });
+    }
+
+    /// Set the anchor mode of a search.
+    ///
+    /// This is like [`Input::anchored`], except it mutates the search
+    /// configuration in place.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Anchored, Input, PatternID};
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(Anchored::No, input.get_anchored());
+    ///
+    /// let pid = PatternID::must(5);
+    /// input.set_anchored(Anchored::Pattern(pid));
+    /// assert_eq!(Anchored::Pattern(pid), input.get_anchored());
+    /// ```
+    #[inline]
+    pub fn set_anchored(&mut self, mode: Anchored) {
+        self.anchored = mode;
+    }
+
+    /// Set whether the search should execute in "earliest" mode or not.
+    ///
+    /// This is like [`Input::earliest`], except it mutates the search
+    /// configuration in place.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert!(!input.get_earliest());
+    /// input.set_earliest(true);
+    /// assert!(input.get_earliest());
+    /// ```
+    #[inline]
+    pub fn set_earliest(&mut self, yes: bool) {
+        self.earliest = yes;
+    }
+
+    /// Return a borrow of the underlying haystack as a slice of bytes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(b"foobar", input.haystack());
+    /// ```
+    #[inline]
+    pub fn haystack(&self) -> &[u8] {
+        self.haystack
+    }
+
+    /// Return the start position of this search.
+    ///
+    /// This is a convenience routine for `search.get_span().start()`.
+    ///
+    /// When [`Input::is_done`] is `false`, this is guaranteed to return
+    /// an offset that is less than or equal to [`Input::end`]. Otherwise,
+    /// the offset is one greater than [`Input::end`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(0, input.start());
+    ///
+    /// let input = Input::new("foobar").span(2..4);
+    /// assert_eq!(2, input.start());
+    /// ```
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.get_span().start
+    }
+
+    /// Return the end position of this search.
+    ///
+    /// This is a convenience routine for `search.get_span().end()`.
+    ///
+    /// This is guaranteed to return an offset that is a valid exclusive end
+    /// bound for this input's haystack.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(6, input.end());
+    ///
+    /// let input = Input::new("foobar").span(2..4);
+    /// assert_eq!(4, input.end());
+    /// ```
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.get_span().end
+    }
+
+    /// Return the span for this search configuration.
+    ///
+    /// If one was not explicitly set, then the span corresponds to the entire
+    /// range of the haystack.
+    ///
+    /// When [`Input::is_done`] is `false`, the span returned is guaranteed
+    /// to correspond to valid bounds for this input's haystack.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Input, Span};
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(Span { start: 0, end: 6 }, input.get_span());
+    /// ```
+    #[inline]
+    pub fn get_span(&self) -> Span {
+        self.span
+    }
+
+    /// Return the span as a range for this search configuration.
+    ///
+    /// If one was not explicitly set, then the span corresponds to the entire
+    /// range of the haystack.
+    ///
+    /// When [`Input::is_done`] is `false`, the range returned is guaranteed
+    /// to correspond to valid bounds for this input's haystack.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert_eq!(0..6, input.get_range());
+    /// ```
+    #[inline]
+    pub fn get_range(&self) -> Range<usize> {
+        self.get_span().range()
+    }
+
+    /// Return the anchored mode for this search configuration.
+    ///
+    /// If no anchored mode was set, then it defaults to [`Anchored::No`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Anchored, Input, PatternID};
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert_eq!(Anchored::No, input.get_anchored());
+    ///
+    /// let pid = PatternID::must(5);
+    /// input.set_anchored(Anchored::Pattern(pid));
+    /// assert_eq!(Anchored::Pattern(pid), input.get_anchored());
+    /// ```
+    #[inline]
+    pub fn get_anchored(&self) -> Anchored {
+        self.anchored
+    }
+
+    /// Return whether this search should execute in "earliest" mode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("foobar");
+    /// assert!(!input.get_earliest());
+    /// ```
+    #[inline]
+    pub fn get_earliest(&self) -> bool {
+        self.earliest
+    }
+
+    /// Return true if and only if this search can never return any other
+    /// matches.
+    ///
+    /// This occurs when the start position of this search is greater than the
+    /// end position of the search.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let mut input = Input::new("foobar");
+    /// assert!(!input.is_done());
+    /// input.set_start(6);
+    /// assert!(!input.is_done());
+    /// input.set_start(7);
+    /// assert!(input.is_done());
+    /// ```
+    #[inline]
+    pub fn is_done(&self) -> bool {
+        self.get_span().start > self.get_span().end
+    }
+
+    /// Returns true if and only if the given offset in this search's haystack
+    /// falls on a valid UTF-8 encoded codepoint boundary.
+    ///
+    /// If the haystack is not valid UTF-8, then the behavior of this routine
+    /// is unspecified.
+    ///
+    /// # Example
+    ///
+    /// This shows where codepoint bounardies do and don't exist in valid
+    /// UTF-8.
+    ///
+    /// ```
+    /// use regex_automata::Input;
+    ///
+    /// let input = Input::new("☃");
+    /// assert!(input.is_char_boundary(0));
+    /// assert!(!input.is_char_boundary(1));
+    /// assert!(!input.is_char_boundary(2));
+    /// assert!(input.is_char_boundary(3));
+    /// assert!(!input.is_char_boundary(4));
+    /// ```
+    #[inline]
+    pub fn is_char_boundary(&self, offset: usize) -> bool {
+        utf8::is_boundary(self.haystack(), offset)
+    }
+}
+
+impl<'h> core::fmt::Debug for Input<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use crate::util::escape::DebugHaystack;
+
+        f.debug_struct("Input")
+            .field("haystack", &DebugHaystack(self.haystack()))
+            .field("span", &self.span)
+            .field("anchored", &self.anchored)
+            .field("earliest", &self.earliest)
+            .finish()
+    }
+}
+
+impl<'h, H: ?Sized + AsRef<[u8]>> From<&'h H> for Input<'h> {
+    fn from(haystack: &'h H) -> Input<'h> {
+        Input::new(haystack)
+    }
+}
+
+/// A representation of a span reported by a regex engine.
+///
+/// A span corresponds to the starting and ending _byte offsets_ of a
+/// contiguous region of bytes. The starting offset is inclusive while the
+/// ending offset is exclusive. That is, a span is a half-open interval.
+///
+/// A span is used to report the offsets of a match, but it is also used to
+/// convey which region of a haystack should be searched via routines like
+/// [`Input::span`].
+///
+/// This is basically equivalent to a `std::ops::Range<usize>`, except this
+/// type implements `Copy` which makes it more ergonomic to use in the context
+/// of this crate. Like a range, this implements `Index` for `[u8]` and `str`,
+/// and `IndexMut` for `[u8]`. For convenience, this also impls `From<Range>`,
+/// which means things like `Span::from(5..10)` work.
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct Span {
+    /// The start offset of the span, inclusive.
+    pub start: usize,
+    /// The end offset of the span, exclusive.
+    pub end: usize,
+}
+
+impl Span {
+    /// Returns this span as a range.
+    #[inline]
+    pub fn range(&self) -> Range<usize> {
+        Range::from(*self)
+    }
+
+    /// Returns true when this span is empty. That is, when `start >= end`.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.start >= self.end
+    }
+
+    /// Returns the length of this span.
+    ///
+    /// This returns `0` in precisely the cases that `is_empty` returns `true`.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.end.saturating_sub(self.start)
+    }
+
+    /// Returns true when the given offset is contained within this span.
+    ///
+    /// Note that an empty span contains no offsets and will always return
+    /// false.
+    #[inline]
+    pub fn contains(&self, offset: usize) -> bool {
+        !self.is_empty() && self.start <= offset && offset <= self.end
+    }
+
+    /// Returns a new span with `offset` added to this span's `start` and `end`
+    /// values.
+    #[inline]
+    pub fn offset(&self, offset: usize) -> Span {
+        Span { start: self.start + offset, end: self.end + offset }
+    }
+}
+
+impl core::fmt::Debug for Span {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}..{}", self.start, self.end)
+    }
+}
+
+impl core::ops::Index<Span> for [u8] {
+    type Output = [u8];
+
+    #[inline]
+    fn index(&self, index: Span) -> &[u8] {
+        &self[index.range()]
+    }
+}
+
+impl core::ops::IndexMut<Span> for [u8] {
+    #[inline]
+    fn index_mut(&mut self, index: Span) -> &mut [u8] {
+        &mut self[index.range()]
+    }
+}
+
+impl core::ops::Index<Span> for str {
+    type Output = str;
+
+    #[inline]
+    fn index(&self, index: Span) -> &str {
+        &self[index.range()]
+    }
+}
+
+impl From<Range<usize>> for Span {
+    #[inline]
+    fn from(range: Range<usize>) -> Span {
+        Span { start: range.start, end: range.end }
+    }
+}
+
+impl From<Span> for Range<usize> {
+    #[inline]
+    fn from(span: Span) -> Range<usize> {
+        Range { start: span.start, end: span.end }
+    }
+}
+
+impl PartialEq<Range<usize>> for Span {
+    #[inline]
+    fn eq(&self, range: &Range<usize>) -> bool {
+        self.start == range.start && self.end == range.end
+    }
+}
+
+impl PartialEq<Span> for Range<usize> {
+    #[inline]
+    fn eq(&self, span: &Span) -> bool {
+        self.start == span.start && self.end == span.end
+    }
+}
+
+/// A representation of "half" of a match reported by a DFA.
+///
+/// This is called a "half" match because it only includes the end location (or
+/// start location for a reverse search) of a match. This corresponds to the
+/// information that a single DFA scan can report. Getting the other half of
+/// the match requires a second scan with a reversed DFA.
+///
+/// A half match also includes the pattern that matched. The pattern is
+/// identified by an ID, which corresponds to its position (starting from `0`)
+/// relative to other patterns used to construct the corresponding DFA. If only
+/// a single pattern is provided to the DFA, then all matches are guaranteed to
+/// have a pattern ID of `0`.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct HalfMatch {
+    /// The pattern ID.
+    pattern: PatternID,
+    /// The offset of the match.
+    ///
+    /// For forward searches, the offset is exclusive. For reverse searches,
+    /// the offset is inclusive.
+    offset: usize,
+}
+
+impl HalfMatch {
+    /// Create a new half match from a pattern ID and a byte offset.
+    #[inline]
+    pub fn new(pattern: PatternID, offset: usize) -> HalfMatch {
+        HalfMatch { pattern, offset }
+    }
+
+    /// Create a new half match from a pattern ID and a byte offset.
+    ///
+    /// This is like [`HalfMatch::new`], but accepts a `usize` instead of a
+    /// [`PatternID`]. This panics if the given `usize` is not representable
+    /// as a `PatternID`.
+    #[inline]
+    pub fn must(pattern: usize, offset: usize) -> HalfMatch {
+        HalfMatch::new(PatternID::new(pattern).unwrap(), offset)
+    }
+
+    /// Returns the ID of the pattern that matched.
+    ///
+    /// The ID of a pattern is derived from the position in which it was
+    /// originally inserted into the corresponding DFA. The first pattern has
+    /// identifier `0`, and each subsequent pattern is `1`, `2` and so on.
+    #[inline]
+    pub fn pattern(&self) -> PatternID {
+        self.pattern
+    }
+
+    /// The position of the match.
+    ///
+    /// If this match was produced by a forward search, then the offset is
+    /// exclusive. If this match was produced by a reverse search, then the
+    /// offset is inclusive.
+    #[inline]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+}
+
+/// A representation of a match reported by a regex engine.
+///
+/// A match has two essential pieces of information: the [`PatternID`] that
+/// matches, and the [`Span`] of the match in a haystack.
+///
+/// The pattern is identified by an ID, which corresponds to its position
+/// (starting from `0`) relative to other patterns used to construct the
+/// corresponding regex engine. If only a single pattern is provided, then all
+/// matches are guaranteed to have a pattern ID of `0`.
+///
+/// Every match reported by a regex engine guarantees that its span has its
+/// start offset as less than or equal to its end offset.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct Match {
+    /// The pattern ID.
+    pattern: PatternID,
+    /// The underlying match span.
+    span: Span,
+}
+
+impl Match {
+    /// Create a new match from a pattern ID and a span.
+    ///
+    /// This constructor is generic over how a span is provided. While
+    /// a [`Span`] may be given directly, one may also provide a
+    /// `std::ops::Range<usize>`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if `end < start`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to create a match for the first pattern in a regex
+    /// object using convenient range syntax.
+    ///
+    /// ```
+    /// use regex_automata::{Match, PatternID};
+    ///
+    /// let m = Match::new(PatternID::ZERO, 5..10);
+    /// assert_eq!(0, m.pattern().as_usize());
+    /// assert_eq!(5, m.start());
+    /// assert_eq!(10, m.end());
+    /// ```
+    #[inline]
+    pub fn new<S: Into<Span>>(pattern: PatternID, span: S) -> Match {
+        let span: Span = span.into();
+        assert!(span.start <= span.end, "invalid match span");
+        Match { pattern, span }
+    }
+
+    /// Create a new match from a pattern ID and a byte offset span.
+    ///
+    /// This constructor is generic over how a span is provided. While
+    /// a [`Span`] may be given directly, one may also provide a
+    /// `std::ops::Range<usize>`.
+    ///
+    /// This is like [`Match::new`], but accepts a `usize` instead of a
+    /// [`PatternID`]. This panics if the given `usize` is not representable
+    /// as a `PatternID`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if `end < start` or if `pattern > PatternID::MAX`.
+    ///
+    /// # Example
+    ///
+    /// This shows how to create a match for the third pattern in a regex
+    /// object using convenient range syntax.
+    ///
+    /// ```
+    /// use regex_automata::Match;
+    ///
+    /// let m = Match::must(3, 5..10);
+    /// assert_eq!(3, m.pattern().as_usize());
+    /// assert_eq!(5, m.start());
+    /// assert_eq!(10, m.end());
+    /// ```
+    #[inline]
+    pub fn must<S: Into<Span>>(pattern: usize, span: S) -> Match {
+        Match::new(PatternID::must(pattern), span)
+    }
+
+    /// Returns the ID of the pattern that matched.
+    ///
+    /// The ID of a pattern is derived from the position in which it was
+    /// originally inserted into the corresponding regex engine. The first
+    /// pattern has identifier `0`, and each subsequent pattern is `1`, `2` and
+    /// so on.
+    #[inline]
+    pub fn pattern(&self) -> PatternID {
+        self.pattern
+    }
+
+    /// The starting position of the match.
+    ///
+    /// This is a convenience routine for `Match::span().start`.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.span().start
+    }
+
+    /// The ending position of the match.
+    ///
+    /// This is a convenience routine for `Match::span().end`.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.span().end
+    }
+
+    /// Returns the match span as a range.
+    ///
+    /// This is a convenience routine for `Match::span().range()`.
+    #[inline]
+    pub fn range(&self) -> core::ops::Range<usize> {
+        self.span().range()
+    }
+
+    /// Returns the span for this match.
+    #[inline]
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    /// Returns true when the span in this match is empty.
+    ///
+    /// An empty match can only be returned when the regex itself can match
+    /// the empty string.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.span().is_empty()
+    }
+
+    /// Returns the length of this match.
+    ///
+    /// This returns `0` in precisely the cases that `is_empty` returns `true`.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.span().len()
+    }
+}
+
+/// A set of `PatternID`s.
+///
+/// A set of pattern identifiers is useful for recording which patterns have
+/// matched a particular haystack. A pattern set _only_ includes pattern
+/// identifiers. It does not include offset information.
+///
+/// # Example
+///
+/// This shows basic usage of a set.
+///
+/// ```
+/// use regex_automata::{PatternID, PatternSet};
+///
+/// let pid1 = PatternID::must(5);
+/// let pid2 = PatternID::must(8);
+/// // Create a new empty set.
+/// let mut set = PatternSet::new(10);
+/// // Insert pattern IDs.
+/// set.insert(pid1);
+/// set.insert(pid2);
+/// // Test membership.
+/// assert!(set.contains(pid1));
+/// assert!(set.contains(pid2));
+/// // Get all members.
+/// assert_eq!(
+///     vec![5, 8],
+///     set.iter().map(|p| p.as_usize()).collect::<Vec<usize>>(),
+/// );
+/// // Clear the set.
+/// set.clear();
+/// // Test that it is indeed empty.
+/// assert!(set.is_empty());
+/// ```
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PatternSet {
+    /// The number of patterns set to 'true' in this set.
+    len: usize,
+    /// A map from PatternID to boolean of whether a pattern matches or not.
+    ///
+    /// This should probably be a bitset, but it's probably unlikely to matter
+    /// much in practice.
+    ///
+    /// The main downside of this representation (and similarly for a bitset)
+    /// is that iteration scales with the capacity of the set instead of
+    /// the length of the set. This doesn't seem likely to be a problem in
+    /// practice.
+    ///
+    /// Another alternative is to just use a 'SparseSet' for this. It does use
+    /// more memory (quite a bit more), but that seems fine I think compared
+    /// to the memory being used by the regex engine. The real hiccup with
+    /// it is that it yields pattern IDs in the order they were inserted.
+    /// Which is actually kind of nice, but at the time of writing, pattern
+    /// IDs are yielded in ascending order in the regex crate RegexSet API.
+    /// If we did change to 'SparseSet', we could provide an additional
+    /// 'iter_match_order' iterator, but keep the ascending order one for
+    /// compatibility.
+    which: alloc::boxed::Box<[bool]>,
+}
+
+#[cfg(feature = "alloc")]
+impl PatternSet {
+    /// Create a new set of pattern identifiers with the given capacity.
+    ///
+    /// The given capacity typically corresponds to (at least) the number of
+    /// patterns in a compiled regex object.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the given capacity exceeds [`PatternID::LIMIT`]. This is
+    /// impossible if you use the `pattern_len()` method as defined on any of
+    /// the regex engines in this crate. Namely, a regex will fail to build by
+    /// returning an error if the number of patterns given to it exceeds the
+    /// limit. Therefore, the number of patterns in a valid regex is alwasys
+    /// a correct capacity to provide here.
+    pub fn new(capacity: usize) -> PatternSet {
+        assert!(
+            capacity <= PatternID::LIMIT,
+            "pattern set capacity exceeds limit of {}",
+            PatternID::LIMIT,
+        );
+        PatternSet {
+            len: 0,
+            which: alloc::vec![false; capacity].into_boxed_slice(),
+        }
+    }
+
+    /// Clear this set such that it contains no pattern IDs.
+    pub fn clear(&mut self) {
+        self.len = 0;
+        for matched in self.which.iter_mut() {
+            *matched = false;
+        }
+    }
+
+    /// Return true if and only if the given pattern identifier is in this set.
+    pub fn contains(&self, pid: PatternID) -> bool {
+        pid.as_usize() < self.capacity() && self.which[pid]
+    }
+
+    /// Insert the given pattern identifier into this set and return `true` if
+    /// the given pattern ID was not previously in this set.
+    ///
+    /// If the pattern identifier is already in this set, then this is a no-op.
+    ///
+    /// Use [`PatternSet::try_insert`] for a fallible version of this routine.
+    ///
+    /// # Panics
+    ///
+    /// This panics if this pattern set has insufficient capacity to
+    /// store the given pattern ID.
+    pub fn insert(&mut self, pid: PatternID) -> bool {
+        self.try_insert(pid)
+            .expect("PatternSet should have sufficient capacity")
+    }
+
+    /// Insert the given pattern identifier into this set and return `true` if
+    /// the given pattern ID was not previously in this set.
+    ///
+    /// If the pattern identifier is already in this set, then this is a no-op.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if this pattern set has insufficient capacity to
+    /// store the given pattern ID.
+    pub fn try_insert(
+        &mut self,
+        pid: PatternID,
+    ) -> Result<bool, PatternSetInsertError> {
+        if pid.as_usize() >= self.capacity() {
+            return Err(PatternSetInsertError {
+                attempted: pid,
+                capacity: self.capacity(),
+            });
+        }
+        if self.which[pid] {
+            return Ok(false);
+        }
+        self.len += 1;
+        self.which[pid] = true;
+        Ok(true)
+    }
+
+    /*
+    // This is currently commented out because it is unused and it is unclear
+    // whether it's useful or not. What's the harm in having it? When, if
+    // we ever wanted to change our representation to a 'SparseSet', then
+    // supporting this method would be a bit tricky. So in order to keep some
+    // API evolution flexibility, we leave it out for now.
+
+    /// Remove the given pattern identifier from this set.
+    ///
+    /// If the pattern identifier was not previously in this set, then this
+    /// does not change the set and returns `false`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if `pid` exceeds the capacity of this set.
+    pub fn remove(&mut self, pid: PatternID) -> bool {
+        if !self.which[pid] {
+            return false;
+        }
+        self.len -= 1;
+        self.which[pid] = false;
+        true
+    }
+    */
+
+    /// Return true if and only if this set has no pattern identifiers in it.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return true if and only if this set has the maximum number of pattern
+    /// identifiers in the set. This occurs precisely when `PatternSet::len()
+    /// == PatternSet::capacity()`.
+    ///
+    /// This particular property is useful to test because it may allow one to
+    /// stop a search earlier than you might otherwise. Namely, if a search is
+    /// only reporting which patterns match a haystack and if you know all of
+    /// the patterns match at a given point, then there's no new information
+    /// that can be learned by continuing the search. (Because a pattern set
+    /// does not keep track of offset information.)
+    pub fn is_full(&self) -> bool {
+        self.len() == self.capacity()
+    }
+
+    /// Returns the total number of pattern identifiers in this set.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns the total number of pattern identifiers that may be stored
+    /// in this set.
+    ///
+    /// This is guaranteed to be less than or equal to [`PatternID::LIMIT`].
+    ///
+    /// Typically, the capacity of a pattern set matches the number of patterns
+    /// in a regex object with which you are searching.
+    pub fn capacity(&self) -> usize {
+        self.which.len()
+    }
+
+    /// Returns an iterator over all pattern identifiers in this set.
+    ///
+    /// The iterator yields pattern identifiers in ascending order, starting
+    /// at zero.
+    pub fn iter(&self) -> PatternSetIter<'_> {
+        PatternSetIter { it: self.which.iter().enumerate() }
+    }
+}
+
+/// An error that occurs when a `PatternID` failed to insert into a
+/// `PatternSet`.
+///
+/// An insert fails when the given `PatternID` exceeds the configured capacity
+/// of the `PatternSet`.
+///
+/// This error is created by the [`PatternSet::try_insert`] routine.
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug)]
+pub struct PatternSetInsertError {
+    attempted: PatternID,
+    capacity: usize,
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for PatternSetInsertError {}
+
+#[cfg(feature = "alloc")]
+impl core::fmt::Display for PatternSetInsertError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(
+            f,
+            "failed to insert pattern ID {} into pattern set \
+             with insufficiet capacity of {}",
+            self.attempted.as_usize(),
+            self.capacity,
+        )
+    }
+}
+
+/// An iterator over all pattern identifiers in a [`PatternSet`].
+///
+/// The lifetime parameter `'a` refers to the lifetime of the pattern set being
+/// iterated over.
+///
+/// This iterator is created by the [`PatternSet::iter`] method.
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug)]
+pub struct PatternSetIter<'a> {
+    it: core::iter::Enumerate<core::slice::Iter<'a, bool>>,
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> Iterator for PatternSetIter<'a> {
+    type Item = PatternID;
+
+    fn next(&mut self) -> Option<PatternID> {
+        while let Some((index, &yes)) = self.it.next() {
+            if yes {
+                // Only valid 'PatternID' values can be inserted into the set
+                // and construction of the set panics if the capacity would
+                // permit storing invalid pattern IDs. Thus, 'yes' is only true
+                // precisely when 'index' corresponds to a valid 'PatternID'.
+                return Some(PatternID::new_unchecked(index));
+            }
+        }
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> DoubleEndedIterator for PatternSetIter<'a> {
+    fn next_back(&mut self) -> Option<PatternID> {
+        while let Some((index, &yes)) = self.it.next_back() {
+            if yes {
+                // Only valid 'PatternID' values can be inserted into the set
+                // and construction of the set panics if the capacity would
+                // permit storing invalid pattern IDs. Thus, 'yes' is only true
+                // precisely when 'index' corresponds to a valid 'PatternID'.
+                return Some(PatternID::new_unchecked(index));
+            }
+        }
+        None
+    }
+}
+
+/// The type of anchored search to perform.
+///
+/// This is *almost* a boolean option. That is, you can either do an unanchored
+/// search for any pattern in a regex, or you can do an anchored search for any
+/// pattern in a regex.
+///
+/// A third option exists that, assuming the regex engine supports it, permits
+/// you to do an anchored search for a specific pattern.
+///
+/// Note that there is no way to run an unanchored search for a specific
+/// pattern. If you need that, you'll need to build separate regexes for each
+/// pattern.
+///
+/// # Errors
+///
+/// If a regex engine does not support the anchored mode selected, then the
+/// regex engine will return an error. While any non-trivial regex engine
+/// should support at least one of the available anchored modes, there is no
+/// singular mode that is guaranteed to be universally supported. Some regex
+/// engines might only support unanchored searches (DFAs compiled without
+/// anchored starting states) and some regex engines might only support
+/// anchored searches (like the one-pass DFA).
+///
+/// The specific error returned is a [`MatchError`] with a
+/// [`MatchErrorKind::UnsupportedAnchored`] kind. The kind includes the
+/// `Anchored` value given that is unsupported.
+///
+/// Note that regex engines should report "no match" if, for example, an
+/// `Anchored::Pattern` is provided with an invalid pattern ID _but_ where
+/// anchored searches for a specific pattern are supported. This is smooths out
+/// behavior such that it's possible to guarantee that an error never occurs
+/// based on how the regex engine is configured. All regex engines in this
+/// crate report "no match" when searching for an invalid pattern ID, but where
+/// searching for a valid pattern ID is otherwise supported.
+///
+/// # Example
+///
+/// This example shows how to use the various `Anchored` modes to run a
+/// search. We use the [`PikeVM`](crate::nfa::thompson::pikevm::PikeVM)
+/// because it supports all modes unconditionally. Some regex engines, like
+/// the [`onepass::DFA`](crate::dfa::onepass::DFA) cannot support unanchored
+/// searches.
+///
+/// ```
+/// # if cfg!(miri) { return Ok(()); } // miri takes too long
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     Anchored, Input, Match, PatternID,
+/// };
+///
+/// let re = PikeVM::new_many(&[
+///     r"Mrs. \w+",
+///     r"Miss \w+",
+///     r"Mr. \w+",
+///     r"Ms. \w+",
+/// ])?;
+/// let mut cache = re.create_cache();
+/// let hay = "Hello Mr. Springsteen!";
+///
+/// // The default is to do an unanchored search.
+/// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, hay));
+/// // Explicitly ask for an unanchored search. Same as above.
+/// let input = Input::new(hay).anchored(Anchored::No);
+/// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, hay));
+///
+/// // Now try an anchored search. Since the match doesn't start at the
+/// // beginning of the haystack, no match is found!
+/// let input = Input::new(hay).anchored(Anchored::Yes);
+/// assert_eq!(None, re.find(&mut cache, input));
+///
+/// // We can try an anchored search again, but move the location of where
+/// // we start the search. Note that the offsets reported are still in
+/// // terms of the overall haystack and not relative to where we started
+/// // the search.
+/// let input = Input::new(hay).anchored(Anchored::Yes).range(6..);
+/// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, input));
+///
+/// // Now try an anchored search for a specific pattern. We specifically
+/// // choose a pattern that we know doesn't match to prove that the search
+/// // only looks for the pattern we provide.
+/// let input = Input::new(hay)
+///     .anchored(Anchored::Pattern(PatternID::must(1)))
+///     .range(6..);
+/// assert_eq!(None, re.find(&mut cache, input));
+///
+/// // But if we switch it to the pattern that we know matches, then we find
+/// // the match.
+/// let input = Input::new(hay)
+///     .anchored(Anchored::Pattern(PatternID::must(2)))
+///     .range(6..);
+/// assert_eq!(Some(Match::must(2, 6..21)), re.find(&mut cache, input));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Anchored {
+    /// Run an unanchored search. This means a match may occur anywhere at or
+    /// after the start position of the search.
+    ///
+    /// This search can return a match for any pattern in the regex.
+    No,
+    /// Run an anchored search. This means that a match must begin at the
+    /// start position of the search.
+    ///
+    /// This search can return a match for any pattern in the regex.
+    Yes,
+    /// Run an anchored search for a specific pattern. This means that a match
+    /// must be for the given pattern and must begin at the start position of
+    /// the search.
+    Pattern(PatternID),
+}
+
+impl Anchored {
+    /// Returns true if and only if this anchor mode corresponds to any kind of
+    /// anchored search.
+    ///
+    /// # Example
+    ///
+    /// This examples shows that both `Anchored::Yes` and `Anchored::Pattern`
+    /// are considered anchored searches.
+    ///
+    /// ```
+    /// use regex_automata::{Anchored, PatternID};
+    ///
+    /// assert!(!Anchored::No.is_anchored());
+    /// assert!(Anchored::Yes.is_anchored());
+    /// assert!(Anchored::Pattern(PatternID::ZERO).is_anchored());
+    /// ```
+    pub fn is_anchored(&self) -> bool {
+        matches!(*self, Anchored::Yes | Anchored::Pattern(_))
+    }
+
+    /// Returns the pattern ID associated with this configuration if it is an
+    /// anchored search for a specific pattern. Otherwise `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::{Anchored, PatternID};
+    ///
+    /// assert_eq!(None, Anchored::No.pattern());
+    /// assert_eq!(None, Anchored::Yes.pattern());
+    ///
+    /// let pid = PatternID::must(5);
+    /// assert_eq!(Some(pid), Anchored::Pattern(pid).pattern());
+    /// ```
+    pub fn pattern(&self) -> Option<PatternID> {
+        match *self {
+            Anchored::Pattern(pid) => Some(pid),
+            _ => None,
+        }
+    }
+}
+
+/// The kind of match semantics to use for a regex pattern.
+///
+/// The default match kind is `LeftmostFirst`, and this corresponds to the
+/// match semantics used by most backtracking engines, such as Perl.
+///
+/// # Leftmost first or "preference order" match semantics
+///
+/// Leftmost-first semantics determine which match to report when there are
+/// multiple paths through a regex that match at the same position. The tie is
+/// essentially broken by how a backtracker would behave. For example, consider
+/// running the regex `foofoofoo|foofoo|foo` on the haystack `foofoo`. In this
+/// case, both the `foofoo` and `foo` branches match at position `0`. So should
+/// the end of the match be `3` or `6`?
+///
+/// A backtracker will conceptually work by trying `foofoofoo` and failing.
+/// Then it will try `foofoo`, find the match and stop there. Thus, the
+/// leftmost-first match position is `6`. This is called "leftmost-first" or
+/// "preference order" because the order of the branches as written in the
+/// regex pattern is what determines how to break the tie.
+///
+/// (Note that leftmost-longest match semantics, which break ties by always
+/// taking the longest matching string, are not currently supported by this
+/// crate. These match semantics tend to be found in POSIX regex engines.)
+///
+/// This example shows how leftmost-first semantics work, and how it even
+/// applies to multi-pattern regexes:
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     Match,
+/// };
+///
+/// let re = PikeVM::new_many(&[
+///     r"foofoofoo",
+///     r"foofoo",
+///     r"foo",
+/// ])?;
+/// let mut cache = re.create_cache();
+/// let got: Vec<Match> = re.find_iter(&mut cache, "foofoo").collect();
+/// let expected = vec![Match::must(1, 0..6)];
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # All matches
+///
+/// The `All` match semantics report any and all matches, and generally will
+/// attempt to match as much as possible. It doesn't respect any sort of match
+/// priority at all, so things like non-greedy matching don't work in this
+/// mode.
+///
+/// The fact that non-greedy matching doesn't work generally makes most forms
+/// of unanchored non-overlapping searches have unintuitive behavior. Namely,
+/// unanchored searches behave as if there is a `(?s-u:.)*?` prefix at the
+/// beginning of the pattern, which is specifically non-greedy. Since it will
+/// be treated as greedy in `All` match semantics, this generally means that
+/// it will first attempt to consume all of the haystack and is likely to wind
+/// up skipping matches.
+///
+/// Generally speaking, `All` should only be used in two circumstances:
+///
+/// * When running an anchored search and there is a desire to match as much as
+/// possible. For example, when building a reverse regex matcher to find the
+/// start of a match after finding the end. In this case, the reverse search
+/// is anchored to the end of the match found by the forward search.
+/// * When running overlapping searches. Since `All` encodes all possible
+/// matches, this is generally what you want for an overlapping search. If you
+/// try to use leftmost-first in an overlapping search, it is likely to produce
+/// counter-intuitive results since leftmost-first specifically excludes some
+/// matches from its underlying finite state machine.
+///
+/// This example demonstrates the counter-intuitive behavior of `All` semantics
+/// when using a standard leftmost unanchored search:
+///
+/// ```
+/// use regex_automata::{
+///     nfa::thompson::pikevm::PikeVM,
+///     Match, MatchKind,
+/// };
+///
+/// let re = PikeVM::builder()
+///     .configure(PikeVM::config().match_kind(MatchKind::All))
+///     .build("foo")?;
+/// let hay = "first foo second foo wat";
+/// let mut cache = re.create_cache();
+/// let got: Vec<Match> = re.find_iter(&mut cache, hay).collect();
+/// // Notice that it completely skips the first 'foo'!
+/// let expected = vec![Match::must(0, 17..20)];
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// This second example shows how `All` semantics are useful for an overlapping
+/// search. Note that we use lower level lazy DFA APIs here since the NFA
+/// engines only currently support a very limited form of overlapping search.
+///
+/// ```
+/// use regex_automata::{
+///     hybrid::dfa::{DFA, OverlappingState},
+///     HalfMatch, Input, MatchKind,
+/// };
+///
+/// let re = DFA::builder()
+///     // If we didn't set 'All' semantics here, then the regex would only
+///     // match 'foo' at offset 3 and nothing else. Why? Because the state
+///     // machine implements preference order and knows that the 'foofoo' and
+///     // 'foofoofoo' branches can never match since 'foo' will always match
+///     // when they match and take priority.
+///     .configure(DFA::config().match_kind(MatchKind::All))
+///     .build(r"foo|foofoo|foofoofoo")?;
+/// let mut cache = re.create_cache();
+/// let mut state = OverlappingState::start();
+/// let input = Input::new("foofoofoo");
+/// let mut got = vec![];
+/// loop {
+///     re.try_search_overlapping_fwd(&mut cache, &input, &mut state)?;
+///     let m = match state.get_match() {
+///         None => break,
+///         Some(m) => m,
+///     };
+///     got.push(m);
+/// }
+/// let expected = vec![
+///     HalfMatch::must(0, 3),
+///     HalfMatch::must(0, 6),
+///     HalfMatch::must(0, 9),
+/// ];
+/// assert_eq!(expected, got);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[non_exhaustive]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum MatchKind {
+    /// Report all possible matches.
+    All,
+    /// Report only the leftmost matches. When multiple leftmost matches exist,
+    /// report the match corresponding to the part of the regex that appears
+    /// first in the syntax.
+    LeftmostFirst,
+    // There is prior art in RE2 that shows that we should be able to add
+    // LeftmostLongest too. The tricky part of it is supporting ungreedy
+    // repetitions. Instead of treating all NFA states as having equivalent
+    // priority (as in 'All') or treating all NFA states as having distinct
+    // priority based on order (as in 'LeftmostFirst'), we instead group NFA
+    // states into sets, and treat members of each set as having equivalent
+    // priority, but having greater priority than all following members
+    // of different sets.
+    //
+    // However, it's not clear whether it's really worth adding this. After
+    // all, leftmost-longest can be emulated when using literals by using
+    // leftmost-first and sorting the literals by length in descending order.
+    // However, this won't work for arbitrary regexes. e.g., `\w|\w\w` will
+    // always match `a` in `ab` when using leftmost-first, but leftmost-longest
+    // would match `ab`.
+}
+
+impl MatchKind {
+    #[cfg(feature = "alloc")]
+    pub(crate) fn continue_past_first_match(&self) -> bool {
+        *self == MatchKind::All
+    }
+}
+
+impl Default for MatchKind {
+    fn default() -> MatchKind {
+        MatchKind::LeftmostFirst
+    }
+}
+
+/// An error indicating that a search stopped before reporting whether a
+/// match exists or not.
+///
+/// To be very clear, this error type implies that one cannot assume that no
+/// matches occur, since the search stopped before completing. That is, if
+/// you're looking for information about where a search determined that no
+/// match can occur, then this error type does *not* give you that. (Indeed, at
+/// the time of writing, if you need such a thing, you have to write your own
+/// search routine.)
+///
+/// Normally, when one searches for something, the response is either an
+/// affirmative "it was found at this location" or a negative "not found at
+/// all." However, in some cases, a regex engine can be configured to stop its
+/// search before concluding whether a match exists or not. When this happens,
+/// it may be important for the caller to know why the regex engine gave up and
+/// where in the input it gave up at. This error type exposes the 'why' and the
+/// 'where.'
+///
+/// For example, the DFAs provided by this library generally cannot correctly
+/// implement Unicode word boundaries. Instead, they provide an option to
+/// eagerly support them on ASCII text (since Unicode word boundaries are
+/// equivalent to ASCII word boundaries when searching ASCII text), but will
+/// "give up" if a non-ASCII byte is seen. In such cases, one is usually
+/// required to either report the failure to the caller (unergonomic) or
+/// otherwise fall back to some other regex engine (ergonomic, but potentially
+/// costly).
+///
+/// More generally, some regex engines offer the ability for callers to specify
+/// certain bytes that will trigger the regex engine to automatically quit if
+/// they are seen.
+///
+/// Still yet, there may be other reasons for a failed match. For example,
+/// the hybrid DFA provided by this crate can be configured to give up if it
+/// believes that it is not efficient. This in turn permits callers to choose a
+/// different regex engine.
+///
+/// (Note that DFAs are configured by default to never quit or give up in this
+/// fashion. For example, by default, a DFA will fail to build if the regex
+/// pattern contains a Unicode word boundary. One needs to opt into the "quit"
+/// behavior via options, like
+/// [`hybrid::dfa::Config::unicode_word_boundary`](crate::hybrid::dfa::Config::unicode_word_boundary).)
+///
+/// There are a couple other ways a search
+/// can fail. For example, when using the
+/// [`BoundedBacktracker`](crate::nfa::thompson::backtrack::BoundedBacktracker)
+/// with a haystack that is too long, or trying to run an unanchored search
+/// with a [one-pass DFA](crate::dfa::onepass).
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MatchError(
+    #[cfg(feature = "alloc")] alloc::boxed::Box<MatchErrorKind>,
+    #[cfg(not(feature = "alloc"))] MatchErrorKind,
+);
+
+impl MatchError {
+    /// Create a new error value with the given kind.
+    ///
+    /// This is a more verbose version of the kind-specific constructors,
+    /// e.g., `MatchError::quit`.
+    pub fn new(kind: MatchErrorKind) -> MatchError {
+        #[cfg(feature = "alloc")]
+        {
+            MatchError(alloc::boxed::Box::new(kind))
+        }
+        #[cfg(not(feature = "alloc"))]
+        {
+            MatchError(kind)
+        }
+    }
+
+    /// Returns a reference to the underlying error kind.
+    pub fn kind(&self) -> &MatchErrorKind {
+        &self.0
+    }
+
+    /// Create a new "quit" error. The given `byte` corresponds to the value
+    /// that tripped a search's quit condition, and `offset` corresponds to the
+    /// location in the haystack at which the search quit.
+    ///
+    /// This is the same as calling `MatchError::new` with a
+    /// [`MatchErrorKind::Quit`] kind.
+    pub fn quit(byte: u8, offset: usize) -> MatchError {
+        MatchError::new(MatchErrorKind::Quit { byte, offset })
+    }
+
+    /// Create a new "gave up" error. The given `offset` corresponds to the
+    /// location in the haystack at which the search gave up.
+    ///
+    /// This is the same as calling `MatchError::new` with a
+    /// [`MatchErrorKind::GaveUp`] kind.
+    pub fn gave_up(offset: usize) -> MatchError {
+        MatchError::new(MatchErrorKind::GaveUp { offset })
+    }
+
+    /// Create a new "haystack too long" error. The given `len` corresponds to
+    /// the length of the haystack that was problematic.
+    ///
+    /// This is the same as calling `MatchError::new` with a
+    /// [`MatchErrorKind::HaystackTooLong`] kind.
+    pub fn haystack_too_long(len: usize) -> MatchError {
+        MatchError::new(MatchErrorKind::HaystackTooLong { len })
+    }
+
+    /// Create a new "unsupported anchored" error. This occurs when the caller
+    /// requests a search with an anchor mode that is not supported by the
+    /// regex engine.
+    ///
+    /// This is the same as calling `MatchError::new` with a
+    /// [`MatchErrorKind::UnsupportedAnchored`] kind.
+    pub fn unsupported_anchored(mode: Anchored) -> MatchError {
+        MatchError::new(MatchErrorKind::UnsupportedAnchored { mode })
+    }
+}
+
+/// The underlying kind of a [`MatchError`].
+///
+/// This is a **non-exhaustive** enum. That means new variants may be added in
+/// a semver-compatible release.
+#[non_exhaustive]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum MatchErrorKind {
+    /// The search saw a "quit" byte at which it was instructed to stop
+    /// searching.
+    Quit {
+        /// The "quit" byte that was observed that caused the search to stop.
+        byte: u8,
+        /// The offset at which the quit byte was observed.
+        offset: usize,
+    },
+    /// The search, based on heuristics, determined that it would be better
+    /// to stop, typically to provide the caller an opportunity to use an
+    /// alternative regex engine.
+    ///
+    /// Currently, the only way for this to occur is via the lazy DFA and
+    /// only when it is configured to do so (it will not return this error by
+    /// default).
+    GaveUp {
+        /// The offset at which the search stopped. This corresponds to the
+        /// position immediately following the last byte scanned.
+        offset: usize,
+    },
+    /// This error occurs if the haystack given to the regex engine was too
+    /// long to be searched. This occurs, for example, with regex engines
+    /// like the bounded backtracker that have a configurable fixed amount of
+    /// capacity that is tied to the length of the haystack. Anything beyond
+    /// that configured limit will result in an error at search time.
+    HaystackTooLong {
+        /// The length of the haystack that exceeded the limit.
+        len: usize,
+    },
+    /// An error indicating that a particular type of anchored search was
+    /// requested, but that the regex engine does not support it.
+    ///
+    /// Note that this error should not be returned by a regex engine simply
+    /// because the pattern ID is invalid (i.e., equal to or exceeds the number
+    /// of patterns in the regex). In that case, the regex engine should report
+    /// a non-match.
+    UnsupportedAnchored {
+        /// The anchored mode given that is unsupported.
+        mode: Anchored,
+    },
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MatchError {}
+
+impl core::fmt::Display for MatchError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        match *self.kind() {
+            MatchErrorKind::Quit { byte, offset } => write!(
+                f,
+                "quit search after observing byte {:?} at offset {}",
+                DebugByte(byte),
+                offset,
+            ),
+            MatchErrorKind::GaveUp { offset } => {
+                write!(f, "gave up searching at offset {}", offset)
+            }
+            MatchErrorKind::HaystackTooLong { len } => {
+                write!(f, "haystack of length {} is too long", len)
+            }
+            MatchErrorKind::UnsupportedAnchored { mode: Anchored::Yes } => {
+                write!(f, "anchored searches are not supported or enabled")
+            }
+            MatchErrorKind::UnsupportedAnchored { mode: Anchored::No } => {
+                write!(f, "unanchored searches are not supported or enabled")
+            }
+            MatchErrorKind::UnsupportedAnchored {
+                mode: Anchored::Pattern(pid),
+            } => {
+                write!(
+                    f,
+                    "anchored searches for a specific pattern ({}) are \
+                     not supported or enabled",
+                    pid.as_usize(),
+                )
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // We test that our 'MatchError' type is the size we expect. This isn't an
+    // API guarantee, but if the size increases, we really want to make sure we
+    // decide to do that intentionally. So this should be a speed bump. And in
+    // general, we should not increase the size without a very good reason.
+    //
+    // Why? Because low level search APIs return Result<.., MatchError>. When
+    // MatchError gets bigger, so to does the Result type.
+    //
+    // Now, when 'alloc' is enabled, we do box the error, which de-emphasizes
+    // the importance of keeping a small error type. But without 'alloc', we
+    // still want things to be small.
+    #[test]
+    fn match_error_size() {
+        let expected_size = if cfg!(feature = "alloc") {
+            core::mem::size_of::<usize>()
+        } else {
+            2 * core::mem::size_of::<usize>()
+        };
+        assert_eq!(expected_size, core::mem::size_of::<MatchError>());
+    }
+
+    // Same as above, but for the underlying match error kind.
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn match_error_kind_size() {
+        let expected_size = 2 * core::mem::size_of::<usize>();
+        assert_eq!(expected_size, core::mem::size_of::<MatchErrorKind>());
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    #[test]
+    fn match_error_kind_size() {
+        let expected_size = 3 * core::mem::size_of::<usize>();
+        assert_eq!(expected_size, core::mem::size_of::<MatchErrorKind>());
+    }
+}
diff --git a/regex-automata/src/util/sparse_set.rs b/regex-automata/src/util/sparse_set.rs
new file mode 100644
index 0000000000..cbaa0b6f4f
--- /dev/null
+++ b/regex-automata/src/util/sparse_set.rs
@@ -0,0 +1,239 @@
+/*!
+This module defines a sparse set data structure. Its most interesting
+properties are:
+
+* They preserve insertion order.
+* Set membership testing is done in constant time.
+* Set insertion is done in constant time.
+* Clearing the set is done in constant time.
+
+The cost for doing this is that the capacity of the set needs to be known up
+front, and the elements in the set are limited to state identifiers.
+
+These sets are principally used when traversing an NFA state graph. This
+happens at search time, for example, in the PikeVM. It also happens during DFA
+determinization.
+*/
+
+use alloc::{vec, vec::Vec};
+
+use crate::util::primitives::StateID;
+
+/// A pairse of sparse sets.
+///
+/// This is useful when one needs to compute NFA epsilon closures from a
+/// previous set of states derived from an epsilon closure. One set can be the
+/// starting states where as the other set can be the destination states after
+/// following the transitions for a particular byte of input.
+///
+/// There is no significance to 'set1' or 'set2'. They are both sparse sets of
+/// the same size.
+///
+/// The members of this struct are exposed so that callers may borrow 'set1'
+/// and 'set2' individually without being force to borrow both at the same
+/// time.
+#[derive(Clone, Debug)]
+pub(crate) struct SparseSets {
+    pub(crate) set1: SparseSet,
+    pub(crate) set2: SparseSet,
+}
+
+impl SparseSets {
+    /// Create a new pair of sparse sets where each set has the given capacity.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    pub(crate) fn new(capacity: usize) -> SparseSets {
+        SparseSets {
+            set1: SparseSet::new(capacity),
+            set2: SparseSet::new(capacity),
+        }
+    }
+
+    /// Resizes these sparse sets to have the new capacity given.
+    ///
+    /// The sets are automatically cleared.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    #[inline]
+    pub(crate) fn resize(&mut self, new_capacity: usize) {
+        self.set1.resize(new_capacity);
+        self.set2.resize(new_capacity);
+    }
+
+    /// Clear both sparse sets.
+    pub(crate) fn clear(&mut self) {
+        self.set1.clear();
+        self.set2.clear();
+    }
+
+    /// Swap set1 with set2.
+    pub(crate) fn swap(&mut self) {
+        core::mem::swap(&mut self.set1, &mut self.set2);
+    }
+
+    /// Returns the memory usage, in bytes, used by this pair of sparse sets.
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.set1.memory_usage() + self.set2.memory_usage()
+    }
+}
+
+/// A sparse set used for representing ordered NFA states.
+///
+/// This supports constant time addition and membership testing. Clearing an
+/// entire set can also be done in constant time. Iteration yields elements
+/// in the order in which they were inserted.
+///
+/// The data structure is based on: https://research.swtch.com/sparse
+/// Note though that we don't actually use uninitialized memory. We generally
+/// reuse sparse sets, so the initial allocation cost is bareable. However, its
+/// other properties listed above are extremely useful.
+#[derive(Clone)]
+pub(crate) struct SparseSet {
+    /// The number of elements currently in this set.
+    len: usize,
+    /// Dense contains the ids in the order in which they were inserted.
+    dense: Vec<StateID>,
+    /// Sparse maps ids to their location in dense.
+    ///
+    /// A state ID is in the set if and only if
+    /// sparse[id] < len && id == dense[sparse[id]].
+    ///
+    /// Note that these are indices into 'dense'. It's a little weird to use
+    /// StateID here, but we know our length can never exceed the bounds of
+    /// StateID (enforced by 'resize') and StateID will be at most 4 bytes
+    /// where as a usize is likely double that in most cases.
+    sparse: Vec<StateID>,
+}
+
+impl SparseSet {
+    /// Create a new sparse set with the given capacity.
+    ///
+    /// Sparse sets have a fixed size and they cannot grow. Attempting to
+    /// insert more distinct elements than the total capacity of the set will
+    /// result in a panic.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    #[inline]
+    pub(crate) fn new(capacity: usize) -> SparseSet {
+        let mut set = SparseSet { len: 0, dense: vec![], sparse: vec![] };
+        set.resize(capacity);
+        set
+    }
+
+    /// Resizes this sparse set to have the new capacity given.
+    ///
+    /// This set is automatically cleared.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    #[inline]
+    pub(crate) fn resize(&mut self, new_capacity: usize) {
+        assert!(
+            new_capacity <= StateID::LIMIT,
+            "sparse set capacity cannot excced {:?}",
+            StateID::LIMIT
+        );
+        self.clear();
+        self.dense.resize(new_capacity, StateID::ZERO);
+        self.sparse.resize(new_capacity, StateID::ZERO);
+    }
+
+    /// Returns the capacity of this set.
+    ///
+    /// The capacity represents a fixed limit on the number of distinct
+    /// elements that are allowed in this set. The capacity cannot be changed.
+    #[inline]
+    pub(crate) fn capacity(&self) -> usize {
+        self.dense.len()
+    }
+
+    /// Returns the number of elements in this set.
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns true if and only if this set is empty.
+    #[inline]
+    pub(crate) fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Insert the state ID value into this set and return true if the given
+    /// state ID was not previously in this set.
+    ///
+    /// This operation is idempotent. If the given value is already in this
+    /// set, then this is a no-op.
+    ///
+    /// If more than `capacity` ids are inserted, then this panics.
+    ///
+    /// This is marked as inline(always) since the compiler won't inline it
+    /// otherwise, and it's a fairly hot piece of code in DFA determinization.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn insert(&mut self, id: StateID) -> bool {
+        if self.contains(id) {
+            return false;
+        }
+
+        let i = self.len();
+        assert!(
+            i < self.capacity(),
+            "{:?} exceeds capacity of {:?} when inserting {:?}",
+            i,
+            self.capacity(),
+            id,
+        );
+        // OK since i < self.capacity() and self.capacity() is guaranteed to
+        // be <= StateID::LIMIT.
+        let index = StateID::new_unchecked(i);
+        self.dense[index] = id;
+        self.sparse[id] = index;
+        self.len += 1;
+        true
+    }
+
+    /// Returns true if and only if this set contains the given value.
+    #[inline]
+    pub(crate) fn contains(&self, id: StateID) -> bool {
+        let index = self.sparse[id];
+        index.as_usize() < self.len() && self.dense[index] == id
+    }
+
+    /// Clear this set such that it has no members.
+    #[inline]
+    pub(crate) fn clear(&mut self) {
+        self.len = 0;
+    }
+
+    #[inline]
+    pub(crate) fn iter(&self) -> SparseSetIter<'_> {
+        SparseSetIter(self.dense[..self.len()].iter())
+    }
+
+    /// Returns the heap memory usage, in bytes, used by this sparse set.
+    #[inline]
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.dense.len() * StateID::SIZE + self.sparse.len() * StateID::SIZE
+    }
+}
+
+impl core::fmt::Debug for SparseSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let elements: Vec<StateID> = self.iter().collect();
+        f.debug_tuple("SparseSet").field(&elements).finish()
+    }
+}
+
+/// An iterator over all elements in a sparse set.
+///
+/// The lifetime `'a` refers to the lifetime of the set being iterated over.
+#[derive(Debug)]
+pub(crate) struct SparseSetIter<'a>(core::slice::Iter<'a, StateID>);
+
+impl<'a> Iterator for SparseSetIter<'a> {
+    type Item = StateID;
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn next(&mut self) -> Option<StateID> {
+        self.0.next().map(|&id| id)
+    }
+}
diff --git a/regex-automata/src/util/start.rs b/regex-automata/src/util/start.rs
new file mode 100644
index 0000000000..809c5e985a
--- /dev/null
+++ b/regex-automata/src/util/start.rs
@@ -0,0 +1,303 @@
+/*!
+Provides some helpers for dealing with start state configurations in DFAs.
+
+[`Start`] represents the possible starting configurations, while
+[`StartByteMap`] represents a way to retrieve the `Start` configuration for a
+given position in a haystack.
+*/
+
+use crate::util::{
+    look::LookMatcher,
+    search::Input,
+    wire::{self, DeserializeError, SerializeError},
+};
+
+/// A map from every possible byte value to its corresponding starting
+/// configuration.
+///
+/// This map is used in order to lookup the start configuration for a particular
+/// position in a haystack. This start configuration is then used in
+/// combination with things like the anchored mode and pattern ID to fully
+/// determine the start state.
+///
+/// Generally speaking, this map is only used for fully compiled DFAs and lazy
+/// DFAs. For NFAs (including the one-pass DFA), the start state is generally
+/// selected by virtue of traversing the NFA state graph. DFAs do the same
+/// thing, but at build time and not search time. (Well, technically the lazy
+/// DFA does it at search time, but it does enough work to cache the full
+/// result of the epsilon closure that the NFA engines tend to need to do.)
+#[derive(Clone)]
+pub(crate) struct StartByteMap {
+    map: [Start; 256],
+}
+
+impl StartByteMap {
+    /// Create a new map from byte values to their corresponding starting
+    /// configurations. The map is determined, in part, by how look-around
+    /// assertions are matched via the matcher given.
+    pub(crate) fn new(lookm: &LookMatcher) -> StartByteMap {
+        let mut map = [Start::NonWordByte; 256];
+        map[usize::from(b'\n')] = Start::LineLF;
+        map[usize::from(b'\r')] = Start::LineCR;
+        map[usize::from(b'_')] = Start::WordByte;
+
+        let mut byte = b'0';
+        while byte <= b'9' {
+            map[usize::from(byte)] = Start::WordByte;
+            byte += 1;
+        }
+        byte = b'A';
+        while byte <= b'Z' {
+            map[usize::from(byte)] = Start::WordByte;
+            byte += 1;
+        }
+        byte = b'a';
+        while byte <= b'z' {
+            map[usize::from(byte)] = Start::WordByte;
+            byte += 1;
+        }
+
+        let lineterm = lookm.get_line_terminator();
+        // If our line terminator is normal, then it is already handled by
+        // the LineLF and LineCR configurations. But if it's weird, then we
+        // overwrite whatever was there before for that terminator with a
+        // special configuration. The trick here is that if the terminator
+        // is, say, a word byte like `a`, then callers seeing this start
+        // configuration need to account for that and build their DFA state as
+        // if it *also* came from a word byte.
+        if lineterm != b'\r' && lineterm != b'\n' {
+            map[usize::from(lineterm)] = Start::CustomLineTerminator;
+        }
+        StartByteMap { map }
+    }
+
+    /// Return the forward starting configuration for the given `input`.
+    pub(crate) fn fwd(&self, input: &Input) -> Start {
+        match input
+            .start()
+            .checked_sub(1)
+            .and_then(|i| input.haystack().get(i))
+        {
+            None => Start::Text,
+            Some(&byte) => self.get(byte),
+        }
+    }
+
+    /// Return the reverse starting configuration for the given `input`.
+    pub(crate) fn rev(&self, input: &Input) -> Start {
+        match input.haystack().get(input.end()) {
+            None => Start::Text,
+            Some(&byte) => self.get(byte),
+        }
+    }
+
+    fn get(&self, byte: u8) -> Start {
+        self.map[usize::from(byte)]
+    }
+
+    /// Deserializes a byte class map from the given slice. If the slice is of
+    /// insufficient length or otherwise contains an impossible mapping, then
+    /// an error is returned. Upon success, the number of bytes read along with
+    /// the map are returned. The number of bytes read is always a multiple of
+    /// 8.
+    pub(crate) fn from_bytes(
+        slice: &[u8],
+    ) -> Result<(StartByteMap, usize), DeserializeError> {
+        wire::check_slice_len(slice, 256, "start byte map")?;
+        let mut map = [Start::NonWordByte; 256];
+        for (i, &repr) in slice[..256].iter().enumerate() {
+            map[i] = match Start::from_usize(usize::from(repr)) {
+                Some(start) => start,
+                None => {
+                    return Err(DeserializeError::generic(
+                        "found invalid starting configuration",
+                    ))
+                }
+            };
+        }
+        Ok((StartByteMap { map }, 256))
+    }
+
+    /// Writes this map to the given byte buffer. if the given buffer is too
+    /// small, then an error is returned. Upon success, the total number of
+    /// bytes written is returned. The number of bytes written is guaranteed to
+    /// be a multiple of 8.
+    pub(crate) fn write_to(
+        &self,
+        dst: &mut [u8],
+    ) -> Result<usize, SerializeError> {
+        let nwrite = self.write_to_len();
+        if dst.len() < nwrite {
+            return Err(SerializeError::buffer_too_small("start byte map"));
+        }
+        for (i, &start) in self.map.iter().enumerate() {
+            dst[i] = start.as_u8();
+        }
+        Ok(nwrite)
+    }
+
+    /// Returns the total number of bytes written by `write_to`.
+    pub(crate) fn write_to_len(&self) -> usize {
+        256
+    }
+}
+
+impl core::fmt::Debug for StartByteMap {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use crate::util::escape::DebugByte;
+
+        write!(f, "StartByteMap{{")?;
+        for byte in 0..=255 {
+            if byte > 0 {
+                write!(f, ", ")?;
+            }
+            let start = self.map[usize::from(byte)];
+            write!(f, "{:?} => {:?}", DebugByte(byte), start)?;
+        }
+        write!(f, "}}")?;
+        Ok(())
+    }
+}
+
+/// Represents the six possible starting configurations of a DFA search.
+///
+/// The starting configuration is determined by inspecting the the beginning
+/// of the haystack (up to 1 byte). Ultimately, this along with a pattern ID
+/// (if specified) and the type of search (anchored or not) is what selects the
+/// start state to use in a DFA.
+///
+/// As one example, if a DFA only supports unanchored searches and does not
+/// support anchored searches for each pattern, then it will have at most 6
+/// distinct start states. (Some start states may be reused if determinization
+/// can determine that they will be equivalent.) If the DFA supports both
+/// anchored and unanchored searches, then it will have a maximum of 12
+/// distinct start states. Finally, if the DFA also supports anchored searches
+/// for each pattern, then it can have up to `12 + (N * 6)` start states, where
+/// `N` is the number of patterns.
+///
+/// Handling each of these starting configurations in the context of DFA
+/// determinization can be *quite* tricky and subtle. But the code is small
+/// and can be found at `crate::util::determinize::set_lookbehind_from_start`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Start {
+    /// This occurs when the starting position is not any of the ones below.
+    NonWordByte = 0,
+    /// This occurs when the byte immediately preceding the start of the search
+    /// is an ASCII word byte.
+    WordByte = 1,
+    /// This occurs when the starting position of the search corresponds to the
+    /// beginning of the haystack.
+    Text = 2,
+    /// This occurs when the byte immediately preceding the start of the search
+    /// is a line terminator. Specifically, `\n`.
+    LineLF = 3,
+    /// This occurs when the byte immediately preceding the start of the search
+    /// is a line terminator. Specifically, `\r`.
+    LineCR = 4,
+    /// This occurs when a custom line terminator has been set via a
+    /// `LookMatcher`, and when that line terminator is neither a `\r` or a
+    /// `\n`.
+    ///
+    /// If the custom line terminator is a word byte, then this start
+    /// configuration is still selected. DFAs that implement word boundary
+    /// assertions will likely need to check whether the custom line terminator
+    /// is a word byte, in which case, it should behave as if the byte
+    /// satisfies `\b` in addition to multi-line anchors.
+    CustomLineTerminator = 5,
+}
+
+impl Start {
+    /// Return the starting state corresponding to the given integer. If no
+    /// starting state exists for the given integer, then None is returned.
+    pub(crate) fn from_usize(n: usize) -> Option<Start> {
+        match n {
+            0 => Some(Start::NonWordByte),
+            1 => Some(Start::WordByte),
+            2 => Some(Start::Text),
+            3 => Some(Start::LineLF),
+            4 => Some(Start::LineCR),
+            5 => Some(Start::CustomLineTerminator),
+            _ => None,
+        }
+    }
+
+    /// Returns the total number of starting state configurations.
+    pub(crate) fn len() -> usize {
+        6
+    }
+
+    /// Return this starting configuration as `u8` integer. It is guaranteed to
+    /// be less than `Start::len()`.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn as_u8(&self) -> u8 {
+        // AFAIK, 'as' is the only way to zero-cost convert an int enum to an
+        // actual int.
+        *self as u8
+    }
+
+    /// Return this starting configuration as a `usize` integer. It is
+    /// guaranteed to be less than `Start::len()`.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn as_usize(&self) -> usize {
+        usize::from(self.as_u8())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn start_fwd_done_range() {
+        let smap = StartByteMap::new(&LookMatcher::default());
+        assert_eq!(Start::Text, smap.fwd(&Input::new("").range(1..0)));
+    }
+
+    #[test]
+    fn start_rev_done_range() {
+        let smap = StartByteMap::new(&LookMatcher::default());
+        assert_eq!(Start::Text, smap.rev(&Input::new("").range(1..0)));
+    }
+
+    #[test]
+    fn start_fwd() {
+        let f = |haystack, start, end| {
+            let smap = StartByteMap::new(&LookMatcher::default());
+            let input = &Input::new(haystack).range(start..end);
+            smap.fwd(input)
+        };
+
+        assert_eq!(Start::Text, f("", 0, 0));
+        assert_eq!(Start::Text, f("abc", 0, 3));
+        assert_eq!(Start::Text, f("\nabc", 0, 3));
+
+        assert_eq!(Start::LineLF, f("\nabc", 1, 3));
+
+        assert_eq!(Start::LineCR, f("\rabc", 1, 3));
+
+        assert_eq!(Start::WordByte, f("abc", 1, 3));
+
+        assert_eq!(Start::NonWordByte, f(" abc", 1, 3));
+    }
+
+    #[test]
+    fn start_rev() {
+        let f = |haystack, start, end| {
+            let smap = StartByteMap::new(&LookMatcher::default());
+            let input = &Input::new(haystack).range(start..end);
+            smap.rev(input)
+        };
+
+        assert_eq!(Start::Text, f("", 0, 0));
+        assert_eq!(Start::Text, f("abc", 0, 3));
+        assert_eq!(Start::Text, f("abc\n", 0, 4));
+
+        assert_eq!(Start::LineLF, f("abc\nz", 0, 3));
+
+        assert_eq!(Start::LineCR, f("abc\rz", 0, 3));
+
+        assert_eq!(Start::WordByte, f("abc", 0, 2));
+
+        assert_eq!(Start::NonWordByte, f("abc ", 0, 3));
+    }
+}
diff --git a/regex-automata/src/util/syntax.rs b/regex-automata/src/util/syntax.rs
new file mode 100644
index 0000000000..9260ea20cb
--- /dev/null
+++ b/regex-automata/src/util/syntax.rs
@@ -0,0 +1,482 @@
+/*!
+Utilities for dealing with the syntax of a regular expression.
+
+This module currently only exposes a [`Config`] type that
+itself represents a wrapper around the configuration for a
+[`regex-syntax::ParserBuilder`](regex_syntax::ParserBuilder). The purpose of
+this wrapper is to make configuring syntax options very similar to how other
+configuration is done throughout this crate. Namely, instead of duplicating
+syntax options across every builder (of which there are many), we instead
+create small config objects like this one that can be passed around and
+composed.
+*/
+
+use alloc::{vec, vec::Vec};
+
+use regex_syntax::{
+    ast,
+    hir::{self, Hir},
+    Error, ParserBuilder,
+};
+
+/// A convenience routine for parsing a pattern into an HIR value with the
+/// default configuration.
+///
+/// # Example
+///
+/// This shows how to parse a pattern into an HIR value:
+///
+/// ```
+/// use regex_automata::util::syntax;
+///
+/// let hir = syntax::parse(r"([a-z]+)|([0-9]+)")?;
+/// assert_eq!(Some(1), hir.properties().static_explicit_captures_len());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+pub fn parse(pattern: &str) -> Result<Hir, Error> {
+    parse_with(pattern, &Config::default())
+}
+
+/// A convenience routine for parsing many patterns into HIR value with the
+/// default configuration.
+///
+/// # Example
+///
+/// This shows how to parse many patterns into an corresponding HIR values:
+///
+/// ```
+/// use {
+///     regex_automata::util::syntax,
+///     regex_syntax::hir::Properties,
+/// };
+///
+/// let hirs = syntax::parse_many(&[
+///     r"([a-z]+)|([0-9]+)",
+///     r"foo(A-Z]+)bar",
+/// ])?;
+/// let props = Properties::union(hirs.iter().map(|h| h.properties()));
+/// assert_eq!(Some(1), props.static_explicit_captures_len());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+pub fn parse_many<P: AsRef<str>>(patterns: &[P]) -> Result<Vec<Hir>, Error> {
+    parse_many_with(patterns, &Config::default())
+}
+
+/// A convenience routine for parsing a pattern into an HIR value using a
+/// `Config`.
+///
+/// # Example
+///
+/// This shows how to parse a pattern into an HIR value with a non-default
+/// configuration:
+///
+/// ```
+/// use regex_automata::util::syntax;
+///
+/// let hir = syntax::parse_with(
+///     r"^[a-z]+$",
+///     &syntax::Config::new().multi_line(true).crlf(true),
+/// )?;
+/// assert!(hir.properties().look_set().contains_anchor_crlf());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+pub fn parse_with(pattern: &str, config: &Config) -> Result<Hir, Error> {
+    let mut builder = ParserBuilder::new();
+    config.apply(&mut builder);
+    builder.build().parse(pattern)
+}
+
+/// A convenience routine for parsing many patterns into HIR values using a
+/// `Config`.
+///
+/// # Example
+///
+/// This shows how to parse many patterns into an corresponding HIR values
+/// with a non-default configuration:
+///
+/// ```
+/// use {
+///     regex_automata::util::syntax,
+///     regex_syntax::hir::Properties,
+/// };
+///
+/// let patterns = &[
+///     r"([a-z]+)|([0-9]+)",
+///     r"\W",
+///     r"foo(A-Z]+)bar",
+/// ];
+/// let config = syntax::Config::new().unicode(false).utf8(false);
+/// let hirs = syntax::parse_many_with(patterns, &config)?;
+/// let props = Properties::union(hirs.iter().map(|h| h.properties()));
+/// assert!(!props.is_utf8());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+pub fn parse_many_with<P: AsRef<str>>(
+    patterns: &[P],
+    config: &Config,
+) -> Result<Vec<Hir>, Error> {
+    let mut builder = ParserBuilder::new();
+    config.apply(&mut builder);
+    let mut hirs = vec![];
+    for p in patterns.iter() {
+        hirs.push(builder.build().parse(p.as_ref())?);
+    }
+    Ok(hirs)
+}
+
+/// A common set of configuration options that apply to the syntax of a regex.
+///
+/// This represents a group of configuration options that specifically apply
+/// to how the concrete syntax of a regular expression is interpreted. In
+/// particular, they are generally forwarded to the
+/// [`ParserBuilder`](https://docs.rs/regex-syntax/*/regex_syntax/struct.ParserBuilder.html)
+/// in the
+/// [`regex-syntax`](https://docs.rs/regex-syntax)
+/// crate when building a regex from its concrete syntax directly.
+///
+/// These options are defined as a group since they apply to every regex engine
+/// in this crate. Instead of re-defining them on every engine's builder, they
+/// are instead provided here as one cohesive unit.
+#[derive(Clone, Copy, Debug)]
+pub struct Config {
+    case_insensitive: bool,
+    multi_line: bool,
+    dot_matches_new_line: bool,
+    crlf: bool,
+    line_terminator: u8,
+    swap_greed: bool,
+    ignore_whitespace: bool,
+    unicode: bool,
+    utf8: bool,
+    nest_limit: u32,
+    octal: bool,
+}
+
+impl Config {
+    /// Return a new default syntax configuration.
+    pub fn new() -> Config {
+        // These defaults match the ones used in regex-syntax.
+        Config {
+            case_insensitive: false,
+            multi_line: false,
+            dot_matches_new_line: false,
+            crlf: false,
+            line_terminator: b'\n',
+            swap_greed: false,
+            ignore_whitespace: false,
+            unicode: true,
+            utf8: true,
+            nest_limit: 250,
+            octal: false,
+        }
+    }
+
+    /// Enable or disable the case insensitive flag by default.
+    ///
+    /// When Unicode mode is enabled, case insensitivity is Unicode-aware.
+    /// Specifically, it will apply the "simple" case folding rules as
+    /// specified by Unicode.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `i` flag.
+    pub fn case_insensitive(mut self, yes: bool) -> Config {
+        self.case_insensitive = yes;
+        self
+    }
+
+    /// Enable or disable the multi-line matching flag by default.
+    ///
+    /// When this is enabled, the `^` and `$` look-around assertions will
+    /// match immediately after and immediately before a new line character,
+    /// respectively. Note that the `\A` and `\z` look-around assertions are
+    /// unaffected by this setting and always correspond to matching at the
+    /// beginning and end of the input.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `m` flag.
+    pub fn multi_line(mut self, yes: bool) -> Config {
+        self.multi_line = yes;
+        self
+    }
+
+    /// Enable or disable the "dot matches any character" flag by default.
+    ///
+    /// When this is enabled, `.` will match any character. When it's disabled,
+    /// then `.` will match any character except for a new line character.
+    ///
+    /// Note that `.` is impacted by whether the "unicode" setting is enabled
+    /// or not. When Unicode is enabled (the defualt), `.` will match any UTF-8
+    /// encoding of any Unicode scalar value (sans a new line, depending on
+    /// whether this "dot matches new line" option is enabled). When Unicode
+    /// mode is disabled, `.` will match any byte instead. Because of this,
+    /// when Unicode mode is disabled, `.` can only be used when the "allow
+    /// invalid UTF-8" option is enabled, since `.` could otherwise match
+    /// invalid UTF-8.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `s` flag.
+    pub fn dot_matches_new_line(mut self, yes: bool) -> Config {
+        self.dot_matches_new_line = yes;
+        self
+    }
+
+    /// Enable or disable the "CRLF mode" flag by default.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `R` flag.
+    ///
+    /// When CRLF mode is enabled, the following happens:
+    ///
+    /// * Unless `dot_matches_new_line` is enabled, `.` will match any character
+    /// except for `\r` and `\n`.
+    /// * When `multi_line` mode is enabled, `^` and `$` will treat `\r\n`,
+    /// `\r` and `\n` as line terminators. And in particular, neither will
+    /// match between a `\r` and a `\n`.
+    pub fn crlf(mut self, yes: bool) -> Config {
+        self.crlf = yes;
+        self
+    }
+
+    /// Sets the line terminator for use with `(?u-s:.)` and `(?-us:.)`.
+    ///
+    /// Namely, instead of `.` (by default) matching everything except for `\n`,
+    /// this will cause `.` to match everything except for the byte given.
+    ///
+    /// If `.` is used in a context where Unicode mode is enabled and this byte
+    /// isn't ASCII, then an error will be returned. When Unicode mode is
+    /// disabled, then any byte is permitted, but will return an error if UTF-8
+    /// mode is enabled and it is a non-ASCII byte.
+    ///
+    /// In short, any ASCII value for a line terminator is always okay. But a
+    /// non-ASCII byte might result in an error depending on whether Unicode
+    /// mode or UTF-8 mode are enabled.
+    ///
+    /// Note that if `R` mode is enabled then it always takes precedence and
+    /// the line terminator will be treated as `\r` and `\n` simultaneously.
+    ///
+    /// Note also that this *doesn't* impact the look-around assertions
+    /// `(?m:^)` and `(?m:$)`. That's usually controlled by additional
+    /// configuration in the regex engine itself.
+    pub fn line_terminator(mut self, byte: u8) -> Config {
+        self.line_terminator = byte;
+        self
+    }
+
+    /// Enable or disable the "swap greed" flag by default.
+    ///
+    /// When this is enabled, `.*` (for example) will become ungreedy and `.*?`
+    /// will become greedy.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `U` flag.
+    pub fn swap_greed(mut self, yes: bool) -> Config {
+        self.swap_greed = yes;
+        self
+    }
+
+    /// Enable verbose mode in the regular expression.
+    ///
+    /// When enabled, verbose mode permits insigificant whitespace in many
+    /// places in the regular expression, as well as comments. Comments are
+    /// started using `#` and continue until the end of the line.
+    ///
+    /// By default, this is disabled. It may be selectively enabled in the
+    /// regular expression by using the `x` flag regardless of this setting.
+    pub fn ignore_whitespace(mut self, yes: bool) -> Config {
+        self.ignore_whitespace = yes;
+        self
+    }
+
+    /// Enable or disable the Unicode flag (`u`) by default.
+    ///
+    /// By default this is **enabled**. It may alternatively be selectively
+    /// disabled in the regular expression itself via the `u` flag.
+    ///
+    /// Note that unless "allow invalid UTF-8" is enabled (it's disabled by
+    /// default), a regular expression will fail to parse if Unicode mode is
+    /// disabled and a sub-expression could possibly match invalid UTF-8.
+    ///
+    /// **WARNING**: Unicode mode can greatly increase the size of the compiled
+    /// DFA, which can noticeably impact both memory usage and compilation
+    /// time. This is especially noticeable if your regex contains character
+    /// classes like `\w` that are impacted by whether Unicode is enabled or
+    /// not. If Unicode is not necessary, you are encouraged to disable it.
+    pub fn unicode(mut self, yes: bool) -> Config {
+        self.unicode = yes;
+        self
+    }
+
+    /// When disabled, the builder will permit the construction of a regular
+    /// expression that may match invalid UTF-8.
+    ///
+    /// For example, when [`Config::unicode`] is disabled, then
+    /// expressions like `[^a]` may match invalid UTF-8 since they can match
+    /// any single byte that is not `a`. By default, these sub-expressions
+    /// are disallowed to avoid returning offsets that split a UTF-8
+    /// encoded codepoint. However, in cases where matching at arbitrary
+    /// locations is desired, this option can be disabled to permit all such
+    /// sub-expressions.
+    ///
+    /// When enabled (the default), the builder is guaranteed to produce a
+    /// regex that will only ever match valid UTF-8 (otherwise, the builder
+    /// will return an error).
+    pub fn utf8(mut self, yes: bool) -> Config {
+        self.utf8 = yes;
+        self
+    }
+
+    /// Set the nesting limit used for the regular expression parser.
+    ///
+    /// The nesting limit controls how deep the abstract syntax tree is allowed
+    /// to be. If the AST exceeds the given limit (e.g., with too many nested
+    /// groups), then an error is returned by the parser.
+    ///
+    /// The purpose of this limit is to act as a heuristic to prevent stack
+    /// overflow when building a finite automaton from a regular expression's
+    /// abstract syntax tree. In particular, construction currently uses
+    /// recursion. In the future, the implementation may stop using recursion
+    /// and this option will no longer be necessary.
+    ///
+    /// This limit is not checked until the entire AST is parsed. Therefore,
+    /// if callers want to put a limit on the amount of heap space used, then
+    /// they should impose a limit on the length, in bytes, of the concrete
+    /// pattern string. In particular, this is viable since the parser will
+    /// limit itself to heap space proportional to the lenth of the pattern
+    /// string.
+    ///
+    /// Note that a nest limit of `0` will return a nest limit error for most
+    /// patterns but not all. For example, a nest limit of `0` permits `a` but
+    /// not `ab`, since `ab` requires a concatenation AST item, which results
+    /// in a nest depth of `1`. In general, a nest limit is not something that
+    /// manifests in an obvious way in the concrete syntax, therefore, it
+    /// should not be used in a granular way.
+    pub fn nest_limit(mut self, limit: u32) -> Config {
+        self.nest_limit = limit;
+        self
+    }
+
+    /// Whether to support octal syntax or not.
+    ///
+    /// Octal syntax is a little-known way of uttering Unicode codepoints in
+    /// a regular expression. For example, `a`, `\x61`, `\u0061` and
+    /// `\141` are all equivalent regular expressions, where the last example
+    /// shows octal syntax.
+    ///
+    /// While supporting octal syntax isn't in and of itself a problem, it does
+    /// make good error messages harder. That is, in PCRE based regex engines,
+    /// syntax like `\1` invokes a backreference, which is explicitly
+    /// unsupported in Rust's regex engine. However, many users expect it to
+    /// be supported. Therefore, when octal support is disabled, the error
+    /// message will explicitly mention that backreferences aren't supported.
+    ///
+    /// Octal syntax is disabled by default.
+    pub fn octal(mut self, yes: bool) -> Config {
+        self.octal = yes;
+        self
+    }
+
+    /// Returns whether "unicode" mode is enabled.
+    pub fn get_unicode(&self) -> bool {
+        self.unicode
+    }
+
+    /// Returns whether "case insensitive" mode is enabled.
+    pub fn get_case_insensitive(&self) -> bool {
+        self.case_insensitive
+    }
+
+    /// Returns whether "multi line" mode is enabled.
+    pub fn get_multi_line(&self) -> bool {
+        self.multi_line
+    }
+
+    /// Returns whether "dot matches new line" mode is enabled.
+    pub fn get_dot_matches_new_line(&self) -> bool {
+        self.dot_matches_new_line
+    }
+
+    /// Returns whether "CRLF" mode is enabled.
+    pub fn get_crlf(&self) -> bool {
+        self.crlf
+    }
+
+    /// Returns the line terminator in this syntax configuration.
+    pub fn get_line_terminator(&self) -> u8 {
+        self.line_terminator
+    }
+
+    /// Returns whether "swap greed" mode is enabled.
+    pub fn get_swap_greed(&self) -> bool {
+        self.swap_greed
+    }
+
+    /// Returns whether "ignore whitespace" mode is enabled.
+    pub fn get_ignore_whitespace(&self) -> bool {
+        self.ignore_whitespace
+    }
+
+    /// Returns whether UTF-8 mode is enabled.
+    pub fn get_utf8(&self) -> bool {
+        self.utf8
+    }
+
+    /// Returns the "nest limit" setting.
+    pub fn get_nest_limit(&self) -> u32 {
+        self.nest_limit
+    }
+
+    /// Returns whether "octal" mode is enabled.
+    pub fn get_octal(&self) -> bool {
+        self.octal
+    }
+
+    /// Applies this configuration to the given parser.
+    pub(crate) fn apply(&self, builder: &mut ParserBuilder) {
+        builder
+            .unicode(self.unicode)
+            .case_insensitive(self.case_insensitive)
+            .multi_line(self.multi_line)
+            .dot_matches_new_line(self.dot_matches_new_line)
+            .crlf(self.crlf)
+            .line_terminator(self.line_terminator)
+            .swap_greed(self.swap_greed)
+            .ignore_whitespace(self.ignore_whitespace)
+            .utf8(self.utf8)
+            .nest_limit(self.nest_limit)
+            .octal(self.octal);
+    }
+
+    /// Applies this configuration to the given AST parser.
+    pub(crate) fn apply_ast(&self, builder: &mut ast::parse::ParserBuilder) {
+        builder
+            .ignore_whitespace(self.ignore_whitespace)
+            .nest_limit(self.nest_limit)
+            .octal(self.octal);
+    }
+
+    /// Applies this configuration to the given AST-to-HIR translator.
+    pub(crate) fn apply_hir(
+        &self,
+        builder: &mut hir::translate::TranslatorBuilder,
+    ) {
+        builder
+            .unicode(self.unicode)
+            .case_insensitive(self.case_insensitive)
+            .multi_line(self.multi_line)
+            .crlf(self.crlf)
+            .dot_matches_new_line(self.dot_matches_new_line)
+            .line_terminator(self.line_terminator)
+            .swap_greed(self.swap_greed)
+            .utf8(self.utf8);
+    }
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config::new()
+    }
+}
diff --git a/regex-automata/src/util/unicode_data/mod.rs b/regex-automata/src/util/unicode_data/mod.rs
new file mode 100644
index 0000000000..fc7b1c738a
--- /dev/null
+++ b/regex-automata/src/util/unicode_data/mod.rs
@@ -0,0 +1,17 @@
+// This cfg should match the one in src/util/look.rs that uses perl_word.
+#[cfg(all(
+    // We have to explicitly want to support Unicode word boundaries.
+    feature = "unicode-word-boundary",
+    not(all(
+        // If we don't have regex-syntax at all, then we definitely need to
+        // bring our own \w data table.
+        feature = "syntax",
+        // If unicode-perl is enabled, then regex-syntax/unicode-perl is
+        // also enabled, which in turn means we can use regex-syntax's
+        // is_word_character routine (and thus use its data tables). But if
+        // unicode-perl is not enabled, even if syntax is, then we need to
+        // bring our own.
+        feature = "unicode-perl",
+    )),
+))]
+pub(crate) mod perl_word;
diff --git a/regex-automata/src/util/unicode_data/perl_word.rs b/regex-automata/src/util/unicode_data/perl_word.rs
new file mode 100644
index 0000000000..74d62656f3
--- /dev/null
+++ b/regex-automata/src/util/unicode_data/perl_word.rs
@@ -0,0 +1,781 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate perl-word tmp/ucd-15.0.0/ --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.15 is available on crates.io.
+
+pub const PERL_WORD: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('A', 'Z'),
+    ('_', '_'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('\u{300}', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('\u{483}', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('\u{610}', '\u{61a}'),
+    ('ؠ', '٩'),
+    ('ٮ', 'ۓ'),
+    ('ە', '\u{6dc}'),
+    ('\u{6df}', '\u{6e8}'),
+    ('\u{6ea}', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', '\u{74a}'),
+    ('ݍ', 'ޱ'),
+    ('߀', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('ࠀ', '\u{82d}'),
+    ('ࡀ', '\u{85b}'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{963}'),
+    ('०', '९'),
+    ('ॱ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૯'),
+    ('ૹ', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୯'),
+    ('ୱ', 'ୱ'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௯'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('ಀ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൎ'),
+    ('ൔ', '\u{d57}'),
+    ('ൟ', '\u{d63}'),
+    ('൦', '൯'),
+    ('ൺ', 'ൿ'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', 'ෳ'),
+    ('ก', '\u{e3a}'),
+    ('เ', '\u{e4e}'),
+    ('๐', '๙'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('\u{f18}', '\u{f19}'),
+    ('༠', '༩'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('က', '၉'),
+    ('ၐ', '\u{109d}'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '\u{135f}'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', '᜕'),
+    ('ᜟ', '᜴'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('ក', '\u{17d3}'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', '\u{17dd}'),
+    ('០', '៩'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥆', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧙'),
+    ('ᨀ', '\u{1a1b}'),
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', 'ᭌ'),
+    ('᭐', '᭙'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '᯳'),
+    ('ᰀ', '\u{1c37}'),
+    ('᱀', '᱉'),
+    ('ᱍ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', 'ᳺ'),
+    ('ᴀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('\u{200c}', '\u{200d}'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('\u{2d7f}', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '〇'),
+    ('〡', '\u{302f}'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('\u{3099}', '\u{309a}'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘫ'),
+    ('Ꙁ', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('ꙿ', '\u{a6f1}'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢀ', '\u{a8c5}'),
+    ('꣐', '꣙'),
+    ('\u{a8e0}', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', '\u{a92d}'),
+    ('ꤰ', '꥓'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', '꧀'),
+    ('ꧏ', '꧙'),
+    ('ꧠ', 'ꧾ'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫯ'),
+    ('ꫲ', '\u{aaf6}'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('꯰', '꯹'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ff', 'st'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('０', '９'),
+    ('Ａ', 'Ｚ'),
+    ('＿', '＿'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '\u{1037a}'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '\u{10ae6}'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𐺰', '𐺱'),
+    ('\u{10efd}', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '\u{10f50}'),
+    ('𐽰', '\u{10f85}'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '\u{11046}'),
+    ('𑁦', '𑁵'),
+    ('\u{1107f}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('\u{11100}', '\u{11134}'),
+    ('𑄶', '𑄿'),
+    ('𑅄', '𑅇'),
+    ('𑅐', '\u{11173}'),
+    ('𑅶', '𑅶'),
+    ('\u{11180}', '𑇄'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '\u{11237}'),
+    ('\u{1123e}', '\u{11241}'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '\u{112ea}'),
+    ('𑋰', '𑋹'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133b}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐀', '𑑊'),
+    ('𑑐', '𑑙'),
+    ('\u{1145e}', '𑑡'),
+    ('𑒀', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('𑗘', '\u{115dd}'),
+    ('𑘀', '\u{11640}'),
+    ('𑙄', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑚀', '𑚸'),
+    ('𑛀', '𑛉'),
+    ('𑜀', '𑜚'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑜰', '𑜹'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '\u{1183a}'),
+    ('𑢠', '𑣩'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{11943}'),
+    ('𑥐', '𑥙'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧡'),
+    ('𑧣', '𑧤'),
+    ('𑨀', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('𑩐', '\u{11a99}'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑱀'),
+    ('𑱐', '𑱙'),
+    ('𑱲', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻶'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('𑽐', '𑽙'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('\u{13440}', '\u{13455}'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩰', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𖫐', '𖫭'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('𖬀', '\u{16b36}'),
+    ('𖭀', '𖭃'),
+    ('𖭐', '𖭙'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('\u{16f4f}', '𖾇'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞄀', '𞄬'),
+    ('\u{1e130}', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '\u{1e2ae}'),
+    ('𞋀', '𞋹'),
+    ('𞓐', '𞓹'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('𞤀', '𞥋'),
+    ('𞥐', '𞥙'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+    ('🯰', '🯹'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
diff --git a/regex-automata/src/util/utf8.rs b/regex-automata/src/util/utf8.rs
new file mode 100644
index 0000000000..91b27efe0f
--- /dev/null
+++ b/regex-automata/src/util/utf8.rs
@@ -0,0 +1,196 @@
+/*!
+Utilities for dealing with UTF-8.
+
+This module provides some UTF-8 related helper routines, including an
+incremental decoder.
+*/
+
+/// Returns true if and only if the given byte is considered a word character.
+/// This only applies to ASCII.
+///
+/// This was copied from regex-syntax so that we can use it to determine the
+/// starting DFA state while searching without depending on regex-syntax. The
+/// definition is never going to change, so there's no maintenance/bit-rot
+/// hazard here.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn is_word_byte(b: u8) -> bool {
+    const fn mkwordset() -> [bool; 256] {
+        // FIXME: Use as_usize() once const functions in traits are stable.
+        let mut set = [false; 256];
+        set[b'_' as usize] = true;
+
+        let mut byte = b'0';
+        while byte <= b'9' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        byte = b'A';
+        while byte <= b'Z' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        byte = b'a';
+        while byte <= b'z' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        set
+    }
+    const WORD: [bool; 256] = mkwordset();
+    WORD[b as usize]
+}
+
+/// Decodes the next UTF-8 encoded codepoint from the given byte slice.
+///
+/// If no valid encoding of a codepoint exists at the beginning of the given
+/// byte slice, then the first byte is returned instead.
+///
+/// This returns `None` if and only if `bytes` is empty.
+///
+/// This never panics.
+///
+/// *WARNING*: This is not designed for performance. If you're looking for a
+/// fast UTF-8 decoder, this is not it. If you feel like you need one in this
+/// crate, then please file an issue and discuss your use case.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn decode(bytes: &[u8]) -> Option<Result<char, u8>> {
+    if bytes.is_empty() {
+        return None;
+    }
+    let len = match len(bytes[0]) {
+        None => return Some(Err(bytes[0])),
+        Some(len) if len > bytes.len() => return Some(Err(bytes[0])),
+        Some(1) => return Some(Ok(char::from(bytes[0]))),
+        Some(len) => len,
+    };
+    match core::str::from_utf8(&bytes[..len]) {
+        Ok(s) => Some(Ok(s.chars().next().unwrap())),
+        Err(_) => Some(Err(bytes[0])),
+    }
+}
+
+/// Decodes the last UTF-8 encoded codepoint from the given byte slice.
+///
+/// If no valid encoding of a codepoint exists at the end of the given byte
+/// slice, then the last byte is returned instead.
+///
+/// This returns `None` if and only if `bytes` is empty.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn decode_last(bytes: &[u8]) -> Option<Result<char, u8>> {
+    if bytes.is_empty() {
+        return None;
+    }
+    let mut start = bytes.len() - 1;
+    let limit = bytes.len().saturating_sub(4);
+    while start > limit && !is_leading_or_invalid_byte(bytes[start]) {
+        start -= 1;
+    }
+    match decode(&bytes[start..]) {
+        None => None,
+        Some(Ok(ch)) => Some(Ok(ch)),
+        Some(Err(_)) => Some(Err(bytes[bytes.len() - 1])),
+    }
+}
+
+/// Given a UTF-8 leading byte, this returns the total number of code units
+/// in the following encoded codepoint.
+///
+/// If the given byte is not a valid UTF-8 leading byte, then this returns
+/// `None`.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn len(byte: u8) -> Option<usize> {
+    if byte <= 0x7F {
+        return Some(1);
+    } else if byte & 0b1100_0000 == 0b1000_0000 {
+        return None;
+    } else if byte <= 0b1101_1111 {
+        Some(2)
+    } else if byte <= 0b1110_1111 {
+        Some(3)
+    } else if byte <= 0b1111_0111 {
+        Some(4)
+    } else {
+        None
+    }
+}
+
+/// Returns true if and only if the given offset in the given bytes falls on a
+/// valid UTF-8 encoded codepoint boundary.
+///
+/// If `bytes` is not valid UTF-8, then the behavior of this routine is
+/// unspecified.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn is_boundary(bytes: &[u8], i: usize) -> bool {
+    match bytes.get(i) {
+        // The position at the end of the bytes always represents an empty
+        // string, which is a valid boundary. But anything after that doesn't
+        // make much sense to call valid a boundary.
+        None => i == bytes.len(),
+        // Other than ASCII (where the most significant bit is never set),
+        // valid starting bytes always have their most significant two bits
+        // set, where as continuation bytes never have their second most
+        // significant bit set. Therefore, this only returns true when bytes[i]
+        // corresponds to a byte that begins a valid UTF-8 encoding of a
+        // Unicode scalar value.
+        Some(&b) => b <= 0b0111_1111 || b >= 0b1100_0000,
+    }
+}
+
+/// Returns true if and only if the given byte is either a valid leading UTF-8
+/// byte, or is otherwise an invalid byte that can never appear anywhere in a
+/// valid UTF-8 sequence.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+fn is_leading_or_invalid_byte(b: u8) -> bool {
+    // In the ASCII case, the most significant bit is never set. The leading
+    // byte of a 2/3/4-byte sequence always has the top two most significant
+    // bits set. For bytes that can never appear anywhere in valid UTF-8, this
+    // also returns true, since every such byte has its two most significant
+    // bits set:
+    //
+    //     \xC0 :: 11000000
+    //     \xC1 :: 11000001
+    //     \xF5 :: 11110101
+    //     \xF6 :: 11110110
+    //     \xF7 :: 11110111
+    //     \xF8 :: 11111000
+    //     \xF9 :: 11111001
+    //     \xFA :: 11111010
+    //     \xFB :: 11111011
+    //     \xFC :: 11111100
+    //     \xFD :: 11111101
+    //     \xFE :: 11111110
+    //     \xFF :: 11111111
+    (b & 0b1100_0000) != 0b1000_0000
+}
+
+/*
+/// Returns the smallest possible index of the next valid UTF-8 sequence
+/// starting after `i`.
+///
+/// For all inputs, including invalid UTF-8 and any value of `i`, the return
+/// value is guaranteed to be greater than `i`. (If there is no value greater
+/// than `i` that fits in `usize`, then this panics.)
+///
+/// Generally speaking, this should only be called on `text` when it is
+/// permitted to assume that it is valid UTF-8 and where either `i >=
+/// text.len()` or where `text[i]` is a leading byte of a UTF-8 sequence.
+///
+/// NOTE: This method was used in a previous conception of iterators where we
+/// specifically tried to skip over empty matches that split a codepoint by
+/// simply requiring that our next search begin at the beginning of codepoint.
+/// But we ended up changing that technique to always advance by 1 byte and
+/// then filter out matches that split a codepoint after-the-fact. Thus, we no
+/// longer use this method. But I've kept it around in case we want to switch
+/// back to this approach. Its guarantees are a little subtle, so I'd prefer
+/// not to rebuild it from whole cloth.
+pub(crate) fn next(text: &[u8], i: usize) -> usize {
+    let b = match text.get(i) {
+        None => return i.checked_add(1).unwrap(),
+        Some(&b) => b,
+    };
+    // For cases where we see an invalid UTF-8 byte, there isn't much we can do
+    // other than just start at the next byte.
+    let inc = len(b).unwrap_or(1);
+    i.checked_add(inc).unwrap()
+}
+*/
diff --git a/regex-automata/src/util/wire.rs b/regex-automata/src/util/wire.rs
new file mode 100644
index 0000000000..a49dfaad10
--- /dev/null
+++ b/regex-automata/src/util/wire.rs
@@ -0,0 +1,973 @@
+/*!
+Types and routines that support the wire format of finite automata.
+
+Currently, this module just exports a few error types and some small helpers
+for deserializing [dense DFAs](crate::dfa::dense::DFA) using correct alignment.
+*/
+
+/*
+A collection of helper functions, types and traits for serializing automata.
+
+This crate defines its own bespoke serialization mechanism for some structures
+provided in the public API, namely, DFAs. A bespoke mechanism was developed
+primarily because structures like automata demand a specific binary format.
+Attempting to encode their rich structure in an existing serialization
+format is just not feasible. Moreover, the format for each structure is
+generally designed such that deserialization is cheap. More specifically, that
+deserialization can be done in constant time. (The idea being that you can
+embed it into your binary or mmap it, and then use it immediately.)
+
+In order to achieve this, the dense and sparse DFAs in this crate use an
+in-memory representation that very closely corresponds to its binary serialized
+form. This pervades and complicates everything, and in some cases, requires
+dealing with alignment and reasoning about safety.
+
+This technique does have major advantages. In particular, it permits doing
+the potentially costly work of compiling a finite state machine in an offline
+manner, and then loading it at runtime not only without having to re-compile
+the regex, but even without the code required to do the compilation. This, for
+example, permits one to use a pre-compiled DFA not only in environments without
+Rust's standard library, but also in environments without a heap.
+
+In the code below, whenever we insert some kind of padding, it's to enforce a
+4-byte alignment, unless otherwise noted. Namely, u32 is the only state ID type
+supported. (In a previous version of this library, DFAs were generic over the
+state ID representation.)
+
+Also, serialization generally requires the caller to specify endianness,
+where as deserialization always assumes native endianness (otherwise cheap
+deserialization would be impossible). This implies that serializing a structure
+generally requires serializing both its big-endian and little-endian variants,
+and then loading the correct one based on the target's endianness.
+*/
+
+use core::{
+    cmp,
+    convert::{TryFrom, TryInto},
+    mem::size_of,
+};
+
+#[cfg(feature = "alloc")]
+use alloc::{vec, vec::Vec};
+
+use crate::util::{
+    int::Pointer,
+    primitives::{PatternID, PatternIDError, StateID, StateIDError},
+};
+
+/// A hack to align a smaller type `B` with a bigger type `T`.
+///
+/// The usual use of this is with `B = [u8]` and `T = u32`. That is,
+/// it permits aligning a sequence of bytes on a 4-byte boundary. This
+/// is useful in contexts where one wants to embed a serialized [dense
+/// DFA](crate::dfa::dense::DFA) into a Rust a program while guaranteeing the
+/// alignment required for the DFA.
+///
+/// See [`dense::DFA::from_bytes`](crate::dfa::dense::DFA::from_bytes) for an
+/// example of how to use this type.
+#[repr(C)]
+#[derive(Debug)]
+pub struct AlignAs<B: ?Sized, T> {
+    /// A zero-sized field indicating the alignment we want.
+    pub _align: [T; 0],
+    /// A possibly non-sized field containing a sequence of bytes.
+    pub bytes: B,
+}
+
+/// An error that occurs when serializing an object from this crate.
+///
+/// Serialization, as used in this crate, universally refers to the process
+/// of transforming a structure (like a DFA) into a custom binary format
+/// represented by `&[u8]`. To this end, serialization is generally infallible.
+/// However, it can fail when caller provided buffer sizes are too small. When
+/// that occurs, a serialization error is reported.
+///
+/// A `SerializeError` provides no introspection capabilities. Its only
+/// supported operation is conversion to a human readable error message.
+///
+/// This error type implements the `std::error::Error` trait only when the
+/// `std` feature is enabled. Otherwise, this type is defined in all
+/// configurations.
+#[derive(Debug)]
+pub struct SerializeError {
+    /// The name of the thing that a buffer is too small for.
+    ///
+    /// Currently, the only kind of serialization error is one that is
+    /// committed by a caller: providing a destination buffer that is too
+    /// small to fit the serialized object. This makes sense conceptually,
+    /// since every valid inhabitant of a type should be serializable.
+    ///
+    /// This is somewhat exposed in the public API of this crate. For example,
+    /// the `to_bytes_{big,little}_endian` APIs return a `Vec<u8>` and are
+    /// guaranteed to never panic or error. This is only possible because the
+    /// implementation guarantees that it will allocate a `Vec<u8>` that is
+    /// big enough.
+    ///
+    /// In summary, if a new serialization error kind needs to be added, then
+    /// it will need careful consideration.
+    what: &'static str,
+}
+
+impl SerializeError {
+    pub(crate) fn buffer_too_small(what: &'static str) -> SerializeError {
+        SerializeError { what }
+    }
+}
+
+impl core::fmt::Display for SerializeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "destination buffer is too small to write {}", self.what)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SerializeError {}
+
+/// An error that occurs when deserializing an object defined in this crate.
+///
+/// Serialization, as used in this crate, universally refers to the process
+/// of transforming a structure (like a DFA) into a custom binary format
+/// represented by `&[u8]`. Deserialization, then, refers to the process of
+/// cheaply converting this binary format back to the object's in-memory
+/// representation as defined in this crate. To the extent possible,
+/// deserialization will report this error whenever this process fails.
+///
+/// A `DeserializeError` provides no introspection capabilities. Its only
+/// supported operation is conversion to a human readable error message.
+///
+/// This error type implements the `std::error::Error` trait only when the
+/// `std` feature is enabled. Otherwise, this type is defined in all
+/// configurations.
+#[derive(Debug)]
+pub struct DeserializeError(DeserializeErrorKind);
+
+#[derive(Debug)]
+enum DeserializeErrorKind {
+    Generic { msg: &'static str },
+    BufferTooSmall { what: &'static str },
+    InvalidUsize { what: &'static str },
+    VersionMismatch { expected: u32, found: u32 },
+    EndianMismatch { expected: u32, found: u32 },
+    AlignmentMismatch { alignment: usize, address: usize },
+    LabelMismatch { expected: &'static str },
+    ArithmeticOverflow { what: &'static str },
+    PatternID { err: PatternIDError, what: &'static str },
+    StateID { err: StateIDError, what: &'static str },
+}
+
+impl DeserializeError {
+    pub(crate) fn generic(msg: &'static str) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::Generic { msg })
+    }
+
+    pub(crate) fn buffer_too_small(what: &'static str) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::BufferTooSmall { what })
+    }
+
+    fn invalid_usize(what: &'static str) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::InvalidUsize { what })
+    }
+
+    fn version_mismatch(expected: u32, found: u32) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::VersionMismatch {
+            expected,
+            found,
+        })
+    }
+
+    fn endian_mismatch(expected: u32, found: u32) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::EndianMismatch {
+            expected,
+            found,
+        })
+    }
+
+    fn alignment_mismatch(
+        alignment: usize,
+        address: usize,
+    ) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::AlignmentMismatch {
+            alignment,
+            address,
+        })
+    }
+
+    fn label_mismatch(expected: &'static str) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::LabelMismatch { expected })
+    }
+
+    fn arithmetic_overflow(what: &'static str) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::ArithmeticOverflow { what })
+    }
+
+    fn pattern_id_error(
+        err: PatternIDError,
+        what: &'static str,
+    ) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::PatternID { err, what })
+    }
+
+    pub(crate) fn state_id_error(
+        err: StateIDError,
+        what: &'static str,
+    ) -> DeserializeError {
+        DeserializeError(DeserializeErrorKind::StateID { err, what })
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DeserializeError {}
+
+impl core::fmt::Display for DeserializeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use self::DeserializeErrorKind::*;
+
+        match self.0 {
+            Generic { msg } => write!(f, "{}", msg),
+            BufferTooSmall { what } => {
+                write!(f, "buffer is too small to read {}", what)
+            }
+            InvalidUsize { what } => {
+                write!(f, "{} is too big to fit in a usize", what)
+            }
+            VersionMismatch { expected, found } => write!(
+                f,
+                "unsupported version: \
+                 expected version {} but found version {}",
+                expected, found,
+            ),
+            EndianMismatch { expected, found } => write!(
+                f,
+                "endianness mismatch: expected 0x{:X} but got 0x{:X}. \
+                 (Are you trying to load an object serialized with a \
+                 different endianness?)",
+                expected, found,
+            ),
+            AlignmentMismatch { alignment, address } => write!(
+                f,
+                "alignment mismatch: slice starts at address \
+                 0x{:X}, which is not aligned to a {} byte boundary",
+                address, alignment,
+            ),
+            LabelMismatch { expected } => write!(
+                f,
+                "label mismatch: start of serialized object should \
+                 contain a NUL terminated {:?} label, but a different \
+                 label was found",
+                expected,
+            ),
+            ArithmeticOverflow { what } => {
+                write!(f, "arithmetic overflow for {}", what)
+            }
+            PatternID { ref err, what } => {
+                write!(f, "failed to read pattern ID for {}: {}", what, err)
+            }
+            StateID { ref err, what } => {
+                write!(f, "failed to read state ID for {}: {}", what, err)
+            }
+        }
+    }
+}
+
+/// Safely converts a `&[u32]` to `&[StateID]` with zero cost.
+pub(crate) fn u32s_to_state_ids(slice: &[u32]) -> &[StateID] {
+    // SAFETY: This is safe because StateID is defined to have the same memory
+    // representation as a u32 (it is repr(transparent)). While not every u32
+    // is a "valid" StateID, callers are not permitted to rely on the validity
+    // of StateIDs for memory safety. It can only lead to logical errors. (This
+    // is why StateID::new_unchecked is safe.)
+    unsafe {
+        core::slice::from_raw_parts(
+            slice.as_ptr().cast::<StateID>(),
+            slice.len(),
+        )
+    }
+}
+
+/// Safely converts a `&mut [u32]` to `&mut [StateID]` with zero cost.
+pub(crate) fn u32s_to_state_ids_mut(slice: &mut [u32]) -> &mut [StateID] {
+    // SAFETY: This is safe because StateID is defined to have the same memory
+    // representation as a u32 (it is repr(transparent)). While not every u32
+    // is a "valid" StateID, callers are not permitted to rely on the validity
+    // of StateIDs for memory safety. It can only lead to logical errors. (This
+    // is why StateID::new_unchecked is safe.)
+    unsafe {
+        core::slice::from_raw_parts_mut(
+            slice.as_mut_ptr().cast::<StateID>(),
+            slice.len(),
+        )
+    }
+}
+
+/// Safely converts a `&[u32]` to `&[PatternID]` with zero cost.
+pub(crate) fn u32s_to_pattern_ids(slice: &[u32]) -> &[PatternID] {
+    // SAFETY: This is safe because PatternID is defined to have the same
+    // memory representation as a u32 (it is repr(transparent)). While not
+    // every u32 is a "valid" PatternID, callers are not permitted to rely
+    // on the validity of PatternIDs for memory safety. It can only lead to
+    // logical errors. (This is why PatternID::new_unchecked is safe.)
+    unsafe {
+        core::slice::from_raw_parts(
+            slice.as_ptr().cast::<PatternID>(),
+            slice.len(),
+        )
+    }
+}
+
+/// Checks that the given slice has an alignment that matches `T`.
+///
+/// This is useful for checking that a slice has an appropriate alignment
+/// before casting it to a &[T]. Note though that alignment is not itself
+/// sufficient to perform the cast for any `T`.
+pub(crate) fn check_alignment<T>(
+    slice: &[u8],
+) -> Result<(), DeserializeError> {
+    let alignment = core::mem::align_of::<T>();
+    let address = slice.as_ptr().as_usize();
+    if address % alignment == 0 {
+        return Ok(());
+    }
+    Err(DeserializeError::alignment_mismatch(alignment, address))
+}
+
+/// Reads a possibly empty amount of padding, up to 7 bytes, from the beginning
+/// of the given slice. All padding bytes must be NUL bytes.
+///
+/// This is useful because it can be theoretically necessary to pad the
+/// beginning of a serialized object with NUL bytes to ensure that it starts
+/// at a correctly aligned address. These padding bytes should come immediately
+/// before the label.
+///
+/// This returns the number of bytes read from the given slice.
+pub(crate) fn skip_initial_padding(slice: &[u8]) -> usize {
+    let mut nread = 0;
+    while nread < 7 && nread < slice.len() && slice[nread] == 0 {
+        nread += 1;
+    }
+    nread
+}
+
+/// Allocate a byte buffer of the given size, along with some initial padding
+/// such that `buf[padding..]` has the same alignment as `T`, where the
+/// alignment of `T` must be at most `8`. In particular, callers should treat
+/// the first N bytes (second return value) as padding bytes that must not be
+/// overwritten. In all cases, the following identity holds:
+///
+/// ```ignore
+/// let (buf, padding) = alloc_aligned_buffer::<StateID>(SIZE);
+/// assert_eq!(SIZE, buf[padding..].len());
+/// ```
+///
+/// In practice, padding is often zero.
+///
+/// The requirement for `8` as a maximum here is somewhat arbitrary. In
+/// practice, we never need anything bigger in this crate, and so this function
+/// does some sanity asserts under the assumption of a max alignment of `8`.
+#[cfg(feature = "alloc")]
+pub(crate) fn alloc_aligned_buffer<T>(size: usize) -> (Vec<u8>, usize) {
+    // NOTE: This is a kludge because there's no easy way to allocate a Vec<u8>
+    // with an alignment guaranteed to be greater than 1. We could create a
+    // Vec<u32>, but this cannot be safely transmuted to a Vec<u8> without
+    // concern, since reallocing or dropping the Vec<u8> is UB (different
+    // alignment than the initial allocation). We could define a wrapper type
+    // to manage this for us, but it seems like more machinery than it's worth.
+    let buf = vec![0; size];
+    let align = core::mem::align_of::<T>();
+    let address = buf.as_ptr().as_usize();
+    if address % align == 0 {
+        return (buf, 0);
+    }
+    // Let's try this again. We have to create a totally new alloc with
+    // the maximum amount of bytes we might need. We can't just extend our
+    // pre-existing 'buf' because that might create a new alloc with a
+    // different alignment.
+    let extra = align - 1;
+    let mut buf = vec![0; size + extra];
+    let address = buf.as_ptr().as_usize();
+    // The code below handles the case where 'address' is aligned to T, so if
+    // we got lucky and 'address' is now aligned to T (when it previously
+    // wasn't), then we're done.
+    if address % align == 0 {
+        buf.truncate(size);
+        return (buf, 0);
+    }
+    let padding = ((address & !(align - 1)).checked_add(align).unwrap())
+        .checked_sub(address)
+        .unwrap();
+    assert!(padding <= 7, "padding of {} is bigger than 7", padding);
+    assert!(
+        padding <= extra,
+        "padding of {} is bigger than extra {} bytes",
+        padding,
+        extra
+    );
+    buf.truncate(size + padding);
+    assert_eq!(size + padding, buf.len());
+    assert_eq!(
+        0,
+        buf[padding..].as_ptr().as_usize() % align,
+        "expected end of initial padding to be aligned to {}",
+        align,
+    );
+    (buf, padding)
+}
+
+/// Reads a NUL terminated label starting at the beginning of the given slice.
+///
+/// If a NUL terminated label could not be found, then an error is returned.
+/// Similary, if a label is found but doesn't match the expected label, then
+/// an error is returned.
+///
+/// Upon success, the total number of bytes read (including padding bytes) is
+/// returned.
+pub(crate) fn read_label(
+    slice: &[u8],
+    expected_label: &'static str,
+) -> Result<usize, DeserializeError> {
+    // Set an upper bound on how many bytes we scan for a NUL. Since no label
+    // in this crate is longer than 256 bytes, if we can't find one within that
+    // range, then we have corrupted data.
+    let first_nul =
+        slice[..cmp::min(slice.len(), 256)].iter().position(|&b| b == 0);
+    let first_nul = match first_nul {
+        Some(first_nul) => first_nul,
+        None => {
+            return Err(DeserializeError::generic(
+                "could not find NUL terminated label \
+                 at start of serialized object",
+            ));
+        }
+    };
+    let len = first_nul + padding_len(first_nul);
+    if slice.len() < len {
+        return Err(DeserializeError::generic(
+            "could not find properly sized label at start of serialized object"
+        ));
+    }
+    if expected_label.as_bytes() != &slice[..first_nul] {
+        return Err(DeserializeError::label_mismatch(expected_label));
+    }
+    Ok(len)
+}
+
+/// Writes the given label to the buffer as a NUL terminated string. The label
+/// given must not contain NUL, otherwise this will panic. Similarly, the label
+/// must not be longer than 255 bytes, otherwise this will panic.
+///
+/// Additional NUL bytes are written as necessary to ensure that the number of
+/// bytes written is always a multiple of 4.
+///
+/// Upon success, the total number of bytes written (including padding) is
+/// returned.
+pub(crate) fn write_label(
+    label: &str,
+    dst: &mut [u8],
+) -> Result<usize, SerializeError> {
+    let nwrite = write_label_len(label);
+    if dst.len() < nwrite {
+        return Err(SerializeError::buffer_too_small("label"));
+    }
+    dst[..label.len()].copy_from_slice(label.as_bytes());
+    for i in 0..(nwrite - label.len()) {
+        dst[label.len() + i] = 0;
+    }
+    assert_eq!(nwrite % 4, 0);
+    Ok(nwrite)
+}
+
+/// Returns the total number of bytes (including padding) that would be written
+/// for the given label. This panics if the given label contains a NUL byte or
+/// is longer than 255 bytes. (The size restriction exists so that searching
+/// for a label during deserialization can be done in small bounded space.)
+pub(crate) fn write_label_len(label: &str) -> usize {
+    if label.len() > 255 {
+        panic!("label must not be longer than 255 bytes");
+    }
+    if label.as_bytes().iter().position(|&b| b == 0).is_some() {
+        panic!("label must not contain NUL bytes");
+    }
+    let label_len = label.len() + 1; // +1 for the NUL terminator
+    label_len + padding_len(label_len)
+}
+
+/// Reads the endianness check from the beginning of the given slice and
+/// confirms that the endianness of the serialized object matches the expected
+/// endianness. If the slice is too small or if the endianness check fails,
+/// this returns an error.
+///
+/// Upon success, the total number of bytes read is returned.
+pub(crate) fn read_endianness_check(
+    slice: &[u8],
+) -> Result<usize, DeserializeError> {
+    let (n, nr) = try_read_u32(slice, "endianness check")?;
+    assert_eq!(nr, write_endianness_check_len());
+    if n != 0xFEFF {
+        return Err(DeserializeError::endian_mismatch(0xFEFF, n));
+    }
+    Ok(nr)
+}
+
+/// Writes 0xFEFF as an integer using the given endianness.
+///
+/// This is useful for writing into the header of a serialized object. It can
+/// be read during deserialization as a sanity check to ensure the proper
+/// endianness is used.
+///
+/// Upon success, the total number of bytes written is returned.
+pub(crate) fn write_endianness_check<E: Endian>(
+    dst: &mut [u8],
+) -> Result<usize, SerializeError> {
+    let nwrite = write_endianness_check_len();
+    if dst.len() < nwrite {
+        return Err(SerializeError::buffer_too_small("endianness check"));
+    }
+    E::write_u32(0xFEFF, dst);
+    Ok(nwrite)
+}
+
+/// Returns the number of bytes written by the endianness check.
+pub(crate) fn write_endianness_check_len() -> usize {
+    size_of::<u32>()
+}
+
+/// Reads a version number from the beginning of the given slice and confirms
+/// that is matches the expected version number given. If the slice is too
+/// small or if the version numbers aren't equivalent, this returns an error.
+///
+/// Upon success, the total number of bytes read is returned.
+///
+/// N.B. Currently, we require that the version number is exactly equivalent.
+/// In the future, if we bump the version number without a semver bump, then
+/// we'll need to relax this a bit and support older versions.
+pub(crate) fn read_version(
+    slice: &[u8],
+    expected_version: u32,
+) -> Result<usize, DeserializeError> {
+    let (n, nr) = try_read_u32(slice, "version")?;
+    assert_eq!(nr, write_version_len());
+    if n != expected_version {
+        return Err(DeserializeError::version_mismatch(expected_version, n));
+    }
+    Ok(nr)
+}
+
+/// Writes the given version number to the beginning of the given slice.
+///
+/// This is useful for writing into the header of a serialized object. It can
+/// be read during deserialization as a sanity check to ensure that the library
+/// code supports the format of the serialized object.
+///
+/// Upon success, the total number of bytes written is returned.
+pub(crate) fn write_version<E: Endian>(
+    version: u32,
+    dst: &mut [u8],
+) -> Result<usize, SerializeError> {
+    let nwrite = write_version_len();
+    if dst.len() < nwrite {
+        return Err(SerializeError::buffer_too_small("version number"));
+    }
+    E::write_u32(version, dst);
+    Ok(nwrite)
+}
+
+/// Returns the number of bytes written by writing the version number.
+pub(crate) fn write_version_len() -> usize {
+    size_of::<u32>()
+}
+
+/// Reads a pattern ID from the given slice. If the slice has insufficient
+/// length, then this panics. If the deserialized integer exceeds the pattern
+/// ID limit for the current target, then this returns an error.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn read_pattern_id(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(PatternID, usize), DeserializeError> {
+    let bytes: [u8; PatternID::SIZE] =
+        slice[..PatternID::SIZE].try_into().unwrap();
+    let pid = PatternID::from_ne_bytes(bytes)
+        .map_err(|err| DeserializeError::pattern_id_error(err, what))?;
+    Ok((pid, PatternID::SIZE))
+}
+
+/// Reads a pattern ID from the given slice. If the slice has insufficient
+/// length, then this panics. Otherwise, the deserialized integer is assumed
+/// to be a valid pattern ID.
+///
+/// This also returns the number of bytes read.
+pub(crate) fn read_pattern_id_unchecked(slice: &[u8]) -> (PatternID, usize) {
+    let pid = PatternID::from_ne_bytes_unchecked(
+        slice[..PatternID::SIZE].try_into().unwrap(),
+    );
+    (pid, PatternID::SIZE)
+}
+
+/// Write the given pattern ID to the beginning of the given slice of bytes
+/// using the specified endianness. The given slice must have length at least
+/// `PatternID::SIZE`, or else this panics. Upon success, the total number of
+/// bytes written is returned.
+pub(crate) fn write_pattern_id<E: Endian>(
+    pid: PatternID,
+    dst: &mut [u8],
+) -> usize {
+    E::write_u32(pid.as_u32(), dst);
+    PatternID::SIZE
+}
+
+/// Attempts to read a state ID from the given slice. If the slice has an
+/// insufficient number of bytes or if the state ID exceeds the limit for
+/// the current target, then this returns an error.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_state_id(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(StateID, usize), DeserializeError> {
+    if slice.len() < StateID::SIZE {
+        return Err(DeserializeError::buffer_too_small(what));
+    }
+    read_state_id(slice, what)
+}
+
+/// Reads a state ID from the given slice. If the slice has insufficient
+/// length, then this panics. If the deserialized integer exceeds the state ID
+/// limit for the current target, then this returns an error.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn read_state_id(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(StateID, usize), DeserializeError> {
+    let bytes: [u8; StateID::SIZE] =
+        slice[..StateID::SIZE].try_into().unwrap();
+    let sid = StateID::from_ne_bytes(bytes)
+        .map_err(|err| DeserializeError::state_id_error(err, what))?;
+    Ok((sid, StateID::SIZE))
+}
+
+/// Reads a state ID from the given slice. If the slice has insufficient
+/// length, then this panics. Otherwise, the deserialized integer is assumed
+/// to be a valid state ID.
+///
+/// This also returns the number of bytes read.
+pub(crate) fn read_state_id_unchecked(slice: &[u8]) -> (StateID, usize) {
+    let sid = StateID::from_ne_bytes_unchecked(
+        slice[..StateID::SIZE].try_into().unwrap(),
+    );
+    (sid, StateID::SIZE)
+}
+
+/// Write the given state ID to the beginning of the given slice of bytes
+/// using the specified endianness. The given slice must have length at least
+/// `StateID::SIZE`, or else this panics. Upon success, the total number of
+/// bytes written is returned.
+pub(crate) fn write_state_id<E: Endian>(
+    sid: StateID,
+    dst: &mut [u8],
+) -> usize {
+    E::write_u32(sid.as_u32(), dst);
+    StateID::SIZE
+}
+
+/// Try to read a u16 as a usize from the beginning of the given slice in
+/// native endian format. If the slice has fewer than 2 bytes or if the
+/// deserialized number cannot be represented by usize, then this returns an
+/// error. The error message will include the `what` description of what is
+/// being deserialized, for better error messages. `what` should be a noun in
+/// singular form.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_u16_as_usize(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(usize, usize), DeserializeError> {
+    try_read_u16(slice, what).and_then(|(n, nr)| {
+        usize::try_from(n)
+            .map(|n| (n, nr))
+            .map_err(|_| DeserializeError::invalid_usize(what))
+    })
+}
+
+/// Try to read a u32 as a usize from the beginning of the given slice in
+/// native endian format. If the slice has fewer than 4 bytes or if the
+/// deserialized number cannot be represented by usize, then this returns an
+/// error. The error message will include the `what` description of what is
+/// being deserialized, for better error messages. `what` should be a noun in
+/// singular form.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_u32_as_usize(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(usize, usize), DeserializeError> {
+    try_read_u32(slice, what).and_then(|(n, nr)| {
+        usize::try_from(n)
+            .map(|n| (n, nr))
+            .map_err(|_| DeserializeError::invalid_usize(what))
+    })
+}
+
+/// Try to read a u16 from the beginning of the given slice in native endian
+/// format. If the slice has fewer than 2 bytes, then this returns an error.
+/// The error message will include the `what` description of what is being
+/// deserialized, for better error messages. `what` should be a noun in
+/// singular form.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_u16(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(u16, usize), DeserializeError> {
+    check_slice_len(slice, size_of::<u16>(), what)?;
+    Ok((read_u16(slice), size_of::<u16>()))
+}
+
+/// Try to read a u32 from the beginning of the given slice in native endian
+/// format. If the slice has fewer than 4 bytes, then this returns an error.
+/// The error message will include the `what` description of what is being
+/// deserialized, for better error messages. `what` should be a noun in
+/// singular form.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_u32(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(u32, usize), DeserializeError> {
+    check_slice_len(slice, size_of::<u32>(), what)?;
+    Ok((read_u32(slice), size_of::<u32>()))
+}
+
+/// Try to read a u128 from the beginning of the given slice in native endian
+/// format. If the slice has fewer than 16 bytes, then this returns an error.
+/// The error message will include the `what` description of what is being
+/// deserialized, for better error messages. `what` should be a noun in
+/// singular form.
+///
+/// Upon success, this also returns the number of bytes read.
+pub(crate) fn try_read_u128(
+    slice: &[u8],
+    what: &'static str,
+) -> Result<(u128, usize), DeserializeError> {
+    check_slice_len(slice, size_of::<u128>(), what)?;
+    Ok((read_u128(slice), size_of::<u128>()))
+}
+
+/// Read a u16 from the beginning of the given slice in native endian format.
+/// If the slice has fewer than 2 bytes, then this panics.
+///
+/// Marked as inline to speed up sparse searching which decodes integers from
+/// its automaton at search time.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn read_u16(slice: &[u8]) -> u16 {
+    let bytes: [u8; 2] = slice[..size_of::<u16>()].try_into().unwrap();
+    u16::from_ne_bytes(bytes)
+}
+
+/// Read a u32 from the beginning of the given slice in native endian format.
+/// If the slice has fewer than 4 bytes, then this panics.
+///
+/// Marked as inline to speed up sparse searching which decodes integers from
+/// its automaton at search time.
+#[cfg_attr(feature = "perf-inline", inline(always))]
+pub(crate) fn read_u32(slice: &[u8]) -> u32 {
+    let bytes: [u8; 4] = slice[..size_of::<u32>()].try_into().unwrap();
+    u32::from_ne_bytes(bytes)
+}
+
+/// Read a u128 from the beginning of the given slice in native endian format.
+/// If the slice has fewer than 16 bytes, then this panics.
+pub(crate) fn read_u128(slice: &[u8]) -> u128 {
+    let bytes: [u8; 16] = slice[..size_of::<u128>()].try_into().unwrap();
+    u128::from_ne_bytes(bytes)
+}
+
+/// Checks that the given slice has some minimal length. If it's smaller than
+/// the bound given, then a "buffer too small" error is returned with `what`
+/// describing what the buffer represents.
+pub(crate) fn check_slice_len<T>(
+    slice: &[T],
+    at_least_len: usize,
+    what: &'static str,
+) -> Result<(), DeserializeError> {
+    if slice.len() < at_least_len {
+        return Err(DeserializeError::buffer_too_small(what));
+    }
+    Ok(())
+}
+
+/// Multiply the given numbers, and on overflow, return an error that includes
+/// 'what' in the error message.
+///
+/// This is useful when doing arithmetic with untrusted data.
+pub(crate) fn mul(
+    a: usize,
+    b: usize,
+    what: &'static str,
+) -> Result<usize, DeserializeError> {
+    match a.checked_mul(b) {
+        Some(c) => Ok(c),
+        None => Err(DeserializeError::arithmetic_overflow(what)),
+    }
+}
+
+/// Add the given numbers, and on overflow, return an error that includes
+/// 'what' in the error message.
+///
+/// This is useful when doing arithmetic with untrusted data.
+pub(crate) fn add(
+    a: usize,
+    b: usize,
+    what: &'static str,
+) -> Result<usize, DeserializeError> {
+    match a.checked_add(b) {
+        Some(c) => Ok(c),
+        None => Err(DeserializeError::arithmetic_overflow(what)),
+    }
+}
+
+/// Shift `a` left by `b`, and on overflow, return an error that includes
+/// 'what' in the error message.
+///
+/// This is useful when doing arithmetic with untrusted data.
+pub(crate) fn shl(
+    a: usize,
+    b: usize,
+    what: &'static str,
+) -> Result<usize, DeserializeError> {
+    let amount = u32::try_from(b)
+        .map_err(|_| DeserializeError::arithmetic_overflow(what))?;
+    match a.checked_shl(amount) {
+        Some(c) => Ok(c),
+        None => Err(DeserializeError::arithmetic_overflow(what)),
+    }
+}
+
+/// Returns the number of additional bytes required to add to the given length
+/// in order to make the total length a multiple of 4. The return value is
+/// always less than 4.
+pub(crate) fn padding_len(non_padding_len: usize) -> usize {
+    (4 - (non_padding_len & 0b11)) & 0b11
+}
+
+/// A simple trait for writing code generic over endianness.
+///
+/// This is similar to what byteorder provides, but we only need a very small
+/// subset.
+pub(crate) trait Endian {
+    /// Writes a u16 to the given destination buffer in a particular
+    /// endianness. If the destination buffer has a length smaller than 2, then
+    /// this panics.
+    fn write_u16(n: u16, dst: &mut [u8]);
+
+    /// Writes a u32 to the given destination buffer in a particular
+    /// endianness. If the destination buffer has a length smaller than 4, then
+    /// this panics.
+    fn write_u32(n: u32, dst: &mut [u8]);
+
+    /// Writes a u64 to the given destination buffer in a particular
+    /// endianness. If the destination buffer has a length smaller than 8, then
+    /// this panics.
+    fn write_u64(n: u64, dst: &mut [u8]);
+
+    /// Writes a u128 to the given destination buffer in a particular
+    /// endianness. If the destination buffer has a length smaller than 16,
+    /// then this panics.
+    fn write_u128(n: u128, dst: &mut [u8]);
+}
+
+/// Little endian writing.
+pub(crate) enum LE {}
+/// Big endian writing.
+pub(crate) enum BE {}
+
+#[cfg(target_endian = "little")]
+pub(crate) type NE = LE;
+#[cfg(target_endian = "big")]
+pub(crate) type NE = BE;
+
+impl Endian for LE {
+    fn write_u16(n: u16, dst: &mut [u8]) {
+        dst[..2].copy_from_slice(&n.to_le_bytes());
+    }
+
+    fn write_u32(n: u32, dst: &mut [u8]) {
+        dst[..4].copy_from_slice(&n.to_le_bytes());
+    }
+
+    fn write_u64(n: u64, dst: &mut [u8]) {
+        dst[..8].copy_from_slice(&n.to_le_bytes());
+    }
+
+    fn write_u128(n: u128, dst: &mut [u8]) {
+        dst[..16].copy_from_slice(&n.to_le_bytes());
+    }
+}
+
+impl Endian for BE {
+    fn write_u16(n: u16, dst: &mut [u8]) {
+        dst[..2].copy_from_slice(&n.to_be_bytes());
+    }
+
+    fn write_u32(n: u32, dst: &mut [u8]) {
+        dst[..4].copy_from_slice(&n.to_be_bytes());
+    }
+
+    fn write_u64(n: u64, dst: &mut [u8]) {
+        dst[..8].copy_from_slice(&n.to_be_bytes());
+    }
+
+    fn write_u128(n: u128, dst: &mut [u8]) {
+        dst[..16].copy_from_slice(&n.to_be_bytes());
+    }
+}
+
+#[cfg(all(test, feature = "alloc"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn labels() {
+        let mut buf = [0; 1024];
+
+        let nwrite = write_label("fooba", &mut buf).unwrap();
+        assert_eq!(nwrite, 8);
+        assert_eq!(&buf[..nwrite], b"fooba\x00\x00\x00");
+
+        let nread = read_label(&buf, "fooba").unwrap();
+        assert_eq!(nread, 8);
+    }
+
+    #[test]
+    #[should_panic]
+    fn bad_label_interior_nul() {
+        // interior NULs are not allowed
+        write_label("foo\x00bar", &mut [0; 1024]).unwrap();
+    }
+
+    #[test]
+    fn bad_label_almost_too_long() {
+        // ok
+        write_label(&"z".repeat(255), &mut [0; 1024]).unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn bad_label_too_long() {
+        // labels longer than 255 bytes are banned
+        write_label(&"z".repeat(256), &mut [0; 1024]).unwrap();
+    }
+
+    #[test]
+    fn padding() {
+        assert_eq!(0, padding_len(8));
+        assert_eq!(3, padding_len(9));
+        assert_eq!(2, padding_len(10));
+        assert_eq!(1, padding_len(11));
+        assert_eq!(0, padding_len(12));
+        assert_eq!(3, padding_len(13));
+        assert_eq!(2, padding_len(14));
+        assert_eq!(1, padding_len(15));
+        assert_eq!(0, padding_len(16));
+    }
+}
diff --git a/regex-automata/test b/regex-automata/test
new file mode 100755
index 0000000000..df3e5ae98d
--- /dev/null
+++ b/regex-automata/test
@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# This is a script that attempts to *approximately* exhaustively run the test
+# suite for regex-automata. The main reason for why 'cargo test' isn't enough
+# is because of crate features. regex-automata has a ton of them. This script
+# tests many of those feature combinations (although not all) to try to get
+# decent coverage in a finite amount of time.
+
+set -e
+
+# cd to the directory containing this crate's Cargo.toml so that we don't need
+# to pass --manifest-path to every `cargo` command.
+cd "$(dirname "$0")"
+
+echo "===== ALL FEATURES TEST ==="
+cargo test --all-features
+
+# Man I don't *want* to have this many crate features, but... I really want
+# folks to be able to slim the crate down to just the things they want. But
+# the main downside is that I just can't feasibly test every combination of
+# features because there are too many of them. Sad, but I'm not sure if there
+# is a better alternative.
+features=(
+  ""
+  "unicode-word-boundary"
+  "unicode-word-boundary,syntax,unicode-perl"
+  "unicode-word-boundary,syntax,dfa-build"
+  "nfa"
+  "dfa"
+  "hybrid"
+  "nfa,dfa"
+  "nfa,hybrid"
+  "dfa,hybrid"
+  "dfa-onepass"
+  "nfa-pikevm"
+  "nfa-backtrack"
+  "std"
+  "alloc"
+  "syntax"
+  "syntax,nfa-pikevm"
+  "syntax,hybrid"
+  "perf-literal-substring"
+  "perf-literal-multisubstring"
+  "meta"
+  "meta,nfa-backtrack"
+  "meta,hybrid"
+  "meta,dfa-build"
+  "meta,dfa-onepass"
+  "meta,nfa,dfa,hybrid,nfa-backtrack"
+  "meta,nfa,dfa,hybrid,nfa-backtrack,perf-literal-substring"
+  "meta,nfa,dfa,hybrid,nfa-backtrack,perf-literal-multisubstring"
+)
+for f in "${features[@]}"; do
+  echo "===== LIB FEATURES: $f ==="
+  # It's actually important to do a standard 'cargo build' in addition to a
+  # 'cargo test'. In particular, in the latter case, the dev-dependencies may
+  # wind up enabling features in dependencies (like memchr) that make it look
+  # like everything is well, but actually isn't. For example, the 'regex-test'
+  # dev-dependency uses 'bstr' and enables its 'std' feature, which in turn
+  # unconditionally enables 'memchr's 'std' feature. Since we're specifically
+  # looking to test that certain feature combinations work as expected, this
+  # can lead to things testing okay, but would actually fail to build. Yikes.
+  cargo build --no-default-features --lib --features "$f"
+  cargo test --no-default-features --lib --features "$f"
+done
+
+# We can also run the integration test suite on stripped down features too.
+# But the test suite doesn't do well with things like 'std' and 'unicode'
+# disabled, so we always enable them.
+features=(
+  "std,unicode,syntax,nfa-pikevm"
+  "std,unicode,syntax,nfa-backtrack"
+  "std,unicode,syntax,hybrid"
+  "std,unicode,syntax,dfa-onepass"
+  "std,unicode,syntax,dfa-search"
+  "std,unicode,syntax,dfa-build"
+  "std,unicode,meta"
+  # This one is a little tricky because it causes the backtracker to get used
+  # in more instances and results in failing tests for the 'earliest' tests.
+  # The actual results are semantically consistent with the API guarantee
+  # (the backtracker tends to report greater offsets because it isn't an FSM),
+  # but our tests are less flexible than the API guarantee and demand offsets
+  # reported by FSM regex engines. (Which is... all of them except for the
+  # backtracker.)
+  # "std,unicode,meta,nfa-backtrack"
+  "std,unicode,meta,hybrid"
+  "std,unicode,meta,dfa-onepass"
+  "std,unicode,meta,dfa-build"
+  "std,unicode,meta,nfa,dfa-onepass,hybrid"
+)
+for f in "${features[@]}"; do
+  echo "===== INTEGRATION FEATURES: $f ==="
+  cargo build --no-default-features --lib --features "$f"
+  cargo test --no-default-features --test integration --features "$f"
+done
diff --git a/regex-automata/tests/dfa/api.rs b/regex-automata/tests/dfa/api.rs
new file mode 100644
index 0000000000..96e73af6c2
--- /dev/null
+++ b/regex-automata/tests/dfa/api.rs
@@ -0,0 +1,69 @@
+use std::error::Error;
+
+use regex_automata::{
+    dfa::{dense, Automaton, OverlappingState},
+    nfa::thompson,
+    HalfMatch, Input, MatchError,
+};
+
+// Tests that quit bytes in the forward direction work correctly.
+#[test]
+fn quit_fwd() -> Result<(), Box<dyn Error>> {
+    let dfa = dense::Builder::new()
+        .configure(dense::Config::new().quit(b'x', true))
+        .build("[[:word:]]+$")?;
+
+    assert_eq!(
+        Err(MatchError::quit(b'x', 3)),
+        dfa.try_search_fwd(&Input::new(b"abcxyz"))
+    );
+    assert_eq!(
+        dfa.try_search_overlapping_fwd(
+            &Input::new(b"abcxyz"),
+            &mut OverlappingState::start()
+        ),
+        Err(MatchError::quit(b'x', 3)),
+    );
+
+    Ok(())
+}
+
+// Tests that quit bytes in the reverse direction work correctly.
+#[test]
+fn quit_rev() -> Result<(), Box<dyn Error>> {
+    let dfa = dense::Builder::new()
+        .configure(dense::Config::new().quit(b'x', true))
+        .thompson(thompson::Config::new().reverse(true))
+        .build("^[[:word:]]+")?;
+
+    assert_eq!(
+        Err(MatchError::quit(b'x', 3)),
+        dfa.try_search_rev(&Input::new(b"abcxyz"))
+    );
+
+    Ok(())
+}
+
+// Tests that if we heuristically enable Unicode word boundaries but then
+// instruct that a non-ASCII byte should NOT be a quit byte, then the builder
+// will panic.
+#[test]
+#[should_panic]
+fn quit_panics() {
+    dense::Config::new().unicode_word_boundary(true).quit(b'\xFF', false);
+}
+
+// This tests an intesting case where even if the Unicode word boundary option
+// is disabled, setting all non-ASCII bytes to be quit bytes will cause Unicode
+// word boundaries to be enabled.
+#[test]
+fn unicode_word_implicitly_works() -> Result<(), Box<dyn Error>> {
+    let mut config = dense::Config::new();
+    for b in 0x80..=0xFF {
+        config = config.quit(b, true);
+    }
+    let dfa = dense::Builder::new().configure(config).build(r"\b")?;
+    let expected = HalfMatch::must(0, 1);
+    assert_eq!(Ok(Some(expected)), dfa.try_search_fwd(&Input::new(b" a")));
+    Ok(())
+}
diff --git a/regex-automata/tests/dfa/mod.rs b/regex-automata/tests/dfa/mod.rs
new file mode 100644
index 0000000000..0d8f539db6
--- /dev/null
+++ b/regex-automata/tests/dfa/mod.rs
@@ -0,0 +1,8 @@
+#[cfg(all(feature = "dfa-build", feature = "dfa-search"))]
+mod api;
+#[cfg(feature = "dfa-onepass")]
+mod onepass;
+#[cfg(all(feature = "dfa-build", feature = "dfa-search"))]
+mod regression;
+#[cfg(all(not(miri), feature = "dfa-build", feature = "dfa-search"))]
+mod suite;
diff --git a/regex-automata/tests/dfa/onepass/mod.rs b/regex-automata/tests/dfa/onepass/mod.rs
new file mode 100644
index 0000000000..9d6ab475ef
--- /dev/null
+++ b/regex-automata/tests/dfa/onepass/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(not(miri))]
+mod suite;
diff --git a/regex-automata/tests/dfa/onepass/suite.rs b/regex-automata/tests/dfa/onepass/suite.rs
new file mode 100644
index 0000000000..20bd6965c8
--- /dev/null
+++ b/regex-automata/tests/dfa/onepass/suite.rs
@@ -0,0 +1,197 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        dfa::onepass::{self, DFA},
+        nfa::thompson,
+        util::{iter, syntax},
+    },
+    regex_test::{
+        CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+        TestRunner,
+    },
+};
+
+use crate::{create_input, suite, testify_captures, untestify_kind};
+
+const EXPANSIONS: &[&str] = &["is_match", "find", "captures"];
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let builder = DFA::builder();
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
+/// tests.
+#[test]
+fn starts_for_each_pattern() -> Result<()> {
+    let mut builder = DFA::builder();
+    builder.configure(DFA::config().starts_for_each_pattern(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when byte classes are disabled.
+///
+/// N.B. Disabling byte classes doesn't avoid any indirection at search time.
+/// All it does is cause every byte value to be its own distinct equivalence
+/// class.
+#[test]
+fn no_byte_classes() -> Result<()> {
+    let mut builder = DFA::builder();
+    builder.configure(DFA::config().byte_classes(false));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+fn compiler(
+    mut builder: onepass::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        // Check if our regex contains things that aren't supported by DFAs.
+        // That is, Unicode word boundaries when searching non-ASCII text.
+        if !configure_onepass_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        let re = match builder.build_many(&regexes) {
+            Ok(re) => re,
+            Err(err) => {
+                let msg = err.to_string();
+                // This is pretty gross, but when a regex fails to compile as
+                // a one-pass regex, then we want to be OK with that and just
+                // skip the test. But we have to be careful to only skip it
+                // when the expected result is that the regex compiles. If
+                // the test is specifically checking that the regex does not
+                // compile, then we should bubble up that error and allow the
+                // test to pass.
+                //
+                // Since our error types are all generally opaque, we just
+                // look for an error string. Not great, but not the end of the
+                // world.
+                if test.compiles() && msg.contains("not one-pass") {
+                    return Ok(CompiledRegex::skip());
+                }
+                return Err(err.into());
+            }
+        };
+        let mut cache = re.create_cache();
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, &mut cache, test)
+        }))
+    }
+}
+
+fn run_test(
+    re: &DFA,
+    cache: &mut onepass::Cache,
+    test: &RegexTest,
+) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => {
+            TestResult::matched(re.is_match(cache, input.earliest(true)))
+        }
+        "find" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                let input =
+                    input.earliest(test.search_kind() == SearchKind::Earliest);
+                let mut caps = re.create_captures();
+                let it = iter::Searcher::new(input)
+                    .into_matches_iter(|input| {
+                        re.try_search(cache, input, &mut caps)?;
+                        Ok(caps.get_match())
+                    })
+                    .infallible()
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    });
+                TestResult::matches(it)
+            }
+            SearchKind::Overlapping => {
+                // The one-pass DFA does not support any kind of overlapping
+                // search. This is not just a matter of not having the API.
+                // It's fundamentally incompatible with the one-pass concept.
+                // If overlapping matches were possible, then the one-pass DFA
+                // would fail to build.
+                TestResult::skip()
+            }
+        },
+        "captures" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                let input =
+                    input.earliest(test.search_kind() == SearchKind::Earliest);
+                let it = iter::Searcher::new(input)
+                    .into_captures_iter(re.create_captures(), |input, caps| {
+                        re.try_search(cache, input, caps)
+                    })
+                    .infallible()
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|caps| testify_captures(&caps));
+                TestResult::captures(it)
+            }
+            SearchKind::Overlapping => {
+                // The one-pass DFA does not support any kind of overlapping
+                // search. This is not just a matter of not having the API.
+                // It's fundamentally incompatible with the one-pass concept.
+                // If overlapping matches were possible, then the one-pass DFA
+                // would fail to build.
+                TestResult::skip()
+            }
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_onepass_builder(
+    test: &RegexTest,
+    builder: &mut onepass::Builder,
+) -> bool {
+    if !test.anchored() {
+        return false;
+    }
+    let match_kind = match untestify_kind(test.match_kind()) {
+        None => return false,
+        Some(k) => k,
+    };
+
+    let config = DFA::config().match_kind(match_kind);
+    builder
+        .configure(config)
+        .syntax(config_syntax(test))
+        .thompson(config_thompson(test));
+    true
+}
+
+/// Configuration of a Thompson NFA compiler from a regex test.
+fn config_thompson(test: &RegexTest) -> thompson::Config {
+    let mut lookm = regex_automata::util::look::LookMatcher::new();
+    lookm.set_line_terminator(test.line_terminator());
+    thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+}
+
+/// Configuration of the regex parser from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
diff --git a/regex-automata/tests/dfa/regression.rs b/regex-automata/tests/dfa/regression.rs
new file mode 100644
index 0000000000..09caffabcb
--- /dev/null
+++ b/regex-automata/tests/dfa/regression.rs
@@ -0,0 +1,48 @@
+// A regression test for checking that minimization correctly translates
+// whether a state is a match state or not. Previously, it was possible for
+// minimization to mark a non-matching state as matching.
+#[test]
+#[cfg(not(miri))]
+fn minimize_sets_correct_match_states() {
+    use regex_automata::{
+        dfa::{dense::DFA, Automaton, StartKind},
+        Anchored, Input,
+    };
+
+    let pattern =
+        // This is a subset of the grapheme matching regex. I couldn't seem
+        // to get a repro any smaller than this unfortunately.
+        r"(?x)
+            (?:
+                \p{gcb=Prepend}*
+                (?:
+                    (?:
+                        (?:
+                            \p{gcb=L}*
+                            (?:\p{gcb=V}+|\p{gcb=LV}\p{gcb=V}*|\p{gcb=LVT})
+                            \p{gcb=T}*
+                        )
+                        |
+                        \p{gcb=L}+
+                        |
+                        \p{gcb=T}+
+                    )
+                    |
+                    \p{Extended_Pictographic}
+                    (?:\p{gcb=Extend}*\p{gcb=ZWJ}\p{Extended_Pictographic})*
+                    |
+                    [^\p{gcb=Control}\p{gcb=CR}\p{gcb=LF}]
+                )
+                [\p{gcb=Extend}\p{gcb=ZWJ}\p{gcb=SpacingMark}]*
+            )
+        ";
+
+    let dfa = DFA::builder()
+        .configure(
+            DFA::config().start_kind(StartKind::Anchored).minimize(true),
+        )
+        .build(pattern)
+        .unwrap();
+    let input = Input::new(b"\xE2").anchored(Anchored::Yes);
+    assert_eq!(Ok(None), dfa.try_search_fwd(&input));
+}
diff --git a/regex-automata/tests/dfa/suite.rs b/regex-automata/tests/dfa/suite.rs
new file mode 100644
index 0000000000..f3445e02a4
--- /dev/null
+++ b/regex-automata/tests/dfa/suite.rs
@@ -0,0 +1,447 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        dfa::{
+            self, dense, regex::Regex, sparse, Automaton, OverlappingState,
+            StartKind,
+        },
+        nfa::thompson,
+        util::{prefilter::Prefilter, syntax},
+        Anchored, Input, PatternSet,
+    },
+    regex_syntax::hir,
+    regex_test::{
+        CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+        TestRunner,
+    },
+};
+
+use crate::{create_input, suite, untestify_kind};
+
+const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+
+/// Runs the test suite with the default configuration.
+#[test]
+fn unminimized_default() -> Result<()> {
+    let builder = Regex::builder();
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite with the default configuration and a prefilter enabled,
+/// if one can be built.
+#[test]
+fn unminimized_prefilter() -> Result<()> {
+    let my_compiler = |test: &RegexTest, regexes: &[String]| {
+        // Parse regexes as HIRs so we can get literals to build a prefilter.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+        let kind = match untestify_kind(test.match_kind()) {
+            None => return Ok(CompiledRegex::skip()),
+            Some(kind) => kind,
+        };
+        let pre = Prefilter::from_hirs_prefix(kind, &hirs);
+        let mut builder = Regex::builder();
+        builder.dense(dense::DFA::config().prefilter(pre));
+        compiler(builder, |_, _, re| {
+            Ok(CompiledRegex::compiled(move |test| -> TestResult {
+                run_test(&re, test)
+            }))
+        })(test, regexes)
+    };
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), my_compiler)
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite with start states specialized.
+#[test]
+fn unminimized_specialized_start_states() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dense(dense::Config::new().specialize_start_states(true));
+
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite with byte classes disabled.
+#[test]
+fn unminimized_no_byte_class() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dense(dense::Config::new().byte_classes(false));
+
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite with NFA shrinking enabled.
+#[test]
+fn unminimized_nfa_shrink() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.thompson(thompson::Config::new().shrink(true));
+
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite on a minimized DFA with an otherwise default
+/// configuration.
+#[test]
+fn minimized_default() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dense(dense::Config::new().minimize(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite on a minimized DFA with byte classes disabled.
+#[test]
+fn minimized_no_byte_class() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dense(dense::Config::new().minimize(true).byte_classes(false));
+
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), dense_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite on a sparse unminimized DFA.
+#[test]
+fn sparse_unminimized_default() -> Result<()> {
+    let builder = Regex::builder();
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), sparse_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Runs the test suite on a sparse unminimized DFA with prefilters enabled.
+#[test]
+fn sparse_unminimized_prefilter() -> Result<()> {
+    let my_compiler = |test: &RegexTest, regexes: &[String]| {
+        // Parse regexes as HIRs so we can get literals to build a prefilter.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+        let kind = match untestify_kind(test.match_kind()) {
+            None => return Ok(CompiledRegex::skip()),
+            Some(kind) => kind,
+        };
+        let pre = Prefilter::from_hirs_prefix(kind, &hirs);
+        let mut builder = Regex::builder();
+        builder.dense(dense::DFA::config().prefilter(pre));
+        compiler(builder, |builder, _, re| {
+            let fwd = re.forward().to_sparse()?;
+            let rev = re.reverse().to_sparse()?;
+            let re = builder.build_from_dfas(fwd, rev);
+            Ok(CompiledRegex::compiled(move |test| -> TestResult {
+                run_test(&re, test)
+            }))
+        })(test, regexes)
+    };
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), my_compiler)
+        .assert();
+    Ok(())
+}
+
+/// Another basic sanity test that checks we can serialize and then deserialize
+/// a regex, and that the resulting regex can be used for searching correctly.
+#[test]
+fn serialization_unminimized_default() -> Result<()> {
+    let builder = Regex::builder();
+    let my_compiler = |builder| {
+        compiler(builder, |builder, _, re| {
+            let builder = builder.clone();
+            let (fwd_bytes, _) = re.forward().to_bytes_native_endian();
+            let (rev_bytes, _) = re.reverse().to_bytes_native_endian();
+            Ok(CompiledRegex::compiled(move |test| -> TestResult {
+                let fwd: dense::DFA<&[u32]> =
+                    dense::DFA::from_bytes(&fwd_bytes).unwrap().0;
+                let rev: dense::DFA<&[u32]> =
+                    dense::DFA::from_bytes(&rev_bytes).unwrap().0;
+                let re = builder.build_from_dfas(fwd, rev);
+
+                run_test(&re, test)
+            }))
+        })
+    };
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), my_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// A basic sanity test that checks we can serialize and then deserialize a
+/// regex using sparse DFAs, and that the resulting regex can be used for
+/// searching correctly.
+#[test]
+fn sparse_serialization_unminimized_default() -> Result<()> {
+    let builder = Regex::builder();
+    let my_compiler = |builder| {
+        compiler(builder, |builder, _, re| {
+            let builder = builder.clone();
+            let fwd_bytes = re.forward().to_sparse()?.to_bytes_native_endian();
+            let rev_bytes = re.reverse().to_sparse()?.to_bytes_native_endian();
+            Ok(CompiledRegex::compiled(move |test| -> TestResult {
+                let fwd: sparse::DFA<&[u8]> =
+                    sparse::DFA::from_bytes(&fwd_bytes).unwrap().0;
+                let rev: sparse::DFA<&[u8]> =
+                    sparse::DFA::from_bytes(&rev_bytes).unwrap().0;
+                let re = builder.build_from_dfas(fwd, rev);
+                run_test(&re, test)
+            }))
+        })
+    };
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .blacklist("expensive")
+        .test_iter(suite()?.iter(), my_compiler(builder))
+        .assert();
+    Ok(())
+}
+
+fn dense_compiler(
+    builder: dfa::regex::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    compiler(builder, |_, _, re| {
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, test)
+        }))
+    })
+}
+
+fn sparse_compiler(
+    builder: dfa::regex::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    compiler(builder, |builder, _, re| {
+        let fwd = re.forward().to_sparse()?;
+        let rev = re.reverse().to_sparse()?;
+        let re = builder.build_from_dfas(fwd, rev);
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, test)
+        }))
+    })
+}
+
+fn compiler(
+    mut builder: dfa::regex::Builder,
+    mut create_matcher: impl FnMut(
+        &dfa::regex::Builder,
+        Option<Prefilter>,
+        Regex,
+    ) -> Result<CompiledRegex>,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        // Parse regexes as HIRs for some analysis below.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+
+        // Get a prefilter in case the test wants it.
+        let kind = match untestify_kind(test.match_kind()) {
+            None => return Ok(CompiledRegex::skip()),
+            Some(kind) => kind,
+        };
+        let pre = Prefilter::from_hirs_prefix(kind, &hirs);
+
+        // Check if our regex contains things that aren't supported by DFAs.
+        // That is, Unicode word boundaries when searching non-ASCII text.
+        if !test.haystack().is_ascii() {
+            for hir in hirs.iter() {
+                let looks = hir.properties().look_set();
+                if looks.contains(hir::Look::WordUnicode)
+                    || looks.contains(hir::Look::WordUnicodeNegate)
+                {
+                    return Ok(CompiledRegex::skip());
+                }
+            }
+        }
+        if !configure_regex_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        create_matcher(&builder, pre, builder.build_many(&regexes)?)
+    }
+}
+
+fn run_test<A: Automaton>(re: &Regex<A>, test: &RegexTest) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(input.earliest(true))),
+        "find" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                let input =
+                    input.earliest(test.search_kind() == SearchKind::Earliest);
+                TestResult::matches(
+                    re.find_iter(input)
+                        .take(test.match_limit().unwrap_or(std::usize::MAX))
+                        .map(|m| Match {
+                            id: m.pattern().as_usize(),
+                            span: Span { start: m.start(), end: m.end() },
+                        }),
+                )
+            }
+            SearchKind::Overlapping => {
+                try_search_overlapping(re, &input).unwrap()
+            }
+        },
+        "which" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                // There are no "which" APIs for standard searches.
+                TestResult::skip()
+            }
+            SearchKind::Overlapping => {
+                let dfa = re.forward();
+                let mut patset = PatternSet::new(dfa.pattern_len());
+                dfa.try_which_overlapping_matches(&input, &mut patset)
+                    .unwrap();
+                TestResult::which(patset.iter().map(|p| p.as_usize()))
+            }
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_regex_builder(
+    test: &RegexTest,
+    builder: &mut dfa::regex::Builder,
+) -> bool {
+    let match_kind = match untestify_kind(test.match_kind()) {
+        None => return false,
+        Some(k) => k,
+    };
+
+    let starts = if test.anchored() {
+        StartKind::Anchored
+    } else {
+        StartKind::Unanchored
+    };
+    let mut dense_config = dense::Config::new()
+        .start_kind(starts)
+        .match_kind(match_kind)
+        .unicode_word_boundary(true);
+    // When doing an overlapping search, we might try to find the start of each
+    // match with a custom search routine. In that case, we need to tell the
+    // reverse search (for the start offset) which pattern to look for. The
+    // only way that API works is when anchored starting states are compiled
+    // for each pattern. This does technically also enable it for the forward
+    // DFA, but we're okay with that.
+    if test.search_kind() == SearchKind::Overlapping {
+        dense_config = dense_config.starts_for_each_pattern(true);
+    }
+
+    builder
+        .syntax(config_syntax(test))
+        .thompson(config_thompson(test))
+        .dense(dense_config);
+    true
+}
+
+/// Configuration of a Thompson NFA compiler from a regex test.
+fn config_thompson(test: &RegexTest) -> thompson::Config {
+    let mut lookm = regex_automata::util::look::LookMatcher::new();
+    lookm.set_line_terminator(test.line_terminator());
+    thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+}
+
+/// Configuration of the regex syntax from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
+
+/// Execute an overlapping search, and for each match found, also find its
+/// overlapping starting positions.
+///
+/// N.B. This routine used to be part of the crate API, but 1) it wasn't clear
+/// to me how useful it was and 2) it wasn't clear to me what its semantics
+/// should be. In particular, a potentially surprising footgun of this routine
+/// that it is worst case *quadratic* in the size of the haystack. Namely, it's
+/// possible to report a match at every position, and for every such position,
+/// scan all the way to the beginning of the haystack to find the starting
+/// position. Typical leftmost non-overlapping searches don't suffer from this
+/// because, well, matches can't overlap. So subsequent searches after a match
+/// is found don't revisit previously scanned parts of the haystack.
+///
+/// Its semantics can be strange for other reasons too. For example, given
+/// the regex '.*' and the haystack 'zz', the full set of overlapping matches
+/// is: [0, 0], [1, 1], [0, 1], [2, 2], [1, 2], [0, 2]. The ordering of
+/// those matches is quite strange, but makes sense when you think about the
+/// implementation: an end offset is found left-to-right, and then one or more
+/// starting offsets are found right-to-left.
+///
+/// Nevertheless, we provide this routine in our test suite because it's
+/// useful to test the low level DFA overlapping search and our test suite
+/// is written in a way that requires starting offsets.
+fn try_search_overlapping<A: Automaton>(
+    re: &Regex<A>,
+    input: &Input<'_>,
+) -> Result<TestResult> {
+    let mut matches = vec![];
+    let mut fwd_state = OverlappingState::start();
+    let (fwd_dfa, rev_dfa) = (re.forward(), re.reverse());
+    while let Some(end) = {
+        fwd_dfa.try_search_overlapping_fwd(input, &mut fwd_state)?;
+        fwd_state.get_match()
+    } {
+        let revsearch = input
+            .clone()
+            .range(input.start()..end.offset())
+            .anchored(Anchored::Pattern(end.pattern()))
+            .earliest(false);
+        let mut rev_state = OverlappingState::start();
+        while let Some(start) = {
+            rev_dfa.try_search_overlapping_rev(&revsearch, &mut rev_state)?;
+            rev_state.get_match()
+        } {
+            let span = Span { start: start.offset(), end: end.offset() };
+            let mat = Match { id: end.pattern().as_usize(), span };
+            matches.push(mat);
+        }
+    }
+    Ok(TestResult::matches(matches))
+}
diff --git a/regex-automata/tests/fuzz/dense.rs b/regex-automata/tests/fuzz/dense.rs
new file mode 100644
index 0000000000..213891b3e8
--- /dev/null
+++ b/regex-automata/tests/fuzz/dense.rs
@@ -0,0 +1,52 @@
+// This test was found by a fuzzer input that crafted a way to provide
+// an invalid serialization of ByteClasses that passed our verification.
+// Specifically, the verification step in the deserialization of ByteClasses
+// used an iterator that depends on part of the serialized bytes being correct.
+// (Specifically, the encoding of the number of classes.)
+#[test]
+fn invalid_byte_classes() {
+    let data = include_bytes!(
+        "testdata/deserialize_dense_crash-9486fb7c8a93b12c12a62166b43d31640c0208a9",
+    );
+    let _ = fuzz_run(data);
+}
+
+#[test]
+fn invalid_byte_classes_min() {
+    let data = include_bytes!(
+        "testdata/deserialize_dense_minimized-from-9486fb7c8a93b12c12a62166b43d31640c0208a9",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This is the code from the fuzz target. Kind of sucks to duplicate it here,
+// but this is fundamentally how we interpret the date.
+fn fuzz_run(given_data: &[u8]) -> Option<()> {
+    use regex_automata::dfa::Automaton;
+
+    if given_data.len() < 2 {
+        return None;
+    }
+    let haystack_len = usize::from(given_data[0]);
+    let haystack = given_data.get(1..1 + haystack_len)?;
+    let given_dfa_bytes = given_data.get(1 + haystack_len..)?;
+
+    // We help the fuzzer along by adding a preamble to the bytes that should
+    // at least make these first parts valid. The preamble expects a very
+    // specific sequence of bytes, so it makes sense to just force this.
+    let label = "rust-regex-automata-dfa-dense\x00\x00\x00";
+    assert_eq!(0, label.len() % 4);
+    let endianness_check = 0xFEFFu32.to_ne_bytes().to_vec();
+    let version_check = 2u32.to_ne_bytes().to_vec();
+    let mut dfa_bytes: Vec<u8> = vec![];
+    dfa_bytes.extend(label.as_bytes());
+    dfa_bytes.extend(&endianness_check);
+    dfa_bytes.extend(&version_check);
+    dfa_bytes.extend(given_dfa_bytes);
+    // This is the real test: checking that any input we give to
+    // DFA::from_bytes will never result in a panic.
+    let (dfa, _) =
+        regex_automata::dfa::dense::DFA::from_bytes(&dfa_bytes).ok()?;
+    let _ = dfa.try_search_fwd(&regex_automata::Input::new(haystack));
+    Some(())
+}
diff --git a/regex-automata/tests/fuzz/mod.rs b/regex-automata/tests/fuzz/mod.rs
new file mode 100644
index 0000000000..960cb4251a
--- /dev/null
+++ b/regex-automata/tests/fuzz/mod.rs
@@ -0,0 +1,2 @@
+mod dense;
+mod sparse;
diff --git a/regex-automata/tests/fuzz/sparse.rs b/regex-automata/tests/fuzz/sparse.rs
new file mode 100644
index 0000000000..837ad10147
--- /dev/null
+++ b/regex-automata/tests/fuzz/sparse.rs
@@ -0,0 +1,132 @@
+// This is a regression test for a bug in how special states are handled. The
+// fuzzer found a case where a state returned true for 'is_special_state' but
+// *didn't* return true for 'is_dead_state', 'is_quit_state', 'is_match_state',
+// 'is_start_state' or 'is_accel_state'. This in turn tripped a debug assertion
+// in the core matching loop that requires 'is_special_state' being true to
+// imply that one of the other routines returns true.
+//
+// We fixed this by adding some validation to both dense and sparse DFAs that
+// checks that this property is true for every state ID in the DFA.
+#[test]
+fn invalid_special_state() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-a1b839d899ced76d5d7d0f78f9edb7a421505838",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This is an interesting case where a fuzzer generated a DFA with
+// a transition to a state ID that decoded as a valid state, but
+// where the ID itself did not point to one of the two existing
+// states for this particular DFA. This combined with marking this
+// transition's state ID as special but without actually making one of the
+// 'is_{dead,quit,match,start,accel}_state' predicates return true ended up
+// tripping the 'debug_assert(dfa.is_quit_state(sid))' code in the search
+// routine.
+//
+// We fixed this in alloc mode by checking that every transition points to a
+// valid state ID. Technically this bug still exists in core-only mode, but
+// it's not clear how to fix it. And it's worth pointing out that the search
+// routine won't panic in production. It will just provide invalid results. And
+// that's acceptable within the contract of DFA::from_bytes.
+#[test]
+fn transition_to_invalid_but_valid_state() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-dbb8172d3984e7e7d03f4b5f8bb86ecd1460eff9",
+    );
+    let _ = fuzz_run(data);
+}
+
+// Another one caught by the fuzzer where it generated a DFA that reported a
+// start state as a match state. Since matches are always delayed by one byte,
+// start states specifically cannot be match states. And indeed, the search
+// code relies on this.
+#[test]
+fn start_state_is_not_match_state() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-0da59c0434eaf35e5a6b470fa9244bb79c72b000",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This is variation on 'transition_to_invalid_but_valid_state', but happens
+// to a start state. Namely, the fuzz data here builds a DFA with a start
+// state ID that is incorrect but points to a sequence of bytes that satisfies
+// state decoding validation. This errant state in turn has a non-zero number
+// of transitions, and its those transitions that point to a state that does
+// *not* satisfy state decoding validation. But we never checked those. So the
+// fix here was to add validation of the transitions off of the start state.
+#[test]
+fn start_state_has_valid_transitions() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-61fd8e3003bf9d99f6c1e5a8488727eefd234b98",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This fuzz input generated a DFA with a state whose ID was in the match state
+// ID range, but where the state itself was encoded with zero pattern IDs. We
+// added validation code to check this case.
+#[test]
+fn match_state_inconsistency() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-c383ae07ec5e191422eadc492117439011816570",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This fuzz input generated a DFA with a state whose ID was in the accelerator
+// range, but who didn't have any accelerators. This violated an invariant that
+// assumes that if 'dfa.is_accel_state(sid)' returns true, then the state must
+// have some accelerators.
+#[test]
+fn invalid_accelerators() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-d07703ceb94b10dcd9e4acb809f2051420449e2b",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This fuzz input generated a DFA with a state whose EOI transition led to
+// a quit state, which is generally considered illegal. Why? Because the EOI
+// transition is defined over a special sentinel alphabet element and one
+// cannot configure a DFA to "quit" on that sentinel.
+#[test]
+fn eoi_transition_to_quit_state() {
+    let data = include_bytes!(
+        "testdata/deserialize_sparse_crash-18cfc246f2ddfc3dfc92b0c7893178c7cf65efa9",
+    );
+    let _ = fuzz_run(data);
+}
+
+// This is the code from the fuzz target. Kind of sucks to duplicate it here,
+// but this is fundamentally how we interpret the date.
+fn fuzz_run(given_data: &[u8]) -> Option<()> {
+    use regex_automata::dfa::Automaton;
+
+    if given_data.len() < 2 {
+        return None;
+    }
+    let haystack_len = usize::from(given_data[0]);
+    let haystack = given_data.get(1..1 + haystack_len)?;
+    let given_dfa_bytes = given_data.get(1 + haystack_len..)?;
+
+    // We help the fuzzer along by adding a preamble to the bytes that should
+    // at least make these first parts valid. The preamble expects a very
+    // specific sequence of bytes, so it makes sense to just force this.
+    let label = "rust-regex-automata-dfa-sparse\x00\x00";
+    assert_eq!(0, label.len() % 4);
+    let endianness_check = 0xFEFFu32.to_ne_bytes().to_vec();
+    let version_check = 2u32.to_ne_bytes().to_vec();
+    let mut dfa_bytes: Vec<u8> = vec![];
+    dfa_bytes.extend(label.as_bytes());
+    dfa_bytes.extend(&endianness_check);
+    dfa_bytes.extend(&version_check);
+    dfa_bytes.extend(given_dfa_bytes);
+    // This is the real test: checking that any input we give to
+    // DFA::from_bytes will never result in a panic.
+    let (dfa, _) =
+        regex_automata::dfa::sparse::DFA::from_bytes(&dfa_bytes).ok()?;
+    let _ = dfa.try_search_fwd(&regex_automata::Input::new(haystack));
+    Some(())
+}
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_dense_crash-9486fb7c8a93b12c12a62166b43d31640c0208a9 b/regex-automata/tests/fuzz/testdata/deserialize_dense_crash-9486fb7c8a93b12c12a62166b43d31640c0208a9
new file mode 100644
index 0000000000..972bfb2cd4
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_dense_crash-9486fb7c8a93b12c12a62166b43d31640c0208a9 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_dense_minimized-from-9486fb7c8a93b12c12a62166b43d31640c0208a9 b/regex-automata/tests/fuzz/testdata/deserialize_dense_minimized-from-9486fb7c8a93b12c12a62166b43d31640c0208a9
new file mode 100644
index 0000000000..72dbdad825
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_dense_minimized-from-9486fb7c8a93b12c12a62166b43d31640c0208a9 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-0da59c0434eaf35e5a6b470fa9244bb79c72b000 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-0da59c0434eaf35e5a6b470fa9244bb79c72b000
new file mode 100644
index 0000000000..5ce508803e
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-0da59c0434eaf35e5a6b470fa9244bb79c72b000 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-18cfc246f2ddfc3dfc92b0c7893178c7cf65efa9 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-18cfc246f2ddfc3dfc92b0c7893178c7cf65efa9
new file mode 100644
index 0000000000..4fa13fbed4
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-18cfc246f2ddfc3dfc92b0c7893178c7cf65efa9 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-61fd8e3003bf9d99f6c1e5a8488727eefd234b98 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-61fd8e3003bf9d99f6c1e5a8488727eefd234b98
new file mode 100644
index 0000000000..0f809f33f4
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-61fd8e3003bf9d99f6c1e5a8488727eefd234b98 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-a1b839d899ced76d5d7d0f78f9edb7a421505838 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-a1b839d899ced76d5d7d0f78f9edb7a421505838
new file mode 100644
index 0000000000..8b435fd26e
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-a1b839d899ced76d5d7d0f78f9edb7a421505838 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-c383ae07ec5e191422eadc492117439011816570 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-c383ae07ec5e191422eadc492117439011816570
new file mode 100644
index 0000000000..69b65160c2
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-c383ae07ec5e191422eadc492117439011816570 differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-d07703ceb94b10dcd9e4acb809f2051420449e2b b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-d07703ceb94b10dcd9e4acb809f2051420449e2b
new file mode 100644
index 0000000000..15b43e47f2
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-d07703ceb94b10dcd9e4acb809f2051420449e2b differ
diff --git a/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-dbb8172d3984e7e7d03f4b5f8bb86ecd1460eff9 b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-dbb8172d3984e7e7d03f4b5f8bb86ecd1460eff9
new file mode 100644
index 0000000000..aa72eb1dd6
Binary files /dev/null and b/regex-automata/tests/fuzz/testdata/deserialize_sparse_crash-dbb8172d3984e7e7d03f4b5f8bb86ecd1460eff9 differ
diff --git a/regex-automata/tests/gen/README.md b/regex-automata/tests/gen/README.md
new file mode 100644
index 0000000000..59439a11fd
--- /dev/null
+++ b/regex-automata/tests/gen/README.md
@@ -0,0 +1,65 @@
+This directory contains tests for serialized objects from the regex-automata
+crate. Currently, there are only two supported such objects: dense and sparse
+DFAs.
+
+The idea behind these tests is to commit some serialized objects and run some
+basic tests by deserializing them and running searches and ensuring they are
+correct. We also make sure these are run under Miri, since deserialization is
+one of the biggest places where undefined behavior might occur in this crate
+(at the time of writing).
+
+The main thing we're testing is that the *current* code can still deserialize
+*old* objects correctly. Generally speaking, compatibility extends to semver
+compatible releases of this crate. Beyond that, no promises are made, although
+in practice callers can at least depend on errors occurring. (The serialized
+format always includes a version number, and incompatible changes increment
+that version number such that an error will occur if an unsupported version is
+detected.)
+
+To generate the dense DFAs, I used this command:
+
+```
+$ regex-cli generate serialize dense regex \
+    MULTI_PATTERN_V2 \
+    tests/gen/dense/ \
+    --rustfmt \
+    --safe \
+    --starts-for-each-pattern \
+    --specialize-start-states \
+    --start-kind both \
+    --unicode-word-boundary \
+    --minimize \
+    '\b[a-zA-Z]+\b' \
+    '(?m)^\S+$' \
+    '(?Rm)^\S+$'
+```
+
+And to generate the sparse DFAs, I used this command, which is the same as
+above, but with `s/dense/sparse/g`.
+
+```
+$ regex-cli generate serialize sparse regex \
+    MULTI_PATTERN_V2 \
+    tests/gen/sparse/ \
+    --rustfmt \
+    --safe \
+    --starts-for-each-pattern \
+    --specialize-start-states \
+    --start-kind both \
+    --unicode-word-boundary \
+    --minimize \
+    '\b[a-zA-Z]+\b' \
+    '(?m)^\S+$' \
+    '(?Rm)^\S+$'
+```
+
+The idea is to try to enable as many of the DFA's options as possible in order
+to test that serialization works for all of them.
+
+Arguably we should increase test coverage here, but this is a start. Note
+that in particular, this does not need to test that serialization and
+deserialization correctly roundtrips on its own. Indeed, the normal regex test
+suite has a test that does a serialization round trip for every test supported
+by DFAs. So that has very good coverage. What we're interested in testing here
+is our compatibility promise: do DFAs generated with an older revision of the
+code still deserialize correctly?
diff --git a/regex-automata/tests/gen/dense/mod.rs b/regex-automata/tests/gen/dense/mod.rs
new file mode 100644
index 0000000000..b4365d4e19
--- /dev/null
+++ b/regex-automata/tests/gen/dense/mod.rs
@@ -0,0 +1,22 @@
+use regex_automata::{Input, Match};
+
+mod multi_pattern_v2;
+
+#[test]
+fn multi_pattern_v2() {
+    use multi_pattern_v2::MULTI_PATTERN_V2 as RE;
+
+    assert_eq!(Some(Match::must(0, 0..4)), RE.find("abcd"));
+    assert_eq!(Some(Match::must(0, 2..6)), RE.find("@ abcd @"));
+    assert_eq!(Some(Match::must(1, 0..6)), RE.find("@abcd@"));
+    assert_eq!(Some(Match::must(0, 1..5)), RE.find("\nabcd\n"));
+    assert_eq!(Some(Match::must(0, 1..5)), RE.find("\nabcd wxyz\n"));
+    assert_eq!(Some(Match::must(1, 1..7)), RE.find("\n@abcd@\n"));
+    assert_eq!(Some(Match::must(2, 0..6)), RE.find("@abcd@\r\n"));
+    assert_eq!(Some(Match::must(1, 2..8)), RE.find("\r\n@abcd@"));
+    assert_eq!(Some(Match::must(2, 2..8)), RE.find("\r\n@abcd@\r\n"));
+
+    // Fails because we have heuristic support for Unicode word boundaries
+    // enabled.
+    assert!(RE.try_search(&Input::new(b"\xFF@abcd@\xFF")).is_err());
+}
diff --git a/regex-automata/tests/gen/dense/multi_pattern_v2.rs b/regex-automata/tests/gen/dense/multi_pattern_v2.rs
new file mode 100644
index 0000000000..a95fd204b5
--- /dev/null
+++ b/regex-automata/tests/gen/dense/multi_pattern_v2.rs
@@ -0,0 +1,43 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//     regex-cli generate serialize dense regex MULTI_PATTERN_V2 tests/gen/dense/ --rustfmt --safe --starts-for-each-pattern --specialize-start-states --start-kind both --unicode-word-boundary --minimize \b[a-zA-Z]+\b (?m)^\S+$ (?Rm)^\S+$
+//
+// regex-cli 0.0.1 is available on crates.io.
+
+use regex_automata::{
+    dfa::{dense::DFA, regex::Regex},
+    util::{lazy::Lazy, wire::AlignAs},
+};
+
+pub static MULTI_PATTERN_V2: Lazy<Regex<DFA<&'static [u32]>>> =
+    Lazy::new(|| {
+        let dfafwd = {
+            static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {
+                _align: [],
+                #[cfg(target_endian = "big")]
+                bytes: *include_bytes!("multi_pattern_v2_fwd.bigendian.dfa"),
+                #[cfg(target_endian = "little")]
+                bytes: *include_bytes!(
+                    "multi_pattern_v2_fwd.littleendian.dfa"
+                ),
+            };
+            DFA::from_bytes(&ALIGNED.bytes)
+                .expect("serialized forward DFA should be valid")
+                .0
+        };
+        let dfarev = {
+            static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {
+                _align: [],
+                #[cfg(target_endian = "big")]
+                bytes: *include_bytes!("multi_pattern_v2_rev.bigendian.dfa"),
+                #[cfg(target_endian = "little")]
+                bytes: *include_bytes!(
+                    "multi_pattern_v2_rev.littleendian.dfa"
+                ),
+            };
+            DFA::from_bytes(&ALIGNED.bytes)
+                .expect("serialized reverse DFA should be valid")
+                .0
+        };
+        Regex::builder().build_from_dfas(dfafwd, dfarev)
+    });
diff --git a/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.bigendian.dfa b/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.bigendian.dfa
new file mode 100644
index 0000000000..6d6e040c36
Binary files /dev/null and b/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.bigendian.dfa differ
diff --git a/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.littleendian.dfa b/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.littleendian.dfa
new file mode 100644
index 0000000000..a1f4b3da15
Binary files /dev/null and b/regex-automata/tests/gen/dense/multi_pattern_v2_fwd.littleendian.dfa differ
diff --git a/regex-automata/tests/gen/dense/multi_pattern_v2_rev.bigendian.dfa b/regex-automata/tests/gen/dense/multi_pattern_v2_rev.bigendian.dfa
new file mode 100644
index 0000000000..74f74ec2a9
Binary files /dev/null and b/regex-automata/tests/gen/dense/multi_pattern_v2_rev.bigendian.dfa differ
diff --git a/regex-automata/tests/gen/dense/multi_pattern_v2_rev.littleendian.dfa b/regex-automata/tests/gen/dense/multi_pattern_v2_rev.littleendian.dfa
new file mode 100644
index 0000000000..663bdb9ead
Binary files /dev/null and b/regex-automata/tests/gen/dense/multi_pattern_v2_rev.littleendian.dfa differ
diff --git a/regex-automata/tests/gen/mod.rs b/regex-automata/tests/gen/mod.rs
new file mode 100644
index 0000000000..960cb4251a
--- /dev/null
+++ b/regex-automata/tests/gen/mod.rs
@@ -0,0 +1,2 @@
+mod dense;
+mod sparse;
diff --git a/regex-automata/tests/gen/sparse/mod.rs b/regex-automata/tests/gen/sparse/mod.rs
new file mode 100644
index 0000000000..b4365d4e19
--- /dev/null
+++ b/regex-automata/tests/gen/sparse/mod.rs
@@ -0,0 +1,22 @@
+use regex_automata::{Input, Match};
+
+mod multi_pattern_v2;
+
+#[test]
+fn multi_pattern_v2() {
+    use multi_pattern_v2::MULTI_PATTERN_V2 as RE;
+
+    assert_eq!(Some(Match::must(0, 0..4)), RE.find("abcd"));
+    assert_eq!(Some(Match::must(0, 2..6)), RE.find("@ abcd @"));
+    assert_eq!(Some(Match::must(1, 0..6)), RE.find("@abcd@"));
+    assert_eq!(Some(Match::must(0, 1..5)), RE.find("\nabcd\n"));
+    assert_eq!(Some(Match::must(0, 1..5)), RE.find("\nabcd wxyz\n"));
+    assert_eq!(Some(Match::must(1, 1..7)), RE.find("\n@abcd@\n"));
+    assert_eq!(Some(Match::must(2, 0..6)), RE.find("@abcd@\r\n"));
+    assert_eq!(Some(Match::must(1, 2..8)), RE.find("\r\n@abcd@"));
+    assert_eq!(Some(Match::must(2, 2..8)), RE.find("\r\n@abcd@\r\n"));
+
+    // Fails because we have heuristic support for Unicode word boundaries
+    // enabled.
+    assert!(RE.try_search(&Input::new(b"\xFF@abcd@\xFF")).is_err());
+}
diff --git a/regex-automata/tests/gen/sparse/multi_pattern_v2.rs b/regex-automata/tests/gen/sparse/multi_pattern_v2.rs
new file mode 100644
index 0000000000..911e3f5ddc
--- /dev/null
+++ b/regex-automata/tests/gen/sparse/multi_pattern_v2.rs
@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//     regex-cli generate serialize sparse regex MULTI_PATTERN_V2 regex-automata/tests/gen/sparse/ --rustfmt --safe --starts-for-each-pattern --specialize-start-states --start-kind both --unicode-word-boundary --minimize \b[a-zA-Z]+\b (?m)^\S+$ (?Rm)^\S+$
+//
+// regex-cli 0.0.1 is available on crates.io.
+
+use regex_automata::{
+    dfa::{regex::Regex, sparse::DFA},
+    util::lazy::Lazy,
+};
+
+pub static MULTI_PATTERN_V2: Lazy<Regex<DFA<&'static [u8]>>> =
+    Lazy::new(|| {
+        let dfafwd = {
+            #[cfg(target_endian = "big")]
+            static BYTES: &'static [u8] =
+                include_bytes!("multi_pattern_v2_fwd.bigendian.dfa");
+            #[cfg(target_endian = "little")]
+            static BYTES: &'static [u8] =
+                include_bytes!("multi_pattern_v2_fwd.littleendian.dfa");
+            DFA::from_bytes(BYTES)
+                .expect("serialized forward DFA should be valid")
+                .0
+        };
+        let dfarev = {
+            #[cfg(target_endian = "big")]
+            static BYTES: &'static [u8] =
+                include_bytes!("multi_pattern_v2_rev.bigendian.dfa");
+            #[cfg(target_endian = "little")]
+            static BYTES: &'static [u8] =
+                include_bytes!("multi_pattern_v2_rev.littleendian.dfa");
+            DFA::from_bytes(BYTES)
+                .expect("serialized reverse DFA should be valid")
+                .0
+        };
+        Regex::builder().build_from_dfas(dfafwd, dfarev)
+    });
diff --git a/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.bigendian.dfa b/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.bigendian.dfa
new file mode 100644
index 0000000000..aa04f63162
Binary files /dev/null and b/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.bigendian.dfa differ
diff --git a/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.littleendian.dfa b/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.littleendian.dfa
new file mode 100644
index 0000000000..c27d92abe1
Binary files /dev/null and b/regex-automata/tests/gen/sparse/multi_pattern_v2_fwd.littleendian.dfa differ
diff --git a/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.bigendian.dfa b/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.bigendian.dfa
new file mode 100644
index 0000000000..89867d30f6
Binary files /dev/null and b/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.bigendian.dfa differ
diff --git a/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.littleendian.dfa b/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.littleendian.dfa
new file mode 100644
index 0000000000..c0ca807f89
Binary files /dev/null and b/regex-automata/tests/gen/sparse/multi_pattern_v2_rev.littleendian.dfa differ
diff --git a/regex-automata/tests/hybrid/api.rs b/regex-automata/tests/hybrid/api.rs
new file mode 100644
index 0000000000..e82d808e34
--- /dev/null
+++ b/regex-automata/tests/hybrid/api.rs
@@ -0,0 +1,171 @@
+use std::error::Error;
+
+use regex_automata::{
+    hybrid::dfa::{OverlappingState, DFA},
+    nfa::thompson,
+    HalfMatch, Input, MatchError,
+};
+
+// Tests that too many cache resets cause the lazy DFA to quit.
+//
+// We only test this on 64-bit because the test is gingerly crafted based on
+// implementation details of cache sizes. It's not a great test because of
+// that, but it does check some interesting properties around how positions are
+// reported when a search "gives up."
+//
+// NOTE: If you change something in lazy DFA implementation that causes this
+// test to fail by reporting different "gave up" positions, then it's generally
+// okay to update the positions in the test below as long as you're sure your
+// changes are correct. Namely, it is expected that if there are changes in the
+// cache size (or changes in how big things are inside the cache), then its
+// utilization may change slightly and thus impact where a search gives up.
+// Precisely where a search gives up is not an API guarantee, so changing the
+// offsets here is OK.
+#[test]
+#[cfg(target_pointer_width = "64")]
+#[cfg(not(miri))]
+fn too_many_cache_resets_cause_quit() -> Result<(), Box<dyn Error>> {
+    // This is a carefully chosen regex. The idea is to pick one that requires
+    // some decent number of states (hence the bounded repetition). But we
+    // specifically choose to create a class with an ASCII letter and a
+    // non-ASCII letter so that we can check that no new states are created
+    // once the cache is full. Namely, if we fill up the cache on a haystack
+    // of 'a's, then in order to match one 'β', a new state will need to be
+    // created since a 'β' is encoded with multiple bytes.
+    //
+    // So we proceed by "filling" up the cache by searching a haystack of just
+    // 'a's. The cache won't have enough room to add enough states to find the
+    // match (because of the bounded repetition), which should result in it
+    // giving up before it finds a match.
+    //
+    // Since there's now no more room to create states, we search a haystack
+    // of 'β' and confirm that it gives up immediately.
+    let pattern = r"[aβ]{99}";
+    let dfa = DFA::builder()
+        .configure(
+            // Configure it so that we have the minimum cache capacity
+            // possible. And that if any resets occur, the search quits.
+            DFA::config()
+                .skip_cache_capacity_check(true)
+                .cache_capacity(0)
+                .minimum_cache_clear_count(Some(0)),
+        )
+        .thompson(thompson::NFA::config())
+        .build(pattern)?;
+    let mut cache = dfa.create_cache();
+
+    let haystack = "a".repeat(101).into_bytes();
+    let err = MatchError::gave_up(25);
+    // Notice that we make the same amount of progress in each search! That's
+    // because the cache is reused and already has states to handle the first
+    // N bytes.
+    assert_eq!(
+        Err(err.clone()),
+        dfa.try_search_fwd(&mut cache, &Input::new(&haystack))
+    );
+    assert_eq!(
+        Err(err.clone()),
+        dfa.try_search_overlapping_fwd(
+            &mut cache,
+            &Input::new(&haystack),
+            &mut OverlappingState::start()
+        ),
+    );
+
+    let haystack = "β".repeat(101).into_bytes();
+    let err = MatchError::gave_up(2);
+    assert_eq!(
+        Err(err),
+        dfa.try_search_fwd(&mut cache, &Input::new(&haystack))
+    );
+    // no need to test that other find routines quit, since we did that above
+
+    // OK, if we reset the cache, then we should be able to create more states
+    // and make more progress with searching for betas.
+    cache.reset(&dfa);
+    let err = MatchError::gave_up(27);
+    assert_eq!(
+        Err(err),
+        dfa.try_search_fwd(&mut cache, &Input::new(&haystack))
+    );
+
+    // ... switching back to ASCII still makes progress since it just needs to
+    // set transitions on existing states!
+    let haystack = "a".repeat(101).into_bytes();
+    let err = MatchError::gave_up(13);
+    assert_eq!(
+        Err(err),
+        dfa.try_search_fwd(&mut cache, &Input::new(&haystack))
+    );
+
+    Ok(())
+}
+
+// Tests that quit bytes in the forward direction work correctly.
+#[test]
+fn quit_fwd() -> Result<(), Box<dyn Error>> {
+    let dfa = DFA::builder()
+        .configure(DFA::config().quit(b'x', true))
+        .build("[[:word:]]+$")?;
+    let mut cache = dfa.create_cache();
+
+    assert_eq!(
+        dfa.try_search_fwd(&mut cache, &Input::new("abcxyz")),
+        Err(MatchError::quit(b'x', 3)),
+    );
+    assert_eq!(
+        dfa.try_search_overlapping_fwd(
+            &mut cache,
+            &Input::new(b"abcxyz"),
+            &mut OverlappingState::start()
+        ),
+        Err(MatchError::quit(b'x', 3)),
+    );
+
+    Ok(())
+}
+
+// Tests that quit bytes in the reverse direction work correctly.
+#[test]
+fn quit_rev() -> Result<(), Box<dyn Error>> {
+    let dfa = DFA::builder()
+        .configure(DFA::config().quit(b'x', true))
+        .thompson(thompson::Config::new().reverse(true))
+        .build("^[[:word:]]+")?;
+    let mut cache = dfa.create_cache();
+
+    assert_eq!(
+        dfa.try_search_rev(&mut cache, &Input::new("abcxyz")),
+        Err(MatchError::quit(b'x', 3)),
+    );
+
+    Ok(())
+}
+
+// Tests that if we heuristically enable Unicode word boundaries but then
+// instruct that a non-ASCII byte should NOT be a quit byte, then the builder
+// will panic.
+#[test]
+#[should_panic]
+fn quit_panics() {
+    DFA::config().unicode_word_boundary(true).quit(b'\xFF', false);
+}
+
+// This tests an intesting case where even if the Unicode word boundary option
+// is disabled, setting all non-ASCII bytes to be quit bytes will cause Unicode
+// word boundaries to be enabled.
+#[test]
+fn unicode_word_implicitly_works() -> Result<(), Box<dyn Error>> {
+    let mut config = DFA::config();
+    for b in 0x80..=0xFF {
+        config = config.quit(b, true);
+    }
+    let dfa = DFA::builder().configure(config).build(r"\b")?;
+    let mut cache = dfa.create_cache();
+    let expected = HalfMatch::must(0, 1);
+    assert_eq!(
+        Ok(Some(expected)),
+        dfa.try_search_fwd(&mut cache, &Input::new(" a")),
+    );
+    Ok(())
+}
diff --git a/regex-automata/tests/hybrid/mod.rs b/regex-automata/tests/hybrid/mod.rs
new file mode 100644
index 0000000000..36667d09cc
--- /dev/null
+++ b/regex-automata/tests/hybrid/mod.rs
@@ -0,0 +1,3 @@
+mod api;
+#[cfg(not(miri))]
+mod suite;
diff --git a/regex-automata/tests/hybrid/suite.rs b/regex-automata/tests/hybrid/suite.rs
new file mode 100644
index 0000000000..4aaca66984
--- /dev/null
+++ b/regex-automata/tests/hybrid/suite.rs
@@ -0,0 +1,347 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        hybrid::{
+            dfa::{OverlappingState, DFA},
+            regex::{self, Regex},
+        },
+        nfa::thompson,
+        util::{prefilter::Prefilter, syntax},
+        Anchored, Input, PatternSet,
+    },
+    regex_test::{
+        CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+        TestRunner,
+    },
+};
+
+use crate::{create_input, suite, untestify_kind};
+
+const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let builder = Regex::builder();
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA with prefilters enabled.
+#[test]
+fn prefilter() -> Result<()> {
+    let my_compiler = |test: &RegexTest, regexes: &[String]| {
+        // Parse regexes as HIRs so we can get literals to build a prefilter.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+        let kind = match untestify_kind(test.match_kind()) {
+            None => return Ok(CompiledRegex::skip()),
+            Some(kind) => kind,
+        };
+        let pre = Prefilter::from_hirs_prefix(kind, &hirs);
+        let mut builder = Regex::builder();
+        builder.dfa(DFA::config().prefilter(pre));
+        compiler(builder)(test, regexes)
+    };
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), my_compiler)
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA with NFA shrinking enabled.
+///
+/// This is *usually* not the configuration one wants for a lazy DFA. NFA
+/// shrinking is mostly only advantageous when building a full DFA since it
+/// can sharply decrease the amount of time determinization takes. But NFA
+/// shrinking is itself otherwise fairly expensive currently. Since a lazy DFA
+/// has no compilation time (other than for building the NFA of course) before
+/// executing a search, it's usually worth it to forgo NFA shrinking.
+///
+/// Nevertheless, we test to make sure everything is OK with NFA shrinking. As
+/// a bonus, there are some tests we don't need to skip because they now fit in
+/// the default cache capacity.
+#[test]
+fn nfa_shrink() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.thompson(thompson::Config::new().shrink(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
+/// tests.
+#[test]
+fn starts_for_each_pattern() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dfa(DFA::config().starts_for_each_pattern(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when 'specialize_start_states' is enabled.
+#[test]
+fn specialize_start_states() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dfa(DFA::config().specialize_start_states(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when byte classes are disabled.
+///
+/// N.B. Disabling byte classes doesn't avoid any indirection at search time.
+/// All it does is cause every byte value to be its own distinct equivalence
+/// class.
+#[test]
+fn no_byte_classes() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dfa(DFA::config().byte_classes(false));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests that hybrid NFA/DFA never clears its cache for any test with the
+/// default capacity.
+///
+/// N.B. If a regex suite test is added that causes the cache to be cleared,
+/// then this should just skip that test. (Which can be done by calling the
+/// 'blacklist' method on 'TestRunner'.)
+#[test]
+fn no_cache_clearing() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.dfa(DFA::config().minimum_cache_clear_count(Some(0)));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        // Without NFA shrinking, this test blows the default cache capacity.
+        .blacklist("expensive/regression-many-repeat-no-stack-overflow")
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the hybrid NFA/DFA when the minimum cache capacity is set.
+#[test]
+fn min_cache_capacity() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder
+        .dfa(DFA::config().cache_capacity(0).skip_cache_capacity_check(true));
+    TestRunner::new()?
+        .expand(EXPANSIONS, |t| t.compiles())
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+fn compiler(
+    mut builder: regex::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        // Parse regexes as HIRs for some analysis below.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+
+        // Check if our regex contains things that aren't supported by DFAs.
+        // That is, Unicode word boundaries when searching non-ASCII text.
+        if !test.haystack().is_ascii() {
+            for hir in hirs.iter() {
+                if hir.properties().look_set().contains_word_unicode() {
+                    return Ok(CompiledRegex::skip());
+                }
+            }
+        }
+        if !configure_regex_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        let re = builder.build_many(&regexes)?;
+        let mut cache = re.create_cache();
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, &mut cache, test)
+        }))
+    }
+}
+
+fn run_test(
+    re: &Regex,
+    cache: &mut regex::Cache,
+    test: &RegexTest,
+) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => {
+            TestResult::matched(re.is_match(cache, input.earliest(true)))
+        }
+        "find" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                let input =
+                    input.earliest(test.search_kind() == SearchKind::Earliest);
+                TestResult::matches(
+                    re.find_iter(cache, input)
+                        .take(test.match_limit().unwrap_or(std::usize::MAX))
+                        .map(|m| Match {
+                            id: m.pattern().as_usize(),
+                            span: Span { start: m.start(), end: m.end() },
+                        }),
+                )
+            }
+            SearchKind::Overlapping => {
+                try_search_overlapping(re, cache, &input).unwrap()
+            }
+        },
+        "which" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Leftmost => {
+                // There are no "which" APIs for standard searches.
+                TestResult::skip()
+            }
+            SearchKind::Overlapping => {
+                let dfa = re.forward();
+                let cache = cache.as_parts_mut().0;
+                let mut patset = PatternSet::new(dfa.pattern_len());
+                dfa.try_which_overlapping_matches(cache, &input, &mut patset)
+                    .unwrap();
+                TestResult::which(patset.iter().map(|p| p.as_usize()))
+            }
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_regex_builder(
+    test: &RegexTest,
+    builder: &mut regex::Builder,
+) -> bool {
+    let match_kind = match untestify_kind(test.match_kind()) {
+        None => return false,
+        Some(k) => k,
+    };
+
+    let mut dfa_config =
+        DFA::config().match_kind(match_kind).unicode_word_boundary(true);
+    // When doing an overlapping search, we might try to find the start of each
+    // match with a custom search routine. In that case, we need to tell the
+    // reverse search (for the start offset) which pattern to look for. The
+    // only way that API works is when anchored starting states are compiled
+    // for each pattern. This does technically also enable it for the forward
+    // DFA, but we're okay with that.
+    if test.search_kind() == SearchKind::Overlapping {
+        dfa_config = dfa_config.starts_for_each_pattern(true);
+    }
+    builder
+        .syntax(config_syntax(test))
+        .thompson(config_thompson(test))
+        .dfa(dfa_config);
+    true
+}
+
+/// Configuration of a Thompson NFA compiler from a regex test.
+fn config_thompson(test: &RegexTest) -> thompson::Config {
+    let mut lookm = regex_automata::util::look::LookMatcher::new();
+    lookm.set_line_terminator(test.line_terminator());
+    thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+}
+
+/// Configuration of the regex parser from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
+
+/// Execute an overlapping search, and for each match found, also find its
+/// overlapping starting positions.
+///
+/// N.B. This routine used to be part of the crate API, but 1) it wasn't clear
+/// to me how useful it was and 2) it wasn't clear to me what its semantics
+/// should be. In particular, a potentially surprising footgun of this routine
+/// that it is worst case *quadratic* in the size of the haystack. Namely, it's
+/// possible to report a match at every position, and for every such position,
+/// scan all the way to the beginning of the haystack to find the starting
+/// position. Typical leftmost non-overlapping searches don't suffer from this
+/// because, well, matches can't overlap. So subsequent searches after a match
+/// is found don't revisit previously scanned parts of the haystack.
+///
+/// Its semantics can be strange for other reasons too. For example, given
+/// the regex '.*' and the haystack 'zz', the full set of overlapping matches
+/// is: [0, 0], [1, 1], [0, 1], [2, 2], [1, 2], [0, 2]. The ordering of
+/// those matches is quite strange, but makes sense when you think about the
+/// implementation: an end offset is found left-to-right, and then one or more
+/// starting offsets are found right-to-left.
+///
+/// Nevertheless, we provide this routine in our test suite because it's
+/// useful to test the low level DFA overlapping search and our test suite
+/// is written in a way that requires starting offsets.
+fn try_search_overlapping(
+    re: &Regex,
+    cache: &mut regex::Cache,
+    input: &Input<'_>,
+) -> Result<TestResult> {
+    let mut matches = vec![];
+    let mut fwd_state = OverlappingState::start();
+    let (fwd_dfa, rev_dfa) = (re.forward(), re.reverse());
+    let (fwd_cache, rev_cache) = cache.as_parts_mut();
+    while let Some(end) = {
+        fwd_dfa.try_search_overlapping_fwd(
+            fwd_cache,
+            input,
+            &mut fwd_state,
+        )?;
+        fwd_state.get_match()
+    } {
+        let revsearch = input
+            .clone()
+            .range(input.start()..end.offset())
+            .anchored(Anchored::Pattern(end.pattern()))
+            .earliest(false);
+        let mut rev_state = OverlappingState::start();
+        while let Some(start) = {
+            rev_dfa.try_search_overlapping_rev(
+                rev_cache,
+                &revsearch,
+                &mut rev_state,
+            )?;
+            rev_state.get_match()
+        } {
+            let span = Span { start: start.offset(), end: end.offset() };
+            let mat = Match { id: end.pattern().as_usize(), span };
+            matches.push(mat);
+        }
+    }
+    Ok(TestResult::matches(matches))
+}
diff --git a/regex-automata/tests/lib.rs b/regex-automata/tests/lib.rs
new file mode 100644
index 0000000000..1465e51eb7
--- /dev/null
+++ b/regex-automata/tests/lib.rs
@@ -0,0 +1,114 @@
+// We have a similar config in the regex-automata crate root. Basically, it is
+// just too annoying to deal with dead code when a subset of features is
+// enabled.
+#![cfg_attr(
+    not(all(
+        feature = "std",
+        feature = "nfa",
+        feature = "dfa",
+        feature = "hybrid",
+        feature = "perf-literal-substring",
+        feature = "perf-literal-multisubstring",
+    )),
+    allow(dead_code, unused_imports, unused_variables)
+)]
+// Similar deal with Miri. Just let dead code warnings be.
+#![cfg_attr(miri, allow(dead_code, unused_imports, unused_variables))]
+
+#[cfg(any(feature = "dfa-search", feature = "dfa-onepass"))]
+mod dfa;
+#[cfg(feature = "dfa-search")]
+mod fuzz;
+#[cfg(feature = "dfa-search")]
+mod gen;
+#[cfg(feature = "hybrid")]
+mod hybrid;
+#[cfg(feature = "meta")]
+mod meta;
+#[cfg(any(feature = "nfa-backtrack", feature = "nfa-pikevm"))]
+mod nfa;
+
+fn suite() -> anyhow::Result<regex_test::RegexTests> {
+    let _ = env_logger::try_init();
+
+    let mut tests = regex_test::RegexTests::new();
+    macro_rules! load {
+        ($name:expr) => {{
+            const DATA: &[u8] =
+                include_bytes!(concat!("../../testdata/", $name, ".toml"));
+            tests.load_slice($name, DATA)?;
+        }};
+    }
+
+    load!("anchored");
+    load!("bytes");
+    load!("crazy");
+    load!("crlf");
+    load!("earliest");
+    load!("empty");
+    load!("expensive");
+    load!("flags");
+    load!("iter");
+    load!("leftmost-all");
+    load!("line-terminator");
+    load!("misc");
+    load!("multiline");
+    load!("no-unicode");
+    load!("overlapping");
+    load!("regression");
+    load!("set");
+    load!("substring");
+    load!("unicode");
+    load!("utf8");
+    load!("word-boundary");
+    load!("fowler/basic");
+    load!("fowler/nullsubexpr");
+    load!("fowler/repetition");
+
+    Ok(tests)
+}
+
+/// Configure a regex_automata::Input with the given test configuration.
+fn create_input<'h>(
+    test: &'h regex_test::RegexTest,
+) -> regex_automata::Input<'h> {
+    use regex_automata::Anchored;
+
+    let bounds = test.bounds();
+    let anchored = if test.anchored() { Anchored::Yes } else { Anchored::No };
+    regex_automata::Input::new(test.haystack())
+        .range(bounds.start..bounds.end)
+        .anchored(anchored)
+}
+
+/// Convert capture matches into the test suite's capture values.
+///
+/// The given captures must represent a valid match, where the first capturing
+/// group has a non-None span. Otherwise this panics.
+fn testify_captures(
+    caps: &regex_automata::util::captures::Captures,
+) -> regex_test::Captures {
+    assert!(caps.is_match(), "expected captures to represent a match");
+    let spans = caps.iter().map(|group| {
+        group.map(|m| regex_test::Span { start: m.start, end: m.end })
+    });
+    // These unwraps are OK because we assume our 'caps' represents a match,
+    // and a match always gives a non-zero number of groups with the first
+    // group being non-None.
+    regex_test::Captures::new(caps.pattern().unwrap().as_usize(), spans)
+        .unwrap()
+}
+
+/// Convert a test harness match kind to a regex-automata match kind. If
+/// regex-automata doesn't support the harness kind, then `None` is returned.
+fn untestify_kind(
+    kind: regex_test::MatchKind,
+) -> Option<regex_automata::MatchKind> {
+    match kind {
+        regex_test::MatchKind::All => Some(regex_automata::MatchKind::All),
+        regex_test::MatchKind::LeftmostFirst => {
+            Some(regex_automata::MatchKind::LeftmostFirst)
+        }
+        regex_test::MatchKind::LeftmostLongest => None,
+    }
+}
diff --git a/regex-automata/tests/meta/mod.rs b/regex-automata/tests/meta/mod.rs
new file mode 100644
index 0000000000..9d6ab475ef
--- /dev/null
+++ b/regex-automata/tests/meta/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(not(miri))]
+mod suite;
diff --git a/regex-automata/tests/meta/suite.rs b/regex-automata/tests/meta/suite.rs
new file mode 100644
index 0000000000..20f97b4bb9
--- /dev/null
+++ b/regex-automata/tests/meta/suite.rs
@@ -0,0 +1,200 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        meta::{self, Regex},
+        util::syntax,
+        MatchKind, PatternSet,
+    },
+    regex_test::{
+        CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+        TestRunner,
+    },
+};
+
+use crate::{create_input, suite, testify_captures};
+
+const BLACKLIST: &[&str] = &[
+    // These 'earliest' tests are blacklisted because the meta searcher doesn't
+    // give the same offsets that the test expects. This is legal because the
+    // 'earliest' routines don't guarantee a particular match offset other
+    // than "the earliest the regex engine can report a match." Some regex
+    // engines will quit earlier than others. The backtracker, for example,
+    // can't really quit before finding the full leftmost-first match. Many of
+    // the literal searchers also don't have the ability to quit fully or it's
+    // otherwise not worth doing. (A literal searcher not quitting as early as
+    // possible usually means looking at a few more bytes. That's no biggie.)
+    "earliest/",
+];
+
+/// Tests the default configuration of the meta regex engine.
+#[test]
+fn default() -> Result<()> {
+    let builder = Regex::builder();
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(BLACKLIST)
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the default configuration minus the full DFA.
+#[test]
+fn no_dfa() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.configure(Regex::config().dfa(false));
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(BLACKLIST)
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the default configuration minus the full DFA and lazy DFA.
+#[test]
+fn no_dfa_hybrid() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.configure(Regex::config().dfa(false).hybrid(false));
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(BLACKLIST)
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the default configuration minus the full DFA, lazy DFA and one-pass
+/// DFA.
+#[test]
+fn no_dfa_hybrid_onepass() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.configure(Regex::config().dfa(false).hybrid(false).onepass(false));
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(BLACKLIST)
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+/// Tests the default configuration minus the full DFA, lazy DFA, one-pass
+/// DFA and backtracker.
+#[test]
+fn no_dfa_hybrid_onepass_backtrack() -> Result<()> {
+    let mut builder = Regex::builder();
+    builder.configure(
+        Regex::config()
+            .dfa(false)
+            .hybrid(false)
+            .onepass(false)
+            .backtrack(false),
+    );
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(BLACKLIST)
+        .test_iter(suite()?.iter(), compiler(builder))
+        .assert();
+    Ok(())
+}
+
+fn compiler(
+    mut builder: meta::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        if !configure_meta_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        let re = builder.build_many(&regexes)?;
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, test)
+        }))
+    }
+}
+
+fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(input)),
+        "find" => match test.search_kind() {
+            SearchKind::Earliest => TestResult::matches(
+                re.find_iter(input.earliest(true))
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    }),
+            ),
+            SearchKind::Leftmost => TestResult::matches(
+                re.find_iter(input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    }),
+            ),
+            SearchKind::Overlapping => {
+                let mut patset = PatternSet::new(re.pattern_len());
+                re.which_overlapping_matches(&input, &mut patset);
+                TestResult::which(patset.iter().map(|p| p.as_usize()))
+            }
+        },
+        "captures" => match test.search_kind() {
+            SearchKind::Earliest => {
+                let it = re
+                    .captures_iter(input.earliest(true))
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|caps| testify_captures(&caps));
+                TestResult::captures(it)
+            }
+            SearchKind::Leftmost => {
+                let it = re
+                    .captures_iter(input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|caps| testify_captures(&caps));
+                TestResult::captures(it)
+            }
+            SearchKind::Overlapping => {
+                // There is no overlapping regex API that supports captures.
+                TestResult::skip()
+            }
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_meta_builder(
+    test: &RegexTest,
+    builder: &mut meta::Builder,
+) -> bool {
+    let match_kind = match test.match_kind() {
+        regex_test::MatchKind::All => MatchKind::All,
+        regex_test::MatchKind::LeftmostFirst => MatchKind::LeftmostFirst,
+        regex_test::MatchKind::LeftmostLongest => return false,
+    };
+    let meta_config = Regex::config()
+        .match_kind(match_kind)
+        .utf8_empty(test.utf8())
+        .line_terminator(test.line_terminator());
+    builder.configure(meta_config).syntax(config_syntax(test));
+    true
+}
+
+/// Configuration of the regex parser from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
diff --git a/regex-automata/tests/nfa/mod.rs b/regex-automata/tests/nfa/mod.rs
new file mode 100644
index 0000000000..3268621473
--- /dev/null
+++ b/regex-automata/tests/nfa/mod.rs
@@ -0,0 +1 @@
+mod thompson;
diff --git a/regex-automata/tests/nfa/thompson/backtrack/mod.rs b/regex-automata/tests/nfa/thompson/backtrack/mod.rs
new file mode 100644
index 0000000000..9d6ab475ef
--- /dev/null
+++ b/regex-automata/tests/nfa/thompson/backtrack/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(not(miri))]
+mod suite;
diff --git a/regex-automata/tests/nfa/thompson/backtrack/suite.rs b/regex-automata/tests/nfa/thompson/backtrack/suite.rs
new file mode 100644
index 0000000000..bce0eef408
--- /dev/null
+++ b/regex-automata/tests/nfa/thompson/backtrack/suite.rs
@@ -0,0 +1,213 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        nfa::thompson::{
+            self,
+            backtrack::{self, BoundedBacktracker},
+            NFA,
+        },
+        util::{prefilter::Prefilter, syntax},
+        Input,
+    },
+    regex_test::{
+        CompiledRegex, Match, MatchKind, RegexTest, SearchKind, Span,
+        TestResult, TestRunner,
+    },
+};
+
+use crate::{create_input, suite, testify_captures};
+
+/// Tests the default configuration of the bounded backtracker.
+#[test]
+fn default() -> Result<()> {
+    let builder = BoundedBacktracker::builder();
+    let mut runner = TestRunner::new()?;
+    runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+    // At the time of writing, every regex search in the test suite fits
+    // into the backtracker's default visited capacity (except for the
+    // blacklisted tests below). If regexes are added that blow that capacity,
+    // then they should be blacklisted here. A tempting alternative is to
+    // automatically skip them by checking the haystack length against
+    // BoundedBacktracker::max_haystack_len, but that could wind up hiding
+    // interesting failure modes. e.g., If the visited capacity is somehow
+    // wrong or smaller than it should be.
+    runner.blacklist("expensive/backtrack-blow-visited-capacity");
+    runner.test_iter(suite()?.iter(), compiler(builder)).assert();
+    Ok(())
+}
+
+/// Tests the backtracker with prefilters enabled.
+#[test]
+fn prefilter() -> Result<()> {
+    let my_compiler = |test: &RegexTest, regexes: &[String]| {
+        // Parse regexes as HIRs so we can get literals to build a prefilter.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+        // We can always select leftmost-first here because the backtracker
+        // only supports leftmost-first matching.
+        let pre = Prefilter::from_hirs_prefix(
+            regex_automata::MatchKind::LeftmostFirst,
+            &hirs,
+        );
+        let mut builder = BoundedBacktracker::builder();
+        builder.configure(BoundedBacktracker::config().prefilter(pre));
+        compiler(builder)(test, regexes)
+    };
+    let mut runner = TestRunner::new()?;
+    runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+    runner.blacklist("expensive/backtrack-blow-visited-capacity");
+    runner.test_iter(suite()?.iter(), my_compiler).assert();
+    Ok(())
+}
+
+/// Tests the bounded backtracker when its visited capacity is set to its
+/// minimum amount.
+#[test]
+fn min_visited_capacity() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+    runner
+        .test_iter(suite()?.iter(), move |test, regexes| {
+            let nfa = NFA::compiler()
+                .configure(config_thompson(test))
+                .syntax(config_syntax(test))
+                .build_many(&regexes)?;
+            let mut builder = BoundedBacktracker::builder();
+            if !configure_backtrack_builder(test, &mut builder) {
+                return Ok(CompiledRegex::skip());
+            }
+            // Setup the bounded backtracker so that its visited capacity is
+            // the absolute minimum required for the test's haystack.
+            builder.configure(BoundedBacktracker::config().visited_capacity(
+                backtrack::min_visited_capacity(
+                    &nfa,
+                    &Input::new(test.haystack()),
+                ),
+            ));
+
+            let re = builder.build_from_nfa(nfa)?;
+            let mut cache = re.create_cache();
+            Ok(CompiledRegex::compiled(move |test| -> TestResult {
+                run_test(&re, &mut cache, test)
+            }))
+        })
+        .assert();
+    Ok(())
+}
+
+fn compiler(
+    mut builder: backtrack::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        if !configure_backtrack_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        let re = builder.build_many(&regexes)?;
+        let mut cache = re.create_cache();
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, &mut cache, test)
+        }))
+    }
+}
+
+fn run_test(
+    re: &BoundedBacktracker,
+    cache: &mut backtrack::Cache,
+    test: &RegexTest,
+) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Overlapping => {
+                TestResult::skip()
+            }
+            SearchKind::Leftmost => {
+                let input = input.earliest(true);
+                TestResult::matched(re.try_is_match(cache, input).unwrap())
+            }
+        },
+        "find" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Overlapping => {
+                TestResult::skip()
+            }
+            SearchKind::Leftmost => TestResult::matches(
+                re.try_find_iter(cache, input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|result| result.unwrap())
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    }),
+            ),
+        },
+        "captures" => match test.search_kind() {
+            SearchKind::Earliest | SearchKind::Overlapping => {
+                TestResult::skip()
+            }
+            SearchKind::Leftmost => TestResult::captures(
+                re.try_captures_iter(cache, input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|result| result.unwrap())
+                    .map(|caps| testify_captures(&caps)),
+            ),
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_backtrack_builder(
+    test: &RegexTest,
+    builder: &mut backtrack::Builder,
+) -> bool {
+    match (test.search_kind(), test.match_kind()) {
+        // For testing the standard search APIs. This is the only supported
+        // configuration for the backtracker.
+        (SearchKind::Leftmost, MatchKind::LeftmostFirst) => {}
+        // Overlapping APIs not supported at all for backtracker.
+        (SearchKind::Overlapping, _) => return false,
+        // Backtracking doesn't really support the notion of 'earliest'.
+        // Namely, backtracking already works by returning as soon as it knows
+        // it has found a match. It just so happens that this corresponds to
+        // the standard 'leftmost' formulation.
+        //
+        // The 'earliest' definition in this crate does indeed permit this
+        // behavior, so this is "fine," but our test suite specifically looks
+        // for the earliest position at which a match is known, which our
+        // finite automata based regex engines have no problem providing. So
+        // for backtracking, we just skip these tests.
+        (SearchKind::Earliest, _) => return false,
+        // For backtracking, 'all' semantics don't really make sense.
+        (_, MatchKind::All) => return false,
+        // Not supported at all in regex-automata.
+        (_, MatchKind::LeftmostLongest) => return false,
+    };
+    let backtrack_config = BoundedBacktracker::config();
+    builder
+        .configure(backtrack_config)
+        .syntax(config_syntax(test))
+        .thompson(config_thompson(test));
+    true
+}
+
+/// Configuration of a Thompson NFA compiler from a regex test.
+fn config_thompson(test: &RegexTest) -> thompson::Config {
+    let mut lookm = regex_automata::util::look::LookMatcher::new();
+    lookm.set_line_terminator(test.line_terminator());
+    thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+}
+
+/// Configuration of the regex parser from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
diff --git a/regex-automata/tests/nfa/thompson/mod.rs b/regex-automata/tests/nfa/thompson/mod.rs
new file mode 100644
index 0000000000..b2558f7049
--- /dev/null
+++ b/regex-automata/tests/nfa/thompson/mod.rs
@@ -0,0 +1,4 @@
+#[cfg(feature = "nfa-backtrack")]
+mod backtrack;
+#[cfg(feature = "nfa-pikevm")]
+mod pikevm;
diff --git a/regex-automata/tests/nfa/thompson/pikevm/mod.rs b/regex-automata/tests/nfa/thompson/pikevm/mod.rs
new file mode 100644
index 0000000000..9d6ab475ef
--- /dev/null
+++ b/regex-automata/tests/nfa/thompson/pikevm/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(not(miri))]
+mod suite;
diff --git a/regex-automata/tests/nfa/thompson/pikevm/suite.rs b/regex-automata/tests/nfa/thompson/pikevm/suite.rs
new file mode 100644
index 0000000000..d32842a156
--- /dev/null
+++ b/regex-automata/tests/nfa/thompson/pikevm/suite.rs
@@ -0,0 +1,162 @@
+use {
+    anyhow::Result,
+    regex_automata::{
+        nfa::thompson::{
+            self,
+            pikevm::{self, PikeVM},
+        },
+        util::{prefilter::Prefilter, syntax},
+        PatternSet,
+    },
+    regex_test::{
+        CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+        TestRunner,
+    },
+};
+
+use crate::{create_input, suite, testify_captures, untestify_kind};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let builder = PikeVM::builder();
+    let mut runner = TestRunner::new()?;
+    runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+    runner.test_iter(suite()?.iter(), compiler(builder)).assert();
+    Ok(())
+}
+
+/// Tests the PikeVM with prefilters enabled.
+#[test]
+fn prefilter() -> Result<()> {
+    let my_compiler = |test: &RegexTest, regexes: &[String]| {
+        // Parse regexes as HIRs so we can get literals to build a prefilter.
+        let mut hirs = vec![];
+        for pattern in regexes.iter() {
+            hirs.push(syntax::parse_with(pattern, &config_syntax(test))?);
+        }
+        let kind = match untestify_kind(test.match_kind()) {
+            None => return Ok(CompiledRegex::skip()),
+            Some(kind) => kind,
+        };
+        let pre = Prefilter::from_hirs_prefix(kind, &hirs);
+        let mut builder = PikeVM::builder();
+        builder.configure(PikeVM::config().prefilter(pre));
+        compiler(builder)(test, regexes)
+    };
+    let mut runner = TestRunner::new()?;
+    runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+    runner.test_iter(suite()?.iter(), my_compiler).assert();
+    Ok(())
+}
+
+fn compiler(
+    mut builder: pikevm::Builder,
+) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+    move |test, regexes| {
+        if !configure_pikevm_builder(test, &mut builder) {
+            return Ok(CompiledRegex::skip());
+        }
+        let re = builder.build_many(&regexes)?;
+        let mut cache = re.create_cache();
+        Ok(CompiledRegex::compiled(move |test| -> TestResult {
+            run_test(&re, &mut cache, test)
+        }))
+    }
+}
+
+fn run_test(
+    re: &PikeVM,
+    cache: &mut pikevm::Cache,
+    test: &RegexTest,
+) -> TestResult {
+    let input = create_input(test);
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(cache, input)),
+        "find" => match test.search_kind() {
+            SearchKind::Earliest => {
+                let it = re
+                    .find_iter(cache, input.earliest(true))
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    });
+                TestResult::matches(it)
+            }
+            SearchKind::Leftmost => {
+                let it = re
+                    .find_iter(cache, input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|m| Match {
+                        id: m.pattern().as_usize(),
+                        span: Span { start: m.start(), end: m.end() },
+                    });
+                TestResult::matches(it)
+            }
+            SearchKind::Overlapping => {
+                let mut patset = PatternSet::new(re.get_nfa().pattern_len());
+                re.which_overlapping_matches(cache, &input, &mut patset);
+                TestResult::which(patset.iter().map(|p| p.as_usize()))
+            }
+        },
+        "captures" => match test.search_kind() {
+            SearchKind::Earliest => {
+                let it = re
+                    .captures_iter(cache, input.earliest(true))
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|caps| testify_captures(&caps));
+                TestResult::captures(it)
+            }
+            SearchKind::Leftmost => {
+                let it = re
+                    .captures_iter(cache, input)
+                    .take(test.match_limit().unwrap_or(std::usize::MAX))
+                    .map(|caps| testify_captures(&caps));
+                TestResult::captures(it)
+            }
+            SearchKind::Overlapping => {
+                // There is no overlapping PikeVM API that supports captures.
+                TestResult::skip()
+            }
+        },
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Configures the given regex builder with all relevant settings on the given
+/// regex test.
+///
+/// If the regex test has a setting that is unsupported, then this returns
+/// false (implying the test should be skipped).
+fn configure_pikevm_builder(
+    test: &RegexTest,
+    builder: &mut pikevm::Builder,
+) -> bool {
+    let match_kind = match untestify_kind(test.match_kind()) {
+        None => return false,
+        Some(k) => k,
+    };
+    let pikevm_config = PikeVM::config().match_kind(match_kind);
+    builder
+        .configure(pikevm_config)
+        .syntax(config_syntax(test))
+        .thompson(config_thompson(test));
+    true
+}
+
+/// Configuration of a Thompson NFA compiler from a regex test.
+fn config_thompson(test: &RegexTest) -> thompson::Config {
+    let mut lookm = regex_automata::util::look::LookMatcher::new();
+    lookm.set_line_terminator(test.line_terminator());
+    thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+}
+
+/// Configuration of the regex parser from a regex test.
+fn config_syntax(test: &RegexTest) -> syntax::Config {
+    syntax::Config::new()
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .utf8(test.utf8())
+        .line_terminator(test.line_terminator())
+}
diff --git a/regex-capi/LICENSE-APACHE b/regex-capi/LICENSE-APACHE
deleted file mode 120000
index 965b606f33..0000000000
--- a/regex-capi/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../LICENSE-APACHE
\ No newline at end of file
diff --git a/regex-capi/LICENSE-APACHE b/regex-capi/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/regex-capi/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/regex-capi/LICENSE-MIT b/regex-capi/LICENSE-MIT
deleted file mode 120000
index 76219eb72e..0000000000
--- a/regex-capi/LICENSE-MIT
+++ /dev/null
@@ -1 +0,0 @@
-../LICENSE-MIT
\ No newline at end of file
diff --git a/regex-capi/LICENSE-MIT b/regex-capi/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/regex-capi/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/regex-capi/src/rure.rs b/regex-capi/src/rure.rs
index d2e1539ed2..9e17668e26 100644
--- a/regex-capi/src/rure.rs
+++ b/regex-capi/src/rure.rs
@@ -41,7 +41,7 @@ pub struct rure_match {
     pub end: size_t,
 }
 
-pub struct Captures(bytes::Locations);
+pub struct Captures(bytes::CaptureLocations);
 
 pub struct Iter {
     re: *const Regex,
@@ -198,7 +198,7 @@ ffi_fn! {
         let re = unsafe { &*re };
         let haystack = unsafe { slice::from_raw_parts(haystack, len) };
         let slots = unsafe { &mut (*captures).0 };
-        re.read_captures_at(slots, haystack, start).is_some()
+        re.captures_read_at(slots, haystack, start).is_some()
     }
 }
 
@@ -375,7 +375,7 @@ ffi_fn! {
         if it.last_end > text.len() {
             return false;
         }
-        let (s, e) = match re.read_captures_at(slots, text, it.last_end) {
+        let (s, e) = match re.captures_read_at(slots, text, it.last_end) {
             None => return false,
             Some(m) => (m.start(), m.end()),
         };
@@ -400,7 +400,7 @@ ffi_fn! {
 ffi_fn! {
     fn rure_captures_new(re: *const Regex) -> *mut Captures {
         let re = unsafe { &*re };
-        let captures = Captures(re.locations());
+        let captures = Captures(re.capture_locations());
         Box::into_raw(Box::new(captures))
     }
 }
@@ -418,7 +418,7 @@ ffi_fn! {
         match_info: *mut rure_match,
     ) -> bool {
         let locs = unsafe { &(*captures).0 };
-        match locs.pos(i) {
+        match locs.get(i) {
             Some((start, end)) => {
                 if !match_info.is_null() {
                     unsafe {
@@ -562,7 +562,7 @@ ffi_fn! {
         for item in matches.iter_mut() {
             *item = false;
         }
-        re.read_matches_at(&mut matches, haystack, start)
+        re.matches_read_at(&mut matches, haystack, start)
     }
 }
 
diff --git a/regex-capi/test b/regex-capi/test
index ff47485458..6b31b1da6d 100755
--- a/regex-capi/test
+++ b/regex-capi/test
@@ -2,6 +2,10 @@
 
 set -e
 
+# cd to the directory containing this crate's Cargo.toml so that we don't need
+# to pass --manifest-path to every `cargo` command.
+cd "$(dirname "$0")"
+
 cargo build --verbose
 (cd ctest && ./compile && LD_LIBRARY_PATH=../../target/debug ./test)
 (cd examples && ./compile && LD_LIBRARY_PATH=../../target/debug ./iter)
diff --git a/regex-cli/Cargo.toml b/regex-cli/Cargo.toml
new file mode 100644
index 0000000000..a533f08d6e
--- /dev/null
+++ b/regex-cli/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+publish = false
+name = "regex-cli"
+version = "0.0.1"
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
+description = """
+A command line tool for debugging, ad hoc benchmarking and generating regular
+expressions.
+"""
+repository = "https://github.com/rust-lang/regex/tree/master/regex-cli"
+keywords = ["regex", "cli", "debug", "nfa", "dfa"]
+license = "MIT OR Apache-2.0"
+categories = ["text-processing"]
+autotests = false
+edition = "2021"
+
+[[bin]]
+name = "regex-cli"
+path = "main.rs"
+
+[features]
+default = []
+instrument = ["regex-automata/internal-instrument"]
+
+[dependencies]
+anyhow = "1.0.28"
+bstr = { version = "1.4.0", default-features = false, features = ["std"] }
+lexopt = "0.3.0"
+log = { version = "0.4.17", features = ["std"] }
+memmap2 = "0.5.10"
+regex = { path = ".." }
+regex-automata = { path = "../regex-automata", features = ["logging"] }
+regex-lite = { path = "../regex-lite" }
+regex-syntax = { path = "../regex-syntax" }
+tabwriter = { version = "1.2.1", features = ["ansi_formatting"] }
+textwrap = { version = "0.16.0", default-features = false }
diff --git a/regex-cli/LICENSE-APACHE b/regex-cli/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/regex-cli/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/regex-cli/LICENSE-MIT b/regex-cli/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/regex-cli/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/regex-cli/README.md b/regex-cli/README.md
new file mode 100644
index 0000000000..36dc50e772
--- /dev/null
+++ b/regex-cli/README.md
@@ -0,0 +1,265 @@
+regex-cli
+=========
+This is a command line tool for interacting with the regex, regex-automata and
+regex-syntax crates. It enables one to print debug representations of various
+values, run searches, generate DFAs and deserialization code and perform
+various regex development tasks such as generating tests.
+
+### Installation
+
+Currently `regex-cli` is not on crates.io and should be installed from this
+git repository:
+
+```
+$ cargo install --git https://github.com/rust-lang/regex regex-cli
+```
+
+
+### Example: print debug output
+
+The `regex-cli` command provides a way to print the debug output for most
+of the principle types in the `regex-automata` crate. This can be useful for
+debugging purposes when working on the `regex` project, or even if you just
+want a better look at a regex object's internal representation. For example,
+the following two commands compare and contrast the differences in the NFA for
+`.` and `(?-u:.)`:
+
+```
+$ regex-cli debug thompson '.' --no-table
+
+thompson::NFA(
+>000000: binary-union(2, 1)
+ 000001: \x00-\xFF => 0
+^000002: capture(pid=0, group=0, slot=0) => 10
+ 000003: \x80-\xBF => 11
+ 000004: \xA0-\xBF => 3
+ 000005: \x80-\xBF => 3
+ 000006: \x80-\x9F => 3
+ 000007: \x90-\xBF => 5
+ 000008: \x80-\xBF => 5
+ 000009: \x80-\x8F => 5
+ 000010: sparse(\x00-\t => 11, \x0B-\x7F => 11, \xC2-\xDF => 3, \xE0 => 4, \xE1-\xEC => 5, \xED => 6, \xEE-\xEF => 5, \xF0 => 7, \xF1-\xF3 => 8, \xF4 => 9)
+ 000011: capture(pid=0, group=0, slot=1) => 12
+ 000012: MATCH(0)
+
+transition equivalence classes: ByteClasses(0 => [\x00-\t], 1 => [\n], 2 => [\x0B-\x7F], 3 => [\x80-\x8F], 4 => [\x90-\x9F], 5 => [\xA0-\xBF], 6 => [\xC0-\xC1], 7 => [\xC2-\xDF], 8 => [\xE0], 9 => [\xE1-\xEC], 10 => [\xED], 11 => [\xEE-\xEF], 12 => [\xF0], 13 => [\xF1-\xF3], 14 => [\xF4], 15 => [\xF5-\xFF], 16 => [EOI])
+)
+```
+
+And now for `(?-u:.)`:
+
+```
+$ regex-cli debug thompson -b '(?-u:.)' --no-table
+
+thompson::NFA(
+>000000: binary-union(2, 1)
+ 000001: \x00-\xFF => 0
+^000002: capture(pid=0, group=0, slot=0) => 3
+ 000003: sparse(\x00-\t => 4, \x0B-\xFF => 4)
+ 000004: capture(pid=0, group=0, slot=1) => 5
+ 000005: MATCH(0)
+
+transition equivalence classes: ByteClasses(0 => [\x00-\t], 1 => [\n], 2 => [\x0B-\xFF], 3 => [EOI])
+)
+```
+
+To make things a bit more concise, we use `--no-table` to omit some extra
+metadata about the size of the NFA and the time required to build it.
+
+In the second example, we also pass the `-b/--no-utf8-syntax` flag. Without
+it, the command returns an error because patterns are compiled with default
+settings. The default setting is to forbid any pattern that can possibly match
+invalid UTF-8. Since `(?-u:.)` matches any byte except for `\n`, it can match
+invalid UTF-8. Thus, you have to say, "I am explicitly okay with matching
+invalid UTF-8."
+
+
+### Example: execute a search
+
+This command shows how to run a search with multiple patterns with each
+containing capture groups. The output shows the value of each matching group.
+
+```
+$ regex-cli find capture meta -p '(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$' -p $'(?m)^(?<key>[[:word:]]+)=\'(?<val>[^\']+)\'$' -y 'best_album="Blow Your Face Out"'
+     parse time:  81.541µs
+ translate time:  52.035µs
+build meta time:  805.696µs
+    search time:  426.391µs
+  total matches:  1
+0:{ 0: 0..31/best_album="Blow\x20Your\x20Face\x20Out", 1/key: 0..10/best_album, 2/val: 12..30/Blow\x20Your\x20Face\x20Out }
+```
+
+In this case, `meta` refers to the regex engine. It can be a number of other
+things, including `lite` for testing the `regex-lite` crate. Also, `capture`
+refers to the kind of search. You can also just ask for the `match` which will
+print the overall match and not the capture groups:
+
+```
+$ regex-cli find match meta -p '(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$' -p $'(?m)^(?<key>[[:word:]]+)=\'(?<val>[^\']+)\'$' -y 'best_album="Blow Your Face Out"'
+     parse time:  67.067µs
+ translate time:  40.005µs
+build meta time:  586.163µs
+    search time:  291.633µs
+  total matches:  1
+0:0:31:best_album="Blow\x20Your\x20Face\x20Out"
+```
+
+Since not all regex engines support capture groups, using `match` will open up
+the ability to test other regex engines such as `hybrid`.
+
+Finally, the `-p/--pattern` flag specifies a pattern and the `-y/--haystack`
+flag provides a haystack to search as a command line argument. One can also omit
+the `-y/--haystack` flag and provide a file path to search instead:
+
+```
+$ echo 'best_album="Blow Your Face Out"' > haystack
+$ regex-cli find match hybrid -p '(?m)^(?<key>[[:word:]]+)="(?<val>[^"]+)"$' -p $'(?m)^(?<key>[[:word:]]+)=\'(?<val>[^\']+)\'$' haystack
+               parse time:  60.278µs
+           translate time:  43.832µs
+ compile forward nfa time:  462.148µs
+ compile reverse nfa time:  56.275µs
+build forward hybrid time:  6.532µs
+build reverse hybrid time:  4.089µs
+         build regex time:  4.899µs
+      cache creation time:  18.59µs
+              search time:  54.653µs
+            total matches:  1
+0:0:31:best_album="Blow\x20Your\x20Face\x20Out"
+```
+
+
+### Example: serialize a DFA
+
+One particularly useful command in `regex-cli` is `regex-cli generate
+serialize`. It takes care of generating and writing a fully compiled DFA to
+a file, and then producing Rust code that deserializes it. The command line
+provides oodles of options, including all options found in the `regex-automata`
+crate for building the DFA in code.
+
+Let's walk through a complete end-to-end example. We assume `regex-cli` is
+already installed per instructions above. Let's start with an empty binary
+Rust project:
+
+```
+$ mkdir regex-dfa-test
+$ cd regex-dfa-test
+$ cargo init --bin
+```
+
+Now add a dependency on `regex-automata`. Technically, the only feature that
+needs to be enabled for this example is `dfa-search`, but we include `std` as
+well to get some conveniences like `std::error::Error` implementations and also
+optimizations. But you can drop `std` and just use `alloc` or even drop `alloc`
+too altogether if necessary.
+
+```
+$ cargo add regex-automata --features std,dfa-search
+```
+
+Now we can generate a DFA with `regex-cli`. This will create three files: the
+little endian binary serialization of the DFA, the big endian version and a
+simple Rust source file for lazily deserializing the DFA via a static into a
+`regex_automata::util::lazy::Lazy`:
+
+```
+regex-cli generate serialize sparse dfa \
+  --minimize \
+  --shrink \
+  --start-kind anchored \
+  --rustfmt \
+  --safe \
+  SIMPLE_WORD_FWD \
+  ./src/ \
+  "\w"
+```
+
+We pass a number of flags here. There are even more available, and generally
+speaking, there is at least one flag for each configuration knob available in
+the library. This means that it should be possible to configure the DFA in any
+way you might expect to be able to in the code. We can briefly explain the
+flags we use here though:
+
+* `--minimize` applies a [DFA minimization] algorithm to try and shrink
+the size of the DFA as much as possible. In some cases it can make a big
+difference, but not all. Minimization can also be extremely expensive, but
+given that this is an offline process and presumably done rarely, it's usually
+a good trade off to make.
+* `--shrink` uses heuristics to make the size of the NFA smaller in some cases.
+This doesn't impact the size of the DFA, but it can make determinization (the
+process of converting an NFA into a DFA) faster at the cost of making NFA
+construction slower. This can make overall DFA generation time faster.
+* `--start-kind anchored` says to build a DFA that only supports anchored
+searches. (That is, every match must have a start offset equivalent to the
+start of the search.) Without this, DFAs support both anchored and unanchored
+searches, and that in turn can make them much bigger than they need to be if
+you only need one or the other.
+* `--rustfmt` will run `rustfmt` on the generated Rust code.
+* `--safe` will use only safe code for deserializing the DFA. This may be
+slower, but it is a one time cost. If you find that deserializing the DFA is
+too slow, then dropping this option will use alternative APIs that may result
+in undefined behavior if the given DFA is not valid. (Every DFA generated by
+`regex-cli` is intended to be valid. So *not* using `--safe` should always be
+correct, but it's up to you whether it's worth doing.)
+
+[DFA minimization]: https://en.wikipedia.org/wiki/DFA_minimization
+
+The final three positional arguments are as follows:
+
+* `SIMPLE_WORD_FWD` is the name of the variable in the Rust source code for
+the DFA, and it is also used in generating the names of the files produced by
+this command.
+* `./src/` is the directory to write the files.
+* `\w` is the regex pattern to build the DFA for. More than one may be given!
+
+Once the DFA is generated, you should see three new files in `./src/`:
+
+```
+$ ls -l src/
+total 32
+-rw-rw-r-- 1 andrew users    45 May 28 22:04 main.rs
+-rw-rw-r-- 1 andrew users 11095 May 30 10:24 simple_word_fwd.bigendian.dfa
+-rw-rw-r-- 1 andrew users 11095 May 30 10:24 simple_word_fwd.littleendian.dfa
+-rw-rw-r-- 1 andrew users   711 May 30 10:24 simple_word_fwd.rs
+```
+
+At this point, you just need to add the appropriate `mod` definition in
+`main.rs` and use the DFA:
+
+```rust
+use regex_automata::{dfa::Automaton, Anchored, Input};
+
+use crate::simple_word_fwd::SIMPLE_WORD_FWD as DFA;
+
+mod simple_word_fwd;
+
+fn main() {
+    let input = Input::new("ω").anchored(Anchored::Yes);
+    println!("is a word: {:?}", DFA.try_search_fwd(&input));
+
+    let input = Input::new("☃").anchored(Anchored::Yes);
+    println!("not a word: {:?}", DFA.try_search_fwd(&input));
+}
+```
+
+And now run the program:
+
+```
+$ cargo run
+   Compiling regex-dfa-test v0.1.0 (/home/andrew/tmp/regex-dfa-test)
+    Finished dev [unoptimized + debuginfo] target(s) in 0.17s
+     Running `target/debug/regex-dfa-test`
+is a word: Ok(Some(HalfMatch { pattern: PatternID(0), offset: 2 }))
+not a word: Ok(None)
+```
+
+There are a few other things worth mentioning:
+
+* The above generates a "sparse" DFA. This sacrifices search performance in
+favor of (potentially much) smaller DFAs. One can also generate a "dense" DFA
+to get faster searches but larger DFAs.
+* Above, we generated a "dfa," but one can also generate a "regex." The
+difference is that a DFA can only find the end of a match (or start of a match
+if the DFA is reversed), where as a regex will generate two DFAs: one for
+finding the end of a match and then another for finding the start. One can
+generate two DFAs manually and stitch them together in the code, but generating
+a `regex` will take care of this for you.
diff --git a/regex-cli/args/api.rs b/regex-cli/args/api.rs
new file mode 100644
index 0000000000..44af3b3f34
--- /dev/null
+++ b/regex-cli/args/api.rs
@@ -0,0 +1,136 @@
+use {
+    lexopt::{Arg, Parser},
+    regex::bytes::{Regex, RegexSet},
+    regex_automata::util::syntax,
+};
+
+use crate::args::{self, Configurable, Usage};
+
+/// Exposes the configuration for the top-level `Regex` API.
+#[derive(Debug, Default)]
+pub struct Config {
+    size_limit: Option<usize>,
+    dfa_size_limit: Option<usize>,
+}
+
+impl Config {
+    /// Builds a `Regex` from the given syntax configuration and sequence of
+    /// patterns. This returns an error is `patterns.len() != 1`.
+    ///
+    /// Note that this also returns an error if UTF-8 mode is enabled in
+    /// the given syntax configuration. This is mostly because we stick to
+    /// returning a `regex::bytes::Regex` which requires hard-codes disabling
+    /// UTF-8 mode. We could add another constructor for `regex::Regex` which
+    /// requires that UTF-8 mode is enabled if it's needed, but I don't think
+    /// it is.
+    pub fn from_patterns(
+        &self,
+        syntax: &syntax::Config,
+        patterns: &[String],
+    ) -> anyhow::Result<Regex> {
+        anyhow::ensure!(
+            !syntax.get_utf8(),
+            "API-level regex requires that UTF-8 syntax mode be disabled",
+        );
+        anyhow::ensure!(
+            patterns.len() == 1,
+            "API-level regex requires exactly one pattern, \
+                 but {} were given",
+            patterns.len(),
+        );
+        let mut b = regex::bytes::RegexBuilder::new(&patterns[0]);
+        b.case_insensitive(syntax.get_case_insensitive());
+        b.multi_line(syntax.get_multi_line());
+        b.dot_matches_new_line(syntax.get_dot_matches_new_line());
+        b.swap_greed(syntax.get_swap_greed());
+        b.ignore_whitespace(syntax.get_ignore_whitespace());
+        b.unicode(syntax.get_unicode());
+        b.octal(syntax.get_octal());
+        b.nest_limit(syntax.get_nest_limit());
+        b.size_limit(self.size_limit.unwrap_or(usize::MAX));
+        if let Some(limit) = self.dfa_size_limit {
+            b.dfa_size_limit(limit);
+        }
+        b.build().map_err(anyhow::Error::from)
+    }
+
+    /// Builds a `RegexSet` from the given syntax configuration and sequence of
+    /// patterns.
+    ///
+    /// Note that this returns an error if UTF-8 mode is enabled in the given
+    /// syntax configuration. This is mostly because we stick to returning a
+    /// `regex::bytes::RegexSet` which requires hard-codes disabling UTF-8
+    /// mode. We could add another constructor for `regex::RegexSet` which
+    /// requires that UTF-8 mode is enabled if it's needed, but I don't think
+    /// it is.
+    pub fn from_patterns_set(
+        &self,
+        syntax: &syntax::Config,
+        patterns: &[String],
+    ) -> anyhow::Result<RegexSet> {
+        anyhow::ensure!(
+            !syntax.get_utf8(),
+            "API-level regex requires that UTF-8 syntax mode be disabled",
+        );
+        let mut b = regex::bytes::RegexSetBuilder::new(patterns);
+        b.case_insensitive(syntax.get_case_insensitive());
+        b.multi_line(syntax.get_multi_line());
+        b.dot_matches_new_line(syntax.get_dot_matches_new_line());
+        b.swap_greed(syntax.get_swap_greed());
+        b.ignore_whitespace(syntax.get_ignore_whitespace());
+        b.unicode(syntax.get_unicode());
+        b.octal(syntax.get_octal());
+        b.nest_limit(syntax.get_nest_limit());
+        b.size_limit(self.size_limit.unwrap_or(usize::MAX));
+        if let Some(limit) = self.dfa_size_limit {
+            b.dfa_size_limit(limit);
+        }
+        b.build().map_err(anyhow::Error::from)
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("size-limit") => {
+                self.size_limit = args::parse_maybe(p, "--size-limit")?;
+            }
+            Arg::Long("dfa-size-limit") => {
+                self.dfa_size_limit =
+                    Some(args::parse(p, "--dfa-size-limit")?);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--size-limit",
+                "Set a limit on heap used by a regex.",
+                r#"
+This sets a limit, in bytes, on the heap memory used by a regex.
+
+The special value 'none' indicates that no size limit should be imposed.
+"#,
+            ),
+            Usage::new(
+                "--dfa-size-limit",
+                "Set a limit on the heap used by a regex's internal lazy DFA.",
+                r#"
+This sets a capacity, in bytes, on the approximate maximum total heap memory
+used by a regex's internal lazy DFA. This only applies if a lazy DFA is used.
+
+Note that one cannot set this to 'none' since it represents a capacity. When
+it isn't set, then some reasonable default is used.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/backtrack.rs b/regex-cli/args/backtrack.rs
new file mode 100644
index 0000000000..01b41a1d40
--- /dev/null
+++ b/regex-cli/args/backtrack.rs
@@ -0,0 +1,71 @@
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::nfa::thompson::{backtrack, NFA},
+};
+
+use crate::args::{self, Configurable, Usage};
+
+/// This exposes the configuration knobs for a `BoundedBacktracker`.
+#[derive(Debug, Default)]
+pub struct Config {
+    backtrack: backtrack::Config,
+}
+
+impl Config {
+    /// Return a `backtrack::Config` object from this configuration.
+    pub fn backtrack(&self) -> anyhow::Result<backtrack::Config> {
+        Ok(self.backtrack.clone())
+    }
+
+    /// Builds a `BoundedBacktracker` regex engine from the NFA given.
+    pub fn from_nfa(
+        &self,
+        nfa: &NFA,
+    ) -> anyhow::Result<backtrack::BoundedBacktracker> {
+        backtrack::Builder::new()
+            .configure(self.backtrack()?)
+            .build_from_nfa(nfa.clone())
+            .context("failed to build BoundedBacktracker matcher")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("visited-capacity") => {
+                let capacity = args::parse(p, "--visited-capacity")?;
+                self.backtrack =
+                    self.backtrack.clone().visited_capacity(capacity);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[Usage::new(
+            "--visited-capacity <capacity>",
+            "Set the visited capacity for the bounded backtracker.",
+            r#"
+Set the visited set capacity used to bound backtracking.
+
+The visited capacity represents the amount of heap memory (in bytes) to
+allocate toward tracking which parts of the backtracking search have been done
+before. The heap memory needed for any particular search is proportional to
+'haystack.len() * nfa.states().len()', whichc an be quite large. Therefore, the
+bounded backtracker is typically only able to run on shorter haystacks.
+
+For a given regex, increasing the visited capacity means that the maximum
+haystack length that can be searched is increased.
+
+The default capacity is a reasonable but empirically chosen size.
+"#,
+        )];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/common.rs b/regex-cli/args/common.rs
new file mode 100644
index 0000000000..81bfb8d00e
--- /dev/null
+++ b/regex-cli/args/common.rs
@@ -0,0 +1,75 @@
+use lexopt::{Arg, Parser};
+
+use crate::args::{Configurable, Usage};
+
+/// This exposes all of the configuration knobs on a regex_automata::Input via
+/// CLI flags. The only aspect of regex_automata::Input that this does not
+/// cover is the haystack, which should be provided by other means (usually
+/// with `Haystack`).
+#[derive(Debug, Default)]
+pub struct Config {
+    pub quiet: bool,
+    pub verbose: bool,
+    pub no_table: bool,
+}
+
+impl Config {
+    pub fn table(&self) -> bool {
+        !self.no_table
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('q') | Arg::Long("quiet") => {
+                self.quiet = true;
+            }
+            Arg::Long("verbose") => {
+                self.verbose = true;
+            }
+            Arg::Long("no-table") => {
+                self.no_table = true;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "-q, --quiet",
+                "Suppress some output.",
+                r#"
+This is a generic flag that suppresses some (but not all) output. Which output
+is suppressed depends on the command. For example, using the -q/--quiet flag
+with the 'regex-cli debug' variety of commands will only show the properties of
+the objected being printed and will suppress the debug printing of the object
+itself.
+"#,
+            ),
+            Usage::new(
+                "--verbose",
+                "Add more output.",
+                r#"
+This is a generic flag that expands output beyond the "normal" amount. Which
+output is added depends on the command.
+"#,
+            ),
+            Usage::new(
+                "--no-table",
+                "Omit any table of information from the output.",
+                r#"
+Many commands in this tool will print a table of property information related
+to the task being performed. Passing this flag will suppress that table.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/dfa.rs b/regex-cli/args/dfa.rs
new file mode 100644
index 0000000000..94793ee874
--- /dev/null
+++ b/regex-cli/args/dfa.rs
@@ -0,0 +1,242 @@
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::{
+        dfa::{self, dense, sparse},
+        nfa::thompson::NFA,
+        MatchKind,
+    },
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// Exposes the configuration for a dense (and also therefore sparse) DFAs.
+#[derive(Debug, Default)]
+pub struct Config {
+    dense: dense::Config,
+}
+
+impl Config {
+    /// Return a `dfa::dense::Config` object from this configuration.
+    pub fn dense(&self) -> anyhow::Result<dense::Config> {
+        Ok(self.dense.clone())
+    }
+
+    /// Returns a new configuration that compiles a reverse DFA from a reverse
+    /// NFA. The caller is responsible for reversing the NFA.
+    pub fn reversed(&self) -> Config {
+        let dense = self
+            .dense
+            .clone()
+            .prefilter(None)
+            .start_kind(dfa::StartKind::Anchored)
+            .match_kind(MatchKind::All);
+        Config { dense }
+    }
+
+    /// Runs determinization on the given NFA to produce a dense DFA. If
+    /// determinization fails, then an error is returned.
+    pub fn from_nfa(&self, nfa: &NFA) -> anyhow::Result<dense::DFA<Vec<u32>>> {
+        dense::Builder::new()
+            .configure(self.dense()?)
+            .build_from_nfa(nfa)
+            .context("failed to compile dense DFA")
+    }
+
+    /// Runs determinization on the given NFA to produce a dense DFA, and then
+    /// converts it to a sparse DFA. If determinization or conversion to a
+    /// sparse DFA fails, then an error is returned.
+    pub fn from_nfa_sparse(
+        &self,
+        nfa: &NFA,
+    ) -> anyhow::Result<sparse::DFA<Vec<u8>>> {
+        self.from_nfa(nfa)?.to_sparse().context("failed to compile sparse DFA")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('A') | Arg::Long("no-accelerate") => {
+                self.dense = self.dense.clone().accelerate(false);
+            }
+            Arg::Long("minimize") => {
+                self.dense = self.dense.clone().minimize(true);
+            }
+            Arg::Short('k') | Arg::Long("match-kind") => {
+                let kind: flags::MatchKind =
+                    args::parse(p, "-k/--match-kind")?;
+                self.dense = self.dense.clone().match_kind(kind.kind);
+            }
+            Arg::Long("start-kind") => {
+                let kind: flags::StartKind = args::parse(p, "--start-kind")?;
+                self.dense = self.dense.clone().start_kind(kind.kind);
+            }
+            Arg::Long("starts-for-each-pattern") => {
+                self.dense = self.dense.clone().starts_for_each_pattern(true);
+            }
+            Arg::Short('C') | Arg::Long("no-byte-classes") => {
+                self.dense = self.dense.clone().byte_classes(false);
+            }
+            Arg::Long("unicode-word-boundary") => {
+                self.dense = self.dense.clone().unicode_word_boundary(true);
+            }
+            Arg::Long("quit") => {
+                let set: flags::ByteSet = args::parse(p, "--quit")?;
+                for &byte in set.0.iter() {
+                    self.dense = self.dense.clone().quit(byte, true);
+                }
+            }
+            Arg::Long("specialize-start-states") => {
+                self.dense = self.dense.clone().specialize_start_states(true);
+            }
+            Arg::Long("dfa-size-limit") => {
+                let limit = args::parse_maybe(p, "--dfa-size-limit")?;
+                self.dense = self.dense.clone().dfa_size_limit(limit);
+            }
+            Arg::Long("determinize-size-limit") => {
+                let limit = args::parse_maybe(p, "--determinize-size-limit")?;
+                self.dense = self.dense.clone().determinize_size_limit(limit);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "-A, --no-accelerate",
+                "Disable DFA state acceleration.",
+                r#"
+Disable DFA state acceleration. It is enabled by default. When enabled, DFA
+states with few outgoing transitions are detected and tagged with special
+information that fast vector routines should search for those outgoing
+transitions whenever that state is entered.
+
+Acceleration is generally a heuristic optimization, since if the vector routine
+doesn't in practice skip over many bytes, it can overall make the DFA search
+slower.
+"#,
+            ),
+            Usage::new(
+                "--minimize",
+                "Minimize the DFA.",
+                r#"
+When enabled, the DFA is minimized. A minimized DFA is said to be as small as
+it possibly can be for the given regular language.
+
+Note that DFA minimization can take a very long time. Generally speaking, the
+benefits of minimization are a smaller DFA. Usually that doesn't directly
+translate to faster search times, but it can if it enables more efficient use
+of your CPU's cache. DFA minimization can also enable more opportunities for
+DFA acceleration.
+"#,
+            ),
+            flags::MatchKind::USAGE,
+            flags::StartKind::USAGE,
+            Usage::new(
+                "--starts-for-each-pattern",
+                "Add anchored start states for each pattern.",
+                r#"
+Add anchored start states for each pattern. This permits running an anchored
+search for a specific pattern using the --pattern-id flag. (Assuming this is
+a search command.)
+"#,
+            ),
+            Usage::new(
+                "-C, --no-byte-classes",
+                "Disable byte classes.",
+                r#"
+This casues all bytes to be an equivalence class unto themselves. By default,
+bytes are grouped into equivalence classes to reduce the size of the alphabet
+for a DFA, and therefore decreases overall space usage.
+
+It can be quite convenient to disable byte classes when looking at the debug
+representation of a DFA. Otherwise, the transitions are much harder for a human
+to read.
+"#,
+            ),
+            Usage::new(
+                "--unicode-word-boundary",
+                "Enable heuristic support for Unicode word boundaries.",
+                r#"
+Enable heuristic support for Unicode word boundaries. When enabled, a DFA
+will treat a Unicode word boundary as if it were an ASCII boundary, but will
+quit if it sees any non-ASCII byte.
+
+This is disabled by default, in which case, attempting to compile a DFA with a
+Unicode word boundary will result in an error.
+
+Note that enabling this is very similar to using the --quit flag and providing
+every non-ASCII byte as a quit byte. The only difference is that when this flag
+is used, the quit bytes are only added if the pattern contains a Unicode word
+boundary.
+"#,
+            ),
+            Usage::new(
+                "--quit",
+                "Add quit bytes to this DFA.",
+                r#"
+Add quit bytes to this DFA. When a quit byte is added to a DFA, then an
+outgoing transition to every state for this byte is added to the DFA that
+points to a special sentinel "quit" state. If the "quit" state is entered
+during a search, then an error is returned.
+
+The bytes given represent a set and may be specified as a sequence. Escape
+sequences like \n and \xFF are supported.
+"#,
+            ),
+            Usage::new(
+                "--specialize-start-states",
+                "Specializes start states for prefilter support.",
+                r#"
+When given, start states are "specialized" such that prefilters are better
+supported. Namely, when start states are specialized they are given a special
+tag that results in them being treated as a special case when entered at search
+time. The special case is that a prefilter can be run at that point in an
+attempt to accelerate the search.
+
+In general, it only makes sense to specialize start states when a prefilter is
+also enabled.
+
+Note also that if start states are not specialized (the default), then it is in
+general not possible to determine whether any given state ID is a start state,
+unless you've enumerated all possible start states and checked it against that
+set.
+"#,
+            ),
+            Usage::new(
+                "--dfa-size-limit",
+                "Set a limit on heap used by a DFA in bytes.",
+                r#"
+This sets a limit on the number of heap memory a DFA can use. The limit is
+enforced at DFA construction time. If the limit is exceeded, then construction
+will fail.
+
+A special value of 'none' may be given, which disables the limit.
+"#,
+            ),
+            Usage::new(
+                "--determinize-size-limit",
+                "Set a limit on heap used by a DFA in bytes.",
+                r#"
+This sets a limit on the number of heap memory that determinization can use.
+The limit is enforced during determinization. If the limit is exceeded, then
+determinization and therefore construction of the DFA will fail.
+
+This limit only applies to ancillary heap memory used by determinization and
+not to the heap memory used by the DFA's transition table itself. The limit the
+size of the DFA, use the --dfa-size-limit flag.
+
+A special value of 'none' may be given, which disables the limit.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/flags.rs b/regex-cli/args/flags.rs
new file mode 100644
index 0000000000..db8a847ef8
--- /dev/null
+++ b/regex-cli/args/flags.rs
@@ -0,0 +1,154 @@
+use bstr::ByteVec;
+
+use crate::args::Usage;
+
+/// This defines a implementation for a flag that wants a single byte. This is
+/// useful because there are some APIs that require a single byte. For example,
+/// setting a line terminator.
+///
+/// This in particular supports the ability to write the byte via an escape
+/// sequence. For example, `--flag '\xFF'` will parse to the single byte 0xFF.
+///
+/// If the flag value is empty or if it unescapes into something with more than
+/// one byte, then it is considered an error.
+#[derive(Debug, Default)]
+pub struct OneByte(pub u8);
+
+impl std::str::FromStr for OneByte {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<OneByte> {
+        let bytes = Vec::unescape_bytes(s);
+        anyhow::ensure!(
+            bytes.len() == 1,
+            "expected exactly one byte, but got {} bytes",
+            bytes.len(),
+        );
+        Ok(OneByte(bytes[0]))
+    }
+}
+
+/// This defines a implementation for a flag that wants a possibly empty set
+/// of bytes. This is useful because there are some APIs that require multiple
+/// individual bytes. For example, setting quit bytes for a DFA.
+///
+/// This in particular supports the ability to write the byte set via a
+/// sequence of escape sequences. For example, `--flag 'a\xFF\t'` will parse to
+/// the sequence 0x61 0xFF 0x09.
+///
+/// By default, the set is empty. If the flag value has a duplicate byte, then
+/// an error is returned. An empty value corresponds to the empty set.
+#[derive(Debug, Default)]
+pub struct ByteSet(pub Vec<u8>);
+
+impl std::str::FromStr for ByteSet {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<ByteSet> {
+        let mut set = vec![];
+        let mut seen = [false; 256];
+        for &byte in Vec::unescape_bytes(s).iter() {
+            anyhow::ensure!(
+                !seen[usize::from(byte)],
+                "saw duplicate byte 0x{:2X} in '{}'",
+                byte,
+                s,
+            );
+            seen[usize::from(byte)] = true;
+            set.push(byte);
+        }
+        set.sort();
+        Ok(ByteSet(set))
+    }
+}
+
+/// Provides an implementation of the --start-kind flag, for use with DFA
+/// configuration.
+#[derive(Debug)]
+pub struct StartKind {
+    pub kind: regex_automata::dfa::StartKind,
+}
+
+impl StartKind {
+    pub const USAGE: Usage = Usage::new(
+        "--start-kind <kind>",
+        "One of: both, unanchored, anchored.",
+        r#"
+Sets the start states supported by a DFA. The default is 'both', but it can
+be set to either 'unanchored' or 'anchored'. The benefit of only supporting
+unanchored or anchored start states is that it usually leads to a smaller
+overall automaton.
+"#,
+    );
+}
+
+impl Default for StartKind {
+    fn default() -> StartKind {
+        StartKind { kind: regex_automata::dfa::StartKind::Both }
+    }
+}
+
+impl std::str::FromStr for StartKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<StartKind> {
+        let kind = match s {
+            "both" => regex_automata::dfa::StartKind::Both,
+            "unanchored" => regex_automata::dfa::StartKind::Unanchored,
+            "anchored" => regex_automata::dfa::StartKind::Anchored,
+            unk => anyhow::bail!("unrecognized start kind '{}'", unk),
+        };
+        Ok(StartKind { kind })
+    }
+}
+
+/// Provides an implementation of the --match-kind flag, for use with most
+/// regex matchers.
+#[derive(Debug)]
+pub struct MatchKind {
+    pub kind: regex_automata::MatchKind,
+}
+
+impl MatchKind {
+    pub const USAGE: Usage = Usage::new(
+        "-k, --match-kind <kind>",
+        "One of: leftmost-first, all.",
+        r#"
+Selects the match semantics for the regex engine. The choices are
+'leftmost-first' (the default) or 'all'.
+
+'leftmost-first' semantics look for the leftmost match, and when there are
+multiple leftmost matches, match priority disambiguates them. For example,
+in the haystack 'samwise', the regex 'samwise|sam' will match 'samwise' when
+using leftmost-first semantics. Similarly, the regex 'sam|samwise' will match
+'sam'.
+
+'all' semantics results in including all possible match states in the
+underlying automaton. When performing an unanchored leftmost search, this has
+the effect of finding the last match, which is usually not what you want.
+When performing an anchored leftmost search, it has the effect of finding the
+longest possible match, which might be what you want. (So there is no support
+for greedy vs non-greedy searching. Everything is greedy.) 'all' is also useful
+for overlapping searches, since all matches are reportable in this scheme.
+"#,
+    );
+}
+
+impl Default for MatchKind {
+    fn default() -> MatchKind {
+        MatchKind { kind: regex_automata::MatchKind::LeftmostFirst }
+    }
+}
+
+impl std::str::FromStr for MatchKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<MatchKind> {
+        let kind = match s {
+            "leftmost-first" => regex_automata::MatchKind::LeftmostFirst,
+            "all" => regex_automata::MatchKind::All,
+            unk => anyhow::bail!("unrecognized match kind '{}'", unk),
+        };
+        Ok(MatchKind { kind })
+    }
+}
diff --git a/regex-cli/args/haystack.rs b/regex-cli/args/haystack.rs
new file mode 100644
index 0000000000..6132516e7e
--- /dev/null
+++ b/regex-cli/args/haystack.rs
@@ -0,0 +1,140 @@
+use std::path::PathBuf;
+
+use {
+    anyhow::Context,
+    bstr::{BStr, BString, ByteSlice, ByteVec},
+    lexopt::{Arg, Parser, ValueExt},
+};
+
+use crate::args::{Configurable, Usage};
+
+/// A configuration object for reading a single haystack from the command line.
+///
+/// This supports reading either an inline haystack specified via the
+/// `-y/--haystack` flag, or via a positional argument pointing to a file path.
+///
+/// This supports reading exactly one haystack. If more than one are provided,
+/// then an error is returned at configuration time. If none are provided, then
+/// an error is returned when one attempts to retrieve the haystack.
+#[derive(Debug, Default)]
+pub struct Config {
+    kind: Option<Kind>,
+}
+
+impl Config {
+    /// Returns the haystack contents in this configuration.
+    ///
+    /// If the haystack was specified via a file path, then this returns the
+    /// entire contents of the file on to the heap.
+    pub fn get(&self) -> anyhow::Result<BString> {
+        match self.kind {
+            Some(Kind::Inline(ref haystack)) => Ok(haystack.clone()),
+            Some(Kind::Path(ref path)) => {
+                let contents = std::fs::read(&path).with_context(|| {
+                    anyhow::anyhow!("failed to read {}", path.display())
+                })?;
+                Ok(BString::from(contents))
+            }
+            None => anyhow::bail!(
+                "haystack is required via the -y/--haystack flag \
+                 or via a positional argument",
+            ),
+        }
+    }
+
+    /// If the haystack is a file, then memory map and pass the contents of the
+    /// file to the given closure. Otherwise, if it's an inline literal, then
+    /// pass it to the closure as-is.
+    pub fn with<T>(
+        &self,
+        mut f: impl FnMut(&BStr) -> anyhow::Result<T>,
+    ) -> anyhow::Result<T> {
+        match self.kind {
+            Some(Kind::Inline(ref haystack)) => f(haystack.as_bstr()),
+            Some(Kind::Path(ref path)) => {
+                let file = std::fs::File::open(path).with_context(|| {
+                    format!("failed to open {}", path.display())
+                })?;
+                // SAFETY: We assume this is OK to do since we assume that our
+                // search input is immutable. We specifically never try to
+                // mutate the bytes from the file or treat them as anything
+                // other than a slice of bytes.
+                let mmap = unsafe {
+                    memmap2::Mmap::map(&file).with_context(|| {
+                        format!("failed to mmap {}", path.display())
+                    })?
+                };
+                f(<&BStr>::from(&*mmap))
+            }
+            None => anyhow::bail!(
+                "haystack is required via the -y/--haystack flag \
+                 or via a positional argument",
+            ),
+        }
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('y') | Arg::Long("haystack") => {
+                anyhow::ensure!(
+                    self.kind.is_none(),
+                    "only one haystack is allowed",
+                );
+                let hay = p.value().context("-y/--haystack needs a value")?;
+                let hay = hay
+                    .string()
+                    .context("-y/--haystack must be valid UTF-8")?;
+                let hay = Vec::unescape_bytes(&hay);
+                self.kind = Some(Kind::Inline(BString::from(hay)));
+            }
+            Arg::Value(ref mut v) => {
+                anyhow::ensure!(
+                    self.kind.is_none(),
+                    "only one haystack is allowed",
+                );
+                let path = PathBuf::from(std::mem::take(v));
+                self.kind = Some(Kind::Path(path));
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[Usage::new(
+            "-y, --haystack <haystack>",
+            "Provide an inline haystack on the command line.",
+            r#"
+This flag provides an inline haystack on the command line. That is, the value
+of this flag is *not* a file path, but the haystack contents itself. This is
+convenient for small regex searches because it lets one skip creating a file or
+other shenanigans.
+
+The haystack contents must be valid UTF-8, but it support escape sequences. So
+for example, "-y 'a\xFF\t'" corresponds to the byte sequence 0x61 0xFF 0x09.
+
+Note that exactly one haystack is permitted. The haystack can either be
+specified inline with this flag, or can be provided as a file path via a
+positional argument.
+"#,
+        )];
+        USAGES
+    }
+}
+
+/// The kind of haystack specified on the command line.
+///
+/// We don't read the file path contents at arg parsing time so that we can
+/// be a little more flexible. For example, by providing a way to memory map
+/// the haystack contents.
+#[derive(Debug)]
+enum Kind {
+    Inline(BString),
+    Path(PathBuf),
+}
diff --git a/regex-cli/args/hybrid.rs b/regex-cli/args/hybrid.rs
new file mode 100644
index 0000000000..e80d9bff8d
--- /dev/null
+++ b/regex-cli/args/hybrid.rs
@@ -0,0 +1,231 @@
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::{hybrid, nfa::thompson::NFA, MatchKind},
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// Exposes the configuration of a lazy DFA.
+#[derive(Debug, Default)]
+pub struct Config {
+    hybrid: hybrid::dfa::Config,
+}
+
+impl Config {
+    /// Return a `hybrid::dfa::Config` object from this configuration.
+    pub fn hybrid(&self) -> anyhow::Result<hybrid::dfa::Config> {
+        Ok(self.hybrid.clone())
+    }
+
+    /// Returns a new configuration that compiles a reverse lazy DFA from a
+    /// reverse NFA. The caller is responsible for reversing the NFA.
+    pub fn reversed(&self) -> Config {
+        let hybrid =
+            self.hybrid.clone().prefilter(None).match_kind(MatchKind::All);
+        Config { hybrid }
+    }
+
+    /// Build a lazy DFA from the NFA given.
+    ///
+    /// Building a lazy DFA is generally cheap. It only does a little bit of
+    /// work, but otherwise, the actual determinization process is carried out
+    /// on demand at search time.
+    pub fn from_nfa(&self, nfa: &NFA) -> anyhow::Result<hybrid::dfa::DFA> {
+        hybrid::dfa::Builder::new()
+            .configure(self.hybrid()?)
+            .build_from_nfa(nfa.clone())
+            .context("failed to compile lazy DFA")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('k') | Arg::Long("match-kind") => {
+                let kind: flags::MatchKind =
+                    args::parse(p, "-k/--match-kind")?;
+                self.hybrid = self.hybrid.clone().match_kind(kind.kind);
+            }
+            Arg::Long("starts-for-each-pattern") => {
+                self.hybrid =
+                    self.hybrid.clone().starts_for_each_pattern(true);
+            }
+            Arg::Short('C') | Arg::Long("no-byte-classes") => {
+                self.hybrid = self.hybrid.clone().byte_classes(false);
+            }
+            Arg::Long("unicode-word-boundary") => {
+                self.hybrid = self.hybrid.clone().unicode_word_boundary(true);
+            }
+            Arg::Long("quit") => {
+                let set: flags::ByteSet = args::parse(p, "--quit")?;
+                for &byte in set.0.iter() {
+                    self.hybrid = self.hybrid.clone().quit(byte, true);
+                }
+            }
+            Arg::Long("specialize-start-states") => {
+                self.hybrid =
+                    self.hybrid.clone().specialize_start_states(true);
+            }
+            Arg::Long("cache-capacity") => {
+                let capacity = args::parse(p, "--cache-capacity")?;
+                self.hybrid = self.hybrid.clone().cache_capacity(capacity);
+            }
+            Arg::Long("skip-cache-capacity-check") => {
+                self.hybrid =
+                    self.hybrid.clone().skip_cache_capacity_check(true);
+            }
+            Arg::Long("minimum-cache-clear-count") => {
+                let min = args::parse_maybe(p, "--minimum-cache-clear-count")?;
+                self.hybrid =
+                    self.hybrid.clone().minimum_cache_clear_count(min);
+            }
+            Arg::Long("minimum-bytes-per-state") => {
+                let min = args::parse_maybe(p, "--minimum-bytes-per-state")?;
+                self.hybrid = self.hybrid.clone().minimum_bytes_per_state(min);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            flags::MatchKind::USAGE,
+            Usage::new(
+                "--starts-for-each-pattern",
+                "Add anchored start states for each pattern.",
+                r#"
+Add anchored start states for each pattern. This permits running an anchored
+search for a specific pattern using the --pattern-id flag. (Assuming this is
+a search command.)
+"#,
+            ),
+            Usage::new(
+                "-C, --no-byte-classes",
+                "Disable byte classes.",
+                r#"
+This casues all bytes to be an equivalence class unto themselves. By default,
+bytes are grouped into equivalence classes to reduce the size of the alphabet
+for a DFA, and therefore decreases overall space usage.
+
+It can be quite convenient to disable byte classes when looking at the debug
+representation of a DFA. Otherwise, the transitions are much harder for a human
+to read.
+"#,
+            ),
+            Usage::new(
+                "--unicode-word-boundary",
+                "Enable heuristic support for Unicode word boundaries.",
+                r#"
+Enable heuristic support for Unicode word boundaries. When enabled, a DFA
+will treat a Unicode word boundary as if it were an ASCII boundary, but will
+quit if it sees any non-ASCII byte.
+
+This is disabled by default, in which case, attempting to compile a DFA with a
+Unicode word boundary will result in an error.
+
+Note that enabling this is very similar to using the --quit flag and providing
+every non-ASCII byte as a quit byte. The only difference is that when this flag
+is used, the quit bytes are only added if the pattern contains a Unicode word
+boundary.
+"#,
+            ),
+            Usage::new(
+                "--quit",
+                "Add quit bytes to this DFA.",
+                r#"
+Add quit bytes to this DFA. When a quit byte is added to a DFA, then an
+outgoing transition to every state for this byte is added to the DFA that
+points to a special sentinel "quit" state. If the "quit" state is entered
+during a search, then an error is returned.
+
+The bytes given represent a set and may be specified as a sequence. Escape
+sequences like \n and \xFF are supported.
+"#,
+            ),
+            Usage::new(
+                "--specialize-start-states",
+                "Specializes start states for prefilter support.",
+                r#"
+When given, start states are "specialized" such that prefilters are better
+supported. Namely, when start states are specialized they are given a special
+tag that results in them being treated as a special case when entered at search
+time. The special case is that a prefilter can be run at that point in an
+attempt to accelerate the search.
+
+In general, it only makes sense to specialize start states when a prefilter is
+also enabled.
+
+Note also that if start states are not specialized (the default), then it is in
+general not possible to determine whether any given state ID is a start state,
+unless you've enumerated all possible start states and checked it against that
+set.
+"#,
+            ),
+            Usage::new(
+                "--cache-capacity",
+                "Set the total cache capacity for the lazy DFA.",
+                r#"
+This sets an approximate limit on the total amount of heap memory used by
+the lazy DFA. Once the cache reaches capacity and there's no more room for
+additional states, the cache is cleared and the lazy DFA keeps rebuilding
+itself.
+"#,
+            ),
+            Usage::new(
+                "--skip-cache-capacity-check",
+                "Use the minimum cache capacity instead of failing.",
+                r#"
+By default, building a lazy DFA will fail if the configured cache capacity
+is too small to hold a small minimum number of DFA states. But enabling this
+option will "skip" that check and instead force the cache to be at least as big
+as the minimum size required.
+
+This can be useful if you are trying hard to avoid cases where the lazy DFA
+fails to build, but is in general not recommended. Namely, if the cache is too
+small, then it's plausible that it will not be used efficiently and the overall
+search would be slow. But it's not guaranteed to be slow, which is why this
+setting is configurable.
+"#,
+            ),
+            Usage::new(
+                "--minimum-cache-clear-count",
+                "Set the minimum number of times the cache must be cleared.",
+                r#"
+Sets the minimum number of times the cache must be cleared before the lazy DFA
+is permitted to give up on the search and return an error.
+
+This may be set to the special value 'none', which sets no minimum. In this
+case, the lazy DFA will never give up. When its cache gets full, it will clear
+it and keep going.
+
+This flag is usually used in combination with --minimum-bytes-per-state. It
+sets a baseline number of cache clearings but then also requires an efficiency
+below a certain amount before the lazy DFA will quit.
+
+When --minimum-bytes-per-state is not set and a minimum cache clear count has
+been set, then the lazy DFA unconditionally quits after the cache has been
+cleared the minimum number of times.
+"#,
+            ),
+            Usage::new(
+                "--minimum-bytes-per-state",
+                "Sets the minimum efficiency for lazy DFA.",
+                r#"
+This flag sets the minimum efficiency of the lazy DFA in terms of the number of
+bytes processed per new state added to the cache. If that number falls below
+the efficiency given by this flag *and* the cache has been cleared the minimum
+number of times, then the lazy DFA will quit the search and return an error.
+
+This flag has no effect if --minimum-cache-clear-count is set to 'none'.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/input.rs b/regex-cli/args/input.rs
new file mode 100644
index 0000000000..9f90809699
--- /dev/null
+++ b/regex-cli/args/input.rs
@@ -0,0 +1,160 @@
+use regex_automata::{Anchored, Input, PatternID};
+
+use lexopt::{Arg, Parser};
+
+use crate::args::{self, Configurable, Usage};
+
+/// This exposes all of the configuration knobs on a regex_automata::Input via
+/// CLI flags. The only aspect of regex_automata::Input that this does not
+/// cover is the haystack, which should be provided by other means (usually
+/// with `Haystack`).
+#[derive(Debug, Default)]
+pub struct Config {
+    start: Option<usize>,
+    end: Option<usize>,
+    anchored: bool,
+    pattern_id: Option<PatternID>,
+    earliest: bool,
+}
+
+impl Config {
+    /// Return an `Input` given the haystack to search. The input configuration
+    /// (other than the haystack) is drawn from this configuration.
+    ///
+    /// If an `Input` could not be constructed from this configuration (for
+    /// example, invalid start/end bounds), then an error is returned.
+    pub fn input<'h>(&self, haystack: &'h [u8]) -> anyhow::Result<Input<'h>> {
+        let mut input = Input::new(haystack).earliest(self.earliest);
+        if let Some(start) = self.start {
+            anyhow::ensure!(
+                start <= haystack.len(),
+                "start bound {} exceeds haystack length {}",
+                start,
+                haystack.len(),
+            );
+            input.set_start(start);
+        }
+        if let Some(end) = self.end {
+            anyhow::ensure!(
+                end <= haystack.len(),
+                "end bound {} exceeds haystack length {}",
+                end,
+                haystack.len(),
+            );
+            input.set_end(end);
+        }
+        if let Some(pid) = self.pattern_id {
+            input.set_anchored(Anchored::Pattern(pid));
+        } else if self.anchored {
+            input.set_anchored(Anchored::Yes)
+        } else {
+            // The default, but we set it explicitly anyway.
+            input.set_anchored(Anchored::No)
+        }
+        Ok(input)
+    }
+
+    /// Pass the `Input` (derived from this configuration) to the closure
+    /// given. Any error returned by the closure is returned by this routine.
+    /// Similarly, an error is returned if an `Input` could not be constructed
+    /// from this configuration.
+    ///
+    /// The `Input` is constructed with the given haystack. The intent of this
+    /// routine is that if the haystack is specified via a file path, then this
+    /// will memory map the haystack.
+    pub fn with<T>(
+        &self,
+        haystack: &args::haystack::Config,
+        mut f: impl FnMut(Input<'_>) -> anyhow::Result<T>,
+    ) -> anyhow::Result<T> {
+        haystack.with(|bytes| f(self.input(bytes)?))
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("start") => {
+                self.start = Some(args::parse(p, "--start")?);
+            }
+            Arg::Long("end") => {
+                self.end = Some(args::parse(p, "--end")?);
+            }
+            Arg::Short('a') | Arg::Long("anchored") => {
+                self.anchored = true;
+            }
+            Arg::Long("pattern-id") => {
+                let pid = args::parse(p, "--pattern-id")?;
+                self.pattern_id = Some(PatternID::new(pid)?);
+            }
+            Arg::Long("earliest") => {
+                self.earliest = true;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--start <bound>",
+                "Set the start of the search.",
+                r#"
+This sets the start bound of a search. It must be a valid offset for the
+haystack, up to and including the length of the haystack.
+
+When not set, the start bound is 0.
+"#,
+            ),
+            Usage::new(
+                "--end <bound>",
+                "Set the end of the search.",
+                r#"
+This sets the end bound of a search. It must be a valid offset for the
+haystack, up to and including the length of the haystack.
+
+When not set, the end bound is the length of the haystack.
+"#,
+            ),
+            Usage::new(
+                "-a, --anchored",
+                "Enable anchored mode for the search.",
+                r#"
+Enabled anchored mode for the search. When enabled and if a match is found, the
+start of the match is guaranteed to be equivalent to the start bound of the
+search.
+"#,
+            ),
+            Usage::new(
+                "--pattern-id <pid>",
+                "Set pattern to search for.",
+                r#"
+Set the pattern to search for. This automatically enables anchored mode for the
+search since regex engines for this crate only support anchored searches for
+specific patterns.
+
+When set and if a match is found, the start of the match is guaranteed to be
+equivalent to the start bound of the search and the pattern ID is guaranteed
+to be equivalent to the one set by this flag.
+
+When not set, a search may match any of the patterns given.
+"#,
+            ),
+            Usage::new(
+                "--earliest",
+                "Returns a match as soon as it is known.",
+                r#"
+This enables "earliest" mode, which asks the regex engine to stop searching as
+soon as a match is found. The specific offset returned may vary depending on
+the regex engine since not all regex engines detect matches in the same way.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/lite.rs b/regex-cli/args/lite.rs
new file mode 100644
index 0000000000..5c2d3cd0ee
--- /dev/null
+++ b/regex-cli/args/lite.rs
@@ -0,0 +1,84 @@
+use {
+    lexopt::{Arg, Parser},
+    regex_automata::util::syntax,
+    regex_lite::Regex,
+};
+
+use crate::args::{self, Configurable, Usage};
+
+/// Exposes the configuration for the top-level `Regex` API.
+#[derive(Debug, Default)]
+pub struct Config {
+    size_limit: Option<usize>,
+}
+
+impl Config {
+    /// Builds a `Regex` from the given syntax configuration and sequence of
+    /// patterns. This returns an error is `patterns.len() != 1`.
+    ///
+    /// Note that this also returns an error if any syntax options are set
+    /// that aren't supported by `regex-lite`.
+    pub fn from_patterns(
+        &self,
+        syntax: &syntax::Config,
+        patterns: &[String],
+    ) -> anyhow::Result<Regex> {
+        anyhow::ensure!(
+            patterns.len() == 1,
+            "API-level regex requires exactly one pattern, \
+                 but {} were given",
+            patterns.len(),
+        );
+        anyhow::ensure!(
+            !syntax.get_octal(),
+            "regex-lite does not support octal mode",
+        );
+        anyhow::ensure!(
+            syntax.get_utf8(),
+            "regex-lite does not support disabling UTF-8 mode",
+        );
+        anyhow::ensure!(
+            syntax.get_unicode(),
+            "regex-lite does not support disabling Unicode mode",
+        );
+        let mut b = regex_lite::RegexBuilder::new(&patterns[0]);
+        b.case_insensitive(syntax.get_case_insensitive());
+        b.multi_line(syntax.get_multi_line());
+        b.crlf(syntax.get_crlf());
+        b.dot_matches_new_line(syntax.get_dot_matches_new_line());
+        b.swap_greed(syntax.get_swap_greed());
+        b.ignore_whitespace(syntax.get_ignore_whitespace());
+        b.nest_limit(syntax.get_nest_limit());
+        b.size_limit(self.size_limit.unwrap_or(usize::MAX));
+        b.build().map_err(anyhow::Error::from)
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("size-limit") => {
+                self.size_limit = args::parse_maybe(p, "--size-limit")?;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[Usage::new(
+            "--size-limit",
+            "Set a limit on heap used by a regex.",
+            r#"
+This sets a limit, in bytes, on the heap memory used by a regex.
+
+The special value 'none' indicates that no size limit should be imposed.
+"#,
+        )];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/meta.rs b/regex-cli/args/meta.rs
new file mode 100644
index 0000000000..e5e7873f0f
--- /dev/null
+++ b/regex-cli/args/meta.rs
@@ -0,0 +1,283 @@
+use std::borrow::Borrow;
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::meta,
+    regex_syntax::hir::Hir,
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// Exposes the configuration of a lazy DFA.
+#[derive(Debug, Default)]
+pub struct Config {
+    meta: meta::Config,
+    build_from_patterns: bool,
+}
+
+impl Config {
+    /// Return a `meta::Config` object from this configuration.
+    pub fn meta(&self) -> anyhow::Result<meta::Config> {
+        Ok(self.meta.clone())
+    }
+
+    /// Whether to build a meta regex directly from the pattern strings, or to
+    /// require the caller to build their own HIR first.
+    ///
+    /// i.e., Whether the caller should use `from_patterns` or `from_hirs`.
+    pub fn build_from_patterns(&self) -> bool {
+        self.build_from_patterns
+    }
+
+    /// Build a meta regex from the pattern strings given.
+    pub fn from_patterns<P: AsRef<str>>(
+        &self,
+        syntax: &crate::args::syntax::Config,
+        patterns: &[P],
+    ) -> anyhow::Result<meta::Regex> {
+        meta::Builder::new()
+            .configure(self.meta()?)
+            .syntax(syntax.syntax()?)
+            .build_many(patterns)
+            .context("failed to compile meta regex")
+    }
+
+    /// Build a meta regex from the HIRs given.
+    pub fn from_hirs<H: Borrow<Hir>>(
+        &self,
+        hirs: &[H],
+    ) -> anyhow::Result<meta::Regex> {
+        meta::Builder::new()
+            .configure(self.meta()?)
+            .build_many_from_hir(hirs)
+            .context("failed to compile meta regex")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("build-from-patterns") => {
+                self.build_from_patterns = true;
+            }
+            Arg::Short('k') | Arg::Long("match-kind") => {
+                let kind: flags::MatchKind =
+                    args::parse(p, "-k/--match-kind")?;
+                self.meta = self.meta.clone().match_kind(kind.kind);
+            }
+            Arg::Short('B') | Arg::Long("no-utf8-nfa") => {
+                self.meta = self.meta.clone().utf8_empty(false);
+            }
+            Arg::Long("no-auto-prefilter") => {
+                self.meta = self.meta.clone().auto_prefilter(false);
+            }
+            Arg::Long("nfa-size-limit") => {
+                let limit = args::parse_maybe(p, "--nfa-size-limit")?;
+                self.meta = self.meta.clone().nfa_size_limit(limit);
+            }
+            Arg::Long("onepass-size-limit") => {
+                let limit = args::parse_maybe(p, "--onepass-size-limit")?;
+                self.meta = self.meta.clone().onepass_size_limit(limit);
+            }
+            Arg::Long("cache-capacity") => {
+                let capacity = args::parse(p, "--cache-capacity")?;
+                self.meta = self.meta.clone().hybrid_cache_capacity(capacity);
+            }
+            Arg::Long("dfa-size-limit") => {
+                let limit = args::parse_maybe(p, "--dfa-size-limit")?;
+                self.meta = self.meta.clone().dfa_size_limit(limit);
+            }
+            Arg::Long("dfa-state-limit") => {
+                let limit = args::parse_maybe(p, "--dfa-state-limit")?;
+                self.meta = self.meta.clone().dfa_state_limit(limit);
+            }
+            Arg::Short('C') | Arg::Long("no-byte-classes") => {
+                self.meta = self.meta.clone().byte_classes(false);
+            }
+            Arg::Long("line-terminator") => {
+                let byte: flags::OneByte =
+                    args::parse(p, "--line-terminator")?;
+                self.meta = self.meta.clone().line_terminator(byte.0);
+            }
+            Arg::Long("no-hybrid") => {
+                self.meta = self.meta.clone().hybrid(false);
+            }
+            Arg::Long("no-dfa") => {
+                self.meta = self.meta.clone().dfa(false);
+            }
+            Arg::Long("no-onepass") => {
+                self.meta = self.meta.clone().onepass(false);
+            }
+            Arg::Long("no-backtrack") => {
+                self.meta = self.meta.clone().backtrack(false);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--build-from-patterns",
+                "Build a meta regex directly from pattern strings.",
+                r#"
+Build a meta regex directly from pattern strings.
+
+By default, a meta regex is built in this tool by first explicitly parsing the
+patterns into ASTs, then translating them into HIRs and finally providing the
+HIRs to the meta regex builder. This flag changes the behavior to pass the
+pattern strings directly to the meta regex builder such that the builder is
+responsible for parsing and translating.
+
+The main reason to use this is if you specifically want to test the meta regex
+builder from patterns directly, as it may contain optimizations for skipping
+aspects of parsing.
+
+The default behavior splits these steps out in order to time them so that
+one gets a good idea of where most time is being spent during meta regex
+construction.
+"#,
+            ),
+            flags::MatchKind::USAGE,
+            Usage::new(
+                "-B, --no-utf8-nfa",
+                "Disable UTF-8 mode for empty matches.",
+                r#"
+Disables UTF-8 mode for empty matches. When this flag is given, empty matches
+that split a codepoint are permitted. Otherwise, they are banned.
+"#,
+            ),
+            Usage::new(
+                "--no-auto-prefilter",
+                "Disable automatic prefilters.",
+                r#"
+By default, a meta regex is accelerated via prefilters if one can be extracted
+from the literals in the pattern. By passing this flag, the automatic prefilter
+optimization is disabled.
+"#,
+            ),
+            Usage::new(
+                "--nfa-size-limit",
+                "Sets a limit on the memory used by an NFA.",
+                r#"
+Sets a limit on the memory used by the NFA built by the meta regex engine, in
+terms of bytes of heap usage. This limit is applied during NFA construction. If
+the limit is exceeded, then construction will fail.
+
+A special 'none' value disables the limit entirely.
+"#,
+            ),
+            Usage::new(
+                "--onepass-size-limit",
+                "Set a limit on heap used by a one-pass DFA in bytes.",
+                r#"
+This sets a limit on the number of heap memory a one-pass DFA built by the meta
+regex engine can use. The limit is enforced at one-pass DFA construction time.
+If the limit is exceeded, then construction will fail.
+
+A special value of 'none' may be given, which disables the limit.
+"#,
+            ),
+            Usage::new(
+                "--cache-capacity",
+                "Set the total cache capacity for the lazy DFA.",
+                r#"
+This sets an approximate limit on the total amount of heap memory used by the
+lazy DFA. This only applies when the meta regex engine uses a lazy DFA. Once
+the cache reaches capacity and there's no more room for additional states, the
+cache is cleared and the lazy DFA keeps rebuilding itself.
+"#,
+            ),
+            Usage::new(
+                "--dfa-size-limit",
+                "Set a limit on heap used by a DFA in bytes.",
+                r#"
+This sets a limit on the number of heap memory a DFA built by the meta regex
+engine can use. The limit is enforced at DFA construction time. If the limit is
+exceeded, then construction will fail.
+
+A special value of 'none' may be given, which disables the limit.
+"#,
+            ),
+            Usage::new(
+                "--dfa-state-limit",
+                "Only build a DFA when the NFA is below this limit.",
+                r#"
+When an NFA built by the meta regex engine has a number of states below this
+limit, the meta regex engine may choose to build a fully compiled DFA.
+
+A special value of 'none' may be given, which disables the limit.
+
+When not set, the default is a very small number. Unless you know what you're
+doing, the limit should be kept small since DFA construction is exponential
+in the number of DFA states. Even 2^N where N is a small number can be quite
+large, and this is why there is also the --dfa-size-limit to ensure the DFA
+cannot get too big.
+"#,
+            ),
+            Usage::new(
+                "-C, --no-byte-classes",
+                "Disable byte classes.",
+                r#"
+This casues all bytes to be an equivalence class unto themselves. By default,
+bytes are grouped into equivalence classes to reduce the size of the alphabet
+for a DFA, and therefore decreases overall space usage.
+
+It can be quite convenient to disable byte classes when looking at the debug
+representation of a DFA. Otherwise, the transitions are much harder for a human
+to read.
+"#,
+            ),
+            Usage::new(
+                "--line-terminator",
+                "Set the line terminator used by line anchors.",
+                r#"
+Set the line terminator used by line anchors. The line anchors are '(?m:^)' and
+'(?m:$)'. By default, they both use '\n' as line terminators for matching
+purposes. This option changes the line terminator to any arbitrary byte.
+
+Note that CRLF aware line anchors, that is, '(?Rm:^)' and '(?Rm:$)', are
+unaffected by this option. CRLF aware line anchors always use '\r' and '\n'
+as line terminators and do not match between a '\r' and '\n'.
+"#,
+            ),
+            Usage::new(
+                "--no-hybrid",
+                "Disable the use of a lazy DFA.",
+                r#"
+This prevents the meta regex engine from building and using a lazy DFA.
+"#,
+            ),
+            Usage::new(
+                "--no-dfa",
+                "Disable the use of a fully compiled DFA.",
+                r#"
+This prevents the meta regex engine from building and using a fully compiled
+DFA.
+"#,
+            ),
+            Usage::new(
+                "--no-onepass",
+                "Disable the use of a one-pass DFA.",
+                r#"
+This prevents the meta regex engine from building and using a one-pass DFA.
+"#,
+            ),
+            Usage::new(
+                "--no-backtrack",
+                "Disable the use of a bounded backtracker.",
+                r#"
+This prevents the meta regex engine from building and using a bounded
+backtracker.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/mod.rs b/regex-cli/args/mod.rs
new file mode 100644
index 0000000000..ba5a032f4a
--- /dev/null
+++ b/regex-cli/args/mod.rs
@@ -0,0 +1,287 @@
+use std::{
+    fmt::{Debug, Display, Write},
+    str::FromStr,
+};
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser, ValueExt},
+};
+
+pub mod api;
+pub mod backtrack;
+pub mod common;
+pub mod dfa;
+pub mod flags;
+pub mod haystack;
+pub mod hybrid;
+pub mod input;
+pub mod lite;
+pub mod meta;
+pub mod onepass;
+pub mod overlapping;
+pub mod patterns;
+pub mod pikevm;
+pub mod syntax;
+pub mod thompson;
+
+pub trait Configurable: Debug {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool>;
+
+    fn usage(&self) -> &[Usage];
+}
+
+pub fn configure(
+    p: &mut Parser,
+    usage: &str,
+    targets: &mut [&mut dyn Configurable],
+) -> anyhow::Result<()> {
+    while let Some(arg) = p.next()? {
+        match arg {
+            Arg::Short('h') | Arg::Long("help") => {
+                let mut usages = vec![];
+                for t in targets.iter() {
+                    usages.extend_from_slice(t.usage());
+                }
+                usages.sort_by_key(|u| {
+                    u.format
+                        .split_once(", ")
+                        .map(|(_, long)| long)
+                        .unwrap_or(u.format)
+                });
+                let options = if arg == Arg::Short('h') {
+                    Usage::short(&usages)
+                } else {
+                    Usage::long(&usages)
+                };
+                let usage = usage.replace("%options%", &options);
+                anyhow::bail!("{}", usage.trim());
+            }
+            _ => {}
+        }
+        // We do this little dance to disentangle the lifetime of 'p' from the
+        // lifetime on 'arg'. The cost is that we have to clone all long flag
+        // names to give it a place to live that isn't tied to 'p'. Annoying,
+        // but not the end of the world.
+        let long_flag: Option<String> = match arg {
+            Arg::Long(name) => Some(name.to_string()),
+            _ => None,
+        };
+        let mut arg = match long_flag {
+            Some(ref flag) => Arg::Long(flag),
+            None => match arg {
+                Arg::Short(c) => Arg::Short(c),
+                Arg::Long(_) => unreachable!(),
+                Arg::Value(value) => Arg::Value(value),
+            },
+        };
+        // OK, now ask all of our targets whether they want this argument.
+        let mut recognized = false;
+        for t in targets.iter_mut() {
+            if t.configure(p, &mut arg)? {
+                recognized = true;
+                break;
+            }
+        }
+        if !recognized {
+            return Err(arg.unexpected().into());
+        }
+    }
+    Ok(())
+}
+
+/*
+pub struct AdHoc<'a> {
+    usage: Usage,
+    configure:
+        Box<dyn FnMut(&mut Parser, &mut Arg) -> anyhow::Result<bool> + 'a>,
+}
+
+impl<'a> AdHoc<'a> {
+    pub fn new(
+        usage: Usage,
+        configure: impl FnMut(&mut Parser, &mut Arg) -> anyhow::Result<bool> + 'a,
+    ) -> AdHoc<'a> {
+        AdHoc { usage, configure: Box::new(configure) }
+    }
+}
+
+impl<'a> Configurable for AdHoc<'a> {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        (self.configure)(p, arg)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        std::slice::from_ref(&self.usage)
+    }
+}
+
+impl<'a> Debug for AdHoc<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("AdHoc")
+            .field("usage", &self.usage)
+            .field("configure", &"FnMut(..)")
+            .finish()
+    }
+}
+*/
+
+/// Parses the argument from the given parser as a command name, and returns
+/// it. If the next arg isn't a simple value then this returns an error.
+///
+/// This also handles the case where -h/--help is given, in which case, the
+/// given usage information is converted into an error and printed.
+pub fn next_as_command(usage: &str, p: &mut Parser) -> anyhow::Result<String> {
+    let usage = usage.trim();
+    let arg = match p.next()? {
+        Some(arg) => arg,
+        None => anyhow::bail!("{}", usage),
+    };
+    let cmd = match arg {
+        Arg::Value(cmd) => cmd.string()?,
+        Arg::Short('h') | Arg::Long("help") => anyhow::bail!("{}", usage),
+        arg => return Err(arg.unexpected().into()),
+    };
+    Ok(cmd)
+}
+
+/// Parses the next 'p.value()' into 'T'. Any error messages will include the
+/// given flag name in them.
+pub fn parse<T>(p: &mut Parser, flag_name: &'static str) -> anyhow::Result<T>
+where
+    T: FromStr,
+    <T as FromStr>::Err: Display + Debug + Send + Sync + 'static,
+{
+    // This is written somewhat awkwardly and the type signature is also pretty
+    // funky primarily because of the following two things: 1) the 'FromStr'
+    // impls in this crate just use 'anyhow::Error' for their error type and 2)
+    // 'anyhow::Error' does not impl 'std::error::Error'.
+    let osv = p.value().context(flag_name)?;
+    let strv = match osv.to_str() {
+        Some(strv) => strv,
+        None => {
+            let err = lexopt::Error::NonUnicodeValue(osv.into());
+            return Err(anyhow::Error::from(err).context(flag_name));
+        }
+    };
+    let parsed = match strv.parse() {
+        Err(err) => return Err(anyhow::Error::msg(err).context(flag_name)),
+        Ok(parsed) => parsed,
+    };
+    Ok(parsed)
+}
+
+/// Like `parse`, but permits the string value "none" to indicate absent. This
+/// is useful for parsing things like limits, where "no limit" is a legal
+/// value. But it can be used for anything.
+pub fn parse_maybe<T>(
+    p: &mut Parser,
+    flag_name: &'static str,
+) -> anyhow::Result<Option<T>>
+where
+    T: FromStr,
+    <T as FromStr>::Err: Display + Debug + Send + Sync + 'static,
+{
+    // This is written somewhat awkwardly and the type signature is also pretty
+    // funky primarily because of the following two things: 1) the 'FromStr'
+    // impls in this crate just use 'anyhow::Error' for their error type and 2)
+    // 'anyhow::Error' does not impl 'std::error::Error'.
+    let osv = p.value().context(flag_name)?;
+    let strv = match osv.to_str() {
+        Some(strv) => strv,
+        None => {
+            let err = lexopt::Error::NonUnicodeValue(osv.into());
+            return Err(anyhow::Error::from(err).context(flag_name));
+        }
+    };
+    if strv == "none" {
+        return Ok(None);
+    }
+    let parsed = match strv.parse() {
+        Err(err) => return Err(anyhow::Error::msg(err).context(flag_name)),
+        Ok(parsed) => parsed,
+    };
+    Ok(Some(parsed))
+}
+
+/// A type for expressing the documentation of a flag.
+///
+/// The `Usage::short` and `Usage::long` functions take a slice of usages and
+/// format them into a human readable display. It does simple word wrapping and
+/// column alignment for you.
+#[derive(Clone, Copy, Debug)]
+pub struct Usage {
+    /// The format of the flag, for example, `-k, --match-kind <kind>`.
+    pub format: &'static str,
+    /// A very short description of the flag. Should fit on one line along with
+    /// the format.
+    pub short: &'static str,
+    /// A longer form description of the flag. May be multiple paragraphs long
+    /// (but doesn't have to be).
+    pub long: &'static str,
+}
+
+impl Usage {
+    /// Create a new usage from the given components.
+    pub const fn new(
+        format: &'static str,
+        short: &'static str,
+        long: &'static str,
+    ) -> Usage {
+        Usage { format, short, long }
+    }
+
+    /// Format a two column table from the given usages, where the first
+    /// column is the format and the second column is the short description.
+    pub fn short(usages: &[Usage]) -> String {
+        const MIN_SPACE: usize = 2;
+
+        let mut result = String::new();
+        let max_len = match usages.iter().map(|u| u.format.len()).max() {
+            None => return result,
+            Some(len) => len,
+        };
+        for usage in usages.iter() {
+            let padlen = MIN_SPACE + (max_len - usage.format.len());
+            let padding = " ".repeat(padlen);
+            writeln!(result, "    {}{}{}", usage.format, padding, usage.short)
+                .unwrap();
+        }
+        result
+    }
+
+    /// Print the format of each usage and its long description below the
+    /// format. This also does appropriate indentation with the assumption that
+    /// it is in an OPTIONS section of a bigger usage message.
+    pub fn long(usages: &[Usage]) -> String {
+        let wrap_opts = textwrap::Options::new(79)
+            .initial_indent("        ")
+            .subsequent_indent("        ");
+        let mut result = String::new();
+        for (i, usage) in usages.iter().enumerate() {
+            if i > 0 {
+                writeln!(result, "").unwrap();
+            }
+            writeln!(result, "    {}", usage.format).unwrap();
+            for (i, paragraph) in usage.long.trim().split("\n\n").enumerate() {
+                if i > 0 {
+                    result.push('\n');
+                }
+                let flattened = paragraph.replace("\n", " ");
+                for line in textwrap::wrap(&flattened, &wrap_opts) {
+                    result.push_str(&line);
+                    result.push('\n');
+                }
+            }
+        }
+        result
+    }
+}
diff --git a/regex-cli/args/onepass.rs b/regex-cli/args/onepass.rs
new file mode 100644
index 0000000000..4261e8b214
--- /dev/null
+++ b/regex-cli/args/onepass.rs
@@ -0,0 +1,99 @@
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::{dfa::onepass, nfa::thompson::NFA},
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// Exposes the configuration of a one-pass DFA.
+#[derive(Debug, Default)]
+pub struct Config {
+    onepass: onepass::Config,
+}
+
+impl Config {
+    /// Return a `dfa::onepass::Config` object from this configuration.
+    pub fn onepass(&self) -> anyhow::Result<onepass::Config> {
+        Ok(self.onepass.clone())
+    }
+
+    /// Attempts to convert the given NFA into a one-pass DFA. If the NFA isn't
+    /// one-pass or if one of a few different limits is hit, then an error
+    /// is returned.
+    pub fn from_nfa(&self, nfa: &NFA) -> anyhow::Result<onepass::DFA> {
+        onepass::Builder::new()
+            .configure(self.onepass()?)
+            .build_from_nfa(nfa.clone())
+            .context("failed to compile onepass DFA")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('k') | Arg::Long("match-kind") => {
+                let kind: flags::MatchKind =
+                    args::parse(p, "-k/--match-kind")?;
+                self.onepass = self.onepass.clone().match_kind(kind.kind);
+            }
+            Arg::Long("starts-for-each-pattern") => {
+                self.onepass =
+                    self.onepass.clone().starts_for_each_pattern(true);
+            }
+            Arg::Short('C') | Arg::Long("no-byte-classes") => {
+                self.onepass = self.onepass.clone().byte_classes(false);
+            }
+            Arg::Long("onepass-size-limit") => {
+                let limit = args::parse_maybe(p, "--onepass-size-limit")?;
+                self.onepass = self.onepass.clone().size_limit(limit);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            flags::MatchKind::USAGE,
+            Usage::new(
+                "--starts-for-each-pattern",
+                "Add anchored start states for each pattern.",
+                r#"
+Add anchored start states for each pattern. This permits running an anchored
+search for a specific pattern using the --pattern-id flag. (Assuming this is
+a search command.)
+"#,
+            ),
+            Usage::new(
+                "-C, --no-byte-classes",
+                "Disable byte classes.",
+                r#"
+This casues all bytes to be an equivalence class unto themselves. By default,
+bytes are grouped into equivalence classes to reduce the size of the alphabet
+for a DFA, and therefore decreases overall space usage.
+
+It can be quite convenient to disable byte classes when looking at the debug
+representation of a DFA. Otherwise, the transitions are much harder for a human
+to read.
+"#,
+            ),
+            Usage::new(
+                "--onepass-size-limit",
+                "Set a limit on heap used by a one-pass DFA in bytes.",
+                r#"
+This sets a limit on the number of heap memory a one-pass DFA can use. The
+limit is enforced at one-pass DFA construction time. If the limit is exceeded,
+then construction will fail.
+
+A special value of 'none' may be given, which disables the limit.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/overlapping.rs b/regex-cli/args/overlapping.rs
new file mode 100644
index 0000000000..c925159e06
--- /dev/null
+++ b/regex-cli/args/overlapping.rs
@@ -0,0 +1,46 @@
+use lexopt::{Arg, Parser};
+
+use crate::args::{Configurable, Usage};
+
+/// This defines a configuration for overlapping searches.
+///
+/// Currently, this just controls whether an overlapping search is enabled or
+/// not. By default, it's disabled.
+#[derive(Debug, Default)]
+pub struct Config {
+    pub enabled: bool,
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("overlapping") => {
+                self.enabled = true;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[Usage::new(
+            "--overlapping",
+            "Enable overlapping search.",
+            r#"
+Enable overlapping search. When this is enabled, the regex matcher will
+atempt to report all possible matches. Generally speaking, when one enables
+overlapping search, you also want to ensure that '--match-kind all' is given as
+well. Otherwise the overlapping search is unlikely to work as one would expect
+since any match semantics other than 'all' exclude some subset of matches from
+the underlying automaton.
+
+Note that overlapping search is not supported in every regex matcher.
+"#,
+        )];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/patterns.rs b/regex-cli/args/patterns.rs
new file mode 100644
index 0000000000..f07f760eea
--- /dev/null
+++ b/regex-cli/args/patterns.rs
@@ -0,0 +1,188 @@
+use std::path::PathBuf;
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser, ValueExt},
+};
+
+use crate::args::{Configurable, Usage};
+
+/// A configuration object for reading patterns from the command line.
+///
+/// It supports two different modes. One mode limits it to reading patterns
+/// from optional flags, i.e., `-p/--pattern` and `-f/--pattern-file`. The
+/// other mode permits reading from optional flags, but also reads all
+/// positional arguments as patterns too. The latter is convenient in cases
+/// where patterns are the only input to a command (like `regex-cli debug`).
+#[derive(Debug, Default)]
+pub struct Config {
+    patterns: Vec<String>,
+    fixed_strings: bool,
+    combine: bool,
+    mode: Mode,
+}
+
+impl Config {
+    /// Creates a new configuration that will greedily treat every positional
+    /// argument as a pattern. This also supports all other ways of providing
+    /// patterns, i.e., the `-p/--pattern` and `-f/--file` flags.
+    ///
+    /// This is useful for commands that don't accept any other kind of
+    /// positional arguments.
+    pub fn positional() -> Config {
+        Config { mode: Mode::Positional, ..Config::default() }
+    }
+
+    /// Creates a new configuration that will never treat a positional argument
+    /// as a pattern. Instead, it only reads patterns from the `-p/--pattern`
+    /// and `-f/--file` flags.
+    ///
+    /// This is useful for commands that accept other kinds of positional
+    /// arguments. Forcing the use of a flag helps avoid resolving more
+    /// complicated ambiguities regarding how to treat each positional
+    /// argument.
+    ///
+    /// This is equivalent to `Config::default()`.
+    pub fn only_flags() -> Config {
+        Config::default()
+    }
+
+    /// Returns all of the pattern strings from this configuration, escaping
+    /// and joining them if requested. When joining is requested, then at most
+    /// one pattern is returned.
+    ///
+    /// Note that it is legal for this to return zero patterns!
+    pub fn get(&self) -> anyhow::Result<Vec<String>> {
+        let mut pats = self.patterns.clone();
+        if self.fixed_strings {
+            pats = pats.iter().map(|p| regex_syntax::escape(p)).collect();
+        }
+        if self.combine {
+            // FIXME: This is... not technically correct, since someone could
+            // provide a pattern `ab(cd` and then `ef)gh`. Neither are valid
+            // patterns, but by joining them with a |, we get `ab(cd|ef)gh`
+            // which is valid. The solution to this is I think to try and
+            // parse the regex to make sure it's valid, but we should be
+            // careful to only use the AST parser. The problem here is that
+            // we don't technically have the configuration of the parser at
+            // this point. We could *ask* for it. We could also just assume a
+            // default configuration since the AST parser doesn't have many
+            // configuration knobs. But probably we should just ask for the
+            // parser configuration here.
+            pats = vec![pats.join("|")];
+        }
+        Ok(pats)
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('p') | Arg::Long("pattern") => {
+                let pat = p.value().context("-p/--pattern needs a value")?;
+                let pat = pat
+                    .string()
+                    .context("-p/--pattern must be valid UTF-8")?;
+                self.patterns.push(pat);
+            }
+            Arg::Short('F') | Arg::Long("fixed-strings") => {
+                self.fixed_strings = true;
+            }
+            Arg::Short('f') | Arg::Long("pattern-file") => {
+                let path =
+                    PathBuf::from(p.value().context("-f/--pattern-file")?);
+                let contents =
+                    std::fs::read_to_string(&path).with_context(|| {
+                        anyhow::anyhow!("failed to read {}", path.display())
+                    })?;
+                self.patterns.extend(contents.lines().map(|x| x.to_string()));
+            }
+            Arg::Long("combine-patterns") => {
+                self.combine = true;
+            }
+            Arg::Value(ref mut v) => {
+                if !matches!(self.mode, Mode::Positional) {
+                    return Ok(false);
+                }
+                let v = std::mem::take(v);
+                self.patterns
+                    .push(v.string().context("patterns must be valid UTF-8")?);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "-p, --pattern <pattern>",
+                "Add a pattern to this command.",
+                r#"
+This adds a new pattern to the command.
+
+All of the patterns provided, whether by this flag, as a positional argument
+(if supported) or via the -f/--pattern-file flag are combined into one regex
+matcher.
+
+All patterns given must be valid UTF-8.
+"#,
+            ),
+            Usage::new(
+                "-f, --pattern-file",
+                "Read patterns from the file given.",
+                r#"
+Reads patterns, one per line, from the file given.
+
+All of the patterns provided, whether by this flag, as a positional argument
+(if supported) or via the -p/--pattern flag are combined into one regex
+matcher.
+
+All patterns given must be valid UTF-8.
+"#,
+            ),
+            Usage::new(
+                "-F, --fixed-strings",
+                "Interpret all patterns literally.",
+                r#"
+When set, all patterns are interpreted as literal strings. So for example,
+special regex meta characters like '+' are matched literally instead of being
+given special significance.
+"#,
+            ),
+            Usage::new(
+                "--combine-patterns",
+                "Combine all patterns into one via an alternation.",
+                r#"
+This flag combines all patterns given in this command into one by joining
+them together via a '|'. This is useful in cases where you want to provide
+many different things to search for, but explicitly only want one pattern to
+be constructed. In terms of debugging the regex engine, this can be used to
+inspect the practical differences between multi-pattern regexes and single
+pattern regexes, even when they generally match the same thing.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
+
+/// The parsing behavior of a pattern configuration. That is, either treat
+/// positional arguments as patterns or not.
+///
+/// The default is to only parse patterns from flags.
+#[derive(Debug)]
+enum Mode {
+    Positional,
+    OnlyFlags,
+}
+
+impl Default for Mode {
+    fn default() -> Mode {
+        Mode::OnlyFlags
+    }
+}
diff --git a/regex-cli/args/pikevm.rs b/regex-cli/args/pikevm.rs
new file mode 100644
index 0000000000..686b6e7d0e
--- /dev/null
+++ b/regex-cli/args/pikevm.rs
@@ -0,0 +1,51 @@
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::nfa::thompson::{pikevm, NFA},
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// This exposes the configuration knobs for a `PikeVM`.
+#[derive(Debug, Default)]
+pub struct Config {
+    pikevm: pikevm::Config,
+}
+
+impl Config {
+    /// Return a `pikevm::Config` object from this configuration.
+    pub fn pikevm(&self) -> anyhow::Result<pikevm::Config> {
+        Ok(self.pikevm.clone())
+    }
+
+    /// Builds a `PikeVM` regex engine from the NFA given.
+    pub fn from_nfa(&self, nfa: &NFA) -> anyhow::Result<pikevm::PikeVM> {
+        pikevm::Builder::new()
+            .configure(self.pikevm()?)
+            .build_from_nfa(nfa.clone())
+            .context("failed to build PikeVM matcher")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('k') | Arg::Long("match-kind") => {
+                let kind: flags::MatchKind =
+                    args::parse(p, "-k/--match-kind")?;
+                self.pikevm = self.pikevm.clone().match_kind(kind.kind);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[flags::MatchKind::USAGE];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/syntax.rs b/regex-cli/args/syntax.rs
new file mode 100644
index 0000000000..a91ac2dcae
--- /dev/null
+++ b/regex-cli/args/syntax.rs
@@ -0,0 +1,272 @@
+use std::borrow::Borrow;
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::util::syntax,
+    regex_syntax::{ast::Ast, hir::Hir},
+};
+
+use crate::args::{self, Configurable, Usage};
+
+/// This exposes all of the configuration knobs on a
+/// regex_automata::util::syntax::Config via CLI flags.
+#[derive(Debug, Default)]
+pub struct Config {
+    syntax: syntax::Config,
+}
+
+impl Config {
+    /// Return a `syntax::Config` object from this configuration.
+    pub fn syntax(&self) -> anyhow::Result<syntax::Config> {
+        Ok(self.syntax.clone())
+    }
+
+    /// Parses the given pattern into an `Ast`.
+    fn ast(&self, pattern: &str) -> anyhow::Result<Ast> {
+        regex_syntax::ast::parse::ParserBuilder::new()
+            .nest_limit(self.syntax.get_nest_limit())
+            .octal(self.syntax.get_octal())
+            .ignore_whitespace(self.syntax.get_ignore_whitespace())
+            .build()
+            .parse(pattern)
+            .context("failed to parse pattern")
+    }
+
+    /// Parses the given patterns into a corresponding sequence of `Ast`s. If
+    /// any of the patterns fail to parse, then an error is returned.
+    pub fn asts<P: AsRef<str>>(
+        &self,
+        patterns: &[P],
+    ) -> anyhow::Result<Vec<Ast>> {
+        patterns
+            .iter()
+            .enumerate()
+            .map(|(i, p)| {
+                let p = p.as_ref();
+                self.ast(p).with_context(|| {
+                    format!("failed to parse pattern {} to AST: '{}'", i, p,)
+                })
+            })
+            .collect()
+    }
+
+    /// Translates the given pattern and `Ast` into an `Hir`.
+    pub fn hir(&self, pattern: &str, ast: &Ast) -> anyhow::Result<Hir> {
+        regex_syntax::hir::translate::TranslatorBuilder::new()
+            .utf8(self.syntax.get_utf8())
+            .case_insensitive(self.syntax.get_case_insensitive())
+            .multi_line(self.syntax.get_multi_line())
+            .dot_matches_new_line(self.syntax.get_dot_matches_new_line())
+            .swap_greed(self.syntax.get_swap_greed())
+            .unicode(self.syntax.get_unicode())
+            .build()
+            .translate(pattern, ast)
+            .context("failed to translate pattern")
+    }
+
+    /// Translates the given patterns and corresponding `Ast`s into a
+    /// corresponding sequence of `Hir`s. If any of the patterns fail to
+    /// translate, then an error is returned.
+    pub fn hirs<P: AsRef<str>, A: Borrow<Ast>>(
+        &self,
+        patterns: &[P],
+        asts: &[A],
+    ) -> anyhow::Result<Vec<Hir>> {
+        patterns
+            .iter()
+            .zip(asts.iter())
+            .enumerate()
+            .map(|(i, (pat, ast))| {
+                let (pat, ast) = (pat.as_ref(), ast.borrow());
+                self.hir(pat, ast).with_context(|| {
+                    format!(
+                        "failed to translate pattern {} to HIR: '{}'",
+                        i, pat,
+                    )
+                })
+            })
+            .collect()
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('i') | Arg::Long("case-insensitive") => {
+                self.syntax = self.syntax.case_insensitive(true);
+            }
+            Arg::Long("multi-line") => {
+                self.syntax = self.syntax.multi_line(true);
+            }
+            Arg::Long("dot-matches-new-line") => {
+                self.syntax = self.syntax.dot_matches_new_line(true);
+            }
+            Arg::Long("crlf") => {
+                self.syntax = self.syntax.crlf(true);
+            }
+            Arg::Long("swap-greed") => {
+                self.syntax = self.syntax.swap_greed(true);
+            }
+            Arg::Long("ignore-whitespace") => {
+                self.syntax = self.syntax.ignore_whitespace(true);
+            }
+            Arg::Short('U') | Arg::Long("no-unicode") => {
+                self.syntax = self.syntax.unicode(false);
+            }
+            Arg::Short('b') | Arg::Long("no-utf8-syntax") => {
+                self.syntax = self.syntax.utf8(false);
+            }
+            Arg::Long("nest-limit") => {
+                let limit = args::parse(p, "--nest-limit")?;
+                self.syntax = self.syntax.nest_limit(limit);
+            }
+            Arg::Long("octal") => {
+                self.syntax = self.syntax.octal(true);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "-i, --case-insensitive",
+                "Enable case insensitive mode.",
+                r#"
+This enables case insensitive mode for all regex patterns given. When absent,
+all patterns are matched case sensitively.
+
+Note that individual patterns can have case insensitivity enabled via the
+inline regex flag 'i'. For example, '(?i:abc)'.
+"#,
+            ),
+            Usage::new(
+                "--multi-line",
+                "Enable multi-line mode.",
+                r#"
+This enables multi-line mode for all regex patterns given. When multi-line
+mode is enabled, the anchors '^' and '$' turn into line anchors. That is,
+in addition to matching the start and end of a haystack, they also match at
+the start and end of a line, respectively.
+
+Note that individual patterns can have multi-line mode enabled via the
+inline regex flag 'm'. For example, '(?m:^)'.
+"#,
+            ),
+            Usage::new(
+                "--dot-matches-new-line",
+                "Make a dot match \\n.",
+                r#"
+Enabling this causes a '.' (dot) to match the line terminator. By default, a
+dot is equivalent to '[^\n]'. (When CRLF mode is enabled it is equivalent to
+'[^\r\n]'.)
+
+Note that individual patterns can have this mode enabled via the inline regex
+flag 's'. For example, '(?s:.)'.
+"#,
+            ),
+            Usage::new(
+                "--crlf",
+                "Line anchors are CRLF aware.",
+                r#"
+When enabled, line anchors become CRLF aware. That is, patterns like '(?m:^)'
+and '(?m:$)' only consider '\n' by default. But when CRLF mode is enabled, line
+anchors consider both '\r' and '\n'. In particular, line anchors will match
+both '\r' and '\n', but never between '\r' and '\n'.
+
+Additionally, when this mode is enabled, '.' is equivalent to '[^\r\n]' instead
+of '[^\n]'.
+
+Note that this does not enable multi-line mode by itself. This only applies to
+'^' and '$' when multi-line mode is enabled.
+
+Note that individual patterns can have CRLF mode enabled via the inline regex
+flag 'R'. For example, '(?Rm:^)'.
+"#,
+            ),
+            Usage::new(
+                "--swap-greed",
+                "Swap the meaning of greediness.",
+                r#"
+This enables "swap greed" mode for all regex patterns given. When greediness
+is swapped, greedy patterns like 'a+' become equivalent to 'a+?', and ungreedy
+patterns like 'a+?' become equivalent to 'a+'.
+
+Note that individual patterns can have "swap greed" mode enabled via the inline
+regex flag 'U'. For example, '(?U:a+)'.
+"#,
+            ),
+            Usage::new(
+                "--ignore-whitespace",
+                "Enable whitespace insensitive mode.",
+                r#"
+This enables whitespace insensitive mode for all regex patterns given. When
+enabled, all whitespace in regex patterns is ignored. Moreover, any lines whose
+first non-whitespace character is '#' will be ignored and treated as a comment.
+
+Note that individual patterns can have whitespace insensitivity enabled via the
+inline regex flag 'x'. For example, '(?x:a b c)' is equivalent to 'abc'.
+"#,
+            ),
+            Usage::new(
+                "-U, --no-unicode",
+                "Disable Unicode mode.",
+                r#"
+This disables Unicode mode for all regex patterns given. When Unicode mode is
+disabled, the logical unit of searching is a single byte, where as when it
+is enabled the logical unit of searching is a single codepoint. In practice,
+this means that Unicode mode makes a number of alterations to the syntax and
+semantics of a regex. 1) '[^a]' matches any codepoint that isn't 'a' instead
+of any byte that isn't 'a'. 2) Case insensitive mode takes Unicode simple case
+folding rules into account. 3) Unicode literals and character classes are
+allowed.
+
+Note that individual patterns can have Unicode mode disabled via the inline
+regex flag 'u'. For example, '(?-u:\xFF)' matches the byte '\xFF' where as
+'(?u:\xFF)' matches the UTF-8 encoding of the Unicode codepoint U+00FF.
+"#,
+            ),
+            Usage::new(
+                "-b, --no-utf8-syntax",
+                "Disable UTF-8 mode for the regex syntax.",
+                r#"
+This disables UTF-8 mode for all regex patterns given. Disabling UTF-8 mode
+permits regexes that match invalid UTF-8. When UTF-8 mode is enabled, then
+patterns are limited to matches corresponding to valid UTF-8.
+
+This only applies to non-empty matches. For empty matches, the UTF-8 mode is
+controlled on the NFA, via --no-utf8-nfa (if applicable).
+"#,
+            ),
+            Usage::new(
+                "--nest-limit",
+                "Set the nest limit on the syntax.",
+                r#"
+This sets the nesting limit of the regex syntax on all patterns. This controls
+how many "nested" constructs are permitted in the pattern. This is useful for
+preventing pathological regexes that require too much nesting. For example,
+if one wants to do recursive analysis on the syntax of a regex, you usually
+need to check that it doesn't have too much nesting or else you risk a stack
+overflow.
+
+Note that the default is likely big enough to permit most regex patterns.
+"#,
+            ),
+            Usage::new(
+                "--octal",
+                "Permit octal escapes.",
+                r#"
+This permits octal escape sequences in the regex syntax. For example, it treats
+'\17' as equivalent to '\x0F'. This is disabled by default.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/args/thompson.rs b/regex-cli/args/thompson.rs
new file mode 100644
index 0000000000..6e7b4afd80
--- /dev/null
+++ b/regex-cli/args/thompson.rs
@@ -0,0 +1,161 @@
+use std::borrow::Borrow;
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::{nfa::thompson, util::look::LookMatcher},
+    regex_syntax::hir::Hir,
+};
+
+use crate::args::{self, flags, Configurable, Usage};
+
+/// This exposes all of the configuration knobs on a regex_automata::Input via
+/// CLI flags. The only aspect of regex_automata::Input that this does not
+/// cover is the haystack, which should be provided by other means (usually
+/// with `Haystack`).
+#[derive(Debug, Default)]
+pub struct Config {
+    thompson: thompson::Config,
+}
+
+impl Config {
+    /// Return a `thompson::Config` object from this configuration.
+    pub fn thompson(&self) -> anyhow::Result<thompson::Config> {
+        Ok(self.thompson.clone())
+    }
+
+    /// Returns a new configuration that compiles a reverse NFA.
+    pub fn reversed(&self) -> Config {
+        // Reverse DFAs require that captures are disabled. In practice, there
+        // is no current use case for a reverse NFA with capture groups.
+        let thompson = self.thompson.clone().reverse(true).captures(false);
+        Config { thompson }
+    }
+
+    /// Compiles the given `Hir` expressions into an NFA. If compilation fails,
+    /// then an error is returned. (And there is generally no way to know which
+    /// pattern caused a failure.)
+    pub fn from_hirs<H: Borrow<Hir>>(
+        &self,
+        hirs: &[H],
+    ) -> anyhow::Result<thompson::NFA> {
+        thompson::Compiler::new()
+            .configure(self.thompson()?)
+            .build_many_from_hir(hirs)
+            .context("failed to compile Thompson NFA")
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('B') | Arg::Long("no-utf8-nfa") => {
+                self.thompson = self.thompson.clone().utf8(false);
+            }
+            Arg::Short('r') | Arg::Long("reverse") => {
+                self.thompson = self.thompson.clone().reverse(true);
+            }
+            Arg::Long("nfa-size-limit") => {
+                let limit = args::parse_maybe(p, "--nfa-size-limit")?;
+                self.thompson = self.thompson.clone().nfa_size_limit(limit);
+            }
+            Arg::Long("shrink") => {
+                self.thompson = self.thompson.clone().shrink(true);
+            }
+            Arg::Long("no-captures") => {
+                self.thompson = self.thompson.clone().captures(false);
+            }
+            Arg::Long("line-terminator") => {
+                let byte: flags::OneByte =
+                    args::parse(p, "--line-terminator")?;
+                let mut lookm = LookMatcher::new();
+                lookm.set_line_terminator(byte.0);
+                self.thompson = self.thompson.clone().look_matcher(lookm);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "-B, --no-utf8-nfa",
+                "Disable UTF-8 mode for empty matches.",
+                r#"
+Disables UTF-8 mode for empty matches. When this flag is given, empty matches
+that split a codepoint are permitted. Otherwise, they are banned.
+"#,
+            ),
+            Usage::new(
+                "-r, --reverse",
+                "Build a reverse Thompson NFA.",
+                r#"
+Build a reverse Thompson NFA. The reverse NFA matches the language described
+by the corresponding forward NFA, but in reverse. In general, this is done by
+reversing the concatenations of the regex and inverting look-around assertions
+that depend on the direction of matching. So for example, `^` becomes `$` and
+`$` becomes `^`. But `\b` and `\B` remain the same.
+
+Note that at time of writing, using this flag requires also using
+--no-captures.
+"#,
+            ),
+            Usage::new(
+                "--nfa-size-limit",
+                "Sets a limit on the memory used by an NFA.",
+                r#"
+Sets a limit on the memory used by an NFA, in terms of bytes of heap usage.
+This limit is applied during NFA construction. If the limit is exceeded, then
+construction will fail.
+
+A special 'none' value disables the limit entirely.
+"#,
+            ),
+            Usage::new(
+                "--shrink",
+                "Enables NFA shrinking.",
+                r#"
+This flag enables NFA shrinking. At time of writing, this is an expensive
+process that only applies to reverse NFA compilation. The process may get
+cheaper or more widely applicable in the future, but it generally results
+in making the state graph of large Unicode character classes much smaller.
+Moreover, if you're building a fully compiled reverse DFA, the extra time
+spent shrinking the NFA can lead to far larger savings in the subsequent DFA
+determinization.
+"#,
+            ),
+            Usage::new(
+                "--no-captures",
+                "Disable capture states.",
+                r#"
+Disables capture states. By default, NFAs include special "capture" states that
+instruct some regex engines (like the PikeVM) to record offset positions in
+ancillary state.
+
+It can be useful to disable capture states in order to reduce "clutter" in the
+automaton when debugging it. Also, at time of writing, reverse NFAs require
+that capture groups are disabled.
+"#,
+            ),
+            Usage::new(
+                "--line-terminator",
+                "Set the line terminator used by line anchors.",
+                r#"
+Set the line terminator used by line anchors. The line anchors are '(?m:^)' and
+'(?m:$)'. By default, they both use '\n' as line terminators for matching
+purposes. This option changes the line terminator to any arbitrary byte.
+
+Note that CRLF aware line anchors, that is, '(?Rm:^)' and '(?Rm:$)', are
+unaffected by this option. CRLF aware line anchors always use '\r' and '\n'
+as line terminators and do not match between a '\r' and '\n'.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/cmd/compile_test.rs b/regex-cli/cmd/compile_test.rs
new file mode 100644
index 0000000000..049e2a6a7e
--- /dev/null
+++ b/regex-cli/cmd/compile_test.rs
@@ -0,0 +1,867 @@
+use std::{
+    io::Write,
+    path::{Path, PathBuf},
+    process::Command,
+    time::{Duration, Instant},
+};
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+};
+
+use crate::args::{self, Usage};
+
+const REGEX_COMBOS: &[&[&str]] = &[
+    &["std", "perf", "unicode"],
+    // TODO: Enable this once we've fully migrated over to regex-automata.
+    // &["std", "perf", "unicode", "perf-dfa-full"],
+    &["std"],
+    &["std", "perf"],
+    &["std", "unicode"],
+    &["std", "unicode-case", "unicode-perl"],
+];
+
+const REGEX_LITE_COMBOS: &[&[&str]] = &[&["std"]];
+
+const REGEX_AUTOMATA_COMBOS: &[&[&str]] = &[
+    &["std", "syntax", "perf", "unicode", "meta", "nfa", "dfa", "hybrid"],
+    // Try out some barebones combinations of individual regex engines.
+    &["std", "syntax", "nfa-pikevm"],
+    &["std", "syntax", "nfa-backtrack"],
+    &["std", "syntax", "hybrid"],
+    &["std", "syntax", "dfa-onepass"],
+    // Now try out some realistic plausible configurations that combine
+    // lots (but maybe not all) regex engines.
+    //
+    // First is dropping 'perf' from the default.
+    &["std", "syntax", "unicode", "meta", "nfa", "dfa", "hybrid"],
+    // Second is dropping 'dfa', which maybe doesn't carry its weight. We are
+    // careful to re-enable the one-pass DFA though.
+    &[
+        "std",
+        "syntax",
+        "perf",
+        "unicode",
+        "meta",
+        "nfa",
+        "hybrid",
+        "dfa-onepass",
+    ],
+    // This is dropping 'unicode', which comes with a whole bunch of tables.
+    &["std", "syntax", "perf", "meta", "nfa", "dfa", "hybrid"],
+    // Drop 'unicode' and also 'dfa'. But again, we keep the one-pass DFA
+    // around.
+    &["std", "syntax", "perf", "meta", "nfa", "hybrid", "dfa-onepass"],
+    // "I the meta regex API and don't care about perf, but I want full
+    // functionality."
+    &["std", "unicode", "meta"],
+    // "I just want the meta regex API, but just enough to make it work"
+    &["std", "meta"],
+];
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = r#"
+Runs compilation time and binary size tests on a variety of configurations.
+
+The output of this test includes compilation time, total binary size and
+relative binary size. Relative binary size is computed by subtracting the
+binary size of a simple "Hello, world!" program from the total size of the
+program compiled with calls to the regex (or regex-automata) crate. The purpose
+of relative size is to try to capture a metric that tracks the overhead of
+the regex crate specifically, and not just the total binary size (which might
+fluctuate with changes to the compiler).
+
+The configurations are a combination of several things. 1) Various interesting
+feature combinations from regex (and regex-automata when it's enabled). 2)
+Debug and release mode Cargo profiles.
+
+Other things, such as lto, are not considered. Instead, we use defaults for
+options like lto.
+
+The arguments given to this command are as follows:
+
+The first is a directory containing a checkout of the regex crate repo.
+
+The second is a directory where a bunch of different Cargo projects will be
+written.
+
+USAGE:
+    regex-cli compile-test <regex-crate-dir> <out-dir>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+"#;
+
+    let mut config = Config::default();
+    args::configure(p, USAGE, &mut [&mut config])?;
+
+    let outdir = config.outdir()?;
+    let revision = git_revision_hash(&config.regexdir()?)?;
+    let baseline_size_dev = baseline_size(&outdir, Profile::Dev)?;
+    let baseline_size_rel = baseline_size(&outdir, Profile::Release)?;
+
+    // We don't bother bringing in a CSV writer just for this. While we don't
+    // check it, none of our field values should contain quotes or delimiters.
+    // This is still somewhat shady, but not nearly as bad as trying to roll
+    // our own CSV parser.
+    let mut wtr = std::io::stdout();
+    writeln!(wtr, "name,crate,revision,profile,duration,size,relative-size")?;
+    for test in config.tests()? {
+        let tdir = TestDir::new(&outdir, test)?;
+        tdir.write_cargo_toml()?;
+        tdir.write_main_rs()?;
+        tdir.cargo_clean()?;
+        tdir.cargo_fetch()?;
+        let m = tdir.cargo_build()?;
+        let relative_size = m.size.saturating_sub(match tdir.test.profile {
+            Profile::Dev => baseline_size_dev,
+            Profile::Release => baseline_size_rel,
+        });
+
+        write!(wtr, "{},", tdir.test.name())?;
+        if tdir.test.regex_automata {
+            write!(wtr, "regex-automata,")?;
+        } else {
+            write!(wtr, "regex,")?;
+        }
+        write!(wtr, "{},", revision)?;
+        write!(wtr, "{},", tdir.test.profile.as_str())?;
+        write!(wtr, "{:?},", m.duration)?;
+        write!(wtr, "{:?},", m.size)?;
+        write!(wtr, "{:?}", relative_size)?;
+        write!(wtr, "\n")?;
+    }
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct Config {
+    regexdir: Option<PathBuf>,
+    outdir: Option<PathBuf>,
+    regex_lite: bool,
+    regex_automata: bool,
+}
+
+impl args::Configurable for Config {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("regex-lite") => {
+                self.regex_lite = true;
+            }
+            Arg::Long("regex-automata") => {
+                self.regex_automata = true;
+            }
+            Arg::Value(ref mut v) => {
+                if self.regexdir.is_none() {
+                    let dir = PathBuf::from(std::mem::take(v));
+                    self.regexdir = Some(
+                        std::fs::canonicalize(&dir).with_context(|| {
+                            format!("could not canonicalize {}", dir.display())
+                        })?,
+                    );
+                } else if self.outdir.is_none() {
+                    self.outdir = Some(PathBuf::from(std::mem::take(v)));
+                } else {
+                    anyhow::bail!("more than 2 arguments were given");
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--regex-automata",
+                "Run tests for regex-automata too.",
+                r#"
+When enabled, this will run compilation time and binary size tests for
+regex-automata too. regex-automata has several interesting configurations, so
+this may add quite a bit of time to the tests. But this is useful because it
+might provide a way to get better compilation times and binary sizes than is
+possible with the 'regex' crate proper. Thus, it is useful to track.
+"#,
+            ),
+            Usage::new(
+                "--regex-lite",
+                "Run tests for regex-lite too.",
+                r#"
+When enabled, this will run compilation time and binary size tests for
+regex-lite too.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
+
+impl Config {
+    fn tests(&self) -> anyhow::Result<Vec<Test>> {
+        let mut tests = vec![];
+        for profile in [Profile::Dev, Profile::Release] {
+            for features in REGEX_COMBOS.iter() {
+                let features =
+                    features.iter().map(|f| f.to_string()).collect();
+                tests.push(Test {
+                    regex_dir: self.regexdir()?.to_path_buf(),
+                    profile,
+                    features,
+                    regex_lite: false,
+                    regex_automata: false,
+                });
+            }
+            if self.regex_lite {
+                for features in REGEX_LITE_COMBOS.iter() {
+                    let features =
+                        features.iter().map(|f| f.to_string()).collect();
+                    tests.push(Test {
+                        regex_dir: self.regexdir()?.to_path_buf(),
+                        profile,
+                        features,
+                        regex_lite: true,
+                        regex_automata: false,
+                    });
+                }
+            }
+            if self.regex_automata {
+                for features in REGEX_AUTOMATA_COMBOS.iter() {
+                    let features =
+                        features.iter().map(|f| f.to_string()).collect();
+                    tests.push(Test {
+                        regex_dir: self.regexdir()?.to_path_buf(),
+                        profile,
+                        features,
+                        regex_lite: false,
+                        regex_automata: true,
+                    });
+                }
+            }
+        }
+        Ok(tests)
+    }
+
+    fn regexdir(&self) -> anyhow::Result<&Path> {
+        self.regexdir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <regex-crate-dir>"))
+    }
+
+    fn outdir(&self) -> anyhow::Result<&Path> {
+        self.outdir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <out-dir>"))
+    }
+}
+
+#[derive(Debug)]
+struct TestDir {
+    dir: PathBuf,
+    test: Test,
+}
+
+impl TestDir {
+    /// Creates a new test directory for the given test. The directory for the
+    /// test is created as a child of `parent_dir`.
+    fn new(parent_dir: &Path, test: Test) -> anyhow::Result<TestDir> {
+        let dir = parent_dir.join(test.name());
+        std::fs::create_dir_all(&dir)
+            .with_context(|| dir.display().to_string())?;
+        Ok(TestDir { dir, test })
+    }
+
+    /// Write the Cargo.toml for this test
+    fn write_cargo_toml(&self) -> anyhow::Result<()> {
+        let path = self.dir.join("Cargo.toml");
+        std::fs::write(&path, self.test.cargo_toml())
+            .with_context(|| path.display().to_string())?;
+        Ok(())
+    }
+
+    /// Write the main.rs for this test.
+    fn write_main_rs(&self) -> anyhow::Result<()> {
+        let path = self.dir.join("main.rs");
+        std::fs::write(&path, self.test.main_rs())
+            .with_context(|| path.display().to_string())?;
+        Ok(())
+    }
+
+    /// Clean the Cargo project in this directory, to ensure we start fresh.
+    fn cargo_clean(&self) -> anyhow::Result<()> {
+        let status = Command::new("cargo")
+            .arg("clean")
+            .arg("--manifest-path")
+            .arg(self.dir.join("Cargo.toml"))
+            .status()
+            .with_context(|| {
+                format!("'cargo clean' failed for test '{}'", self.test.name())
+            })?;
+        anyhow::ensure!(
+            status.success(),
+            "'cargo clean' got an error exit code of {:?} for test '{}'",
+            status,
+            self.test.name(),
+        );
+        Ok(())
+    }
+
+    /// Fetch all dependencies for the Cargo project in this directory.
+    fn cargo_fetch(&self) -> anyhow::Result<()> {
+        let status = Command::new("cargo")
+            .arg("fetch")
+            .arg("--manifest-path")
+            .arg(self.dir.join("Cargo.toml"))
+            .status()
+            .with_context(|| {
+                format!("'cargo fetch' failed for test '{}'", self.test.name())
+            })?;
+        anyhow::ensure!(
+            status.success(),
+            "'cargo fetch' got an error exit code of {:?} for test '{}'",
+            status,
+            self.test.name(),
+        );
+        Ok(())
+    }
+
+    /// Build the test and return the time it took and the size of the binary.
+    ///
+    /// Callers should run 'cargo_fetch()' before this, as this passes the
+    /// '--offline' flag. This ensures that our timing measurement only
+    /// includes build times.
+    fn cargo_build(&self) -> anyhow::Result<Measurement> {
+        let start = Instant::now();
+        let status = Command::new("cargo")
+            .arg("build")
+            .arg("--manifest-path")
+            .arg(self.dir.join("Cargo.toml"))
+            .arg("--offline")
+            .arg("--profile")
+            .arg(self.test.profile.as_str())
+            .status()
+            .with_context(|| {
+                format!("'cargo build' failed for test '{}'", self.test.name())
+            })?;
+        anyhow::ensure!(
+            status.success(),
+            "'cargo build' got an error exit code of {:?} for test '{}'",
+            status,
+            self.test.name(),
+        );
+        let duration = start.elapsed();
+        let bin = self
+            .dir
+            .join("target")
+            .join(self.test.profile.as_str_for_target_path())
+            .join(format!("main{}", std::env::consts::EXE_SUFFIX));
+        let size = std::fs::metadata(&bin)
+            .with_context(|| bin.display().to_string())?
+            .len();
+        Ok(Measurement { duration, size })
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Measurement {
+    duration: Duration,
+    size: u64,
+}
+
+#[derive(Debug)]
+struct Test {
+    /// The path to the directory containing the regex crate.
+    regex_dir: PathBuf,
+    /// The Cargo profile to use.
+    profile: Profile,
+    /// The list of crate features to enabled.
+    features: Vec<String>,
+    /// Whether we're testing the regex-lite crate or not.
+    regex_lite: bool,
+    /// Whether we're testing the regex-automata crate or not.
+    regex_automata: bool,
+}
+
+impl Test {
+    /// Returns the name for this test.
+    ///
+    /// The name is meant to be a unique identifier for this test based on its
+    /// configuration. At the time of writing, the configuration space is still
+    /// somewhat small enough where this is reasonable. But if it blows up in
+    /// the future, we might need to reconsider the approach here... But that
+    /// would be sad.
+    fn name(&self) -> String {
+        // Bah, we should probably use an enum for this but I got lazy.
+        assert!(!(self.regex_lite && self.regex_automata));
+        let krate = if self.regex_lite {
+            "regex-lite"
+        } else if self.regex_automata {
+            "regex-automata"
+        } else {
+            "regex"
+        };
+        let profile = self.profile.as_str();
+        let features = self.features.join("_");
+        format!("{krate}__{profile}__{features}")
+    }
+
+    /// Return a string corresponding to the `Cargo.toml` for this test.
+    fn cargo_toml(&self) -> String {
+        if self.regex_lite {
+            self.cargo_toml_regex_lite()
+        } else if self.regex_automata {
+            self.cargo_toml_regex_automata()
+        } else {
+            self.cargo_toml_regex()
+        }
+    }
+
+    /// Return a string corresponding to the `main.rs` for this test.
+    fn main_rs(&self) -> String {
+        if self.regex_lite {
+            self.main_rs_regex_lite()
+        } else if self.regex_automata {
+            self.main_rs_regex_automata()
+        } else {
+            self.main_rs_regex()
+        }
+    }
+
+    fn cargo_toml_regex(&self) -> String {
+        let name = self.name();
+        let path = self.regex_dir.display();
+        let features = self
+            .features
+            .iter()
+            .map(|f| format!(r#""{}""#, f))
+            .collect::<Vec<String>>()
+            .join(", ");
+        format!(
+            r#"
+[package]
+name = "{name}"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+# This detaches this directory from any workspace
+# in a parent directory.
+[workspace]
+
+[[bin]]
+name = "main"
+path = "main.rs"
+
+[dependencies.regex]
+path = "{path}"
+version = "*"
+default-features = false
+features = [{features}]
+
+[profile.dev]
+strip = "symbols"
+
+[profile.release]
+strip = "symbols"
+"#
+        )
+    }
+
+    fn cargo_toml_regex_lite(&self) -> String {
+        let name = self.name();
+        let path = self.regex_dir.join("regex-lite");
+        let path = path.display();
+        let features = self
+            .features
+            .iter()
+            .map(|f| format!(r#""{}""#, f))
+            .collect::<Vec<String>>()
+            .join(", ");
+        format!(
+            r#"
+[package]
+name = "{name}"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+# This detaches this directory from any workspace
+# in a parent directory.
+[workspace]
+
+[[bin]]
+name = "main"
+path = "main.rs"
+
+[dependencies.regex-lite]
+path = "{path}"
+version = "*"
+default-features = false
+features = [{features}]
+
+[profile.dev]
+strip = "symbols"
+
+[profile.release]
+strip = "symbols"
+"#
+        )
+    }
+
+    fn cargo_toml_regex_automata(&self) -> String {
+        let name = self.name();
+        let path = self.regex_dir.join("regex-automata");
+        let path = path.display();
+        let features = self
+            .features
+            .iter()
+            .map(|f| format!(r#""{}""#, f))
+            .collect::<Vec<String>>()
+            .join(", ");
+        format!(
+            r#"
+[package]
+name = "{name}"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+# This detaches this directory from any workspace
+# in a parent directory.
+[workspace]
+
+[[bin]]
+name = "main"
+path = "main.rs"
+
+[dependencies.regex-automata]
+path = "{path}"
+default-features = false
+features = [{features}]
+
+[profile.dev]
+strip = "symbols"
+
+[profile.release]
+strip = "symbols"
+"#
+        )
+    }
+
+    fn main_rs_regex(&self) -> String {
+        format!(
+            r#"
+use regex::{{bytes, Regex, RegexSet}};
+
+fn main() {{
+    let re = Regex::new("a").unwrap();
+    assert!(re.is_match("a"));
+    assert_eq!("a", re.find("a").unwrap().as_str());
+    assert_eq!("a", &re.captures("a").unwrap()[0]);
+    assert_eq!(2, re.find_iter("aa").count());
+    assert_eq!(2, re.captures_iter("aa").count());
+
+    let re = bytes::Regex::new("a").unwrap();
+    assert!(re.is_match(b"a"));
+    assert_eq!(b"a", re.find(b"a").unwrap().as_bytes());
+    assert_eq!(b"a", &re.captures(b"a").unwrap()[0]);
+    assert_eq!(2, re.find_iter(b"aa").count());
+    assert_eq!(2, re.captures_iter(b"aa").count());
+
+    let re = RegexSet::new(&["a", "b"]).unwrap();
+    assert!(re.is_match("a"));
+    assert_eq!(2, re.matches("acdb").iter().count());
+
+    let re = bytes::RegexSet::new(&["a", "b"]).unwrap();
+    assert!(re.is_match(b"a"));
+    assert_eq!(2, re.matches(b"acdb").iter().count());
+}}
+"#
+        )
+    }
+
+    fn main_rs_regex_lite(&self) -> String {
+        format!(
+            r#"
+use regex_lite::{{Regex}};
+
+fn main() {{
+    let re = Regex::new("a").unwrap();
+    assert!(re.is_match("a"));
+    assert_eq!("a", re.find("a").unwrap().as_str());
+    assert_eq!("a", &re.captures("a").unwrap()[0]);
+    assert_eq!(2, re.find_iter("aa").count());
+    assert_eq!(2, re.captures_iter("aa").count());
+}}
+"#
+        )
+    }
+
+    fn main_rs_regex_automata(&self) -> String {
+        use std::fmt::Write;
+
+        let mut bufuse = String::new();
+        let mut bufmain = String::new();
+        if self.contains("nfa") || self.contains("nfa-pikevm") {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::nfa::thompson::pikevm::PikeVM;
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = PikeVM::new("a").unwrap();
+    let mut cache = re.create_cache();
+    assert!(re.is_match(&mut cache, "a"));
+    assert_eq!(0..1, re.find(&mut cache, "a").unwrap().range());
+    assert_eq!(2, re.find_iter(&mut cache, "aa").count());
+    assert_eq!(2, re.captures_iter(&mut cache, "aa").count());
+"#
+            )
+            .unwrap();
+        }
+        if self.contains("nfa") || self.contains("nfa-backtrack") {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::nfa::thompson::backtrack::BoundedBacktracker;
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = BoundedBacktracker::new("a").unwrap();
+    let mut cache = re.create_cache();
+    assert!(re.try_is_match(&mut cache, "a").unwrap());
+    assert_eq!(0..1, re.try_find(&mut cache, "a").unwrap().unwrap().range());
+    assert_eq!(2, re.try_find_iter(&mut cache, "aa").count());
+    assert_eq!(2, re.try_captures_iter(&mut cache, "aa").count());
+"#
+            )
+            .unwrap();
+        }
+        if self.contains("hybrid") {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::hybrid;
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = hybrid::dfa::DFA::new("a").unwrap();
+    let mut cache = re.create_cache();
+    let input = regex_automata::Input::new("a");
+    assert_eq!(1, re.try_search_fwd(&mut cache, &input).unwrap().unwrap().offset());
+"#
+            ).unwrap();
+        }
+        if self.contains("dfa")
+            || (self.contains("dfa-build") && self.contains("dfa-search"))
+        {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::dfa::{{Automaton, dense, sparse}};
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = dense::DFA::new("a").unwrap();
+    let input = regex_automata::Input::new("a");
+    assert_eq!(1, re.try_search_fwd(&input).unwrap().unwrap().offset());
+
+    let re = sparse::DFA::new("a").unwrap();
+    let input = regex_automata::Input::new("a");
+    assert_eq!(1, re.try_search_fwd(&input).unwrap().unwrap().offset());
+"#
+            )
+            .unwrap();
+        }
+        if self.contains("dfa") || self.contains("dfa-onepass") {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::dfa::onepass;
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = onepass::DFA::new("a").unwrap();
+    let mut cache = re.create_cache();
+    assert!(re.is_match(&mut cache, "a"));
+    let input = regex_automata::Input::new("a");
+    let mut caps = re.create_captures();
+    assert!(re.try_search(&mut cache, &input, &mut caps).is_ok());
+    assert_eq!(0..1, caps.get_match().unwrap().range());
+"#
+            )
+            .unwrap();
+        }
+        if self.contains("meta") {
+            writeln!(
+                bufuse,
+                r#"
+use regex_automata::meta;
+"#
+            )
+            .unwrap();
+            writeln!(
+                bufmain,
+                r#"
+    let re = meta::Regex::new("a").unwrap();
+    assert!(re.is_match("a"));
+    assert_eq!(0..1, re.find("a").unwrap().range());
+    let mut caps = re.create_captures();
+    re.captures("a", &mut caps);
+    assert_eq!(0..1, caps.get_match().unwrap().range());
+    assert_eq!(2, re.find_iter("aa").count());
+    assert_eq!(2, re.captures_iter("aa").count());
+"#
+            )
+            .unwrap();
+        }
+        format!(
+            r#"
+{bufuse}
+
+fn main() {{
+{bufmain}
+}}
+"#
+        )
+    }
+
+    fn contains(&self, feature_name: &str) -> bool {
+        self.features.iter().find(|name| feature_name == &**name).is_some()
+    }
+}
+
+/// The Cargo profile to use.
+#[derive(Clone, Copy, Debug)]
+enum Profile {
+    Dev,
+    Release,
+}
+
+impl Profile {
+    fn as_str(&self) -> &'static str {
+        match *self {
+            Profile::Dev => "dev",
+            Profile::Release => "release",
+        }
+    }
+
+    fn as_str_for_target_path(&self) -> &'static str {
+        match *self {
+            Profile::Dev => "debug",
+            Profile::Release => "release",
+        }
+    }
+}
+
+/// Compiles a basic "Hello, world!" program with the given profile and returns
+/// the size of the resulting binary.
+fn baseline_size(parent_dir: &Path, profile: Profile) -> anyhow::Result<u64> {
+    let dir = parent_dir.join(profile.as_str());
+    let cargo_toml_path = dir.join("Cargo.toml");
+    let main_rs_path = dir.join("main.rs");
+    std::fs::create_dir_all(&dir)
+        .with_context(|| dir.display().to_string())?;
+    std::fs::write(&cargo_toml_path, baseline_cargo_toml())
+        .with_context(|| dir.display().to_string())?;
+    std::fs::write(
+        &main_rs_path,
+        r#"fn main() {{ println!("Hello, world!"); }}"#,
+    )
+    .with_context(|| dir.display().to_string())?;
+
+    let status = Command::new("cargo")
+        .arg("clean")
+        .arg("--manifest-path")
+        .arg(&cargo_toml_path)
+        .status()
+        .with_context(|| format!("'cargo clean' failed for baseline"))?;
+    anyhow::ensure!(
+        status.success(),
+        "'cargo clean' got an error exit code of {:?} for baseline",
+        status,
+    );
+    let status = Command::new("cargo")
+        .arg("build")
+        .arg("--manifest-path")
+        .arg(dir.join("Cargo.toml"))
+        .arg("--offline")
+        .arg("--profile")
+        .arg(profile.as_str())
+        .status()
+        .with_context(|| format!("'cargo build' failed for baseline"))?;
+    anyhow::ensure!(
+        status.success(),
+        "'cargo build' got an error exit code of {:?} for baseline",
+        status,
+    );
+    let bin = dir
+        .join("target")
+        .join(profile.as_str_for_target_path())
+        .join(format!("main{}", std::env::consts::EXE_SUFFIX));
+    let size = std::fs::metadata(&bin)
+        .with_context(|| bin.display().to_string())?
+        .len();
+
+    Ok(size)
+}
+
+fn baseline_cargo_toml() -> String {
+    format!(
+        r#"
+[package]
+name = "baseline"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+# This detaches this directory from any workspace
+# in a parent directory.
+[workspace]
+
+[[bin]]
+name = "main"
+path = "main.rs"
+
+[profile.dev]
+strip = "symbols"
+
+[profile.release]
+strip = "symbols"
+"#
+    )
+}
+
+fn git_revision_hash(regex_dir: &Path) -> anyhow::Result<String> {
+    let output = std::process::Command::new("git")
+        .current_dir(regex_dir)
+        .args(&["rev-parse", "--short=10", "HEAD"])
+        .output()
+        .context("failed to run 'git rev-parse'")?;
+    let v = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    anyhow::ensure!(!v.is_empty(), "got empty output from 'git rev-parse'",);
+    Ok(v)
+}
diff --git a/regex-cli/cmd/debug/dfa.rs b/regex-cli/cmd/debug/dfa.rs
new file mode 100644
index 0000000000..9381cdadc8
--- /dev/null
+++ b/regex-cli/cmd/debug/dfa.rs
@@ -0,0 +1,326 @@
+use std::io::{stdout, Write};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+use {lexopt, regex_automata::dfa::Automaton};
+
+pub fn run_dense(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a dense DFA or a dense DFA regex.
+
+A DFA regex contains two DFAs: a forward DFA for finding the end of a match,
+and a reverse DFA for finding the start of a match. These can be compiled
+independently using just 'regex-cli debug dense dfa', but using the 'regex'
+sub-command will handle it for you and print the debug representation of both
+the forward and reverse DFAs.
+
+USAGE:
+    regex-cli debug dense <command> ...
+
+COMMANDS:
+    dfa    Print the debug representation of a single dense DFA.
+    regex  Print the debug representation of a forward and reverse DFA regex.
+";
+
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "dfa" => run_dense_dfa(p),
+        "regex" => run_dense_regex(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_dense_dfa(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a fully compiled dense DFA.
+
+USAGE:
+    regex-cli debug dense dfa [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (dfa, time) = util::timeitr(|| dfa.from_nfa(&nfa))?;
+    table.add("compile dfa time", time);
+    table.add("memory", dfa.memory_usage());
+    table.add("pattern len", dfa.pattern_len());
+    table.add("start kind", dfa.start_kind());
+    table.add("alphabet len", dfa.alphabet_len());
+    table.add("stride", dfa.stride());
+    table.add("has empty?", dfa.has_empty());
+    table.add("is utf8?", dfa.is_utf8());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", dfa)?;
+    }
+    Ok(())
+}
+
+fn run_dense_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a fully compiled dense DFA regex.
+
+This includes both the forward and reverse DFAs that make up a dense DFA regex.
+
+USAGE:
+    regex-cli debug dense regex [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (dfafwd, time) = util::timeitr(|| dfa.from_nfa(&nfafwd))?;
+    table.add("compile forward dfa time", time);
+
+    let (nfarev, time) =
+        util::timeitr(|| thompson.reversed().from_hirs(&hirs))?;
+    table.add("compile reverse nfa time", time);
+    let (dfarev, time) = util::timeitr(|| dfa.reversed().from_nfa(&nfarev))?;
+    table.add("compile reverse dfa time", time);
+
+    let (re, time) = util::timeit(|| {
+        regex_automata::dfa::regex::Builder::new()
+            .build_from_dfas(dfafwd, dfarev)
+    });
+    table.add("build regex time", time);
+    table.add(
+        "memory",
+        re.forward().memory_usage() + re.reverse().memory_usage(),
+    );
+    table.add("pattern len", re.pattern_len());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", re)?;
+    }
+    Ok(())
+}
+
+pub fn run_sparse(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a sparse DFA or a sparse DFA regex.
+
+A DFA regex contains two DFAs: a forward DFA for finding the end of a match,
+and a reverse DFA for finding the start of a match. These can be compiled
+independently using just 'regex-cli debug dense dfa', but using the 'regex'
+sub-command will handle it for you and print the debug representation of both
+the forward and reverse DFAs.
+
+USAGE:
+    regex-cli debug sparse <command> ...
+
+COMMANDS:
+    dfa    Print the debug representation of a single sparse DFA.
+    regex  Print the debug representation of a forward and reverse DFA regex.
+";
+
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "dfa" => run_sparse_dfa(p),
+        "regex" => run_sparse_regex(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_sparse_dfa(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a fully compiled sparse DFA.
+
+USAGE:
+    regex-cli debug sparse dfa [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (dfa, time) = util::timeitr(|| dfa.from_nfa_sparse(&nfa))?;
+    table.add("compile dfa time", time);
+    table.add("memory", dfa.memory_usage());
+    table.add("pattern len", dfa.pattern_len());
+    table.add("start kind", dfa.start_kind());
+    table.add("has empty?", dfa.has_empty());
+    table.add("is utf8?", dfa.is_utf8());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", dfa)?;
+    }
+    Ok(())
+}
+
+fn run_sparse_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a fully compiled sparse DFA regex.
+
+This includes both the forward and reverse DFAs that make up a sparse DFA
+regex.
+
+USAGE:
+    regex-cli debug sparse regex [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (dfafwd, time) = util::timeitr(|| dfa.from_nfa_sparse(&nfafwd))?;
+    table.add("compile forward dfa time", time);
+
+    let (nfarev, time) =
+        util::timeitr(|| thompson.reversed().from_hirs(&hirs))?;
+    table.add("compile reverse nfa time", time);
+    let (dfarev, time) =
+        util::timeitr(|| dfa.reversed().from_nfa_sparse(&nfarev))?;
+    table.add("compile reverse dfa time", time);
+
+    let (re, time) = util::timeit(|| {
+        regex_automata::dfa::regex::Builder::new()
+            .build_from_dfas(dfafwd, dfarev)
+    });
+    table.add("build regex time", time);
+    table.add(
+        "memory",
+        re.forward().memory_usage() + re.reverse().memory_usage(),
+    );
+    table.add("pattern len", re.pattern_len());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", re)?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/debug/literal.rs b/regex-cli/cmd/debug/literal.rs
new file mode 100644
index 0000000000..715e1bbb9c
--- /dev/null
+++ b/regex-cli/cmd/debug/literal.rs
@@ -0,0 +1,234 @@
+use std::io::{stdout, Write};
+
+use {
+    anyhow::Context,
+    bstr::BString,
+    lexopt::{Arg, Parser, ValueExt},
+    regex_syntax::hir::literal::{ExtractKind, Extractor},
+};
+
+use crate::{
+    args::{self, Configurable, Usage},
+    util::{self, Table},
+};
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of extract literals from a regex pattern.
+
+Note that the literals this command prints by default should roughly reflect
+what regex-automata's meta regex engine does by defualt. In particular, this
+will optimize the extracted literals and will do so under the presumption of
+leftmost-first match semantics. The --no-optimize flag can be given to skip
+this optimization step and instead get the literals precisely as they were
+extracted.
+
+USAGE:
+    regex-cli debug literal <pattern>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut literal = Literal::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [&mut common, &mut patterns, &mut syntax, &mut literal],
+    )?;
+
+    let pats = patterns.get()?;
+    anyhow::ensure!(
+        pats.len() == 1,
+        "only one pattern is allowed, but {} were given",
+        pats.len(),
+    );
+
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (mut seq, time) = util::timeit(|| literal.extractor.extract(&hirs[0]));
+    table.add("extraction time", time);
+    if literal.optimize.unwrap_or(true) {
+        let ((), time) = util::timeitr(|| {
+            match literal.kind {
+                ExtractKind::Prefix => seq.optimize_for_prefix_by_preference(),
+                ExtractKind::Suffix => seq.optimize_for_suffix_by_preference(),
+                unk => {
+                    anyhow::bail!(
+                        "unsupported literal extraction kind: {:?}",
+                        unk
+                    )
+                }
+            }
+            Ok(())
+        })?;
+        table.add("optimization time", time);
+    }
+    table.add("len", seq.len());
+    table.add("is finite?", seq.is_finite());
+    table.add("is exact?", seq.is_exact());
+    table.add("min literal len", seq.min_literal_len());
+    table.add("max literal len", seq.max_literal_len());
+    table.add(
+        "longest common prefix",
+        seq.longest_common_prefix().map(BString::from),
+    );
+    table.add(
+        "longest common suffix",
+        seq.longest_common_suffix().map(BString::from),
+    );
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        let mut out = stdout();
+        if common.table() {
+            writeln!(out, "")?;
+        }
+        match seq.literals() {
+            None => writeln!(out, "{:?}", seq)?,
+            Some(literals) => {
+                for lit in literals.iter() {
+                    writeln!(stdout(), "{:?}", lit)?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct Literal {
+    extractor: Extractor,
+    kind: ExtractKind,
+    optimize: Option<bool>,
+}
+
+impl Configurable for Literal {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("extract-kind") => {
+                let value = p.value().context("--extract-kind")?;
+                let value = value.string().context("--extract-kind")?;
+                let kind = match &*value {
+                    "prefix" => ExtractKind::Prefix,
+                    "suffix" => ExtractKind::Suffix,
+                    unk => anyhow::bail!(
+                        "unknown value for --extract-kind: {}",
+                        unk
+                    ),
+                };
+                self.kind = kind.clone();
+                self.extractor.kind(kind);
+            }
+            Arg::Long("limit-class") => {
+                let limit = args::parse(p, "--limit-class")?;
+                self.extractor.limit_class(limit);
+            }
+            Arg::Long("limit-repeat") => {
+                let limit = args::parse(p, "--limit-repeat")?;
+                self.extractor.limit_repeat(limit);
+            }
+            Arg::Long("limit-literal-len") => {
+                let limit = args::parse(p, "--limit-literal-len")?;
+                self.extractor.limit_literal_len(limit);
+            }
+            Arg::Long("limit-total") => {
+                let limit = args::parse(p, "--limit-total")?;
+                self.extractor.limit_total(limit);
+            }
+            Arg::Long("no-optimize") => {
+                self.optimize = Some(false);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--extract-kind <kind>",
+                "The literals to extract, either 'prefix' or 'suffix'.",
+                r#"
+This sets the kind of literals to extract. Either 'prefix' literals can be
+extracted (the default) or 'suffix' literals.
+"#,
+            ),
+            Usage::new(
+                "--limit-class <limit>",
+                "The maximum size of a character class to support.",
+                r#"
+This limit controls how big a character class needs to be for literal
+extraction to ignore it. In practice, large classes aren't good for literal
+extraction because it becomes easy to create very large sets of literals that
+aren't practical to search quickly for.
+"#,
+            ),
+            Usage::new(
+                "--limit-repeat <limit>",
+                "The maximum repeat size to expand.",
+                r#"
+Literal extraction will attempt to expand bounded repetitions like
+'(abcd){50}'. But repetitions can become large easily, and so it makes sense to
+stop at a certain point. This limit specifies that point.
+"#,
+            ),
+            Usage::new(
+                "--limit-literal-len <limit>",
+                "The maximum length of a literal to extract.",
+                r#"
+This limit caps the maximum length of a literal that is extract. If a literal
+would otherwise get longer than this limit, then it is cut and prevented from
+being expanded upon.
+"#,
+            ),
+            Usage::new(
+                "--limit-total <limit>",
+                "Limits the total number of literals to extract.",
+                r#"
+This limit applies to the total number of literals to extract. If the number of
+literals would exceed this number, then literal extraction may use heuristics
+to cut the set before proceeding. In some cases though, this may cause
+extraction to give up entirely and return no literals.
+
+This limit tends to act as a backstop catch-all for when other limits fail.
+For example, '[ab]{3}{3}' uses small bounded repetitions and a small character
+class. The actual literals it generates are also pretty small. But the
+number of total literals it creates is quite large (512) despite each of its
+constituent pieces being quite small. Thus, this limit protects against cases
+like these by preventing the total size of the extracted literal set from
+getting too big.
+"#,
+            ),
+            Usage::new(
+                "--no-optimize",
+                "Don't attempt to optimize the extracted literals.",
+                r#"
+This flag disables "optimization" of the extracted literals. Optimization is
+performed by default as it reflects what the meta regex engine does by default.
+
+Optimization is the "black magic" part of literal extraction that uses
+heuristics to guess at what kinds of literal sets are better to search for.
+Generally speaking, you want a small number of a literals to make multiple
+substring vector algorithms faster, but you want your literals to be longer so
+that they're more discriminatory and overall reduce their false positive rate.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/cmd/debug/mod.rs b/regex-cli/cmd/debug/mod.rs
new file mode 100644
index 0000000000..525c4d1383
--- /dev/null
+++ b/regex-cli/cmd/debug/mod.rs
@@ -0,0 +1,244 @@
+use std::io::{stdout, Write};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+mod dfa;
+mod literal;
+
+pub fn run(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of various things from regex-automata and
+regex-syntax.
+
+This is useful for ad hoc interactions with objects on the command line. In
+general, most objects support the full suite of configuration available in code
+via the crate.
+
+USAGE:
+    regex-cli debug <command> ...
+
+COMMANDS:
+    ast        Print the debug representation of an AST.
+    dense      Print the debug representation of a dense DFA.
+    hir        Print the debug representation of an HIR.
+    literal    Print the debug representation of extracted literals.
+    onepass    Print the debug representation of a one-pass DFA.
+    sparse     Print the debug representation of a sparse DFA.
+    thompson   Print the debug representation of a Thompson NFA.
+";
+
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "ast" => run_ast(p),
+        "dense" => dfa::run_dense(p),
+        "hir" => run_hir(p),
+        "literal" => literal::run(p),
+        "onepass" => run_onepass(p),
+        "sparse" => dfa::run_sparse(p),
+        "thompson" => run_thompson(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_ast(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of an abstract syntax tree (AST).
+
+USAGE:
+    regex-cli debug ast <pattern>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    args::configure(p, USAGE, &mut [&mut common, &mut patterns, &mut syntax])?;
+
+    let pats = patterns.get()?;
+    anyhow::ensure!(
+        pats.len() == 1,
+        "only one pattern is allowed, but {} were given",
+        pats.len(),
+    );
+
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:#?}", &asts[0])?;
+    }
+    Ok(())
+}
+
+fn run_hir(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a high-level intermediate representation
+(HIR).
+
+USAGE:
+    regex-cli debug hir <pattern>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    args::configure(p, USAGE, &mut [&mut common, &mut patterns, &mut syntax])?;
+
+    let pats = patterns.get()?;
+    anyhow::ensure!(
+        pats.len() == 1,
+        "only one pattern is allowed, but {} were given",
+        pats.len(),
+    );
+
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:#?}", &hirs[0])?;
+    }
+    Ok(())
+}
+
+fn run_onepass(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a one-pass DFA.
+
+USAGE:
+    regex-cli debug onepass [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut onepass = args::onepass::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut onepass,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (dfa, time) = util::timeitr(|| onepass.from_nfa(&nfa))?;
+    table.add("compile one-pass DFA time", time);
+    table.add("memory", dfa.memory_usage());
+    table.add("states", dfa.state_len());
+    table.add("pattern len", dfa.pattern_len());
+    table.add("alphabet len", dfa.alphabet_len());
+    table.add("stride", dfa.stride());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", dfa)?;
+    }
+    Ok(())
+}
+
+fn run_thompson(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Prints the debug representation of a Thompson NFA.
+
+USAGE:
+    regex-cli debug thompson [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [&mut common, &mut patterns, &mut syntax, &mut thompson],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    table.add("memory", nfa.memory_usage());
+    table.add("states", nfa.states().len());
+    table.add("pattern len", nfa.pattern_len());
+    table.add("capture len", nfa.group_info().all_group_len());
+    table.add("has empty?", nfa.has_empty());
+    table.add("is utf8?", nfa.is_utf8());
+    table.add("is reverse?", nfa.is_reverse());
+    table.add(
+        "line terminator",
+        bstr::BString::from(&[nfa.look_matcher().get_line_terminator()][..]),
+    );
+    table.add("lookset any", nfa.look_set_any());
+    table.add("lookset prefix any", nfa.look_set_prefix_any());
+    if common.table() {
+        table.print(stdout())?;
+    }
+    if !common.quiet {
+        if common.table() {
+            writeln!(stdout(), "")?;
+        }
+        writeln!(stdout(), "{:?}", nfa)?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/capture/dfa.rs b/regex-cli/cmd/find/capture/dfa.rs
new file mode 100644
index 0000000000..733931bac4
--- /dev/null
+++ b/regex-cli/cmd/find/capture/dfa.rs
@@ -0,0 +1,84 @@
+use regex_automata::{util::captures::Captures, Input};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_onepass(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the one-pass DFA regex engine.
+
+USAGE:
+    regex-cli find capture onepass [-p <pattern> ...] <haystack-path>
+    regex-cli find capture onepass [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut onepass = args::onepass::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut onepass,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| onepass.from_nfa(&nfa))?;
+    table.add("build onepass time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        re.try_search(&mut cache, input, caps)
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/capture/mod.rs b/regex-cli/cmd/find/capture/mod.rs
new file mode 100644
index 0000000000..3af46bfcff
--- /dev/null
+++ b/regex-cli/cmd/find/capture/mod.rs
@@ -0,0 +1,464 @@
+use std::io::{stdout, Write};
+
+use {
+    anyhow::Context,
+    bstr::ByteSlice,
+    lexopt::Parser,
+    regex_automata::{
+        util::captures::{Captures, GroupInfo},
+        Input, MatchError, PatternID,
+    },
+};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+mod dfa;
+mod nfa;
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for capturing groups.
+
+This command is limited to regex engines that support resolving capture groups.
+It prints each match, corresponding to possibly many matching capture groups,
+on its own line. It is prefixed with the pattern ID of the match. Each group
+contains both the spans matched and the actual substring that matches.
+
+USAGE:
+    regex-cli find capture <engine>
+
+ENGINES:
+    backtrack  Search with the bounded backtracker regex engine.
+    lite       Search with the regex-lite engine.
+    meta       Search with the meta regex engine.
+    onepass    Search with the one-pass DFA regex engine.
+    pikevm     Search with the PikeVM regex engine.
+    regex      Search with the top-level API regex engine.
+";
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "backtrack" => nfa::run_backtrack(p),
+        "lite" => run_lite(p),
+        "meta" => run_meta(p),
+        "onepass" => dfa::run_onepass(p),
+        "pikevm" => nfa::run_pikevm(p),
+        "regex" => run_regex(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level API regex engine.
+
+USAGE:
+    regex-cli find capture regex [-p <pattern> ...] <haystack-path>
+    regex-cli find capture regex [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut api = args::api::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut api,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| api.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    // The top-level API also doesn't use 'Captures' from regex-automata
+    // directly, but we can map between them with some annoyance.
+    let group_info = GroupInfo::new([re.capture_names()])
+        .context("could not build capture group info")?;
+    let mut locs = re.capture_locations();
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        caps.set_pattern(None);
+        if !re
+            .captures_read_at(&mut locs, input.haystack(), input.start())
+            .is_some()
+        {
+            return Ok(());
+        }
+        caps.set_pattern(Some(PatternID::ZERO));
+        for i in 0..locs.len() {
+            use regex_automata::util::primitives::NonMaxUsize;
+
+            let slot_start = i * 2;
+            let slot_end = slot_start + 1;
+            match locs.get(i) {
+                None => {
+                    caps.slots_mut()[slot_start] = None;
+                    caps.slots_mut()[slot_end] = None;
+                }
+                Some((start, end)) => {
+                    caps.slots_mut()[slot_start] = NonMaxUsize::new(start);
+                    caps.slots_mut()[slot_end] = NonMaxUsize::new(end);
+                }
+            }
+        }
+        Ok(())
+    };
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    } else {
+        run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    }
+    Ok(())
+}
+
+fn run_meta(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the meta regex engine.
+
+USAGE:
+    regex-cli find capture meta [-p <pattern> ...] <haystack-path>
+    regex-cli find capture meta [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut meta = args::meta::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut meta,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+
+    let re = if meta.build_from_patterns() {
+        let (re, time) = util::timeitr(|| meta.from_patterns(&syntax, &pats))?;
+        table.add("build meta time", time);
+        re
+    } else {
+        let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+        table.add("parse time", time);
+        let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+        table.add("translate time", time);
+        let (re, time) = util::timeitr(|| meta.from_hirs(&hirs))?;
+        table.add("build meta time", time);
+        re
+    };
+
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        Ok(re.search_captures(input, caps))
+    };
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.group_info(),
+            search,
+        )?;
+    } else {
+        run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.group_info(),
+            search,
+        )?;
+    }
+    Ok(())
+}
+
+fn run_lite(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level regex-lite engine.
+
+USAGE:
+    regex-cli find capture lite [-p <pattern> ...] <haystack-path>
+    regex-cli find capture lite [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut lite = args::lite::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut lite,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| lite.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // Check that the haystack is valid UTF-8 since regex-lite doesn't support
+    // searching arbitrary byte sequences. (At time of writing.)
+    haystack.get()?.to_str()?;
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    // The top-level API also doesn't use 'Captures' from regex-automata
+    // directly, but we can map between them with some annoyance.
+    let group_info = GroupInfo::new([re.capture_names()])
+        .context("could not build capture group info")?;
+    let mut locs = re.capture_locations();
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        let haystack = input.haystack().to_str().unwrap();
+        caps.set_pattern(None);
+        if !re.captures_read_at(&mut locs, haystack, input.start()).is_some() {
+            return Ok(());
+        }
+        caps.set_pattern(Some(PatternID::ZERO));
+        for i in 0..locs.len() {
+            use regex_automata::util::primitives::NonMaxUsize;
+
+            let slot_start = i * 2;
+            let slot_end = slot_start + 1;
+            match locs.get(i) {
+                None => {
+                    caps.slots_mut()[slot_start] = None;
+                    caps.slots_mut()[slot_end] = None;
+                }
+                Some((start, end)) => {
+                    caps.slots_mut()[slot_start] = NonMaxUsize::new(start);
+                    caps.slots_mut()[slot_end] = NonMaxUsize::new(end);
+                }
+            }
+        }
+        Ok(())
+    };
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    } else {
+        run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    }
+    Ok(())
+}
+
+/// A function that takes in a bunch of configuration, runs the given search
+/// routine, and prints out a table of counts.
+fn run_counts(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    group_info: &GroupInfo,
+    mut search: impl FnMut(&Input<'_>, &mut Captures) -> Result<(), MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (counts, time) = util::timeitr(|| {
+            let mut counts = vec![vec![]; group_info.pattern_len()];
+            for i in 0..group_info.pattern_len() {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                counts[i] = vec![0; group_info.group_len(pid)];
+            }
+            let mut caps = Captures::all(group_info.clone());
+            for _ in 0..find.repeat() {
+                let mut it =
+                    regex_automata::util::iter::Searcher::new(input.clone());
+                loop {
+                    let m = it.try_advance(|input| {
+                        search(input, &mut caps)?;
+                        Ok(caps.get_match())
+                    })?;
+                    match m {
+                        None => break,
+                        Some(m) => {
+                            for (i, span) in caps.iter().enumerate() {
+                                if span.is_some() {
+                                    counts[m.pattern()][i] += 1;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Ok::<_, anyhow::Error>(counts)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", counts.iter().map(|c| c[0]).sum::<u64>());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for (i, pattern_counts) in counts.iter().enumerate() {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                write!(out, "{}:{{ ", pid.as_usize())?;
+                let names = group_info.pattern_names(pid);
+                for (group_index, maybe_name) in names.enumerate() {
+                    if group_index > 0 {
+                        write!(out, ", ")?;
+                    }
+                    let count = pattern_counts[group_index];
+                    if let Some(name) = maybe_name {
+                        write!(out, "{}/{}: {}", group_index, name, count)?;
+                    } else {
+                        write!(out, "{}: {}", group_index, count)?;
+                    }
+                }
+                write!(out, " }}\n")?;
+            }
+        }
+        Ok(())
+    })
+}
+
+/// Like `run_counts`, but prints the actual matches instead.
+fn run_search(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    group_info: &GroupInfo,
+    mut search: impl FnMut(&Input<'_>, &mut Captures) -> Result<(), MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (matches, time) = util::timeitr(|| {
+            let mut matches = vec![];
+            for _ in 0..find.repeat() {
+                let caps = Captures::all(group_info.clone());
+                let it =
+                    regex_automata::util::iter::Searcher::new(input.clone())
+                        .into_captures_iter(caps, &mut search);
+                for caps in it {
+                    matches.push(caps?);
+                }
+            }
+            Ok::<_, anyhow::Error>(matches)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", matches.len());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for caps in matches.iter() {
+                let pid = caps.pattern().unwrap();
+                write!(out, "{}:{{ ", pid.as_usize())?;
+                let names = caps.group_info().pattern_names(pid);
+                for (group_index, maybe_name) in names.enumerate() {
+                    if group_index > 0 {
+                        write!(out, ", ")?;
+                    }
+                    if let Some(name) = maybe_name {
+                        write!(out, "{}/{}: ", group_index, name)?;
+                    } else {
+                        write!(out, "{}: ", group_index)?;
+                    }
+                    match caps.get_group(group_index) {
+                        None => write!(out, "NONE")?,
+                        Some(sp) => {
+                            let string = input.haystack()[sp].escape_bytes();
+                            write!(
+                                out,
+                                "{}..{}/{}",
+                                sp.start, sp.end, string
+                            )?;
+                        }
+                    }
+                }
+                write!(out, " }}\n")?;
+            }
+        }
+        Ok(())
+    })
+}
diff --git a/regex-cli/cmd/find/capture/nfa.rs b/regex-cli/cmd/find/capture/nfa.rs
new file mode 100644
index 0000000000..1c44da5e6a
--- /dev/null
+++ b/regex-cli/cmd/find/capture/nfa.rs
@@ -0,0 +1,162 @@
+use regex_automata::{util::captures::Captures, Input};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_backtrack(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the BoundedBacktracker regex engine.
+
+USAGE:
+    regex-cli find capture backtrack [-p <pattern> ...] <haystack-path>
+    regex-cli find capture backtrack [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut backtrack = args::backtrack::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut backtrack,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| backtrack.from_nfa(&nfa))?;
+    table.add("build backtracker time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        re.try_search(&mut cache, input, caps)
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    }
+    Ok(())
+}
+
+pub fn run_pikevm(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the PikeVM regex engine.
+
+USAGE:
+    regex-cli find capture pikevm [-p <pattern> ...] <haystack-path>
+    regex-cli find capture pikevm [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut pikevm = args::pikevm::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut pikevm,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| pikevm.from_nfa(&nfa))?;
+    table.add("build pikevm time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        Ok(re.search(&mut cache, input, caps))
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.get_nfa().group_info(),
+            search,
+        )?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/half/dfa.rs b/regex-cli/cmd/find/half/dfa.rs
new file mode 100644
index 0000000000..d576eef6e8
--- /dev/null
+++ b/regex-cli/cmd/find/half/dfa.rs
@@ -0,0 +1,314 @@
+use regex_automata::{dfa::Automaton, Input};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_hybrid(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    use regex_automata::hybrid::dfa::OverlappingState;
+
+    const USAGE: &'static str = "\
+Executes a search for half matches using the lazy DFA regex engine.
+
+USAGE:
+    regex-cli find half hybrid [-p <pattern> ...] <haystack-path>
+    regex-cli find half hybrid [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut hybrid = args::hybrid::Config::default();
+    let mut overlapping = args::overlapping::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut hybrid,
+            &mut overlapping,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| hybrid.from_nfa(&nfafwd))?;
+    table.add("build forward hybrid time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    if overlapping.enabled {
+        let search = |input: &Input<'_>, state: &mut OverlappingState| {
+            re.try_search_overlapping_fwd(&mut cache, input, state)
+        };
+        if find.count {
+            super::run_counts_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        } else {
+            super::run_search_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        }
+    } else {
+        let search = |input: &Input<'_>| re.try_search_fwd(&mut cache, input);
+        if find.count {
+            super::run_counts(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                search,
+            )?;
+        } else {
+            super::run_search(
+                &mut table, &common, &find, &input, &haystack, search,
+            )?;
+        }
+    }
+    Ok(())
+}
+
+pub fn run_dense(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    use regex_automata::dfa::OverlappingState;
+
+    const USAGE: &'static str = "\
+Executes a search for half matches using the dense DFA regex engine.
+
+USAGE:
+    regex-cli find half dense [-p <pattern> ...] <haystack-path>
+    regex-cli find half dense [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dense = args::dfa::Config::default();
+    let mut overlapping = args::overlapping::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut dense,
+            &mut overlapping,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| dense.from_nfa(&nfafwd))?;
+    table.add("build forward dense DFA time", time);
+
+    if overlapping.enabled {
+        let search = |input: &Input<'_>, state: &mut OverlappingState| {
+            re.try_search_overlapping_fwd(input, state)
+        };
+        if find.count {
+            super::run_counts_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        } else {
+            super::run_search_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        }
+    } else {
+        let search = |input: &Input<'_>| re.try_search_fwd(input);
+        if find.count {
+            super::run_counts(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                search,
+            )?;
+        } else {
+            super::run_search(
+                &mut table, &common, &find, &input, &haystack, search,
+            )?;
+        }
+    }
+    Ok(())
+}
+
+pub fn run_sparse(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    use regex_automata::dfa::OverlappingState;
+
+    const USAGE: &'static str = "\
+Executes a search for half matches using the sparse DFA regex engine.
+
+USAGE:
+    regex-cli find half sparse [-p <pattern> ...] <haystack-path>
+    regex-cli find half sparse [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut sparse = args::dfa::Config::default();
+    let mut overlapping = args::overlapping::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut sparse,
+            &mut overlapping,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| sparse.from_nfa_sparse(&nfafwd))?;
+    table.add("build forward sparse DFA time", time);
+
+    if overlapping.enabled {
+        let search = |input: &Input<'_>, state: &mut OverlappingState| {
+            re.try_search_overlapping_fwd(input, state)
+        };
+        if find.count {
+            super::run_counts_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        } else {
+            super::run_search_overlapping(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                || OverlappingState::start(),
+                |s| s.get_match(),
+                search,
+            )?;
+        }
+    } else {
+        let search = |input: &Input<'_>| re.try_search_fwd(input);
+        if find.count {
+            super::run_counts(
+                &mut table,
+                &common,
+                &find,
+                &input,
+                &haystack,
+                re.pattern_len(),
+                search,
+            )?;
+        } else {
+            super::run_search(
+                &mut table, &common, &find, &input, &haystack, search,
+            )?;
+        }
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/half/mod.rs b/regex-cli/cmd/find/half/mod.rs
new file mode 100644
index 0000000000..a7239f234b
--- /dev/null
+++ b/regex-cli/cmd/find/half/mod.rs
@@ -0,0 +1,372 @@
+use std::io::{stdout, Write};
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser},
+    regex_automata::{HalfMatch, Input, MatchError, PatternID},
+};
+
+use crate::{
+    args::{self, Configurable, Usage},
+    util::{self, Table},
+};
+
+mod dfa;
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = r#"\
+Executes a search for "half" matches. That is, matches that only have the end
+offset of a match (as well as the pattern that matched). This type of search
+can be done by any regex engine, but for this command, we only expose regex
+engines that can specifically do less work to report a half match.
+
+For example, a DFA regex can report a half match by only searching with its
+forward DFA. Indeed, if all we care about are half matches, we can avoid
+compiling a reverse DFA entirely.
+
+Also, since half matches cannot know the full bounds of a match, this only
+prints the end offset of each match and not the matched contents. (Since the
+start offset of each match is not known.)
+
+USAGE:
+    regex-cli find half <engine>
+
+ENGINES:
+    dense      Search with the dense DFA regex engine.
+    hybrid     Search with the lazy DFA regex engine.
+    meta       Search with the meta regex engine.
+    regex      Search with the top-level API regex engine.
+    sparse     Search with the sparse DFA regex engine.
+"#;
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "dense" => dfa::run_dense(p),
+        "hybrid" => dfa::run_hybrid(p),
+        "meta" => run_meta(p),
+        "regex" => run_regex(p),
+        "sparse" => dfa::run_sparse(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+#[derive(Debug, Default)]
+struct Args {
+    overlapping: bool,
+}
+
+impl Configurable for Args {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("overlapping") => {
+                self.overlapping = true;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &[Usage] = &[Usage::new(
+            "--overlapping",
+            "Search for overlapping matches.",
+            r#"
+This flag enables overlapping mode, where the regex engine will attempt to find
+all possible matches reported by the underlying matcher.
+
+Generally this flag is used in conjunction with '--match-kind all'. If the
+match semantics are not set to compile all possible matches in the underlying
+automaton, then the results will likely be counter-intuitive.
+"#,
+        )];
+        USAGES
+    }
+}
+
+fn run_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for half matches using the top-level API regex engine.
+
+USAGE:
+    regex-cli find half regex [-p <pattern> ...] <haystack-path>
+    regex-cli find half regex [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut api = args::api::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut api,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| api.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    let search = |input: &Input<'_>| {
+        Ok(re
+            .shortest_match_at(input.haystack(), input.start())
+            .map(|offset| HalfMatch::new(PatternID::ZERO, offset)))
+    };
+    if find.count {
+        run_counts(&mut table, &common, &find, &input, &haystack, 1, search)?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
+fn run_meta(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for half matches using the meta regex engine.
+
+USAGE:
+    regex-cli find half meta [-p <pattern> ...] <haystack-path>
+    regex-cli find half meta [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut meta = args::meta::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut meta,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+
+    let re = if meta.build_from_patterns() {
+        let (re, time) = util::timeitr(|| meta.from_patterns(&syntax, &pats))?;
+        table.add("build meta time", time);
+        re
+    } else {
+        let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+        table.add("parse time", time);
+        let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+        table.add("translate time", time);
+        let (re, time) = util::timeitr(|| meta.from_hirs(&hirs))?;
+        table.add("build meta time", time);
+        re
+    };
+
+    let search = |input: &Input<'_>| Ok(re.search_half(input));
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
+/// A function that takes in a bunch of configuration, runs the given search
+/// routine, and prints out a table of counts.
+fn run_counts(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    pattern_len: usize,
+    mut search: impl FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (counts, time) = util::timeitr(|| {
+            let mut counts = vec![0; pattern_len];
+            for _ in 0..find.repeat() {
+                let mut it =
+                    regex_automata::util::iter::Searcher::new(input.clone());
+                while let Some(m) = it.try_advance_half(&mut search)? {
+                    counts[m.pattern().as_usize()] += 1;
+                }
+            }
+            Ok::<_, anyhow::Error>(counts)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", counts.iter().copied().sum::<u64>());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for (i, &count) in counts.iter().enumerate() {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                writeln!(out, "{}:{}", pid.as_usize(), count)?;
+            }
+        }
+        Ok(())
+    })
+}
+
+/// Like `run_counts`, but prints the actual matches instead.
+fn run_search(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    mut search: impl FnMut(&Input<'_>) -> Result<Option<HalfMatch>, MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (matches, time) = util::timeitr(|| {
+            let mut matches = vec![];
+            for _ in 0..find.repeat() {
+                let mut it =
+                    regex_automata::util::iter::Searcher::new(input.clone());
+                while let Some(m) = it.try_advance_half(&mut search)? {
+                    matches.push(m);
+                }
+            }
+            Ok::<_, anyhow::Error>(matches)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", matches.len());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for m in matches.iter() {
+                writeln!(out, "{}:{}", m.pattern().as_usize(), m.offset())?;
+            }
+        }
+        Ok(())
+    })
+}
+
+/// Like `run_counts`, but does an overlapping search.
+fn run_counts_overlapping<S>(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    pattern_len: usize,
+    mut start_state: impl FnMut() -> S,
+    mut get_match: impl FnMut(&S) -> Option<HalfMatch>,
+    mut search: impl FnMut(&Input<'_>, &mut S) -> Result<(), MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (counts, time) = util::timeitr(|| {
+            let mut counts = vec![0; pattern_len];
+            for _ in 0..find.repeat() {
+                let mut state = start_state();
+                loop {
+                    search(&input, &mut state)?;
+                    match get_match(&state) {
+                        None => break,
+                        Some(hm) => counts[hm.pattern().as_usize()] += 1,
+                    }
+                }
+            }
+            Ok::<_, anyhow::Error>(counts)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", counts.iter().copied().sum::<u64>());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for (i, &count) in counts.iter().enumerate() {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                writeln!(out, "{}:{}", pid.as_usize(), count)?;
+            }
+        }
+        Ok(())
+    })
+}
+
+/// Like `run_search`, but does an overlapping search.
+fn run_search_overlapping<S>(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    mut start_state: impl FnMut() -> S,
+    mut get_match: impl FnMut(&S) -> Option<HalfMatch>,
+    mut search: impl FnMut(&Input<'_>, &mut S) -> Result<(), MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (matches, time) = util::timeitr(|| {
+            let mut matches = vec![];
+            for _ in 0..find.repeat() {
+                let mut state = start_state();
+                loop {
+                    search(&input, &mut state)?;
+                    match get_match(&state) {
+                        None => break,
+                        Some(hm) => matches.push(hm),
+                    }
+                }
+            }
+            Ok::<_, anyhow::Error>(matches)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", matches.len());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for m in matches.iter() {
+                writeln!(out, "{}:{}", m.pattern().as_usize(), m.offset())?;
+            }
+        }
+        Ok(())
+    })
+}
diff --git a/regex-cli/cmd/find/match/dfa.rs b/regex-cli/cmd/find/match/dfa.rs
new file mode 100644
index 0000000000..7bc5c48daf
--- /dev/null
+++ b/regex-cli/cmd/find/match/dfa.rs
@@ -0,0 +1,319 @@
+use regex_automata::Input;
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_hybrid(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the lazy DFA regex engine.
+
+USAGE:
+    regex-cli find match hybrid [-p <pattern> ...] <haystack-path>
+    regex-cli find match hybrid [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut hybrid = args::hybrid::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut hybrid,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (nfarev, time) =
+        util::timeitr(|| thompson.reversed().from_hirs(&hirs))?;
+    table.add("compile reverse nfa time", time);
+    let (dfafwd, time) = util::timeitr(|| hybrid.from_nfa(&nfafwd))?;
+    table.add("build forward hybrid time", time);
+    let (dfarev, time) =
+        util::timeitr(|| hybrid.reversed().from_nfa(&nfarev))?;
+    table.add("build reverse hybrid time", time);
+    let (re, time) = util::timeit(|| {
+        regex_automata::hybrid::regex::Builder::new()
+            .build_from_dfas(dfafwd, dfarev)
+    });
+    table.add("build regex time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>| re.try_search(&mut cache, input);
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
+
+pub fn run_dense(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the dense DFA regex engine.
+
+USAGE:
+    regex-cli find match dense [-p <pattern> ...] <haystack-path>
+    regex-cli find match dense [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dense = args::dfa::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut dense,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (nfarev, time) =
+        util::timeitr(|| thompson.reversed().from_hirs(&hirs))?;
+    table.add("compile reverse nfa time", time);
+    let (dfafwd, time) = util::timeitr(|| dense.from_nfa(&nfafwd))?;
+    table.add("build forward dense DFA time", time);
+    let (dfarev, time) = util::timeitr(|| dense.reversed().from_nfa(&nfarev))?;
+    table.add("build reverse dense DFA time", time);
+    let (re, time) = util::timeit(|| {
+        regex_automata::dfa::regex::Builder::new()
+            .build_from_dfas(dfafwd, dfarev)
+    });
+    table.add("build regex time", time);
+
+    let search = |input: &Input<'_>| re.try_search(input);
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
+
+pub fn run_sparse(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the sparse DFA regex engine.
+
+USAGE:
+    regex-cli find match sparse [-p <pattern> ...] <haystack-path>
+    regex-cli find match sparse [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut sparse = args::dfa::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut sparse,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (nfarev, time) =
+        util::timeitr(|| thompson.reversed().from_hirs(&hirs))?;
+    table.add("compile reverse nfa time", time);
+    let (dfafwd, time) = util::timeitr(|| sparse.from_nfa_sparse(&nfafwd))?;
+    table.add("build forward sparse DFA time", time);
+    let (dfarev, time) =
+        util::timeitr(|| sparse.reversed().from_nfa_sparse(&nfarev))?;
+    table.add("build reverse sparse DFA time", time);
+    let (re, time) = util::timeit(|| {
+        regex_automata::dfa::regex::Builder::new()
+            .build_from_dfas(dfafwd, dfarev)
+    });
+    table.add("build regex time", time);
+
+    let search = |input: &Input<'_>| re.try_search(input);
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
+
+pub fn run_onepass(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the one-pass DFA regex engine.
+
+USAGE:
+    regex-cli find match onepass [-p <pattern> ...] <haystack-path>
+    regex-cli find match onepass [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut onepass = args::onepass::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut onepass,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| onepass.from_nfa(&nfa))?;
+    table.add("build onepass time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+    let (mut caps, time) = util::timeit(|| re.create_captures());
+    table.add("captures creation time", time);
+
+    let search = |input: &Input<'_>| {
+        re.try_search(&mut cache, input, &mut caps)?;
+        Ok(caps.get_match())
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/match/mod.rs b/regex-cli/cmd/find/match/mod.rs
new file mode 100644
index 0000000000..0bafd8b2b4
--- /dev/null
+++ b/regex-cli/cmd/find/match/mod.rs
@@ -0,0 +1,322 @@
+use std::io::{stdout, Write};
+
+use {
+    anyhow::Context,
+    bstr::ByteSlice,
+    lexopt::Parser,
+    regex_automata::{Input, Match, MatchError, PatternID},
+};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+mod dfa;
+mod nfa;
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search.
+
+USAGE:
+    regex-cli find match <engine>
+
+ENGINES:
+    backtrack  Search with the bounded backtracker regex engine.
+    dense      Search with the dense DFA regex engine.
+    hybrid     Search with the lazy DFA regex engine.
+    lite       Search with the regex-lite engine.
+    meta       Search with the meta regex engine.
+    onepass    Search with the one-pass DFA regex engine.
+    pikevm     Search with the PikeVM regex engine.
+    regex      Search with the top-level API regex engine.
+    sparse     Search with the sparse DFA regex engine.
+";
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "backtrack" => nfa::run_backtrack(p),
+        "dense" => dfa::run_dense(p),
+        "hybrid" => dfa::run_hybrid(p),
+        "lite" => run_lite(p),
+        "meta" => run_meta(p),
+        "onepass" => dfa::run_onepass(p),
+        "pikevm" => nfa::run_pikevm(p),
+        "regex" => run_regex(p),
+        "sparse" => dfa::run_sparse(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level API regex engine.
+
+USAGE:
+    regex-cli find match regex [-p <pattern> ...] <haystack-path>
+    regex-cli find match regex [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut api = args::api::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut api,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| api.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    let search = |input: &Input<'_>| {
+        Ok(re
+            .find_at(input.haystack(), input.start())
+            .map(|m| Match::new(PatternID::ZERO, m.start()..m.end())))
+    };
+    if find.count {
+        run_counts(&mut table, &common, &find, &input, &haystack, 1, search)?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
+fn run_meta(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the meta regex engine.
+
+USAGE:
+    regex-cli find match meta [-p <pattern> ...] <haystack-path>
+    regex-cli find match meta [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut meta = args::meta::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut meta,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+
+    let re = if meta.build_from_patterns() {
+        let (re, time) = util::timeitr(|| meta.from_patterns(&syntax, &pats))?;
+        table.add("build meta time", time);
+        re
+    } else {
+        let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+        table.add("parse time", time);
+        let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+        table.add("translate time", time);
+        let (re, time) = util::timeitr(|| meta.from_hirs(&hirs))?;
+        table.add("build meta time", time);
+        re
+    };
+
+    let search = |input: &Input<'_>| Ok(re.search(input));
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
+fn run_lite(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level regex-lite engine.
+
+Note that since the regex-lite crate doesn't have an API for search arbitrary
+byte slices, the haystack must be valid UTF-8. If it isn't, this command will
+report an error.
+
+USAGE:
+    regex-cli find match lite [-p <pattern> ...] <haystack-path>
+    regex-cli find match lite [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut lite = args::lite::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut lite,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| lite.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // Check that the haystack is valid UTF-8 since regex-lite doesn't support
+    // searching arbitrary byte sequences. (At time of writing.)
+    haystack.get()?.to_str()?;
+
+    // The top-level regex-lite API doesn't support regex-automata's more
+    // granular Input abstraction.
+    let input = args::input::Config::default();
+    let search = |input: &Input<'_>| {
+        let haystack = input.haystack().to_str().unwrap();
+        Ok(re
+            .find_at(haystack, input.start())
+            .map(|m| Match::new(PatternID::ZERO, m.start()..m.end())))
+    };
+    if find.count {
+        run_counts(&mut table, &common, &find, &input, &haystack, 1, search)?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
+/// A function that takes in a bunch of configuration, runs the given search
+/// routine, and prints out a table of counts.
+fn run_counts(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    pattern_len: usize,
+    mut search: impl FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (counts, time) = util::timeitr(|| {
+            let mut counts = vec![0; pattern_len];
+            for _ in 0..find.repeat() {
+                let mut it =
+                    regex_automata::util::iter::Searcher::new(input.clone());
+                while let Some(m) = it.try_advance(&mut search)? {
+                    counts[m.pattern().as_usize()] += 1;
+                }
+            }
+            Ok::<_, anyhow::Error>(counts)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", counts.iter().copied().sum::<u64>());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for (i, &count) in counts.iter().enumerate() {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                writeln!(out, "{}:{}", pid.as_usize(), count)?;
+            }
+        }
+        Ok(())
+    })
+}
+
+/// Like `run_counts`, but prints the actual matches instead.
+fn run_search(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    mut search: impl FnMut(&Input<'_>) -> Result<Option<Match>, MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (matches, time) = util::timeitr(|| {
+            let mut matches = vec![];
+            for _ in 0..find.repeat() {
+                let mut it =
+                    regex_automata::util::iter::Searcher::new(input.clone());
+                while let Some(m) = it.try_advance(&mut search)? {
+                    matches.push(m);
+                }
+            }
+            Ok::<_, anyhow::Error>(matches)
+        })?;
+        table.add("search time", time);
+        table.add("total matches", matches.len());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for m in matches.iter() {
+                writeln!(
+                    out,
+                    "{}:{}:{}:{}",
+                    m.pattern().as_usize(),
+                    m.start(),
+                    m.end(),
+                    input.haystack()[m.range()].escape_bytes()
+                )?;
+            }
+        }
+        Ok(())
+    })
+}
diff --git a/regex-cli/cmd/find/match/nfa.rs b/regex-cli/cmd/find/match/nfa.rs
new file mode 100644
index 0000000000..d8f4058d63
--- /dev/null
+++ b/regex-cli/cmd/find/match/nfa.rs
@@ -0,0 +1,156 @@
+use regex_automata::Input;
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_backtrack(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the BoundedBacktracker regex engine.
+
+USAGE:
+    regex-cli find match backtrack [-p <pattern> ...] <haystack-path>
+    regex-cli find match backtrack [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut backtrack = args::backtrack::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut backtrack,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| backtrack.from_nfa(&nfa))?;
+    table.add("build backtracker time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+    let (mut caps, time) = util::timeit(|| re.create_captures());
+    table.add("captures creation time", time);
+
+    let search = |input: &Input<'_>| {
+        re.try_search(&mut cache, input, &mut caps)?;
+        Ok(caps.get_match())
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
+
+pub fn run_pikevm(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the PikeVM regex engine.
+
+USAGE:
+    regex-cli find match pikevm [-p <pattern> ...] <haystack-path>
+    regex-cli find match pikevm [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut pikevm = args::pikevm::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut pikevm,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| pikevm.from_nfa(&nfa))?;
+    table.add("build pikevm time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+    let (mut caps, time) = util::timeit(|| re.create_captures());
+    table.add("captures creation time", time);
+
+    let search = |input: &Input<'_>| {
+        re.search(&mut cache, input, &mut caps);
+        Ok(caps.get_match())
+    };
+    if find.count {
+        super::run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            re.pattern_len(),
+            search,
+        )?;
+    } else {
+        super::run_search(
+            &mut table, &common, &find, &input, &haystack, search,
+        )?;
+    }
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/mod.rs b/regex-cli/cmd/find/mod.rs
new file mode 100644
index 0000000000..deb8cd1edc
--- /dev/null
+++ b/regex-cli/cmd/find/mod.rs
@@ -0,0 +1,94 @@
+use lexopt::{Arg, Parser};
+
+use crate::args::{self, Configurable, Usage};
+
+mod capture;
+mod half;
+mod r#match;
+mod which;
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search.
+
+The sub-command determines what kind of search to execute. The kind of the
+search to execute also determines which regex engines are available. For
+example, a lazy DFA cannot report the match positions of capture groups, so
+there is no 'regex-cli find capture hybrid' command.
+
+USAGE:
+    regex-cli find <command>
+
+COMMANDS:
+    capture   Search for regexes with capture groups.
+    half      Search for half matches.
+    match     Search for full matches.
+    which     Search for which patterns match in a set.
+";
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "capture" => capture::run(p),
+        "half" => half::run(p),
+        "match" => r#match::run(p),
+        "which" => which::run(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+#[derive(Debug, Default)]
+struct Config {
+    count: bool,
+    repeat: Option<u32>,
+}
+
+impl Config {
+    fn repeat(&self) -> u32 {
+        self.repeat.unwrap_or(1)
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Short('c') | Arg::Long("count") => {
+                self.count = true;
+            }
+            Arg::Long("repeat") => {
+                self.repeat = Some(args::parse(p, "--repeat")?);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &[Usage] = &[
+            Usage::new(
+                "-c, --count",
+                "Show a count of all matches.",
+                r#"
+Prints a count of all matches instead of printing the matches themselves. For
+the 'capture' command, this prints the number of times each group matched. For
+the 'which' command, this just prints whether each pattern matched or not.
+"#,
+            ),
+            Usage::new(
+                "--repeat",
+                "Repeat the search this many times.",
+                r#"
+Repeat the search this many times. By default, this is set to 1. This is useful
+when you want the search time to dominate the runtime of the program, or if the
+search is otherwise too short/fast to measure reliably.
+
+Note that this will print the matches repeatedly by default as well. For this
+reason, it's usually best to use this option in combination with -c/--count.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
diff --git a/regex-cli/cmd/find/which/dfa.rs b/regex-cli/cmd/find/which/dfa.rs
new file mode 100644
index 0000000000..a5827b504b
--- /dev/null
+++ b/regex-cli/cmd/find/which/dfa.rs
@@ -0,0 +1,212 @@
+use regex_automata::{dfa::Automaton, Input, PatternSet};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_hybrid(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the lazy DFA regex engine.
+
+USAGE:
+    regex-cli find match hybrid [-p <pattern> ...] <haystack-path>
+    regex-cli find match hybrid [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut hybrid = args::hybrid::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut hybrid,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| hybrid.from_nfa(&nfafwd))?;
+    table.add("build forward hybrid time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        re.try_which_overlapping_matches(&mut cache, input, patset)
+    };
+    super::run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.pattern_len(),
+        search,
+    )?;
+    Ok(())
+}
+
+pub fn run_dense(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the dense DFA regex engine.
+
+USAGE:
+    regex-cli find match dense [-p <pattern> ...] <haystack-path>
+    regex-cli find match dense [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dense = args::dfa::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut dense,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| dense.from_nfa(&nfafwd))?;
+    table.add("build forward dense DFA time", time);
+
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        re.try_which_overlapping_matches(input, patset)
+    };
+    super::run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.pattern_len(),
+        search,
+    )?;
+    Ok(())
+}
+
+pub fn run_sparse(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the sparse DFA regex engine.
+
+USAGE:
+    regex-cli find match sparse [-p <pattern> ...] <haystack-path>
+    regex-cli find match sparse [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut sparse = args::dfa::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut sparse,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfafwd, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile forward nfa time", time);
+    let (re, time) = util::timeitr(|| sparse.from_nfa_sparse(&nfafwd))?;
+    table.add("build forward sparse DFA time", time);
+
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        re.try_which_overlapping_matches(input, patset)
+    };
+    super::run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.pattern_len(),
+        search,
+    )?;
+    Ok(())
+}
diff --git a/regex-cli/cmd/find/which/mod.rs b/regex-cli/cmd/find/which/mod.rs
new file mode 100644
index 0000000000..4416a76f89
--- /dev/null
+++ b/regex-cli/cmd/find/which/mod.rs
@@ -0,0 +1,241 @@
+use std::io::{stdout, Write};
+
+use {
+    anyhow::Context,
+    lexopt::Parser,
+    regex_automata::{Input, MatchError, PatternID, PatternSet},
+};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+mod dfa;
+mod nfa;
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a 'which' search. This type of search reports *only* which patterns
+match a haystack. It doesn't report positions or even how many times each
+pattern matches. (Therefore, the -c/--count flag doesn't work with this
+command.)
+
+It is generally expected to use '--match-kind all' with this command, as the
+intent is to report all overlapping matches.
+
+Note that the search will usually scan the entire haystack. It can sometimes
+short circuit if all patterns are anchored or if the search knows no more
+patterns will match.
+
+This type of search is somewhat of a legacy feature because of how the
+top-level RegexSet API works in the 'regex' crate. Its API is pretty limited
+and it is difficult to extend to the more flexible meta regex API in
+regex-automata.
+
+The 'backtrack' engine isn't supported here because it doesn't have a 'which'
+search routine. In theory it could, but it would likely be slow and no better
+than just running each regex over the haystack one at a time.
+
+The 'onepass' engine also does not support this API. (At least, not currently.)
+
+USAGE:
+    regex-cli find which <engine>
+
+ENGINES:
+    dense      Search with the dense DFA regex engine.
+    hybrid     Search with the lazy DFA regex engine.
+    meta       Search with the meta regex engine.
+    pikevm     Search with the PikeVM regex engine.
+    regexset   Search with the top-level API regex engine.
+    sparse     Search with the sparse DFA regex engine.
+";
+    let cmd = args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "dense" => dfa::run_dense(p),
+        "hybrid" => dfa::run_hybrid(p),
+        "meta" => run_meta(p),
+        "pikevm" => nfa::run_pikevm(p),
+        "regex" => run_regex(p),
+        "sparse" => dfa::run_sparse(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_regex(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level API regex engine.
+
+USAGE:
+    regex-cli find match regex [-p <pattern> ...] <haystack-path>
+    regex-cli find match regex [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut api = args::api::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut api,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| api.from_patterns_set(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        let matches = re.matches(input.haystack());
+        for pid in matches.iter() {
+            let pid = PatternID::new(pid).unwrap();
+            patset.try_insert(pid).unwrap();
+        }
+        Ok(())
+    };
+    run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.len(),
+        search,
+    )?;
+    Ok(())
+}
+
+fn run_meta(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the meta regex engine.
+
+USAGE:
+    regex-cli find match meta [-p <pattern> ...] <haystack-path>
+    regex-cli find match meta [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut meta = args::meta::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut meta,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+
+    let re = if meta.build_from_patterns() {
+        let (re, time) = util::timeitr(|| meta.from_patterns(&syntax, &pats))?;
+        table.add("build meta time", time);
+        re
+    } else {
+        let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+        table.add("parse time", time);
+        let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+        table.add("translate time", time);
+        let (re, time) = util::timeitr(|| meta.from_hirs(&hirs))?;
+        table.add("build meta time", time);
+        re
+    };
+
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        Ok(re.which_overlapping_matches(input, patset))
+    };
+    run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.pattern_len(),
+        search,
+    )?;
+    Ok(())
+}
+
+/// Like `run_counts`, but prints the actual matches instead.
+fn run_search(
+    table: &mut Table,
+    common: &args::common::Config,
+    find: &super::Config,
+    input: &args::input::Config,
+    haystack: &args::haystack::Config,
+    pattern_len: usize,
+    mut search: impl FnMut(&Input<'_>, &mut PatternSet) -> Result<(), MatchError>,
+) -> anyhow::Result<()> {
+    let mut out = stdout();
+    input.with(haystack, |input| {
+        let (patset, time) = util::timeitr(|| {
+            let mut patset = PatternSet::new(pattern_len);
+            for _ in 0..find.repeat() {
+                search(&input, &mut patset)?;
+            }
+            Ok::<_, anyhow::Error>(patset)
+        })?;
+        table.add("search time", time);
+        table.add("patterns that matched", patset.len());
+        if common.table() {
+            table.print(&mut out)?;
+        }
+        if !common.quiet {
+            for i in 0..pattern_len {
+                let pid = PatternID::new(i).context("invalid pattern ID")?;
+                writeln!(
+                    out,
+                    "{}:{:?}",
+                    pid.as_usize(),
+                    patset.contains(pid)
+                )?;
+            }
+        }
+        Ok(())
+    })
+}
diff --git a/regex-cli/cmd/find/which/nfa.rs b/regex-cli/cmd/find/which/nfa.rs
new file mode 100644
index 0000000000..12356ced28
--- /dev/null
+++ b/regex-cli/cmd/find/which/nfa.rs
@@ -0,0 +1,77 @@
+use regex_automata::{Input, PatternSet};
+
+use crate::{
+    args,
+    util::{self, Table},
+};
+
+pub fn run_pikevm(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the PikeVM regex engine.
+
+USAGE:
+    regex-cli find match pikevm [-p <pattern> ...] <haystack-path>
+    regex-cli find match pikevm [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut input = args::input::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut pikevm = args::pikevm::Config::default();
+    let mut find = super::super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut input,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut thompson,
+            &mut pikevm,
+            &mut find,
+        ],
+    )?;
+    anyhow::ensure!(
+        !find.count,
+        "'which' command does not support reporting counts",
+    );
+
+    let pats = patterns.get()?;
+    let mut table = Table::empty();
+    let (asts, time) = util::timeitr(|| syntax.asts(&pats))?;
+    table.add("parse time", time);
+    let (hirs, time) = util::timeitr(|| syntax.hirs(&pats, &asts))?;
+    table.add("translate time", time);
+    let (nfa, time) = util::timeitr(|| thompson.from_hirs(&hirs))?;
+    table.add("compile nfa time", time);
+    let (re, time) = util::timeitr(|| pikevm.from_nfa(&nfa))?;
+    table.add("build pikevm time", time);
+    let (mut cache, time) = util::timeit(|| re.create_cache());
+    table.add("cache creation time", time);
+
+    let search = |input: &Input<'_>, patset: &mut PatternSet| {
+        re.which_overlapping_matches(&mut cache, input, patset);
+        Ok(())
+    };
+    super::run_search(
+        &mut table,
+        &common,
+        &find,
+        &input,
+        &haystack,
+        re.pattern_len(),
+        search,
+    )?;
+    Ok(())
+}
diff --git a/regex-cli/cmd/generate/fowler.rs b/regex-cli/cmd/generate/fowler.rs
new file mode 100644
index 0000000000..c0ab1b361c
--- /dev/null
+++ b/regex-cli/cmd/generate/fowler.rs
@@ -0,0 +1,420 @@
+use std::{
+    collections::HashSet,
+    fs::File,
+    io::{BufRead, Read, Write},
+    path::{Path, PathBuf},
+};
+
+use {
+    anyhow::Context,
+    bstr::ByteSlice,
+    lexopt::{Arg, Parser},
+};
+
+use crate::args::{self, Usage};
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = r#"
+Generate TOML tests from Glenn Fowler's regex test suite.
+
+This corresponds to a very sizeable set of regex tests that were written many
+moons ago. They have been tweaked slightly by both Russ Cox and myself (Andrew
+Gallant).
+
+This tool is the spiritual successor of some hacky Python scripts. Its input is
+a bespoke plain text format matching the original test data, and its output are
+TOML files meant to work with the 'regex-test' crate.
+
+Example usage from the root of this repository:
+
+    regex-cli generate fowler tests/data/fowler tests/data/fowler/dat/*.dat
+
+See tests/data/fowler/dat/README for more context.
+
+USAGE:
+    regex-cli generate fowler <outdir> <datfile> ...
+
+    outdir should be a path to a directory where you want the TOML files
+    to be written. datfile should be a Glenn Fowler dat file whose format
+    is bespoke.
+"#;
+
+    let mut config = Config::default();
+    args::configure(p, USAGE, &mut [&mut config])?;
+
+    let outdir = config.outdir()?;
+    let datfiles = config.datfiles()?;
+    for datfile in datfiles.iter() {
+        let datfile = Path::new(datfile);
+        let stem = match datfile.file_stem() {
+            Some(stem) => stem.to_string_lossy(),
+            None => anyhow::bail!("{}: has no file stem", datfile.display()),
+        };
+        let tomlfile = outdir.join(format!("{}.toml", stem));
+
+        let mut rdr = File::open(datfile)
+            .with_context(|| datfile.display().to_string())?;
+        let mut wtr = File::create(&tomlfile)
+            .with_context(|| tomlfile.display().to_string())?;
+        convert(&stem, &mut rdr, &mut wtr)
+            .with_context(|| stem.to_string())?;
+    }
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct Config {
+    outdir: Option<PathBuf>,
+    datfiles: Vec<PathBuf>,
+}
+
+impl Config {
+    fn outdir(&self) -> anyhow::Result<&Path> {
+        self.outdir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <outdir>"))
+    }
+
+    fn datfiles(&self) -> anyhow::Result<&[PathBuf]> {
+        anyhow::ensure!(!self.datfiles.is_empty(), "no Fowler datfiles given",);
+        Ok(&self.datfiles)
+    }
+}
+
+impl args::Configurable for Config {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Value(ref mut value) => {
+                let path = PathBuf::from(std::mem::take(value));
+                if self.outdir.is_none() {
+                    self.outdir = Some(path);
+                } else {
+                    self.datfiles.push(path);
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[];
+        USAGES
+    }
+}
+
+fn convert(
+    mut group_name: &str,
+    src: &mut dyn Read,
+    dst: &mut dyn Write,
+) -> anyhow::Result<()> {
+    log::trace!("processing {}", group_name);
+    let src = std::io::BufReader::new(src);
+
+    writeln!(
+        dst,
+        "\
+# !!! DO NOT EDIT !!!
+# Automatically generated by 'regex-cli generate fowler'.
+# Numbers in the test names correspond to the line number of the test from
+# the original dat file.
+"
+    )?;
+
+    let mut prev = None;
+    for (i, result) in src.lines().enumerate() {
+        // Every usize can fit into a u64... Right?
+        let line_number = u64::try_from(i).unwrap().checked_add(1).unwrap();
+        let line = result.with_context(|| format!("line {}", line_number))?;
+        // The last group of tests in 'repetition' take quite a lot of time
+        // when using them to build and minimize a DFA. So we tag them with
+        // 'expensive' so that we can skip those tests when we need to minimize
+        // a DFA.
+        if group_name == "repetition" && line.contains("Chris Kuklewicz") {
+            group_name = "repetition-expensive";
+        }
+        if line.trim().is_empty() || line.starts_with('#') {
+            // Too noisy to log that we're skipping an empty or commented test.
+            continue;
+        }
+        let dat = match DatTest::parse(prev.as_ref(), line_number, &line)? {
+            None => continue,
+            Some(dat) => dat,
+        };
+        let toml = TomlTest::from_dat_test(group_name, &dat)?;
+        writeln!(dst, "{}", toml)?;
+        prev = Some(dat);
+    }
+    Ok(())
+}
+
+#[derive(Debug)]
+struct TomlTest {
+    group_name: String,
+    line_number: u64,
+    regex: String,
+    haystack: String,
+    captures: Vec<Option<(u64, u64)>>,
+    unescape: bool,
+    case_insensitive: bool,
+    comment: Option<String>,
+}
+
+impl TomlTest {
+    fn from_dat_test(
+        group_name: &str,
+        dat: &DatTest,
+    ) -> anyhow::Result<TomlTest> {
+        let mut captures = dat.captures.clone();
+        if !captures.is_empty() {
+            // Many of the Fowler tests don't actually list out every capturing
+            // group match, and they instead stop once all remaining capturing
+            // groups are empty. In effect, it makes writing tests terser,
+            // but adds more implicitness. The TOML test suite does not make
+            // this trade off (to this extent anyway), so it really wants all
+            // capturing groups...
+            //
+            // So what we do here is is look for the number of groups in the
+            // pattern and then just pad out the capture matches with None
+            // values to make the number of capture matches equal to what we
+            // would expect from the pattern. (We actually parse the regex to
+            // determine this.)
+            //
+            // Sadly, this doesn't work for a small subset of tests that
+            // actually have more capturing group MATCHES than what is listed
+            // explicitly in the test. Instead, the test includes an 'nmatch'
+            // instruction that instructs the test runner to only consider the
+            // first N capturing groups. Our test runner has no such option...
+            // To fix that, I rewrote the tests to use non-capturing groups in
+            // order to match the expected number of capture matches.
+            let numcaps = count_capturing_groups(&dat.regex)?;
+            for _ in captures.len()..numcaps {
+                captures.push(None);
+            }
+        }
+
+        let comment = if dat.re2go {
+            Some("Test added by RE2/Go project.".to_string())
+        } else if dat.rust {
+            Some("Test added by Rust regex project.".to_string())
+        } else {
+            None
+        };
+        Ok(TomlTest {
+            group_name: group_name.to_string(),
+            line_number: dat.line_number,
+            regex: dat.regex.clone(),
+            haystack: dat.haystack.clone(),
+            captures,
+            unescape: dat.flags.contains(&'$'),
+            case_insensitive: dat.flags.contains(&'i'),
+            comment,
+        })
+    }
+}
+
+impl core::fmt::Display for TomlTest {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if let Some(ref comment) = self.comment {
+            writeln!(f, "# {}", comment)?;
+        }
+        writeln!(f, "[[test]]")?;
+        writeln!(f, "name = \"{}{}\"", self.group_name, self.line_number)?;
+        writeln!(f, "regex = '''{}'''", self.regex)?;
+        writeln!(f, "haystack = '''{}'''", self.haystack)?;
+        if self.captures.is_empty() {
+            writeln!(f, "matches = []")?;
+        } else {
+            write!(f, "matches = [[")?;
+            for (i, &group) in self.captures.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                match group {
+                    None => write!(f, "[]")?,
+                    Some((start, end)) => write!(f, "[{}, {}]", start, end)?,
+                }
+            }
+            writeln!(f, "]]")?;
+        }
+        writeln!(f, "match-limit = 1")?;
+        // If the match starts at 0, then set anchored=true. This gives us more
+        // coverage on the anchored option and lets regex engines like the
+        // one-pass DFA participate a bit more in the test suite.
+        if self
+            .captures
+            .get(0)
+            .and_then(|&s| s)
+            .map_or(false, |span| span.0 == 0)
+        {
+            writeln!(f, "anchored = true")?;
+        }
+        if self.unescape {
+            writeln!(f, "unescape = true")?;
+        }
+        if self.case_insensitive {
+            writeln!(f, "case-insensitive = true")?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct DatTest {
+    line_number: u64,
+    flags: HashSet<char>,
+    regex: String,
+    haystack: String,
+    captures: Vec<Option<(u64, u64)>>,
+    re2go: bool,
+    rust: bool,
+}
+
+impl DatTest {
+    fn parse(
+        prev: Option<&DatTest>,
+        line_number: u64,
+        line: &str,
+    ) -> anyhow::Result<Option<DatTest>> {
+        let fields: Vec<String> = line
+            .split('\t')
+            .map(|f| f.trim().to_string())
+            .filter(|f| !f.is_empty())
+            .collect();
+        if !(4 <= fields.len() && fields.len() <= 5) {
+            log::trace!(
+                "skipping {}: too few or too many fields ({})",
+                line_number,
+                fields.len(),
+            );
+            return Ok(None);
+        }
+
+        // First field contains terse one-letter flags.
+        let mut flags: HashSet<char> = fields[0].chars().collect();
+        if !flags.contains(&'E') {
+            log::trace!("skipping {}: does not contain 'E' flag", line_number);
+            return Ok(None);
+        }
+
+        // Second field contains the regex pattern or 'SAME' if it's the
+        // same as the regex in the previous test.
+        let mut regex = fields[1].clone();
+        if regex == "SAME" {
+            regex = match prev {
+                Some(test) => test.regex.clone(),
+                None => anyhow::bail!(
+                    "line {}: wants previous pattern but none is available",
+                    line_number,
+                ),
+            };
+        }
+
+        // Third field contains the text to search or 'NULL'.
+        let mut haystack = fields[2].clone();
+        if haystack == "NULL" {
+            haystack = "".to_string();
+        }
+
+        // Some tests have literal control characters in the regex/input
+        // instead of using escapes. TOML freaks out at this, so we detect the
+        // case, escape them and add '$' to our flags. (Which will ultimately
+        // instruct the test harness to unescape the input.)
+        if regex.chars().any(|c| c.is_control())
+            || haystack.chars().any(|c| c.is_control())
+        {
+            flags.insert('$');
+            regex = regex.as_bytes().escape_bytes().to_string();
+            haystack = haystack.as_bytes().escape_bytes().to_string();
+        }
+
+        // Fourth field contains the capturing groups, or 'NOMATCH' or an
+        // error.
+        let mut captures = vec![];
+        if fields[3] != "NOMATCH" {
+            // Some tests check for a compilation error to occur, but we skip
+            // these for now. We might consider adding them manually, or better
+            // yet, just adding support for them here.
+            if !fields[3].contains(',') {
+                log::trace!(
+                    "skipping {}: malformed capturing group",
+                    line_number
+                );
+                return Ok(None);
+            }
+            let noparen = fields[3]
+                .split(")(")
+                .map(|x| x.trim_matches(|c| c == '(' || c == ')'));
+            for group in noparen {
+                let (start, end) = match group.split_once(',') {
+                    Some((start, end)) => (start.trim(), end.trim()),
+                    None => anyhow::bail!(
+                        "line {}: invalid capturing group '{}' in '{}'",
+                        line_number,
+                        group,
+                        fields[3]
+                    ),
+                };
+                if start == "?" && end == "?" {
+                    captures.push(None);
+                } else {
+                    let start = start.parse()?;
+                    let end = end.parse()?;
+                    captures.push(Some((start, end)));
+                }
+            }
+        }
+
+        // The fifth field is optional and contains some notes. Currently, this
+        // is used to indicate tests added or modified by particular regex
+        // implementations.
+        let re2go = fields.len() >= 5 && fields[4] == "RE2/Go";
+        let rust = fields.len() >= 5 && fields[4] == "Rust";
+
+        Ok(Some(DatTest {
+            line_number,
+            flags,
+            regex,
+            haystack,
+            captures,
+            re2go,
+            rust,
+        }))
+    }
+}
+
+fn count_capturing_groups(pattern: &str) -> anyhow::Result<usize> {
+    let ast = regex_syntax::ast::parse::Parser::new()
+        .parse(pattern)
+        .with_context(|| format!("failed to parse '{}'", pattern))?;
+    // We add 1 to account for the capturing group for the entire
+    // pattern.
+    Ok(1 + count_capturing_groups_ast(&ast))
+}
+
+fn count_capturing_groups_ast(ast: &regex_syntax::ast::Ast) -> usize {
+    use regex_syntax::ast::Ast;
+    match *ast {
+        Ast::Empty(_)
+        | Ast::Flags(_)
+        | Ast::Literal(_)
+        | Ast::Dot(_)
+        | Ast::Assertion(_)
+        | Ast::Class(_) => 0,
+        Ast::Repetition(ref rep) => count_capturing_groups_ast(&*rep.ast),
+        Ast::Group(ref group) => {
+            let this = if group.is_capturing() { 1 } else { 0 };
+            this + count_capturing_groups_ast(&*group.ast)
+        }
+        Ast::Alternation(ref alt) => {
+            alt.asts.iter().map(count_capturing_groups_ast).sum()
+        }
+        Ast::Concat(ref concat) => {
+            concat.asts.iter().map(count_capturing_groups_ast).sum()
+        }
+    }
+}
diff --git a/regex-cli/cmd/generate/mod.rs b/regex-cli/cmd/generate/mod.rs
new file mode 100644
index 0000000000..3a2faac403
--- /dev/null
+++ b/regex-cli/cmd/generate/mod.rs
@@ -0,0 +1,28 @@
+use crate::args;
+
+mod fowler;
+mod serialize;
+mod unicode;
+
+const USAGE: &'static str = r#"
+A tool for doing various types of generation tasks. This includes things like
+serializing DFAs to be compiled into other programs, and generating the Unicode
+tables used by the regex project.
+
+USAGE:
+    regex-cli generate <command>
+
+COMMANDS:
+    fowler      Convert Glenn Fowler's test suite to TOML files.
+    serialize   Serialize DFAs and generate Rust code to load them.
+    unicode     Generate all Unicode tables required for the regex project.
+"#;
+
+pub fn run(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    match &*args::next_as_command(USAGE, p)? {
+        "fowler" => fowler::run(p),
+        "serialize" => serialize::run(p),
+        "unicode" => unicode::run(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
diff --git a/regex-cli/cmd/generate/serialize/dfa.rs b/regex-cli/cmd/generate/serialize/dfa.rs
new file mode 100644
index 0000000000..1c7b409b3a
--- /dev/null
+++ b/regex-cli/cmd/generate/serialize/dfa.rs
@@ -0,0 +1,864 @@
+// The code in this module honestly sucks. I did at one point try and make it a
+// little more composable, particularly with respect to the stuff that writes
+// the Rust code, but it became an unintelligble mess. Instead, I squashed
+// it down into four functions: dense DFAs, dense regexes, sparse DFAs and
+// sparse regexes. And each of those functions handles the 'regex-automata',
+// 'once-cell' and 'lazy-static' variants. So that's 12 different variants.
+// There's *some* sharing within each function at least...
+//
+// With that said, I don't expect this code generation task to expand much.
+// We'll probably support std's OnceCell once that stabilizes, but otherwise,
+// I think we'll be stuck with just full DFAs for the time being. If and when
+// the code generation task expands to other objects (NFAs?), maybe we should
+// reconsider how this code is structured.
+
+use std::{
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use {
+    anyhow::Context,
+    lexopt::{Arg, Parser, ValueExt},
+    regex_automata::dfa::{dense, sparse},
+};
+
+use crate::{
+    args::{self, Usage},
+    util,
+};
+
+pub fn run_dense(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a dense fully compiled DFA (or regex DFA) to disk.
+
+USAGE:
+    regex-cli generate serialize dense <command>
+
+ENGINES:
+    dfa     Serialize a fully compiled dense DFA.
+    regex   Serialize a pair of fully compiled dense DFAs as a regex.
+";
+    match &*args::next_as_command(USAGE, p)? {
+        "dfa" => run_dense_dfa(p),
+        "regex" => run_dense_regex(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_dense_dfa(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a dense fully compiled DFA to disk.
+
+USAGE:
+    regex-cli generate serialize dense dfa <name> <outdir> [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut config = Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            // This needs to come first, as it greedily parses the first
+            // two positional parameters, and then 'patterns' takes the rest.
+            &mut config,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let asts = syntax.asts(&pats)?;
+    let hirs = syntax.hirs(&pats, &asts)?;
+    let nfa = thompson.from_hirs(&hirs)?;
+    let dfa = dfa.from_nfa(&nfa)?;
+
+    let wtr = config.writer()?;
+    wtr.write_dfa_dense_bytes(&dfa, "")?;
+    wtr.write_dfa_dense_rust()?;
+
+    Ok(())
+}
+
+fn run_dense_regex(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a dense fully compiled DFA regex to disk.
+
+USAGE:
+    regex-cli generate serialize dense regex <name> <outdir> [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut config = Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            // This needs to come first, as it greedily parses the first
+            // two positional parameters, and then 'patterns' takes the rest.
+            &mut config,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let asts = syntax.asts(&pats)?;
+    let hirs = syntax.hirs(&pats, &asts)?;
+    let nfafwd = thompson.from_hirs(&hirs)?;
+    let nfarev = thompson.reversed().from_hirs(&hirs)?;
+    let dfafwd = dfa.from_nfa(&nfafwd)?;
+    let dfarev = dfa.reversed().from_nfa(&nfarev)?;
+
+    let wtr = config.writer()?;
+    wtr.write_dfa_dense_bytes(&dfafwd, "_fwd")?;
+    wtr.write_dfa_dense_bytes(&dfarev, "_rev")?;
+    wtr.write_regex_dense_rust()?;
+    Ok(())
+}
+
+pub fn run_sparse(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a sparse fully compiled DFA (or regex DFA) to disk.
+
+USAGE:
+    regex-cli generate serialize sparse <command>
+
+ENGINES:
+    dfa     Serialize a fully compiled sparse DFA.
+    regex   Serialize a pair of fully compiled sparse DFAs as a regex.
+";
+    match &*args::next_as_command(USAGE, p)? {
+        "dfa" => run_sparse_dfa(p),
+        "regex" => run_sparse_regex(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
+
+fn run_sparse_dfa(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a sparse fully compiled DFA to disk.
+
+USAGE:
+    regex-cli generate serialize sparse dfa <name> <outdir> [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut config = Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            // This needs to come first, as it greedily parses the first
+            // two positional parameters, and then 'patterns' takes the rest.
+            &mut config,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let asts = syntax.asts(&pats)?;
+    let hirs = syntax.hirs(&pats, &asts)?;
+    let nfa = thompson.from_hirs(&hirs)?;
+    let dfa = dfa.from_nfa_sparse(&nfa)?;
+
+    let wtr = config.writer()?;
+    wtr.write_dfa_sparse_bytes(&dfa, "")?;
+    wtr.write_dfa_sparse_rust()?;
+
+    Ok(())
+}
+
+fn run_sparse_regex(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes a sparse fully compiled DFA regex to disk.
+
+USAGE:
+    regex-cli generate serialize sparse regex <name> <outdir> [<pattern> ...]
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut config = Config::default();
+    let mut patterns = args::patterns::Config::positional();
+    let mut syntax = args::syntax::Config::default();
+    let mut thompson = args::thompson::Config::default();
+    let mut dfa = args::dfa::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            // This needs to come first, as it greedily parses the first
+            // two positional parameters, and then 'patterns' takes the rest.
+            &mut config,
+            &mut patterns,
+            &mut syntax,
+            &mut thompson,
+            &mut dfa,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let asts = syntax.asts(&pats)?;
+    let hirs = syntax.hirs(&pats, &asts)?;
+    let nfafwd = thompson.from_hirs(&hirs)?;
+    let nfarev = thompson.reversed().from_hirs(&hirs)?;
+    let dfafwd = dfa.from_nfa_sparse(&nfafwd)?;
+    let dfarev = dfa.reversed().from_nfa_sparse(&nfarev)?;
+
+    let wtr = config.writer()?;
+    wtr.write_dfa_sparse_bytes(&dfafwd, "_fwd")?;
+    wtr.write_dfa_sparse_bytes(&dfarev, "_rev")?;
+    wtr.write_regex_sparse_rust()?;
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct Config {
+    name: Option<String>,
+    outdir: Option<PathBuf>,
+    safe: bool,
+    rust_kind: RustKind,
+    rustfmt: bool,
+}
+
+impl Config {
+    fn writer(&self) -> anyhow::Result<Writer> {
+        let varname = self.name()?.to_string();
+        let modname = rust_module_name(&varname);
+        Ok(Writer {
+            varname,
+            modname,
+            outdir: self.outdir()?.to_path_buf(),
+            safe: self.safe,
+            rust_kind: self.rust_kind,
+            rustfmt: self.rustfmt,
+        })
+    }
+
+    fn name(&self) -> anyhow::Result<&str> {
+        self.name.as_deref().ok_or_else(|| anyhow::anyhow!("missing <name>"))
+    }
+
+    fn outdir(&self) -> anyhow::Result<&Path> {
+        self.outdir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <outdir>"))
+    }
+}
+
+impl args::Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("safe") => {
+                self.safe = true;
+            }
+            Arg::Long("rust") => {
+                self.rust_kind = args::parse(p, "--rust")?;
+            }
+            Arg::Long("rustfmt") => {
+                self.rustfmt = true;
+            }
+            Arg::Value(ref mut value) => {
+                if self.name.is_none() {
+                    let v = std::mem::take(value);
+                    self.name = Some(
+                        v.string().context("<name> must be valid UTF-8")?,
+                    );
+                } else if self.outdir.is_none() {
+                    self.outdir = Some(PathBuf::from(std::mem::take(value)));
+                } else {
+                    return Ok(false);
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[
+            Usage::new(
+                "--safe",
+                "If possible, only use safe Rust code to deserialize DFAs.",
+                r#"
+If possible, only use safe Rust code to deserialize DFAs. Generally speaking,
+this requires a more expensive deserialization process, as it needs to verify
+that every transition in the DFA points to a valid state. In other words, it
+does work that is proportional to the size of every transition in the DFA.
+Where as using deserialization that isn't safe will execute in constant time.
+Whether the extra checks take too much time depends. They probably don't.
+
+With that said, it is always correct to *not* use this flag, as the serialized
+DFA is generated by this crate. That is, the only way undefined behavior
+can occur is if there is a bug in the implementation of serialization or
+deserialization. Therefore, cases where --safe should be used are somewhat
+limited. For example, if the risk of a bug in the implementation is too high or
+if you're just paranoid.
+"#,
+            ),
+            Usage::new(
+                "--rust <kind>",
+                "Choose from: regex-automata, once-cell, lazy-static, none.",
+                r#"
+This flag permits one to specify how the DFA is initially loaded.
+
+The default is regex-automata, which will use its 'util::lazy::Lazy' type.
+The 'Lazy' type works in no-std and no-alloc contexts. Otherwise, 'once-cell'
+will use the 'Lazy' type from the once_cell crate. 'lazy-static' will use the
+'lazy_static!' macro from the lazy_static crate. And 'none' will not generate
+any Rust source code at all.
+"#,
+            ),
+            Usage::new(
+                "--rustfmt",
+                "Run rustfmt on the generated code.",
+                r#"
+When set, rustfmt is run on the generated code. Without rustfmt, the code
+formatting may be arbitrarily bad.
+"#,
+            ),
+        ];
+        USAGES
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum RustKind {
+    RegexAutomata,
+    OnceCell,
+    LazyStatic,
+    None,
+}
+
+impl Default for RustKind {
+    fn default() -> RustKind {
+        RustKind::RegexAutomata
+    }
+}
+
+impl std::str::FromStr for RustKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<RustKind> {
+        match s {
+            "regex-automata" => Ok(RustKind::RegexAutomata),
+            "once-cell" => Ok(RustKind::OnceCell),
+            "lazy-static" => Ok(RustKind::LazyStatic),
+            "none" => Ok(RustKind::None),
+            unk => anyhow::bail!("unrecognized rust output kind: '{}'", unk),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Writer {
+    outdir: PathBuf,
+    varname: String,
+    modname: String,
+    safe: bool,
+    rust_kind: RustKind,
+    rustfmt: bool,
+}
+
+impl Writer {
+    fn write_dfa_dense_bytes(
+        &self,
+        dfa: &dense::DFA<Vec<u32>>,
+        name_suffix: &str,
+    ) -> anyhow::Result<()> {
+        let (big_bytes, _) = dfa.to_bytes_big_endian();
+        let (lil_bytes, _) = dfa.to_bytes_little_endian();
+        let big_path = self.outdir.join(self.big_name(name_suffix));
+        let lil_path = self.outdir.join(self.lil_name(name_suffix));
+        std::fs::write(&big_path, &big_bytes)
+            .with_context(|| format!("{}", big_path.display()))?;
+        std::fs::write(&lil_path, &lil_bytes)
+            .with_context(|| format!("{}", lil_path.display()))?;
+        Ok(())
+    }
+
+    fn write_dfa_sparse_bytes(
+        &self,
+        dfa: &sparse::DFA<Vec<u8>>,
+        name_suffix: &str,
+    ) -> anyhow::Result<()> {
+        let big_bytes = dfa.to_bytes_big_endian();
+        let lil_bytes = dfa.to_bytes_little_endian();
+        let big_path = self.outdir.join(self.big_name(name_suffix));
+        let lil_path = self.outdir.join(self.lil_name(name_suffix));
+        std::fs::write(&big_path, &big_bytes)
+            .with_context(|| format!("{}", big_path.display()))?;
+        std::fs::write(&lil_path, &lil_bytes)
+            .with_context(|| format!("{}", lil_path.display()))?;
+        Ok(())
+    }
+
+    fn write_dfa_dense_rust(&self) -> anyhow::Result<()> {
+        if matches!(self.rust_kind, RustKind::None) {
+            return Ok(());
+        }
+        let outpath = self.outdir.join(format!("{}.rs", self.modname));
+        let mut wtr = std::fs::File::create(&outpath)
+            .with_context(|| outpath.display().to_string())?;
+
+        let auto_gen_message = self.auto_gen_message().trim().to_string();
+        let name = &self.varname;
+        let bigname = self.big_name("");
+        let lilname = self.lil_name("");
+        let from_bytes = if self.safe {
+            "DFA::from_bytes(&ALIGNED.bytes)"
+        } else {
+            "unsafe { DFA::from_bytes_unchecked(&ALIGNED.bytes) }"
+        };
+        let deserialize = format!(
+            r##"
+    static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {{
+        _align: [],
+        #[cfg(target_endian = "big")]
+        bytes: *include_bytes!("{bigname}"),
+        #[cfg(target_endian = "little")]
+        bytes: *include_bytes!("{lilname}"),
+    }};
+    let (dfa, _) = {from_bytes}.expect("serialized DFA should be valid");
+    dfa
+"##,
+        );
+        match self.rust_kind {
+            RustKind::RegexAutomata => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::dense::DFA,
+    util::{{lazy::Lazy, wire::AlignAs}},
+}};
+
+pub static {name}: Lazy<DFA<&'static [u32]>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::OnceCell => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use {{
+    once_cell::sync::Lazy,
+    regex_automata::{{
+        dfa::dense::DFA,
+        util::wire::AlignAs,
+    }},
+}};
+
+pub static {name}: Lazy<DFA<&'static [u32]>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::LazyStatic => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::dense::DFA,
+    util::wire::AlignAs,
+}};
+
+lazy_static::lazy_static! {{
+    pub static ref {name}: DFA<&'static [u32]> = {{
+        {deserialize}
+    }};
+}}
+"##,
+                )?;
+            }
+            RustKind::None => unreachable!(),
+        }
+        if self.rustfmt {
+            util::rustfmt(&outpath)?;
+        }
+        Ok(())
+    }
+
+    fn write_dfa_sparse_rust(&self) -> anyhow::Result<()> {
+        if matches!(self.rust_kind, RustKind::None) {
+            return Ok(());
+        }
+        let outpath = self.outdir.join(format!("{}.rs", self.modname));
+        let mut wtr = std::fs::File::create(&outpath)
+            .with_context(|| outpath.display().to_string())?;
+
+        let auto_gen_message = self.auto_gen_message().trim().to_string();
+        let name = &self.varname;
+        let bigname = self.big_name("");
+        let lilname = self.lil_name("");
+        let from_bytes = if self.safe {
+            "DFA::from_bytes(BYTES)"
+        } else {
+            "unsafe { DFA::from_bytes_unchecked(BYTES) }"
+        };
+        let deserialize = format!(
+            r##"
+    #[cfg(target_endian = "big")]
+    static BYTES: &'static [u8] = include_bytes!("{bigname}");
+    #[cfg(target_endian = "little")]
+    static BYTES: &'static [u8] = include_bytes!("{lilname}");
+    let (dfa, _) = {from_bytes}.expect("serialized DFA should be valid");
+    dfa
+"##,
+        );
+        match self.rust_kind {
+            RustKind::RegexAutomata => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::sparse::DFA,
+    util::lazy::Lazy,
+}};
+
+pub static {name}: Lazy<DFA<&'static [u8]>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::OnceCell => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use {{
+    once_cell::sync::Lazy,
+    regex_automata::dfa::sparse::DFA,
+}};
+
+pub static {name}: Lazy<DFA<&'static [u8]>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::LazyStatic => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::dfa::sparse::DFA;
+
+lazy_static::lazy_static! {{
+    pub static ref {name}: DFA<&'static [u8]> = {{
+        {deserialize}
+    }};
+}}
+"##,
+                )?;
+            }
+            RustKind::None => unreachable!(),
+        }
+        if self.rustfmt {
+            util::rustfmt(&outpath)?;
+        }
+        Ok(())
+    }
+
+    fn write_regex_dense_rust(&self) -> anyhow::Result<()> {
+        if matches!(self.rust_kind, RustKind::None) {
+            return Ok(());
+        }
+        let outpath = self.outdir.join(format!("{}.rs", self.modname));
+        let mut wtr = std::fs::File::create(&outpath)
+            .with_context(|| outpath.display().to_string())?;
+
+        let auto_gen_message = self.auto_gen_message().trim().to_string();
+        let name = &self.varname;
+        let fwdbigname = self.big_name("_fwd");
+        let fwdlilname = self.lil_name("_fwd");
+        let revbigname = self.big_name("_rev");
+        let revlilname = self.lil_name("_rev");
+        let from_bytes = if self.safe {
+            "DFA::from_bytes(&ALIGNED.bytes)"
+        } else {
+            "unsafe { DFA::from_bytes_unchecked(&ALIGNED.bytes) }"
+        };
+        let deserialize = format!(
+            r##"
+    let dfafwd = {{
+        static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {{
+            _align: [],
+            #[cfg(target_endian = "big")]
+            bytes: *include_bytes!("{fwdbigname}"),
+            #[cfg(target_endian = "little")]
+            bytes: *include_bytes!("{fwdlilname}"),
+        }};
+        {from_bytes}.expect("serialized forward DFA should be valid").0
+    }};
+    let dfarev = {{
+        static ALIGNED: &AlignAs<[u8], u32> = &AlignAs {{
+            _align: [],
+            #[cfg(target_endian = "big")]
+            bytes: *include_bytes!("{revbigname}"),
+            #[cfg(target_endian = "little")]
+            bytes: *include_bytes!("{revlilname}"),
+        }};
+        {from_bytes}.expect("serialized reverse DFA should be valid").0
+    }};
+    Regex::builder().build_from_dfas(dfafwd, dfarev)
+
+"##,
+        );
+        match self.rust_kind {
+            RustKind::RegexAutomata => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::{{dense::DFA, regex::Regex}},
+    util::{{lazy::Lazy, wire::AlignAs}},
+}};
+
+pub static {name}: Lazy<Regex<DFA<&'static [u32]>>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::OnceCell => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use {{
+    once_cell::sync::Lazy,
+    regex_automata::{{
+        dfa::{{dense::DFA, regex::Regex}},
+        util::wire::AlignAs,
+    }},
+}};
+
+pub static {name}: Lazy<Regex<DFA<&'static [u32]>>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::LazyStatic => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::{{dense::DFA, regex::Regex}},
+    util::wire::AlignAs,
+}};
+
+lazy_static::lazy_static! {{
+    pub static ref {name}: Regex<DFA<&'static [u32]>> = {{
+        {deserialize}
+    }};
+}}
+"##,
+                )?;
+            }
+            RustKind::None => unreachable!(),
+        }
+        if self.rustfmt {
+            util::rustfmt(&outpath)?;
+        }
+        Ok(())
+    }
+
+    fn write_regex_sparse_rust(&self) -> anyhow::Result<()> {
+        if matches!(self.rust_kind, RustKind::None) {
+            return Ok(());
+        }
+        let outpath = self.outdir.join(format!("{}.rs", self.modname));
+        let mut wtr = std::fs::File::create(&outpath)
+            .with_context(|| outpath.display().to_string())?;
+
+        let auto_gen_message = self.auto_gen_message().trim().to_string();
+        let name = &self.varname;
+        let fwdbigname = self.big_name("_fwd");
+        let fwdlilname = self.lil_name("_fwd");
+        let revbigname = self.big_name("_rev");
+        let revlilname = self.lil_name("_rev");
+        let from_bytes = if self.safe {
+            "DFA::from_bytes(BYTES)"
+        } else {
+            "unsafe { DFA::from_bytes_unchecked(BYTES) }"
+        };
+        let deserialize = format!(
+            r##"
+    let dfafwd = {{
+        #[cfg(target_endian = "big")]
+        static BYTES: &'static [u8] = include_bytes!("{fwdbigname}");
+        #[cfg(target_endian = "little")]
+        static BYTES: &'static [u8] = include_bytes!("{fwdlilname}");
+        {from_bytes}.expect("serialized forward DFA should be valid").0
+    }};
+    let dfarev = {{
+        #[cfg(target_endian = "big")]
+        static BYTES: &'static [u8] = include_bytes!("{revbigname}");
+        #[cfg(target_endian = "little")]
+        static BYTES: &'static [u8] = include_bytes!("{revlilname}");
+        {from_bytes}.expect("serialized reverse DFA should be valid").0
+    }};
+    Regex::builder().build_from_dfas(dfafwd, dfarev)
+
+"##,
+        );
+        match self.rust_kind {
+            RustKind::RegexAutomata => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::{{
+    dfa::{{regex::Regex, sparse::DFA}},
+    util::lazy::Lazy,
+}};
+
+pub static {name}: Lazy<Regex<DFA<&'static [u8]>>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::OnceCell => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use {{
+    once_cell::sync::Lazy,
+    regex_automata::dfa::{{regex::Regex, sparse::DFA}},
+}};
+
+pub static {name}: Lazy<Regex<DFA<&'static [u8]>>> = Lazy::new(|| {{
+    {deserialize}
+}});
+"##,
+                )?;
+            }
+            RustKind::LazyStatic => {
+                writeln!(
+                    wtr,
+                    r##"
+{auto_gen_message}
+
+use regex_automata::dfa::{{regex::Regex, sparse::DFA}};
+
+lazy_static::lazy_static! {{
+    pub static ref {name}: Regex<DFA<&'static [u8]>> = {{
+        {deserialize}
+    }};
+}}
+"##,
+                )?;
+            }
+            RustKind::None => unreachable!(),
+        }
+        if self.rustfmt {
+            util::rustfmt(&outpath)?;
+        }
+        Ok(())
+    }
+
+    fn auto_gen_message(&self) -> String {
+        let version = env!("CARGO_PKG_VERSION");
+        let cmd = std::env::args_os()
+            .map(|a| a.to_string_lossy().into_owned())
+            .map(|a| {
+                if a.contains('\n') {
+                    "<snip: arg too long>".to_string()
+                } else {
+                    a
+                }
+            })
+            .collect::<Vec<String>>()
+            .join(" ");
+        format!(
+            r#"
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//     {cmd}
+//
+// regex-cli {version} is available on crates.io.
+"#
+        )
+    }
+
+    fn big_name(&self, name_suffix: &str) -> String {
+        format!("{}{}.bigendian.dfa", self.modname, name_suffix)
+    }
+
+    fn lil_name(&self, name_suffix: &str) -> String {
+        format!("{}{}.littleendian.dfa", self.modname, name_suffix)
+    }
+}
+
+fn rust_module_name(var_name: &str) -> String {
+    var_name.to_ascii_lowercase()
+}
diff --git a/regex-cli/cmd/generate/serialize/mod.rs b/regex-cli/cmd/generate/serialize/mod.rs
new file mode 100644
index 0000000000..a0c2f779ac
--- /dev/null
+++ b/regex-cli/cmd/generate/serialize/mod.rs
@@ -0,0 +1,22 @@
+use crate::args;
+
+mod dfa;
+
+pub fn run(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Serializes regex objects to disk, and optionally includes generating Rust
+source code for embedding and loading those regex objects into your program.
+
+USAGE:
+    regex-cli generate serialize <engine>
+
+ENGINES:
+    dense    Serialize fully compiled dense DFAs or dense regex DFAs.
+    sparse   Serialize fully compiled sparse DFAs or sparse regex DFAs.
+";
+    match &*args::next_as_command(USAGE, p)? {
+        "dense" => dfa::run_dense(p),
+        "sparse" => dfa::run_sparse(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
diff --git a/regex-cli/cmd/generate/unicode.rs b/regex-cli/cmd/generate/unicode.rs
new file mode 100644
index 0000000000..2c60bb872a
--- /dev/null
+++ b/regex-cli/cmd/generate/unicode.rs
@@ -0,0 +1,189 @@
+use std::{
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use {
+    anyhow::Context,
+    bstr::BString,
+    lexopt::{Arg, Parser},
+};
+
+use crate::{
+    args::{self, Usage},
+    util,
+};
+
+pub fn run(p: &mut Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Generates all Unicode tables for the regex project.
+
+Most Unicode tables are generated into the regex-syntax library.
+
+Note that this requires that the 'ucd-generate' tool be installed and in your
+PATH. The 'ucd-generate' tool is what is responsible for reading from the
+Unicode Character Database (UCD) and converting tables of codepoints into Rust
+code that is embedded into the regex library.
+
+ucd-generate can be found here https://github.com/BurntSushi/ucd-generate/
+and can be installed with:
+
+    cargo install ucd-generate
+
+And you can get a copy of, for example, UCD 15.0.0 like this:
+
+    $ mkdir /tmp/ucd-15.0.0
+    $ cd /tmp/ucd-15.0.0
+    $ curl -LO https://www.unicode.org/Public/zipped/15.0.0/UCD.zip
+    $ unzip UCD.zip
+
+USAGE:
+    regex-cli generate unicode <outdir> <ucddir>
+
+    outdir should be a directory path pointing to the root of the regex
+    repository. ucddir should be a directory containing the UCD data
+    downloaded from unicode.org, as described in ucd-generate's README:
+    https://github.com/BurntSushi/ucd-generate/
+
+";
+
+    let mut config = Config::default();
+    args::configure(p, USAGE, &mut [&mut config])?;
+
+    let out = config.outdir()?;
+    let ucd = config.ucddir()?;
+
+    // Data tables for regex-syntax.
+    let d = out.join("regex-syntax").join("src").join("unicode_tables");
+    gen(d.join("age.rs"), &["age", &ucd, "--chars"])?;
+    gen(
+        d.join("case_folding_simple.rs"),
+        &["case-folding-simple", &ucd, "--chars", "--all-pairs"],
+    )?;
+    gen(
+        d.join("general_category.rs"),
+        &["general-category", &ucd, "--chars", "--exclude", "surrogate"],
+    )?;
+    gen(
+        d.join("grapheme_cluster_break.rs"),
+        &["grapheme-cluster-break", &ucd, "--chars"],
+    )?;
+    gen(d.join("property_bool.rs"), &["property-bool", &ucd, "--chars"])?;
+    gen(d.join("property_names.rs"), &["property-names", &ucd])?;
+    gen(
+        d.join("property_values.rs"),
+        &["property-values", &ucd, "--include", "gc,script,scx,age,gcb,wb,sb"],
+    )?;
+    gen(d.join("script.rs"), &["script", &ucd, "--chars"])?;
+    gen(
+        d.join("script_extension.rs"),
+        &["script-extension", &ucd, "--chars"],
+    )?;
+    gen(d.join("sentence_break.rs"), &["sentence-break", &ucd, "--chars"])?;
+    gen(d.join("word_break.rs"), &["word-break", &ucd, "--chars"])?;
+
+    // Data tables for regex-automata.
+    let d = out
+        .join("regex-automata")
+        .join("src")
+        .join("util")
+        .join("unicode_data");
+    // Note that this table is only used in cases where the regex-syntax
+    // dependency is disabled for regex-automata, but where the
+    // unicode-word-boundary feature is still enabled. That is, we do NOT
+    // duplicate the perl_word table from regex-syntax. Only one copy will get
+    // built.
+    gen(d.join("perl_word.rs"), &["perl-word", &ucd, "--chars"])?;
+
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct Config {
+    outdir: Option<PathBuf>,
+    ucddir: Option<PathBuf>,
+}
+
+impl Config {
+    fn outdir(&self) -> anyhow::Result<&Path> {
+        self.outdir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <outdir>"))
+    }
+
+    fn ucddir(&self) -> anyhow::Result<&str> {
+        self.ucddir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("missing <ucddir>"))?
+            .to_str()
+            .ok_or_else(|| anyhow::anyhow!("ucddir must be valid UTF-8"))
+    }
+}
+
+impl args::Configurable for Config {
+    fn configure(
+        &mut self,
+        _: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Value(ref mut value) => {
+                if self.outdir.is_none() {
+                    self.outdir = Some(PathBuf::from(std::mem::take(value)));
+                } else if self.ucddir.is_none() {
+                    self.ucddir = Some(PathBuf::from(std::mem::take(value)));
+                } else {
+                    return Ok(false);
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[];
+        USAGES
+    }
+}
+
+/// Run 'ucd-generate' with the args given, write its output to the file path
+/// given and apply 'rustfmt' to it.
+fn gen<P: AsRef<Path>>(dest: P, args: &[&str]) -> anyhow::Result<()> {
+    let dest = dest.as_ref();
+    ucdgen_to(dest, args)?;
+    util::rustfmt(dest)?;
+    Ok(())
+}
+
+/// Run 'ucd-generate' with the args given and write its output to the file
+/// path given.
+fn ucdgen_to<P: AsRef<Path>>(dest: P, args: &[&str]) -> anyhow::Result<()> {
+    let dest = dest.as_ref();
+    let err = || format!("{}", dest.display());
+    // The "right" thing would be to connect this to the stdout of
+    // ucd-generate, but meh, I got lazy.
+    let mut fdest = File::create(dest).with_context(err)?;
+    let data = ucdgen(args)?;
+    fdest.write_all(&data).with_context(err)?;
+    Ok(())
+}
+
+/// Run 'ucd-generate' with the args given. Upon success, the contents of
+/// stdout are returned. Otherwise, the error will include the contents of
+/// stderr.
+fn ucdgen(args: &[&str]) -> anyhow::Result<Vec<u8>> {
+    let out = Command::new("ucd-generate")
+        .args(args)
+        .output()
+        .context("ucd-generate command failed")?;
+    anyhow::ensure!(
+        out.status.success(),
+        "ucd-generate {}: {}",
+        args.join(" "),
+        BString::from(out.stderr),
+    );
+    Ok(out.stdout)
+}
diff --git a/regex-cli/cmd/mod.rs b/regex-cli/cmd/mod.rs
new file mode 100644
index 0000000000..5e9706a57b
--- /dev/null
+++ b/regex-cli/cmd/mod.rs
@@ -0,0 +1,28 @@
+mod compile_test;
+mod debug;
+mod find;
+mod generate;
+
+const USAGE: &'static str = "\
+A tool for interacting with Rust's regex crate on the command line.
+
+USAGE:
+    regex-cli <command> ...
+
+COMMANDS:
+    compile-test  Measure binary size and compile time of various configs.
+    debug         Print the debug representation of things from regex-automata.
+    find          Search haystacks with one of many different regex engines.
+    generate      Various generation tasks, e.g., serializing DFAs.
+";
+
+pub fn run(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    let cmd = crate::args::next_as_command(USAGE, p)?;
+    match &*cmd {
+        "compile-test" => compile_test::run(p),
+        "find" => find::run(p),
+        "debug" => debug::run(p),
+        "generate" => generate::run(p),
+        unk => anyhow::bail!("unrecognized command '{}'", unk),
+    }
+}
diff --git a/regex-cli/logger.rs b/regex-cli/logger.rs
new file mode 100644
index 0000000000..0fe063f1ce
--- /dev/null
+++ b/regex-cli/logger.rs
@@ -0,0 +1,68 @@
+// This module defines a super simple logger that works with the `log` crate.
+// We don't need anything fancy; just basic log levels and the ability to
+// print to stderr. We therefore avoid bringing in extra dependencies just
+// for this functionality.
+
+use log::{self, Log};
+
+/// The simplest possible logger that logs to stderr.
+///
+/// This logger does no filtering. Instead, it relies on the `log` crates
+/// filtering via its global max_level setting.
+#[derive(Debug)]
+pub struct Logger(());
+
+const LOGGER: &'static Logger = &Logger(());
+
+impl Logger {
+    /// Create a new logger that logs to stderr and initialize it as the
+    /// global logger. If there was a problem setting the logger, then an
+    /// error is returned.
+    pub fn init() -> Result<(), log::SetLoggerError> {
+        log::set_logger(LOGGER)
+    }
+}
+
+impl Log for Logger {
+    fn enabled(&self, _: &log::Metadata<'_>) -> bool {
+        // We set the log level via log::set_max_level, so we don't need to
+        // implement filtering here.
+        true
+    }
+
+    fn log(&self, record: &log::Record<'_>) {
+        match (record.file(), record.line()) {
+            (Some(file), Some(line)) => {
+                eprintln!(
+                    "{}|{}|{}:{}: {}",
+                    record.level(),
+                    record.target(),
+                    file,
+                    line,
+                    record.args()
+                );
+            }
+            (Some(file), None) => {
+                eprintln!(
+                    "{}|{}|{}: {}",
+                    record.level(),
+                    record.target(),
+                    file,
+                    record.args()
+                );
+            }
+            _ => {
+                eprintln!(
+                    "{}|{}: {}",
+                    record.level(),
+                    record.target(),
+                    record.args()
+                );
+            }
+        }
+    }
+
+    fn flush(&self) {
+        // We use eprintln! which is flushed on every call.
+    }
+}
diff --git a/regex-cli/main.rs b/regex-cli/main.rs
new file mode 100644
index 0000000000..3ebbac3c00
--- /dev/null
+++ b/regex-cli/main.rs
@@ -0,0 +1,31 @@
+use std::{env, io::Write};
+
+mod args;
+mod cmd;
+mod logger;
+mod util;
+
+fn main() -> anyhow::Result<()> {
+    let rustlog = env::var("RUST_LOG").unwrap_or_else(|_| String::new());
+    let level = match &*rustlog {
+        "" | "off" => log::LevelFilter::Off,
+        "error" => log::LevelFilter::Error,
+        "warn" => log::LevelFilter::Warn,
+        "info" => log::LevelFilter::Info,
+        "debug" => log::LevelFilter::Debug,
+        "trace" => log::LevelFilter::Trace,
+        unk => anyhow::bail!("unrecognized log level '{}'", unk),
+    };
+    logger::Logger::init()?;
+    log::set_max_level(level);
+
+    if let Err(err) = cmd::run(&mut lexopt::Parser::from_env()) {
+        if std::env::var("RUST_BACKTRACE").map_or(false, |v| v == "1") {
+            writeln!(&mut std::io::stderr(), "{:?}", err).unwrap();
+        } else {
+            writeln!(&mut std::io::stderr(), "{:#}", err).unwrap();
+        }
+        std::process::exit(1);
+    }
+    Ok(())
+}
diff --git a/regex-cli/util.rs b/regex-cli/util.rs
new file mode 100644
index 0000000000..3ff7d60e7d
--- /dev/null
+++ b/regex-cli/util.rs
@@ -0,0 +1,73 @@
+use std::{
+    io::{self, Write},
+    path::Path,
+    process::Command,
+};
+
+use {anyhow::Context, bstr::BString};
+
+/// Time an arbitrary operation.
+pub fn timeit<T>(run: impl FnOnce() -> T) -> (T, std::time::Duration) {
+    let start = std::time::Instant::now();
+    let t = run();
+    (t, start.elapsed())
+}
+
+/// Convenient time an operation that returns a result by packing the duration
+/// into the `Ok` variant.
+pub fn timeitr<T, E>(
+    run: impl FnOnce() -> Result<T, E>,
+) -> Result<(T, std::time::Duration), E> {
+    let (result, time) = timeit(run);
+    let t = result?;
+    Ok((t, time))
+}
+
+/// Run rustfmt on the given file.
+pub fn rustfmt<P: AsRef<Path>>(path: P) -> anyhow::Result<()> {
+    let path = path.as_ref();
+    let out = Command::new("rustfmt")
+        .arg(path)
+        .output()
+        .context("rustfmt command failed")?;
+    anyhow::ensure!(
+        out.status.success(),
+        "rustfmt {}: {}",
+        path.display(),
+        BString::from(out.stderr),
+    );
+    Ok(())
+}
+
+/// A somewhat silly little thing that prints an aligned table of key-value
+/// pairs. Keys can be any string and values can be anything that implements
+/// Debug.
+///
+/// This table is used to print little bits of useful information about stuff.
+#[derive(Debug)]
+pub struct Table {
+    pairs: Vec<(String, Box<dyn std::fmt::Debug>)>,
+}
+
+impl Table {
+    pub fn empty() -> Table {
+        Table { pairs: vec![] }
+    }
+
+    pub fn add<D: std::fmt::Debug + 'static>(
+        &mut self,
+        label: &str,
+        value: D,
+    ) {
+        self.pairs.push((label.to_string(), Box::new(value)));
+    }
+
+    pub fn print<W: io::Write>(&self, wtr: W) -> io::Result<()> {
+        let mut wtr = tabwriter::TabWriter::new(wtr)
+            .alignment(tabwriter::Alignment::Right);
+        for (label, value) in self.pairs.iter() {
+            writeln!(wtr, "{}:\t{:?}", label, value)?;
+        }
+        wtr.flush()
+    }
+}
diff --git a/regex-lite/Cargo.toml b/regex-lite/Cargo.toml
new file mode 100644
index 0000000000..1dc144b316
--- /dev/null
+++ b/regex-lite/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "regex-lite"
+version = "0.1.0"  #:version
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-lang/regex/tree/master/regex-lite"
+documentation = "https://docs.rs/regex-lite"
+description = """
+A lightweight regex engine that optimizes for binary size and compilation time.
+"""
+workspace = ".."
+edition = "2021"
+rust-version = "1.60.0"
+autotests = false
+
+# Features are documented in the "Crate features" section of the crate docs:
+# https://docs.rs/regex-syntax/*/#crate-features
+#
+# (Currently there are no supported features. 'std' is technically one, but it
+# is currently required.)
+[features]
+default = ["std", "string"]
+std = []
+string = []
+
+[dev-dependencies]
+anyhow = "1.0.69"
+regex-test = { path = "../regex-test", version = "0.1.0" }
+
+[[test]]
+path = "tests/lib.rs"
+name = "integration"
+
+[package.metadata.docs.rs]
+# We want to document all features.
+all-features = true
diff --git a/regex-lite/LICENSE-APACHE b/regex-lite/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/regex-lite/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/regex-lite/LICENSE-MIT b/regex-lite/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/regex-lite/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/regex-lite/README.md b/regex-lite/README.md
new file mode 100644
index 0000000000..34c749b216
--- /dev/null
+++ b/regex-lite/README.md
@@ -0,0 +1,129 @@
+regex-lite
+==========
+This crate provides a **lightweight** regex engine for searching strings. The
+regex syntax supported by this crate is nearly identical to what is found in
+the `regex` crate. Like the `regex` crate, all regex searches in this crate
+have worst case `O(m * n)` time complexity, where `m` is proportional to the
+size of the regex and `n` is proportional to the size of the string being
+searched.
+
+[![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
+[![Crates.io](https://img.shields.io/crates/v/regex-lite.svg)](https://crates.io/crates/regex-lite)
+
+
+### Documentation
+
+https://docs.rs/regex-lite
+
+
+### Usage
+
+To bring this crate into your repository, either add `regex-lite` to your
+`Cargo.toml`, or run `cargo add regex-lite`.
+
+Here's a simple example that matches a date in YYYY-MM-DD format and prints the
+year, month and day:
+
+```rust
+use regex_lite::Regex;
+
+fn main() {
+    let re = Regex::new(r"(?x)
+(?P<year>\d{4})  # the year
+-
+(?P<month>\d{2}) # the month
+-
+(?P<day>\d{2})   # the day
+").unwrap();
+    let caps = re.captures("2010-03-14").unwrap();
+
+    assert_eq!("2010", &caps["year"]);
+    assert_eq!("03", &caps["month"]);
+    assert_eq!("14", &caps["day"]);
+}
+```
+
+If you have lots of dates in text that you'd like to iterate over, then it's
+easy to adapt the above example with an iterator:
+
+```rust
+use regex::Regex;
+
+const TO_SEARCH: &'static str = "
+On 2010-03-14, foo happened. On 2014-10-14, bar happened.
+";
+
+fn main() {
+    let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
+
+    for caps in re.captures_iter(TO_SEARCH) {
+        // Note that all of the unwraps are actually OK for this regex
+        // because the only way for the regex to match is if all of the
+        // capture groups match. This is not true in general though!
+        println!("year: {}, month: {}, day: {}",
+                 caps.get(1).unwrap().as_str(),
+                 caps.get(2).unwrap().as_str(),
+                 caps.get(3).unwrap().as_str());
+    }
+}
+```
+
+This example outputs:
+
+```text
+year: 2010, month: 03, day: 14
+year: 2014, month: 10, day: 14
+```
+
+
+### Minimum Rust version policy
+
+This crate's minimum supported `rustc` version is `1.60.0`.
+
+The policy is that the minimum Rust version required to use this crate can be
+increased in semver compatible updates.
+
+
+### Motivation
+
+The primary purpose of this crate is to provide an alternative regex engine
+for folks that are unhappy with the binary size and compilation time of the
+primary `regex` crate. The `regex-lite` crate does the absolute minimum possible
+to act as a drop-in replacement to the `regex` crate's `Regex` type. It avoids
+a lot of complexity by choosing not to optimize searches and to opt out of
+functionality such as robust Unicode support. By keeping the code simpler
+and smaller, we get binary sizes and compile times that are substantially
+better than even the `regex` crate with all of its features disabled.
+
+To make the benefits a bit more concrete, here are the results of one
+experiment I did. For `regex`, I disabled all features except for `std`:
+
+* `regex 1.7.3`: 1.41s compile time, 373KB relative size increase
+* `regex 1.8.1`: 1.46s compile time, 410KB relative size increase
+* `regex 1.9.0`: 1.93s compile time, 565KB relative size increase
+* `regex-lite 0.1.0`: 0.73s compile time, 94KB relative size increase
+
+The main reason why `regex-lite` does so much better than `regex` when all of
+`regex`'s features are disabled is because of irreducible complexity. There are
+certain parts of the code in `regex` that can't be arbitrarily divided based
+on binary size and compile time goals. It's instead more sustainable to just
+maintain an entirely separate crate.
+
+Ideas for improving the binary size and compile times of this crate even more
+are most welcome.
+
+
+### License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   https://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   https://opensource.org/licenses/MIT)
+
+at your option.
+
+The data in `regex-syntax/src/unicode_tables/` is licensed under the Unicode
+License Agreement
+([LICENSE-UNICODE](https://www.unicode.org/copyright.html#License)).
diff --git a/regex-lite/src/error.rs b/regex-lite/src/error.rs
new file mode 100644
index 0000000000..c56c20c61a
--- /dev/null
+++ b/regex-lite/src/error.rs
@@ -0,0 +1,28 @@
+/// An error that occurred during parsing or compiling a regular expression.
+///
+/// A parse error occurs when the syntax of the regex pattern is not
+/// valid. Otherwise, a regex can still fail to build if it would
+/// result in a machine that exceeds the configured size limit, via
+/// [`RegexBuilder::size_limit`](crate::RegexBuilder::size_limit).
+///
+/// This error type provides no introspection capabilities. The only thing you
+/// can do with it is convert it to a string as a human readable error message.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    msg: &'static str,
+}
+
+impl Error {
+    pub(crate) fn new(msg: &'static str) -> Error {
+        Error { msg }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
diff --git a/regex-lite/src/hir/mod.rs b/regex-lite/src/hir/mod.rs
new file mode 100644
index 0000000000..f73a5420ab
--- /dev/null
+++ b/regex-lite/src/hir/mod.rs
@@ -0,0 +1,707 @@
+use alloc::{boxed::Box, string::String, vec, vec::Vec};
+
+use crate::{error::Error, utf8};
+
+mod parse;
+
+/// Escapes all regular expression meta characters in `pattern`.
+///
+/// The string returned may be safely used as a literal in a regular
+/// expression.
+pub fn escape(pattern: &str) -> String {
+    let mut buf = String::new();
+    buf.reserve(pattern.len());
+    for ch in pattern.chars() {
+        if is_meta_character(ch) {
+            buf.push('\\');
+        }
+        buf.push(ch);
+    }
+    buf
+}
+
+/// Returns true if the given character has significance in a regex.
+///
+/// Generally speaking, these are the only characters which _must_ be escaped
+/// in order to match their literal meaning. For example, to match a literal
+/// `|`, one could write `\|`. Sometimes escaping isn't always necessary. For
+/// example, `-` is treated as a meta character because of its significance
+/// for writing ranges inside of character classes, but the regex `-` will
+/// match a literal `-` because `-` has no special meaning outside of character
+/// classes.
+///
+/// In order to determine whether a character may be escaped at all, the
+/// [`is_escapeable_character`] routine should be used. The difference between
+/// `is_meta_character` and `is_escapeable_character` is that the latter will
+/// return true for some characters that are _not_ meta characters. For
+/// example, `%` and `\%` both match a literal `%` in all contexts. In other
+/// words, `is_escapeable_character` includes "superfluous" escapes.
+///
+/// Note that the set of characters for which this function returns `true` or
+/// `false` is fixed and won't change in a semver compatible release. (In this
+/// case, "semver compatible release" actually refers to the `regex` crate
+/// itself, since reducing or expanding the set of meta characters would be a
+/// breaking change for not just `regex-syntax` but also `regex` itself.)
+fn is_meta_character(c: char) -> bool {
+    match c {
+        '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{'
+        | '}' | '^' | '$' | '#' | '&' | '-' | '~' => true,
+        _ => false,
+    }
+}
+
+/// Returns true if the given character can be escaped in a regex.
+///
+/// This returns true in all cases that `is_meta_character` returns true, but
+/// also returns true in some cases where `is_meta_character` returns false.
+/// For example, `%` is not a meta character, but it is escapeable. That is,
+/// `%` and `\%` both match a literal `%` in all contexts.
+///
+/// The purpose of this routine is to provide knowledge about what characters
+/// may be escaped. Namely, most regex engines permit "superfluous" escapes
+/// where characters without any special significance may be escaped even
+/// though there is no actual _need_ to do so.
+///
+/// This will return false for some characters. For example, `e` is not
+/// escapeable. Therefore, `\e` will either result in a parse error (which is
+/// true today), or it could backwards compatibly evolve into a new construct
+/// with its own meaning. Indeed, that is the purpose of banning _some_
+/// superfluous escapes: it provides a way to evolve the syntax in a compatible
+/// manner.
+fn is_escapeable_character(c: char) -> bool {
+    // Certainly escapeable if it's a meta character.
+    if is_meta_character(c) {
+        return true;
+    }
+    // Any character that isn't ASCII is definitely not escapeable. There's
+    // no real need to allow things like \☃ right?
+    if !c.is_ascii() {
+        return false;
+    }
+    // Otherwise, we basically say that everything is escapeable unless it's a
+    // letter or digit. Things like \3 are either octal (when enabled) or an
+    // error, and we should keep it that way. Otherwise, letters are reserved
+    // for adding new syntax in a backwards compatible way.
+    match c {
+        '0'..='9' | 'A'..='Z' | 'a'..='z' => false,
+        // While not currently supported, we keep these as not escapeable to
+        // give us some flexibility with respect to supporting the \< and
+        // \> word boundary assertions in the future. By rejecting them as
+        // escapeable, \< and \> will result in a parse error. Thus, we can
+        // turn them into something else in the future without it being a
+        // backwards incompatible change.
+        '<' | '>' => false,
+        _ => true,
+    }
+}
+
+/// The configuration for a regex parser.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Config {
+    /// The maximum number of times we're allowed to recurse.
+    ///
+    /// Note that unlike the regex-syntax parser, we actually use recursion in
+    /// this parser for simplicity. My hope is that by setting a conservative
+    /// default call limit and providing a way to configure it, that we can
+    /// keep this simplification. But if we must, we can re-work the parser to
+    /// put the call stack on the heap like regex-syntax does.
+    pub(crate) nest_limit: u32,
+    /// Various flags that control how a pattern is interpreted.
+    pub(crate) flags: Flags,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config { nest_limit: 50, flags: Flags::default() }
+    }
+}
+
+/// Various flags that control the interpretation of the pattern.
+///
+/// These can be set via explicit configuration in code, or change dynamically
+/// during parsing via inline flags. For example, `foo(?i:bar)baz` will match
+/// `foo` and `baz` case sensitiviely and `bar` case insensitively (assuming a
+/// default configuration).
+#[derive(Clone, Copy, Debug, Default)]
+pub(crate) struct Flags {
+    /// Whether to match case insensitively.
+    ///
+    /// This is the `i` flag.
+    pub(crate) case_insensitive: bool,
+    /// Whether `^` and `$` should be treated as line anchors or not.
+    ///
+    /// This is the `m` flag.
+    pub(crate) multi_line: bool,
+    /// Whether `.` should match line terminators or not.
+    ///
+    /// This is the `s` flag.
+    pub(crate) dot_matches_new_line: bool,
+    /// Whether to swap the meaning of greedy and non-greedy operators.
+    ///
+    /// This is the `U` flag.
+    pub(crate) swap_greed: bool,
+    /// Whether to enable CRLF mode.
+    ///
+    /// This is the `R` flag.
+    pub(crate) crlf: bool,
+    /// Whether to ignore whitespace. i.e., verbose mode.
+    ///
+    /// This is the `x` flag.
+    pub(crate) ignore_whitespace: bool,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Hir {
+    kind: HirKind,
+    is_start_anchored: bool,
+    is_match_empty: bool,
+    static_explicit_captures_len: Option<usize>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum HirKind {
+    Empty,
+    Char(char),
+    Class(Class),
+    Look(Look),
+    Repetition(Repetition),
+    Capture(Capture),
+    Concat(Vec<Hir>),
+    Alternation(Vec<Hir>),
+}
+
+impl Hir {
+    /// Parses the given pattern string with the given configuration into a
+    /// structured representation. If the pattern is invalid, then an error
+    /// is returned.
+    pub(crate) fn parse(config: Config, pattern: &str) -> Result<Hir, Error> {
+        self::parse::Parser::new(config, pattern).parse()
+    }
+
+    /// Returns the underlying kind of this high-level intermediate
+    /// representation.
+    ///
+    /// Note that there is explicitly no way to build an `Hir` directly from
+    /// an `HirKind`. If you need to do that, then you must do case analysis
+    /// on the `HirKind` and call the appropriate smart constructor on `Hir`.
+    pub(crate) fn kind(&self) -> &HirKind {
+        &self.kind
+    }
+
+    /// Returns true if and only if this Hir expression can only match at the
+    /// beginning of a haystack.
+    pub(crate) fn is_start_anchored(&self) -> bool {
+        self.is_start_anchored
+    }
+
+    /// Returns true if and only if this Hir expression can match the empty
+    /// string.
+    pub(crate) fn is_match_empty(&self) -> bool {
+        self.is_match_empty
+    }
+
+    /// If the pattern always reports the same number of matching capture groups
+    /// for every match, then this returns the number of those groups. This
+    /// doesn't include the implicit group found in every pattern.
+    pub(crate) fn static_explicit_captures_len(&self) -> Option<usize> {
+        self.static_explicit_captures_len
+    }
+
+    fn fail() -> Hir {
+        let kind = HirKind::Class(Class { ranges: vec![] });
+        Hir {
+            kind,
+            is_start_anchored: false,
+            is_match_empty: false,
+            static_explicit_captures_len: Some(0),
+        }
+    }
+
+    fn empty() -> Hir {
+        let kind = HirKind::Empty;
+        Hir {
+            kind,
+            is_start_anchored: false,
+            is_match_empty: true,
+            static_explicit_captures_len: Some(0),
+        }
+    }
+
+    fn char(ch: char) -> Hir {
+        let kind = HirKind::Char(ch);
+        Hir {
+            kind,
+            is_start_anchored: false,
+            is_match_empty: false,
+            static_explicit_captures_len: Some(0),
+        }
+    }
+
+    fn class(class: Class) -> Hir {
+        let kind = HirKind::Class(class);
+        Hir {
+            kind,
+            is_start_anchored: false,
+            is_match_empty: false,
+            static_explicit_captures_len: Some(0),
+        }
+    }
+
+    fn look(look: Look) -> Hir {
+        let kind = HirKind::Look(look);
+        Hir {
+            kind,
+            is_start_anchored: matches!(look, Look::Start),
+            is_match_empty: true,
+            static_explicit_captures_len: Some(0),
+        }
+    }
+
+    fn repetition(rep: Repetition) -> Hir {
+        if rep.min == 0 && rep.max == Some(0) {
+            return Hir::empty();
+        } else if rep.min == 1 && rep.max == Some(1) {
+            return *rep.sub;
+        }
+        let is_start_anchored = rep.min > 0 && rep.sub.is_start_anchored;
+        let is_match_empty = rep.min == 0 || rep.sub.is_match_empty;
+        let mut static_explicit_captures_len =
+            rep.sub.static_explicit_captures_len;
+        // If the static captures len of the sub-expression is not known or
+        // is greater than zero, then it automatically propagates to the
+        // repetition, regardless of the repetition. Otherwise, it might
+        // change, but only when the repetition can match 0 times.
+        if rep.min == 0
+            && static_explicit_captures_len.map_or(false, |len| len > 0)
+        {
+            // If we require a match 0 times, then our captures len is
+            // guaranteed to be zero. Otherwise, if we *can* match the empty
+            // string, then it's impossible to know how many captures will be
+            // in the resulting match.
+            if rep.max == Some(0) {
+                static_explicit_captures_len = Some(0);
+            } else {
+                static_explicit_captures_len = None;
+            }
+        }
+        Hir {
+            kind: HirKind::Repetition(rep),
+            is_start_anchored,
+            is_match_empty,
+            static_explicit_captures_len,
+        }
+    }
+
+    fn capture(cap: Capture) -> Hir {
+        let is_start_anchored = cap.sub.is_start_anchored;
+        let is_match_empty = cap.sub.is_match_empty;
+        let static_explicit_captures_len = cap
+            .sub
+            .static_explicit_captures_len
+            .map(|len| len.saturating_add(1));
+        let kind = HirKind::Capture(cap);
+        Hir {
+            kind,
+            is_start_anchored,
+            is_match_empty,
+            static_explicit_captures_len,
+        }
+    }
+
+    fn concat(mut subs: Vec<Hir>) -> Hir {
+        if subs.is_empty() {
+            Hir::empty()
+        } else if subs.len() == 1 {
+            subs.pop().unwrap()
+        } else {
+            let is_start_anchored = subs[0].is_start_anchored;
+            let mut is_match_empty = true;
+            let mut static_explicit_captures_len = Some(0usize);
+            for sub in subs.iter() {
+                is_match_empty = is_match_empty && sub.is_match_empty;
+                static_explicit_captures_len = static_explicit_captures_len
+                    .and_then(|len1| {
+                        Some((len1, sub.static_explicit_captures_len?))
+                    })
+                    .and_then(|(len1, len2)| Some(len1.saturating_add(len2)));
+            }
+            Hir {
+                kind: HirKind::Concat(subs),
+                is_start_anchored,
+                is_match_empty,
+                static_explicit_captures_len,
+            }
+        }
+    }
+
+    fn alternation(mut subs: Vec<Hir>) -> Hir {
+        if subs.is_empty() {
+            Hir::fail()
+        } else if subs.len() == 1 {
+            subs.pop().unwrap()
+        } else {
+            let mut it = subs.iter().peekable();
+            let mut is_start_anchored =
+                it.peek().map_or(false, |sub| sub.is_start_anchored);
+            let mut is_match_empty =
+                it.peek().map_or(false, |sub| sub.is_match_empty);
+            let mut static_explicit_captures_len =
+                it.peek().and_then(|sub| sub.static_explicit_captures_len);
+            for sub in it {
+                is_start_anchored = is_start_anchored && sub.is_start_anchored;
+                is_match_empty = is_match_empty || sub.is_match_empty;
+                if static_explicit_captures_len
+                    != sub.static_explicit_captures_len
+                {
+                    static_explicit_captures_len = None;
+                }
+            }
+            Hir {
+                kind: HirKind::Alternation(subs),
+                is_start_anchored,
+                is_match_empty,
+                static_explicit_captures_len,
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Class {
+    pub(crate) ranges: Vec<ClassRange>,
+}
+
+impl Class {
+    /// Create a new class from the given ranges. The ranges may be provided
+    /// in any order or may even overlap. They will be automatically
+    /// canonicalized.
+    fn new<I: IntoIterator<Item = ClassRange>>(ranges: I) -> Class {
+        let mut class = Class { ranges: ranges.into_iter().collect() };
+        class.canonicalize();
+        class
+    }
+
+    /// Expand this class such that it matches the ASCII codepoints in this set
+    /// case insensitively.
+    fn ascii_case_fold(&mut self) {
+        let len = self.ranges.len();
+        for i in 0..len {
+            if let Some(folded) = self.ranges[i].ascii_case_fold() {
+                self.ranges.push(folded);
+            }
+        }
+        self.canonicalize();
+    }
+
+    /// Negate this set.
+    ///
+    /// For all `x` where `x` is any element, if `x` was in this set, then it
+    /// will not be in this set after negation.
+    fn negate(&mut self) {
+        const MIN: char = '\x00';
+        const MAX: char = char::MAX;
+
+        if self.ranges.is_empty() {
+            self.ranges.push(ClassRange { start: MIN, end: MAX });
+            return;
+        }
+
+        // There should be a way to do this in-place with constant memory,
+        // but I couldn't figure out a simple way to do it. So just append
+        // the negation to the end of this range, and then drain it before
+        // we're done.
+        let drain_end = self.ranges.len();
+
+        // If our class doesn't start the minimum possible char, then negation
+        // needs to include all codepoints up to the minimum in this set.
+        if self.ranges[0].start > MIN {
+            self.ranges.push(ClassRange {
+                start: MIN,
+                // OK because we know it's bigger than MIN.
+                end: prev_char(self.ranges[0].start).unwrap(),
+            });
+        }
+        for i in 1..drain_end {
+            // let lower = self.ranges[i - 1].upper().increment();
+            // let upper = self.ranges[i].lower().decrement();
+            // self.ranges.push(I::create(lower, upper));
+            self.ranges.push(ClassRange {
+                // OK because we know i-1 is never the last range and therefore
+                // there must be a range greater than it. It therefore follows
+                // that 'end' can never be char::MAX, and thus there must be
+                // a next char.
+                start: next_char(self.ranges[i - 1].end).unwrap(),
+                // Since 'i' is guaranteed to never be the first range, it
+                // follows that there is always a range before this and thus
+                // 'start' can never be '\x00'. Thus, there must be a previous
+                // char.
+                end: prev_char(self.ranges[i].start).unwrap(),
+            });
+        }
+        if self.ranges[drain_end - 1].end < MAX {
+            // let lower = self.ranges[drain_end - 1].upper().increment();
+            // self.ranges.push(I::create(lower, I::Bound::max_value()));
+            self.ranges.push(ClassRange {
+                // OK because we know 'end' is less than char::MAX, and thus
+                // there is a next char.
+                start: next_char(self.ranges[drain_end - 1].end).unwrap(),
+                end: MAX,
+            });
+        }
+        self.ranges.drain(..drain_end);
+        // We don't need to canonicalize because we processed the ranges above
+        // in canonical order and the new ranges we added based on those are
+        // also necessarily in canonical order.
+    }
+
+    /// Converts this set into a canonical ordering.
+    fn canonicalize(&mut self) {
+        if self.is_canonical() {
+            return;
+        }
+        self.ranges.sort();
+        assert!(!self.ranges.is_empty());
+
+        // Is there a way to do this in-place with constant memory? I couldn't
+        // figure out a way to do it. So just append the canonicalization to
+        // the end of this range, and then drain it before we're done.
+        let drain_end = self.ranges.len();
+        for oldi in 0..drain_end {
+            // If we've added at least one new range, then check if we can
+            // merge this range in the previously added range.
+            if self.ranges.len() > drain_end {
+                let (last, rest) = self.ranges.split_last_mut().unwrap();
+                if let Some(union) = last.union(&rest[oldi]) {
+                    *last = union;
+                    continue;
+                }
+            }
+            self.ranges.push(self.ranges[oldi]);
+        }
+        self.ranges.drain(..drain_end);
+    }
+
+    /// Returns true if and only if this class is in a canonical ordering.
+    fn is_canonical(&self) -> bool {
+        for pair in self.ranges.windows(2) {
+            if pair[0] >= pair[1] {
+                return false;
+            }
+            if pair[0].is_contiguous(&pair[1]) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub(crate) struct ClassRange {
+    pub(crate) start: char,
+    pub(crate) end: char,
+}
+
+impl ClassRange {
+    /// Apply simple case folding to this byte range. Only ASCII case mappings
+    /// (for A-Za-z) are applied.
+    ///
+    /// Additional ranges are appended to the given vector. Canonical ordering
+    /// is *not* maintained in the given vector.
+    fn ascii_case_fold(&self) -> Option<ClassRange> {
+        if !(ClassRange { start: 'a', end: 'z' }).is_intersection_empty(self) {
+            let start = core::cmp::max(self.start, 'a');
+            let end = core::cmp::min(self.end, 'z');
+            return Some(ClassRange {
+                start: char::try_from(u32::from(start) - 32).unwrap(),
+                end: char::try_from(u32::from(end) - 32).unwrap(),
+            });
+        }
+        if !(ClassRange { start: 'A', end: 'Z' }).is_intersection_empty(self) {
+            let start = core::cmp::max(self.start, 'A');
+            let end = core::cmp::min(self.end, 'Z');
+            return Some(ClassRange {
+                start: char::try_from(u32::from(start) + 32).unwrap(),
+                end: char::try_from(u32::from(end) + 32).unwrap(),
+            });
+        }
+        None
+    }
+
+    /// Union the given overlapping range into this range.
+    ///
+    /// If the two ranges aren't contiguous, then this returns `None`.
+    fn union(&self, other: &ClassRange) -> Option<ClassRange> {
+        if !self.is_contiguous(other) {
+            return None;
+        }
+        let start = core::cmp::min(self.start, other.start);
+        let end = core::cmp::max(self.end, other.end);
+        Some(ClassRange { start, end })
+    }
+
+    /// Returns true if and only if the two ranges are contiguous. Two ranges
+    /// are contiguous if and only if the ranges are either overlapping or
+    /// adjacent.
+    fn is_contiguous(&self, other: &ClassRange) -> bool {
+        let (s1, e1) = (u32::from(self.start), u32::from(self.end));
+        let (s2, e2) = (u32::from(other.start), u32::from(other.end));
+        core::cmp::max(s1, s2) <= core::cmp::min(e1, e2).saturating_add(1)
+    }
+
+    /// Returns true if and only if the intersection of this range and the
+    /// other range is empty.
+    fn is_intersection_empty(&self, other: &ClassRange) -> bool {
+        let (s1, e1) = (self.start, self.end);
+        let (s2, e2) = (other.start, other.end);
+        core::cmp::max(s1, s2) > core::cmp::min(e1, e2)
+    }
+}
+
+/// The high-level intermediate representation for a look-around assertion.
+///
+/// An assertion match is always zero-length. Also called an "empty match."
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Look {
+    /// Match the beginning of text. Specifically, this matches at the starting
+    /// position of the input.
+    Start = 1 << 0,
+    /// Match the end of text. Specifically, this matches at the ending
+    /// position of the input.
+    End = 1 << 1,
+    /// Match the beginning of a line or the beginning of text. Specifically,
+    /// this matches at the starting position of the input, or at the position
+    /// immediately following a `\n` character.
+    StartLF = 1 << 2,
+    /// Match the end of a line or the end of text. Specifically, this matches
+    /// at the end position of the input, or at the position immediately
+    /// preceding a `\n` character.
+    EndLF = 1 << 3,
+    /// Match the beginning of a line or the beginning of text. Specifically,
+    /// this matches at the starting position of the input, or at the position
+    /// immediately following either a `\r` or `\n` character, but never after
+    /// a `\r` when a `\n` follows.
+    StartCRLF = 1 << 4,
+    /// Match the end of a line or the end of text. Specifically, this matches
+    /// at the end position of the input, or at the position immediately
+    /// preceding a `\r` or `\n` character, but never before a `\n` when a `\r`
+    /// precedes it.
+    EndCRLF = 1 << 5,
+    /// Match an ASCII-only word boundary. That is, this matches a position
+    /// where the left adjacent character and right adjacent character
+    /// correspond to a word and non-word or a non-word and word character.
+    Word = 1 << 6,
+    /// Match an ASCII-only negation of a word boundary.
+    WordNegate = 1 << 7,
+}
+
+impl Look {
+    /// Returns true if the given position in the given haystack matches this
+    /// look-around assertion.
+    pub(crate) fn is_match(&self, haystack: &[u8], at: usize) -> bool {
+        use self::Look::*;
+
+        match *self {
+            Start => at == 0,
+            End => at == haystack.len(),
+            StartLF => at == 0 || haystack[at - 1] == b'\n',
+            EndLF => at == haystack.len() || haystack[at] == b'\n',
+            StartCRLF => {
+                at == 0
+                    || haystack[at - 1] == b'\n'
+                    || (haystack[at - 1] == b'\r'
+                        && (at >= haystack.len() || haystack[at] != b'\n'))
+            }
+            EndCRLF => {
+                at == haystack.len()
+                    || haystack[at] == b'\r'
+                    || (haystack[at] == b'\n'
+                        && (at == 0 || haystack[at - 1] != b'\r'))
+            }
+            Word => {
+                let word_before =
+                    at > 0 && utf8::is_word_byte(haystack[at - 1]);
+                let word_after =
+                    at < haystack.len() && utf8::is_word_byte(haystack[at]);
+                word_before != word_after
+            }
+            WordNegate => {
+                let word_before =
+                    at > 0 && utf8::is_word_byte(haystack[at - 1]);
+                let word_after =
+                    at < haystack.len() && utf8::is_word_byte(haystack[at]);
+                word_before == word_after
+            }
+        }
+    }
+}
+
+/// The high-level intermediate representation of a repetition operator.
+///
+/// A repetition operator permits the repetition of an arbitrary
+/// sub-expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Repetition {
+    /// The minimum range of the repetition.
+    ///
+    /// Note that special cases like `?`, `+` and `*` all get translated into
+    /// the ranges `{0,1}`, `{1,}` and `{0,}`, respectively.
+    ///
+    /// When `min` is zero, this expression can match the empty string
+    /// regardless of what its sub-expression is.
+    pub(crate) min: u32,
+    /// The maximum range of the repetition.
+    ///
+    /// Note that when `max` is `None`, `min` acts as a lower bound but where
+    /// there is no upper bound. For something like `x{5}` where the min and
+    /// max are equivalent, `min` will be set to `5` and `max` will be set to
+    /// `Some(5)`.
+    pub(crate) max: Option<u32>,
+    /// Whether this repetition operator is greedy or not. A greedy operator
+    /// will match as much as it can. A non-greedy operator will match as
+    /// little as it can.
+    ///
+    /// Typically, operators are greedy by default and are only non-greedy when
+    /// a `?` suffix is used, e.g., `(expr)*` is greedy while `(expr)*?` is
+    /// not. However, this can be inverted via the `U` "ungreedy" flag.
+    pub(crate) greedy: bool,
+    /// The expression being repeated.
+    pub(crate) sub: Box<Hir>,
+}
+
+/// The high-level intermediate representation for a capturing group.
+///
+/// A capturing group always has an index and a child expression. It may
+/// also have a name associated with it (e.g., `(?P<foo>\w)`), but it's not
+/// necessary.
+///
+/// Note that there is no explicit representation of a non-capturing group
+/// in a `Hir`. Instead, non-capturing grouping is handled automatically by
+/// the recursive structure of the `Hir` itself.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Capture {
+    /// The capture index of the capture.
+    pub(crate) index: u32,
+    /// The name of the capture, if it exists.
+    pub(crate) name: Option<Box<str>>,
+    /// The expression inside the capturing group, which may be empty.
+    pub(crate) sub: Box<Hir>,
+}
+
+fn next_char(ch: char) -> Option<char> {
+    // Skip over the surrogate range.
+    if ch == '\u{D7FF}' {
+        return Some('\u{E000}');
+    }
+    // OK because char::MAX < u32::MAX and we handle U+D7FF above.
+    char::from_u32(u32::from(ch).checked_add(1).unwrap())
+}
+
+fn prev_char(ch: char) -> Option<char> {
+    // Skip over the surrogate range.
+    if ch == '\u{E000}' {
+        return Some('\u{D7FF}');
+    }
+    // OK because subtracting 1 from any valid scalar value other than 0
+    // and U+E000 yields a valid scalar value.
+    Some(char::from_u32(u32::from(ch).checked_sub(1)?).unwrap())
+}
diff --git a/regex-lite/src/hir/parse.rs b/regex-lite/src/hir/parse.rs
new file mode 100644
index 0000000000..0b406d1d89
--- /dev/null
+++ b/regex-lite/src/hir/parse.rs
@@ -0,0 +1,2106 @@
+use core::cell::{Cell, RefCell};
+
+use alloc::{
+    boxed::Box,
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
+
+use crate::{
+    error::Error,
+    hir::{self, Config, Flags, Hir, HirKind},
+};
+
+// These are all of the errors that can occur while parsing a regex. Unlike
+// regex-syntax, our errors are not particularly great. They are just enough
+// to get a general sense of what went wrong. But in exchange, the error
+// reporting mechanism is *much* simpler than what's in regex-syntax.
+//
+// By convention, we use each of these messages in exactly one place. That
+// way, every branch that leads to an error has a unique message. This in turn
+// means that given a message, one can precisely identify which part of the
+// parser reported it.
+//
+// Finally, we give names to each message so that we can reference them in
+// tests.
+const ERR_TOO_MUCH_NESTING: &str = "pattern has too much nesting";
+const ERR_TOO_MANY_CAPTURES: &str = "too many capture groups";
+const ERR_DUPLICATE_CAPTURE_NAME: &str = "duplicate capture group name";
+const ERR_UNCLOSED_GROUP: &str = "found open group without closing ')'";
+const ERR_UNCLOSED_GROUP_QUESTION: &str =
+    "expected closing ')', but got end of pattern";
+const ERR_UNOPENED_GROUP: &str = "found closing ')' without matching '('";
+const ERR_LOOK_UNSUPPORTED: &str = "look-around is not supported";
+const ERR_EMPTY_FLAGS: &str = "empty flag directive '(?)' is not allowed";
+const ERR_MISSING_GROUP_NAME: &str =
+    "exepcted capture group name, but got end of pattern";
+const ERR_INVALID_GROUP_NAME: &str = "invalid group name";
+const ERR_UNCLOSED_GROUP_NAME: &str =
+    "expected end of capture group name, but got end of pattern";
+const ERR_EMPTY_GROUP_NAME: &str = "empty capture group names are not allowed";
+const ERR_FLAG_UNRECOGNIZED: &str = "unrecognized inline flag";
+const ERR_FLAG_REPEATED_NEGATION: &str =
+    "inline flag negation cannot be repeated";
+const ERR_FLAG_DUPLICATE: &str = "duplicate inline flag is not allowed";
+const ERR_FLAG_UNEXPECTED_EOF: &str =
+    "expected ':' or ')' to end inline flags, but got end of pattern";
+const ERR_FLAG_DANGLING_NEGATION: &str =
+    "inline flags cannot end with negation directive";
+const ERR_DECIMAL_NO_DIGITS: &str =
+    "expected decimal number, but found no digits";
+const ERR_DECIMAL_INVALID: &str = "got invalid decimal number";
+const ERR_HEX_BRACE_INVALID_DIGIT: &str =
+    "expected hexadecimal number in braces, but got non-hex digit";
+const ERR_HEX_BRACE_UNEXPECTED_EOF: &str =
+    "expected hexadecimal number, but saw end of pattern before closing brace";
+const ERR_HEX_BRACE_EMPTY: &str =
+    "expected hexadecimal number in braces, but got no digits";
+const ERR_HEX_BRACE_INVALID: &str = "got invalid hexadecimal number in braces";
+const ERR_HEX_FIXED_UNEXPECTED_EOF: &str =
+    "expected fixed length hexadecimal number, but saw end of pattern first";
+const ERR_HEX_FIXED_INVALID_DIGIT: &str =
+    "expected fixed length hexadecimal number, but got non-hex digit";
+const ERR_HEX_FIXED_INVALID: &str =
+    "got invalid fixed length hexadecimal number";
+const ERR_HEX_UNEXPECTED_EOF: &str =
+    "expected hexadecimal number, but saw end of pattern first";
+const ERR_ESCAPE_UNEXPECTED_EOF: &str =
+    "saw start of escape sequence, but saw end of pattern before it finished";
+const ERR_BACKREF_UNSUPPORTED: &str = "backreferences are not supported";
+const ERR_UNICODE_CLASS_UNSUPPORTED: &str =
+    "Unicode character classes are not supported";
+const ERR_ESCAPE_UNRECOGNIZED: &str = "unrecognized escape sequence";
+const ERR_POSIX_CLASS_UNRECOGNIZED: &str =
+    "unrecognized POSIX character class";
+const ERR_UNCOUNTED_REP_SUB_MISSING: &str =
+    "uncounted repetition operator must be applied to a sub-expression";
+const ERR_COUNTED_REP_SUB_MISSING: &str =
+    "counted repetition operator must be applied to a sub-expression";
+const ERR_COUNTED_REP_UNCLOSED: &str =
+    "found unclosed counted repetition operator";
+const ERR_COUNTED_REP_MIN_UNCLOSED: &str =
+    "found incomplete and unclosed counted repetition operator";
+const ERR_COUNTED_REP_COMMA_UNCLOSED: &str =
+    "found counted repetition operator with a comma that is unclosed";
+const ERR_COUNTED_REP_MIN_MAX_UNCLOSED: &str =
+    "found counted repetition with min and max that is unclosed";
+const ERR_COUNTED_REP_INVALID: &str =
+    "expected closing brace for counted repetition, but got something else";
+const ERR_COUNTED_REP_INVALID_RANGE: &str =
+    "found counted repetition with a min bigger than its max";
+const ERR_CLASS_UNCLOSED_AFTER_ITEM: &str =
+    "non-empty character class has no closing bracket";
+const ERR_CLASS_INVALID_RANGE_ITEM: &str =
+    "character class ranges must start and end with a single character";
+const ERR_CLASS_INVALID_ITEM: &str =
+    "invalid escape sequence in character class";
+const ERR_CLASS_UNCLOSED_AFTER_DASH: &str =
+    "non-empty character class has no closing bracket after dash";
+const ERR_CLASS_UNCLOSED_AFTER_NEGATION: &str =
+    "negated character class has no closing bracket";
+const ERR_CLASS_UNCLOSED_AFTER_CLOSING: &str =
+    "character class begins with literal ']' but has no closing bracket";
+const ERR_CLASS_INVALID_RANGE: &str = "invalid range in character class";
+const ERR_CLASS_UNCLOSED: &str = "found unclosed character class";
+const ERR_CLASS_NEST_UNSUPPORTED: &str =
+    "nested character classes are not supported";
+const ERR_CLASS_INTERSECTION_UNSUPPORTED: &str =
+    "character class intersection is not supported";
+const ERR_CLASS_DIFFERENCE_UNSUPPORTED: &str =
+    "character class difference is not supported";
+const ERR_CLASS_SYMDIFFERENCE_UNSUPPORTED: &str =
+    "character class symmetric difference is not supported";
+
+/// A regular expression parser.
+///
+/// This parses a string representation of a regular expression into an
+/// abstract syntax tree. The size of the tree is proportional to the length
+/// of the regular expression pattern.
+///
+/// A `Parser` can be configured in more detail via a [`ParserBuilder`].
+#[derive(Clone, Debug)]
+pub(super) struct Parser<'a> {
+    /// The configuration of the parser as given by the caller.
+    config: Config,
+    /// The pattern we're parsing as given by the caller.
+    pattern: &'a str,
+    /// The call depth of the parser. This is incremented for each
+    /// sub-expression parsed. Its peak value is the maximum nesting of the
+    /// pattern.
+    depth: Cell<u32>,
+    /// The current position of the parser.
+    pos: Cell<usize>,
+    /// The current codepoint of the parser. The codepoint corresponds to the
+    /// codepoint encoded in `pattern` beginning at `pos`.
+    ///
+    /// This is `None` if and only if `pos == pattern.len()`.
+    char: Cell<Option<char>>,
+    /// The current capture index.
+    capture_index: Cell<u32>,
+    /// The flags that are currently set.
+    flags: RefCell<Flags>,
+    /// A sorted sequence of capture names. This is used to detect duplicate
+    /// capture names and report an error if one is detected.
+    capture_names: RefCell<Vec<String>>,
+}
+
+/// The constructor and a variety of helper routines.
+impl<'a> Parser<'a> {
+    /// Build a parser from this configuration with the given pattern.
+    pub(super) fn new(config: Config, pattern: &'a str) -> Parser<'a> {
+        Parser {
+            config,
+            pattern,
+            depth: Cell::new(0),
+            pos: Cell::new(0),
+            char: Cell::new(pattern.chars().next()),
+            capture_index: Cell::new(0),
+            flags: RefCell::new(config.flags),
+            capture_names: RefCell::new(vec![]),
+        }
+    }
+
+    /// Returns the full pattern string that we're parsing.
+    fn pattern(&self) -> &str {
+        self.pattern
+    }
+
+    /// Return the current byte offset of the parser.
+    ///
+    /// The offset starts at `0` from the beginning of the regular expression
+    /// pattern string.
+    fn pos(&self) -> usize {
+        self.pos.get()
+    }
+
+    /// Increments the call depth of the parser.
+    ///
+    /// If the call depth would exceed the configured nest limit, then this
+    /// returns an error.
+    ///
+    /// This returns the old depth.
+    fn increment_depth(&self) -> Result<u32, Error> {
+        let old = self.depth.get();
+        if old > self.config.nest_limit {
+            return Err(Error::new(ERR_TOO_MUCH_NESTING));
+        }
+        // OK because our depth starts at 0, and we return an error if it
+        // ever reaches the limit. So the call depth can never exceed u32::MAX.
+        let new = old.checked_add(1).unwrap();
+        self.depth.set(new);
+        Ok(old)
+    }
+
+    /// Decrements the call depth of the parser.
+    ///
+    /// This panics if the current depth is 0.
+    fn decrement_depth(&self) {
+        let old = self.depth.get();
+        // If this fails then the caller has a bug in how they're incrementing
+        // and decrementing the depth of the parser's call stack.
+        let new = old.checked_sub(1).unwrap();
+        self.depth.set(new);
+    }
+
+    /// Return the codepoint at the current position of the parser.
+    ///
+    /// This panics if the parser is positioned at the end of the pattern.
+    fn char(&self) -> char {
+        self.char.get().expect("codepoint, but parser is done")
+    }
+
+    /// Returns true if the next call to `bump` would return false.
+    fn is_done(&self) -> bool {
+        self.pos() == self.pattern.len()
+    }
+
+    /// Returns the flags that are current set for this regex.
+    fn flags(&self) -> Flags {
+        *self.flags.borrow()
+    }
+
+    /// Bump the parser to the next Unicode scalar value.
+    ///
+    /// If the end of the input has been reached, then `false` is returned.
+    fn bump(&self) -> bool {
+        if self.is_done() {
+            return false;
+        }
+        self.pos.set(self.pos() + self.char().len_utf8());
+        self.char.set(self.pattern()[self.pos()..].chars().next());
+        self.char.get().is_some()
+    }
+
+    /// If the substring starting at the current position of the parser has
+    /// the given prefix, then bump the parser to the character immediately
+    /// following the prefix and return true. Otherwise, don't bump the parser
+    /// and return false.
+    fn bump_if(&self, prefix: &str) -> bool {
+        if self.pattern()[self.pos()..].starts_with(prefix) {
+            for _ in 0..prefix.chars().count() {
+                self.bump();
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Bump the parser, and if the `x` flag is enabled, bump through any
+    /// subsequent spaces. Return true if and only if the parser is not done.
+    fn bump_and_bump_space(&self) -> bool {
+        if !self.bump() {
+            return false;
+        }
+        self.bump_space();
+        !self.is_done()
+    }
+
+    /// If the `x` flag is enabled (i.e., whitespace insensitivity with
+    /// comments), then this will advance the parser through all whitespace
+    /// and comments to the next non-whitespace non-comment byte.
+    ///
+    /// If the `x` flag is disabled, then this is a no-op.
+    ///
+    /// This should be used selectively throughout the parser where
+    /// arbitrary whitespace is permitted when the `x` flag is enabled. For
+    /// example, `{   5  , 6}` is equivalent to `{5,6}`.
+    fn bump_space(&self) {
+        if !self.flags().ignore_whitespace {
+            return;
+        }
+        while !self.is_done() {
+            if self.char().is_whitespace() {
+                self.bump();
+            } else if self.char() == '#' {
+                self.bump();
+                while !self.is_done() {
+                    let c = self.char();
+                    self.bump();
+                    if c == '\n' {
+                        break;
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+    }
+
+    /// Peek at the next character in the input without advancing the parser.
+    ///
+    /// If the input has been exhausted, then this returns `None`.
+    fn peek(&self) -> Option<char> {
+        if self.is_done() {
+            return None;
+        }
+        self.pattern()[self.pos() + self.char().len_utf8()..].chars().next()
+    }
+
+    /// Peeks at the next character in the pattern from the current offset, and
+    /// will ignore spaces when the parser is in whitespace insensitive mode.
+    fn peek_space(&self) -> Option<char> {
+        if !self.flags().ignore_whitespace {
+            return self.peek();
+        }
+        if self.is_done() {
+            return None;
+        }
+        let mut start = self.pos() + self.char().len_utf8();
+        let mut in_comment = false;
+        for (i, ch) in self.pattern()[start..].char_indices() {
+            if ch.is_whitespace() {
+                continue;
+            } else if !in_comment && ch == '#' {
+                in_comment = true;
+            } else if in_comment && ch == '\n' {
+                in_comment = false;
+            } else {
+                start += i;
+                break;
+            }
+        }
+        self.pattern()[start..].chars().next()
+    }
+
+    /// Return the next capturing index. Each subsequent call increments the
+    /// internal index. Since the way capture indices are computed is a public
+    /// API guarantee, use of this routine depends on the parser being depth
+    /// first and left-to-right.
+    ///
+    /// If the capture limit is exceeded, then an error is returned.
+    fn next_capture_index(&self) -> Result<u32, Error> {
+        let current = self.capture_index.get();
+        let next = current
+            .checked_add(1)
+            .ok_or_else(|| Error::new(ERR_TOO_MANY_CAPTURES))?;
+        self.capture_index.set(next);
+        Ok(next)
+    }
+
+    /// Adds the given capture name to this parser. If this capture name has
+    /// already been used, then an error is returned.
+    fn add_capture_name(&self, name: &str) -> Result<(), Error> {
+        let mut names = self.capture_names.borrow_mut();
+        match names.binary_search_by(|n| name.cmp(n)) {
+            Ok(_) => Err(Error::new(ERR_DUPLICATE_CAPTURE_NAME)),
+            Err(i) => {
+                names.insert(i, name.to_string());
+                Ok(())
+            }
+        }
+    }
+
+    /// Returns true if and only if the parser is positioned at a look-around
+    /// prefix. The conditions under which this returns true must always
+    /// correspond to a regular expression that would otherwise be consider
+    /// invalid.
+    ///
+    /// This should only be called immediately after parsing the opening of
+    /// a group or a set of flags.
+    fn is_lookaround_prefix(&self) -> bool {
+        self.bump_if("?=")
+            || self.bump_if("?!")
+            || self.bump_if("?<=")
+            || self.bump_if("?<!")
+    }
+}
+
+/// The actual parser. We try to break out each kind of regex syntax into its
+/// own routine.
+impl<'a> Parser<'a> {
+    pub(super) fn parse(&self) -> Result<Hir, Error> {
+        let depth = self.increment_depth()?;
+        let mut alternates = vec![];
+        let mut concat = vec![];
+        loop {
+            self.bump_space();
+            if self.is_done() {
+                break;
+            }
+            match self.char() {
+                '(' => {
+                    // Save the old flags and reset them only when we close
+                    // the group.
+                    let oldflags = *self.flags.borrow();
+                    if let Some(sub) = self.parse_group()? {
+                        concat.push(sub);
+                        // We only reset them here because if 'parse_group'
+                        // returns None, then that means it handled a flag
+                        // directive, e.g., '(?ism)'. And the whole point is
+                        // that those flags remain active until either disabled
+                        // or the end of the pattern or current group.
+                        *self.flags.borrow_mut() = oldflags;
+                    }
+                    if self.char.get() != Some(')') {
+                        return Err(Error::new(ERR_UNCLOSED_GROUP));
+                    }
+                    self.bump();
+                }
+                ')' => {
+                    if depth == 0 {
+                        return Err(Error::new(ERR_UNOPENED_GROUP));
+                    }
+                    break;
+                }
+                '|' => {
+                    alternates.push(Hir::concat(core::mem::take(&mut concat)));
+                    self.bump();
+                }
+                '[' => concat.push(self.parse_class()?),
+                '?' | '*' | '+' => {
+                    concat = self.parse_uncounted_repetition(concat)?;
+                }
+                '{' => {
+                    concat = self.parse_counted_repetition(concat)?;
+                }
+                _ => concat.push(self.parse_primitive()?),
+            }
+        }
+        self.decrement_depth();
+        alternates.push(Hir::concat(concat));
+        // N.B. This strips off the "alternation" if there's only one branch.
+        Ok(Hir::alternation(alternates))
+    }
+
+    /// Parses a "primitive" pattern. A primitive is any expression that does
+    /// not contain any sub-expressions.
+    ///
+    /// This assumes the parser is pointing at the beginning of the primitive.
+    fn parse_primitive(&self) -> Result<Hir, Error> {
+        let ch = self.char();
+        self.bump();
+        match ch {
+            '\\' => self.parse_escape(),
+            '.' => Ok(self.hir_dot()),
+            '^' => Ok(self.hir_anchor_start()),
+            '$' => Ok(self.hir_anchor_end()),
+            ch => Ok(self.hir_char(ch)),
+        }
+    }
+
+    /// Parse an escape sequence. This always results in a "primitive" HIR,
+    /// that is, an HIR with no sub-expressions.
+    ///
+    /// This assumes the parser is positioned at the start of the sequence,
+    /// immediately *after* the `\`. It advances the parser to the first
+    /// position immediately following the escape sequence.
+    fn parse_escape(&self) -> Result<Hir, Error> {
+        if self.is_done() {
+            return Err(Error::new(ERR_ESCAPE_UNEXPECTED_EOF));
+        }
+        let ch = self.char();
+        // Put some of the more complicated routines into helpers.
+        match ch {
+            '0'..='9' => return Err(Error::new(ERR_BACKREF_UNSUPPORTED)),
+            'p' | 'P' => {
+                return Err(Error::new(ERR_UNICODE_CLASS_UNSUPPORTED))
+            }
+            'x' | 'u' | 'U' => return self.parse_hex(),
+            'd' | 's' | 'w' | 'D' | 'S' | 'W' => {
+                return Ok(self.parse_perl_class());
+            }
+            _ => {}
+        }
+
+        // Handle all of the one letter sequences inline.
+        self.bump();
+        if hir::is_meta_character(ch) || hir::is_escapeable_character(ch) {
+            return Ok(self.hir_char(ch));
+        }
+        let special = |ch| Ok(self.hir_char(ch));
+        match ch {
+            'a' => special('\x07'),
+            'f' => special('\x0C'),
+            't' => special('\t'),
+            'n' => special('\n'),
+            'r' => special('\r'),
+            'v' => special('\x0B'),
+            'A' => Ok(Hir::look(hir::Look::Start)),
+            'z' => Ok(Hir::look(hir::Look::End)),
+            'b' => Ok(Hir::look(hir::Look::Word)),
+            'B' => Ok(Hir::look(hir::Look::WordNegate)),
+            _ => Err(Error::new(ERR_ESCAPE_UNRECOGNIZED)),
+        }
+    }
+
+    /// Parse a hex representation of a Unicode codepoint. This handles both
+    /// hex notations, i.e., `\xFF` and `\x{FFFF}`. This expects the parser to
+    /// be positioned at the `x`, `u` or `U` prefix. The parser is advanced to
+    /// the first character immediately following the hexadecimal literal.
+    fn parse_hex(&self) -> Result<Hir, Error> {
+        let digit_len = match self.char() {
+            'x' => 2,
+            'u' => 4,
+            'U' => 8,
+            unk => unreachable!(
+                "invalid start of fixed length hexadecimal number {}",
+                unk
+            ),
+        };
+        if !self.bump_and_bump_space() {
+            return Err(Error::new(ERR_HEX_UNEXPECTED_EOF));
+        }
+        if self.char() == '{' {
+            self.parse_hex_brace()
+        } else {
+            self.parse_hex_digits(digit_len)
+        }
+    }
+
+    /// Parse an N-digit hex representation of a Unicode codepoint. This
+    /// expects the parser to be positioned at the first digit and will advance
+    /// the parser to the first character immediately following the escape
+    /// sequence.
+    ///
+    /// The number of digits given must be 2 (for `\xNN`), 4 (for `\uNNNN`)
+    /// or 8 (for `\UNNNNNNNN`).
+    fn parse_hex_digits(&self, digit_len: usize) -> Result<Hir, Error> {
+        let mut scratch = String::new();
+        for i in 0..digit_len {
+            if i > 0 && !self.bump_and_bump_space() {
+                return Err(Error::new(ERR_HEX_FIXED_UNEXPECTED_EOF));
+            }
+            if !is_hex(self.char()) {
+                return Err(Error::new(ERR_HEX_FIXED_INVALID_DIGIT));
+            }
+            scratch.push(self.char());
+        }
+        // The final bump just moves the parser past the literal, which may
+        // be EOF.
+        self.bump_and_bump_space();
+        match u32::from_str_radix(&scratch, 16).ok().and_then(char::from_u32) {
+            None => Err(Error::new(ERR_HEX_FIXED_INVALID)),
+            Some(ch) => Ok(self.hir_char(ch)),
+        }
+    }
+
+    /// Parse a hex representation of any Unicode scalar value. This expects
+    /// the parser to be positioned at the opening brace `{` and will advance
+    /// the parser to the first character following the closing brace `}`.
+    fn parse_hex_brace(&self) -> Result<Hir, Error> {
+        let mut scratch = String::new();
+        while self.bump_and_bump_space() && self.char() != '}' {
+            if !is_hex(self.char()) {
+                return Err(Error::new(ERR_HEX_BRACE_INVALID_DIGIT));
+            }
+            scratch.push(self.char());
+        }
+        if self.is_done() {
+            return Err(Error::new(ERR_HEX_BRACE_UNEXPECTED_EOF));
+        }
+        assert_eq!(self.char(), '}');
+        self.bump_and_bump_space();
+
+        if scratch.is_empty() {
+            return Err(Error::new(ERR_HEX_BRACE_EMPTY));
+        }
+        match u32::from_str_radix(&scratch, 16).ok().and_then(char::from_u32) {
+            None => Err(Error::new(ERR_HEX_BRACE_INVALID)),
+            Some(ch) => Ok(self.hir_char(ch)),
+        }
+    }
+
+    /// Parse a decimal number into a u32 while trimming leading and trailing
+    /// whitespace.
+    ///
+    /// This expects the parser to be positioned at the first position where
+    /// a decimal digit could occur. This will advance the parser to the byte
+    /// immediately following the last contiguous decimal digit.
+    ///
+    /// If no decimal digit could be found or if there was a problem parsing
+    /// the complete set of digits into a u32, then an error is returned.
+    fn parse_decimal(&self) -> Result<u32, Error> {
+        let mut scratch = String::new();
+        while !self.is_done() && self.char().is_whitespace() {
+            self.bump();
+        }
+        while !self.is_done() && '0' <= self.char() && self.char() <= '9' {
+            scratch.push(self.char());
+            self.bump_and_bump_space();
+        }
+        while !self.is_done() && self.char().is_whitespace() {
+            self.bump_and_bump_space();
+        }
+        let digits = scratch.as_str();
+        if digits.is_empty() {
+            return Err(Error::new(ERR_DECIMAL_NO_DIGITS));
+        }
+        match u32::from_str_radix(digits, 10).ok() {
+            Some(n) => Ok(n),
+            None => Err(Error::new(ERR_DECIMAL_INVALID)),
+        }
+    }
+
+    /// Parses an uncounted repetition operator. An uncounted repetition
+    /// operator includes `?`, `*` and `+`, but does not include the `{m,n}`
+    /// syntax. The current character should be one of `?`, `*` or `+`. Any
+    /// other character will result in a panic.
+    ///
+    /// This assumes that the parser is currently positioned at the repetition
+    /// operator and advances the parser to the first character after the
+    /// operator. (Note that the operator may include a single additional `?`,
+    /// which makes the operator ungreedy.)
+    ///
+    /// The caller should include the concatenation that is being built. The
+    /// concatenation returned includes the repetition operator applied to the
+    /// last expression in the given concatenation.
+    ///
+    /// If the concatenation is empty, then this returns an error.
+    fn parse_uncounted_repetition(
+        &self,
+        mut concat: Vec<Hir>,
+    ) -> Result<Vec<Hir>, Error> {
+        let sub = match concat.pop() {
+            Some(hir) => Box::new(hir),
+            None => {
+                return Err(Error::new(ERR_UNCOUNTED_REP_SUB_MISSING));
+            }
+        };
+        let (min, max) = match self.char() {
+            '?' => (0, Some(1)),
+            '*' => (0, None),
+            '+' => (1, None),
+            unk => unreachable!("unrecognized repetition operator '{}'", unk),
+        };
+        let mut greedy = true;
+        if self.bump() && self.char() == '?' {
+            greedy = false;
+            self.bump();
+        }
+        if self.flags().swap_greed {
+            greedy = !greedy;
+        }
+        concat.push(Hir::repetition(hir::Repetition {
+            min,
+            max,
+            greedy,
+            sub,
+        }));
+        Ok(concat)
+    }
+
+    /// Parses a counted repetition operation. A counted repetition operator
+    /// corresponds to the `{m,n}` syntax, and does not include the `?`, `*` or
+    /// `+` operators.
+    ///
+    /// This assumes that the parser is currently at the opening `{` and
+    /// advances the parser to the first character after the operator. (Note
+    /// that the operator may include a single additional `?`, which makes the
+    /// operator ungreedy.)
+    ///
+    /// The caller should include the concatenation that is being built. The
+    /// concatenation returned includes the repetition operator applied to the
+    /// last expression in the given concatenation.
+    ///
+    /// If the concatenation is empty, then this returns an error.
+    fn parse_counted_repetition(
+        &self,
+        mut concat: Vec<Hir>,
+    ) -> Result<Vec<Hir>, Error> {
+        assert_eq!(self.char(), '{', "expected opening brace");
+        let sub = match concat.pop() {
+            Some(hir) => Box::new(hir),
+            None => {
+                return Err(Error::new(ERR_COUNTED_REP_SUB_MISSING));
+            }
+        };
+        if !self.bump_and_bump_space() {
+            return Err(Error::new(ERR_COUNTED_REP_UNCLOSED));
+        }
+        let min = self.parse_decimal()?;
+        let mut max = Some(min);
+        if self.is_done() {
+            return Err(Error::new(ERR_COUNTED_REP_MIN_UNCLOSED));
+        }
+        if self.char() == ',' {
+            if !self.bump_and_bump_space() {
+                return Err(Error::new(ERR_COUNTED_REP_COMMA_UNCLOSED));
+            }
+            if self.char() != '}' {
+                max = Some(self.parse_decimal()?);
+            } else {
+                max = None;
+            }
+            if self.is_done() {
+                return Err(Error::new(ERR_COUNTED_REP_MIN_MAX_UNCLOSED));
+            }
+        }
+        if self.char() != '}' {
+            return Err(Error::new(ERR_COUNTED_REP_INVALID));
+        }
+
+        let mut greedy = true;
+        if self.bump_and_bump_space() && self.char() == '?' {
+            greedy = false;
+            self.bump();
+        }
+        if self.flags().swap_greed {
+            greedy = !greedy;
+        }
+
+        if max.map_or(false, |max| min > max) {
+            return Err(Error::new(ERR_COUNTED_REP_INVALID_RANGE));
+        }
+        concat.push(Hir::repetition(hir::Repetition {
+            min,
+            max,
+            greedy,
+            sub,
+        }));
+        Ok(concat)
+    }
+
+    /// Parses the part of a pattern that starts with a `(`. This is usually
+    /// a group sub-expression, but might just be a directive that enables
+    /// (or disables) certain flags.
+    ///
+    /// This assumes the parser is pointing at the opening `(`.
+    fn parse_group(&self) -> Result<Option<Hir>, Error> {
+        assert_eq!(self.char(), '(');
+        self.bump_and_bump_space();
+        if self.is_lookaround_prefix() {
+            return Err(Error::new(ERR_LOOK_UNSUPPORTED));
+        }
+        if self.bump_if("?P<") || self.bump_if("?<") {
+            let index = self.next_capture_index()?;
+            let name = Some(Box::from(self.parse_capture_name()?));
+            let sub = Box::new(self.parse()?);
+            let cap = hir::Capture { index, name, sub };
+            Ok(Some(Hir::capture(cap)))
+        } else if self.bump_if("?") {
+            if self.is_done() {
+                return Err(Error::new(ERR_UNCLOSED_GROUP_QUESTION));
+            }
+            let start = self.pos();
+            // The flags get reset in the top-level 'parse' routine.
+            *self.flags.borrow_mut() = self.parse_flags()?;
+            let consumed = self.pos() - start;
+            if self.char() == ')' {
+                // We don't allow empty flags, e.g., `(?)`.
+                if consumed == 0 {
+                    return Err(Error::new(ERR_EMPTY_FLAGS));
+                }
+                Ok(None)
+            } else {
+                assert_eq!(':', self.char());
+                self.bump();
+                self.parse().map(Some)
+            }
+        } else {
+            let index = self.next_capture_index()?;
+            let sub = Box::new(self.parse()?);
+            let cap = hir::Capture { index, name: None, sub };
+            Ok(Some(Hir::capture(cap)))
+        }
+    }
+
+    /// Parses a capture group name. Assumes that the parser is positioned at
+    /// the first character in the name following the opening `<` (and may
+    /// possibly be EOF). This advances the parser to the first character
+    /// following the closing `>`.
+    fn parse_capture_name(&self) -> Result<&str, Error> {
+        if self.is_done() {
+            return Err(Error::new(ERR_MISSING_GROUP_NAME));
+        }
+        let start = self.pos();
+        loop {
+            if self.char() == '>' {
+                break;
+            }
+            if !is_capture_char(self.char(), self.pos() == start) {
+                return Err(Error::new(ERR_INVALID_GROUP_NAME));
+            }
+            if !self.bump() {
+                break;
+            }
+        }
+        let end = self.pos();
+        if self.is_done() {
+            return Err(Error::new(ERR_UNCLOSED_GROUP_NAME));
+        }
+        assert_eq!(self.char(), '>');
+        self.bump();
+        let name = &self.pattern()[start..end];
+        if name.is_empty() {
+            return Err(Error::new(ERR_EMPTY_GROUP_NAME));
+        }
+        self.add_capture_name(name)?;
+        Ok(name)
+    }
+
+    /// Parse a sequence of flags starting at the current character.
+    ///
+    /// This advances the parser to the character immediately following the
+    /// flags, which is guaranteed to be either `:` or `)`.
+    ///
+    /// # Errors
+    ///
+    /// If any flags are duplicated, then an error is returned.
+    ///
+    /// If the negation operator is used more than once, then an error is
+    /// returned.
+    ///
+    /// If no flags could be found or if the negation operation is not followed
+    /// by any flags, then an error is returned.
+    fn parse_flags(&self) -> Result<Flags, Error> {
+        let mut flags = *self.flags.borrow();
+        let mut negate = false;
+        // Keeps track of whether the previous flag item was a '-'. We use this
+        // to detect whether there is a dangling '-', which is invalid.
+        let mut last_was_negation = false;
+        // A set to keep track of the flags we've seen. Since all flags are
+        // ASCII, we only need 128 bytes.
+        let mut seen = [false; 128];
+        while self.char() != ':' && self.char() != ')' {
+            if self.char() == '-' {
+                last_was_negation = true;
+                if negate {
+                    return Err(Error::new(ERR_FLAG_REPEATED_NEGATION));
+                }
+                negate = true;
+            } else {
+                last_was_negation = false;
+                self.parse_flag(&mut flags, negate)?;
+                // OK because every valid flag is ASCII, and we're only here if
+                // the flag is valid.
+                let flag_byte = u8::try_from(self.char()).unwrap();
+                if seen[usize::from(flag_byte)] {
+                    return Err(Error::new(ERR_FLAG_DUPLICATE));
+                }
+                seen[usize::from(flag_byte)] = true;
+            }
+            if !self.bump() {
+                return Err(Error::new(ERR_FLAG_UNEXPECTED_EOF));
+            }
+        }
+        if last_was_negation {
+            return Err(Error::new(ERR_FLAG_DANGLING_NEGATION));
+        }
+        Ok(flags)
+    }
+
+    /// Parse the current character as a flag. Do not advance the parser.
+    ///
+    /// This sets the appropriate boolean value in place on the set of flags
+    /// given. The boolean is inverted when `negate` is true.
+    ///
+    /// # Errors
+    ///
+    /// If the flag is not recognized, then an error is returned.
+    fn parse_flag(
+        &self,
+        flags: &mut Flags,
+        negate: bool,
+    ) -> Result<(), Error> {
+        let enabled = !negate;
+        match self.char() {
+            'i' => flags.case_insensitive = enabled,
+            'm' => flags.multi_line = enabled,
+            's' => flags.dot_matches_new_line = enabled,
+            'U' => flags.swap_greed = enabled,
+            'R' => flags.crlf = enabled,
+            'x' => flags.ignore_whitespace = enabled,
+            // We make a special exception for this flag where we let it
+            // through as a recognized flag, but treat it as a no-op. This in
+            // practice retains some compatibility with the regex crate. It is
+            // a little suspect to do this, but for example, '(?-u:\b).+' in
+            // the regex crate is equivalent to '\b.+' in regex-lite.
+            'u' => {}
+            _ => return Err(Error::new(ERR_FLAG_UNRECOGNIZED)),
+        }
+        Ok(())
+    }
+
+    /// Parse a standard character class consisting primarily of characters or
+    /// character ranges.
+    ///
+    /// This assumes the parser is positioned at the opening `[`. If parsing
+    /// is successful, then the parser is advanced to the position immediately
+    /// following the closing `]`.
+    fn parse_class(&self) -> Result<Hir, Error> {
+        assert_eq!(self.char(), '[');
+
+        let mut union = vec![];
+        if !self.bump_and_bump_space() {
+            return Err(Error::new(ERR_CLASS_UNCLOSED));
+        }
+        // Determine whether the class is negated or not.
+        let negate = if self.char() != '^' {
+            false
+        } else {
+            if !self.bump_and_bump_space() {
+                return Err(Error::new(ERR_CLASS_UNCLOSED_AFTER_NEGATION));
+            }
+            true
+        };
+        // Accept any number of `-` as literal `-`.
+        while self.char() == '-' {
+            union.push(hir::ClassRange { start: '-', end: '-' });
+            if !self.bump_and_bump_space() {
+                return Err(Error::new(ERR_CLASS_UNCLOSED_AFTER_DASH));
+            }
+        }
+        // If `]` is the *first* char in a set, then interpret it as a literal
+        // `]`. That is, an empty class is impossible to write.
+        if union.is_empty() && self.char() == ']' {
+            union.push(hir::ClassRange { start: ']', end: ']' });
+            if !self.bump_and_bump_space() {
+                return Err(Error::new(ERR_CLASS_UNCLOSED_AFTER_CLOSING));
+            }
+        }
+        loop {
+            self.bump_space();
+            if self.is_done() {
+                return Err(Error::new(ERR_CLASS_UNCLOSED));
+            }
+            match self.char() {
+                '[' => {
+                    // Attempt to treat this as the beginning of a POSIX class.
+                    // If POSIX class parsing fails, then the parser backs up
+                    // to `[`.
+                    if let Some(class) = self.maybe_parse_posix_class() {
+                        union.extend_from_slice(&class.ranges);
+                        continue;
+                    }
+                    // ... otherwise we don't support nested classes.
+                    return Err(Error::new(ERR_CLASS_NEST_UNSUPPORTED));
+                }
+                ']' => {
+                    self.bump();
+                    let mut class = hir::Class::new(union);
+                    // Note that we must apply case folding before negation!
+                    // Consider `(?i)[^x]`. If we applied negation first, then
+                    // the result would be the character class that matched any
+                    // Unicode scalar value.
+                    if self.flags().case_insensitive {
+                        class.ascii_case_fold();
+                    }
+                    if negate {
+                        class.negate();
+                    }
+                    return Ok(Hir::class(class));
+                }
+                '&' if self.peek() == Some('&') => {
+                    return Err(Error::new(
+                        ERR_CLASS_INTERSECTION_UNSUPPORTED,
+                    ));
+                }
+                '-' if self.peek() == Some('-') => {
+                    return Err(Error::new(ERR_CLASS_DIFFERENCE_UNSUPPORTED));
+                }
+                '~' if self.peek() == Some('~') => {
+                    return Err(Error::new(
+                        ERR_CLASS_SYMDIFFERENCE_UNSUPPORTED,
+                    ));
+                }
+                _ => self.parse_class_range(&mut union)?,
+            }
+        }
+    }
+
+    /// Parse a single primitive item in a character class set. The item to
+    /// be parsed can either be one of a simple literal character, a range
+    /// between two simple literal characters or a "primitive" character
+    /// class like `\w`.
+    ///
+    /// If an invalid escape is found, or if a character class is found where
+    /// a simple literal is expected (e.g., in a range), then an error is
+    /// returned.
+    ///
+    /// Otherwise, the range (or ranges) are appended to the given union of
+    /// ranges.
+    fn parse_class_range(
+        &self,
+        union: &mut Vec<hir::ClassRange>,
+    ) -> Result<(), Error> {
+        let prim1 = self.parse_class_item()?;
+        self.bump_space();
+        if self.is_done() {
+            return Err(Error::new(ERR_CLASS_UNCLOSED_AFTER_ITEM));
+        }
+        // If the next char isn't a `-`, then we don't have a range.
+        // There are two exceptions. If the char after a `-` is a `]`, then
+        // `-` is interpreted as a literal `-`. Alternatively, if the char
+        // after a `-` is a `-`, then `--` corresponds to a "difference"
+        // operation. (Which we don't support in regex-lite, but error about
+        // specifically in an effort to be loud about differences between the
+        // main regex crate where possible.)
+        if self.char() != '-'
+            || self.peek_space() == Some(']')
+            || self.peek_space() == Some('-')
+        {
+            union.extend_from_slice(&into_class_item_ranges(prim1)?);
+            return Ok(());
+        }
+        // OK, now we're parsing a range, so bump past the `-` and parse the
+        // second half of the range.
+        if !self.bump_and_bump_space() {
+            return Err(Error::new(ERR_CLASS_UNCLOSED_AFTER_DASH));
+        }
+        let prim2 = self.parse_class_item()?;
+        let range = hir::ClassRange {
+            start: into_class_item_range(prim1)?,
+            end: into_class_item_range(prim2)?,
+        };
+        if range.start > range.end {
+            return Err(Error::new(ERR_CLASS_INVALID_RANGE));
+        }
+        union.push(range);
+        Ok(())
+    }
+
+    /// Parse a single item in a character class as a primitive, where the
+    /// primitive either consists of a verbatim literal or a single escape
+    /// sequence.
+    ///
+    /// This assumes the parser is positioned at the beginning of a primitive,
+    /// and advances the parser to the first position after the primitive if
+    /// successful.
+    ///
+    /// Note that it is the caller's responsibility to report an error if an
+    /// illegal primitive was parsed.
+    fn parse_class_item(&self) -> Result<Hir, Error> {
+        let ch = self.char();
+        self.bump();
+        if ch == '\\' {
+            self.parse_escape()
+        } else {
+            Ok(Hir::char(ch))
+        }
+    }
+
+    /// Attempt to parse a POSIX character class, e.g., `[:alnum:]`.
+    ///
+    /// This assumes the parser is positioned at the opening `[`.
+    ///
+    /// If no valid POSIX character class could be found, then this does not
+    /// advance the parser and `None` is returned. Otherwise, the parser is
+    /// advanced to the first byte following the closing `]` and the
+    /// corresponding POSIX class is returned.
+    fn maybe_parse_posix_class(&self) -> Option<hir::Class> {
+        // POSIX character classes are interesting from a parsing perspective
+        // because parsing cannot fail with any interesting error. For example,
+        // in order to use an POSIX character class, it must be enclosed in
+        // double brackets, e.g., `[[:alnum:]]`. Alternatively, you might think
+        // of it as "POSIX character classes have the syntax `[:NAME:]` which
+        // can only appear within character brackets." This means that things
+        // like `[[:lower:]A]` are legal constructs.
+        //
+        // However, if one types an incorrect POSIX character class, e.g.,
+        // `[[:loower:]]`, then we treat that as if it were normal nested
+        // character class containing the characters `:elorw`. (Which isn't
+        // supported and results in an error in regex-lite.) One might argue
+        // that we should return an error instead since the repeated colons
+        // give away the intent to write an POSIX class. But what if the user
+        // typed `[[:lower]]` instead? How can we tell that was intended to be
+        // a POSXI class and not just a normal nested class?
+        //
+        // Reasonable people can probably disagree over this, but for better
+        // or worse, we implement semantics that never fails at the expense of
+        // better failure modes.
+        assert_eq!(self.char(), '[');
+
+        // If parsing fails, then we back up the parser to this starting point.
+        let start_pos = self.pos();
+        let start_char = self.char.get();
+        let reset = || {
+            self.pos.set(start_pos);
+            self.char.set(start_char);
+        };
+
+        let mut negated = false;
+        if !self.bump() || self.char() != ':' {
+            reset();
+            return None;
+        }
+        if !self.bump() {
+            reset();
+            return None;
+        }
+        if self.char() == '^' {
+            negated = true;
+            if !self.bump() {
+                reset();
+                return None;
+            }
+        }
+        let name_start = self.pos();
+        while self.char() != ':' && self.bump() {}
+        if self.is_done() {
+            reset();
+            return None;
+        }
+        let name = &self.pattern()[name_start..self.pos()];
+        if !self.bump_if(":]") {
+            reset();
+            return None;
+        }
+        if let Ok(ranges) = posix_class(name) {
+            let mut class = hir::Class::new(ranges);
+            if negated {
+                class.negate();
+            }
+            return Some(class);
+        }
+        reset();
+        None
+    }
+
+    /// Parse a Perl character class, e.g., `\d` or `\W`. This assumes the
+    /// parser is currently at a valid character class name and will be
+    /// advanced to the character immediately following the class.
+    fn parse_perl_class(&self) -> Hir {
+        let ch = self.char();
+        self.bump();
+        let mut class = hir::Class::new(match ch {
+            'd' | 'D' => posix_class("digit").unwrap(),
+            's' | 'S' => posix_class("space").unwrap(),
+            'w' | 'W' => posix_class("word").unwrap(),
+            unk => unreachable!("invalid Perl class \\{}", unk),
+        });
+        if ch.is_ascii_uppercase() {
+            class.negate();
+        }
+        Hir::class(class)
+    }
+
+    fn hir_dot(&self) -> Hir {
+        if self.flags().dot_matches_new_line {
+            Hir::class(hir::Class::new([hir::ClassRange {
+                start: '\x00',
+                end: '\u{10FFFF}',
+            }]))
+        } else if self.flags().crlf {
+            Hir::class(hir::Class::new([
+                hir::ClassRange { start: '\x00', end: '\x09' },
+                hir::ClassRange { start: '\x0B', end: '\x0C' },
+                hir::ClassRange { start: '\x0E', end: '\u{10FFFF}' },
+            ]))
+        } else {
+            Hir::class(hir::Class::new([
+                hir::ClassRange { start: '\x00', end: '\x09' },
+                hir::ClassRange { start: '\x0B', end: '\u{10FFFF}' },
+            ]))
+        }
+    }
+
+    fn hir_anchor_start(&self) -> Hir {
+        let look = if self.flags().multi_line {
+            if self.flags().crlf {
+                hir::Look::StartCRLF
+            } else {
+                hir::Look::StartLF
+            }
+        } else {
+            hir::Look::Start
+        };
+        Hir::look(look)
+    }
+
+    fn hir_anchor_end(&self) -> Hir {
+        let look = if self.flags().multi_line {
+            if self.flags().crlf {
+                hir::Look::EndCRLF
+            } else {
+                hir::Look::EndLF
+            }
+        } else {
+            hir::Look::End
+        };
+        Hir::look(look)
+    }
+
+    fn hir_char(&self, ch: char) -> Hir {
+        if self.flags().case_insensitive {
+            let this = hir::ClassRange { start: ch, end: ch };
+            if let Some(folded) = this.ascii_case_fold() {
+                return Hir::class(hir::Class::new([this, folded]));
+            }
+        }
+        Hir::char(ch)
+    }
+}
+
+/// Converts the given Hir to a literal char if the Hir is just a single
+/// character. Otherwise this returns an error.
+///
+/// This is useful in contexts where you can only accept a single character,
+/// but where it is convenient to parse something more general. For example,
+/// parsing a single part of a character class range. It's useful to reuse
+/// the literal parsing code, but that code can itself return entire classes
+/// which can't be used as the start/end of a class range.
+fn into_class_item_range(hir: Hir) -> Result<char, Error> {
+    match hir.kind {
+        HirKind::Char(ch) => Ok(ch),
+        _ => Err(Error::new(ERR_CLASS_INVALID_RANGE_ITEM)),
+    }
+}
+
+fn into_class_item_ranges(hir: Hir) -> Result<Vec<hir::ClassRange>, Error> {
+    match hir.kind {
+        HirKind::Char(ch) => Ok(vec![hir::ClassRange { start: ch, end: ch }]),
+        HirKind::Class(hir::Class { ranges }) => Ok(ranges),
+        _ => Err(Error::new(ERR_CLASS_INVALID_ITEM)),
+    }
+}
+
+/// Returns an iterator of character class ranges for the given named POSIX
+/// character class. If no such character class exists for the name given, then
+/// an error is returned.
+fn posix_class(
+    kind: &str,
+) -> Result<impl Iterator<Item = hir::ClassRange>, Error> {
+    let slice: &'static [(u8, u8)] = match kind {
+        "alnum" => &[(b'0', b'9'), (b'A', b'Z'), (b'a', b'z')],
+        "alpha" => &[(b'A', b'Z'), (b'a', b'z')],
+        "ascii" => &[(b'\x00', b'\x7F')],
+        "blank" => &[(b'\t', b'\t'), (b' ', b' ')],
+        "cntrl" => &[(b'\x00', b'\x1F'), (b'\x7F', b'\x7F')],
+        "digit" => &[(b'0', b'9')],
+        "graph" => &[(b'!', b'~')],
+        "lower" => &[(b'a', b'z')],
+        "print" => &[(b' ', b'~')],
+        "punct" => &[(b'!', b'/'), (b':', b'@'), (b'[', b'`'), (b'{', b'~')],
+        "space" => &[
+            (b'\t', b'\t'),
+            (b'\n', b'\n'),
+            (b'\x0B', b'\x0B'),
+            (b'\x0C', b'\x0C'),
+            (b'\r', b'\r'),
+            (b' ', b' '),
+        ],
+        "upper" => &[(b'A', b'Z')],
+        "word" => &[(b'0', b'9'), (b'A', b'Z'), (b'_', b'_'), (b'a', b'z')],
+        "xdigit" => &[(b'0', b'9'), (b'A', b'F'), (b'a', b'f')],
+        _ => return Err(Error::new(ERR_POSIX_CLASS_UNRECOGNIZED)),
+    };
+    Ok(slice.iter().map(|&(start, end)| hir::ClassRange {
+        start: char::from(start),
+        end: char::from(end),
+    }))
+}
+
+/// Returns true if the given character is a hexadecimal digit.
+fn is_hex(c: char) -> bool {
+    ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
+}
+
+/// Returns true if the given character is a valid in a capture group name.
+///
+/// If `first` is true, then `c` is treated as the first character in the
+/// group name (which must be alphabetic or underscore).
+fn is_capture_char(c: char, first: bool) -> bool {
+    if first {
+        c == '_' || c.is_alphabetic()
+    } else {
+        c == '_' || c == '.' || c == '[' || c == ']' || c.is_alphanumeric()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn p(pattern: &str) -> Hir {
+        Parser::new(Config::default(), pattern).parse().unwrap()
+    }
+
+    fn perr(pattern: &str) -> String {
+        Parser::new(Config::default(), pattern)
+            .parse()
+            .unwrap_err()
+            .to_string()
+    }
+
+    fn class<I: IntoIterator<Item = (char, char)>>(it: I) -> Hir {
+        Hir::class(hir::Class::new(
+            it.into_iter().map(|(start, end)| hir::ClassRange { start, end }),
+        ))
+    }
+
+    fn singles<I: IntoIterator<Item = char>>(it: I) -> Hir {
+        Hir::class(hir::Class::new(
+            it.into_iter().map(|ch| hir::ClassRange { start: ch, end: ch }),
+        ))
+    }
+
+    fn posix(name: &str) -> Hir {
+        Hir::class(hir::Class::new(posix_class(name).unwrap()))
+    }
+
+    fn cap(index: u32, sub: Hir) -> Hir {
+        Hir::capture(hir::Capture { index, name: None, sub: Box::new(sub) })
+    }
+
+    fn named_cap(index: u32, name: &str, sub: Hir) -> Hir {
+        Hir::capture(hir::Capture {
+            index,
+            name: Some(Box::from(name)),
+            sub: Box::new(sub),
+        })
+    }
+
+    #[test]
+    fn ok_literal() {
+        assert_eq!(p("a"), Hir::char('a'));
+        assert_eq!(p("ab"), Hir::concat(vec![Hir::char('a'), Hir::char('b')]));
+        assert_eq!(p("💩"), Hir::char('💩'));
+    }
+
+    #[test]
+    fn ok_meta_escapes() {
+        assert_eq!(p(r"\*"), Hir::char('*'));
+        assert_eq!(p(r"\+"), Hir::char('+'));
+        assert_eq!(p(r"\?"), Hir::char('?'));
+        assert_eq!(p(r"\|"), Hir::char('|'));
+        assert_eq!(p(r"\("), Hir::char('('));
+        assert_eq!(p(r"\)"), Hir::char(')'));
+        assert_eq!(p(r"\^"), Hir::char('^'));
+        assert_eq!(p(r"\$"), Hir::char('$'));
+        assert_eq!(p(r"\["), Hir::char('['));
+        assert_eq!(p(r"\]"), Hir::char(']'));
+    }
+
+    #[test]
+    fn ok_special_escapes() {
+        assert_eq!(p(r"\a"), Hir::char('\x07'));
+        assert_eq!(p(r"\f"), Hir::char('\x0C'));
+        assert_eq!(p(r"\t"), Hir::char('\t'));
+        assert_eq!(p(r"\n"), Hir::char('\n'));
+        assert_eq!(p(r"\r"), Hir::char('\r'));
+        assert_eq!(p(r"\v"), Hir::char('\x0B'));
+        assert_eq!(p(r"\A"), Hir::look(hir::Look::Start));
+        assert_eq!(p(r"\z"), Hir::look(hir::Look::End));
+        assert_eq!(p(r"\b"), Hir::look(hir::Look::Word));
+        assert_eq!(p(r"\B"), Hir::look(hir::Look::WordNegate));
+    }
+
+    #[test]
+    fn ok_hex() {
+        // fixed length
+        assert_eq!(p(r"\x41"), Hir::char('A'));
+        assert_eq!(p(r"\u2603"), Hir::char('☃'));
+        assert_eq!(p(r"\U0001F4A9"), Hir::char('💩'));
+        // braces
+        assert_eq!(p(r"\x{1F4A9}"), Hir::char('💩'));
+        assert_eq!(p(r"\u{1F4A9}"), Hir::char('💩'));
+        assert_eq!(p(r"\U{1F4A9}"), Hir::char('💩'));
+    }
+
+    #[test]
+    fn ok_perl() {
+        assert_eq!(p(r"\d"), posix("digit"));
+        assert_eq!(p(r"\s"), posix("space"));
+        assert_eq!(p(r"\w"), posix("word"));
+
+        let negated = |name| {
+            let mut class = hir::Class::new(posix_class(name).unwrap());
+            class.negate();
+            Hir::class(class)
+        };
+        assert_eq!(p(r"\D"), negated("digit"));
+        assert_eq!(p(r"\S"), negated("space"));
+        assert_eq!(p(r"\W"), negated("word"));
+    }
+
+    #[test]
+    fn ok_flags_and_primitives() {
+        assert_eq!(p(r"a"), Hir::char('a'));
+        assert_eq!(p(r"(?i:a)"), singles(['A', 'a']));
+
+        assert_eq!(p(r"^"), Hir::look(hir::Look::Start));
+        assert_eq!(p(r"(?m:^)"), Hir::look(hir::Look::StartLF));
+        assert_eq!(p(r"(?mR:^)"), Hir::look(hir::Look::StartCRLF));
+
+        assert_eq!(p(r"$"), Hir::look(hir::Look::End));
+        assert_eq!(p(r"(?m:$)"), Hir::look(hir::Look::EndLF));
+        assert_eq!(p(r"(?mR:$)"), Hir::look(hir::Look::EndCRLF));
+
+        assert_eq!(p(r"."), class([('\x00', '\x09'), ('\x0B', '\u{10FFFF}')]));
+        assert_eq!(
+            p(r"(?R:.)"),
+            class([
+                ('\x00', '\x09'),
+                ('\x0B', '\x0C'),
+                ('\x0E', '\u{10FFFF}'),
+            ])
+        );
+        assert_eq!(p(r"(?s:.)"), class([('\x00', '\u{10FFFF}')]));
+        assert_eq!(p(r"(?sR:.)"), class([('\x00', '\u{10FFFF}')]));
+    }
+
+    #[test]
+    fn ok_alternate() {
+        assert_eq!(
+            p(r"a|b"),
+            Hir::alternation(vec![Hir::char('a'), Hir::char('b')])
+        );
+        assert_eq!(
+            p(r"(?:a|b)"),
+            Hir::alternation(vec![Hir::char('a'), Hir::char('b')])
+        );
+
+        assert_eq!(
+            p(r"(a|b)"),
+            cap(1, Hir::alternation(vec![Hir::char('a'), Hir::char('b')]))
+        );
+        assert_eq!(
+            p(r"(?<foo>a|b)"),
+            named_cap(
+                1,
+                "foo",
+                Hir::alternation(vec![Hir::char('a'), Hir::char('b')])
+            )
+        );
+
+        assert_eq!(
+            p(r"a|b|c"),
+            Hir::alternation(vec![
+                Hir::char('a'),
+                Hir::char('b'),
+                Hir::char('c')
+            ])
+        );
+
+        assert_eq!(
+            p(r"ax|by|cz"),
+            Hir::alternation(vec![
+                Hir::concat(vec![Hir::char('a'), Hir::char('x')]),
+                Hir::concat(vec![Hir::char('b'), Hir::char('y')]),
+                Hir::concat(vec![Hir::char('c'), Hir::char('z')]),
+            ])
+        );
+        assert_eq!(
+            p(r"(ax|(by|(cz)))"),
+            cap(
+                1,
+                Hir::alternation(vec![
+                    Hir::concat(vec![Hir::char('a'), Hir::char('x')]),
+                    cap(
+                        2,
+                        Hir::alternation(vec![
+                            Hir::concat(vec![Hir::char('b'), Hir::char('y')]),
+                            cap(
+                                3,
+                                Hir::concat(vec![
+                                    Hir::char('c'),
+                                    Hir::char('z')
+                                ])
+                            ),
+                        ])
+                    ),
+                ])
+            )
+        );
+
+        assert_eq!(
+            p(r"|"),
+            Hir::alternation(vec![Hir::empty(), Hir::empty()])
+        );
+        assert_eq!(
+            p(r"||"),
+            Hir::alternation(vec![Hir::empty(), Hir::empty(), Hir::empty()])
+        );
+
+        assert_eq!(
+            p(r"a|"),
+            Hir::alternation(vec![Hir::char('a'), Hir::empty()])
+        );
+        assert_eq!(
+            p(r"|a"),
+            Hir::alternation(vec![Hir::empty(), Hir::char('a')])
+        );
+
+        assert_eq!(
+            p(r"(|)"),
+            cap(1, Hir::alternation(vec![Hir::empty(), Hir::empty()]))
+        );
+        assert_eq!(
+            p(r"(a|)"),
+            cap(1, Hir::alternation(vec![Hir::char('a'), Hir::empty()]))
+        );
+        assert_eq!(
+            p(r"(|a)"),
+            cap(1, Hir::alternation(vec![Hir::empty(), Hir::char('a')]))
+        );
+    }
+
+    #[test]
+    fn ok_flag_group() {
+        assert_eq!(
+            p("a(?i:b)"),
+            Hir::concat(vec![Hir::char('a'), singles(['B', 'b'])])
+        );
+    }
+
+    #[test]
+    fn ok_flag_directive() {
+        assert_eq!(p("(?i)a"), singles(['A', 'a']));
+        assert_eq!(p("a(?i)"), Hir::char('a'));
+        assert_eq!(
+            p("a(?i)b"),
+            Hir::concat(vec![Hir::char('a'), singles(['B', 'b'])])
+        );
+        assert_eq!(
+            p("a(?i)a(?-i)a"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                singles(['A', 'a']),
+                Hir::char('a'),
+            ])
+        );
+        assert_eq!(
+            p("a(?:(?i)a)a"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                singles(['A', 'a']),
+                Hir::char('a'),
+            ])
+        );
+        assert_eq!(
+            p("a((?i)a)a"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                cap(1, singles(['A', 'a'])),
+                Hir::char('a'),
+            ])
+        );
+    }
+
+    #[test]
+    fn ok_uncounted_repetition() {
+        assert_eq!(
+            p(r"a?"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: Some(1),
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a*"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: None,
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a+"),
+            Hir::repetition(hir::Repetition {
+                min: 1,
+                max: None,
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+
+        assert_eq!(
+            p(r"a??"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: Some(1),
+                greedy: false,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a*?"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: None,
+                greedy: false,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a+?"),
+            Hir::repetition(hir::Repetition {
+                min: 1,
+                max: None,
+                greedy: false,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+
+        assert_eq!(
+            p(r"a?b"),
+            Hir::concat(vec![
+                Hir::repetition(hir::Repetition {
+                    min: 0,
+                    max: Some(1),
+                    greedy: true,
+                    sub: Box::new(Hir::char('a')),
+                }),
+                Hir::char('b'),
+            ]),
+        );
+
+        assert_eq!(
+            p(r"ab?"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                Hir::repetition(hir::Repetition {
+                    min: 0,
+                    max: Some(1),
+                    greedy: true,
+                    sub: Box::new(Hir::char('b')),
+                }),
+            ]),
+        );
+
+        assert_eq!(
+            p(r"(?:ab)?"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: Some(1),
+                greedy: true,
+                sub: Box::new(Hir::concat(vec![
+                    Hir::char('a'),
+                    Hir::char('b')
+                ])),
+            }),
+        );
+
+        assert_eq!(
+            p(r"(ab)?"),
+            Hir::repetition(hir::Repetition {
+                min: 0,
+                max: Some(1),
+                greedy: true,
+                sub: Box::new(cap(
+                    1,
+                    Hir::concat(vec![Hir::char('a'), Hir::char('b')])
+                )),
+            }),
+        );
+
+        assert_eq!(
+            p(r"|a?"),
+            Hir::alternation(vec![
+                Hir::empty(),
+                Hir::repetition(hir::Repetition {
+                    min: 0,
+                    max: Some(1),
+                    greedy: true,
+                    sub: Box::new(Hir::char('a')),
+                })
+            ]),
+        );
+    }
+
+    #[test]
+    fn ok_counted_repetition() {
+        assert_eq!(
+            p(r"a{5}"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(5),
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a{5}?"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(5),
+                greedy: false,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+
+        assert_eq!(
+            p(r"a{5,}"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: None,
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+
+        assert_eq!(
+            p(r"a{5,9}"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(9),
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+
+        assert_eq!(
+            p(r"ab{5}c"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                Hir::repetition(hir::Repetition {
+                    min: 5,
+                    max: Some(5),
+                    greedy: true,
+                    sub: Box::new(Hir::char('b')),
+                }),
+                Hir::char('c'),
+            ]),
+        );
+
+        assert_eq!(
+            p(r"a{ 5 }"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(5),
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+        assert_eq!(
+            p(r"a{ 5 , 9 }"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(9),
+                greedy: true,
+                sub: Box::new(Hir::char('a')),
+            }),
+        );
+    }
+
+    #[test]
+    fn ok_group_unnamed() {
+        assert_eq!(p("(a)"), cap(1, Hir::char('a')));
+        assert_eq!(
+            p("(ab)"),
+            cap(1, Hir::concat(vec![Hir::char('a'), Hir::char('b')]))
+        );
+    }
+
+    #[test]
+    fn ok_group_named() {
+        assert_eq!(p("(?P<foo>a)"), named_cap(1, "foo", Hir::char('a')));
+        assert_eq!(p("(?<foo>a)"), named_cap(1, "foo", Hir::char('a')));
+
+        assert_eq!(
+            p("(?P<foo>ab)"),
+            named_cap(
+                1,
+                "foo",
+                Hir::concat(vec![Hir::char('a'), Hir::char('b')])
+            )
+        );
+        assert_eq!(
+            p("(?<foo>ab)"),
+            named_cap(
+                1,
+                "foo",
+                Hir::concat(vec![Hir::char('a'), Hir::char('b')])
+            )
+        );
+
+        assert_eq!(p(r"(?<a>z)"), named_cap(1, "a", Hir::char('z')));
+        assert_eq!(p(r"(?P<a>z)"), named_cap(1, "a", Hir::char('z')));
+
+        assert_eq!(p(r"(?<a_1>z)"), named_cap(1, "a_1", Hir::char('z')));
+        assert_eq!(p(r"(?P<a_1>z)"), named_cap(1, "a_1", Hir::char('z')));
+
+        assert_eq!(p(r"(?<a.1>z)"), named_cap(1, "a.1", Hir::char('z')));
+        assert_eq!(p(r"(?P<a.1>z)"), named_cap(1, "a.1", Hir::char('z')));
+
+        assert_eq!(p(r"(?<a[1]>z)"), named_cap(1, "a[1]", Hir::char('z')));
+        assert_eq!(p(r"(?P<a[1]>z)"), named_cap(1, "a[1]", Hir::char('z')));
+
+        assert_eq!(p(r"(?<a¾>z)"), named_cap(1, "a¾", Hir::char('z')));
+        assert_eq!(p(r"(?P<a¾>z)"), named_cap(1, "a¾", Hir::char('z')));
+
+        assert_eq!(p(r"(?<名字>z)"), named_cap(1, "名字", Hir::char('z')));
+        assert_eq!(p(r"(?P<名字>z)"), named_cap(1, "名字", Hir::char('z')));
+    }
+
+    #[test]
+    fn ok_class() {
+        assert_eq!(p(r"[a]"), singles(['a']));
+        assert_eq!(p(r"[a\]]"), singles(['a', ']']));
+        assert_eq!(p(r"[a\-z]"), singles(['a', '-', 'z']));
+        assert_eq!(p(r"[ab]"), class([('a', 'b')]));
+        assert_eq!(p(r"[a-]"), singles(['a', '-']));
+        assert_eq!(p(r"[-a]"), singles(['a', '-']));
+        assert_eq!(p(r"[--a]"), singles(['a', '-']));
+        assert_eq!(p(r"[---a]"), singles(['a', '-']));
+        assert_eq!(p(r"[[:alnum:]]"), posix("alnum"));
+        assert_eq!(p(r"[\w]"), posix("word"));
+        assert_eq!(p(r"[a\wz]"), posix("word"));
+        assert_eq!(p(r"[\s\S]"), class([('\x00', '\u{10FFFF}')]));
+        assert_eq!(p(r"[^\s\S]"), Hir::fail());
+        assert_eq!(p(r"[a-cx-z]"), class([('a', 'c'), ('x', 'z')]));
+        assert_eq!(p(r"[☃-⛄]"), class([('☃', '⛄')]));
+        assert_eq!(p(r"[]]"), singles([']']));
+        assert_eq!(p(r"[]a]"), singles([']', 'a']));
+        assert_eq!(p(r"[]\[]"), singles(['[', ']']));
+        assert_eq!(p(r"[\[]"), singles(['[']));
+
+        assert_eq!(p(r"(?i)[a]"), singles(['A', 'a']));
+        assert_eq!(p(r"(?i)[A]"), singles(['A', 'a']));
+        assert_eq!(p(r"(?i)[k]"), singles(['K', 'k']));
+        assert_eq!(p(r"(?i)[s]"), singles(['S', 's']));
+        assert_eq!(p(r"(?i)[β]"), singles(['β']));
+
+        assert_eq!(p(r"[^^]"), class([('\x00', ']'), ('_', '\u{10FFFF}')]));
+        assert_eq!(
+            p(r"[^-a]"),
+            class([('\x00', ','), ('.', '`'), ('b', '\u{10FFFF}')])
+        );
+
+        assert_eq!(
+            p(r"[-]a]"),
+            Hir::concat(vec![singles(['-']), Hir::char('a'), Hir::char(']')])
+        );
+    }
+
+    #[test]
+    fn ok_verbatim() {
+        assert_eq!(
+            p(r"(?x)a{5,9} ?"),
+            Hir::repetition(hir::Repetition {
+                min: 5,
+                max: Some(9),
+                greedy: false,
+                sub: Box::new(Hir::char('a')),
+            })
+        );
+        assert_eq!(p(r"(?x)[   a]"), singles(['a']));
+        assert_eq!(
+            p(r"(?x)[ ^  a]"),
+            class([('\x00', '`'), ('b', '\u{10FFFF}')])
+        );
+        assert_eq!(p(r"(?x)[ - a]"), singles(['a', '-']));
+        assert_eq!(p(r"(?x)[ ] a]"), singles([']', 'a']));
+
+        assert_eq!(
+            p(r"(?x)a b"),
+            Hir::concat(vec![Hir::char('a'), Hir::char('b')])
+        );
+        assert_eq!(
+            p(r"(?x)a b(?-x)a b"),
+            Hir::concat(vec![
+                Hir::char('a'),
+                Hir::char('b'),
+                Hir::char('a'),
+                Hir::char(' '),
+                Hir::char('b'),
+            ])
+        );
+        assert_eq!(
+            p(r"a (?x:a )a "),
+            Hir::concat(vec![
+                Hir::char('a'),
+                Hir::char(' '),
+                Hir::char('a'),
+                Hir::char('a'),
+                Hir::char(' '),
+            ])
+        );
+        assert_eq!(
+            p(r"(?x)( ?P<foo> a )"),
+            named_cap(1, "foo", Hir::char('a')),
+        );
+        assert_eq!(p(r"(?x)(  a )"), cap(1, Hir::char('a')));
+        assert_eq!(p(r"(?x)(   ?:  a )"), Hir::char('a'));
+        assert_eq!(p(r"(?x)\x { 53 }"), Hir::char('\x53'));
+        assert_eq!(p(r"(?x)\ "), Hir::char(' '));
+    }
+
+    #[test]
+    fn ok_comments() {
+        let pat = "(?x)
+# This is comment 1.
+foo # This is comment 2.
+  # This is comment 3.
+bar
+# This is comment 4.";
+        assert_eq!(
+            p(pat),
+            Hir::concat(vec![
+                Hir::char('f'),
+                Hir::char('o'),
+                Hir::char('o'),
+                Hir::char('b'),
+                Hir::char('a'),
+                Hir::char('r'),
+            ])
+        );
+    }
+
+    #[test]
+    fn err_standard() {
+        assert_eq!(
+            ERR_TOO_MUCH_NESTING,
+            perr("(((((((((((((((((((((((((((((((((((((((((((((((((((a)))))))))))))))))))))))))))))))))))))))))))))))))))"),
+        );
+        // This one is tricky, because the only way it can happen is if the
+        // number of captures overflows u32. Perhaps we should allow setting a
+        // lower limit?
+        // assert_eq!(ERR_TOO_MANY_CAPTURES, perr(""));
+        assert_eq!(ERR_DUPLICATE_CAPTURE_NAME, perr(r"(?P<a>y)(?P<a>z)"));
+        assert_eq!(ERR_UNCLOSED_GROUP, perr("("));
+        assert_eq!(ERR_UNCLOSED_GROUP_QUESTION, perr("(?"));
+        assert_eq!(ERR_UNOPENED_GROUP, perr(")"));
+        assert_eq!(ERR_LOOK_UNSUPPORTED, perr(r"(?=a)"));
+        assert_eq!(ERR_LOOK_UNSUPPORTED, perr(r"(?!a)"));
+        assert_eq!(ERR_LOOK_UNSUPPORTED, perr(r"(?<=a)"));
+        assert_eq!(ERR_LOOK_UNSUPPORTED, perr(r"(?<!a)"));
+        assert_eq!(ERR_EMPTY_FLAGS, perr(r"(?)"));
+        assert_eq!(ERR_MISSING_GROUP_NAME, perr(r"(?P<"));
+        assert_eq!(ERR_MISSING_GROUP_NAME, perr(r"(?<"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?P<1abc>z)"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?<1abc>z)"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?<¾>z)"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?<¾a>z)"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?<☃>z)"));
+        assert_eq!(ERR_INVALID_GROUP_NAME, perr(r"(?<a☃>z)"));
+        assert_eq!(ERR_UNCLOSED_GROUP_NAME, perr(r"(?P<foo"));
+        assert_eq!(ERR_UNCLOSED_GROUP_NAME, perr(r"(?<foo"));
+        assert_eq!(ERR_EMPTY_GROUP_NAME, perr(r"(?P<>z)"));
+        assert_eq!(ERR_EMPTY_GROUP_NAME, perr(r"(?<>z)"));
+        assert_eq!(ERR_FLAG_UNRECOGNIZED, perr(r"(?z:foo)"));
+        assert_eq!(ERR_FLAG_REPEATED_NEGATION, perr(r"(?s-i-R)"));
+        assert_eq!(ERR_FLAG_DUPLICATE, perr(r"(?isi)"));
+        assert_eq!(ERR_FLAG_DUPLICATE, perr(r"(?is-i)"));
+        assert_eq!(ERR_FLAG_UNEXPECTED_EOF, perr(r"(?is"));
+        assert_eq!(ERR_FLAG_DANGLING_NEGATION, perr(r"(?is-:foo)"));
+        assert_eq!(ERR_HEX_BRACE_INVALID_DIGIT, perr(r"\x{Z}"));
+        assert_eq!(ERR_HEX_BRACE_UNEXPECTED_EOF, perr(r"\x{"));
+        assert_eq!(ERR_HEX_BRACE_UNEXPECTED_EOF, perr(r"\x{A"));
+        assert_eq!(ERR_HEX_BRACE_EMPTY, perr(r"\x{}"));
+        assert_eq!(ERR_HEX_BRACE_INVALID, perr(r"\x{FFFFFFFFFFFFFFFFF}"));
+        assert_eq!(ERR_HEX_FIXED_UNEXPECTED_EOF, perr(r"\xA"));
+        assert_eq!(ERR_HEX_FIXED_INVALID_DIGIT, perr(r"\xZ"));
+        assert_eq!(ERR_HEX_FIXED_INVALID_DIGIT, perr(r"\xZA"));
+        assert_eq!(ERR_HEX_FIXED_INVALID_DIGIT, perr(r"\xAZ"));
+        assert_eq!(ERR_HEX_FIXED_INVALID, perr(r"\uD800"));
+        assert_eq!(ERR_HEX_FIXED_INVALID, perr(r"\UFFFFFFFF"));
+        assert_eq!(ERR_HEX_UNEXPECTED_EOF, perr(r"\x"));
+        assert_eq!(ERR_ESCAPE_UNEXPECTED_EOF, perr(r"\"));
+        assert_eq!(ERR_BACKREF_UNSUPPORTED, perr(r"\0"));
+        assert_eq!(ERR_BACKREF_UNSUPPORTED, perr(r"\1"));
+        assert_eq!(ERR_BACKREF_UNSUPPORTED, perr(r"\8"));
+        assert_eq!(ERR_UNICODE_CLASS_UNSUPPORTED, perr(r"\pL"));
+        assert_eq!(ERR_UNICODE_CLASS_UNSUPPORTED, perr(r"\p{L}"));
+        assert_eq!(ERR_ESCAPE_UNRECOGNIZED, perr(r"\i"));
+        assert_eq!(ERR_ESCAPE_UNRECOGNIZED, perr(r"\<"));
+        assert_eq!(ERR_ESCAPE_UNRECOGNIZED, perr(r"\>"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"?"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"*"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"+"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"(+)"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"|?"));
+        assert_eq!(ERR_UNCOUNTED_REP_SUB_MISSING, perr(r"(?i)?"));
+        assert_eq!(ERR_COUNTED_REP_SUB_MISSING, perr(r"{5}"));
+        assert_eq!(ERR_COUNTED_REP_SUB_MISSING, perr(r"({5})"));
+        assert_eq!(ERR_COUNTED_REP_SUB_MISSING, perr(r"(?i){5}"));
+        assert_eq!(ERR_COUNTED_REP_UNCLOSED, perr(r"a{"));
+        assert_eq!(ERR_COUNTED_REP_MIN_UNCLOSED, perr(r"a{5"));
+        assert_eq!(ERR_COUNTED_REP_COMMA_UNCLOSED, perr(r"a{5,"));
+        assert_eq!(ERR_COUNTED_REP_MIN_MAX_UNCLOSED, perr(r"a{5,6"));
+        assert_eq!(ERR_COUNTED_REP_INVALID, perr(r"a{5,6Z"));
+        assert_eq!(ERR_COUNTED_REP_INVALID_RANGE, perr(r"a{6,5}"));
+        assert_eq!(ERR_DECIMAL_NO_DIGITS, perr(r"a{}"));
+        assert_eq!(ERR_DECIMAL_NO_DIGITS, perr(r"a{]}"));
+        assert_eq!(ERR_DECIMAL_INVALID, perr(r"a{999999999999999}"));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_ITEM, perr(r"[a"));
+        assert_eq!(ERR_CLASS_INVALID_RANGE_ITEM, perr(r"[\w-a]"));
+        assert_eq!(ERR_CLASS_INVALID_RANGE_ITEM, perr(r"[a-\w]"));
+        assert_eq!(ERR_CLASS_INVALID_ITEM, perr(r"[\b]"));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_DASH, perr(r"[a-"));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_NEGATION, perr(r"[^"));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_CLOSING, perr(r"[]"));
+        assert_eq!(ERR_CLASS_INVALID_RANGE, perr(r"[z-a]"));
+        assert_eq!(ERR_CLASS_UNCLOSED, perr(r"["));
+        assert_eq!(ERR_CLASS_UNCLOSED, perr(r"[a-z"));
+        assert_eq!(ERR_CLASS_NEST_UNSUPPORTED, perr(r"[a-z[A-Z]]"));
+        assert_eq!(ERR_CLASS_NEST_UNSUPPORTED, perr(r"[[:alnum]]"));
+        assert_eq!(ERR_CLASS_INTERSECTION_UNSUPPORTED, perr(r"[a&&b]"));
+        assert_eq!(ERR_CLASS_DIFFERENCE_UNSUPPORTED, perr(r"[a--b]"));
+        assert_eq!(ERR_CLASS_SYMDIFFERENCE_UNSUPPORTED, perr(r"[a~~b]"));
+    }
+
+    #[test]
+    fn err_verbatim() {
+        // See: https://github.com/rust-lang/regex/issues/792
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_DASH, perr(r"(?x)[-#]"));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_ITEM, perr(r"(?x)[a "));
+        assert_eq!(ERR_CLASS_UNCLOSED_AFTER_DASH, perr(r"(?x)[a- "));
+        assert_eq!(ERR_CLASS_UNCLOSED, perr(r"(?x)[         "));
+    }
+
+    // This tests a bug fix where the nest limit checker wasn't decrementing
+    // its depth during post-traversal, which causes long regexes to trip
+    // the default limit too aggressively.
+    #[test]
+    fn regression_454_nest_too_big() {
+        let pattern = r#"
+        2(?:
+          [45]\d{3}|
+          7(?:
+            1[0-267]|
+            2[0-289]|
+            3[0-29]|
+            4[01]|
+            5[1-3]|
+            6[013]|
+            7[0178]|
+            91
+          )|
+          8(?:
+            0[125]|
+            [139][1-6]|
+            2[0157-9]|
+            41|
+            6[1-35]|
+            7[1-5]|
+            8[1-8]|
+            90
+          )|
+          9(?:
+            0[0-2]|
+            1[0-4]|
+            2[568]|
+            3[3-6]|
+            5[5-7]|
+            6[0167]|
+            7[15]|
+            8[0146-9]
+          )
+        )\d{4}
+        "#;
+        p(pattern);
+    }
+
+    // This tests that we treat a trailing `-` in a character class as a
+    // literal `-` even when whitespace mode is enabled and there is whitespace
+    // after the trailing `-`.
+    #[test]
+    fn regression_455_trailing_dash_ignore_whitespace() {
+        p("(?x)[ / - ]");
+        p("(?x)[ a - ]");
+        p("(?x)[
+            a
+            - ]
+        ");
+        p("(?x)[
+            a # wat
+            - ]
+        ");
+
+        perr("(?x)[ / -");
+        perr("(?x)[ / - ");
+        perr(
+            "(?x)[
+            / -
+        ",
+        );
+        perr(
+            "(?x)[
+            / - # wat
+        ",
+        );
+    }
+
+    #[test]
+    fn regression_capture_indices() {
+        let got = p(r"(a|ab|c|bcd){4,10}(d*)");
+        assert_eq!(
+            got,
+            Hir::concat(vec![
+                Hir::repetition(hir::Repetition {
+                    min: 4,
+                    max: Some(10),
+                    greedy: true,
+                    sub: Box::new(cap(
+                        1,
+                        Hir::alternation(vec![
+                            Hir::char('a'),
+                            Hir::concat(vec![Hir::char('a'), Hir::char('b')]),
+                            Hir::char('c'),
+                            Hir::concat(vec![
+                                Hir::char('b'),
+                                Hir::char('c'),
+                                Hir::char('d')
+                            ]),
+                        ])
+                    ))
+                }),
+                cap(
+                    2,
+                    Hir::repetition(hir::Repetition {
+                        min: 0,
+                        max: None,
+                        greedy: true,
+                        sub: Box::new(Hir::char('d')),
+                    })
+                ),
+            ])
+        );
+    }
+}
diff --git a/regex-lite/src/int.rs b/regex-lite/src/int.rs
new file mode 100644
index 0000000000..c369f04297
--- /dev/null
+++ b/regex-lite/src/int.rs
@@ -0,0 +1,56 @@
+use core::num::NonZeroUsize;
+
+/// An extension trait that adds routines to the `u32` primitive type.
+pub(crate) trait U32 {
+    fn as_usize(self) -> usize;
+}
+
+impl U32 for u32 {
+    fn as_usize(self) -> usize {
+        // OK because we require 32 or 64 bit targets. Therefore, every u32
+        // necessarily fits into a usize.
+        self as usize
+    }
+}
+
+/// A `usize` that can never be `usize::MAX`.
+///
+/// This is similar to `core::num::NonZeroUsize`, but instead of not permitting
+/// a zero value, this does not permit a max value.
+///
+/// This is useful in certain contexts where one wants to optimize the memory
+/// usage of things that contain match offsets. Namely, since Rust slices
+/// are guaranteed to never have a length exceeding `isize::MAX`, we can use
+/// `usize::MAX` as a sentinel to indicate that no match was found. Indeed,
+/// types like `Option<NonMaxUsize>` have exactly the same size in memory as a
+/// `usize`.
+///
+/// This type is defined to be `repr(transparent)` for
+/// `core::num::NonZeroUsize`, which is in turn defined to be
+/// `repr(transparent)` for `usize`.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub(crate) struct NonMaxUsize(NonZeroUsize);
+
+impl NonMaxUsize {
+    /// Create a new `NonMaxUsize` from the given value.
+    ///
+    /// This returns `None` only when the given value is equal to `usize::MAX`.
+    pub(crate) fn new(value: usize) -> Option<NonMaxUsize> {
+        NonZeroUsize::new(value.wrapping_add(1)).map(NonMaxUsize)
+    }
+
+    /// Return the underlying `usize` value. The returned value is guaranteed
+    /// to not equal `usize::MAX`.
+    pub(crate) fn get(self) -> usize {
+        self.0.get().wrapping_sub(1)
+    }
+}
+
+// We provide our own Debug impl because seeing the internal repr can be quite
+// surprising if you aren't expecting it. e.g., 'NonMaxUsize(5)' vs just '5'.
+impl core::fmt::Debug for NonMaxUsize {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{:?}", self.get())
+    }
+}
diff --git a/regex-lite/src/interpolate.rs b/regex-lite/src/interpolate.rs
new file mode 100644
index 0000000000..b01d25bdc9
--- /dev/null
+++ b/regex-lite/src/interpolate.rs
@@ -0,0 +1,536 @@
+/*!
+Provides routines for interpolating capture group references.
+
+That is, if a replacement string contains references like `$foo` or `${foo1}`,
+then they are replaced with the corresponding capture values for the groups
+named `foo` and `foo1`, respectively. Similarly, syntax like `$1` and `${1}`
+is supported as well, with `1` corresponding to a capture group index and not
+a name.
+
+This module provides the free functions [`string`] and [`bytes`], which
+interpolate Rust Unicode strings and byte strings, respectively.
+
+# Format
+
+These routines support two different kinds of capture references: unbraced and
+braced.
+
+For the unbraced format, the format supported is `$ref` where `name` can be
+any character in the class `[0-9A-Za-z_]`. `ref` is always the longest
+possible parse. So for example, `$1a` corresponds to the capture group named
+`1a` and not the capture group at index `1`. If `ref` matches `^[0-9]+$`, then
+it is treated as a capture group index itself and not a name.
+
+For the braced format, the format supported is `${ref}` where `ref` can be any
+sequence of bytes except for `}`. If no closing brace occurs, then it is not
+considered a capture reference. As with the unbraced format, if `ref` matches
+`^[0-9]+$`, then it is treated as a capture group index and not a name.
+
+The braced format is useful for exerting precise control over the name of the
+capture reference. For example, `${1}a` corresponds to the capture group
+reference `1` followed by the letter `a`, where as `$1a` (as mentioned above)
+corresponds to the capture group reference `1a`. The braced format is also
+useful for expressing capture group names that use characters not supported by
+the unbraced format. For example, `${foo[bar].baz}` refers to the capture group
+named `foo[bar].baz`.
+
+If a capture group reference is found and it does not refer to a valid capture
+group, then it will be replaced with the empty string.
+
+To write a literal `$`, use `$$`.
+
+To be clear, and as exhibited via the type signatures in the routines in this
+module, it is impossible for a replacement string to be invalid. A replacement
+string may not have the intended semantics, but the interpolation procedure
+itself can never fail.
+*/
+
+use alloc::string::String;
+
+/// Accepts a replacement string and interpolates capture references with their
+/// corresponding values.
+///
+/// `append` should be a function that appends the string value of a capture
+/// group at a particular index to the string given. If the capture group
+/// index is invalid, then nothing should be appended.
+///
+/// `name_to_index` should be a function that maps a capture group name to a
+/// capture group index. If the given name doesn't exist, then `None` should
+/// be returned.
+///
+/// Finally, `dst` is where the final interpolated contents should be written.
+/// If `replacement` contains no capture group references, then `dst` will be
+/// equivalent to `replacement`.
+///
+/// See the [module documentation](self) for details about the format
+/// supported.
+pub fn string(
+    mut replacement: &str,
+    mut append: impl FnMut(usize, &mut String),
+    mut name_to_index: impl FnMut(&str) -> Option<usize>,
+    dst: &mut String,
+) {
+    while !replacement.is_empty() {
+        match replacement.find('$') {
+            None => break,
+            Some(i) => {
+                dst.push_str(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        // Handle escaping of '$'.
+        if replacement.as_bytes().get(1).map_or(false, |&b| b == b'$') {
+            dst.push_str("$");
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement.as_bytes()) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push_str("$");
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => append(i, dst),
+            Ref::Named(name) => {
+                if let Some(i) = name_to_index(name) {
+                    append(i, dst);
+                }
+            }
+        }
+    }
+    dst.push_str(replacement);
+}
+
+/*
+This should be uncommented and used if we ever provide public APIs for
+searching `&[u8]`.
+
+/// Accepts a replacement byte string and interpolates capture references with
+/// their corresponding values.
+///
+/// `append` should be a function that appends the byte string value of a
+/// capture group at a particular index to the byte string given. If the
+/// capture group index is invalid, then nothing should be appended.
+///
+/// `name_to_index` should be a function that maps a capture group name to a
+/// capture group index. If the given name doesn't exist, then `None` should
+/// be returned.
+///
+/// Finally, `dst` is where the final interpolated contents should be written.
+/// If `replacement` contains no capture group references, then `dst` will be
+/// equivalent to `replacement`.
+///
+/// See the [module documentation](self) for details about the format
+/// supported.
+pub fn bytes(
+    mut replacement: &[u8],
+    mut append: impl FnMut(usize, &mut Vec<u8>),
+    mut name_to_index: impl FnMut(&str) -> Option<usize>,
+    dst: &mut Vec<u8>,
+) {
+    while !replacement.is_empty() {
+        match replacement.iter().position(|&b| b == b'$') {
+            None => break,
+            Some(i) => {
+                dst.extend_from_slice(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        // Handle escaping of '$'.
+        if replacement.get(1).map_or(false, |&b| b == b'$') {
+            dst.push(b'$');
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push(b'$');
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => append(i, dst),
+            Ref::Named(name) => {
+                if let Some(i) = name_to_index(name) {
+                    append(i, dst);
+                }
+            }
+        }
+    }
+    dst.extend_from_slice(replacement);
+}
+*/
+
+/// `CaptureRef` represents a reference to a capture group inside some text.
+/// The reference is either a capture group name or a number.
+///
+/// It is also tagged with the position in the text following the
+/// capture reference.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct CaptureRef<'a> {
+    cap: Ref<'a>,
+    end: usize,
+}
+
+/// A reference to a capture group in some text.
+///
+/// e.g., `$2`, `$foo`, `${foo}`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Ref<'a> {
+    Named(&'a str),
+    Number(usize),
+}
+
+impl<'a> From<&'a str> for Ref<'a> {
+    fn from(x: &'a str) -> Ref<'a> {
+        Ref::Named(x)
+    }
+}
+
+impl From<usize> for Ref<'static> {
+    fn from(x: usize) -> Ref<'static> {
+        Ref::Number(x)
+    }
+}
+
+/// Parses a possible reference to a capture group name in the given text,
+/// starting at the beginning of `replacement`.
+///
+/// If no such valid reference could be found, None is returned.
+///
+/// Note that this returns a "possible" reference because this routine doesn't
+/// know whether the reference is to a valid group or not. If it winds up not
+/// being a valid reference, then it should be replaced with the empty string.
+fn find_cap_ref(replacement: &[u8]) -> Option<CaptureRef<'_>> {
+    let mut i = 0;
+    let rep: &[u8] = replacement;
+    if rep.len() <= 1 || rep[0] != b'$' {
+        return None;
+    }
+    i += 1;
+    if rep[i] == b'{' {
+        return find_cap_ref_braced(rep, i + 1);
+    }
+    let mut cap_end = i;
+    while rep.get(cap_end).copied().map_or(false, is_valid_cap_letter) {
+        cap_end += 1;
+    }
+    if cap_end == i {
+        return None;
+    }
+    // We just verified that the range 0..cap_end is valid ASCII, so it must
+    // therefore be valid UTF-8. If we really cared, we could avoid this UTF-8
+    // check via an unchecked conversion or by parsing the number straight from
+    // &[u8].
+    let cap = core::str::from_utf8(&rep[i..cap_end])
+        .expect("valid UTF-8 capture name");
+    Some(CaptureRef {
+        cap: match cap.parse::<usize>() {
+            Ok(i) => Ref::Number(i),
+            Err(_) => Ref::Named(cap),
+        },
+        end: cap_end,
+    })
+}
+
+/// Looks for a braced reference, e.g., `${foo1}`. This assumes that an opening
+/// brace has been found at `i-1` in `rep`. This then looks for a closing
+/// brace and returns the capture reference within the brace.
+fn find_cap_ref_braced(rep: &[u8], mut i: usize) -> Option<CaptureRef<'_>> {
+    assert_eq!(b'{', rep[i.checked_sub(1).unwrap()]);
+    let start = i;
+    while rep.get(i).map_or(false, |&b| b != b'}') {
+        i += 1;
+    }
+    if !rep.get(i).map_or(false, |&b| b == b'}') {
+        return None;
+    }
+    // When looking at braced names, we don't put any restrictions on the name,
+    // so it's possible it could be invalid UTF-8. But a capture group name
+    // can never be invalid UTF-8, so if we have invalid UTF-8, then we can
+    // safely return None.
+    let cap = match core::str::from_utf8(&rep[start..i]) {
+        Err(_) => return None,
+        Ok(cap) => cap,
+    };
+    Some(CaptureRef {
+        cap: match cap.parse::<usize>() {
+            Ok(i) => Ref::Number(i),
+            Err(_) => Ref::Named(cap),
+        },
+        end: i + 1,
+    })
+}
+
+/// Returns true if and only if the given byte is allowed in a capture name
+/// written in non-brace form.
+fn is_valid_cap_letter(b: u8) -> bool {
+    match b {
+        b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_' => true,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::{string::String, vec, vec::Vec};
+
+    use super::{find_cap_ref, CaptureRef};
+
+    macro_rules! find {
+        ($name:ident, $text:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(None, find_cap_ref($text.as_bytes()));
+            }
+        };
+        ($name:ident, $text:expr, $capref:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(Some($capref), find_cap_ref($text.as_bytes()));
+            }
+        };
+    }
+
+    macro_rules! c {
+        ($name_or_number:expr, $pos:expr) => {
+            CaptureRef { cap: $name_or_number.into(), end: $pos }
+        };
+    }
+
+    find!(find_cap_ref1, "$foo", c!("foo", 4));
+    find!(find_cap_ref2, "${foo}", c!("foo", 6));
+    find!(find_cap_ref3, "$0", c!(0, 2));
+    find!(find_cap_ref4, "$5", c!(5, 2));
+    find!(find_cap_ref5, "$10", c!(10, 3));
+    // See https://github.com/rust-lang/regex/pull/585
+    // for more on characters following numbers
+    find!(find_cap_ref6, "$42a", c!("42a", 4));
+    find!(find_cap_ref7, "${42}a", c!(42, 5));
+    find!(find_cap_ref8, "${42");
+    find!(find_cap_ref9, "${42 ");
+    find!(find_cap_ref10, " $0 ");
+    find!(find_cap_ref11, "$");
+    find!(find_cap_ref12, " ");
+    find!(find_cap_ref13, "");
+    find!(find_cap_ref14, "$1-$2", c!(1, 2));
+    find!(find_cap_ref15, "$1_$2", c!("1_", 3));
+    find!(find_cap_ref16, "$x-$y", c!("x", 2));
+    find!(find_cap_ref17, "$x_$y", c!("x_", 3));
+    find!(find_cap_ref18, "${#}", c!("#", 4));
+    find!(find_cap_ref19, "${Z[}", c!("Z[", 5));
+    find!(find_cap_ref20, "${¾}", c!("¾", 5));
+    find!(find_cap_ref21, "${¾a}", c!("¾a", 6));
+    find!(find_cap_ref22, "${a¾}", c!("a¾", 6));
+    find!(find_cap_ref23, "${☃}", c!("☃", 6));
+    find!(find_cap_ref24, "${a☃}", c!("a☃", 7));
+    find!(find_cap_ref25, "${☃a}", c!("☃a", 7));
+    find!(find_cap_ref26, "${名字}", c!("名字", 9));
+
+    fn interpolate_string(
+        mut name_to_index: Vec<(&'static str, usize)>,
+        caps: Vec<&'static str>,
+        replacement: &str,
+    ) -> String {
+        name_to_index.sort_by_key(|x| x.0);
+
+        let mut dst = String::new();
+        super::string(
+            replacement,
+            |i, dst| {
+                if let Some(&s) = caps.get(i) {
+                    dst.push_str(s);
+                }
+            },
+            |name| -> Option<usize> {
+                name_to_index
+                    .binary_search_by_key(&name, |x| x.0)
+                    .ok()
+                    .map(|i| name_to_index[i].1)
+            },
+            &mut dst,
+        );
+        dst
+    }
+
+    /*
+    fn interpolate_bytes(
+        mut name_to_index: Vec<(&'static str, usize)>,
+        caps: Vec<&'static str>,
+        replacement: &str,
+    ) -> String {
+        name_to_index.sort_by_key(|x| x.0);
+
+        let mut dst = vec![];
+        super::bytes(
+            replacement.as_bytes(),
+            |i, dst| {
+                if let Some(&s) = caps.get(i) {
+                    dst.extend_from_slice(s.as_bytes());
+                }
+            },
+            |name| -> Option<usize> {
+                name_to_index
+                    .binary_search_by_key(&name, |x| x.0)
+                    .ok()
+                    .map(|i| name_to_index[i].1)
+            },
+            &mut dst,
+        );
+        String::from_utf8(dst).unwrap()
+    }
+    */
+
+    macro_rules! interp {
+        ($name:ident, $map:expr, $caps:expr, $hay:expr, $expected:expr $(,)*) => {
+            #[test]
+            fn $name() {
+                assert_eq!(
+                    $expected,
+                    interpolate_string($map, $caps, $hay),
+                    "interpolate::string failed",
+                );
+                /*
+                assert_eq!(
+                    $expected,
+                    interpolate_bytes($map, $caps, $hay),
+                    "interpolate::bytes failed",
+                );
+                */
+            }
+        };
+    }
+
+    interp!(
+        interp1,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $foo test",
+        "test xxx test",
+    );
+
+    interp!(
+        interp2,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test$footest",
+        "test",
+    );
+
+    interp!(
+        interp3,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test${foo}test",
+        "testxxxtest",
+    );
+
+    interp!(
+        interp4,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test$2test",
+        "test",
+    );
+
+    interp!(
+        interp5,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test${2}test",
+        "testxxxtest",
+    );
+
+    interp!(
+        interp6,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $$foo test",
+        "test $foo test",
+    );
+
+    interp!(
+        interp7,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "test $foo",
+        "test xxx",
+    );
+
+    interp!(
+        interp8,
+        vec![("foo", 2)],
+        vec!["", "", "xxx"],
+        "$foo test",
+        "xxx test",
+    );
+
+    interp!(
+        interp9,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test $bar$foo",
+        "test yyyxxx",
+    );
+
+    interp!(
+        interp10,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test $ test",
+        "test $ test",
+    );
+
+    interp!(
+        interp11,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${} test",
+        "test  test",
+    );
+
+    interp!(
+        interp12,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${ } test",
+        "test  test",
+    );
+
+    interp!(
+        interp13,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${a b} test",
+        "test  test",
+    );
+
+    interp!(
+        interp14,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${a} test",
+        "test  test",
+    );
+
+    // This is a funny case where a braced reference is never closed, but
+    // within the unclosed braced reference, there is an unbraced reference.
+    // In this case, the braced reference is just treated literally and the
+    // unbraced reference is found.
+    interp!(
+        interp15,
+        vec![("bar", 1), ("foo", 2)],
+        vec!["", "yyy", "xxx"],
+        "test ${wat $bar ok",
+        "test ${wat yyy ok",
+    );
+}
diff --git a/regex-lite/src/lib.rs b/regex-lite/src/lib.rs
new file mode 100644
index 0000000000..d8e9016788
--- /dev/null
+++ b/regex-lite/src/lib.rs
@@ -0,0 +1,877 @@
+/*!
+This crate provides a **lightweight** regex engine for searching strings. The
+regex syntax supported by this crate is nearly identical to what is found in
+the [`regex`](https://docs.rs/regex) crate. Like the `regex` crate, all regex
+searches in this crate have worst case `O(m * n)` time complexity, where `m` is
+proportional to the size of the regex and `n` is proportional to the size of
+the string being searched.
+
+The principal difference between the `regex` and `regex-lite` crates is that
+the latter prioritizes smaller binary sizes and shorter Rust compile times
+over performance and functionality. As a result, regex searches in this crate
+are typically substantially slower than what is provided by the `regex` crate.
+Moreover, this crate only has the most basic level of Unicode support: it
+matches codepoint by codepoint but otherwise doesn't support Unicode case
+insensivity or things like `\p{Letter}`. In exchange, this crate contributes
+far less to binary size and compiles much more quickly.
+
+If you just want API documentation, then skip to the [`Regex`] type. Otherwise,
+here's a quick example showing one way of parsing the output of a grep-like
+program:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?m)^([^:]+):([0-9]+):(.+)$").unwrap();
+let hay = "\
+path/to/foo:54:Blue Harvest
+path/to/bar:90:Something, Something, Something, Dark Side
+path/to/baz:3:It's a Trap!
+";
+
+let mut results = vec![];
+for (_, [path, lineno, line]) in re.captures_iter(hay).map(|c| c.extract()) {
+    results.push((path, lineno.parse::<u64>()?, line));
+}
+assert_eq!(results, vec![
+    ("path/to/foo", 54, "Blue Harvest"),
+    ("path/to/bar", 90, "Something, Something, Something, Dark Side"),
+    ("path/to/baz", 3, "It's a Trap!"),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Overview
+
+The primary type in this crate is a [`Regex`]. Its most important methods are
+as follows:
+
+* [`Regex::new`] compiles a regex using the default configuration. A
+[`RegexBuilder`] permits setting a non-default configuration. (For example,
+case insensitive matching, verbose mode and others.)
+* [`Regex::is_match`] reports whether a match exists in a particular haystack.
+* [`Regex::find`] reports the byte offsets of a match in a haystack, if one
+exists. [`Regex::find_iter`] returns an iterator over all such matches.
+* [`Regex::captures`] returns a [`Captures`], which reports both the byte
+offsets of a match in a haystack and the byte offsets of each matching capture
+group from the regex in the haystack.
+[`Regex::captures_iter`] returns an iterator over all such matches.
+
+Otherwise, this top-level crate documentation is organized as follows:
+
+* [Usage](#usage) shows how to add the `regex` crate to your Rust project.
+* [Examples](#examples) provides a limited selection of regex search examples.
+* [Differences with the regex crate](#differences-with-the-regex-crate)
+provides a precise description of how `regex-lite` differs from `regex`.
+* [Syntax](#syntax) enumerates the specific regex syntax supported by this
+crate.
+* [Untrusted input](#untrusted-input) discusses how this crate deals with regex
+patterns or haystacks that are untrusted.
+
+# Usage
+
+The `regex-lite` crate is [on crates.io](https://crates.io/crates/regex-lite)
+and can be used by adding `regex-lite` to your dependencies in your project's
+`Cargo.toml`. Or more simply, just run `cargo add regex-lite`.
+
+Here is a complete example that creates a new Rust project, adds a dependency
+on `regex-lite`, creates the source code for a regex search and then runs the
+program.
+
+First, create the project in a new directory:
+
+```text
+$ mkdir regex-example
+$ cd regex-example
+$ cargo init
+```
+
+Second, add a dependency on `regex`:
+
+```text
+$ cargo add regex-lite
+```
+
+Third, edit `src/main.rs`. Delete what's there and replace it with this:
+
+```
+use regex_lite::Regex;
+
+fn main() {
+    let re = Regex::new(r"Hello (?<name>\w+)!").unwrap();
+    let Some(caps) = re.captures("Hello Murphy!") else {
+        println!("no match!");
+        return;
+    };
+    println!("The name is: {}", &caps["name"]);
+}
+```
+
+Foruth, run it with `cargo run`:
+
+```text
+$ cargo run
+   Compiling regex-lite v0.1.0
+   Compiling regex-example v0.1.0 (/tmp/regex-example)
+    Finished dev [unoptimized + debuginfo] target(s) in 4.22s
+     Running `target/debug/regex-example`
+The name is: Murphy
+```
+
+The first time you run the program will show more output like above. But
+subsequent runs shouldn't have to re-compile the dependencies.
+
+# Examples
+
+This section provides a few examples, in tutorial style, showing how to
+search a haystack with a regex. There are more examples throughout the API
+documentation.
+
+Before starting though, it's worth defining a few terms:
+
+* A **regex** is a Rust value whose type is `Regex`. We use `re` as a
+variable name for a regex.
+* A **pattern** is the string that is used to build a regex. We use `pat` as
+a variable name for a pattern.
+* A **haystack** is the string that is searched by a regex. We use `hay` as a
+variable name for a haystack.
+
+Sometimes the words "regex" and "pattern" are used interchangeably.
+
+General use of regular expressions in this crate proceeds by compiling a
+**pattern** into a **regex**, and then using that regex to search, split or
+replace parts of a **haystack**.
+
+### Example: find a middle initial
+
+We'll start off with a very simple example: a regex that looks for a specific
+name but uses a wildcard to match a middle initial. Our pattern serves as
+something like a template that will match a particular name with *any* middle
+initial.
+
+```rust
+use regex_lite::Regex;
+
+// We use 'unwrap()' here because it would be a bug in our program if the
+// pattern failed to compile to a regex. Panicking in the presence of a bug
+// is okay.
+let re = Regex::new(r"Homer (.)\. Simpson").unwrap();
+let hay = "Homer J. Simpson";
+let Some(caps) = re.captures(hay) else { return };
+assert_eq!("J", &caps[1]);
+```
+
+There are a few things worth noticing here in our first example:
+
+* The `.` is a special pattern meta character that means "match any single
+character except for new lines." (More precisely, in this crate, it means
+"match any UTF-8 encoding of any Unicode scalar value other than `\n`.")
+* We can match an actual `.` literally by escaping it, i.e., `\.`.
+* We use Rust's [raw strings] to avoid needing to deal with escape sequences in
+both the regex pattern syntax and in Rust's string literal syntax. If we didn't
+use raw strings here, we would have had to use `\\.` to match a literal `.`
+character. That is, `r"\."` and `"\\."` are equivalent patterns.
+* We put our wildcard `.` instruction in parentheses. These parentheses have a
+special meaning that says, "make whatever part of the haystack matches within
+these parentheses available as a capturing group." After finding a match, we
+access this capture group with `&caps[1]`.
+
+[raw strings]: https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals
+
+Otherwise, we execute a search using `re.captures(hay)` and return from our
+function if no match occurred. We then reference the middle initial by asking
+for the part of the haystack that matched the capture group indexed at `1`.
+(The capture group at index 0 is implicit and always corresponds to the entire
+match. In this case, that's `Homer J. Simpson`.)
+
+### Example: named capture groups
+
+Continuing from our middle initial example above, we can tweak the pattern
+slightly to give a name to the group that matches the middle initial:
+
+```rust
+use regex_lite::Regex;
+
+// Note that (?P<middle>.) is a different way to spell the same thing.
+let re = Regex::new(r"Homer (?<middle>.)\. Simpson").unwrap();
+let hay = "Homer J. Simpson";
+let Some(caps) = re.captures(hay) else { return };
+assert_eq!("J", &caps["middle"]);
+```
+
+Giving a name to a group can be useful when there are multiple groups in
+a pattern. It makes the code referring to those groups a bit easier to
+understand.
+
+### Example: validating a particular date format
+
+This examples shows how to confirm whether a haystack, in its entirety, matches
+a particular date format:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
+assert!(re.is_match("2010-03-14"));
+```
+
+Notice the use of the `^` and `$` anchors. In this crate, every regex search is
+run with an implicit `(?s:.)*?` at the beginning of its pattern, which allows
+the regex to match anywhere in a haystack. Anchors, as above, can be used to
+ensure that the full haystack matches a pattern.
+
+### Example: finding dates in a haystack
+
+In the previous example, we showed how one might validate that a haystack,
+in its entirety, corresponded to a particular date format. But what if we wanted
+to extract all things that look like dates in a specific format from a haystack?
+To do this, we can use an iterator API to find all matches (notice that we've
+removed the anchors):
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"\d{4}-\d{2}-\d{2}").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
+let dates: Vec<&str> = re.find_iter(hay).map(|m| m.as_str()).collect();
+assert_eq!(dates, vec![
+    "1865-04-14",
+    "1881-07-02",
+    "1901-09-06",
+    "1963-11-22",
+]);
+```
+
+We can also iterate over [`Captures`] values instead of [`Match`] values, and
+that in turn permits accessing each component of the date via capturing groups:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
+let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
+    // The unwraps are okay because every capture group must match if the whole
+    // regex matches, and in this context, we know we have a match.
+    //
+    // Note that we use `caps.name("y").unwrap().as_str()` instead of
+    // `&caps["y"]` because the the lifetime of the former is the same as the
+    // lifetime of `hay` above, but the lifetime of the latter is tied to the
+    // lifetime of `caps` due to how the `Index` trait is defined.
+    let year = caps.name("y").unwrap().as_str();
+    let month = caps.name("m").unwrap().as_str();
+    let day = caps.name("d").unwrap().as_str();
+    (year, month, day)
+}).collect();
+assert_eq!(dates, vec![
+    ("1865", "04", "14"),
+    ("1881", "07", "02"),
+    ("1901", "09", "06"),
+    ("1963", "11", "22"),
+]);
+```
+
+### Example: simpler capture group extraction
+
+One can use [`Captures::extract`] to make the code from the previous example a
+bit simpler in this case:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
+    let (_, [year, month, day]) = caps.extract();
+    (year, month, day)
+}).collect();
+assert_eq!(dates, vec![
+    ("1865", "04", "14"),
+    ("1881", "07", "02"),
+    ("1901", "09", "06"),
+    ("1963", "11", "22"),
+]);
+```
+
+`Captures::extract` works by ensuring that the number of matching groups match
+the number of groups requested via the `[year, month, day]` syntax. If they do,
+then the substrings for each corresponding capture group are automatically
+returned in an appropriately sized array. Rust's syntax for pattern matching
+arrays does the rest.
+
+### Example: replacement with named capture groups
+
+Building on the previous example, perhaps we'd like to rearrange the date
+formats. This can be done by finding each match and replacing it with
+something different. The [`Regex::replace_all`] routine provides a convenient
+way to do this, including by supporting references to named groups in the
+replacement string:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
+let before = "1973-01-05, 1975-08-25 and 1980-10-18";
+let after = re.replace_all(before, "$m/$d/$y");
+assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
+```
+
+The replace methods are actually polymorphic in the replacement, which
+provides more flexibility than is seen here. (See the documentation for
+[`Regex::replace`] for more details.)
+
+### Example: verbose mode
+
+When your regex gets complicated, you might consider using something other
+than regex. But if you stick with regex, you can use the `x` flag to enable
+insignificant whitespace mode or "verbose mode." In this mode, whitespace
+is treated as insignificant and one may write comments. This may make your
+patterns easier to comprehend.
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?x)
+  (?P<y>\d{4}) # the year
+  -
+  (?P<m>\d{2}) # the month
+  -
+  (?P<d>\d{2}) # the day
+").unwrap();
+
+let before = "1973-01-05, 1975-08-25 and 1980-10-18";
+let after = re.replace_all(before, "$m/$d/$y");
+assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
+```
+
+If you wish to match against whitespace in this mode, you can still use `\s`,
+`\n`, `\t`, etc. For escaping a single space character, you can escape it
+directly with `\ `, use its hex character code `\x20` or temporarily disable
+the `x` flag, e.g., `(?-x: )`.
+
+# Differences with the `regex` crate
+
+As mentioned in the introduction above, the purpose of this crate is to
+prioritize small binary sizes and shorter Rust compilation times as much as
+possible. Namely, while the `regex` crate tends to eschew both binary size
+and compilation time in favor of faster searches and features, the
+`regex-lite` crate gives up faster searches and some functionality in exchange
+for smaller binary sizes and faster compilation times.
+
+The precise set of differences at the syntax level:
+
+* The Perl character classes are limited to ASCII codepoints. That is,
+`\d` is `[0-9]`, `\s` is `[\t\n\v\f\r ]` and `\w` is `[0-9A-Za-z_]`.
+* Unicode character classes of the form `\p{...}` and `\P{...}` are not
+supported at all. Note though that things like `[^β]` are still supported and
+will match any Unicode scalar value except for `β`.
+* Case insensitive searching is limited to ASCII case insensitivity.
+* Character class set operations other than union are not supported. That is,
+difference (`--`), intersection (`&&`) and symmetric difference (`~~`) are
+not available. These tend to be most useful with Unicode classes, which also
+aren't available.
+* Opt-in octal support is not available in this crate.
+
+And now at the API level:
+
+* Currently, this crate only supports searching `&str`. It does not have APIs
+for searching `&[u8]` haystacks, although it is planned to add these in the
+future if there's demand.
+* There is no `RegexSet` in this crate and there are no plans to add it.
+* The `Error` type in this crate is completely opaque.
+
+Other than these things, the `regex-lite` crate is intended to be a drop-in
+replacement for the `regex` crate. In most cases, you can just replace `use
+regex::Regex;` with `use regex_lite::Regex;` and everything will work. (Unless
+you're depending on Unicode support in your regexes.)
+
+# Syntax
+
+The syntax supported in this crate is documented below.
+
+### Matching one character
+
+<pre class="rust">
+.             any character except new line (includes new line with s flag)
+[0-9]         any ASCII digit
+\d            digit ([0-9])
+\D            not digit
+</pre>
+
+### Character classes
+
+<pre class="rust">
+[xyz]         A character class matching either x, y or z (union).
+[^xyz]        A character class matching any character except x, y and z.
+[a-z]         A character class matching any character in range a-z.
+[[:alpha:]]   ASCII character class ([A-Za-z])
+[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])
+[\[\]]        Escaping in character classes (matching [ or ])
+</pre>
+
+Any ASCII or Perl character class may appear inside a bracketed `[...]` character
+class. For example, `[\s[:digit:]]` matches any digit or space character.
+
+Precedence in character classes, from most binding to least:
+
+1. Ranges: `[a-cd]` == `[[a-c]d]`
+2. Union: `[ab&&bc]` == `[[ab]&&[bc]]`
+3. Negation: `[^a-z&&b]` == `[^[a-z&&b]]`.
+
+### Composites
+
+<pre class="rust">
+xy    concatenation (x followed by y)
+x|y   alternation (x or y, prefer x)
+</pre>
+
+This example shows how an alternation works, and what it means to prefer a
+branch in the alternation over subsequent branches.
+
+```
+use regex_lite::Regex;
+
+let haystack = "samwise";
+// If 'samwise' comes first in our alternation, then it is
+// preferred as a match, even if the regex engine could
+// technically detect that 'sam' led to a match earlier.
+let re = Regex::new(r"samwise|sam").unwrap();
+assert_eq!("samwise", re.find(haystack).unwrap().as_str());
+// But if 'sam' comes first, then it will match instead.
+// In this case, it is impossible for 'samwise' to match
+// because 'sam' is a prefix of it.
+let re = Regex::new(r"sam|samwise").unwrap();
+assert_eq!("sam", re.find(haystack).unwrap().as_str());
+```
+
+### Repetitions
+
+<pre class="rust">
+x*        zero or more of x (greedy)
+x+        one or more of x (greedy)
+x?        zero or one of x (greedy)
+x*?       zero or more of x (ungreedy/lazy)
+x+?       one or more of x (ungreedy/lazy)
+x??       zero or one of x (ungreedy/lazy)
+x{n,m}    at least n x and at most m x (greedy)
+x{n,}     at least n x (greedy)
+x{n}      exactly n x
+x{n,m}?   at least n x and at most m x (ungreedy/lazy)
+x{n,}?    at least n x (ungreedy/lazy)
+x{n}?     exactly n x
+</pre>
+
+### Empty matches
+
+<pre class="rust">
+^     the beginning of a haystack (or start-of-line with multi-line mode)
+$     the end of a haystack (or end-of-line with multi-line mode)
+\A    only the beginning of a haystack (even with multi-line mode enabled)
+\z    only the end of a haystack (even with multi-line mode enabled)
+\b    an ASCII word boundary (\w on one side and \W, \A, or \z on other)
+\B    not an ASCII word boundary
+</pre>
+
+The empty regex is valid and matches the empty string. For example, the
+empty regex matches `abc` at positions `0`, `1`, `2` and `3`. When using the
+top-level [`Regex`] on `&str` haystacks, an empty match that splits a codepoint
+is guaranteed to never be returned. For example:
+
+```rust
+let re = regex_lite::Regex::new(r"").unwrap();
+let ranges: Vec<_> = re.find_iter("💩").map(|m| m.range()).collect();
+assert_eq!(ranges, vec![0..0, 4..4]);
+```
+
+Note that an empty regex is distinct from a regex that can never match. For
+example, the regex `[^\s\S]` is a character class that represents the negation
+of `[\s\S]`, where the union of `\s` and `\S` corresponds to all Unicode scalar
+values. The negation of everything is nothing, which means the character class
+is empty. Since nothing is in the empty set, `[^\s\S]` matches nothing, not
+even the empty string.
+
+### Grouping and flags
+
+<pre class="rust">
+(exp)          numbered capture group (indexed by opening parenthesis)
+(?P&lt;name&gt;exp)  named (also numbered) capture group (names must be alpha-numeric)
+(?&lt;name&gt;exp)   named (also numbered) capture group (names must be alpha-numeric)
+(?:exp)        non-capturing group
+(?flags)       set flags within current group
+(?flags:exp)   set flags for exp (non-capturing)
+</pre>
+
+Capture group names must be any sequence of alpha-numeric Unicode codepoints,
+in addition to `.`, `_`, `[` and `]`. Names must start with either an `_` or
+an alphabetic codepoint. Alphabetic codepoints correspond to the `Alphabetic`
+Unicode property, while numeric codepoints correspond to the union of the
+`Decimal_Number`, `Letter_Number` and `Other_Number` general categories.
+
+Flags are each a single character. For example, `(?x)` sets the flag `x`
+and `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at
+the same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets
+the `x` flag and clears the `y` flag.
+
+All flags are by default disabled unless stated otherwise. They are:
+
+<pre class="rust">
+i     case-insensitive: letters match both upper and lower case
+m     multi-line mode: ^ and $ match begin/end of line
+s     allow . to match \n
+R     enables CRLF mode: when multi-line mode is enabled, \r\n is used
+U     swap the meaning of x* and x*?
+x     verbose mode, ignores whitespace and allow line comments (starting with `#`)
+</pre>
+
+Note that in verbose mode, whitespace is ignored everywhere, including within
+character classes. To insert whitespace, use its escaped form or a hex literal.
+For example, `\ ` or `\x20` for an ASCII space.
+
+Flags can be toggled within a pattern. Here's an example that matches
+case-insensitively for the first part but case-sensitively for the second part:
+
+```rust
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?i)a+(?-i)b+").unwrap();
+let m = re.find("AaAaAbbBBBb").unwrap();
+assert_eq!(m.as_str(), "AaAaAbb");
+```
+
+Notice that the `a+` matches either `a` or `A`, but the `b+` only matches
+`b`.
+
+Multi-line mode means `^` and `$` no longer match just at the beginning/end of
+the input, but also at the beginning/end of lines:
+
+```
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?m)^line \d+").unwrap();
+let m = re.find("line one\nline 2\n").unwrap();
+assert_eq!(m.as_str(), "line 2");
+```
+
+Note that `^` matches after new lines, even at the end of input:
+
+```
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?m)^").unwrap();
+let m = re.find_iter("test\n").last().unwrap();
+assert_eq!((m.start(), m.end()), (5, 5));
+```
+
+When both CRLF mode and multi-line mode are enabled, then `^` and `$` will
+match either `\r` and `\n`, but never in the middle of a `\r\n`:
+
+```
+use regex_lite::Regex;
+
+let re = Regex::new(r"(?mR)^foo$").unwrap();
+let m = re.find("\r\nfoo\r\n").unwrap();
+assert_eq!(m.as_str(), "foo");
+```
+
+### Escape sequences
+
+Note that this includes all possible escape sequences, even ones that are
+documented elsewhere.
+
+<pre class="rust">
+\*          literal *, applies to all ASCII except [0-9A-Za-z<>]
+\a          bell (\x07)
+\f          form feed (\x0C)
+\t          horizontal tab
+\n          new line
+\r          carriage return
+\v          vertical tab (\x0B)
+\A          matches at the beginning of a haystack
+\z          matches at the end of a haystack
+\b          word boundary assertion
+\B          negated word boundary assertion
+\x7F        hex character code (exactly two digits)
+\x{10FFFF}  any hex character code corresponding to a Unicode code point
+\u007F      hex character code (exactly four digits)
+\u{7F}      any hex character code corresponding to a Unicode code point
+\U0000007F  hex character code (exactly eight digits)
+\U{7F}      any hex character code corresponding to a Unicode code point
+\d, \s, \w  Perl character class
+\D, \S, \W  negated Perl character class
+</pre>
+
+### Perl character classes (ASCII only)
+
+These character classes are short-hands for common groups of characters. In
+this crate, `\d`, `\s` and `\w` only consist of ASCII codepoints.
+
+<pre class="rust">
+\d     digit ([0-9])
+\D     not digit
+\s     whitespace ([\t\n\v\f\r ])
+\S     not whitespace
+\w     word character ([0-9A-Za-z_])
+\W     not word character
+</pre>
+
+### ASCII character classes
+
+These reflect additional groups of characters taken from POSIX regex syntax
+that are sometimes useful to have. In this crate, all of these classes only
+consist of ASCII codepoints.
+
+<pre class="rust">
+[[:alnum:]]    alphanumeric ([0-9A-Za-z])
+[[:alpha:]]    alphabetic ([A-Za-z])
+[[:ascii:]]    ASCII ([\x00-\x7F])
+[[:blank:]]    blank ([\t ])
+[[:cntrl:]]    control ([\x00-\x1F\x7F])
+[[:digit:]]    digits ([0-9])
+[[:graph:]]    graphical ([!-~])
+[[:lower:]]    lower case ([a-z])
+[[:print:]]    printable ([ -~])
+[[:punct:]]    punctuation ([!-/:-@\[-`{-~])
+[[:space:]]    whitespace ([\t\n\v\f\r ])
+[[:upper:]]    upper case ([A-Z])
+[[:word:]]     word characters ([0-9A-Za-z_])
+[[:xdigit:]]   hex digit ([0-9A-Fa-f])
+</pre>
+
+# Untrusted input
+
+This crate is meant to be able to run regex searches on untrusted haystacks
+without fear of [ReDoS]. This crate also, to a certain extent, supports
+untrusted patterns.
+
+[ReDoS]: https://en.wikipedia.org/wiki/ReDoS
+
+This crate differs from most (but not all) other regex engines in that it
+doesn't use unbounded backtracking to run a regex search. In those cases,
+one generally cannot use untrusted patterns *or* untrusted haystacks because
+it can be very difficult to know whether a particular pattern will result in
+catastrophic backtracking or not.
+
+We'll first discuss how this crate deals with untrusted inputs and then wrap
+it up with a realistic discussion about what practice really looks like.
+
+### Panics
+
+Outside of clearly documented cases, most APIs in this crate are intended to
+never panic regardless of the inputs given to them. For example, `Regex::new`,
+`Regex::is_match`, `Regex::find` and `Regex::captures` should never panic. That
+is, it is an API promise that those APIs will never panic no matter what inputs
+are given to them. With that said, regex engines are complicated beasts, and
+providing a rock solid guarantee that these APIs literally never panic is
+essentially equivalent to saying, "there are no bugs in this library." That is
+a bold claim, and not really one that can be feasibly made with a straight
+face.
+
+Don't get the wrong impression here. This crate is extensively tested, not just
+with unit and integration tests, but also via fuzz testing. For example, this
+crate is part of the [OSS-fuzz project]. Panics should be incredibly rare, but
+it is possible for bugs to exist, and thus possible for a panic to occur. If
+you need a rock solid guarantee against panics, then you should wrap calls into
+this library with [`std::panic::catch_unwind`].
+
+It's also worth pointing out that this library will generally panic when other
+regex engines would commit undefined behavior. When undefined behavior occurs,
+your program might continue as if nothing bad has happened, but it also might
+mean your program is open to the worst kinds of exploits. In contrast, the
+worst thing a panic can do is a denial of service.
+
+[OSS-fuzz project]: https://android.googlesource.com/platform/external/oss-fuzz/+/refs/tags/android-t-preview-1/projects/rust-regex/
+[`std::panic::catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html
+
+### Untrusted patterns
+
+The principal way this crate deals with them is by limiting their size by
+default. The size limit can be configured via [`RegexBuilder::size_limit`]. The
+idea of a size limit is that compiling a pattern into a `Regex` will fail if it
+becomes "too big." Namely, while *most* resources consumed by compiling a regex
+are approximately proportional to the length of the pattern itself, there is
+one particular exception to this: counted repetitions. Namely, this pattern:
+
+```text
+a{5}{5}{5}{5}{5}{5}
+```
+
+Is equivalent to this pattern:
+
+```text
+a{15625}
+```
+
+In both of these cases, the actual pattern string is quite small, but the
+resulting `Regex` value is quite large. Indeed, as the first pattern shows,
+it isn't enough to locally limit the size of each repetition because they can
+be stacked in a way that results in exponential growth.
+
+To provide a bit more context, a simplified view of regex compilation looks
+like this:
+
+* The pattern string is parsed into a structured representation called an HIR
+(high-level intermediate representation). Counted repetitions are not expanded
+in this stage. That is, the size of the HIR is proportional to the size
+of the pattern with "reasonable" constant factors. In other words, one can
+reasonably limit the memory used by an HIR by limiting the length of the
+pattern string.
+* The HIR is compiled into a [Thompson NFA]. This is the stage at which
+something like `\w{5}` is rewritten to `\w\w\w\w\w`. Thus, this is the stage
+at which [`RegexBuilder::size_limit`] is enforced. If the NFA exceeds the
+configured size, then this stage will fail.
+
+[Thompson NFA]: https://en.wikipedia.org/wiki/Thompson%27s_construction
+
+The size limit helps avoid two different kinds of exorbitant resource usage:
+
+* It avoids permitting exponential memory usage based on the size of the
+pattern string.
+* It avoids long search times. This will be discussed in more detail in the
+next section, but worst case search time *is* dependent on the size of the
+regex. So keeping regexes limited to a reasonable size is also a way of keeping
+search times reasonable.
+
+Finally, it's worth pointing out that regex compilation is guaranteed to take
+worst case `O(m)` time, where `m` is proportional to the size of regex. The
+size of the regex here is *after* the counted repetitions have been expanded.
+
+**Advice for those using untrusted regexes**: limit the pattern length to
+something small and expand it as needed. Configure [`RegexBuilder::size_limit`]
+to something small and then expand it as needed.
+
+### Untrusted haystacks
+
+The main way this crate guards against searches from taking a long time is by
+using algorithms that guarantee a `O(m * n)` worst case time and space bound.
+Namely:
+
+* `m` is proportional to the size of the regex, where the size of the regex
+includes the expansion of all counted repetitions. (See the previous section on
+untrusted patterns.)
+* `n` is proportional to the length, in bytes, of the haystack.
+
+In other words, if you consider `m` to be a constant (for example, the regex
+pattern is a literal in the source code), then the search can be said to run
+in "linear time." Or equivalently, "linear time with respect to the size of the
+haystack."
+
+But the `m` factor here is important not to ignore. If a regex is
+particularly big, the search times can get quite slow. This is why, in part,
+[`RegexBuilder::size_limit`] exists.
+
+**Advice for those searching untrusted haystacks**: As long as your regexes
+are not enormous, you should expect to be able to search untrusted haystacks
+without fear. If you aren't sure, you should benchmark it. Unlike backtracking
+engines, if your regex is so big that it's likely to result in slow searches,
+this is probably something you'll be able to observe regardless of what the
+haystack is made up of.
+
+### Iterating over matches
+
+One thing that is perhaps easy to miss is that the worst case time
+complexity bound of `O(m * n)` applies to methods like [`Regex::is_match`],
+[`Regex::find`] and [`Regex::captures`]. It does **not** apply to
+[`Regex::find_iter`] or [`Regex::captures_iter`]. Namely, since iterating over
+all matches can execute many searches, and each search can scan the entire
+haystack, the worst case time complexity for iterators is `O(m * n^2)`.
+
+One example of where this occurs is when a pattern consists of an alternation,
+where an earlier branch of the alternation requires scanning the entire
+haystack only to discover that there is no match. It also requires a later
+branch of the alternation to have matched at the beginning of the search. For
+example, consider the pattern `.*[^A-Z]|[A-Z]` and the haystack `AAAAA`. The
+first search will scan to the end looking for matches of `.*[^A-Z]` even though
+a finite automata engine (as in this crate) knows that `[A-Z]` has already
+matched the first character of the haystack. This is due to the greedy nature
+of regex searching. That first search will report a match at the first `A` only
+after scanning to the end to discover that no other match exists. The next
+search then begins at the second `A` and the behavior repeats.
+
+There is no way to avoid this. This means that if both patterns and haystacks
+are untrusted and you're iterating over all matches, you're susceptible
+to worst case quadratic time complexity. One possible way to mitigate
+this is to switch to the lower level `regex-automata` crate and use its
+`meta::Regex` iterator APIs. There, you can configure the search to operate
+in "earliest" mode by passing a `Input::new(haystack).earliest(true)` to
+`meta::Regex::find_iter` (for example). By enabling this mode, you give up
+the normal greedy match semantics of regex searches and instead ask the regex
+engine to immediately stop as soon as a match has been found. Enabling this
+mode will thus restore the worst case `O(m * n)` time complexity bound, but at
+the cost of different semantics.
+
+### Untrusted inputs in practice
+
+While providing a `O(m * n)` worst case time bound on all searches goes a long
+way toward preventing [ReDoS], that doesn't mean every search you can possibly
+run will complete without burning CPU time. In general, there are a few ways
+for the `m * n` time bound to still bite you:
+
+* You are searching an exceptionally long haystack. No matter how you slice
+it, a longer haystack will take more time to search.
+* Very large regexes can searches to be quite slow due to increasing the size
+`m` in the worst case `O(m * n)` bound. This is especially true when they
+are combined with counted repetitions. While the regex size limit above will
+protect you from the most egregious cases, the the default size limit still
+permits pretty big regexes that can execute more slowly than one might expect.
+* While routines like [`Regex::find`] and [`Regex::captures`] guarantee
+worst case `O(m * n)` search time, routines like [`Regex::find_iter`] and
+[`Regex::captures_iter`] actually have worst case `O(m * n^2)` search time.
+This is because `find_iter` runs many searches, and each search takes worst
+case `O(m * n)` time. Thus, iteration of all matches in a haystack has
+worst case `O(m * n^2)`. A good example of a pattern that exhibits this is
+`(?:A+){1000}|` or even `.*[^A-Z]|[A-Z]`.
+
+In general, unstrusted haystacks are easier to stomach than untrusted patterns.
+Untrusted patterns give a lot more control to the caller to impact the
+performance of a search. Therefore, permitting untrusted patterns means that
+your only line of defense is to put a limit on how big `m` (and perhaps also
+`n`) can be in `O(m * n)`. `n` is limited by simply inspecting the length
+of the haystack while `m` is limited by *both* applying a limit to the
+length of the pattern *and* a limit on the compiled size of the regex via
+[`RegexBuilder::size_limit`].
+
+It bears repeating: if you're accepting untrusted patterns, it would be a good
+idea to start with conservative limits on `m` and `n`, and then carefully
+increase them as needed.
+*/
+
+#![no_std]
+// I'm not ideologically opposed to allowing non-safe code in this crate, but
+// IMO it needs really excellent justification. One likely place where this
+// could show up is if and when we support a non-std alloc mode. In that case,
+// we need some way to synchronize access to a PikeVM cache. That in turn will
+// likely require rolling our own primitive spin-lock or similar structure.
+#![forbid(unsafe_code)]
+#![deny(missing_docs, rustdoc::broken_intra_doc_links)]
+#![warn(missing_debug_implementations)]
+// When the main features are disabled, squash dead code warnings. The
+// alternative is to litter conditional compilation directives everywhere,
+// which is super annoying.
+#![cfg_attr(not(feature = "string"), allow(dead_code))]
+
+#[cfg(not(feature = "std"))]
+compile_error!("'std' is currently a required feature, please file an issue");
+
+#[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
+compile_error!("not supported on non-{32,64}, please file an issue");
+
+extern crate alloc;
+#[cfg(any(test, feature = "std"))]
+extern crate std;
+
+#[cfg(feature = "string")]
+pub use self::string::*;
+pub use self::{error::Error, hir::escape};
+
+mod error;
+mod hir;
+mod int;
+mod interpolate;
+mod nfa;
+mod pikevm;
+mod pool;
+#[cfg(feature = "string")]
+mod string;
+mod utf8;
diff --git a/regex-lite/src/nfa.rs b/regex-lite/src/nfa.rs
new file mode 100644
index 0000000000..12404dab61
--- /dev/null
+++ b/regex-lite/src/nfa.rs
@@ -0,0 +1,713 @@
+use core::{cell::RefCell, mem::size_of};
+
+use alloc::{string::String, sync::Arc, vec, vec::Vec};
+
+use crate::{
+    error::Error,
+    hir::{self, Hir, HirKind},
+    int::U32,
+};
+
+pub(crate) type StateID = u32;
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Config {
+    pub(crate) size_limit: Option<usize>,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config { size_limit: Some(10 * (1 << 20)) }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct NFA {
+    /// The pattern string this NFA was generated from.
+    ///
+    /// We put it here for lack of a better place to put it. ¯\_(ツ)_/¯
+    pattern: String,
+    /// The states that make up this NFA.
+    states: Vec<State>,
+    /// The ID of the start state.
+    start: StateID,
+    /// Whether this NFA can only match at the beginning of a haystack.
+    is_start_anchored: bool,
+    /// Whether this NFA can match the empty string.
+    is_match_empty: bool,
+    /// If every match has the same number of matching capture groups, then
+    /// this corresponds to the number of groups.
+    static_explicit_captures_len: Option<usize>,
+    /// A map from capture group name to its corresponding index.
+    cap_name_to_index: CaptureNameMap,
+    /// A map from capture group index to the corresponding name, if one
+    /// exists.
+    cap_index_to_name: Vec<Option<Arc<str>>>,
+    /// Heap memory used indirectly by NFA states and other things (like the
+    /// various capturing group representations above). Since each state
+    /// might use a different amount of heap, we need to keep track of this
+    /// incrementally.
+    memory_extra: usize,
+}
+
+impl NFA {
+    /// Creates a new NFA from the given configuration and HIR.
+    pub(crate) fn new(
+        config: Config,
+        pattern: String,
+        hir: &Hir,
+    ) -> Result<NFA, Error> {
+        Compiler::new(config, pattern).compile(hir)
+    }
+
+    /// Returns the pattern string used to construct this NFA.
+    pub(crate) fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Returns the state corresponding to the given ID.
+    ///
+    /// # Panics
+    ///
+    /// If the ID does not refer to a valid state, then this panics.
+    pub(crate) fn state(&self, id: StateID) -> &State {
+        &self.states[id.as_usize()]
+    }
+
+    /// Returns the total number of states in this NFA.
+    pub(crate) fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    /// Returns the ID of the starting state for this NFA.
+    pub(crate) fn start(&self) -> StateID {
+        self.start
+    }
+
+    /// Returns the capture group index for the corresponding named group.
+    /// If no such group with the given name exists, then `None` is returned.
+    pub(crate) fn to_index(&self, name: &str) -> Option<usize> {
+        self.cap_name_to_index.get(name).cloned().map(|i| i.as_usize())
+    }
+
+    /*
+    /// Returns the capture group name for the corresponding index.
+    /// If no such group with the given index, then `None` is returned.
+    pub(crate) fn to_name(&self, index: usize) -> Option<&str> {
+        self.cap_index_to_name.get(index)?.as_deref()
+    }
+    */
+
+    /// Returns an iterator over all of the capture groups, along with their
+    /// names if they exist, in this NFA.
+    pub(crate) fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames { it: self.cap_index_to_name.iter() }
+    }
+
+    /// Returns the total number of capture groups, including the first and
+    /// implicit group, in this NFA.
+    pub(crate) fn group_len(&self) -> usize {
+        self.cap_index_to_name.len()
+    }
+
+    /// Returns true if and only if this NFA can only match at the beginning of
+    /// a haystack.
+    pub(crate) fn is_start_anchored(&self) -> bool {
+        self.is_start_anchored
+    }
+
+    /// If the pattern always reports the same number of matching capture groups
+    /// for every match, then this returns the number of those groups. This
+    /// doesn't include the implicit group found in every pattern.
+    pub(crate) fn static_explicit_captures_len(&self) -> Option<usize> {
+        self.static_explicit_captures_len
+    }
+
+    /// Returns the heap memory usage, in bytes, used by this NFA.
+    fn memory_usage(&self) -> usize {
+        (self.states.len() * size_of::<State>())
+            + (self.cap_index_to_name.len() * size_of::<Option<Arc<str>>>())
+            + self.memory_extra
+    }
+}
+
+impl core::fmt::Debug for NFA {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        writeln!(f, "NFA(")?;
+        writeln!(f, "pattern: {}", self.pattern)?;
+        for (sid, state) in self.states.iter().enumerate() {
+            writeln!(f, "{:07?}: {:?}", sid, state)?;
+        }
+        writeln!(f, ")")?;
+        Ok(())
+    }
+}
+
+/// An iterator over all capture groups in an NFA.
+///
+/// If a particular group has a name, then it is yielded. Otherwise, `None`
+/// is yielded.
+#[derive(Clone, Debug)]
+pub(crate) struct CaptureNames<'a> {
+    it: core::slice::Iter<'a, Option<Arc<str>>>,
+}
+
+impl<'a> Iterator for CaptureNames<'a> {
+    type Item = Option<&'a str>;
+
+    fn next(&mut self) -> Option<Option<&'a str>> {
+        self.it.next().map(|n| n.as_deref())
+    }
+}
+
+#[derive(Clone, Eq, PartialEq)]
+pub(crate) enum State {
+    Char { target: StateID, ch: char },
+    Ranges { target: StateID, ranges: Vec<(char, char)> },
+    Splits { targets: Vec<StateID>, reverse: bool },
+    Goto { target: StateID, look: Option<hir::Look> },
+    Capture { target: StateID, slot: u32 },
+    Fail,
+    Match,
+}
+
+impl State {
+    /// Returns the heap memory usage of this NFA state in bytes.
+    fn memory_usage(&self) -> usize {
+        match *self {
+            State::Char { .. }
+            | State::Goto { .. }
+            | State::Capture { .. }
+            | State::Fail { .. }
+            | State::Match => 0,
+            State::Splits { ref targets, .. } => {
+                targets.len() * size_of::<StateID>()
+            }
+            State::Ranges { ref ranges, .. } => {
+                ranges.len() * size_of::<(char, char)>()
+            }
+        }
+    }
+
+    /// Returns an iterator over the given split targets. The order of the
+    /// iterator yields elements in reverse when `reverse` is true.
+    pub(crate) fn iter_splits<'a>(
+        splits: &'a [StateID],
+        reverse: bool,
+    ) -> impl Iterator<Item = StateID> + 'a {
+        let mut it = splits.iter();
+        core::iter::from_fn(move || {
+            if reverse { it.next_back() } else { it.next() }.copied()
+        })
+    }
+}
+
+impl core::fmt::Debug for State {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            State::Char { target, ch } => {
+                write!(f, "{:?} => {:?}", ch, target)
+            }
+            State::Ranges { target, ref ranges } => {
+                for (i, &(start, end)) in ranges.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{:?}-{:?} => {:?}", start, end, target)?;
+                }
+                Ok(())
+            }
+            State::Splits { ref targets, reverse } => {
+                write!(f, "splits(")?;
+                for (i, sid) in
+                    State::iter_splits(targets, reverse).enumerate()
+                {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{:?}", sid)?;
+                }
+                write!(f, ")")
+            }
+            State::Goto { target, look: None } => {
+                write!(f, "goto({:?})", target)
+            }
+            State::Goto { target, look: Some(look) } => {
+                write!(f, "{:?} => {:?}", look, target)
+            }
+            State::Capture { target, slot } => {
+                write!(f, "capture(slot={:?}) => {:?}", slot, target,)
+            }
+            State::Fail => write!(f, "FAIL"),
+            State::Match => {
+                write!(f, "MATCH")
+            }
+        }
+    }
+}
+
+/// A map from capture group name to its corresponding capture group index.
+///
+/// We define a type alias here so that we can transparently use a `HashMap`
+/// whenever it's available. We do so presumably because it's faster, although
+/// there are no benchmarks verifying this.
+#[cfg(feature = "std")]
+type CaptureNameMap = std::collections::HashMap<Arc<str>, u32>;
+#[cfg(not(feature = "std"))]
+type CaptureNameMap = alloc::collections::BTreeMap<Arc<str>, u32>;
+
+#[derive(Debug)]
+struct Compiler {
+    config: Config,
+    nfa: RefCell<NFA>,
+}
+
+impl Compiler {
+    fn new(config: Config, pattern: String) -> Compiler {
+        let nfa = RefCell::new(NFA {
+            pattern,
+            states: vec![],
+            start: 0,
+            is_start_anchored: false,
+            is_match_empty: false,
+            static_explicit_captures_len: None,
+            cap_name_to_index: CaptureNameMap::default(),
+            cap_index_to_name: vec![],
+            memory_extra: 0,
+        });
+        Compiler { config, nfa }
+    }
+
+    fn compile(self, hir: &Hir) -> Result<NFA, Error> {
+        self.nfa.borrow_mut().is_start_anchored = hir.is_start_anchored();
+        self.nfa.borrow_mut().is_match_empty = hir.is_match_empty();
+        self.nfa.borrow_mut().static_explicit_captures_len =
+            hir.static_explicit_captures_len();
+        let compiled = self.c_capture(0, None, hir)?;
+        let mat = self.add(State::Match)?;
+        self.patch(compiled.end, mat)?;
+        self.nfa.borrow_mut().start = compiled.start;
+        Ok(self.nfa.into_inner())
+    }
+
+    fn c(&self, hir: &Hir) -> Result<ThompsonRef, Error> {
+        match *hir.kind() {
+            HirKind::Empty => self.c_empty(),
+            HirKind::Char(ch) => self.c_char(ch),
+            HirKind::Class(ref class) => self.c_class(class),
+            HirKind::Look(ref look) => self.c_look(look),
+            HirKind::Repetition(ref rep) => self.c_repetition(rep),
+            HirKind::Capture(ref cap) => {
+                self.c_capture(cap.index, cap.name.as_deref(), &cap.sub)
+            }
+            HirKind::Concat(ref subs) => {
+                self.c_concat(subs.iter().map(|s| self.c(s)))
+            }
+            HirKind::Alternation(ref subs) => {
+                self.c_alternation(subs.iter().map(|s| self.c(s)))
+            }
+        }
+    }
+
+    /// Compile a "fail" state that can never be transitioned out of.
+    fn c_fail(&self) -> Result<ThompsonRef, Error> {
+        let id = self.add(State::Fail)?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile an "empty" state with one unconditional epsilon transition.
+    ///
+    /// Both the `start` and `end` locations point to the state created.
+    /// Callers will likely want to keep the `start`, but patch the `end` to
+    /// point to some other state.
+    fn c_empty(&self) -> Result<ThompsonRef, Error> {
+        let id = self.add_empty()?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile the given literal char to an NFA.
+    fn c_char(&self, ch: char) -> Result<ThompsonRef, Error> {
+        let id = self.add(State::Char { target: 0, ch })?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile the given character class into an NFA.
+    ///
+    /// If the class is empty, then this compiles to a `Fail` state.
+    fn c_class(&self, class: &hir::Class) -> Result<ThompsonRef, Error> {
+        let id = if class.ranges.is_empty() {
+            // Technically using an explicit fail state probably isn't
+            // necessary. Because if you try to match against an empty Ranges,
+            // then it should turn up with nothing regardless of input, and
+            // thus "acts" like a Fail state. But it's better to be more
+            // explicit, and there's no real cost to doing so.
+            self.add(State::Fail)
+        } else {
+            let ranges =
+                class.ranges.iter().map(|r| (r.start, r.end)).collect();
+            self.add(State::Ranges { target: 0, ranges })
+        }?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile the given HIR look-around assertion to an NFA look-around
+    /// assertion.
+    fn c_look(&self, look: &hir::Look) -> Result<ThompsonRef, Error> {
+        let id = self.add(State::Goto { target: 0, look: Some(*look) })?;
+        Ok(ThompsonRef { start: id, end: id })
+    }
+
+    /// Compile the given repetition expression. This handles all types of
+    /// repetitions and greediness.
+    fn c_repetition(
+        &self,
+        rep: &hir::Repetition,
+    ) -> Result<ThompsonRef, Error> {
+        match (rep.min, rep.max) {
+            (0, Some(1)) => self.c_zero_or_one(&rep.sub, rep.greedy),
+            (min, None) => self.c_at_least(&rep.sub, rep.greedy, min),
+            (min, Some(max)) if min == max => self.c_exactly(&rep.sub, min),
+            (min, Some(max)) => self.c_bounded(&rep.sub, rep.greedy, min, max),
+        }
+    }
+
+    /// Compile the given expression such that it matches at least `min` times,
+    /// but no more than `max` times.
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_bounded(
+        &self,
+        hir: &Hir,
+        greedy: bool,
+        min: u32,
+        max: u32,
+    ) -> Result<ThompsonRef, Error> {
+        let prefix = self.c_exactly(hir, min)?;
+        if min == max {
+            return Ok(prefix);
+        }
+
+        // It is tempting here to compile the rest here as a concatenation
+        // of zero-or-one matches. i.e., for `a{2,5}`, compile it as if it
+        // were `aaa?a?a?`. The problem here is that it leads to this program:
+        //
+        //     >000000: 61 => 01
+        //      000001: 61 => 02
+        //      000002: union(03, 04)
+        //      000003: 61 => 04
+        //      000004: union(05, 06)
+        //      000005: 61 => 06
+        //      000006: union(07, 08)
+        //      000007: 61 => 08
+        //      000008: MATCH
+        //
+        // And effectively, once you hit state 2, the epsilon closure will
+        // include states 3, 5, 6, 7 and 8, which is quite a bit. It is better
+        // to instead compile it like so:
+        //
+        //     >000000: 61 => 01
+        //      000001: 61 => 02
+        //      000002: union(03, 08)
+        //      000003: 61 => 04
+        //      000004: union(05, 08)
+        //      000005: 61 => 06
+        //      000006: union(07, 08)
+        //      000007: 61 => 08
+        //      000008: MATCH
+        //
+        // So that the epsilon closure of state 2 is now just 3 and 8.
+        let empty = self.add_empty()?;
+        let mut prev_end = prefix.end;
+        for _ in min..max {
+            let splits =
+                self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+            let compiled = self.c(hir)?;
+            self.patch(prev_end, splits)?;
+            self.patch(splits, compiled.start)?;
+            self.patch(splits, empty)?;
+            prev_end = compiled.end;
+        }
+        self.patch(prev_end, empty)?;
+        Ok(ThompsonRef { start: prefix.start, end: empty })
+    }
+
+    /// Compile the given expression such that it may be matched `n` or more
+    /// times, where `n` can be any integer. (Although a particularly large
+    /// integer is likely to run afoul of any configured size limits.)
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_at_least(
+        &self,
+        hir: &Hir,
+        greedy: bool,
+        n: u32,
+    ) -> Result<ThompsonRef, Error> {
+        if n == 0 {
+            // When the expression cannot match the empty string, then we
+            // can get away with something much simpler: just one 'alt'
+            // instruction that optionally repeats itself. But if the expr
+            // can match the empty string... see below.
+            if !hir.is_match_empty() {
+                let splits = self.add(State::Splits {
+                    targets: vec![],
+                    reverse: !greedy,
+                })?;
+                let compiled = self.c(hir)?;
+                self.patch(splits, compiled.start)?;
+                self.patch(compiled.end, splits)?;
+                return Ok(ThompsonRef { start: splits, end: splits });
+            }
+
+            // What's going on here? Shouldn't x* be simpler than this? It
+            // turns out that when implementing leftmost-first (Perl-like)
+            // match semantics, x* results in an incorrect preference order
+            // when computing the transitive closure of states if and only if
+            // 'x' can match the empty string. So instead, we compile x* as
+            // (x+)?, which preserves the correct preference order.
+            //
+            // See: https://github.com/rust-lang/regex/issues/779
+            let compiled = self.c(hir)?;
+            let plus =
+                self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+            self.patch(compiled.end, plus)?;
+            self.patch(plus, compiled.start)?;
+
+            let question =
+                self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+            let empty = self.add_empty()?;
+            self.patch(question, compiled.start)?;
+            self.patch(question, empty)?;
+            self.patch(plus, empty)?;
+            Ok(ThompsonRef { start: question, end: empty })
+        } else if n == 1 {
+            let compiled = self.c(hir)?;
+            let splits =
+                self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+            self.patch(compiled.end, splits)?;
+            self.patch(splits, compiled.start)?;
+            Ok(ThompsonRef { start: compiled.start, end: splits })
+        } else {
+            let prefix = self.c_exactly(hir, n - 1)?;
+            let last = self.c(hir)?;
+            let splits =
+                self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+            self.patch(prefix.end, last.start)?;
+            self.patch(last.end, splits)?;
+            self.patch(splits, last.start)?;
+            Ok(ThompsonRef { start: prefix.start, end: splits })
+        }
+    }
+
+    /// Compile the given expression such that it may be matched zero or one
+    /// times.
+    ///
+    /// When `greedy` is true, then the preference is for the expression to
+    /// match as much as possible. Otheriwse, it will match as little as
+    /// possible.
+    fn c_zero_or_one(
+        &self,
+        hir: &Hir,
+        greedy: bool,
+    ) -> Result<ThompsonRef, Error> {
+        let splits =
+            self.add(State::Splits { targets: vec![], reverse: !greedy })?;
+        let compiled = self.c(hir)?;
+        let empty = self.add_empty()?;
+        self.patch(splits, compiled.start)?;
+        self.patch(splits, empty)?;
+        self.patch(compiled.end, empty)?;
+        Ok(ThompsonRef { start: splits, end: empty })
+    }
+
+    /// Compile the given HIR expression exactly `n` times.
+    fn c_exactly(&self, hir: &Hir, n: u32) -> Result<ThompsonRef, Error> {
+        self.c_concat((0..n).map(|_| self.c(hir)))
+    }
+
+    /// Compile the given expression and insert capturing states at the
+    /// beginning and end of it. The slot for the capture states is computed
+    /// from the index.
+    fn c_capture(
+        &self,
+        index: u32,
+        name: Option<&str>,
+        hir: &Hir,
+    ) -> Result<ThompsonRef, Error> {
+        // For discontiguous indices, push placeholders for earlier capture
+        // groups that weren't explicitly added. This can happen, for example,
+        // with patterns like '(a){0}(a)' where '(a){0}' is completely removed
+        // from the pattern.
+        let existing_groups_len = self.nfa.borrow().cap_index_to_name.len();
+        for _ in 0..(index.as_usize().saturating_sub(existing_groups_len)) {
+            self.nfa.borrow_mut().cap_index_to_name.push(None);
+        }
+        if index.as_usize() >= existing_groups_len {
+            if let Some(name) = name {
+                let name = Arc::from(name);
+                let mut nfa = self.nfa.borrow_mut();
+                nfa.cap_name_to_index.insert(Arc::clone(&name), index);
+                nfa.cap_index_to_name.push(Some(Arc::clone(&name)));
+                // This is an approximation.
+                nfa.memory_extra += name.len() + size_of::<u32>();
+            } else {
+                self.nfa.borrow_mut().cap_index_to_name.push(None);
+            }
+        }
+
+        let Some(slot) = index.checked_mul(2) else {
+            return Err(Error::new("capture group slots exhausted"));
+        };
+        let start = self.add(State::Capture { target: 0, slot })?;
+        let inner = self.c(hir)?;
+        let Some(slot) = slot.checked_add(1) else {
+            return Err(Error::new("capture group slots exhausted"));
+        };
+        let end = self.add(State::Capture { target: 0, slot })?;
+        self.patch(start, inner.start)?;
+        self.patch(inner.end, end)?;
+
+        Ok(ThompsonRef { start, end })
+    }
+
+    /// Compile a concatenation of the sub-expressions yielded by the given
+    /// iterator. If the iterator yields no elements, then this compiles down
+    /// to an "empty" state that always matches.
+    fn c_concat<I>(&self, mut it: I) -> Result<ThompsonRef, Error>
+    where
+        I: Iterator<Item = Result<ThompsonRef, Error>>,
+    {
+        let ThompsonRef { start, mut end } = match it.next() {
+            Some(result) => result?,
+            None => return self.c_empty(),
+        };
+        for result in it {
+            let compiled = result?;
+            self.patch(end, compiled.start)?;
+            end = compiled.end;
+        }
+        Ok(ThompsonRef { start, end })
+    }
+
+    /// Compile an alternation, where each element yielded by the given
+    /// iterator represents an item in the alternation. If the iterator yields
+    /// no elements, then this compiles down to a "fail" state.
+    ///
+    /// In an alternation, expressions appearing earlier are "preferred" at
+    /// match time over expressions appearing later. (This is currently always
+    /// true, as this crate only supports leftmost-first semantics.)
+    fn c_alternation<I>(&self, mut it: I) -> Result<ThompsonRef, Error>
+    where
+        I: Iterator<Item = Result<ThompsonRef, Error>>,
+    {
+        let first = match it.next() {
+            None => return self.c_fail(),
+            Some(result) => result?,
+        };
+        let second = match it.next() {
+            None => return Ok(first),
+            Some(result) => result?,
+        };
+
+        let splits =
+            self.add(State::Splits { targets: vec![], reverse: false })?;
+        let end = self.add_empty()?;
+        self.patch(splits, first.start)?;
+        self.patch(first.end, end)?;
+        self.patch(splits, second.start)?;
+        self.patch(second.end, end)?;
+        for result in it {
+            let compiled = result?;
+            self.patch(splits, compiled.start)?;
+            self.patch(compiled.end, end)?;
+        }
+        Ok(ThompsonRef { start: splits, end })
+    }
+
+    /// A convenience routine for adding an empty state, also known as an
+    /// unconditional epsilon transition. These are quite useful for making
+    /// NFA construction simpler.
+    ///
+    /// (In the regex crate, we do a second pass to remove these, but don't
+    /// bother with that here.)
+    fn add_empty(&self) -> Result<StateID, Error> {
+        self.add(State::Goto { target: 0, look: None })
+    }
+
+    /// The common implementation of "add a state." It handles the common
+    /// error cases of state ID exhausting (by owning state ID allocation) and
+    /// whether the size limit has been exceeded.
+    fn add(&self, state: State) -> Result<StateID, Error> {
+        let id = u32::try_from(self.nfa.borrow().states.len())
+            .map_err(|_| Error::new("exhausted state IDs, too many states"))?;
+        self.nfa.borrow_mut().memory_extra += state.memory_usage();
+        self.nfa.borrow_mut().states.push(state);
+        self.check_size_limit()?;
+        Ok(id)
+    }
+
+    /// Add a transition from one state to another.
+    ///
+    /// This routine is called "patch" since it is very common to add the
+    /// states you want, typically with "dummy" state ID transitions, and then
+    /// "patch" in the real state IDs later. This is because you don't always
+    /// know all of the necessary state IDs to add because they might not
+    /// exist yet.
+    ///
+    /// # Errors
+    ///
+    /// This may error if patching leads to an increase in heap usage beyond
+    /// the configured size limit. Heap usage only grows when patching adds a
+    /// new transition (as in the case of a "splits" state).
+    fn patch(&self, from: StateID, to: StateID) -> Result<(), Error> {
+        let mut new_memory_extra = self.nfa.borrow().memory_extra;
+        match self.nfa.borrow_mut().states[from.as_usize()] {
+            State::Char { ref mut target, .. } => {
+                *target = to;
+            }
+            State::Ranges { ref mut target, .. } => {
+                *target = to;
+            }
+            State::Splits { ref mut targets, .. } => {
+                targets.push(to);
+                new_memory_extra += size_of::<StateID>();
+            }
+            State::Goto { ref mut target, .. } => {
+                *target = to;
+            }
+            State::Capture { ref mut target, .. } => {
+                *target = to;
+            }
+            State::Fail | State::Match => {}
+        }
+        if new_memory_extra != self.nfa.borrow().memory_extra {
+            self.nfa.borrow_mut().memory_extra = new_memory_extra;
+            self.check_size_limit()?;
+        }
+        Ok(())
+    }
+
+    /// Checks that the current heap memory usage of the NFA being compiled
+    /// doesn't exceed the configured size limit. If it does, an error is
+    /// returned.
+    fn check_size_limit(&self) -> Result<(), Error> {
+        if let Some(limit) = self.config.size_limit {
+            if self.nfa.borrow().memory_usage() > limit {
+                return Err(Error::new("compiled regex exceeded size limit"));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// A value that represents the result of compiling a sub-expression of a
+/// regex's HIR. Specifically, this represents a sub-graph of the NFA that
+/// has an initial state at `start` and a final state at `end`.
+#[derive(Clone, Copy, Debug)]
+struct ThompsonRef {
+    start: StateID,
+    end: StateID,
+}
diff --git a/regex-lite/src/pikevm.rs b/regex-lite/src/pikevm.rs
new file mode 100644
index 0000000000..97b4505551
--- /dev/null
+++ b/regex-lite/src/pikevm.rs
@@ -0,0 +1,916 @@
+use alloc::{vec, vec::Vec};
+
+use crate::{
+    int::{NonMaxUsize, U32},
+    nfa::{State, StateID, NFA},
+    pool::CachePoolGuard,
+    utf8,
+};
+
+/// A PikeVM searcher.
+///
+/// A PikeVM uses the standard Thompson NFA linear time search algorithm, but
+/// augmented to support tracking the offsets of matching capture groups.
+#[derive(Clone, Debug)]
+pub(crate) struct PikeVM {
+    nfa: NFA,
+}
+
+impl PikeVM {
+    /// Create a new PikeVM searcher that uses the given NFA.
+    pub(crate) fn new(nfa: NFA) -> PikeVM {
+        PikeVM { nfa }
+    }
+
+    /// Return the underlying NFA used by this PikeVM.
+    pub(crate) fn nfa(&self) -> &NFA {
+        &self.nfa
+    }
+
+    /// Returns an iterator of non-overlapping matches in the given haystack.
+    pub(crate) fn find_iter<'r, 'h>(
+        &'r self,
+        cache: CachePoolGuard<'r>,
+        haystack: &'h [u8],
+    ) -> FindMatches<'r, 'h> {
+        FindMatches {
+            pikevm: self,
+            cache,
+            haystack,
+            at: 0,
+            slots: vec![None, None],
+            last_match_end: None,
+        }
+    }
+
+    /// Returns an iterator of non-overlapping capture matches in the given
+    /// haystack.
+    pub(crate) fn captures_iter<'r, 'h>(
+        &'r self,
+        cache: CachePoolGuard<'r>,
+        haystack: &'h [u8],
+    ) -> CapturesMatches<'r, 'h> {
+        // OK because the NFA wouldn't have compiled if this could overflow.
+        let len = self.nfa().group_len().checked_mul(2).unwrap();
+        CapturesMatches {
+            it: FindMatches {
+                pikevm: self,
+                cache,
+                haystack,
+                at: 0,
+                slots: vec![None; len],
+                last_match_end: None,
+            },
+        }
+    }
+
+    /// The implementation of standard leftmost search.
+    ///
+    /// Capturing group spans are written to `slots`, but only if requested.
+    /// `slots` can be any length. Any slot in the NFA that is activated but
+    /// which is out of bounds for the given `slots` is ignored.
+    pub(crate) fn search(
+        &self,
+        cache: &mut Cache,
+        haystack: &[u8],
+        start: usize,
+        end: usize,
+        earliest: bool,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> bool {
+        cache.setup_search(slots.len());
+        if start > end {
+            return false;
+        }
+        // Why do we even care about this? Well, in our `slots` representation,
+        // we use usize::MAX as a sentinel to indicate "no match." This isn't
+        // problematic so long as our haystack doesn't have a maximal length.
+        // Byte slices are guaranteed by Rust to have a length that fits into
+        // isize, and so this assert should always pass. But we put it here to
+        // make our assumption explicit.
+        assert!(
+            haystack.len() < core::usize::MAX,
+            "byte slice lengths must be less than usize MAX",
+        );
+
+        let Cache { ref mut stack, ref mut curr, ref mut next } = cache;
+        let start_id = self.nfa().start();
+        let anchored = self.nfa().is_start_anchored();
+        let mut matched = false;
+        // Yes, our search doesn't end at `end`, but includes it. This is
+        // necessary because matches are delayed by one byte. The delay is used
+        // to handle look-behind assertions. In the case of the PikeVM, the
+        // delay is implemented by not considering a match to exist until it
+        // is visited in `nexts`. Technically, we know a match exists in the
+        // previous iteration via `epsilon_closure`.
+        let mut at = start;
+        while at <= end {
+            // If we have no states left to visit, then there are some cases
+            // where we know we can quit early or even skip ahead.
+            if curr.set.is_empty() {
+                // We have a match so we can quit.
+                if matched {
+                    break;
+                }
+                // If we're running an anchored search and we've advanced
+                // beyond the start position with no other states to try, then
+                // we will never observe a match and thus can stop.
+                if anchored && at > start {
+                    break;
+                }
+            }
+            // Instead of using a hypothetical unanchored start state in the
+            // NFA (which doesn't exist, but we could add it), we actually
+            // always use its anchored starting state. As a result, when doing
+            // an unanchored search, we need to simulate our own '(?s:.)*?'
+            // prefix, to permit a match to appear anywhere.
+            //
+            // Now, we don't *have* to do things this way. We could create
+            // a proper unanchored start state in the NFA and do one
+            // `epsilon_closure` call from that starting state before the main
+            // loop here. And that is just as correct. However, it turns out to
+            // be slower than our approach here because it slightly increases
+            // the cost of processing each byte by requiring us to visit
+            // more NFA states to deal with the additional NFA states in the
+            // unanchored prefix. By simulating it explicitly here, we lower
+            // those costs substantially. The cost is itself small, but it adds
+            // up for large haystacks.
+            //
+            // In order to simulate the '(?s:.)*?' prefix---which is not
+            // greedy---we are careful not to perform an epsilon closure on
+            // the start state if we already have a match. Namely, if we
+            // did otherwise, we would never reach a terminating condition
+            // because there would always be additional states to process.
+            if !matched {
+                // Since we are adding to the 'curr' active states and since
+                // this is for the start ID, we use a slots slice that is
+                // guaranteed to have the right length but where every element
+                // is absent. This is exactly what we want, because this
+                // epsilon closure is responsible for simulating an unanchored
+                // '(?s:.)*?' prefix. It is specifically outside of any
+                // capturing groups, and thus, using slots that are always
+                // absent is correct.
+                //
+                // Note though that we can't just use `&mut []` here, since
+                // this epsilon closure may traverse through `Capture` states
+                // transitions, and thus must be able to write offsets to the
+                // slots given which are later copied to slot values in `curr`.
+                let slots = next.slot_table.all_absent();
+                self.epsilon_closure(
+                    stack, slots, curr, haystack, at, start_id,
+                );
+            }
+            let (ch, len) = utf8::decode_lossy(&haystack[at..]);
+            if self.nexts(stack, curr, next, haystack, at, ch, len, slots) {
+                matched = true;
+            }
+            // Unless the caller asked us to return early, we need to mush
+            // on to see if we can extend our match. (But note that 'nexts'
+            // will quit right after seeing a match, as is consistent with
+            // leftmost-first match priority.)
+            if (earliest && matched) || len == 0 {
+                break;
+            }
+            core::mem::swap(curr, next);
+            next.set.clear();
+            at += len;
+        }
+        matched
+    }
+
+    /// Process the active states in 'curr' to find the states (written to
+    /// 'next') we should process for the next byte in the haystack.
+    ///
+    /// 'stack' is used to perform a depth first traversal of the NFA when
+    /// computing an epsilon closure.
+    ///
+    /// When a match is found, the slots for that match state (in 'curr') are
+    /// copied to 'caps'. Moreover, once a match is seen, processing for 'curr'
+    /// stops (unless the PikeVM was configured with MatchKind::All semantics).
+    ///
+    /// `at_ch` is the Unicode scalar value whose UTF-8 encoding begins at `at`
+    /// in `haystack`.
+    ///
+    /// `at_len` is the number of bytes consumed by `at_ch`. This is usually
+    /// equal to `at_ch.len_utf8()`, but not always. For example, in the case
+    /// where `at_ch` is the replacement codepoint that results from decoding
+    /// invalid UTF-8. In that case, `at_len` can be 1, 2 or 3.
+    fn nexts(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr: &mut ActiveStates,
+        next: &mut ActiveStates,
+        haystack: &[u8],
+        at: usize,
+        at_ch: char,
+        at_len: usize,
+        slots: &mut [Option<NonMaxUsize>],
+    ) -> bool {
+        let ActiveStates { ref set, ref mut slot_table } = *curr;
+        for sid in set.iter() {
+            if self.next(
+                stack, slot_table, next, haystack, at, at_ch, at_len, sid,
+            ) {
+                slots.copy_from_slice(slot_table.for_state(sid));
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Starting from `sid`, if the position `at` in the `haystack` has a
+    /// transition defined out of `sid`, then add the state transitioned to and
+    /// its epsilon closure to the `next` set of states to explore.
+    ///
+    /// `stack` is used by the epsilon closure computation to perform a depth
+    /// first traversal of the NFA.
+    ///
+    /// `curr_slot_table` should be the table of slots for the current set of
+    /// states being explored. If there is a transition out of `sid`, then
+    /// sid's row in the slot table is used to perform the epsilon closure.
+    ///
+    /// `at_ch` is the Unicode scalar value whose UTF-8 encoding begins at `at`
+    /// in `haystack`. The caller provides it so that this routine doesn't
+    /// need to re-decode it. (Since it's expected that this routine is called
+    /// multiple times for each position.)
+    ///
+    /// `at_len` is the number of bytes consumed by `at_ch`. This is usually
+    /// equal to `at_ch.len_utf8()`, but not always. For example, in the case
+    /// where `at_ch` is the replacement codepoint that results from decoding
+    /// invalid UTF-8. In that case, `at_len` can be 1, 2 or 3.
+    fn next(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slot_table: &mut SlotTable,
+        next: &mut ActiveStates,
+        haystack: &[u8],
+        at: usize,
+        at_ch: char,
+        at_len: usize,
+        sid: StateID,
+    ) -> bool {
+        match *self.nfa.state(sid) {
+            State::Fail
+            | State::Goto { .. }
+            | State::Splits { .. }
+            | State::Capture { .. } => false,
+            State::Char { target, ch } => {
+                if at_ch == ch && at_len > 0 {
+                    let slots = curr_slot_table.for_state(sid);
+                    // OK because `at_len` is always derived from the number
+                    // of bytes read from `at` that make up `at_ch`. So this
+                    // will never wrap.
+                    let at = at.wrapping_add(at_len);
+                    self.epsilon_closure(
+                        stack, slots, next, haystack, at, target,
+                    );
+                }
+                false
+            }
+            State::Ranges { target, ref ranges } => {
+                for (start, end) in ranges.iter().copied() {
+                    if start > at_ch {
+                        break;
+                    } else if start <= at_ch && at_ch <= end {
+                        if at_len == 0 {
+                            return false;
+                        }
+                        let slots = curr_slot_table.for_state(sid);
+                        // OK because `at_len` is always derived from the
+                        // number of bytes read from `at` that make up `at_ch`.
+                        // So this will never wrap.
+                        let at = at.wrapping_add(at_len);
+                        self.epsilon_closure(
+                            stack, slots, next, haystack, at, target,
+                        );
+                    }
+                }
+                false
+            }
+            State::Match => true,
+        }
+    }
+
+    /// Compute the epsilon closure of `sid`, writing the closure into `next`
+    /// while copying slot values from `curr_slots` into corresponding states
+    /// in `next`. `curr_slots` should be the slot values corresponding to
+    /// `sid`.
+    ///
+    /// The given `stack` is used to perform a depth first traversal of the
+    /// NFA by recursively following all epsilon transitions out of `sid`.
+    /// Conditional epsilon transitions are followed if and only if they are
+    /// satisfied for the position `at` in the `input` haystack.
+    ///
+    /// While this routine may write to `curr_slots`, once it returns, any
+    /// writes are undone and the original values (even if absent) are
+    /// restored.
+    fn epsilon_closure(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slots: &mut [Option<NonMaxUsize>],
+        next: &mut ActiveStates,
+        haystack: &[u8],
+        at: usize,
+        sid: StateID,
+    ) {
+        stack.push(FollowEpsilon::Explore(sid));
+        while let Some(frame) = stack.pop() {
+            match frame {
+                FollowEpsilon::RestoreCapture { slot, offset } => {
+                    curr_slots[slot.as_usize()] = offset;
+                }
+                FollowEpsilon::Explore(sid) => {
+                    self.epsilon_closure_explore(
+                        stack, curr_slots, next, haystack, at, sid,
+                    );
+                }
+            }
+        }
+    }
+
+    /// Explore all of the epsilon transitions out of `sid`. This is mostly
+    /// split out from `epsilon_closure` in order to clearly delineate
+    /// the actual work of computing an epsilon closure from the stack
+    /// book-keeping.
+    ///
+    /// This will push any additional explorations needed on to `stack`.
+    ///
+    /// `curr_slots` should refer to the slots for the currently active NFA
+    /// state. That is, the current state we are stepping through. These
+    /// slots are mutated in place as new `Captures` states are traversed
+    /// during epsilon closure, but the slots are restored to their original
+    /// values once the full epsilon closure is completed. The ultimate use of
+    /// `curr_slots` is to copy them to the corresponding `next_slots`, so that
+    /// the capturing group spans are forwarded from the currently active state
+    /// to the next.
+    ///
+    /// `next` refers to the next set of active states. Computing an epsilon
+    /// closure may increase the next set of active states.
+    ///
+    /// `haystack` refers to the what we're searching and `at` refers to the
+    /// current position in the haystack. These are used to check whether
+    /// conditional epsilon transitions (like look-around) are satisfied at
+    /// the current position. If they aren't, then the epsilon closure won't
+    /// include them.
+    fn epsilon_closure_explore(
+        &self,
+        stack: &mut Vec<FollowEpsilon>,
+        curr_slots: &mut [Option<NonMaxUsize>],
+        next: &mut ActiveStates,
+        haystack: &[u8],
+        at: usize,
+        mut sid: StateID,
+    ) {
+        // We can avoid pushing some state IDs on to our stack in precisely
+        // the cases where a 'push(x)' would be immediately followed by a 'x
+        // = pop()'. This is achieved by this outer-loop. We simply set 'sid'
+        // to be the next state ID we want to explore once we're done with
+        // our initial exploration. In practice, this avoids a lot of stack
+        // thrashing.
+        loop {
+            // Record this state as part of our next set of active states. If
+            // we've already explored it, then no need to do it again.
+            if !next.set.insert(sid) {
+                return;
+            }
+            match *self.nfa.state(sid) {
+                State::Fail
+                | State::Match { .. }
+                | State::Char { .. }
+                | State::Ranges { .. } => {
+                    next.slot_table.for_state(sid).copy_from_slice(curr_slots);
+                    return;
+                }
+                State::Goto { target, look: None } => {
+                    sid = target;
+                }
+                State::Goto { target, look: Some(look) } => {
+                    if !look.is_match(haystack, at) {
+                        return;
+                    }
+                    sid = target;
+                }
+                State::Splits { ref targets, reverse: false } => {
+                    sid = match targets.get(0) {
+                        None => return,
+                        Some(&sid) => sid,
+                    };
+                    stack.extend(
+                        targets[1..]
+                            .iter()
+                            .copied()
+                            .rev()
+                            .map(FollowEpsilon::Explore),
+                    );
+                }
+                State::Splits { ref targets, reverse: true } => {
+                    sid = match targets.last() {
+                        None => return,
+                        Some(&sid) => sid,
+                    };
+                    stack.extend(
+                        targets[..targets.len() - 1]
+                            .iter()
+                            .copied()
+                            .map(FollowEpsilon::Explore),
+                    );
+                }
+                State::Capture { target, slot } => {
+                    // There's no need to do anything with slots that
+                    // ultimately won't be copied into the caller-provided
+                    // 'Captures' value. So we just skip dealing with them at
+                    // all.
+                    if slot.as_usize() < curr_slots.len() {
+                        stack.push(FollowEpsilon::RestoreCapture {
+                            slot,
+                            offset: curr_slots[slot.as_usize()],
+                        });
+                        // OK because length of a slice must fit into an isize.
+                        curr_slots[slot.as_usize()] =
+                            Some(NonMaxUsize::new(at).unwrap());
+                    }
+                    sid = target;
+                }
+            }
+        }
+    }
+}
+
+/// An iterator over all successive non-overlapping matches in a particular
+/// haystack. `'r` represents the lifetime of the regex, `'c` is the lifetime
+/// of the cache and `'h` represents the lifetime of the haystack.
+#[derive(Debug)]
+pub(crate) struct FindMatches<'r, 'h> {
+    pikevm: &'r PikeVM,
+    cache: CachePoolGuard<'r>,
+    haystack: &'h [u8],
+    at: usize,
+    slots: Vec<Option<NonMaxUsize>>,
+    last_match_end: Option<usize>,
+}
+
+impl<'r, 'h> Iterator for FindMatches<'r, 'h> {
+    type Item = (usize, usize);
+
+    fn next(&mut self) -> Option<(usize, usize)> {
+        if !self.pikevm.search(
+            &mut self.cache,
+            self.haystack,
+            self.at,
+            self.haystack.len(),
+            false,
+            &mut self.slots,
+        ) {
+            return None;
+        }
+        let mut m =
+            (self.slots[0].unwrap().get(), self.slots[1].unwrap().get());
+        if m.0 >= m.1 {
+            m = self.handle_overlapping_empty_match(m)?;
+        }
+        self.at = m.1;
+        self.last_match_end = Some(m.1);
+        Some(m)
+    }
+}
+
+impl<'r, 'h> FindMatches<'r, 'h> {
+    /// Handles the special case of an empty match by ensuring that 1) the
+    /// iterator always advances and 2) empty matches never overlap with other
+    /// matches.
+    ///
+    /// Note that we mark this cold and forcefully prevent inlining because
+    /// handling empty matches like this is extremely rare and does require a
+    /// bit of code, comparatively. Keeping this code out of the main iterator
+    /// function keeps it smaller and more amenable to inlining itself.
+    #[cold]
+    #[inline(never)]
+    fn handle_overlapping_empty_match(
+        &mut self,
+        mut m: (usize, usize),
+    ) -> Option<(usize, usize)> {
+        assert!(m.0 >= m.1);
+        if Some(m.1) == self.last_match_end {
+            let len =
+                core::cmp::max(1, utf8::decode(&self.haystack[self.at..]).1);
+            self.at = self.at.checked_add(len).unwrap();
+            if !self.pikevm.search(
+                &mut self.cache,
+                self.haystack,
+                self.at,
+                self.haystack.len(),
+                false,
+                &mut self.slots,
+            ) {
+                return None;
+            }
+            m = (self.slots[0].unwrap().get(), self.slots[1].unwrap().get());
+        }
+        Some(m)
+    }
+}
+
+/// An iterator over all successive non-overlapping capture matches in a particular
+/// haystack. `'r` represents the lifetime of the regex, `'c` is the lifetime
+/// of the cache and `'h` represents the lifetime of the haystack.
+#[derive(Debug)]
+pub(crate) struct CapturesMatches<'r, 'h> {
+    it: FindMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for CapturesMatches<'r, 'h> {
+    type Item = Vec<Option<NonMaxUsize>>;
+
+    fn next(&mut self) -> Option<Vec<Option<NonMaxUsize>>> {
+        self.it.next()?;
+        Some(self.it.slots.clone())
+    }
+}
+
+/// A cache represents mutable state that a `PikeVM` requires during a search.
+///
+/// For a given `PikeVM`, its corresponding cache may be created either via
+/// `PikeVM::create_cache`, or via `Cache::new`. They are equivalent in every
+/// way, except the former does not require explicitly importing `Cache`.
+///
+/// A particular `Cache` is coupled with the `PikeVM` from which it was
+/// created. It may only be used with that `PikeVM`. A cache and its
+/// allocations may be re-purposed via `Cache::reset`, in which case, it can
+/// only be used with the new `PikeVM` (and not the old one).
+#[derive(Clone, Debug)]
+pub(crate) struct Cache {
+    /// Stack used while computing epsilon closure. This effectively lets us
+    /// move what is more naturally expressed through recursion to a stack
+    /// on the heap.
+    stack: Vec<FollowEpsilon>,
+    /// The current active states being explored for the current byte in the
+    /// haystack.
+    curr: ActiveStates,
+    /// The next set of states we're building that will be explored for the
+    /// next byte in the haystack.
+    next: ActiveStates,
+}
+
+impl Cache {
+    /// Create a new `PikeVM` cache.
+    ///
+    /// A potentially more convenient routine to create a cache is
+    /// `PikeVM::create_cache`, as it does not require also importing the
+    /// `Cache` type.
+    ///
+    /// If you want to reuse the returned `Cache` with some other `PikeVM`,
+    /// then you must call `Cache::reset` with the desired `PikeVM`.
+    pub(crate) fn new(re: &PikeVM) -> Cache {
+        Cache {
+            stack: vec![],
+            curr: ActiveStates::new(re),
+            next: ActiveStates::new(re),
+        }
+    }
+
+    /// Clears this cache. This should be called at the start of every search
+    /// to ensure we start with a clean slate.
+    ///
+    /// This also sets the length of the capturing groups used in the current
+    /// search. This permits an optimization where by 'SlotTable::for_state'
+    /// only returns the number of slots equivalent to the number of slots
+    /// given in the 'Captures' value. This may be less than the total number
+    /// of possible slots, e.g., when one only wants to track overall match
+    /// offsets. This in turn permits less copying of capturing group spans
+    /// in the PikeVM.
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.stack.clear();
+        self.curr.setup_search(captures_slot_len);
+        self.next.setup_search(captures_slot_len);
+    }
+}
+
+/// A set of active states used to "simulate" the execution of an NFA via the
+/// PikeVM.
+///
+/// There are two sets of these used during NFA simulation. One set corresponds
+/// to the "current" set of states being traversed for the current position
+/// in a haystack. The other set corresponds to the "next" set of states being
+/// built, which will become the new "current" set for the next position in the
+/// haystack. These two sets correspond to CLIST and NLIST in Thompson's
+/// original paper regexes: https://dl.acm.org/doi/pdf/10.1145/363347.363387
+///
+/// In addition to representing a set of NFA states, this also maintains slot
+/// values for each state. These slot values are what turn the NFA simulation
+/// into the "Pike VM." Namely, they track capturing group values for each
+/// state. During the computation of epsilon closure, we copy slot values from
+/// states in the "current" set to the "next" set. Eventually, once a match
+/// is found, the slot values for that match state are what we write to the
+/// caller provided slots.
+#[derive(Clone, Debug)]
+struct ActiveStates {
+    /// The set of active NFA states. This set preserves insertion order, which
+    /// is critical for simulating the match semantics of backtracking regex
+    /// engines.
+    set: SparseSet,
+    /// The slots for every NFA state, where each slot stores a (possibly
+    /// absent) offset. Every capturing group has two slots. One for a start
+    /// offset and one for an end offset.
+    slot_table: SlotTable,
+}
+
+impl ActiveStates {
+    /// Create a new set of active states for the given PikeVM. The active
+    /// states returned may only be used with the given PikeVM. (Use 'reset'
+    /// to re-purpose the allocation for a different PikeVM.)
+    fn new(re: &PikeVM) -> ActiveStates {
+        let mut active = ActiveStates {
+            set: SparseSet::new(0),
+            slot_table: SlotTable::new(),
+        };
+        active.reset(re);
+        active
+    }
+
+    /// Reset this set of active states such that it can be used with the given
+    /// PikeVM (and only that PikeVM).
+    fn reset(&mut self, re: &PikeVM) {
+        self.set.resize(re.nfa().len());
+        self.slot_table.reset(re);
+    }
+
+    /// Setup this set of active states for a new search. The given slot
+    /// length should be the number of slots in a caller provided 'Captures'
+    /// (and may be zero).
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.set.clear();
+        self.slot_table.setup_search(captures_slot_len);
+    }
+}
+
+/// A table of slots, where each row represent a state in an NFA. Thus, the
+/// table has room for storing slots for every single state in an NFA.
+///
+/// This table is represented with a single contiguous allocation. In general,
+/// the notion of "capturing group" doesn't really exist at this level of
+/// abstraction, hence the name "slot" instead. (Indeed, every capturing group
+/// maps to a pair of slots, one for the start offset and one for the end
+/// offset.) Slots are indexed by the `Captures` NFA state.
+#[derive(Clone, Debug)]
+struct SlotTable {
+    /// The actual table of offsets.
+    table: Vec<Option<NonMaxUsize>>,
+    /// The number of slots per state, i.e., the table's stride or the length
+    /// of each row.
+    slots_per_state: usize,
+    /// The number of slots in the caller-provided `Captures` value for the
+    /// current search. Setting this to `slots_per_state` is always correct,
+    /// but may be wasteful.
+    slots_for_captures: usize,
+}
+
+impl SlotTable {
+    /// Create a new slot table.
+    ///
+    /// One should call 'reset' with the corresponding PikeVM before use.
+    fn new() -> SlotTable {
+        SlotTable { table: vec![], slots_for_captures: 0, slots_per_state: 0 }
+    }
+
+    /// Reset this slot table such that it can be used with the given PikeVM
+    /// (and only that PikeVM).
+    fn reset(&mut self, re: &PikeVM) {
+        let nfa = re.nfa();
+        // OK because NFA construction would have failed if this overflowed.
+        self.slots_per_state = nfa.group_len().checked_mul(2).unwrap();
+        // This is always correct, but may be reduced for a particular search
+        // if fewer slots were given by the caller, e.g., none at all or only
+        // slots for tracking the overall match instead of all slots for every
+        // group.
+        self.slots_for_captures = self.slots_per_state;
+        let len = nfa
+            .len()
+            // We add 1 so that our last row is always empty. We use it as
+            // "scratch" space for computing the epsilon closure off of the
+            // starting state.
+            .checked_add(1)
+            .and_then(|x| x.checked_mul(self.slots_per_state))
+            // It seems like this could actually panic on legitimate inputs
+            // on 32-bit targets. Should we somehow convert this to an error?
+            // What about something similar for the lazy DFA cache? If you're
+            // tripping this assert, please file a bug.
+            .expect("slot table length doesn't overflow");
+        self.table.resize(len, None);
+    }
+
+    /// Perform any per-search setup for this slot table.
+    ///
+    /// In particular, this sets the length of the number of slots used in the
+    /// slots given by the caller (if any at all). This number may be smaller
+    /// than the total number of slots available, e.g., when the caller is only
+    /// interested in tracking the overall match and not the spans of every
+    /// matching capturing group. Only tracking the overall match can save a
+    /// substantial amount of time copying capturing spans during a search.
+    fn setup_search(&mut self, captures_slot_len: usize) {
+        self.slots_for_captures = captures_slot_len;
+    }
+
+    /// Return a mutable slice of the slots for the given state.
+    ///
+    /// Note that the length of the slice returned may be less than the total
+    /// number of slots available for this state. In particular, the length
+    /// always matches the number of slots indicated via `setup_search`.
+    fn for_state(&mut self, sid: StateID) -> &mut [Option<NonMaxUsize>] {
+        let i = sid.as_usize() * self.slots_per_state;
+        &mut self.table[i..i + self.slots_for_captures]
+    }
+
+    /// Return a slice of slots of appropriate length where every slot offset
+    /// is guaranteed to be absent. This is useful in cases where you need to
+    /// compute an epsilon closure outside of the user supplied regex, and thus
+    /// never want it to have any capturing slots set.
+    fn all_absent(&mut self) -> &mut [Option<NonMaxUsize>] {
+        let i = self.table.len() - self.slots_per_state;
+        &mut self.table[i..i + self.slots_for_captures]
+    }
+}
+
+/// Represents a stack frame for use while computing an epsilon closure.
+///
+/// (An "epsilon closure" refers to the set of reachable NFA states from a
+/// single state without consuming any input. That is, the set of all epsilon
+/// transitions not only from that single state, but from every other state
+/// reachable by an epsilon transition as well. This is why it's called a
+/// "closure.")
+///
+/// Computing the epsilon closure in a Thompson NFA proceeds via a depth
+/// first traversal over all epsilon transitions from a particular state.
+/// (A depth first traversal is important because it emulates the same priority
+/// of matches that is typically found in backtracking regex engines.) This
+/// depth first traversal is naturally expressed using recursion, but to avoid
+/// a call stack size proportional to the size of a regex, we put our stack on
+/// the heap instead.
+///
+/// This stack thus consists of call frames. The typical call frame is
+/// `Explore`, which instructs epsilon closure to explore the epsilon
+/// transitions from that state. (Subsequent epsilon transitions are then
+/// pushed on to the stack as more `Explore` frames.) If the state ID being
+/// explored has no epsilon transitions, then the capturing group slots are
+/// copied from the original state that sparked the epsilon closure (from the
+/// 'step' routine) to the state ID being explored. This way, capturing group
+/// slots are forwarded from the previous state to the next.
+///
+/// The other stack frame, `RestoreCaptures`, instructs the epsilon closure to
+/// set the position for a particular slot back to some particular offset. This
+/// frame is pushed when `Explore` sees a `Capture` transition. `Explore` will
+/// set the offset of the slot indicated in `Capture` to the current offset,
+/// and then push the old offset on to the stack as a `RestoreCapture` frame.
+/// Thus, the new offset is only used until the epsilon closure reverts back to
+/// the `RestoreCapture` frame. In effect, this gives the `Capture` epsilon
+/// transition its "scope" to only states that come "after" it during depth
+/// first traversal.
+#[derive(Clone, Debug)]
+enum FollowEpsilon {
+    /// Explore the epsilon transitions from a state ID.
+    Explore(StateID),
+    /// Reset the given `slot` to the given `offset` (which might be `None`).
+    RestoreCapture { slot: u32, offset: Option<NonMaxUsize> },
+}
+
+/// A sparse set used for representing ordered NFA states.
+///
+/// This supports constant time addition and membership testing. Clearing an
+/// entire set can also be done in constant time. Iteration yields elements
+/// in the order in which they were inserted.
+///
+/// The data structure is based on: https://research.swtch.com/sparse
+/// Note though that we don't actually use uninitialized memory. We generally
+/// reuse sparse sets, so the initial allocation cost is bareable. However, its
+/// other properties listed above are extremely useful.
+#[derive(Clone)]
+struct SparseSet {
+    /// The number of elements currently in this set.
+    len: usize,
+    /// Dense contains the ids in the order in which they were inserted.
+    dense: Vec<StateID>,
+    /// Sparse maps ids to their location in dense.
+    ///
+    /// A state ID is in the set if and only if
+    /// sparse[id] < len && id == dense[sparse[id]].
+    ///
+    /// Note that these are indices into 'dense'. It's a little weird to use
+    /// StateID here, but we know our length can never exceed the bounds of
+    /// StateID (enforced by 'resize') and StateID will be at most 4 bytes
+    /// where as a usize is likely double that in most cases.
+    sparse: Vec<StateID>,
+}
+
+impl SparseSet {
+    /// Create a new sparse set with the given capacity.
+    ///
+    /// Sparse sets have a fixed size and they cannot grow. Attempting to
+    /// insert more distinct elements than the total capacity of the set will
+    /// result in a panic.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    fn new(capacity: usize) -> SparseSet {
+        let mut set = SparseSet { len: 0, dense: vec![], sparse: vec![] };
+        set.resize(capacity);
+        set
+    }
+
+    /// Resizes this sparse set to have the new capacity given.
+    ///
+    /// This set is automatically cleared.
+    ///
+    /// This panics if the capacity given is bigger than `StateID::LIMIT`.
+    fn resize(&mut self, new_capacity: usize) {
+        assert!(
+            new_capacity <= u32::MAX.as_usize(),
+            "sparse set capacity cannot excced {:?}",
+            u32::MAX,
+        );
+        self.clear();
+        self.dense.resize(new_capacity, 0);
+        self.sparse.resize(new_capacity, 0);
+    }
+
+    /// Returns the capacity of this set.
+    ///
+    /// The capacity represents a fixed limit on the number of distinct
+    /// elements that are allowed in this set. The capacity cannot be changed.
+    fn capacity(&self) -> usize {
+        self.dense.len()
+    }
+
+    /// Returns the number of elements in this set.
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns true if and only if this set is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Insert the state ID value into this set and return true if the given
+    /// state ID was not previously in this set.
+    ///
+    /// This operation is idempotent. If the given value is already in this
+    /// set, then this is a no-op.
+    ///
+    /// If more than `capacity` ids are inserted, then this panics.
+    fn insert(&mut self, id: StateID) -> bool {
+        if self.contains(id) {
+            return false;
+        }
+
+        let index = self.len();
+        assert!(
+            index < self.capacity(),
+            "{:?} exceeds capacity of {:?} when inserting {:?}",
+            index,
+            self.capacity(),
+            id,
+        );
+        self.dense[index] = id;
+        // OK because we don't permit the capacity to be set higher than
+        // u32::MAX.
+        self.sparse[id.as_usize()] = u32::try_from(index).unwrap();
+        self.len += 1;
+        true
+    }
+
+    /// Returns true if and only if this set contains the given value.
+    fn contains(&self, id: StateID) -> bool {
+        let index = self.sparse[id.as_usize()];
+        index.as_usize() < self.len() && self.dense[index.as_usize()] == id
+    }
+
+    /// Clear this set such that it has no members.
+    fn clear(&mut self) {
+        self.len = 0;
+    }
+
+    /// Returns an iterator over all the state IDs in this set in the order in
+    /// which they were inserted.
+    fn iter(&self) -> SparseSetIter<'_> {
+        SparseSetIter(self.dense[..self.len()].iter())
+    }
+}
+
+impl core::fmt::Debug for SparseSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let elements: Vec<StateID> = self.iter().collect();
+        f.debug_tuple("SparseSet").field(&elements).finish()
+    }
+}
+
+/// An iterator over all elements in a sparse set.
+///
+/// The lifetime `'a` refers to the lifetime of the set being iterated over.
+#[derive(Debug)]
+struct SparseSetIter<'a>(core::slice::Iter<'a, StateID>);
+
+impl<'a> Iterator for SparseSetIter<'a> {
+    type Item = StateID;
+
+    fn next(&mut self) -> Option<StateID> {
+        self.0.next().map(|&id| id)
+    }
+}
diff --git a/regex-lite/src/pool.rs b/regex-lite/src/pool.rs
new file mode 100644
index 0000000000..c8b1f81256
--- /dev/null
+++ b/regex-lite/src/pool.rs
@@ -0,0 +1,119 @@
+use core::panic::{RefUnwindSafe, UnwindSafe};
+
+use alloc::{boxed::Box, vec, vec::Vec};
+
+use crate::pikevm;
+
+// Literally the only reason that this crate requires 'std' currently.
+//
+// In regex-automata, we support the no-std use case by rolling our own
+// spin-lock based Mutex. That's questionable on its own, but it's not clear if
+// we should be doing that here. It will require introducing non-safe code in a
+// crate that is otherwise safe. But maybe it's worth doing?
+use std::sync::Mutex;
+
+/// A type alias for our pool of meta::Cache that fixes the type parameters to
+/// what we use for the meta regex below.
+pub(crate) type CachePool = Pool<pikevm::Cache, CachePoolFn>;
+
+/// Same as above, but for the guard returned by a pool.
+pub(crate) type CachePoolGuard<'a> = PoolGuard<'a, pikevm::Cache, CachePoolFn>;
+
+/// The type of the closure we use to create new caches. We need to spell out
+/// all of the marker traits or else we risk leaking !MARKER impls.
+pub(crate) type CachePoolFn =
+    Box<dyn Fn() -> pikevm::Cache + Send + Sync + UnwindSafe + RefUnwindSafe>;
+
+/// A thread safe pool utilizing alloc-only features.
+///
+/// Unlike the pool in regex-automata, this has no "fast path." We could add
+/// it, but it's more code and requires reasoning about safety.
+pub(crate) struct Pool<T, F> {
+    /// A stack of T values to hand out. These are used when a Pool is
+    /// accessed by a thread that didn't create it.
+    stack: Mutex<Vec<Box<T>>>,
+    /// A function to create more T values when stack is empty and a caller
+    /// has requested a T.
+    create: F,
+}
+
+// If T is UnwindSafe, then since we provide exclusive access to any
+// particular value in the pool, it should therefore also be considered
+// RefUnwindSafe.
+impl<T: UnwindSafe, F: UnwindSafe> RefUnwindSafe for Pool<T, F> {}
+
+impl<T, F> Pool<T, F> {
+    /// Create a new pool. The given closure is used to create values in
+    /// the pool when necessary.
+    pub(crate) const fn new(create: F) -> Pool<T, F> {
+        Pool { stack: Mutex::new(vec![]), create }
+    }
+}
+
+impl<T: Send, F: Fn() -> T> Pool<T, F> {
+    /// Get a value from the pool. This may block if another thread is also
+    /// attempting to retrieve a value from the pool.
+    pub(crate) fn get(&self) -> PoolGuard<'_, T, F> {
+        let mut stack = self.stack.lock().unwrap();
+        let value = match stack.pop() {
+            None => Box::new((self.create)()),
+            Some(value) => value,
+        };
+        PoolGuard { pool: self, value: Some(value) }
+    }
+
+    /// Puts a value back into the pool. Callers don't need to call this.
+    /// Once the guard that's returned by 'get' is dropped, it is put back
+    /// into the pool automatically.
+    fn put_value(&self, value: Box<T>) {
+        let mut stack = self.stack.lock().unwrap();
+        stack.push(value);
+    }
+}
+
+impl<T: core::fmt::Debug, F> core::fmt::Debug for Pool<T, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Pool").field("stack", &self.stack).finish()
+    }
+}
+
+/// A guard that is returned when a caller requests a value from the pool.
+pub(crate) struct PoolGuard<'a, T: Send, F: Fn() -> T> {
+    /// The pool that this guard is attached to.
+    pool: &'a Pool<T, F>,
+    /// This is None after the guard has been put back into the pool.
+    value: Option<Box<T>>,
+}
+
+impl<'a, T: Send, F: Fn() -> T> Drop for PoolGuard<'a, T, F> {
+    fn drop(&mut self) {
+        if let Some(value) = self.value.take() {
+            self.pool.put_value(value);
+        }
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::Deref for PoolGuard<'a, T, F> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.value.as_deref().unwrap()
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::DerefMut for PoolGuard<'a, T, F> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.value.as_deref_mut().unwrap()
+    }
+}
+
+impl<'a, T: Send + core::fmt::Debug, F: Fn() -> T> core::fmt::Debug
+    for PoolGuard<'a, T, F>
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("PoolGuard")
+            .field("pool", &self.pool)
+            .field("value", &self.value)
+            .finish()
+    }
+}
diff --git a/regex-lite/src/string.rs b/regex-lite/src/string.rs
new file mode 100644
index 0000000000..358f7a0c75
--- /dev/null
+++ b/regex-lite/src/string.rs
@@ -0,0 +1,2955 @@
+use alloc::{
+    borrow::Cow, boxed::Box, string::String, string::ToString, sync::Arc, vec,
+    vec::Vec,
+};
+
+use crate::{
+    error::Error,
+    hir::{self, Hir},
+    int::NonMaxUsize,
+    interpolate,
+    nfa::{self, NFA},
+    pikevm::{self, Cache, PikeVM},
+    pool::CachePool,
+};
+
+/// A compiled regular expression for searching Unicode haystacks.
+///
+/// A `Regex` can be used to search haystacks, split haystacks into substrings
+/// or replace substrings in a haystack with a different substring. All
+/// searching is done with an implicit `(?s:.)*?` at the beginning and end of
+/// an pattern. To force an expression to match the whole string (or a prefix
+/// or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`).
+///
+/// While this crate will handle Unicode strings (whether in the regular
+/// expression or in the haystack), all positions returned are **byte
+/// offsets**. Every byte offset is guaranteed to be at a Unicode code point
+/// boundary. That is, all offsets returned by the `Regex` API are guaranteed
+/// to be ranges that can slice a `&str` without panicking.
+///
+/// The only methods that allocate new strings are the string replacement
+/// methods. All other methods (searching and splitting) return borrowed
+/// references into the haystack given.
+///
+/// # Example
+///
+/// Find the offsets of a US phone number:
+///
+/// ```
+/// use regex_lite::Regex;
+///
+/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();
+/// let m = re.find("phone: 111-222-3333").unwrap();
+/// assert_eq!(7..19, m.range());
+/// ```
+///
+/// # Example: extracting capture groups
+///
+/// A common way to use regexes is with capture groups. That is, instead of
+/// just looking for matches of an entire regex, parentheses are used to create
+/// groups that represent part of the match.
+///
+/// For example, consider a haystack with multiple lines, and each line has
+/// three whitespace delimited fields where the second field is expected to be
+/// a number and the third field a boolean. To make this convenient, we use
+/// the [`Captures::extract`] API to put the strings that match each group
+/// into a fixed size array:
+///
+/// ```
+/// use regex_lite::Regex;
+///
+/// let hay = "
+/// rabbit         54 true
+/// groundhog 2 true
+/// does not match
+/// fox   109    false
+/// ";
+/// let re = Regex::new(r"(?m)^\s*(\S+)\s+([0-9]+)\s+(true|false)\s*$").unwrap();
+/// let mut fields: Vec<(&str, i64, bool)> = vec![];
+/// for (_, [f1, f2, f3]) in re.captures_iter(hay).map(|caps| caps.extract()) {
+///     fields.push((f1, f2.parse()?, f3.parse()?));
+/// }
+/// assert_eq!(fields, vec![
+///     ("rabbit", 54, true),
+///     ("groundhog", 2, true),
+///     ("fox", 109, false),
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+pub struct Regex {
+    pikevm: Arc<PikeVM>,
+    pool: CachePool,
+}
+
+impl Clone for Regex {
+    fn clone(&self) -> Regex {
+        let pikevm = Arc::clone(&self.pikevm);
+        let pool = {
+            let pikevm = Arc::clone(&self.pikevm);
+            let create = Box::new(move || Cache::new(&pikevm));
+            CachePool::new(create)
+        };
+        Regex { pikevm, pool }
+    }
+}
+
+impl core::fmt::Display for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl core::fmt::Debug for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("Regex").field(&self.as_str()).finish()
+    }
+}
+
+impl core::str::FromStr for Regex {
+    type Err = Error;
+
+    /// Attempts to parse a string into a regular expression
+    fn from_str(s: &str) -> Result<Regex, Error> {
+        Regex::new(s)
+    }
+}
+
+/// Core regular expression methods.
+impl Regex {
+    /// Compiles a regular expression. Once compiled, it can be used repeatedly
+    /// to search, split or replace substrings in a haystack.
+    ///
+    /// Note that regex compilation tends to be a somewhat expensive process,
+    /// and unlike higher level environments, compilation is not automatically
+    /// cached for you. One should endeavor to compile a regex once and then
+    /// reuse it. For example, it's a bad idea to compile the same regex
+    /// repeatedly in a loop.
+    ///
+    /// # Errors
+    ///
+    /// If an invalid pattern is given, then an error is returned.
+    /// An error is also returned if the pattern is valid, but would
+    /// produce a regex that is bigger than the configured size limit via
+    /// [`RegexBuilder::size_limit`]. (A reasonable size limit is enabled by
+    /// default.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// // An Invalid pattern because of an unclosed parenthesis
+    /// assert!(Regex::new(r"foo(bar").is_err());
+    /// // An invalid pattern because the regex would be too big
+    /// // because Unicode tends to inflate things.
+    /// assert!(Regex::new(r"\w{1000000}").is_err());
+    /// ```
+    pub fn new(pattern: &str) -> Result<Regex, Error> {
+        RegexBuilder::new(pattern).build()
+    }
+
+    /// Returns true if and only if there is a match for the regex anywhere
+    /// in the haystack given.
+    ///
+    /// It is recommended to use this method if all you need to do is test
+    /// whether a match exists, since the underlying matching engine may be
+    /// able to do less work.
+    ///
+    /// # Example
+    ///
+    /// Test if some haystack contains at least one word with exactly 13
+    /// word characters:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "I categorically deny having triskaidekaphobia.";
+    /// assert!(re.is_match(hay));
+    /// ```
+    #[inline]
+    pub fn is_match(&self, haystack: &str) -> bool {
+        self.is_match_at(haystack, 0)
+    }
+
+    /// This routine searches for the first match of this regex in the
+    /// haystack given, and if found, returns a [`Match`]. The `Match`
+    /// provides access to both the byte offsets of the match and the actual
+    /// substring that matched.
+    ///
+    /// Note that this should only be used if you want to find the entire
+    /// match. If instead you just want to test the existence of a match,
+    /// it's potentially faster to use `Regex::is_match(hay)` instead of
+    /// `Regex::find(hay).is_some()`.
+    ///
+    /// # Example
+    ///
+    /// Find the first word with exactly 13 word characters:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "I categorically deny having triskaidekaphobia.";
+    /// let mat = re.find(hay).unwrap();
+    /// assert_eq!(2..15, mat.range());
+    /// assert_eq!("categorically", mat.as_str());
+    /// ```
+    #[inline]
+    pub fn find<'h>(&self, haystack: &'h str) -> Option<Match<'h>> {
+        self.find_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Match`].
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `find_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// Find every word with exactly 13 word characters:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "Retroactively relinquishing remunerations is reprehensible.";
+    /// let matches: Vec<_> = re.find_iter(hay).map(|m| m.as_str()).collect();
+    /// assert_eq!(matches, vec![
+    ///     "Retroactively",
+    ///     "relinquishing",
+    ///     "remunerations",
+    ///     "reprehensible",
+    /// ]);
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'h>(&'r self, haystack: &'h str) -> Matches<'r, 'h> {
+        Matches {
+            haystack,
+            it: self.pikevm.find_iter(self.pool.get(), haystack.as_bytes()),
+        }
+    }
+
+    /// This routine searches for the first match of this regex in the haystack
+    /// given, and if found, returns not only the overall match but also the
+    /// matches of each capture group in the regex. If no match is found, then
+    /// `None` is returned.
+    ///
+    /// Capture group `0` always corresponds to an implicit unnamed group that
+    /// includes the entire match. If a match is found, this group is always
+    /// present. Subsequent groups may be named and are numbered, starting
+    /// at 1, by the order in which the opening parenthesis appears in the
+    /// pattern. For example, in the pattern `(?<a>.(?<b>.))(?<c>.)`, `a`,
+    /// `b` and `c` correspond to capture group indices `1`, `2` and `3`,
+    /// respectively.
+    ///
+    /// You should only use `captures` if you need access to the capture group
+    /// matches. Otherwise, [`Regex::find`] is generally faster for discovering
+    /// just the overall match.
+    ///
+    /// # Example
+    ///
+    /// Say you have some haystack with movie names and their release years,
+    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for
+    /// substrings looking like that, while also extracting the movie name and
+    /// its release year separately. The example below shows how to do that.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.get(2).unwrap().as_str(), "1941");
+    /// // You can also access the groups by index using the Index notation.
+    /// // Note that this will panic on an invalid index. In this case, these
+    /// // accesses are always correct because the overall regex will only
+    /// // match when these capture groups match.
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    /// assert_eq!(&caps[1], "Citizen Kane");
+    /// assert_eq!(&caps[2], "1941");
+    /// ```
+    ///
+    /// Note that the full match is at capture group `0`. Each subsequent
+    /// capture group is indexed by the order of its opening `(`.
+    ///
+    /// We can make this example a bit clearer by using *named* capture groups:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// assert_eq!(caps.name("title").unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.name("year").unwrap().as_str(), "1941");
+    /// // You can also access the groups by name using the Index notation.
+    /// // Note that this will panic on an invalid group name. In this case,
+    /// // these accesses are always correct because the overall regex will
+    /// // only match when these capture groups match.
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    /// assert_eq!(&caps["title"], "Citizen Kane");
+    /// assert_eq!(&caps["year"], "1941");
+    /// ```
+    ///
+    /// Here we name the capture groups, which we can access with the `name`
+    /// method or the `Index` notation with a `&str`. Note that the named
+    /// capture groups are still accessible with `get` or the `Index` notation
+    /// with a `usize`.
+    ///
+    /// The `0`th capture group is always unnamed, so it must always be
+    /// accessed with `get(0)` or `[0]`.
+    ///
+    /// Finally, one other way to to get the matched substrings is with the
+    /// [`Captures::extract`] API:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let (full, [title, year]) = re.captures(hay).unwrap().extract();
+    /// assert_eq!(full, "'Citizen Kane' (1941)");
+    /// assert_eq!(title, "Citizen Kane");
+    /// assert_eq!(year, "1941");
+    /// ```
+    #[inline]
+    pub fn captures<'h>(&self, haystack: &'h str) -> Option<Captures<'h>> {
+        self.captures_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Captures`].
+    ///
+    /// This is the same as [`Regex::find_iter`], but instead of only providing
+    /// access to the overall match, each value yield includes access to the
+    /// matches of all capture groups in the regex. Reporting this extra match
+    /// data is potentially costly, so callers should only use `captures_iter`
+    /// over `find_iter` when they actually need access to the capture group
+    /// matches.
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `captures_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// We can use this to find all movie titles and their release years in
+    /// some haystack, where the movie is formatted like "'Title' (xxxx)":
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\(([0-9]{4})\)").unwrap();
+    /// let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut movies = vec![];
+    /// for (_, [title, year]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     movies.push((title, year.parse::<i64>()?));
+    /// }
+    /// assert_eq!(movies, vec![
+    ///     ("Citizen Kane", 1941),
+    ///     ("The Wizard of Oz", 1939),
+    ///     ("M", 1931),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Or with named groups:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>[0-9]{4})\)").unwrap();
+    /// let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut it = re.captures_iter(hay);
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "Citizen Kane");
+    /// assert_eq!(&caps["year"], "1941");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "The Wizard of Oz");
+    /// assert_eq!(&caps["year"], "1939");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "M");
+    /// assert_eq!(&caps["year"], "1931");
+    /// ```
+    #[inline]
+    pub fn captures_iter<'r, 'h>(
+        &'r self,
+        haystack: &'h str,
+    ) -> CaptureMatches<'r, 'h> {
+        CaptureMatches {
+            haystack,
+            re: self,
+            it: self
+                .pikevm
+                .captures_iter(self.pool.get(), haystack.as_bytes()),
+        }
+    }
+
+    /// Returns an iterator of substrings of the haystack given, delimited by a
+    /// match of the regex. Namely, each element of the iterator corresponds to
+    /// a part of the haystack that *isn't* matched by the regular expression.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"[ \t]+").unwrap();
+    /// let hay = "a b \t  c\td    e";
+    /// let fields: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);
+    /// ```
+    ///
+    /// # Example: more cases
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a", "little", "lamb"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["lion", "", "tiger", "leopard"]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["lion", "tiger", "leopard"]);
+    /// ```
+    ///
+    /// If a haystack contains multiple contiguous matches, you will end up
+    /// with empty spans yielded by the iterator:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "XXXXaXXbXc";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    ///
+    /// let re = Regex::new(r"/").unwrap();
+    /// let hay = "(///)";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["(", "", "", ")"]);
+    /// ```
+    ///
+    /// Separators at the start or end of a haystack are neighbored by empty
+    /// substring.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"0").unwrap();
+    /// let hay = "010";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "1", ""]);
+    /// ```
+    ///
+    /// When the empty string is used as a regex, it splits at every valid
+    /// UTF-8 boundary by default (which includes the beginning and end of the
+    /// haystack):
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let hay = "rust";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "r", "u", "s", "t", ""]);
+    ///
+    /// // Splitting by an empty string is UTF-8 aware by default!
+    /// let re = Regex::new(r"").unwrap();
+    /// let hay = "☃";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "☃", ""]);
+    /// ```
+    ///
+    /// Contiguous separators (commonly shows up with whitespace), can lead to
+    /// possibly surprising behavior. For example, this code is correct:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    /// ```
+    ///
+    /// It does *not* give you `["a", "b", "c"]`. For that behavior, you'd want
+    /// to match contiguous space characters:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r" +").unwrap();
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// // N.B. This does still include a leading empty span because ' +'
+    /// // matches at the beginning of the haystack.
+    /// assert_eq!(got, vec!["", "a", "b", "c"]);
+    /// ```
+    #[inline]
+    pub fn split<'r, 'h>(&'r self, haystack: &'h str) -> Split<'r, 'h> {
+        Split { haystack, finder: self.find_iter(haystack), last: 0 }
+    }
+
+    /// Returns an iterator of at most `limit` substrings of the haystack
+    /// given, delimited by a match of the regex. (A `limit` of `0` will return
+    /// no substrings.) Namely, each element of the iterator corresponds to a
+    /// part of the haystack that *isn't* matched by the regular expression.
+    /// The remainder of the haystack that is not split will be the last
+    /// element in the iterator.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some haystack:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let hay = "Hey! How are you?";
+    /// let fields: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(fields, vec!["Hey", "How", "are you?"]);
+    /// ```
+    ///
+    /// # Examples: more cases
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a little lamb"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec!["lion", "", "tigerXleopard"]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec!["lion", "tiger::leopard"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 1).collect();
+    /// assert_eq!(got, vec!["abcXdef"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcdef";
+    /// let got: Vec<&str> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec!["abcdef"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 0).collect();
+    /// assert!(got.is_empty());
+    /// ```
+    #[inline]
+    pub fn splitn<'r, 'h>(
+        &'r self,
+        haystack: &'h str,
+        limit: usize,
+    ) -> SplitN<'r, 'h> {
+        SplitN { splits: self.split(haystack), limit }
+    }
+
+    /// Replaces the leftmost-first match in the given haystack with the
+    /// replacement provided. The replacement can be a regular string (where
+    /// `$N` and `$name` are expanded to match capture groups) or a function
+    /// that takes a [`Captures`] and returns the replaced string.
+    ///
+    /// If no match is found, then the haystack is returned unchanged. In that
+    /// case, this implementation will likely return a `Cow::Borrowed` value
+    /// such that no allocation is performed.
+    ///
+    /// # Replacement string syntax
+    ///
+    /// All instances of `$ref` in the replacement string are replaced with
+    /// the substring corresponding to the capture group identified by `ref`.
+    ///
+    /// `ref` may be an integer corresponding to the index of the capture group
+    /// (counted by order of opening parenthesis where `0` is the entire match)
+    /// or it can be a name (consisting of letters, digits or underscores)
+    /// corresponding to a named capture group.
+    ///
+    /// If `ref` isn't a valid capture group (whether the name doesn't exist or
+    /// isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name is used. For example, `$1a` looks up the
+    /// capture group named `1a` and not the capture group at index `1`. To
+    /// exert more precise control over the name, use braces, e.g., `${1}a`.
+    ///
+    /// To write a literal `$` use `$$`.
+    ///
+    /// # Example
+    ///
+    /// Note that this function is polymorphic with respect to the replacement.
+    /// In typical usage, this can just be a normal string:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"[^01]+").unwrap();
+    /// assert_eq!(re.replace("1078910", ""), "1010");
+    /// ```
+    ///
+    /// But anything satisfying the [`Replacer`] trait will work. For example,
+    /// a closure of type `|&Captures| -> String` provides direct access to the
+    /// captures corresponding to a match. This allows one to access capturing
+    /// group matches easily:
+    ///
+    /// ```
+    /// use regex_lite::{Captures, Regex};
+    ///
+    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", |caps: &Captures| {
+    ///     format!("{} {}", &caps[2], &caps[1])
+    /// });
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// ```
+    ///
+    /// But this is a bit cumbersome to use all the time. Instead, a simple
+    /// syntax is supported (as described above) that expands `$name` into the
+    /// corresponding capture group. Here's the last example, but using this
+    /// expansion technique with named capture groups:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", "$first $last");
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// ```
+    ///
+    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
+    /// would produce the same result. To write a literal `$` use `$$`.
+    ///
+    /// Sometimes the replacement string requires use of curly braces to
+    /// delineate a capture group replacement when it is adjacent to some other
+    /// literal text. For example, if we wanted to join two words together with
+    /// an underscore:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<second>\w+)").unwrap();
+    /// let result = re.replace("deep fried", "${first}_$second");
+    /// assert_eq!(result, "deep_fried");
+    /// ```
+    ///
+    /// Without the curly braces, the capture group name `first_` would be
+    /// used, and since it doesn't exist, it would be replaced with the empty
+    /// string.
+    ///
+    /// Finally, sometimes you just want to replace a literal string with no
+    /// regard for capturing group expansion. This can be done by wrapping a
+    /// string with [`NoExpand`]:
+    ///
+    /// ```
+    /// use regex_lite::{NoExpand, Regex};
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
+    /// assert_eq!(result, "$2 $last");
+    /// ```
+    ///
+    /// Using `NoExpand` may also be faster, since the replacement string won't
+    /// need to be parsed for the `$` syntax.
+    #[inline]
+    pub fn replace<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        rep: R,
+    ) -> Cow<'h, str> {
+        self.replacen(haystack, 1, rep)
+    }
+
+    /// Replaces all non-overlapping matches in the haystack with the
+    /// replacement provided. This is the same as calling `replacen` with
+    /// `limit` set to `0`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Fallibility
+    ///
+    /// If you need to write a replacement routine where any individual
+    /// replacement might "fail," doing so with this API isn't really feasible
+    /// because there's no way to stop the search process if a replacement
+    /// fails. Instead, if you need this functionality, you should consider
+    /// implementing your own replacement routine:
+    ///
+    /// ```
+    /// use regex_lite::{Captures, Regex};
+    ///
+    /// fn replace_all<E>(
+    ///     re: &Regex,
+    ///     haystack: &str,
+    ///     replacement: impl Fn(&Captures) -> Result<String, E>,
+    /// ) -> Result<String, E> {
+    ///     let mut new = String::with_capacity(haystack.len());
+    ///     let mut last_match = 0;
+    ///     for caps in re.captures_iter(haystack) {
+    ///         let m = caps.get(0).unwrap();
+    ///         new.push_str(&haystack[last_match..m.start()]);
+    ///         new.push_str(&replacement(&caps)?);
+    ///         last_match = m.end();
+    ///     }
+    ///     new.push_str(&haystack[last_match..]);
+    ///     Ok(new)
+    /// }
+    ///
+    /// // Let's replace each word with the number of bytes in that word.
+    /// // But if we see a word that is "too long," we'll give up.
+    /// let re = Regex::new(r"\w+").unwrap();
+    /// let replacement = |caps: &Captures| -> Result<String, &'static str> {
+    ///     if caps[0].len() >= 5 {
+    ///         return Err("word too long");
+    ///     }
+    ///     Ok(caps[0].len().to_string())
+    /// };
+    /// assert_eq!(
+    ///     Ok("2 3 3 3?".to_string()),
+    ///     replace_all(&re, "hi how are you?", &replacement),
+    /// );
+    /// assert!(replace_all(&re, "hi there", &replacement).is_err());
+    /// ```
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace delimited
+    /// fields, and normalizes the whitespace that delimits the fields:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)\s+(\S+)$").unwrap();
+    /// let hay = "
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replace_all(hay, "$2 $1");
+    /// assert_eq!(new, "
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// 1975 BornToRun
+    /// 1978 Darkness
+    /// 1980 TheRiver
+    /// ");
+    /// ```
+    #[inline]
+    pub fn replace_all<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        rep: R,
+    ) -> Cow<'h, str> {
+        self.replacen(haystack, 0, rep)
+    }
+
+    /// Replaces at most `limit` non-overlapping matches in the haystack with
+    /// the replacement provided. If `limit` is `0`, then all non-overlapping
+    /// matches are replaced. That is, `Regex::replace_all(hay, rep)` is
+    /// equivalent to `Regex::replacen(hay, 0, rep)`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Fallibility
+    ///
+    /// See the corresponding section in the docs for [`Regex::replace_all`]
+    /// for tips on how to deal with a replacement routine that can fail.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace delimited
+    /// fields, and normalizes the whitespace that delimits the fields. But we
+    /// only do it for the first two matches.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)\s+(\S+)$").unwrap();
+    /// let hay = "
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replacen(hay, 2, "$2 $1");
+    /// assert_eq!(new, "
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ");
+    /// ```
+    #[inline]
+    pub fn replacen<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        limit: usize,
+        mut rep: R,
+    ) -> Cow<'h, str> {
+        // If we know that the replacement doesn't have any capture expansions,
+        // then we can use the fast path. The fast path can make a tremendous
+        // difference:
+        //
+        //   1) We use `find_iter` instead of `captures_iter`. Not asking for
+        //      captures generally makes the regex engines faster.
+        //   2) We don't need to look up all of the capture groups and do
+        //      replacements inside the replacement string. We just push it
+        //      at each match and be done with it.
+        if let Some(rep) = rep.no_expansion() {
+            let mut it = self.find_iter(haystack).enumerate().peekable();
+            if it.peek().is_none() {
+                return Cow::Borrowed(haystack);
+            }
+            let mut new = String::with_capacity(haystack.len());
+            let mut last_match = 0;
+            for (i, m) in it {
+                new.push_str(&haystack[last_match..m.start()]);
+                new.push_str(&rep);
+                last_match = m.end();
+                if limit > 0 && i >= limit - 1 {
+                    break;
+                }
+            }
+            new.push_str(&haystack[last_match..]);
+            return Cow::Owned(new);
+        }
+
+        // The slower path, which we use if the replacement needs access to
+        // capture groups.
+        let mut it = self.captures_iter(haystack).enumerate().peekable();
+        if it.peek().is_none() {
+            return Cow::Borrowed(haystack);
+        }
+        let mut new = String::with_capacity(haystack.len());
+        let mut last_match = 0;
+        for (i, cap) in it {
+            // unwrap on 0 is OK because captures only reports matches
+            let m = cap.get(0).unwrap();
+            new.push_str(&haystack[last_match..m.start()]);
+            rep.replace_append(&cap, &mut new);
+            last_match = m.end();
+            if limit > 0 && i >= limit - 1 {
+                break;
+            }
+        }
+        new.push_str(&haystack[last_match..]);
+        Cow::Owned(new)
+    }
+}
+
+/// A group of advanced or "lower level" search methods. Some methods permit
+/// starting the search at a position greater than `0` in the haystack. Other
+/// methods permit reusing allocations, for example, when extracting the
+/// matches for capture groups.
+impl Regex {
+    /// Returns the end byte offset of the first match in the haystack given.
+    ///
+    /// This method may have the same performance characteristics as
+    /// `is_match`. Behaviorlly, it doesn't just report whether it match
+    /// occurs, but also the end offset for a match. In particular, the offset
+    /// returned *may be shorter* than the proper end of the leftmost-first
+    /// match that you would find via [`Regex::find`].
+    ///
+    /// Note that it is not guaranteed that this routine finds the shortest or
+    /// "earliest" possible match. Instead, the main idea of this API is that
+    /// it returns the offset at the point at which the internal regex engine
+    /// has determined that a match has occurred. This may vary depending on
+    /// which internal regex engine is used, and thus, the offset itself may
+    /// change based on internal heuristics.
+    ///
+    /// # Example
+    ///
+    /// Typically, `a+` would match the entire first sequence of `a` in some
+    /// haystack, but `shortest_match` *may* give up as soon as it sees the
+    /// first `a`.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"a+").unwrap();
+    /// let offset = re.shortest_match("aaaaa").unwrap();
+    /// assert_eq!(offset, 1);
+    /// ```
+    #[inline]
+    pub fn shortest_match(&self, haystack: &str) -> Option<usize> {
+        self.shortest_match_at(haystack, 0)
+    }
+
+    /// Returns the same as [`Regex::shortest_match`], but starts the search at
+    /// the given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only match
+    /// when `start == 0`.
+    ///
+    /// If a match is found, the offset returned is relative to the beginning
+    /// of the haystack, not the beginning of the search.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.shortest_match(&hay[2..]), Some(4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.shortest_match_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn shortest_match_at(
+        &self,
+        haystack: &str,
+        start: usize,
+    ) -> Option<usize> {
+        let mut cache = self.pool.get();
+        let mut slots = [None, None];
+        let matched = self.pikevm.search(
+            &mut cache,
+            haystack.as_bytes(),
+            start,
+            haystack.len(),
+            true,
+            &mut slots,
+        );
+        if !matched {
+            return None;
+        }
+        Some(slots[1].unwrap().get())
+    }
+
+    /// Returns the same as [`Regex::is_match`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.is_match(&hay[2..]));
+    /// // No match because the  assertions take the context into account.
+    /// assert!(!re.is_match_at(hay, 2));
+    /// ```
+    #[inline]
+    pub fn is_match_at(&self, haystack: &str, start: usize) -> bool {
+        let mut cache = self.pool.get();
+        self.pikevm.search(
+            &mut cache,
+            haystack.as_bytes(),
+            start,
+            haystack.len(),
+            true,
+            &mut [],
+        )
+    }
+
+    /// Returns the same as [`Regex::find`], but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.find(&hay[2..]).map(|m| m.range()), Some(0..4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.find_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn find_at<'h>(
+        &self,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let mut cache = self.pool.get();
+        let mut slots = [None, None];
+        let matched = self.pikevm.search(
+            &mut cache,
+            haystack.as_bytes(),
+            start,
+            haystack.len(),
+            false,
+            &mut slots,
+        );
+        if !matched {
+            return None;
+        }
+        let (start, end) = (slots[0].unwrap().get(), slots[1].unwrap().get());
+        Some(Match::new(haystack, start, end))
+    }
+
+    /// Returns the same as [`Regex::captures`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(&re.captures(&hay[2..]).unwrap()[0], "chew");
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_at(hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_at<'h>(
+        &self,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Captures<'h>> {
+        let mut caps = Captures {
+            haystack,
+            slots: self.capture_locations(),
+            pikevm: Arc::clone(&self.pikevm),
+        };
+        let mut cache = self.pool.get();
+        let matched = self.pikevm.search(
+            &mut cache,
+            haystack.as_bytes(),
+            start,
+            haystack.len(),
+            false,
+            &mut caps.slots.0,
+        );
+        if !matched {
+            return None;
+        }
+        Some(caps)
+    }
+
+    /// This is like [`Regex::captures`], but writes the byte offsets of each
+    /// capture group match into the locations given.
+    ///
+    /// A [`CaptureLocations`] stores the same byte offsets as a [`Captures`],
+    /// but does *not* store a reference to the haystack. This makes its API
+    /// a bit lower level and less convenience. But in exchange, callers
+    /// may allocate their own `CaptureLocations` and reuse it for multiple
+    /// searches. This may be helpful if allocating a `Captures` shows up in a
+    /// profile as too costly.
+    ///
+    /// To create a `CaptureLocations` value, use the
+    /// [`Regex::capture_locations`] method.
+    ///
+    /// This also the overall match if one was found. When a match is found,
+    /// its offsets are also always stored in `locs` at index `0`.
+    ///
+    /// # Panics
+    ///
+    /// This routine may panic if the given `CaptureLocations` was not created
+    /// by this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"^([a-z]+)=(\S*)$").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, "id=foo123").is_some());
+    /// assert_eq!(Some((0, 9)), locs.get(0));
+    /// assert_eq!(Some((0, 2)), locs.get(1));
+    /// assert_eq!(Some((3, 9)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn captures_read<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h str,
+    ) -> Option<Match<'h>> {
+        self.captures_read_at(locs, haystack, 0)
+    }
+
+    /// Returns the same as [`Regex::captures_read`], but starts the search at
+    /// the given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// This routine may also panic if the given `CaptureLocations` was not
+    /// created by this regex.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// let mut locs = re.capture_locations();
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.captures_read(&mut locs, &hay[2..]).is_some());
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_read_at(&mut locs, hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_read_at<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let mut cache = self.pool.get();
+        let matched = self.pikevm.search(
+            &mut cache,
+            haystack.as_bytes(),
+            start,
+            haystack.len(),
+            false,
+            &mut locs.0,
+        );
+        if !matched {
+            return None;
+        }
+        let (start, end) = locs.get(0).unwrap();
+        Some(Match::new(haystack, start, end))
+    }
+}
+
+/// Auxiliary methods.
+impl Regex {
+    /// Returns the original string of this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"foo\w+bar").unwrap();
+    /// assert_eq!(re.as_str(), r"foo\w+bar");
+    /// ```
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        &self.pikevm.nfa().pattern()
+    }
+
+    /// Returns an iterator over the capture names in this regex.
+    ///
+    /// The iterator returned yields elements of type `Option<&str>`. That is,
+    /// the iterator yields values for all capture groups, even ones that are
+    /// unnamed. The order of the groups corresponds to the order of the group's
+    /// corresponding opening parenthesis.
+    ///
+    /// The first element of the iterator always yields the group corresponding
+    /// to the overall match, and this group is always unnamed. Therefore, the
+    /// iterator always yields at least one group.
+    ///
+    /// # Example
+    ///
+    /// This shows basic usage with a mix of named and unnamed capture groups:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), Some(Some("a")));
+    /// assert_eq!(names.next(), Some(Some("b")));
+    /// assert_eq!(names.next(), Some(None));
+    /// // the '(?:.)' group is non-capturing and so doesn't appear here!
+    /// assert_eq!(names.next(), Some(Some("c")));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    ///
+    /// The iterator always yields at least one element, even for regexes with
+    /// no capture groups and even for regexes that can never match:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    ///
+    /// let re = Regex::new(r"[^\s\S]").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    #[inline]
+    pub fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames(self.pikevm.nfa().capture_names())
+    }
+
+    /// Returns the number of captures groups in this regex.
+    ///
+    /// This includes all named and unnamed groups, including the implicit
+    /// unnamed group that is always present and corresponds to the entire
+    /// match.
+    ///
+    /// Since the implict unnamed group is always included in this length, the
+    /// length returned is guaranteed to be greater than zero.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"foo").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(foo)").unwrap();
+    /// assert_eq!(2, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// assert_eq!(5, re.captures_len());
+    ///
+    /// let re = Regex::new(r"[^\s\S]").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    /// ```
+    #[inline]
+    pub fn captures_len(&self) -> usize {
+        self.pikevm.nfa().group_len()
+    }
+
+    /// Returns the total number of capturing groups that appear in every
+    /// possible match.
+    ///
+    /// If the number of capture groups can vary depending on the match, then
+    /// this returns `None`. That is, a value is only returned when the number
+    /// of matching groups is invariant or "static."
+    ///
+    /// Note that like [`Regex::captures_len`], this **does** include the
+    /// implicit capturing group corresponding to the entire match. Therefore,
+    /// when a non-None value is returned, it is guaranteed to be at least `1`.
+    /// Stated differently, a return value of `Some(0)` is impossible.
+    ///
+    /// # Example
+    ///
+    /// This shows a few cases where a static number of capture groups is
+    /// available and a few cases where it is not.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let len = |pattern| {
+    ///     Regex::new(pattern).map(|re| re.static_captures_len())
+    /// };
+    ///
+    /// assert_eq!(Some(1), len("a")?);
+    /// assert_eq!(Some(2), len("(a)")?);
+    /// assert_eq!(Some(2), len("(a)|(b)")?);
+    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
+    /// assert_eq!(None, len("(a)|b")?);
+    /// assert_eq!(None, len("a|(b)")?);
+    /// assert_eq!(None, len("(b)*")?);
+    /// assert_eq!(Some(2), len("(b)+")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn static_captures_len(&self) -> Option<usize> {
+        self.pikevm
+            .nfa()
+            .static_explicit_captures_len()
+            .map(|len| len.saturating_add(1))
+    }
+
+    /// Returns a fresh allocated set of capture locations that can
+    /// be reused in multiple calls to [`Regex::captures_read`] or
+    /// [`Regex::captures_read_at`].
+    ///
+    /// The returned locations can be used for any subsequent search for this
+    /// particular regex. There is no guarantee that it is correct to use for
+    /// other regexes, even if they have the same number of capture groups.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(.)(.)(\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, "Padron").is_some());
+    /// assert_eq!(locs.get(0), Some((0, 6)));
+    /// assert_eq!(locs.get(1), Some((0, 1)));
+    /// assert_eq!(locs.get(2), Some((1, 2)));
+    /// assert_eq!(locs.get(3), Some((2, 6)));
+    /// ```
+    #[inline]
+    pub fn capture_locations(&self) -> CaptureLocations {
+        // OK because NFA construction would have failed if this overflowed.
+        let len = self.pikevm.nfa().group_len().checked_mul(2).unwrap();
+        CaptureLocations(vec![None; len])
+    }
+}
+
+/// Represents a single match of a regex in a haystack.
+///
+/// A `Match` contains both the start and end byte offsets of the match and the
+/// actual substring corresponding to the range of those byte offsets. It is
+/// guaranteed that `start <= end`. When `start == end`, the match is empty.
+///
+/// Since this `Match` can only be produced by the top-level `Regex` APIs
+/// that only support searching UTF-8 encoded strings, the byte offsets for a
+/// `Match` are guaranteed to fall on valid UTF-8 codepoint boundaries. That
+/// is, slicing a `&str` with [`Match::range`] is guaranteed to never panic.
+///
+/// Values with this type are created by [`Regex::find`] or
+/// [`Regex::find_iter`]. Other APIs can create `Match` values too. For
+/// example, [`Captures::get`].
+///
+/// The lifetime parameter `'h` refers to the lifetime of the matched of the
+/// haystack that this match was produced from.
+///
+/// # Numbering
+///
+/// The byte offsets in a `Match` form a half-open interval. That is, the
+/// start of the range is inclusive and the end of the range is exclusive.
+/// For example, given a haystack `abcFOOxyz` and a match of `FOO`, its byte
+/// offset range starts at `3` and ends at `6`. `3` corresponds to `F` and
+/// `6` corresponds to `x`, which is one past the end of the match. This
+/// corresponds to the same kind of slicing that Rust uses.
+///
+/// For more on why this was chosen over other schemes (aside from being
+/// consistent with how Rust the language works), see [this discussion] and
+/// [Dijkstra's note on a related topic][note].
+///
+/// [this discussion]: https://github.com/rust-lang/regex/discussions/866
+/// [note]: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html
+///
+/// # Example
+///
+/// This example shows the value of each of the methods on `Match` for a
+/// particular search.
+///
+/// ```
+/// use regex_lite::Regex;
+///
+/// let re = Regex::new(r"\d+").unwrap();
+/// let hay = "numbers: 1234";
+/// let m = re.find(hay).unwrap();
+/// assert_eq!(9, m.start());
+/// assert_eq!(13, m.end());
+/// assert!(!m.is_empty());
+/// assert_eq!(4, m.len());
+/// assert_eq!(9..13, m.range());
+/// assert_eq!("1234", m.as_str());
+/// ```
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct Match<'h> {
+    haystack: &'h str,
+    start: usize,
+    end: usize,
+}
+
+impl<'h> Match<'h> {
+    /// Creates a new match from the given haystack and byte offsets.
+    #[inline]
+    fn new(haystack: &'h str, start: usize, end: usize) -> Match<'h> {
+        Match { haystack, start, end }
+    }
+
+    /// Returns the byte offset of the start of the match in the haystack. The
+    /// start of the match corresponds to the position where the match begins
+    /// and includes the first byte in the match.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// This is guaranteed to fall on a valid UTF-8 codepoint boundary. That
+    /// is, it will never be an offset that appears between the UTF-8 code
+    /// units of a UTF-8 encoded Unicode scalar value. Consequently, it is
+    /// always safe to slice the corresponding haystack using this offset.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Returns the byte offset of the end of the match in the haystack. The
+    /// end of the match corresponds to the byte immediately following the last
+    /// byte in the match. This means that `&slice[start..end]` works as one
+    /// would expect.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// This is guaranteed to fall on a valid UTF-8 codepoint boundary. That
+    /// is, it will never be an offset that appears between the UTF-8 code
+    /// units of a UTF-8 encoded Unicode scalar value. Consequently, it is
+    /// always safe to slice the corresponding haystack using this offset.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    /// Returns true if and only if this match has a length of zero.
+    ///
+    /// Note that an empty match can only occur when the regex itself can
+    /// match the empty string. Here are some examples of regexes that can
+    /// all match the empty string: `^`, `^$`, `\b`, `a?`, `a*`, `a{0}`,
+    /// `(foo|\d+|quux)?`.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.start == self.end
+    }
+
+    /// Returns the length, in bytes, of this match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.end - self.start
+    }
+
+    /// Returns the range over the starting and ending byte offsets of the
+    /// match in the haystack.
+    ///
+    /// It is always correct to slice the original haystack searched with this
+    /// range. That is, because the offsets are guaranteed to fall on valid
+    /// UTF-8 boundaries, the range returned is always valid.
+    #[inline]
+    pub fn range(&self) -> core::ops::Range<usize> {
+        self.start..self.end
+    }
+
+    /// Returns the substring of the haystack that matched.
+    #[inline]
+    pub fn as_str(&self) -> &'h str {
+        &self.haystack[self.range()]
+    }
+}
+
+impl<'h> core::fmt::Debug for Match<'h> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("Match")
+            .field("start", &self.start)
+            .field("end", &self.end)
+            .field("string", &self.as_str())
+            .finish()
+    }
+}
+
+impl<'h> From<Match<'h>> for &'h str {
+    fn from(m: Match<'h>) -> &'h str {
+        m.as_str()
+    }
+}
+
+impl<'h> From<Match<'h>> for core::ops::Range<usize> {
+    fn from(m: Match<'h>) -> core::ops::Range<usize> {
+        m.range()
+    }
+}
+
+/// Represents the capture groups for a single match.
+///
+/// Capture groups refer to parts of a regex enclosed in parentheses. They can
+/// be optionally named. The purpose of capture groups is to be able to
+/// reference different parts of a match based on the original pattern. For
+/// example, say you want to match the individual letters in a 5-letter word:
+///
+/// ```text
+/// (?<first>\w)(\w)(?:\w)\w(?<last>\w)
+/// ```
+///
+/// This regex has 4 capture groups:
+///
+/// * The group at index `0` corresponds to the overall match. It is always
+/// present in every match and never has a name.
+/// * The group at index `1` with name `first` corresponding to the first
+/// letter.
+/// * The group at index `2` with no name corresponding to the second letter.
+/// * The group at index `3` with name `last` corresponding to the fifth and
+/// last letter.
+///
+/// Notice that `(?:\w)` was not listed above as a capture group despite it
+/// being enclosed in parentheses. That's because `(?:pattern)` is a special
+/// syntax that permits grouping but *without* capturing. The reason for not
+/// treating it as a capture is that tracking and reporting capture groups
+/// requires additional state that may lead to slower searches. So using as few
+/// capture groups as possible can help performance. (Although the difference
+/// in performance of a couple of capture groups is likely immaterial.)
+///
+/// Values with this type are created by [`Regex::captures`] or
+/// [`Regex::captures_iter`].
+///
+/// `'h` is the lifetime of the haystack that these captures were matched from.
+///
+/// # Example
+///
+/// ```
+/// use regex_lite::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w)(\w)(?:\w)\w(?<last>\w)").unwrap();
+/// let caps = re.captures("toady").unwrap();
+/// assert_eq!("toady", &caps[0]);
+/// assert_eq!("t", &caps["first"]);
+/// assert_eq!("o", &caps[2]);
+/// assert_eq!("y", &caps["last"]);
+/// ```
+pub struct Captures<'h> {
+    haystack: &'h str,
+    slots: CaptureLocations,
+    // It's a little weird to put the PikeVM in our Captures, but it's the
+    // simplest thing to do and is cheap. The PikeVM gives us access to the
+    // NFA and the NFA gives us access to the capture name<->index mapping.
+    pikevm: Arc<PikeVM>,
+}
+
+impl<'h> Captures<'h> {
+    /// Returns the `Match` associated with the capture group at index `i`. If
+    /// `i` does not correspond to a capture group, or if the capture group did
+    /// not participate in the match, then `None` is returned.
+    ///
+    /// When `i == 0`, this is guaranteed to return a non-`None` value.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
+    /// let caps = re.captures("abc123").unwrap();
+    ///
+    /// let substr1 = caps.get(1).map_or("", |m| m.as_str());
+    /// let substr2 = caps.get(2).map_or("", |m| m.as_str());
+    /// assert_eq!(substr1, "123");
+    /// assert_eq!(substr2, "");
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<Match<'h>> {
+        self.slots.get(i).map(|(s, e)| Match::new(self.haystack, s, e))
+    }
+
+    /// Returns the `Match` associated with the capture group named `name`. If
+    /// `name` isn't a valid capture group or it refers to a group that didn't
+    /// match, then `None` is returned.
+    ///
+    /// Note that unlike `caps["name"]`, this returns a `Match` whose lifetime
+    /// matches the lifetime of the haystack in this `Captures` value.
+    /// Conversely, the substring returned by `caps["name"]` has a lifetime
+    /// of the `Captures` value, which is likely shorter than the lifetime of
+    /// the haystack. In some cases, it may be necessary to use this method to
+    /// access the matching substring instead of the `caps["name"]` notation.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"[a-z]+(?:(?<numbers>[0-9]+)|(?<letters>[A-Z]+))",
+    /// ).unwrap();
+    /// let caps = re.captures("abc123").unwrap();
+    ///
+    /// let numbers = caps.name("numbers").map_or("", |m| m.as_str());
+    /// let letters = caps.name("letters").map_or("", |m| m.as_str());
+    /// assert_eq!(numbers, "123");
+    /// assert_eq!(letters, "");
+    /// ```
+    #[inline]
+    pub fn name(&self, name: &str) -> Option<Match<'h>> {
+        let i = self.pikevm.nfa().to_index(name)?;
+        self.get(i)
+    }
+
+    /// This is a convenience routine for extracting the substrings
+    /// corresponding to matching capture groups.
+    ///
+    /// This returns a tuple where the first element corresponds to the full
+    /// substring of the haystack that matched the regex. The second element is
+    /// an array of substrings, with each corresponding to the to the substring
+    /// that matched for a particular capture group.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the number of possible matching groups in this
+    /// `Captures` value is not fixed to `N` in all circumstances.
+    /// More precisely, this routine only works when `N` is equivalent to
+    /// [`Regex::static_captures_len`].
+    ///
+    /// Stated more plainly, if the number of matching capture groups in a
+    /// regex can vary from match to match, then this function always panics.
+    ///
+    /// For example, `(a)(b)|(c)` could produce two matching capture groups
+    /// or one matching capture group for any given match. Therefore, one
+    /// cannot use `extract` with such a pattern.
+    ///
+    /// But a pattern like `(a)(b)|(c)(d)` can be used with `extract` because
+    /// the number of capture groups in every match is always equivalent,
+    /// even if the capture _indices_ in each match are not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = "On 2010-03-14, I became a Tenneessee lamb.";
+    /// let Some((full, [year, month, day])) =
+    ///     re.captures(hay).map(|caps| caps.extract()) else { return };
+    /// assert_eq!("2010-03-14", full);
+    /// assert_eq!("2010", year);
+    /// assert_eq!("03", month);
+    /// assert_eq!("14", day);
+    /// ```
+    ///
+    /// # Example: iteration
+    ///
+    /// This example shows how to use this method when iterating over all
+    /// `Captures` matches in a haystack.
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = "1973-01-05, 1975-08-25 and 1980-10-18";
+    ///
+    /// let mut dates: Vec<(&str, &str, &str)> = vec![];
+    /// for (_, [y, m, d]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     dates.push((y, m, d));
+    /// }
+    /// assert_eq!(dates, vec![
+    ///     ("1973", "01", "05"),
+    ///     ("1975", "08", "25"),
+    ///     ("1980", "10", "18"),
+    /// ]);
+    /// ```
+    ///
+    /// # Example: parsing different formats
+    ///
+    /// This API is particularly useful when you need to extract a particular
+    /// value that might occur in a different format. Consider, for example,
+    /// an identifier that might be in double quotes or single quotes:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r#"id:(?:"([^"]+)"|'([^']+)')"#).unwrap();
+    /// let hay = r#"The first is id:"foo" and the second is id:'bar'."#;
+    /// let mut ids = vec![];
+    /// for (_, [id]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     ids.push(id);
+    /// }
+    /// assert_eq!(ids, vec!["foo", "bar"]);
+    /// ```
+    pub fn extract<const N: usize>(&self) -> (&'h str, [&'h str; N]) {
+        let len = self
+            .pikevm
+            .nfa()
+            .static_explicit_captures_len()
+            .expect("number of capture groups can vary in a match");
+        assert_eq!(N, len, "asked for {} groups, but must ask for {}", N, len);
+        let mut matched = self.iter().flatten();
+        let whole_match = matched.next().expect("a match").as_str();
+        let group_matches = [0; N].map(|_| {
+            matched.next().expect("too few matching groups").as_str()
+        });
+        (whole_match, group_matches)
+    }
+
+    /// Expands all instances of `$ref` in `replacement` to the corresponding
+    /// capture group, and writes them to the `dst` buffer given. A `ref` can
+    /// be a capture group index or a name. If `ref` doesn't refer to a capture
+    /// group that participated in the match, then it is replaced with the
+    /// empty string.
+    ///
+    /// # Format
+    ///
+    /// The format of the replacement string supports two different kinds of
+    /// capture references: unbraced and braced.
+    ///
+    /// For the unbraced format, the format supported is `$ref` where `name`
+    /// can be any character in the class `[0-9A-Za-z_]`. `ref` is always
+    /// the longest possible parse. So for example, `$1a` corresponds to the
+    /// capture group named `1a` and not the capture group at index `1`. If
+    /// `ref` matches `^[0-9]+$`, then it is treated as a capture group index
+    /// itself and not a name.
+    ///
+    /// For the braced format, the format supported is `${ref}` where `ref` can
+    /// be any sequence of bytes except for `}`. If no closing brace occurs,
+    /// then it is not considered a capture reference. As with the unbraced
+    /// format, if `ref` matches `^[0-9]+$`, then it is treated as a capture
+    /// group index and not a name.
+    ///
+    /// The braced format is useful for exerting precise control over the name
+    /// of the capture reference. For example, `${1}a` corresponds to the
+    /// capture group reference `1` followed by the letter `a`, where as `$1a`
+    /// (as mentioned above) corresponds to the capture group reference `1a`.
+    /// The braced format is also useful for expressing capture group names
+    /// that use characters not supported by the unbraced format. For example,
+    /// `${foo[bar].baz}` refers to the capture group named `foo[bar].baz`.
+    ///
+    /// If a capture group reference is found and it does not refer to a valid
+    /// capture group, then it will be replaced with the empty string.
+    ///
+    /// To write a literal `$`, use `$$`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    /// ).unwrap();
+    /// let hay = "On 14-03-2010, I became a Tenneessee lamb.";
+    /// let caps = re.captures(hay).unwrap();
+    ///
+    /// let mut dst = String::new();
+    /// caps.expand("year=$year, month=$month, day=$day", &mut dst);
+    /// assert_eq!(dst, "year=2010, month=03, day=14");
+    /// ```
+    #[inline]
+    pub fn expand(&self, replacement: &str, dst: &mut String) {
+        interpolate::string(
+            replacement,
+            |index, dst| {
+                let m = match self.get(index) {
+                    None => return,
+                    Some(m) => m,
+                };
+                dst.push_str(&self.haystack[m.range()]);
+            },
+            |name| self.pikevm.nfa().to_index(name),
+            dst,
+        );
+    }
+
+    /// Returns an iterator over all capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The iterator always yields at least one matching group: the first group
+    /// (at index `0`) with no name. Subsequent groups are returned in the order
+    /// of their opening parenthesis in the regex.
+    ///
+    /// The elements yielded have type `Option<Match<'h>>`, where a non-`None`
+    /// value is present if the capture group matches.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures("AZ").unwrap();
+    ///
+    /// let mut it = caps.iter();
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("AZ"));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("A"));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), None);
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("Z"));
+    /// assert_eq!(it.next(), None);
+    /// ```
+    #[inline]
+    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 'h> {
+        SubCaptureMatches {
+            caps: self,
+            it: self.pikevm.nfa().capture_names().enumerate(),
+        }
+    }
+
+    /// Returns the total number of capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The length returned is always equivalent to the number of elements
+    /// yielded by [`Captures::iter`]. Consequently, the length is always
+    /// greater than zero since every `Captures` value always includes the
+    /// match for the entire regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures("AZ").unwrap();
+    /// assert_eq!(caps.len(), 4);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.pikevm.nfa().group_len()
+    }
+}
+
+impl<'h> core::fmt::Debug for Captures<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        /// A little helper type to provide a nice map-like debug
+        /// representation for our capturing group spans.
+        ///
+        /// regex-automata has something similar, but it includes the pattern
+        /// ID in its debug output, which is confusing. It also doesn't include
+        /// that strings that match because a regex-automata `Captures` doesn't
+        /// borrow the haystack.
+        struct CapturesDebugMap<'a> {
+            caps: &'a Captures<'a>,
+        }
+
+        impl<'a> core::fmt::Debug for CapturesDebugMap<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                let mut map = f.debug_map();
+                let names = self.caps.pikevm.nfa().capture_names();
+                for (group_index, maybe_name) in names.enumerate() {
+                    let key = Key(group_index, maybe_name);
+                    match self.caps.get(group_index) {
+                        None => map.entry(&key, &None::<()>),
+                        Some(mat) => map.entry(&key, &Value(mat)),
+                    };
+                }
+                map.finish()
+            }
+        }
+
+        struct Key<'a>(usize, Option<&'a str>);
+
+        impl<'a> core::fmt::Debug for Key<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "{}", self.0)?;
+                if let Some(name) = self.1 {
+                    write!(f, "/{:?}", name)?;
+                }
+                Ok(())
+            }
+        }
+
+        struct Value<'a>(Match<'a>);
+
+        impl<'a> core::fmt::Debug for Value<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(
+                    f,
+                    "{}..{}/{:?}",
+                    self.0.start(),
+                    self.0.end(),
+                    self.0.as_str()
+                )
+            }
+        }
+
+        f.debug_tuple("Captures")
+            .field(&CapturesDebugMap { caps: self })
+            .finish()
+    }
+}
+
+/// Get a matching capture group's haystack substring by index.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// # Panics
+///
+/// If there is no matching group at the given index.
+impl<'h> core::ops::Index<usize> for Captures<'h> {
+    type Output = str;
+
+    // The lifetime is written out to make it clear that the &str returned
+    // does NOT have a lifetime equivalent to 'h.
+    fn index(&self, i: usize) -> &str {
+        self.get(i)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+    }
+}
+
+/// Get a matching capture group's haystack substring by name.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// `'n` is the lifetime of the group name used to index the `Captures` value.
+///
+/// # Panics
+///
+/// If there is no matching group at the given name.
+impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
+    type Output = str;
+
+    fn index<'a>(&'a self, name: &'n str) -> &'a str {
+        self.name(name)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group named '{}'", name))
+    }
+}
+
+/// A low level representation of the byte offsets of each capture group.
+///
+/// You can think of this as a lower level [`Captures`], where this type does
+/// not support named capturing groups directly and it does not borrow the
+/// haystack that these offsets were matched on.
+///
+/// Primarily, this type is useful when using the lower level `Regex` APIs such
+/// as [`Regex::captures_read`], which permits amortizing the allocation in
+/// which capture match offsets are stored.
+///
+/// In order to build a value of this type, you'll need to call the
+/// [`Regex::capture_locations`] method. The value returned can then be reused
+/// in subsequent searches for that regex. Using it for other regexes may
+/// result in a panic or otherwise incorrect results.
+///
+/// # Example
+///
+/// This example shows how to create and use `CaptureLocations` in a search.
+///
+/// ```
+/// use regex_lite::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+/// let mut locs = re.capture_locations();
+/// let m = re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+/// assert_eq!(0..17, m.range());
+/// assert_eq!(Some((0, 17)), locs.get(0));
+/// assert_eq!(Some((0, 5)), locs.get(1));
+/// assert_eq!(Some((6, 17)), locs.get(2));
+///
+/// // Asking for an invalid capture group always returns None.
+/// assert_eq!(None, locs.get(3));
+/// assert_eq!(None, locs.get(34973498648));
+/// assert_eq!(None, locs.get(9944060567225171988));
+/// ```
+#[derive(Clone, Debug)]
+pub struct CaptureLocations(Vec<Option<NonMaxUsize>>);
+
+impl CaptureLocations {
+    /// Returns the start and end byte offsets of the capture group at index
+    /// `i`. This returns `None` if `i` is not a valid capture group or if the
+    /// capture group did not match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+    /// assert_eq!(Some((0, 17)), locs.get(0));
+    /// assert_eq!(Some((0, 5)), locs.get(1));
+    /// assert_eq!(Some((6, 17)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
+        let slot = i.checked_mul(2)?;
+        let start = self.0.get(slot).copied()??.get();
+        let slot = slot.checked_add(1)?;
+        let end = self.0.get(slot).copied()??.get();
+        Some((start, end))
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    /// That is, the length returned is unaffected by the result of a search.
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert_eq!(3, locs.len());
+    /// re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+    /// assert_eq!(3, locs.len());
+    /// ```
+    ///
+    /// Notice that the length is always at least `1`, regardless of the regex:
+    ///
+    /// ```
+    /// use regex_lite::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    ///
+    /// // [a&&b] is a regex that never matches anything.
+    /// let re = Regex::new(r"[^\s\S]").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        // We always have twice as many slots as groups.
+        self.0.len().checked_shr(1).unwrap()
+    }
+}
+
+/// An iterator over all non-overlapping matches in a haystack.
+///
+/// This iterator yields [`Match`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the haystack.
+///
+/// This iterator is created by [`Regex::find_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Matches<'r, 'h> {
+    haystack: &'h str,
+    it: pikevm::FindMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for Matches<'r, 'h> {
+    type Item = Match<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match<'h>> {
+        self.it.next().map(|(s, e)| Match::new(self.haystack, s, e))
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Matches<'r, 'h> {}
+
+/// An iterator over all non-overlapping capture matches in a haystack.
+///
+/// This iterator yields [`Captures`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the matched string.
+///
+/// This iterator is created by [`Regex::captures_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct CaptureMatches<'r, 'h> {
+    haystack: &'h str,
+    re: &'r Regex,
+    it: pikevm::CapturesMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for CaptureMatches<'r, 'h> {
+    type Item = Captures<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures<'h>> {
+        self.it.next().map(|slots| Captures {
+            haystack: self.haystack,
+            slots: CaptureLocations(slots),
+            pikevm: Arc::clone(&self.re.pikevm),
+        })
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for CaptureMatches<'r, 'h> {}
+
+/// An iterator over all substrings delimited by a regex match.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::split`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Split<'r, 'h> {
+    haystack: &'h str,
+    finder: Matches<'r, 'h>,
+    last: usize,
+}
+
+impl<'r, 'h> Iterator for Split<'r, 'h> {
+    type Item = &'h str;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h str> {
+        match self.finder.next() {
+            None => {
+                let len = self.haystack.len();
+                if self.last > len {
+                    None
+                } else {
+                    let range = self.last..len;
+                    self.last = len + 1; // Next call will return None
+                    Some(&self.haystack[range])
+                }
+            }
+            Some(m) => {
+                let range = self.last..m.start();
+                self.last = m.end();
+                Some(&self.haystack[range])
+            }
+        }
+    }
+}
+
+impl<'r, 't> core::iter::FusedIterator for Split<'r, 't> {}
+
+/// An iterator over at most `N` substrings delimited by a regex match.
+///
+/// The last substring yielded by this iterator will be whatever remains after
+/// `N-1` splits.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::splitn`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+///
+/// Although note that the worst case time here has an upper bound given
+/// by the `limit` parameter to [`Regex::splitn`].
+#[derive(Debug)]
+pub struct SplitN<'r, 'h> {
+    splits: Split<'r, 'h>,
+    limit: usize,
+}
+
+impl<'r, 'h> Iterator for SplitN<'r, 'h> {
+    type Item = &'h str;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h str> {
+        if self.limit == 0 {
+            return None;
+        }
+
+        self.limit -= 1;
+        if self.limit > 0 {
+            return self.splits.next();
+        }
+
+        let len = self.splits.haystack.len();
+        if self.splits.last > len {
+            // We've already returned all substrings.
+            None
+        } else {
+            // self.n == 0, so future calls will return None immediately
+            Some(&self.splits.haystack[self.splits.last..len])
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.splits.size_hint()
+    }
+}
+
+impl<'r, 't> core::iter::FusedIterator for SplitN<'r, 't> {}
+
+/// An iterator over the names of all capture groups in a regex.
+///
+/// This iterator yields values of type `Option<&str>` in order of the opening
+/// capture group parenthesis in the regex pattern. `None` is yielded for
+/// groups with no name. The first element always corresponds to the implicit
+/// and unnamed group for the overall match.
+///
+/// `'r` is the lifetime of the compiled regular expression.
+///
+/// This iterator is created by [`Regex::capture_names`].
+#[derive(Clone, Debug)]
+pub struct CaptureNames<'r>(nfa::CaptureNames<'r>);
+
+impl<'r> Iterator for CaptureNames<'r> {
+    type Item = Option<&'r str>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<&'r str>> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<'r> ExactSizeIterator for CaptureNames<'r> {}
+
+impl<'r> core::iter::FusedIterator for CaptureNames<'r> {}
+
+/// An iterator over all group matches in a [`Captures`] value.
+///
+/// This iterator yields values of type `Option<Match<'h>>`, where `'h` is the
+/// lifetime of the haystack that the matches are for. The order of elements
+/// yielded corresponds to the order of the opening parenthesis for the group
+/// in the regex pattern. `None` is yielded for groups that did not participate
+/// in the match.
+///
+/// The first element always corresponds to the implicit group for the overall
+/// match. Since this iterator is created by a [`Captures`] value, and a
+/// `Captures` value is only created when a match occurs, it follows that the
+/// first element yielded by this iterator is guaranteed to be non-`None`.
+///
+/// The lifetime `'c` corresponds to the lifetime of the `Captures` value that
+/// created this iterator, and the lifetime `'h` corresponds to the originally
+/// matched haystack.
+#[derive(Clone, Debug)]
+pub struct SubCaptureMatches<'c, 'h> {
+    caps: &'c Captures<'h>,
+    it: core::iter::Enumerate<nfa::CaptureNames<'c>>,
+}
+
+impl<'c, 'h> Iterator for SubCaptureMatches<'c, 'h> {
+    type Item = Option<Match<'h>>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<Match<'h>>> {
+        let (group_index, _) = self.it.next()?;
+        Some(self.caps.get(group_index))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'c, 'h> ExactSizeIterator for SubCaptureMatches<'c, 'h> {}
+
+impl<'c, 'h> core::iter::FusedIterator for SubCaptureMatches<'c, 'h> {}
+
+/// A trait for types that can be used to replace matches in a haystack.
+///
+/// In general, users of this crate shouldn't need to implement this trait,
+/// since implementations are already provided for `&str` along with other
+/// variants of string types, as well as `FnMut(&Captures) -> String` (or any
+/// `FnMut(&Captures) -> T` where `T: AsRef<str>`). Those cover most use cases,
+/// but callers can implement this trait directly if necessary.
+///
+/// # Example
+///
+/// This example shows a basic implementation of  the `Replacer` trait. This
+/// can be done much more simply using the replacement string interpolation
+/// support (e.g., `$first $last`), but this approach avoids needing to parse
+/// the replacement string at all.
+///
+/// ```
+/// use regex_lite::{Captures, Regex, Replacer};
+///
+/// struct NameSwapper;
+///
+/// impl Replacer for NameSwapper {
+///     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+///         dst.push_str(&caps["first"]);
+///         dst.push_str(" ");
+///         dst.push_str(&caps["last"]);
+///     }
+/// }
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+/// let result = re.replace("Springsteen, Bruce", NameSwapper);
+/// assert_eq!(result, "Bruce Springsteen");
+/// ```
+pub trait Replacer {
+    /// Appends possibly empty data to `dst` to replace the current match.
+    ///
+    /// The current match is represented by `caps`, which is guaranteed to
+    /// have a match at capture group `0`.
+    ///
+    /// For example, a no-op replacement would be `dst.push_str(&caps[0])`.
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String);
+
+    /// Return a fixed unchanging replacement string.
+    ///
+    /// When doing replacements, if access to [`Captures`] is not needed (e.g.,
+    /// the replacement string does not need `$` expansion), then it can be
+    /// beneficial to avoid finding sub-captures.
+    ///
+    /// In general, this is called once for every call to a replacement routine
+    /// such as [`Regex::replace_all`].
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, str>> {
+        None
+    }
+
+    /// Returns a type that implements `Replacer`, but that borrows and wraps
+    /// this `Replacer`.
+    ///
+    /// This is useful when you want to take a generic `Replacer` (which might
+    /// not be cloneable) and use it without consuming it, so it can be used
+    /// more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::{Regex, Replacer};
+    ///
+    /// fn replace_all_twice<R: Replacer>(
+    ///     re: Regex,
+    ///     src: &str,
+    ///     mut rep: R,
+    /// ) -> String {
+    ///     let dst = re.replace_all(src, rep.by_ref());
+    ///     let dst = re.replace_all(&dst, rep.by_ref());
+    ///     dst.into_owned()
+    /// }
+    /// ```
+    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
+        ReplacerRef(self)
+    }
+}
+
+impl<'a> Replacer for &'a str {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl Replacer for String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<F, T> Replacer for F
+where
+    F: FnMut(&Captures<'_>) -> T,
+    T: AsRef<str>,
+{
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        dst.push_str((*self)(caps).as_ref());
+    }
+}
+
+/// A by-reference adaptor for a [`Replacer`].
+///
+/// This permits reusing the same `Replacer` value in multiple calls to a
+/// replacement routine like [`Regex::replace_all`].
+///
+/// This type is created by [`Replacer::by_ref`].
+#[derive(Debug)]
+pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
+
+impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.0.replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        self.0.no_expansion()
+    }
+}
+
+/// A helper type for forcing literal string replacement.
+///
+/// It can be used with routines like [`Regex::replace`] and
+/// [`Regex::replace_all`] to do a literal string replacement without expanding
+/// `$name` to their corresponding capture groups. This can be both convenient
+/// (to avoid escaping `$`, for example) and faster (since capture groups
+/// don't need to be found).
+///
+/// `'s` is the lifetime of the literal string to use.
+///
+/// # Example
+///
+/// ```
+/// use regex_lite::{NoExpand, Regex};
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+/// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
+/// assert_eq!(result, "$2 $last");
+/// ```
+#[derive(Clone, Debug)]
+pub struct NoExpand<'t>(pub &'t str);
+
+impl<'t> Replacer for NoExpand<'t> {
+    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut String) {
+        dst.push_str(self.0);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        Some(Cow::Borrowed(self.0))
+    }
+}
+
+/// Quickly checks the given replacement string for whether interpolation
+/// should be done on it. It returns `None` if a `$` was found anywhere in the
+/// given string, which suggests interpolation needs to be done. But if there's
+/// no `$` anywhere, then interpolation definitely does not need to be done. In
+/// that case, the given string is returned as a borrowed `Cow`.
+///
+/// This is meant to be used to implement the `Replacer::no_expandsion` method
+/// in its various trait impls.
+fn no_expansion<T: AsRef<str>>(t: &T) -> Option<Cow<'_, str>> {
+    let s = t.as_ref();
+    match s.find('$') {
+        Some(_) => None,
+        None => Some(Cow::Borrowed(s)),
+    }
+}
+
+/// A configurable builder for a [`Regex`].
+///
+/// This builder can be used to programmatically set flags such as `i` (case
+/// insensitive) and `x` (for verbose mode). This builder can also be used to
+/// configure things like a size limit on the compiled regular expression.
+#[derive(Debug)]
+pub struct RegexBuilder {
+    pattern: String,
+    hir_config: hir::Config,
+    nfa_config: nfa::Config,
+}
+
+impl RegexBuilder {
+    /// Create a new builder with a default configuration for the given
+    /// pattern.
+    ///
+    /// If the pattern is invalid or exceeds the configured size limits, then
+    /// an error will be returned when [`RegexBuilder::build`] is called.
+    pub fn new(pattern: &str) -> RegexBuilder {
+        RegexBuilder {
+            pattern: pattern.to_string(),
+            hir_config: hir::Config::default(),
+            nfa_config: nfa::Config::default(),
+        }
+    }
+
+    /// Compiles the pattern given to `RegexBuilder::new` with the
+    /// configuration set on this builder.
+    ///
+    /// If the pattern isn't a valid regex or if a configured size limit was
+    /// exceeded, then an error is returned.
+    pub fn build(&self) -> Result<Regex, Error> {
+        let hir = Hir::parse(self.hir_config, &self.pattern)?;
+        let nfa = NFA::new(self.nfa_config, self.pattern.clone(), &hir)?;
+        let pikevm = Arc::new(PikeVM::new(nfa));
+        let pool = {
+            let pikevm = Arc::clone(&pikevm);
+            let create = Box::new(move || Cache::new(&pikevm));
+            CachePool::new(create)
+        };
+        Ok(Regex { pikevm, pool })
+    }
+
+    /// This configures whether to enable ASCII case insensitive matching for
+    /// the entire pattern.
+    ///
+    /// This setting can also be configured using the inline flag `i`
+    /// in the pattern. For example, `(?i:foo)` matches `foo` case
+    /// insensitively while `(?-i:foo)` matches `foo` case sensitively.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"foo(?-i:bar)quux")
+    ///     .case_insensitive(true)
+    ///     .build()
+    ///     .unwrap();
+    /// assert!(re.is_match("FoObarQuUx"));
+    /// // Even though case insensitive matching is enabled in the builder,
+    /// // it can be locally disabled within the pattern. In this case,
+    /// // `bar` is matched case sensitively.
+    /// assert!(!re.is_match("fooBARquux"));
+    /// ```
+    pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.case_insensitive = yes;
+        self
+    }
+
+    /// This configures multi-line mode for the entire pattern.
+    ///
+    /// Enabling multi-line mode changes the behavior of the `^` and `$` anchor
+    /// assertions. Instead of only matching at the beginning and end of a
+    /// haystack, respectively, multi-line mode causes them to match at the
+    /// beginning and end of a line *in addition* to the beginning and end of
+    /// a haystack. More precisely, `^` will match at the position immediately
+    /// following a `\n` and `$` will match at the position immediately
+    /// preceding a `\n`.
+    ///
+    /// The behavior of this option is impacted by the [`RegexBuilder::crlf`]
+    /// setting. Namely, CRLF mode changes the line terminator to be either
+    /// `\r` or `\n`, but never at the position between a `\r` and `\`n.
+    ///
+    /// This setting can also be configured using the inline flag `m` in the
+    /// pattern.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"^foo$")
+    ///     .multi_line(true)
+    ///     .build()
+    ///     .unwrap();
+    /// assert_eq!(Some(1..4), re.find("\nfoo\n").map(|m| m.range()));
+    /// ```
+    pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.multi_line = yes;
+        self
+    }
+
+    /// This configures dot-matches-new-line mode for the entire pattern.
+    ///
+    /// Perhaps surprisingly, the default behavior for `.` is not to match
+    /// any character, but rather, to match any character except for the line
+    /// terminator (which is `\n` by default). When this mode is enabled, the
+    /// behavior changes such that `.` truly matches any character.
+    ///
+    /// This setting can also be configured using the inline flag `s` in the
+    /// pattern.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"foo.bar")
+    ///     .dot_matches_new_line(true)
+    ///     .build()
+    ///     .unwrap();
+    /// let hay = "foo\nbar";
+    /// assert_eq!(Some("foo\nbar"), re.find(hay).map(|m| m.as_str()));
+    /// ```
+    pub fn dot_matches_new_line(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.dot_matches_new_line = yes;
+        self
+    }
+
+    /// This configures CRLF mode for the entire pattern.
+    ///
+    /// When CRLF mode is enabled, both `\r` ("carriage return" or CR for
+    /// short) and `\n` ("line feed" or LF for short) are treated as line
+    /// terminators. This results in the following:
+    ///
+    /// * Unless dot-matches-new-line mode is enabled, `.` will now match any
+    /// character except for `\n` and `\r`.
+    /// * When multi-line mode is enabled, `^` will match immediatelly
+    /// following a `\n` or a `\r`. Similarly, `$` will match immediately
+    /// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match between
+    /// `\r` and `\n`.
+    ///
+    /// This setting can also be configured using the inline flag `R` in
+    /// the pattern.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"^foo$")
+    ///     .multi_line(true)
+    ///     .crlf(true)
+    ///     .build()
+    ///     .unwrap();
+    /// let hay = "\r\nfoo\r\n";
+    /// // If CRLF mode weren't enabled here, then '$' wouldn't match
+    /// // immediately after 'foo', and thus no match would be found.
+    /// assert_eq!(Some("foo"), re.find(hay).map(|m| m.as_str()));
+    /// ```
+    ///
+    /// This example demonstrates that `^` will never match at a position
+    /// between `\r` and `\n`. (`$` will similarly not match between a `\r`
+    /// and a `\n`.)
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"^")
+    ///     .multi_line(true)
+    ///     .crlf(true)
+    ///     .build()
+    ///     .unwrap();
+    /// let hay = "\r\n\r\n";
+    /// let ranges: Vec<_> = re.find_iter(hay).map(|m| m.range()).collect();
+    /// assert_eq!(ranges, vec![0..0, 2..2, 4..4]);
+    /// ```
+    pub fn crlf(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.crlf = yes;
+        self
+    }
+
+    /// This configures swap-greed mode for the entire pattern.
+    ///
+    /// When swap-greed mode is enabled, patterns like `a+` will become
+    /// non-greedy and patterns like `a+?` will become greedy. In other words,
+    /// the meanings of `a+` and `a+?` are switched.
+    ///
+    /// This setting can also be configured using the inline flag `U` in the
+    /// pattern.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let re = RegexBuilder::new(r"a+")
+    ///     .swap_greed(true)
+    ///     .build()
+    ///     .unwrap();
+    /// assert_eq!(Some("a"), re.find("aaa").map(|m| m.as_str()));
+    /// ```
+    pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.swap_greed = yes;
+        self
+    }
+
+    /// This configures verbose mode for the entire pattern.
+    ///
+    /// When enabled, whitespace will treated as insignifcant in the pattern
+    /// and `#` can be used to start a comment until the next new line.
+    ///
+    /// Normally, in most places in a pattern, whitespace is treated literally.
+    /// For example ` +` will match one or more ASCII whitespace characters.
+    ///
+    /// When verbose mode is enabled, `\#` can be used to match a literal `#`
+    /// and `\ ` can be used to match a literal ASCII whitespace character.
+    ///
+    /// Verbose mode is useful for permitting regexes to be formatted and
+    /// broken up more nicely. This may make them more easily readable.
+    ///
+    /// This setting can also be configured using the inline flag `x` in the
+    /// pattern.
+    ///
+    /// The default for this is `false`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// let pat = r"
+    ///     \b
+    ///     (?<first>[A-Z]\w*)  # always start with uppercase letter
+    ///     \s+                 # whitespace should separate names
+    ///     (?: # middle name can be an initial!
+    ///         (?:(?<initial>[A-Z])\.|(?<middle>[A-Z]\w*))
+    ///         \s+
+    ///     )?
+    ///     (?<last>[A-Z]\w*)
+    ///     \b
+    /// ";
+    /// let re = RegexBuilder::new(pat)
+    ///     .ignore_whitespace(true)
+    ///     .build()
+    ///     .unwrap();
+    ///
+    /// let caps = re.captures("Harry Potter").unwrap();
+    /// assert_eq!("Harry", &caps["first"]);
+    /// assert_eq!("Potter", &caps["last"]);
+    ///
+    /// let caps = re.captures("Harry J. Potter").unwrap();
+    /// assert_eq!("Harry", &caps["first"]);
+    /// // Since a middle name/initial isn't required for an overall match,
+    /// // we can't assume that 'initial' or 'middle' will be populated!
+    /// assert_eq!(Some("J"), caps.name("initial").map(|m| m.as_str()));
+    /// assert_eq!(None, caps.name("middle").map(|m| m.as_str()));
+    /// assert_eq!("Potter", &caps["last"]);
+    ///
+    /// let caps = re.captures("Harry James Potter").unwrap();
+    /// assert_eq!("Harry", &caps["first"]);
+    /// // Since a middle name/initial isn't required for an overall match,
+    /// // we can't assume that 'initial' or 'middle' will be populated!
+    /// assert_eq!(None, caps.name("initial").map(|m| m.as_str()));
+    /// assert_eq!(Some("James"), caps.name("middle").map(|m| m.as_str()));
+    /// assert_eq!("Potter", &caps["last"]);
+    /// ```
+    pub fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexBuilder {
+        self.hir_config.flags.ignore_whitespace = yes;
+        self
+    }
+
+    /// Sets the approximate size limit, in bytes, of the compiled regex.
+    ///
+    /// This roughly corresponds to the number of heap memory, in bytes,
+    /// occupied by a single regex. If the regex would otherwise approximately
+    /// exceed this limit, then compiling that regex will fail.
+    ///
+    /// The main utility of a method like this is to avoid compiling regexes
+    /// that use an unexpected amount of resources, such as time and memory.
+    /// Even if the memory usage of a large regex is acceptable, its search
+    /// time may not be. Namely, worst case time complexity for search is `O(m
+    /// * n)`, where `m ~ len(pattern)` and `n ~ len(haystack)`. That is,
+    /// search time depends, in part, on the size of the compiled regex. This
+    /// means that putting a limit on the size of the regex limits how much a
+    /// regex can impact search time.
+    ///
+    /// The default for this is some reasonable number that permits most
+    /// patterns to compile successfully.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// assert!(RegexBuilder::new(r"\w").size_limit(100).build().is_err());
+    /// ```
+    pub fn size_limit(&mut self, limit: usize) -> &mut RegexBuilder {
+        self.nfa_config.size_limit = Some(limit);
+        self
+    }
+
+    /// Set the nesting limit for this parser.
+    ///
+    /// The nesting limit controls how deep the abstract syntax tree is allowed
+    /// to be. If the AST exceeds the given limit (e.g., with too many nested
+    /// groups), then an error is returned by the parser.
+    ///
+    /// The purpose of this limit is to act as a heuristic to prevent stack
+    /// overflow for consumers that do structural induction on an AST using
+    /// explicit recursion. While this crate never does this (instead using
+    /// constant stack space and moving the call stack to the heap), other
+    /// crates may.
+    ///
+    /// This limit is not checked until the entire AST is parsed. Therefore, if
+    /// callers want to put a limit on the amount of heap space used, then they
+    /// should impose a limit on the length, in bytes, of the concrete pattern
+    /// string. In particular, this is viable since this parser implementation
+    /// will limit itself to heap space proportional to the length of the
+    /// pattern string. See also the [untrusted inputs](crate#untrusted-input)
+    /// section in the top-level crate documentation for more information about
+    /// this.
+    ///
+    /// Note that a nest limit of `0` will return a nest limit error for most
+    /// patterns but not all. For example, a nest limit of `0` permits `a` but
+    /// not `ab`, since `ab` requires an explicit concatenation, which results
+    /// in a nest depth of `1`. In general, a nest limit is not something that
+    /// manifests in an obvious way in the concrete syntax, therefore, it
+    /// should not be used in a granular way.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_lite::RegexBuilder;
+    ///
+    /// assert!(RegexBuilder::new(r"").nest_limit(0).build().is_ok());
+    /// assert!(RegexBuilder::new(r"a").nest_limit(0).build().is_ok());
+    /// assert!(RegexBuilder::new(r"(a)").nest_limit(0).build().is_err());
+    /// ```
+    pub fn nest_limit(&mut self, limit: u32) -> &mut RegexBuilder {
+        self.hir_config.nest_limit = limit;
+        self
+    }
+}
diff --git a/regex-lite/src/utf8.rs b/regex-lite/src/utf8.rs
new file mode 100644
index 0000000000..5f2a6a153c
--- /dev/null
+++ b/regex-lite/src/utf8.rs
@@ -0,0 +1,240 @@
+/// Returns true if and only if the given byte is considered a word character.
+/// This only applies to ASCII.
+pub(crate) fn is_word_byte(b: u8) -> bool {
+    const fn mkwordset() -> [bool; 256] {
+        // FIXME: Use as_usize() once const functions in traits are stable.
+        let mut set = [false; 256];
+        set[b'_' as usize] = true;
+
+        let mut byte = b'0';
+        while byte <= b'9' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        byte = b'A';
+        while byte <= b'Z' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        byte = b'a';
+        while byte <= b'z' {
+            set[byte as usize] = true;
+            byte += 1;
+        }
+        set
+    }
+    const WORD: [bool; 256] = mkwordset();
+    WORD[b as usize]
+}
+
+/// The accept state index. When we enter this state, we know we've found a
+/// valid Unicode scalar value.
+const ACCEPT: usize = 12;
+/// The reject state index. When we enter this state, we know that we've found
+/// invalid UTF-8.
+const REJECT: usize = 0;
+
+/// Like `decode`, but automatically converts the `None` case to the
+/// replacement codepoint.
+pub(crate) fn decode_lossy<B: AsRef<[u8]>>(slice: B) -> (char, usize) {
+    match decode(slice) {
+        (Some(ch), size) => (ch, size),
+        (None, size) => ('\u{FFFD}', size),
+    }
+}
+
+/// UTF-8 decode a single Unicode scalar value from the beginning of a slice.
+///
+/// When successful, the corresponding Unicode scalar value is returned along
+/// with the number of bytes it was encoded with. The number of bytes consumed
+/// for a successful decode is always between 1 and 4, inclusive.
+///
+/// When unsuccessful, `None` is returned along with the number of bytes that
+/// make up a maximal prefix of a valid UTF-8 code unit sequence. In this case,
+/// the number of bytes consumed is always between 0 and 3, inclusive, where
+/// 0 is only returned when `slice` is empty.
+pub(crate) fn decode<B: AsRef<[u8]>>(slice: B) -> (Option<char>, usize) {
+    let slice = slice.as_ref();
+    match slice.get(0) {
+        None => return (None, 0),
+        Some(&b) if b <= 0x7F => return (Some(b as char), 1),
+        _ => {}
+    }
+
+    let (mut state, mut cp, mut i) = (ACCEPT, 0, 0);
+    while i < slice.len() {
+        decode_step(&mut state, &mut cp, slice[i]);
+        i += 1;
+
+        if state == ACCEPT {
+            // OK since `decode_step` guarantees that `cp` is a valid Unicode
+            // scalar value in an ACCEPT state.
+            //
+            // We don't have to use safe code here, but do so because perf
+            // isn't our primary objective in regex-lite.
+            let ch = char::from_u32(cp).unwrap();
+            return (Some(ch), i);
+        } else if state == REJECT {
+            // At this point, we always want to advance at least one byte.
+            return (None, core::cmp::max(1, i.saturating_sub(1)));
+        }
+    }
+    (None, i)
+}
+
+/// Transitions to the next state and updates `cp` while it does.
+fn decode_step(state: &mut usize, cp: &mut u32, b: u8) {
+    // Splits the space of all bytes into equivalence classes, such that
+    // any byte in the same class can never discriminate between whether a
+    // particular sequence is valid UTF-8 or not.
+    #[cfg_attr(rustfmt, rustfmt::skip)]
+    const CLASSES: [u8; 256] = [
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+       8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+      10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+    ];
+
+    // A state machine taken from `bstr` which was in turn adapted from:
+    // https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    #[cfg_attr(rustfmt, rustfmt::skip)]
+    const STATES_FORWARD: &'static [u8] = &[
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      12, 0, 24, 36, 60, 96, 84, 0, 0, 0, 48, 72,
+      0, 12, 0, 0, 0, 0, 0, 12, 0, 12, 0, 0,
+      0, 24, 0, 0, 0, 0, 0, 24, 0, 24, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0,
+      0, 24, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 36, 0, 36, 0, 0,
+      0, 36, 0, 0, 0, 0, 0, 36, 0, 36, 0, 0,
+      0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+
+    let class = CLASSES[usize::from(b)];
+    if *state == ACCEPT {
+        *cp = (0xFF >> class) & (b as u32);
+    } else {
+        *cp = (b as u32 & 0b111111) | (*cp << 6);
+    }
+    *state = usize::from(STATES_FORWARD[*state + usize::from(class)]);
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::{vec, vec::Vec};
+
+    use super::*;
+
+    #[test]
+    fn decode_valid() {
+        fn d(mut s: &str) -> Vec<char> {
+            let mut chars = vec![];
+            while !s.is_empty() {
+                let (ch, size) = decode(s.as_bytes());
+                s = &s[size..];
+                chars.push(ch.unwrap());
+            }
+            chars
+        }
+
+        assert_eq!(vec!['☃'], d("☃"));
+        assert_eq!(vec!['☃', '☃'], d("☃☃"));
+        assert_eq!(vec!['α', 'β', 'γ', 'δ', 'ε'], d("αβγδε"));
+        assert_eq!(vec!['☃', '⛄', '⛇'], d("☃⛄⛇"));
+        assert_eq!(vec!['𝗮', '𝗯', '𝗰', '𝗱', '𝗲'], d("𝗮𝗯𝗰𝗱𝗲"));
+    }
+
+    #[test]
+    fn decode_invalid() {
+        let (ch, size) = decode(b"");
+        assert_eq!(None, ch);
+        assert_eq!(0, size);
+
+        let (ch, size) = decode(b"\xFF");
+        assert_eq!(None, ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode(b"\xCE\xF0");
+        assert_eq!(None, ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode(b"\xE2\x98\xF0");
+        assert_eq!(None, ch);
+        assert_eq!(2, size);
+
+        let (ch, size) = decode(b"\xF0\x9D\x9D");
+        assert_eq!(None, ch);
+        assert_eq!(3, size);
+
+        let (ch, size) = decode(b"\xF0\x9D\x9D\xF0");
+        assert_eq!(None, ch);
+        assert_eq!(3, size);
+
+        let (ch, size) = decode(b"\xF0\x82\x82\xAC");
+        assert_eq!(None, ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode(b"\xED\xA0\x80");
+        assert_eq!(None, ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode(b"\xCEa");
+        assert_eq!(None, ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode(b"\xE2\x98a");
+        assert_eq!(None, ch);
+        assert_eq!(2, size);
+
+        let (ch, size) = decode(b"\xF0\x9D\x9Ca");
+        assert_eq!(None, ch);
+        assert_eq!(3, size);
+    }
+
+    #[test]
+    fn decode_lossily() {
+        let (ch, size) = decode_lossy(b"");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(0, size);
+
+        let (ch, size) = decode_lossy(b"\xFF");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode_lossy(b"\xCE\xF0");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode_lossy(b"\xE2\x98\xF0");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(2, size);
+
+        let (ch, size) = decode_lossy(b"\xF0\x9D\x9D\xF0");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(3, size);
+
+        let (ch, size) = decode_lossy(b"\xF0\x82\x82\xAC");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode_lossy(b"\xED\xA0\x80");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode_lossy(b"\xCEa");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(1, size);
+
+        let (ch, size) = decode_lossy(b"\xE2\x98a");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(2, size);
+
+        let (ch, size) = decode_lossy(b"\xF0\x9D\x9Ca");
+        assert_eq!('\u{FFFD}', ch);
+        assert_eq!(3, size);
+    }
+}
diff --git a/regex-lite/tests/fuzz/mod.rs b/regex-lite/tests/fuzz/mod.rs
new file mode 100644
index 0000000000..6eb37b50bb
--- /dev/null
+++ b/regex-lite/tests/fuzz/mod.rs
@@ -0,0 +1,34 @@
+#[test]
+fn captures_wrong_order() {
+    let data = include_bytes!(
+        "testdata/crash-a886ce2b0d64963f1232f9b08b8c9ad4740c26f5"
+    );
+    let _ = run(data);
+}
+
+#[test]
+fn captures_wrong_order_min() {
+    let data = include_bytes!(
+        "testdata/minimized-from-298f84f9dbb2589cb9938a63334fa4083b609f34"
+    );
+    let _ = run(data);
+}
+
+// This is the fuzz target function. We duplicate it here since this is the
+// thing we use to interpret the data. It is ultimately what we want to
+// succeed.
+fn run(data: &[u8]) -> Option<()> {
+    if data.len() < 2 {
+        return None;
+    }
+    let mut split_at = usize::from(data[0]);
+    let data = std::str::from_utf8(&data[1..]).ok()?;
+    // Split data into a regex and haystack to search.
+    let len = usize::try_from(data.chars().count()).ok()?;
+    split_at = std::cmp::max(split_at, 1) % len;
+    let char_index = data.char_indices().nth(split_at)?.0;
+    let (pattern, input) = data.split_at(char_index);
+    let re = regex_lite::Regex::new(pattern).ok()?;
+    re.is_match(input);
+    Some(())
+}
diff --git a/regex-lite/tests/fuzz/testdata/crash-a886ce2b0d64963f1232f9b08b8c9ad4740c26f5 b/regex-lite/tests/fuzz/testdata/crash-a886ce2b0d64963f1232f9b08b8c9ad4740c26f5
new file mode 100644
index 0000000000..637eb0cf19
Binary files /dev/null and b/regex-lite/tests/fuzz/testdata/crash-a886ce2b0d64963f1232f9b08b8c9ad4740c26f5 differ
diff --git a/regex-lite/tests/fuzz/testdata/minimized-from-298f84f9dbb2589cb9938a63334fa4083b609f34 b/regex-lite/tests/fuzz/testdata/minimized-from-298f84f9dbb2589cb9938a63334fa4083b609f34
new file mode 100644
index 0000000000..13cdf24da7
Binary files /dev/null and b/regex-lite/tests/fuzz/testdata/minimized-from-298f84f9dbb2589cb9938a63334fa4083b609f34 differ
diff --git a/regex-lite/tests/lib.rs b/regex-lite/tests/lib.rs
new file mode 100644
index 0000000000..757b394411
--- /dev/null
+++ b/regex-lite/tests/lib.rs
@@ -0,0 +1,49 @@
+mod fuzz;
+mod string;
+
+const BLACKLIST: &[&str] = &[
+    // Custom line terminators aren't supported in regex-lite. We could add it,
+    // but it didn't seem worth it.
+    "line-terminator",
+];
+
+fn suite() -> anyhow::Result<regex_test::RegexTests> {
+    let mut tests = regex_test::RegexTests::new();
+    macro_rules! load {
+        ($name:expr) => {{
+            const DATA: &[u8] =
+                include_bytes!(concat!("../../testdata/", $name, ".toml"));
+            tests.load_slice($name, DATA)?;
+        }};
+    }
+
+    load!("anchored");
+    load!("bytes");
+    load!("crazy");
+    load!("crlf");
+    load!("earliest");
+    load!("empty");
+    load!("expensive");
+    load!("flags");
+    load!("iter");
+    load!("leftmost-all");
+    load!("line-terminator");
+    load!("misc");
+    load!("multiline");
+    load!("no-unicode");
+    load!("overlapping");
+    load!("regression");
+    load!("set");
+    load!("substring");
+    load!("unicode");
+    load!("utf8");
+    load!("word-boundary");
+    load!("fowler/basic");
+    load!("fowler/nullsubexpr");
+    load!("fowler/repetition");
+
+    // Special tests for regex-lite specifically.
+    load!("regex-lite");
+
+    Ok(tests)
+}
diff --git a/regex-lite/tests/string.rs b/regex-lite/tests/string.rs
new file mode 100644
index 0000000000..283e103a2e
--- /dev/null
+++ b/regex-lite/tests/string.rs
@@ -0,0 +1,150 @@
+use {
+    anyhow::Result,
+    regex_lite::{Regex, RegexBuilder},
+    regex_test::{
+        CompiledRegex, Match, RegexTest, Span, TestResult, TestRunner,
+    },
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+    let hay = match std::str::from_utf8(test.haystack()) {
+        Ok(hay) => hay,
+        Err(err) => {
+            return TestResult::fail(&format!(
+                "haystack is not valid UTF-8: {}",
+                err
+            ));
+        }
+    };
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(hay)),
+        "find" => TestResult::matches(
+            re.find_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|m| Match {
+                    id: 0,
+                    span: Span { start: m.start(), end: m.end() },
+                }),
+        ),
+        "captures" => {
+            let it = re
+                .captures_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|caps| testify_captures(&caps));
+            TestResult::captures(it)
+        }
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let Some(pattern) = skip_or_get_pattern(test) else {
+        return Ok(CompiledRegex::skip());
+    };
+    let re = RegexBuilder::new(pattern)
+        .case_insensitive(test.case_insensitive())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
+
+/// Whether we should skip the given test or not. If not, return the single
+/// pattern from the given test.
+fn skip_or_get_pattern(test: &RegexTest) -> Option<&str> {
+    // We're only testing Regex here, which supports one pattern only.
+    let pattern = match test.regexes().len() {
+        1 => &test.regexes()[0],
+        _ => return None,
+    };
+    // If the test name contains 'regex-lite', then we ALWAYS run it. Because
+    // those tests are specifically designed for regex-lite. So if they fail,
+    // then something needs attention.
+    if test.full_name().contains("regex-lite/") {
+        return Some(pattern);
+    }
+    // If the pattern has a \p in it, then we almost certainly don't support
+    // it. This probably skips more than we intend, but there are likely very
+    // few tests that contain a \p that isn't also a Unicode class.
+    if pattern.contains(r"\p") || pattern.contains(r"\P") {
+        return None;
+    }
+    // Similar deal for Perl classes, but we can abide them if the haystack
+    // is ASCII-only.
+    if !test.haystack().is_ascii() {
+        if pattern.contains(r"\d") || pattern.contains(r"\D") {
+            return None;
+        }
+        if pattern.contains(r"\s") || pattern.contains(r"\S") {
+            return None;
+        }
+        if pattern.contains(r"\w") || pattern.contains(r"\W") {
+            return None;
+        }
+    }
+    // And also same deal for word boundaries.
+    if !test.haystack().is_ascii() {
+        if pattern.contains(r"\b") || pattern.contains(r"\B") {
+            return None;
+        }
+    }
+    // We only test is_match, find_iter and captures_iter. All of those are
+    // leftmost searches.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Leftmost) {
+        return None;
+    }
+    // The top-level single-pattern regex API always uses leftmost-first.
+    if !matches!(test.match_kind(), regex_test::MatchKind::LeftmostFirst) {
+        return None;
+    }
+    // The top-level regex API always runs unanchored searches. ... But we can
+    // handle tests that are anchored but have only one match.
+    if test.anchored() && test.match_limit() != Some(1) {
+        return None;
+    }
+    // We don't support tests with explicit search bounds. We could probably
+    // support this by using the 'find_at' (and such) APIs.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return None;
+    }
+    // The Regex API specifically does not support disabling UTF-8 mode because
+    // it can only search &str which is always valid UTF-8.
+    if !test.utf8() {
+        return None;
+    }
+    // regex-lite doesn't support Unicode-aware case insensitive matching.
+    if test.case_insensitive()
+        && (!pattern.is_ascii() || !test.haystack().is_ascii())
+    {
+        return None;
+    }
+    Some(pattern)
+}
+
+/// Convert `Captures` into the test suite's capture values.
+fn testify_captures(caps: &regex_lite::Captures<'_>) -> regex_test::Captures {
+    let spans = caps.iter().map(|group| {
+        group.map(|m| regex_test::Span { start: m.start(), end: m.end() })
+    });
+    // This unwrap is OK because we assume our 'caps' represents a match, and
+    // a match always gives a non-zero number of groups with the first group
+    // being non-None.
+    regex_test::Captures::new(0, spans).unwrap()
+}
diff --git a/regex-syntax/Cargo.toml b/regex-syntax/Cargo.toml
index 2b12f497d9..4b49309e52 100644
--- a/regex-syntax/Cargo.toml
+++ b/regex-syntax/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
 name = "regex-syntax"
 version = "0.7.2"  #:version
-authors = ["The Rust Project Developers"]
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
 license = "MIT OR Apache-2.0"
-repository = "https://github.com/rust-lang/regex"
+repository = "https://github.com/rust-lang/regex/tree/master/regex-syntax"
 documentation = "https://docs.rs/regex-syntax"
-homepage = "https://github.com/rust-lang/regex"
 description = "A regular expression parser."
 workspace = ".."
 edition = "2021"
@@ -16,6 +15,7 @@ rust-version = "1.60.0"
 [features]
 default = ["std", "unicode"]
 std = []
+arbitrary = ["dep:arbitrary"]
 
 unicode = [
   "unicode-age",
@@ -34,6 +34,9 @@ unicode-perl = []
 unicode-script = []
 unicode-segment = []
 
+[dependencies]
+arbitrary = { version = "1.3.0", features = ["derive"], optional = true }
+
 [package.metadata.docs.rs]
 # We want to document all features.
 all-features = true
diff --git a/regex-syntax/LICENSE-APACHE b/regex-syntax/LICENSE-APACHE
deleted file mode 120000
index 965b606f33..0000000000
--- a/regex-syntax/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../LICENSE-APACHE
\ No newline at end of file
diff --git a/regex-syntax/LICENSE-APACHE b/regex-syntax/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/regex-syntax/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/regex-syntax/LICENSE-MIT b/regex-syntax/LICENSE-MIT
deleted file mode 120000
index 76219eb72e..0000000000
--- a/regex-syntax/LICENSE-MIT
+++ /dev/null
@@ -1 +0,0 @@
-../LICENSE-MIT
\ No newline at end of file
diff --git a/regex-syntax/LICENSE-MIT b/regex-syntax/LICENSE-MIT
new file mode 100644
index 0000000000..39d4bdb5ac
--- /dev/null
+++ b/regex-syntax/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/regex-syntax/README.md b/regex-syntax/README.md
index ff4fe094c3..529513b0c8 100644
--- a/regex-syntax/README.md
+++ b/regex-syntax/README.md
@@ -4,7 +4,6 @@ This crate provides a robust regular expression parser.
 
 [![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
 [![Crates.io](https://img.shields.io/crates/v/regex-syntax.svg)](https://crates.io/crates/regex-syntax)
-[![Rust](https://img.shields.io/badge/rust-1.28.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/regex)
 
 
 ### Documentation
diff --git a/regex-syntax/src/ast/mod.rs b/regex-syntax/src/ast/mod.rs
index a95b1c8737..9e4284fee8 100644
--- a/regex-syntax/src/ast/mod.rs
+++ b/regex-syntax/src/ast/mod.rs
@@ -20,6 +20,7 @@ mod visitor;
 /// valid Unicode property name. That particular error is reported when
 /// translating an AST to the high-level intermediate representation (`HIR`).
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Error {
     /// The kind of error.
     kind: ErrorKind,
@@ -70,6 +71,7 @@ impl Error {
 /// new variant is not considered a breaking change.
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ErrorKind {
     /// The capturing group limit was exceeded.
     ///
@@ -278,6 +280,7 @@ impl core::fmt::Display for ErrorKind {
 /// All span positions are absolute byte offsets that can be used on the
 /// original regular expression that was parsed.
 #[derive(Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Span {
     /// The start byte offset.
     pub start: Position,
@@ -308,6 +311,7 @@ impl PartialOrd for Span {
 /// A position encodes one half of a span, and include the byte offset, line
 /// number and column number.
 #[derive(Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Position {
     /// The absolute offset of this position, starting at `0` from the
     /// beginning of the regular expression pattern string.
@@ -396,6 +400,7 @@ impl Position {
 /// comment contains a span of precisely where it occurred in the original
 /// regular expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct WithComments {
     /// The actual ast.
     pub ast: Ast,
@@ -408,6 +413,7 @@ pub struct WithComments {
 /// A regular expression can only contain comments when the `x` flag is
 /// enabled.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Comment {
     /// The span of this comment, including the beginning `#` and ending `\n`.
     pub span: Span,
@@ -424,6 +430,7 @@ pub struct Comment {
 /// This type defines its own destructor that uses constant stack space and
 /// heap space proportional to the size of the `Ast`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum Ast {
     /// An empty regex that matches everything.
     Empty(Span),
@@ -508,6 +515,7 @@ impl core::fmt::Display for Ast {
 
 /// An alternation of regular expressions.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Alternation {
     /// The span of this alternation.
     pub span: Span,
@@ -532,6 +540,7 @@ impl Alternation {
 
 /// A concatenation of regular expressions.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Concat {
     /// The span of this concatenation.
     pub span: Span,
@@ -560,6 +569,7 @@ impl Concat {
 /// represented in their literal form, e.g., `a` or in their escaped form,
 /// e.g., `\x61`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Literal {
     /// The span of this literal.
     pub span: Span,
@@ -584,6 +594,7 @@ impl Literal {
 
 /// The kind of a single literal expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum LiteralKind {
     /// The literal is written verbatim, e.g., `a` or `☃`.
     Verbatim,
@@ -613,6 +624,7 @@ pub enum LiteralKind {
 /// A special literal is a special escape sequence recognized by the regex
 /// parser, e.g., `\f` or `\n`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum SpecialLiteralKind {
     /// Bell, spelled `\a` (`\x07`).
     Bell,
@@ -637,6 +649,7 @@ pub enum SpecialLiteralKind {
 /// differ when used without brackets in the number of hex digits that must
 /// follow.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum HexLiteralKind {
     /// A `\x` prefix. When used without brackets, this form is limited to
     /// two digits.
@@ -664,6 +677,7 @@ impl HexLiteralKind {
 
 /// A single character class expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum Class {
     /// A Unicode character class, e.g., `\pL` or `\p{Greek}`.
     Unicode(ClassUnicode),
@@ -688,6 +702,7 @@ impl Class {
 
 /// A Perl character class.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassPerl {
     /// The span of this class.
     pub span: Span,
@@ -700,6 +715,7 @@ pub struct ClassPerl {
 
 /// The available Perl character classes.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassPerlKind {
     /// Decimal numbers.
     Digit,
@@ -711,6 +727,7 @@ pub enum ClassPerlKind {
 
 /// An ASCII character class.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassAscii {
     /// The span of this class.
     pub span: Span,
@@ -723,6 +740,7 @@ pub struct ClassAscii {
 
 /// The available ASCII character classes.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassAsciiKind {
     /// `[0-9A-Za-z]`
     Alnum,
@@ -786,6 +804,7 @@ impl ClassAsciiKind {
 
 /// A Unicode character class.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassUnicode {
     /// The span of this class.
     pub span: Span,
@@ -838,8 +857,156 @@ pub enum ClassUnicodeKind {
     },
 }
 
+#[cfg(feature = "arbitrary")]
+impl arbitrary::Arbitrary<'_> for ClassUnicodeKind {
+    fn arbitrary(
+        u: &mut arbitrary::Unstructured,
+    ) -> arbitrary::Result<ClassUnicodeKind> {
+        #[cfg(any(
+            feature = "unicode-age",
+            feature = "unicode-bool",
+            feature = "unicode-gencat",
+            feature = "unicode-perl",
+            feature = "unicode-script",
+            feature = "unicode-segment",
+        ))]
+        {
+            use alloc::string::ToString;
+
+            use super::unicode_tables::{
+                property_names::PROPERTY_NAMES,
+                property_values::PROPERTY_VALUES,
+            };
+
+            match u.choose_index(3)? {
+                0 => {
+                    let all = PROPERTY_VALUES
+                        .iter()
+                        .flat_map(|e| e.1.iter())
+                        .filter(|(name, _)| name.len() == 1)
+                        .count();
+                    let idx = u.choose_index(all)?;
+                    let value = PROPERTY_VALUES
+                        .iter()
+                        .flat_map(|e| e.1.iter())
+                        .take(idx + 1)
+                        .last()
+                        .unwrap()
+                        .0
+                        .chars()
+                        .next()
+                        .unwrap();
+                    Ok(ClassUnicodeKind::OneLetter(value))
+                }
+                1 => {
+                    let all = PROPERTY_VALUES
+                        .iter()
+                        .map(|e| e.1.len())
+                        .sum::<usize>()
+                        + PROPERTY_NAMES.len();
+                    let idx = u.choose_index(all)?;
+                    let name = PROPERTY_VALUES
+                        .iter()
+                        .flat_map(|e| e.1.iter())
+                        .chain(PROPERTY_NAMES)
+                        .map(|(_, e)| e)
+                        .take(idx + 1)
+                        .last()
+                        .unwrap();
+                    Ok(ClassUnicodeKind::Named(name.to_string()))
+                }
+                2 => {
+                    let all = PROPERTY_VALUES
+                        .iter()
+                        .map(|e| e.1.len())
+                        .sum::<usize>();
+                    let idx = u.choose_index(all)?;
+                    let (prop, value) = PROPERTY_VALUES
+                        .iter()
+                        .flat_map(|e| {
+                            e.1.iter().map(|(_, value)| (e.0, value))
+                        })
+                        .take(idx + 1)
+                        .last()
+                        .unwrap();
+                    Ok(ClassUnicodeKind::NamedValue {
+                        op: u.arbitrary()?,
+                        name: prop.to_string(),
+                        value: value.to_string(),
+                    })
+                }
+                _ => unreachable!("index chosen is impossible"),
+            }
+        }
+        #[cfg(not(any(
+            feature = "unicode-age",
+            feature = "unicode-bool",
+            feature = "unicode-gencat",
+            feature = "unicode-perl",
+            feature = "unicode-script",
+            feature = "unicode-segment",
+        )))]
+        {
+            match u.choose_index(3)? {
+                0 => Ok(ClassUnicodeKind::OneLetter(u.arbitrary()?)),
+                1 => Ok(ClassUnicodeKind::Named(u.arbitrary()?)),
+                2 => Ok(ClassUnicodeKind::NamedValue {
+                    op: u.arbitrary()?,
+                    name: u.arbitrary()?,
+                    value: u.arbitrary()?,
+                }),
+                _ => unreachable!("index chosen is impossible"),
+            }
+        }
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        #[cfg(any(
+            feature = "unicode-age",
+            feature = "unicode-bool",
+            feature = "unicode-gencat",
+            feature = "unicode-perl",
+            feature = "unicode-script",
+            feature = "unicode-segment",
+        ))]
+        {
+            arbitrary::size_hint::and_all(&[
+                usize::size_hint(depth),
+                usize::size_hint(depth),
+                arbitrary::size_hint::or(
+                    (0, Some(0)),
+                    ClassUnicodeOpKind::size_hint(depth),
+                ),
+            ])
+        }
+        #[cfg(not(any(
+            feature = "unicode-age",
+            feature = "unicode-bool",
+            feature = "unicode-gencat",
+            feature = "unicode-perl",
+            feature = "unicode-script",
+            feature = "unicode-segment",
+        )))]
+        {
+            arbitrary::size_hint::and(
+                usize::size_hint(depth),
+                arbitrary::size_hint::or_all(&[
+                    char::size_hint(depth),
+                    String::size_hint(depth),
+                    arbitrary::size_hint::and_all(&[
+                        String::size_hint(depth),
+                        String::size_hint(depth),
+                        ClassUnicodeOpKind::size_hint(depth),
+                    ]),
+                ]),
+            )
+        }
+    }
+}
+
 /// The type of op used in a Unicode character class.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassUnicodeOpKind {
     /// A property set to a specific value, e.g., `\p{scx=Katakana}`.
     Equal,
@@ -862,6 +1029,7 @@ impl ClassUnicodeOpKind {
 
 /// A bracketed character class, e.g., `[a-z0-9]`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassBracketed {
     /// The span of this class.
     pub span: Span,
@@ -880,6 +1048,7 @@ pub struct ClassBracketed {
 /// items (literals, ranges, other bracketed classes) or a tree of binary set
 /// operations.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassSet {
     /// An item, which can be a single literal, range, nested character class
     /// or a union of items.
@@ -913,6 +1082,7 @@ impl ClassSet {
 
 /// A single component of a character class set.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassSetItem {
     /// An empty item.
     ///
@@ -956,6 +1126,7 @@ impl ClassSetItem {
 
 /// A single character class range in a set.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassSetRange {
     /// The span of this range.
     pub span: Span,
@@ -977,6 +1148,7 @@ impl ClassSetRange {
 
 /// A union of items inside a character class set.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassSetUnion {
     /// The span of the items in this operation. e.g., the `a-z0-9` in
     /// `[^a-z0-9]`
@@ -1021,6 +1193,7 @@ impl ClassSetUnion {
 
 /// A Unicode character class set operation.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct ClassSetBinaryOp {
     /// The span of this operation. e.g., the `a-z--[h-p]` in `[a-z--h-p]`.
     pub span: Span,
@@ -1038,6 +1211,7 @@ pub struct ClassSetBinaryOp {
 /// explicit union operator. Concatenation inside a character class corresponds
 /// to the union operation.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ClassSetBinaryOpKind {
     /// The intersection of two sets, e.g., `\pN&&[a-z]`.
     Intersection,
@@ -1051,6 +1225,7 @@ pub enum ClassSetBinaryOpKind {
 
 /// A single zero-width assertion.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Assertion {
     /// The span of this assertion.
     pub span: Span,
@@ -1060,6 +1235,7 @@ pub struct Assertion {
 
 /// An assertion kind.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum AssertionKind {
     /// `^`
     StartLine,
@@ -1077,6 +1253,7 @@ pub enum AssertionKind {
 
 /// A repetition operation applied to a regular expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Repetition {
     /// The span of this operation.
     pub span: Span,
@@ -1090,6 +1267,7 @@ pub struct Repetition {
 
 /// The repetition operator itself.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct RepetitionOp {
     /// The span of this operator. This includes things like `+`, `*?` and
     /// `{m,n}`.
@@ -1100,6 +1278,7 @@ pub struct RepetitionOp {
 
 /// The kind of a repetition operator.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum RepetitionKind {
     /// `?`
     ZeroOrOne,
@@ -1113,6 +1292,7 @@ pub enum RepetitionKind {
 
 /// A range repetition operator.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum RepetitionRange {
     /// `{m}`
     Exactly(u32),
@@ -1142,6 +1322,7 @@ impl RepetitionRange {
 /// contains a sub-expression, e.g., `(a)`, `(?P<name>a)`, `(?:a)` and
 /// `(?is:a)`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Group {
     /// The span of this group.
     pub span: Span,
@@ -1183,6 +1364,7 @@ impl Group {
 
 /// The kind of a group.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum GroupKind {
     /// `(a)`
     CaptureIndex(u32),
@@ -1211,8 +1393,38 @@ pub struct CaptureName {
     pub index: u32,
 }
 
+#[cfg(feature = "arbitrary")]
+impl arbitrary::Arbitrary<'_> for CaptureName {
+    fn arbitrary(
+        u: &mut arbitrary::Unstructured,
+    ) -> arbitrary::Result<CaptureName> {
+        let len = u.arbitrary_len::<char>()?;
+        if len == 0 {
+            return Err(arbitrary::Error::NotEnoughData);
+        }
+        let mut name: String = String::new();
+        for _ in 0..len {
+            let ch: char = u.arbitrary()?;
+            let cp = u32::from(ch);
+            let ascii_letter_offset = u8::try_from(cp % 26).unwrap();
+            let ascii_letter = b'a' + ascii_letter_offset;
+            name.push(char::from(ascii_letter));
+        }
+        Ok(CaptureName { span: u.arbitrary()?, name, index: u.arbitrary()? })
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        arbitrary::size_hint::and_all(&[
+            Span::size_hint(depth),
+            usize::size_hint(depth),
+            u32::size_hint(depth),
+        ])
+    }
+}
+
 /// A group of flags that is not applied to a particular regular expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct SetFlags {
     /// The span of these flags, including the grouping parentheses.
     pub span: Span,
@@ -1224,6 +1436,7 @@ pub struct SetFlags {
 ///
 /// This corresponds only to the sequence of flags themselves, e.g., `is-u`.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Flags {
     /// The span of this group of flags.
     pub span: Span,
@@ -1276,6 +1489,7 @@ impl Flags {
 
 /// A single item in a group of flags.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct FlagsItem {
     /// The span of this item.
     pub span: Span,
@@ -1285,6 +1499,7 @@ pub struct FlagsItem {
 
 /// The kind of an item in a group of flags.
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum FlagsItemKind {
     /// A negation operator applied to all subsequent flags in the enclosing
     /// group.
@@ -1305,6 +1520,7 @@ impl FlagsItemKind {
 
 /// A single flag.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum Flag {
     /// `i`
     CaseInsensitive,
diff --git a/regex-syntax/src/hir/literal.rs b/regex-syntax/src/hir/literal.rs
index bd3a2d143b..bcab2fb752 100644
--- a/regex-syntax/src/hir/literal.rs
+++ b/regex-syntax/src/hir/literal.rs
@@ -51,7 +51,7 @@ the "trickier" parts are how to combine literal sequences, and that is all
 implemented on [`Seq`].
 */
 
-use core::{cmp, mem};
+use core::{cmp, mem, num::NonZeroUsize};
 
 use alloc::{vec, vec::Vec};
 
@@ -1571,7 +1571,7 @@ impl Seq {
     /// unioning `self` with `other`. If either set is infinite, then this
     /// returns `None`.
     #[inline]
-    fn max_union_len(&self, other: &Seq) -> Option<usize> {
+    pub fn max_union_len(&self, other: &Seq) -> Option<usize> {
         let len1 = self.len()?;
         let len2 = other.len()?;
         Some(len1.saturating_add(len2))
@@ -1581,7 +1581,7 @@ impl Seq {
     /// cross product of `self` with `other`. If either set is infinite, then
     /// this returns `None`.
     #[inline]
-    fn max_cross_len(&self, other: &Seq) -> Option<usize> {
+    pub fn max_cross_len(&self, other: &Seq) -> Option<usize> {
         let len1 = self.len()?;
         let len2 = other.len()?;
         Some(len1.saturating_mul(len2))
@@ -1841,6 +1841,14 @@ impl Seq {
             None => return,
             Some(len) => len,
         };
+        // Just give up now if our sequence contains an empty string.
+        if self.min_literal_len().map_or(false, |len| len == 0) {
+            // We squash the sequence so that nobody else gets any bright
+            // ideas to try and use it. An empty string implies a match at
+            // every position. A prefilter cannot help you here.
+            self.make_infinite();
+            return;
+        }
         // Make sure we start with the smallest sequence possible. We use a
         // special version of preference minimization that retains exactness.
         // This is legal because optimization is only expected to occur once
@@ -1910,34 +1918,41 @@ impl Seq {
                 // longest common prefix to be subject to the poison check.
             }
         }
-        // Everything below this check is more-or-less about trying to
-        // heuristically reduce the false positive rate of a prefilter. But
-        // if our sequence is completely exact, then it's possible the regex
-        // engine can be skipped entirely. In this case, the false positive
-        // rate is zero because every literal match corresponds to a regex
-        // match.
+        // If we have an exact sequence, we *probably* just want to keep it
+        // as-is. But there are some cases where we don't. So we save a copy of
+        // the exact sequence now, and then try to do some more optimizations
+        // below. If those don't work out, we go back to this exact sequence.
         //
-        // This is OK even if the sequence contains a poison literal. Remember,
-        // a literal is only poisononous because of what we assume about its
-        // impact on the false positive rate. However, we do still check for
-        // an empty string. Empty strings are weird and it's best to let the
-        // regex engine handle those.
+        // The specific motivation for this is that we sometimes wind up with
+        // an exact sequence with a hefty number of literals. Say, 100. If we
+        // stuck with that, it would be too big for Teddy and would result in
+        // using Aho-Corasick. Which is fine... but the lazy DFA is plenty
+        // suitable in such cases. The real issue is that we will wind up not
+        // using a fast prefilter at all. So in cases like this, even though
+        // we have an exact sequence, it would be better to try and shrink the
+        // sequence (which we do below) and use it as a prefilter that can
+        // produce false positive matches.
         //
-        // We do currently do this check after the longest common prefix (or
-        // suffix) check, under the theory that single-substring search is so
-        // fast that we want that even if we'd end up turning an exact sequence
-        // into an inexact one. But this might be wrong...
-        if self.is_exact()
-            && self.min_literal_len().map_or(false, |len| len > 0)
-        {
-            return;
-        }
+        // But if the shrinking below results in a sequence that "sucks," then
+        // we don't want to use that because we already have an exact sequence
+        // in hand.
+        let exact: Option<Seq> =
+            if self.is_exact() { Some(self.clone()) } else { None };
         // Now we attempt to shorten the sequence. The idea here is that we
         // don't want to look for too many literals, but we want to shorten
         // our sequence enough to improve our odds of using better algorithms
         // downstream (such as Teddy).
+        //
+        // The pair of numbers in this list corresponds to the maximal prefix
+        // (in bytes) to keep for all literals and the length of the sequence
+        // at which to do it.
+        //
+        // So for example, the pair (3, 500) would mean, "if we have more than
+        // 500 literals in our sequence, then truncate all of our literals
+        // such that they are at most 3 bytes in length and the minimize the
+        // sequence."
         const ATTEMPTS: [(usize, usize); 5] =
-            [(5, 64), (4, 64), (3, 64), (2, 64), (1, 10)];
+            [(5, 10), (4, 10), (3, 64), (2, 64), (1, 10)];
         for (keep, limit) in ATTEMPTS {
             let len = match self.len() {
                 None => break,
@@ -1951,7 +1966,11 @@ impl Seq {
             } else {
                 self.keep_last_bytes(keep);
             }
-            self.minimize_by_preference();
+            if prefix {
+                if let Some(ref mut lits) = self.literals {
+                    PreferenceTrie::minimize(lits, true);
+                }
+            }
         }
         // Check for a poison literal. A poison literal is one that is short
         // and is believed to have a very high match count. These poisons
@@ -1968,6 +1987,30 @@ impl Seq {
                 self.make_infinite();
             }
         }
+        // OK, if we had an exact sequence before attempting more optimizations
+        // above and our post-optimized sequence sucks for some reason or
+        // another, then we go back to the exact sequence.
+        if let Some(exact) = exact {
+            // If optimizing resulted in dropping our literals, then certainly
+            // backup and use the exact sequence that we had.
+            if !self.is_finite() {
+                *self = exact;
+                return;
+            }
+            // If our optimized sequence contains a short literal, then it's
+            // *probably* not so great. So throw it away and revert to the
+            // exact sequence.
+            if self.min_literal_len().map_or(true, |len| len <= 2) {
+                *self = exact;
+                return;
+            }
+            // Finally, if our optimized sequence is "big" (i.e., can't use
+            // Teddy), then also don't use it and rely on the exact sequence.
+            if self.len().map_or(true, |len| len > 64) {
+                *self = exact;
+                return;
+            }
+        }
     }
 }
 
@@ -1977,7 +2020,7 @@ impl core::fmt::Debug for Seq {
         if let Some(lits) = self.literals() {
             f.debug_list().entries(lits.iter()).finish()
         } else {
-            write!(f, "[∅]")
+            write!(f, "[∞]")
         }
     }
 }
@@ -2160,12 +2203,19 @@ impl core::fmt::Debug for Literal {
 /// never seen this show up on a profile. Because of the heuristic limits
 /// imposed on literal extractions, the size of the inputs here is usually
 /// very small.)
-#[derive(Debug, Default)]
+#[derive(Debug)]
 struct PreferenceTrie {
     /// The states in this trie. The index of a state in this vector is its ID.
     states: Vec<State>,
+    /// This vec indicates which states are match states. It always has
+    /// the same length as `states` and is indexed by the same state ID.
+    /// A state with identifier `sid` is a match state if and only if
+    /// `matches[sid].is_some()`. The option contains the index of the literal
+    /// corresponding to the match. The index is offset by 1 so that it fits in
+    /// a NonZeroUsize.
+    matches: Vec<Option<NonZeroUsize>>,
     /// The index to allocate to the next literal added to this trie. Starts at
-    /// 0 and increments by 1 for every literal successfully added to the trie.
+    /// 1 and increments by 1 for every literal successfully added to the trie.
     next_literal_index: usize,
 }
 
@@ -2176,9 +2226,6 @@ struct State {
     /// are sorted by byte. There is at most one such transition for any
     /// particular byte.
     trans: Vec<(u8, usize)>,
-    /// Whether this is a matching state or not. If it is, then it contains the
-    /// index to the matching literal.
-    literal_index: Option<usize>,
 }
 
 impl PreferenceTrie {
@@ -2195,14 +2242,18 @@ impl PreferenceTrie {
         use core::cell::RefCell;
 
         // MSRV(1.61): Use retain_mut here to avoid interior mutability.
-        let trie = RefCell::new(PreferenceTrie::default());
+        let trie = RefCell::new(PreferenceTrie {
+            states: vec![],
+            matches: vec![],
+            next_literal_index: 1,
+        });
         let mut make_inexact = vec![];
         literals.retain(|lit| {
             match trie.borrow_mut().insert(lit.as_bytes()) {
                 Ok(_) => true,
                 Err(i) => {
                     if !keep_exact {
-                        make_inexact.push(i);
+                        make_inexact.push(i.checked_sub(1).unwrap());
                     }
                     false
                 }
@@ -2225,15 +2276,15 @@ impl PreferenceTrie {
     /// search.
     fn insert(&mut self, bytes: &[u8]) -> Result<usize, usize> {
         let mut prev = self.root();
-        if let Some(idx) = self.states[prev].literal_index {
-            return Err(idx);
+        if let Some(idx) = self.matches[prev] {
+            return Err(idx.get());
         }
         for &b in bytes.iter() {
             match self.states[prev].trans.binary_search_by_key(&b, |t| t.0) {
                 Ok(i) => {
                     prev = self.states[prev].trans[i].1;
-                    if let Some(idx) = self.states[prev].literal_index {
-                        return Err(idx);
+                    if let Some(idx) = self.matches[prev] {
+                        return Err(idx.get());
                     }
                 }
                 Err(i) => {
@@ -2245,7 +2296,7 @@ impl PreferenceTrie {
         }
         let idx = self.next_literal_index;
         self.next_literal_index += 1;
-        self.states[prev].literal_index = Some(idx);
+        self.matches[prev] = NonZeroUsize::new(idx);
         Ok(idx)
     }
 
@@ -2262,6 +2313,7 @@ impl PreferenceTrie {
     fn create_state(&mut self) -> usize {
         let id = self.states.len();
         self.states.push(State::default());
+        self.matches.push(None);
         id
     }
 }
@@ -2815,13 +2867,13 @@ mod tests {
     // repeats.
     #[test]
     fn crazy_repeats() {
-        assert_eq!(inexact([I("")], [I("")]), e(r"(?:){4294967295}"));
+        assert_eq!(inexact([E("")], [E("")]), e(r"(?:){4294967295}"));
         assert_eq!(
-            inexact([I("")], [I("")]),
+            inexact([E("")], [E("")]),
             e(r"(?:){64}{64}{64}{64}{64}{64}")
         );
-        assert_eq!(inexact([I("")], [I("")]), e(r"x{0}{4294967295}"));
-        assert_eq!(inexact([I("")], [I("")]), e(r"(?:|){4294967295}"));
+        assert_eq!(inexact([E("")], [E("")]), e(r"x{0}{4294967295}"));
+        assert_eq!(inexact([E("")], [E("")]), e(r"(?:|){4294967295}"));
 
         assert_eq!(
             inexact([E("")], [E("")]),
diff --git a/regex-syntax/src/hir/mod.rs b/regex-syntax/src/hir/mod.rs
index 062d4dcab5..c6272cd4c8 100644
--- a/regex-syntax/src/hir/mod.rs
+++ b/regex-syntax/src/hir/mod.rs
@@ -88,6 +88,9 @@ pub enum ErrorKind {
     /// This error occurs when translating a pattern that could match a byte
     /// sequence that isn't UTF-8 and `utf8` was enabled.
     InvalidUtf8,
+    /// This error occurs when one uses a non-ASCII byte for a line terminator,
+    /// but where Unicode mode is enabled and UTF-8 mode is disabled.
+    InvalidLineTerminator,
     /// This occurs when an unrecognized Unicode property name could not
     /// be found.
     UnicodePropertyNotFound,
@@ -120,6 +123,7 @@ impl core::fmt::Display for ErrorKind {
         let msg = match *self {
             UnicodeNotAllowed => "Unicode not allowed here",
             InvalidUtf8 => "pattern can match invalid UTF-8",
+            InvalidLineTerminator => "invalid line terminator, must be ASCII",
             UnicodePropertyNotFound => "Unicode property not found",
             UnicodePropertyValueNotFound => "Unicode property value not found",
             UnicodePerlClassNotFound => {
@@ -355,7 +359,13 @@ impl Hir {
 
     /// Creates a repetition HIR expression.
     #[inline]
-    pub fn repetition(rep: Repetition) -> Hir {
+    pub fn repetition(mut rep: Repetition) -> Hir {
+        // If the sub-expression of a repetition can only match the empty
+        // string, then we force its maximum to be at most 1.
+        if rep.sub.properties().maximum_len() == Some(0) {
+            rep.min = cmp::min(rep.min, 1);
+            rep.max = rep.max.map(|n| cmp::min(n, 1)).or(Some(1));
+        }
         // The regex 'a{0}' is always equivalent to the empty regex. This is
         // true even when 'a' is an expression that never matches anything
         // (like '\P{any}').
@@ -547,7 +557,7 @@ impl Hir {
         // We rebuild the alternation by simplifying it. We proceed similarly
         // as the concatenation case. But in this case, there's no literal
         // simplification happening. We're just flattening alternations.
-        let mut new = vec![];
+        let mut new = Vec::with_capacity(subs.len());
         for sub in subs {
             let (kind, props) = sub.into_parts();
             match kind {
@@ -642,6 +652,12 @@ impl Hir {
                 cls.push(ClassBytesRange::new(b'\0', b'\xFF'));
                 Hir::class(Class::Bytes(cls))
             }
+            Dot::AnyCharExcept(ch) => {
+                let mut cls =
+                    ClassUnicode::new([ClassUnicodeRange::new(ch, ch)]);
+                cls.negate();
+                Hir::class(Class::Unicode(cls))
+            }
             Dot::AnyCharExceptLF => {
                 let mut cls = ClassUnicode::empty();
                 cls.push(ClassUnicodeRange::new('\0', '\x09'));
@@ -655,6 +671,12 @@ impl Hir {
                 cls.push(ClassUnicodeRange::new('\x0E', '\u{10FFFF}'));
                 Hir::class(Class::Unicode(cls))
             }
+            Dot::AnyByteExcept(byte) => {
+                let mut cls =
+                    ClassBytes::new([ClassBytesRange::new(byte, byte)]);
+                cls.negate();
+                Hir::class(Class::Bytes(cls))
+            }
             Dot::AnyByteExceptLF => {
                 let mut cls = ClassBytes::empty();
                 cls.push(ClassBytesRange::new(b'\0', b'\x09'));
@@ -1766,6 +1788,18 @@ pub enum Dot {
     ///
     /// This is equivalent to `(?s-u:.)` and also `(?-u:[\x00-\xFF])`.
     AnyByte,
+    /// Matches the UTF-8 encoding of any Unicode scalar value except for the
+    /// `char` given.
+    ///
+    /// This is equivalent to using `(?u-s:.)` with the line terminator set
+    /// to a particular ASCII byte. (Because of peculiarities in the regex
+    /// engines, a line terminator must be a single byte. It follows that when
+    /// UTF-8 mode is enabled, this single byte must also be a Unicode scalar
+    /// value. That is, ti must be ASCII.)
+    ///
+    /// (This and `AnyCharExceptLF` both exist because of legacy reasons.
+    /// `AnyCharExceptLF` will be dropped in the next breaking change release.)
+    AnyCharExcept(char),
     /// Matches the UTF-8 encoding of any Unicode scalar value except for `\n`.
     ///
     /// This is equivalent to `(?u-s:.)` and also `[\p{any}--\n]`.
@@ -1775,6 +1809,17 @@ pub enum Dot {
     ///
     /// This is equivalent to `(?uR-s:.)` and also `[\p{any}--\r\n]`.
     AnyCharExceptCRLF,
+    /// Matches any byte value except for the `u8` given.
+    ///
+    /// This is equivalent to using `(?-us:.)` with the line terminator set
+    /// to a particular ASCII byte. (Because of peculiarities in the regex
+    /// engines, a line terminator must be a single byte. It follows that when
+    /// UTF-8 mode is enabled, this single byte must also be a Unicode scalar
+    /// value. That is, ti must be ASCII.)
+    ///
+    /// (This and `AnyByteExceptLF` both exist because of legacy reasons.
+    /// `AnyByteExceptLF` will be dropped in the next breaking change release.)
+    AnyByteExcept(u8),
     /// Matches any byte value except for `\n`.
     ///
     /// This is equivalent to `(?-su:.)` and also `(?-u:[[\x00-\xFF]--\n])`.
@@ -2410,10 +2455,10 @@ impl Properties {
             inner.look_set_prefix = p.look_set_prefix();
             inner.look_set_suffix = p.look_set_suffix();
         }
-        // If the static captures len of the sub-expression is not known or is
-        // zero, then it automatically propagates to the repetition, regardless
-        // of the repetition. Otherwise, it might change, but only when the
-        // repetition can match 0 times.
+        // If the static captures len of the sub-expression is not known or
+        // is greater than zero, then it automatically propagates to the
+        // repetition, regardless of the repetition. Otherwise, it might
+        // change, but only when the repetition can match 0 times.
         if rep.min == 0
             && inner.static_explicit_captures_len.map_or(false, |len| len > 0)
         {
diff --git a/regex-syntax/src/hir/print.rs b/regex-syntax/src/hir/print.rs
index fcb7cd252b..aa737a092d 100644
--- a/regex-syntax/src/hir/print.rs
+++ b/regex-syntax/src/hir/print.rs
@@ -89,9 +89,16 @@ impl<W: fmt::Write> Visitor for Writer<W> {
 
     fn visit_pre(&mut self, hir: &Hir) -> fmt::Result {
         match *hir.kind() {
-            // Empty is represented by nothing in the concrete syntax, and
-            // repetition operators are strictly suffix oriented.
-            HirKind::Empty | HirKind::Repetition(_) => {}
+            HirKind::Empty => {
+                // Technically an empty sub-expression could be "printed" by
+                // just ignoring it, but in practice, you could have a
+                // repetition operator attached to an empty expression, and you
+                // really need something in the concrete syntax to make that
+                // work as you'd expect.
+                self.wtr.write_str(r"(?:)")?;
+            }
+            // Repetition operators are strictly suffix oriented.
+            HirKind::Repetition(_) => {}
             HirKind::Literal(hir::Literal(ref bytes)) => {
                 // See the comment on the 'Concat' and 'Alternation' case below
                 // for why we put parens here. Literals are, conceptually,
@@ -424,20 +431,20 @@ mod tests {
         // Test that various zero-length repetitions always translate to an
         // empty regex. This is more a property of HIR's smart constructors
         // than the printer though.
-        roundtrip("a{0}", "");
-        roundtrip("(?:ab){0}", "");
+        roundtrip("a{0}", "(?:)");
+        roundtrip("(?:ab){0}", "(?:)");
         #[cfg(feature = "unicode-gencat")]
         {
-            roundtrip(r"\p{any}{0}", "");
-            roundtrip(r"\P{any}{0}", "");
+            roundtrip(r"\p{any}{0}", "(?:)");
+            roundtrip(r"\P{any}{0}", "(?:)");
         }
     }
 
     #[test]
     fn print_group() {
-        roundtrip("()", "()");
-        roundtrip("(?P<foo>)", "(?P<foo>)");
-        roundtrip("(?:)", "");
+        roundtrip("()", "((?:))");
+        roundtrip("(?P<foo>)", "(?P<foo>(?:))");
+        roundtrip("(?:)", "(?:)");
 
         roundtrip("(a)", "(a)");
         roundtrip("(?P<foo>a)", "(?P<foo>a)");
@@ -448,8 +455,8 @@ mod tests {
 
     #[test]
     fn print_alternation() {
-        roundtrip("|", "(?:|)");
-        roundtrip("||", "(?:||)");
+        roundtrip("|", "(?:(?:)|(?:))");
+        roundtrip("||", "(?:(?:)|(?:)|(?:))");
 
         roundtrip("a|b", "[ab]");
         roundtrip("ab|cd", "(?:(?:ab)|(?:cd))");
@@ -503,7 +510,7 @@ mod tests {
             }),
             Hir::look(hir::Look::End),
         ]);
-        assert_eq!(r"(?:\A(?:\A\z)+\z)", expr.to_string());
+        assert_eq!(r"(?:\A\A\z\z)", expr.to_string());
     }
 
     // Just like regression_repetition_concat, but with the repetition using
@@ -540,7 +547,7 @@ mod tests {
             }),
             Hir::look(hir::Look::End),
         ]);
-        assert_eq!(r"(?:\A(?:\A|\z)+\z)", expr.to_string());
+        assert_eq!(r"(?:\A(?:\A|\z)\z)", expr.to_string());
     }
 
     // This regression test is very similar in flavor to
diff --git a/regex-syntax/src/hir/translate.rs b/regex-syntax/src/hir/translate.rs
index ff9c5ee91e..5430b51b27 100644
--- a/regex-syntax/src/hir/translate.rs
+++ b/regex-syntax/src/hir/translate.rs
@@ -19,6 +19,7 @@ type Result<T> = core::result::Result<T, Error>;
 #[derive(Clone, Debug)]
 pub struct TranslatorBuilder {
     utf8: bool,
+    line_terminator: u8,
     flags: Flags,
 }
 
@@ -31,7 +32,11 @@ impl Default for TranslatorBuilder {
 impl TranslatorBuilder {
     /// Create a new translator builder with a default c onfiguration.
     pub fn new() -> TranslatorBuilder {
-        TranslatorBuilder { utf8: true, flags: Flags::default() }
+        TranslatorBuilder {
+            utf8: true,
+            line_terminator: b'\n',
+            flags: Flags::default(),
+        }
     }
 
     /// Build a translator using the current configuration.
@@ -40,6 +45,7 @@ impl TranslatorBuilder {
             stack: RefCell::new(vec![]),
             flags: Cell::new(self.flags),
             utf8: self.utf8,
+            line_terminator: self.line_terminator,
         }
     }
 
@@ -63,6 +69,31 @@ impl TranslatorBuilder {
         self
     }
 
+    /// Sets the line terminator for use with `(?u-s:.)` and `(?-us:.)`.
+    ///
+    /// Namely, instead of `.` (by default) matching everything except for `\n`,
+    /// this will cause `.` to match everything except for the byte given.
+    ///
+    /// If `.` is used in a context where Unicode mode is enabled and this byte
+    /// isn't ASCII, then an error will be returned. When Unicode mode is
+    /// disabled, then any byte is permitted, but will return an error if UTF-8
+    /// mode is enabled and it is a non-ASCII byte.
+    ///
+    /// In short, any ASCII value for a line terminator is always okay. But a
+    /// non-ASCII byte might result in an error depending on whether Unicode
+    /// mode or UTF-8 mode are enabled.
+    ///
+    /// Note that if `R` mode is enabled then it always takes precedence and
+    /// the line terminator will be treated as `\r` and `\n` simultaneously.
+    ///
+    /// Note also that this *doesn't* impact the look-around assertions
+    /// `(?m:^)` and `(?m:$)`. That's usually controlled by additional
+    /// configuration in the regex engine itself.
+    pub fn line_terminator(&mut self, byte: u8) -> &mut TranslatorBuilder {
+        self.line_terminator = byte;
+        self
+    }
+
     /// Enable or disable the case insensitive flag (`i`) by default.
     pub fn case_insensitive(&mut self, yes: bool) -> &mut TranslatorBuilder {
         self.flags.case_insensitive = if yes { Some(true) } else { None };
@@ -120,6 +151,8 @@ pub struct Translator {
     flags: Cell<Flags>,
     /// Whether we're allowed to produce HIR that can match arbitrary bytes.
     utf8: bool,
+    /// The line terminator to use for `.`.
+    line_terminator: u8,
 }
 
 impl Translator {
@@ -862,10 +895,38 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
     }
 
     fn hir_dot(&self, span: Span) -> Result<Hir> {
-        if !self.flags().unicode() && self.trans().utf8 {
+        let (utf8, lineterm, flags) =
+            (self.trans().utf8, self.trans().line_terminator, self.flags());
+        if utf8 && (!flags.unicode() || !lineterm.is_ascii()) {
             return Err(self.error(span, ErrorKind::InvalidUtf8));
         }
-        Ok(Hir::dot(self.flags().dot()))
+        let dot = if flags.dot_matches_new_line() {
+            if flags.unicode() {
+                hir::Dot::AnyChar
+            } else {
+                hir::Dot::AnyByte
+            }
+        } else {
+            if flags.unicode() {
+                if flags.crlf() {
+                    hir::Dot::AnyCharExceptCRLF
+                } else {
+                    if !lineterm.is_ascii() {
+                        return Err(
+                            self.error(span, ErrorKind::InvalidLineTerminator)
+                        );
+                    }
+                    hir::Dot::AnyCharExcept(char::from(lineterm))
+                }
+            } else {
+                if flags.crlf() {
+                    hir::Dot::AnyByteExceptCRLF
+                } else {
+                    hir::Dot::AnyByteExcept(lineterm)
+                }
+            }
+        };
+        Ok(Hir::dot(dot))
     }
 
     fn hir_assertion(&self, asst: &ast::Assertion) -> Result<Hir> {
@@ -1209,30 +1270,6 @@ impl Flags {
         }
     }
 
-    fn dot(&self) -> hir::Dot {
-        if self.dot_matches_new_line() {
-            if self.unicode() {
-                hir::Dot::AnyChar
-            } else {
-                hir::Dot::AnyByte
-            }
-        } else {
-            if self.unicode() {
-                if self.crlf() {
-                    hir::Dot::AnyCharExceptCRLF
-                } else {
-                    hir::Dot::AnyCharExceptLF
-                }
-            } else {
-                if self.crlf() {
-                    hir::Dot::AnyByteExceptCRLF
-                } else {
-                    hir::Dot::AnyByteExceptLF
-                }
-            }
-        }
-    }
-
     fn case_insensitive(&self) -> bool {
         self.case_insensitive.unwrap_or(false)
     }
@@ -3489,6 +3526,15 @@ mod tests {
         assert!(!props(r"(?:z|xx)@|xx").is_alternation_literal());
     }
 
+    // This tests that the smart Hir::repetition constructors does some basic
+    // simplifications.
+    #[test]
+    fn smart_repetition() {
+        assert_eq!(t(r"a{0}"), Hir::empty());
+        assert_eq!(t(r"a{1}"), hir_lit("a"));
+        assert_eq!(t(r"\B{32111}"), hir_look(hir::Look::WordUnicodeNegate));
+    }
+
     // This tests that the smart Hir::concat constructor simplifies the given
     // exprs in a way we expect.
     #[test]
diff --git a/regex-syntax/src/lib.rs b/regex-syntax/src/lib.rs
index 7548589006..47d818a17f 100644
--- a/regex-syntax/src/lib.rs
+++ b/regex-syntax/src/lib.rs
@@ -157,12 +157,29 @@ The following features are available:
   [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
   This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
   `\p{sb=ATerm}`.
+* **arbitrary** -
+  Enabling this feature introduces a public dependency on the
+  [`arbitrary`](https://crates.io/crates/arbitrary)
+  crate. Namely, it implements the `Arbitrary` trait from that crate for the
+  [`Ast`](crate::ast::Ast) type. This feature is disabled by default.
 */
 
 #![no_std]
 #![forbid(unsafe_code)]
 #![deny(missing_docs, rustdoc::broken_intra_doc_links)]
 #![warn(missing_debug_implementations)]
+// MSRV(1.62): Allow unused warnings. Needed for the 'allow' below,
+// since the warning is no longer triggered in newer Rust releases.
+// Once the 'allow(mutable_borrow_reservation_conflict)' can be
+// removed, we can remove the 'allow(renamed_and_removed_lints)' too.
+#![allow(renamed_and_removed_lints)]
+// MSRV(1.62): This gets triggered on Rust <1.62, and since our MSRV
+// is Rust 1.60 at the time of writing, a warning is displayed. But
+// the lang team decided the code pattern flagged by this warning is
+// OK, so the warning is innocuous. We can remove this explicit allow
+// once we get to a Rust release where the warning is no longer
+// triggered. I believe that's Rust 1.62.
+#![allow(mutable_borrow_reservation_conflict)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
 #[cfg(any(test, feature = "std"))]
diff --git a/regex-syntax/src/parser.rs b/regex-syntax/src/parser.rs
index 2e7a2bb80c..f482b84667 100644
--- a/regex-syntax/src/parser.rs
+++ b/regex-syntax/src/parser.rs
@@ -165,6 +165,31 @@ impl ParserBuilder {
         self
     }
 
+    /// Sets the line terminator for use with `(?u-s:.)` and `(?-us:.)`.
+    ///
+    /// Namely, instead of `.` (by default) matching everything except for `\n`,
+    /// this will cause `.` to match everything except for the byte given.
+    ///
+    /// If `.` is used in a context where Unicode mode is enabled and this byte
+    /// isn't ASCII, then an error will be returned. When Unicode mode is
+    /// disabled, then any byte is permitted, but will return an error if UTF-8
+    /// mode is enabled and it is a non-ASCII byte.
+    ///
+    /// In short, any ASCII value for a line terminator is always okay. But a
+    /// non-ASCII byte might result in an error depending on whether Unicode
+    /// mode or UTF-8 mode are enabled.
+    ///
+    /// Note that if `R` mode is enabled then it always takes precedence and
+    /// the line terminator will be treated as `\r` and `\n` simultaneously.
+    ///
+    /// Note also that this *doesn't* impact the look-around assertions
+    /// `(?m:^)` and `(?m:$)`. That's usually controlled by additional
+    /// configuration in the regex engine itself.
+    pub fn line_terminator(&mut self, byte: u8) -> &mut ParserBuilder {
+        self.hir.line_terminator(byte);
+        self
+    }
+
     /// Enable or disable the "swap greed" flag by default.
     ///
     /// By default this is disabled. It may alternatively be selectively
diff --git a/regex-syntax/test b/regex-syntax/test
index a4d6cfaba5..8626c3bfcc 100755
--- a/regex-syntax/test
+++ b/regex-syntax/test
@@ -2,6 +2,10 @@
 
 set -e
 
+# cd to the directory containing this crate's Cargo.toml so that we don't need
+# to pass --manifest-path to every `cargo` command.
+cd "$(dirname "$0")"
+
 # This is a convenience script for running a broad swath of the syntax tests.
 echo "===== DEFAULT FEATURES ==="
 cargo test
diff --git a/regex-test/Cargo.toml b/regex-test/Cargo.toml
new file mode 100644
index 0000000000..8adeb58881
--- /dev/null
+++ b/regex-test/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "regex-test"
+version = "0.1.0"  #:version
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
+description = """
+Infrastructure for testing regexes.
+
+You probably don't want to use this crate unless you're working on a regex
+implementation.
+"""
+documentation = "https://docs.rs/regex-test"
+repository = "https://github.com/rust-lang/regex/tree/master/regex-test"
+readme = "README.md"
+keywords = ["regex", "regexp", "dfa", "automata", "test"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+
+[lib]
+name = "regex_test"
+bench = false
+path = "lib.rs"
+
+[dependencies]
+anyhow = "1.0.27"
+bstr = { version = "1.3.0", default-features = false, features = ["std", "serde"] }
+serde = { version = "1.0.105", features = ["derive"] }
+toml = { version = "0.7.3", default-features = false, features = ["parse"] }
diff --git a/regex-test/lib.rs b/regex-test/lib.rs
new file mode 100644
index 0000000000..3287473e05
--- /dev/null
+++ b/regex-test/lib.rs
@@ -0,0 +1,1795 @@
+/*!
+A crate for defining tests in a TOML format and applying them to regex engine
+implementations.
+
+Generally speaking, if you aren't writing your own regex engine and looking to
+test it, then this crate is probably not for you. Moreover, this crate does not
+come with any actual tests. It merely defines the test format and provides some
+convenient routines for executing tests within the context of Rust unit tests.
+
+# Format
+
+The entire test corpus is derived from zero or more TOML files. Each TOML
+file contains zero or more tests, where each test is defined as a table via
+`[[test]]`.
+
+Each test has the following fields:
+
+* `name` - A name for the test. It must be unique within its file. A test's
+[`RegexTest::full_name`] is derived either via `{group_name}/{name}` or
+`{group_name}/{name}/{additional_name}`, with the latter being used only when
+[`TestRunner::expand`] is used. The `group_name` is derived from the file stem
+(the file name without the `.toml suffix).
+* `regex` - The regex to test. This is either a string or a (possibly empty)
+list of regex patterns. When using a list, the underlying regex engine is
+expected to support multiple patterns where each are identified starting from
+`0` and incrementing by 1 for each subsequent pattern.
+* `haystack` - The text to search.
+* `bounds` - An optional field whose value is a table with `start` and `end`
+fields, whose values must be valid for the given `haystack`. When set,
+the search will only execute within these bounds. When absent, the bounds
+correspond to `start = 0` and `end = haystack.len()`.
+* `matches` - Zero or more match values. Each match value can be in one of four
+formats:
+    * A simple span, i.e., `[5, 12]`, corresponding to the start and end of the
+    match, in byte offsets. The start is inclusive and the end is exclusive.
+    The pattern ID for the match is assumed to be `0`.
+    * A table corresponding to the matching pattern ID and the span of the
+    match. For example, `{ id = 5, span = [20, 21] }`.
+    * A list of capture group spans, with the first corresponding to the
+    overall match and the pattern ID assumed to be `0`. For example,
+    `[[5, 10], [6, 8], [], [9, 10]]`, where `[]` corresponds to a group
+    present in the regex but one that did not participate in a match.
+    * A table corresponding to the matching pattern ID and a list of spans
+    corresponding to the capture groups. For example,
+    `{ id = 5, spans = [[5, 10], [6, 8], [], [9, 10]] }`. This is the most
+    general, but also most verbose, syntax.
+* `match-limit` - An optional field that specifies a limit on the number of
+matches. When absent, no limit is enforced and all matches should be reported
+by the regex engine. This can be useful, for example, when one only cares about
+the first match.
+* `compiles` - An optional field indicating whether the regex is expected to
+compile. It defaults to `true` when absent. When `true`, if the regex does not
+compile, then the test fails. Conversely, when `false`, if the regex _does_
+compile, then the test fails.
+* `anchored` - Whether to execute an anchored search or not. Note that this is
+not the same as adding a `^` to the beginning of your regex pattern. `^` always
+requires the regex to match at position `0`, but an anchored search simply
+requires that the regex match at the starting position of the search. (The
+starting position of the search can be configured via the optional `bounds`
+field.)
+* `case-insensitive` - Whether to match the regex case insensitively. This is
+disabled by default. There is no real difference between using this field and
+adding a `(?i)` to the beginning of your regex. (Some regex engines may not
+support `(?i)`.)
+* `unescape` - When enabled, the haystack is unescaped. Sequences like `\x00`
+are turned into their corresponding byte values. This permits one to write
+haystacks that contain invalid UTF-8 without embedding actual invalid UTF-8
+into a TOML file (which is not allowed). There is generally no other reason to
+enable `unescape`.
+* `unicode` - When enabled, the regex pattern should be compiled with its
+corresponding Unicode mode enabled. For example, `[^a]` matches any UTF-8
+encoding of any codepoint other than `a`. Case insensitivty should be Unicode
+aware. Unicode classes like `\pL` are available. The Perl classes `\w`, `\s`
+and `\d` should be Unicode aware. And so on. This is an optional field and is
+enabled by default.
+* `utf8` - When this is enabled, all regex match substrings should be entirely
+valid UTF-8. While parts of the haystack the regex searches through may not be
+valid UTF-8, only the portions that are valid UTF-8 may be reported in match
+spans. Importantly, this includes zero-width matches. Zero-width matches must
+never split the UTF-8 encoding of a single codepoint when this is enabled. This
+is an optional field and is enabled by default.
+* `line-terminator` - This sets the line terminator used by the multi-line
+assertions `(?m:^)` and `(?m:$)`. It defaults to `\n`. It must be exactly one
+byte. This field is automatically unescaped in order to permit a non-ASCII
+byte.
+* `match-kind` - May be one of `all`, `leftmost-first` or `leftmost-longest`.
+See [`MatchKind`] for more details. This is an optional field and defaults to
+`leftmost-first`.
+* `search-kind` - May be one of `earliest`, `leftmost` or `overlapping`. See
+[`SearchKind`] for more details. This is an optional field and defaults to
+`leftmost`.
+*/
+
+#![deny(missing_docs)]
+
+/// For convenience, `anyhow::Error` is used to represents errors in this
+/// crate.
+///
+/// For this reason, `anyhow` is a public dependency and is re-exported here.
+pub extern crate anyhow;
+
+use std::{
+    borrow::Borrow, collections::HashSet, convert::TryFrom, fs, path::Path,
+};
+
+use {
+    anyhow::{bail, Context, Result},
+    bstr::{BString, ByteSlice, ByteVec},
+    serde::Deserialize,
+};
+
+const ENV_REGEX_TEST: &str = "REGEX_TEST";
+const ENV_REGEX_TEST_VERBOSE: &str = "REGEX_TEST_VERBOSE";
+
+/// A collection of regex tests.
+#[derive(Clone, Debug, Deserialize)]
+pub struct RegexTests {
+    /// 'default' permits an empty TOML file.
+    #[serde(default, rename = "test")]
+    tests: Vec<RegexTest>,
+    #[serde(skip)]
+    seen: HashSet<String>,
+}
+
+impl RegexTests {
+    /// Create a new empty collection of glob tests.
+    pub fn new() -> RegexTests {
+        RegexTests { tests: vec![], seen: HashSet::new() }
+    }
+
+    /// Loads all of the tests in the given TOML file. The group name assigned
+    /// to each test is the stem of the file name. For example, if one loads
+    /// `foo/bar.toml`, then the group name for each test will be `bar`.
+    pub fn load<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
+        let path = path.as_ref();
+        let data = fs::read(path)
+            .with_context(|| format!("failed to read {}", path.display()))?;
+        let group_name = path
+            .file_stem()
+            .with_context(|| {
+                format!("failed to get file name of {}", path.display())
+            })?
+            .to_str()
+            .with_context(|| {
+                format!("invalid UTF-8 found in {}", path.display())
+            })?;
+        self.load_slice(&group_name, &data)
+            .with_context(|| format!("error loading {}", path.display()))?;
+        Ok(())
+    }
+
+    /// Load all of the TOML encoded tests in `data` into this collection.
+    /// The given group name is assigned to all loaded tests.
+    pub fn load_slice(&mut self, group_name: &str, data: &[u8]) -> Result<()> {
+        let data = std::str::from_utf8(&data).with_context(|| {
+            format!("data in {} is not valid UTF-8", group_name)
+        })?;
+        let mut index = 1;
+        let mut tests: RegexTests =
+            toml::from_str(&data).with_context(|| {
+                format!("error decoding TOML for '{}'", group_name)
+            })?;
+        for t in &mut tests.tests {
+            t.group = group_name.to_string();
+            if t.name.is_empty() {
+                t.name = format!("{}", index);
+                index += 1;
+            }
+            t.full_name = format!("{}/{}", t.group, t.name);
+            if t.unescape {
+                t.haystack = BString::from(Vec::unescape_bytes(
+                    // OK because TOML requires valid UTF-8.
+                    t.haystack.to_str().unwrap(),
+                ));
+            }
+            if t.line_terminator.is_empty() {
+                t.line_terminator = BString::from("\n");
+            } else {
+                t.line_terminator = BString::from(Vec::unescape_bytes(
+                    // OK because TOML requires valid UTF-8.
+                    t.line_terminator.to_str().unwrap(),
+                ));
+                anyhow::ensure!(
+                    t.line_terminator.len() == 1,
+                    "line terminator '{:?}' has length not equal to 1",
+                    t.line_terminator,
+                );
+            }
+            if self.seen.contains(t.full_name()) {
+                bail!("found duplicate tests for name '{}'", t.full_name());
+            }
+            self.seen.insert(t.full_name().to_string());
+        }
+        self.tests.extend(tests.tests);
+        Ok(())
+    }
+
+    /// Return an iterator over all regex tests that have been loaded. The
+    /// order of the iterator corresponds to the order in which the tests were
+    /// loaded.
+    ///
+    /// This is useful to pass to [`TestRunner::test_iter`].
+    pub fn iter(&self) -> RegexTestsIter {
+        RegexTestsIter(self.tests.iter())
+    }
+}
+
+/// A regex test describes the inputs and expected outputs of a regex match.
+///
+/// Each `RegexTest` represents a single `[[test]]` table in a TOML test file.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct RegexTest {
+    #[serde(skip)]
+    group: String,
+    #[serde(default)]
+    name: String,
+    #[serde(skip)]
+    additional_name: String,
+    #[serde(skip)]
+    full_name: String,
+    regex: RegexesFormat,
+    haystack: BString,
+    bounds: Option<Span>,
+    matches: Vec<Captures>,
+    #[serde(rename = "match-limit")]
+    match_limit: Option<usize>,
+    #[serde(default = "default_true")]
+    compiles: bool,
+    #[serde(default)]
+    anchored: bool,
+    #[serde(default, rename = "case-insensitive")]
+    case_insensitive: bool,
+    #[serde(default)]
+    unescape: bool,
+    #[serde(default = "default_true")]
+    unicode: bool,
+    #[serde(default = "default_true")]
+    utf8: bool,
+    #[serde(default, rename = "line-terminator")]
+    line_terminator: BString,
+    #[serde(default, rename = "match-kind")]
+    match_kind: MatchKind,
+    #[serde(default, rename = "search-kind")]
+    search_kind: SearchKind,
+}
+
+impl RegexTest {
+    /// Return the group name of this test.
+    ///
+    /// Usually the group name corresponds to a collection of related
+    /// tests. More specifically, when using [`RegexTests::load`], the
+    /// group name corresponds to the file stem (the file name without the
+    /// `.toml` suffix). Otherwise, the group name is whatever is given to
+    /// [`RegexTests::load_slice`].
+    pub fn group(&self) -> &str {
+        &self.group
+    }
+
+    /// The name of this test.
+    ///
+    /// Note that this is only the name as given in the `[[test]]` block. The
+    /// actual full name used for filtering and reporting can be retrieved with
+    /// [`RegexTest::full_name`].
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// The additional name for this test.
+    ///
+    /// This is only non-empty when the test runner was expanded with
+    /// [`TestRunner::expand`].
+    pub fn additional_name(&self) -> &str {
+        &self.additional_name
+    }
+
+    /// The full name of this test, which is formed by joining the group
+    /// name, the test name and the additional name with a `/`.
+    pub fn full_name(&self) -> &str {
+        &self.full_name
+    }
+
+    /// Return all of the regexes that should be matched for this test. This
+    /// slice may be empty!
+    pub fn regexes(&self) -> &[String] {
+        self.regex.patterns()
+    }
+
+    /// Return the bytes on which the regex should be matched.
+    pub fn haystack(&self) -> &[u8] {
+        &self.haystack
+    }
+
+    /// Returns the bounds of a search.
+    ///
+    /// If the test didn't specify any bounds, then the bounds returned are
+    /// equivalent to the entire haystack.
+    pub fn bounds(&self) -> Span {
+        self.bounds.unwrap_or(Span { start: 0, end: self.haystack().len() })
+    }
+
+    /// Returns the limit on the number of matches that should be reported,
+    /// if specified in the test.
+    ///
+    /// This is useful for tests that only want to check for the first
+    /// match. In which case, the match limit is set to 1.
+    ///
+    /// If there is no match limit, then regex engines are expected to report
+    /// all matches.
+    pub fn match_limit(&self) -> Option<usize> {
+        self.match_limit
+    }
+
+    /// Returns true if the regex(es) in this test are expected to compile.
+    pub fn compiles(&self) -> bool {
+        self.compiles
+    }
+
+    /// Whether the regex should perform an anchored search.
+    ///
+    /// This is distinct from putting a `^` in the regex in that `bounds` may
+    /// be specified that permit the regex search to start at a position
+    /// `i > 0`. In which case, enabling anchored mode here requires that any
+    /// matches produced must have a start offset at `i`.
+    pub fn anchored(&self) -> bool {
+        self.anchored
+    }
+
+    /// Returns true if regex matching should be performed without regard to
+    /// case.
+    pub fn case_insensitive(&self) -> bool {
+        self.case_insensitive
+    }
+
+    /// Returns true if regex matching should have Unicode mode enabled.
+    ///
+    /// For example, `[^a]` matches any UTF-8 encoding of any codepoint other
+    /// than `a`. Case insensitivty should be Unicode aware. Unicode classes
+    /// like `\pL` are available. The Perl classes `\w`, `\s` and `\d` should
+    /// be Unicode aware. And so on.
+    ///
+    /// This is enabled by default.
+    pub fn unicode(&self) -> bool {
+        self.unicode
+    }
+
+    /// Returns true if regex matching should exclusively match valid UTF-8.
+    /// When this is disabled, matching on arbitrary bytes is permitted.
+    ///
+    /// When this is enabled, all regex match substrings should be entirely
+    /// valid UTF-8. While parts of the haystack the regex searches through
+    /// may not be valid UTF-8, only the portions that are valid UTF-8 may be
+    /// reported in match spans.
+    ///
+    /// Importantly, this includes zero-width matches. Zero-width matches must
+    /// never split the UTF-8 encoding of a single codepoint when this is
+    /// enabled.
+    ///
+    /// This is enabled by default.
+    pub fn utf8(&self) -> bool {
+        self.utf8
+    }
+
+    /// Returns the line terminator that should be used for the multi-line
+    /// assertions `(?m:^)` and `(?m:$)`.
+    ///
+    /// If it isn't set, then this defaults to `\n`.
+    pub fn line_terminator(&self) -> u8 {
+        self.line_terminator[0]
+    }
+
+    /// Return the match semantics required by this test.
+    pub fn match_kind(&self) -> MatchKind {
+        self.match_kind
+    }
+
+    /// Return the search semantics required by this test.
+    pub fn search_kind(&self) -> SearchKind {
+        self.search_kind
+    }
+
+    /// Run the test and return the result produced by the given compiled
+    /// regex.
+    fn test(&self, regex: &mut CompiledRegex) -> TestResult {
+        match regex.matcher {
+            None => TestResult::skip(),
+            Some(ref mut match_regex) => match_regex(self),
+        }
+    }
+
+    /// Append `/name` to the `full_name` of this test.
+    ///
+    /// This is used to support [`TestRunner::expand`].
+    fn with_additional_name(&self, name: &str) -> RegexTest {
+        let additional_name = name.to_string();
+        let full_name = format!("{}/{}", self.full_name, additional_name);
+        RegexTest { additional_name, full_name, ..self.clone() }
+    }
+
+    /// Returns true if and only if this test expects at least one of the
+    /// regexes to match the haystack.
+    fn is_match(&self) -> bool {
+        !self.matches.is_empty()
+    }
+
+    /// Returns a slice of pattern IDs that are expected to match the haystack.
+    /// The slice is empty if no match is expected to occur. The IDs returned
+    /// are deduplicated and sorted in ascending order.
+    fn which_matches(&self) -> Vec<usize> {
+        let mut seen = HashSet::new();
+        let mut ids = vec![];
+        for cap in self.matches.iter() {
+            if !seen.contains(&cap.id) {
+                seen.insert(cap.id);
+                ids.push(cap.id);
+            }
+        }
+        ids.sort();
+        ids
+    }
+
+    /// Extracts the overall match from each `Captures` match in this test
+    /// and returns it.
+    fn matches(&self) -> Vec<Match> {
+        let mut matches = vec![];
+        for cap in self.matches.iter() {
+            matches.push(cap.to_match());
+        }
+        matches
+    }
+
+    /// Returns the matches expected by this test, includng the spans of any
+    /// matching capture groups.
+    fn captures(&self) -> Vec<Captures> {
+        self.matches.clone()
+    }
+}
+
+/// The result of compiling a regex.
+///
+/// In many implementations, the act of matching a regex can be separated from
+/// the act of compiling a regex. A `CompiledRegex` represents a regex that has
+/// been compiled and is ready to be used for matching.
+///
+/// The matching implementation is represented by a closure that accepts a
+/// [`&RegexTest`](RegexTest) and returns a [`TestResult`].
+pub struct CompiledRegex {
+    matcher: Option<Box<dyn FnMut(&RegexTest) -> TestResult + 'static>>,
+}
+
+impl CompiledRegex {
+    /// Provide a closure that represents the compiled regex and executes a
+    /// regex match on any `RegexTest`. The `RegexTest` given to the closure
+    /// provided is the exact same `RegexTest` that is used to compile this
+    /// regex.
+    pub fn compiled(
+        matcher: impl FnMut(&RegexTest) -> TestResult + 'static,
+    ) -> CompiledRegex {
+        CompiledRegex { matcher: Some(Box::new(matcher)) }
+    }
+
+    /// Indicate that tests on this regex should be skipped. This typically
+    /// occurs if the `RegexTest` requires something that an implementation
+    /// does not support.
+    pub fn skip() -> CompiledRegex {
+        CompiledRegex { matcher: None }
+    }
+
+    /// Returns true if the test runner decided to skip the test when
+    /// attempting to compile the regex.
+    pub fn is_skip(&self) -> bool {
+        self.matcher.is_none()
+    }
+}
+
+impl std::fmt::Debug for CompiledRegex {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let status = match self.matcher {
+            None => "Skip",
+            Some(_) => "Run(...)",
+        };
+        f.debug_struct("CompiledRegex").field("matcher", &status).finish()
+    }
+}
+
+/// The result of executing a regex search.
+///
+/// When using the test runner, callers must provide a closure that takes
+/// a `RegexTest` and returns a `TestResult`. The `TestResult` is meant to
+/// capture the results of matching the haystack against the regex specified by
+/// the `RegexTest`.
+///
+/// Usually this consists of one or more matches, which can be constructed via
+/// `TestResult::matches` (for just overall matches) or `TestResult::captures`
+/// (for matches with capture group spans). But the regex engine may also
+/// report whether a match exists, or just whether a pattern matched or not.
+/// That can be done via `TestResult::matched` and `TestResult::which`,
+/// respectively.
+#[derive(Debug, Clone)]
+pub struct TestResult {
+    kind: TestResultKind,
+}
+
+#[derive(Debug, Clone)]
+enum TestResultKind {
+    Match(bool),
+    Which(Vec<usize>),
+    StartEnd(Vec<Match>),
+    Captures(Vec<Captures>),
+    Skip,
+    Fail { why: String },
+}
+
+impl TestResult {
+    /// Create a test result that indicates just whether any match was found
+    /// or not.
+    pub fn matched(yes: bool) -> TestResult {
+        TestResult { kind: TestResultKind::Match(yes) }
+    }
+
+    /// Create a test result that indicates which out of possibly many regexes
+    /// matched the haystack. If `which` is empty, then this is equivalent to
+    /// `TestResult::matched(false)`.
+    ///
+    /// Note that the iterator should consist of pattern IDs, where each
+    /// ID corresponds to a pattern that matches anywhere in the haystack.
+    /// Multiple patterns may match the same region of the haystack. That is,
+    /// this supports overlapping matches.
+    pub fn which<I: IntoIterator<Item = usize>>(it: I) -> TestResult {
+        let mut which: Vec<usize> = it.into_iter().collect();
+        which.sort();
+        TestResult { kind: TestResultKind::Which(which) }
+    }
+
+    /// Create a test result containing a sequence of all matches in the test's
+    /// haystack. This is useful when the regex engine only reports overall
+    /// matches and not the spans of each matching capture group.
+    ///
+    /// If the sequence is empty, then this is equivalent to
+    /// `TestResult::matched(false)`.
+    pub fn matches<I: IntoIterator<Item = Match>>(it: I) -> TestResult {
+        TestResult { kind: TestResultKind::StartEnd(it.into_iter().collect()) }
+    }
+
+    /// Create a test result containing a sequence of all capturing matches in
+    /// the test's haystack. Each match is a `Captures`, and each `Captures`
+    /// should include the spans of all matching capturing groups.
+    ///
+    /// If the sequence is empty, then this is equivalent to
+    /// `TestResult::matched(false)`.
+    pub fn captures<I: IntoIterator<Item = Captures>>(it: I) -> TestResult {
+        TestResult { kind: TestResultKind::Captures(it.into_iter().collect()) }
+    }
+
+    /// Indicate that this test should be skipped. It will not be counted as
+    /// a failure.
+    pub fn skip() -> TestResult {
+        TestResult { kind: TestResultKind::Skip }
+    }
+
+    /// Indicate that this test should be failed for the reason given.
+    ///
+    /// This is useful when a test needs to be failed for reasons that the
+    /// test runner itself cannot check. That is, the test is failed by the
+    /// implementation being tested.
+    pub fn fail(why: &str) -> TestResult {
+        TestResult { kind: TestResultKind::Fail { why: why.to_string() } }
+    }
+}
+
+/// A runner for executing regex tests.
+///
+/// This runner is intended to be used within a Rust unit test, marked with the
+/// `#[test]` attribute.
+///
+/// A test runner is responsible for running tests against a regex
+/// implementation. It contains logic for skipping tests and collects test
+/// results. Typical usage corresponds to calling [`TestRunner::test_iter`] on
+/// an iterator of `RegexTest`s, and then calling `assert` once done. If any
+/// tests failed, then `assert` will panic with an error message containing all
+/// test failures. `assert` must be called before the test completes.
+///
+/// # Skipping tests
+///
+/// If the `REGEX_TEST` environment variable is set, then it may contain
+/// a comma separated list of substrings. Each substring corresponds to a
+/// whitelisted item, unless it starts with a `-`, in which case it corresponds
+/// to a blacklisted item.
+///
+/// If there are any whitelist items, then a test's full name must contain at
+/// least one of the whitelist substrings in order to be run, and does not
+/// contain and blacklist substrings. If there are no whitelist substrings,
+/// then a test is run only when it does not match any blacklist substrings.
+///
+/// The last substring that a test name matches takes precedent.
+///
+/// Callers may also specify explicit whitelist or blacklist substrings using
+/// the corresponding methods on this type, which has the effect of always
+/// having those rules in place for that specific test. For example, if you're
+/// testing a search by building a DFA and then minimizing it, you may want to
+/// skip tests with bigger regexes, since they could take quite some time to
+/// run.
+///
+/// Whitelist and blacklist substrings are matched on the full name of each
+/// test, which typically looks like `group_name/test_name`.
+///
+/// Currently there is no way to escape either a `-` or a `,` in `REGEX_TEST`.
+/// This usually isn't required because test names usually don't include either
+/// character.
+#[derive(Debug)]
+pub struct TestRunner {
+    include: Vec<IncludePattern>,
+    results: RegexTestResults,
+    expanders: Vec<Expander>,
+}
+
+impl TestRunner {
+    /// Create a new runner for executing tests.
+    ///
+    /// The test runner maintains a full list of tests that have succeeded,
+    /// failed or been skipped. Moreover, the test runner may control which
+    /// tests get run via its whitelist and blacklist.
+    ///
+    /// This returns an error if there was a problem reading the `REGEX_TEST`
+    /// environment variable, which may be set to include or exclude tests.
+    /// See the docs on `TestRunner` for its format.
+    pub fn new() -> Result<TestRunner> {
+        let mut runner = TestRunner {
+            include: vec![],
+            results: RegexTestResults::new(),
+            expanders: vec![],
+        };
+        for mut substring in read_env(ENV_REGEX_TEST)?.split(",") {
+            substring = substring.trim();
+            if substring.is_empty() {
+                continue;
+            }
+            if substring.starts_with("-") {
+                runner.blacklist(&substring[1..]);
+            } else {
+                runner.whitelist(substring);
+            }
+        }
+        Ok(runner)
+    }
+
+    /// Assert that all tests run have either passed or have been skipped.
+    ///
+    /// If any tests have failed, then a panic occurs with a report of all
+    /// failures.
+    ///
+    /// If `REGEX_TEST_VERBOSE` is set to `1`, then a longer report of tests
+    /// that passed, failed or skipped is printed.
+    pub fn assert(&mut self) {
+        self.results.assert();
+    }
+
+    /// Whitelist the given substring.
+    ///
+    /// Whitelist and blacklist rules are only applied when
+    /// [`TestRunner::test_iter`] is called.
+    pub fn whitelist(&mut self, substring: &str) -> &mut TestRunner {
+        self.include.push(IncludePattern {
+            blacklist: false,
+            substring: BString::from(substring),
+        });
+        self
+    }
+
+    /// Whitelist the given iterator substrings.
+    ///
+    /// This is a convenience routine for calling `whitelist` on each of the
+    /// substrings in the iterator provided.
+    ///
+    /// Whitelist and blacklist rules are only applied when
+    /// [`TestRunner::test_iter`] is called.
+    pub fn whitelist_iter<I, S>(&mut self, substrings: I) -> &mut TestRunner
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        for substring in substrings {
+            self.whitelist(substring.as_ref());
+        }
+        self
+    }
+
+    /// Blacklist the given substring.
+    ///
+    /// A blacklisted test is never run, unless a whitelisted substring added
+    /// after the blacklisted substring matches it.
+    ///
+    /// Whitelist and blacklist rules are only applied when
+    /// [`TestRunner::test_iter`] is called.
+    pub fn blacklist(&mut self, substring: &str) -> &mut TestRunner {
+        self.include.push(IncludePattern {
+            blacklist: true,
+            substring: BString::from(substring),
+        });
+        self
+    }
+
+    /// Blacklist the given iterator substrings.
+    ///
+    /// A blacklisted test is never run, unless a whitelisted substring added
+    /// after the blacklisted substring matches it.
+    ///
+    /// This is a convenience routine for calling `blacklist` on each of the
+    /// substrings in the iterator provided.
+    ///
+    /// Whitelist and blacklist rules are only applied when
+    /// [`TestRunner::test_iter`] is called.
+    pub fn blacklist_iter<I, S>(&mut self, substrings: I) -> &mut TestRunner
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        for substring in substrings {
+            self.blacklist(substring.as_ref());
+        }
+        self
+    }
+
+    /// Set an expansion predicate that appends each entry in
+    /// `additional_names` to the end the name for every test that `predicate`
+    /// returns true. Moreover, the corresponding additional name is made
+    /// available via [`RegexTest::additional_name`].
+    ///
+    /// This permits implementors to create multiple copies of each test, and
+    /// then do specifically different tasks with each, while making it so each
+    /// test is distinct.
+    ///
+    /// For example, you might write something like this:
+    ///
+    /// ```ignore
+    /// TestRunner::new()?
+    ///     .expand(&["is_match", "find"], |t| t.compiles())
+    ///     .test_iter(tests, compiler)
+    ///     .assert()
+    /// ```
+    ///
+    /// where each test that is expected to have a regex compile gets copied
+    /// with `/is_match` and `/find` appends to the end of its name. Then, in
+    /// your own test runner, you can inspect [`RegexTest::additional_name`] to
+    /// decide what to do. In the case of `is_match`, you might test your regex
+    /// engines "has a match" API, which might exercise different logic than
+    /// your "find where the matches are" API.
+    pub fn expand<S: AsRef<str>>(
+        &mut self,
+        additional_names: &[S],
+        predicate: impl FnMut(&RegexTest) -> bool + 'static,
+    ) -> &mut TestRunner {
+        self.expanders.push(Expander {
+            predicate: Box::new(predicate),
+            additional_names: additional_names
+                .iter()
+                .map(|s| s.as_ref().to_string())
+                .collect(),
+        });
+        self
+    }
+
+    /// Run all of the given tests using the given regex compiler.
+    ///
+    /// The compiler given is a closure that accepts a
+    /// [`&RegexTest`](RegexTest) and a sequence of patterns, and returns (if
+    /// successful) a [`CompiledRegex`] which can execute a search.
+    ///
+    /// Note that if there are test failures, this merely _collects_ them. Use
+    /// [`TestRunner::assert`] to fail the current test by panicking if there
+    /// any failures.
+    ///
+    /// Typically, one provides [`RegexTests::iter`] as the iterator of
+    /// `RegexTest` values.
+    pub fn test_iter<I, T>(
+        &mut self,
+        it: I,
+        mut compile: impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex>,
+    ) -> &mut TestRunner
+    where
+        I: IntoIterator<Item = T>,
+        T: Borrow<RegexTest>,
+    {
+        for test in it {
+            let test = test.borrow();
+            let mut additional = vec![];
+            for expander in &mut self.expanders {
+                if (expander.predicate)(test) {
+                    for name in expander.additional_names.iter() {
+                        additional.push(test.with_additional_name(name));
+                    }
+                    break;
+                }
+            }
+            if additional.is_empty() {
+                additional.push(test.to_owned());
+            }
+            for test in &additional {
+                if self.should_skip(test) {
+                    self.results.skip(test);
+                    continue;
+                }
+                self.test(test, |regexes| compile(test, regexes));
+            }
+        }
+        self
+    }
+
+    /// Run a single test.
+    ///
+    /// This records the result of running the test in this runner. This does
+    /// not fail the test immediately if the given regex test fails. Instead,
+    /// this is only done when the `assert` method is called.
+    ///
+    /// Note that using this method bypasses any whitelist or blacklist applied
+    /// to this runner. Whitelisted (and blacklisted) substrings are only
+    /// applied when using `test_iter`.
+    pub fn test(
+        &mut self,
+        test: &RegexTest,
+        mut compile: impl FnMut(&[String]) -> Result<CompiledRegex>,
+    ) -> &mut TestRunner {
+        let mut compiled = match safe(|| compile(test.regexes())) {
+            Err(msg) => {
+                // Regex tests should never panic. It's auto-fail if they do.
+                self.results.fail(
+                    test,
+                    RegexTestFailureKind::UnexpectedPanicCompile(msg),
+                );
+                return self;
+            }
+            Ok(Ok(compiled)) => compiled,
+            Ok(Err(err)) => {
+                if !test.compiles() {
+                    self.results.pass(test);
+                } else {
+                    self.results.fail(
+                        test,
+                        RegexTestFailureKind::CompileError { err },
+                    );
+                }
+                return self;
+            }
+        };
+        // We fail the test if we didn't expect the regex to compile. However,
+        // it's possible the caller decided to skip the test when attempting
+        // to compile the regex, so we check for that. If the compiled regex
+        // is marked as skipped, then 'test.test(..)' below handles it
+        // correctly.
+        if !test.compiles() && !compiled.is_skip() {
+            self.results.fail(test, RegexTestFailureKind::NoCompileError);
+            return self;
+        }
+        let result = match safe(|| test.test(&mut compiled)) {
+            Ok(result) => result,
+            Err(msg) => {
+                self.results.fail(
+                    test,
+                    RegexTestFailureKind::UnexpectedPanicSearch(msg),
+                );
+                return self;
+            }
+        };
+        match result.kind {
+            TestResultKind::Match(yes) => {
+                if yes == test.is_match() {
+                    self.results.pass(test);
+                } else {
+                    self.results.fail(test, RegexTestFailureKind::IsMatch);
+                }
+            }
+            TestResultKind::Which(which) => {
+                if which != test.which_matches() {
+                    self.results
+                        .fail(test, RegexTestFailureKind::Many { got: which });
+                } else {
+                    self.results.pass(test);
+                }
+            }
+            TestResultKind::StartEnd(matches) => {
+                let expected = test.matches();
+                if expected != matches {
+                    self.results.fail(
+                        test,
+                        RegexTestFailureKind::StartEnd { got: matches },
+                    );
+                } else {
+                    self.results.pass(test);
+                }
+            }
+            TestResultKind::Captures(caps) => {
+                let expected = test.captures();
+                if expected != caps {
+                    self.results.fail(
+                        test,
+                        RegexTestFailureKind::Captures { got: caps },
+                    );
+                } else {
+                    self.results.pass(test);
+                }
+            }
+            TestResultKind::Skip => {
+                self.results.skip(test);
+            }
+            TestResultKind::Fail { why } => {
+                self.results
+                    .fail(test, RegexTestFailureKind::UserFailure { why });
+            }
+        }
+        self
+    }
+
+    /// Return true if and only if the given test should be skipped.
+    fn should_skip(&self, test: &RegexTest) -> bool {
+        if self.include.is_empty() {
+            return false;
+        }
+
+        // If we don't have any whitelist patterns, then the test will be run
+        // unless it is blacklisted. Otherwise, if there are whitelist
+        // patterns, then the test must match at least one of them.
+        let mut skip = self.include.iter().any(|pat| !pat.blacklist);
+        for pat in &self.include {
+            if test.full_name().as_bytes().contains_str(&pat.substring) {
+                skip = pat.blacklist;
+            }
+        }
+        skip
+    }
+}
+
+#[derive(Debug)]
+struct IncludePattern {
+    blacklist: bool,
+    substring: BString,
+}
+
+struct Expander {
+    predicate: Box<dyn FnMut(&RegexTest) -> bool>,
+    additional_names: Vec<String>,
+}
+
+impl std::fmt::Debug for Expander {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("Expander")
+            .field("predicate", &"<FnMut(..)>")
+            .field("additional_names", &self.additional_names)
+            .finish()
+    }
+}
+
+/// A collection of test results, corresponding to passed, skipped and failed
+/// tests.
+#[derive(Debug)]
+struct RegexTestResults {
+    pass: Vec<RegexTestResult>,
+    fail: Vec<RegexTestFailure>,
+    skip: Vec<RegexTestResult>,
+}
+
+/// A test that passed or skipped, along with its specific result.
+#[derive(Debug)]
+struct RegexTestResult {
+    test: RegexTest,
+}
+
+/// A test that failed along with the reason why.
+#[derive(Debug)]
+struct RegexTestFailure {
+    test: RegexTest,
+    kind: RegexTestFailureKind,
+}
+
+/// Describes the nature of the failed test.
+#[derive(Debug)]
+enum RegexTestFailureKind {
+    /// UserFailure indicates that the test failed because the test function
+    /// explicitly failed it for the reason in the message given.
+    UserFailure { why: String },
+    /// This occurs when the test expected a match (or didn't expect a match),
+    /// but the actual regex implementation didn't match (or did match).
+    IsMatch,
+    /// This occurs when a set of regexes is tested, and the matching regexes
+    /// returned by the regex implementation don't match the expected matching
+    /// regexes. This error contains the indices of the regexes that matched.
+    Many { got: Vec<usize> },
+    /// This occurs when a single regex is used to find all non-overlapping
+    /// matches in a haystack, where the result did not match what was
+    /// expected. This reports the incorrect matches returned by the regex
+    /// implementation under test.
+    StartEnd { got: Vec<Match> },
+    /// Like StartEnd, but for capturing groups.
+    Captures { got: Vec<Captures> },
+    /// This occurs when the test expected the regex to fail to compile, but it
+    /// compiled successfully.
+    NoCompileError,
+    /// This occurs when the test expected the regex to compile successfully,
+    /// but it failed to compile.
+    CompileError { err: anyhow::Error },
+    /// While compiling, a panic occurred. If possible, the panic message
+    /// is captured.
+    UnexpectedPanicCompile(String),
+    /// While searching, a panic occurred. If possible, the panic message
+    /// is captured.
+    UnexpectedPanicSearch(String),
+}
+
+impl RegexTestResults {
+    fn new() -> RegexTestResults {
+        RegexTestResults { pass: vec![], fail: vec![], skip: vec![] }
+    }
+
+    fn pass(&mut self, test: &RegexTest) {
+        self.pass.push(RegexTestResult { test: test.clone() });
+    }
+
+    fn fail(&mut self, test: &RegexTest, kind: RegexTestFailureKind) {
+        self.fail.push(RegexTestFailure { test: test.clone(), kind });
+    }
+
+    fn skip(&mut self, test: &RegexTest) {
+        self.skip.push(RegexTestResult { test: test.clone() });
+    }
+
+    fn assert(&self) {
+        if read_env(ENV_REGEX_TEST_VERBOSE).map_or(false, |s| s == "1") {
+            self.verbose();
+        }
+        if self.fail.is_empty() {
+            return;
+        }
+        let failures = self
+            .fail
+            .iter()
+            .map(|f| f.to_string())
+            .collect::<Vec<String>>()
+            .join("\n\n");
+        panic!(
+            "found {} failures:\n{}\n{}\n{}\n\n\
+             Set the REGEX_TEST environment variable to filter tests, \n\
+             e.g., REGEX_TEST=foo,-foo2 runs every test whose name contains \n\
+             foo but not foo2\n\n",
+            self.fail.len(),
+            "~".repeat(79),
+            failures.trim(),
+            "~".repeat(79),
+        )
+    }
+
+    fn verbose(&self) {
+        println!("{}", "~".repeat(79));
+        for t in &self.skip {
+            println!("skip: {}", t.full_name());
+        }
+        for t in &self.pass {
+            println!("pass: {}", t.full_name());
+        }
+        for t in &self.fail {
+            println!("FAIL: {}", t.test.full_name());
+        }
+        println!(
+            "\npassed: {}, skipped: {}, failed: {}",
+            self.pass.len(),
+            self.skip.len(),
+            self.fail.len()
+        );
+        println!("{}", "~".repeat(79));
+    }
+}
+
+impl RegexTestResult {
+    fn full_name(&self) -> String {
+        self.test.full_name().to_string()
+    }
+}
+
+impl RegexTestFailure {
+    fn full_name(&self) -> String {
+        self.test.full_name().to_string()
+    }
+}
+
+impl std::fmt::Display for RegexTestFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{}: {}\n\
+             pattern:     {:?}\n\
+             haystack:    {:?}",
+            self.full_name(),
+            self.kind.fmt(&self.test)?,
+            self.test.regexes(),
+            self.test.haystack().as_bstr(),
+        )?;
+        Ok(())
+    }
+}
+
+impl RegexTestFailureKind {
+    fn fmt(&self, test: &RegexTest) -> Result<String, std::fmt::Error> {
+        use std::fmt::Write;
+
+        let mut buf = String::new();
+        match *self {
+            RegexTestFailureKind::UserFailure { ref why } => {
+                write!(buf, "failed by implementor because: {}", why)?;
+            }
+            RegexTestFailureKind::IsMatch => {
+                if test.is_match() {
+                    write!(buf, "expected match, but none found")?;
+                } else {
+                    write!(buf, "expected no match, but found a match")?;
+                }
+            }
+            RegexTestFailureKind::Many { ref got } => {
+                write!(
+                    buf,
+                    "expected regexes {:?} to match, but found {:?}",
+                    test.which_matches(),
+                    got
+                )?;
+            }
+            RegexTestFailureKind::StartEnd { ref got } => {
+                write!(
+                    buf,
+                    "did not find expected matches\n\
+                     expected: {:?}\n     \
+                     got: {:?}",
+                    test.matches(),
+                    got,
+                )?;
+            }
+            RegexTestFailureKind::Captures { ref got } => {
+                write!(
+                    buf,
+                    "expected to find {:?} captures, but got {:?}",
+                    test.captures(),
+                    got,
+                )?;
+            }
+            RegexTestFailureKind::NoCompileError => {
+                write!(buf, "expected regex to NOT compile, but it did")?;
+            }
+            RegexTestFailureKind::CompileError { ref err } => {
+                write!(buf, "expected regex to compile, failed: {}", err)?;
+            }
+            RegexTestFailureKind::UnexpectedPanicCompile(ref msg) => {
+                write!(buf, "got unexpected panic while compiling:\n{}", msg)?;
+            }
+            RegexTestFailureKind::UnexpectedPanicSearch(ref msg) => {
+                write!(buf, "got unexpected panic while searching:\n{}", msg)?;
+            }
+        }
+        Ok(buf)
+    }
+}
+
+/// An iterator over regex tests.
+///
+/// This iterator is created by the [`RegexTests::iter`] method.
+#[derive(Debug)]
+pub struct RegexTestsIter<'a>(std::slice::Iter<'a, RegexTest>);
+
+impl<'a> Iterator for RegexTestsIter<'a> {
+    type Item = &'a RegexTest;
+
+    fn next(&mut self) -> Option<&'a RegexTest> {
+        self.0.next()
+    }
+}
+
+/// Represents either a single regex or a list of regexes in a TOML.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(untagged)]
+enum RegexesFormat {
+    Single(String),
+    Many(Vec<String>),
+}
+
+impl RegexesFormat {
+    fn patterns(&self) -> &[String] {
+        match *self {
+            RegexesFormat::Single(ref pat) => std::slice::from_ref(pat),
+            RegexesFormat::Many(ref pats) => pats,
+        }
+    }
+}
+
+/// Captures represents a single group of captured matches from a regex search.
+///
+/// There is always at least 1 group, and the first group is always present and
+/// corresponds to the overall match.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(try_from = "CapturesFormat")]
+pub struct Captures {
+    /// The ID of the regex that matched.
+    ///
+    /// The ID is the index of the regex provided to the regex compiler,
+    /// starting from `0`. In the case of a single regex search, the only
+    /// possible ID is `0`.
+    id: usize,
+    /// The capturing groups that matched, along with the match offsets for
+    /// each. The first group should always be non-None, as it corresponds to
+    /// the overall match.
+    ///
+    /// This should either have length 1 (when not capturing group offsets are
+    /// included in the tes tresult) or it should have length equal to the
+    /// number of capturing groups in the regex pattern.
+    groups: Vec<Option<Span>>,
+}
+
+impl Captures {
+    /// Create a new set of captures for a single match of a regex.
+    ///
+    /// If available, iterator should provide items for every capturing group
+    /// in the regex, including the 0th capturing group corresponding to the
+    /// entire match. At minimum, the 0th capturing group should be provided.
+    ///
+    /// If a capturing group did not participate in the match, then a `None`
+    /// value should be used. (The 0th capturing group should never be `None`.)
+    ///
+    /// If the iterator yields no elements or the first group is `None`, then
+    /// this returns an error.
+    ///
+    /// The `id` should be the ID of the pattern that matched. This is always
+    /// `0` for single-pattern regexes. Otherwise, the ID of a pattern starts
+    /// at `0` and is incremented by 1 for each subsequent pattern.
+    ///
+    /// Note that there are possibly more convenient and infallible `From`
+    /// impls for converting a `Match` or a `Span` into a `Captures`.
+    pub fn new<I: IntoIterator<Item = Option<Span>>>(
+        id: usize,
+        it: I,
+    ) -> Result<Captures> {
+        let groups: Vec<Option<Span>> = it.into_iter().collect();
+        if groups.is_empty() {
+            bail!("captures must contain at least one group");
+        } else if groups[0].is_none() {
+            bail!("first group (index 0) of captures must be non-None");
+        }
+        Ok(Captures { id, groups })
+    }
+
+    /// Returns the ID of the pattern that matched.
+    ///
+    /// For any single pattern regexes, this should always be zero.
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
+    /// Returns a slice of the underlying spans, each group corresponding to
+    /// the (possibly) matched span. The first group in the slice returned
+    /// is guaranteed to correspond to the overall match span and is thus
+    /// non-`None`. All other groups may be `None`. Similarly, the slice is
+    /// guaranteed to have length at least 1.
+    pub fn groups(&self) -> &[Option<Span>] {
+        &self.groups
+    }
+
+    /// Returns the number of groups (including the first) in these captures.
+    ///
+    /// The length returned is guaranteed to be greater than zero.
+    pub fn len(&self) -> usize {
+        self.groups.len()
+    }
+
+    /// Returns the overall match, including the pattern ID, for this group
+    /// of captures.
+    pub fn to_match(&self) -> Match {
+        Match { id: self.id(), span: self.to_span() }
+    }
+
+    /// Returns the overall match span for this group of captures.
+    pub fn to_span(&self) -> Span {
+        // This is OK because a Captures value must always have at least one
+        // group where the first group always corresponds to match offsets.
+        self.groups[0].unwrap()
+    }
+}
+
+/// Converts a plain `Match` to a `Captures` value, where the match corresponds
+/// to the first and only group in `Captures`.
+impl From<Match> for Captures {
+    fn from(m: Match) -> Captures {
+        Captures { id: m.id, groups: vec![Some(m.span)] }
+    }
+}
+
+/// Converts a plain `Span` to a `Captures` value, where the span corresponds to
+/// the first and only group in `Captures`. Since a `Span` does not contain a
+/// pattern ID, the pattern ID used in this conversion is always `0`.
+impl From<Span> for Captures {
+    fn from(sp: Span) -> Captures {
+        Captures { id: 0, groups: vec![Some(sp)] }
+    }
+}
+
+/// Represents the actual 'captures' key format more faithfully such that
+/// Serde can deserialize it.
+///
+/// Namely, we need a way to represent a 'None' value inside a TOML array, and
+/// TOML has no 'null' value. So we make '[]' be 'None', and we use 'MaybeSpan'
+/// to recognize it.
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum CapturesFormat {
+    Span([usize; 2]),
+    Match { id: usize, span: [usize; 2] },
+    Spans(Vec<MaybeSpan>),
+    Captures { id: usize, spans: Vec<MaybeSpan> },
+}
+
+impl TryFrom<CapturesFormat> for Captures {
+    type Error = anyhow::Error;
+
+    fn try_from(data: CapturesFormat) -> Result<Captures> {
+        match data {
+            CapturesFormat::Span([start, end]) => {
+                Ok(Captures { id: 0, groups: vec![Some(Span { start, end })] })
+            }
+            CapturesFormat::Match { id, span: [start, end] } => {
+                Ok(Captures { id, groups: vec![Some(Span { start, end })] })
+            }
+            CapturesFormat::Spans(spans) => {
+                Captures::new(0, spans.into_iter().map(|s| s.into_option()))
+            }
+            CapturesFormat::Captures { id, spans } => {
+                Captures::new(id, spans.into_iter().map(|s| s.into_option()))
+            }
+        }
+    }
+}
+
+/// A single match, consisting of the pattern that matched and its span.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Match {
+    /// The ID of the pattern that matched.
+    ///
+    /// This is always `0` for single-pattern regexes. Otherwise, patterns
+    /// start at `0` and count upwards in increments of `1`.
+    pub id: usize,
+    /// The span of the overall match.
+    pub span: Span,
+}
+
+impl std::fmt::Debug for Match {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "Match({:?}: {:?})", self.id, self.span)
+    }
+}
+
+/// A span of contiguous bytes, from start to end, represented via byte
+/// offsets.
+///
+/// The range is inclusive at the beginning and exclusive at the end.
+#[derive(Clone, Copy, Deserialize, Eq, PartialEq)]
+pub struct Span {
+    /// The starting byte offset of the match.
+    pub start: usize,
+    /// The ending byte offset of the match.
+    pub end: usize,
+}
+
+impl std::fmt::Debug for Span {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}..{:?}", self.start, self.end)
+    }
+}
+
+/// Represents a single span, either present or empty.
+///
+/// An empty span is spelled `[]` in TOML, and a present span is spelled `[m,
+/// n]`.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(untagged)]
+enum MaybeSpan {
+    None([usize; 0]),
+    Some([usize; 2]),
+}
+
+impl MaybeSpan {
+    /// Converts this TOML representation of a possibly absent span to a proper
+    /// `Option<Span>`.
+    fn into_option(self) -> Option<Span> {
+        match self {
+            MaybeSpan::None(_) => None,
+            MaybeSpan::Some([start, end]) => Some(Span { start, end }),
+        }
+    }
+}
+
+/// The match semantics to use for a search.
+///
+/// When not specified in a test, the default is `MatchKind::LeftmostFirst`.
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+pub enum MatchKind {
+    /// All possible matches should be reported.
+    ///
+    /// Usually this makes it impossible for non-greedy repetition operators
+    /// to exist. That is, they behave as greedy repetition operators.
+    All,
+    /// Report only the leftmost match. When there are multiple leftmost
+    /// matches that start at the same position, prefer the one that comes
+    /// "first" in the pattern. For example, `sam|samwise` matches `sam` in
+    /// `samwise`.
+    ///
+    /// This typically corresponds to the semantics implemented by backtracking
+    /// engines.
+    LeftmostFirst,
+    /// Report only the leftmost match. When there are multiple leftmost
+    /// matches that start at the same position, prefer the one the longest
+    /// match. For example, `sam|samwise` matches `samwise` in `samwise`.
+    ///
+    /// This typically corresponds to the semantics implemented by POSIX
+    /// engines.
+    LeftmostLongest,
+}
+
+impl Default for MatchKind {
+    fn default() -> MatchKind {
+        MatchKind::LeftmostFirst
+    }
+}
+
+/// Represents the type of search to perform.
+///
+/// When not specified in a test, the default is `SearchKind::Leftmost`.
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+pub enum SearchKind {
+    /// Report matches as soon as they are found.
+    ///
+    /// This is somewhat tricky to test, as this semantic is specified in terms
+    /// of whatever the regex engine can do. For exmaple, an automata oriented
+    /// engine might be able to report a match earlier than a backtracking
+    /// engine.
+    Earliest,
+    /// A standard leftmost search, returning either the leftmost-first or
+    /// leftmost-longest match. Generally speaking, it doesn't make sense to
+    /// use this type of search in combination with [`MatchKind::All`].
+    Leftmost,
+    /// Return all possible matches, including ones that overlap. Typically
+    /// this search kind is used in combination with [`MatchKind::All`].
+    Overlapping,
+}
+
+impl Default for SearchKind {
+    fn default() -> SearchKind {
+        SearchKind::Leftmost
+    }
+}
+
+/// Read the environment variable given. If it doesn't exist, then return an
+/// empty string. Otherwise, check that it is valid UTF-8. If it isn't, return
+/// a useful error message.
+fn read_env(var: &str) -> Result<String> {
+    let val = match std::env::var_os(var) {
+        None => return Ok("".to_string()),
+        Some(val) => val,
+    };
+    let val = val.into_string().map_err(|os| {
+        anyhow::anyhow!(
+            "invalid UTF-8 in env var {}={:?}",
+            var,
+            Vec::from_os_str_lossy(&os)
+        )
+    })?;
+    Ok(val)
+}
+
+/// Runs the given closure such that any panics are caught and converted into
+/// errors. If the panic'd value could not be converted to a known error type,
+/// then a generic string error message is used.
+///
+/// This is useful for use inside the test runner such that bugs for certain
+/// tests don't prevent other tests from running.
+fn safe<T, F>(fun: F) -> Result<T, String>
+where
+    F: FnOnce() -> T,
+{
+    use std::panic;
+
+    panic::catch_unwind(panic::AssertUnwindSafe(fun)).map_err(|any_err| {
+        // Extract common types of panic payload:
+        // panic and assert produce &str or String
+        if let Some(&s) = any_err.downcast_ref::<&str>() {
+            s.to_owned()
+        } else if let Some(s) = any_err.downcast_ref::<String>() {
+            s.to_owned()
+        } else {
+            "UNABLE TO SHOW RESULT OF PANIC.".to_owned()
+        }
+    })
+}
+
+/// A function to set some boolean fields to a default of 'true'. We use a
+/// function so that we can hand a path to it to Serde.
+fn default_true() -> bool {
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn err_no_regexes() {
+        let data = r#"
+[[test]]
+name = "foo"
+haystack = "lib.rs"
+matches = true
+case-insensitive = true
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn err_unknown_field() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = true
+something = 0
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn err_no_matches() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn load_match() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [[0, 6]]
+compiles = false
+anchored = true
+case-insensitive = true
+unicode = false
+utf8 = false
+"#;
+
+        let mut tests = RegexTests::new();
+        tests.load_slice("test", data.as_bytes()).unwrap();
+
+        let t0 = &tests.tests[0];
+        assert_eq!("test", t0.group());
+        assert_eq!("foo", t0.name());
+        assert_eq!("test/foo", t0.full_name());
+        assert_eq!(&[".*.rs"], t0.regexes());
+        assert_eq!(true, t0.is_match());
+        assert_eq!(vec![0], t0.which_matches());
+
+        assert!(!t0.compiles());
+        assert!(t0.anchored());
+        assert!(t0.case_insensitive());
+        assert!(!t0.unicode());
+        assert!(!t0.utf8());
+    }
+
+    #[test]
+    fn load_which_matches() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = [".*.rs", ".*.toml"]
+haystack = "lib.rs"
+matches = [
+    { id = 0, spans = [[0, 0]] },
+    { id = 2, spans = [[0, 0]] },
+    { id = 5, spans = [[0, 0]] },
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        tests.load_slice("test", data.as_bytes()).unwrap();
+
+        let t0 = &tests.tests[0];
+        assert_eq!(&[".*.rs", ".*.toml"], t0.regexes());
+        assert_eq!(true, t0.is_match());
+        assert_eq!(vec![0, 2, 5], t0.which_matches());
+
+        assert!(t0.compiles());
+        assert!(!t0.anchored());
+        assert!(!t0.case_insensitive());
+        assert!(t0.unicode());
+        assert!(t0.utf8());
+    }
+
+    #[test]
+    fn load_spans() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [[0, 2], [5, 10]]
+"#;
+
+        let mut tests = RegexTests::new();
+        tests.load_slice("test", data.as_bytes()).unwrap();
+
+        let spans =
+            vec![Span { start: 0, end: 2 }, Span { start: 5, end: 10 }];
+        let t0 = &tests.tests[0];
+        assert_eq!(t0.regexes(), &[".*.rs"]);
+        assert_eq!(t0.is_match(), true);
+        assert_eq!(t0.which_matches(), &[0]);
+        assert_eq!(
+            t0.matches(),
+            vec![
+                Match { id: 0, span: spans[0] },
+                Match { id: 0, span: spans[1] },
+            ]
+        );
+        assert_eq!(
+            t0.captures(),
+            vec![
+                Captures::new(0, vec![Some(spans[0])]).unwrap(),
+                Captures::new(0, vec![Some(spans[1])]).unwrap(),
+            ]
+        );
+    }
+
+    #[test]
+    fn load_capture_spans() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  [[0, 15], [5, 10], [], [13, 14]],
+  [[20, 30], [22, 24], [25, 27], []],
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        tests.load_slice("test", data.as_bytes()).unwrap();
+
+        let t0 = &tests.tests[0];
+        assert_eq!(t0.regexes(), &[".*.rs"]);
+        assert_eq!(t0.is_match(), true);
+        assert_eq!(t0.which_matches(), &[0]);
+        assert_eq!(
+            t0.matches(),
+            vec![
+                Match { id: 0, span: Span { start: 0, end: 15 } },
+                Match { id: 0, span: Span { start: 20, end: 30 } },
+            ]
+        );
+        assert_eq!(
+            t0.captures(),
+            vec![
+                Captures::new(
+                    0,
+                    vec![
+                        Some(Span { start: 0, end: 15 }),
+                        Some(Span { start: 5, end: 10 }),
+                        None,
+                        Some(Span { start: 13, end: 14 }),
+                    ]
+                )
+                .unwrap(),
+                Captures::new(
+                    0,
+                    vec![
+                        Some(Span { start: 20, end: 30 }),
+                        Some(Span { start: 22, end: 24 }),
+                        Some(Span { start: 25, end: 27 }),
+                        None,
+                    ]
+                )
+                .unwrap(),
+            ]
+        );
+    }
+
+    #[test]
+    fn fail_spans_empty1() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  [],
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn fail_spans_empty2() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  [[]],
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn fail_spans_empty3() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  [[], [0, 2]],
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn fail_captures_empty1() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  { id = 0, spans = [] },
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn fail_captures_empty2() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  { id = 0, spans = [[]] },
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+
+    #[test]
+    fn fail_captures_empty3() {
+        let data = r#"
+[[test]]
+name = "foo"
+regex = ".*.rs"
+haystack = "lib.rs"
+matches = [
+  { id = 0, spans = [[], [0, 2]] },
+]
+"#;
+
+        let mut tests = RegexTests::new();
+        assert!(tests.load_slice("test", data.as_bytes()).is_err());
+    }
+}
diff --git a/scripts/frequencies.py b/scripts/frequencies.py
deleted file mode 100755
index 37eeca7b7d..0000000000
--- a/scripts/frequencies.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-
-# This does simple normalized frequency analysis on UTF-8 encoded text. The
-# result of the analysis is translated to a ranked list, where every byte is
-# assigned a rank. This list is written to src/freqs.rs.
-#
-# Currently, the frequencies are generated from the following corpuses:
-#
-#   * The CIA world fact book
-#   * The source code of rustc
-#   * Septuaginta
-
-from __future__ import absolute_import, division, print_function
-
-import argparse
-from collections import Counter
-import sys
-
-preamble = '''
-// NOTE: The following code was generated by "scripts/frequencies.py", do not
-// edit directly
-'''.lstrip()
-
-
-def eprint(*args, **kwargs):
-    kwargs['file'] = sys.stderr
-    print(*args, **kwargs)
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument('corpus', metavar='FILE', nargs='+')
-    args = p.parse_args()
-
-    # Get frequency counts of each byte.
-    freqs = Counter()
-    for i in range(0, 256):
-        freqs[i] = 0
-
-    eprint('reading entire corpus into memory')
-    corpus = []
-    for fpath in args.corpus:
-        corpus.append(open(fpath, 'rb').read())
-
-    eprint('computing byte frequencies')
-    for c in corpus:
-        for byte in c:
-            freqs[byte] += 1.0 / float(len(c))
-
-    eprint('writing Rust code')
-    # Get the rank of each byte. A lower rank => lower relative frequency.
-    rank = [0] * 256
-    for i, (byte, _) in enumerate(freqs.most_common()):
-        # print(byte)
-        rank[byte] = 255 - i
-
-    # Forcefully set the highest rank possible for bytes that start multi-byte
-    # UTF-8 sequences. The idea here is that a continuation byte will be more
-    # discerning in a homogenous haystack.
-    for byte in range(0xC0, 0xFF + 1):
-        rank[byte] = 255
-
-    # Now write Rust.
-    olines = ['pub const BYTE_FREQUENCIES: [u8; 256] = [']
-    for byte in range(256):
-        olines.append('    %3d, // %r' % (rank[byte], chr(byte)))
-    olines.append('];')
-
-    print(preamble)
-    print('\n'.join(olines))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/scripts/generate-unicode-tables b/scripts/generate-unicode-tables
deleted file mode 100755
index a670cb404f..0000000000
--- a/scripts/generate-unicode-tables
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/bin/sh
-
-# This script is responsible for generating some of the Unicode tables used
-# in regex-syntax.
-#
-# Usage is simple, first download the Unicode data:
-#
-#   $ mkdir ucd
-#   $ cd ucd
-#   $ curl -LO https://www.unicode.org/Public/zipped/14.0.0/UCD.zip
-#   $ unzip UCD.zip
-#
-# And then run this script from the root of this repository by pointing it at
-# the data directory downloaded above:
-#
-#   $ ./scripts/generate-unicode-tables path/to/ucd
-#
-# Once complete, if you are upgrading to a new version of Unicode,
-# you'll need to add a new "age" value to the 'ages' routine in
-# regex-syntax/src/unicode.rs.
-
-if [ $# != 1 ]; then
-    echo "Usage: $(basename "$0") <ucd-data-directory>" >&2
-    exit 1
-fi
-ucddir="$1"
-
-out="regex-syntax/src/unicode_tables"
-ucd-generate age "$ucddir" \
-    --chars > "$out/age.rs"
-ucd-generate case-folding-simple "$ucddir" \
-    --chars --all-pairs > "$out/case_folding_simple.rs"
-ucd-generate general-category "$ucddir" \
-    --chars --exclude surrogate > "$out/general_category.rs"
-ucd-generate grapheme-cluster-break "$ucddir" \
-    --chars > "$out/grapheme_cluster_break.rs"
-ucd-generate property-bool "$ucddir" \
-    --chars > "$out/property_bool.rs"
-ucd-generate property-names "$ucddir" \
-    > "$out/property_names.rs"
-ucd-generate property-values "$ucddir" \
-    --include gc,script,scx,age,gcb,wb,sb > "$out/property_values.rs"
-ucd-generate script "$ucddir" \
-    --chars > "$out/script.rs"
-ucd-generate script-extension "$ucddir" \
-    --chars > "$out/script_extension.rs"
-ucd-generate sentence-break "$ucddir" \
-    --chars > "$out/sentence_break.rs"
-ucd-generate word-break "$ucddir" \
-    --chars > "$out/word_break.rs"
-
-# These generate the \w, \d and \s Unicode-aware character classes. \d and \s
-# are technically part of the general category and boolean properties generated
-# above. However, these are generated separately to make it possible to enable
-# or disable them via Cargo features independently of whether all boolean
-# properties or general categories are enabled or disabled. The crate ensures
-# that only one copy is compiled.
-ucd-generate perl-word "$ucddir" \
-    --chars > "$out/perl_word.rs"
-ucd-generate general-category "$ucddir" \
-    --chars --include decimalnumber > "$out/perl_decimal.rs"
-ucd-generate property-bool "$ucddir" \
-    --chars --include whitespace > "$out/perl_space.rs"
-
-# Make sure everything is formatted.
-cargo +stable fmt --all
diff --git a/scripts/regex-match-tests.py b/scripts/regex-match-tests.py
deleted file mode 100755
index 42311285c6..0000000000
--- a/scripts/regex-match-tests.py
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/env python2
-
-from __future__ import absolute_import, division, print_function
-import argparse
-import datetime
-import os.path as path
-
-
-def print_tests(tests):
-    print('\n'.join([test_tostr(t) for t in tests]))
-
-
-def read_tests(f):
-    basename, _ = path.splitext(path.basename(f))
-    tests = []
-    for lineno, line in enumerate(open(f), 1):
-        fields = filter(None, map(str.strip, line.split('\t')))
-        if not (4 <= len(fields) <= 5) \
-           or 'E' not in fields[0] or fields[0][0] == '#':
-            continue
-
-        opts, pat, text, sgroups = fields[0:4]
-        groups = []  # groups as integer ranges
-        if sgroups == 'NOMATCH':
-            groups = [None]
-        elif ',' in sgroups:
-            noparen = map(lambda s: s.strip('()'), sgroups.split(')('))
-            for g in noparen:
-                s, e = map(str.strip, g.split(','))
-                if s == '?' and e == '?':
-                    groups.append(None)
-                else:
-                    groups.append((int(s), int(e)))
-        else:
-            # This skips tests that should result in an error.
-            # There aren't many, so I think we can just capture those
-            # manually. Possibly fix this in future.
-            continue
-
-        if pat == 'SAME':
-            pat = tests[-1][1]
-        if '$' in opts:
-            pat = pat.decode('string_escape')
-            text = text.decode('string_escape')
-        if 'i' in opts:
-            pat = '(?i)%s' % pat
-
-        name = '%s_%d' % (basename, lineno)
-        tests.append((name, pat, text, groups))
-    return tests
-
-
-def test_tostr(t):
-    lineno, pat, text, groups = t
-    options = map(group_tostr, groups)
-    return 'mat!(match_%s, r"%s", r"%s", %s);' \
-           % (lineno, pat, '' if text == "NULL" else text, ', '.join(options))
-
-
-def group_tostr(g):
-    if g is None:
-        return 'None'
-    else:
-        return 'Some((%d, %d))' % (g[0], g[1])
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='Generate match tests from an AT&T POSIX test file.')
-    aa = parser.add_argument
-    aa('files', nargs='+',
-       help='A list of dat AT&T POSIX test files. See src/testdata')
-    args = parser.parse_args()
-
-    tests = []
-    for f in args.files:
-        tests += read_tests(f)
-
-    tpl = '''
-// DO NOT EDIT. Automatically generated by 'scripts/regex-match-tests.py'
-// on {date}.
-'''.lstrip()
-    print(tpl.format(date=str(datetime.datetime.now())))
-
-    for f in args.files:
-        print('// Tests from %s' % path.basename(f))
-        print_tests(read_tests(f))
-        print('')
diff --git a/scripts/scrape_crates_io.py b/scripts/scrape_crates_io.py
deleted file mode 100755
index da21553a7e..0000000000
--- a/scripts/scrape_crates_io.py
+++ /dev/null
@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-
-from subprocess import call
-import argparse
-import datetime
-import glob
-import json
-import os
-import re
-import shutil
-import tempfile
-import time
-import urllib3
-
-CRATES_IO_INDEX_GIT_LOC = "https://github.com/rust-lang/crates.io-index.git"
-RE_REGEX = re.compile(r"Regex::new\((r?\".*?\")\)")
-KNOWN_UNMAINTAINED_CRATES = set(["queryst-prime", "oozz"])
-
-# if only requests was in the standard library...
-urllib3.disable_warnings()
-http = urllib3.PoolManager()
-
-
-def argparser():
-    p = argparse.ArgumentParser("A script to scrape crates.io for regex.")
-    p.add_argument("-c", "--crates-index", metavar="CRATES_INDEX_DIR",
-                   help=("A directory where we can find crates.io-index "
-                         + "(if this isn't set it will be automatically "
-                         + "downloaded)."))
-    p.add_argument("-o", "--output-file", metavar="OUTPUT",
-                   default="crates_regex.rs",
-                   help="The name of the output file to create.")
-    return p
-
-
-PRELUDE = """
-// DO NOT EDIT. Automatically generated by 'scripts/scrape_crates_io.py'
-// on {date}.
-
-
-
-""".lstrip()
-
-
-def main():
-    args = argparser().parse_args()
-    out = open(os.path.abspath(args.output_file), "w")
-    out.write(PRELUDE.format(date=str(datetime.datetime.now())))
-    if args.crates_index:
-        args.crates_index = os.path.abspath(args.crates_index)
-
-    # enter our scratch directory
-    old_dir = os.getcwd()
-    work_dir = tempfile.mkdtemp(prefix="scrape-crates-io")
-    os.chdir(work_dir)
-
-    crates_index = (args.crates_index
-                    if os.path.join(old_dir, args.crates_index)
-                    else download_crates_index())
-
-    for (name, vers) in iter_crates(crates_index):
-        if name in KNOWN_UNMAINTAINED_CRATES:
-            continue
-
-        with Crate(work_dir, name, vers) as c:
-            i = 0
-            for line in c.iter_lines():
-                for r in RE_REGEX.findall(line):
-                    print((name, vers, r))
-                    if len(r) >= 2 and r[-2] == "\\":
-                        continue
-                    out.write("// {}-{}: {}\n".format(name, vers, r))
-                    out.write("consistent!({}_{}, {});\n\n".format(
-                                name.replace("-", "_"), i, r))
-                    out.flush()
-                    i += 1
-
-    # Leave the scratch directory
-    os.chdir(old_dir)
-    shutil.rmtree(work_dir)
-    out.close()
-
-
-def download_crates_index():
-    if call(["git", "clone", CRATES_IO_INDEX_GIT_LOC]) != 0:
-        print("Error cloning the crates.io index")
-        exit(1)
-    return "crates.io-index"
-
-
-def iter_crates(crates_index):
-    exclude = set(["config.json", ".git"])
-    for crate_index_file in iter_files(crates_index, exclude=exclude):
-        with open(crate_index_file) as f:
-            most_recent = list(f)
-            most_recent = most_recent[len(most_recent) - 1]
-
-            crate_info = json.loads(most_recent)
-            if "regex" not in set(d["name"] for d in crate_info["deps"]):
-                continue
-
-            if crate_info["yanked"]:
-                continue
-            yield (crate_info["name"], crate_info["vers"])
-
-
-def iter_files(d, exclude=set()):
-    for x in os.listdir(d):
-        if x in exclude:
-            continue
-
-        fullfp = os.path.abspath(d + "/" + x)
-        if os.path.isfile(fullfp):
-            yield fullfp
-        elif os.path.isdir(fullfp):
-            for f in iter_files(fullfp, exclude):
-                yield f
-
-
-class Crate(object):
-    def __init__(self, work_dir, name, version):
-        self.name = name
-        self.version = version
-        self.url = ("https://crates.io/api/v1/crates/{name}/{version}/download"
-                    .format(name=self.name, version=self.version))
-        self.filename = "{}/{}-{}.tar.gz".format(
-                            work_dir, self.name, self.version)
-
-    def __enter__(self):
-        max_retries = 1
-        retries = 0
-        while retries < max_retries:
-            retries += 1
-
-            r = http.request("GET", self.url, preload_content=False)
-            try:
-                print("[{}/{}] Downloading {}".format(
-                        retries, max_retries + 1, self.url))
-                with open(self.filename, "wb") as f:
-                    while True:
-                        data = r.read(1024)
-                        if not data:
-                            break
-                        f.write(data)
-            except Exception:
-                time.sleep(1)
-                r.release_conn()
-                continue
-
-            r.release_conn()
-            break
-
-        call(["tar", "-xf", self.filename])
-
-        return self
-
-    def __exit__(self, ty, value, tb):
-        # We are going to clean up the whole temp dir anyway, so
-        # we don't really need to do this. Its nice to clean up
-        # after ourselves though.
-        try:
-            shutil.rmtree(self.filename[:-len(".tar.gz")])
-            os.remove(self.filename)
-        except Exception:
-            pass
-
-    def iter_srcs(self):
-        g = "{crate}/**/*.rs".format(crate=self.filename[:-len(".tar.gz")])
-        for rsrc in glob.iglob(g):
-            yield rsrc
-
-    def iter_lines(self):
-        for src in self.iter_srcs():
-            with open(src) as f:
-                for line in f:
-                    yield line
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/backtrack.rs b/src/backtrack.rs
deleted file mode 100644
index 4d83856ca0..0000000000
--- a/src/backtrack.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-// This is the backtracking matching engine. It has the same exact capability
-// as the full NFA simulation, except it is artificially restricted to small
-// regexes on small inputs because of its memory requirements.
-//
-// In particular, this is a *bounded* backtracking engine. It retains worst
-// case linear time by keeping track of the states that it has visited (using a
-// bitmap). Namely, once a state is visited, it is never visited again. Since a
-// state is keyed by `(instruction index, input index)`, we have that its time
-// complexity is `O(mn)` (i.e., linear in the size of the search text).
-//
-// The backtracking engine can beat out the NFA simulation on small
-// regexes/inputs because it doesn't have to keep track of multiple copies of
-// the capture groups. In benchmarks, the backtracking engine is roughly twice
-// as fast as the full NFA simulation. Note though that its performance doesn't
-// scale, even if you're willing to live with the memory requirements. Namely,
-// the bitset has to be zeroed on each execution, which becomes quite expensive
-// on large bitsets.
-
-use crate::exec::ProgramCache;
-use crate::input::{Input, InputAt};
-use crate::prog::{InstPtr, Program};
-use crate::re_trait::Slot;
-
-type Bits = u32;
-
-const BIT_SIZE: usize = 32;
-const MAX_SIZE_BYTES: usize = 256 * (1 << 10); // 256 KB
-
-/// Returns true iff the given regex and input should be executed by this
-/// engine with reasonable memory usage.
-pub fn should_exec(num_insts: usize, text_len: usize) -> bool {
-    // Total memory usage in bytes is determined by:
-    //
-    //   ((len(insts) * (len(input) + 1) + bits - 1) / bits) * (size_of(u32))
-    //
-    // The actual limit picked is pretty much a heuristic.
-    // See: https://github.com/rust-lang/regex/issues/215
-    let size = ((num_insts * (text_len + 1) + BIT_SIZE - 1) / BIT_SIZE) * 4;
-    size <= MAX_SIZE_BYTES
-}
-
-/// A backtracking matching engine.
-#[derive(Debug)]
-pub struct Bounded<'a, 'm, 'r, 's, I> {
-    prog: &'r Program,
-    input: I,
-    matches: &'m mut [bool],
-    slots: &'s mut [Slot],
-    m: &'a mut Cache,
-}
-
-/// Shared cached state between multiple invocations of a backtracking engine
-/// in the same thread.
-#[derive(Clone, Debug)]
-pub struct Cache {
-    jobs: Vec<Job>,
-    visited: Vec<Bits>,
-}
-
-impl Cache {
-    /// Create new empty cache for the backtracking engine.
-    pub fn new(_prog: &Program) -> Self {
-        Cache { jobs: vec![], visited: vec![] }
-    }
-}
-
-/// A job is an explicit unit of stack space in the backtracking engine.
-///
-/// The "normal" representation is a single state transition, which corresponds
-/// to an NFA state and a character in the input. However, the backtracking
-/// engine must keep track of old capture group values. We use the explicit
-/// stack to do it.
-#[derive(Clone, Copy, Debug)]
-enum Job {
-    Inst { ip: InstPtr, at: InputAt },
-    SaveRestore { slot: usize, old_pos: Option<usize> },
-}
-
-impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
-    /// Execute the backtracking matching engine.
-    ///
-    /// If there's a match, `exec` returns `true` and populates the given
-    /// captures accordingly.
-    pub fn exec(
-        prog: &'r Program,
-        cache: &ProgramCache,
-        matches: &'m mut [bool],
-        slots: &'s mut [Slot],
-        input: I,
-        start: usize,
-        end: usize,
-    ) -> bool {
-        let mut cache = cache.borrow_mut();
-        let cache = &mut cache.backtrack;
-        let start = input.at(start);
-        let mut b = Bounded { prog, input, matches, slots, m: cache };
-        b.exec_(start, end)
-    }
-
-    /// Clears the cache such that the backtracking engine can be executed
-    /// on some input of fixed length.
-    fn clear(&mut self) {
-        // Reset the job memory so that we start fresh.
-        self.m.jobs.clear();
-
-        // Now we need to clear the bit state set.
-        // We do this by figuring out how much space we need to keep track
-        // of the states we've visited.
-        // Then we reset all existing allocated space to 0.
-        // Finally, we request more space if we need it.
-        //
-        // This is all a little circuitous, but doing this using unchecked
-        // operations doesn't seem to have a measurable impact on performance.
-        // (Probably because backtracking is limited to such small
-        // inputs/regexes in the first place.)
-        let visited_len =
-            (self.prog.len() * (self.input.len() + 1) + BIT_SIZE - 1)
-                / BIT_SIZE;
-        self.m.visited.truncate(visited_len);
-        for v in &mut self.m.visited {
-            *v = 0;
-        }
-        if visited_len > self.m.visited.len() {
-            let len = self.m.visited.len();
-            self.m.visited.reserve_exact(visited_len - len);
-            for _ in 0..(visited_len - len) {
-                self.m.visited.push(0);
-            }
-        }
-    }
-
-    /// Start backtracking at the given position in the input, but also look
-    /// for literal prefixes.
-    fn exec_(&mut self, mut at: InputAt, end: usize) -> bool {
-        self.clear();
-        // If this is an anchored regex at the beginning of the input, then
-        // we're either already done or we only need to try backtracking once.
-        if self.prog.is_anchored_start {
-            return if !at.is_start() { false } else { self.backtrack(at) };
-        }
-        let mut matched = false;
-        loop {
-            if !self.prog.prefixes.is_empty() {
-                at = match self.input.prefix_at(&self.prog.prefixes, at) {
-                    None => break,
-                    Some(at) => at,
-                };
-            }
-            matched = self.backtrack(at) || matched;
-            if matched && self.prog.matches.len() == 1 {
-                return true;
-            }
-            if at.pos() >= end {
-                break;
-            }
-            at = self.input.at(at.next_pos());
-        }
-        matched
-    }
-
-    /// The main backtracking loop starting at the given input position.
-    fn backtrack(&mut self, start: InputAt) -> bool {
-        // N.B. We use an explicit stack to avoid recursion.
-        // To avoid excessive pushing and popping, most transitions are handled
-        // in the `step` helper function, which only pushes to the stack when
-        // there's a capture or a branch.
-        let mut matched = false;
-        self.m.jobs.push(Job::Inst { ip: 0, at: start });
-        while let Some(job) = self.m.jobs.pop() {
-            match job {
-                Job::Inst { ip, at } => {
-                    if self.step(ip, at) {
-                        // Only quit if we're matching one regex.
-                        // If we're matching a regex set, then mush on and
-                        // try to find other matches (if we want them).
-                        if self.prog.matches.len() == 1 {
-                            return true;
-                        }
-                        matched = true;
-                    }
-                }
-                Job::SaveRestore { slot, old_pos } => {
-                    if slot < self.slots.len() {
-                        self.slots[slot] = old_pos;
-                    }
-                }
-            }
-        }
-        matched
-    }
-
-    fn step(&mut self, mut ip: InstPtr, mut at: InputAt) -> bool {
-        use crate::prog::Inst::*;
-        loop {
-            // This loop is an optimization to avoid constantly pushing/popping
-            // from the stack. Namely, if we're pushing a job only to run it
-            // next, avoid the push and just mutate `ip` (and possibly `at`)
-            // in place.
-            if self.has_visited(ip, at) {
-                return false;
-            }
-            match self.prog[ip] {
-                Match(slot) => {
-                    if slot < self.matches.len() {
-                        self.matches[slot] = true;
-                    }
-                    return true;
-                }
-                Save(ref inst) => {
-                    if let Some(&old_pos) = self.slots.get(inst.slot) {
-                        // If this path doesn't work out, then we save the old
-                        // capture index (if one exists) in an alternate
-                        // job. If the next path fails, then the alternate
-                        // job is popped and the old capture index is restored.
-                        self.m.jobs.push(Job::SaveRestore {
-                            slot: inst.slot,
-                            old_pos,
-                        });
-                        self.slots[inst.slot] = Some(at.pos());
-                    }
-                    ip = inst.goto;
-                }
-                Split(ref inst) => {
-                    self.m.jobs.push(Job::Inst { ip: inst.goto2, at });
-                    ip = inst.goto1;
-                }
-                EmptyLook(ref inst) => {
-                    if self.input.is_empty_match(at, inst) {
-                        ip = inst.goto;
-                    } else {
-                        return false;
-                    }
-                }
-                Char(ref inst) => {
-                    if inst.c == at.char() {
-                        ip = inst.goto;
-                        at = self.input.at(at.next_pos());
-                    } else {
-                        return false;
-                    }
-                }
-                Ranges(ref inst) => {
-                    if inst.matches(at.char()) {
-                        ip = inst.goto;
-                        at = self.input.at(at.next_pos());
-                    } else {
-                        return false;
-                    }
-                }
-                Bytes(ref inst) => {
-                    if let Some(b) = at.byte() {
-                        if inst.matches(b) {
-                            ip = inst.goto;
-                            at = self.input.at(at.next_pos());
-                            continue;
-                        }
-                    }
-                    return false;
-                }
-            }
-        }
-    }
-
-    fn has_visited(&mut self, ip: InstPtr, at: InputAt) -> bool {
-        let k = ip * (self.input.len() + 1) + at.pos();
-        let k1 = k / BIT_SIZE;
-        let k2 = usize_to_u32(1 << (k & (BIT_SIZE - 1)));
-        if self.m.visited[k1] & k2 == 0 {
-            self.m.visited[k1] |= k2;
-            false
-        } else {
-            true
-        }
-    }
-}
-
-fn usize_to_u32(n: usize) -> u32 {
-    if (n as u64) > (::std::u32::MAX as u64) {
-        panic!("BUG: {} is too big to fit into u32", n)
-    }
-    n as u32
-}
diff --git a/src/builders.rs b/src/builders.rs
new file mode 100644
index 0000000000..285331a825
--- /dev/null
+++ b/src/builders.rs
@@ -0,0 +1,2525 @@
+#![allow(warnings)]
+
+// This module defines an internal builder that encapsulates all interaction
+// with meta::Regex construction, and then 4 public API builders that wrap
+// around it. The docs are essentially repeated on each of the 4 public
+// builders, with tweaks to the examples as needed.
+//
+// The reason why there are so many builders is partially because of a misstep
+// in the initial API design: the builder constructor takes in the pattern
+// strings instead of using the `build` method to accept the pattern strings.
+// This means `new` has a different signature for each builder. It probably
+// would have been nicer to to use one builder with `fn new()`, and then add
+// `build(pat)` and `build_many(pats)` constructors.
+//
+// The other reason is because I think the `bytes` module should probably
+// have its own builder type. That way, it is completely isolated from the
+// top-level API.
+//
+// If I could do it again, I'd probably have a `regex::Builder` and a
+// `regex::bytes::Builder`. Each would have `build` and `build_set` (or
+// `build_many`) methods for constructing a single pattern `Regex` and a
+// multi-pattern `RegexSet`, respectively.
+
+use alloc::{
+    string::{String, ToString},
+    sync::Arc,
+    vec,
+    vec::Vec,
+};
+
+use regex_automata::{meta, util::syntax, MatchKind};
+
+use crate::error::Error;
+
+/// A builder for constructing a `Regex`, `bytes::Regex`, `RegexSet` or a
+/// `bytes::RegexSet`.
+///
+/// This is essentially the implementation of the four different builder types
+/// in the public API: `RegexBuilder`, `bytes::RegexBuilder`, `RegexSetBuilder`
+/// and `bytes::RegexSetBuilder`.
+#[derive(Clone, Debug)]
+struct Builder {
+    pats: Vec<String>,
+    metac: meta::Config,
+    syntaxc: syntax::Config,
+}
+
+impl Default for Builder {
+    fn default() -> Builder {
+        let metac = meta::Config::new()
+            .nfa_size_limit(Some(10 * (1 << 20)))
+            .hybrid_cache_capacity(2 * (1 << 20));
+        Builder { pats: vec![], metac, syntaxc: syntax::Config::default() }
+    }
+}
+
+impl Builder {
+    fn new<I, S>(patterns: I) -> Builder
+    where
+        S: AsRef<str>,
+        I: IntoIterator<Item = S>,
+    {
+        let mut b = Builder::default();
+        b.pats.extend(patterns.into_iter().map(|p| p.as_ref().to_string()));
+        b
+    }
+
+    fn build_one_string(&self) -> Result<crate::Regex, Error> {
+        assert_eq!(1, self.pats.len());
+        let metac = self
+            .metac
+            .clone()
+            .match_kind(MatchKind::LeftmostFirst)
+            .utf8_empty(true);
+        let syntaxc = self.syntaxc.clone().utf8(true);
+        let pattern = Arc::from(self.pats[0].as_str());
+        meta::Builder::new()
+            .configure(metac)
+            .syntax(syntaxc)
+            .build(&pattern)
+            .map(|meta| crate::Regex { meta, pattern })
+            .map_err(Error::from_meta_build_error)
+    }
+
+    fn build_one_bytes(&self) -> Result<crate::bytes::Regex, Error> {
+        assert_eq!(1, self.pats.len());
+        let metac = self
+            .metac
+            .clone()
+            .match_kind(MatchKind::LeftmostFirst)
+            .utf8_empty(false);
+        let syntaxc = self.syntaxc.clone().utf8(false);
+        let pattern = Arc::from(self.pats[0].as_str());
+        meta::Builder::new()
+            .configure(metac)
+            .syntax(syntaxc)
+            .build(&pattern)
+            .map(|meta| crate::bytes::Regex { meta, pattern })
+            .map_err(Error::from_meta_build_error)
+    }
+
+    fn build_many_string(&self) -> Result<crate::RegexSet, Error> {
+        let metac =
+            self.metac.clone().match_kind(MatchKind::All).utf8_empty(true);
+        let syntaxc = self.syntaxc.clone().utf8(true);
+        let patterns = Arc::from(self.pats.as_slice());
+        meta::Builder::new()
+            .configure(metac)
+            .syntax(syntaxc)
+            .build_many(&patterns)
+            .map(|meta| crate::RegexSet { meta, patterns })
+            .map_err(Error::from_meta_build_error)
+    }
+
+    fn build_many_bytes(&self) -> Result<crate::bytes::RegexSet, Error> {
+        let metac =
+            self.metac.clone().match_kind(MatchKind::All).utf8_empty(false);
+        let syntaxc = self.syntaxc.clone().utf8(false);
+        let patterns = Arc::from(self.pats.as_slice());
+        meta::Builder::new()
+            .configure(metac)
+            .syntax(syntaxc)
+            .build_many(&patterns)
+            .map(|meta| crate::bytes::RegexSet { meta, patterns })
+            .map_err(Error::from_meta_build_error)
+    }
+
+    fn case_insensitive(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.case_insensitive(yes);
+        self
+    }
+
+    fn multi_line(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.multi_line(yes);
+        self
+    }
+
+    fn dot_matches_new_line(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.dot_matches_new_line(yes);
+        self
+    }
+
+    fn crlf(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.crlf(yes);
+        self
+    }
+
+    fn line_terminator(&mut self, byte: u8) -> &mut Builder {
+        self.metac = self.metac.clone().line_terminator(byte);
+        self.syntaxc = self.syntaxc.line_terminator(byte);
+        self
+    }
+
+    fn swap_greed(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.swap_greed(yes);
+        self
+    }
+
+    fn ignore_whitespace(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.ignore_whitespace(yes);
+        self
+    }
+
+    fn unicode(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.unicode(yes);
+        self
+    }
+
+    fn octal(&mut self, yes: bool) -> &mut Builder {
+        self.syntaxc = self.syntaxc.octal(yes);
+        self
+    }
+
+    fn size_limit(&mut self, limit: usize) -> &mut Builder {
+        self.metac = self.metac.clone().nfa_size_limit(Some(limit));
+        self
+    }
+
+    fn dfa_size_limit(&mut self, limit: usize) -> &mut Builder {
+        self.metac = self.metac.clone().hybrid_cache_capacity(limit);
+        self
+    }
+
+    fn nest_limit(&mut self, limit: u32) -> &mut Builder {
+        self.syntaxc = self.syntaxc.nest_limit(limit);
+        self
+    }
+}
+
+pub(crate) mod string {
+    use crate::{error::Error, Regex, RegexSet};
+
+    use super::Builder;
+
+    /// A configurable builder for a [`Regex`].
+    ///
+    /// This builder can be used to programmatically set flags such as `i`
+    /// (case insensitive) and `x` (for verbose mode). This builder can also be
+    /// used to configure things like the line terminator and a size limit on
+    /// the compiled regular expression.
+    #[derive(Clone, Debug)]
+    pub struct RegexBuilder {
+        builder: Builder,
+    }
+
+    impl RegexBuilder {
+        /// Create a new builder with a default configuration for the given
+        /// pattern.
+        ///
+        /// If the pattern is invalid or exceeds the configured size limits,
+        /// then an error will be returned when [`RegexBuilder::build`] is
+        /// called.
+        pub fn new(pattern: &str) -> RegexBuilder {
+            RegexBuilder { builder: Builder::new([pattern]) }
+        }
+
+        /// Compiles the pattern given to `RegexBuilder::new` with the
+        /// configuration set on this builder.
+        ///
+        /// If the pattern isn't a valid regex or if a configured size limit
+        /// was exceeded, then an error is returned.
+        pub fn build(&self) -> Result<Regex, Error> {
+            self.builder.build_one_string()
+        }
+
+        /// This configures Unicode mode for the entire pattern.
+        ///
+        /// Enabling Unicode mode does a number of things:
+        ///
+        /// * Most fundamentally, it causes the fundamental atom of matching
+        /// to be a single codepoint. When Unicode mode is disabled, it's a
+        /// single byte. For example, when Unicode mode is enabled, `.` will
+        /// match `💩` once, where as it will match 4 times when Unicode mode
+        /// is disabled. (Since the UTF-8 encoding of `💩` is 4 bytes long.)
+        /// * Case insensitive matching uses Unicode simple case folding rules.
+        /// * Unicode character classes like `\p{Letter}` and `\p{Greek}` are
+        /// available.
+        /// * Perl character classes are Unicode aware. That is, `\w`, `\s` and
+        /// `\d`.
+        /// * The word boundary assertions, `\b` and `\B`, use the Unicode
+        /// definition of a word character.
+        ///
+        /// Note that if Unicode mode is disabled, then the regex will fail to
+        /// compile if it could match invalid UTF-8. For example, when Unicode
+        /// mode is disabled, then since `.` matches any byte (except for
+        /// `\n`), then it can match invalid UTF-8 and thus building a regex
+        /// from it will fail. Another example is `\w` and `\W`. Since `\w` can
+        /// only match ASCII bytes when Unicode mode is disabled, it's allowed.
+        /// But `\W` can match more than ASCII bytes, including invalid UTF-8,
+        /// and so it is not allowed. This restriction can be lifted only by
+        /// using a [`bytes::Regex`](crate::bytes::Regex).
+        ///
+        /// For more details on the Unicode support in this crate, see the
+        /// [Unicode section](crate#unicode) in this crate's top-level
+        /// documentation.
+        ///
+        /// The default for this is `true`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"\w")
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(!re.is_match("δ"));
+        ///
+        /// let re = RegexBuilder::new(r"s")
+        ///     .case_insensitive(true)
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally 'ſ' is included when searching for 's' case
+        /// // insensitively due to Unicode's simple case folding rules. But
+        /// // when Unicode mode is disabled, only ASCII case insensitive rules
+        /// // are used.
+        /// assert!(!re.is_match("ſ"));
+        /// ```
+        pub fn unicode(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.unicode(yes);
+            self
+        }
+
+        /// This configures whether to enable case insensitive matching for the
+        /// entire pattern.
+        ///
+        /// This setting can also be configured using the inline flag `i`
+        /// in the pattern. For example, `(?i:foo)` matches `foo` case
+        /// insensitively while `(?-i:foo)` matches `foo` case sensitively.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"foo(?-i:bar)quux")
+        ///     .case_insensitive(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("FoObarQuUx"));
+        /// // Even though case insensitive matching is enabled in the builder,
+        /// // it can be locally disabled within the pattern. In this case,
+        /// // `bar` is matched case sensitively.
+        /// assert!(!re.is_match("fooBARquux"));
+        /// ```
+        pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.case_insensitive(yes);
+            self
+        }
+
+        /// This configures multi-line mode for the entire pattern.
+        ///
+        /// Enabling multi-line mode changes the behavior of the `^` and `$`
+        /// anchor assertions. Instead of only matching at the beginning and
+        /// end of a haystack, respectively, multi-line mode causes them to
+        /// match at the beginning and end of a line *in addition* to the
+        /// beginning and end of a haystack. More precisely, `^` will match at
+        /// the position immediately following a `\n` and `$` will match at the
+        /// position immediately preceding a `\n`.
+        ///
+        /// The behavior of this option can be impacted by other settings too:
+        ///
+        /// * The [`RegexBuilder::line_terminator`] option changes `\n` above
+        /// to any ASCII byte.
+        /// * The [`RegexBuilder::crlf`] option changes the line terminator to
+        /// be either `\r` or `\n`, but never at the position between a `\r`
+        /// and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `m` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert_eq!(Some(1..4), re.find("\nfoo\n").map(|m| m.range()));
+        /// ```
+        pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.multi_line(yes);
+            self
+        }
+
+        /// This configures dot-matches-new-line mode for the entire pattern.
+        ///
+        /// Perhaps surprisingly, the default behavior for `.` is not to match
+        /// any character, but rather, to match any character except for the
+        /// line terminator (which is `\n` by default). When this mode is
+        /// enabled, the behavior changes such that `.` truly matches any
+        /// character.
+        ///
+        /// This setting can also be configured using the inline flag `s` in
+        /// the pattern. For example, `(?s:.)` and `\p{any}` are equivalent
+        /// regexes.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"foo.bar")
+        ///     .dot_matches_new_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "foo\nbar";
+        /// assert_eq!(Some("foo\nbar"), re.find(hay).map(|m| m.as_str()));
+        /// ```
+        pub fn dot_matches_new_line(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexBuilder {
+            self.builder.dot_matches_new_line(yes);
+            self
+        }
+
+        /// This configures CRLF mode for the entire pattern.
+        ///
+        /// When CRLF mode is enabled, both `\r` ("carriage return" or CR for
+        /// short) and `\n` ("line feed" or LF for short) are treated as line
+        /// terminators. This results in the following:
+        ///
+        /// * Unless dot-matches-new-line mode is enabled, `.` will now match
+        /// any character except for `\n` and `\r`.
+        /// * When multi-line mode is enabled, `^` will match immediatelly
+        /// following a `\n` or a `\r`. Similarly, `$` will match immediately
+        /// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match
+        /// between `\r` and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `R` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "\r\nfoo\r\n";
+        /// // If CRLF mode weren't enabled here, then '$' wouldn't match
+        /// // immediately after 'foo', and thus no match would be found.
+        /// assert_eq!(Some("foo"), re.find(hay).map(|m| m.as_str()));
+        /// ```
+        ///
+        /// This example demonstrates that `^` will never match at a position
+        /// between `\r` and `\n`. (`$` will similarly not match between a `\r`
+        /// and a `\n`.)
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^")
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "\r\n\r\n";
+        /// let ranges: Vec<_> = re.find_iter(hay).map(|m| m.range()).collect();
+        /// assert_eq!(ranges, vec![0..0, 2..2, 4..4]);
+        /// ```
+        pub fn crlf(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.crlf(yes);
+            self
+        }
+
+        /// Configures the line terminator to be used by the regex.
+        ///
+        /// The line terminator is relevant in two ways for a particular regex:
+        ///
+        /// * When dot-matches-new-line mode is *not* enabled (the default),
+        /// then `.` will match any character except for the configured line
+        /// terminator.
+        /// * When multi-line mode is enabled (not the default), then `^` and
+        /// `$` will match immediately after and before, respectively, a line
+        /// terminator.
+        ///
+        /// In both cases, if CRLF mode is enabled in a particular context,
+        /// then it takes precedence over any configured line terminator.
+        ///
+        /// This option cannot be configured from within the pattern.
+        ///
+        /// The default line terminator is `\n`.
+        ///
+        /// # Example
+        ///
+        /// This shows how to treat the NUL byte as a line terminator. This can
+        /// be a useful heuristic when searching binary data.
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "\x00foo\x00";
+        /// assert_eq!(Some(1..4), re.find(hay).map(|m| m.range()));
+        /// ```
+        ///
+        /// This example shows that the behavior of `.` is impacted by this
+        /// setting as well:
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r".")
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("\n"));
+        /// assert!(!re.is_match("\x00"));
+        /// ```
+        ///
+        /// This shows that building a regex will fail if the byte given
+        /// is not ASCII and the pattern could result in matching invalid
+        /// UTF-8. This is because any singular non-ASCII byte is not valid
+        /// UTF-8, and it is not permitted for a [`Regex`] to match invalid
+        /// UTF-8. (It is permissible to use a non-ASCII byte when building a
+        /// [`bytes::Regex`](crate::bytes::Regex).)
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// assert!(RegexBuilder::new(r".").line_terminator(0x80).build().is_err());
+        /// // Note that using a non-ASCII byte isn't enough on its own to
+        /// // cause regex compilation to fail. You actually have to make use
+        /// // of it in the regex in a way that leads to matching invalid
+        /// // UTF-8. If you don't, then regex compilation will succeed!
+        /// assert!(RegexBuilder::new(r"a").line_terminator(0x80).build().is_ok());
+        /// ```
+        pub fn line_terminator(&mut self, byte: u8) -> &mut RegexBuilder {
+            self.builder.line_terminator(byte);
+            self
+        }
+
+        /// This configures swap-greed mode for the entire pattern.
+        ///
+        /// When swap-greed mode is enabled, patterns like `a+` will become
+        /// non-greedy and patterns like `a+?` will become greedy. In other
+        /// words, the meanings of `a+` and `a+?` are switched.
+        ///
+        /// This setting can also be configured using the inline flag `U` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"a+")
+        ///     .swap_greed(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert_eq!(Some("a"), re.find("aaa").map(|m| m.as_str()));
+        /// ```
+        pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.swap_greed(yes);
+            self
+        }
+
+        /// This configures verbose mode for the entire pattern.
+        ///
+        /// When enabled, whitespace will treated as insignifcant in the
+        /// pattern and `#` can be used to start a comment until the next new
+        /// line.
+        ///
+        /// Normally, in most places in a pattern, whitespace is treated
+        /// literally. For example ` +` will match one or more ASCII whitespace
+        /// characters.
+        ///
+        /// When verbose mode is enabled, `\#` can be used to match a literal
+        /// `#` and `\ ` can be used to match a literal ASCII whitespace
+        /// character.
+        ///
+        /// Verbose mode is useful for permitting regexes to be formatted and
+        /// broken up more nicely. This may make them more easily readable.
+        ///
+        /// This setting can also be configured using the inline flag `x` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// let pat = r"
+        ///     \b
+        ///     (?<first>\p{Uppercase}\w*)  # always start with uppercase letter
+        ///     [\s--\n]+                   # whitespace should separate names
+        ///     (?: # middle name can be an initial!
+        ///         (?:(?<initial>\p{Uppercase})\.|(?<middle>\p{Uppercase}\w*))
+        ///         [\s--\n]+
+        ///     )?
+        ///     (?<last>\p{Uppercase}\w*)
+        ///     \b
+        /// ";
+        /// let re = RegexBuilder::new(pat)
+        ///     .ignore_whitespace(true)
+        ///     .build()
+        ///     .unwrap();
+        ///
+        /// let caps = re.captures("Harry Potter").unwrap();
+        /// assert_eq!("Harry", &caps["first"]);
+        /// assert_eq!("Potter", &caps["last"]);
+        ///
+        /// let caps = re.captures("Harry J. Potter").unwrap();
+        /// assert_eq!("Harry", &caps["first"]);
+        /// // Since a middle name/initial isn't required for an overall match,
+        /// // we can't assume that 'initial' or 'middle' will be populated!
+        /// assert_eq!(Some("J"), caps.name("initial").map(|m| m.as_str()));
+        /// assert_eq!(None, caps.name("middle").map(|m| m.as_str()));
+        /// assert_eq!("Potter", &caps["last"]);
+        ///
+        /// let caps = re.captures("Harry James Potter").unwrap();
+        /// assert_eq!("Harry", &caps["first"]);
+        /// // Since a middle name/initial isn't required for an overall match,
+        /// // we can't assume that 'initial' or 'middle' will be populated!
+        /// assert_eq!(None, caps.name("initial").map(|m| m.as_str()));
+        /// assert_eq!(Some("James"), caps.name("middle").map(|m| m.as_str()));
+        /// assert_eq!("Potter", &caps["last"]);
+        /// ```
+        pub fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.ignore_whitespace(yes);
+            self
+        }
+
+        /// This configures octal mode for the entire pattern.
+        ///
+        /// Octal syntax is a little-known way of uttering Unicode codepoints
+        /// in a pattern. For example, `a`, `\x61`, `\u0061` and `\141` are all
+        /// equivalent patterns, where the last example shows octal syntax.
+        ///
+        /// While supporting octal syntax isn't in and of itself a problem,
+        /// it does make good error messages harder. That is, in PCRE based
+        /// regex engines, syntax like `\1` invokes a backreference, which is
+        /// explicitly unsupported this library. However, many users expect
+        /// backreferences to be supported. Therefore, when octal support
+        /// is disabled, the error message will explicitly mention that
+        /// backreferences aren't supported.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// // Normally this pattern would not compile, with an error message
+        /// // about backreferences not being supported. But with octal mode
+        /// // enabled, octal escape sequences work.
+        /// let re = RegexBuilder::new(r"\141")
+        ///     .octal(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("a"));
+        /// ```
+        pub fn octal(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.octal(yes);
+            self
+        }
+
+        /// Sets the approximate size limit, in bytes, of the compiled regex.
+        ///
+        /// This roughly corresponds to the number of heap memory, in
+        /// bytes, occupied by a single regex. If the regex would otherwise
+        /// approximately exceed this limit, then compiling that regex will
+        /// fail.
+        ///
+        /// The main utility of a method like this is to avoid compiling
+        /// regexes that use an unexpected amount of resources, such as
+        /// time and memory. Even if the memory usage of a large regex is
+        /// acceptable, its search time may not be. Namely, worst case time
+        /// complexity for search is `O(m * n)`, where `m ~ len(pattern)` and
+        /// `n ~ len(haystack)`. That is, search time depends, in part, on the
+        /// size of the compiled regex. This means that putting a limit on the
+        /// size of the regex limits how much a regex can impact search time.
+        ///
+        /// For more information about regex size limits, see the section on
+        /// [untrusted inputs](crate#untrusted-input) in the top-level crate
+        /// documentation.
+        ///
+        /// The default for this is some reasonable number that permits most
+        /// patterns to compile successfully.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// // It may surprise you how big some seemingly small patterns can
+        /// // be! Since \w is Unicode aware, this generates a regex that can
+        /// // match approximately 140,000 distinct codepoints.
+        /// assert!(RegexBuilder::new(r"\w").size_limit(45_000).build().is_err());
+        /// ```
+        pub fn size_limit(&mut self, bytes: usize) -> &mut RegexBuilder {
+            self.builder.size_limit(bytes);
+            self
+        }
+
+        /// Set the approximate capacity, in bytes, of the cache of transitions
+        /// used by the lazy DFA.
+        ///
+        /// While the lazy DFA isn't always used, in tends to be the most
+        /// commonly use regex engine in default configurations. It tends to
+        /// adopt the performance profile of a fully build DFA, but without the
+        /// downside of taking worst case exponential time to build.
+        ///
+        /// The downside is that it needs to keep a cache of transitions and
+        /// states that are built while running a search, and this cache
+        /// can fill up. When it fills up, the cache will reset itself. Any
+        /// previously generated states and transitions will then need to be
+        /// re-generated. If this happens too many times, then this library
+        /// will bail out of using the lazy DFA and switch to a different regex
+        /// engine.
+        ///
+        /// If your regex provokes this particular downside of the lazy DFA,
+        /// then it may be beneficial to increase its cache capacity. This will
+        /// potentially reduce the frequency of cache resetting (ideally to
+        /// `0`). While it won't fix all potential performance problems with
+        /// the lazy DFA, increasing the cache capacity does fix some.
+        ///
+        /// There is no easy way to determine, a priori, whether increasing
+        /// this cache capacity will help. In general, the larger your regex,
+        /// the more cache it's likely to use. But that isn't an ironclad rule.
+        /// For example, a regex like `[01]*1[01]{N}` would normally produce a
+        /// fully build DFA that is exponential in size with respect to `N`.
+        /// The lazy DFA will prevent exponential space blow-up, but it cache
+        /// is likely to fill up, even when it's large and even for smallish
+        /// values of `N`.
+        ///
+        /// If you aren't sure whether this helps or not, it is sensible to
+        /// set this to some arbitrarily large number in testing, such as
+        /// `usize::MAX`. Namely, this represents the amount of capacity that
+        /// *may* be used. It's probably not a good idea to use `usize::MAX` in
+        /// production though, since it implies there are no controls on heap
+        /// memory used by this library during a search. In effect, set it to
+        /// whatever you're willing to allocate for a single regex search.
+        pub fn dfa_size_limit(&mut self, bytes: usize) -> &mut RegexBuilder {
+            self.builder.dfa_size_limit(bytes);
+            self
+        }
+
+        /// Set the nesting limit for this parser.
+        ///
+        /// The nesting limit controls how deep the abstract syntax tree is
+        /// allowed to be. If the AST exceeds the given limit (e.g., with too
+        /// many nested groups), then an error is returned by the parser.
+        ///
+        /// The purpose of this limit is to act as a heuristic to prevent stack
+        /// overflow for consumers that do structural induction on an AST using
+        /// explicit recursion. While this crate never does this (instead using
+        /// constant stack space and moving the call stack to the heap), other
+        /// crates may.
+        ///
+        /// This limit is not checked until the entire AST is parsed.
+        /// Therefore, if callers want to put a limit on the amount of heap
+        /// space used, then they should impose a limit on the length, in
+        /// bytes, of the concrete pattern string. In particular, this is
+        /// viable since this parser implementation will limit itself to heap
+        /// space proportional to the length of the pattern string. See also
+        /// the [untrusted inputs](crate#untrusted-input) section in the
+        /// top-level crate documentation for more information about this.
+        ///
+        /// Note that a nest limit of `0` will return a nest limit error for
+        /// most patterns but not all. For example, a nest limit of `0` permits
+        /// `a` but not `ab`, since `ab` requires an explicit concatenation,
+        /// which results in a nest depth of `1`. In general, a nest limit is
+        /// not something that manifests in an obvious way in the concrete
+        /// syntax, therefore, it should not be used in a granular way.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexBuilder;
+        ///
+        /// assert!(RegexBuilder::new(r"a").nest_limit(0).build().is_ok());
+        /// assert!(RegexBuilder::new(r"ab").nest_limit(0).build().is_err());
+        /// ```
+        pub fn nest_limit(&mut self, limit: u32) -> &mut RegexBuilder {
+            self.builder.nest_limit(limit);
+            self
+        }
+    }
+
+    /// A configurable builder for a [`RegexSet`].
+    ///
+    /// This builder can be used to programmatically set flags such as
+    /// `i` (case insensitive) and `x` (for verbose mode). This builder
+    /// can also be used to configure things like the line terminator
+    /// and a size limit on the compiled regular expression.
+    #[derive(Clone, Debug)]
+    pub struct RegexSetBuilder {
+        builder: Builder,
+    }
+
+    impl RegexSetBuilder {
+        /// Create a new builder with a default configuration for the given
+        /// patterns.
+        ///
+        /// If the patterns are invalid or exceed the configured size limits,
+        /// then an error will be returned when [`RegexSetBuilder::build`] is
+        /// called.
+        pub fn new<I, S>(patterns: I) -> RegexSetBuilder
+        where
+            I: IntoIterator<Item = S>,
+            S: AsRef<str>,
+        {
+            RegexSetBuilder { builder: Builder::new(patterns) }
+        }
+
+        /// Compiles the patterns given to `RegexSetBuilder::new` with the
+        /// configuration set on this builder.
+        ///
+        /// If the patterns aren't valid regexes or if a configured size limit
+        /// was exceeded, then an error is returned.
+        pub fn build(&self) -> Result<RegexSet, Error> {
+            self.builder.build_many_string()
+        }
+
+        /// This configures Unicode mode for the all of the patterns.
+        ///
+        /// Enabling Unicode mode does a number of things:
+        ///
+        /// * Most fundamentally, it causes the fundamental atom of matching
+        /// to be a single codepoint. When Unicode mode is disabled, it's a
+        /// single byte. For example, when Unicode mode is enabled, `.` will
+        /// match `💩` once, where as it will match 4 times when Unicode mode
+        /// is disabled. (Since the UTF-8 encoding of `💩` is 4 bytes long.)
+        /// * Case insensitive matching uses Unicode simple case folding rules.
+        /// * Unicode character classes like `\p{Letter}` and `\p{Greek}` are
+        /// available.
+        /// * Perl character classes are Unicode aware. That is, `\w`, `\s` and
+        /// `\d`.
+        /// * The word boundary assertions, `\b` and `\B`, use the Unicode
+        /// definition of a word character.
+        ///
+        /// Note that if Unicode mode is disabled, then the regex will fail to
+        /// compile if it could match invalid UTF-8. For example, when Unicode
+        /// mode is disabled, then since `.` matches any byte (except for
+        /// `\n`), then it can match invalid UTF-8 and thus building a regex
+        /// from it will fail. Another example is `\w` and `\W`. Since `\w` can
+        /// only match ASCII bytes when Unicode mode is disabled, it's allowed.
+        /// But `\W` can match more than ASCII bytes, including invalid UTF-8,
+        /// and so it is not allowed. This restriction can be lifted only by
+        /// using a [`bytes::RegexSet`](crate::bytes::RegexSet).
+        ///
+        /// For more details on the Unicode support in this crate, see the
+        /// [Unicode section](crate#unicode) in this crate's top-level
+        /// documentation.
+        ///
+        /// The default for this is `true`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"\w"])
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(!re.is_match("δ"));
+        ///
+        /// let re = RegexSetBuilder::new([r"s"])
+        ///     .case_insensitive(true)
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally 'ſ' is included when searching for 's' case
+        /// // insensitively due to Unicode's simple case folding rules. But
+        /// // when Unicode mode is disabled, only ASCII case insensitive rules
+        /// // are used.
+        /// assert!(!re.is_match("ſ"));
+        /// ```
+        pub fn unicode(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.unicode(yes);
+            self
+        }
+
+        /// This configures whether to enable case insensitive matching for all
+        /// of the patterns.
+        ///
+        /// This setting can also be configured using the inline flag `i`
+        /// in the pattern. For example, `(?i:foo)` matches `foo` case
+        /// insensitively while `(?-i:foo)` matches `foo` case sensitively.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"foo(?-i:bar)quux"])
+        ///     .case_insensitive(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("FoObarQuUx"));
+        /// // Even though case insensitive matching is enabled in the builder,
+        /// // it can be locally disabled within the pattern. In this case,
+        /// // `bar` is matched case sensitively.
+        /// assert!(!re.is_match("fooBARquux"));
+        /// ```
+        pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.case_insensitive(yes);
+            self
+        }
+
+        /// This configures multi-line mode for all of the patterns.
+        ///
+        /// Enabling multi-line mode changes the behavior of the `^` and `$`
+        /// anchor assertions. Instead of only matching at the beginning and
+        /// end of a haystack, respectively, multi-line mode causes them to
+        /// match at the beginning and end of a line *in addition* to the
+        /// beginning and end of a haystack. More precisely, `^` will match at
+        /// the position immediately following a `\n` and `$` will match at the
+        /// position immediately preceding a `\n`.
+        ///
+        /// The behavior of this option can be impacted by other settings too:
+        ///
+        /// * The [`RegexSetBuilder::line_terminator`] option changes `\n`
+        /// above to any ASCII byte.
+        /// * The [`RegexSetBuilder::crlf`] option changes the line terminator
+        /// to be either `\r` or `\n`, but never at the position between a `\r`
+        /// and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `m` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("\nfoo\n"));
+        /// ```
+        pub fn multi_line(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.multi_line(yes);
+            self
+        }
+
+        /// This configures dot-matches-new-line mode for the entire pattern.
+        ///
+        /// Perhaps surprisingly, the default behavior for `.` is not to match
+        /// any character, but rather, to match any character except for the
+        /// line terminator (which is `\n` by default). When this mode is
+        /// enabled, the behavior changes such that `.` truly matches any
+        /// character.
+        ///
+        /// This setting can also be configured using the inline flag `s` in
+        /// the pattern. For example, `(?s:.)` and `\p{any}` are equivalent
+        /// regexes.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"foo.bar"])
+        ///     .dot_matches_new_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "foo\nbar";
+        /// assert!(re.is_match(hay));
+        /// ```
+        pub fn dot_matches_new_line(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexSetBuilder {
+            self.builder.dot_matches_new_line(yes);
+            self
+        }
+
+        /// This configures CRLF mode for all of the patterns.
+        ///
+        /// When CRLF mode is enabled, both `\r` ("carriage return" or CR for
+        /// short) and `\n` ("line feed" or LF for short) are treated as line
+        /// terminators. This results in the following:
+        ///
+        /// * Unless dot-matches-new-line mode is enabled, `.` will now match
+        /// any character except for `\n` and `\r`.
+        /// * When multi-line mode is enabled, `^` will match immediatelly
+        /// following a `\n` or a `\r`. Similarly, `$` will match immediately
+        /// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match
+        /// between `\r` and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `R` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "\r\nfoo\r\n";
+        /// // If CRLF mode weren't enabled here, then '$' wouldn't match
+        /// // immediately after 'foo', and thus no match would be found.
+        /// assert!(re.is_match(hay));
+        /// ```
+        ///
+        /// This example demonstrates that `^` will never match at a position
+        /// between `\r` and `\n`. (`$` will similarly not match between a `\r`
+        /// and a `\n`.)
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^\n"])
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(!re.is_match("\r\n"));
+        /// ```
+        pub fn crlf(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.crlf(yes);
+            self
+        }
+
+        /// Configures the line terminator to be used by the regex.
+        ///
+        /// The line terminator is relevant in two ways for a particular regex:
+        ///
+        /// * When dot-matches-new-line mode is *not* enabled (the default),
+        /// then `.` will match any character except for the configured line
+        /// terminator.
+        /// * When multi-line mode is enabled (not the default), then `^` and
+        /// `$` will match immediately after and before, respectively, a line
+        /// terminator.
+        ///
+        /// In both cases, if CRLF mode is enabled in a particular context,
+        /// then it takes precedence over any configured line terminator.
+        ///
+        /// This option cannot be configured from within the pattern.
+        ///
+        /// The default line terminator is `\n`.
+        ///
+        /// # Example
+        ///
+        /// This shows how to treat the NUL byte as a line terminator. This can
+        /// be a useful heuristic when searching binary data.
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = "\x00foo\x00";
+        /// assert!(re.is_match(hay));
+        /// ```
+        ///
+        /// This example shows that the behavior of `.` is impacted by this
+        /// setting as well:
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"."])
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("\n"));
+        /// assert!(!re.is_match("\x00"));
+        /// ```
+        ///
+        /// This shows that building a regex will fail if the byte given
+        /// is not ASCII and the pattern could result in matching invalid
+        /// UTF-8. This is because any singular non-ASCII byte is not valid
+        /// UTF-8, and it is not permitted for a [`RegexSet`] to match invalid
+        /// UTF-8. (It is permissible to use a non-ASCII byte when building a
+        /// [`bytes::RegexSet`](crate::bytes::RegexSet).)
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// assert!(
+        ///     RegexSetBuilder::new([r"."])
+        ///         .line_terminator(0x80)
+        ///         .build()
+        ///         .is_err()
+        /// );
+        /// // Note that using a non-ASCII byte isn't enough on its own to
+        /// // cause regex compilation to fail. You actually have to make use
+        /// // of it in the regex in a way that leads to matching invalid
+        /// // UTF-8. If you don't, then regex compilation will succeed!
+        /// assert!(
+        ///     RegexSetBuilder::new([r"a"])
+        ///         .line_terminator(0x80)
+        ///         .build()
+        ///         .is_ok()
+        /// );
+        /// ```
+        pub fn line_terminator(&mut self, byte: u8) -> &mut RegexSetBuilder {
+            self.builder.line_terminator(byte);
+            self
+        }
+
+        /// This configures swap-greed mode for all of the patterns.
+        ///
+        /// When swap-greed mode is enabled, patterns like `a+` will become
+        /// non-greedy and patterns like `a+?` will become greedy. In other
+        /// words, the meanings of `a+` and `a+?` are switched.
+        ///
+        /// This setting can also be configured using the inline flag `U` in
+        /// the pattern.
+        ///
+        /// Note that this is generally not useful for a `RegexSet` since a
+        /// `RegexSet` can only report whether a pattern matches or not. Since
+        /// greediness never impacts whether a match is found or not (only the
+        /// offsets of the match), it follows that whether parts of a pattern
+        /// are greedy or not doesn't matter for a `RegexSet`.
+        ///
+        /// The default for this is `false`.
+        pub fn swap_greed(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.swap_greed(yes);
+            self
+        }
+
+        /// This configures verbose mode for all of the patterns.
+        ///
+        /// When enabled, whitespace will treated as insignifcant in the
+        /// pattern and `#` can be used to start a comment until the next new
+        /// line.
+        ///
+        /// Normally, in most places in a pattern, whitespace is treated
+        /// literally. For example ` +` will match one or more ASCII whitespace
+        /// characters.
+        ///
+        /// When verbose mode is enabled, `\#` can be used to match a literal
+        /// `#` and `\ ` can be used to match a literal ASCII whitespace
+        /// character.
+        ///
+        /// Verbose mode is useful for permitting regexes to be formatted and
+        /// broken up more nicely. This may make them more easily readable.
+        ///
+        /// This setting can also be configured using the inline flag `x` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// let pat = r"
+        ///     \b
+        ///     (?<first>\p{Uppercase}\w*)  # always start with uppercase letter
+        ///     [\s--\n]+                   # whitespace should separate names
+        ///     (?: # middle name can be an initial!
+        ///         (?:(?<initial>\p{Uppercase})\.|(?<middle>\p{Uppercase}\w*))
+        ///         [\s--\n]+
+        ///     )?
+        ///     (?<last>\p{Uppercase}\w*)
+        ///     \b
+        /// ";
+        /// let re = RegexSetBuilder::new([pat])
+        ///     .ignore_whitespace(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("Harry Potter"));
+        /// assert!(re.is_match("Harry J. Potter"));
+        /// assert!(re.is_match("Harry James Potter"));
+        /// assert!(!re.is_match("harry J. Potter"));
+        /// ```
+        pub fn ignore_whitespace(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexSetBuilder {
+            self.builder.ignore_whitespace(yes);
+            self
+        }
+
+        /// This configures octal mode for all of the patterns.
+        ///
+        /// Octal syntax is a little-known way of uttering Unicode codepoints
+        /// in a pattern. For example, `a`, `\x61`, `\u0061` and `\141` are all
+        /// equivalent patterns, where the last example shows octal syntax.
+        ///
+        /// While supporting octal syntax isn't in and of itself a problem,
+        /// it does make good error messages harder. That is, in PCRE based
+        /// regex engines, syntax like `\1` invokes a backreference, which is
+        /// explicitly unsupported this library. However, many users expect
+        /// backreferences to be supported. Therefore, when octal support
+        /// is disabled, the error message will explicitly mention that
+        /// backreferences aren't supported.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// // Normally this pattern would not compile, with an error message
+        /// // about backreferences not being supported. But with octal mode
+        /// // enabled, octal escape sequences work.
+        /// let re = RegexSetBuilder::new([r"\141"])
+        ///     .octal(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match("a"));
+        /// ```
+        pub fn octal(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.octal(yes);
+            self
+        }
+
+        /// Sets the approximate size limit, in bytes, of the compiled regex.
+        ///
+        /// This roughly corresponds to the number of heap memory, in
+        /// bytes, occupied by a single regex. If the regex would otherwise
+        /// approximately exceed this limit, then compiling that regex will
+        /// fail.
+        ///
+        /// The main utility of a method like this is to avoid compiling
+        /// regexes that use an unexpected amount of resources, such as
+        /// time and memory. Even if the memory usage of a large regex is
+        /// acceptable, its search time may not be. Namely, worst case time
+        /// complexity for search is `O(m * n)`, where `m ~ len(pattern)` and
+        /// `n ~ len(haystack)`. That is, search time depends, in part, on the
+        /// size of the compiled regex. This means that putting a limit on the
+        /// size of the regex limits how much a regex can impact search time.
+        ///
+        /// For more information about regex size limits, see the section on
+        /// [untrusted inputs](crate#untrusted-input) in the top-level crate
+        /// documentation.
+        ///
+        /// The default for this is some reasonable number that permits most
+        /// patterns to compile successfully.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// // It may surprise you how big some seemingly small patterns can
+        /// // be! Since \w is Unicode aware, this generates a regex that can
+        /// // match approximately 140,000 distinct codepoints.
+        /// assert!(
+        ///     RegexSetBuilder::new([r"\w"])
+        ///         .size_limit(45_000)
+        ///         .build()
+        ///         .is_err()
+        /// );
+        /// ```
+        pub fn size_limit(&mut self, bytes: usize) -> &mut RegexSetBuilder {
+            self.builder.size_limit(bytes);
+            self
+        }
+
+        /// Set the approximate capacity, in bytes, of the cache of transitions
+        /// used by the lazy DFA.
+        ///
+        /// While the lazy DFA isn't always used, in tends to be the most
+        /// commonly use regex engine in default configurations. It tends to
+        /// adopt the performance profile of a fully build DFA, but without the
+        /// downside of taking worst case exponential time to build.
+        ///
+        /// The downside is that it needs to keep a cache of transitions and
+        /// states that are built while running a search, and this cache
+        /// can fill up. When it fills up, the cache will reset itself. Any
+        /// previously generated states and transitions will then need to be
+        /// re-generated. If this happens too many times, then this library
+        /// will bail out of using the lazy DFA and switch to a different regex
+        /// engine.
+        ///
+        /// If your regex provokes this particular downside of the lazy DFA,
+        /// then it may be beneficial to increase its cache capacity. This will
+        /// potentially reduce the frequency of cache resetting (ideally to
+        /// `0`). While it won't fix all potential performance problems with
+        /// the lazy DFA, increasing the cache capacity does fix some.
+        ///
+        /// There is no easy way to determine, a priori, whether increasing
+        /// this cache capacity will help. In general, the larger your regex,
+        /// the more cache it's likely to use. But that isn't an ironclad rule.
+        /// For example, a regex like `[01]*1[01]{N}` would normally produce a
+        /// fully build DFA that is exponential in size with respect to `N`.
+        /// The lazy DFA will prevent exponential space blow-up, but it cache
+        /// is likely to fill up, even when it's large and even for smallish
+        /// values of `N`.
+        ///
+        /// If you aren't sure whether this helps or not, it is sensible to
+        /// set this to some arbitrarily large number in testing, such as
+        /// `usize::MAX`. Namely, this represents the amount of capacity that
+        /// *may* be used. It's probably not a good idea to use `usize::MAX` in
+        /// production though, since it implies there are no controls on heap
+        /// memory used by this library during a search. In effect, set it to
+        /// whatever you're willing to allocate for a single regex search.
+        pub fn dfa_size_limit(
+            &mut self,
+            bytes: usize,
+        ) -> &mut RegexSetBuilder {
+            self.builder.dfa_size_limit(bytes);
+            self
+        }
+
+        /// Set the nesting limit for this parser.
+        ///
+        /// The nesting limit controls how deep the abstract syntax tree is
+        /// allowed to be. If the AST exceeds the given limit (e.g., with too
+        /// many nested groups), then an error is returned by the parser.
+        ///
+        /// The purpose of this limit is to act as a heuristic to prevent stack
+        /// overflow for consumers that do structural induction on an AST using
+        /// explicit recursion. While this crate never does this (instead using
+        /// constant stack space and moving the call stack to the heap), other
+        /// crates may.
+        ///
+        /// This limit is not checked until the entire AST is parsed.
+        /// Therefore, if callers want to put a limit on the amount of heap
+        /// space used, then they should impose a limit on the length, in
+        /// bytes, of the concrete pattern string. In particular, this is
+        /// viable since this parser implementation will limit itself to heap
+        /// space proportional to the length of the pattern string. See also
+        /// the [untrusted inputs](crate#untrusted-input) section in the
+        /// top-level crate documentation for more information about this.
+        ///
+        /// Note that a nest limit of `0` will return a nest limit error for
+        /// most patterns but not all. For example, a nest limit of `0` permits
+        /// `a` but not `ab`, since `ab` requires an explicit concatenation,
+        /// which results in a nest depth of `1`. In general, a nest limit is
+        /// not something that manifests in an obvious way in the concrete
+        /// syntax, therefore, it should not be used in a granular way.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::RegexSetBuilder;
+        ///
+        /// assert!(RegexSetBuilder::new([r"a"]).nest_limit(0).build().is_ok());
+        /// assert!(RegexSetBuilder::new([r"ab"]).nest_limit(0).build().is_err());
+        /// ```
+        pub fn nest_limit(&mut self, limit: u32) -> &mut RegexSetBuilder {
+            self.builder.nest_limit(limit);
+            self
+        }
+    }
+}
+
+pub(crate) mod bytes {
+    use crate::{
+        bytes::{Regex, RegexSet},
+        error::Error,
+    };
+
+    use super::Builder;
+
+    /// A configurable builder for a [`Regex`].
+    ///
+    /// This builder can be used to programmatically set flags such as `i`
+    /// (case insensitive) and `x` (for verbose mode). This builder can also be
+    /// used to configure things like the line terminator and a size limit on
+    /// the compiled regular expression.
+    #[derive(Clone, Debug)]
+    pub struct RegexBuilder {
+        builder: Builder,
+    }
+
+    impl RegexBuilder {
+        /// Create a new builder with a default configuration for the given
+        /// pattern.
+        ///
+        /// If the pattern is invalid or exceeds the configured size limits,
+        /// then an error will be returned when [`RegexBuilder::build`] is
+        /// called.
+        pub fn new(pattern: &str) -> RegexBuilder {
+            RegexBuilder { builder: Builder::new([pattern]) }
+        }
+
+        /// Compiles the pattern given to `RegexBuilder::new` with the
+        /// configuration set on this builder.
+        ///
+        /// If the pattern isn't a valid regex or if a configured size limit
+        /// was exceeded, then an error is returned.
+        pub fn build(&self) -> Result<Regex, Error> {
+            self.builder.build_one_bytes()
+        }
+
+        /// This configures Unicode mode for the entire pattern.
+        ///
+        /// Enabling Unicode mode does a number of things:
+        ///
+        /// * Most fundamentally, it causes the fundamental atom of matching
+        /// to be a single codepoint. When Unicode mode is disabled, it's a
+        /// single byte. For example, when Unicode mode is enabled, `.` will
+        /// match `💩` once, where as it will match 4 times when Unicode mode
+        /// is disabled. (Since the UTF-8 encoding of `💩` is 4 bytes long.)
+        /// * Case insensitive matching uses Unicode simple case folding rules.
+        /// * Unicode character classes like `\p{Letter}` and `\p{Greek}` are
+        /// available.
+        /// * Perl character classes are Unicode aware. That is, `\w`, `\s` and
+        /// `\d`.
+        /// * The word boundary assertions, `\b` and `\B`, use the Unicode
+        /// definition of a word character.
+        ///
+        /// Note that unlike the top-level `Regex` for searching `&str`, it
+        /// is permitted to disable Unicode mode even if the resulting pattern
+        /// could match invalid UTF-8. For example, `(?-u:.)` is not a valid
+        /// pattern for a top-level `Regex`, but is valid for a `bytes::Regex`.
+        ///
+        /// For more details on the Unicode support in this crate, see the
+        /// [Unicode section](crate#unicode) in this crate's top-level
+        /// documentation.
+        ///
+        /// The default for this is `true`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"\w")
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(!re.is_match("δ".as_bytes()));
+        ///
+        /// let re = RegexBuilder::new(r"s")
+        ///     .case_insensitive(true)
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally 'ſ' is included when searching for 's' case
+        /// // insensitively due to Unicode's simple case folding rules. But
+        /// // when Unicode mode is disabled, only ASCII case insensitive rules
+        /// // are used.
+        /// assert!(!re.is_match("ſ".as_bytes()));
+        /// ```
+        ///
+        /// Since this builder is for constructing a [`bytes::Regex`](Regex),
+        /// one can disable Unicode mode even if it would match invalid UTF-8:
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r".")
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(re.is_match(b"\xFF"));
+        /// ```
+        pub fn unicode(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.unicode(yes);
+            self
+        }
+
+        /// This configures whether to enable case insensitive matching for the
+        /// entire pattern.
+        ///
+        /// This setting can also be configured using the inline flag `i`
+        /// in the pattern. For example, `(?i:foo)` matches `foo` case
+        /// insensitively while `(?-i:foo)` matches `foo` case sensitively.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"foo(?-i:bar)quux")
+        ///     .case_insensitive(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"FoObarQuUx"));
+        /// // Even though case insensitive matching is enabled in the builder,
+        /// // it can be locally disabled within the pattern. In this case,
+        /// // `bar` is matched case sensitively.
+        /// assert!(!re.is_match(b"fooBARquux"));
+        /// ```
+        pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.case_insensitive(yes);
+            self
+        }
+
+        /// This configures multi-line mode for the entire pattern.
+        ///
+        /// Enabling multi-line mode changes the behavior of the `^` and `$`
+        /// anchor assertions. Instead of only matching at the beginning and
+        /// end of a haystack, respectively, multi-line mode causes them to
+        /// match at the beginning and end of a line *in addition* to the
+        /// beginning and end of a haystack. More precisely, `^` will match at
+        /// the position immediately following a `\n` and `$` will match at the
+        /// position immediately preceding a `\n`.
+        ///
+        /// The behavior of this option can be impacted by other settings too:
+        ///
+        /// * The [`RegexBuilder::line_terminator`] option changes `\n` above
+        /// to any ASCII byte.
+        /// * The [`RegexBuilder::crlf`] option changes the line terminator to
+        /// be either `\r` or `\n`, but never at the position between a `\r`
+        /// and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `m` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert_eq!(Some(1..4), re.find(b"\nfoo\n").map(|m| m.range()));
+        /// ```
+        pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.multi_line(yes);
+            self
+        }
+
+        /// This configures dot-matches-new-line mode for the entire pattern.
+        ///
+        /// Perhaps surprisingly, the default behavior for `.` is not to match
+        /// any character, but rather, to match any character except for the
+        /// line terminator (which is `\n` by default). When this mode is
+        /// enabled, the behavior changes such that `.` truly matches any
+        /// character.
+        ///
+        /// This setting can also be configured using the inline flag `s` in
+        /// the pattern. For example, `(?s:.)` and `\p{any}` are equivalent
+        /// regexes.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"foo.bar")
+        ///     .dot_matches_new_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"foo\nbar";
+        /// assert_eq!(Some(&b"foo\nbar"[..]), re.find(hay).map(|m| m.as_bytes()));
+        /// ```
+        pub fn dot_matches_new_line(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexBuilder {
+            self.builder.dot_matches_new_line(yes);
+            self
+        }
+
+        /// This configures CRLF mode for the entire pattern.
+        ///
+        /// When CRLF mode is enabled, both `\r` ("carriage return" or CR for
+        /// short) and `\n` ("line feed" or LF for short) are treated as line
+        /// terminators. This results in the following:
+        ///
+        /// * Unless dot-matches-new-line mode is enabled, `.` will now match
+        /// any character except for `\n` and `\r`.
+        /// * When multi-line mode is enabled, `^` will match immediatelly
+        /// following a `\n` or a `\r`. Similarly, `$` will match immediately
+        /// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match
+        /// between `\r` and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `R` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"\r\nfoo\r\n";
+        /// // If CRLF mode weren't enabled here, then '$' wouldn't match
+        /// // immediately after 'foo', and thus no match would be found.
+        /// assert_eq!(Some(&b"foo"[..]), re.find(hay).map(|m| m.as_bytes()));
+        /// ```
+        ///
+        /// This example demonstrates that `^` will never match at a position
+        /// between `\r` and `\n`. (`$` will similarly not match between a `\r`
+        /// and a `\n`.)
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^")
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"\r\n\r\n";
+        /// let ranges: Vec<_> = re.find_iter(hay).map(|m| m.range()).collect();
+        /// assert_eq!(ranges, vec![0..0, 2..2, 4..4]);
+        /// ```
+        pub fn crlf(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.crlf(yes);
+            self
+        }
+
+        /// Configures the line terminator to be used by the regex.
+        ///
+        /// The line terminator is relevant in two ways for a particular regex:
+        ///
+        /// * When dot-matches-new-line mode is *not* enabled (the default),
+        /// then `.` will match any character except for the configured line
+        /// terminator.
+        /// * When multi-line mode is enabled (not the default), then `^` and
+        /// `$` will match immediately after and before, respectively, a line
+        /// terminator.
+        ///
+        /// In both cases, if CRLF mode is enabled in a particular context,
+        /// then it takes precedence over any configured line terminator.
+        ///
+        /// This option cannot be configured from within the pattern.
+        ///
+        /// The default line terminator is `\n`.
+        ///
+        /// # Example
+        ///
+        /// This shows how to treat the NUL byte as a line terminator. This can
+        /// be a useful heuristic when searching binary data.
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"^foo$")
+        ///     .multi_line(true)
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"\x00foo\x00";
+        /// assert_eq!(Some(1..4), re.find(hay).map(|m| m.range()));
+        /// ```
+        ///
+        /// This example shows that the behavior of `.` is impacted by this
+        /// setting as well:
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r".")
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"\n"));
+        /// assert!(!re.is_match(b"\x00"));
+        /// ```
+        ///
+        /// This shows that building a regex will work even when the byte
+        /// given is not ASCII. This is unlike the top-level `Regex` API where
+        /// matching invalid UTF-8 is not allowed.
+        ///
+        /// Note though that you must disable Unicode mode. This is required
+        /// because Unicode mode requires matching one codepoint at a time,
+        /// and there is no way to match a non-ASCII byte as if it were a
+        /// codepoint.
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// assert!(
+        ///     RegexBuilder::new(r".")
+        ///         .unicode(false)
+        ///         .line_terminator(0x80)
+        ///         .build()
+        ///         .is_ok(),
+        /// );
+        /// ```
+        pub fn line_terminator(&mut self, byte: u8) -> &mut RegexBuilder {
+            self.builder.line_terminator(byte);
+            self
+        }
+
+        /// This configures swap-greed mode for the entire pattern.
+        ///
+        /// When swap-greed mode is enabled, patterns like `a+` will become
+        /// non-greedy and patterns like `a+?` will become greedy. In other
+        /// words, the meanings of `a+` and `a+?` are switched.
+        ///
+        /// This setting can also be configured using the inline flag `U` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let re = RegexBuilder::new(r"a+")
+        ///     .swap_greed(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert_eq!(Some(&b"a"[..]), re.find(b"aaa").map(|m| m.as_bytes()));
+        /// ```
+        pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.swap_greed(yes);
+            self
+        }
+
+        /// This configures verbose mode for the entire pattern.
+        ///
+        /// When enabled, whitespace will treated as insignifcant in the
+        /// pattern and `#` can be used to start a comment until the next new
+        /// line.
+        ///
+        /// Normally, in most places in a pattern, whitespace is treated
+        /// literally. For example ` +` will match one or more ASCII whitespace
+        /// characters.
+        ///
+        /// When verbose mode is enabled, `\#` can be used to match a literal
+        /// `#` and `\ ` can be used to match a literal ASCII whitespace
+        /// character.
+        ///
+        /// Verbose mode is useful for permitting regexes to be formatted and
+        /// broken up more nicely. This may make them more easily readable.
+        ///
+        /// This setting can also be configured using the inline flag `x` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// let pat = r"
+        ///     \b
+        ///     (?<first>\p{Uppercase}\w*)  # always start with uppercase letter
+        ///     [\s--\n]+                   # whitespace should separate names
+        ///     (?: # middle name can be an initial!
+        ///         (?:(?<initial>\p{Uppercase})\.|(?<middle>\p{Uppercase}\w*))
+        ///         [\s--\n]+
+        ///     )?
+        ///     (?<last>\p{Uppercase}\w*)
+        ///     \b
+        /// ";
+        /// let re = RegexBuilder::new(pat)
+        ///     .ignore_whitespace(true)
+        ///     .build()
+        ///     .unwrap();
+        ///
+        /// let caps = re.captures(b"Harry Potter").unwrap();
+        /// assert_eq!(&b"Harry"[..], &caps["first"]);
+        /// assert_eq!(&b"Potter"[..], &caps["last"]);
+        ///
+        /// let caps = re.captures(b"Harry J. Potter").unwrap();
+        /// assert_eq!(&b"Harry"[..], &caps["first"]);
+        /// // Since a middle name/initial isn't required for an overall match,
+        /// // we can't assume that 'initial' or 'middle' will be populated!
+        /// assert_eq!(
+        ///     Some(&b"J"[..]),
+        ///     caps.name("initial").map(|m| m.as_bytes()),
+        /// );
+        /// assert_eq!(None, caps.name("middle").map(|m| m.as_bytes()));
+        /// assert_eq!(&b"Potter"[..], &caps["last"]);
+        ///
+        /// let caps = re.captures(b"Harry James Potter").unwrap();
+        /// assert_eq!(&b"Harry"[..], &caps["first"]);
+        /// // Since a middle name/initial isn't required for an overall match,
+        /// // we can't assume that 'initial' or 'middle' will be populated!
+        /// assert_eq!(None, caps.name("initial").map(|m| m.as_bytes()));
+        /// assert_eq!(
+        ///     Some(&b"James"[..]),
+        ///     caps.name("middle").map(|m| m.as_bytes()),
+        /// );
+        /// assert_eq!(&b"Potter"[..], &caps["last"]);
+        /// ```
+        pub fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.ignore_whitespace(yes);
+            self
+        }
+
+        /// This configures octal mode for the entire pattern.
+        ///
+        /// Octal syntax is a little-known way of uttering Unicode codepoints
+        /// in a pattern. For example, `a`, `\x61`, `\u0061` and `\141` are all
+        /// equivalent patterns, where the last example shows octal syntax.
+        ///
+        /// While supporting octal syntax isn't in and of itself a problem,
+        /// it does make good error messages harder. That is, in PCRE based
+        /// regex engines, syntax like `\1` invokes a backreference, which is
+        /// explicitly unsupported this library. However, many users expect
+        /// backreferences to be supported. Therefore, when octal support
+        /// is disabled, the error message will explicitly mention that
+        /// backreferences aren't supported.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// // Normally this pattern would not compile, with an error message
+        /// // about backreferences not being supported. But with octal mode
+        /// // enabled, octal escape sequences work.
+        /// let re = RegexBuilder::new(r"\141")
+        ///     .octal(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"a"));
+        /// ```
+        pub fn octal(&mut self, yes: bool) -> &mut RegexBuilder {
+            self.builder.octal(yes);
+            self
+        }
+
+        /// Sets the approximate size limit, in bytes, of the compiled regex.
+        ///
+        /// This roughly corresponds to the number of heap memory, in
+        /// bytes, occupied by a single regex. If the regex would otherwise
+        /// approximately exceed this limit, then compiling that regex will
+        /// fail.
+        ///
+        /// The main utility of a method like this is to avoid compiling
+        /// regexes that use an unexpected amount of resources, such as
+        /// time and memory. Even if the memory usage of a large regex is
+        /// acceptable, its search time may not be. Namely, worst case time
+        /// complexity for search is `O(m * n)`, where `m ~ len(pattern)` and
+        /// `n ~ len(haystack)`. That is, search time depends, in part, on the
+        /// size of the compiled regex. This means that putting a limit on the
+        /// size of the regex limits how much a regex can impact search time.
+        ///
+        /// For more information about regex size limits, see the section on
+        /// [untrusted inputs](crate#untrusted-input) in the top-level crate
+        /// documentation.
+        ///
+        /// The default for this is some reasonable number that permits most
+        /// patterns to compile successfully.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// // It may surprise you how big some seemingly small patterns can
+        /// // be! Since \w is Unicode aware, this generates a regex that can
+        /// // match approximately 140,000 distinct codepoints.
+        /// assert!(RegexBuilder::new(r"\w").size_limit(45_000).build().is_err());
+        /// ```
+        pub fn size_limit(&mut self, bytes: usize) -> &mut RegexBuilder {
+            self.builder.size_limit(bytes);
+            self
+        }
+
+        /// Set the approximate capacity, in bytes, of the cache of transitions
+        /// used by the lazy DFA.
+        ///
+        /// While the lazy DFA isn't always used, in tends to be the most
+        /// commonly use regex engine in default configurations. It tends to
+        /// adopt the performance profile of a fully build DFA, but without the
+        /// downside of taking worst case exponential time to build.
+        ///
+        /// The downside is that it needs to keep a cache of transitions and
+        /// states that are built while running a search, and this cache
+        /// can fill up. When it fills up, the cache will reset itself. Any
+        /// previously generated states and transitions will then need to be
+        /// re-generated. If this happens too many times, then this library
+        /// will bail out of using the lazy DFA and switch to a different regex
+        /// engine.
+        ///
+        /// If your regex provokes this particular downside of the lazy DFA,
+        /// then it may be beneficial to increase its cache capacity. This will
+        /// potentially reduce the frequency of cache resetting (ideally to
+        /// `0`). While it won't fix all potential performance problems with
+        /// the lazy DFA, increasing the cache capacity does fix some.
+        ///
+        /// There is no easy way to determine, a priori, whether increasing
+        /// this cache capacity will help. In general, the larger your regex,
+        /// the more cache it's likely to use. But that isn't an ironclad rule.
+        /// For example, a regex like `[01]*1[01]{N}` would normally produce a
+        /// fully build DFA that is exponential in size with respect to `N`.
+        /// The lazy DFA will prevent exponential space blow-up, but it cache
+        /// is likely to fill up, even when it's large and even for smallish
+        /// values of `N`.
+        ///
+        /// If you aren't sure whether this helps or not, it is sensible to
+        /// set this to some arbitrarily large number in testing, such as
+        /// `usize::MAX`. Namely, this represents the amount of capacity that
+        /// *may* be used. It's probably not a good idea to use `usize::MAX` in
+        /// production though, since it implies there are no controls on heap
+        /// memory used by this library during a search. In effect, set it to
+        /// whatever you're willing to allocate for a single regex search.
+        pub fn dfa_size_limit(&mut self, bytes: usize) -> &mut RegexBuilder {
+            self.builder.dfa_size_limit(bytes);
+            self
+        }
+
+        /// Set the nesting limit for this parser.
+        ///
+        /// The nesting limit controls how deep the abstract syntax tree is
+        /// allowed to be. If the AST exceeds the given limit (e.g., with too
+        /// many nested groups), then an error is returned by the parser.
+        ///
+        /// The purpose of this limit is to act as a heuristic to prevent stack
+        /// overflow for consumers that do structural induction on an AST using
+        /// explicit recursion. While this crate never does this (instead using
+        /// constant stack space and moving the call stack to the heap), other
+        /// crates may.
+        ///
+        /// This limit is not checked until the entire AST is parsed.
+        /// Therefore, if callers want to put a limit on the amount of heap
+        /// space used, then they should impose a limit on the length, in
+        /// bytes, of the concrete pattern string. In particular, this is
+        /// viable since this parser implementation will limit itself to heap
+        /// space proportional to the length of the pattern string. See also
+        /// the [untrusted inputs](crate#untrusted-input) section in the
+        /// top-level crate documentation for more information about this.
+        ///
+        /// Note that a nest limit of `0` will return a nest limit error for
+        /// most patterns but not all. For example, a nest limit of `0` permits
+        /// `a` but not `ab`, since `ab` requires an explicit concatenation,
+        /// which results in a nest depth of `1`. In general, a nest limit is
+        /// not something that manifests in an obvious way in the concrete
+        /// syntax, therefore, it should not be used in a granular way.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexBuilder;
+        ///
+        /// assert!(RegexBuilder::new(r"a").nest_limit(0).build().is_ok());
+        /// assert!(RegexBuilder::new(r"ab").nest_limit(0).build().is_err());
+        /// ```
+        pub fn nest_limit(&mut self, limit: u32) -> &mut RegexBuilder {
+            self.builder.nest_limit(limit);
+            self
+        }
+    }
+
+    /// A configurable builder for a [`RegexSet`].
+    ///
+    /// This builder can be used to programmatically set flags such as `i`
+    /// (case insensitive) and `x` (for verbose mode). This builder can also be
+    /// used to configure things like the line terminator and a size limit on
+    /// the compiled regular expression.
+    #[derive(Clone, Debug)]
+    pub struct RegexSetBuilder {
+        builder: Builder,
+    }
+
+    impl RegexSetBuilder {
+        /// Create a new builder with a default configuration for the given
+        /// patterns.
+        ///
+        /// If the patterns are invalid or exceed the configured size limits,
+        /// then an error will be returned when [`RegexSetBuilder::build`] is
+        /// called.
+        pub fn new<I, S>(patterns: I) -> RegexSetBuilder
+        where
+            I: IntoIterator<Item = S>,
+            S: AsRef<str>,
+        {
+            RegexSetBuilder { builder: Builder::new(patterns) }
+        }
+
+        /// Compiles the patterns given to `RegexSetBuilder::new` with the
+        /// configuration set on this builder.
+        ///
+        /// If the patterns aren't valid regexes or if a configured size limit
+        /// was exceeded, then an error is returned.
+        pub fn build(&self) -> Result<RegexSet, Error> {
+            self.builder.build_many_bytes()
+        }
+
+        /// This configures Unicode mode for the all of the patterns.
+        ///
+        /// Enabling Unicode mode does a number of things:
+        ///
+        /// * Most fundamentally, it causes the fundamental atom of matching
+        /// to be a single codepoint. When Unicode mode is disabled, it's a
+        /// single byte. For example, when Unicode mode is enabled, `.` will
+        /// match `💩` once, where as it will match 4 times when Unicode mode
+        /// is disabled. (Since the UTF-8 encoding of `💩` is 4 bytes long.)
+        /// * Case insensitive matching uses Unicode simple case folding rules.
+        /// * Unicode character classes like `\p{Letter}` and `\p{Greek}` are
+        /// available.
+        /// * Perl character classes are Unicode aware. That is, `\w`, `\s` and
+        /// `\d`.
+        /// * The word boundary assertions, `\b` and `\B`, use the Unicode
+        /// definition of a word character.
+        ///
+        /// Note that unlike the top-level `RegexSet` for searching `&str`,
+        /// it is permitted to disable Unicode mode even if the resulting
+        /// pattern could match invalid UTF-8. For example, `(?-u:.)` is not
+        /// a valid pattern for a top-level `RegexSet`, but is valid for a
+        /// `bytes::RegexSet`.
+        ///
+        /// For more details on the Unicode support in this crate, see the
+        /// [Unicode section](crate#unicode) in this crate's top-level
+        /// documentation.
+        ///
+        /// The default for this is `true`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"\w"])
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(!re.is_match("δ".as_bytes()));
+        ///
+        /// let re = RegexSetBuilder::new([r"s"])
+        ///     .case_insensitive(true)
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally 'ſ' is included when searching for 's' case
+        /// // insensitively due to Unicode's simple case folding rules. But
+        /// // when Unicode mode is disabled, only ASCII case insensitive rules
+        /// // are used.
+        /// assert!(!re.is_match("ſ".as_bytes()));
+        /// ```
+        ///
+        /// Since this builder is for constructing a
+        /// [`bytes::RegexSet`](RegexSet), one can disable Unicode mode even if
+        /// it would match invalid UTF-8:
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"."])
+        ///     .unicode(false)
+        ///     .build()
+        ///     .unwrap();
+        /// // Normally greek letters would be included in \w, but since
+        /// // Unicode mode is disabled, it only matches ASCII letters.
+        /// assert!(re.is_match(b"\xFF"));
+        /// ```
+        pub fn unicode(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.unicode(yes);
+            self
+        }
+
+        /// This configures whether to enable case insensitive matching for all
+        /// of the patterns.
+        ///
+        /// This setting can also be configured using the inline flag `i`
+        /// in the pattern. For example, `(?i:foo)` matches `foo` case
+        /// insensitively while `(?-i:foo)` matches `foo` case sensitively.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"foo(?-i:bar)quux"])
+        ///     .case_insensitive(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"FoObarQuUx"));
+        /// // Even though case insensitive matching is enabled in the builder,
+        /// // it can be locally disabled within the pattern. In this case,
+        /// // `bar` is matched case sensitively.
+        /// assert!(!re.is_match(b"fooBARquux"));
+        /// ```
+        pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.case_insensitive(yes);
+            self
+        }
+
+        /// This configures multi-line mode for all of the patterns.
+        ///
+        /// Enabling multi-line mode changes the behavior of the `^` and `$`
+        /// anchor assertions. Instead of only matching at the beginning and
+        /// end of a haystack, respectively, multi-line mode causes them to
+        /// match at the beginning and end of a line *in addition* to the
+        /// beginning and end of a haystack. More precisely, `^` will match at
+        /// the position immediately following a `\n` and `$` will match at the
+        /// position immediately preceding a `\n`.
+        ///
+        /// The behavior of this option can be impacted by other settings too:
+        ///
+        /// * The [`RegexSetBuilder::line_terminator`] option changes `\n`
+        /// above to any ASCII byte.
+        /// * The [`RegexSetBuilder::crlf`] option changes the line terminator
+        /// to be either `\r` or `\n`, but never at the position between a `\r`
+        /// and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `m` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"\nfoo\n"));
+        /// ```
+        pub fn multi_line(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.multi_line(yes);
+            self
+        }
+
+        /// This configures dot-matches-new-line mode for the entire pattern.
+        ///
+        /// Perhaps surprisingly, the default behavior for `.` is not to match
+        /// any character, but rather, to match any character except for the
+        /// line terminator (which is `\n` by default). When this mode is
+        /// enabled, the behavior changes such that `.` truly matches any
+        /// character.
+        ///
+        /// This setting can also be configured using the inline flag `s` in
+        /// the pattern. For example, `(?s:.)` and `\p{any}` are equivalent
+        /// regexes.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"foo.bar"])
+        ///     .dot_matches_new_line(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"foo\nbar";
+        /// assert!(re.is_match(hay));
+        /// ```
+        pub fn dot_matches_new_line(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexSetBuilder {
+            self.builder.dot_matches_new_line(yes);
+            self
+        }
+
+        /// This configures CRLF mode for all of the patterns.
+        ///
+        /// When CRLF mode is enabled, both `\r` ("carriage return" or CR for
+        /// short) and `\n` ("line feed" or LF for short) are treated as line
+        /// terminators. This results in the following:
+        ///
+        /// * Unless dot-matches-new-line mode is enabled, `.` will now match
+        /// any character except for `\n` and `\r`.
+        /// * When multi-line mode is enabled, `^` will match immediatelly
+        /// following a `\n` or a `\r`. Similarly, `$` will match immediately
+        /// preceding a `\n` or a `\r`. Neither `^` nor `$` will ever match
+        /// between `\r` and `\n`.
+        ///
+        /// This setting can also be configured using the inline flag `R` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"\r\nfoo\r\n";
+        /// // If CRLF mode weren't enabled here, then '$' wouldn't match
+        /// // immediately after 'foo', and thus no match would be found.
+        /// assert!(re.is_match(hay));
+        /// ```
+        ///
+        /// This example demonstrates that `^` will never match at a position
+        /// between `\r` and `\n`. (`$` will similarly not match between a `\r`
+        /// and a `\n`.)
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^\n"])
+        ///     .multi_line(true)
+        ///     .crlf(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(!re.is_match(b"\r\n"));
+        /// ```
+        pub fn crlf(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.crlf(yes);
+            self
+        }
+
+        /// Configures the line terminator to be used by the regex.
+        ///
+        /// The line terminator is relevant in two ways for a particular regex:
+        ///
+        /// * When dot-matches-new-line mode is *not* enabled (the default),
+        /// then `.` will match any character except for the configured line
+        /// terminator.
+        /// * When multi-line mode is enabled (not the default), then `^` and
+        /// `$` will match immediately after and before, respectively, a line
+        /// terminator.
+        ///
+        /// In both cases, if CRLF mode is enabled in a particular context,
+        /// then it takes precedence over any configured line terminator.
+        ///
+        /// This option cannot be configured from within the pattern.
+        ///
+        /// The default line terminator is `\n`.
+        ///
+        /// # Example
+        ///
+        /// This shows how to treat the NUL byte as a line terminator. This can
+        /// be a useful heuristic when searching binary data.
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"^foo$"])
+        ///     .multi_line(true)
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// let hay = b"\x00foo\x00";
+        /// assert!(re.is_match(hay));
+        /// ```
+        ///
+        /// This example shows that the behavior of `.` is impacted by this
+        /// setting as well:
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let re = RegexSetBuilder::new([r"."])
+        ///     .line_terminator(b'\x00')
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"\n"));
+        /// assert!(!re.is_match(b"\x00"));
+        /// ```
+        ///
+        /// This shows that building a regex will work even when the byte given
+        /// is not ASCII. This is unlike the top-level `RegexSet` API where
+        /// matching invalid UTF-8 is not allowed.
+        ///
+        /// Note though that you must disable Unicode mode. This is required
+        /// because Unicode mode requires matching one codepoint at a time,
+        /// and there is no way to match a non-ASCII byte as if it were a
+        /// codepoint.
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// assert!(
+        ///     RegexSetBuilder::new([r"."])
+        ///         .unicode(false)
+        ///         .line_terminator(0x80)
+        ///         .build()
+        ///         .is_ok(),
+        /// );
+        /// ```
+        pub fn line_terminator(&mut self, byte: u8) -> &mut RegexSetBuilder {
+            self.builder.line_terminator(byte);
+            self
+        }
+
+        /// This configures swap-greed mode for all of the patterns.
+        ///
+        /// When swap-greed mode is enabled, patterns like `a+` will become
+        /// non-greedy and patterns like `a+?` will become greedy. In other
+        /// words, the meanings of `a+` and `a+?` are switched.
+        ///
+        /// This setting can also be configured using the inline flag `U` in
+        /// the pattern.
+        ///
+        /// Note that this is generally not useful for a `RegexSet` since a
+        /// `RegexSet` can only report whether a pattern matches or not. Since
+        /// greediness never impacts whether a match is found or not (only the
+        /// offsets of the match), it follows that whether parts of a pattern
+        /// are greedy or not doesn't matter for a `RegexSet`.
+        ///
+        /// The default for this is `false`.
+        pub fn swap_greed(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.swap_greed(yes);
+            self
+        }
+
+        /// This configures verbose mode for all of the patterns.
+        ///
+        /// When enabled, whitespace will treated as insignifcant in the
+        /// pattern and `#` can be used to start a comment until the next new
+        /// line.
+        ///
+        /// Normally, in most places in a pattern, whitespace is treated
+        /// literally. For example ` +` will match one or more ASCII whitespace
+        /// characters.
+        ///
+        /// When verbose mode is enabled, `\#` can be used to match a literal
+        /// `#` and `\ ` can be used to match a literal ASCII whitespace
+        /// character.
+        ///
+        /// Verbose mode is useful for permitting regexes to be formatted and
+        /// broken up more nicely. This may make them more easily readable.
+        ///
+        /// This setting can also be configured using the inline flag `x` in
+        /// the pattern.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// let pat = r"
+        ///     \b
+        ///     (?<first>\p{Uppercase}\w*)  # always start with uppercase letter
+        ///     [\s--\n]+                   # whitespace should separate names
+        ///     (?: # middle name can be an initial!
+        ///         (?:(?<initial>\p{Uppercase})\.|(?<middle>\p{Uppercase}\w*))
+        ///         [\s--\n]+
+        ///     )?
+        ///     (?<last>\p{Uppercase}\w*)
+        ///     \b
+        /// ";
+        /// let re = RegexSetBuilder::new([pat])
+        ///     .ignore_whitespace(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"Harry Potter"));
+        /// assert!(re.is_match(b"Harry J. Potter"));
+        /// assert!(re.is_match(b"Harry James Potter"));
+        /// assert!(!re.is_match(b"harry J. Potter"));
+        /// ```
+        pub fn ignore_whitespace(
+            &mut self,
+            yes: bool,
+        ) -> &mut RegexSetBuilder {
+            self.builder.ignore_whitespace(yes);
+            self
+        }
+
+        /// This configures octal mode for all of the patterns.
+        ///
+        /// Octal syntax is a little-known way of uttering Unicode codepoints
+        /// in a pattern. For example, `a`, `\x61`, `\u0061` and `\141` are all
+        /// equivalent patterns, where the last example shows octal syntax.
+        ///
+        /// While supporting octal syntax isn't in and of itself a problem,
+        /// it does make good error messages harder. That is, in PCRE based
+        /// regex engines, syntax like `\1` invokes a backreference, which is
+        /// explicitly unsupported this library. However, many users expect
+        /// backreferences to be supported. Therefore, when octal support
+        /// is disabled, the error message will explicitly mention that
+        /// backreferences aren't supported.
+        ///
+        /// The default for this is `false`.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// // Normally this pattern would not compile, with an error message
+        /// // about backreferences not being supported. But with octal mode
+        /// // enabled, octal escape sequences work.
+        /// let re = RegexSetBuilder::new([r"\141"])
+        ///     .octal(true)
+        ///     .build()
+        ///     .unwrap();
+        /// assert!(re.is_match(b"a"));
+        /// ```
+        pub fn octal(&mut self, yes: bool) -> &mut RegexSetBuilder {
+            self.builder.octal(yes);
+            self
+        }
+
+        /// Sets the approximate size limit, in bytes, of the compiled regex.
+        ///
+        /// This roughly corresponds to the number of heap memory, in
+        /// bytes, occupied by a single regex. If the regex would otherwise
+        /// approximately exceed this limit, then compiling that regex will
+        /// fail.
+        ///
+        /// The main utility of a method like this is to avoid compiling
+        /// regexes that use an unexpected amount of resources, such as
+        /// time and memory. Even if the memory usage of a large regex is
+        /// acceptable, its search time may not be. Namely, worst case time
+        /// complexity for search is `O(m * n)`, where `m ~ len(pattern)` and
+        /// `n ~ len(haystack)`. That is, search time depends, in part, on the
+        /// size of the compiled regex. This means that putting a limit on the
+        /// size of the regex limits how much a regex can impact search time.
+        ///
+        /// For more information about regex size limits, see the section on
+        /// [untrusted inputs](crate#untrusted-input) in the top-level crate
+        /// documentation.
+        ///
+        /// The default for this is some reasonable number that permits most
+        /// patterns to compile successfully.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// // It may surprise you how big some seemingly small patterns can
+        /// // be! Since \w is Unicode aware, this generates a regex that can
+        /// // match approximately 140,000 distinct codepoints.
+        /// assert!(
+        ///     RegexSetBuilder::new([r"\w"])
+        ///         .size_limit(45_000)
+        ///         .build()
+        ///         .is_err()
+        /// );
+        /// ```
+        pub fn size_limit(&mut self, bytes: usize) -> &mut RegexSetBuilder {
+            self.builder.size_limit(bytes);
+            self
+        }
+
+        /// Set the approximate capacity, in bytes, of the cache of transitions
+        /// used by the lazy DFA.
+        ///
+        /// While the lazy DFA isn't always used, in tends to be the most
+        /// commonly use regex engine in default configurations. It tends to
+        /// adopt the performance profile of a fully build DFA, but without the
+        /// downside of taking worst case exponential time to build.
+        ///
+        /// The downside is that it needs to keep a cache of transitions and
+        /// states that are built while running a search, and this cache
+        /// can fill up. When it fills up, the cache will reset itself. Any
+        /// previously generated states and transitions will then need to be
+        /// re-generated. If this happens too many times, then this library
+        /// will bail out of using the lazy DFA and switch to a different regex
+        /// engine.
+        ///
+        /// If your regex provokes this particular downside of the lazy DFA,
+        /// then it may be beneficial to increase its cache capacity. This will
+        /// potentially reduce the frequency of cache resetting (ideally to
+        /// `0`). While it won't fix all potential performance problems with
+        /// the lazy DFA, increasing the cache capacity does fix some.
+        ///
+        /// There is no easy way to determine, a priori, whether increasing
+        /// this cache capacity will help. In general, the larger your regex,
+        /// the more cache it's likely to use. But that isn't an ironclad rule.
+        /// For example, a regex like `[01]*1[01]{N}` would normally produce a
+        /// fully build DFA that is exponential in size with respect to `N`.
+        /// The lazy DFA will prevent exponential space blow-up, but it cache
+        /// is likely to fill up, even when it's large and even for smallish
+        /// values of `N`.
+        ///
+        /// If you aren't sure whether this helps or not, it is sensible to
+        /// set this to some arbitrarily large number in testing, such as
+        /// `usize::MAX`. Namely, this represents the amount of capacity that
+        /// *may* be used. It's probably not a good idea to use `usize::MAX` in
+        /// production though, since it implies there are no controls on heap
+        /// memory used by this library during a search. In effect, set it to
+        /// whatever you're willing to allocate for a single regex search.
+        pub fn dfa_size_limit(
+            &mut self,
+            bytes: usize,
+        ) -> &mut RegexSetBuilder {
+            self.builder.dfa_size_limit(bytes);
+            self
+        }
+
+        /// Set the nesting limit for this parser.
+        ///
+        /// The nesting limit controls how deep the abstract syntax tree is
+        /// allowed to be. If the AST exceeds the given limit (e.g., with too
+        /// many nested groups), then an error is returned by the parser.
+        ///
+        /// The purpose of this limit is to act as a heuristic to prevent stack
+        /// overflow for consumers that do structural induction on an AST using
+        /// explicit recursion. While this crate never does this (instead using
+        /// constant stack space and moving the call stack to the heap), other
+        /// crates may.
+        ///
+        /// This limit is not checked until the entire AST is parsed.
+        /// Therefore, if callers want to put a limit on the amount of heap
+        /// space used, then they should impose a limit on the length, in
+        /// bytes, of the concrete pattern string. In particular, this is
+        /// viable since this parser implementation will limit itself to heap
+        /// space proportional to the length of the pattern string. See also
+        /// the [untrusted inputs](crate#untrusted-input) section in the
+        /// top-level crate documentation for more information about this.
+        ///
+        /// Note that a nest limit of `0` will return a nest limit error for
+        /// most patterns but not all. For example, a nest limit of `0` permits
+        /// `a` but not `ab`, since `ab` requires an explicit concatenation,
+        /// which results in a nest depth of `1`. In general, a nest limit is
+        /// not something that manifests in an obvious way in the concrete
+        /// syntax, therefore, it should not be used in a granular way.
+        ///
+        /// # Example
+        ///
+        /// ```
+        /// use regex::bytes::RegexSetBuilder;
+        ///
+        /// assert!(RegexSetBuilder::new([r"a"]).nest_limit(0).build().is_ok());
+        /// assert!(RegexSetBuilder::new([r"ab"]).nest_limit(0).build().is_err());
+        /// ```
+        pub fn nest_limit(&mut self, limit: u32) -> &mut RegexSetBuilder {
+            self.builder.nest_limit(limit);
+            self
+        }
+    }
+}
diff --git a/src/bytes.rs b/src/bytes.rs
new file mode 100644
index 0000000000..c81c1a43d1
--- /dev/null
+++ b/src/bytes.rs
@@ -0,0 +1,91 @@
+/*!
+Search for regex matches in `&[u8]` haystacks.
+
+This module provides a nearly identical API via [`Regex`] to the one found in
+the top-level of this crate. There are two important differences:
+
+1. Matching is done on `&[u8]` instead of `&str`. Additionally, `Vec<u8>`
+is used where `String` would have been used in the top-level API.
+2. Unicode support can be disabled even when disabling it would result in
+matching invalid UTF-8 bytes.
+
+# Example: match null terminated string
+
+This shows how to find all null-terminated strings in a slice of bytes. This
+works even if a C string contains invalid UTF-8.
+
+```rust
+use regex::bytes::Regex;
+
+let re = Regex::new(r"(?-u)(?<cstr>[^\x00]+)\x00").unwrap();
+let hay = b"foo\x00qu\xFFux\x00baz\x00";
+
+// Extract all of the strings without the NUL terminator from each match.
+// The unwrap is OK here since a match requires the `cstr` capture to match.
+let cstrs: Vec<&[u8]> =
+    re.captures_iter(hay)
+      .map(|c| c.name("cstr").unwrap().as_bytes())
+      .collect();
+assert_eq!(cstrs, vec![&b"foo"[..], &b"qu\xFFux"[..], &b"baz"[..]]);
+```
+
+# Example: selectively enable Unicode support
+
+This shows how to match an arbitrary byte pattern followed by a UTF-8 encoded
+string (e.g., to extract a title from a Matroska file):
+
+```rust
+use regex::bytes::Regex;
+
+let re = Regex::new(
+    r"(?-u)\x7b\xa9(?:[\x80-\xfe]|[\x40-\xff].)(?u:(.*))"
+).unwrap();
+let hay = b"\x12\xd0\x3b\x5f\x7b\xa9\x85\xe2\x98\x83\x80\x98\x54\x76\x68\x65";
+
+// Notice that despite the `.*` at the end, it will only match valid UTF-8
+// because Unicode mode was enabled with the `u` flag. Without the `u` flag,
+// the `.*` would match the rest of the bytes regardless of whehter they were
+// valid UTF-8.
+let (_, [title]) = re.captures(hay).unwrap().extract();
+assert_eq!(title, b"\xE2\x98\x83");
+// We can UTF-8 decode the title now. And the unwrap here
+// is correct because the existence of a match guarantees
+// that `title` is valid UTF-8.
+let title = std::str::from_utf8(title).unwrap();
+assert_eq!(title, "☃");
+```
+
+In general, if the Unicode flag is enabled in a capture group and that capture
+is part of the overall match, then the capture is *guaranteed* to be valid
+UTF-8.
+
+# Syntax
+
+The supported syntax is pretty much the same as the syntax for Unicode
+regular expressions with a few changes that make sense for matching arbitrary
+bytes:
+
+1. The `u` flag can be disabled even when disabling it might cause the regex to
+match invalid UTF-8. When the `u` flag is disabled, the regex is said to be in
+"ASCII compatible" mode.
+2. In ASCII compatible mode, neither Unicode scalar values nor Unicode
+character classes are allowed.
+3. In ASCII compatible mode, Perl character classes (`\w`, `\d` and `\s`)
+revert to their typical ASCII definition. `\w` maps to `[[:word:]]`, `\d` maps
+to `[[:digit:]]` and `\s` maps to `[[:space:]]`.
+4. In ASCII compatible mode, word boundaries use the ASCII compatible `\w` to
+determine whether a byte is a word byte or not.
+5. Hexadecimal notation can be used to specify arbitrary bytes instead of
+Unicode codepoints. For example, in ASCII compatible mode, `\xFF` matches the
+literal byte `\xFF`, while in Unicode mode, `\xFF` is the Unicode codepoint
+`U+00FF` that matches its UTF-8 encoding of `\xC3\xBF`. Similarly for octal
+notation when enabled.
+6. In ASCII compatible mode, `.` matches any *byte* except for `\n`. When the
+`s` flag is additionally enabled, `.` matches any byte.
+
+# Performance
+
+In general, one should expect performance on `&[u8]` to be roughly similar to
+performance on `&str`.
+*/
+pub use crate::{builders::bytes::*, regex::bytes::*, regexset::bytes::*};
diff --git a/src/compile.rs b/src/compile.rs
deleted file mode 100644
index 23e63ec891..0000000000
--- a/src/compile.rs
+++ /dev/null
@@ -1,1333 +0,0 @@
-use std::collections::HashMap;
-use std::fmt;
-use std::iter;
-use std::result;
-use std::sync::Arc;
-
-use regex_syntax::hir::{self, Hir, Look};
-use regex_syntax::is_word_byte;
-use regex_syntax::utf8::{Utf8Range, Utf8Sequence, Utf8Sequences};
-
-use crate::prog::{
-    EmptyLook, Inst, InstBytes, InstChar, InstEmptyLook, InstPtr, InstRanges,
-    InstSave, InstSplit, Program,
-};
-
-use crate::Error;
-
-type Result = result::Result<Patch, Error>;
-type ResultOrEmpty = result::Result<Option<Patch>, Error>;
-
-#[derive(Debug)]
-struct Patch {
-    hole: Hole,
-    entry: InstPtr,
-}
-
-/// A compiler translates a regular expression AST to a sequence of
-/// instructions. The sequence of instructions represents an NFA.
-// `Compiler` is only public via the `internal` module, so avoid deriving
-// `Debug`.
-#[allow(missing_debug_implementations)]
-pub struct Compiler {
-    insts: Vec<MaybeInst>,
-    compiled: Program,
-    capture_name_idx: HashMap<String, usize>,
-    num_exprs: usize,
-    size_limit: usize,
-    suffix_cache: SuffixCache,
-    utf8_seqs: Option<Utf8Sequences>,
-    byte_classes: ByteClassSet,
-    // This keeps track of extra bytes allocated while compiling the regex
-    // program. Currently, this corresponds to two things. First is the heap
-    // memory allocated by Unicode character classes ('InstRanges'). Second is
-    // a "fake" amount of memory used by empty sub-expressions, so that enough
-    // empty sub-expressions will ultimately trigger the compiler to bail
-    // because of a size limit restriction. (That empty sub-expressions don't
-    // add to heap memory usage is more-or-less an implementation detail.) In
-    // the second case, if we don't bail, then an excessively large repetition
-    // on an empty sub-expression can result in the compiler using a very large
-    // amount of CPU time.
-    extra_inst_bytes: usize,
-}
-
-impl Compiler {
-    /// Create a new regular expression compiler.
-    ///
-    /// Various options can be set before calling `compile` on an expression.
-    pub fn new() -> Self {
-        Compiler {
-            insts: vec![],
-            compiled: Program::new(),
-            capture_name_idx: HashMap::new(),
-            num_exprs: 0,
-            size_limit: 10 * (1 << 20),
-            suffix_cache: SuffixCache::new(1000),
-            utf8_seqs: Some(Utf8Sequences::new('\x00', '\x00')),
-            byte_classes: ByteClassSet::new(),
-            extra_inst_bytes: 0,
-        }
-    }
-
-    /// The size of the resulting program is limited by size_limit. If
-    /// the program approximately exceeds the given size (in bytes), then
-    /// compilation will stop and return an error.
-    pub fn size_limit(mut self, size_limit: usize) -> Self {
-        self.size_limit = size_limit;
-        self
-    }
-
-    /// If bytes is true, then the program is compiled as a byte based
-    /// automaton, which incorporates UTF-8 decoding into the machine. If it's
-    /// false, then the automaton is Unicode scalar value based, e.g., an
-    /// engine utilizing such an automaton is responsible for UTF-8 decoding.
-    ///
-    /// The specific invariant is that when returning a byte based machine,
-    /// the neither the `Char` nor `Ranges` instructions are produced.
-    /// Conversely, when producing a Unicode scalar value machine, the `Bytes`
-    /// instruction is never produced.
-    ///
-    /// Note that `dfa(true)` implies `bytes(true)`.
-    pub fn bytes(mut self, yes: bool) -> Self {
-        self.compiled.is_bytes = yes;
-        self
-    }
-
-    /// When disabled, the program compiled may match arbitrary bytes.
-    ///
-    /// When enabled (the default), all compiled programs exclusively match
-    /// valid UTF-8 bytes.
-    pub fn only_utf8(mut self, yes: bool) -> Self {
-        self.compiled.only_utf8 = yes;
-        self
-    }
-
-    /// When set, the machine returned is suitable for use in the DFA matching
-    /// engine.
-    ///
-    /// In particular, this ensures that if the regex is not anchored in the
-    /// beginning, then a preceding `.*?` is included in the program. (The NFA
-    /// based engines handle the preceding `.*?` explicitly, which is difficult
-    /// or impossible in the DFA engine.)
-    pub fn dfa(mut self, yes: bool) -> Self {
-        self.compiled.is_dfa = yes;
-        self
-    }
-
-    /// When set, the machine returned is suitable for matching text in
-    /// reverse. In particular, all concatenations are flipped.
-    pub fn reverse(mut self, yes: bool) -> Self {
-        self.compiled.is_reverse = yes;
-        self
-    }
-
-    /// Compile a regular expression given its AST.
-    ///
-    /// The compiler is guaranteed to succeed unless the program exceeds the
-    /// specified size limit. If the size limit is exceeded, then compilation
-    /// stops and returns an error.
-    pub fn compile(mut self, exprs: &[Hir]) -> result::Result<Program, Error> {
-        debug_assert!(!exprs.is_empty());
-        self.num_exprs = exprs.len();
-        if exprs.len() == 1 {
-            self.compile_one(&exprs[0])
-        } else {
-            self.compile_many(exprs)
-        }
-    }
-
-    fn compile_one(mut self, expr: &Hir) -> result::Result<Program, Error> {
-        if self.compiled.only_utf8
-            && expr.properties().look_set().contains(Look::WordAsciiNegate)
-        {
-            return Err(Error::Syntax(
-                "ASCII-only \\B is not allowed in Unicode regexes \
-                 because it may result in invalid UTF-8 matches"
-                    .to_string(),
-            ));
-        }
-        // If we're compiling a forward DFA and we aren't anchored, then
-        // add a `.*?` before the first capture group.
-        // Other matching engines handle this by baking the logic into the
-        // matching engine itself.
-        let mut dotstar_patch = Patch { hole: Hole::None, entry: 0 };
-        self.compiled.is_anchored_start =
-            expr.properties().look_set_prefix().contains(Look::Start);
-        self.compiled.is_anchored_end =
-            expr.properties().look_set_suffix().contains(Look::End);
-        if self.compiled.needs_dotstar() {
-            dotstar_patch = self.c_dotstar()?;
-            self.compiled.start = dotstar_patch.entry;
-        }
-        self.compiled.captures = vec![None];
-        let patch =
-            self.c_capture(0, expr)?.unwrap_or_else(|| self.next_inst());
-        if self.compiled.needs_dotstar() {
-            self.fill(dotstar_patch.hole, patch.entry);
-        } else {
-            self.compiled.start = patch.entry;
-        }
-        self.fill_to_next(patch.hole);
-        self.compiled.matches = vec![self.insts.len()];
-        self.push_compiled(Inst::Match(0));
-        self.compiled.static_captures_len =
-            expr.properties().static_explicit_captures_len();
-        self.compile_finish()
-    }
-
-    fn compile_many(
-        mut self,
-        exprs: &[Hir],
-    ) -> result::Result<Program, Error> {
-        debug_assert!(exprs.len() > 1);
-
-        self.compiled.is_anchored_start = exprs
-            .iter()
-            .all(|e| e.properties().look_set_prefix().contains(Look::Start));
-        self.compiled.is_anchored_end = exprs
-            .iter()
-            .all(|e| e.properties().look_set_suffix().contains(Look::End));
-        let mut dotstar_patch = Patch { hole: Hole::None, entry: 0 };
-        if self.compiled.needs_dotstar() {
-            dotstar_patch = self.c_dotstar()?;
-            self.compiled.start = dotstar_patch.entry;
-        } else {
-            self.compiled.start = 0; // first instruction is always split
-        }
-        self.fill_to_next(dotstar_patch.hole);
-
-        let mut prev_hole = Hole::None;
-        for (i, expr) in exprs[0..exprs.len() - 1].iter().enumerate() {
-            self.fill_to_next(prev_hole);
-            let split = self.push_split_hole();
-            let Patch { hole, entry } =
-                self.c_capture(0, expr)?.unwrap_or_else(|| self.next_inst());
-            self.fill_to_next(hole);
-            self.compiled.matches.push(self.insts.len());
-            self.push_compiled(Inst::Match(i));
-            prev_hole = self.fill_split(split, Some(entry), None);
-        }
-        let i = exprs.len() - 1;
-        let Patch { hole, entry } =
-            self.c_capture(0, &exprs[i])?.unwrap_or_else(|| self.next_inst());
-        self.fill(prev_hole, entry);
-        self.fill_to_next(hole);
-        self.compiled.matches.push(self.insts.len());
-        self.push_compiled(Inst::Match(i));
-        self.compile_finish()
-    }
-
-    fn compile_finish(mut self) -> result::Result<Program, Error> {
-        self.compiled.insts =
-            self.insts.into_iter().map(|inst| inst.unwrap()).collect();
-        self.compiled.byte_classes = self.byte_classes.byte_classes();
-        self.compiled.capture_name_idx = Arc::new(self.capture_name_idx);
-        Ok(self.compiled)
-    }
-
-    /// Compile expr into self.insts, returning a patch on success,
-    /// or an error if we run out of memory.
-    ///
-    /// All of the c_* methods of the compiler share the contract outlined
-    /// here.
-    ///
-    /// The main thing that a c_* method does is mutate `self.insts`
-    /// to add a list of mostly compiled instructions required to execute
-    /// the given expression. `self.insts` contains MaybeInsts rather than
-    /// Insts because there is some backpatching required.
-    ///
-    /// The `Patch` value returned by each c_* method provides metadata
-    /// about the compiled instructions emitted to `self.insts`. The
-    /// `entry` member of the patch refers to the first instruction
-    /// (the entry point), while the `hole` member contains zero or
-    /// more offsets to partial instructions that need to be backpatched.
-    /// The c_* routine can't know where its list of instructions are going to
-    /// jump to after execution, so it is up to the caller to patch
-    /// these jumps to point to the right place. So compiling some
-    /// expression, e, we would end up with a situation that looked like:
-    ///
-    /// ```text
-    /// self.insts = [ ..., i1, i2, ..., iexit1, ..., iexitn, ...]
-    ///                     ^              ^             ^
-    ///                     |                \         /
-    ///                   entry                \     /
-    ///                                         hole
-    /// ```
-    ///
-    /// To compile two expressions, e1 and e2, concatenated together we
-    /// would do:
-    ///
-    /// ```ignore
-    /// let patch1 = self.c(e1);
-    /// let patch2 = self.c(e2);
-    /// ```
-    ///
-    /// while leaves us with a situation that looks like
-    ///
-    /// ```text
-    /// self.insts = [ ..., i1, ..., iexit1, ..., i2, ..., iexit2 ]
-    ///                     ^        ^            ^        ^
-    ///                     |        |            |        |
-    ///                entry1        hole1   entry2        hole2
-    /// ```
-    ///
-    /// Then to merge the two patches together into one we would backpatch
-    /// hole1 with entry2 and return a new patch that enters at entry1
-    /// and has hole2 for a hole. In fact, if you look at the c_concat
-    /// method you will see that it does exactly this, though it handles
-    /// a list of expressions rather than just the two that we use for
-    /// an example.
-    ///
-    /// Ok(None) is returned when an expression is compiled to no
-    /// instruction, and so no patch.entry value makes sense.
-    fn c(&mut self, expr: &Hir) -> ResultOrEmpty {
-        use crate::prog;
-        use regex_syntax::hir::HirKind::*;
-
-        self.check_size()?;
-        match *expr.kind() {
-            Empty => self.c_empty(),
-            Literal(hir::Literal(ref bytes)) => {
-                if self.compiled.is_reverse {
-                    let mut bytes = bytes.to_vec();
-                    bytes.reverse();
-                    self.c_literal(&bytes)
-                } else {
-                    self.c_literal(bytes)
-                }
-            }
-            Class(hir::Class::Unicode(ref cls)) => self.c_class(cls.ranges()),
-            Class(hir::Class::Bytes(ref cls)) => {
-                if self.compiled.uses_bytes() {
-                    self.c_class_bytes(cls.ranges())
-                } else {
-                    assert!(cls.is_ascii());
-                    let mut char_ranges = vec![];
-                    for r in cls.iter() {
-                        let (s, e) = (r.start() as char, r.end() as char);
-                        char_ranges.push(hir::ClassUnicodeRange::new(s, e));
-                    }
-                    self.c_class(&char_ranges)
-                }
-            }
-            Look(ref look) => match *look {
-                hir::Look::Start if self.compiled.is_reverse => {
-                    self.c_empty_look(prog::EmptyLook::EndText)
-                }
-                hir::Look::Start => {
-                    self.c_empty_look(prog::EmptyLook::StartText)
-                }
-                hir::Look::End if self.compiled.is_reverse => {
-                    self.c_empty_look(prog::EmptyLook::StartText)
-                }
-                hir::Look::End => self.c_empty_look(prog::EmptyLook::EndText),
-                hir::Look::StartLF if self.compiled.is_reverse => {
-                    self.byte_classes.set_range(b'\n', b'\n');
-                    self.c_empty_look(prog::EmptyLook::EndLine)
-                }
-                hir::Look::StartLF => {
-                    self.byte_classes.set_range(b'\n', b'\n');
-                    self.c_empty_look(prog::EmptyLook::StartLine)
-                }
-                hir::Look::EndLF if self.compiled.is_reverse => {
-                    self.byte_classes.set_range(b'\n', b'\n');
-                    self.c_empty_look(prog::EmptyLook::StartLine)
-                }
-                hir::Look::EndLF => {
-                    self.byte_classes.set_range(b'\n', b'\n');
-                    self.c_empty_look(prog::EmptyLook::EndLine)
-                }
-                hir::Look::StartCRLF | hir::Look::EndCRLF => {
-                    return Err(Error::Syntax(
-                        "CRLF-aware line anchors are not supported yet"
-                            .to_string(),
-                    ));
-                }
-                hir::Look::WordAscii => {
-                    self.byte_classes.set_word_boundary();
-                    self.c_empty_look(prog::EmptyLook::WordBoundaryAscii)
-                }
-                hir::Look::WordAsciiNegate => {
-                    self.byte_classes.set_word_boundary();
-                    self.c_empty_look(prog::EmptyLook::NotWordBoundaryAscii)
-                }
-                hir::Look::WordUnicode => {
-                    if !cfg!(feature = "unicode-perl") {
-                        return Err(Error::Syntax(
-                            "Unicode word boundaries are unavailable when \
-                         the unicode-perl feature is disabled"
-                                .to_string(),
-                        ));
-                    }
-                    self.compiled.has_unicode_word_boundary = true;
-                    self.byte_classes.set_word_boundary();
-                    // We also make sure that all ASCII bytes are in a different
-                    // class from non-ASCII bytes. Otherwise, it's possible for
-                    // ASCII bytes to get lumped into the same class as non-ASCII
-                    // bytes. This in turn may cause the lazy DFA to falsely start
-                    // when it sees an ASCII byte that maps to a byte class with
-                    // non-ASCII bytes. This ensures that never happens.
-                    self.byte_classes.set_range(0, 0x7F);
-                    self.c_empty_look(prog::EmptyLook::WordBoundary)
-                }
-                hir::Look::WordUnicodeNegate => {
-                    if !cfg!(feature = "unicode-perl") {
-                        return Err(Error::Syntax(
-                            "Unicode word boundaries are unavailable when \
-                         the unicode-perl feature is disabled"
-                                .to_string(),
-                        ));
-                    }
-                    self.compiled.has_unicode_word_boundary = true;
-                    self.byte_classes.set_word_boundary();
-                    // See comments above for why we set the ASCII range here.
-                    self.byte_classes.set_range(0, 0x7F);
-                    self.c_empty_look(prog::EmptyLook::NotWordBoundary)
-                }
-            },
-            Capture(hir::Capture { index, ref name, ref sub }) => {
-                if index as usize >= self.compiled.captures.len() {
-                    let name = match *name {
-                        None => None,
-                        Some(ref boxed_str) => Some(boxed_str.to_string()),
-                    };
-                    self.compiled.captures.push(name.clone());
-                    if let Some(name) = name {
-                        self.capture_name_idx.insert(name, index as usize);
-                    }
-                }
-                self.c_capture(2 * index as usize, sub)
-            }
-            Concat(ref es) => {
-                if self.compiled.is_reverse {
-                    self.c_concat(es.iter().rev())
-                } else {
-                    self.c_concat(es)
-                }
-            }
-            Alternation(ref es) => self.c_alternate(&**es),
-            Repetition(ref rep) => self.c_repeat(rep),
-        }
-    }
-
-    fn c_empty(&mut self) -> ResultOrEmpty {
-        // See: https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8
-        // See: CVE-2022-24713
-        //
-        // Since 'empty' sub-expressions don't increase the size of
-        // the actual compiled object, we "fake" an increase in its
-        // size so that our 'check_size_limit' routine will eventually
-        // stop compilation if there are too many empty sub-expressions
-        // (e.g., via a large repetition).
-        self.extra_inst_bytes += std::mem::size_of::<Inst>();
-        Ok(None)
-    }
-
-    fn c_capture(&mut self, first_slot: usize, expr: &Hir) -> ResultOrEmpty {
-        if self.num_exprs > 1 || self.compiled.is_dfa {
-            // Don't ever compile Save instructions for regex sets because
-            // they are never used. They are also never used in DFA programs
-            // because DFAs can't handle captures.
-            self.c(expr)
-        } else {
-            let entry = self.insts.len();
-            let hole = self.push_hole(InstHole::Save { slot: first_slot });
-            let patch = self.c(expr)?.unwrap_or_else(|| self.next_inst());
-            self.fill(hole, patch.entry);
-            self.fill_to_next(patch.hole);
-            let hole = self.push_hole(InstHole::Save { slot: first_slot + 1 });
-            Ok(Some(Patch { hole, entry }))
-        }
-    }
-
-    fn c_dotstar(&mut self) -> Result {
-        let hir = if self.compiled.only_utf8() {
-            Hir::dot(hir::Dot::AnyChar)
-        } else {
-            Hir::dot(hir::Dot::AnyByte)
-        };
-        Ok(self
-            .c(&Hir::repetition(hir::Repetition {
-                min: 0,
-                max: None,
-                greedy: false,
-                sub: Box::new(hir),
-            }))?
-            .unwrap())
-    }
-
-    fn c_char(&mut self, c: char) -> ResultOrEmpty {
-        if self.compiled.uses_bytes() {
-            if c.is_ascii() {
-                let b = c as u8;
-                let hole =
-                    self.push_hole(InstHole::Bytes { start: b, end: b });
-                self.byte_classes.set_range(b, b);
-                Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
-            } else {
-                self.c_class(&[hir::ClassUnicodeRange::new(c, c)])
-            }
-        } else {
-            let hole = self.push_hole(InstHole::Char { c });
-            Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
-        }
-    }
-
-    fn c_class(&mut self, ranges: &[hir::ClassUnicodeRange]) -> ResultOrEmpty {
-        use std::mem::size_of;
-
-        if ranges.is_empty() {
-            return Err(Error::Syntax(
-                "empty character classes are not allowed".to_string(),
-            ));
-        }
-        if self.compiled.uses_bytes() {
-            Ok(Some(CompileClass { c: self, ranges }.compile()?))
-        } else {
-            let ranges: Vec<(char, char)> =
-                ranges.iter().map(|r| (r.start(), r.end())).collect();
-            let hole = if ranges.len() == 1 && ranges[0].0 == ranges[0].1 {
-                self.push_hole(InstHole::Char { c: ranges[0].0 })
-            } else {
-                self.extra_inst_bytes +=
-                    ranges.len() * (size_of::<char>() * 2);
-                self.push_hole(InstHole::Ranges { ranges })
-            };
-            Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
-        }
-    }
-
-    fn c_byte(&mut self, b: u8) -> ResultOrEmpty {
-        self.c_class_bytes(&[hir::ClassBytesRange::new(b, b)])
-    }
-
-    fn c_class_bytes(
-        &mut self,
-        ranges: &[hir::ClassBytesRange],
-    ) -> ResultOrEmpty {
-        if ranges.is_empty() {
-            return Err(Error::Syntax(
-                "empty character classes are not allowed".to_string(),
-            ));
-        }
-
-        let first_split_entry = self.insts.len();
-        let mut holes = vec![];
-        let mut prev_hole = Hole::None;
-        for r in &ranges[0..ranges.len() - 1] {
-            self.fill_to_next(prev_hole);
-            let split = self.push_split_hole();
-            let next = self.insts.len();
-            self.byte_classes.set_range(r.start(), r.end());
-            holes.push(self.push_hole(InstHole::Bytes {
-                start: r.start(),
-                end: r.end(),
-            }));
-            prev_hole = self.fill_split(split, Some(next), None);
-        }
-        let next = self.insts.len();
-        let r = &ranges[ranges.len() - 1];
-        self.byte_classes.set_range(r.start(), r.end());
-        holes.push(
-            self.push_hole(InstHole::Bytes { start: r.start(), end: r.end() }),
-        );
-        self.fill(prev_hole, next);
-        Ok(Some(Patch { hole: Hole::Many(holes), entry: first_split_entry }))
-    }
-
-    fn c_empty_look(&mut self, look: EmptyLook) -> ResultOrEmpty {
-        let hole = self.push_hole(InstHole::EmptyLook { look });
-        Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
-    }
-
-    fn c_literal(&mut self, bytes: &[u8]) -> ResultOrEmpty {
-        match core::str::from_utf8(bytes) {
-            Ok(string) => {
-                let mut it = string.chars();
-                let Patch { mut hole, entry } = loop {
-                    match it.next() {
-                        None => return self.c_empty(),
-                        Some(ch) => {
-                            if let Some(p) = self.c_char(ch)? {
-                                break p;
-                            }
-                        }
-                    }
-                };
-                for ch in it {
-                    if let Some(p) = self.c_char(ch)? {
-                        self.fill(hole, p.entry);
-                        hole = p.hole;
-                    }
-                }
-                Ok(Some(Patch { hole, entry }))
-            }
-            Err(_) => {
-                assert!(self.compiled.uses_bytes());
-                let mut it = bytes.iter().copied();
-                let Patch { mut hole, entry } = loop {
-                    match it.next() {
-                        None => return self.c_empty(),
-                        Some(byte) => {
-                            if let Some(p) = self.c_byte(byte)? {
-                                break p;
-                            }
-                        }
-                    }
-                };
-                for byte in it {
-                    if let Some(p) = self.c_byte(byte)? {
-                        self.fill(hole, p.entry);
-                        hole = p.hole;
-                    }
-                }
-                Ok(Some(Patch { hole, entry }))
-            }
-        }
-    }
-
-    fn c_concat<'a, I>(&mut self, exprs: I) -> ResultOrEmpty
-    where
-        I: IntoIterator<Item = &'a Hir>,
-    {
-        let mut exprs = exprs.into_iter();
-        let Patch { mut hole, entry } = loop {
-            match exprs.next() {
-                None => return self.c_empty(),
-                Some(e) => {
-                    if let Some(p) = self.c(e)? {
-                        break p;
-                    }
-                }
-            }
-        };
-        for e in exprs {
-            if let Some(p) = self.c(e)? {
-                self.fill(hole, p.entry);
-                hole = p.hole;
-            }
-        }
-        Ok(Some(Patch { hole, entry }))
-    }
-
-    fn c_alternate(&mut self, exprs: &[Hir]) -> ResultOrEmpty {
-        debug_assert!(
-            exprs.len() >= 2,
-            "alternates must have at least 2 exprs"
-        );
-
-        // Initial entry point is always the first split.
-        let first_split_entry = self.insts.len();
-
-        // Save up all of the holes from each alternate. They will all get
-        // patched to point to the same location.
-        let mut holes = vec![];
-
-        // true indicates that the hole is a split where we want to fill
-        // the second branch.
-        let mut prev_hole = (Hole::None, false);
-        for e in &exprs[0..exprs.len() - 1] {
-            if prev_hole.1 {
-                let next = self.insts.len();
-                self.fill_split(prev_hole.0, None, Some(next));
-            } else {
-                self.fill_to_next(prev_hole.0);
-            }
-            let split = self.push_split_hole();
-            if let Some(Patch { hole, entry }) = self.c(e)? {
-                holes.push(hole);
-                prev_hole = (self.fill_split(split, Some(entry), None), false);
-            } else {
-                let (split1, split2) = split.dup_one();
-                holes.push(split1);
-                prev_hole = (split2, true);
-            }
-        }
-        if let Some(Patch { hole, entry }) = self.c(&exprs[exprs.len() - 1])? {
-            holes.push(hole);
-            if prev_hole.1 {
-                self.fill_split(prev_hole.0, None, Some(entry));
-            } else {
-                self.fill(prev_hole.0, entry);
-            }
-        } else {
-            // We ignore prev_hole.1. When it's true, it means we have two
-            // empty branches both pushing prev_hole.0 into holes, so both
-            // branches will go to the same place anyway.
-            holes.push(prev_hole.0);
-        }
-        Ok(Some(Patch { hole: Hole::Many(holes), entry: first_split_entry }))
-    }
-
-    fn c_repeat(&mut self, rep: &hir::Repetition) -> ResultOrEmpty {
-        match (rep.min, rep.max) {
-            (0, Some(1)) => self.c_repeat_zero_or_one(&rep.sub, rep.greedy),
-            (0, None) => self.c_repeat_zero_or_more(&rep.sub, rep.greedy),
-            (1, None) => self.c_repeat_one_or_more(&rep.sub, rep.greedy),
-            (min, None) => {
-                self.c_repeat_range_min_or_more(&rep.sub, rep.greedy, min)
-            }
-            (min, Some(max)) => {
-                self.c_repeat_range(&rep.sub, rep.greedy, min, max)
-            }
-        }
-    }
-
-    fn c_repeat_zero_or_one(
-        &mut self,
-        expr: &Hir,
-        greedy: bool,
-    ) -> ResultOrEmpty {
-        let split_entry = self.insts.len();
-        let split = self.push_split_hole();
-        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
-            Some(p) => p,
-            None => return self.pop_split_hole(),
-        };
-        let split_hole = if greedy {
-            self.fill_split(split, Some(entry_rep), None)
-        } else {
-            self.fill_split(split, None, Some(entry_rep))
-        };
-        let holes = vec![hole_rep, split_hole];
-        Ok(Some(Patch { hole: Hole::Many(holes), entry: split_entry }))
-    }
-
-    fn c_repeat_zero_or_more(
-        &mut self,
-        expr: &Hir,
-        greedy: bool,
-    ) -> ResultOrEmpty {
-        let split_entry = self.insts.len();
-        let split = self.push_split_hole();
-        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
-            Some(p) => p,
-            None => return self.pop_split_hole(),
-        };
-
-        self.fill(hole_rep, split_entry);
-        let split_hole = if greedy {
-            self.fill_split(split, Some(entry_rep), None)
-        } else {
-            self.fill_split(split, None, Some(entry_rep))
-        };
-        Ok(Some(Patch { hole: split_hole, entry: split_entry }))
-    }
-
-    fn c_repeat_one_or_more(
-        &mut self,
-        expr: &Hir,
-        greedy: bool,
-    ) -> ResultOrEmpty {
-        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
-            Some(p) => p,
-            None => return Ok(None),
-        };
-        self.fill_to_next(hole_rep);
-        let split = self.push_split_hole();
-
-        let split_hole = if greedy {
-            self.fill_split(split, Some(entry_rep), None)
-        } else {
-            self.fill_split(split, None, Some(entry_rep))
-        };
-        Ok(Some(Patch { hole: split_hole, entry: entry_rep }))
-    }
-
-    fn c_repeat_range_min_or_more(
-        &mut self,
-        expr: &Hir,
-        greedy: bool,
-        min: u32,
-    ) -> ResultOrEmpty {
-        let min = u32_to_usize(min);
-        // Using next_inst() is ok, because we can't return it (concat would
-        // have to return Some(_) while c_repeat_range_min_or_more returns
-        // None).
-        let patch_concat = self
-            .c_concat(iter::repeat(expr).take(min))?
-            .unwrap_or_else(|| self.next_inst());
-        if let Some(patch_rep) = self.c_repeat_zero_or_more(expr, greedy)? {
-            self.fill(patch_concat.hole, patch_rep.entry);
-            Ok(Some(Patch { hole: patch_rep.hole, entry: patch_concat.entry }))
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn c_repeat_range(
-        &mut self,
-        expr: &Hir,
-        greedy: bool,
-        min: u32,
-        max: u32,
-    ) -> ResultOrEmpty {
-        let (min, max) = (u32_to_usize(min), u32_to_usize(max));
-        debug_assert!(min <= max);
-        let patch_concat = self.c_concat(iter::repeat(expr).take(min))?;
-        if min == max {
-            return Ok(patch_concat);
-        }
-        // Same reasoning as in c_repeat_range_min_or_more (we know that min <
-        // max at this point).
-        let patch_concat = patch_concat.unwrap_or_else(|| self.next_inst());
-        let initial_entry = patch_concat.entry;
-        // It is much simpler to compile, e.g., `a{2,5}` as:
-        //
-        //     aaa?a?a?
-        //
-        // But you end up with a sequence of instructions like this:
-        //
-        //     0: 'a'
-        //     1: 'a',
-        //     2: split(3, 4)
-        //     3: 'a'
-        //     4: split(5, 6)
-        //     5: 'a'
-        //     6: split(7, 8)
-        //     7: 'a'
-        //     8: MATCH
-        //
-        // This is *incredibly* inefficient because the splits end
-        // up forming a chain, which has to be resolved everything a
-        // transition is followed.
-        let mut holes = vec![];
-        let mut prev_hole = patch_concat.hole;
-        for _ in min..max {
-            self.fill_to_next(prev_hole);
-            let split = self.push_split_hole();
-            let Patch { hole, entry } = match self.c(expr)? {
-                Some(p) => p,
-                None => return self.pop_split_hole(),
-            };
-            prev_hole = hole;
-            if greedy {
-                holes.push(self.fill_split(split, Some(entry), None));
-            } else {
-                holes.push(self.fill_split(split, None, Some(entry)));
-            }
-        }
-        holes.push(prev_hole);
-        Ok(Some(Patch { hole: Hole::Many(holes), entry: initial_entry }))
-    }
-
-    /// Can be used as a default value for the c_* functions when the call to
-    /// c_function is followed by inserting at least one instruction that is
-    /// always executed after the ones written by the c* function.
-    fn next_inst(&self) -> Patch {
-        Patch { hole: Hole::None, entry: self.insts.len() }
-    }
-
-    fn fill(&mut self, hole: Hole, goto: InstPtr) {
-        match hole {
-            Hole::None => {}
-            Hole::One(pc) => {
-                self.insts[pc].fill(goto);
-            }
-            Hole::Many(holes) => {
-                for hole in holes {
-                    self.fill(hole, goto);
-                }
-            }
-        }
-    }
-
-    fn fill_to_next(&mut self, hole: Hole) {
-        let next = self.insts.len();
-        self.fill(hole, next);
-    }
-
-    fn fill_split(
-        &mut self,
-        hole: Hole,
-        goto1: Option<InstPtr>,
-        goto2: Option<InstPtr>,
-    ) -> Hole {
-        match hole {
-            Hole::None => Hole::None,
-            Hole::One(pc) => match (goto1, goto2) {
-                (Some(goto1), Some(goto2)) => {
-                    self.insts[pc].fill_split(goto1, goto2);
-                    Hole::None
-                }
-                (Some(goto1), None) => {
-                    self.insts[pc].half_fill_split_goto1(goto1);
-                    Hole::One(pc)
-                }
-                (None, Some(goto2)) => {
-                    self.insts[pc].half_fill_split_goto2(goto2);
-                    Hole::One(pc)
-                }
-                (None, None) => unreachable!(
-                    "at least one of the split \
-                     holes must be filled"
-                ),
-            },
-            Hole::Many(holes) => {
-                let mut new_holes = vec![];
-                for hole in holes {
-                    new_holes.push(self.fill_split(hole, goto1, goto2));
-                }
-                if new_holes.is_empty() {
-                    Hole::None
-                } else if new_holes.len() == 1 {
-                    new_holes.pop().unwrap()
-                } else {
-                    Hole::Many(new_holes)
-                }
-            }
-        }
-    }
-
-    fn push_compiled(&mut self, inst: Inst) {
-        self.insts.push(MaybeInst::Compiled(inst));
-    }
-
-    fn push_hole(&mut self, inst: InstHole) -> Hole {
-        let hole = self.insts.len();
-        self.insts.push(MaybeInst::Uncompiled(inst));
-        Hole::One(hole)
-    }
-
-    fn push_split_hole(&mut self) -> Hole {
-        let hole = self.insts.len();
-        self.insts.push(MaybeInst::Split);
-        Hole::One(hole)
-    }
-
-    fn pop_split_hole(&mut self) -> ResultOrEmpty {
-        self.insts.pop();
-        Ok(None)
-    }
-
-    fn check_size(&self) -> result::Result<(), Error> {
-        use std::mem::size_of;
-
-        let size =
-            self.extra_inst_bytes + (self.insts.len() * size_of::<Inst>());
-        if size > self.size_limit {
-            Err(Error::CompiledTooBig(self.size_limit))
-        } else {
-            Ok(())
-        }
-    }
-}
-
-#[derive(Debug)]
-enum Hole {
-    None,
-    One(InstPtr),
-    Many(Vec<Hole>),
-}
-
-impl Hole {
-    fn dup_one(self) -> (Self, Self) {
-        match self {
-            Hole::One(pc) => (Hole::One(pc), Hole::One(pc)),
-            Hole::None | Hole::Many(_) => {
-                unreachable!("must be called on single hole")
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-enum MaybeInst {
-    Compiled(Inst),
-    Uncompiled(InstHole),
-    Split,
-    Split1(InstPtr),
-    Split2(InstPtr),
-}
-
-impl MaybeInst {
-    fn fill(&mut self, goto: InstPtr) {
-        let maybeinst = match *self {
-            MaybeInst::Split => MaybeInst::Split1(goto),
-            MaybeInst::Uncompiled(ref inst) => {
-                MaybeInst::Compiled(inst.fill(goto))
-            }
-            MaybeInst::Split1(goto1) => {
-                MaybeInst::Compiled(Inst::Split(InstSplit {
-                    goto1,
-                    goto2: goto,
-                }))
-            }
-            MaybeInst::Split2(goto2) => {
-                MaybeInst::Compiled(Inst::Split(InstSplit {
-                    goto1: goto,
-                    goto2,
-                }))
-            }
-            _ => unreachable!(
-                "not all instructions were compiled! \
-                 found uncompiled instruction: {:?}",
-                self
-            ),
-        };
-        *self = maybeinst;
-    }
-
-    fn fill_split(&mut self, goto1: InstPtr, goto2: InstPtr) {
-        let filled = match *self {
-            MaybeInst::Split => Inst::Split(InstSplit { goto1, goto2 }),
-            _ => unreachable!(
-                "must be called on Split instruction, \
-                 instead it was called on: {:?}",
-                self
-            ),
-        };
-        *self = MaybeInst::Compiled(filled);
-    }
-
-    fn half_fill_split_goto1(&mut self, goto1: InstPtr) {
-        let half_filled = match *self {
-            MaybeInst::Split => goto1,
-            _ => unreachable!(
-                "must be called on Split instruction, \
-                 instead it was called on: {:?}",
-                self
-            ),
-        };
-        *self = MaybeInst::Split1(half_filled);
-    }
-
-    fn half_fill_split_goto2(&mut self, goto2: InstPtr) {
-        let half_filled = match *self {
-            MaybeInst::Split => goto2,
-            _ => unreachable!(
-                "must be called on Split instruction, \
-                 instead it was called on: {:?}",
-                self
-            ),
-        };
-        *self = MaybeInst::Split2(half_filled);
-    }
-
-    fn unwrap(self) -> Inst {
-        match self {
-            MaybeInst::Compiled(inst) => inst,
-            _ => unreachable!(
-                "must be called on a compiled instruction, \
-                 instead it was called on: {:?}",
-                self
-            ),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-enum InstHole {
-    Save { slot: usize },
-    EmptyLook { look: EmptyLook },
-    Char { c: char },
-    Ranges { ranges: Vec<(char, char)> },
-    Bytes { start: u8, end: u8 },
-}
-
-impl InstHole {
-    fn fill(&self, goto: InstPtr) -> Inst {
-        match *self {
-            InstHole::Save { slot } => Inst::Save(InstSave { goto, slot }),
-            InstHole::EmptyLook { look } => {
-                Inst::EmptyLook(InstEmptyLook { goto, look })
-            }
-            InstHole::Char { c } => Inst::Char(InstChar { goto, c }),
-            InstHole::Ranges { ref ranges } => Inst::Ranges(InstRanges {
-                goto,
-                ranges: ranges.clone().into_boxed_slice(),
-            }),
-            InstHole::Bytes { start, end } => {
-                Inst::Bytes(InstBytes { goto, start, end })
-            }
-        }
-    }
-}
-
-struct CompileClass<'a, 'b> {
-    c: &'a mut Compiler,
-    ranges: &'b [hir::ClassUnicodeRange],
-}
-
-impl<'a, 'b> CompileClass<'a, 'b> {
-    fn compile(mut self) -> Result {
-        let mut holes = vec![];
-        let mut initial_entry = None;
-        let mut last_split = Hole::None;
-        let mut utf8_seqs = self.c.utf8_seqs.take().unwrap();
-        self.c.suffix_cache.clear();
-
-        for (i, range) in self.ranges.iter().enumerate() {
-            let is_last_range = i + 1 == self.ranges.len();
-            utf8_seqs.reset(range.start(), range.end());
-            let mut it = (&mut utf8_seqs).peekable();
-            loop {
-                let utf8_seq = match it.next() {
-                    None => break,
-                    Some(utf8_seq) => utf8_seq,
-                };
-                if is_last_range && it.peek().is_none() {
-                    let Patch { hole, entry } = self.c_utf8_seq(&utf8_seq)?;
-                    holes.push(hole);
-                    self.c.fill(last_split, entry);
-                    last_split = Hole::None;
-                    if initial_entry.is_none() {
-                        initial_entry = Some(entry);
-                    }
-                } else {
-                    if initial_entry.is_none() {
-                        initial_entry = Some(self.c.insts.len());
-                    }
-                    self.c.fill_to_next(last_split);
-                    last_split = self.c.push_split_hole();
-                    let Patch { hole, entry } = self.c_utf8_seq(&utf8_seq)?;
-                    holes.push(hole);
-                    last_split =
-                        self.c.fill_split(last_split, Some(entry), None);
-                }
-            }
-        }
-        self.c.utf8_seqs = Some(utf8_seqs);
-        Ok(Patch { hole: Hole::Many(holes), entry: initial_entry.unwrap() })
-    }
-
-    fn c_utf8_seq(&mut self, seq: &Utf8Sequence) -> Result {
-        if self.c.compiled.is_reverse {
-            self.c_utf8_seq_(seq)
-        } else {
-            self.c_utf8_seq_(seq.into_iter().rev())
-        }
-    }
-
-    fn c_utf8_seq_<'r, I>(&mut self, seq: I) -> Result
-    where
-        I: IntoIterator<Item = &'r Utf8Range>,
-    {
-        // The initial instruction for each UTF-8 sequence should be the same.
-        let mut from_inst = ::std::usize::MAX;
-        let mut last_hole = Hole::None;
-        for byte_range in seq {
-            let key = SuffixCacheKey {
-                from_inst,
-                start: byte_range.start,
-                end: byte_range.end,
-            };
-            {
-                let pc = self.c.insts.len();
-                if let Some(cached_pc) = self.c.suffix_cache.get(key, pc) {
-                    from_inst = cached_pc;
-                    continue;
-                }
-            }
-            self.c.byte_classes.set_range(byte_range.start, byte_range.end);
-            if from_inst == ::std::usize::MAX {
-                last_hole = self.c.push_hole(InstHole::Bytes {
-                    start: byte_range.start,
-                    end: byte_range.end,
-                });
-            } else {
-                self.c.push_compiled(Inst::Bytes(InstBytes {
-                    goto: from_inst,
-                    start: byte_range.start,
-                    end: byte_range.end,
-                }));
-            }
-            from_inst = self.c.insts.len().checked_sub(1).unwrap();
-            debug_assert!(from_inst < ::std::usize::MAX);
-        }
-        debug_assert!(from_inst < ::std::usize::MAX);
-        Ok(Patch { hole: last_hole, entry: from_inst })
-    }
-}
-
-/// `SuffixCache` is a simple bounded hash map for caching suffix entries in
-/// UTF-8 automata. For example, consider the Unicode range \u{0}-\u{FFFF}.
-/// The set of byte ranges looks like this:
-///
-/// [0-7F]
-/// [C2-DF][80-BF]
-/// [E0][A0-BF][80-BF]
-/// [E1-EC][80-BF][80-BF]
-/// [ED][80-9F][80-BF]
-/// [EE-EF][80-BF][80-BF]
-///
-/// Each line above translates to one alternate in the compiled regex program.
-/// However, all but one of the alternates end in the same suffix, which is
-/// a waste of an instruction. The suffix cache facilitates reusing them across
-/// alternates.
-///
-/// Note that a HashMap could be trivially used for this, but we don't need its
-/// overhead. Some small bounded space (LRU style) is more than enough.
-///
-/// This uses similar idea to [`SparseSet`](../sparse/struct.SparseSet.html),
-/// except it uses hashes as original indices and then compares full keys for
-/// validation against `dense` array.
-#[derive(Debug)]
-struct SuffixCache {
-    sparse: Box<[usize]>,
-    dense: Vec<SuffixCacheEntry>,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-struct SuffixCacheEntry {
-    key: SuffixCacheKey,
-    pc: InstPtr,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-struct SuffixCacheKey {
-    from_inst: InstPtr,
-    start: u8,
-    end: u8,
-}
-
-impl SuffixCache {
-    fn new(size: usize) -> Self {
-        SuffixCache {
-            sparse: vec![0usize; size].into(),
-            dense: Vec::with_capacity(size),
-        }
-    }
-
-    fn get(&mut self, key: SuffixCacheKey, pc: InstPtr) -> Option<InstPtr> {
-        let hash = self.hash(&key);
-        let pos = &mut self.sparse[hash];
-        if let Some(entry) = self.dense.get(*pos) {
-            if entry.key == key {
-                return Some(entry.pc);
-            }
-        }
-        *pos = self.dense.len();
-        self.dense.push(SuffixCacheEntry { key, pc });
-        None
-    }
-
-    fn clear(&mut self) {
-        self.dense.clear();
-    }
-
-    fn hash(&self, suffix: &SuffixCacheKey) -> usize {
-        // Basic FNV-1a hash as described:
-        // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-        const FNV_PRIME: u64 = 1_099_511_628_211;
-        let mut h = 14_695_981_039_346_656_037;
-        h = (h ^ (suffix.from_inst as u64)).wrapping_mul(FNV_PRIME);
-        h = (h ^ (suffix.start as u64)).wrapping_mul(FNV_PRIME);
-        h = (h ^ (suffix.end as u64)).wrapping_mul(FNV_PRIME);
-        (h as usize) % self.sparse.len()
-    }
-}
-
-struct ByteClassSet([bool; 256]);
-
-impl ByteClassSet {
-    fn new() -> Self {
-        ByteClassSet([false; 256])
-    }
-
-    fn set_range(&mut self, start: u8, end: u8) {
-        debug_assert!(start <= end);
-        if start > 0 {
-            self.0[start as usize - 1] = true;
-        }
-        self.0[end as usize] = true;
-    }
-
-    fn set_word_boundary(&mut self) {
-        // We need to mark all ranges of bytes whose pairs result in
-        // evaluating \b differently.
-        let iswb = is_word_byte;
-        let mut b1: u16 = 0;
-        let mut b2: u16;
-        while b1 <= 255 {
-            b2 = b1 + 1;
-            while b2 <= 255 && iswb(b1 as u8) == iswb(b2 as u8) {
-                b2 += 1;
-            }
-            self.set_range(b1 as u8, (b2 - 1) as u8);
-            b1 = b2;
-        }
-    }
-
-    fn byte_classes(&self) -> Vec<u8> {
-        // N.B. If you're debugging the DFA, it's useful to simply return
-        // `(0..256).collect()`, which effectively removes the byte classes
-        // and makes the transitions easier to read.
-        // (0usize..256).map(|x| x as u8).collect()
-        let mut byte_classes = vec![0; 256];
-        let mut class = 0u8;
-        let mut i = 0;
-        loop {
-            byte_classes[i] = class as u8;
-            if i >= 255 {
-                break;
-            }
-            if self.0[i] {
-                class = class.checked_add(1).unwrap();
-            }
-            i += 1;
-        }
-        byte_classes
-    }
-}
-
-impl fmt::Debug for ByteClassSet {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("ByteClassSet").field(&&self.0[..]).finish()
-    }
-}
-
-fn u32_to_usize(n: u32) -> usize {
-    // In case usize is less than 32 bits, we need to guard against overflow.
-    // On most platforms this compiles to nothing.
-    // TODO Use `std::convert::TryFrom` once it's stable.
-    if (n as u64) > (::std::usize::MAX as u64) {
-        panic!("BUG: {} is too big to be pointer sized", n)
-    }
-    n as usize
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ByteClassSet;
-
-    #[test]
-    fn byte_classes() {
-        let mut set = ByteClassSet::new();
-        set.set_range(b'a', b'z');
-        let classes = set.byte_classes();
-        assert_eq!(classes[0], 0);
-        assert_eq!(classes[1], 0);
-        assert_eq!(classes[2], 0);
-        assert_eq!(classes[b'a' as usize - 1], 0);
-        assert_eq!(classes[b'a' as usize], 1);
-        assert_eq!(classes[b'm' as usize], 1);
-        assert_eq!(classes[b'z' as usize], 1);
-        assert_eq!(classes[b'z' as usize + 1], 2);
-        assert_eq!(classes[254], 2);
-        assert_eq!(classes[255], 2);
-
-        let mut set = ByteClassSet::new();
-        set.set_range(0, 2);
-        set.set_range(4, 6);
-        let classes = set.byte_classes();
-        assert_eq!(classes[0], 0);
-        assert_eq!(classes[1], 0);
-        assert_eq!(classes[2], 0);
-        assert_eq!(classes[3], 1);
-        assert_eq!(classes[4], 2);
-        assert_eq!(classes[5], 2);
-        assert_eq!(classes[6], 2);
-        assert_eq!(classes[7], 3);
-        assert_eq!(classes[255], 3);
-    }
-
-    #[test]
-    fn full_byte_classes() {
-        let mut set = ByteClassSet::new();
-        for i in 0..256u16 {
-            set.set_range(i as u8, i as u8);
-        }
-        assert_eq!(set.byte_classes().len(), 256);
-    }
-}
diff --git a/src/dfa.rs b/src/dfa.rs
deleted file mode 100644
index 78ed71021e..0000000000
--- a/src/dfa.rs
+++ /dev/null
@@ -1,1945 +0,0 @@
-/*!
-The DFA matching engine.
-
-A DFA provides faster matching because the engine is in exactly one state at
-any point in time. In the NFA, there may be multiple active states, and
-considerable CPU cycles are spent shuffling them around. In finite automata
-speak, the DFA follows epsilon transitions in the regex far less than the NFA.
-
-A DFA is a classic trade off between time and space. The NFA is slower, but
-its memory requirements are typically small and predictable. The DFA is faster,
-but given the right regex and the right input, the number of states in the
-DFA can grow exponentially. To mitigate this space problem, we do two things:
-
-1. We implement an *online* DFA. That is, the DFA is constructed from the NFA
-   during a search. When a new state is computed, it is stored in a cache so
-   that it may be reused. An important consequence of this implementation
-   is that states that are never reached for a particular input are never
-   computed. (This is impossible in an "offline" DFA which needs to compute
-   all possible states up front.)
-2. If the cache gets too big, we wipe it and continue matching.
-
-In pathological cases, a new state can be created for every byte of input.
-(e.g., The regex `(a|b)*a(a|b){20}` on a long sequence of a's and b's.)
-In this case, performance regresses to slightly slower than the full NFA
-simulation, in large part because the cache becomes useless. If the cache
-is wiped too frequently, the DFA quits and control falls back to one of the
-NFA simulations.
-
-Because of the "lazy" nature of this DFA, the inner matching loop is
-considerably more complex than one might expect out of a DFA. A number of
-tricks are employed to make it fast. Tread carefully.
-
-N.B. While this implementation is heavily commented, Russ Cox's series of
-articles on regexes is strongly recommended: <https://swtch.com/~rsc/regexp/>
-(As is the DFA implementation in RE2, which heavily influenced this
-implementation.)
-*/
-
-use std::collections::HashMap;
-use std::fmt;
-use std::iter::repeat;
-use std::mem;
-use std::sync::Arc;
-
-use crate::exec::ProgramCache;
-use crate::prog::{Inst, Program};
-use crate::sparse::SparseSet;
-
-/// Return true if and only if the given program can be executed by a DFA.
-///
-/// Generally, a DFA is always possible. A pathological case where it is not
-/// possible is if the number of NFA states exceeds `u32::MAX`, in which case,
-/// this function will return false.
-///
-/// This function will also return false if the given program has any Unicode
-/// instructions (Char or Ranges) since the DFA operates on bytes only.
-pub fn can_exec(insts: &Program) -> bool {
-    use crate::prog::Inst::*;
-    // If for some reason we manage to allocate a regex program with more
-    // than i32::MAX instructions, then we can't execute the DFA because we
-    // use 32 bit instruction pointer deltas for memory savings.
-    // If i32::MAX is the largest positive delta,
-    // then -i32::MAX == i32::MIN + 1 is the largest negative delta,
-    // and we are OK to use 32 bits.
-    if insts.dfa_size_limit == 0 || insts.len() > ::std::i32::MAX as usize {
-        return false;
-    }
-    for inst in insts {
-        match *inst {
-            Char(_) | Ranges(_) => return false,
-            EmptyLook(_) | Match(_) | Save(_) | Split(_) | Bytes(_) => {}
-        }
-    }
-    true
-}
-
-/// A reusable cache of DFA states.
-///
-/// This cache is reused between multiple invocations of the same regex
-/// program. (It is not shared simultaneously between threads. If there is
-/// contention, then new caches are created.)
-#[derive(Debug)]
-pub struct Cache {
-    /// Group persistent DFA related cache state together. The sparse sets
-    /// listed below are used as scratch space while computing uncached states.
-    inner: CacheInner,
-    /// qcur and qnext are ordered sets with constant time
-    /// addition/membership/clearing-whole-set and linear time iteration. They
-    /// are used to manage the sets of NFA states in DFA states when computing
-    /// cached DFA states. In particular, the order of the NFA states matters
-    /// for leftmost-first style matching. Namely, when computing a cached
-    /// state, the set of NFA states stops growing as soon as the first Match
-    /// instruction is observed.
-    qcur: SparseSet,
-    qnext: SparseSet,
-}
-
-/// `CacheInner` is logically just a part of Cache, but groups together fields
-/// that aren't passed as function parameters throughout search. (This split
-/// is mostly an artifact of the borrow checker. It is happily paid.)
-#[derive(Debug)]
-struct CacheInner {
-    /// A cache of pre-compiled DFA states, keyed by the set of NFA states
-    /// and the set of empty-width flags set at the byte in the input when the
-    /// state was observed.
-    ///
-    /// A StatePtr is effectively a `*State`, but to avoid various inconvenient
-    /// things, we just pass indexes around manually. The performance impact of
-    /// this is probably an instruction or two in the inner loop. However, on
-    /// 64 bit, each StatePtr is half the size of a *State.
-    compiled: StateMap,
-    /// The transition table.
-    ///
-    /// The transition table is laid out in row-major order, where states are
-    /// rows and the transitions for each state are columns. At a high level,
-    /// given state `s` and byte `b`, the next state can be found at index
-    /// `s * 256 + b`.
-    ///
-    /// This is, of course, a lie. A StatePtr is actually a pointer to the
-    /// *start* of a row in this table. When indexing in the DFA's inner loop,
-    /// this removes the need to multiply the StatePtr by the stride. Yes, it
-    /// matters. This reduces the number of states we can store, but: the
-    /// stride is rarely 256 since we define transitions in terms of
-    /// *equivalence classes* of bytes. Each class corresponds to a set of
-    /// bytes that never discriminate a distinct path through the DFA from each
-    /// other.
-    trans: Transitions,
-    /// A set of cached start states, which are limited to the number of
-    /// permutations of flags set just before the initial byte of input. (The
-    /// index into this vec is a `EmptyFlags`.)
-    ///
-    /// N.B. A start state can be "dead" (i.e., no possible match), so we
-    /// represent it with a StatePtr.
-    start_states: Vec<StatePtr>,
-    /// Stack scratch space used to follow epsilon transitions in the NFA.
-    /// (This permits us to avoid recursion.)
-    ///
-    /// The maximum stack size is the number of NFA states.
-    stack: Vec<InstPtr>,
-    /// The total number of times this cache has been flushed by the DFA
-    /// because of space constraints.
-    flush_count: u64,
-    /// The total heap size of the DFA's cache. We use this to determine when
-    /// we should flush the cache.
-    size: usize,
-    /// Scratch space used when building instruction pointer lists for new
-    /// states. This helps amortize allocation.
-    insts_scratch_space: Vec<u8>,
-}
-
-/// The transition table.
-///
-/// It is laid out in row-major order, with states as rows and byte class
-/// transitions as columns.
-///
-/// The transition table is responsible for producing valid `StatePtrs`. A
-/// `StatePtr` points to the start of a particular row in this table. When
-/// indexing to find the next state this allows us to avoid a multiplication
-/// when computing an index into the table.
-#[derive(Clone)]
-struct Transitions {
-    /// The table.
-    table: Vec<StatePtr>,
-    /// The stride.
-    num_byte_classes: usize,
-}
-
-/// Fsm encapsulates the actual execution of the DFA.
-#[derive(Debug)]
-pub struct Fsm<'a> {
-    /// prog contains the NFA instruction opcodes. DFA execution uses either
-    /// the `dfa` instructions or the `dfa_reverse` instructions from
-    /// `exec::ExecReadOnly`. (It never uses `ExecReadOnly.nfa`, which may have
-    /// Unicode opcodes that cannot be executed by the DFA.)
-    prog: &'a Program,
-    /// The start state. We record it here because the pointer may change
-    /// when the cache is wiped.
-    start: StatePtr,
-    /// The current position in the input.
-    at: usize,
-    /// Should we quit after seeing the first match? e.g., When the caller
-    /// uses `is_match` or `shortest_match`.
-    quit_after_match: bool,
-    /// The last state that matched.
-    ///
-    /// When no match has occurred, this is set to STATE_UNKNOWN.
-    ///
-    /// This is only useful when matching regex sets. The last match state
-    /// is useful because it contains all of the match instructions seen,
-    /// thereby allowing us to enumerate which regexes in the set matched.
-    last_match_si: StatePtr,
-    /// The input position of the last cache flush. We use this to determine
-    /// if we're thrashing in the cache too often. If so, the DFA quits so
-    /// that we can fall back to the NFA algorithm.
-    last_cache_flush: usize,
-    /// All cached DFA information that is persisted between searches.
-    cache: &'a mut CacheInner,
-}
-
-/// The result of running the DFA.
-///
-/// Generally, the result is either a match or not a match, but sometimes the
-/// DFA runs too slowly because the cache size is too small. In that case, it
-/// gives up with the intent of falling back to the NFA algorithm.
-///
-/// The DFA can also give up if it runs out of room to create new states, or if
-/// it sees non-ASCII bytes in the presence of a Unicode word boundary.
-#[derive(Clone, Debug)]
-pub enum Result<T> {
-    Match(T),
-    NoMatch(usize),
-    Quit,
-}
-
-impl<T> Result<T> {
-    /// Returns true if this result corresponds to a match.
-    pub fn is_match(&self) -> bool {
-        match *self {
-            Result::Match(_) => true,
-            Result::NoMatch(_) | Result::Quit => false,
-        }
-    }
-
-    /// Maps the given function onto T and returns the result.
-    ///
-    /// If this isn't a match, then this is a no-op.
-    #[cfg(feature = "perf-literal")]
-    pub fn map<U, F: FnMut(T) -> U>(self, mut f: F) -> Result<U> {
-        match self {
-            Result::Match(t) => Result::Match(f(t)),
-            Result::NoMatch(x) => Result::NoMatch(x),
-            Result::Quit => Result::Quit,
-        }
-    }
-
-    /// Sets the non-match position.
-    ///
-    /// If this isn't a non-match, then this is a no-op.
-    fn set_non_match(self, at: usize) -> Result<T> {
-        match self {
-            Result::NoMatch(_) => Result::NoMatch(at),
-            r => r,
-        }
-    }
-}
-
-/// `State` is a DFA state. It contains an ordered set of NFA states (not
-/// necessarily complete) and a smattering of flags.
-///
-/// The flags are packed into the first byte of data.
-///
-/// States don't carry their transitions. Instead, transitions are stored in
-/// a single row-major table.
-///
-/// Delta encoding is used to store the instruction pointers.
-/// The first instruction pointer is stored directly starting
-/// at data[1], and each following pointer is stored as an offset
-/// to the previous one. If a delta is in the range -127..127,
-/// it is packed into a single byte; Otherwise the byte 128 (-128 as an i8)
-/// is coded as a flag, followed by 4 bytes encoding the delta.
-#[derive(Clone, Eq, Hash, PartialEq)]
-struct State {
-    data: Arc<[u8]>,
-}
-
-/// `InstPtr` is a 32 bit pointer into a sequence of opcodes (i.e., it indexes
-/// an NFA state).
-///
-/// Throughout this library, this is usually set to `usize`, but we force a
-/// `u32` here for the DFA to save on space.
-type InstPtr = u32;
-
-/// Adds ip to data using delta encoding with respect to prev.
-///
-/// After completion, `data` will contain `ip` and `prev` will be set to `ip`.
-fn push_inst_ptr(data: &mut Vec<u8>, prev: &mut InstPtr, ip: InstPtr) {
-    let delta = (ip as i32) - (*prev as i32);
-    write_vari32(data, delta);
-    *prev = ip;
-}
-
-struct InstPtrs<'a> {
-    base: usize,
-    data: &'a [u8],
-}
-
-impl<'a> Iterator for InstPtrs<'a> {
-    type Item = usize;
-
-    fn next(&mut self) -> Option<usize> {
-        if self.data.is_empty() {
-            return None;
-        }
-        let (delta, nread) = read_vari32(self.data);
-        let base = self.base as i32 + delta;
-        debug_assert!(base >= 0);
-        debug_assert!(nread > 0);
-        self.data = &self.data[nread..];
-        self.base = base as usize;
-        Some(self.base)
-    }
-}
-
-impl State {
-    fn flags(&self) -> StateFlags {
-        StateFlags(self.data[0])
-    }
-
-    fn inst_ptrs(&self) -> InstPtrs<'_> {
-        InstPtrs { base: 0, data: &self.data[1..] }
-    }
-}
-
-/// `StatePtr` is a 32 bit pointer to the start of a row in the transition
-/// table.
-///
-/// It has many special values. There are two types of special values:
-/// sentinels and flags.
-///
-/// Sentinels corresponds to special states that carry some kind of
-/// significance. There are three such states: unknown, dead and quit states.
-///
-/// Unknown states are states that haven't been computed yet. They indicate
-/// that a transition should be filled in that points to either an existing
-/// cached state or a new state altogether. In general, an unknown state means
-/// "follow the NFA's epsilon transitions."
-///
-/// Dead states are states that can never lead to a match, no matter what
-/// subsequent input is observed. This means that the DFA should quit
-/// immediately and return the longest match it has found thus far.
-///
-/// Quit states are states that imply the DFA is not capable of matching the
-/// regex correctly. Currently, this is only used when a Unicode word boundary
-/// exists in the regex *and* a non-ASCII byte is observed.
-///
-/// The other type of state pointer is a state pointer with special flag bits.
-/// There are two flags: a start flag and a match flag. The lower bits of both
-/// kinds always contain a "valid" `StatePtr` (indicated by the `STATE_MAX`
-/// mask).
-///
-/// The start flag means that the state is a start state, and therefore may be
-/// subject to special prefix scanning optimizations.
-///
-/// The match flag means that the state is a match state, and therefore the
-/// current position in the input (while searching) should be recorded.
-///
-/// The above exists mostly in the service of making the inner loop fast.
-/// In particular, the inner *inner* loop looks something like this:
-///
-/// ```ignore
-/// while state <= STATE_MAX and i < len(text):
-///     state = state.next[i]
-/// ```
-///
-/// This is nice because it lets us execute a lazy DFA as if it were an
-/// entirely offline DFA (i.e., with very few instructions). The loop will
-/// quit only when we need to examine a case that needs special attention.
-type StatePtr = u32;
-
-/// An unknown state means that the state has not been computed yet, and that
-/// the only way to progress is to compute it.
-const STATE_UNKNOWN: StatePtr = 1 << 31;
-
-/// A dead state means that the state has been computed and it is known that
-/// once it is entered, no future match can ever occur.
-const STATE_DEAD: StatePtr = STATE_UNKNOWN + 1;
-
-/// A quit state means that the DFA came across some input that it doesn't
-/// know how to process correctly. The DFA should quit and another matching
-/// engine should be run in its place.
-const STATE_QUIT: StatePtr = STATE_DEAD + 1;
-
-/// A start state is a state that the DFA can start in.
-///
-/// Note that start states have their lower bits set to a state pointer.
-const STATE_START: StatePtr = 1 << 30;
-
-/// A match state means that the regex has successfully matched.
-///
-/// Note that match states have their lower bits set to a state pointer.
-const STATE_MATCH: StatePtr = 1 << 29;
-
-/// The maximum state pointer. This is useful to mask out the "valid" state
-/// pointer from a state with the "start" or "match" bits set.
-///
-/// It doesn't make sense to use this with unknown, dead or quit state
-/// pointers, since those pointers are sentinels and never have their lower
-/// bits set to anything meaningful.
-const STATE_MAX: StatePtr = STATE_MATCH - 1;
-
-/// Byte is a u8 in spirit, but a u16 in practice so that we can represent the
-/// special EOF sentinel value.
-#[derive(Copy, Clone, Debug)]
-struct Byte(u16);
-
-/// A set of flags for zero-width assertions.
-#[derive(Clone, Copy, Eq, Debug, Default, Hash, PartialEq)]
-struct EmptyFlags {
-    start: bool,
-    end: bool,
-    start_line: bool,
-    end_line: bool,
-    word_boundary: bool,
-    not_word_boundary: bool,
-}
-
-/// A set of flags describing various configurations of a DFA state. This is
-/// represented by a `u8` so that it is compact.
-#[derive(Clone, Copy, Eq, Default, Hash, PartialEq)]
-struct StateFlags(u8);
-
-impl Cache {
-    /// Create new empty cache for the DFA engine.
-    pub fn new(prog: &Program) -> Self {
-        // We add 1 to account for the special EOF byte.
-        let num_byte_classes = (prog.byte_classes[255] as usize + 1) + 1;
-        let starts = vec![STATE_UNKNOWN; 256];
-        let mut cache = Cache {
-            inner: CacheInner {
-                compiled: StateMap::new(num_byte_classes),
-                trans: Transitions::new(num_byte_classes),
-                start_states: starts,
-                stack: vec![],
-                flush_count: 0,
-                size: 0,
-                insts_scratch_space: vec![],
-            },
-            qcur: SparseSet::new(prog.insts.len()),
-            qnext: SparseSet::new(prog.insts.len()),
-        };
-        cache.inner.reset_size();
-        cache
-    }
-}
-
-impl CacheInner {
-    /// Resets the cache size to account for fixed costs, such as the program
-    /// and stack sizes.
-    fn reset_size(&mut self) {
-        self.size = (self.start_states.len() * mem::size_of::<StatePtr>())
-            + (self.stack.len() * mem::size_of::<InstPtr>());
-    }
-}
-
-impl<'a> Fsm<'a> {
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn forward(
-        prog: &'a Program,
-        cache: &ProgramCache,
-        quit_after_match: bool,
-        text: &[u8],
-        at: usize,
-    ) -> Result<usize> {
-        let mut cache = cache.borrow_mut();
-        let cache = &mut cache.dfa;
-        let mut dfa = Fsm {
-            prog,
-            start: 0, // filled in below
-            at,
-            quit_after_match,
-            last_match_si: STATE_UNKNOWN,
-            last_cache_flush: at,
-            cache: &mut cache.inner,
-        };
-        let (empty_flags, state_flags) = dfa.start_flags(text, at);
-        dfa.start =
-            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
-                None => return Result::Quit,
-                Some(STATE_DEAD) => return Result::NoMatch(at),
-                Some(si) => si,
-            };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
-        dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn reverse(
-        prog: &'a Program,
-        cache: &ProgramCache,
-        quit_after_match: bool,
-        text: &[u8],
-        at: usize,
-    ) -> Result<usize> {
-        let mut cache = cache.borrow_mut();
-        let cache = &mut cache.dfa_reverse;
-        let mut dfa = Fsm {
-            prog,
-            start: 0, // filled in below
-            at,
-            quit_after_match,
-            last_match_si: STATE_UNKNOWN,
-            last_cache_flush: at,
-            cache: &mut cache.inner,
-        };
-        let (empty_flags, state_flags) = dfa.start_flags_reverse(text, at);
-        dfa.start =
-            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
-                None => return Result::Quit,
-                Some(STATE_DEAD) => return Result::NoMatch(at),
-                Some(si) => si,
-            };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
-        dfa.exec_at_reverse(&mut cache.qcur, &mut cache.qnext, text)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn forward_many(
-        prog: &'a Program,
-        cache: &ProgramCache,
-        matches: &mut [bool],
-        text: &[u8],
-        at: usize,
-    ) -> Result<usize> {
-        debug_assert!(matches.len() == prog.matches.len());
-        let mut cache = cache.borrow_mut();
-        let cache = &mut cache.dfa;
-        let mut dfa = Fsm {
-            prog,
-            start: 0, // filled in below
-            at,
-            quit_after_match: false,
-            last_match_si: STATE_UNKNOWN,
-            last_cache_flush: at,
-            cache: &mut cache.inner,
-        };
-        let (empty_flags, state_flags) = dfa.start_flags(text, at);
-        dfa.start =
-            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
-                None => return Result::Quit,
-                Some(STATE_DEAD) => return Result::NoMatch(at),
-                Some(si) => si,
-            };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
-        let result = dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text);
-        if result.is_match() {
-            if matches.len() == 1 {
-                matches[0] = true;
-            } else {
-                debug_assert!(dfa.last_match_si != STATE_UNKNOWN);
-                debug_assert!(dfa.last_match_si != STATE_DEAD);
-                for ip in dfa.state(dfa.last_match_si).inst_ptrs() {
-                    if let Inst::Match(slot) = dfa.prog[ip] {
-                        matches[slot] = true;
-                    }
-                }
-            }
-        }
-        result
-    }
-
-    /// Executes the DFA on a forward NFA.
-    ///
-    /// {qcur,qnext} are scratch ordered sets which may be non-empty.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn exec_at(
-        &mut self,
-        qcur: &mut SparseSet,
-        qnext: &mut SparseSet,
-        text: &[u8],
-    ) -> Result<usize> {
-        // For the most part, the DFA is basically:
-        //
-        //   last_match = null
-        //   while current_byte != EOF:
-        //     si = current_state.next[current_byte]
-        //     if si is match
-        //       last_match = si
-        //   return last_match
-        //
-        // However, we need to deal with a few things:
-        //
-        //   1. This is an *online* DFA, so the current state's next list
-        //      may not point to anywhere yet, so we must go out and compute
-        //      them. (They are then cached into the current state's next list
-        //      to avoid re-computation.)
-        //   2. If we come across a state that is known to be dead (i.e., never
-        //      leads to a match), then we can quit early.
-        //   3. If the caller just wants to know if a match occurs, then we
-        //      can quit as soon as we know we have a match. (Full leftmost
-        //      first semantics require continuing on.)
-        //   4. If we're in the start state, then we can use a pre-computed set
-        //      of prefix literals to skip quickly along the input.
-        //   5. After the input is exhausted, we run the DFA on one symbol
-        //      that stands for EOF. This is useful for handling empty width
-        //      assertions.
-        //   6. We can't actually do state.next[byte]. Instead, we have to do
-        //      state.next[byte_classes[byte]], which permits us to keep the
-        //      'next' list very small.
-        //
-        // Since there's a bunch of extra stuff we need to consider, we do some
-        // pretty hairy tricks to get the inner loop to run as fast as
-        // possible.
-        debug_assert!(!self.prog.is_reverse);
-
-        // The last match is the currently known ending match position. It is
-        // reported as an index to the most recent byte that resulted in a
-        // transition to a match state and is always stored in capture slot `1`
-        // when searching forwards. Its maximum value is `text.len()`.
-        let mut result = Result::NoMatch(self.at);
-        let (mut prev_si, mut next_si) = (self.start, self.start);
-        let mut at = self.at;
-        while at < text.len() {
-            // This is the real inner loop. We take advantage of special bits
-            // set in the state pointer to determine whether a state is in the
-            // "common" case or not. Specifically, the common case is a
-            // non-match non-start non-dead state that has already been
-            // computed. So long as we remain in the common case, this inner
-            // loop will chew through the input.
-            //
-            // We also unroll the loop 4 times to amortize the cost of checking
-            // whether we've consumed the entire input. We are also careful
-            // to make sure that `prev_si` always represents the previous state
-            // and `next_si` always represents the next state after the loop
-            // exits, even if it isn't always true inside the loop.
-            while next_si <= STATE_MAX && at < text.len() {
-                // Argument for safety is in the definition of next_si.
-                prev_si = unsafe { self.next_si(next_si, text, at) };
-                at += 1;
-                if prev_si > STATE_MAX || at + 2 >= text.len() {
-                    mem::swap(&mut prev_si, &mut next_si);
-                    break;
-                }
-                next_si = unsafe { self.next_si(prev_si, text, at) };
-                at += 1;
-                if next_si > STATE_MAX {
-                    break;
-                }
-                prev_si = unsafe { self.next_si(next_si, text, at) };
-                at += 1;
-                if prev_si > STATE_MAX {
-                    mem::swap(&mut prev_si, &mut next_si);
-                    break;
-                }
-                next_si = unsafe { self.next_si(prev_si, text, at) };
-                at += 1;
-            }
-            if next_si & STATE_MATCH > 0 {
-                // A match state is outside of the common case because it needs
-                // special case analysis. In particular, we need to record the
-                // last position as having matched and possibly quit the DFA if
-                // we don't need to keep matching.
-                next_si &= !STATE_MATCH;
-                result = Result::Match(at - 1);
-                if self.quit_after_match {
-                    return result;
-                }
-                self.last_match_si = next_si;
-                prev_si = next_si;
-
-                // This permits short-circuiting when matching a regex set.
-                // In particular, if this DFA state contains only match states,
-                // then it's impossible to extend the set of matches since
-                // match states are final. Therefore, we can quit.
-                if self.prog.matches.len() > 1 {
-                    let state = self.state(next_si);
-                    let just_matches =
-                        state.inst_ptrs().all(|ip| self.prog[ip].is_match());
-                    if just_matches {
-                        return result;
-                    }
-                }
-
-                // Another inner loop! If the DFA stays in this particular
-                // match state, then we can rip through all of the input
-                // very quickly, and only recording the match location once
-                // we've left this particular state.
-                let cur = at;
-                while (next_si & !STATE_MATCH) == prev_si
-                    && at + 2 < text.len()
-                {
-                    // Argument for safety is in the definition of next_si.
-                    next_si = unsafe {
-                        self.next_si(next_si & !STATE_MATCH, text, at)
-                    };
-                    at += 1;
-                }
-                if at > cur {
-                    result = Result::Match(at - 2);
-                }
-            } else if next_si & STATE_START > 0 {
-                // A start state isn't in the common case because we may
-                // want to do quick prefix scanning. If the program doesn't
-                // have a detected prefix, then start states are actually
-                // considered common and this case is never reached.
-                debug_assert!(self.has_prefix());
-                next_si &= !STATE_START;
-                prev_si = next_si;
-                at = match self.prefix_at(text, at) {
-                    None => return Result::NoMatch(text.len()),
-                    Some(i) => i,
-                };
-            } else if next_si >= STATE_UNKNOWN {
-                if next_si == STATE_QUIT {
-                    return Result::Quit;
-                }
-                // Finally, this corresponds to the case where the transition
-                // entered a state that can never lead to a match or a state
-                // that hasn't been computed yet. The latter being the "slow"
-                // path.
-                let byte = Byte::byte(text[at - 1]);
-                // We no longer care about the special bits in the state
-                // pointer.
-                prev_si &= STATE_MAX;
-                // Record where we are. This is used to track progress for
-                // determining whether we should quit if we've flushed the
-                // cache too much.
-                self.at = at;
-                next_si = match self.next_state(qcur, qnext, prev_si, byte) {
-                    None => return Result::Quit,
-                    Some(STATE_DEAD) => return result.set_non_match(at),
-                    Some(si) => si,
-                };
-                debug_assert!(next_si != STATE_UNKNOWN);
-                if next_si & STATE_MATCH > 0 {
-                    next_si &= !STATE_MATCH;
-                    result = Result::Match(at - 1);
-                    if self.quit_after_match {
-                        return result;
-                    }
-                    self.last_match_si = next_si;
-                }
-                prev_si = next_si;
-            } else {
-                prev_si = next_si;
-            }
-        }
-
-        // Run the DFA once more on the special EOF sentinel value.
-        // We don't care about the special bits in the state pointer any more,
-        // so get rid of them.
-        prev_si &= STATE_MAX;
-        prev_si = match self.next_state(qcur, qnext, prev_si, Byte::eof()) {
-            None => return Result::Quit,
-            Some(STATE_DEAD) => return result.set_non_match(text.len()),
-            Some(si) => si & !STATE_START,
-        };
-        debug_assert!(prev_si != STATE_UNKNOWN);
-        if prev_si & STATE_MATCH > 0 {
-            prev_si &= !STATE_MATCH;
-            self.last_match_si = prev_si;
-            result = Result::Match(text.len());
-        }
-        result
-    }
-
-    /// Executes the DFA on a reverse NFA.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn exec_at_reverse(
-        &mut self,
-        qcur: &mut SparseSet,
-        qnext: &mut SparseSet,
-        text: &[u8],
-    ) -> Result<usize> {
-        // The comments in `exec_at` above mostly apply here too. The main
-        // difference is that we move backwards over the input and we look for
-        // the longest possible match instead of the leftmost-first match.
-        //
-        // N.B. The code duplication here is regrettable. Efforts to improve
-        // it without sacrificing performance are welcome. ---AG
-        debug_assert!(self.prog.is_reverse);
-        let mut result = Result::NoMatch(self.at);
-        let (mut prev_si, mut next_si) = (self.start, self.start);
-        let mut at = self.at;
-        while at > 0 {
-            while next_si <= STATE_MAX && at > 0 {
-                // Argument for safety is in the definition of next_si.
-                at -= 1;
-                prev_si = unsafe { self.next_si(next_si, text, at) };
-                if prev_si > STATE_MAX || at <= 4 {
-                    mem::swap(&mut prev_si, &mut next_si);
-                    break;
-                }
-                at -= 1;
-                next_si = unsafe { self.next_si(prev_si, text, at) };
-                if next_si > STATE_MAX {
-                    break;
-                }
-                at -= 1;
-                prev_si = unsafe { self.next_si(next_si, text, at) };
-                if prev_si > STATE_MAX {
-                    mem::swap(&mut prev_si, &mut next_si);
-                    break;
-                }
-                at -= 1;
-                next_si = unsafe { self.next_si(prev_si, text, at) };
-            }
-            if next_si & STATE_MATCH > 0 {
-                next_si &= !STATE_MATCH;
-                result = Result::Match(at + 1);
-                if self.quit_after_match {
-                    return result;
-                }
-                self.last_match_si = next_si;
-                prev_si = next_si;
-                let cur = at;
-                while (next_si & !STATE_MATCH) == prev_si && at >= 2 {
-                    // Argument for safety is in the definition of next_si.
-                    at -= 1;
-                    next_si = unsafe {
-                        self.next_si(next_si & !STATE_MATCH, text, at)
-                    };
-                }
-                if at < cur {
-                    result = Result::Match(at + 2);
-                }
-            } else if next_si >= STATE_UNKNOWN {
-                if next_si == STATE_QUIT {
-                    return Result::Quit;
-                }
-                let byte = Byte::byte(text[at]);
-                prev_si &= STATE_MAX;
-                self.at = at;
-                next_si = match self.next_state(qcur, qnext, prev_si, byte) {
-                    None => return Result::Quit,
-                    Some(STATE_DEAD) => return result.set_non_match(at),
-                    Some(si) => si,
-                };
-                debug_assert!(next_si != STATE_UNKNOWN);
-                if next_si & STATE_MATCH > 0 {
-                    next_si &= !STATE_MATCH;
-                    result = Result::Match(at + 1);
-                    if self.quit_after_match {
-                        return result;
-                    }
-                    self.last_match_si = next_si;
-                }
-                prev_si = next_si;
-            } else {
-                prev_si = next_si;
-            }
-        }
-
-        // Run the DFA once more on the special EOF sentinel value.
-        prev_si = match self.next_state(qcur, qnext, prev_si, Byte::eof()) {
-            None => return Result::Quit,
-            Some(STATE_DEAD) => return result.set_non_match(0),
-            Some(si) => si,
-        };
-        debug_assert!(prev_si != STATE_UNKNOWN);
-        if prev_si & STATE_MATCH > 0 {
-            prev_si &= !STATE_MATCH;
-            self.last_match_si = prev_si;
-            result = Result::Match(0);
-        }
-        result
-    }
-
-    /// next_si transitions to the next state, where the transition input
-    /// corresponds to text[i].
-    ///
-    /// This elides bounds checks, and is therefore not safe.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    unsafe fn next_si(&self, si: StatePtr, text: &[u8], i: usize) -> StatePtr {
-        // What is the argument for safety here?
-        // We have three unchecked accesses that could possibly violate safety:
-        //
-        //   1. The given byte of input (`text[i]`).
-        //   2. The class of the byte of input (`classes[text[i]]`).
-        //   3. The transition for the class (`trans[si + cls]`).
-        //
-        // (1) is only safe when calling next_si is guarded by
-        // `i < text.len()`.
-        //
-        // (2) is the easiest case to guarantee since `text[i]` is always a
-        // `u8` and `self.prog.byte_classes` always has length `u8::MAX`.
-        // (See `ByteClassSet.byte_classes` in `compile.rs`.)
-        //
-        // (3) is only safe if (1)+(2) are safe. Namely, the transitions
-        // of every state are defined to have length equal to the number of
-        // byte classes in the program. Therefore, a valid class leads to a
-        // valid transition. (All possible transitions are valid lookups, even
-        // if it points to a state that hasn't been computed yet.) (3) also
-        // relies on `si` being correct, but StatePtrs should only ever be
-        // retrieved from the transition table, which ensures they are correct.
-        debug_assert!(i < text.len());
-        let b = *text.get_unchecked(i);
-        debug_assert!((b as usize) < self.prog.byte_classes.len());
-        let cls = *self.prog.byte_classes.get_unchecked(b as usize);
-        self.cache.trans.next_unchecked(si, cls as usize)
-    }
-
-    /// Computes the next state given the current state and the current input
-    /// byte (which may be EOF).
-    ///
-    /// If STATE_DEAD is returned, then there is no valid state transition.
-    /// This implies that no permutation of future input can lead to a match
-    /// state.
-    ///
-    /// STATE_UNKNOWN can never be returned.
-    fn exec_byte(
-        &mut self,
-        qcur: &mut SparseSet,
-        qnext: &mut SparseSet,
-        mut si: StatePtr,
-        b: Byte,
-    ) -> Option<StatePtr> {
-        use crate::prog::Inst::*;
-
-        // Initialize a queue with the current DFA state's NFA states.
-        qcur.clear();
-        for ip in self.state(si).inst_ptrs() {
-            qcur.insert(ip);
-        }
-
-        // Before inspecting the current byte, we may need to also inspect
-        // whether the position immediately preceding the current byte
-        // satisfies the empty assertions found in the current state.
-        //
-        // We only need to do this step if there are any empty assertions in
-        // the current state.
-        let is_word_last = self.state(si).flags().is_word();
-        let is_word = b.is_ascii_word();
-        if self.state(si).flags().has_empty() {
-            // Compute the flags immediately preceding the current byte.
-            // This means we only care about the "end" or "end line" flags.
-            // (The "start" flags are computed immediately following the
-            // current byte and are handled below.)
-            let mut flags = EmptyFlags::default();
-            if b.is_eof() {
-                flags.end = true;
-                flags.end_line = true;
-            } else if b.as_byte().map_or(false, |b| b == b'\n') {
-                flags.end_line = true;
-            }
-            if is_word_last == is_word {
-                flags.not_word_boundary = true;
-            } else {
-                flags.word_boundary = true;
-            }
-            // Now follow epsilon transitions from every NFA state, but make
-            // sure we only follow transitions that satisfy our flags.
-            qnext.clear();
-            for &ip in &*qcur {
-                self.follow_epsilons(usize_to_u32(ip), qnext, flags);
-            }
-            mem::swap(qcur, qnext);
-        }
-
-        // Now we set flags for immediately after the current byte. Since start
-        // states are processed separately, and are the only states that can
-        // have the StartText flag set, we therefore only need to worry about
-        // the StartLine flag here.
-        //
-        // We do also keep track of whether this DFA state contains a NFA state
-        // that is a matching state. This is precisely how we delay the DFA
-        // matching by one byte in order to process the special EOF sentinel
-        // byte. Namely, if this DFA state containing a matching NFA state,
-        // then it is the *next* DFA state that is marked as a match.
-        let mut empty_flags = EmptyFlags::default();
-        let mut state_flags = StateFlags::default();
-        empty_flags.start_line = b.as_byte().map_or(false, |b| b == b'\n');
-        if b.is_ascii_word() {
-            state_flags.set_word();
-        }
-        // Now follow all epsilon transitions again, but only after consuming
-        // the current byte.
-        qnext.clear();
-        for &ip in &*qcur {
-            match self.prog[ip as usize] {
-                // These states never happen in a byte-based program.
-                Char(_) | Ranges(_) => unreachable!(),
-                // These states are handled when following epsilon transitions.
-                Save(_) | Split(_) | EmptyLook(_) => {}
-                Match(_) => {
-                    state_flags.set_match();
-                    if !self.continue_past_first_match() {
-                        break;
-                    } else if self.prog.matches.len() > 1
-                        && !qnext.contains(ip as usize)
-                    {
-                        // If we are continuing on to find other matches,
-                        // then keep a record of the match states we've seen.
-                        qnext.insert(ip);
-                    }
-                }
-                Bytes(ref inst) => {
-                    if b.as_byte().map_or(false, |b| inst.matches(b)) {
-                        self.follow_epsilons(
-                            inst.goto as InstPtr,
-                            qnext,
-                            empty_flags,
-                        );
-                    }
-                }
-            }
-        }
-
-        let cache = if b.is_eof() && self.prog.matches.len() > 1 {
-            // If we're processing the last byte of the input and we're
-            // matching a regex set, then make the next state contain the
-            // previous states transitions. We do this so that the main
-            // matching loop can extract all of the match instructions.
-            mem::swap(qcur, qnext);
-            // And don't cache this state because it's totally bunk.
-            false
-        } else {
-            true
-        };
-
-        // We've now built up the set of NFA states that ought to comprise the
-        // next DFA state, so try to find it in the cache, and if it doesn't
-        // exist, cache it.
-        //
-        // N.B. We pass `&mut si` here because the cache may clear itself if
-        // it has gotten too full. When that happens, the location of the
-        // current state may change.
-        let mut next =
-            match self.cached_state(qnext, state_flags, Some(&mut si)) {
-                None => return None,
-                Some(next) => next,
-            };
-        if (self.start & !STATE_START) == next {
-            // Start states can never be match states since all matches are
-            // delayed by one byte.
-            debug_assert!(!self.state(next).flags().is_match());
-            next = self.start_ptr(next);
-        }
-        if next <= STATE_MAX && self.state(next).flags().is_match() {
-            next |= STATE_MATCH;
-        }
-        debug_assert!(next != STATE_UNKNOWN);
-        // And now store our state in the current state's next list.
-        if cache {
-            let cls = self.byte_class(b);
-            self.cache.trans.set_next(si, cls, next);
-        }
-        Some(next)
-    }
-
-    /// Follows the epsilon transitions starting at (and including) `ip`. The
-    /// resulting states are inserted into the ordered set `q`.
-    ///
-    /// Conditional epsilon transitions (i.e., empty width assertions) are only
-    /// followed if they are satisfied by the given flags, which should
-    /// represent the flags set at the current location in the input.
-    ///
-    /// If the current location corresponds to the empty string, then only the
-    /// end line and/or end text flags may be set. If the current location
-    /// corresponds to a real byte in the input, then only the start line
-    /// and/or start text flags may be set.
-    ///
-    /// As an exception to the above, when finding the initial state, any of
-    /// the above flags may be set:
-    ///
-    /// If matching starts at the beginning of the input, then start text and
-    /// start line should be set. If the input is empty, then end text and end
-    /// line should also be set.
-    ///
-    /// If matching starts after the beginning of the input, then only start
-    /// line should be set if the preceding byte is `\n`. End line should never
-    /// be set in this case. (Even if the following byte is a `\n`, it will
-    /// be handled in a subsequent DFA state.)
-    fn follow_epsilons(
-        &mut self,
-        ip: InstPtr,
-        q: &mut SparseSet,
-        flags: EmptyFlags,
-    ) {
-        use crate::prog::EmptyLook::*;
-        use crate::prog::Inst::*;
-
-        // We need to traverse the NFA to follow epsilon transitions, so avoid
-        // recursion with an explicit stack.
-        self.cache.stack.push(ip);
-        while let Some(mut ip) = self.cache.stack.pop() {
-            // Try to munch through as many states as possible without
-            // pushes/pops to the stack.
-            loop {
-                // Don't visit states we've already added.
-                if q.contains(ip as usize) {
-                    break;
-                }
-                q.insert(ip as usize);
-                match self.prog[ip as usize] {
-                    Char(_) | Ranges(_) => unreachable!(),
-                    Match(_) | Bytes(_) => {
-                        break;
-                    }
-                    EmptyLook(ref inst) => {
-                        // Only follow empty assertion states if our flags
-                        // satisfy the assertion.
-                        match inst.look {
-                            StartLine if flags.start_line => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            EndLine if flags.end_line => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            StartText if flags.start => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            EndText if flags.end => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            WordBoundaryAscii if flags.word_boundary => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            NotWordBoundaryAscii
-                                if flags.not_word_boundary =>
-                            {
-                                ip = inst.goto as InstPtr;
-                            }
-                            WordBoundary if flags.word_boundary => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            NotWordBoundary if flags.not_word_boundary => {
-                                ip = inst.goto as InstPtr;
-                            }
-                            StartLine | EndLine | StartText | EndText
-                            | WordBoundaryAscii | NotWordBoundaryAscii
-                            | WordBoundary | NotWordBoundary => {
-                                break;
-                            }
-                        }
-                    }
-                    Save(ref inst) => {
-                        ip = inst.goto as InstPtr;
-                    }
-                    Split(ref inst) => {
-                        self.cache.stack.push(inst.goto2 as InstPtr);
-                        ip = inst.goto1 as InstPtr;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Find a previously computed state matching the given set of instructions
-    /// and is_match bool.
-    ///
-    /// The given set of instructions should represent a single state in the
-    /// NFA along with all states reachable without consuming any input.
-    ///
-    /// The is_match bool should be true if and only if the preceding DFA state
-    /// contains an NFA matching state. The cached state produced here will
-    /// then signify a match. (This enables us to delay a match by one byte,
-    /// in order to account for the EOF sentinel byte.)
-    ///
-    /// If the cache is full, then it is wiped before caching a new state.
-    ///
-    /// The current state should be specified if it exists, since it will need
-    /// to be preserved if the cache clears itself. (Start states are
-    /// always saved, so they should not be passed here.) It takes a mutable
-    /// pointer to the index because if the cache is cleared, the state's
-    /// location may change.
-    fn cached_state(
-        &mut self,
-        q: &SparseSet,
-        mut state_flags: StateFlags,
-        current_state: Option<&mut StatePtr>,
-    ) -> Option<StatePtr> {
-        // If we couldn't come up with a non-empty key to represent this state,
-        // then it is dead and can never lead to a match.
-        //
-        // Note that inst_flags represent the set of empty width assertions
-        // in q. We use this as an optimization in exec_byte to determine when
-        // we should follow epsilon transitions at the empty string preceding
-        // the current byte.
-        let key = match self.cached_state_key(q, &mut state_flags) {
-            None => return Some(STATE_DEAD),
-            Some(v) => v,
-        };
-        // In the cache? Cool. Done.
-        if let Some(si) = self.cache.compiled.get_ptr(&key) {
-            return Some(si);
-        }
-        // If the cache has gotten too big, wipe it.
-        if self.approximate_size() > self.prog.dfa_size_limit
-            && !self.clear_cache_and_save(current_state)
-        {
-            // Ooops. DFA is giving up.
-            return None;
-        }
-        // Allocate room for our state and add it.
-        self.add_state(key)
-    }
-
-    /// Produces a key suitable for describing a state in the DFA cache.
-    ///
-    /// The key invariant here is that equivalent keys are produced for any two
-    /// sets of ordered NFA states (and toggling of whether the previous NFA
-    /// states contain a match state) that do not discriminate a match for any
-    /// input.
-    ///
-    /// Specifically, q should be an ordered set of NFA states and is_match
-    /// should be true if and only if the previous NFA states contained a match
-    /// state.
-    fn cached_state_key(
-        &mut self,
-        q: &SparseSet,
-        state_flags: &mut StateFlags,
-    ) -> Option<State> {
-        use crate::prog::Inst::*;
-
-        // We need to build up enough information to recognize pre-built states
-        // in the DFA. Generally speaking, this includes every instruction
-        // except for those which are purely epsilon transitions, e.g., the
-        // Save and Split instructions.
-        //
-        // Empty width assertions are also epsilon transitions, but since they
-        // are conditional, we need to make them part of a state's key in the
-        // cache.
-
-        let mut insts =
-            mem::replace(&mut self.cache.insts_scratch_space, vec![]);
-        insts.clear();
-        // Reserve 1 byte for flags.
-        insts.push(0);
-
-        let mut prev = 0;
-        for &ip in q {
-            let ip = usize_to_u32(ip);
-            match self.prog[ip as usize] {
-                Char(_) | Ranges(_) => unreachable!(),
-                Save(_) | Split(_) => {}
-                Bytes(_) => push_inst_ptr(&mut insts, &mut prev, ip),
-                EmptyLook(_) => {
-                    state_flags.set_empty();
-                    push_inst_ptr(&mut insts, &mut prev, ip)
-                }
-                Match(_) => {
-                    push_inst_ptr(&mut insts, &mut prev, ip);
-                    if !self.continue_past_first_match() {
-                        break;
-                    }
-                }
-            }
-        }
-        // If we couldn't transition to any other instructions and we didn't
-        // see a match when expanding NFA states previously, then this is a
-        // dead state and no amount of additional input can transition out
-        // of this state.
-        let opt_state = if insts.len() == 1 && !state_flags.is_match() {
-            None
-        } else {
-            let StateFlags(f) = *state_flags;
-            insts[0] = f;
-            Some(State { data: Arc::from(&*insts) })
-        };
-        self.cache.insts_scratch_space = insts;
-        opt_state
-    }
-
-    /// Clears the cache, but saves and restores current_state if it is not
-    /// none.
-    ///
-    /// The current state must be provided here in case its location in the
-    /// cache changes.
-    ///
-    /// This returns false if the cache is not cleared and the DFA should
-    /// give up.
-    fn clear_cache_and_save(
-        &mut self,
-        current_state: Option<&mut StatePtr>,
-    ) -> bool {
-        if self.cache.compiled.is_empty() {
-            // Nothing to clear...
-            return true;
-        }
-        match current_state {
-            None => self.clear_cache(),
-            Some(si) => {
-                let cur = self.state(*si).clone();
-                if !self.clear_cache() {
-                    return false;
-                }
-                // The unwrap is OK because we just cleared the cache and
-                // therefore know that the next state pointer won't exceed
-                // STATE_MAX.
-                *si = self.restore_state(cur).unwrap();
-                true
-            }
-        }
-    }
-
-    /// Wipes the state cache, but saves and restores the current start state.
-    ///
-    /// This returns false if the cache is not cleared and the DFA should
-    /// give up.
-    fn clear_cache(&mut self) -> bool {
-        // Bail out of the DFA if we're moving too "slowly."
-        // A heuristic from RE2: assume the DFA is too slow if it is processing
-        // 10 or fewer bytes per state.
-        // Additionally, we permit the cache to be flushed a few times before
-        // caling it quits.
-        let nstates = self.cache.compiled.len();
-        if self.cache.flush_count >= 3
-            && self.at >= self.last_cache_flush
-            && (self.at - self.last_cache_flush) <= 10 * nstates
-        {
-            return false;
-        }
-        // Update statistics tracking cache flushes.
-        self.last_cache_flush = self.at;
-        self.cache.flush_count += 1;
-
-        // OK, actually flush the cache.
-        let start = self.state(self.start & !STATE_START).clone();
-        let last_match = if self.last_match_si <= STATE_MAX {
-            Some(self.state(self.last_match_si).clone())
-        } else {
-            None
-        };
-        self.cache.reset_size();
-        self.cache.trans.clear();
-        self.cache.compiled.clear();
-        for s in &mut self.cache.start_states {
-            *s = STATE_UNKNOWN;
-        }
-        // The unwraps are OK because we just cleared the cache and therefore
-        // know that the next state pointer won't exceed STATE_MAX.
-        let start_ptr = self.restore_state(start).unwrap();
-        self.start = self.start_ptr(start_ptr);
-        if let Some(last_match) = last_match {
-            self.last_match_si = self.restore_state(last_match).unwrap();
-        }
-        true
-    }
-
-    /// Restores the given state back into the cache, and returns a pointer
-    /// to it.
-    fn restore_state(&mut self, state: State) -> Option<StatePtr> {
-        // If we've already stored this state, just return a pointer to it.
-        // None will be the wiser.
-        if let Some(si) = self.cache.compiled.get_ptr(&state) {
-            return Some(si);
-        }
-        self.add_state(state)
-    }
-
-    /// Returns the next state given the current state si and current byte
-    /// b. {qcur,qnext} are used as scratch space for storing ordered NFA
-    /// states.
-    ///
-    /// This tries to fetch the next state from the cache, but if that fails,
-    /// it computes the next state, caches it and returns a pointer to it.
-    ///
-    /// The pointer can be to a real state, or it can be STATE_DEAD.
-    /// STATE_UNKNOWN cannot be returned.
-    ///
-    /// None is returned if a new state could not be allocated (i.e., the DFA
-    /// ran out of space and thinks it's running too slowly).
-    fn next_state(
-        &mut self,
-        qcur: &mut SparseSet,
-        qnext: &mut SparseSet,
-        si: StatePtr,
-        b: Byte,
-    ) -> Option<StatePtr> {
-        if si == STATE_DEAD {
-            return Some(STATE_DEAD);
-        }
-        match self.cache.trans.next(si, self.byte_class(b)) {
-            STATE_UNKNOWN => self.exec_byte(qcur, qnext, si, b),
-            STATE_QUIT => None,
-            nsi => Some(nsi),
-        }
-    }
-
-    /// Computes and returns the start state, where searching begins at
-    /// position `at` in `text`. If the state has already been computed,
-    /// then it is pulled from the cache. If the state hasn't been cached,
-    /// then it is computed, cached and a pointer to it is returned.
-    ///
-    /// This may return STATE_DEAD but never STATE_UNKNOWN.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn start_state(
-        &mut self,
-        q: &mut SparseSet,
-        empty_flags: EmptyFlags,
-        state_flags: StateFlags,
-    ) -> Option<StatePtr> {
-        // Compute an index into our cache of start states based on the set
-        // of empty/state flags set at the current position in the input. We
-        // don't use every flag since not all flags matter. For example, since
-        // matches are delayed by one byte, start states can never be match
-        // states.
-        let flagi = {
-            (((empty_flags.start as u8) << 0)
-                | ((empty_flags.end as u8) << 1)
-                | ((empty_flags.start_line as u8) << 2)
-                | ((empty_flags.end_line as u8) << 3)
-                | ((empty_flags.word_boundary as u8) << 4)
-                | ((empty_flags.not_word_boundary as u8) << 5)
-                | ((state_flags.is_word() as u8) << 6)) as usize
-        };
-        match self.cache.start_states[flagi] {
-            STATE_UNKNOWN => {}
-            si => return Some(si),
-        }
-        q.clear();
-        let start = usize_to_u32(self.prog.start);
-        self.follow_epsilons(start, q, empty_flags);
-        // Start states can never be match states because we delay every match
-        // by one byte. Given an empty string and an empty match, the match
-        // won't actually occur until the DFA processes the special EOF
-        // sentinel byte.
-        let sp = match self.cached_state(q, state_flags, None) {
-            None => return None,
-            Some(sp) => self.start_ptr(sp),
-        };
-        self.cache.start_states[flagi] = sp;
-        Some(sp)
-    }
-
-    /// Computes the set of starting flags for the given position in text.
-    ///
-    /// This should only be used when executing the DFA forwards over the
-    /// input.
-    fn start_flags(&self, text: &[u8], at: usize) -> (EmptyFlags, StateFlags) {
-        let mut empty_flags = EmptyFlags::default();
-        let mut state_flags = StateFlags::default();
-        empty_flags.start = at == 0;
-        empty_flags.end = text.is_empty();
-        empty_flags.start_line = at == 0 || text[at - 1] == b'\n';
-        empty_flags.end_line = text.is_empty();
-
-        let is_word_last = at > 0 && Byte::byte(text[at - 1]).is_ascii_word();
-        let is_word = at < text.len() && Byte::byte(text[at]).is_ascii_word();
-        if is_word_last {
-            state_flags.set_word();
-        }
-        if is_word == is_word_last {
-            empty_flags.not_word_boundary = true;
-        } else {
-            empty_flags.word_boundary = true;
-        }
-        (empty_flags, state_flags)
-    }
-
-    /// Computes the set of starting flags for the given position in text.
-    ///
-    /// This should only be used when executing the DFA in reverse over the
-    /// input.
-    fn start_flags_reverse(
-        &self,
-        text: &[u8],
-        at: usize,
-    ) -> (EmptyFlags, StateFlags) {
-        let mut empty_flags = EmptyFlags::default();
-        let mut state_flags = StateFlags::default();
-        empty_flags.start = at == text.len();
-        empty_flags.end = text.is_empty();
-        empty_flags.start_line = at == text.len() || text[at] == b'\n';
-        empty_flags.end_line = text.is_empty();
-
-        let is_word_last =
-            at < text.len() && Byte::byte(text[at]).is_ascii_word();
-        let is_word = at > 0 && Byte::byte(text[at - 1]).is_ascii_word();
-        if is_word_last {
-            state_flags.set_word();
-        }
-        if is_word == is_word_last {
-            empty_flags.not_word_boundary = true;
-        } else {
-            empty_flags.word_boundary = true;
-        }
-        (empty_flags, state_flags)
-    }
-
-    /// Returns a reference to a State given a pointer to it.
-    fn state(&self, si: StatePtr) -> &State {
-        self.cache.compiled.get_state(si).unwrap()
-    }
-
-    /// Adds the given state to the DFA.
-    ///
-    /// This allocates room for transitions out of this state in
-    /// self.cache.trans. The transitions can be set with the returned
-    /// StatePtr.
-    ///
-    /// If None is returned, then the state limit was reached and the DFA
-    /// should quit.
-    fn add_state(&mut self, state: State) -> Option<StatePtr> {
-        // This will fail if the next state pointer exceeds STATE_PTR. In
-        // practice, the cache limit will prevent us from ever getting here,
-        // but maybe callers will set the cache size to something ridiculous...
-        let si = match self.cache.trans.add() {
-            None => return None,
-            Some(si) => si,
-        };
-        // If the program has a Unicode word boundary, then set any transitions
-        // for non-ASCII bytes to STATE_QUIT. If the DFA stumbles over such a
-        // transition, then it will quit and an alternative matching engine
-        // will take over.
-        if self.prog.has_unicode_word_boundary {
-            for b in 128..256 {
-                let cls = self.byte_class(Byte::byte(b as u8));
-                self.cache.trans.set_next(si, cls, STATE_QUIT);
-            }
-        }
-        // Finally, put our actual state on to our heap of states and index it
-        // so we can find it later.
-        self.cache.size += self.cache.trans.state_heap_size()
-            + state.data.len()
-            + (2 * mem::size_of::<State>())
-            + mem::size_of::<StatePtr>();
-        self.cache.compiled.insert(state, si);
-        // Transition table and set of states and map should all be in sync.
-        debug_assert!(
-            self.cache.compiled.len() == self.cache.trans.num_states()
-        );
-        Some(si)
-    }
-
-    /// Quickly finds the next occurrence of any literal prefixes in the regex.
-    /// If there are no literal prefixes, then the current position is
-    /// returned. If there are literal prefixes and one could not be found,
-    /// then None is returned.
-    ///
-    /// This should only be called when the DFA is in a start state.
-    fn prefix_at(&self, text: &[u8], at: usize) -> Option<usize> {
-        self.prog.prefixes.find(&text[at..]).map(|(s, _)| at + s)
-    }
-
-    /// Returns the number of byte classes required to discriminate transitions
-    /// in each state.
-    ///
-    /// invariant: num_byte_classes() == len(State.next)
-    fn num_byte_classes(&self) -> usize {
-        // We add 1 to account for the special EOF byte.
-        (self.prog.byte_classes[255] as usize + 1) + 1
-    }
-
-    /// Given an input byte or the special EOF sentinel, return its
-    /// corresponding byte class.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn byte_class(&self, b: Byte) -> usize {
-        match b.as_byte() {
-            None => self.num_byte_classes() - 1,
-            Some(b) => self.u8_class(b),
-        }
-    }
-
-    /// Like byte_class, but explicitly for u8s.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn u8_class(&self, b: u8) -> usize {
-        self.prog.byte_classes[b as usize] as usize
-    }
-
-    /// Returns true if the DFA should continue searching past the first match.
-    ///
-    /// Leftmost first semantics in the DFA are preserved by not following NFA
-    /// transitions after the first match is seen.
-    ///
-    /// On occasion, we want to avoid leftmost first semantics to find either
-    /// the longest match (for reverse search) or all possible matches (for
-    /// regex sets).
-    fn continue_past_first_match(&self) -> bool {
-        self.prog.is_reverse || self.prog.matches.len() > 1
-    }
-
-    /// Returns true if there is a prefix we can quickly search for.
-    fn has_prefix(&self) -> bool {
-        !self.prog.is_reverse
-            && !self.prog.prefixes.is_empty()
-            && !self.prog.is_anchored_start
-    }
-
-    /// Sets the STATE_START bit in the given state pointer if and only if
-    /// we have a prefix to scan for.
-    ///
-    /// If there's no prefix, then it's a waste to treat the start state
-    /// specially.
-    fn start_ptr(&self, si: StatePtr) -> StatePtr {
-        if self.has_prefix() {
-            si | STATE_START
-        } else {
-            si
-        }
-    }
-
-    /// Approximate size returns the approximate heap space currently used by
-    /// the DFA. It is used to determine whether the DFA's state cache needs to
-    /// be wiped. Namely, it is possible that for certain regexes on certain
-    /// inputs, a new state could be created for every byte of input. (This is
-    /// bad for memory use, so we bound it with a cache.)
-    fn approximate_size(&self) -> usize {
-        self.cache.size
-    }
-}
-
-/// An abstraction for representing a map of states. The map supports two
-/// different ways of state lookup. One is fast constant time access via a
-/// state pointer. The other is a hashmap lookup based on the DFA's
-/// constituent NFA states.
-///
-/// A DFA state internally uses an Arc such that we only need to store the
-/// set of NFA states on the heap once, even though we support looking up
-/// states by two different means. A more natural way to express this might
-/// use raw pointers, but an Arc is safe and effectively achieves the same
-/// thing.
-#[derive(Debug)]
-struct StateMap {
-    /// The keys are not actually static but rely on always pointing to a
-    /// buffer in `states` which will never be moved except when clearing
-    /// the map or on drop, in which case the keys of this map will be
-    /// removed before
-    map: HashMap<State, StatePtr>,
-    /// Our set of states. Note that `StatePtr / num_byte_classes` indexes
-    /// this Vec rather than just a `StatePtr`.
-    states: Vec<State>,
-    /// The number of byte classes in the DFA. Used to index `states`.
-    num_byte_classes: usize,
-}
-
-impl StateMap {
-    fn new(num_byte_classes: usize) -> StateMap {
-        StateMap { map: HashMap::new(), states: vec![], num_byte_classes }
-    }
-
-    fn len(&self) -> usize {
-        self.states.len()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.states.is_empty()
-    }
-
-    fn get_ptr(&self, state: &State) -> Option<StatePtr> {
-        self.map.get(state).cloned()
-    }
-
-    fn get_state(&self, si: StatePtr) -> Option<&State> {
-        self.states.get(si as usize / self.num_byte_classes)
-    }
-
-    fn insert(&mut self, state: State, si: StatePtr) {
-        self.map.insert(state.clone(), si);
-        self.states.push(state);
-    }
-
-    fn clear(&mut self) {
-        self.map.clear();
-        self.states.clear();
-    }
-}
-
-impl Transitions {
-    /// Create a new transition table.
-    ///
-    /// The number of byte classes corresponds to the stride. Every state will
-    /// have `num_byte_classes` slots for transitions.
-    fn new(num_byte_classes: usize) -> Transitions {
-        Transitions { table: vec![], num_byte_classes }
-    }
-
-    /// Returns the total number of states currently in this table.
-    fn num_states(&self) -> usize {
-        self.table.len() / self.num_byte_classes
-    }
-
-    /// Allocates room for one additional state and returns a pointer to it.
-    ///
-    /// If there's no more room, None is returned.
-    fn add(&mut self) -> Option<StatePtr> {
-        let si = self.table.len();
-        if si > STATE_MAX as usize {
-            return None;
-        }
-        self.table.extend(repeat(STATE_UNKNOWN).take(self.num_byte_classes));
-        Some(usize_to_u32(si))
-    }
-
-    /// Clears the table of all states.
-    fn clear(&mut self) {
-        self.table.clear();
-    }
-
-    /// Sets the transition from (si, cls) to next.
-    fn set_next(&mut self, si: StatePtr, cls: usize, next: StatePtr) {
-        self.table[si as usize + cls] = next;
-    }
-
-    /// Returns the transition corresponding to (si, cls).
-    fn next(&self, si: StatePtr, cls: usize) -> StatePtr {
-        self.table[si as usize + cls]
-    }
-
-    /// The heap size, in bytes, of a single state in the transition table.
-    fn state_heap_size(&self) -> usize {
-        self.num_byte_classes * mem::size_of::<StatePtr>()
-    }
-
-    /// Like `next`, but uses unchecked access and is therefore not safe.
-    unsafe fn next_unchecked(&self, si: StatePtr, cls: usize) -> StatePtr {
-        debug_assert!((si as usize) < self.table.len());
-        debug_assert!(cls < self.num_byte_classes);
-        *self.table.get_unchecked(si as usize + cls)
-    }
-}
-
-impl StateFlags {
-    fn is_match(&self) -> bool {
-        self.0 & 0b0000_0001 > 0
-    }
-
-    fn set_match(&mut self) {
-        self.0 |= 0b0000_0001;
-    }
-
-    fn is_word(&self) -> bool {
-        self.0 & 0b0000_0010 > 0
-    }
-
-    fn set_word(&mut self) {
-        self.0 |= 0b0000_0010;
-    }
-
-    fn has_empty(&self) -> bool {
-        self.0 & 0b0000_0100 > 0
-    }
-
-    fn set_empty(&mut self) {
-        self.0 |= 0b0000_0100;
-    }
-}
-
-impl Byte {
-    fn byte(b: u8) -> Self {
-        Byte(b as u16)
-    }
-    fn eof() -> Self {
-        Byte(256)
-    }
-    fn is_eof(&self) -> bool {
-        self.0 == 256
-    }
-
-    fn is_ascii_word(&self) -> bool {
-        let b = match self.as_byte() {
-            None => return false,
-            Some(b) => b,
-        };
-        match b {
-            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'_' => true,
-            _ => false,
-        }
-    }
-
-    fn as_byte(&self) -> Option<u8> {
-        if self.is_eof() {
-            None
-        } else {
-            Some(self.0 as u8)
-        }
-    }
-}
-
-impl fmt::Debug for State {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let ips: Vec<usize> = self.inst_ptrs().collect();
-        f.debug_struct("State")
-            .field("flags", &self.flags())
-            .field("insts", &ips)
-            .finish()
-    }
-}
-
-impl fmt::Debug for Transitions {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut fmtd = f.debug_map();
-        for si in 0..self.num_states() {
-            let s = si * self.num_byte_classes;
-            let e = s + self.num_byte_classes;
-            fmtd.entry(&si.to_string(), &TransitionsRow(&self.table[s..e]));
-        }
-        fmtd.finish()
-    }
-}
-
-struct TransitionsRow<'a>(&'a [StatePtr]);
-
-impl<'a> fmt::Debug for TransitionsRow<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut fmtd = f.debug_map();
-        for (b, si) in self.0.iter().enumerate() {
-            match *si {
-                STATE_UNKNOWN => {}
-                STATE_DEAD => {
-                    fmtd.entry(&vb(b as usize), &"DEAD");
-                }
-                si => {
-                    fmtd.entry(&vb(b as usize), &si.to_string());
-                }
-            }
-        }
-        fmtd.finish()
-    }
-}
-
-impl fmt::Debug for StateFlags {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("StateFlags")
-            .field("is_match", &self.is_match())
-            .field("is_word", &self.is_word())
-            .field("has_empty", &self.has_empty())
-            .finish()
-    }
-}
-
-/// Helper function for formatting a byte as a nice-to-read escaped string.
-fn vb(b: usize) -> String {
-    use std::ascii::escape_default;
-
-    if b > ::std::u8::MAX as usize {
-        "EOF".to_owned()
-    } else {
-        let escaped = escape_default(b as u8).collect::<Vec<u8>>();
-        String::from_utf8_lossy(&escaped).into_owned()
-    }
-}
-
-fn usize_to_u32(n: usize) -> u32 {
-    if (n as u64) > (::std::u32::MAX as u64) {
-        panic!("BUG: {} is too big to fit into u32", n)
-    }
-    n as u32
-}
-
-#[allow(dead_code)] // useful for debugging
-fn show_state_ptr(si: StatePtr) -> String {
-    let mut s = format!("{:?}", si & STATE_MAX);
-    if si == STATE_UNKNOWN {
-        s = format!("{} (unknown)", s);
-    }
-    if si == STATE_DEAD {
-        s = format!("{} (dead)", s);
-    }
-    if si == STATE_QUIT {
-        s = format!("{} (quit)", s);
-    }
-    if si & STATE_START > 0 {
-        s = format!("{} (start)", s);
-    }
-    if si & STATE_MATCH > 0 {
-        s = format!("{} (match)", s);
-    }
-    s
-}
-
-/// https://developers.google.com/protocol-buffers/docs/encoding#varints
-fn write_vari32(data: &mut Vec<u8>, n: i32) {
-    let mut un = (n as u32) << 1;
-    if n < 0 {
-        un = !un;
-    }
-    write_varu32(data, un)
-}
-
-/// https://developers.google.com/protocol-buffers/docs/encoding#varints
-fn read_vari32(data: &[u8]) -> (i32, usize) {
-    let (un, i) = read_varu32(data);
-    let mut n = (un >> 1) as i32;
-    if un & 1 != 0 {
-        n = !n;
-    }
-    (n, i)
-}
-
-/// https://developers.google.com/protocol-buffers/docs/encoding#varints
-fn write_varu32(data: &mut Vec<u8>, mut n: u32) {
-    while n >= 0b1000_0000 {
-        data.push((n as u8) | 0b1000_0000);
-        n >>= 7;
-    }
-    data.push(n as u8);
-}
-
-/// https://developers.google.com/protocol-buffers/docs/encoding#varints
-fn read_varu32(data: &[u8]) -> (u32, usize) {
-    let mut n: u32 = 0;
-    let mut shift: u32 = 0;
-    for (i, &b) in data.iter().enumerate() {
-        if b < 0b1000_0000 {
-            return (n | ((b as u32) << shift), i + 1);
-        }
-        n |= ((b as u32) & 0b0111_1111) << shift;
-        shift += 7;
-    }
-    (0, 0)
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::{
-        push_inst_ptr, read_vari32, read_varu32, write_vari32, write_varu32,
-        State, StateFlags,
-    };
-    use quickcheck::{quickcheck, Gen, QuickCheck};
-    use std::sync::Arc;
-
-    #[test]
-    fn prop_state_encode_decode() {
-        fn p(mut ips: Vec<u32>, flags: u8) -> bool {
-            // It looks like our encoding scheme can't handle instruction
-            // pointers at or above 2**31. We should fix that, but it seems
-            // unlikely to occur in real code due to the amount of memory
-            // required for such a state machine. So for now, we just clamp
-            // our test data.
-            for ip in &mut ips {
-                if *ip >= 1 << 31 {
-                    *ip = (1 << 31) - 1;
-                }
-            }
-            let mut data = vec![flags];
-            let mut prev = 0;
-            for &ip in ips.iter() {
-                push_inst_ptr(&mut data, &mut prev, ip);
-            }
-            let state = State { data: Arc::from(&data[..]) };
-
-            let expected: Vec<usize> =
-                ips.into_iter().map(|ip| ip as usize).collect();
-            let got: Vec<usize> = state.inst_ptrs().collect();
-            expected == got && state.flags() == StateFlags(flags)
-        }
-        QuickCheck::new()
-            .gen(Gen::new(10_000))
-            .quickcheck(p as fn(Vec<u32>, u8) -> bool);
-    }
-
-    #[test]
-    fn prop_read_write_u32() {
-        fn p(n: u32) -> bool {
-            let mut buf = vec![];
-            write_varu32(&mut buf, n);
-            let (got, nread) = read_varu32(&buf);
-            nread == buf.len() && got == n
-        }
-        quickcheck(p as fn(u32) -> bool);
-    }
-
-    #[test]
-    fn prop_read_write_i32() {
-        fn p(n: i32) -> bool {
-            let mut buf = vec![];
-            write_vari32(&mut buf, n);
-            let (got, nread) = read_vari32(&buf);
-            nread == buf.len() && got == n
-        }
-        quickcheck(p as fn(i32) -> bool);
-    }
-}
diff --git a/src/error.rs b/src/error.rs
index 6c341f604b..6026b3849d 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,7 +1,9 @@
-use std::fmt;
-use std::iter::repeat;
+use alloc::string::{String, ToString};
+
+use regex_automata::meta;
 
 /// An error that occurred during parsing or compiling a regular expression.
+#[non_exhaustive]
 #[derive(Clone, PartialEq)]
 pub enum Error {
     /// A syntax error.
@@ -27,29 +29,44 @@ pub enum Error {
     /// approaches may be appropriate. Instead, you'll have to determine just
     /// how big of a regex you want to allow.
     CompiledTooBig(usize),
-    /// Hints that destructuring should not be exhaustive.
-    ///
-    /// This enum may grow additional variants, so this makes sure clients
-    /// don't count on exhaustive matching. (Otherwise, adding a new variant
-    /// could break existing code.)
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
-impl ::std::error::Error for Error {
+impl Error {
+    pub(crate) fn from_meta_build_error(err: meta::BuildError) -> Error {
+        if let Some(size_limit) = err.size_limit() {
+            Error::CompiledTooBig(size_limit)
+        } else if let Some(ref err) = err.syntax_error() {
+            Error::Syntax(err.to_string())
+        } else {
+            // This is a little suspect. Technically there are more ways for
+            // a meta regex to fail to build other than "exceeded size limit"
+            // and "syntax error." For example, if there are too many states
+            // or even too many patterns. But in practice this is probably
+            // good enough. The worst thing that happens is that Error::Syntax
+            // represents an error that isn't technically a syntax error, but
+            // the actual message will still be shown. So... it's not too bad.
+            //
+            // We really should have made the Error type in the regex crate
+            // completely opaque. Rookie mistake.
+            Error::Syntax(err.to_string())
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
     // TODO: Remove this method entirely on the next breaking semver release.
     #[allow(deprecated)]
     fn description(&self) -> &str {
         match *self {
             Error::Syntax(ref err) => err,
             Error::CompiledTooBig(_) => "compiled program too big",
-            Error::__Nonexhaustive => unreachable!(),
         }
     }
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match *self {
             Error::Syntax(ref err) => err.fmt(f),
             Error::CompiledTooBig(limit) => write!(
@@ -57,7 +74,6 @@ impl fmt::Display for Error {
                 "Compiled regex exceeds size limit of {} bytes.",
                 limit
             ),
-            Error::__Nonexhaustive => unreachable!(),
         }
     }
 }
@@ -66,11 +82,11 @@ impl fmt::Display for Error {
 // errors when people use `Regex::new(...).unwrap()`. It's a little weird,
 // but the `Syntax` variant is already storing a `String` anyway, so we might
 // as well format it nicely.
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Debug for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match *self {
             Error::Syntax(ref err) => {
-                let hr: String = repeat('~').take(79).collect();
+                let hr: String = core::iter::repeat('~').take(79).collect();
                 writeln!(f, "Syntax(")?;
                 writeln!(f, "{}", hr)?;
                 writeln!(f, "{}", err)?;
@@ -81,9 +97,6 @@ impl fmt::Debug for Error {
             Error::CompiledTooBig(limit) => {
                 f.debug_tuple("CompiledTooBig").field(&limit).finish()
             }
-            Error::__Nonexhaustive => {
-                f.debug_tuple("__Nonexhaustive").finish()
-            }
         }
     }
 }
diff --git a/src/exec.rs b/src/exec.rs
deleted file mode 100644
index ee8b589d22..0000000000
--- a/src/exec.rs
+++ /dev/null
@@ -1,1759 +0,0 @@
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::panic::AssertUnwindSafe;
-use std::sync::Arc;
-
-#[cfg(feature = "perf-literal")]
-use aho_corasick::{AhoCorasick, MatchKind};
-use regex_syntax::hir::literal;
-use regex_syntax::hir::{Hir, Look};
-use regex_syntax::ParserBuilder;
-
-use crate::backtrack;
-use crate::compile::Compiler;
-#[cfg(feature = "perf-dfa")]
-use crate::dfa;
-use crate::error::Error;
-use crate::input::{ByteInput, CharInput};
-use crate::literal::LiteralSearcher;
-use crate::pikevm;
-use crate::pool::{Pool, PoolGuard};
-use crate::prog::Program;
-use crate::re_builder::RegexOptions;
-use crate::re_bytes;
-use crate::re_set;
-use crate::re_trait::{Locations, RegularExpression, Slot};
-use crate::re_unicode;
-use crate::utf8::next_utf8;
-
-/// `Exec` manages the execution of a regular expression.
-///
-/// In particular, this manages the various compiled forms of a single regular
-/// expression and the choice of which matching engine to use to execute a
-/// regular expression.
-#[derive(Debug)]
-pub struct Exec {
-    /// All read only state.
-    ro: Arc<ExecReadOnly>,
-    /// A pool of reusable values for the various matching engines.
-    ///
-    /// Note that boxing this value is not strictly necessary, but it is an
-    /// easy way to ensure that T does not bloat the stack sized used by a pool
-    /// in the case where T is big. And this turns out to be the case at the
-    /// time of writing for regex's use of this pool. At the time of writing,
-    /// the size of a Regex on the stack is 856 bytes. Boxing this value
-    /// reduces that size to 16 bytes.
-    pool: Box<Pool<ProgramCache>>,
-}
-
-/// `ExecNoSync` is like `Exec`, except it embeds a reference to a cache. This
-/// means it is no longer Sync, but we can now avoid the overhead of
-/// synchronization to fetch the cache.
-#[derive(Debug)]
-pub struct ExecNoSync<'c> {
-    /// All read only state.
-    ro: &'c Arc<ExecReadOnly>,
-    /// Caches for the various matching engines.
-    cache: PoolGuard<'c, ProgramCache>,
-}
-
-/// `ExecNoSyncStr` is like `ExecNoSync`, but matches on &str instead of &[u8].
-#[derive(Debug)]
-pub struct ExecNoSyncStr<'c>(ExecNoSync<'c>);
-
-/// `ExecReadOnly` comprises all read only state for a regex. Namely, all such
-/// state is determined at compile time and never changes during search.
-#[derive(Debug)]
-struct ExecReadOnly {
-    /// The original regular expressions given by the caller to compile.
-    res: Vec<String>,
-    /// A compiled program that is used in the NFA simulation and backtracking.
-    /// It can be byte-based or Unicode codepoint based.
-    ///
-    /// N.B. It is not possibly to make this byte-based from the public API.
-    /// It is only used for testing byte based programs in the NFA simulations.
-    nfa: Program,
-    /// A compiled byte based program for DFA execution. This is only used
-    /// if a DFA can be executed. (Currently, only word boundary assertions are
-    /// not supported.) Note that this program contains an embedded `.*?`
-    /// preceding the first capture group, unless the regex is anchored at the
-    /// beginning.
-    #[allow(dead_code)]
-    dfa: Program,
-    /// The same as above, except the program is reversed (and there is no
-    /// preceding `.*?`). This is used by the DFA to find the starting location
-    /// of matches.
-    #[allow(dead_code)]
-    dfa_reverse: Program,
-    /// A set of suffix literals extracted from the regex.
-    ///
-    /// Prefix literals are stored on the `Program`, since they are used inside
-    /// the matching engines.
-    #[allow(dead_code)]
-    suffixes: LiteralSearcher,
-    /// An Aho-Corasick automaton with leftmost-first match semantics.
-    ///
-    /// This is only set when the entire regex is a simple unanchored
-    /// alternation of literals. We could probably use it more circumstances,
-    /// but this is already hacky enough in this architecture.
-    ///
-    /// N.B. We use u32 as a state ID representation under the assumption that
-    /// if we were to exhaust the ID space, we probably would have long
-    /// surpassed the compilation size limit.
-    #[cfg(feature = "perf-literal")]
-    ac: Option<AhoCorasick>,
-    /// match_type encodes as much upfront knowledge about how we're going to
-    /// execute a search as possible.
-    match_type: MatchType,
-}
-
-/// Facilitates the construction of an executor by exposing various knobs
-/// to control how a regex is executed and what kinds of resources it's
-/// permitted to use.
-// `ExecBuilder` is only public via the `internal` module, so avoid deriving
-// `Debug`.
-#[allow(missing_debug_implementations)]
-pub struct ExecBuilder {
-    options: RegexOptions,
-    match_type: Option<MatchType>,
-    bytes: bool,
-    only_utf8: bool,
-}
-
-/// Parsed represents a set of parsed regular expressions and their detected
-/// literals.
-struct Parsed {
-    exprs: Vec<Hir>,
-    prefixes: literal::Seq,
-    suffixes: literal::Seq,
-    bytes: bool,
-}
-
-impl ExecBuilder {
-    /// Create a regex execution builder.
-    ///
-    /// This uses default settings for everything except the regex itself,
-    /// which must be provided. Further knobs can be set by calling methods,
-    /// and then finally, `build` to actually create the executor.
-    pub fn new(re: &str) -> Self {
-        Self::new_many(&[re])
-    }
-
-    /// Like new, but compiles the union of the given regular expressions.
-    ///
-    /// Note that when compiling 2 or more regular expressions, capture groups
-    /// are completely unsupported. (This means both `find` and `captures`
-    /// won't work.)
-    pub fn new_many<I, S>(res: I) -> Self
-    where
-        S: AsRef<str>,
-        I: IntoIterator<Item = S>,
-    {
-        let mut opts = RegexOptions::default();
-        opts.pats = res.into_iter().map(|s| s.as_ref().to_owned()).collect();
-        Self::new_options(opts)
-    }
-
-    /// Create a regex execution builder.
-    pub fn new_options(opts: RegexOptions) -> Self {
-        ExecBuilder {
-            options: opts,
-            match_type: None,
-            bytes: false,
-            only_utf8: true,
-        }
-    }
-
-    /// Set the matching engine to be automatically determined.
-    ///
-    /// This is the default state and will apply whatever optimizations are
-    /// possible, such as running a DFA.
-    ///
-    /// This overrides whatever was previously set via the `nfa` or
-    /// `bounded_backtracking` methods.
-    pub fn automatic(mut self) -> Self {
-        self.match_type = None;
-        self
-    }
-
-    /// Sets the matching engine to use the NFA algorithm no matter what
-    /// optimizations are possible.
-    ///
-    /// This overrides whatever was previously set via the `automatic` or
-    /// `bounded_backtracking` methods.
-    pub fn nfa(mut self) -> Self {
-        self.match_type = Some(MatchType::Nfa(MatchNfaType::PikeVM));
-        self
-    }
-
-    /// Sets the matching engine to use a bounded backtracking engine no
-    /// matter what optimizations are possible.
-    ///
-    /// One must use this with care, since the bounded backtracking engine
-    /// uses memory proportion to `len(regex) * len(text)`.
-    ///
-    /// This overrides whatever was previously set via the `automatic` or
-    /// `nfa` methods.
-    pub fn bounded_backtracking(mut self) -> Self {
-        self.match_type = Some(MatchType::Nfa(MatchNfaType::Backtrack));
-        self
-    }
-
-    /// Compiles byte based programs for use with the NFA matching engines.
-    ///
-    /// By default, the NFA engines match on Unicode scalar values. They can
-    /// be made to use byte based programs instead. In general, the byte based
-    /// programs are slower because of a less efficient encoding of character
-    /// classes.
-    ///
-    /// Note that this does not impact DFA matching engines, which always
-    /// execute on bytes.
-    pub fn bytes(mut self, yes: bool) -> Self {
-        self.bytes = yes;
-        self
-    }
-
-    /// When disabled, the program compiled may match arbitrary bytes.
-    ///
-    /// When enabled (the default), all compiled programs exclusively match
-    /// valid UTF-8 bytes.
-    pub fn only_utf8(mut self, yes: bool) -> Self {
-        self.only_utf8 = yes;
-        self
-    }
-
-    /// Set the Unicode flag.
-    pub fn unicode(mut self, yes: bool) -> Self {
-        self.options.unicode = yes;
-        self
-    }
-
-    /// Parse the current set of patterns into their AST and extract literals.
-    fn parse(&self) -> Result<Parsed, Error> {
-        let mut exprs = Vec::with_capacity(self.options.pats.len());
-        let mut prefixes = Some(literal::Seq::empty());
-        let mut suffixes = Some(literal::Seq::empty());
-        let mut bytes = false;
-        let is_set = self.options.pats.len() > 1;
-        // If we're compiling a regex set and that set has any anchored
-        // expressions, then disable all literal optimizations.
-        for pat in &self.options.pats {
-            let mut parser = ParserBuilder::new()
-                .octal(self.options.octal)
-                .case_insensitive(self.options.case_insensitive)
-                .multi_line(self.options.multi_line)
-                .dot_matches_new_line(self.options.dot_matches_new_line)
-                .swap_greed(self.options.swap_greed)
-                .ignore_whitespace(self.options.ignore_whitespace)
-                .unicode(self.options.unicode)
-                .utf8(self.only_utf8)
-                .nest_limit(self.options.nest_limit)
-                .build();
-            let expr =
-                parser.parse(pat).map_err(|e| Error::Syntax(e.to_string()))?;
-            let props = expr.properties();
-            // This used to just check whether the HIR matched valid UTF-8
-            // or not, but in regex-syntax 0.7, we changed our definition of
-            // "matches valid UTF-8" to exclude zero-width matches. And in
-            // particular, previously, we considered WordAsciiNegate (that
-            // is '(?-u:\B)') to be capable of matching invalid UTF-8. Our
-            // matcher engines were built under this assumption and fixing
-            // them is not worth it with the imminent plan to switch over to
-            // regex-automata. So for now, we retain the previous behavior by
-            // just explicitly treating the presence of a negated ASCII word
-            // boundary as forcing use to use a byte oriented automaton.
-            bytes = bytes
-                || !props.is_utf8()
-                || props.look_set().contains(Look::WordAsciiNegate);
-
-            if cfg!(feature = "perf-literal") {
-                if !props.look_set_prefix().contains(Look::Start)
-                    && props.look_set().contains(Look::Start)
-                {
-                    // Partial anchors unfortunately make it hard to use
-                    // prefixes, so disable them.
-                    prefixes = None;
-                } else if is_set
-                    && props.look_set_prefix_any().contains(Look::Start)
-                {
-                    // Regex sets with anchors do not go well with literal
-                    // optimizations.
-                    prefixes = None;
-                } else if props.look_set_prefix_any().contains_word() {
-                    // The new literal extractor ignores look-around while
-                    // the old one refused to extract prefixes from regexes
-                    // that began with a \b. These old creaky regex internals
-                    // can't deal with it, so we drop it.
-                    prefixes = None;
-                } else if props.look_set_prefix_any().contains(Look::StartLF) {
-                    // Similar to the reasoning for word boundaries, this old
-                    // regex engine can't handle literal prefixes with '(?m:^)'
-                    // at the beginning of a regex.
-                    prefixes = None;
-                }
-
-                if !props.look_set_suffix().contains(Look::End)
-                    && props.look_set().contains(Look::End)
-                {
-                    // Partial anchors unfortunately make it hard to use
-                    // suffixes, so disable them.
-                    suffixes = None;
-                } else if is_set
-                    && props.look_set_suffix_any().contains(Look::End)
-                {
-                    // Regex sets with anchors do not go well with literal
-                    // optimizations.
-                    suffixes = None;
-                } else if props.look_set_suffix_any().contains_word() {
-                    // See the prefix case for reasoning here.
-                    suffixes = None;
-                } else if props.look_set_suffix_any().contains(Look::EndLF) {
-                    // See the prefix case for reasoning here.
-                    suffixes = None;
-                }
-
-                let (mut pres, mut suffs) =
-                    if prefixes.is_none() && suffixes.is_none() {
-                        (literal::Seq::infinite(), literal::Seq::infinite())
-                    } else {
-                        literal_analysis(&expr)
-                    };
-                // These old creaky regex internals can't handle cases where
-                // the literal sequences are exact but there are look-around
-                // assertions. So we make sure the sequences are inexact if
-                // there are look-around assertions anywhere. This forces the
-                // regex engines to run instead of assuming that a literal
-                // match implies an overall match.
-                if !props.look_set().is_empty() {
-                    pres.make_inexact();
-                    suffs.make_inexact();
-                }
-                prefixes = prefixes.and_then(|mut prefixes| {
-                    prefixes.union(&mut pres);
-                    Some(prefixes)
-                });
-                suffixes = suffixes.and_then(|mut suffixes| {
-                    suffixes.union(&mut suffs);
-                    Some(suffixes)
-                });
-            }
-            exprs.push(expr);
-        }
-        Ok(Parsed {
-            exprs,
-            prefixes: prefixes.unwrap_or_else(literal::Seq::empty),
-            suffixes: suffixes.unwrap_or_else(literal::Seq::empty),
-            bytes,
-        })
-    }
-
-    /// Build an executor that can run a regular expression.
-    pub fn build(self) -> Result<Exec, Error> {
-        // Special case when we have no patterns to compile.
-        // This can happen when compiling a regex set.
-        if self.options.pats.is_empty() {
-            let ro = Arc::new(ExecReadOnly {
-                res: vec![],
-                nfa: Program::new(),
-                dfa: Program::new(),
-                dfa_reverse: Program::new(),
-                suffixes: LiteralSearcher::empty(),
-                #[cfg(feature = "perf-literal")]
-                ac: None,
-                match_type: MatchType::Nothing,
-            });
-            let pool = ExecReadOnly::new_pool(&ro);
-            return Ok(Exec { ro, pool });
-        }
-        let parsed = self.parse()?;
-        let mut nfa = Compiler::new()
-            .size_limit(self.options.size_limit)
-            .bytes(self.bytes || parsed.bytes)
-            .only_utf8(self.only_utf8)
-            .compile(&parsed.exprs)?;
-        let mut dfa = Compiler::new()
-            .size_limit(self.options.size_limit)
-            .dfa(true)
-            .only_utf8(self.only_utf8)
-            .compile(&parsed.exprs)?;
-        let mut dfa_reverse = Compiler::new()
-            .size_limit(self.options.size_limit)
-            .dfa(true)
-            .only_utf8(self.only_utf8)
-            .reverse(true)
-            .compile(&parsed.exprs)?;
-
-        #[cfg(feature = "perf-literal")]
-        let ac = self.build_aho_corasick(&parsed);
-        nfa.prefixes = LiteralSearcher::prefixes(parsed.prefixes);
-        dfa.prefixes = nfa.prefixes.clone();
-        dfa.dfa_size_limit = self.options.dfa_size_limit;
-        dfa_reverse.dfa_size_limit = self.options.dfa_size_limit;
-
-        let mut ro = ExecReadOnly {
-            res: self.options.pats,
-            nfa,
-            dfa,
-            dfa_reverse,
-            suffixes: LiteralSearcher::suffixes(parsed.suffixes),
-            #[cfg(feature = "perf-literal")]
-            ac,
-            match_type: MatchType::Nothing,
-        };
-        ro.match_type = ro.choose_match_type(self.match_type);
-
-        let ro = Arc::new(ro);
-        let pool = ExecReadOnly::new_pool(&ro);
-        Ok(Exec { ro, pool })
-    }
-
-    #[cfg(feature = "perf-literal")]
-    fn build_aho_corasick(&self, parsed: &Parsed) -> Option<AhoCorasick> {
-        if parsed.exprs.len() != 1 {
-            return None;
-        }
-        let lits = match alternation_literals(&parsed.exprs[0]) {
-            None => return None,
-            Some(lits) => lits,
-        };
-        // If we have a small number of literals, then let Teddy handle
-        // things (see literal/mod.rs).
-        if lits.len() <= 32 {
-            return None;
-        }
-        Some(
-            AhoCorasick::builder()
-                .match_kind(MatchKind::LeftmostFirst)
-                .build(&lits)
-                // This should never happen because we'd long exceed the
-                // compilation limit for regexes first.
-                .expect("AC automaton too big"),
-        )
-    }
-}
-
-impl<'c> RegularExpression for ExecNoSyncStr<'c> {
-    type Text = str;
-
-    fn slots_len(&self) -> usize {
-        self.0.slots_len()
-    }
-
-    fn next_after_empty(&self, text: &str, i: usize) -> usize {
-        next_utf8(text.as_bytes(), i)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn shortest_match_at(&self, text: &str, start: usize) -> Option<usize> {
-        self.0.shortest_match_at(text.as_bytes(), start)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match_at(&self, text: &str, start: usize) -> bool {
-        self.0.is_match_at(text.as_bytes(), start)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
-        self.0.find_at(text.as_bytes(), start)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn captures_read_at(
-        &self,
-        locs: &mut Locations,
-        text: &str,
-        start: usize,
-    ) -> Option<(usize, usize)> {
-        self.0.captures_read_at(locs, text.as_bytes(), start)
-    }
-}
-
-impl<'c> RegularExpression for ExecNoSync<'c> {
-    type Text = [u8];
-
-    /// Returns the number of capture slots in the regular expression. (There
-    /// are two slots for every capture group, corresponding to possibly empty
-    /// start and end locations of the capture.)
-    fn slots_len(&self) -> usize {
-        self.ro.nfa.captures.len() * 2
-    }
-
-    fn next_after_empty(&self, _text: &[u8], i: usize) -> usize {
-        i + 1
-    }
-
-    /// Returns the end of a match location, possibly occurring before the
-    /// end location of the correct leftmost-first match.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn shortest_match_at(&self, text: &[u8], start: usize) -> Option<usize> {
-        if !self.is_anchor_end_match(text) {
-            return None;
-        }
-        match self.ro.match_type {
-            #[cfg(feature = "perf-literal")]
-            MatchType::Literal(ty) => {
-                self.find_literals(ty, text, start).map(|(_, e)| e)
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::Dfa | MatchType::DfaMany => {
-                match self.shortest_dfa(text, start) {
-                    dfa::Result::Match(end) => Some(end),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => self.shortest_nfa(text, start),
-                }
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaAnchoredReverse => {
-                match dfa::Fsm::reverse(
-                    &self.ro.dfa_reverse,
-                    self.cache.value(),
-                    true,
-                    &text[start..],
-                    text.len() - start,
-                ) {
-                    dfa::Result::Match(_) => Some(text.len()),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => self.shortest_nfa(text, start),
-                }
-            }
-            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-            MatchType::DfaSuffix => {
-                match self.shortest_dfa_reverse_suffix(text, start) {
-                    dfa::Result::Match(e) => Some(e),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => self.shortest_nfa(text, start),
-                }
-            }
-            MatchType::Nfa(ty) => self.shortest_nfa_type(ty, text, start),
-            MatchType::Nothing => None,
-        }
-    }
-
-    /// Returns true if and only if the regex matches text.
-    ///
-    /// For single regular expressions, this is equivalent to calling
-    /// shortest_match(...).is_some().
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match_at(&self, text: &[u8], start: usize) -> bool {
-        if !self.is_anchor_end_match(text) {
-            return false;
-        }
-        // We need to do this dance because shortest_match relies on the NFA
-        // filling in captures[1], but a RegexSet has no captures. In other
-        // words, a RegexSet can't (currently) use shortest_match. ---AG
-        match self.ro.match_type {
-            #[cfg(feature = "perf-literal")]
-            MatchType::Literal(ty) => {
-                self.find_literals(ty, text, start).is_some()
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::Dfa | MatchType::DfaMany => {
-                match self.shortest_dfa(text, start) {
-                    dfa::Result::Match(_) => true,
-                    dfa::Result::NoMatch(_) => false,
-                    dfa::Result::Quit => self.match_nfa(text, start),
-                }
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaAnchoredReverse => {
-                match dfa::Fsm::reverse(
-                    &self.ro.dfa_reverse,
-                    self.cache.value(),
-                    true,
-                    &text[start..],
-                    text.len() - start,
-                ) {
-                    dfa::Result::Match(_) => true,
-                    dfa::Result::NoMatch(_) => false,
-                    dfa::Result::Quit => self.match_nfa(text, start),
-                }
-            }
-            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-            MatchType::DfaSuffix => {
-                match self.shortest_dfa_reverse_suffix(text, start) {
-                    dfa::Result::Match(_) => true,
-                    dfa::Result::NoMatch(_) => false,
-                    dfa::Result::Quit => self.match_nfa(text, start),
-                }
-            }
-            MatchType::Nfa(ty) => self.match_nfa_type(ty, text, start),
-            MatchType::Nothing => false,
-        }
-    }
-
-    /// Finds the start and end location of the leftmost-first match, starting
-    /// at the given location.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_at(&self, text: &[u8], start: usize) -> Option<(usize, usize)> {
-        if !self.is_anchor_end_match(text) {
-            return None;
-        }
-        match self.ro.match_type {
-            #[cfg(feature = "perf-literal")]
-            MatchType::Literal(ty) => self.find_literals(ty, text, start),
-            #[cfg(feature = "perf-dfa")]
-            MatchType::Dfa => match self.find_dfa_forward(text, start) {
-                dfa::Result::Match((s, e)) => Some((s, e)),
-                dfa::Result::NoMatch(_) => None,
-                dfa::Result::Quit => {
-                    self.find_nfa(MatchNfaType::Auto, text, start)
-                }
-            },
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaAnchoredReverse => {
-                match self.find_dfa_anchored_reverse(text, start) {
-                    dfa::Result::Match((s, e)) => Some((s, e)),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => {
-                        self.find_nfa(MatchNfaType::Auto, text, start)
-                    }
-                }
-            }
-            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-            MatchType::DfaSuffix => {
-                match self.find_dfa_reverse_suffix(text, start) {
-                    dfa::Result::Match((s, e)) => Some((s, e)),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => {
-                        self.find_nfa(MatchNfaType::Auto, text, start)
-                    }
-                }
-            }
-            MatchType::Nfa(ty) => self.find_nfa(ty, text, start),
-            MatchType::Nothing => None,
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaMany => {
-                unreachable!("BUG: RegexSet cannot be used with find")
-            }
-        }
-    }
-
-    /// Finds the start and end location of the leftmost-first match and also
-    /// fills in all matching capture groups.
-    ///
-    /// The number of capture slots given should be equal to the total number
-    /// of capture slots in the compiled program.
-    ///
-    /// Note that the first two slots always correspond to the start and end
-    /// locations of the overall match.
-    fn captures_read_at(
-        &self,
-        locs: &mut Locations,
-        text: &[u8],
-        start: usize,
-    ) -> Option<(usize, usize)> {
-        let slots = locs.as_slots();
-        for slot in slots.iter_mut() {
-            *slot = None;
-        }
-        // If the caller unnecessarily uses this, then we try to save them
-        // from themselves.
-        match slots.len() {
-            0 => return self.find_at(text, start),
-            2 => {
-                return self.find_at(text, start).map(|(s, e)| {
-                    slots[0] = Some(s);
-                    slots[1] = Some(e);
-                    (s, e)
-                });
-            }
-            _ => {} // fallthrough
-        }
-        if !self.is_anchor_end_match(text) {
-            return None;
-        }
-        match self.ro.match_type {
-            #[cfg(feature = "perf-literal")]
-            MatchType::Literal(ty) => {
-                self.find_literals(ty, text, start).and_then(|(s, e)| {
-                    self.captures_nfa_type(
-                        MatchNfaType::Auto,
-                        slots,
-                        text,
-                        s,
-                        e,
-                    )
-                })
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::Dfa => {
-                if self.ro.nfa.is_anchored_start {
-                    self.captures_nfa(slots, text, start)
-                } else {
-                    match self.find_dfa_forward(text, start) {
-                        dfa::Result::Match((s, e)) => self.captures_nfa_type(
-                            MatchNfaType::Auto,
-                            slots,
-                            text,
-                            s,
-                            e,
-                        ),
-                        dfa::Result::NoMatch(_) => None,
-                        dfa::Result::Quit => {
-                            self.captures_nfa(slots, text, start)
-                        }
-                    }
-                }
-            }
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaAnchoredReverse => {
-                match self.find_dfa_anchored_reverse(text, start) {
-                    dfa::Result::Match((s, e)) => self.captures_nfa_type(
-                        MatchNfaType::Auto,
-                        slots,
-                        text,
-                        s,
-                        e,
-                    ),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => self.captures_nfa(slots, text, start),
-                }
-            }
-            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-            MatchType::DfaSuffix => {
-                match self.find_dfa_reverse_suffix(text, start) {
-                    dfa::Result::Match((s, e)) => self.captures_nfa_type(
-                        MatchNfaType::Auto,
-                        slots,
-                        text,
-                        s,
-                        e,
-                    ),
-                    dfa::Result::NoMatch(_) => None,
-                    dfa::Result::Quit => self.captures_nfa(slots, text, start),
-                }
-            }
-            MatchType::Nfa(ty) => {
-                self.captures_nfa_type(ty, slots, text, start, text.len())
-            }
-            MatchType::Nothing => None,
-            #[cfg(feature = "perf-dfa")]
-            MatchType::DfaMany => {
-                unreachable!("BUG: RegexSet cannot be used with captures")
-            }
-        }
-    }
-}
-
-impl<'c> ExecNoSync<'c> {
-    /// Finds the leftmost-first match using only literal search.
-    #[cfg(feature = "perf-literal")]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_literals(
-        &self,
-        ty: MatchLiteralType,
-        text: &[u8],
-        start: usize,
-    ) -> Option<(usize, usize)> {
-        use self::MatchLiteralType::*;
-        match ty {
-            Unanchored => {
-                let lits = &self.ro.nfa.prefixes;
-                lits.find(&text[start..]).map(|(s, e)| (start + s, start + e))
-            }
-            AnchoredStart => {
-                let lits = &self.ro.nfa.prefixes;
-                if start == 0 || !self.ro.nfa.is_anchored_start {
-                    lits.find_start(&text[start..])
-                        .map(|(s, e)| (start + s, start + e))
-                } else {
-                    None
-                }
-            }
-            AnchoredEnd => {
-                let lits = &self.ro.suffixes;
-                lits.find_end(&text[start..])
-                    .map(|(s, e)| (start + s, start + e))
-            }
-            AhoCorasick => self
-                .ro
-                .ac
-                .as_ref()
-                .unwrap()
-                .find(&text[start..])
-                .map(|m| (start + m.start(), start + m.end())),
-        }
-    }
-
-    /// Finds the leftmost-first match (start and end) using only the DFA.
-    ///
-    /// If the result returned indicates that the DFA quit, then another
-    /// matching engine should be used.
-    #[cfg(feature = "perf-dfa")]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_dfa_forward(
-        &self,
-        text: &[u8],
-        start: usize,
-    ) -> dfa::Result<(usize, usize)> {
-        use crate::dfa::Result::*;
-        let end = match dfa::Fsm::forward(
-            &self.ro.dfa,
-            self.cache.value(),
-            false,
-            text,
-            start,
-        ) {
-            NoMatch(i) => return NoMatch(i),
-            Quit => return Quit,
-            Match(end) if start == end => return Match((start, start)),
-            Match(end) => end,
-        };
-        // Now run the DFA in reverse to find the start of the match.
-        match dfa::Fsm::reverse(
-            &self.ro.dfa_reverse,
-            self.cache.value(),
-            false,
-            &text[start..],
-            end - start,
-        ) {
-            Match(s) => Match((start + s, end)),
-            NoMatch(i) => NoMatch(i),
-            Quit => Quit,
-        }
-    }
-
-    /// Finds the leftmost-first match (start and end) using only the DFA,
-    /// but assumes the regex is anchored at the end and therefore starts at
-    /// the end of the regex and matches in reverse.
-    ///
-    /// If the result returned indicates that the DFA quit, then another
-    /// matching engine should be used.
-    #[cfg(feature = "perf-dfa")]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_dfa_anchored_reverse(
-        &self,
-        text: &[u8],
-        start: usize,
-    ) -> dfa::Result<(usize, usize)> {
-        use crate::dfa::Result::*;
-        match dfa::Fsm::reverse(
-            &self.ro.dfa_reverse,
-            self.cache.value(),
-            false,
-            &text[start..],
-            text.len() - start,
-        ) {
-            Match(s) => Match((start + s, text.len())),
-            NoMatch(i) => NoMatch(i),
-            Quit => Quit,
-        }
-    }
-
-    /// Finds the end of the shortest match using only the DFA.
-    #[cfg(feature = "perf-dfa")]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn shortest_dfa(&self, text: &[u8], start: usize) -> dfa::Result<usize> {
-        dfa::Fsm::forward(&self.ro.dfa, self.cache.value(), true, text, start)
-    }
-
-    /// Finds the end of the shortest match using only the DFA by scanning for
-    /// suffix literals.
-    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn shortest_dfa_reverse_suffix(
-        &self,
-        text: &[u8],
-        start: usize,
-    ) -> dfa::Result<usize> {
-        match self.exec_dfa_reverse_suffix(text, start) {
-            None => self.shortest_dfa(text, start),
-            Some(r) => r.map(|(_, end)| end),
-        }
-    }
-
-    /// Finds the end of the shortest match using only the DFA by scanning for
-    /// suffix literals. It also reports the start of the match.
-    ///
-    /// Note that if None is returned, then the optimization gave up to avoid
-    /// worst case quadratic behavior. A forward scanning DFA should be tried
-    /// next.
-    ///
-    /// If a match is returned and the full leftmost-first match is desired,
-    /// then a forward scan starting from the beginning of the match must be
-    /// done.
-    ///
-    /// If the result returned indicates that the DFA quit, then another
-    /// matching engine should be used.
-    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn exec_dfa_reverse_suffix(
-        &self,
-        text: &[u8],
-        original_start: usize,
-    ) -> Option<dfa::Result<(usize, usize)>> {
-        use crate::dfa::Result::*;
-
-        let lcs = self.ro.suffixes.lcs();
-        debug_assert!(lcs.len() >= 1);
-        let mut start = original_start;
-        let mut end = start;
-        let mut last_literal = start;
-        while end <= text.len() {
-            last_literal += match lcs.find(&text[last_literal..]) {
-                None => return Some(NoMatch(text.len())),
-                Some(i) => i,
-            };
-            end = last_literal + lcs.len();
-            match dfa::Fsm::reverse(
-                &self.ro.dfa_reverse,
-                self.cache.value(),
-                false,
-                &text[start..end],
-                end - start,
-            ) {
-                Match(0) | NoMatch(0) => return None,
-                Match(i) => return Some(Match((start + i, end))),
-                NoMatch(i) => {
-                    start += i;
-                    last_literal += 1;
-                    continue;
-                }
-                Quit => return Some(Quit),
-            };
-        }
-        Some(NoMatch(text.len()))
-    }
-
-    /// Finds the leftmost-first match (start and end) using only the DFA
-    /// by scanning for suffix literals.
-    ///
-    /// If the result returned indicates that the DFA quit, then another
-    /// matching engine should be used.
-    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find_dfa_reverse_suffix(
-        &self,
-        text: &[u8],
-        start: usize,
-    ) -> dfa::Result<(usize, usize)> {
-        use crate::dfa::Result::*;
-
-        let match_start = match self.exec_dfa_reverse_suffix(text, start) {
-            None => return self.find_dfa_forward(text, start),
-            Some(Match((start, _))) => start,
-            Some(r) => return r,
-        };
-        // At this point, we've found a match. The only way to quit now
-        // without a match is if the DFA gives up (seems unlikely).
-        //
-        // Now run the DFA forwards to find the proper end of the match.
-        // (The suffix literal match can only indicate the earliest
-        // possible end location, which may appear before the end of the
-        // leftmost-first match.)
-        match dfa::Fsm::forward(
-            &self.ro.dfa,
-            self.cache.value(),
-            false,
-            text,
-            match_start,
-        ) {
-            NoMatch(_) => panic!("BUG: reverse match implies forward match"),
-            Quit => Quit,
-            Match(e) => Match((match_start, e)),
-        }
-    }
-
-    /// Executes the NFA engine to return whether there is a match or not.
-    ///
-    /// Ideally, we could use shortest_nfa(...).is_some() and get the same
-    /// performance characteristics, but regex sets don't have captures, which
-    /// shortest_nfa depends on.
-    #[cfg(feature = "perf-dfa")]
-    fn match_nfa(&self, text: &[u8], start: usize) -> bool {
-        self.match_nfa_type(MatchNfaType::Auto, text, start)
-    }
-
-    /// Like match_nfa, but allows specification of the type of NFA engine.
-    fn match_nfa_type(
-        &self,
-        ty: MatchNfaType,
-        text: &[u8],
-        start: usize,
-    ) -> bool {
-        self.exec_nfa(
-            ty,
-            &mut [false],
-            &mut [],
-            true,
-            false,
-            text,
-            start,
-            text.len(),
-        )
-    }
-
-    /// Finds the shortest match using an NFA.
-    #[cfg(feature = "perf-dfa")]
-    fn shortest_nfa(&self, text: &[u8], start: usize) -> Option<usize> {
-        self.shortest_nfa_type(MatchNfaType::Auto, text, start)
-    }
-
-    /// Like shortest_nfa, but allows specification of the type of NFA engine.
-    fn shortest_nfa_type(
-        &self,
-        ty: MatchNfaType,
-        text: &[u8],
-        start: usize,
-    ) -> Option<usize> {
-        let mut slots = [None, None];
-        if self.exec_nfa(
-            ty,
-            &mut [false],
-            &mut slots,
-            true,
-            true,
-            text,
-            start,
-            text.len(),
-        ) {
-            slots[1]
-        } else {
-            None
-        }
-    }
-
-    /// Like find, but executes an NFA engine.
-    fn find_nfa(
-        &self,
-        ty: MatchNfaType,
-        text: &[u8],
-        start: usize,
-    ) -> Option<(usize, usize)> {
-        let mut slots = [None, None];
-        if self.exec_nfa(
-            ty,
-            &mut [false],
-            &mut slots,
-            false,
-            false,
-            text,
-            start,
-            text.len(),
-        ) {
-            match (slots[0], slots[1]) {
-                (Some(s), Some(e)) => Some((s, e)),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-
-    /// Like find_nfa, but fills in captures.
-    ///
-    /// `slots` should have length equal to `2 * nfa.captures.len()`.
-    #[cfg(feature = "perf-dfa")]
-    fn captures_nfa(
-        &self,
-        slots: &mut [Slot],
-        text: &[u8],
-        start: usize,
-    ) -> Option<(usize, usize)> {
-        self.captures_nfa_type(
-            MatchNfaType::Auto,
-            slots,
-            text,
-            start,
-            text.len(),
-        )
-    }
-
-    /// Like captures_nfa, but allows specification of type of NFA engine.
-    fn captures_nfa_type(
-        &self,
-        ty: MatchNfaType,
-        slots: &mut [Slot],
-        text: &[u8],
-        start: usize,
-        end: usize,
-    ) -> Option<(usize, usize)> {
-        if self.exec_nfa(
-            ty,
-            &mut [false],
-            slots,
-            false,
-            false,
-            text,
-            start,
-            end,
-        ) {
-            match (slots[0], slots[1]) {
-                (Some(s), Some(e)) => Some((s, e)),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-
-    fn exec_nfa(
-        &self,
-        mut ty: MatchNfaType,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        quit_after_match: bool,
-        quit_after_match_with_pos: bool,
-        text: &[u8],
-        start: usize,
-        end: usize,
-    ) -> bool {
-        use self::MatchNfaType::*;
-        if let Auto = ty {
-            if backtrack::should_exec(self.ro.nfa.len(), text.len()) {
-                ty = Backtrack;
-            } else {
-                ty = PikeVM;
-            }
-        }
-        // The backtracker can't return the shortest match position as it is
-        // implemented today. So if someone calls `shortest_match` and we need
-        // to run an NFA, then use the PikeVM.
-        if quit_after_match_with_pos || ty == PikeVM {
-            self.exec_pikevm(
-                matches,
-                slots,
-                quit_after_match,
-                text,
-                start,
-                end,
-            )
-        } else {
-            self.exec_backtrack(matches, slots, text, start, end)
-        }
-    }
-
-    /// Always run the NFA algorithm.
-    fn exec_pikevm(
-        &self,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        quit_after_match: bool,
-        text: &[u8],
-        start: usize,
-        end: usize,
-    ) -> bool {
-        if self.ro.nfa.uses_bytes() {
-            pikevm::Fsm::exec(
-                &self.ro.nfa,
-                self.cache.value(),
-                matches,
-                slots,
-                quit_after_match,
-                ByteInput::new(text, self.ro.nfa.only_utf8),
-                start,
-                end,
-            )
-        } else {
-            pikevm::Fsm::exec(
-                &self.ro.nfa,
-                self.cache.value(),
-                matches,
-                slots,
-                quit_after_match,
-                CharInput::new(text),
-                start,
-                end,
-            )
-        }
-    }
-
-    /// Always runs the NFA using bounded backtracking.
-    fn exec_backtrack(
-        &self,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        text: &[u8],
-        start: usize,
-        end: usize,
-    ) -> bool {
-        if self.ro.nfa.uses_bytes() {
-            backtrack::Bounded::exec(
-                &self.ro.nfa,
-                self.cache.value(),
-                matches,
-                slots,
-                ByteInput::new(text, self.ro.nfa.only_utf8),
-                start,
-                end,
-            )
-        } else {
-            backtrack::Bounded::exec(
-                &self.ro.nfa,
-                self.cache.value(),
-                matches,
-                slots,
-                CharInput::new(text),
-                start,
-                end,
-            )
-        }
-    }
-
-    /// Finds which regular expressions match the given text.
-    ///
-    /// `matches` should have length equal to the number of regexes being
-    /// searched.
-    ///
-    /// This is only useful when one wants to know which regexes in a set
-    /// match some text.
-    pub fn many_matches_at(
-        &self,
-        matches: &mut [bool],
-        text: &[u8],
-        start: usize,
-    ) -> bool {
-        use self::MatchType::*;
-        if !self.is_anchor_end_match(text) {
-            return false;
-        }
-        match self.ro.match_type {
-            #[cfg(feature = "perf-literal")]
-            Literal(ty) => {
-                debug_assert_eq!(matches.len(), 1);
-                matches[0] = self.find_literals(ty, text, start).is_some();
-                matches[0]
-            }
-            #[cfg(feature = "perf-dfa")]
-            Dfa | DfaAnchoredReverse | DfaMany => {
-                match dfa::Fsm::forward_many(
-                    &self.ro.dfa,
-                    self.cache.value(),
-                    matches,
-                    text,
-                    start,
-                ) {
-                    dfa::Result::Match(_) => true,
-                    dfa::Result::NoMatch(_) => false,
-                    dfa::Result::Quit => self.exec_nfa(
-                        MatchNfaType::Auto,
-                        matches,
-                        &mut [],
-                        false,
-                        false,
-                        text,
-                        start,
-                        text.len(),
-                    ),
-                }
-            }
-            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-            DfaSuffix => {
-                match dfa::Fsm::forward_many(
-                    &self.ro.dfa,
-                    self.cache.value(),
-                    matches,
-                    text,
-                    start,
-                ) {
-                    dfa::Result::Match(_) => true,
-                    dfa::Result::NoMatch(_) => false,
-                    dfa::Result::Quit => self.exec_nfa(
-                        MatchNfaType::Auto,
-                        matches,
-                        &mut [],
-                        false,
-                        false,
-                        text,
-                        start,
-                        text.len(),
-                    ),
-                }
-            }
-            Nfa(ty) => self.exec_nfa(
-                ty,
-                matches,
-                &mut [],
-                false,
-                false,
-                text,
-                start,
-                text.len(),
-            ),
-            Nothing => false,
-        }
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_anchor_end_match(&self, text: &[u8]) -> bool {
-        #[cfg(not(feature = "perf-literal"))]
-        fn imp(_: &ExecReadOnly, _: &[u8]) -> bool {
-            true
-        }
-
-        #[cfg(feature = "perf-literal")]
-        fn imp(ro: &ExecReadOnly, text: &[u8]) -> bool {
-            // Only do this check if the haystack is big (>1MB).
-            if text.len() > (1 << 20) && ro.nfa.is_anchored_end {
-                let lcs = ro.suffixes.lcs();
-                if lcs.len() >= 1 && !lcs.is_suffix(text) {
-                    return false;
-                }
-            }
-            true
-        }
-
-        imp(&self.ro, text)
-    }
-
-    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
-        &self.ro.nfa.capture_name_idx
-    }
-}
-
-impl<'c> ExecNoSyncStr<'c> {
-    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
-        self.0.capture_name_idx()
-    }
-}
-
-impl Exec {
-    /// Get a searcher that isn't Sync.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn searcher(&self) -> ExecNoSync<'_> {
-        ExecNoSync {
-            ro: &self.ro, // a clone is too expensive here! (and not needed)
-            cache: self.pool.get(),
-        }
-    }
-
-    /// Get a searcher that isn't Sync and can match on &str.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn searcher_str(&self) -> ExecNoSyncStr<'_> {
-        ExecNoSyncStr(self.searcher())
-    }
-
-    /// Build a Regex from this executor.
-    pub fn into_regex(self) -> re_unicode::Regex {
-        re_unicode::Regex::from(self)
-    }
-
-    /// Build a RegexSet from this executor.
-    pub fn into_regex_set(self) -> re_set::unicode::RegexSet {
-        re_set::unicode::RegexSet::from(self)
-    }
-
-    /// Build a Regex from this executor that can match arbitrary bytes.
-    pub fn into_byte_regex(self) -> re_bytes::Regex {
-        re_bytes::Regex::from(self)
-    }
-
-    /// Build a RegexSet from this executor that can match arbitrary bytes.
-    pub fn into_byte_regex_set(self) -> re_set::bytes::RegexSet {
-        re_set::bytes::RegexSet::from(self)
-    }
-
-    /// The original regular expressions given by the caller that were
-    /// compiled.
-    pub fn regex_strings(&self) -> &[String] {
-        &self.ro.res
-    }
-
-    /// Return a slice of capture names.
-    ///
-    /// Any capture that isn't named is None.
-    pub fn capture_names(&self) -> &[Option<String>] {
-        &self.ro.nfa.captures
-    }
-
-    /// Return a reference to named groups mapping (from group name to
-    /// group position).
-    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
-        &self.ro.nfa.capture_name_idx
-    }
-
-    /// If the number of capture groups in every match is always the same, then
-    /// return that number. Otherwise return `None`.
-    pub fn static_captures_len(&self) -> Option<usize> {
-        self.ro.nfa.static_captures_len
-    }
-}
-
-impl Clone for Exec {
-    fn clone(&self) -> Exec {
-        let pool = ExecReadOnly::new_pool(&self.ro);
-        Exec { ro: self.ro.clone(), pool }
-    }
-}
-
-impl ExecReadOnly {
-    fn choose_match_type(&self, hint: Option<MatchType>) -> MatchType {
-        if let Some(MatchType::Nfa(_)) = hint {
-            return hint.unwrap();
-        }
-        // If the NFA is empty, then we'll never match anything.
-        if self.nfa.insts.is_empty() {
-            return MatchType::Nothing;
-        }
-        if let Some(literalty) = self.choose_literal_match_type() {
-            return literalty;
-        }
-        if let Some(dfaty) = self.choose_dfa_match_type() {
-            return dfaty;
-        }
-        // We're so totally hosed.
-        MatchType::Nfa(MatchNfaType::Auto)
-    }
-
-    /// If a plain literal scan can be used, then a corresponding literal
-    /// search type is returned.
-    fn choose_literal_match_type(&self) -> Option<MatchType> {
-        #[cfg(not(feature = "perf-literal"))]
-        fn imp(_: &ExecReadOnly) -> Option<MatchType> {
-            None
-        }
-
-        #[cfg(feature = "perf-literal")]
-        fn imp(ro: &ExecReadOnly) -> Option<MatchType> {
-            // If our set of prefixes is complete, then we can use it to find
-            // a match in lieu of a regex engine. This doesn't quite work well
-            // in the presence of multiple regexes, so only do it when there's
-            // one.
-            //
-            // TODO(burntsushi): Also, don't try to match literals if the regex
-            // is partially anchored. We could technically do it, but we'd need
-            // to create two sets of literals: all of them and then the subset
-            // that aren't anchored. We would then only search for all of them
-            // when at the beginning of the input and use the subset in all
-            // other cases.
-            if ro.res.len() != 1 {
-                return None;
-            }
-            if ro.ac.is_some() {
-                return Some(MatchType::Literal(
-                    MatchLiteralType::AhoCorasick,
-                ));
-            }
-            if ro.nfa.prefixes.complete() {
-                return if ro.nfa.is_anchored_start {
-                    Some(MatchType::Literal(MatchLiteralType::AnchoredStart))
-                } else {
-                    Some(MatchType::Literal(MatchLiteralType::Unanchored))
-                };
-            }
-            if ro.suffixes.complete() {
-                return if ro.nfa.is_anchored_end {
-                    Some(MatchType::Literal(MatchLiteralType::AnchoredEnd))
-                } else {
-                    // This case shouldn't happen. When the regex isn't
-                    // anchored, then complete prefixes should imply complete
-                    // suffixes.
-                    //
-                    // The above is wrong! This case can happen. While
-                    // complete prefixes should imply complete suffixes
-                    // here, that doesn't necessarily mean we have a useful
-                    // prefix matcher! It could be the case that the literal
-                    // searcher decided the prefixes---even though they are
-                    // "complete"---weren't good enough and thus created an
-                    // empty matcher. If that happens and we return Unanchored
-                    // here, then we'll end up using that matcher, which is
-                    // very bad because it matches at every position. So...
-                    // return None.
-                    None
-                };
-            }
-            None
-        }
-
-        imp(self)
-    }
-
-    /// If a DFA scan can be used, then choose the appropriate DFA strategy.
-    fn choose_dfa_match_type(&self) -> Option<MatchType> {
-        #[cfg(not(feature = "perf-dfa"))]
-        fn imp(_: &ExecReadOnly) -> Option<MatchType> {
-            None
-        }
-
-        #[cfg(feature = "perf-dfa")]
-        fn imp(ro: &ExecReadOnly) -> Option<MatchType> {
-            if !dfa::can_exec(&ro.dfa) {
-                return None;
-            }
-            // Regex sets require a slightly specialized path.
-            if ro.res.len() >= 2 {
-                return Some(MatchType::DfaMany);
-            }
-            // If the regex is anchored at the end but not the start, then
-            // just match in reverse from the end of the haystack.
-            if !ro.nfa.is_anchored_start && ro.nfa.is_anchored_end {
-                return Some(MatchType::DfaAnchoredReverse);
-            }
-            #[cfg(feature = "perf-literal")]
-            {
-                // If there's a longish suffix literal, then it might be faster
-                // to look for that first.
-                if ro.should_suffix_scan() {
-                    return Some(MatchType::DfaSuffix);
-                }
-            }
-            // Fall back to your garden variety forward searching lazy DFA.
-            Some(MatchType::Dfa)
-        }
-
-        imp(self)
-    }
-
-    /// Returns true if the program is amenable to suffix scanning.
-    ///
-    /// When this is true, as a heuristic, we assume it is OK to quickly scan
-    /// for suffix literals and then do a *reverse* DFA match from any matches
-    /// produced by the literal scan. (And then followed by a forward DFA
-    /// search, since the previously found suffix literal maybe not actually be
-    /// the end of a match.)
-    ///
-    /// This is a bit of a specialized optimization, but can result in pretty
-    /// big performance wins if 1) there are no prefix literals and 2) the
-    /// suffix literals are pretty rare in the text. (1) is obviously easy to
-    /// account for but (2) is harder. As a proxy, we assume that longer
-    /// strings are generally rarer, so we only enable this optimization when
-    /// we have a meaty suffix.
-    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-    fn should_suffix_scan(&self) -> bool {
-        if self.suffixes.is_empty() {
-            return false;
-        }
-        let lcs_len = self.suffixes.lcs().char_len();
-        lcs_len >= 3 && lcs_len > self.dfa.prefixes.lcp().char_len()
-    }
-
-    fn new_pool(ro: &Arc<ExecReadOnly>) -> Box<Pool<ProgramCache>> {
-        let ro = ro.clone();
-        Box::new(Pool::new(Box::new(move || {
-            AssertUnwindSafe(RefCell::new(ProgramCacheInner::new(&ro)))
-        })))
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-enum MatchType {
-    /// A single or multiple literal search. This is only used when the regex
-    /// can be decomposed into a literal search.
-    #[cfg(feature = "perf-literal")]
-    Literal(MatchLiteralType),
-    /// A normal DFA search.
-    #[cfg(feature = "perf-dfa")]
-    Dfa,
-    /// A reverse DFA search starting from the end of a haystack.
-    #[cfg(feature = "perf-dfa")]
-    DfaAnchoredReverse,
-    /// A reverse DFA search with suffix literal scanning.
-    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
-    DfaSuffix,
-    /// Use the DFA on two or more regular expressions.
-    #[cfg(feature = "perf-dfa")]
-    DfaMany,
-    /// An NFA variant.
-    Nfa(MatchNfaType),
-    /// No match is ever possible, so don't ever try to search.
-    Nothing,
-}
-
-#[derive(Clone, Copy, Debug)]
-#[cfg(feature = "perf-literal")]
-enum MatchLiteralType {
-    /// Match literals anywhere in text.
-    Unanchored,
-    /// Match literals only at the start of text.
-    AnchoredStart,
-    /// Match literals only at the end of text.
-    AnchoredEnd,
-    /// Use an Aho-Corasick automaton. This requires `ac` to be Some on
-    /// ExecReadOnly.
-    AhoCorasick,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum MatchNfaType {
-    /// Choose between Backtrack and PikeVM.
-    Auto,
-    /// NFA bounded backtracking.
-    ///
-    /// (This is only set by tests, since it never makes sense to always want
-    /// backtracking.)
-    Backtrack,
-    /// The Pike VM.
-    ///
-    /// (This is only set by tests, since it never makes sense to always want
-    /// the Pike VM.)
-    PikeVM,
-}
-
-/// `ProgramCache` maintains reusable allocations for each matching engine
-/// available to a particular program.
-///
-/// We declare this as unwind safe since it's a cache that's only used for
-/// performance purposes. If a panic occurs, it is (or should be) always safe
-/// to continue using the same regex object.
-pub type ProgramCache = AssertUnwindSafe<RefCell<ProgramCacheInner>>;
-
-#[derive(Debug)]
-pub struct ProgramCacheInner {
-    pub pikevm: pikevm::Cache,
-    pub backtrack: backtrack::Cache,
-    #[cfg(feature = "perf-dfa")]
-    pub dfa: dfa::Cache,
-    #[cfg(feature = "perf-dfa")]
-    pub dfa_reverse: dfa::Cache,
-}
-
-impl ProgramCacheInner {
-    fn new(ro: &ExecReadOnly) -> Self {
-        ProgramCacheInner {
-            pikevm: pikevm::Cache::new(&ro.nfa),
-            backtrack: backtrack::Cache::new(&ro.nfa),
-            #[cfg(feature = "perf-dfa")]
-            dfa: dfa::Cache::new(&ro.dfa),
-            #[cfg(feature = "perf-dfa")]
-            dfa_reverse: dfa::Cache::new(&ro.dfa_reverse),
-        }
-    }
-}
-
-/// Alternation literals checks if the given HIR is a simple alternation of
-/// literals, and if so, returns them. Otherwise, this returns None.
-#[cfg(feature = "perf-literal")]
-fn alternation_literals(expr: &Hir) -> Option<Vec<Vec<u8>>> {
-    use regex_syntax::hir::{HirKind, Literal};
-
-    // This is pretty hacky, but basically, if `is_alternation_literal` is
-    // true, then we can make several assumptions about the structure of our
-    // HIR. This is what justifies the `unreachable!` statements below.
-    //
-    // This code should be refactored once we overhaul this crate's
-    // optimization pipeline, because this is a terribly inflexible way to go
-    // about things.
-
-    if !expr.properties().is_alternation_literal() {
-        return None;
-    }
-    let alts = match *expr.kind() {
-        HirKind::Alternation(ref alts) => alts,
-        _ => return None, // one literal isn't worth it
-    };
-
-    let mut lits = vec![];
-    for alt in alts {
-        let mut lit = vec![];
-        match *alt.kind() {
-            HirKind::Literal(Literal(ref bytes)) => {
-                lit.extend_from_slice(bytes)
-            }
-            HirKind::Concat(ref exprs) => {
-                for e in exprs {
-                    match *e.kind() {
-                        HirKind::Literal(Literal(ref bytes)) => {
-                            lit.extend_from_slice(bytes);
-                        }
-                        _ => unreachable!("expected literal, got {:?}", e),
-                    }
-                }
-            }
-            _ => unreachable!("expected literal or concat, got {:?}", alt),
-        }
-        lits.push(lit);
-    }
-    Some(lits)
-}
-
-#[cfg(not(feature = "perf-literal"))]
-fn literal_analysis(_: &Hir) -> (literal::Seq, literal::Seq) {
-    (literal::Seq::infinite(), literal::Seq::infinite())
-}
-
-#[cfg(feature = "perf-literal")]
-fn literal_analysis(expr: &Hir) -> (literal::Seq, literal::Seq) {
-    const ATTEMPTS: [(usize, usize); 3] = [(5, 50), (4, 30), (3, 20)];
-
-    let mut prefixes = literal::Extractor::new()
-        .kind(literal::ExtractKind::Prefix)
-        .extract(expr);
-    for (keep, limit) in ATTEMPTS {
-        let len = match prefixes.len() {
-            None => break,
-            Some(len) => len,
-        };
-        if len <= limit {
-            break;
-        }
-        prefixes.keep_first_bytes(keep);
-        prefixes.minimize_by_preference();
-    }
-
-    let mut suffixes = literal::Extractor::new()
-        .kind(literal::ExtractKind::Suffix)
-        .extract(expr);
-    for (keep, limit) in ATTEMPTS {
-        let len = match suffixes.len() {
-            None => break,
-            Some(len) => len,
-        };
-        if len <= limit {
-            break;
-        }
-        suffixes.keep_last_bytes(keep);
-        suffixes.minimize_by_preference();
-    }
-
-    (prefixes, suffixes)
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn uppercut_s_backtracking_bytes_default_bytes_mismatch() {
-        use crate::internal::ExecBuilder;
-
-        let backtrack_bytes_re = ExecBuilder::new("^S")
-            .bounded_backtracking()
-            .only_utf8(false)
-            .build()
-            .map(|exec| exec.into_byte_regex())
-            .map_err(|err| format!("{}", err))
-            .unwrap();
-
-        let default_bytes_re = ExecBuilder::new("^S")
-            .only_utf8(false)
-            .build()
-            .map(|exec| exec.into_byte_regex())
-            .map_err(|err| format!("{}", err))
-            .unwrap();
-
-        let input = vec![83, 83];
-
-        let s1 = backtrack_bytes_re.split(&input);
-        let s2 = default_bytes_re.split(&input);
-        for (chunk1, chunk2) in s1.zip(s2) {
-            assert_eq!(chunk1, chunk2);
-        }
-    }
-
-    #[test]
-    fn unicode_lit_star_backtracking_utf8bytes_default_utf8bytes_mismatch() {
-        use crate::internal::ExecBuilder;
-
-        let backtrack_bytes_re = ExecBuilder::new(r"^(?u:\*)")
-            .bounded_backtracking()
-            .bytes(true)
-            .build()
-            .map(|exec| exec.into_regex())
-            .map_err(|err| format!("{}", err))
-            .unwrap();
-
-        let default_bytes_re = ExecBuilder::new(r"^(?u:\*)")
-            .bytes(true)
-            .build()
-            .map(|exec| exec.into_regex())
-            .map_err(|err| format!("{}", err))
-            .unwrap();
-
-        let input = "**";
-
-        let s1 = backtrack_bytes_re.split(input);
-        let s2 = default_bytes_re.split(input);
-        for (chunk1, chunk2) in s1.zip(s2) {
-            assert_eq!(chunk1, chunk2);
-        }
-    }
-}
diff --git a/src/expand.rs b/src/expand.rs
deleted file mode 100644
index 98fafc949f..0000000000
--- a/src/expand.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-use std::str;
-
-use crate::find_byte::find_byte;
-
-use crate::re_bytes;
-use crate::re_unicode;
-
-pub fn expand_str(
-    caps: &re_unicode::Captures<'_>,
-    mut replacement: &str,
-    dst: &mut String,
-) {
-    while !replacement.is_empty() {
-        match find_byte(b'$', replacement.as_bytes()) {
-            None => break,
-            Some(i) => {
-                dst.push_str(&replacement[..i]);
-                replacement = &replacement[i..];
-            }
-        }
-        if replacement.as_bytes().get(1).map_or(false, |&b| b == b'$') {
-            dst.push_str("$");
-            replacement = &replacement[2..];
-            continue;
-        }
-        debug_assert!(!replacement.is_empty());
-        let cap_ref = match find_cap_ref(replacement.as_bytes()) {
-            Some(cap_ref) => cap_ref,
-            None => {
-                dst.push_str("$");
-                replacement = &replacement[1..];
-                continue;
-            }
-        };
-        replacement = &replacement[cap_ref.end..];
-        match cap_ref.cap {
-            Ref::Number(i) => {
-                dst.push_str(caps.get(i).map(|m| m.as_str()).unwrap_or(""));
-            }
-            Ref::Named(name) => {
-                dst.push_str(
-                    caps.name(name).map(|m| m.as_str()).unwrap_or(""),
-                );
-            }
-        }
-    }
-    dst.push_str(replacement);
-}
-
-pub fn expand_bytes(
-    caps: &re_bytes::Captures<'_>,
-    mut replacement: &[u8],
-    dst: &mut Vec<u8>,
-) {
-    while !replacement.is_empty() {
-        match find_byte(b'$', replacement) {
-            None => break,
-            Some(i) => {
-                dst.extend(&replacement[..i]);
-                replacement = &replacement[i..];
-            }
-        }
-        if replacement.get(1).map_or(false, |&b| b == b'$') {
-            dst.push(b'$');
-            replacement = &replacement[2..];
-            continue;
-        }
-        debug_assert!(!replacement.is_empty());
-        let cap_ref = match find_cap_ref(replacement) {
-            Some(cap_ref) => cap_ref,
-            None => {
-                dst.push(b'$');
-                replacement = &replacement[1..];
-                continue;
-            }
-        };
-        replacement = &replacement[cap_ref.end..];
-        match cap_ref.cap {
-            Ref::Number(i) => {
-                dst.extend(caps.get(i).map(|m| m.as_bytes()).unwrap_or(b""));
-            }
-            Ref::Named(name) => {
-                dst.extend(
-                    caps.name(name).map(|m| m.as_bytes()).unwrap_or(b""),
-                );
-            }
-        }
-    }
-    dst.extend(replacement);
-}
-
-/// `CaptureRef` represents a reference to a capture group inside some text.
-/// The reference is either a capture group name or a number.
-///
-/// It is also tagged with the position in the text following the
-/// capture reference.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-struct CaptureRef<'a> {
-    cap: Ref<'a>,
-    end: usize,
-}
-
-/// A reference to a capture group in some text.
-///
-/// e.g., `$2`, `$foo`, `${foo}`.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum Ref<'a> {
-    Named(&'a str),
-    Number(usize),
-}
-
-impl<'a> From<&'a str> for Ref<'a> {
-    fn from(x: &'a str) -> Ref<'a> {
-        Ref::Named(x)
-    }
-}
-
-impl From<usize> for Ref<'static> {
-    fn from(x: usize) -> Ref<'static> {
-        Ref::Number(x)
-    }
-}
-
-/// Parses a possible reference to a capture group name in the given text,
-/// starting at the beginning of `replacement`.
-///
-/// If no such valid reference could be found, None is returned.
-fn find_cap_ref(replacement: &[u8]) -> Option<CaptureRef<'_>> {
-    let mut i = 0;
-    let rep: &[u8] = replacement;
-    if rep.len() <= 1 || rep[0] != b'$' {
-        return None;
-    }
-    i += 1;
-    if rep[i] == b'{' {
-        return find_cap_ref_braced(rep, i + 1);
-    }
-    let mut cap_end = i;
-    while rep.get(cap_end).copied().map_or(false, is_valid_cap_letter) {
-        cap_end += 1;
-    }
-    if cap_end == i {
-        return None;
-    }
-    // We just verified that the range 0..cap_end is valid ASCII, so it must
-    // therefore be valid UTF-8. If we really cared, we could avoid this UTF-8
-    // check via an unchecked conversion or by parsing the number straight from
-    // &[u8].
-    let cap =
-        str::from_utf8(&rep[i..cap_end]).expect("valid UTF-8 capture name");
-    Some(CaptureRef {
-        cap: match cap.parse::<u32>() {
-            Ok(i) => Ref::Number(i as usize),
-            Err(_) => Ref::Named(cap),
-        },
-        end: cap_end,
-    })
-}
-
-fn find_cap_ref_braced(rep: &[u8], mut i: usize) -> Option<CaptureRef<'_>> {
-    let start = i;
-    while rep.get(i).map_or(false, |&b| b != b'}') {
-        i += 1;
-    }
-    if !rep.get(i).map_or(false, |&b| b == b'}') {
-        return None;
-    }
-    // When looking at braced names, we don't put any restrictions on the name,
-    // so it's possible it could be invalid UTF-8. But a capture group name
-    // can never be invalid UTF-8, so if we have invalid UTF-8, then we can
-    // safely return None.
-    let cap = match str::from_utf8(&rep[start..i]) {
-        Err(_) => return None,
-        Ok(cap) => cap,
-    };
-    Some(CaptureRef {
-        cap: match cap.parse::<u32>() {
-            Ok(i) => Ref::Number(i as usize),
-            Err(_) => Ref::Named(cap),
-        },
-        end: i + 1,
-    })
-}
-
-/// Returns true if and only if the given byte is allowed in a capture name
-/// written in non-brace form.
-fn is_valid_cap_letter(b: u8) -> bool {
-    match b {
-        b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_' => true,
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{find_cap_ref, CaptureRef};
-
-    macro_rules! find {
-        ($name:ident, $text:expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!(None, find_cap_ref($text.as_bytes()));
-            }
-        };
-        ($name:ident, $text:expr, $capref:expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!(Some($capref), find_cap_ref($text.as_bytes()));
-            }
-        };
-    }
-
-    macro_rules! c {
-        ($name_or_number:expr, $pos:expr) => {
-            CaptureRef { cap: $name_or_number.into(), end: $pos }
-        };
-    }
-
-    find!(find_cap_ref1, "$foo", c!("foo", 4));
-    find!(find_cap_ref2, "${foo}", c!("foo", 6));
-    find!(find_cap_ref3, "$0", c!(0, 2));
-    find!(find_cap_ref4, "$5", c!(5, 2));
-    find!(find_cap_ref5, "$10", c!(10, 3));
-    // See https://github.com/rust-lang/regex/pull/585
-    // for more on characters following numbers
-    find!(find_cap_ref6, "$42a", c!("42a", 4));
-    find!(find_cap_ref7, "${42}a", c!(42, 5));
-    find!(find_cap_ref8, "${42");
-    find!(find_cap_ref9, "${42 ");
-    find!(find_cap_ref10, " $0 ");
-    find!(find_cap_ref11, "$");
-    find!(find_cap_ref12, " ");
-    find!(find_cap_ref13, "");
-    find!(find_cap_ref14, "$1-$2", c!(1, 2));
-    find!(find_cap_ref15, "$1_$2", c!("1_", 3));
-    find!(find_cap_ref16, "$x-$y", c!("x", 2));
-    find!(find_cap_ref17, "$x_$y", c!("x_", 3));
-    find!(find_cap_ref18, "${#}", c!("#", 4));
-    find!(find_cap_ref19, "${Z[}", c!("Z[", 5));
-    find!(find_cap_ref20, "${¾}", c!("¾", 5));
-    find!(find_cap_ref21, "${¾a}", c!("¾a", 6));
-    find!(find_cap_ref22, "${a¾}", c!("a¾", 6));
-    find!(find_cap_ref23, "${☃}", c!("☃", 6));
-    find!(find_cap_ref24, "${a☃}", c!("a☃", 7));
-    find!(find_cap_ref25, "${☃a}", c!("☃a", 7));
-    find!(find_cap_ref26, "${名字}", c!("名字", 9));
-}
diff --git a/src/find_byte.rs b/src/find_byte.rs
index e95f72afb9..9c6915db40 100644
--- a/src/find_byte.rs
+++ b/src/find_byte.rs
@@ -2,7 +2,7 @@
 ///
 /// If the perf-literal feature is enabled, then this uses the super optimized
 /// memchr crate. Otherwise, it uses the naive byte-at-a-time implementation.
-pub fn find_byte(needle: u8, haystack: &[u8]) -> Option<usize> {
+pub(crate) fn find_byte(needle: u8, haystack: &[u8]) -> Option<usize> {
     #[cfg(not(feature = "perf-literal"))]
     fn imp(needle: u8, haystack: &[u8]) -> Option<usize> {
         haystack.iter().position(|&b| b == needle)
@@ -10,8 +10,7 @@ pub fn find_byte(needle: u8, haystack: &[u8]) -> Option<usize> {
 
     #[cfg(feature = "perf-literal")]
     fn imp(needle: u8, haystack: &[u8]) -> Option<usize> {
-        use memchr::memchr;
-        memchr(needle, haystack)
+        memchr::memchr(needle, haystack)
     }
 
     imp(needle, haystack)
diff --git a/src/freqs.rs b/src/freqs.rs
deleted file mode 100644
index fcffa95fb5..0000000000
--- a/src/freqs.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-// NOTE: The following code was generated by "scripts/frequencies.py", do not
-// edit directly
-
-pub const BYTE_FREQUENCIES: [u8; 256] = [
-    55,  // '\x00'
-    52,  // '\x01'
-    51,  // '\x02'
-    50,  // '\x03'
-    49,  // '\x04'
-    48,  // '\x05'
-    47,  // '\x06'
-    46,  // '\x07'
-    45,  // '\x08'
-    103, // '\t'
-    242, // '\n'
-    66,  // '\x0b'
-    67,  // '\x0c'
-    229, // '\r'
-    44,  // '\x0e'
-    43,  // '\x0f'
-    42,  // '\x10'
-    41,  // '\x11'
-    40,  // '\x12'
-    39,  // '\x13'
-    38,  // '\x14'
-    37,  // '\x15'
-    36,  // '\x16'
-    35,  // '\x17'
-    34,  // '\x18'
-    33,  // '\x19'
-    56,  // '\x1a'
-    32,  // '\x1b'
-    31,  // '\x1c'
-    30,  // '\x1d'
-    29,  // '\x1e'
-    28,  // '\x1f'
-    255, // ' '
-    148, // '!'
-    164, // '"'
-    149, // '#'
-    136, // '$'
-    160, // '%'
-    155, // '&'
-    173, // "'"
-    221, // '('
-    222, // ')'
-    134, // '*'
-    122, // '+'
-    232, // ','
-    202, // '-'
-    215, // '.'
-    224, // '/'
-    208, // '0'
-    220, // '1'
-    204, // '2'
-    187, // '3'
-    183, // '4'
-    179, // '5'
-    177, // '6'
-    168, // '7'
-    178, // '8'
-    200, // '9'
-    226, // ':'
-    195, // ';'
-    154, // '<'
-    184, // '='
-    174, // '>'
-    126, // '?'
-    120, // '@'
-    191, // 'A'
-    157, // 'B'
-    194, // 'C'
-    170, // 'D'
-    189, // 'E'
-    162, // 'F'
-    161, // 'G'
-    150, // 'H'
-    193, // 'I'
-    142, // 'J'
-    137, // 'K'
-    171, // 'L'
-    176, // 'M'
-    185, // 'N'
-    167, // 'O'
-    186, // 'P'
-    112, // 'Q'
-    175, // 'R'
-    192, // 'S'
-    188, // 'T'
-    156, // 'U'
-    140, // 'V'
-    143, // 'W'
-    123, // 'X'
-    133, // 'Y'
-    128, // 'Z'
-    147, // '['
-    138, // '\\'
-    146, // ']'
-    114, // '^'
-    223, // '_'
-    151, // '`'
-    249, // 'a'
-    216, // 'b'
-    238, // 'c'
-    236, // 'd'
-    253, // 'e'
-    227, // 'f'
-    218, // 'g'
-    230, // 'h'
-    247, // 'i'
-    135, // 'j'
-    180, // 'k'
-    241, // 'l'
-    233, // 'm'
-    246, // 'n'
-    244, // 'o'
-    231, // 'p'
-    139, // 'q'
-    245, // 'r'
-    243, // 's'
-    251, // 't'
-    235, // 'u'
-    201, // 'v'
-    196, // 'w'
-    240, // 'x'
-    214, // 'y'
-    152, // 'z'
-    182, // '{'
-    205, // '|'
-    181, // '}'
-    127, // '~'
-    27,  // '\x7f'
-    212, // '\x80'
-    211, // '\x81'
-    210, // '\x82'
-    213, // '\x83'
-    228, // '\x84'
-    197, // '\x85'
-    169, // '\x86'
-    159, // '\x87'
-    131, // '\x88'
-    172, // '\x89'
-    105, // '\x8a'
-    80,  // '\x8b'
-    98,  // '\x8c'
-    96,  // '\x8d'
-    97,  // '\x8e'
-    81,  // '\x8f'
-    207, // '\x90'
-    145, // '\x91'
-    116, // '\x92'
-    115, // '\x93'
-    144, // '\x94'
-    130, // '\x95'
-    153, // '\x96'
-    121, // '\x97'
-    107, // '\x98'
-    132, // '\x99'
-    109, // '\x9a'
-    110, // '\x9b'
-    124, // '\x9c'
-    111, // '\x9d'
-    82,  // '\x9e'
-    108, // '\x9f'
-    118, // '\xa0'
-    141, // '¡'
-    113, // '¢'
-    129, // '£'
-    119, // '¤'
-    125, // '¥'
-    165, // '¦'
-    117, // '§'
-    92,  // '¨'
-    106, // '©'
-    83,  // 'ª'
-    72,  // '«'
-    99,  // '¬'
-    93,  // '\xad'
-    65,  // '®'
-    79,  // '¯'
-    166, // '°'
-    237, // '±'
-    163, // '²'
-    199, // '³'
-    190, // '´'
-    225, // 'µ'
-    209, // '¶'
-    203, // '·'
-    198, // '¸'
-    217, // '¹'
-    219, // 'º'
-    206, // '»'
-    234, // '¼'
-    248, // '½'
-    158, // '¾'
-    239, // '¿'
-    255, // 'À'
-    255, // 'Á'
-    255, // 'Â'
-    255, // 'Ã'
-    255, // 'Ä'
-    255, // 'Å'
-    255, // 'Æ'
-    255, // 'Ç'
-    255, // 'È'
-    255, // 'É'
-    255, // 'Ê'
-    255, // 'Ë'
-    255, // 'Ì'
-    255, // 'Í'
-    255, // 'Î'
-    255, // 'Ï'
-    255, // 'Ð'
-    255, // 'Ñ'
-    255, // 'Ò'
-    255, // 'Ó'
-    255, // 'Ô'
-    255, // 'Õ'
-    255, // 'Ö'
-    255, // '×'
-    255, // 'Ø'
-    255, // 'Ù'
-    255, // 'Ú'
-    255, // 'Û'
-    255, // 'Ü'
-    255, // 'Ý'
-    255, // 'Þ'
-    255, // 'ß'
-    255, // 'à'
-    255, // 'á'
-    255, // 'â'
-    255, // 'ã'
-    255, // 'ä'
-    255, // 'å'
-    255, // 'æ'
-    255, // 'ç'
-    255, // 'è'
-    255, // 'é'
-    255, // 'ê'
-    255, // 'ë'
-    255, // 'ì'
-    255, // 'í'
-    255, // 'î'
-    255, // 'ï'
-    255, // 'ð'
-    255, // 'ñ'
-    255, // 'ò'
-    255, // 'ó'
-    255, // 'ô'
-    255, // 'õ'
-    255, // 'ö'
-    255, // '÷'
-    255, // 'ø'
-    255, // 'ù'
-    255, // 'ú'
-    255, // 'û'
-    255, // 'ü'
-    255, // 'ý'
-    255, // 'þ'
-    255, // 'ÿ'
-];
diff --git a/src/input.rs b/src/input.rs
deleted file mode 100644
index df6c3e0c91..0000000000
--- a/src/input.rs
+++ /dev/null
@@ -1,432 +0,0 @@
-use std::char;
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops;
-use std::u32;
-
-use crate::literal::LiteralSearcher;
-use crate::prog::InstEmptyLook;
-use crate::utf8::{decode_last_utf8, decode_utf8};
-
-/// Represents a location in the input.
-#[derive(Clone, Copy, Debug)]
-pub struct InputAt {
-    pos: usize,
-    c: Char,
-    byte: Option<u8>,
-    len: usize,
-}
-
-impl InputAt {
-    /// Returns true iff this position is at the beginning of the input.
-    pub fn is_start(&self) -> bool {
-        self.pos == 0
-    }
-
-    /// Returns true iff this position is past the end of the input.
-    pub fn is_end(&self) -> bool {
-        self.c.is_none() && self.byte.is_none()
-    }
-
-    /// Returns the character at this position.
-    ///
-    /// If this position is just before or after the input, then an absent
-    /// character is returned.
-    pub fn char(&self) -> Char {
-        self.c
-    }
-
-    /// Returns the byte at this position.
-    pub fn byte(&self) -> Option<u8> {
-        self.byte
-    }
-
-    /// Returns the UTF-8 width of the character at this position.
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Returns whether the UTF-8 width of the character at this position
-    /// is zero.
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Returns the byte offset of this position.
-    pub fn pos(&self) -> usize {
-        self.pos
-    }
-
-    /// Returns the byte offset of the next position in the input.
-    pub fn next_pos(&self) -> usize {
-        self.pos + self.len
-    }
-}
-
-/// An abstraction over input used in the matching engines.
-pub trait Input: fmt::Debug {
-    /// Return an encoding of the position at byte offset `i`.
-    fn at(&self, i: usize) -> InputAt;
-
-    /// Return the Unicode character occurring next to `at`.
-    ///
-    /// If no such character could be decoded, then `Char` is absent.
-    fn next_char(&self, at: InputAt) -> Char;
-
-    /// Return the Unicode character occurring previous to `at`.
-    ///
-    /// If no such character could be decoded, then `Char` is absent.
-    fn previous_char(&self, at: InputAt) -> Char;
-
-    /// Return true if the given empty width instruction matches at the
-    /// input position given.
-    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool;
-
-    /// Scan the input for a matching prefix.
-    fn prefix_at(
-        &self,
-        prefixes: &LiteralSearcher,
-        at: InputAt,
-    ) -> Option<InputAt>;
-
-    /// The number of bytes in the input.
-    fn len(&self) -> usize;
-
-    /// Whether the input is empty.
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Return the given input as a sequence of bytes.
-    fn as_bytes(&self) -> &[u8];
-}
-
-impl<'a, T: Input> Input for &'a T {
-    fn at(&self, i: usize) -> InputAt {
-        (**self).at(i)
-    }
-
-    fn next_char(&self, at: InputAt) -> Char {
-        (**self).next_char(at)
-    }
-
-    fn previous_char(&self, at: InputAt) -> Char {
-        (**self).previous_char(at)
-    }
-
-    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
-        (**self).is_empty_match(at, empty)
-    }
-
-    fn prefix_at(
-        &self,
-        prefixes: &LiteralSearcher,
-        at: InputAt,
-    ) -> Option<InputAt> {
-        (**self).prefix_at(prefixes, at)
-    }
-
-    fn len(&self) -> usize {
-        (**self).len()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        (**self).as_bytes()
-    }
-}
-
-/// An input reader over characters.
-#[derive(Clone, Copy, Debug)]
-pub struct CharInput<'t>(&'t [u8]);
-
-impl<'t> CharInput<'t> {
-    /// Return a new character input reader for the given string.
-    pub fn new(s: &'t [u8]) -> CharInput<'t> {
-        CharInput(s)
-    }
-}
-
-impl<'t> ops::Deref for CharInput<'t> {
-    type Target = [u8];
-
-    fn deref(&self) -> &[u8] {
-        self.0
-    }
-}
-
-impl<'t> Input for CharInput<'t> {
-    fn at(&self, i: usize) -> InputAt {
-        if i >= self.len() {
-            InputAt { pos: self.len(), c: None.into(), byte: None, len: 0 }
-        } else {
-            let c = decode_utf8(&self[i..]).map(|(c, _)| c).into();
-            InputAt { pos: i, c, byte: None, len: c.len_utf8() }
-        }
-    }
-
-    fn next_char(&self, at: InputAt) -> Char {
-        at.char()
-    }
-
-    fn previous_char(&self, at: InputAt) -> Char {
-        decode_last_utf8(&self[..at.pos()]).map(|(c, _)| c).into()
-    }
-
-    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
-        use crate::prog::EmptyLook::*;
-        match empty.look {
-            StartLine => {
-                let c = self.previous_char(at);
-                at.pos() == 0 || c == '\n'
-            }
-            EndLine => {
-                let c = self.next_char(at);
-                at.pos() == self.len() || c == '\n'
-            }
-            StartText => at.pos() == 0,
-            EndText => at.pos() == self.len(),
-            WordBoundary => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_char() != c2.is_word_char()
-            }
-            NotWordBoundary => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_char() == c2.is_word_char()
-            }
-            WordBoundaryAscii => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_byte() != c2.is_word_byte()
-            }
-            NotWordBoundaryAscii => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_byte() == c2.is_word_byte()
-            }
-        }
-    }
-
-    fn prefix_at(
-        &self,
-        prefixes: &LiteralSearcher,
-        at: InputAt,
-    ) -> Option<InputAt> {
-        prefixes.find(&self[at.pos()..]).map(|(s, _)| self.at(at.pos() + s))
-    }
-
-    fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        self.0
-    }
-}
-
-/// An input reader over bytes.
-#[derive(Clone, Copy, Debug)]
-pub struct ByteInput<'t> {
-    text: &'t [u8],
-    only_utf8: bool,
-}
-
-impl<'t> ByteInput<'t> {
-    /// Return a new byte-based input reader for the given string.
-    pub fn new(text: &'t [u8], only_utf8: bool) -> ByteInput<'t> {
-        ByteInput { text, only_utf8 }
-    }
-}
-
-impl<'t> ops::Deref for ByteInput<'t> {
-    type Target = [u8];
-
-    fn deref(&self) -> &[u8] {
-        self.text
-    }
-}
-
-impl<'t> Input for ByteInput<'t> {
-    fn at(&self, i: usize) -> InputAt {
-        if i >= self.len() {
-            InputAt { pos: self.len(), c: None.into(), byte: None, len: 0 }
-        } else {
-            InputAt {
-                pos: i,
-                c: None.into(),
-                byte: self.get(i).cloned(),
-                len: 1,
-            }
-        }
-    }
-
-    fn next_char(&self, at: InputAt) -> Char {
-        decode_utf8(&self[at.pos()..]).map(|(c, _)| c).into()
-    }
-
-    fn previous_char(&self, at: InputAt) -> Char {
-        decode_last_utf8(&self[..at.pos()]).map(|(c, _)| c).into()
-    }
-
-    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
-        use crate::prog::EmptyLook::*;
-        match empty.look {
-            StartLine => {
-                let c = self.previous_char(at);
-                at.pos() == 0 || c == '\n'
-            }
-            EndLine => {
-                let c = self.next_char(at);
-                at.pos() == self.len() || c == '\n'
-            }
-            StartText => at.pos() == 0,
-            EndText => at.pos() == self.len(),
-            WordBoundary => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_char() != c2.is_word_char()
-            }
-            NotWordBoundary => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                c1.is_word_char() == c2.is_word_char()
-            }
-            WordBoundaryAscii => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                if self.only_utf8 {
-                    // If we must match UTF-8, then we can't match word
-                    // boundaries at invalid UTF-8.
-                    if c1.is_none() && !at.is_start() {
-                        return false;
-                    }
-                    if c2.is_none() && !at.is_end() {
-                        return false;
-                    }
-                }
-                c1.is_word_byte() != c2.is_word_byte()
-            }
-            NotWordBoundaryAscii => {
-                let (c1, c2) = (self.previous_char(at), self.next_char(at));
-                if self.only_utf8 {
-                    // If we must match UTF-8, then we can't match word
-                    // boundaries at invalid UTF-8.
-                    if c1.is_none() && !at.is_start() {
-                        return false;
-                    }
-                    if c2.is_none() && !at.is_end() {
-                        return false;
-                    }
-                }
-                c1.is_word_byte() == c2.is_word_byte()
-            }
-        }
-    }
-
-    fn prefix_at(
-        &self,
-        prefixes: &LiteralSearcher,
-        at: InputAt,
-    ) -> Option<InputAt> {
-        prefixes.find(&self[at.pos()..]).map(|(s, _)| self.at(at.pos() + s))
-    }
-
-    fn len(&self) -> usize {
-        self.text.len()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        self.text
-    }
-}
-
-/// An inline representation of `Option<char>`.
-///
-/// This eliminates the need to do case analysis on `Option<char>` to determine
-/// ordinality with other characters.
-///
-/// (The `Option<char>` is not related to encoding. Instead, it is used in the
-/// matching engines to represent the beginning and ending boundaries of the
-/// search text.)
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Char(u32);
-
-impl fmt::Debug for Char {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match char::from_u32(self.0) {
-            None => write!(f, "Empty"),
-            Some(c) => write!(f, "{:?}", c),
-        }
-    }
-}
-
-impl Char {
-    /// Returns true iff the character is absent.
-    #[inline]
-    pub fn is_none(self) -> bool {
-        self.0 == u32::MAX
-    }
-
-    /// Returns the length of the character's UTF-8 encoding.
-    ///
-    /// If the character is absent, then `1` is returned.
-    #[inline]
-    pub fn len_utf8(self) -> usize {
-        char::from_u32(self.0).map_or(1, |c| c.len_utf8())
-    }
-
-    /// Returns true iff the character is a word character.
-    ///
-    /// If the character is absent, then false is returned.
-    pub fn is_word_char(self) -> bool {
-        // is_word_character can panic if the Unicode data for \w isn't
-        // available. However, our compiler ensures that if a Unicode word
-        // boundary is used, then the data must also be available. If it isn't,
-        // then the compiler returns an error.
-        char::from_u32(self.0).map_or(false, regex_syntax::is_word_character)
-    }
-
-    /// Returns true iff the byte is a word byte.
-    ///
-    /// If the byte is absent, then false is returned.
-    pub fn is_word_byte(self) -> bool {
-        match char::from_u32(self.0) {
-            Some(c) if c <= '\u{7F}' => regex_syntax::is_word_byte(c as u8),
-            None | Some(_) => false,
-        }
-    }
-}
-
-impl From<char> for Char {
-    fn from(c: char) -> Char {
-        Char(c as u32)
-    }
-}
-
-impl From<Option<char>> for Char {
-    fn from(c: Option<char>) -> Char {
-        c.map_or(Char(u32::MAX), |c| c.into())
-    }
-}
-
-impl PartialEq<char> for Char {
-    #[inline]
-    fn eq(&self, other: &char) -> bool {
-        self.0 == *other as u32
-    }
-}
-
-impl PartialEq<Char> for char {
-    #[inline]
-    fn eq(&self, other: &Char) -> bool {
-        *self as u32 == other.0
-    }
-}
-
-impl PartialOrd<char> for Char {
-    #[inline]
-    fn partial_cmp(&self, other: &char) -> Option<Ordering> {
-        self.0.partial_cmp(&(*other as u32))
-    }
-}
-
-impl PartialOrd<Char> for char {
-    #[inline]
-    fn partial_cmp(&self, other: &Char) -> Option<Ordering> {
-        (*self as u32).partial_cmp(&other.0)
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index 82c1b77ad8..191aa2e1a2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,146 +1,371 @@
 /*!
-This crate provides a library for parsing, compiling, and executing regular
-expressions. Its syntax is similar to Perl-style regular expressions, but lacks
-a few features like look around and backreferences. In exchange, all searches
-execute in linear time with respect to the size of the regular expression and
-search text.
+This crate provides routines for searching strings for matches of a [regular
+expression] (aka "regex"). The regex syntax supported by this crate is similar
+to other regex engines, but it lacks several features that are not known how to
+implement efficiently. This includes, but is not limited to, look-around and
+backreferences. In exchange, all regex searches in this crate have worst case
+`O(m * n)` time complexity, where `m` is proportional to the size of the regex
+and `n` is proportional to the size of the string being searched.
 
-This crate's documentation provides some simple examples, describes
-[Unicode support](#unicode) and exhaustively lists the
-[supported syntax](#syntax).
+[regular expression]: https://en.wikipedia.org/wiki/Regular_expression
 
-For more specific details on the API for regular expressions, please see the
-documentation for the [`Regex`](struct.Regex.html) type.
+If you just want API documentation, then skip to the [`Regex`] type. Otherwise,
+here's a quick example showing one way of parsing the output of a grep-like
+program:
+
+```rust
+use regex::Regex;
+
+let re = Regex::new(r"(?m)^([^:]+):([0-9]+):(.+)$").unwrap();
+let hay = "\
+path/to/foo:54:Blue Harvest
+path/to/bar:90:Something, Something, Something, Dark Side
+path/to/baz:3:It's a Trap!
+";
+
+let mut results = vec![];
+for (_, [path, lineno, line]) in re.captures_iter(hay).map(|c| c.extract()) {
+    results.push((path, lineno.parse::<u64>()?, line));
+}
+assert_eq!(results, vec![
+    ("path/to/foo", 54, "Blue Harvest"),
+    ("path/to/bar", 90, "Something, Something, Something, Dark Side"),
+    ("path/to/baz", 3, "It's a Trap!"),
+]);
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# Overview
+
+The primary type in this crate is a [`Regex`]. Its most important methods are
+as follows:
+
+* [`Regex::new`] compiles a regex using the default configuration. A
+[`RegexBuilder`] permits setting a non-default configuration. (For example,
+case insensitive matching, verbose mode and others.)
+* [`Regex::is_match`] reports whether a match exists in a particular haystack.
+* [`Regex::find`] reports the byte offsets of a match in a haystack, if one
+exists. [`Regex::find_iter`] returns an iterator over all such matches.
+* [`Regex::captures`] returns a [`Captures`], which reports both the byte
+offsets of a match in a haystack and the byte offsets of each matching capture
+group from the regex in the haystack.
+[`Regex::captures_iter`] returns an iterator over all such matches.
+
+There is also a [`RegexSet`], which permits searching for multiple regex
+patterns simultaneously in a single search. However, it currently only reports
+which patterns match and *not* the byte offsets of a match.
+
+Otherwise, this top-level crate documentation is organized as follows:
+
+* [Usage](#usage) shows how to add the `regex` crate to your Rust project.
+* [Examples](#examples) provides a limited selection of regex search examples.
+* [Performance](#performance) provides a brief summary of how to optimize regex
+searching speed.
+* [Unicode](#unicode) discusses support for non-ASCII patterns.
+* [Syntax](#syntax) enumerates the specific regex syntax supported by this
+crate.
+* [Untrusted input](#untrusted-input) discusses how this crate deals with regex
+patterns or haystacks that are untrusted.
+* [Crate features](#crate-features) documents the Cargo features that can be
+enabled or disabled for this crate.
+* [Other crates](#other-crates) links to other crates in the `regex` family.
 
 # Usage
 
-This crate is [on crates.io](https://crates.io/crates/regex) and can be
+The `regex` crate is [on crates.io](https://crates.io/crates/regex) and can be
 used by adding `regex` to your dependencies in your project's `Cargo.toml`.
+Or more simply, just run `cargo add regex`.
+
+Here is a complete example that creates a new Rust project, adds a dependency
+on `regex`, creates the source code for a regex search and then runs the
+program.
+
+First, create the project in a new directory:
 
-```toml
-[dependencies]
-regex = "1"
+```text
+$ mkdir regex-example
+$ cd regex-example
+$ cargo init
 ```
 
-# Example: find a date
+Second, add a dependency on `regex`:
 
-General use of regular expressions in this package involves compiling an
-expression and then using it to search, split or replace text. For example,
-to confirm that some text resembles a date:
+```text
+$ cargo add regex
+```
+
+Third, edit `src/main.rs`. Delete what's there and replace it with this:
+
+```
+use regex::Regex;
+
+fn main() {
+    let re = Regex::new(r"Hello (?<name>\w+)!").unwrap();
+    let Some(caps) = re.captures("Hello Murphy!") else {
+        println!("no match!");
+        return;
+    };
+    println!("The name is: {}", &caps["name"]);
+}
+```
+
+Foruth, run it with `cargo run`:
+
+```text
+$ cargo run
+   Compiling memchr v2.5.0
+   Compiling regex-syntax v0.7.1
+   Compiling aho-corasick v1.0.1
+   Compiling regex v1.8.1
+   Compiling regex-example v0.1.0 (/tmp/regex-example)
+    Finished dev [unoptimized + debuginfo] target(s) in 4.22s
+     Running `target/debug/regex-example`
+The name is: Murphy
+```
+
+The first time you run the program will show more output like above. But
+subsequent runs shouldn't have to re-compile the dependencies.
+
+# Examples
+
+This section provides a few examples, in tutorial style, showing how to
+search a haystack with a regex. There are more examples throughout the API
+documentation.
+
+Before starting though, it's worth defining a few terms:
+
+* A **regex** is a Rust value whose type is `Regex`. We use `re` as a
+variable name for a regex.
+* A **pattern** is the string that is used to build a regex. We use `pat` as
+a variable name for a pattern.
+* A **haystack** is the string that is searched by a regex. We use `hay` as a
+variable name for a haystack.
+
+Sometimes the words "regex" and "pattern" are used interchangeably.
+
+General use of regular expressions in this crate proceeds by compiling a
+**pattern** into a **regex**, and then using that regex to search, split or
+replace parts of a **haystack**.
+
+### Example: find a middle initial
+
+We'll start off with a very simple example: a regex that looks for a specific
+name but uses a wildcard to match a middle initial. Our pattern serves as
+something like a template that will match a particular name with *any* middle
+initial.
 
 ```rust
 use regex::Regex;
-let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
-assert!(re.is_match("2014-01-01"));
+
+// We use 'unwrap()' here because it would be a bug in our program if the
+// pattern failed to compile to a regex. Panicking in the presence of a bug
+// is okay.
+let re = Regex::new(r"Homer (.)\. Simpson").unwrap();
+let hay = "Homer J. Simpson";
+let Some(caps) = re.captures(hay) else { return };
+assert_eq!("J", &caps[1]);
 ```
 
-Notice the use of the `^` and `$` anchors. In this crate, every expression
-is executed with an implicit `.*?` at the beginning and end, which allows
-it to match anywhere in the text. Anchors can be used to ensure that the
-full text matches an expression.
+There are a few things worth noticing here in our first example:
 
-This example also demonstrates the utility of
-[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)
-in Rust, which
-are just like regular strings except they are prefixed with an `r` and do
-not process any escape sequences. For example, `"\\d"` is the same
-expression as `r"\d"`.
+* The `.` is a special pattern meta character that means "match any single
+character except for new lines." (More precisely, in this crate, it means
+"match any UTF-8 encoding of any Unicode scalar value other than `\n`.")
+* We can match an actual `.` literally by escaping it, i.e., `\.`.
+* We use Rust's [raw strings] to avoid needing to deal with escape sequences in
+both the regex pattern syntax and in Rust's string literal syntax. If we didn't
+use raw strings here, we would have had to use `\\.` to match a literal `.`
+character. That is, `r"\."` and `"\\."` are equivalent patterns.
+* We put our wildcard `.` instruction in parentheses. These parentheses have a
+special meaning that says, "make whatever part of the haystack matches within
+these parentheses available as a capturing group." After finding a match, we
+access this capture group with `&caps[1]`.
 
-# Example: Avoid compiling the same regex in a loop
+[raw strings]: https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals
 
-It is an anti-pattern to compile the same regular expression in a loop
-since compilation is typically expensive. (It takes anywhere from a few
-microseconds to a few **milliseconds** depending on the size of the
-regex.) Not only is compilation itself expensive, but this also prevents
-optimizations that reuse allocations internally to the matching engines.
+Otherwise, we execute a search using `re.captures(hay)` and return from our
+function if no match occurred. We then reference the middle initial by asking
+for the part of the haystack that matched the capture group indexed at `1`.
+(The capture group at index 0 is implicit and always corresponds to the entire
+match. In this case, that's `Homer J. Simpson`.)
 
-In Rust, it can sometimes be a pain to pass regular expressions around if
-they're used from inside a helper function. Instead, we recommend using the
-[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that
-regular expressions are compiled exactly once.
+### Example: named capture groups
 
-For example:
+Continuing from our middle initial example above, we can tweak the pattern
+slightly to give a name to the group that matches the middle initial:
 
 ```rust
-use lazy_static::lazy_static;
 use regex::Regex;
 
-fn some_helper_function(text: &str) -> bool {
-    lazy_static! {
-        static ref RE: Regex = Regex::new("...").unwrap();
-    }
-    RE.is_match(text)
-}
+// Note that (?P<middle>.) is a different way to spell the same thing.
+let re = Regex::new(r"Homer (?<middle>.)\. Simpson").unwrap();
+let hay = "Homer J. Simpson";
+let Some(caps) = re.captures(hay) else { return };
+assert_eq!("J", &caps["middle"]);
+```
+
+Giving a name to a group can be useful when there are multiple groups in
+a pattern. It makes the code referring to those groups a bit easier to
+understand.
+
+### Example: validating a particular date format
+
+This examples shows how to confirm whether a haystack, in its entirety, matches
+a particular date format:
+
+```rust
+use regex::Regex;
 
-fn main() {}
+let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
+assert!(re.is_match("2010-03-14"));
 ```
 
-Specifically, in this example, the regex will be compiled when it is used for
-the first time. On subsequent uses, it will reuse the previous compilation.
+Notice the use of the `^` and `$` anchors. In this crate, every regex search is
+run with an implicit `(?s:.)*?` at the beginning of its pattern, which allows
+the regex to match anywhere in a haystack. Anchors, as above, can be used to
+ensure that the full haystack matches a pattern.
+
+This crate is also Unicode aware by default, which means that `\d` might match
+more than you might expect it to. For example:
+
+```rust
+use regex::Regex;
+
+let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
+assert!(re.is_match("𝟚𝟘𝟙𝟘-𝟘𝟛-𝟙𝟜"));
+```
+
+To only match an ASCII decimal digit, all of the following are equivalent:
 
-# Example: iterating over capture groups
+* `[0-9]`
+* `(?-u:\d)`
+* `[[:digit:]]`
+* `[\d&&\p{ascii}]`
 
-This crate provides convenient iterators for matching an expression
-repeatedly against a search string to find successive non-overlapping
-matches. For example, to find all dates in a string and be able to access
-them by their component pieces:
+### Example: finding dates in a haystack
+
+In the previous example, we showed how one might validate that a haystack,
+in its entirety, corresponded to a particular date format. But what if we wanted
+to extract all things that look like dates in a specific format from a haystack?
+To do this, we can use an iterator API to find all matches (notice that we've
+removed the anchors and switched to looking for ASCII-only digits):
 
 ```rust
-# use regex::Regex;
-# fn main() {
-let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
-let text = "2012-03-14, 2013-01-01 and 2014-07-05";
-for cap in re.captures_iter(text) {
-    println!("Month: {} Day: {} Year: {}", &cap[2], &cap[3], &cap[1]);
-}
-// Output:
-// Month: 03 Day: 14 Year: 2012
-// Month: 01 Day: 01 Year: 2013
-// Month: 07 Day: 05 Year: 2014
-# }
+use regex::Regex;
+
+let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
+let dates: Vec<&str> = re.find_iter(hay).map(|m| m.as_str()).collect();
+assert_eq!(dates, vec![
+    "1865-04-14",
+    "1881-07-02",
+    "1901-09-06",
+    "1963-11-22",
+]);
+```
+
+We can also iterate over [`Captures`] values instead of [`Match`] values, and
+that in turn permits accessing each component of the date via capturing groups:
+
+```rust
+use regex::Regex;
+
+let re = Regex::new(r"(?<y>[0-9]{4})-(?<m>[0-9]{2})-(?<d>[0-9]{2})").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+// 'm' is a 'Match', and 'as_str()' returns the matching part of the haystack.
+let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
+    // The unwraps are okay because every capture group must match if the whole
+    // regex matches, and in this context, we know we have a match.
+    //
+    // Note that we use `caps.name("y").unwrap().as_str()` instead of
+    // `&caps["y"]` because the lifetime of the former is the same as the
+    // lifetime of `hay` above, but the lifetime of the latter is tied to the
+    // lifetime of `caps` due to how the `Index` trait is defined.
+    let year = caps.name("y").unwrap().as_str();
+    let month = caps.name("m").unwrap().as_str();
+    let day = caps.name("d").unwrap().as_str();
+    (year, month, day)
+}).collect();
+assert_eq!(dates, vec![
+    ("1865", "04", "14"),
+    ("1881", "07", "02"),
+    ("1901", "09", "06"),
+    ("1963", "11", "22"),
+]);
 ```
 
-Notice that the year is in the capture group indexed at `1`. This is
-because the *entire match* is stored in the capture group at index `0`.
+### Example: simpler capture group extraction
 
-# Example: replacement with named capture groups
+One can use [`Captures::extract`] to make the code from the previous example a
+bit simpler in this case:
+
+```rust
+use regex::Regex;
+
+let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+let hay = "What do 1865-04-14, 1881-07-02, 1901-09-06 and 1963-11-22 have in common?";
+let dates: Vec<(&str, &str, &str)> = re.captures_iter(hay).map(|caps| {
+    let (_, [year, month, day]) = caps.extract();
+    (year, month, day)
+}).collect();
+assert_eq!(dates, vec![
+    ("1865", "04", "14"),
+    ("1881", "07", "02"),
+    ("1901", "09", "06"),
+    ("1963", "11", "22"),
+]);
+```
+
+`Captures::extract` works by ensuring that the number of matching groups match
+the number of groups requested via the `[year, month, day]` syntax. If they do,
+then the substrings for each corresponding capture group are automatically
+returned in an appropriately sized array. Rust's syntax for pattern matching
+arrays does the rest.
+
+### Example: replacement with named capture groups
 
 Building on the previous example, perhaps we'd like to rearrange the date
-formats. This can be done with text replacement. But to make the code
-clearer, we can *name*  our capture groups and use those names as variables
-in our replacement text:
+formats. This can be done by finding each match and replacing it with
+something different. The [`Regex::replace_all`] routine provides a convenient
+way to do this, including by supporting references to named groups in the
+replacement string:
 
 ```rust
-# use regex::Regex;
-# fn main() {
-let re = Regex::new(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})").unwrap();
-let before = "2012-03-14, 2013-01-01 and 2014-07-05";
+use regex::Regex;
+
+let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
+let before = "1973-01-05, 1975-08-25 and 1980-10-18";
 let after = re.replace_all(before, "$m/$d/$y");
-assert_eq!(after, "03/14/2012, 01/01/2013 and 07/05/2014");
-# }
+assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
 ```
 
-The `replace` methods are actually polymorphic in the replacement, which
+The replace methods are actually polymorphic in the replacement, which
 provides more flexibility than is seen here. (See the documentation for
-`Regex::replace` for more details.)
+[`Regex::replace`] for more details.)
+
+### Example: verbose mode
 
-Note that if your regex gets complicated, you can use the `x` flag to
-enable insignificant whitespace mode, which also lets you write comments:
+When your regex gets complicated, you might consider using something other
+than regex. But if you stick with regex, you can use the `x` flag to enable
+insignificant whitespace mode or "verbose mode." In this mode, whitespace
+is treated as insignificant and one may write comments. This may make your
+patterns easier to comprehend.
 
 ```rust
-# use regex::Regex;
-# fn main() {
+use regex::Regex;
+
 let re = Regex::new(r"(?x)
-  (?P<y>\d{4}) # the year
+  (?P<y>\d{4}) # the year, including all Unicode digits
   -
-  (?P<m>\d{2}) # the month
+  (?P<m>\d{2}) # the month, including all Unicode digits
   -
-  (?P<d>\d{2}) # the day
+  (?P<d>\d{2}) # the day, including all Unicode digits
 ").unwrap();
-let before = "2012-03-14, 2013-01-01 and 2014-07-05";
+
+let before = "1973-01-05, 1975-08-25 and 1980-10-18";
 let after = re.replace_all(before, "$m/$d/$y");
-assert_eq!(after, "03/14/2012, 01/01/2013 and 07/05/2014");
-# }
+assert_eq!(after, "01/05/1973, 08/25/1975 and 10/18/1980");
 ```
 
 If you wish to match against whitespace in this mode, you can still use `\s`,
@@ -148,10 +373,10 @@ If you wish to match against whitespace in this mode, you can still use `\s`,
 directly with `\ `, use its hex character code `\x20` or temporarily disable
 the `x` flag, e.g., `(?-x: )`.
 
-# Example: match multiple regular expressions simultaneously
+### Example: match multiple regular expressions simultaneously
 
-This demonstrates how to use a `RegexSet` to match multiple (possibly
-overlapping) regular expressions in a single scan of the search text:
+This demonstrates how to use a [`RegexSet`] to match multiple (possibly
+overlapping) regexes in a single scan of a haystack:
 
 ```rust
 use regex::RegexSet;
@@ -166,7 +391,8 @@ let set = RegexSet::new(&[
     r"foobar",
 ]).unwrap();
 
-// Iterate over and collect all of the matches.
+// Iterate over and collect all of the matches. Each match corresponds to the
+// ID of the matching pattern.
 let matches: Vec<_> = set.matches("foobar").into_iter().collect();
 assert_eq!(matches, vec![0, 2, 3, 4, 6]);
 
@@ -176,96 +402,223 @@ assert!(!matches.matched(5));
 assert!(matches.matched(6));
 ```
 
-# Pay for what you use
+# Performance
+
+This section briefly discusses a few concerns regarding the speed and resource
+usage of regexes.
 
-With respect to searching text with a regular expression, there are three
-questions that can be asked:
+### Only ask for what you need
 
-1. Does the text match this expression?
-2. If so, where does it match?
-3. Where did the capturing groups match?
+When running a search with a regex, there are generally three different types
+of information one can ask for:
+
+1. Does a regex match in a haystack?
+2. Where does a regex match in a haystack?
+3. Where do each of the capturing groups match in a haystack?
 
 Generally speaking, this crate could provide a function to answer only #3,
 which would subsume #1 and #2 automatically. However, it can be significantly
 more expensive to compute the location of capturing group matches, so it's best
 not to do it if you don't need to.
 
-Therefore, only use what you need. For example, don't use `find` if you
-only need to test if an expression matches a string. (Use `is_match`
-instead.)
+Therefore, only ask for what you need. For example, don't use [`Regex::find`]
+if you only need to test if a regex matches a haystack. Use [`Regex::is_match`]
+instead.
+
+### Unicode can impact memory usage and search speed
+
+This crate has first class support for Unicode and it is **enabled by default**.
+In many cases, the extra memory required to support it will be negligible and
+it typically won't impact search speed. But it can in some cases.
+
+With respect to memory usage, the impact of Unicode principally manifests
+through the use of Unicode character classes. Unicode character classes
+tend to be quite large. For example, `\w` by default matches around 140,000
+distinct codepoints. This requires additional memory, and tends to slow down
+regex compilation. While a `\w` here and there is unlikely to be noticed,
+writing `\w{100}` will for example result in quite a large regex by default.
+Indeed, `\w` is considerably larger than its ASCII-only version, so if your
+requirements are satisfied by ASCII, it's probably a good idea to stick to
+ASCII classes. The ASCII-only version of `\w` can be spelled in a number of
+ways. All of the following are equivalent:
+
+* `[0-9A-Za-z_]`
+* `(?-u:\w)`
+* `[[:word:]]`
+* `[\w&&\p{ascii}]`
+
+With respect to search speed, Unicode tends to be handled pretty well, even when
+using large Unicode character classes. However, some of the faster internal
+regex engines cannot handle a Unicode aware word boundary assertion. So if you
+don't need Unicode-aware word boundary assertions, you might consider using
+`(?-u:\b)` instead of `\b`, where the former uses an ASCII-only definition of
+a word character.
+
+### Literals might accelerate searches
+
+This crate tends to be quite good at recognizing literals in a regex pattern
+and using them to accelerate a search. If it is at all possible to include
+some kind of literal in your pattern, then it might make search substantially
+faster. For example, in the regex `\w+@\w+`, the engine will look for
+occurrences of `@` and then try a reverse match for `\w+` to find the start
+position.
+
+### Avoid re-compiling regexes, especially in a loop
+
+It is an anti-pattern to compile the same pattern in a loop since regex
+compilation is typically expensive. (It takes anywhere from a few microseconds
+to a few **milliseconds** depending on the size of the pattern.) Not only is
+compilation itself expensive, but this also prevents optimizations that reuse
+allocations internally to the regex engine.
+
+In Rust, it can sometimes be a pain to pass regexes around if they're used from
+inside a helper function. Instead, we recommend using crates like [`once_cell`]
+and [`lazy_static`] to ensure that patterns are compiled exactly once.
+
+[`once_cell`]: https://crates.io/crates/once_cell
+[`lazy_static`]: https://crates.io/crates/lazy_static
+
+This example shows how to use `once_cell`:
 
-# Unicode
+```rust
+use {
+    once_cell::sync::Lazy,
+    regex::Regex,
+};
 
-This implementation executes regular expressions **only** on valid UTF-8
-while exposing match locations as byte indices into the search string. (To
-relax this restriction, use the [`bytes`](bytes/index.html) sub-module.)
-Conceptually, the regex engine works by matching a haystack as if it were a
-sequence of Unicode scalar values.
+fn some_helper_function(haystack: &str) -> bool {
+    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"...").unwrap());
+    RE.is_match(haystack)
+}
+
+fn main() {
+    assert!(some_helper_function("abc"));
+    assert!(!some_helper_function("ac"));
+}
+```
+
+Specifically, in this example, the regex will be compiled when it is used for
+the first time. On subsequent uses, it will reuse the previously built `Regex`.
+Notice how one can define the `Regex` locally to a specific function.
+
+### Sharing a regex across threads can result in contention
+
+While a single `Regex` can be freely used from multiple threads simultaneously,
+there is a small synchronization cost that must be paid. Generally speaking,
+one shouldn't expect to observe this unless the principal task in each thread
+is searching with the regex *and* most searches are on short haystacks. In this
+case, internal contention on shared resources can spike and increase latency,
+which in turn may slow down each individual search.
+
+One can work around this by cloning each `Regex` before sending it to another
+thread. The cloned regexes will still share the same internal read-only portion
+of its compiled state (it's reference counted), but each thread will get
+optimized access to the mutable space that is used to run a search. In general,
+there is no additional cost in memory to doing this. The only cost is the added
+code complexity required to explicitly clone the regex. (If you share the same
+`Regex` across multiple threads, each thread still gets its own mutable space,
+but accessing that space is slower.)
 
-Only simple case folding is supported. Namely, when matching
-case-insensitively, the characters are first mapped using the "simple" case
-folding rules defined by Unicode.
+# Unicode
 
-Regular expressions themselves are **only** interpreted as a sequence of
-Unicode scalar values. This means you can use Unicode characters directly
-in your expression:
+This section discusses what kind of Unicode support this regex library has.
+Before showing some examples, we'll summarize the relevant points:
+
+* This crate almost fully implements "Basic Unicode Support" (Level 1) as
+specified by the [Unicode Technical Standard #18][UTS18]. The full details
+of what is supported are documented in [UNICODE.md] in the root of the regex
+crate repository. There is virtually no support for "Extended Unicode Support"
+(Level 2) from UTS#18.
+* The top-level [`Regex`] runs searches *as if* iterating over each of the
+codepoints in the haystack. That is, the fundamental atom of matching is a
+single codepoint.
+* [`bytes::Regex`], in contrast, permits disabling Unicode mode for part of all
+of your pattern in all cases. When Unicode mode is disabled, then a search is
+run *as if* iterating over each byte in the haystack. That is, the fundamental
+atom of matching is a single byte. (A top-level `Regex` also permits disabling
+Unicode and thus matching *as if* it were one byte at a time, but only when
+doing so wouldn't permit matching invalid UTF-8.)
+* When Unicode mode is enabled (the default), `.` will match an entire Unicode
+scalar value, even when it is encoded using multiple bytes. When Unicode mode
+is disabled (e.g., `(?-u:.)`), then `.` will match a single byte in all cases.
+* The character classes `\w`, `\d` and `\s` are all Unicode-aware by default.
+Use `(?-u:\w)`, `(?-u:\d)` and `(?-u:\s)` to get their ASCII-only definitions.
+* Similarly, `\b` and `\B` use a Unicode definition of a "word" character. To
+get ASCII-only word boundaries, use `(?-u:\b)` and `(?-u:\B)`.
+* `^` and `$` are **not** Unicode-aware in multi-line mode. Namely, they only
+recognize `\n` (assuming CRLF mode is not enabled) and not any of the other
+forms of line terminators defined by Unicode.
+* Case insensitive searching is Unicode-aware and uses simple case folding.
+* Unicode general categories, scripts and many boolean properties are available
+by default via the `\p{property name}` syntax.
+* In all cases, matches are reported using byte offsets. Or more precisely,
+UTF-8 code unit offsets. This permits constant time indexing and slicing of the
+haystack.
+
+[UTS18]: https://unicode.org/reports/tr18/
+[UNICODE.md]: https://github.com/rust-lang/regex/blob/master/UNICODE.md
+
+Patterns themselves are **only** interpreted as a sequence of Unicode scalar
+values. This means you can use Unicode characters directly in your pattern:
 
 ```rust
-# use regex::Regex;
-# fn main() {
+use regex::Regex;
+
 let re = Regex::new(r"(?i)Δ+").unwrap();
-let mat = re.find("ΔδΔ").unwrap();
-assert_eq!((mat.start(), mat.end()), (0, 6));
-# }
+let m = re.find("ΔδΔ").unwrap();
+assert_eq!((0, 6), (m.start(), m.end()));
+// alternatively:
+assert_eq!(0..6, m.range());
 ```
 
-Most features of the regular expressions in this crate are Unicode aware. Here
-are some examples:
-
-* `.` will match any valid UTF-8 encoded Unicode scalar value except for `\n`.
-  (To also match `\n`, enable the `s` flag, e.g., `(?s:.)`.)
-* `\w`, `\d` and `\s` are Unicode aware. For example, `\s` will match all forms
-  of whitespace categorized by Unicode.
-* `\b` matches a Unicode word boundary.
-* Negated character classes like `[^a]` match all Unicode scalar values except
-  for `a`.
-* `^` and `$` are **not** Unicode aware in multi-line mode. Namely, they only
-  recognize `\n` and not any of the other forms of line terminators defined
-  by Unicode.
-
-Unicode general categories, scripts, script extensions, ages and a smattering
-of boolean properties are available as character classes. For example, you can
-match a sequence of numerals, Greek or Cherokee letters:
+As noted above, Unicode general categories, scripts, script extensions, ages
+and a smattering of boolean properties are available as character classes. For
+example, you can match a sequence of numerals, Greek or Cherokee letters:
 
 ```rust
-# use regex::Regex;
-# fn main() {
+use regex::Regex;
+
 let re = Regex::new(r"[\pN\p{Greek}\p{Cherokee}]+").unwrap();
-let mat = re.find("abcΔᎠβⅠᏴγδⅡxyz").unwrap();
-assert_eq!((mat.start(), mat.end()), (3, 23));
-# }
+let m = re.find("abcΔᎠβⅠᏴγδⅡxyz").unwrap();
+assert_eq!(3..23, m.range());
 ```
 
-For a more detailed breakdown of Unicode support with respect to
-[UTS#18](https://unicode.org/reports/tr18/),
-please see the
-[UNICODE](https://github.com/rust-lang/regex/blob/master/UNICODE.md)
-document in the root of the regex repository.
+While not specific to Unicode, this library also supports character class set
+operations. Namely, one can nest character classes arbitrarily and perform set
+operations on them. Those set operations are union (the default), intersection,
+difference and symmetric difference. These set operations tend to be most
+useful with Unicode character classes. For example, to match any codepoint
+that is both in the `Greek` script and in the `Letter` general category:
+
+```rust
+use regex::Regex;
+
+let re = Regex::new(r"[\p{Greek}&&\pL]+").unwrap();
+let subs: Vec<&str> = re.find_iter("ΔδΔ𐅌ΔδΔ").map(|m| m.as_str()).collect();
+assert_eq!(subs, vec!["ΔδΔ", "ΔδΔ"]);
 
-# Opt out of Unicode support
+// If we just matches on Greek, then all codepoints would match!
+let re = Regex::new(r"\p{Greek}+").unwrap();
+let subs: Vec<&str> = re.find_iter("ΔδΔ𐅌ΔδΔ").map(|m| m.as_str()).collect();
+assert_eq!(subs, vec!["ΔδΔ𐅌ΔδΔ"]);
+```
 
-The `bytes` sub-module provides a `Regex` type that can be used to match
-on `&[u8]`. By default, text is interpreted as UTF-8 just like it is with
-the main `Regex` type. However, this behavior can be disabled by turning
-off the `u` flag, even if doing so could result in matching invalid UTF-8.
-For example, when the `u` flag is disabled, `.` will match any byte instead
-of any Unicode scalar value.
+### Opt out of Unicode support
+
+The [`bytes::Regex`] type that can be used to search `&[u8]` haystacks. By
+default, haystacks are conventionally treated as UTF-8 just like it is with the
+main `Regex` type. However, this behavior can be disabled by turning off the
+`u` flag, even if doing so could result in matching invalid UTF-8. For example,
+when the `u` flag is disabled, `.` will match any byte instead of any Unicode
+scalar value.
 
 Disabling the `u` flag is also possible with the standard `&str`-based `Regex`
 type, but it is only allowed where the UTF-8 invariant is maintained. For
 example, `(?-u:\w)` is an ASCII-only `\w` character class and is legal in an
-`&str`-based `Regex`, but `(?-u:\xFF)` will attempt to match the raw byte
-`\xFF`, which is invalid UTF-8 and therefore is illegal in `&str`-based
+`&str`-based `Regex`, but `(?-u:\W)` will attempt to match *any byte* that
+isn't in `(?-u:\w)`, which in turn includes bytes that are invalid UTF-8.
+Similarly, `(?-u:\xFF)` will attempt to match the raw byte `\xFF` (instead of
+`U+00FF`), which is invalid UTF-8 and therefore is illegal in `&str`-based
 regexes.
 
 Finally, since Unicode support requires bundling large Unicode data
@@ -281,10 +634,11 @@ The syntax supported in this crate is documented below.
 Note that the regular expression parser and abstract syntax are exposed in
 a separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).
 
-## Matching one character
+### Matching one character
 
 <pre class="rust">
 .             any character except new line (includes new line with s flag)
+[0-9]         any ASCII digit
 \d            digit (\p{Nd})
 \D            not digit
 \pX           Unicode character class identified by a one-letter name
@@ -307,6 +661,7 @@ a separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).
 [0-9--4]      Direct subtraction (matching 0-9 except 4)
 [a-g~~b-h]    Symmetric difference (matching `a` and `h` only)
 [\[\]]        Escaping in character classes (matching [ or ])
+[a&&b]        An empty character class matching nothing
 </pre>
 
 Any named character class may appear inside a bracketed `[...]` character
@@ -315,12 +670,14 @@ digit. `[\p{Greek}&&\pL]` matches Greek letters.
 
 Precedence in character classes, from most binding to least:
 
-1. Ranges: `a-cd` == `[a-c]d`
-2. Union: `ab&&bc` == `[ab]&&[bc]`
-3. Intersection: `^a-z&&b` == `^[a-z&&b]`
-4. Negation
+1. Ranges: `[a-cd]` == `[[a-c]d]`
+2. Union: `[ab&&bc]` == `[[ab]&&[bc]]`
+3. Intersection, difference, symmetric difference. All three have equivalent
+precedence, and are evaluated in left-to-right order. For example,
+`[\pL--\p{Greek}&&\p{Uppercase}]` == `[[\pL--\p{Greek}]&&\p{Uppercase}]`.
+4. Negation: `[^a-z&&b]` == `[^[a-z&&b]]`.
 
-## Composites
+### Composites
 
 <pre class="rust">
 xy    concatenation (x followed by y)
@@ -346,7 +703,7 @@ let re = Regex::new(r"sam|samwise").unwrap();
 assert_eq!("sam", re.find(haystack).unwrap().as_str());
 ```
 
-## Repetitions
+### Repetitions
 
 <pre class="rust">
 x*        zero or more of x (greedy)
@@ -363,21 +720,40 @@ x{n,}?    at least n x (ungreedy/lazy)
 x{n}?     exactly n x
 </pre>
 
-## Empty matches
+### Empty matches
 
 <pre class="rust">
-^     the beginning of text (or start-of-line with multi-line mode)
-$     the end of text (or end-of-line with multi-line mode)
-\A    only the beginning of text (even with multi-line mode enabled)
-\z    only the end of text (even with multi-line mode enabled)
+^     the beginning of a haystack (or start-of-line with multi-line mode)
+$     the end of a haystack (or end-of-line with multi-line mode)
+\A    only the beginning of a haystack (even with multi-line mode enabled)
+\z    only the end of a haystack (even with multi-line mode enabled)
 \b    a Unicode word boundary (\w on one side and \W, \A, or \z on other)
 \B    not a Unicode word boundary
 </pre>
 
-The empty regex is valid and matches the empty string. For example, the empty
-regex matches `abc` at positions `0`, `1`, `2` and `3`.
+The empty regex is valid and matches the empty string. For example, the
+empty regex matches `abc` at positions `0`, `1`, `2` and `3`. When using the
+top-level [`Regex`] on `&str` haystacks, an empty match that splits a codepoint
+is guaranteed to never be returned. However, such matches are permitted when
+using a [`bytes::Regex`]. For example:
 
-## Grouping and flags
+```rust
+let re = regex::Regex::new(r"").unwrap();
+let ranges: Vec<_> = re.find_iter("💩").map(|m| m.range()).collect();
+assert_eq!(ranges, vec![0..0, 4..4]);
+
+let re = regex::bytes::Regex::new(r"").unwrap();
+let ranges: Vec<_> = re.find_iter("💩".as_bytes()).map(|m| m.range()).collect();
+assert_eq!(ranges, vec![0..0, 1..1, 2..2, 3..3, 4..4]);
+```
+
+Note that an empty regex is distinct from a regex that can never match.
+For example, the regex `[a&&b]` is a character class that represents the
+intersection of `a` and `b`. That intersection is empty, which means the
+character class is empty. Since nothing is in the empty set, `[a&&b]` matches
+nothing, not even the empty string.
+
+### Grouping and flags
 
 <pre class="rust">
 (exp)          numbered capture group (indexed by opening parenthesis)
@@ -405,6 +781,7 @@ All flags are by default disabled unless stated otherwise. They are:
 i     case-insensitive: letters match both upper and lower case
 m     multi-line mode: ^ and $ match begin/end of line
 s     allow . to match \n
+R     enables CRLF mode: when multi-line mode is enabled, \r\n is used
 U     swap the meaning of x* and x*?
 u     Unicode support (enabled by default)
 x     verbose mode, ignores whitespace and allow line comments (starting with `#`)
@@ -418,22 +795,22 @@ Flags can be toggled within a pattern. Here's an example that matches
 case-insensitively for the first part but case-sensitively for the second part:
 
 ```rust
-# use regex::Regex;
-# fn main() {
+use regex::Regex;
+
 let re = Regex::new(r"(?i)a+(?-i)b+").unwrap();
-let cap = re.captures("AaAaAbbBBBb").unwrap();
-assert_eq!(&cap[0], "AaAaAbb");
-# }
+let m = re.find("AaAaAbbBBBb").unwrap();
+assert_eq!(m.as_str(), "AaAaAbb");
 ```
 
 Notice that the `a+` matches either `a` or `A`, but the `b+` only matches
 `b`.
 
 Multi-line mode means `^` and `$` no longer match just at the beginning/end of
-the input, but at the beginning/end of lines:
+the input, but also at the beginning/end of lines:
 
 ```
-# use regex::Regex;
+use regex::Regex;
+
 let re = Regex::new(r"(?m)^line \d+").unwrap();
 let m = re.find("line one\nline 2\n").unwrap();
 assert_eq!(m.as_str(), "line 2");
@@ -442,44 +819,68 @@ assert_eq!(m.as_str(), "line 2");
 Note that `^` matches after new lines, even at the end of input:
 
 ```
-# use regex::Regex;
+use regex::Regex;
+
 let re = Regex::new(r"(?m)^").unwrap();
 let m = re.find_iter("test\n").last().unwrap();
 assert_eq!((m.start(), m.end()), (5, 5));
 ```
 
-Here is an example that uses an ASCII word boundary instead of a Unicode
-word boundary:
+When both CRLF mode and multi-line mode are enabled, then `^` and `$` will
+match either `\r` and `\n`, but never in the middle of a `\r\n`:
+
+```
+use regex::Regex;
+
+let re = Regex::new(r"(?mR)^foo$").unwrap();
+let m = re.find("\r\nfoo\r\n").unwrap();
+assert_eq!(m.as_str(), "foo");
+```
+
+Unicode mode can also be selectively disabled, although only when the result
+*would not* match invalid UTF-8. One good example of this is using an ASCII
+word boundary instead of a Unicode word boundary, which might make some regex
+searches run faster:
 
 ```rust
-# use regex::Regex;
-# fn main() {
+use regex::Regex;
+
 let re = Regex::new(r"(?-u:\b).+(?-u:\b)").unwrap();
-let cap = re.captures("$$abc$$").unwrap();
-assert_eq!(&cap[0], "abc");
-# }
+let m = re.find("$$abc$$").unwrap();
+assert_eq!(m.as_str(), "abc");
 ```
 
-## Escape sequences
+### Escape sequences
+
+Note that this includes all possible escape sequences, even ones that are
+documented elsewhere.
 
 <pre class="rust">
-\*          literal *, works for any punctuation character: \.+*?()|[]{}^$
+\*          literal *, applies to all ASCII except [0-9A-Za-z<>]
 \a          bell (\x07)
 \f          form feed (\x0C)
 \t          horizontal tab
 \n          new line
 \r          carriage return
 \v          vertical tab (\x0B)
-\123        octal character code (up to three digits) (when enabled)
+\A          matches at the beginning of a haystack
+\z          matches at the end of a haystack
+\b          word boundary assertion
+\B          negated word boundary assertion
+\123        octal character code, up to three digits (when enabled)
 \x7F        hex character code (exactly two digits)
 \x{10FFFF}  any hex character code corresponding to a Unicode code point
 \u007F      hex character code (exactly four digits)
 \u{7F}      any hex character code corresponding to a Unicode code point
 \U0000007F  hex character code (exactly eight digits)
 \U{7F}      any hex character code corresponding to a Unicode code point
+\p{Letter}  Unicode character class
+\P{Letter}  negated Unicode character class
+\d, \s, \w  Perl character class
+\D, \S, \W  negated Perl character class
 </pre>
 
-## Perl character classes (Unicode friendly)
+### Perl character classes (Unicode friendly)
 
 These classes are based on the definitions provided in
 [UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):
@@ -493,7 +894,10 @@ These classes are based on the definitions provided in
 \W     not word character
 </pre>
 
-## ASCII character classes
+### ASCII character classes
+
+These classes are based on the definitions provided in
+[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):
 
 <pre class="rust">
 [[:alnum:]]    alphanumeric ([0-9A-Za-z])
@@ -512,16 +916,228 @@ These classes are based on the definitions provided in
 [[:xdigit:]]   hex digit ([0-9A-Fa-f])
 </pre>
 
+# Untrusted input
+
+This crate is meant to be able to run regex searches on untrusted haystacks
+without fear of [ReDoS]. This crate also, to a certain extent, supports
+untrusted patterns.
+
+[ReDoS]: https://en.wikipedia.org/wiki/ReDoS
+
+This crate differs from most (but not all) other regex engines in that it
+doesn't use unbounded backtracking to run a regex search. In those cases,
+one generally cannot use untrusted patterns *or* untrusted haystacks because
+it can be very difficult to know whether a particular pattern will result in
+catastrophic backtracking or not.
+
+We'll first discuss how this crate deals with untrusted inputs and then wrap
+it up with a realistic discussion about what practice really looks like.
+
+### Panics
+
+Outside of clearly documented cases, most APIs in this crate are intended to
+never panic regardless of the inputs given to them. For example, `Regex::new`,
+`Regex::is_match`, `Regex::find` and `Regex::captures` should never panic. That
+is, it is an API promise that those APIs will never panic no matter what inputs
+are given to them. With that said, regex engines are complicated beasts, and
+providing a rock solid guarantee that these APIs literally never panic is
+essentially equivalent to saying, "there are no bugs in this library." That is
+a bold claim, and not really one that can be feasibly made with a straight
+face.
+
+Don't get the wrong impression here. This crate is extensively tested, not just
+with unit and integration tests, but also via fuzz testing. For example, this
+crate is part of the [OSS-fuzz project]. Panics should be incredibly rare, but
+it is possible for bugs to exist, and thus possible for a panic to occur. If
+you need a rock solid guarantee against panics, then you should wrap calls into
+this library with [`std::panic::catch_unwind`].
+
+It's also worth pointing out that this library will *generally* panic when
+other regex engines would commit undefined behavior. When undefined behavior
+occurs, your program might continue as if nothing bad has happened, but it also
+might mean your program is open to the worst kinds of exploits. In contrast,
+the worst thing a panic can do is a denial of service.
+
+[OSS-fuzz project]: https://android.googlesource.com/platform/external/oss-fuzz/+/refs/tags/android-t-preview-1/projects/rust-regex/
+[`std::panic::catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html
+
+### Untrusted patterns
+
+The principal way this crate deals with them is by limiting their size by
+default. The size limit can be configured via [`RegexBuilder::size_limit`]. The
+idea of a size limit is that compiling a pattern into a `Regex` will fail if it
+becomes "too big." Namely, while *most* resources consumed by compiling a regex
+are approximately proportional (albeit with some high constant factors in some
+cases, such as with Unicode character classes) to the length of the pattern
+itself, there is one particular exception to this: counted repetitions. Namely,
+this pattern:
+
+```text
+a{5}{5}{5}{5}{5}{5}
+```
+
+Is equivalent to this pattern:
+
+```text
+a{15625}
+```
+
+In both of these cases, the actual pattern string is quite small, but the
+resulting `Regex` value is quite large. Indeed, as the first pattern shows,
+it isn't enough to locally limit the size of each repetition because they can
+be stacked in a way that results in exponential growth.
+
+To provide a bit more context, a simplified view of regex compilation looks
+like this:
+
+* The pattern string is parsed into a structured representation called an AST.
+Counted repetitions are not expanded and Unicode character classes are not
+looked up in this stage. That is, the size of the AST is proportional to the
+size of the pattern with "reasonable" constant factors. In other words, one
+can reasonably limit the memory used by an AST by limiting the length of the
+pattern string.
+* The AST is translated into an HIR. Counted repetitions are still *not*
+expanded at this stage, but Unicode character classes are embedded into the
+HIR. The memory usage of a HIR is still proportional to the length of the
+original pattern string, but the constant factors---mostly as a result of
+Unicode character classes---can be quite high. Still though, the memory used by
+an HIR can be reasonably limited by limiting the length of the pattern string.
+* The HIR is compiled into a [Thompson NFA]. This is the stage at which
+something like `\w{5}` is rewritten to `\w\w\w\w\w`. Thus, this is the stage
+at which [`RegexBuilder::size_limit`] is enforced. If the NFA exceeds the
+configured size, then this stage will fail.
+
+[Thompson NFA]: https://en.wikipedia.org/wiki/Thompson%27s_construction
+
+The size limit helps avoid two different kinds of exorbitant resource usage:
+
+* It avoids permitting exponential memory usage based on the size of the
+pattern string.
+* It avoids long search times. This will be discussed in more detail in the
+next section, but worst case search time *is* dependent on the size of the
+regex. So keeping regexes limited to a reasonable size is also a way of keeping
+search times reasonable.
+
+Finally, it's worth pointing out that regex compilation is guaranteed to take
+worst case `O(m)` time, where `m` is proportional to the size of regex. The
+size of the regex here is *after* the counted repetitions have been expanded.
+
+**Advice for those using untrusted regexes**: limit the pattern length to
+something small and expand it as needed. Configure [`RegexBuilder::size_limit`]
+to something small and then expand it as needed.
+
+### Untrusted haystacks
+
+The main way this crate guards against searches from taking a long time is by
+using algorithms that guarantee a `O(m * n)` worst case time and space bound.
+Namely:
+
+* `m` is proportional to the size of the regex, where the size of the regex
+includes the expansion of all counted repetitions. (See the previous section on
+untrusted patterns.)
+* `n` is proportional to the length, in bytes, of the haystack.
+
+In other words, if you consider `m` to be a constant (for example, the regex
+pattern is a literal in the source code), then the search can be said to run
+in "linear time." Or equivalently, "linear time with respect to the size of the
+haystack."
+
+But the `m` factor here is important not to ignore. If a regex is
+particularly big, the search times can get quite slow. This is why, in part,
+[`RegexBuilder::size_limit`] exists.
+
+**Advice for those searching untrusted haystacks**: As long as your regexes
+are not enormous, you should expect to be able to search untrusted haystacks
+without fear. If you aren't sure, you should benchmark it. Unlike backtracking
+engines, if your regex is so big that it's likely to result in slow searches,
+this is probably something you'll be able to observe regardless of what the
+haystack is made up of.
+
+### Iterating over matches
+
+One thing that is perhaps easy to miss is that the worst case time
+complexity bound of `O(m * n)` applies to methods like [`Regex::is_match`],
+[`Regex::find`] and [`Regex::captures`]. It does **not** apply to
+[`Regex::find_iter`] or [`Regex::captures_iter`]. Namely, since iterating over
+all matches can execute many searches, and each search can scan the entire
+haystack, the worst case time complexity for iterators is `O(m * n^2)`.
+
+One example of where this occurs is when a pattern consists of an alternation,
+where an earlier branch of the alternation requires scanning the entire
+haystack only to discover that there is no match. It also requires a later
+branch of the alternation to have matched at the beginning of the search. For
+example, consider the pattern `.*[^A-Z]|[A-Z]` and the haystack `AAAAA`. The
+first search will scan to the end looking for matches of `.*[^A-Z]` even though
+a finite automata engine (as in this crate) knows that `[A-Z]` has already
+matched the first character of the haystack. This is due to the greedy nature
+of regex searching. That first search will report a match at the first `A` only
+after scanning to the end to discover that no other match exists. The next
+search then begins at the second `A` and the behavior repeats.
+
+There is no way to avoid this. This means that if both patterns and haystacks
+are untrusted and you're iterating over all matches, you're susceptible to
+worst case quadratic time complexity. One possible way to mitigate this
+is to drop down to the lower level `regex-automata` crate and use its
+`meta::Regex` iterator APIs. There, you can configure the search to operate
+in "earliest" mode by passing a `Input::new(haystack).earliest(true)` to
+`meta::Regex::find_iter` (for example). By enabling this mode, you give up
+the normal greedy match semantics of regex searches and instead ask the regex
+engine to immediately stop as soon as a match has been found. Enabling this
+mode will thus restore the worst case `O(m * n)` time complexity bound, but at
+the cost of different semantics.
+
+### Untrusted inputs in practice
+
+While providing a `O(m * n)` worst case time bound on all searches goes a long
+way toward preventing [ReDoS], that doesn't mean every search you can possibly
+run will complete without burning CPU time. In general, there are a few ways
+for the `m * n` time bound to still bite you:
+
+* You are searching an exceptionally long haystack. No matter how you slice
+it, a longer haystack will take more time to search. This crate may often make
+very quick work of even long haystacks because of its literal optimizations,
+but those aren't available for all regexes.
+* Unicode character classes can cause searches to be quite slow in some cases.
+This is especially true when they are combined with counted repetitions. While
+the regex size limit above will protect you from the most egregious cases,
+the default size limit still permits pretty big regexes that can execute more
+slowly than one might expect.
+* While routines like [`Regex::find`] and [`Regex::captures`] guarantee
+worst case `O(m * n)` search time, routines like [`Regex::find_iter`] and
+[`Regex::captures_iter`] actually have worst case `O(m * n^2)` search time.
+This is because `find_iter` runs many searches, and each search takes worst
+case `O(m * n)` time. Thus, iteration of all matches in a haystack has
+worst case `O(m * n^2)`. A good example of a pattern that exhibits this is
+`(?:A+){1000}|` or even `.*[^A-Z]|[A-Z]`.
+
+In general, unstrusted haystacks are easier to stomach than untrusted patterns.
+Untrusted patterns give a lot more control to the caller to impact the
+performance of a search. In many cases, a regex search will actually execute in
+average case `O(n)` time (i.e., not dependent on the size of the regex), but
+this can't be guaranteed in general. Therefore, permitting untrusted patterns
+means that your only line of defense is to put a limit on how big `m` (and
+perhaps also `n`) can be in `O(m * n)`. `n` is limited by simply inspecting
+the length of the haystack while `m` is limited by *both* applying a limit to
+the length of the pattern *and* a limit on the compiled size of the regex via
+[`RegexBuilder::size_limit`].
+
+It bears repeating: if you're accepting untrusted patterns, it would be a good
+idea to start with conservative limits on `m` and `n`, and then carefully
+increase them as needed.
+
 # Crate features
 
 By default, this crate tries pretty hard to make regex matching both as fast
-as possible and as correct as it can be, within reason. This means that there
-is a lot of code dedicated to performance, the handling of Unicode data and the
-Unicode data itself. Overall, this leads to more dependencies, larger binaries
-and longer compile times.  This trade off may not be appropriate in all cases,
-and indeed, even when all Unicode and performance features are disabled, one
-is still left with a perfectly serviceable regex engine that will work well
-in many cases.
+as possible and as correct as it can be. This means that there is a lot of
+code dedicated to performance, the handling of Unicode data and the Unicode
+data itself. Overall, this leads to more dependencies, larger binaries and
+longer compile times. This trade off may not be appropriate in all cases, and
+indeed, even when all Unicode and performance features are disabled, one is
+still left with a perfectly serviceable regex engine that will work well in
+many cases. (Note that code is not arbitrarily reducible, and for this reason,
+the [`regex-lite`](https://docs.rs/regex-lite) crate exists to provide an even
+more minimal experience by cutting out Unicode and performance, but still
+maintaining the linear search time bound.)
 
 This crate exposes a number of features for controlling that trade off. Some
 of these features are strictly performance oriented, such that disabling them
@@ -530,32 +1146,61 @@ Other features, such as the ones controlling the presence or absence of Unicode
 data, can result in a loss of functionality. For example, if one disables the
 `unicode-case` feature (described below), then compiling the regex `(?i)a`
 will fail since Unicode case insensitivity is enabled by default. Instead,
-callers must use `(?i-u)a` instead to disable Unicode case folding. Stated
-differently, enabling or disabling any of the features below can only add or
-subtract from the total set of valid regular expressions. Enabling or disabling
-a feature will never modify the match semantics of a regular expression.
+callers must use `(?i-u)a` to disable Unicode case folding. Stated differently,
+enabling or disabling any of the features below can only add or subtract from
+the total set of valid regular expressions. Enabling or disabling a feature
+will never modify the match semantics of a regular expression.
 
-All features below are enabled by default.
+Most features below are enabled by default. Features that aren't enabled by
+default are noted.
 
 ### Ecosystem features
 
 * **std** -
-  When enabled, this will cause `regex` to use the standard library. Currently,
-  disabling this feature will always result in a compilation error. It is
-  intended to add `alloc`-only support to regex in the future.
+  When enabled, this will cause `regex` to use the standard library. In terms
+  of APIs, `std` causes error types to implement the `std::error::Error`
+  trait. Enabling `std` will also result in performance optimizations,
+  including SIMD and faster synchronization primitives. Notably, **disabling
+  the `std` feature will result in the use of spin locks**. To use a regex
+  engine without `std` and without spin locks, you'll need to drop down to
+  the [`regex-automata`](https://docs.rs/regex-automata) crate.
+* **logging** -
+  When enabled, the `log` crate is used to emit messages about regex
+  compilation and search strategies. This is **disabled by default**. This is
+  typically only useful to someone working on this crate's internals, but might
+  be useful if you're doing some rabbit hole performance hacking. Or if you're
+  just interested in the kinds of decisions being made by the regex engine.
 
 ### Performance features
 
 * **perf** -
-  Enables all performance related features. This feature is enabled by default
-  and will always cover all features that improve performance, even if more
-  are added in the future.
+  Enables all performance related features except for `perf-dfa-full`. This
+  feature is enabled by default is intended to cover all reasonable features
+  that improve performance, even if more are added in the future.
 * **perf-dfa** -
   Enables the use of a lazy DFA for matching. The lazy DFA is used to compile
   portions of a regex to a very fast DFA on an as-needed basis. This can
   result in substantial speedups, usually by an order of magnitude on large
   haystacks. The lazy DFA does not bring in any new dependencies, but it can
   make compile times longer.
+* **perf-dfa-full** -
+  Enables the use of a full DFA for matching. Full DFAs are problematic because
+  they have worst case `O(2^n)` construction time. For this reason, when this
+  feature is enabled, full DFAs are only used for very small regexes and a
+  very small space bound is used during determinization to avoid the DFA
+  from blowing up. This feature is not enabled by default, even as part of
+  `perf`, because it results in fairly sizeable increases in binary size and
+  compilation time. It can result in faster search times, but they tend to be
+  more modest and limited to non-Unicode regexes.
+* **perf-onepass** -
+  Enables the use of a one-pass DFA for extracting the positions of capture
+  groups. This optimization applies to a subset of certain types of NFAs and
+  represents the fastest engine in this crate for dealing with capture groups.
+* **perf-backtrack** -
+  Enables the use of a bounded backtracking algorithm for extracting the
+  positions of capture groups. This usually sits between the slowest engine
+  (the PikeVM) and the fastest engine (one-pass DFA) for extracting capture
+  groups. It's used whenever the regex is not one-pass and is small enough.
 * **perf-inline** -
   Enables the use of aggressive inlining inside match routines. This reduces
   the overhead of each match. The aggressive inlining, however, increases
@@ -609,193 +1254,83 @@ All features below are enabled by default.
   This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
   `\p{sb=ATerm}`.
 
-
-# Untrusted input
-
-This crate can handle both untrusted regular expressions and untrusted
-search text.
-
-Untrusted regular expressions are handled by capping the size of a compiled
-regular expression.
-(See [`RegexBuilder::size_limit`](struct.RegexBuilder.html#method.size_limit).)
-Without this, it would be trivial for an attacker to exhaust your system's
-memory with expressions like `a{100}{100}{100}`.
-
-Untrusted search text is allowed because the matching engine(s) in this
-crate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search
-text`), which means there's no way to cause exponential blow-up like with
-some other regular expression engines. (We pay for this by disallowing
-features like arbitrary look-ahead and backreferences.)
-
-When a DFA is used, pathological cases with exponential state blow-up are
-avoided by constructing the DFA lazily or in an "online" manner. Therefore,
-at most one new state can be created for each byte of input. This satisfies
-our time complexity guarantees, but can lead to memory growth
-proportional to the size of the input. As a stopgap, the DFA is only
-allowed to store a fixed number of states. When the limit is reached, its
-states are wiped and continues on, possibly duplicating previous work. If
-the limit is reached too frequently, it gives up and hands control off to
-another matching engine with fixed memory requirements.
-(The DFA size limit can also be tweaked. See
-[`RegexBuilder::dfa_size_limit`](struct.RegexBuilder.html#method.dfa_size_limit).)
+# Other crates
+
+This crate has two required dependencies and several optional dependencies.
+This section briefly describes them with the goal of raising awareness of how
+different components of this crate may be used independently.
+
+It is somewhat unusual for a regex engine to have dependencies, as most regex
+libraries are self contained units with no dependencies other than a particular
+environment's standard library. Indeed, for other similarly optimized regex
+engines, most or all of the code in the dependencies of this crate would
+normally just be unseparable or coupled parts of the crate itself. But since
+Rust and its tooling ecosystem make the use of dependencies so easy, it made
+sense to spend some effort de-coupling parts of this crate and making them
+independently useful.
+
+We only briefly describe each crate here.
+
+* [`regex-lite`](https://docs.rs/regex-lite) is not a dependency of `regex`,
+but rather, a standalone zero-dependency simpler version of `regex` that
+prioritizes compile times and binary size. In exchange, it eschews Unicode
+support and performance. Its match semantics are as identical as possible to
+the `regex` crate, and for the things it supports, its APIs are identical to
+the APIs in this crate. In other words, for a lot of use cases, it is a drop-in
+replacement.
+* [`regex-syntax`](https://docs.rs/regex-syntax) provides a regular expression
+parser via `Ast` and `Hir` types. It also provides routines for extracting
+literals from a pattern. Folks can use this crate to do analysis, or even to
+build their own regex engine without having to worry about writing a parser.
+* [`regex-automata`](https://docs.rs/regex-automata) provides the regex engines
+themselves. One of the downsides of finite automata based regex engines is that
+they often need multiple internal engines in order to have similar or better
+performance than an unbounded backtracking engine in practice. `regex-automata`
+in particular provides public APIs for a PikeVM, a bounded backtracker, a
+one-pass DFA, a lazy DFA, a fully compiled DFA and a meta regex engine that
+combines all them together. It also has native multi-pattern support and
+provides a way to compile and serialize full DFAs such that they can be loaded
+and searched in a no-std no-alloc environment. `regex-automata` itself doesn't
+even have a required dependency on `regex-syntax`!
+* [`memchr`](https://docs.rs/memchr) provides low level SIMD vectorized
+routines for quickly finding the location of single bytes or even substrings
+in a haystack. In other words, it provides fast `memchr` and `memmem` routines.
+These are used by this crate in literal optimizations.
+* [`aho-corasick`](https://docs.rs/aho-corasick) provides multi-substring
+search. It also provides SIMD vectorized routines in the case where the number
+of substrings to search for is relatively small. The `regex` crate also uses
+this for literal optimizations.
 */
 
+#![no_std]
 #![deny(missing_docs)]
 #![cfg_attr(feature = "pattern", feature(pattern))]
 #![warn(missing_debug_implementations)]
 
-#[cfg(not(feature = "std"))]
-compile_error!("`std` feature is currently required to build this crate");
+#[cfg(doctest)]
+doc_comment::doctest!("../README.md");
 
-// To check README's example
-// TODO: Re-enable this once the MSRV is 1.43 or greater.
-// See: https://github.com/rust-lang/regex/issues/684
-// See: https://github.com/rust-lang/regex/issues/685
-// #[cfg(doctest)]
-// doc_comment::doctest!("../README.md");
+extern crate alloc;
+#[cfg(any(test, feature = "std"))]
+extern crate std;
 
-#[cfg(feature = "std")]
 pub use crate::error::Error;
-#[cfg(feature = "std")]
-pub use crate::re_builder::set_unicode::*;
-#[cfg(feature = "std")]
-pub use crate::re_builder::unicode::*;
-#[cfg(feature = "std")]
-pub use crate::re_set::unicode::*;
-#[cfg(feature = "std")]
-pub use crate::re_unicode::{
-    escape, CaptureLocations, CaptureMatches, CaptureNames, Captures,
-    Locations, Match, Matches, NoExpand, Regex, Replacer, ReplacerRef, Split,
-    SplitN, SubCaptureMatches,
-};
-
-/**
-Match regular expressions on arbitrary bytes.
-
-This module provides a nearly identical API to the one found in the
-top-level of this crate. There are two important differences:
-
-1. Matching is done on `&[u8]` instead of `&str`. Additionally, `Vec<u8>`
-is used where `String` would have been used.
-2. Unicode support can be disabled even when disabling it would result in
-matching invalid UTF-8 bytes.
-
-# Example: match null terminated string
-
-This shows how to find all null-terminated strings in a slice of bytes:
 
-```rust
-# use regex::bytes::Regex;
-let re = Regex::new(r"(?-u)(?P<cstr>[^\x00]+)\x00").unwrap();
-let text = b"foo\x00bar\x00baz\x00";
-
-// Extract all of the strings without the null terminator from each match.
-// The unwrap is OK here since a match requires the `cstr` capture to match.
-let cstrs: Vec<&[u8]> =
-    re.captures_iter(text)
-      .map(|c| c.name("cstr").unwrap().as_bytes())
-      .collect();
-assert_eq!(vec![&b"foo"[..], &b"bar"[..], &b"baz"[..]], cstrs);
-```
-
-# Example: selectively enable Unicode support
-
-This shows how to match an arbitrary byte pattern followed by a UTF-8 encoded
-string (e.g., to extract a title from a Matroska file):
-
-```rust
-# use std::str;
-# use regex::bytes::Regex;
-let re = Regex::new(
-    r"(?-u)\x7b\xa9(?:[\x80-\xfe]|[\x40-\xff].)(?u:(.*))"
-).unwrap();
-let text = b"\x12\xd0\x3b\x5f\x7b\xa9\x85\xe2\x98\x83\x80\x98\x54\x76\x68\x65";
-let caps = re.captures(text).unwrap();
-
-// Notice that despite the `.*` at the end, it will only match valid UTF-8
-// because Unicode mode was enabled with the `u` flag. Without the `u` flag,
-// the `.*` would match the rest of the bytes.
-let mat = caps.get(1).unwrap();
-assert_eq!((7, 10), (mat.start(), mat.end()));
-
-// If there was a match, Unicode mode guarantees that `title` is valid UTF-8.
-let title = str::from_utf8(&caps[1]).unwrap();
-assert_eq!("☃", title);
-```
-
-In general, if the Unicode flag is enabled in a capture group and that capture
-is part of the overall match, then the capture is *guaranteed* to be valid
-UTF-8.
-
-# Syntax
-
-The supported syntax is pretty much the same as the syntax for Unicode
-regular expressions with a few changes that make sense for matching arbitrary
-bytes:
-
-1. The `u` flag can be disabled even when disabling it might cause the regex to
-match invalid UTF-8. When the `u` flag is disabled, the regex is said to be in
-"ASCII compatible" mode.
-2. In ASCII compatible mode, neither Unicode scalar values nor Unicode
-character classes are allowed.
-3. In ASCII compatible mode, Perl character classes (`\w`, `\d` and `\s`)
-revert to their typical ASCII definition. `\w` maps to `[[:word:]]`, `\d` maps
-to `[[:digit:]]` and `\s` maps to `[[:space:]]`.
-4. In ASCII compatible mode, word boundaries use the ASCII compatible `\w` to
-determine whether a byte is a word byte or not.
-5. Hexadecimal notation can be used to specify arbitrary bytes instead of
-Unicode codepoints. For example, in ASCII compatible mode, `\xFF` matches the
-literal byte `\xFF`, while in Unicode mode, `\xFF` is a Unicode codepoint that
-matches its UTF-8 encoding of `\xC3\xBF`. Similarly for octal notation when
-enabled.
-6. In ASCII compatible mode, `.` matches any *byte* except for `\n`. When the
-`s` flag is additionally enabled, `.` matches any byte.
-
-# Performance
-
-In general, one should expect performance on `&[u8]` to be roughly similar to
-performance on `&str`.
-*/
-#[cfg(feature = "std")]
-pub mod bytes {
-    pub use crate::re_builder::bytes::*;
-    pub use crate::re_builder::set_bytes::*;
-    pub use crate::re_bytes::*;
-    pub use crate::re_set::bytes::*;
-}
+pub use crate::{builders::string::*, regex::string::*, regexset::string::*};
 
-mod backtrack;
-mod compile;
-#[cfg(feature = "perf-dfa")]
-mod dfa;
+mod builders;
+pub mod bytes;
 mod error;
-mod exec;
-mod expand;
 mod find_byte;
-mod input;
-mod literal;
 #[cfg(feature = "pattern")]
 mod pattern;
-mod pikevm;
-mod pool;
-mod prog;
-mod re_builder;
-mod re_bytes;
-mod re_set;
-mod re_trait;
-mod re_unicode;
-mod sparse;
-mod utf8;
-
-/// The `internal` module exists to support suspicious activity, such as
-/// testing different matching engines and supporting the `regex-debug` CLI
-/// utility.
-#[doc(hidden)]
-#[cfg(feature = "std")]
-pub mod internal {
-    pub use crate::compile::Compiler;
-    pub use crate::exec::{Exec, ExecBuilder};
-    pub use crate::input::{Char, CharInput, Input, InputAt};
-    pub use crate::literal::LiteralSearcher;
-    pub use crate::prog::{EmptyLook, Inst, InstRanges, Program};
+mod regex;
+mod regexset;
+
+/// Escapes all regular expression meta characters in `pattern`.
+///
+/// The string returned may be safely used as a literal in a regular
+/// expression.
+pub fn escape(pattern: &str) -> alloc::string::String {
+    regex_syntax::escape(pattern)
 }
diff --git a/src/literal/imp.rs b/src/literal/imp.rs
deleted file mode 100644
index 75fa6e37b2..0000000000
--- a/src/literal/imp.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-use std::mem;
-
-use aho_corasick::{self, packed, AhoCorasick};
-use memchr::{memchr, memchr2, memchr3, memmem};
-use regex_syntax::hir::literal::{Literal, Seq};
-
-/// A prefix extracted from a compiled regular expression.
-///
-/// A regex prefix is a set of literal strings that *must* be matched at the
-/// beginning of a regex in order for the entire regex to match. Similarly
-/// for a regex suffix.
-#[derive(Clone, Debug)]
-pub struct LiteralSearcher {
-    complete: bool,
-    lcp: Memmem,
-    lcs: Memmem,
-    matcher: Matcher,
-}
-
-#[derive(Clone, Debug)]
-enum Matcher {
-    /// No literals. (Never advances through the input.)
-    Empty,
-    /// A set of four or more single byte literals.
-    Bytes(SingleByteSet),
-    /// A single substring, using vector accelerated routines when available.
-    Memmem(Memmem),
-    /// An Aho-Corasick automaton.
-    AC { ac: AhoCorasick, lits: Vec<Literal> },
-    /// A packed multiple substring searcher, using SIMD.
-    ///
-    /// Note that Aho-Corasick will actually use this packed searcher
-    /// internally automatically, however, there is some overhead associated
-    /// with going through the Aho-Corasick machinery. So using the packed
-    /// searcher directly results in some gains.
-    Packed { s: packed::Searcher, lits: Vec<Literal> },
-}
-
-impl LiteralSearcher {
-    /// Returns a matcher that never matches and never advances the input.
-    pub fn empty() -> Self {
-        Self::new(Seq::infinite(), Matcher::Empty)
-    }
-
-    /// Returns a matcher for literal prefixes from the given set.
-    pub fn prefixes(lits: Seq) -> Self {
-        let matcher = Matcher::prefixes(&lits);
-        Self::new(lits, matcher)
-    }
-
-    /// Returns a matcher for literal suffixes from the given set.
-    pub fn suffixes(lits: Seq) -> Self {
-        let matcher = Matcher::suffixes(&lits);
-        Self::new(lits, matcher)
-    }
-
-    fn new(lits: Seq, matcher: Matcher) -> Self {
-        LiteralSearcher {
-            complete: lits.is_exact(),
-            lcp: Memmem::new(lits.longest_common_prefix().unwrap_or(b"")),
-            lcs: Memmem::new(lits.longest_common_suffix().unwrap_or(b"")),
-            matcher,
-        }
-    }
-
-    /// Returns true if all matches comprise the entire regular expression.
-    ///
-    /// This does not necessarily mean that a literal match implies a match
-    /// of the regular expression. For example, the regular expression `^a`
-    /// is comprised of a single complete literal `a`, but the regular
-    /// expression demands that it only match at the beginning of a string.
-    pub fn complete(&self) -> bool {
-        self.complete && !self.is_empty()
-    }
-
-    /// Find the position of a literal in `haystack` if it exists.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn find(&self, haystack: &[u8]) -> Option<(usize, usize)> {
-        use self::Matcher::*;
-        match self.matcher {
-            Empty => Some((0, 0)),
-            Bytes(ref sset) => sset.find(haystack).map(|i| (i, i + 1)),
-            Memmem(ref s) => s.find(haystack).map(|i| (i, i + s.len())),
-            AC { ref ac, .. } => {
-                ac.find(haystack).map(|m| (m.start(), m.end()))
-            }
-            Packed { ref s, .. } => {
-                s.find(haystack).map(|m| (m.start(), m.end()))
-            }
-        }
-    }
-
-    /// Like find, except matches must start at index `0`.
-    pub fn find_start(&self, haystack: &[u8]) -> Option<(usize, usize)> {
-        for lit in self.iter() {
-            if lit.len() > haystack.len() {
-                continue;
-            }
-            if lit == &haystack[0..lit.len()] {
-                return Some((0, lit.len()));
-            }
-        }
-        None
-    }
-
-    /// Like find, except matches must end at index `haystack.len()`.
-    pub fn find_end(&self, haystack: &[u8]) -> Option<(usize, usize)> {
-        for lit in self.iter() {
-            if lit.len() > haystack.len() {
-                continue;
-            }
-            if lit == &haystack[haystack.len() - lit.len()..] {
-                return Some((haystack.len() - lit.len(), haystack.len()));
-            }
-        }
-        None
-    }
-
-    /// Returns an iterator over all literals to be matched.
-    pub fn iter(&self) -> LiteralIter<'_> {
-        match self.matcher {
-            Matcher::Empty => LiteralIter::Empty,
-            Matcher::Bytes(ref sset) => LiteralIter::Bytes(&sset.dense),
-            Matcher::Memmem(ref s) => LiteralIter::Single(&s.finder.needle()),
-            Matcher::AC { ref lits, .. } => LiteralIter::AC(lits),
-            Matcher::Packed { ref lits, .. } => LiteralIter::Packed(lits),
-        }
-    }
-
-    /// Returns a matcher for the longest common prefix of this matcher.
-    pub fn lcp(&self) -> &Memmem {
-        &self.lcp
-    }
-
-    /// Returns a matcher for the longest common suffix of this matcher.
-    pub fn lcs(&self) -> &Memmem {
-        &self.lcs
-    }
-
-    /// Returns true iff this prefix is empty.
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Returns the number of prefixes in this machine.
-    pub fn len(&self) -> usize {
-        use self::Matcher::*;
-        match self.matcher {
-            Empty => 0,
-            Bytes(ref sset) => sset.dense.len(),
-            Memmem(_) => 1,
-            AC { ref ac, .. } => ac.patterns_len(),
-            Packed { ref lits, .. } => lits.len(),
-        }
-    }
-
-    /// Return the approximate heap usage of literals in bytes.
-    pub fn approximate_size(&self) -> usize {
-        use self::Matcher::*;
-        match self.matcher {
-            Empty => 0,
-            Bytes(ref sset) => sset.approximate_size(),
-            Memmem(ref single) => single.approximate_size(),
-            AC { ref ac, .. } => ac.memory_usage(),
-            Packed { ref s, .. } => s.memory_usage(),
-        }
-    }
-}
-
-impl Matcher {
-    fn prefixes(lits: &Seq) -> Self {
-        let sset = SingleByteSet::prefixes(lits);
-        Matcher::new(lits, sset)
-    }
-
-    fn suffixes(lits: &Seq) -> Self {
-        let sset = SingleByteSet::suffixes(lits);
-        Matcher::new(lits, sset)
-    }
-
-    fn new(lits: &Seq, sset: SingleByteSet) -> Self {
-        if lits.is_empty() || lits.min_literal_len() == Some(0) {
-            return Matcher::Empty;
-        }
-        let lits = match lits.literals() {
-            None => return Matcher::Empty,
-            Some(members) => members,
-        };
-        if sset.dense.len() >= 26 {
-            // Avoid trying to match a large number of single bytes.
-            // This is *very* sensitive to a frequency analysis comparison
-            // between the bytes in sset and the composition of the haystack.
-            // No matter the size of sset, if its members all are rare in the
-            // haystack, then it'd be worth using it. How to tune this... IDK.
-            // ---AG
-            return Matcher::Empty;
-        }
-        if sset.complete {
-            return Matcher::Bytes(sset);
-        }
-        if lits.len() == 1 {
-            return Matcher::Memmem(Memmem::new(lits[0].as_bytes()));
-        }
-
-        let pats: Vec<&[u8]> = lits.iter().map(|lit| lit.as_bytes()).collect();
-        let is_aho_corasick_fast = sset.dense.len() <= 1 && sset.all_ascii;
-        if lits.len() <= 100 && !is_aho_corasick_fast {
-            let mut builder = packed::Config::new()
-                .match_kind(packed::MatchKind::LeftmostFirst)
-                .builder();
-            if let Some(s) = builder.extend(&pats).build() {
-                return Matcher::Packed { s, lits: lits.to_owned() };
-            }
-        }
-        let ac = AhoCorasick::builder()
-            .match_kind(aho_corasick::MatchKind::LeftmostFirst)
-            .kind(Some(aho_corasick::AhoCorasickKind::DFA))
-            .build(&pats)
-            .unwrap();
-        Matcher::AC { ac, lits: lits.to_owned() }
-    }
-}
-
-#[derive(Debug)]
-pub enum LiteralIter<'a> {
-    Empty,
-    Bytes(&'a [u8]),
-    Single(&'a [u8]),
-    AC(&'a [Literal]),
-    Packed(&'a [Literal]),
-}
-
-impl<'a> Iterator for LiteralIter<'a> {
-    type Item = &'a [u8];
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match *self {
-            LiteralIter::Empty => None,
-            LiteralIter::Bytes(ref mut many) => {
-                if many.is_empty() {
-                    None
-                } else {
-                    let next = &many[0..1];
-                    *many = &many[1..];
-                    Some(next)
-                }
-            }
-            LiteralIter::Single(ref mut one) => {
-                if one.is_empty() {
-                    None
-                } else {
-                    let next = &one[..];
-                    *one = &[];
-                    Some(next)
-                }
-            }
-            LiteralIter::AC(ref mut lits) => {
-                if lits.is_empty() {
-                    None
-                } else {
-                    let next = &lits[0];
-                    *lits = &lits[1..];
-                    Some(next.as_bytes())
-                }
-            }
-            LiteralIter::Packed(ref mut lits) => {
-                if lits.is_empty() {
-                    None
-                } else {
-                    let next = &lits[0];
-                    *lits = &lits[1..];
-                    Some(next.as_bytes())
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-struct SingleByteSet {
-    sparse: Vec<bool>,
-    dense: Vec<u8>,
-    complete: bool,
-    all_ascii: bool,
-}
-
-impl SingleByteSet {
-    fn new() -> SingleByteSet {
-        SingleByteSet {
-            sparse: vec![false; 256],
-            dense: vec![],
-            complete: true,
-            all_ascii: true,
-        }
-    }
-
-    fn prefixes(lits: &Seq) -> SingleByteSet {
-        let mut sset = SingleByteSet::new();
-        let lits = match lits.literals() {
-            None => return sset,
-            Some(lits) => lits,
-        };
-        for lit in lits.iter() {
-            sset.complete = sset.complete && lit.len() == 1;
-            if let Some(&b) = lit.as_bytes().get(0) {
-                if !sset.sparse[b as usize] {
-                    if b > 0x7F {
-                        sset.all_ascii = false;
-                    }
-                    sset.dense.push(b);
-                    sset.sparse[b as usize] = true;
-                }
-            }
-        }
-        sset
-    }
-
-    fn suffixes(lits: &Seq) -> SingleByteSet {
-        let mut sset = SingleByteSet::new();
-        let lits = match lits.literals() {
-            None => return sset,
-            Some(lits) => lits,
-        };
-        for lit in lits.iter() {
-            sset.complete = sset.complete && lit.len() == 1;
-            if let Some(&b) = lit.as_bytes().last() {
-                if !sset.sparse[b as usize] {
-                    if b > 0x7F {
-                        sset.all_ascii = false;
-                    }
-                    sset.dense.push(b);
-                    sset.sparse[b as usize] = true;
-                }
-            }
-        }
-        sset
-    }
-
-    /// Faster find that special cases certain sizes to use memchr.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn find(&self, text: &[u8]) -> Option<usize> {
-        match self.dense.len() {
-            0 => None,
-            1 => memchr(self.dense[0], text),
-            2 => memchr2(self.dense[0], self.dense[1], text),
-            3 => memchr3(self.dense[0], self.dense[1], self.dense[2], text),
-            _ => self._find(text),
-        }
-    }
-
-    /// Generic find that works on any sized set.
-    fn _find(&self, haystack: &[u8]) -> Option<usize> {
-        for (i, &b) in haystack.iter().enumerate() {
-            if self.sparse[b as usize] {
-                return Some(i);
-            }
-        }
-        None
-    }
-
-    fn approximate_size(&self) -> usize {
-        (self.dense.len() * mem::size_of::<u8>())
-            + (self.sparse.len() * mem::size_of::<bool>())
-    }
-}
-
-/// A simple wrapper around the memchr crate's memmem implementation.
-///
-/// The API this exposes mirrors the API of previous substring searchers that
-/// this supplanted.
-#[derive(Clone, Debug)]
-pub struct Memmem {
-    finder: memmem::Finder<'static>,
-    char_len: usize,
-}
-
-impl Memmem {
-    fn new(pat: &[u8]) -> Memmem {
-        Memmem {
-            finder: memmem::Finder::new(pat).into_owned(),
-            char_len: char_len_lossy(pat),
-        }
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn find(&self, haystack: &[u8]) -> Option<usize> {
-        self.finder.find(haystack)
-    }
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn is_suffix(&self, text: &[u8]) -> bool {
-        if text.len() < self.len() {
-            return false;
-        }
-        &text[text.len() - self.len()..] == self.finder.needle()
-    }
-
-    pub fn len(&self) -> usize {
-        self.finder.needle().len()
-    }
-
-    pub fn char_len(&self) -> usize {
-        self.char_len
-    }
-
-    fn approximate_size(&self) -> usize {
-        self.finder.needle().len() * mem::size_of::<u8>()
-    }
-}
-
-fn char_len_lossy(bytes: &[u8]) -> usize {
-    String::from_utf8_lossy(bytes).chars().count()
-}
diff --git a/src/literal/mod.rs b/src/literal/mod.rs
deleted file mode 100644
index b9fb77aed9..0000000000
--- a/src/literal/mod.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-pub use self::imp::*;
-
-#[cfg(feature = "perf-literal")]
-mod imp;
-
-#[allow(missing_docs)]
-#[cfg(not(feature = "perf-literal"))]
-mod imp {
-    use regex_syntax::hir::literal::Seq;
-
-    #[derive(Clone, Debug)]
-    pub struct LiteralSearcher(());
-
-    impl LiteralSearcher {
-        pub fn empty() -> Self {
-            LiteralSearcher(())
-        }
-
-        pub fn prefixes(_: Seq) -> Self {
-            LiteralSearcher(())
-        }
-
-        pub fn suffixes(_: Seq) -> Self {
-            LiteralSearcher(())
-        }
-
-        pub fn complete(&self) -> bool {
-            false
-        }
-
-        pub fn find(&self, _: &[u8]) -> Option<(usize, usize)> {
-            unreachable!()
-        }
-
-        pub fn find_start(&self, _: &[u8]) -> Option<(usize, usize)> {
-            unreachable!()
-        }
-
-        pub fn find_end(&self, _: &[u8]) -> Option<(usize, usize)> {
-            unreachable!()
-        }
-
-        pub fn is_empty(&self) -> bool {
-            true
-        }
-
-        pub fn len(&self) -> usize {
-            0
-        }
-
-        pub fn approximate_size(&self) -> usize {
-            0
-        }
-    }
-}
diff --git a/src/pattern.rs b/src/pattern.rs
index 00549e5106..2db04d8b35 100644
--- a/src/pattern.rs
+++ b/src/pattern.rs
@@ -1,6 +1,6 @@
-use std::str::pattern::{Pattern, SearchStep, Searcher};
+use core::str::pattern::{Pattern, SearchStep, Searcher};
 
-use crate::re_unicode::{Matches, Regex};
+use crate::{Matches, Regex};
 
 #[derive(Debug)]
 pub struct RegexSearcher<'r, 't> {
diff --git a/src/pikevm.rs b/src/pikevm.rs
deleted file mode 100644
index 8c9eac2d39..0000000000
--- a/src/pikevm.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-// This module implements the Pike VM. That is, it guarantees linear time
-// search of a regex on any text with memory use proportional to the size of
-// the regex.
-//
-// It is equal in power to the backtracking engine in this crate, except the
-// backtracking engine is typically faster on small regexes/texts at the
-// expense of a bigger memory footprint.
-//
-// It can do more than the DFA can (specifically, record capture locations
-// and execute Unicode word boundary assertions), but at a slower speed.
-// Specifically, the Pike VM executes a DFA implicitly by repeatedly expanding
-// epsilon transitions. That is, the Pike VM engine can be in multiple states
-// at once where as the DFA is only ever in one state at a time.
-//
-// Therefore, the Pike VM is generally treated as the fallback when the other
-// matching engines either aren't feasible to run or are insufficient.
-
-use std::mem;
-
-use crate::exec::ProgramCache;
-use crate::input::{Input, InputAt};
-use crate::prog::{InstPtr, Program};
-use crate::re_trait::Slot;
-use crate::sparse::SparseSet;
-
-/// An NFA simulation matching engine.
-#[derive(Debug)]
-pub struct Fsm<'r, I> {
-    /// The sequence of opcodes (among other things) that is actually executed.
-    ///
-    /// The program may be byte oriented or Unicode codepoint oriented.
-    prog: &'r Program,
-    /// An explicit stack used for following epsilon transitions. (This is
-    /// borrowed from the cache.)
-    stack: &'r mut Vec<FollowEpsilon>,
-    /// The input to search.
-    input: I,
-}
-
-/// A cached allocation that can be reused on each execution.
-#[derive(Clone, Debug)]
-pub struct Cache {
-    /// A pair of ordered sets for tracking NFA states.
-    clist: Threads,
-    nlist: Threads,
-    /// An explicit stack used for following epsilon transitions.
-    stack: Vec<FollowEpsilon>,
-}
-
-/// An ordered set of NFA states and their captures.
-#[derive(Clone, Debug)]
-struct Threads {
-    /// An ordered set of opcodes (each opcode is an NFA state).
-    set: SparseSet,
-    /// Captures for every NFA state.
-    ///
-    /// It is stored in row-major order, where the columns are the capture
-    /// slots and the rows are the states.
-    caps: Vec<Slot>,
-    /// The number of capture slots stored per thread. (Every capture has
-    /// two slots.)
-    slots_per_thread: usize,
-}
-
-/// A representation of an explicit stack frame when following epsilon
-/// transitions. This is used to avoid recursion.
-#[derive(Clone, Debug)]
-enum FollowEpsilon {
-    /// Follow transitions at the given instruction pointer.
-    IP(InstPtr),
-    /// Restore the capture slot with the given position in the input.
-    Capture { slot: usize, pos: Slot },
-}
-
-impl Cache {
-    /// Create a new allocation used by the NFA machine to record execution
-    /// and captures.
-    pub fn new(_prog: &Program) -> Self {
-        Cache { clist: Threads::new(), nlist: Threads::new(), stack: vec![] }
-    }
-}
-
-impl<'r, I: Input> Fsm<'r, I> {
-    /// Execute the NFA matching engine.
-    ///
-    /// If there's a match, `exec` returns `true` and populates the given
-    /// captures accordingly.
-    pub fn exec(
-        prog: &'r Program,
-        cache: &ProgramCache,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        quit_after_match: bool,
-        input: I,
-        start: usize,
-        end: usize,
-    ) -> bool {
-        let mut cache = cache.borrow_mut();
-        let cache = &mut cache.pikevm;
-        cache.clist.resize(prog.len(), prog.captures.len());
-        cache.nlist.resize(prog.len(), prog.captures.len());
-        let at = input.at(start);
-        Fsm { prog, stack: &mut cache.stack, input }.exec_(
-            &mut cache.clist,
-            &mut cache.nlist,
-            matches,
-            slots,
-            quit_after_match,
-            at,
-            end,
-        )
-    }
-
-    fn exec_(
-        &mut self,
-        mut clist: &mut Threads,
-        mut nlist: &mut Threads,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        quit_after_match: bool,
-        mut at: InputAt,
-        end: usize,
-    ) -> bool {
-        let mut matched = false;
-        let mut all_matched = false;
-        clist.set.clear();
-        nlist.set.clear();
-        'LOOP: loop {
-            if clist.set.is_empty() {
-                // Three ways to bail out when our current set of threads is
-                // empty.
-                //
-                // 1. We have a match---so we're done exploring any possible
-                //    alternatives. Time to quit. (We can't do this if we're
-                //    looking for matches for multiple regexes, unless we know
-                //    they all matched.)
-                //
-                // 2. If the expression starts with a '^' we can terminate as
-                //    soon as the last thread dies.
-                if (matched && matches.len() <= 1)
-                    || all_matched
-                    || (!at.is_start() && self.prog.is_anchored_start)
-                {
-                    break;
-                }
-
-                // 3. If there's a literal prefix for the program, try to
-                //    jump ahead quickly. If it can't be found, then we can
-                //    bail out early.
-                if !self.prog.prefixes.is_empty() {
-                    at = match self.input.prefix_at(&self.prog.prefixes, at) {
-                        None => break,
-                        Some(at) => at,
-                    };
-                }
-            }
-
-            // This simulates a preceding '.*?' for every regex by adding
-            // a state starting at the current position in the input for the
-            // beginning of the program only if we don't already have a match.
-            if clist.set.is_empty()
-                || (!self.prog.is_anchored_start && !all_matched)
-            {
-                self.add(&mut clist, slots, 0, at);
-            }
-            // The previous call to "add" actually inspects the position just
-            // before the current character. For stepping through the machine,
-            // we can to look at the current character, so we advance the
-            // input.
-            let at_next = self.input.at(at.next_pos());
-            for i in 0..clist.set.len() {
-                let ip = clist.set[i];
-                if self.step(
-                    &mut nlist,
-                    matches,
-                    slots,
-                    clist.caps(ip),
-                    ip,
-                    at,
-                    at_next,
-                ) {
-                    matched = true;
-                    all_matched = all_matched || matches.iter().all(|&b| b);
-                    if quit_after_match {
-                        // If we only care if a match occurs (not its
-                        // position), then we can quit right now.
-                        break 'LOOP;
-                    }
-                    if self.prog.matches.len() == 1 {
-                        // We don't need to check the rest of the threads
-                        // in this set because we've matched something
-                        // ("leftmost-first"). However, we still need to check
-                        // threads in the next set to support things like
-                        // greedy matching.
-                        //
-                        // This is only true on normal regexes. For regex sets,
-                        // we need to mush on to observe other matches.
-                        break;
-                    }
-                }
-            }
-            if at.pos() >= end {
-                break;
-            }
-            at = at_next;
-            mem::swap(clist, nlist);
-            nlist.set.clear();
-        }
-        matched
-    }
-
-    /// Step through the input, one token (byte or codepoint) at a time.
-    ///
-    /// nlist is the set of states that will be processed on the next token
-    /// in the input.
-    ///
-    /// caps is the set of captures passed by the caller of the NFA. They are
-    /// written to only when a match state is visited.
-    ///
-    /// thread_caps is the set of captures set for the current NFA state, ip.
-    ///
-    /// at and at_next are the current and next positions in the input. at or
-    /// at_next may be EOF.
-    fn step(
-        &mut self,
-        nlist: &mut Threads,
-        matches: &mut [bool],
-        slots: &mut [Slot],
-        thread_caps: &mut [Option<usize>],
-        ip: usize,
-        at: InputAt,
-        at_next: InputAt,
-    ) -> bool {
-        use crate::prog::Inst::*;
-        match self.prog[ip] {
-            Match(match_slot) => {
-                if match_slot < matches.len() {
-                    matches[match_slot] = true;
-                }
-                for (slot, val) in slots.iter_mut().zip(thread_caps.iter()) {
-                    *slot = *val;
-                }
-                true
-            }
-            Char(ref inst) => {
-                if inst.c == at.char() {
-                    self.add(nlist, thread_caps, inst.goto, at_next);
-                }
-                false
-            }
-            Ranges(ref inst) => {
-                if inst.matches(at.char()) {
-                    self.add(nlist, thread_caps, inst.goto, at_next);
-                }
-                false
-            }
-            Bytes(ref inst) => {
-                if let Some(b) = at.byte() {
-                    if inst.matches(b) {
-                        self.add(nlist, thread_caps, inst.goto, at_next);
-                    }
-                }
-                false
-            }
-            EmptyLook(_) | Save(_) | Split(_) => false,
-        }
-    }
-
-    /// Follows epsilon transitions and adds them for processing to nlist,
-    /// starting at and including ip.
-    fn add(
-        &mut self,
-        nlist: &mut Threads,
-        thread_caps: &mut [Option<usize>],
-        ip: usize,
-        at: InputAt,
-    ) {
-        self.stack.push(FollowEpsilon::IP(ip));
-        while let Some(frame) = self.stack.pop() {
-            match frame {
-                FollowEpsilon::IP(ip) => {
-                    self.add_step(nlist, thread_caps, ip, at);
-                }
-                FollowEpsilon::Capture { slot, pos } => {
-                    thread_caps[slot] = pos;
-                }
-            }
-        }
-    }
-
-    /// A helper function for add that avoids excessive pushing to the stack.
-    fn add_step(
-        &mut self,
-        nlist: &mut Threads,
-        thread_caps: &mut [Option<usize>],
-        mut ip: usize,
-        at: InputAt,
-    ) {
-        // Instead of pushing and popping to the stack, we mutate ip as we
-        // traverse the set of states. We only push to the stack when we
-        // absolutely need recursion (restoring captures or following a
-        // branch).
-        use crate::prog::Inst::*;
-        loop {
-            // Don't visit states we've already added.
-            if nlist.set.contains(ip) {
-                return;
-            }
-            nlist.set.insert(ip);
-            match self.prog[ip] {
-                EmptyLook(ref inst) => {
-                    if self.input.is_empty_match(at, inst) {
-                        ip = inst.goto;
-                    }
-                }
-                Save(ref inst) => {
-                    if inst.slot < thread_caps.len() {
-                        self.stack.push(FollowEpsilon::Capture {
-                            slot: inst.slot,
-                            pos: thread_caps[inst.slot],
-                        });
-                        thread_caps[inst.slot] = Some(at.pos());
-                    }
-                    ip = inst.goto;
-                }
-                Split(ref inst) => {
-                    self.stack.push(FollowEpsilon::IP(inst.goto2));
-                    ip = inst.goto1;
-                }
-                Match(_) | Char(_) | Ranges(_) | Bytes(_) => {
-                    let t = &mut nlist.caps(ip);
-                    for (slot, val) in t.iter_mut().zip(thread_caps.iter()) {
-                        *slot = *val;
-                    }
-                    return;
-                }
-            }
-        }
-    }
-}
-
-impl Threads {
-    fn new() -> Self {
-        Threads { set: SparseSet::new(0), caps: vec![], slots_per_thread: 0 }
-    }
-
-    fn resize(&mut self, num_insts: usize, ncaps: usize) {
-        if num_insts == self.set.capacity() {
-            return;
-        }
-        self.slots_per_thread = ncaps * 2;
-        self.set = SparseSet::new(num_insts);
-        self.caps = vec![None; self.slots_per_thread * num_insts];
-    }
-
-    fn caps(&mut self, pc: usize) -> &mut [Option<usize>] {
-        let i = pc * self.slots_per_thread;
-        &mut self.caps[i..i + self.slots_per_thread]
-    }
-}
diff --git a/src/pool.rs b/src/pool.rs
deleted file mode 100644
index 6a6f15b194..0000000000
--- a/src/pool.rs
+++ /dev/null
@@ -1,333 +0,0 @@
-// This module provides a relatively simple thread-safe pool of reusable
-// objects. For the most part, it's implemented by a stack represented by a
-// Mutex<Vec<T>>. It has one small trick: because unlocking a mutex is somewhat
-// costly, in the case where a pool is accessed by the first thread that tried
-// to get a value, we bypass the mutex. Here are some benchmarks showing the
-// difference.
-//
-// 1) misc::anchored_literal_long_non_match    21 (18571 MB/s)
-// 2) misc::anchored_literal_long_non_match   107 (3644 MB/s)
-// 3) misc::anchored_literal_long_non_match    45 (8666 MB/s)
-// 4) misc::anchored_literal_long_non_match    19 (20526 MB/s)
-//
-// (1) represents our baseline: the master branch at the time of writing when
-// using the 'thread_local' crate to implement the pool below.
-//
-// (2) represents a naive pool implemented completely via Mutex<Vec<T>>. There
-// is no special trick for bypassing the mutex.
-//
-// (3) is the same as (2), except it uses Mutex<Vec<Box<T>>>. It is twice as
-// fast because a Box<T> is much smaller than the T we use with a Pool in this
-// crate. So pushing and popping a Box<T> from a Vec is quite a bit faster
-// than for T.
-//
-// (4) is the same as (3), but with the trick for bypassing the mutex in the
-// case of the first-to-get thread.
-//
-// Why move off of thread_local? Even though (4) is a hair faster than (1)
-// above, this was not the main goal. The main goal was to move off of
-// thread_local and find a way to *simply* re-capture some of its speed for
-// regex's specific case. So again, why move off of it? The *primary* reason is
-// because of memory leaks. See https://github.com/rust-lang/regex/issues/362
-// for example. (Why do I want it to be simple? Well, I suppose what I mean is,
-// "use as much safe code as possible to minimize risk and be as sure as I can
-// be that it is correct.")
-//
-// My guess is that the thread_local design is probably not appropriate for
-// regex since its memory usage scales to the number of active threads that
-// have used a regex, where as the pool below scales to the number of threads
-// that simultaneously use a regex. While neither case permits contraction,
-// since we own the pool data structure below, we can add contraction if a
-// clear use case pops up in the wild. More pressingly though, it seems that
-// there are at least some use case patterns where one might have many threads
-// sitting around that might have used a regex at one point. While thread_local
-// does try to reuse space previously used by a thread that has since stopped,
-// its maximal memory usage still scales with the total number of active
-// threads. In contrast, the pool below scales with the total number of threads
-// *simultaneously* using the pool. The hope is that this uses less memory
-// overall. And if it doesn't, we can hopefully tune it somehow.
-//
-// It seems that these sort of conditions happen frequently
-// in FFI inside of other more "managed" languages. This was
-// mentioned in the issue linked above, and also mentioned here:
-// https://github.com/BurntSushi/rure-go/issues/3. And in particular, users
-// confirm that disabling the use of thread_local resolves the leak.
-//
-// There were other weaker reasons for moving off of thread_local as well.
-// Namely, at the time, I was looking to reduce dependencies. And for something
-// like regex, maintenance can be simpler when we own the full dependency tree.
-
-use std::panic::{RefUnwindSafe, UnwindSafe};
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Mutex;
-
-/// An atomic counter used to allocate thread IDs.
-static COUNTER: AtomicUsize = AtomicUsize::new(1);
-
-thread_local!(
-    /// A thread local used to assign an ID to a thread.
-    static THREAD_ID: usize = {
-        let next = COUNTER.fetch_add(1, Ordering::Relaxed);
-        // SAFETY: We cannot permit the reuse of thread IDs since reusing a
-        // thread ID might result in more than one thread "owning" a pool,
-        // and thus, permit accessing a mutable value from multiple threads
-        // simultaneously without synchronization. The intent of this panic is
-        // to be a sanity check. It is not expected that the thread ID space
-        // will actually be exhausted in practice.
-        //
-        // This checks that the counter never wraps around, since atomic
-        // addition wraps around on overflow.
-        if next == 0 {
-            panic!("regex: thread ID allocation space exhausted");
-        }
-        next
-    };
-);
-
-/// The type of the function used to create values in a pool when the pool is
-/// empty and the caller requests one.
-type CreateFn<T> =
-    Box<dyn Fn() -> T + Send + Sync + UnwindSafe + RefUnwindSafe + 'static>;
-
-/// A simple thread safe pool for reusing values.
-///
-/// Getting a value out comes with a guard. When that guard is dropped, the
-/// value is automatically put back in the pool.
-///
-/// A Pool<T> impls Sync when T is Send (even if it's not Sync). This means
-/// that T can use interior mutability. This is possible because a pool is
-/// guaranteed to provide a value to exactly one thread at any time.
-///
-/// Currently, a pool never contracts in size. Its size is proportional to the
-/// number of simultaneous uses.
-pub struct Pool<T> {
-    /// A stack of T values to hand out. These are used when a Pool is
-    /// accessed by a thread that didn't create it.
-    stack: Mutex<Vec<Box<T>>>,
-    /// A function to create more T values when stack is empty and a caller
-    /// has requested a T.
-    create: CreateFn<T>,
-    /// The ID of the thread that owns this pool. The owner is the thread
-    /// that makes the first call to 'get'. When the owner calls 'get', it
-    /// gets 'owner_val' directly instead of returning a T from 'stack'.
-    /// See comments elsewhere for details, but this is intended to be an
-    /// optimization for the common case that makes getting a T faster.
-    ///
-    /// It is initialized to a value of zero (an impossible thread ID) as a
-    /// sentinel to indicate that it is unowned.
-    owner: AtomicUsize,
-    /// A value to return when the caller is in the same thread that created
-    /// the Pool.
-    owner_val: T,
-}
-
-// SAFETY: Since we want to use a Pool from multiple threads simultaneously
-// behind an Arc, we need for it to be Sync. In cases where T is sync, Pool<T>
-// would be Sync. However, since we use a Pool to store mutable scratch space,
-// we wind up using a T that has interior mutability and is thus itself not
-// Sync. So what we *really* want is for our Pool<T> to by Sync even when T is
-// not Sync (but is at least Send).
-//
-// The only non-sync aspect of a Pool is its 'owner_val' field, which is used
-// to implement faster access to a pool value in the common case of a pool
-// being accessed in the same thread in which it was created. The 'stack' field
-// is also shared, but a Mutex<T> where T: Send is already Sync. So we only
-// need to worry about 'owner_val'.
-//
-// The key is to guarantee that 'owner_val' can only ever be accessed from one
-// thread. In our implementation below, we guarantee this by only returning the
-// 'owner_val' when the ID of the current thread matches the ID of the thread
-// that created the Pool. Since this can only ever be one thread, it follows
-// that only one thread can access 'owner_val' at any point in time. Thus, it
-// is safe to declare that Pool<T> is Sync when T is Send.
-//
-// NOTE: It would also be possible to make the owning thread be the *first*
-// thread that tries to get a value out of a Pool. However, the current
-// implementation is a little simpler and it's not clear if making the first
-// thread (rather than the creating thread) is meaningfully better.
-//
-// If there is a way to achieve our performance goals using safe code, then
-// I would very much welcome a patch. As it stands, the implementation below
-// tries to balance safety with performance. The case where a Regex is used
-// from multiple threads simultaneously will suffer a bit since getting a cache
-// will require unlocking a mutex.
-unsafe impl<T: Send> Sync for Pool<T> {}
-
-impl<T: ::std::fmt::Debug> ::std::fmt::Debug for Pool<T> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        f.debug_struct("Pool")
-            .field("stack", &self.stack)
-            .field("owner", &self.owner)
-            .field("owner_val", &self.owner_val)
-            .finish()
-    }
-}
-
-/// A guard that is returned when a caller requests a value from the pool.
-///
-/// The purpose of the guard is to use RAII to automatically put the value back
-/// in the pool once it's dropped.
-#[derive(Debug)]
-pub struct PoolGuard<'a, T: Send> {
-    /// The pool that this guard is attached to.
-    pool: &'a Pool<T>,
-    /// This is None when the guard represents the special "owned" value. In
-    /// which case, the value is retrieved from 'pool.owner_val'.
-    value: Option<Box<T>>,
-}
-
-impl<T: Send> Pool<T> {
-    /// Create a new pool. The given closure is used to create values in the
-    /// pool when necessary.
-    pub fn new(create: CreateFn<T>) -> Pool<T> {
-        let owner = AtomicUsize::new(0);
-        let owner_val = create();
-        Pool { stack: Mutex::new(vec![]), create, owner, owner_val }
-    }
-
-    /// Get a value from the pool. The caller is guaranteed to have exclusive
-    /// access to the given value.
-    ///
-    /// Note that there is no guarantee provided about which value in the
-    /// pool is returned. That is, calling get, dropping the guard (causing
-    /// the value to go back into the pool) and then calling get again is NOT
-    /// guaranteed to return the same value received in the first get call.
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    pub fn get(&self) -> PoolGuard<'_, T> {
-        // Our fast path checks if the caller is the thread that "owns" this
-        // pool. Or stated differently, whether it is the first thread that
-        // tried to extract a value from the pool. If it is, then we can return
-        // a T to the caller without going through a mutex.
-        //
-        // SAFETY: We must guarantee that only one thread gets access to this
-        // value. Since a thread is uniquely identified by the THREAD_ID thread
-        // local, it follows that is the caller's thread ID is equal to the
-        // owner, then only one thread may receive this value.
-        let caller = THREAD_ID.with(|id| *id);
-        let owner = self.owner.load(Ordering::Relaxed);
-        if caller == owner {
-            return self.guard_owned();
-        }
-        self.get_slow(caller, owner)
-    }
-
-    /// This is the "slow" version that goes through a mutex to pop an
-    /// allocated value off a stack to return to the caller. (Or, if the stack
-    /// is empty, a new value is created.)
-    ///
-    /// If the pool has no owner, then this will set the owner.
-    #[cold]
-    fn get_slow(&self, caller: usize, owner: usize) -> PoolGuard<'_, T> {
-        use std::sync::atomic::Ordering::Relaxed;
-
-        if owner == 0 {
-            // The sentinel 0 value means this pool is not yet owned. We
-            // try to atomically set the owner. If we do, then this thread
-            // becomes the owner and we can return a guard that represents
-            // the special T for the owner.
-            let res = self.owner.compare_exchange(0, caller, Relaxed, Relaxed);
-            if res.is_ok() {
-                return self.guard_owned();
-            }
-        }
-        let mut stack = self.stack.lock().unwrap();
-        let value = match stack.pop() {
-            None => Box::new((self.create)()),
-            Some(value) => value,
-        };
-        self.guard_stack(value)
-    }
-
-    /// Puts a value back into the pool. Callers don't need to call this. Once
-    /// the guard that's returned by 'get' is dropped, it is put back into the
-    /// pool automatically.
-    fn put(&self, value: Box<T>) {
-        let mut stack = self.stack.lock().unwrap();
-        stack.push(value);
-    }
-
-    /// Create a guard that represents the special owned T.
-    fn guard_owned(&self) -> PoolGuard<'_, T> {
-        PoolGuard { pool: self, value: None }
-    }
-
-    /// Create a guard that contains a value from the pool's stack.
-    fn guard_stack(&self, value: Box<T>) -> PoolGuard<'_, T> {
-        PoolGuard { pool: self, value: Some(value) }
-    }
-}
-
-impl<'a, T: Send> PoolGuard<'a, T> {
-    /// Return the underlying value.
-    pub fn value(&self) -> &T {
-        match self.value {
-            None => &self.pool.owner_val,
-            Some(ref v) => &**v,
-        }
-    }
-}
-
-impl<'a, T: Send> Drop for PoolGuard<'a, T> {
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn drop(&mut self) {
-        if let Some(value) = self.value.take() {
-            self.pool.put(value);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::panic::{RefUnwindSafe, UnwindSafe};
-
-    use super::*;
-
-    #[test]
-    fn oibits() {
-        use crate::exec::ProgramCache;
-
-        fn has_oibits<T: Send + Sync + UnwindSafe + RefUnwindSafe>() {}
-        has_oibits::<Pool<ProgramCache>>();
-    }
-
-    // Tests that Pool implements the "single owner" optimization. That is, the
-    // thread that first accesses the pool gets its own copy, while all other
-    // threads get distinct copies.
-    #[test]
-    fn thread_owner_optimization() {
-        use std::cell::RefCell;
-        use std::sync::Arc;
-
-        let pool: Arc<Pool<RefCell<Vec<char>>>> =
-            Arc::new(Pool::new(Box::new(|| RefCell::new(vec!['a']))));
-        pool.get().value().borrow_mut().push('x');
-
-        let pool1 = pool.clone();
-        let t1 = std::thread::spawn(move || {
-            let guard = pool1.get();
-            let v = guard.value();
-            v.borrow_mut().push('y');
-        });
-
-        let pool2 = pool.clone();
-        let t2 = std::thread::spawn(move || {
-            let guard = pool2.get();
-            let v = guard.value();
-            v.borrow_mut().push('z');
-        });
-
-        t1.join().unwrap();
-        t2.join().unwrap();
-
-        // If we didn't implement the single owner optimization, then one of
-        // the threads above is likely to have mutated the [a, x] vec that
-        // we stuffed in the pool before spawning the threads. But since
-        // neither thread was first to access the pool, and because of the
-        // optimization, we should be guaranteed that neither thread mutates
-        // the special owned pool value.
-        //
-        // (Technically this is an implementation detail and not a contract of
-        // Pool's API.)
-        assert_eq!(vec!['a', 'x'], *pool.get().value().borrow());
-    }
-}
diff --git a/src/prog.rs b/src/prog.rs
deleted file mode 100644
index 100862cf1b..0000000000
--- a/src/prog.rs
+++ /dev/null
@@ -1,451 +0,0 @@
-use std::cmp::Ordering;
-use std::collections::HashMap;
-use std::fmt;
-use std::mem;
-use std::ops::Deref;
-use std::slice;
-use std::sync::Arc;
-
-use crate::input::Char;
-use crate::literal::LiteralSearcher;
-
-/// `InstPtr` represents the index of an instruction in a regex program.
-pub type InstPtr = usize;
-
-/// Program is a sequence of instructions and various facts about thos
-/// instructions.
-#[derive(Clone)]
-pub struct Program {
-    /// A sequence of instructions that represents an NFA.
-    pub insts: Vec<Inst>,
-    /// Pointers to each Match instruction in the sequence.
-    ///
-    /// This is always length 1 unless this program represents a regex set.
-    pub matches: Vec<InstPtr>,
-    /// The ordered sequence of all capture groups extracted from the AST.
-    /// Unnamed groups are `None`.
-    pub captures: Vec<Option<String>>,
-    /// Pointers to all named capture groups into `captures`.
-    pub capture_name_idx: Arc<HashMap<String, usize>>,
-    /// If the number of capture groups is the same for all possible matches,
-    /// then this is that number.
-    pub static_captures_len: Option<usize>,
-    /// A pointer to the start instruction. This can vary depending on how
-    /// the program was compiled. For example, programs for use with the DFA
-    /// engine have a `.*?` inserted at the beginning of unanchored regular
-    /// expressions. The actual starting point of the program is after the
-    /// `.*?`.
-    pub start: InstPtr,
-    /// A set of equivalence classes for discriminating bytes in the compiled
-    /// program.
-    pub byte_classes: Vec<u8>,
-    /// When true, this program can only match valid UTF-8.
-    pub only_utf8: bool,
-    /// When true, this program uses byte range instructions instead of Unicode
-    /// range instructions.
-    pub is_bytes: bool,
-    /// When true, the program is compiled for DFA matching. For example, this
-    /// implies `is_bytes` and also inserts a preceding `.*?` for unanchored
-    /// regexes.
-    pub is_dfa: bool,
-    /// When true, the program matches text in reverse (for use only in the
-    /// DFA).
-    pub is_reverse: bool,
-    /// Whether the regex must match from the start of the input.
-    pub is_anchored_start: bool,
-    /// Whether the regex must match at the end of the input.
-    pub is_anchored_end: bool,
-    /// Whether this program contains a Unicode word boundary instruction.
-    pub has_unicode_word_boundary: bool,
-    /// A possibly empty machine for very quickly matching prefix literals.
-    pub prefixes: LiteralSearcher,
-    /// A limit on the size of the cache that the DFA is allowed to use while
-    /// matching.
-    ///
-    /// The cache limit specifies approximately how much space we're willing to
-    /// give to the state cache. Once the state cache exceeds the size, it is
-    /// wiped and all states must be re-computed.
-    ///
-    /// Note that this value does not impact correctness. It can be set to 0
-    /// and the DFA will run just fine. (It will only ever store exactly one
-    /// state in the cache, and will likely run very slowly, but it will work.)
-    ///
-    /// Also note that this limit is *per thread of execution*. That is,
-    /// if the same regex is used to search text across multiple threads
-    /// simultaneously, then the DFA cache is not shared. Instead, copies are
-    /// made.
-    pub dfa_size_limit: usize,
-}
-
-impl Program {
-    /// Creates an empty instruction sequence. Fields are given default
-    /// values.
-    pub fn new() -> Self {
-        Program {
-            insts: vec![],
-            matches: vec![],
-            captures: vec![],
-            capture_name_idx: Arc::new(HashMap::new()),
-            static_captures_len: None,
-            start: 0,
-            byte_classes: vec![0; 256],
-            only_utf8: true,
-            is_bytes: false,
-            is_dfa: false,
-            is_reverse: false,
-            is_anchored_start: false,
-            is_anchored_end: false,
-            has_unicode_word_boundary: false,
-            prefixes: LiteralSearcher::empty(),
-            dfa_size_limit: 2 * (1 << 20),
-        }
-    }
-
-    /// If pc is an index to a no-op instruction (like Save), then return the
-    /// next pc that is not a no-op instruction.
-    pub fn skip(&self, mut pc: usize) -> usize {
-        loop {
-            match self[pc] {
-                Inst::Save(ref i) => pc = i.goto,
-                _ => return pc,
-            }
-        }
-    }
-
-    /// Return true if and only if an execution engine at instruction `pc` will
-    /// always lead to a match.
-    pub fn leads_to_match(&self, pc: usize) -> bool {
-        if self.matches.len() > 1 {
-            // If we have a regex set, then we have more than one ending
-            // state, so leading to one of those states is generally
-            // meaningless.
-            return false;
-        }
-        match self[self.skip(pc)] {
-            Inst::Match(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the current configuration demands that an implicit
-    /// `.*?` be prepended to the instruction sequence.
-    pub fn needs_dotstar(&self) -> bool {
-        self.is_dfa && !self.is_reverse && !self.is_anchored_start
-    }
-
-    /// Returns true if this program uses Byte instructions instead of
-    /// Char/Range instructions.
-    pub fn uses_bytes(&self) -> bool {
-        self.is_bytes || self.is_dfa
-    }
-
-    /// Returns true if this program exclusively matches valid UTF-8 bytes.
-    ///
-    /// That is, if an invalid UTF-8 byte is seen, then no match is possible.
-    pub fn only_utf8(&self) -> bool {
-        self.only_utf8
-    }
-
-    /// Return the approximate heap usage of this instruction sequence in
-    /// bytes.
-    pub fn approximate_size(&self) -> usize {
-        // The only instruction that uses heap space is Ranges (for
-        // Unicode codepoint programs) to store non-overlapping codepoint
-        // ranges. To keep this operation constant time, we ignore them.
-        (self.len() * mem::size_of::<Inst>())
-            + (self.matches.len() * mem::size_of::<InstPtr>())
-            + (self.captures.len() * mem::size_of::<Option<String>>())
-            + (self.capture_name_idx.len()
-                * (mem::size_of::<String>() + mem::size_of::<usize>()))
-            + (self.byte_classes.len() * mem::size_of::<u8>())
-            + self.prefixes.approximate_size()
-    }
-}
-
-impl Deref for Program {
-    type Target = [Inst];
-
-    #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn deref(&self) -> &Self::Target {
-        &*self.insts
-    }
-}
-
-impl fmt::Debug for Program {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use self::Inst::*;
-
-        fn with_goto(cur: usize, goto: usize, fmtd: String) -> String {
-            if goto == cur + 1 {
-                fmtd
-            } else {
-                format!("{} (goto: {})", fmtd, goto)
-            }
-        }
-
-        fn visible_byte(b: u8) -> String {
-            use std::ascii::escape_default;
-            let escaped = escape_default(b).collect::<Vec<u8>>();
-            String::from_utf8_lossy(&escaped).into_owned()
-        }
-
-        for (pc, inst) in self.iter().enumerate() {
-            match *inst {
-                Match(slot) => write!(f, "{:04} Match({:?})", pc, slot)?,
-                Save(ref inst) => {
-                    let s = format!("{:04} Save({})", pc, inst.slot);
-                    write!(f, "{}", with_goto(pc, inst.goto, s))?;
-                }
-                Split(ref inst) => {
-                    write!(
-                        f,
-                        "{:04} Split({}, {})",
-                        pc, inst.goto1, inst.goto2
-                    )?;
-                }
-                EmptyLook(ref inst) => {
-                    let s = format!("{:?}", inst.look);
-                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
-                }
-                Char(ref inst) => {
-                    let s = format!("{:?}", inst.c);
-                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
-                }
-                Ranges(ref inst) => {
-                    let ranges = inst
-                        .ranges
-                        .iter()
-                        .map(|r| format!("{:?}-{:?}", r.0, r.1))
-                        .collect::<Vec<String>>()
-                        .join(", ");
-                    write!(
-                        f,
-                        "{:04} {}",
-                        pc,
-                        with_goto(pc, inst.goto, ranges)
-                    )?;
-                }
-                Bytes(ref inst) => {
-                    let s = format!(
-                        "Bytes({}, {})",
-                        visible_byte(inst.start),
-                        visible_byte(inst.end)
-                    );
-                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
-                }
-            }
-            if pc == self.start {
-                write!(f, " (start)")?;
-            }
-            writeln!(f)?;
-        }
-        Ok(())
-    }
-}
-
-impl<'a> IntoIterator for &'a Program {
-    type Item = &'a Inst;
-    type IntoIter = slice::Iter<'a, Inst>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-/// Inst is an instruction code in a Regex program.
-///
-/// Regrettably, a regex program either contains Unicode codepoint
-/// instructions (Char and Ranges) or it contains byte instructions (Bytes).
-/// A regex program can never contain both.
-///
-/// It would be worth investigating splitting this into two distinct types and
-/// then figuring out how to make the matching engines polymorphic over those
-/// types without sacrificing performance.
-///
-/// Other than the benefit of moving invariants into the type system, another
-/// benefit is the decreased size. If we remove the `Char` and `Ranges`
-/// instructions from the `Inst` enum, then its size shrinks from 32 bytes to
-/// 24 bytes. (This is because of the removal of a `Box<[]>` in the `Ranges`
-/// variant.) Given that byte based machines are typically much bigger than
-/// their Unicode analogues (because they can decode UTF-8 directly), this ends
-/// up being a pretty significant savings.
-#[derive(Clone, Debug)]
-pub enum Inst {
-    /// Match indicates that the program has reached a match state.
-    ///
-    /// The number in the match corresponds to the Nth logical regular
-    /// expression in this program. This index is always 0 for normal regex
-    /// programs. Values greater than 0 appear when compiling regex sets, and
-    /// each match instruction gets its own unique value. The value corresponds
-    /// to the Nth regex in the set.
-    Match(usize),
-    /// Save causes the program to save the current location of the input in
-    /// the slot indicated by InstSave.
-    Save(InstSave),
-    /// Split causes the program to diverge to one of two paths in the
-    /// program, preferring goto1 in InstSplit.
-    Split(InstSplit),
-    /// EmptyLook represents a zero-width assertion in a regex program. A
-    /// zero-width assertion does not consume any of the input text.
-    EmptyLook(InstEmptyLook),
-    /// Char requires the regex program to match the character in InstChar at
-    /// the current position in the input.
-    Char(InstChar),
-    /// Ranges requires the regex program to match the character at the current
-    /// position in the input with one of the ranges specified in InstRanges.
-    Ranges(InstRanges),
-    /// Bytes is like Ranges, except it expresses a single byte range. It is
-    /// used in conjunction with Split instructions to implement multi-byte
-    /// character classes.
-    Bytes(InstBytes),
-}
-
-impl Inst {
-    /// Returns true if and only if this is a match instruction.
-    pub fn is_match(&self) -> bool {
-        match *self {
-            Inst::Match(_) => true,
-            _ => false,
-        }
-    }
-}
-
-/// Representation of the Save instruction.
-#[derive(Clone, Debug)]
-pub struct InstSave {
-    /// The next location to execute in the program.
-    pub goto: InstPtr,
-    /// The capture slot (there are two slots for every capture in a regex,
-    /// including the zeroth capture for the entire match).
-    pub slot: usize,
-}
-
-/// Representation of the Split instruction.
-#[derive(Clone, Debug)]
-pub struct InstSplit {
-    /// The first instruction to try. A match resulting from following goto1
-    /// has precedence over a match resulting from following goto2.
-    pub goto1: InstPtr,
-    /// The second instruction to try. A match resulting from following goto1
-    /// has precedence over a match resulting from following goto2.
-    pub goto2: InstPtr,
-}
-
-/// Representation of the `EmptyLook` instruction.
-#[derive(Clone, Debug)]
-pub struct InstEmptyLook {
-    /// The next location to execute in the program if this instruction
-    /// succeeds.
-    pub goto: InstPtr,
-    /// The type of zero-width assertion to check.
-    pub look: EmptyLook,
-}
-
-/// The set of zero-width match instructions.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum EmptyLook {
-    /// Start of line or input.
-    StartLine,
-    /// End of line or input.
-    EndLine,
-    /// Start of input.
-    StartText,
-    /// End of input.
-    EndText,
-    /// Word character on one side and non-word character on other.
-    WordBoundary,
-    /// Word character on both sides or non-word character on both sides.
-    NotWordBoundary,
-    /// ASCII word boundary.
-    WordBoundaryAscii,
-    /// Not ASCII word boundary.
-    NotWordBoundaryAscii,
-}
-
-/// Representation of the Char instruction.
-#[derive(Clone, Debug)]
-pub struct InstChar {
-    /// The next location to execute in the program if this instruction
-    /// succeeds.
-    pub goto: InstPtr,
-    /// The character to test.
-    pub c: char,
-}
-
-/// Representation of the Ranges instruction.
-#[derive(Clone, Debug)]
-pub struct InstRanges {
-    /// The next location to execute in the program if this instruction
-    /// succeeds.
-    pub goto: InstPtr,
-    /// The set of Unicode scalar value ranges to test.
-    pub ranges: Box<[(char, char)]>,
-}
-
-impl InstRanges {
-    /// Tests whether the given input character matches this instruction.
-    pub fn matches(&self, c: Char) -> bool {
-        // This speeds up the `match_class_unicode` benchmark by checking
-        // some common cases quickly without binary search. e.g., Matching
-        // a Unicode class on predominantly ASCII text.
-        for r in self.ranges.iter().take(4) {
-            if c < r.0 {
-                return false;
-            }
-            if c <= r.1 {
-                return true;
-            }
-        }
-        self.ranges
-            .binary_search_by(|r| {
-                if r.1 < c {
-                    Ordering::Less
-                } else if r.0 > c {
-                    Ordering::Greater
-                } else {
-                    Ordering::Equal
-                }
-            })
-            .is_ok()
-    }
-
-    /// Return the number of distinct characters represented by all of the
-    /// ranges.
-    pub fn num_chars(&self) -> usize {
-        self.ranges
-            .iter()
-            .map(|&(s, e)| 1 + (e as u32) - (s as u32))
-            .sum::<u32>() as usize
-    }
-}
-
-/// Representation of the Bytes instruction.
-#[derive(Clone, Debug)]
-pub struct InstBytes {
-    /// The next location to execute in the program if this instruction
-    /// succeeds.
-    pub goto: InstPtr,
-    /// The start (inclusive) of this byte range.
-    pub start: u8,
-    /// The end (inclusive) of this byte range.
-    pub end: u8,
-}
-
-impl InstBytes {
-    /// Returns true if and only if the given byte is in this range.
-    pub fn matches(&self, byte: u8) -> bool {
-        self.start <= byte && byte <= self.end
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    #[cfg(target_pointer_width = "64")]
-    fn test_size_of_inst() {
-        use std::mem::size_of;
-
-        use super::Inst;
-
-        assert_eq!(32, size_of::<Inst>());
-    }
-}
diff --git a/src/re_builder.rs b/src/re_builder.rs
deleted file mode 100644
index ee6383690d..0000000000
--- a/src/re_builder.rs
+++ /dev/null
@@ -1,421 +0,0 @@
-/// The set of user configurable options for compiling zero or more regexes.
-#[derive(Clone, Debug)]
-#[allow(missing_docs)]
-pub struct RegexOptions {
-    pub pats: Vec<String>,
-    pub size_limit: usize,
-    pub dfa_size_limit: usize,
-    pub nest_limit: u32,
-    pub case_insensitive: bool,
-    pub multi_line: bool,
-    pub dot_matches_new_line: bool,
-    pub swap_greed: bool,
-    pub ignore_whitespace: bool,
-    pub unicode: bool,
-    pub octal: bool,
-}
-
-impl Default for RegexOptions {
-    fn default() -> Self {
-        RegexOptions {
-            pats: vec![],
-            size_limit: 10 * (1 << 20),
-            dfa_size_limit: 2 * (1 << 20),
-            nest_limit: 250,
-            case_insensitive: false,
-            multi_line: false,
-            dot_matches_new_line: false,
-            swap_greed: false,
-            ignore_whitespace: false,
-            unicode: true,
-            octal: false,
-        }
-    }
-}
-
-macro_rules! define_builder {
-    ($name:ident, $regex_mod:ident, $only_utf8:expr) => {
-        pub mod $name {
-            use super::RegexOptions;
-            use crate::error::Error;
-            use crate::exec::ExecBuilder;
-
-            use crate::$regex_mod::Regex;
-
-            /// A configurable builder for a regular expression.
-            ///
-            /// A builder can be used to configure how the regex is built, for example, by
-            /// setting the default flags (which can be overridden in the expression
-            /// itself) or setting various limits.
-            #[derive(Debug)]
-            pub struct RegexBuilder(RegexOptions);
-
-            impl RegexBuilder {
-                /// Create a new regular expression builder with the given pattern.
-                ///
-                /// If the pattern is invalid, then an error will be returned when
-                /// `build` is called.
-                pub fn new(pattern: &str) -> RegexBuilder {
-                    let mut builder = RegexBuilder(RegexOptions::default());
-                    builder.0.pats.push(pattern.to_owned());
-                    builder
-                }
-
-                /// Consume the builder and compile the regular expression.
-                ///
-                /// Note that calling `as_str` on the resulting `Regex` will produce the
-                /// pattern given to `new` verbatim. Notably, it will not incorporate any
-                /// of the flags set on this builder.
-                pub fn build(&self) -> Result<Regex, Error> {
-                    ExecBuilder::new_options(self.0.clone())
-                        .only_utf8($only_utf8)
-                        .build()
-                        .map(Regex::from)
-                }
-
-                /// Set the value for the case insensitive (`i`) flag.
-                ///
-                /// When enabled, letters in the pattern will match both upper case and
-                /// lower case variants.
-                pub fn case_insensitive(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexBuilder {
-                    self.0.case_insensitive = yes;
-                    self
-                }
-
-                /// Set the value for the multi-line matching (`m`) flag.
-                ///
-                /// When enabled, `^` matches the beginning of lines and `$` matches the
-                /// end of lines.
-                ///
-                /// By default, they match beginning/end of the input.
-                pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
-                    self.0.multi_line = yes;
-                    self
-                }
-
-                /// Set the value for the any character (`s`) flag, where in `.` matches
-                /// anything when `s` is set and matches anything except for new line when
-                /// it is not set (the default).
-                ///
-                /// N.B. "matches anything" means "any byte" when Unicode is disabled and
-                /// means "any valid UTF-8 encoding of any Unicode scalar value" when
-                /// Unicode is enabled.
-                pub fn dot_matches_new_line(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexBuilder {
-                    self.0.dot_matches_new_line = yes;
-                    self
-                }
-
-                /// Set the value for the greedy swap (`U`) flag.
-                ///
-                /// When enabled, a pattern like `a*` is lazy (tries to find shortest
-                /// match) and `a*?` is greedy (tries to find longest match).
-                ///
-                /// By default, `a*` is greedy and `a*?` is lazy.
-                pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
-                    self.0.swap_greed = yes;
-                    self
-                }
-
-                /// Set the value for the ignore whitespace (`x`) flag.
-                ///
-                /// When enabled, whitespace such as new lines and spaces will be ignored
-                /// between expressions of the pattern, and `#` can be used to start a
-                /// comment until the next new line.
-                pub fn ignore_whitespace(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexBuilder {
-                    self.0.ignore_whitespace = yes;
-                    self
-                }
-
-                /// Set the value for the Unicode (`u`) flag.
-                ///
-                /// Enabled by default. When disabled, character classes such as `\w` only
-                /// match ASCII word characters instead of all Unicode word characters.
-                pub fn unicode(&mut self, yes: bool) -> &mut RegexBuilder {
-                    self.0.unicode = yes;
-                    self
-                }
-
-                /// Whether to support octal syntax or not.
-                ///
-                /// Octal syntax is a little-known way of uttering Unicode codepoints in
-                /// a regular expression. For example, `a`, `\x61`, `\u0061` and
-                /// `\141` are all equivalent regular expressions, where the last example
-                /// shows octal syntax.
-                ///
-                /// While supporting octal syntax isn't in and of itself a problem, it does
-                /// make good error messages harder. That is, in PCRE based regex engines,
-                /// syntax like `\0` invokes a backreference, which is explicitly
-                /// unsupported in Rust's regex engine. However, many users expect it to
-                /// be supported. Therefore, when octal support is disabled, the error
-                /// message will explicitly mention that backreferences aren't supported.
-                ///
-                /// Octal syntax is disabled by default.
-                pub fn octal(&mut self, yes: bool) -> &mut RegexBuilder {
-                    self.0.octal = yes;
-                    self
-                }
-
-                /// Set the approximate size limit of the compiled regular expression.
-                ///
-                /// This roughly corresponds to the number of bytes occupied by a single
-                /// compiled program. If the program exceeds this number, then a
-                /// compilation error is returned.
-                pub fn size_limit(
-                    &mut self,
-                    limit: usize,
-                ) -> &mut RegexBuilder {
-                    self.0.size_limit = limit;
-                    self
-                }
-
-                /// Set the approximate size of the cache used by the DFA.
-                ///
-                /// This roughly corresponds to the number of bytes that the DFA will
-                /// use while searching.
-                ///
-                /// Note that this is a *per thread* limit. There is no way to set a global
-                /// limit. In particular, if a regex is used from multiple threads
-                /// simultaneously, then each thread may use up to the number of bytes
-                /// specified here.
-                pub fn dfa_size_limit(
-                    &mut self,
-                    limit: usize,
-                ) -> &mut RegexBuilder {
-                    self.0.dfa_size_limit = limit;
-                    self
-                }
-
-                /// Set the nesting limit for this parser.
-                ///
-                /// The nesting limit controls how deep the abstract syntax tree is allowed
-                /// to be. If the AST exceeds the given limit (e.g., with too many nested
-                /// groups), then an error is returned by the parser.
-                ///
-                /// The purpose of this limit is to act as a heuristic to prevent stack
-                /// overflow for consumers that do structural induction on an `Ast` using
-                /// explicit recursion. While this crate never does this (instead using
-                /// constant stack space and moving the call stack to the heap), other
-                /// crates may.
-                ///
-                /// This limit is not checked until the entire Ast is parsed. Therefore,
-                /// if callers want to put a limit on the amount of heap space used, then
-                /// they should impose a limit on the length, in bytes, of the concrete
-                /// pattern string. In particular, this is viable since this parser
-                /// implementation will limit itself to heap space proportional to the
-                /// length of the pattern string.
-                ///
-                /// Note that a nest limit of `0` will return a nest limit error for most
-                /// patterns but not all. For example, a nest limit of `0` permits `a` but
-                /// not `ab`, since `ab` requires a concatenation, which results in a nest
-                /// depth of `1`. In general, a nest limit is not something that manifests
-                /// in an obvious way in the concrete syntax, therefore, it should not be
-                /// used in a granular way.
-                pub fn nest_limit(&mut self, limit: u32) -> &mut RegexBuilder {
-                    self.0.nest_limit = limit;
-                    self
-                }
-            }
-        }
-    };
-}
-
-define_builder!(bytes, re_bytes, false);
-define_builder!(unicode, re_unicode, true);
-
-macro_rules! define_set_builder {
-    ($name:ident, $regex_mod:ident, $only_utf8:expr) => {
-        pub mod $name {
-            use super::RegexOptions;
-            use crate::error::Error;
-            use crate::exec::ExecBuilder;
-
-            use crate::re_set::$regex_mod::RegexSet;
-
-            /// A configurable builder for a set of regular expressions.
-            ///
-            /// A builder can be used to configure how the regexes are built, for example,
-            /// by setting the default flags (which can be overridden in the expression
-            /// itself) or setting various limits.
-            #[derive(Debug)]
-            pub struct RegexSetBuilder(RegexOptions);
-
-            impl RegexSetBuilder {
-                /// Create a new regular expression builder with the given pattern.
-                ///
-                /// If the pattern is invalid, then an error will be returned when
-                /// `build` is called.
-                pub fn new<I, S>(patterns: I) -> RegexSetBuilder
-                where
-                    S: AsRef<str>,
-                    I: IntoIterator<Item = S>,
-                {
-                    let mut builder = RegexSetBuilder(RegexOptions::default());
-                    for pat in patterns {
-                        builder.0.pats.push(pat.as_ref().to_owned());
-                    }
-                    builder
-                }
-
-                /// Consume the builder and compile the regular expressions into a set.
-                pub fn build(&self) -> Result<RegexSet, Error> {
-                    ExecBuilder::new_options(self.0.clone())
-                        .only_utf8($only_utf8)
-                        .build()
-                        .map(RegexSet::from)
-                }
-
-                /// Set the value for the case insensitive (`i`) flag.
-                pub fn case_insensitive(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexSetBuilder {
-                    self.0.case_insensitive = yes;
-                    self
-                }
-
-                /// Set the value for the multi-line matching (`m`) flag.
-                pub fn multi_line(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexSetBuilder {
-                    self.0.multi_line = yes;
-                    self
-                }
-
-                /// Set the value for the any character (`s`) flag, where in `.` matches
-                /// anything when `s` is set and matches anything except for new line when
-                /// it is not set (the default).
-                ///
-                /// N.B. "matches anything" means "any byte" for `regex::bytes::RegexSet`
-                /// expressions and means "any Unicode scalar value" for `regex::RegexSet`
-                /// expressions.
-                pub fn dot_matches_new_line(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexSetBuilder {
-                    self.0.dot_matches_new_line = yes;
-                    self
-                }
-
-                /// Set the value for the greedy swap (`U`) flag.
-                pub fn swap_greed(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexSetBuilder {
-                    self.0.swap_greed = yes;
-                    self
-                }
-
-                /// Set the value for the ignore whitespace (`x`) flag.
-                pub fn ignore_whitespace(
-                    &mut self,
-                    yes: bool,
-                ) -> &mut RegexSetBuilder {
-                    self.0.ignore_whitespace = yes;
-                    self
-                }
-
-                /// Set the value for the Unicode (`u`) flag.
-                pub fn unicode(&mut self, yes: bool) -> &mut RegexSetBuilder {
-                    self.0.unicode = yes;
-                    self
-                }
-
-                /// Whether to support octal syntax or not.
-                ///
-                /// Octal syntax is a little-known way of uttering Unicode codepoints in
-                /// a regular expression. For example, `a`, `\x61`, `\u0061` and
-                /// `\141` are all equivalent regular expressions, where the last example
-                /// shows octal syntax.
-                ///
-                /// While supporting octal syntax isn't in and of itself a problem, it does
-                /// make good error messages harder. That is, in PCRE based regex engines,
-                /// syntax like `\0` invokes a backreference, which is explicitly
-                /// unsupported in Rust's regex engine. However, many users expect it to
-                /// be supported. Therefore, when octal support is disabled, the error
-                /// message will explicitly mention that backreferences aren't supported.
-                ///
-                /// Octal syntax is disabled by default.
-                pub fn octal(&mut self, yes: bool) -> &mut RegexSetBuilder {
-                    self.0.octal = yes;
-                    self
-                }
-
-                /// Set the approximate size limit of the compiled regular expression.
-                ///
-                /// This roughly corresponds to the number of bytes occupied by a single
-                /// compiled program. If the program exceeds this number, then a
-                /// compilation error is returned.
-                pub fn size_limit(
-                    &mut self,
-                    limit: usize,
-                ) -> &mut RegexSetBuilder {
-                    self.0.size_limit = limit;
-                    self
-                }
-
-                /// Set the approximate size of the cache used by the DFA.
-                ///
-                /// This roughly corresponds to the number of bytes that the DFA will
-                /// use while searching.
-                ///
-                /// Note that this is a *per thread* limit. There is no way to set a global
-                /// limit. In particular, if a regex is used from multiple threads
-                /// simultaneously, then each thread may use up to the number of bytes
-                /// specified here.
-                pub fn dfa_size_limit(
-                    &mut self,
-                    limit: usize,
-                ) -> &mut RegexSetBuilder {
-                    self.0.dfa_size_limit = limit;
-                    self
-                }
-
-                /// Set the nesting limit for this parser.
-                ///
-                /// The nesting limit controls how deep the abstract syntax tree is allowed
-                /// to be. If the AST exceeds the given limit (e.g., with too many nested
-                /// groups), then an error is returned by the parser.
-                ///
-                /// The purpose of this limit is to act as a heuristic to prevent stack
-                /// overflow for consumers that do structural induction on an `Ast` using
-                /// explicit recursion. While this crate never does this (instead using
-                /// constant stack space and moving the call stack to the heap), other
-                /// crates may.
-                ///
-                /// This limit is not checked until the entire Ast is parsed. Therefore,
-                /// if callers want to put a limit on the amount of heap space used, then
-                /// they should impose a limit on the length, in bytes, of the concrete
-                /// pattern string. In particular, this is viable since this parser
-                /// implementation will limit itself to heap space proportional to the
-                /// length of the pattern string.
-                ///
-                /// Note that a nest limit of `0` will return a nest limit error for most
-                /// patterns but not all. For example, a nest limit of `0` permits `a` but
-                /// not `ab`, since `ab` requires a concatenation, which results in a nest
-                /// depth of `1`. In general, a nest limit is not something that manifests
-                /// in an obvious way in the concrete syntax, therefore, it should not be
-                /// used in a granular way.
-                pub fn nest_limit(
-                    &mut self,
-                    limit: u32,
-                ) -> &mut RegexSetBuilder {
-                    self.0.nest_limit = limit;
-                    self
-                }
-            }
-        }
-    };
-}
-
-define_set_builder!(set_bytes, bytes, false);
-define_set_builder!(set_unicode, unicode, true);
diff --git a/src/re_bytes.rs b/src/re_bytes.rs
deleted file mode 100644
index e3a3b019b5..0000000000
--- a/src/re_bytes.rs
+++ /dev/null
@@ -1,1372 +0,0 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fmt;
-use std::iter::FusedIterator;
-use std::ops::{Index, Range};
-use std::str::FromStr;
-use std::sync::Arc;
-
-use crate::find_byte::find_byte;
-
-use crate::error::Error;
-use crate::exec::{Exec, ExecNoSync};
-use crate::expand::expand_bytes;
-use crate::re_builder::bytes::RegexBuilder;
-use crate::re_trait::{self, RegularExpression, SubCapturesPosIter};
-
-/// Match represents a single match of a regex in a haystack.
-///
-/// The lifetime parameter `'t` refers to the lifetime of the matched text.
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Match<'t> {
-    text: &'t [u8],
-    start: usize,
-    end: usize,
-}
-
-impl<'t> Match<'t> {
-    /// Returns the starting byte offset of the match in the haystack.
-    #[inline]
-    pub fn start(&self) -> usize {
-        self.start
-    }
-
-    /// Returns the ending byte offset of the match in the haystack.
-    #[inline]
-    pub fn end(&self) -> usize {
-        self.end
-    }
-
-    /// Returns true if and only if this match has a length of zero.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.start == self.end
-    }
-
-    /// Returns the length, in bytes, of this match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.end - self.start
-    }
-
-    /// Returns the range over the starting and ending byte offsets of the
-    /// match in the haystack.
-    #[inline]
-    pub fn range(&self) -> Range<usize> {
-        self.start..self.end
-    }
-
-    /// Returns the matched text.
-    #[inline]
-    pub fn as_bytes(&self) -> &'t [u8] {
-        &self.text[self.range()]
-    }
-
-    /// Creates a new match from the given haystack and byte offsets.
-    #[inline]
-    fn new(haystack: &'t [u8], start: usize, end: usize) -> Match<'t> {
-        Match { text: haystack, start, end }
-    }
-}
-
-impl<'t> std::fmt::Debug for Match<'t> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let mut fmt = f.debug_struct("Match");
-        fmt.field("start", &self.start).field("end", &self.end);
-        if let Ok(s) = std::str::from_utf8(self.as_bytes()) {
-            fmt.field("bytes", &s);
-        } else {
-            // FIXME: It would be nice if this could be printed as a string
-            // with invalid UTF-8 replaced with hex escapes. A alloc would
-            // probably okay if that makes it easier, but regex-automata does
-            // (at time of writing) have internal routines that do this. So
-            // maybe we should expose them.
-            fmt.field("bytes", &self.as_bytes());
-        }
-        fmt.finish()
-    }
-}
-
-impl<'t> From<Match<'t>> for Range<usize> {
-    fn from(m: Match<'t>) -> Range<usize> {
-        m.range()
-    }
-}
-
-/// A compiled regular expression for matching arbitrary bytes.
-///
-/// It can be used to search, split or replace text. All searching is done with
-/// an implicit `.*?` at the beginning and end of an expression. To force an
-/// expression to match the whole string (or a prefix or a suffix), you must
-/// use an anchor like `^` or `$` (or `\A` and `\z`).
-///
-/// Like the `Regex` type in the parent module, matches with this regex return
-/// byte offsets into the search text. **Unlike** the parent `Regex` type,
-/// these byte offsets may not correspond to UTF-8 sequence boundaries since
-/// the regexes in this module can match arbitrary bytes.
-#[derive(Clone)]
-pub struct Regex(Exec);
-
-impl fmt::Display for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl fmt::Debug for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-/// A constructor for Regex from an Exec.
-///
-/// This is hidden because Exec isn't actually part of the public API.
-#[doc(hidden)]
-impl From<Exec> for Regex {
-    fn from(exec: Exec) -> Regex {
-        Regex(exec)
-    }
-}
-
-impl FromStr for Regex {
-    type Err = Error;
-
-    /// Attempts to parse a string into a regular expression
-    fn from_str(s: &str) -> Result<Regex, Error> {
-        Regex::new(s)
-    }
-}
-
-/// Core regular expression methods.
-impl Regex {
-    /// Compiles a regular expression. Once compiled, it can be used repeatedly
-    /// to search, split or replace text in a string.
-    ///
-    /// If an invalid expression is given, then an error is returned.
-    pub fn new(re: &str) -> Result<Regex, Error> {
-        RegexBuilder::new(re).build()
-    }
-
-    /// Returns true if and only if there is a match for the regex in the
-    /// string given.
-    ///
-    /// It is recommended to use this method if all you need to do is test
-    /// a match, since the underlying matching engine may be able to do less
-    /// work.
-    ///
-    /// # Example
-    ///
-    /// Test if some text contains at least one word with exactly 13 ASCII word
-    /// bytes:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let text = b"I categorically deny having triskaidekaphobia.";
-    /// assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));
-    /// # }
-    /// ```
-    pub fn is_match(&self, text: &[u8]) -> bool {
-        self.is_match_at(text, 0)
-    }
-
-    /// Returns the start and end byte range of the leftmost-first match in
-    /// `text`. If no match exists, then `None` is returned.
-    ///
-    /// Note that this should only be used if you want to discover the position
-    /// of the match. Testing the existence of a match is faster if you use
-    /// `is_match`.
-    ///
-    /// # Example
-    ///
-    /// Find the start and end location of the first word with exactly 13
-    /// ASCII word bytes:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let text = b"I categorically deny having triskaidekaphobia.";
-    /// let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
-    /// assert_eq!((mat.start(), mat.end()), (2, 15));
-    /// # }
-    /// ```
-    pub fn find<'t>(&self, text: &'t [u8]) -> Option<Match<'t>> {
-        self.find_at(text, 0)
-    }
-
-    /// Returns an iterator for each successive non-overlapping match in
-    /// `text`, returning the start and end byte indices with respect to
-    /// `text`.
-    ///
-    /// # Example
-    ///
-    /// Find the start and end location of every word with exactly 13 ASCII
-    /// word bytes:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let text = b"Retroactively relinquishing remunerations is reprehensible.";
-    /// for mat in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) {
-    ///     println!("{:?}", mat);
-    /// }
-    /// # }
-    /// ```
-    pub fn find_iter<'r, 't>(&'r self, text: &'t [u8]) -> Matches<'r, 't> {
-        Matches(self.0.searcher().find_iter(text))
-    }
-
-    /// Returns the capture groups corresponding to the leftmost-first
-    /// match in `text`. Capture group `0` always corresponds to the entire
-    /// match. If no match is found, then `None` is returned.
-    ///
-    /// You should only use `captures` if you need access to the location of
-    /// capturing group matches. Otherwise, `find` is faster for discovering
-    /// the location of the overall match.
-    ///
-    /// # Examples
-    ///
-    /// Say you have some text with movie names and their release years,
-    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for text
-    /// looking like that, while also extracting the movie name and its release
-    /// year separately.
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
-    /// let text = b"Not my favorite movie: 'Citizen Kane' (1941).";
-    /// let caps = re.captures(text).unwrap();
-    /// assert_eq!(caps.get(1).unwrap().as_bytes(), &b"Citizen Kane"[..]);
-    /// assert_eq!(caps.get(2).unwrap().as_bytes(), &b"1941"[..]);
-    /// assert_eq!(caps.get(0).unwrap().as_bytes(), &b"'Citizen Kane' (1941)"[..]);
-    /// // You can also access the groups by index using the Index notation.
-    /// // Note that this will panic on an invalid index.
-    /// assert_eq!(&caps[1], b"Citizen Kane");
-    /// assert_eq!(&caps[2], b"1941");
-    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
-    /// # }
-    /// ```
-    ///
-    /// Note that the full match is at capture group `0`. Each subsequent
-    /// capture group is indexed by the order of its opening `(`.
-    ///
-    /// We can make this example a bit clearer by using *named* capture groups:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
-    ///                .unwrap();
-    /// let text = b"Not my favorite movie: 'Citizen Kane' (1941).";
-    /// let caps = re.captures(text).unwrap();
-    /// assert_eq!(caps.name("title").unwrap().as_bytes(), b"Citizen Kane");
-    /// assert_eq!(caps.name("year").unwrap().as_bytes(), b"1941");
-    /// assert_eq!(caps.get(0).unwrap().as_bytes(), &b"'Citizen Kane' (1941)"[..]);
-    /// // You can also access the groups by name using the Index notation.
-    /// // Note that this will panic on an invalid group name.
-    /// assert_eq!(&caps["title"], b"Citizen Kane");
-    /// assert_eq!(&caps["year"], b"1941");
-    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
-    ///
-    /// # }
-    /// ```
-    ///
-    /// Here we name the capture groups, which we can access with the `name`
-    /// method or the `Index` notation with a `&str`. Note that the named
-    /// capture groups are still accessible with `get` or the `Index` notation
-    /// with a `usize`.
-    ///
-    /// The `0`th capture group is always unnamed, so it must always be
-    /// accessed with `get(0)` or `[0]`.
-    pub fn captures<'t>(&self, text: &'t [u8]) -> Option<Captures<'t>> {
-        self.captures_at(text, 0)
-    }
-
-    /// Returns an iterator over all the non-overlapping capture groups matched
-    /// in `text`. This is operationally the same as `find_iter`, except it
-    /// yields information about capturing group matches.
-    ///
-    /// # Example
-    ///
-    /// We can use this to find all movie titles and their release years in
-    /// some text, where the movie is formatted like "'Title' (xxxx)":
-    ///
-    /// ```rust
-    /// # use std::str; use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
-    ///                .unwrap();
-    /// let text = b"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
-    /// for caps in re.captures_iter(text) {
-    ///     let title = str::from_utf8(&caps["title"]).unwrap();
-    ///     let year = str::from_utf8(&caps["year"]).unwrap();
-    ///     println!("Movie: {:?}, Released: {:?}", title, year);
-    /// }
-    /// // Output:
-    /// // Movie: Citizen Kane, Released: 1941
-    /// // Movie: The Wizard of Oz, Released: 1939
-    /// // Movie: M, Released: 1931
-    /// # }
-    /// ```
-    pub fn captures_iter<'r, 't>(
-        &'r self,
-        text: &'t [u8],
-    ) -> CaptureMatches<'r, 't> {
-        CaptureMatches(self.0.searcher().captures_iter(text))
-    }
-
-    /// Returns an iterator of substrings of `text` delimited by a match of the
-    /// regular expression. Namely, each element of the iterator corresponds to
-    /// text that *isn't* matched by the regular expression.
-    ///
-    /// This method will *not* copy the text given.
-    ///
-    /// # Example
-    ///
-    /// To split a string delimited by arbitrary amounts of spaces or tabs:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"[ \t]+").unwrap();
-    /// let fields: Vec<&[u8]> = re.split(b"a b \t  c\td    e").collect();
-    /// assert_eq!(fields, vec![
-    ///     &b"a"[..], &b"b"[..], &b"c"[..], &b"d"[..], &b"e"[..],
-    /// ]);
-    /// # }
-    /// ```
-    pub fn split<'r, 't>(&'r self, text: &'t [u8]) -> Split<'r, 't> {
-        Split { finder: self.find_iter(text), last: 0 }
-    }
-
-    /// Returns an iterator of at most `limit` substrings of `text` delimited
-    /// by a match of the regular expression. (A `limit` of `0` will return no
-    /// substrings.) Namely, each element of the iterator corresponds to text
-    /// that *isn't* matched by the regular expression. The remainder of the
-    /// string that is not split will be the last element in the iterator.
-    ///
-    /// This method will *not* copy the text given.
-    ///
-    /// # Example
-    ///
-    /// Get the first two words in some text:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"\W+").unwrap();
-    /// let fields: Vec<&[u8]> = re.splitn(b"Hey! How are you?", 3).collect();
-    /// assert_eq!(fields, vec![&b"Hey"[..], &b"How"[..], &b"are you?"[..]]);
-    /// # }
-    /// ```
-    pub fn splitn<'r, 't>(
-        &'r self,
-        text: &'t [u8],
-        limit: usize,
-    ) -> SplitN<'r, 't> {
-        SplitN { splits: self.split(text), n: limit }
-    }
-
-    /// Replaces the leftmost-first match with the replacement provided. The
-    /// replacement can be a regular byte string (where `$N` and `$name` are
-    /// expanded to match capture groups) or a function that takes the matches'
-    /// `Captures` and returns the replaced byte string.
-    ///
-    /// If no match is found, then a copy of the byte string is returned
-    /// unchanged.
-    ///
-    /// # Replacement string syntax
-    ///
-    /// All instances of `$name` in the replacement text is replaced with the
-    /// corresponding capture group `name`.
-    ///
-    /// `name` may be an integer corresponding to the index of the
-    /// capture group (counted by order of opening parenthesis where `0` is the
-    /// entire match) or it can be a name (consisting of letters, digits or
-    /// underscores) corresponding to a named capture group.
-    ///
-    /// If `name` isn't a valid capture group (whether the name doesn't exist
-    /// or isn't a valid index), then it is replaced with the empty string.
-    ///
-    /// The longest possible name is used. e.g., `$1a` looks up the capture
-    /// group named `1a` and not the capture group at index `1`. To exert more
-    /// precise control over the name, use braces, e.g., `${1}a`.
-    ///
-    /// To write a literal `$` use `$$`.
-    ///
-    /// # Examples
-    ///
-    /// Note that this function is polymorphic with respect to the replacement.
-    /// In typical usage, this can just be a normal byte string:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new("[^01]+").unwrap();
-    /// assert_eq!(re.replace(b"1078910", &b""[..]), &b"1010"[..]);
-    /// # }
-    /// ```
-    ///
-    /// But anything satisfying the `Replacer` trait will work. For example, a
-    /// closure of type `|&Captures| -> Vec<u8>` provides direct access to the
-    /// captures corresponding to a match. This allows one to access capturing
-    /// group matches easily:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # use regex::bytes::Captures; fn main() {
-    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
-    /// let result = re.replace(b"Springsteen, Bruce", |caps: &Captures| {
-    ///     let mut replacement = caps[2].to_owned();
-    ///     replacement.push(b' ');
-    ///     replacement.extend(&caps[1]);
-    ///     replacement
-    /// });
-    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
-    /// # }
-    /// ```
-    ///
-    /// But this is a bit cumbersome to use all the time. Instead, a simple
-    /// syntax is supported that expands `$name` into the corresponding capture
-    /// group. Here's the last example, but using this expansion technique
-    /// with named capture groups:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(?P<first>\S+)").unwrap();
-    /// let result = re.replace(b"Springsteen, Bruce", &b"$first $last"[..]);
-    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
-    /// # }
-    /// ```
-    ///
-    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
-    /// would produce the same result. To write a literal `$` use `$$`.
-    ///
-    /// Sometimes the replacement string requires use of curly braces to
-    /// delineate a capture group replacement and surrounding literal text.
-    /// For example, if we wanted to join two words together with an
-    /// underscore:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"(?P<first>\w+)\s+(?P<second>\w+)").unwrap();
-    /// let result = re.replace(b"deep fried", &b"${first}_$second"[..]);
-    /// assert_eq!(result, &b"deep_fried"[..]);
-    /// # }
-    /// ```
-    ///
-    /// Without the curly braces, the capture group name `first_` would be
-    /// used, and since it doesn't exist, it would be replaced with the empty
-    /// string.
-    ///
-    /// Finally, sometimes you just want to replace a literal string with no
-    /// regard for capturing group expansion. This can be done by wrapping a
-    /// byte string with `NoExpand`:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// use regex::bytes::NoExpand;
-    ///
-    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(\S+)").unwrap();
-    /// let result = re.replace(b"Springsteen, Bruce", NoExpand(b"$2 $last"));
-    /// assert_eq!(result, &b"$2 $last"[..]);
-    /// # }
-    /// ```
-    pub fn replace<'t, R: Replacer>(
-        &self,
-        text: &'t [u8],
-        rep: R,
-    ) -> Cow<'t, [u8]> {
-        self.replacen(text, 1, rep)
-    }
-
-    /// Replaces all non-overlapping matches in `text` with the replacement
-    /// provided. This is the same as calling `replacen` with `limit` set to
-    /// `0`.
-    ///
-    /// See the documentation for `replace` for details on how to access
-    /// capturing group matches in the replacement text.
-    pub fn replace_all<'t, R: Replacer>(
-        &self,
-        text: &'t [u8],
-        rep: R,
-    ) -> Cow<'t, [u8]> {
-        self.replacen(text, 0, rep)
-    }
-
-    /// Replaces at most `limit` non-overlapping matches in `text` with the
-    /// replacement provided. If `limit` is 0, then all non-overlapping matches
-    /// are replaced.
-    ///
-    /// See the documentation for `replace` for details on how to access
-    /// capturing group matches in the replacement text.
-    pub fn replacen<'t, R: Replacer>(
-        &self,
-        text: &'t [u8],
-        limit: usize,
-        mut rep: R,
-    ) -> Cow<'t, [u8]> {
-        if let Some(rep) = rep.no_expansion() {
-            let mut it = self.find_iter(text).enumerate().peekable();
-            if it.peek().is_none() {
-                return Cow::Borrowed(text);
-            }
-            let mut new = Vec::with_capacity(text.len());
-            let mut last_match = 0;
-            for (i, m) in it {
-                new.extend_from_slice(&text[last_match..m.start()]);
-                new.extend_from_slice(&rep);
-                last_match = m.end();
-                if limit > 0 && i >= limit - 1 {
-                    break;
-                }
-            }
-            new.extend_from_slice(&text[last_match..]);
-            return Cow::Owned(new);
-        }
-
-        // The slower path, which we use if the replacement needs access to
-        // capture groups.
-        let mut it = self.captures_iter(text).enumerate().peekable();
-        if it.peek().is_none() {
-            return Cow::Borrowed(text);
-        }
-        let mut new = Vec::with_capacity(text.len());
-        let mut last_match = 0;
-        for (i, cap) in it {
-            // unwrap on 0 is OK because captures only reports matches
-            let m = cap.get(0).unwrap();
-            new.extend_from_slice(&text[last_match..m.start()]);
-            rep.replace_append(&cap, &mut new);
-            last_match = m.end();
-            if limit > 0 && i >= limit - 1 {
-                break;
-            }
-        }
-        new.extend_from_slice(&text[last_match..]);
-        Cow::Owned(new)
-    }
-}
-
-/// Advanced or "lower level" search methods.
-impl Regex {
-    /// Returns the end location of a match in the text given.
-    ///
-    /// This method may have the same performance characteristics as
-    /// `is_match`, except it provides an end location for a match. In
-    /// particular, the location returned *may be shorter* than the proper end
-    /// of the leftmost-first match that you would find via `Regex::find`.
-    ///
-    /// Note that it is not guaranteed that this routine finds the shortest or
-    /// "earliest" possible match. Instead, the main idea of this API is that
-    /// it returns the offset at the point at which the internal regex engine
-    /// has determined that a match has occurred. This may vary depending on
-    /// which internal regex engine is used, and thus, the offset itself may
-    /// change.
-    ///
-    /// # Example
-    ///
-    /// Typically, `a+` would match the entire first sequence of `a` in some
-    /// text, but `shortest_match` can give up as soon as it sees the first
-    /// `a`.
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// # fn main() {
-    /// let text = b"aaaaa";
-    /// let pos = Regex::new(r"a+").unwrap().shortest_match(text);
-    /// assert_eq!(pos, Some(1));
-    /// # }
-    /// ```
-    pub fn shortest_match(&self, text: &[u8]) -> Option<usize> {
-        self.shortest_match_at(text, 0)
-    }
-
-    /// Returns the same as shortest_match, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn shortest_match_at(
-        &self,
-        text: &[u8],
-        start: usize,
-    ) -> Option<usize> {
-        self.0.searcher().shortest_match_at(text, start)
-    }
-
-    /// Returns the same as is_match, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn is_match_at(&self, text: &[u8], start: usize) -> bool {
-        self.0.searcher().is_match_at(text, start)
-    }
-
-    /// Returns the same as find, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn find_at<'t>(
-        &self,
-        text: &'t [u8],
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.0
-            .searcher()
-            .find_at(text, start)
-            .map(|(s, e)| Match::new(text, s, e))
-    }
-
-    /// Returns the same as [`Regex::captures`], but starts the search at the
-    /// given offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn captures_at<'t>(
-        &self,
-        text: &'t [u8],
-        start: usize,
-    ) -> Option<Captures<'t>> {
-        let mut locs = self.capture_locations();
-        self.captures_read_at(&mut locs, text, start).map(move |_| Captures {
-            text,
-            locs: locs.0,
-            named_groups: self.0.capture_name_idx().clone(),
-        })
-    }
-
-    /// This is like `captures`, but uses
-    /// [`CaptureLocations`](struct.CaptureLocations.html)
-    /// instead of
-    /// [`Captures`](struct.Captures.html) in order to amortize allocations.
-    ///
-    /// To create a `CaptureLocations` value, use the
-    /// `Regex::capture_locations` method.
-    ///
-    /// This returns the overall match if this was successful, which is always
-    /// equivalence to the `0`th capture group.
-    pub fn captures_read<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t [u8],
-    ) -> Option<Match<'t>> {
-        self.captures_read_at(locs, text, 0)
-    }
-
-    /// Returns the same as `captures_read`, but starts the search at the given
-    /// offset and populates the capture locations given.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn captures_read_at<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t [u8],
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.0
-            .searcher()
-            .captures_read_at(&mut locs.0, text, start)
-            .map(|(s, e)| Match::new(text, s, e))
-    }
-
-    /// An undocumented alias for `captures_read_at`.
-    ///
-    /// The `regex-capi` crate previously used this routine, so to avoid
-    /// breaking that crate, we continue to provide the name as an undocumented
-    /// alias.
-    #[doc(hidden)]
-    pub fn read_captures_at<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t [u8],
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.captures_read_at(locs, text, start)
-    }
-}
-
-/// Auxiliary methods.
-impl Regex {
-    /// Returns the original string of this regex.
-    pub fn as_str(&self) -> &str {
-        &self.0.regex_strings()[0]
-    }
-
-    /// Returns an iterator over the capture names.
-    pub fn capture_names(&self) -> CaptureNames<'_> {
-        CaptureNames(self.0.capture_names().iter())
-    }
-
-    /// Returns the number of captures.
-    pub fn captures_len(&self) -> usize {
-        self.0.capture_names().len()
-    }
-
-    /// Returns the total number of capturing groups that appear in every
-    /// possible match.
-    ///
-    /// If the number of capture groups can vary depending on the match, then
-    /// this returns `None`. That is, a value is only returned when the number
-    /// of matching groups is invariant or "static."
-    ///
-    /// Note that like [`Regex::captures_len`], this **does** include the
-    /// implicit capturing group corresponding to the entire match. Therefore,
-    /// when a non-None value is returned, it is guaranteed to be at least `1`.
-    /// Stated differently, a return value of `Some(0)` is impossible.
-    ///
-    /// # Example
-    ///
-    /// This shows a few cases where a static number of capture groups is
-    /// available and a few cases where it is not.
-    ///
-    /// ```
-    /// use regex::bytes::Regex;
-    ///
-    /// let len = |pattern| {
-    ///     Regex::new(pattern).map(|re| re.static_captures_len())
-    /// };
-    ///
-    /// assert_eq!(Some(1), len("a")?);
-    /// assert_eq!(Some(2), len("(a)")?);
-    /// assert_eq!(Some(2), len("(a)|(b)")?);
-    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
-    /// assert_eq!(None, len("(a)|b")?);
-    /// assert_eq!(None, len("a|(b)")?);
-    /// assert_eq!(None, len("(b)*")?);
-    /// assert_eq!(Some(2), len("(b)+")?);
-    ///
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
-    /// ```
-    #[inline]
-    pub fn static_captures_len(&self) -> Option<usize> {
-        self.0.static_captures_len().map(|len| len.saturating_add(1))
-    }
-
-    /// Returns an empty set of capture locations that can be reused in
-    /// multiple calls to `captures_read` or `captures_read_at`.
-    pub fn capture_locations(&self) -> CaptureLocations {
-        CaptureLocations(self.0.searcher().locations())
-    }
-
-    /// An alias for `capture_locations` to preserve backward compatibility.
-    ///
-    /// The `regex-capi` crate uses this method, so to avoid breaking that
-    /// crate, we continue to export it as an undocumented API.
-    #[doc(hidden)]
-    pub fn locations(&self) -> CaptureLocations {
-        CaptureLocations(self.0.searcher().locations())
-    }
-}
-
-/// An iterator over all non-overlapping matches for a particular string.
-///
-/// The iterator yields a tuple of integers corresponding to the start and end
-/// of the match. The indices are byte offsets. The iterator stops when no more
-/// matches can be found.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the matched byte string.
-#[derive(Debug)]
-pub struct Matches<'r, 't>(re_trait::Matches<'t, ExecNoSync<'r>>);
-
-impl<'r, 't> Iterator for Matches<'r, 't> {
-    type Item = Match<'t>;
-
-    fn next(&mut self) -> Option<Match<'t>> {
-        let text = self.0.text();
-        self.0.next().map(|(s, e)| Match::new(text, s, e))
-    }
-}
-
-impl<'r, 't> FusedIterator for Matches<'r, 't> {}
-
-/// An iterator that yields all non-overlapping capture groups matching a
-/// particular regular expression.
-///
-/// The iterator stops when no more matches can be found.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the matched byte string.
-#[derive(Debug)]
-pub struct CaptureMatches<'r, 't>(
-    re_trait::CaptureMatches<'t, ExecNoSync<'r>>,
-);
-
-impl<'r, 't> Iterator for CaptureMatches<'r, 't> {
-    type Item = Captures<'t>;
-
-    fn next(&mut self) -> Option<Captures<'t>> {
-        self.0.next().map(|locs| Captures {
-            text: self.0.text(),
-            locs,
-            named_groups: self.0.regex().capture_name_idx().clone(),
-        })
-    }
-}
-
-impl<'r, 't> FusedIterator for CaptureMatches<'r, 't> {}
-
-/// Yields all substrings delimited by a regular expression match.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the byte string being split.
-#[derive(Debug)]
-pub struct Split<'r, 't> {
-    finder: Matches<'r, 't>,
-    last: usize,
-}
-
-impl<'r, 't> Iterator for Split<'r, 't> {
-    type Item = &'t [u8];
-
-    fn next(&mut self) -> Option<&'t [u8]> {
-        let text = self.finder.0.text();
-        match self.finder.next() {
-            None => {
-                if self.last > text.len() {
-                    None
-                } else {
-                    let s = &text[self.last..];
-                    self.last = text.len() + 1; // Next call will return None
-                    Some(s)
-                }
-            }
-            Some(m) => {
-                let matched = &text[self.last..m.start()];
-                self.last = m.end();
-                Some(matched)
-            }
-        }
-    }
-}
-
-impl<'r, 't> FusedIterator for Split<'r, 't> {}
-
-/// Yields at most `N` substrings delimited by a regular expression match.
-///
-/// The last substring will be whatever remains after splitting.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the byte string being split.
-#[derive(Debug)]
-pub struct SplitN<'r, 't> {
-    splits: Split<'r, 't>,
-    n: usize,
-}
-
-impl<'r, 't> Iterator for SplitN<'r, 't> {
-    type Item = &'t [u8];
-
-    fn next(&mut self) -> Option<&'t [u8]> {
-        if self.n == 0 {
-            return None;
-        }
-
-        self.n -= 1;
-        if self.n > 0 {
-            return self.splits.next();
-        }
-
-        let text = self.splits.finder.0.text();
-        if self.splits.last > text.len() {
-            // We've already returned all substrings.
-            None
-        } else {
-            // self.n == 0, so future calls will return None immediately
-            Some(&text[self.splits.last..])
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.n))
-    }
-}
-
-impl<'r, 't> FusedIterator for SplitN<'r, 't> {}
-
-/// An iterator over the names of all possible captures.
-///
-/// `None` indicates an unnamed capture; the first element (capture 0, the
-/// whole matched region) is always unnamed.
-///
-/// `'r` is the lifetime of the compiled regular expression.
-#[derive(Clone, Debug)]
-pub struct CaptureNames<'r>(::std::slice::Iter<'r, Option<String>>);
-
-impl<'r> Iterator for CaptureNames<'r> {
-    type Item = Option<&'r str>;
-
-    fn next(&mut self) -> Option<Option<&'r str>> {
-        self.0
-            .next()
-            .as_ref()
-            .map(|slot| slot.as_ref().map(|name| name.as_ref()))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-
-    fn count(self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<'r> ExactSizeIterator for CaptureNames<'r> {}
-
-impl<'r> FusedIterator for CaptureNames<'r> {}
-
-/// CaptureLocations is a low level representation of the raw offsets of each
-/// submatch.
-///
-/// You can think of this as a lower level
-/// [`Captures`](struct.Captures.html), where this type does not support
-/// named capturing groups directly and it does not borrow the text that these
-/// offsets were matched on.
-///
-/// Primarily, this type is useful when using the lower level `Regex` APIs
-/// such as `read_captures`, which permits amortizing the allocation in which
-/// capture match locations are stored.
-///
-/// In order to build a value of this type, you'll need to call the
-/// `capture_locations` method on the `Regex` being used to execute the search.
-/// The value returned can then be reused in subsequent searches.
-///
-/// # Example
-///
-/// This example shows how to create and use `CaptureLocations` in a search.
-///
-/// ```
-/// use regex::bytes::Regex;
-///
-/// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
-/// let mut locs = re.capture_locations();
-/// let m = re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();
-/// assert_eq!(0..17, m.range());
-/// assert_eq!(Some((0, 17)), locs.get(0));
-/// assert_eq!(Some((0, 5)), locs.get(1));
-/// assert_eq!(Some((6, 17)), locs.get(2));
-///
-/// // Asking for an invalid capture group always returns None.
-/// assert_eq!(None, locs.get(3));
-/// assert_eq!(None, locs.get(34973498648));
-/// assert_eq!(None, locs.get(9944060567225171988));
-/// ```
-#[derive(Clone, Debug)]
-pub struct CaptureLocations(re_trait::Locations);
-
-/// A type alias for `CaptureLocations` for backwards compatibility.
-///
-/// Previously, we exported `CaptureLocations` as `Locations` in an
-/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
-/// we continue re-exporting the same undocumented API.
-#[doc(hidden)]
-pub type Locations = CaptureLocations;
-
-impl CaptureLocations {
-    /// Returns the start and end positions of the Nth capture group. Returns
-    /// `None` if `i` is not a valid capture group or if the capture group did
-    /// not match anything. The positions returned are *always* byte indices
-    /// with respect to the original string matched.
-    #[inline]
-    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
-        self.0.pos(i)
-    }
-
-    /// Returns the total number of capture groups (even if they didn't match).
-    ///
-    /// This is always at least `1` since every regex has at least `1`
-    /// capturing group that corresponds to the entire match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    /// An alias for the `get` method for backwards compatibility.
-    ///
-    /// Previously, we exported `get` as `pos` in an undocumented API. To
-    /// prevent breaking that code (e.g., in `regex-capi`), we continue
-    /// re-exporting the same undocumented API.
-    #[doc(hidden)]
-    #[inline]
-    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
-        self.get(i)
-    }
-}
-
-/// Captures represents a group of captured byte strings for a single match.
-///
-/// The 0th capture always corresponds to the entire match. Each subsequent
-/// index corresponds to the next capture group in the regex. If a capture
-/// group is named, then the matched byte string is *also* available via the
-/// `name` method. (Note that the 0th capture is always unnamed and so must be
-/// accessed with the `get` method.)
-///
-/// Positions returned from a capture group are always byte indices.
-///
-/// `'t` is the lifetime of the matched text.
-pub struct Captures<'t> {
-    text: &'t [u8],
-    locs: re_trait::Locations,
-    named_groups: Arc<HashMap<String, usize>>,
-}
-
-impl<'t> Captures<'t> {
-    /// Returns the match associated with the capture group at index `i`. If
-    /// `i` does not correspond to a capture group, or if the capture group
-    /// did not participate in the match, then `None` is returned.
-    ///
-    /// # Examples
-    ///
-    /// Get the text of the match with a default of an empty string if this
-    /// group didn't participate in the match:
-    ///
-    /// ```rust
-    /// # use regex::bytes::Regex;
-    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
-    /// let caps = re.captures(b"abc123").unwrap();
-    ///
-    /// let text1 = caps.get(1).map_or(&b""[..], |m| m.as_bytes());
-    /// let text2 = caps.get(2).map_or(&b""[..], |m| m.as_bytes());
-    /// assert_eq!(text1, &b"123"[..]);
-    /// assert_eq!(text2, &b""[..]);
-    /// ```
-    pub fn get(&self, i: usize) -> Option<Match<'t>> {
-        self.locs.pos(i).map(|(s, e)| Match::new(self.text, s, e))
-    }
-
-    /// Returns the match for the capture group named `name`. If `name` isn't a
-    /// valid capture group or didn't match anything, then `None` is returned.
-    pub fn name(&self, name: &str) -> Option<Match<'t>> {
-        self.named_groups.get(name).and_then(|&i| self.get(i))
-    }
-
-    /// An iterator that yields all capturing matches in the order in which
-    /// they appear in the regex. If a particular capture group didn't
-    /// participate in the match, then `None` is yielded for that capture.
-    ///
-    /// The first match always corresponds to the overall match of the regex.
-    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 't> {
-        SubCaptureMatches { caps: self, it: self.locs.iter() }
-    }
-
-    /// Expands all instances of `$name` in `replacement` to the corresponding
-    /// capture group `name`, and writes them to the `dst` buffer given.
-    ///
-    /// `name` may be an integer corresponding to the index of the capture
-    /// group (counted by order of opening parenthesis where `0` is the
-    /// entire match) or it can be a name (consisting of letters, digits or
-    /// underscores) corresponding to a named capture group.
-    ///
-    /// If `name` isn't a valid capture group (whether the name doesn't exist
-    /// or isn't a valid index), then it is replaced with the empty string.
-    ///
-    /// The longest possible name consisting of the characters `[_0-9A-Za-z]`
-    /// is used. e.g., `$1a` looks up the capture group named `1a` and not the
-    /// capture group at index `1`. To exert more precise control over the
-    /// name, or to refer to a capture group name that uses characters outside
-    /// of `[_0-9A-Za-z]`, use braces, e.g., `${1}a` or `${foo[bar].baz}`. When
-    /// using braces, any sequence of valid UTF-8 bytes is permitted. If the
-    /// sequence does not refer to a capture group name in the corresponding
-    /// regex, then it is replaced with an empty string.
-    ///
-    /// To write a literal `$` use `$$`.
-    pub fn expand(&self, replacement: &[u8], dst: &mut Vec<u8>) {
-        expand_bytes(self, replacement, dst)
-    }
-
-    /// Returns the total number of capture groups (even if they didn't match).
-    ///
-    /// This is always at least `1`, since every regex has at least one capture
-    /// group that corresponds to the full match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.locs.len()
-    }
-}
-
-impl<'t> fmt::Debug for Captures<'t> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("Captures").field(&CapturesDebug(self)).finish()
-    }
-}
-
-struct CapturesDebug<'c, 't>(&'c Captures<'t>);
-
-impl<'c, 't> fmt::Debug for CapturesDebug<'c, 't> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fn escape_bytes(bytes: &[u8]) -> String {
-            let mut s = String::new();
-            for &b in bytes {
-                s.push_str(&escape_byte(b));
-            }
-            s
-        }
-
-        fn escape_byte(byte: u8) -> String {
-            use std::ascii::escape_default;
-
-            let escaped: Vec<u8> = escape_default(byte).collect();
-            String::from_utf8_lossy(&escaped).into_owned()
-        }
-
-        // We'd like to show something nice here, even if it means an
-        // allocation to build a reverse index.
-        let slot_to_name: HashMap<&usize, &String> =
-            self.0.named_groups.iter().map(|(a, b)| (b, a)).collect();
-        let mut map = f.debug_map();
-        for (slot, m) in self.0.locs.iter().enumerate() {
-            let m = m.map(|(s, e)| escape_bytes(&self.0.text[s..e]));
-            if let Some(name) = slot_to_name.get(&slot) {
-                map.entry(&name, &m);
-            } else {
-                map.entry(&slot, &m);
-            }
-        }
-        map.finish()
-    }
-}
-
-/// Get a group by index.
-///
-/// `'t` is the lifetime of the matched text.
-///
-/// The text can't outlive the `Captures` object if this method is
-/// used, because of how `Index` is defined (normally `a[i]` is part
-/// of `a` and can't outlive it); to do that, use `get()` instead.
-///
-/// # Panics
-///
-/// If there is no group at the given index.
-impl<'t> Index<usize> for Captures<'t> {
-    type Output = [u8];
-
-    fn index(&self, i: usize) -> &[u8] {
-        self.get(i)
-            .map(|m| m.as_bytes())
-            .unwrap_or_else(|| panic!("no group at index '{}'", i))
-    }
-}
-
-/// Get a group by name.
-///
-/// `'t` is the lifetime of the matched text and `'i` is the lifetime
-/// of the group name (the index).
-///
-/// The text can't outlive the `Captures` object if this method is
-/// used, because of how `Index` is defined (normally `a[i]` is part
-/// of `a` and can't outlive it); to do that, use `name` instead.
-///
-/// # Panics
-///
-/// If there is no group named by the given value.
-impl<'t, 'i> Index<&'i str> for Captures<'t> {
-    type Output = [u8];
-
-    fn index<'a>(&'a self, name: &'i str) -> &'a [u8] {
-        self.name(name)
-            .map(|m| m.as_bytes())
-            .unwrap_or_else(|| panic!("no group named '{}'", name))
-    }
-}
-
-/// An iterator that yields all capturing matches in the order in which they
-/// appear in the regex.
-///
-/// If a particular capture group didn't participate in the match, then `None`
-/// is yielded for that capture. The first match always corresponds to the
-/// overall match of the regex.
-///
-/// The lifetime `'c` corresponds to the lifetime of the `Captures` value, and
-/// the lifetime `'t` corresponds to the originally matched text.
-#[derive(Clone, Debug)]
-pub struct SubCaptureMatches<'c, 't> {
-    caps: &'c Captures<'t>,
-    it: SubCapturesPosIter<'c>,
-}
-
-impl<'c, 't> Iterator for SubCaptureMatches<'c, 't> {
-    type Item = Option<Match<'t>>;
-
-    fn next(&mut self) -> Option<Option<Match<'t>>> {
-        self.it
-            .next()
-            .map(|cap| cap.map(|(s, e)| Match::new(self.caps.text, s, e)))
-    }
-}
-
-impl<'c, 't> FusedIterator for SubCaptureMatches<'c, 't> {}
-
-/// Replacer describes types that can be used to replace matches in a byte
-/// string.
-///
-/// In general, users of this crate shouldn't need to implement this trait,
-/// since implementations are already provided for `&[u8]` along with other
-/// variants of bytes types and `FnMut(&Captures) -> Vec<u8>` (or any
-/// `FnMut(&Captures) -> T` where `T: AsRef<[u8]>`), which covers most use cases.
-pub trait Replacer {
-    /// Appends text to `dst` to replace the current match.
-    ///
-    /// The current match is represented by `caps`, which is guaranteed to
-    /// have a match at capture group `0`.
-    ///
-    /// For example, a no-op replacement would be
-    /// `dst.extend(&caps[0])`.
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>);
-
-    /// Return a fixed unchanging replacement byte string.
-    ///
-    /// When doing replacements, if access to `Captures` is not needed (e.g.,
-    /// the replacement byte string does not need `$` expansion), then it can
-    /// be beneficial to avoid finding sub-captures.
-    ///
-    /// In general, this is called once for every call to `replacen`.
-    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
-        None
-    }
-
-    /// Return a `Replacer` that borrows and wraps this `Replacer`.
-    ///
-    /// This is useful when you want to take a generic `Replacer` (which might
-    /// not be cloneable) and use it without consuming it, so it can be used
-    /// more than once.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use regex::bytes::{Regex, Replacer};
-    ///
-    /// fn replace_all_twice<R: Replacer>(
-    ///     re: Regex,
-    ///     src: &[u8],
-    ///     mut rep: R,
-    /// ) -> Vec<u8> {
-    ///     let dst = re.replace_all(src, rep.by_ref());
-    ///     let dst = re.replace_all(&dst, rep.by_ref());
-    ///     dst.into_owned()
-    /// }
-    /// ```
-    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
-        ReplacerRef(self)
-    }
-}
-
-/// By-reference adaptor for a `Replacer`
-///
-/// Returned by [`Replacer::by_ref`](trait.Replacer.html#method.by_ref).
-#[derive(Debug)]
-pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
-
-impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        self.0.replace_append(caps, dst)
-    }
-    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
-        self.0.no_expansion()
-    }
-}
-
-impl<'a> Replacer for &'a [u8] {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        caps.expand(*self, dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for &'a Vec<u8> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        caps.expand(*self, dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        no_expansion(self)
-    }
-}
-
-impl Replacer for Vec<u8> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        caps.expand(self, dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for Cow<'a, [u8]> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        caps.expand(self.as_ref(), dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for &'a Cow<'a, [u8]> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        caps.expand(self.as_ref(), dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        no_expansion(self)
-    }
-}
-
-fn no_expansion<T: AsRef<[u8]>>(t: &T) -> Option<Cow<'_, [u8]>> {
-    let s = t.as_ref();
-    match find_byte(b'$', s) {
-        Some(_) => None,
-        None => Some(Cow::Borrowed(s)),
-    }
-}
-
-impl<F, T> Replacer for F
-where
-    F: FnMut(&Captures<'_>) -> T,
-    T: AsRef<[u8]>,
-{
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
-        dst.extend_from_slice((*self)(caps).as_ref());
-    }
-}
-
-/// `NoExpand` indicates literal byte string replacement.
-///
-/// It can be used with `replace` and `replace_all` to do a literal byte string
-/// replacement without expanding `$name` to their corresponding capture
-/// groups. This can be both convenient (to avoid escaping `$`, for example)
-/// and performant (since capture groups don't need to be found).
-///
-/// `'t` is the lifetime of the literal text.
-#[derive(Clone, Debug)]
-pub struct NoExpand<'t>(pub &'t [u8]);
-
-impl<'t> Replacer for NoExpand<'t> {
-    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut Vec<u8>) {
-        dst.extend_from_slice(self.0);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
-        Some(Cow::Borrowed(self.0))
-    }
-}
diff --git a/src/re_set.rs b/src/re_set.rs
deleted file mode 100644
index 7c8253f0ca..0000000000
--- a/src/re_set.rs
+++ /dev/null
@@ -1,518 +0,0 @@
-macro_rules! define_set {
-    ($name:ident, $builder_mod:ident, $text_ty:ty, $as_bytes:expr,
-     $(#[$doc_regexset_example:meta])* ) => {
-        pub mod $name {
-            use std::fmt;
-            use std::iter;
-            use std::slice;
-            use std::vec;
-
-            use crate::error::Error;
-            use crate::exec::Exec;
-            use crate::re_builder::$builder_mod::RegexSetBuilder;
-            use crate::re_trait::RegularExpression;
-
-/// Match multiple (possibly overlapping) regular expressions in a single scan.
-///
-/// A regex set corresponds to the union of two or more regular expressions.
-/// That is, a regex set will match text where at least one of its
-/// constituent regular expressions matches. A regex set as its formulated here
-/// provides a touch more power: it will also report *which* regular
-/// expressions in the set match. Indeed, this is the key difference between
-/// regex sets and a single `Regex` with many alternates, since only one
-/// alternate can match at a time.
-///
-/// For example, consider regular expressions to match email addresses and
-/// domains: `[a-z]+@[a-z]+\.(com|org|net)` and `[a-z]+\.(com|org|net)`. If a
-/// regex set is constructed from those regexes, then searching the text
-/// `foo@example.com` will report both regexes as matching. Of course, one
-/// could accomplish this by compiling each regex on its own and doing two
-/// searches over the text. The key advantage of using a regex set is that it
-/// will report the matching regexes using a *single pass through the text*.
-/// If one has hundreds or thousands of regexes to match repeatedly (like a URL
-/// router for a complex web application or a user agent matcher), then a regex
-/// set can realize huge performance gains.
-///
-/// # Example
-///
-/// This shows how the above two regexes (for matching email addresses and
-/// domains) might work:
-///
-$(#[$doc_regexset_example])*
-///
-/// Note that it would be possible to adapt the above example to using `Regex`
-/// with an expression like:
-///
-/// ```text
-/// (?P<email>[a-z]+@(?P<email_domain>[a-z]+[.](com|org|net)))|(?P<domain>[a-z]+[.](com|org|net))
-/// ```
-///
-/// After a match, one could then inspect the capture groups to figure out
-/// which alternates matched. The problem is that it is hard to make this
-/// approach scale when there are many regexes since the overlap between each
-/// alternate isn't always obvious to reason about.
-///
-/// # Limitations
-///
-/// Regex sets are limited to answering the following two questions:
-///
-/// 1. Does any regex in the set match?
-/// 2. If so, which regexes in the set match?
-///
-/// As with the main [`Regex`][crate::Regex] type, it is cheaper to ask (1)
-/// instead of (2) since the matching engines can stop after the first match
-/// is found.
-///
-/// You cannot directly extract [`Match`][crate::Match] or
-/// [`Captures`][crate::Captures] objects from a regex set. If you need these
-/// operations, the recommended approach is to compile each pattern in the set
-/// independently and scan the exact same input a second time with those
-/// independently compiled patterns:
-///
-/// ```rust
-/// use regex::{Regex, RegexSet};
-///
-/// let patterns = ["foo", "bar"];
-/// // Both patterns will match different ranges of this string.
-/// let text = "barfoo";
-///
-/// // Compile a set matching any of our patterns.
-/// let set = RegexSet::new(&patterns).unwrap();
-/// // Compile each pattern independently.
-/// let regexes: Vec<_> = set.patterns().iter()
-///     .map(|pat| Regex::new(pat).unwrap())
-///     .collect();
-///
-/// // Match against the whole set first and identify the individual
-/// // matching patterns.
-/// let matches: Vec<&str> = set.matches(text).into_iter()
-///     // Dereference the match index to get the corresponding
-///     // compiled pattern.
-///     .map(|match_idx| &regexes[match_idx])
-///     // To get match locations or any other info, we then have to search
-///     // the exact same text again, using our separately-compiled pattern.
-///     .map(|pat| pat.find(text).unwrap().as_str())
-///     .collect();
-///
-/// // Matches arrive in the order the constituent patterns were declared,
-/// // not the order they appear in the input.
-/// assert_eq!(vec!["foo", "bar"], matches);
-/// ```
-///
-/// # Performance
-///
-/// A `RegexSet` has the same performance characteristics as `Regex`. Namely,
-/// search takes `O(mn)` time, where `m` is proportional to the size of the
-/// regex set and `n` is proportional to the length of the search text.
-#[derive(Clone)]
-pub struct RegexSet(Exec);
-
-impl RegexSet {
-    /// Create a new regex set with the given regular expressions.
-    ///
-    /// This takes an iterator of `S`, where `S` is something that can produce
-    /// a `&str`. If any of the strings in the iterator are not valid regular
-    /// expressions, then an error is returned.
-    ///
-    /// # Example
-    ///
-    /// Create a new regex set from an iterator of strings:
-    ///
-    /// ```rust
-    /// # use regex::RegexSet;
-    /// let set = RegexSet::new(&[r"\w+", r"\d+"]).unwrap();
-    /// assert!(set.is_match("foo"));
-    /// ```
-    pub fn new<I, S>(exprs: I) -> Result<RegexSet, Error>
-            where S: AsRef<str>, I: IntoIterator<Item=S> {
-        RegexSetBuilder::new(exprs).build()
-    }
-
-    /// Create a new empty regex set.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use regex::RegexSet;
-    /// let set = RegexSet::empty();
-    /// assert!(set.is_empty());
-    /// ```
-    pub fn empty() -> RegexSet {
-        RegexSetBuilder::new(&[""; 0]).build().unwrap()
-    }
-
-    /// Returns true if and only if one of the regexes in this set matches
-    /// the text given.
-    ///
-    /// This method should be preferred if you only need to test whether any
-    /// of the regexes in the set should match, but don't care about *which*
-    /// regexes matched. This is because the underlying matching engine will
-    /// quit immediately after seeing the first match instead of continuing to
-    /// find all matches.
-    ///
-    /// Note that as with searches using `Regex`, the expression is unanchored
-    /// by default. That is, if the regex does not start with `^` or `\A`, or
-    /// end with `$` or `\z`, then it is permitted to match anywhere in the
-    /// text.
-    ///
-    /// # Example
-    ///
-    /// Tests whether a set matches some text:
-    ///
-    /// ```rust
-    /// # use regex::RegexSet;
-    /// let set = RegexSet::new(&[r"\w+", r"\d+"]).unwrap();
-    /// assert!(set.is_match("foo"));
-    /// assert!(!set.is_match("☃"));
-    /// ```
-    pub fn is_match(&self, text: $text_ty) -> bool {
-        self.is_match_at(text, 0)
-    }
-
-    /// Returns the same as is_match, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    #[doc(hidden)]
-    pub fn is_match_at(&self, text: $text_ty, start: usize) -> bool {
-        self.0.searcher().is_match_at($as_bytes(text), start)
-    }
-
-    /// Returns the set of regular expressions that match in the given text.
-    ///
-    /// The set returned contains the index of each regular expression that
-    /// matches in the given text. The index is in correspondence with the
-    /// order of regular expressions given to `RegexSet`'s constructor.
-    ///
-    /// The set can also be used to iterate over the matched indices.
-    ///
-    /// Note that as with searches using `Regex`, the expression is unanchored
-    /// by default. That is, if the regex does not start with `^` or `\A`, or
-    /// end with `$` or `\z`, then it is permitted to match anywhere in the
-    /// text.
-    ///
-    /// # Example
-    ///
-    /// Tests which regular expressions match the given text:
-    ///
-    /// ```rust
-    /// # use regex::RegexSet;
-    /// let set = RegexSet::new(&[
-    ///     r"\w+",
-    ///     r"\d+",
-    ///     r"\pL+",
-    ///     r"foo",
-    ///     r"bar",
-    ///     r"barfoo",
-    ///     r"foobar",
-    /// ]).unwrap();
-    /// let matches: Vec<_> = set.matches("foobar").into_iter().collect();
-    /// assert_eq!(matches, vec![0, 2, 3, 4, 6]);
-    ///
-    /// // You can also test whether a particular regex matched:
-    /// let matches = set.matches("foobar");
-    /// assert!(!matches.matched(5));
-    /// assert!(matches.matched(6));
-    /// ```
-    pub fn matches(&self, text: $text_ty) -> SetMatches {
-        let mut matches = vec![false; self.0.regex_strings().len()];
-        let any = self.read_matches_at(&mut matches, text, 0);
-        SetMatches {
-            matched_any: any,
-            matches: matches,
-        }
-    }
-
-    /// Returns the same as matches, but starts the search at the given
-    /// offset and stores the matches into the slice given.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    ///
-    /// `matches` must have a length that is at least the number of regexes
-    /// in this set.
-    ///
-    /// This method returns true if and only if at least one member of
-    /// `matches` is true after executing the set against `text`.
-    #[doc(hidden)]
-    pub fn read_matches_at(
-        &self,
-        matches: &mut [bool],
-        text: $text_ty,
-        start: usize,
-    ) -> bool {
-        self.0.searcher().many_matches_at(matches, $as_bytes(text), start)
-    }
-
-    /// Returns the total number of regular expressions in this set.
-    pub fn len(&self) -> usize {
-        self.0.regex_strings().len()
-    }
-
-    /// Returns `true` if this set contains no regular expressions.
-    pub fn is_empty(&self) -> bool {
-        self.0.regex_strings().is_empty()
-    }
-
-    /// Returns the patterns that this set will match on.
-    ///
-    /// This function can be used to determine the pattern for a match. The
-    /// slice returned has exactly as many patterns givens to this regex set,
-    /// and the order of the slice is the same as the order of the patterns
-    /// provided to the set.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use regex::RegexSet;
-    /// let set = RegexSet::new(&[
-    ///     r"\w+",
-    ///     r"\d+",
-    ///     r"\pL+",
-    ///     r"foo",
-    ///     r"bar",
-    ///     r"barfoo",
-    ///     r"foobar",
-    /// ]).unwrap();
-    /// let matches: Vec<_> = set
-    ///     .matches("foobar")
-    ///     .into_iter()
-    ///     .map(|match_idx| &set.patterns()[match_idx])
-    ///     .collect();
-    /// assert_eq!(matches, vec![r"\w+", r"\pL+", r"foo", r"bar", r"foobar"]);
-    /// ```
-    pub fn patterns(&self) -> &[String] {
-        self.0.regex_strings()
-    }
-}
-
-impl Default for RegexSet {
-    fn default() -> Self {
-        RegexSet::empty()
-    }
-}
-
-/// A set of matches returned by a regex set.
-#[derive(Clone, Debug)]
-pub struct SetMatches {
-    matched_any: bool,
-    matches: Vec<bool>,
-}
-
-impl SetMatches {
-    /// Whether this set contains any matches.
-    pub fn matched_any(&self) -> bool {
-        self.matched_any
-    }
-
-    /// Whether the regex at the given index matched.
-    ///
-    /// The index for a regex is determined by its insertion order upon the
-    /// initial construction of a `RegexSet`, starting at `0`.
-    ///
-    /// # Panics
-    ///
-    /// If `regex_index` is greater than or equal to `self.len()`.
-    pub fn matched(&self, regex_index: usize) -> bool {
-        self.matches[regex_index]
-    }
-
-    /// The total number of regexes in the set that created these matches.
-    ///
-    /// **WARNING:** This always returns the same value as [`RegexSet::len`].
-    /// In particular, it does *not* return the number of elements yielded by
-    /// [`SetMatches::iter`]. The only way to determine the total number of
-    /// matched regexes is to iterate over them.
-    pub fn len(&self) -> usize {
-        self.matches.len()
-    }
-
-    /// Returns an iterator over indexes in the regex that matched.
-    ///
-    /// This will always produces matches in ascending order of index, where
-    /// the index corresponds to the index of the regex that matched with
-    /// respect to its position when initially building the set.
-    pub fn iter(&self) -> SetMatchesIter<'_> {
-        SetMatchesIter((&*self.matches).into_iter().enumerate())
-    }
-}
-
-impl IntoIterator for SetMatches {
-    type IntoIter = SetMatchesIntoIter;
-    type Item = usize;
-
-    fn into_iter(self) -> Self::IntoIter {
-        SetMatchesIntoIter(self.matches.into_iter().enumerate())
-    }
-}
-
-impl<'a> IntoIterator for &'a SetMatches {
-    type IntoIter = SetMatchesIter<'a>;
-    type Item = usize;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-/// An owned iterator over the set of matches from a regex set.
-///
-/// This will always produces matches in ascending order of index, where the
-/// index corresponds to the index of the regex that matched with respect to
-/// its position when initially building the set.
-#[derive(Debug)]
-pub struct SetMatchesIntoIter(iter::Enumerate<vec::IntoIter<bool>>);
-
-impl Iterator for SetMatchesIntoIter {
-    type Item = usize;
-
-    fn next(&mut self) -> Option<usize> {
-        loop {
-            match self.0.next() {
-                None => return None,
-                Some((_, false)) => {}
-                Some((i, true)) => return Some(i),
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
-
-impl DoubleEndedIterator for SetMatchesIntoIter {
-    fn next_back(&mut self) -> Option<usize> {
-        loop {
-            match self.0.next_back() {
-                None => return None,
-                Some((_, false)) => {}
-                Some((i, true)) => return Some(i),
-            }
-        }
-    }
-}
-
-impl iter::FusedIterator for SetMatchesIntoIter {}
-
-/// A borrowed iterator over the set of matches from a regex set.
-///
-/// The lifetime `'a` refers to the lifetime of a `SetMatches` value.
-///
-/// This will always produces matches in ascending order of index, where the
-/// index corresponds to the index of the regex that matched with respect to
-/// its position when initially building the set.
-#[derive(Clone, Debug)]
-pub struct SetMatchesIter<'a>(iter::Enumerate<slice::Iter<'a, bool>>);
-
-impl<'a> Iterator for SetMatchesIter<'a> {
-    type Item = usize;
-
-    fn next(&mut self) -> Option<usize> {
-        loop {
-            match self.0.next() {
-                None => return None,
-                Some((_, &false)) => {}
-                Some((i, &true)) => return Some(i),
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
-
-impl<'a> DoubleEndedIterator for SetMatchesIter<'a> {
-    fn next_back(&mut self) -> Option<usize> {
-        loop {
-            match self.0.next_back() {
-                None => return None,
-                Some((_, &false)) => {}
-                Some((i, &true)) => return Some(i),
-            }
-        }
-    }
-}
-
-impl<'a> iter::FusedIterator for SetMatchesIter<'a> {}
-
-#[doc(hidden)]
-impl From<Exec> for RegexSet {
-    fn from(exec: Exec) -> Self {
-        RegexSet(exec)
-    }
-}
-
-impl fmt::Debug for RegexSet {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "RegexSet({:?})", self.0.regex_strings())
-    }
-}
-
-#[allow(dead_code)] fn as_bytes_str(text: &str) -> &[u8] { text.as_bytes() }
-#[allow(dead_code)] fn as_bytes_bytes(text: &[u8]) -> &[u8] { text }
-        }
-    }
-}
-
-define_set! {
-    unicode,
-    set_unicode,
-    &str,
-    as_bytes_str,
-/// ```rust
-/// # use regex::RegexSet;
-/// let set = RegexSet::new(&[
-///     r"[a-z]+@[a-z]+\.(com|org|net)",
-///     r"[a-z]+\.(com|org|net)",
-/// ]).unwrap();
-///
-/// // Ask whether any regexes in the set match.
-/// assert!(set.is_match("foo@example.com"));
-///
-/// // Identify which regexes in the set match.
-/// let matches: Vec<_> = set.matches("foo@example.com").into_iter().collect();
-/// assert_eq!(vec![0, 1], matches);
-///
-/// // Try again, but with text that only matches one of the regexes.
-/// let matches: Vec<_> = set.matches("example.com").into_iter().collect();
-/// assert_eq!(vec![1], matches);
-///
-/// // Try again, but with text that doesn't match any regex in the set.
-/// let matches: Vec<_> = set.matches("example").into_iter().collect();
-/// assert!(matches.is_empty());
-/// ```
-}
-
-define_set! {
-    bytes,
-    set_bytes,
-    &[u8],
-    as_bytes_bytes,
-/// ```rust
-/// # use regex::bytes::RegexSet;
-/// let set = RegexSet::new(&[
-///     r"[a-z]+@[a-z]+\.(com|org|net)",
-///     r"[a-z]+\.(com|org|net)",
-/// ]).unwrap();
-///
-/// // Ask whether any regexes in the set match.
-/// assert!(set.is_match(b"foo@example.com"));
-///
-/// // Identify which regexes in the set match.
-/// let matches: Vec<_> = set.matches(b"foo@example.com").into_iter().collect();
-/// assert_eq!(vec![0, 1], matches);
-///
-/// // Try again, but with text that only matches one of the regexes.
-/// let matches: Vec<_> = set.matches(b"example.com").into_iter().collect();
-/// assert_eq!(vec![1], matches);
-///
-/// // Try again, but with text that doesn't match any regex in the set.
-/// let matches: Vec<_> = set.matches(b"example").into_iter().collect();
-/// assert!(matches.is_empty());
-/// ```
-}
diff --git a/src/re_trait.rs b/src/re_trait.rs
deleted file mode 100644
index 505810c848..0000000000
--- a/src/re_trait.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use std::fmt;
-use std::iter::FusedIterator;
-
-/// Slot is a single saved capture location. Note that there are two slots for
-/// every capture in a regular expression (one slot each for the start and end
-/// of the capture).
-pub type Slot = Option<usize>;
-
-/// Locations represents the offsets of each capturing group in a regex for
-/// a single match.
-///
-/// Unlike `Captures`, a `Locations` value only stores offsets.
-#[doc(hidden)]
-#[derive(Clone, Debug)]
-pub struct Locations(Vec<Slot>);
-
-impl Locations {
-    /// Returns the start and end positions of the Nth capture group. Returns
-    /// `None` if `i` is not a valid capture group or if the capture group did
-    /// not match anything. The positions returned are *always* byte indices
-    /// with respect to the original string matched.
-    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
-        let (s, e) = (i.checked_mul(2)?, i.checked_mul(2)?.checked_add(1)?);
-        match (self.0.get(s), self.0.get(e)) {
-            (Some(&Some(s)), Some(&Some(e))) => Some((s, e)),
-            _ => None,
-        }
-    }
-
-    /// Creates an iterator of all the capture group positions in order of
-    /// appearance in the regular expression. Positions are byte indices
-    /// in terms of the original string matched.
-    pub fn iter(&self) -> SubCapturesPosIter<'_> {
-        SubCapturesPosIter { idx: 0, locs: self }
-    }
-
-    /// Returns the total number of capturing groups.
-    ///
-    /// This is always at least `1` since every regex has at least `1`
-    /// capturing group that corresponds to the entire match.
-    pub fn len(&self) -> usize {
-        self.0.len() / 2
-    }
-
-    /// Return the individual slots as a slice.
-    pub(crate) fn as_slots(&mut self) -> &mut [Slot] {
-        &mut self.0
-    }
-}
-
-/// An iterator over capture group positions for a particular match of a
-/// regular expression.
-///
-/// Positions are byte indices in terms of the original string matched.
-///
-/// `'c` is the lifetime of the captures.
-#[derive(Clone, Debug)]
-pub struct SubCapturesPosIter<'c> {
-    idx: usize,
-    locs: &'c Locations,
-}
-
-impl<'c> Iterator for SubCapturesPosIter<'c> {
-    type Item = Option<(usize, usize)>;
-
-    fn next(&mut self) -> Option<Option<(usize, usize)>> {
-        if self.idx >= self.locs.len() {
-            return None;
-        }
-        let x = match self.locs.pos(self.idx) {
-            None => Some(None),
-            Some((s, e)) => Some(Some((s, e))),
-        };
-        self.idx += 1;
-        x
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.locs.len() - self.idx;
-        (len, Some(len))
-    }
-
-    fn count(self) -> usize {
-        self.len()
-    }
-}
-
-impl<'c> ExactSizeIterator for SubCapturesPosIter<'c> {}
-
-impl<'c> FusedIterator for SubCapturesPosIter<'c> {}
-
-/// `RegularExpression` describes types that can implement regex searching.
-///
-/// This trait is my attempt at reducing code duplication and to standardize
-/// the internal API. Specific duplication that is avoided are the `find`
-/// and `capture` iterators, which are slightly tricky.
-///
-/// It's not clear whether this trait is worth it, and it also isn't
-/// clear whether it's useful as a public trait or not. Methods like
-/// `next_after_empty` reak of bad design, but the rest of the methods seem
-/// somewhat reasonable. One particular thing this trait would expose would be
-/// the ability to start the search of a regex anywhere in a haystack, which
-/// isn't possible in the current public API.
-pub trait RegularExpression: Sized + fmt::Debug {
-    /// The type of the haystack.
-    type Text: ?Sized + fmt::Debug;
-
-    /// The number of capture slots in the compiled regular expression. This is
-    /// always two times the number of capture groups (two slots per group).
-    fn slots_len(&self) -> usize;
-
-    /// Allocates fresh space for all capturing groups in this regex.
-    fn locations(&self) -> Locations {
-        Locations(vec![None; self.slots_len()])
-    }
-
-    /// Returns the position of the next character after `i`.
-    ///
-    /// For example, a haystack with type `&[u8]` probably returns `i+1`,
-    /// whereas a haystack with type `&str` probably returns `i` plus the
-    /// length of the next UTF-8 sequence.
-    fn next_after_empty(&self, text: &Self::Text, i: usize) -> usize;
-
-    /// Returns the location of the shortest match.
-    fn shortest_match_at(
-        &self,
-        text: &Self::Text,
-        start: usize,
-    ) -> Option<usize>;
-
-    /// Returns whether the regex matches the text given.
-    fn is_match_at(&self, text: &Self::Text, start: usize) -> bool;
-
-    /// Returns the leftmost-first match location if one exists.
-    fn find_at(
-        &self,
-        text: &Self::Text,
-        start: usize,
-    ) -> Option<(usize, usize)>;
-
-    /// Returns the leftmost-first match location if one exists, and also
-    /// fills in any matching capture slot locations.
-    fn captures_read_at(
-        &self,
-        locs: &mut Locations,
-        text: &Self::Text,
-        start: usize,
-    ) -> Option<(usize, usize)>;
-
-    /// Returns an iterator over all non-overlapping successive leftmost-first
-    /// matches.
-    fn find_iter(self, text: &Self::Text) -> Matches<'_, Self> {
-        Matches { re: self, text, last_end: 0, last_match: None }
-    }
-
-    /// Returns an iterator over all non-overlapping successive leftmost-first
-    /// matches with captures.
-    fn captures_iter(self, text: &Self::Text) -> CaptureMatches<'_, Self> {
-        CaptureMatches(self.find_iter(text))
-    }
-}
-
-/// An iterator over all non-overlapping successive leftmost-first matches.
-#[derive(Debug)]
-pub struct Matches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't,
-{
-    re: R,
-    text: &'t R::Text,
-    last_end: usize,
-    last_match: Option<usize>,
-}
-
-impl<'t, R> Matches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't,
-{
-    /// Return the text being searched.
-    pub fn text(&self) -> &'t R::Text {
-        self.text
-    }
-
-    /// Return the underlying regex.
-    pub fn regex(&self) -> &R {
-        &self.re
-    }
-}
-
-impl<'t, R> Iterator for Matches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't + AsRef<[u8]>,
-{
-    type Item = (usize, usize);
-
-    fn next(&mut self) -> Option<(usize, usize)> {
-        if self.last_end > self.text.as_ref().len() {
-            return None;
-        }
-        let (s, e) = match self.re.find_at(self.text, self.last_end) {
-            None => return None,
-            Some((s, e)) => (s, e),
-        };
-        if s == e {
-            // This is an empty match. To ensure we make progress, start
-            // the next search at the smallest possible starting position
-            // of the next match following this one.
-            self.last_end = self.re.next_after_empty(self.text, e);
-            // Don't accept empty matches immediately following a match.
-            // Just move on to the next match.
-            if Some(e) == self.last_match {
-                return self.next();
-            }
-        } else {
-            self.last_end = e;
-        }
-        self.last_match = Some(e);
-        Some((s, e))
-    }
-}
-
-impl<'t, R> FusedIterator for Matches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't + AsRef<[u8]>,
-{
-}
-
-/// An iterator over all non-overlapping successive leftmost-first matches with
-/// captures.
-#[derive(Debug)]
-pub struct CaptureMatches<'t, R>(Matches<'t, R>)
-where
-    R: RegularExpression,
-    R::Text: 't;
-
-impl<'t, R> CaptureMatches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't,
-{
-    /// Return the text being searched.
-    pub fn text(&self) -> &'t R::Text {
-        self.0.text()
-    }
-
-    /// Return the underlying regex.
-    pub fn regex(&self) -> &R {
-        self.0.regex()
-    }
-}
-
-impl<'t, R> Iterator for CaptureMatches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't + AsRef<[u8]>,
-{
-    type Item = Locations;
-
-    fn next(&mut self) -> Option<Locations> {
-        if self.0.last_end > self.0.text.as_ref().len() {
-            return None;
-        }
-        let mut locs = self.0.re.locations();
-        let (s, e) = match self.0.re.captures_read_at(
-            &mut locs,
-            self.0.text,
-            self.0.last_end,
-        ) {
-            None => return None,
-            Some((s, e)) => (s, e),
-        };
-        if s == e {
-            self.0.last_end = self.0.re.next_after_empty(self.0.text, e);
-            if Some(e) == self.0.last_match {
-                return self.next();
-            }
-        } else {
-            self.0.last_end = e;
-        }
-        self.0.last_match = Some(e);
-        Some(locs)
-    }
-}
-
-impl<'t, R> FusedIterator for CaptureMatches<'t, R>
-where
-    R: RegularExpression,
-    R::Text: 't + AsRef<[u8]>,
-{
-}
diff --git a/src/re_unicode.rs b/src/re_unicode.rs
deleted file mode 100644
index 57689086dc..0000000000
--- a/src/re_unicode.rs
+++ /dev/null
@@ -1,1415 +0,0 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fmt;
-use std::iter::FusedIterator;
-use std::ops::{Index, Range};
-use std::str::FromStr;
-use std::sync::Arc;
-
-use crate::find_byte::find_byte;
-
-use crate::error::Error;
-use crate::exec::{Exec, ExecNoSyncStr};
-use crate::expand::expand_str;
-use crate::re_builder::unicode::RegexBuilder;
-use crate::re_trait::{self, RegularExpression, SubCapturesPosIter};
-
-/// Escapes all regular expression meta characters in `text`.
-///
-/// The string returned may be safely used as a literal in a regular
-/// expression.
-pub fn escape(text: &str) -> String {
-    regex_syntax::escape(text)
-}
-
-/// Match represents a single match of a regex in a haystack.
-///
-/// The lifetime parameter `'t` refers to the lifetime of the matched text.
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Match<'t> {
-    text: &'t str,
-    start: usize,
-    end: usize,
-}
-
-impl<'t> Match<'t> {
-    /// Returns the starting byte offset of the match in the haystack.
-    #[inline]
-    pub fn start(&self) -> usize {
-        self.start
-    }
-
-    /// Returns the ending byte offset of the match in the haystack.
-    #[inline]
-    pub fn end(&self) -> usize {
-        self.end
-    }
-
-    /// Returns true if and only if this match has a length of zero.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.start == self.end
-    }
-
-    /// Returns the length, in bytes, of this match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.end - self.start
-    }
-
-    /// Returns the range over the starting and ending byte offsets of the
-    /// match in the haystack.
-    #[inline]
-    pub fn range(&self) -> Range<usize> {
-        self.start..self.end
-    }
-
-    /// Returns the matched text.
-    #[inline]
-    pub fn as_str(&self) -> &'t str {
-        &self.text[self.range()]
-    }
-
-    /// Creates a new match from the given haystack and byte offsets.
-    #[inline]
-    fn new(haystack: &'t str, start: usize, end: usize) -> Match<'t> {
-        Match { text: haystack, start, end }
-    }
-}
-
-impl<'t> std::fmt::Debug for Match<'t> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        f.debug_struct("Match")
-            .field("start", &self.start)
-            .field("end", &self.end)
-            .field("string", &self.as_str())
-            .finish()
-    }
-}
-
-impl<'t> From<Match<'t>> for &'t str {
-    fn from(m: Match<'t>) -> &'t str {
-        m.as_str()
-    }
-}
-
-impl<'t> From<Match<'t>> for Range<usize> {
-    fn from(m: Match<'t>) -> Range<usize> {
-        m.range()
-    }
-}
-
-/// A compiled regular expression for matching Unicode strings.
-///
-/// It is represented as either a sequence of bytecode instructions (dynamic)
-/// or as a specialized Rust function (native). It can be used to search, split
-/// or replace text. All searching is done with an implicit `.*?` at the
-/// beginning and end of an expression. To force an expression to match the
-/// whole string (or a prefix or a suffix), you must use an anchor like `^` or
-/// `$` (or `\A` and `\z`).
-///
-/// While this crate will handle Unicode strings (whether in the regular
-/// expression or in the search text), all positions returned are **byte
-/// indices**. Every byte index is guaranteed to be at a Unicode code point
-/// boundary.
-///
-/// The lifetimes `'r` and `'t` in this crate correspond to the lifetime of a
-/// compiled regular expression and text to search, respectively.
-///
-/// The only methods that allocate new strings are the string replacement
-/// methods. All other methods (searching and splitting) return borrowed
-/// pointers into the string given.
-///
-/// # Examples
-///
-/// Find the location of a US phone number:
-///
-/// ```rust
-/// # use regex::Regex;
-/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();
-/// let mat = re.find("phone: 111-222-3333").unwrap();
-/// assert_eq!((mat.start(), mat.end()), (7, 19));
-/// ```
-///
-/// # Using the `std::str::pattern` methods with `Regex`
-///
-/// > **Note**: This section requires that this crate is compiled with the
-/// > `pattern` Cargo feature enabled, which **requires nightly Rust**.
-///
-/// Since `Regex` implements `Pattern`, you can use regexes with methods
-/// defined on `&str`. For example, `is_match`, `find`, `find_iter`
-/// and `split` can be replaced with `str::contains`, `str::find`,
-/// `str::match_indices` and `str::split`.
-///
-/// Here are some examples:
-///
-/// ```rust,ignore
-/// # use regex::Regex;
-/// let re = Regex::new(r"\d+").unwrap();
-/// let haystack = "a111b222c";
-///
-/// assert!(haystack.contains(&re));
-/// assert_eq!(haystack.find(&re), Some(1));
-/// assert_eq!(haystack.match_indices(&re).collect::<Vec<_>>(),
-///            vec![(1, "111"), (5, "222")]);
-/// assert_eq!(haystack.split(&re).collect::<Vec<_>>(), vec!["a", "b", "c"]);
-/// ```
-#[derive(Clone)]
-pub struct Regex(Exec);
-
-impl fmt::Display for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl fmt::Debug for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-#[doc(hidden)]
-impl From<Exec> for Regex {
-    fn from(exec: Exec) -> Regex {
-        Regex(exec)
-    }
-}
-
-impl FromStr for Regex {
-    type Err = Error;
-
-    /// Attempts to parse a string into a regular expression
-    fn from_str(s: &str) -> Result<Regex, Error> {
-        Regex::new(s)
-    }
-}
-
-/// Core regular expression methods.
-impl Regex {
-    /// Compiles a regular expression. Once compiled, it can be used repeatedly
-    /// to search, split or replace text in a string.
-    ///
-    /// If an invalid expression is given, then an error is returned.
-    pub fn new(re: &str) -> Result<Regex, Error> {
-        RegexBuilder::new(re).build()
-    }
-
-    /// Returns true if and only if there is a match for the regex in the
-    /// string given.
-    ///
-    /// It is recommended to use this method if all you need to do is test
-    /// a match, since the underlying matching engine may be able to do less
-    /// work.
-    ///
-    /// # Example
-    ///
-    /// Test if some text contains at least one word with exactly 13
-    /// Unicode word characters:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let text = "I categorically deny having triskaidekaphobia.";
-    /// assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));
-    /// # }
-    /// ```
-    pub fn is_match(&self, text: &str) -> bool {
-        self.is_match_at(text, 0)
-    }
-
-    /// Returns the start and end byte range of the leftmost-first match in
-    /// `text`. If no match exists, then `None` is returned.
-    ///
-    /// Note that this should only be used if you want to discover the position
-    /// of the match. Testing the existence of a match is faster if you use
-    /// `is_match`.
-    ///
-    /// # Example
-    ///
-    /// Find the start and end location of the first word with exactly 13
-    /// Unicode word characters:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let text = "I categorically deny having triskaidekaphobia.";
-    /// let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
-    /// assert_eq!(mat.start(), 2);
-    /// assert_eq!(mat.end(), 15);
-    /// # }
-    /// ```
-    pub fn find<'t>(&self, text: &'t str) -> Option<Match<'t>> {
-        self.find_at(text, 0)
-    }
-
-    /// Returns an iterator for each successive non-overlapping match in
-    /// `text`, returning the start and end byte indices with respect to
-    /// `text`.
-    ///
-    /// # Example
-    ///
-    /// Find the start and end location of every word with exactly 13 Unicode
-    /// word characters:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let text = "Retroactively relinquishing remunerations is reprehensible.";
-    /// for mat in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) {
-    ///     println!("{:?}", mat);
-    /// }
-    /// # }
-    /// ```
-    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> Matches<'r, 't> {
-        Matches(self.0.searcher_str().find_iter(text))
-    }
-
-    /// Returns the capture groups corresponding to the leftmost-first
-    /// match in `text`. Capture group `0` always corresponds to the entire
-    /// match. If no match is found, then `None` is returned.
-    ///
-    /// You should only use `captures` if you need access to the location of
-    /// capturing group matches. Otherwise, `find` is faster for discovering
-    /// the location of the overall match.
-    ///
-    /// # Examples
-    ///
-    /// Say you have some text with movie names and their release years,
-    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for text
-    /// looking like that, while also extracting the movie name and its release
-    /// year separately.
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
-    /// let text = "Not my favorite movie: 'Citizen Kane' (1941).";
-    /// let caps = re.captures(text).unwrap();
-    /// assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");
-    /// assert_eq!(caps.get(2).unwrap().as_str(), "1941");
-    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
-    /// // You can also access the groups by index using the Index notation.
-    /// // Note that this will panic on an invalid index.
-    /// assert_eq!(&caps[1], "Citizen Kane");
-    /// assert_eq!(&caps[2], "1941");
-    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
-    /// # }
-    /// ```
-    ///
-    /// Note that the full match is at capture group `0`. Each subsequent
-    /// capture group is indexed by the order of its opening `(`.
-    ///
-    /// We can make this example a bit clearer by using *named* capture groups:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
-    ///                .unwrap();
-    /// let text = "Not my favorite movie: 'Citizen Kane' (1941).";
-    /// let caps = re.captures(text).unwrap();
-    /// assert_eq!(caps.name("title").unwrap().as_str(), "Citizen Kane");
-    /// assert_eq!(caps.name("year").unwrap().as_str(), "1941");
-    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
-    /// // You can also access the groups by name using the Index notation.
-    /// // Note that this will panic on an invalid group name.
-    /// assert_eq!(&caps["title"], "Citizen Kane");
-    /// assert_eq!(&caps["year"], "1941");
-    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
-    ///
-    /// # }
-    /// ```
-    ///
-    /// Here we name the capture groups, which we can access with the `name`
-    /// method or the `Index` notation with a `&str`. Note that the named
-    /// capture groups are still accessible with `get` or the `Index` notation
-    /// with a `usize`.
-    ///
-    /// The `0`th capture group is always unnamed, so it must always be
-    /// accessed with `get(0)` or `[0]`.
-    pub fn captures<'t>(&self, text: &'t str) -> Option<Captures<'t>> {
-        self.captures_at(text, 0)
-    }
-
-    /// Returns an iterator over all the non-overlapping capture groups matched
-    /// in `text`. This is operationally the same as `find_iter`, except it
-    /// yields information about capturing group matches.
-    ///
-    /// # Example
-    ///
-    /// We can use this to find all movie titles and their release years in
-    /// some text, where the movie is formatted like "'Title' (xxxx)":
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
-    ///                .unwrap();
-    /// let text = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
-    /// for caps in re.captures_iter(text) {
-    ///     println!("Movie: {:?}, Released: {:?}",
-    ///              &caps["title"], &caps["year"]);
-    /// }
-    /// // Output:
-    /// // Movie: Citizen Kane, Released: 1941
-    /// // Movie: The Wizard of Oz, Released: 1939
-    /// // Movie: M, Released: 1931
-    /// # }
-    /// ```
-    pub fn captures_iter<'r, 't>(
-        &'r self,
-        text: &'t str,
-    ) -> CaptureMatches<'r, 't> {
-        CaptureMatches(self.0.searcher_str().captures_iter(text))
-    }
-
-    /// Returns an iterator of substrings of `text` delimited by a match of the
-    /// regular expression. Namely, each element of the iterator corresponds to
-    /// text that *isn't* matched by the regular expression.
-    ///
-    /// This method will *not* copy the text given.
-    ///
-    /// # Example
-    ///
-    /// To split a string delimited by arbitrary amounts of spaces or tabs:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"[ \t]+").unwrap();
-    /// let fields: Vec<&str> = re.split("a b \t  c\td    e").collect();
-    /// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);
-    /// # }
-    /// ```
-    pub fn split<'r, 't>(&'r self, text: &'t str) -> Split<'r, 't> {
-        Split { finder: self.find_iter(text), last: 0 }
-    }
-
-    /// Returns an iterator of at most `limit` substrings of `text` delimited
-    /// by a match of the regular expression. (A `limit` of `0` will return no
-    /// substrings.) Namely, each element of the iterator corresponds to text
-    /// that *isn't* matched by the regular expression. The remainder of the
-    /// string that is not split will be the last element in the iterator.
-    ///
-    /// This method will *not* copy the text given.
-    ///
-    /// # Example
-    ///
-    /// Get the first two words in some text:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"\W+").unwrap();
-    /// let fields: Vec<&str> = re.splitn("Hey! How are you?", 3).collect();
-    /// assert_eq!(fields, vec!("Hey", "How", "are you?"));
-    /// # }
-    /// ```
-    pub fn splitn<'r, 't>(
-        &'r self,
-        text: &'t str,
-        limit: usize,
-    ) -> SplitN<'r, 't> {
-        SplitN { splits: self.split(text), n: limit }
-    }
-
-    /// Replaces the leftmost-first match with the replacement provided.
-    /// The replacement can be a regular string (where `$N` and `$name` are
-    /// expanded to match capture groups) or a function that takes the matches'
-    /// `Captures` and returns the replaced string.
-    ///
-    /// If no match is found, then a copy of the string is returned unchanged.
-    ///
-    /// # Replacement string syntax
-    ///
-    /// All instances of `$name` in the replacement text is replaced with the
-    /// corresponding capture group `name`.
-    ///
-    /// `name` may be an integer corresponding to the index of the
-    /// capture group (counted by order of opening parenthesis where `0` is the
-    /// entire match) or it can be a name (consisting of letters, digits or
-    /// underscores) corresponding to a named capture group.
-    ///
-    /// If `name` isn't a valid capture group (whether the name doesn't exist
-    /// or isn't a valid index), then it is replaced with the empty string.
-    ///
-    /// The longest possible name is used. e.g., `$1a` looks up the capture
-    /// group named `1a` and not the capture group at index `1`. To exert more
-    /// precise control over the name, use braces, e.g., `${1}a`.
-    ///
-    /// To write a literal `$` use `$$`.
-    ///
-    /// # Examples
-    ///
-    /// Note that this function is polymorphic with respect to the replacement.
-    /// In typical usage, this can just be a normal string:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new("[^01]+").unwrap();
-    /// assert_eq!(re.replace("1078910", ""), "1010");
-    /// # }
-    /// ```
-    ///
-    /// But anything satisfying the `Replacer` trait will work. For example,
-    /// a closure of type `|&Captures| -> String` provides direct access to the
-    /// captures corresponding to a match. This allows one to access
-    /// capturing group matches easily:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # use regex::Captures; fn main() {
-    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
-    /// let result = re.replace("Springsteen, Bruce", |caps: &Captures| {
-    ///     format!("{} {}", &caps[2], &caps[1])
-    /// });
-    /// assert_eq!(result, "Bruce Springsteen");
-    /// # }
-    /// ```
-    ///
-    /// But this is a bit cumbersome to use all the time. Instead, a simple
-    /// syntax is supported that expands `$name` into the corresponding capture
-    /// group. Here's the last example, but using this expansion technique
-    /// with named capture groups:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(?P<first>\S+)").unwrap();
-    /// let result = re.replace("Springsteen, Bruce", "$first $last");
-    /// assert_eq!(result, "Bruce Springsteen");
-    /// # }
-    /// ```
-    ///
-    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
-    /// would produce the same result. To write a literal `$` use `$$`.
-    ///
-    /// Sometimes the replacement string requires use of curly braces to
-    /// delineate a capture group replacement and surrounding literal text.
-    /// For example, if we wanted to join two words together with an
-    /// underscore:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let re = Regex::new(r"(?P<first>\w+)\s+(?P<second>\w+)").unwrap();
-    /// let result = re.replace("deep fried", "${first}_$second");
-    /// assert_eq!(result, "deep_fried");
-    /// # }
-    /// ```
-    ///
-    /// Without the curly braces, the capture group name `first_` would be
-    /// used, and since it doesn't exist, it would be replaced with the empty
-    /// string.
-    ///
-    /// Finally, sometimes you just want to replace a literal string with no
-    /// regard for capturing group expansion. This can be done by wrapping a
-    /// byte string with `NoExpand`:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// use regex::NoExpand;
-    ///
-    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(\S+)").unwrap();
-    /// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
-    /// assert_eq!(result, "$2 $last");
-    /// # }
-    /// ```
-    pub fn replace<'t, R: Replacer>(
-        &self,
-        text: &'t str,
-        rep: R,
-    ) -> Cow<'t, str> {
-        self.replacen(text, 1, rep)
-    }
-
-    /// Replaces all non-overlapping matches in `text` with the replacement
-    /// provided. This is the same as calling `replacen` with `limit` set to
-    /// `0`.
-    ///
-    /// See the documentation for `replace` for details on how to access
-    /// capturing group matches in the replacement string.
-    pub fn replace_all<'t, R: Replacer>(
-        &self,
-        text: &'t str,
-        rep: R,
-    ) -> Cow<'t, str> {
-        self.replacen(text, 0, rep)
-    }
-
-    /// Replaces at most `limit` non-overlapping matches in `text` with the
-    /// replacement provided. If `limit` is 0, then all non-overlapping matches
-    /// are replaced.
-    ///
-    /// See the documentation for `replace` for details on how to access
-    /// capturing group matches in the replacement string.
-    pub fn replacen<'t, R: Replacer>(
-        &self,
-        text: &'t str,
-        limit: usize,
-        mut rep: R,
-    ) -> Cow<'t, str> {
-        // If we know that the replacement doesn't have any capture expansions,
-        // then we can use the fast path. The fast path can make a tremendous
-        // difference:
-        //
-        //   1) We use `find_iter` instead of `captures_iter`. Not asking for
-        //      captures generally makes the regex engines faster.
-        //   2) We don't need to look up all of the capture groups and do
-        //      replacements inside the replacement string. We just push it
-        //      at each match and be done with it.
-        if let Some(rep) = rep.no_expansion() {
-            let mut it = self.find_iter(text).enumerate().peekable();
-            if it.peek().is_none() {
-                return Cow::Borrowed(text);
-            }
-            let mut new = String::with_capacity(text.len());
-            let mut last_match = 0;
-            for (i, m) in it {
-                new.push_str(&text[last_match..m.start()]);
-                new.push_str(&rep);
-                last_match = m.end();
-                if limit > 0 && i >= limit - 1 {
-                    break;
-                }
-            }
-            new.push_str(&text[last_match..]);
-            return Cow::Owned(new);
-        }
-
-        // The slower path, which we use if the replacement needs access to
-        // capture groups.
-        let mut it = self.captures_iter(text).enumerate().peekable();
-        if it.peek().is_none() {
-            return Cow::Borrowed(text);
-        }
-        let mut new = String::with_capacity(text.len());
-        let mut last_match = 0;
-        for (i, cap) in it {
-            // unwrap on 0 is OK because captures only reports matches
-            let m = cap.get(0).unwrap();
-            new.push_str(&text[last_match..m.start()]);
-            rep.replace_append(&cap, &mut new);
-            last_match = m.end();
-            if limit > 0 && i >= limit - 1 {
-                break;
-            }
-        }
-        new.push_str(&text[last_match..]);
-        Cow::Owned(new)
-    }
-}
-
-/// Advanced or "lower level" search methods.
-impl Regex {
-    /// Returns the end location of a match in the text given.
-    ///
-    /// This method may have the same performance characteristics as
-    /// `is_match`, except it provides an end location for a match. In
-    /// particular, the location returned *may be shorter* than the proper end
-    /// of the leftmost-first match that you would find via `Regex::find`.
-    ///
-    /// Note that it is not guaranteed that this routine finds the shortest or
-    /// "earliest" possible match. Instead, the main idea of this API is that
-    /// it returns the offset at the point at which the internal regex engine
-    /// has determined that a match has occurred. This may vary depending on
-    /// which internal regex engine is used, and thus, the offset itself may
-    /// change.
-    ///
-    /// # Example
-    ///
-    /// Typically, `a+` would match the entire first sequence of `a` in some
-    /// text, but `shortest_match` can give up as soon as it sees the first
-    /// `a`.
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// # fn main() {
-    /// let text = "aaaaa";
-    /// let pos = Regex::new(r"a+").unwrap().shortest_match(text);
-    /// assert_eq!(pos, Some(1));
-    /// # }
-    /// ```
-    pub fn shortest_match(&self, text: &str) -> Option<usize> {
-        self.shortest_match_at(text, 0)
-    }
-
-    /// Returns the same as `shortest_match`, but starts the search at the
-    /// given offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only match
-    /// when `start == 0`.
-    pub fn shortest_match_at(
-        &self,
-        text: &str,
-        start: usize,
-    ) -> Option<usize> {
-        self.0.searcher_str().shortest_match_at(text, start)
-    }
-
-    /// Returns the same as is_match, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn is_match_at(&self, text: &str, start: usize) -> bool {
-        self.0.searcher_str().is_match_at(text, start)
-    }
-
-    /// Returns the same as find, but starts the search at the given
-    /// offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn find_at<'t>(
-        &self,
-        text: &'t str,
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.0
-            .searcher_str()
-            .find_at(text, start)
-            .map(|(s, e)| Match::new(text, s, e))
-    }
-
-    /// Returns the same as [`Regex::captures`], but starts the search at the
-    /// given offset.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn captures_at<'t>(
-        &self,
-        text: &'t str,
-        start: usize,
-    ) -> Option<Captures<'t>> {
-        let mut locs = self.capture_locations();
-        self.captures_read_at(&mut locs, text, start).map(move |_| Captures {
-            text,
-            locs: locs.0,
-            named_groups: self.0.capture_name_idx().clone(),
-        })
-    }
-
-    /// This is like `captures`, but uses
-    /// [`CaptureLocations`](struct.CaptureLocations.html)
-    /// instead of
-    /// [`Captures`](struct.Captures.html) in order to amortize allocations.
-    ///
-    /// To create a `CaptureLocations` value, use the
-    /// `Regex::capture_locations` method.
-    ///
-    /// This returns the overall match if this was successful, which is always
-    /// equivalence to the `0`th capture group.
-    pub fn captures_read<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t str,
-    ) -> Option<Match<'t>> {
-        self.captures_read_at(locs, text, 0)
-    }
-
-    /// Returns the same as captures, but starts the search at the given
-    /// offset and populates the capture locations given.
-    ///
-    /// The significance of the starting point is that it takes the surrounding
-    /// context into consideration. For example, the `\A` anchor can only
-    /// match when `start == 0`.
-    pub fn captures_read_at<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t str,
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.0
-            .searcher_str()
-            .captures_read_at(&mut locs.0, text, start)
-            .map(|(s, e)| Match::new(text, s, e))
-    }
-
-    /// An undocumented alias for `captures_read_at`.
-    ///
-    /// The `regex-capi` crate previously used this routine, so to avoid
-    /// breaking that crate, we continue to provide the name as an undocumented
-    /// alias.
-    #[doc(hidden)]
-    pub fn read_captures_at<'t>(
-        &self,
-        locs: &mut CaptureLocations,
-        text: &'t str,
-        start: usize,
-    ) -> Option<Match<'t>> {
-        self.captures_read_at(locs, text, start)
-    }
-}
-
-/// Auxiliary methods.
-impl Regex {
-    /// Returns the original string of this regex.
-    pub fn as_str(&self) -> &str {
-        &self.0.regex_strings()[0]
-    }
-
-    /// Returns an iterator over the capture names.
-    pub fn capture_names(&self) -> CaptureNames<'_> {
-        CaptureNames(self.0.capture_names().iter())
-    }
-
-    /// Returns the number of captures.
-    pub fn captures_len(&self) -> usize {
-        self.0.capture_names().len()
-    }
-
-    /// Returns the total number of capturing groups that appear in every
-    /// possible match.
-    ///
-    /// If the number of capture groups can vary depending on the match, then
-    /// this returns `None`. That is, a value is only returned when the number
-    /// of matching groups is invariant or "static."
-    ///
-    /// Note that like [`Regex::captures_len`], this **does** include the
-    /// implicit capturing group corresponding to the entire match. Therefore,
-    /// when a non-None value is returned, it is guaranteed to be at least `1`.
-    /// Stated differently, a return value of `Some(0)` is impossible.
-    ///
-    /// # Example
-    ///
-    /// This shows a few cases where a static number of capture groups is
-    /// available and a few cases where it is not.
-    ///
-    /// ```
-    /// use regex::Regex;
-    ///
-    /// let len = |pattern| {
-    ///     Regex::new(pattern).map(|re| re.static_captures_len())
-    /// };
-    ///
-    /// assert_eq!(Some(1), len("a")?);
-    /// assert_eq!(Some(2), len("(a)")?);
-    /// assert_eq!(Some(2), len("(a)|(b)")?);
-    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
-    /// assert_eq!(None, len("(a)|b")?);
-    /// assert_eq!(None, len("a|(b)")?);
-    /// assert_eq!(None, len("(b)*")?);
-    /// assert_eq!(Some(2), len("(b)+")?);
-    ///
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
-    /// ```
-    #[inline]
-    pub fn static_captures_len(&self) -> Option<usize> {
-        self.0.static_captures_len().map(|len| len.saturating_add(1))
-    }
-
-    /// Returns an empty set of capture locations that can be reused in
-    /// multiple calls to `captures_read` or `captures_read_at`.
-    pub fn capture_locations(&self) -> CaptureLocations {
-        CaptureLocations(self.0.searcher_str().locations())
-    }
-
-    /// An alias for `capture_locations` to preserve backward compatibility.
-    ///
-    /// The `regex-capi` crate uses this method, so to avoid breaking that
-    /// crate, we continue to export it as an undocumented API.
-    #[doc(hidden)]
-    pub fn locations(&self) -> CaptureLocations {
-        CaptureLocations(self.0.searcher_str().locations())
-    }
-}
-
-/// An iterator over the names of all possible captures.
-///
-/// `None` indicates an unnamed capture; the first element (capture 0, the
-/// whole matched region) is always unnamed.
-///
-/// `'r` is the lifetime of the compiled regular expression.
-#[derive(Clone, Debug)]
-pub struct CaptureNames<'r>(::std::slice::Iter<'r, Option<String>>);
-
-impl<'r> Iterator for CaptureNames<'r> {
-    type Item = Option<&'r str>;
-
-    fn next(&mut self) -> Option<Option<&'r str>> {
-        self.0
-            .next()
-            .as_ref()
-            .map(|slot| slot.as_ref().map(|name| name.as_ref()))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-
-    fn count(self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<'r> ExactSizeIterator for CaptureNames<'r> {}
-
-impl<'r> FusedIterator for CaptureNames<'r> {}
-
-/// Yields all substrings delimited by a regular expression match.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the string being split.
-#[derive(Debug)]
-pub struct Split<'r, 't> {
-    finder: Matches<'r, 't>,
-    last: usize,
-}
-
-impl<'r, 't> Iterator for Split<'r, 't> {
-    type Item = &'t str;
-
-    fn next(&mut self) -> Option<&'t str> {
-        let text = self.finder.0.text();
-        match self.finder.next() {
-            None => {
-                if self.last > text.len() {
-                    None
-                } else {
-                    let s = &text[self.last..];
-                    self.last = text.len() + 1; // Next call will return None
-                    Some(s)
-                }
-            }
-            Some(m) => {
-                let matched = &text[self.last..m.start()];
-                self.last = m.end();
-                Some(matched)
-            }
-        }
-    }
-}
-
-impl<'r, 't> FusedIterator for Split<'r, 't> {}
-
-/// Yields at most `N` substrings delimited by a regular expression match.
-///
-/// The last substring will be whatever remains after splitting.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the string being split.
-#[derive(Debug)]
-pub struct SplitN<'r, 't> {
-    splits: Split<'r, 't>,
-    n: usize,
-}
-
-impl<'r, 't> Iterator for SplitN<'r, 't> {
-    type Item = &'t str;
-
-    fn next(&mut self) -> Option<&'t str> {
-        if self.n == 0 {
-            return None;
-        }
-
-        self.n -= 1;
-        if self.n > 0 {
-            return self.splits.next();
-        }
-
-        let text = self.splits.finder.0.text();
-        if self.splits.last > text.len() {
-            // We've already returned all substrings.
-            None
-        } else {
-            // self.n == 0, so future calls will return None immediately
-            Some(&text[self.splits.last..])
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.n))
-    }
-}
-
-impl<'r, 't> FusedIterator for SplitN<'r, 't> {}
-
-/// CaptureLocations is a low level representation of the raw offsets of each
-/// submatch.
-///
-/// You can think of this as a lower level
-/// [`Captures`](struct.Captures.html), where this type does not support
-/// named capturing groups directly and it does not borrow the text that these
-/// offsets were matched on.
-///
-/// Primarily, this type is useful when using the lower level `Regex` APIs
-/// such as `read_captures`, which permits amortizing the allocation in which
-/// capture match locations are stored.
-///
-/// In order to build a value of this type, you'll need to call the
-/// `capture_locations` method on the `Regex` being used to execute the search.
-/// The value returned can then be reused in subsequent searches.
-///
-/// # Example
-///
-/// This example shows how to create and use `CaptureLocations` in a search.
-///
-/// ```
-/// use regex::Regex;
-///
-/// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
-/// let mut locs = re.capture_locations();
-/// let m = re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
-/// assert_eq!(0..17, m.range());
-/// assert_eq!(Some((0, 17)), locs.get(0));
-/// assert_eq!(Some((0, 5)), locs.get(1));
-/// assert_eq!(Some((6, 17)), locs.get(2));
-///
-/// // Asking for an invalid capture group always returns None.
-/// assert_eq!(None, locs.get(3));
-/// assert_eq!(None, locs.get(34973498648));
-/// assert_eq!(None, locs.get(9944060567225171988));
-/// ```
-#[derive(Clone, Debug)]
-pub struct CaptureLocations(re_trait::Locations);
-
-/// A type alias for `CaptureLocations` for backwards compatibility.
-///
-/// Previously, we exported `CaptureLocations` as `Locations` in an
-/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
-/// we continue re-exporting the same undocumented API.
-#[doc(hidden)]
-pub type Locations = CaptureLocations;
-
-impl CaptureLocations {
-    /// Returns the start and end positions of the Nth capture group. Returns
-    /// `None` if `i` is not a valid capture group or if the capture group did
-    /// not match anything. The positions returned are *always* byte indices
-    /// with respect to the original string matched.
-    #[inline]
-    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
-        self.0.pos(i)
-    }
-
-    /// Returns the total number of capture groups (even if they didn't match).
-    ///
-    /// This is always at least `1` since every regex has at least `1`
-    /// capturing group that corresponds to the entire match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    /// An alias for the `get` method for backwards compatibility.
-    ///
-    /// Previously, we exported `get` as `pos` in an undocumented API. To
-    /// prevent breaking that code (e.g., in `regex-capi`), we continue
-    /// re-exporting the same undocumented API.
-    #[doc(hidden)]
-    #[inline]
-    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
-        self.get(i)
-    }
-}
-
-/// Captures represents a group of captured strings for a single match.
-///
-/// The 0th capture always corresponds to the entire match. Each subsequent
-/// index corresponds to the next capture group in the regex. If a capture
-/// group is named, then the matched string is *also* available via the `name`
-/// method. (Note that the 0th capture is always unnamed and so must be
-/// accessed with the `get` method.)
-///
-/// Positions returned from a capture group are always byte indices.
-///
-/// `'t` is the lifetime of the matched text.
-pub struct Captures<'t> {
-    text: &'t str,
-    locs: re_trait::Locations,
-    named_groups: Arc<HashMap<String, usize>>,
-}
-
-impl<'t> Captures<'t> {
-    /// Returns the match associated with the capture group at index `i`. If
-    /// `i` does not correspond to a capture group, or if the capture group
-    /// did not participate in the match, then `None` is returned.
-    ///
-    /// # Examples
-    ///
-    /// Get the text of the match with a default of an empty string if this
-    /// group didn't participate in the match:
-    ///
-    /// ```rust
-    /// # use regex::Regex;
-    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
-    /// let caps = re.captures("abc123").unwrap();
-    ///
-    /// let text1 = caps.get(1).map_or("", |m| m.as_str());
-    /// let text2 = caps.get(2).map_or("", |m| m.as_str());
-    /// assert_eq!(text1, "123");
-    /// assert_eq!(text2, "");
-    /// ```
-    pub fn get(&self, i: usize) -> Option<Match<'t>> {
-        self.locs.pos(i).map(|(s, e)| Match::new(self.text, s, e))
-    }
-
-    /// Returns the match for the capture group named `name`. If `name` isn't a
-    /// valid capture group or didn't match anything, then `None` is returned.
-    pub fn name(&self, name: &str) -> Option<Match<'t>> {
-        self.named_groups.get(name).and_then(|&i| self.get(i))
-    }
-
-    /// An iterator that yields all capturing matches in the order in which
-    /// they appear in the regex. If a particular capture group didn't
-    /// participate in the match, then `None` is yielded for that capture.
-    ///
-    /// The first match always corresponds to the overall match of the regex.
-    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 't> {
-        SubCaptureMatches { caps: self, it: self.locs.iter() }
-    }
-
-    /// Expands all instances of `$name` in `replacement` to the corresponding
-    /// capture group `name`, and writes them to the `dst` buffer given.
-    ///
-    /// `name` may be an integer corresponding to the index of the capture
-    /// group (counted by order of opening parenthesis where `0` is the
-    /// entire match) or it can be a name (consisting of letters, digits or
-    /// underscores) corresponding to a named capture group.
-    ///
-    /// If `name` isn't a valid capture group (whether the name doesn't exist
-    /// or isn't a valid index), then it is replaced with the empty string.
-    ///
-    /// The longest possible name consisting of the characters `[_0-9A-Za-z]`
-    /// is used. e.g., `$1a` looks up the capture group named `1a` and not the
-    /// capture group at index `1`. To exert more precise control over the
-    /// name, or to refer to a capture group name that uses characters outside
-    /// of `[_0-9A-Za-z]`, use braces, e.g., `${1}a` or `${foo[bar].baz}`. When
-    /// using braces, any sequence of characters is permitted. If the sequence
-    /// does not refer to a capture group name in the corresponding regex, then
-    /// it is replaced with an empty string.
-    ///
-    /// To write a literal `$` use `$$`.
-    pub fn expand(&self, replacement: &str, dst: &mut String) {
-        expand_str(self, replacement, dst)
-    }
-
-    /// Returns the total number of capture groups (even if they didn't match).
-    ///
-    /// This is always at least `1`, since every regex has at least one capture
-    /// group that corresponds to the full match.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.locs.len()
-    }
-}
-
-impl<'t> fmt::Debug for Captures<'t> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("Captures").field(&CapturesDebug(self)).finish()
-    }
-}
-
-struct CapturesDebug<'c, 't>(&'c Captures<'t>);
-
-impl<'c, 't> fmt::Debug for CapturesDebug<'c, 't> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // We'd like to show something nice here, even if it means an
-        // allocation to build a reverse index.
-        let slot_to_name: HashMap<&usize, &String> =
-            self.0.named_groups.iter().map(|(a, b)| (b, a)).collect();
-        let mut map = f.debug_map();
-        for (slot, m) in self.0.locs.iter().enumerate() {
-            let m = m.map(|(s, e)| &self.0.text[s..e]);
-            if let Some(name) = slot_to_name.get(&slot) {
-                map.entry(&name, &m);
-            } else {
-                map.entry(&slot, &m);
-            }
-        }
-        map.finish()
-    }
-}
-
-/// Get a group by index.
-///
-/// `'t` is the lifetime of the matched text.
-///
-/// The text can't outlive the `Captures` object if this method is
-/// used, because of how `Index` is defined (normally `a[i]` is part
-/// of `a` and can't outlive it); to do that, use `get()` instead.
-///
-/// # Panics
-///
-/// If there is no group at the given index.
-impl<'t> Index<usize> for Captures<'t> {
-    type Output = str;
-
-    fn index(&self, i: usize) -> &str {
-        self.get(i)
-            .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group at index '{}'", i))
-    }
-}
-
-/// Get a group by name.
-///
-/// `'t` is the lifetime of the matched text and `'i` is the lifetime
-/// of the group name (the index).
-///
-/// The text can't outlive the `Captures` object if this method is
-/// used, because of how `Index` is defined (normally `a[i]` is part
-/// of `a` and can't outlive it); to do that, use `name` instead.
-///
-/// # Panics
-///
-/// If there is no group named by the given value.
-impl<'t, 'i> Index<&'i str> for Captures<'t> {
-    type Output = str;
-
-    fn index<'a>(&'a self, name: &'i str) -> &'a str {
-        self.name(name)
-            .map(|m| m.as_str())
-            .unwrap_or_else(|| panic!("no group named '{}'", name))
-    }
-}
-
-/// An iterator that yields all capturing matches in the order in which they
-/// appear in the regex.
-///
-/// If a particular capture group didn't participate in the match, then `None`
-/// is yielded for that capture. The first match always corresponds to the
-/// overall match of the regex.
-///
-/// The lifetime `'c` corresponds to the lifetime of the `Captures` value, and
-/// the lifetime `'t` corresponds to the originally matched text.
-#[derive(Clone, Debug)]
-pub struct SubCaptureMatches<'c, 't> {
-    caps: &'c Captures<'t>,
-    it: SubCapturesPosIter<'c>,
-}
-
-impl<'c, 't> Iterator for SubCaptureMatches<'c, 't> {
-    type Item = Option<Match<'t>>;
-
-    fn next(&mut self) -> Option<Option<Match<'t>>> {
-        self.it
-            .next()
-            .map(|cap| cap.map(|(s, e)| Match::new(self.caps.text, s, e)))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.it.size_hint()
-    }
-
-    fn count(self) -> usize {
-        self.it.count()
-    }
-}
-
-impl<'c, 't> ExactSizeIterator for SubCaptureMatches<'c, 't> {}
-
-impl<'c, 't> FusedIterator for SubCaptureMatches<'c, 't> {}
-
-/// An iterator that yields all non-overlapping capture groups matching a
-/// particular regular expression.
-///
-/// The iterator stops when no more matches can be found.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the matched string.
-#[derive(Debug)]
-pub struct CaptureMatches<'r, 't>(
-    re_trait::CaptureMatches<'t, ExecNoSyncStr<'r>>,
-);
-
-impl<'r, 't> Iterator for CaptureMatches<'r, 't> {
-    type Item = Captures<'t>;
-
-    fn next(&mut self) -> Option<Captures<'t>> {
-        self.0.next().map(|locs| Captures {
-            text: self.0.text(),
-            locs,
-            named_groups: self.0.regex().capture_name_idx().clone(),
-        })
-    }
-}
-
-impl<'r, 't> FusedIterator for CaptureMatches<'r, 't> {}
-
-/// An iterator over all non-overlapping matches for a particular string.
-///
-/// The iterator yields a `Match` value. The iterator stops when no more
-/// matches can be found.
-///
-/// `'r` is the lifetime of the compiled regular expression and `'t` is the
-/// lifetime of the matched string.
-#[derive(Debug)]
-pub struct Matches<'r, 't>(re_trait::Matches<'t, ExecNoSyncStr<'r>>);
-
-impl<'r, 't> Iterator for Matches<'r, 't> {
-    type Item = Match<'t>;
-
-    fn next(&mut self) -> Option<Match<'t>> {
-        let text = self.0.text();
-        self.0.next().map(|(s, e)| Match::new(text, s, e))
-    }
-}
-
-impl<'r, 't> FusedIterator for Matches<'r, 't> {}
-
-/// Replacer describes types that can be used to replace matches in a string.
-///
-/// In general, users of this crate shouldn't need to implement this trait,
-/// since implementations are already provided for `&str` along with other
-/// variants of string types and `FnMut(&Captures) -> String` (or any
-/// `FnMut(&Captures) -> T` where `T: AsRef<str>`), which covers most use cases.
-pub trait Replacer {
-    /// Appends text to `dst` to replace the current match.
-    ///
-    /// The current match is represented by `caps`, which is guaranteed to
-    /// have a match at capture group `0`.
-    ///
-    /// For example, a no-op replacement would be
-    /// `dst.push_str(caps.get(0).unwrap().as_str())`.
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String);
-
-    /// Return a fixed unchanging replacement string.
-    ///
-    /// When doing replacements, if access to `Captures` is not needed (e.g.,
-    /// the replacement byte string does not need `$` expansion), then it can
-    /// be beneficial to avoid finding sub-captures.
-    ///
-    /// In general, this is called once for every call to `replacen`.
-    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, str>> {
-        None
-    }
-
-    /// Return a `Replacer` that borrows and wraps this `Replacer`.
-    ///
-    /// This is useful when you want to take a generic `Replacer` (which might
-    /// not be cloneable) and use it without consuming it, so it can be used
-    /// more than once.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use regex::{Regex, Replacer};
-    ///
-    /// fn replace_all_twice<R: Replacer>(
-    ///     re: Regex,
-    ///     src: &str,
-    ///     mut rep: R,
-    /// ) -> String {
-    ///     let dst = re.replace_all(src, rep.by_ref());
-    ///     let dst = re.replace_all(&dst, rep.by_ref());
-    ///     dst.into_owned()
-    /// }
-    /// ```
-    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
-        ReplacerRef(self)
-    }
-}
-
-/// By-reference adaptor for a `Replacer`
-///
-/// Returned by [`Replacer::by_ref`](trait.Replacer.html#method.by_ref).
-#[derive(Debug)]
-pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
-
-impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        self.0.replace_append(caps, dst)
-    }
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        self.0.no_expansion()
-    }
-}
-
-impl<'a> Replacer for &'a str {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        caps.expand(*self, dst);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for &'a String {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        self.as_str().replace_append(caps, dst)
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        no_expansion(self)
-    }
-}
-
-impl Replacer for String {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        self.as_str().replace_append(caps, dst)
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for Cow<'a, str> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        self.as_ref().replace_append(caps, dst)
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        no_expansion(self)
-    }
-}
-
-impl<'a> Replacer for &'a Cow<'a, str> {
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        self.as_ref().replace_append(caps, dst)
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        no_expansion(self)
-    }
-}
-
-fn no_expansion<T: AsRef<str>>(t: &T) -> Option<Cow<'_, str>> {
-    let s = t.as_ref();
-    match find_byte(b'$', s.as_bytes()) {
-        Some(_) => None,
-        None => Some(Cow::Borrowed(s)),
-    }
-}
-
-impl<F, T> Replacer for F
-where
-    F: FnMut(&Captures<'_>) -> T,
-    T: AsRef<str>,
-{
-    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
-        dst.push_str((*self)(caps).as_ref());
-    }
-}
-
-/// `NoExpand` indicates literal string replacement.
-///
-/// It can be used with `replace` and `replace_all` to do a literal string
-/// replacement without expanding `$name` to their corresponding capture
-/// groups. This can be both convenient (to avoid escaping `$`, for example)
-/// and performant (since capture groups don't need to be found).
-///
-/// `'t` is the lifetime of the literal text.
-#[derive(Clone, Debug)]
-pub struct NoExpand<'t>(pub &'t str);
-
-impl<'t> Replacer for NoExpand<'t> {
-    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut String) {
-        dst.push_str(self.0);
-    }
-
-    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
-        Some(Cow::Borrowed(self.0))
-    }
-}
diff --git a/src/regex/bytes.rs b/src/regex/bytes.rs
new file mode 100644
index 0000000000..fc4238bcd9
--- /dev/null
+++ b/src/regex/bytes.rs
@@ -0,0 +1,2579 @@
+use alloc::{borrow::Cow, sync::Arc, vec::Vec};
+
+use regex_automata::{meta, util::captures, Input, PatternID};
+
+use crate::{bytes::RegexBuilder, error::Error};
+
+/// A compiled regular expression for searching Unicode haystacks.
+///
+/// A `Regex` can be used to search haystacks, split haystacks into substrings
+/// or replace substrings in a haystack with a different substring. All
+/// searching is done with an implicit `(?s:.)*?` at the beginning and end of
+/// an pattern. To force an expression to match the whole string (or a prefix
+/// or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`).
+///
+/// Like the `Regex` type in the parent module, matches with this regex return
+/// byte offsets into the haystack. **Unlike** the parent `Regex` type, these
+/// byte offsets may not correspond to UTF-8 sequence boundaries since the
+/// regexes in this module can match arbitrary bytes.
+///
+/// The only methods that allocate new byte strings are the string replacement
+/// methods. All other methods (searching and splitting) return borrowed
+/// references into the haystack given.
+///
+/// # Example
+///
+/// Find the offsets of a US phone number:
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();
+/// let m = re.find(b"phone: 111-222-3333").unwrap();
+/// assert_eq!(7..19, m.range());
+/// ```
+///
+/// # Example: extracting capture groups
+///
+/// A common way to use regexes is with capture groups. That is, instead of
+/// just looking for matches of an entire regex, parentheses are used to create
+/// groups that represent part of the match.
+///
+/// For example, consider a haystack with multiple lines, and each line has
+/// three whitespace delimited fields where the second field is expected to be
+/// a number and the third field a boolean. To make this convenient, we use
+/// the [`Captures::extract`] API to put the strings that match each group
+/// into a fixed size array:
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// let hay = b"
+/// rabbit         54 true
+/// groundhog 2 true
+/// does not match
+/// fox   109    false
+/// ";
+/// let re = Regex::new(r"(?m)^\s*(\S+)\s+([0-9]+)\s+(true|false)\s*$").unwrap();
+/// let mut fields: Vec<(&[u8], i64, bool)> = vec![];
+/// for (_, [f1, f2, f3]) in re.captures_iter(hay).map(|caps| caps.extract()) {
+///     // These unwraps are OK because our pattern is written in a way where
+///     // all matches for f2 and f3 will be valid UTF-8.
+///     let f2 = std::str::from_utf8(f2).unwrap();
+///     let f3 = std::str::from_utf8(f3).unwrap();
+///     fields.push((f1, f2.parse()?, f3.parse()?));
+/// }
+/// assert_eq!(fields, vec![
+///     (&b"rabbit"[..], 54, true),
+///     (&b"groundhog"[..], 2, true),
+///     (&b"fox"[..], 109, false),
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: matching invalid UTF-8
+///
+/// One of the reasons for searching `&[u8]` haystacks is that the `&[u8]`
+/// might not be valid UTF-8. Indeed, with a `bytes::Regex`, patterns that
+/// match invalid UTF-8 are explicitly allowed. Here's one example that looks
+/// for valid UTF-8 fields that might be separated by invalid UTF-8. In this
+/// case, we use `(?s-u:.)`, which matches any byte. Attempting to use it in a
+/// top-level `Regex` will result in the regex failing to compile. Notice also
+/// that we use `.` with Unicode mode enabled, in which case, only valid UTF-8
+/// is matched. In this way, we can build one pattern where some parts only
+/// match valid UTF-8 while other parts are more permissive.
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// // F0 9F 92 A9 is the UTF-8 encoding for a Pile of Poo.
+/// let hay = b"\xFF\xFFfoo\xFF\xFF\xFF\xF0\x9F\x92\xA9\xFF";
+/// // An equivalent to '(?s-u:.)' is '(?-u:[\x00-\xFF])'.
+/// let re = Regex::new(r"(?s)(?-u:.)*?(?<f1>.+)(?-u:.)*?(?<f2>.+)").unwrap();
+/// let caps = re.captures(hay).unwrap();
+/// assert_eq!(&caps["f1"], &b"foo"[..]);
+/// assert_eq!(&caps["f2"], "💩".as_bytes());
+/// ```
+#[derive(Clone)]
+pub struct Regex {
+    pub(crate) meta: meta::Regex,
+    pub(crate) pattern: Arc<str>,
+}
+
+impl core::fmt::Display for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl core::fmt::Debug for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("Regex").field(&self.as_str()).finish()
+    }
+}
+
+impl core::str::FromStr for Regex {
+    type Err = Error;
+
+    /// Attempts to parse a string into a regular expression
+    fn from_str(s: &str) -> Result<Regex, Error> {
+        Regex::new(s)
+    }
+}
+
+/// Core regular expression methods.
+impl Regex {
+    /// Compiles a regular expression. Once compiled, it can be used repeatedly
+    /// to search, split or replace substrings in a haystack.
+    ///
+    /// Note that regex compilation tends to be a somewhat expensive process,
+    /// and unlike higher level environments, compilation is not automatically
+    /// cached for you. One should endeavor to compile a regex once and then
+    /// reuse it. For example, it's a bad idea to compile the same regex
+    /// repeatedly in a loop.
+    ///
+    /// # Errors
+    ///
+    /// If an invalid pattern is given, then an error is returned.
+    /// An error is also returned if the pattern is valid, but would
+    /// produce a regex that is bigger than the configured size limit via
+    /// [`RegexBuilder::size_limit`]. (A reasonable size limit is enabled by
+    /// default.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// // An Invalid pattern because of an unclosed parenthesis
+    /// assert!(Regex::new(r"foo(bar").is_err());
+    /// // An invalid pattern because the regex would be too big
+    /// // because Unicode tends to inflate things.
+    /// assert!(Regex::new(r"\w{1000}").is_err());
+    /// // Disabling Unicode can make the regex much smaller,
+    /// // potentially by up to or more than an order of magnitude.
+    /// assert!(Regex::new(r"(?-u:\w){1000}").is_ok());
+    /// ```
+    pub fn new(re: &str) -> Result<Regex, Error> {
+        RegexBuilder::new(re).build()
+    }
+
+    /// Returns true if and only if there is a match for the regex anywhere
+    /// in the haystack given.
+    ///
+    /// It is recommended to use this method if all you need to do is test
+    /// whether a match exists, since the underlying matching engine may be
+    /// able to do less work.
+    ///
+    /// # Example
+    ///
+    /// Test if some haystack contains at least one word with exactly 13
+    /// Unicode word characters:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = b"I categorically deny having triskaidekaphobia.";
+    /// assert!(re.is_match(hay));
+    /// ```
+    #[inline]
+    pub fn is_match(&self, haystack: &[u8]) -> bool {
+        self.is_match_at(haystack, 0)
+    }
+
+    /// This routine searches for the first match of this regex in the
+    /// haystack given, and if found, returns a [`Match`]. The `Match`
+    /// provides access to both the byte offsets of the match and the actual
+    /// substring that matched.
+    ///
+    /// Note that this should only be used if you want to find the entire
+    /// match. If instead you just want to test the existence of a match,
+    /// it's potentially faster to use `Regex::is_match(hay)` instead of
+    /// `Regex::find(hay).is_some()`.
+    ///
+    /// # Example
+    ///
+    /// Find the first word with exactly 13 Unicode word characters:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = b"I categorically deny having triskaidekaphobia.";
+    /// let mat = re.find(hay).unwrap();
+    /// assert_eq!(2..15, mat.range());
+    /// assert_eq!(b"categorically", mat.as_bytes());
+    /// ```
+    #[inline]
+    pub fn find<'h>(&self, haystack: &'h [u8]) -> Option<Match<'h>> {
+        self.find_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Match`].
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `find_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// Find every word with exactly 13 Unicode word characters:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = b"Retroactively relinquishing remunerations is reprehensible.";
+    /// let matches: Vec<_> = re.find_iter(hay).map(|m| m.as_bytes()).collect();
+    /// assert_eq!(matches, vec![
+    ///     &b"Retroactively"[..],
+    ///     &b"relinquishing"[..],
+    ///     &b"remunerations"[..],
+    ///     &b"reprehensible"[..],
+    /// ]);
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'h>(&'r self, haystack: &'h [u8]) -> Matches<'r, 'h> {
+        Matches { haystack, it: self.meta.find_iter(haystack) }
+    }
+
+    /// This routine searches for the first match of this regex in the haystack
+    /// given, and if found, returns not only the overall match but also the
+    /// matches of each capture group in the regex. If no match is found, then
+    /// `None` is returned.
+    ///
+    /// Capture group `0` always corresponds to an implicit unnamed group that
+    /// includes the entire match. If a match is found, this group is always
+    /// present. Subsequent groups may be named and are numbered, starting
+    /// at 1, by the order in which the opening parenthesis appears in the
+    /// pattern. For example, in the pattern `(?<a>.(?<b>.))(?<c>.)`, `a`,
+    /// `b` and `c` correspond to capture group indices `1`, `2` and `3`,
+    /// respectively.
+    ///
+    /// You should only use `captures` if you need access to the capture group
+    /// matches. Otherwise, [`Regex::find`] is generally faster for discovering
+    /// just the overall match.
+    ///
+    /// # Example
+    ///
+    /// Say you have some haystack with movie names and their release years,
+    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for
+    /// strings looking like that, while also extracting the movie name and its
+    /// release year separately. The example below shows how to do that.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = b"Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_bytes(), b"'Citizen Kane' (1941)");
+    /// assert_eq!(caps.get(1).unwrap().as_bytes(), b"Citizen Kane");
+    /// assert_eq!(caps.get(2).unwrap().as_bytes(), b"1941");
+    /// // You can also access the groups by index using the Index notation.
+    /// // Note that this will panic on an invalid index. In this case, these
+    /// // accesses are always correct because the overall regex will only
+    /// // match when these capture groups match.
+    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
+    /// assert_eq!(&caps[1], b"Citizen Kane");
+    /// assert_eq!(&caps[2], b"1941");
+    /// ```
+    ///
+    /// Note that the full match is at capture group `0`. Each subsequent
+    /// capture group is indexed by the order of its opening `(`.
+    ///
+    /// We can make this example a bit clearer by using *named* capture groups:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>\d{4})\)").unwrap();
+    /// let hay = b"Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_bytes(), b"'Citizen Kane' (1941)");
+    /// assert_eq!(caps.name("title").unwrap().as_bytes(), b"Citizen Kane");
+    /// assert_eq!(caps.name("year").unwrap().as_bytes(), b"1941");
+    /// // You can also access the groups by name using the Index notation.
+    /// // Note that this will panic on an invalid group name. In this case,
+    /// // these accesses are always correct because the overall regex will
+    /// // only match when these capture groups match.
+    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
+    /// assert_eq!(&caps["title"], b"Citizen Kane");
+    /// assert_eq!(&caps["year"], b"1941");
+    /// ```
+    ///
+    /// Here we name the capture groups, which we can access with the `name`
+    /// method or the `Index` notation with a `&str`. Note that the named
+    /// capture groups are still accessible with `get` or the `Index` notation
+    /// with a `usize`.
+    ///
+    /// The `0`th capture group is always unnamed, so it must always be
+    /// accessed with `get(0)` or `[0]`.
+    ///
+    /// Finally, one other way to to get the matched substrings is with the
+    /// [`Captures::extract`] API:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = b"Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let (full, [title, year]) = re.captures(hay).unwrap().extract();
+    /// assert_eq!(full, b"'Citizen Kane' (1941)");
+    /// assert_eq!(title, b"Citizen Kane");
+    /// assert_eq!(year, b"1941");
+    /// ```
+    #[inline]
+    pub fn captures<'h>(&self, haystack: &'h [u8]) -> Option<Captures<'h>> {
+        self.captures_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Captures`].
+    ///
+    /// This is the same as [`Regex::find_iter`], but instead of only providing
+    /// access to the overall match, each value yield includes access to the
+    /// matches of all capture groups in the regex. Reporting this extra match
+    /// data is potentially costly, so callers should only use `captures_iter`
+    /// over `find_iter` when they actually need access to the capture group
+    /// matches.
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `captures_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// We can use this to find all movie titles and their release years in
+    /// some haystack, where the movie is formatted like "'Title' (xxxx)":
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\(([0-9]{4})\)").unwrap();
+    /// let hay = b"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut movies = vec![];
+    /// for (_, [title, year]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     // OK because [0-9]{4} can only match valid UTF-8.
+    ///     let year = std::str::from_utf8(year).unwrap();
+    ///     movies.push((title, year.parse::<i64>()?));
+    /// }
+    /// assert_eq!(movies, vec![
+    ///     (&b"Citizen Kane"[..], 1941),
+    ///     (&b"The Wizard of Oz"[..], 1939),
+    ///     (&b"M"[..], 1931),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Or with named groups:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>[0-9]{4})\)").unwrap();
+    /// let hay = b"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut it = re.captures_iter(hay);
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], b"Citizen Kane");
+    /// assert_eq!(&caps["year"], b"1941");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], b"The Wizard of Oz");
+    /// assert_eq!(&caps["year"], b"1939");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], b"M");
+    /// assert_eq!(&caps["year"], b"1931");
+    /// ```
+    #[inline]
+    pub fn captures_iter<'r, 'h>(
+        &'r self,
+        haystack: &'h [u8],
+    ) -> CaptureMatches<'r, 'h> {
+        CaptureMatches { haystack, it: self.meta.captures_iter(haystack) }
+    }
+
+    /// Returns an iterator of substrings of the haystack given, delimited by a
+    /// match of the regex. Namely, each element of the iterator corresponds to
+    /// a part of the haystack that *isn't* matched by the regular expression.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"[ \t]+").unwrap();
+    /// let hay = b"a b \t  c\td    e";
+    /// let fields: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(fields, vec![
+    ///     &b"a"[..], &b"b"[..], &b"c"[..], &b"d"[..], &b"e"[..],
+    /// ]);
+    /// ```
+    ///
+    /// # Example: more cases
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = b"Mary had a little lamb";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![
+    ///     &b"Mary"[..], &b"had"[..], &b"a"[..], &b"little"[..], &b"lamb"[..],
+    /// ]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![&b""[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"lionXXtigerXleopard";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![
+    ///     &b"lion"[..], &b""[..], &b"tiger"[..], &b"leopard"[..],
+    /// ]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = b"lion::tiger::leopard";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![&b"lion"[..], &b"tiger"[..], &b"leopard"[..]]);
+    /// ```
+    ///
+    /// If a haystack contains multiple contiguous matches, you will end up
+    /// with empty spans yielded by the iterator:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"XXXXaXXbXc";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![
+    ///     &b""[..], &b""[..], &b""[..], &b""[..],
+    ///     &b"a"[..], &b""[..], &b"b"[..], &b"c"[..],
+    /// ]);
+    ///
+    /// let re = Regex::new(r"/").unwrap();
+    /// let hay = b"(///)";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![&b"("[..], &b""[..], &b""[..], &b")"[..]]);
+    /// ```
+    ///
+    /// Separators at the start or end of a haystack are neighbored by empty
+    /// substring.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"0").unwrap();
+    /// let hay = b"010";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![&b""[..], &b"1"[..], &b""[..]]);
+    /// ```
+    ///
+    /// When the regex can match the empty string, it splits at every byte
+    /// position in the haystack. This includes between all UTF-8 code units.
+    /// (The top-level [`Regex::split`](crate::Regex::split) will only split
+    /// at valid UTF-8 boundaries.)
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let hay = "☃".as_bytes();
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![
+    ///     &[][..], &[b'\xE2'][..], &[b'\x98'][..], &[b'\x83'][..], &[][..],
+    /// ]);
+    /// ```
+    ///
+    /// Contiguous separators (commonly shows up with whitespace), can lead to
+    /// possibly surprising behavior. For example, this code is correct:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = b"    a  b c";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// assert_eq!(got, vec![
+    ///     &b""[..], &b""[..], &b""[..], &b""[..],
+    ///     &b"a"[..], &b""[..], &b"b"[..], &b"c"[..],
+    /// ]);
+    /// ```
+    ///
+    /// It does *not* give you `["a", "b", "c"]`. For that behavior, you'd want
+    /// to match contiguous space characters:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r" +").unwrap();
+    /// let hay = b"    a  b c";
+    /// let got: Vec<&[u8]> = re.split(hay).collect();
+    /// // N.B. This does still include a leading empty span because ' +'
+    /// // matches at the beginning of the haystack.
+    /// assert_eq!(got, vec![&b""[..], &b"a"[..], &b"b"[..], &b"c"[..]]);
+    /// ```
+    #[inline]
+    pub fn split<'r, 'h>(&'r self, haystack: &'h [u8]) -> Split<'r, 'h> {
+        Split { haystack, it: self.meta.split(haystack) }
+    }
+
+    /// Returns an iterator of at most `limit` substrings of the haystack
+    /// given, delimited by a match of the regex. (A `limit` of `0` will return
+    /// no substrings.) Namely, each element of the iterator corresponds to a
+    /// part of the haystack that *isn't* matched by the regular expression.
+    /// The remainder of the haystack that is not split will be the last
+    /// element in the iterator.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some haystack:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let hay = b"Hey! How are you?";
+    /// let fields: Vec<&[u8]> = re.splitn(hay, 3).collect();
+    /// assert_eq!(fields, vec![&b"Hey"[..], &b"How"[..], &b"are you?"[..]]);
+    /// ```
+    ///
+    /// # Examples: more cases
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = b"Mary had a little lamb";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec![&b"Mary"[..], &b"had"[..], &b"a little lamb"[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec![&b""[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"lionXXtigerXleopard";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec![&b"lion"[..], &b""[..], &b"tigerXleopard"[..]]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = b"lion::tiger::leopard";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec![&b"lion"[..], &b"tiger::leopard"[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"abcXdef";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 1).collect();
+    /// assert_eq!(got, vec![&b"abcXdef"[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"abcdef";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec![&b"abcdef"[..]]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = b"abcXdef";
+    /// let got: Vec<&[u8]> = re.splitn(hay, 0).collect();
+    /// assert!(got.is_empty());
+    /// ```
+    #[inline]
+    pub fn splitn<'r, 'h>(
+        &'r self,
+        haystack: &'h [u8],
+        limit: usize,
+    ) -> SplitN<'r, 'h> {
+        SplitN { haystack, it: self.meta.splitn(haystack, limit) }
+    }
+
+    /// Replaces the leftmost-first match in the given haystack with the
+    /// replacement provided. The replacement can be a regular string (where
+    /// `$N` and `$name` are expanded to match capture groups) or a function
+    /// that takes a [`Captures`] and returns the replaced string.
+    ///
+    /// If no match is found, then the haystack is returned unchanged. In that
+    /// case, this implementation will likely return a `Cow::Borrowed` value
+    /// such that no allocation is performed.
+    ///
+    /// # Replacement string syntax
+    ///
+    /// All instances of `$ref` in the replacement string are replaced with
+    /// the substring corresponding to the capture group identified by `ref`.
+    ///
+    /// `ref` may be an integer corresponding to the index of the capture group
+    /// (counted by order of opening parenthesis where `0` is the entire match)
+    /// or it can be a name (consisting of letters, digits or underscores)
+    /// corresponding to a named capture group.
+    ///
+    /// If `ref` isn't a valid capture group (whether the name doesn't exist or
+    /// isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name is used. For example, `$1a` looks up the
+    /// capture group named `1a` and not the capture group at index `1`. To
+    /// exert more precise control over the name, use braces, e.g., `${1}a`.
+    ///
+    /// To write a literal `$` use `$$`.
+    ///
+    /// # Example
+    ///
+    /// Note that this function is polymorphic with respect to the replacement.
+    /// In typical usage, this can just be a normal string:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"[^01]+").unwrap();
+    /// assert_eq!(re.replace(b"1078910", b""), &b"1010"[..]);
+    /// ```
+    ///
+    /// But anything satisfying the [`Replacer`] trait will work. For example,
+    /// a closure of type `|&Captures| -> String` provides direct access to the
+    /// captures corresponding to a match. This allows one to access capturing
+    /// group matches easily:
+    ///
+    /// ```
+    /// use regex::bytes::{Captures, Regex};
+    ///
+    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", |caps: &Captures| {
+    ///     let mut buf = vec![];
+    ///     buf.extend_from_slice(&caps[2]);
+    ///     buf.push(b' ');
+    ///     buf.extend_from_slice(&caps[1]);
+    ///     buf
+    /// });
+    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
+    /// ```
+    ///
+    /// But this is a bit cumbersome to use all the time. Instead, a simple
+    /// syntax is supported (as described above) that expands `$name` into the
+    /// corresponding capture group. Here's the last example, but using this
+    /// expansion technique with named capture groups:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", b"$first $last");
+    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
+    /// ```
+    ///
+    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
+    /// would produce the same result. To write a literal `$` use `$$`.
+    ///
+    /// Sometimes the replacement string requires use of curly braces to
+    /// delineate a capture group replacement when it is adjacent to some other
+    /// literal text. For example, if we wanted to join two words together with
+    /// an underscore:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<second>\w+)").unwrap();
+    /// let result = re.replace(b"deep fried", b"${first}_$second");
+    /// assert_eq!(result, &b"deep_fried"[..]);
+    /// ```
+    ///
+    /// Without the curly braces, the capture group name `first_` would be
+    /// used, and since it doesn't exist, it would be replaced with the empty
+    /// string.
+    ///
+    /// Finally, sometimes you just want to replace a literal string with no
+    /// regard for capturing group expansion. This can be done by wrapping a
+    /// string with [`NoExpand`]:
+    ///
+    /// ```
+    /// use regex::bytes::{NoExpand, Regex};
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", NoExpand(b"$2 $last"));
+    /// assert_eq!(result, &b"$2 $last"[..]);
+    /// ```
+    ///
+    /// Using `NoExpand` may also be faster, since the replacement string won't
+    /// need to be parsed for the `$` syntax.
+    #[inline]
+    pub fn replace<'h, R: Replacer>(
+        &self,
+        haystack: &'h [u8],
+        rep: R,
+    ) -> Cow<'h, [u8]> {
+        self.replacen(haystack, 1, rep)
+    }
+
+    /// Replaces all non-overlapping matches in the haystack with the
+    /// replacement provided. This is the same as calling `replacen` with
+    /// `limit` set to `0`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Fallibility
+    ///
+    /// If you need to write a replacement routine where any individual
+    /// replacement might "fail," doing so with this API isn't really feasible
+    /// because there's no way to stop the search process if a replacement
+    /// fails. Instead, if you need this functionality, you should consider
+    /// implementing your own replacement routine:
+    ///
+    /// ```
+    /// use regex::bytes::{Captures, Regex};
+    ///
+    /// fn replace_all<E>(
+    ///     re: &Regex,
+    ///     haystack: &[u8],
+    ///     replacement: impl Fn(&Captures) -> Result<Vec<u8>, E>,
+    /// ) -> Result<Vec<u8>, E> {
+    ///     let mut new = Vec::with_capacity(haystack.len());
+    ///     let mut last_match = 0;
+    ///     for caps in re.captures_iter(haystack) {
+    ///         let m = caps.get(0).unwrap();
+    ///         new.extend_from_slice(&haystack[last_match..m.start()]);
+    ///         new.extend_from_slice(&replacement(&caps)?);
+    ///         last_match = m.end();
+    ///     }
+    ///     new.extend_from_slice(&haystack[last_match..]);
+    ///     Ok(new)
+    /// }
+    ///
+    /// // Let's replace each word with the number of bytes in that word.
+    /// // But if we see a word that is "too long," we'll give up.
+    /// let re = Regex::new(r"\w+").unwrap();
+    /// let replacement = |caps: &Captures| -> Result<Vec<u8>, &'static str> {
+    ///     if caps[0].len() >= 5 {
+    ///         return Err("word too long");
+    ///     }
+    ///     Ok(caps[0].len().to_string().into_bytes())
+    /// };
+    /// assert_eq!(
+    ///     Ok(b"2 3 3 3?".to_vec()),
+    ///     replace_all(&re, b"hi how are you?", &replacement),
+    /// );
+    /// assert!(replace_all(&re, b"hi there", &replacement).is_err());
+    /// ```
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace (excluding line
+    /// terminators) delimited fields, and normalizes the whitespace that
+    /// delimits the fields:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)[\s--\r\n]+(\S+)$").unwrap();
+    /// let hay = b"
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replace_all(hay, b"$2 $1");
+    /// assert_eq!(new, &b"
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// 1975 BornToRun
+    /// 1978 Darkness
+    /// 1980 TheRiver
+    /// "[..]);
+    /// ```
+    #[inline]
+    pub fn replace_all<'h, R: Replacer>(
+        &self,
+        haystack: &'h [u8],
+        rep: R,
+    ) -> Cow<'h, [u8]> {
+        self.replacen(haystack, 0, rep)
+    }
+
+    /// Replaces at most `limit` non-overlapping matches in the haystack with
+    /// the replacement provided. If `limit` is `0`, then all non-overlapping
+    /// matches are replaced. That is, `Regex::replace_all(hay, rep)` is
+    /// equivalent to `Regex::replacen(hay, 0, rep)`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Fallibility
+    ///
+    /// See the corresponding section in the docs for [`Regex::replace_all`]
+    /// for tips on how to deal with a replacement routine that can fail.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace (excluding line
+    /// terminators) delimited fields, and normalizes the whitespace that
+    /// delimits the fields. But we only do it for the first two matches.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)[\s--\r\n]+(\S+)$").unwrap();
+    /// let hay = b"
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replacen(hay, 2, b"$2 $1");
+    /// assert_eq!(new, &b"
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// "[..]);
+    /// ```
+    #[inline]
+    pub fn replacen<'h, R: Replacer>(
+        &self,
+        haystack: &'h [u8],
+        limit: usize,
+        mut rep: R,
+    ) -> Cow<'h, [u8]> {
+        // If we know that the replacement doesn't have any capture expansions,
+        // then we can use the fast path. The fast path can make a tremendous
+        // difference:
+        //
+        //   1) We use `find_iter` instead of `captures_iter`. Not asking for
+        //      captures generally makes the regex engines faster.
+        //   2) We don't need to look up all of the capture groups and do
+        //      replacements inside the replacement string. We just push it
+        //      at each match and be done with it.
+        if let Some(rep) = rep.no_expansion() {
+            let mut it = self.find_iter(haystack).enumerate().peekable();
+            if it.peek().is_none() {
+                return Cow::Borrowed(haystack);
+            }
+            let mut new = Vec::with_capacity(haystack.len());
+            let mut last_match = 0;
+            for (i, m) in it {
+                new.extend_from_slice(&haystack[last_match..m.start()]);
+                new.extend_from_slice(&rep);
+                last_match = m.end();
+                if limit > 0 && i >= limit - 1 {
+                    break;
+                }
+            }
+            new.extend_from_slice(&haystack[last_match..]);
+            return Cow::Owned(new);
+        }
+
+        // The slower path, which we use if the replacement needs access to
+        // capture groups.
+        let mut it = self.captures_iter(haystack).enumerate().peekable();
+        if it.peek().is_none() {
+            return Cow::Borrowed(haystack);
+        }
+        let mut new = Vec::with_capacity(haystack.len());
+        let mut last_match = 0;
+        for (i, cap) in it {
+            // unwrap on 0 is OK because captures only reports matches
+            let m = cap.get(0).unwrap();
+            new.extend_from_slice(&haystack[last_match..m.start()]);
+            rep.replace_append(&cap, &mut new);
+            last_match = m.end();
+            if limit > 0 && i >= limit - 1 {
+                break;
+            }
+        }
+        new.extend_from_slice(&haystack[last_match..]);
+        Cow::Owned(new)
+    }
+}
+
+/// A group of advanced or "lower level" search methods. Some methods permit
+/// starting the search at a position greater than `0` in the haystack. Other
+/// methods permit reusing allocations, for example, when extracting the
+/// matches for capture groups.
+impl Regex {
+    /// Returns the end byte offset of the first match in the haystack given.
+    ///
+    /// This method may have the same performance characteristics as
+    /// `is_match`. Behaviorlly, it doesn't just report whether it match
+    /// occurs, but also the end offset for a match. In particular, the offset
+    /// returned *may be shorter* than the proper end of the leftmost-first
+    /// match that you would find via [`Regex::find`].
+    ///
+    /// Note that it is not guaranteed that this routine finds the shortest or
+    /// "earliest" possible match. Instead, the main idea of this API is that
+    /// it returns the offset at the point at which the internal regex engine
+    /// has determined that a match has occurred. This may vary depending on
+    /// which internal regex engine is used, and thus, the offset itself may
+    /// change based on internal heuristics.
+    ///
+    /// # Example
+    ///
+    /// Typically, `a+` would match the entire first sequence of `a` in some
+    /// haystack, but `shortest_match` *may* give up as soon as it sees the
+    /// first `a`.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"a+").unwrap();
+    /// let offset = re.shortest_match(b"aaaaa").unwrap();
+    /// assert_eq!(offset, 1);
+    /// ```
+    #[inline]
+    pub fn shortest_match(&self, haystack: &[u8]) -> Option<usize> {
+        self.shortest_match_at(haystack, 0)
+    }
+
+    /// Returns the same as `shortest_match`, but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only match
+    /// when `start == 0`.
+    ///
+    /// If a match is found, the offset returned is relative to the beginning
+    /// of the haystack, not the beginning of the search.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = b"eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.shortest_match(&hay[2..]), Some(4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.shortest_match_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn shortest_match_at(
+        &self,
+        haystack: &[u8],
+        start: usize,
+    ) -> Option<usize> {
+        let input =
+            Input::new(haystack).earliest(true).span(start..haystack.len());
+        self.meta.search_half(&input).map(|hm| hm.offset())
+    }
+
+    /// Returns the same as [`Regex::is_match`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = b"eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.is_match(&hay[2..]));
+    /// // No match because the  assertions take the context into account.
+    /// assert!(!re.is_match_at(hay, 2));
+    /// ```
+    #[inline]
+    pub fn is_match_at(&self, haystack: &[u8], start: usize) -> bool {
+        self.meta.is_match(Input::new(haystack).span(start..haystack.len()))
+    }
+
+    /// Returns the same as [`Regex::find`], but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = b"eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.find(&hay[2..]).map(|m| m.range()), Some(0..4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.find_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn find_at<'h>(
+        &self,
+        haystack: &'h [u8],
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        self.meta.find(input).map(|m| Match::new(haystack, m.start(), m.end()))
+    }
+
+    /// Returns the same as [`Regex::captures`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = b"eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(&re.captures(&hay[2..]).unwrap()[0], b"chew");
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_at(hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_at<'h>(
+        &self,
+        haystack: &'h [u8],
+        start: usize,
+    ) -> Option<Captures<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        let mut caps = self.meta.create_captures();
+        self.meta.captures(input, &mut caps);
+        if caps.is_match() {
+            let static_captures_len = self.static_captures_len();
+            Some(Captures { haystack, caps, static_captures_len })
+        } else {
+            None
+        }
+    }
+
+    /// This is like [`Regex::captures`], but writes the byte offsets of each
+    /// capture group match into the locations given.
+    ///
+    /// A [`CaptureLocations`] stores the same byte offsets as a [`Captures`],
+    /// but does *not* store a reference to the haystack. This makes its API
+    /// a bit lower level and less convenience. But in exchange, callers
+    /// may allocate their own `CaptureLocations` and reuse it for multiple
+    /// searches. This may be helpful if allocating a `Captures` shows up in a
+    /// profile as too costly.
+    ///
+    /// To create a `CaptureLocations` value, use the
+    /// [`Regex::capture_locations`] method.
+    ///
+    /// This also the overall match if one was found. When a match is found,
+    /// its offsets are also always stored in `locs` at index `0`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"^([a-z]+)=(\S*)$").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, b"id=foo123").is_some());
+    /// assert_eq!(Some((0, 9)), locs.get(0));
+    /// assert_eq!(Some((0, 2)), locs.get(1));
+    /// assert_eq!(Some((3, 9)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn captures_read<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h [u8],
+    ) -> Option<Match<'h>> {
+        self.captures_read_at(locs, haystack, 0)
+    }
+
+    /// Returns the same as [`Regex::captures_read`], but starts the search at
+    /// the given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = b"eschew";
+    /// let mut locs = re.capture_locations();
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.captures_read(&mut locs, &hay[2..]).is_some());
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_read_at(&mut locs, hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_read_at<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h [u8],
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        self.meta.search_captures(&input, &mut locs.0);
+        locs.0.get_match().map(|m| Match::new(haystack, m.start(), m.end()))
+    }
+
+    /// An undocumented alias for `captures_read_at`.
+    ///
+    /// The `regex-capi` crate previously used this routine, so to avoid
+    /// breaking that crate, we continue to provide the name as an undocumented
+    /// alias.
+    #[doc(hidden)]
+    #[inline]
+    pub fn read_captures_at<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h [u8],
+        start: usize,
+    ) -> Option<Match<'h>> {
+        self.captures_read_at(locs, haystack, start)
+    }
+}
+
+/// Auxiliary methods.
+impl Regex {
+    /// Returns the original string of this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"foo\w+bar").unwrap();
+    /// assert_eq!(re.as_str(), r"foo\w+bar");
+    /// ```
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Returns an iterator over the capture names in this regex.
+    ///
+    /// The iterator returned yields elements of type `Option<&str>`. That is,
+    /// the iterator yields values for all capture groups, even ones that are
+    /// unnamed. The order of the groups corresponds to the order of the group's
+    /// corresponding opening parenthesis.
+    ///
+    /// The first element of the iterator always yields the group corresponding
+    /// to the overall match, and this group is always unnamed. Therefore, the
+    /// iterator always yields at least one group.
+    ///
+    /// # Example
+    ///
+    /// This shows basic usage with a mix of named and unnamed capture groups:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), Some(Some("a")));
+    /// assert_eq!(names.next(), Some(Some("b")));
+    /// assert_eq!(names.next(), Some(None));
+    /// // the '(?:.)' group is non-capturing and so doesn't appear here!
+    /// assert_eq!(names.next(), Some(Some("c")));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    ///
+    /// The iterator always yields at least one element, even for regexes with
+    /// no capture groups and even for regexes that can never match:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    ///
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    #[inline]
+    pub fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames(self.meta.group_info().pattern_names(PatternID::ZERO))
+    }
+
+    /// Returns the number of captures groups in this regex.
+    ///
+    /// This includes all named and unnamed groups, including the implicit
+    /// unnamed group that is always present and corresponds to the entire
+    /// match.
+    ///
+    /// Since the implict unnamed group is always included in this length, the
+    /// length returned is guaranteed to be greater than zero.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"foo").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(foo)").unwrap();
+    /// assert_eq!(2, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// assert_eq!(5, re.captures_len());
+    ///
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    /// ```
+    #[inline]
+    pub fn captures_len(&self) -> usize {
+        self.meta.group_info().group_len(PatternID::ZERO)
+    }
+
+    /// Returns the total number of capturing groups that appear in every
+    /// possible match.
+    ///
+    /// If the number of capture groups can vary depending on the match, then
+    /// this returns `None`. That is, a value is only returned when the number
+    /// of matching groups is invariant or "static."
+    ///
+    /// Note that like [`Regex::captures_len`], this **does** include the
+    /// implicit capturing group corresponding to the entire match. Therefore,
+    /// when a non-None value is returned, it is guaranteed to be at least `1`.
+    /// Stated differently, a return value of `Some(0)` is impossible.
+    ///
+    /// # Example
+    ///
+    /// This shows a few cases where a static number of capture groups is
+    /// available and a few cases where it is not.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let len = |pattern| {
+    ///     Regex::new(pattern).map(|re| re.static_captures_len())
+    /// };
+    ///
+    /// assert_eq!(Some(1), len("a")?);
+    /// assert_eq!(Some(2), len("(a)")?);
+    /// assert_eq!(Some(2), len("(a)|(b)")?);
+    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
+    /// assert_eq!(None, len("(a)|b")?);
+    /// assert_eq!(None, len("a|(b)")?);
+    /// assert_eq!(None, len("(b)*")?);
+    /// assert_eq!(Some(2), len("(b)+")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn static_captures_len(&self) -> Option<usize> {
+        self.meta.static_captures_len()
+    }
+
+    /// Returns a fresh allocated set of capture locations that can
+    /// be reused in multiple calls to [`Regex::captures_read`] or
+    /// [`Regex::captures_read_at`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(.)(.)(\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, b"Padron").is_some());
+    /// assert_eq!(locs.get(0), Some((0, 6)));
+    /// assert_eq!(locs.get(1), Some((0, 1)));
+    /// assert_eq!(locs.get(2), Some((1, 2)));
+    /// assert_eq!(locs.get(3), Some((2, 6)));
+    /// ```
+    #[inline]
+    pub fn capture_locations(&self) -> CaptureLocations {
+        CaptureLocations(self.meta.create_captures())
+    }
+
+    /// An alias for `capture_locations` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate uses this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn locations(&self) -> CaptureLocations {
+        self.capture_locations()
+    }
+}
+
+/// Represents a single match of a regex in a haystack.
+///
+/// A `Match` contains both the start and end byte offsets of the match and the
+/// actual substring corresponding to the range of those byte offsets. It is
+/// guaranteed that `start <= end`. When `start == end`, the match is empty.
+///
+/// Unlike the top-level `Match` type, this `Match` type is produced by APIs
+/// that search `&[u8]` haystacks. This means that the offsets in a `Match` can
+/// point to anywhere in the haystack, including in a place that splits the
+/// UTF-8 encoding of a Unicode scalar value.
+///
+/// The lifetime parameter `'h` refers to the lifetime of the matched of the
+/// haystack that this match was produced from.
+///
+/// # Numbering
+///
+/// The byte offsets in a `Match` form a half-open interval. That is, the
+/// start of the range is inclusive and the end of the range is exclusive.
+/// For example, given a haystack `abcFOOxyz` and a match of `FOO`, its byte
+/// offset range starts at `3` and ends at `6`. `3` corresponds to `F` and
+/// `6` corresponds to `x`, which is one past the end of the match. This
+/// corresponds to the same kind of slicing that Rust uses.
+///
+/// For more on why this was chosen over other schemes (aside from being
+/// consistent with how Rust the language works), see [this discussion] and
+/// [Dijkstra's note on a related topic][note].
+///
+/// [this discussion]: https://github.com/rust-lang/regex/discussions/866
+/// [note]: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html
+///
+/// # Example
+///
+/// This example shows the value of each of the methods on `Match` for a
+/// particular search.
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// let re = Regex::new(r"\p{Greek}+").unwrap();
+/// let hay = "Greek: αβγδ".as_bytes();
+/// let m = re.find(hay).unwrap();
+/// assert_eq!(7, m.start());
+/// assert_eq!(15, m.end());
+/// assert!(!m.is_empty());
+/// assert_eq!(8, m.len());
+/// assert_eq!(7..15, m.range());
+/// assert_eq!("αβγδ".as_bytes(), m.as_bytes());
+/// ```
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct Match<'h> {
+    haystack: &'h [u8],
+    start: usize,
+    end: usize,
+}
+
+impl<'h> Match<'h> {
+    /// Returns the byte offset of the start of the match in the haystack. The
+    /// start of the match corresponds to the position where the match begins
+    /// and includes the first byte in the match.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// Unlike the top-level `Match` type, the start offset may appear anywhere
+    /// in the haystack. This includes between the code units of a UTF-8
+    /// encoded Unicode scalar value.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Returns the byte offset of the end of the match in the haystack. The
+    /// end of the match corresponds to the byte immediately following the last
+    /// byte in the match. This means that `&slice[start..end]` works as one
+    /// would expect.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// Unlike the top-level `Match` type, the start offset may appear anywhere
+    /// in the haystack. This includes between the code units of a UTF-8
+    /// encoded Unicode scalar value.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    /// Returns true if and only if this match has a length of zero.
+    ///
+    /// Note that an empty match can only occur when the regex itself can
+    /// match the empty string. Here are some examples of regexes that can
+    /// all match the empty string: `^`, `^$`, `\b`, `a?`, `a*`, `a{0}`,
+    /// `(foo|\d+|quux)?`.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.start == self.end
+    }
+
+    /// Returns the length, in bytes, of this match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.end - self.start
+    }
+
+    /// Returns the range over the starting and ending byte offsets of the
+    /// match in the haystack.
+    #[inline]
+    pub fn range(&self) -> core::ops::Range<usize> {
+        self.start..self.end
+    }
+
+    /// Returns the substring of the haystack that matched.
+    #[inline]
+    pub fn as_bytes(&self) -> &'h [u8] {
+        &self.haystack[self.range()]
+    }
+
+    /// Creates a new match from the given haystack and byte offsets.
+    #[inline]
+    fn new(haystack: &'h [u8], start: usize, end: usize) -> Match<'h> {
+        Match { haystack, start, end }
+    }
+}
+
+impl<'h> core::fmt::Debug for Match<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        let mut fmt = f.debug_struct("Match");
+        fmt.field("start", &self.start).field("end", &self.end);
+        if let Ok(s) = core::str::from_utf8(self.as_bytes()) {
+            fmt.field("bytes", &s);
+        } else {
+            // FIXME: It would be nice if this could be printed as a string
+            // with invalid UTF-8 replaced with hex escapes. A alloc would
+            // probably okay if that makes it easier, but regex-automata does
+            // (at time of writing) have internal routines that do this. So
+            // maybe we should expose them.
+            fmt.field("bytes", &self.as_bytes());
+        }
+        fmt.finish()
+    }
+}
+
+impl<'h> From<Match<'h>> for &'h [u8] {
+    fn from(m: Match<'h>) -> &'h [u8] {
+        m.as_bytes()
+    }
+}
+
+impl<'h> From<Match<'h>> for core::ops::Range<usize> {
+    fn from(m: Match<'h>) -> core::ops::Range<usize> {
+        m.range()
+    }
+}
+
+/// Represents the capture groups for a single match.
+///
+/// Capture groups refer to parts of a regex enclosed in parentheses. They can
+/// be optionally named. The purpose of capture groups is to be able to
+/// reference different parts of a match based on the original pattern. For
+/// example, say you want to match the individual letters in a 5-letter word:
+///
+/// ```text
+/// (?<first>\w)(\w)(?:\w)\w(?<last>\w)
+/// ```
+///
+/// This regex has 4 capture groups:
+///
+/// * The group at index `0` corresponds to the overall match. It is always
+/// present in every match and never has a name.
+/// * The group at index `1` with name `first` corresponding to the first
+/// letter.
+/// * The group at index `2` with no name corresponding to the second letter.
+/// * The group at index `3` with name `last` corresponding to the fifth and
+/// last letter.
+///
+/// Notice that `(?:\w)` was not listed above as a capture group despite it
+/// being enclosed in parentheses. That's because `(?:pattern)` is a special
+/// syntax that permits grouping but *without* capturing. The reason for not
+/// treating it as a capture is that tracking and reporting capture groups
+/// requires additional state that may lead to slower searches. So using as few
+/// capture groups as possible can help performance. (Although the difference
+/// in performance of a couple of capture groups is likely immaterial.)
+///
+/// Values with this type are created by [`Regex::captures`] or
+/// [`Regex::captures_iter`].
+///
+/// `'h` is the lifetime of the haystack that these captures were matched from.
+///
+/// # Example
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w)(\w)(?:\w)\w(?<last>\w)").unwrap();
+/// let caps = re.captures(b"toady").unwrap();
+/// assert_eq!(b"toady", &caps[0]);
+/// assert_eq!(b"t", &caps["first"]);
+/// assert_eq!(b"o", &caps[2]);
+/// assert_eq!(b"y", &caps["last"]);
+/// ```
+pub struct Captures<'h> {
+    haystack: &'h [u8],
+    caps: captures::Captures,
+    static_captures_len: Option<usize>,
+}
+
+impl<'h> Captures<'h> {
+    /// Returns the `Match` associated with the capture group at index `i`. If
+    /// `i` does not correspond to a capture group, or if the capture group did
+    /// not participate in the match, then `None` is returned.
+    ///
+    /// When `i == 0`, this is guaranteed to return a non-`None` value.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
+    /// let caps = re.captures(b"abc123").unwrap();
+    ///
+    /// let substr1 = caps.get(1).map_or(&b""[..], |m| m.as_bytes());
+    /// let substr2 = caps.get(2).map_or(&b""[..], |m| m.as_bytes());
+    /// assert_eq!(substr1, b"123");
+    /// assert_eq!(substr2, b"");
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<Match<'h>> {
+        self.caps
+            .get_group(i)
+            .map(|sp| Match::new(self.haystack, sp.start, sp.end))
+    }
+
+    /// Returns the `Match` associated with the capture group named `name`. If
+    /// `name` isn't a valid capture group or it refers to a group that didn't
+    /// match, then `None` is returned.
+    ///
+    /// Note that unlike `caps["name"]`, this returns a `Match` whose lifetime
+    /// matches the lifetime of the haystack in this `Captures` value.
+    /// Conversely, the substring returned by `caps["name"]` has a lifetime
+    /// of the `Captures` value, which is likely shorter than the lifetime of
+    /// the haystack. In some cases, it may be necessary to use this method to
+    /// access the matching substring instead of the `caps["name"]` notation.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"[a-z]+(?:(?<numbers>[0-9]+)|(?<letters>[A-Z]+))",
+    /// ).unwrap();
+    /// let caps = re.captures(b"abc123").unwrap();
+    ///
+    /// let numbers = caps.name("numbers").map_or(&b""[..], |m| m.as_bytes());
+    /// let letters = caps.name("letters").map_or(&b""[..], |m| m.as_bytes());
+    /// assert_eq!(numbers, b"123");
+    /// assert_eq!(letters, b"");
+    /// ```
+    #[inline]
+    pub fn name(&self, name: &str) -> Option<Match<'h>> {
+        self.caps
+            .get_group_by_name(name)
+            .map(|sp| Match::new(self.haystack, sp.start, sp.end))
+    }
+
+    /// This is a convenience routine for extracting the substrings
+    /// corresponding to matching capture groups.
+    ///
+    /// This returns a tuple where the first element corresponds to the full
+    /// substring of the haystack that matched the regex. The second element is
+    /// an array of substrings, with each corresponding to the to the substring
+    /// that matched for a particular capture group.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the number of possible matching groups in this
+    /// `Captures` value is not fixed to `N` in all circumstances.
+    /// More precisely, this routine only works when `N` is equivalent to
+    /// [`Regex::static_captures_len`].
+    ///
+    /// Stated more plainly, if the number of matching capture groups in a
+    /// regex can vary from match to match, then this function always panics.
+    ///
+    /// For example, `(a)(b)|(c)` could produce two matching capture groups
+    /// or one matching capture group for any given match. Therefore, one
+    /// cannot use `extract` with such a pattern.
+    ///
+    /// But a pattern like `(a)(b)|(c)(d)` can be used with `extract` because
+    /// the number of capture groups in every match is always equivalent,
+    /// even if the capture _indices_ in each match are not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = b"On 2010-03-14, I became a Tenneessee lamb.";
+    /// let Some((full, [year, month, day])) =
+    ///     re.captures(hay).map(|caps| caps.extract()) else { return };
+    /// assert_eq!(b"2010-03-14", full);
+    /// assert_eq!(b"2010", year);
+    /// assert_eq!(b"03", month);
+    /// assert_eq!(b"14", day);
+    /// ```
+    ///
+    /// # Example: iteration
+    ///
+    /// This example shows how to use this method when iterating over all
+    /// `Captures` matches in a haystack.
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = b"1973-01-05, 1975-08-25 and 1980-10-18";
+    ///
+    /// let mut dates: Vec<(&[u8], &[u8], &[u8])> = vec![];
+    /// for (_, [y, m, d]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     dates.push((y, m, d));
+    /// }
+    /// assert_eq!(dates, vec![
+    ///     (&b"1973"[..], &b"01"[..], &b"05"[..]),
+    ///     (&b"1975"[..], &b"08"[..], &b"25"[..]),
+    ///     (&b"1980"[..], &b"10"[..], &b"18"[..]),
+    /// ]);
+    /// ```
+    ///
+    /// # Example: parsing different formats
+    ///
+    /// This API is particularly useful when you need to extract a particular
+    /// value that might occur in a different format. Consider, for example,
+    /// an identifier that might be in double quotes or single quotes:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r#"id:(?:"([^"]+)"|'([^']+)')"#).unwrap();
+    /// let hay = br#"The first is id:"foo" and the second is id:'bar'."#;
+    /// let mut ids = vec![];
+    /// for (_, [id]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     ids.push(id);
+    /// }
+    /// assert_eq!(ids, vec![b"foo", b"bar"]);
+    /// ```
+    pub fn extract<const N: usize>(&self) -> (&'h [u8], [&'h [u8]; N]) {
+        let len = self
+            .static_captures_len
+            .expect("number of capture groups can vary in a match")
+            .checked_sub(1)
+            .expect("number of groups is always greater than zero");
+        assert_eq!(N, len, "asked for {} groups, but must ask for {}", N, len);
+        // The regex-automata variant of extract is a bit more permissive.
+        // It doesn't require the number of matching capturing groups to be
+        // static, and you can even request fewer groups than what's there. So
+        // this is guaranteed to never panic because we've asserted above that
+        // the user has requested precisely the number of groups that must be
+        // present in any match for this regex.
+        self.caps.extract_bytes(self.haystack)
+    }
+
+    /// Expands all instances of `$ref` in `replacement` to the corresponding
+    /// capture group, and writes them to the `dst` buffer given. A `ref` can
+    /// be a capture group index or a name. If `ref` doesn't refer to a capture
+    /// group that participated in the match, then it is replaced with the
+    /// empty string.
+    ///
+    /// # Format
+    ///
+    /// The format of the replacement string supports two different kinds of
+    /// capture references: unbraced and braced.
+    ///
+    /// For the unbraced format, the format supported is `$ref` where `name`
+    /// can be any character in the class `[0-9A-Za-z_]`. `ref` is always
+    /// the longest possible parse. So for example, `$1a` corresponds to the
+    /// capture group named `1a` and not the capture group at index `1`. If
+    /// `ref` matches `^[0-9]+$`, then it is treated as a capture group index
+    /// itself and not a name.
+    ///
+    /// For the braced format, the format supported is `${ref}` where `ref` can
+    /// be any sequence of bytes except for `}`. If no closing brace occurs,
+    /// then it is not considered a capture reference. As with the unbraced
+    /// format, if `ref` matches `^[0-9]+$`, then it is treated as a capture
+    /// group index and not a name.
+    ///
+    /// The braced format is useful for exerting precise control over the name
+    /// of the capture reference. For example, `${1}a` corresponds to the
+    /// capture group reference `1` followed by the letter `a`, where as `$1a`
+    /// (as mentioned above) corresponds to the capture group reference `1a`.
+    /// The braced format is also useful for expressing capture group names
+    /// that use characters not supported by the unbraced format. For example,
+    /// `${foo[bar].baz}` refers to the capture group named `foo[bar].baz`.
+    ///
+    /// If a capture group reference is found and it does not refer to a valid
+    /// capture group, then it will be replaced with the empty string.
+    ///
+    /// To write a literal `$`, use `$$`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    /// ).unwrap();
+    /// let hay = b"On 14-03-2010, I became a Tenneessee lamb.";
+    /// let caps = re.captures(hay).unwrap();
+    ///
+    /// let mut dst = vec![];
+    /// caps.expand(b"year=$year, month=$month, day=$day", &mut dst);
+    /// assert_eq!(dst, b"year=2010, month=03, day=14");
+    /// ```
+    #[inline]
+    pub fn expand(&self, replacement: &[u8], dst: &mut Vec<u8>) {
+        self.caps.interpolate_bytes_into(self.haystack, replacement, dst);
+    }
+
+    /// Returns an iterator over all capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The iterator always yields at least one matching group: the first group
+    /// (at index `0`) with no name. Subsequent groups are returned in the order
+    /// of their opening parenthesis in the regex.
+    ///
+    /// The elements yielded have type `Option<Match<'h>>`, where a non-`None`
+    /// value is present if the capture group matches.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures(b"AZ").unwrap();
+    ///
+    /// let mut it = caps.iter();
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"AZ"[..]));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"A"[..]));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), None);
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_bytes()), Some(&b"Z"[..]));
+    /// assert_eq!(it.next(), None);
+    /// ```
+    #[inline]
+    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 'h> {
+        SubCaptureMatches { haystack: self.haystack, it: self.caps.iter() }
+    }
+
+    /// Returns the total number of capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The length returned is always equivalent to the number of elements
+    /// yielded by [`Captures::iter`]. Consequently, the length is always
+    /// greater than zero since every `Captures` value always includes the
+    /// match for the entire regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures(b"AZ").unwrap();
+    /// assert_eq!(caps.len(), 4);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.caps.group_len()
+    }
+}
+
+impl<'h> core::fmt::Debug for Captures<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        /// A little helper type to provide a nice map-like debug
+        /// representation for our capturing group spans.
+        ///
+        /// regex-automata has something similar, but it includes the pattern
+        /// ID in its debug output, which is confusing. It also doesn't include
+        /// that strings that match because a regex-automata `Captures` doesn't
+        /// borrow the haystack.
+        struct CapturesDebugMap<'a> {
+            caps: &'a Captures<'a>,
+        }
+
+        impl<'a> core::fmt::Debug for CapturesDebugMap<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                let mut map = f.debug_map();
+                let names =
+                    self.caps.caps.group_info().pattern_names(PatternID::ZERO);
+                for (group_index, maybe_name) in names.enumerate() {
+                    let key = Key(group_index, maybe_name);
+                    match self.caps.get(group_index) {
+                        None => map.entry(&key, &None::<()>),
+                        Some(mat) => map.entry(&key, &Value(mat)),
+                    };
+                }
+                map.finish()
+            }
+        }
+
+        struct Key<'a>(usize, Option<&'a str>);
+
+        impl<'a> core::fmt::Debug for Key<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "{}", self.0)?;
+                if let Some(name) = self.1 {
+                    write!(f, "/{:?}", name)?;
+                }
+                Ok(())
+            }
+        }
+
+        struct Value<'a>(Match<'a>);
+
+        impl<'a> core::fmt::Debug for Value<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                use regex_automata::util::escape::DebugHaystack;
+
+                write!(
+                    f,
+                    "{}..{}/{:?}",
+                    self.0.start(),
+                    self.0.end(),
+                    DebugHaystack(self.0.as_bytes())
+                )
+            }
+        }
+
+        f.debug_tuple("Captures")
+            .field(&CapturesDebugMap { caps: self })
+            .finish()
+    }
+}
+
+/// Get a matching capture group's haystack substring by index.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// # Panics
+///
+/// If there is no matching group at the given index.
+impl<'h> core::ops::Index<usize> for Captures<'h> {
+    type Output = [u8];
+
+    // The lifetime is written out to make it clear that the &str returned
+    // does NOT have a lifetime equivalent to 'h.
+    fn index<'a>(&'a self, i: usize) -> &'a [u8] {
+        self.get(i)
+            .map(|m| m.as_bytes())
+            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+    }
+}
+
+/// Get a matching capture group's haystack substring by name.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// `'n` is the lifetime of the group name used to index the `Captures` value.
+///
+/// # Panics
+///
+/// If there is no matching group at the given name.
+impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
+    type Output = [u8];
+
+    fn index<'a>(&'a self, name: &'n str) -> &'a [u8] {
+        self.name(name)
+            .map(|m| m.as_bytes())
+            .unwrap_or_else(|| panic!("no group named '{}'", name))
+    }
+}
+
+/// A low level representation of the byte offsets of each capture group.
+///
+/// You can think of this as a lower level [`Captures`], where this type does
+/// not support named capturing groups directly and it does not borrow the
+/// haystack that these offsets were matched on.
+///
+/// Primarily, this type is useful when using the lower level `Regex` APIs such
+/// as [`Regex::captures_read`], which permits amortizing the allocation in
+/// which capture match offsets are stored.
+///
+/// In order to build a value of this type, you'll need to call the
+/// [`Regex::capture_locations`] method. The value returned can then be reused
+/// in subsequent searches for that regex. Using it for other regexes may
+/// result in a panic or otherwise incorrect results.
+///
+/// # Example
+///
+/// This example shows how to create and use `CaptureLocations` in a search.
+///
+/// ```
+/// use regex::bytes::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+/// let mut locs = re.capture_locations();
+/// let m = re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();
+/// assert_eq!(0..17, m.range());
+/// assert_eq!(Some((0, 17)), locs.get(0));
+/// assert_eq!(Some((0, 5)), locs.get(1));
+/// assert_eq!(Some((6, 17)), locs.get(2));
+///
+/// // Asking for an invalid capture group always returns None.
+/// assert_eq!(None, locs.get(3));
+/// assert_eq!(None, locs.get(34973498648));
+/// assert_eq!(None, locs.get(9944060567225171988));
+/// ```
+#[derive(Clone, Debug)]
+pub struct CaptureLocations(captures::Captures);
+
+/// A type alias for `CaptureLocations` for backwards compatibility.
+///
+/// Previously, we exported `CaptureLocations` as `Locations` in an
+/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
+/// we continue re-exporting the same undocumented API.
+#[doc(hidden)]
+pub type Locations = CaptureLocations;
+
+impl CaptureLocations {
+    /// Returns the start and end byte offsets of the capture group at index
+    /// `i`. This returns `None` if `i` is not a valid capture group or if the
+    /// capture group did not match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();
+    /// assert_eq!(Some((0, 17)), locs.get(0));
+    /// assert_eq!(Some((0, 5)), locs.get(1));
+    /// assert_eq!(Some((6, 17)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
+        self.0.get_group(i).map(|sp| (sp.start, sp.end))
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    /// That is, the length returned is unaffected by the result of a search.
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert_eq!(3, locs.len());
+    /// re.captures_read(&mut locs, b"Bruce Springsteen").unwrap();
+    /// assert_eq!(3, locs.len());
+    /// ```
+    ///
+    /// Notice that the length is always at least `1`, regardless of the regex:
+    ///
+    /// ```
+    /// use regex::bytes::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    ///
+    /// // [a&&b] is a regex that never matches anything.
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        // self.0.group_len() returns 0 if the underlying captures doesn't
+        // represent a match, but the behavior guaranteed for this method is
+        // that the length doesn't change based on a match or not.
+        self.0.group_info().group_len(PatternID::ZERO)
+    }
+
+    /// An alias for the `get` method for backwards compatibility.
+    ///
+    /// Previously, we exported `get` as `pos` in an undocumented API. To
+    /// prevent breaking that code (e.g., in `regex-capi`), we continue
+    /// re-exporting the same undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
+        self.get(i)
+    }
+}
+
+/// An iterator over all non-overlapping matches in a haystack.
+///
+/// This iterator yields [`Match`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the haystack.
+///
+/// This iterator is created by [`Regex::find_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Matches<'r, 'h> {
+    haystack: &'h [u8],
+    it: meta::FindMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for Matches<'r, 'h> {
+    type Item = Match<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match<'h>> {
+        self.it
+            .next()
+            .map(|sp| Match::new(self.haystack, sp.start(), sp.end()))
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        // This can actually be up to 2x faster than calling `next()` until
+        // completion, because counting matches when using a DFA only requires
+        // finding the end of each match. But returning a `Match` via `next()`
+        // requires the start of each match which, with a DFA, requires a
+        // reverse forward scan to find it.
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Matches<'r, 'h> {}
+
+/// An iterator over all non-overlapping capture matches in a haystack.
+///
+/// This iterator yields [`Captures`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the matched string.
+///
+/// This iterator is created by [`Regex::captures_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct CaptureMatches<'r, 'h> {
+    haystack: &'h [u8],
+    it: meta::CapturesMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for CaptureMatches<'r, 'h> {
+    type Item = Captures<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures<'h>> {
+        let static_captures_len = self.it.regex().static_captures_len();
+        self.it.next().map(|caps| Captures {
+            haystack: self.haystack,
+            caps,
+            static_captures_len,
+        })
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        // This can actually be up to 2x faster than calling `next()` until
+        // completion, because counting matches when using a DFA only requires
+        // finding the end of each match. But returning a `Match` via `next()`
+        // requires the start of each match which, with a DFA, requires a
+        // reverse forward scan to find it.
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for CaptureMatches<'r, 'h> {}
+
+/// An iterator over all substrings delimited by a regex match.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::split`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Split<'r, 'h> {
+    haystack: &'h [u8],
+    it: meta::Split<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for Split<'r, 'h> {
+    type Item = &'h [u8];
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h [u8]> {
+        self.it.next().map(|span| &self.haystack[span])
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Split<'r, 'h> {}
+
+/// An iterator over at most `N` substrings delimited by a regex match.
+///
+/// The last substring yielded by this iterator will be whatever remains after
+/// `N-1` splits.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::splitn`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+///
+/// Although note that the worst case time here has an upper bound given
+/// by the `limit` parameter to [`Regex::splitn`].
+#[derive(Debug)]
+pub struct SplitN<'r, 'h> {
+    haystack: &'h [u8],
+    it: meta::SplitN<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for SplitN<'r, 'h> {
+    type Item = &'h [u8];
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h [u8]> {
+        self.it.next().map(|span| &self.haystack[span])
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for SplitN<'r, 'h> {}
+
+/// An iterator over the names of all capture groups in a regex.
+///
+/// This iterator yields values of type `Option<&str>` in order of the opening
+/// capture group parenthesis in the regex pattern. `None` is yielded for
+/// groups with no name. The first element always corresponds to the implicit
+/// and unnamed group for the overall match.
+///
+/// `'r` is the lifetime of the compiled regular expression.
+///
+/// This iterator is created by [`Regex::capture_names`].
+#[derive(Clone, Debug)]
+pub struct CaptureNames<'r>(captures::GroupInfoPatternNames<'r>);
+
+impl<'r> Iterator for CaptureNames<'r> {
+    type Item = Option<&'r str>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<&'r str>> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<'r> ExactSizeIterator for CaptureNames<'r> {}
+
+impl<'r> core::iter::FusedIterator for CaptureNames<'r> {}
+
+/// An iterator over all group matches in a [`Captures`] value.
+///
+/// This iterator yields values of type `Option<Match<'h>>`, where `'h` is the
+/// lifetime of the haystack that the matches are for. The order of elements
+/// yielded corresponds to the order of the opening parenthesis for the group
+/// in the regex pattern. `None` is yielded for groups that did not participate
+/// in the match.
+///
+/// The first element always corresponds to the implicit group for the overall
+/// match. Since this iterator is created by a [`Captures`] value, and a
+/// `Captures` value is only created when a match occurs, it follows that the
+/// first element yielded by this iterator is guaranteed to be non-`None`.
+///
+/// The lifetime `'c` corresponds to the lifetime of the `Captures` value that
+/// created this iterator, and the lifetime `'h` corresponds to the originally
+/// matched haystack.
+#[derive(Clone, Debug)]
+pub struct SubCaptureMatches<'c, 'h> {
+    haystack: &'h [u8],
+    it: captures::CapturesPatternIter<'c>,
+}
+
+impl<'c, 'h> Iterator for SubCaptureMatches<'c, 'h> {
+    type Item = Option<Match<'h>>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<Match<'h>>> {
+        self.it.next().map(|group| {
+            group.map(|sp| Match::new(self.haystack, sp.start, sp.end))
+        })
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'c, 'h> ExactSizeIterator for SubCaptureMatches<'c, 'h> {}
+
+impl<'c, 'h> core::iter::FusedIterator for SubCaptureMatches<'c, 'h> {}
+
+/// A trait for types that can be used to replace matches in a haystack.
+///
+/// In general, users of this crate shouldn't need to implement this trait,
+/// since implementations are already provided for `&[u8]` along with other
+/// variants of byte string types, as well as `FnMut(&Captures) -> Vec<u8>` (or
+/// any `FnMut(&Captures) -> T` where `T: AsRef<[u8]>`). Those cover most use
+/// cases, but callers can implement this trait directly if necessary.
+///
+/// # Example
+///
+/// This example shows a basic implementation of the `Replacer` trait. This can
+/// be done much more simply using the replacement byte string interpolation
+/// support (e.g., `$first $last`), but this approach avoids needing to parse
+/// the replacement byte string at all.
+///
+/// ```
+/// use regex::bytes::{Captures, Regex, Replacer};
+///
+/// struct NameSwapper;
+///
+/// impl Replacer for NameSwapper {
+///     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+///         dst.extend_from_slice(&caps["first"]);
+///         dst.extend_from_slice(b" ");
+///         dst.extend_from_slice(&caps["last"]);
+///     }
+/// }
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+/// let result = re.replace(b"Springsteen, Bruce", NameSwapper);
+/// assert_eq!(result, &b"Bruce Springsteen"[..]);
+/// ```
+pub trait Replacer {
+    /// Appends possibly empty data to `dst` to replace the current match.
+    ///
+    /// The current match is represented by `caps`, which is guaranteed to have
+    /// a match at capture group `0`.
+    ///
+    /// For example, a no-op replacement would be
+    /// `dst.extend_from_slice(&caps[0])`.
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>);
+
+    /// Return a fixed unchanging replacement byte string.
+    ///
+    /// When doing replacements, if access to [`Captures`] is not needed (e.g.,
+    /// the replacement byte string does not need `$` expansion), then it can
+    /// be beneficial to avoid finding sub-captures.
+    ///
+    /// In general, this is called once for every call to a replacement routine
+    /// such as [`Regex::replace_all`].
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
+        None
+    }
+
+    /// Returns a type that implements `Replacer`, but that borrows and wraps
+    /// this `Replacer`.
+    ///
+    /// This is useful when you want to take a generic `Replacer` (which might
+    /// not be cloneable) and use it without consuming it, so it can be used
+    /// more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::{Regex, Replacer};
+    ///
+    /// fn replace_all_twice<R: Replacer>(
+    ///     re: Regex,
+    ///     src: &[u8],
+    ///     mut rep: R,
+    /// ) -> Vec<u8> {
+    ///     let dst = re.replace_all(src, rep.by_ref());
+    ///     let dst = re.replace_all(&dst, rep.by_ref());
+    ///     dst.into_owned()
+    /// }
+    /// ```
+    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
+        ReplacerRef(self)
+    }
+}
+
+impl<'a, const N: usize> Replacer for &'a [u8; N] {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(&**self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<const N: usize> Replacer for [u8; N] {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(&*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a [u8] {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Vec<u8> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl Replacer for Vec<u8> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for Cow<'a, [u8]> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self.as_ref(), dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Cow<'a, [u8]> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self.as_ref(), dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<F, T> Replacer for F
+where
+    F: FnMut(&Captures<'_>) -> T,
+    T: AsRef<[u8]>,
+{
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        dst.extend_from_slice((*self)(caps).as_ref());
+    }
+}
+
+/// A by-reference adaptor for a [`Replacer`].
+///
+/// This permits reusing the same `Replacer` value in multiple calls to a
+/// replacement routine like [`Regex::replace_all`].
+///
+/// This type is created by [`Replacer::by_ref`].
+#[derive(Debug)]
+pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
+
+impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        self.0.replace_append(caps, dst)
+    }
+
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
+        self.0.no_expansion()
+    }
+}
+
+/// A helper type for forcing literal string replacement.
+///
+/// It can be used with routines like [`Regex::replace`] and
+/// [`Regex::replace_all`] to do a literal string replacement without expanding
+/// `$name` to their corresponding capture groups. This can be both convenient
+/// (to avoid escaping `$`, for example) and faster (since capture groups
+/// don't need to be found).
+///
+/// `'s` is the lifetime of the literal string to use.
+///
+/// # Example
+///
+/// ```
+/// use regex::bytes::{NoExpand, Regex};
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+/// let result = re.replace(b"Springsteen, Bruce", NoExpand(b"$2 $last"));
+/// assert_eq!(result, &b"$2 $last"[..]);
+/// ```
+#[derive(Clone, Debug)]
+pub struct NoExpand<'s>(pub &'s [u8]);
+
+impl<'s> Replacer for NoExpand<'s> {
+    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut Vec<u8>) {
+        dst.extend_from_slice(self.0);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        Some(Cow::Borrowed(self.0))
+    }
+}
+
+/// Quickly checks the given replacement string for whether interpolation
+/// should be done on it. It returns `None` if a `$` was found anywhere in the
+/// given string, which suggests interpolation needs to be done. But if there's
+/// no `$` anywhere, then interpolation definitely does not need to be done. In
+/// that case, the given string is returned as a borrowed `Cow`.
+///
+/// This is meant to be used to implement the `Replacer::no_expandsion` method
+/// in its various trait impls.
+fn no_expansion<T: AsRef<[u8]>>(replacement: &T) -> Option<Cow<'_, [u8]>> {
+    let replacement = replacement.as_ref();
+    match crate::find_byte::find_byte(b'$', replacement) {
+        Some(_) => None,
+        None => Some(Cow::Borrowed(replacement)),
+    }
+}
diff --git a/src/regex/mod.rs b/src/regex/mod.rs
new file mode 100644
index 0000000000..93fadec8bf
--- /dev/null
+++ b/src/regex/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod bytes;
+pub(crate) mod string;
diff --git a/src/regex/string.rs b/src/regex/string.rs
new file mode 100644
index 0000000000..438af7bebf
--- /dev/null
+++ b/src/regex/string.rs
@@ -0,0 +1,2561 @@
+use alloc::{borrow::Cow, string::String, sync::Arc};
+
+use regex_automata::{meta, util::captures, Input, PatternID};
+
+use crate::{error::Error, RegexBuilder};
+
+/// A compiled regular expression for searching Unicode haystacks.
+///
+/// A `Regex` can be used to search haystacks, split haystacks into substrings
+/// or replace substrings in a haystack with a different substring. All
+/// searching is done with an implicit `(?s:.)*?` at the beginning and end of
+/// an pattern. To force an expression to match the whole string (or a prefix
+/// or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`).
+///
+/// While this crate will handle Unicode strings (whether in the regular
+/// expression or in the haystack), all positions returned are **byte
+/// offsets**. Every byte offset is guaranteed to be at a Unicode code point
+/// boundary. That is, all offsets returned by the `Regex` API are guaranteed
+/// to be ranges that can slice a `&str` without panicking. If you want to
+/// relax this requirement, then you must search `&[u8]` haystacks with a
+/// [`bytes::Regex`](crate::bytes::Regex).
+///
+/// The only methods that allocate new strings are the string replacement
+/// methods. All other methods (searching and splitting) return borrowed
+/// references into the haystack given.
+///
+/// # Example
+///
+/// Find the offsets of a US phone number:
+///
+/// ```
+/// use regex::Regex;
+///
+/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();
+/// let m = re.find("phone: 111-222-3333").unwrap();
+/// assert_eq!(7..19, m.range());
+/// ```
+///
+/// # Example: extracting capture groups
+///
+/// A common way to use regexes is with capture groups. That is, instead of
+/// just looking for matches of an entire regex, parentheses are used to create
+/// groups that represent part of the match.
+///
+/// For example, consider a haystack with multiple lines, and each line has
+/// three whitespace delimited fields where the second field is expected to be
+/// a number and the third field a boolean. To make this convenient, we use
+/// the [`Captures::extract`] API to put the strings that match each group
+/// into a fixed size array:
+///
+/// ```
+/// use regex::Regex;
+///
+/// let hay = "
+/// rabbit         54 true
+/// groundhog 2 true
+/// does not match
+/// fox   109    false
+/// ";
+/// let re = Regex::new(r"(?m)^\s*(\S+)\s+([0-9]+)\s+(true|false)\s*$").unwrap();
+/// let mut fields: Vec<(&str, i64, bool)> = vec![];
+/// for (_, [f1, f2, f3]) in re.captures_iter(hay).map(|caps| caps.extract()) {
+///     fields.push((f1, f2.parse()?, f3.parse()?));
+/// }
+/// assert_eq!(fields, vec![
+///     ("rabbit", 54, true),
+///     ("groundhog", 2, true),
+///     ("fox", 109, false),
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Example: searching with the `Pattern` trait
+///
+/// **Note**: This section requires that this crate is compiled with the
+/// `pattern` Cargo feature enabled, which **requires nightly Rust**.
+///
+/// Since `Regex` implements `Pattern` from the standard library, one can
+/// use regexes with methods defined on `&str`. For example, `is_match`,
+/// `find`, `find_iter` and `split` can, in some cases, be replaced with
+/// `str::contains`, `str::find`, `str::match_indices` and `str::split`.
+///
+/// Here are some examples:
+///
+/// ```ignore
+/// use regex::Regex;
+///
+/// let re = Regex::new(r"\d+").unwrap();
+/// let hay = "a111b222c";
+///
+/// assert!(hay.contains(&re));
+/// assert_eq!(hay.find(&re), Some(1));
+/// assert_eq!(hay.match_indices(&re).collect::<Vec<_>>(), vec![
+///     (1, "111"),
+///     (5, "222"),
+/// ]);
+/// assert_eq!(hay.split(&re).collect::<Vec<_>>(), vec!["a", "b", "c"]);
+/// ```
+#[derive(Clone)]
+pub struct Regex {
+    pub(crate) meta: meta::Regex,
+    pub(crate) pattern: Arc<str>,
+}
+
+impl core::fmt::Display for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl core::fmt::Debug for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("Regex").field(&self.as_str()).finish()
+    }
+}
+
+impl core::str::FromStr for Regex {
+    type Err = Error;
+
+    /// Attempts to parse a string into a regular expression
+    fn from_str(s: &str) -> Result<Regex, Error> {
+        Regex::new(s)
+    }
+}
+
+/// Core regular expression methods.
+impl Regex {
+    /// Compiles a regular expression. Once compiled, it can be used repeatedly
+    /// to search, split or replace substrings in a haystack.
+    ///
+    /// Note that regex compilation tends to be a somewhat expensive process,
+    /// and unlike higher level environments, compilation is not automatically
+    /// cached for you. One should endeavor to compile a regex once and then
+    /// reuse it. For example, it's a bad idea to compile the same regex
+    /// repeatedly in a loop.
+    ///
+    /// # Errors
+    ///
+    /// If an invalid pattern is given, then an error is returned.
+    /// An error is also returned if the pattern is valid, but would
+    /// produce a regex that is bigger than the configured size limit via
+    /// [`RegexBuilder::size_limit`]. (A reasonable size limit is enabled by
+    /// default.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// // An Invalid pattern because of an unclosed parenthesis
+    /// assert!(Regex::new(r"foo(bar").is_err());
+    /// // An invalid pattern because the regex would be too big
+    /// // because Unicode tends to inflate things.
+    /// assert!(Regex::new(r"\w{1000}").is_err());
+    /// // Disabling Unicode can make the regex much smaller,
+    /// // potentially by up to or more than an order of magnitude.
+    /// assert!(Regex::new(r"(?-u:\w){1000}").is_ok());
+    /// ```
+    pub fn new(re: &str) -> Result<Regex, Error> {
+        RegexBuilder::new(re).build()
+    }
+
+    /// Returns true if and only if there is a match for the regex anywhere
+    /// in the haystack given.
+    ///
+    /// It is recommended to use this method if all you need to do is test
+    /// whether a match exists, since the underlying matching engine may be
+    /// able to do less work.
+    ///
+    /// # Example
+    ///
+    /// Test if some haystack contains at least one word with exactly 13
+    /// Unicode word characters:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "I categorically deny having triskaidekaphobia.";
+    /// assert!(re.is_match(hay));
+    /// ```
+    #[inline]
+    pub fn is_match(&self, haystack: &str) -> bool {
+        self.is_match_at(haystack, 0)
+    }
+
+    /// This routine searches for the first match of this regex in the
+    /// haystack given, and if found, returns a [`Match`]. The `Match`
+    /// provides access to both the byte offsets of the match and the actual
+    /// substring that matched.
+    ///
+    /// Note that this should only be used if you want to find the entire
+    /// match. If instead you just want to test the existence of a match,
+    /// it's potentially faster to use `Regex::is_match(hay)` instead of
+    /// `Regex::find(hay).is_some()`.
+    ///
+    /// # Example
+    ///
+    /// Find the first word with exactly 13 Unicode word characters:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "I categorically deny having triskaidekaphobia.";
+    /// let mat = re.find(hay).unwrap();
+    /// assert_eq!(2..15, mat.range());
+    /// assert_eq!("categorically", mat.as_str());
+    /// ```
+    #[inline]
+    pub fn find<'h>(&self, haystack: &'h str) -> Option<Match<'h>> {
+        self.find_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Match`].
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `find_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// Find every word with exactly 13 Unicode word characters:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\b\w{13}\b").unwrap();
+    /// let hay = "Retroactively relinquishing remunerations is reprehensible.";
+    /// let matches: Vec<_> = re.find_iter(hay).map(|m| m.as_str()).collect();
+    /// assert_eq!(matches, vec![
+    ///     "Retroactively",
+    ///     "relinquishing",
+    ///     "remunerations",
+    ///     "reprehensible",
+    /// ]);
+    /// ```
+    #[inline]
+    pub fn find_iter<'r, 'h>(&'r self, haystack: &'h str) -> Matches<'r, 'h> {
+        Matches { haystack, it: self.meta.find_iter(haystack) }
+    }
+
+    /// This routine searches for the first match of this regex in the haystack
+    /// given, and if found, returns not only the overall match but also the
+    /// matches of each capture group in the regex. If no match is found, then
+    /// `None` is returned.
+    ///
+    /// Capture group `0` always corresponds to an implicit unnamed group that
+    /// includes the entire match. If a match is found, this group is always
+    /// present. Subsequent groups may be named and are numbered, starting
+    /// at 1, by the order in which the opening parenthesis appears in the
+    /// pattern. For example, in the pattern `(?<a>.(?<b>.))(?<c>.)`, `a`,
+    /// `b` and `c` correspond to capture group indices `1`, `2` and `3`,
+    /// respectively.
+    ///
+    /// You should only use `captures` if you need access to the capture group
+    /// matches. Otherwise, [`Regex::find`] is generally faster for discovering
+    /// just the overall match.
+    ///
+    /// # Example
+    ///
+    /// Say you have some haystack with movie names and their release years,
+    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for
+    /// substrings looking like that, while also extracting the movie name and
+    /// its release year separately. The example below shows how to do that.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.get(2).unwrap().as_str(), "1941");
+    /// // You can also access the groups by index using the Index notation.
+    /// // Note that this will panic on an invalid index. In this case, these
+    /// // accesses are always correct because the overall regex will only
+    /// // match when these capture groups match.
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    /// assert_eq!(&caps[1], "Citizen Kane");
+    /// assert_eq!(&caps[2], "1941");
+    /// ```
+    ///
+    /// Note that the full match is at capture group `0`. Each subsequent
+    /// capture group is indexed by the order of its opening `(`.
+    ///
+    /// We can make this example a bit clearer by using *named* capture groups:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(hay).unwrap();
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// assert_eq!(caps.name("title").unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.name("year").unwrap().as_str(), "1941");
+    /// // You can also access the groups by name using the Index notation.
+    /// // Note that this will panic on an invalid group name. In this case,
+    /// // these accesses are always correct because the overall regex will
+    /// // only match when these capture groups match.
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    /// assert_eq!(&caps["title"], "Citizen Kane");
+    /// assert_eq!(&caps["year"], "1941");
+    /// ```
+    ///
+    /// Here we name the capture groups, which we can access with the `name`
+    /// method or the `Index` notation with a `&str`. Note that the named
+    /// capture groups are still accessible with `get` or the `Index` notation
+    /// with a `usize`.
+    ///
+    /// The `0`th capture group is always unnamed, so it must always be
+    /// accessed with `get(0)` or `[0]`.
+    ///
+    /// Finally, one other way to to get the matched substrings is with the
+    /// [`Captures::extract`] API:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let hay = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let (full, [title, year]) = re.captures(hay).unwrap().extract();
+    /// assert_eq!(full, "'Citizen Kane' (1941)");
+    /// assert_eq!(title, "Citizen Kane");
+    /// assert_eq!(year, "1941");
+    /// ```
+    #[inline]
+    pub fn captures<'h>(&self, haystack: &'h str) -> Option<Captures<'h>> {
+        self.captures_at(haystack, 0)
+    }
+
+    /// Returns an iterator that yields successive non-overlapping matches in
+    /// the given haystack. The iterator yields values of type [`Captures`].
+    ///
+    /// This is the same as [`Regex::find_iter`], but instead of only providing
+    /// access to the overall match, each value yield includes access to the
+    /// matches of all capture groups in the regex. Reporting this extra match
+    /// data is potentially costly, so callers should only use `captures_iter`
+    /// over `find_iter` when they actually need access to the capture group
+    /// matches.
+    ///
+    /// # Time complexity
+    ///
+    /// Note that since `captures_iter` runs potentially many searches on the
+    /// haystack and since each search has worst case `O(m * n)` time
+    /// complexity, the overall worst case time complexity for iteration is
+    /// `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// We can use this to find all movie titles and their release years in
+    /// some haystack, where the movie is formatted like "'Title' (xxxx)":
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"'([^']+)'\s+\(([0-9]{4})\)").unwrap();
+    /// let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut movies = vec![];
+    /// for (_, [title, year]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     movies.push((title, year.parse::<i64>()?));
+    /// }
+    /// assert_eq!(movies, vec![
+    ///     ("Citizen Kane", 1941),
+    ///     ("The Wizard of Oz", 1939),
+    ///     ("M", 1931),
+    /// ]);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// Or with named groups:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"'(?<title>[^']+)'\s+\((?<year>[0-9]{4})\)").unwrap();
+    /// let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// let mut it = re.captures_iter(hay);
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "Citizen Kane");
+    /// assert_eq!(&caps["year"], "1941");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "The Wizard of Oz");
+    /// assert_eq!(&caps["year"], "1939");
+    ///
+    /// let caps = it.next().unwrap();
+    /// assert_eq!(&caps["title"], "M");
+    /// assert_eq!(&caps["year"], "1931");
+    /// ```
+    #[inline]
+    pub fn captures_iter<'r, 'h>(
+        &'r self,
+        haystack: &'h str,
+    ) -> CaptureMatches<'r, 'h> {
+        CaptureMatches { haystack, it: self.meta.captures_iter(haystack) }
+    }
+
+    /// Returns an iterator of substrings of the haystack given, delimited by a
+    /// match of the regex. Namely, each element of the iterator corresponds to
+    /// a part of the haystack that *isn't* matched by the regular expression.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"[ \t]+").unwrap();
+    /// let hay = "a b \t  c\td    e";
+    /// let fields: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);
+    /// ```
+    ///
+    /// # Example: more cases
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a", "little", "lamb"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["lion", "", "tiger", "leopard"]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["lion", "tiger", "leopard"]);
+    /// ```
+    ///
+    /// If a haystack contains multiple contiguous matches, you will end up
+    /// with empty spans yielded by the iterator:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "XXXXaXXbXc";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    ///
+    /// let re = Regex::new(r"/").unwrap();
+    /// let hay = "(///)";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["(", "", "", ")"]);
+    /// ```
+    ///
+    /// Separators at the start or end of a haystack are neighbored by empty
+    /// substring.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"0").unwrap();
+    /// let hay = "010";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "1", ""]);
+    /// ```
+    ///
+    /// When the empty string is used as a regex, it splits at every valid
+    /// UTF-8 boundary by default (which includes the beginning and end of the
+    /// haystack):
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let hay = "rust";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "r", "u", "s", "t", ""]);
+    ///
+    /// // Splitting by an empty string is UTF-8 aware by default!
+    /// let re = Regex::new(r"").unwrap();
+    /// let hay = "☃";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "☃", ""]);
+    /// ```
+    ///
+    /// Contiguous separators (commonly shows up with whitespace), can lead to
+    /// possibly surprising behavior. For example, this code is correct:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// assert_eq!(got, vec!["", "", "", "", "a", "", "b", "c"]);
+    /// ```
+    ///
+    /// It does *not* give you `["a", "b", "c"]`. For that behavior, you'd want
+    /// to match contiguous space characters:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r" +").unwrap();
+    /// let hay = "    a  b c";
+    /// let got: Vec<&str> = re.split(hay).collect();
+    /// // N.B. This does still include a leading empty span because ' +'
+    /// // matches at the beginning of the haystack.
+    /// assert_eq!(got, vec!["", "a", "b", "c"]);
+    /// ```
+    #[inline]
+    pub fn split<'r, 'h>(&'r self, haystack: &'h str) -> Split<'r, 'h> {
+        Split { haystack, it: self.meta.split(haystack) }
+    }
+
+    /// Returns an iterator of at most `limit` substrings of the haystack
+    /// given, delimited by a match of the regex. (A `limit` of `0` will return
+    /// no substrings.) Namely, each element of the iterator corresponds to a
+    /// part of the haystack that *isn't* matched by the regular expression.
+    /// The remainder of the haystack that is not split will be the last
+    /// element in the iterator.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some haystack:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let hay = "Hey! How are you?";
+    /// let fields: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(fields, vec!["Hey", "How", "are you?"]);
+    /// ```
+    ///
+    /// # Examples: more cases
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r" ").unwrap();
+    /// let hay = "Mary had a little lamb";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec!["Mary", "had", "a little lamb"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec![""]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "lionXXtigerXleopard";
+    /// let got: Vec<&str> = re.splitn(hay, 3).collect();
+    /// assert_eq!(got, vec!["lion", "", "tigerXleopard"]);
+    ///
+    /// let re = Regex::new(r"::").unwrap();
+    /// let hay = "lion::tiger::leopard";
+    /// let got: Vec<&str> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec!["lion", "tiger::leopard"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 1).collect();
+    /// assert_eq!(got, vec!["abcXdef"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcdef";
+    /// let got: Vec<&str> = re.splitn(hay, 2).collect();
+    /// assert_eq!(got, vec!["abcdef"]);
+    ///
+    /// let re = Regex::new(r"X").unwrap();
+    /// let hay = "abcXdef";
+    /// let got: Vec<&str> = re.splitn(hay, 0).collect();
+    /// assert!(got.is_empty());
+    /// ```
+    #[inline]
+    pub fn splitn<'r, 'h>(
+        &'r self,
+        haystack: &'h str,
+        limit: usize,
+    ) -> SplitN<'r, 'h> {
+        SplitN { haystack, it: self.meta.splitn(haystack, limit) }
+    }
+
+    /// Replaces the leftmost-first match in the given haystack with the
+    /// replacement provided. The replacement can be a regular string (where
+    /// `$N` and `$name` are expanded to match capture groups) or a function
+    /// that takes a [`Captures`] and returns the replaced string.
+    ///
+    /// If no match is found, then the haystack is returned unchanged. In that
+    /// case, this implementation will likely return a `Cow::Borrowed` value
+    /// such that no allocation is performed.
+    ///
+    /// # Replacement string syntax
+    ///
+    /// All instances of `$ref` in the replacement string are replaced with
+    /// the substring corresponding to the capture group identified by `ref`.
+    ///
+    /// `ref` may be an integer corresponding to the index of the capture group
+    /// (counted by order of opening parenthesis where `0` is the entire match)
+    /// or it can be a name (consisting of letters, digits or underscores)
+    /// corresponding to a named capture group.
+    ///
+    /// If `ref` isn't a valid capture group (whether the name doesn't exist or
+    /// isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name is used. For example, `$1a` looks up the
+    /// capture group named `1a` and not the capture group at index `1`. To
+    /// exert more precise control over the name, use braces, e.g., `${1}a`.
+    ///
+    /// To write a literal `$` use `$$`.
+    ///
+    /// # Example
+    ///
+    /// Note that this function is polymorphic with respect to the replacement.
+    /// In typical usage, this can just be a normal string:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"[^01]+").unwrap();
+    /// assert_eq!(re.replace("1078910", ""), "1010");
+    /// ```
+    ///
+    /// But anything satisfying the [`Replacer`] trait will work. For example,
+    /// a closure of type `|&Captures| -> String` provides direct access to the
+    /// captures corresponding to a match. This allows one to access capturing
+    /// group matches easily:
+    ///
+    /// ```
+    /// use regex::{Captures, Regex};
+    ///
+    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", |caps: &Captures| {
+    ///     format!("{} {}", &caps[2], &caps[1])
+    /// });
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// ```
+    ///
+    /// But this is a bit cumbersome to use all the time. Instead, a simple
+    /// syntax is supported (as described above) that expands `$name` into the
+    /// corresponding capture group. Here's the last example, but using this
+    /// expansion technique with named capture groups:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", "$first $last");
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// ```
+    ///
+    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
+    /// would produce the same result. To write a literal `$` use `$$`.
+    ///
+    /// Sometimes the replacement string requires use of curly braces to
+    /// delineate a capture group replacement when it is adjacent to some other
+    /// literal text. For example, if we wanted to join two words together with
+    /// an underscore:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<second>\w+)").unwrap();
+    /// let result = re.replace("deep fried", "${first}_$second");
+    /// assert_eq!(result, "deep_fried");
+    /// ```
+    ///
+    /// Without the curly braces, the capture group name `first_` would be
+    /// used, and since it doesn't exist, it would be replaced with the empty
+    /// string.
+    ///
+    /// Finally, sometimes you just want to replace a literal string with no
+    /// regard for capturing group expansion. This can be done by wrapping a
+    /// string with [`NoExpand`]:
+    ///
+    /// ```
+    /// use regex::{NoExpand, Regex};
+    ///
+    /// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
+    /// assert_eq!(result, "$2 $last");
+    /// ```
+    ///
+    /// Using `NoExpand` may also be faster, since the replacement string won't
+    /// need to be parsed for the `$` syntax.
+    #[inline]
+    pub fn replace<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        rep: R,
+    ) -> Cow<'h, str> {
+        self.replacen(haystack, 1, rep)
+    }
+
+    /// Replaces all non-overlapping matches in the haystack with the
+    /// replacement provided. This is the same as calling `replacen` with
+    /// `limit` set to `0`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// # Fallibility
+    ///
+    /// If you need to write a replacement routine where any individual
+    /// replacement might "fail," doing so with this API isn't really feasible
+    /// because there's no way to stop the search process if a replacement
+    /// fails. Instead, if you need this functionality, you should consider
+    /// implementing your own replacement routine:
+    ///
+    /// ```
+    /// use regex::{Captures, Regex};
+    ///
+    /// fn replace_all<E>(
+    ///     re: &Regex,
+    ///     haystack: &str,
+    ///     replacement: impl Fn(&Captures) -> Result<String, E>,
+    /// ) -> Result<String, E> {
+    ///     let mut new = String::with_capacity(haystack.len());
+    ///     let mut last_match = 0;
+    ///     for caps in re.captures_iter(haystack) {
+    ///         let m = caps.get(0).unwrap();
+    ///         new.push_str(&haystack[last_match..m.start()]);
+    ///         new.push_str(&replacement(&caps)?);
+    ///         last_match = m.end();
+    ///     }
+    ///     new.push_str(&haystack[last_match..]);
+    ///     Ok(new)
+    /// }
+    ///
+    /// // Let's replace each word with the number of bytes in that word.
+    /// // But if we see a word that is "too long," we'll give up.
+    /// let re = Regex::new(r"\w+").unwrap();
+    /// let replacement = |caps: &Captures| -> Result<String, &'static str> {
+    ///     if caps[0].len() >= 5 {
+    ///         return Err("word too long");
+    ///     }
+    ///     Ok(caps[0].len().to_string())
+    /// };
+    /// assert_eq!(
+    ///     Ok("2 3 3 3?".to_string()),
+    ///     replace_all(&re, "hi how are you?", &replacement),
+    /// );
+    /// assert!(replace_all(&re, "hi there", &replacement).is_err());
+    /// ```
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace (excluding line
+    /// terminators) delimited fields, and normalizes the whitespace that
+    /// delimits the fields:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)[\s--\r\n]+(\S+)$").unwrap();
+    /// let hay = "
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replace_all(hay, "$2 $1");
+    /// assert_eq!(new, "
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// 1975 BornToRun
+    /// 1978 Darkness
+    /// 1980 TheRiver
+    /// ");
+    /// ```
+    #[inline]
+    pub fn replace_all<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        rep: R,
+    ) -> Cow<'h, str> {
+        self.replacen(haystack, 0, rep)
+    }
+
+    /// Replaces at most `limit` non-overlapping matches in the haystack with
+    /// the replacement provided. If `limit` is `0`, then all non-overlapping
+    /// matches are replaced. That is, `Regex::replace_all(hay, rep)` is
+    /// equivalent to `Regex::replacen(hay, 0, rep)`.
+    ///
+    /// The documentation for [`Regex::replace`] goes into more detail about
+    /// what kinds of replacement strings are supported.
+    ///
+    /// # Time complexity
+    ///
+    /// Since iterators over all matches requires running potentially many
+    /// searches on the haystack, and since each search has worst case
+    /// `O(m * n)` time complexity, the overall worst case time complexity for
+    /// this routine is `O(m * n^2)`.
+    ///
+    /// Although note that the worst case time here has an upper bound given
+    /// by the `limit` parameter.
+    ///
+    /// # Fallibility
+    ///
+    /// See the corresponding section in the docs for [`Regex::replace_all`]
+    /// for tips on how to deal with a replacement routine that can fail.
+    ///
+    /// # Example
+    ///
+    /// This example shows how to flip the order of whitespace (excluding line
+    /// terminators) delimited fields, and normalizes the whitespace that
+    /// delimits the fields. But we only do it for the first two matches.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?m)^(\S+)[\s--\r\n]+(\S+)$").unwrap();
+    /// let hay = "
+    /// Greetings  1973
+    /// Wild\t1973
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ";
+    /// let new = re.replacen(hay, 2, "$2 $1");
+    /// assert_eq!(new, "
+    /// 1973 Greetings
+    /// 1973 Wild
+    /// BornToRun\t\t\t\t1975
+    /// Darkness                    1978
+    /// TheRiver 1980
+    /// ");
+    /// ```
+    #[inline]
+    pub fn replacen<'h, R: Replacer>(
+        &self,
+        haystack: &'h str,
+        limit: usize,
+        mut rep: R,
+    ) -> Cow<'h, str> {
+        // If we know that the replacement doesn't have any capture expansions,
+        // then we can use the fast path. The fast path can make a tremendous
+        // difference:
+        //
+        //   1) We use `find_iter` instead of `captures_iter`. Not asking for
+        //      captures generally makes the regex engines faster.
+        //   2) We don't need to look up all of the capture groups and do
+        //      replacements inside the replacement string. We just push it
+        //      at each match and be done with it.
+        if let Some(rep) = rep.no_expansion() {
+            let mut it = self.find_iter(haystack).enumerate().peekable();
+            if it.peek().is_none() {
+                return Cow::Borrowed(haystack);
+            }
+            let mut new = String::with_capacity(haystack.len());
+            let mut last_match = 0;
+            for (i, m) in it {
+                new.push_str(&haystack[last_match..m.start()]);
+                new.push_str(&rep);
+                last_match = m.end();
+                if limit > 0 && i >= limit - 1 {
+                    break;
+                }
+            }
+            new.push_str(&haystack[last_match..]);
+            return Cow::Owned(new);
+        }
+
+        // The slower path, which we use if the replacement may need access to
+        // capture groups.
+        let mut it = self.captures_iter(haystack).enumerate().peekable();
+        if it.peek().is_none() {
+            return Cow::Borrowed(haystack);
+        }
+        let mut new = String::with_capacity(haystack.len());
+        let mut last_match = 0;
+        for (i, cap) in it {
+            // unwrap on 0 is OK because captures only reports matches
+            let m = cap.get(0).unwrap();
+            new.push_str(&haystack[last_match..m.start()]);
+            rep.replace_append(&cap, &mut new);
+            last_match = m.end();
+            if limit > 0 && i >= limit - 1 {
+                break;
+            }
+        }
+        new.push_str(&haystack[last_match..]);
+        Cow::Owned(new)
+    }
+}
+
+/// A group of advanced or "lower level" search methods. Some methods permit
+/// starting the search at a position greater than `0` in the haystack. Other
+/// methods permit reusing allocations, for example, when extracting the
+/// matches for capture groups.
+impl Regex {
+    /// Returns the end byte offset of the first match in the haystack given.
+    ///
+    /// This method may have the same performance characteristics as
+    /// `is_match`. Behaviorlly, it doesn't just report whether it match
+    /// occurs, but also the end offset for a match. In particular, the offset
+    /// returned *may be shorter* than the proper end of the leftmost-first
+    /// match that you would find via [`Regex::find`].
+    ///
+    /// Note that it is not guaranteed that this routine finds the shortest or
+    /// "earliest" possible match. Instead, the main idea of this API is that
+    /// it returns the offset at the point at which the internal regex engine
+    /// has determined that a match has occurred. This may vary depending on
+    /// which internal regex engine is used, and thus, the offset itself may
+    /// change based on internal heuristics.
+    ///
+    /// # Example
+    ///
+    /// Typically, `a+` would match the entire first sequence of `a` in some
+    /// haystack, but `shortest_match` *may* give up as soon as it sees the
+    /// first `a`.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"a+").unwrap();
+    /// let offset = re.shortest_match("aaaaa").unwrap();
+    /// assert_eq!(offset, 1);
+    /// ```
+    #[inline]
+    pub fn shortest_match(&self, haystack: &str) -> Option<usize> {
+        self.shortest_match_at(haystack, 0)
+    }
+
+    /// Returns the same as [`Regex::shortest_match`], but starts the search at
+    /// the given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only match
+    /// when `start == 0`.
+    ///
+    /// If a match is found, the offset returned is relative to the beginning
+    /// of the haystack, not the beginning of the search.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.shortest_match(&hay[2..]), Some(4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.shortest_match_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn shortest_match_at(
+        &self,
+        haystack: &str,
+        start: usize,
+    ) -> Option<usize> {
+        let input =
+            Input::new(haystack).earliest(true).span(start..haystack.len());
+        self.meta.search_half(&input).map(|hm| hm.offset())
+    }
+
+    /// Returns the same as [`Regex::is_match`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.is_match(&hay[2..]));
+    /// // No match because the  assertions take the context into account.
+    /// assert!(!re.is_match_at(hay, 2));
+    /// ```
+    #[inline]
+    pub fn is_match_at(&self, haystack: &str, start: usize) -> bool {
+        let input =
+            Input::new(haystack).earliest(true).span(start..haystack.len());
+        self.meta.search_half(&input).is_some()
+    }
+
+    /// Returns the same as [`Regex::find`], but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(re.find(&hay[2..]).map(|m| m.range()), Some(0..4));
+    /// // No match because the  assertions take the context into account.
+    /// assert_eq!(re.find_at(hay, 2), None);
+    /// ```
+    #[inline]
+    pub fn find_at<'h>(
+        &self,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        self.meta
+            .search(&input)
+            .map(|m| Match::new(haystack, m.start(), m.end()))
+    }
+
+    /// Returns the same as [`Regex::captures`], but starts the search at the
+    /// given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// // We get a match here, but it's probably not intended.
+    /// assert_eq!(&re.captures(&hay[2..]).unwrap()[0], "chew");
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_at(hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_at<'h>(
+        &self,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Captures<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        let mut caps = self.meta.create_captures();
+        self.meta.search_captures(&input, &mut caps);
+        if caps.is_match() {
+            let static_captures_len = self.static_captures_len();
+            Some(Captures { haystack, caps, static_captures_len })
+        } else {
+            None
+        }
+    }
+
+    /// This is like [`Regex::captures`], but writes the byte offsets of each
+    /// capture group match into the locations given.
+    ///
+    /// A [`CaptureLocations`] stores the same byte offsets as a [`Captures`],
+    /// but does *not* store a reference to the haystack. This makes its API
+    /// a bit lower level and less convenience. But in exchange, callers
+    /// may allocate their own `CaptureLocations` and reuse it for multiple
+    /// searches. This may be helpful if allocating a `Captures` shows up in a
+    /// profile as too costly.
+    ///
+    /// To create a `CaptureLocations` value, use the
+    /// [`Regex::capture_locations`] method.
+    ///
+    /// This also the overall match if one was found. When a match is found,
+    /// its offsets are also always stored in `locs` at index `0`.
+    ///
+    /// # Panics
+    ///
+    /// This routine may panic if the given `CaptureLocations` was not created
+    /// by this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"^([a-z]+)=(\S*)$").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, "id=foo123").is_some());
+    /// assert_eq!(Some((0, 9)), locs.get(0));
+    /// assert_eq!(Some((0, 2)), locs.get(1));
+    /// assert_eq!(Some((3, 9)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn captures_read<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h str,
+    ) -> Option<Match<'h>> {
+        self.captures_read_at(locs, haystack, 0)
+    }
+
+    /// Returns the same as [`Regex::captures_read`], but starts the search at
+    /// the given offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// This routine may also panic if the given `CaptureLocations` was not
+    /// created by this regex.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start` by demonstrating how it
+    /// can be used to permit look-around assertions in a regex to take the
+    /// surrounding context into account.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"\bchew\b").unwrap();
+    /// let hay = "eschew";
+    /// let mut locs = re.capture_locations();
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(re.captures_read(&mut locs, &hay[2..]).is_some());
+    /// // No match because the  assertions take the context into account.
+    /// assert!(re.captures_read_at(&mut locs, hay, 2).is_none());
+    /// ```
+    #[inline]
+    pub fn captures_read_at<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Match<'h>> {
+        let input = Input::new(haystack).span(start..haystack.len());
+        self.meta.search_captures(&input, &mut locs.0);
+        locs.0.get_match().map(|m| Match::new(haystack, m.start(), m.end()))
+    }
+
+    /// An undocumented alias for `captures_read_at`.
+    ///
+    /// The `regex-capi` crate previously used this routine, so to avoid
+    /// breaking that crate, we continue to provide the name as an undocumented
+    /// alias.
+    #[doc(hidden)]
+    #[inline]
+    pub fn read_captures_at<'h>(
+        &self,
+        locs: &mut CaptureLocations,
+        haystack: &'h str,
+        start: usize,
+    ) -> Option<Match<'h>> {
+        self.captures_read_at(locs, haystack, start)
+    }
+}
+
+/// Auxiliary methods.
+impl Regex {
+    /// Returns the original string of this regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"foo\w+bar").unwrap();
+    /// assert_eq!(re.as_str(), r"foo\w+bar");
+    /// ```
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Returns an iterator over the capture names in this regex.
+    ///
+    /// The iterator returned yields elements of type `Option<&str>`. That is,
+    /// the iterator yields values for all capture groups, even ones that are
+    /// unnamed. The order of the groups corresponds to the order of the group's
+    /// corresponding opening parenthesis.
+    ///
+    /// The first element of the iterator always yields the group corresponding
+    /// to the overall match, and this group is always unnamed. Therefore, the
+    /// iterator always yields at least one group.
+    ///
+    /// # Example
+    ///
+    /// This shows basic usage with a mix of named and unnamed capture groups:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), Some(Some("a")));
+    /// assert_eq!(names.next(), Some(Some("b")));
+    /// assert_eq!(names.next(), Some(None));
+    /// // the '(?:.)' group is non-capturing and so doesn't appear here!
+    /// assert_eq!(names.next(), Some(Some("c")));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    ///
+    /// The iterator always yields at least one element, even for regexes with
+    /// no capture groups and even for regexes that can never match:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    ///
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// let mut names = re.capture_names();
+    /// assert_eq!(names.next(), Some(None));
+    /// assert_eq!(names.next(), None);
+    /// ```
+    #[inline]
+    pub fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames(self.meta.group_info().pattern_names(PatternID::ZERO))
+    }
+
+    /// Returns the number of captures groups in this regex.
+    ///
+    /// This includes all named and unnamed groups, including the implicit
+    /// unnamed group that is always present and corresponds to the entire
+    /// match.
+    ///
+    /// Since the implict unnamed group is always included in this length, the
+    /// length returned is guaranteed to be greater than zero.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"foo").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(foo)").unwrap();
+    /// assert_eq!(2, re.captures_len());
+    ///
+    /// let re = Regex::new(r"(?<a>.(?<b>.))(.)(?:.)(?<c>.)").unwrap();
+    /// assert_eq!(5, re.captures_len());
+    ///
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// assert_eq!(1, re.captures_len());
+    /// ```
+    #[inline]
+    pub fn captures_len(&self) -> usize {
+        self.meta.group_info().group_len(PatternID::ZERO)
+    }
+
+    /// Returns the total number of capturing groups that appear in every
+    /// possible match.
+    ///
+    /// If the number of capture groups can vary depending on the match, then
+    /// this returns `None`. That is, a value is only returned when the number
+    /// of matching groups is invariant or "static."
+    ///
+    /// Note that like [`Regex::captures_len`], this **does** include the
+    /// implicit capturing group corresponding to the entire match. Therefore,
+    /// when a non-None value is returned, it is guaranteed to be at least `1`.
+    /// Stated differently, a return value of `Some(0)` is impossible.
+    ///
+    /// # Example
+    ///
+    /// This shows a few cases where a static number of capture groups is
+    /// available and a few cases where it is not.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let len = |pattern| {
+    ///     Regex::new(pattern).map(|re| re.static_captures_len())
+    /// };
+    ///
+    /// assert_eq!(Some(1), len("a")?);
+    /// assert_eq!(Some(2), len("(a)")?);
+    /// assert_eq!(Some(2), len("(a)|(b)")?);
+    /// assert_eq!(Some(3), len("(a)(b)|(c)(d)")?);
+    /// assert_eq!(None, len("(a)|b")?);
+    /// assert_eq!(None, len("a|(b)")?);
+    /// assert_eq!(None, len("(b)*")?);
+    /// assert_eq!(Some(2), len("(b)+")?);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn static_captures_len(&self) -> Option<usize> {
+        self.meta.static_captures_len()
+    }
+
+    /// Returns a fresh allocated set of capture locations that can
+    /// be reused in multiple calls to [`Regex::captures_read`] or
+    /// [`Regex::captures_read_at`].
+    ///
+    /// The returned locations can be used for any subsequent search for this
+    /// particular regex. There is no guarantee that it is correct to use for
+    /// other regexes, even if they have the same number of capture groups.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(.)(.)(\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert!(re.captures_read(&mut locs, "Padron").is_some());
+    /// assert_eq!(locs.get(0), Some((0, 6)));
+    /// assert_eq!(locs.get(1), Some((0, 1)));
+    /// assert_eq!(locs.get(2), Some((1, 2)));
+    /// assert_eq!(locs.get(3), Some((2, 6)));
+    /// ```
+    #[inline]
+    pub fn capture_locations(&self) -> CaptureLocations {
+        CaptureLocations(self.meta.create_captures())
+    }
+
+    /// An alias for `capture_locations` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate used this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn locations(&self) -> CaptureLocations {
+        self.capture_locations()
+    }
+}
+
+/// Represents a single match of a regex in a haystack.
+///
+/// A `Match` contains both the start and end byte offsets of the match and the
+/// actual substring corresponding to the range of those byte offsets. It is
+/// guaranteed that `start <= end`. When `start == end`, the match is empty.
+///
+/// Since this `Match` can only be produced by the top-level `Regex` APIs
+/// that only support searching UTF-8 encoded strings, the byte offsets for a
+/// `Match` are guaranteed to fall on valid UTF-8 codepoint boundaries. That
+/// is, slicing a `&str` with [`Match::range`] is guaranteed to never panic.
+///
+/// Values with this type are created by [`Regex::find`] or
+/// [`Regex::find_iter`]. Other APIs can create `Match` values too. For
+/// example, [`Captures::get`].
+///
+/// The lifetime parameter `'h` refers to the lifetime of the matched of the
+/// haystack that this match was produced from.
+///
+/// # Numbering
+///
+/// The byte offsets in a `Match` form a half-open interval. That is, the
+/// start of the range is inclusive and the end of the range is exclusive.
+/// For example, given a haystack `abcFOOxyz` and a match of `FOO`, its byte
+/// offset range starts at `3` and ends at `6`. `3` corresponds to `F` and
+/// `6` corresponds to `x`, which is one past the end of the match. This
+/// corresponds to the same kind of slicing that Rust uses.
+///
+/// For more on why this was chosen over other schemes (aside from being
+/// consistent with how Rust the language works), see [this discussion] and
+/// [Dijkstra's note on a related topic][note].
+///
+/// [this discussion]: https://github.com/rust-lang/regex/discussions/866
+/// [note]: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html
+///
+/// # Example
+///
+/// This example shows the value of each of the methods on `Match` for a
+/// particular search.
+///
+/// ```
+/// use regex::Regex;
+///
+/// let re = Regex::new(r"\p{Greek}+").unwrap();
+/// let hay = "Greek: αβγδ";
+/// let m = re.find(hay).unwrap();
+/// assert_eq!(7, m.start());
+/// assert_eq!(15, m.end());
+/// assert!(!m.is_empty());
+/// assert_eq!(8, m.len());
+/// assert_eq!(7..15, m.range());
+/// assert_eq!("αβγδ", m.as_str());
+/// ```
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct Match<'h> {
+    haystack: &'h str,
+    start: usize,
+    end: usize,
+}
+
+impl<'h> Match<'h> {
+    /// Returns the byte offset of the start of the match in the haystack. The
+    /// start of the match corresponds to the position where the match begins
+    /// and includes the first byte in the match.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// This is guaranteed to fall on a valid UTF-8 codepoint boundary. That
+    /// is, it will never be an offset that appears between the UTF-8 code
+    /// units of a UTF-8 encoded Unicode scalar value. Consequently, it is
+    /// always safe to slice the corresponding haystack using this offset.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Returns the byte offset of the end of the match in the haystack. The
+    /// end of the match corresponds to the byte immediately following the last
+    /// byte in the match. This means that `&slice[start..end]` works as one
+    /// would expect.
+    ///
+    /// It is guaranteed that `Match::start() <= Match::end()`.
+    ///
+    /// This is guaranteed to fall on a valid UTF-8 codepoint boundary. That
+    /// is, it will never be an offset that appears between the UTF-8 code
+    /// units of a UTF-8 encoded Unicode scalar value. Consequently, it is
+    /// always safe to slice the corresponding haystack using this offset.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    /// Returns true if and only if this match has a length of zero.
+    ///
+    /// Note that an empty match can only occur when the regex itself can
+    /// match the empty string. Here are some examples of regexes that can
+    /// all match the empty string: `^`, `^$`, `\b`, `a?`, `a*`, `a{0}`,
+    /// `(foo|\d+|quux)?`.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.start == self.end
+    }
+
+    /// Returns the length, in bytes, of this match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.end - self.start
+    }
+
+    /// Returns the range over the starting and ending byte offsets of the
+    /// match in the haystack.
+    ///
+    /// It is always correct to slice the original haystack searched with this
+    /// range. That is, because the offsets are guaranteed to fall on valid
+    /// UTF-8 boundaries, the range returned is always valid.
+    #[inline]
+    pub fn range(&self) -> core::ops::Range<usize> {
+        self.start..self.end
+    }
+
+    /// Returns the substring of the haystack that matched.
+    #[inline]
+    pub fn as_str(&self) -> &'h str {
+        &self.haystack[self.range()]
+    }
+
+    /// Creates a new match from the given haystack and byte offsets.
+    #[inline]
+    fn new(haystack: &'h str, start: usize, end: usize) -> Match<'h> {
+        Match { haystack, start, end }
+    }
+}
+
+impl<'h> core::fmt::Debug for Match<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("Match")
+            .field("start", &self.start)
+            .field("end", &self.end)
+            .field("string", &self.as_str())
+            .finish()
+    }
+}
+
+impl<'h> From<Match<'h>> for &'h str {
+    fn from(m: Match<'h>) -> &'h str {
+        m.as_str()
+    }
+}
+
+impl<'h> From<Match<'h>> for core::ops::Range<usize> {
+    fn from(m: Match<'h>) -> core::ops::Range<usize> {
+        m.range()
+    }
+}
+
+/// Represents the capture groups for a single match.
+///
+/// Capture groups refer to parts of a regex enclosed in parentheses. They can
+/// be optionally named. The purpose of capture groups is to be able to
+/// reference different parts of a match based on the original pattern. For
+/// example, say you want to match the individual letters in a 5-letter word:
+///
+/// ```text
+/// (?<first>\w)(\w)(?:\w)\w(?<last>\w)
+/// ```
+///
+/// This regex has 4 capture groups:
+///
+/// * The group at index `0` corresponds to the overall match. It is always
+/// present in every match and never has a name.
+/// * The group at index `1` with name `first` corresponding to the first
+/// letter.
+/// * The group at index `2` with no name corresponding to the second letter.
+/// * The group at index `3` with name `last` corresponding to the fifth and
+/// last letter.
+///
+/// Notice that `(?:\w)` was not listed above as a capture group despite it
+/// being enclosed in parentheses. That's because `(?:pattern)` is a special
+/// syntax that permits grouping but *without* capturing. The reason for not
+/// treating it as a capture is that tracking and reporting capture groups
+/// requires additional state that may lead to slower searches. So using as few
+/// capture groups as possible can help performance. (Although the difference
+/// in performance of a couple of capture groups is likely immaterial.)
+///
+/// Values with this type are created by [`Regex::captures`] or
+/// [`Regex::captures_iter`].
+///
+/// `'h` is the lifetime of the haystack that these captures were matched from.
+///
+/// # Example
+///
+/// ```
+/// use regex::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w)(\w)(?:\w)\w(?<last>\w)").unwrap();
+/// let caps = re.captures("toady").unwrap();
+/// assert_eq!("toady", &caps[0]);
+/// assert_eq!("t", &caps["first"]);
+/// assert_eq!("o", &caps[2]);
+/// assert_eq!("y", &caps["last"]);
+/// ```
+pub struct Captures<'h> {
+    haystack: &'h str,
+    caps: captures::Captures,
+    static_captures_len: Option<usize>,
+}
+
+impl<'h> Captures<'h> {
+    /// Returns the `Match` associated with the capture group at index `i`. If
+    /// `i` does not correspond to a capture group, or if the capture group did
+    /// not participate in the match, then `None` is returned.
+    ///
+    /// When `i == 0`, this is guaranteed to return a non-`None` value.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
+    /// let caps = re.captures("abc123").unwrap();
+    ///
+    /// let substr1 = caps.get(1).map_or("", |m| m.as_str());
+    /// let substr2 = caps.get(2).map_or("", |m| m.as_str());
+    /// assert_eq!(substr1, "123");
+    /// assert_eq!(substr2, "");
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<Match<'h>> {
+        self.caps
+            .get_group(i)
+            .map(|sp| Match::new(self.haystack, sp.start, sp.end))
+    }
+
+    /// Returns the `Match` associated with the capture group named `name`. If
+    /// `name` isn't a valid capture group or it refers to a group that didn't
+    /// match, then `None` is returned.
+    ///
+    /// Note that unlike `caps["name"]`, this returns a `Match` whose lifetime
+    /// matches the lifetime of the haystack in this `Captures` value.
+    /// Conversely, the substring returned by `caps["name"]` has a lifetime
+    /// of the `Captures` value, which is likely shorter than the lifetime of
+    /// the haystack. In some cases, it may be necessary to use this method to
+    /// access the matching substring instead of the `caps["name"]` notation.
+    ///
+    /// # Examples
+    ///
+    /// Get the substring that matched with a default of an empty string if the
+    /// group didn't participate in the match:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"[a-z]+(?:(?<numbers>[0-9]+)|(?<letters>[A-Z]+))",
+    /// ).unwrap();
+    /// let caps = re.captures("abc123").unwrap();
+    ///
+    /// let numbers = caps.name("numbers").map_or("", |m| m.as_str());
+    /// let letters = caps.name("letters").map_or("", |m| m.as_str());
+    /// assert_eq!(numbers, "123");
+    /// assert_eq!(letters, "");
+    /// ```
+    #[inline]
+    pub fn name(&self, name: &str) -> Option<Match<'h>> {
+        self.caps
+            .get_group_by_name(name)
+            .map(|sp| Match::new(self.haystack, sp.start, sp.end))
+    }
+
+    /// This is a convenience routine for extracting the substrings
+    /// corresponding to matching capture groups.
+    ///
+    /// This returns a tuple where the first element corresponds to the full
+    /// substring of the haystack that matched the regex. The second element is
+    /// an array of substrings, with each corresponding to the to the substring
+    /// that matched for a particular capture group.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the number of possible matching groups in this
+    /// `Captures` value is not fixed to `N` in all circumstances.
+    /// More precisely, this routine only works when `N` is equivalent to
+    /// [`Regex::static_captures_len`].
+    ///
+    /// Stated more plainly, if the number of matching capture groups in a
+    /// regex can vary from match to match, then this function always panics.
+    ///
+    /// For example, `(a)(b)|(c)` could produce two matching capture groups
+    /// or one matching capture group for any given match. Therefore, one
+    /// cannot use `extract` with such a pattern.
+    ///
+    /// But a pattern like `(a)(b)|(c)(d)` can be used with `extract` because
+    /// the number of capture groups in every match is always equivalent,
+    /// even if the capture _indices_ in each match are not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = "On 2010-03-14, I became a Tenneessee lamb.";
+    /// let Some((full, [year, month, day])) =
+    ///     re.captures(hay).map(|caps| caps.extract()) else { return };
+    /// assert_eq!("2010-03-14", full);
+    /// assert_eq!("2010", year);
+    /// assert_eq!("03", month);
+    /// assert_eq!("14", day);
+    /// ```
+    ///
+    /// # Example: iteration
+    ///
+    /// This example shows how to use this method when iterating over all
+    /// `Captures` matches in a haystack.
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"([0-9]{4})-([0-9]{2})-([0-9]{2})").unwrap();
+    /// let hay = "1973-01-05, 1975-08-25 and 1980-10-18";
+    ///
+    /// let mut dates: Vec<(&str, &str, &str)> = vec![];
+    /// for (_, [y, m, d]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     dates.push((y, m, d));
+    /// }
+    /// assert_eq!(dates, vec![
+    ///     ("1973", "01", "05"),
+    ///     ("1975", "08", "25"),
+    ///     ("1980", "10", "18"),
+    /// ]);
+    /// ```
+    ///
+    /// # Example: parsing different formats
+    ///
+    /// This API is particularly useful when you need to extract a particular
+    /// value that might occur in a different format. Consider, for example,
+    /// an identifier that might be in double quotes or single quotes:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r#"id:(?:"([^"]+)"|'([^']+)')"#).unwrap();
+    /// let hay = r#"The first is id:"foo" and the second is id:'bar'."#;
+    /// let mut ids = vec![];
+    /// for (_, [id]) in re.captures_iter(hay).map(|c| c.extract()) {
+    ///     ids.push(id);
+    /// }
+    /// assert_eq!(ids, vec!["foo", "bar"]);
+    /// ```
+    pub fn extract<const N: usize>(&self) -> (&'h str, [&'h str; N]) {
+        let len = self
+            .static_captures_len
+            .expect("number of capture groups can vary in a match")
+            .checked_sub(1)
+            .expect("number of groups is always greater than zero");
+        assert_eq!(N, len, "asked for {} groups, but must ask for {}", N, len);
+        // The regex-automata variant of extract is a bit more permissive.
+        // It doesn't require the number of matching capturing groups to be
+        // static, and you can even request fewer groups than what's there. So
+        // this is guaranteed to never panic because we've asserted above that
+        // the user has requested precisely the number of groups that must be
+        // present in any match for this regex.
+        self.caps.extract(self.haystack)
+    }
+
+    /// Expands all instances of `$ref` in `replacement` to the corresponding
+    /// capture group, and writes them to the `dst` buffer given. A `ref` can
+    /// be a capture group index or a name. If `ref` doesn't refer to a capture
+    /// group that participated in the match, then it is replaced with the
+    /// empty string.
+    ///
+    /// # Format
+    ///
+    /// The format of the replacement string supports two different kinds of
+    /// capture references: unbraced and braced.
+    ///
+    /// For the unbraced format, the format supported is `$ref` where `name`
+    /// can be any character in the class `[0-9A-Za-z_]`. `ref` is always
+    /// the longest possible parse. So for example, `$1a` corresponds to the
+    /// capture group named `1a` and not the capture group at index `1`. If
+    /// `ref` matches `^[0-9]+$`, then it is treated as a capture group index
+    /// itself and not a name.
+    ///
+    /// For the braced format, the format supported is `${ref}` where `ref` can
+    /// be any sequence of bytes except for `}`. If no closing brace occurs,
+    /// then it is not considered a capture reference. As with the unbraced
+    /// format, if `ref` matches `^[0-9]+$`, then it is treated as a capture
+    /// group index and not a name.
+    ///
+    /// The braced format is useful for exerting precise control over the name
+    /// of the capture reference. For example, `${1}a` corresponds to the
+    /// capture group reference `1` followed by the letter `a`, where as `$1a`
+    /// (as mentioned above) corresponds to the capture group reference `1a`.
+    /// The braced format is also useful for expressing capture group names
+    /// that use characters not supported by the unbraced format. For example,
+    /// `${foo[bar].baz}` refers to the capture group named `foo[bar].baz`.
+    ///
+    /// If a capture group reference is found and it does not refer to a valid
+    /// capture group, then it will be replaced with the empty string.
+    ///
+    /// To write a literal `$`, use `$$`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(
+    ///     r"(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})",
+    /// ).unwrap();
+    /// let hay = "On 14-03-2010, I became a Tenneessee lamb.";
+    /// let caps = re.captures(hay).unwrap();
+    ///
+    /// let mut dst = String::new();
+    /// caps.expand("year=$year, month=$month, day=$day", &mut dst);
+    /// assert_eq!(dst, "year=2010, month=03, day=14");
+    /// ```
+    #[inline]
+    pub fn expand(&self, replacement: &str, dst: &mut String) {
+        self.caps.interpolate_string_into(self.haystack, replacement, dst);
+    }
+
+    /// Returns an iterator over all capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The iterator always yields at least one matching group: the first group
+    /// (at index `0`) with no name. Subsequent groups are returned in the order
+    /// of their opening parenthesis in the regex.
+    ///
+    /// The elements yielded have type `Option<Match<'h>>`, where a non-`None`
+    /// value is present if the capture group matches.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures("AZ").unwrap();
+    ///
+    /// let mut it = caps.iter();
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("AZ"));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("A"));
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), None);
+    /// assert_eq!(it.next().unwrap().map(|m| m.as_str()), Some("Z"));
+    /// assert_eq!(it.next(), None);
+    /// ```
+    #[inline]
+    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 'h> {
+        SubCaptureMatches { haystack: self.haystack, it: self.caps.iter() }
+    }
+
+    /// Returns the total number of capture groups. This includes both
+    /// matching and non-matching groups.
+    ///
+    /// The length returned is always equivalent to the number of elements
+    /// yielded by [`Captures::iter`]. Consequently, the length is always
+    /// greater than zero since every `Captures` value always includes the
+    /// match for the entire regex.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(\w)(\d)?(\w)").unwrap();
+    /// let caps = re.captures("AZ").unwrap();
+    /// assert_eq!(caps.len(), 4);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.caps.group_len()
+    }
+}
+
+impl<'h> core::fmt::Debug for Captures<'h> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        /// A little helper type to provide a nice map-like debug
+        /// representation for our capturing group spans.
+        ///
+        /// regex-automata has something similar, but it includes the pattern
+        /// ID in its debug output, which is confusing. It also doesn't include
+        /// that strings that match because a regex-automata `Captures` doesn't
+        /// borrow the haystack.
+        struct CapturesDebugMap<'a> {
+            caps: &'a Captures<'a>,
+        }
+
+        impl<'a> core::fmt::Debug for CapturesDebugMap<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                let mut map = f.debug_map();
+                let names =
+                    self.caps.caps.group_info().pattern_names(PatternID::ZERO);
+                for (group_index, maybe_name) in names.enumerate() {
+                    let key = Key(group_index, maybe_name);
+                    match self.caps.get(group_index) {
+                        None => map.entry(&key, &None::<()>),
+                        Some(mat) => map.entry(&key, &Value(mat)),
+                    };
+                }
+                map.finish()
+            }
+        }
+
+        struct Key<'a>(usize, Option<&'a str>);
+
+        impl<'a> core::fmt::Debug for Key<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "{}", self.0)?;
+                if let Some(name) = self.1 {
+                    write!(f, "/{:?}", name)?;
+                }
+                Ok(())
+            }
+        }
+
+        struct Value<'a>(Match<'a>);
+
+        impl<'a> core::fmt::Debug for Value<'a> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(
+                    f,
+                    "{}..{}/{:?}",
+                    self.0.start(),
+                    self.0.end(),
+                    self.0.as_str()
+                )
+            }
+        }
+
+        f.debug_tuple("Captures")
+            .field(&CapturesDebugMap { caps: self })
+            .finish()
+    }
+}
+
+/// Get a matching capture group's haystack substring by index.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// # Panics
+///
+/// If there is no matching group at the given index.
+impl<'h> core::ops::Index<usize> for Captures<'h> {
+    type Output = str;
+
+    // The lifetime is written out to make it clear that the &str returned
+    // does NOT have a lifetime equivalent to 'h.
+    fn index<'a>(&'a self, i: usize) -> &'a str {
+        self.get(i)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+    }
+}
+
+/// Get a matching capture group's haystack substring by name.
+///
+/// The haystack substring returned can't outlive the `Captures` object if this
+/// method is used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it). To work around this limitation, do that, use
+/// [`Captures::get`] instead.
+///
+/// `'h` is the lifetime of the matched haystack, but the lifetime of the
+/// `&str` returned by this implementation is the lifetime of the `Captures`
+/// value itself.
+///
+/// `'n` is the lifetime of the group name used to index the `Captures` value.
+///
+/// # Panics
+///
+/// If there is no matching group at the given name.
+impl<'h, 'n> core::ops::Index<&'n str> for Captures<'h> {
+    type Output = str;
+
+    fn index<'a>(&'a self, name: &'n str) -> &'a str {
+        self.name(name)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group named '{}'", name))
+    }
+}
+
+/// A low level representation of the byte offsets of each capture group.
+///
+/// You can think of this as a lower level [`Captures`], where this type does
+/// not support named capturing groups directly and it does not borrow the
+/// haystack that these offsets were matched on.
+///
+/// Primarily, this type is useful when using the lower level `Regex` APIs such
+/// as [`Regex::captures_read`], which permits amortizing the allocation in
+/// which capture match offsets are stored.
+///
+/// In order to build a value of this type, you'll need to call the
+/// [`Regex::capture_locations`] method. The value returned can then be reused
+/// in subsequent searches for that regex. Using it for other regexes may
+/// result in a panic or otherwise incorrect results.
+///
+/// # Example
+///
+/// This example shows how to create and use `CaptureLocations` in a search.
+///
+/// ```
+/// use regex::Regex;
+///
+/// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+/// let mut locs = re.capture_locations();
+/// let m = re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+/// assert_eq!(0..17, m.range());
+/// assert_eq!(Some((0, 17)), locs.get(0));
+/// assert_eq!(Some((0, 5)), locs.get(1));
+/// assert_eq!(Some((6, 17)), locs.get(2));
+///
+/// // Asking for an invalid capture group always returns None.
+/// assert_eq!(None, locs.get(3));
+/// assert_eq!(None, locs.get(34973498648));
+/// assert_eq!(None, locs.get(9944060567225171988));
+/// ```
+#[derive(Clone, Debug)]
+pub struct CaptureLocations(captures::Captures);
+
+/// A type alias for `CaptureLocations` for backwards compatibility.
+///
+/// Previously, we exported `CaptureLocations` as `Locations` in an
+/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
+/// we continue re-exporting the same undocumented API.
+#[doc(hidden)]
+pub type Locations = CaptureLocations;
+
+impl CaptureLocations {
+    /// Returns the start and end byte offsets of the capture group at index
+    /// `i`. This returns `None` if `i` is not a valid capture group or if the
+    /// capture group did not match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+    /// assert_eq!(Some((0, 17)), locs.get(0));
+    /// assert_eq!(Some((0, 5)), locs.get(1));
+    /// assert_eq!(Some((6, 17)), locs.get(2));
+    /// ```
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
+        self.0.get_group(i).map(|sp| (sp.start, sp.end))
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    /// That is, the length returned is unaffected by the result of a search.
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"(?<first>\w+)\s+(?<last>\w+)").unwrap();
+    /// let mut locs = re.capture_locations();
+    /// assert_eq!(3, locs.len());
+    /// re.captures_read(&mut locs, "Bruce Springsteen").unwrap();
+    /// assert_eq!(3, locs.len());
+    /// ```
+    ///
+    /// Notice that the length is always at least `1`, regardless of the regex:
+    ///
+    /// ```
+    /// use regex::Regex;
+    ///
+    /// let re = Regex::new(r"").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    ///
+    /// // [a&&b] is a regex that never matches anything.
+    /// let re = Regex::new(r"[a&&b]").unwrap();
+    /// let locs = re.capture_locations();
+    /// assert_eq!(1, locs.len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        // self.0.group_len() returns 0 if the underlying captures doesn't
+        // represent a match, but the behavior guaranteed for this method is
+        // that the length doesn't change based on a match or not.
+        self.0.group_info().group_len(PatternID::ZERO)
+    }
+
+    /// An alias for the `get` method for backwards compatibility.
+    ///
+    /// Previously, we exported `get` as `pos` in an undocumented API. To
+    /// prevent breaking that code (e.g., in `regex-capi`), we continue
+    /// re-exporting the same undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
+        self.get(i)
+    }
+}
+
+/// An iterator over all non-overlapping matches in a haystack.
+///
+/// This iterator yields [`Match`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the haystack.
+///
+/// This iterator is created by [`Regex::find_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Matches<'r, 'h> {
+    haystack: &'h str,
+    it: meta::FindMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for Matches<'r, 'h> {
+    type Item = Match<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Match<'h>> {
+        self.it
+            .next()
+            .map(|sp| Match::new(self.haystack, sp.start(), sp.end()))
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        // This can actually be up to 2x faster than calling `next()` until
+        // completion, because counting matches when using a DFA only requires
+        // finding the end of each match. But returning a `Match` via `next()`
+        // requires the start of each match which, with a DFA, requires a
+        // reverse forward scan to find it.
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Matches<'r, 'h> {}
+
+/// An iterator over all non-overlapping capture matches in a haystack.
+///
+/// This iterator yields [`Captures`] values. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the matched string.
+///
+/// This iterator is created by [`Regex::captures_iter`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct CaptureMatches<'r, 'h> {
+    haystack: &'h str,
+    it: meta::CapturesMatches<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for CaptureMatches<'r, 'h> {
+    type Item = Captures<'h>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Captures<'h>> {
+        let static_captures_len = self.it.regex().static_captures_len();
+        self.it.next().map(|caps| Captures {
+            haystack: self.haystack,
+            caps,
+            static_captures_len,
+        })
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        // This can actually be up to 2x faster than calling `next()` until
+        // completion, because counting matches when using a DFA only requires
+        // finding the end of each match. But returning a `Match` via `next()`
+        // requires the start of each match which, with a DFA, requires a
+        // reverse forward scan to find it.
+        self.it.count()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for CaptureMatches<'r, 'h> {}
+
+/// An iterator over all substrings delimited by a regex match.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::split`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+#[derive(Debug)]
+pub struct Split<'r, 'h> {
+    haystack: &'h str,
+    it: meta::Split<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for Split<'r, 'h> {
+    type Item = &'h str;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h str> {
+        self.it.next().map(|span| &self.haystack[span])
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for Split<'r, 'h> {}
+
+/// An iterator over at most `N` substrings delimited by a regex match.
+///
+/// The last substring yielded by this iterator will be whatever remains after
+/// `N-1` splits.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'h` is the
+/// lifetime of the byte string being split.
+///
+/// This iterator is created by [`Regex::splitn`].
+///
+/// # Time complexity
+///
+/// Note that since an iterator runs potentially many searches on the haystack
+/// and since each search has worst case `O(m * n)` time complexity, the
+/// overall worst case time complexity for iteration is `O(m * n^2)`.
+///
+/// Although note that the worst case time here has an upper bound given
+/// by the `limit` parameter to [`Regex::splitn`].
+#[derive(Debug)]
+pub struct SplitN<'r, 'h> {
+    haystack: &'h str,
+    it: meta::SplitN<'r, 'h>,
+}
+
+impl<'r, 'h> Iterator for SplitN<'r, 'h> {
+    type Item = &'h str;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'h str> {
+        self.it.next().map(|span| &self.haystack[span])
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'r, 'h> core::iter::FusedIterator for SplitN<'r, 'h> {}
+
+/// An iterator over the names of all capture groups in a regex.
+///
+/// This iterator yields values of type `Option<&str>` in order of the opening
+/// capture group parenthesis in the regex pattern. `None` is yielded for
+/// groups with no name. The first element always corresponds to the implicit
+/// and unnamed group for the overall match.
+///
+/// `'r` is the lifetime of the compiled regular expression.
+///
+/// This iterator is created by [`Regex::capture_names`].
+#[derive(Clone, Debug)]
+pub struct CaptureNames<'r>(captures::GroupInfoPatternNames<'r>);
+
+impl<'r> Iterator for CaptureNames<'r> {
+    type Item = Option<&'r str>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<&'r str>> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<'r> ExactSizeIterator for CaptureNames<'r> {}
+
+impl<'r> core::iter::FusedIterator for CaptureNames<'r> {}
+
+/// An iterator over all group matches in a [`Captures`] value.
+///
+/// This iterator yields values of type `Option<Match<'h>>`, where `'h` is the
+/// lifetime of the haystack that the matches are for. The order of elements
+/// yielded corresponds to the order of the opening parenthesis for the group
+/// in the regex pattern. `None` is yielded for groups that did not participate
+/// in the match.
+///
+/// The first element always corresponds to the implicit group for the overall
+/// match. Since this iterator is created by a [`Captures`] value, and a
+/// `Captures` value is only created when a match occurs, it follows that the
+/// first element yielded by this iterator is guaranteed to be non-`None`.
+///
+/// The lifetime `'c` corresponds to the lifetime of the `Captures` value that
+/// created this iterator, and the lifetime `'h` corresponds to the originally
+/// matched haystack.
+#[derive(Clone, Debug)]
+pub struct SubCaptureMatches<'c, 'h> {
+    haystack: &'h str,
+    it: captures::CapturesPatternIter<'c>,
+}
+
+impl<'c, 'h> Iterator for SubCaptureMatches<'c, 'h> {
+    type Item = Option<Match<'h>>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Option<Match<'h>>> {
+        self.it.next().map(|group| {
+            group.map(|sp| Match::new(self.haystack, sp.start, sp.end))
+        })
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'c, 'h> ExactSizeIterator for SubCaptureMatches<'c, 'h> {}
+
+impl<'c, 'h> core::iter::FusedIterator for SubCaptureMatches<'c, 'h> {}
+
+/// A trait for types that can be used to replace matches in a haystack.
+///
+/// In general, users of this crate shouldn't need to implement this trait,
+/// since implementations are already provided for `&str` along with other
+/// variants of string types, as well as `FnMut(&Captures) -> String` (or any
+/// `FnMut(&Captures) -> T` where `T: AsRef<str>`). Those cover most use cases,
+/// but callers can implement this trait directly if necessary.
+///
+/// # Example
+///
+/// This example shows a basic implementation of  the `Replacer` trait. This
+/// can be done much more simply using the replacement string interpolation
+/// support (e.g., `$first $last`), but this approach avoids needing to parse
+/// the replacement string at all.
+///
+/// ```
+/// use regex::{Captures, Regex, Replacer};
+///
+/// struct NameSwapper;
+///
+/// impl Replacer for NameSwapper {
+///     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+///         dst.push_str(&caps["first"]);
+///         dst.push_str(" ");
+///         dst.push_str(&caps["last"]);
+///     }
+/// }
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(?<first>\S+)").unwrap();
+/// let result = re.replace("Springsteen, Bruce", NameSwapper);
+/// assert_eq!(result, "Bruce Springsteen");
+/// ```
+pub trait Replacer {
+    /// Appends possibly empty data to `dst` to replace the current match.
+    ///
+    /// The current match is represented by `caps`, which is guaranteed to
+    /// have a match at capture group `0`.
+    ///
+    /// For example, a no-op replacement would be `dst.push_str(&caps[0])`.
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String);
+
+    /// Return a fixed unchanging replacement string.
+    ///
+    /// When doing replacements, if access to [`Captures`] is not needed (e.g.,
+    /// the replacement string does not need `$` expansion), then it can be
+    /// beneficial to avoid finding sub-captures.
+    ///
+    /// In general, this is called once for every call to a replacement routine
+    /// such as [`Regex::replace_all`].
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, str>> {
+        None
+    }
+
+    /// Returns a type that implements `Replacer`, but that borrows and wraps
+    /// this `Replacer`.
+    ///
+    /// This is useful when you want to take a generic `Replacer` (which might
+    /// not be cloneable) and use it without consuming it, so it can be used
+    /// more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::{Regex, Replacer};
+    ///
+    /// fn replace_all_twice<R: Replacer>(
+    ///     re: Regex,
+    ///     src: &str,
+    ///     mut rep: R,
+    /// ) -> String {
+    ///     let dst = re.replace_all(src, rep.by_ref());
+    ///     let dst = re.replace_all(&dst, rep.by_ref());
+    ///     dst.into_owned()
+    /// }
+    /// ```
+    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
+        ReplacerRef(self)
+    }
+}
+
+impl<'a> Replacer for &'a str {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl Replacer for String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<F, T> Replacer for F
+where
+    F: FnMut(&Captures<'_>) -> T,
+    T: AsRef<str>,
+{
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        dst.push_str((*self)(caps).as_ref());
+    }
+}
+
+/// A by-reference adaptor for a [`Replacer`].
+///
+/// This permits reusing the same `Replacer` value in multiple calls to a
+/// replacement routine like [`Regex::replace_all`].
+///
+/// This type is created by [`Replacer::by_ref`].
+#[derive(Debug)]
+pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
+
+impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.0.replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        self.0.no_expansion()
+    }
+}
+
+/// A helper type for forcing literal string replacement.
+///
+/// It can be used with routines like [`Regex::replace`] and
+/// [`Regex::replace_all`] to do a literal string replacement without expanding
+/// `$name` to their corresponding capture groups. This can be both convenient
+/// (to avoid escaping `$`, for example) and faster (since capture groups
+/// don't need to be found).
+///
+/// `'s` is the lifetime of the literal string to use.
+///
+/// # Example
+///
+/// ```
+/// use regex::{NoExpand, Regex};
+///
+/// let re = Regex::new(r"(?<last>[^,\s]+),\s+(\S+)").unwrap();
+/// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
+/// assert_eq!(result, "$2 $last");
+/// ```
+#[derive(Clone, Debug)]
+pub struct NoExpand<'s>(pub &'s str);
+
+impl<'s> Replacer for NoExpand<'s> {
+    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut String) {
+        dst.push_str(self.0);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        Some(Cow::Borrowed(self.0))
+    }
+}
+
+/// Quickly checks the given replacement string for whether interpolation
+/// should be done on it. It returns `None` if a `$` was found anywhere in the
+/// given string, which suggests interpolation needs to be done. But if there's
+/// no `$` anywhere, then interpolation definitely does not need to be done. In
+/// that case, the given string is returned as a borrowed `Cow`.
+///
+/// This is meant to be used to implement the `Replacer::no_expandsion` method
+/// in its various trait impls.
+fn no_expansion<T: AsRef<str>>(replacement: &T) -> Option<Cow<'_, str>> {
+    let replacement = replacement.as_ref();
+    match crate::find_byte::find_byte(b'$', replacement.as_bytes()) {
+        Some(_) => None,
+        None => Some(Cow::Borrowed(replacement)),
+    }
+}
diff --git a/src/regexset/bytes.rs b/src/regexset/bytes.rs
new file mode 100644
index 0000000000..1220a14662
--- /dev/null
+++ b/src/regexset/bytes.rs
@@ -0,0 +1,710 @@
+use alloc::string::String;
+
+use regex_automata::{meta, Input, PatternID, PatternSet, PatternSetIter};
+
+use crate::{bytes::RegexSetBuilder, Error};
+
+/// Match multiple, possibly overlapping, regexes in a single search.
+///
+/// A regex set corresponds to the union of zero or more regular expressions.
+/// That is, a regex set will match a haystack when at least one of its
+/// constituent regexes matches. A regex set as its formulated here provides a
+/// touch more power: it will also report *which* regular expressions in the
+/// set match. Indeed, this is the key difference between regex sets and a
+/// single `Regex` with many alternates, since only one alternate can match at
+/// a time.
+///
+/// For example, consider regular expressions to match email addresses and
+/// domains: `[a-z]+@[a-z]+\.(com|org|net)` and `[a-z]+\.(com|org|net)`. If a
+/// regex set is constructed from those regexes, then searching the haystack
+/// `foo@example.com` will report both regexes as matching. Of course, one
+/// could accomplish this by compiling each regex on its own and doing two
+/// searches over the haystack. The key advantage of using a regex set is
+/// that it will report the matching regexes using a *single pass through the
+/// haystack*. If one has hundreds or thousands of regexes to match repeatedly
+/// (like a URL router for a complex web application or a user agent matcher),
+/// then a regex set *can* realize huge performance gains.
+///
+/// Unlike the top-level [`RegexSet`](crate::RegexSet), this `RegexSet`
+/// searches haystacks with type `&[u8]` instead of `&str`. Consequently, this
+/// `RegexSet` is permitted to match invalid UTF-8.
+///
+/// # Limitations
+///
+/// Regex sets are limited to answering the following two questions:
+///
+/// 1. Does any regex in the set match?
+/// 2. If so, which regexes in the set match?
+///
+/// As with the main [`Regex`][crate::bytes::Regex] type, it is cheaper to ask
+/// (1) instead of (2) since the matching engines can stop after the first
+/// match is found.
+///
+/// You cannot directly extract [`Match`][crate::bytes::Match] or
+/// [`Captures`][crate::bytes::Captures] objects from a regex set. If you need
+/// these operations, the recommended approach is to compile each pattern in
+/// the set independently and scan the exact same haystack a second time with
+/// those independently compiled patterns:
+///
+/// ```
+/// use regex::bytes::{Regex, RegexSet};
+///
+/// let patterns = ["foo", "bar"];
+/// // Both patterns will match different ranges of this string.
+/// let hay = b"barfoo";
+///
+/// // Compile a set matching any of our patterns.
+/// let set = RegexSet::new(patterns).unwrap();
+/// // Compile each pattern independently.
+/// let regexes: Vec<_> = set
+///     .patterns()
+///     .iter()
+///     .map(|pat| Regex::new(pat).unwrap())
+///     .collect();
+///
+/// // Match against the whole set first and identify the individual
+/// // matching patterns.
+/// let matches: Vec<&[u8]> = set
+///     .matches(hay)
+///     .into_iter()
+///     // Dereference the match index to get the corresponding
+///     // compiled pattern.
+///     .map(|index| &regexes[index])
+///     // To get match locations or any other info, we then have to search the
+///     // exact same haystack again, using our separately-compiled pattern.
+///     .map(|re| re.find(hay).unwrap().as_bytes())
+///     .collect();
+///
+/// // Matches arrive in the order the constituent patterns were declared,
+/// // not the order they appear in the haystack.
+/// assert_eq!(vec![&b"foo"[..], &b"bar"[..]], matches);
+/// ```
+///
+/// # Performance
+///
+/// A `RegexSet` has the same performance characteristics as `Regex`. Namely,
+/// search takes `O(m * n)` time, where `m` is proportional to the size of the
+/// regex set and `n` is proportional to the length of the haystack.
+///
+/// # Trait implementations
+///
+/// The `Default` trait is implemented for `RegexSet`. The default value
+/// is an empty set. An empty set can also be explicitly constructed via
+/// [`RegexSet::empty`].
+///
+/// # Example
+///
+/// This shows how the above two regexes (for matching email addresses and
+/// domains) might work:
+///
+/// ```
+/// use regex::bytes::RegexSet;
+///
+/// let set = RegexSet::new(&[
+///     r"[a-z]+@[a-z]+\.(com|org|net)",
+///     r"[a-z]+\.(com|org|net)",
+/// ]).unwrap();
+///
+/// // Ask whether any regexes in the set match.
+/// assert!(set.is_match(b"foo@example.com"));
+///
+/// // Identify which regexes in the set match.
+/// let matches: Vec<_> = set.matches(b"foo@example.com").into_iter().collect();
+/// assert_eq!(vec![0, 1], matches);
+///
+/// // Try again, but with a haystack that only matches one of the regexes.
+/// let matches: Vec<_> = set.matches(b"example.com").into_iter().collect();
+/// assert_eq!(vec![1], matches);
+///
+/// // Try again, but with a haystack that doesn't match any regex in the set.
+/// let matches: Vec<_> = set.matches(b"example").into_iter().collect();
+/// assert!(matches.is_empty());
+/// ```
+///
+/// Note that it would be possible to adapt the above example to using `Regex`
+/// with an expression like:
+///
+/// ```text
+/// (?P<email>[a-z]+@(?P<email_domain>[a-z]+[.](com|org|net)))|(?P<domain>[a-z]+[.](com|org|net))
+/// ```
+///
+/// After a match, one could then inspect the capture groups to figure out
+/// which alternates matched. The problem is that it is hard to make this
+/// approach scale when there are many regexes since the overlap between each
+/// alternate isn't always obvious to reason about.
+#[derive(Clone)]
+pub struct RegexSet {
+    pub(crate) meta: meta::Regex,
+    pub(crate) patterns: alloc::sync::Arc<[String]>,
+}
+
+impl RegexSet {
+    /// Create a new regex set with the given regular expressions.
+    ///
+    /// This takes an iterator of `S`, where `S` is something that can produce
+    /// a `&str`. If any of the strings in the iterator are not valid regular
+    /// expressions, then an error is returned.
+    ///
+    /// # Example
+    ///
+    /// Create a new regex set from an iterator of strings:
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match(b"foo"));
+    /// ```
+    pub fn new<I, S>(exprs: I) -> Result<RegexSet, Error>
+    where
+        S: AsRef<str>,
+        I: IntoIterator<Item = S>,
+    {
+        RegexSetBuilder::new(exprs).build()
+    }
+
+    /// Create a new empty regex set.
+    ///
+    /// An empty regex never matches anything.
+    ///
+    /// This is a convenience function for `RegexSet::new([])`, but doesn't
+    /// require one to specify the type of the input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::empty();
+    /// assert!(set.is_empty());
+    /// // an empty set matches nothing
+    /// assert!(!set.is_match(b""));
+    /// ```
+    pub fn empty() -> RegexSet {
+        let empty: [&str; 0] = [];
+        RegexSetBuilder::new(empty).build().unwrap()
+    }
+
+    /// Returns true if and only if one of the regexes in this set matches
+    /// the haystack given.
+    ///
+    /// This method should be preferred if you only need to test whether any
+    /// of the regexes in the set should match, but don't care about *which*
+    /// regexes matched. This is because the underlying matching engine will
+    /// quit immediately after seeing the first match instead of continuing to
+    /// find all matches.
+    ///
+    /// Note that as with searches using [`Regex`](crate::bytes::Regex), the
+    /// expression is unanchored by default. That is, if the regex does not
+    /// start with `^` or `\A`, or end with `$` or `\z`, then it is permitted
+    /// to match anywhere in the haystack.
+    ///
+    /// # Example
+    ///
+    /// Tests whether a set matches somewhere in a haystack:
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match(b"foo"));
+    /// assert!(!set.is_match("☃".as_bytes()));
+    /// ```
+    #[inline]
+    pub fn is_match(&self, haystack: &[u8]) -> bool {
+        self.is_match_at(haystack, 0)
+    }
+
+    /// Returns true if and only if one of the regexes in this set matches the
+    /// haystack given, with the search starting at the offset given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start`. Namely, consider a
+    /// haystack `foobar` and a desire to execute a search starting at offset
+    /// `3`. You could search a substring explicitly, but then the look-around
+    /// assertions won't work correctly. Instead, you can use this method to
+    /// specify the start position of a search.
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\bbar\b", r"(?m)^bar$"]).unwrap();
+    /// let hay = b"foobar";
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(set.is_match(&hay[3..]));
+    /// // No match because the  assertions take the context into account.
+    /// assert!(!set.is_match_at(hay, 3));
+    /// ```
+    #[inline]
+    pub fn is_match_at(&self, haystack: &[u8], start: usize) -> bool {
+        self.meta.is_match(Input::new(haystack).span(start..haystack.len()))
+    }
+
+    /// Returns the set of regexes that match in the given haystack.
+    ///
+    /// The set returned contains the index of each regex that matches in
+    /// the given haystack. The index is in correspondence with the order of
+    /// regular expressions given to `RegexSet`'s constructor.
+    ///
+    /// The set can also be used to iterate over the matched indices. The order
+    /// of iteration is always ascending with respect to the matching indices.
+    ///
+    /// Note that as with searches using [`Regex`](crate::bytes::Regex), the
+    /// expression is unanchored by default. That is, if the regex does not
+    /// start with `^` or `\A`, or end with `$` or `\z`, then it is permitted
+    /// to match anywhere in the haystack.
+    ///
+    /// # Example
+    ///
+    /// Tests which regular expressions match the given haystack:
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set.matches(b"foobar").into_iter().collect();
+    /// assert_eq!(matches, vec![0, 2, 3, 4, 6]);
+    ///
+    /// // You can also test whether a particular regex matched:
+    /// let matches = set.matches(b"foobar");
+    /// assert!(!matches.matched(5));
+    /// assert!(matches.matched(6));
+    /// ```
+    #[inline]
+    pub fn matches(&self, haystack: &[u8]) -> SetMatches {
+        self.matches_at(haystack, 0)
+    }
+
+    /// Returns the set of regexes that match in the given haystack.
+    ///
+    /// The set returned contains the index of each regex that matches in
+    /// the given haystack. The index is in correspondence with the order of
+    /// regular expressions given to `RegexSet`'s constructor.
+    ///
+    /// The set can also be used to iterate over the matched indices. The order
+    /// of iteration is always ascending with respect to the matching indices.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// Tests which regular expressions match the given haystack:
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\bbar\b", r"(?m)^bar$"]).unwrap();
+    /// let hay = b"foobar";
+    /// // We get matches here, but it's probably not intended.
+    /// let matches: Vec<_> = set.matches(&hay[3..]).into_iter().collect();
+    /// assert_eq!(matches, vec![0, 1]);
+    /// // No matches because the  assertions take the context into account.
+    /// let matches: Vec<_> = set.matches_at(hay, 3).into_iter().collect();
+    /// assert_eq!(matches, vec![]);
+    /// ```
+    #[inline]
+    pub fn matches_at(&self, haystack: &[u8], start: usize) -> SetMatches {
+        let input = Input::new(haystack).span(start..haystack.len());
+        let mut patset = PatternSet::new(self.meta.pattern_len());
+        self.meta.which_overlapping_matches(&input, &mut patset);
+        SetMatches(patset)
+    }
+
+    /// Returns the same as matches, but starts the search at the given
+    /// offset and stores the matches into the slice given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// `matches` must have a length that is at least the number of regexes
+    /// in this set.
+    ///
+    /// This method returns true if and only if at least one member of
+    /// `matches` is true after executing the set against `haystack`.
+    #[doc(hidden)]
+    #[inline]
+    pub fn matches_read_at(
+        &self,
+        matches: &mut [bool],
+        haystack: &[u8],
+        start: usize,
+    ) -> bool {
+        // This is pretty dumb. We should try to fix this, but the
+        // regex-automata API doesn't provide a way to store matches in an
+        // arbitrary &mut [bool]. Thankfully, this API is is doc(hidden) and
+        // thus not public... But regex-capi currently uses it. We should
+        // fix regex-capi to use a PatternSet, maybe? Not sure... PatternSet
+        // is in regex-automata, not regex. So maybe we should just accept a
+        // 'SetMatches', which is basically just a newtype around PatternSet.
+        let mut patset = PatternSet::new(self.meta.pattern_len());
+        let mut input = Input::new(haystack);
+        input.set_start(start);
+        self.meta.which_overlapping_matches(&input, &mut patset);
+        for pid in patset.iter() {
+            matches[pid] = true;
+        }
+        !patset.is_empty()
+    }
+
+    /// An alias for `matches_read_at` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate used this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn read_matches_at(
+        &self,
+        matches: &mut [bool],
+        haystack: &[u8],
+        start: usize,
+    ) -> bool {
+        self.matches_read_at(matches, haystack, start)
+    }
+
+    /// Returns the total number of regexes in this set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// assert_eq!(0, RegexSet::empty().len());
+    /// assert_eq!(1, RegexSet::new([r"[0-9]"]).unwrap().len());
+    /// assert_eq!(2, RegexSet::new([r"[0-9]", r"[a-z]"]).unwrap().len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.meta.pattern_len()
+    }
+
+    /// Returns `true` if this set contains no regexes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// assert!(RegexSet::empty().is_empty());
+    /// assert!(!RegexSet::new([r"[0-9]"]).unwrap().is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.meta.pattern_len() == 0
+    }
+
+    /// Returns the regex patterns that this regex set was constructed from.
+    ///
+    /// This function can be used to determine the pattern for a match. The
+    /// slice returned has exactly as many patterns givens to this regex set,
+    /// and the order of the slice is the same as the order of the patterns
+    /// provided to the set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new(&[
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set
+    ///     .matches(b"foobar")
+    ///     .into_iter()
+    ///     .map(|index| &set.patterns()[index])
+    ///     .collect();
+    /// assert_eq!(matches, vec![r"\w+", r"\pL+", r"foo", r"bar", r"foobar"]);
+    /// ```
+    #[inline]
+    pub fn patterns(&self) -> &[String] {
+        &self.patterns
+    }
+}
+
+impl Default for RegexSet {
+    fn default() -> Self {
+        RegexSet::empty()
+    }
+}
+
+/// A set of matches returned by a regex set.
+///
+/// Values of this type are constructed by [`RegexSet::matches`].
+#[derive(Clone, Debug)]
+pub struct SetMatches(PatternSet);
+
+impl SetMatches {
+    /// Whether this set contains any matches.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new(&[
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches(b"foo@example.com");
+    /// assert!(matches.matched_any());
+    /// ```
+    #[inline]
+    pub fn matched_any(&self) -> bool {
+        !self.0.is_empty()
+    }
+
+    /// Whether the regex at the given index matched.
+    ///
+    /// The index for a regex is determined by its insertion order upon the
+    /// initial construction of a `RegexSet`, starting at `0`.
+    ///
+    /// # Panics
+    ///
+    /// If `index` is greater than or equal to the number of regexes in the
+    /// original set that produced these matches. Equivalently, when `index`
+    /// is greater than or equal to [`SetMatches::len`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches(b"example.com");
+    /// assert!(!matches.matched(0));
+    /// assert!(matches.matched(1));
+    /// ```
+    #[inline]
+    pub fn matched(&self, index: usize) -> bool {
+        self.0.contains(PatternID::new_unchecked(index))
+    }
+
+    /// The total number of regexes in the set that created these matches.
+    ///
+    /// **WARNING:** This always returns the same value as [`RegexSet::len`].
+    /// In particular, it does *not* return the number of elements yielded by
+    /// [`SetMatches::iter`]. The only way to determine the total number of
+    /// matched regexes is to iterate over them.
+    ///
+    /// # Example
+    ///
+    /// Notice that this method returns the total number of regexes in the
+    /// original set, and *not* the total number of regexes that matched.
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches(b"example.com");
+    /// // Total number of patterns that matched.
+    /// assert_eq!(1, matches.iter().count());
+    /// // Total number of patterns in the set.
+    /// assert_eq!(2, matches.len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.capacity()
+    }
+
+    /// Returns an iterator over the indices of the regexes that matched.
+    ///
+    /// This will always produces matches in ascending order, where the index
+    /// yielded corresponds to the index of the regex that matched with respect
+    /// to its position when initially building the set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[0-9]",
+    ///     r"[a-z]",
+    ///     r"[A-Z]",
+    ///     r"\p{Greek}",
+    /// ]).unwrap();
+    /// let hay = "βa1".as_bytes();
+    /// let matches: Vec<_> = set.matches(hay).iter().collect();
+    /// assert_eq!(matches, vec![0, 1, 3]);
+    /// ```
+    ///
+    /// Note that `SetMatches` also implemnets the `IntoIterator` trait, so
+    /// this method is not always needed. For example:
+    ///
+    /// ```
+    /// use regex::bytes::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[0-9]",
+    ///     r"[a-z]",
+    ///     r"[A-Z]",
+    ///     r"\p{Greek}",
+    /// ]).unwrap();
+    /// let hay = "βa1".as_bytes();
+    /// let mut matches = vec![];
+    /// for index in set.matches(hay) {
+    ///     matches.push(index);
+    /// }
+    /// assert_eq!(matches, vec![0, 1, 3]);
+    /// ```
+    #[inline]
+    pub fn iter(&self) -> SetMatchesIter<'_> {
+        SetMatchesIter(self.0.iter())
+    }
+}
+
+impl IntoIterator for SetMatches {
+    type IntoIter = SetMatchesIntoIter;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let it = 0..self.0.capacity();
+        SetMatchesIntoIter { patset: self.0, it }
+    }
+}
+
+impl<'a> IntoIterator for &'a SetMatches {
+    type IntoIter = SetMatchesIter<'a>;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// An owned iterator over the set of matches from a regex set.
+///
+/// This will always produces matches in ascending order of index, where the
+/// index corresponds to the index of the regex that matched with respect to
+/// its position when initially building the set.
+///
+/// This iterator is created by calling `SetMatches::into_iter` via the
+/// `IntoIterator` trait. This is automatically done in `for` loops.
+///
+/// # Example
+///
+/// ```
+/// use regex::bytes::RegexSet;
+///
+/// let set = RegexSet::new([
+///     r"[0-9]",
+///     r"[a-z]",
+///     r"[A-Z]",
+///     r"\p{Greek}",
+/// ]).unwrap();
+/// let hay = "βa1".as_bytes();
+/// let mut matches = vec![];
+/// for index in set.matches(hay) {
+///     matches.push(index);
+/// }
+/// assert_eq!(matches, vec![0, 1, 3]);
+/// ```
+#[derive(Debug)]
+pub struct SetMatchesIntoIter {
+    patset: PatternSet,
+    it: core::ops::Range<usize>,
+}
+
+impl Iterator for SetMatchesIntoIter {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        loop {
+            let id = self.it.next()?;
+            if self.patset.contains(PatternID::new_unchecked(id)) {
+                return Some(id);
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl DoubleEndedIterator for SetMatchesIntoIter {
+    fn next_back(&mut self) -> Option<usize> {
+        loop {
+            let id = self.it.next_back()?;
+            if self.patset.contains(PatternID::new_unchecked(id)) {
+                return Some(id);
+            }
+        }
+    }
+}
+
+impl core::iter::FusedIterator for SetMatchesIntoIter {}
+
+/// A borrowed iterator over the set of matches from a regex set.
+///
+/// The lifetime `'a` refers to the lifetime of the [`SetMatches`] value that
+/// created this iterator.
+///
+/// This will always produces matches in ascending order, where the index
+/// corresponds to the index of the regex that matched with respect to its
+/// position when initially building the set.
+///
+/// This iterator is created by the [`SetMatches::iter`] method.
+#[derive(Clone, Debug)]
+pub struct SetMatchesIter<'a>(PatternSetIter<'a>);
+
+impl<'a> Iterator for SetMatchesIter<'a> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        self.0.next().map(|pid| pid.as_usize())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for SetMatchesIter<'a> {
+    fn next_back(&mut self) -> Option<usize> {
+        self.0.next_back().map(|pid| pid.as_usize())
+    }
+}
+
+impl<'a> core::iter::FusedIterator for SetMatchesIter<'a> {}
+
+impl core::fmt::Debug for RegexSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "RegexSet({:?})", self.patterns())
+    }
+}
diff --git a/src/regexset/mod.rs b/src/regexset/mod.rs
new file mode 100644
index 0000000000..93fadec8bf
--- /dev/null
+++ b/src/regexset/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod bytes;
+pub(crate) mod string;
diff --git a/src/regexset/string.rs b/src/regexset/string.rs
new file mode 100644
index 0000000000..2a3e7b8027
--- /dev/null
+++ b/src/regexset/string.rs
@@ -0,0 +1,706 @@
+use alloc::string::String;
+
+use regex_automata::{meta, Input, PatternID, PatternSet, PatternSetIter};
+
+use crate::{Error, RegexSetBuilder};
+
+/// Match multiple, possibly overlapping, regexes in a single search.
+///
+/// A regex set corresponds to the union of zero or more regular expressions.
+/// That is, a regex set will match a haystack when at least one of its
+/// constituent regexes matches. A regex set as its formulated here provides a
+/// touch more power: it will also report *which* regular expressions in the
+/// set match. Indeed, this is the key difference between regex sets and a
+/// single `Regex` with many alternates, since only one alternate can match at
+/// a time.
+///
+/// For example, consider regular expressions to match email addresses and
+/// domains: `[a-z]+@[a-z]+\.(com|org|net)` and `[a-z]+\.(com|org|net)`. If a
+/// regex set is constructed from those regexes, then searching the haystack
+/// `foo@example.com` will report both regexes as matching. Of course, one
+/// could accomplish this by compiling each regex on its own and doing two
+/// searches over the haystack. The key advantage of using a regex set is
+/// that it will report the matching regexes using a *single pass through the
+/// haystack*. If one has hundreds or thousands of regexes to match repeatedly
+/// (like a URL router for a complex web application or a user agent matcher),
+/// then a regex set *can* realize huge performance gains.
+///
+/// # Limitations
+///
+/// Regex sets are limited to answering the following two questions:
+///
+/// 1. Does any regex in the set match?
+/// 2. If so, which regexes in the set match?
+///
+/// As with the main [`Regex`][crate::Regex] type, it is cheaper to ask (1)
+/// instead of (2) since the matching engines can stop after the first match
+/// is found.
+///
+/// You cannot directly extract [`Match`][crate::Match] or
+/// [`Captures`][crate::Captures] objects from a regex set. If you need these
+/// operations, the recommended approach is to compile each pattern in the set
+/// independently and scan the exact same haystack a second time with those
+/// independently compiled patterns:
+///
+/// ```
+/// use regex::{Regex, RegexSet};
+///
+/// let patterns = ["foo", "bar"];
+/// // Both patterns will match different ranges of this string.
+/// let hay = "barfoo";
+///
+/// // Compile a set matching any of our patterns.
+/// let set = RegexSet::new(patterns).unwrap();
+/// // Compile each pattern independently.
+/// let regexes: Vec<_> = set
+///     .patterns()
+///     .iter()
+///     .map(|pat| Regex::new(pat).unwrap())
+///     .collect();
+///
+/// // Match against the whole set first and identify the individual
+/// // matching patterns.
+/// let matches: Vec<&str> = set
+///     .matches(hay)
+///     .into_iter()
+///     // Dereference the match index to get the corresponding
+///     // compiled pattern.
+///     .map(|index| &regexes[index])
+///     // To get match locations or any other info, we then have to search the
+///     // exact same haystack again, using our separately-compiled pattern.
+///     .map(|re| re.find(hay).unwrap().as_str())
+///     .collect();
+///
+/// // Matches arrive in the order the constituent patterns were declared,
+/// // not the order they appear in the haystack.
+/// assert_eq!(vec!["foo", "bar"], matches);
+/// ```
+///
+/// # Performance
+///
+/// A `RegexSet` has the same performance characteristics as `Regex`. Namely,
+/// search takes `O(m * n)` time, where `m` is proportional to the size of the
+/// regex set and `n` is proportional to the length of the haystack.
+///
+/// # Trait implementations
+///
+/// The `Default` trait is implemented for `RegexSet`. The default value
+/// is an empty set. An empty set can also be explicitly constructed via
+/// [`RegexSet::empty`].
+///
+/// # Example
+///
+/// This shows how the above two regexes (for matching email addresses and
+/// domains) might work:
+///
+/// ```
+/// use regex::RegexSet;
+///
+/// let set = RegexSet::new(&[
+///     r"[a-z]+@[a-z]+\.(com|org|net)",
+///     r"[a-z]+\.(com|org|net)",
+/// ]).unwrap();
+///
+/// // Ask whether any regexes in the set match.
+/// assert!(set.is_match("foo@example.com"));
+///
+/// // Identify which regexes in the set match.
+/// let matches: Vec<_> = set.matches("foo@example.com").into_iter().collect();
+/// assert_eq!(vec![0, 1], matches);
+///
+/// // Try again, but with a haystack that only matches one of the regexes.
+/// let matches: Vec<_> = set.matches("example.com").into_iter().collect();
+/// assert_eq!(vec![1], matches);
+///
+/// // Try again, but with a haystack that doesn't match any regex in the set.
+/// let matches: Vec<_> = set.matches("example").into_iter().collect();
+/// assert!(matches.is_empty());
+/// ```
+///
+/// Note that it would be possible to adapt the above example to using `Regex`
+/// with an expression like:
+///
+/// ```text
+/// (?P<email>[a-z]+@(?P<email_domain>[a-z]+[.](com|org|net)))|(?P<domain>[a-z]+[.](com|org|net))
+/// ```
+///
+/// After a match, one could then inspect the capture groups to figure out
+/// which alternates matched. The problem is that it is hard to make this
+/// approach scale when there are many regexes since the overlap between each
+/// alternate isn't always obvious to reason about.
+#[derive(Clone)]
+pub struct RegexSet {
+    pub(crate) meta: meta::Regex,
+    pub(crate) patterns: alloc::sync::Arc<[String]>,
+}
+
+impl RegexSet {
+    /// Create a new regex set with the given regular expressions.
+    ///
+    /// This takes an iterator of `S`, where `S` is something that can produce
+    /// a `&str`. If any of the strings in the iterator are not valid regular
+    /// expressions, then an error is returned.
+    ///
+    /// # Example
+    ///
+    /// Create a new regex set from an iterator of strings:
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match("foo"));
+    /// ```
+    pub fn new<I, S>(exprs: I) -> Result<RegexSet, Error>
+    where
+        S: AsRef<str>,
+        I: IntoIterator<Item = S>,
+    {
+        RegexSetBuilder::new(exprs).build()
+    }
+
+    /// Create a new empty regex set.
+    ///
+    /// An empty regex never matches anything.
+    ///
+    /// This is a convenience function for `RegexSet::new([])`, but doesn't
+    /// require one to specify the type of the input.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::empty();
+    /// assert!(set.is_empty());
+    /// // an empty set matches nothing
+    /// assert!(!set.is_match(""));
+    /// ```
+    pub fn empty() -> RegexSet {
+        let empty: [&str; 0] = [];
+        RegexSetBuilder::new(empty).build().unwrap()
+    }
+
+    /// Returns true if and only if one of the regexes in this set matches
+    /// the haystack given.
+    ///
+    /// This method should be preferred if you only need to test whether any
+    /// of the regexes in the set should match, but don't care about *which*
+    /// regexes matched. This is because the underlying matching engine will
+    /// quit immediately after seeing the first match instead of continuing to
+    /// find all matches.
+    ///
+    /// Note that as with searches using [`Regex`](crate::Regex), the
+    /// expression is unanchored by default. That is, if the regex does not
+    /// start with `^` or `\A`, or end with `$` or `\z`, then it is permitted
+    /// to match anywhere in the haystack.
+    ///
+    /// # Example
+    ///
+    /// Tests whether a set matches somewhere in a haystack:
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match("foo"));
+    /// assert!(!set.is_match("☃"));
+    /// ```
+    #[inline]
+    pub fn is_match(&self, haystack: &str) -> bool {
+        self.is_match_at(haystack, 0)
+    }
+
+    /// Returns true if and only if one of the regexes in this set matches the
+    /// haystack given, with the search starting at the offset given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// This example shows the significance of `start`. Namely, consider a
+    /// haystack `foobar` and a desire to execute a search starting at offset
+    /// `3`. You could search a substring explicitly, but then the look-around
+    /// assertions won't work correctly. Instead, you can use this method to
+    /// specify the start position of a search.
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\bbar\b", r"(?m)^bar$"]).unwrap();
+    /// let hay = "foobar";
+    /// // We get a match here, but it's probably not intended.
+    /// assert!(set.is_match(&hay[3..]));
+    /// // No match because the  assertions take the context into account.
+    /// assert!(!set.is_match_at(hay, 3));
+    /// ```
+    #[inline]
+    pub fn is_match_at(&self, haystack: &str, start: usize) -> bool {
+        self.meta.is_match(Input::new(haystack).span(start..haystack.len()))
+    }
+
+    /// Returns the set of regexes that match in the given haystack.
+    ///
+    /// The set returned contains the index of each regex that matches in
+    /// the given haystack. The index is in correspondence with the order of
+    /// regular expressions given to `RegexSet`'s constructor.
+    ///
+    /// The set can also be used to iterate over the matched indices. The order
+    /// of iteration is always ascending with respect to the matching indices.
+    ///
+    /// Note that as with searches using [`Regex`](crate::Regex), the
+    /// expression is unanchored by default. That is, if the regex does not
+    /// start with `^` or `\A`, or end with `$` or `\z`, then it is permitted
+    /// to match anywhere in the haystack.
+    ///
+    /// # Example
+    ///
+    /// Tests which regular expressions match the given haystack:
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set.matches("foobar").into_iter().collect();
+    /// assert_eq!(matches, vec![0, 2, 3, 4, 6]);
+    ///
+    /// // You can also test whether a particular regex matched:
+    /// let matches = set.matches("foobar");
+    /// assert!(!matches.matched(5));
+    /// assert!(matches.matched(6));
+    /// ```
+    #[inline]
+    pub fn matches(&self, haystack: &str) -> SetMatches {
+        self.matches_at(haystack, 0)
+    }
+
+    /// Returns the set of regexes that match in the given haystack.
+    ///
+    /// The set returned contains the index of each regex that matches in
+    /// the given haystack. The index is in correspondence with the order of
+    /// regular expressions given to `RegexSet`'s constructor.
+    ///
+    /// The set can also be used to iterate over the matched indices. The order
+    /// of iteration is always ascending with respect to the matching indices.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// # Panics
+    ///
+    /// This panics when `start >= haystack.len() + 1`.
+    ///
+    /// # Example
+    ///
+    /// Tests which regular expressions match the given haystack:
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([r"\bbar\b", r"(?m)^bar$"]).unwrap();
+    /// let hay = "foobar";
+    /// // We get matches here, but it's probably not intended.
+    /// let matches: Vec<_> = set.matches(&hay[3..]).into_iter().collect();
+    /// assert_eq!(matches, vec![0, 1]);
+    /// // No matches because the  assertions take the context into account.
+    /// let matches: Vec<_> = set.matches_at(hay, 3).into_iter().collect();
+    /// assert_eq!(matches, vec![]);
+    /// ```
+    #[inline]
+    pub fn matches_at(&self, haystack: &str, start: usize) -> SetMatches {
+        let input = Input::new(haystack).span(start..haystack.len());
+        let mut patset = PatternSet::new(self.meta.pattern_len());
+        self.meta.which_overlapping_matches(&input, &mut patset);
+        SetMatches(patset)
+    }
+
+    /// Returns the same as matches, but starts the search at the given
+    /// offset and stores the matches into the slice given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// `matches` must have a length that is at least the number of regexes
+    /// in this set.
+    ///
+    /// This method returns true if and only if at least one member of
+    /// `matches` is true after executing the set against `haystack`.
+    #[doc(hidden)]
+    #[inline]
+    pub fn matches_read_at(
+        &self,
+        matches: &mut [bool],
+        haystack: &str,
+        start: usize,
+    ) -> bool {
+        // This is pretty dumb. We should try to fix this, but the
+        // regex-automata API doesn't provide a way to store matches in an
+        // arbitrary &mut [bool]. Thankfully, this API is is doc(hidden) and
+        // thus not public... But regex-capi currently uses it. We should
+        // fix regex-capi to use a PatternSet, maybe? Not sure... PatternSet
+        // is in regex-automata, not regex. So maybe we should just accept a
+        // 'SetMatches', which is basically just a newtype around PatternSet.
+        let mut patset = PatternSet::new(self.meta.pattern_len());
+        let mut input = Input::new(haystack);
+        input.set_start(start);
+        self.meta.which_overlapping_matches(&input, &mut patset);
+        for pid in patset.iter() {
+            matches[pid] = true;
+        }
+        !patset.is_empty()
+    }
+
+    /// An alias for `matches_read_at` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate used this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn read_matches_at(
+        &self,
+        matches: &mut [bool],
+        haystack: &str,
+        start: usize,
+    ) -> bool {
+        self.matches_read_at(matches, haystack, start)
+    }
+
+    /// Returns the total number of regexes in this set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// assert_eq!(0, RegexSet::empty().len());
+    /// assert_eq!(1, RegexSet::new([r"[0-9]"]).unwrap().len());
+    /// assert_eq!(2, RegexSet::new([r"[0-9]", r"[a-z]"]).unwrap().len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.meta.pattern_len()
+    }
+
+    /// Returns `true` if this set contains no regexes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// assert!(RegexSet::empty().is_empty());
+    /// assert!(!RegexSet::new([r"[0-9]"]).unwrap().is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.meta.pattern_len() == 0
+    }
+
+    /// Returns the regex patterns that this regex set was constructed from.
+    ///
+    /// This function can be used to determine the pattern for a match. The
+    /// slice returned has exactly as many patterns givens to this regex set,
+    /// and the order of the slice is the same as the order of the patterns
+    /// provided to the set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new(&[
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set
+    ///     .matches("foobar")
+    ///     .into_iter()
+    ///     .map(|index| &set.patterns()[index])
+    ///     .collect();
+    /// assert_eq!(matches, vec![r"\w+", r"\pL+", r"foo", r"bar", r"foobar"]);
+    /// ```
+    #[inline]
+    pub fn patterns(&self) -> &[String] {
+        &self.patterns
+    }
+}
+
+impl Default for RegexSet {
+    fn default() -> Self {
+        RegexSet::empty()
+    }
+}
+
+/// A set of matches returned by a regex set.
+///
+/// Values of this type are constructed by [`RegexSet::matches`].
+#[derive(Clone, Debug)]
+pub struct SetMatches(PatternSet);
+
+impl SetMatches {
+    /// Whether this set contains any matches.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new(&[
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches("foo@example.com");
+    /// assert!(matches.matched_any());
+    /// ```
+    #[inline]
+    pub fn matched_any(&self) -> bool {
+        !self.0.is_empty()
+    }
+
+    /// Whether the regex at the given index matched.
+    ///
+    /// The index for a regex is determined by its insertion order upon the
+    /// initial construction of a `RegexSet`, starting at `0`.
+    ///
+    /// # Panics
+    ///
+    /// If `index` is greater than or equal to the number of regexes in the
+    /// original set that produced these matches. Equivalently, when `index`
+    /// is greater than or equal to [`SetMatches::len`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches("example.com");
+    /// assert!(!matches.matched(0));
+    /// assert!(matches.matched(1));
+    /// ```
+    #[inline]
+    pub fn matched(&self, index: usize) -> bool {
+        self.0.contains(PatternID::new_unchecked(index))
+    }
+
+    /// The total number of regexes in the set that created these matches.
+    ///
+    /// **WARNING:** This always returns the same value as [`RegexSet::len`].
+    /// In particular, it does *not* return the number of elements yielded by
+    /// [`SetMatches::iter`]. The only way to determine the total number of
+    /// matched regexes is to iterate over them.
+    ///
+    /// # Example
+    ///
+    /// Notice that this method returns the total number of regexes in the
+    /// original set, and *not* the total number of regexes that matched.
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[a-z]+@[a-z]+\.(com|org|net)",
+    ///     r"[a-z]+\.(com|org|net)",
+    /// ]).unwrap();
+    /// let matches = set.matches("example.com");
+    /// // Total number of patterns that matched.
+    /// assert_eq!(1, matches.iter().count());
+    /// // Total number of patterns in the set.
+    /// assert_eq!(2, matches.len());
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.capacity()
+    }
+
+    /// Returns an iterator over the indices of the regexes that matched.
+    ///
+    /// This will always produces matches in ascending order, where the index
+    /// yielded corresponds to the index of the regex that matched with respect
+    /// to its position when initially building the set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[0-9]",
+    ///     r"[a-z]",
+    ///     r"[A-Z]",
+    ///     r"\p{Greek}",
+    /// ]).unwrap();
+    /// let hay = "βa1";
+    /// let matches: Vec<_> = set.matches(hay).iter().collect();
+    /// assert_eq!(matches, vec![0, 1, 3]);
+    /// ```
+    ///
+    /// Note that `SetMatches` also implemnets the `IntoIterator` trait, so
+    /// this method is not always needed. For example:
+    ///
+    /// ```
+    /// use regex::RegexSet;
+    ///
+    /// let set = RegexSet::new([
+    ///     r"[0-9]",
+    ///     r"[a-z]",
+    ///     r"[A-Z]",
+    ///     r"\p{Greek}",
+    /// ]).unwrap();
+    /// let hay = "βa1";
+    /// let mut matches = vec![];
+    /// for index in set.matches(hay) {
+    ///     matches.push(index);
+    /// }
+    /// assert_eq!(matches, vec![0, 1, 3]);
+    /// ```
+    #[inline]
+    pub fn iter(&self) -> SetMatchesIter<'_> {
+        SetMatchesIter(self.0.iter())
+    }
+}
+
+impl IntoIterator for SetMatches {
+    type IntoIter = SetMatchesIntoIter;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let it = 0..self.0.capacity();
+        SetMatchesIntoIter { patset: self.0, it }
+    }
+}
+
+impl<'a> IntoIterator for &'a SetMatches {
+    type IntoIter = SetMatchesIter<'a>;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// An owned iterator over the set of matches from a regex set.
+///
+/// This will always produces matches in ascending order of index, where the
+/// index corresponds to the index of the regex that matched with respect to
+/// its position when initially building the set.
+///
+/// This iterator is created by calling `SetMatches::into_iter` via the
+/// `IntoIterator` trait. This is automatically done in `for` loops.
+///
+/// # Example
+///
+/// ```
+/// use regex::RegexSet;
+///
+/// let set = RegexSet::new([
+///     r"[0-9]",
+///     r"[a-z]",
+///     r"[A-Z]",
+///     r"\p{Greek}",
+/// ]).unwrap();
+/// let hay = "βa1";
+/// let mut matches = vec![];
+/// for index in set.matches(hay) {
+///     matches.push(index);
+/// }
+/// assert_eq!(matches, vec![0, 1, 3]);
+/// ```
+#[derive(Debug)]
+pub struct SetMatchesIntoIter {
+    patset: PatternSet,
+    it: core::ops::Range<usize>,
+}
+
+impl Iterator for SetMatchesIntoIter {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        loop {
+            let id = self.it.next()?;
+            if self.patset.contains(PatternID::new_unchecked(id)) {
+                return Some(id);
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl DoubleEndedIterator for SetMatchesIntoIter {
+    fn next_back(&mut self) -> Option<usize> {
+        loop {
+            let id = self.it.next_back()?;
+            if self.patset.contains(PatternID::new_unchecked(id)) {
+                return Some(id);
+            }
+        }
+    }
+}
+
+impl core::iter::FusedIterator for SetMatchesIntoIter {}
+
+/// A borrowed iterator over the set of matches from a regex set.
+///
+/// The lifetime `'a` refers to the lifetime of the [`SetMatches`] value that
+/// created this iterator.
+///
+/// This will always produces matches in ascending order, where the index
+/// corresponds to the index of the regex that matched with respect to its
+/// position when initially building the set.
+///
+/// This iterator is created by the [`SetMatches::iter`] method.
+#[derive(Clone, Debug)]
+pub struct SetMatchesIter<'a>(PatternSetIter<'a>);
+
+impl<'a> Iterator for SetMatchesIter<'a> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        self.0.next().map(|pid| pid.as_usize())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for SetMatchesIter<'a> {
+    fn next_back(&mut self) -> Option<usize> {
+        self.0.next_back().map(|pid| pid.as_usize())
+    }
+}
+
+impl<'a> core::iter::FusedIterator for SetMatchesIter<'a> {}
+
+impl core::fmt::Debug for RegexSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "RegexSet({:?})", self.patterns())
+    }
+}
diff --git a/src/sparse.rs b/src/sparse.rs
deleted file mode 100644
index 98b726613d..0000000000
--- a/src/sparse.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use std::fmt;
-use std::ops::Deref;
-use std::slice;
-
-/// A sparse set used for representing ordered NFA states.
-///
-/// This supports constant time addition and membership testing. Clearing an
-/// entire set can also be done in constant time. Iteration yields elements
-/// in the order in which they were inserted.
-///
-/// The data structure is based on: https://research.swtch.com/sparse
-/// Note though that we don't actually use uninitialized memory. We generally
-/// reuse allocations, so the initial allocation cost is bareable. However,
-/// its other properties listed above are extremely useful.
-#[derive(Clone)]
-pub struct SparseSet {
-    /// Dense contains the instruction pointers in the order in which they
-    /// were inserted.
-    dense: Vec<usize>,
-    /// Sparse maps instruction pointers to their location in dense.
-    ///
-    /// An instruction pointer is in the set if and only if
-    /// sparse[ip] < dense.len() && ip == dense[sparse[ip]].
-    sparse: Box<[usize]>,
-}
-
-impl SparseSet {
-    pub fn new(size: usize) -> SparseSet {
-        SparseSet {
-            dense: Vec::with_capacity(size),
-            sparse: vec![0; size].into_boxed_slice(),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.dense.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.dense.is_empty()
-    }
-
-    pub fn capacity(&self) -> usize {
-        self.dense.capacity()
-    }
-
-    pub fn insert(&mut self, value: usize) {
-        let i = self.len();
-        assert!(i < self.capacity());
-        self.dense.push(value);
-        self.sparse[value] = i;
-    }
-
-    pub fn contains(&self, value: usize) -> bool {
-        let i = self.sparse[value];
-        self.dense.get(i) == Some(&value)
-    }
-
-    pub fn clear(&mut self) {
-        self.dense.clear();
-    }
-}
-
-impl fmt::Debug for SparseSet {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "SparseSet({:?})", self.dense)
-    }
-}
-
-impl Deref for SparseSet {
-    type Target = [usize];
-
-    fn deref(&self) -> &Self::Target {
-        &self.dense
-    }
-}
-
-impl<'a> IntoIterator for &'a SparseSet {
-    type Item = &'a usize;
-    type IntoIter = slice::Iter<'a, usize>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
diff --git a/src/testdata/LICENSE b/src/testdata/LICENSE
deleted file mode 100644
index f47dbf4c44..0000000000
--- a/src/testdata/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-The following license covers testregex.c and all associated test data.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of THIS SOFTWARE FILE (the "Software"), to deal in the Software
-without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, and/or sell copies of the
-Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following disclaimer:
-
-THIS SOFTWARE IS PROVIDED BY AT&T ``AS IS'' AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL AT&T BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/testdata/README b/src/testdata/README
deleted file mode 100644
index 6efc2dad33..0000000000
--- a/src/testdata/README
+++ /dev/null
@@ -1,17 +0,0 @@
-Test data was taken from the Go distribution, which was in turn taken from the
-testregex test suite:
-
-  http://www2.research.att.com/~astopen/testregex/testregex.html
-
-The LICENSE in this directory corresponds to the LICENSE that the data was
-released under.
-
-The tests themselves were modified for RE2/Go. A couple were modified further
-by me (Andrew Gallant) (only in repetition.dat) so that RE2/Go would pass them.
-(Yes, it seems like RE2/Go includes failing test cases.) This may or may not
-have been a bad idea, but I think being consistent with an established Regex
-library is worth something.
-
-Note that these files are read by 'scripts/regex-match-tests.py' and turned
-into Rust tests found in 'regex_macros/tests/matches.rs'.
-
diff --git a/src/utf8.rs b/src/utf8.rs
deleted file mode 100644
index 2dfd2c0d1d..0000000000
--- a/src/utf8.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-/// A few elementary UTF-8 encoding and decoding functions used by the matching
-/// engines.
-///
-/// In an ideal world, the matching engines operate on `&str` and we can just
-/// lean on the standard library for all our UTF-8 needs. However, to support
-/// byte based regexes (that can match on arbitrary bytes which may contain
-/// UTF-8), we need to be capable of searching and decoding UTF-8 on a `&[u8]`.
-/// The standard library doesn't really recognize this use case, so we have
-/// to build it out ourselves.
-///
-/// Should this be factored out into a separate crate? It seems independently
-/// useful. There are other crates that already exist (e.g., `utf-8`) that have
-/// overlapping use cases. Not sure what to do.
-use std::char;
-
-const TAG_CONT: u8 = 0b1000_0000;
-const TAG_TWO: u8 = 0b1100_0000;
-const TAG_THREE: u8 = 0b1110_0000;
-const TAG_FOUR: u8 = 0b1111_0000;
-
-/// Returns the smallest possible index of the next valid UTF-8 sequence
-/// starting after `i`.
-pub fn next_utf8(text: &[u8], i: usize) -> usize {
-    let b = match text.get(i) {
-        None => return i + 1,
-        Some(&b) => b,
-    };
-    let inc = if b <= 0x7F {
-        1
-    } else if b <= 0b110_11111 {
-        2
-    } else if b <= 0b1110_1111 {
-        3
-    } else {
-        4
-    };
-    i + inc
-}
-
-/// Decode a single UTF-8 sequence into a single Unicode codepoint from `src`.
-///
-/// If no valid UTF-8 sequence could be found, then `None` is returned.
-/// Otherwise, the decoded codepoint and the number of bytes read is returned.
-/// The number of bytes read (for a valid UTF-8 sequence) is guaranteed to be
-/// 1, 2, 3 or 4.
-///
-/// Note that a UTF-8 sequence is invalid if it is incorrect UTF-8, encodes a
-/// codepoint that is out of range (surrogate codepoints are out of range) or
-/// is not the shortest possible UTF-8 sequence for that codepoint.
-#[inline]
-pub fn decode_utf8(src: &[u8]) -> Option<(char, usize)> {
-    let b0 = match src.get(0) {
-        None => return None,
-        Some(&b) if b <= 0x7F => return Some((b as char, 1)),
-        Some(&b) => b,
-    };
-    match b0 {
-        0b110_00000..=0b110_11111 => {
-            if src.len() < 2 {
-                return None;
-            }
-            let b1 = src[1];
-            if 0b11_000000 & b1 != TAG_CONT {
-                return None;
-            }
-            let cp = ((b0 & !TAG_TWO) as u32) << 6 | ((b1 & !TAG_CONT) as u32);
-            match cp {
-                0x80..=0x7FF => char::from_u32(cp).map(|cp| (cp, 2)),
-                _ => None,
-            }
-        }
-        0b1110_0000..=0b1110_1111 => {
-            if src.len() < 3 {
-                return None;
-            }
-            let (b1, b2) = (src[1], src[2]);
-            if 0b11_000000 & b1 != TAG_CONT {
-                return None;
-            }
-            if 0b11_000000 & b2 != TAG_CONT {
-                return None;
-            }
-            let cp = ((b0 & !TAG_THREE) as u32) << 12
-                | ((b1 & !TAG_CONT) as u32) << 6
-                | ((b2 & !TAG_CONT) as u32);
-            match cp {
-                // char::from_u32 will disallow surrogate codepoints.
-                0x800..=0xFFFF => char::from_u32(cp).map(|cp| (cp, 3)),
-                _ => None,
-            }
-        }
-        0b11110_000..=0b11110_111 => {
-            if src.len() < 4 {
-                return None;
-            }
-            let (b1, b2, b3) = (src[1], src[2], src[3]);
-            if 0b11_000000 & b1 != TAG_CONT {
-                return None;
-            }
-            if 0b11_000000 & b2 != TAG_CONT {
-                return None;
-            }
-            if 0b11_000000 & b3 != TAG_CONT {
-                return None;
-            }
-            let cp = ((b0 & !TAG_FOUR) as u32) << 18
-                | ((b1 & !TAG_CONT) as u32) << 12
-                | ((b2 & !TAG_CONT) as u32) << 6
-                | ((b3 & !TAG_CONT) as u32);
-            match cp {
-                0x10000..=0x0010_FFFF => char::from_u32(cp).map(|cp| (cp, 4)),
-                _ => None,
-            }
-        }
-        _ => None,
-    }
-}
-
-/// Like `decode_utf8`, but decodes the last UTF-8 sequence in `src` instead
-/// of the first.
-pub fn decode_last_utf8(src: &[u8]) -> Option<(char, usize)> {
-    if src.is_empty() {
-        return None;
-    }
-    let mut start = src.len() - 1;
-    if src[start] <= 0x7F {
-        return Some((src[start] as char, 1));
-    }
-    while start > src.len().saturating_sub(4) {
-        start -= 1;
-        if is_start_byte(src[start]) {
-            break;
-        }
-    }
-    match decode_utf8(&src[start..]) {
-        None => None,
-        Some((_, n)) if n < src.len() - start => None,
-        Some((cp, n)) => Some((cp, n)),
-    }
-}
-
-fn is_start_byte(b: u8) -> bool {
-    b & 0b11_000000 != 0b1_0000000
-}
-
-#[cfg(test)]
-mod tests {
-    use std::str;
-
-    use quickcheck::quickcheck;
-
-    use super::{
-        decode_last_utf8, decode_utf8, TAG_CONT, TAG_FOUR, TAG_THREE, TAG_TWO,
-    };
-
-    #[test]
-    fn prop_roundtrip() {
-        fn p(given_cp: char) -> bool {
-            let mut tmp = [0; 4];
-            let encoded_len = given_cp.encode_utf8(&mut tmp).len();
-            let (got_cp, got_len) = decode_utf8(&tmp[..encoded_len]).unwrap();
-            encoded_len == got_len && given_cp == got_cp
-        }
-        quickcheck(p as fn(char) -> bool)
-    }
-
-    #[test]
-    fn prop_roundtrip_last() {
-        fn p(given_cp: char) -> bool {
-            let mut tmp = [0; 4];
-            let encoded_len = given_cp.encode_utf8(&mut tmp).len();
-            let (got_cp, got_len) =
-                decode_last_utf8(&tmp[..encoded_len]).unwrap();
-            encoded_len == got_len && given_cp == got_cp
-        }
-        quickcheck(p as fn(char) -> bool)
-    }
-
-    #[test]
-    fn prop_encode_matches_std() {
-        fn p(cp: char) -> bool {
-            let mut got = [0; 4];
-            let n = cp.encode_utf8(&mut got).len();
-            let expected = cp.to_string();
-            &got[..n] == expected.as_bytes()
-        }
-        quickcheck(p as fn(char) -> bool)
-    }
-
-    #[test]
-    fn prop_decode_matches_std() {
-        fn p(given_cp: char) -> bool {
-            let mut tmp = [0; 4];
-            let n = given_cp.encode_utf8(&mut tmp).len();
-            let (got_cp, _) = decode_utf8(&tmp[..n]).unwrap();
-            let expected_cp =
-                str::from_utf8(&tmp[..n]).unwrap().chars().next().unwrap();
-            got_cp == expected_cp
-        }
-        quickcheck(p as fn(char) -> bool)
-    }
-
-    #[test]
-    fn prop_decode_last_matches_std() {
-        fn p(given_cp: char) -> bool {
-            let mut tmp = [0; 4];
-            let n = given_cp.encode_utf8(&mut tmp).len();
-            let (got_cp, _) = decode_last_utf8(&tmp[..n]).unwrap();
-            let expected_cp = str::from_utf8(&tmp[..n])
-                .unwrap()
-                .chars()
-                .rev()
-                .next()
-                .unwrap();
-            got_cp == expected_cp
-        }
-        quickcheck(p as fn(char) -> bool)
-    }
-
-    #[test]
-    fn reject_invalid() {
-        // Invalid start byte
-        assert_eq!(decode_utf8(&[0xFF]), None);
-        // Surrogate pair
-        assert_eq!(decode_utf8(&[0xED, 0xA0, 0x81]), None);
-        // Invalid continuation byte.
-        assert_eq!(decode_utf8(&[0xD4, 0xC2]), None);
-        // Bad lengths
-        assert_eq!(decode_utf8(&[0xC3]), None); // 2 bytes
-        assert_eq!(decode_utf8(&[0xEF, 0xBF]), None); // 3 bytes
-        assert_eq!(decode_utf8(&[0xF4, 0x8F, 0xBF]), None); // 4 bytes
-                                                            // Not a minimal UTF-8 sequence
-        assert_eq!(decode_utf8(&[TAG_TWO, TAG_CONT | b'a']), None);
-        assert_eq!(decode_utf8(&[TAG_THREE, TAG_CONT, TAG_CONT | b'a']), None);
-        assert_eq!(
-            decode_utf8(&[TAG_FOUR, TAG_CONT, TAG_CONT, TAG_CONT | b'a',]),
-            None
-        );
-    }
-
-    #[test]
-    fn reject_invalid_last() {
-        // Invalid start byte
-        assert_eq!(decode_last_utf8(&[0xFF]), None);
-        // Surrogate pair
-        assert_eq!(decode_last_utf8(&[0xED, 0xA0, 0x81]), None);
-        // Bad lengths
-        assert_eq!(decode_last_utf8(&[0xC3]), None); // 2 bytes
-        assert_eq!(decode_last_utf8(&[0xEF, 0xBF]), None); // 3 bytes
-        assert_eq!(decode_last_utf8(&[0xF4, 0x8F, 0xBF]), None); // 4 bytes
-                                                                 // Not a minimal UTF-8 sequence
-        assert_eq!(decode_last_utf8(&[TAG_TWO, TAG_CONT | b'a']), None);
-        assert_eq!(
-            decode_last_utf8(&[TAG_THREE, TAG_CONT, TAG_CONT | b'a',]),
-            None
-        );
-        assert_eq!(
-            decode_last_utf8(
-                &[TAG_FOUR, TAG_CONT, TAG_CONT, TAG_CONT | b'a',]
-            ),
-            None
-        );
-    }
-}
diff --git a/test b/test
index b10564f128..48224c6d11 100755
--- a/test
+++ b/test
@@ -2,14 +2,23 @@
 
 set -e
 
+# cd to the directory containing this crate's Cargo.toml so that we don't need
+# to pass --manifest-path to every `cargo` command.
+cd "$(dirname "$0")"
+
 # This is a convenience script for running a broad swath of tests across
 # features. We don't test the complete space, since the complete space is quite
 # large. Hopefully once we migrate the test suite to better infrastructure
 # (like regex-automata), we'll be able to test more of the space.
-echo "===== DEFAULT FEATURES ==="
+echo "===== DEFAULT FEATURES ====="
 cargo test
 
-echo "===== DOC TESTS ==="
+# no-std mode is annoyingly difficult to test. Currently, the integration tests
+# don't run. So for now, we just test that library tests run. (There aren't
+# many because `regex` is just a wrapper crate.)
+cargo test --no-default-features --lib
+
+echo "===== DOC TESTS ====="
 cargo test --doc
 
 features=(
@@ -21,10 +30,17 @@ features=(
     "std perf-dfa"
     "std perf-inline"
     "std perf-literal"
+    "std perf-dfa-full"
+    "std perf-onepass"
+    "std perf-backtrack"
 )
 for f in "${features[@]}"; do
-    echo "===== FEATURE: $f (default) ==="
-    cargo test --test default --no-default-features --features "$f"
-    echo "===== FEATURE: $f (default-bytes) ==="
-    cargo test --test default-bytes --no-default-features --features "$f"
+    echo "===== FEATURE: $f ====="
+    cargo test --test integration --no-default-features --features "$f"
 done
+
+# And test the probably-forever-nightly-only 'pattern' feature...
+if rustc --version | grep -q nightly; then
+    echo "===== FEATURE: std,pattern,unicode-perl ====="
+    cargo test --test integration --no-default-features --features std,pattern,unicode-perl
+fi
diff --git a/testdata/README.md b/testdata/README.md
new file mode 100644
index 0000000000..c3bc1acb5d
--- /dev/null
+++ b/testdata/README.md
@@ -0,0 +1,22 @@
+This directory contains a large suite of regex tests defined in a TOML format.
+They are used to drive tests in `tests/lib.rs`, `regex-automata/tests/lib.rs`
+and `regex-lite/tests/lib.rs`.
+
+See the [`regex-test`][regex-test] crate documentation for an explanation of
+the format and how it generates tests.
+
+The basic idea here is that we have many different regex engines but generally
+one set of tests. We want to be able to run those tests (or most of them) on
+every engine. Prior to `regex 1.9`, we used to do this with a hodge podge soup
+of macros and a different test executable for each engine. It overall took a
+longer time to compile, was harder to maintain and it made the test definitions
+themselves less clear.
+
+In `regex 1.9`, when we moved over to `regex-automata`, the situation got a lot
+worse because of an increase in the number of engines. So I devised an engine
+independent format for testing regex patterns and their semantics.
+
+Note: the naming scheme used in these tests isn't terribly consistent. It would
+be great to fix that.
+
+[regex-test]: https://docs.rs/regex-test
diff --git a/testdata/anchored.toml b/testdata/anchored.toml
new file mode 100644
index 0000000000..cca561de10
--- /dev/null
+++ b/testdata/anchored.toml
@@ -0,0 +1,71 @@
+# These tests are specifically geared toward searches with 'anchored = true'.
+# While they are interesting in their own right, they are particularly
+# important for testing the one-pass DFA since the one-pass DFA can't work in
+# unanchored contexts.
+#
+# Note that "anchored" in this context does not mean "^". Anchored searches are
+# searches whose matches must begin at the start of the search, which may not
+# be at the start of the haystack. That's why anchored searches---and there are
+# some examples below---can still report multiple matches. This occurs when the
+# matches are adjacent to one another.
+
+[[test]]
+name = "greedy"
+regex = '(abc)+'
+haystack = "abcabcabc"
+matches = [
+  [[0, 9], [6, 9]],
+]
+anchored = true
+
+# When a "earliest" search is used, greediness doesn't really exist because
+# matches are reported as soon as they are known.
+[[test]]
+name = "greedy-earliest"
+regex = '(abc)+'
+haystack = "abcabcabc"
+matches = [
+  [[0, 3], [0, 3]],
+  [[3, 6], [3, 6]],
+  [[6, 9], [6, 9]],
+]
+anchored = true
+search-kind = "earliest"
+
+[[test]]
+name = "nongreedy"
+regex = '(abc)+?'
+haystack = "abcabcabc"
+matches = [
+  [[0, 3], [0, 3]],
+  [[3, 6], [3, 6]],
+  [[6, 9], [6, 9]],
+]
+anchored = true
+
+# When "all" semantics are used, non-greediness doesn't exist since the longest
+# possible match is always taken.
+[[test]]
+name = "nongreedy-all"
+regex = '(abc)+?'
+haystack = "abcabcabc"
+matches = [
+  [[0, 9], [6, 9]],
+]
+anchored = true
+match-kind = "all"
+
+[[test]]
+name = "word-boundary-unicode-01"
+regex = '\b\w+\b'
+haystack = 'βββ☃'
+matches = [[0, 6]]
+anchored = true
+
+[[test]]
+name = "word-boundary-nounicode-01"
+regex = '\b\w+\b'
+haystack = 'abcβ'
+matches = [[0, 3]]
+anchored = true
+unicode = false
diff --git a/testdata/bytes.toml b/testdata/bytes.toml
new file mode 100644
index 0000000000..346e36971d
--- /dev/null
+++ b/testdata/bytes.toml
@@ -0,0 +1,235 @@
+# These are tests specifically crafted for regexes that can match arbitrary
+# bytes. In some cases, we also test the Unicode variant as well, just because
+# it's good sense to do so. But also, these tests aren't really about Unicode,
+# but whether matches are only reported at valid UTF-8 boundaries. For most
+# tests in this entire collection, utf8 = true. But for these tests, we use
+# utf8 = false.
+
+[[test]]
+name = "word-boundary-ascii"
+regex = ' \b'
+haystack = " δ"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "word-boundary-unicode"
+regex = ' \b'
+haystack = " δ"
+matches = [[0, 1]]
+unicode = true
+utf8 = false
+
+[[test]]
+name = "word-boundary-ascii-not"
+regex = ' \B'
+haystack = " δ"
+matches = [[0, 1]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "word-boundary-unicode-not"
+regex = ' \B'
+haystack = " δ"
+matches = []
+unicode = true
+utf8 = false
+
+[[test]]
+name = "perl-word-ascii"
+regex = '\w+'
+haystack = "aδ"
+matches = [[0, 1]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "perl-word-unicode"
+regex = '\w+'
+haystack = "aδ"
+matches = [[0, 3]]
+unicode = true
+utf8 = false
+
+[[test]]
+name = "perl-decimal-ascii"
+regex = '\d+'
+haystack = "1२३9"
+matches = [[0, 1], [7, 8]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "perl-decimal-unicode"
+regex = '\d+'
+haystack = "1२३9"
+matches = [[0, 8]]
+unicode = true
+utf8 = false
+
+[[test]]
+name = "perl-whitespace-ascii"
+regex = '\s+'
+haystack = " \u1680"
+matches = [[0, 1]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "perl-whitespace-unicode"
+regex = '\s+'
+haystack = " \u1680"
+matches = [[0, 4]]
+unicode = true
+utf8 = false
+
+# The first `(.+)` matches two Unicode codepoints, but can't match the 5th
+# byte, which isn't valid UTF-8. The second (byte based) `(.+)` takes over and
+# matches.
+[[test]]
+name = "mixed-dot"
+regex = '(.+)(?-u)(.+)'
+haystack = '\xCE\x93\xCE\x94\xFF'
+matches = [
+  [[0, 5], [0, 4], [4, 5]],
+]
+unescape = true
+unicode = true
+utf8 = false
+
+[[test]]
+name = "case-one-ascii"
+regex = 'a'
+haystack = "A"
+matches = [[0, 1]]
+case-insensitive = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "case-one-unicode"
+regex = 'a'
+haystack = "A"
+matches = [[0, 1]]
+case-insensitive = true
+unicode = true
+utf8 = false
+
+[[test]]
+name = "case-class-simple-ascii"
+regex = '[a-z]+'
+haystack = "AaAaA"
+matches = [[0, 5]]
+case-insensitive = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "case-class-ascii"
+regex = '[a-z]+'
+haystack = "aA\u212AaA"
+matches = [[0, 2], [5, 7]]
+case-insensitive = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "case-class-unicode"
+regex = '[a-z]+'
+haystack = "aA\u212AaA"
+matches = [[0, 7]]
+case-insensitive = true
+unicode = true
+utf8 = false
+
+[[test]]
+name = "negate-ascii"
+regex = '[^a]'
+haystack = "δ"
+matches = [[0, 1], [1, 2]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "negate-unicode"
+regex = '[^a]'
+haystack = "δ"
+matches = [[0, 2]]
+unicode = true
+utf8 = false
+
+# When utf8=true, this won't match, because the implicit '.*?' prefix is
+# Unicode aware and will refuse to match through invalid UTF-8 bytes.
+[[test]]
+name = "dotstar-prefix-ascii"
+regex = 'a'
+haystack = '\xFFa'
+matches = [[1, 2]]
+unescape = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "dotstar-prefix-unicode"
+regex = 'a'
+haystack = '\xFFa'
+matches = [[1, 2]]
+unescape = true
+unicode = true
+utf8 = false
+
+[[test]]
+name = "null-bytes"
+regex = '(?P<cstr>[^\x00]+)\x00'
+haystack = 'foo\x00'
+matches = [
+  [[0, 4], [0, 3]],
+]
+unescape = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "invalid-utf8-anchor-100"
+regex = '\xCC?^'
+haystack = '\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4'
+matches = [[0, 0]]
+unescape = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "invalid-utf8-anchor-200"
+regex = '^\xf7|4\xff\d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########[] d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########\[] #####\x80\S7|$'
+haystack = '\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4'
+matches = [[22, 22]]
+unescape = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "invalid-utf8-anchor-300"
+regex = '^|ddp\xff\xffdddddlQd@\x80'
+haystack = '\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4'
+matches = [[0, 0]]
+unescape = true
+unicode = false
+utf8 = false
+
+[[test]]
+name = "word-boundary-ascii-100"
+regex = '\Bx\B'
+haystack = "áxβ"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "word-boundary-ascii-200"
+regex = '\B'
+haystack = "0\U0007EF5E"
+matches = [[2, 2], [3, 3], [4, 4], [5, 5]]
+unicode = false
+utf8 = false
diff --git a/testdata/crazy.toml b/testdata/crazy.toml
new file mode 100644
index 0000000000..aed46ea157
--- /dev/null
+++ b/testdata/crazy.toml
@@ -0,0 +1,315 @@
+[[test]]
+name = "nothing-empty"
+regex = []
+haystack = ""
+matches = []
+
+[[test]]
+name = "nothing-something"
+regex = []
+haystack = "wat"
+matches = []
+
+[[test]]
+name = "ranges"
+regex = '(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b'
+haystack = "num: 255"
+matches = [[5, 8]]
+
+[[test]]
+name = "ranges-not"
+regex = '(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b'
+haystack = "num: 256"
+matches = []
+
+[[test]]
+name = "float1"
+regex = '[-+]?[0-9]*\.?[0-9]+'
+haystack = "0.1"
+matches = [[0, 3]]
+
+[[test]]
+name = "float2"
+regex = '[-+]?[0-9]*\.?[0-9]+'
+haystack = "0.1.2"
+matches = [[0, 3]]
+match-limit = 1
+
+[[test]]
+name = "float3"
+regex = '[-+]?[0-9]*\.?[0-9]+'
+haystack = "a1.2"
+matches = [[1, 4]]
+
+[[test]]
+name = "float4"
+regex = '[-+]?[0-9]*\.?[0-9]+'
+haystack = "1.a"
+matches = [[0, 1]]
+
+[[test]]
+name = "float5"
+regex = '^[-+]?[0-9]*\.?[0-9]+$'
+haystack = "1.a"
+matches = []
+
+[[test]]
+name = "email"
+regex = '(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b'
+haystack = "mine is jam.slam@gmail.com "
+matches = [[8, 26]]
+
+[[test]]
+name = "email-not"
+regex = '(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b'
+haystack = "mine is jam.slam@gmail "
+matches = []
+
+[[test]]
+name = "email-big"
+regex = '''[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?'''
+haystack = "mine is jam.slam@gmail.com "
+matches = [[8, 26]]
+
+[[test]]
+name = "date1"
+regex = '^(?:19|20)\d\d[- /.](?:0[1-9]|1[012])[- /.](?:0[1-9]|[12][0-9]|3[01])$'
+haystack = "1900-01-01"
+matches = [[0, 10]]
+unicode = false
+
+[[test]]
+name = "date2"
+regex = '^(?:19|20)\d\d[- /.](?:0[1-9]|1[012])[- /.](?:0[1-9]|[12][0-9]|3[01])$'
+haystack = "1900-00-01"
+matches = []
+unicode = false
+
+[[test]]
+name = "date3"
+regex = '^(?:19|20)\d\d[- /.](?:0[1-9]|1[012])[- /.](?:0[1-9]|[12][0-9]|3[01])$'
+haystack = "1900-13-01"
+matches = []
+unicode = false
+
+[[test]]
+name = "start-end-empty"
+regex = '^$'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "start-end-empty-rev"
+regex = '$^'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "start-end-empty-many-1"
+regex = '^$^$^$'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "start-end-empty-many-2"
+regex = '^^^$$$'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "start-end-empty-rep"
+regex = '(?:^$)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "start-end-empty-rep-rev"
+regex = '(?:$^)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "neg-class-letter"
+regex = '[^ac]'
+haystack = "acx"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-letter-comma"
+regex = '[^a,]'
+haystack = "a,x"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-letter-space"
+regex = '[^a[:space:]]'
+haystack = "a x"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-comma"
+regex = '[^,]'
+haystack = ",,x"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-space"
+regex = '[^[:space:]]'
+haystack = " a"
+matches = [[1, 2]]
+
+[[test]]
+name = "neg-class-space-comma"
+regex = '[^,[:space:]]'
+haystack = ", a"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-comma-space"
+regex = '[^[:space:],]'
+haystack = " ,a"
+matches = [[2, 3]]
+
+[[test]]
+name = "neg-class-ascii"
+regex = '[^[:alpha:]Z]'
+haystack = "A1"
+matches = [[1, 2]]
+
+[[test]]
+name = "lazy-many-many"
+regex = '(?:(?:.*)*?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "lazy-many-optional"
+regex = '(?:(?:.?)*?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "lazy-one-many-many"
+regex = '(?:(?:.*)+?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "lazy-one-many-optional"
+regex = '(?:(?:.?)+?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "lazy-range-min-many"
+regex = '(?:(?:.*){1,}?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "lazy-range-many"
+regex = '(?:(?:.*){1,2}?)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-many-many"
+regex = '(?:(?:.*)*)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-many-optional"
+regex = '(?:(?:.?)*)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-one-many-many"
+regex = '(?:(?:.*)+)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-one-many-optional"
+regex = '(?:(?:.?)+)='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-range-min-many"
+regex = '(?:(?:.*){1,})='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "greedy-range-many"
+regex = '(?:(?:.*){1,2})='
+haystack = "a=b"
+matches = [[0, 2]]
+
+[[test]]
+name = "empty1"
+regex = ''
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "empty2"
+regex = ''
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty3"
+regex = '(?:)'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty4"
+regex = '(?:)*'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty5"
+regex = '(?:)+'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty6"
+regex = '(?:)?'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty7"
+regex = '(?:)(?:)'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty8"
+regex = '(?:)+|z'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty9"
+regex = 'z|(?:)+'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty10"
+regex = '(?:)+|b'
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty11"
+regex = 'b|(?:)+'
+haystack = "abc"
+matches = [[0, 0], [1, 2], [3, 3]]
diff --git a/testdata/crlf.toml b/testdata/crlf.toml
new file mode 100644
index 0000000000..9e2d3761af
--- /dev/null
+++ b/testdata/crlf.toml
@@ -0,0 +1,117 @@
+# This is a basic test that checks ^ and $ treat \r\n as a single line
+# terminator. If ^ and $ only treated \n as a line terminator, then this would
+# only match 'xyz' at the end of the haystack.
+[[test]]
+name = "basic"
+regex = '(?mR)^[a-z]+$'
+haystack = "abc\r\ndef\r\nxyz"
+matches = [[0, 3], [5, 8], [10, 13]]
+
+# Tests that a CRLF-aware '^$' assertion does not match between CR and LF.
+[[test]]
+name = "start-end-non-empty"
+regex = '(?mR)^$'
+haystack = "abc\r\ndef\r\nxyz"
+matches = []
+
+# Tests that a CRLF-aware '^$' assertion matches the empty string, just like
+# a non-CRLF-aware '^$' assertion.
+[[test]]
+name = "start-end-empty"
+regex = '(?mR)^$'
+haystack = ""
+matches = [[0, 0]]
+
+# Tests that a CRLF-aware '^$' assertion matches the empty string preceding
+# and following a line terminator.
+[[test]]
+name = "start-end-before-after"
+regex = '(?mR)^$'
+haystack = "\r\n"
+matches = [[0, 0], [2, 2]]
+
+# Tests that a CRLF-aware '^' assertion does not split a line terminator.
+[[test]]
+name = "start-no-split"
+regex = '(?mR)^'
+haystack = "abc\r\ndef\r\nxyz"
+matches = [[0, 0], [5, 5], [10, 10]]
+
+# Same as above, but with adjacent runs of line terminators.
+[[test]]
+name = "start-no-split-adjacent"
+regex = '(?mR)^'
+haystack = "\r\n\r\n\r\n"
+matches = [[0, 0], [2, 2], [4, 4], [6, 6]]
+
+# Same as above, but with adjacent runs of just carriage returns.
+[[test]]
+name = "start-no-split-adjacent-cr"
+regex = '(?mR)^'
+haystack = "\r\r\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+# Same as above, but with adjacent runs of just line feeds.
+[[test]]
+name = "start-no-split-adjacent-lf"
+regex = '(?mR)^'
+haystack = "\n\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+# Tests that a CRLF-aware '$' assertion does not split a line terminator.
+[[test]]
+name = "end-no-split"
+regex = '(?mR)$'
+haystack = "abc\r\ndef\r\nxyz"
+matches = [[3, 3], [8, 8], [13, 13]]
+
+# Same as above, but with adjacent runs of line terminators.
+[[test]]
+name = "end-no-split-adjacent"
+regex = '(?mR)$'
+haystack = "\r\n\r\n\r\n"
+matches = [[0, 0], [2, 2], [4, 4], [6, 6]]
+
+# Same as above, but with adjacent runs of just carriage returns.
+[[test]]
+name = "end-no-split-adjacent-cr"
+regex = '(?mR)$'
+haystack = "\r\r\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+# Same as above, but with adjacent runs of just line feeds.
+[[test]]
+name = "end-no-split-adjacent-lf"
+regex = '(?mR)$'
+haystack = "\n\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+# Tests that '.' does not match either \r or \n when CRLF mode is enabled. Note
+# that this doesn't require multi-line mode to be enabled.
+[[test]]
+name = "dot-no-crlf"
+regex = '(?R).'
+haystack = "\r\n\r\n\r\n"
+matches = []
+
+# This is a test that caught a bug in the one-pass DFA where it (amazingly) was
+# using 'is_end_lf' instead of 'is_end_crlf' here. It was probably a copy &
+# paste bug. We insert an empty capture group here because it provokes the meta
+# regex engine to first find a match and then trip over a panic because the
+# one-pass DFA erroneously says there is no match.
+[[test]]
+name = "onepass-wrong-crlf-with-capture"
+regex = '(?Rm:().$)'
+haystack = "ZZ\r"
+matches = [[[1, 2], [1, 1]]]
+
+# This is like onepass-wrong-crlf-with-capture above, except it sets up the
+# test so that it can be run by the one-pass DFA directly. (i.e., Make it
+# anchored and start the search at the right place.)
+[[test]]
+name = "onepass-wrong-crlf-anchored"
+regex = '(?Rm:.$)'
+haystack = "ZZ\r"
+matches = [[1, 2]]
+anchored = true
+bounds = [1, 3]
diff --git a/testdata/earliest.toml b/testdata/earliest.toml
new file mode 100644
index 0000000000..951689358e
--- /dev/null
+++ b/testdata/earliest.toml
@@ -0,0 +1,52 @@
+[[test]]
+name = "no-greedy-100"
+regex = 'a+'
+haystack = "aaa"
+matches = [[0, 1], [1, 2], [2, 3]]
+search-kind = "earliest"
+
+[[test]]
+name = "no-greedy-200"
+regex = 'abc+'
+haystack = "zzzabccc"
+matches = [[3, 6]]
+search-kind = "earliest"
+
+[[test]]
+name = "is-ungreedy"
+regex = 'a+?'
+haystack = "aaa"
+matches = [[0, 1], [1, 2], [2, 3]]
+search-kind = "earliest"
+
+[[test]]
+name = "look-start-test"
+regex = '^(abc|a)'
+haystack = "abc"
+matches = [
+  [[0, 1], [0, 1]],
+]
+search-kind = "earliest"
+
+[[test]]
+name = "look-end-test"
+regex = '(abc|a)$'
+haystack = "abc"
+matches = [
+  [[0, 3], [0, 3]],
+]
+search-kind = "earliest"
+
+[[test]]
+name = "no-leftmost-first-100"
+regex = 'abc|a'
+haystack = "abc"
+matches = [[0, 1]]
+search-kind = "earliest"
+
+[[test]]
+name = "no-leftmost-first-200"
+regex = 'aba|a'
+haystack = "aba"
+matches = [[0, 1], [2, 3]]
+search-kind = "earliest"
diff --git a/testdata/empty.toml b/testdata/empty.toml
new file mode 100644
index 0000000000..7dfd8027a4
--- /dev/null
+++ b/testdata/empty.toml
@@ -0,0 +1,113 @@
+[[test]]
+name = "100"
+regex = "|b"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "110"
+regex = "b|"
+haystack = "abc"
+matches = [[0, 0], [1, 2], [3, 3]]
+
+[[test]]
+name = "120"
+regex = "|z"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "130"
+regex = "z|"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "200"
+regex = "|"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "210"
+regex = "||"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "220"
+regex = "||b"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "230"
+regex = "b||"
+haystack = "abc"
+matches = [[0, 0], [1, 2], [3, 3]]
+
+[[test]]
+name = "240"
+regex = "||z"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "300"
+regex = "(?:)|b"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "310"
+regex = "b|(?:)"
+haystack = "abc"
+matches = [[0, 0], [1, 2], [3, 3]]
+
+[[test]]
+name = "320"
+regex = "(?:|)"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "330"
+regex = "(?:|)|z"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "400"
+regex = "a(?:)|b"
+haystack = "abc"
+matches = [[0, 1], [1, 2]]
+
+[[test]]
+name = "500"
+regex = ""
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "510"
+regex = ""
+haystack = "a"
+matches = [[0, 0], [1, 1]]
+
+[[test]]
+name = "520"
+regex = ""
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "600"
+regex = '(?:|a)*'
+haystack = "aaa"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "610"
+regex = '(?:|a)+'
+haystack = "aaa"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
diff --git a/testdata/expensive.toml b/testdata/expensive.toml
new file mode 100644
index 0000000000..b70e42f9bb
--- /dev/null
+++ b/testdata/expensive.toml
@@ -0,0 +1,23 @@
+# This file represent tests that may be expensive to run on some regex engines.
+# For example, tests that build a full DFA ahead of time and minimize it can
+# take a horrendously long time on regexes that are large (or result in an
+# explosion in the number of states). We group these tests together so that
+# such engines can simply skip these tests.
+
+# See: https://github.com/rust-lang/regex/issues/98
+[[test]]
+name = "regression-many-repeat-no-stack-overflow"
+regex = '^.{1,2500}'
+haystack = "a"
+matches = [[0, 1]]
+
+# This test is meant to blow the bounded backtracker's visited capacity. In
+# order to do that, we need a somewhat sizeable regex. The purpose of this
+# is to make sure there's at least one test that exercises this path in the
+# backtracker. All other tests (at time of writing) are small enough that the
+# backtracker can handle them fine.
+[[test]]
+name = "backtrack-blow-visited-capacity"
+regex = '\pL{50}'
+haystack = "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyZZ"
+matches = [[0, 50], [50, 100], [100, 150]]
diff --git a/testdata/flags.toml b/testdata/flags.toml
new file mode 100644
index 0000000000..30b412ca65
--- /dev/null
+++ b/testdata/flags.toml
@@ -0,0 +1,68 @@
+[[test]]
+name = "1"
+regex = "(?i)abc"
+haystack = "ABC"
+matches = [[0, 3]]
+
+[[test]]
+name = "2"
+regex = "(?i)a(?-i)bc"
+haystack = "Abc"
+matches = [[0, 3]]
+
+[[test]]
+name = "3"
+regex = "(?i)a(?-i)bc"
+haystack = "ABC"
+matches = []
+
+[[test]]
+name = "4"
+regex = "(?is)a."
+haystack = "A\n"
+matches = [[0, 2]]
+
+[[test]]
+name = "5"
+regex = "(?is)a.(?-is)a."
+haystack = "A\nab"
+matches = [[0, 4]]
+
+[[test]]
+name = "6"
+regex = "(?is)a.(?-is)a."
+haystack = "A\na\n"
+matches = []
+
+[[test]]
+name = "7"
+regex = "(?is)a.(?-is:a.)?"
+haystack = "A\na\n"
+matches = [[0, 2]]
+match-limit = 1
+
+[[test]]
+name = "8"
+regex = "(?U)a+"
+haystack = "aa"
+matches = [[0, 1]]
+match-limit = 1
+
+[[test]]
+name = "9"
+regex = "(?U)a+?"
+haystack = "aa"
+matches = [[0, 2]]
+
+[[test]]
+name = "10"
+regex = "(?U)(?-U)a+"
+haystack = "aa"
+matches = [[0, 2]]
+
+[[test]]
+name = "11"
+regex = '(?m)(?:^\d+$\n?)+'
+haystack = "123\n456\n789"
+matches = [[0, 11]]
+unicode = false
diff --git a/testdata/fowler/basic.toml b/testdata/fowler/basic.toml
new file mode 100644
index 0000000000..92b4e4cf72
--- /dev/null
+++ b/testdata/fowler/basic.toml
@@ -0,0 +1,1611 @@
+# !!! DO NOT EDIT !!!
+# Automatically generated by 'regex-cli generate fowler'.
+# Numbers in the test names correspond to the line number of the test from
+# the original dat file.
+
+[[test]]
+name = "basic3"
+regex = '''abracadabra$'''
+haystack = '''abracadabracadabra'''
+matches = [[[7, 18]]]
+match-limit = 1
+
+[[test]]
+name = "basic4"
+regex = '''a...b'''
+haystack = '''abababbb'''
+matches = [[[2, 7]]]
+match-limit = 1
+
+[[test]]
+name = "basic5"
+regex = '''XXXXXX'''
+haystack = '''..XXXXXX'''
+matches = [[[2, 8]]]
+match-limit = 1
+
+[[test]]
+name = "basic6"
+regex = '''\)'''
+haystack = '''()'''
+matches = [[[1, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic7"
+regex = '''a]'''
+haystack = '''a]a'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic9"
+regex = '''\}'''
+haystack = '''}'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic10"
+regex = '''\]'''
+haystack = ''']'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic12"
+regex = ''']'''
+haystack = ''']'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic15"
+regex = '''^a'''
+haystack = '''ax'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic16"
+regex = '''\^a'''
+haystack = '''a^a'''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic17"
+regex = '''a\^'''
+haystack = '''a^'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic18"
+regex = '''a$'''
+haystack = '''aa'''
+matches = [[[1, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic19"
+regex = '''a\$'''
+haystack = '''a$'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic20"
+regex = '''^$'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic21"
+regex = '''$^'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic22"
+regex = '''a($)'''
+haystack = '''aa'''
+matches = [[[1, 2], [2, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic23"
+regex = '''a*(^a)'''
+haystack = '''aa'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic24"
+regex = '''(..)*(...)*'''
+haystack = '''a'''
+matches = [[[0, 0], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic25"
+regex = '''(..)*(...)*'''
+haystack = '''abcd'''
+matches = [[[0, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic26"
+regex = '''(ab|a)(bc|c)'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 2], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic27"
+regex = '''(ab)c|abc'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic28"
+regex = '''a{0}b'''
+haystack = '''ab'''
+matches = [[[1, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic29"
+regex = '''(a*)(b?)(b+)b{3}'''
+haystack = '''aaabbbbbbb'''
+matches = [[[0, 10], [0, 3], [3, 4], [4, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic30"
+regex = '''(a*)(b{0,1})(b{1,})b{3}'''
+haystack = '''aaabbbbbbb'''
+matches = [[[0, 10], [0, 3], [3, 4], [4, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic32"
+regex = '''((a|a)|a)'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic33"
+regex = '''(a*)(a|aa)'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [0, 3], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic34"
+regex = '''a*(a.|aa)'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [2, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic35"
+regex = '''a(b)|c(d)|a(e)f'''
+haystack = '''aef'''
+matches = [[[0, 3], [], [], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic36"
+regex = '''(a|b)?.*'''
+haystack = '''b'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic37"
+regex = '''(a|b)c|a(b|c)'''
+haystack = '''ac'''
+matches = [[[0, 2], [0, 1], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic38"
+regex = '''(a|b)c|a(b|c)'''
+haystack = '''ab'''
+matches = [[[0, 2], [], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic39"
+regex = '''(a|b)*c|(a|ab)*c'''
+haystack = '''abc'''
+matches = [[[0, 3], [1, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic40"
+regex = '''(a|b)*c|(a|ab)*c'''
+haystack = '''xc'''
+matches = [[[1, 2], [], []]]
+match-limit = 1
+
+[[test]]
+name = "basic41"
+regex = '''(.a|.b).*|.*(.a|.b)'''
+haystack = '''xa'''
+matches = [[[0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic42"
+regex = '''a?(ab|ba)ab'''
+haystack = '''abab'''
+matches = [[[0, 4], [0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic43"
+regex = '''a?(ac{0}b|ba)ab'''
+haystack = '''abab'''
+matches = [[[0, 4], [0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic44"
+regex = '''ab|abab'''
+haystack = '''abbabab'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic45"
+regex = '''aba|bab|bba'''
+haystack = '''baaabbbaba'''
+matches = [[[5, 8]]]
+match-limit = 1
+
+[[test]]
+name = "basic46"
+regex = '''aba|bab'''
+haystack = '''baaabbbaba'''
+matches = [[[6, 9]]]
+match-limit = 1
+
+[[test]]
+name = "basic47"
+regex = '''(aa|aaa)*|(a|aaaaa)'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic48"
+regex = '''(a.|.a.)*|(a|.a...)'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic49"
+regex = '''ab|a'''
+haystack = '''xabc'''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic50"
+regex = '''ab|a'''
+haystack = '''xxabc'''
+matches = [[[2, 4]]]
+match-limit = 1
+
+[[test]]
+name = "basic51"
+regex = '''(Ab|cD)*'''
+haystack = '''aBcD'''
+matches = [[[0, 4], [2, 4]]]
+match-limit = 1
+anchored = true
+case-insensitive = true
+
+[[test]]
+name = "basic52"
+regex = '''[^-]'''
+haystack = '''--a'''
+matches = [[[2, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic53"
+regex = '''[a-]*'''
+haystack = '''--a'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic54"
+regex = '''[a-m-]*'''
+haystack = '''--amoma--'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic55"
+regex = ''':::1:::0:|:::1:1:0:'''
+haystack = ''':::0:::1:::1:::0:'''
+matches = [[[8, 17]]]
+match-limit = 1
+
+[[test]]
+name = "basic56"
+regex = ''':::1:::0:|:::1:1:1:'''
+haystack = ''':::0:::1:::1:::0:'''
+matches = [[[8, 17]]]
+match-limit = 1
+
+[[test]]
+name = "basic57"
+regex = '''[[:upper:]]'''
+haystack = '''A'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic58"
+regex = '''[[:lower:]]+'''
+haystack = '''`az{'''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic59"
+regex = '''[[:upper:]]+'''
+haystack = '''@AZ['''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic65"
+regex = '''\n'''
+haystack = '''\n'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic66"
+regex = '''\n'''
+haystack = '''\n'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic67"
+regex = '''[^a]'''
+haystack = '''\n'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic68"
+regex = '''\na'''
+haystack = '''\na'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic69"
+regex = '''(a)(b)(c)'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 1], [1, 2], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic70"
+regex = '''xxx'''
+haystack = '''xxx'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic72"
+regex = '''(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)'''
+haystack = '''feb 6,'''
+matches = [[[0, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic74"
+regex = '''(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)'''
+haystack = '''2/7'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic76"
+regex = '''(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)'''
+haystack = '''feb 1,Feb 6'''
+matches = [[[5, 11]]]
+match-limit = 1
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic78"
+regex = '''(((?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:x))))))))))))))))))))))))))))))'''
+haystack = '''x'''
+matches = [[[0, 1], [0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic80"
+regex = '''(((?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:x))))))))))))))))))))))))))))))*'''
+haystack = '''xx'''
+matches = [[[0, 2], [1, 2], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic81"
+regex = '''a?(ab|ba)*'''
+haystack = '''ababababababababababababababababababababababababababababababababababababababababa'''
+matches = [[[0, 81], [79, 81]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic82"
+regex = '''abaa|abbaa|abbbaa|abbbbaa'''
+haystack = '''ababbabbbabbbabbbbabbbbaa'''
+matches = [[[18, 25]]]
+match-limit = 1
+
+[[test]]
+name = "basic83"
+regex = '''abaa|abbaa|abbbaa|abbbbaa'''
+haystack = '''ababbabbbabbbabbbbabaa'''
+matches = [[[18, 22]]]
+match-limit = 1
+
+[[test]]
+name = "basic84"
+regex = '''aaac|aabc|abac|abbc|baac|babc|bbac|bbbc'''
+haystack = '''baaabbbabac'''
+matches = [[[7, 11]]]
+match-limit = 1
+
+# Test added by Rust regex project.
+[[test]]
+name = "basic86"
+regex = '''.*'''
+haystack = '''\x01\x7f'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic87"
+regex = '''aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll'''
+haystack = '''XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa'''
+matches = [[[53, 57]]]
+match-limit = 1
+
+[[test]]
+name = "basic89"
+regex = '''a*a*a*a*a*b'''
+haystack = '''aaaaaaaaab'''
+matches = [[[0, 10]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic90"
+regex = '''^'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic91"
+regex = '''$'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic92"
+regex = '''^$'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic93"
+regex = '''^a$'''
+haystack = '''a'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic94"
+regex = '''abc'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic95"
+regex = '''abc'''
+haystack = '''xabcy'''
+matches = [[[1, 4]]]
+match-limit = 1
+
+[[test]]
+name = "basic96"
+regex = '''abc'''
+haystack = '''ababc'''
+matches = [[[2, 5]]]
+match-limit = 1
+
+[[test]]
+name = "basic97"
+regex = '''ab*c'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic98"
+regex = '''ab*bc'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic99"
+regex = '''ab*bc'''
+haystack = '''abbc'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic100"
+regex = '''ab*bc'''
+haystack = '''abbbbc'''
+matches = [[[0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic101"
+regex = '''ab+bc'''
+haystack = '''abbc'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic102"
+regex = '''ab+bc'''
+haystack = '''abbbbc'''
+matches = [[[0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic103"
+regex = '''ab?bc'''
+haystack = '''abbc'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic104"
+regex = '''ab?bc'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic105"
+regex = '''ab?c'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic106"
+regex = '''^abc$'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic107"
+regex = '''^abc'''
+haystack = '''abcc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic108"
+regex = '''abc$'''
+haystack = '''aabc'''
+matches = [[[1, 4]]]
+match-limit = 1
+
+[[test]]
+name = "basic109"
+regex = '''^'''
+haystack = '''abc'''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic110"
+regex = '''$'''
+haystack = '''abc'''
+matches = [[[3, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic111"
+regex = '''a.c'''
+haystack = '''abc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic112"
+regex = '''a.c'''
+haystack = '''axc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic113"
+regex = '''a.*c'''
+haystack = '''axyzc'''
+matches = [[[0, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic114"
+regex = '''a[bc]d'''
+haystack = '''abd'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic115"
+regex = '''a[b-d]e'''
+haystack = '''ace'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic116"
+regex = '''a[b-d]'''
+haystack = '''aac'''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic117"
+regex = '''a[-b]'''
+haystack = '''a-'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic118"
+regex = '''a[b-]'''
+haystack = '''a-'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic119"
+regex = '''a]'''
+haystack = '''a]'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic120"
+regex = '''a[]]b'''
+haystack = '''a]b'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic121"
+regex = '''a[^bc]d'''
+haystack = '''aed'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic122"
+regex = '''a[^-b]c'''
+haystack = '''adc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic123"
+regex = '''a[^]b]c'''
+haystack = '''adc'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic124"
+regex = '''ab|cd'''
+haystack = '''abc'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic125"
+regex = '''ab|cd'''
+haystack = '''abcd'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic126"
+regex = '''a\(b'''
+haystack = '''a(b'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic127"
+regex = '''a\(*b'''
+haystack = '''ab'''
+matches = [[[0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic128"
+regex = '''a\(*b'''
+haystack = '''a((b'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic129"
+regex = '''((a))'''
+haystack = '''abc'''
+matches = [[[0, 1], [0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic130"
+regex = '''(a)b(c)'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 1], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic131"
+regex = '''a+b+c'''
+haystack = '''aabbabc'''
+matches = [[[4, 7]]]
+match-limit = 1
+
+[[test]]
+name = "basic132"
+regex = '''a*'''
+haystack = '''aaa'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic133"
+regex = '''(a*)*'''
+haystack = '''-'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic134"
+regex = '''(a*)+'''
+haystack = '''-'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic135"
+regex = '''(a*|b)*'''
+haystack = '''-'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic136"
+regex = '''(a+|b)*'''
+haystack = '''ab'''
+matches = [[[0, 2], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic137"
+regex = '''(a+|b)+'''
+haystack = '''ab'''
+matches = [[[0, 2], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic138"
+regex = '''(a+|b)?'''
+haystack = '''ab'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic139"
+regex = '''[^ab]*'''
+haystack = '''cde'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic140"
+regex = '''(^)*'''
+haystack = '''-'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic141"
+regex = '''a*'''
+haystack = ''''''
+matches = [[[0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic142"
+regex = '''([abc])*d'''
+haystack = '''abbbcd'''
+matches = [[[0, 6], [4, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic143"
+regex = '''([abc])*bcd'''
+haystack = '''abcd'''
+matches = [[[0, 4], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic144"
+regex = '''a|b|c|d|e'''
+haystack = '''e'''
+matches = [[[0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic145"
+regex = '''(a|b|c|d|e)f'''
+haystack = '''ef'''
+matches = [[[0, 2], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic146"
+regex = '''((a*|b))*'''
+haystack = '''-'''
+matches = [[[0, 0], [0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic147"
+regex = '''abcd*efg'''
+haystack = '''abcdefg'''
+matches = [[[0, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic148"
+regex = '''ab*'''
+haystack = '''xabyabbbz'''
+matches = [[[1, 3]]]
+match-limit = 1
+
+[[test]]
+name = "basic149"
+regex = '''ab*'''
+haystack = '''xayabbbz'''
+matches = [[[1, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic150"
+regex = '''(ab|cd)e'''
+haystack = '''abcde'''
+matches = [[[2, 5], [2, 4]]]
+match-limit = 1
+
+[[test]]
+name = "basic151"
+regex = '''[abhgefdc]ij'''
+haystack = '''hij'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic152"
+regex = '''(a|b)c*d'''
+haystack = '''abcd'''
+matches = [[[1, 4], [1, 2]]]
+match-limit = 1
+
+[[test]]
+name = "basic153"
+regex = '''(ab|ab*)bc'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic154"
+regex = '''a([bc]*)c*'''
+haystack = '''abc'''
+matches = [[[0, 3], [1, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic155"
+regex = '''a([bc]*)(c*d)'''
+haystack = '''abcd'''
+matches = [[[0, 4], [1, 3], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic156"
+regex = '''a([bc]+)(c*d)'''
+haystack = '''abcd'''
+matches = [[[0, 4], [1, 3], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic157"
+regex = '''a([bc]*)(c+d)'''
+haystack = '''abcd'''
+matches = [[[0, 4], [1, 2], [2, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic158"
+regex = '''a[bcd]*dcdcde'''
+haystack = '''adcdcde'''
+matches = [[[0, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic159"
+regex = '''(ab|a)b*c'''
+haystack = '''abc'''
+matches = [[[0, 3], [0, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic160"
+regex = '''((a)(b)c)(d)'''
+haystack = '''abcd'''
+matches = [[[0, 4], [0, 3], [0, 1], [1, 2], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic161"
+regex = '''[A-Za-z_][A-Za-z0-9_]*'''
+haystack = '''alpha'''
+matches = [[[0, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic162"
+regex = '''^a(bc+|b[eh])g|.h$'''
+haystack = '''abh'''
+matches = [[[1, 3], []]]
+match-limit = 1
+
+[[test]]
+name = "basic163"
+regex = '''(bc+d$|ef*g.|h?i(j|k))'''
+haystack = '''effgz'''
+matches = [[[0, 5], [0, 5], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic164"
+regex = '''(bc+d$|ef*g.|h?i(j|k))'''
+haystack = '''ij'''
+matches = [[[0, 2], [0, 2], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic165"
+regex = '''(bc+d$|ef*g.|h?i(j|k))'''
+haystack = '''reffgz'''
+matches = [[[1, 6], [1, 6], []]]
+match-limit = 1
+
+[[test]]
+name = "basic166"
+regex = '''(((((((((a)))))))))'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic167"
+regex = '''multiple words'''
+haystack = '''multiple words yeah'''
+matches = [[[0, 14]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic168"
+regex = '''(.*)c(.*)'''
+haystack = '''abcde'''
+matches = [[[0, 5], [0, 2], [3, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic169"
+regex = '''abcd'''
+haystack = '''abcd'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic170"
+regex = '''a(bc)d'''
+haystack = '''abcd'''
+matches = [[[0, 4], [1, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic171"
+regex = '''a[\x01-\x03]?c'''
+haystack = '''a\x02c'''
+matches = [[[0, 3]]]
+match-limit = 1
+anchored = true
+unescape = true
+
+[[test]]
+name = "basic172"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Qaddafi'''
+matches = [[[0, 15], [], [10, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic173"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Mo'ammar Gadhafi'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic174"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Kaddafi'''
+matches = [[[0, 15], [], [10, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic175"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Qadhafi'''
+matches = [[[0, 15], [], [10, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic176"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Gadafi'''
+matches = [[[0, 14], [], [10, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic177"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Mu'ammar Qadafi'''
+matches = [[[0, 15], [], [11, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic178"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Moamar Gaddafi'''
+matches = [[[0, 14], [], [9, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic179"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Mu'ammar Qadhdhafi'''
+matches = [[[0, 18], [], [13, 15]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic180"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Khaddafi'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic181"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Ghaddafy'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic182"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Ghadafi'''
+matches = [[[0, 15], [], [11, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic183"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Ghaddafi'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic184"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muamar Kaddafi'''
+matches = [[[0, 14], [], [9, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic185"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Quathafi'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic186"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Muammar Gheddafi'''
+matches = [[[0, 16], [], [11, 13]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic187"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Moammar Khadafy'''
+matches = [[[0, 15], [], [11, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic188"
+regex = '''M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]'''
+haystack = '''Moammar Qudhafi'''
+matches = [[[0, 15], [], [10, 12]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic189"
+regex = '''a+(b|c)*d+'''
+haystack = '''aabcdd'''
+matches = [[[0, 6], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic190"
+regex = '''^.+$'''
+haystack = '''vivi'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic191"
+regex = '''^(.+)$'''
+haystack = '''vivi'''
+matches = [[[0, 4], [0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic192"
+regex = '''^([^!.]+).att.com!(.+)$'''
+haystack = '''gryphon.att.com!eby'''
+matches = [[[0, 19], [0, 7], [16, 19]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic193"
+regex = '''^([^!]+!)?([^!]+)$'''
+haystack = '''bas'''
+matches = [[[0, 3], [], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic194"
+regex = '''^([^!]+!)?([^!]+)$'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 4], [4, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic195"
+regex = '''^([^!]+!)?([^!]+)$'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 4], [4, 7]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic196"
+regex = '''^.+!([^!]+!)([^!]+)$'''
+haystack = '''foo!bar!bas'''
+matches = [[[0, 11], [4, 8], [8, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic197"
+regex = '''((foo)|(bar))!bas'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 3], [], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic198"
+regex = '''((foo)|(bar))!bas'''
+haystack = '''foo!bar!bas'''
+matches = [[[4, 11], [4, 7], [], [4, 7]]]
+match-limit = 1
+
+[[test]]
+name = "basic199"
+regex = '''((foo)|(bar))!bas'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 3], [0, 3], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic200"
+regex = '''((foo)|bar)!bas'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 3], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic201"
+regex = '''((foo)|bar)!bas'''
+haystack = '''foo!bar!bas'''
+matches = [[[4, 11], [4, 7], []]]
+match-limit = 1
+
+[[test]]
+name = "basic202"
+regex = '''((foo)|bar)!bas'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 3], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic203"
+regex = '''(foo|(bar))!bas'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 3], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic204"
+regex = '''(foo|(bar))!bas'''
+haystack = '''foo!bar!bas'''
+matches = [[[4, 11], [4, 7], [4, 7]]]
+match-limit = 1
+
+[[test]]
+name = "basic205"
+regex = '''(foo|(bar))!bas'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 3], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic206"
+regex = '''(foo|bar)!bas'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic207"
+regex = '''(foo|bar)!bas'''
+haystack = '''foo!bar!bas'''
+matches = [[[4, 11], [4, 7]]]
+match-limit = 1
+
+[[test]]
+name = "basic208"
+regex = '''(foo|bar)!bas'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic209"
+regex = '''^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$'''
+haystack = '''foo!bar!bas'''
+matches = [[[0, 11], [0, 11], [], [], [4, 8], [8, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic210"
+regex = '''^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$'''
+haystack = '''bas'''
+matches = [[[0, 3], [], [0, 3], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic211"
+regex = '''^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 4], [4, 7], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic212"
+regex = '''^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$'''
+haystack = '''foo!bar!bas'''
+matches = [[[0, 11], [], [], [4, 8], [8, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic213"
+regex = '''^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 4], [4, 7], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic214"
+regex = '''^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$'''
+haystack = '''bas'''
+matches = [[[0, 3], [0, 3], [], [0, 3], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic215"
+regex = '''^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$'''
+haystack = '''bar!bas'''
+matches = [[[0, 7], [0, 7], [0, 4], [4, 7], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic216"
+regex = '''^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$'''
+haystack = '''foo!bar!bas'''
+matches = [[[0, 11], [0, 11], [], [], [4, 8], [8, 11]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic217"
+regex = '''^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$'''
+haystack = '''foo!bas'''
+matches = [[[0, 7], [0, 7], [0, 4], [4, 7], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic218"
+regex = '''.*(/XXX).*'''
+haystack = '''/XXX'''
+matches = [[[0, 4], [0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic219"
+regex = '''.*(\\XXX).*'''
+haystack = '''\XXX'''
+matches = [[[0, 4], [0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic220"
+regex = '''\\XXX'''
+haystack = '''\XXX'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic221"
+regex = '''.*(/000).*'''
+haystack = '''/000'''
+matches = [[[0, 4], [0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic222"
+regex = '''.*(\\000).*'''
+haystack = '''\000'''
+matches = [[[0, 4], [0, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "basic223"
+regex = '''\\000'''
+haystack = '''\000'''
+matches = [[[0, 4]]]
+match-limit = 1
+anchored = true
+
diff --git a/testdata/fowler/dat/README b/testdata/fowler/dat/README
new file mode 100644
index 0000000000..242a0e6c3a
--- /dev/null
+++ b/testdata/fowler/dat/README
@@ -0,0 +1,25 @@
+Test data was taken from the Go distribution, which was in turn taken from the
+testregex test suite:
+
+  http://web.archive.org/web/20150925124103/http://www2.research.att.com/~astopen/testregex/testregex.html
+
+Unfortunately, the original web site now appears dead, but the test data lives
+on.
+
+The LICENSE in this directory corresponds to the LICENSE that the data was
+originally released under.
+
+The tests themselves were modified for RE2/Go (and marked as such). A
+couple were modified further by me (Andrew Gallant) and marked with 'Rust'.
+
+After some number of years, these tests were transformed into a TOML format
+using the 'regex-cli generate fowler' command. To re-generate the
+TOML files, run the following from the root of this repository:
+
+  regex-cli generate fowler tests/data/fowler tests/data/fowler/dat/*.dat
+
+This assumes that you have 'regex-cli' installed. See 'regex-cli/README.md'
+from the root of the repository for more information.
+
+This brings the Fowler tests into a more "sensible" structured format in which
+other tests can be written such that they aren't write-only.
diff --git a/src/testdata/basic.dat b/testdata/fowler/dat/basic.dat
similarity index 87%
rename from src/testdata/basic.dat
rename to testdata/fowler/dat/basic.dat
index 632e1bb416..654a72b39b 100644
--- a/src/testdata/basic.dat
+++ b/testdata/fowler/dat/basic.dat
@@ -48,7 +48,7 @@ E	(aa|aaa)*|(a|aaaaa)		aa	(0,2)(0,2)
 E	(a.|.a.)*|(a|.a...)		aa	(0,2)(0,2)
 E	ab|a				xabc	(1,3)
 E	ab|a				xxabc	(2,4)
-Ei	(?-u)(Ab|cD)*			aBcD	(0,4)(2,4)
+Ei	(Ab|cD)*			aBcD	(0,4)(2,4)
 BE	[^-]			--a		(2,3)
 BE	[a-]*			--a		(0,3)
 BE	[a-m-]*			--amoma--	(0,4)
@@ -68,16 +68,22 @@ BE$	[^a]		\n	(0,1)
 BE$	\na		\na	(0,2)
 E	(a)(b)(c)	abc	(0,3)(0,1)(1,2)(2,3)
 BE	xxx		xxx	(0,3)
-E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 6,	(0,6)
-E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	2/7	(0,3)
-E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 1,Feb 6	(5,11)
-E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))	x	(0,1)(0,1)(0,1)
-E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))*	xx	(0,2)(1,2)(1,2)
+#E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 6,	(0,6)
+E	(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)	feb 6,	(0,6)	Rust
+#E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	2/7	(0,3)
+E	(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)	2/7	(0,3)	Rust
+#E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 1,Feb 6	(5,11)
+E	(?:^|[ (,;])(?:(?:(?:[Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))(?:[^0-9]|$)	feb 1,Feb 6	(5,11)	Rust
+#E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))	x	(0,1)(0,1)(0,1)
+E	(((?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:x))))))))))))))))))))))))))))))	x	(0,1)(0,1)(0,1)	Rust
+#E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))*	xx	(0,2)(1,2)(1,2)
+E	(((?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:(?:x))))))))))))))))))))))))))))))*	xx	(0,2)(1,2)(1,2)	Rust
 E	a?(ab|ba)*	ababababababababababababababababababababababababababababababababababababababababa	(0,81)(79,81)
 E	abaa|abbaa|abbbaa|abbbbaa	ababbabbbabbbabbbbabbbbaa	(18,25)
 E	abaa|abbaa|abbbaa|abbbbaa	ababbabbbabbbabbbbabaa	(18,22)
 E	aaac|aabc|abac|abbc|baac|babc|bbac|bbbc	baaabbbabac	(7,11)
-BE$	.*			\x01\x7f	(0,2)
+#BE$	.*			\x01\xff	(0,2)
+BE$	.*			\x01\x7f	(0,2)	Rust
 E	aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll		XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa	(53,57)
 L	aaaa\nbbbb\ncccc\nddddd\neeeeee\nfffffff\ngggg\nhhhh\niiiii\njjjjj\nkkkkk\nllll		XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa	NOMATCH
 E	a*a*a*a*a*b		aaaaaaaaab	(0,10)
@@ -124,24 +130,20 @@ E	((a))			abc		(0,1)(0,1)(0,1)
 E	(a)b(c)			abc		(0,3)(0,1)(2,3)
 E	a+b+c			aabbabc		(4,7)
 E	a*			aaa		(0,3)
-#E	(a*)*			-		(0,0)(0,0)
-E	(a*)*			-		(0,0)(?,?)	RE2/Go
+E	(a*)*			-		(0,0)(0,0)
 E	(a*)+			-		(0,0)(0,0)
-#E	(a*|b)*			-		(0,0)(0,0)
-E	(a*|b)*			-		(0,0)(?,?)	RE2/Go
+E	(a*|b)*			-		(0,0)(0,0)
 E	(a+|b)*			ab		(0,2)(1,2)
 E	(a+|b)+			ab		(0,2)(1,2)
 E	(a+|b)?			ab		(0,1)(0,1)
 BE	[^ab]*			cde		(0,3)
-#E	(^)*			-		(0,0)(0,0)
-E	(^)*			-		(0,0)(?,?)	RE2/Go
+E	(^)*			-		(0,0)(0,0)
 BE	a*			NULL		(0,0)
 E	([abc])*d		abbbcd		(0,6)(4,5)
 E	([abc])*bcd		abcd		(0,4)(0,1)
 E	a|b|c|d|e		e		(0,1)
 E	(a|b|c|d|e)f		ef		(0,2)(0,1)
-#E	((a*|b))*		-		(0,0)(0,0)(0,0)
-E	((a*|b))*		-		(0,0)(?,?)(?,?)	RE2/Go
+E	((a*|b))*		-		(0,0)(0,0)(0,0)
 BE	abcd*efg		abcdefg		(0,7)
 BE	ab*			xabyabbbz	(1,3)
 BE	ab*			xayabbbz	(1,2)
diff --git a/src/testdata/nullsubexpr.dat b/testdata/fowler/dat/nullsubexpr.dat
similarity index 81%
rename from src/testdata/nullsubexpr.dat
rename to testdata/fowler/dat/nullsubexpr.dat
index 2e18fbb917..a94430649e 100644
--- a/src/testdata/nullsubexpr.dat
+++ b/testdata/fowler/dat/nullsubexpr.dat
@@ -1,8 +1,7 @@
 NOTE	null subexpression matches : 2002-06-06
 
 E	(a*)*		a		(0,1)(0,1)
-#E	SAME		x		(0,0)(0,0)
-E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	(a*)+		a		(0,1)(0,1)
@@ -19,8 +18,7 @@ E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 
 E	([a]*)*		a		(0,1)(0,1)
-#E	SAME		x		(0,0)(0,0)
-E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	([a]*)+		a		(0,1)(0,1)
@@ -28,8 +26,7 @@ E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	([^b]*)*	a		(0,1)(0,1)
-#E	SAME		b		(0,0)(0,0)
-E	SAME		b		(0,0)(?,?)	RE2/Go
+E	SAME		b		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaab		(0,6)(0,6)
 E	([ab]*)*	a		(0,1)(0,1)
@@ -41,13 +38,12 @@ E	SAME		bbbbbb		(0,6)(0,6)
 E	SAME		aaaabcde	(0,5)(0,5)
 E	([^a]*)*	b		(0,1)(0,1)
 E	SAME		bbbbbb		(0,6)(0,6)
-#E	SAME		aaaaaa		(0,0)(0,0)
-E	SAME		aaaaaa		(0,0)(?,?)	RE2/Go
+E	SAME		aaaaaa		(0,0)(0,0)
 E	([^ab]*)*	ccccxx		(0,6)(0,6)
-#E	SAME		ababab		(0,0)(0,0)
-E	SAME		ababab		(0,0)(?,?)	RE2/Go
+E	SAME		ababab		(0,0)(0,0)
 
-E	((z)+|a)*	zabcde		(0,2)(1,2)
+#E	((z)+|a)*	zabcde		(0,2)(1,2)
+E	((z)+|a)*	zabcde		(0,2)(1,2)(0,1)	Rust
 
 #{E	a+?		aaaaaa		(0,1)	no *? +? mimimal match ops
 #E	(a)		aaa		(0,1)(0,1)
@@ -65,8 +61,7 @@ B	\(a*\)*\(x\)\(\1\)	axa	(0,3)(0,1)(1,2)(2,3)
 B	\(a*\)*\(x\)\(\1\)\(x\)	axax	(0,4)(0,1)(1,2)(2,3)(3,4)
 B	\(a*\)*\(x\)\(\1\)\(x\)	axxa	(0,3)(1,1)(1,2)(2,2)(2,3)
 
-#E	(a*)*(x)		x	(0,1)(0,0)(0,1)
-E	(a*)*(x)		x	(0,1)(?,?)(0,1)	RE2/Go
+E	(a*)*(x)		x	(0,1)(0,0)(0,1)
 E	(a*)*(x)		ax	(0,2)(0,1)(1,2)
 E	(a*)*(x)		axa	(0,2)(0,1)(1,2)
 
diff --git a/src/testdata/repetition.dat b/testdata/fowler/dat/repetition.dat
similarity index 89%
rename from src/testdata/repetition.dat
rename to testdata/fowler/dat/repetition.dat
index 3bb2121180..cf0d8382f8 100644
--- a/src/testdata/repetition.dat
+++ b/testdata/fowler/dat/repetition.dat
@@ -84,7 +84,7 @@ E	((..)|(.))*				aaaaaa		(0,6)(4,6)(4,6)(?,?)
 
 NOTE	additional repetition tests graciously provided by Chris Kuklewicz www.haskell.org 2009-02-02
 
-# These test a bug in OS X / FreeBSD / NetBSD, and libtree. 
+# These test a bug in OS X / FreeBSD / NetBSD, and libtree.
 # Linux/GLIBC gets the {8,} and {8,8} wrong.
 
 :HA#100:E	X(.?){0,}Y	X1234567Y	(0,9)(7,8)
@@ -123,18 +123,24 @@ NOTE	additional repetition tests graciously provided by Chris Kuklewicz www.hask
 # OS X / FreeBSD / NetBSD badly fail many of these, with impossible
 # results like (0,6)(4,5)(6,6).
 
-:HA#260:E	(a|ab|c|bcd){0,}(d*)	ababcd	(0,1)(0,1)(1,1)
-:HA#261:E	(a|ab|c|bcd){1,}(d*)	ababcd	(0,1)(0,1)(1,1)
+#:HA#260:E	(a|ab|c|bcd){0,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#260:E	(a|ab|c|bcd){0,}(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
+#:HA#261:E	(a|ab|c|bcd){1,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#261:E	(a|ab|c|bcd){1,}(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
 :HA#262:E	(a|ab|c|bcd){2,}(d*)	ababcd	(0,6)(3,6)(6,6)
 :HA#263:E	(a|ab|c|bcd){3,}(d*)	ababcd	(0,6)(3,6)(6,6)
 :HA#264:E	(a|ab|c|bcd){4,}(d*)	ababcd	NOMATCH
-:HA#265:E	(a|ab|c|bcd){0,10}(d*)	ababcd	(0,1)(0,1)(1,1)
-:HA#266:E	(a|ab|c|bcd){1,10}(d*)	ababcd	(0,1)(0,1)(1,1)
+#:HA#265:E	(a|ab|c|bcd){0,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#265:E	(a|ab|c|bcd){0,10}(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
+#:HA#266:E	(a|ab|c|bcd){1,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#266:E	(a|ab|c|bcd){1,10}(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
 :HA#267:E	(a|ab|c|bcd){2,10}(d*)	ababcd	(0,6)(3,6)(6,6)
 :HA#268:E	(a|ab|c|bcd){3,10}(d*)	ababcd	(0,6)(3,6)(6,6)
 :HA#269:E	(a|ab|c|bcd){4,10}(d*)	ababcd	NOMATCH
-:HA#270:E	(a|ab|c|bcd)*(d*)	ababcd	(0,1)(0,1)(1,1)
-:HA#271:E	(a|ab|c|bcd)+(d*)	ababcd	(0,1)(0,1)(1,1)
+#:HA#270:E	(a|ab|c|bcd)*(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#270:E	(a|ab|c|bcd)*(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
+#:HA#271:E	(a|ab|c|bcd)+(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#271:E	(a|ab|c|bcd)+(d*)	ababcd	(0,1)(0,1)(1,1)	Rust
 
 # The above worked on Linux/GLIBC but the following often fail.
 # They also trip up OS X / FreeBSD / NetBSD:
diff --git a/testdata/fowler/nullsubexpr.toml b/testdata/fowler/nullsubexpr.toml
new file mode 100644
index 0000000000..2f1f0183ed
--- /dev/null
+++ b/testdata/fowler/nullsubexpr.toml
@@ -0,0 +1,405 @@
+# !!! DO NOT EDIT !!!
+# Automatically generated by 'regex-cli generate fowler'.
+# Numbers in the test names correspond to the line number of the test from
+# the original dat file.
+
+[[test]]
+name = "nullsubexpr3"
+regex = '''(a*)*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr4"
+regex = '''(a*)*'''
+haystack = '''x'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr5"
+regex = '''(a*)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr6"
+regex = '''(a*)*'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr7"
+regex = '''(a*)+'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr8"
+regex = '''(a*)+'''
+haystack = '''x'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr9"
+regex = '''(a*)+'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr10"
+regex = '''(a*)+'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr11"
+regex = '''(a+)*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr12"
+regex = '''(a+)*'''
+haystack = '''x'''
+matches = [[[0, 0], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr13"
+regex = '''(a+)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr14"
+regex = '''(a+)*'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr15"
+regex = '''(a+)+'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr16"
+regex = '''(a+)+'''
+haystack = '''x'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "nullsubexpr17"
+regex = '''(a+)+'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr18"
+regex = '''(a+)+'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr20"
+regex = '''([a]*)*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr21"
+regex = '''([a]*)*'''
+haystack = '''x'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr22"
+regex = '''([a]*)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr23"
+regex = '''([a]*)*'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr24"
+regex = '''([a]*)+'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr25"
+regex = '''([a]*)+'''
+haystack = '''x'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr26"
+regex = '''([a]*)+'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr27"
+regex = '''([a]*)+'''
+haystack = '''aaaaaax'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr28"
+regex = '''([^b]*)*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr29"
+regex = '''([^b]*)*'''
+haystack = '''b'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr30"
+regex = '''([^b]*)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr31"
+regex = '''([^b]*)*'''
+haystack = '''aaaaaab'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr32"
+regex = '''([ab]*)*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr33"
+regex = '''([ab]*)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr34"
+regex = '''([ab]*)*'''
+haystack = '''ababab'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr35"
+regex = '''([ab]*)*'''
+haystack = '''bababa'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr36"
+regex = '''([ab]*)*'''
+haystack = '''b'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr37"
+regex = '''([ab]*)*'''
+haystack = '''bbbbbb'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr38"
+regex = '''([ab]*)*'''
+haystack = '''aaaabcde'''
+matches = [[[0, 5], [0, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr39"
+regex = '''([^a]*)*'''
+haystack = '''b'''
+matches = [[[0, 1], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr40"
+regex = '''([^a]*)*'''
+haystack = '''bbbbbb'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr41"
+regex = '''([^a]*)*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr42"
+regex = '''([^ab]*)*'''
+haystack = '''ccccxx'''
+matches = [[[0, 6], [0, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr43"
+regex = '''([^ab]*)*'''
+haystack = '''ababab'''
+matches = [[[0, 0], [0, 0]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "nullsubexpr46"
+regex = '''((z)+|a)*'''
+haystack = '''zabcde'''
+matches = [[[0, 2], [1, 2], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr64"
+regex = '''(a*)*(x)'''
+haystack = '''x'''
+matches = [[[0, 1], [0, 0], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr65"
+regex = '''(a*)*(x)'''
+haystack = '''ax'''
+matches = [[[0, 2], [0, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr66"
+regex = '''(a*)*(x)'''
+haystack = '''axa'''
+matches = [[[0, 2], [0, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr68"
+regex = '''(a*)+(x)'''
+haystack = '''x'''
+matches = [[[0, 1], [0, 0], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr69"
+regex = '''(a*)+(x)'''
+haystack = '''ax'''
+matches = [[[0, 2], [0, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr70"
+regex = '''(a*)+(x)'''
+haystack = '''axa'''
+matches = [[[0, 2], [0, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr72"
+regex = '''(a*){2}(x)'''
+haystack = '''x'''
+matches = [[[0, 1], [0, 0], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr73"
+regex = '''(a*){2}(x)'''
+haystack = '''ax'''
+matches = [[[0, 2], [1, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "nullsubexpr74"
+regex = '''(a*){2}(x)'''
+haystack = '''axa'''
+matches = [[[0, 2], [1, 1], [1, 2]]]
+match-limit = 1
+anchored = true
+
diff --git a/testdata/fowler/repetition.toml b/testdata/fowler/repetition.toml
new file mode 100644
index 0000000000..d6a7112022
--- /dev/null
+++ b/testdata/fowler/repetition.toml
@@ -0,0 +1,746 @@
+# !!! DO NOT EDIT !!!
+# Automatically generated by 'regex-cli generate fowler'.
+# Numbers in the test names correspond to the line number of the test from
+# the original dat file.
+
+[[test]]
+name = "repetition10"
+regex = '''((..)|(.))'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition11"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition12"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition14"
+regex = '''((..)|(.)){1}'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition15"
+regex = '''((..)|(.)){2}'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition16"
+regex = '''((..)|(.)){3}'''
+haystack = ''''''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition18"
+regex = '''((..)|(.))*'''
+haystack = ''''''
+matches = [[[0, 0], [], [], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition20"
+regex = '''((..)|(.))'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1], [], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition21"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''a'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition22"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''a'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition24"
+regex = '''((..)|(.)){1}'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1], [], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition25"
+regex = '''((..)|(.)){2}'''
+haystack = '''a'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition26"
+regex = '''((..)|(.)){3}'''
+haystack = '''a'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition28"
+regex = '''((..)|(.))*'''
+haystack = '''a'''
+matches = [[[0, 1], [0, 1], [], [0, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition30"
+regex = '''((..)|(.))'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition31"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 1], [], [0, 1], [1, 2], [], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition32"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''aa'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition34"
+regex = '''((..)|(.)){1}'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition35"
+regex = '''((..)|(.)){2}'''
+haystack = '''aa'''
+matches = [[[0, 2], [1, 2], [], [1, 2]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition36"
+regex = '''((..)|(.)){3}'''
+haystack = '''aa'''
+matches = []
+match-limit = 1
+
+[[test]]
+name = "repetition38"
+regex = '''((..)|(.))*'''
+haystack = '''aa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition40"
+regex = '''((..)|(.))'''
+haystack = '''aaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition41"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''aaa'''
+matches = [[[0, 3], [0, 2], [0, 2], [], [2, 3], [], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition42"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''aaa'''
+matches = [[[0, 3], [0, 1], [], [0, 1], [1, 2], [], [1, 2], [2, 3], [], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition44"
+regex = '''((..)|(.)){1}'''
+haystack = '''aaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition46"
+regex = '''((..)|(.)){2}'''
+haystack = '''aaa'''
+matches = [[[0, 3], [2, 3], [0, 2], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition47"
+regex = '''((..)|(.)){3}'''
+haystack = '''aaa'''
+matches = [[[0, 3], [2, 3], [], [2, 3]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition50"
+regex = '''((..)|(.))*'''
+haystack = '''aaa'''
+matches = [[[0, 3], [2, 3], [0, 2], [2, 3]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition52"
+regex = '''((..)|(.))'''
+haystack = '''aaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition53"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [0, 2], [0, 2], [], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition54"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [0, 2], [0, 2], [], [2, 3], [], [2, 3], [3, 4], [], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition56"
+regex = '''((..)|(.)){1}'''
+haystack = '''aaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition57"
+regex = '''((..)|(.)){2}'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition59"
+regex = '''((..)|(.)){3}'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [3, 4], [0, 2], [3, 4]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition61"
+regex = '''((..)|(.))*'''
+haystack = '''aaaa'''
+matches = [[[0, 4], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition63"
+regex = '''((..)|(.))'''
+haystack = '''aaaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition64"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''aaaaa'''
+matches = [[[0, 4], [0, 2], [0, 2], [], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition65"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''aaaaa'''
+matches = [[[0, 5], [0, 2], [0, 2], [], [2, 4], [2, 4], [], [4, 5], [], [4, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition67"
+regex = '''((..)|(.)){1}'''
+haystack = '''aaaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition68"
+regex = '''((..)|(.)){2}'''
+haystack = '''aaaaa'''
+matches = [[[0, 4], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition70"
+regex = '''((..)|(.)){3}'''
+haystack = '''aaaaa'''
+matches = [[[0, 5], [4, 5], [2, 4], [4, 5]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition73"
+regex = '''((..)|(.))*'''
+haystack = '''aaaaa'''
+matches = [[[0, 5], [4, 5], [2, 4], [4, 5]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition75"
+regex = '''((..)|(.))'''
+haystack = '''aaaaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition76"
+regex = '''((..)|(.))((..)|(.))'''
+haystack = '''aaaaaa'''
+matches = [[[0, 4], [0, 2], [0, 2], [], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition77"
+regex = '''((..)|(.))((..)|(.))((..)|(.))'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [0, 2], [0, 2], [], [2, 4], [2, 4], [], [4, 6], [4, 6], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition79"
+regex = '''((..)|(.)){1}'''
+haystack = '''aaaaaa'''
+matches = [[[0, 2], [0, 2], [0, 2], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition80"
+regex = '''((..)|(.)){2}'''
+haystack = '''aaaaaa'''
+matches = [[[0, 4], [2, 4], [2, 4], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition81"
+regex = '''((..)|(.)){3}'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [4, 6], [4, 6], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition83"
+regex = '''((..)|(.))*'''
+haystack = '''aaaaaa'''
+matches = [[[0, 6], [4, 6], [4, 6], []]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive90"
+regex = '''X(.?){0,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive91"
+regex = '''X(.?){1,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive92"
+regex = '''X(.?){2,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive93"
+regex = '''X(.?){3,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive94"
+regex = '''X(.?){4,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive95"
+regex = '''X(.?){5,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive96"
+regex = '''X(.?){6,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive97"
+regex = '''X(.?){7,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [7, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive98"
+regex = '''X(.?){8,}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive100"
+regex = '''X(.?){0,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive102"
+regex = '''X(.?){1,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive104"
+regex = '''X(.?){2,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive106"
+regex = '''X(.?){3,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive108"
+regex = '''X(.?){4,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive110"
+regex = '''X(.?){5,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive112"
+regex = '''X(.?){6,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive114"
+regex = '''X(.?){7,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive115"
+regex = '''X(.?){8,8}Y'''
+haystack = '''X1234567Y'''
+matches = [[[0, 9], [8, 8]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive127"
+regex = '''(a|ab|c|bcd){0,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive129"
+regex = '''(a|ab|c|bcd){1,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive130"
+regex = '''(a|ab|c|bcd){2,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [3, 6], [6, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive131"
+regex = '''(a|ab|c|bcd){3,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [3, 6], [6, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive132"
+regex = '''(a|ab|c|bcd){4,}(d*)'''
+haystack = '''ababcd'''
+matches = []
+match-limit = 1
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive134"
+regex = '''(a|ab|c|bcd){0,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive136"
+regex = '''(a|ab|c|bcd){1,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive137"
+regex = '''(a|ab|c|bcd){2,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [3, 6], [6, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive138"
+regex = '''(a|ab|c|bcd){3,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [3, 6], [6, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive139"
+regex = '''(a|ab|c|bcd){4,10}(d*)'''
+haystack = '''ababcd'''
+matches = []
+match-limit = 1
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive141"
+regex = '''(a|ab|c|bcd)*(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+# Test added by Rust regex project.
+[[test]]
+name = "repetition-expensive143"
+regex = '''(a|ab|c|bcd)+(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 1], [0, 1], [1, 1]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive149"
+regex = '''(ab|a|c|bcd){0,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive151"
+regex = '''(ab|a|c|bcd){1,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive153"
+regex = '''(ab|a|c|bcd){2,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive155"
+regex = '''(ab|a|c|bcd){3,}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive156"
+regex = '''(ab|a|c|bcd){4,}(d*)'''
+haystack = '''ababcd'''
+matches = []
+match-limit = 1
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive158"
+regex = '''(ab|a|c|bcd){0,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive160"
+regex = '''(ab|a|c|bcd){1,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive162"
+regex = '''(ab|a|c|bcd){2,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive164"
+regex = '''(ab|a|c|bcd){3,10}(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+[[test]]
+name = "repetition-expensive165"
+regex = '''(ab|a|c|bcd){4,10}(d*)'''
+haystack = '''ababcd'''
+matches = []
+match-limit = 1
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive167"
+regex = '''(ab|a|c|bcd)*(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
+# Test added by RE2/Go project.
+[[test]]
+name = "repetition-expensive169"
+regex = '''(ab|a|c|bcd)+(d*)'''
+haystack = '''ababcd'''
+matches = [[[0, 6], [4, 5], [5, 6]]]
+match-limit = 1
+anchored = true
+
diff --git a/testdata/iter.toml b/testdata/iter.toml
new file mode 100644
index 0000000000..329b9f031b
--- /dev/null
+++ b/testdata/iter.toml
@@ -0,0 +1,143 @@
+[[test]]
+name = "1"
+regex = "a"
+haystack = "aaa"
+matches = [[0, 1], [1, 2], [2, 3]]
+
+[[test]]
+name = "2"
+regex = "a"
+haystack = "aba"
+matches = [[0, 1], [2, 3]]
+
+[[test]]
+name = "empty1"
+regex = ''
+haystack = ''
+matches = [[0, 0]]
+
+[[test]]
+name = "empty2"
+regex = ''
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty3"
+regex = '(?:)'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty4"
+regex = '(?:)*'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty5"
+regex = '(?:)+'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty6"
+regex = '(?:)?'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty7"
+regex = '(?:)(?:)'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty8"
+regex = '(?:)+|z'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty9"
+regex = 'z|(?:)+'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty10"
+regex = '(?:)+|b'
+haystack = 'abc'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+
+[[test]]
+name = "empty11"
+regex = 'b|(?:)+'
+haystack = 'abc'
+matches = [[0, 0], [1, 2], [3, 3]]
+
+[[test]]
+name = "start1"
+regex = "^a"
+haystack = "a"
+matches = [[0, 1]]
+
+[[test]]
+name = "start2"
+regex = "^a"
+haystack = "aa"
+matches = [[0, 1]]
+
+[[test]]
+name = "anchored1"
+regex = "a"
+haystack = "a"
+matches = [[0, 1]]
+anchored = true
+
+# This test is pretty subtle. It demonstrates the crucial difference between
+# '^a' and 'a' compiled in 'anchored' mode. The former regex exclusively
+# matches at the start of a haystack and nowhere else. The latter regex has
+# no such restriction, but its automaton is constructed such that it lacks a
+# `.*?` prefix. So it can actually produce matches at multiple locations.
+# The anchored3 test drives this point home.
+[[test]]
+name = "anchored2"
+regex = "a"
+haystack = "aa"
+matches = [[0, 1], [1, 2]]
+anchored = true
+
+# Unlikely anchored2, this test stops matching anything after it sees `b`
+# since it lacks a `.*?` prefix. Since it is looking for 'a' but sees 'b', it
+# determines that there are no remaining matches.
+[[test]]
+name = "anchored3"
+regex = "a"
+haystack = "aaba"
+matches = [[0, 1], [1, 2]]
+anchored = true
+
+[[test]]
+name = "nonempty-followedby-empty"
+regex = 'abc|.*?'
+haystack = "abczzz"
+matches = [[0, 3], [4, 4], [5, 5], [6, 6]]
+
+[[test]]
+name = "nonempty-followedby-oneempty"
+regex = 'abc|.*?'
+haystack = "abcz"
+matches = [[0, 3], [4, 4]]
+
+[[test]]
+name = "nonempty-followedby-onemixed"
+regex = 'abc|.*?'
+haystack = "abczabc"
+matches = [[0, 3], [4, 7]]
+
+[[test]]
+name = "nonempty-followedby-twomixed"
+regex = 'abc|.*?'
+haystack = "abczzabc"
+matches = [[0, 3], [4, 4], [5, 8]]
diff --git a/testdata/leftmost-all.toml b/testdata/leftmost-all.toml
new file mode 100644
index 0000000000..e3fd950b6b
--- /dev/null
+++ b/testdata/leftmost-all.toml
@@ -0,0 +1,25 @@
+[[test]]
+name = "alt"
+regex = 'foo|foobar'
+haystack = "foobar"
+matches = [[0, 6]]
+match-kind = "all"
+search-kind = "leftmost"
+
+[[test]]
+name = "multi"
+regex = ['foo', 'foobar']
+haystack = "foobar"
+matches = [
+  { id = 1, span = [0, 6] },
+]
+match-kind = "all"
+search-kind = "leftmost"
+
+[[test]]
+name = "dotall"
+regex = '(?s:.)'
+haystack = "foobar"
+matches = [[5, 6]]
+match-kind = "all"
+search-kind = "leftmost"
diff --git a/testdata/line-terminator.toml b/testdata/line-terminator.toml
new file mode 100644
index 0000000000..4de72de31e
--- /dev/null
+++ b/testdata/line-terminator.toml
@@ -0,0 +1,97 @@
+# This tests that we can switch the line terminator to the NUL byte.
+[[test]]
+name = "nul"
+regex = '(?m)^[a-z]+$'
+haystack = '\x00abc\x00'
+matches = [[1, 4]]
+unescape = true
+line-terminator = '\x00'
+
+# This tests that '.' will not match the configured line terminator, but will
+# match \n.
+[[test]]
+name = "dot-changes-with-line-terminator"
+regex = '.'
+haystack = '\x00\n'
+matches = [[1, 2]]
+unescape = true
+line-terminator = '\x00'
+
+# This tests that when we switch the line terminator, \n is no longer
+# recognized as the terminator.
+[[test]]
+name = "not-line-feed"
+regex = '(?m)^[a-z]+$'
+haystack = '\nabc\n'
+matches = []
+unescape = true
+line-terminator = '\x00'
+
+# This tests that we can set the line terminator to a non-ASCII byte and have
+# it behave as expected.
+[[test]]
+name = "non-ascii"
+regex = '(?m)^[a-z]+$'
+haystack = '\xFFabc\xFF'
+matches = [[1, 4]]
+unescape = true
+line-terminator = '\xFF'
+utf8 = false
+
+# This tests that we can set the line terminator to a byte corresponding to a
+# word character, and things work as expected.
+[[test]]
+name = "word-byte"
+regex = '(?m)^[a-z]+$'
+haystack = 'ZabcZ'
+matches = [[1, 4]]
+unescape = true
+line-terminator = 'Z'
+
+# This tests that we can set the line terminator to a byte corresponding to a
+# non-word character, and things work as expected.
+[[test]]
+name = "non-word-byte"
+regex = '(?m)^[a-z]+$'
+haystack = '%abc%'
+matches = [[1, 4]]
+unescape = true
+line-terminator = '%'
+
+# This combines "set line terminator to a word byte" with a word boundary
+# assertion, which should result in no match even though ^/$ matches.
+[[test]]
+name = "word-boundary"
+regex = '(?m)^\b[a-z]+\b$'
+haystack = 'ZabcZ'
+matches = []
+unescape = true
+line-terminator = 'Z'
+
+# Like 'word-boundary', but does an anchored search at the point where ^
+# matches, but where \b should not.
+[[test]]
+name = "word-boundary-at"
+regex = '(?m)^\b[a-z]+\b$'
+haystack = 'ZabcZ'
+matches = []
+bounds = [1, 4]
+anchored = true
+unescape = true
+line-terminator = 'Z'
+
+# Like 'word-boundary-at', but flips the word boundary to a negation. This
+# in particular tests a tricky case in DFA engines, where they must consider
+# explicitly that a starting configuration from a custom line terminator may
+# also required setting the "is from word byte" flag on a state. Otherwise,
+# it's treated as "not from a word byte," which would result in \B not matching
+# here when it should.
+[[test]]
+name = "not-word-boundary-at"
+regex = '(?m)^\B[a-z]+\B$'
+haystack = 'ZabcZ'
+matches = [[1, 4]]
+bounds = [1, 4]
+anchored = true
+unescape = true
+line-terminator = 'Z'
diff --git a/testdata/misc.toml b/testdata/misc.toml
new file mode 100644
index 0000000000..c65531f5d9
--- /dev/null
+++ b/testdata/misc.toml
@@ -0,0 +1,99 @@
+[[test]]
+name = "ascii-literal"
+regex = "a"
+haystack = "a"
+matches = [[0, 1]]
+
+[[test]]
+name = "ascii-literal-not"
+regex = "a"
+haystack = "z"
+matches = []
+
+[[test]]
+name = "ascii-literal-anchored"
+regex = "a"
+haystack = "a"
+matches = [[0, 1]]
+anchored = true
+
+[[test]]
+name = "ascii-literal-anchored-not"
+regex = "a"
+haystack = "z"
+matches = []
+anchored = true
+
+[[test]]
+name = "anchor-start-end-line"
+regex = '(?m)^bar$'
+haystack = "foo\nbar\nbaz"
+matches = [[4, 7]]
+
+[[test]]
+name = "prefix-literal-match"
+regex = '^abc'
+haystack = "abc"
+matches = [[0, 3]]
+
+[[test]]
+name = "prefix-literal-match-ascii"
+regex = '^abc'
+haystack = "abc"
+matches = [[0, 3]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "prefix-literal-no-match"
+regex = '^abc'
+haystack = "zabc"
+matches = []
+
+[[test]]
+name = "one-literal-edge"
+regex = 'abc'
+haystack = "xxxxxab"
+matches = []
+
+[[test]]
+name = "terminates"
+regex = 'a$'
+haystack = "a"
+matches = [[0, 1]]
+
+[[test]]
+name = "suffix-100"
+regex = '.*abcd'
+haystack = "abcd"
+matches = [[0, 4]]
+
+[[test]]
+name = "suffix-200"
+regex = '.*(?:abcd)+'
+haystack = "abcd"
+matches = [[0, 4]]
+
+[[test]]
+name = "suffix-300"
+regex = '.*(?:abcd)+'
+haystack = "abcdabcd"
+matches = [[0, 8]]
+
+[[test]]
+name = "suffix-400"
+regex = '.*(?:abcd)+'
+haystack = "abcdxabcd"
+matches = [[0, 9]]
+
+[[test]]
+name = "suffix-500"
+regex = '.*x(?:abcd)+'
+haystack = "abcdxabcd"
+matches = [[0, 9]]
+
+[[test]]
+name = "suffix-600"
+regex = '[^abcd]*x(?:abcd)+'
+haystack = "abcdxabcd"
+matches = [[4, 9]]
diff --git a/testdata/multiline.toml b/testdata/multiline.toml
new file mode 100644
index 0000000000..3acc901d50
--- /dev/null
+++ b/testdata/multiline.toml
@@ -0,0 +1,845 @@
+[[test]]
+name = "basic1"
+regex = '(?m)^[a-z]+$'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 3], [4, 7], [8, 11]]
+
+[[test]]
+name = "basic1-crlf"
+regex = '(?Rm)^[a-z]+$'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 3], [4, 7], [8, 11]]
+
+[[test]]
+name = "basic1-crlf-cr"
+regex = '(?Rm)^[a-z]+$'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 3], [4, 7], [8, 11]]
+
+[[test]]
+name = "basic2"
+regex = '(?m)^$'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic2-crlf"
+regex = '(?Rm)^$'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic2-crlf-cr"
+regex = '(?Rm)^$'
+haystack = "abc\rdef\rxyz"
+matches = []
+
+[[test]]
+name = "basic3"
+regex = '(?m)^'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 0], [4, 4], [8, 8]]
+
+[[test]]
+name = "basic3-crlf"
+regex = '(?Rm)^'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 0], [4, 4], [8, 8]]
+
+[[test]]
+name = "basic3-crlf-cr"
+regex = '(?Rm)^'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 0], [4, 4], [8, 8]]
+
+[[test]]
+name = "basic4"
+regex = '(?m)$'
+haystack = "abc\ndef\nxyz"
+matches = [[3, 3], [7, 7], [11, 11]]
+
+[[test]]
+name = "basic4-crlf"
+regex = '(?Rm)$'
+haystack = "abc\ndef\nxyz"
+matches = [[3, 3], [7, 7], [11, 11]]
+
+[[test]]
+name = "basic4-crlf-cr"
+regex = '(?Rm)$'
+haystack = "abc\rdef\rxyz"
+matches = [[3, 3], [7, 7], [11, 11]]
+
+[[test]]
+name = "basic5"
+regex = '(?m)^[a-z]'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "basic5-crlf"
+regex = '(?Rm)^[a-z]'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "basic5-crlf-cr"
+regex = '(?Rm)^[a-z]'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "basic6"
+regex = '(?m)[a-z]^'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic6-crlf"
+regex = '(?Rm)[a-z]^'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic6-crlf-cr"
+regex = '(?Rm)[a-z]^'
+haystack = "abc\rdef\rxyz"
+matches = []
+
+[[test]]
+name = "basic7"
+regex = '(?m)[a-z]$'
+haystack = "abc\ndef\nxyz"
+matches = [[2, 3], [6, 7], [10, 11]]
+
+[[test]]
+name = "basic7-crlf"
+regex = '(?Rm)[a-z]$'
+haystack = "abc\ndef\nxyz"
+matches = [[2, 3], [6, 7], [10, 11]]
+
+[[test]]
+name = "basic7-crlf-cr"
+regex = '(?Rm)[a-z]$'
+haystack = "abc\rdef\rxyz"
+matches = [[2, 3], [6, 7], [10, 11]]
+
+[[test]]
+name = "basic8"
+regex = '(?m)$[a-z]'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic8-crlf"
+regex = '(?Rm)$[a-z]'
+haystack = "abc\ndef\nxyz"
+matches = []
+
+[[test]]
+name = "basic8-crlf-cr"
+regex = '(?Rm)$[a-z]'
+haystack = "abc\rdef\rxyz"
+matches = []
+
+[[test]]
+name = "basic9"
+regex = '(?m)^$'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "basic9-crlf"
+regex = '(?Rm)^$'
+haystack = ""
+matches = [[0, 0]]
+
+[[test]]
+name = "repeat1"
+regex = '(?m)(?:^$)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat1-crlf"
+regex = '(?Rm)(?:^$)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat1-crlf-cr"
+regex = '(?Rm)(?:^$)*'
+haystack = "a\rb\rc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat1-no-multi"
+regex = '(?:^$)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat1-no-multi-crlf"
+regex = '(?R)(?:^$)*'
+haystack = "a\nb\nc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat1-no-multi-crlf-cr"
+regex = '(?R)(?:^$)*'
+haystack = "a\rb\rc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+[[test]]
+name = "repeat2"
+regex = '(?m)(?:^|a)+'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat2-crlf"
+regex = '(?Rm)(?:^|a)+'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat2-crlf-cr"
+regex = '(?Rm)(?:^|a)+'
+haystack = "a\raaa\r"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat2-no-multi"
+regex = '(?:^|a)+'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat2-no-multi-crlf"
+regex = '(?R)(?:^|a)+'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat2-no-multi-crlf-cr"
+regex = '(?R)(?:^|a)+'
+haystack = "a\raaa\r"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat3"
+regex = '(?m)(?:^|a)*'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat3-crlf"
+regex = '(?Rm)(?:^|a)*'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat3-crlf-cr"
+regex = '(?Rm)(?:^|a)*'
+haystack = "a\raaa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat3-no-multi"
+regex = '(?:^|a)*'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat3-no-multi-crlf"
+regex = '(?R)(?:^|a)*'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat3-no-multi-crlf-cr"
+regex = '(?R)(?:^|a)*'
+haystack = "a\raaa\r"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat4"
+regex = '(?m)(?:^|a+)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat4-crlf"
+regex = '(?Rm)(?:^|a+)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat4-crlf-cr"
+regex = '(?Rm)(?:^|a+)'
+haystack = "a\raaa\r"
+matches = [[0, 0], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat4-no-multi"
+regex = '(?:^|a+)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat4-no-multi-crlf"
+regex = '(?R)(?:^|a+)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat4-no-multi-crlf-cr"
+regex = '(?R)(?:^|a+)'
+haystack = "a\raaa\r"
+matches = [[0, 0], [2, 5]]
+
+[[test]]
+name = "repeat5"
+regex = '(?m)(?:^|a*)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat5-crlf"
+regex = '(?Rm)(?:^|a*)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat5-crlf-cr"
+regex = '(?Rm)(?:^|a*)'
+haystack = "a\raaa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 5], [6, 6]]
+
+[[test]]
+name = "repeat5-no-multi"
+regex = '(?:^|a*)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat5-no-multi-crlf"
+regex = '(?R)(?:^|a*)'
+haystack = "a\naaa\n"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat5-no-multi-crlf-cr"
+regex = '(?R)(?:^|a*)'
+haystack = "a\raaa\r"
+matches = [[0, 0], [1, 1], [2, 5], [6, 6]]
+
+[[test]]
+name = "repeat6"
+regex = '(?m)(?:^[a-z])+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "repeat6-crlf"
+regex = '(?Rm)(?:^[a-z])+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "repeat6-crlf-cr"
+regex = '(?Rm)(?:^[a-z])+'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 1], [4, 5], [8, 9]]
+
+[[test]]
+name = "repeat6-no-multi"
+regex = '(?:^[a-z])+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1]]
+
+[[test]]
+name = "repeat6-no-multi-crlf"
+regex = '(?R)(?:^[a-z])+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 1]]
+
+[[test]]
+name = "repeat6-no-multi-crlf-cr"
+regex = '(?R)(?:^[a-z])+'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 1]]
+
+[[test]]
+name = "repeat7"
+regex = '(?m)(?:^[a-z]{3}\n?)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat7-crlf"
+regex = '(?Rm)(?:^[a-z]{3}\n?)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat7-crlf-cr"
+regex = '(?Rm)(?:^[a-z]{3}\r?)+'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat7-no-multi"
+regex = '(?:^[a-z]{3}\n?)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 4]]
+
+[[test]]
+name = "repeat7-no-multi-crlf"
+regex = '(?R)(?:^[a-z]{3}\n?)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 4]]
+
+[[test]]
+name = "repeat7-no-multi-crlf-cr"
+regex = '(?R)(?:^[a-z]{3}\r?)+'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 4]]
+
+[[test]]
+name = "repeat8"
+regex = '(?m)(?:^[a-z]{3}\n?)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat8-crlf"
+regex = '(?Rm)(?:^[a-z]{3}\n?)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat8-crlf-cr"
+regex = '(?Rm)(?:^[a-z]{3}\r?)*'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat8-no-multi"
+regex = '(?:^[a-z]{3}\n?)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11]]
+
+[[test]]
+name = "repeat8-no-multi-crlf"
+regex = '(?R)(?:^[a-z]{3}\n?)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11]]
+
+[[test]]
+name = "repeat8-no-multi-crlf-cr"
+regex = '(?R)(?:^[a-z]{3}\r?)*'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11]]
+
+[[test]]
+name = "repeat9"
+regex = '(?m)(?:\n?[a-z]{3}$)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat9-crlf"
+regex = '(?Rm)(?:\n?[a-z]{3}$)+'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat9-crlf-cr"
+regex = '(?Rm)(?:\r?[a-z]{3}$)+'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat9-no-multi"
+regex = '(?:\n?[a-z]{3}$)+'
+haystack = "abc\ndef\nxyz"
+matches = [[7, 11]]
+
+[[test]]
+name = "repeat9-no-multi-crlf"
+regex = '(?R)(?:\n?[a-z]{3}$)+'
+haystack = "abc\ndef\nxyz"
+matches = [[7, 11]]
+
+[[test]]
+name = "repeat9-no-multi-crlf-cr"
+regex = '(?R)(?:\r?[a-z]{3}$)+'
+haystack = "abc\rdef\rxyz"
+matches = [[7, 11]]
+
+[[test]]
+name = "repeat10"
+regex = '(?m)(?:\n?[a-z]{3}$)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat10-crlf"
+regex = '(?Rm)(?:\n?[a-z]{3}$)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat10-crlf-cr"
+regex = '(?Rm)(?:\r?[a-z]{3}$)*'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 11]]
+
+[[test]]
+name = "repeat10-no-multi"
+regex = '(?:\n?[a-z]{3}$)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 11]]
+
+[[test]]
+name = "repeat10-no-multi-crlf"
+regex = '(?R)(?:\n?[a-z]{3}$)*'
+haystack = "abc\ndef\nxyz"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 11]]
+
+[[test]]
+name = "repeat10-no-multi-crlf-cr"
+regex = '(?R)(?:\r?[a-z]{3}$)*'
+haystack = "abc\rdef\rxyz"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 11]]
+
+[[test]]
+name = "repeat11"
+regex = '(?m)^*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat11-crlf"
+regex = '(?Rm)^*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat11-crlf-cr"
+regex = '(?Rm)^*'
+haystack = "\raa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat11-no-multi"
+regex = '^*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat11-no-multi-crlf"
+regex = '(?R)^*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat11-no-multi-crlf-cr"
+regex = '(?R)^*'
+haystack = "\raa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat12"
+regex = '(?m)^+'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [4, 4]]
+
+[[test]]
+name = "repeat12-crlf"
+regex = '(?Rm)^+'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [4, 4]]
+
+[[test]]
+name = "repeat12-crlf-cr"
+regex = '(?Rm)^+'
+haystack = "\raa\r"
+matches = [[0, 0], [1, 1], [4, 4]]
+
+[[test]]
+name = "repeat12-no-multi"
+regex = '^+'
+haystack = "\naa\n"
+matches = [[0, 0]]
+
+[[test]]
+name = "repeat12-no-multi-crlf"
+regex = '(?R)^+'
+haystack = "\naa\n"
+matches = [[0, 0]]
+
+[[test]]
+name = "repeat12-no-multi-crlf-cr"
+regex = '(?R)^+'
+haystack = "\raa\r"
+matches = [[0, 0]]
+
+[[test]]
+name = "repeat13"
+regex = '(?m)$*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat13-crlf"
+regex = '(?Rm)$*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat13-crlf-cr"
+regex = '(?Rm)$*'
+haystack = "\raa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat13-no-multi"
+regex = '$*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat13-no-multi-crlf"
+regex = '(?R)$*'
+haystack = "\naa\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat13-no-multi-crlf-cr"
+regex = '(?R)$*'
+haystack = "\raa\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat14"
+regex = '(?m)$+'
+haystack = "\naa\n"
+matches = [[0, 0], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat14-crlf"
+regex = '(?Rm)$+'
+haystack = "\naa\n"
+matches = [[0, 0], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat14-crlf-cr"
+regex = '(?Rm)$+'
+haystack = "\raa\r"
+matches = [[0, 0], [3, 3], [4, 4]]
+
+[[test]]
+name = "repeat14-no-multi"
+regex = '$+'
+haystack = "\naa\n"
+matches = [[4, 4]]
+
+[[test]]
+name = "repeat14-no-multi-crlf"
+regex = '(?R)$+'
+haystack = "\naa\n"
+matches = [[4, 4]]
+
+[[test]]
+name = "repeat14-no-multi-crlf-cr"
+regex = '(?R)$+'
+haystack = "\raa\r"
+matches = [[4, 4]]
+
+[[test]]
+name = "repeat15"
+regex = '(?m)(?:$\n)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat15-crlf"
+regex = '(?Rm)(?:$\n)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat15-crlf-cr"
+regex = '(?Rm)(?:$\r)+'
+haystack = "\r\raaa\r\r"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat15-no-multi"
+regex = '(?:$\n)+'
+haystack = "\n\naaa\n\n"
+matches = []
+
+[[test]]
+name = "repeat15-no-multi-crlf"
+regex = '(?R)(?:$\n)+'
+haystack = "\n\naaa\n\n"
+matches = []
+
+[[test]]
+name = "repeat15-no-multi-crlf-cr"
+regex = '(?R)(?:$\r)+'
+haystack = "\r\raaa\r\r"
+matches = []
+
+[[test]]
+name = "repeat16"
+regex = '(?m)(?:$\n)*'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [3, 3], [4, 4], [5, 7]]
+
+[[test]]
+name = "repeat16-crlf"
+regex = '(?Rm)(?:$\n)*'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [3, 3], [4, 4], [5, 7]]
+
+[[test]]
+name = "repeat16-crlf-cr"
+regex = '(?Rm)(?:$\r)*'
+haystack = "\r\raaa\r\r"
+matches = [[0, 2], [3, 3], [4, 4], [5, 7]]
+
+[[test]]
+name = "repeat16-no-multi"
+regex = '(?:$\n)*'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat16-no-multi-crlf"
+regex = '(?R)(?:$\n)*'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat16-no-multi-crlf-cr"
+regex = '(?R)(?:$\r)*'
+haystack = "\r\raaa\r\r"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat17"
+regex = '(?m)(?:$\n^)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat17-crlf"
+regex = '(?Rm)(?:$\n^)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat17-crlf-cr"
+regex = '(?Rm)(?:$\r^)+'
+haystack = "\r\raaa\r\r"
+matches = [[0, 2], [5, 7]]
+
+[[test]]
+name = "repeat17-no-multi"
+regex = '(?:$\n^)+'
+haystack = "\n\naaa\n\n"
+matches = []
+
+[[test]]
+name = "repeat17-no-multi-crlf"
+regex = '(?R)(?:$\n^)+'
+haystack = "\n\naaa\n\n"
+matches = []
+
+[[test]]
+name = "repeat17-no-multi-crlf-cr"
+regex = '(?R)(?:$\r^)+'
+haystack = "\r\raaa\r\r"
+matches = []
+
+[[test]]
+name = "repeat18"
+regex = '(?m)(?:^|$)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat18-crlf"
+regex = '(?Rm)(?:^|$)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [1, 1], [2, 2], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat18-crlf-cr"
+regex = '(?Rm)(?:^|$)+'
+haystack = "\r\raaa\r\r"
+matches = [[0, 0], [1, 1], [2, 2], [5, 5], [6, 6], [7, 7]]
+
+[[test]]
+name = "repeat18-no-multi"
+regex = '(?:^|$)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [7, 7]]
+
+[[test]]
+name = "repeat18-no-multi-crlf"
+regex = '(?R)(?:^|$)+'
+haystack = "\n\naaa\n\n"
+matches = [[0, 0], [7, 7]]
+
+[[test]]
+name = "repeat18-no-multi-crlf-cr"
+regex = '(?R)(?:^|$)+'
+haystack = "\r\raaa\r\r"
+matches = [[0, 0], [7, 7]]
+
+[[test]]
+name = "match-line-100"
+regex = '(?m)^.+$'
+haystack = "aa\naaaaaaaaaaaaaaaaaaa\n"
+matches = [[0, 2], [3, 22]]
+
+[[test]]
+name = "match-line-100-crlf"
+regex = '(?Rm)^.+$'
+haystack = "aa\naaaaaaaaaaaaaaaaaaa\n"
+matches = [[0, 2], [3, 22]]
+
+[[test]]
+name = "match-line-100-crlf-cr"
+regex = '(?Rm)^.+$'
+haystack = "aa\raaaaaaaaaaaaaaaaaaa\r"
+matches = [[0, 2], [3, 22]]
+
+[[test]]
+name = "match-line-200"
+regex = '(?m)^.+$'
+haystack = "aa\naaaaaaaaaaaaaaaaaaa\n"
+matches = [[0, 2], [3, 22]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "match-line-200-crlf"
+regex = '(?Rm)^.+$'
+haystack = "aa\naaaaaaaaaaaaaaaaaaa\n"
+matches = [[0, 2], [3, 22]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "match-line-200-crlf-cr"
+regex = '(?Rm)^.+$'
+haystack = "aa\raaaaaaaaaaaaaaaaaaa\r"
+matches = [[0, 2], [3, 22]]
+unicode = false
+utf8 = false
diff --git a/testdata/no-unicode.toml b/testdata/no-unicode.toml
new file mode 100644
index 0000000000..0ddac4c96d
--- /dev/null
+++ b/testdata/no-unicode.toml
@@ -0,0 +1,222 @@
+[[test]]
+name = "invalid-utf8-literal1"
+regex = '\xFF'
+haystack = '\xFF'
+matches = [[0, 1]]
+unicode = false
+utf8 = false
+unescape = true
+
+
+[[test]]
+name = "mixed"
+regex = '(?:.+)(?-u)(?:.+)'
+haystack = '\xCE\x93\xCE\x94\xFF'
+matches = [[0, 5]]
+utf8 = false
+unescape = true
+
+
+[[test]]
+name = "case1"
+regex = "a"
+haystack = "A"
+matches = [[0, 1]]
+case-insensitive = true
+unicode = false
+
+[[test]]
+name = "case2"
+regex = "[a-z]+"
+haystack = "AaAaA"
+matches = [[0, 5]]
+case-insensitive = true
+unicode = false
+
+[[test]]
+name = "case3"
+regex = "[a-z]+"
+haystack = "aA\u212AaA"
+matches = [[0, 7]]
+case-insensitive = true
+
+[[test]]
+name = "case4"
+regex = "[a-z]+"
+haystack = "aA\u212AaA"
+matches = [[0, 2], [5, 7]]
+case-insensitive = true
+unicode = false
+
+
+[[test]]
+name = "negate1"
+regex = "[^a]"
+haystack = "δ"
+matches = [[0, 2]]
+
+[[test]]
+name = "negate2"
+regex = "[^a]"
+haystack = "δ"
+matches = [[0, 1], [1, 2]]
+unicode = false
+utf8 = false
+
+
+[[test]]
+name = "dotstar-prefix1"
+regex = "a"
+haystack = '\xFFa'
+matches = [[1, 2]]
+unicode = false
+utf8 = false
+unescape = true
+
+[[test]]
+name = "dotstar-prefix2"
+regex = "a"
+haystack = '\xFFa'
+matches = [[1, 2]]
+utf8 = false
+unescape = true
+
+
+[[test]]
+name = "null-bytes1"
+regex = '[^\x00]+\x00'
+haystack = 'foo\x00'
+matches = [[0, 4]]
+unicode = false
+utf8 = false
+unescape = true
+
+
+[[test]]
+name = "word-ascii"
+regex = '\w+'
+haystack = "aδ"
+matches = [[0, 1]]
+unicode = false
+
+[[test]]
+name = "word-unicode"
+regex = '\w+'
+haystack = "aδ"
+matches = [[0, 3]]
+
+[[test]]
+name = "decimal-ascii"
+regex = '\d+'
+haystack = "1२३9"
+matches = [[0, 1], [7, 8]]
+unicode = false
+
+[[test]]
+name = "decimal-unicode"
+regex = '\d+'
+haystack = "1२३9"
+matches = [[0, 8]]
+
+[[test]]
+name = "space-ascii"
+regex = '\s+'
+haystack = " \u1680"
+matches = [[0, 1]]
+unicode = false
+
+[[test]]
+name = "space-unicode"
+regex = '\s+'
+haystack = " \u1680"
+matches = [[0, 4]]
+
+
+[[test]]
+# See: https://github.com/rust-lang/regex/issues/484
+name = "iter1-bytes"
+regex = ''
+haystack = "☃"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+utf8 = false
+
+[[test]]
+# See: https://github.com/rust-lang/regex/issues/484
+name = "iter1-utf8"
+regex = ''
+haystack = "☃"
+matches = [[0, 0], [3, 3]]
+
+[[test]]
+# See: https://github.com/rust-lang/regex/issues/484
+# Note that iter2-utf8 doesn't make sense here, since the input isn't UTF-8.
+name = "iter2-bytes"
+regex = ''
+haystack = 'b\xFFr'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+unescape = true
+utf8 = false
+
+
+# These test that unanchored prefixes can munch through invalid UTF-8 even when
+# utf8 is enabled.
+#
+# This test actually reflects an interesting simplification in how the Thompson
+# NFA is constructed. It used to be that the NFA could be built with an
+# unanchored prefix that either matched any byte or _only_ matched valid UTF-8.
+# But the latter turns out to be pretty precarious when it comes to prefilters,
+# because if you search a haystack that contains invalid UTF-8 but have an
+# unanchored prefix that requires UTF-8, then prefilters are no longer a valid
+# optimization because you actually have to check that everything is valid
+# UTF-8.
+#
+# Originally, I had thought that we needed a valid UTF-8 unanchored prefix in
+# order to guarantee that we only match at valid UTF-8 boundaries. But this
+# isn't actually true! There are really only two things to consider here:
+#
+# 1) Will a regex match split an encoded codepoint? No. Because by construction,
+# we ensure that a MATCH state can only be reached by following valid UTF-8 (assuming
+# all of the UTF-8 modes are enabled).
+#
+# 2) Will a regex match arbitrary bytes that aren't valid UTF-8? Again, no,
+# assuming all of the UTF-8 modes are enabled.
+[[test]]
+name = "unanchored-invalid-utf8-match-100"
+regex = '[a-z]'
+haystack = '\xFFa\xFF'
+matches = [[1, 2]]
+unescape = true
+utf8 = false
+
+# This test shows that we can still prevent a match from occurring by requiring
+# that valid UTF-8 match by inserting our own unanchored prefix. Thus, if the
+# behavior of not munching through invalid UTF-8 anywhere is needed, then it
+# can be achieved thusly.
+[[test]]
+name = "unanchored-invalid-utf8-nomatch"
+regex = '^(?s:.)*?[a-z]'
+haystack = '\xFFa\xFF'
+matches = []
+unescape = true
+utf8 = false
+
+# This is a tricky test that makes sure we don't accidentally do a kind of
+# unanchored search when we've requested that a regex engine not report
+# empty matches that split a codepoint. This test caught a regression during
+# development where the code for skipping over bad empty matches would do so
+# even if the search should have been anchored. This is ultimately what led to
+# making 'anchored' an 'Input' option, so that it was always clear what kind
+# of search was being performed. (Before that, whether a search was anchored
+# or not was a config knob on the regex engine.) This did wind up making DFAs
+# a little more complex to configure (with their 'StartKind' knob), but it
+# generally smoothed out everything else.
+#
+# Great example of a test whose failure motivated a sweeping API refactoring.
+[[test]]
+name = "anchored-iter-empty-utf8"
+regex = ''
+haystack = 'a☃z'
+matches = [[0, 0], [1, 1]]
+unescape = false
+utf8 = true
+anchored = true
diff --git a/testdata/overlapping.toml b/testdata/overlapping.toml
new file mode 100644
index 0000000000..7bcd45a2f7
--- /dev/null
+++ b/testdata/overlapping.toml
@@ -0,0 +1,280 @@
+# NOTE: We define a number of tests where the *match* kind is 'leftmost-first'
+# but the *search* kind is 'overlapping'. This is a somewhat nonsensical
+# combination and can produce odd results. Nevertheless, those results should
+# be consistent so we test them here. (At the time of writing this note, I
+# hadn't yet decided whether to make 'leftmost-first' with 'overlapping' result
+# in unspecified behavior.)
+
+# This demonstrates how a full overlapping search is obvious quadratic. This
+# regex reports a match for every substring in the haystack.
+[[test]]
+name = "ungreedy-dotstar-matches-everything-100"
+regex = [".*?"]
+haystack = "zzz"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [0, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [1, 2] },
+  { id = 0, span = [0, 2] },
+  { id = 0, span = [3, 3] },
+  { id = 0, span = [2, 3] },
+  { id = 0, span = [1, 3] },
+  { id = 0, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "greedy-dotstar-matches-everything-100"
+regex = [".*"]
+haystack = "zzz"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [0, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [1, 2] },
+  { id = 0, span = [0, 2] },
+  { id = 0, span = [3, 3] },
+  { id = 0, span = [2, 3] },
+  { id = 0, span = [1, 3] },
+  { id = 0, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-leftmost-first-100"
+regex = 'a+'
+haystack = "aaa"
+matches = [[0, 1], [1, 2], [0, 2], [2, 3], [1, 3], [0, 3]]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-leftmost-first-110"
+regex = '☃+'
+haystack = "☃☃☃"
+matches = [[0, 3], [3, 6], [0, 6], [6, 9], [3, 9], [0, 9]]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-all-100"
+regex = 'a+'
+haystack = "aaa"
+matches = [[0, 1], [1, 2], [0, 2], [2, 3], [1, 3], [0, 3]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-all-110"
+regex = '☃+'
+haystack = "☃☃☃"
+matches = [[0, 3], [3, 6], [0, 6], [6, 9], [3, 9], [0, 9]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-leftmost-first-200"
+regex = '(abc)+'
+haystack = "zzabcabczzabc"
+matches = [
+  [[2, 5], [2, 5]],
+  [[5, 8], [5, 8]],
+  [[2, 8], [5, 8]],
+]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-plus-all-200"
+regex = '(abc)+'
+haystack = "zzabcabczzabc"
+matches = [
+  [[2, 5], [2, 5]],
+  [[5, 8], [5, 8]],
+  [[2, 8], [5, 8]],
+  [[10, 13], [10, 13]],
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-star-leftmost-first-100"
+regex = 'a*'
+haystack = "aaa"
+matches = [
+  [0, 0],
+  [1, 1],
+  [0, 1],
+  [2, 2],
+  [1, 2],
+  [0, 2],
+  [3, 3],
+  [2, 3],
+  [1, 3],
+  [0, 3],
+]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-star-all-100"
+regex = 'a*'
+haystack = "aaa"
+matches = [
+  [0, 0],
+  [1, 1],
+  [0, 1],
+  [2, 2],
+  [1, 2],
+  [0, 2],
+  [3, 3],
+  [2, 3],
+  [1, 3],
+  [0, 3],
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-star-leftmost-first-200"
+regex = '(abc)*'
+haystack = "zzabcabczzabc"
+matches = [
+  [[0, 0], []],
+]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "repetition-star-all-200"
+regex = '(abc)*'
+haystack = "zzabcabczzabc"
+matches = [
+  [[0, 0], []],
+  [[1, 1], []],
+  [[2, 2], []],
+  [[3, 3], []],
+  [[4, 4], []],
+  [[5, 5], []],
+  [[2, 5], [2, 5]],
+  [[6, 6], []],
+  [[7, 7], []],
+  [[8, 8], []],
+  [[5, 8], [5, 8]],
+  [[2, 8], [5, 8]],
+  [[9, 9], []],
+  [[10, 10], []],
+  [[11, 11], []],
+  [[12, 12], []],
+  [[13, 13], []],
+  [[10, 13], [10, 13]],
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "start-end-rep-leftmost-first"
+regex = '(^$)*'
+haystack = "abc"
+matches = [
+  [[0, 0], []],
+]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "start-end-rep-all"
+regex = '(^$)*'
+haystack = "abc"
+matches = [
+  [[0, 0], []],
+  [[1, 1], []],
+  [[2, 2], []],
+  [[3, 3], []],
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "alt-leftmost-first-100"
+regex = 'abc|a'
+haystack = "zzabcazzaabc"
+matches = [[2, 3], [2, 5]]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
+
+[[test]]
+name = "alt-all-100"
+regex = 'abc|a'
+haystack = "zzabcazzaabc"
+matches = [[2, 3], [2, 5], [5, 6], [8, 9], [9, 10], [9, 12]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty-000"
+regex = ""
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty-alt-000"
+regex = "|b"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [1, 2], [3, 3]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty-alt-010"
+regex = "b|"
+haystack = "abc"
+matches = [[0, 0], [1, 1], [2, 2], [1, 2], [3, 3]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+# See: https://github.com/rust-lang/regex/issues/484
+name = "iter1-bytes"
+regex = ''
+haystack = "☃"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+# See: https://github.com/rust-lang/regex/issues/484
+name = "iter1-utf8"
+regex = ''
+haystack = "☃"
+matches = [[0, 0], [3, 3]]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "iter1-incomplete-utf8"
+regex = ''
+haystack = '\xE2\x98'  # incomplete snowman
+matches = [[0, 0], [1, 1], [2, 2]]
+match-kind = "all"
+search-kind = "overlapping"
+unescape = true
+utf8 = false
+
+[[test]]
+name = "scratch"
+regex = ['sam', 'samwise']
+haystack = "samwise"
+matches = [
+  { id = 0, span = [0, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "overlapping"
diff --git a/testdata/regex-lite.toml b/testdata/regex-lite.toml
new file mode 100644
index 0000000000..1769d803d4
--- /dev/null
+++ b/testdata/regex-lite.toml
@@ -0,0 +1,98 @@
+# These tests are specifically written to test the regex-lite crate. While it
+# largely has the same semantics as the regex crate, there are some differences
+# around Unicode support and UTF-8.
+#
+# To be clear, regex-lite supports far fewer patterns because of its lack of
+# Unicode support, nested character classes and character class set operations.
+# What we're talking about here are the patterns that both crates support but
+# where the semantics might differ.
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-decimal"
+regex = '\d'
+haystack = '᠕'
+matches = []
+unicode = true
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-space"
+regex = '\s'
+haystack = "\u2000"
+matches = []
+unicode = true
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-word"
+regex = '\w'
+haystack = 'δ'
+matches = []
+unicode = true
+
+# regex-lite uses the ASCII definition of word for word boundary assertions.
+[[test]]
+name = "word-boundary"
+regex = '\b'
+haystack = 'δ'
+matches = []
+unicode = true
+
+# regex-lite uses the ASCII definition of word for negated word boundary
+# assertions. But note that it should still not split codepoints!
+[[test]]
+name = "word-boundary-negated"
+regex = '\B'
+haystack = 'δ'
+matches = [[0, 0], [2, 2]]
+unicode = true
+
+# While we're here, the empty regex---which matches at every
+# position---shouldn't split a codepoint either.
+[[test]]
+name = "empty-no-split-codepoint"
+regex = ''
+haystack = '💩'
+matches = [[0, 0], [4, 4]]
+unicode = true
+
+# A dot always matches a full codepoint.
+[[test]]
+name = "dot-always-matches-codepoint"
+regex = '.'
+haystack = '💩'
+matches = [[0, 4]]
+unicode = false
+
+# A negated character class also always matches a full codepoint.
+[[test]]
+name = "negated-class-always-matches-codepoint"
+regex = '[^a]'
+haystack = '💩'
+matches = [[0, 4]]
+unicode = false
+
+# regex-lite only supports ASCII-aware case insensitive matching.
+[[test]]
+name = "case-insensitive-is-ascii-only"
+regex = 's'
+haystack = 'ſ'
+matches = []
+unicode = true
+case-insensitive = true
+
+# Negated word boundaries shouldn't split a codepoint, but they will match
+# between invalid UTF-8.
+#
+# This test is only valid for a 'bytes' API, but that doesn't (yet) exist in
+# regex-lite. This can't happen in the main API because &str can't contain
+# invalid UTF-8.
+# [[test]]
+# name = "word-boundary-invalid-utf8"
+# regex = '\B'
+# haystack = '\xFF\xFF\xFF\xFF'
+# unescape = true
+# matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+# unicode = true
+# utf8 = false
diff --git a/testdata/regression.toml b/testdata/regression.toml
new file mode 100644
index 0000000000..bb5e4fd46f
--- /dev/null
+++ b/testdata/regression.toml
@@ -0,0 +1,741 @@
+# See: https://github.com/rust-lang/regex/issues/48
+[[test]]
+name = "invalid-regex-no-crash-100"
+regex = '(*)'
+haystack = ""
+matches = []
+compiles = false
+
+# See: https://github.com/rust-lang/regex/issues/48
+[[test]]
+name = "invalid-regex-no-crash-200"
+regex = '(?:?)'
+haystack = ""
+matches = []
+compiles = false
+
+# See: https://github.com/rust-lang/regex/issues/48
+[[test]]
+name = "invalid-regex-no-crash-300"
+regex = '(?)'
+haystack = ""
+matches = []
+compiles = false
+
+# See: https://github.com/rust-lang/regex/issues/48
+[[test]]
+name = "invalid-regex-no-crash-400"
+regex = '*'
+haystack = ""
+matches = []
+compiles = false
+
+# See: https://github.com/rust-lang/regex/issues/75
+[[test]]
+name = "unsorted-binary-search-100"
+regex = '(?i-u)[a_]+'
+haystack = "A_"
+matches = [[0, 2]]
+
+# See: https://github.com/rust-lang/regex/issues/75
+[[test]]
+name = "unsorted-binary-search-200"
+regex = '(?i-u)[A_]+'
+haystack = "a_"
+matches = [[0, 2]]
+
+# See: https://github.com/rust-lang/regex/issues/76
+[[test]]
+name = "unicode-case-lower-nocase-flag"
+regex = '(?i)\p{Ll}+'
+haystack = "ΛΘΓΔα"
+matches = [[0, 10]]
+
+# See: https://github.com/rust-lang/regex/issues/99
+[[test]]
+name = "negated-char-class-100"
+regex = '(?i)[^x]'
+haystack = "x"
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/99
+[[test]]
+name = "negated-char-class-200"
+regex = '(?i)[^x]'
+haystack = "X"
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/101
+[[test]]
+name = "ascii-word-underscore"
+regex = '[[:word:]]'
+haystack = "_"
+matches = [[0, 1]]
+
+# See: https://github.com/rust-lang/regex/issues/129
+[[test]]
+name = "captures-repeat"
+regex = '([a-f]){2}(?P<foo>[x-z])'
+haystack = "abx"
+matches = [
+  [[0, 3], [1, 2], [2, 3]],
+]
+
+# See: https://github.com/rust-lang/regex/issues/153
+[[test]]
+name = "alt-in-alt-100"
+regex = 'ab?|$'
+haystack = "az"
+matches = [[0, 1], [2, 2]]
+
+# See: https://github.com/rust-lang/regex/issues/153
+[[test]]
+name = "alt-in-alt-200"
+regex = '^(?:.*?)(?:\n|\r\n?|$)'
+haystack = "ab\rcd"
+matches = [[0, 3]]
+
+# See: https://github.com/rust-lang/regex/issues/169
+[[test]]
+name = "leftmost-first-prefix"
+regex = 'z*azb'
+haystack = "azb"
+matches = [[0, 3]]
+
+# See: https://github.com/rust-lang/regex/issues/191
+[[test]]
+name = "many-alternates"
+regex = '1|2|3|4|5|6|7|8|9|10|int'
+haystack = "int"
+matches = [[0, 3]]
+
+# See: https://github.com/rust-lang/regex/issues/204
+[[test]]
+name = "word-boundary-alone-100"
+regex = '\b'
+haystack = "Should this (work?)"
+matches = [[0, 0], [6, 6], [7, 7], [11, 11], [13, 13], [17, 17]]
+
+# See: https://github.com/rust-lang/regex/issues/204
+[[test]]
+name = "word-boundary-alone-200"
+regex = '\b'
+haystack = "a b c"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+
+# See: https://github.com/rust-lang/regex/issues/264
+[[test]]
+name = "word-boundary-ascii-no-capture"
+regex = '\B'
+haystack = "\U00028F3E"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+unicode = false
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/264
+[[test]]
+name = "word-boundary-ascii-capture"
+regex = '(?:\B)'
+haystack = "\U00028F3E"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+unicode = false
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/268
+[[test]]
+name = "partial-anchor"
+regex = '^a|b'
+haystack = "ba"
+matches = [[0, 1]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "endl-or-word-boundary"
+regex = '(?m:$)|(?-u:\b)'
+haystack = "\U0006084E"
+matches = [[4, 4]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "zero-or-end"
+regex = '(?i-u:\x00)|$'
+haystack = "\U000E682F"
+matches = [[4, 4]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "y-or-endl"
+regex = '(?i-u:y)|(?m:$)'
+haystack = "\U000B4331"
+matches = [[4, 4]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "word-boundary-start-x"
+regex = '(?u:\b)^(?-u:X)'
+haystack = "X"
+matches = [[0, 1]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "word-boundary-ascii-start-x"
+regex = '(?-u:\b)^(?-u:X)'
+haystack = "X"
+matches = [[0, 1]]
+
+# See: https://github.com/rust-lang/regex/issues/271
+[[test]]
+name = "end-not-word-boundary"
+regex = '$\B'
+haystack = "\U0005C124\U000B576C"
+matches = [[8, 8]]
+unicode = false
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/280
+[[test]]
+name = "partial-anchor-alternate-begin"
+regex = '^a|z'
+haystack = "yyyyya"
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/280
+[[test]]
+name = "partial-anchor-alternate-end"
+regex = 'a$|z'
+haystack = "ayyyyy"
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/289
+[[test]]
+name = "lits-unambiguous-100"
+regex = '(?:ABC|CDA|BC)X'
+haystack = "CDAX"
+matches = [[0, 4]]
+
+# See: https://github.com/rust-lang/regex/issues/291
+[[test]]
+name = "lits-unambiguous-200"
+regex = '((IMG|CAM|MG|MB2)_|(DSCN|CIMG))(?P<n>[0-9]+)$'
+haystack = "CIMG2341"
+matches = [
+  [[0, 8], [0, 4], [], [0, 4], [4, 8]],
+]
+
+# See: https://github.com/rust-lang/regex/issues/303
+#
+# 2022-09-19: This has now been "properly" fixed in that empty character
+# classes are fully supported as something that can never match. This test
+# used to be marked as 'compiles = false', but now it works.
+[[test]]
+name = "negated-full-byte-range"
+regex = '[^\x00-\xFF]'
+haystack = ""
+matches = []
+compiles = true
+unicode = false
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/321
+[[test]]
+name = "strange-anchor-non-complete-prefix"
+regex = 'a^{2}'
+haystack = ""
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/321
+[[test]]
+name = "strange-anchor-non-complete-suffix"
+regex = '${2}a'
+haystack = ""
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/334
+# See: https://github.com/rust-lang/regex/issues/557
+[[test]]
+name = "captures-after-dfa-premature-end-100"
+regex = 'a(b*(X|$))?'
+haystack = "abcbX"
+matches = [
+  [[0, 1], [], []],
+]
+
+# See: https://github.com/rust-lang/regex/issues/334
+# See: https://github.com/rust-lang/regex/issues/557
+[[test]]
+name = "captures-after-dfa-premature-end-200"
+regex = 'a(bc*(X|$))?'
+haystack = "abcbX"
+matches = [
+  [[0, 1], [], []],
+]
+
+# See: https://github.com/rust-lang/regex/issues/334
+# See: https://github.com/rust-lang/regex/issues/557
+[[test]]
+name = "captures-after-dfa-premature-end-300"
+regex = '(aa$)?'
+haystack = "aaz"
+matches = [
+  [[0, 0], []],
+  [[1, 1], []],
+  [[2, 2], []],
+  [[3, 3], []],
+]
+
+# Plucked from "Why aren’t regular expressions a lingua franca? an empirical
+# study on the re-use and portability of regular expressions", The ACM Joint
+# European Software Engineering Conference and Symposium on the Foundations of
+# Software Engineering (ESEC/FSE), 2019.
+#
+# Link: https://dl.acm.org/doi/pdf/10.1145/3338906.3338909
+[[test]]
+name = "captures-after-dfa-premature-end-400"
+regex = '(a)\d*\.?\d+\b'
+haystack = "a0.0c"
+matches = [
+  [[0, 2], [0, 1]],
+]
+
+# See: https://github.com/rust-lang/regex/issues/437
+[[test]]
+name = "literal-panic"
+regex = 'typename type\-parameter\-[0-9]+\-[0-9]+::.+'
+haystack = "test"
+matches = []
+
+# See: https://github.com/rust-lang/regex/issues/527
+[[test]]
+name = "empty-flag-expr"
+regex = '(?:(?:(?x)))'
+haystack = ""
+matches = [[0, 0]]
+
+# See: https://github.com/rust-lang/regex/issues/533
+#[[tests]]
+#name = "blank-matches-nothing-between-space-and-tab"
+#regex = '[[:blank:]]'
+#input = '\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'
+#match = false
+#unescape = true
+
+# See: https://github.com/rust-lang/regex/issues/533
+#[[tests]]
+#name = "blank-matches-nothing-between-space-and-tab-inverted"
+#regex = '^[[:^blank:]]+$'
+#input = '\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'
+#match = true
+#unescape = true
+
+# See: https://github.com/rust-lang/regex/issues/555
+[[test]]
+name = "invalid-repetition"
+regex = '(?m){1,1}'
+haystack = ""
+matches = []
+compiles = false
+
+# See: https://github.com/rust-lang/regex/issues/640
+[[test]]
+name = "flags-are-unset"
+regex = '(?:(?i)foo)|Bar'
+haystack = "foo Foo bar Bar"
+matches = [[0, 3], [4, 7], [12, 15]]
+
+# Note that 'Ј' is not 'j', but cyrillic Je
+# https://en.wikipedia.org/wiki/Je_(Cyrillic)
+#
+# See: https://github.com/rust-lang/regex/issues/659
+[[test]]
+name = "empty-group-with-unicode"
+regex = '(?:)Ј01'
+haystack = 'zЈ01'
+matches = [[1, 5]]
+
+# See: https://github.com/rust-lang/regex/issues/579
+[[test]]
+name = "word-boundary-weird"
+regex = '\b..\b'
+haystack = "I have 12, he has 2!"
+matches = [[0, 2], [7, 9], [9, 11], [11, 13], [17, 19]]
+
+# See: https://github.com/rust-lang/regex/issues/579
+[[test]]
+name = "word-boundary-weird-ascii"
+regex = '\b..\b'
+haystack = "I have 12, he has 2!"
+matches = [[0, 2], [7, 9], [9, 11], [11, 13], [17, 19]]
+unicode = false
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/579
+[[test]]
+name = "word-boundary-weird-minimal-ascii"
+regex = '\b..\b'
+haystack = "az,,b"
+matches = [[0, 2], [2, 4]]
+unicode = false
+utf8 = false
+
+# See: https://github.com/BurntSushi/ripgrep/issues/1203
+[[test]]
+name = "reverse-suffix-100"
+regex = '[0-4][0-4][0-4]000'
+haystack = "153.230000"
+matches = [[4, 10]]
+
+# See: https://github.com/BurntSushi/ripgrep/issues/1203
+[[test]]
+name = "reverse-suffix-200"
+regex = '[0-9][0-9][0-9]000'
+haystack = "153.230000\n"
+matches = [[4, 10]]
+
+# This is a tricky case for the reverse suffix optimization, because it
+# finds the 'foobar' match but the reverse scan must fail to find a match by
+# correctly dealing with the word boundary following the 'foobar' literal when
+# computing the start state.
+#
+# This test exists because I tried to break the following assumption that
+# is currently in the code: that if a suffix is found and the reverse scan
+# succeeds, then it's guaranteed that there is an overall match. Namely, the
+# 'is_match' routine does *not* do another forward scan in this case because of
+# this assumption.
+[[test]]
+name = "reverse-suffix-300"
+regex = '\w+foobar\b'
+haystack = "xyzfoobarZ"
+matches = []
+unicode = false
+utf8 = false
+
+# See: https://github.com/BurntSushi/ripgrep/issues/1247
+[[test]]
+name = "stops"
+regex = '\bs(?:[ab])'
+haystack = 's\xE4'
+matches = []
+unescape = true
+utf8 = false
+
+# See: https://github.com/BurntSushi/ripgrep/issues/1247
+[[test]]
+name = "stops-ascii"
+regex = '(?-u:\b)s(?:[ab])'
+haystack = 's\xE4'
+matches = []
+unescape = true
+utf8 = false
+
+# See: https://github.com/rust-lang/regex/issues/850
+[[test]]
+name = "adjacent-line-boundary-100"
+regex = '(?m)^(?:[^ ]+?)$'
+haystack = "line1\nline2"
+matches = [[0, 5], [6, 11]]
+
+# Continued.
+[[test]]
+name = "adjacent-line-boundary-200"
+regex = '(?m)^(?:[^ ]+?)$'
+haystack = "A\nB"
+matches = [[0, 1], [2, 3]]
+
+# There is no issue for this bug.
+[[test]]
+name = "anchored-prefix-100"
+regex = '^a[[:^space:]]'
+haystack = "a "
+matches = []
+
+# There is no issue for this bug.
+[[test]]
+name = "anchored-prefix-200"
+regex = '^a[[:^space:]]'
+haystack = "foo boo a"
+matches = []
+
+# There is no issue for this bug.
+[[test]]
+name = "anchored-prefix-300"
+regex = '^-[a-z]'
+haystack = "r-f"
+matches = []
+
+# Tests that a possible Aho-Corasick optimization works correctly. It only
+# kicks in when we have a lot of literals. By "works correctly," we mean that
+# leftmost-first match semantics are properly respected. That is, samwise
+# should match, not sam.
+#
+# There is no issue for this bug.
+[[test]]
+name = "aho-corasick-100"
+regex = 'samwise|sam|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z'
+haystack = "samwise"
+matches = [[0, 7]]
+
+# See: https://github.com/rust-lang/regex/issues/921
+[[test]]
+name = "interior-anchor-capture"
+regex = '(a$)b$'
+haystack = 'ab'
+matches = []
+
+# I found this bug in the course of adding some of the regexes that Ruff uses
+# to rebar. It turns out that the lazy DFA was finding a match that was being
+# rejected by the one-pass DFA. Yikes. I then minimized the regex and haystack.
+#
+# Source: https://github.com/charliermarsh/ruff/blob/a919041ddaa64cdf6f216f90dd0480dab69fd3ba/crates/ruff/src/rules/pycodestyle/rules/whitespace_around_keywords.rs#L52
+[[test]]
+name = "ruff-whitespace-around-keywords"
+regex = '^(a|ab)$'
+haystack = "ab"
+anchored = true
+unicode = false
+utf8 = true
+matches = [[[0, 2], [0, 2]]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-0"
+regex = '(?:(?-u:\b)|(?u:h))+'
+haystack = "h"
+unicode = true
+utf8 = false
+matches = [[0, 0], [1, 1]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-1"
+regex = '(?u:\B)'
+haystack = "鋸"
+unicode = true
+utf8 = false
+matches = []
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-2"
+regex = '(?:(?u:\b)|(?s-u:.))+'
+haystack = "oB"
+unicode = true
+utf8 = false
+matches = [[0, 0], [1, 2]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-3"
+regex = '(?:(?-u:\B)|(?su:.))+'
+haystack = "\U000FEF80"
+unicode = true
+utf8 = false
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-3-utf8"
+regex = '(?:(?-u:\B)|(?su:.))+'
+haystack = "\U000FEF80"
+unicode = true
+utf8 = true
+matches = [[0, 0], [4, 4]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-4"
+regex = '(?m:$)(?m:^)(?su:.)'
+haystack = "\n‣"
+unicode = true
+utf8 = false
+matches = [[0, 1]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-5"
+regex = '(?m:$)^(?m:^)'
+haystack = "\n"
+unicode = true
+utf8 = false
+matches = [[0, 0]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-6"
+regex = '(?P<kp>(?iu:do)(?m:$))*'
+haystack = "dodo"
+unicode = true
+utf8 = false
+matches = [
+  [[0, 0], []],
+  [[1, 1], []],
+  [[2, 4], [2, 4]],
+]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-7"
+regex = '(?u:\B)'
+haystack = "䡁"
+unicode = true
+utf8 = false
+matches = []
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-8"
+regex = '(?:(?-u:\b)|(?u:[\u{0}-W]))+'
+haystack = "0"
+unicode = true
+utf8 = false
+matches = [[0, 0], [1, 1]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-9"
+regex = '((?m:$)(?-u:\B)(?s-u:.)(?-u:\B)$)'
+haystack = "\n\n"
+unicode = true
+utf8 = false
+matches = [
+  [[1, 2], [1, 2]],
+]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-10"
+regex = '(?m:$)(?m:$)^(?su:.)'
+haystack = "\n\u0081¨\u200a"
+unicode = true
+utf8 = false
+matches = [[0, 1]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-11"
+regex = '(?-u:\B)(?m:^)'
+haystack = "0\n"
+unicode = true
+utf8 = false
+matches = [[2, 2]]
+
+# From: https://github.com/rust-lang/regex/issues/429
+[[test]]
+name = "i429-12"
+regex = '(?:(?u:\b)|(?-u:.))+'
+haystack = "0"
+unicode = true
+utf8 = false
+matches = [[0, 0], [1, 1]]
+
+# From: https://github.com/rust-lang/regex/issues/969
+[[test]]
+name = "i969"
+regex = 'c.*d\z'
+haystack = "ababcd"
+bounds = [4, 6]
+search-kind = "earliest"
+matches = [[4, 6]]
+
+# I found this during the regex-automata migration. This is the fowler basic
+# 154 test, but without anchored = true and without a match limit.
+#
+# This test caught a subtle bug in the hybrid reverse DFA search, where it
+# would skip over the termination condition if it entered a start state. This
+# was a double bug. Firstly, the reverse DFA shouldn't have had start states
+# specialized in the first place, and thus it shouldn't have possible to detect
+# that the DFA had entered a start state. The second bug was that the start
+# state handling was incorrect by jumping over the termination condition.
+[[test]]
+name = "fowler-basic154-unanchored"
+regex = '''a([bc]*)c*'''
+haystack = '''abc'''
+matches = [[[0, 3], [1, 3]]]
+
+# From: https://github.com/rust-lang/regex/issues/981
+#
+# This was never really a problem in the new architecture because the
+# regex-automata engines are far more principled about how they deal with
+# look-around. (This was one of the many reasons I wanted to re-work the
+# original regex crate engines.)
+[[test]]
+name = "word-boundary-interact-poorly-with-literal-optimizations"
+regex = '(?i:(?:\b|_)win(?:32|64|dows)?(?:\b|_))'
+haystack = 'ubi-Darwin-x86_64.tar.gz'
+matches = []
+
+# This was found during fuzz testing of regex. It provoked a panic in the meta
+# engine as a result of the reverse suffix optimization. Namely, it hit a case
+# where a suffix match was found, a corresponding reverse match was found, but
+# the forward search turned up no match. The forward search should always match
+# if the suffix and reverse search match.
+#
+# This in turn uncovered an inconsistency between the PikeVM and the DFA (lazy
+# and fully compiled) engines. It was caused by a mishandling of the collection
+# of NFA state IDs in the generic determinization code (which is why both types
+# of DFA were impacted). Namely, when a fail state was encountered (that's the
+# `[^\s\S]` in the pattern below), then it would just stop collecting states.
+# But that's not correct since a later state could lead to a match.
+[[test]]
+name = "impossible-branch"
+regex = '.*[^\s\S]A|B'
+haystack = "B"
+matches = [[0, 1]]
+
+# This was found during fuzz testing in regex-lite. The regex crate never
+# suffered from this bug, but it causes regex-lite to incorrectly compile
+# captures.
+[[test]]
+name = "captures-wrong-order"
+regex = '(a){0}(a)'
+haystack = 'a'
+matches = [[[0, 1], [], [0, 1]]]
+
+# This tests a bug in how quit states are handled in the DFA. At some point
+# during development, the DFAs were tweaked slightly such that if they hit
+# a quit state (which means, they hit a byte that the caller configured should
+# stop the search), then it might not return an error necessarily. Namely, if a
+# match had already been found, then it would be returned instead of an error.
+#
+# But this is actually wrong! Why? Because even though a match had been found,
+# it wouldn't be fully correct to return it once a quit state has been seen
+# because you can't determine whether the match offset returned is the correct
+# greedy/leftmost-first match. Since you can't complete the search as requested
+# by the caller, the DFA should just stop and return an error.
+#
+# Interestingly, this does seem to produce an unavoidable difference between
+# 'try_is_match().unwrap()' and 'try_find().unwrap().is_some()' for the DFAs.
+# The former will stop immediately once a match is known to occur and return
+# 'Ok(true)', where as the latter could find the match but quit with an
+# 'Err(..)' first.
+#
+# Thankfully, I believe this inconsistency between 'is_match()' and 'find()'
+# cannot be observed in the higher level meta regex API because it specifically
+# will try another engine that won't fail in the case of a DFA failing.
+#
+# This regression happened in the regex crate rewrite, but before anything got
+# released.
+[[test]]
+name = "negated-unicode-word-boundary-dfa-fail"
+regex = '\B.*'
+haystack = "!\u02D7"
+matches = [[0, 3]]
+
+# This failure was found in the *old* regex crate (prior to regex 1.9), but
+# I didn't investigate why. My best guess is that it's a literal optimization
+# bug. It didn't occur in the rewrite.
+[[test]]
+name = "missed-match"
+regex = 'e..+e.ee>'
+haystack = 'Zeee.eZZZZZZZZeee>eeeeeee>'
+matches = [[1, 26]]
+
+# This test came from the 'ignore' crate and tripped a bug in how accelerated
+# DFA states were handled in an overlapping search.
+[[test]]
+name = "regex-to-glob"
+regex = ['(?-u)^path1/[^/]*$']
+haystack = "path1/foo"
+matches = [[0, 9]]
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
diff --git a/testdata/set.toml b/testdata/set.toml
new file mode 100644
index 0000000000..049e8a89d1
--- /dev/null
+++ b/testdata/set.toml
@@ -0,0 +1,641 @@
+# Basic multi-regex tests.
+
+[[test]]
+name = "basic10"
+regex = ["a", "a"]
+haystack = "a"
+matches = [
+  { id = 0, span = [0, 1] },
+  { id = 1, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic10-leftmost-first"
+regex = ["a", "a"]
+haystack = "a"
+matches = [
+  { id = 0, span = [0, 1] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "basic20"
+regex = ["a", "a"]
+haystack = "ba"
+matches = [
+  { id = 0, span = [1, 2] },
+  { id = 1, span = [1, 2] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic30"
+regex = ["a", "b"]
+haystack = "a"
+matches = [
+  { id = 0, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic40"
+regex = ["a", "b"]
+haystack = "b"
+matches = [
+  { id = 1, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic50"
+regex = ["a|b", "b|a"]
+haystack = "b"
+matches = [
+  { id = 0, span = [0, 1] },
+  { id = 1, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic60"
+regex = ["foo", "oo"]
+haystack = "foo"
+matches = [
+  { id = 0, span = [0, 3] },
+  { id = 1, span = [1, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic60-leftmost-first"
+regex = ["foo", "oo"]
+haystack = "foo"
+matches = [
+  { id = 0, span = [0, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "basic61"
+regex = ["oo", "foo"]
+haystack = "foo"
+matches = [
+  { id = 1, span = [0, 3] },
+  { id = 0, span = [1, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic61-leftmost-first"
+regex = ["oo", "foo"]
+haystack = "foo"
+matches = [
+  { id = 1, span = [0, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "basic70"
+regex = ["abcd", "bcd", "cd", "d"]
+haystack = "abcd"
+matches = [
+  { id = 0, span = [0, 4] },
+  { id = 1, span = [1, 4] },
+  { id = 2, span = [2, 4] },
+  { id = 3, span = [3, 4] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic71"
+regex = ["bcd", "cd", "d", "abcd"]
+haystack = "abcd"
+matches = [
+  { id = 3, span = [0, 4] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "basic80"
+regex = ["^foo", "bar$"]
+haystack = "foo"
+matches = [
+  { id = 0, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic81"
+regex = ["^foo", "bar$"]
+haystack = "foo bar"
+matches = [
+  { id = 0, span = [0, 3] },
+  { id = 1, span = [4, 7] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic82"
+regex = ["^foo", "bar$"]
+haystack = "bar"
+matches = [
+  { id = 1, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic90"
+regex = ["[a-z]+$", "foo"]
+haystack = "01234 foo"
+matches = [
+  { id = 0, span = [8, 9] },
+  { id = 0, span = [7, 9] },
+  { id = 0, span = [6, 9] },
+  { id = 1, span = [6, 9] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic91"
+regex = ["[a-z]+$", "foo"]
+haystack = "foo 01234"
+matches = [
+  { id = 1, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic100"
+regex = [".*?", "a"]
+haystack = "zzza"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [0, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [1, 2] },
+  { id = 0, span = [0, 2] },
+  { id = 0, span = [3, 3] },
+  { id = 0, span = [2, 3] },
+  { id = 0, span = [1, 3] },
+  { id = 0, span = [0, 3] },
+  { id = 0, span = [4, 4] },
+  { id = 0, span = [3, 4] },
+  { id = 0, span = [2, 4] },
+  { id = 0, span = [1, 4] },
+  { id = 0, span = [0, 4] },
+  { id = 1, span = [3, 4] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic101"
+regex = [".*", "a"]
+haystack = "zzza"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [0, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [1, 2] },
+  { id = 0, span = [0, 2] },
+  { id = 0, span = [3, 3] },
+  { id = 0, span = [2, 3] },
+  { id = 0, span = [1, 3] },
+  { id = 0, span = [0, 3] },
+  { id = 0, span = [4, 4] },
+  { id = 0, span = [3, 4] },
+  { id = 0, span = [2, 4] },
+  { id = 0, span = [1, 4] },
+  { id = 0, span = [0, 4] },
+  { id = 1, span = [3, 4] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic102"
+regex = [".*", "a"]
+haystack = "zzz"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [0, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [1, 2] },
+  { id = 0, span = [0, 2] },
+  { id = 0, span = [3, 3] },
+  { id = 0, span = [2, 3] },
+  { id = 0, span = [1, 3] },
+  { id = 0, span = [0, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic110"
+regex = ['\ba\b']
+haystack = "hello a bye"
+matches = [
+  { id = 0, span = [6, 7] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic111"
+regex = ['\ba\b', '\be\b']
+haystack = "hello a bye e"
+matches = [
+  { id = 0, span = [6, 7] },
+  { id = 1, span = [12, 13] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic120"
+regex = ["a"]
+haystack = "a"
+matches = [
+  { id = 0, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic121"
+regex = [".*a"]
+haystack = "a"
+matches = [
+  { id = 0, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic122"
+regex = [".*a", "β"]
+haystack = "β"
+matches = [
+  { id = 1, span = [0, 2] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "basic130"
+regex = ["ab", "b"]
+haystack = "ba"
+matches = [
+  { id = 1, span = [0, 1] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+# These test cases where one of the regexes matches the empty string.
+
+[[test]]
+name = "empty10"
+regex = ["", "a"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 1, span = [0, 1] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty10-leftmost-first"
+regex = ["", "a"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty11"
+regex = ["a", ""]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 0, span = [0, 1] },
+  { id = 1, span = [1, 1] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty11-leftmost-first"
+regex = ["a", ""]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 1] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty20"
+regex = ["", "b"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 1, span = [1, 2] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty20-leftmost-first"
+regex = ["", "b"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty21"
+regex = ["b", ""]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 1, span = [1, 1] },
+  { id = 0, span = [1, 2] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty21-leftmost-first"
+regex = ["b", ""]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 0, span = [1, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty22"
+regex = ["(?:)", "b"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 1, span = [1, 2] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty23"
+regex = ["b", "(?:)"]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 1, span = [1, 1] },
+  { id = 0, span = [1, 2] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty30"
+regex = ["", "z"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty30-leftmost-first"
+regex = ["", "z"]
+haystack = "abc"
+matches = [
+  { id = 0, span = [0, 0] },
+  { id = 0, span = [1, 1] },
+  { id = 0, span = [2, 2] },
+  { id = 0, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty31"
+regex = ["z", ""]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 1, span = [1, 1] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty31-leftmost-first"
+regex = ["z", ""]
+haystack = "abc"
+matches = [
+  { id = 1, span = [0, 0] },
+  { id = 1, span = [1, 1] },
+  { id = 1, span = [2, 2] },
+  { id = 1, span = [3, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+[[test]]
+name = "empty40"
+regex = ["c(?:)", "b"]
+haystack = "abc"
+matches = [
+  { id = 1, span = [1, 2] },
+  { id = 0, span = [2, 3] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "empty40-leftmost-first"
+regex = ["c(?:)", "b"]
+haystack = "abc"
+matches = [
+  { id = 1, span = [1, 2] },
+  { id = 0, span = [2, 3] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+
+# These test cases where there are no matches.
+
+[[test]]
+name = "nomatch10"
+regex = ["a", "a"]
+haystack = "b"
+matches = []
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "nomatch20"
+regex = ["^foo", "bar$"]
+haystack = "bar foo"
+matches = []
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "nomatch30"
+regex = []
+haystack = "a"
+matches = []
+match-kind = "all"
+search-kind = "overlapping"
+
+[[test]]
+name = "nomatch40"
+regex = ["^rooted$", '\.log$']
+haystack = "notrooted"
+matches = []
+match-kind = "all"
+search-kind = "overlapping"
+
+# These test multi-regex searches with capture groups.
+#
+# NOTE: I wrote these tests in the course of developing a first class API for
+# overlapping capturing group matches, but ultimately removed that API because
+# the semantics for overlapping matches aren't totally clear. However, I've
+# left the tests because I believe the semantics for these patterns are clear
+# and because we can still test our "which patterns matched" APIs with them.
+
+[[test]]
+name = "caps-010"
+regex = ['^(\w+) (\w+)$', '^(\S+) (\S+)$']
+haystack = "Bruce Springsteen"
+matches = [
+  { id = 0, spans = [[0, 17], [0, 5], [6, 17]] },
+  { id = 1, spans = [[0, 17], [0, 5], [6, 17]] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+unicode = false
+utf8 = false
+
+[[test]]
+name = "caps-020"
+regex = ['^(\w+) (\w+)$', '^[A-Z](\S+) [A-Z](\S+)$']
+haystack = "Bruce Springsteen"
+matches = [
+  { id = 0, spans = [[0, 17], [0, 5], [6, 17]] },
+  { id = 1, spans = [[0, 17], [1, 5], [7, 17]] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+unicode = false
+utf8 = false
+
+[[test]]
+name = "caps-030"
+regex = ['^(\w+) (\w+)$', '^([A-Z])(\S+) ([A-Z])(\S+)$']
+haystack = "Bruce Springsteen"
+matches = [
+  { id = 0, spans = [[0, 17], [0, 5], [6, 17]] },
+  { id = 1, spans = [[0, 17], [0, 1], [1, 5], [6, 7], [7, 17]] },
+]
+match-kind = "all"
+search-kind = "overlapping"
+unicode = false
+utf8 = false
+
+[[test]]
+name = "caps-110"
+regex = ['(\w+) (\w+)', '(\S+) (\S+)']
+haystack = "Bruce Springsteen"
+matches = [
+  { id = 0, spans = [[0, 17], [0, 5], [6, 17]] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+unicode = false
+utf8 = false
+
+[[test]]
+name = "caps-120"
+regex = ['(\w+) (\w+)', '(\S+) (\S+)']
+haystack = "&ruce $pringsteen"
+matches = [
+  { id = 1, spans = [[0, 17], [0, 5], [6, 17]] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+unicode = false
+utf8 = false
+
+[[test]]
+name = "caps-121"
+regex = ['(\w+) (\w+)', '(\S+) (\S+)']
+haystack = "&ruce $pringsteen Foo Bar"
+matches = [
+  { id = 1, spans = [[0, 17], [0, 5], [6, 17]] },
+  { id = 0, spans = [[18, 25], [18, 21], [22, 25]] },
+]
+match-kind = "leftmost-first"
+search-kind = "leftmost"
+unicode = false
+utf8 = false
diff --git a/testdata/substring.toml b/testdata/substring.toml
new file mode 100644
index 0000000000..69595ce851
--- /dev/null
+++ b/testdata/substring.toml
@@ -0,0 +1,36 @@
+# These tests check that regex engines perform as expected when the search is
+# instructed to only search a substring of a haystack instead of the entire
+# haystack. This tends to exercise interesting edge cases that are otherwise
+# difficult to provoke. (But not necessarily impossible. Regex search iterators
+# for example, make use of the "search just a substring" APIs by changing the
+# starting position of a search to the end position of the previous match.)
+
+[[test]]
+name = "unicode-word-start"
+regex = '\b[0-9]+\b'
+haystack = "β123"
+bounds = { start = 2, end = 5 }
+matches = []
+
+[[test]]
+name = "unicode-word-end"
+regex = '\b[0-9]+\b'
+haystack = "123β"
+bounds = { start = 0, end = 3 }
+matches = []
+
+[[test]]
+name = "ascii-word-start"
+regex = '\b[0-9]+\b'
+haystack = "β123"
+bounds = { start = 2, end = 5 }
+matches = [[2, 5]]
+unicode = false
+
+[[test]]
+name = "ascii-word-end"
+regex = '\b[0-9]+\b'
+haystack = "123β"
+bounds = { start = 0, end = 3 }
+matches = [[0, 3]]
+unicode = false
diff --git a/testdata/unicode.toml b/testdata/unicode.toml
new file mode 100644
index 0000000000..f4ac76bae6
--- /dev/null
+++ b/testdata/unicode.toml
@@ -0,0 +1,517 @@
+# Basic Unicode literal support.
+[[test]]
+name = "literal1"
+regex = '☃'
+haystack = "☃"
+matches = [[0, 3]]
+
+[[test]]
+name = "literal2"
+regex = '☃+'
+haystack = "☃"
+matches = [[0, 3]]
+
+[[test]]
+name = "literal3"
+regex = '☃+'
+haystack = "☃"
+matches = [[0, 3]]
+case-insensitive = true
+
+[[test]]
+name = "literal4"
+regex = 'Δ'
+haystack = "δ"
+matches = [[0, 2]]
+case-insensitive = true
+
+# Unicode word boundaries.
+[[test]]
+name = "wb-100"
+regex = '\d\b'
+haystack = "6δ"
+matches = []
+
+[[test]]
+name = "wb-200"
+regex = '\d\b'
+haystack = "6 "
+matches = [[0, 1]]
+
+[[test]]
+name = "wb-300"
+regex = '\d\B'
+haystack = "6δ"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb-400"
+regex = '\d\B'
+haystack = "6 "
+matches = []
+
+# Unicode character class support.
+[[test]]
+name = "class1"
+regex = '[☃Ⅰ]+'
+haystack = "☃"
+matches = [[0, 3]]
+
+[[test]]
+name = "class2"
+regex = '\pN'
+haystack = "Ⅰ"
+matches = [[0, 3]]
+
+[[test]]
+name = "class3"
+regex = '\pN+'
+haystack = "Ⅰ1Ⅱ2"
+matches = [[0, 8]]
+
+[[test]]
+name = "class4"
+regex = '\PN+'
+haystack = "abⅠ"
+matches = [[0, 2]]
+
+[[test]]
+name = "class5"
+regex = '[\PN]+'
+haystack = "abⅠ"
+matches = [[0, 2]]
+
+[[test]]
+name = "class6"
+regex = '[^\PN]+'
+haystack = "abⅠ"
+matches = [[2, 5]]
+
+[[test]]
+name = "class7"
+regex = '\p{Lu}+'
+haystack = "ΛΘΓΔα"
+matches = [[0, 8]]
+
+[[test]]
+name = "class8"
+regex = '\p{Lu}+'
+haystack = "ΛΘΓΔα"
+matches = [[0, 10]]
+case-insensitive = true
+
+[[test]]
+name = "class9"
+regex = '\pL+'
+haystack = "ΛΘΓΔα"
+matches = [[0, 10]]
+
+[[test]]
+name = "class10"
+regex = '\p{Ll}+'
+haystack = "ΛΘΓΔα"
+matches = [[8, 10]]
+
+# Unicode aware "Perl" character classes.
+[[test]]
+name = "perl1"
+regex = '\w+'
+haystack = "dδd"
+matches = [[0, 4]]
+
+[[test]]
+name = "perl2"
+regex = '\w+'
+haystack = "⥡"
+matches = []
+
+[[test]]
+name = "perl3"
+regex = '\W+'
+haystack = "⥡"
+matches = [[0, 3]]
+
+[[test]]
+name = "perl4"
+regex = '\d+'
+haystack = "1२३9"
+matches = [[0, 8]]
+
+[[test]]
+name = "perl5"
+regex = '\d+'
+haystack = "Ⅱ"
+matches = []
+
+[[test]]
+name = "perl6"
+regex = '\D+'
+haystack = "Ⅱ"
+matches = [[0, 3]]
+
+[[test]]
+name = "perl7"
+regex = '\s+'
+haystack = " "
+matches = [[0, 3]]
+
+[[test]]
+name = "perl8"
+regex = '\s+'
+haystack = "☃"
+matches = []
+
+[[test]]
+name = "perl9"
+regex = '\S+'
+haystack = "☃"
+matches = [[0, 3]]
+
+# Specific tests for Unicode general category classes.
+[[test]]
+name = "class-gencat1"
+regex = '\p{Cased_Letter}'
+haystack = "Ａ"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat2"
+regex = '\p{Close_Punctuation}'
+haystack = "❯"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat3"
+regex = '\p{Connector_Punctuation}'
+haystack = "⁀"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat4"
+regex = '\p{Control}'
+haystack = "\u009F"
+matches = [[0, 2]]
+
+[[test]]
+name = "class-gencat5"
+regex = '\p{Currency_Symbol}'
+haystack = "￡"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat6"
+regex = '\p{Dash_Punctuation}'
+haystack = "〰"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat7"
+regex = '\p{Decimal_Number}'
+haystack = "𑓙"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat8"
+regex = '\p{Enclosing_Mark}'
+haystack = "\uA672"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat9"
+regex = '\p{Final_Punctuation}'
+haystack = "⸡"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat10"
+regex = '\p{Format}'
+haystack = "\U000E007F"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat11"
+regex = '\p{Initial_Punctuation}'
+haystack = "⸜"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat12"
+regex = '\p{Letter}'
+haystack = "Έ"
+matches = [[0, 2]]
+
+[[test]]
+name = "class-gencat13"
+regex = '\p{Letter_Number}'
+haystack = "ↂ"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat14"
+regex = '\p{Line_Separator}'
+haystack = "\u2028"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat15"
+regex = '\p{Lowercase_Letter}'
+haystack = "ϛ"
+matches = [[0, 2]]
+
+[[test]]
+name = "class-gencat16"
+regex = '\p{Mark}'
+haystack = "\U000E01EF"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat17"
+regex = '\p{Math}'
+haystack = "⋿"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat18"
+regex = '\p{Modifier_Letter}'
+haystack = "𖭃"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat19"
+regex = '\p{Modifier_Symbol}'
+haystack = "🏿"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat20"
+regex = '\p{Nonspacing_Mark}'
+haystack = "\U0001E94A"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat21"
+regex = '\p{Number}'
+haystack = "⓿"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat22"
+regex = '\p{Open_Punctuation}'
+haystack = "｟"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat23"
+regex = '\p{Other}'
+haystack = "\u0BC9"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat24"
+regex = '\p{Other_Letter}'
+haystack = "ꓷ"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat25"
+regex = '\p{Other_Number}'
+haystack = "㉏"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat26"
+regex = '\p{Other_Punctuation}'
+haystack = "𞥞"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat27"
+regex = '\p{Other_Symbol}'
+haystack = "⅌"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat28"
+regex = '\p{Paragraph_Separator}'
+haystack = "\u2029"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat29"
+regex = '\p{Private_Use}'
+haystack = "\U0010FFFD"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat30"
+regex = '\p{Punctuation}'
+haystack = "𑁍"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat31"
+regex = '\p{Separator}'
+haystack = "\u3000"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat32"
+regex = '\p{Space_Separator}'
+haystack = "\u205F"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat33"
+regex = '\p{Spacing_Mark}'
+haystack = "\U00016F7E"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat34"
+regex = '\p{Symbol}'
+haystack = "⯈"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat35"
+regex = '\p{Titlecase_Letter}'
+haystack = "ῼ"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gencat36"
+regex = '\p{Unassigned}'
+haystack = "\U0010FFFF"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gencat37"
+regex = '\p{Uppercase_Letter}'
+haystack = "Ꝋ"
+matches = [[0, 3]]
+
+
+# Tests for Unicode emoji properties.
+[[test]]
+name = "class-emoji1"
+regex = '\p{Emoji}'
+haystack = "\u23E9"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-emoji2"
+regex = '\p{emoji}'
+haystack = "\U0001F21A"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-emoji3"
+regex = '\p{extendedpictographic}'
+haystack = "\U0001FA6E"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-emoji4"
+regex = '\p{extendedpictographic}'
+haystack = "\U0001FFFD"
+matches = [[0, 4]]
+
+
+# Tests for Unicode grapheme cluster properties.
+[[test]]
+name = "class-gcb1"
+regex = '\p{grapheme_cluster_break=prepend}'
+haystack = "\U00011D46"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gcb2"
+regex = '\p{gcb=regional_indicator}'
+haystack = "\U0001F1E6"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gcb3"
+regex = '\p{gcb=ri}'
+haystack = "\U0001F1E7"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gcb4"
+regex = '\p{regionalindicator}'
+haystack = "\U0001F1FF"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-gcb5"
+regex = '\p{gcb=lvt}'
+haystack = "\uC989"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-gcb6"
+regex = '\p{gcb=zwj}'
+haystack = "\u200D"
+matches = [[0, 3]]
+
+# Tests for Unicode word boundary properties.
+[[test]]
+name = "class-word-break1"
+regex = '\p{word_break=Hebrew_Letter}'
+haystack = "\uFB46"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-word-break2"
+regex = '\p{wb=hebrewletter}'
+haystack = "\uFB46"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-word-break3"
+regex = '\p{wb=ExtendNumLet}'
+haystack = "\uFF3F"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-word-break4"
+regex = '\p{wb=WSegSpace}'
+haystack = "\u3000"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-word-break5"
+regex = '\p{wb=numeric}'
+haystack = "\U0001E950"
+matches = [[0, 4]]
+
+# Tests for Unicode sentence boundary properties.
+[[test]]
+name = "class-sentence-break1"
+regex = '\p{sentence_break=Lower}'
+haystack = "\u0469"
+matches = [[0, 2]]
+
+[[test]]
+name = "class-sentence-break2"
+regex = '\p{sb=lower}'
+haystack = "\u0469"
+matches = [[0, 2]]
+
+[[test]]
+name = "class-sentence-break3"
+regex = '\p{sb=Close}'
+haystack = "\uFF60"
+matches = [[0, 3]]
+
+[[test]]
+name = "class-sentence-break4"
+regex = '\p{sb=Close}'
+haystack = "\U0001F677"
+matches = [[0, 4]]
+
+[[test]]
+name = "class-sentence-break5"
+regex = '\p{sb=SContinue}'
+haystack = "\uFF64"
+matches = [[0, 3]]
diff --git a/testdata/utf8.toml b/testdata/utf8.toml
new file mode 100644
index 0000000000..39e284b382
--- /dev/null
+++ b/testdata/utf8.toml
@@ -0,0 +1,399 @@
+# These test the UTF-8 modes expose by regex-automata. Namely, when utf8 is
+# true, then we promise that the haystack is valid UTF-8. (Otherwise behavior
+# is unspecified.) This also corresponds to building the regex engine with the
+# following two guarantees:
+#
+# 1) For any non-empty match reported, its span is guaranteed to correspond to
+# valid UTF-8.
+# 2) All empty or zero-width matches reported must never split a UTF-8
+# encoded codepoint. If the haystack has invalid UTF-8, then this results in
+# unspecified behavior.
+#
+# The (2) is in particular what we focus our testing on since (1) is generally
+# guaranteed by regex-syntax's AST-to-HIR translator and is well tested there.
+# The thing with (2) is that it can't be described in the HIR, so the regex
+# engines have to handle that case. Thus, we test it here.
+#
+# Note that it is possible to build a regex that has property (1) but not
+# (2), and vice versa. This is done by building the HIR with 'utf8=true' but
+# building the Thompson NFA with 'utf8=false'. We don't test that here because
+# the harness doesn't expose a way to enable or disable UTF-8 mode with that
+# granularity. Instead, those combinations are lightly tested via doc examples.
+# That's not to say that (1) without (2) is uncommon. Indeed, ripgrep uses it
+# because it cannot guarantee that its haystack is valid UTF-8.
+
+# This tests that an empty regex doesn't split a codepoint.
+[[test]]
+name = "empty-utf8yes"
+regex = ''
+haystack = '☃'
+matches = [[0, 0], [3, 3]]
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-overlapping"
+regex = ''
+haystack = '☃'
+matches = [[0, 0], [3, 3]]
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that an empty regex DOES split a codepoint when utf=false.
+[[test]]
+name = "empty-utf8no"
+regex = ''
+haystack = '☃'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8no-overlapping"
+regex = ''
+haystack = '☃'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3]]
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that an empty regex doesn't split a codepoint, even if we give
+# it bounds entirely within the codepoint.
+#
+# This is one of the trickier cases and is what motivated the current UTF-8
+# mode design. In particular, at one point, this test failed the 'is_match'
+# variant of the test but not 'find'. This is because the 'is_match' code path
+# is specifically optimized for "was a match found" rather than "where is the
+# match." In the former case, you don't really care about the empty-vs-non-empty
+# matches, and thus, the codepoint splitting filtering logic wasn't getting
+# applied. (In multiple ways across multiple regex engines.) In this way, you
+# can wind up with a situation where 'is_match' says "yes," but 'find' says,
+# "I didn't find anything." Which is... not great.
+#
+# I could have decided to say that providing boundaries that themselves split
+# a codepoint would have unspecified behavior. But I couldn't quite convince
+# myself that such boundaries were the only way to get an inconsistency between
+# 'is_match' and 'find'.
+#
+# Note that I also tried to come up with a test like this that fails without
+# using `bounds`. Specifically, a test where 'is_match' and 'find' disagree.
+# But I couldn't do it, and I'm tempted to conclude it is impossible. The
+# fundamental problem is that you need to simultaneously produce an empty match
+# that splits a codepoint while *not* matching before or after the codepoint.
+[[test]]
+name = "empty-utf8yes-bounds"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = []
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-bounds-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = []
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that an empty regex splits a codepoint when the bounds are
+# entirely within the codepoint.
+[[test]]
+name = "empty-utf8no-bounds"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = [[1, 1], [2, 2], [3, 3]]
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8no-bounds-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = [[1, 1], [2, 2], [3, 3]]
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# In this test, we anchor the search. Since the start position is also a UTF-8
+# boundary, we get a match.
+[[test]]
+name = "empty-utf8yes-anchored"
+regex = ''
+haystack = '𝛃'
+matches = [[0, 0]]
+anchored = true
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-anchored-overlapping"
+regex = ''
+haystack = '𝛃'
+matches = [[0, 0]]
+anchored = true
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# Same as above, except with UTF-8 mode disabled. It almost doesn't change the
+# result, except for the fact that since this is an anchored search and we
+# always find all matches, the test harness will keep reporting matches until
+# none are found. Because it's anchored, matches will be reported so long as
+# they are directly adjacent. Since with UTF-8 mode the next anchored search
+# after the match at [0, 0] fails, iteration stops (and doesn't find the last
+# match at [4, 4]).
+[[test]]
+name = "empty-utf8no-anchored"
+regex = ''
+haystack = '𝛃'
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+anchored = true
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+#
+# Note that overlapping anchored searches are a little weird, and it's not
+# totally clear what their semantics ought to be. For now, we just test the
+# current behavior of our test shim that implements overlapping search. (This
+# is one of the reasons why we don't really expose regex-level overlapping
+# searches.)
+[[test]]
+name = "empty-utf8no-anchored-overlapping"
+regex = ''
+haystack = '𝛃'
+matches = [[0, 0]]
+anchored = true
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# In this test, we anchor the search, but also set bounds. The bounds start the
+# search in the middle of a codepoint, so there should never be a match.
+[[test]]
+name = "empty-utf8yes-anchored-bounds"
+regex = ''
+haystack = '𝛃'
+matches = []
+bounds = [1, 3]
+anchored = true
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-anchored-bounds-overlapping"
+regex = ''
+haystack = '𝛃'
+matches = []
+bounds = [1, 3]
+anchored = true
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# Same as above, except with UTF-8 mode disabled. Without UTF-8 mode enabled,
+# matching within a codepoint is allowed. And remember, as in the anchored test
+# above with UTF-8 mode disabled, iteration will report all adjacent matches.
+# The matches at [0, 0] and [4, 4] are not included because of the bounds of
+# the search.
+[[test]]
+name = "empty-utf8no-anchored-bounds"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = [[1, 1], [2, 2], [3, 3]]
+anchored = true
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+#
+# Note that overlapping anchored searches are a little weird, and it's not
+# totally clear what their semantics ought to be. For now, we just test the
+# current behavior of our test shim that implements overlapping search. (This
+# is one of the reasons why we don't really expose regex-level overlapping
+# searches.)
+[[test]]
+name = "empty-utf8no-anchored-bounds-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 3]
+matches = [[1, 1]]
+anchored = true
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that we find the match at the end of the string when the bounds
+# exclude the first match.
+[[test]]
+name = "empty-utf8yes-startbound"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[4, 4]]
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-startbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[4, 4]]
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# Same as above, except since UTF-8 mode is disabled, we also find the matches
+# inbetween that split the codepoint.
+[[test]]
+name = "empty-utf8no-startbound"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[1, 1], [2, 2], [3, 3], [4, 4]]
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8no-startbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[1, 1], [2, 2], [3, 3], [4, 4]]
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that we don't find any matches in an anchored search, even when
+# the bounds include a match (at the end).
+[[test]]
+name = "empty-utf8yes-anchored-startbound"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = []
+anchored = true
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-anchored-startbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = []
+anchored = true
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# Same as above, except since UTF-8 mode is disabled, we also find the matches
+# inbetween that split the codepoint. Even though this is an anchored search,
+# since the matches are adjacent, we find all of them.
+[[test]]
+name = "empty-utf8no-anchored-startbound"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[1, 1], [2, 2], [3, 3], [4, 4]]
+anchored = true
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+#
+# Note that overlapping anchored searches are a little weird, and it's not
+# totally clear what their semantics ought to be. For now, we just test the
+# current behavior of our test shim that implements overlapping search. (This
+# is one of the reasons why we don't really expose regex-level overlapping
+# searches.)
+[[test]]
+name = "empty-utf8no-anchored-startbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [1, 4]
+matches = [[1, 1]]
+anchored = true
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
+
+# This tests that we find the match at the end of the haystack in UTF-8 mode
+# when our bounds only include the empty string at the end of the haystack.
+[[test]]
+name = "empty-utf8yes-anchored-endbound"
+regex = ''
+haystack = '𝛃'
+bounds = [4, 4]
+matches = [[4, 4]]
+anchored = true
+unicode = true
+utf8 = true
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8yes-anchored-endbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [4, 4]
+matches = [[4, 4]]
+anchored = true
+unicode = true
+utf8 = true
+match-kind = "all"
+search-kind = "overlapping"
+
+# Same as above, but with UTF-8 mode disabled. Results remain the same since
+# the only possible match does not split a codepoint.
+[[test]]
+name = "empty-utf8no-anchored-endbound"
+regex = ''
+haystack = '𝛃'
+bounds = [4, 4]
+matches = [[4, 4]]
+anchored = true
+unicode = true
+utf8 = false
+
+# Tests the overlapping case of the above.
+[[test]]
+name = "empty-utf8no-anchored-endbound-overlapping"
+regex = ''
+haystack = '𝛃'
+bounds = [4, 4]
+matches = [[4, 4]]
+anchored = true
+unicode = true
+utf8 = false
+match-kind = "all"
+search-kind = "overlapping"
diff --git a/testdata/word-boundary.toml b/testdata/word-boundary.toml
new file mode 100644
index 0000000000..1d86fc9bb3
--- /dev/null
+++ b/testdata/word-boundary.toml
@@ -0,0 +1,781 @@
+# Some of these are cribbed from RE2's test suite.
+
+# These test \b. Below are tests for \B.
+[[test]]
+name = "wb1"
+regex = '\b'
+haystack = ""
+matches = []
+unicode = false
+
+[[test]]
+name = "wb2"
+regex = '\b'
+haystack = "a"
+matches = [[0, 0], [1, 1]]
+unicode = false
+
+[[test]]
+name = "wb3"
+regex = '\b'
+haystack = "ab"
+matches = [[0, 0], [2, 2]]
+unicode = false
+
+[[test]]
+name = "wb4"
+regex = '^\b'
+haystack = "ab"
+matches = [[0, 0]]
+unicode = false
+
+[[test]]
+name = "wb5"
+regex = '\b$'
+haystack = "ab"
+matches = [[2, 2]]
+unicode = false
+
+[[test]]
+name = "wb6"
+regex = '^\b$'
+haystack = "ab"
+matches = []
+unicode = false
+
+[[test]]
+name = "wb7"
+regex = '\bbar\b'
+haystack = "nobar bar foo bar"
+matches = [[6, 9], [14, 17]]
+unicode = false
+
+[[test]]
+name = "wb8"
+regex = 'a\b'
+haystack = "faoa x"
+matches = [[3, 4]]
+unicode = false
+
+[[test]]
+name = "wb9"
+regex = '\bbar'
+haystack = "bar x"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb10"
+regex = '\bbar'
+haystack = "foo\nbar x"
+matches = [[4, 7]]
+unicode = false
+
+[[test]]
+name = "wb11"
+regex = 'bar\b'
+haystack = "foobar"
+matches = [[3, 6]]
+unicode = false
+
+[[test]]
+name = "wb12"
+regex = 'bar\b'
+haystack = "foobar\nxxx"
+matches = [[3, 6]]
+unicode = false
+
+[[test]]
+name = "wb13"
+regex = '(?:foo|bar|[A-Z])\b'
+haystack = "foo"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb14"
+regex = '(?:foo|bar|[A-Z])\b'
+haystack = "foo\n"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb15"
+regex = '\b(?:foo|bar|[A-Z])'
+haystack = "foo"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb16"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "X"
+matches = [[0, 1]]
+unicode = false
+
+[[test]]
+name = "wb17"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "XY"
+matches = []
+unicode = false
+
+[[test]]
+name = "wb18"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "bar"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb19"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "foo"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb20"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "foo\n"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb21"
+regex = '\b(?:foo|bar|[A-Z])\b'
+haystack = "ffoo bbar N x"
+matches = [[10, 11]]
+unicode = false
+
+[[test]]
+name = "wb22"
+regex = '\b(?:fo|foo)\b'
+haystack = "fo"
+matches = [[0, 2]]
+unicode = false
+
+[[test]]
+name = "wb23"
+regex = '\b(?:fo|foo)\b'
+haystack = "foo"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb24"
+regex = '\b\b'
+haystack = ""
+matches = []
+unicode = false
+
+[[test]]
+name = "wb25"
+regex = '\b\b'
+haystack = "a"
+matches = [[0, 0], [1, 1]]
+unicode = false
+
+[[test]]
+name = "wb26"
+regex = '\b$'
+haystack = ""
+matches = []
+unicode = false
+
+[[test]]
+name = "wb27"
+regex = '\b$'
+haystack = "x"
+matches = [[1, 1]]
+unicode = false
+
+[[test]]
+name = "wb28"
+regex = '\b$'
+haystack = "y x"
+matches = [[3, 3]]
+unicode = false
+
+[[test]]
+name = "wb29"
+regex = '(?-u:\b).$'
+haystack = "x"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb30"
+regex = '^\b(?:fo|foo)\b'
+haystack = "fo"
+matches = [[0, 2]]
+unicode = false
+
+[[test]]
+name = "wb31"
+regex = '^\b(?:fo|foo)\b'
+haystack = "foo"
+matches = [[0, 3]]
+unicode = false
+
+[[test]]
+name = "wb32"
+regex = '^\b$'
+haystack = ""
+matches = []
+unicode = false
+
+[[test]]
+name = "wb33"
+regex = '^\b$'
+haystack = "x"
+matches = []
+unicode = false
+
+[[test]]
+name = "wb34"
+regex = '^(?-u:\b).$'
+haystack = "x"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb35"
+regex = '^(?-u:\b).(?-u:\b)$'
+haystack = "x"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb36"
+regex = '^^^^^\b$$$$$'
+haystack = ""
+matches = []
+unicode = false
+
+[[test]]
+name = "wb37"
+regex = '^^^^^(?-u:\b).$$$$$'
+haystack = "x"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb38"
+regex = '^^^^^\b$$$$$'
+haystack = "x"
+matches = []
+unicode = false
+
+[[test]]
+name = "wb39"
+regex = '^^^^^(?-u:\b\b\b).(?-u:\b\b\b)$$$$$'
+haystack = "x"
+matches = [[0, 1]]
+
+[[test]]
+name = "wb40"
+regex = '(?-u:\b).+(?-u:\b)'
+haystack = "$$abc$$"
+matches = [[2, 5]]
+
+[[test]]
+name = "wb41"
+regex = '\b'
+haystack = "a b c"
+matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]
+unicode = false
+
+[[test]]
+name = "wb42"
+regex = '\bfoo\b'
+haystack = "zzz foo zzz"
+matches = [[4, 7]]
+unicode = false
+
+[[test]]
+name = "wb43"
+regex = '\b^'
+haystack = "ab"
+matches = [[0, 0]]
+unicode = false
+
+[[test]]
+name = "wb44"
+regex = '$\b'
+haystack = "ab"
+matches = [[2, 2]]
+unicode = false
+
+
+# Tests for \B. Note that \B is not allowed if UTF-8 mode is enabled, so we
+# have to disable it for most of these tests. This is because \B can match at
+# non-UTF-8 boundaries.
+[[test]]
+name = "nb1"
+regex = '\Bfoo\B'
+haystack = "n foo xfoox that"
+matches = [[7, 10]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb2"
+regex = 'a\B'
+haystack = "faoa x"
+matches = [[1, 2]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb3"
+regex = '\Bbar'
+haystack = "bar x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb4"
+regex = '\Bbar'
+haystack = "foo\nbar x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb5"
+regex = 'bar\B'
+haystack = "foobar"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb6"
+regex = 'bar\B'
+haystack = "foobar\nxxx"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb7"
+regex = '(?:foo|bar|[A-Z])\B'
+haystack = "foox"
+matches = [[0, 3]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb8"
+regex = '(?:foo|bar|[A-Z])\B'
+haystack = "foo\n"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb9"
+regex = '\B'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb10"
+regex = '\B'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb11"
+regex = '\B(?:foo|bar|[A-Z])'
+haystack = "foo"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb12"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "xXy"
+matches = [[1, 2]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb13"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "XY"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb14"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "XYZ"
+matches = [[1, 2]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb15"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "abara"
+matches = [[1, 4]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb16"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "xfoo_"
+matches = [[1, 4]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb17"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "xfoo\n"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb18"
+regex = '\B(?:foo|bar|[A-Z])\B'
+haystack = "foo bar vNX"
+matches = [[9, 10]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb19"
+regex = '\B(?:fo|foo)\B'
+haystack = "xfoo"
+matches = [[1, 3]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb20"
+regex = '\B(?:foo|fo)\B'
+haystack = "xfooo"
+matches = [[1, 4]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb21"
+regex = '\B\B'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb22"
+regex = '\B\B'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb23"
+regex = '\B$'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb24"
+regex = '\B$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb25"
+regex = '\B$'
+haystack = "y x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb26"
+regex = '\B.$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb27"
+regex = '^\B(?:fo|foo)\B'
+haystack = "fo"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb28"
+regex = '^\B(?:fo|foo)\B'
+haystack = "fo"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb29"
+regex = '^\B'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb30"
+regex = '^\B'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb31"
+regex = '^\B\B'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb32"
+regex = '^\B\B'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb33"
+regex = '^\B$'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb34"
+regex = '^\B$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb35"
+regex = '^\B.$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb36"
+regex = '^\B.\B$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb37"
+regex = '^^^^^\B$$$$$'
+haystack = ""
+matches = [[0, 0]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb38"
+regex = '^^^^^\B.$$$$$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+[[test]]
+name = "nb39"
+regex = '^^^^^\B$$$$$'
+haystack = "x"
+matches = []
+unicode = false
+utf8 = false
+
+
+# unicode1* and unicode2* work for both Unicode and ASCII because all matches
+# are reported as byte offsets, and « and » do not correspond to word
+# boundaries at either the character or byte level.
+[[test]]
+name = "unicode1"
+regex = '\bx\b'
+haystack = "«x"
+matches = [[2, 3]]
+
+[[test]]
+name = "unicode1-only-ascii"
+regex = '\bx\b'
+haystack = "«x"
+matches = [[2, 3]]
+unicode = false
+
+[[test]]
+name = "unicode2"
+regex = '\bx\b'
+haystack = "x»"
+matches = [[0, 1]]
+
+[[test]]
+name = "unicode2-only-ascii"
+regex = '\bx\b'
+haystack = "x»"
+matches = [[0, 1]]
+unicode = false
+
+# ASCII word boundaries are completely oblivious to Unicode characters, so
+# even though β is a character, an ASCII \b treats it as a word boundary
+# when it is adjacent to another ASCII character. (The ASCII \b only looks
+# at the leading byte of β.) For Unicode \b, the tests are precisely inverted.
+[[test]]
+name = "unicode3"
+regex = '\bx\b'
+haystack = 'áxβ'
+matches = []
+
+[[test]]
+name = "unicode3-only-ascii"
+regex = '\bx\b'
+haystack = 'áxβ'
+matches = [[2, 3]]
+unicode = false
+
+[[test]]
+name = "unicode4"
+regex = '\Bx\B'
+haystack = 'áxβ'
+matches = [[2, 3]]
+
+[[test]]
+name = "unicode4-only-ascii"
+regex = '\Bx\B'
+haystack = 'áxβ'
+matches = []
+unicode = false
+utf8 = false
+
+# The same as above, but with \b instead of \B as a sanity check.
+[[test]]
+name = "unicode5"
+regex = '\b'
+haystack = "0\U0007EF5E"
+matches = [[0, 0], [1, 1]]
+
+[[test]]
+name = "unicode5-only-ascii"
+regex = '\b'
+haystack = "0\U0007EF5E"
+matches = [[0, 0], [1, 1]]
+unicode = false
+utf8 = false
+
+[[test]]
+name = "unicode5-noutf8"
+regex = '\b'
+haystack = '0\xFF\xFF\xFF\xFF'
+matches = [[0, 0], [1, 1]]
+unescape = true
+utf8 = false
+
+[[test]]
+name = "unicode5-noutf8-only-ascii"
+regex = '\b'
+haystack = '0\xFF\xFF\xFF\xFF'
+matches = [[0, 0], [1, 1]]
+unescape = true
+unicode = false
+utf8 = false
+
+# Weird special case to ensure that ASCII \B treats each individual code unit
+# as a non-word byte. (The specific codepoint is irrelevant. It's an arbitrary
+# codepoint that uses 4 bytes in its UTF-8 encoding and is not a member of the
+# \w character class.)
+[[test]]
+name = "unicode5-not"
+regex = '\B'
+haystack = "0\U0007EF5E"
+matches = [[5, 5]]
+
+[[test]]
+name = "unicode5-not-only-ascii"
+regex = '\B'
+haystack = "0\U0007EF5E"
+matches = [[2, 2], [3, 3], [4, 4], [5, 5]]
+unicode = false
+utf8 = false
+
+# This gets no matches since \B only matches in the presence of valid UTF-8
+# when Unicode is enabled, even when UTF-8 mode is disabled.
+[[test]]
+name = "unicode5-not-noutf8"
+regex = '\B'
+haystack = '0\xFF\xFF\xFF\xFF'
+matches = []
+unescape = true
+utf8 = false
+
+# But this DOES get matches since \B in ASCII mode only looks at individual
+# bytes.
+[[test]]
+name = "unicode5-not-noutf8-only-ascii"
+regex = '\B'
+haystack = '0\xFF\xFF\xFF\xFF'
+matches = [[2, 2], [3, 3], [4, 4], [5, 5]]
+unescape = true
+unicode = false
+utf8 = false
+
+# Some tests of no particular significance.
+[[test]]
+name = "unicode6"
+regex = '\b[0-9]+\b'
+haystack = "foo 123 bar 456 quux 789"
+matches = [[4, 7], [12, 15], [21, 24]]
+
+[[test]]
+name = "unicode7"
+regex = '\b[0-9]+\b'
+haystack = "foo 123 bar a456 quux 789"
+matches = [[4, 7], [22, 25]]
+
+[[test]]
+name = "unicode8"
+regex = '\b[0-9]+\b'
+haystack = "foo 123 bar 456a quux 789"
+matches = [[4, 7], [22, 25]]
+
+# A variant of the problem described here:
+# https://github.com/google/re2/blob/89567f5de5b23bb5ad0c26cbafc10bdc7389d1fa/re2/dfa.cc#L658-L667
+[[test]]
+name = "alt-with-assertion-repetition"
+regex = '(?:\b|%)+'
+haystack = "z%"
+bounds = [1, 2]
+anchored = true
+matches = [[1, 1]]
diff --git a/tests/api.rs b/tests/api.rs
deleted file mode 100644
index c7250a8a3a..0000000000
--- a/tests/api.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-#[test]
-fn empty_regex_empty_match() {
-    let re = regex!("");
-    assert_eq!(vec![(0, 0)], findall!(re, ""));
-}
-
-#[test]
-fn empty_regex_nonempty_match() {
-    let re = regex!("");
-    assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc"));
-}
-
-#[test]
-fn one_zero_length_match() {
-    let re = regex!(r"[0-9]*");
-    assert_eq!(vec![(0, 0), (1, 2), (3, 4)], findall!(re, "a1b2"));
-}
-
-#[test]
-fn many_zero_length_match() {
-    let re = regex!(r"[0-9]*");
-    assert_eq!(
-        vec![(0, 0), (1, 2), (3, 3), (4, 4), (5, 6)],
-        findall!(re, "a1bbb2")
-    );
-}
-
-#[test]
-fn many_sequential_zero_length_match() {
-    let re = regex!(r"[0-9]?");
-    assert_eq!(
-        vec![(0, 0), (1, 2), (2, 3), (4, 5), (6, 6)],
-        findall!(re, "a12b3c")
-    );
-}
-
-#[test]
-fn quoted_bracket_set() {
-    let re = regex!(r"([\x{5b}\x{5d}])");
-    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
-    let re = regex!(r"([\[\]])");
-    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
-}
-
-#[test]
-fn first_range_starts_with_left_bracket() {
-    let re = regex!(r"([\[-z])");
-    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
-}
-
-#[test]
-fn range_ends_with_escape() {
-    let re = regex!(r"([\[-\x{5d}])");
-    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
-}
-
-#[test]
-fn empty_match_find_iter() {
-    let re = regex!(r".*?");
-    assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc"));
-}
-
-#[test]
-fn empty_match_captures_iter() {
-    let re = regex!(r".*?");
-    let ms: Vec<_> = re
-        .captures_iter(text!("abc"))
-        .map(|c| c.get(0).unwrap())
-        .map(|m| (m.start(), m.end()))
-        .collect();
-    assert_eq!(ms, vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
-}
-
-#[test]
-fn capture_names() {
-    let re = regex!(r"(.)(?P<a>.)");
-    assert_eq!(3, re.captures_len());
-    assert_eq!((3, Some(3)), re.capture_names().size_hint());
-    assert_eq!(
-        vec![None, None, Some("a")],
-        re.capture_names().collect::<Vec<_>>()
-    );
-}
-
-#[test]
-fn regex_string() {
-    assert_eq!(r"[a-zA-Z0-9]+", regex!(r"[a-zA-Z0-9]+").as_str());
-    assert_eq!(r"[a-zA-Z0-9]+", &format!("{}", regex!(r"[a-zA-Z0-9]+")));
-    assert_eq!(r"[a-zA-Z0-9]+", &format!("{:?}", regex!(r"[a-zA-Z0-9]+")));
-}
-
-#[test]
-fn capture_index() {
-    let re = regex!(r"^(?P<name>.+)$");
-    let cap = re.captures(t!("abc")).unwrap();
-    assert_eq!(&cap[0], t!("abc"));
-    assert_eq!(&cap[1], t!("abc"));
-    assert_eq!(&cap["name"], t!("abc"));
-}
-
-#[test]
-#[should_panic]
-#[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)]
-fn capture_index_panic_usize() {
-    let re = regex!(r"^(?P<name>.+)$");
-    let cap = re.captures(t!("abc")).unwrap();
-    let _ = cap[2];
-}
-
-#[test]
-#[should_panic]
-#[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)]
-fn capture_index_panic_name() {
-    let re = regex!(r"^(?P<name>.+)$");
-    let cap = re.captures(t!("abc")).unwrap();
-    let _ = cap["bad name"];
-}
-
-#[test]
-fn capture_index_lifetime() {
-    // This is a test of whether the types on `caps["..."]` are general
-    // enough. If not, this will fail to typecheck.
-    fn inner(s: &str) -> usize {
-        let re = regex!(r"(?P<number>[0-9]+)");
-        let caps = re.captures(t!(s)).unwrap();
-        caps["number"].len()
-    }
-    assert_eq!(3, inner("123"));
-}
-
-#[test]
-fn capture_misc() {
-    let re = regex!(r"(.)(?P<a>a)?(.)(?P<b>.)");
-    let cap = re.captures(t!("abc")).unwrap();
-
-    assert_eq!(5, cap.len());
-
-    assert_eq!((0, 3), {
-        let m = cap.get(0).unwrap();
-        (m.start(), m.end())
-    });
-    assert_eq!(None, cap.get(2));
-    assert_eq!((2, 3), {
-        let m = cap.get(4).unwrap();
-        (m.start(), m.end())
-    });
-
-    assert_eq!(t!("abc"), match_text!(cap.get(0).unwrap()));
-    assert_eq!(None, cap.get(2));
-    assert_eq!(t!("c"), match_text!(cap.get(4).unwrap()));
-
-    assert_eq!(None, cap.name("a"));
-    assert_eq!(t!("c"), match_text!(cap.name("b").unwrap()));
-}
-
-#[test]
-fn sub_capture_matches() {
-    let re = regex!(r"([a-z])(([a-z])|([0-9]))");
-    let cap = re.captures(t!("a5")).unwrap();
-    let subs: Vec<_> = cap.iter().collect();
-
-    assert_eq!(5, subs.len());
-    assert!(subs[0].is_some());
-    assert!(subs[1].is_some());
-    assert!(subs[2].is_some());
-    assert!(subs[3].is_none());
-    assert!(subs[4].is_some());
-
-    assert_eq!(t!("a5"), match_text!(subs[0].unwrap()));
-    assert_eq!(t!("a"), match_text!(subs[1].unwrap()));
-    assert_eq!(t!("5"), match_text!(subs[2].unwrap()));
-    assert_eq!(t!("5"), match_text!(subs[4].unwrap()));
-}
-
-expand!(expand1, r"(?-u)(?P<foo>\w+)", "abc", "$foo", "abc");
-expand!(expand2, r"(?-u)(?P<foo>\w+)", "abc", "$0", "abc");
-expand!(expand3, r"(?-u)(?P<foo>\w+)", "abc", "$1", "abc");
-expand!(expand4, r"(?-u)(?P<foo>\w+)", "abc", "$$1", "$1");
-expand!(expand5, r"(?-u)(?P<foo>\w+)", "abc", "$$foo", "$foo");
-expand!(expand6, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$b$a", "123abc");
-expand!(expand7, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "z$bz$az", "z");
-expand!(
-    expand8,
-    r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)",
-    "abc 123",
-    ".$b.$a.",
-    ".123.abc."
-);
-expand!(
-    expand9,
-    r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)",
-    "abc 123",
-    " $b $a ",
-    " 123 abc "
-);
-expand!(expand10, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$bz$az", "");
-
-expand!(expand_name1, r"%(?P<Z>[a-z]+)", "%abc", "$Z%", "abc%");
-expand!(expand_name2, r"\[(?P<Z>[a-z]+)", "[abc", "$Z[", "abc[");
-expand!(expand_name3, r"\{(?P<Z>[a-z]+)", "{abc", "$Z{", "abc{");
-expand!(expand_name4, r"\}(?P<Z>[a-z]+)", "}abc", "$Z}", "abc}");
-expand!(expand_name5, r"%([a-z]+)", "%abc", "$1a%", "%");
-expand!(expand_name6, r"%([a-z]+)", "%abc", "${1}a%", "abca%");
-expand!(expand_name7, r"\[(?P<Z[>[a-z]+)", "[abc", "${Z[}[", "abc[");
-expand!(expand_name8, r"\[(?P<Z[>[a-z]+)", "[abc", "${foo}[", "[");
-expand!(expand_name9, r"\[(?P<Z[>[a-z]+)", "[abc", "${1a}[", "[");
-expand!(expand_name10, r"\[(?P<Z[>[a-z]+)", "[abc", "${#}[", "[");
-expand!(expand_name11, r"\[(?P<Z[>[a-z]+)", "[abc", "${$$}[", "[");
-
-split!(
-    split1,
-    r"(?-u)\s+",
-    "a b\nc\td\n\t e",
-    &[t!("a"), t!("b"), t!("c"), t!("d"), t!("e")]
-);
-split!(
-    split2,
-    r"(?-u)\b",
-    "a b c",
-    &[t!(""), t!("a"), t!(" "), t!("b"), t!(" "), t!("c"), t!("")]
-);
-split!(split3, r"a$", "a", &[t!(""), t!("")]);
-split!(split_none, r"-", r"a", &[t!("a")]);
-split!(split_trailing_blank, r"-", r"a-", &[t!("a"), t!("")]);
-split!(split_trailing_blanks, r"-", r"a--", &[t!("a"), t!(""), t!("")]);
-split!(split_empty, r"-", r"", &[t!("")]);
-
-splitn!(splitn_below_limit, r"-", r"a", 2, &[t!("a")]);
-splitn!(splitn_at_limit, r"-", r"a-b", 2, &[t!("a"), t!("b")]);
-splitn!(splitn_above_limit, r"-", r"a-b-c", 2, &[t!("a"), t!("b-c")]);
-splitn!(splitn_zero_limit, r"-", r"a-b", 0, empty_vec!());
-splitn!(splitn_trailing_blank, r"-", r"a-", 2, &[t!("a"), t!("")]);
-splitn!(splitn_trailing_separator, r"-", r"a--", 2, &[t!("a"), t!("-")]);
-splitn!(splitn_empty, r"-", r"", 1, &[t!("")]);
diff --git a/tests/api_str.rs b/tests/api_str.rs
deleted file mode 100644
index 480116da73..0000000000
--- a/tests/api_str.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// These tests don't really make sense with the bytes API, so we only test them
-// on the Unicode API.
-
-#[test]
-fn empty_match_unicode_find_iter() {
-    // Tests that we still yield byte ranges at valid UTF-8 sequence boundaries
-    // even when we're susceptible to empty width matches.
-    let re = regex!(r".*?");
-    assert_eq!(
-        vec![(0, 0), (3, 3), (4, 4), (7, 7), (8, 8)],
-        findall!(re, "Ⅰ1Ⅱ2")
-    );
-}
-
-#[test]
-fn empty_match_unicode_captures_iter() {
-    // Same as empty_match_unicode_find_iter, but tests capture iteration.
-    let re = regex!(r".*?");
-    let ms: Vec<_> = re
-        .captures_iter(text!("Ⅰ1Ⅱ2"))
-        .map(|c| c.get(0).unwrap())
-        .map(|m| (m.start(), m.end()))
-        .collect();
-    assert_eq!(vec![(0, 0), (3, 3), (4, 4), (7, 7), (8, 8)], ms);
-}
-
-#[test]
-fn match_as_str() {
-    let re = regex!(r"fo+");
-    let caps = re.captures("barfoobar").unwrap();
-    assert_eq!(caps.get(0).map(|m| m.as_str()), Some("foo"));
-    assert_eq!(caps.get(0).map(From::from), Some("foo"));
-    assert_eq!(caps.get(0).map(Into::into), Some("foo"));
-}
diff --git a/tests/bytes.rs b/tests/bytes.rs
deleted file mode 100644
index d05f138edf..0000000000
--- a/tests/bytes.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-// These are tests specifically crafted for regexes that can match arbitrary
-// bytes.
-
-// A silly wrapper to make it possible to write and match raw bytes.
-struct R<'a>(&'a [u8]);
-impl<'a> R<'a> {
-    fn as_bytes(&self) -> &'a [u8] {
-        self.0
-    }
-}
-
-mat!(word_boundary, r"(?-u) \b", " δ", None);
-#[cfg(feature = "unicode-perl")]
-mat!(word_boundary_unicode, r" \b", " δ", Some((0, 1)));
-mat!(word_not_boundary, r"(?-u) \B", " δ", Some((0, 1)));
-#[cfg(feature = "unicode-perl")]
-mat!(word_not_boundary_unicode, r" \B", " δ", None);
-
-mat!(perl_w_ascii, r"(?-u)\w+", "aδ", Some((0, 1)));
-#[cfg(feature = "unicode-perl")]
-mat!(perl_w_unicode, r"\w+", "aδ", Some((0, 3)));
-mat!(perl_d_ascii, r"(?-u)\d+", "1२३9", Some((0, 1)));
-#[cfg(feature = "unicode-perl")]
-mat!(perl_d_unicode, r"\d+", "1२३9", Some((0, 8)));
-mat!(perl_s_ascii, r"(?-u)\s+", " \u{1680}", Some((0, 1)));
-#[cfg(feature = "unicode-perl")]
-mat!(perl_s_unicode, r"\s+", " \u{1680}", Some((0, 4)));
-
-// The first `(.+)` matches two Unicode codepoints, but can't match the 5th
-// byte, which isn't valid UTF-8. The second (byte based) `(.+)` takes over and
-// matches.
-mat!(
-    mixed1,
-    r"(.+)(?-u)(.+)",
-    R(b"\xCE\x93\xCE\x94\xFF"),
-    Some((0, 5)),
-    Some((0, 4)),
-    Some((4, 5))
-);
-
-mat!(case_ascii_one, r"(?i-u)a", "A", Some((0, 1)));
-mat!(case_ascii_class, r"(?i-u)[a-z]+", "AaAaA", Some((0, 5)));
-#[cfg(feature = "unicode-case")]
-mat!(case_unicode, r"(?i)[a-z]+", "aA\u{212A}aA", Some((0, 7)));
-mat!(case_not_unicode, r"(?i-u)[a-z]+", "aA\u{212A}aA", Some((0, 2)));
-
-mat!(negate_unicode, r"[^a]", "δ", Some((0, 2)));
-mat!(negate_not_unicode, r"(?-u)[^a]", "δ", Some((0, 1)));
-
-// This doesn't match in a normal Unicode regex because the implicit preceding
-// `.*?` is Unicode aware.
-mat!(dotstar_prefix_not_unicode1, r"(?-u)a", R(b"\xFFa"), Some((1, 2)));
-mat!(dotstar_prefix_not_unicode2, r"a", R(b"\xFFa"), Some((1, 2)));
-
-// Have fun with null bytes.
-mat!(
-    null_bytes,
-    r"(?-u)(?P<cstr>[^\x00]+)\x00",
-    R(b"foo\x00"),
-    Some((0, 4)),
-    Some((0, 3))
-);
-
-// Test that lookahead operators work properly in the face of invalid UTF-8.
-// See: https://github.com/rust-lang/regex/issues/277
-matiter!(
-    invalidutf8_anchor1,
-    r"(?-u)\xcc?^",
-    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
-    (0, 0)
-);
-matiter!(
-    invalidutf8_anchor2,
-    r"(?-u)^\xf7|4\xff\d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########[] d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########\[] #####\x80\S7|$",
-    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
-    (22, 22)
-);
-matiter!(
-    invalidutf8_anchor3,
-    r"(?-u)^|ddp\xff\xffdddddlQd@\x80",
-    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
-    (0, 0)
-);
-
-// See https://github.com/rust-lang/regex/issues/303
-#[test]
-fn negated_full_byte_range() {
-    assert!(::regex::bytes::Regex::new(r#"(?-u)[^\x00-\xff]"#).is_err());
-}
-
-matiter!(word_boundary_ascii1, r"(?-u:\B)x(?-u:\B)", "áxβ");
-matiter!(
-    word_boundary_ascii2,
-    r"(?-u:\B)",
-    "0\u{7EF5E}",
-    (2, 2),
-    (3, 3),
-    (4, 4),
-    (5, 5)
-);
-
-// See: https://github.com/rust-lang/regex/issues/264
-mat!(ascii_boundary_no_capture, r"(?-u)\B", "\u{28f3e}", Some((0, 0)));
-mat!(ascii_boundary_capture, r"(?-u)(\B)", "\u{28f3e}", Some((0, 0)));
-
-// See: https://github.com/rust-lang/regex/issues/271
-mat!(end_not_wb, r"$(?-u:\B)", "\u{5c124}\u{b576c}", Some((8, 8)));
diff --git a/tests/consistent.rs b/tests/consistent.rs
deleted file mode 100644
index 722f2a51a0..0000000000
--- a/tests/consistent.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use regex::internal::ExecBuilder;
-
-/// Given a regex, check if all of the backends produce the same
-/// results on a number of different inputs.
-///
-/// For now this just throws quickcheck at the problem, which
-/// is not very good because it only really tests half of the
-/// problem space. It is pretty unlikely that a random string
-/// will match any given regex, so this will probably just
-/// be checking that the different backends fail in the same
-/// way. This is still worthwhile to test, but is definitely not
-/// the whole story.
-///
-/// TODO(ethan): In order to cover the other half of the problem
-/// space, we should generate a random matching string by inspecting
-/// the AST of the input regex. The right way to do this probably
-/// involves adding a custom Arbitrary instance around a couple
-/// of newtypes. That way we can respect the quickcheck size hinting
-/// and shrinking and whatnot.
-pub fn backends_are_consistent(re: &str) -> Result<u64, String> {
-    let standard_backends = vec![
-        (
-            "bounded_backtracking_re",
-            ExecBuilder::new(re)
-                .bounded_backtracking()
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "pikevm_re",
-            ExecBuilder::new(re)
-                .nfa()
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "default_re",
-            ExecBuilder::new(re)
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-    ];
-
-    let utf8bytes_backends = vec![
-        (
-            "bounded_backtracking_utf8bytes_re",
-            ExecBuilder::new(re)
-                .bounded_backtracking()
-                .bytes(true)
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "pikevm_utf8bytes_re",
-            ExecBuilder::new(re)
-                .nfa()
-                .bytes(true)
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "default_utf8bytes_re",
-            ExecBuilder::new(re)
-                .bytes(true)
-                .build()
-                .map(|exec| exec.into_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-    ];
-
-    let bytes_backends = vec![
-        (
-            "bounded_backtracking_bytes_re",
-            ExecBuilder::new(re)
-                .bounded_backtracking()
-                .only_utf8(false)
-                .build()
-                .map(|exec| exec.into_byte_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "pikevm_bytes_re",
-            ExecBuilder::new(re)
-                .nfa()
-                .only_utf8(false)
-                .build()
-                .map(|exec| exec.into_byte_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-        (
-            "default_bytes_re",
-            ExecBuilder::new(re)
-                .only_utf8(false)
-                .build()
-                .map(|exec| exec.into_byte_regex())
-                .map_err(|err| format!("{}", err))?,
-        ),
-    ];
-
-    Ok(string_checker::check_backends(&standard_backends)?
-        + string_checker::check_backends(&utf8bytes_backends)?
-        + bytes_checker::check_backends(&bytes_backends)?)
-}
-
-//
-// A consistency checker parameterized by the input type (&str or &[u8]).
-//
-
-macro_rules! checker {
-    ($module_name:ident, $regex_type:path, $mk_input:expr) => {
-        mod $module_name {
-            use quickcheck;
-            use quickcheck::{Arbitrary, TestResult};
-
-            pub fn check_backends(
-                backends: &[(&str, $regex_type)],
-            ) -> Result<u64, String> {
-                let mut total_passed = 0;
-                for regex in backends[1..].iter() {
-                    total_passed += quickcheck_regex_eq(&backends[0], regex)?;
-                }
-
-                Ok(total_passed)
-            }
-
-            fn quickcheck_regex_eq(
-                &(name1, ref re1): &(&str, $regex_type),
-                &(name2, ref re2): &(&str, $regex_type),
-            ) -> Result<u64, String> {
-                quickcheck::QuickCheck::new()
-                    .quicktest(RegexEqualityTest::new(
-                        re1.clone(),
-                        re2.clone(),
-                    ))
-                    .map_err(|err| {
-                        format!(
-                            "{}(/{}/) and {}(/{}/) are inconsistent.\
-                             QuickCheck Err: {:?}",
-                            name1, re1, name2, re2, err
-                        )
-                    })
-            }
-
-            struct RegexEqualityTest {
-                re1: $regex_type,
-                re2: $regex_type,
-            }
-            impl RegexEqualityTest {
-                fn new(re1: $regex_type, re2: $regex_type) -> Self {
-                    RegexEqualityTest { re1: re1, re2: re2 }
-                }
-            }
-
-            impl quickcheck::Testable for RegexEqualityTest {
-                fn result(&self, gen: &mut quickcheck::Gen) -> TestResult {
-                    let input = $mk_input(gen);
-                    let input = &input;
-
-                    if self.re1.find(&input) != self.re2.find(input) {
-                        return TestResult::error(format!(
-                            "find mismatch input={:?}",
-                            input
-                        ));
-                    }
-
-                    let cap1 = self.re1.captures(input);
-                    let cap2 = self.re2.captures(input);
-                    match (cap1, cap2) {
-                        (None, None) => {}
-                        (Some(cap1), Some(cap2)) => {
-                            for (c1, c2) in cap1.iter().zip(cap2.iter()) {
-                                if c1 != c2 {
-                                    return TestResult::error(format!(
-                                        "captures mismatch input={:?}",
-                                        input
-                                    ));
-                                }
-                            }
-                        }
-                        _ => {
-                            return TestResult::error(format!(
-                                "captures mismatch input={:?}",
-                                input
-                            ))
-                        }
-                    }
-
-                    let fi1 = self.re1.find_iter(input);
-                    let fi2 = self.re2.find_iter(input);
-                    for (m1, m2) in fi1.zip(fi2) {
-                        if m1 != m2 {
-                            return TestResult::error(format!(
-                                "find_iter mismatch input={:?}",
-                                input
-                            ));
-                        }
-                    }
-
-                    let ci1 = self.re1.captures_iter(input);
-                    let ci2 = self.re2.captures_iter(input);
-                    for (cap1, cap2) in ci1.zip(ci2) {
-                        for (c1, c2) in cap1.iter().zip(cap2.iter()) {
-                            if c1 != c2 {
-                                return TestResult::error(format!(
-                                    "captures_iter mismatch input={:?}",
-                                    input
-                                ));
-                            }
-                        }
-                    }
-
-                    let s1 = self.re1.split(input);
-                    let s2 = self.re2.split(input);
-                    for (chunk1, chunk2) in s1.zip(s2) {
-                        if chunk1 != chunk2 {
-                            return TestResult::error(format!(
-                                "split mismatch input={:?}",
-                                input
-                            ));
-                        }
-                    }
-
-                    TestResult::from_bool(true)
-                }
-            }
-        } // mod
-    }; // rule case
-} // macro_rules!
-
-checker!(string_checker, ::regex::Regex, |gen| String::arbitrary(gen));
-checker!(bytes_checker, ::regex::bytes::Regex, |gen| Vec::<u8>::arbitrary(
-    gen
-));
diff --git a/tests/crates_regex.rs b/tests/crates_regex.rs
deleted file mode 100644
index 200ec27b2d..0000000000
--- a/tests/crates_regex.rs
+++ /dev/null
@@ -1,3287 +0,0 @@
-// DO NOT EDIT. Automatically generated by 'scripts/scrape_crates_io.py'
-// on 2018-06-20 09:56:32.820354.
-
-// autoshutdown-0.1.0: r"\s*(\d+)(\w)\s*"
-consistent!(autoshutdown_0, r"\s*(\d+)(\w)\s*");
-
-// epub-1.1.1: r"/"
-consistent!(epub_0, r"/");
-
-// rpi-info-0.2.0: "^Revision\t+: ([0-9a-fA-F]+)"
-consistent!(rpi_info_0, "^Revision\t+: ([0-9a-fA-F]+)");
-
-// rpi-info-0.2.0: "Serial\t+: ([0-9a-fA-F]+)"
-consistent!(rpi_info_1, "Serial\t+: ([0-9a-fA-F]+)");
-
-// pnet_macros-0.21.0: r"^u([0-9]+)(be|le|he)?$"
-consistent!(pnet_macros_0, r"^u([0-9]+)(be|le|he)?$");
-
-// iban_validate-1.0.3: r"^[A-Z]{2}\d{2}[A-Z\d]{1,30}$"
-consistent!(iban_validate_0, r"^[A-Z]{2}\d{2}[A-Z\d]{1,30}$");
-
-// markifier-0.1.0: r".*\[(?P<percent>.+)%.*\].*"
-consistent!(markifier_0, r".*\[(?P<percent>.+)%.*\].*");
-
-// mallumo-0.3.0: r"(#include) (\S*)(.*)"
-consistent!(mallumo_0, r"(#include) (\S*)(.*)");
-
-// mallumo-0.3.0: r"(ERROR: \d+:)(\d+)(: )(.+)"
-consistent!(mallumo_1, r"(ERROR: \d+:)(\d+)(: )(.+)");
-
-// mallumo-0.3.0: r"(\d+\()(\d+)(?:\) : )(.+)"
-consistent!(mallumo_2, r"(\d+\()(\d+)(?:\) : )(.+)");
-
-// magnet_more-0.0.1: r"(.+?)(\[.*?\])?"
-consistent!(magnet_more_0, r"(.+?)(\[.*?\])?");
-
-// magnet_app-0.0.1: r":(?P<k>[a-zA-Z_]+)"
-consistent!(magnet_app_0, r":(?P<k>[a-zA-Z_]+)");
-
-// yubibomb-0.2.0: r"^\d{6}(?:\s*,\s*\d{6})*$"
-consistent!(yubibomb_0, r"^\d{6}(?:\s*,\s*\d{6})*$");
-
-// multirust-rs-0.0.4: r"[\\/]([^\\/?]+)(\?.*)?$"
-consistent!(multirust_rs_0, r"[\\/]([^\\/?]+)(\?.*)?$");
-
-// hueclient-0.3.2: "\"[a-z]*\":null"
-consistent!(hueclient_0, "\"[a-z]*\":null");
-
-// hueclient-0.3.2: ",+"
-consistent!(hueclient_1, ",+");
-
-// hueclient-0.3.2: ",\\}"
-consistent!(hueclient_2, ",\\}");
-
-// hueclient-0.3.2: "\\{,"
-consistent!(hueclient_3, "\\{,");
-
-// aerial-0.1.0: r"[a-zA-Z_\$][a-zA-Z_0-9]*"
-consistent!(aerial_0, r"[a-zA-Z_\$][a-zA-Z_0-9]*");
-
-// aerial-0.1.0: r"thi[sng]+"
-consistent!(aerial_1, r"thi[sng]+");
-
-// rvue-0.1.0: r"(.+)\s+\((.+?)\)"
-consistent!(rvue_0, r"(.+)\s+\((.+?)\)");
-
-// rvue-0.1.0: r"([\d\.]+)\s*out\s*of\s*([\d\.]+)"
-consistent!(rvue_1, r"([\d\.]+)\s*out\s*of\s*([\d\.]+)");
-
-// rvue-0.1.0: r"^([\d\.]+)\s*(?:\(\))?$"
-consistent!(rvue_2, r"^([\d\.]+)\s*(?:\(\))?$");
-
-// rvue-0.1.0: r"([\d\.]+)\s*Points\s*Possible"
-consistent!(rvue_3, r"([\d\.]+)\s*Points\s*Possible");
-
-// rvue-0.1.0: r"([\d\.]+)\s*/\s*([\d\.]+)"
-consistent!(rvue_4, r"([\d\.]+)\s*/\s*([\d\.]+)");
-
-// rvsim-0.1.0: r"_?([_a-z0-9]+)\s*:\s*([_a-z0-9]+)\s*[,)]"
-consistent!(rvsim_0, r"_?([_a-z0-9]+)\s*:\s*([_a-z0-9]+)\s*[,)]");
-
-// nereon-0.1.4: "(.*[^\\\\])\\{\\}(.*)"
-consistent!(nereon_0, "(.*[^\\\\])\\{\\}(.*)");
-
-// next_episode-0.3.0: r"((?i)^(.+).s(\d+)e(\d+).*)$"
-consistent!(next_episode_0, r"((?i)^(.+).s(\d+)e(\d+).*)$");
-
-// migrant_lib-0.19.2: r"[^a-z0-9-]+"
-consistent!(migrant_lib_0, r"[^a-z0-9-]+");
-
-// migrant_lib-0.19.2: r"[0-9]{14}_[a-z0-9-]+"
-consistent!(migrant_lib_1, r"[0-9]{14}_[a-z0-9-]+");
-
-// migrant_lib-0.19.2: r"([0-9]{14}_)?[a-z0-9-]+"
-consistent!(migrant_lib_2, r"([0-9]{14}_)?[a-z0-9-]+");
-
-// minipre-0.2.0: "$_"
-consistent!(minipre_0, "$_");
-
-// minifier-0.0.13: r">\s+<"
-consistent!(minifier_0, r">\s+<");
-
-// minifier-0.0.13: r"\s{2,}|[\r\n]"
-consistent!(minifier_1, r"\s{2,}|[\r\n]");
-
-// minifier-0.0.13: r"<(style|script)[\w|\s].*?>"
-consistent!(minifier_2, r"<(style|script)[\w|\s].*?>");
-
-// minifier-0.0.13: "<!--(.|\n)*?-->"
-consistent!(minifier_3, "<!--(.|\n)*?-->");
-
-// minifier-0.0.13: r"<\w.*?>"
-consistent!(minifier_4, r"<\w.*?>");
-
-// minifier-0.0.13: r" \s+|\s +"
-consistent!(minifier_5, r" \s+|\s +");
-
-// minifier-0.0.13: r"\w\s+\w"
-consistent!(minifier_6, r"\w\s+\w");
-
-// minifier-0.0.13: r"'\s+>"
-consistent!(minifier_7, r"'\s+>");
-
-// minifier-0.0.13: r"\d\s+>"
-consistent!(minifier_8, r"\d\s+>");
-
-// ggp-rs-0.1.2: r"(?P<relation>\([^)]+\))|(?P<prop>[a-zA-Z0-9_]+)"
-consistent!(ggp_rs_0, r"(?P<relation>\([^)]+\))|(?P<prop>[a-zA-Z0-9_]+)");
-
-// ggp-rs-0.1.2: r"\((.*)\)."
-consistent!(ggp_rs_1, r"\((.*)\).");
-
-// poe-superfilter-0.2.0: "[A-Za-z0-9_]"
-consistent!(poe_superfilter_0, "[A-Za-z0-9_]");
-
-// poke-a-mango-0.5.0: r"(\d+)x(\d+)"
-consistent!(poke_a_mango_0, r"(\d+)x(\d+)");
-
-// pop3-rs-0.1.0: r"(?P<nmsg>\d+) (?P<size>\d+)"
-consistent!(pop3_rs_0, r"(?P<nmsg>\d+) (?P<size>\d+)");
-
-// pop3-rs-0.1.0: r"(?P<msgid>\d+) (?P<uidl>[\x21-\x7E]{1,70})"
-consistent!(pop3_rs_1, r"(?P<msgid>\d+) (?P<uidl>[\x21-\x7E]{1,70})");
-
-// pop3-rs-0.1.0: r"(<.*>)\r\n$"
-consistent!(pop3_rs_2, r"(<.*>)\r\n$");
-
-// pop3-rs-0.1.0: r"^(?P<status>\+OK|-ERR) (?P<statustext>.*)"
-consistent!(pop3_rs_3, r"^(?P<status>\+OK|-ERR) (?P<statustext>.*)");
-
-// pop3-1.0.6: r"^\.\r\n$"
-consistent!(pop3_0, r"^\.\r\n$");
-
-// pop3-1.0.6: r"\+OK(.*)"
-consistent!(pop3_1, r"\+OK(.*)");
-
-// pop3-1.0.6: r"-ERR(.*)"
-consistent!(pop3_2, r"-ERR(.*)");
-
-// pop3-1.0.6: r"\+OK (\d+) (\d+)\r\n"
-consistent!(pop3_3, r"\+OK (\d+) (\d+)\r\n");
-
-// pop3-1.0.6: r"(\d+) ([\x21-\x7e]+)\r\n"
-consistent!(pop3_4, r"(\d+) ([\x21-\x7e]+)\r\n");
-
-// pop3-1.0.6: r"\+OK (\d+) ([\x21-\x7e]+)\r\n"
-consistent!(pop3_5, r"\+OK (\d+) ([\x21-\x7e]+)\r\n");
-
-// pop3-1.0.6: r"(\d+) (\d+)\r\n"
-consistent!(pop3_6, r"(\d+) (\d+)\r\n");
-
-// pop3-1.0.6: r"\+OK (\d+) (\d+)\r\n"
-consistent!(pop3_7, r"\+OK (\d+) (\d+)\r\n");
-
-// polk-1.1.3: "github:(\\w+)/?(\\w+)?"
-consistent!(polk_0, "github:(\\w+)/?(\\w+)?");
-
-// geochunk-0.1.5: "^[0-9]{5}"
-consistent!(geochunk_0, "^[0-9]{5}");
-
-// generic-dns-update-1.1.4: r"((?:(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?)\.){3}(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?))"
-consistent!(generic_dns_update_0, r"((?:(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?)\.){3}(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?))");
-
-// generic-dns-update-1.1.4: r"((([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}:[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){5}:([0-9A-Fa-f]{1,4}:)?[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){4}:([0-9A-Fa-f]{1,4}:){0,2}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){3}:([0-9A-Fa-f]{1,4}:){0,3}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){2}:([0-9A-Fa-f]{1,4}:){0,4}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(([0-9A-Fa-f]{1,4}:){0,5}:((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(::([0-9A-Fa-f]{1,4}:){0,5}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|([0-9A-Fa-f]{1,4}::([0-9A-Fa-f]{1,4}:){0,5}[0-9A-Fa-f]{1,4})|(::([0-9A-Fa-f]{1,4}:){0,6}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){1,7}:))"
-consistent!(generic_dns_update_1, r"((([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}:[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){5}:([0-9A-Fa-f]{1,4}:)?[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){4}:([0-9A-Fa-f]{1,4}:){0,2}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){3}:([0-9A-Fa-f]{1,4}:){0,3}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){2}:([0-9A-Fa-f]{1,4}:){0,4}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(([0-9A-Fa-f]{1,4}:){0,5}:((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(::([0-9A-Fa-f]{1,4}:){0,5}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|([0-9A-Fa-f]{1,4}::([0-9A-Fa-f]{1,4}:){0,5}[0-9A-Fa-f]{1,4})|(::([0-9A-Fa-f]{1,4}:){0,6}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){1,7}:))");
-
-// generic-dns-update-1.1.4: r"<value><string>([0-9.]*)</string></value>"
-consistent!(
-    generic_dns_update_2,
-    r"<value><string>([0-9.]*)</string></value>"
-);
-
-// generic-dns-update-1.1.4: r"<int>([0-9]+)</int>"
-consistent!(generic_dns_update_3, r"<int>([0-9]+)</int>");
-
-// generic-dns-update-1.1.4: r"<int>([0-9]+)</int>"
-consistent!(generic_dns_update_4, r"<int>([0-9]+)</int>");
-
-// generic-dns-update-1.1.4: r"<boolean>([0-1]*)</boolean>"
-consistent!(generic_dns_update_5, r"<boolean>([0-1]*)</boolean>");
-
-// generate-nix-pkg-0.3.0: r"(\d*)\.(\d*)\.(\d*)(-(\S*))?"
-consistent!(generate_nix_pkg_0, r"(\d*)\.(\d*)\.(\d*)(-(\S*))?");
-
-// generate-nix-pkg-0.3.0: r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?"
-consistent!(generate_nix_pkg_1, r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?");
-
-// genact-0.6.0: r"arch/([a-z0-9_])+/"
-consistent!(genact_0, r"arch/([a-z0-9_])+/");
-
-// genact-0.6.0: r"arch/([a-z0-9_])+/"
-consistent!(genact_1, r"arch/([a-z0-9_])+/");
-
-// cron_rs-0.1.6: r"^\s*((\*(/\d+)?)|[0-9-,/]+)(\s+((\*(/\d+)?)|[0-9-,/]+)){4,5}\s*$"
-consistent!(
-    cron_rs_0,
-    r"^\s*((\*(/\d+)?)|[0-9-,/]+)(\s+((\*(/\d+)?)|[0-9-,/]+)){4,5}\s*$"
-);
-
-// systemfd-0.3.0: r"^([a-zA-Z]+)::(.+)$"
-consistent!(systemfd_0, r"^([a-zA-Z]+)::(.+)$");
-
-// symbolic-debuginfo-5.0.2: "__?hidden#\\d+_"
-consistent!(symbolic_debuginfo_0, "__?hidden#\\d+_");
-
-// symbolic-minidump-5.0.2: r"^Linux ([^ ]+) (.*) \w+(?: GNU/Linux)?$"
-consistent!(symbolic_minidump_0, r"^Linux ([^ ]+) (.*) \w+(?: GNU/Linux)?$");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\#)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+"
-consistent!(graphql_idl_parser_0, "^(?u:\\#)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+");
-
-// graphql-idl-parser-0.1.1: "^(?u:=)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+"
-consistent!(graphql_idl_parser_1, "^(?u:=)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+");
-
-// graphql-idl-parser-0.1.1: "^(?u:[A-Z_-_a-z])(?u:[0-9A-Z_-_a-z])*"
-consistent!(graphql_idl_parser_2, "^(?u:[A-Z_-_a-z])(?u:[0-9A-Z_-_a-z])*");
-
-// graphql-idl-parser-0.1.1: "^(?u:!)"
-consistent!(graphql_idl_parser_3, "^(?u:!)");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\()"
-consistent!(graphql_idl_parser_4, "^(?u:\\()");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\))"
-consistent!(graphql_idl_parser_5, "^(?u:\\))");
-
-// graphql-idl-parser-0.1.1: "^(?u:,)"
-consistent!(graphql_idl_parser_6, "^(?u:,)");
-
-// graphql-idl-parser-0.1.1: "^(?u::)"
-consistent!(graphql_idl_parser_7, "^(?u::)");
-
-// graphql-idl-parser-0.1.1: "^(?u:@)"
-consistent!(graphql_idl_parser_8, "^(?u:@)");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\[)"
-consistent!(graphql_idl_parser_9, "^(?u:\\[)");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\])"
-consistent!(graphql_idl_parser_10, "^(?u:\\])");
-
-// graphql-idl-parser-0.1.1: "^(?u:enum)"
-consistent!(graphql_idl_parser_11, "^(?u:enum)");
-
-// graphql-idl-parser-0.1.1: "^(?u:implements)"
-consistent!(graphql_idl_parser_12, "^(?u:implements)");
-
-// graphql-idl-parser-0.1.1: "^(?u:input)"
-consistent!(graphql_idl_parser_13, "^(?u:input)");
-
-// graphql-idl-parser-0.1.1: "^(?u:interface)"
-consistent!(graphql_idl_parser_14, "^(?u:interface)");
-
-// graphql-idl-parser-0.1.1: "^(?u:scalar)"
-consistent!(graphql_idl_parser_15, "^(?u:scalar)");
-
-// graphql-idl-parser-0.1.1: "^(?u:type)"
-consistent!(graphql_idl_parser_16, "^(?u:type)");
-
-// graphql-idl-parser-0.1.1: "^(?u:union)"
-consistent!(graphql_idl_parser_17, "^(?u:union)");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\{)"
-consistent!(graphql_idl_parser_18, "^(?u:\\{)");
-
-// graphql-idl-parser-0.1.1: "^(?u:\\})"
-consistent!(graphql_idl_parser_19, "^(?u:\\})");
-
-// grimoire-0.1.0: r"(?s)/\*(?P<config>.*?)\*/"
-consistent!(grimoire_0, r"(?s)/\*(?P<config>.*?)\*/");
-
-// phonenumber-0.2.0+8.9.0: r"[\d]+(?:[~\x{2053}\x{223C}\x{FF5E}][\d]+)?"
-consistent!(phonenumber_0, r"[\d]+(?:[~\x{2053}\x{223C}\x{FF5E}][\d]+)?");
-
-// phonenumber-0.2.0+8.9.0: r"[, \[\]]"
-consistent!(phonenumber_1, r"[, \[\]]");
-
-// phonenumber-0.2.0+8.9.0: r"[\\/] *x"
-consistent!(phonenumber_2, r"[\\/] *x");
-
-// phonenumber-0.2.0+8.9.0: r"[[\P{N}&&\P{L}]&&[^#]]+$"
-consistent!(phonenumber_3, r"[[\P{N}&&\P{L}]&&[^#]]+$");
-
-// phonenumber-0.2.0+8.9.0: r"(?:.*?[A-Za-z]){3}.*"
-consistent!(phonenumber_4, r"(?:.*?[A-Za-z]){3}.*");
-
-// phonenumber-0.2.0+8.9.0: r"(\D+)"
-consistent!(phonenumber_5, r"(\D+)");
-
-// phonenumber-0.2.0+8.9.0: r"(\$\d)"
-consistent!(phonenumber_6, r"(\$\d)");
-
-// phonenumber-0.2.0+8.9.0: r"\(?\$1\)?"
-consistent!(phonenumber_7, r"\(?\$1\)?");
-
-// phone_number-0.1.0: r"\D"
-consistent!(phone_number_0, r"\D");
-
-// phone_number-0.1.0: r"^0+"
-consistent!(phone_number_1, r"^0+");
-
-// phone_number-0.1.0: r"^89"
-consistent!(phone_number_2, r"^89");
-
-// phone_number-0.1.0: r"^8+"
-consistent!(phone_number_3, r"^8+");
-
-// phile-0.1.4: r"^ *(\^_*\^) *$"
-consistent!(phile_0, r"^ *(\^_*\^) *$");
-
-// phile-0.1.4: r"^[_\p{XID_Start}]$"
-consistent!(phile_1, r"^[_\p{XID_Start}]$");
-
-// phile-0.1.4: r"^\p{XID_Continue}$"
-consistent!(phile_2, r"^\p{XID_Continue}$");
-
-// uritemplate-0.1.2: "%25(?P<hex>[0-9a-fA-F][0-9a-fA-F])"
-consistent!(uritemplate_0, "%25(?P<hex>[0-9a-fA-F][0-9a-fA-F])");
-
-// urdf-rs-0.4.2: "^package://(\\w+)/"
-consistent!(urdf_rs_0, "^package://(\\w+)/");
-
-// url-match-0.1.7: r"(?P<key>[?&.])"
-consistent!(url_match_0, r"(?P<key>[?&.])");
-
-// url-match-0.1.7: r":(?P<key>[a-zA-Z0-9_-]+)"
-consistent!(url_match_1, r":(?P<key>[a-zA-Z0-9_-]+)");
-
-// tsm-sys-0.1.0: r"hello world"
-consistent!(tsm_sys_0, r"hello world");
-
-// deb-version-0.1.0: "^(?:(?:(?:\\d+:).+)|(?:[^:]+))$"
-consistent!(deb_version_0, "^(?:(?:(?:\\d+:).+)|(?:[^:]+))$");
-
-// debcargo-2.1.0: r"^(?i)(a|an|the)\s+"
-consistent!(debcargo_0, r"^(?i)(a|an|the)\s+");
-
-// debcargo-2.1.0: r"^(?i)(rust\s+)?(implementation|library|tool|crate)\s+(of|to|for)\s+"
-consistent!(
-    debcargo_1,
-    r"^(?i)(rust\s+)?(implementation|library|tool|crate)\s+(of|to|for)\s+"
-);
-
-// feaders-0.2.0: r"^.*\.h$"
-consistent!(feaders_0, r"^.*\.h$");
-
-// feaders-0.2.0: r"^.*\.c$"
-consistent!(feaders_1, r"^.*\.c$");
-
-// feaders-0.2.0: r"^.*\.hpp$"
-consistent!(feaders_2, r"^.*\.hpp$");
-
-// feaders-0.2.0: r"^.*\.cc$"
-consistent!(feaders_3, r"^.*\.cc$");
-
-// feaders-0.2.0: r"^.*\.cpp$"
-consistent!(feaders_4, r"^.*\.cpp$");
-
-// hyperscan-0.1.6: r"CPtr\(\w+\)"
-consistent!(hyperscan_0, r"CPtr\(\w+\)");
-
-// hyperscan-0.1.6: r"^Version:\s(\d\.\d\.\d)\sFeatures:\s+(\w+)?\sMode:\s(\w+)$"
-consistent!(
-    hyperscan_1,
-    r"^Version:\s(\d\.\d\.\d)\sFeatures:\s+(\w+)?\sMode:\s(\w+)$"
-);
-
-// hyperscan-0.1.6: r"RawDatabase<Block>\{db: \w+\}"
-consistent!(hyperscan_2, r"RawDatabase<Block>\{db: \w+\}");
-
-// hyperscan-0.1.6: r"RawSerializedDatabase\{p: \w+, len: \d+\}"
-consistent!(hyperscan_3, r"RawSerializedDatabase\{p: \w+, len: \d+\}");
-
-// ucd-parse-0.1.1: r"[0-9A-F]+"
-consistent!(ucd_parse_0, r"[0-9A-F]+");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_0, r".*");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_1, r".*");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_2, r".*");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_3, r".*");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_4, r".*");
-
-// afsort-0.2.0: r".*"
-consistent!(afsort_5, r".*");
-
-// afsort-0.2.0: r"^[a-z]+$"
-consistent!(afsort_6, r"^[a-z]+$");
-
-// afsort-0.2.0: r"^[a-z]+$"
-consistent!(afsort_7, r"^[a-z]+$");
-
-// tin-summer-1.21.4: r"(\.git|\.pijul|_darcs|\.hg)$"
-consistent!(tin_summer_0, r"(\.git|\.pijul|_darcs|\.hg)$");
-
-// tin-drummer-1.0.1: r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
-consistent!(tin_drummer_0, r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
-
-// tin-drummer-1.0.1: r".*?\.(stats|conf|h|out|cache.*|dat|pc|info|\.js)$"
-consistent!(
-    tin_drummer_1,
-    r".*?\.(stats|conf|h|out|cache.*|dat|pc|info|\.js)$"
-);
-
-// tin-drummer-1.0.1: r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
-consistent!(tin_drummer_2, r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
-
-// tin-drummer-1.0.1: r".*?\.(stats|conf|h|out|cache.*|\.js)$"
-consistent!(tin_drummer_3, r".*?\.(stats|conf|h|out|cache.*|\.js)$");
-
-// tin-drummer-1.0.1: r"(\.git|\.pijul|_darcs|\.hg)$"
-consistent!(tin_drummer_4, r"(\.git|\.pijul|_darcs|\.hg)$");
-
-// tin-drummer-1.0.1: r".*?\.(dyn_o|out|d|hi|dyn_hi|dump-.*|p_hi|p_o|prof|tix)$"
-consistent!(
-    tin_drummer_5,
-    r".*?\.(dyn_o|out|d|hi|dyn_hi|dump-.*|p_hi|p_o|prof|tix)$"
-);
-
-// tin-drummer-1.0.1: r".*?\.(ibc)$"
-consistent!(tin_drummer_6, r".*?\.(ibc)$");
-
-// tin-drummer-1.0.1: r"\.stack-work|dist-newstyle"
-consistent!(tin_drummer_7, r"\.stack-work|dist-newstyle");
-
-// timmy-0.3.0: r"_NET_WM_PID\(CARDINAL\) = (\d+)"
-consistent!(timmy_0, r"_NET_WM_PID\(CARDINAL\) = (\d+)");
-
-// timmy-0.3.0: r"today|yesterday|now"
-consistent!(timmy_1, r"today|yesterday|now");
-
-// timmy-0.3.0: r"(?P<day>\d{1,2})/(?P<month>\d{1,2})(/(?P<year>\d{4}|\d{2}))?"
-consistent!(
-    timmy_2,
-    r"(?P<day>\d{1,2})/(?P<month>\d{1,2})(/(?P<year>\d{4}|\d{2}))?"
-);
-
-// timmy-0.3.0: r"(?P<n>\d+) (days?|ds?)(?P<ago>( ago)?)"
-consistent!(timmy_3, r"(?P<n>\d+) (days?|ds?)(?P<ago>( ago)?)");
-
-// timmy-0.3.0: r"(?P<hr>\d{2}):(?P<mins>\d{2})"
-consistent!(timmy_4, r"(?P<hr>\d{2}):(?P<mins>\d{2})");
-
-// tinfo-0.5.0: r"^(\d+): \d+ windows \(.*\) \[\d+x\d+\]( \(attached\))?"
-consistent!(
-    tinfo_0,
-    r"^(\d+): \d+ windows \(.*\) \[\d+x\d+\]( \(attached\))?"
-);
-
-// tinfo-0.5.0: r"^(\d+):(\d+): (.*) \((\d+) panes\) \[(\d+)x(\d+)\]"
-consistent!(tinfo_1, r"^(\d+):(\d+): (.*) \((\d+) panes\) \[(\d+)x(\d+)\]");
-
-// timespan-0.0.4: r"(?:\\\{start\\\}|\\\{end\\\})"
-consistent!(timespan_0, r"(?:\\\{start\\\}|\\\{end\\\})");
-
-// timespan-0.0.4: r"(.*)\s+-\s+(.*)"
-consistent!(timespan_1, r"(.*)\s+-\s+(.*)");
-
-// timespan-0.0.4: r"(.*)\s+(\w+)$"
-consistent!(timespan_2, r"(.*)\s+(\w+)$");
-
-// timespan-0.0.4: r"(.*)\s+(\w+)$"
-consistent!(timespan_3, r"(.*)\s+(\w+)$");
-
-// timespan-0.0.4: r"(.*)\s+-\s+(.*)"
-consistent!(timespan_4, r"(.*)\s+-\s+(.*)");
-
-// titlecase-0.10.0: r"[[:lower:]]"
-consistent!(titlecase_0, r"[[:lower:]]");
-
-// tight-0.1.3: r"^\d+ (day|week|month|year)s?$"
-consistent!(tight_0, r"^\d+ (day|week|month|year)s?$");
-
-// tight-0.1.3: r"^\d+ (day|week|month|year)s?$"
-consistent!(tight_1, r"^\d+ (day|week|month|year)s?$");
-
-// yaml-0.2.1: r"^[-+]?(0|[1-9][0-9_]*)$"
-consistent!(yaml_0, r"^[-+]?(0|[1-9][0-9_]*)$");
-
-// yaml-0.2.1: r"^([-+]?)0o?([0-7_]+)$"
-consistent!(yaml_1, r"^([-+]?)0o?([0-7_]+)$");
-
-// yaml-0.2.1: r"^([-+]?)0x([0-9a-fA-F_]+)$"
-consistent!(yaml_2, r"^([-+]?)0x([0-9a-fA-F_]+)$");
-
-// yaml-0.2.1: r"^([-+]?)0b([0-1_]+)$"
-consistent!(yaml_3, r"^([-+]?)0b([0-1_]+)$");
-
-// yaml-0.2.1: r"^([-+]?)(\.[0-9]+|[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$"
-consistent!(
-    yaml_4,
-    r"^([-+]?)(\.[0-9]+|[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$"
-);
-
-// yaml-0.2.1: r"^[+]?(\.inf|\.Inf|\.INF)$"
-consistent!(yaml_5, r"^[+]?(\.inf|\.Inf|\.INF)$");
-
-// yaml-0.2.1: r"^-(\.inf|\.Inf|\.INF)$"
-consistent!(yaml_6, r"^-(\.inf|\.Inf|\.INF)$");
-
-// yaml-0.2.1: r"^(\.nan|\.NaN|\.NAN)$"
-consistent!(yaml_7, r"^(\.nan|\.NaN|\.NAN)$");
-
-// yaml-0.2.1: r"^(null|Null|NULL|~)$"
-consistent!(yaml_8, r"^(null|Null|NULL|~)$");
-
-// yaml-0.2.1: r"^(true|True|TRUE|yes|Yes|YES)$"
-consistent!(yaml_9, r"^(true|True|TRUE|yes|Yes|YES)$");
-
-// yaml-0.2.1: r"^(false|False|FALSE|no|No|NO)$"
-consistent!(yaml_10, r"^(false|False|FALSE|no|No|NO)$");
-
-// kefia-0.1.0: r"(?m)^(\S+)/(\S+) (\S+)(?: \((.*)\))?$"
-consistent!(kefia_0, r"(?m)^(\S+)/(\S+) (\S+)(?: \((.*)\))?$");
-
-// risp-0.7.0: "^(\\s+|;.*?(\n|$))+"
-consistent!(risp_0, "^(\\s+|;.*?(\n|$))+");
-
-// risp-0.7.0: "^\".*?\""
-consistent!(risp_1, "^\".*?\"");
-
-// risp-0.7.0: r"^[^\s\{\}()\[\]]+"
-consistent!(risp_2, r"^[^\s\{\}()\[\]]+");
-
-// risp-0.7.0: r"^-?\d+"
-consistent!(risp_3, r"^-?\d+");
-
-// ripgrep-0.8.1: "^([0-9]+)([KMG])?$"
-consistent!(ripgrep_0, "^([0-9]+)([KMG])?$");
-
-// riquid-0.0.1: r"^\w+"
-consistent!(riquid_0, r"^\w+");
-
-// riquid-0.0.1: r"^\d+"
-consistent!(riquid_1, r"^\d+");
-
-// recursive_disassembler-2.1.2: r"\A(0x)?([a-fA-F0-9]+)\z"
-consistent!(recursive_disassembler_0, r"\A(0x)?([a-fA-F0-9]+)\z");
-
-// remake-0.1.0: r"^[a-zA-Z_][a-zA-Z0-9_]*"
-consistent!(remake_0, r"^[a-zA-Z_][a-zA-Z0-9_]*");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_0, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_1, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_2, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_3, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_4, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_5, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{2})\)"
-consistent!(regex_decode_6, r"'(?P<title>[^']+)'\s+\((?P<year>\d{2})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_7, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
-consistent!(regex_decode_8, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
-consistent!(regex_decode_9, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
-consistent!(regex_decode_10, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
-consistent!(regex_decode_11, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
-consistent!(regex_decode_12, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
-
-// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
-consistent!(regex_decode_13, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
-
-// regex-cache-0.2.0: "[0-9]{3}-[0-9]{3}-[0-9]{4}"
-consistent!(regex_cache_0, "[0-9]{3}-[0-9]{3}-[0-9]{4}");
-
-// regex-cache-0.2.0: r"^\d+$"
-consistent!(regex_cache_1, r"^\d+$");
-
-// regex-cache-0.2.0: r"^[a-z]+$"
-consistent!(regex_cache_2, r"^[a-z]+$");
-
-// regex-cache-0.2.0: r"^\d+$"
-consistent!(regex_cache_3, r"^\d+$");
-
-// regex-cache-0.2.0: r"^\d+$"
-consistent!(regex_cache_4, r"^\d+$");
-
-// regex_dfa-0.5.0: r"\d{4}-\d{2}-\d{2}"
-consistent!(regex_dfa_0, r"\d{4}-\d{2}-\d{2}");
-
-// reaper-2.0.0: r"^[0-9\p{L} _\\.]{3,16}$"
-consistent!(reaper_0, r"^[0-9\p{L} _\\.]{3,16}$");
-
-// retdec-0.1.0: r"^attachment; filename=(.+)$"
-consistent!(retdec_0, r"^attachment; filename=(.+)$");
-
-// renvsubst-0.1.2: r"(\\)(?P<head>\$[0-9A-Za-z_{])"
-consistent!(renvsubst_0, r"(\\)(?P<head>\$[0-9A-Za-z_{])");
-
-// renvsubst-0.1.2: r"\$([[:word:]]+)"
-consistent!(renvsubst_1, r"\$([[:word:]]+)");
-
-// renvsubst-0.1.2: r"\$\{([[:word:]]+)\}"
-consistent!(renvsubst_2, r"\$\{([[:word:]]+)\}");
-
-// rexpect-0.3.0: r"'[a-z]+'"
-consistent!(rexpect_0, r"'[a-z]+'");
-
-// rexpect-0.3.0: r"^\d{4}-\d{2}-\d{2}$"
-consistent!(rexpect_1, r"^\d{4}-\d{2}-\d{2}$");
-
-// rexpect-0.3.0: r"-\d{2}-"
-consistent!(rexpect_2, r"-\d{2}-");
-
-// luther-0.1.0: "^a(b|c)c*$"
-consistent!(luther_0, "^a(b|c)c*$");
-
-// little_boxes-1.6.0: r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]"
-consistent!(little_boxes_0, r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]");
-
-// libimagentrytag-0.8.0: "^[a-zA-Z]([a-zA-Z0-9_-]*)$"
-consistent!(libimagentrytag_0, "^[a-zA-Z]([a-zA-Z0-9_-]*)$");
-
-// libimaginteraction-0.8.0: r"^[Yy](\n?)$"
-consistent!(libimaginteraction_0, r"^[Yy](\n?)$");
-
-// libimaginteraction-0.8.0: r"^[Nn](\n?)$"
-consistent!(libimaginteraction_1, r"^[Nn](\n?)$");
-
-// libimagutil-0.8.0: "^(?P<KEY>([^=]*))=(.*)$"
-consistent!(libimagutil_0, "^(?P<KEY>([^=]*))=(.*)$");
-
-// libimagutil-0.8.0: "(.*)=(\"(?P<QVALUE>([^\"]*))\"|(?P<VALUE>(.*)))$"
-consistent!(libimagutil_1, "(.*)=(\"(?P<QVALUE>([^\"]*))\"|(?P<VALUE>(.*)))$");
-
-// linux_ip-0.1.0: r"\s+"
-consistent!(linux_ip_0, r"\s+");
-
-// linux_ip-0.1.0: r"\s*[\n\r]+\s*"
-consistent!(linux_ip_1, r"\s*[\n\r]+\s*");
-
-// linux_ip-0.1.0: r"^([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$"
-consistent!(linux_ip_2, r"^([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$");
-
-// linux_ip-0.1.0: r"^([0-9a-fA-F\.:/]+|default)\s+via\s+([a-z0-9\.:]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$"
-consistent!(linux_ip_3, r"^([0-9a-fA-F\.:/]+|default)\s+via\s+([a-z0-9\.:]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$");
-
-// linux_ip-0.1.0: r"^(blackhole)\s+([0-9a-fA-F\.:/]+)$"
-consistent!(linux_ip_4, r"^(blackhole)\s+([0-9a-fA-F\.:/]+)$");
-
-// linux_ip-0.1.0: r"^(unreachable)\s+([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s+(.*)$"
-consistent!(
-    linux_ip_5,
-    r"^(unreachable)\s+([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s+(.*)$"
-);
-
-// linux_ip-0.1.0: r"\s*[\n\r]+\s*"
-consistent!(linux_ip_6, r"\s*[\n\r]+\s*");
-
-// linux_ip-0.1.0: r"^\d+:\s+([a-zA-Z0-9\.-]+)(@\S+)*:\s+(.*)$"
-consistent!(linux_ip_7, r"^\d+:\s+([a-zA-Z0-9\.-]+)(@\S+)*:\s+(.*)$");
-
-// linux_ip-0.1.0: r"\s*link/ether\s+([a-f0-9:]+)\s+.*"
-consistent!(linux_ip_8, r"\s*link/ether\s+([a-f0-9:]+)\s+.*");
-
-// linux_ip-0.1.0: r"\s*inet[6]*\s+([0-9a-f:\./]+)\s+.*"
-consistent!(linux_ip_9, r"\s*inet[6]*\s+([0-9a-f:\./]+)\s+.*");
-
-// linky-0.1.4: r"[^\w -]"
-consistent!(linky_0, r"[^\w -]");
-
-// linky-0.1.4: r"^(.*):(\d+): [^ ]* ([^ ]*)$"
-consistent!(linky_1, r"^(.*):(\d+): [^ ]* ([^ ]*)$");
-
-// limonite-0.2.1: r"^(\d{4}-\d{2}-\d{2})-(\d{3})-(.+)$"
-consistent!(limonite_0, r"^(\d{4}-\d{2}-\d{2})-(\d{3})-(.+)$");
-
-// process-queue-0.1.1: r"^[a-zA-Z]+$"
-consistent!(process_queue_0, r"^[a-zA-Z]+$");
-
-// pronghorn-0.1.2: r"^\{([a-zA-Z_]+)\}$"
-consistent!(pronghorn_0, r"^\{([a-zA-Z_]+)\}$");
-
-// protocol-ftp-client-0.1.1: "(?m:^(\\d{3}) (.+)\r$)"
-consistent!(protocol_ftp_client_0, "(?m:^(\\d{3}) (.+)\r$)");
-
-// protocol-ftp-client-0.1.1: "\"(.+)\""
-consistent!(protocol_ftp_client_1, "\"(.+)\"");
-
-// protocol-ftp-client-0.1.1: "(\\w+) [Tt]ype: (\\w+)"
-consistent!(protocol_ftp_client_2, "(\\w+) [Tt]ype: (\\w+)");
-
-// protocol-ftp-client-0.1.1: "(?m:^(\\d{3})-.+\r$)"
-consistent!(protocol_ftp_client_3, "(?m:^(\\d{3})-.+\r$)");
-
-// protocol-ftp-client-0.1.1: "Entering Passive Mode \\((\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)\\)"
-consistent!(
-    protocol_ftp_client_4,
-    "Entering Passive Mode \\((\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)\\)"
-);
-
-// protocol-ftp-client-0.1.1: "(?m:^(.+)\r$)"
-consistent!(protocol_ftp_client_5, "(?m:^(.+)\r$)");
-
-// protocol-ftp-client-0.1.1: "^([d-])(?:[rwx-]{3}){3} +\\d+ +\\w+ +\\w+ +(\\d+) +(.+) +(.+)$"
-consistent!(
-    protocol_ftp_client_6,
-    "^([d-])(?:[rwx-]{3}){3} +\\d+ +\\w+ +\\w+ +(\\d+) +(.+) +(.+)$"
-);
-
-// article-date-extractor-0.1.1: r"([\./\-_]{0,1}(19|20)\d{2})[\./\-_]{0,1}(([0-3]{0,1}[0-9][\./\-_])|(\w{3,5}[\./\-_]))([0-3]{0,1}[0-9][\./\-]{0,1})"
-consistent!(article_date_extractor_0, r"([\./\-_]{0,1}(19|20)\d{2})[\./\-_]{0,1}(([0-3]{0,1}[0-9][\./\-_])|(\w{3,5}[\./\-_]))([0-3]{0,1}[0-9][\./\-]{0,1})");
-
-// article-date-extractor-0.1.1: r"(?i)publishdate|pubdate|timestamp|article_date|articledate|date"
-consistent!(
-    article_date_extractor_1,
-    r"(?i)publishdate|pubdate|timestamp|article_date|articledate|date"
-);
-
-// arthas_plugin-0.1.1: r"type\((.*)\)"
-consistent!(arthas_plugin_0, r"type\((.*)\)");
-
-// arthas_plugin-0.1.1: r"Vec<(.*)>"
-consistent!(arthas_plugin_1, r"Vec<(.*)>");
-
-// arthas_plugin-0.1.1: r"Option<(.*)>"
-consistent!(arthas_plugin_2, r"Option<(.*)>");
-
-// arthas_plugin-0.1.1: r"HashMap<[a-z0-9A-Z]+, *(.*)>"
-consistent!(arthas_plugin_3, r"HashMap<[a-z0-9A-Z]+, *(.*)>");
-
-// arthas_derive-0.1.0: "Vec *< *(.*) *>"
-consistent!(arthas_derive_0, "Vec *< *(.*) *>");
-
-// arthas_derive-0.1.0: r"Option *< *(.*) *>"
-consistent!(arthas_derive_1, r"Option *< *(.*) *>");
-
-// arthas_derive-0.1.0: r"HashMap *< *[a-z0-9A-Z]+ *, *(.*) *>"
-consistent!(arthas_derive_2, r"HashMap *< *[a-z0-9A-Z]+ *, *(.*) *>");
-
-// arpabet-0.2.0: r"^([\w\-\(\)\.']+)\s+([^\s].*)\s*$"
-consistent!(arpabet_0, r"^([\w\-\(\)\.']+)\s+([^\s].*)\s*$");
-
-// arpabet-0.2.0: r"^;;;\s+"
-consistent!(arpabet_1, r"^;;;\s+");
-
-// glossy_codegen-0.2.0: r"/\*.*?\*/|//.*"
-consistent!(glossy_codegen_0, r"/\*.*?\*/|//.*");
-
-// glossy_codegen-0.2.0: "^\\s*#\\s*include\\s+<([:print:]+)>\\s*$"
-consistent!(glossy_codegen_1, "^\\s*#\\s*include\\s+<([:print:]+)>\\s*$");
-
-// glossy_codegen-0.2.0: "^\\s*#\\s*include\\s+\"([:print:]+)\"\\s*$"
-consistent!(glossy_codegen_2, "^\\s*#\\s*include\\s+\"([:print:]+)\"\\s*$");
-
-// glossy_codegen-0.2.0: r"^\s*#\s*version\s+(\d+)"
-consistent!(glossy_codegen_3, r"^\s*#\s*version\s+(\d+)");
-
-// glossy_codegen-0.2.0: r"^\s*$"
-consistent!(glossy_codegen_4, r"^\s*$");
-
-// gluster-1.0.1: r"(?P<addr>via \S+)"
-consistent!(gluster_0, r"(?P<addr>via \S+)");
-
-// gluster-1.0.1: r"(?P<src>src \S+)"
-consistent!(gluster_1, r"(?P<src>src \S+)");
-
-// gl_helpers-0.1.7: r"(.*)\[\d+\]"
-consistent!(gl_helpers_0, r"(.*)\[\d+\]");
-
-// gl_helpers-0.1.7: r"(\d+).(\d+)"
-consistent!(gl_helpers_1, r"(\d+).(\d+)");
-
-// glr-parser-0.0.1: r"(?P<c>[\\\.\+\*\?\(\)\|\[\]\{\}\^\$])"
-consistent!(glr_parser_0, r"(?P<c>[\\\.\+\*\?\(\)\|\[\]\{\}\^\$])");
-
-// glr-parser-0.0.1: r"^\w+$"
-consistent!(glr_parser_1, r"^\w+$");
-
-// glr-parser-0.0.1: "'[^']+'"
-consistent!(glr_parser_2, "'[^']+'");
-
-// hoodlum-0.5.0: r"(?m)//.*"
-consistent!(hoodlum_0, r"(?m)//.*");
-
-// form-checker-0.2.2: r"^1\d{10}$"
-consistent!(form_checker_0, r"^1\d{10}$");
-
-// form-checker-0.2.2: r"(?i)^[\w.%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}$"
-consistent!(form_checker_1, r"(?i)^[\w.%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}$");
-
-// wikibase-0.2.0: r"(?P<user_agent>[a-zA-Z0-9-_]+/[0-9\.]+)"
-consistent!(wikibase_0, r"(?P<user_agent>[a-zA-Z0-9-_]+/[0-9\.]+)");
-
-// wifiscanner-0.3.6: r"Cell [0-9]{2,} - Address:"
-consistent!(wifiscanner_0, r"Cell [0-9]{2,} - Address:");
-
-// wifiscanner-0.3.6: r"([0-9a-zA-Z]{1}[0-9a-zA-Z]{1}[:]{1}){5}[0-9a-zA-Z]{1}[0-9a-zA-Z]{1}"
-consistent!(
-    wifiscanner_1,
-    r"([0-9a-zA-Z]{1}[0-9a-zA-Z]{1}[:]{1}){5}[0-9a-zA-Z]{1}[0-9a-zA-Z]{1}"
-);
-
-// wifiscanner-0.3.6: r"Signal level=(\d+)/100"
-consistent!(wifiscanner_2, r"Signal level=(\d+)/100");
-
-// bbcode-1.0.2: r"(?s)\[b\](.*?)\[/b\]"
-consistent!(bbcode_0, r"(?s)\[b\](.*?)\[/b\]");
-
-// bbcode-1.0.2: r"(?s)\[i\](.*?)\[/i\]"
-consistent!(bbcode_1, r"(?s)\[i\](.*?)\[/i\]");
-
-// bbcode-1.0.2: r"(?s)\[u\](.*?)\[/u\]"
-consistent!(bbcode_2, r"(?s)\[u\](.*?)\[/u\]");
-
-// bbcode-1.0.2: r"(?s)\[s\](.*?)\[/s\]"
-consistent!(bbcode_3, r"(?s)\[s\](.*?)\[/s\]");
-
-// bbcode-1.0.2: r"(?s)\[size=(\d+)](.*?)\[/size\]"
-consistent!(bbcode_4, r"(?s)\[size=(\d+)](.*?)\[/size\]");
-
-// bbcode-1.0.2: r"(?s)\[color=(.+)](.*?)\[/color\]"
-consistent!(bbcode_5, r"(?s)\[color=(.+)](.*?)\[/color\]");
-
-// bbcode-1.0.2: r"(?s)\[center\](.*?)\[/center\]"
-consistent!(bbcode_6, r"(?s)\[center\](.*?)\[/center\]");
-
-// bbcode-1.0.2: r"(?s)\[left\](.*?)\[/left\]"
-consistent!(bbcode_7, r"(?s)\[left\](.*?)\[/left\]");
-
-// bbcode-1.0.2: r"(?s)\[right\](.*?)\[/right\]"
-consistent!(bbcode_8, r"(?s)\[right\](.*?)\[/right\]");
-
-// bbcode-1.0.2: r"(?s)\[table\](.*?)\[/table\]"
-consistent!(bbcode_9, r"(?s)\[table\](.*?)\[/table\]");
-
-// bbcode-1.0.2: r"(?s)\[td\](.*?)\[/td\]"
-consistent!(bbcode_10, r"(?s)\[td\](.*?)\[/td\]");
-
-// bbcode-1.0.2: r"(?s)\[tr\](.*?)\[/tr\]"
-consistent!(bbcode_11, r"(?s)\[tr\](.*?)\[/tr\]");
-
-// bbcode-1.0.2: r"(?s)\[th\](.*?)\[/th\]"
-consistent!(bbcode_12, r"(?s)\[th\](.*?)\[/th\]");
-
-// bbcode-1.0.2: r"(?s)\[url\](.*?)\[/url\]"
-consistent!(bbcode_13, r"(?s)\[url\](.*?)\[/url\]");
-
-// bbcode-1.0.2: r"(?s)\[url=(.+)\](.*?)\[/url\]"
-consistent!(bbcode_14, r"(?s)\[url=(.+)\](.*?)\[/url\]");
-
-// bbcode-1.0.2: r"(?s)\[quote\](.*?)\[/quote\]"
-consistent!(bbcode_15, r"(?s)\[quote\](.*?)\[/quote\]");
-
-// bbcode-1.0.2: r"(?s)\[quote=(.+)\](.*?)\[/quote\]"
-consistent!(bbcode_16, r"(?s)\[quote=(.+)\](.*?)\[/quote\]");
-
-// bbcode-1.0.2: r"(?s)\[img=(\d+)x(\d+)(\b.*)?\](.*?)\[/img\]"
-consistent!(bbcode_17, r"(?s)\[img=(\d+)x(\d+)(\b.*)?\](.*?)\[/img\]");
-
-// bbcode-1.0.2: r"(?s)\[img=(.+)(\b.*)?\](.*?)\[/img\]"
-consistent!(bbcode_18, r"(?s)\[img=(.+)(\b.*)?\](.*?)\[/img\]");
-
-// bbcode-1.0.2: r"(?s)\[img(\b.*)?\](.*?)\[/img\]"
-consistent!(bbcode_19, r"(?s)\[img(\b.*)?\](.*?)\[/img\]");
-
-// bbcode-1.0.2: r"(?s)\[ol\](.*?)\[/ol\]"
-consistent!(bbcode_20, r"(?s)\[ol\](.*?)\[/ol\]");
-
-// bbcode-1.0.2: r"(?s)\[ul\](.*?)\[/ul\]"
-consistent!(bbcode_21, r"(?s)\[ul\](.*?)\[/ul\]");
-
-// bbcode-1.0.2: r"(?s)\[list\](.*?)\[/list\]"
-consistent!(bbcode_22, r"(?s)\[list\](.*?)\[/list\]");
-
-// bbcode-1.0.2: r"(?s)\[youtube\](.*?)\[/youtube\]"
-consistent!(bbcode_23, r"(?s)\[youtube\](.*?)\[/youtube\]");
-
-// bbcode-1.0.2: r"(?s)\[youtube=(\d+)x(\d+)\](.*?)\[/youtube\]"
-consistent!(bbcode_24, r"(?s)\[youtube=(\d+)x(\d+)\](.*?)\[/youtube\]");
-
-// bbcode-1.0.2: r"(?s)\[li\](.*?)\[/li\]"
-consistent!(bbcode_25, r"(?s)\[li\](.*?)\[/li\]");
-
-// block-utils-0.5.0: r"loop\d+"
-consistent!(block_utils_0, r"loop\d+");
-
-// block-utils-0.5.0: r"ram\d+"
-consistent!(block_utils_1, r"ram\d+");
-
-// block-utils-0.5.0: r"md\d+"
-consistent!(block_utils_2, r"md\d+");
-
-// kvvliveapi-0.1.0: r"^([1-9]) min$"
-consistent!(kvvliveapi_0, r"^([1-9]) min$");
-
-// rfc822_sanitizer-0.3.3: r"(\d{2}):(\d{2}):(\d{2})"
-consistent!(rfc822_sanitizer_0, r"(\d{2}):(\d{2}):(\d{2})");
-
-// rfc822_sanitizer-0.3.3: r"(\d{1,2}):(\d{1,2}):(\d{1,2})"
-consistent!(rfc822_sanitizer_1, r"(\d{1,2}):(\d{1,2}):(\d{1,2})");
-
-// faker-0.0.4: r"[2-9]"
-consistent!(faker_0, r"[2-9]");
-
-// faker-0.0.4: r"[1-9]"
-consistent!(faker_1, r"[1-9]");
-
-// faker-0.0.4: r"[0-9]"
-consistent!(faker_2, r"[0-9]");
-
-// faker-0.0.4: r"\d{10}"
-consistent!(faker_3, r"\d{10}");
-
-// faker-0.0.4: r"\d{1}"
-consistent!(faker_4, r"\d{1}");
-
-// faker-0.0.4: r"^\w+"
-consistent!(faker_5, r"^\w+");
-
-// faker-0.0.4: r"^\w+"
-consistent!(faker_6, r"^\w+");
-
-// faker-0.0.4: r"^(\w+\.? ?){2,3}$"
-consistent!(faker_7, r"^(\w+\.? ?){2,3}$");
-
-// faker-0.0.4: r"^[A-Z][a-z]+\.?$"
-consistent!(faker_8, r"^[A-Z][a-z]+\.?$");
-
-// faker-0.0.4: r"^[A-Z][A-Za-z]*\.?$"
-consistent!(faker_9, r"^[A-Z][A-Za-z]*\.?$");
-
-// faker-0.0.4: r"http://lorempixel.com/100/100/\w+"
-consistent!(faker_10, r"http://lorempixel.com/100/100/\w+");
-
-// faker-0.0.4: r"http://lorempixel.com/100/100/cats"
-consistent!(faker_11, r"http://lorempixel.com/100/100/cats");
-
-// fancy-regex-0.1.0: "(?i:ß)"
-consistent!(fancy_regex_0, "(?i:ß)");
-
-// fancy-regex-0.1.0: "(?i:\\x{0587})"
-consistent!(fancy_regex_1, "(?i:\\x{0587})");
-
-// fancy-regex-0.1.0: "^\\\\([!-/:-@\\[-`\\{-~aftnrv]|[0-7]{1,3}|x[0-9a-fA-F]{2}|x\\{[0-9a-fA-F]{1,6}\\})"
-consistent!(fancy_regex_2, "^\\\\([!-/:-@\\[-`\\{-~aftnrv]|[0-7]{1,3}|x[0-9a-fA-F]{2}|x\\{[0-9a-fA-F]{1,6}\\})");
-
-// fancy-prompt-0.1.5: r"/([^/])[^/]+/"
-consistent!(fancy_prompt_0, r"/([^/])[^/]+/");
-
-// fancy-prompt-0.1.5: r"^([^:]+):.*?(?::([^:]+))?$"
-consistent!(fancy_prompt_1, r"^([^:]+):.*?(?::([^:]+))?$");
-
-// fanta-0.2.0: r"^(/?__\w+__)/(.*)"
-consistent!(fanta_0, r"^(/?__\w+__)/(.*)");
-
-// fanta-cli-0.1.1: r"(.)([A-Z])"
-consistent!(fanta_cli_0, r"(.)([A-Z])");
-
-// fanta-cli-0.1.1: "\\{:[^\\s]+\\}"
-consistent!(fanta_cli_1, "\\{:[^\\s]+\\}");
-
-// amethyst_tools-0.7.1: "(?P<last>[^\r])\n"
-consistent!(amethyst_tools_0, "(?P<last>[^\r])\n");
-
-// amigo-0.3.1: r"^-?\d+(\.\d)?"
-consistent!(amigo_0, r"^-?\d+(\.\d)?");
-
-// amigo-0.3.1: r"^[a-zA-Z_]+[\w-]*[!?_]?"
-consistent!(amigo_1, r"^[a-zA-Z_]+[\w-]*[!?_]?");
-
-// amigo-0.3.1: r"^\("
-consistent!(amigo_2, r"^\(");
-
-// amigo-0.3.1: r"^\)"
-consistent!(amigo_3, r"^\)");
-
-// amigo-0.3.1: r"^\s+"
-consistent!(amigo_4, r"^\s+");
-
-// ethcore-logger-1.12.0: "\x1b\\[[^m]+m"
-consistent!(ethcore_logger_0, "\x1b\\[[^m]+m");
-
-// dash2html-1.0.1: r"__.*?__"
-consistent!(dash2html_0, r"__.*?__");
-
-// dash2html-1.0.1: r"(?i)@(?:time|clipboard|cursor|date)"
-consistent!(dash2html_1, r"(?i)@(?:time|clipboard|cursor|date)");
-
-// os_type-2.0.0: r"^Microsoft Windows \[Version\s(\d+\.\d+\.\d+)\]$"
-consistent!(os_type_0, r"^Microsoft Windows \[Version\s(\d+\.\d+\.\d+)\]$");
-
-// os_type-2.0.0: r"ProductName:\s([\w\s]+)\n"
-consistent!(os_type_1, r"ProductName:\s([\w\s]+)\n");
-
-// os_type-2.0.0: r"ProductVersion:\s(\w+\.\w+\.\w+)"
-consistent!(os_type_2, r"ProductVersion:\s(\w+\.\w+\.\w+)");
-
-// os_type-2.0.0: r"BuildVersion:\s(\w+)"
-consistent!(os_type_3, r"BuildVersion:\s(\w+)");
-
-// os_type-2.0.0: r"(\w+) Linux release"
-consistent!(os_type_4, r"(\w+) Linux release");
-
-// os_type-2.0.0: r"release\s([\w\.]+)"
-consistent!(os_type_5, r"release\s([\w\.]+)");
-
-// os_type-2.0.0: r"Distributor ID:\s(\w+)"
-consistent!(os_type_6, r"Distributor ID:\s(\w+)");
-
-// os_type-2.0.0: r"Release:\s([\w\.]+)"
-consistent!(os_type_7, r"Release:\s([\w\.]+)");
-
-// bindgen-0.37.0: r"typename type\-parameter\-\d+\-\d+::.+"
-consistent!(bindgen_0, r"typename type\-parameter\-\d+\-\d+::.+");
-
-// imap-0.8.1: "^+(.*)\r\n"
-consistent!(imap_0, "^+(.*)\r\n");
-
-// image-base64-0.1.0: r"^ffd8ffe0"
-consistent!(image_base64_0, r"^ffd8ffe0");
-
-// image-base64-0.1.0: r"^89504e47"
-consistent!(image_base64_1, r"^89504e47");
-
-// image-base64-0.1.0: r"^47494638"
-consistent!(image_base64_2, r"^47494638");
-
-// json-pointer-0.3.2: "^(/([^/~]|~[01])*)*$"
-consistent!(json_pointer_0, "^(/([^/~]|~[01])*)*$");
-
-// json-pointer-0.3.2: "^#(/([^/~%]|~[01]|%[0-9a-fA-F]{2})*)*$"
-consistent!(json_pointer_1, "^#(/([^/~%]|~[01]|%[0-9a-fA-F]{2})*)*$");
-
-// mysql_common-0.7.0: r"^5.5.5-(\d{1,2})\.(\d{1,2})\.(\d{1,3})-MariaDB"
-consistent!(mysql_common_0, r"^5.5.5-(\d{1,2})\.(\d{1,2})\.(\d{1,3})-MariaDB");
-
-// mysql_common-0.7.0: r"^(\d{1,2})\.(\d{1,2})\.(\d{1,3})(.*)"
-consistent!(mysql_common_1, r"^(\d{1,2})\.(\d{1,2})\.(\d{1,3})(.*)");
-
-// government_id-0.1.0: r"^[0-9]{4}[0-9A-Z]{2}[0-9]{3}$"
-consistent!(government_id_0, r"^[0-9]{4}[0-9A-Z]{2}[0-9]{3}$");
-
-// ohmers-0.1.1: r"UniqueIndexViolation: (\w+)"
-consistent!(ohmers_0, r"UniqueIndexViolation: (\w+)");
-
-// eliza-1.0.0: r"(.*) you are (.*)"
-consistent!(eliza_0, r"(.*) you are (.*)");
-
-// eliza-1.0.0: r"(.*) you are (.*)"
-consistent!(eliza_1, r"(.*) you are (.*)");
-
-// eliza-1.0.0: r"(.*) you are (.*)"
-consistent!(eliza_2, r"(.*) you are (.*)");
-
-// chema-0.0.5: "^\\s*\\*"
-consistent!(chema_0, "^\\s*\\*");
-
-// chema-0.0.5: "^\\s*@(\\w+)\\s+(.*)"
-consistent!(chema_1, "^\\s*@(\\w+)\\s+(.*)");
-
-// chord3-0.3.0: r"^\s*#"
-consistent!(chord3_0, r"^\s*#");
-
-// chord3-0.3.0: r"\{(?P<cmd>\w+)(?::?\s*(?P<arg>.*))?\}"
-consistent!(chord3_1, r"\{(?P<cmd>\w+)(?::?\s*(?P<arg>.*))?\}");
-
-// chord3-0.3.0: r"\{(eot|end_of_tab):?\s*"
-consistent!(chord3_2, r"\{(eot|end_of_tab):?\s*");
-
-// chord3-0.3.0: r"([^\[]*)(?:\[([^\]]*)\])?"
-consistent!(chord3_3, r"([^\[]*)(?:\[([^\]]*)\])?");
-
-// checkmail-0.1.1: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
-consistent!(checkmail_0, "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$");
-
-// cntk-0.2.1: r"\b\w\w+\b"
-consistent!(cntk_0, r"\b\w\w+\b");
-
-// cntk-0.2.1: r"\b\w\w+\b"
-consistent!(cntk_1, r"\b\w\w+\b");
-
-// cniguru-0.1.0: r"\(id: (\d+)\)"
-consistent!(cniguru_0, r"\(id: (\d+)\)");
-
-// upm_lib-0.3.0: r"^(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$"
-consistent!(upm_lib_0, r"^(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$");
-
-// avro-0.2.1: r"^\s*(\*+(\s+))?"
-consistent!(avro_0, r"^\s*(\*+(\s+))?");
-
-// avro-0.2.1: r"^\s*(\*+)?"
-consistent!(avro_1, r"^\s*(\*+)?");
-
-// nomi-0.0.2: "[0-9]+"
-consistent!(nomi_0, "[0-9]+");
-
-// nodes-0.1.0: "([0-9]+)@(?:nodes|n)?:([^@]+)?"
-consistent!(nodes_0, "([0-9]+)@(?:nodes|n)?:([^@]+)?");
-
-// not-stakkr-1.0.0: r"(?i)in (\d+) (second|minute|hour|day|week)s?"
-consistent!(not_stakkr_0, r"(?i)in (\d+) (second|minute|hour|day|week)s?");
-
-// notetxt-0.0.1: "^([A-Za-z0-9 -_:]+)\n-+\n"
-consistent!(notetxt_0, "^([A-Za-z0-9 -_:]+)\n-+\n");
-
-// nail-0.1.0-pre.0: r"^-?[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?$"
-consistent!(nail_0, r"^-?[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?$");
-
-// nail-0.1.0-pre.0: r"^-?[0-9]+$"
-consistent!(nail_1, r"^-?[0-9]+$");
-
-// askalono-0.2.0: r"[^\w\s\pP]+"
-consistent!(askalono_0, r"[^\w\s\pP]+");
-
-// askalono-0.2.0: r"(?x)[ \t\p{Zs} \\ / \| \x2044 ]+"
-consistent!(askalono_1, r"(?x)[ \t\p{Zs} \\ / \| \x2044 ]+");
-
-// askalono-0.2.0: r"\p{Pd}+"
-consistent!(askalono_2, r"\p{Pd}+");
-
-// askalono-0.2.0: r"\p{Ps}+"
-consistent!(askalono_3, r"\p{Ps}+");
-
-// askalono-0.2.0: r"\p{Pe}+"
-consistent!(askalono_4, r"\p{Pe}+");
-
-// askalono-0.2.0: r"\p{Pc}+"
-consistent!(askalono_5, r"\p{Pc}+");
-
-// askalono-0.2.0: r"[©Ⓒⓒ]"
-consistent!(askalono_6, r"[©Ⓒⓒ]");
-
-// askalono-0.2.0: r"[\r\n\v\f]"
-consistent!(askalono_7, r"[\r\n\v\f]");
-
-// askalono-0.2.0: r"\n{3,}"
-consistent!(askalono_8, r"\n{3,}");
-
-// askalono-0.2.0: r"[^\w\s]+"
-consistent!(askalono_9, r"[^\w\s]+");
-
-// askalono-0.2.0: r"\s+"
-consistent!(askalono_10, r"\s+");
-
-// assembunny_plus-0.0.3: r"[^0-9a-zA-Z_]"
-consistent!(assembunny_plus_0, r"[^0-9a-zA-Z_]");
-
-// assembunny_plus-0.0.3: r"[0-9]"
-consistent!(assembunny_plus_1, r"[0-9]");
-
-// salt-compressor-0.4.0: r"(?m)^Minion (\S*) did not respond\. No job will be sent\.$"
-consistent!(
-    salt_compressor_0,
-    r"(?m)^Minion (\S*) did not respond\. No job will be sent\.$"
-);
-
-// sabisabi-0.4.1: r"</?[^>]+?>"
-consistent!(sabisabi_0, r"</?[^>]+?>");
-
-// sabisabi-0.4.1: r"\([^)]*\)"
-consistent!(sabisabi_1, r"\([^)]*\)");
-
-// sassers-0.13.5-h28: "@import \"([^\"]*)\";"
-consistent!(sassers_0, "@import \"([^\"]*)\";");
-
-// shadowsocks-0.6.2: r"[A-Za-z\d-]{1,63}$"
-consistent!(shadowsocks_0, r"[A-Za-z\d-]{1,63}$");
-
-// shkeleton-0.1.5: "[abc]+"
-consistent!(shkeleton_0, "[abc]+");
-
-// shellwords-0.1.0: r"([^A-Za-z0-9_\-.,:/@\n])"
-consistent!(shellwords_0, r"([^A-Za-z0-9_\-.,:/@\n])");
-
-// shellwords-0.1.0: r"\n"
-consistent!(shellwords_1, r"\n");
-
-// shush-0.1.5: "(?P<num>[0-9]+)(?P<units>[dhms])"
-consistent!(shush_0, "(?P<num>[0-9]+)(?P<units>[dhms])");
-
-// woothee-0.8.0: r"(?:Chrome|CrMo|CriOS)/([.0-9]+)"
-consistent!(woothee_0, r"(?:Chrome|CrMo|CriOS)/([.0-9]+)");
-
-// woothee-0.8.0: r"Vivaldi/([.0-9]+)"
-consistent!(woothee_1, r"Vivaldi/([.0-9]+)");
-
-// woothee-0.8.0: r"Firefox/([.0-9]+)"
-consistent!(woothee_2, r"Firefox/([.0-9]+)");
-
-// woothee-0.8.0: r"^Mozilla/[.0-9]+ \((?:Mobile|Tablet);(?:.*;)? rv:([.0-9]+)\) Gecko/[.0-9]+ Firefox/[.0-9]+$"
-consistent!(woothee_3, r"^Mozilla/[.0-9]+ \((?:Mobile|Tablet);(?:.*;)? rv:([.0-9]+)\) Gecko/[.0-9]+ Firefox/[.0-9]+$");
-
-// woothee-0.8.0: r"FxiOS/([.0-9]+)"
-consistent!(woothee_4, r"FxiOS/([.0-9]+)");
-
-// woothee-0.8.0: r"\(([^;)]+);FOMA;"
-consistent!(woothee_5, r"\(([^;)]+);FOMA;");
-
-// woothee-0.8.0: r"jig browser[^;]+; ([^);]+)"
-consistent!(woothee_6, r"jig browser[^;]+; ([^);]+)");
-
-// woothee-0.8.0: r"(?i)rss(?:reader|bar|[-_ /;()]|[ +]*/)"
-consistent!(woothee_7, r"(?i)rss(?:reader|bar|[-_ /;()]|[ +]*/)");
-
-// woothee-0.8.0: r"(?i)(?:bot|crawler|spider)(?:[-_ ./;@()]|$)"
-consistent!(woothee_8, r"(?i)(?:bot|crawler|spider)(?:[-_ ./;@()]|$)");
-
-// woothee-0.8.0: r"(?i)(?:feed|web) ?parser"
-consistent!(woothee_9, r"(?i)(?:feed|web) ?parser");
-
-// woothee-0.8.0: r"(?i)watch ?dog"
-consistent!(woothee_10, r"(?i)watch ?dog");
-
-// woothee-0.8.0: r"Edge/([.0-9]+)"
-consistent!(woothee_11, r"Edge/([.0-9]+)");
-
-// woothee-0.8.0: r"MSIE ([.0-9]+);"
-consistent!(woothee_12, r"MSIE ([.0-9]+);");
-
-// woothee-0.8.0: r"Version/([.0-9]+)"
-consistent!(woothee_13, r"Version/([.0-9]+)");
-
-// woothee-0.8.0: r"Opera[/ ]([.0-9]+)"
-consistent!(woothee_14, r"Opera[/ ]([.0-9]+)");
-
-// woothee-0.8.0: r"OPR/([.0-9]+)"
-consistent!(woothee_15, r"OPR/([.0-9]+)");
-
-// woothee-0.8.0: r"Version/([.0-9]+)"
-consistent!(woothee_16, r"Version/([.0-9]+)");
-
-// woothee-0.8.0: r"(?:SoftBank|Vodafone|J-PHONE)/[.0-9]+/([^ /;()]+)"
-consistent!(woothee_17, r"(?:SoftBank|Vodafone|J-PHONE)/[.0-9]+/([^ /;()]+)");
-
-// woothee-0.8.0: r"Trident/([.0-9]+);"
-consistent!(woothee_18, r"Trident/([.0-9]+);");
-
-// woothee-0.8.0: r" rv:([.0-9]+)"
-consistent!(woothee_19, r" rv:([.0-9]+)");
-
-// woothee-0.8.0: r"IEMobile/([.0-9]+);"
-consistent!(woothee_20, r"IEMobile/([.0-9]+);");
-
-// woothee-0.8.0: r"(?:WILLCOM|DDIPOCKET);[^/]+/([^ /;()]+)"
-consistent!(woothee_21, r"(?:WILLCOM|DDIPOCKET);[^/]+/([^ /;()]+)");
-
-// woothee-0.8.0: r"Windows ([ .a-zA-Z0-9]+)[;\\)]"
-consistent!(woothee_22, r"Windows ([ .a-zA-Z0-9]+)[;\\)]");
-
-// woothee-0.8.0: r"^Phone(?: OS)? ([.0-9]+)"
-consistent!(woothee_23, r"^Phone(?: OS)? ([.0-9]+)");
-
-// woothee-0.8.0: r"iP(hone;|ad;|od) .*like Mac OS X"
-consistent!(woothee_24, r"iP(hone;|ad;|od) .*like Mac OS X");
-
-// woothee-0.8.0: r"Version/([.0-9]+)"
-consistent!(woothee_25, r"Version/([.0-9]+)");
-
-// woothee-0.8.0: r"rv:(\d+\.\d+\.\d+)"
-consistent!(woothee_26, r"rv:(\d+\.\d+\.\d+)");
-
-// woothee-0.8.0: r"FreeBSD ([^;\)]+);"
-consistent!(woothee_27, r"FreeBSD ([^;\)]+);");
-
-// woothee-0.8.0: r"CrOS ([^\)]+)\)"
-consistent!(woothee_28, r"CrOS ([^\)]+)\)");
-
-// woothee-0.8.0: r"Android[- ](\d+\.\d+(?:\.\d+)?)"
-consistent!(woothee_29, r"Android[- ](\d+\.\d+(?:\.\d+)?)");
-
-// woothee-0.8.0: r"PSP \(PlayStation Portable\); ([.0-9]+)\)"
-consistent!(woothee_30, r"PSP \(PlayStation Portable\); ([.0-9]+)\)");
-
-// woothee-0.8.0: r"PLAYSTATION 3;? ([.0-9]+)\)"
-consistent!(woothee_31, r"PLAYSTATION 3;? ([.0-9]+)\)");
-
-// woothee-0.8.0: r"PlayStation Vita ([.0-9]+)\)"
-consistent!(woothee_32, r"PlayStation Vita ([.0-9]+)\)");
-
-// woothee-0.8.0: r"PlayStation 4 ([.0-9]+)\)"
-consistent!(woothee_33, r"PlayStation 4 ([.0-9]+)\)");
-
-// woothee-0.8.0: r"BB10(?:.+)Version/([.0-9]+) "
-consistent!(woothee_34, r"BB10(?:.+)Version/([.0-9]+) ");
-
-// woothee-0.8.0: r"BlackBerry(?:\d+)/([.0-9]+) "
-consistent!(woothee_35, r"BlackBerry(?:\d+)/([.0-9]+) ");
-
-// woothee-0.8.0: r"; CPU(?: iPhone)? OS (\d+_\d+(?:_\d+)?) like Mac OS X"
-consistent!(
-    woothee_36,
-    r"; CPU(?: iPhone)? OS (\d+_\d+(?:_\d+)?) like Mac OS X"
-);
-
-// woothee-0.8.0: r"Mac OS X (10[._]\d+(?:[._]\d+)?)(?:\)|;)"
-consistent!(woothee_37, r"Mac OS X (10[._]\d+(?:[._]\d+)?)(?:\)|;)");
-
-// woothee-0.8.0: r"^(?:Apache-HttpClient/|Jakarta Commons-HttpClient/|Java/)"
-consistent!(
-    woothee_38,
-    r"^(?:Apache-HttpClient/|Jakarta Commons-HttpClient/|Java/)"
-);
-
-// woothee-0.8.0: r"[- ]HttpClient(/|$)"
-consistent!(woothee_39, r"[- ]HttpClient(/|$)");
-
-// woothee-0.8.0: r"^(?:PHP|WordPress|CakePHP|PukiWiki|PECL::HTTP)(?:/| |$)"
-consistent!(
-    woothee_40,
-    r"^(?:PHP|WordPress|CakePHP|PukiWiki|PECL::HTTP)(?:/| |$)"
-);
-
-// woothee-0.8.0: r"(?:PEAR HTTP_Request|HTTP_Request)(?: class|2)"
-consistent!(woothee_41, r"(?:PEAR HTTP_Request|HTTP_Request)(?: class|2)");
-
-// woothee-0.8.0: r"(?:Rome Client |UnwindFetchor/|ia_archiver |Summify |PostRank/)"
-consistent!(
-    woothee_42,
-    r"(?:Rome Client |UnwindFetchor/|ia_archiver |Summify |PostRank/)"
-);
-
-// woothee-0.8.0: r"Sleipnir/([.0-9]+)"
-consistent!(woothee_43, r"Sleipnir/([.0-9]+)");
-
-// word_replace-0.0.3: r"@@[a-z|A-Z|\d]+@@"
-consistent!(word_replace_0, r"@@[a-z|A-Z|\d]+@@");
-
-// wordcount-0.1.0: r"\w+"
-consistent!(wordcount_0, r"\w+");
-
-// just-0.3.12: "^([^=]+)=(.*)$"
-consistent!(just_0, "^([^=]+)=(.*)$");
-
-// emote-0.1.0: r":[a-zA-Z_]+?:"
-consistent!(emote_0, r":[a-zA-Z_]+?:");
-
-// emojicons-1.0.1: r":([a-zA-Z0-9_+-]+):"
-consistent!(emojicons_0, r":([a-zA-Z0-9_+-]+):");
-
-// git2_codecommit-0.1.2: r"git-codecommit\.([a-z0-9-]+)\.amazonaws\.com"
-consistent!(
-    git2_codecommit_0,
-    r"git-codecommit\.([a-z0-9-]+)\.amazonaws\.com"
-);
-
-// git-workarea-3.1.2: r"^submodule\.(?P<name>.*)\.(?P<key>[^=]*)=(?P<value>.*)$"
-consistent!(
-    git_workarea_0,
-    r"^submodule\.(?P<name>.*)\.(?P<key>[^=]*)=(?P<value>.*)$"
-);
-
-// git-shell-enforce-directory-1.0.0: r"^(?P<command>git-(?:receive|upload)-pack) '(?P<path>.+)'$"
-consistent!(
-    git_shell_enforce_directory_0,
-    r"^(?P<command>git-(?:receive|upload)-pack) '(?P<path>.+)'$"
-);
-
-// git-journal-1.6.3: r"[ \n]:(.*?):"
-consistent!(git_journal_0, r"[ \n]:(.*?):");
-
-// git-find-0.3.2: r"^git@(?P<host>[[:alnum:]\._-]+):(?P<path>[[:alnum:]\._\-/]+).git$"
-consistent!(
-    git_find_0,
-    r"^git@(?P<host>[[:alnum:]\._-]+):(?P<path>[[:alnum:]\._\-/]+).git$"
-);
-
-// gitlab-api-0.6.0: r"private_token=\w{20}"
-consistent!(gitlab_api_0, r"private_token=\w{20}");
-
-// td-client-0.7.0: "^(http://|https://)"
-consistent!(td_client_0, "^(http://|https://)");
-
-// karaconv-0.3.0: r"--(?P<type>[a-zA-Z]+)-- (?P<contents>.*)"
-consistent!(karaconv_0, r"--(?P<type>[a-zA-Z]+)-- (?P<contents>.*)");
-
-// katana-1.0.2: r"(?P<comp>et al\.)(?:\.)"
-consistent!(katana_0, r"(?P<comp>et al\.)(?:\.)");
-
-// katana-1.0.2: r"\.{3}"
-consistent!(katana_1, r"\.{3}");
-
-// katana-1.0.2: r"(?P<number>[0-9]+)\.(?P<decimal>[0-9]+)"
-consistent!(katana_2, r"(?P<number>[0-9]+)\.(?P<decimal>[0-9]+)");
-
-// katana-1.0.2: r"\s\.(?P<nums>[0-9]+)"
-consistent!(katana_3, r"\s\.(?P<nums>[0-9]+)");
-
-// katana-1.0.2: r"(?:[A-Za-z]\.){2,}"
-consistent!(katana_4, r"(?:[A-Za-z]\.){2,}");
-
-// katana-1.0.2: r"(?P<init>[A-Z])(?P<point>\.)"
-consistent!(katana_5, r"(?P<init>[A-Z])(?P<point>\.)");
-
-// katana-1.0.2: r"(?P<title>[A-Z][a-z]{1,3})(\.)"
-consistent!(katana_6, r"(?P<title>[A-Z][a-z]{1,3})(\.)");
-
-// katana-1.0.2: r"&==&(?P<p>[.!?])"
-consistent!(katana_7, r"&==&(?P<p>[.!?])");
-
-// katana-1.0.2: r"&\^&(?P<p>[.!?])"
-consistent!(katana_8, r"&\^&(?P<p>[.!?])");
-
-// katana-1.0.2: r"&\*\*&(?P<p>[.!?])"
-consistent!(katana_9, r"&\*\*&(?P<p>[.!?])");
-
-// katana-1.0.2: r"&=&(?P<p>[.!?])"
-consistent!(katana_10, r"&=&(?P<p>[.!?])");
-
-// katana-1.0.2: r"&##&(?P<p>[.!?])"
-consistent!(katana_11, r"&##&(?P<p>[.!?])");
-
-// katana-1.0.2: r"&\$&(?P<p>[.!?])"
-consistent!(katana_12, r"&\$&(?P<p>[.!?])");
-
-// kailua_syntax-1.1.0: r"@(?:_|\d+(?:/\d+(?:-\d+)?)?)"
-consistent!(kailua_syntax_0, r"@(?:_|\d+(?:/\d+(?:-\d+)?)?)");
-
-// kailua_syntax-1.1.0: r"<(\d+)>"
-consistent!(kailua_syntax_1, r"<(\d+)>");
-
-// ftp-3.0.1: r"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)"
-consistent!(ftp_0, r"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)");
-
-// ftp-3.0.1: r"\b(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\b"
-consistent!(ftp_1, r"\b(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\b");
-
-// ftp-3.0.1: r"\s+(\d+)\s*$"
-consistent!(ftp_2, r"\s+(\d+)\s*$");
-
-// vat-0.1.0: r"<countryCode>(.*?)</countryCode>"
-consistent!(vat_0, r"<countryCode>(.*?)</countryCode>");
-
-// vat-0.1.0: r"<vatNumber>(.*?)</vatNumber>"
-consistent!(vat_1, r"<vatNumber>(.*?)</vatNumber>");
-
-// vat-0.1.0: r"<name>(.*?)</name>"
-consistent!(vat_2, r"<name>(.*?)</name>");
-
-// vat-0.1.0: r"<address>(?s)(.*?)(?-s)</address>"
-consistent!(vat_3, r"<address>(?s)(.*?)(?-s)</address>");
-
-// vat-0.1.0: r"<valid>(true|false)</valid>"
-consistent!(vat_4, r"<valid>(true|false)</valid>");
-
-// vat-0.1.0: r"^ATU\d{8}$"
-consistent!(vat_5, r"^ATU\d{8}$");
-
-// vat-0.1.0: r"^BE0?\d{9, 10}$"
-consistent!(vat_6, r"^BE0?\d{9, 10}$");
-
-// vat-0.1.0: r"^BG\d{9,10}$"
-consistent!(vat_7, r"^BG\d{9,10}$");
-
-// vat-0.1.0: r"^HR\d{11}$"
-consistent!(vat_8, r"^HR\d{11}$");
-
-// vat-0.1.0: r"^CY\d{8}[A-Z]$"
-consistent!(vat_9, r"^CY\d{8}[A-Z]$");
-
-// vat-0.1.0: r"^CZ\d{8,10}$"
-consistent!(vat_10, r"^CZ\d{8,10}$");
-
-// vat-0.1.0: r"^DK\d{8}$"
-consistent!(vat_11, r"^DK\d{8}$");
-
-// vat-0.1.0: r"^EE\d{9}$"
-consistent!(vat_12, r"^EE\d{9}$");
-
-// vat-0.1.0: r"^FI\d{8}$"
-consistent!(vat_13, r"^FI\d{8}$");
-
-// vat-0.1.0: r"^FR[A-HJ-NP-Z0-9][A-HJ-NP-Z0-9]\d{9}$"
-consistent!(vat_14, r"^FR[A-HJ-NP-Z0-9][A-HJ-NP-Z0-9]\d{9}$");
-
-// vat-0.1.0: r"^DE\d{9}$"
-consistent!(vat_15, r"^DE\d{9}$");
-
-// vat-0.1.0: r"^EL\d{9}$"
-consistent!(vat_16, r"^EL\d{9}$");
-
-// vat-0.1.0: r"^HU\d{8}$"
-consistent!(vat_17, r"^HU\d{8}$");
-
-// vat-0.1.0: r"^IE\d[A-Z0-9\+\*]\d{5}[A-Z]{1,2}$"
-consistent!(vat_18, r"^IE\d[A-Z0-9\+\*]\d{5}[A-Z]{1,2}$");
-
-// vat-0.1.0: r"^IT\d{11}$"
-consistent!(vat_19, r"^IT\d{11}$");
-
-// vat-0.1.0: r"^LV\d{11}$"
-consistent!(vat_20, r"^LV\d{11}$");
-
-// vat-0.1.0: r"^LT(\d{9}|\d{12})$"
-consistent!(vat_21, r"^LT(\d{9}|\d{12})$");
-
-// vat-0.1.0: r"^LU\d{8}$"
-consistent!(vat_22, r"^LU\d{8}$");
-
-// vat-0.1.0: r"^MT\d{8}$"
-consistent!(vat_23, r"^MT\d{8}$");
-
-// vat-0.1.0: r"^NL\d{9}B\d{2}$"
-consistent!(vat_24, r"^NL\d{9}B\d{2}$");
-
-// vat-0.1.0: r"^PL\d{10}$"
-consistent!(vat_25, r"^PL\d{10}$");
-
-// vat-0.1.0: r"^PT\d{9}$"
-consistent!(vat_26, r"^PT\d{9}$");
-
-// vat-0.1.0: r"^RO\d{2,10}$"
-consistent!(vat_27, r"^RO\d{2,10}$");
-
-// vat-0.1.0: r"^SK\d{10}$"
-consistent!(vat_28, r"^SK\d{10}$");
-
-// vat-0.1.0: r"^SI\d{8}$"
-consistent!(vat_29, r"^SI\d{8}$");
-
-// vat-0.1.0: r"^ES[A-Z0-9]\d{7}[A-Z0-9]$"
-consistent!(vat_30, r"^ES[A-Z0-9]\d{7}[A-Z0-9]$");
-
-// vat-0.1.0: r"^SE\d{10}01$"
-consistent!(vat_31, r"^SE\d{10}01$");
-
-// vat-0.1.0: r"^(GB(GD|HA)\d{3}|GB\d{9}|GB\d{12})$"
-consistent!(vat_32, r"^(GB(GD|HA)\d{3}|GB\d{9}|GB\d{12})$");
-
-// eve-0.1.1: r"\{\{(.*)\}\}"
-consistent!(eve_0, r"\{\{(.*)\}\}");
-
-// egc-0.1.2: "^mio"
-consistent!(egc_0, "^mio");
-
-// pew-0.2.3: ""
-consistent!(pew_0, "");
-
-// pew-0.2.3: ""
-consistent!(pew_1, "");
-
-// mob-0.4.3: "y"
-consistent!(mob_0, "y");
-
-// lit-0.2.8: "@([a-z]+)"
-consistent!(lit_0, "@([a-z]+)");
-
-// lit-0.2.8: "([A-Z-]+):(.*)"
-consistent!(lit_1, "([A-Z-]+):(.*)");
-
-// lit-0.2.8: "^[a-zA-Z_][a-zA-Z0-9_]*$"
-consistent!(lit_2, "^[a-zA-Z_][a-zA-Z0-9_]*$");
-
-// avm-1.0.1: r"\d+\.\d+\.\d+"
-consistent!(avm_0, r"\d+\.\d+\.\d+");
-
-// avm-1.0.1: r"\d+\.\d+\.\d+"
-consistent!(avm_1, r"\d+\.\d+\.\d+");
-
-// orm-0.2.0: r"^Vec<(.+)>$"
-consistent!(orm_0, r"^Vec<(.+)>$");
-
-// sgf-0.1.5: r"\\(\r\n|\n\r|\n|\r)"
-consistent!(sgf_0, r"\\(\r\n|\n\r|\n|\r)");
-
-// sgf-0.1.5: r"\\(.)"
-consistent!(sgf_1, r"\\(.)");
-
-// sgf-0.1.5: r"\r\n|\n\r|\n|\r"
-consistent!(sgf_2, r"\r\n|\n\r|\n|\r");
-
-// sgf-0.1.5: r"([\]\\:])"
-consistent!(sgf_3, r"([\]\\:])");
-
-// dok-0.2.0: "^Bearer realm=\"(.+?)\",service=\"(.+?)\",scope=\"(.+?)\"$"
-consistent!(
-    dok_0,
-    "^Bearer realm=\"(.+?)\",service=\"(.+?)\",scope=\"(.+?)\"$"
-);
-
-// d20-0.1.0: r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)"
-consistent!(d20_0, r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)");
-
-// dvb-0.3.0: "E"
-consistent!(dvb_0, "E");
-
-// dvb-0.3.0: "^F"
-consistent!(dvb_1, "^F");
-
-// dvb-0.3.0: "^S"
-consistent!(dvb_2, "^S");
-
-// ger-0.2.0: r"Change-Id: (I[a-f0-9]{40})$"
-consistent!(ger_0, r"Change-Id: (I[a-f0-9]{40})$");
-
-// ger-0.2.0: r"(refs|ref|fix|fixes|close|closes)\s+([A-Z]{2,5}-[0-9]{1,5})$"
-consistent!(
-    ger_1,
-    r"(refs|ref|fix|fixes|close|closes)\s+([A-Z]{2,5}-[0-9]{1,5})$"
-);
-
-// n5-0.2.1: r"(\d+)(\.(\d+))?(\.(\d+))?(.*)"
-consistent!(n5_0, r"(\d+)(\.(\d+))?(\.(\d+))?(.*)");
-
-// po-0.1.4: r"[A-Za-z0-9]"
-consistent!(po_0, r"[A-Za-z0-9]");
-
-// carnix-0.8.5: "path is (‘|')?([^’'\n]*)(’|')?"
-consistent!(carnix_0, "path is (‘|')?([^’'\n]*)(’|')?");
-
-// carnix-0.8.5: r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?(.*)?"
-consistent!(carnix_1, r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?(.*)?");
-
-// carnix-0.8.5: r"(\d*)\.(\d*)\.(\d*)(-(\S*))?"
-consistent!(carnix_2, r"(\d*)\.(\d*)\.(\d*)(-(\S*))?");
-
-// carnix-0.8.5: r"(\S*)-(\d*)\.(\d*)\.(\d*)(-(\S*))?"
-consistent!(carnix_3, r"(\S*)-(\d*)\.(\d*)\.(\d*)(-(\S*))?");
-
-// caseless-0.2.1: r"^# CaseFolding-(\d+)\.(\d+)\.(\d+).txt$"
-consistent!(caseless_0, r"^# CaseFolding-(\d+)\.(\d+)\.(\d+).txt$");
-
-// caseless-0.2.1: r"^([0-9A-F]+); [CF]; ([0-9A-F ]+);"
-consistent!(caseless_1, r"^([0-9A-F]+); [CF]; ([0-9A-F ]+);");
-
-// cabot-0.2.0: "\r?\n\r?\n"
-consistent!(cabot_0, "\r?\n\r?\n");
-
-// cabot-0.2.0: "\r?\n"
-consistent!(cabot_1, "\r?\n");
-
-// card-validate-2.2.1: r"^600"
-consistent!(card_validate_0, r"^600");
-
-// card-validate-2.2.1: r"^5019"
-consistent!(card_validate_1, r"^5019");
-
-// card-validate-2.2.1: r"^4"
-consistent!(card_validate_2, r"^4");
-
-// card-validate-2.2.1: r"^(5[1-5]|2[2-7])"
-consistent!(card_validate_3, r"^(5[1-5]|2[2-7])");
-
-// card-validate-2.2.1: r"^3[47]"
-consistent!(card_validate_4, r"^3[47]");
-
-// card-validate-2.2.1: r"^3[0689]"
-consistent!(card_validate_5, r"^3[0689]");
-
-// card-validate-2.2.1: r"^6([045]|22)"
-consistent!(card_validate_6, r"^6([045]|22)");
-
-// card-validate-2.2.1: r"^(62|88)"
-consistent!(card_validate_7, r"^(62|88)");
-
-// card-validate-2.2.1: r"^35"
-consistent!(card_validate_8, r"^35");
-
-// card-validate-2.2.1: r"^[0-9]+$"
-consistent!(card_validate_9, r"^[0-9]+$");
-
-// cargo-testify-0.3.0: r"\d{1,} passed.*filtered out"
-consistent!(cargo_testify_0, r"\d{1,} passed.*filtered out");
-
-// cargo-testify-0.3.0: r"error(:|\[).*"
-consistent!(cargo_testify_1, r"error(:|\[).*");
-
-// cargo-wix-0.0.5: r"<(.*?)>"
-consistent!(cargo_wix_0, r"<(.*?)>");
-
-// cargo-wix-0.0.5: r"<(.*?)>"
-consistent!(cargo_wix_1, r"<(.*?)>");
-
-// cargo-wix-0.0.5: r"<(.*?)>"
-consistent!(cargo_wix_2, r"<(.*?)>");
-
-// cargo-wix-0.0.5: r"<(.*?)>"
-consistent!(cargo_wix_3, r"<(.*?)>");
-
-// cargo-incremental-0.1.23: r"(?m)^incremental: re-using (\d+) out of (\d+) modules$"
-consistent!(
-    cargo_incremental_0,
-    r"(?m)^incremental: re-using (\d+) out of (\d+) modules$"
-);
-
-// cargo-incremental-0.1.23: "(?m)(warning|error): (.*)\n  --> ([^:]:\\d+:\\d+)$"
-consistent!(
-    cargo_incremental_1,
-    "(?m)(warning|error): (.*)\n  --> ([^:]:\\d+:\\d+)$"
-);
-
-// cargo-incremental-0.1.23: r"(?m)^test (.*) \.\.\. (\w+)"
-consistent!(cargo_incremental_2, r"(?m)^test (.*) \.\.\. (\w+)");
-
-// cargo-incremental-0.1.23: r"(?m)(\d+) passed; (\d+) failed; (\d+) ignored; \d+ measured"
-consistent!(
-    cargo_incremental_3,
-    r"(?m)(\d+) passed; (\d+) failed; (\d+) ignored; \d+ measured"
-);
-
-// cargo-testjs-0.1.2: r"^[^-]+-[0-9a-f]+\.js$"
-consistent!(cargo_testjs_0, r"^[^-]+-[0-9a-f]+\.js$");
-
-// cargo-tarpaulin-0.6.2: r"\s*//"
-consistent!(cargo_tarpaulin_0, r"\s*//");
-
-// cargo-tarpaulin-0.6.2: r"/\*"
-consistent!(cargo_tarpaulin_1, r"/\*");
-
-// cargo-tarpaulin-0.6.2: r"\*/"
-consistent!(cargo_tarpaulin_2, r"\*/");
-
-// cargo-culture-kit-0.1.0: r"^fo"
-consistent!(cargo_culture_kit_0, r"^fo");
-
-// cargo-screeps-0.1.3: "\\s+"
-consistent!(cargo_screeps_0, "\\s+");
-
-// cargo-brew-0.1.4: r"`(\S+) v([0-9.]+)"
-consistent!(cargo_brew_0, r"`(\S+) v([0-9.]+)");
-
-// cargo-release-0.10.2: "^\\[.+\\]"
-consistent!(cargo_release_0, "^\\[.+\\]");
-
-// cargo-release-0.10.2: "^\\[\\[.+\\]\\]"
-consistent!(cargo_release_1, "^\\[\\[.+\\]\\]");
-
-// cargo-edit-0.3.0-beta.1: r"^https://github.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
-consistent!(
-    cargo_edit_0,
-    r"^https://github.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
-);
-
-// cargo-edit-0.3.0-beta.1: r"^https://gitlab.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
-consistent!(
-    cargo_edit_1,
-    r"^https://gitlab.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
-);
-
-// cargo-disassemble-0.1.1: ".*"
-consistent!(cargo_disassemble_0, ".*");
-
-// cargo-demangle-0.1.2: r"(?m)(?P<symbol>_ZN[0-9]+.*E)"
-consistent!(cargo_demangle_0, r"(?m)(?P<symbol>_ZN[0-9]+.*E)");
-
-// cargo-coverage-annotations-0.1.5: r"^\s*\}(?:\)*;?|\s*else\s*\{)$"
-consistent!(cargo_coverage_annotations_0, r"^\s*\}(?:\)*;?|\s*else\s*\{)$");
-
-// cargo-urlcrate-1.0.1: "[\u{001b}\u{009b}][\\[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]"
-consistent!(cargo_urlcrate_0, "[\u{001b}\u{009b}][\\[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]");
-
-// cargo-script-0.2.8: r"^\s*\*( |$)"
-consistent!(cargo_script_0, r"^\s*\*( |$)");
-
-// cargo-script-0.2.8: r"^(\s+)"
-consistent!(cargo_script_1, r"^(\s+)");
-
-// cargo-script-0.2.8: r"/\*|\*/"
-consistent!(cargo_script_2, r"/\*|\*/");
-
-// cargo-script-0.2.8: r"^\s*//!"
-consistent!(cargo_script_3, r"^\s*//!");
-
-// cargo-script-0.2.8: r"^#![^\[].*?(\r\n|\n)"
-consistent!(cargo_script_4, r"^#![^\[].*?(\r\n|\n)");
-
-// cargo-update-1.5.2: r"cargo-install-update\.exe-v.+"
-consistent!(cargo_update_0, r"cargo-install-update\.exe-v.+");
-
-// canteen-0.4.1: r"^<(?:(int|uint|str|float|path):)?([\w_][a-zA-Z0-9_]*)>$"
-consistent!(
-    canteen_0,
-    r"^<(?:(int|uint|str|float|path):)?([\w_][a-zA-Z0-9_]*)>$"
-);
-
-// thruster-cli-0.1.3: r"(.)([A-Z])"
-consistent!(thruster_cli_0, r"(.)([A-Z])");
-
-// thieves-cant-0.1.0: "([Z]+)$"
-consistent!(thieves_cant_0, "([Z]+)$");
-
-// codeowners-0.1.3: r"^@\S+/\S+"
-consistent!(codeowners_0, r"^@\S+/\S+");
-
-// codeowners-0.1.3: r"^@\S+"
-consistent!(codeowners_1, r"^@\S+");
-
-// codeowners-0.1.3: r"^\S+@\S+"
-consistent!(codeowners_2, r"^\S+@\S+");
-
-// conserve-0.4.2: r"^b0000 {21} complete   20[-0-9T:+]+\s +\d+s\n$"
-consistent!(conserve_0, r"^b0000 {21} complete   20[-0-9T:+]+\s +\d+s\n$");
-
-// commodore-0.3.0: r"(?P<greeting>\S+?) (?P<name>\S+?)$"
-consistent!(commodore_0, r"(?P<greeting>\S+?) (?P<name>\S+?)$");
-
-// corollary-0.3.0: r"([ \t]*)```haskell([\s\S]*?)```"
-consistent!(corollary_0, r"([ \t]*)```haskell([\s\S]*?)```");
-
-// corollary-0.3.0: r"\b((?:a|b|t)\d*)\b"
-consistent!(corollary_1, r"\b((?:a|b|t)\d*)\b");
-
-// colorizex-0.1.3: "NB"
-consistent!(colorizex_0, "NB");
-
-// colorstring-0.0.1: r"(?i)\[[a-z0-9_-]+\]"
-consistent!(colorstring_0, r"(?i)\[[a-z0-9_-]+\]");
-
-// colorstring-0.0.1: r"^(?i)(\[[a-z0-9_-]+\])+"
-consistent!(colorstring_1, r"^(?i)(\[[a-z0-9_-]+\])+");
-
-// cosmogony-0.3.0: "name:(.+)"
-consistent!(cosmogony_0, "name:(.+)");
-
-// cobalt-bin-0.12.1: r"(?m:^ {0,3}\[[^\]]+\]:.+$)"
-consistent!(cobalt_bin_0, r"(?m:^ {0,3}\[[^\]]+\]:.+$)");
-
-// comrak-0.2.12: r"[^\p{L}\p{M}\p{N}\p{Pc} -]"
-consistent!(comrak_0, r"[^\p{L}\p{M}\p{N}\p{Pc} -]");
-
-// content-blocker-0.2.3: ""
-consistent!(content_blocker_0, "");
-
-// content-blocker-0.2.3: "(?i)hi"
-consistent!(content_blocker_1, "(?i)hi");
-
-// content-blocker-0.2.3: "http[s]?://domain.org"
-consistent!(content_blocker_2, "http[s]?://domain.org");
-
-// content-blocker-0.2.3: "(?i)http[s]?://domain.org"
-consistent!(content_blocker_3, "(?i)http[s]?://domain.org");
-
-// content-blocker-0.2.3: "http://domain.org"
-consistent!(content_blocker_4, "http://domain.org");
-
-// content-blocker-0.2.3: "http://domain.org"
-consistent!(content_blocker_5, "http://domain.org");
-
-// content-blocker-0.2.3: "ad.html"
-consistent!(content_blocker_6, "ad.html");
-
-// content-blocker-0.2.3: "ad.html"
-consistent!(content_blocker_7, "ad.html");
-
-// content-blocker-0.2.3: "http://domain.org"
-consistent!(content_blocker_8, "http://domain.org");
-
-// content-blocker-0.2.3: "http://domain.org/nocookies.sjs"
-consistent!(content_blocker_9, "http://domain.org/nocookies.sjs");
-
-// content-blocker-0.2.3: "http://domain.org/nocookies.sjs"
-consistent!(content_blocker_10, "http://domain.org/nocookies.sjs");
-
-// content-blocker-0.2.3: "http://domain.org/hideme.jpg"
-consistent!(content_blocker_11, "http://domain.org/hideme.jpg");
-
-// content-blocker-0.2.3: "http://domain.org/ok.html"
-consistent!(content_blocker_12, "http://domain.org/ok.html");
-
-// content-blocker-0.2.3: "http://domain.org/ok.html\\?except_this=1"
-consistent!(content_blocker_13, "http://domain.org/ok.html\\?except_this=1");
-
-// victoria-dom-0.1.2: "[A-Za-z0-9=]"
-consistent!(victoria_dom_0, "[A-Za-z0-9=]");
-
-// numbat-1.0.0: r"^nsq://"
-consistent!(numbat_0, r"^nsq://");
-
-// airkorea-0.1.2: r"[\s\t\r\n]"
-consistent!(airkorea_0, r"[\s\t\r\n]");
-
-// airkorea-0.1.2: r"([\{\[,])|([\}\]])"
-consistent!(airkorea_1, r"([\{\[,])|([\}\]])");
-
-// airkorea-0.1.2: r"[^.\d]+$"
-consistent!(airkorea_2, r"[^.\d]+$");
-
-// rofl-0.0.1: r"\b"
-// consistent!(rofl_0, r"\b");
-
-// rogcat-0.2.15: r"--------- beginning of.*"
-consistent!(rogcat_0, r"--------- beginning of.*");
-
-// rogcat-0.2.15: r"a|e|i|o|u"
-consistent!(rogcat_1, r"a|e|i|o|u");
-
-// rogcat-0.2.15: r"^(\d+)([kMG])$"
-consistent!(rogcat_2, r"^(\d+)([kMG])$");
-
-// media_filename-0.1.4: "\\.([A-Za-z0-9]{2,4})$"
-consistent!(media_filename_0, "\\.([A-Za-z0-9]{2,4})$");
-
-// media_filename-0.1.4: "([0-9]{3,4}p|[0-9]{3,4}x[0-9]{3,4})"
-consistent!(media_filename_1, "([0-9]{3,4}p|[0-9]{3,4}x[0-9]{3,4})");
-
-// media_filename-0.1.4: "(?:^\\[([^]]+)\\]|- ?([^-]+)$)"
-consistent!(media_filename_2, "(?:^\\[([^]]+)\\]|- ?([^-]+)$)");
-
-// media_filename-0.1.4: "(?:[eE]([0-9]{2,3})|[^0-9A-Za-z]([0-9]{2,3})(?:v[0-9])?[^0-9A-Za-z])"
-consistent!(
-    media_filename_3,
-    "(?:[eE]([0-9]{2,3})|[^0-9A-Za-z]([0-9]{2,3})(?:v[0-9])?[^0-9A-Za-z])"
-);
-
-// media_filename-0.1.4: "[sS]([0-9]{1,2})"
-consistent!(media_filename_4, "[sS]([0-9]{1,2})");
-
-// media_filename-0.1.4: "((?i)(?:PPV.)?[HP]DTV|(?:HD)?CAM|BRRIP|[^a-z]TS[^a-z]|(?:PPV )?WEB.?DL(?: DVDRip)?|HDRip|DVDRip|CamRip|W[EB]BRip|BluRay|BD|DVD|DvDScr|hdtv)"
-consistent!(media_filename_5, "((?i)(?:PPV.)?[HP]DTV|(?:HD)?CAM|BRRIP|[^a-z]TS[^a-z]|(?:PPV )?WEB.?DL(?: DVDRip)?|HDRip|DVDRip|CamRip|W[EB]BRip|BluRay|BD|DVD|DvDScr|hdtv)");
-
-// media_filename-0.1.4: "((19[0-9]|20[01])[0-9])"
-consistent!(media_filename_6, "((19[0-9]|20[01])[0-9])");
-
-// media_filename-0.1.4: "((?i)xvid|x264|h\\.?264)"
-consistent!(media_filename_7, "((?i)xvid|x264|h\\.?264)");
-
-// media_filename-0.1.4: "((?i)MP3|DD5\\.?1|Dual[- ]Audio|LiNE|DTS|AAC(?:\\.?2\\.0)?|AC3(?:\\.5\\.1)?)"
-consistent!(media_filename_8, "((?i)MP3|DD5\\.?1|Dual[- ]Audio|LiNE|DTS|AAC(?:\\.?2\\.0)?|AC3(?:\\.5\\.1)?)");
-
-// media_filename-0.1.4: "\\[([0-9A-F]{8})\\]"
-consistent!(media_filename_9, "\\[([0-9A-F]{8})\\]");
-
-// termimage-0.3.2: r"(\d+)[xX](\d+)"
-consistent!(termimage_0, r"(\d+)[xX](\d+)");
-
-// teensy-0.1.0: r".*(\d{4}-\d{2}-\d{2}).*"
-consistent!(teensy_0, r".*(\d{4}-\d{2}-\d{2}).*");
-
-// telescreen-0.1.3: r"<@(.+)>"
-consistent!(telescreen_0, r"<@(.+)>");
-
-// tempus_fugit-0.4.4: r"^(\d+)"
-consistent!(tempus_fugit_0, r"^(\d+)");
-
-// fselect-0.4.1: "(\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)"
-consistent!(fselect_0, "(\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)");
-
-// fselect-0.4.1: "(%|_|\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)"
-consistent!(fselect_1, "(%|_|\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)");
-
-// fs_eventbridge-0.1.0: r"^([A-Z]+)(?:\s(.+))?\s*"
-consistent!(fs_eventbridge_0, r"^([A-Z]+)(?:\s(.+))?\s*");
-
-// joseki-0.0.1: r"(\w{1,2})\[(.+?)\]"
-consistent!(joseki_0, r"(\w{1,2})\[(.+?)\]");
-
-// tweetr-0.2.1: r"(?i)in (\d+) (second|minute|hour|day|week)s?"
-consistent!(tweetr_0, r"(?i)in (\d+) (second|minute|hour|day|week)s?");
-
-// bullet_core-0.1.1: "^(?u:[0-9])+"
-consistent!(bullet_core_0, "^(?u:[0-9])+");
-
-// bullet_core-0.1.1: "^(?u:[0-9])+(?u:\\.)(?u:[0-9])+"
-consistent!(bullet_core_1, "^(?u:[0-9])+(?u:\\.)(?u:[0-9])+");
-
-// bullet_core-0.1.1: "^(?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+"
-consistent!(bullet_core_2, "^(?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+");
-
-// bullet_core-0.1.1: "^(?u:d/d)((?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+)"
-consistent!(bullet_core_3, "^(?u:d/d)((?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+)");
-
-// bullet_core-0.1.1: "^(?u:\\()"
-consistent!(bullet_core_4, "^(?u:\\()");
-
-// bullet_core-0.1.1: "^(?u:\\))"
-consistent!(bullet_core_5, "^(?u:\\))");
-
-// bullet_core-0.1.1: "^(?u:\\*)"
-consistent!(bullet_core_6, "^(?u:\\*)");
-
-// bullet_core-0.1.1: "^(?u:\\+)"
-consistent!(bullet_core_7, "^(?u:\\+)");
-
-// bullet_core-0.1.1: "^(?u:,)"
-consistent!(bullet_core_8, "^(?u:,)");
-
-// bullet_core-0.1.1: "^(?u:\\-)"
-consistent!(bullet_core_9, "^(?u:\\-)");
-
-// bullet_core-0.1.1: "^(?u:/)"
-consistent!(bullet_core_10, "^(?u:/)");
-
-// bullet_core-0.1.1: "^(?u:\\[)"
-consistent!(bullet_core_11, "^(?u:\\[)");
-
-// bullet_core-0.1.1: "^(?u:\\])"
-consistent!(bullet_core_12, "^(?u:\\])");
-
-// bullet_core-0.1.1: "^(?u:\\^)"
-consistent!(bullet_core_13, "^(?u:\\^)");
-
-// bullet_core-0.1.1: "^(?u:·)"
-consistent!(bullet_core_14, "^(?u:·)");
-
-// actix-web-0.6.13: "//+"
-consistent!(actix_web_0, "//+");
-
-// actix-web-0.6.13: "//+"
-consistent!(actix_web_1, "//+");
-
-// althea_kernel_interface-0.1.0: r"(\S*) .* (\S*) (REACHABLE|STALE|DELAY)"
-consistent!(
-    althea_kernel_interface_0,
-    r"(\S*) .* (\S*) (REACHABLE|STALE|DELAY)"
-);
-
-// althea_kernel_interface-0.1.0: r"-s (.*) --ip6-dst (.*)/.* bcnt = (.*)"
-consistent!(
-    althea_kernel_interface_1,
-    r"-s (.*) --ip6-dst (.*)/.* bcnt = (.*)"
-);
-
-// alcibiades-0.3.0: r"\buci(?:\s|$)"
-consistent!(alcibiades_0, r"\buci(?:\s|$)");
-
-// ruma-identifiers-0.11.0: r"\A[a-z0-9._=-]+\z"
-consistent!(ruma_identifiers_0, r"\A[a-z0-9._=-]+\z");
-
-// rusqbin-0.2.3: r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})$"
-consistent!(rusqbin_0, r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})$");
-
-// rusqbin-0.2.3: r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})/requests/?$"
-consistent!(rusqbin_1, r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})/requests/?$");
-
-// rust-install-0.0.4: r"^(nightly|beta|stable)(?:-(\d{4}-\d{2}-\d{2}))?$"
-consistent!(
-    rust_install_0,
-    r"^(nightly|beta|stable)(?:-(\d{4}-\d{2}-\d{2}))?$"
-);
-
-// rust_inbox-0.0.5: "^+(.*)\r\n"
-consistent!(rust_inbox_0, "^+(.*)\r\n");
-
-// rust_inbox-0.0.5: r"^\* CAPABILITY (.*)\r\n"
-consistent!(rust_inbox_1, r"^\* CAPABILITY (.*)\r\n");
-
-// rust_inbox-0.0.5: r"^([a-zA-Z0-9]+) (OK|NO|BAD)(.*)"
-consistent!(rust_inbox_2, r"^([a-zA-Z0-9]+) (OK|NO|BAD)(.*)");
-
-// rust_inbox-0.0.5: r"^\* (\d+) EXISTS\r\n"
-consistent!(rust_inbox_3, r"^\* (\d+) EXISTS\r\n");
-
-// rust_inbox-0.0.5: r"^\* (\d+) RECENT\r\n"
-consistent!(rust_inbox_4, r"^\* (\d+) RECENT\r\n");
-
-// rust_inbox-0.0.5: r"^\* FLAGS (.+)\r\n"
-consistent!(rust_inbox_5, r"^\* FLAGS (.+)\r\n");
-
-// rust_inbox-0.0.5: r"^\* OK \[UNSEEN (\d+)\](.*)\r\n"
-consistent!(rust_inbox_6, r"^\* OK \[UNSEEN (\d+)\](.*)\r\n");
-
-// rust_inbox-0.0.5: r"^\* OK \[UIDVALIDITY (\d+)\](.*)\r\n"
-consistent!(rust_inbox_7, r"^\* OK \[UIDVALIDITY (\d+)\](.*)\r\n");
-
-// rust_inbox-0.0.5: r"^\* OK \[UIDNEXT (\d+)\](.*)\r\n"
-consistent!(rust_inbox_8, r"^\* OK \[UIDNEXT (\d+)\](.*)\r\n");
-
-// rust_inbox-0.0.5: r"^\* OK \[PERMANENTFLAGS (.+)\](.*)\r\n"
-consistent!(rust_inbox_9, r"^\* OK \[PERMANENTFLAGS (.+)\](.*)\r\n");
-
-// rustml-0.0.7: r"^[a-z]+ (\d+)$"
-consistent!(rustml_0, r"^[a-z]+ (\d+)$");
-
-// rustml-0.0.7: r"^[a-z]+ (\d+)$"
-consistent!(rustml_1, r"^[a-z]+ (\d+)$");
-
-// rustml-0.0.7: r"^[a-z]+ (\d+)$"
-consistent!(rustml_2, r"^[a-z]+ (\d+)$");
-
-// rustfmt-0.10.0: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
-consistent!(rustfmt_0, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
-
-// rustfmt-core-0.4.0: r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)"
-consistent!(rustfmt_core_0, r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)");
-
-// rustfmt-core-0.4.0: r"^## `([^`]+)`"
-consistent!(rustfmt_core_1, r"^## `([^`]+)`");
-
-// rustfmt-core-0.4.0: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
-consistent!(rustfmt_core_2, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
-
-// rustfmt-core-0.4.0: r"\s;"
-consistent!(rustfmt_core_3, r"\s;");
-
-// rust-enum-derive-0.4.0: r"^(0x)?([:digit:]+)$"
-consistent!(rust_enum_derive_0, r"^(0x)?([:digit:]+)$");
-
-// rust-enum-derive-0.4.0: r"^([:digit:]+)[:space:]*<<[:space:]*([:digit:]+)$"
-consistent!(
-    rust_enum_derive_1,
-    r"^([:digit:]+)[:space:]*<<[:space:]*([:digit:]+)$"
-);
-
-// rust-enum-derive-0.4.0: r"^[:space:]*([[:alnum:]_]+)([:space:]*=[:space:]*([:graph:]+))?[:space:]*,"
-consistent!(rust_enum_derive_2, r"^[:space:]*([[:alnum:]_]+)([:space:]*=[:space:]*([:graph:]+))?[:space:]*,");
-
-// rust-enum-derive-0.4.0: r"^#define[:space:]+([:graph:]+)[:space:]+([:graph:]+)"
-consistent!(
-    rust_enum_derive_3,
-    r"^#define[:space:]+([:graph:]+)[:space:]+([:graph:]+)"
-);
-
-// rustsourcebundler-0.2.0: r"^\s*pub mod (.+);$"
-consistent!(rustsourcebundler_0, r"^\s*pub mod (.+);$");
-
-// rustsourcebundler-0.2.0: r"^\s*pub mod (.+);$"
-consistent!(rustsourcebundler_1, r"^\s*pub mod (.+);$");
-
-// rustfmt-nightly-0.8.2: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
-consistent!(rustfmt_nightly_0, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
-
-// rustfmt-nightly-0.8.2: r"\s;"
-consistent!(rustfmt_nightly_1, r"\s;");
-
-// rustache-0.1.0: r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)"
-consistent!(rustache_0, r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)");
-
-// rustfilt-0.2.0: r"_ZN[\$\._[:alnum:]]*"
-consistent!(rustfilt_0, r"_ZN[\$\._[:alnum:]]*");
-
-// rustache-lists-0.1.2: r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)"
-consistent!(rustache_lists_0, r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)");
-
-// rural-0.7.3: "(.+)=(.+)"
-consistent!(rural_0, "(.+)=(.+)");
-
-// rural-0.7.3: "(.*):(.+)"
-consistent!(rural_1, "(.*):(.+)");
-
-// rural-0.7.3: "(.+):=(.+)"
-consistent!(rural_2, "(.+):=(.+)");
-
-// rural-0.7.3: "(.*)==(.+)"
-consistent!(rural_3, "(.*)==(.+)");
-
-// rusoto_credential-0.11.0: r"^\[([^\]]+)\]$"
-consistent!(rusoto_credential_0, r"^\[([^\]]+)\]$");
-
-// rumblebars-0.3.0: "([:blank:]*)$"
-consistent!(rumblebars_0, "([:blank:]*)$");
-
-// rumblebars-0.3.0: "(\r?\n)[:blank:]*(\\{\\{~?[#!/](?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
-consistent!(rumblebars_1, "(\r?\n)[:blank:]*(\\{\\{~?[#!/](?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z");
-
-// rumblebars-0.3.0: "(\r?\n[:blank:]*)(\\{\\{~?>(?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
-consistent!(
-    rumblebars_2,
-    "(\r?\n[:blank:]*)(\\{\\{~?>(?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
-);
-
-// rumblebars-0.3.0: "((?:[:blank:]|\r?\n)*)(\r?\n)[:blank:]*$"
-consistent!(rumblebars_3, "((?:[:blank:]|\r?\n)*)(\r?\n)[:blank:]*$");
-
-// rumblebars-0.3.0: "^([:blank:]*\r?\n)(.*)"
-consistent!(rumblebars_4, "^([:blank:]*\r?\n)(.*)");
-
-// diesel_cli-1.3.1: r"(?P<stamp>[\d-]*)_hello"
-consistent!(diesel_cli_0, r"(?P<stamp>[\d-]*)_hello");
-
-// dishub-0.1.1: r"(\d+)s"
-consistent!(dishub_0, r"(\d+)s");
-
-// spreadsheet_textconv-0.1.0: r"\n"
-consistent!(spreadsheet_textconv_0, r"\n");
-
-// spreadsheet_textconv-0.1.0: r"\r"
-consistent!(spreadsheet_textconv_1, r"\r");
-
-// spreadsheet_textconv-0.1.0: r"\t"
-consistent!(spreadsheet_textconv_2, r"\t");
-
-// split_aud-0.1.0: r"DELAY (-?\d+)ms"
-consistent!(split_aud_0, r"DELAY (-?\d+)ms");
-
-// split_aud-0.1.0: r"Trim\((\d+), ?(\d+)\)"
-consistent!(split_aud_1, r"Trim\((\d+), ?(\d+)\)");
-
-// spotrust-0.0.5: r"spotify:[a-z]+:[a-zA-Z0-9]+"
-consistent!(spotrust_0, r"spotify:[a-z]+:[a-zA-Z0-9]+");
-
-// spaceslugs-0.1.0: r"[^\x00-\x7F]"
-consistent!(spaceslugs_0, r"[^\x00-\x7F]");
-
-// spaceslugs-0.1.0: r"[']+"
-consistent!(spaceslugs_1, r"[']+");
-
-// spaceslugs-0.1.0: r"\W+"
-consistent!(spaceslugs_2, r"\W+");
-
-// spaceslugs-0.1.0: r"[ ]+"
-consistent!(spaceslugs_3, r"[ ]+");
-
-// space_email_api-0.1.1: "PHPSESSID=([0-9a-f]+)"
-consistent!(space_email_api_0, "PHPSESSID=([0-9a-f]+)");
-
-// lorikeet-0.7.0: "[^0-9.,]"
-consistent!(lorikeet_0, "[^0-9.,]");
-
-// claude-0.3.0: r"^(?:\b|(-)?)(\p{Currency_Symbol})?((?:(?:\d{1,3}[\.,])+\d{3})|\d+)(?:[\.,](\d{2}))?\b$"
-consistent!(claude_0, r"^(?:\b|(-)?)(\p{Currency_Symbol})?((?:(?:\d{1,3}[\.,])+\d{3})|\d+)(?:[\.,](\d{2}))?\b$");
-
-// clam-0.1.6: r"<%=\s*(.+?)\s*%>"
-consistent!(clam_0, r"<%=\s*(.+?)\s*%>");
-
-// classifier-0.0.3: r"(\s)"
-consistent!(classifier_0, r"(\s)");
-
-// click-0.3.2: r"(-----BEGIN .*-----\n)((?:(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)*\n)+)(-----END .*-----)"
-consistent!(click_0, r"(-----BEGIN .*-----\n)((?:(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)*\n)+)(-----END .*-----)");
-
-// click-0.3.2: r"-----BEGIN PRIVATE KEY-----"
-consistent!(click_1, r"-----BEGIN PRIVATE KEY-----");
-
-// ultrastar-txt-0.1.2: r"#([A-Z3a-z]*):(.*)"
-consistent!(ultrastar_txt_0, r"#([A-Z3a-z]*):(.*)");
-
-// ultrastar-txt-0.1.2: "^-\\s?(-?[0-9]+)\\s*$"
-consistent!(ultrastar_txt_1, "^-\\s?(-?[0-9]+)\\s*$");
-
-// ultrastar-txt-0.1.2: "^-\\s?(-?[0-9]+)\\s+(-?[0-9]+)"
-consistent!(ultrastar_txt_2, "^-\\s?(-?[0-9]+)\\s+(-?[0-9]+)");
-
-// ultrastar-txt-0.1.2: "^(.)\\s*(-?[0-9]+)\\s+(-?[0-9]+)\\s+(-?[0-9]+)\\s?(.*)"
-consistent!(
-    ultrastar_txt_3,
-    "^(.)\\s*(-?[0-9]+)\\s+(-?[0-9]+)\\s+(-?[0-9]+)\\s?(.*)"
-);
-
-// ultrastar-txt-0.1.2: "^P\\s?(-?[0-9]+)"
-consistent!(ultrastar_txt_4, "^P\\s?(-?[0-9]+)");
-
-// db-accelerate-2.0.0: r"^template\.add($|\..+$)"
-consistent!(db_accelerate_0, r"^template\.add($|\..+$)");
-
-// db-accelerate-2.0.0: r"^template\.sub($|\..+$)"
-consistent!(db_accelerate_1, r"^template\.sub($|\..+$)");
-
-// sterling-0.3.0: r"(\d+)([cegps])"
-consistent!(sterling_0, r"(\d+)([cegps])");
-
-// stache-0.2.0: r"[^\w]"
-consistent!(stache_0, r"[^\w]");
-
-// strukt-0.1.0: "\"([<>]?)([xcbB\\?hHiIlLqQfdspP]*)\""
-consistent!(strukt_0, "\"([<>]?)([xcbB\\?hHiIlLqQfdspP]*)\"");
-
-// steamid-ng-0.3.1: r"^STEAM_([0-4]):([0-1]):([0-9]{1,10})$"
-consistent!(steamid_ng_0, r"^STEAM_([0-4]):([0-1]):([0-9]{1,10})$");
-
-// steamid-ng-0.3.1: r"^\[([AGMPCgcLTIUai]):([0-4]):([0-9]{1,10})(:([0-9]+))?\]$"
-consistent!(
-    steamid_ng_1,
-    r"^\[([AGMPCgcLTIUai]):([0-4]):([0-9]{1,10})(:([0-9]+))?\]$"
-);
-
-// strscan-0.1.1: r"^\w+"
-consistent!(strscan_0, r"^\w+");
-
-// strscan-0.1.1: r"^\s+"
-consistent!(strscan_1, r"^\s+");
-
-// strscan-0.1.1: r"^\w+"
-consistent!(strscan_2, r"^\w+");
-
-// strscan-0.1.1: r"^\s+"
-consistent!(strscan_3, r"^\s+");
-
-// strscan-0.1.1: r"^(\w+)\s+"
-consistent!(strscan_4, r"^(\w+)\s+");
-
-// tk-carbon-0.2.0: r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$"
-consistent!(tk_carbon_0, r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$");
-
-// tk-carbon-0.2.0: r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$"
-consistent!(tk_carbon_1, r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$");
-
-// evalrs-0.0.10: r"extern\s+crate\s+([a-z0-9_]+)\s*;(\s*//(.+))?"
-consistent!(evalrs_0, r"extern\s+crate\s+([a-z0-9_]+)\s*;(\s*//(.+))?");
-
-// evalrs-0.0.10: r"(?m)^# "
-consistent!(evalrs_1, r"(?m)^# ");
-
-// evalrs-0.0.10: r"(?m)^\s*fn +main *\( *\)"
-consistent!(evalrs_2, r"(?m)^\s*fn +main *\( *\)");
-
-// evalrs-0.0.10: r"(extern\s+crate\s+[a-z0-9_]+\s*;)"
-consistent!(evalrs_3, r"(extern\s+crate\s+[a-z0-9_]+\s*;)");
-
-// gate_build-0.5.0: "(.*)_t([0-9]+)"
-consistent!(gate_build_0, "(.*)_t([0-9]+)");
-
-// rake-0.1.1: r"[^\P{P}-]|\s+-\s+"
-consistent!(rake_0, r"[^\P{P}-]|\s+-\s+");
-
-// rafy-0.2.1: r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*"
-consistent!(rafy_0, r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*");
-
-// raven-0.2.1: r"^(?P<protocol>.*?)://(?P<public_key>.*?):(?P<secret_key>.*?)@(?P<host>.*?)/(?P<path>.*/)?(?P<project_id>.*)$"
-consistent!(raven_0, r"^(?P<protocol>.*?)://(?P<public_key>.*?):(?P<secret_key>.*?)@(?P<host>.*?)/(?P<path>.*/)?(?P<project_id>.*)$");
-
-// rargs-0.2.0: r"\{[[:space:]]*[^{}]*[[:space:]]*\}"
-consistent!(rargs_0, r"\{[[:space:]]*[^{}]*[[:space:]]*\}");
-
-// rargs-0.2.0: r"^\{[[:space:]]*(?P<name>[[:word:]]*)[[:space:]]*\}$"
-consistent!(rargs_1, r"^\{[[:space:]]*(?P<name>[[:word:]]*)[[:space:]]*\}$");
-
-// rargs-0.2.0: r"^\{[[:space:]]*(?P<num>-?\d+)[[:space:]]*\}$"
-consistent!(rargs_2, r"^\{[[:space:]]*(?P<num>-?\d+)[[:space:]]*\}$");
-
-// rargs-0.2.0: r"^\{(?P<left>-?\d*)?\.\.(?P<right>-?\d*)?(?::(?P<sep>.*))?\}$"
-consistent!(
-    rargs_3,
-    r"^\{(?P<left>-?\d*)?\.\.(?P<right>-?\d*)?(?::(?P<sep>.*))?\}$"
-);
-
-// rargs-0.2.0: r"(.*?)[[:space:]]+|(.*?)$"
-consistent!(rargs_4, r"(.*?)[[:space:]]+|(.*?)$");
-
-// indradb-lib-0.15.0: r"[a-zA-Z0-9]{8}"
-consistent!(indradb_lib_0, r"[a-zA-Z0-9]{8}");
-
-// fungi-lang-0.1.50: r"::"
-consistent!(fungi_lang_0, r"::");
-
-// nickel-0.10.1: "/hello/(?P<name>[a-zA-Z]+)"
-consistent!(nickel_0, "/hello/(?P<name>[a-zA-Z]+)");
-
-// nickel-0.10.1: "/hello/(?P<name>[a-zA-Z]+)"
-consistent!(nickel_1, "/hello/(?P<name>[a-zA-Z]+)");
-
-// pact_verifier-0.4.0: r"\{(\w+)\}"
-consistent!(pact_verifier_0, r"\{(\w+)\}");
-
-// pact_matching-0.4.1: "application/.*json"
-consistent!(pact_matching_0, "application/.*json");
-
-// pact_matching-0.4.1: "application/json.*"
-consistent!(pact_matching_1, "application/json.*");
-
-// pact_matching-0.4.1: "application/.*xml"
-consistent!(pact_matching_2, "application/.*xml");
-
-// pangu-0.2.0: "([\"'\\(\\[\\{{<\u{201c}])(\\s*)(.+?)(\\s*)([\"'\\)\\]\\}}>\u{201d}])"
-consistent!(
-    pangu_0,
-    "([\"'\\(\\[\\{{<\u{201c}])(\\s*)(.+?)(\\s*)([\"'\\)\\]\\}}>\u{201d}])"
-);
-
-// pangu-0.2.0: "([\\(\\[\\{{<\u{201c}]+)(\\s*)(.+?)(\\s*)([\\)\\]\\}}>\u{201d}]+)"
-consistent!(
-    pangu_1,
-    "([\\(\\[\\{{<\u{201c}]+)(\\s*)(.+?)(\\s*)([\\)\\]\\}}>\u{201d}]+)"
-);
-
-// parser-haskell-0.2.0: r"\{-[\s\S]*?-\}"
-consistent!(parser_haskell_0, r"\{-[\s\S]*?-\}");
-
-// parser-haskell-0.2.0: r"(?m);+\s*$"
-consistent!(parser_haskell_1, r"(?m);+\s*$");
-
-// parser-haskell-0.2.0: r"(?m)^#(if|ifn?def|endif|else|include|elif).*"
-consistent!(parser_haskell_2, r"(?m)^#(if|ifn?def|endif|else|include|elif).*");
-
-// parser-haskell-0.2.0: r"'([^'\\]|\\[A-Z]{1,3}|\\.)'"
-consistent!(parser_haskell_3, r"'([^'\\]|\\[A-Z]{1,3}|\\.)'");
-
-// parser-haskell-0.2.0: r"forall\s+(.*?)\."
-consistent!(parser_haskell_4, r"forall\s+(.*?)\.");
-
-// html2md-0.2.1: "\\s{2,}"
-consistent!(html2md_0, "\\s{2,}");
-
-// html2md-0.2.1: "\\n{2,}"
-consistent!(html2md_1, "\\n{2,}");
-
-// html2md-0.2.1: "(?m)(\\S) $"
-consistent!(html2md_2, "(?m)(\\S) $");
-
-// html2md-0.2.1: "(?m)^[-*] "
-consistent!(html2md_3, "(?m)^[-*] ");
-
-// ovpnfile-0.1.2: r"#.*$"
-consistent!(ovpnfile_0, r"#.*$");
-
-// ovpnfile-0.1.2: r"^<(\S+)>"
-consistent!(ovpnfile_1, r"^<(\S+)>");
-
-// ovpnfile-0.1.2: r"^</(\S+)>"
-consistent!(ovpnfile_2, r"^</(\S+)>");
-
-// screenruster-saver-fractal-0.1.1: r"#([:xdigit:]{2})([:xdigit:]{2})([:xdigit:]{2})"
-consistent!(
-    screenruster_saver_fractal_0,
-    r"#([:xdigit:]{2})([:xdigit:]{2})([:xdigit:]{2})"
-);
-
-// scarlet-0.2.2: r"rgb\((?: *(\d{1,3}),)(?: *(\d{1,3}),)(?: *(\d{1,3}))\)"
-consistent!(
-    scarlet_0,
-    r"rgb\((?: *(\d{1,3}),)(?: *(\d{1,3}),)(?: *(\d{1,3}))\)"
-);
-
-// cpp_to_rust_generator-0.2.0: r"^([\w:]+)<(.+)>$"
-consistent!(cpp_to_rust_generator_0, r"^([\w:]+)<(.+)>$");
-
-// cpp_to_rust_generator-0.2.0: r"^type-parameter-(\d+)-(\d+)$"
-consistent!(cpp_to_rust_generator_1, r"^type-parameter-(\d+)-(\d+)$");
-
-// cpp_to_rust_generator-0.2.0: r"^([\w~]+)<[^<>]+>$"
-consistent!(cpp_to_rust_generator_2, r"^([\w~]+)<[^<>]+>$");
-
-// cpp_to_rust_generator-0.2.0: r"(signals|Q_SIGNALS)\s*:"
-consistent!(cpp_to_rust_generator_3, r"(signals|Q_SIGNALS)\s*:");
-
-// cpp_to_rust_generator-0.2.0: r"(slots|Q_SLOTS)\s*:"
-consistent!(cpp_to_rust_generator_4, r"(slots|Q_SLOTS)\s*:");
-
-// cpp_to_rust_generator-0.2.0: r"(public|protected|private)\s*:"
-consistent!(cpp_to_rust_generator_5, r"(public|protected|private)\s*:");
-
-// cpp_to_rust-0.5.3: r"^([\w:]+)<(.+)>$"
-consistent!(cpp_to_rust_0, r"^([\w:]+)<(.+)>$");
-
-// cpp_to_rust-0.5.3: r"^type-parameter-(\d+)-(\d+)$"
-consistent!(cpp_to_rust_1, r"^type-parameter-(\d+)-(\d+)$");
-
-// cpp_to_rust-0.5.3: r"^([\w~]+)<[^<>]+>$"
-consistent!(cpp_to_rust_2, r"^([\w~]+)<[^<>]+>$");
-
-// cpp_to_rust-0.5.3: r"(signals|Q_SIGNALS)\s*:"
-consistent!(cpp_to_rust_3, r"(signals|Q_SIGNALS)\s*:");
-
-// cpp_to_rust-0.5.3: r"(slots|Q_SLOTS)\s*:"
-consistent!(cpp_to_rust_4, r"(slots|Q_SLOTS)\s*:");
-
-// cpp_to_rust-0.5.3: r"(public|protected|private)\s*:"
-consistent!(cpp_to_rust_5, r"(public|protected|private)\s*:");
-
-// fritzbox_logs-0.2.0: "(\\d{2}\\.\\d{2}\\.\\d{2}) (\\d{2}:\\d{2}:\\d{2}) (.*)"
-consistent!(
-    fritzbox_logs_0,
-    "(\\d{2}\\.\\d{2}\\.\\d{2}) (\\d{2}:\\d{2}:\\d{2}) (.*)"
-);
-
-// fractal-matrix-api-3.29.0: r"mxc://(?P<server>[^/]+)/(?P<media>.+)"
-consistent!(fractal_matrix_api_0, r"mxc://(?P<server>[^/]+)/(?P<media>.+)");
-
-// smtp2go-0.1.4: r"^api-[a-zA-Z0-9]{32}$"
-consistent!(smtp2go_0, r"^api-[a-zA-Z0-9]{32}$");
-
-// pusher-0.3.1: r"^[-a-zA-Z0-9_=@,.;]+$"
-consistent!(pusher_0, r"^[-a-zA-Z0-9_=@,.;]+$");
-
-// pusher-0.3.1: r"\A\d+\.\d+\z"
-consistent!(pusher_1, r"\A\d+\.\d+\z");
-
-// bakervm-0.9.0: r"^\.(.+?) +?(.+)$"
-consistent!(bakervm_0, r"^\.(.+?) +?(.+)$");
-
-// bakervm-0.9.0: r"^\.([^\s]+)$"
-consistent!(bakervm_1, r"^\.([^\s]+)$");
-
-// bakervm-0.9.0: r"^include! +([^\s]+)$"
-consistent!(bakervm_2, r"^include! +([^\s]+)$");
-
-// bakervm-0.9.0: r"^@(\d+)$"
-consistent!(bakervm_3, r"^@(\d+)$");
-
-// bakervm-0.9.0: r"^true|false$"
-consistent!(bakervm_4, r"^true|false$");
-
-// bakervm-0.9.0: r"^(-?\d+)?\.[0-9]+$"
-consistent!(bakervm_5, r"^(-?\d+)?\.[0-9]+$");
-
-// bakervm-0.9.0: r"^(-?\d+)?$"
-consistent!(bakervm_6, r"^(-?\d+)?$");
-
-// bakervm-0.9.0: r"^#([0-9abcdefABCDEF]{6})$"
-consistent!(bakervm_7, r"^#([0-9abcdefABCDEF]{6})$");
-
-// bakervm-0.9.0: r"^'(.)'$"
-consistent!(bakervm_8, r"^'(.)'$");
-
-// bakervm-0.9.0: r"^\$vi\((\d+)\)$"
-consistent!(bakervm_9, r"^\$vi\((\d+)\)$");
-
-// bakervm-0.9.0: r"^\$key\((\d+)\)$"
-consistent!(bakervm_10, r"^\$key\((\d+)\)$");
-
-// banana-0.0.2: "(?P<type>[A-Z^']+) (?P<route>[^']+) HTTP/(?P<http>[^']+)"
-consistent!(
-    banana_0,
-    "(?P<type>[A-Z^']+) (?P<route>[^']+) HTTP/(?P<http>[^']+)"
-);
-
-// serial-key-2.0.0: r"[A-F0-9]{8}"
-consistent!(serial_key_0, r"[A-F0-9]{8}");
-
-// serde-hjson-0.8.1: "[\\\\\"\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
-consistent!(serde_hjson_0, "[\\\\\"\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
-
-// serde-hjson-0.8.1: "[\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
-consistent!(serde_hjson_1, "[\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
-
-// serde-hjson-0.8.1: "'''|[\x00-\x09\x0b\x0c\x0e-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
-consistent!(serde_hjson_2, "'''|[\x00-\x09\x0b\x0c\x0e-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
-
-// serde-odbc-0.1.0: r"/todos/(?P<id>\d+)"
-consistent!(serde_odbc_0, r"/todos/(?P<id>\d+)");
-
-// sentry-0.6.0: r"^(?:_<)?([a-zA-Z0-9_]+?)(?:\.\.|::)"
-consistent!(sentry_0, r"^(?:_<)?([a-zA-Z0-9_]+?)(?:\.\.|::)");
-
-// sentiment-0.1.1: r"[^a-zA-Z0 -]+"
-consistent!(sentiment_0, r"[^a-zA-Z0 -]+");
-
-// sentiment-0.1.1: r" {2,}"
-consistent!(sentiment_1, r" {2,}");
-
-// verilog-0.0.1: r"(?m)//.*"
-consistent!(verilog_0, r"(?m)//.*");
-
-// verex-0.2.2: "(?P<robot>C3PO)"
-consistent!(verex_0, "(?P<robot>C3PO)");
-
-// handlebars-0.32.4: ">|<|\"|&"
-consistent!(handlebars_0, ">|<|\"|&");
-
-// haikunator-0.1.2: r"^\w+-\w+-[0123456789]{4}$"
-consistent!(haikunator_0, r"^\w+-\w+-[0123456789]{4}$");
-
-// haikunator-0.1.2: r"^\w+@\w+@[0123456789]{4}$"
-consistent!(haikunator_1, r"^\w+@\w+@[0123456789]{4}$");
-
-// haikunator-0.1.2: r"^\w+-\w+-[0123456789abcdef]{4}$"
-consistent!(haikunator_2, r"^\w+-\w+-[0123456789abcdef]{4}$");
-
-// haikunator-0.1.2: r"^\w+-\w+-[0123456789忠犬ハチ公]{10}$"
-consistent!(haikunator_3, r"^\w+-\w+-[0123456789忠犬ハチ公]{10}$");
-
-// haikunator-0.1.2: r"^\w+-\w+$"
-consistent!(haikunator_4, r"^\w+-\w+$");
-
-// haikunator-0.1.2: r"^\w+-\w+-[foo]{4}$"
-consistent!(haikunator_5, r"^\w+-\w+-[foo]{4}$");
-
-// haikunator-0.1.2: r"^\w+-\w+-[0123456789忠犬ハチ公]{5}$"
-consistent!(haikunator_6, r"^\w+-\w+-[0123456789忠犬ハチ公]{5}$");
-
-// bobbin-cli-0.8.3: r"(.*)"
-consistent!(bobbin_cli_0, r"(.*)");
-
-// bobbin-cli-0.8.3: r"rustc (.*)"
-consistent!(bobbin_cli_1, r"rustc (.*)");
-
-// bobbin-cli-0.8.3: r"cargo (.*)"
-consistent!(bobbin_cli_2, r"cargo (.*)");
-
-// bobbin-cli-0.8.3: r"xargo (.*)\n"
-consistent!(bobbin_cli_3, r"xargo (.*)\n");
-
-// bobbin-cli-0.8.3: r"Open On-Chip Debugger (.*)"
-consistent!(bobbin_cli_4, r"Open On-Chip Debugger (.*)");
-
-// bobbin-cli-0.8.3: r"arm-none-eabi-gcc \(GNU Tools for ARM Embedded Processors[^\)]*\) (.*)"
-consistent!(
-    bobbin_cli_5,
-    r"arm-none-eabi-gcc \(GNU Tools for ARM Embedded Processors[^\)]*\) (.*)"
-);
-
-// bobbin-cli-0.8.3: r"(?m).*\nBasic Open Source SAM-BA Application \(BOSSA\) Version (.*)\n"
-consistent!(
-    bobbin_cli_6,
-    r"(?m).*\nBasic Open Source SAM-BA Application \(BOSSA\) Version (.*)\n"
-);
-
-// bobbin-cli-0.8.3: r"(?m)SEGGER J-Link Commander (.*)\n"
-consistent!(bobbin_cli_7, r"(?m)SEGGER J-Link Commander (.*)\n");
-
-// bobbin-cli-0.8.3: r"(?m)Teensy Loader, Command Line, Version (.*)\n"
-consistent!(bobbin_cli_8, r"(?m)Teensy Loader, Command Line, Version (.*)\n");
-
-// bobbin-cli-0.8.3: r"dfu-util (.*)\n"
-consistent!(bobbin_cli_9, r"dfu-util (.*)\n");
-
-// borsholder-0.9.1: r"^/static/[\w.]+$"
-consistent!(borsholder_0, r"^/static/[\w.]+$");
-
-// borsholder-0.9.1: r"^/timeline/([0-9]+)$"
-consistent!(borsholder_1, r"^/timeline/([0-9]+)$");
-
-// fblog-1.0.1: "\u{001B}\\[[\\d;]*[^\\d;]"
-consistent!(fblog_0, "\u{001B}\\[[\\d;]*[^\\d;]");
-
-// fblog-1.0.1: "\u{001B}\\[[\\d;]*[^\\d;]"
-consistent!(fblog_1, "\u{001B}\\[[\\d;]*[^\\d;]");
-
-// toml-query-0.6.0: r"^\[\d+\]$"
-consistent!(toml_query_0, r"^\[\d+\]$");
-
-// todo-txt-1.1.0: r" (?P<key>[^\s]+):(?P<value>[^\s^/]+)"
-consistent!(todo_txt_0, r" (?P<key>[^\s]+):(?P<value>[^\s^/]+)");
-
-// findr-0.1.5: r"\band\b"
-consistent!(findr_0, r"\band\b");
-
-// findr-0.1.5: r"\bor\b"
-consistent!(findr_1, r"\bor\b");
-
-// findr-0.1.5: r"\bnot\b"
-consistent!(findr_2, r"\bnot\b");
-
-// file-sniffer-3.0.1: r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
-consistent!(file_sniffer_0, r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
-
-// file-sniffer-3.0.1: r".*?\.(stats|conf|h|cache.*|dat|pc|info)$"
-consistent!(file_sniffer_1, r".*?\.(stats|conf|h|cache.*|dat|pc|info)$");
-
-// file-sniffer-3.0.1: r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
-consistent!(file_sniffer_2, r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
-
-// file-sniffer-3.0.1: r".*?\.(stats|conf|h|cache.*)$"
-consistent!(file_sniffer_3, r".*?\.(stats|conf|h|cache.*)$");
-
-// file-sniffer-3.0.1: r"(\.git|\.pijul|_darcs|\.hg)$"
-consistent!(file_sniffer_4, r"(\.git|\.pijul|_darcs|\.hg)$");
-
-// file_logger-0.1.0: "test"
-consistent!(file_logger_0, "test");
-
-// file_scanner-0.2.0: r"foo"
-consistent!(file_scanner_0, r"foo");
-
-// file_scanner-0.2.0: r"a+b"
-consistent!(file_scanner_1, r"a+b");
-
-// file_scanner-0.2.0: r"a[ab]*b"
-consistent!(file_scanner_2, r"a[ab]*b");
-
-// file_scanner-0.2.0: r"\s+"
-consistent!(file_scanner_3, r"\s+");
-
-// file_scanner-0.2.0: r"\s+"
-consistent!(file_scanner_4, r"\s+");
-
-// cellsplit-0.2.1: r"^\s*([^\s]+) %cellsplit<\d+>$"
-consistent!(cellsplit_0, r"^\s*([^\s]+) %cellsplit<\d+>$");
-
-// cellsplit-0.2.1: r"^\s*([^\s]+) %cellsplit<\d+>$"
-consistent!(cellsplit_1, r"^\s*([^\s]+) %cellsplit<\d+>$");
-
-// aterm-0.20.0: r"^[+\-]?[0-9]+"
-consistent!(aterm_0, r"^[+\-]?[0-9]+");
-
-// aterm-0.20.0: r"^[+\-]?[0-9]+\.[0-9]*([eE][+\-]?[0-9]+)?"
-consistent!(aterm_1, r"^[+\-]?[0-9]+\.[0-9]*([eE][+\-]?[0-9]+)?");
-
-// atarashii_imap-0.3.0: r"^[*] OK"
-consistent!(atarashii_imap_0, r"^[*] OK");
-
-// atarashii_imap-0.3.0: r"FLAGS\s\((.+)\)"
-consistent!(atarashii_imap_1, r"FLAGS\s\((.+)\)");
-
-// atarashii_imap-0.3.0: r"\[PERMANENTFLAGS\s\((.+)\)\]"
-consistent!(atarashii_imap_2, r"\[PERMANENTFLAGS\s\((.+)\)\]");
-
-// atarashii_imap-0.3.0: r"\[UIDVALIDITY\s(\d+)\]"
-consistent!(atarashii_imap_3, r"\[UIDVALIDITY\s(\d+)\]");
-
-// atarashii_imap-0.3.0: r"(\d+)\sEXISTS"
-consistent!(atarashii_imap_4, r"(\d+)\sEXISTS");
-
-// atarashii_imap-0.3.0: r"(\d+)\sRECENT"
-consistent!(atarashii_imap_5, r"(\d+)\sRECENT");
-
-// atarashii_imap-0.3.0: r"\[UNSEEN\s(\d+)\]"
-consistent!(atarashii_imap_6, r"\[UNSEEN\s(\d+)\]");
-
-// atarashii_imap-0.3.0: r"\[UIDNEXT\s(\d+)\]"
-consistent!(atarashii_imap_7, r"\[UIDNEXT\s(\d+)\]");
-
-// editorconfig-1.0.0: r"\\(\{|\})"
-consistent!(editorconfig_0, r"\\(\{|\})");
-
-// editorconfig-1.0.0: r"(^|[^\\])\\\|"
-consistent!(editorconfig_1, r"(^|[^\\])\\\|");
-
-// editorconfig-1.0.0: r"\[([^\]]*)$"
-consistent!(editorconfig_2, r"\[([^\]]*)$");
-
-// editorconfig-1.0.0: r"\[(.*/.*)\]"
-consistent!(editorconfig_3, r"\[(.*/.*)\]");
-
-// editorconfig-1.0.0: r"\{(-?\d+\\\.\\\.-?\d+)\}"
-consistent!(editorconfig_4, r"\{(-?\d+\\\.\\\.-?\d+)\}");
-
-// editorconfig-1.0.0: r"\{([^,]+)\}"
-consistent!(editorconfig_5, r"\{([^,]+)\}");
-
-// editorconfig-1.0.0: r"\{(([^\}].*)?(,|\|)(.*[^\\])?)\}"
-consistent!(editorconfig_6, r"\{(([^\}].*)?(,|\|)(.*[^\\])?)\}");
-
-// editorconfig-1.0.0: r"^/"
-consistent!(editorconfig_7, r"^/");
-
-// editorconfig-1.0.0: r"(^|[^\\])(\{|\})"
-consistent!(editorconfig_8, r"(^|[^\\])(\{|\})");
-
-// edmunge-1.0.0: "^#!.*\n"
-consistent!(edmunge_0, "^#!.*\n");
-
-// unicode_names2_macros-0.2.0: r"\\N\{(.*?)(?:\}|$)"
-consistent!(unicode_names2_macros_0, r"\\N\{(.*?)(?:\}|$)");
-
-// unidiff-0.2.1: r"^--- (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
-consistent!(
-    unidiff_0,
-    r"^--- (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
-);
-
-// unidiff-0.2.1: r"^\+\+\+ (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
-consistent!(
-    unidiff_1,
-    r"^\+\+\+ (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
-);
-
-// unidiff-0.2.1: r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)"
-consistent!(unidiff_2, r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)");
-
-// unidiff-0.2.1: r"^(?P<line_type>[- \n\+\\]?)(?P<value>.*)"
-consistent!(unidiff_3, r"^(?P<line_type>[- \n\+\\]?)(?P<value>.*)");
-
-// slippy-map-tiles-0.13.1: "/?(?P<zoom>[0-9]?[0-9])/(?P<x>[0-9]{1,10})/(?P<y>[0-9]{1,10})(\\.[a-zA-Z]{3,4})?$"
-consistent!(slippy_map_tiles_0, "/?(?P<zoom>[0-9]?[0-9])/(?P<x>[0-9]{1,10})/(?P<y>[0-9]{1,10})(\\.[a-zA-Z]{3,4})?$");
-
-// slippy-map-tiles-0.13.1: r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$"
-consistent!(slippy_map_tiles_1, r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$");
-
-// slippy-map-tiles-0.13.1: r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$"
-consistent!(slippy_map_tiles_2, r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$");
-
-// sonos-0.1.2: r"^https?://(.+?):1400/xml"
-consistent!(sonos_0, r"^https?://(.+?):1400/xml");
-
-// validator_derive-0.7.0: r"^[a-z]{2}$"
-consistent!(validator_derive_0, r"^[a-z]{2}$");
-
-// validator_derive-0.7.0: r"[a-z]{2}"
-consistent!(validator_derive_1, r"[a-z]{2}");
-
-// validator_derive-0.7.0: r"[a-z]{2}"
-consistent!(validator_derive_2, r"[a-z]{2}");
-
-// nginx-config-0.8.0: r"one of \d+ options"
-consistent!(nginx_config_0, r"one of \d+ options");
-
-// waltz-0.4.0: r"[\s,]"
-consistent!(waltz_0, r"[\s,]");
-
-// warheadhateus-0.2.1: r"^aws_access_key_id = (.*)"
-consistent!(warheadhateus_0, r"^aws_access_key_id = (.*)");
-
-// warheadhateus-0.2.1: r"^aws_secret_access_key = (.*)"
-consistent!(warheadhateus_1, r"^aws_secret_access_key = (.*)");
-
-// warheadhateus-0.2.1: r"^aws_access_key_id = (.*)"
-consistent!(warheadhateus_2, r"^aws_access_key_id = (.*)");
-
-// warheadhateus-0.2.1: r"^aws_secret_access_key = (.*)"
-consistent!(warheadhateus_3, r"^aws_secret_access_key = (.*)");
-
-// jieba-rs-0.2.2: r"([\u{4E00}-\u{9FD5}a-zA-Z0-9+#&\._%]+)"
-consistent!(jieba_rs_0, r"([\u{4E00}-\u{9FD5}a-zA-Z0-9+#&\._%]+)");
-
-// jieba-rs-0.2.2: r"(\r\n|\s)"
-consistent!(jieba_rs_1, r"(\r\n|\s)");
-
-// jieba-rs-0.2.2: "([\u{4E00}-\u{9FD5}]+)"
-consistent!(jieba_rs_2, "([\u{4E00}-\u{9FD5}]+)");
-
-// jieba-rs-0.2.2: r"[^a-zA-Z0-9+#\n]"
-consistent!(jieba_rs_3, r"[^a-zA-Z0-9+#\n]");
-
-// jieba-rs-0.2.2: r"([\u{4E00}-\u{9FD5}]+)"
-consistent!(jieba_rs_4, r"([\u{4E00}-\u{9FD5}]+)");
-
-// jieba-rs-0.2.2: r"([a-zA-Z0-9]+(?:.\d+)?%?)"
-consistent!(jieba_rs_5, r"([a-zA-Z0-9]+(?:.\d+)?%?)");
-
-// lalrpop-0.15.2: r"Span\([0-9 ,]*\)"
-consistent!(lalrpop_0, r"Span\([0-9 ,]*\)");
-
-// lalrpop-snap-0.15.2: r"Span\([0-9 ,]*\)"
-consistent!(lalrpop_snap_0, r"Span\([0-9 ,]*\)");
-
-// nlp-tokenize-0.1.0: r"[\S]+"
-consistent!(nlp_tokenize_0, r"[\S]+");
-
-// kbgpg-0.1.2: "[[:xdigit:]][70]"
-consistent!(kbgpg_0, "[[:xdigit:]][70]");
-
-// cdbd-0.1.1: r"^((?P<address>.*):)?(?P<port>\d+)$"
-consistent!(cdbd_0, r"^((?P<address>.*):)?(?P<port>\d+)$");
-
-// mbutiles-0.1.1: r"[\w\s=+-/]+\((\{(.|\n)*\})\);?"
-consistent!(mbutiles_0, r"[\w\s=+-/]+\((\{(.|\n)*\})\);?");
-
-// extrahop-0.2.5: r"^-\d+(?:ms|s|m|h|d|w|y)?$"
-consistent!(extrahop_0, r"^-\d+(?:ms|s|m|h|d|w|y)?$");
-
-// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$"
-consistent!(pippin_0, "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$");
-
-// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
-consistent!(
-    pippin_1,
-    "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
-);
-
-// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$"
-consistent!(pippin_2, "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$");
-
-// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
-consistent!(
-    pippin_3,
-    "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
-);
-
-// pippin-0.1.0: "^.*pn(0|[1-9][0-9]*)(-ss(0|[1-9][0-9]*)(\\.pip|-cl(0|[1-9][0-9]*)\\.piplog))?$"
-consistent!(pippin_4, "^.*pn(0|[1-9][0-9]*)(-ss(0|[1-9][0-9]*)(\\.pip|-cl(0|[1-9][0-9]*)\\.piplog))?$");
-
-// pippin-0.1.0: "^(.*)-ss(?:0|[1-9][0-9]*)(?:\\.pip|-cl(?:0|[1-9][0-9]*)\\.piplog)$"
-consistent!(
-    pippin_5,
-    "^(.*)-ss(?:0|[1-9][0-9]*)(?:\\.pip|-cl(?:0|[1-9][0-9]*)\\.piplog)$"
-);
-
-// pinyin-0.3.0: r"(?i)[āáǎàēéěèōóǒòīíǐìūúǔùüǘǚǜńň]"
-consistent!(
-    pinyin_0,
-    r"(?i)[āáǎàēéěèōóǒòīíǐìūúǔùüǘǚǜńň]"
-);
-
-// pinyin-0.3.0: r"([aeoiuvnm])([0-4])$"
-consistent!(pinyin_1, r"([aeoiuvnm])([0-4])$");
-
-// duration-parser-0.2.0: r"(?P<value>\d+)(?P<units>[a-z])"
-consistent!(duration_parser_0, r"(?P<value>\d+)(?P<units>[a-z])");
-
-// dutree-0.2.7: r"^\d+\D?$"
-consistent!(dutree_0, r"^\d+\D?$");
-
-// djangohashers-0.3.0: r"^[A-Za-z0-9]*$"
-consistent!(djangohashers_0, r"^[A-Za-z0-9]*$");
-
-// rtag-0.3.5: r"^[A-Z][A-Z0-9]{2,}$"
-consistent!(rtag_0, r"^[A-Z][A-Z0-9]{2,}$");
-
-// rtag-0.3.5: r"^http://www\.emusic\.com"
-consistent!(rtag_1, r"^http://www\.emusic\.com");
-
-// rtag-0.3.5: r"^[A-Z][A-Z0-9]{2,}"
-consistent!(rtag_2, r"^[A-Z][A-Z0-9]{2,}");
-
-// rtag-0.3.5: r"(^[\x{0}|\x{feff}|\x{fffe}]*|[\x{0}|\x{feff}|\x{fffe}]*$)"
-consistent!(
-    rtag_3,
-    r"(^[\x{0}|\x{feff}|\x{fffe}]*|[\x{0}|\x{feff}|\x{fffe}]*$)"
-);
-
-// rtow-0.1.0: r"(\d+)[xX](\d+)"
-consistent!(rtow_0, r"(\d+)[xX](\d+)");
-
-// pleingres-sql-plugin-0.1.0: r"\$([a-zA-Z0-9_]+)"
-consistent!(pleingres_sql_plugin_0, r"\$([a-zA-Z0-9_]+)");
-
-// dono-2.0.0: "[\\n]+"
-consistent!(dono_0, "[\\n]+");
-
-// dono-2.0.0: "(?m)^\\n"
-consistent!(dono_1, "(?m)^\\n");
-
-// dono-2.0.0: "(?m)^\\n"
-consistent!(dono_2, "(?m)^\\n");
-
-// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{43}=\.ed25519$"
-consistent!(ssb_common_0, r"^[0-9A-Za-z\+/]{43}=\.ed25519$");
-
-// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{86}==\.ed25519$"
-consistent!(ssb_common_1, r"^[0-9A-Za-z\+/]{86}==\.ed25519$");
-
-// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{43}=\.sha256$"
-consistent!(ssb_common_2, r"^[0-9A-Za-z\+/]{43}=\.sha256$");
-
-// mozversion-0.1.3: r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?(?:(?P<pre0>[a-z]+)(?P<pre1>\d*))?$"
-consistent!(mozversion_0, r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?(?:(?P<pre0>[a-z]+)(?P<pre1>\d*))?$");
-
-// monger-0.5.6: r"^(\d+)\.(\d+)$"
-consistent!(monger_0, r"^(\d+)\.(\d+)$");
-
-// mongo_rub-0.0.2: r"^[rv]2\.6"
-consistent!(mongo_rub_0, r"^[rv]2\.6");
-
-// flow-0.3.5: "body value"
-consistent!(flow_0, "body value");
-
-// flow-0.3.5: "start marker"
-consistent!(flow_1, "start marker");
-
-// flow-0.3.5: "end marker"
-consistent!(flow_2, "end marker");
-
-// flow-0.3.5: "body value"
-consistent!(flow_3, "body value");
-
-// vobsub-0.2.3: "^([A-Za-z/ ]+): (.*)"
-consistent!(vobsub_0, "^([A-Za-z/ ]+): (.*)");
-
-// voidmap-1.1.2: r"#([^\s=]+)*"
-consistent!(voidmap_0, r"#([^\s=]+)*");
-
-// voidmap-1.1.2: r"#(\S+)*"
-consistent!(voidmap_1, r"#(\S+)*");
-
-// voidmap-1.1.2: r"#prio=(\d+)"
-consistent!(voidmap_2, r"#prio=(\d+)");
-
-// voidmap-1.1.2: r"\[(\S+)\]"
-consistent!(voidmap_3, r"\[(\S+)\]");
-
-// voidmap-1.1.2: r"#limit=(\d+)"
-consistent!(voidmap_4, r"#limit=(\d+)");
-
-// voidmap-1.1.2: r"#tagged=(\S+)"
-consistent!(voidmap_5, r"#tagged=(\S+)");
-
-// voidmap-1.1.2: r"#rev\b"
-consistent!(voidmap_6, r"#rev\b");
-
-// voidmap-1.1.2: r"#done\b"
-consistent!(voidmap_7, r"#done\b");
-
-// voidmap-1.1.2: r"#open\b"
-consistent!(voidmap_8, r"#open\b");
-
-// voidmap-1.1.2: r"#since=(\S+)"
-consistent!(voidmap_9, r"#since=(\S+)");
-
-// voidmap-1.1.2: r"#until=(\S+)"
-consistent!(voidmap_10, r"#until=(\S+)");
-
-// voidmap-1.1.2: r"#plot=(\S+)"
-consistent!(voidmap_11, r"#plot=(\S+)");
-
-// voidmap-1.1.2: r"#n=(\d+)"
-consistent!(voidmap_12, r"#n=(\d+)");
-
-// voidmap-1.1.2: r"(\S+)"
-consistent!(voidmap_13, r"(\S+)");
-
-// voidmap-1.1.2: r"(?P<y>\d+)y"
-consistent!(voidmap_14, r"(?P<y>\d+)y");
-
-// voidmap-1.1.2: r"(?P<m>\d+)m"
-consistent!(voidmap_15, r"(?P<m>\d+)m");
-
-// voidmap-1.1.2: r"(?P<w>\d+)w"
-consistent!(voidmap_16, r"(?P<w>\d+)w");
-
-// voidmap-1.1.2: r"(?P<d>\d+)d"
-consistent!(voidmap_17, r"(?P<d>\d+)d");
-
-// voidmap-1.1.2: r"(?P<h>\d+)h"
-consistent!(voidmap_18, r"(?P<h>\d+)h");
-
-// voidmap-1.1.2: r"C-(.)"
-consistent!(voidmap_19, r"C-(.)");
-
-// qt_generator-0.2.0: r"^\.\./qt[^/]+/"
-consistent!(qt_generator_0, r"^\.\./qt[^/]+/");
-
-// qt_generator-0.2.0: "(href|src)=\"([^\"]*)\""
-consistent!(qt_generator_1, "(href|src)=\"([^\"]*)\"");
-
-// kryptos-0.6.1: r"[01]{5}"
-consistent!(kryptos_0, r"[01]{5}");
-
-// cifar_10_loader-0.2.0: "data_batch_[1-5].bin"
-consistent!(cifar_10_loader_0, "data_batch_[1-5].bin");
-
-// cifar_10_loader-0.2.0: "test_batch.bin"
-consistent!(cifar_10_loader_1, "test_batch.bin");
-
-// circadian-0.6.0: r"^\d+.\d+s$"
-consistent!(circadian_0, r"^\d+.\d+s$");
-
-// circadian-0.6.0: r"^\d+:\d+$"
-consistent!(circadian_1, r"^\d+:\d+$");
-
-// circadian-0.6.0: r"^\d+:\d+m$"
-consistent!(circadian_2, r"^\d+:\d+m$");
-
-// cicada-0.8.1: r"!!"
-consistent!(cicada_0, r"!!");
-
-// cicada-0.8.1: r"^([^`]*)`([^`]+)`(.*)$"
-consistent!(cicada_1, r"^([^`]*)`([^`]+)`(.*)$");
-
-// cicada-0.8.1: r"\*+"
-consistent!(cicada_2, r"\*+");
-
-// cicada-0.8.1: r"([^\$]*)\$\{?([A-Za-z0-9\?\$_]+)\}?(.*)"
-consistent!(cicada_3, r"([^\$]*)\$\{?([A-Za-z0-9\?\$_]+)\}?(.*)");
-
-// cicada-0.8.1: r"^ *alias +([a-zA-Z0-9_\.-]+)=(.*)$"
-consistent!(cicada_4, r"^ *alias +([a-zA-Z0-9_\.-]+)=(.*)$");
-
-// vterm-sys-0.1.0: r"hi"
-consistent!(vterm_sys_0, r"hi");
-
-// skim-0.5.0: r".*?\t"
-consistent!(skim_0, r".*?\t");
-
-// skim-0.5.0: r".*?[\t ]"
-consistent!(skim_1, r".*?[\t ]");
-
-// skim-0.5.0: r"(\{-?[0-9.,q]*?})"
-consistent!(skim_2, r"(\{-?[0-9.,q]*?})");
-
-// skim-0.5.0: r"[ \t\n]+"
-consistent!(skim_3, r"[ \t\n]+");
-
-// skim-0.5.0: r"[ \t\n]+"
-consistent!(skim_4, r"[ \t\n]+");
-
-// skim-0.5.0: r"([^ |]+( +\| +[^ |]*)+)|( +)"
-consistent!(skim_5, r"([^ |]+( +\| +[^ |]*)+)|( +)");
-
-// skim-0.5.0: r" +\| +"
-consistent!(skim_6, r" +\| +");
-
-// skim-0.5.0: r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$"
-consistent!(skim_7, r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$");
-
-// skim-0.5.0: ","
-consistent!(skim_8, ",");
-
-// skim-0.5.0: ".*?,"
-consistent!(skim_9, ".*?,");
-
-// skim-0.5.0: ".*?,"
-consistent!(skim_10, ".*?,");
-
-// skim-0.5.0: ","
-consistent!(skim_11, ",");
-
-// skim-0.5.0: r"\x1B\[(?:([0-9]+;[0-9]+[Hf])|([0-9]+[ABCD])|(s|u|2J|K)|([0-9;]*m)|(=[0-9]+[hI]))"
-consistent!(skim_12, r"\x1B\[(?:([0-9]+;[0-9]+[Hf])|([0-9]+[ABCD])|(s|u|2J|K)|([0-9;]*m)|(=[0-9]+[hI]))");
-
-// egg-mode-text-1.14.7: r"[-_./]\z"
-consistent!(egg_mode_text_0, r"[-_./]\z");
-
-// java-properties-1.1.1: "^[ \t\r\n\x0c]*[#!]"
-consistent!(java_properties_0, "^[ \t\r\n\x0c]*[#!]");
-
-// java-properties-1.1.1: r"^[ \t\x0c]*[#!][^\r\n]*$"
-consistent!(java_properties_1, r"^[ \t\x0c]*[#!][^\r\n]*$");
-
-// java-properties-1.1.1: r"^([ \t\x0c]*[:=][ \t\x0c]*|[ \t\x0c]+)$"
-consistent!(java_properties_2, r"^([ \t\x0c]*[:=][ \t\x0c]*|[ \t\x0c]+)$");
-
-// ipaddress-0.1.2: r":.+\."
-consistent!(ipaddress_0, r":.+\.");
-
-// ipaddress-0.1.2: r"\."
-consistent!(ipaddress_1, r"\.");
-
-// ipaddress-0.1.2: r":"
-consistent!(ipaddress_2, r":");
-
-// iptables-0.2.2: r"v(\d+)\.(\d+)\.(\d+)"
-consistent!(iptables_0, r"v(\d+)\.(\d+)\.(\d+)");
-
-// rsure-0.8.1: r"^([^-]+)-(.*)\.dat\.gz$"
-consistent!(rsure_0, r"^([^-]+)-(.*)\.dat\.gz$");
-
-// rs-jsonpath-0.1.0: "^(.*?)(<=|<|==|>=|>)(.*?)$"
-consistent!(rs_jsonpath_0, "^(.*?)(<=|<|==|>=|>)(.*?)$");
-
-// oatie-0.3.0: r"(\n|^)(\w+):([\n\w\W]+?)(\n(?:\w)|(\n\]))"
-consistent!(oatie_0, r"(\n|^)(\w+):([\n\w\W]+?)(\n(?:\w)|(\n\]))");
-
-// weld-0.2.0: "#.*$"
-consistent!(weld_0, "#.*$");
-
-// weld-0.2.0: r"^[A-Za-z$_][A-Za-z0-9$_]*$"
-consistent!(weld_1, r"^[A-Za-z$_][A-Za-z0-9$_]*$");
-
-// weld-0.2.0: r"^[0-9]+[cC]$"
-consistent!(weld_2, r"^[0-9]+[cC]$");
-
-// weld-0.2.0: r"^0b[0-1]+[cC]$"
-consistent!(weld_3, r"^0b[0-1]+[cC]$");
-
-// weld-0.2.0: r"^0x[0-9a-fA-F]+[cC]$"
-consistent!(weld_4, r"^0x[0-9a-fA-F]+[cC]$");
-
-// weld-0.2.0: r"^[0-9]+$"
-consistent!(weld_5, r"^[0-9]+$");
-
-// weld-0.2.0: r"^0b[0-1]+$"
-consistent!(weld_6, r"^0b[0-1]+$");
-
-// weld-0.2.0: r"^0x[0-9a-fA-F]+$"
-consistent!(weld_7, r"^0x[0-9a-fA-F]+$");
-
-// weld-0.2.0: r"^[0-9]+[lL]$"
-consistent!(weld_8, r"^[0-9]+[lL]$");
-
-// weld-0.2.0: r"^0b[0-1]+[lL]$"
-consistent!(weld_9, r"^0b[0-1]+[lL]$");
-
-// weld-0.2.0: r"^0x[0-9a-fA-F]+[lL]$"
-consistent!(weld_10, r"^0x[0-9a-fA-F]+[lL]$");
-
-// webgl_generator-0.1.0: "([(, ])enum\\b"
-consistent!(webgl_generator_0, "([(, ])enum\\b");
-
-// webgl_generator-0.1.0: "\\bAcquireResourcesCallback\\b"
-consistent!(webgl_generator_1, "\\bAcquireResourcesCallback\\b");
-
-// weave-0.2.0: r"^(\d+)(,(\d+))?([acd]).*$"
-consistent!(weave_0, r"^(\d+)(,(\d+))?([acd]).*$");
-
-// wemo-0.0.12: r"<BinaryState>(\d)(\|-?\d+)*</BinaryState>"
-consistent!(wemo_0, r"<BinaryState>(\d)(\|-?\d+)*</BinaryState>");
-
-// webscale-0.9.4: r"(http[s]?://[^\s]+)"
-consistent!(webscale_0, r"(http[s]?://[^\s]+)");
-
-// svgrep-1.1.0: r"^\d+.*$"
-consistent!(svgrep_0, r"^\d+.*$");
-
-// ignore-0.4.2: r"^[\pL\pN]+$"
-consistent!(ignore_0, r"^[\pL\pN]+$");
-
-// ommui_string_patterns-0.1.2: r"^([A-Za-z][0-9A-Za-z_]*)?$"
-consistent!(ommui_string_patterns_0, r"^([A-Za-z][0-9A-Za-z_]*)?$");
-
-// ommui_string_patterns-0.1.2: r"^(\S+(?:.*\S)?)?$"
-consistent!(ommui_string_patterns_1, r"^(\S+(?:.*\S)?)?$");
-
-// opcua-types-0.3.0: "^(?P<min>[0-9]{1,10})(:(?P<max>[0-9]{1,10}))?$"
-consistent!(opcua_types_0, "^(?P<min>[0-9]{1,10})(:(?P<max>[0-9]{1,10}))?$");
-
-// opcua-types-0.3.0: r"^(ns=(?P<ns>[0-9]+);)?(?P<t>[isgb])=(?P<v>.+)$"
-consistent!(opcua_types_1, r"^(ns=(?P<ns>[0-9]+);)?(?P<t>[isgb])=(?P<v>.+)$");
-
-// open_read_later-1.1.1: r"^(.+?)\s*:\s*(.+)$"
-consistent!(open_read_later_0, r"^(.+?)\s*:\s*(.+)$");
-
-// youtube-downloader-0.1.0: r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*"
-consistent!(youtube_downloader_0, r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*");
-
-// yobot-0.1.1: "."
-consistent!(yobot_0, ".");
-
-// yobot-0.1.1: r"."
-consistent!(yobot_1, r".");
-
-// yobot-0.1.1: r".+"
-consistent!(yobot_2, r".+");
-
-// yobot-0.1.1: r"."
-consistent!(yobot_3, r".");
-
-// ubiquity-0.1.5: r"foo"
-consistent!(ubiquity_0, r"foo");
-
-// ubiquity-0.1.5: r"/target/"
-consistent!(ubiquity_1, r"/target/");
-
-// ubiquity-0.1.5: r".DS_Store"
-consistent!(ubiquity_2, r".DS_Store");
-
-// qasm-1.0.0: r"//.*"
-consistent!(qasm_0, r"//.*");
-
-// drill-0.3.5: r"\{\{ *([a-z\._]+) *\}\}"
-consistent!(drill_0, r"\{\{ *([a-z\._]+) *\}\}");
-
-// queryst-2.0.0: r"^([^\]\[]+)"
-consistent!(queryst_0, r"^([^\]\[]+)");
-
-// queryst-2.0.0: r"(\[[^\]\[]*\])"
-consistent!(queryst_1, r"(\[[^\]\[]*\])");
-
-// qui-vive-0.1.0: r"^/(\w+)$"
-consistent!(qui_vive_0, r"^/(\w+)$");
-
-// qui-vive-0.1.0: r"^/key$"
-consistent!(qui_vive_1, r"^/key$");
-
-// qui-vive-0.1.0: r"^/key/(\w+)$"
-consistent!(qui_vive_2, r"^/key/(\w+)$");
-
-// qui-vive-0.1.0: r"^/url$"
-consistent!(qui_vive_3, r"^/url$");
-
-// qui-vive-0.1.0: r"^/url/(\w+)$"
-consistent!(qui_vive_4, r"^/url/(\w+)$");
-
-// qui-vive-0.1.0: r"^/inv$"
-consistent!(qui_vive_5, r"^/inv$");
-
-// qui-vive-0.1.0: r"^/inv/(\w+)$"
-consistent!(qui_vive_6, r"^/inv/(\w+)$");
-
-// subdiff-0.1.0: r"\b"
-// consistent!(subdiff_0, r"\b");
-
-// substudy-0.4.5: r"^(\d+)/(\d+)$"
-consistent!(substudy_0, r"^(\d+)/(\d+)$");
-
-// substudy-0.4.5: r"\s+"
-consistent!(substudy_1, r"\s+");
-
-// substudy-0.4.5: r"<[a-z/][^>]*>"
-consistent!(substudy_2, r"<[a-z/][^>]*>");
-
-// substudy-0.4.5: r"(\([^)]*\)|♪[^♪]*♪|[A-Z]{2,} ?:)"
-consistent!(substudy_3, r"(\([^)]*\)|♪[^♪]*♪|[A-Z]{2,} ?:)");
-
-// substudy-0.4.5: r"\s+"
-consistent!(substudy_4, r"\s+");
-
-// isbnid-0.1.3: r"^(\d(-| )?){9}(x|X|\d|(\d(-| )?){3}\d)$"
-consistent!(isbnid_0, r"^(\d(-| )?){9}(x|X|\d|(\d(-| )?){3}\d)$");
-
-// isbnid-0.1.3: r"[^0-9X]"
-consistent!(isbnid_1, r"[^0-9X]");
-
-// ispc-0.3.5: r"Intel\(r\) SPMD Program Compiler \(ispc\), (\d+\.\d+\.\d+)"
-consistent!(
-    ispc_0,
-    r"Intel\(r\) SPMD Program Compiler \(ispc\), (\d+\.\d+\.\d+)"
-);
diff --git a/tests/crazy.rs b/tests/crazy.rs
deleted file mode 100644
index 293ac1ae72..0000000000
--- a/tests/crazy.rs
+++ /dev/null
@@ -1,459 +0,0 @@
-mat!(ascii_literal, r"a", "a", Some((0, 1)));
-
-// Some crazy expressions from regular-expressions.info.
-mat!(
-    match_ranges,
-    r"(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b",
-    "num: 255",
-    Some((5, 8))
-);
-mat!(
-    match_ranges_not,
-    r"(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b",
-    "num: 256",
-    None
-);
-mat!(match_float1, r"[-+]?[0-9]*\.?[0-9]+", "0.1", Some((0, 3)));
-mat!(match_float2, r"[-+]?[0-9]*\.?[0-9]+", "0.1.2", Some((0, 3)));
-mat!(match_float3, r"[-+]?[0-9]*\.?[0-9]+", "a1.2", Some((1, 4)));
-mat!(match_float4, r"^[-+]?[0-9]*\.?[0-9]+$", "1.a", None);
-mat!(
-    match_email,
-    r"(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b",
-    "mine is jam.slam@gmail.com ",
-    Some((8, 26))
-);
-mat!(
-    match_email_not,
-    r"(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b",
-    "mine is jam.slam@gmail ",
-    None
-);
-mat!(
-    match_email_big,
-    r"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?",
-    "mine is jam.slam@gmail.com ",
-    Some((8, 26))
-);
-mat!(
-    match_date1,
-    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
-    "1900-01-01",
-    Some((0, 10))
-);
-mat!(
-    match_date2,
-    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
-    "1900-00-01",
-    None
-);
-mat!(
-    match_date3,
-    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
-    "1900-13-01",
-    None
-);
-
-// Do some crazy dancing with the start/end assertions.
-matiter!(match_start_end_empty, r"^$", "", (0, 0));
-matiter!(match_start_end_empty_many_1, r"^$^$^$", "", (0, 0));
-matiter!(match_start_end_empty_many_2, r"^^^$$$", "", (0, 0));
-matiter!(match_start_end_empty_rev, r"$^", "", (0, 0));
-matiter!(
-    match_start_end_empty_rep,
-    r"(?:^$)*",
-    "a\nb\nc",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4),
-    (5, 5)
-);
-matiter!(
-    match_start_end_empty_rep_rev,
-    r"(?:$^)*",
-    "a\nb\nc",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4),
-    (5, 5)
-);
-
-// Test negated character classes.
-mat!(negclass_letters, r"[^ac]", "acx", Some((2, 3)));
-mat!(negclass_letter_comma, r"[^a,]", "a,x", Some((2, 3)));
-mat!(negclass_letter_space, r"[^a[:space:]]", "a x", Some((2, 3)));
-mat!(negclass_comma, r"[^,]", ",,x", Some((2, 3)));
-mat!(negclass_space, r"[^[:space:]]", " a", Some((1, 2)));
-mat!(negclass_space_comma, r"[^,[:space:]]", ", a", Some((2, 3)));
-mat!(negclass_comma_space, r"[^[:space:],]", " ,a", Some((2, 3)));
-mat!(negclass_ascii, r"[^[:alpha:]Z]", "A1", Some((1, 2)));
-
-// Test that repeated empty expressions don't loop forever.
-mat!(lazy_many_many, r"((?:.*)*?)=", "a=b", Some((0, 2)));
-mat!(lazy_many_optional, r"((?:.?)*?)=", "a=b", Some((0, 2)));
-mat!(lazy_one_many_many, r"((?:.*)+?)=", "a=b", Some((0, 2)));
-mat!(lazy_one_many_optional, r"((?:.?)+?)=", "a=b", Some((0, 2)));
-mat!(lazy_range_min_many, r"((?:.*){1,}?)=", "a=b", Some((0, 2)));
-mat!(lazy_range_many, r"((?:.*){1,2}?)=", "a=b", Some((0, 2)));
-mat!(greedy_many_many, r"((?:.*)*)=", "a=b", Some((0, 2)));
-mat!(greedy_many_optional, r"((?:.?)*)=", "a=b", Some((0, 2)));
-mat!(greedy_one_many_many, r"((?:.*)+)=", "a=b", Some((0, 2)));
-mat!(greedy_one_many_optional, r"((?:.?)+)=", "a=b", Some((0, 2)));
-mat!(greedy_range_min_many, r"((?:.*){1,})=", "a=b", Some((0, 2)));
-mat!(greedy_range_many, r"((?:.*){1,2})=", "a=b", Some((0, 2)));
-
-// Test that we handle various flavors of empty expressions.
-matiter!(match_empty1, r"", "", (0, 0));
-matiter!(match_empty2, r"", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty3, r"()", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty4, r"()*", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty5, r"()+", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty6, r"()?", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty7, r"()()", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty8, r"()+|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty9, r"z|()+", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty10, r"()+|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty11, r"b|()+", "abc", (0, 0), (1, 2), (3, 3));
-matiter!(match_empty12, r"|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty13, r"b|", "abc", (0, 0), (1, 2), (3, 3));
-matiter!(match_empty14, r"|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty15, r"z|", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty16, r"|", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty17, r"||", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty18, r"||z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty19, r"(?:)|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty20, r"b|(?:)", "abc", (0, 0), (1, 2), (3, 3));
-matiter!(match_empty21, r"(?:|)", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty22, r"(?:|)|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
-matiter!(match_empty23, r"a(?:)|b", "abc", (0, 1), (1, 2));
-
-// Test that the DFA can handle pathological cases.
-// (This should result in the DFA's cache being flushed too frequently, which
-// should cause it to quit and fall back to the NFA algorithm.)
-#[test]
-fn dfa_handles_pathological_case() {
-    fn ones_and_zeroes(count: usize) -> String {
-        use rand::rngs::SmallRng;
-        use rand::{Rng, SeedableRng};
-
-        let mut rng = SmallRng::from_entropy();
-        let mut s = String::new();
-        for _ in 0..count {
-            if rng.gen() {
-                s.push('1');
-            } else {
-                s.push('0');
-            }
-        }
-        s
-    }
-
-    let re = regex!(r"[01]*1[01]{20}$");
-    let text = {
-        let mut pieces = ones_and_zeroes(100_000);
-        pieces.push('1');
-        pieces.push_str(&ones_and_zeroes(20));
-        pieces
-    };
-    assert!(re.is_match(text!(&*text)));
-}
-
-#[test]
-fn nest_limit_makes_it_parse() {
-    use regex::RegexBuilder;
-
-    RegexBuilder::new(
-        r#"(?-u)
-        2(?:
-          [45]\d{3}|
-          7(?:
-            1[0-267]|
-            2[0-289]|
-            3[0-29]|
-            4[01]|
-            5[1-3]|
-            6[013]|
-            7[0178]|
-            91
-          )|
-          8(?:
-            0[125]|
-            [139][1-6]|
-            2[0157-9]|
-            41|
-            6[1-35]|
-            7[1-5]|
-            8[1-8]|
-            90
-          )|
-          9(?:
-            0[0-2]|
-            1[0-4]|
-            2[568]|
-            3[3-6]|
-            5[5-7]|
-            6[0167]|
-            7[15]|
-            8[0146-9]
-          )
-        )\d{4}|
-        3(?:
-          12?[5-7]\d{2}|
-          0(?:
-            2(?:
-              [025-79]\d|
-              [348]\d{1,2}
-            )|
-            3(?:
-              [2-4]\d|
-              [56]\d?
-            )
-          )|
-          2(?:
-            1\d{2}|
-            2(?:
-              [12]\d|
-              [35]\d{1,2}|
-              4\d?
-            )
-          )|
-          3(?:
-            1\d{2}|
-            2(?:
-              [2356]\d|
-              4\d{1,2}
-            )
-          )|
-          4(?:
-            1\d{2}|
-            2(?:
-              2\d{1,2}|
-              [47]|
-              5\d{2}
-            )
-          )|
-          5(?:
-            1\d{2}|
-            29
-          )|
-          [67]1\d{2}|
-          8(?:
-            1\d{2}|
-            2(?:
-              2\d{2}|
-              3|
-              4\d
-            )
-          )
-        )\d{3}|
-        4(?:
-          0(?:
-            2(?:
-              [09]\d|
-              7
-            )|
-            33\d{2}
-          )|
-          1\d{3}|
-          2(?:
-            1\d{2}|
-            2(?:
-              [25]\d?|
-              [348]\d|
-              [67]\d{1,2}
-            )
-          )|
-          3(?:
-            1\d{2}(?:
-              \d{2}
-            )?|
-            2(?:
-              [045]\d|
-              [236-9]\d{1,2}
-            )|
-            32\d{2}
-          )|
-          4(?:
-            [18]\d{2}|
-            2(?:
-              [2-46]\d{2}|
-              3
-            )|
-            5[25]\d{2}
-          )|
-          5(?:
-            1\d{2}|
-            2(?:
-              3\d|
-              5
-            )
-          )|
-          6(?:
-            [18]\d{2}|
-            2(?:
-              3(?:
-                \d{2}
-              )?|
-              [46]\d{1,2}|
-              5\d{2}|
-              7\d
-            )|
-            5(?:
-              3\d?|
-              4\d|
-              [57]\d{1,2}|
-              6\d{2}|
-              8
-            )
-          )|
-          71\d{2}|
-          8(?:
-            [18]\d{2}|
-            23\d{2}|
-            54\d{2}
-          )|
-          9(?:
-            [18]\d{2}|
-            2[2-5]\d{2}|
-            53\d{1,2}
-          )
-        )\d{3}|
-        5(?:
-          02[03489]\d{2}|
-          1\d{2}|
-          2(?:
-            1\d{2}|
-            2(?:
-              2(?:
-                \d{2}
-              )?|
-              [457]\d{2}
-            )
-          )|
-          3(?:
-            1\d{2}|
-            2(?:
-              [37](?:
-                \d{2}
-              )?|
-              [569]\d{2}
-            )
-          )|
-          4(?:
-            1\d{2}|
-            2[46]\d{2}
-          )|
-          5(?:
-            1\d{2}|
-            26\d{1,2}
-          )|
-          6(?:
-            [18]\d{2}|
-            2|
-            53\d{2}
-          )|
-          7(?:
-            1|
-            24
-          )\d{2}|
-          8(?:
-            1|
-            26
-          )\d{2}|
-          91\d{2}
-        )\d{3}|
-        6(?:
-          0(?:
-            1\d{2}|
-            2(?:
-              3\d{2}|
-              4\d{1,2}
-            )
-          )|
-          2(?:
-            2[2-5]\d{2}|
-            5(?:
-              [3-5]\d{2}|
-              7
-            )|
-            8\d{2}
-          )|
-          3(?:
-            1|
-            2[3478]
-          )\d{2}|
-          4(?:
-            1|
-            2[34]
-          )\d{2}|
-          5(?:
-            1|
-            2[47]
-          )\d{2}|
-          6(?:
-            [18]\d{2}|
-            6(?:
-              2(?:
-                2\d|
-                [34]\d{2}
-              )|
-              5(?:
-                [24]\d{2}|
-                3\d|
-                5\d{1,2}
-              )
-            )
-          )|
-          72[2-5]\d{2}|
-          8(?:
-            1\d{2}|
-            2[2-5]\d{2}
-          )|
-          9(?:
-            1\d{2}|
-            2[2-6]\d{2}
-          )
-        )\d{3}|
-        7(?:
-          (?:
-            02|
-            [3-589]1|
-            6[12]|
-            72[24]
-          )\d{2}|
-          21\d{3}|
-          32
-        )\d{3}|
-        8(?:
-          (?:
-            4[12]|
-            [5-7]2|
-            1\d?
-          )|
-          (?:
-            0|
-            3[12]|
-            [5-7]1|
-            217
-          )\d
-        )\d{4}|
-        9(?:
-          [35]1|
-          (?:
-            [024]2|
-            81
-          )\d|
-          (?:
-            1|
-            [24]1
-          )\d{2}
-        )\d{3}
-        "#,
-    )
-    .build()
-    .unwrap();
-}
diff --git a/tests/flags.rs b/tests/flags.rs
deleted file mode 100644
index c33b82d434..0000000000
--- a/tests/flags.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-mat!(match_flag_case, "(?-u)(?i)abc", "ABC", Some((0, 3)));
-mat!(match_flag_weird_case, "(?-u)(?i)a(?-i)bc", "Abc", Some((0, 3)));
-mat!(match_flag_weird_case_not, "(?-u)(?i)a(?-i)bc", "ABC", None);
-mat!(match_flag_case_dotnl, "(?-u)(?is)a(?u:.)", "A\n", Some((0, 2)));
-mat!(
-    match_flag_case_dotnl_toggle,
-    "(?-u)(?is)a(?u:.)(?-is)a(?u:.)",
-    "A\nab",
-    Some((0, 4))
-);
-mat!(
-    match_flag_case_dotnl_toggle_not,
-    "(?-u)(?is)a(?u:.)(?-is)a(?u:.)",
-    "A\na\n",
-    None
-);
-mat!(
-    match_flag_case_dotnl_toggle_ok,
-    "(?-u)(?is)a(?u:.)(?-is:a(?u:.))?",
-    "A\na\n",
-    Some((0, 2))
-);
-mat!(
-    match_flag_multi,
-    r"(?-u)(?m)(?:^\d+$\n?)+",
-    "123\n456\n789",
-    Some((0, 11))
-);
-mat!(match_flag_ungreedy, "(?U)a+", "aa", Some((0, 1)));
-mat!(match_flag_ungreedy_greedy, "(?U)a+?", "aa", Some((0, 2)));
-mat!(match_flag_ungreedy_noop, "(?U)(?-U)a+", "aa", Some((0, 2)));
diff --git a/tests/fowler.rs b/tests/fowler.rs
deleted file mode 100644
index 7f56a758d3..0000000000
--- a/tests/fowler.rs
+++ /dev/null
@@ -1,1588 +0,0 @@
-// DO NOT EDIT. Automatically generated by 'scripts/regex-match-tests.py'
-// on 2019-09-02 11:07:37.849994.
-
-// Tests from basic.dat
-mat!(match_basic_3, r"abracadabra$", r"abracadabracadabra", Some((7, 18)));
-mat!(match_basic_4, r"a...b", r"abababbb", Some((2, 7)));
-mat!(match_basic_5, r"XXXXXX", r"..XXXXXX", Some((2, 8)));
-mat!(match_basic_6, r"\)", r"()", Some((1, 2)));
-mat!(match_basic_7, r"a]", r"a]a", Some((0, 2)));
-mat!(match_basic_9, r"\}", r"}", Some((0, 1)));
-mat!(match_basic_10, r"\]", r"]", Some((0, 1)));
-mat!(match_basic_12, r"]", r"]", Some((0, 1)));
-mat!(match_basic_15, r"^a", r"ax", Some((0, 1)));
-mat!(match_basic_16, r"\^a", r"a^a", Some((1, 3)));
-mat!(match_basic_17, r"a\^", r"a^", Some((0, 2)));
-mat!(match_basic_18, r"a$", r"aa", Some((1, 2)));
-mat!(match_basic_19, r"a\$", r"a$", Some((0, 2)));
-mat!(match_basic_20, r"^$", r"", Some((0, 0)));
-mat!(match_basic_21, r"$^", r"", Some((0, 0)));
-mat!(match_basic_22, r"a($)", r"aa", Some((1, 2)), Some((2, 2)));
-mat!(match_basic_23, r"a*(^a)", r"aa", Some((0, 1)), Some((0, 1)));
-mat!(match_basic_24, r"(..)*(...)*", r"a", Some((0, 0)));
-mat!(match_basic_25, r"(..)*(...)*", r"abcd", Some((0, 4)), Some((2, 4)));
-mat!(
-    match_basic_26,
-    r"(ab|a)(bc|c)",
-    r"abc",
-    Some((0, 3)),
-    Some((0, 2)),
-    Some((2, 3))
-);
-mat!(match_basic_27, r"(ab)c|abc", r"abc", Some((0, 3)), Some((0, 2)));
-mat!(match_basic_28, r"a{0}b", r"ab", Some((1, 2)));
-mat!(
-    match_basic_29,
-    r"(a*)(b?)(b+)b{3}",
-    r"aaabbbbbbb",
-    Some((0, 10)),
-    Some((0, 3)),
-    Some((3, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_30,
-    r"(a*)(b{0,1})(b{1,})b{3}",
-    r"aaabbbbbbb",
-    Some((0, 10)),
-    Some((0, 3)),
-    Some((3, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_32,
-    r"((a|a)|a)",
-    r"a",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1))
-);
-mat!(
-    match_basic_33,
-    r"(a*)(a|aa)",
-    r"aaaa",
-    Some((0, 4)),
-    Some((0, 3)),
-    Some((3, 4))
-);
-mat!(match_basic_34, r"a*(a.|aa)", r"aaaa", Some((0, 4)), Some((2, 4)));
-mat!(
-    match_basic_35,
-    r"a(b)|c(d)|a(e)f",
-    r"aef",
-    Some((0, 3)),
-    None,
-    None,
-    Some((1, 2))
-);
-mat!(match_basic_36, r"(a|b)?.*", r"b", Some((0, 1)), Some((0, 1)));
-mat!(match_basic_37, r"(a|b)c|a(b|c)", r"ac", Some((0, 2)), Some((0, 1)));
-mat!(
-    match_basic_38,
-    r"(a|b)c|a(b|c)",
-    r"ab",
-    Some((0, 2)),
-    None,
-    Some((1, 2))
-);
-mat!(match_basic_39, r"(a|b)*c|(a|ab)*c", r"abc", Some((0, 3)), Some((1, 2)));
-mat!(match_basic_40, r"(a|b)*c|(a|ab)*c", r"xc", Some((1, 2)));
-mat!(
-    match_basic_41,
-    r"(.a|.b).*|.*(.a|.b)",
-    r"xa",
-    Some((0, 2)),
-    Some((0, 2))
-);
-mat!(match_basic_42, r"a?(ab|ba)ab", r"abab", Some((0, 4)), Some((0, 2)));
-mat!(match_basic_43, r"a?(ac{0}b|ba)ab", r"abab", Some((0, 4)), Some((0, 2)));
-mat!(match_basic_44, r"ab|abab", r"abbabab", Some((0, 2)));
-mat!(match_basic_45, r"aba|bab|bba", r"baaabbbaba", Some((5, 8)));
-mat!(match_basic_46, r"aba|bab", r"baaabbbaba", Some((6, 9)));
-mat!(
-    match_basic_47,
-    r"(aa|aaa)*|(a|aaaaa)",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 2))
-);
-mat!(
-    match_basic_48,
-    r"(a.|.a.)*|(a|.a...)",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 2))
-);
-mat!(match_basic_49, r"ab|a", r"xabc", Some((1, 3)));
-mat!(match_basic_50, r"ab|a", r"xxabc", Some((2, 4)));
-mat!(
-    match_basic_51,
-    r"(?i)(?-u)(Ab|cD)*",
-    r"aBcD",
-    Some((0, 4)),
-    Some((2, 4))
-);
-mat!(match_basic_52, r"[^-]", r"--a", Some((2, 3)));
-mat!(match_basic_53, r"[a-]*", r"--a", Some((0, 3)));
-mat!(match_basic_54, r"[a-m-]*", r"--amoma--", Some((0, 4)));
-mat!(
-    match_basic_55,
-    r":::1:::0:|:::1:1:0:",
-    r":::0:::1:::1:::0:",
-    Some((8, 17))
-);
-mat!(
-    match_basic_56,
-    r":::1:::0:|:::1:1:1:",
-    r":::0:::1:::1:::0:",
-    Some((8, 17))
-);
-mat!(match_basic_57, r"[[:upper:]]", r"A", Some((0, 1)));
-mat!(match_basic_58, r"[[:lower:]]+", r"`az{", Some((1, 3)));
-mat!(match_basic_59, r"[[:upper:]]+", r"@AZ[", Some((1, 3)));
-mat!(
-    match_basic_65,
-    r"
-",
-    r"
-",
-    Some((0, 1))
-);
-mat!(
-    match_basic_66,
-    r"
-",
-    r"
-",
-    Some((0, 1))
-);
-mat!(
-    match_basic_67,
-    r"[^a]",
-    r"
-",
-    Some((0, 1))
-);
-mat!(
-    match_basic_68,
-    r"
-a",
-    r"
-a",
-    Some((0, 2))
-);
-mat!(
-    match_basic_69,
-    r"(a)(b)(c)",
-    r"abc",
-    Some((0, 3)),
-    Some((0, 1)),
-    Some((1, 2)),
-    Some((2, 3))
-);
-mat!(match_basic_70, r"xxx", r"xxx", Some((0, 3)));
-mat!(
-    match_basic_71,
-    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
-    r"feb 6,",
-    Some((0, 6))
-);
-mat!(
-    match_basic_72,
-    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
-    r"2/7",
-    Some((0, 3))
-);
-mat!(
-    match_basic_73,
-    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
-    r"feb 1,Feb 6",
-    Some((5, 11))
-);
-mat!(
-    match_basic_74,
-    r"((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))",
-    r"x",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1))
-);
-mat!(
-    match_basic_75,
-    r"((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))*",
-    r"xx",
-    Some((0, 2)),
-    Some((1, 2)),
-    Some((1, 2))
-);
-mat!(
-    match_basic_76,
-    r"a?(ab|ba)*",
-    r"ababababababababababababababababababababababababababababababababababababababababa",
-    Some((0, 81)),
-    Some((79, 81))
-);
-mat!(
-    match_basic_77,
-    r"abaa|abbaa|abbbaa|abbbbaa",
-    r"ababbabbbabbbabbbbabbbbaa",
-    Some((18, 25))
-);
-mat!(
-    match_basic_78,
-    r"abaa|abbaa|abbbaa|abbbbaa",
-    r"ababbabbbabbbabbbbabaa",
-    Some((18, 22))
-);
-mat!(
-    match_basic_79,
-    r"aaac|aabc|abac|abbc|baac|babc|bbac|bbbc",
-    r"baaabbbabac",
-    Some((7, 11))
-);
-mat!(match_basic_80, r".*", r"
", Some((0, 2)));
-mat!(
-    match_basic_81,
-    r"aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll",
-    r"XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa",
-    Some((53, 57))
-);
-mat!(match_basic_83, r"a*a*a*a*a*b", r"aaaaaaaaab", Some((0, 10)));
-mat!(match_basic_84, r"^", r"", Some((0, 0)));
-mat!(match_basic_85, r"$", r"", Some((0, 0)));
-mat!(match_basic_86, r"^$", r"", Some((0, 0)));
-mat!(match_basic_87, r"^a$", r"a", Some((0, 1)));
-mat!(match_basic_88, r"abc", r"abc", Some((0, 3)));
-mat!(match_basic_89, r"abc", r"xabcy", Some((1, 4)));
-mat!(match_basic_90, r"abc", r"ababc", Some((2, 5)));
-mat!(match_basic_91, r"ab*c", r"abc", Some((0, 3)));
-mat!(match_basic_92, r"ab*bc", r"abc", Some((0, 3)));
-mat!(match_basic_93, r"ab*bc", r"abbc", Some((0, 4)));
-mat!(match_basic_94, r"ab*bc", r"abbbbc", Some((0, 6)));
-mat!(match_basic_95, r"ab+bc", r"abbc", Some((0, 4)));
-mat!(match_basic_96, r"ab+bc", r"abbbbc", Some((0, 6)));
-mat!(match_basic_97, r"ab?bc", r"abbc", Some((0, 4)));
-mat!(match_basic_98, r"ab?bc", r"abc", Some((0, 3)));
-mat!(match_basic_99, r"ab?c", r"abc", Some((0, 3)));
-mat!(match_basic_100, r"^abc$", r"abc", Some((0, 3)));
-mat!(match_basic_101, r"^abc", r"abcc", Some((0, 3)));
-mat!(match_basic_102, r"abc$", r"aabc", Some((1, 4)));
-mat!(match_basic_103, r"^", r"abc", Some((0, 0)));
-mat!(match_basic_104, r"$", r"abc", Some((3, 3)));
-mat!(match_basic_105, r"a.c", r"abc", Some((0, 3)));
-mat!(match_basic_106, r"a.c", r"axc", Some((0, 3)));
-mat!(match_basic_107, r"a.*c", r"axyzc", Some((0, 5)));
-mat!(match_basic_108, r"a[bc]d", r"abd", Some((0, 3)));
-mat!(match_basic_109, r"a[b-d]e", r"ace", Some((0, 3)));
-mat!(match_basic_110, r"a[b-d]", r"aac", Some((1, 3)));
-mat!(match_basic_111, r"a[-b]", r"a-", Some((0, 2)));
-mat!(match_basic_112, r"a[b-]", r"a-", Some((0, 2)));
-mat!(match_basic_113, r"a]", r"a]", Some((0, 2)));
-mat!(match_basic_114, r"a[]]b", r"a]b", Some((0, 3)));
-mat!(match_basic_115, r"a[^bc]d", r"aed", Some((0, 3)));
-mat!(match_basic_116, r"a[^-b]c", r"adc", Some((0, 3)));
-mat!(match_basic_117, r"a[^]b]c", r"adc", Some((0, 3)));
-mat!(match_basic_118, r"ab|cd", r"abc", Some((0, 2)));
-mat!(match_basic_119, r"ab|cd", r"abcd", Some((0, 2)));
-mat!(match_basic_120, r"a\(b", r"a(b", Some((0, 3)));
-mat!(match_basic_121, r"a\(*b", r"ab", Some((0, 2)));
-mat!(match_basic_122, r"a\(*b", r"a((b", Some((0, 4)));
-mat!(
-    match_basic_123,
-    r"((a))",
-    r"abc",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1))
-);
-mat!(
-    match_basic_124,
-    r"(a)b(c)",
-    r"abc",
-    Some((0, 3)),
-    Some((0, 1)),
-    Some((2, 3))
-);
-mat!(match_basic_125, r"a+b+c", r"aabbabc", Some((4, 7)));
-mat!(match_basic_126, r"a*", r"aaa", Some((0, 3)));
-mat!(match_basic_128, r"(a*)*", r"-", Some((0, 0)), None);
-mat!(match_basic_129, r"(a*)+", r"-", Some((0, 0)), Some((0, 0)));
-mat!(match_basic_131, r"(a*|b)*", r"-", Some((0, 0)), None);
-mat!(match_basic_132, r"(a+|b)*", r"ab", Some((0, 2)), Some((1, 2)));
-mat!(match_basic_133, r"(a+|b)+", r"ab", Some((0, 2)), Some((1, 2)));
-mat!(match_basic_134, r"(a+|b)?", r"ab", Some((0, 1)), Some((0, 1)));
-mat!(match_basic_135, r"[^ab]*", r"cde", Some((0, 3)));
-mat!(match_basic_137, r"(^)*", r"-", Some((0, 0)), None);
-mat!(match_basic_138, r"a*", r"", Some((0, 0)));
-mat!(match_basic_139, r"([abc])*d", r"abbbcd", Some((0, 6)), Some((4, 5)));
-mat!(match_basic_140, r"([abc])*bcd", r"abcd", Some((0, 4)), Some((0, 1)));
-mat!(match_basic_141, r"a|b|c|d|e", r"e", Some((0, 1)));
-mat!(match_basic_142, r"(a|b|c|d|e)f", r"ef", Some((0, 2)), Some((0, 1)));
-mat!(match_basic_144, r"((a*|b))*", r"-", Some((0, 0)), None, None);
-mat!(match_basic_145, r"abcd*efg", r"abcdefg", Some((0, 7)));
-mat!(match_basic_146, r"ab*", r"xabyabbbz", Some((1, 3)));
-mat!(match_basic_147, r"ab*", r"xayabbbz", Some((1, 2)));
-mat!(match_basic_148, r"(ab|cd)e", r"abcde", Some((2, 5)), Some((2, 4)));
-mat!(match_basic_149, r"[abhgefdc]ij", r"hij", Some((0, 3)));
-mat!(match_basic_150, r"(a|b)c*d", r"abcd", Some((1, 4)), Some((1, 2)));
-mat!(match_basic_151, r"(ab|ab*)bc", r"abc", Some((0, 3)), Some((0, 1)));
-mat!(match_basic_152, r"a([bc]*)c*", r"abc", Some((0, 3)), Some((1, 3)));
-mat!(
-    match_basic_153,
-    r"a([bc]*)(c*d)",
-    r"abcd",
-    Some((0, 4)),
-    Some((1, 3)),
-    Some((3, 4))
-);
-mat!(
-    match_basic_154,
-    r"a([bc]+)(c*d)",
-    r"abcd",
-    Some((0, 4)),
-    Some((1, 3)),
-    Some((3, 4))
-);
-mat!(
-    match_basic_155,
-    r"a([bc]*)(c+d)",
-    r"abcd",
-    Some((0, 4)),
-    Some((1, 2)),
-    Some((2, 4))
-);
-mat!(match_basic_156, r"a[bcd]*dcdcde", r"adcdcde", Some((0, 7)));
-mat!(match_basic_157, r"(ab|a)b*c", r"abc", Some((0, 3)), Some((0, 2)));
-mat!(
-    match_basic_158,
-    r"((a)(b)c)(d)",
-    r"abcd",
-    Some((0, 4)),
-    Some((0, 3)),
-    Some((0, 1)),
-    Some((1, 2)),
-    Some((3, 4))
-);
-mat!(match_basic_159, r"[A-Za-z_][A-Za-z0-9_]*", r"alpha", Some((0, 5)));
-mat!(match_basic_160, r"^a(bc+|b[eh])g|.h$", r"abh", Some((1, 3)));
-mat!(
-    match_basic_161,
-    r"(bc+d$|ef*g.|h?i(j|k))",
-    r"effgz",
-    Some((0, 5)),
-    Some((0, 5))
-);
-mat!(
-    match_basic_162,
-    r"(bc+d$|ef*g.|h?i(j|k))",
-    r"ij",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((1, 2))
-);
-mat!(
-    match_basic_163,
-    r"(bc+d$|ef*g.|h?i(j|k))",
-    r"reffgz",
-    Some((1, 6)),
-    Some((1, 6))
-);
-mat!(
-    match_basic_164,
-    r"(((((((((a)))))))))",
-    r"a",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((0, 1))
-);
-mat!(
-    match_basic_165,
-    r"multiple words",
-    r"multiple words yeah",
-    Some((0, 14))
-);
-mat!(
-    match_basic_166,
-    r"(.*)c(.*)",
-    r"abcde",
-    Some((0, 5)),
-    Some((0, 2)),
-    Some((3, 5))
-);
-mat!(match_basic_167, r"abcd", r"abcd", Some((0, 4)));
-mat!(match_basic_168, r"a(bc)d", r"abcd", Some((0, 4)), Some((1, 3)));
-mat!(match_basic_169, r"a[
-]?c", r"ac", Some((0, 3)));
-mat!(
-    match_basic_170,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Qaddafi",
-    Some((0, 15)),
-    None,
-    Some((10, 12))
-);
-mat!(
-    match_basic_171,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Mo'ammar Gadhafi",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_172,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Kaddafi",
-    Some((0, 15)),
-    None,
-    Some((10, 12))
-);
-mat!(
-    match_basic_173,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Qadhafi",
-    Some((0, 15)),
-    None,
-    Some((10, 12))
-);
-mat!(
-    match_basic_174,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Gadafi",
-    Some((0, 14)),
-    None,
-    Some((10, 11))
-);
-mat!(
-    match_basic_175,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Mu'ammar Qadafi",
-    Some((0, 15)),
-    None,
-    Some((11, 12))
-);
-mat!(
-    match_basic_176,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Moamar Gaddafi",
-    Some((0, 14)),
-    None,
-    Some((9, 11))
-);
-mat!(
-    match_basic_177,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Mu'ammar Qadhdhafi",
-    Some((0, 18)),
-    None,
-    Some((13, 15))
-);
-mat!(
-    match_basic_178,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Khaddafi",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_179,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Ghaddafy",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_180,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Ghadafi",
-    Some((0, 15)),
-    None,
-    Some((11, 12))
-);
-mat!(
-    match_basic_181,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Ghaddafi",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_182,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muamar Kaddafi",
-    Some((0, 14)),
-    None,
-    Some((9, 11))
-);
-mat!(
-    match_basic_183,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Quathafi",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_184,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Muammar Gheddafi",
-    Some((0, 16)),
-    None,
-    Some((11, 13))
-);
-mat!(
-    match_basic_185,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Moammar Khadafy",
-    Some((0, 15)),
-    None,
-    Some((11, 12))
-);
-mat!(
-    match_basic_186,
-    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
-    r"Moammar Qudhafi",
-    Some((0, 15)),
-    None,
-    Some((10, 12))
-);
-mat!(match_basic_187, r"a+(b|c)*d+", r"aabcdd", Some((0, 6)), Some((3, 4)));
-mat!(match_basic_188, r"^.+$", r"vivi", Some((0, 4)));
-mat!(match_basic_189, r"^(.+)$", r"vivi", Some((0, 4)), Some((0, 4)));
-mat!(
-    match_basic_190,
-    r"^([^!.]+).att.com!(.+)$",
-    r"gryphon.att.com!eby",
-    Some((0, 19)),
-    Some((0, 7)),
-    Some((16, 19))
-);
-mat!(
-    match_basic_191,
-    r"^([^!]+!)?([^!]+)$",
-    r"bas",
-    Some((0, 3)),
-    None,
-    Some((0, 3))
-);
-mat!(
-    match_basic_192,
-    r"^([^!]+!)?([^!]+)$",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_193,
-    r"^([^!]+!)?([^!]+)$",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_194,
-    r"^.+!([^!]+!)([^!]+)$",
-    r"foo!bar!bas",
-    Some((0, 11)),
-    Some((4, 8)),
-    Some((8, 11))
-);
-mat!(
-    match_basic_195,
-    r"((foo)|(bar))!bas",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 3)),
-    None,
-    Some((0, 3))
-);
-mat!(
-    match_basic_196,
-    r"((foo)|(bar))!bas",
-    r"foo!bar!bas",
-    Some((4, 11)),
-    Some((4, 7)),
-    None,
-    Some((4, 7))
-);
-mat!(
-    match_basic_197,
-    r"((foo)|(bar))!bas",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 3)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_198,
-    r"((foo)|bar)!bas",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_199,
-    r"((foo)|bar)!bas",
-    r"foo!bar!bas",
-    Some((4, 11)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_200,
-    r"((foo)|bar)!bas",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 3)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_201,
-    r"(foo|(bar))!bas",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 3)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_202,
-    r"(foo|(bar))!bas",
-    r"foo!bar!bas",
-    Some((4, 11)),
-    Some((4, 7)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_203,
-    r"(foo|(bar))!bas",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_204,
-    r"(foo|bar)!bas",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_205,
-    r"(foo|bar)!bas",
-    r"foo!bar!bas",
-    Some((4, 11)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_206,
-    r"(foo|bar)!bas",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 3))
-);
-mat!(
-    match_basic_207,
-    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
-    r"foo!bar!bas",
-    Some((0, 11)),
-    Some((0, 11)),
-    None,
-    None,
-    Some((4, 8)),
-    Some((8, 11))
-);
-mat!(
-    match_basic_208,
-    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
-    r"bas",
-    Some((0, 3)),
-    None,
-    Some((0, 3))
-);
-mat!(
-    match_basic_209,
-    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_210,
-    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
-    r"foo!bar!bas",
-    Some((0, 11)),
-    None,
-    None,
-    Some((4, 8)),
-    Some((8, 11))
-);
-mat!(
-    match_basic_211,
-    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_212,
-    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
-    r"bas",
-    Some((0, 3)),
-    Some((0, 3)),
-    None,
-    Some((0, 3))
-);
-mat!(
-    match_basic_213,
-    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
-    r"bar!bas",
-    Some((0, 7)),
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(
-    match_basic_214,
-    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
-    r"foo!bar!bas",
-    Some((0, 11)),
-    Some((0, 11)),
-    None,
-    None,
-    Some((4, 8)),
-    Some((8, 11))
-);
-mat!(
-    match_basic_215,
-    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
-    r"foo!bas",
-    Some((0, 7)),
-    Some((0, 7)),
-    Some((0, 4)),
-    Some((4, 7))
-);
-mat!(match_basic_216, r".*(/XXX).*", r"/XXX", Some((0, 4)), Some((0, 4)));
-mat!(match_basic_217, r".*(\\XXX).*", r"\XXX", Some((0, 4)), Some((0, 4)));
-mat!(match_basic_218, r"\\XXX", r"\XXX", Some((0, 4)));
-mat!(match_basic_219, r".*(/000).*", r"/000", Some((0, 4)), Some((0, 4)));
-mat!(match_basic_220, r".*(\\000).*", r"\000", Some((0, 4)), Some((0, 4)));
-mat!(match_basic_221, r"\\000", r"\000", Some((0, 4)));
-
-// Tests from nullsubexpr.dat
-mat!(match_nullsubexpr_3, r"(a*)*", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_5, r"(a*)*", r"x", Some((0, 0)), None);
-mat!(match_nullsubexpr_6, r"(a*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_7, r"(a*)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_8, r"(a*)+", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_9, r"(a*)+", r"x", Some((0, 0)), Some((0, 0)));
-mat!(match_nullsubexpr_10, r"(a*)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_11, r"(a*)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_12, r"(a+)*", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_13, r"(a+)*", r"x", Some((0, 0)));
-mat!(match_nullsubexpr_14, r"(a+)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_15, r"(a+)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_16, r"(a+)+", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_17, r"(a+)+", r"x", None);
-mat!(match_nullsubexpr_18, r"(a+)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_19, r"(a+)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_21, r"([a]*)*", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_23, r"([a]*)*", r"x", Some((0, 0)), None);
-mat!(match_nullsubexpr_24, r"([a]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_25, r"([a]*)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_26, r"([a]*)+", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_27, r"([a]*)+", r"x", Some((0, 0)), Some((0, 0)));
-mat!(match_nullsubexpr_28, r"([a]*)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_29, r"([a]*)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_30, r"([^b]*)*", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_32, r"([^b]*)*", r"b", Some((0, 0)), None);
-mat!(match_nullsubexpr_33, r"([^b]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(
-    match_nullsubexpr_34,
-    r"([^b]*)*",
-    r"aaaaaab",
-    Some((0, 6)),
-    Some((0, 6))
-);
-mat!(match_nullsubexpr_35, r"([ab]*)*", r"a", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_36, r"([ab]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_37, r"([ab]*)*", r"ababab", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_38, r"([ab]*)*", r"bababa", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_39, r"([ab]*)*", r"b", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_40, r"([ab]*)*", r"bbbbbb", Some((0, 6)), Some((0, 6)));
-mat!(
-    match_nullsubexpr_41,
-    r"([ab]*)*",
-    r"aaaabcde",
-    Some((0, 5)),
-    Some((0, 5))
-);
-mat!(match_nullsubexpr_42, r"([^a]*)*", r"b", Some((0, 1)), Some((0, 1)));
-mat!(match_nullsubexpr_43, r"([^a]*)*", r"bbbbbb", Some((0, 6)), Some((0, 6)));
-mat!(match_nullsubexpr_45, r"([^a]*)*", r"aaaaaa", Some((0, 0)), None);
-mat!(
-    match_nullsubexpr_46,
-    r"([^ab]*)*",
-    r"ccccxx",
-    Some((0, 6)),
-    Some((0, 6))
-);
-mat!(match_nullsubexpr_48, r"([^ab]*)*", r"ababab", Some((0, 0)), None);
-mat!(
-    match_nullsubexpr_50,
-    r"((z)+|a)*",
-    r"zabcde",
-    Some((0, 2)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_69,
-    r"(a*)*(x)",
-    r"x",
-    Some((0, 1)),
-    None,
-    Some((0, 1))
-);
-mat!(
-    match_nullsubexpr_70,
-    r"(a*)*(x)",
-    r"ax",
-    Some((0, 2)),
-    Some((0, 1)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_71,
-    r"(a*)*(x)",
-    r"axa",
-    Some((0, 2)),
-    Some((0, 1)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_73,
-    r"(a*)+(x)",
-    r"x",
-    Some((0, 1)),
-    Some((0, 0)),
-    Some((0, 1))
-);
-mat!(
-    match_nullsubexpr_74,
-    r"(a*)+(x)",
-    r"ax",
-    Some((0, 2)),
-    Some((0, 1)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_75,
-    r"(a*)+(x)",
-    r"axa",
-    Some((0, 2)),
-    Some((0, 1)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_77,
-    r"(a*){2}(x)",
-    r"x",
-    Some((0, 1)),
-    Some((0, 0)),
-    Some((0, 1))
-);
-mat!(
-    match_nullsubexpr_78,
-    r"(a*){2}(x)",
-    r"ax",
-    Some((0, 2)),
-    Some((1, 1)),
-    Some((1, 2))
-);
-mat!(
-    match_nullsubexpr_79,
-    r"(a*){2}(x)",
-    r"axa",
-    Some((0, 2)),
-    Some((1, 1)),
-    Some((1, 2))
-);
-
-// Tests from repetition.dat
-mat!(match_repetition_10, r"((..)|(.))", r"", None);
-mat!(match_repetition_11, r"((..)|(.))((..)|(.))", r"", None);
-mat!(match_repetition_12, r"((..)|(.))((..)|(.))((..)|(.))", r"", None);
-mat!(match_repetition_14, r"((..)|(.)){1}", r"", None);
-mat!(match_repetition_15, r"((..)|(.)){2}", r"", None);
-mat!(match_repetition_16, r"((..)|(.)){3}", r"", None);
-mat!(match_repetition_18, r"((..)|(.))*", r"", Some((0, 0)));
-mat!(
-    match_repetition_20,
-    r"((..)|(.))",
-    r"a",
-    Some((0, 1)),
-    Some((0, 1)),
-    None,
-    Some((0, 1))
-);
-mat!(match_repetition_21, r"((..)|(.))((..)|(.))", r"a", None);
-mat!(match_repetition_22, r"((..)|(.))((..)|(.))((..)|(.))", r"a", None);
-mat!(
-    match_repetition_24,
-    r"((..)|(.)){1}",
-    r"a",
-    Some((0, 1)),
-    Some((0, 1)),
-    None,
-    Some((0, 1))
-);
-mat!(match_repetition_25, r"((..)|(.)){2}", r"a", None);
-mat!(match_repetition_26, r"((..)|(.)){3}", r"a", None);
-mat!(
-    match_repetition_28,
-    r"((..)|(.))*",
-    r"a",
-    Some((0, 1)),
-    Some((0, 1)),
-    None,
-    Some((0, 1))
-);
-mat!(
-    match_repetition_30,
-    r"((..)|(.))",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_31,
-    r"((..)|(.))((..)|(.))",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 1)),
-    None,
-    Some((0, 1)),
-    Some((1, 2)),
-    None,
-    Some((1, 2))
-);
-mat!(match_repetition_32, r"((..)|(.))((..)|(.))((..)|(.))", r"aa", None);
-mat!(
-    match_repetition_34,
-    r"((..)|(.)){1}",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_35,
-    r"((..)|(.)){2}",
-    r"aa",
-    Some((0, 2)),
-    Some((1, 2)),
-    None,
-    Some((1, 2))
-);
-mat!(match_repetition_36, r"((..)|(.)){3}", r"aa", None);
-mat!(
-    match_repetition_38,
-    r"((..)|(.))*",
-    r"aa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_40,
-    r"((..)|(.))",
-    r"aaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_41,
-    r"((..)|(.))((..)|(.))",
-    r"aaa",
-    Some((0, 3)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 3)),
-    None,
-    Some((2, 3))
-);
-mat!(
-    match_repetition_42,
-    r"((..)|(.))((..)|(.))((..)|(.))",
-    r"aaa",
-    Some((0, 3)),
-    Some((0, 1)),
-    None,
-    Some((0, 1)),
-    Some((1, 2)),
-    None,
-    Some((1, 2)),
-    Some((2, 3)),
-    None,
-    Some((2, 3))
-);
-mat!(
-    match_repetition_44,
-    r"((..)|(.)){1}",
-    r"aaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_46,
-    r"((..)|(.)){2}",
-    r"aaa",
-    Some((0, 3)),
-    Some((2, 3)),
-    Some((0, 2)),
-    Some((2, 3))
-);
-mat!(
-    match_repetition_47,
-    r"((..)|(.)){3}",
-    r"aaa",
-    Some((0, 3)),
-    Some((2, 3)),
-    None,
-    Some((2, 3))
-);
-mat!(
-    match_repetition_50,
-    r"((..)|(.))*",
-    r"aaa",
-    Some((0, 3)),
-    Some((2, 3)),
-    Some((0, 2)),
-    Some((2, 3))
-);
-mat!(
-    match_repetition_52,
-    r"((..)|(.))",
-    r"aaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_53,
-    r"((..)|(.))((..)|(.))",
-    r"aaaa",
-    Some((0, 4)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_54,
-    r"((..)|(.))((..)|(.))((..)|(.))",
-    r"aaaa",
-    Some((0, 4)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 3)),
-    None,
-    Some((2, 3)),
-    Some((3, 4)),
-    None,
-    Some((3, 4))
-);
-mat!(
-    match_repetition_56,
-    r"((..)|(.)){1}",
-    r"aaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_57,
-    r"((..)|(.)){2}",
-    r"aaaa",
-    Some((0, 4)),
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_59,
-    r"((..)|(.)){3}",
-    r"aaaa",
-    Some((0, 4)),
-    Some((3, 4)),
-    Some((0, 2)),
-    Some((3, 4))
-);
-mat!(
-    match_repetition_61,
-    r"((..)|(.))*",
-    r"aaaa",
-    Some((0, 4)),
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_63,
-    r"((..)|(.))",
-    r"aaaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_64,
-    r"((..)|(.))((..)|(.))",
-    r"aaaaa",
-    Some((0, 4)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_65,
-    r"((..)|(.))((..)|(.))((..)|(.))",
-    r"aaaaa",
-    Some((0, 5)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 4)),
-    Some((2, 4)),
-    None,
-    Some((4, 5)),
-    None,
-    Some((4, 5))
-);
-mat!(
-    match_repetition_67,
-    r"((..)|(.)){1}",
-    r"aaaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_68,
-    r"((..)|(.)){2}",
-    r"aaaaa",
-    Some((0, 4)),
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_70,
-    r"((..)|(.)){3}",
-    r"aaaaa",
-    Some((0, 5)),
-    Some((4, 5)),
-    Some((2, 4)),
-    Some((4, 5))
-);
-mat!(
-    match_repetition_73,
-    r"((..)|(.))*",
-    r"aaaaa",
-    Some((0, 5)),
-    Some((4, 5)),
-    Some((2, 4)),
-    Some((4, 5))
-);
-mat!(
-    match_repetition_75,
-    r"((..)|(.))",
-    r"aaaaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_76,
-    r"((..)|(.))((..)|(.))",
-    r"aaaaaa",
-    Some((0, 4)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_77,
-    r"((..)|(.))((..)|(.))((..)|(.))",
-    r"aaaaaa",
-    Some((0, 6)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None,
-    Some((2, 4)),
-    Some((2, 4)),
-    None,
-    Some((4, 6)),
-    Some((4, 6)),
-    None
-);
-mat!(
-    match_repetition_79,
-    r"((..)|(.)){1}",
-    r"aaaaaa",
-    Some((0, 2)),
-    Some((0, 2)),
-    Some((0, 2)),
-    None
-);
-mat!(
-    match_repetition_80,
-    r"((..)|(.)){2}",
-    r"aaaaaa",
-    Some((0, 4)),
-    Some((2, 4)),
-    Some((2, 4)),
-    None
-);
-mat!(
-    match_repetition_81,
-    r"((..)|(.)){3}",
-    r"aaaaaa",
-    Some((0, 6)),
-    Some((4, 6)),
-    Some((4, 6)),
-    None
-);
-mat!(
-    match_repetition_83,
-    r"((..)|(.))*",
-    r"aaaaaa",
-    Some((0, 6)),
-    Some((4, 6)),
-    Some((4, 6)),
-    None
-);
-mat!(
-    match_repetition_90,
-    r"X(.?){0,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_91,
-    r"X(.?){1,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_92,
-    r"X(.?){2,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_93,
-    r"X(.?){3,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_94,
-    r"X(.?){4,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_95,
-    r"X(.?){5,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_96,
-    r"X(.?){6,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_97,
-    r"X(.?){7,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((7, 8))
-);
-mat!(
-    match_repetition_98,
-    r"X(.?){8,}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_100,
-    r"X(.?){0,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_102,
-    r"X(.?){1,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_104,
-    r"X(.?){2,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_106,
-    r"X(.?){3,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_108,
-    r"X(.?){4,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_110,
-    r"X(.?){5,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_112,
-    r"X(.?){6,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_114,
-    r"X(.?){7,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_115,
-    r"X(.?){8,8}Y",
-    r"X1234567Y",
-    Some((0, 9)),
-    Some((8, 8))
-);
-mat!(
-    match_repetition_126,
-    r"(a|ab|c|bcd){0,}(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_127,
-    r"(a|ab|c|bcd){1,}(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_128,
-    r"(a|ab|c|bcd){2,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((3, 6)),
-    Some((6, 6))
-);
-mat!(
-    match_repetition_129,
-    r"(a|ab|c|bcd){3,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((3, 6)),
-    Some((6, 6))
-);
-mat!(match_repetition_130, r"(a|ab|c|bcd){4,}(d*)", r"ababcd", None);
-mat!(
-    match_repetition_131,
-    r"(a|ab|c|bcd){0,10}(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_132,
-    r"(a|ab|c|bcd){1,10}(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_133,
-    r"(a|ab|c|bcd){2,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((3, 6)),
-    Some((6, 6))
-);
-mat!(
-    match_repetition_134,
-    r"(a|ab|c|bcd){3,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((3, 6)),
-    Some((6, 6))
-);
-mat!(match_repetition_135, r"(a|ab|c|bcd){4,10}(d*)", r"ababcd", None);
-mat!(
-    match_repetition_136,
-    r"(a|ab|c|bcd)*(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_137,
-    r"(a|ab|c|bcd)+(d*)",
-    r"ababcd",
-    Some((0, 1)),
-    Some((0, 1)),
-    Some((1, 1))
-);
-mat!(
-    match_repetition_143,
-    r"(ab|a|c|bcd){0,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_145,
-    r"(ab|a|c|bcd){1,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_147,
-    r"(ab|a|c|bcd){2,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_149,
-    r"(ab|a|c|bcd){3,}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(match_repetition_150, r"(ab|a|c|bcd){4,}(d*)", r"ababcd", None);
-mat!(
-    match_repetition_152,
-    r"(ab|a|c|bcd){0,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_154,
-    r"(ab|a|c|bcd){1,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_156,
-    r"(ab|a|c|bcd){2,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_158,
-    r"(ab|a|c|bcd){3,10}(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(match_repetition_159, r"(ab|a|c|bcd){4,10}(d*)", r"ababcd", None);
-mat!(
-    match_repetition_161,
-    r"(ab|a|c|bcd)*(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
-mat!(
-    match_repetition_163,
-    r"(ab|a|c|bcd)+(d*)",
-    r"ababcd",
-    Some((0, 6)),
-    Some((4, 5)),
-    Some((5, 6))
-);
diff --git a/tests/fuzz/mod.rs b/tests/fuzz/mod.rs
new file mode 100644
index 0000000000..88c196ae67
--- /dev/null
+++ b/tests/fuzz/mod.rs
@@ -0,0 +1,166 @@
+// This set of tests is different from regression_fuzz in that the tests start
+// from the fuzzer data directly. The test essentially duplicates the fuzz
+// target. I wonder if there's a better way to set this up... Hmmm. I bet
+// `cargo fuzz` has something where it can run a target against crash files and
+// verify that they pass.
+
+// This case found by the fuzzer causes the meta engine to use the "reverse
+// inner" literal strategy. That in turn uses a specialized search routine
+// for the lazy DFA in order to avoid worst case quadratic behavior. That
+// specialized search routine had a bug where it assumed that start state
+// specialization was disabled. But this is indeed not the case, since it
+// reuses the "general" lazy DFA for the full regex created as part of the core
+// strategy, which might very well have start states specialized due to the
+// existence of a prefilter.
+//
+// This is a somewhat weird case because if the core engine has a prefilter,
+// then it's usually the case that the "reverse inner" optimization won't be
+// pursued in that case. But there are some heuristics that try to detect
+// whether a prefilter is "fast" or not. If it's not, then the meta engine will
+// attempt the reverse inner optimization. And indeed, that's what happens
+// here. So the reverse inner optimization ends up with a lazy DFA that has
+// start states specialized. Ideally this wouldn't happen because specializing
+// start states without a prefilter inside the DFA can be disastrous for
+// performance by causing the DFA to ping-pong in and out of the special state
+// handling. In this case, it's probably not a huge deal because the lazy
+// DFA is only used for part of the matching where as the work horse is the
+// prefilter found by the reverse inner optimization.
+//
+// We could maybe fix this by refactoring the meta engine to be a little more
+// careful. For example, by attempting the optimizations before building the
+// core engine. But this is perhaps a little tricky.
+#[test]
+fn meta_stopat_specialize_start_states() {
+    let data = include_bytes!(
+        "testdata/crash-8760b19b25d74e3603d4c643e9c7404fdd3631f9",
+    );
+    let _ = run(data);
+}
+
+// Same bug as meta_stopat_specialize_start_states, but minimized by the
+// fuzzer.
+#[test]
+fn meta_stopat_specialize_start_states_min() {
+    let data = include_bytes!(
+        "testdata/minimized-from-8760b19b25d74e3603d4c643e9c7404fdd3631f9",
+    );
+    let _ = run(data);
+}
+
+// This input generated a pattern with a fail state (e.g., \P{any}, [^\s\S]
+// or [a&&b]). But the fail state was in a branch, where a subsequent branch
+// should have led to an overall match, but handling of the fail state
+// prevented it from doing so. A hand-minimized version of this is '[^\s\S]A|B'
+// on the haystack 'B'. That should yield a match of 'B'.
+//
+// The underlying cause was an issue in how DFA determinization handled fail
+// states. The bug didn't impact the PikeVM or the bounded backtracker.
+#[test]
+fn fail_branch_prevents_match() {
+    let data = include_bytes!(
+        "testdata/crash-cd33b13df59ea9d74503986f9d32a270dd43cc04",
+    );
+    let _ = run(data);
+}
+
+// This input generated a pattern that contained a sub-expression like this:
+//
+//     a{0}{50000}
+//
+// This turned out to provoke quadratic behavior in the NFA compiler.
+// Basically, the NFA compiler works in two phases. The first phase builds
+// a more complicated-but-simpler-to-construct sequence of NFA states that
+// includes unconditional epsilon transitions. As part of converting this
+// sequence to the "final" NFA, we remove those unconditional espilon
+// transition. The code responsible for doing this follows every chain of
+// these transitions and remaps the state IDs. The way we were doing this
+// before resulted in re-following every subsequent part of the chain for each
+// state in the chain, which ended up being quadratic behavior. We effectively
+// memoized this, which fixed the performance bug.
+#[test]
+fn slow_big_empty_chain() {
+    let data = include_bytes!(
+        "testdata/slow-unit-9ca9cc9929fee1fcbb847a78384effb8b98ea18a",
+    );
+    let _ = run(data);
+}
+
+// A different case of slow_big_empty_chain.
+#[test]
+fn slow_big_empty_chain2() {
+    let data = include_bytes!(
+        "testdata/slow-unit-3ab758ea520027fefd3f00e1384d9aeef155739e",
+    );
+    let _ = run(data);
+}
+
+// A different case of slow_big_empty_chain.
+#[test]
+fn slow_big_empty_chain3() {
+    let data = include_bytes!(
+        "testdata/slow-unit-b8a052f4254802edbe5f569b6ce6e9b6c927e9d6",
+    );
+    let _ = run(data);
+}
+
+// A different case of slow_big_empty_chain.
+#[test]
+fn slow_big_empty_chain4() {
+    let data = include_bytes!(
+        "testdata/slow-unit-93c73a43581f205f9aaffd9c17e52b34b17becd0",
+    );
+    let _ = run(data);
+}
+
+// A different case of slow_big_empty_chain.
+#[test]
+fn slow_big_empty_chain5() {
+    let data = include_bytes!(
+        "testdata/slow-unit-5345fccadf3812c53c3ccc7af5aa2741b7b2106c",
+    );
+    let _ = run(data);
+}
+
+// A different case of slow_big_empty_chain.
+#[test]
+fn slow_big_empty_chain6() {
+    let data = include_bytes!(
+        "testdata/slow-unit-6bd643eec330166e4ada91da2d3f284268481085",
+    );
+    let _ = run(data);
+}
+
+// This fuzz input generated a pattern with a large repetition that would fail
+// NFA compilation, but its HIR was small. (HIR doesn't expand repetitions.)
+// But, the bounds were high enough that the minimum length calculation
+// overflowed. We fixed this by using saturating arithmetic (and also checked
+// arithmetic for the maximum length calculation).
+//
+// Incidentally, this was the only unguarded arithmetic operation performed in
+// the HIR smart constructors. And the fuzzer found it. Hah. Nice.
+#[test]
+fn minimum_len_overflow() {
+    let data = include_bytes!(
+        "testdata/crash-7eb3351f0965e5d6c1cb98aa8585949ef96531ff",
+    );
+    let _ = run(data);
+}
+
+// This is the fuzz target function. We duplicate it here since this is the
+// thing we use to interpret the data. It is ultimately what we want to
+// succeed.
+fn run(data: &[u8]) -> Option<()> {
+    if data.len() < 2 {
+        return None;
+    }
+    let mut split_at = usize::from(data[0]);
+    let data = std::str::from_utf8(&data[1..]).ok()?;
+    // Split data into a regex and haystack to search.
+    let len = usize::try_from(data.chars().count()).ok()?;
+    split_at = std::cmp::max(split_at, 1) % len;
+    let char_index = data.char_indices().nth(split_at)?.0;
+    let (pattern, input) = data.split_at(char_index);
+    let re = regex::Regex::new(pattern).ok()?;
+    re.is_match(input);
+    Some(())
+}
diff --git a/tests/fuzz/testdata/crash-7eb3351f0965e5d6c1cb98aa8585949ef96531ff b/tests/fuzz/testdata/crash-7eb3351f0965e5d6c1cb98aa8585949ef96531ff
new file mode 100644
index 0000000000..f7ffbc9740
Binary files /dev/null and b/tests/fuzz/testdata/crash-7eb3351f0965e5d6c1cb98aa8585949ef96531ff differ
diff --git a/tests/fuzz/testdata/crash-8760b19b25d74e3603d4c643e9c7404fdd3631f9 b/tests/fuzz/testdata/crash-8760b19b25d74e3603d4c643e9c7404fdd3631f9
new file mode 100644
index 0000000000..86748199b3
Binary files /dev/null and b/tests/fuzz/testdata/crash-8760b19b25d74e3603d4c643e9c7404fdd3631f9 differ
diff --git a/tests/fuzz/testdata/crash-cd33b13df59ea9d74503986f9d32a270dd43cc04 b/tests/fuzz/testdata/crash-cd33b13df59ea9d74503986f9d32a270dd43cc04
new file mode 100644
index 0000000000..152769d2da
Binary files /dev/null and b/tests/fuzz/testdata/crash-cd33b13df59ea9d74503986f9d32a270dd43cc04 differ
diff --git a/tests/fuzz/testdata/minimized-from-8760b19b25d74e3603d4c643e9c7404fdd3631f9 b/tests/fuzz/testdata/minimized-from-8760b19b25d74e3603d4c643e9c7404fdd3631f9
new file mode 100644
index 0000000000..69663d5c73
Binary files /dev/null and b/tests/fuzz/testdata/minimized-from-8760b19b25d74e3603d4c643e9c7404fdd3631f9 differ
diff --git a/tests/fuzz/testdata/slow-unit-3ab758ea520027fefd3f00e1384d9aeef155739e b/tests/fuzz/testdata/slow-unit-3ab758ea520027fefd3f00e1384d9aeef155739e
new file mode 100644
index 0000000000..6c22803538
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-3ab758ea520027fefd3f00e1384d9aeef155739e differ
diff --git a/tests/fuzz/testdata/slow-unit-5345fccadf3812c53c3ccc7af5aa2741b7b2106c b/tests/fuzz/testdata/slow-unit-5345fccadf3812c53c3ccc7af5aa2741b7b2106c
new file mode 100644
index 0000000000..0570f328c3
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-5345fccadf3812c53c3ccc7af5aa2741b7b2106c differ
diff --git a/tests/fuzz/testdata/slow-unit-6bd643eec330166e4ada91da2d3f284268481085 b/tests/fuzz/testdata/slow-unit-6bd643eec330166e4ada91da2d3f284268481085
new file mode 100644
index 0000000000..182bc7fa13
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-6bd643eec330166e4ada91da2d3f284268481085 differ
diff --git a/tests/fuzz/testdata/slow-unit-93c73a43581f205f9aaffd9c17e52b34b17becd0 b/tests/fuzz/testdata/slow-unit-93c73a43581f205f9aaffd9c17e52b34b17becd0
new file mode 100644
index 0000000000..f939c33ab7
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-93c73a43581f205f9aaffd9c17e52b34b17becd0 differ
diff --git a/tests/fuzz/testdata/slow-unit-9ca9cc9929fee1fcbb847a78384effb8b98ea18a b/tests/fuzz/testdata/slow-unit-9ca9cc9929fee1fcbb847a78384effb8b98ea18a
new file mode 100644
index 0000000000..a87de230ff
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-9ca9cc9929fee1fcbb847a78384effb8b98ea18a differ
diff --git a/tests/fuzz/testdata/slow-unit-b8a052f4254802edbe5f569b6ce6e9b6c927e9d6 b/tests/fuzz/testdata/slow-unit-b8a052f4254802edbe5f569b6ce6e9b6c927e9d6
new file mode 100644
index 0000000000..dc3329339e
Binary files /dev/null and b/tests/fuzz/testdata/slow-unit-b8a052f4254802edbe5f569b6ce6e9b6c927e9d6 differ
diff --git a/tests/lib.rs b/tests/lib.rs
new file mode 100644
index 0000000000..badd57455d
--- /dev/null
+++ b/tests/lib.rs
@@ -0,0 +1,57 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+mod fuzz;
+mod misc;
+mod regression;
+mod regression_fuzz;
+mod replace;
+#[cfg(feature = "pattern")]
+mod searcher;
+mod suite_bytes;
+mod suite_bytes_set;
+mod suite_string;
+mod suite_string_set;
+
+const BLACKLIST: &[&str] = &[
+    // Nothing to blacklist yet!
+];
+
+fn suite() -> anyhow::Result<regex_test::RegexTests> {
+    let _ = env_logger::try_init();
+
+    let mut tests = regex_test::RegexTests::new();
+    macro_rules! load {
+        ($name:expr) => {{
+            const DATA: &[u8] =
+                include_bytes!(concat!("../testdata/", $name, ".toml"));
+            tests.load_slice($name, DATA)?;
+        }};
+    }
+
+    load!("anchored");
+    load!("bytes");
+    load!("crazy");
+    load!("crlf");
+    load!("earliest");
+    load!("empty");
+    load!("expensive");
+    load!("flags");
+    load!("iter");
+    load!("leftmost-all");
+    load!("line-terminator");
+    load!("misc");
+    load!("multiline");
+    load!("no-unicode");
+    load!("overlapping");
+    load!("regression");
+    load!("set");
+    load!("substring");
+    load!("unicode");
+    load!("utf8");
+    load!("word-boundary");
+    load!("fowler/basic");
+    load!("fowler/nullsubexpr");
+    load!("fowler/repetition");
+
+    Ok(tests)
+}
diff --git a/tests/macros.rs b/tests/macros.rs
deleted file mode 100644
index e70e9489fd..0000000000
--- a/tests/macros.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-// Convenience macros.
-
-macro_rules! findall {
-    ($re:expr, $text:expr) => {{
-        $re.find_iter(text!($text))
-           .map(|m| (m.start(), m.end())).collect::<Vec<_>>()
-    }}
-}
-
-// Macros for automatically producing tests.
-
-macro_rules! ismatch {
-    ($name:ident, $re:expr, $text:expr, $ismatch:expr) => {
-        #[test]
-        fn $name() {
-            let re = regex!($re);
-            assert_eq!($ismatch, re.is_match(text!($text)));
-        }
-    };
-}
-
-macro_rules! mat(
-    ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let expected: Vec<Option<_>> = vec![$($loc)+];
-            let r = regex!($re);
-            let got: Vec<Option<_>> = match r.captures(text) {
-                Some(c) => {
-                    assert!(r.is_match(text));
-                    assert!(r.shortest_match(text).is_some());
-                    r.capture_names()
-                     .enumerate()
-                     .map(|(i, _)| c.get(i).map(|m| (m.start(), m.end())))
-                     .collect()
-                }
-                None => vec![None],
-            };
-            // The test set sometimes leave out capture groups, so truncate
-            // actual capture groups to match test set.
-            let mut sgot = &got[..];
-            if sgot.len() > expected.len() {
-                sgot = &sgot[0..expected.len()]
-            }
-            if expected != sgot {
-                panic!("For RE '{}' against '{:?}', \
-                        expected '{:?}' but got '{:?}'",
-                       $re, text, expected, sgot);
-            }
-        }
-    );
-);
-
-macro_rules! matiter(
-    ($name:ident, $re:expr, $text:expr) => (
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let expected: Vec<(usize, usize)> = vec![];
-            let r = regex!($re);
-            let got: Vec<_> =
-                r.find_iter(text).map(|m| (m.start(), m.end())).collect();
-            if expected != got {
-                panic!("For RE '{}' against '{:?}', \
-                        expected '{:?}' but got '{:?}'",
-                       $re, text, expected, got);
-            }
-            let captures_got: Vec<_> =
-                r.captures_iter(text)
-                 .map(|c| c.get(0).unwrap())
-                 .map(|m| (m.start(), m.end()))
-                 .collect();
-            if captures_got != got {
-                panic!("For RE '{}' against '{:?}', \
-                        got '{:?}' using find_iter but got '{:?}' \
-                        using captures_iter",
-                       $re, text, got, captures_got);
-            }
-        }
-    );
-    ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let expected: Vec<_> = vec![$($loc)+];
-            let r = regex!($re);
-            let got: Vec<_> =
-                r.find_iter(text).map(|m| (m.start(), m.end())).collect();
-            if expected != got {
-                panic!("For RE '{}' against '{:?}', \
-                        expected '{:?}' but got '{:?}'",
-                       $re, text, expected, got);
-            }
-            let captures_got: Vec<_> =
-                r.captures_iter(text)
-                 .map(|c| c.get(0).unwrap())
-                 .map(|m| (m.start(), m.end()))
-                 .collect();
-            if captures_got != got {
-                panic!("For RE '{}' against '{:?}', \
-                        got '{:?}' using find_iter but got '{:?}' \
-                        using captures_iter",
-                       $re, text, got, captures_got);
-            }
-        }
-    );
-);
-
-macro_rules! matset {
-    ($name:ident, $res:expr, $text:expr, $($match_index:expr),*) => {
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let set = regex_set!($res);
-            assert!(set.is_match(text));
-            let expected = vec![$($match_index),*];
-            let matches = set.matches(text);
-            assert!(matches.matched_any());
-            let got: Vec<_> = matches.into_iter().collect();
-            assert_eq!(expected, got);
-        }
-    }
-}
-
-macro_rules! nomatset {
-    ($name:ident, $res:expr, $text:expr) => {
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let set = regex_set!($res);
-            assert!(!set.is_match(text));
-            let matches = set.matches(text);
-            assert!(!matches.matched_any());
-            assert_eq!(0, matches.into_iter().count());
-        }
-    }
-}
-
-macro_rules! split {
-    ($name:ident, $re:expr, $text:expr, $expected:expr) => {
-        #[test]
-        fn $name() {
-            let re = regex!($re);
-            let splitted: Vec<_> = re.split(t!($text)).collect();
-            assert_eq!($expected, &*splitted);
-        }
-    }
-}
-
-macro_rules! splitn {
-    ($name:ident, $re:expr, $text:expr, $limit:expr, $expected:expr) => {
-        #[test]
-        fn $name() {
-            let re = regex!($re);
-            let splitted: Vec<_> = re.splitn(t!($text), $limit).collect();
-            assert_eq!($expected, &*splitted);
-        }
-    }
-}
diff --git a/tests/macros_bytes.rs b/tests/macros_bytes.rs
deleted file mode 100644
index 3d6c8c3ac8..0000000000
--- a/tests/macros_bytes.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Macros for use in writing tests generic over &str/&[u8].
-macro_rules! text { ($text:expr) => { $text.as_bytes() } }
-macro_rules! t { ($re:expr) => { text!($re) } }
-macro_rules! match_text { ($text:expr) => { $text.as_bytes() } }
-macro_rules! use_ { ($($path: tt)*) => { use regex::bytes::$($path)*; } }
-macro_rules! empty_vec { () => { <Vec<&[u8]>>::new() } }
-macro_rules! bytes { ($text:expr) => { $text } }
-
-macro_rules! no_expand {
-    ($text:expr) => {{
-        use regex::bytes::NoExpand;
-        NoExpand(text!($text))
-    }}
-}
-
-macro_rules! show {
-    ($text:expr) => {{
-        use std::ascii::escape_default;
-        let mut s = vec![];
-        for &b in bytes!($text) {
-            s.extend(escape_default(b));
-        }
-        String::from_utf8(s).unwrap()
-    }}
-}
-
-macro_rules! expand {
-    ($name:ident, $re:expr, $text:expr, $expand:expr, $expected:expr) => {
-        #[test]
-        fn $name() {
-            let re = regex!($re);
-            let cap = re.captures(t!($text)).unwrap();
-
-            let mut got = vec![];
-            cap.expand(t!($expand), &mut got);
-            assert_eq!(show!(t!($expected)), show!(&*got));
-        }
-    }
-}
diff --git a/tests/macros_str.rs b/tests/macros_str.rs
deleted file mode 100644
index 7b7eb110c2..0000000000
--- a/tests/macros_str.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Macros for use in writing tests generic over &str/&[u8].
-macro_rules! text { ($text:expr) => { $text } }
-macro_rules! t { ($text:expr) => { text!($text) } }
-macro_rules! match_text { ($text:expr) => { $text.as_str() } }
-macro_rules! use_ { ($($path: tt)*) => { use regex::$($path)*; } }
-macro_rules! empty_vec { () => { <Vec<&str>>::new() } }
-macro_rules! bytes { ($text:expr) => { std::str::from_utf8($text.as_ref()).unwrap() } }
-
-macro_rules! no_expand {
-    ($text:expr) => {{
-        use regex::NoExpand;
-        NoExpand(text!($text))
-    }}
-}
-
-macro_rules! show { ($text:expr) => { $text } }
-
-// N.B. The expansion API for &str and &[u8] APIs differs slightly for now,
-// but they should be unified in 1.0. Then we can move this macro back into
-// tests/api.rs where it is used. ---AG
-macro_rules! expand {
-    ($name:ident, $re:expr, $text:expr, $expand:expr, $expected:expr) => {
-        #[test]
-        fn $name() {
-            let re = regex!($re);
-            let cap = re.captures(t!($text)).unwrap();
-
-            let mut got = String::new();
-            cap.expand(t!($expand), &mut got);
-            assert_eq!(show!(t!($expected)), show!(&*got));
-        }
-    }
-}
-
-#[cfg(feature = "pattern")]
-macro_rules! searcher_expr { ($e:expr) => ($e) }
-#[cfg(not(feature = "pattern"))]
-macro_rules! searcher_expr { ($e:expr) => ({}) }
diff --git a/tests/misc.rs b/tests/misc.rs
index 314811e252..91e7d28980 100644
--- a/tests/misc.rs
+++ b/tests/misc.rs
@@ -1,4 +1,143 @@
-mat!(prefix_literal_match, r"^abc", r"abc", Some((0, 3)));
-mat!(prefix_literal_nomatch, r"^abc", r"zabc", None);
-mat!(one_literal_edge, r"abc", r"xxxxxab", None);
-matiter!(terminates, r"a$", r"a", (0, 1));
+use regex::Regex;
+
+macro_rules! regex {
+    ($pattern:expr) => {
+        regex::Regex::new($pattern).unwrap()
+    };
+}
+
+#[test]
+fn unclosed_group_error() {
+    let err = Regex::new(r"(").unwrap_err();
+    let msg = err.to_string();
+    assert!(msg.contains("unclosed group"), "error message: {:?}", msg);
+}
+
+#[test]
+fn regex_string() {
+    assert_eq!(r"[a-zA-Z0-9]+", regex!(r"[a-zA-Z0-9]+").as_str());
+    assert_eq!(r"[a-zA-Z0-9]+", &format!("{}", regex!(r"[a-zA-Z0-9]+")));
+    assert_eq!(
+        r#"Regex("[a-zA-Z0-9]+")"#,
+        &format!("{:?}", regex!(r"[a-zA-Z0-9]+"))
+    );
+}
+
+#[test]
+fn capture_names() {
+    let re = regex!(r"(.)(?P<a>.)");
+    assert_eq!(3, re.captures_len());
+    assert_eq!((3, Some(3)), re.capture_names().size_hint());
+    assert_eq!(
+        vec![None, None, Some("a")],
+        re.capture_names().collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn capture_index() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures("abc").unwrap();
+    assert_eq!(&cap[0], "abc");
+    assert_eq!(&cap[1], "abc");
+    assert_eq!(&cap["name"], "abc");
+}
+
+#[test]
+#[should_panic]
+fn capture_index_panic_usize() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures("abc").unwrap();
+    let _ = cap[2];
+}
+
+#[test]
+#[should_panic]
+fn capture_index_panic_name() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures("abc").unwrap();
+    let _ = cap["bad name"];
+}
+
+#[test]
+fn capture_index_lifetime() {
+    // This is a test of whether the types on `caps["..."]` are general
+    // enough. If not, this will fail to typecheck.
+    fn inner(s: &str) -> usize {
+        let re = regex!(r"(?P<number>[0-9]+)");
+        let caps = re.captures(s).unwrap();
+        caps["number"].len()
+    }
+    assert_eq!(3, inner("123"));
+}
+
+#[test]
+fn capture_misc() {
+    let re = regex!(r"(.)(?P<a>a)?(.)(?P<b>.)");
+    let cap = re.captures("abc").unwrap();
+
+    assert_eq!(5, cap.len());
+
+    assert_eq!((0, 3), {
+        let m = cap.get(0).unwrap();
+        (m.start(), m.end())
+    });
+    assert_eq!(None, cap.get(2));
+    assert_eq!((2, 3), {
+        let m = cap.get(4).unwrap();
+        (m.start(), m.end())
+    });
+
+    assert_eq!("abc", cap.get(0).unwrap().as_str());
+    assert_eq!(None, cap.get(2));
+    assert_eq!("c", cap.get(4).unwrap().as_str());
+
+    assert_eq!(None, cap.name("a"));
+    assert_eq!("c", cap.name("b").unwrap().as_str());
+}
+
+#[test]
+fn sub_capture_matches() {
+    let re = regex!(r"([a-z])(([a-z])|([0-9]))");
+    let cap = re.captures("a5").unwrap();
+    let subs: Vec<_> = cap.iter().collect();
+
+    assert_eq!(5, subs.len());
+    assert!(subs[0].is_some());
+    assert!(subs[1].is_some());
+    assert!(subs[2].is_some());
+    assert!(subs[3].is_none());
+    assert!(subs[4].is_some());
+
+    assert_eq!("a5", subs[0].unwrap().as_str());
+    assert_eq!("a", subs[1].unwrap().as_str());
+    assert_eq!("5", subs[2].unwrap().as_str());
+    assert_eq!("5", subs[4].unwrap().as_str());
+}
+
+// Test that the DFA can handle pathological cases. (This should result in the
+// DFA's cache being flushed too frequently, which should cause it to quit and
+// fall back to the NFA algorithm.)
+#[test]
+fn dfa_handles_pathological_case() {
+    fn ones_and_zeroes(count: usize) -> String {
+        let mut s = String::new();
+        for i in 0..count {
+            if i % 3 == 0 {
+                s.push('1');
+            } else {
+                s.push('0');
+            }
+        }
+        s
+    }
+
+    let re = regex!(r"[01]*1[01]{20}$");
+    let text = {
+        let mut pieces = ones_and_zeroes(100_000);
+        pieces.push('1');
+        pieces.push_str(&ones_and_zeroes(20));
+        pieces
+    };
+    assert!(re.is_match(&text));
+}
diff --git a/tests/multiline.rs b/tests/multiline.rs
deleted file mode 100644
index 62ee47b62b..0000000000
--- a/tests/multiline.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-matiter!(
-    match_multi_1,
-    r"(?m)^[a-z]+$",
-    "abc\ndef\nxyz",
-    (0, 3),
-    (4, 7),
-    (8, 11)
-);
-matiter!(match_multi_2, r"(?m)^$", "abc\ndef\nxyz");
-matiter!(match_multi_3, r"(?m)^", "abc\ndef\nxyz", (0, 0), (4, 4), (8, 8));
-matiter!(match_multi_4, r"(?m)$", "abc\ndef\nxyz", (3, 3), (7, 7), (11, 11));
-matiter!(
-    match_multi_5,
-    r"(?m)^[a-z]",
-    "abc\ndef\nxyz",
-    (0, 1),
-    (4, 5),
-    (8, 9)
-);
-matiter!(match_multi_6, r"(?m)[a-z]^", "abc\ndef\nxyz");
-matiter!(
-    match_multi_7,
-    r"(?m)[a-z]$",
-    "abc\ndef\nxyz",
-    (2, 3),
-    (6, 7),
-    (10, 11)
-);
-matiter!(match_multi_8, r"(?m)$[a-z]", "abc\ndef\nxyz");
-matiter!(match_multi_9, r"(?m)^$", "", (0, 0));
-
-matiter!(
-    match_multi_rep_1,
-    r"(?m)(?:^$)*",
-    "a\nb\nc",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4),
-    (5, 5)
-);
-matiter!(
-    match_multi_rep_2,
-    r"(?m)(?:^|a)+",
-    "a\naaa\n",
-    (0, 0),
-    (2, 2),
-    (3, 5),
-    (6, 6)
-);
-matiter!(
-    match_multi_rep_3,
-    r"(?m)(?:^|a)*",
-    "a\naaa\n",
-    (0, 1),
-    (2, 5),
-    (6, 6)
-);
-matiter!(
-    match_multi_rep_4,
-    r"(?m)(?:^[a-z])+",
-    "abc\ndef\nxyz",
-    (0, 1),
-    (4, 5),
-    (8, 9)
-);
-matiter!(
-    match_multi_rep_5,
-    r"(?m)(?:^[a-z]{3}\n?)+",
-    "abc\ndef\nxyz",
-    (0, 11)
-);
-matiter!(
-    match_multi_rep_6,
-    r"(?m)(?:^[a-z]{3}\n?)*",
-    "abc\ndef\nxyz",
-    (0, 11)
-);
-matiter!(
-    match_multi_rep_7,
-    r"(?m)(?:\n?[a-z]{3}$)+",
-    "abc\ndef\nxyz",
-    (0, 11)
-);
-matiter!(
-    match_multi_rep_8,
-    r"(?m)(?:\n?[a-z]{3}$)*",
-    "abc\ndef\nxyz",
-    (0, 11)
-);
-matiter!(
-    match_multi_rep_9,
-    r"(?m)^*",
-    "\naa\n",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4)
-);
-matiter!(match_multi_rep_10, r"(?m)^+", "\naa\n", (0, 0), (1, 1), (4, 4));
-matiter!(
-    match_multi_rep_11,
-    r"(?m)$*",
-    "\naa\n",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4)
-);
-matiter!(match_multi_rep_12, r"(?m)$+", "\naa\n", (0, 0), (3, 3), (4, 4));
-matiter!(match_multi_rep_13, r"(?m)(?:$\n)+", "\n\naaa\n\n", (0, 2), (5, 7));
-matiter!(
-    match_multi_rep_14,
-    r"(?m)(?:$\n)*",
-    "\n\naaa\n\n",
-    (0, 2),
-    (3, 3),
-    (4, 4),
-    (5, 7)
-);
-matiter!(match_multi_rep_15, r"(?m)(?:$\n^)+", "\n\naaa\n\n", (0, 2), (5, 7));
-matiter!(
-    match_multi_rep_16,
-    r"(?m)(?:^|$)+",
-    "\n\naaa\n\n",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (5, 5),
-    (6, 6),
-    (7, 7)
-);
-matiter!(
-    match_multi_rep_17,
-    r"(?m)(?:$\n)*",
-    "\n\naaa\n\n",
-    (0, 2),
-    (3, 3),
-    (4, 4),
-    (5, 7)
-);
diff --git a/tests/noparse.rs b/tests/noparse.rs
deleted file mode 100644
index 8ded1dce7b..0000000000
--- a/tests/noparse.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-macro_rules! noparse(
-    ($name:ident, $re:expr) => (
-        #[test]
-        fn $name() {
-            let re = $re;
-            match regex_new!(re) {
-                Err(_) => {},
-                Ok(_) => panic!("Regex '{}' should cause a parse error.", re),
-            }
-        }
-    );
-);
-
-noparse!(fail_no_repeat_arg, "*");
-noparse!(fail_incomplete_escape, "\\");
-noparse!(fail_class_incomplete, "[A-");
-noparse!(fail_class_not_closed, "[A");
-noparse!(fail_class_no_begin, r"[\A]");
-noparse!(fail_class_no_end, r"[\z]");
-noparse!(fail_class_no_boundary, r"[\b]");
-noparse!(fail_open_paren, "(");
-noparse!(fail_close_paren, ")");
-noparse!(fail_invalid_range, "[a-Z]");
-noparse!(fail_empty_capture_name, "(?P<>a)");
-noparse!(fail_bad_capture_name, "(?P<na-me>)");
-noparse!(fail_bad_flag, "(?a)a");
-noparse!(fail_too_big, "a{10000000}");
-noparse!(fail_counted_no_close, "a{1001");
-noparse!(fail_counted_decreasing, "a{2,1}");
-noparse!(fail_counted_nonnegative, "a{-1,1}");
-noparse!(fail_unfinished_cap, "(?");
-noparse!(fail_unfinished_escape, "\\");
-noparse!(fail_octal_digit, r"\8");
-noparse!(fail_hex_digit, r"\xG0");
-noparse!(fail_hex_short, r"\xF");
-noparse!(fail_hex_long_digits, r"\x{fffg}");
-noparse!(fail_flag_bad, "(?a)");
-noparse!(fail_flag_empty, "(?)");
-noparse!(fail_double_neg, "(?-i-i)");
-noparse!(fail_neg_empty, "(?i-)");
-noparse!(fail_dupe_named, "(?P<a>.)(?P<a>.)");
-noparse!(fail_range_end_no_class, "[a-[:lower:]]");
-noparse!(fail_range_end_no_begin, r"[a-\A]");
-noparse!(fail_range_end_no_end, r"[a-\z]");
-noparse!(fail_range_end_no_boundary, r"[a-\b]");
diff --git a/tests/regression.rs b/tests/regression.rs
index 291062a77d..a5867016b2 100644
--- a/tests/regression.rs
+++ b/tests/regression.rs
@@ -1,235 +1,67 @@
+use regex::Regex;
+
+macro_rules! regex {
+    ($pattern:expr) => {
+        regex::Regex::new($pattern).unwrap()
+    };
+}
+
 // See: https://github.com/rust-lang/regex/issues/48
 #[test]
 fn invalid_regexes_no_crash() {
-    assert!(regex_new!("(*)").is_err());
-    assert!(regex_new!("(?:?)").is_err());
-    assert!(regex_new!("(?)").is_err());
-    assert!(regex_new!("*").is_err());
+    assert!(Regex::new("(*)").is_err());
+    assert!(Regex::new("(?:?)").is_err());
+    assert!(Regex::new("(?)").is_err());
+    assert!(Regex::new("*").is_err());
 }
 
 // See: https://github.com/rust-lang/regex/issues/98
 #[test]
 fn regression_many_repeat_stack_overflow() {
     let re = regex!("^.{1,2500}");
-    assert_eq!(vec![(0, 1)], findall!(re, "a"));
+    assert_eq!(
+        vec![0..1],
+        re.find_iter("a").map(|m| m.range()).collect::<Vec<_>>()
+    );
 }
 
 // See: https://github.com/rust-lang/regex/issues/555
 #[test]
 fn regression_invalid_repetition_expr() {
-    assert!(regex_new!("(?m){1,1}").is_err());
+    assert!(Regex::new("(?m){1,1}").is_err());
 }
 
 // See: https://github.com/rust-lang/regex/issues/527
 #[test]
 fn regression_invalid_flags_expression() {
-    assert!(regex_new!("(((?x)))").is_ok());
+    assert!(Regex::new("(((?x)))").is_ok());
 }
 
-// See: https://github.com/rust-lang/regex/issues/75
-mat!(regression_unsorted_binary_search_1, r"(?i-u)[a_]+", "A_", Some((0, 2)));
-mat!(regression_unsorted_binary_search_2, r"(?i-u)[A_]+", "a_", Some((0, 2)));
-
-// See: https://github.com/rust-lang/regex/issues/99
-#[cfg(feature = "unicode-case")]
-mat!(regression_negated_char_class_1, r"(?i)[^x]", "x", None);
-#[cfg(feature = "unicode-case")]
-mat!(regression_negated_char_class_2, r"(?i)[^x]", "X", None);
-
-// See: https://github.com/rust-lang/regex/issues/101
-mat!(regression_ascii_word_underscore, r"[[:word:]]", "_", Some((0, 1)));
-
 // See: https://github.com/rust-lang/regex/issues/129
 #[test]
 fn regression_captures_rep() {
     let re = regex!(r"([a-f]){2}(?P<foo>[x-z])");
-    let caps = re.captures(text!("abx")).unwrap();
-    assert_eq!(match_text!(caps.name("foo").unwrap()), text!("x"));
+    let caps = re.captures("abx").unwrap();
+    assert_eq!(&caps["foo"], "x");
 }
 
-// See: https://github.com/rust-lang/regex/issues/153
-mat!(regression_alt_in_alt1, r"ab?|$", "az", Some((0, 1)));
-mat!(regression_alt_in_alt2, r"^(.*?)(\n|\r\n?|$)", "ab\rcd", Some((0, 3)));
-
-// See: https://github.com/rust-lang/regex/issues/169
-mat!(regression_leftmost_first_prefix, r"z*azb", "azb", Some((0, 3)));
-
-// See: https://github.com/rust-lang/regex/issues/76
-#[cfg(all(feature = "unicode-case", feature = "unicode-gencat"))]
-mat!(uni_case_lower_nocase_flag, r"(?i)\p{Ll}+", "ΛΘΓΔα", Some((0, 10)));
-
-// See: https://github.com/rust-lang/regex/issues/191
-mat!(many_alternates, r"1|2|3|4|5|6|7|8|9|10|int", "int", Some((0, 3)));
-
-// burntsushi was bad and didn't create an issue for this bug.
-mat!(anchored_prefix1, r"^a[[:^space:]]", "a ", None);
-mat!(anchored_prefix2, r"^a[[:^space:]]", "foo boo a ", None);
-mat!(anchored_prefix3, r"^-[a-z]", "r-f", None);
-
-// See: https://github.com/rust-lang/regex/issues/204
-#[cfg(feature = "unicode-perl")]
-split!(
-    split_on_word_boundary,
-    r"\b",
-    r"Should this (work?)",
-    &[
-        t!(""),
-        t!("Should"),
-        t!(" "),
-        t!("this"),
-        t!(" ("),
-        t!("work"),
-        t!("?)")
-    ]
-);
-#[cfg(feature = "unicode-perl")]
-matiter!(
-    word_boundary_dfa,
-    r"\b",
-    "a b c",
-    (0, 0),
-    (1, 1),
-    (2, 2),
-    (3, 3),
-    (4, 4),
-    (5, 5)
-);
-
-// See: https://github.com/rust-lang/regex/issues/268
-matiter!(partial_anchor, r"^a|b", "ba", (0, 1));
-
-// See: https://github.com/rust-lang/regex/issues/280
-ismatch!(partial_anchor_alternate_begin, r"^a|z", "yyyyya", false);
-ismatch!(partial_anchor_alternate_end, r"a$|z", "ayyyyy", false);
-
-// See: https://github.com/rust-lang/regex/issues/289
-mat!(lits_unambiguous1, r"(ABC|CDA|BC)X", "CDAX", Some((0, 4)));
-
-// See: https://github.com/rust-lang/regex/issues/291
-mat!(
-    lits_unambiguous2,
-    r"((IMG|CAM|MG|MB2)_|(DSCN|CIMG))(?P<n>[0-9]+)$",
-    "CIMG2341",
-    Some((0, 8)),
-    Some((0, 4)),
-    None,
-    Some((0, 4)),
-    Some((4, 8))
-);
-
-// See: https://github.com/rust-lang/regex/issues/271
-mat!(endl_or_wb, r"(?m:$)|(?-u:\b)", "\u{6084e}", Some((4, 4)));
-mat!(zero_or_end, r"(?i-u:\x00)|$", "\u{e682f}", Some((4, 4)));
-mat!(y_or_endl, r"(?i-u:y)|(?m:$)", "\u{b4331}", Some((4, 4)));
-#[cfg(feature = "unicode-perl")]
-mat!(wb_start_x, r"(?u:\b)^(?-u:X)", "X", Some((0, 1)));
-
-// See: https://github.com/rust-lang/regex/issues/321
-ismatch!(strange_anchor_non_complete_prefix, r"a^{2}", "", false);
-ismatch!(strange_anchor_non_complete_suffix, r"${2}a", "", false);
-
-// See: https://github.com/BurntSushi/ripgrep/issues/1203
-ismatch!(reverse_suffix1, r"[0-4][0-4][0-4]000", "153.230000", true);
-ismatch!(reverse_suffix2, r"[0-9][0-9][0-9]000", "153.230000\n", true);
-matiter!(reverse_suffix3, r"[0-9][0-9][0-9]000", "153.230000\n", (4, 10));
-
-// See: https://github.com/rust-lang/regex/issues/334
-// See: https://github.com/rust-lang/regex/issues/557
-mat!(
-    captures_after_dfa_premature_end1,
-    r"a(b*(X|$))?",
-    "abcbX",
-    Some((0, 1)),
-    None,
-    None
-);
-mat!(
-    captures_after_dfa_premature_end2,
-    r"a(bc*(X|$))?",
-    "abcbX",
-    Some((0, 1)),
-    None,
-    None
-);
-mat!(captures_after_dfa_premature_end3, r"(aa$)?", "aaz", Some((0, 0)));
-
-// See: https://github.com/rust-lang/regex/issues/437
-ismatch!(
-    literal_panic,
-    r"typename type\-parameter\-[0-9]+\-[0-9]+::.+",
-    "test",
-    false
-);
-
-// See: https://github.com/rust-lang/regex/issues/533
-ismatch!(
-    blank_matches_nothing_between_space_and_tab,
-    r"[[:blank:]]",
-    "\u{a}\u{b}\u{c}\u{d}\u{e}\u{f}\
-     \u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\
-     \u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}",
-    false
-);
-
-ismatch!(
-    inverted_blank_matches_everything_between_space_and_tab,
-    r"^[[:^blank:]]+$",
-    "\u{a}\u{b}\u{c}\u{d}\u{e}\u{f}\
-     \u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\
-     \u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}",
-    true
-);
-
-// Tests that our Aho-Corasick optimization works correctly. It only
-// kicks in when we have >32 literals. By "works correctly," we mean that
-// leftmost-first match semantics are properly respected. That is, samwise
-// should match, not sam.
-mat!(
-    ahocorasick1,
-    "samwise|sam|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|\
-     A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z",
-    "samwise",
-    Some((0, 7))
-);
-
 // See: https://github.com/BurntSushi/ripgrep/issues/1247
-#[test]
 #[cfg(feature = "unicode-perl")]
+#[test]
 fn regression_nfa_stops1() {
-    let re = ::regex::bytes::Regex::new(r"\bs(?:[ab])").unwrap();
+    let re = regex::bytes::Regex::new(r"\bs(?:[ab])").unwrap();
     assert_eq!(0, re.find_iter(b"s\xE4").count());
 }
 
-// See: https://github.com/rust-lang/regex/issues/640
-#[cfg(feature = "unicode-case")]
-matiter!(
-    flags_are_unset,
-    r"((?i)foo)|Bar",
-    "foo Foo bar Bar",
-    (0, 3),
-    (4, 7),
-    (12, 15)
-);
-
-// See: https://github.com/rust-lang/regex/issues/659
-//
-// Note that 'Ј' is not 'j', but cyrillic Je
-// https://en.wikipedia.org/wiki/Je_(Cyrillic)
-ismatch!(empty_group_match, r"()Ј01", "zЈ01", true);
-matiter!(empty_group_find, r"()Ј01", "zЈ01", (1, 5));
-
-// See: https://github.com/rust-lang/regex/issues/862
-mat!(non_greedy_question_literal, r"ab??", "ab", Some((0, 1)));
-
 // See: https://github.com/rust-lang/regex/issues/981
 #[cfg(feature = "unicode")]
 #[test]
 fn regression_bad_word_boundary() {
-    let re = regex_new!(r#"(?i:(?:\b|_)win(?:32|64|dows)?(?:\b|_))"#).unwrap();
+    let re = regex!(r#"(?i:(?:\b|_)win(?:32|64|dows)?(?:\b|_))"#);
     let hay = "ubi-Darwin-x86_64.tar.gz";
-    assert!(!re.is_match(text!(hay)));
+    assert!(!re.is_match(hay));
     let hay = "ubi-Windows-x86_64.zip";
-    assert!(re.is_match(text!(hay)));
+    assert!(re.is_match(hay));
 }
 
 // See: https://github.com/rust-lang/regex/issues/982
@@ -237,18 +69,17 @@ fn regression_bad_word_boundary() {
 #[test]
 fn regression_unicode_perl_not_enabled() {
     let pat = r"(\d+\s?(years|year|y))?\s?(\d+\s?(months|month|m))?\s?(\d+\s?(weeks|week|w))?\s?(\d+\s?(days|day|d))?\s?(\d+\s?(hours|hour|h))?";
-    let re = regex_new!(pat);
-    assert!(re.is_ok());
+    assert!(Regex::new(pat).is_ok());
 }
 
 // See: https://github.com/rust-lang/regex/issues/995
 #[test]
 fn regression_big_regex_overflow() {
     let pat = r" {2147483516}{2147483416}{5}";
-    let re = regex_new!(pat);
-    assert!(re.is_err());
+    assert!(Regex::new(pat).is_err());
 }
 
+// See: https://github.com/rust-lang/regex/issues/999
 #[test]
 fn regression_complete_literals_suffix_incorrect() {
     let needles = vec![
@@ -259,5 +90,5 @@ fn regression_complete_literals_suffix_incorrect() {
     let pattern = needles.join("|");
     let re = regex!(&pattern);
     let hay = "FUBAR";
-    assert_eq!(0, re.find_iter(text!(hay)).count());
+    assert_eq!(0, re.find_iter(hay).count());
 }
diff --git a/tests/regression_fuzz.rs b/tests/regression_fuzz.rs
index 5f49530a72..f90ad4cb20 100644
--- a/tests/regression_fuzz.rs
+++ b/tests/regression_fuzz.rs
@@ -2,6 +2,14 @@
 // can take quite a long time. Some of them take long enough that it's not
 // practical to run them in debug mode. :-/
 
+use regex::Regex;
+
+macro_rules! regex {
+    ($pattern:expr) => {
+        regex::Regex::new($pattern).unwrap()
+    };
+}
+
 // See: https://oss-fuzz.com/testcase-detail/5673225499181056
 //
 // Ignored by default since it takes too long in debug mode (almost a minute).
@@ -14,8 +22,9 @@ fn fuzz1() {
 // See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=26505
 // See: https://github.com/rust-lang/regex/issues/722
 #[test]
+#[cfg(feature = "unicode")]
 fn empty_any_errors_no_panic() {
-    assert!(regex_new!(r"\P{any}").is_err());
+    assert!(Regex::new(r"\P{any}").is_ok());
 }
 
 // This tests that a very large regex errors during compilation instead of
@@ -27,7 +36,7 @@ fn empty_any_errors_no_panic() {
 #[test]
 fn big_regex_fails_to_compile() {
     let pat = "[\u{0}\u{e}\u{2}\\w~~>[l\t\u{0}]p?<]{971158}";
-    assert!(regex_new!(pat).is_err());
+    assert!(Regex::new(pat).is_err());
 }
 
 // This was caught while on master but before a release went out(!).
@@ -36,5 +45,17 @@ fn big_regex_fails_to_compile() {
 #[test]
 fn todo() {
     let pat = "(?:z|xx)@|xx";
-    assert!(regex_new!(pat).is_ok());
+    assert!(Regex::new(pat).is_ok());
+}
+
+// This was caused by the fuzzer, and then minimized by hand.
+//
+// This was caused by a bug in DFA determinization that mishandled NFA fail
+// states.
+#[test]
+fn fail_branch_prevents_match() {
+    let pat = r".*[a&&b]A|B";
+    let hay = "B";
+    let re = Regex::new(pat).unwrap();
+    assert!(re.is_match(hay));
 }
diff --git a/tests/replace.rs b/tests/replace.rs
index f23c575515..08b80a241f 100644
--- a/tests/replace.rs
+++ b/tests/replace.rs
@@ -3,39 +3,32 @@ macro_rules! replace(
      $search:expr, $replace:expr, $result:expr) => (
         #[test]
         fn $name() {
-            let re = regex!($re);
-            assert_eq!(re.$which(text!($search), $replace), text!($result));
+            let re = regex::Regex::new($re).unwrap();
+            assert_eq!(re.$which($search, $replace), $result);
         }
     );
 );
 
-replace!(first, replace, r"[0-9]", "age: 26", t!("Z"), "age: Z6");
-replace!(plus, replace, r"[0-9]+", "age: 26", t!("Z"), "age: Z");
-replace!(all, replace_all, r"[0-9]", "age: 26", t!("Z"), "age: ZZ");
-replace!(
-    groups,
-    replace,
-    r"([^ ]+)[ ]+([^ ]+)",
-    "w1 w2",
-    t!("$2 $1"),
-    "w2 w1"
-);
+replace!(first, replace, r"[0-9]", "age: 26", "Z", "age: Z6");
+replace!(plus, replace, r"[0-9]+", "age: 26", "Z", "age: Z");
+replace!(all, replace_all, r"[0-9]", "age: 26", "Z", "age: ZZ");
+replace!(groups, replace, r"([^ ]+)[ ]+([^ ]+)", "w1 w2", "$2 $1", "w2 w1");
 replace!(
     double_dollar,
     replace,
     r"([^ ]+)[ ]+([^ ]+)",
     "w1 w2",
-    t!("$2 $$1"),
+    "$2 $$1",
     "w2 $1"
 );
 // replace!(adjacent_index, replace,
-// r"([^aeiouy])ies$", "skies", t!("$1y"), "sky");
+// r"([^aeiouy])ies$", "skies", "$1y", "sky");
 replace!(
     named,
     replace_all,
     r"(?P<first>[^ ]+)[ ]+(?P<last>[^ ]+)(?P<space>[ ]*)",
     "w1 w2 w3 w4",
-    t!("$last $first$space"),
+    "$last $first$space",
     "w2 w1 w4 w3"
 );
 replace!(
@@ -43,17 +36,17 @@ replace!(
     replace_all,
     "^[ \t]+|[ \t]+$",
     " \t  trim me\t   \t",
-    t!(""),
+    "",
     "trim me"
 );
-replace!(number_hypen, replace, r"(.)(.)", "ab", t!("$1-$2"), "a-b");
-// replace!(number_underscore, replace, r"(.)(.)", "ab", t!("$1_$2"), "a_b");
+replace!(number_hypen, replace, r"(.)(.)", "ab", "$1-$2", "a-b");
+// replace!(number_underscore, replace, r"(.)(.)", "ab", "$1_$2", "a_b");
 replace!(
     simple_expand,
     replace_all,
     r"([a-z]) ([a-z])",
     "a b",
-    t!("$2 $1"),
+    "$2 $1",
     "b a"
 );
 replace!(
@@ -61,7 +54,7 @@ replace!(
     replace_all,
     r"([a-z]+) ([a-z]+)",
     "a b",
-    t!("$$1"),
+    "$$1",
     "$1"
 );
 replace!(
@@ -69,7 +62,7 @@ replace!(
     replace_all,
     r"([a-z]+) ([a-z]+)",
     "a b",
-    t!("$2 $$c $1"),
+    "$2 $$c $1",
     "b $c a"
 );
 replace!(
@@ -77,7 +70,7 @@ replace!(
     replace,
     r"([^ ]+)[ ]+([^ ]+)",
     "w1 w2",
-    no_expand!("$2 $1"),
+    regex::NoExpand("$2 $1"),
     "$2 $1"
 );
 replace!(
@@ -85,18 +78,15 @@ replace!(
     replace,
     r"([^ ]+)[ ]+([^ ]+)",
     "w1 w2",
-    no_expand!("$$1"),
+    regex::NoExpand("$$1"),
     "$$1"
 );
-use_!(Captures);
 replace!(
     closure_returning_reference,
     replace,
     r"([0-9]+)",
     "age: 26",
-    |captures: &Captures<'_>| {
-        match_text!(captures.get(1).unwrap())[0..1].to_owned()
-    },
+    |captures: &regex::Captures<'_>| { captures[1][0..1].to_owned() },
     "age: 2"
 );
 replace!(
@@ -104,7 +94,7 @@ replace!(
     replace,
     r"[0-9]+",
     "age: 26",
-    |_captures: &Captures<'_>| t!("Z").to_owned(),
+    |_captures: &regex::Captures<'_>| "Z".to_owned(),
     "age: Z"
 );
 
@@ -114,12 +104,12 @@ replace!(
     replace_all,
     r"foo",
     "foobar",
-    t!(""),
+    "",
     "bar"
 );
 
 // See https://github.com/rust-lang/regex/issues/393
-replace!(single_empty_match, replace, r"^", "bar", t!("foo"), "foobar");
+replace!(single_empty_match, replace, r"^", "bar", "foo", "foobar");
 
 // See https://github.com/rust-lang/regex/issues/399
 replace!(
@@ -127,7 +117,7 @@ replace!(
     replace_all,
     r"(.)",
     "b",
-    t!("${1}a $1a"),
+    "${1}a $1a",
     "ba "
 );
 
@@ -136,7 +126,7 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!("Z".to_string()),
+    "Z".to_string(),
     "age: Z6"
 );
 replace!(
@@ -144,7 +134,7 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!(&"Z".to_string()),
+    &"Z".to_string(),
     "age: Z6"
 );
 replace!(
@@ -152,7 +142,7 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!(std::borrow::Cow::<'_, str>::Borrowed("Z")),
+    std::borrow::Cow::<'_, str>::Borrowed("Z"),
     "age: Z6"
 );
 replace!(
@@ -160,7 +150,7 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!(&std::borrow::Cow::<'_, str>::Borrowed("Z")),
+    &std::borrow::Cow::<'_, str>::Borrowed("Z"),
     "age: Z6"
 );
 replace!(
@@ -168,7 +158,7 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!(std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
+    std::borrow::Cow::<'_, str>::Owned("Z".to_string()),
     "age: Z6"
 );
 replace!(
@@ -176,73 +166,18 @@ replace!(
     replace,
     r"[0-9]",
     "age: 26",
-    t!(&std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
-    "age: Z6"
-);
-
-replace!(
-    impl_vec_u8,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(vec![b'Z']),
-    "age: Z6"
-);
-replace!(
-    impl_vec_u8_ref,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(&vec![b'Z']),
-    "age: Z6"
-);
-replace!(
-    impl_cow_slice_borrowed,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
-    "age: Z6"
-);
-replace!(
-    impl_cow_slice_borrowed_ref,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(&std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
-    "age: Z6"
-);
-replace!(
-    impl_cow_slice_owned,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
-    "age: Z6"
-);
-replace!(
-    impl_cow_slice_owned_ref,
-    replace,
-    r"[0-9]",
-    "age: 26",
-    bytes!(&std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
+    &std::borrow::Cow::<'_, str>::Owned("Z".to_string()),
     "age: Z6"
 );
 
 #[test]
 fn replacen_no_captures() {
-    let re = regex!(r"[0-9]");
-    assert_eq!(
-        re.replacen(text!("age: 1234"), 2, t!("Z")),
-        text!("age: ZZ34")
-    );
+    let re = regex::Regex::new(r"[0-9]").unwrap();
+    assert_eq!(re.replacen("age: 1234", 2, "Z"), "age: ZZ34");
 }
 
 #[test]
 fn replacen_with_captures() {
-    let re = regex!(r"([0-9])");
-    assert_eq!(
-        re.replacen(text!("age: 1234"), 2, t!("${1}Z")),
-        text!("age: 1Z2Z34")
-    );
+    let re = regex::Regex::new(r"([0-9])").unwrap();
+    assert_eq!(re.replacen("age: 1234", 2, "${1}Z"), "age: 1Z2Z34");
 }
diff --git a/tests/searcher.rs b/tests/searcher.rs
index 3779f54c31..f6dae13105 100644
--- a/tests/searcher.rs
+++ b/tests/searcher.rs
@@ -12,20 +12,18 @@ macro_rules! searcher {
         #[test]
         #[allow(unused_imports)]
         fn $name() {
-            searcher_expr! {{
-                use std::str::pattern::{Pattern, Searcher};
-                use std::str::pattern::SearchStep::{Match, Reject, Done};
-                let re = regex!($re);
-                let mut se = re.into_searcher($haystack);
-                let mut got_steps = vec![];
-                loop {
-                    match se.next() {
-                        Done => break,
-                        step => { got_steps.push(step); }
-                    }
+            use std::str::pattern::{Pattern, Searcher};
+            use std::str::pattern::SearchStep::{Match, Reject, Done};
+            let re = regex::Regex::new($re).unwrap();
+            let mut se = re.into_searcher($haystack);
+            let mut got_steps = vec![];
+            loop {
+                match se.next() {
+                    Done => break,
+                    step => { got_steps.push(step); }
                 }
-                assert_eq!(got_steps, $expect_steps);
-            }}
+            }
+            assert_eq!(got_steps, $expect_steps);
         }
     );
 }
diff --git a/tests/set.rs b/tests/set.rs
deleted file mode 100644
index d1144d6623..0000000000
--- a/tests/set.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-matset!(set1, &["a", "a"], "a", 0, 1);
-matset!(set2, &["a", "a"], "ba", 0, 1);
-matset!(set3, &["a", "b"], "a", 0);
-matset!(set4, &["a", "b"], "b", 1);
-matset!(set5, &["a|b", "b|a"], "b", 0, 1);
-matset!(set6, &["foo", "oo"], "foo", 0, 1);
-matset!(set7, &["^foo", "bar$"], "foo", 0);
-matset!(set8, &["^foo", "bar$"], "foo bar", 0, 1);
-matset!(set9, &["^foo", "bar$"], "bar", 1);
-matset!(set10, &[r"[a-z]+$", "foo"], "01234 foo", 0, 1);
-matset!(set11, &[r"[a-z]+$", "foo"], "foo 01234", 1);
-matset!(set12, &[r".*?", "a"], "zzzzzza", 0, 1);
-matset!(set13, &[r".*", "a"], "zzzzzza", 0, 1);
-matset!(set14, &[r".*", "a"], "zzzzzz", 0);
-matset!(set15, &[r"(?-u)\ba\b"], "hello a bye", 0);
-matset!(set16, &["a"], "a", 0);
-matset!(set17, &[".*a"], "a", 0);
-matset!(set18, &["a", "β"], "β", 1);
-
-// regexes that match the empty string
-matset!(setempty1, &["", "a"], "abc", 0, 1);
-matset!(setempty2, &["", "b"], "abc", 0, 1);
-matset!(setempty3, &["", "z"], "abc", 0);
-matset!(setempty4, &["a", ""], "abc", 0, 1);
-matset!(setempty5, &["b", ""], "abc", 0, 1);
-matset!(setempty6, &["z", ""], "abc", 1);
-matset!(setempty7, &["b", "(?:)"], "abc", 0, 1);
-matset!(setempty8, &["(?:)", "b"], "abc", 0, 1);
-matset!(setempty9, &["c(?:)", "b"], "abc", 0, 1);
-
-nomatset!(nset1, &["a", "a"], "b");
-nomatset!(nset2, &["^foo", "bar$"], "bar foo");
-nomatset!(
-    nset3,
-    {
-        let xs: &[&str] = &[];
-        xs
-    },
-    "a"
-);
-nomatset!(nset4, &[r"^rooted$", r"\.log$"], "notrooted");
-
-// See: https://github.com/rust-lang/regex/issues/187
-#[test]
-fn regression_subsequent_matches() {
-    let set = regex_set!(&["ab", "b"]);
-    let text = text!("ba");
-    assert!(set.matches(text).matched(1));
-    assert!(set.matches(text).matched(1));
-}
-
-#[test]
-fn get_set_patterns() {
-    let set = regex_set!(&["a", "b"]);
-    assert_eq!(vec!["a", "b"], set.patterns());
-}
-
-#[test]
-fn len_and_empty() {
-    let empty = regex_set!(&[""; 0]);
-    assert_eq!(empty.len(), 0);
-    assert!(empty.is_empty());
-
-    let not_empty = regex_set!(&["ab", "b"]);
-    assert_eq!(not_empty.len(), 2);
-    assert!(!not_empty.is_empty());
-}
-
-#[test]
-fn default_set_is_empty() {
-    let set: regex::bytes::RegexSet = Default::default();
-    assert_eq!(set.len(), 0);
-    assert!(set.is_empty());
-}
diff --git a/tests/shortest_match.rs b/tests/shortest_match.rs
deleted file mode 100644
index f8b4fed156..0000000000
--- a/tests/shortest_match.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-macro_rules! shortmat {
-    ($name:ident, $re:expr, $text:expr, $shortest_match:expr) => {
-        #[test]
-        fn $name() {
-            let text = text!($text);
-            let re = regex!($re);
-            assert_eq!($shortest_match, re.shortest_match(text));
-        }
-    };
-}
-
-shortmat!(t01, r"a+", r"aa", Some(1));
-// Test that the reverse suffix optimization gets it right.
-shortmat!(t02, r".*(?:abcd)+", r"abcdabcd", Some(4));
diff --git a/tests/suffix_reverse.rs b/tests/suffix_reverse.rs
deleted file mode 100644
index 774c9e85f0..0000000000
--- a/tests/suffix_reverse.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-mat!(t01, r".*abcd", r"abcd", Some((0, 4)));
-mat!(t02, r".*(?:abcd)+", r"abcd", Some((0, 4)));
-mat!(t03, r".*(?:abcd)+", r"abcdabcd", Some((0, 8)));
-mat!(t04, r".*(?:abcd)+", r"abcdxabcd", Some((0, 9)));
-mat!(t05, r".*x(?:abcd)+", r"abcdxabcd", Some((0, 9)));
-mat!(t06, r"[^abcd]*x(?:abcd)+", r"abcdxabcd", Some((4, 9)));
diff --git a/tests/suite_bytes.rs b/tests/suite_bytes.rs
new file mode 100644
index 0000000000..106d998085
--- /dev/null
+++ b/tests/suite_bytes.rs
@@ -0,0 +1,108 @@
+use {
+    anyhow::Result,
+    regex::bytes::{Regex, RegexBuilder},
+    regex_test::{
+        CompiledRegex, Match, RegexTest, Span, TestResult, TestRunner,
+    },
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(test.haystack())),
+        "find" => TestResult::matches(
+            re.find_iter(test.haystack())
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|m| Match {
+                    id: 0,
+                    span: Span { start: m.start(), end: m.end() },
+                }),
+        ),
+        "captures" => {
+            let it = re
+                .captures_iter(test.haystack())
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|caps| testify_captures(&caps));
+            TestResult::captures(it)
+        }
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let skip = Ok(CompiledRegex::skip());
+
+    // We're only testing bytes::Regex here, which supports one pattern only.
+    let pattern = match test.regexes().len() {
+        1 => &test.regexes()[0],
+        _ => return skip,
+    };
+    // We only test is_match, find_iter and captures_iter. All of those are
+    // leftmost searches.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Leftmost) {
+        return skip;
+    }
+    // The top-level single-pattern regex API always uses leftmost-first.
+    if !matches!(test.match_kind(), regex_test::MatchKind::LeftmostFirst) {
+        return skip;
+    }
+    // The top-level regex API always runs unanchored searches. ... But we can
+    // handle tests that are anchored but have only one match.
+    if test.anchored() && test.match_limit() != Some(1) {
+        return skip;
+    }
+    // We don't support tests with explicit search bounds. We could probably
+    // support this by using the 'find_at' (and such) APIs.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return skip;
+    }
+    // The bytes::Regex API specifically does not support enabling UTF-8 mode.
+    // It could I suppose, but currently it does not. That is, it permits
+    // matches to have offsets that split codepoints.
+    if test.utf8() {
+        return skip;
+    }
+    // If the test requires Unicode but the Unicode feature isn't enabled,
+    // skip it. This is a little aggressive, but the test suite doesn't
+    // have any easy way of communicating which Unicode features are needed.
+    if test.unicode() && !cfg!(feature = "unicode") {
+        return skip;
+    }
+    let re = RegexBuilder::new(pattern)
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .line_terminator(test.line_terminator())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
+
+/// Convert `Captures` into the test suite's capture values.
+fn testify_captures(
+    caps: &regex::bytes::Captures<'_>,
+) -> regex_test::Captures {
+    let spans = caps.iter().map(|group| {
+        group.map(|m| regex_test::Span { start: m.start(), end: m.end() })
+    });
+    // This unwrap is OK because we assume our 'caps' represents a match, and
+    // a match always gives a non-zero number of groups with the first group
+    // being non-None.
+    regex_test::Captures::new(0, spans).unwrap()
+}
diff --git a/tests/suite_bytes_set.rs b/tests/suite_bytes_set.rs
new file mode 100644
index 0000000000..899d24c17e
--- /dev/null
+++ b/tests/suite_bytes_set.rs
@@ -0,0 +1,71 @@
+use {
+    anyhow::Result,
+    regex::bytes::{RegexSet, RegexSetBuilder},
+    regex_test::{CompiledRegex, RegexTest, TestResult, TestRunner},
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "which"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &RegexSet, test: &RegexTest) -> TestResult {
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(test.haystack())),
+        "which" => TestResult::which(re.matches(test.haystack()).iter()),
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let skip = Ok(CompiledRegex::skip());
+
+    // The top-level RegexSet API only supports "overlapping" semantics.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Overlapping) {
+        return skip;
+    }
+    // The top-level RegexSet API only supports "all" semantics.
+    if !matches!(test.match_kind(), regex_test::MatchKind::All) {
+        return skip;
+    }
+    // The top-level RegexSet API always runs unanchored searches.
+    if test.anchored() {
+        return skip;
+    }
+    // We don't support tests with explicit search bounds.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return skip;
+    }
+    // The bytes::Regex API specifically does not support enabling UTF-8 mode.
+    // It could I suppose, but currently it does not. That is, it permits
+    // matches to have offsets that split codepoints.
+    if test.utf8() {
+        return skip;
+    }
+    // If the test requires Unicode but the Unicode feature isn't enabled,
+    // skip it. This is a little aggressive, but the test suite doesn't
+    // have any easy way of communicating which Unicode features are needed.
+    if test.unicode() && !cfg!(feature = "unicode") {
+        return skip;
+    }
+    let re = RegexSetBuilder::new(test.regexes())
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .line_terminator(test.line_terminator())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
diff --git a/tests/suite_string.rs b/tests/suite_string.rs
new file mode 100644
index 0000000000..1e5bf0bb3b
--- /dev/null
+++ b/tests/suite_string.rs
@@ -0,0 +1,114 @@
+use {
+    anyhow::Result,
+    regex::{Regex, RegexBuilder},
+    regex_test::{
+        CompiledRegex, Match, RegexTest, Span, TestResult, TestRunner,
+    },
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+    let hay = match std::str::from_utf8(test.haystack()) {
+        Ok(hay) => hay,
+        Err(err) => {
+            return TestResult::fail(&format!(
+                "haystack is not valid UTF-8: {}",
+                err
+            ));
+        }
+    };
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(hay)),
+        "find" => TestResult::matches(
+            re.find_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|m| Match {
+                    id: 0,
+                    span: Span { start: m.start(), end: m.end() },
+                }),
+        ),
+        "captures" => {
+            let it = re
+                .captures_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|caps| testify_captures(&caps));
+            TestResult::captures(it)
+        }
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let skip = Ok(CompiledRegex::skip());
+
+    // We're only testing bytes::Regex here, which supports one pattern only.
+    let pattern = match test.regexes().len() {
+        1 => &test.regexes()[0],
+        _ => return skip,
+    };
+    // We only test is_match, find_iter and captures_iter. All of those are
+    // leftmost searches.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Leftmost) {
+        return skip;
+    }
+    // The top-level single-pattern regex API always uses leftmost-first.
+    if !matches!(test.match_kind(), regex_test::MatchKind::LeftmostFirst) {
+        return skip;
+    }
+    // The top-level regex API always runs unanchored searches. ... But we can
+    // handle tests that are anchored but have only one match.
+    if test.anchored() && test.match_limit() != Some(1) {
+        return skip;
+    }
+    // We don't support tests with explicit search bounds. We could probably
+    // support this by using the 'find_at' (and such) APIs.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return skip;
+    }
+    // The Regex API specifically does not support disabling UTF-8 mode because
+    // it can only search &str which is always valid UTF-8.
+    if !test.utf8() {
+        return skip;
+    }
+    // If the test requires Unicode but the Unicode feature isn't enabled,
+    // skip it. This is a little aggressive, but the test suite doesn't
+    // have any easy way of communicating which Unicode features are needed.
+    if test.unicode() && !cfg!(feature = "unicode") {
+        return skip;
+    }
+    let re = RegexBuilder::new(pattern)
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .line_terminator(test.line_terminator())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
+
+/// Convert `Captures` into the test suite's capture values.
+fn testify_captures(caps: &regex::Captures<'_>) -> regex_test::Captures {
+    let spans = caps.iter().map(|group| {
+        group.map(|m| regex_test::Span { start: m.start(), end: m.end() })
+    });
+    // This unwrap is OK because we assume our 'caps' represents a match, and
+    // a match always gives a non-zero number of groups with the first group
+    // being non-None.
+    regex_test::Captures::new(0, spans).unwrap()
+}
diff --git a/tests/suite_string_set.rs b/tests/suite_string_set.rs
new file mode 100644
index 0000000000..dffdc70810
--- /dev/null
+++ b/tests/suite_string_set.rs
@@ -0,0 +1,79 @@
+use {
+    anyhow::Result,
+    regex::{RegexSet, RegexSetBuilder},
+    regex_test::{CompiledRegex, RegexTest, TestResult, TestRunner},
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "which"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &RegexSet, test: &RegexTest) -> TestResult {
+    let hay = match std::str::from_utf8(test.haystack()) {
+        Ok(hay) => hay,
+        Err(err) => {
+            return TestResult::fail(&format!(
+                "haystack is not valid UTF-8: {}",
+                err
+            ));
+        }
+    };
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(hay)),
+        "which" => TestResult::which(re.matches(hay).iter()),
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let skip = Ok(CompiledRegex::skip());
+
+    // The top-level RegexSet API only supports "overlapping" semantics.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Overlapping) {
+        return skip;
+    }
+    // The top-level RegexSet API only supports "all" semantics.
+    if !matches!(test.match_kind(), regex_test::MatchKind::All) {
+        return skip;
+    }
+    // The top-level RegexSet API always runs unanchored searches.
+    if test.anchored() {
+        return skip;
+    }
+    // We don't support tests with explicit search bounds.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return skip;
+    }
+    // The Regex API specifically does not support disabling UTF-8 mode because
+    // it can only search &str which is always valid UTF-8.
+    if !test.utf8() {
+        return skip;
+    }
+    // If the test requires Unicode but the Unicode feature isn't enabled,
+    // skip it. This is a little aggressive, but the test suite doesn't
+    // have any easy way of communicating which Unicode features are needed.
+    if test.unicode() && !cfg!(feature = "unicode") {
+        return skip;
+    }
+    let re = RegexSetBuilder::new(test.regexes())
+        .case_insensitive(test.case_insensitive())
+        .unicode(test.unicode())
+        .line_terminator(test.line_terminator())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
diff --git a/tests/test_backtrack.rs b/tests/test_backtrack.rs
deleted file mode 100644
index fb934e2d8f..0000000000
--- a/tests/test_backtrack.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![cfg_attr(feature = "pattern", feature(pattern))]
-
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re)
-            .bounded_backtracking()
-            .build()
-            .map(|e| e.into_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re)
-            .bounded_backtracking()
-            .build()
-            .map(|e| e.into_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_str.rs");
-include!("macros.rs");
-
-mod api;
-mod api_str;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod searcher;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/test_backtrack_bytes.rs b/tests/test_backtrack_bytes.rs
deleted file mode 100644
index a59426c949..0000000000
--- a/tests/test_backtrack_bytes.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re)
-            .bounded_backtracking()
-            .only_utf8(false)
-            .build()
-            .map(|e| e.into_byte_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re)
-            .bounded_backtracking()
-            .only_utf8(false)
-            .build()
-            .map(|e| e.into_byte_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_bytes.rs");
-include!("macros.rs");
-
-mod api;
-mod bytes;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_ascii;
diff --git a/tests/test_backtrack_utf8bytes.rs b/tests/test_backtrack_utf8bytes.rs
deleted file mode 100644
index 6d308e9e1c..0000000000
--- a/tests/test_backtrack_utf8bytes.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-#![cfg_attr(feature = "pattern", feature(pattern))]
-
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re)
-            .bounded_backtracking()
-            .bytes(true)
-            .build()
-            .map(|e| e.into_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re)
-            .bounded_backtracking()
-            .bytes(true)
-            .build()
-            .map(|e| e.into_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_str.rs");
-include!("macros.rs");
-
-mod api;
-mod api_str;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod searcher;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/test_crates_regex.rs b/tests/test_crates_regex.rs
deleted file mode 100644
index a681604727..0000000000
--- a/tests/test_crates_regex.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * This test is a minimal version of <rofl_0> and <subdiff_0>
- *
- * Once this bug gets fixed, uncomment rofl_0 and subdiff_0
- * (in `tests/crates_regex.rs`).
-#[test]
-fn word_boundary_backtracking_default_mismatch() {
-    use regex::internal::ExecBuilder;
-
-    let backtrack_re = ExecBuilder::new(r"\b")
-        .bounded_backtracking()
-        .build()
-        .map(|exec| exec.into_regex())
-        .map_err(|err| format!("{}", err))
-        .unwrap();
-
-    let default_re = ExecBuilder::new(r"\b")
-        .build()
-        .map(|exec| exec.into_regex())
-        .map_err(|err| format!("{}", err))
-        .unwrap();
-
-    let input = "䅅\\u{a0}";
-
-    let fi1 = backtrack_re.find_iter(input);
-    let fi2 = default_re.find_iter(input);
-    for (m1, m2) in fi1.zip(fi2) {
-        assert_eq!(m1, m2);
-    }
-}
-*/
-
-mod consistent;
-
-mod crates_regex {
-
-    macro_rules! consistent {
-        ($test_name:ident, $regex_src:expr) => {
-            #[test]
-            fn $test_name() {
-                use super::consistent::backends_are_consistent;
-
-                if option_env!("RUST_REGEX_RANDOM_TEST").is_some() {
-                    match backends_are_consistent($regex_src) {
-                        Ok(_) => {}
-                        Err(err) => panic!("{}", err),
-                    }
-                }
-            }
-        };
-    }
-
-    include!("crates_regex.rs");
-}
diff --git a/tests/test_default.rs b/tests/test_default.rs
deleted file mode 100644
index 19a319af11..0000000000
--- a/tests/test_default.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-#![cfg_attr(feature = "pattern", feature(pattern))]
-
-use regex;
-
-// Due to macro scoping rules, this definition only applies for the modules
-// defined below. Effectively, it allows us to use the same tests for both
-// native and dynamic regexes.
-//
-// This is also used to test the various matching engines. This one exercises
-// the normal code path which automatically chooses the engine based on the
-// regex and the input. Other dynamic tests explicitly set the engine to use.
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::Regex;
-        Regex::new($re)
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::RegexSet;
-        RegexSet::new($re)
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_str.rs");
-include!("macros.rs");
-
-mod api;
-mod api_str;
-mod crazy;
-mod flags;
-mod fowler;
-mod misc;
-mod multiline;
-mod noparse;
-mod regression;
-mod regression_fuzz;
-mod replace;
-mod searcher;
-mod set;
-mod shortest_match;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
-
-#[test]
-fn disallow_non_utf8() {
-    assert!(regex::Regex::new(r"(?-u)\xFF").is_err());
-    assert!(regex::Regex::new(r"(?-u).").is_err());
-    assert!(regex::Regex::new(r"(?-u)[\xFF]").is_err());
-    assert!(regex::Regex::new(r"(?-u)☃").is_err());
-}
-
-#[test]
-fn disallow_octal() {
-    assert!(regex::Regex::new(r"\0").is_err());
-}
-
-#[test]
-fn allow_octal() {
-    assert!(regex::RegexBuilder::new(r"\0").octal(true).build().is_ok());
-}
-
-#[test]
-fn oibits() {
-    use regex::bytes;
-    use regex::{Regex, RegexBuilder, RegexSet, RegexSetBuilder};
-    use std::panic::{RefUnwindSafe, UnwindSafe};
-
-    fn assert_send<T: Send>() {}
-    fn assert_sync<T: Sync>() {}
-    fn assert_unwind_safe<T: UnwindSafe>() {}
-    fn assert_ref_unwind_safe<T: RefUnwindSafe>() {}
-
-    assert_send::<Regex>();
-    assert_sync::<Regex>();
-    assert_unwind_safe::<Regex>();
-    assert_ref_unwind_safe::<Regex>();
-    assert_send::<RegexBuilder>();
-    assert_sync::<RegexBuilder>();
-    assert_unwind_safe::<RegexBuilder>();
-    assert_ref_unwind_safe::<RegexBuilder>();
-
-    assert_send::<bytes::Regex>();
-    assert_sync::<bytes::Regex>();
-    assert_unwind_safe::<bytes::Regex>();
-    assert_ref_unwind_safe::<bytes::Regex>();
-    assert_send::<bytes::RegexBuilder>();
-    assert_sync::<bytes::RegexBuilder>();
-    assert_unwind_safe::<bytes::RegexBuilder>();
-    assert_ref_unwind_safe::<bytes::RegexBuilder>();
-
-    assert_send::<RegexSet>();
-    assert_sync::<RegexSet>();
-    assert_unwind_safe::<RegexSet>();
-    assert_ref_unwind_safe::<RegexSet>();
-    assert_send::<RegexSetBuilder>();
-    assert_sync::<RegexSetBuilder>();
-    assert_unwind_safe::<RegexSetBuilder>();
-    assert_ref_unwind_safe::<RegexSetBuilder>();
-
-    assert_send::<bytes::RegexSet>();
-    assert_sync::<bytes::RegexSet>();
-    assert_unwind_safe::<bytes::RegexSet>();
-    assert_ref_unwind_safe::<bytes::RegexSet>();
-    assert_send::<bytes::RegexSetBuilder>();
-    assert_sync::<bytes::RegexSetBuilder>();
-    assert_unwind_safe::<bytes::RegexSetBuilder>();
-    assert_ref_unwind_safe::<bytes::RegexSetBuilder>();
-}
-
-// See: https://github.com/rust-lang/regex/issues/568
-#[test]
-fn oibits_regression() {
-    use regex::Regex;
-    use std::panic;
-
-    let _ = panic::catch_unwind(|| Regex::new("a").unwrap());
-}
-
-// See: https://github.com/rust-lang/regex/issues/750
-#[test]
-#[cfg(target_pointer_width = "64")]
-fn regex_is_reasonably_small() {
-    use std::mem::size_of;
-
-    use regex::bytes;
-    use regex::{Regex, RegexSet};
-
-    assert_eq!(16, size_of::<Regex>());
-    assert_eq!(16, size_of::<RegexSet>());
-    assert_eq!(16, size_of::<bytes::Regex>());
-    assert_eq!(16, size_of::<bytes::RegexSet>());
-}
-
-// See: https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8
-// See: CVE-2022-24713
-//
-// We test that our regex compiler will correctly return a "too big" error when
-// we try to use a very large repetition on an *empty* sub-expression.
-//
-// At the time this test was written, the regex compiler does not represent
-// empty sub-expressions with any bytecode instructions. In effect, it's an
-// "optimization" to leave them out, since they would otherwise correspond
-// to an unconditional JUMP in the regex bytecode (i.e., an unconditional
-// epsilon transition in the NFA graph). Therefore, an empty sub-expression
-// represents an interesting case for the compiler's size limits. Since it
-// doesn't actually contribute any additional memory to the compiled regex
-// instructions, the size limit machinery never detects it. Instead, it just
-// dumbly tries to compile the empty sub-expression N times, where N is the
-// repetition size.
-//
-// When N is very large, this will cause the compiler to essentially spin and
-// do nothing for a decently large amount of time. It causes the regex to take
-// quite a bit of time to compile, despite the concrete syntax of the regex
-// being quite small.
-//
-// The degree to which this is actually a problem is somewhat of a judgment
-// call. Some regexes simply take a long time to compile. But in general, you
-// should be able to reasonably control this by setting lower or higher size
-// limits on the compiled object size. But this mitigation doesn't work at all
-// for this case.
-//
-// This particular test is somewhat narrow. It merely checks that regex
-// compilation will, at some point, return a "too big" error. Before the
-// fix landed, this test would eventually fail because the regex would be
-// successfully compiled (after enough time elapsed). So while this test
-// doesn't check that we exit in a reasonable amount of time, it does at least
-// check that we are properly returning an error at some point.
-#[test]
-fn big_empty_regex_fails() {
-    use regex::Regex;
-
-    let result = Regex::new("(?:){4294967295}");
-    assert!(result.is_err());
-}
-
-// Below is a "billion laughs" variant of the previous test case.
-#[test]
-fn big_empty_reps_chain_regex_fails() {
-    use regex::Regex;
-
-    let result = Regex::new("(?:){64}{64}{64}{64}{64}{64}");
-    assert!(result.is_err());
-}
-
-// Below is another situation where a zero-length sub-expression can be
-// introduced.
-#[test]
-fn big_zero_reps_regex_fails() {
-    use regex::Regex;
-
-    let result = Regex::new(r"x{0}{4294967295}");
-    assert!(result.is_err());
-}
-
-// Testing another case for completeness.
-#[test]
-fn empty_alt_regex_fails() {
-    use regex::Regex;
-
-    let result = Regex::new(r"(?:|){4294967295}");
-    assert!(result.is_err());
-}
-
-// Regression test for: https://github.com/rust-lang/regex/issues/969
-#[test]
-fn regression_i969() {
-    use regex::Regex;
-
-    let re = Regex::new(r"c.*d\z").unwrap();
-    assert_eq!(Some(6), re.shortest_match_at("ababcd", 4));
-    assert_eq!(Some(6), re.find_at("ababcd", 4).map(|m| m.end()));
-}
diff --git a/tests/test_default_bytes.rs b/tests/test_default_bytes.rs
deleted file mode 100644
index f200596ba1..0000000000
--- a/tests/test_default_bytes.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::bytes::Regex;
-        Regex::new($re)
-    }};
-}
-
-macro_rules! regex_set_new {
-    ($res:expr) => {{
-        use regex::bytes::RegexSet;
-        RegexSet::new($res)
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_bytes.rs");
-include!("macros.rs");
-
-// A silly wrapper to make it possible to write and match raw bytes.
-struct R<'a>(&'a [u8]);
-impl<'a> R<'a> {
-    fn as_bytes(&self) -> &'a [u8] {
-        self.0
-    }
-}
-
-// See: https://github.com/rust-lang/regex/issues/321
-//
-// These tests are here because they do not have the same behavior in every
-// regex engine.
-mat!(invalid_utf8_nfa1, r".", R(b"\xD4\xC2\x65\x2B\x0E\xFE"), Some((2, 3)));
-mat!(invalid_utf8_nfa2, r"${2}ä", R(b"\xD4\xC2\x65\x2B\x0E\xFE"), None);
-mat!(
-    invalid_utf8_nfa3,
-    r".",
-    R(b"\x0A\xDB\x82\x6E\x33\x01\xDD\x33\xCD"),
-    Some((1, 3))
-);
-mat!(
-    invalid_utf8_nfa4,
-    r"${2}ä",
-    R(b"\x0A\xDB\x82\x6E\x33\x01\xDD\x33\xCD"),
-    None
-);
-
-mod api;
-mod bytes;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod set;
-mod shortest_match;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/test_nfa.rs b/tests/test_nfa.rs
deleted file mode 100644
index e5a67d180a..0000000000
--- a/tests/test_nfa.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![cfg_attr(feature = "pattern", feature(pattern))]
-
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re).nfa().build().map(|e| e.into_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re).nfa().build().map(|e| e.into_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_str.rs");
-include!("macros.rs");
-
-mod api;
-mod api_str;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod searcher;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/test_nfa_bytes.rs b/tests/test_nfa_bytes.rs
deleted file mode 100644
index 0a10e032a2..0000000000
--- a/tests/test_nfa_bytes.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re)
-            .nfa()
-            .only_utf8(false)
-            .build()
-            .map(|e| e.into_byte_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re)
-            .nfa()
-            .only_utf8(false)
-            .build()
-            .map(|e| e.into_byte_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_bytes.rs");
-include!("macros.rs");
-
-mod api;
-mod bytes;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/test_nfa_utf8bytes.rs b/tests/test_nfa_utf8bytes.rs
deleted file mode 100644
index 36a572b5fc..0000000000
--- a/tests/test_nfa_utf8bytes.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![cfg_attr(feature = "pattern", feature(pattern))]
-
-macro_rules! regex_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new($re).nfa().bytes(true).build().map(|e| e.into_regex())
-    }};
-}
-
-macro_rules! regex {
-    ($re:expr) => {
-        regex_new!($re).unwrap()
-    };
-}
-
-macro_rules! regex_set_new {
-    ($re:expr) => {{
-        use regex::internal::ExecBuilder;
-        ExecBuilder::new_many($re)
-            .nfa()
-            .bytes(true)
-            .build()
-            .map(|e| e.into_regex_set())
-    }};
-}
-
-macro_rules! regex_set {
-    ($res:expr) => {
-        regex_set_new!($res).unwrap()
-    };
-}
-
-// Must come before other module definitions.
-include!("macros_str.rs");
-include!("macros.rs");
-
-mod api;
-mod api_str;
-mod crazy;
-mod flags;
-mod fowler;
-mod multiline;
-mod noparse;
-mod regression;
-mod replace;
-mod searcher;
-mod set;
-mod suffix_reverse;
-#[cfg(feature = "unicode")]
-mod unicode;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary;
-#[cfg(feature = "unicode-perl")]
-mod word_boundary_unicode;
diff --git a/tests/unicode.rs b/tests/unicode.rs
deleted file mode 100644
index d7dbdd31b8..0000000000
--- a/tests/unicode.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-mat!(uni_literal, r"☃", "☃", Some((0, 3)));
-mat!(uni_literal_plus, r"☃+", "☃", Some((0, 3)));
-mat!(uni_literal_casei_plus, r"(?i)☃+", "☃", Some((0, 3)));
-mat!(uni_class_plus, r"[☃Ⅰ]+", "☃", Some((0, 3)));
-mat!(uni_one, r"\pN", "Ⅰ", Some((0, 3)));
-mat!(uni_mixed, r"\pN+", "Ⅰ1Ⅱ2", Some((0, 8)));
-mat!(uni_not, r"\PN+", "abⅠ", Some((0, 2)));
-mat!(uni_not_class, r"[\PN]+", "abⅠ", Some((0, 2)));
-mat!(uni_not_class_neg, r"[^\PN]+", "abⅠ", Some((2, 5)));
-mat!(uni_case, r"(?i)Δ", "δ", Some((0, 2)));
-mat!(uni_case_upper, r"\p{Lu}+", "ΛΘΓΔα", Some((0, 8)));
-mat!(uni_case_upper_nocase_flag, r"(?i)\p{Lu}+", "ΛΘΓΔα", Some((0, 10)));
-mat!(uni_case_upper_nocase, r"\p{L}+", "ΛΘΓΔα", Some((0, 10)));
-mat!(uni_case_lower, r"\p{Ll}+", "ΛΘΓΔα", Some((8, 10)));
-
-// Test the Unicode friendliness of Perl character classes.
-mat!(uni_perl_w, r"\w+", "dδd", Some((0, 4)));
-mat!(uni_perl_w_not, r"\w+", "⥡", None);
-mat!(uni_perl_w_neg, r"\W+", "⥡", Some((0, 3)));
-mat!(uni_perl_d, r"\d+", "1२३9", Some((0, 8)));
-mat!(uni_perl_d_not, r"\d+", "Ⅱ", None);
-mat!(uni_perl_d_neg, r"\D+", "Ⅱ", Some((0, 3)));
-mat!(uni_perl_s, r"\s+", " ", Some((0, 3)));
-mat!(uni_perl_s_not, r"\s+", "☃", None);
-mat!(uni_perl_s_neg, r"\S+", "☃", Some((0, 3)));
-
-// And do the same for word boundaries.
-mat!(uni_boundary_none, r"\d\b", "6δ", None);
-mat!(uni_boundary_ogham, r"\d\b", "6 ", Some((0, 1)));
-mat!(uni_not_boundary_none, r"\d\B", "6δ", Some((0, 1)));
-mat!(uni_not_boundary_ogham, r"\d\B", "6 ", None);
-
-// Test general categories.
-//
-// We should test more, but there's a lot. Write a script to generate more of
-// these tests.
-mat!(uni_class_gencat_cased_letter, r"\p{Cased_Letter}", "Ａ", Some((0, 3)));
-mat!(uni_class_gencat_cased_letter2, r"\p{gc=LC}", "Ａ", Some((0, 3)));
-mat!(uni_class_gencat_cased_letter3, r"\p{LC}", "Ａ", Some((0, 3)));
-mat!(
-    uni_class_gencat_close_punctuation,
-    r"\p{Close_Punctuation}",
-    "❯",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_connector_punctuation,
-    r"\p{Connector_Punctuation}",
-    "⁀",
-    Some((0, 3))
-);
-mat!(uni_class_gencat_control, r"\p{Control}", "\u{9f}", Some((0, 2)));
-mat!(
-    uni_class_gencat_currency_symbol,
-    r"\p{Currency_Symbol}",
-    "￡",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_dash_punctuation,
-    r"\p{Dash_Punctuation}",
-    "〰",
-    Some((0, 3))
-);
-mat!(uni_class_gencat_decimal_numer, r"\p{Decimal_Number}", "𑓙", Some((0, 4)));
-mat!(
-    uni_class_gencat_enclosing_mark,
-    r"\p{Enclosing_Mark}",
-    "\u{A672}",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_final_punctuation,
-    r"\p{Final_Punctuation}",
-    "⸡",
-    Some((0, 3))
-);
-mat!(uni_class_gencat_format, r"\p{Format}", "\u{E007F}", Some((0, 4)));
-// See: https://github.com/rust-lang/regex/issues/719
-mat!(uni_class_gencat_format_abbrev1, r"\p{cf}", "\u{E007F}", Some((0, 4)));
-mat!(uni_class_gencat_format_abbrev2, r"\p{gc=cf}", "\u{E007F}", Some((0, 4)));
-mat!(uni_class_gencat_format_abbrev3, r"\p{Sc}", "$", Some((0, 1)));
-mat!(
-    uni_class_gencat_initial_punctuation,
-    r"\p{Initial_Punctuation}",
-    "⸜",
-    Some((0, 3))
-);
-mat!(uni_class_gencat_letter, r"\p{Letter}", "Έ", Some((0, 2)));
-mat!(uni_class_gencat_letter_number, r"\p{Letter_Number}", "ↂ", Some((0, 3)));
-mat!(
-    uni_class_gencat_line_separator,
-    r"\p{Line_Separator}",
-    "\u{2028}",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_lowercase_letter,
-    r"\p{Lowercase_Letter}",
-    "ϛ",
-    Some((0, 2))
-);
-mat!(uni_class_gencat_mark, r"\p{Mark}", "\u{E01EF}", Some((0, 4)));
-mat!(uni_class_gencat_math, r"\p{Math}", "⋿", Some((0, 3)));
-mat!(
-    uni_class_gencat_modifier_letter,
-    r"\p{Modifier_Letter}",
-    "𖭃",
-    Some((0, 4))
-);
-mat!(
-    uni_class_gencat_modifier_symbol,
-    r"\p{Modifier_Symbol}",
-    "🏿",
-    Some((0, 4))
-);
-mat!(
-    uni_class_gencat_nonspacing_mark,
-    r"\p{Nonspacing_Mark}",
-    "\u{1E94A}",
-    Some((0, 4))
-);
-mat!(uni_class_gencat_number, r"\p{Number}", "⓿", Some((0, 3)));
-mat!(
-    uni_class_gencat_open_punctuation,
-    r"\p{Open_Punctuation}",
-    "｟",
-    Some((0, 3))
-);
-mat!(uni_class_gencat_other, r"\p{Other}", "\u{bc9}", Some((0, 3)));
-mat!(uni_class_gencat_other_letter, r"\p{Other_Letter}", "ꓷ", Some((0, 3)));
-mat!(uni_class_gencat_other_number, r"\p{Other_Number}", "㉏", Some((0, 3)));
-mat!(
-    uni_class_gencat_other_punctuation,
-    r"\p{Other_Punctuation}",
-    "𞥞",
-    Some((0, 4))
-);
-mat!(uni_class_gencat_other_symbol, r"\p{Other_Symbol}", "⅌", Some((0, 3)));
-mat!(
-    uni_class_gencat_paragraph_separator,
-    r"\p{Paragraph_Separator}",
-    "\u{2029}",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_private_use,
-    r"\p{Private_Use}",
-    "\u{10FFFD}",
-    Some((0, 4))
-);
-mat!(uni_class_gencat_punctuation, r"\p{Punctuation}", "𑁍", Some((0, 4)));
-mat!(uni_class_gencat_separator, r"\p{Separator}", "\u{3000}", Some((0, 3)));
-mat!(
-    uni_class_gencat_space_separator,
-    r"\p{Space_Separator}",
-    "\u{205F}",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_spacing_mark,
-    r"\p{Spacing_Mark}",
-    "\u{16F7E}",
-    Some((0, 4))
-);
-mat!(uni_class_gencat_symbol, r"\p{Symbol}", "⯈", Some((0, 3)));
-mat!(
-    uni_class_gencat_titlecase_letter,
-    r"\p{Titlecase_Letter}",
-    "ῼ",
-    Some((0, 3))
-);
-mat!(
-    uni_class_gencat_unassigned,
-    r"\p{Unassigned}",
-    "\u{10FFFF}",
-    Some((0, 4))
-);
-mat!(
-    uni_class_gencat_uppercase_letter,
-    r"\p{Uppercase_Letter}",
-    "Ꝋ",
-    Some((0, 3))
-);
-
-// Test a smattering of properties.
-mat!(uni_class_prop_emoji1, r"\p{Emoji}", "\u{23E9}", Some((0, 3)));
-mat!(uni_class_prop_emoji2, r"\p{emoji}", "\u{1F21A}", Some((0, 4)));
-mat!(
-    uni_class_prop_picto1,
-    r"\p{extendedpictographic}",
-    "\u{1FA6E}",
-    Some((0, 4))
-);
-mat!(
-    uni_class_prop_picto2,
-    r"\p{extendedpictographic}",
-    "\u{1FFFD}",
-    Some((0, 4))
-);
-
-// grapheme_cluster_break
-mat!(
-    uni_class_gcb_prepend,
-    r"\p{grapheme_cluster_break=prepend}",
-    "\u{11D46}",
-    Some((0, 4))
-);
-mat!(
-    uni_class_gcb_ri1,
-    r"\p{gcb=regional_indicator}",
-    "\u{1F1E6}",
-    Some((0, 4))
-);
-mat!(uni_class_gcb_ri2, r"\p{gcb=ri}", "\u{1F1E7}", Some((0, 4)));
-mat!(
-    uni_class_gcb_ri3,
-    r"\p{gcb=regionalindicator}",
-    "\u{1F1FF}",
-    Some((0, 4))
-);
-mat!(uni_class_gcb_lvt, r"\p{gcb=lvt}", "\u{C989}", Some((0, 3)));
-mat!(uni_class_gcb_zwj, r"\p{gcb=zwj}", "\u{200D}", Some((0, 3)));
-
-// word_break
-mat!(uni_class_wb1, r"\p{word_break=Hebrew_Letter}", "\u{FB46}", Some((0, 3)));
-mat!(uni_class_wb2, r"\p{wb=hebrewletter}", "\u{FB46}", Some((0, 3)));
-mat!(uni_class_wb3, r"\p{wb=ExtendNumLet}", "\u{FF3F}", Some((0, 3)));
-mat!(uni_class_wb4, r"\p{wb=WSegSpace}", "\u{3000}", Some((0, 3)));
-mat!(uni_class_wb5, r"\p{wb=numeric}", "\u{1E950}", Some((0, 4)));
-
-// sentence_break
-mat!(uni_class_sb1, r"\p{sentence_break=Lower}", "\u{0469}", Some((0, 2)));
-mat!(uni_class_sb2, r"\p{sb=lower}", "\u{0469}", Some((0, 2)));
-mat!(uni_class_sb3, r"\p{sb=Close}", "\u{FF60}", Some((0, 3)));
-mat!(uni_class_sb4, r"\p{sb=Close}", "\u{1F677}", Some((0, 4)));
-mat!(uni_class_sb5, r"\p{sb=SContinue}", "\u{FF64}", Some((0, 3)));
-
-// Test 'Vithkuqi' support, which was added in Unicode 14.
-// See: https://github.com/rust-lang/regex/issues/877
-mat!(
-    uni_vithkuqi_literal_upper,
-    r"(?i)^\u{10570}$",
-    "\u{10570}",
-    Some((0, 4))
-);
-mat!(
-    uni_vithkuqi_literal_lower,
-    r"(?i)^\u{10570}$",
-    "\u{10597}",
-    Some((0, 4))
-);
-mat!(uni_vithkuqi_word_upper, r"^\w$", "\u{10570}", Some((0, 4)));
-mat!(uni_vithkuqi_word_lower, r"^\w$", "\u{10597}", Some((0, 4)));
diff --git a/tests/word_boundary.rs b/tests/word_boundary.rs
deleted file mode 100644
index 7fe97a2974..0000000000
--- a/tests/word_boundary.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Many of these are cribbed from RE2's test suite.
-
-matiter!(wb1, r"\b", "");
-matiter!(wb2, r"\b", "a", (0, 0), (1, 1));
-matiter!(wb3, r"\b", "ab", (0, 0), (2, 2));
-matiter!(wb4, r"^\b", "ab", (0, 0));
-matiter!(wb5, r"\b$", "ab", (2, 2));
-matiter!(wb6, r"^\b$", "ab");
-matiter!(wb7, r"\bbar\b", "nobar bar foo bar", (6, 9), (14, 17));
-matiter!(wb8, r"a\b", "faoa x", (3, 4));
-matiter!(wb9, r"\bbar", "bar x", (0, 3));
-matiter!(wb10, r"\bbar", "foo\nbar x", (4, 7));
-matiter!(wb11, r"bar\b", "foobar", (3, 6));
-matiter!(wb12, r"bar\b", "foobar\nxxx", (3, 6));
-matiter!(wb13, r"(foo|bar|[A-Z])\b", "foo", (0, 3));
-matiter!(wb14, r"(foo|bar|[A-Z])\b", "foo\n", (0, 3));
-matiter!(wb15, r"\b(foo|bar|[A-Z])", "foo", (0, 3));
-matiter!(wb16, r"\b(foo|bar|[A-Z])\b", "X", (0, 1));
-matiter!(wb17, r"\b(foo|bar|[A-Z])\b", "XY");
-matiter!(wb18, r"\b(foo|bar|[A-Z])\b", "bar", (0, 3));
-matiter!(wb19, r"\b(foo|bar|[A-Z])\b", "foo", (0, 3));
-matiter!(wb20, r"\b(foo|bar|[A-Z])\b", "foo\n", (0, 3));
-matiter!(wb21, r"\b(foo|bar|[A-Z])\b", "ffoo bbar N x", (10, 11));
-matiter!(wb22, r"\b(fo|foo)\b", "fo", (0, 2));
-matiter!(wb23, r"\b(fo|foo)\b", "foo", (0, 3));
-matiter!(wb24, r"\b\b", "");
-matiter!(wb25, r"\b\b", "a", (0, 0), (1, 1));
-matiter!(wb26, r"\b$", "");
-matiter!(wb27, r"\b$", "x", (1, 1));
-matiter!(wb28, r"\b$", "y x", (3, 3));
-matiter!(wb29, r"\b.$", "x", (0, 1));
-matiter!(wb30, r"^\b(fo|foo)\b", "fo", (0, 2));
-matiter!(wb31, r"^\b(fo|foo)\b", "foo", (0, 3));
-matiter!(wb32, r"^\b$", "");
-matiter!(wb33, r"^\b$", "x");
-matiter!(wb34, r"^\b.$", "x", (0, 1));
-matiter!(wb35, r"^\b.\b$", "x", (0, 1));
-matiter!(wb36, r"^^^^^\b$$$$$", "");
-matiter!(wb37, r"^^^^^\b.$$$$$", "x", (0, 1));
-matiter!(wb38, r"^^^^^\b$$$$$", "x");
-matiter!(wb39, r"^^^^^\b\b\b.\b\b\b$$$$$", "x", (0, 1));
-matiter!(wb40, r"\b.+\b", "$$abc$$", (2, 5));
-matiter!(wb41, r"\b", "a b c", (0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5));
-
-matiter!(nb1, r"\Bfoo\B", "n foo xfoox that", (7, 10));
-matiter!(nb2, r"a\B", "faoa x", (1, 2));
-matiter!(nb3, r"\Bbar", "bar x");
-matiter!(nb4, r"\Bbar", "foo\nbar x");
-matiter!(nb5, r"bar\B", "foobar");
-matiter!(nb6, r"bar\B", "foobar\nxxx");
-matiter!(nb7, r"(foo|bar|[A-Z])\B", "foox", (0, 3));
-matiter!(nb8, r"(foo|bar|[A-Z])\B", "foo\n");
-matiter!(nb9, r"\B", "", (0, 0));
-matiter!(nb10, r"\B", "x");
-matiter!(nb11, r"\B(foo|bar|[A-Z])", "foo");
-matiter!(nb12, r"\B(foo|bar|[A-Z])\B", "xXy", (1, 2));
-matiter!(nb13, r"\B(foo|bar|[A-Z])\B", "XY");
-matiter!(nb14, r"\B(foo|bar|[A-Z])\B", "XYZ", (1, 2));
-matiter!(nb15, r"\B(foo|bar|[A-Z])\B", "abara", (1, 4));
-matiter!(nb16, r"\B(foo|bar|[A-Z])\B", "xfoo_", (1, 4));
-matiter!(nb17, r"\B(foo|bar|[A-Z])\B", "xfoo\n");
-matiter!(nb18, r"\B(foo|bar|[A-Z])\B", "foo bar vNX", (9, 10));
-matiter!(nb19, r"\B(fo|foo)\B", "xfoo", (1, 3));
-matiter!(nb20, r"\B(foo|fo)\B", "xfooo", (1, 4));
-matiter!(nb21, r"\B\B", "", (0, 0));
-matiter!(nb22, r"\B\B", "x");
-matiter!(nb23, r"\B$", "", (0, 0));
-matiter!(nb24, r"\B$", "x");
-matiter!(nb25, r"\B$", "y x");
-matiter!(nb26, r"\B.$", "x");
-matiter!(nb27, r"^\B(fo|foo)\B", "fo");
-matiter!(nb28, r"^\B(fo|foo)\B", "foo");
-matiter!(nb29, r"^\B", "", (0, 0));
-matiter!(nb30, r"^\B", "x");
-matiter!(nb31, r"^\B\B", "", (0, 0));
-matiter!(nb32, r"^\B\B", "x");
-matiter!(nb33, r"^\B$", "", (0, 0));
-matiter!(nb34, r"^\B$", "x");
-matiter!(nb35, r"^\B.$", "x");
-matiter!(nb36, r"^\B.\B$", "x");
-matiter!(nb37, r"^^^^^\B$$$$$", "", (0, 0));
-matiter!(nb38, r"^^^^^\B.$$$$$", "x");
-matiter!(nb39, r"^^^^^\B$$$$$", "x");
-
-// These work for both Unicode and ASCII because all matches are reported as
-// byte offsets, and « and » do not correspond to word boundaries at either
-// the character or byte level.
-matiter!(unicode1, r"\bx\b", "«x", (2, 3));
-matiter!(unicode2, r"\bx\b", "x»", (0, 1));
diff --git a/tests/word_boundary_ascii.rs b/tests/word_boundary_ascii.rs
deleted file mode 100644
index 5a3cf1166c..0000000000
--- a/tests/word_boundary_ascii.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// ASCII word boundaries are completely oblivious to Unicode characters.
-// For Unicode word boundaries, the tests are precisely inverted.
-matiter!(ascii1, r"(?-u:\b)x(?-u:\b)", "áxβ", (2, 3));
-matiter!(ascii2, r"(?-u:\B)x(?-u:\B)", "áxβ");
-matiter!(ascii3, r"(?-u:\B)", "0\u{7EF5E}", (2, 2), (3, 3), (4, 4), (5, 5));
-
-// We still get Unicode word boundaries by default in byte regexes.
-matiter!(unicode1, r"\bx\b", "áxβ");
-matiter!(unicode2, r"\Bx\B", "áxβ", (2, 3));
diff --git a/tests/word_boundary_unicode.rs b/tests/word_boundary_unicode.rs
deleted file mode 100644
index c41355ffc4..0000000000
--- a/tests/word_boundary_unicode.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-// Unicode word boundaries know about Unicode characters.
-// For ASCII word boundaries, the tests are precisely inverted.
-matiter!(unicode1, r"\bx\b", "áxβ");
-matiter!(unicode2, r"\Bx\B", "áxβ", (2, 3));
-
-matiter!(ascii1, r"(?-u:\b)x(?-u:\b)", "áxβ", (2, 3));